コード例 #1
0
            public bool StructureDoesntMatch(ExposedList <Attachment> attachments, ExposedList <SubmeshInstruction> instructions)
            {
                if (attachments.Count != this.attachmentsUsed.Count)
                {
                    return(true);
                }
                if (instructions.Count != this.instructionsUsed.Count)
                {
                    return(true);
                }
                Attachment[] items  = attachments.Items;
                Attachment[] items2 = this.attachmentsUsed.Items;
                int          i      = 0;
                int          count  = this.attachmentsUsed.Count;

                while (i < count)
                {
                    if (items[i] != items2[i])
                    {
                        return(true);
                    }
                    i++;
                }
                SubmeshInstruction[] items3 = instructions.Items;
                SubmeshInstruction[] items4 = this.instructionsUsed.Items;
                int j      = 0;
                int count2 = this.instructionsUsed.Count;

                while (j < count2)
                {
                    SubmeshInstruction submeshInstruction  = items3[j];
                    SubmeshInstruction submeshInstruction2 = items4[j];
                    if (submeshInstruction.material.GetInstanceID() != submeshInstruction2.material.GetInstanceID() || submeshInstruction.startSlot != submeshInstruction2.startSlot || submeshInstruction.endSlot != submeshInstruction2.endSlot || submeshInstruction.triangleCount != submeshInstruction2.triangleCount || submeshInstruction.vertexCount != submeshInstruction2.vertexCount || submeshInstruction.firstVertexIndex != submeshInstruction2.firstVertexIndex)
                    {
                        return(true);
                    }
                    j++;
                }
                return(false);
            }
コード例 #2
0
		public static bool EnsureTriangleBuffersSize (ExposedList<SubmeshTriangleBuffer> submeshBuffers, int targetSubmeshCount, SubmeshInstruction[] instructionItems) {
			bool submeshBuffersWasResized = submeshBuffers.Count < targetSubmeshCount;
			if (submeshBuffersWasResized) {
				submeshBuffers.GrowIfNeeded(targetSubmeshCount - submeshBuffers.Count);
				for (int i = submeshBuffers.Count; submeshBuffers.Count < targetSubmeshCount; i++)
					submeshBuffers.Add(new SubmeshTriangleBuffer(instructionItems[i].triangleCount));
			}
			return submeshBuffersWasResized;
		}
