com.wallstop-studios.unity-helpers 2.0.0-rc14 → 2.0.0-rc16

package/README.md

@@ -1,2 +1,2 @@
 # A Grab-Bag
-Various Unity Helpers. Includes deterministic randoms including a PCGRandom implementation,
+Various Unity Helpers. Includes many deterministic, seedable random number generators.

package/Runtime/Core/DataStructure/KDTree.cs

@@ -6,6 +6,7 @@
     using System.Linq;
     using Extension;
     using UnityEngine;
+    using Utils;
 
     [Serializable]
     public sealed class KDTree<T> : ISpatialTree<T>
@@ -13,7 +14,7 @@
         public delegate float Axis<in V>(V element);
 
         [Serializable]
-        private sealed class KDTreeNode<V>
+        public sealed class KDTreeNode<V>
         {
             public readonly Bounds boundary;
             public readonly KDTreeNode<V> left;
@@ -21,7 +22,13 @@
             public readonly V[] elements;
             public readonly bool isTerminal;
 
-            public KDTreeNode(List<V> elements, Func<V, Vector2> elementTransformer, int bucketSize, bool isXAxis, bool balanced)
+            public KDTreeNode(
+                List<V> elements,
+                Func<V, Vector2> elementTransformer,
+                int bucketSize,
+                bool isXAxis,
+                bool balanced
+            )
             {
                 boundary = elements.Select(elementTransformer).GetBounds() ?? new Bounds();
                 this.elements = elements.ToArray();
@@ -44,21 +51,65 @@
                     elements.Sort(Comparison);
 
                     int cutoff = elements.Count / 2;
-                    left = new KDTreeNode<V>(elements.Take(cutoff).ToList(), elementTransformer, bucketSize, !isXAxis, true);
-                    right = new KDTreeNode<V>(elements.Skip(cutoff).ToList(), elementTransformer, bucketSize, !isXAxis, true);
+                    left = new KDTreeNode<V>(
+                        elements.Take(cutoff).ToList(),
+                        elementTransformer,
+                        bucketSize,
+                        !isXAxis,
+                        true
+                    );
+                    right = new KDTreeNode<V>(
+                        elements.Skip(cutoff).ToList(),
+                        elementTransformer,
+                        bucketSize,
+                        !isXAxis,
+                        true
+                    );
                 }
                 else
                 {
                     Vector2 cutoff = boundary.center;
                     if (isXAxis)
                     {
-                        left = new KDTreeNode<V>(elements.Where(element => elementTransformer(element).x <= cutoff.x).ToList(), elementTransformer, bucketSize, false, false);
-                        right = new KDTreeNode<V>(elements.Where(element => cutoff.x < elementTransformer(element).x).ToList(), elementTransformer, bucketSize, false, false);
+                        left = new KDTreeNode<V>(
+                            elements
+                                .Where(element => elementTransformer(element).x <= cutoff.x)
+                                .ToList(),
+                            elementTransformer,
+                            bucketSize,
+                            false,
+                            false
+                        );
+                        right = new KDTreeNode<V>(
+                            elements
+                                .Where(element => cutoff.x < elementTransformer(element).x)
+                                .ToList(),
+                            elementTransformer,
+                            bucketSize,
+                            false,
+                            false
+                        );
                     }
                     else
                     {
-                        left = new KDTreeNode<V>(elements.Where(element => elementTransformer(element).y <= cutoff.y).ToList(), elementTransformer, bucketSize, true, false);
-                        right = new KDTreeNode<V>(elements.Where(element => cutoff.y < elementTransformer(element).y).ToList(), elementTransformer, bucketSize, true, false);
+                        left = new KDTreeNode<V>(
+                            elements
+                                .Where(element => elementTransformer(element).y <= cutoff.y)
+                                .ToList(),
+                            elementTransformer,
+                            bucketSize,
+                            true,
+                            false
+                        );
+                        right = new KDTreeNode<V>(
+                            elements
+                                .Where(element => cutoff.y < elementTransformer(element).y)
+                                .ToList(),
+                            elementTransformer,
+                            bucketSize,
+                            true,
+                            false
+                        );
                     }
                 }
             }
@@ -74,22 +125,42 @@
         private readonly Func<T, Vector2> _elementTransformer;
         private readonly KDTreeNode<T> _head;
 
