com.wallstop-studios.unity-helpers 2.0.0-rc13 → 2.0.0-rc15

package/Editor/EnsureTextureSizeWizard.cs

@@ -0,0 +1,110 @@
+namespace UnityHelpers.Editor
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Core.Extension;
+    using UnityEditor;
+    using UnityEngine;
+
+    public sealed class EnsureTextureSizeWizard : ScriptableWizard
+    {
+        public List<Texture2D> textures = new();
+
+        public List<Object> textureSourcePaths = new();
+
+        [MenuItem("Tools/Unity Helpers/Ensure Texture Size")]
+        public static void EnsureSizes()
+        {
+            _ = DisplayWizard<EnsureTextureSizeWizard>("Ensure Texture Size", "Run");
+        }
+
+        private void OnWizardCreate()
+        {
+            textures ??= new List<Texture2D>();
+            textureSourcePaths ??= new List<Object>();
+            HashSet<string> texturePath = new();
+            foreach (Object textureSource in textureSourcePaths)
+            {
+                string assetPath = AssetDatabase.GetAssetPath(textureSource);
+                if (!string.IsNullOrWhiteSpace(assetPath))
+                {
+                    _ = texturePath.Add(assetPath);
+                }
+            }
+
+            if (texturePath.Any())
+            {
+                foreach (
+                    string assetGuid in AssetDatabase.FindAssets(
+                        "t:texture2D",
+                        texturePath.ToArray()
+                    )
+                )
+                {
+                    string path = AssetDatabase.GUIDToAssetPath(assetGuid);
+                    if (string.IsNullOrWhiteSpace(path))
+                    {
+                        continue;
+                    }
+
+                    Texture2D texture = AssetDatabase.LoadAssetAtPath<Texture2D>(path);
+                    if (texture != null)
+                    {
+                        textures.Add(texture);
+                    }
+                }
+            }
+
+            textures = textures.Distinct().OrderBy(texture => texture.name).ToList();
+            if (textures.Count <= 0)
+            {
+                this.Log("Failed to find any texture paths.");
+                return;
+            }
+
+            int changedCount = 0;
+            foreach (Texture2D inputTexture in textures)
+            {
+                Texture2D texture = inputTexture;
+                string assetPath = AssetDatabase.GetAssetPath(texture);
+                if (string.IsNullOrWhiteSpace(assetPath))
+                {
+                    continue;
+                }
+
+                TextureImporter tImporter = AssetImporter.GetAtPath(assetPath) as TextureImporter;
+                if (tImporter == null)
+                {
+                    continue;
+                }
+                tImporter.GetSourceTextureWidthAndHeight(out int width, out int height);
+
+                float size = Mathf.Max(width, height);
+                int textureSize = tImporter.maxTextureSize;
+                bool changed = false;
+                while (textureSize < size)
+                {
+                    changed = true;
+                    textureSize <<= 1;
+                }
+                tImporter.maxTextureSize = textureSize;
+
+                if (changed)
+                {
+                    changedCount++;
+                    tImporter.SaveAndReimport();
+                }
+            }
+
+            if (changedCount != 0)
+            {
+                this.Log($"Updated {changedCount} textures.");
+                AssetDatabase.Refresh();
+            }
+            else
+            {
+                this.Log("No textures updated.");
+            }
+        }
+    }
+}

package/Editor/EnsureTextureSizeWizard.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8e55e0cc59d640b3affc8f4d9f865c50
+timeCreated: 1735605040

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
+                );
         }
     }
 }