com.wallstop-studios.unity-helpers 2.0.0-rc26 → 2.0.0-rc30

package/Tests/Runtime/Performance/RandomPerformanceTests.cs

@@ -1,139 +1,139 @@
-namespace UnityHelpers.Tests.Performance
-{
-    using System;
-    using System.Diagnostics;
-    using NUnit.Framework;
-    using UnityHelpers.Core.Random;
-
-    public sealed class RandomPerformanceTests
-    {
-        [Test]
-        public void Benchmark()
-        {
-            TimeSpan timeout = TimeSpan.FromSeconds(1.125);
-
-            UnityEngine.Debug.Log(
-                $"| Random | NextBool | Next | NextUInt | NextFloat | NextDouble | NextUint - Range | "
-            );
-            UnityEngine.Debug.Log(
-                $"| ------ | -------- | ---- | -------- | --------- | ---------- | ---------------- |"
-            );
-
-            RunTest(new PcgRandom(), timeout);
-            RunTest(new SystemRandom(), timeout);
-            RunTest(new SquirrelRandom(), timeout);
-            RunTest(new XorShiftRandom(), timeout);
-            RunTest(new DotNetRandom(), timeout);
-            RunTest(new WyRandom(), timeout);
-            RunTest(new SplitMix64(), timeout);
-            RunTest(new RomuDuo(), timeout);
-            RunTest(new XorShiroRandom(), timeout);
-        }
-
-        private static void RunTest<T>(T random, TimeSpan timeout)
-            where T : IRandom
-        {
-            int nextBool = RunNextBool(timeout, random);
-            int nextInt = RunNext(timeout, random);
-            int nextUint = RunNextUint(timeout, random);
-            int nextFloat = RunNextFloat(timeout, random);
-            int nextDouble = RunNextDouble(timeout, random);
-            int nextUintRange = RunNextUintRange(timeout, random);
-
-            UnityEngine.Debug.Log(
-                $"| {random.GetType().Name} | "
-                    + $"{(nextBool / timeout.TotalSeconds):N0} | "
-                    + $"{(nextInt / timeout.TotalSeconds):N0} | "
-                    + $"{(nextUint / timeout.TotalSeconds):N0} | "
-                    + $"{(nextFloat / timeout.TotalSeconds):N0} | "
-                    + $"{(nextDouble / timeout.TotalSeconds):N0} |"
-                    + $"{(nextUintRange / timeout.TotalSeconds):N0} |"
-            );
-        }
-
-        // Copy-pasta'd for maximum speed
-        private static int RunNext<T>(TimeSpan timeout, T random)
-            where T : IRandom
-        {
-            int count = 0;
-            Stopwatch timer = Stopwatch.StartNew();
-            do
-            {
-                _ = random.Next();
-                ++count;
-            } while (timer.Elapsed < timeout);
-
-            return count;
-        }
-
-        private static int RunNextBool<T>(TimeSpan timeout, T random)
-            where T : IRandom
-        {
-            int count = 0;
-            Stopwatch timer = Stopwatch.StartNew();
-            do
-            {
-                _ = random.NextBool();
-                ++count;
-            } while (timer.Elapsed < timeout);
-
-            return count;
-        }
-
-        private static int RunNextUint<T>(TimeSpan timeout, T random)
-            where T : IRandom
-        {
-            int count = 0;
-            Stopwatch timer = Stopwatch.StartNew();
-            do
-            {
-                _ = random.NextUint();
-                ++count;
-            } while (timer.Elapsed < timeout);
-
-            return count;
-        }
-
-        private static int RunNextUintRange<T>(TimeSpan timeout, T random)
-            where T : IRandom
-        {
-            int count = 0;
-            Stopwatch timer = Stopwatch.StartNew();
-            do
-            {
-                _ = random.NextUint(1_000);
-                ++count;
-            } while (timer.Elapsed < timeout);
-
-            return count;
-        }
-
-        private static int RunNextFloat<T>(TimeSpan timeout, T random)
-            where T : IRandom
-        {
-            int count = 0;
-            Stopwatch timer = Stopwatch.StartNew();
-            do
-            {
-                _ = random.NextFloat();
-                ++count;
-            } while (timer.Elapsed < timeout);
-
-            return count;
-        }
-
-        private static int RunNextDouble<T>(TimeSpan timeout, T random)
-            where T : IRandom
-        {
-            int count = 0;
-            Stopwatch timer = Stopwatch.StartNew();
-            do
-            {
-                _ = random.NextDouble();
-                ++count;
-            } while (timer.Elapsed < timeout);
-
-            return count;
-        }
-    }
-}
+namespace UnityHelpers.Tests.Performance
+{
+    using System;
+    using System.Diagnostics;
+    using NUnit.Framework;
+    using UnityHelpers.Core.Random;
+
+    public sealed class RandomPerformanceTests
+    {
+        [Test]
+        public void Benchmark()
+        {
+            TimeSpan timeout = TimeSpan.FromSeconds(1.125);
+
+            UnityEngine.Debug.Log(
+                $"| Random | NextBool | Next | NextUInt | NextFloat | NextDouble | NextUint - Range | "
+            );
+            UnityEngine.Debug.Log(
+                $"| ------ | -------- | ---- | -------- | --------- | ---------- | ---------------- |"
+            );
+
+            RunTest(new PcgRandom(), timeout);
+            RunTest(new SystemRandom(), timeout);
+            RunTest(new SquirrelRandom(), timeout);
+            RunTest(new XorShiftRandom(), timeout);
+            RunTest(new DotNetRandom(), timeout);
+            RunTest(new WyRandom(), timeout);
+            RunTest(new SplitMix64(), timeout);
+            RunTest(new RomuDuo(), timeout);
+            RunTest(new XorShiroRandom(), timeout);
+        }
+
+        private static void RunTest<T>(T random, TimeSpan timeout)
+            where T : IRandom
+        {
+            int nextBool = RunNextBool(timeout, random);
+            int nextInt = RunNext(timeout, random);
+            int nextUint = RunNextUint(timeout, random);
+            int nextFloat = RunNextFloat(timeout, random);
+            int nextDouble = RunNextDouble(timeout, random);
+            int nextUintRange = RunNextUintRange(timeout, random);
+
+            UnityEngine.Debug.Log(
+                $"| {random.GetType().Name} | "
+                    + $"{(nextBool / timeout.TotalSeconds):N0} | "
+                    + $"{(nextInt / timeout.TotalSeconds):N0} | "
+                    + $"{(nextUint / timeout.TotalSeconds):N0} | "
+                    + $"{(nextFloat / timeout.TotalSeconds):N0} | "
+                    + $"{(nextDouble / timeout.TotalSeconds):N0} |"
+                    + $"{(nextUintRange / timeout.TotalSeconds):N0} |"
+            );
+        }
+
+        // Copy-pasta'd for maximum speed
+        private static int RunNext<T>(TimeSpan timeout, T random)
+            where T : IRandom
+        {
+            int count = 0;
+            Stopwatch timer = Stopwatch.StartNew();
+            do
+            {
+                _ = random.Next();
+                ++count;
+            } while (timer.Elapsed < timeout);
+
+            return count;
+        }
+
+        private static int RunNextBool<T>(TimeSpan timeout, T random)
+            where T : IRandom
+        {
+            int count = 0;
+            Stopwatch timer = Stopwatch.StartNew();
+            do
+            {
+                _ = random.NextBool();
+                ++count;
+            } while (timer.Elapsed < timeout);
+
+            return count;
+        }
+
+        private static int RunNextUint<T>(TimeSpan timeout, T random)
+            where T : IRandom
+        {
+            int count = 0;
+            Stopwatch timer = Stopwatch.StartNew();
+            do
+            {
+                _ = random.NextUint();
+                ++count;
+            } while (timer.Elapsed < timeout);
+
+            return count;
+        }
+
+        private static int RunNextUintRange<T>(TimeSpan timeout, T random)
+            where T : IRandom
+        {
+            int count = 0;
+            Stopwatch timer = Stopwatch.StartNew();
+            do
+            {
+                _ = random.NextUint(1_000);
+                ++count;
+            } while (timer.Elapsed < timeout);
+
+            return count;
+        }
+
+        private static int RunNextFloat<T>(TimeSpan timeout, T random)
+            where T : IRandom
+        {
+            int count = 0;
+            Stopwatch timer = Stopwatch.StartNew();
+            do
+            {
+                _ = random.NextFloat();
+                ++count;
+            } while (timer.Elapsed < timeout);
+
+            return count;
+        }
+
+        private static int RunNextDouble<T>(TimeSpan timeout, T random)
+            where T : IRandom
+        {
+            int count = 0;
+            Stopwatch timer = Stopwatch.StartNew();
+            do
+            {
+                _ = random.NextDouble();
+                ++count;
+            } while (timer.Elapsed < timeout);
+
+            return count;
+        }
+    }
+}