-        public KDTree(IEnumerable<T> points, Func<T, Vector2> elementTransformer, int bucketSize = DefaultBucketSize, bool balanced = true)
+        public KDTree(
+            IEnumerable<T> points,
+            Func<T, Vector2> elementTransformer,
+            int bucketSize = DefaultBucketSize,
+            bool balanced = true
+        )
         {
-            _elementTransformer = elementTransformer ?? throw new ArgumentNullException(nameof(elementTransformer));
-            elements = points?.ToImmutableArray() ?? throw new ArgumentNullException(nameof(points));
+            _elementTransformer =
+                elementTransformer ?? throw new ArgumentNullException(nameof(elementTransformer));
+            elements =
+                points?.ToImmutableArray() ?? throw new ArgumentNullException(nameof(points));
             _bounds = elements.Select(elementTransformer).GetBounds() ?? new Bounds();
-            _head = new KDTreeNode<T>(elements.ToList(), elementTransformer, bucketSize: bucketSize, isXAxis:true, balanced: balanced);
+            _head = new KDTreeNode<T>(
+                elements.ToList(),
+                elementTransformer,
+                bucketSize: bucketSize,
+                isXAxis: true,
+                balanced: balanced
+            );
         }
 
         public IEnumerable<T> GetElementsInBounds(Bounds bounds)
+        {
+            Stack<KDTreeNode<T>> buffer = Buffers<KDTreeNode<T>>.Stack;
+            return GetElementsInBounds(bounds, buffer);
+        }
+
+        public IEnumerable<T> GetElementsInBounds(Bounds bounds, Stack<KDTreeNode<T>> nodeBuffer)
         {
             if (!bounds.FastIntersects2D(_bounds))
             {
                 yield break;
             }
 
-            Stack<KDTreeNode<T>> nodesToVisit = new();
+            Stack<KDTreeNode<T>> nodesToVisit = nodeBuffer ?? new Stack<KDTreeNode<T>>();
+            nodesToVisit.Clear();
             nodesToVisit.Push(_head);
 
             while (nodesToVisit.TryPop(out KDTreeNode<T> currentNode))
@@ -131,22 +202,49 @@
             }
         }
 
+        public void GetApproximateNearestNeighbors(
+            Vector2 position,
+            int count,
+            List<T> nearestNeighbors
+        )
+        {
+            Stack<KDTreeNode<T>> nodeBuffer = Buffers<KDTreeNode<T>>.Stack;
+            HashSet<T> nearestNeighborBuffer = Buffers<T>.HashSet;
+            GetApproximateNearestNeighbors(
+                position,
+                count,
+                nearestNeighbors,
+                nodeBuffer,
+                nearestNeighborBuffer
+            );
+        }
+
         // Heavily adapted http://homepage.divms.uiowa.edu/%7Ekvaradar/sp2012/daa/ann.pdf
-        public void GetApproximateNearestNeighbors(Vector2 position, int count, List<T> nearestNeighbors)
+        public void GetApproximateNearestNeighbors(
+            Vector2 position,
+            int count,
+            List<T> nearestNeighbors,
+            Stack<KDTreeNode<T>> nodeBuffer,
+            HashSet<T> nearestNeighborBuffer
+        )
         {
             nearestNeighbors.Clear();
 
             KDTreeNode<T> current = _head;
-            Stack<KDTreeNode<T>> stack = new();
+            Stack<KDTreeNode<T>> stack = nodeBuffer ?? new Stack<KDTreeNode<T>>();
+            stack.Clear();
             stack.Push(_head);
-            HashSet<T> nearestNeighborsSet = new(count);
+            HashSet<T> nearestNeighborsSet = nearestNeighborBuffer ?? new HashSet<T>(count);
+            nearestNeighborsSet.Clear();
 
             while (!current.isTerminal)
             {
                 KDTreeNode<T> left = current.left;
                 KDTreeNode<T> right = current.right;
-                if (((Vector2)left.boundary.center - position).sqrMagnitude <
-                    ((Vector2)right.boundary.center - position).sqrMagnitude)
+                if (
+                    ((Vector2)left.boundary.center - position).sqrMagnitude
+                    < ((Vector2)right.boundary.center - position).sqrMagnitude
+                )
                 {
                     stack.Push(left);
                     current = left;
@@ -177,10 +275,16 @@
             nearestNeighbors.AddRange(nearestNeighborsSet);
             if (count < nearestNeighbors.Count)
             {
-                int NearestComparison(T lhs, T rhs) => (_elementTransformer(lhs) - position).sqrMagnitude.CompareTo((_elementTransformer(rhs) - position).sqrMagnitude);
                 nearestNeighbors.Sort(NearestComparison);
                 nearestNeighbors.RemoveRange(count, nearestNeighbors.Count - count);
             }
+
+            return;
+
+            int NearestComparison(T lhs, T rhs) =>
+                (_elementTransformer(lhs) - position).sqrMagnitude.CompareTo(
+                    (_elementTransformer(rhs) - position).sqrMagnitude
+                );
         }
     }
 }

package/Runtime/Core/DataStructure/QuadTree.cs

@@ -6,6 +6,7 @@
     using System.Linq;
     using Extension;
     using UnityEngine;
+    using Utils;
 
     [Serializable]
     public sealed class QuadTree<T> : ISpatialTree<T>
@@ -13,17 +14,21 @@
         private const int NumChildren = 4;
 
         [Serializable]
