com.wallstop-studios.unity-helpers 2.0.0-rc73.7 → 2.0.0-rc73.8

package/Runtime/Core/DataStructure/Circle.cs

@@ -34,7 +34,7 @@
             float yN = Math.Max(center.y, rectangle.y);
             float dX = xN - center.x;
             float dY = yN - center.y;
-            return (dX * dX + dY * dY) <= _radiusSquared;
+            return dX * dX + dY * dY <= _radiusSquared;
         }
 
         public bool Overlaps(Bounds bounds)

package/Runtime/Core/DataStructure/QuadTree.cs

@@ -45,7 +45,7 @@
 
                 Bounds[] quadrants =
                 {
-                    new Bounds(
+                    new(
                         new Vector3(
                             boundary.center.x - halfQuadrantSize.x,
                             boundary.center.y + halfQuadrantSize.y,
@@ -53,7 +53,7 @@
                         ),
                         quadrantSize
                     ),
-                    new Bounds(
+                    new(
                         new Vector3(
                             boundary.center.x + halfQuadrantSize.x,
                             boundary.center.y + halfQuadrantSize.y,
@@ -61,7 +61,7 @@
                         ),
                         quadrantSize
                     ),
-                    new Bounds(
+                    new(
                         new Vector3(
                             boundary.center.x + halfQuadrantSize.x,
                             boundary.center.y - halfQuadrantSize.y,
@@ -69,7 +69,7 @@
                         ),
                         quadrantSize
                     ),
-                    new Bounds(
+                    new(
                         new Vector3(
                             boundary.center.x - halfQuadrantSize.x,
                             boundary.center.y - halfQuadrantSize.y,

package/Runtime/Core/Extension/ColorExtensions.cs

@@ -534,14 +534,14 @@
                 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 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;
+            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));
+            return new LABColor(116 * y - 16, 500 * (x - y), 200 * (y - z));
         }
 
         private static Color LABToRGB(double l, double a, double b)

package/Runtime/Core/Extension/IEnumerableExtensions.cs

@@ -78,7 +78,7 @@
 
         public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> items, int size)
         {
-            using var enumerator = items.GetEnumerator();
+            using IEnumerator<T> enumerator = items.GetEnumerator();
             bool hasNext = enumerator.MoveNext();
 
             IEnumerable<T> NextPartitionOf()

package/Runtime/Core/Extension/UnityExtensions.cs

@@ -126,9 +126,9 @@
                 xMin,
                 yMin,
                 zMin,
-                (xMax - xMin) + 1,
-                (yMax - yMin) + 1,
-                (zMax - zMin) + 1
+                xMax - xMin + 1,
+                yMax - yMin + 1,
+                zMax - zMin + 1
             );
         }
 
@@ -160,9 +160,9 @@
                 xMin,
                 yMin,
                 zMin,
-                (xMax - xMin) + 1,
-                (yMax - yMin) + 1,
-                (zMax - zMin) + 1
+                xMax - xMin + 1,
+                yMax - yMin + 1,
+                zMax - zMin + 1
             );
         }
 
@@ -584,8 +584,8 @@
             public float LargestAngle(FastVector3Int point)
             {
                 Vector2 worldPoint = _grid.CellToWorld(point);
-                float angleFrom = Vector2.Angle((toWorld - fromWorld), (worldPoint - fromWorld));
-                float angleTo = Vector2.Angle((fromWorld - toWorld), (worldPoint - toWorld));
+                float angleFrom = Vector2.Angle(toWorld - fromWorld, worldPoint - fromWorld);
+                float angleTo = Vector2.Angle(fromWorld - toWorld, worldPoint - toWorld);
                 return Math.Max(angleFrom, angleTo);
             }
         }
@@ -1126,7 +1126,7 @@
                 }
 
                 if (
-                    (newVector.x < position.x) == (position.x <= oldVector.x)
+                    newVector.x < position.x == position.x <= oldVector.x
                     && (position.y - (long)lhs.y) * (rhs.x - lhs.x)
                         < (rhs.y - (long)lhs.y) * (position.x - lhs.x)
                 )
@@ -1274,7 +1274,7 @@
                     yield break;
                 }
 
