reworked mesh decimation yes

LightlessSync/ThirdParty/Nanomesh/Mesh/SharedMesh.cs

@@ -0,0 +1,118 @@
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace Nanomesh
+{
+    /// <summary>
+    /// A shared mesh is a flattened approach of the triangle mesh.
+    /// Is does not has connectivity information, but it is simple to create
+    /// and is a rather lightweight mesh data structure.
+    /// </summary>
+    public class SharedMesh
+    {
+        public Vector3[] positions;
+        public int[] triangles;
+        public Group[] groups;
+        public MetaAttributeList attributes;
+        public AttributeDefinition[] attributeDefinitions;
+
+        [Conditional("DEBUG")]
+        public void CheckLengths()
+        {
+            //if (attributes != null)
+            //{
+            //    foreach (var pair in attributes)
+            //    {
+            //        Debug.Assert(pair.Value.Length == vertices.Length, $"Attribute '{pair.Value}' must have as many elements as vertices");
+            //    }
+            //}
+        }
+
+        public ConnectedMesh ToConnectedMesh()
+        {
+            CheckLengths();
+
+            ConnectedMesh connectedMesh = new ConnectedMesh
+            {
+                groups = groups
+            };
+
+            connectedMesh.positions = positions;
+            connectedMesh.attributes = attributes;
+            connectedMesh.attributeDefinitions = attributeDefinitions;
+
+            // Building relatives
+            ConnectedMesh.Node[] nodes = new ConnectedMesh.Node[triangles.Length];
+            Dictionary<int, List<int>> vertexToNodes = new Dictionary<int, List<int>>();
+            for (int i = 0; i < triangles.Length; i += 3)
+            {
+                ConnectedMesh.Node A = new ConnectedMesh.Node();
+                ConnectedMesh.Node B = new ConnectedMesh.Node();
+                ConnectedMesh.Node C = new ConnectedMesh.Node();
+
+                A.position = triangles[i];
+                B.position = triangles[i + 1];
+                C.position = triangles[i + 2];
+
+                A.attribute = triangles[i];
+                B.attribute = triangles[i + 1];
+                C.attribute = triangles[i + 2];
+
+                A.relative = i + 1; // B
+                B.relative = i + 2; // C
+                C.relative = i; // A
+
+                if (!vertexToNodes.ContainsKey(A.position))
+                {
+                    vertexToNodes.Add(A.position, new List<int>());
+                }
+
+                if (!vertexToNodes.ContainsKey(B.position))
+                {
+                    vertexToNodes.Add(B.position, new List<int>());
+                }
+
+                if (!vertexToNodes.ContainsKey(C.position))
+                {
+                    vertexToNodes.Add(C.position, new List<int>());
+                }
+
+                vertexToNodes[A.position].Add(i);
+                vertexToNodes[B.position].Add(i + 1);
+                vertexToNodes[C.position].Add(i + 2);
+
+                nodes[i] = A;
+                nodes[i + 1] = B;
+                nodes[i + 2] = C;
+
+                connectedMesh._faceCount++;
+            }
+
+            // Building siblings
+            foreach (KeyValuePair<int, List<int>> pair in vertexToNodes)
+            {
+                int previousSibling = -1;
+                int firstSibling = -1;
+                foreach (int node in pair.Value)
+                {
+                    if (firstSibling != -1)
+                    {
+                        nodes[node].sibling = previousSibling;
+                    }
+                    else
+                    {
+                        firstSibling = node;
+                    }
+                    previousSibling = node;
+                }
+                nodes[firstSibling].sibling = previousSibling;
+            }
+
+            connectedMesh.nodes = nodes;
+
+            Debug.Assert(connectedMesh.Check());
+
+            return connectedMesh;
+        }
+    }
+}