package/Tests/Runtime/Performance/RandomPerformanceTests.cs.meta

@@ -1,11 +1,11 @@
-fileFormatVersion: 2
-guid: cd362cfc7f5bcc74fa5a42a2670f070c
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: cd362cfc7f5bcc74fa5a42a2670f070c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Performance/RelationComponentPerformanceTests.cs

@@ -0,0 +1,37 @@
+namespace UnityHelpers.Tests.Performance
+{
+    using System;
+    using System.Diagnostics;
+    using Components;
+    using Core.Attributes;
+    using NUnit.Framework;
+    using UnityEngine;
+
+    public sealed class RelationComponentPerformanceTests
+    {
+        [Test]
+        public void RelationalPerformanceTest()
+        {
+            int count = 0;
+
+            GameObject go = new("Test", typeof(RelationalComponentTester));
+            RelationalComponentTester tester = go.GetComponent<RelationalComponentTester>();
+            // Pre-warm
+            tester.AssignRelationalComponents();
+
+            TimeSpan timeout = TimeSpan.FromSeconds(10);
+            Stopwatch timer = Stopwatch.StartNew();
+            do
+            {
+                tester.AssignRelationalComponents();
+                ++count;
+            } while (timer.Elapsed < timeout);
+
+            UnityEngine.Debug.Log($"Averaged {count / timeout.TotalSeconds} operations / second.");
+
+            Assert.AreNotEqual(0, tester._childColliders.Length);
+            Assert.AreNotEqual(0, tester._parentColliders.Length);
+            Assert.AreNotEqual(0, tester._siblingColliders.Length);
+        }
+    }
+}