-        private sealed class QuadTreeNode<V>
+        public sealed class QuadTreeNode<V>
         {
             private static readonly List<V> Buffer = new();
 
             public readonly Bounds boundary;
-            public readonly QuadTreeNode<V>[] children;
+            internal readonly QuadTreeNode<V>[] children;
             public readonly V[] elements;
             public readonly bool isTerminal;
 
-            public QuadTreeNode(V[] elements, Func<V, Vector2> elementTransformer, Bounds boundary,
-                int bucketSize)
+            public QuadTreeNode(
+                V[] elements,
+                Func<V, Vector2> elementTransformer,
+                Bounds boundary,
+                int bucketSize
+            )
             {
                 this.boundary = boundary;
                 this.elements = elements;
@@ -34,16 +39,44 @@
                     return;
                 }
                 children = new QuadTreeNode<V>[NumChildren];
-                
+
                 Vector3 quadrantSize = boundary.size / 2f;
                 Vector2 halfQuadrantSize = quadrantSize / 2f;
 
                 Bounds[] quadrants =
                 {
-                    new Bounds(new Vector3(boundary.center.x - halfQuadrantSize.x, boundary.center.y + halfQuadrantSize.y, boundary.center.z), quadrantSize),
-                    new Bounds(new Vector3(boundary.center.x + halfQuadrantSize.x, boundary.center.y + halfQuadrantSize.y, boundary.center.z), quadrantSize),
-                    new Bounds(new Vector3(boundary.center.x + halfQuadrantSize.x, boundary.center.y - halfQuadrantSize.y, boundary.center.z), quadrantSize),
-                    new Bounds(new Vector3(boundary.center.x - halfQuadrantSize.x, boundary.center.y - halfQuadrantSize.y, boundary.center.z), quadrantSize),
+                    new Bounds(
+                        new Vector3(
+                            boundary.center.x - halfQuadrantSize.x,
+                            boundary.center.y + halfQuadrantSize.y,
+                            boundary.center.z
+                        ),
+                        quadrantSize
+                    ),
+                    new Bounds(
+                        new Vector3(
+                            boundary.center.x + halfQuadrantSize.x,
+                            boundary.center.y + halfQuadrantSize.y,
+                            boundary.center.z
+                        ),
+                        quadrantSize
+                    ),
+                    new Bounds(
+                        new Vector3(
+                            boundary.center.x + halfQuadrantSize.x,
+                            boundary.center.y - halfQuadrantSize.y,
+                            boundary.center.z
+                        ),
+                        quadrantSize
+                    ),
+                    new Bounds(
+                        new Vector3(
+                            boundary.center.x - halfQuadrantSize.x,
+                            boundary.center.y - halfQuadrantSize.y,
+                            boundary.center.z
+                        ),
+                        quadrantSize
+                    ),
                 };
 
                 for (int i = 0; i < quadrants.Length; ++i)
@@ -58,7 +91,12 @@
                         }
                     }
 
-                    children[i] = new QuadTreeNode<V>(Buffer.ToArray(), elementTransformer, quadrant, bucketSize);
+                    children[i] = new QuadTreeNode<V>(
+                        Buffer.ToArray(),
+                        elementTransformer,
+                        quadrant,
+                        bucketSize
+                    );
                 }
             }
         }
@@ -73,23 +111,41 @@
         private readonly Func<T, Vector2> _elementTransformer;
         private readonly QuadTreeNode<T> _head;
 
-        public QuadTree(IEnumerable<T> points, Func<T, Vector2> elementTransformer, Bounds? boundary = null,
-            int bucketSize = DefaultBucketSize)
+        public QuadTree(
+            IEnumerable<T> points,
+            Func<T, Vector2> elementTransformer,
+            Bounds? boundary = null,
+            int bucketSize = DefaultBucketSize
+        )
         {
-            _elementTransformer = elementTransformer ?? throw new ArgumentNullException(nameof(elementTransformer));
-            elements = points?.ToImmutableArray() ?? throw new ArgumentNullException(nameof(points));
+            _elementTransformer =
+                elementTransformer ?? throw new ArgumentNullException(nameof(elementTransformer));
+            elements =
+                points?.ToImmutableArray() ?? throw new ArgumentNullException(nameof(points));
             _bounds = boundary ?? elements.Select(elementTransformer).GetBounds() ?? new Bounds();
-            _head = new QuadTreeNode<T>(elements.ToArray(), elementTransformer, _bounds, bucketSize);
+            _head = new QuadTreeNode<T>(
+                elements.ToArray(),
+                elementTransformer,
+                _bounds,
+                bucketSize
+            );
         }
 
         public IEnumerable<T> GetElementsInBounds(Bounds bounds)
