Merge branch 'feature/scriptable-objects-creation-tool' into bugfix/fix-serialized-scene-serialization

arimger · arimger · commit 0386bd352d24 · 2022-10-19T22:03:23.000+02:00
diff --git a/Assets/Editor Toolbox/Editor/Drawers/Toolbox/PropertySelf/ReferencePickerAttributeDrawer.cs b/Assets/Editor Toolbox/Editor/Drawers/Toolbox/PropertySelf/ReferencePickerAttributeDrawer.cs
@@ -24,20 +24,21 @@ private void UpdateContexts(ReferencePickerAttribute attribute)
 
         private Type GetParentType(SerializedProperty property, ReferencePickerAttribute attribute)
         {
-            property.GetFieldInfo(out Type propertyType);
+            var fieldInfo = property.GetFieldInfo(out _);
+            var fieldType = property.GetProperType(fieldInfo);
             var candidateType = attribute.ParentType;
             if (candidateType != null)
             {
-                if (propertyType.IsAssignableFrom(candidateType))
+                if (fieldType.IsAssignableFrom(candidateType))
                 {
                     return candidateType;
                 }
 
                 ToolboxEditorLog.AttributeUsageWarning(attribute, property,
-                    $"Provided {nameof(attribute.ParentType)} ({candidateType}) cannot be used because it's not assignable from: '{propertyType}'");
+                    $"Provided {nameof(attribute.ParentType)} ({candidateType}) cannot be used because it's not assignable from: '{fieldType}'");
             }
 
-            return propertyType;
+            return fieldType;
         }
 
         private void CreateTypeProperty(Rect position, SerializedProperty property, Type parentType)
diff --git a/Assets/Editor Toolbox/Editor/Internal/PropertyScope.cs b/Assets/Editor Toolbox/Editor/Internal/PropertyScope.cs
@@ -36,17 +36,19 @@ private void TryDrawLabel(Rect rect, GUIContent label)
             InputRect = rect;
             var size = EditorStyles.label.CalcSize(label);
             rect.xMax = rect.xMin + size.x;
+            rect.xMax += EditorGuiUtility.IndentSize;
+            rect.xMax += EditorGuiUtility.SpacingSize;
             LabelRect = rect;
             if (property.hasVisibleChildren)
             {
                 var labelRect = LabelRect;
-                labelRect.xMax += EditorGuiUtility.FoldoutOffset;
+                labelRect.xMax += EditorGuiUtility.FoldoutSize;
                 LabelRect = labelRect;
                 property.isExpanded = EditorGUI.Foldout(labelRect, property.isExpanded, label, true);
             }
             else
             {
-                EditorGUI.LabelField(rect, label);
+                EditorGUI.LabelField(LabelRect, label);
             }
         }
 
diff --git a/Assets/Editor Toolbox/Editor/ToolboxPropertyHandler.cs b/Assets/Editor Toolbox/Editor/ToolboxPropertyHandler.cs
@@ -286,11 +286,11 @@ private void DrawProperty(SerializedProperty property, GUIContent label)
                     //draw target property using the associated type drawer
                     ToolboxDrawerModule.GetTargetTypeDrawer(type)?.OnGui(property, label);
                 }
+
+                return;
             }
-            else
-            {
-                OnGuiDefault(property, label);
-            }
+
+            OnGuiDefault(property, label);
         }
 
         private void BeginDecoratorDrawers(PropertyCondition conditionState = PropertyCondition.Valid)
diff --git a/Assets/Editor Toolbox/Editor/Utilities/EditorGuiUtility.cs b/Assets/Editor Toolbox/Editor/Utilities/EditorGuiUtility.cs
@@ -12,6 +12,8 @@ namespace Toolbox.Editor
     /// </summary>
     internal static class EditorGuiUtility
     {
+        private const float indentPerLevel = 15.0f;
+
         private static readonly Dictionary<string, Texture2D> loadedTextures = new Dictionary<string, Texture2D>();
 
 
@@ -99,6 +101,9 @@ public static Texture GetHelpIcon(MessageType messageType)
         }
 
 
-        public static float FoldoutOffset { get; internal set; } = 28.0f;
+        public static float FoldoutSize { get; internal set; } = 15.0f;
+        public static float SpacingSize => EditorGUIUtility.standardVerticalSpacing;
+        public static float HeightSize => EditorGUIUtility.singleLineHeight;
+        public static float IndentSize => EditorGUI.indentLevel * indentPerLevel;
     }
 }
