Ejemplo n.º 1
0
        private static void Capping(Plane blade, MeshCutSide leftSide, MeshCutSide rightSide, List <Vector3> newVertices)
        {
            try
            {
                List <Vector3> capVertTracker = new List <Vector3>();
                List <Vector3> capVertpolygon = new List <Vector3>();
                int            numNewVertices = newVertices.Count;

                for (int i = 0; i < numNewVertices; i++)
                {
                    if (!capVertTracker.Contains(newVertices[i]))
                    {
                        capVertpolygon.Clear();
                        capVertpolygon.Add(newVertices[i]);
                        capVertpolygon.Add(newVertices[i + 1]);

                        capVertTracker.Add(newVertices[i]);
                        capVertTracker.Add(newVertices[i + 1]);

                        bool isDone = false;

                        while (!isDone)
                        {
                            isDone = true;

                            for (int k = 0; k < numNewVertices; k += 2)
                            {
                                // go through the pairs
                                if (newVertices[k] == capVertpolygon[capVertpolygon.Count - 1] && !capVertTracker.Contains(newVertices[k + 1]))
                                {
                                    // if so add the other
                                    isDone = false;
                                    capVertpolygon.Add(newVertices[k + 1]);
                                    capVertTracker.Add(newVertices[k + 1]);
                                }
                                else if (newVertices[k + 1] == capVertpolygon[capVertpolygon.Count - 1] && !capVertTracker.Contains(newVertices[k]))
                                {
                                    // if so add the other
                                    isDone = false;
                                    capVertpolygon.Add(newVertices[k]);
                                    capVertTracker.Add(newVertices[k]);
                                }
                            }
                        }

                        FillCap(blade, leftSide, rightSide, capVertpolygon);
                    }
                }
            }
            catch (System.Exception e)
            {
                Debug.LogErrorFormat("MeshCutter Capping: Caught exception: {0}", e.Message);
            }
        }
Ejemplo n.º 2
0
        static void FillCap(Plane blade, MeshCutSide leftSide, MeshCutSide rightSide, List <Vector3> vertices)
        {
            // center of the cap
            Vector3 center      = Vector3.zero;
            int     numVertices = vertices.Count;

            for (int i = 0; i < numVertices; ++i)
            {
                center += vertices[i];
            }

            center = center / vertices.Count;

            // you need an axis based on the cap
            Vector3 upward = Vector3.zero;

            // 90 degree turn
            upward.x = blade.normal.y;
            upward.y = -blade.normal.x;
            upward.z = blade.normal.z;
            Vector3 left = Vector3.Cross(blade.normal, upward);

            Vector3 displacement = Vector3.zero;
            Vector3 newUV1       = Vector3.zero;
            Vector3 newUV2       = Vector3.zero;
            Vector2 half         = new Vector2(0.5f, 0.5f);

            for (int i = 0; i < numVertices; ++i)
            {
                displacement = vertices[i] - center;
                newUV1       = Vector3.zero;
                newUV1.x     = 0.5f + Vector3.Dot(displacement, left);
                newUV1.y     = 0.5f + Vector3.Dot(displacement, upward);
                newUV1.z     = 0.5f + Vector3.Dot(displacement, blade.normal);

                displacement = vertices[(i + 1) % vertices.Count] - center;
                newUV2       = Vector3.zero;
                newUV2.x     = 0.5f + Vector3.Dot(displacement, left);
                newUV2.y     = 0.5f + Vector3.Dot(displacement, upward);
                newUV2.z     = 0.5f + Vector3.Dot(displacement, blade.normal);

                leftSide.AddTriangle(
                    new Vector3[] {
                    vertices[i], vertices[(i + 1) % vertices.Count], center
                },
                    new Vector3[] {
                    -blade.normal, -blade.normal, -blade.normal
                },
                    new Vector2[] {
                    newUV1, newUV2, half
                },
                    -blade.normal,
                    leftSide.subIndices.Count - 1
                    );

                rightSide.AddTriangle(
                    new Vector3[] {
                    vertices[i], vertices[(i + 1) % vertices.Count], center
                },
                    new Vector3[] {
                    blade.normal, blade.normal, blade.normal
                },
                    new Vector2[] {
                    newUV1, newUV2, half
                },
                    blade.normal,
                    rightSide.subIndices.Count - 1
                    );
            }
        }
