예제 #1
0
        private void MergeWithCollidingFaces()
        {
            //Collecting all moved faces and static faces and remove faces if they overlap.

            var facesToRemove = new List <int>();

            Manifold manifold = Extrudable._manifold;


            int noFaces = manifold.NumberOfFaces();


            var vertexIds   = new int[manifold.NumberOfVertices()];
            var halfedgeIds = new int[manifold.NumberOfHalfEdges()];

            int[] allFaces = new int[noFaces];
            Extrudable._manifold.GetHMeshIds(vertexIds, halfedgeIds, allFaces);



            int[] staticFaces = allFaces;


            HashSet <int> facesBeingExtruded = new HashSet <int>();

            //collect all neighbouring faces of extruded faces, theses faces are the one connecting the vertices of the old face to the face being moved.
            foreach (int face0 in extrudingFaces)
            {
                foreach (int face1 in Extrudable._manifold.GetAdjacentFaceIdsAndEdgeCenters(face0).faceId)
                {
                    facesBeingExtruded.Add(face1);
                }
                //the moved face itself
                facesBeingExtruded.Add(face0);
            }



            foreach (int faceMoving in facesBeingExtruded)
            {
                foreach (int faceStatic in staticFaces)
                {
                    if (faceMoving == faceStatic)
                    {
                        break;
                    }

                    if (facingFaces(faceMoving, faceStatic)) //initial cheap check
                    {
                        var verticesFromFaceMoving = Extrudable._manifold.GetVertexPositionsFromFace(faceMoving);
                        var verticesFromFaceStatic = Extrudable._manifold.GetVertexPositionsFromFace(faceStatic);
                        if (verticesFromFaceMoving.Count() == verticesFromFaceStatic.Count())
                        {
                            var matches = faceBridgingVertexAssignment(verticesFromFaceMoving, verticesFromFaceStatic);

                            if (facingFaces(matches, faceMoving, verticesFromFaceMoving, faceStatic, verticesFromFaceStatic))
                            {
                                if (matches.Length == 6)
                                {
                                    facesToRemove.Add(faceMoving);
                                    facesToRemove.Add(faceStatic);
                                }
                                else if (matches.Length == 8)
                                {
                                    facesToRemove.Add(faceMoving);
                                    facesToRemove.Add(faceStatic);
                                }
                            }
                        }
                    }
                }
            }

            //remove facing faces and stich everything together
            foreach (int face in facesToRemove)
            {
                Extrudable._manifold.RemoveFace(face);
            }
            Extrudable._manifold.StitchMesh(0.05);
        }
예제 #2
0
        public void UpdateControls()
        {
            Manifold manifold    = Extrudable._manifold;
            var      faceIds     = new int[manifold.NumberOfFaces()];
            var      vertexIds   = new int[manifold.NumberOfVertices()];
            var      halfedgeIds = new int[manifold.NumberOfHalfEdges()];

            manifold.GetHMeshIds(vertexIds, halfedgeIds, faceIds);

            // update face handles
            foreach (var faceHandleController in _faceHandles)
            {
                var handleFace = faceHandleController.Value.AssociatedFaceID;

                if (!faceHandleController.Value.IsDragged)
                {
                    var center = manifold.GetCenterTriangulated(handleFace);

                    //Use average of edgecenters if we have more than 4 edges.
                    var temp = manifold.GetAdjacentFaceIdsAndEdgeCenters(handleFace);
                    if (temp.edgeCenter.Length > 4)
                    {
                        Vector3 cent = new Vector3();
                        foreach (Vector3 v in temp.edgeCenter)
                        {
                            cent[0] += v[0];
                            cent[1] += v[1];
                            cent[2] += v[2];
                        }
                        cent[0] /= temp.edgeCenter.Length;
                        cent[1] /= temp.edgeCenter.Length;
                        cent[2] /= temp.edgeCenter.Length;

                        center = cent;
                    }

                    // Rotate the handle to look in the opposite direction of face's normal
                    var normal     = manifold.GetFaceNormal(handleFace);
                    var edgeNormal = manifold.GetFirstEdgeDirection(handleFace);
                    faceHandleController.Value.UpdatePositionAndRotation(center, normal, edgeNormal);
                    faceHandleController.Value.gameObject.SetActive(true);
                }

                var adjacentFaces = manifold.GetAdjacentFaceIdsAndEdgeCenters(handleFace);

                for (int j = 0; j < adjacentFaces.edgeId.Length; j++)
                {
                    EdgeHandleController latch;
                    if (_edgeHandles.TryGetValue(adjacentFaces.edgeId[j], out latch))
                    {
                        var otherFace = latch.GetOtherFace(handleFace);

                        var edgeCenter         = adjacentFaces.edgeCenter[j];
                        var normal             = manifold.GetFaceNormal(handleFace);
                        var adjacentFaceNormal = manifold.GetFaceNormal(otherFace);

                        latch.UpdatePositionAndRotation(edgeCenter, adjacentFaces.edgeNormals[j],
                                                        adjacentFaceNormal + normal);
                        latch.gameObject.SetActive(true);
                    }
                }
            }

            for (int i = 0; i < faceIds.Length; i++)
            {
                int id = faceIds[i];
                FaceHandleController visitedHandleController = null;
                _faceHandles.TryGetValue(id, out visitedHandleController);

                var newHandle = visitedHandleController != null
                    ? visitedHandleController
                    : InstantiateFaceHandle(manifold, id);
                InstantiateLatches(manifold, newHandle);
            }

            foreach (var vertexHandleController in _vertexHandles)
            {
                if (!vertexHandleController.Value.IsDragged)
                {
                    Vector3 vertexPosition = manifold.VertexPosition(vertexHandleController.Key);
                    vertexHandleController.Value.transform.localPosition = vertexPosition;

                    Vector3 vertexNormal = manifold.GetVertexNormal(vertexHandleController.Key);
                    //Debug.Log("VertexHandleNormal: " + vertexNormal);
                    Quaternion handleRotation = Quaternion.LookRotation(-vertexNormal);
                    vertexHandleController.Value.transform.localRotation = handleRotation;
                }
                vertexHandleController.Value.gameObject.SetActive(true);
            }

            for (int i = 0; i < vertexIds.Length; i++)
            {
                int id = vertexIds[i];
                VertexHandleController vertexHandle = null;
                _vertexHandles.TryGetValue(id, out vertexHandle);
                if (!manifold.IsVertexInUse(id) || vertexHandle != null)
                {
                    continue;
                }

                InstantiateVertexHandle(manifold, id);
            }

            //update sizes
            foreach (var faceHandleController in _faceHandles.Values)
            {
                faceHandleController.UpdateHandleSize();
            }
            foreach (var edgeHandleController in _edgeHandles.Values)
            {
                edgeHandleController.UpdateHandleSize();
            }
            foreach (var vertexHandleController in _vertexHandles.Values)
            {
                vertexHandleController.UpdateHandleSize();
            }
        }