-                scaleFactor *= (4 / 3f);
+                scaleFactor *= 4 / 3f;
             }
         }
 
@@ -1416,8 +1416,8 @@
             float ty = v.y;
 
             Vector2 rotatedVector;
-            rotatedVector.x = (cos * tx) - (sin * ty);
-            rotatedVector.y = (sin * tx) + (cos * ty);
+            rotatedVector.x = cos * tx - sin * ty;
+            rotatedVector.y = sin * tx + cos * ty;
 
             return rotatedVector;
         }
@@ -1564,12 +1564,12 @@
 
         public static bool IsOnEdge2D(this FastVector3Int position, BoundsInt bounds)
         {
-            if (bounds.xMin == position.x || (bounds.xMax - 1) == position.x)
+            if (bounds.xMin == position.x || bounds.xMax - 1 == position.x)
             {
                 return bounds.yMin <= position.y && position.y < bounds.yMax;
             }
 
-            if (bounds.yMin == position.y || (bounds.yMax - 1) == position.y)
+            if (bounds.yMin == position.y || bounds.yMax - 1 == position.y)
             {
                 return bounds.xMin <= position.x && position.x < bounds.xMax;
             }

package/Runtime/Core/Helper/Helpers.cs

@@ -47,9 +47,9 @@
             }
 
             float a =
-                (targetVelocity.x * targetVelocity.x)
-                + (targetVelocity.y * targetVelocity.y)
-                - (projectileSpeed * projectileSpeed);
+                targetVelocity.x * targetVelocity.x
+                + targetVelocity.y * targetVelocity.y
+                - projectileSpeed * projectileSpeed;
 
             float b =
                 2
@@ -59,10 +59,10 @@
                 );
 
             float c =
-                ((target.x - launchLocation.x) * (target.x - launchLocation.x))
-                + ((target.y - launchLocation.y) * (target.y - launchLocation.y));
+                (target.x - launchLocation.x) * (target.x - launchLocation.x)
+                + (target.y - launchLocation.y) * (target.y - launchLocation.y);
 
