Update project to Unity 2021.x; implement SerializeReference-based co…

…ntext menu operations (Copy, Paster, Duplicate)

Assets/Editor Toolbox/Editor/ContextMenu/IContextMenuOperation.cs

@@ -0,0 +1,14 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Toolbox.Editor.ContextMenu
+{
+    internal interface IContextMenuOperation
+    {
+        bool IsVisible(SerializedProperty property);
+        bool IsEnabled(SerializedProperty property);
+        void Perform(SerializedProperty property);
+
+        GUIContent Label { get; }
+    }
+}

Assets/Editor Toolbox/Editor/ContextMenu/Management/ToolboxContextMenuManager.cs

@@ -0,0 +1,60 @@
+using System.Collections.Generic;
+
+using UnityEditor;
+
+namespace Toolbox.Editor.ContextMenu.Management
+{
+    using Toolbox.Editor.ContextMenu.Operations;
+
+    [InitializeOnLoad]
+    internal static class ToolboxContextMenuManager
+    {
+        private static readonly List<IContextMenuOperation> registeredOperations;
+
+        static ToolboxContextMenuManager()
+        {
+            registeredOperations = new List<IContextMenuOperation>()
+            {
+                new CopySerializeReferenceOperation(),
+                new PasteSerializeReferenceOperation(),
+                new DuplicateSerializeReferenceArrayElementOperation()
+            };
+
+            EditorApplication.contextualPropertyMenu -= OnContextMenuOpening;
+            EditorApplication.contextualPropertyMenu += OnContextMenuOpening;
+        }
+
+        public static void AppendOpertation(IContextMenuOperation operation)
+        {
+            registeredOperations.Add(operation);
+        }
+
+        public static bool RemoveOperation(IContextMenuOperation operation)
+        {
+            return registeredOperations.Remove(operation);
+        }
+
+        private static void OnContextMenuOpening(GenericMenu menu, SerializedProperty property)
+        {
+            foreach (var operation in registeredOperations)
+            {
+                if (!operation.IsVisible(property))
+                {
+                    continue;
+                }
+
+                var label = operation.Label;
+                if (!operation.IsEnabled(property))
+                {
+                    menu.AddDisabledItem(label);
+                    continue;
+                }
+
+                menu.AddItem(label, false, () =>
+                {
+                    operation.Perform(property);
+                });
+            }
+        }
+    }
+}

Assets/Editor Toolbox/Editor/ContextMenu/Operations/SerializeReference/CopySerializeReferenceOperation.cs

@@ -0,0 +1,48 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Toolbox.Editor.ContextMenu.Operations
+{
+    internal class CopySerializeReferenceOperation : IContextMenuOperation
+    {
+        internal static CopySerializedRererenceCache Cache { get; private set; }
+
+        public bool IsVisible(SerializedProperty property)
+        {
+#if UNITY_2021_3_OR_NEWER
+            return property != null && property.propertyType == SerializedPropertyType.ManagedReference;
+#else
+            return false;
+#endif
+        }
+
+        public bool IsEnabled(SerializedProperty property)
+        {
+            return true;
+        }
+
+        public void Perform(SerializedProperty property)
+        {
+#if UNITY_2021_3_OR_NEWER
+            var value = property.managedReferenceValue;
+            if (value != null)
+            {
+                var referenceType = value.GetType();
+                var data = JsonUtility.ToJson(value);
+                Cache = new CopySerializedRererenceCache(referenceType, data);
+                return;
+            }
+
+            Cache = new CopySerializedRererenceCache(null, null);
+#endif
+        }
+
+        public GUIContent Label => new GUIContent("Copy Serialize Reference");
+
+        [InitializeOnLoadMethod]
+        private static void Initialize()
+        {
+            Cache = null;
+        }
+    }
+}

Assets/Editor Toolbox/Editor/ContextMenu/Operations/SerializeReference/CopySerializedRererenceCache.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace Toolbox.Editor.ContextMenu.Operations
+{
+    internal class CopySerializedRererenceCache
+    {
+        public CopySerializedRererenceCache(Type referenceType, string data)
+        {
+            ReferenceType = referenceType;
+            Data = data;
+        }
+
+        public Type ReferenceType { get; }
+        public string Data { get; }
+    }
+}

Assets/Editor Toolbox/Editor/ContextMenu/Operations/SerializeReference/DuplicateSerializeReferenceArrayElementOperation.cs

@@ -0,0 +1,46 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Toolbox.Editor.ContextMenu.Operations
+{
+    internal class DuplicateSerializeReferenceArrayElementOperation : IContextMenuOperation
+    {
+        public GUIContent Label => new GUIContent("Duplicate Serialize Reference Array Element");
+
+        public bool IsVisible(SerializedProperty property)
+        {
+#if UNITY_2021_3_OR_NEWER
+            return property != null && property.propertyType == SerializedPropertyType.ManagedReference &&
+                PropertyUtility.IsSerializableArrayElement(property);
+#else
+            return false;
+#endif
+        }
+
+        public bool IsEnabled(SerializedProperty property)
+        {
+            return true;
+        }
+
+        public void Perform(SerializedProperty property)
+        {
+            var sourceProperty = property.Copy();
+            sourceProperty.serializedObject.Update();
+            var sourceValue = sourceProperty.managedReferenceValue;
+
+            var arrayProperty = PropertyUtility.GetArray(sourceProperty);
+            var newElementIndex = arrayProperty.arraySize;
+            arrayProperty.arraySize = newElementIndex + 1;
+            //NOTE: there will be null by default anyway
+            if (sourceValue != null)
+            {
+                var targetData = JsonUtility.ToJson(sourceValue);
+                var targetValue = JsonUtility.FromJson(targetData, sourceValue.GetType());
+                var targetProperty = arrayProperty.GetArrayElementAtIndex(newElementIndex);
+                targetProperty.managedReferenceValue = targetValue;
+            }
+
+            sourceProperty.serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

Assets/Editor Toolbox/Editor/ContextMenu/Operations/SerializeReference/PasteSerializeReferenceOperation.cs

@@ -0,0 +1,54 @@
+using System;
+
+using UnityEditor;
+using UnityEngine;
+
+namespace Toolbox.Editor.ContextMenu.Operations
+{
+
+    internal class PasteSerializeReferenceOperation : IContextMenuOperation
+    {
+        private object GetCachedManagedReferenceValue()
+        {
+            var cachedData = CopySerializeReferenceOperation.Cache;
+            if (cachedData.ReferenceType != null)
+            {
+                var newValue = JsonUtility.FromJson(cachedData.Data, cachedData.ReferenceType);
+                return newValue;
+            }
+            else
+            {
+                return null;
+            }
+        }
+
+        public bool IsVisible(SerializedProperty property)
+        {
+#if UNITY_2021_3_OR_NEWER
+            return property != null && property.propertyType == SerializedPropertyType.ManagedReference;
+#else
+            return false;
+#endif
+        }
+
+        public bool IsEnabled(SerializedProperty property)
+        {
+            return CopySerializeReferenceOperation.Cache != null;
+        }
+
+        public void Perform(SerializedProperty property)
+        {
+            var targetProperty = property.Copy();
+            try
+            {
+                targetProperty.serializedObject.Update();
+                targetProperty.managedReferenceValue = GetCachedManagedReferenceValue();
+                targetProperty.serializedObject.ApplyModifiedProperties();
+            }
+            catch (Exception)
+            { }
+        }
+
+        public GUIContent Label => new GUIContent("Paste Serialize Reference");
+    }
+}