コード例 #3
0
        void SetSubmesh(int submeshIndex, Spine.Unity.MeshGeneration.SubmeshInstruction submeshInstructions, ExposedList <bool> flipStates, bool isLastSubmesh)
        {
            var currentSubmesh = submeshes.Items[submeshIndex];

            int[] triangles = currentSubmesh.triangles;

            int triangleCount = submeshInstructions.triangleCount;
            int firstVertex   = submeshInstructions.firstVertexIndex;

            int trianglesCapacity = triangles.Length;

            if (isLastSubmesh && trianglesCapacity > triangleCount)
            {
                // Last submesh may have more triangles than required, so zero triangles to the end.
                for (int i = triangleCount; i < trianglesCapacity; i++)
                {
                    triangles[i] = 0;
                }

                currentSubmesh.triangleCount = triangleCount;
            }
            else if (trianglesCapacity != triangleCount)
            {
                // Reallocate triangles when not the exact size needed.
                currentSubmesh.triangles     = triangles = new int[triangleCount];
                currentSubmesh.triangleCount = 0;
            }

            if (!this.renderMeshes && !this.frontFacing)
            {
                // Use stored triangles if possible.
                if (currentSubmesh.firstVertex != firstVertex || currentSubmesh.triangleCount < triangleCount)                   //|| currentSubmesh.triangleCount == 0
                {
                    currentSubmesh.triangleCount = triangleCount;
                    currentSubmesh.firstVertex   = firstVertex;

                    for (int i = 0; i < triangleCount; i += 6, firstVertex += 4)
                    {
                        triangles[i]     = firstVertex;
                        triangles[i + 1] = firstVertex + 2;
                        triangles[i + 2] = firstVertex + 1;
                        triangles[i + 3] = firstVertex + 2;
                        triangles[i + 4] = firstVertex + 3;
                        triangles[i + 5] = firstVertex + 1;
                    }
                }
                return;
            }

            var flipStatesItems = flipStates.Items;

            // Iterate through all slots and store their triangles.
            var drawOrderItems = skeleton.DrawOrder.Items;
            int triangleIndex  = 0;            // Modified by loop

            for (int i = submeshInstructions.startSlot, n = submeshInstructions.endSlot; i < n; i++)
            {
                Attachment attachment = drawOrderItems[i].attachment;
                bool       flip       = frontFacing && flipStatesItems[i];

                // Add RegionAttachment triangles
                if (attachment is RegionAttachment)
                {
                    if (!flip)
                    {
                        triangles[triangleIndex]     = firstVertex;
                        triangles[triangleIndex + 1] = firstVertex + 2;
                        triangles[triangleIndex + 2] = firstVertex + 1;
                        triangles[triangleIndex + 3] = firstVertex + 2;
                        triangles[triangleIndex + 4] = firstVertex + 3;
                        triangles[triangleIndex + 5] = firstVertex + 1;
                    }
                    else
                    {
                        triangles[triangleIndex]     = firstVertex + 1;
                        triangles[triangleIndex + 1] = firstVertex + 2;
                        triangles[triangleIndex + 2] = firstVertex;
                        triangles[triangleIndex + 3] = firstVertex + 1;
                        triangles[triangleIndex + 4] = firstVertex + 3;
                        triangles[triangleIndex + 5] = firstVertex + 2;
                    }

                    triangleIndex += 6;
                    firstVertex   += 4;
                    continue;
                }

                // Add (Weighted)MeshAttachment triangles
                int[] attachmentTriangles;
                int   attachmentVertexCount;
                var   meshAttachment = attachment as MeshAttachment;
                if (meshAttachment != null)
                {
                    attachmentVertexCount = meshAttachment.worldVerticesLength >> 1;                     // length/2
                    attachmentTriangles   = meshAttachment.triangles;
                }
                else
                {
                    continue;
                }

                if (flip)
                {
                    for (int ii = 0, nn = attachmentTriangles.Length; ii < nn; ii += 3, triangleIndex += 3)
                    {
                        triangles[triangleIndex + 2] = firstVertex + attachmentTriangles[ii];
                        triangles[triangleIndex + 1] = firstVertex + attachmentTriangles[ii + 1];
                        triangles[triangleIndex]     = firstVertex + attachmentTriangles[ii + 2];
                    }
                }
                else
                {
                    for (int ii = 0, nn = attachmentTriangles.Length; ii < nn; ii++, triangleIndex++)
                    {
                        triangles[triangleIndex] = firstVertex + attachmentTriangles[ii];
                    }
                }

                firstVertex += attachmentVertexCount;
            }
        }
