com.wallstop-studios.unity-helpers 2.0.0-rc73.14 → 2.0.0-rc73.16

package/Editor/CustomEditors/SourceFolderEntryDrawer.cs

@@ -0,0 +1,303 @@
+namespace WallstopStudios.UnityHelpers.Editor.CustomEditors
+{
+#if UNITY_EDITOR
+    using System;
+    using Sprites;
+    using UnityEngine;
+    using UnityEditor;
+    using System.Collections.Generic;
+    using System.IO;
+    using Core.Helper;
+    using System.Linq;
+
+    [CustomPropertyDrawer(typeof(SourceFolderEntry))]
+    public sealed class SourceFolderEntryDrawer : PropertyDrawer
+    {
+        private static readonly Dictionary<string, bool> RegexesFoldoutState = new(
+            StringComparer.Ordinal
+        );
+
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            EditorGUI.BeginProperty(position, label, property);
+
+            Rect foldoutRect = new(
+                position.x,
+                position.y,
+                position.width,
+                EditorGUIUtility.singleLineHeight
+            );
+            property.isExpanded = EditorGUI.Foldout(foldoutRect, property.isExpanded, label, true);
+
+            if (property.isExpanded)
+            {
+                int originalIndent = EditorGUI.indentLevel;
+                EditorGUI.indentLevel++;
+
+                float currentY = foldoutRect.yMax + EditorGUIUtility.standardVerticalSpacing;
+                float availableWidth = position.width - EditorGUI.indentLevel * 15f;
+                float startX = position.x + EditorGUI.indentLevel * 15f;
+
+                SerializedProperty folderPathProp = property.FindPropertyRelative(
+                    nameof(SourceFolderEntry.folderPath)
+                );
+                SerializedProperty regexesProp = property.FindPropertyRelative(
+                    nameof(SourceFolderEntry.regexes)
+                );
+
+                Rect folderPathLabelRect = new(
+                    startX,
+                    currentY,
+                    availableWidth,
+                    EditorGUIUtility.singleLineHeight
+                );
+                EditorGUI.LabelField(folderPathLabelRect, "Folder Path", EditorStyles.boldLabel);
+                currentY += folderPathLabelRect.height + EditorGUIUtility.standardVerticalSpacing;
+
+                Rect pathFieldRect = new(
+                    startX,
+                    currentY,
+                    availableWidth - 75,
+                    EditorGUIUtility.singleLineHeight
+                );
+                Rect browseButtonRect = new(
+                    pathFieldRect.xMax + 5,
+                    currentY,
+                    70,
+                    EditorGUIUtility.singleLineHeight
+                );
+
+                EditorGUI.BeginChangeCheck();
+                string newPath = EditorGUI.TextField(
+                    pathFieldRect,
+                    new GUIContent("Path:"),
+                    folderPathProp.stringValue
+                );
+                if (EditorGUI.EndChangeCheck())
+                {
+                    folderPathProp.stringValue = newPath;
+                }
+
+                if (GUI.Button(browseButtonRect, "Browse..."))
+                {
+                    string initialBrowsePath = Application.dataPath;
+                    if (
+                        !string.IsNullOrWhiteSpace(folderPathProp.stringValue)
+                        && Directory.Exists(folderPathProp.stringValue)
+                    )
+                    {
+                        initialBrowsePath = folderPathProp.stringValue;
+                    }
+
+                    string selectedPathSys = EditorUtility.OpenFolderPanel(
+                        "Select Source Folder",
+                        initialBrowsePath,
+                        ""
+                    );
+                    if (!string.IsNullOrWhiteSpace(selectedPathSys))
+                    {
+                        string processedPath = selectedPathSys.SanitizePath();
+                        if (
+                            processedPath.StartsWith(
+                                Application.dataPath.SanitizePath(),
+                                StringComparison.Ordinal
+                            )
+                        )
+                        {
+                            processedPath =
+                                "Assets"
+                                + processedPath.Substring(
+                                    Application.dataPath.SanitizePath().Length
+                                );
+                        }
+                        folderPathProp.stringValue = processedPath;
+
+                        string toolName = "SpriteAtlasTool_Drawer";
+                        string contextKey =
+                            $"{property.serializedObject.targetObject.GetType().Name}_{folderPathProp.propertyPath}";
+                        PersistentDirectorySettings.Instance.RecordPath(
+                            toolName,
+                            contextKey,
+                            processedPath
+                        );
+                        property.serializedObject.ApplyModifiedProperties();
+                        GUI.FocusControl(null);
+                    }
+                }
+                currentY += pathFieldRect.height + EditorGUIUtility.standardVerticalSpacing;
+
+                string historyContextKey =
+                    $"{property.serializedObject.targetObject.GetType().Name}_{folderPathProp.propertyPath}";
+                DirectoryUsageData[] historyPaths = PersistentDirectorySettings.Instance.GetPaths(
+                    nameof(ScriptableSpriteAtlasEditor),
+                    historyContextKey,
+                    true,
+                    3
+                );
+                if (historyPaths.Any())
+                {
+                    Rect historyLabelRect = new(
+                        startX,
+                        currentY,
+                        availableWidth,
+                        EditorGUIUtility.singleLineHeight
+                    );
+                    EditorGUI.LabelField(historyLabelRect, "History:", EditorStyles.miniBoldLabel);
+                    currentY += historyLabelRect.height;
+
+                    foreach (DirectoryUsageData dirData in historyPaths)
+                    {
+                        Rect historyButtonRect = new(
+                            startX + 15f,
+                            currentY,
+                            availableWidth - 15f,
+                            EditorGUIUtility.singleLineHeight
+                        );
+                        if (
+                            GUI.Button(
+                                historyButtonRect,
+                                new GUIContent($"({dirData.count}) {dirData.path}", dirData.path),
+                                EditorStyles.miniButtonLeft
+                            )
+                        )
+                        {
+                            folderPathProp.stringValue = dirData.path;
+                            PersistentDirectorySettings.Instance.RecordPath(
+                                nameof(ScriptableSpriteAtlasEditor),
+                                historyContextKey,
+                                dirData.path
+                            );
+                            property.serializedObject.ApplyModifiedProperties();
+                            GUI.FocusControl(null);
+                        }
+                        currentY += historyButtonRect.height;
+                    }
+                    currentY += EditorGUIUtility.standardVerticalSpacing;
+                }
+
+                Rect regexFoldoutLabelRect = new(
+                    startX,
+                    currentY,
+                    availableWidth,
+                    EditorGUIUtility.singleLineHeight
+                );
+                string regexesFoldoutKey =
+                    property.serializedObject.targetObject.name
+                    + property.propertyPath
+                    + ".regexesList";
+                RegexesFoldoutState.TryAdd(regexesFoldoutKey, true);
+                RegexesFoldoutState[regexesFoldoutKey] = EditorGUI.Foldout(
+                    regexFoldoutLabelRect,
+                    RegexesFoldoutState[regexesFoldoutKey],
+                    "Regexes (AND logic)",
+                    true
+                );
+                currentY += regexFoldoutLabelRect.height + EditorGUIUtility.standardVerticalSpacing;
+                if (RegexesFoldoutState[regexesFoldoutKey])
+                {
+                    int listElementIndent = EditorGUI.indentLevel;
+                    EditorGUI.indentLevel++;
+                    Rect sizeFieldRect = new(
+                        startX,
+                        currentY,
+                        availableWidth,
+                        EditorGUIUtility.singleLineHeight
+                    );
+                    EditorGUI.BeginChangeCheck();
+                    int newSize = EditorGUI.IntField(sizeFieldRect, "Size", regexesProp.arraySize);
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        if (newSize < 0)
+                        {
+                            newSize = 0;
+                        }
+
+                        regexesProp.arraySize = newSize;
+                    }
+                    currentY += sizeFieldRect.height + EditorGUIUtility.standardVerticalSpacing;
+
+                    for (int i = 0; i < regexesProp.arraySize; i++)
+                    {
+                        SerializedProperty elementProp = regexesProp.GetArrayElementAtIndex(i);
+                        Rect elementRect = new(
+                            startX,
+                            currentY,
+                            availableWidth,
+                            EditorGUIUtility.singleLineHeight
+                        );
+                        EditorGUI.BeginChangeCheck();
+                        string newStringValue = EditorGUI.TextField(
+                            elementRect,
+                            $"Element {i}",
+                            elementProp.stringValue
+                        );
+                        if (EditorGUI.EndChangeCheck())
+                        {
+                            elementProp.stringValue = newStringValue;
+                        }
+                        currentY += elementRect.height + EditorGUIUtility.standardVerticalSpacing;
+                    }
+                    EditorGUI.indentLevel = listElementIndent;
+                }
+
+                EditorGUI.indentLevel = originalIndent;
+            }
+            EditorGUI.EndProperty();
+        }
+
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            float height = EditorGUIUtility.singleLineHeight;
+            if (!property.isExpanded)
+            {
+                return height;
+            }
+
+            height += EditorGUIUtility.standardVerticalSpacing;
+            height += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            height += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+
+            SerializedProperty folderPathProp = property.FindPropertyRelative(
+                nameof(SourceFolderEntry.folderPath)
+            );
+            string historyToolName = "SpriteAtlasTool_Drawer";
+            string historyContextKey =
+                $"{property.serializedObject.targetObject.GetType().Name}_{folderPathProp.propertyPath}";
+            DirectoryUsageData[] historyPaths = PersistentDirectorySettings.Instance.GetPaths(
+                historyToolName,
+                historyContextKey,
+                true,
+                3
+            );
+            if (historyPaths.Any())
+            {
+                height += EditorGUIUtility.singleLineHeight;
+                height += historyPaths.Length * EditorGUIUtility.singleLineHeight;
+                height += EditorGUIUtility.standardVerticalSpacing;
+            }
+
+            height += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+
+            string regexesFoldoutKey = property.propertyPath + ".regexesList";
+            bool isRegexesExpanded = RegexesFoldoutState.GetValueOrDefault(regexesFoldoutKey, true);
+
+            if (isRegexesExpanded)
+            {
+                SerializedProperty regexesProp = property.FindPropertyRelative(
+                    nameof(SourceFolderEntry.regexes)
+                );
+                height +=
+                    EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                for (int i = 0; i < regexesProp.arraySize; i++)
+                {
+                    height +=
+                        EditorGUIUtility.singleLineHeight
+                        + EditorGUIUtility.standardVerticalSpacing;
+                }
+            }
+            height += EditorGUIUtility.standardVerticalSpacing;
+            return height;
+        }
+    }
+#endif
+}

