com.wallstop-studios.unity-helpers 2.0.0-rc44 → 2.0.0-rc46

package/Runtime/Core/DataStructure/CyclicBuffer.cs

@@ -12,7 +12,6 @@
     {
         public int Capacity { get; private set; }
         public int Count { get; private set; }
-        public bool IsReadOnly => false;
 
         private readonly List<T> _buffer;
         private int _position;
@@ -52,7 +51,7 @@
         {
             for (int i = 0; i < Count; ++i)
             {
-                // No need for bounds check, we're safe
+                // No need for bound check, we're safe
                 yield return _buffer[AdjustedIndexFor(i)];
             }
         }
@@ -87,7 +86,6 @@
 
         public void Clear()
         {
-            /* Simply reset state */
             Count = 0;
             _position = 0;
             _buffer.Clear();

package/Runtime/Core/DataStructure/KDTree.cs

@@ -272,19 +272,21 @@
                 }
             }
 
-            nearestNeighbors.AddRange(nearestNeighborsSet);
+            foreach (T element in nearestNeighborsSet)
+            {
+                nearestNeighbors.Add(element);
+            }
             if (count < nearestNeighbors.Count)
             {
+                Vector2 localPosition = position;
                 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
-                );
+                int NearestComparison(T lhs, T rhs) =>
+                    (_elementTransformer(lhs) - localPosition).sqrMagnitude.CompareTo(
+                        (_elementTransformer(rhs) - localPosition).sqrMagnitude
+                    );
+            }
         }
     }
 }

package/Runtime/Core/DataStructure/QuadTree.cs

@@ -231,11 +231,15 @@
             HashSet<T> nearestNeighborsSet = nearestNeighborBuffer ?? new HashSet<T>(count);
             nearestNeighborsSet.Clear();
 
+            Comparison<QuadTreeNode<T>> comparison = Comparison;
             while (!current.isTerminal)
             {
                 childrenCopy.Clear();
-                childrenCopy.AddRange(current.children);
-                childrenCopy.Sort(Comparison);
+                foreach (QuadTreeNode<T> child in current.children)
+                {
+                    childrenCopy.Add(child);
+                }
+                childrenCopy.Sort(comparison);
                 for (int i = childrenCopy.Count - 1; 0 <= i; --i)
                 {
                     stack.Push(childrenCopy[i]);
@@ -256,11 +260,20 @@
                 }
             }
 
-            nearestNeighbors.AddRange(nearestNeighborsSet);
+            foreach (T element in nearestNeighborsSet)
+            {
+                nearestNeighbors.Add(element);
+            }
             if (count < nearestNeighbors.Count)
             {
+                Vector2 localPosition = position;
                 nearestNeighbors.Sort(NearestComparison);
                 nearestNeighbors.RemoveRange(count, nearestNeighbors.Count - count);
+
+                int NearestComparison(T lhs, T rhs) =>
+                    (_elementTransformer(lhs) - localPosition).sqrMagnitude.CompareTo(
+                        (_elementTransformer(rhs) - localPosition).sqrMagnitude
+                    );
             }
 
             return;
