com.wallstop-studios.unity-helpers 2.0.0-rc75.9 → 2.0.0-rc76.1

package/Runtime/UI/LayeredImage.cs

@@ -8,13 +8,15 @@
     using System.Threading.Tasks;
     using Core.Extension;
     using Core.Helper;
-    using UnityEditor;
     using UnityEngine;
     using UnityEngine.UIElements;
     using Utils;
     using Debug = UnityEngine.Debug;
+#if UNITY_EDITOR
+    using UnityEditor;
+#endif
 
-    public readonly struct AnimatedSpriteLayer
+    public readonly struct AnimatedSpriteLayer : IEquatable<AnimatedSpriteLayer>
     {
         public const float FrameRate = 12f;
 
@@ -85,27 +87,122 @@
                 Enumerable.Empty<Sprite>(),
 #endif
                 worldSpaceOffsets, alpha) { }
+
+        public static bool operator ==(AnimatedSpriteLayer left, AnimatedSpriteLayer right)
+        {
+            return left.Equals(right);
+        }
+
+        public static bool operator !=(AnimatedSpriteLayer left, AnimatedSpriteLayer right)
+        {
+            return !left.Equals(right);
+        }
+
+        public bool Equals(AnimatedSpriteLayer other)
+        {
+            bool equal = perFramePixelOffsets.AsSpan().SequenceEqual(other.perFramePixelOffsets);
+            if (!equal)
+            {
+                return false;
+            }
+
+            equal = frames.Length == other.frames.Length;
+            if (!equal)
+            {
+                return false;
+            }
+
+            for (int i = 0; i < frames.Length; ++i)
+            {
+                if (frames[i] != other.frames[i])
+                {
+                    return false;
+                }
+            }
+
+            return alpha.Equals(other.alpha);
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is AnimatedSpriteLayer other && Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            return Objects.ValueTypeHashCode(perFramePixelOffsets.Length, frames.Length, alpha);
+        }
     }
 
     public sealed class LayeredImage : VisualElement
     {
+        public float Fps
+        {
+            get => _fps;
+            set
+            {
+                if (_fps == value)
+                {
+                    return;
+                }
+
+                _fps = value;
+                if (_updatesSelf && _computed.Length > 1 && _fps > 0)
+                {
+#if UNITY_EDITOR
+                    if (Application.isEditor && !Application.isPlaying && !_tickAttached)
+                    {
+                        EditorApplication.update += () => Update(force: false);
+                        _tickAttached = true;
+                        return;
+                    }
+#endif
+                    if (Application.isPlaying)
+                    {
+                        if (_coroutine != null)
+                        {
+                            CoroutineHandler.Instance.StopCoroutine(_coroutine);
+                        }
+
+                        _coroutine = CoroutineHandler.Instance.StartFunctionAsCoroutine(
+                            () => Update(force: true),
+                            1f / _fps
+                        );
+                    }
+                }
+            }
+        }
+
         private readonly AnimatedSpriteLayer[] _layers;
         private readonly Texture2D[] _computed;
         private readonly Color _backgroundColor;
         private readonly Rect? _largestArea;
+        private readonly Stopwatch _timer;
+        private readonly bool _updatesSelf;
+        private readonly float _pixelCutoff;
+
+        private TimeSpan _lastTick;
+        private Coroutine _coroutine;
+        private bool _tickAttached;
+        private float _fps;
+        private int _index;
 
         public LayeredImage(
             IEnumerable<AnimatedSpriteLayer> inputSpriteLayers,
             Color? backgroundColor = null,
-            float fps = AnimatedSpriteLayer.FrameRate
+            float fps = AnimatedSpriteLayer.FrameRate,
+            bool updatesSelf = true,
+            float pixelCutoff = 0.01f
         )
         {
+            _pixelCutoff = pixelCutoff;
             _layers = inputSpriteLayers.ToArray();
             _backgroundColor = backgroundColor ?? Color.white;
             _computed = ComputeTextures().ToArray();
             _largestArea = null;
+            _updatesSelf = updatesSelf;
 
-            foreach (Texture2D? computedTexture in _computed)
+            foreach (Texture2D computedTexture in _computed)
             {
                 if (computedTexture == null)
                 {
@@ -128,57 +225,33 @@
                 }
             }
 
-            Render(0);
+            _timer = Stopwatch.StartNew();
+            Fps = fps;
+            Update();
+        }
 
-            if (_computed.Length > 1 && fps > 0)
+        public void Update(bool force = false)
+        {
+            if (panel == null)
             {
-#if UNITY_EDITOR
-                if (!Application.isPlaying)
-                {
-                    TimeSpan lastTick = TimeSpan.Zero;
-                    TimeSpan fpsSpan = TimeSpan.FromMilliseconds(1000f / fps);
-                    int index = 0;
-                    Stopwatch timer = Stopwatch.StartNew();
-                    EditorApplication.update += Tick;
-                    return;
-
-                    void Tick()
-                    {
-                        if (panel == null)
-                        {
-                            EditorApplication.update -= Tick;
-                            return;
-                        }
-                        TimeSpan elapsed = timer.Elapsed;
-                        if (lastTick + fpsSpan >= elapsed)
-                        {
-                            return;
-                        }
+                return;
+            }
 
-                        index = index.WrappedIncrement(_computed.Length);
-                        lastTick = elapsed;
-                        Render(index);
-                    }
-                }
-#endif
-                if (Application.isPlaying && CoroutineHandler.Instance != null)
-                {
-                    int index = 0;
-                    CoroutineHandler.Instance.StartFunctionAsCoroutine(
-                        () =>
-                        {
-                            if (panel == null)
-                            {
-                                return;
-                            }
+            if (_computed.Length == 0)
+            {
+                return;
+            }
 
-                            index = index.WrappedIncrement(_computed.Length);
-                            Render(index);
-                        },
-                        1f / fps
-                    );
-                }
+            TimeSpan elapsed = _timer.Elapsed;
+            TimeSpan deltaTime = TimeSpan.FromMilliseconds(1000 / _fps);
+            if (!force && _lastTick + deltaTime > elapsed)
+            {
+                return;
             }
+
+            _index = _index.WrappedIncrement(_computed.Length);
+            _lastTick += deltaTime;
+            Render(_index);
         }
 
         private void Render(int index)
@@ -223,9 +296,8 @@
             }
         }
 
