public void Set(Vector3[] verts, Vector2[] uvs, Color32[] colors, SubmeshedMeshInstruction instruction) { this.mesh.vertices = verts; this.mesh.uv = uvs; this.mesh.colors32 = colors; this.attachmentsUsed.Clear(false); this.attachmentsUsed.GrowIfNeeded(instruction.attachmentList.Capacity); this.attachmentsUsed.Count = instruction.attachmentList.Count; instruction.attachmentList.CopyTo(this.attachmentsUsed.Items); this.instructionsUsed.Clear(false); this.instructionsUsed.GrowIfNeeded(instruction.submeshInstructions.Capacity); this.instructionsUsed.Count = instruction.submeshInstructions.Count; instruction.submeshInstructions.CopyTo(this.instructionsUsed.Items); }
public bool StructureDoesntMatch(SubmeshedMeshInstruction instructions) { // Check count inequality. if (instructions.attachmentList.Count != this.attachmentsUsed.Count) { return(true); } if (instructions.submeshInstructions.Count != this.instructionsUsed.Count) { return(true); } // Check each attachment. var attachmentsPassed = instructions.attachmentList.Items; var myAttachments = this.attachmentsUsed.Items; for (int i = 0, n = attachmentsUsed.Count; i < n; i++) { if (attachmentsPassed[i] != myAttachments[i]) { return(true); } } // Check each submesh for equal arrangement. var instructionListItems = instructions.submeshInstructions.Items; var myInstructions = this.instructionsUsed.Items; for (int i = 0, n = this.instructionsUsed.Count; i < n; i++) { var lhs = instructionListItems[i]; var rhs = myInstructions[i]; if ( lhs.material.GetInstanceID() != rhs.material.GetInstanceID() || lhs.startSlot != rhs.startSlot || lhs.endSlot != rhs.endSlot || lhs.triangleCount != rhs.triangleCount || lhs.vertexCount != rhs.vertexCount || lhs.firstVertexIndex != rhs.firstVertexIndex ) { return(true); } } //Debug.Log("structure matched"); return(false); }
public bool StructureDoesntMatch(SubmeshedMeshInstruction instructions) { if (instructions.attachmentList.Count != this.attachmentsUsed.Count) { return(true); } if (instructions.submeshInstructions.Count != this.instructionsUsed.Count) { return(true); } Attachment[] items = instructions.attachmentList.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.submeshInstructions.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); }
// ISubmeshedMeshGenerator.GenerateMesh /// <summary>Generates a mesh based on SubmeshedMeshInstructions</summary> public MeshAndMaterials GenerateMesh(SubmeshedMeshInstruction meshInstructions) { var smartMesh = doubleBufferedSmartMesh.GetNext(); var mesh = smartMesh.mesh; int submeshCount = meshInstructions.submeshInstructions.Count; var instructionList = meshInstructions.submeshInstructions; // STEP 1: Ensure correct buffer sizes. int vertexCount = meshInstructions.vertexCount; bool submeshBuffersResized = ArraysMeshGenerator.EnsureTriangleBuffersSize(submeshBuffers, submeshCount, instructionList.Items); bool vertBufferResized = ArraysMeshGenerator.EnsureSize(vertexCount, ref this.meshVertices, ref this.meshUVs, ref this.meshColors32); Vector3[] vertices = this.meshVertices; // STEP 2: Update buffers based on Skeleton. float zSpacing = this.ZSpacing; Vector3 meshBoundsMin; Vector3 meshBoundsMax; int attachmentCount = meshInstructions.attachmentList.Count; if (attachmentCount <= 0) { meshBoundsMin = new Vector3(0, 0, 0); meshBoundsMax = new Vector3(0, 0, 0); } else { meshBoundsMin.x = int.MaxValue; meshBoundsMin.y = int.MaxValue; meshBoundsMax.x = int.MinValue; meshBoundsMax.y = int.MinValue; if (zSpacing > 0f) { meshBoundsMin.z = 0f; meshBoundsMax.z = zSpacing * (attachmentCount - 1); } else { meshBoundsMin.z = zSpacing * (attachmentCount - 1); meshBoundsMax.z = 0f; } } bool structureDoesntMatch = vertBufferResized || submeshBuffersResized || smartMesh.StructureDoesntMatch(meshInstructions); // For each submesh, add vertex data From attachments. Also triangles, but only if needed. int vertexIndex = 0; // modified by FillVerts for (int submeshIndex = 0; submeshIndex < submeshCount; submeshIndex++) { var submeshInstruction = instructionList.Items[submeshIndex]; int start = submeshInstruction.startSlot; int end = submeshInstruction.endSlot; var skeleton = submeshInstruction.skeleton; ArraysMeshGenerator.FillVerts(skeleton, start, end, zSpacing, this.PremultiplyVertexColors, vertices, this.meshUVs, this.meshColors32, ref vertexIndex, ref this.attachmentVertexBuffer, ref meshBoundsMin, ref meshBoundsMax); if (structureDoesntMatch) { var currentBuffer = submeshBuffers.Items[submeshIndex]; bool isLastSubmesh = (submeshIndex == submeshCount - 1); ArraysMeshGenerator.FillTriangles(ref currentBuffer.triangles, skeleton, submeshInstruction.triangleCount, submeshInstruction.firstVertexIndex, start, end, isLastSubmesh); currentBuffer.triangleCount = submeshInstruction.triangleCount; currentBuffer.firstVertex = submeshInstruction.firstVertexIndex; } } if (structureDoesntMatch) { mesh.Clear(); this.sharedMaterials = meshInstructions.GetUpdatedMaterialArray(this.sharedMaterials); } // STEP 3: Assign the buffers into the Mesh. smartMesh.Set(this.meshVertices, this.meshUVs, this.meshColors32, meshInstructions); mesh.bounds = ArraysMeshGenerator.ToBounds(meshBoundsMin, meshBoundsMax); if (structureDoesntMatch) { // Push new triangles if doesn't match. mesh.subMeshCount = submeshCount; for (int i = 0; i < submeshCount; i++) { mesh.SetTriangles(submeshBuffers.Items[i].triangles, i); } TryAddNormalsTo(mesh, vertexCount); } if (addTangents) { SolveTangents2DEnsureSize(ref this.meshTangents, ref this.tempTanBuffer, vertexCount); for (int i = 0, n = submeshCount; i < n; i++) { var submesh = submeshBuffers.Items[i]; SolveTangents2DTriangles(this.tempTanBuffer, submesh.triangles, submesh.triangleCount, meshVertices, meshUVs, vertexCount); } SolveTangents2DBuffer(this.meshTangents, this.tempTanBuffer, vertexCount); } return(new MeshAndMaterials(smartMesh.mesh, sharedMaterials)); }
public bool StructureDoesntMatch(SubmeshedMeshInstruction instructions) { // Check count inequality. if (instructions.attachmentList.Count != this.attachmentsUsed.Count) return true; if (instructions.submeshInstructions.Count != this.instructionsUsed.Count) return true; // Check each attachment. var attachmentsPassed = instructions.attachmentList.Items; var myAttachments = this.attachmentsUsed.Items; for (int i = 0, n = attachmentsUsed.Count; i < n; i++) if (attachmentsPassed[i] != myAttachments[i]) return true; // Check each submesh for equal arrangement. var instructionListItems = instructions.submeshInstructions.Items; var myInstructions = this.instructionsUsed.Items; for (int i = 0, n = this.instructionsUsed.Count; i < n; i++) { var lhs = instructionListItems[i]; var rhs = myInstructions[i]; if ( lhs.material.GetInstanceID() != rhs.material.GetInstanceID() || lhs.startSlot != rhs.startSlot || lhs.endSlot != rhs.endSlot || lhs.triangleCount != rhs.triangleCount || lhs.vertexCount != rhs.vertexCount || lhs.firstVertexIndex != rhs.firstVertexIndex ) return true; } //Debug.Log("structure matched"); return false; }
public void Set(Vector3[] verts, Vector2[] uvs, Color32[] colors, SubmeshedMeshInstruction instruction) { mesh.vertices = verts; mesh.uv = uvs; mesh.colors32 = colors; attachmentsUsed.Clear(false); attachmentsUsed.GrowIfNeeded(instruction.attachmentList.Capacity); attachmentsUsed.Count = instruction.attachmentList.Count; instruction.attachmentList.CopyTo(attachmentsUsed.Items); instructionsUsed.Clear(false); instructionsUsed.GrowIfNeeded(instruction.submeshInstructions.Capacity); instructionsUsed.Count = instruction.submeshInstructions.Count; instruction.submeshInstructions.CopyTo(instructionsUsed.Items); }
// ISubmeshedMeshGenerator.GenerateMesh /// <summary>Generates a mesh based on SubmeshedMeshInstructions</summary> public MeshAndMaterials GenerateMesh(SubmeshedMeshInstruction meshInstructions) { var smartMesh = doubleBufferedSmartMesh.GetNext(); var mesh = smartMesh.mesh; int submeshCount = meshInstructions.submeshInstructions.Count; var instructionList = meshInstructions.submeshInstructions; // STEP 1: Ensure correct buffer sizes. bool submeshBuffersResized = ArraysMeshGenerator.EnsureTriangleBuffersSize(submeshBuffers, submeshCount, instructionList.Items); bool vertBufferResized = ArraysMeshGenerator.EnsureSize(meshInstructions.vertexCount, ref this.meshVertices, ref this.meshUVs, ref this.meshColors32); Vector3[] vertices = this.meshVertices; // STEP 2: Update buffers based on Skeleton. float zSpacing = this.zSpacing; Vector3 meshBoundsMin; Vector3 meshBoundsMax; int attachmentCount = meshInstructions.attachmentList.Count; if (attachmentCount <= 0) { meshBoundsMin = new Vector3(0, 0, 0); meshBoundsMax = new Vector3(0, 0, 0); } else { meshBoundsMin.x = int.MaxValue; meshBoundsMin.y = int.MaxValue; meshBoundsMax.x = int.MinValue; meshBoundsMax.y = int.MinValue; if (zSpacing > 0f) { meshBoundsMin.z = 0f; meshBoundsMax.z = zSpacing * (attachmentCount - 1); } else { meshBoundsMin.z = zSpacing * (attachmentCount - 1); meshBoundsMax.z = 0f; } } bool structureDoesntMatch = vertBufferResized || submeshBuffersResized || smartMesh.StructureDoesntMatch(meshInstructions); // For each submesh, add vertex data from attachments. Also triangles, but only if needed. int vertexIndex = 0; // modified by FillVerts for (int submeshIndex = 0; submeshIndex < submeshCount; submeshIndex++) { var submeshInstruction = instructionList.Items[submeshIndex]; int start = submeshInstruction.startSlot; int end = submeshInstruction.endSlot; var skeleton = submeshInstruction.skeleton; ArraysMeshGenerator.FillVerts(skeleton, start, end, zSpacing, this.premultiplyVertexColors, vertices, this.meshUVs, this.meshColors32, ref vertexIndex, ref this.attachmentVertexBuffer, ref meshBoundsMin, ref meshBoundsMax); if (structureDoesntMatch) { var currentBuffer = submeshBuffers.Items[submeshIndex]; bool isLastSubmesh = (submeshIndex == submeshCount - 1); ArraysMeshGenerator.FillTriangles(skeleton, submeshInstruction.triangleCount, submeshInstruction.firstVertexIndex, start, end, ref currentBuffer.triangles, isLastSubmesh); } } if (structureDoesntMatch) { mesh.Clear(); this.sharedMaterials = meshInstructions.GetUpdatedMaterialArray(this.sharedMaterials); } // STEP 3: Assign the buffers into the Mesh. smartMesh.Set(this.meshVertices, this.meshUVs, this.meshColors32, meshInstructions); mesh.bounds = ArraysMeshGenerator.ToBounds(meshBoundsMin, meshBoundsMax); if (structureDoesntMatch) { // Push new triangles if doesn't match. mesh.subMeshCount = submeshCount; for (int i = 0; i < submeshCount; i++) mesh.SetTriangles(submeshBuffers.Items[i].triangles, i); #if SPINE_OPTIONAL_NORMALS if (generateNormals) { int vertexCount = meshInstructions.vertexCount; Vector3[] normals = new Vector3[vertexCount]; Vector3 normal = new Vector3(0, 0, -1); for (int i = 0; i < vertexCount; i++) normals[i] = normal; mesh.normals = normals; if (generateTangents) { Vector4[] tangents = new Vector4[vertexCount]; Vector4 tangent = new Vector4(1, 0, 0, -1); for (int i = 0; i < vertexCount; i++) tangents[i] = tangent; mesh.tangents = tangents; } } #endif } return new MeshAndMaterials(smartMesh.mesh, sharedMaterials); }
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)); }