split runtime and editor

Editor/Attributes.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9bc24f38d5cb0f64ca274cd898f2f098
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Editor/Attributes/SerializeReferenceButtonAttributeDrawer.cs

@@ -0,0 +1,31 @@
+#if UNITY_EDITOR
+
+using UnityEditor; 
+using UnityEngine;
+
+[CustomPropertyDrawer(typeof(SerializeReferenceButtonAttribute))]
+public class SerializeReferenceButtonAttributeDrawer : PropertyDrawer
+{
+    public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+    {
+        return EditorGUI.GetPropertyHeight(property, true);
+    }
+ 
+    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+    {
+
+        
+        EditorGUI.BeginProperty(position, label, property); 
+        
+        var labelPosition = new Rect(position.x, position.y, position.width, EditorGUIUtility.singleLineHeight);
+        EditorGUI.LabelField(labelPosition, label);    
+         
+        var typeRestrictions = SerializedReferenceUIDefaultTypeRestrictions.GetAllBuiltInTypeRestrictions(fieldInfo);
+        property.DrawSelectionButtonForManagedReference(position, typeRestrictions);
+        
+        EditorGUI.PropertyField(position, property, GUIContent.none, true);
+        
+        EditorGUI.EndProperty(); 
+    } 
+}
+#endif

Editor/Attributes/SerializeReferenceButtonAttributeDrawer.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5a07638044724309b6088c28a11a15af
+timeCreated: 1579584059

Editor/Attributes/SerializeReferenceMenuAttributeDrawer.cs

@@ -0,0 +1,26 @@
+#if UNITY_EDITOR
+
+using UnityEditor;
+using UnityEngine;
+
+[CustomPropertyDrawer(typeof(SerializeReferenceMenuAttribute))]
+public class SerializeReferenceMenuAttributeDrawer : PropertyDrawer
+{
+    public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+    {
+        return EditorGUI.GetPropertyHeight(property, true);
+    }
+
+    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+    {
+        EditorGUI.BeginProperty(position, label, property);
+        
+        var typeRestrictions = SerializedReferenceUIDefaultTypeRestrictions.GetAllBuiltInTypeRestrictions(fieldInfo);
+        property.ShowContextMenuForManagedReferenceOnMouseMiddleButton(position, typeRestrictions);
+        
+        EditorGUI.PropertyField(position, property, true);
+        EditorGUI.EndProperty();
+    }
+}
+#endif
+

Editor/Attributes/SerializeReferenceMenuAttributeDrawer.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: eaa31b1c39ee9424abe12fa0034d9d1b
+timeCreated: 1579584059

Editor/Core.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1388bc43afa1f4e41ba1032dcee62b04
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Editor/Core/ManagedReferenceUtility.cs

