com.wallstop-studios.unity-helpers 1.0.0-rc9 → 1.0.1-rc01

package/Runtime/Utils/SpriteRendererMetadata.cs

@@ -0,0 +1,273 @@
+namespace UnityHelpers.Utils
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using UnityEngine;
+    using Core.Attributes;
+
+    /// <summary>
+    ///     Keeps stack-like track of Colors and Materials of SpriteRenderers
+    /// </summary>
+    [DisallowMultipleComponent]
+    public sealed class SpriteRendererMetadata : MonoBehaviour
+    {
+        private readonly List<(Component component, Color color)> _colorStack = new();
+        private readonly List<(Component component, Material material)> _materialStack = new();
+
+        private readonly List<(Component component, Color color)> _colorStackCache = new();
+        private readonly List<(Component component, Material material)> _materialStackCache = new();
+
+        public Color OriginalColor => _colorStack[0].color;
+
+        public Color CurrentColor => _colorStack[^1].color;
+
+        public Material OriginalMaterial => _materialStack[0].material;
+
+        public Material CurrentMaterial => _materialStack[^1].material;
+
+        public IEnumerable<Material> Materials => _materialStack.Select(entry => entry.material);
+
+        public IEnumerable<Color> Colors => _colorStack.Select(entry => entry.color);
+
+        [SiblingComponent]
+        [SerializeField]
+        private SpriteRenderer _spriteRenderer;
+
+        private bool _enabled;
+
+        public void PushColor(Component component, Color color, bool force = false)
+        {
+            if (component == this)
+            {
+                return;
+            }
+
+            if (!force && !enabled)
+            {
+                return;
+            }
+
+            InternalPushColor(component, color);
+        }
+
+        private void InternalPushColor(Component component, Color color)
+        {
+            RemoveColor(component);
+            _colorStack.Add((component, color));
+            _spriteRenderer.color = CurrentColor;
+        }
+
+        public void PushBackColor(Component component, Color color, bool force = false)
+        {
+            if (component == this)
+            {
+                return;
+            }
+
+            if (!force && !enabled)
+            {
+                return;
+            }
+
+            RemoveColor(component);
+            _colorStack.Insert(1, (component, color));
+            _spriteRenderer.color = CurrentColor;
+        }
+
+        public void PopColor(Component component)
+        {
+            RemoveColor(component);
+            _spriteRenderer.color = CurrentColor;
+        }
+
+        /// <summary>
+        ///     Inserts a material as "first in the queue".
+        /// </summary>
+        /// <param name="component">Component that owns the material.</param>
+        /// <param name="material">Material to use.</param>
+        /// <param name="force">If true, overrides the enable check.</param>
+        /// <returns>The instanced material, if possible.</returns> 
+        public Material PushMaterial(Component component, Material material, bool force = false)
+        {
+            if (component == this)
+            {
+                return null;
+            }
+
+            if (!force && !enabled)
+            {
+                return null;
+            }
+
+#if UNITY_EDITOR
+            if (!Application.isPlaying)
+            {
+                return null;
+            }
+#endif
+            return InternalPushMaterial(component, material);
+        }
+
+        private Material InternalPushMaterial(Component component, Material material)
+        {
+            RemoveMaterial(component);
+            _spriteRenderer.material = material;
+            Material instanced = _spriteRenderer.material;
+            _materialStack.Add((component, instanced));
+            return instanced;
+        }
+
+        /// <summary>
+        ///     Inserts a material as "last in the queue".
+        /// </summary>
+        /// <param name="component">Component that owns the material.</param>
+        /// <param name="material">Material to use.</param>
+        /// <param name="force">If true, overrides the enable check.</param>
+        /// <returns>The instanced material, if possible.</returns>
+        public Material PushBackMaterial(Component component, Material material, bool force = false)
+        {
+            if (component == this)
+            {
+                return null;
+            }
+
+            if (!force && !enabled)
+            {
+                return null;
+            }
+
+#if UNITY_EDITOR
+            if (!Application.isPlaying)
+            {
+                return null;
+            }
+#endif
+
+            RemoveMaterial(component);
+            Material instanced = material;
+            if (_materialStack.Count <= 1)
+            {
+                _spriteRenderer.material = material;
+                instanced = _spriteRenderer.material;
+            }
+
+            _materialStack.Insert(1, (component, instanced));
+            return instanced;
+        }
+
+        public void PopMaterial(Component component)
+        {
+#if UNITY_EDITOR
+            if (!Application.isPlaying)
+            {
+                return;
+            }
+#endif
+
+            RemoveMaterial(component);
+            _spriteRenderer.material = CurrentMaterial;
+            Material instanced = _spriteRenderer.material;
+            Component currentComponent = _materialStack[^1].component;
+            _materialStack[^1] = (currentComponent, instanced);
+        }
+
+        private void Awake()
+        {
+            if (_spriteRenderer == null)
+            {
+                this.AssignSiblingComponents();
+            }
+
+            InternalPushColor(this, _spriteRenderer.color);
+            _colorStackCache.AddRange(_colorStack);
+            _ = InternalPushMaterial(this, _spriteRenderer.material);
+            _materialStackCache.AddRange(_materialStack);
+        }
+
+        private void OnEnable()
+        {
+            // Ignore the OnEnable call from when the object is first initialized
+            if (!_enabled)
+            {
+                _enabled = true;
+                return;
+            }
+
+            _colorStack.Clear();
+            _colorStack.Add(_colorStackCache[0]);
+            List<(Component component, Color color)> colorBuffer = Buffers<(Component component, Color color)>.List;
+            colorBuffer.Clear();
+            colorBuffer.AddRange(_colorStackCache);
+            for (int i = 1; i < colorBuffer.Count; ++i)
+            {
+                (Component component, Color color) entry = colorBuffer[i];
+                PushColor(entry.component, entry.color, force: true);
+            }
+
+            _materialStack.Clear();
+            _materialStack.Add(_materialStackCache[0]);
+            List<(Component component, Material material)> materialBuffer =
+                Buffers<(Component component, Material material)>.List;
+            materialBuffer.Clear();
+            materialBuffer.AddRange(_materialStackCache);
+            for (int i = 1; i < materialBuffer.Count; ++i)
+            {
+                (Component component, Material material) entry = materialBuffer[i];
+                PushMaterial(entry.component, entry.material, force: true);
+            }
+        }
+
+        private void OnDisable()
+        {
+            List<(Component component, Color color)> colorBuffer = Buffers<(Component component, Color color)>.List;
+            colorBuffer.Clear();
+            colorBuffer.AddRange(_colorStack);
+            for (int i = colorBuffer.Count - 1; 1 <= i; --i)
+            {
+                PopColor(colorBuffer[i].component);
+            }
+
+            _colorStackCache.Clear();
+            _colorStackCache.AddRange(colorBuffer);
+
+            List<(Component component, Material material)> materialBuffer =
+                Buffers<(Component component, Material material)>.List;
+            materialBuffer.Clear();
+            materialBuffer.AddRange(_materialStack);
+
+            for (int i = materialBuffer.Count - 1; 1 <= i; --i)
+            {
+                PopMaterial(materialBuffer[i].component);
+            }
+
+            _materialStackCache.Clear();
+            _materialStackCache.AddRange(materialBuffer);
+        }
+
+        private void RemoveColor(Component component)
+        {
+            if (component == this)
+            {
+                return;
+            }
+
+            _ = _colorStack.RemoveAll(
+                existingComponent => existingComponent.component == component || existingComponent.component == null);
+            _ = _colorStackCache.RemoveAll(
+                existingComponent => existingComponent.component == component || existingComponent.component == null);
+        }
+
+        private void RemoveMaterial(Component component)
+        {
+            if (component == this)
+            {
+                return;
+            }
+
+            _ = _materialStack.RemoveAll(
+                existingComponent => existingComponent.component == component || existingComponent.component == null);
+            _ = _materialStackCache.RemoveAll(
+                existingComponent => existingComponent.component == component || existingComponent.component == null);
+        }
+    }
+}

