com.wallstop-studios.unity-helpers 2.0.0-rc76.5 → 2.0.0-rc76.7

package/Editor/AssetProcessors/SpriteLabelProcessor.cs

@@ -0,0 +1,133 @@
+namespace WallstopStudios.UnityHelpers.Editor.AssetProcessors
+{
+#if UNITY_EDITOR
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using Core.Extension;
+    using Core.Helper;
+    using UnityEditor;
+    using UnityEngine;
+    using Object = UnityEngine.Object;
+
+    public sealed class SpriteLabelProcessor : AssetPostprocessor
+    {
+        private static readonly Dictionary<string, string[]> CachedLabels = new(
+            StringComparer.OrdinalIgnoreCase
+        );
+
+        private static void OnPostprocessAllAssets(
+            string[] importedAssets,
+            string[] deletedAssets,
+            string[] movedAssets,
+            string[] movedFromAssetPaths
+        )
+        {
+            bool anyChanged = !CachedLabels.Any();
+            InitializeCacheIfNeeded();
+
+            foreach (string path in importedAssets)
+            {
+                if (
+                    !path.EndsWith(".png", StringComparison.OrdinalIgnoreCase)
+                    && !path.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase)
+                    && !path.EndsWith(".jpeg", StringComparison.OrdinalIgnoreCase)
+                )
+                {
+                    continue;
+                }
+
+                TextureImporter ti = AssetImporter.GetAtPath(path) as TextureImporter;
+                if (ti == null || ti.textureType != TextureImporterType.Sprite)
+                {
+                    continue;
+                }
+
+                Object mainObj = AssetDatabase.LoadMainAssetAtPath(path);
+                if (mainObj == null)
+                {
+                    continue;
+                }
+
+                string[] newLabels = AssetDatabase.GetLabels(mainObj);
+                if (
+                    !CachedLabels.TryGetValue(path, out string[] oldLabels)
+                    || !AreEqual(oldLabels, newLabels)
+                )
+                {
+                    Debug.Log(
+                        $"[SpriteLabelProcessor] Labels changed on '{path}': {FormatLabels(oldLabels)} → {FormatLabels(newLabels)}"
+                    );
+
+                    string[] updated = new string[newLabels.Length];
+                    Array.Copy(newLabels, updated, newLabels.Length);
+                    anyChanged = true;
+                    CachedLabels[path] = updated;
+                }
+            }
+
+            if (anyChanged)
+            {
+                Helpers.AllSpriteLabels = CachedLabels
+                    .Values.SelectMany(x => x)
+                    .Distinct()
+                    .Ordered()
+                    .ToArray();
+            }
+        }
+
+        private static void InitializeCacheIfNeeded()
+        {
+            if (CachedLabels.Count > 0)
+            {
+                return;
+            }
+
+            string[] guids = AssetDatabase.FindAssets("t:Sprite");
+            foreach (string guid in guids)
+            {
+                string path = AssetDatabase.GUIDToAssetPath(guid);
+                Object asset = AssetDatabase.LoadMainAssetAtPath(path);
+                if (asset == null)
+                {
+                    continue;
+                }
+
+                CachedLabels[path] = AssetDatabase.GetLabels(asset);
+            }
+        }
+
+        private static bool AreEqual(string[] a, string[] b)
+        {
+            if (a == null && b == null)
+            {
+                return true;
+            }
+
+            if (a == null || b == null)
+            {
+                return false;
+            }
+
+            if (a.Length != b.Length)
+            {
+                return false;
+            }
+
+            HashSet<string> setA = new(a, StringComparer.OrdinalIgnoreCase);
+            HashSet<string> setB = new(b, StringComparer.OrdinalIgnoreCase);
+            return setA.SetEquals(setB);
+        }
+
+        private static string FormatLabels(string[] arr)
+        {
+            if (arr == null || arr.Length == 0)
+            {
+                return "(none)";
+            }
+
+            return string.Join(", ", arr);
+        }
+    }
+#endif
+}

package/Editor/AssetProcessors/SpriteLabelProcessor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 36d579d02fe04cb3baab70ec40645cc9
+timeCreated: 1748731957

package/Editor/AssetProcessors.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 46f7f82eccd54399947ba07a548e8a87
+timeCreated: 1748731948

package/Editor/CustomDrawers/StringInListeDrawer.cs

@@ -4,12 +4,25 @@
     using System;
     using UnityEditor;
     using UnityEngine;
