1.8.4: Added PopupFromScriptableObjectType

Editor/AssetImporters.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: adea2f219bc34c5690f613740e7f0ee7
+timeCreated: 1702156747

Editor/AssetImporters/EditorAssetImporterForScriptableObject.cs

@@ -0,0 +1,30 @@
+using UnityEditor;
+
+namespace Module.Inspector.Editor.AssetImporters
+{
+    internal sealed class EditorAssetImporterForScriptableObject : AssetPostprocessor
+    {
+        public static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
+        {
+            if (HasAnyScriptableObjects(importedAssets) || 
+                HasAnyScriptableObjects(deletedAssets) || 
+                HasAnyScriptableObjects(movedAssets))
+            {
+                EditorUtilitySearchObject.Clear();
+            }
+        }
+
+        private static bool HasAnyScriptableObjects(string[] paths)
+        {
+            for (var i = 0; i < paths.Length; i++)
+            {
+                string path = paths[i];
+
+                if (path.EndsWith(".asset"))
+                    return true;
+            }
+
+            return false;
+        }
+    }
+}

Editor/AssetImporters/EditorAssetImporterForScriptableObject.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a1d618b9d79641b79e5815e258baeecb
+timeCreated: 1702156766

Editor/Drawers/PopupFromScriptableObjectTypeAttributeDrawer.cs

@@ -0,0 +1,57 @@
+using System;
+using Module.Inspector.Editor.Utilities;
+using UnityEditor;
+using UnityEngine;
+
+namespace Module.Inspector.Editor
+{
+    [CustomPropertyDrawer(typeof(PopupFromScriptableObjectTypeAttribute))]
+    internal sealed class PopupFromScriptableObjectTypeAttributeDrawer : DrawerPropertyDrawer
+    {
+        private static readonly Type ASSIGNABLE_FROM_TYPE = typeof(ScriptableObject);
+        
+        public override bool Draw(Rect position, DrawerPropertyAttribute attribute, SerializedProperty property, GUIContent label, EditorPropertyUtility.Result result)
+        {
+            if (property.propertyType != SerializedPropertyType.ObjectReference)
+                return false;
+
+            var att = (PopupFromScriptableObjectTypeAttribute)attribute;
+            Type targetType = att.type != null ? att.type : property.GetValueType();
+            
+            if (targetType != null && !ASSIGNABLE_FROM_TYPE.IsAssignableFrom(targetType))
+                return false;
+            
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.BeginProperty(position, label, property);
+            {
+                const float BUTTON_WIDTH = 20f;
+                const float BUTTON_PADDING = 3f;
+                
+                var rect0 = new Rect(position.x, position.y, position.width - BUTTON_WIDTH, position.height);
+                var rect1 = new Rect(rect0.xMax + BUTTON_PADDING, rect0.y + 1, BUTTON_WIDTH - BUTTON_PADDING, rect0.height - 3);
+                
+                EditorUtilitySearchObject.SearchObject searchObject = EditorUtilitySearchObject.SearchAndCache(targetType);
+                int index = searchObject.assets.IndexOf(property.objectReferenceValue) + 1;
+                int newIndex = EditorGUI.Popup(rect0, label, index, searchObject.names);
+
+                if (newIndex != -1 && index != newIndex)
+                    property.objectReferenceValue = newIndex > 0 ? searchObject.assets[newIndex - 1] : null;
+                
+                if (GUI.Button(rect1, EditorIcons.GetScriptableObjectIconContent(), GUIStyle.none) && property.objectReferenceValue != null)
+                    EditorGUIUtility.PingObject(property.objectReferenceValue);
+            }
+            EditorGUI.EndProperty();
+            bool changed = EditorGUI.EndChangeCheck();
+
+            if (changed)
+                property.serializedObject.ApplyModifiedProperties();
+            
+            return true;
+        }
+        
+        public override string GetErrorMessage(SerializedProperty property)
+        {
+            return "Only supports Scriptable Object types";
+        }
+    }
+}

Editor/Drawers/PopupFromScriptableObjectTypeAttributeDrawer.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7ff046961af547fa913d5febb8176b31
+timeCreated: 1702147997

Editor/Utilities/EditorIcons.cs

@@ -7,6 +7,7 @@ namespace Module.Inspector.Editor.Utilities
     {
         private static GUIContent CONTENT_WARNING;
         private static GUIContent CONTENT_ERROR;
+        private static GUIContent CONTENT_OBJECT;
 
         private static GUIContent GetWarningIconContent()
         {
@@ -23,6 +24,14 @@ namespace Module.Inspector.Editor.Utilities
             
             return CONTENT_ERROR;
         }
+        
+        public static GUIContent GetScriptableObjectIconContent()
+        {
+            if (CONTENT_ERROR == null)
+                CONTENT_ERROR = EditorGUIUtility.IconContent("d_ScriptableObject Icon");
+            
+            return CONTENT_ERROR;
+        }
 
         public static void SetWarningIcon(GUIContent content)
         {

Editor/Utilities/EditorUtilitySearchObject.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace Module.Inspector.Editor
+{
+    internal static class EditorUtilitySearchObject
+    {
+        private static readonly Dictionary<Type, SearchObject> TYPE_TO_ASSETS = new();
+        
+        public static SearchObject SearchAndCache(Type type)
+        {
+            if (TYPE_TO_ASSETS.TryGetValue(type, out SearchObject searchObject))
+                return searchObject;
+            
+            string[] guids = AssetDatabase.FindAssets($"t:{type.Name}");
+            searchObject = new();
+
+            for (var i = 0; i < guids.Length; i++)
+            {
+                string path = AssetDatabase.GUIDToAssetPath(guids[i]);
+                Object asset = AssetDatabase.LoadAssetAtPath(path, type);
+                
+                if (asset != null)
+                    searchObject.assets.Add(asset);
+            }
+            
+            searchObject.CreateNamesFromAssets();
+            TYPE_TO_ASSETS.Add(type, searchObject);
+            return searchObject;
+        }
+
+        public static void Clear()
+        {
+            TYPE_TO_ASSETS.Clear();
+        }
+        
+        public sealed class SearchObject
+        {
+            public readonly List<Object> assets = new();
+            public GUIContent[] names;
+            
+            public void CreateNamesFromAssets()
+            {
+                assets.Sort((a0, a1) => string.Compare(a0.name, a1.name, StringComparison.Ordinal));
+                
+                names = new GUIContent[assets.Count + 1];
+                names[0] = new GUIContent("None");
+
+                for (var i = 0; i < assets.Count; i++)
+                {
+                    names[i + 1] = new GUIContent(assets[i].name);
+                }
+            }
+        }
+    }
+}

Editor/Utilities/EditorUtilitySearchObject.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8083be0f988541b294da46beca2224d9
+timeCreated: 1702156783