@@ -269,11 +282,6 @@
                 ((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

@@ -288,11 +288,15 @@
             HashSet<T> nearestNeighborsSet = nearestNeighborsBuffer ?? new HashSet<T>(count);
             nearestNeighborsSet.Clear();
 
+            Comparison<RTreeNode<T>> comparison = Comparison;
             while (!current.isTerminal)
             {
                 childrenCopy.Clear();
-                childrenCopy.AddRange(current.children);
-                childrenCopy.Sort(Comparison);
+                foreach (RTreeNode<T> child in current.children)
+                {
+                    childrenCopy.Add(child);
+                }
+                childrenCopy.Sort(comparison);
                 for (int i = childrenCopy.Count - 1; 0 <= i; --i)
                 {
                     stack.Push(childrenCopy[i]);
@@ -313,11 +317,22 @@
                 }
             }
 
-            nearestNeighbors.AddRange(nearestNeighborsSet);
+            foreach (T element in nearestNeighborsSet)
+            {
+                nearestNeighbors.Add(element);
+            }
             if (count < nearestNeighbors.Count)
             {
+                Vector2 localPosition = position;
                 nearestNeighbors.Sort(NearestComparison);
                 nearestNeighbors.RemoveRange(count, nearestNeighbors.Count - count);
+
+                int NearestComparison(T lhs, T rhs) =>
+                    (
+                        (Vector2)_elementTransformer(lhs).center - localPosition
+                    ).sqrMagnitude.CompareTo(
+                        ((Vector2)_elementTransformer(rhs).center - localPosition).sqrMagnitude
+                    );
             }
 
             return;
@@ -326,11 +341,6 @@
                 ((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/DataStructure/StringWrapper.cs

@@ -19,7 +19,7 @@
         private StringWrapper(string value)
         {
             this.value = value;
-            _hashCode = value?.GetHashCode() ?? 0;
+            _hashCode = value.GetHashCode();
         }
 
         public static StringWrapper Get(string value)
@@ -27,9 +27,9 @@
             return Cache.GetOrAdd(value, key => new StringWrapper(key));
         }
 
-        public static void Remove(string value)
+        public static bool Remove(string value)
         {
-            _ = Cache.TryRemove(value, out _);
+            return Cache.TryRemove(value, out _);
         }
 
         public bool Equals(StringWrapper other)
@@ -49,7 +49,7 @@
                 return false;
             }
 
-            return string.Equals(value, other.value);
+            return string.Equals(value, other.value, StringComparison.Ordinal);
         }
 
         public int CompareTo(StringWrapper other)

package/Runtime/Core/DataStructure/TimedCache.cs

@@ -11,10 +11,23 @@
         {
             get
             {
-                if (!_lastRead.HasValue || Helpers.HasEnoughTimePassed(_lastRead.Value, _cacheTtl))
+                if (!_lastRead.HasValue)
                 {
                     Reset();
                 }
+                else if (
+                    Helpers.HasEnoughTimePassed(
+                        _lastRead.Value,
+                        _cacheTtl + (_shouldUseJitter && !_usedJitter ? _jitterAmount : 0f)
+                    )
+                )
+                {
+                    if (_shouldUseJitter)
+                    {
+                        _usedJitter = true;
+                    }
+                    Reset();
+                }
 
                 return _value;
             }
@@ -26,6 +39,10 @@
         private float? _lastRead;
         private T _value;
 
+        private bool _usedJitter;
+        private readonly bool _shouldUseJitter;
+        private readonly float _jitterAmount;
+
         public TimedCache(Func<T> valueProducer, float cacheTtl, bool useJitter = false)
         {
             _valueProducer =
@@ -36,10 +53,8 @@
             }
 
             _cacheTtl = cacheTtl;
-            if (useJitter && 0 < _cacheTtl)
-            {
-                _cacheTtl += PRNG.Instance.NextFloat(_cacheTtl);
-            }
+            _shouldUseJitter = useJitter;
+            _jitterAmount = useJitter ? PRNG.Instance.NextFloat(0f, cacheTtl) : 0f;
         }
 
         public void Reset()

package/Runtime/Core/Extension/IListExtensions.cs

@@ -85,5 +85,22 @@
             list[index] = last;
             list.RemoveAt(lastIndex);
         }
+
+        public static void InsertionSort<T, TComparer>(this IList<T> array, TComparer comparer)
+            where TComparer : struct, IComparer<T>
+        {
+            int arrayCount = array.Count;
+            for (int i = 1; i < arrayCount; ++i)
+            {
+                T key = array[i];
+                int j = i - 1;
+                while (j >= 0 && comparer.Compare(array[j], key) > 0)
+                {
+                    array[j + 1] = array[j];
+                    j--;
+                }
+                array[j + 1] = key;
+            }
+        }
     }
 }

package/Runtime/Core/Helper/FormattingHelpers.cs