+        {
+            Stack<QuadTreeNode<T>> nodeBuffer = Buffers<QuadTreeNode<T>>.Stack;
+            return GetElementsInBounds(bounds, nodeBuffer);
+        }
+
+        public IEnumerable<T> GetElementsInBounds(Bounds bounds, Stack<QuadTreeNode<T>> nodeBuffer)
         {
             if (!bounds.FastIntersects2D(_bounds))
             {
                 yield break;
             }
 
-            Stack<QuadTreeNode<T>> nodesToVisit = new();
+            Stack<QuadTreeNode<T>> nodesToVisit = nodeBuffer ?? new Stack<QuadTreeNode<T>>();
+            nodesToVisit.Clear();
             nodesToVisit.Push(_head);
 
             while (nodesToVisit.TryPop(out QuadTreeNode<T> currentNode))
@@ -134,19 +190,47 @@
             }
         }
 
+        public void GetApproximateNearestNeighbors(
+            Vector2 position,
+            int count,
+            List<T> nearestNeighbors
+        )
+        {
+            Stack<QuadTreeNode<T>> nodeBuffer = Buffers<QuadTreeNode<T>>.Stack;
+            List<QuadTreeNode<T>> childrenBuffer = Buffers<QuadTreeNode<T>>.List;
+            HashSet<T> nearestNeighborBuffer = Buffers<T>.HashSet;
+            GetApproximateNearestNeighbors(
+                position,
+                count,
+                nearestNeighbors,
+                nodeBuffer,
+                childrenBuffer,
+                nearestNeighborBuffer
+            );
+        }
+
         // Heavily adapted http://homepage.divms.uiowa.edu/%7Ekvaradar/sp2012/daa/ann.pdf
-        public void GetApproximateNearestNeighbors(Vector2 position, int count, List<T> nearestNeighbors)
+        public void GetApproximateNearestNeighbors(
+            Vector2 position,
+            int count,
+            List<T> nearestNeighbors,
+            Stack<QuadTreeNode<T>> nodeBuffer,
+            List<QuadTreeNode<T>> childrenBuffer,
+            HashSet<T> nearestNeighborBuffer
+        )
         {
             nearestNeighbors.Clear();
 
             QuadTreeNode<T> current = _head;
-            Stack<QuadTreeNode<T>> stack = new();
+            Stack<QuadTreeNode<T>> stack = nodeBuffer ?? new Stack<QuadTreeNode<T>>();
+            stack.Clear();
             stack.Push(_head);
-            List<QuadTreeNode<T>> childrenCopy = new(NumChildren);
-            HashSet<T> nearestNeighborsSet = new(count);
+            List<QuadTreeNode<T>> childrenCopy =
+                childrenBuffer ?? new List<QuadTreeNode<T>>(NumChildren);
+            childrenCopy.Clear();
+            HashSet<T> nearestNeighborsSet = nearestNeighborBuffer ?? new HashSet<T>(count);
+            nearestNeighborsSet.Clear();
 
-            int Comparison(QuadTreeNode<T> lhs, QuadTreeNode<T> rhs) => ((Vector2)lhs.boundary.center - position).sqrMagnitude.CompareTo(((Vector2)rhs.boundary.center - position).sqrMagnitude);
-            
             while (!current.isTerminal)
             {
                 childrenCopy.Clear();
@@ -175,10 +259,21 @@
             nearestNeighbors.AddRange(nearestNeighborsSet);
             if (count < nearestNeighbors.Count)
             {
-                int NearestComparison(T lhs, T rhs) => (_elementTransformer(lhs) - position).sqrMagnitude.CompareTo((_elementTransformer(rhs) - position).sqrMagnitude);
                 nearestNeighbors.Sort(NearestComparison);
                 nearestNeighbors.RemoveRange(count, nearestNeighbors.Count - count);
             }
+
+            return;
+
+            int Comparison(QuadTreeNode<T> lhs, QuadTreeNode<T> rhs) =>
+                ((Vector2)lhs.boundary.center - position).sqrMagnitude.CompareTo(
+                    ((Vector2)rhs.boundary.center - position).sqrMagnitude
+                );
+
+            int NearestComparison(T lhs, T rhs) =>
+                (_elementTransformer(lhs) - position).sqrMagnitude.CompareTo(
+                    (_elementTransformer(rhs) - position).sqrMagnitude
+                );
         }
     }
 }

package/Runtime/Core/DataStructure/RTree.cs

@@ -6,19 +6,25 @@
     using System.Linq;
     using Extension;
     using UnityEngine;
