com.wallstop-studios.unity-helpers 2.0.0-rc68 → 2.0.0-rc70

package/Editor/TextureResizerWizard.cs

@@ -9,8 +9,8 @@
     using UnityEditor;
     using UnityEngine;
     using UnityEngine.Serialization;
-    using WallstopStudios.UnityHelpers.Core.Extension;
-    using WallstopStudios.UnityHelpers.Core.Helper;
+    using Core.Extension;
+    using Core.Helper;
     using WallstopStudios.UnityHelpers.Utils;
     using Object = UnityEngine.Object;
 
@@ -39,7 +39,7 @@
         public float widthMultiplier = 0.54f;
         public float heightMultiplier = 0.245f;
 
-        [MenuItem("Tools/Unity Helpers/Texture Resizer")]
+        [MenuItem("Tools/Wallstop Studios/Unity Helpers/Texture Resizer")]
         public static void ResizeTextures()
         {
             _ = DisplayWizard<TextureResizerWizard>("Texture Resizer", "Resize");

package/Editor/TextureSettingsApplier.cs

@@ -7,23 +7,23 @@
     using System.Linq;
     using UnityEditor;
     using UnityEngine;
-    using WallstopStudios.UnityHelpers.Core.Attributes;
-    using WallstopStudios.UnityHelpers.Core.Extension;
+    using Core.Attributes;
+    using Core.Extension;
     using WallstopStudios.UnityHelpers.Utils;
     using Object = UnityEngine.Object;
 
     public sealed class TextureSettingsApplier : ScriptableWizard
     {
-        public bool applyReadOnly = false;
-        public bool isReadOnly = false;
-        public bool applyMipMaps = false;
-        public bool generateMipMaps = false;
-        public bool applyWrapMode = false;
+        public bool applyReadOnly;
+        public bool isReadOnly;
+        public bool applyMipMaps;
+        public bool generateMipMaps;
+        public bool applyWrapMode;
 
         [WShowIf(nameof(applyWrapMode))]
         public TextureWrapMode wrapMode = TextureWrapMode.Clamp;
 
-        public bool applyFilterMode = false;
+        public bool applyFilterMode;
 
         [WShowIf(nameof(applyFilterMode))]
         public FilterMode filterMode = FilterMode.Trilinear;
@@ -42,7 +42,7 @@
         )]
         public List<Object> directories = new();
 
