public void GenerateVisualVertexBuffer() { visualVertexBuffer = new List <List <int> >(heVertices.Count); foreach (Oni.Vertex vertex in heVertices) { HashSet <int> set = new HashSet <int>(); Oni.HalfEdge startEdge = heHalfEdges[vertex.halfEdge]; Oni.HalfEdge edge = startEdge; do { edge = heHalfEdges[edge.pair]; switch (edge.indexInFace) { case 0: set.Add(heFaces[edge.face].visualVertex1); break; case 1: set.Add(heFaces[edge.face].visualVertex2); break; case 2: set.Add(heFaces[edge.face].visualVertex3); break; } edge = heHalfEdges[edge.nextHalfEdge]; } while (edge.index != startEdge.index); visualVertexBuffer.Add(new List <int>(set)); } }
public float GetFaceArea(Oni.Face face) { Oni.HalfEdge e1 = heHalfEdges[face.halfEdge]; Oni.HalfEdge e2 = heHalfEdges[e1.nextHalfEdge]; Oni.HalfEdge e3 = heHalfEdges[e2.nextHalfEdge]; return(Vector3.Cross(heVertices[e2.endVertex].position - heVertices[e1.endVertex].position, heVertices[e3.endVertex].position - heVertices[e1.endVertex].position).magnitude / 2.0f); }
public int[] GetFaceEdges(Oni.Face face) { Oni.HalfEdge e1 = heHalfEdges[face.halfEdge]; Oni.HalfEdge e2 = heHalfEdges[e1.nextHalfEdge]; Oni.HalfEdge e3 = heHalfEdges[e2.nextHalfEdge]; return(new int[] { e1.index, e2.index, e3.index }); }
public int GetHalfEdgeStartVertex(Oni.HalfEdge edge) { // In a border edge, get the ending vertex of the pair edge: if (edge.face == -1) { return(heHalfEdges[edge.pair].endVertex); } // In case of an interior edge, find the vertex by going around the face: return(heHalfEdges[heHalfEdges[edge.nextHalfEdge].nextHalfEdge].endVertex); }
public IEnumerable <Oni.Vertex> GetNeighbourVerticesEnumerator(Oni.Vertex vertex) { Oni.HalfEdge startEdge = heHalfEdges[vertex.halfEdge]; Oni.HalfEdge edge = startEdge; do { yield return(heVertices[edge.endVertex]); edge = heHalfEdges[edge.pair]; edge = heHalfEdges[edge.nextHalfEdge]; } while (edge.index != startEdge.index); }
/** * Returns true if the edge has been split in a vertex split operation. (as a result of tearing) */ public bool IsSplit(int halfEdgeIndex) { Oni.HalfEdge edge = heHalfEdges[halfEdgeIndex]; if (edge.pair < 0 || edge.face < 0) { return(false); } Oni.HalfEdge pair = heHalfEdges[edge.pair]; return(edge.endVertex != heHalfEdges[heHalfEdges[pair.nextHalfEdge].nextHalfEdge].endVertex || pair.endVertex != heHalfEdges[heHalfEdges[edge.nextHalfEdge].nextHalfEdge].endVertex); }
public IEnumerable <Oni.HalfEdge> GetNeighbourEdgesEnumerator(Oni.Vertex vertex) { Oni.HalfEdge startEdge = heHalfEdges[vertex.halfEdge]; Oni.HalfEdge edge = startEdge; do { edge = heHalfEdges[edge.pair]; yield return(edge); edge = heHalfEdges[edge.nextHalfEdge]; yield return(edge); } while (edge.index != startEdge.index); }
public IEnumerable <Oni.Face> GetNeighbourFacesEnumerator(Oni.Vertex vertex) { Oni.HalfEdge startEdge = heHalfEdges[vertex.halfEdge]; Oni.HalfEdge edge = startEdge; do { edge = heHalfEdges[edge.pair]; if (edge.face > -1) { yield return(heFaces[edge.face]); } edge = heHalfEdges[edge.nextHalfEdge]; } while (edge.index != startEdge.index); }
/** * Tears a cloth distance constraint, affecting both the physical representation of the cloth and its mesh. */ public void Tear(int constraintIndex) { if (topology == null) { return; } // don't allow splitting if there are no free particles left in the pool. if (usedParticles >= sharedMesh.vertexCount + pooledVertices) { return; } // get involved constraint batches: ObiDistanceConstraintBatch distanceBatch = (ObiDistanceConstraintBatch)DistanceConstraints.GetBatches()[0]; ObiBendConstraintBatch bendingBatch = (ObiBendConstraintBatch)BendingConstraints.GetBatches()[0]; // get particle indices at both ends of the constraint: int splitIndex = distanceBatch.springIndices[constraintIndex * 2]; int intactIndex = distanceBatch.springIndices[constraintIndex * 2 + 1]; // we will split the particle with higher mass, so swap them if needed. if (invMasses[splitIndex] > invMasses[intactIndex]) { int aux = splitIndex; splitIndex = intactIndex; intactIndex = aux; } // Calculate the splitting plane in local space: Vector3 v1 = transform.worldToLocalMatrix.MultiplyPoint3x4(solver.renderablePositions[particleIndices[splitIndex]]); Vector3 v2 = transform.worldToLocalMatrix.MultiplyPoint3x4(solver.renderablePositions[particleIndices[intactIndex]]); Vector3 normal = (v2 - v1).normalized; int numUpdatedHalfEdges = maxVertexValency; int[] updatedHalfEdges = new int[numUpdatedHalfEdges]; // Try to split the vertex at that particle. // If we cannot not split the higher mass particle, try the other one. If that fails too, we cannot tear this edge. if (invMasses[splitIndex] == 0 || !Oni.TearDeformableMeshAtVertex(deformableMesh, splitIndex, ref v1, ref normal, updatedHalfEdges, ref numUpdatedHalfEdges)) { // Try to split the other particle: int aux = splitIndex; splitIndex = intactIndex; intactIndex = aux; v1 = transform.worldToLocalMatrix.MultiplyPoint3x4(solver.renderablePositions[particleIndices[splitIndex]]); v2 = transform.worldToLocalMatrix.MultiplyPoint3x4(solver.renderablePositions[particleIndices[intactIndex]]); normal = (v2 - v1).normalized; if (invMasses[splitIndex] == 0 || !Oni.TearDeformableMeshAtVertex(deformableMesh, splitIndex, ref v1, ref normal, updatedHalfEdges, ref numUpdatedHalfEdges)) { return; } } // identify weak points around the cut: int weakPt1 = -1; int weakPt2 = -1; float weakestValue = float.MaxValue; float secondWeakestValue = float.MaxValue; foreach (Oni.Vertex v in topology.GetNeighbourVerticesEnumerator(topology.heVertices[splitIndex])) { Vector3 neighbour = transform.worldToLocalMatrix.MultiplyPoint3x4(solver.renderablePositions[particleIndices[v.index]]); float weakness = Mathf.Abs(Vector3.Dot(normal, (neighbour - v1).normalized)); if (weakness < weakestValue) { secondWeakestValue = weakestValue; weakestValue = weakness; weakPt2 = weakPt1; weakPt1 = v.index; } else if (weakness < secondWeakestValue) { secondWeakestValue = weakness; weakPt2 = v.index; } } // reduce tear resistance at the weak spots of the cut, to encourage coherent tear formation. if (weakPt1 >= 0) { tearResistance[weakPt1] *= 1 - tearDebilitation; } if (weakPt2 >= 0) { tearResistance[weakPt2] *= 1 - tearDebilitation; } topology.UpdateVertexCount(); // halve the mass and radius of the original particle: invMasses[splitIndex] *= 2; solidRadii[splitIndex] *= 0.5f; // copy the new particle data in the actor and solver arrays: positions[usedParticles] = positions[splitIndex]; velocities[usedParticles] = velocities[splitIndex]; active[usedParticles] = active[splitIndex]; invMasses[usedParticles] = invMasses[splitIndex]; solidRadii[usedParticles] = solidRadii[splitIndex]; phases[usedParticles] = phases[splitIndex]; areaContribution[usedParticles] = areaContribution[splitIndex]; tearResistance[usedParticles] = tearResistance[splitIndex]; restPositions[usedParticles] = positions[splitIndex]; restPositions[usedParticles][3] = 0; // activate rest position. solver.activeParticles.Add(particleIndices[usedParticles]); // update solver particle data: Vector4[] velocity = { Vector4.zero }; Oni.GetParticleVelocities(solver.OniSolver, velocity, 1, particleIndices[splitIndex]); Oni.SetParticleVelocities(solver.OniSolver, velocity, 1, particleIndices[usedParticles]); Vector4[] position = { Vector4.zero }; Oni.GetParticlePositions(solver.OniSolver, position, 1, particleIndices[splitIndex]); Oni.SetParticlePositions(solver.OniSolver, position, 1, particleIndices[usedParticles]); Oni.SetParticleInverseMasses(solver.OniSolver, new float[] { invMasses[splitIndex] }, 1, particleIndices[usedParticles]); Oni.SetParticleSolidRadii(solver.OniSolver, new float[] { solidRadii[splitIndex] }, 1, particleIndices[usedParticles]); Oni.SetParticlePhases(solver.OniSolver, new int[] { phases[splitIndex] }, 1, particleIndices[usedParticles]); usedParticles++; // update distance constraints: for (int i = 0; i < numUpdatedHalfEdges; ++i) { int halfEdgeIndex = updatedHalfEdges[i]; Oni.HalfEdge e = topology.heHalfEdges[halfEdgeIndex]; // find start and end vertex indices for this edge: int startVertex = topology.GetHalfEdgeStartVertex(topology.heHalfEdges[halfEdgeIndex]); int endVertex = topology.heHalfEdges[halfEdgeIndex].endVertex; if (distanceConstraintMap[halfEdgeIndex] > -1) // update existing edge { distanceBatch.springIndices[distanceConstraintMap[halfEdgeIndex] * 2] = startVertex; distanceBatch.springIndices[distanceConstraintMap[halfEdgeIndex] * 2 + 1] = endVertex; } else if (topology.IsSplit(halfEdgeIndex)) // new edge { int pairConstraintIndex = distanceConstraintMap[topology.heHalfEdges[halfEdgeIndex].pair]; // update constraint-edge map: distanceConstraintMap[halfEdgeIndex] = distanceBatch.restLengths.Count; // add the new constraint: distanceBatch.AddConstraint(startVertex, endVertex, distanceBatch.restLengths[pairConstraintIndex], distanceBatch.stiffnesses[pairConstraintIndex].x, distanceBatch.stiffnesses[pairConstraintIndex].y); } // update deformable triangles: if (e.indexInFace > -1) { deformableTriangles[e.face * 3 + e.indexInFace] = e.endVertex; } } if (splitIndex < bendConstraintOffsets.Length - 1) { // deactivate bend constraints that contain the split vertex... // ...at the center: for (int i = bendConstraintOffsets[splitIndex]; i < bendConstraintOffsets[splitIndex + 1]; ++i) { bendingBatch.DeactivateConstraint(i); } // ...at one end: foreach (Oni.Vertex v in topology.GetNeighbourVerticesEnumerator(topology.heVertices[splitIndex])) { if (v.index < bendConstraintOffsets.Length - 1) { for (int i = bendConstraintOffsets[v.index]; i < bendConstraintOffsets[v.index + 1]; ++i) { if (bendingBatch.bendingIndices[i * 3] == splitIndex || bendingBatch.bendingIndices[i * 3 + 1] == splitIndex) { bendingBatch.DeactivateConstraint(i); } } } } } // Create new aerodynamic constraint: /*aerodynamicConstraints.AddConstraint(true,newParticle[0], * Vector3.up, * aerodynamicConstraints.windVector, * areaContribution[newParticle[0]], * aerodynamicConstraints.dragCoefficient, * aerodynamicConstraints.liftCoefficient);*/ }
/** * Generates the particle based physical representation of the cloth mesh. This is the initialization method for the cloth object * and should not be called directly once the object has been created. */ public override IEnumerator GeneratePhysicRepresentationForMesh() { initialized = false; initializing = false; if (sharedTopology == null) { Debug.LogError("No ObiMeshTopology provided. Cannot initialize physical representation."); yield break; } else if (!sharedTopology.Initialized) { Debug.LogError("The provided ObiMeshTopology contains no data. Cannot initialize physical representation."); yield break; } initializing = true; RemoveFromSolver(null); ResetTopology(); maxVertexValency = 0; pooledParticles = (int)((topology.heFaces.Length * 3 - topology.heVertices.Length) * tearCapacity); usedParticles = topology.heVertices.Length; int totalParticles = usedParticles + pooledParticles; active = new bool[totalParticles]; positions = new Vector3[totalParticles]; restPositions = new Vector4[totalParticles]; velocities = new Vector3[totalParticles]; vorticities = new Vector3[totalParticles]; invMasses = new float[totalParticles]; solidRadii = new float[totalParticles]; phases = new int[totalParticles]; areaContribution = new float[totalParticles]; tearResistance = new float[totalParticles]; deformableTriangles = new int[topology.heFaces.Length * 3]; // Create a particle for each vertex, and gather per-vertex data (area, valency) for (int i = 0; i < topology.heVertices.Length; i++) { Oni.Vertex vertex = topology.heVertices[i]; // Get the particle's area contribution. areaContribution[i] = 0; foreach (Oni.Face face in topology.GetNeighbourFacesEnumerator(vertex)) { areaContribution[i] += topology.GetFaceArea(face) / 3; } // Calculate particle's valency: int valency = 0; foreach (Oni.HalfEdge edge in topology.GetNeighbourEdgesEnumerator(vertex)) { valency++; } maxVertexValency = Mathf.Max(maxVertexValency, valency); // Get the shortest neighbour edge, particle radius will be half of its length. float minEdgeLength = Single.MaxValue; foreach (Oni.HalfEdge edge in topology.GetNeighbourEdgesEnumerator(vertex)) { minEdgeLength = Mathf.Min(minEdgeLength, Vector3.Distance(topology.heVertices[topology.GetHalfEdgeStartVertex(edge)].position, topology.heVertices[edge.endVertex].position)); } active[i] = true; tearResistance[i] = 1; invMasses[i] = (areaContribution[i] > 0) ? (1.0f / (0.05f * areaContribution[i])) : 0; positions[i] = vertex.position; restPositions[i] = positions[i]; restPositions[i][3] = 0; // activate rest position. solidRadii[i] = minEdgeLength * 0.5f; phases[i] = Oni.MakePhase(gameObject.layer, selfCollisions?Oni.ParticlePhase.SelfCollide:0); if (i % 500 == 0) { yield return(new CoroutineJob.ProgressInfo("ObiCloth: generating particles...", i / (float)topology.heVertices.Length)); } } // Initialize basic data for pooled particles: for (int i = topology.heVertices.Length; i < pooledParticles; i++) { active[i] = false; tearResistance[i] = 1; invMasses[i] = 1.0f / 0.05f; solidRadii[i] = 0.1f; phases[i] = Oni.MakePhase(gameObject.layer, selfCollisions?Oni.ParticlePhase.SelfCollide:0); if (i % 100 == 0) { yield return(new CoroutineJob.ProgressInfo("ObiRope: generating pooled particles...", i / (float)pooledParticles)); } } // Generate deformable triangles: for (int i = 0; i < topology.heFaces.Length; i++) { Oni.Face face = topology.heFaces[i]; Oni.HalfEdge e1 = topology.heHalfEdges[face.halfEdge]; Oni.HalfEdge e2 = topology.heHalfEdges[e1.nextHalfEdge]; Oni.HalfEdge e3 = topology.heHalfEdges[e2.nextHalfEdge]; deformableTriangles[i * 3] = e1.endVertex; deformableTriangles[i * 3 + 1] = e2.endVertex; deformableTriangles[i * 3 + 2] = e3.endVertex; if (i % 500 == 0) { yield return(new CoroutineJob.ProgressInfo("ObiCloth: generating deformable geometry...", i / (float)topology.heFaces.Length)); } } List <ObiMeshTopology.HEEdge> edges = topology.GetEdgeList(); DistanceConstraints.Clear(); ObiDistanceConstraintBatch distanceBatch = new ObiDistanceConstraintBatch(false, false); DistanceConstraints.AddBatch(distanceBatch); // Initialize constraint-halfedge map for cloth tearing purposes: TODO: reset on awake!!! distanceConstraintMap = new int[topology.heHalfEdges.Length]; for (int i = 0; i < distanceConstraintMap.Length; i++) { distanceConstraintMap[i] = -1; } // Create distance springs: for (int i = 0; i < edges.Count; i++) { distanceConstraintMap[edges[i].halfEdgeIndex] = i; Oni.HalfEdge hedge = topology.heHalfEdges[edges[i].halfEdgeIndex]; Oni.Vertex startVertex = topology.heVertices[topology.GetHalfEdgeStartVertex(hedge)]; Oni.Vertex endVertex = topology.heVertices[hedge.endVertex]; distanceBatch.AddConstraint(topology.GetHalfEdgeStartVertex(hedge), hedge.endVertex, Vector3.Distance(startVertex.position, endVertex.position), 1, 1); if (i % 500 == 0) { yield return(new CoroutineJob.ProgressInfo("ObiCloth: generating structural constraints...", i / (float)topology.heHalfEdges.Length)); } } // Create aerodynamic constraints: AerodynamicConstraints.Clear(); ObiAerodynamicConstraintBatch aeroBatch = new ObiAerodynamicConstraintBatch(false, false); AerodynamicConstraints.AddBatch(aeroBatch); for (int i = 0; i < topology.heVertices.Length; i++) { aeroBatch.AddConstraint(i, areaContribution[i], AerodynamicConstraints.dragCoefficient, AerodynamicConstraints.liftCoefficient); if (i % 500 == 0) { yield return(new CoroutineJob.ProgressInfo("ObiCloth: generating aerodynamic constraints...", i / (float)topology.heFaces.Length)); } } BendingConstraints.Clear(); ObiBendConstraintBatch bendBatch = new ObiBendConstraintBatch(false, false); BendingConstraints.AddBatch(bendBatch); bendConstraintOffsets = new int[topology.heVertices.Length + 1]; Dictionary <int, int> cons = new Dictionary <int, int>(); for (int i = 0; i < topology.heVertices.Length; i++) { Oni.Vertex vertex = topology.heVertices[i]; bendConstraintOffsets[i] = bendBatch.ConstraintCount; foreach (Oni.Vertex n1 in topology.GetNeighbourVerticesEnumerator(vertex)) { float cosBest = 0; Oni.Vertex vBest = n1; foreach (Oni.Vertex n2 in topology.GetNeighbourVerticesEnumerator(vertex)) { float cos = Vector3.Dot((n1.position - vertex.position).normalized, (n2.position - vertex.position).normalized); if (cos < cosBest) { cosBest = cos; vBest = n2; } } if (!cons.ContainsKey(vBest.index) || cons[vBest.index] != n1.index) { cons[n1.index] = vBest.index; float[] restPos = new float[] { n1.position[0], n1.position[1], n1.position[2], vBest.position[0], vBest.position[1], vBest.position[2], vertex.position[0], vertex.position[1], vertex.position[2] }; float restBend = Oni.BendingConstraintRest(restPos); bendBatch.AddConstraint(n1.index, vBest.index, vertex.index, restBend, 0, 1); } } if (i % 500 == 0) { yield return(new CoroutineJob.ProgressInfo("ObiCloth: adding bend constraints...", i / (float)sharedTopology.heVertices.Length)); } } bendConstraintOffsets[topology.heVertices.Length] = bendBatch.ConstraintCount; //Initialize pin constraints: PinConstraints.Clear(); ObiPinConstraintBatch pinBatch = new ObiPinConstraintBatch(false, false); PinConstraints.AddBatch(pinBatch); AddToSolver(null); initializing = false; initialized = true; InitializeWithRegularMesh(); pooledVertices = (int)((topology.heFaces.Length * 3 - sharedMesh.vertexCount) * tearCapacity); }
/** * Calculates angle-weighted normals for the input mesh, taking into account shared vertices. */ /*public Vector3[] AngleWeightedNormals(){ * * if (input == null) return null; * * Vector3[] normals = input.normals; * Vector3[] vertices = input.vertices; * * for(int i = 0; i < normals.Length; i++) * normals[i] = Vector3.zero; * * int i1,i2,i3; * Vector3 e1, e2; * foreach(HEFace face in heFaces){ * * HEVertex hv1 = heVertices[heHalfEdges[face.edges[0]].endVertex]; * HEVertex hv2 = heVertices[heHalfEdges[face.edges[1]].endVertex]; * HEVertex hv3 = heVertices[heHalfEdges[face.edges[2]].endVertex]; * * i1 = hv1.physicalIDs[0]; * i2 = hv2.physicalIDs[0]; * i3 = hv3.physicalIDs[0]; * * e1 = vertices[i2]-vertices[i1]; * e2 = vertices[i3]-vertices[i1]; * foreach(int pi in hv1.physicalIDs) * normals[pi] += Vector3.Cross(e1,e2) * Mathf.Acos(Vector3.Dot(e1.normalized,e2.normalized)); * * e1 = vertices[i3]-vertices[i2]; * e2 = vertices[i1]-vertices[i2]; * foreach(int pi in hv2.physicalIDs) * normals[pi] += Vector3.Cross(e1,e2) * Mathf.Acos(Vector3.Dot(e1.normalized,e2.normalized)); * * e1 = vertices[i1]-vertices[i3]; * e2 = vertices[i2]-vertices[i3]; * foreach(int pi in hv3.physicalIDs) * normals[pi] += Vector3.Cross(e1,e2) * Mathf.Acos(Vector3.Dot(e1.normalized,e2.normalized)); * * } * * for(int i = 0; i < normals.Length; i++) * normals[i].Normalize(); * * return normals; * }*/ /** * Splits a vertex in two along a plane. Returns true if the vertex can be split, false otherwise. * \param vertex the vertex to split. * \param splitPlane plane to split the vertex at. * \param newVertex the newly created vertex after the split operation has been performed. * \param vertices new mesh vertices list after the split operation. * \param updatedEdges indices of half-edges that need some kind of constraint update. */ public bool SplitVertex(Oni.Vertex vertex, Plane splitPlane, MeshBuffer meshBuffer, Vector4[] positions, List <int> particleIndices, out Oni.Vertex newVertex, out HashSet <int> updatedEdges, out HashSet <int> addedEdges) { // initialize return values: updatedEdges = new HashSet <int>(); addedEdges = new HashSet <int>(); newVertex = new Oni.Vertex(); // initialize face lists for each side of the split plane. List <Oni.Face> side1Faces = new List <Oni.Face>(); List <Oni.Face> side2Faces = new List <Oni.Face>(); HashSet <int> side2Edges = new HashSet <int>(); // classify adjacent faces depending on which side of the cut plane they reside in: foreach (Oni.Face face in GetNeighbourFacesEnumerator(vertex)) { Oni.HalfEdge e1 = heHalfEdges[face.halfEdge]; Oni.HalfEdge e2 = heHalfEdges[e1.nextHalfEdge]; Oni.HalfEdge e3 = heHalfEdges[e2.nextHalfEdge]; // Skip this face if it doesnt contain the splitted vertex. // This can happen because edge pair links are not updated, and so a vertex in the cut stil "sees" // the faces at the other side like neighbour faces. if (e1.endVertex != vertex.index && e2.endVertex != vertex.index && e3.endVertex != vertex.index) { continue; } // Average positions to get the center of the face: Vector3 faceCenter = (positions[particleIndices[e1.endVertex]] + positions[particleIndices[e2.endVertex]] + positions[particleIndices[e3.endVertex]]) / 3.0f; if (splitPlane.GetSide(faceCenter)) { side1Faces.Add(face); } else { side2Faces.Add(face); side2Edges.Add(e1.index); side2Edges.Add(e2.index); side2Edges.Add(e3.index); } } // If the vertex cant be split, return false. if (side1Faces.Count == 0 || side2Faces.Count == 0) { return(false); } // create a new vertex: newVertex = new Oni.Vertex(vertex.position, heVertices.Count, vertex.halfEdge); // add a new vertex to the mesh too, if needed. if (meshBuffer != null) { visualVertexBuffer.Add(new List <int>() { meshBuffer.vertexCount }); meshBuffer.AddVertex(visualVertexBuffer[vertex.index][0]); } // rearrange edges at side 1: foreach (Oni.Face face in side1Faces) { // find half edges that start or end at the split vertex: int[] faceEdges = GetFaceEdges(face); Oni.HalfEdge edgeIn = heHalfEdges[Array.Find <int>(faceEdges, e => heHalfEdges[e].endVertex == vertex.index)]; Oni.HalfEdge edgeOut = heHalfEdges[Array.Find <int>(faceEdges, e => this.GetHalfEdgeStartVertex(heHalfEdges[e]) == vertex.index)]; // Edges whose pair is on the other side of the cut and share the same vertices, will spawn a new constraint. if (side2Edges.Contains(edgeIn.pair) && GetHalfEdgeStartVertex(edgeIn) == heHalfEdges[edgeIn.pair].endVertex) { addedEdges.Add(Mathf.Max(edgeIn.index, edgeIn.pair)); } if (side2Edges.Contains(edgeOut.pair) && GetHalfEdgeStartVertex(heHalfEdges[edgeOut.pair]) == edgeOut.endVertex) { addedEdges.Add(Mathf.Max(edgeOut.index, edgeOut.pair)); } // Constraints for these edges should be updated. (There's no guarantee the constraint exists!). updatedEdges.Add(edgeIn.index); updatedEdges.Add(edgeIn.pair); updatedEdges.Add(edgeOut.index); updatedEdges.Add(edgeOut.pair); // stitch in half edge to new vertex edgeIn.endVertex = newVertex.index; newVertex.halfEdge = edgeOut.index; heHalfEdges[edgeIn.index] = edgeIn; heHalfEdges[edgeOut.index] = edgeOut; // update mesh triangle buffer to point at new vertex where needed: if (meshBuffer != null) { if (meshBuffer.triangles[face.index * 3] == visualVertexBuffer[vertex.index][0]) { meshBuffer.triangles[face.index * 3] = meshBuffer.vertexCount - 1; } if (meshBuffer.triangles[face.index * 3 + 1] == visualVertexBuffer[vertex.index][0]) { meshBuffer.triangles[face.index * 3 + 1] = meshBuffer.vertexCount - 1; } if (meshBuffer.triangles[face.index * 3 + 2] == visualVertexBuffer[vertex.index][0]) { meshBuffer.triangles[face.index * 3 + 2] = meshBuffer.vertexCount - 1; } } } // Add the nex vertex to the half-edge. heVertices.Add(newVertex); meshInfo.closed = false; return(true); }
/** * Generates the particle based physical representation of the cloth mesh. This is the initialization method for the cloth object * and should not be called directly once the object has been created. */ protected override IEnumerator Initialize() { initialized = false; initializing = false; if (sharedTopology == null) { Debug.LogError("No ObiMeshTopology provided. Cannot initialize physical representation."); yield break; } else if (!sharedTopology.Initialized) { Debug.LogError("The provided ObiMeshTopology contains no data. Cannot initialize physical representation."); yield break; } initializing = true; RemoveFromSolver(null); GameObject.DestroyImmediate(topology); topology = GameObject.Instantiate(sharedTopology); active = new bool[topology.heVertices.Length]; positions = new Vector3[topology.heVertices.Length]; restPositions = new Vector4[topology.heVertices.Length]; velocities = new Vector3[topology.heVertices.Length]; invMasses = new float[topology.heVertices.Length]; principalRadii = new Vector3[topology.heVertices.Length]; phases = new int[topology.heVertices.Length]; areaContribution = new float[topology.heVertices.Length]; deformableTriangles = new int[topology.heFaces.Length * 3]; initialScaleMatrix.SetTRS(Vector3.zero, Quaternion.identity, transform.lossyScale); // Create a particle for each vertex: for (int i = 0; i < topology.heVertices.Length; i++) { Oni.Vertex vertex = topology.heVertices[i]; // Get the particle's area contribution. areaContribution[i] = 0; foreach (Oni.Face face in topology.GetNeighbourFacesEnumerator(vertex)) { areaContribution[i] += topology.GetFaceArea(face) / 3; } // Get the shortest neighbour edge, particle radius will be half of its length. float minEdgeLength = Single.MaxValue; foreach (Oni.HalfEdge edge in topology.GetNeighbourEdgesEnumerator(vertex)) { // vertices at each end of the edge: Vector3 v1 = initialScaleMatrix * topology.heVertices[topology.GetHalfEdgeStartVertex(edge)].position; Vector3 v2 = initialScaleMatrix * topology.heVertices[edge.endVertex].position; minEdgeLength = Mathf.Min(minEdgeLength, Vector3.Distance(v1, v2)); } active[i] = true; invMasses[i] = (skinnedMeshRenderer == null && areaContribution[i] > 0) ? (1.0f / (DEFAULT_PARTICLE_MASS * areaContribution[i])) : 0; positions[i] = initialScaleMatrix * vertex.position; restPositions[i] = positions[i]; restPositions[i][3] = 1; // activate rest position. principalRadii[i] = Vector3.one * minEdgeLength * 0.5f; phases[i] = Oni.MakePhase(1, selfCollisions?Oni.ParticlePhase.SelfCollide:0); if (i % 500 == 0) { yield return(new CoroutineJob.ProgressInfo("ObiCloth: generating particles...", i / (float)topology.heVertices.Length)); } } // Generate deformable triangles: for (int i = 0; i < topology.heFaces.Length; i++) { Oni.Face face = topology.heFaces[i]; Oni.HalfEdge e1 = topology.heHalfEdges[face.halfEdge]; Oni.HalfEdge e2 = topology.heHalfEdges[e1.nextHalfEdge]; Oni.HalfEdge e3 = topology.heHalfEdges[e2.nextHalfEdge]; deformableTriangles[i * 3] = e1.endVertex; deformableTriangles[i * 3 + 1] = e2.endVertex; deformableTriangles[i * 3 + 2] = e3.endVertex; if (i % 500 == 0) { yield return(new CoroutineJob.ProgressInfo("ObiCloth: generating deformable geometry...", i / (float)topology.heFaces.Length)); } } List <ObiMeshTopology.HEEdge> edges = topology.GetEdgeList(); DistanceConstraints.Clear(); ObiDistanceConstraintBatch distanceBatch = new ObiDistanceConstraintBatch(true, false); DistanceConstraints.AddBatch(distanceBatch); // Create distance springs: for (int i = 0; i < edges.Count; i++) { Oni.HalfEdge hedge = topology.heHalfEdges[edges[i].halfEdgeIndex]; Oni.Vertex startVertex = topology.heVertices[topology.GetHalfEdgeStartVertex(hedge)]; Oni.Vertex endVertex = topology.heVertices[hedge.endVertex]; distanceBatch.AddConstraint(topology.GetHalfEdgeStartVertex(hedge), hedge.endVertex, Vector3.Distance(initialScaleMatrix * startVertex.position, initialScaleMatrix * endVertex.position), 1, 1); if (i % 500 == 0) { yield return(new CoroutineJob.ProgressInfo("ObiCloth: generating structural constraints...", i / (float)topology.heHalfEdges.Length)); } } // Cook distance constraints, for better cache and SIMD use: distanceBatch.Cook(); // Create aerodynamic constraints: AerodynamicConstraints.Clear(); ObiAerodynamicConstraintBatch aeroBatch = new ObiAerodynamicConstraintBatch(false, false); AerodynamicConstraints.AddBatch(aeroBatch); for (int i = 0; i < topology.heVertices.Length; i++) { aeroBatch.AddConstraint(i, areaContribution[i], AerodynamicConstraints.dragCoefficient, AerodynamicConstraints.liftCoefficient); if (i % 500 == 0) { yield return(new CoroutineJob.ProgressInfo("ObiCloth: generating aerodynamic constraints...", i / (float)topology.heFaces.Length)); } } //Create skin constraints (if needed) if (skinnedMeshRenderer != null) { SkinConstraints.Clear(); ObiSkinConstraintBatch skinBatch = new ObiSkinConstraintBatch(true, false); SkinConstraints.AddBatch(skinBatch); for (int i = 0; i < topology.heVertices.Length; ++i) { skinBatch.AddConstraint(i, initialScaleMatrix * topology.heVertices[i].position, Vector3.up, 0.05f, 0.1f, 0, 1); if (i % 500 == 0) { yield return(new CoroutineJob.ProgressInfo("ObiCloth: generating skin constraints...", i / (float)topology.heVertices.Length)); } } for (int i = 0; i < topology.normals.Length; ++i) { skinBatch.skinNormals[topology.visualMap[i]] = topology.normals[i]; } skinBatch.Cook(); } //Create pressure constraints if the mesh is closed: VolumeConstraints.Clear(); if (topology.IsClosed) { ObiVolumeConstraintBatch volumeBatch = new ObiVolumeConstraintBatch(false, false); VolumeConstraints.AddBatch(volumeBatch); float avgInitialScale = (initialScaleMatrix.m00 + initialScaleMatrix.m11 + initialScaleMatrix.m22) * 0.33f; int[] triangleIndices = new int[topology.heFaces.Length * 3]; for (int i = 0; i < topology.heFaces.Length; i++) { Oni.Face face = topology.heFaces[i]; Oni.HalfEdge e1 = topology.heHalfEdges[face.halfEdge]; Oni.HalfEdge e2 = topology.heHalfEdges[e1.nextHalfEdge]; Oni.HalfEdge e3 = topology.heHalfEdges[e2.nextHalfEdge]; triangleIndices[i * 3] = e1.endVertex; triangleIndices[i * 3 + 1] = e2.endVertex; triangleIndices[i * 3 + 2] = e3.endVertex; if (i % 500 == 0) { yield return(new CoroutineJob.ProgressInfo("ObiCloth: generating volume constraints...", i / (float)topology.heFaces.Length)); } } volumeBatch.AddConstraint(triangleIndices, topology.MeshVolume * avgInitialScale, 1, 1); } //Create bending constraints: BendingConstraints.Clear(); ObiBendConstraintBatch bendBatch = new ObiBendConstraintBatch(true, false); BendingConstraints.AddBatch(bendBatch); Dictionary <int, int> cons = new Dictionary <int, int>(); for (int i = 0; i < topology.heVertices.Length; i++) { Oni.Vertex vertex = topology.heVertices[i]; foreach (Oni.Vertex n1 in topology.GetNeighbourVerticesEnumerator(vertex)) { float cosBest = 0; Oni.Vertex vBest = n1; foreach (Oni.Vertex n2 in topology.GetNeighbourVerticesEnumerator(vertex)) { float cos = Vector3.Dot((n1.position - vertex.position).normalized, (n2.position - vertex.position).normalized); if (cos < cosBest) { cosBest = cos; vBest = n2; } } if (!cons.ContainsKey(vBest.index) || cons[vBest.index] != n1.index) { cons[n1.index] = vBest.index; Vector3 n1Pos = initialScaleMatrix * n1.position; Vector3 bestPos = initialScaleMatrix * vBest.position; Vector3 vertexPos = initialScaleMatrix * vertex.position; float[] bendRestPositions = new float[] { n1Pos[0], n1Pos[1], n1Pos[2], bestPos[0], bestPos[1], bestPos[2], vertexPos[0], vertexPos[1], vertexPos[2] }; float restBend = Oni.BendingConstraintRest(bendRestPositions); bendBatch.AddConstraint(n1.index, vBest.index, vertex.index, restBend, 0, 1); } } if (i % 500 == 0) { yield return(new CoroutineJob.ProgressInfo("ObiCloth: adding bend constraints...", i / (float)sharedTopology.heVertices.Length)); } } bendBatch.Cook(); // Initialize tether constraints: TetherConstraints.Clear(); // Initialize pin constraints: PinConstraints.Clear(); ObiPinConstraintBatch pinBatch = new ObiPinConstraintBatch(false, false); PinConstraints.AddBatch(pinBatch); initializing = false; initialized = true; if (skinnedMeshRenderer == null) { InitializeWithRegularMesh(); } else { InitializeWithSkinnedMesh(); } }