com.wallstop-studios.unity-helpers 2.0.0-rc73.19 → 2.0.0-rc73.3

package/Runtime/UI/LayeredImage.cs

@@ -18,13 +18,13 @@
     {
         public const float FrameRate = 12f;
 
-        public readonly Vector2[] perFramePixelOffsets;
+        public readonly Vector2[] offsets;
         public readonly Sprite[] frames;
         public readonly float alpha;
 
         public AnimatedSpriteLayer(
             IEnumerable<Sprite> sprites,
-            IEnumerable<Vector2> worldSpaceOffsets = null,
+            IEnumerable<Vector2> offsets,
             float alpha = 1
         )
         {
@@ -37,45 +37,21 @@
                 }
 
                 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> worldSpaceOffsets = null,
+            IEnumerable<Vector2> offsets,
             float alpha = 1
         )
             : this(
@@ -84,7 +60,7 @@
 #else
                 Enumerable.Empty<Sprite>(),
 #endif
-                worldSpaceOffsets, alpha) { }
+                offsets, alpha) { }
     }
 
     public sealed class LayeredImage : VisualElement
@@ -92,6 +68,7 @@
         private readonly AnimatedSpriteLayer[] _layers;
         private readonly Texture2D[] _computed;
         private readonly Color _backgroundColor;