-    using WallstopStudios.UnityHelpers.Core.Helper;
+    using Core.Helper;
 
     [CustomPropertyDrawer(typeof(StringInList))]
-    public class StringInListDrawer : PropertyDrawer
+    public sealed class StringInListDrawer : PropertyDrawer
     {
-        // Draw the property inside the given rect
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            if (property.isArray && property.propertyType == SerializedPropertyType.Generic)
+            {
+                int arraySize = property.arraySize;
+
+                float singleLine = EditorGUIUtility.singleLineHeight;
+                float spacing = EditorGUIUtility.standardVerticalSpacing;
+                return singleLine + arraySize * (singleLine + spacing);
+            }
+
+            return base.GetPropertyHeight(property, label);
+        }
+
         public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
         {
             if (attribute is not StringInList stringInList)
@@ -19,37 +32,103 @@
 
             string[] list = stringInList.List;
 
-            switch (property.propertyType)
+            if (property.propertyType == SerializedPropertyType.String)
             {
-                case SerializedPropertyType.String:
+                int index = Mathf.Max(0, Array.IndexOf(list, property.stringValue));
+                index = EditorGUI.Popup(position, property.displayName, index, list);
+                if (index < 0 || list.Length <= index)
                 {
-                    int index = Mathf.Max(0, Array.IndexOf(list, property.stringValue));
-                    index = EditorGUI.Popup(position, property.displayName, index, list);
-                    if (index < 0 || list.Length <= index)
-                    {
-                        base.OnGUI(position, property, label);
-                        return;
-                    }
-
-                    property.stringValue = list[index];
-                    break;
+                    base.OnGUI(position, property, label);
+                    return;
                 }
-                case SerializedPropertyType.Integer:
+
+                property.stringValue = list[index];
+            }
+            else if (property.propertyType == SerializedPropertyType.Integer)
+            {
+                property.intValue = EditorGUI.Popup(
+                    position,
+                    property.displayName,
+                    property.intValue,
+                    list
+                );
+            }
+            else if (property.isArray && property.propertyType == SerializedPropertyType.Generic)
+            {
+                EditorGUI.BeginProperty(position, label, property);
+
+                int originalIndent = EditorGUI.indentLevel;
+                EditorGUI.indentLevel++;
+                try
                 {
-                    property.intValue = EditorGUI.Popup(
-                        position,
-                        property.displayName,
-                        property.intValue,
-                        list
+                    Rect sizeRect = new(
+                        position.x,
+                        position.y,
+                        position.width,
+                        EditorGUIUtility.singleLineHeight
                     );
-                    break;
+                    int newSize = EditorGUI.IntField(
+                        sizeRect,
+                        property.displayName + " Size",
+                        property.arraySize
+                    );
+                    if (newSize < 0)
+                    {
+                        newSize = 0;
+                    }
+
+                    if (newSize != property.arraySize)
+                    {
+                        property.arraySize = newSize;
+                    }
+
+                    for (int i = 0; i < property.arraySize; i++)
+                    {
+                        SerializedProperty elemProp = property.GetArrayElementAtIndex(i);
+                        Rect elementRect = new(
+                            position.x,
+                            position.y
+                                + (
+                                    EditorGUIUtility.singleLineHeight
+                                    + EditorGUIUtility.standardVerticalSpacing
+                                ) * (i + 1),
+                            position.width,
+                            EditorGUIUtility.singleLineHeight
+                        );
+
+                        if (elemProp.propertyType == SerializedPropertyType.String)
+                        {
+                            int currentIndex = Mathf.Max(
+                                0,
+                                Array.IndexOf(list, elemProp.stringValue)
+                            );
+                            currentIndex = EditorGUI.Popup(
+                                elementRect,
+                                $"Element {i}",
+                                currentIndex,
+                                list
+                            );
+                            if (currentIndex >= 0 && currentIndex < list.Length)
+                            {
+                                elemProp.stringValue = list[currentIndex];
+                            }
+                        }
+                        else
+                        {
+                            EditorGUI.PropertyField(elementRect, elemProp);
+                        }
+                    }
                 }
-                default:
+                finally
                 {
-                    base.OnGUI(position, property, label);
-                    break;
+                    EditorGUI.indentLevel = originalIndent;
+                    EditorGUI.EndProperty();
                 }
             }
+            else
+            {
+                base.OnGUI(position, property, label);
+            }
         }
     }
 #endif

package/Editor/CustomDrawers/WShowIfPropertyDrawer.cs

