feat: native disposable impl

Author: andywiecko

Runtime/Triangulator.cs

@@ -467,7 +467,7 @@ public readonly struct Handle
     /// </remarks>
     /// <seealso cref="Triangulator{T2}"/>
     /// <seealso cref="UnsafeTriangulator{T2}"/>
-    public class Triangulator : IDisposable
+    public class Triangulator : INativeDisposable
     {
         /// <summary>
         /// Settings used for triangulation.
@@ -499,6 +499,18 @@ public class Triangulator : IDisposable
         /// </summary>
         public void Dispose() => impl.Dispose();
 
+        /// <summary>
+        /// Creates and schedules a job that releases all resources (memory and safety handles).
+        /// </summary>
+        /// <param name="dependencies">The dependency for the new job.</param>
+        /// <remarks>
+        /// Note: Consider using <see cref="UnsafeTriangulator"/>, which provides more customization for data management.
+        /// </remarks>
+        /// <returns>
+        /// The handle of the new job. The job depends upon <paramref name="dependencies"/> and releases all resources (memory and safety handles).
+        /// </returns>
+        public JobHandle Dispose(JobHandle dependencies) => impl.Dispose(dependencies);
+
         /// <summary>
         /// Perform the job's Execute method immediately on the same thread.
         /// </summary>
@@ -556,7 +568,7 @@ public class Triangulator : IDisposable
     /// <seealso cref="Triangulator"/>
     /// <seealso cref="UnsafeTriangulator{T2}"/>
     /// <seealso cref="Extensions"/>
-    public class Triangulator<T2> : IDisposable where T2 : unmanaged
+    public class Triangulator<T2> : INativeDisposable where T2 : unmanaged
     {
         /// <summary>
         /// Settings used for triangulation.
@@ -614,6 +626,27 @@ public void Dispose()
             constrainedHalfedges.Dispose();
             ignoredHalfedgesForPlantingSeeds.Dispose();
         }
+
+        /// <summary>
+        /// Creates and schedules a job that releases all resources (memory and safety handles).
+        /// </summary>
+        /// <param name="dependencies">The dependency for the new job.</param>
+        /// <remarks>
+        /// Note: Consider using <see cref="UnsafeTriangulator"/>, which provides more customization for data management.
+        /// </remarks>
+        /// <returns>
+        /// The handle of the new job. The job depends upon <paramref name="dependencies"/> and releases all resources (memory and safety handles).
+        /// </returns>
+        public JobHandle Dispose(JobHandle dependencies)
+        {
+            dependencies = outputPositions.Dispose(dependencies);
+            dependencies = triangles.Dispose(dependencies);
+            dependencies = status.Dispose(dependencies);
+            dependencies = halfedges.Dispose(dependencies);
+            dependencies = constrainedHalfedges.Dispose(dependencies);
+            dependencies = ignoredHalfedgesForPlantingSeeds.Dispose(dependencies);
+            return dependencies;
+        }
     }
 
     /// <summary>

Tests/TriangulatorEditorTests.cs

@@ -125,5 +125,18 @@ public void DisposeLeaksTest()
             var leaks = Unity.Collections.LowLevel.Unsafe.UnsafeUtility.CheckForLeaks();
             Assert.That(leaks, Is.Zero);
         }
+
+        [Test, Description("Checks for memory leaks during Triangulator allocation and disposal (with dependencies).")]
+        public void DisposeLeaksWithDependenciesTest()
+        {
+            // Log and forgive any existing leaks before the test.
+            // Note: These leaks may not be related to Triangulator and could be caused by other internal systems (e.g., UIElements).
+            Unity.Collections.LowLevel.Unsafe.UnsafeUtility.CheckForLeaks();
+            var dependencies = default(JobHandle);
+            dependencies = new Triangulator(Allocator.Persistent).Dispose(dependencies);
+            dependencies.Complete();
+            var leaks = Unity.Collections.LowLevel.Unsafe.UnsafeUtility.CheckForLeaks();
+            Assert.That(leaks, Is.Zero);
+        }
     }
 }