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

package/Runtime/Core/Extension/DictionaryExtensions.cs

@@ -1,6 +1,7 @@
 namespace UnityHelpers.Core.Extension
 {
     using System;
+    using System.Collections.Concurrent;
     using System.Collections.Generic;
     using System.Linq;
 
@@ -8,6 +9,11 @@
     {
         public static V GetOrAdd<K, V>(this IDictionary<K, V> dictionary, K key, Func<V> valueProducer)
         {
+            if (dictionary is ConcurrentDictionary<K, V> concurrentDictionary)
+            {
+                return concurrentDictionary.GetOrAdd(key, static (_, existing) => existing(), valueProducer);
+            }
+
             if (dictionary.TryGetValue(key, out V result))
             {
                 return result;
@@ -15,8 +21,14 @@
 
             return dictionary[key] = valueProducer();
         }
+
         public static V GetOrAdd<K, V>(this IDictionary<K, V> dictionary, K key, Func<K, V> valueProducer)
         {
+            if (dictionary is ConcurrentDictionary<K, V> concurrentDictionary)
+            {
+                return concurrentDictionary.GetOrAdd(key, valueProducer);
+            }
+
             if (dictionary.TryGetValue(key, out V result))
             {
                 return result;
@@ -25,16 +37,17 @@
             return dictionary[key] = valueProducer(key);
         }
 
-        public static V GetOrElse<K, V>(this IDictionary<K, V> dictionary, K key, Func<V> valueProducer)
+        public static V GetOrElse<K, V>(this IReadOnlyDictionary<K, V> dictionary, K key, Func<V> valueProducer)
         {
             if (dictionary.TryGetValue(key, out V value))
             {
                 return value;
             }
+
             return valueProducer.Invoke();
         }
 
-        public static V GetOrElse<K, V>(this IDictionary<K, V> dictionary, K key, Func<K, V> valueProducer)
+        public static V GetOrElse<K, V>(this IReadOnlyDictionary<K, V> dictionary, K key, Func<K, V> valueProducer)
         {
             if (dictionary.TryGetValue(key, out V value))
             {
@@ -46,6 +59,11 @@
 
         public static V GetOrAdd<K, V>(this IDictionary<K, V> dictionary, K key) where V : new()
         {
+            if (dictionary is ConcurrentDictionary<K, V> concurrentDictionary)
+            {
+                return concurrentDictionary.AddOrUpdate(key, _ => new V(), (_, existing) => existing);
+            }
+
             if (dictionary.TryGetValue(key, out V result))
             {
                 return result;
@@ -54,43 +72,58 @@
             return dictionary[key] = new V();
         }
 
-        public static V GetOrElse<K, V>(this IDictionary<K, V> dictionary, K key, V value)
+        public static V GetOrElse<K, V>(this IReadOnlyDictionary<K, V> dictionary, K key, V value)
         {
             return GetOrElse(dictionary, key, () => value);
         }
 
-        public static bool Remove<K, V>(this IDictionary<K, V> dictionary, K key, out V value)
+        public static V AddOrUpdate<K, V>(
+            this IDictionary<K, V> dictionary, K key, Func<K, V> creator, Func<K, V, V> updater)
         {
-            if (dictionary.TryGetValue(key, out value))
+            if (dictionary is ConcurrentDictionary<K, V> concurrentDictionary)
             {
-                return dictionary.Remove(key);
+                return concurrentDictionary.AddOrUpdate(key, creator, updater);
             }
-            return false;
-        }
 
-        public static V AddOrUpdate<K, V>(this IDictionary<K, V> dictionary, K key, Func<K, V> creator, Func<K, V, V> updater)
-        {
             V latest = dictionary.TryGetValue(key, out V value) ? updater(key, value) : creator(key);
             dictionary[key] = latest;
             return latest;
         }
 
-        public static Dictionary<K, V> Merge<K, V>(this IDictionary<K, V> lhs, IDictionary<K, V> rhs)
+        public static V TryAdd<K, V>(this IDictionary<K, V> dictionary, K key, Func<K, V> creator)
+        {
+            if (dictionary is ConcurrentDictionary<K, V> concurrentDictionary)
+            {
+                return concurrentDictionary.AddOrUpdate(key, creator, (_, existing) => existing);
+            }
+
+            if (dictionary.TryGetValue(key, out V existing))
+            {
+                return existing;
+            }
+
+            V value = creator(key);
+            dictionary[key] = value;
+            return value;
+        }
+
+        public static Dictionary<K, V> Merge<K, V>(this IReadOnlyDictionary<K, V> lhs, IReadOnlyDictionary<K, V> rhs)
         {
-            Dictionary<K, V> result = new Dictionary<K, V>(lhs.Count);
-            foreach (KeyValuePair<K, V> kvp in lhs)
+            Dictionary<K, V> result = new();
+            if (0 < lhs.Count)
             {
-                if (rhs.ContainsKey(kvp.Key))
+                foreach (KeyValuePair<K, V> kvp in lhs)
                 {
-                    continue;
+                    result[kvp.Key] = kvp.Value;
                 }
-
-                result[kvp.Key] = kvp.Value;
             }
 
-            foreach (KeyValuePair<K, V> kvp in rhs)
+            if (0 < rhs.Count)
             {
-                result[kvp.Key] = kvp.Value;
+                foreach (KeyValuePair<K, V> kvp in rhs)
+                {
+                    result[kvp.Key] = kvp.Value;
+                }
             }
 
             return result;
@@ -103,38 +136,36 @@
         /// <param name="lhs">Basis dictionary.</param>
         /// <param name="rhs">Changed dictionary.</param>
         /// <returns>All elements of rhs that either don't exist in or are different from lhs</returns>
-        public static Dictionary<K, V> Difference<K, V>(this IDictionary<K, V> lhs, IDictionary<K, V> rhs)
+        public static Dictionary<K, V> Difference<K, V>(
+            this IReadOnlyDictionary<K, V> lhs, IReadOnlyDictionary<K, V> rhs)
         {
-            Dictionary<K, V> result = new Dictionary<K, V>(rhs.Count);
+            Dictionary<K, V> result = new(rhs.Count);
             foreach (KeyValuePair<K, V> kvp in rhs)
             {
                 K key = kvp.Key;
-                V existing;
-                if (lhs.TryGetValue(key, out existing))
+                if (lhs.TryGetValue(key, out V existing) && Equals(existing, kvp.Value))
                 {
-                    if (Equals(existing, kvp.Value))
-                    {
-                        continue;
-                    }
-
-                    result[key] = kvp.Value;
+                    continue;
                 }
+
+                result[key] = kvp.Value;
             }
 
             return result;
         }
 
-        public static Dictionary<V, K> Reverse<K, V>(this IDictionary<K, V> dictionary)
+        public static Dictionary<V, K> Reverse<K, V>(this IReadOnlyDictionary<K, V> dictionary)
         {
-            Dictionary<V, K> output = new Dictionary<V, K>(dictionary.Count);
+            Dictionary<V, K> output = new(dictionary.Count);
             foreach (KeyValuePair<K, V> entry in dictionary)
             {
                 output[entry.Value] = entry.Key;
             }
+
             return output;
         }
 
-        public static Dictionary<K, V> ToDictionary<K, V>(this IDictionary<K, V> dictionary)
+        public static Dictionary<K, V> ToDictionary<K, V>(this IReadOnlyDictionary<K, V> dictionary)
         {
             return new Dictionary<K, V>(dictionary);
         }
@@ -144,7 +175,13 @@
             return prettyMuchADictionary.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
         }
 
-        public static bool ContentEquals<K, V>(this IDictionary<K, V> dictionary, IDictionary<K, V> other)
+        public static Dictionary<K, V> ToDictionary<K, V>(this IEnumerable<(K, V)> prettyMuchADictionary)
+        {
+            return prettyMuchADictionary.ToDictionary(kvp => kvp.Item1, kvp => kvp.Item2);
+        }
+
+        public static bool ContentEquals<K, V>(
+            this IReadOnlyDictionary<K, V> dictionary, IReadOnlyDictionary<K, V> other)
         {
             if (ReferenceEquals(dictionary, other))
             {
@@ -170,4 +207,4 @@
             value = kvp.Value;
         }
     }
-}
+}

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