-            float disc = b * b - (4 * a * c);
+            float disc = b * b - 4 * a * c;
             if (disc < 0)
             {
                 return target;
@@ -72,8 +72,8 @@
             float t2 = (-1 * b - Mathf.Sqrt(disc)) / (2 * a);
             float t = Mathf.Max(t1, t2); // let us take the larger time value
 
-            float aimX = target.x + (targetVelocity.x * t);
-            float aimY = target.y + (targetVelocity.y * t);
+            float aimX = target.x + targetVelocity.x * t;
+            float aimY = target.y + targetVelocity.y * t;
 
             if (float.IsNaN(aimX) || float.IsNaN(aimY))
             {
@@ -283,7 +283,7 @@
                 // optional delay execution from happening on 0, 1, 2, ... n-1 to 1, 2, ... n
                 if (
                     totalExecuted < totalCount
-                    && ((totalExecuted + (delay ? 1f : 0f)) / totalCount) <= percent
+                    && (totalExecuted + (delay ? 1f : 0f)) / totalCount <= percent
                 )
                 {
                     action();

package/Runtime/Core/Helper/Logging/UnityLogTagFormatter.cs

@@ -137,11 +137,9 @@
             const string sizeCheck = "size=";
             AddDecoration(
                 format =>
-                    (
-                        format.StartsWith(sizeCheck, StringComparison.OrdinalIgnoreCase)
-                            && int.TryParse(format.Substring(sizeCheck.Length), out _)
-                        || int.TryParse(format, out _)
-                    ),
+                    format.StartsWith(sizeCheck, StringComparison.OrdinalIgnoreCase)
+                        && int.TryParse(format.Substring(sizeCheck.Length), out _)
+                    || int.TryParse(format, out _),
                 format: (format, value) =>
                 {
                     if (!int.TryParse(format, out int size))
@@ -373,11 +371,26 @@
         )
         {
             bool stopLooping = false;
-            foreach (var entry in _matchingDecorations)
+            foreach (
+                KeyValuePair<
+                    int,
+                    List<(
+                        string tag,
+                        bool editorOnly,
+                        Func<string, bool> predicate,
+                        Func<string, object, string> formatter
+                    )>
+                > entry in _matchingDecorations
+            )
             {
                 for (int i = 0; i < entry.Value.Count; i++)
                 {
-                    var existingDecoration = entry.Value[i];
+                    (
+                        string tag,
+                        bool editorOnly,
+                        Func<string, bool> predicate,
+                        Func<string, object, string> formatter
+                    ) existingDecoration = entry.Value[i];
                     if (
                         !string.Equals(
                             existingDecoration.tag,
@@ -459,7 +472,17 @@
             ) decoration
         )
         {
-            foreach (var entry in _matchingDecorations)
+            foreach (
+                KeyValuePair<
+                    int,
+                    List<(
+                        string tag,
+                        bool editorOnly,
+                        Func<string, bool> predicate,
+                        Func<string, object, string> formatter
+                    )>
+                > entry in _matchingDecorations
+            )
             {
                 for (int i = 0; i < entry.Value.Count; ++i)
                 {

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

@@ -156,7 +156,7 @@
                 }
             }
 
-            Transform transform = (component as Transform) ?? component.transform;
+            Transform transform = component as Transform ?? component.transform;
             if (transform == null)
             {
                 return;
@@ -187,7 +187,7 @@
                 behavior.enabled = enabled;
             }
 
-            Transform transform = (component as Transform) ?? component.transform;
+            Transform transform = component as Transform ?? component.transform;
             if (transform == null)
             {
                 return;

package/Runtime/Core/Random/DotNetRandom.cs

@@ -11,7 +11,7 @@
         public static DotNetRandom Instance => ThreadLocalRandom<DotNetRandom>.Instance;
 
         public override RandomState InternalState =>
-            new RandomState(unchecked((ulong)_seed), state2: _numberGenerated);
+            new(unchecked((ulong)_seed), state2: _numberGenerated);
 
         private ulong _numberGenerated;
         private int _seed;

package/Runtime/Core/Random/SplitMix64.cs

@@ -45,7 +45,7 @@
                 ulong z = _state;
                 z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9UL;
                 z = (z ^ (z >> 27)) * 0x94D049BB133111EBUL;
-                z ^= (z >> 31);
+                z ^= z >> 31;
 
                 return (uint)z;
             }

package/Runtime/Core/Random/SquirrelRandom.cs

@@ -54,11 +54,11 @@
         private static uint NextUintInternal(ref uint seed)
         {
             seed *= BitNoise1;
-            seed ^= (seed >> 8);
+            seed ^= seed >> 8;
             seed += BitNoise2;
-            seed ^= (seed << 8);
+            seed ^= seed << 8;
             seed *= BitNoise3;
-            seed ^= (seed >> 8);
+            seed ^= seed >> 8;
             return seed;
         }
 
@@ -68,17 +68,17 @@
             uint result = unchecked((uint)x);
             result *= BitNoise1;
             result += seed;
-            result ^= (result >> 8);
+            result ^= result >> 8;
             result += BitNoise2;
-            result ^= (result << 8);
+            result ^= result << 8;
             result *= BitNoise3;
-            result ^= (result >> 8);
+            result ^= result >> 8;
             return (result >> 8) * MagicFloat;
         }
 
         private static float NextNoise(int x, int y, uint seed)
         {
-            return NextNoise(x + (LargePrime * y), seed);
+            return NextNoise(x + LargePrime * y, seed);
         }
     }
 }

package/Runtime/Core/Random/ThreadLocalRandom.cs

@@ -5,7 +5,7 @@
     public static class ThreadLocalRandom<T>
         where T : IRandom, new()
     {
-        private static readonly ThreadLocal<T> RandomCache = new ThreadLocal<T>(() => new T());
+        private static readonly ThreadLocal<T> RandomCache = new(() => new T());
 
         public static T Instance => RandomCache.Value;
     }

package/Runtime/Core/Random/WyRandom.cs

@@ -16,7 +16,7 @@
 
         public static WyRandom Instance => ThreadLocalRandom<WyRandom>.Instance;
 
-        public override RandomState InternalState => new RandomState(_state);
+        public override RandomState InternalState => new(_state);
 
         private ulong _state;
 

package/Runtime/Tags/EffectHandler.cs

@@ -297,7 +297,7 @@
                     if (cosmeticEffectData.RequiresInstancing)
                     {
                         this.LogWarn(
-                            $"Double-deregistration detected for handle {handle:json}. Existing handles: [{(string.Join(",", _instancedCosmeticEffects.Keys))}]."
+                            $"Double-deregistration detected for handle {handle:json}. Existing handles: [{string.Join(",", _instancedCosmeticEffects.Keys)}]."
                         );
                         continue;
                     }

package/Runtime/UI/LayeredImage.cs

@@ -18,13 +18,13 @@
     {
         public const float FrameRate = 12f;
 
-        public readonly Vector2[] offsets;
+        public readonly Vector2[] perFramePixelOffsets;
         public readonly Sprite[] frames;
         public readonly float alpha;
 
         public AnimatedSpriteLayer(
             IEnumerable<Sprite> sprites,
-            IEnumerable<Vector2> offsets,
+            IEnumerable<Vector2>? worldSpaceOffsets = null,
             float alpha = 1
         )
         {
@@ -37,21 +37,45 @@
                 }
 
                 frame.texture.MakeReadable();
+                try
+                {
+                    frame.texture.GetPixel(0, 0);
+                }
+                catch (UnityException e)
+                {
+                    Debug.LogError(
+                        $"Texture '{frame.texture.name}' for sprite '{frame.name}' is not readable. Please enable Read/Write in its import settings. Error: {e.Message}"
+                    );
+                }
+            }
+
+            if (worldSpaceOffsets != null && frames is { Length: > 0 })
+            {
+                perFramePixelOffsets = worldSpaceOffsets
+                    .Zip(
+                        frames,
+                        (offset, frame) =>
+                            frame != null && frame.pixelsPerUnit > 0
+                                ? frame.pixelsPerUnit * offset
+                                : Vector2.zero
+                    )
+                    .ToArray();
+                Debug.Assert(
+                    perFramePixelOffsets.Length == frames.Length,
+                    $"Expected {frames.Length} sprite frames to match {perFramePixelOffsets.Length} offsets after processing."
+                );
+            }
+            else
+            {
+                perFramePixelOffsets = null;
             }
 
-            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,
+            IEnumerable<Vector2>? worldSpaceOffsets = null,
             float alpha = 1
         )
             : this(
@@ -60,7 +84,7 @@
 #else
                 Enumerable.Empty<Sprite>(),
 #endif
-                offsets, alpha) { }
+                worldSpaceOffsets, alpha) { }
     }
 
     public sealed class LayeredImage : VisualElement
@@ -68,7 +92,6 @@
         private readonly AnimatedSpriteLayer[] _layers;
         private readonly Texture2D[] _computed;
         private readonly Color _backgroundColor;
-
         private readonly Rect? _largestArea;
 
         public LayeredImage(
@@ -81,52 +104,73 @@
             _backgroundColor = backgroundColor ?? Color.white;
             _computed = ComputeTextures().ToArray();
             _largestArea = null;
-            foreach (Texture2D computed in _computed)
+
+            foreach (Texture2D? computedTexture in _computed)
             {
+                if (computedTexture == null)
+                {
+                    continue;
+                }
+
                 if (_largestArea == null)
                 {
-                    _largestArea = new Rect(0, 0, computed.width, computed.height);
+                    _largestArea = new Rect(0, 0, computedTexture.width, computedTexture.height);
                 }
                 else
                 {
-                    Rect largestArea = _largestArea.Value;
-                    largestArea.width = Mathf.Max(largestArea.width, computed.width);
-                    largestArea.height = Mathf.Max(largestArea.height, computed.height);
-                    _largestArea = largestArea;
+                    Rect currentLargest = _largestArea.Value;
+                    currentLargest.width = Mathf.Max(currentLargest.width, computedTexture.width);
+                    currentLargest.height = Mathf.Max(
+                        currentLargest.height,
+                        computedTexture.height
+                    );
+                    _largestArea = currentLargest;
                 }
             }
 
             Render(0);
-            float fpsMs = 1000f / fps;
-            if (1 < _computed.Length)
+
+            if (_computed.Length > 1 && fps > 0)
             {
 #if UNITY_EDITOR
                 if (!Application.isPlaying)
                 {
                     TimeSpan lastTick = TimeSpan.Zero;
-                    TimeSpan fpsSpan = TimeSpan.FromMilliseconds(fpsMs);
+                    TimeSpan fpsSpan = TimeSpan.FromMilliseconds(1000f / fps);
                     int index = 0;
                     Stopwatch timer = Stopwatch.StartNew();
                     EditorApplication.update += () =>
                     {
+                        if (panel == null)
+                        {
+                            EditorApplication.update = null;
+                            return;
+                        }
                         TimeSpan elapsed = timer.Elapsed;
-                        if (lastTick + fpsSpan < elapsed)
+                        if (lastTick + fpsSpan >= elapsed)
                         {
-                            index = index.WrappedIncrement(_computed.Length);
-                            lastTick = elapsed;
-                            Render(index);
+                            return;
                         }
+
+                        index = (index + 1) % _computed.Length;
+                        lastTick = elapsed;
+                        Render(index);
                     };
                     return;
                 }
-
 #endif
+                if (Application.isPlaying && CoroutineHandler.Instance != null)
                 {
                     int index = 0;
                     CoroutineHandler.Instance.StartFunctionAsCoroutine(
                         () =>
                         {
-                            index = index.WrappedIncrement(_computed.Length);
+                            if (panel == null)
+                            {
+                                return;
+                            }
+
+                            index = (index + 1) % _computed.Length;
                             Render(index);
                         },
                         1f / fps
@@ -137,6 +181,11 @@
 
         private void Render(int index)
         {
+            if (index < 0 || index >= _computed.Length)
+            {
+                return;
+            }
+
             Texture2D computed = _computed[index];
             if (computed != null)
             {
@@ -144,205 +193,303 @@
                 style.width = computed.width;
                 style.height = computed.height;
             }
+            else
+            {
+                style.backgroundImage = null;
+                style.width = _largestArea?.width ?? 0;
+                style.height = _largestArea?.height ?? 0;
+            }
 
             style.marginRight = 0;
             style.marginBottom = 0;
-            if (_largestArea != null)
+            if (_largestArea == null)
             {
-                Rect largestArea = _largestArea.Value;
-                if (style.width.value.value < largestArea.width)
-                {
-                    style.marginRight = largestArea.width - style.width.value.value;
-                }
+                return;
+            }
 
-                if (style.height.value.value < largestArea.height)
-                {
-                    style.marginBottom = largestArea.height - style.height.value.value;
-                }
+            Rect largestAreaRect = _largestArea.Value;
+            float currentWidth = computed != null ? computed.width : _largestArea?.width ?? 0;
+            float currentHeight = computed != null ? computed.height : _largestArea?.height ?? 0;
+
+            if (currentWidth < largestAreaRect.width)
+            {
+                style.marginRight = largestAreaRect.width - currentWidth;
+            }
+            if (currentHeight < largestAreaRect.height)
+            {
+                style.marginBottom = largestAreaRect.height - currentHeight;
             }
         }
 
-        private IEnumerable<Texture2D> ComputeTextures()
+        private IEnumerable<Texture2D?> ComputeTextures()
         {
             const float pixelCutoff = 0.01f;
-            int frameCount = _layers.Select(layer => layer.frames.Length).Distinct().Single();
+            if (_layers is not { Length: > 0 })
+            {
+                yield break;
+            }
+
+            int frameCount = 0;
+            foreach (AnimatedSpriteLayer layer in _layers)
+            {
+                if (layer.frames != null)
+                {
+                    frameCount = Mathf.Max(frameCount, layer.frames.Length);
+                }
+            }
+            if (frameCount == 0)
+            {
+                yield break;
+            }
 
-            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;
+                float overallMinX = float.MaxValue;
+                float overallMaxX = float.MinValue;
+                float overallMinY = float.MaxValue;
+                float overallMaxY = float.MinValue;
+                bool hasVisibleSpriteThisFrame = false;
+
                 foreach (AnimatedSpriteLayer layer in _layers)
                 {
-                    if (layer.frames.Length <= 0)
+                    if (layer.frames == null || frameIndex >= layer.frames.Length)
                     {
                         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 (sprite == null)
+                    {
+                        continue;
+                    }
+
+                    hasVisibleSpriteThisFrame = true;
+                    Rect spriteGeomRect = sprite.rect;
+                    Vector2 pivot = sprite.pivot;
+
+                    Vector2 additionalPixelOffset = Vector2.zero;
+                    if (
+                        layer.perFramePixelOffsets != null
+                        && frameIndex < layer.perFramePixelOffsets.Length
+                    )
+                    {
+                        additionalPixelOffset = layer.perFramePixelOffsets[frameIndex];
+                    }
+
+                    float spriteWorldMinX = -pivot.x + additionalPixelOffset.x;
+                    float spriteWorldMaxX =
+                        spriteGeomRect.width - pivot.x + additionalPixelOffset.x;
+                    float spriteWorldMinY = -pivot.y + additionalPixelOffset.y;
+                    float spriteWorldMaxY =
+                        spriteGeomRect.height - pivot.y + additionalPixelOffset.y;
+
+                    overallMinX = Mathf.Min(overallMinX, spriteWorldMinX);
+                    overallMaxX = Mathf.Max(overallMaxX, spriteWorldMaxX);
+                    overallMinY = Mathf.Min(overallMinY, spriteWorldMinY);
+                    overallMaxY = Mathf.Max(overallMaxY, spriteWorldMaxY);
+                }
+
+                if (!hasVisibleSpriteThisFrame)
+                {
+                    yield return null;
+                    continue;
                 }
 
-                if (minX == int.MaxValue)
+                int compositeBufferOriginX = Mathf.FloorToInt(overallMinX);
+                int compositeBufferOriginY = Mathf.FloorToInt(overallMinY);
+                int compositeBufferWidth = Mathf.CeilToInt(overallMaxX) - compositeBufferOriginX;
+                int compositeBufferHeight = Mathf.CeilToInt(overallMaxY) - compositeBufferOriginY;
+
+                if (compositeBufferWidth <= 0 || compositeBufferHeight <= 0)
                 {
+                    yield return null;
                     continue;
                 }
 
-                // Calculate the width and height of the non-transparent region
-                int width = maxX - minX + 1;
-                int height = maxY - minY + 1;
+                Color[] bufferPixels = new Color[compositeBufferWidth * compositeBufferHeight];
 
-                Color[] pixels = new Color[width * height];
-                Array.Fill(pixels, Color.clear);
+                Array.Fill(bufferPixels, Color.clear);
 
                 foreach (AnimatedSpriteLayer layer in _layers)
                 {
-                    if (layer.frames.Length <= 0)
+                    if (layer.frames == null || frameIndex >= layer.frames.Length)
                     {
                         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
-                    );
+                    if (sprite == null)
+                    {
+                        continue;
+                    }
 
-                    Parallel.For(
-                        0,
-                        spritePixels.Length,
-                        inIndex =>
-                        {
-                            int x = inIndex % spriteWidth;
-                            int y = inIndex / spriteWidth;
+                    float layerAlpha = layer.alpha;
+                    Texture2D spriteTexture = sprite.texture;
+                    Rect spriteGeomRect = sprite.rect;
+                    Vector2 pivot = sprite.pivot;
 
-                            Color pixelColor = spritePixels[inIndex];
-                            if (pixelColor.a < pixelCutoff)
-                            {
-                                return;
-                            }
+                    Vector2 additionalPixelOffset = Vector2.zero;
+                    if (
+                        layer.perFramePixelOffsets != null
+                        && frameIndex < layer.perFramePixelOffsets.Length
+                    )
+                    {
+                        additionalPixelOffset = layer.perFramePixelOffsets[frameIndex];
+                    }
 
-                            int textureX = (-1 * minX) + offsetX + x + spriteX;
-                            int textureY = (-1 * minY) + offsetY + y + spriteY;
-                            int index = textureY * width + textureX;
+                    int spriteRectX = Mathf.FloorToInt(spriteGeomRect.x);
+                    int spriteRectY = Mathf.FloorToInt(spriteGeomRect.y);
+                    int spriteRectWidth = Mathf.FloorToInt(spriteGeomRect.width);
+                    int spriteRectHeight = Mathf.FloorToInt(spriteGeomRect.height);
 
-                            if (index < 0 || pixels.Length <= index)
-                            {
-                                return;
-                            }
+                    if (spriteRectWidth <= 0 || spriteRectHeight <= 0)
+                    {
+                        continue;
+                    }
 
-                            Color existingColor = pixels[index];
-                            if (existingColor == transparent)
+                    Color[] spriteRawPixels = spriteTexture.GetPixels(
+                        spriteRectX,
+                        spriteRectY,
+                        spriteRectWidth,
+                        spriteRectHeight
+                    );
+
+                    Parallel.For(
+                        0,
+                        spriteRectHeight,
+                        sySprite =>
+                        {
+                            for (int sxSprite = 0; sxSprite < spriteRectWidth; ++sxSprite)
                             {
-                                existingColor = _backgroundColor;
+                                Color spritePixelColor = spriteRawPixels[
+                                    sySprite * spriteRectWidth + sxSprite
+                                ];
+
+                                if (spritePixelColor.a < pixelCutoff)
+                                {
+                                    continue;
+                                }
+
+                                float pixelWorldX = sxSprite - pivot.x + additionalPixelOffset.x;
+                                float pixelWorldY = sySprite - pivot.y + additionalPixelOffset.y;
+                                int bufferX = Mathf.FloorToInt(
+                                    pixelWorldX - compositeBufferOriginX
+                                );
+                                int bufferY = Mathf.FloorToInt(
+                                    pixelWorldY - compositeBufferOriginY
+                                );
+
+                                if (
+                                    bufferX < 0
+                                    || bufferX >= compositeBufferWidth
+                                    || bufferY < 0
+                                    || bufferY >= compositeBufferHeight
+                                )
+                                {
+                                    continue;
+                                }
+
+                                int bufferIndex = bufferY * compositeBufferWidth + bufferX;
+                                Color existingColor = bufferPixels[bufferIndex];
+                                if (existingColor.a < pixelCutoff)
+                                {
+                                    existingColor = _backgroundColor;
+                                }
+
+                                Color blendedColor = Color.Lerp(
+                                    existingColor,
+                                    spritePixelColor,
+                                    layerAlpha
+                                );
+
+                                bufferPixels[bufferIndex] = blendedColor;
                             }
-
-                            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;
+                int finalMinX = int.MaxValue,
+                    finalMaxX = int.MinValue;
+                int finalMinY = int.MaxValue,
+                    finalMaxY = int.MinValue;
 
                 Parallel.For(
                     0,
-                    height * width,
-                    inIndex =>
+                    compositeBufferHeight * compositeBufferWidth,
+                    bufferIndex =>
                     {
-                        Color pixelColor = pixels[inIndex];
-                        if (pixelColor.a < pixelCutoff)
-                        {
-                            return;
-                        }
-
-                        int x = inIndex % width;
-                        int y = inIndex / width;
-
-                        int expectedX = finalMinX;
-                        while (x < expectedX)
+                        if (bufferPixels[bufferIndex].a >= pixelCutoff)
                         {
-                            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);
-                        }
+                            int x = bufferIndex % compositeBufferWidth;
+                            int y = bufferIndex / compositeBufferWidth;
 
-                        expectedY = finalMaxY;
-                        while (expectedY < y)
-                        {
-                            expectedY = Interlocked.CompareExchange(ref finalMaxY, y, expectedY);
+                            int currentVal;
+                            do
+                            {
+                                currentVal = Volatile.Read(ref finalMinX);
+                            } while (
+                                x < currentVal
+                                && Interlocked.CompareExchange(ref finalMinX, x, currentVal)
+                                    != currentVal
+                            );
+                            do
+                            {
+                                currentVal = Volatile.Read(ref finalMaxX);
+                            } while (
+                                x > currentVal
+                                && Interlocked.CompareExchange(ref finalMaxX, x, currentVal)
+                                    != currentVal
+                            );
+                            do
+                            {
+                                currentVal = Volatile.Read(ref finalMinY);
+                            } while (
+                                y < currentVal
+                                && Interlocked.CompareExchange(ref finalMinY, y, currentVal)
+                                    != currentVal
+                            );
+                            do
+                            {
+                                currentVal = Volatile.Read(ref finalMaxY);
+                            } while (
+                                y > currentVal
+                                && Interlocked.CompareExchange(ref finalMaxY, y, currentVal)
+                                    != currentVal
+                            );
                         }
                     }
                 );
 
                 if (finalMinX == int.MaxValue)
                 {
+                    yield return null;
                     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
+                Array.Fill(finalPixels, _backgroundColor);
                 Parallel.For(
                     0,
-                    finalWidth * finalHeight,
-                    inIndex =>
+                    finalHeight,
+                    yFinal =>
                     {
-                        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)
+                        for (int xFinal = 0; xFinal < finalWidth; ++xFinal)
                         {
-                            return;
+                            int bufferX = finalMinX + xFinal;
+                            int bufferY = finalMinY + yFinal;
+                            Color pixelColor = bufferPixels[
+                                bufferY * compositeBufferWidth + bufferX
+                            ];
+
+                            if (pixelColor.a >= pixelCutoff)
+                            {
+                                finalPixels[yFinal * finalWidth + xFinal] = pixelColor;
+                            }
                         }
-                        finalPixels[y * finalWidth + x] = pixelColor;
                     }
                 );
 
@@ -351,12 +498,11 @@
                     finalHeight,
                     TextureFormat.RGBA32,
                     mipChain: false,
-                    linear: false,
-                    createUninitialized: true
+                    linear: false
                 );
-                finalTexture.SetPixels(finalPixels);
-                finalTexture.Apply(false, false);
 
+                finalTexture.SetPixels(finalPixels);
+                finalTexture.Apply(updateMipmaps: false, makeNoLongerReadable: false);
                 yield return finalTexture;
             }
         }

package/Runtime/Utils/AnimatorEnumStateMachine.cs

@@ -21,7 +21,7 @@
 
         [JsonIgnore]
         [IgnoreDataMember]
-        private readonly HashSet<string> _availableBools = new HashSet<string>();
+        private readonly HashSet<string> _availableBools = new();
 
         [JsonIgnore]
         [IgnoreDataMember]

package/Runtime/Utils/SetTextureImportData.cs

@@ -53,7 +53,7 @@
 
             tImporter.isReadable = isReadable;
 
-            TextureImporterPlatformSettings importerSettings = new TextureImporterPlatformSettings
+            TextureImporterPlatformSettings importerSettings = new()
             {
                 resizeAlgorithm = TextureResizeAlgorithm.Bilinear,
                 maxTextureSize = MaxTextureSize,

package/Runtime/Utils/TextureScale.cs

@@ -54,8 +54,8 @@
             }
             else
             {
-                ratioX = ((float)tex.width) / newWidth;
-                ratioY = ((float)tex.height) / newHeight;
+                ratioX = (float)tex.width / newWidth;
+                ratioY = (float)tex.height / newHeight;
             }
 
             w = tex.width;
@@ -123,7 +123,7 @@
                 int y2 = (yFloor + 1) * w;
                 int yw = y * w2;
 
-                for (var x = 0; x < w2; x++)
+                for (int x = 0; x < w2; x++)
                 {
                     int xFloor = (int)Mathf.Floor(x * ratioX);
                     float xLerp = x * ratioX - xFloor;
@@ -155,7 +155,7 @@
             {
                 int thisY = (int)(ratioY * y) * w;
                 int yw = y * w2;
-                for (var x = 0; x < w2; x++)
+                for (int x = 0; x < w2; x++)
                 {
                     newColors[yw + x] = texColors[(int)(thisY + ratioX * x)];
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "2.0.0-rc73.7",
+  "version": "2.0.0-rc73.8",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},
@@ -43,3 +43,4 @@
 
 
 
+