Merge remote-tracking branch 'upstream/main' into #22-Fix-DragAndDrop-ReferenceDrawer

marc-antoine-girard · marc-antoine-girard · commit 38f79b8649ad · 2022-07-22T12:12:35.000-04:00
diff --git a/.editorconfig b/.editorconfig
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           token: ${{ secrets.GH_TOKEN }}
       - name: Setup Node.js
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,3 +1,17 @@
+### [1.7.3](https://github.com/Thundernerd/Unity3D-SerializableInterface/compare/v1.7.2...v1.7.3) (2022-07-22)
+
+
+### Refactors
+
+* property drawer now reuses cached reference drawers ([f930d8e](https://github.com/Thundernerd/Unity3D-SerializableInterface/commit/f930d8ed92b8358e417d075f9a089f7161cadc50))
+
+### [1.7.2](https://github.com/Thundernerd/Unity3D-SerializableInterface/compare/v1.7.1...v1.7.2) (2022-07-22)
+
+
+### Bug Fixes
+
+* updated actions/checkout to version 3 ([ef748e1](https://github.com/Thundernerd/Unity3D-SerializableInterface/commit/ef748e176b864cd3dfc00f3b96e9cedb8783055d))
+
 ### [1.7.1](https://github.com/Thundernerd/Unity3D-SerializableInterface/compare/v1.7.0...v1.7.1) (2022-06-18)
 
 
diff --git a/Editor/Drawers/RawReferenceDrawer.cs b/Editor/Drawers/RawReferenceDrawer.cs
@@ -8,8 +8,11 @@ namespace TNRD.Drawers
 {
     internal class RawReferenceDrawer : ReferenceDrawer, IReferenceDrawer
     {
-        private readonly GUIContent label;
-        private readonly FieldInfo fieldInfo;
+        private GUIContent label;
+        private FieldInfo fieldInfo;
+
+        private object previousReferenceValue;
+        private string previousPropertyPath;
 
         private object RawReferenceValue
         {
@@ -21,14 +24,22 @@ private object RawReferenceValue
                 ISerializableInterface instance =
                     (ISerializableInterface)fieldInfo.GetValue(Property.serializedObject.targetObject);
                 return instance.GetRawReference();
+#endif
+            }
+
+            set
+            {
+#if UNITY_2021_1_OR_NEWER
+                RawReferenceProperty.managedReferenceValue = value;
+#else
+                fieldInfo.SetValue(Property.serializedObject.targetObject, value);
 #endif
             }
         }
 
-        /// <inheritdoc />
-        public RawReferenceDrawer(SerializedProperty property, GUIContent label, Type genericType, FieldInfo fieldInfo)
-            : base(property, genericType)
+        public void Initialize(SerializedProperty property, Type genericType, GUIContent label, FieldInfo fieldInfo)
         {
+            Initialize(property, genericType);
             this.label = label;
             this.fieldInfo = fieldInfo;
         }
@@ -47,6 +58,8 @@ public float GetHeight()
         /// <inheritdoc />
         public void OnGUI(Rect position)
         {
+            AvoidDuplicateReferencesInArray();
+
             Rect objectFieldRect = new Rect(position)
             {
                 height = EditorGUIUtility.singleLineHeight
@@ -72,6 +85,8 @@ public void OnGUI(Rect position)
                 RawReferenceProperty,
                 new GUIContent(rawReferenceValue.GetType().Name),
                 true);
+
+            previousPropertyPath = Property.propertyPath;
         }
 
         /// <inheritdoc />
@@ -92,5 +107,41 @@ protected override void OnPropertiesClicked()
                 }
             }
         }
+
+        private void AvoidDuplicateReferencesInArray()
+        {
+            if (!IsPropertyInArray(Property)) 
+                return;
+            if (previousPropertyPath == null) 
+                return;
+            if (previousPropertyPath == Property.propertyPath) 
+                return;
+
+            SerializedProperty rawReferenceProperty = Property.FindPropertyRelative("rawReference");
+            object currentReferenceValue = RawReferenceValue;
+
+            if (currentReferenceValue == null) 
+                return;
+
+            if (previousReferenceValue == currentReferenceValue)
+            {
+                RawReferenceValue = CreateInstance(currentReferenceValue);
+                rawReferenceProperty.serializedObject.ApplyModifiedProperties();
+            }
+
+            previousReferenceValue = currentReferenceValue;
+        }
+
+        private static bool IsPropertyInArray(SerializedProperty prop)
+        {
+            return prop.propertyPath.Contains(".Array.data[");
+        }
+
+        private static object CreateInstance(object source)
+        {
+            object instance = Activator.CreateInstance(source.GetType());
+            EditorUtility.CopySerializedManagedFieldsOnly(source, instance);
+            return instance;
+        }
     }
 }
