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

package/Runtime/Core/Extension/SerializedPropertyExtensions.cs

@@ -0,0 +1,157 @@
+namespace UnityHelpers.Core.Extension
+{
+#if UNITY_EDITOR
+    using UnityEditor;
+    using System;
+    using System.Reflection;
+
+    public static class SerializedPropertyExtensions
+    {
+        /// <summary>
+        /// Gets the instance object that contains the given SerializedProperty.
+        /// </summary>
+        /// <param name="property">The SerializedProperty.</param>
+        /// <param name="fieldInfo">Outputs the FieldInfo of the referenced field.</param>
+        /// <returns>The instance object that owns the field.</returns>
+        public static object GetEnclosingObject(
+            this SerializedProperty property,
+            out FieldInfo fieldInfo
+        )
+        {
+            fieldInfo = null;
+            object obj = property.serializedObject.targetObject;
+            if (obj == null)
+            {
+                return null;
+            }
+            Type type = obj.GetType();
+            string[] pathParts = property.propertyPath.Split('.');
+
+            // Traverse the path but stop at the second-to-last field
+            for (int i = 0; i < pathParts.Length - 1; ++i)
+            {
+                string fieldName = pathParts[i];
+
+                if (string.Equals(fieldName, "Array", StringComparison.Ordinal))
+                {
+                    // Move to "data[i]", no need to length-check, we're guarded above
+
+                    ++i;
+                    if (
+                        !int.TryParse(
+                            pathParts[i]
+                                .Replace("data[", string.Empty, StringComparison.Ordinal)
+                                .Replace("]", string.Empty, StringComparison.Ordinal),
+                            out int index
+                        )
+                    )
+                    {
+                        // Unexpected, die
+                        fieldInfo = null;
+                        return null;
+                    }
+                    obj = GetElementAtIndex(obj, index);
+                    type = obj?.GetType();
+                    continue;
+                }
+
+                fieldInfo = type?.GetField(
+                    fieldName,
+                    BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance
+                );
+                if (fieldInfo == null)
+                {
+                    return null;
+                }
+
+                // Move deeper but stop before the last property in the path
+                if (i < pathParts.Length - 2)
+                {
+                    obj = fieldInfo.GetValue(obj);
+                    type = fieldInfo.FieldType;
+                }
+            }
+
+            return obj;
+        }
+
+        /// <summary>
+        /// Gets the FieldInfo and the instance object that owns the field for a given SerializedProperty.
+        /// </summary>
+        /// <param name="property">The SerializedProperty to reflect upon.</param>
+        /// <param name="fieldInfo">Outputs the FieldInfo of the referenced field.</param>
+        /// <returns>The instance object that owns the field.</returns>
+        public static object GetTargetObjectWithField(
+            this SerializedProperty property,
+            out FieldInfo fieldInfo
+        )
+        {
+            fieldInfo = null;
+            object obj = property.serializedObject.targetObject;
+            if (obj == null)
+            {
+                return null;
+            }
+
+            Type type = obj.GetType();
+            string[] pathParts = property.propertyPath.Split('.');
+
+            for (int i = 0; i < pathParts.Length; ++i)
+            {
+                string fieldName = pathParts[i];
+
+                if (string.Equals(fieldName, "Array", StringComparison.Ordinal))
+                {
+                    // Move to "data[i]"
+                    ++i;
+                    if (pathParts.Length <= i)
+                    {
+                        break;
+                    }
+
+                    if (
+                        !int.TryParse(
+                            pathParts[i]
+                                .Replace("data[", string.Empty, StringComparison.Ordinal)
+                                .Replace("]", string.Empty, StringComparison.Ordinal),
+                            out int index
+                        )
+                    )
+                    {
+                        // Unexpected, die
+                        fieldInfo = null;
+                        return null;
+                    }
+                    obj = GetElementAtIndex(obj, index);
+                    type = obj?.GetType();
+                    continue;
+                }
+
+                fieldInfo = type?.GetField(
+                    fieldName,
+                    BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance
+                );
+                if (fieldInfo == null)
+                {
+                    return null;
+                }
+
+                // Move deeper into the object tree
+                obj = fieldInfo.GetValue(obj);
+                type = fieldInfo.FieldType;
+            }
+
+            return obj;
+        }
+
+        private static object GetElementAtIndex(object obj, int index)
+        {
+            if (obj is System.Collections.IList list && index >= 0 && index < list.Count)
+            {
+                return list[index];
+            }
+            return null;
+        }
+    }
+#endif
+}

package/Runtime/Core/Extension/SerializedPropertyExtensions.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f58cbae584d8414a89cc3996d16fc5b0
+timeCreated: 1742507900

package/Runtime/Core/Helper/FormattingHelpers.cs