-        [MenuItem("Tools/Unity Helpers/Texture Settings Applier")]
+        [MenuItem("Tools/Wallstop Studios/Unity Helpers/Texture Settings Applier")]
         public static void CreateAnimation()
         {
             _ = DisplayWizard<TextureSettingsApplier>("Texture Settings Directory Applier", "Set");

package/Editor/WShowIfPropertyDrawer.cs

@@ -4,8 +4,8 @@
     using System.Reflection;
     using UnityEditor;
     using UnityEngine;
-    using WallstopStudios.UnityHelpers.Core.Attributes;
-    using WallstopStudios.UnityHelpers.Core.Extension;
+    using Core.Attributes;
+    using Core.Extension;
 
     [CustomPropertyDrawer(typeof(WShowIfAttribute))]
     public sealed class WShowIfPropertyDrawer : PropertyDrawer

package/Runtime/Core/Attributes/EnumDisplayNameAttribute.cs

@@ -0,0 +1,15 @@
+namespace WallstopStudios.UnityHelpers.Core.Attributes
+{
+    using System;
+
+    [AttributeUsage(AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
+    public sealed class EnumDisplayNameAttribute : Attribute
+    {
+        public string DisplayName { get; }
+
+        public EnumDisplayNameAttribute(string displayName)
+        {
+            DisplayName = displayName;
+        }
+    }
+}

package/Runtime/Core/Attributes/EnumDisplayNameAttribute.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 54bb1abcfa114c6ba1e01504b66bc326
+timeCreated: 1746457791

package/Runtime/Core/Attributes/ValidateAssignmentAttribute.cs

@@ -6,7 +6,7 @@
     using System.Linq;
     using System.Reflection;
     using Extension;
-    using Helper.Partials;
+    using Helper;
     using JetBrains.Annotations;
     using Object = UnityEngine.Object;
 

package/Runtime/Core/Extension/EnumExtensions.cs

@@ -1,7 +1,158 @@
-namespace WallstopStudios.UnityHelpers.Core.Extension
+// ReSharper disable StaticMemberInGenericType
+namespace WallstopStudios.UnityHelpers.Core.Extension
 {
     using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
     using System.Runtime.CompilerServices;
+    using Attributes;
+    using Helper;
+
+    public static class EnumNameCache<T>
+        where T : struct, Enum
+    {
+        private const int MaxDenseRange = 1024;
+
+        private static readonly bool UseDensePacking;
+        private static readonly int Min;
+        private static readonly string[]? DenseNames;
+        private static readonly Dictionary<int, string>? SparseNames;
+
+        static EnumNameCache()
+        {
+            T[] values = Enum.GetValues(typeof(T)).Cast<T>().ToArray();
+            int[] intValues = values.Select(v => Unsafe.As<T, int>(ref v)).ToArray();
+            int min = intValues.Min();
+            int max = intValues.Max();
+            int range = max - min + 1;
+
+            if (range <= MaxDenseRange)
+            {
+                UseDensePacking = true;
+                Min = min;
+                DenseNames = new string[range];
+
+                for (int i = 0; i < values.Length; i++)
+                {
+                    int key = intValues[i] - min;
+                    T value = values[i];
+                    DenseNames[key] = value.ToString("G");
+                }
+            }
+            else
+            {
+                UseDensePacking = false;
+                SparseNames = new Dictionary<int, string>();
+                for (int i = 0; i < values.Length; i++)
+                {
+                    int key = Unsafe.As<T, int>(ref values[i]);
+                    T value = values[i];
+                    string name = value.ToString("G");
+                    SparseNames.TryAdd(key, name);
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static string ToCachedName(T value)
+        {
+            int key = Unsafe.As<T, int>(ref value);
+            if (UseDensePacking)
+            {
+                int idx = key - Min;
+                if ((uint)idx < (uint)DenseNames!.Length)
+                {
+                    return DenseNames[idx];
+                }
+            }
+            else
+            {
+                if (SparseNames!.TryGetValue(key, out string name))
+                {
+                    return name;
+                }
+            }
+
+            return value.ToString();
+        }
+    }
+
+    public static class EnumDisplayNameCache<T>
+        where T : struct, Enum
+    {
+        private const int MaxDenseRange = 1024;
+
+        private static readonly bool UseDensePacking;
+        private static readonly int Min;
+        private static readonly string[]? DenseNames;
+        private static readonly Dictionary<int, string>? SparseNames;
+
+        static EnumDisplayNameCache()
+        {
+            Type type = typeof(T);
+            FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.Static);
+            T[] values = fields.Select(f => (T)f.GetValue(null)).ToArray();
+            int[] intValues = values.Select(v => Unsafe.As<T, int>(ref v)).ToArray();
+            int min = intValues.Min();
+            int max = intValues.Max();
+            int range = max - min + 1;
+
+            if (range <= MaxDenseRange)
+            {
+                UseDensePacking = true;
+                Min = min;
+                DenseNames = new string[range];
+
+                for (int i = 0; i < fields.Length; i++)
+                {
+                    int key = intValues[i] - min;
+                    FieldInfo field = fields[i];
+                    string name = field.IsAttributeDefined(out EnumDisplayNameAttribute displayName)
+                        ? displayName.DisplayName
+                        : field.Name;
+                    DenseNames[key] = name;
+                }
+            }
+            else
+            {
+                UseDensePacking = false;
+                SparseNames = new Dictionary<int, string>();
+                for (int i = 0; i < fields.Length; i++)
+                {
+                    int key = Unsafe.As<T, int>(ref values[i]);
+                    FieldInfo field = fields[i];
+                    string name = field.IsAttributeDefined(out EnumDisplayNameAttribute displayName)
+                        ? displayName.DisplayName
+                        : field.Name;
+                    SparseNames.TryAdd(key, name);
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static string ToDisplayName(T value)
+        {
+            int key = Unsafe.As<T, int>(ref value);
+            if (UseDensePacking)
+            {
+                int idx = key - Min;
+                if ((uint)idx < (uint)DenseNames!.Length)
+                {
+                    return DenseNames[idx];
+                }
+            }
+            else
+            {
+                if (SparseNames!.TryGetValue(key, out string name))
+                {
+                    return name;
+                }
+            }
+
+            return value.ToString();
+        }
+    }
 
     public static class EnumExtensions
     {
@@ -14,6 +165,30 @@
             return (valueUnderlying & flagUnderlying) == flagUnderlying;
         }
 
+        public static string ToDisplayName<T>(this T value)
+            where T : unmanaged, Enum
+        {
+            return EnumDisplayNameCache<T>.ToDisplayName(value);
+        }
+
+        public static IEnumerable<string> ToDisplayNames<T>(this IEnumerable<T> enumerable)
+            where T : unmanaged, Enum
+        {
+            return enumerable.Select(value => value.ToDisplayName());
+        }
+
+        public static string ToCachedName<T>(this T value)
+            where T : unmanaged, Enum
+        {
+            return EnumNameCache<T>.ToCachedName(value);
+        }
+
+        public static IEnumerable<string> ToCachedNames<T>(this IEnumerable<T> enumerable)
+            where T : unmanaged, Enum
+        {
+            return enumerable.Select(value => value.ToCachedName());
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static unsafe ulong GetUInt64<T>(T value)
             where T : unmanaged

package/Runtime/Core/Extension/UnityExtensions.cs

@@ -1508,7 +1508,7 @@
             );
         }
 
-        public static void SetColors(this UnityEngine.UI.Slider slider, Color color)
+        public static void SetColors(this Slider slider, Color color)
         {
             ColorBlock block = slider.colors;
 

package/Runtime/Core/Helper/Partials/LogHelpers.cs

@@ -1,4 +1,4 @@
-namespace WallstopStudios.UnityHelpers.Core.Helper.Partials
+namespace WallstopStudios.UnityHelpers.Core.Helper
 {
     using Extension;
     using UnityEngine;

package/Runtime/Core/Helper/Partials/MathHelpers.cs

@@ -1,4 +1,4 @@
-namespace WallstopStudios.UnityHelpers.Core.Helper.Partials
+namespace WallstopStudios.UnityHelpers.Core.Helper
 {
     using UnityEngine;
 

package/Runtime/Core/Helper/Partials/ObjectHelpers.cs

@@ -2,13 +2,12 @@
 {
     using System;
     using Extension;
+    using UnityEditor;
+    using UnityEditor.SceneManagement;
     using UnityEngine;
     using UnityEngine.SceneManagement;
     using Object = UnityEngine.Object;
-#if UNITY_EDITOR
-    using UnityEditor;
-    using UnityEditor.SceneManagement;
-#endif
+
     public static partial class Helpers
     {
         public static T Find<T>(this Object component, string tag, bool log = true)

package/Runtime/Tags/Attribute.cs

@@ -0,0 +1,205 @@
+namespace WallstopStudios.UnityHelpers.Tags
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Globalization;
+    using System.Linq;
+    using System.Runtime.Serialization;
+    using System.Text.Json.Serialization;
+    using Core.Extension;
+    using ProtoBuf;
+    using UnityEngine;
+
+    [Serializable]
+    [ProtoContract]
+    public sealed class Attribute : IEquatable<Attribute>, IEquatable<float>
+    {
+        public float CurrentValue
+        {
+            get
+            {
+#if UNITY_EDITOR
+                /*
+                    For some reason, there's a bug with loot tables where
+                    _currentValueCalculated will be true but the current
+                    value is not calculated, so ignore the flag if we're
+                    in editor mode, where this happens
+                 */
+                if (Application.isPlaying)
+#endif
+                {
+                    if (_currentValueCalculated)
+                    {
+                        return _currentValue;
+                    }
+                }
+
+                CalculateCurrentValue();
+                return _currentValue;
+            }
+        }
+
+        public float BaseValue => _baseValue;
+
+        [SerializeField]
+        internal float _baseValue;
+
+        [SerializeField]
+        private float _currentValue;
+
+        private bool _currentValueCalculated;
+
+        internal void CalculateCurrentValue()
+        {
+            float calculatedValue = _baseValue;
+            foreach (
+                AttributeModification attributeModification in _modifications
+                    .SelectMany(kvp => kvp.Value)
+                    .OrderBy(mod => mod.action)
+            )
+            {
+                ApplyAttributeModification(attributeModification, ref calculatedValue);
+            }
+
+            _currentValue = calculatedValue;
+            _currentValueCalculated = true;
+        }
+
+        private readonly Dictionary<EffectHandle, List<AttributeModification>> _modifications =
+            new();
+
+        public static implicit operator float(Attribute attribute) => attribute.CurrentValue;
+
+        public static implicit operator Attribute(float value) => new(value);
+
+        public Attribute()
+            : this(0) { }
+
+        public Attribute(float value)
+        {
+            _baseValue = value;
+            _currentValueCalculated = false;
+        }
+
+        [JsonConstructor]
+        public Attribute(float baseValue, float currentValue)
+        {
+            _baseValue = baseValue;
+            _currentValue = currentValue;
+            _currentValueCalculated = true;
+        }
+
+        public void ClearCache()
+        {
+            _currentValueCalculated = false;
+        }
+
+        public void ApplyAttributeModification(
+            AttributeModification attributeModification,
+            EffectHandle? handle = null
+        )
+        {
+            // If we don't have a handle, then this is an instant effect, apply it to the base value.
+            if (!handle.HasValue)
+            {
+                ApplyAttributeModification(attributeModification, ref _baseValue);
+            }
+            else
+            {
+                _modifications.GetOrAdd(handle.Value).Add(attributeModification);
+            }
+
+            CalculateCurrentValue();
+        }
+
+        public bool RemoveAttributeModification(EffectHandle handle)
+        {
+            bool removed = _modifications.Remove(handle);
+            if (removed)
+            {
+                CalculateCurrentValue();
+            }
+
+            return removed;
+        }
+
+        [OnDeserialized]
+        private void AfterDeserialize(StreamingContext streamingContext)
+        {
+            ClearCache();
+        }
+
+        [ProtoAfterDeserialization]
+        private void AfterProtoDeserialized()
+        {
+            ClearCache();
+        }
+
+        private static void ApplyAttributeModification(
+            AttributeModification attributeModification,
+            ref float value
+        )
+        {
+            switch (attributeModification.action)
+            {
+                case ModificationAction.Addition:
+                    value += attributeModification.value;
+                    break;
+                case ModificationAction.Multiplication:
+                    value *= attributeModification.value;
+                    break;
+                case ModificationAction.Override:
+                    value = attributeModification.value;
+                    break;
+                default:
+                    throw new InvalidEnumArgumentException(
+                        nameof(attributeModification.action),
+                        (int)attributeModification.action,
+                        typeof(ModificationAction)
+                    );
+            }
+        }
+
+        public bool Equals(Attribute other)
+        {
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return other != null && CurrentValue.Equals(other.CurrentValue);
+        }
+
+        public override bool Equals(object other)
+        {
+            switch (other)
+            {
+                case Attribute attribute:
+                    return Equals(attribute);
+                case float attribute:
+                    return Equals(attribute);
+                case double attribute:
+                    return Equals((float)attribute);
+                default:
+                    return false;
+            }
+        }
+
+        public bool Equals(float other)
+        {
+            return CurrentValue.Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            // ReSharper disable once BaseObjectGetHashCodeCallInGetHashCode
+            return base.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            return ((float)this).ToString(CultureInfo.InvariantCulture);
+        }
+    }
+}

package/Runtime/Tags/Attribute.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7209237176394eaf99a875c53950e2d0
+timeCreated: 1746412136