package/Tests/Runtime/Performance/RelationComponentPerformanceTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 08f1585008ba43b0b666e27eb45f0768
+timeCreated: 1742065801

package/Tests/Runtime/Performance/SpatialTreePerformanceTest.cs

@@ -1,154 +1,154 @@
-namespace UnityHelpers.Tests.Performance
-{
-    using System;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Diagnostics;
-    using System.Linq;
-    using System.Threading.Tasks;
-    using Core.DataStructure;
-    using NUnit.Framework;
-    using UnityEngine;
-    using UnityEngine.TestTools;
-
-    public abstract class SpatialTreePerformanceTest<TTree>
-        where TTree : ISpatialTree<Vector2>
-    {
-        protected abstract TTree CreateTree(IEnumerable<Vector2> points);
-
-        [UnityTest]
-        public IEnumerator Performance()
-        {
-            UnityEngine.Debug.Log("| Operation | Operations / Second |");
-            UnityEngine.Debug.Log("| --------- | ------------------- |");
-
-            Vector2[] points = new Vector2[1_000_000];
-            float radius = 500;
-            ParallelLoopResult result = Parallel.For(
-                0,
-                1_000_000,
-                index =>
-                {
-                    // ReSharper disable once PossibleLossOfFraction
-                    points[index] = new Vector2(index % 1_000, index / 1_000);
-                }
-            );
-
-            while (!result.IsCompleted)
-            {
-                yield return null;
-            }
-
-            Stopwatch timer = Stopwatch.StartNew();
-            TTree tree = CreateTree(points);
-            timer.Stop();
-            UnityEngine.Debug.Log(
-                $"| Construction (1 million points) | {(int)Math.Floor(1 / timer.Elapsed.TotalSeconds)} ({timer.Elapsed.TotalSeconds} seconds total) |"
-            );
-            Vector2 center = tree.Boundary.center;
-            int count = 0;
-            TimeSpan timeout = TimeSpan.FromSeconds(1);
-            timer.Restart();
-            do
-            {
-                int elementsInRange = tree.GetElementsInRange(center, radius).Count();
-                Assert.AreEqual(785456, elementsInRange);
-                ++count;
-            } while (timer.Elapsed < timeout);
-
-            UnityEngine.Debug.Log(
-                $"| Elements In Range - Full | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
-            );
-
-            radius /= 2f;
-            count = 0;
-            timer.Restart();
-            do
-            {
-                int elementsInRange = tree.GetElementsInRange(center, radius).Count();
-                Assert.AreEqual(196364, elementsInRange);
-                ++count;
-            } while (timer.Elapsed < timeout);
-            UnityEngine.Debug.Log(
-                $"| Elements In Range - Half | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
-            );
-
-            radius /= 2f;
-            count = 0;
-            timer.Restart();
-            do
-            {
-                int elementsInRange = tree.GetElementsInRange(center, radius).Count();
-                Assert.AreEqual(49080, elementsInRange);
-                ++count;
-            } while (timer.Elapsed < timeout);
-            UnityEngine.Debug.Log(
-                $"| Elements In Range - Quarter | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
-            );
-
-            radius = 1f;
-            count = 0;
-            timer.Restart();
-            do
-            {
-                int elementsInRange = tree.GetElementsInRange(center, radius).Count();
-                Assert.AreEqual(4, elementsInRange);
-                ++count;
-            } while (timer.Elapsed < timeout);
-            UnityEngine.Debug.Log(
-                $"| Elements In Range - 1 Range | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
-            );
-
-            int nearestNeighborCount = 500;
-            List<Vector2> nearestNeighbors = new();
-            count = 0;
-            timer.Restart();
-            do
-            {
-                tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
-                Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
-                ++count;
-            } while (timer.Elapsed < timeout);
-            UnityEngine.Debug.Log(
-                $"| ANN - 500 | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
-            );
-
-            nearestNeighborCount = 100;
-            count = 0;
-            timer.Restart();
-            do
-            {
-                tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
-                Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
-                ++count;
-            } while (timer.Elapsed < timeout);
-            UnityEngine.Debug.Log(
-                $"| ANN - 100 | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
-            );
-
-            nearestNeighborCount = 10;
-            count = 0;
-            timer.Restart();
-            do
-            {
-                tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
-                Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
-                ++count;
-            } while (timer.Elapsed < timeout);
-            UnityEngine.Debug.Log(
-                $"| ANN - 10 | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
-            );
-
-            nearestNeighborCount = 1;
-            count = 0;
-            timer.Restart();
-            do
-            {
-                tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
-                Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
-                ++count;
-            } while (timer.Elapsed < timeout);
-            UnityEngine.Debug.Log($"| ANN - 1 | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
-        }
-    }
-}
+namespace UnityHelpers.Tests.Performance
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Linq;
+    using System.Threading.Tasks;
+    using Core.DataStructure;
+    using NUnit.Framework;
+    using UnityEngine;
+    using UnityEngine.TestTools;
+
+    public abstract class SpatialTreePerformanceTest<TTree>
+        where TTree : ISpatialTree<Vector2>
+    {
+        protected abstract TTree CreateTree(IEnumerable<Vector2> points);
+
+        [UnityTest]
+        public IEnumerator Performance()
+        {
+            UnityEngine.Debug.Log("| Operation | Operations / Second |");
+            UnityEngine.Debug.Log("| --------- | ------------------- |");
+
+            Vector2[] points = new Vector2[1_000_000];
+            float radius = 500;
+            ParallelLoopResult result = Parallel.For(
+                0,
+                1_000_000,
+                index =>
+                {
+                    // ReSharper disable once PossibleLossOfFraction
+                    points[index] = new Vector2(index % 1_000, index / 1_000);
+                }
+            );
+
+            while (!result.IsCompleted)
+            {
+                yield return null;
+            }
+
+            Stopwatch timer = Stopwatch.StartNew();
+            TTree tree = CreateTree(points);
+            timer.Stop();
+            UnityEngine.Debug.Log(
+                $"| Construction (1 million points) | {(int)Math.Floor(1 / timer.Elapsed.TotalSeconds)} ({timer.Elapsed.TotalSeconds} seconds total) |"
+            );
+            Vector2 center = tree.Boundary.center;
+            int count = 0;
+            TimeSpan timeout = TimeSpan.FromSeconds(1);
+            timer.Restart();
+            do
+            {
+                int elementsInRange = tree.GetElementsInRange(center, radius).Count();
+                Assert.AreEqual(785456, elementsInRange);
+                ++count;
+            } while (timer.Elapsed < timeout);
+
+            UnityEngine.Debug.Log(
+                $"| Elements In Range - Full | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
+
+            radius /= 2f;
+            count = 0;
+            timer.Restart();
+            do
+            {
+                int elementsInRange = tree.GetElementsInRange(center, radius).Count();
+                Assert.AreEqual(196364, elementsInRange);
+                ++count;
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| Elements In Range - Half | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
+
+            radius /= 2f;
+            count = 0;
+            timer.Restart();
+            do
+            {
+                int elementsInRange = tree.GetElementsInRange(center, radius).Count();
+                Assert.AreEqual(49080, elementsInRange);
+                ++count;
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| Elements In Range - Quarter | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
+
+            radius = 1f;
+            count = 0;
+            timer.Restart();
+            do
+            {
+                int elementsInRange = tree.GetElementsInRange(center, radius).Count();
+                Assert.AreEqual(4, elementsInRange);
+                ++count;
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| Elements In Range - 1 Range | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
+
+            int nearestNeighborCount = 500;
+            List<Vector2> nearestNeighbors = new();
+            count = 0;
+            timer.Restart();
+            do
+            {
+                tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
+                Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
+                ++count;
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| ANN - 500 | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
+
+            nearestNeighborCount = 100;
+            count = 0;
+            timer.Restart();
+            do
+            {
+                tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
+                Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
+                ++count;
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| ANN - 100 | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
+
+            nearestNeighborCount = 10;
+            count = 0;
+            timer.Restart();
+            do
+            {
+                tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
+                Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
+                ++count;
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| ANN - 10 | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
+
+            nearestNeighborCount = 1;
+            count = 0;
+            timer.Restart();
+            do
+            {
+                tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
+                Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
+                ++count;
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log($"| ANN - 1 | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+        }
+    }
+}