@@ -0,0 +1,101 @@
+#if UNITY_EDITOR
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+public static class ManagedReferenceUtility
+{
+    /// Creates instance of passed type and assigns it to managed reference
+    public static object AssignNewInstanceOfTypeToManagedReference(this SerializedProperty serializedProperty, Type type)
+    {
+        var instance = Activator.CreateInstance(type);
+        
+        serializedProperty.serializedObject.Update(); 
+        serializedProperty.managedReferenceValue = instance;
+        serializedProperty.serializedObject.ApplyModifiedProperties(); 
+        
+        return instance;
+    }
+
+    /// Sets managed reference to null
+    public static void SetManagedReferenceToNull(this SerializedProperty serializedProperty)
+    {
+        serializedProperty.serializedObject.Update();
+        serializedProperty.managedReferenceValue = null;
+        serializedProperty.serializedObject.ApplyModifiedProperties(); 
+    }
+
+    /// Collects appropriate types based on managed reference field type and filters. Filters all derive
+    public static IEnumerable<Type> GetAppropriateTypesForAssigningToManagedReference(this SerializedProperty property, List<Func<Type, bool>> filters = null)
+    {
+        var fieldType = property.GetManagedReferenceFieldType();
+        return GetAppropriateTypesForAssigningToManagedReference(fieldType, filters);
+    }
+
+    /// Filters derived types of field typ parameter and finds ones whose are compatible with managed reference and filters.
+    public static IEnumerable<Type> GetAppropriateTypesForAssigningToManagedReference(Type fieldType, List<Func<Type, bool>> filters = null)
+    {
+        var appropriateTypes = new List<Type>();
+
+        // Get and filter all appropriate types
+        var derivedTypes = TypeCache.GetTypesDerivedFrom(fieldType);
+        foreach (var type in derivedTypes)
+        {
+            // Skips unity engine Objects (because they are not serialized by SerializeReference)
+            if (type.IsSubclassOf(typeof(Object)))
+                continue;
+            // Skip abstract classes because they should not be instantiated
+            if (type.IsAbstract)
+                continue;
+			// Skip generic classes because they can not be instantiated
+            if (type.ContainsGenericParameters)
+                continue;
+            // Skip types that has no public empty constructors (activator can not create them)    
+            if (type.IsClass && type.GetConstructor(Type.EmptyTypes) == null) // Structs still can be created (strangely)
+                continue;
+            // Filter types by provided filters if there is ones
+            if (filters != null && filters.All(f => f == null || f.Invoke(type)) == false) 
+                continue;
+
+            appropriateTypes.Add(type);
+        }
+
+        return appropriateTypes;
+    }
+    
+    /// Gets real type of managed reference
+    public static Type GetManagedReferenceFieldType(this SerializedProperty property)
+    {
+        var realPropertyType = GetRealTypeFromTypename(property.managedReferenceFieldTypename);
+        if (realPropertyType != null) 
+            return realPropertyType;
+        
+        Debug.LogError($"Can not get field type of managed reference : {property.managedReferenceFieldTypename}");
+        return null;
+    }
+    
+    /// Gets real type of managed reference's field typeName
+    public static Type GetRealTypeFromTypename(string stringType)
+    {
+        var names = GetSplitNamesFromTypename(stringType);
+        var realType = Type.GetType($"{names.ClassName}, {names.AssemblyName}");
+        return realType;
+    }
+    
+    /// Get assembly and class names from typeName
+    public static (string AssemblyName, string ClassName) GetSplitNamesFromTypename(string typename)
+    {
+        if (string.IsNullOrEmpty(typename))  
+            return ("","");
+        
+        var typeSplitString = typename.Split(char.Parse(" "));
+        var typeClassName = typeSplitString[1];
+        var typeAssemblyName = typeSplitString[0];
+        return (typeAssemblyName,  typeClassName); 
+    }
+}
+#endif

Editor/Core/ManagedReferenceUtility.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 07d7d3b6c96d5a04093953c060518522
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Editor/Core/SerializeReferenceGenericSelectionMenu.cs

@@ -0,0 +1,82 @@
+#if UNITY_EDITOR
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+ 
+public static class SerializeReferenceGenericSelectionMenu
+{
+    /// Purpose.
+    /// This is generic selection menu (will appear at position).
+    /// Filtering. 
+    /// You can add substring filter here to filter by search string.
+    /// As well ass type or interface restrictions.
+    /// As well as any custom restriction that is based on input type.
+    /// And it will be performed on each Appropriate type found by TypeCache.
+    public static void ShowContextMenuForManagedReference(this SerializedProperty property, Rect position, IEnumerable<Func<Type,bool>> filters = null)
+    { 
+        var context = new GenericMenu();
+        FillContextMenu(filters, context, property);
+        context.DropDown(position);
+    }
+
+    /// Purpose.
+    /// This is generic selection menu (will appear at click position).
+    /// Filtering. 
+    /// You can add substring filter here to filter by search string.
+    /// As well ass type or interface restrictions.
+    /// As well as any custom restriction that is based on input type.
+    /// And it will be performed on each Appropriate type found by TypeCache.
+    public static void ShowContextMenuForManagedReference(this SerializedProperty property, IEnumerable<Func<Type, bool>> filters = null)
+    {
+        var context = new GenericMenu();
+        FillContextMenu(filters, context, property);
+        context.ShowAsContext();
+    }
+    
+    private static void FillContextMenu(IEnumerable<Func<Type, bool>> enumerableFilters, GenericMenu contextMenu, SerializedProperty property)
+    {
+        var filters = enumerableFilters.ToList();// Prevents possible multiple enumerations
+        
+        // Adds "Make Null" menu command
+        contextMenu.AddItem(new GUIContent("Null"), false, property.SetManagedReferenceToNull);
+         
+        // Collects appropriate types
+        var appropriateTypes = property.GetAppropriateTypesForAssigningToManagedReference(filters);
+        
+        // Adds appropriate types to menu
+        foreach (var appropriateType in appropriateTypes)
+            AddItemToContextMenu(appropriateType, contextMenu, property); 
+    }
+    
+    private static void AddItemToContextMenu(Type type, GenericMenu genericMenuContext, SerializedProperty property)
+    {
+        var assemblyName =  type.Assembly.ToString().Split('(', ',')[0];
+        var entryName = type + "  ( " + assemblyName + " )";
+        genericMenuContext.AddItem(new GUIContent(entryName), false, AssignNewInstanceCommand, new GenericMenuParameterForAssignInstanceCommand(type, property));
+    }
+    
+    private static void AssignNewInstanceCommand(object objectGenericMenuParameter )
+    {
+        var parameter = (GenericMenuParameterForAssignInstanceCommand) objectGenericMenuParameter;
+        var type = parameter.Type;
+        var property = parameter.Property;
+        property.AssignNewInstanceOfTypeToManagedReference(type);
+    }
+
+    private readonly struct GenericMenuParameterForAssignInstanceCommand
+    {
+        public GenericMenuParameterForAssignInstanceCommand(Type type, SerializedProperty property)
+        {
+            Type = type;
+            Property = property;
+        }
+        
+        public readonly SerializedProperty Property;
+        public readonly Type Type;
+    }
+} 
+
+#endif