@@ -1,12 +1,12 @@
 namespace WallstopStudios.UnityHelpers.Editor.CustomDrawers
 {
 #if UNITY_EDITOR
+    using System;
     using System.Reflection;
     using Extensions;
     using UnityEditor;
     using UnityEngine;
-    using WallstopStudios.UnityHelpers.Core.Attributes;
-    using WallstopStudios.UnityHelpers.Core.Extension;
+    using Core.Attributes;
 
     [CustomPropertyDrawer(typeof(WShowIfAttribute))]
     public sealed class WShowIfPropertyDrawer : PropertyDrawer
@@ -49,11 +49,19 @@
                         showIf.conditionField,
                         BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
                     );
-                if (conditionField?.GetValue(enclosingObject) is bool maybeCondition)
+                object fieldValue = conditionField?.GetValue(enclosingObject);
+                if (fieldValue is bool maybeCondition)
                 {
                     return showIf.inverse ? !maybeCondition : maybeCondition;
                 }
-                return true;
+
+                int index = Array.IndexOf(showIf.expectedValues, fieldValue);
+                if (showIf.inverse)
+                {
+                    return index < 0;
+                }
+
+                return 0 <= index;
             }
 
             bool condition = conditionProperty.boolValue;

package/Editor/CustomEditors/PersistentDirectoryGUI.cs

@@ -620,7 +620,10 @@
                                 }
                             }
                         }