diff --git a/Editor/Drawers/ReferenceDrawer.cs b/Editor/Drawers/ReferenceDrawer.cs
@@ -21,26 +21,30 @@ private enum DragAndDropMode
 
         private DragAndDropMode dragAndDropMode;
 
-        protected readonly SerializedProperty Property;
-        protected readonly Type GenericType;
         protected readonly CustomObjectDrawer CustomObjectDrawer;
 
+        protected SerializedProperty Property { get; private set; }
+        protected Type GenericType { get; private set; }
+
         protected SerializedProperty ReferenceModeProperty => Property.FindPropertyRelative("mode");
         protected SerializedProperty RawReferenceProperty => Property.FindPropertyRelative("rawReference");
         protected SerializedProperty UnityReferenceProperty => Property.FindPropertyRelative("unityReference");
 
-        protected ReferenceDrawer(SerializedProperty property, Type genericType)
+        protected ReferenceDrawer()
         {
-            Property = property;
-            GenericType = genericType;
-
             CustomObjectDrawer = new CustomObjectDrawer();
             CustomObjectDrawer.ButtonClicked += OnButtonClicked;
             CustomObjectDrawer.Clicked += OnClicked;
             CustomObjectDrawer.DeletePressed += OnDeletePressed;
             CustomObjectDrawer.PropertiesClicked += OnPropertiesClicked;
         }
 
