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

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/Runtime/Core/Extension/ColorExtensions.cs

@@ -1,13 +1,272 @@
 namespace UnityHelpers.Core.Extension
 {
     using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Linq;
+    using Helper;
     using Random;
     using UnityEngine;
 
+    public enum ColorAveragingMethod
+    {
+        LAB = 0, // CIE L*a*b* space averaging
+        HSV = 1, // HSV space averaging
+        Weighted = 2, // Weighted RGB averaging using perceived luminance
+        Dominant = 3, // Find most dominant color cluster
+    }
+
     // https://sharpsnippets.wordpress.com/2014/03/11/c-extension-complementary-color/
     public static class ColorExtensions
     {
-        public static Color GetComplement(this Color source, IRandom random = null, float variance = 0f)
+        public static Color GetAverageColor(
+            this Sprite sprite,
+            ColorAveragingMethod method = ColorAveragingMethod.LAB
+        )
+        {
+            return GetAverageColor(Enumerables.Of(sprite), method);
+        }
+
+        public static Color GetAverageColor(
+            this IEnumerable<Sprite> sprites,
+            ColorAveragingMethod method = ColorAveragingMethod.LAB
+        )
+        {
+            return GetAverageColor(
+                sprites
+                    .Where(Objects.NotNull)
+                    .Select(sprite => sprite.texture)
+                    .Where(Objects.NotNull)
+                    .SelectMany(texture =>
+                    {
+                        texture.MakeReadable();
+                        Color[] pixels = texture.GetPixels();
+                        return pixels.Where(pixel => pixel.a > 0.01f);
+                    }),
+                method
+            );
+        }
+
+        public static Color GetAverageColor(
+            this IEnumerable<Color> pixels,
+            ColorAveragingMethod method = ColorAveragingMethod.LAB
+        )
+        {
+            switch (method)
+            {
+                case ColorAveragingMethod.LAB:
+                {
+                    return AverageInLABSpace(pixels);
+                }
+                case ColorAveragingMethod.HSV:
+                {
+                    return AverageInHSVSpace(pixels);
+                }
+                case ColorAveragingMethod.Weighted:
+                {
+                    return WeightedRGBAverage(pixels);
+                }
+                case ColorAveragingMethod.Dominant:
+                {
+                    return GetDominantColor(pixels);
+                }
+                default:
+                {
+                    throw new InvalidEnumArgumentException(
+                        nameof(method),
+                        (int)method,
+                        typeof(ColorAveragingMethod)
+                    );
+                }
+            }
+        }
+
+        // CIE L*a*b* space averaging - most perceptually accurate
+        private static Color AverageInLABSpace(IEnumerable<Color> pixels)
+        {
+            List<LABColor> labValues = pixels.Select(RGBToLAB).ToList();
+
+            double avgL = labValues.Average(lab => lab.l);
+            double avgA = labValues.Average(lab => lab.a);
+            double avgB = labValues.Average(lab => lab.b);
+
+            return LABToRGB(avgL, avgA, avgB);
+        }
+
+        // HSV space averaging - good for preserving vibrant colors
+        private static Color AverageInHSVSpace(IEnumerable<Color> pixels)
+        {
+            float avgH = 0f;
+            float avgS = 0f;
+            float avgV = 0f;
+            int count = 0;
+
+            foreach (Color pixel in pixels)
+            {
+                Color.RGBToHSV(pixel, out float h, out float s, out float v);
+
+                // Handle hue wrapping around 360 degrees
+                float hRad = h * 2f * Mathf.PI;
+                avgH += Mathf.Cos(hRad);
+                avgH += Mathf.Sin(hRad);
+
+                avgS += s;
+                avgV += v;
+                count++;
+            }
+
+            avgH = Mathf.Atan2(avgH / count, avgH / count) / (2f * Mathf.PI);
+            if (avgH < 0)
+            {
+                avgH += 1f;
+            }
+
+            if (count <= 0)
+            {
+                count = 1;
+            }
+
+            avgS /= count;
+            avgV /= count;
+
+            return Color.HSVToRGB(avgH, avgS, avgV);
+        }
+
+        // Weighted RGB averaging using perceived luminance
+        private static Color WeightedRGBAverage(IEnumerable<Color> pixels)
+        {
+            // Use perceived luminance weights
+            const float rWeight = 0.299f;
+            const float gWeight = 0.587f;
+            const float bWeight = 0.114f;
+
+            float totalWeight = 0f;
+            float r = 0f,
+                g = 0f,
+                b = 0f,
+                a = 0f;
+
+            foreach (Color pixel in pixels)
+            {
+                float weight = pixel.r * rWeight + pixel.g * gWeight + pixel.b * bWeight;
+                r += pixel.r * weight;
+                g += pixel.g * weight;
+                b += pixel.b * weight;
+                a += pixel.a * weight;
+                totalWeight += weight;
+            }
+
+            if (totalWeight > 0f)
+            {
+                r /= totalWeight;
+                g /= totalWeight;
+                b /= totalWeight;
+                a /= totalWeight;
+            }
+
+            return new Color(r, g, b, a);
+        }
+
+        // Find dominant color using simple clustering
+        private static Color GetDominantColor(IEnumerable<Color> pixels)
+        {
+            Dictionary<Vector3Int, int> colorBuckets = new();
+            const int bucketSize = 32; // Adjust for different precision
+
+            foreach (Color pixel in pixels)
+            {
+                Vector3Int bucket = new(
+                    Mathf.RoundToInt(pixel.r * 255 / bucketSize),
+                    Mathf.RoundToInt(pixel.g * 255 / bucketSize),
+                    Mathf.RoundToInt(pixel.b * 255 / bucketSize)
+                );
+
+                colorBuckets.TryAdd(bucket, 0);
+                colorBuckets[bucket]++;
+            }
+
+            Vector3Int dominantBucket = colorBuckets
+                .OrderByDescending(kvp => kvp.Value)
+                .First()
+                .Key;
+            return new Color(
+                dominantBucket.x * bucketSize / 255f,
+                dominantBucket.y * bucketSize / 255f,
+                dominantBucket.z * bucketSize / 255f
+            );
+        }
+
+        // Helper struct for LAB color space
+        private readonly struct LABColor
+        {
+            public readonly double l;
+            public readonly double a;
+            public readonly double b;
+
+            public LABColor(double l, double a, double b)
+            {
+                this.l = l;
+                this.a = a;
+                this.b = b;
+            }
+        }
+
+        private static LABColor RGBToLAB(Color rgb)
+        {
+            // First convert to XYZ
+            double r =
+                rgb.r > 0.04045 ? Mathf.Pow((rgb.r + 0.055f) / 1.055f, 2.4f) : rgb.r / 12.92f;
+            double g =
+                rgb.g > 0.04045 ? Mathf.Pow((rgb.g + 0.055f) / 1.055f, 2.4f) : rgb.g / 12.92f;
+            double b =
+                rgb.b > 0.04045 ? Mathf.Pow((rgb.b + 0.055f) / 1.055f, 2.4f) : rgb.b / 12.92f;
+
+            double x = (r * 0.4124 + g * 0.3576 + b * 0.1805) / 0.95047;
+            double y = (r * 0.2126 + g * 0.7152 + b * 0.0722);
+            double z = (r * 0.0193 + g * 0.1192 + b * 0.9505) / 1.08883;
+
+            x = x > 0.008856 ? Mathf.Pow((float)x, 1f / 3f) : (7.787 * x) + 16f / 116f;
+            y = y > 0.008856 ? Mathf.Pow((float)y, 1f / 3f) : (7.787 * y) + 16f / 116f;
+            z = z > 0.008856 ? Mathf.Pow((float)z, 1f / 3f) : (7.787 * z) + 16f / 116f;
+
+            return new LABColor((116 * y) - 16, 500 * (x - y), 200 * (y - z));
+        }
+
+        private static Color LABToRGB(double l, double a, double b)
+        {
+            double y = (l + 16) / 116;
+            double x = a / 500 + y;
+            double z = y - b / 200;
+
+            double x3 = x * x * x;
+            double y3 = y * y * y;
+            double z3 = z * z * z;
+
+            x = 0.95047 * (x3 > 0.008856 ? x3 : (x - 16.0 / 116.0) / 7.787);
+            y = y3 > 0.008856 ? y3 : (y - 16.0 / 116.0) / 7.787;
+            z = 1.08883 * (z3 > 0.008856 ? z3 : (z - 16.0 / 116.0) / 7.787);
+
+            double r = x * 3.2406 + y * -1.5372 + z * -0.4986;
+            double g = x * -0.9689 + y * 1.8758 + z * 0.0415;
+            double b2 = x * 0.0557 + y * -0.2040 + z * 1.0570;
+
+            r = r > 0.0031308 ? 1.055 * Mathf.Pow((float)r, 1 / 2.4f) - 0.055 : 12.92 * r;
+            g = g > 0.0031308 ? 1.055 * Mathf.Pow((float)g, 1 / 2.4f) - 0.055 : 12.92 * g;
+            b2 = b2 > 0.0031308 ? 1.055 * Mathf.Pow((float)b2, 1 / 2.4f) - 0.055 : 12.92 * b2;
+
+            return new Color(
+                Mathf.Clamp01((float)r),
+                Mathf.Clamp01((float)g),
+                Mathf.Clamp01((float)b2),
+                1f
+            );
+        }
+
+        public static Color GetComplement(
+            this Color source,
+            IRandom random = null,
+            float variance = 0f
+        )
         {
             Color inputColor = source;
             //if RGB values are close to each other by a diff less than 10%, then if RGB values are lighter side, decrease the blue by 50% (eventually it will increase in conversion below), if RBB values are on darker side, decrease yellow by about 50% (it will increase in conversion)

package/Runtime/Core/Extension/UnityExtensions.cs

@@ -14,6 +14,16 @@
 
     public static class UnityExtensions
     {
+        public static Vector2 GetCenter(this GameObject gameObject)
+        {
+            if (gameObject.TryGetComponent(out CenterPointOffset centerPointOffset))
+            {
+                return centerPointOffset.CenterPoint;
+            }
+
+            return gameObject.transform.position;
+        }
+
         public static Bounds Bounds(this Rect rect)
         {
             return new Bounds(rect.center, rect.size);

package/Runtime/Core/Helper/Geometry.cs

@@ -1,9 +1,26 @@
 namespace UnityHelpers.Core.Helper
 {
+    using System.Collections.Generic;
+    using System.Linq;
     using UnityEngine;
 
     public static class Geometry
     {
+        public static Rect Accumulate(this IEnumerable<Rect> rects)
+        {
+            return rects.Aggregate(
+                (accumulated, next) =>
+                    new Rect(
+                        Mathf.Min(accumulated.xMin, next.xMin),
+                        Mathf.Min(accumulated.yMin, next.yMin),
+                        Mathf.Max(accumulated.xMax, next.xMax)
+                            - Mathf.Min(accumulated.xMin, next.xMin),
+                        Mathf.Max(accumulated.yMax, next.yMax)
+                            - Mathf.Min(accumulated.yMin, next.yMin)
+                    )
+            );
+        }
+
         //Where is p in relation to a-b
         // < 0 -> to the right
         // = 0 -> on the line

package/Runtime/Core/Helper/SpriteHelpers.cs

@@ -1,11 +1,41 @@
 namespace UnityHelpers.Core.Helper
 {
+    using Extension;
     using UnityEditor;
     using UnityEngine;
     using Utils;
 
     public static class SpriteHelpers
     {
+        public static void MakeReadable(this Texture2D texture)
+        {
+            if (texture.isReadable)
+            {
+                return;
+            }
+
+#if UNITY_EDITOR
+            string assetPath = AssetDatabase.GetAssetPath(texture);
+            if (string.IsNullOrEmpty(assetPath))
+            {
+                texture.LogError("Failed to get asset path.");
+                return;
+            }
+
+            TextureImporter tImporter = AssetImporter.GetAtPath(assetPath) as TextureImporter;
+            if (tImporter == null)
+            {
+                texture.LogError("Failed to get texture importer.");
+                return;
+            }
+
+            tImporter.isReadable = true;
+            EditorUtility.SetDirty(tImporter);
+            tImporter.SaveAndReimport();
+            EditorUtility.SetDirty(texture);
+#endif
+        }
+
         public static void SetSpritePivot(string fullSpritePath, Vector2 pivot)
         {
 #if UNITY_EDITOR
@@ -16,7 +46,10 @@
         public static void SetSpritePivot(Sprite sprite, Vector2 pivot)
         {
 #if UNITY_EDITOR
-            SetSpritePivot(AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(sprite)) as TextureImporter, pivot);
+            SetSpritePivot(
+                AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(sprite)) as TextureImporter,
+                pivot
+            );
 #endif
         }
 
@@ -30,7 +63,7 @@
 
             TextureImporterSettings textureImportSettings = new TextureImporterSettings();
             textureImporter.ReadTextureSettings(textureImportSettings);
-            textureImportSettings.spriteAlignment = (int) SpriteAlignment.Custom;
+            textureImportSettings.spriteAlignment = (int)SpriteAlignment.Custom;
             textureImportSettings.wrapMode = TextureWrapMode.Clamp;
             textureImportSettings.filterMode = FilterMode.Trilinear;
             textureImporter.SetTextureSettings(textureImportSettings);
@@ -40,7 +73,7 @@
                 resizeAlgorithm = TextureResizeAlgorithm.Bilinear,
                 maxTextureSize = SetTextureImportData.RegularTextureSize,
                 textureCompression = TextureImporterCompression.Compressed,
-                format = TextureImporterFormat.Automatic
+                format = TextureImporterFormat.Automatic,
             };
 
             textureImporter.SetPlatformTextureSettings(importerSettings);

package/Runtime/Core/Random/PcgRandom.cs

@@ -17,6 +17,8 @@
     {
         public static IRandom Instance => ThreadLocalRandom<PcgRandom>.Instance;
 
+        public override RandomState InternalState => new(_state, _increment, _cachedGaussian);
+
         internal readonly ulong _increment;
 
         internal ulong _state;
@@ -53,8 +55,6 @@
             _increment = NextUlong();
         }
 
-        public override RandomState InternalState => new(_state, _increment, _cachedGaussian);
-
         public override uint NextUint()
         {
             unchecked

package/Runtime/Core/Random/RomuDuo.cs

@@ -0,0 +1,116 @@
+namespace UnityHelpers.Core.Random
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.Serialization;
+    using System.Text.Json.Serialization;
+    using Extension;
+    using Helper;
+
+    [Serializable]
+    [DataContract]
+    public sealed class RomuDuo
+        : AbstractRandom,
+            IEquatable<RomuDuo>,
+            IComparable,
+            IComparable<RomuDuo>
+    {
+        public static IRandom Instance => ThreadLocalRandom<RomuDuo>.Instance;
+        public override RandomState InternalState => new(_x, _y, _cachedGaussian);
+
+        internal ulong _x;
+        internal ulong _y;
+
+        public RomuDuo()
+            : this(Guid.NewGuid()) { }
+
+        public RomuDuo(Guid guid)
+        {
+            byte[] bytes = guid.ToByteArray();
+            _x = BitConverter.ToUInt64(bytes, 0);
+            _y = BitConverter.ToUInt64(bytes, sizeof(ulong));
+        }
+
+        public RomuDuo(ulong seedX, ulong seedY)
+        {
+            _x = seedX;
+            _y = seedY;
+        }
+
+        [JsonConstructor]
+        public RomuDuo(RandomState internalState)
+        {
+            _x = internalState.State1;
+            _y = internalState.State2;
+            _cachedGaussian = internalState.Gaussian;
+        }
+
+        public override uint NextUint()
+        {
+            unchecked
+            {
+                ulong xp = _x;
+                _x = 15241094284759029579UL * _y;
+                _y = Rol64(_y, 27) + xp;
+                return (uint)xp;
+            }
+        }
+
+        public override IRandom Copy()
+        {
+            return new RomuDuo(InternalState);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ulong Rol64(ulong x, int k)
+        {
+            return (x << k) | (x >> (64 - k));
+        }
+
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as RomuDuo);
+        }
+
+        public bool Equals(RomuDuo other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            return _x == other._x && _y == other._y;
+        }
+
+        public override int GetHashCode()
+        {
+            return Objects.ValueTypeHashCode(_x, _y);
+        }
+
+        public override string ToString()
+        {
+            return this.ToJson();
+        }
+
+        public int CompareTo(object obj)
+        {
+            return CompareTo(obj as RomuDuo);
+        }
+
+        public int CompareTo(RomuDuo other)
+        {
+            if (other == null)
+            {
+                return -1;
+            }
+
+            int comparison = _x.CompareTo(other._x);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            return _y.CompareTo(other._y);
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 562c2538ef434c048b1fd0816dcc2369
+timeCreated: 1735610205

package/Runtime/Core/Random/SplitMix64.cs

@@ -0,0 +1,94 @@
+namespace UnityHelpers.Core.Random
+{
+    using System;
+    using System.Runtime.Serialization;
+    using System.Text.Json.Serialization;
+
+    [Serializable]
+    [DataContract]
+    public sealed class SplitMix64
+        : AbstractRandom,
+            IEquatable<SplitMix64>,
+            IComparable,
+            IComparable<SplitMix64>
+    {
+        public static IRandom Instance => ThreadLocalRandom<SplitMix64>.Instance;
+
+        public override RandomState InternalState => new(_state, 0, _cachedGaussian);
+
+        internal ulong _state;
+
+        public SplitMix64()
+            : this(Guid.NewGuid()) { }
+
+        public SplitMix64(Guid guid)
+            : this(BitConverter.ToUInt64(guid.ToByteArray(), 0)) { }
+
+        public SplitMix64(ulong seed)
+        {
+            _state = seed;
+        }
+
+        [JsonConstructor]
+        public SplitMix64(RandomState internalState)
+        {
+            _state = internalState.State1;
+            _cachedGaussian = internalState.Gaussian;
+        }
+
+        public override uint NextUint()
+        {
+            unchecked
+            {
+                _state += 0x9E3779B97F4A7C15UL;
+
+                ulong z = _state;
+                z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9UL;
+                z = (z ^ (z >> 27)) * 0x94D049BB133111EBUL;
+                z ^= (z >> 31);
+
+                return (uint)z;
+            }
+        }
+
+        public override IRandom Copy()
+        {
+            return new SplitMix64(InternalState);
+        }
+
+        public bool Equals(SplitMix64 other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            return _state == other._state;
+        }
+
+        public int CompareTo(object obj)
+        {
+            return CompareTo(obj as SplitMix64);
+        }
+
+        public int CompareTo(SplitMix64 other)
+        {
+            if (other == null)
+            {
+                return -1;
+            }
+
+            return _state.CompareTo(other._state);
+        }
+
+        public override int GetHashCode()
+        {
+            return _state.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            return $"{{\"State\": {_state}}}";
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: cea6a12d9c0d4373b21094cdb49b8cfb
+timeCreated: 1735605670

package/Runtime/Core/Random/XorShiroRandom.cs

@@ -0,0 +1,117 @@
+namespace UnityHelpers.Core.Random
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Text.Json.Serialization;
+    using Extension;
+    using Helper;
+
+    public sealed class XorShiroRandom
+        : AbstractRandom,
+            IEquatable<XorShiroRandom>,
+            IComparable,
+            IComparable<XorShiroRandom>
+    {
+        public override RandomState InternalState => new(_s0, _s1, _cachedGaussian);
+
+        internal ulong _s0;
+        internal ulong _s1;
+
+        public XorShiroRandom()
+            : this(Guid.NewGuid()) { }
+
+        public XorShiroRandom(Guid guid)
+        {
+            byte[] bytes = guid.ToByteArray();
+            _s0 = BitConverter.ToUInt64(bytes, 0);
+            _s1 = BitConverter.ToUInt64(bytes, 8);
+        }
+
+        public XorShiroRandom(ulong seed1, ulong seed2)
+        {
+            _s0 = seed1;
+            _s1 = seed2;
+        }
+
+        [JsonConstructor]
+        public XorShiroRandom(RandomState internalState)
+        {
+            _s0 = internalState.State1;
+            _s1 = internalState.State2;
+            _cachedGaussian = internalState.Gaussian;
+        }
+
+        public override uint NextUint()
+        {
+            unchecked
+            {
+                ulong s0 = _s0;
+                ulong s1 = _s1;
+                ulong result = s0 + s1;
+
+                s1 ^= s0;
+                _s0 = Rotl(s0, 24) ^ s1 ^ (s1 << 16);
+                _s1 = Rotl(s1, 37);
+
+                return (uint)result;
+            }
+        }
+
+        public override IRandom Copy()
+        {
+            return new XorShiroRandom(InternalState);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ulong Rotl(ulong x, int k)
+        {
+            return (x << k) | (x >> (64 - k));
+        }
+
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as XorShiroRandom);
+        }
+
+        public bool Equals(XorShiroRandom other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            return _s0 == other._s0 && _s1 == other._s1;
+        }
+
+        public override int GetHashCode()
+        {
+            return Objects.ValueTypeHashCode(_s0, _s1);
+        }
+
+        public override string ToString()
+        {
+            return this.ToJson();
+        }
+
+        public int CompareTo(object obj)
+        {
+            return CompareTo(obj as XorShiroRandom);
+        }
+
+        public int CompareTo(XorShiroRandom other)
+        {
+            if (other == null)
+            {
+                return -1;
+            }
+
+            int comparison = _s0.CompareTo(other._s0);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            return _s1.CompareTo(other._s1);
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1252767904fc4f4bb2a8a876964f2dfc
+timeCreated: 1735610452

package/Runtime/UI/LayeredImage.cs

@@ -0,0 +1,364 @@
+namespace UnityHelpers.UI
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Linq;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Core.Extension;
+    using Core.Helper;
+    using UnityEditor;
+    using UnityEngine;
+    using UnityEngine.UIElements;
+    using Utils;
+    using Debug = UnityEngine.Debug;
+
+    public readonly struct AnimatedSpriteLayer
+    {
+        public const float FrameRate = 12f;
+
+        public readonly Vector2[] offsets;
+        public readonly Sprite[] frames;
+        public readonly float alpha;
+
+        public AnimatedSpriteLayer(
+            IEnumerable<Sprite> sprites,
+            IEnumerable<Vector2> offsets,
+            float alpha = 1
+        )
+        {
+            frames = sprites?.ToArray() ?? Array.Empty<Sprite>();
+            foreach (Sprite frame in frames)
+            {
+                if (frame == null)
+                {
+                    continue;
+                }
+
+                frame.texture.MakeReadable();
+            }
+
+            this.offsets =
+                offsets?.Zip(frames, (offset, frame) => frame.pixelsPerUnit * offset).ToArray()
+                ?? Array.Empty<Vector2>();
+            Debug.Assert(
+                this.offsets.Length == frames.Length,
+                $"Expected {frames.Length} to match {this.offsets.Length}"
+            );
+            this.alpha = Mathf.Clamp01(alpha);
+        }
+
+        public AnimatedSpriteLayer(
+            AnimationClip clip,
+            IEnumerable<Vector2> offsets,
+            float alpha = 1
+        )
+            : this(
+#if UNITY_EDITOR
+                clip.GetSpritesFromClip(),
+#else
+                Enumerable.Empty<Sprite>(),
+#endif
+                offsets, alpha) { }
+    }
+
+    public sealed class LayeredImage : VisualElement
+    {
+        private readonly AnimatedSpriteLayer[] _layers;
+        private readonly Texture2D[] _computed;
+        private readonly Color _backgroundColor;
+
+        private readonly Rect? _largestArea;
+
+        public LayeredImage(
+            IEnumerable<AnimatedSpriteLayer> inputSpriteLayers,
+            Color? backgroundColor = null,
+            float fps = AnimatedSpriteLayer.FrameRate
+        )
+        {
+            _layers = inputSpriteLayers.ToArray();
+            _backgroundColor = backgroundColor ?? Color.white;
+            _computed = ComputeTextures().ToArray();
+            _largestArea = null;
+            foreach (Texture2D computed in _computed)
+            {
+                if (_largestArea == null)
+                {
+                    _largestArea = new Rect(0, 0, computed.width, computed.height);
+                }
+                else
+                {
+                    Rect largestArea = _largestArea.Value;
+                    largestArea.width = Mathf.Max(largestArea.width, computed.width);
+                    largestArea.height = Mathf.Max(largestArea.height, computed.height);
+                    _largestArea = largestArea;
+                }
+            }
+
+            Render(0);
+            float fpsMs = 1000f / fps;
+            if (1 < _computed.Length)
+            {
+#if UNITY_EDITOR
+                if (!Application.isPlaying)
+                {
+                    TimeSpan lastTick = TimeSpan.Zero;
+                    TimeSpan fpsSpan = TimeSpan.FromMilliseconds(fpsMs);
+                    int index = 0;
+                    Stopwatch timer = Stopwatch.StartNew();
+                    EditorApplication.update += () =>
+                    {
+                        TimeSpan elapsed = timer.Elapsed;
+                        if (lastTick + fpsSpan < elapsed)
+                        {
+                            index = index.WrappedIncrement(_computed.Length);
+                            lastTick = elapsed;
+                            Render(index);
+                        }
+                    };
+                    return;
+                }
+
+#endif
+                {
+                    int index = 0;
+                    CoroutineHandler.Instance.StartFunctionAsCoroutine(
+                        () =>
+                        {
+                            index = index.WrappedIncrement(_computed.Length);
+                            Render(index);
+                        },
+                        1f / fps
+                    );
+                }
+            }
+        }
+
+        private void Render(int index)
+        {
+            Texture2D computed = _computed[index];
+            if (computed != null)
+            {
+                style.backgroundImage = computed;
+                style.width = computed.width;
+                style.height = computed.height;
+            }
+
+            style.marginRight = 0;
+            style.marginBottom = 0;
+            if (_largestArea != null)
+            {
+                Rect largestArea = _largestArea.Value;
+                if (style.width.value.value < largestArea.width)
+                {
+                    style.marginRight = largestArea.width - style.width.value.value;
+                }
+
+                if (style.height.value.value < largestArea.height)
+                {
+                    style.marginBottom = largestArea.height - style.height.value.value;
+                }
+            }
+        }
+
+        private IEnumerable<Texture2D> ComputeTextures()
+        {
+            const float pixelCutoff = 0.01f;
+            int frameCount = _layers.Select(layer => layer.frames.Length).Distinct().Single();
+
+            Color transparent = Color.clear;
+            for (int frameIndex = 0; frameIndex < frameCount; ++frameIndex)
+            {
+                int minX = int.MaxValue;
+                int maxX = int.MinValue;
+                int minY = int.MaxValue;
+                int maxY = int.MinValue;
+                foreach (AnimatedSpriteLayer layer in _layers)
+                {
+                    if (!layer.frames.Any())
+                    {
+                        continue;
+                    }
+
+                    Sprite sprite = layer.frames[frameIndex];
+                    Vector2 offset = layer.offsets[frameIndex];
+                    Rect spriteRect = sprite.rect;
+
+                    int left = Mathf.RoundToInt(offset.x + spriteRect.xMin);
+                    int right = Mathf.RoundToInt(offset.x + spriteRect.xMax);
+                    int bottom = Mathf.RoundToInt(offset.y + spriteRect.yMin);
+                    int top = Mathf.RoundToInt(offset.y + spriteRect.yMax);
+
+                    minX = Mathf.Min(minX, left);
+                    maxX = Mathf.Max(maxX, right);
+                    minY = Mathf.Min(minY, bottom);
+                    maxY = Mathf.Max(maxY, top);
+                }
+
+                if (minX == int.MaxValue)
+                {
+                    continue;
+                }
+
+                // Calculate the width and height of the non-transparent region
+                int width = maxX - minX + 1;
+                int height = maxY - minY + 1;
+
+                Color[] pixels = new Color[width * height];
+                Array.Fill(pixels, Color.clear);
+
+                foreach (AnimatedSpriteLayer layer in _layers)
+                {
+                    if (!layer.frames.Any())
+                    {
+                        continue;
+                    }
+
+                    Sprite sprite = layer.frames[frameIndex];
+                    Vector2 offset = layer.offsets[frameIndex];
+                    float alpha = layer.alpha;
+                    int offsetX = Mathf.RoundToInt(offset.x);
+                    int offsetY = Mathf.RoundToInt(offset.y);
+                    Texture2D texture = sprite.texture;
+                    Rect spriteRect = sprite.rect;
+
+                    int spriteX = Mathf.RoundToInt(spriteRect.xMin);
+                    int spriteWidth = Mathf.RoundToInt(spriteRect.width);
+                    int spriteY = Mathf.RoundToInt(spriteRect.yMin);
+                    int spriteHeight = Mathf.RoundToInt(spriteRect.height);
+                    Color[] spritePixels = texture.GetPixels(
+                        spriteX,
+                        spriteY,
+                        spriteWidth,
+                        spriteHeight
+                    );
+
+                    Parallel.For(
+                        0,
+                        spritePixels.Length,
+                        inIndex =>
+                        {
+                            int x = inIndex % spriteWidth;
+                            int y = inIndex / spriteWidth;
+
+                            Color pixelColor = spritePixels[inIndex];
+                            if (pixelColor.a < pixelCutoff)
+                            {
+                                return;
+                            }
+
+                            int textureX = offsetX + x + spriteX;
+                            int textureY = offsetY + y + spriteY;
+                            int index = textureY * width + textureX;
+
+                            if (index < 0 || pixels.Length <= index)
+                            {
+                                return;
+                            }
+
+                            Color existingColor = pixels[index];
+                            if (existingColor == transparent)
+                            {
+                                existingColor = _backgroundColor;
+                            }
+
+                            Color blendedColor = Color.Lerp(existingColor, pixelColor, alpha);
+                            pixels[index] = blendedColor;
+                        }
+                    );
+                }
+
+                // Find the bounds of the non-transparent pixels in the temporary texture
+                int finalMinX = int.MaxValue;
+                int finalMaxX = int.MinValue;
+                int finalMinY = int.MaxValue;
+                int finalMaxY = int.MinValue;
+
+                Parallel.For(
+                    0,
+                    height * width,
+                    inIndex =>
+                    {
+                        Color pixelColor = pixels[inIndex];
+                        if (pixelColor.a < pixelCutoff)
+                        {
+                            return;
+                        }
+
+                        int x = inIndex % width;
+                        int y = inIndex / width;
+
+                        int expectedX = finalMinX;
+                        while (x < expectedX)
+                        {
+                            expectedX = Interlocked.CompareExchange(ref finalMinX, x, expectedX);
+                        }
+
+                        expectedX = finalMaxX;
+                        while (expectedX < x)
+                        {
+                            expectedX = Interlocked.CompareExchange(ref finalMaxX, x, expectedX);
+                        }
+
+                        int expectedY = finalMinY;
+                        while (y < expectedY)
+                        {
+                            expectedY = Interlocked.CompareExchange(ref finalMinY, y, expectedY);
+                        }
+
+                        expectedY = finalMaxY;
+                        while (expectedY < y)
+                        {
+                            expectedY = Interlocked.CompareExchange(ref finalMaxY, y, expectedY);
+                        }
+                    }
+                );
+
+                if (finalMinX == int.MaxValue)
+                {
+                    continue;
+                }
+
+                // Calculate the final width and height of the culled texture
+                int finalWidth = finalMaxX - finalMinX + 1;
+                int finalHeight = finalMaxY - finalMinY + 1;
+
+                Color[] finalPixels = new Color[finalWidth * finalHeight];
+                Array.Fill(finalPixels, _backgroundColor);
+
+                // Copy the non-transparent pixels from the temporary texture to the final texture
+                Parallel.For(
+                    0,
+                    finalWidth * finalHeight,
+                    inIndex =>
+                    {
+                        int x = inIndex % finalWidth;
+                        int y = inIndex / finalWidth;
+                        int outerX = x + finalMinX;
+                        int outerY = y + finalMinY;
+                        Color pixelColor = pixels[outerY * width + outerX];
+                        if (pixelColor.a < pixelCutoff)
+                        {
+                            return;
+                        }
+                        finalPixels[y * finalWidth + x] = pixelColor;
+                    }
+                );
+
+                Texture2D finalTexture = new(
+                    finalWidth,
+                    finalHeight,
+                    TextureFormat.RGBA32,
+                    mipChain: false,
+                    linear: false,
+                    createUninitialized: true
+                );
+                finalTexture.SetPixels(finalPixels);
+                finalTexture.Apply(false, false);
+
+                yield return finalTexture;
+            }
+        }
+    }
+}

package/Runtime/UI/LayeredImage.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d4af7f20a66c40e686d59e4253d72156
+timeCreated: 1735605169

package/Runtime/UI.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: dd17cad9fb2348fa8249a668bc458174
+timeCreated: 1735605163

package/Tests/Runtime/Performance/RandomPerformanceTests.cs

@@ -25,6 +25,9 @@
             RunTest(new XorShiftRandom(), timeout);
             RunTest(new DotNetRandom(), timeout);
             RunTest(new WyRandom(), timeout);
+            RunTest(new SplitMix64(), timeout);
+            RunTest(new RomuDuo(), timeout);
+            RunTest(new XorShiroRandom(), timeout);
         }
 
         private static void RunTest<T>(T random, TimeSpan timeout)

package/Tests/Runtime/Random/RomuDuoRandomTests.cs

@@ -0,0 +1,9 @@
+namespace UnityHelpers.Tests.Random
+{
+    using Core.Random;
+
+    public sealed class RomuDuoRandomTests : RandomTestBase
+    {
+        protected override IRandom NewRandom() => new RomuDuo();
+    }
+}

package/Tests/Runtime/Random/RomuDuoRandomTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6998ef56b2d04d58977cd95f226c6f50
+timeCreated: 1735610612

package/Tests/Runtime/Random/SplitMix64RandomTests.cs

@@ -0,0 +1,9 @@
+namespace UnityHelpers.Tests.Random
+{
+    using Core.Random;
+
+    public sealed class SplitMix64RandomTests : RandomTestBase
+    {
+        protected override IRandom NewRandom() => new SplitMix64();
+    }
+}

package/Tests/Runtime/Random/SplitMix64RandomTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9c07a25c515041908a3920ff7d2c2607
+timeCreated: 1735606130

package/Tests/Runtime/Random/XorShiroRandomTests.cs

@@ -0,0 +1,9 @@
+namespace UnityHelpers.Tests.Random
+{
+    using Core.Random;
+
+    public sealed class XorShiroRandomTests : RandomTestBase
+    {
+        protected override IRandom NewRandom() => new XorShiroRandom();
+    }
+}

package/Tests/Runtime/Random/XorShiroRandomTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 533b6ecf4c3d4115ad733f59afa8618f
+timeCreated: 1735610645

package/package.json

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