@@ -4,19 +4,19 @@
 
     public static class FormattingHelpers
     {
+        private static readonly string[] ByteSizes = { "B", "KB", "MB", "GB", "TB", "PB", "EB" };
+
         public static string FormatBytes(long bytes)
         {
-            string[] sizes = { "B", "KB", "MB", "GB", "TB", "PB", "EB" };
+            bytes = Math.Max(0L, bytes);
             double len = bytes;
             int order = 0;
 
-            bytes = Math.Max(0, bytes);
-
             const int byteInChunk = 1024;
             while (byteInChunk <= len)
             {
                 len /= byteInChunk;
-                if (order < sizes.Length - 1)
+                if (order < ByteSizes.Length - 1)
                 {
                     ++order;
                 }
@@ -26,7 +26,7 @@
                 }
             }
 
-            return $"{len:0.##} {sizes[order]}";
+            return $"{len:0.##} {ByteSizes[order]}";
         }
     }
 }

package/Runtime/Core/Helper/Objects.cs

@@ -7,8 +7,8 @@
 
     public static class Objects
     {
-        private const int HashBase = 839;
-        private const int HashMultiplier = 4021;
+        private const int HashBase = 5556137;
+        private const int HashMultiplier = 95785853;
 
         public static T FromWeakReference<T>(WeakReference weakReference)
             where T : class

package/Runtime/Core/Helper/ReflectionHelpers.cs

@@ -20,6 +20,7 @@
         public static Array CreateArray(Type type, int length)
         {
             return ArrayCreators
+                // ReSharper disable once ConvertClosureToMethodGroup
                 .GetOrAdd(type, elementType => GetArrayCreator(elementType))
                 .Invoke(length);
         }
@@ -28,6 +29,7 @@
         public static IList CreateList(Type elementType, int length)
         {
             return ListWithCapacityCreators
+                // ReSharper disable once ConvertClosureToMethodGroup
                 .GetOrAdd(elementType, type => GetListWithCapacityCreator(type))
                 .Invoke(length);
         }
@@ -35,6 +37,7 @@
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static IList CreateList(Type elementType)
         {
+            // ReSharper disable once ConvertClosureToMethodGroup
             return ListCreators.GetOrAdd(elementType, type => GetListCreator(type)).Invoke();
         }
 
@@ -44,7 +47,7 @@
             return field.GetValue;
 #else
             DynamicMethod dynamicMethod = new(
-                $"Get{(field.DeclaringType?.Name ?? string.Empty)}{field.Name}",
+                $"Get{field.DeclaringType.Name}{field.Name}",
                 typeof(object),
                 new[] { typeof(object) },
                 field.DeclaringType,
@@ -72,6 +75,41 @@
 #endif
         }
 
+        public static Func<object> GetStaticFieldGetter(FieldInfo field)
+        {
+            if (!field.IsStatic)
+            {
+                throw new ArgumentException(nameof(field));
+            }
+
+#if WEB_GL
+            return () => field.GetValue(null);
+#else
+            DynamicMethod dynamicMethod = new(
+                $"Get{field.DeclaringType.Name}{field.Name}",
+                typeof(object),
+                Type.EmptyTypes, // No parameters for static fields
+                field.DeclaringType,
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+
+            // Load the static field
+            il.Emit(OpCodes.Ldsfld, field);
+
+            // If the field's type is a value type, box it.
+            if (field.FieldType.IsValueType)
+            {
+                il.Emit(OpCodes.Box, field.FieldType);
+            }
+
+            il.Emit(OpCodes.Ret);
+
+            return (Func<object>)dynamicMethod.CreateDelegate(typeof(Func<object>));
+#endif
+        }
+
         public static Func<TInstance, TValue> GetFieldGetter<TInstance, TValue>(FieldInfo field)
         {
 #if WEB_GL
@@ -142,6 +180,59 @@
 #endif
         }
 
+        public static Func<TValue> GetStaticFieldGetter<TValue>(FieldInfo field)
+        {
+            if (!field.IsStatic)
+            {
+                throw new ArgumentException(nameof(field));
+            }
+
+#if WEB_GL
+            return Getter;
+            TValue Getter()
+            {
+                return (TValue)field.GetValue(null);
+            }
+#else
+            DynamicMethod dynamicMethod = new(
+                $"GetGenericStatic{field.DeclaringType.Name}{field.Name}",
+                typeof(TValue),
+                Type.EmptyTypes, // no parameters needed for static fields
+                field.DeclaringType,
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+
+            // Load the static field.
+            il.Emit(OpCodes.Ldsfld, field);
+
+            // Handle conversion from the field type to TValue.
+            if (field.FieldType.IsValueType)
+            {
+                if (!typeof(TValue).IsValueType)
+                {
+                    il.Emit(OpCodes.Box, field.FieldType);
+                }
+            }
+            else
+            {
+                if (typeof(TValue).IsValueType)
+                {
+                    il.Emit(OpCodes.Unbox_Any, typeof(TValue));
+                }
+                else if (typeof(TValue) != field.FieldType)
+                {
+                    il.Emit(OpCodes.Castclass, typeof(TValue));
+                }
+            }
+
+            il.Emit(OpCodes.Ret);
+
+            return (Func<TValue>)dynamicMethod.CreateDelegate(typeof(Func<TValue>));
+#endif
+        }
+
         public static FieldSetter<TInstance, TValue> GetFieldSetter<TInstance, TValue>(
             FieldInfo field
         )
@@ -184,6 +275,36 @@
 #endif
         }
 
+        public static Action<TValue> GetStaticFieldSetter<TValue>(FieldInfo field)
+        {
+            if (!field.IsStatic)
+            {
+                throw new ArgumentException(nameof(field));
+            }
+#if WEB_GL
+            return Setter;
+            void Setter(TValue newValue)
+            {
+                field.SetValue(null, newValue);
+            }
+#else
+            DynamicMethod dynamicMethod = new(
+                $"SetFieldGenericStatic{field.DeclaringType.Name}{field.Name}",
+                typeof(void),
+                new[] { typeof(TValue) },
+                field.Module,
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+            il.Emit(OpCodes.Ldarg_0);
+            il.Emit(OpCodes.Stsfld, field);
+            il.Emit(OpCodes.Ret);
+
+            return (Action<TValue>)dynamicMethod.CreateDelegate(typeof(Action<TValue>));
+#endif
+        }
+
         public static Action<object, object> GetFieldSetter(FieldInfo field)
         {
 #if WEB_GL
@@ -217,6 +338,40 @@
 #endif
         }
 
+        public static Action<object> GetStaticFieldSetter(FieldInfo field)
+        {
+            if (!field.IsStatic)
+            {
+                throw new ArgumentException(nameof(field));
+            }
+#if WEB_GL
+            return value => field.SetValue(null, value);
+#else
+            DynamicMethod dynamicMethod = new(
+                $"SetFieldStatic{field.DeclaringType.Name}{field.Name}",
+                null,
+                new[] { typeof(object) },
+                field.DeclaringType.Module,
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+
+            // Load the new value (argument 0)
+            il.Emit(OpCodes.Ldarg_0);
+            // Convert the object to the field's type (unbox or cast as needed)
+            il.Emit(
+                field.FieldType.IsValueType ? OpCodes.Unbox_Any : OpCodes.Castclass,
+                field.FieldType
+            );
+            // Set the static field
+            il.Emit(OpCodes.Stsfld, field);
+            il.Emit(OpCodes.Ret);
+
+            return (Action<object>)dynamicMethod.CreateDelegate(typeof(Action<object>));
+#endif
+        }
+
         public static Func<int, Array> GetArrayCreator(Type elementType)
         {
 #if WEB_GL

package/Runtime/Core/Helper/SpriteHelpers.cs

@@ -3,13 +3,12 @@
     using Extension;
     using UnityEditor;
     using UnityEngine;
-    using Utils;
 
     public static class SpriteHelpers
     {
         public static void MakeReadable(this Texture2D texture)
         {
-            if (texture.isReadable)
+            if (texture == null || texture.isReadable)
             {
                 return;
             }
@@ -29,58 +28,14 @@
                 return;
             }
 
-            tImporter.isReadable = true;
-            EditorUtility.SetDirty(tImporter);
-            tImporter.SaveAndReimport();
-            EditorUtility.SetDirty(texture);
-#endif
-        }
-
-        public static void SetSpritePivot(string fullSpritePath, Vector2 pivot)
-        {
-#if UNITY_EDITOR
-            SetSpritePivot(AssetImporter.GetAtPath(fullSpritePath) as TextureImporter, pivot);
-#endif
-        }
-
-        public static void SetSpritePivot(Sprite sprite, Vector2 pivot)
-        {
-#if UNITY_EDITOR
-            SetSpritePivot(
-                AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(sprite)) as TextureImporter,
-                pivot
-            );
-#endif
-        }
-
-#if UNITY_EDITOR
-        public static void SetSpritePivot(TextureImporter textureImporter, Vector2 pivot)
-        {
-            if (textureImporter == null)
+            if (!tImporter.isReadable)
             {
-                return;
+                tImporter.isReadable = true;
+                EditorUtility.SetDirty(tImporter);
+                tImporter.SaveAndReimport();
+                EditorUtility.SetDirty(texture);
             }
-
-            TextureImporterSettings textureImportSettings = new TextureImporterSettings();
-            textureImporter.ReadTextureSettings(textureImportSettings);
-            textureImportSettings.spriteAlignment = (int)SpriteAlignment.Custom;
-            textureImportSettings.wrapMode = TextureWrapMode.Clamp;
-            textureImportSettings.filterMode = FilterMode.Trilinear;
-            textureImporter.SetTextureSettings(textureImportSettings);
-
-            TextureImporterPlatformSettings importerSettings = new TextureImporterPlatformSettings
-            {
-                resizeAlgorithm = TextureResizeAlgorithm.Bilinear,
-                maxTextureSize = SetTextureImportData.RegularTextureSize,
-                textureCompression = TextureImporterCompression.Compressed,
-                format = TextureImporterFormat.Automatic,
-            };
-
-            textureImporter.SetPlatformTextureSettings(importerSettings);
-            textureImporter.isReadable = true;
-            textureImporter.spritePivot = pivot;
-            textureImporter.SaveAndReimport();
-        }
 #endif
+        }
     }
 }

package/Runtime/Core/Helper/WallMath.cs

@@ -125,12 +125,12 @@
                 if (0 < direction.x)
                 {
                     float t2 = (max.x - center.x) / direction.x;
-                    tMax = Math.Min(tMax, t2);
+                    tMax = Mathf.Min(tMax, t2);
                 }
                 else
                 {
                     float t1 = (min.x - center.x) / direction.x;
-                    tMax = Math.Min(tMax, t1);
+                    tMax = Mathf.Min(tMax, t1);
                 }
             }
 
