com.wallstop-studios.unity-helpers 2.0.0-rc58 → 2.0.0-rc60

package/Runtime/Utils/SpriteRendererMetadata.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 7b2d3d00a0e140fea968fea4859c1781
+fileFormatVersion: 2
+guid: 7b2d3d00a0e140fea968fea4859c1781
 timeCreated: 1720397272

package/Runtime/Utils/SpriteRendererSyncer.cs

@@ -1,100 +1,100 @@
-namespace UnityHelpers.Utils
-{
-    using System;
-    using Core.Attributes;
-    using UnityEngine;
-    using UnityEngine.Serialization;
-
-    [DisallowMultipleComponent]
-    public sealed class SpriteRendererSync : MonoBehaviour
-    {
-        public int? DynamicSortingOrderOverride { get; set; }
-
-        public SpriteRenderer DynamicToMatch
-        {
-            get => GetDynamicSpriteRenderer();
-            set => _cachedSpriteRenderer = value;
-        }
-
-        [FormerlySerializedAs("_toMatch")]
-        public SpriteRenderer toMatch;
-
-        [FormerlySerializedAs("_matchColor")]
-        public bool matchColor;
-
-        [FormerlySerializedAs("_matchMaterial")]
-        public bool matchMaterial;
-
-        public bool matchSortingLayer = true;
-
-        public bool matchOrderInLayer = true;
-
-        public Func<SpriteRenderer> dynamicToMatch;
-
-        [SerializeField]
-        [SiblingComponent]
-        private SpriteRenderer _spriteRenderer;
-
-        private SpriteRenderer _cachedSpriteRenderer;
-
-        private void Awake()
-        {
-            if (_spriteRenderer == null)
-            {
-                this.AssignSiblingComponents();
-            }
-        }
-
-        private void LateUpdate()
-        {
-            SpriteRenderer localToMatch =
-                dynamicToMatch != null ? GetDynamicSpriteRenderer() : toMatch;
-            if (localToMatch == null)
-            {
-                _spriteRenderer.sprite = null;
-                return;
-            }
-
-            _spriteRenderer.sprite = localToMatch.sprite;
-            _spriteRenderer.enabled = localToMatch.enabled;
-            _spriteRenderer.flipX = localToMatch.flipX;
-            _spriteRenderer.flipY = localToMatch.flipY;
-            if (matchColor)
-            {
-                _spriteRenderer.color = localToMatch.color;
-            }
-
-            if (matchMaterial)
-            {
-                _spriteRenderer.material = localToMatch.material;
-            }
-
-            if (matchSortingLayer)
-            {
-                _spriteRenderer.sortingLayerName = localToMatch.sortingLayerName;
-            }
-
-            if (matchOrderInLayer)
-            {
-                _spriteRenderer.sortingOrder =
-                    DynamicSortingOrderOverride ?? localToMatch.sortingOrder;
-            }
-
-            _spriteRenderer.size = localToMatch.size;
-            _spriteRenderer.spriteSortPoint = localToMatch.spriteSortPoint;
-            _spriteRenderer.drawMode = localToMatch.drawMode;
-            _spriteRenderer.tileMode = localToMatch.tileMode;
-        }
-
-        private SpriteRenderer GetDynamicSpriteRenderer()
-        {
-            if (_cachedSpriteRenderer != null && _cachedSpriteRenderer.gameObject.activeSelf)
-            {
-                return _cachedSpriteRenderer;
-            }
-
-            _cachedSpriteRenderer = dynamicToMatch();
-            return _cachedSpriteRenderer;
-        }
-    }
-}
+namespace UnityHelpers.Utils
+{
+    using System;
+    using Core.Attributes;
+    using UnityEngine;
+    using UnityEngine.Serialization;
+
+    [DisallowMultipleComponent]
+    public sealed class SpriteRendererSync : MonoBehaviour
+    {
+        public int? DynamicSortingOrderOverride { get; set; }
+
+        public SpriteRenderer DynamicToMatch
+        {
+            get => GetDynamicSpriteRenderer();
+            set => _cachedSpriteRenderer = value;
+        }
+
+        [FormerlySerializedAs("_toMatch")]
+        public SpriteRenderer toMatch;
+
+        [FormerlySerializedAs("_matchColor")]
+        public bool matchColor;
+
+        [FormerlySerializedAs("_matchMaterial")]
+        public bool matchMaterial;
+
+        public bool matchSortingLayer = true;
+
+        public bool matchOrderInLayer = true;
+
+        public Func<SpriteRenderer> dynamicToMatch;
+
+        [SerializeField]
+        [SiblingComponent]
+        private SpriteRenderer _spriteRenderer;
+
+        private SpriteRenderer _cachedSpriteRenderer;
+
+        private void Awake()
+        {
+            if (_spriteRenderer == null)
+            {
+                this.AssignSiblingComponents();
+            }
+        }
+
+        private void LateUpdate()
+        {
+            SpriteRenderer localToMatch =
+                dynamicToMatch != null ? GetDynamicSpriteRenderer() : toMatch;
+            if (localToMatch == null)
+            {
+                _spriteRenderer.sprite = null;
+                return;
+            }
+
+            _spriteRenderer.sprite = localToMatch.sprite;
+            _spriteRenderer.enabled = localToMatch.enabled;
+            _spriteRenderer.flipX = localToMatch.flipX;
+            _spriteRenderer.flipY = localToMatch.flipY;
+            if (matchColor)
+            {
+                _spriteRenderer.color = localToMatch.color;
+            }
+
+            if (matchMaterial)
+            {
+                _spriteRenderer.material = localToMatch.material;
+            }
+
+            if (matchSortingLayer)
+            {
+                _spriteRenderer.sortingLayerName = localToMatch.sortingLayerName;
+            }
+
+            if (matchOrderInLayer)
+            {
+                _spriteRenderer.sortingOrder =
+                    DynamicSortingOrderOverride ?? localToMatch.sortingOrder;
+            }
+
+            _spriteRenderer.size = localToMatch.size;
+            _spriteRenderer.spriteSortPoint = localToMatch.spriteSortPoint;
+            _spriteRenderer.drawMode = localToMatch.drawMode;
+            _spriteRenderer.tileMode = localToMatch.tileMode;
+        }
+
+        private SpriteRenderer GetDynamicSpriteRenderer()
+        {
+            if (_cachedSpriteRenderer != null && _cachedSpriteRenderer.gameObject.activeSelf)
+            {
+                return _cachedSpriteRenderer;
+            }
+
+            _cachedSpriteRenderer = dynamicToMatch();
+            return _cachedSpriteRenderer;
+        }
+    }
+}