+
         private readonly Rect? _largestArea;
 
         public LayeredImage(
@@ -104,74 +81,51 @@
             _backgroundColor = backgroundColor ?? Color.white;
             _computed = ComputeTextures().ToArray();
             _largestArea = null;
-
-            foreach (Texture2D? computedTexture in _computed)
+            foreach (Texture2D computed in _computed)
             {
-                if (computedTexture == null)
-                {
-                    continue;
-                }
-
                 if (_largestArea == null)
                 {
-                    _largestArea = new Rect(0, 0, computedTexture.width, computedTexture.height);
+                    _largestArea = new Rect(0, 0, computed.width, computed.height);
                 }
                 else
                 {
-                    Rect currentLargest = _largestArea.Value;
-                    currentLargest.width = Mathf.Max(currentLargest.width, computedTexture.width);
-                    currentLargest.height = Mathf.Max(
-                        currentLargest.height,
-                        computedTexture.height
-                    );
-                    _largestArea = currentLargest;
+                    Rect largestArea = _largestArea.Value;
+                    largestArea.width = Mathf.Max(largestArea.width, computed.width);
+                    largestArea.height = Mathf.Max(largestArea.height, computed.height);
+                    _largestArea = largestArea;
                 }
             }
 
             Render(0);
-
-            if (_computed.Length > 1 && fps > 0)
+            float fpsMs = 1000f / fps;
+            if (1 < _computed.Length)
             {
 #if UNITY_EDITOR
                 if (!Application.isPlaying)
                 {
                     TimeSpan lastTick = TimeSpan.Zero;
-                    TimeSpan fpsSpan = TimeSpan.FromMilliseconds(1000f / fps);
+                    TimeSpan fpsSpan = TimeSpan.FromMilliseconds(fpsMs);
                     int index = 0;
                     Stopwatch timer = Stopwatch.StartNew();
-                    EditorApplication.update += Tick;
-                    return;
-
-                    void Tick()
+                    EditorApplication.update += () =>
                     {
-                        if (panel == null)
-                        {
-                            EditorApplication.update -= Tick;
-                            return;
-                        }
                         TimeSpan elapsed = timer.Elapsed;
-                        if (lastTick + fpsSpan >= elapsed)
+                        if (lastTick + fpsSpan < elapsed)
                         {
-                            return;
+                            index = index.WrappedIncrement(_computed.Length);
+                            lastTick = elapsed;
+                            Render(index);
                         }
-
-                        index = index.WrappedIncrement(_computed.Length);
-                        lastTick = elapsed;
-                        Render(index);
-                    }
+                    };
+                    return;
                 }
+
 #endif
-                if (Application.isPlaying && CoroutineHandler.Instance != null)
                 {
                     int index = 0;
                     CoroutineHandler.Instance.StartFunctionAsCoroutine(
                         () =>
                         {
-                            if (panel == null)
-                            {
-                                return;
-                            }
-
                             index = index.WrappedIncrement(_computed.Length);
                             Render(index);
                         },
@@ -183,11 +137,6 @@
 
         private void Render(int index)
         {
-            if (index < 0 || index >= _computed.Length)
-            {
-                return;
-            }
-
             Texture2D computed = _computed[index];
             if (computed != null)
             {
@@ -195,303 +144,205 @@
                 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)
             {
-                return;
-            }
-
-            Rect largestAreaRect = _largestArea.Value;
-            float currentWidth = computed != null ? computed.width : _largestArea?.width ?? 0;
-            float currentHeight = computed != null ? computed.height : _largestArea?.height ?? 0;
+                Rect largestArea = _largestArea.Value;
+                if (style.width.value.value < largestArea.width)
+                {
+                    style.marginRight = largestArea.width - style.width.value.value;
+                }
 
-            if (currentWidth < largestAreaRect.width)
-            {
-                style.marginRight = largestAreaRect.width - currentWidth;
-            }
-            if (currentHeight < largestAreaRect.height)
-            {
-                style.marginBottom = largestAreaRect.height - currentHeight;
+                if (style.height.value.value < largestArea.height)
+                {
+                    style.marginBottom = largestArea.height - style.height.value.value;
+                }
             }
         }
 
-        private IEnumerable<Texture2D?> ComputeTextures()
+        private IEnumerable<Texture2D> ComputeTextures()
         {
             const float pixelCutoff = 0.01f;
-            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;
-            }
+            int frameCount = _layers.Select(layer => layer.frames.Length).Distinct().Single();
 
+            Color transparent = Color.clear;
             for (int frameIndex = 0; frameIndex < frameCount; ++frameIndex)
             {
-                float overallMinX = float.MaxValue;
-                float overallMaxX = float.MinValue;
-                float overallMinY = float.MaxValue;
-                float overallMaxY = float.MinValue;
-                bool hasVisibleSpriteThisFrame = false;
-
+                int minX = int.MaxValue;
+                int maxX = int.MinValue;
+                int minY = int.MaxValue;
+                int maxY = int.MinValue;
                 foreach (AnimatedSpriteLayer layer in _layers)
                 {
-                    if (layer.frames == null || frameIndex >= layer.frames.Length)
+                    if (layer.frames.Length <= 0)
                     {
                         continue;
                     }
 
                     Sprite sprite = layer.frames[frameIndex];
-                    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;
+                    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);
                 }
 
-                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)
+                if (minX == int.MaxValue)
                 {
-                    yield return null;
                     continue;
                 }
 
-                Color[] bufferPixels = new Color[compositeBufferWidth * compositeBufferHeight];
+                // Calculate the width and height of the non-transparent region
+                int width = maxX - minX + 1;
+                int height = maxY - minY + 1;
 
-                Array.Fill(bufferPixels, Color.clear);
+                Color[] pixels = new Color[width * height];
+                Array.Fill(pixels, Color.clear);
 
                 foreach (AnimatedSpriteLayer layer in _layers)
                 {
-                    if (layer.frames == null || frameIndex >= layer.frames.Length)
+                    if (layer.frames.Length <= 0)
                     {
                         continue;
                     }
 
                     Sprite sprite = layer.frames[frameIndex];
-                    if (sprite == null)
-                    {
-                        continue;
-                    }
-
-                    float layerAlpha = layer.alpha;
-                    Texture2D spriteTexture = sprite.texture;
-                    Rect spriteGeomRect = sprite.rect;
-                    Vector2 pivot = sprite.pivot;
-
-                    Vector2 additionalPixelOffset = Vector2.zero;
-                    if (
-                        layer.perFramePixelOffsets != null
-                        && frameIndex < layer.perFramePixelOffsets.Length
-                    )
-                    {
-                        additionalPixelOffset = layer.perFramePixelOffsets[frameIndex];
-                    }
-
-                    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 (spriteRectWidth <= 0 || spriteRectHeight <= 0)
-                    {
-                        continue;
-                    }
-
-                    Color[] spriteRawPixels = spriteTexture.GetPixels(
-                        spriteRectX,
-                        spriteRectY,
-                        spriteRectWidth,
-                        spriteRectHeight
+                    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,
-                        spriteRectHeight,
-                        sySprite =>
+                        spritePixels.Length,
+                        inIndex =>
                         {
-                            for (int sxSprite = 0; sxSprite < spriteRectWidth; ++sxSprite)
+                            int x = inIndex % spriteWidth;
+                            int y = inIndex / spriteWidth;
+
+                            Color pixelColor = spritePixels[inIndex];
+                            if (pixelColor.a < pixelCutoff)
                             {
-                                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;
+                                return;
+                            }
+
+                            int textureX = (-1 * minX) + offsetX + x + spriteX;
+                            int textureY = (-1 * minY) + 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;
                         }
                     );
                 }
 
-                int finalMinX = int.MaxValue,
-                    finalMaxX = int.MinValue;
-                int finalMinY = int.MaxValue,
-                    finalMaxY = int.MinValue;
+                // 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,
-                    compositeBufferHeight * compositeBufferWidth,
-                    bufferIndex =>
+                    height * width,
+                    inIndex =>
                     {
-                        if (bufferPixels[bufferIndex].a >= pixelCutoff)
+                        Color pixelColor = pixels[inIndex];
+                        if (pixelColor.a < pixelCutoff)
                         {
-                            int x = bufferIndex % compositeBufferWidth;
-                            int y = bufferIndex / compositeBufferWidth;
+                            return;
+                        }
 
-                            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
-                            );
+                        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)
                 {
-                    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
                 Parallel.For(
                     0,
-                    finalHeight,
-                    yFinal =>
+                    finalWidth * finalHeight,
+                    inIndex =>
                     {
-                        for (int xFinal = 0; xFinal < finalWidth; ++xFinal)
+                        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)
                         {
-                            int bufferX = finalMinX + xFinal;
-                            int bufferY = finalMinY + yFinal;
-                            Color pixelColor = bufferPixels[
-                                bufferY * compositeBufferWidth + bufferX
-                            ];
-
-                            if (pixelColor.a >= pixelCutoff)
-                            {
-                                finalPixels[yFinal * finalWidth + xFinal] = pixelColor;
-                            }
+                            return;
                         }
+                        finalPixels[y * finalWidth + x] = pixelColor;
                     }
                 );
 
@@ -500,11 +351,12 @@
                     finalHeight,
                     TextureFormat.RGBA32,
                     mipChain: false,
-                    linear: false
+                    linear: false,
+                    createUninitialized: true
                 );
-
                 finalTexture.SetPixels(finalPixels);
-                finalTexture.Apply(updateMipmaps: false, makeNoLongerReadable: false);
+                finalTexture.Apply(false, false);
+
                 yield return finalTexture;
             }
         }

package/Runtime/Utils/AnimatorEnumStateMachine.cs

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

package/Runtime/Utils/SetTextureImportData.cs

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