@@ -0,0 +1,32 @@
+namespace UnityHelpers.Core.Helper
+{
+    using System;
+
+    public static class FormattingHelpers
+    {
+        public static string FormatBytes(long bytes)
+        {
+            string[] sizes = { "B", "KB", "MB", "GB", "TB", "PB", "EB" };
+            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)
+                {
+                    ++order;
+                }
+                else
+                {
+                    throw new ArgumentException($"Too many bytes! Cannot parse {bytes}");
+                }
+            }
+
+            return $"{len:0.##} {sizes[order]}";
+        }
+    }
+}

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

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

package/Runtime/Core/Helper/Objects.cs

@@ -18,7 +18,8 @@
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool Null(UnityEngine.Object instance)
+        public static bool Null<T>(T instance)
+            where T : UnityEngine.Object
         {
             return instance == null;
         }
@@ -29,7 +30,8 @@
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool NotNull(UnityEngine.Object instance)
+        public static bool NotNull<T>(T instance)
+            where T : UnityEngine.Object
         {
             return instance != null;
         }

package/Runtime/Core/Helper/Partials/TransformHelpers.cs

@@ -1,7 +1,6 @@
 namespace UnityHelpers.Core.Helper
 {
     using System.Collections.Generic;
-    using System.Linq;
     using UnityEngine;
 
     public static partial class Helpers

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/Core/Threading/SingleThreadedThreadPool.cs

@@ -7,6 +7,7 @@
     public sealed class SingleThreadedThreadPool : IDisposable
     {
         public ConcurrentQueue<Exception> Exceptions => _exceptions;
+        public int Count => _work.Count + Interlocked.CompareExchange(ref _working, 0, 0);
 
         private int _active;
         private int _working;
@@ -16,14 +17,14 @@
         private bool _disposed;
         private readonly ConcurrentQueue<Exception> _exceptions;
 
-        public SingleThreadedThreadPool()
+        public SingleThreadedThreadPool(bool runInBackground = false)
         {
             _active = 1;
             _working = 1;
             _work = new ConcurrentQueue<Action>();
             _exceptions = new ConcurrentQueue<Exception>();
             _waitHandle = new AutoResetEvent(false);
-            _worker = new Thread(DoWork);
+            _worker = new Thread(DoWork) { IsBackground = runInBackground };
             _worker.Start();
         }
 
@@ -32,40 +33,12 @@
             Dispose(false);
         }
 
-        private void DoWork()
-        {
-            while (Interlocked.CompareExchange(ref _active, 0, 0) != 0)
-            {
-                _ = Interlocked.Exchange(ref _working, 0);
-                if (_work.TryDequeue(out Action workItem))
-                {
-                    _ = Interlocked.Exchange(ref _working, 1);
-                    try
-                    {
-                        workItem();
-                    }
-                    catch (Exception e)
-                    {
-                        _exceptions.Enqueue(e);
-                    }
-                }
-                else
-                {
-                    _ = _waitHandle.WaitOne(TimeSpan.FromSeconds(1));
-                }
-
-                _ = Interlocked.Exchange(ref _working, 0);
-            }
-        }
-
         public void Enqueue(Action work)
         {
             _work.Enqueue(work);
             _ = _waitHandle.Set();
         }
 
-        public int Count => _work.Count + Interlocked.CompareExchange(ref _working, 0, 0);
-
         public void Dispose()
         {
             Dispose(true);
@@ -79,17 +52,16 @@
                 return;
             }
 
-            int active;
-            do
+            while (Interlocked.CompareExchange(ref _active, 0, _active) != 0)
             {
-                active = Interlocked.CompareExchange(ref _active, 0, _active);
-            } while (active != 0);
+                // Spin
+            }
 
             if (disposing)
             {
                 try
                 {
-                    _worker?.Join();
+                    _worker?.Join(TimeSpan.FromSeconds(30));
                     _waitHandle?.Dispose();
                 }
                 catch
@@ -103,5 +75,42 @@
 
             _disposed = true;
         }
+
+        private void DoWork()
+        {
+            while (Interlocked.CompareExchange(ref _active, 0, 0) != 0)
+            {
+                try
+                {
+                    if (_work.TryDequeue(out Action workItem))
+                    {
+                        _ = Interlocked.Exchange(ref _working, 1);
+                        try
+                        {
+                            workItem();
+                        }
+                        catch (Exception e)
+                        {
+                            _exceptions.Enqueue(e);
+                        }
+                    }
+                    else
+                    {
+                        try
+                        {
+                            _ = _waitHandle?.WaitOne(TimeSpan.FromSeconds(1));
+                        }
+                        catch (ObjectDisposedException)
+                        {
+                            return;
+                        }
+                    }
+                }
+                finally
+                {
+                    _ = Interlocked.Exchange(ref _working, 0);
+                }
+            }
+        }
     }
 }

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