package/Runtime/Utils/SpriteRendererSyncer.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: ec3a379f59bc407f92daaab2a3d4e089
+fileFormatVersion: 2
+guid: ec3a379f59bc407f92daaab2a3d4e089
 timeCreated: 1720400998

package/Runtime/Utils/StartTracker.cs

@@ -0,0 +1,15 @@
+namespace UnityHelpers.Utils
+{
+    using UnityEngine;
+
+    [DisallowMultipleComponent]
+    public sealed class StartTracker : MonoBehaviour
+    {
+        public bool Started { get; private set; }
+
+        private void Start()
+        {
+            Started = true;
+        }
+    }
+}

package/Runtime/Utils/StartTracker.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a3a542214e594fd199901492cbaaceac
+timeCreated: 1744835337

package/Runtime/Utils/TextureScale.cs

@@ -1,179 +1,179 @@
-namespace UnityHelpers.Utils
-{
-    using System.Threading;
-    using UnityEngine;
-
-    // https://answers.unity.com/questions/348163/resize-texture2d-comes-out-grey.html
-    // http://wiki.unity3d.com/index.php/TextureScale
-    public static class TextureScale
-    {
-        private sealed class ThreadData
-        {
-            public readonly int start;
-            public readonly int end;
-
-            public ThreadData(int s, int e)
-            {
-                start = s;
-                end = e;
-            }
-        }
-
-        private static Color[] texColors;
-        private static Color[] newColors;
-        private static int w;
-        private static float ratioX;
-        private static float ratioY;
-        private static int w2;
-        private static int finishCount;
-        private static Mutex mutex;
-
-        public static void Point(Texture2D tex, int newWidth, int newHeight)
-        {
-            ThreadedScale(tex, newWidth, newHeight, false);
-        }
-
-        public static void Bilinear(Texture2D tex, int newWidth, int newHeight)
-        {
-            ThreadedScale(tex, newWidth, newHeight, true);
-        }
-
-        private static void ThreadedScale(
-            Texture2D tex,
-            int newWidth,
-            int newHeight,
-            bool useBilinear
-        )
-        {
-            texColors = tex.GetPixels();
-            newColors = new Color[newWidth * newHeight];
-            if (useBilinear)
-            {
-                ratioX = 1.0f / ((float)newWidth / (tex.width - 1));
-                ratioY = 1.0f / ((float)newHeight / (tex.height - 1));
-            }
-            else
-            {
-                ratioX = ((float)tex.width) / newWidth;
-                ratioY = ((float)tex.height) / newHeight;
-            }
-
-            w = tex.width;
-            w2 = newWidth;
-            int cores = Mathf.Min(SystemInfo.processorCount, newHeight);
-            int slice = newHeight / cores;
-
-            finishCount = 0;
-            mutex ??= new Mutex(false);
-            if (1 < cores)
-            {
-                int i;
-                ThreadData threadData;
-                for (i = 0; i < cores - 1; i++)
-                {
-                    threadData = new ThreadData(slice * i, slice * (i + 1));
-                    ParameterizedThreadStart ts = useBilinear ? BilinearScale : PointScale;
-                    Thread thread = new(ts);
-                    thread.Start(threadData);
-                }
-
-                threadData = new ThreadData(slice * i, newHeight);
-                if (useBilinear)
-                {
-                    BilinearScale(threadData);
-                }
-                else
-                {
-                    PointScale(threadData);
-                }
-
-                while (finishCount < cores)
-                {
-                    Thread.Sleep(1);
-                }
-            }
-            else
-            {
-                ThreadData threadData = new(0, newHeight);
-                if (useBilinear)
-                {
-                    BilinearScale(threadData);
-                }
-                else
-                {
-                    PointScale(threadData);
-                }
-            }
-
-            _ = tex.Reinitialize(newWidth, newHeight);
-            tex.SetPixels(newColors);
-            tex.Apply();
-
-            texColors = null;
-            newColors = null;
-        }
-
-        private static void BilinearScale(System.Object obj)
-        {
-            ThreadData threadData = (ThreadData)obj;
-            for (int y = threadData.start; y < threadData.end; y++)
-            {
-                int yFloor = (int)Mathf.Floor(y * ratioY);
-                int y1 = yFloor * w;
-                int y2 = (yFloor + 1) * w;
-                int yw = y * w2;
-
-                for (var x = 0; x < w2; x++)
-                {
-                    int xFloor = (int)Mathf.Floor(x * ratioX);
-                    float xLerp = x * ratioX - xFloor;
-                    newColors[yw + x] = ColorLerpUnclamped(
-                        ColorLerpUnclamped(
-                            texColors[y1 + xFloor],
-                            texColors[y1 + xFloor + 1],
-                            xLerp
-                        ),
-                        ColorLerpUnclamped(
-                            texColors[y2 + xFloor],
-                            texColors[y2 + xFloor + 1],
-                            xLerp
-                        ),
-                        y * ratioY - yFloor
-                    );
-                }
-            }
-
-            _ = mutex.WaitOne();
-            finishCount++;
-            mutex.ReleaseMutex();
-        }
-
-        private static void PointScale(System.Object obj)
-        {
-            ThreadData threadData = (ThreadData)obj;
-            for (int y = threadData.start; y < threadData.end; y++)
-            {
-                int thisY = (int)(ratioY * y) * w;
-                int yw = y * w2;
-                for (var x = 0; x < w2; x++)
-                {
-                    newColors[yw + x] = texColors[(int)(thisY + ratioX * x)];
-                }
-            }
-
-            _ = mutex.WaitOne();
-            finishCount++;
-            mutex.ReleaseMutex();
-        }
-
-        private static Color ColorLerpUnclamped(Color c1, Color c2, float value)
-        {
-            return new Color(
-                c1.r + (c2.r - c1.r) * value,
-                c1.g + (c2.g - c1.g) * value,
-                c1.b + (c2.b - c1.b) * value,
-                c1.a + (c2.a - c1.a) * value
-            );
-        }
-    }
-}
+namespace UnityHelpers.Utils
+{
+    using System.Threading;
+    using UnityEngine;
+
+    // https://answers.unity.com/questions/348163/resize-texture2d-comes-out-grey.html
+    // http://wiki.unity3d.com/index.php/TextureScale
+    public static class TextureScale
+    {
+        private sealed class ThreadData
+        {
+            public readonly int start;
+            public readonly int end;
+
+            public ThreadData(int s, int e)
+            {
+                start = s;
+                end = e;
+            }
+        }
+
+        private static Color[] texColors;
+        private static Color[] newColors;
+        private static int w;
+        private static float ratioX;
+        private static float ratioY;
+        private static int w2;
+        private static int finishCount;
+        private static Mutex mutex;
+
+        public static void Point(Texture2D tex, int newWidth, int newHeight)
+        {
+            ThreadedScale(tex, newWidth, newHeight, false);
+        }
+
+        public static void Bilinear(Texture2D tex, int newWidth, int newHeight)
+        {
+            ThreadedScale(tex, newWidth, newHeight, true);
+        }
+
+        private static void ThreadedScale(
+            Texture2D tex,
+            int newWidth,
+            int newHeight,
+            bool useBilinear
+        )
+        {
+            texColors = tex.GetPixels();
+            newColors = new Color[newWidth * newHeight];
+            if (useBilinear)
+            {
+                ratioX = 1.0f / ((float)newWidth / (tex.width - 1));
+                ratioY = 1.0f / ((float)newHeight / (tex.height - 1));
+            }
+            else
+            {
+                ratioX = ((float)tex.width) / newWidth;
+                ratioY = ((float)tex.height) / newHeight;
+            }
+
+            w = tex.width;
+            w2 = newWidth;
+            int cores = Mathf.Min(SystemInfo.processorCount, newHeight);
+            int slice = newHeight / cores;
+
+            finishCount = 0;
+            mutex ??= new Mutex(false);
+            if (1 < cores)
+            {
+                int i;
+                ThreadData threadData;
+                for (i = 0; i < cores - 1; i++)
+                {
+                    threadData = new ThreadData(slice * i, slice * (i + 1));
+                    ParameterizedThreadStart ts = useBilinear ? BilinearScale : PointScale;
+                    Thread thread = new(ts);
+                    thread.Start(threadData);
+                }
+
+                threadData = new ThreadData(slice * i, newHeight);
+                if (useBilinear)
+                {
+                    BilinearScale(threadData);
+                }
+                else
+                {
+                    PointScale(threadData);
+                }
+
+                while (finishCount < cores)
+                {
+                    Thread.Sleep(1);
+                }
+            }
+            else
+            {
+                ThreadData threadData = new(0, newHeight);
+                if (useBilinear)
+                {
+                    BilinearScale(threadData);
+                }
+                else
+                {
+                    PointScale(threadData);
+                }
+            }
+
+            _ = tex.Reinitialize(newWidth, newHeight);
+            tex.SetPixels(newColors);
+            tex.Apply();
+
+            texColors = null;
+            newColors = null;
+        }
+
+        private static void BilinearScale(System.Object obj)
+        {
+            ThreadData threadData = (ThreadData)obj;
+            for (int y = threadData.start; y < threadData.end; y++)
+            {
+                int yFloor = (int)Mathf.Floor(y * ratioY);
+                int y1 = yFloor * w;
+                int y2 = (yFloor + 1) * w;
+                int yw = y * w2;
+
+                for (var x = 0; x < w2; x++)
+                {
+                    int xFloor = (int)Mathf.Floor(x * ratioX);
+                    float xLerp = x * ratioX - xFloor;
+                    newColors[yw + x] = ColorLerpUnclamped(
+                        ColorLerpUnclamped(
+                            texColors[y1 + xFloor],
+                            texColors[y1 + xFloor + 1],
+                            xLerp
+                        ),
+                        ColorLerpUnclamped(
+                            texColors[y2 + xFloor],
+                            texColors[y2 + xFloor + 1],
+                            xLerp
+                        ),
+                        y * ratioY - yFloor
+                    );
+                }
+            }
+
+            _ = mutex.WaitOne();
+            finishCount++;
+            mutex.ReleaseMutex();
+        }
+
+        private static void PointScale(System.Object obj)
+        {
+            ThreadData threadData = (ThreadData)obj;
+            for (int y = threadData.start; y < threadData.end; y++)
+            {
+                int thisY = (int)(ratioY * y) * w;
+                int yw = y * w2;
+                for (var x = 0; x < w2; x++)
+                {
+                    newColors[yw + x] = texColors[(int)(thisY + ratioX * x)];
+                }
+            }
+
+            _ = mutex.WaitOne();
+            finishCount++;
+            mutex.ReleaseMutex();
+        }
+
+        private static Color ColorLerpUnclamped(Color c1, Color c2, float value)
+        {
+            return new Color(
+                c1.r + (c2.r - c1.r) * value,
+                c1.g + (c2.g - c1.g) * value,
+                c1.b + (c2.b - c1.b) * value,
+                c1.a + (c2.a - c1.a) * value
+            );
+        }
+    }
+}