Ejemplo n.º 3
0
        private static void CutFace(
            Plane blade,
            MeshCutSide leftSide,
            MeshCutSide rightSide,
            List <Vector3> newVertices,
            Vector3[] targetMeshVertices,
            Vector3[] targetMeshNormals,
            Vector2[] targetMeshUVs,
            int submesh,
            bool[] sides,
            int index1,
            int index2,
            int index3)
        {
            Vector3[] leftPoints   = new Vector3[2];
            Vector3[] leftNormals  = new Vector3[2];
            Vector2[] leftUvs      = new Vector2[2];
            Vector3[] rightPoints  = new Vector3[2];
            Vector3[] rightNormals = new Vector3[2];
            Vector2[] rightUvs     = new Vector2[2];

            bool didset_left  = false;
            bool didset_right = false;

            int p = index1;

            for (int side = 0; side < 3; side++)
            {
                switch (side)
                {
                case 0: p = index1; break;

                case 1: p = index2; break;

                case 2: p = index3; break;
                }

                if (sides[side])
                {
                    if (!didset_left)
                    {
                        didset_left = true;

                        leftPoints[0]  = targetMeshVertices[p];
                        leftPoints[1]  = leftPoints[0];
                        leftUvs[0]     = targetMeshUVs[p];
                        leftUvs[1]     = leftUvs[0];
                        leftNormals[0] = targetMeshNormals[p];
                        leftNormals[1] = leftNormals[0];
                    }
                    else
                    {
                        leftPoints[1]  = targetMeshVertices[p];
                        leftUvs[1]     = targetMeshUVs[p];
                        leftNormals[1] = targetMeshNormals[p];
                    }
                }
                else
                {
                    if (!didset_right)
                    {
                        didset_right = true;

                        rightPoints[0]  = targetMeshVertices[p];
                        rightPoints[1]  = rightPoints[0];
                        rightUvs[0]     = targetMeshUVs[p];
                        rightUvs[1]     = rightUvs[0];
                        rightNormals[0] = targetMeshNormals[p];
                        rightNormals[1] = rightNormals[0];
                    }
                    else
                    {
                        rightPoints[1]  = targetMeshVertices[p];
                        rightUvs[1]     = targetMeshUVs[p];
                        rightNormals[1] = targetMeshNormals[p];
                    }
                }
            }

            float normalizedDistance = 0.0f;
            float distance           = 0;

            blade.Raycast(new Ray(leftPoints[0], (rightPoints[0] - leftPoints[0]).normalized), out distance);

            normalizedDistance = distance / (rightPoints[0] - leftPoints[0]).magnitude;
            Vector3 newVertex1 = Vector3.Lerp(leftPoints[0], rightPoints[0], normalizedDistance);
            Vector2 newUv1     = Vector2.Lerp(leftUvs[0], rightUvs[0], normalizedDistance);
            Vector3 newNormal1 = Vector3.Lerp(leftNormals[0], rightNormals[0], normalizedDistance);

            newVertices.Add(newVertex1);

            blade.Raycast(new Ray(leftPoints[1], (rightPoints[1] - leftPoints[1]).normalized), out distance);

            normalizedDistance = distance / (rightPoints[1] - leftPoints[1]).magnitude;
            Vector3 newVertex2 = Vector3.Lerp(leftPoints[1], rightPoints[1], normalizedDistance);
            Vector2 newUv2     = Vector2.Lerp(leftUvs[1], rightUvs[1], normalizedDistance);
            Vector3 newNormal2 = Vector3.Lerp(leftNormals[1], rightNormals[1], normalizedDistance);

            newVertices.Add(newVertex2);

            leftSide.AddTriangle(new Vector3[] { leftPoints[0], newVertex1, newVertex2 },
                                 new Vector3[] { leftNormals[0], newNormal1, newNormal2 },
                                 new Vector2[] { leftUvs[0], newUv1, newUv2 }, newNormal1,
                                 submesh);

            leftSide.AddTriangle(new Vector3[] { leftPoints[0], leftPoints[1], newVertex2 },
                                 new Vector3[] { leftNormals[0], leftNormals[1], newNormal2 },
                                 new Vector2[] { leftUvs[0], leftUvs[1], newUv2 }, newNormal2,
                                 submesh);

            rightSide.AddTriangle(new Vector3[] { rightPoints[0], newVertex1, newVertex2 },
                                  new Vector3[] { rightNormals[0], newNormal1, newNormal2 },
                                  new Vector2[] { rightUvs[0], newUv1, newUv2 }, newNormal1,
                                  submesh);

            rightSide.AddTriangle(new Vector3[] { rightPoints[0], rightPoints[1], newVertex2 },
                                  new Vector3[] { rightNormals[0], rightNormals[1], newNormal2 },
                                  new Vector2[] { rightUvs[0], rightUvs[1], newUv2 }, newNormal2,
                                  submesh);
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Cuts the specified target into two pieces and caps the sides with the specified Material.
        /// </summary>
        /// <param name="target">The target that is cut - must have a MeshFilter component.</param>
        /// <param name="anchorPoint">Anchor point of the blade i.e. the point where the blade cuts the object.</param>
        /// <param name="normalDirection">Normal direction of the blade plane.</param>
        /// <param name="capMaterial">Cap material - placed as material on the cutting surface of the two sides.</param>
        /// <param name="copyRigidbody">Should the rigidbody be copied to both of the two new pieces.</param>
        /// <param name="copyRigidbody">Should both of the new pieces have colliders.</param>
        public static IObservable <GameObject[]> Cut(GameObject target, Vector3 anchorPoint, Vector3 normalDirection, Material capMaterial, bool copyRigidbody = true, bool copyCollider = true)
        {
            // Set the blade relative to victim
            Plane blade = new Plane(target.transform.InverseTransformDirection(-normalDirection),
                                    target.transform.InverseTransformPoint(anchorPoint));

            // Get the target mesh
            Mesh targetMesh = target.GetComponent <MeshFilter>().mesh;

            Vector3[] targetMeshVertices = targetMesh.vertices;
            Vector3[] targetMeshNormals  = targetMesh.normals;
            Vector2[] targetMeshUVs      = targetMesh.uv;

            int          subMeshCount   = targetMesh.subMeshCount;
            List <int[]> subMeshIndices = new List <int[]>();

            for (int i = 0; i < subMeshCount; ++i)
            {
                subMeshIndices.Add(targetMesh.GetIndices(i));
            }

            // Material parameters
            Material[] mats            = target.GetComponent <MeshRenderer>().sharedMaterials;
            string[]   matsNames       = mats.Select(m => m.name).ToArray();
            string     capMaterialName = capMaterial.name;

            return(Observable.Start(() =>
            {
                if (targetMesh == null)
                {
                    Debug.LogError("MeshCut Cut: Target did not have a MeshFilter component");
                }

                // Left and right side mesh cuts
                MeshCutSide leftSide = new MeshCutSide(targetMeshVertices, targetMeshNormals, targetMeshUVs);
                MeshCutSide rightSide = new MeshCutSide(targetMeshVertices, targetMeshNormals, targetMeshUVs);

                // New vertices for capping the cutting surface
                List <Vector3> newVertices = new List <Vector3>();

                bool[] sides = new bool[3];
                int p1, p2, p3;

                for (int sub = 0; sub < subMeshCount; ++sub)
                {
                    int[] indices = subMeshIndices[sub];
                    leftSide.subIndices.Add(new List <int>());
                    rightSide.subIndices.Add(new List <int>());

                    for (int i = 0; i < indices.Length; i += 3)
                    {
                        p1 = indices[i];
                        p2 = indices[i + 1];
                        p3 = indices[i + 2];

                        sides[0] = blade.GetSide(targetMeshVertices[p1]);
                        sides[1] = blade.GetSide(targetMeshVertices[p2]);
                        sides[2] = blade.GetSide(targetMeshVertices[p3]);

                        // whole triangle
                        if (sides[0] == sides[1] && sides[0] == sides[2])
                        {
                            if (sides[0])
                            {
                                // left side
                                leftSide.AddTriangle(p1, p2, p3, sub);
                            }
                            else
                            {
                                rightSide.AddTriangle(p1, p2, p3, sub);
                            }
                        }
                        else
                        {
                            // Cut the triangle
                            CutFace(
                                blade,
                                leftSide,
                                rightSide,
                                newVertices,
                                targetMeshVertices,
                                targetMeshNormals,
                                targetMeshUVs,
                                sub,
                                sides,
                                p1,
                                p2,
                                p3
                                );
                        }
                    }
                }

                if (matsNames[mats.Length - 1] != capMaterialName)
                {
                    // Add cap indices
                    leftSide.subIndices.Add(new List <int>());
                    rightSide.subIndices.Add(new List <int>());

                    Material[] newMats = new Material[mats.Length + 1];
                    mats.CopyTo(newMats, 0);
                    newMats[mats.Length] = capMaterial;
                    mats = newMats;
                }

                // Cap the openings
                Capping(blade, leftSide, rightSide, newVertices);

                return new MeshCutSide[] { leftSide, rightSide };
            },
                                    Scheduler.ThreadPool)
                   .ObserveOnMainThread()
                   .Select(results => {
                MeshCutSide leftSide = results[0];
                MeshCutSide rightSide = results[1];

                // Left Mesh
                Mesh leftHalfMesh = new Mesh();
                leftHalfMesh.name = "Split Mesh Left";
                leftHalfMesh.vertices = leftSide.vertices.ToArray();
                leftHalfMesh.triangles = leftSide.triangles.ToArray();
                leftHalfMesh.normals = leftSide.normals.ToArray();
                leftHalfMesh.uv = leftSide.uvs.ToArray();

                leftHalfMesh.subMeshCount = leftSide.subIndices.Count;
                int leftHalfMeshSubMeshCount = leftHalfMesh.subMeshCount;

                for (int i = 0; i < leftHalfMeshSubMeshCount; ++i)
                {
                    leftHalfMesh.SetIndices(leftSide.subIndices[i].ToArray(), MeshTopology.Triangles, i);
                }

                // Right Mesh
                Mesh rightHalfMesh = new Mesh();
                rightHalfMesh.name = "Split Mesh Right";
                rightHalfMesh.vertices = rightSide.vertices.ToArray();
                rightHalfMesh.triangles = rightSide.triangles.ToArray();
                rightHalfMesh.normals = rightSide.normals.ToArray();
                rightHalfMesh.uv = rightSide.uvs.ToArray();

                rightHalfMesh.subMeshCount = rightSide.subIndices.Count;
                int rightHalfSubMeshCount = rightHalfMesh.subMeshCount;

                for (int i = 0; i < rightHalfSubMeshCount; ++i)
                {
                    rightHalfMesh.SetIndices(rightSide.subIndices[i].ToArray(), MeshTopology.Triangles, i);
                }

                // Assign the game objects
                target.GetComponent <MeshFilter>().mesh = leftHalfMesh;
                GameObject leftSideObj = target;

                GameObject rightSideObj = new GameObject(target.name, typeof(MeshFilter), typeof(MeshRenderer));
                rightSideObj.transform.position = target.transform.position;
                rightSideObj.transform.rotation = target.transform.rotation;
                rightSideObj.transform.localScale = target.transform.localScale;
                rightSideObj.GetComponent <MeshFilter>().mesh = rightHalfMesh;

                // Maintain colliders and rigidbodies on both pieces i.e. populate the right piece
                Rigidbody leftSideRigidbody = leftSideObj.GetComponent <Rigidbody>();
                MeshCollider leftSideCollider = leftSideObj.GetComponent <MeshCollider>();

                if (copyRigidbody && leftSideRigidbody != null)
                {
                    Rigidbody rigidbody = rightSideObj.AddComponent <Rigidbody>();
                    rigidbody.useGravity = leftSideRigidbody.useGravity;
                    rigidbody.interpolation = leftSideRigidbody.interpolation;
                    rigidbody.collisionDetectionMode = leftSideRigidbody.collisionDetectionMode;
                }

                if (copyCollider && leftSideCollider != null)
                {
                    MeshCollider meshCollider = rightSideObj.AddComponent <MeshCollider>();
                    meshCollider.convex = true;
                }

                // Assign mats
                leftSideObj.GetComponent <MeshRenderer>().materials = mats;
                rightSideObj.GetComponent <MeshRenderer>().materials = mats;

                return new GameObject[] { leftSideObj, rightSideObj };
            }));
        }