@@ -139,12 +139,12 @@
                 if (direction.y > 0)
                 {
                     float t2 = (max.y - center.y) / direction.y;
-                    tMax = Math.Min(tMax, t2);
+                    tMax = Mathf.Min(tMax, t2);
                 }
                 else
                 {
                     float t1 = (min.y - center.y) / direction.y;
-                    tMax = Math.Min(tMax, t1);
+                    tMax = Mathf.Min(tMax, t1);
                 }
             }
 
@@ -160,7 +160,7 @@
 
         public static bool Approximately(this float lhs, float rhs, float tolerance = 0.045f)
         {
-            return Math.Abs(lhs - rhs) <= tolerance;
+            return Mathf.Abs(lhs - rhs) <= tolerance;
         }
     }
 }

package/Runtime/Utils/RuntimeSingleton.cs

@@ -45,12 +45,20 @@
 
         protected virtual void Start()
         {
-            if (_instance != null && _instance != this)
+            if (_instance == null || _instance == this)
             {
-                this.LogError(
-                    $"Double singleton detected, {_instance.name} conflicts with {name}."
-                );
-                gameObject.Destroy();
+                return;
+            }
+
+            this.LogError($"Double singleton detected, {_instance.name} conflicts with {name}.");
+            gameObject.Destroy();
+        }
+
+        protected virtual void OnDestroy()
+        {
+            if (_instance == this)
+            {
+                _instance = null;
             }
         }
     }