com.wallstop-studios.unity-helpers 2.0.0-rc81.9 → 2.0.1

package/Editor/Sprites/AnimationViewerWindow.cs

@@ -54,7 +54,7 @@ namespace WallstopStudios.UnityHelpers.Editor.Sprites
         private const string DirToolName = "SpriteAnimationEditor";
         private const string DirContextKey = "Clips";
 
-        private sealed class EditorLayerData
+        internal sealed class EditorLayerData
         {
             public AnimationClip SourceClip { get; }
             public List<Sprite> Sprites { get; }
@@ -65,7 +65,17 @@ namespace WallstopStudios.UnityHelpers.Editor.Sprites
             public EditorLayerData(AnimationClip clip)
             {
                 SourceClip = clip;
-                Sprites = clip.GetSpritesFromClip()?.ToList();
+                Sprites = new List<Sprite>();
+                if (clip != null)
+                {
+                    foreach (Sprite s in clip.GetSpritesFromClip())
+                    {
+                        if (s != null)
+                        {
+                            Sprites.Add(s);
+                        }
+                    }
+                }
                 OriginalClipFps =
                     clip.frameRate > 0 ? clip.frameRate : AnimatedSpriteLayer.FrameRate;
 
@@ -442,7 +452,16 @@ namespace WallstopStudios.UnityHelpers.Editor.Sprites
                 AnimationClip clip = AssetDatabase.LoadAssetAtPath<AnimationClip>(assetPath);
                 if (clip != null)
                 {
-                    if (_loadedEditorLayers.All(layer => layer.SourceClip != clip))
+                    bool noneMatch = true;
+                    for (int i = 0; i < _loadedEditorLayers.Count; i++)
+                    {
+                        if (_loadedEditorLayers[i]?.SourceClip == clip)
+                        {
+                            noneMatch = false;
+                            break;
+                        }
+                    }
+                    if (noneMatch)
                     {
                         AddEditorLayer(clip);
                         clipsAddedCount++;
@@ -500,7 +519,15 @@ namespace WallstopStudios.UnityHelpers.Editor.Sprites
             {
                 if (obj is AnimationClip clip)
                 {
-                    bool alreadyExists = _loadedEditorLayers.Any(layer => layer.SourceClip == clip);
+                    bool alreadyExists = false;
+                    for (int i = 0; i < _loadedEditorLayers.Count; i++)
+                    {
+                        if (_loadedEditorLayers[i]?.SourceClip == clip)
+                        {
+                            alreadyExists = true;
+                            break;
+                        }
+                    }
                     if (!alreadyExists)
                     {
                         AddEditorLayer(clip);
@@ -615,7 +642,16 @@ namespace WallstopStudios.UnityHelpers.Editor.Sprites
 
         private void AddEditorLayer(AnimationClip clip)
         {
-            if (clip == null || _loadedEditorLayers.Any(layer => layer.SourceClip == clip))
+            bool exists = false;
+            for (int i = 0; i < _loadedEditorLayers.Count; i++)
+            {
+                if (_loadedEditorLayers[i]?.SourceClip == clip)
+                {
+                    exists = true;
+                    break;
+                }
+            }
+            if (clip == null || exists)
             {
                 string clipName = clip != null ? clip.name : "<null>";
                 this.LogWarn($"Clip '{clipName}' is null or already loaded.");
@@ -649,7 +685,7 @@ namespace WallstopStudios.UnityHelpers.Editor.Sprites
 
             if (_activeEditorLayer == layerToRemove)
             {
-                SetActiveEditorLayer(_loadedEditorLayers.FirstOrDefault());
+                SetActiveEditorLayer(_loadedEditorLayers.Count > 0 ? _loadedEditorLayers[0] : null);
             }
 
             RebuildLoadedClipsUI();

package/Editor/Sprites/TexturePlatformNameHelper.cs

@@ -3,11 +3,42 @@ namespace WallstopStudios.UnityHelpers.Editor.Sprites
 #if UNITY_EDITOR
     using System;
     using System.Collections.Generic;
+    using UnityEngine.SceneManagement;
     using UnityEditor;
+    using UnityEditor.SceneManagement;
+    using WallstopStudios.UnityHelpers.Utils;
 
     internal static class TexturePlatformNameHelper
     {
         private static string[] _cached;
+        private static readonly Dictionary<BuildTargetGroup, string> Map = new()
+        {
+            { BuildTargetGroup.Standalone, "Standalone" },
+            { BuildTargetGroup.iOS, "iPhone" },
+            { BuildTargetGroup.tvOS, "tvOS" },
+            { BuildTargetGroup.Android, "Android" },
+            { BuildTargetGroup.WebGL, "WebGL" },
+            { BuildTargetGroup.PS4, "PS4" },
+            { BuildTargetGroup.PS5, "PS5" },
+            { BuildTargetGroup.XboxOne, "XboxOne" },
+            { BuildTargetGroup.Switch, "Switch" },
+        };
+
+        static TexturePlatformNameHelper()
+        {
+            // Proactively invalidate cache on common editor lifecycle events where domain
+            // reload may be disabled. This keeps results correct while enabling caching.
+            AssemblyReloadEvents.beforeAssemblyReload += ClearCache;
+            EditorApplication.playModeStateChanged += _ => ClearCache();
+            EditorSceneManager.activeSceneChangedInEditMode += (_, _) => ClearCache();
+            SceneManager.sceneLoaded += (_, _) => ClearCache();
+            EditorApplication.projectChanged += ClearCache;
+        }
+
+        private static void ClearCache()
+        {
+            _cached = null;
+        }
 
         public static string[] GetKnownPlatformNames()
         {
@@ -16,62 +47,42 @@ namespace WallstopStudios.UnityHelpers.Editor.Sprites
                 return _cached;
             }
 
-            List<string> names = new(16) { "DefaultTexturePlatform" };
-
-            // Map BuildTargetGroup to importer platform names
-            Dictionary<BuildTargetGroup, string> map = new()
-            {
-                { BuildTargetGroup.Standalone, "Standalone" },
-#if UNITY_IOS || UNITY_TVOS || true
-                { BuildTargetGroup.iOS, "iPhone" },
-                { BuildTargetGroup.tvOS, "tvOS" },
-#endif
-                { BuildTargetGroup.Android, "Android" },
-                { BuildTargetGroup.WebGL, "WebGL" },
-#if UNITY_PS4 || true
-                { BuildTargetGroup.PS4, "PS4" },
-#endif
-#if UNITY_PS5 || true
-                { BuildTargetGroup.PS5, "PS5" },
-#endif
-#if UNITY_XBOXONE || true
-                { BuildTargetGroup.XboxOne, "XboxOne" },
-#endif
-#if UNITY_SWITCH || true
-                { BuildTargetGroup.Switch, "Switch" },
-#endif
-            };
+            // Use a pooled set during build to avoid duplicate checks (O(1) membership) with minimal allocations.
+            using PooledResource<HashSet<string>> setLease = Buffers<string>.HashSet.Get(
+                out HashSet<string> set
+            );
+            _ = set.Add("DefaultTexturePlatform");
 
-            Array values = Enum.GetValues(typeof(BuildTargetGroup));
-            for (int i = 0; i < values.Length; i++)
+            // Enum.GetValues returns a typed array; cast once to avoid boxing per element.
+            BuildTargetGroup[] groups = (BuildTargetGroup[])
+                Enum.GetValues(typeof(BuildTargetGroup));
+            for (int i = 0; i < groups.Length; i++)
             {
-                BuildTargetGroup g = (BuildTargetGroup)values.GetValue(i);
+                BuildTargetGroup g = groups[i];
                 if (g == BuildTargetGroup.Unknown)
                 {
                     continue;
                 }
 
-                // Old/obsolete groups may exist; include them as ToString fallback
-                if (map.TryGetValue(g, out string name))
+                if (Map.TryGetValue(g, out string mapped))
                 {
-                    if (!names.Contains(name))
-                    {
-                        names.Add(name);
-                    }
+                    _ = set.Add(mapped);
                 }
                 else
                 {
                     string n = g.ToString();
-                    if (!string.IsNullOrEmpty(n) && !names.Contains(n))
+                    if (!string.IsNullOrEmpty(n))
                     {
-                        names.Add(n);
+                        _ = set.Add(n);
                     }
                 }
             }
 
-            names.Sort(StringComparer.Ordinal);
-            _cached = names.ToArray();
-            return _cached;
+            string[] arr = new string[set.Count];
+            set.CopyTo(arr);
+            Array.Sort(arr, StringComparer.Ordinal);
+            _cached = arr;
+            return arr;
         }
     }
 #endif

package/Editor/Sprites/TextureResizerWizard.cs

@@ -122,7 +122,29 @@ namespace WallstopStudios.UnityHelpers.Editor.Sprites
                 }
             }
 
-            textures = textures.Where(t => t != null).Distinct().OrderBy(t => t.name).ToList();
+            // Remove nulls, de-dupe, and order by name without LINQ
+            using (Buffers<Texture2D>.HashSet.Get(out HashSet<Texture2D> distinct))
+            using (Buffers<Texture2D>.List.Get(out List<Texture2D> ordered))
+            {
+                for (int i = 0; i < textures.Count; i++)
+                {
+                    Texture2D t = textures[i];
+                    if (t == null)
+                    {
+                        continue;
+                    }
+                    if (distinct.Add(t))
+                    {
+                        ordered.Add(t);
+                    }
+                }
+
+                ordered.Sort(
+                    static (a, b) => string.Compare(a.name, b.name, StringComparison.Ordinal)
+                );
+                textures.Clear();
+                textures.AddRange(ordered);
+            }
 
             if (textures.Count <= 0 || numResizes <= 0)
             {

package/Editor/Sprites/TextureSettingsApplierWindow.cs

@@ -4,7 +4,6 @@ namespace WallstopStudios.UnityHelpers.Editor.Sprites
     using System;
     using System.Collections.Generic;
     using System.IO;
-    using System.Linq;
     using UnityEditor;
     using UnityEngine;
     using CustomEditors;
@@ -74,20 +73,8 @@ namespace WallstopStudios.UnityHelpers.Editor.Sprites
 
         // Optional: named per-platform overrides
         public List<PlatformOverrideEntry> platformOverrides = new();
-        private static readonly string[] KnownPlatforms = new[]
-        {
-            "DefaultTexturePlatform",
-            "Standalone",
-            "iPhone",
-            "Android",
-            "WebGL",
-            "tvOS",
-            "XboxOne",
-            "PS4",
-            "PS5",
-            "Switch",
-        };
         private int _addPlatformIndex;
+        private readonly Dictionary<int, int> _replaceSelectionByIndex = new();
 
         // Flow options
         public bool requireChangesBeforeApply = true; // If true, stats are checked and apply is skipped if nothing changes.
@@ -210,6 +197,37 @@ namespace WallstopStudios.UnityHelpers.Editor.Sprites
                         $"Unknown platform name '{name}'. It will be passed to Unity importer as-is.",
                         MessageType.Info
                     );
+
+                    // Quick fix UX: allow replacing with a known platform directly
+                    EditorGUILayout.BeginHorizontal();
+                    EditorGUILayout.LabelField("Replace With", GUILayout.Width(90));
+                    int currentChoice = 0;
+                    if (_replaceSelectionByIndex.TryGetValue(i, out int tmp))
+                    {
+                        currentChoice = tmp;
+                    }
+                    currentChoice = EditorGUILayout.Popup(currentChoice, knownNames);
+                    _replaceSelectionByIndex[i] = currentChoice;
+                    if (GUILayout.Button("Replace", GUILayout.Width(80)))
+                    {
+                        if (0 <= currentChoice && currentChoice < knownNames.Length)
+                        {
+                            platformOverrides[i].platformName = knownNames[currentChoice];
+                            Repaint();
+                        }
+                    }
+                    // Heuristic quick button for common typo: iOS -> iPhone
+                    if (string.Equals(name, "iOS", StringComparison.OrdinalIgnoreCase))
+                    {
+                        int idx = Array.IndexOf(knownNames, "iPhone");
+                        if (idx >= 0 && GUILayout.Button("Use iPhone", GUILayout.Width(90)))
+                        {
+                            platformOverrides[i].platformName = "iPhone";
+                            _replaceSelectionByIndex[i] = idx;
+                            Repaint();
+                        }
+                    }
+                    EditorGUILayout.EndHorizontal();
                 }
             }
 
@@ -294,13 +312,17 @@ namespace WallstopStudios.UnityHelpers.Editor.Sprites
                 return;
             }
 
-            if (
-                platformOverrides.Any(p =>
-                    string.Equals(p.platformName?.Trim(), name, StringComparison.Ordinal)
-                )
-            )
+            for (int i = 0; i < (platformOverrides?.Count ?? 0); i++)
             {
-                return;
+                PlatformOverrideEntry p = platformOverrides[i];
+                string existing = p?.platformName;
+                if (
+                    !string.IsNullOrEmpty(existing)
+                    && string.Equals(existing.Trim(), name, StringComparison.Ordinal)
+                )
+                {
+                    return;
+                }
             }
             platformOverrides.Add(new PlatformOverrideEntry { platformName = name });
         }
@@ -362,86 +384,127 @@ namespace WallstopStudios.UnityHelpers.Editor.Sprites
         private List<string> GetTargetTexturePaths()
         {
             // Build extension filter (normalize)
-            HashSet<string> allowedExtensions = new(StringComparer.OrdinalIgnoreCase);
-            foreach (string extRaw in spriteFileExtensions ?? Enumerable.Empty<string>())
-            {
-                if (string.IsNullOrWhiteSpace(extRaw))
-                {
-                    continue;
-                }
-
-                string ext = extRaw.StartsWith(".") ? extRaw : "." + extRaw;
-                _ = allowedExtensions.Add(ext);
-            }
-
-            // Collect folders
-            List<string> folderAssetPaths = new();
-            foreach (Object directory in directories ?? Enumerable.Empty<Object>())
+            using (
+                SetBuffers<string>
+                    .GetHashSetPool(StringComparer.OrdinalIgnoreCase)
+                    .Get(out HashSet<string> allowedExtensions)
+            )
             {
-                if (directory == null)
+                if (spriteFileExtensions != null)
                 {
-                    continue;
-                }
-
-                string assetPath = AssetDatabase.GetAssetPath(directory);
-                if (!string.IsNullOrWhiteSpace(assetPath) && AssetDatabase.IsValidFolder(assetPath))
-                {
-                    folderAssetPaths.Add(assetPath);
-                }
-            }
+                    foreach (string extRaw in spriteFileExtensions)
+                    {
+                        if (string.IsNullOrWhiteSpace(extRaw))
+                        {
+                            continue;
+                        }
 
-            HashSet<string> unique = new(StringComparer.OrdinalIgnoreCase);
-            if (folderAssetPaths.Count > 0)
-            {
-                using PooledResource<string[]> folderLease = WallstopFastArrayPool<string>.Get(
-                    folderAssetPaths.Count,
-                    out string[] folders
-                );
-                for (int i = 0; i < folderAssetPaths.Count; i++)
-                {
-                    folders[i] = folderAssetPaths[i];
+                        string ext = extRaw.StartsWith(".") ? extRaw : "." + extRaw;
+                        _ = allowedExtensions.Add(ext);
+                    }
                 }
 
-                string[] guids = AssetDatabase.FindAssets("t:Texture2D", folders);
-                for (int i = 0; i < guids.Length; i++)
+                // Collect folders
+                using (Buffers<string>.List.Get(out List<string> folderAssetPaths))
                 {
-                    string p = AssetDatabase.GUIDToAssetPath(guids[i]);
-                    if (string.IsNullOrWhiteSpace(p))
+                    if (directories != null)
                     {
-                        continue;
+                        foreach (Object directory in directories)
+                        {
+                            if (directory == null)
+                            {
+                                continue;
+                            }
+
+                            string assetPath = AssetDatabase.GetAssetPath(directory);
+                            if (
+                                !string.IsNullOrWhiteSpace(assetPath)
+                                && AssetDatabase.IsValidFolder(assetPath)
+                            )
+                            {
+                                folderAssetPaths.Add(assetPath);
+                            }
+                        }
                     }
 
-                    string ext = Path.GetExtension(p);
-                    if (allowedExtensions.Count > 0 && !allowedExtensions.Contains(ext))
+                    using (
+                        SetBuffers<string>
+                            .GetHashSetPool(StringComparer.OrdinalIgnoreCase)
+                            .Get(out HashSet<string> unique)
+                    )
                     {
-                        continue;
-                    }
+                        if (folderAssetPaths.Count > 0)
+                        {
+                            using PooledResource<string[]> folderLease =
+                                WallstopFastArrayPool<string>.Get(
+                                    folderAssetPaths.Count,
+                                    out string[] folders
+                                );
+                            for (int i = 0; i < folderAssetPaths.Count; i++)
+                            {
+                                folders[i] = folderAssetPaths[i];
+                            }
 
-                    _ = unique.Add(p);
-                }
-            }
+                            string[] guids = AssetDatabase.FindAssets("t:Texture2D", folders);
+                            for (int i = 0; i < guids.Length; i++)
+                            {
+                                string p = AssetDatabase.GUIDToAssetPath(guids[i]);
+                                if (string.IsNullOrWhiteSpace(p))
+                                {
+                                    continue;
+                                }
+
+                                string ext = Path.GetExtension(p);
+                                if (allowedExtensions.Count > 0 && !allowedExtensions.Contains(ext))
+                                {
+                                    continue;
+                                }
+
+                                _ = unique.Add(p);
+                            }
+                        }
 
-            foreach (
-                Texture2D t in textures?.Where(t => t != null).Distinct()
-                    ?? Enumerable.Empty<Texture2D>()
-            )
-            {
-                string p = AssetDatabase.GetAssetPath(t);
-                if (string.IsNullOrWhiteSpace(p))
-                {
-                    continue;
-                }
+                        // De-dupe textures and skip nulls without LINQ
+                        using (Buffers<Texture2D>.HashSet.Get(out HashSet<Texture2D> texSet))
+                        {
+                            if (textures != null)
+                            {
+                                for (int ti = 0; ti < textures.Count; ti++)
+                                {
+                                    Texture2D t = textures[ti];
+                                    if (t == null)
+                                    {
+                                        continue;
+                                    }
+                                    if (!texSet.Add(t))
+                                    {
+                                        continue;
+                                    }
+
+                                    string p = AssetDatabase.GetAssetPath(t);
+                                    if (string.IsNullOrWhiteSpace(p))
+                                    {
+                                        continue;
+                                    }
+
+                                    string ext = Path.GetExtension(p);
+                                    if (
+                                        allowedExtensions.Count > 0
+                                        && !allowedExtensions.Contains(ext)
+                                    )
+                                    {
+                                        continue;
+                                    }
+
+                                    _ = unique.Add(p);
+                                }
+                            }
+                        }
 
-                string ext = Path.GetExtension(p);
-                if (allowedExtensions.Count > 0 && !allowedExtensions.Contains(ext))
-                {
-                    continue;
+                        return new List<string>(unique);
+                    }
                 }
-
-                _ = unique.Add(p);
             }
-
-            return new List<string>(unique);
         }
 
         public void CalculateStats()

package/Editor/Tools/ImageBlurTool.cs

@@ -3,12 +3,10 @@ namespace WallstopStudios.UnityHelpers.Editor.Tools
     using System;
     using System.Collections.Generic;
     using System.IO;
-    using System.Linq;
     using System.Threading.Tasks;
     using UnityEditor;
     using UnityEngine;
     using WallstopStudios.UnityHelpers.Core.Extension;
-    using WallstopStudios.UnityHelpers.Core.Helper;
     using WallstopStudios.UnityHelpers.Editor.CustomEditors;
     using WallstopStudios.UnityHelpers.Editor.Utils;
     using Object = UnityEngine.Object;
@@ -92,16 +90,39 @@ namespace WallstopStudios.UnityHelpers.Editor.Tools
                 nameof(ImageBlurTool)
             );
 