package/Editor/CustomEditors/SourceFolderEntryDrawer.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 30a7a4de43c24796aaabe10a9929fcdf
+timeCreated: 1746913161

package/Editor/FitTextureSizeWindow.cs

@@ -7,6 +7,7 @@
     using UnityEditor;
     using UnityEngine;
     using Core.Extension;
+    using CustomEditors;
     using Object = UnityEngine.Object;
 
     public enum FitMode
@@ -65,50 +66,10 @@
             _fitMode = (FitMode)EditorGUILayout.EnumPopup("Fit Mode", _fitMode);
 
             EditorGUILayout.Space();
-            EditorGUILayout.LabelField("Source Folders", EditorStyles.boldLabel);
-
-            if (GUILayout.Button("Add Source Directory"))
-            {
-                string path = EditorUtility.OpenFolderPanel(
-                    "Select Texture Source Directory",
-                    "Assets",
-                    ""
-                );
-                if (!string.IsNullOrWhiteSpace(path))
-                {
-                    if (path.StartsWith(Application.dataPath))
-                    {
-                        string relativePath =
-                            "Assets" + path.Substring(Application.dataPath.Length);
-                        Object folderObject = AssetDatabase.LoadAssetAtPath<Object>(relativePath);
-                        if (folderObject != null)
-                        {
-                            _textureSourcePaths ??= new List<Object>();
-                            if (!_textureSourcePaths.Contains(folderObject))
-                            {
-                                _textureSourcePaths.Add(folderObject);
-                                _potentialChangeCount = -1;
-                            }
-                            else
-                            {
-                                this.LogWarn($"Directory '{relativePath}' is already in the list.");
-                            }
-                        }
-                        else
-                        {
-                            this.LogError($"Could not load asset at path: '{relativePath}'");
-                        }
-                    }
-                    else
-                    {
-                        this.LogError(
-                            $"Selected path is outside the project's Assets folder: '{path}'"
-                        );
-                    }
-                }
-            }
-
-            EditorGUILayout.PropertyField(_textureSourcePathsProperty, true);
+            PersistentDirectoryGUI.PathSelectorObjectArray(
+                _textureSourcePathsProperty,
+                nameof(FitTextureSizeWindow)
+            );
             EditorGUILayout.Space();
             EditorGUILayout.LabelField("Actions", EditorStyles.boldLabel);
 