-        private IEnumerable<Texture2D?> ComputeTextures()
+        private IEnumerable<Texture2D> ComputeTextures()
         {
-            const float pixelCutoff = 0.01f;
             if (_layers is not { Length: > 0 })
             {
                 yield break;
@@ -367,7 +439,7 @@
                                     sySprite * spriteRectWidth + sxSprite
                                 ];
 
-                                if (spritePixelColor.a < pixelCutoff)
+                                if (spritePixelColor.a < _pixelCutoff)
                                 {
                                     continue;
                                 }
@@ -393,7 +465,7 @@
 
                                 int bufferIndex = bufferY * compositeBufferWidth + bufferX;
                                 Color existingColor = bufferPixels[bufferIndex];
-                                if (existingColor.a < pixelCutoff)
+                                if (existingColor.a < _pixelCutoff)
                                 {
                                     existingColor = _backgroundColor;
                                 }
@@ -410,66 +482,89 @@
                     );
                 }
 
-                int finalMinX = int.MaxValue,
-                    finalMaxX = int.MinValue;
-                int finalMinY = int.MaxValue,
-                    finalMaxY = int.MinValue;
+                int globalMinX = int.MaxValue;
+                int globalMaxX = int.MinValue;
+                int globalMinY = int.MaxValue;
+                int globalMaxY = int.MinValue;
+                object sync = new();
 
                 Parallel.For(
                     0,
-                    compositeBufferHeight * compositeBufferWidth,
-                    bufferIndex =>
+                    compositeBufferHeight,
+                    () =>
+                        (
+                            minX: int.MaxValue,
+                            maxX: int.MinValue,
+                            minY: int.MaxValue,
+                            maxY: int.MinValue
+                        ),
+                    (y, _, local) =>
                     {
-                        if (bufferPixels[bufferIndex].a >= pixelCutoff)
+                        int baseIndex = y * compositeBufferWidth;
+                        for (int x = 0; x < compositeBufferWidth; ++x)
                         {
-                            int x = bufferIndex % compositeBufferWidth;
-                            int y = bufferIndex / compositeBufferWidth;
+                            if (bufferPixels[baseIndex + x].a < _pixelCutoff)
+                            {
+                                continue;
+                            }
 
-                            int currentVal;
-                            do
+                            if (x < local.minX)
                             {
-                                currentVal = Volatile.Read(ref finalMinX);
-                            } while (
-                                x < currentVal
-                                && Interlocked.CompareExchange(ref finalMinX, x, currentVal)
-                                    != currentVal
-                            );
-                            do
+                                local.minX = x;
+                            }
+
+                            if (x > local.maxX)
                             {
-                                currentVal = Volatile.Read(ref finalMaxX);
-                            } while (
-                                x > currentVal
-                                && Interlocked.CompareExchange(ref finalMaxX, x, currentVal)
-                                    != currentVal
-                            );
-                            do
+                                local.maxX = x;
+                            }
+
+                            if (y < local.minY)
                             {
-                                currentVal = Volatile.Read(ref finalMinY);
-                            } while (
-                                y < currentVal
-                                && Interlocked.CompareExchange(ref finalMinY, y, currentVal)
-                                    != currentVal
-                            );
-                            do
+                                local.minY = y;
+                            }
+
+                            if (y > local.maxY)
                             {
-                                currentVal = Volatile.Read(ref finalMaxY);
-                            } while (
-                                y > currentVal
-                                && Interlocked.CompareExchange(ref finalMaxY, y, currentVal)
-                                    != currentVal
-                            );
+                                local.maxY = y;
+                            }
+                        }
+                        return local;
+                    },
+                    local =>
+                    {
+                        lock (sync)
+                        {
+                            if (local.minX < globalMinX)
+                            {
+                                globalMinX = local.minX;
+                            }
+
+                            if (local.maxX > globalMaxX)
+                            {
+                                globalMaxX = local.maxX;
+                            }
+
+                            if (local.minY < globalMinY)
+                            {
+                                globalMinY = local.minY;
+                            }
+
+                            if (local.maxY > globalMaxY)
+                            {
+                                globalMaxY = local.maxY;
+                            }
                         }
                     }
                 );
 
-                if (finalMinX == int.MaxValue)
+                if (globalMinX == int.MaxValue)
                 {
                     yield return null;
                     continue;
                 }
 
-                int finalWidth = finalMaxX - finalMinX + 1;
-                int finalHeight = finalMaxY - finalMinY + 1;
+                int finalWidth = globalMaxX - globalMinX + 1;
+                int finalHeight = globalMaxY - globalMinY + 1;
 
                 Color[] finalPixels = new Color[finalWidth * finalHeight];
 
@@ -481,13 +576,13 @@
                     {
                         for (int xFinal = 0; xFinal < finalWidth; ++xFinal)
                         {
-                            int bufferX = finalMinX + xFinal;
-                            int bufferY = finalMinY + yFinal;
+                            int bufferX = globalMinX + xFinal;
+                            int bufferY = globalMinY + yFinal;
                             Color pixelColor = bufferPixels[
                                 bufferY * compositeBufferWidth + bufferX
                             ];
 
-                            if (pixelColor.a >= pixelCutoff)
+                            if (pixelColor.a >= _pixelCutoff)
                             {
                                 finalPixels[yFinal * finalWidth + xFinal] = pixelColor;
                             }