com.wallstop-studios.unity-helpers 2.0.0-rc43 → 2.0.0-rc45

package/README.md

@@ -129,6 +129,22 @@ random.NextNoiseMap(width, height); // A configurable noise map generated using
 - XorShift
 - XorShiro
 
+## Performance (Number of Operations / Second)
+
+| Random | NextBool | Next | NextUInt | NextFloat | NextDouble | NextUint - Range | NextInt - Range |
+| ------ | -------- | ---- | -------- | --------- | ---------- | ---------------- | --------------- |
+| PcgRandom | 34,260,478 | 34,303,866 | 35,148,246 | 24,818,438 | 30,034,632 |22,436,474 |20,801,797 |
+| SystemRandom | 28,698,806 | 30,040,782 | 20,435,092 | 24,079,399 | 27,284,147 |20,735,769 |19,861,780 |
+| SquirrelRandom | 33,285,784 | 33,439,909 | 34,611,893 | 23,885,731 | 28,958,725 |21,520,279 |20,311,372 |
+| XorShiftRandom | 34,695,989 | 35,147,320 | 35,997,718 | 25,248,238 | 31,582,991 |22,679,928 |21,255,319 |
+| DotNetRandom | 18,097,489 | 18,191,042 | 18,783,063 | 14,061,444 | 15,730,439 |13,284,050 |12,596,913 |
+| WyRandom | 28,490,852 | 29,086,052 | 29,724,907 | 20,252,065 | 24,542,201 |18,474,790 |17,404,641 |
+| SplitMix64 | 34,301,843 | 34,343,404 | 35,512,284 | 24,289,416 | 30,586,231 |22,470,330 |20,850,965 |
+| RomuDuo | 32,969,889 | 33,413,212 | 34,339,227 | 23,755,059 | 29,483,136 |21,671,641 |20,253,479 |
+| XorShiroRandom | 31,529,025 | 31,717,709 | 32,536,277 | 22,421,715 | 27,619,417 |20,843,993 |19,270,063 |
+| UnityRandom | 24,925,268 | 24,830,594 | 26,429,283 | 17,864,528 | 21,206,384 |16,376,626 |15,528,972 |
+| LinearCongruentialGenerator | 35,013,818 | 35,025,182 | 35,843,533 | 25,093,401 | 31,553,487 |22,579,798 |21,211,175 |
+
 # Spatial Trees
 There are three implemented 2D immutable spatial trees that can store generic objects, as long as there is some resolution function that can convert them into Vector2 spatial positions.
 

package/Runtime/Core/Helper/FormattingHelpers.cs

@@ -0,0 +1,32 @@
+namespace UnityHelpers.Core.Helper
+{
+    using System;
+
+    public static class FormattingHelpers
+    {
+        private static readonly string[] ByteSizes = { "B", "KB", "MB", "GB", "TB", "PB", "EB" };
+
+        public static string FormatBytes(long bytes)
+        {
+            bytes = Math.Max(0L, bytes);
+            double len = bytes;
+            int order = 0;
+
+            const int byteInChunk = 1024;
+            while (byteInChunk <= len)
+            {
+                len /= byteInChunk;
+                if (order < ByteSizes.Length - 1)
+                {
+                    ++order;
+                }
+                else
+                {
+                    throw new ArgumentException($"Too many bytes! Cannot parse {bytes}");
+                }
+            }
+
+            return $"{len:0.##} {ByteSizes[order]}";
+        }
+    }
+}

package/Runtime/Core/Helper/FormattingHelpers.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a4bf649a0aef41b48c8afb261c4bd1d1
+timeCreated: 1742614257

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/Core/Random/AbstractRandom.cs

@@ -21,6 +21,8 @@
 
         public abstract RandomState InternalState { get; }
 
