上传YomovSDK

Packages/jillejr.newtonsoft.json-for-unity.converters/Editor/Newtonsoft.Json.UnityConverters.Editor.asmdef

@@ -0,0 +1,16 @@
+{
+    "name": "Newtonsoft.Json.UnityConverters.Editor",
+    "references": [
+        "Newtonsoft.Json.UnityConverters"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "Newtonsoft.Json.dll"
+    ],
+    "autoReferenced": false
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/Editor/Newtonsoft.Json.UnityConverters.Editor.asmdef.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/Editor/UnityConvertersConfigEditor.cs

@@ -0,0 +1,343 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json.UnityConverters.Configuration;
+using UnityEditor;
+using UnityEditor.AnimatedValues;
+using UnityEngine;
+// Unity 2020 also has a type cache: UnityEditor.TypeCache:
+// https://docs.unity3d.com/2019.2/Documentation/ScriptReference/TypeCache.html
+using TypeCache = Newtonsoft.Json.UnityConverters.Utility.TypeCache;
+
+namespace Newtonsoft.Json.UnityConverters.Editor
+{
+    using Editor = UnityEditor.Editor;
+
+    [CustomEditor(typeof(UnityConvertersConfig))]
+    public class UnityConvertersConfigEditor : Editor
+    {
+        private SerializedProperty _useUnityContractResolver;
+        private SerializedProperty _useAllOutsideConverters;
+        private SerializedProperty _outsideConverters;
+        private SerializedProperty _useAllUnityConverters;
+        private SerializedProperty _unityConverters;
+        private SerializedProperty _useAllJsonNetConverters;
+        private SerializedProperty _jsonNetConverters;
+        private SerializedProperty _autoSyncConverters;
+
+        private AnimBool _outsideConvertersShow;
+        private AnimBool _unityConvertersShow;
+        private AnimBool _jsonNetConvertersShow;
+        private AnimBool _autoSyncConvertersShow;
+
+        private bool _isDirty;
+
+        private static class Styles
+        {
+            public static GUIStyle headerStyle;
+            public static GUIStyle boldHeaderStyle;
+
+            static Styles()
+            {
+                headerStyle = new GUIStyle { fontSize = 20, wordWrap = true, normal = EditorStyles.label.normal };
+                boldHeaderStyle = new GUIStyle { fontSize = 20, fontStyle = FontStyle.Bold, wordWrap = true, normal = EditorStyles.label.normal };
+            }
+        }
+
+        private void OnEnable()
+        {
+            var config = (UnityConvertersConfig)target;
+            var grouped = UnityConverterInitializer.FindGroupedConverters(config);
+
+            // Hack around the "SerializedObjectNotCreatableException: Object at index 0 is null"
+            // error message
+            try
+            {
+                _ = serializedObject;
+            }
+            catch (Exception)
+            {
+                return;
+            }
+
+            _useUnityContractResolver = serializedObject.FindProperty(nameof(UnityConvertersConfig.useUnityContractResolver));
+            _useAllOutsideConverters = serializedObject.FindProperty(nameof(UnityConvertersConfig.useAllOutsideConverters));
+            _outsideConverters = serializedObject.FindProperty(nameof(UnityConvertersConfig.outsideConverters));
+            _useAllUnityConverters = serializedObject.FindProperty(nameof(UnityConvertersConfig.useAllUnityConverters));
+            _unityConverters = serializedObject.FindProperty(nameof(UnityConvertersConfig.unityConverters));
+            _useAllJsonNetConverters = serializedObject.FindProperty(nameof(UnityConvertersConfig.useAllJsonNetConverters));
+            _jsonNetConverters = serializedObject.FindProperty(nameof(UnityConvertersConfig.jsonNetConverters));
+            _autoSyncConverters = serializedObject.FindProperty(nameof(UnityConvertersConfig.autoSyncConverters));
+
+            _outsideConvertersShow = new AnimBool(_outsideConverters.isExpanded);
+            _unityConvertersShow = new AnimBool(_unityConverters.isExpanded);
+            _jsonNetConvertersShow = new AnimBool(_jsonNetConverters.isExpanded);
+            _autoSyncConvertersShow = new AnimBool(!_autoSyncConverters.boolValue);
+
+            _outsideConvertersShow.valueChanged.AddListener(Repaint);
+            _unityConvertersShow.valueChanged.AddListener(Repaint);
+            _jsonNetConvertersShow.valueChanged.AddListener(Repaint);
+
+            serializedObject.Update();
+            AddAndSetupConverters(_outsideConverters, grouped.outsideConverters, _useAllOutsideConverters.boolValue);
+            AddAndSetupConverters(_unityConverters, grouped.unityConverters, _useAllUnityConverters.boolValue);
+            AddAndSetupConverters(_jsonNetConverters, grouped.jsonNetConverters, _useAllJsonNetConverters.boolValue);
+
+            serializedObject.ApplyModifiedProperties();
+        }
+
+        public override void OnInspectorGUI()
+        {
+            _isDirty = false;
+            EditorGUILayout.LabelField("Settings for the converters of", Styles.headerStyle);
+            EditorGUILayout.LabelField("Newtonsoft.Json-for-Unity.Converters", Styles.boldHeaderStyle);
+
+            serializedObject.Update();
+
+            EditorGUILayout.Space();
+
+            ToggleLeft(_useUnityContractResolver, "Custom 'Newtonsoft.Json.Serialization.IContractResolver' defined to" +
+                " properly handle the 'UnityEngine.SerializeFieldAttribute' attribute and correctly creates" +
+                " 'UnityEngine.ScriptableObject' via 'ScriptableObject.Create()' instead of the default" +
+                " 'new ScriptableObject()'.");
+
+            EditorGUILayout.Space();
+
+            FoldedConverters(_useAllOutsideConverters, _outsideConverters, _outsideConvertersShow,
+                "Registers all classes outside of the 'Newtonsoft.Json.*' namespace" +
+                " that derive from 'Newtonsoft.Json.JsonConverter' that has a default constructor.");
+
+            EditorGUILayout.Space();
+
+            FoldedConverters(_useAllUnityConverters, _unityConverters, _unityConvertersShow,
+                "Registers all classes inside of the 'Newtonsoft.Json.UnityConverters.*' namespace.");
+
+            EditorGUILayout.Space();
+
+            FoldedConverters(_useAllJsonNetConverters, _jsonNetConverters, _jsonNetConvertersShow,
+                "Registers all classes inside of the 'Newtonsoft.Json.UnityConverters.*' namespace.");
+
+            EditorGUILayout.Space();
+
+            ToggleLeft(_autoSyncConverters,
+                "Automatic synchronization of JsonConverter types is enabled by default," +
+                " but can induce a heavy spike on each assembly reload (such as when entering play mode) on bigger projects.");
+            _autoSyncConvertersShow.target = !_autoSyncConverters.boolValue;
+            if (EditorGUILayout.BeginFadeGroup(_autoSyncConvertersShow.faded))
+            {
+                EditorGUILayout.HelpBox("The Newtonsoft.Json-for-Unity.Converters package will no longer automatically" +
+                    " look for new JsonConverters.\n\n" +
+                    "Having this automatic scan disabled reduces the load spike caused on larger projects every time you enter play mode," +
+                    " but you must instead remember to press the sync button below every time you add a new JsonConverter.",
+                    MessageType.Warning);
+                if (GUILayout.Button("Manual Converter Sync Now"))
+                {
+                    var grouped = ConverterGrouping.Create(UnityConverterInitializer.FindConverters());
+                    AddAndSetupConverters(_outsideConverters, grouped.outsideConverters, _useAllOutsideConverters.boolValue);
+                    AddAndSetupConverters(_unityConverters, grouped.unityConverters, _useAllUnityConverters.boolValue);
+                    AddAndSetupConverters(_jsonNetConverters, grouped.jsonNetConverters, _useAllJsonNetConverters.boolValue);
+                }
+            }
+            EditorGUILayout.EndFadeGroup();
+
+            serializedObject.ApplyModifiedProperties();
+
+            if (_isDirty)
+            {
+                UnityConverterInitializer.RefreshSettingsFromConfig();
+            }
+        }
+
+        private void AddAndSetupConverters(SerializedProperty arrayProperty, IList<Type> converterTypes, bool newAreEnabledByDefault)
+        {
+            var elements = EnumerateArrayElements(arrayProperty).ToArray();
+            var elementTypes = elements
+                .Select(e => TypeCache.FindType(
+                    name: e.FindPropertyRelative(nameof(ConverterConfig.converterName)).stringValue,
+                    assemblyName: e.FindPropertyRelative(nameof(ConverterConfig.converterAssembly)).stringValue
+                ))
+                .ToArray();
+
+            // Refresh missing fields on existing types
+            for (int i = 0; i < elements.Length; i++)
+            {
+                SerializedProperty elem = elements[i];
+                Type type = elementTypes[i];
+
+                var assemblyNameProp = elem.FindPropertyRelative(nameof(ConverterConfig.converterAssembly));
+                if (string.IsNullOrEmpty(assemblyNameProp.stringValue))
+                {
+                    assemblyNameProp.stringValue = type.Assembly.GetName().Name;
+                }
+            }
+
+            Type[] missingConverters = converterTypes
+                .Where(type => !elementTypes.Contains(type))
+                .ToArray();
+
+            // Cleanup excess types
+            for (int i = elementTypes.Length - 1; i >= 0; i--)
+            {
+                if (converterTypes.Contains(elementTypes[i]))
+                {
+                    continue;
+                }
+                string typeName = arrayProperty.GetArrayElementAtIndex(i).FindPropertyRelative(nameof(ConverterConfig.converterName)).stringValue;
+                Debug.Log($"Removed type from JsonConverter list: \"{typeName}\"", target);
+                arrayProperty.DeleteArrayElementAtIndex(i);
+            }
+
+            foreach (Type converterType in missingConverters)
+            {
+                int nextIndex = arrayProperty.arraySize;
+                arrayProperty.InsertArrayElementAtIndex(nextIndex);
+
+                SerializedProperty elemProp = arrayProperty.GetArrayElementAtIndex(nextIndex);
+                SerializedProperty enabledProp = elemProp.FindPropertyRelative(nameof(ConverterConfig.enabled));
+                SerializedProperty converterNameProp = elemProp.FindPropertyRelative(nameof(ConverterConfig.converterName));
+                SerializedProperty assemblyNameProp = elemProp.FindPropertyRelative(nameof(ConverterConfig.converterAssembly));
+
+                enabledProp.boolValue = newAreEnabledByDefault;
+                converterNameProp.stringValue = converterType.FullName;
+                assemblyNameProp.stringValue = converterType.Assembly.GetName().Name;
+            }
+        }
+
+        private static IEnumerable<SerializedProperty> EnumerateArrayElements(SerializedProperty arrayProperty)
+        {
+            for (int i = 0; i < arrayProperty.arraySize; i++)
+            {
+                yield return arrayProperty.GetArrayElementAtIndex(i);
+            }
+        }
+
+        private void FoldedConverters(
+            SerializedProperty useAllBoolProperty,
+            SerializedProperty convertersArrayProperty,
+            AnimBool foldoutAnim,
+            string tooltip)
+        {
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+            ToggleLeft(useAllBoolProperty, tooltip);
+
+            EditorGUI.BeginDisabledGroup(useAllBoolProperty.boolValue || convertersArrayProperty.arraySize == 0);
+            FoldoutConvertersList(convertersArrayProperty, foldoutAnim);
+            EditorGUI.EndDisabledGroup();
+            EditorGUILayout.EndVertical();
+
+            EditorGUILayout.Space();
+        }
+
+        private static void ToggleLeft(SerializedProperty property, string tooltip)
+        {
+            var content = new GUIContent {
+                text = property.displayName,
+                tooltip = tooltip,
+            };
+
+            property.boolValue = EditorGUILayout.ToggleLeft(content, property.boolValue);
+        }
+
+        private void FoldoutConvertersList(SerializedProperty property, AnimBool fadedAnim)
+        {
+            string displayName = $"{property.displayName} ({(property.arraySize == 0 ? "none found" : property.arraySize.ToString())})";
+
+            EditorGUI.indentLevel++;
+            property.isExpanded = EditorGUILayout.Foldout(property.isExpanded, displayName, true);
+            EditorGUI.indentLevel--;
+            fadedAnim.target = property.isExpanded;
+
+            if (EditorGUILayout.BeginFadeGroup(fadedAnim.faded))
+            {
+                EditorGUI.indentLevel++;
+
+                var allConfigsWithType = EnumerateArrayElements(property)
+                    .Select(o => (
+                        serializedProperty: o,
+                        type: TypeCache.FindType(
+                            name: o.FindPropertyRelative(nameof(ConverterConfig.converterName)).stringValue,
+                            assemblyName: o.FindPropertyRelative(nameof(ConverterConfig.converterAssembly)).stringValue
+                        )
+                    ))
+                    .Where(o => o.type != null)
+                    .OrderBy(o => o.type.FullName);
+
+                foreach (var namespaceGroup in allConfigsWithType.GroupBy(o => GetTypeNamespace(o.type)))
+                {
+                    var groupLabel = new GUIContent {
+                        tooltip = GetNamespaceTooltip(namespaceGroup),
+                        text = GetNamespaceHeader(namespaceGroup),
+                    };
+                    EditorGUILayout.LabelField(groupLabel, EditorStyles.boldLabel);
+
+                    EditorGUI.indentLevel++;
+                    foreach (var configWithType in namespaceGroup.OrderBy(o => o.type?.Name))
+                    {
+                        SerializedProperty enabledProp = configWithType.serializedProperty.FindPropertyRelative(nameof(ConverterConfig.enabled));
+                        if (configWithType.type != null)
+                        {
+                            var toggleContent = new GUIContent {
+                                text = configWithType.type.Name,
+                                tooltip = configWithType.type.AssemblyQualifiedName,
+                            };
+
+                            bool oldValue = enabledProp.boolValue;
+                            enabledProp.boolValue = EditorGUILayout.ToggleLeft(toggleContent, enabledProp.boolValue);
+
+                            if (oldValue != enabledProp.boolValue)
+                            {
+                                _isDirty = true;
+                            }
+                        }
+                        else
+                        {
+                            if (enabledProp.boolValue)
+                            {
+                                enabledProp.boolValue = false;
+                            }
+
+                            SerializedProperty converterNameProp = configWithType.serializedProperty.FindPropertyRelative(nameof(ConverterConfig.converterName));
+                            EditorGUI.BeginDisabledGroup(true);
+                            EditorGUILayout.ToggleLeft($"Unknown type: {converterNameProp.stringValue}", false);
+                            EditorGUI.EndDisabledGroup();
+                        }
+                    }
+                    EditorGUI.indentLevel--;
+                    EditorGUILayout.Space();
+                }
+
+                EditorGUI.indentLevel--;
+            }
+
+            EditorGUILayout.EndFadeGroup();
+        }
+
+
+        private static string GetNamespaceHeader(IGrouping<string, (SerializedProperty serializedProperty, Type type)> namespaceGroup)
+        {
+            return $"{namespaceGroup.Key ?? "<Misconfigured converters>"} ({namespaceGroup.Count()})";
+        }
+
+        private static string GetNamespaceTooltip(IGrouping<string, (SerializedProperty serializedProperty, Type type)> namespaceGroup)
+        {
+            switch (namespaceGroup.Key)
+            {
+            case "global::":
+                return "Converters found with a default constructor from the global namespace.";
+
+            case null:
+                return "Converters that was found in the configuration but was" +
+                   " unable to map them to existing types. Maybe the type got renamed, or moved to a different" +
+                   " namespace?";
+
+            default:
+                return $"Converters found with a default constructor from the namespace '{namespaceGroup.Key}'.";
+            }
+        }
+
+        private static string GetTypeNamespace(Type type)
+        {
+            return type is null ? null : (type.Namespace ?? "global::");
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/Editor/UnityConvertersConfigEditor.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/Editor/UnityConvertersConfigMenu.cs

@@ -0,0 +1,46 @@
+using System.IO;
+using Newtonsoft.Json.UnityConverters.Configuration;
+using UnityEditor;
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Editor
+{
+    public static class UnityConvertersConfigMenu
+    {
+
+        [MenuItem("Edit/Json.NET converters settings...", false, 250)]
+        public static void OpenOrCreateConfig()
+        {
+            var config = GetOrCreateConfig();
+
+            EditorUtility.FocusProjectWindow();
+            EditorWindow inspectorWindow = EditorWindow.GetWindow(typeof(UnityEditor.Editor).Assembly.GetType("UnityEditor.InspectorWindow"));
+            inspectorWindow.Focus();
+
+            Selection.activeObject = config;
+        }
+
+        private static UnityConvertersConfig GetOrCreateConfig()
+        {
+            var config = Resources.Load<UnityConvertersConfig>(UnityConvertersConfig.PATH_FOR_RESOURCES_LOAD);
+
+            if (config)
+            {
+                return config;
+            }
+
+            config = ScriptableObject.CreateInstance<UnityConvertersConfig>();
+
+            string directory = Path.GetDirectoryName(UnityConvertersConfig.PATH);
+            if (!Directory.Exists(directory))
+            {
+                Directory.CreateDirectory(directory);
+            }
+
+            AssetDatabase.CreateAsset(config, UnityConvertersConfig.PATH);
+            AssetDatabase.SaveAssets();
+
+            return config;
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/Editor/UnityConvertersConfigMenu.cs.meta

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