diff --git a/Assets/Editor Toolbox/Editor/Utilities/PropertyUtility.cs b/Assets/Editor Toolbox/Editor/Utilities/PropertyUtility.cs
@@ -10,6 +10,12 @@ namespace Toolbox.Editor
 {
     public static partial class PropertyUtility
     {
+        //NOTE: last non-reflection implementation was ok but support for [SerializeReference] makes it a bit slow
+        // unfortunately UnityEditor.ScriptAttributeUtility.GetFieldInfoFromProperty is internal so we have to retrive it using reflection
+        private static readonly MethodInfo getGetFieldInfoFromPropertyMethod =
+            ReflectionUtility.GetEditorMethod("UnityEditor.ScriptAttributeUtility", "GetFieldInfoFromProperty",
+                BindingFlags.NonPublic | BindingFlags.Static);
+
         /// <summary>
         /// Indicates if the property has all changes applied and can be safely used for reflection-based features.
         /// </summary>
@@ -249,22 +255,20 @@ public static Type GetScriptTypeFromProperty(SerializedProperty property)
             return scriptInstance.GetClass();
         }
 
-
         public static FieldInfo GetFieldInfo(this SerializedProperty property)
         {
             return GetFieldInfo(property, out _);
         }
 
         public static FieldInfo GetFieldInfo(this SerializedProperty property, out Type propertyType)
         {
-            return GetFieldInfoFromProperty(property, out propertyType);
-        }
-
-        public static FieldInfo GetFieldInfo(this SerializedProperty property, out Type propertyType, Object target)
-        {
-            return GetFieldInfoFromProperty(property, out propertyType, target.GetType());
+            var parameters = new object[] { property, null };
+            var result = getGetFieldInfoFromPropertyMethod.Invoke(null, parameters) as FieldInfo;
+            propertyType = parameters[1] as Type;
+            return result;
         }
 
+        [Obsolete("This method is no longer safe, use GetFieldInfo() instead.")]
         public static FieldInfo GetFieldInfoFromProperty(SerializedProperty property, out Type type)
         {
             var classType = GetScriptTypeFromProperty(property);
@@ -277,8 +281,11 @@ public static FieldInfo GetFieldInfoFromProperty(SerializedProperty property, ou
             return GetFieldInfoFromProperty(property, out type, classType);
         }
 
+        [Obsolete("This method is no longer safe, use GetFieldInfo() instead.")]
         public static FieldInfo GetFieldInfoFromProperty(SerializedProperty property, out Type type, Type host)
         {
+            const BindingFlags fieldFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
+
             FieldInfo field = null;
             type = host;
 
@@ -297,7 +304,6 @@ public static FieldInfo GetFieldInfoFromProperty(SerializedProperty property, ou
                     continue;
                 }
 
-                const BindingFlags fieldFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
                 FieldInfo foundField = null;
                 for (var currentType = type; foundField == null && currentType != null; currentType = currentType.BaseType)
                 {
@@ -383,7 +389,7 @@ public static SerializedProperty GetSize(this SerializedProperty array)
 
         public static T GetAttribute<T>(SerializedProperty property) where T : Attribute
         {
-            return GetAttribute<T>(property, GetFieldInfoFromProperty(property, out _));
+            return GetAttribute<T>(property, GetFieldInfo(property, out _));
         }
 
         public static T GetAttribute<T>(SerializedProperty property, FieldInfo fieldInfo) where T : Attribute
@@ -393,7 +399,7 @@ public static T GetAttribute<T>(SerializedProperty property, FieldInfo fieldInfo
 
         public static T[] GetAttributes<T>(SerializedProperty property) where T : Attribute
         {
-            return GetAttributes<T>(property, GetFieldInfoFromProperty(property, out _));
+            return GetAttributes<T>(property, GetFieldInfo(property, out _));
         }
 
         public static T[] GetAttributes<T>(SerializedProperty property, FieldInfo fieldInfo) where T : Attribute
diff --git a/Assets/Editor Toolbox/README.md b/Assets/Editor Toolbox/README.md
@@ -555,6 +555,8 @@ public int var1;
 
 You can draw properties marked with the **[SerializeReference]** attribute with an additional type picker that allows you to manipulate what managed type will be serialized.
 
+To prevent issues after renaming types use `UnityEngine.Scripting.APIUpdating.MovedFromAttribute`.
+
 ```csharp
 [SerializeReference, ReferencePicker(TypeGrouping = TypeGrouping.ByFlatName)]
 public Interface1 var1;
diff --git a/Assets/Editor Toolbox/Tests/Editor/PropertyUtilitesTest.cs b/Assets/Editor Toolbox/Tests/Editor/PropertyUtilitesTest.cs
@@ -36,7 +36,7 @@ public void TestGetParentPass(string propertyPath, string parentName)
         public void TestGetValuePass(string propertyPath, object value)
         {
             var property = scriptableObject.FindProperty(propertyPath);
-            var fieldInfo = property.GetFieldInfo(out _, scriptableObject.targetObject);
+            var fieldInfo = property.GetFieldInfo(out _);
             property.SetProperValue(fieldInfo, value);
             var newValue = property.GetProperValue(fieldInfo);
             Assert.AreEqual(value, newValue);
diff --git a/Assets/Examples/Scenes/SampleScene.unity b/Assets/Examples/Scenes/SampleScene.unity
@@ -583,15 +583,16 @@ MonoBehaviour:
     id: 1
   var3:
     id: 2
-  vars: []
+  vars:
+  - id: 3
   references:
     version: 1
     00000000:
       type: {class: SampleBehaviour6/ClassWithInterface1, ns: , asm: Assembly-CSharp}
       data:
         go: {fileID: 977748987}
         var1:
-          id: 3
+          id: 4
     00000001:
       type: {class: SampleBehaviour6/ClassWithInterface3, ns: , asm: Assembly-CSharp}
       data:
@@ -602,6 +603,11 @@ MonoBehaviour:
         var1: 0
         mat: {fileID: 2100000, guid: 7404c70251f9d0045a4aabaa49d83963, type: 2}
     00000003:
+      type: {class: SampleBehaviour6/Struct, ns: , asm: Assembly-CSharp}
+      data:
+        var1: 0
+        var2: 0
+    00000004:
       type: {class: SampleBehaviour6/Struct, ns: , asm: Assembly-CSharp}
       data:
         var1: 1
diff --git a/README.md b/README.md
@@ -555,6 +555,8 @@ public int var1;
 
 You can draw properties marked with the **[SerializeReference]** attribute with an additional type picker that allows you to manipulate what managed type will be serialized.
 
+To prevent issues after renaming types use `UnityEngine.Scripting.APIUpdating.MovedFromAttribute`.
+
 ```csharp
 [SerializeReference, ReferencePicker(TypeGrouping = TypeGrouping.ByFlatName)]
 public Interface1 var1;

Original file line number	Diff line number	Diff line change
`@@ -24,20 +24,21 @@ private void UpdateContexts(ReferencePickerAttribute attribute)`
`24`	`24`
`25`	`25`	`private Type GetParentType(SerializedProperty property, ReferencePickerAttribute attribute)`
`26`	`26`	`{`
`27`		`- property.GetFieldInfo(out Type propertyType);`
	`27`	`+ var fieldInfo = property.GetFieldInfo(out _);`
	`28`	`+ var fieldType = property.GetProperType(fieldInfo);`
`28`	`29`	`var candidateType = attribute.ParentType;`
`29`	`30`	`if (candidateType != null)`
`30`	`31`	`{`
`31`		`- if (propertyType.IsAssignableFrom(candidateType))`
	`32`	`+ if (fieldType.IsAssignableFrom(candidateType))`
`32`	`33`	`{`
`33`	`34`	`return candidateType;`
`34`	`35`	`}`
`35`	`36`
`36`	`37`	`ToolboxEditorLog.AttributeUsageWarning(attribute, property,`
`37`		`- $"Provided {nameof(attribute.ParentType)} ({candidateType}) cannot be used because it's not assignable from: '{propertyType}'");`
	`38`	`+ $"Provided {nameof(attribute.ParentType)} ({candidateType}) cannot be used because it's not assignable from: '{fieldType}'");`
`38`	`39`	`}`
`39`	`40`
`40`		`- return propertyType;`
	`41`	`+ return fieldType;`
`41`	`42`	`}`
`42`	`43`
`43`	`44`	`private void CreateTypeProperty(Rect position, SerializedProperty property, Type parentType)`
Original file line number	Diff line number	Diff line change
`@@ -36,17 +36,19 @@ private void TryDrawLabel(Rect rect, GUIContent label)`
`36`	`36`	`InputRect = rect;`
`37`	`37`	`var size = EditorStyles.label.CalcSize(label);`
`38`	`38`	`rect.xMax = rect.xMin + size.x;`
	`39`	`+ rect.xMax += EditorGuiUtility.IndentSize;`
	`40`	`+ rect.xMax += EditorGuiUtility.SpacingSize;`
`39`	`41`	`LabelRect = rect;`
`40`	`42`	`if (property.hasVisibleChildren)`
`41`	`43`	`{`
`42`	`44`	`var labelRect = LabelRect;`
`43`		`- labelRect.xMax += EditorGuiUtility.FoldoutOffset;`
	`45`	`+ labelRect.xMax += EditorGuiUtility.FoldoutSize;`
`44`	`46`	`LabelRect = labelRect;`
`45`	`47`	`property.isExpanded = EditorGUI.Foldout(labelRect, property.isExpanded, label, true);`
`46`	`48`	`}`
`47`	`49`	`else`
`48`	`50`	`{`
`49`		`- EditorGUI.LabelField(rect, label);`
	`51`	`+ EditorGUI.LabelField(LabelRect, label);`
`50`	`52`	`}`
`51`	`53`	`}`
`52`	`54`
Original file line number	Diff line number	Diff line change
`@@ -286,11 +286,11 @@ private void DrawProperty(SerializedProperty property, GUIContent label)`
`286`	`286`	`//draw target property using the associated type drawer`
`287`	`287`	`ToolboxDrawerModule.GetTargetTypeDrawer(type)?.OnGui(property, label);`
`288`	`288`	`}`
	`289`	`+`
	`290`	`+ return;`
`289`	`291`	`}`
`290`		`- else`
`291`		`- {`
`292`		`- OnGuiDefault(property, label);`
`293`		`- }`
	`292`	`+`
	`293`	`+ OnGuiDefault(property, label);`
`294`	`294`	`}`
`295`	`295`
`296`	`296`	`private void BeginDecoratorDrawers(PropertyCondition conditionState = PropertyCondition.Valid)`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,8 @@ namespace Toolbox.Editor`
`12`	`12`	`/// </summary>`
`13`	`13`	`internal static class EditorGuiUtility`
`14`	`14`	`{`
	`15`	`+ private const float indentPerLevel = 15.0f;`
	`16`	`+`
`15`	`17`	`private static readonly Dictionary<string, Texture2D> loadedTextures = new Dictionary<string, Texture2D>();`
`16`	`18`
`17`	`19`
`@@ -99,6 +101,9 @@ public static Texture GetHelpIcon(MessageType messageType)`
`99`	`101`	`}`
`100`	`102`
`101`	`103`
`102`		`- public static float FoldoutOffset { get; internal set; } = 28.0f;`
	`104`	`+ public static float FoldoutSize { get; internal set; } = 15.0f;`
	`105`	`+ public static float SpacingSize => EditorGUIUtility.standardVerticalSpacing;`
	`106`	`+ public static float HeightSize => EditorGUIUtility.singleLineHeight;`
	`107`	`+ public static float IndentSize => EditorGUI.indentLevel * indentPerLevel;`
`103`	`108`	`}`
`104`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,12 @@ namespace Toolbox.Editor`
`10`	`10`	`{`
`11`	`11`	`public static partial class PropertyUtility`
`12`	`12`	`{`
	`13`	`+ //NOTE: last non-reflection implementation was ok but support for [SerializeReference] makes it a bit slow`
	`14`	`+ // unfortunately UnityEditor.ScriptAttributeUtility.GetFieldInfoFromProperty is internal so we have to retrive it using reflection`
	`15`	`+ private static readonly MethodInfo getGetFieldInfoFromPropertyMethod =`
	`16`	`+ ReflectionUtility.GetEditorMethod("UnityEditor.ScriptAttributeUtility", "GetFieldInfoFromProperty",`
	`17`	`+ BindingFlags.NonPublic \| BindingFlags.Static);`
	`18`	`+`
`13`	`19`	`/// <summary>`
`14`	`20`	`/// Indicates if the property has all changes applied and can be safely used for reflection-based features.`
`15`	`21`	`/// </summary>`
`@@ -249,22 +255,20 @@ public static Type GetScriptTypeFromProperty(SerializedProperty property)`
`249`	`255`	`return scriptInstance.GetClass();`
`250`	`256`	`}`
`251`	`257`
`252`		`-`
`253`	`258`	`public static FieldInfo GetFieldInfo(this SerializedProperty property)`
`254`	`259`	`{`
`255`	`260`	`return GetFieldInfo(property, out _);`
`256`	`261`	`}`
`257`	`262`
`258`	`263`	`public static FieldInfo GetFieldInfo(this SerializedProperty property, out Type propertyType)`
`259`	`264`	`{`
`260`		`- return GetFieldInfoFromProperty(property, out propertyType);`
`261`		`- }`
`262`		`-`
`263`		`- public static FieldInfo GetFieldInfo(this SerializedProperty property, out Type propertyType, Object target)`
`264`		`- {`
`265`		`- return GetFieldInfoFromProperty(property, out propertyType, target.GetType());`
	`265`	`+ var parameters = new object[] { property, null };`
	`266`	`+ var result = getGetFieldInfoFromPropertyMethod.Invoke(null, parameters) as FieldInfo;`
	`267`	`+ propertyType = parameters[1] as Type;`
	`268`	`+ return result;`
`266`	`269`	`}`
`267`	`270`
	`271`	`+ [Obsolete("This method is no longer safe, use GetFieldInfo() instead.")]`
`268`	`272`	`public static FieldInfo GetFieldInfoFromProperty(SerializedProperty property, out Type type)`
`269`	`273`	`{`
`270`	`274`	`var classType = GetScriptTypeFromProperty(property);`
`@@ -277,8 +281,11 @@ public static FieldInfo GetFieldInfoFromProperty(SerializedProperty property, ou`
`277`	`281`	`return GetFieldInfoFromProperty(property, out type, classType);`
`278`	`282`	`}`
`279`	`283`
	`284`	`+ [Obsolete("This method is no longer safe, use GetFieldInfo() instead.")]`
`280`	`285`	`public static FieldInfo GetFieldInfoFromProperty(SerializedProperty property, out Type type, Type host)`
`281`	`286`	`{`
	`287`	`+ const BindingFlags fieldFlags = BindingFlags.Instance \| BindingFlags.Public \| BindingFlags.NonPublic;`
	`288`	`+`
`282`	`289`	`FieldInfo field = null;`
`283`	`290`	`type = host;`
`284`	`291`
`@@ -297,7 +304,6 @@ public static FieldInfo GetFieldInfoFromProperty(SerializedProperty property, ou`
`297`	`304`	`continue;`
`298`	`305`	`}`
`299`	`306`
`300`		`- const BindingFlags fieldFlags = BindingFlags.Instance \| BindingFlags.Public \| BindingFlags.NonPublic;`
`301`	`307`	`FieldInfo foundField = null;`
`302`	`308`	`for (var currentType = type; foundField == null && currentType != null; currentType = currentType.BaseType)`
`303`	`309`	`{`
`@@ -383,7 +389,7 @@ public static SerializedProperty GetSize(this SerializedProperty array)`
`383`	`389`
`384`	`390`	`public static T GetAttribute<T>(SerializedProperty property) where T : Attribute`
`385`	`391`	`{`
`386`		`- return GetAttribute<T>(property, GetFieldInfoFromProperty(property, out _));`
	`392`	`+ return GetAttribute<T>(property, GetFieldInfo(property, out _));`
`387`	`393`	`}`
`388`	`394`
`389`	`395`	`public static T GetAttribute<T>(SerializedProperty property, FieldInfo fieldInfo) where T : Attribute`
`@@ -393,7 +399,7 @@ public static T GetAttribute<T>(SerializedProperty property, FieldInfo fieldInfo`
`393`	`399`
`394`	`400`	`public static T[] GetAttributes<T>(SerializedProperty property) where T : Attribute`
`395`	`401`	`{`
`396`		`- return GetAttributes<T>(property, GetFieldInfoFromProperty(property, out _));`
	`402`	`+ return GetAttributes<T>(property, GetFieldInfo(property, out _));`
`397`	`403`	`}`
`398`	`404`
`399`	`405`	`public static T[] GetAttributes<T>(SerializedProperty property, FieldInfo fieldInfo) where T : Attribute`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ public void TestGetParentPass(string propertyPath, string parentName)`
`36`	`36`	`public void TestGetValuePass(string propertyPath, object value)`
`37`	`37`	`{`
`38`	`38`	`var property = scriptableObject.FindProperty(propertyPath);`
`39`		`- var fieldInfo = property.GetFieldInfo(out _, scriptableObject.targetObject);`
	`39`	`+ var fieldInfo = property.GetFieldInfo(out _);`
`40`	`40`	`property.SetProperValue(fieldInfo, value);`
`41`	`41`	`var newValue = property.GetProperValue(fieldInfo);`
`42`	`42`	`Assert.AreEqual(value, newValue);`