+        private readonly byte[] _guidBytes = new byte[16];
+
         public virtual int Next()
         {
             // Mask out the MSB to ensure the value is within [0, int.MaxValue]
@@ -410,24 +412,23 @@
             where T : struct, Enum
         {
             Type enumType = typeof(T);
-            T[] enumValues = (T[])EnumTypeCache.GetOrAdd(enumType, Enum.GetValues);
+            T[] enumValues = (T[])EnumTypeCache.GetOrAdd(enumType, type => Enum.GetValues(type));
 
             return RandomOf(enumValues);
         }
 
         public Guid NextGuid()
         {
-            return new Guid(GenerateGuidBytes());
+            return new Guid(GenerateGuidBytes(_guidBytes));
         }
 
         public KGuid NextKGuid()
         {
-            return new KGuid(GenerateGuidBytes());
+            return new KGuid(GenerateGuidBytes(_guidBytes));
         }
 
-        private byte[] GenerateGuidBytes()
+        private byte[] GenerateGuidBytes(byte[] guidBytes)
         {
-            byte[] guidBytes = new byte[16];
             NextBytes(guidBytes);
             SetUuidV4Bits(guidBytes);
             return guidBytes;

package/Runtime/Core/Random/DotNetRandom.cs

@@ -8,6 +8,8 @@
     [DataContract]
     public sealed class DotNetRandom : AbstractRandom
     {
+        public static DotNetRandom Instance => ThreadLocalRandom<DotNetRandom>.Instance;
+
         public override RandomState InternalState =>
             new RandomState(unchecked((ulong)_seed), state2: _numberGenerated);
 

package/Runtime/Core/Random/IRandom.cs

@@ -138,6 +138,7 @@
         double NextGaussian(double mean = 0, double stdDev = 1);
 
         Guid NextGuid();
+
         KGuid NextKGuid();
 
         T NextOf<T>(IEnumerable<T> enumerable);

package/Runtime/Core/Random/LinearCongruentialGenerator.cs

@@ -0,0 +1,49 @@
+namespace UnityHelpers.Core.Random
+{
+    using System;
+    using System.Text.Json.Serialization;
+
+    public sealed class LinearCongruentialGenerator : AbstractRandom
+    {
+        public static LinearCongruentialGenerator Instance =>
+            ThreadLocalRandom<LinearCongruentialGenerator>.Instance;
+
+        public override RandomState InternalState => new(_state, 0, _cachedGaussian);
+
+        private uint _state;
+
+        public LinearCongruentialGenerator()
+            : this(Guid.NewGuid()) { }
+
+        public LinearCongruentialGenerator(int seed)
+        {
+            _state = unchecked((uint)seed);
+        }
+
+        public LinearCongruentialGenerator(Guid seed)
+        {
+            _state = unchecked((uint)seed.GetHashCode());
+        }
+
+        [JsonConstructor]
+        public LinearCongruentialGenerator(RandomState internalState)
+        {
+            _state = unchecked((uint)internalState.State1);
+            _cachedGaussian = internalState.Gaussian;
+        }
+
+        public override uint NextUint()
+        {
+            unchecked
+            {
+                _state = _state * 1664525U + 1013904223U;
+            }
+            return _state;
+        }
+
+        public override IRandom Copy()
+        {
+            return new LinearCongruentialGenerator(InternalState);
+        }
+    }
+}

package/Runtime/Core/Random/LinearCongruentialGenerator.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 23eaec3a914247e59d9bd39e199b718e
+timeCreated: 1742702544

package/Runtime/Core/Random/PcgRandom.cs

@@ -15,7 +15,7 @@
             IComparable,
             IComparable<PcgRandom>
     {
-        public static IRandom Instance => ThreadLocalRandom<PcgRandom>.Instance;
+        public static PcgRandom Instance => ThreadLocalRandom<PcgRandom>.Instance;
 
         public override RandomState InternalState => new(_state, _increment, _cachedGaussian);
 

package/Runtime/Core/Random/RomuDuo.cs

@@ -15,7 +15,7 @@
             IComparable,
             IComparable<RomuDuo>
     {
-        public static IRandom Instance => ThreadLocalRandom<RomuDuo>.Instance;
+        public static RomuDuo Instance => ThreadLocalRandom<RomuDuo>.Instance;
         public override RandomState InternalState => new(_x, _y, _cachedGaussian);
 
         internal ulong _x;

package/Runtime/Core/Random/SplitMix64.cs

@@ -12,7 +12,7 @@
             IComparable,
             IComparable<SplitMix64>
     {
-        public static IRandom Instance => ThreadLocalRandom<SplitMix64>.Instance;
+        public static SplitMix64 Instance => ThreadLocalRandom<SplitMix64>.Instance;
 
         public override RandomState InternalState => new(_state, 0, _cachedGaussian);
 

package/Runtime/Core/Random/SystemRandom.cs

@@ -16,7 +16,7 @@
         private const int SeedArraySize = 56;
         private const int LastSeedIndex = SeedArraySize - 1;
 
-        public static IRandom Instance => ThreadLocalRandom<SystemRandom>.Instance;
+        public static SystemRandom Instance => ThreadLocalRandom<SystemRandom>.Instance;
 
         public override RandomState InternalState =>
             new(

package/Runtime/Core/Random/WyRandom.cs

@@ -14,7 +14,7 @@
         private const ulong Prime0 = 0xa0761d6478bd642f;
         private const ulong Prime1 = 0xe7037ed1a0b428db;
 
-        public static IRandom Instance => ThreadLocalRandom<WyRandom>.Instance;
+        public static WyRandom Instance => ThreadLocalRandom<WyRandom>.Instance;
 
         public override RandomState InternalState => new RandomState(_state);
 

package/Runtime/Core/Random/XorShiftRandom.cs

@@ -8,18 +8,25 @@
     [DataContract]
     public sealed class XorShiftRandom : AbstractRandom
     {
-        public static IRandom Instance => ThreadLocalRandom<XorShiftRandom>.Instance;
+        public static XorShiftRandom Instance => ThreadLocalRandom<XorShiftRandom>.Instance;
 
         public override RandomState InternalState => new(_state, 0, _cachedGaussian);
 
         private uint _state;
 
         public XorShiftRandom()
-            : this(Guid.NewGuid().GetHashCode()) { }
+            : this(Guid.NewGuid()) { }
 
         public XorShiftRandom(int state)
         {
             _state = unchecked((uint)state);
+            _state = _state != 0 ? _state : 2463534242U;
+        }
+
+        public XorShiftRandom(Guid seed)
+        {
+            _state = unchecked((uint)seed.GetHashCode());
+            _state = _state != 0 ? _state : 2463534242U;
         }
 
         [JsonConstructor]
@@ -31,12 +38,10 @@
 
         public override uint NextUint()
         {
-            uint state = _state;
-            state ^= state << 13;
-            state ^= state >> 17;
-            state ^= state << 5;
-            _state = state;
-            return state;
+            _state ^= _state << 13;
+            _state ^= _state >> 17;
+            _state ^= _state << 5;
+            return _state;
         }
 
         public override IRandom Copy()

package/Runtime/Core/Random/XorShiroRandom.cs

@@ -12,6 +12,8 @@
             IComparable,
             IComparable<XorShiroRandom>
     {
+        public static XorShiroRandom Instance => ThreadLocalRandom<XorShiroRandom>.Instance;
+
         public override RandomState InternalState => new(_s0, _s1, _cachedGaussian);
 
         internal ulong _s0;

package/Runtime/UI/LayeredImage.cs

@@ -176,7 +176,7 @@
                 int maxY = int.MinValue;
                 foreach (AnimatedSpriteLayer layer in _layers)
                 {
-                    if (!layer.frames.Any())
+                    if (layer.frames.Length <= 0)
                     {
                         continue;
                     }
@@ -210,7 +210,7 @@
 
                 foreach (AnimatedSpriteLayer layer in _layers)
                 {
-                    if (!layer.frames.Any())
+                    if (layer.frames.Length <= 0)
                     {
                         continue;
                     }