+    using Utils;
 
     [Serializable]
     public sealed class RTree<T>
     {
         [Serializable]
-        private sealed class RTreeNode<V>
+        public sealed class RTreeNode<V>
         {
             public readonly Bounds boundary;
-            public readonly RTreeNode<V>[] children;
+            internal readonly RTreeNode<V>[] children;
             public readonly V[] elements;
             public readonly bool isTerminal;
 
-            public RTreeNode(List<V> elements, Func<V, Bounds> elementTransformer, int bucketSize, int branchFactor)
+            public RTreeNode(
+                List<V> elements,
+                Func<V, Bounds> elementTransformer,
+                int bucketSize,
+                int branchFactor
+            )
             {
                 float minX = float.MaxValue;
                 float minY = float.MaxValue;
@@ -35,7 +41,13 @@
                     maxY = Math.Max(maxY, max.y);
                 }
 
-                boundary = elements.Count <= 0 ? new Bounds() : new Bounds(new Vector3(minX + (maxX - minX) / 2, minY + (maxY - minY) / 2), new Vector3(maxX - minX, maxY - minY));
+                boundary =
+                    elements.Count <= 0
+                        ? new Bounds()
+                        : new Bounds(
+                            new Vector3(minX + (maxX - minX) / 2, minY + (maxY - minY) / 2),
+                            new Vector3(maxX - minX, maxY - minY)
+                        );
                 this.elements = elements.ToArray();
                 isTerminal = elements.Count <= bucketSize;
                 if (isTerminal)
@@ -61,28 +73,44 @@
                 double slicesPerAxis = Math.Sqrt(branchFactor);
                 int rectanglesPerPagePerAxis = (int)(slicesPerAxis * targetSize);
 
-                int XAxis(V lhs, V rhs)
-                {
-                    return elementTransformer(lhs).center.x.CompareTo(elementTransformer(rhs).center.x);
-                }
-
-                int YAxis(V lhs, V rhs)
-                {
-                    return elementTransformer(lhs).center.y.CompareTo(elementTransformer(rhs).center.y);
-                }
-
                 elements.Sort(XAxis);
-                foreach (List<V> xSlice in elements.Partition(rectanglesPerPagePerAxis).Select(enumerable => enumerable as List<V> ?? enumerable.ToList()))
+                foreach (
+                    List<V> xSlice in elements
+                        .Partition(rectanglesPerPagePerAxis)
+                        .Select(enumerable => enumerable as List<V> ?? enumerable.ToList())
+                )
                 {
                     xSlice.Sort(YAxis);
-                    foreach (List<V> ySlice in xSlice.Partition(intTargetSize).Select(enumerable => enumerable as List<V> ?? enumerable.ToList()))
+                    foreach (
+                        List<V> ySlice in xSlice
+                            .Partition(intTargetSize)
+                            .Select(enumerable => enumerable as List<V> ?? enumerable.ToList())
+                    )
                     {
-                        RTreeNode<V> node = new(ySlice, elementTransformer, bucketSize, branchFactor);
+                        RTreeNode<V> node = new(
+                            ySlice,
+                            elementTransformer,
+                            bucketSize,
+                            branchFactor
+                        );
                         tempChildren.Add(node);
                     }
                 }
 
                 children = tempChildren.ToArray();
+                return;
+
+                int XAxis(V lhs, V rhs)
+                {
+                    return elementTransformer(lhs)
+                        .center.x.CompareTo(elementTransformer(rhs).center.x);
+                }
+
+                int YAxis(V lhs, V rhs)
+                {
+                    return elementTransformer(lhs)
+                        .center.y.CompareTo(elementTransformer(rhs).center.y);
+                }
             }
         }
 
@@ -97,16 +125,30 @@
         private readonly RTreeNode<T> _head;
 
         public RTree(
-            IEnumerable<T> points, Func<T, Bounds> elementTransformer, int bucketSize = DefaultBucketSize,
-            int branchFactor = DefaultBranchFactor)
+            IEnumerable<T> points,
+            Func<T, Bounds> elementTransformer,
+            int bucketSize = DefaultBucketSize,
+            int branchFactor = DefaultBranchFactor
+        )
         {
-            _elementTransformer = elementTransformer ?? throw new ArgumentNullException(nameof(elementTransformer));
-            elements = points?.ToImmutableArray() ?? throw new ArgumentNullException(nameof(points));
+            _elementTransformer =
+                elementTransformer ?? throw new ArgumentNullException(nameof(elementTransformer));
+            elements =
+                points?.ToImmutableArray() ?? throw new ArgumentNullException(nameof(points));
             _bounds = elements.Select(elementTransformer).GetBounds() ?? new Bounds();
-            _head = new RTreeNode<T>(elements.ToList(), elementTransformer, bucketSize, branchFactor);
+            _head = new RTreeNode<T>(
+                elements.ToList(),
+                elementTransformer,
+                bucketSize,
+                branchFactor
+            );
         }
 