+        protected void Initialize(SerializedProperty property, Type genericType)
+        {
+            Property = property;
+            GenericType = genericType;
+        }
+
         private void OnButtonClicked(Rect position)
         {
             AdvancedDropdownState state = new AdvancedDropdownState();
diff --git a/Editor/Drawers/UnityReferenceDrawer.cs b/Editor/Drawers/UnityReferenceDrawer.cs
@@ -8,11 +8,11 @@ namespace TNRD.Drawers
 {
     internal class UnityReferenceDrawer : ReferenceDrawer, IReferenceDrawer
     {
-        private readonly GUIContent label;
+        private GUIContent label;
 
-        public UnityReferenceDrawer(SerializedProperty property, GUIContent label, Type genericType)
-            : base(property, genericType)
+        public void Initialize(SerializedProperty property, Type genericType, GUIContent label)
         {
+            Initialize(property, genericType);
             this.label = label;
         }
 
diff --git a/Editor/SerializableInterfacePropertyDrawer.cs b/Editor/SerializableInterfacePropertyDrawer.cs
@@ -10,23 +10,20 @@ namespace TNRD
     [CustomPropertyDrawer(typeof(SerializableInterface<>), true)]
     internal sealed class SerializableInterfacePropertyDrawer : PropertyDrawer
     {
+        private readonly RawReferenceDrawer rawReferenceDrawer = new RawReferenceDrawer();
+        private readonly UnityReferenceDrawer unityReferenceDrawer = new UnityReferenceDrawer();
+
         private SerializedProperty serializedProperty;
         private Type genericType;
 
-        private IReferenceDrawer activeDrawer;
-
         /// <inheritdoc />
-        public override bool CanCacheInspectorGUI(SerializedProperty property)
-        {
-            return false;
-        }
+        public override bool CanCacheInspectorGUI(SerializedProperty property) => false;
 
         private void Initialize(SerializedProperty property)
         {
             if (serializedProperty == property)
                 return;
 
-            activeDrawer = null;
             serializedProperty = property;
             genericType = GetGenericArgument();
             Assert.IsNotNull(genericType, "Unable to find generic argument, are you doing some shady inheritance?");
@@ -36,16 +33,14 @@ private void Initialize(SerializedProperty property)
         public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
         {
             Initialize(property);
-            activeDrawer = GetReferenceDrawer(activeDrawer, property, label);
-            return activeDrawer.GetHeight();
+            return GetReferenceDrawer(property, label).GetHeight();
         }
 
         /// <inheritdoc />
         public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
         {
             Initialize(property);
-            activeDrawer = GetReferenceDrawer(activeDrawer, property, label);
-            activeDrawer.OnGUI(position);
+            GetReferenceDrawer(property, label).OnGUI(position);
         }
 
         private Type GetGenericArgument()
@@ -84,25 +79,19 @@ private Type GetGenericArgument()
             return null;
         }
 
-        private IReferenceDrawer GetReferenceDrawer(
-            IReferenceDrawer original,
-            SerializedProperty property,
-            GUIContent label
-        )
+        private IReferenceDrawer GetReferenceDrawer(SerializedProperty property, GUIContent label)
         {
             SerializedProperty modeProperty = serializedProperty.FindPropertyRelative("mode");
             ReferenceMode referenceMode = (ReferenceMode)modeProperty.enumValueIndex;
 
             switch (referenceMode)
             {
                 case ReferenceMode.Raw:
-                    return original is RawReferenceDrawer
-                        ? original
-                        : new RawReferenceDrawer(property, label, genericType, fieldInfo);
+                    rawReferenceDrawer.Initialize(property, genericType, label, fieldInfo);
+                    return rawReferenceDrawer;
                 case ReferenceMode.Unity:
-                    return original is UnityReferenceDrawer
-                        ? original
-                        : new UnityReferenceDrawer(property, label, genericType);
+                    unityReferenceDrawer.Initialize(property, genericType, label);
+                    return unityReferenceDrawer;
                 default:
                     throw new ArgumentOutOfRangeException();
             }
diff --git a/Runtime/SerializableInterface.cs b/Runtime/SerializableInterface.cs
@@ -9,7 +9,7 @@ namespace TNRD
     /// </summary>
     /// <typeparam name="TInterface">The type of the interface you want to serialize</typeparam>
     [Serializable]
-    public class SerializableInterface<TInterface> : ISerializableInterface
+    public class SerializableInterface<TInterface> : ISerializableInterface where TInterface : class
     {
         [HideInInspector, SerializeField] private ReferenceMode mode = ReferenceMode.Unity;
         [HideInInspector, SerializeField] private UnityEngine.Object unityReference;
@@ -21,8 +21,8 @@ public TInterface Value
             {
                 return mode switch
                 {
-                    ReferenceMode.Raw => (TInterface)rawReference,
-                    ReferenceMode.Unity => (TInterface)(object)unityReference,
+                    ReferenceMode.Raw => rawReference as TInterface,
+                    ReferenceMode.Unity => (object)unityReference as TInterface,
                     _ => throw new ArgumentOutOfRangeException()
                 };
             }
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "net.tnrd.serializableinterface",
-  "version": "1.7.1",
+  "version": "1.7.3",
   "displayName": "Serializable Interface",
   "unity": "2020.1",
   "description": "A wrapper that allows serialization of interfaces that supports both UnityEngine.Object and regular object types",
@@ -28,7 +28,7 @@
     "@semantic-release/changelog": "^6.0.1",
     "@semantic-release/commit-analyzer": "^9.0.2",
     "@semantic-release/git": "^10.0.1",
-    "@semantic-release/github": "^8.0.4",
+    "@semantic-release/github": "^8.0.5",
     "@semantic-release/npm": "^9.0.1",
     "@semantic-release/release-notes-generator": "^10.0.3",
     "conventional-changelog-conventionalcommits": "^4.6.3",

Original file line number	Diff line number	Diff line change
`@@ -8,11 +8,11 @@ namespace TNRD.Drawers`
`8`	`8`	`{`
`9`	`9`	`internal class UnityReferenceDrawer : ReferenceDrawer, IReferenceDrawer`
`10`	`10`	`{`
`11`		`- private readonly GUIContent label;`
	`11`	`+ private GUIContent label;`
`12`	`12`
`13`		`- public UnityReferenceDrawer(SerializedProperty property, GUIContent label, Type genericType)`
`14`		`- : base(property, genericType)`
	`13`	`+ public void Initialize(SerializedProperty property, Type genericType, GUIContent label)`
`15`	`14`	`{`
	`15`	`+ Initialize(property, genericType);`
`16`	`16`	`this.label = label;`
`17`	`17`	`}`
`18`	`18`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ namespace TNRD`
`9`	`9`	`/// </summary>`
`10`	`10`	`/// <typeparam name="TInterface">The type of the interface you want to serialize</typeparam>`
`11`	`11`	`[Serializable]`
`12`		`- public class SerializableInterface<TInterface> : ISerializableInterface`
	`12`	`+ public class SerializableInterface<TInterface> : ISerializableInterface where TInterface : class`
`13`	`13`	`{`
`14`	`14`	`[HideInInspector, SerializeField] private ReferenceMode mode = ReferenceMode.Unity;`
`15`	`15`	`[HideInInspector, SerializeField] private UnityEngine.Object unityReference;`
`@@ -21,8 +21,8 @@ public TInterface Value`
`21`	`21`	`{`
`22`	`22`	`return mode switch`
`23`	`23`	`{`
`24`		`- ReferenceMode.Raw => (TInterface)rawReference,`
`25`		`- ReferenceMode.Unity => (TInterface)(object)unityReference,`
	`24`	`+ ReferenceMode.Raw => rawReference as TInterface,`
	`25`	`+ ReferenceMode.Unity => (object)unityReference as TInterface,`
`26`	`26`	`_ => throw new ArgumentOutOfRangeException()`
`27`	`27`	`};`
`28`	`28`	`}`