-                        catch { }
+                        catch
+                        {
+                            // Swalllow
+                        }
                     }
                     if (!Directory.Exists(initialBrowsePath))
                     {

package/Editor/CustomEditors/SourceFolderEntryDrawer.cs

@@ -38,9 +38,6 @@
                 SerializedProperty folderPathProp = property.FindPropertyRelative(
                     nameof(SourceFolderEntry.folderPath)
                 );
-                SerializedProperty regexesProp = property.FindPropertyRelative(
-                    nameof(SourceFolderEntry.regexes)
-                );
 
                 Rect folderPathLabelRect = new(
                     startX,
@@ -134,68 +131,165 @@
                 );
 
                 currentY += EditorGUIUtility.standardVerticalSpacing;
-                Rect regexFoldoutLabelRect = new(
+
+                SerializedProperty modeProp = property.FindPropertyRelative(
+                    nameof(SourceFolderEntry.selectionMode)
+                );
+                SpriteSelectionMode modeValue = (SpriteSelectionMode)modeProp.intValue;
+                Rect selectionMode = new(
                     startX,
                     currentY,
                     availableWidth,
                     EditorGUIUtility.singleLineHeight
                 );
+                modeValue = (SpriteSelectionMode)
+                    EditorGUI.EnumFlagsField(
+                        selectionMode,
+                        new GUIContent("Selection Mode"),
+                        modeValue
+                    );
+                modeProp.intValue = (int)modeValue;
+                currentY +=
+                    EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
 
-                string regexesFoldoutKey = GetRegexFoldoutKey(property);
-                RegexesFoldoutState.TryAdd(regexesFoldoutKey, true);
-                RegexesFoldoutState[regexesFoldoutKey] = EditorGUI.Foldout(
-                    regexFoldoutLabelRect,
-                    RegexesFoldoutState[regexesFoldoutKey],
-                    "Regexes (AND logic)",
-                    true
-                );
-                currentY += regexFoldoutLabelRect.height + EditorGUIUtility.standardVerticalSpacing;
+                bool useRegex = (modeValue & SpriteSelectionMode.Regex) != 0;
+                bool useLabels = (modeValue & SpriteSelectionMode.Labels) != 0;
 
-                if (RegexesFoldoutState[regexesFoldoutKey])
+                if (useRegex)
                 {
-                    int listElementIndentLvl = EditorGUI.indentLevel;
-                    EditorGUI.indentLevel++;
-                    float regexStartX = startX + 15f;
-                    float regexAvailableWidth = availableWidth - 15f;
-                    Rect sizeFieldRect = new(
-                        regexStartX,
+                    Rect regexFoldoutLabelRect = new(
+                        startX,
                         currentY,
-                        regexAvailableWidth,
+                        availableWidth,
                         EditorGUIUtility.singleLineHeight
                     );
 
-                    EditorGUI.BeginChangeCheck();
-                    int newSize = EditorGUI.IntField(sizeFieldRect, "Size", regexesProp.arraySize);
-                    if (EditorGUI.EndChangeCheck())
-                    {
-                        newSize = Mathf.Max(0, newSize);
-                        regexesProp.arraySize = newSize;
-                    }
-                    currentY += sizeFieldRect.height + EditorGUIUtility.standardVerticalSpacing;
+                    string regexesFoldoutKey = GetRegexFoldoutKey(property);
+                    RegexesFoldoutState.TryAdd(regexesFoldoutKey, true);
+                    RegexesFoldoutState[regexesFoldoutKey] = EditorGUI.Foldout(
+                        regexFoldoutLabelRect,
+                        RegexesFoldoutState[regexesFoldoutKey],
+                        "Regexes (AND logic)",
+                        true
+                    );
+                    currentY +=
+                        regexFoldoutLabelRect.height + EditorGUIUtility.standardVerticalSpacing;
 
-                    for (int i = 0; i < regexesProp.arraySize; i++)
+                    if (RegexesFoldoutState[regexesFoldoutKey])
                     {
-                        SerializedProperty elementProp = regexesProp.GetArrayElementAtIndex(i);
-                        Rect elementRect = new(
+                        SerializedProperty regexesProp = property.FindPropertyRelative(
+                            nameof(SourceFolderEntry.regexes)
+                        );
+                        float regexStartX = startX + 15f;
+                        float regexWidth = availableWidth - 15f;
+
+                        for (int i = 0; i < regexesProp.arraySize; i++)
+                        {
+                            SerializedProperty elemProp = regexesProp.GetArrayElementAtIndex(i);
+                            Rect fieldRect = new(
+                                regexStartX,
+                                currentY,
+                                regexWidth - 25f,
+                                EditorGUIUtility.singleLineHeight
+                            );
+                            EditorGUI.BeginChangeCheck();
+                            string newVal = EditorGUI.TextField(
+                                fieldRect,
+                                $"Regex {i}:",
+                                elemProp.stringValue
+                            );
+                            if (EditorGUI.EndChangeCheck())
+                            {
+                                elemProp.stringValue = newVal;
+                            }
+
+                            Rect remRect = new(
+                                fieldRect.xMax + 4f,
+                                currentY,
+                                25f,
+                                EditorGUIUtility.singleLineHeight
+                            );
+                            if (GUI.Button(remRect, "–"))
+                            {
+                                regexesProp.DeleteArrayElementAtIndex(i);
+                                property.serializedObject.ApplyModifiedProperties();
+                            }
+
+                            currentY +=
+                                EditorGUIUtility.singleLineHeight
+                                + EditorGUIUtility.standardVerticalSpacing;
+                        }
+
+                        Rect addRect = new(
                             regexStartX,
                             currentY,
-                            regexAvailableWidth,
+                            regexWidth,
                             EditorGUIUtility.singleLineHeight
                         );
-                        EditorGUI.BeginChangeCheck();
-                        string newStringValue = EditorGUI.TextField(
-                            elementRect,
-                            $"Element {i}",
-                            elementProp.stringValue
-                        );
-                        if (EditorGUI.EndChangeCheck())
+
+                        if (GUI.Button(addRect, "+ Add Regex"))
                         {
-                            elementProp.stringValue = newStringValue;
+                            int idx = regexesProp.arraySize;
+                            regexesProp.InsertArrayElementAtIndex(idx);
+                            regexesProp.GetArrayElementAtIndex(idx).stringValue = string.Empty;
+                            property.serializedObject.ApplyModifiedProperties();
                         }
-                        currentY += elementRect.height + EditorGUIUtility.standardVerticalSpacing;
                     }
-                    EditorGUI.indentLevel = listElementIndentLvl;
                 }
+
+                if (useRegex && useLabels)
+                {
+                    SerializedProperty booleanProp = property.FindPropertyRelative(
+                        nameof(SourceFolderEntry.regexAndTagLogic)
+                    );
+                    currentY +=
+                        EditorGUIUtility.singleLineHeight
+                        + EditorGUIUtility.standardVerticalSpacing;
+                    EditorGUI.PropertyField(
+                        new Rect(
+                            startX,
+                            currentY,
+                            availableWidth,
+                            EditorGUIUtility.singleLineHeight
+                        ),
+                        booleanProp,
+                        new GUIContent("Regex & Tags Logic")
+                    );
+                    currentY +=
+                        EditorGUIUtility.singleLineHeight
+                        + EditorGUIUtility.standardVerticalSpacing;
+                }
+
+                if (useLabels)
+                {
+                    SerializedProperty labelModeProp = property.FindPropertyRelative(
+                        "labelSelectionMode"
+                    );
+                    Rect rectLabelMode = new(
+                        startX,
+                        currentY,
+                        availableWidth,
+                        EditorGUIUtility.singleLineHeight
+                    );
+                    EditorGUI.PropertyField(
+                        rectLabelMode,
+                        labelModeProp,
+                        new GUIContent("Label Selection Mode")
+                    );
+                    currentY +=
+                        EditorGUIUtility.singleLineHeight
+                        + EditorGUIUtility.standardVerticalSpacing;
+
+                    SerializedProperty labelsProp = property.FindPropertyRelative(
+                        nameof(SourceFolderEntry.labels)
+                    );
+                    float labelsHeight = EditorGUI.GetPropertyHeight(labelsProp, true);
+
+                    Rect rectLabels = new(startX, currentY, availableWidth, labelsHeight);
+                    EditorGUI.PropertyField(rectLabels, labelsProp, new GUIContent("Labels"), true);
+                    currentY += labelsHeight + EditorGUIUtility.standardVerticalSpacing;
+                }
+
                 EditorGUI.indentLevel = originalIndent;
             }
             EditorGUI.EndProperty();
@@ -225,19 +319,62 @@
 
             height += EditorGUIUtility.standardVerticalSpacing;
             height += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-            string regexesFoldoutKey = GetRegexFoldoutKey(property);
-            bool isRegexesExpanded = RegexesFoldoutState.GetValueOrDefault(regexesFoldoutKey, true);
-            if (isRegexesExpanded)
+
+            SerializedProperty modeProp = property.FindPropertyRelative(
+                nameof(SourceFolderEntry.selectionMode)
+            );
+            SpriteSelectionMode modeValue = (SpriteSelectionMode)modeProp.intValue;
+            bool useRegex = (modeValue & SpriteSelectionMode.Regex) != 0;
+            bool useLabels = (modeValue & SpriteSelectionMode.Labels) != 0;
+
+            if (useRegex)
             {
-                SerializedProperty regexesProp = property.FindPropertyRelative(
-                    nameof(SourceFolderEntry.regexes)
+                string regexesFoldoutKey = GetRegexFoldoutKey(property);
+                bool isRegexesExpanded = RegexesFoldoutState.GetValueOrDefault(
+                    regexesFoldoutKey,
+                    true
                 );
-                height +=
-                    (1 + regexesProp.arraySize)
-                    * (
-                        EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing
+                if (isRegexesExpanded)
+                {
+                    SerializedProperty regexesProp = property.FindPropertyRelative(
+                        nameof(SourceFolderEntry.regexes)
                     );
+                    height +=
+                        (1 + regexesProp.arraySize)
+                        * (
+                            EditorGUIUtility.singleLineHeight
+                            + EditorGUIUtility.standardVerticalSpacing
+                        );
+                }
+
+                height +=
+                    EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            }
+
+            if (useRegex && useLabels)
+            {
+                height +=
+                    EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
             }
+
+            if (useLabels)
+            {
+                // 1) Draw the “Label Selection Mode” line (dropdown)
+                height += EditorGUIUtility.singleLineHeight;
+                height += EditorGUIUtility.standardVerticalSpacing;
+
+                // 2) Now figure out how tall “labels” really is. Let Unity handle foldout‐vs‐expanded.
+                SerializedProperty labelsProp = property.FindPropertyRelative(
+                    nameof(SourceFolderEntry.labels)
+                );
+
+                //    Passing `true` tells Unity: “Include children if expanded, or just header if collapsed.”
+                float labelsFullHeight = EditorGUI.GetPropertyHeight(labelsProp, true);
+
+                height += labelsFullHeight;
+                height += EditorGUIUtility.standardVerticalSpacing;
+            }
+
             height += EditorGUIUtility.standardVerticalSpacing;
             return height;
         }

package/Editor/Extensions/SerializedPropertyExtensions.cs

@@ -27,6 +27,17 @@
             Type type = obj.GetType();
             string[] pathParts = property.propertyPath.Split('.');
 
+            if (
+                string.Equals(property.name, "data", StringComparison.Ordinal)
+                && pathParts.Length > 1
+                && pathParts[^1].Contains('[')
+                && pathParts[^1].Contains(']')
+                && string.Equals(pathParts[^2], "Array", StringComparison.Ordinal)
+            )
+            {
+                Array.Resize(ref pathParts, pathParts.Length - 2);
+            }
+
             // Traverse the path but stop at the second-to-last field
             for (int i = 0; i < pathParts.Length - 1; ++i)
             {