MouseSlice

admin

1. using System.Collections.Generic;
   
2. using UnityEngine;
   
3. 
   
4. public class MouseSlice : MonoBehaviour {
   
5. 
   
6.     public GameObject plane;
   
7.     public Transform ObjectContainer;
   
8. 
   
9.     // How far away from the slice do we separate resulting objects
   
10.     public float separation;
    
11. 
    
12.     // Do we draw a plane object associated with the slice
    
13.     private Plane slicePlane = new Plane();
    
14.     public bool drawPlane;
    
15.    
    
16.     // Reference to the line renderer
    
17.     public ScreenLineRenderer lineRenderer;
    
18. 
    
19.     private MeshCutter meshCutter;
    
20.     private TempMesh biggerMesh, smallerMesh;
    
21. 
    
22.     #region Utility Functions
    
23. 
    
24.     void DrawPlane(Vector3 start, Vector3 end, Vector3 normalVec)
    
25.     {
    
26.         Quaternion rotate = Quaternion.FromToRotation(Vector3.up, normalVec);
    
27. 
    
28.         plane.transform.localRotation = rotate;
    
29.         plane.transform.position = (end + start) / 2;
    
30.         plane.SetActive(true);
    
31.     }
    
32. 
    
33.     #endregion
    
34. 
    
35.     // Use this for initialization
    
36.     void Start () {
    
37.         // Initialize a somewhat big array so that it doesn't resize
    
38.         meshCutter = new MeshCutter(256);
    
39.         }
    
40. 
    
41.     private void OnEnable()
    
42.     {
    
43.         lineRenderer.OnLineDrawn += OnLineDrawn;
    
44.     }
    
45. 
    
46.     private void OnDisable()
    
47.     {
    
48.         lineRenderer.OnLineDrawn -= OnLineDrawn;
    
49.     }
    
50. 
    
51.     private void OnLineDrawn(Vector3 start, Vector3 end, Vector3 depth)
    
52.     {
    
53.         var planeTangent = (end - start).normalized;
    
54. 
    
55.         // if we didn't drag, we set tangent to be on x
    
56.         if (planeTangent == Vector3.zero)
    
57.             planeTangent = Vector3.right;
    
58. 
    
59.         var normalVec = Vector3.Cross(depth, planeTangent);
    
60. 
    
61.         if (drawPlane) DrawPlane(start, end, normalVec);
    
62. 
    
63.         SliceObjects(start, normalVec);
    
64.     }
    
65.    
    
66. 
    
67.     void SliceObjects(Vector3 point, Vector3 normal)
    
68.     {
    
69.         var toSlice = GameObject.FindGameObjectsWithTag("Sliceable");
    
70. 
    
71.         // Put results in positive and negative array so that we separate all meshes if there was a cut made
    
72.         List<Transform> positive = new List<Transform>(),
    
73.             negative = new List<Transform>();
    
74. 
    
75.         GameObject obj;
    
76.         bool slicedAny = false;
    
77.         for (int i = 0; i < toSlice.Length; ++i)
    
78.         {
    
79.             obj = toSlice[i];
    
80.             // We multiply by the inverse transpose of the worldToLocal Matrix, a.k.a the transpose of the localToWorld Matrix
    
81.             // Since this is how normal are transformed
    
82.             var transformedNormal = ((Vector3)(obj.transform.localToWorldMatrix.transpose * normal)).normalized;
    
83. 
    
84.             //Convert plane in object's local frame
    
85.             slicePlane.SetNormalAndPosition(
    
86.                 transformedNormal,
    
87.                 obj.transform.InverseTransformPoint(point));
    
88. 
    
89.             slicedAny = SliceObject(ref slicePlane, obj, positive, negative) || slicedAny;
    
90.         }
    
91. 
    
92.         // Separate meshes if a slice was made
    
93.         if (slicedAny)
    
94.             SeparateMeshes(positive, negative, normal);
    
95.     }
    
96. 
    
97.     bool SliceObject(ref Plane slicePlane, GameObject obj, List<Transform> positiveObjects, List<Transform> negativeObjects)
    
98.     {
    
99.         var mesh = obj.GetComponent<MeshFilter>().mesh;
    
100. 
     
101.         if (!meshCutter.SliceMesh(mesh, ref slicePlane))
     
102.         {
     
103.             // Put object in the respective list
     
104.             if (slicePlane.GetDistanceToPoint(meshCutter.GetFirstVertex()) >= 0)
     
105.                 positiveObjects.Add(obj.transform);
     
106.             else
     
107.                 negativeObjects.Add(obj.transform);
     
108. 
     
109.             return false;
     
110.         }
     
111. 
     
112.         // TODO: Update center of mass
     
113. 
     
114.         // Silly condition that labels which mesh is bigger to keep the bigger mesh in the original gameobject
     
115.         bool posBigger = meshCutter.PositiveMesh.surfacearea > meshCutter.NegativeMesh.surfacearea;
     
116.         if (posBigger)
     
117.         {
     
118.             biggerMesh = meshCutter.PositiveMesh;
     
119.             smallerMesh = meshCutter.NegativeMesh;
     
120.         }
     
121.         else
     
122.         {
     
123.             biggerMesh = meshCutter.NegativeMesh;
     
124.             smallerMesh = meshCutter.PositiveMesh;
     
125.         }
     
126. 
     
127.         // Create new Sliced object with the other mesh
     
128.         GameObject newObject = Instantiate(obj, ObjectContainer);
     
129.         newObject.transform.SetPositionAndRotation(obj.transform.position, obj.transform.rotation);
     
130.         var newObjMesh = newObject.GetComponent<MeshFilter>().mesh;
     
131. 
     
132.         // Put the bigger mesh in the original object
     
133.         // TODO: Enable collider generation (either the exact mesh or compute smallest enclosing sphere)
     
134.         ReplaceMesh(mesh, biggerMesh);
     
135.         ReplaceMesh(newObjMesh, smallerMesh);
     
136. 
     
137.         (posBigger ? positiveObjects : negativeObjects).Add(obj.transform);
     
138.         (posBigger ? negativeObjects : positiveObjects).Add(newObject.transform);
     
139. 
     
140.         return true;
     
141.     }
     
142. 
     
143. 
     
144.     /// <summary>
     
145.     /// Replace the mesh with tempMesh.
     
146.     /// </summary>
     
147.     void ReplaceMesh(Mesh mesh, TempMesh tempMesh, MeshCollider collider = null)
     
148.     {
     
149.         mesh.Clear();
     
150.         mesh.SetVertices(tempMesh.vertices);
     
151.         mesh.SetTriangles(tempMesh.triangles, 0);
     
152.         mesh.SetNormals(tempMesh.normals);
     
153.         mesh.SetUVs(0, tempMesh.uvs);
     
154.         
     
155.         //mesh.RecalculateNormals();
     
156.         mesh.RecalculateTangents();
     
157. 
     
158.         if (collider != null && collider.enabled)
     
159.         {
     
160.             collider.sharedMesh = mesh;
     
161.             collider.convex = true;
     
162.         }
     
163.     }
     
164. 
     
165.     void SeparateMeshes(Transform posTransform, Transform negTransform, Vector3 localPlaneNormal)
     
166.     {
     
167.         // Bring back normal in world space
     
168.         Vector3 worldNormal = ((Vector3)(posTransform.worldToLocalMatrix.transpose * localPlaneNormal)).normalized;
     
169. 
     
170.         Vector3 separationVec = worldNormal * separation;
     
171.         // Transform direction in world coordinates
     
172.         posTransform.position += separationVec;
     
173.         negTransform.position -= separationVec;
     
174.     }
     
175. 
     
176.     void SeparateMeshes(List<Transform> positives, List<Transform> negatives, Vector3 worldPlaneNormal)
     
177.     {
     
178.         int i;
     
179.         var separationVector = worldPlaneNormal * separation;
     
180. 
     
181.         for(i = 0; i <positives.Count; ++i)
     
182.             positives[i].transform.position += separationVector;
     
183. 
     
184.         for (i = 0; i < negatives.Count; ++i)
     
185.             negatives[i].transform.position -= separationVector;
     
186.     }
     
187. }
     

复制代码