-        public IEnumerable<T> GetElementsInRange(Vector2 position, float range, float minimumRange = 0f)
+        public IEnumerable<T> GetElementsInRange(
+            Vector2 position,
+            float range,
+            float minimumRange = 0f
+        )
         {
             Circle area = new(position, range);
             if (0 < minimumRange)
@@ -115,25 +157,10 @@
                 return GetElementsInBounds(
                         new Bounds(
                             new Vector3(position.x, position.y, 0f),
-                            new Vector3(range * 2f, range * 2f, 1f)))
-                    .Where(
-                        element =>
-                        {
-                            Bounds elementBoundary = _elementTransformer(element);
-                            if (!area.Intersects(elementBoundary))
-                            {
-                                return false;
-                            }
-
-                            return !minimumArea.Intersects(elementBoundary);
-                        });
-            }
-            return GetElementsInBounds(
-                    new Bounds(
-                        new Vector3(position.x, position.y, 0f),
-                        new Vector3(range * 2f, range * 2f, 1f)))
-                .Where(
-                    element =>
+                            new Vector3(range * 2f, range * 2f, 1f)
+                        )
+                    )
+                    .Where(element =>
                     {
                         Bounds elementBoundary = _elementTransformer(element);
                         if (!area.Intersects(elementBoundary))
@@ -141,18 +168,42 @@
                             return false;
                         }
 
-                        return true;
+                        return !minimumArea.Intersects(elementBoundary);
                     });
+            }
+            return GetElementsInBounds(
+                    new Bounds(
+                        new Vector3(position.x, position.y, 0f),
+                        new Vector3(range * 2f, range * 2f, 1f)
+                    )
+                )
+                .Where(element =>
+                {
+                    Bounds elementBoundary = _elementTransformer(element);
+                    if (!area.Intersects(elementBoundary))
+                    {
+                        return false;
+                    }
+
+                    return true;
+                });
         }
 
         public IEnumerable<T> GetElementsInBounds(Bounds bounds)
+        {
+            Stack<RTreeNode<T>> nodeBuffer = Buffers<RTreeNode<T>>.Stack;
+            return GetElementsInBounds(bounds, nodeBuffer);
+        }
+
+        public IEnumerable<T> GetElementsInBounds(Bounds bounds, Stack<RTreeNode<T>> nodeBuffer)
         {
             if (!bounds.FastIntersects2D(_bounds))
             {
                 yield break;
             }
 
-            Stack<RTreeNode<T>> nodesToVisit = new();
+            Stack<RTreeNode<T>> nodesToVisit = nodeBuffer ?? new Stack<RTreeNode<T>>();
+            nodeBuffer.Clear();
             nodesToVisit.Push(_head);
 
             while (nodesToVisit.TryPop(out RTreeNode<T> currentNode))
@@ -197,18 +248,45 @@
             }
         }
 
+        public void GetApproximateNearestNeighbors(
+            Vector2 position,
+            int count,
+            List<T> nearestNeighbors
+        )
+        {
+            Stack<RTreeNode<T>> nodeBuffer = Buffers<RTreeNode<T>>.Stack;
+            List<RTreeNode<T>> childrenBuffer = Buffers<RTreeNode<T>>.List;
+            HashSet<T> nearestNeighborBuffer = Buffers<T>.HashSet;
+            GetApproximateNearestNeighbors(
+                position,
+                count,
+                nearestNeighbors,
+                nodeBuffer,
+                childrenBuffer,
+                nearestNeighborBuffer
+            );
+        }
+
         // Heavily adapted http://homepage.divms.uiowa.edu/%7Ekvaradar/sp2012/daa/ann.pdf
-        public void GetApproximateNearestNeighbors(Vector2 position, int count, List<T> nearestNeighbors)
+        public void GetApproximateNearestNeighbors(
+            Vector2 position,
+            int count,
+            List<T> nearestNeighbors,
+            Stack<RTreeNode<T>> nodeBuffer,
+            List<RTreeNode<T>> childrenBuffer,
+            HashSet<T> nearestNeighborsBuffer
+        )
         {
             nearestNeighbors.Clear();
 
             RTreeNode<T> current = _head;
-            Stack<RTreeNode<T>> stack = new();
+            Stack<RTreeNode<T>> stack = nodeBuffer ?? new Stack<RTreeNode<T>>();
+            stack.Clear();
             stack.Push(_head);
-            List<RTreeNode<T>> childrenCopy = new();
-            HashSet<T> nearestNeighborsSet = new(count);
-
-            int Comparison(RTreeNode<T> lhs, RTreeNode<T> rhs) => ((Vector2)lhs.boundary.center - position).sqrMagnitude.CompareTo(((Vector2)rhs.boundary.center - position).sqrMagnitude);
+            List<RTreeNode<T>> childrenCopy = childrenBuffer ?? new List<RTreeNode<T>>();
+            childrenCopy.Clear();
+            HashSet<T> nearestNeighborsSet = nearestNeighborsBuffer ?? new HashSet<T>(count);
+            nearestNeighborsSet.Clear();
 
             while (!current.isTerminal)
             {
@@ -238,10 +316,21 @@
             nearestNeighbors.AddRange(nearestNeighborsSet);
             if (count < nearestNeighbors.Count)
             {
-                int NearestComparison(T lhs, T rhs) => ((Vector2)_elementTransformer(lhs).center - position).sqrMagnitude.CompareTo(((Vector2)_elementTransformer(rhs).center - position).sqrMagnitude);
                 nearestNeighbors.Sort(NearestComparison);
                 nearestNeighbors.RemoveRange(count, nearestNeighbors.Count - count);
             }
+
+            return;
+
+            int Comparison(RTreeNode<T> lhs, RTreeNode<T> rhs) =>
+                ((Vector2)lhs.boundary.center - position).sqrMagnitude.CompareTo(
+                    ((Vector2)rhs.boundary.center - position).sqrMagnitude
+                );
+
+            int NearestComparison(T lhs, T rhs) =>
+                ((Vector2)_elementTransformer(lhs).center - position).sqrMagnitude.CompareTo(
+                    ((Vector2)_elementTransformer(rhs).center - position).sqrMagnitude
+                );
         }
     }
 }