コード例 #4
0
        void SetSubmesh(int submeshIndex, Spine.Unity.MeshGeneration.SubmeshInstruction submeshInstructions, ExposedList <bool> flipStates, bool isLastSubmesh)
        {
                #else
        void SetSubmesh(int submeshIndex, Spine.Unity.MeshGeneration.SubmeshInstruction submeshInstructions, bool isLastSubmesh)
        {
                #endif
            SubmeshTriangleBuffer currentSubmesh = submeshes.Items[submeshIndex];
            int[] triangles = currentSubmesh.triangles;

            int triangleCount = submeshInstructions.triangleCount;
            int firstVertex   = submeshInstructions.firstVertexIndex;

            int trianglesCapacity = triangles.Length;
            if (isLastSubmesh && trianglesCapacity > triangleCount)
            {
                // Last submesh may have more triangles than required, so zero triangles to the end.
                for (int i = triangleCount; i < trianglesCapacity; i++)
                {
                    triangles[i] = 0;
                }

                currentSubmesh.triangleCount = triangleCount;
            }
            else if (trianglesCapacity != triangleCount)
            {
                // Reallocate triangles when not the exact size needed.
                currentSubmesh.triangles     = triangles = new int[triangleCount];
                currentSubmesh.triangleCount = 0;
            }

                        #if SPINE_OPTIONAL_FRONTFACING
            if (!this.renderMeshes && !this.frontFacing)
            {
                        #else
            if (!this.renderMeshes)
            {
                        #endif
                // Use stored triangles if possible.
                if (currentSubmesh.firstVertex != firstVertex || currentSubmesh.triangleCount < triangleCount)                   //|| currentSubmesh.triangleCount == 0
                {
                    currentSubmesh.triangleCount = triangleCount;
                    currentSubmesh.firstVertex   = firstVertex;

                    for (int i = 0; i < triangleCount; i += 6, firstVertex += 4)
                    {
                        triangles[i]     = firstVertex;
                        triangles[i + 1] = firstVertex + 2;
                        triangles[i + 2] = firstVertex + 1;
                        triangles[i + 3] = firstVertex + 2;
                        triangles[i + 4] = firstVertex + 3;
                        triangles[i + 5] = firstVertex + 1;
                    }
                }
                return;
            }

            // This method caches several .Items arrays.
            // Never mutate their overlying ExposedList objects.

                        #if SPINE_OPTIONAL_FRONTFACING
            var flipStatesItems = flipStates.Items;
                        #endif

            // Iterate through all slots and store their triangles.
            var drawOrderItems = skeleton.DrawOrder.Items;
            int triangleIndex  = 0;            // Modified by loop
            for (int i = submeshInstructions.startSlot, n = submeshInstructions.endSlot; i < n; i++)
            {
                Attachment attachment = drawOrderItems[i].attachment;
                                #if SPINE_OPTIONAL_FRONTFACING
                bool flip = frontFacing && flipStatesItems[i];

                // Add RegionAttachment triangles
                if (attachment is RegionAttachment)
                {
                    if (!flip)
                    {
                        triangles[triangleIndex]     = firstVertex;
                        triangles[triangleIndex + 1] = firstVertex + 2;
                        triangles[triangleIndex + 2] = firstVertex + 1;
                        triangles[triangleIndex + 3] = firstVertex + 2;
                        triangles[triangleIndex + 4] = firstVertex + 3;
                        triangles[triangleIndex + 5] = firstVertex + 1;
                    }
                    else
                    {
                        triangles[triangleIndex]     = firstVertex + 1;
                        triangles[triangleIndex + 1] = firstVertex + 2;
                        triangles[triangleIndex + 2] = firstVertex;
                        triangles[triangleIndex + 3] = firstVertex + 1;
                        triangles[triangleIndex + 4] = firstVertex + 3;
                        triangles[triangleIndex + 5] = firstVertex + 2;
                    }

                    triangleIndex += 6;
                    firstVertex   += 4;
                    continue;
                }
                                #else
                if (attachment is RegionAttachment)
                {
                    triangles[triangleIndex]     = firstVertex;
                    triangles[triangleIndex + 1] = firstVertex + 2;
                    triangles[triangleIndex + 2] = firstVertex + 1;
                    triangles[triangleIndex + 3] = firstVertex + 2;
                    triangles[triangleIndex + 4] = firstVertex + 3;
                    triangles[triangleIndex + 5] = firstVertex + 1;

                    triangleIndex += 6;
                    firstVertex   += 4;
                    continue;
                }
                                #endif

                // Add (Weighted)MeshAttachment triangles
                int[] attachmentTriangles;
                int   attachmentVertexCount;
                var   meshAttachment = attachment as MeshAttachment;
                if (meshAttachment != null)
                {
                    attachmentVertexCount = meshAttachment.worldVerticesLength >> 1;                     // length/2
                    attachmentTriangles   = meshAttachment.triangles;
                }
                else
                {
                    continue;
                }

                                #if SPINE_OPTIONAL_FRONTFACING
                if (flip)
                {
                    for (int ii = 0, nn = attachmentTriangles.Length; ii < nn; ii += 3, triangleIndex += 3)
                    {
                        triangles[triangleIndex + 2] = firstVertex + attachmentTriangles[ii];
                        triangles[triangleIndex + 1] = firstVertex + attachmentTriangles[ii + 1];
                        triangles[triangleIndex]     = firstVertex + attachmentTriangles[ii + 2];
                    }
                }
                else
                {
                    for (int ii = 0, nn = attachmentTriangles.Length; ii < nn; ii++, triangleIndex++)
                    {
                        triangles[triangleIndex] = firstVertex + attachmentTriangles[ii];
                    }
                }
                                #else
                for (int ii = 0, nn = attachmentTriangles.Length; ii < nn; ii++, triangleIndex++)
                {
                    triangles[triangleIndex] = firstVertex + attachmentTriangles[ii];
                }
                                #endif

                firstVertex += attachmentVertexCount;
            }
        }

                #if UNITY_EDITOR
        void OnDrawGizmos()
        {
            // Make scene view selection easier by drawing a clear gizmo over the skeleton.
            meshFilter = GetComponent <MeshFilter>();
            if (meshFilter == null)
            {
                return;
            }

            Mesh mesh = meshFilter.sharedMesh;

            if (mesh == null)
            {
                return;
            }

            Bounds meshBounds = mesh.bounds;

            Gizmos.color  = Color.clear;
            Gizmos.matrix = transform.localToWorldMatrix;
            Gizmos.DrawCube(meshBounds.center, meshBounds.size);
        }
                #endif

        ///<summary>This is a Mesh that also stores the instructions SkeletonRenderer generated for it.</summary>
        public class SmartMesh {
コード例 #5
0
        public MeshAndMaterials GenerateMesh(ExposedList <SubmeshInstruction> instructions, int startSubmesh, int endSubmesh)
        {
            SubmeshInstruction[] items = instructions.Items;
            this.currentInstructions.Clear(false);
            for (int i = startSubmesh; i < endSubmesh; i++)
            {
                this.currentInstructions.Add(items[i]);
            }
            SmartMesh next  = this.doubleBufferedSmartMesh.GetNext();
            Mesh      mesh  = next.mesh;
            int       count = this.currentInstructions.Count;

            SubmeshInstruction[] items2 = this.currentInstructions.Items;
            int num = 0;

            for (int j = 0; j < count; j++)
            {
                items2[j].firstVertexIndex = num;
                num += items2[j].vertexCount;
            }
            bool    flag     = ArraysMeshGenerator.EnsureSize(num, ref this.meshVertices, ref this.meshUVs, ref this.meshColors32);
            bool    flag2    = ArraysMeshGenerator.EnsureTriangleBuffersSize(this.submeshBuffers, count, items2);
            float   zspacing = this.ZSpacing;
            Vector3 boundsMin;
            Vector3 boundsMax;

            if (num <= 0)
            {
                boundsMin = new Vector3(0f, 0f, 0f);
                boundsMax = new Vector3(0f, 0f, 0f);
            }
            else
            {
                boundsMin.x = 2.14748365E+09f;
                boundsMin.y = 2.14748365E+09f;
                boundsMax.x = -2.14748365E+09f;
                boundsMax.y = -2.14748365E+09f;
                int endSlot = items2[count - 1].endSlot;
                if (zspacing > 0f)
                {
                    boundsMin.z = 0f;
                    boundsMax.z = zspacing * (float)endSlot;
                }
                else
                {
                    boundsMin.z = zspacing * (float)endSlot;
                    boundsMax.z = 0f;
                }
            }
            ExposedList <Attachment> exposedList = this.attachmentBuffer;

            exposedList.Clear(false);
            int num2 = 0;

            for (int k = 0; k < count; k++)
            {
                SubmeshInstruction submeshInstruction = items2[k];
                int      startSlot = submeshInstruction.startSlot;
                int      endSlot2  = submeshInstruction.endSlot;
                Skeleton skeleton  = submeshInstruction.skeleton;
                Slot[]   items3    = skeleton.DrawOrder.Items;
                for (int l = startSlot; l < endSlot2; l++)
                {
                    Attachment attachment = items3[l].attachment;
                    if (attachment != null)
                    {
                        exposedList.Add(attachment);
                    }
                }
                ArraysMeshGenerator.FillVerts(skeleton, startSlot, endSlot2, zspacing, base.PremultiplyVertexColors, this.meshVertices, this.meshUVs, this.meshColors32, ref num2, ref this.attachmentVertexBuffer, ref boundsMin, ref boundsMax, true);
            }
            bool flag3 = flag || flag2 || next.StructureDoesntMatch(exposedList, this.currentInstructions);

            for (int m = 0; m < count; m++)
            {
                SubmeshInstruction submeshInstruction2 = items2[m];
                if (flag3)
                {
                    SubmeshTriangleBuffer submeshTriangleBuffer = this.submeshBuffers.Items[m];
                    bool isLastSubmesh = m == count - 1;
                    ArraysMeshGenerator.FillTriangles(ref submeshTriangleBuffer.triangles, submeshInstruction2.skeleton, submeshInstruction2.triangleCount, submeshInstruction2.firstVertexIndex, submeshInstruction2.startSlot, submeshInstruction2.endSlot, isLastSubmesh);
                    submeshTriangleBuffer.triangleCount = submeshInstruction2.triangleCount;
                    submeshTriangleBuffer.firstVertex   = submeshInstruction2.firstVertexIndex;
                }
            }
            if (flag3)
            {
                mesh.Clear();
                this.sharedMaterials = this.currentInstructions.GetUpdatedMaterialArray(this.sharedMaterials);
            }
            next.Set(this.meshVertices, this.meshUVs, this.meshColors32, exposedList, this.currentInstructions);
            mesh.bounds = ArraysMeshGenerator.ToBounds(boundsMin, boundsMax);
            if (flag3)
            {
                mesh.subMeshCount = count;
                for (int n = 0; n < count; n++)
                {
                    mesh.SetTriangles(this.submeshBuffers.Items[n].triangles, n);
                }
                base.TryAddNormalsTo(mesh, num);
            }
            if (this.addTangents)
            {
                ArraysMeshGenerator.SolveTangents2DEnsureSize(ref this.meshTangents, ref this.tempTanBuffer, num);
                int num3 = 0;
                int num4 = count;
                while (num3 < num4)
                {
                    SubmeshTriangleBuffer submeshTriangleBuffer2 = this.submeshBuffers.Items[num3];
                    ArraysMeshGenerator.SolveTangents2DTriangles(this.tempTanBuffer, submeshTriangleBuffer2.triangles, submeshTriangleBuffer2.triangleCount, this.meshVertices, this.meshUVs, num);
                    num3++;
                }
                ArraysMeshGenerator.SolveTangents2DBuffer(this.meshTangents, this.tempTanBuffer, num);
            }
            return(new MeshAndMaterials(next.mesh, this.sharedMaterials));
        }
コード例 #6
0
        public MeshAndMaterials GenerateMesh(SubmeshedMeshInstruction meshInstructions)
        {
            SmartMesh next  = this.doubleBufferedSmartMesh.GetNext();
            Mesh      mesh  = next.mesh;
            int       count = meshInstructions.submeshInstructions.Count;
            ExposedList <SubmeshInstruction> submeshInstructions = meshInstructions.submeshInstructions;
            int  vertexCount = meshInstructions.vertexCount;
            bool flag        = ArraysMeshGenerator.EnsureTriangleBuffersSize(this.submeshBuffers, count, submeshInstructions.Items);
            bool flag2       = ArraysMeshGenerator.EnsureSize(vertexCount, ref this.meshVertices, ref this.meshUVs, ref this.meshColors32);

            Vector3[] meshVertices = this.meshVertices;
            float     zspacing     = this.ZSpacing;
            int       count2       = meshInstructions.attachmentList.Count;
            Vector3   boundsMin;
            Vector3   boundsMax;

            if (count2 <= 0)
            {
                boundsMin = new Vector3(0f, 0f, 0f);
                boundsMax = new Vector3(0f, 0f, 0f);
            }
            else
            {
                boundsMin.x = 2.14748365E+09f;
                boundsMin.y = 2.14748365E+09f;
                boundsMax.x = -2.14748365E+09f;
                boundsMax.y = -2.14748365E+09f;
                if (zspacing > 0f)
                {
                    boundsMin.z = 0f;
                    boundsMax.z = zspacing * (float)(count2 - 1);
                }
                else
                {
                    boundsMin.z = zspacing * (float)(count2 - 1);
                    boundsMax.z = 0f;
                }
            }
            bool flag3 = flag2 || flag || next.StructureDoesntMatch(meshInstructions);
            int  num   = 0;

            for (int i = 0; i < count; i++)
            {
                SubmeshInstruction submeshInstruction = submeshInstructions.Items[i];
                int      startSlot = submeshInstruction.startSlot;
                int      endSlot   = submeshInstruction.endSlot;
                Skeleton skeleton  = submeshInstruction.skeleton;
                ArraysMeshGenerator.FillVerts(skeleton, startSlot, endSlot, zspacing, base.PremultiplyVertexColors, meshVertices, this.meshUVs, this.meshColors32, ref num, ref this.attachmentVertexBuffer, ref boundsMin, ref boundsMax, true);
                if (flag3)
                {
                    SubmeshTriangleBuffer submeshTriangleBuffer = this.submeshBuffers.Items[i];
                    bool isLastSubmesh = i == count - 1;
                    ArraysMeshGenerator.FillTriangles(ref submeshTriangleBuffer.triangles, skeleton, submeshInstruction.triangleCount, submeshInstruction.firstVertexIndex, startSlot, endSlot, isLastSubmesh);
                    submeshTriangleBuffer.triangleCount = submeshInstruction.triangleCount;
                    submeshTriangleBuffer.firstVertex   = submeshInstruction.firstVertexIndex;
                }
            }
            if (flag3)
            {
                mesh.Clear();
                this.sharedMaterials = meshInstructions.GetUpdatedMaterialArray(this.sharedMaterials);
            }
            next.Set(this.meshVertices, this.meshUVs, this.meshColors32, meshInstructions);
            mesh.bounds = ArraysMeshGenerator.ToBounds(boundsMin, boundsMax);
            if (flag3)
            {
                mesh.subMeshCount = count;
                for (int j = 0; j < count; j++)
                {
                    mesh.SetTriangles(this.submeshBuffers.Items[j].triangles, j);
                }
                base.TryAddNormalsTo(mesh, vertexCount);
            }
            if (this.addTangents)
            {
                ArraysMeshGenerator.SolveTangents2DEnsureSize(ref this.meshTangents, ref this.tempTanBuffer, vertexCount);
                int k    = 0;
                int num2 = count;
                while (k < num2)
                {
                    SubmeshTriangleBuffer submeshTriangleBuffer2 = this.submeshBuffers.Items[k];
                    ArraysMeshGenerator.SolveTangents2DTriangles(this.tempTanBuffer, submeshTriangleBuffer2.triangles, submeshTriangleBuffer2.triangleCount, this.meshVertices, this.meshUVs, vertexCount);
                    k++;
                }
                ArraysMeshGenerator.SolveTangents2DBuffer(this.meshTangents, this.tempTanBuffer, vertexCount);
            }
            return(new MeshAndMaterials(next.mesh, this.sharedMaterials));
        }