Added support for runtimesets

Author: DanielEverland

Assets/SO Architecture/Editor/Inspectors/RuntimeSetEditor.cs

@@ -2,6 +2,7 @@
 using UnityEditor;
 using UnityEditorInternal;
 using UnityEngine;
+using Type = System.Type;
 
 [CustomEditor(typeof(BaseRuntimeSet), true)]
 public class RuntimeSetEditor : Editor
@@ -11,6 +12,8 @@ public class RuntimeSetEditor : Editor
 
     private ReorderableList _reorderableList;
 
+    private const bool DISABLE_ELEMENTS = false;
+
     private void OnEnable()
     {
         SerializedProperty items = serializedObject.FindProperty("_items");
@@ -40,8 +43,23 @@ private void DrawElement(Rect rect, int index, bool isActive, bool isFocused)
 
         SerializedProperty property = _reorderableList.serializedProperty.GetArrayElementAtIndex(index);
 
-        EditorGUI.BeginDisabledGroup(true);
-            EditorGUI.ObjectField(rect, "Element " + index, property.objectReferenceValue, Target.Type, false);
+        EditorGUI.BeginDisabledGroup(DISABLE_ELEMENTS);
+
+        EditorGUI.LabelField(rect, "Element " + index);
+
+        rect.width /= 2;
+        rect.x += rect.width;
+
+        if (SOArchitecture_EditorUtility.HasPropertyDrawer(Target.Type))
+        {
+            EditorGUI.PropertyField(rect, property, new GUIContent(""));
+        }
+        else
+        {
+            EditorGUI.LabelField(rect, "No PropertyDrawer");
+        }
+
+            //EditorGUI.ObjectField(rect, "Element " + index, property.objectReferenceValue, Target.Type, false);
         EditorGUI.EndDisabledGroup();
     }
     private void Remove(ReorderableList list)

Assets/SO Architecture/Editor/SOArchitecture_EditorUtility.cs

@@ -0,0 +1,111 @@
+using System.IO;
+using System.Reflection;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.Callbacks;
+using Type = System.Type;
+
+public static class SOArchitecture_EditorUtility
+{
+    static SOArchitecture_EditorUtility()
+    {
+        //We use this as a default since it'll be Assembly-CSharp-Editor
+        _defaultTargetType = typeof(SOArchitecture_EditorUtility).Assembly;
+    }
+
+    private static PropertyDrawerGraph _propertyDrawerGraph;
+    private static Regex _removeWhiteSpace = new Regex(@"\s+");
+    private static Assembly _defaultTargetType;
+    private static BindingFlags _fieldBindingsFlag = BindingFlags.Instance | BindingFlags.NonPublic;
+
+    public static bool HasPropertyDrawer(Type type)
+    {
+        return HasPropertyDrawer(type, _defaultTargetType);
+    }
+    public static bool HasPropertyDrawer(Type type, Assembly assembly)
+    {
+        if (HasBuiltinPropertyDrawer(type))
+            return true;
+
+        if (_propertyDrawerGraph == null)
+            _propertyDrawerGraph = new PropertyDrawerGraph();
+
+        _propertyDrawerGraph.CreateGraph(assembly);
+
+        return _propertyDrawerGraph.HasPropertyDrawer(type);
+    }
+    private static bool HasBuiltinPropertyDrawer(Type type)
+    {
+        if (type.IsPrimitive || type == typeof(string) || typeof(Object).IsAssignableFrom(type))
+            return true;
+
+        return false;
+    }
+    [DidReloadScripts]
+    private static void OnProjectReloaded()
+    {
+        _propertyDrawerGraph = null;
+    }
+
+    /// <summary>
+    /// Goes through the entirety of the project and collects data about custom property drawers
+    /// </summary>
+    private class PropertyDrawerGraph
+    {
+        private List<Type> _supportedTypes = new List<Type>();
+        private List<Type> _supportedInheritedTypes = new List<Type>();
+        private List<Assembly> _checkedAssemblies = new List<Assembly>();
+
+        public bool HasPropertyDrawer(Type type)
+        {
+            foreach (Type supportedType in _supportedTypes)
+            {
+                if (supportedType == type)
+                    return true;
+            }
+
+            foreach (Type inheritedSupportedType in _supportedInheritedTypes)
+            {
+                if (type.IsSubclassOf(inheritedSupportedType))
+                    return true;
+            }
+
+            return false;
+        }
+        public void CreateGraph(Assembly assembly)
+        {
+            if (_checkedAssemblies.Contains(assembly))
+                return;
+
+            _checkedAssemblies.Add(assembly);
+            
+            foreach (Type type in assembly.GetTypes())
+            {
+                object[] attributes = type.GetCustomAttributes(typeof(CustomPropertyDrawer), false);
+
+                foreach (object attribute in attributes)
+                {
+                    if(attribute is CustomPropertyDrawer)
+                    {
+                        CustomPropertyDrawer drawerData = attribute as CustomPropertyDrawer;
+                        
+                        bool useForChildren = (bool)typeof(CustomPropertyDrawer).GetField("m_UseForChildren", _fieldBindingsFlag).GetValue(drawerData);
+                        Type targetType = (Type)typeof(CustomPropertyDrawer).GetField("m_Type", _fieldBindingsFlag).GetValue(drawerData);
+
+                        if (useForChildren)
+                        {
+                            _supportedInheritedTypes.Add(targetType);
+                        }
+                        else
+                        {
+                            _supportedTypes.Add(targetType);
+                        }
+                    }
+                }
+            }            
+        }
+    }
+}