-            if (
-                _serializedObject.ApplyModifiedProperties()
-                || !_lastSeenImageSources.SequenceEqual(imageSources)
-            )
+            bool changed = _serializedObject.ApplyModifiedProperties();
+            if (!changed)
+            {
+                int aCount = _lastSeenImageSources.Count;
+                int bCount = imageSources.Count;
+                if (aCount != bCount)
+                {
+                    changed = true;
+                }
+                else
+                {
+                    for (int i = 0; i < aCount; i++)
+                    {
+                        if (!ReferenceEquals(_lastSeenImageSources[i], imageSources[i]))
+                        {
+                            changed = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            if (changed)
             {
                 _lastSeenImageSources.Clear();
                 _lastSeenImageSources.AddRange(imageSources);
                 _manualTextures.Clear();
-                foreach (Object directory in imageSources.Where(Objects.NotNull))
+                for (int i = 0; i < imageSources.Count; i++)
                 {
+                    Object directory = imageSources[i];
+                    if (directory == null)
+                    {
+                        continue;
+                    }
                     string path = AssetDatabase.GetAssetPath(directory);
                     if (string.IsNullOrWhiteSpace(path))
                     {
@@ -171,9 +192,30 @@ namespace WallstopStudios.UnityHelpers.Editor.Tools
                     _scrollPosition,
                     GUILayout.Height(200)
                 );
-                foreach (Texture2D tex in _manualTextures.Concat(_orderedTextures).Distinct())
+                using (
+                    WallstopStudios.UnityHelpers.Utils.Buffers<Texture2D>.HashSet.Get(
+                        out HashSet<Texture2D> seen
+                    )
+                )
                 {
-                    EditorGUILayout.ObjectField(tex.name, tex, typeof(Texture2D), false);
+                    for (int i = 0; i < _manualTextures.Count; i++)
+                    {
+                        Texture2D t = _manualTextures[i];
+                        if (t == null || !seen.Add(t))
+                        {
+                            continue;
+                        }
+                        EditorGUILayout.ObjectField(t.name, t, typeof(Texture2D), false);
+                    }
+                    for (int i = 0; i < _orderedTextures.Count; i++)
+                    {
+                        Texture2D t = _orderedTextures[i];
+                        if (t == null || !seen.Add(t))
+                        {
+                            continue;
+                        }
+                        EditorGUILayout.ObjectField(t.name, t, typeof(Texture2D), false);
+                    }
                 }
                 EditorGUILayout.EndScrollView();
 
@@ -223,7 +265,36 @@ namespace WallstopStudios.UnityHelpers.Editor.Tools
         private void ApplyBlurToSelectedTextures()
         {
             int processedCount = 0;
-            Texture2D[] toProcess = _manualTextures.Concat(_orderedTextures).Distinct().ToArray();
+            Texture2D[] toProcess;
+            using (
+                WallstopStudios.UnityHelpers.Utils.Buffers<Texture2D>.HashSet.Get(
+                    out HashSet<Texture2D> seen
+                )
+            )
+            using (
+                WallstopStudios.UnityHelpers.Utils.Buffers<Texture2D>.List.Get(
+                    out List<Texture2D> combined
+                )
+            )
+            {
+                for (int i = 0; i < _manualTextures.Count; i++)
+                {
+                    Texture2D t = _manualTextures[i];
+                    if (t != null && seen.Add(t))
+                    {
+                        combined.Add(t);
+                    }
+                }
+                for (int i = 0; i < _orderedTextures.Count; i++)
+                {
+                    Texture2D t = _orderedTextures[i];
+                    if (t != null && seen.Add(t))
+                    {
+                        combined.Add(t);
+                    }
+                }
+                toProcess = combined.ToArray();
+            }
             foreach (Texture2D originalTexture in toProcess)
             {
                 string assetPath = AssetDatabase.GetAssetPath(originalTexture);

package/Editor/Utils/EditorUi.cs

@@ -99,7 +99,7 @@ namespace WallstopStudios.UnityHelpers.Editor.Utils
 
                 PropertyInfo prop = t.GetProperty(
                     "CurrentContext",
-                    System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static
+                    BindingFlags.Public | BindingFlags.Static
                 );
                 if (prop == null)
                 {

package/Editor/Utils/ScriptableObjectSingletonCreator.cs

@@ -47,7 +47,7 @@ namespace WallstopStudios.UnityHelpers.Editor.Utils
                 // Collect candidate types once and detect simple name collisions (same class name, different namespaces)
                 List<Type> allCandidates = new();
                 foreach (
-                    Type t in WallstopStudios.UnityHelpers.Core.Helper.ReflectionHelpers.GetTypesDerivedFrom(
+                    Type t in ReflectionHelpers.GetTypesDerivedFrom(
                         typeof(UnityHelpers.Utils.ScriptableObjectSingleton<>),
                         includeAbstract: false
                     )