Editor/Core/SerializeReferenceGenericSelectionMenu.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d7796948b498be241ba10c88bcf3d5fe
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Editor/DefaultUI.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4a5d0da55302d3d418d5afe408a9a916
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Editor/DefaultUI/SerializeReferenceInspectorButton.cs

@@ -0,0 +1,38 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic; 
+using UnityEditor;
+using UnityEngine;
+
+public static class SerializeReferenceInspectorButton
+{
+    /// Must be drawn before DefaultProperty in order to receive input
+    public static void DrawSelectionButtonForManagedReference(this SerializedProperty property, Rect position, IEnumerable<Func<Type, bool>> filters = null)  
+    {
+        Rect buttonPosition = position;
+        buttonPosition.x += EditorGUIUtility.labelWidth + 1 * EditorGUIUtility.standardVerticalSpacing;
+        buttonPosition.width = position.width - EditorGUIUtility.labelWidth - 1 * EditorGUIUtility.standardVerticalSpacing;
+        buttonPosition.height = EditorGUIUtility.singleLineHeight;
+
+        Color storedColor = GUI.backgroundColor;
+        int storedIndent = EditorGUI.indentLevel;
+        EditorGUI.indentLevel = 0;
+
+        (string AssemblyName, string ClassName) = ManagedReferenceUtility.GetSplitNamesFromTypename(property.managedReferenceFullTypename);
+       
+        bool isNull = string.IsNullOrEmpty(ClassName);
+        GUI.backgroundColor = isNull ? Color.red : storedColor;
+        
+        string className = isNull ? "Null (Assign)" : ClassName;
+        string assemblyName = AssemblyName;
+
+        if (GUI.Button(buttonPosition, new GUIContent(className, className + "  ( "+ assemblyName +" )")))
+        {
+            property.ShowContextMenuForManagedReference(buttonPosition, filters);
+        }
+        
+        GUI.backgroundColor = storedColor;
+        EditorGUI.indentLevel = storedIndent;
+    }
+}
+#endif

Editor/DefaultUI/SerializeReferenceInspectorButton.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 50b013bc3b4409b438f8781dee4dbbf1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Editor/DefaultUI/SerializeReferenceInspectorMiddleMouseMenu.cs

@@ -0,0 +1,21 @@
+#if UNITY_EDITOR
+
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+public static class SerializeReferenceInspectorMiddleMouseMenu
+{
+    public static void ShowContextMenuForManagedReferenceOnMouseMiddleButton(this SerializedProperty property,
+        Rect position, IEnumerable<Func<Type, bool>> filters = null)
+    {
+        var e = Event.current;
+        if (e.type != EventType.MouseDown || !position.Contains(e.mousePosition) || e.button != 2) 
+            return;
+        
+        property.ShowContextMenuForManagedReference(filters);
+    } 
+}
+
+#endif

Editor/DefaultUI/SerializeReferenceInspectorMiddleMouseMenu.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ba51bcbc90077924abfcf504152b4a51
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Editor/Textus.SerializeReferenceUI.Editor.asmdef

@@ -0,0 +1,18 @@
+{
+    "name": "Textus.SerializeReferenceUI.Editor",
+    "rootNamespace": "Textus.SerializeReferenceUI.Editor",
+    "references": [
+        "GUID:73106583b323919458c1e05166706ce3"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Editor/Textus.SerializeReferenceUI.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 724728a2dc59e6542afdd88f2b4e569a
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: