Add ability to ignore some positions

When creating a new triangulation job, you can now optionally pass a NativeArray<bool> called IgnorePositions. This array should be the same length as the Positions array. Any indexes that are true it IngorePositions will not be used in the triangulation.

Example use case: regenerate a mesh's triangles but only use a subset of its vertices, without having to change the mesh's vertices array.

Author: JimmyCushnie

Runtime/Triangulator.cs

@@ -231,6 +231,8 @@ public class TriangulationSettings
         public class InputData
         {
             public NativeArray<float2> Positions { get; set; }
+            
+            public NativeArray<bool> IgnorePositions { get; set; }
             public NativeArray<int> ConstraintEdges { get; set; }
             public NativeArray<float2> HoleSeeds { get; set; }
         }
@@ -309,6 +311,8 @@ public struct InputData
             {
                 public NativeArray<float2> Positions;
                 [NativeDisableContainerSafetyRestriction]
+                public NativeArray<bool> IgnorePositions;
+                [NativeDisableContainerSafetyRestriction]
                 public NativeArray<int> ConstraintEdges;
                 [NativeDisableContainerSafetyRestriction]
                 public NativeArray<float2> HoleSeeds;
@@ -336,6 +340,7 @@ public TriangulationJob(Triangulator triangulator)
                 input = new()
                 {
                     Positions = triangulator.Input.Positions,
+                    IgnorePositions = triangulator.Input.IgnorePositions,
                     ConstraintEdges = triangulator.Input.ConstraintEdges,
                     HoleSeeds = triangulator.Input.HoleSeeds,
                 };
@@ -397,6 +402,7 @@ public void Execute()
                 {
                     status = output.Status,
                     positions = localPositions.AsArray(),
+                    ignorePositions = input.IgnorePositions,
                     triangles = triangles,
                     halfedges = halfedges,
                     hullStart = int.MaxValue,
@@ -603,9 +609,11 @@ private struct DistComparer : IComparer<int>
             public NativeList<int> triangles;
 
             public NativeList<int> halfedges;
-
+            
+            [NativeDisableContainerSafetyRestriction]
+            public NativeArray<bool> ignorePositions;
             [NativeDisableContainerSafetyRestriction]
-            private NativeArray<int> ids;
+            private NativeList<int> ids;
             [NativeDisableContainerSafetyRestriction]
             private NativeArray<float> dists;
             [NativeDisableContainerSafetyRestriction]
@@ -661,25 +669,29 @@ public void Execute()
 
                 var min = (float2)float.MaxValue;
                 var max = (float2)float.MinValue;
-
+                
                 for (int i = 0; i < positions.Length; i++)
                 {
+                    if (ignorePositions.IsCreated && ignorePositions[i])
+                        continue;
+                    
                     var p = positions[i];
                     min = math.min(min, p);
                     max = math.max(max, p);
-                    ids[i] = i;
+                    ids.Add(i);
                 }
 
                 var center = 0.5f * (min + max);
 
                 int i0 = int.MaxValue, i1 = int.MaxValue, i2 = int.MaxValue;
                 var minDistSq = float.MaxValue;
-                for (int i = 0; i < positions.Length; i++)
+                for (int i = 0; i < ids.Length; i++)
                 {
-                    var distSq = math.distancesq(center, positions[i]);
+                    var id = ids[i];
+                    var distSq = math.distancesq(center, positions[id]);
                     if (distSq < minDistSq)
                     {
-                        i0 = i;
+                        i0 = id;
                         minDistSq = distSq;
                     }
                 }
@@ -688,13 +700,14 @@ public void Execute()
                 var p0 = positions[i0];
 
                 minDistSq = float.MaxValue;
-                for (int i = 0; i < positions.Length; i++)
+                for (int i = 0; i < ids.Length; i++)
                 {
-                    if (i == i0) continue;
-                    var distSq = math.distancesq(p0, positions[i]);
+                    var id = ids[i];
+                    if (id == i0) continue;
+                    var distSq = math.distancesq(p0, positions[id]);
                     if (distSq < minDistSq)
                     {
-                        i1 = i;
+                        i1 = id;
                         minDistSq = distSq;
                     }
                 }
@@ -703,14 +716,15 @@ public void Execute()
                 var p1 = positions[i1];
 
                 var minRadius = float.MaxValue;
-                for (int i = 0; i < positions.Length; i++)
+                for (int i = 0; i < ids.Length; i++)
                 {
-                    if (i == i0 || i == i1) continue;
-                    var p = positions[i];
+                    var id = ids[i];
+                    if (id == i0 || id == i1) continue;
+                    var p = positions[id];
                     var r = CircumRadiusSq(p0, p1, p);
                     if (r < minRadius)
                     {
-                        i2 = i;
+                        i2 = id;
                         minRadius = r;
                     }
                 }
@@ -739,9 +753,10 @@ public void Execute()
 
                 // Sort all other vertices by their distance to the circumcenter of the initial triangle
                 c = CircumCenter(p0, p1, p2);
-                for (int i = 0; i < positions.Length; i++)
+                for (int i = 0; i < ids.Length; i++)
                 {
-                    dists[i] = math.distancesq(c, positions[i]);
+                    var id = ids[i];
+                    dists[id] = math.distancesq(c, positions[id]);
                 }
 
                 ids.Sort(new DistComparer(dists));