package/Editor/PersistentDirectorySettings.cs

@@ -0,0 +1,248 @@
+namespace WallstopStudios.UnityHelpers.Editor
+{
+#if UNITY_EDITOR
+    using System;
+    using UnityEngine;
+    using UnityEditor;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.IO;
+    using Core.Helper;
+    using UnityEngine.Serialization;
+
+    [Serializable]
+    public sealed class DirectoryUsageData
+    {
+        public string path;
+        public int count;
+        public long lastUsedTicks;
+
+        public DirectoryUsageData(string p)
+        {
+            path = p;
+            count = 0;
+            lastUsedTicks = DateTime.UtcNow.Ticks;
+        }
+
+        public void MarkUsed()
+        {
+            count++;
+            lastUsedTicks = DateTime.UtcNow.Ticks;
+        }
+    }
+
+    [Serializable]
+    public sealed class ContextHistory
+    {
+        public string contextKey;
+        public List<DirectoryUsageData> directories = new();
+
+        public ContextHistory() { }
+
+        public ContextHistory(string key)
+        {
+            contextKey = key;
+        }
+
+        public DirectoryUsageData GetOrAddDirectory(string path)
+        {
+            DirectoryUsageData dirData = directories.Find(directoryData =>
+                string.Equals(directoryData.path, path, StringComparison.Ordinal)
+            );
+            if (dirData != null)
+            {
+                return dirData;
+            }
+
+            dirData = new DirectoryUsageData(path);
+            directories.Add(dirData);
+            return dirData;
+        }
+    }
+
+    [Serializable]
+    public sealed class ToolHistory
+    {
+        public string toolName;
+        public List<ContextHistory> contexts = new();
+
+        public ToolHistory() { }
+
+        public ToolHistory(string name)
+        {
+            toolName = name;
+        }
+
+        public ContextHistory GetOrAddContext(string contextKey)
+        {
+            ContextHistory context = contexts.Find(c =>
+                string.Equals(c.contextKey, contextKey, StringComparison.Ordinal)
+            );
+            if (context != null)
+            {
+                return context;
+            }
+
+            context = new ContextHistory(contextKey);
+            contexts.Add(context);
+            return context;
+        }
+    }
+
+    public sealed class PersistentDirectorySettings : ScriptableObject
+    {
+        private const string DefaultAssetPath = "Assets/Editor/PersistentDirectorySettings.asset";
+
+        [FormerlySerializedAs("allToolHistories")]
+        [SerializeField]
+        private List<ToolHistory> _allToolHistories = new();
+
+        private static PersistentDirectorySettings _instance;
+
+        public static PersistentDirectorySettings Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    PersistentDirectorySettings[] settings = AssetDatabase
+                        .FindAssets($"t:{nameof(PersistentDirectorySettings)}")
+                        .Select(AssetDatabase.GUIDToAssetPath)
+                        .Select(AssetDatabase.LoadAssetAtPath<PersistentDirectorySettings>)
+                        .Where(Objects.NotNull)
+                        .ToArray();
+
+                    if (settings.Length > 0)
+                    {
+                        if (settings.Length > 1)
+                        {
+                            Debug.LogWarning(
+                                $"Multiple instances of {nameof(PersistentDirectorySettings)} found. Using the first one at: {AssetDatabase.GetAssetPath(settings[0])}. Please ensure only one instance exists for consistent behavior."
+                            );
+                        }
+
+                        _instance = settings[0];
+                    }
+                    else
+                    {
+                        if (_instance == null)
+                        {
+                            Debug.Log(
+                                $"No instance of {nameof(PersistentDirectorySettings)} found. Creating a new one at {DefaultAssetPath}."
+                            );
+                            _instance = CreateInstance<PersistentDirectorySettings>();
+
+                            string directoryPath = Path.GetDirectoryName(DefaultAssetPath);
+                            if (
+                                !string.IsNullOrWhiteSpace(directoryPath)
+                                && !Directory.Exists(directoryPath)
+                            )
+                            {
+                                Directory.CreateDirectory(directoryPath);
+                            }
+
+                            AssetDatabase.CreateAsset(_instance, DefaultAssetPath);
+                            AssetDatabase.SaveAssets();
+                            AssetDatabase.Refresh();
+                            EditorUtility.FocusProjectWindow();
+                            Selection.activeObject = _instance;
+                        }
+                    }
+                }
+
+                if (_instance == null)
+                {
+                    Debug.LogError(
+                        $"Failed to find or create {nameof(PersistentDirectorySettings)}. Directory persistence will not work."
+                    );
+                }
+
+                return _instance;
+            }
+        }
+
+        private ToolHistory GetOrAddToolHistory(string toolName)
+        {
+            ToolHistory toolHistory = _allToolHistories.Find(toolHistory =>
+                string.Equals(toolHistory.toolName, toolName, StringComparison.Ordinal)
+            );
+            if (toolHistory != null)
+            {
+                return toolHistory;
+            }
+
+            toolHistory = new ToolHistory(toolName);
+            _allToolHistories.Add(toolHistory);
+
+            return toolHistory;
+        }
+
+        public void RecordPath(string toolName, string contextKey, string path)
+        {
+            if (
+                string.IsNullOrWhiteSpace(toolName)
+                || string.IsNullOrWhiteSpace(contextKey)
+                || string.IsNullOrWhiteSpace(path)
+            )
+            {
+                Debug.LogWarning("RecordPath: toolName, contextKey, or path cannot be empty.");
+                return;
+            }
+
+            string sanitizedPath = path.SanitizePath();
+            if (
+                !sanitizedPath.StartsWith("Assets/", StringComparison.Ordinal)
+                || !AssetDatabase.IsValidFolder(sanitizedPath)
+            )
+            {
+                if (
+                    !Path.IsPathRooted(sanitizedPath)
+                    && !sanitizedPath.StartsWith("Assets/", StringComparison.Ordinal)
+                )
+                {
+                    Debug.LogWarning(
+                        $"Recording path '{sanitizedPath}' that is not an 'Assets/' relative path or an absolute path. This might be intentional."
+                    );
+                }
+            }
+
+            ToolHistory tool = GetOrAddToolHistory(toolName);
+            ContextHistory context = tool.GetOrAddContext(contextKey);
+            DirectoryUsageData dirData = context.GetOrAddDirectory(sanitizedPath);
+            dirData.MarkUsed();
+            EditorUtility.SetDirty(this);
+        }
+
+        public DirectoryUsageData[] GetPaths(
+            string toolName,
+            string contextKey,
+            bool topOnly = false,
+            int topN = 5
+        )
+        {
+            ToolHistory tool = _allToolHistories.Find(th =>
+                string.Equals(th.toolName, toolName, StringComparison.Ordinal)
+            );
+            if (tool == null)
+            {
+                return Array.Empty<DirectoryUsageData>();
+            }
+
+            ContextHistory context = tool.contexts.Find(c =>
+                string.Equals(c.contextKey, contextKey, StringComparison.Ordinal)
+            );
+            if (context == null)
+            {
+                return Array.Empty<DirectoryUsageData>();
+            }
+
+            DirectoryUsageData[] sortedDirectories = context
+                .directories.OrderByDescending(directoryData => directoryData.count)
+                .ThenByDescending(directoryData => directoryData.lastUsedTicks)
+                .ToArray();
+
+            return topOnly ? sortedDirectories.Take(topN).ToArray() : sortedDirectories;
+        }
+    }
+#endif
+}

package/Editor/PersistentDirectorySettings.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c86a641278ae47599e2061241a0a74f6
+timeCreated: 1746915782

package/Editor/PrefabChecker.cs

@@ -12,7 +12,6 @@
     using Core.Attributes;
     using Core.Extension;
     using Core.Helper;
-    using Utils;
     using WallstopStudios.UnityHelpers.Utils;
     using Object = UnityEngine.Object;
 
@@ -149,7 +148,7 @@
             GUI.enabled = wasEnabled && _checkNullObjectReferences;
             try
             {
-                using GUIIndentScope indent = new();
+                using EditorGUI.IndentLevelScope indent = new();
                 DrawAndAlign(
                     new GUIContent(
                         "Only if [ValidateAssignment]",