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

package/Editor/Core/Helper/AnimationEventHelpers.cs

@@ -2,7 +2,6 @@ namespace WallstopStudios.UnityHelpers.Editor.Core.Helper
 {
     using System;
     using System.Collections.Generic;
-    using System.Linq;
     using System.Reflection;
     using UnityEditor;
     using UnityEngine;
@@ -17,188 +16,215 @@ namespace WallstopStudios.UnityHelpers.Editor.Core.Helper
         static AnimationEventHelpers()
         {
             List<(Type, string)> ignoreDerived = new();
-            Dictionary<Type, List<MethodInfo>> typesToMethods = TypeCache
-                .GetTypesDerivedFrom<MonoBehaviour>()
-                .Where(type => type.IsClass && !type.IsAbstract)
-                .ToDictionary(
-                    type => type,
-                    type =>
+            Dictionary<Type, List<MethodInfo>> typesToMethods = new();
+
+            TypeCache.TypeCollection monoTypes = TypeCache.GetTypesDerivedFrom<MonoBehaviour>();
+            for (int i = 0; i < monoTypes.Count; i++)
+            {
+                Type type = monoTypes[i];
+                if (type == null || !type.IsClass || type.IsAbstract)
+                {
+                    continue;
+                }
+
+                List<MethodInfo> definedMethods = GetPossibleAnimatorEventsForType(type);
+                // Filter: only methods directly declared on this type and attributed
+                for (int m = definedMethods.Count - 1; m >= 0; m--)
+                {
+                    MethodInfo method = definedMethods[m];
+                    if (method.DeclaringType != type)
                     {
-                        List<MethodInfo> definedMethods = GetPossibleAnimatorEventsForType(type)
-                            .Where(method =>
-                            {
-                                // Only include methods where the attribute is directly defined
-                                if (
-                                    !method.IsAttributeDefined<AnimationEventAttribute>(
-                                        out _,
-                                        inherit: false
-                                    )
-                                )
-                                {
-                                    return false;
-                                }
-
-                                // Only include methods that are declared on this type
-                                return method.DeclaringType == type;
-                            })
-                            .ToList();
-
-                        // Only include inherited methods if this type has its own handlers
-                        if (definedMethods.Count > 0)
+                        definedMethods.RemoveAt(m);
+                        continue;
+                    }
+                    if (!method.IsAttributeDefined<AnimationEventAttribute>(out _, inherit: false))
+                    {
+                        definedMethods.RemoveAt(m);
+                    }
+                }
+
+                if (definedMethods.Count > 0)
+                {
+                    // Include inherited methods that explicitly allow derived
+                    List<MethodInfo> allPossible = GetPossibleAnimatorEventsForType(type);
+                    for (int m = 0; m < allPossible.Count; m++)
+                    {
+                        MethodInfo candidate = allPossible[m];
+                        if (candidate.DeclaringType == type)
                         {
-                            // Also include inherited methods that explicitly allow derived types
-                            List<MethodInfo> inheritedMethods = GetPossibleAnimatorEventsForType(
-                                    type
-                                )
-                                .Where(method =>
-                                {
-                                    // Skip if not attributed
-                                    if (
-                                        !method.IsAttributeDefined<AnimationEventAttribute>(
-                                            out _,
-                                            inherit: false
-                                        )
-                                    )
-                                    {
-                                        return false;
-                                    }
-
-                                    // Skip if declared on this type (already handled)
-                                    if (method.DeclaringType == type)
-                                    {
-                                        return false;
-                                    }
-
-                                    // Include inherited methods that allow derived
-                                    if (
-                                        method.IsAttributeDefined(
-                                            out AnimationEventAttribute attribute,
-                                            inherit: false
-                                        )
-                                    )
-                                    {
-                                        return !attribute.ignoreDerived;
-                                    }
-
-                                    return false;
-                                })
-                                .Select(method =>
-                                    // Get the method from its declaring type to ensure consistent MethodInfo references
-                                    method.DeclaringType.GetMethod(
-                                        method.Name,
-                                        BindingFlags.Instance
-                                            | BindingFlags.Public
-                                            | BindingFlags.NonPublic,
-                                        null,
-                                        method
-                                            .GetParameters()
-                                            .Select(p => p.ParameterType)
-                                            .ToArray(),
-                                        null
-                                    )
-                                )
-                                .ToList();
-
-                            definedMethods.AddRange(inheritedMethods);
+                            continue;
                         }
-                        foreach (MethodInfo definedMethod in definedMethods)
-                        {
-                            // Only consider attributes on our specific method
-                            if (
-                                !definedMethod.IsAttributeDefined<AnimationEventAttribute>(
-                                    out _,
-                                    inherit: false
-                                )
+                        if (
+                            !candidate.IsAttributeDefined<AnimationEventAttribute>(
+                                out AnimationEventAttribute attribute,
+                                inherit: false
                             )
-                            {
-                                continue;
-                            }
+                        )
+                        {
+                            continue;
+                        }
+                        if (attribute.ignoreDerived)
+                        {
+                            continue;
+                        }
 
-                            if (
-                                definedMethod.IsAttributeDefined(
-                                    out AnimationEventAttribute attribute,
-                                    inherit: false
-                                ) && attribute.ignoreDerived
-                            )
+                        // Re-resolve method on its declaring type with exact parameter types
+                        ParameterInfo[] parameters = candidate.GetParameters();
+                        Type[] paramTypes;
+                        if (parameters is { Length: > 0 })
+                        {
+                            paramTypes = new Type[parameters.Length];
+                            for (int pi = 0; pi < parameters.Length; pi++)
                             {
-                                ignoreDerived.Add((type, definedMethod.Name));
+                                paramTypes[pi] = parameters[pi].ParameterType;
                             }
                         }
+                        else
+                        {
+                            paramTypes = Array.Empty<Type>();
+                        }
 
-                        return definedMethods;
+                        MethodInfo resolved = candidate.DeclaringType.GetMethod(
+                            candidate.Name,
+                            BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
+                            null,
+                            paramTypes,
+                            null
+                        );
+                        if (resolved != null)
+                        {
+                            definedMethods.Add(resolved);
+                        }
                     }
-                );
+                }
 
-            using PooledResource<List<KeyValuePair<Type, List<MethodInfo>>>> methodBufferResource =
-                Buffers<KeyValuePair<Type, List<MethodInfo>>>.List.Get();
-            List<KeyValuePair<Type, List<MethodInfo>>> methodBuffer = methodBufferResource.resource;
-            foreach (KeyValuePair<Type, List<MethodInfo>> entry in typesToMethods)
-            {
-                methodBuffer.Add(entry);
+                for (int m = 0; m < definedMethods.Count; m++)
+                {
+                    MethodInfo definedMethod = definedMethods[m];
+                    if (
+                        definedMethod.IsAttributeDefined(
+                            out AnimationEventAttribute attr,
+                            inherit: false
+                        ) && attr.ignoreDerived
+                    )
+                    {
+                        ignoreDerived.Add((type, definedMethod.Name));
+                    }
+                }
+
+                if (definedMethods.Count > 0)
+                {
+                    typesToMethods[type] = definedMethods;
+                }
             }
-            foreach (KeyValuePair<Type, List<MethodInfo>> entry in methodBuffer)
+
+            using (
+                PooledResource<List<KeyValuePair<Type, List<MethodInfo>>>> methodBufferResource =
+                    Buffers<KeyValuePair<Type, List<MethodInfo>>>.List.Get()
+            )
             {
-                if (entry.Value.Count <= 0)
+                List<KeyValuePair<Type, List<MethodInfo>>> methodBuffer =
+                    methodBufferResource.resource;
+                foreach (KeyValuePair<Type, List<MethodInfo>> entry in typesToMethods)
                 {
-                    _ = typesToMethods.Remove(entry.Key);
+                    methodBuffer.Add(entry);
                 }
 
-                Type key = entry.Key;
-                foreach ((Type type, string methodName) in ignoreDerived)
+                foreach (KeyValuePair<Type, List<MethodInfo>> entry in methodBuffer)
                 {
-                    if (key == type)
+                    if (entry.Value.Count <= 0)
                     {
+                        _ = typesToMethods.Remove(entry.Key);
                         continue;
                     }
 
-                    if (!key.IsSubclassOf(type))
+                    Type key = entry.Key;
+                    for (int i = 0; i < ignoreDerived.Count; i++)
                     {
-                        continue;
-                    }
+                        (Type baseType, string methodName) = ignoreDerived[i];
+                        if (key == baseType)
+                        {
+                            continue;
+                        }
+                        if (!key.IsSubclassOf(baseType))
+                        {
+                            continue;
+                        }
 
-                    entry.Value.RemoveAll(method => method.Name == methodName);
-                    if (entry.Value.Count <= 0)
-                    {
-                        _ = typesToMethods.Remove(entry.Key);
-                        break;
+                        // Remove inherited methods with this name
+                        for (int midx = entry.Value.Count - 1; midx >= 0; midx--)
+                        {
+                            if (entry.Value[midx].Name == methodName)
+                            {
+                                entry.Value.RemoveAt(midx);
+                            }
+                        }
+                        if (entry.Value.Count <= 0)
+                        {
+                            _ = typesToMethods.Remove(entry.Key);
+                            break;
+                        }
                     }
                 }
             }
 
-            TypesToMethods = typesToMethods.ToDictionary(
-                kvp => kvp.Key,
-                kvp => (IReadOnlyList<MethodInfo>)kvp.Value
-            );
+            // Project to IReadOnlyList without LINQ
+            Dictionary<Type, IReadOnlyList<MethodInfo>> ro = new();
+            foreach (KeyValuePair<Type, List<MethodInfo>> kvp in typesToMethods)
+            {
+                ro[kvp.Key] = kvp.Value;
+            }
+            TypesToMethods = ro;
         }
 
         public static List<MethodInfo> GetPossibleAnimatorEventsForType(Type type)
         {
-            return type.GetMethods(
-                    BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
-                )
-                .Where(p =>
-                    p.ReturnType == typeof(void)
-                    && (
-                        p.GetParameters().Select(q => q.ParameterType).SequenceEqual(new Type[] { })
-                        || p.GetParameters()
-                            .Select(q => q.ParameterType)
-                            .SequenceEqual(new Type[] { typeof(int) })
-                        || p.GetParameters()
-                            .Select(q => q.ParameterType.BaseType)
-                            .SequenceEqual(new Type[] { typeof(Enum) })
-                        || p.GetParameters()
-                            .Select(q => q.ParameterType)
-                            .SequenceEqual(new Type[] { typeof(float) })
-                        || p.GetParameters()
-                            .Select(q => q.ParameterType)
-                            .SequenceEqual(new Type[] { typeof(string) })
-                        || p.GetParameters()
-                            .Select(q => q.ParameterType)
-                            .SequenceEqual(new Type[] { typeof(UnityEngine.Object) })
-                    )
-                )
-                .OrderBy(method => method.Name)
-                .ToList();
+            MethodInfo[] methods = type.GetMethods(
+                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
+            );
+            using (Buffers<MethodInfo>.List.Get(out List<MethodInfo> result))
+            {
+                for (int i = 0; i < methods.Length; i++)
+                {
+                    MethodInfo m = methods[i];
+                    if (m.ReturnType != typeof(void))
+                    {
+                        continue;
+                    }
+
+                    ParameterInfo[] ps = m.GetParameters();
+                    bool ok;
+                    if (ps == null || ps.Length == 0)
+                    {
+                        ok = true;
+                    }
+                    else if (ps.Length == 1)
+                    {
+                        Type pt = ps[0].ParameterType;
+                        ok =
+                            pt == typeof(int)
+                            || pt == typeof(float)
+                            || pt == typeof(string)
+                            || pt == typeof(UnityEngine.Object)
+                            || (pt.BaseType == typeof(Enum));
+                    }
+                    else
+                    {
+                        ok = false;
+                    }
+
+                    if (ok)
+                    {
+                        result.Add(m);
+                    }
+                }
+
+                result.Sort(
+                    static (a, b) => string.Compare(a.Name, b.Name, StringComparison.Ordinal)
+                );
+                // Return a new list to avoid exposing pooled instance
+                return new List<MethodInfo>(result);
+            }
         }
     }
 }

package/Editor/CustomEditors/PersistentDirectoryGUI.cs

@@ -5,7 +5,6 @@ namespace WallstopStudios.UnityHelpers.Editor.CustomEditors
     using UnityEngine;
     using UnityEditor;
     using System.Collections.Generic;
-    using System.Linq;
     using System.IO;
     using WallstopStudios.UnityHelpers.Core.Helper;
     using Object = UnityEngine.Object;
@@ -115,13 +114,12 @@ namespace WallstopStudios.UnityHelpers.Editor.CustomEditors
 
                     if (ContextFoldoutStates[foldoutKey])
                     {
-                        List<DirectoryUsageData> pathsNotAlreadyInTop = allPaths
-                            .Skip(topN)
-                            .ToList();
-                        if (pathsNotAlreadyInTop.Any())
+                        int remaining = allPaths.Length - topN;
+                        if (remaining > 0)
                         {
-                            foreach (DirectoryUsageData dirData in pathsNotAlreadyInTop)
+                            for (int idx = topN; idx < allPaths.Length; idx++)
                             {
+                                DirectoryUsageData dirData = allPaths[idx];
                                 Rect moreHistoryButtonRect = new(
                                     startX + 30f,
                                     currentY,
@@ -213,8 +211,13 @@ namespace WallstopStudios.UnityHelpers.Editor.CustomEditors
                     bool isExpanded = ContextFoldoutStates.GetValueOrDefault(foldoutKey, false);
                     if (isExpanded)
                     {
+                        int remaining = allPaths.Length - topN;
+                        if (remaining < 1)
+                        {
+                            remaining = 1;
+                        }
                         height +=
-                            Mathf.Max(1, allPaths.Skip(topN).Count())
+                            remaining
                             * (
                                 EditorGUIUtility.singleLineHeight
                                 + EditorGUIUtility.standardVerticalSpacing
@@ -271,8 +274,13 @@ namespace WallstopStudios.UnityHelpers.Editor.CustomEditors
                     bool isExpanded = ContextFoldoutStates.GetValueOrDefault(foldoutKey, false);
                     if (isExpanded)
                     {
+                        int remaining = allPaths.Length - topN;
+                        if (remaining < 1)
+                        {
+                            remaining = 1;
+                        }
                         height +=
-                            Mathf.Max(1, allPaths.Skip(topN).Count())
+                            remaining
                             * (
                                 EditorGUIUtility.singleLineHeight
                                 + EditorGUIUtility.standardVerticalSpacing
@@ -765,11 +773,12 @@ namespace WallstopStudios.UnityHelpers.Editor.CustomEditors
                         return;
                     }
 
-                    DirectoryUsageData[] pathsNotAlreadyInTop = allPaths.Skip(topN).ToArray();
-                    if (0 < pathsNotAlreadyInTop.Length)
+                    int remaining = allPaths.Length - topN;
+                    if (remaining > 0)
                     {
-                        foreach (DirectoryUsageData dirData in pathsNotAlreadyInTop)
+                        for (int idx = topN; idx < allPaths.Length; idx++)
                         {
+                            DirectoryUsageData dirData = allPaths[idx];
                             if (
                                 GUILayout.Button(
                                     new GUIContent(

package/Editor/CustomEditors/TexturePlatformOverrideEntryDrawer.cs

@@ -8,17 +8,26 @@ namespace WallstopStudios.UnityHelpers.Editor.CustomEditors
     [CustomPropertyDrawer(typeof(TextureSettingsApplierWindow.PlatformOverrideEntry))]
     public sealed class TexturePlatformOverrideEntryDrawer : PropertyDrawer
     {
+        private static string[] _cachedChoices;
+        private static string[] _lastKnownRef;
+
         private static string[] GetChoices()
         {
             string[] known = TexturePlatformNameHelper.GetKnownPlatformNames();
+            if (ReferenceEquals(known, _lastKnownRef) && _cachedChoices != null)
+            {
+                return _cachedChoices;
+            }
+
             string[] arr = new string[known.Length + 1];
             for (int i = 0; i < known.Length; i++)
             {
                 arr[i] = known[i];
             }
-
             arr[arr.Length - 1] = "Custom";
-            return arr;
+            _lastKnownRef = known;
+            _cachedChoices = arr;
+            return _cachedChoices;
         }
 
         public override float GetPropertyHeight(SerializedProperty property, GUIContent label)

package/Editor/FitTextureSizeWindow.cs

@@ -4,7 +4,6 @@ namespace WallstopStudios.UnityHelpers.Editor
     using System;
     using System.Collections.Generic;
     using System.IO;
-    using System.Linq;
     using System.Text.RegularExpressions;
     using UnityEditor;
     using UnityEngine;
@@ -410,20 +409,32 @@ namespace WallstopStudios.UnityHelpers.Editor
             // Reset the label-query GUIDs set for a fresh collection
             _labelQueryGuids.Clear();
 
-            if (!uniqueAssetPaths.Any())
+            if (uniqueAssetPaths.Count == 0)
             {
                 if (_useSelectionOnly)
                 {
                     // Selection-only mode with no folders selected: rely on direct GUIDs only.
                 }
-                else if (_textureSourcePaths.Any(o => o != null))
-                {
-                    this.LogWarn($"No valid source folders found in the list.");
-                }
                 else
                 {
-                    this.Log($"No source folders specified. Searching entire 'Assets' folder.");
-                    searchPaths.Add("Assets");
+                    bool anyNonNull = false;
+                    for (int i = 0; i < _textureSourcePaths.Count; i++)
+                    {
+                        if (_textureSourcePaths[i] != null)
+                        {
+                            anyNonNull = true;
+                            break;
+                        }
+                    }
+                    if (anyNonNull)
+                    {
+                        this.LogWarn($"No valid source folders found in the list.");
+                    }
+                    else
+                    {
+                        this.Log($"No source folders specified. Searching entire 'Assets' folder.");
+                        searchPaths.Add("Assets");
+                    }
                 }
             }
             else
@@ -490,21 +501,34 @@ namespace WallstopStudios.UnityHelpers.Editor
             bool hasLabelFilterCsv = !string.IsNullOrWhiteSpace(_labelFilterCsv);
             if (hasLabelFilterCsv)
             {
-                parsedLabels = _labelFilterCsv
-                    .Split(new[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries)
-                    .Select(s => s.Trim())
-                    .Where(s => s.Length > 0)
-                    .ToArray();
-                if (parsedLabels.Length > 0)
+                string raw = _labelFilterCsv;
+                char[] seps = { ',', ';' };
+                string[] parts = raw.Split(seps, StringSplitOptions.RemoveEmptyEntries);
+                // Trim and filter empties without LINQ
+                int count = 0;
+                for (int i = 0; i < parts.Length; i++)
+                {
+                    string item = parts[i] != null ? parts[i].Trim() : string.Empty;
+                    if (!string.IsNullOrEmpty(item))
+                    {
+                        parts[count++] = item;
+                    }
+                }
+                if (count > 0)
                 {
+                    parsedLabels = new string[count];
+                    for (int i = 0; i < count; i++)
+                    {
+                        parsedLabels[i] = parts[i];
+                    }
+
                     labelSetRes = Buffers<string>.HashSet.Get(out labelSet);
                     for (int i = 0; i < parsedLabels.Length; i++)
                     {
-                        _ = labelSet.Add(
-                            _caseSensitiveNameFilter
-                                ? parsedLabels[i]
-                                : parsedLabels[i].ToLowerInvariant()
-                        );
+                        string norm = _caseSensitiveNameFilter
+                            ? parsedLabels[i]
+                            : parsedLabels[i].ToLowerInvariant();
+                        _ = labelSet.Add(norm);
                     }
                 }
             }