package/Runtime/Utils/SpriteRendererMetadata.cs.meta

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

package/Runtime/Utils/SpriteRendererSyncer.cs

@@ -0,0 +1,98 @@
+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

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

package/Tests/Runtime/Extensions/StringExtensionTests.cs

@@ -3,7 +3,7 @@
     using Core.Extension;
     using NUnit.Framework;
 
-    public class StringExtensionTests
+    public sealed class StringExtensionTests
     {
         [Test]
         public void ToPascalCaseNominal()

package/Tests/Runtime/Utils/SpriteRendererMetadataTests.cs

@@ -0,0 +1,395 @@
+namespace UnityHelpers.Tests.Utils
+{
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+    using Core.Helper;
+    using Core.Random;
+    using NUnit.Framework;
+    using UnityEngine;
+    using UnityEngine.TestTools;
+    using UnityHelpers.Utils;
+
+    public sealed class SpriteRendererMetadataTests
+    {
+        private readonly List<GameObject> _spawned = new();
+
+        [TearDown]
+        public void Cleanup()
+        {
+            foreach (GameObject spawned in _spawned)
+            {
+                if (spawned == null)
+                {
+                    continue;
+                }
+
+                Object.Destroy(spawned);
+            }
+
+            _spawned.Clear();
+        }
+
+        private SpriteRendererMetadata CreateMetadata()
+        {
+            GameObject go = new("TestSpriteRendererMetadata", typeof(SpriteRenderer), typeof(SpriteRendererMetadata));
+            _spawned.Add(go);
+            return go.GetComponent<SpriteRendererMetadata>();
+        }
+
+        private Material CreateMaterial()
+        {
+            return new Material(Shader.Find("Sprites/Default"));
+        }
+
+        private Color CreateColor()
+        {
+            IRandom random = PcgRandom.Instance;
+            Color color = new(random.NextFloat(), random.NextFloat(), random.NextFloat(), random.NextFloat());
+            return color;
+        }
+
+        [UnityTest]
+        public IEnumerator Initialization()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(spriteRenderer.material, metadata.CurrentMaterial);
+            Assert.AreEqual(metadata.OriginalColor, metadata.CurrentColor);
+            Assert.AreEqual(metadata.OriginalMaterial, metadata.CurrentMaterial);
+            Assert.AreEqual(1, metadata.Colors.Count());
+            Assert.IsTrue(metadata.Colors.Contains(metadata.OriginalColor));
+            Assert.AreEqual(1, metadata.Materials.Count());
+            Assert.IsTrue(metadata.Materials.Contains(metadata.OriginalMaterial));
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator PushColor()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            Color originalColor = metadata.OriginalColor;
+            Color newColor = originalColor;
+            Material originalMaterial = metadata.OriginalMaterial;
+            do
+            {
+                newColor.r = PcgRandom.Instance.NextFloat();
+            }
+            while (newColor == originalColor);
+
+            SpriteRendererMetadata second = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            metadata.PushColor(second, newColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(newColor, metadata.CurrentColor);
+            Assert.IsTrue(metadata.Colors.Contains(newColor));
+            Assert.AreEqual(originalColor, metadata.OriginalColor);
+            Assert.AreEqual(originalMaterial, metadata.CurrentMaterial);
+
+            Color updatedColor = newColor;
+            do
+            {
+                updatedColor.g = PcgRandom.Instance.NextFloat();
+            }
+            while (updatedColor == newColor);
+
+            metadata.PushColor(spriteRenderer, updatedColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(updatedColor, metadata.CurrentColor);
+            Assert.AreEqual(3, metadata.Colors.Count());
+            Assert.IsTrue(metadata.Colors.Contains(originalColor));
+            Assert.IsTrue(metadata.Colors.Contains(newColor));
+            Assert.IsTrue(metadata.Colors.Contains(updatedColor));
+            Assert.AreEqual(originalColor, metadata.OriginalColor);
+            Assert.AreEqual(originalMaterial, metadata.CurrentMaterial);
+
+            Color latestColor = updatedColor;
+            do
+            {
+                latestColor.b = PcgRandom.Instance.NextFloat();
+            }
+            while (latestColor == updatedColor);
+
+            metadata.PushColor(second, latestColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(latestColor, metadata.CurrentColor);
+            Assert.AreEqual(3, metadata.Colors.Count());
+            // Should be replaced
+            Assert.IsFalse(metadata.Colors.Contains(newColor));
+            do
+            {
+                newColor.a = PcgRandom.Instance.NextFloat();
+            }
+            while (newColor == latestColor);
+
+            metadata.PushColor(second, newColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(newColor, metadata.CurrentColor);
+            Assert.AreEqual(3, metadata.Colors.Count());
+            Assert.IsTrue(metadata.Colors.Contains(originalColor));
+            Assert.IsTrue(metadata.Colors.Contains(newColor));
+            Assert.IsTrue(metadata.Colors.Contains(updatedColor));
+
+            metadata.PushColor(second, newColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(newColor, metadata.CurrentColor);
+            Assert.AreEqual(3, metadata.Colors.Count());
+            Assert.IsTrue(metadata.Colors.Contains(originalColor));
+            Assert.IsTrue(metadata.Colors.Contains(newColor));
+            Assert.IsTrue(metadata.Colors.Contains(updatedColor));
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator PushColorIdempotent()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Color color = CreateColor();
+
+            void Verify()
+            {
+                metadata.PushColor(spriteRenderer, color);
+                Assert.AreEqual(spriteRenderer.color, color);
+                Assert.AreEqual(color, metadata.CurrentColor);
+                Assert.AreEqual(2, metadata.Colors.Count());
+            }
+
+            for (int i = 0; i < 100; ++i)
+            {
+                Verify();
+            }
+
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator PushMaterialIdempotent()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Material material = CreateMaterial();
+
+            void Verify()
+            {
+                metadata.PushMaterial(spriteRenderer, material);
+                Assert.AreEqual(spriteRenderer.material, metadata.CurrentMaterial);
+                Assert.AreEqual(2, metadata.Materials.Count());
+                Assert.IsTrue(metadata.Materials.Contains(spriteRenderer.material));
+                Assert.IsTrue(metadata.Materials.Contains(metadata.OriginalMaterial));
+            }
+
+            for (int i = 0; i < 100; ++i)
+            {
+                Verify();
+            }
+
+            yield break;
+        }
+
+
+        [UnityTest]
+        public IEnumerator PopColorIdempotent()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Color originalColor = spriteRenderer.color;
+            Color color = CreateColor();
+            metadata.PushColor(spriteRenderer, color);
+
+            void Verify()
+            {
+                metadata.PopColor(spriteRenderer);
+                Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+                Assert.AreEqual(originalColor, metadata.CurrentColor);
+                Assert.AreEqual(1, metadata.Colors.Count());
+            }
+
+            for (int i = 0; i < 100; ++i)
+            {
+                Verify();
+            }
+
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator PopMaterialIdempotent()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Material material = CreateMaterial();
+
+            metadata.PushMaterial(spriteRenderer, material);
+
+            void Verify()
+            {
+                metadata.PopMaterial(spriteRenderer);
+                Assert.AreEqual(spriteRenderer.material, metadata.CurrentMaterial);
+                Assert.AreEqual(1, metadata.Materials.Count());
+                Assert.IsTrue(metadata.Materials.Contains(spriteRenderer.material));
+            }
+
+            for (int i = 0; i < 100; ++i)
+            {
+                Verify();
+            }
+
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator CannotSelfPushColor()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Color color = CreateColor();
+            Color originalColor = metadata.OriginalColor;
+            metadata.PushColor(metadata, color);
+            Assert.AreEqual(originalColor, metadata.CurrentColor);
+            Assert.AreEqual(originalColor, spriteRenderer.color);
+            Assert.AreEqual(1, metadata.Colors.Count());
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator CannotSelfPopColor()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Color originalColor = metadata.OriginalColor;
+            metadata.PopColor(metadata);
+            Assert.AreEqual(originalColor, metadata.CurrentColor);
+            Assert.AreEqual(originalColor, spriteRenderer.color);
+            Assert.AreEqual(1, metadata.Colors.Count());
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator CannotSelfPopMaterial()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Material originalMaterial = metadata.OriginalMaterial;
+            metadata.PopMaterial(metadata);
+            Assert.AreEqual(originalMaterial, metadata.CurrentMaterial);
+            Assert.AreEqual(originalMaterial, spriteRenderer.material);
+            Assert.AreEqual(1, metadata.Materials.Count());
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator CannotSelfPushMaterial()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Material material = CreateMaterial();
+            Material originalMaterial = metadata.OriginalMaterial;
+            metadata.PushMaterial(metadata, material);
+            Assert.AreEqual(originalMaterial, metadata.CurrentMaterial);
+            Assert.AreEqual(originalMaterial, spriteRenderer.material);
+            Assert.AreNotEqual(material, spriteRenderer.material);
+            Assert.AreEqual(1, metadata.Materials.Count());
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator EnableDisableColor()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Color color = CreateColor();
+            metadata.PushColor(spriteRenderer, color);
+            Assert.AreEqual(color, metadata.CurrentColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(2, metadata.Colors.Count());
+
+            metadata.enabled = false;
+            Assert.AreEqual(metadata.OriginalColor, metadata.CurrentColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(1, metadata.Colors.Count());
+
+            metadata.enabled = true;
+            Assert.AreEqual(color, metadata.CurrentColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(2, metadata.Colors.Count());
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator EnableDisableMaterial()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Material material = CreateMaterial();
+            metadata.PushMaterial(spriteRenderer, material);
+            Assert.AreEqual(spriteRenderer.material, metadata.CurrentMaterial);
+            Assert.AreEqual(2, metadata.Materials.Count());
+
+            metadata.enabled = false;
+            Assert.AreEqual(metadata.OriginalMaterial, metadata.CurrentMaterial);
+            Assert.AreEqual(1, metadata.Materials.Count());
+
+            metadata.enabled = true;
+            Assert.AreEqual(spriteRenderer.material, metadata.CurrentMaterial);
+            Assert.AreEqual(2, metadata.Materials.Count());
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator EnableDisableWithRemoveColor()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Color color = CreateColor();
+            metadata.PushColor(spriteRenderer, color);
+            Assert.AreEqual(color, metadata.CurrentColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(2, metadata.Colors.Count());
+
+            metadata.enabled = false;
+            Assert.AreEqual(metadata.OriginalColor, metadata.CurrentColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(1, metadata.Colors.Count());
+
+            metadata.PopColor(spriteRenderer);
+
+            Assert.AreEqual(metadata.OriginalColor, metadata.CurrentColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(1, metadata.Colors.Count());
+
+            metadata.enabled = true;
+            Assert.AreEqual(metadata.OriginalColor, metadata.CurrentColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(1, metadata.Colors.Count());
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator EnableDisableWithRemoveMaterial()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Material material = CreateMaterial();
+            metadata.PushMaterial(spriteRenderer, material);
+            Assert.AreEqual(spriteRenderer.material, metadata.CurrentMaterial);
+            Assert.AreEqual(2, metadata.Materials.Count());
+
+            metadata.enabled = false;
+            Assert.AreEqual(metadata.OriginalMaterial, metadata.CurrentMaterial);
+            Assert.AreEqual(1, metadata.Materials.Count());
+
+            metadata.PopMaterial(spriteRenderer);
+
+            Assert.AreEqual(metadata.OriginalMaterial, metadata.CurrentMaterial);
+            Assert.AreEqual(1, metadata.Materials.Count());
+
+            metadata.enabled = true;
+            Assert.AreEqual(metadata.OriginalMaterial, metadata.CurrentMaterial);
+            Assert.AreEqual(1, metadata.Materials.Count());
+            yield break;
+        }
+    }
+}

package/Tests/Runtime/Utils/SpriteRendererMetadataTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5cbbc68f2b7c4c7d8b2fc2324a429130
+timeCreated: 1720397409

package/Tests/Runtime/Utils.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 07d3ff4fdf554c119ebd3f49fcaa09a3
+timeCreated: 1720397402

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "1.0.0-rc9",
+  "version": "1.0.1-rc01",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {
@@ -16,6 +16,7 @@
     "random",
     "pcg random",
     "protobuf",
+    "pascal",
     "rtree",
     "r tree",
     "kd tree",