package/Runtime/Core/Extension/ColorExtensions.cs

@@ -21,15 +21,17 @@
     {
         public static Color GetAverageColor(
             this Sprite sprite,
-            ColorAveragingMethod method = ColorAveragingMethod.LAB
+            ColorAveragingMethod method = ColorAveragingMethod.LAB,
+            float alphaCutoff = 0.01f
         )
         {
-            return GetAverageColor(Enumerables.Of(sprite), method);
+            return GetAverageColor(Enumerables.Of(sprite), method, alphaCutoff);
         }
 
         public static Color GetAverageColor(
             this IEnumerable<Sprite> sprites,
-            ColorAveragingMethod method = ColorAveragingMethod.LAB
+            ColorAveragingMethod method = ColorAveragingMethod.LAB,
+            float alphaCutoff = 0.01f
         )
         {
             return GetAverageColor(
@@ -41,34 +43,36 @@
                     {
                         texture.MakeReadable();
                         Color[] pixels = texture.GetPixels();
-                        return pixels.Where(pixel => pixel.a > 0.01f);
+                        return pixels;
                     }),
-                method
+                method,
+                alphaCutoff
             );
         }
 
         public static Color GetAverageColor(
             this IEnumerable<Color> pixels,
-            ColorAveragingMethod method = ColorAveragingMethod.LAB
+            ColorAveragingMethod method = ColorAveragingMethod.LAB,
+            float alphaCutoff = 0.01f
         )
         {
             switch (method)
             {
                 case ColorAveragingMethod.LAB:
                 {
-                    return AverageInLABSpace(pixels);
+                    return AverageInLABSpace(pixels, alphaCutoff);
                 }
                 case ColorAveragingMethod.HSV:
                 {
-                    return AverageInHSVSpace(pixels);
+                    return AverageInHSVSpace(pixels, alphaCutoff);
                 }
                 case ColorAveragingMethod.Weighted:
                 {
-                    return WeightedRGBAverage(pixels);
+                    return WeightedRGBAverage(pixels, alphaCutoff);
                 }
                 case ColorAveragingMethod.Dominant:
                 {
-                    return GetDominantColor(pixels);
+                    return GetDominantColor(pixels, alphaCutoff);
                 }
                 default:
                 {
@@ -82,9 +86,12 @@
         }
 
         // CIE L*a*b* space averaging - most perceptually accurate
-        private static Color AverageInLABSpace(IEnumerable<Color> pixels)
+        private static Color AverageInLABSpace(IEnumerable<Color> pixels, float alphaCutoff)
         {
-            List<LABColor> labValues = pixels.Select(RGBToLAB).ToList();
+            List<LABColor> labValues = pixels
+                .Where(pixel => pixel.a > alphaCutoff)
+                .Select(RGBToLAB)
+                .ToList();
 
             double avgL = labValues.Average(lab => lab.l);
             double avgA = labValues.Average(lab => lab.a);
@@ -94,14 +101,14 @@
         }
 
         // HSV space averaging - good for preserving vibrant colors
-        private static Color AverageInHSVSpace(IEnumerable<Color> pixels)
+        private static Color AverageInHSVSpace(IEnumerable<Color> pixels, float alphaCutoff)
         {
             float avgH = 0f;
             float avgS = 0f;
             float avgV = 0f;
             int count = 0;
 
-            foreach (Color pixel in pixels)
+            foreach (Color pixel in pixels.Where(pixel => pixel.a > alphaCutoff))
             {
                 Color.RGBToHSV(pixel, out float h, out float s, out float v);
 
@@ -133,7 +140,7 @@
         }
 
         // Weighted RGB averaging using perceived luminance
-        private static Color WeightedRGBAverage(IEnumerable<Color> pixels)
+        private static Color WeightedRGBAverage(IEnumerable<Color> pixels, float alphaCutoff)
         {
             // Use perceived luminance weights
             const float rWeight = 0.299f;
@@ -146,7 +153,7 @@
                 b = 0f,
                 a = 0f;
 
-            foreach (Color pixel in pixels)
+            foreach (Color pixel in pixels.Where(pixel => pixel.a > alphaCutoff))
             {
                 float weight = pixel.r * rWeight + pixel.g * gWeight + pixel.b * bWeight;
                 r += pixel.r * weight;
@@ -168,12 +175,12 @@
         }
 
         // Find dominant color using simple clustering
-        private static Color GetDominantColor(IEnumerable<Color> pixels)
+        private static Color GetDominantColor(IEnumerable<Color> pixels, float alphaCutoff)
         {
             Dictionary<Vector3Int, int> colorBuckets = new();
             const int bucketSize = 32; // Adjust for different precision
 
-            foreach (Color pixel in pixels)
+            foreach (Color pixel in pixels.Where(pixel => pixel.a > alphaCutoff))
             {
                 Vector3Int bucket = new(
                     Mathf.RoundToInt(pixel.r * 255 / bucketSize),

package/Runtime/Core/Extension/RandomExtensions.cs

@@ -1,5 +1,8 @@
 namespace UnityHelpers.Core.Extension
 {
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
     using Helper;
     using Random;
     using UnityEngine;
@@ -11,6 +14,33 @@
             return random.NextVector2(-amplitude, amplitude);
         }
 
+        public static T NextEnumExcept<T>(this IRandom random, params T[] values)
+            where T : struct, Enum
+        {
+            T value;
+            do
+            {
+                value = random.NextEnum<T>();
+            } while (values.Contains(value));
+
+            return value;
+        }
+
+        public static T NextOfExcept<T>(
+            this IRandom random,
+            IEnumerable<T> values,
+            params T[] exceptions
+        )
+        {
+            T value;
+            do
+            {
+                value = random.NextOf(values);
+            } while (exceptions.Contains(value));
+
+            return value;
+        }
+
         public static Vector2 NextVector2(
             this IRandom random,
             float minAmplitude,

package/Runtime/Core/Random/AbstractRandom.cs

@@ -417,16 +417,40 @@
 
         public Guid NextGuid()
         {
-            byte[] guidBytes = new byte[16];
-            NextBytes(guidBytes);
-            return new Guid(guidBytes);
+            return new Guid(GenerateGuidBytes());
         }
 
         public KGuid NextKGuid()
+        {
+            return new KGuid(GenerateGuidBytes());
+        }
+
+        private byte[] GenerateGuidBytes()
         {
             byte[] guidBytes = new byte[16];
             NextBytes(guidBytes);
-            return new KGuid(guidBytes);
+            SetUuidV4Bits(guidBytes);
+            return guidBytes;
+        }
+
+        public static void SetUuidV4Bits(byte[] bytes)
+        {
+            // Set version to 4 (bits 6-7 of byte 6)
+
+            // Clear the version bits first (clear bits 4-7)
+            byte value = bytes[6];
+            value &= 0x0f;
+            // Set version 4 (set bits 4-7 to 0100)
+            value |= 0x40;
+            bytes[6] = value;
+
+            // Set variant to RFC 4122 (bits 6-7 of byte 8)
+            value = bytes[8];
+            // Clear the variant bits first (clear bits 6-7)
+            value &= 0x3f;
+            // Set RFC 4122 variant (set bits 6-7 to 10)
+            value |= 0x80;
+            bytes[8] = value;
         }
 
         // Advances the RNG

package/Tests/Runtime/Random/RandomTestBase.cs

@@ -549,6 +549,26 @@
             }
         }
 
+        [Test]
+        [Parallelizable]
+        public void NextEnumerableExcept()
+        {
+            IRandom random = NewRandom();
+            for (int i = 0; i < NormalIterations; ++i)
+            {
+                TestValues exception = random.NextEnum<TestValues>();
+                HashSet<TestValues> selected = Enum.GetValues(typeof(TestValues))
+                    .OfType<TestValues>()
+                    .Shuffled(random)
+                    .Skip(3)
+                    .ToHashSet();
+
+                TestValues value = random.NextOfExcept(selected.Shuffled(random), exception);
+                Assert.IsTrue(selected.Contains(value));
+                Assert.AreNotEqual(value, exception);
+            }
+        }
+
         [Test]
         [Parallelizable]
         public void NextArray()
@@ -636,6 +656,23 @@
             Assert.AreEqual(Enum.GetValues(typeof(TestValues)).Length, seenEnums.Count);
         }
 
+        [Test]
+        [Parallelizable]
+        public void NextEnumExcept()
+        {
+            IRandom random = NewRandom();
+            HashSet<TestValues> seenEnums = new();
+            for (int i = 0; i < NormalIterations; ++i)
+            {
+                TestValues value = random.NextEnumExcept(TestValues.Value8, TestValues.Value9);
+                _ = seenEnums.Add(value);
+            }
+
+            Assert.AreEqual(Enum.GetValues(typeof(TestValues)).Length - 2, seenEnums.Count);
+            Assert.IsFalse(seenEnums.Contains(TestValues.Value8));
+            Assert.IsFalse(seenEnums.Contains(TestValues.Value9));
+        }
+
         [Test]
         [Parallelizable]
         public void NextNoiseMap()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "2.0.0-rc14",
+  "version": "2.0.0-rc16",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},