package/Runtime/Utils/TextureScale.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 985292b70519406bafda70e5ab4e06ce
+fileFormatVersion: 2
+guid: 985292b70519406bafda70e5ab4e06ce
 timeCreated: 1720667849

package/Runtime/Utils/UnityObjectNameComparer.cs

@@ -0,0 +1,33 @@
+namespace UnityHelpers.Utils
+{
+    using System;
+    using System.Collections.Generic;
+
+    public sealed class UnityObjectNameComparer<T> : IComparer<T>
+        where T : UnityEngine.Object
+    {
+        public static readonly UnityObjectNameComparer<T> Instance = new();
+
+        private UnityObjectNameComparer() { }
+
+        public int Compare(T x, T y)
+        {
+            if (x == y)
+            {
+                return 0;
+            }
+
+            if (y == null)
+            {
+                return 1;
+            }
+
+            if (x == null)
+            {
+                return -1;
+            }
+
+            return string.Compare(x.name, y.name, StringComparison.OrdinalIgnoreCase);
+        }
+    }
+}

package/Runtime/Utils/UnityObjectNameComparer.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 24d2fd0003b641b7be52bc54e743be35
+timeCreated: 1744989641

package/Runtime/WallstopStudios.UnityHelpers.asmdef

@@ -1,14 +1,14 @@
-{
-    "name": "WallstopStudios.UnityHelpers",
-    "rootNamespace": "UnityHelpers",
-    "references": [],
-    "includePlatforms": [],
-    "excludePlatforms": [],
-    "allowUnsafeCode": true,
-    "overrideReferences": false,
-    "precompiledReferences": [],
-    "autoReferenced": true,
-    "defineConstraints": [],
-    "versionDefines": [],
-    "noEngineReferences": false
+{
+    "name": "WallstopStudios.UnityHelpers",
+    "rootNamespace": "UnityHelpers",
+    "references": [],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
 }