上传YomovSDK

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/AI.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/AI/NavMesh.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/AI/NavMesh/NavMeshQueryFilterConverter.cs

@@ -0,0 +1,55 @@
+#if HAVE_MODULE_AI || !UNITY_2019_1_OR_NEWER
+using System;
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+using UnityEngine.AI;
+
+namespace Newtonsoft.Json.UnityConverters.AI.NavMesh
+{
+    public class NavMeshQueryFilterConverter : PartialConverter<NavMeshQueryFilter>
+    {
+        // Magic number taken from /Modules/AI/NavMesh/NavMesh.bindings.cs
+        // inside Unitys open source repo
+        // https://github.com/Unity-Technologies/UnityCsReference/blob/2019.2/Modules/AI/NavMesh/NavMesh.bindings.cs#L149
+        private const int AREA_COST_ELEMENT_COUNT = 32;
+
+        protected override void ReadValue(ref NavMeshQueryFilter value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case "costs":
+                    var costs = reader.ReadViaSerializer<float[]>(serializer);
+                    if (costs != null)
+                    {
+                        for (int i = Mathf.Min(costs.Length, AREA_COST_ELEMENT_COUNT) - 1; i >= 0; i--)
+                        {
+                            value.SetAreaCost(i, costs[i]);
+                        }
+                    }
+                    break;
+                case nameof(value.areaMask):
+                    value.areaMask = reader.ReadAsInt32() ?? 0;
+                    break;
+                case "agentTypeId": // camelCased the ID->Id
+                    value.agentTypeID = reader.ReadAsInt32() ?? 0;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, NavMeshQueryFilter value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName("costs");
+            writer.WriteStartArray();
+            for (int i = 0; i < AREA_COST_ELEMENT_COUNT; i++)
+            {
+                writer.WriteValue(value.GetAreaCost(i));
+            }
+            writer.WriteEndArray();
+            writer.WritePropertyName(nameof(value.areaMask));
+            writer.WriteValue(value.areaMask);
+            writer.WritePropertyName("agentTypeId"); // camelCased the ID->id
+            writer.WriteValue(value.agentTypeID);
+        }
+    }
+}
+#endif

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/AI/NavMesh/NavMeshQueryFilterConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/AI/NavMesh/NavMeshTriangulationConverter.cs

@@ -0,0 +1,39 @@
+#if HAVE_MODULE_AI || !UNITY_2019_1_OR_NEWER
+using System;
+using System.Diagnostics.CodeAnalysis;
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+using UnityEngine.AI;
+
+namespace Newtonsoft.Json.UnityConverters.AI.NavMesh
+{
+    public class NavMeshTriangulationConverter : PartialConverter<NavMeshTriangulation>
+    {
+        protected override void ReadValue(ref NavMeshTriangulation value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.vertices):
+                    value.vertices = reader.ReadViaSerializer<Vector3[]>(serializer);
+                    break;
+                case nameof(value.indices):
+                    value.indices = reader.ReadViaSerializer<int[]>(serializer);
+                    break;
+                case nameof(value.areas):
+                    value.areas = reader.ReadViaSerializer<int[]>(serializer);
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, NavMeshTriangulation value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.vertices));
+            serializer.Serialize(writer, value.vertices, typeof(Vector3[]));
+            writer.WritePropertyName(nameof(value.indices));
+            serializer.Serialize(writer, value.indices, typeof(int[]));
+            writer.WritePropertyName(nameof(value.areas));
+            serializer.Serialize(writer, value.areas, typeof(int[]));
+        }
+    }
+}
+#endif

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/AI/NavMesh/NavMeshTriangulationConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Addressables.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Addressables/AssetReferenceConverter.cs

@@ -0,0 +1,52 @@
+using System;
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine.AddressableAssets;
+using UnityEngine.Scripting;
+
+[assembly: Preserve]
+
+namespace Newtonsoft.Json.UnityConverters.Addressables
+{
+    public class AssetReferenceConverter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType == typeof(AssetReference) || (objectType.IsGenericType && objectType.GetGenericTypeDefinition() == typeof(AssetReferenceT<>));
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                return null;
+            }
+
+            if (reader.TokenType == JsonToken.String && reader.Value is string stringValue)
+            {
+                if (objectType.IsGenericType && objectType.GetGenericTypeDefinition() == typeof(AssetReferenceT<>))
+                {
+                    return Activator.CreateInstance(objectType, stringValue);
+                } else
+                {
+                    return new AssetReference(stringValue);
+                }
+            }
+            else
+            {
+                throw reader.CreateSerializationException($"Expected string when reading UnityEngine.Addressables.AssetReference type, got '{reader.TokenType}' <{reader.Value}>.");
+            }
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            if (value is null || string.IsNullOrEmpty(((AssetReference)value).AssetGUID))
+            {
+                writer.WriteNull();
+            }
+            else
+            {
+                writer.WriteValue(((AssetReference)value).AssetGUID);
+            }
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Addressables/AssetReferenceConverter.cs.meta

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

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

@@ -0,0 +1,24 @@
+{
+    "name": "Newtonsoft.Json.UnityConverters.Addressables",
+    "references": [
+        "Unity.Addressables",
+        "Newtonsoft.Json.UnityConverters"
+    ],
+    "optionalUnityReferences": [],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [
+        "HAVE_MODULE_ADDRESSABLES"
+    ],
+    "versionDefines": [
+        {
+            "name": "com.unity.addressables",
+            "expression": "",
+            "define": "HAVE_MODULE_ADDRESSABLES"
+        }
+    ]
+}

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

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Camera.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Camera/CullingGroupEventConverter.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Camera
+{
+    public class CullingGroupEventConverter : PartialConverter<CullingGroupEvent>
+    {
+        private const byte DISTANCE_MASK = (1 << 7) - 1;
+
+        [MaybeNull]
+        private static readonly FieldInfo _indexField = typeof(CullingGroupEvent).GetFieldInfoOrThrow("m_Index");
+        [MaybeNull]
+        private static readonly FieldInfo _prevStateField = typeof(CullingGroupEvent).GetFieldInfoOrThrow("m_PrevState");
+        [MaybeNull]
+        private static readonly FieldInfo _thisStateField = typeof(CullingGroupEvent).GetFieldInfoOrThrow("m_ThisState");
+
+        protected override void ReadValue(ref CullingGroupEvent value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.index):
+                    _indexField.SetValueDirectRef(ref value, reader.ReadAsInt32() ?? 0);
+                    break;
+                case nameof(value.isVisible):
+                    SetStateField(_thisStateField, ref value, value.currentDistance, reader.ReadAsBoolean() ?? false);
+                    break;
+                case nameof(value.wasVisible):
+                    SetStateField(_prevStateField, ref value, value.previousDistance, reader.ReadAsBoolean() ?? false);
+                    break;
+                case nameof(value.currentDistance):
+                    SetStateField(_thisStateField, ref value, reader.ReadAsInt32() ?? 0, value.isVisible);
+                    break;
+                case nameof(value.previousDistance):
+                    SetStateField(_prevStateField, ref value, reader.ReadAsInt32() ?? 0, value.wasVisible);
+                    break;
+            }
+        }
+
+        private static void SetStateField(FieldInfo field, ref CullingGroupEvent value, int distance, bool isVisible)
+        {
+            byte isVisibleByte = isVisible ? (byte)0x80 : (byte)0;
+            byte stateByte = (byte)(isVisibleByte | (distance & DISTANCE_MASK));
+            field.SetValueDirectRef(ref value, stateByte);
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, CullingGroupEvent value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.index));
+            writer.WriteValue(value.index);
+            writer.WritePropertyName(nameof(value.isVisible));
+            writer.WriteValue(value.isVisible);
+            writer.WritePropertyName(nameof(value.wasVisible));
+            writer.WriteValue(value.wasVisible);
+            writer.WritePropertyName(nameof(value.currentDistance));
+            writer.WriteValue(value.currentDistance);
+            writer.WritePropertyName(nameof(value.previousDistance));
+            writer.WriteValue(value.previousDistance);
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Camera/CullingGroupEventConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/ConverterGrouping.cs

@@ -0,0 +1,65 @@
+#region License
+// The MIT License (MIT)
+//
+// Copyright (c) 2020 Wanzyee Studio
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+#if UNITY_EDITOR
+#endif
+
+namespace Newtonsoft.Json.UnityConverters
+{
+    internal class ConverterGrouping
+    {
+        public List<Type> outsideConverters { get; set; }
+        public List<Type> unityConverters { get; set; }
+        public List<Type> jsonNetConverters { get; set; }
+
+        public static ConverterGrouping Create(IEnumerable<Type> types)
+        {
+            var grouping = new ConverterGrouping {
+                outsideConverters = new List<Type>(),
+                unityConverters = new List<Type>(),
+                jsonNetConverters = new List<Type>(),
+            };
+
+            foreach (var converter in types)
+            {
+                if (converter.Namespace?.StartsWith("Newtonsoft.Json.UnityConverters") == true)
+                {
+                    grouping.unityConverters.Add(converter);
+                }
+                else if (converter.Namespace?.StartsWith("Newtonsoft.Json.Converters") == true)
+                {
+                    grouping.jsonNetConverters.Add(converter);
+                }
+                else
+                {
+                    grouping.outsideConverters.Add(converter);
+                }
+            }
+
+            return grouping;
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/ConverterGrouping.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Geometry.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Geometry/BoundsConverter.cs

@@ -0,0 +1,56 @@
+#region License
+// The MIT License (MIT)
+//
+// Copyright (c) 2020 Wanzyee Studio
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Geometry
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity Bounds type <see cref="Bounds"/>.
+    /// </summary>
+    public class BoundsConverter : PartialConverter<Bounds>
+    {
+        protected override void ReadValue(ref Bounds value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.center):
+                    value.center = reader.ReadViaSerializer<Vector3>(serializer);
+                    break;
+                case nameof(value.size):
+                    value.size = reader.ReadViaSerializer<Vector3>(serializer);
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, Bounds value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.center));
+            serializer.Serialize(writer, value.center, typeof(Vector3));
+            writer.WritePropertyName(nameof(value.size));
+            serializer.Serialize(writer, value.size, typeof(Vector3));
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Geometry/BoundsConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Geometry/BoundsIntConverter.cs

@@ -0,0 +1,58 @@
+#region License
+// The MIT License (MIT)
+//
+// Copyright (c) 2020 Wanzyee Studio
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+using UnityEngine.Scripting;
+
+namespace Newtonsoft.Json.UnityConverters.Geometry
+{
+    /// <summary>
+
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity integer Bounds type <see cref="BoundsInt"/>.
+    /// </summary>
+    public class BoundsIntConverter : PartialConverter<BoundsInt>
+    {
+        protected override void ReadValue(ref BoundsInt value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.position):
+                    value.position = reader.ReadViaSerializer<Vector3Int>(serializer);
+                    break;
+                case nameof(value.size):
+                    value.size = reader.ReadViaSerializer<Vector3Int>(serializer);
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, BoundsInt value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.position));
+            serializer.Serialize(writer, value.position, typeof(Vector3Int));
+            writer.WritePropertyName(nameof(value.size));
+            serializer.Serialize(writer, value.size, typeof(Vector3Int));
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Geometry/BoundsIntConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Geometry/PlaneConverter.cs

@@ -0,0 +1,29 @@
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Geometry
+{
+    public class PlaneConverter : PartialConverter<Plane>
+    {
+        protected override void ReadValue(ref Plane value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.normal):
+                    value.normal = reader.ReadViaSerializer<Vector3>(serializer);
+                    break;
+                case nameof(value.distance):
+                    value.distance = reader.ReadAsFloat() ?? 0;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, Plane value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.normal));
+            serializer.Serialize(writer, value.normal, typeof(Vector3));
+            writer.WritePropertyName(nameof(value.distance));
+            writer.WriteValue(value.distance);
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Geometry/PlaneConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Geometry/RectConverter.cs

@@ -0,0 +1,66 @@
+#region License
+// The MIT License (MIT)
+//
+// Copyright (c) 2020 Wanzyee Studio
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Geometry
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity Rect type <see cref="Rect"/>.
+    /// </summary>
+    public class RectConverter : PartialConverter<Rect>
+    {
+        protected override void ReadValue(ref Rect value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = reader.ReadAsFloat() ?? 0;
+                    break;
+                case nameof(value.y):
+                    value.y = reader.ReadAsFloat() ?? 0;
+                    break;
+                case nameof(value.width):
+                    value.width = reader.ReadAsFloat() ?? 0;
+                    break;
+                case nameof(value.height):
+                    value.height = reader.ReadAsFloat() ?? 0;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, Rect value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+            writer.WritePropertyName(nameof(value.width));
+            writer.WriteValue(value.width);
+            writer.WritePropertyName(nameof(value.height));
+            writer.WriteValue(value.height);
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Geometry/RectConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Geometry/RectIntConverter.cs

@@ -0,0 +1,65 @@
+#region License
+// The MIT License (MIT)
+//
+// Copyright (c) 2020 Wanzyee Studio
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Geometry
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity RectInt type <see cref="RectInt"/>.
+    /// </summary>
+    public class RectIntConverter : PartialConverter<RectInt>
+    {
+        protected override void ReadValue(ref RectInt value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = reader.ReadAsInt32() ?? 0;
+                    break;
+                case nameof(value.y):
+                    value.y = reader.ReadAsInt32() ?? 0;
+                    break;
+                case nameof(value.width):
+                    value.width = reader.ReadAsInt32() ?? 0;
+                    break;
+                case nameof(value.height):
+                    value.height = reader.ReadAsInt32() ?? 0;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, RectInt value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+            writer.WritePropertyName(nameof(value.width));
+            writer.WriteValue(value.width);
+            writer.WritePropertyName(nameof(value.height));
+            writer.WriteValue(value.height);
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Geometry/RectIntConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Geometry/RectOffsetConverter.cs

@@ -0,0 +1,65 @@
+#region License
+// The MIT License (MIT)
+//
+// Copyright (c) 2020 Wanzyee Studio
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Geometry
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity RectOffset type <see cref="RectOffset"/>.
+    /// </summary>
+    public class RectOffsetConverter : PartialConverter<RectOffset>
+    {
+        protected override void ReadValue(ref RectOffset value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.left):
+                    value.left = reader.ReadAsInt32() ?? 0;
+                    break;
+                case nameof(value.right):
+                    value.right = reader.ReadAsInt32() ?? 0;
+                    break;
+                case nameof(value.top):
+                    value.top = reader.ReadAsInt32() ?? 0;
+                    break;
+                case nameof(value.bottom):
+                    value.bottom = reader.ReadAsInt32() ?? 0;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, RectOffset value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.left));
+            writer.WriteValue(value.left);
+            writer.WritePropertyName(nameof(value.right));
+            writer.WriteValue(value.right);
+            writer.WritePropertyName(nameof(value.top));
+            writer.WriteValue(value.top);
+            writer.WritePropertyName(nameof(value.bottom));
+            writer.WriteValue(value.bottom);
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Geometry/RectOffsetConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Graphics.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Graphics/ResolutionConverter.cs

@@ -0,0 +1,61 @@
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Graphics
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity Color type <see cref="Color"/>.
+    /// </summary>
+    public class ResolutionConverter : PartialConverter<Resolution>
+    {
+        protected override void ReadValue(ref Resolution value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.width):
+                    value.width = reader.ReadAsInt32() ?? 0;
+                    break;
+                case nameof(value.height):
+                    value.height = reader.ReadAsInt32() ?? 0;
+                    break;
+#pragma warning disable CS0618 // Type or member is obsolete
+                case nameof(value.refreshRate):
+                    value.refreshRate = reader.ReadAsInt32() ?? 0;
+                    break;
+#pragma warning restore CS0618 // Type or member is obsolete
+#if UNITY_2022_2_OR_NEWER
+                case nameof(value.refreshRateRatio):
+                    value.refreshRateRatio = reader.ReadViaSerializer<RefreshRate>(serializer);
+                    break;
+#endif
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, Resolution value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.width));
+            writer.WriteValue(value.width);
+            writer.WritePropertyName(nameof(value.height));
+            writer.WriteValue(value.height);
+#pragma warning disable CS0618 // Type or member is obsolete
+            writer.WritePropertyName(nameof(value.refreshRate));
+#if UNITY_2022_2_OR_NEWER
+            if (double.IsNaN(value.refreshRateRatio.value))
+            {
+                writer.WriteValue(0);
+            }
+            else
+            {
+                writer.WriteValue(value.refreshRate);
+            }
+#else
+            writer.WriteValue(value.refreshRate);
+#endif
+#pragma warning restore CS0618 // Type or member is obsolete
+#if UNITY_2022_2_OR_NEWER
+            writer.WritePropertyName(nameof(value.refreshRateRatio));
+            serializer.Serialize(writer, value.refreshRateRatio);
+#endif
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Graphics/ResolutionConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Hashing.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Hashing/Hash128Converter.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Hashing
+{
+    public class Hash128Converter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType == typeof(Hash128) || objectType == typeof(Hash128?);
+        }
+
+        [return: MaybeNull]
+        public override object ReadJson(JsonReader reader, Type objectType, [AllowNull] object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                return objectType == typeof(Hash128?)
+                    ? (Hash128?)null
+                    : new Hash128();
+            }
+
+            if (reader.TokenType == JsonToken.String && reader.Value is string stringValue)
+            {
+                return Hash128.Parse(stringValue);
+            }
+            else
+            {
+                throw reader.CreateSerializationException($"Expected string when reading UnityEngine.Hash128 type, got '{reader.TokenType}' <{reader.Value}>.");
+            }
+        }
+
+        public override void WriteJson(JsonWriter writer, [AllowNull] object value, JsonSerializer serializer)
+        {
+            if (value is null)
+            {
+                writer.WriteNull();
+            }
+            else
+            {
+                writer.WriteValue(((Hash128)value).ToString());
+            }
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Hashing/Hash128Converter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Helpers.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Helpers/EnumerableExtensions.cs

@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+
+namespace Newtonsoft.Json.UnityConverters.Helpers
+{
+    internal static class EnumerableExtensions
+    {
+        public static IEnumerable<T> WhereNotNullRef<T>(this IEnumerable<T> values)
+            where T : class
+        {
+            foreach (T item in values)
+            {
+                if (item != null)
+                {
+                    yield return item;
+                }
+            }
+        }
+
+        public static IEnumerable<T> WhereNotNullValue<T>(this IEnumerable<T?> values)
+            where T : struct
+        {
+            foreach (T? item in values)
+            {
+                if (item.HasValue)
+                {
+                    yield return item.Value;
+                }
+            }
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Helpers/EnumerableExtensions.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Helpers/JsonHelperExtensions.cs

@@ -0,0 +1,117 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Reflection;
+using System.Text;
+
+namespace Newtonsoft.Json.UnityConverters.Helpers
+{
+    internal static class JsonHelperExtensions
+    {
+        /// <summary>
+        /// This refers to the ctor that lets you specify the line number and
+        /// position that was introduced in Json.NET v12.0.1.
+        /// <see cref="JsonSerializationException.JsonSerializationException(string, string, int, int, Exception)"/>
+        /// <see href="https://github.com/JamesNK/Newtonsoft.Json/blob/12.0.1/Src/Newtonsoft.Json/JsonSerializationException.cs#L110"/>
+        /// </summary>
+        internal static readonly ConstructorInfo _JsonSerializationExceptionPositionalCtor
+            = typeof(JsonSerializationException).GetConstructor(new[] {
+                typeof(string), typeof(string), typeof(int), typeof(int), typeof(Exception)
+            });
+
+        private static JsonSerializationException NewJsonSerializationException(string message, string path, int lineNumber, int linePosition, [AllowNull] Exception innerException)
+        {
+            if (_JsonSerializationExceptionPositionalCtor != null)
+            {
+                return (JsonSerializationException)_JsonSerializationExceptionPositionalCtor.Invoke(new object[] {
+                    message, path, lineNumber, linePosition, innerException
+                });
+            }
+            else
+            {
+                return new JsonSerializationException(message, innerException);
+            }
+        }
+
+        public static JsonSerializationException CreateSerializationException(this JsonReader reader, string message, [AllowNull] Exception innerException = null)
+        {
+            StringBuilder builder = CreateStringBuilderWithSpaceAfter(message);
+
+            builder.AppendFormat(CultureInfo.InvariantCulture, "Path '{0}'", reader.Path);
+
+            var lineInfo = reader as IJsonLineInfo;
+            int lineNumber = default;
+            int linePosition = default;
+
+            if (lineInfo?.HasLineInfo() == true)
+            {
+                lineNumber = lineInfo.LineNumber;
+                linePosition = lineInfo.LinePosition;
+                builder.AppendFormat(CultureInfo.InvariantCulture, ", line {0}, position {1}", lineNumber, linePosition);
+            }
+
+            builder.Append('.');
+
+            return NewJsonSerializationException(
+                message: builder.ToString(), reader.Path, lineNumber, linePosition, innerException);
+        }
+
+        public static JsonWriterException CreateWriterException(this JsonWriter writer, string message, [AllowNull] Exception innerException = null)
+        {
+            StringBuilder builder = CreateStringBuilderWithSpaceAfter(message);
+
+            builder.AppendFormat(CultureInfo.InvariantCulture, "Path '{0}'.", writer.Path);
+
+            return new JsonWriterException(
+                message: builder.ToString(), writer.Path, innerException);
+        }
+
+        private static StringBuilder CreateStringBuilderWithSpaceAfter(string message)
+        {
+            var builder = new StringBuilder(message);
+
+            if (message.EndsWith("."))
+            {
+                builder.Append(' ');
+            }
+            else if (!message.EndsWith(". "))
+            {
+                builder.Append(". ");
+            }
+
+            return builder;
+        }
+
+        [return: MaybeNull]
+        public static T ReadViaSerializer<T>(this JsonReader reader, JsonSerializer serializer)
+        {
+            reader.Read();
+            return serializer.Deserialize<T>(reader);
+        }
+
+        public static float? ReadAsFloat(this JsonReader reader)
+        {
+            // https://github.com/jilleJr/Newtonsoft.Json-for-Unity.Converters/issues/46
+
+            var str = reader.ReadAsString();
+
+            if (string.IsNullOrEmpty(str))
+            {
+                return null;
+            }
+            else if (float.TryParse(str, NumberStyles.Any, CultureInfo.InvariantCulture, out var valueParsed))
+            {
+                return valueParsed;
+            }
+            else
+            {
+                return 0f;
+            }
+        }
+
+        public static byte? ReadAsInt8(this JsonReader reader)
+        {
+            return checked((byte)(reader.ReadAsInt32() ?? 0));
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Helpers/JsonHelperExtensions.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Helpers/NullableAttributes.cs

@@ -0,0 +1,152 @@
+#pragma warning disable MA0048 // File name must match type name
+#define INTERNAL_NULLABLE_ATTRIBUTES
+#if (NET_STANDARD_2_0 || NET_4_6 || NET_2_0 || NET_2_0_SUBSET || NET_LEGACY) && !NET_STANDARD_2_1
+
+// https://github.com/dotnet/corefx/blob/48363ac826ccf66fbe31a5dcb1dc2aab9a7dd768/src/Common/src/CoreLib/System/Diagnostics/CodeAnalysis/NullableAttributes.cs
+
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    /// <summary>Specifies that null is allowed as an input even if the corresponding type disallows it.</summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property, Inherited = false)]
+#if INTERNAL_NULLABLE_ATTRIBUTES
+    internal
+#else
+    public
+#endif
+        sealed class AllowNullAttribute : Attribute
+    { }
+
+    /// <summary>Specifies that null is disallowed as an input even if the corresponding type allows it.</summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property, Inherited = false)]
+#if INTERNAL_NULLABLE_ATTRIBUTES
+    internal
+#else
+    public
+#endif
+        sealed class DisallowNullAttribute : Attribute
+    { }
+
+    /// <summary>Specifies that an output may be null even if the corresponding type disallows it.</summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, Inherited = false)]
+#if INTERNAL_NULLABLE_ATTRIBUTES
+    internal
+#else
+    public
+#endif
+        sealed class MaybeNullAttribute : Attribute
+    { }
+
+    /// <summary>Specifies that an output will not be null even if the corresponding type allows it.</summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, Inherited = false)]
+#if INTERNAL_NULLABLE_ATTRIBUTES
+    internal
+#else
+    public
+#endif
+        sealed class NotNullAttribute : Attribute
+    { }
+
+    /// <summary>Specifies that when a method returns <see cref="ReturnValue"/>, the parameter may be null even if the corresponding type disallows it.</summary>
+    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
+#if INTERNAL_NULLABLE_ATTRIBUTES
+    internal
+#else
+    public
+#endif
+        sealed class MaybeNullWhenAttribute : Attribute
+    {
+        /// <summary>Initializes the attribute with the specified return value condition.</summary>
+        /// <param name="returnValue">
+        /// The return value condition. If the method returns this value, the associated parameter may be null.
+        /// </param>
+        public MaybeNullWhenAttribute(bool returnValue)
+        {
+            ReturnValue = returnValue;
+        }
+
+        /// <summary>Gets the return value condition.</summary>
+        public bool ReturnValue { get; }
+    }
+
+    /// <summary>Specifies that when a method returns <see cref="ReturnValue"/>, the parameter will not be null even if the corresponding type allows it.</summary>
+    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
+#if INTERNAL_NULLABLE_ATTRIBUTES
+    internal
+#else
+    public
+#endif
+        sealed class NotNullWhenAttribute : Attribute
+    {
+        /// <summary>Initializes the attribute with the specified return value condition.</summary>
+        /// <param name="returnValue">
+        /// The return value condition. If the method returns this value, the associated parameter will not be null.
+        /// </param>
+        public NotNullWhenAttribute(bool returnValue)
+        {
+            ReturnValue = returnValue;
+        }
+
+        /// <summary>Gets the return value condition.</summary>
+        public bool ReturnValue { get; }
+    }
+
+    /// <summary>Specifies that the output will be non-null if the named parameter is non-null.</summary>
+    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
+#if INTERNAL_NULLABLE_ATTRIBUTES
+    internal
+#else
+    public
+#endif
+        sealed class NotNullIfNotNullAttribute : Attribute
+    {
+        /// <summary>Initializes the attribute with the associated parameter name.</summary>
+        /// <param name="parameterName">
+        /// The associated parameter name.  The output will be non-null if the argument to the parameter specified is non-null.
+        /// </param>
+        public NotNullIfNotNullAttribute(string parameterName)
+        {
+            ParameterName = parameterName;
+        }
+
+        /// <summary>Gets the associated parameter name.</summary>
+        public string ParameterName { get; }
+    }
+
+    /// <summary>Applied to a method that will never return under any circumstance.</summary>
+    [AttributeUsage(AttributeTargets.Method, Inherited = false)]
+#if INTERNAL_NULLABLE_ATTRIBUTES
+    internal
+#else
+    public
+#endif
+        sealed class DoesNotReturnAttribute : Attribute
+    { }
+
+    /// <summary>Specifies that the method will not return if the associated Boolean parameter is passed the specified value.</summary>
+    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
+#if INTERNAL_NULLABLE_ATTRIBUTES
+    internal
+#else
+    public
+#endif
+        sealed class DoesNotReturnIfAttribute : Attribute
+    {
+        /// <summary>Initializes the attribute with the specified parameter value.</summary>
+        /// <param name="parameterValue">
+        /// The condition parameter value. Code after the method will be considered unreachable by diagnostics if the argument to
+        /// the associated parameter matches this value.
+        /// </param>
+        public DoesNotReturnIfAttribute(bool parameterValue)
+        {
+            ParameterValue = parameterValue;
+        }
+
+        /// <summary>Gets the condition parameter value.</summary>
+        public bool ParameterValue { get; }
+    }
+}
+#endif

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Helpers/NullableAttributes.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Helpers/TypeExtensions.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace Newtonsoft.Json.UnityConverters.Helpers
+{
+    internal static class TypeExtensions
+    {
+        public static IEnumerable<Type> GetLoadableTypes(this Assembly assembly)
+        {
+            try
+            {
+                return assembly.GetTypes();
+            }
+            catch (ReflectionTypeLoadException ex)
+            {
+#if DEBUG
+                Console.WriteLine("Newtonsoft.Json.UnityConverters.Helpers.TypeExtensions: "
+                    + "Failed to load some types from assembly '{assembly.FullName}'. Maybe assembly is not fully loaded yet?\n"
+                    + ex.ToString());
+#endif
+                return ex.Types.Where(t => t != null);
+            }
+        }
+
+        /// <summary>
+        /// Gets the non-public instance field info <see cref="FieldInfo"/> for the converted type
+        /// <typeparamref name="T"/>.
+        /// If not found then will throw a missing member exception <see cref="MissingMemberException"/>.
+        /// </summary>
+        /// <remarks>
+        /// If used in static initialization (ex: inside static constructor,
+        /// static field, or static property backing field initialization)
+        /// and the field does not exist it would invalidate the type for
+        /// the entirety of the programs lifetime.
+        /// </remarks>
+        /// <param name="name">Name of the non-public instance field.</param>
+        public static FieldInfo GetFieldInfoOrThrow(this Type type, string name)
+        {
+            return type.GetField(name, BindingFlags.NonPublic | BindingFlags.Instance)
+                ?? throw new MissingMemberException(type.FullName, name);
+        }
+
+        public static void SetValueDirectRef<T1, T2>(this FieldInfo field, ref T1 state, T2 value)
+        {
+#if ENABLE_IL2CPP
+            object boxed = state;
+            field.SetValue(boxed, value);
+            state = (T1)boxed;
+#else
+            TypedReference reference = __makeref(state);
+            field.SetValueDirect(reference, value);
+#endif
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Helpers/TypeExtensions.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math/Color32Converter.cs

@@ -0,0 +1,66 @@
+#region License
+// The MIT License (MIT)
+//
+// Copyright (c) 2020 Wanzyee Studio
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Math
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity byte based Color type <see cref="Color32"/>.
+    /// </summary>
+    public class Color32Converter : PartialConverter<Color32>
+    {
+        protected override void ReadValue(ref Color32 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.r):
+                    value.r = reader.ReadAsInt8() ?? 0;
+                    break;
+                case nameof(value.g):
+                    value.g = reader.ReadAsInt8() ?? 0;
+                    break;
+                case nameof(value.b):
+                    value.b = reader.ReadAsInt8() ?? 0;
+                    break;
+                case nameof(value.a):
+                    value.a = reader.ReadAsInt8() ?? 0;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, Color32 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.r));
+            writer.WriteValue(value.r);
+            writer.WritePropertyName(nameof(value.g));
+            writer.WriteValue(value.g);
+            writer.WritePropertyName(nameof(value.b));
+            writer.WriteValue(value.b);
+            writer.WritePropertyName(nameof(value.a));
+            writer.WriteValue(value.a);
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math/Color32Converter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math/ColorConverter.cs

@@ -0,0 +1,66 @@
+#region License
+// The MIT License (MIT)
+//
+// Copyright (c) 2020 Wanzyee Studio
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Math
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity Color type <see cref="Color"/>.
+    /// </summary>
+    public class ColorConverter : PartialConverter<Color>
+    {
+        protected override void ReadValue(ref Color value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.r):
+                    value.r = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.g):
+                    value.g = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.b):
+                    value.b = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.a):
+                    value.a = reader.ReadAsFloat() ?? 0f;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, Color value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.r));
+            writer.WriteValue(value.r);
+            writer.WritePropertyName(nameof(value.g));
+            writer.WriteValue(value.g);
+            writer.WritePropertyName(nameof(value.b));
+            writer.WriteValue(value.b);
+            writer.WritePropertyName(nameof(value.a));
+            writer.WriteValue(value.a);
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math/ColorConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math/Matrix4x4Converter.cs

@@ -0,0 +1,79 @@
+#region License
+// The MIT License (MIT)
+//
+// Copyright (c) 2020 Wanzyee Studio
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Math
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity Matrix4x4 type <see cref="Matrix4x4"/>.
+    /// </summary>
+    public class Matrix4x4Converter : PartialConverter<Matrix4x4>
+    {
+        // https://github.com/Unity-Technologies/UnityCsReference/blob/2019.2/Runtime/Export/Math/Matrix4x4.cs#L21-L29
+        private static readonly string[] _names = GetMemberNames();
+        private static readonly Dictionary<string, int> _namesToIndex = GetNamesToIndex(_names);
+
+        /// <summary>
+        /// Get the property names include from <c>m00</c> to <c>m33</c>.
+        /// </summary>
+        /// <returns>The property names.</returns>
+        private static string[] GetMemberNames()
+        {
+            string[] indexes = new[] { "0", "1", "2", "3" };
+            return indexes.SelectMany((row) => indexes.Select((column) => "m" + column + row)).ToArray();
+        }
+
+        // Reusing the same strings here instead of creating new ones. Tiny bit lower memory footprint
+        private static Dictionary<string, int> GetNamesToIndex(string[] names)
+        {
+            var dict = new Dictionary<string, int>();
+            for (int i = 0; i < names.Length; i++)
+            {
+                dict[names[i]] = i;
+            }
+            return dict;
+        }
+
+        protected override void ReadValue(ref Matrix4x4 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            if (_namesToIndex.TryGetValue(name, out var index))
+            {
+                value[index] = reader.ReadAsFloat() ?? 0;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, Matrix4x4 value, JsonSerializer serializer)
+        {
+            for (int i = 0; i < _names.Length; i++)
+            {
+                writer.WritePropertyName(_names[i]);
+                writer.WriteValue(value[i]);
+            }
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math/Matrix4x4Converter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math/QuaternionConverter.cs

@@ -0,0 +1,66 @@
+#region License
+// The MIT License (MIT)
+//
+// Copyright (c) 2020 Wanzyee Studio
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Math
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity Quaternion type <see cref="Quaternion"/>.
+    /// </summary>
+    public class QuaternionConverter : PartialConverter<Quaternion>
+    {
+        protected override void ReadValue(ref Quaternion value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.y):
+                    value.y = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.z):
+                    value.z = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.w):
+                    value.w = reader.ReadAsFloat() ?? 0f;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, Quaternion value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+            writer.WritePropertyName(nameof(value.z));
+            writer.WriteValue(value.z);
+            writer.WritePropertyName(nameof(value.w));
+            writer.WriteValue(value.w);
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math/QuaternionConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math/SphericalHarmonicsL2Converter.cs

@@ -0,0 +1,69 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine.Rendering;
+
+namespace Newtonsoft.Json.UnityConverters.Math
+{
+    public class SphericalHarmonicsL2Converter : PartialConverter<SphericalHarmonicsL2>
+    {
+        // Magic numbers taken from /Runtime/Export/Math/SphericalHarmonicsL2.bindings.cs
+        // inside Unitys open source repo
+        // https://github.com/Unity-Technologies/UnityCsReference/blob/2019.2/Runtime/Export/Math/SphericalHarmonicsL2.bindings.cs#L59
+        private const int COEFFICIENT_COUNT = 9;
+        private const int ARRAY_SIZE = 3 * COEFFICIENT_COUNT;
+        private static readonly (string name, int rgb, int coefficient)[] _indices = GetMemberNames();
+        private static readonly Dictionary<string, (int color, int coefficient)> _nameToIndex = GetNamesToIndexDictionary(_indices);
+
+        private static (string name, int rgb, int coefficient)[] GetMemberNames()
+        {
+            var array = new (string name, int rgb, int coefficient)[ARRAY_SIZE];
+
+            for (int i = 0; i < COEFFICIENT_COUNT; i++)
+            {
+                array[i] = ('r' + i.ToString(), 0, i);
+            }
+
+            for (int i = 0; i < COEFFICIENT_COUNT; i++)
+            {
+                array[COEFFICIENT_COUNT + i] = ('g' + i.ToString(), 1, i);
+            }
+
+            for (int i = 0; i < COEFFICIENT_COUNT; i++)
+            {
+                array[COEFFICIENT_COUNT + COEFFICIENT_COUNT + i] = ('b' + i.ToString(), 2, i);
+            }
+
+            return array;
+        }
+
+        // Reusing the same strings here instead of creating new ones. Tiny bit lower memory footprint
+        private static Dictionary<string, (int color, int coefficient)> GetNamesToIndexDictionary((string name, int rgb, int coefficient)[] indices)
+        {
+            var dict = new Dictionary<string, (int color, int coefficient)>();
+            for (int i = 0; i < indices.Length; i++)
+            {
+                (string name, int rgb, int coefficient) = indices[i];
+                dict[name] = (rgb, coefficient);
+            }
+            return dict;
+        }
+
+        protected override void ReadValue(ref SphericalHarmonicsL2 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            if (_nameToIndex.TryGetValue(name, out var index))
+            {
+                value[index.color, index.coefficient] = reader.ReadAsFloat() ?? 0f;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, SphericalHarmonicsL2 value, JsonSerializer serializer)
+        {
+            foreach (var (name, rgb, coefficient) in _indices) 
+            {
+                writer.WritePropertyName(name);
+                writer.WriteValue(value[rgb, coefficient]);
+            }
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math/SphericalHarmonicsL2Converter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math/Vector2Converter.cs

@@ -0,0 +1,56 @@
+#region License
+// The MIT License (MIT)
+//
+// Copyright (c) 2020 Wanzyee Studio
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Math
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity Vector2 type <see cref="Vector2"/>.
+    /// </summary>
+    public class Vector2Converter : PartialConverter<Vector2>
+    {
+        protected override void ReadValue(ref Vector2 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.y):
+                    value.y = reader.ReadAsFloat() ?? 0f;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, Vector2 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math/Vector2Converter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math/Vector2IntConverter.cs

@@ -0,0 +1,55 @@
+#region License
+// The MIT License (MIT)
+//
+// Copyright (c) 2020 Wanzyee Studio
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Math
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity integer Vector2 type <see cref="Vector2Int"/>.
+    /// </summary>
+    public class Vector2IntConverter : PartialConverter<Vector2Int>
+    {
+        protected override void ReadValue(ref Vector2Int value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = reader.ReadAsInt32() ?? 0;
+                    break;
+                case nameof(value.y):
+                    value.y = reader.ReadAsInt32() ?? 0;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, Vector2Int value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math/Vector2IntConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math/Vector3Converter.cs

@@ -0,0 +1,61 @@
+#region License
+// The MIT License (MIT)
+//
+// Copyright (c) 2020 Wanzyee Studio
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Math
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity Vector3 type <see cref="Vector3"/>.
+    /// </summary>
+    public class Vector3Converter : PartialConverter<Vector3>
+    {
+        protected override void ReadValue(ref Vector3 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.y):
+                    value.y = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.z):
+                    value.z = reader.ReadAsFloat() ?? 0f;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, Vector3 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+            writer.WritePropertyName(nameof(value.z));
+            writer.WriteValue(value.z);
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math/Vector3Converter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math/Vector3IntConverter.cs

@@ -0,0 +1,60 @@
+#region License
+// The MIT License (MIT)
+//
+// Copyright (c) 2020 Wanzyee Studio
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Math
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity integer Vector3 type <see cref="Vector3Int"/>.
+    /// </summary>
+    public class Vector3IntConverter : PartialConverter<Vector3Int>
+    {
+        protected override void ReadValue(ref Vector3Int value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = reader.ReadAsInt32() ?? 0;
+                    break;
+                case nameof(value.y):
+                    value.y = reader.ReadAsInt32() ?? 0;
+                    break;
+                case nameof(value.z):
+                    value.z = reader.ReadAsInt32() ?? 0;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, Vector3Int value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+            writer.WritePropertyName(nameof(value.z));
+            writer.WriteValue(value.z);
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math/Vector3IntConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math/Vector4Converter.cs

@@ -0,0 +1,66 @@
+#region License
+// The MIT License (MIT)
+//
+// Copyright (c) 2020 Wanzyee Studio
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Math
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity Vector4 type <see cref="Vector4"/>.
+    /// </summary>
+    public class Vector4Converter : PartialConverter<Vector4>
+    {
+        protected override void ReadValue(ref Vector4 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.y):
+                    value.y = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.z):
+                    value.z = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.w):
+                    value.w = reader.ReadAsFloat() ?? 0f;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, Vector4 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+            writer.WritePropertyName(nameof(value.z));
+            writer.WriteValue(value.z);
+            writer.WritePropertyName(nameof(value.w));
+            writer.WriteValue(value.w);
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Math/Vector4Converter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Mathematics.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Mathematics/BoolConverters.cs

@@ -0,0 +1,100 @@
+using Unity.Mathematics;
+
+namespace Newtonsoft.Json.UnityConverters.Mathematics
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity.Mathematics <see cref="bool2"/> type.
+    /// </summary>
+    public class Bool2Converter : PartialConverter<bool2>
+    {
+        protected override void ReadValue(ref bool2 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = reader.ReadAsBoolean() ?? false;
+                    break;
+                case nameof(value.y):
+                    value.y = reader.ReadAsBoolean() ?? false;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, bool2 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+        }
+    }
+
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity.Mathematics <see cref="bool3"/> type.
+    /// </summary>
+    public class Bool3Converter : PartialConverter<bool3>
+    {
+        protected override void ReadValue(ref bool3 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = reader.ReadAsBoolean() ?? false;
+                    break;
+                case nameof(value.y):
+                    value.y = reader.ReadAsBoolean() ?? false;
+                    break;
+                case nameof(value.z):
+                    value.z = reader.ReadAsBoolean() ?? false;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, bool3 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+            writer.WritePropertyName(nameof(value.z));
+            writer.WriteValue(value.z);
+        }
+    }
+
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity.Mathematics <see cref="bool4"/> type.
+    /// </summary>
+    public class Bool4Converter : PartialConverter<bool4>
+    {
+        protected override void ReadValue(ref bool4 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = reader.ReadAsBoolean() ?? false;
+                    break;
+                case nameof(value.y):
+                    value.y = reader.ReadAsBoolean() ?? false;
+                    break;
+                case nameof(value.z):
+                    value.z = reader.ReadAsBoolean() ?? false;
+                    break;
+                case nameof(value.w):
+                    value.w = reader.ReadAsBoolean() ?? false;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, bool4 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+            writer.WritePropertyName(nameof(value.z));
+            writer.WriteValue(value.z);
+            writer.WritePropertyName(nameof(value.w));
+            writer.WriteValue(value.w);
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Mathematics/BoolConverters.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Mathematics/DoubleConverters.cs

@@ -0,0 +1,101 @@
+using Newtonsoft.Json.UnityConverters.Helpers;
+using Unity.Mathematics;
+
+namespace Newtonsoft.Json.UnityConverters.Mathematics
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity.Mathematics <see cref="double2"/> type.
+    /// </summary>
+    public class Double2Converter : PartialConverter<double2>
+    {
+        protected override void ReadValue(ref double2 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = reader.ReadAsDouble() ?? 0f;
+                    break;
+                case nameof(value.y):
+                    value.y = reader.ReadAsDouble() ?? 0f;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, double2 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+        }
+    }
+
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity.Mathematics <see cref="double3"/> type.
+    /// </summary>
+    public class Double3Converter : PartialConverter<double3>
+    {
+        protected override void ReadValue(ref double3 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = reader.ReadAsDouble() ?? 0f;
+                    break;
+                case nameof(value.y):
+                    value.y = reader.ReadAsDouble() ?? 0f;
+                    break;
+                case nameof(value.z):
+                    value.z = reader.ReadAsDouble() ?? 0f;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, double3 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+            writer.WritePropertyName(nameof(value.z));
+            writer.WriteValue(value.z);
+        }
+    }
+
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity.Mathematics <see cref="double4"/> type.
+    /// </summary>
+    public class Double4Converter : PartialConverter<double4>
+    {
+        protected override void ReadValue(ref double4 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = reader.ReadAsDouble() ?? 0f;
+                    break;
+                case nameof(value.y):
+                    value.y = reader.ReadAsDouble() ?? 0f;
+                    break;
+                case nameof(value.z):
+                    value.z = reader.ReadAsDouble() ?? 0f;
+                    break;
+                case nameof(value.w):
+                    value.w = reader.ReadAsDouble() ?? 0f;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, double4 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+            writer.WritePropertyName(nameof(value.z));
+            writer.WriteValue(value.z);
+            writer.WritePropertyName(nameof(value.w));
+            writer.WriteValue(value.w);
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Mathematics/DoubleConverters.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Mathematics/FloatConverters.cs

@@ -0,0 +1,101 @@
+using Newtonsoft.Json.UnityConverters.Helpers;
+using Unity.Mathematics;
+
+namespace Newtonsoft.Json.UnityConverters.Mathematics
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity.Mathematics <see cref="float2"/> type.
+    /// </summary>
+    public class Float2Converter : PartialConverter<float2>
+    {
+        protected override void ReadValue(ref float2 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.y):
+                    value.y = reader.ReadAsFloat() ?? 0f;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, float2 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+        }
+    }
+
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity.Mathematics <see cref="float3"/> type.
+    /// </summary>
+    public class Float3Converter : PartialConverter<float3>
+    {
+        protected override void ReadValue(ref float3 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.y):
+                    value.y = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.z):
+                    value.z = reader.ReadAsFloat() ?? 0f;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, float3 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+            writer.WritePropertyName(nameof(value.z));
+            writer.WriteValue(value.z);
+        }
+    }
+
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity.Mathematics <see cref="float4"/> type.
+    /// </summary>
+    public class Float4Converter : PartialConverter<float4>
+    {
+        protected override void ReadValue(ref float4 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.y):
+                    value.y = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.z):
+                    value.z = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.w):
+                    value.w = reader.ReadAsFloat() ?? 0f;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, float4 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+            writer.WritePropertyName(nameof(value.z));
+            writer.WriteValue(value.z);
+            writer.WritePropertyName(nameof(value.w));
+            writer.WriteValue(value.w);
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Mathematics/FloatConverters.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Mathematics/HalfConverters.cs

@@ -0,0 +1,119 @@
+using System;
+using System.Globalization;
+using Newtonsoft.Json.UnityConverters.Helpers;
+using Unity.Mathematics;
+
+namespace Newtonsoft.Json.UnityConverters.Mathematics
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity.Mathematics <see cref="half"/> type.
+    /// </summary>
+    public class HalfConverter : PartialConverter<half>
+    {
+        protected override void ReadValue(ref half value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            value = new half((double)reader.Value);
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, half value, JsonSerializer serializer)
+        {
+            writer.WriteValue(value);
+        }
+    }
+
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity.Mathematics <see cref="half2"/> type.
+    /// </summary>
+    public class Half2Converter : PartialConverter<half2>
+    {
+        protected override void ReadValue(ref half2 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = new half(reader.ReadAsFloat() ?? 0f);
+                    break;
+                case nameof(value.y):
+                    value.y = new half(reader.ReadAsFloat() ?? 0f);
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, half2 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+        }
+    }
+
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity.Mathematics <see cref="half3"/> type.
+    /// </summary>
+    public class Half3Converter : PartialConverter<half3>
+    {
+        protected override void ReadValue(ref half3 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = new half(reader.ReadAsFloat() ?? 0f);
+                    break;
+                case nameof(value.y):
+                    value.y = new half(reader.ReadAsFloat() ?? 0f);
+                    break;
+                case nameof(value.z):
+                    value.z = new half(reader.ReadAsFloat() ?? 0f);
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, half3 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+            writer.WritePropertyName(nameof(value.z));
+            writer.WriteValue(value.z);
+        }
+    }
+
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity.Mathematics <see cref="half4"/> type.
+    /// </summary>
+    public class Half4Converter : PartialConverter<half4>
+    {
+        protected override void ReadValue(ref half4 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = new half(reader.ReadAsFloat() ?? 0f);
+                    break;
+                case nameof(value.y):
+                    value.y = new half(reader.ReadAsFloat() ?? 0f);
+                    break;
+                case nameof(value.z):
+                    value.z = new half(reader.ReadAsFloat() ?? 0f);
+                    break;
+                case nameof(value.w):
+                    value.w = new half(reader.ReadAsFloat() ?? 0f);
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, half4 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+            writer.WritePropertyName(nameof(value.z));
+            writer.WriteValue(value.z);
+            writer.WritePropertyName(nameof(value.w));
+            writer.WriteValue(value.w);
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Mathematics/HalfConverters.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Mathematics/IntConverters.cs

@@ -0,0 +1,100 @@
+using Unity.Mathematics;
+
+namespace Newtonsoft.Json.UnityConverters.Mathematics
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity.Mathematics <see cref="int2"/> type.
+    /// </summary>
+    public class Int2Converter : PartialConverter<int2>
+    {
+        protected override void ReadValue(ref int2 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = reader.ReadAsInt32() ?? 0;
+                    break;
+                case nameof(value.y):
+                    value.y = reader.ReadAsInt32() ?? 0;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, int2 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+        }
+    }
+
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity.Mathematics <see cref="int3"/> type.
+    /// </summary>
+    public class Int3Converter : PartialConverter<int3>
+    {
+        protected override void ReadValue(ref int3 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = reader.ReadAsInt32() ?? 0;
+                    break;
+                case nameof(value.y):
+                    value.y = reader.ReadAsInt32() ?? 0;
+                    break;
+                case nameof(value.z):
+                    value.z = reader.ReadAsInt32() ?? 0;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, int3 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+            writer.WritePropertyName(nameof(value.z));
+            writer.WriteValue(value.z);
+        }
+    }
+
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity.Mathematics <see cref="int4"/> type.
+    /// </summary>
+    public class Int4Converter : PartialConverter<int4>
+    {
+        protected override void ReadValue(ref int4 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = reader.ReadAsInt32() ?? 0;
+                    break;
+                case nameof(value.y):
+                    value.y = reader.ReadAsInt32() ?? 0;
+                    break;
+                case nameof(value.z):
+                    value.z = reader.ReadAsInt32() ?? 0;
+                    break;
+                case nameof(value.w):
+                    value.w = reader.ReadAsInt32() ?? 0;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, int4 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+            writer.WritePropertyName(nameof(value.z));
+            writer.WriteValue(value.z);
+            writer.WritePropertyName(nameof(value.w));
+            writer.WriteValue(value.w);
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Mathematics/IntConverters.cs.meta

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

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

@@ -0,0 +1,24 @@
+{
+    "name": "Newtonsoft.Json.UnityConverters.Mathematics",
+    "references": [
+        "Unity.Mathematics",
+        "Newtonsoft.Json.UnityConverters"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [
+        "HAVE_MODULE_MATHEMATICS"
+    ],
+    "versionDefines": [
+        {
+            "name": "com.unity.mathematics",
+            "expression": "",
+            "define": "HAVE_MODULE_MATHEMATICS"
+        }
+    ],
+    "noEngineReferences": false
+}

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

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Mathematics/QuaternionConverter.cs

@@ -0,0 +1,66 @@
+#region License
+// The MIT License (MIT)
+//
+// Copyright (c) 2020 Wanzyee Studio
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+using Newtonsoft.Json.UnityConverters.Helpers;
+using Unity.Mathematics;
+
+namespace Newtonsoft.Json.UnityConverters.Mathematics
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity.Mathematics type <see cref="quaternion"/>.
+    /// </summary>
+    public class QuaternionConverter : PartialConverter<quaternion>
+    {
+        protected override void ReadValue(ref quaternion value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.value.x):
+                    value.value.x = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.value.y):
+                    value.value.y = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.value.z):
+                    value.value.z = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.value.w):
+                    value.value.w = reader.ReadAsFloat() ?? 0f;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, quaternion value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.value.x));
+            writer.WriteValue(value.value.x);
+            writer.WritePropertyName(nameof(value.value.y));
+            writer.WriteValue(value.value.y);
+            writer.WritePropertyName(nameof(value.value.z));
+            writer.WriteValue(value.value.z);
+            writer.WritePropertyName(nameof(value.value.w));
+            writer.WriteValue(value.value.w);
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Mathematics/QuaternionConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Mathematics/UintConverters.cs

@@ -0,0 +1,100 @@
+using Unity.Mathematics;
+
+namespace Newtonsoft.Json.UnityConverters.Mathematics
+{
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity.Mathematics <see cref="uint2"/> type.
+    /// </summary>
+    public class Uint2Converter : PartialConverter<uint2>
+    {
+        protected override void ReadValue(ref uint2 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = (uint)(reader.ReadAsInt32() ?? 0);
+                    break;
+                case nameof(value.y):
+                    value.y = (uint)(reader.ReadAsInt32() ?? 0);
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, uint2 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+        }
+    }
+
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity.Mathematics <see cref="uint3"/> type.
+    /// </summary>
+    public class Uint3Converter : PartialConverter<uint3>
+    {
+        protected override void ReadValue(ref uint3 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = (uint)(reader.ReadAsInt32() ?? 0);
+                    break;
+                case nameof(value.y):
+                    value.y = (uint)(reader.ReadAsInt32() ?? 0);
+                    break;
+                case nameof(value.z):
+                    value.z = (uint)(reader.ReadAsInt32() ?? 0);
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, uint3 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+            writer.WritePropertyName(nameof(value.z));
+            writer.WriteValue(value.z);
+        }
+    }
+
+    /// <summary>
+    /// Custom Newtonsoft.Json converter <see cref="JsonConverter"/> for the Unity.Mathematics <see cref="uint4"/> type.
+    /// </summary>
+    public class Uint4Converter : PartialConverter<uint4>
+    {
+        protected override void ReadValue(ref uint4 value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.x):
+                    value.x = (uint)(reader.ReadAsInt32() ?? 0);
+                    break;
+                case nameof(value.y):
+                    value.y = (uint)(reader.ReadAsInt32() ?? 0);
+                    break;
+                case nameof(value.z):
+                    value.z = (uint)(reader.ReadAsInt32() ?? 0);
+                    break;
+                case nameof(value.w):
+                    value.w = (uint)(reader.ReadAsInt32() ?? 0);
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, uint4 value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.x));
+            writer.WriteValue(value.x);
+            writer.WritePropertyName(nameof(value.y));
+            writer.WriteValue(value.y);
+            writer.WritePropertyName(nameof(value.z));
+            writer.WriteValue(value.z);
+            writer.WritePropertyName(nameof(value.w));
+            writer.WriteValue(value.w);
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Mathematics/UintConverters.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/NativeArray.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/NativeArray/NativeArrayConverter.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections;
+using System.Diagnostics.CodeAnalysis;
+using Newtonsoft.Json.UnityConverters.Helpers;
+using Unity.Collections;
+
+namespace Newtonsoft.Json.UnityConverters.NativeArray
+{
+    public class NativeArrayConverter : JsonConverter
+    {
+        public override void WriteJson(JsonWriter writer, [AllowNull] object value, JsonSerializer serializer)
+        {
+            if (value is null)
+            {
+                writer.WriteNull();
+                return;
+            }
+
+            var enumerable = (IEnumerable)value;
+            writer.WriteStartArray();
+            foreach (object item in enumerable)
+            {
+                serializer.Serialize(writer, item);
+            }
+            writer.WriteEndArray();
+        }
+
+        [return: MaybeNull]
+        public override object ReadJson(JsonReader reader, Type objectType, [AllowNull] object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                return null;
+            }
+
+            throw reader.CreateSerializationException(
+                "Deserializing NativeArray<> and NativeSlice<> is disabled to not cause accidental memory leaks. Use regular List<> or array types instead in your JSON models. Due to technical limitations, we cannot even populate existing NativeArray<> or NativeSlice<> values. You simply have to use other collection types."
+            );
+        }
+
+        public override bool CanConvert(Type objectType)
+        {
+            if (objectType.IsGenericType)
+            {
+                Type genericTypeDefinition = objectType.GetGenericTypeDefinition();
+                return genericTypeDefinition == typeof(NativeArray<>)
+                    || genericTypeDefinition == typeof(NativeSlice<>);
+            }
+            else
+            {
+                return false;
+            }
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/NativeArray/NativeArrayConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/PartialConverter.cs

@@ -0,0 +1,142 @@
+#region License
+// The MIT License (MIT)
+//
+// Copyright (c) 2020 Wanzyee Studio
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using Newtonsoft.Json.UnityConverters.Helpers;
+
+namespace Newtonsoft.Json.UnityConverters
+{
+    /// <summary>
+    /// Custom base <c>Newtonsoft.Json.JsonConverter</c> to filter serialized properties.
+    /// </summary>
+    public abstract class PartialConverter<T> : JsonConverter
+        where T : new()
+    {
+        protected abstract void ReadValue(ref T value, string name, JsonReader reader, JsonSerializer serializer);
+
+        protected abstract void WriteJsonProperties(JsonWriter writer, T value, JsonSerializer serializer);
+
+        /// <summary>
+        /// Determine if the object type is <typeparamref name="T"/>
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns><c>true</c> if this can convert the specified type; otherwise, <c>false</c>.</returns>
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType == typeof(T)
+                || (objectType.IsGenericType
+                    && objectType.GetGenericTypeDefinition() == typeof(Nullable<>)
+                    && objectType.GenericTypeArguments[0] == typeof(T));
+        }
+
+        /// <summary>
+        /// Read the specified properties to the object.
+        /// </summary>
+        /// <returns>The object value.</returns>
+        /// <param name="reader">The <c>Newtonsoft.Json.JsonReader</c> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        [return: MaybeNull]
+        public override object ReadJson(
+            JsonReader reader,
+            Type objectType,
+            [AllowNull] object existingValue,
+            JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                bool isNullableStruct = objectType.IsGenericType
+                    && objectType.GetGenericTypeDefinition() == typeof(Nullable<>);
+
+                return isNullableStruct ? null : (object)default(T);
+            }
+
+            return InternalReadJson(reader, serializer, existingValue);
+        }
+
+        [return: MaybeNull]
+        private T InternalReadJson(JsonReader reader, JsonSerializer serializer, [AllowNull] object existingValue)
+        {
+            if (reader.TokenType != JsonToken.StartObject)
+            {
+                throw reader.CreateSerializationException($"Failed to read type '{typeof(T).Name}'. Expected object start, got '{reader.TokenType}' <{reader.Value}>");
+            }
+
+            reader.Read();
+
+            if (!(existingValue is T value))
+            {
+                value = new T();
+            }
+            
+            string previousName = null;
+            
+            while (reader.TokenType == JsonToken.PropertyName)
+            {
+                if (reader.Value is string name)
+                {
+                    if (name == previousName)
+                    {
+                        throw reader.CreateSerializationException($"Failed to read type '{typeof(T).Name}'. Possible loop when reading property '{name}'");
+                    }
+                    
+                    previousName = name;
+                    ReadValue(ref value, name, reader, serializer);
+                }
+                else
+                {
+                    reader.Skip();
+                }
+
+                reader.Read();
+            }
+
+            return value;
+        }
+
+        /// <summary>
+        /// Write the specified properties of the object.
+        /// </summary>
+        /// <param name="writer">The <c>Newtonsoft.Json.JsonWriter</c> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, [AllowNull] object value, JsonSerializer serializer)
+        {
+            if (value == null)
+            {
+                writer.WriteNull();
+                return;
+            }
+
+            writer.WriteStartObject();
+
+            var typed = (T)value;
+            WriteJsonProperties(writer, typed, serializer);
+
+            writer.WriteEndObject();
+        }
+    }
+}

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/PartialConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Physics.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Physics/JointDriveConverter.cs

@@ -0,0 +1,36 @@
+#if HAVE_MODULE_PHYSICS || !UNITY_2019_1_OR_NEWER
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Physics
+{
+    public class JointDriveConverter : PartialConverter<JointDrive>
+    {
+        protected override void ReadValue(ref JointDrive value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.positionSpring):
+                    value.positionSpring = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.positionDamper):
+                    value.positionDamper = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.maximumForce):
+                    value.maximumForce = reader.ReadAsFloat() ?? 0f;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, JointDrive value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.positionSpring));
+            writer.WriteValue(value.positionSpring);
+            writer.WritePropertyName(nameof(value.positionDamper));
+            writer.WriteValue(value.positionDamper);
+            writer.WritePropertyName(nameof(value.maximumForce));
+            writer.WriteValue(value.maximumForce);
+        }
+    }
+}
+#endif

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Physics/JointDriveConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Physics/JointLimitsConverter.cs

@@ -0,0 +1,46 @@
+#if HAVE_MODULE_PHYSICS || !UNITY_2019_1_OR_NEWER
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Physics
+{
+    public class JointLimitsConverter : PartialConverter<JointLimits>
+    {
+        protected override void ReadValue(ref JointLimits value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.min):
+                    value.min = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.max):
+                    value.max = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.bounciness):
+                    value.bounciness = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.bounceMinVelocity):
+                    value.bounceMinVelocity = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.contactDistance):
+                    value.contactDistance = reader.ReadAsFloat() ?? 0f;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, JointLimits value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.min));
+            writer.WriteValue(value.min);
+            writer.WritePropertyName(nameof(value.max));
+            writer.WriteValue(value.max);
+            writer.WritePropertyName(nameof(value.bounciness));
+            writer.WriteValue(value.bounciness);
+            writer.WritePropertyName(nameof(value.bounceMinVelocity));
+            writer.WriteValue(value.bounceMinVelocity);
+            writer.WritePropertyName(nameof(value.contactDistance));
+            writer.WriteValue(value.contactDistance);
+        }
+    }
+}
+#endif

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Physics/JointLimitsConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Physics/SoftJointLimitConverter.cs

@@ -0,0 +1,36 @@
+#if HAVE_MODULE_PHYSICS || !UNITY_2019_1_OR_NEWER
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Physics
+{
+    public class SoftJointLimitConverter : PartialConverter<SoftJointLimit>
+    {
+        protected override void ReadValue(ref SoftJointLimit value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+                case nameof(value.limit):
+                    value.limit = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.bounciness):
+                    value.bounciness = reader.ReadAsFloat() ?? 0f;
+                    break;
+                case nameof(value.contactDistance):
+                    value.contactDistance = reader.ReadAsFloat() ?? 0f;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, SoftJointLimit value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.limit));
+            writer.WriteValue(value.limit);
+            writer.WritePropertyName(nameof(value.bounciness));
+            writer.WriteValue(value.bounciness);
+            writer.WritePropertyName(nameof(value.contactDistance));
+            writer.WriteValue(value.contactDistance);
+        }
+    }
+}
+#endif

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Physics/SoftJointLimitConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Physics2D.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Physics2D/ColliderDistance2DConverter.cs

@@ -0,0 +1,50 @@
+#if HAVE_MODULE_PHYSICS2D || !UNITY_2019_1_OR_NEWER
+using System;
+using System.Reflection;
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Physics2D
+{
+    public class ColliderDistance2DConverter : PartialConverter<ColliderDistance2D>
+    {
+        private static readonly FieldInfo _normalField = typeof(ColliderDistance2D).GetFieldInfoOrThrow("m_Normal");
+
+        protected override void ReadValue(ref ColliderDistance2D value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch(name)
+            {
+                case nameof(value.pointA):
+                    value.pointA = reader.ReadViaSerializer<Vector2>(serializer);
+                    break;
+                case nameof(value.pointB):
+                    value.pointB = reader.ReadViaSerializer<Vector2>(serializer);
+                    break;
+                case nameof(value.normal):
+                    _normalField.SetValueDirectRef(ref value, reader.ReadViaSerializer<Vector2>(serializer));
+                    break;
+                case nameof(value.distance):
+                    value.distance = reader.ReadAsFloat() ?? 0;
+                    break;
+                case nameof(value.isValid):
+                    value.isValid = reader.ReadAsBoolean() ?? false;
+                    break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, ColliderDistance2D value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.pointA));
+            serializer.Serialize(writer, value.pointA, typeof(Vector2));
+            writer.WritePropertyName(nameof(value.pointB));
+            serializer.Serialize(writer, value.pointB, typeof(Vector2));
+            writer.WritePropertyName(nameof(value.normal));
+            serializer.Serialize(writer, value.normal, typeof(Vector2));
+            writer.WritePropertyName(nameof(value.distance));
+            writer.WriteValue(value.distance);
+            writer.WritePropertyName(nameof(value.isValid));
+            writer.WriteValue(value.isValid);
+        }
+    }
+}
+#endif

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Physics2D/ColliderDistance2DConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Physics2D/ContactFilter2DConverter.cs

@@ -0,0 +1,79 @@
+#if HAVE_MODULE_PHYSICS2D || !UNITY_2019_1_OR_NEWER
+using System;
+using Newtonsoft.Json.UnityConverters.Helpers;
+using UnityEngine;
+
+namespace Newtonsoft.Json.UnityConverters.Physics2D
+{
+    public class ContactFilter2DConverter : PartialConverter<ContactFilter2D>
+    {
+        protected override void ReadValue(ref ContactFilter2D value, string name, JsonReader reader, JsonSerializer serializer)
+        {
+            switch (name)
+            {
+            case nameof(value.useTriggers):
+                value.useTriggers = reader.ReadAsBoolean() ?? false;
+                break;
+            case nameof(value.useLayerMask):
+                value.useLayerMask = reader.ReadAsBoolean() ?? false;
+                break;
+            case nameof(value.useDepth):
+                value.useDepth = reader.ReadAsBoolean() ?? false;
+                break;
+            case nameof(value.useOutsideDepth):
+                value.useOutsideDepth = reader.ReadAsBoolean() ?? false;
+                break;
+            case nameof(value.useNormalAngle):
+                value.useNormalAngle = reader.ReadAsBoolean() ?? false;
+                break;
+            case nameof(value.useOutsideNormalAngle):
+                value.useOutsideNormalAngle = reader.ReadAsBoolean() ?? false;
+                break;
+
+            case nameof(value.layerMask):
+                value.layerMask = reader.ReadViaSerializer<LayerMask>(serializer);
+                break;
+
+            case nameof(value.minDepth):
+                value.minDepth = reader.ReadAsFloat() ?? 0f;
+                break;
+            case nameof(value.maxDepth):
+                value.maxDepth = reader.ReadAsFloat() ?? 0f;
+                break;
+            case nameof(value.minNormalAngle):
+                value.minNormalAngle = reader.ReadAsFloat() ?? 0f;
+                break;
+            case nameof(value.maxNormalAngle):
+                value.maxNormalAngle = reader.ReadAsFloat() ?? 0f;
+                break;
+            }
+        }
+
+        protected override void WriteJsonProperties(JsonWriter writer, ContactFilter2D value, JsonSerializer serializer)
+        {
+            writer.WritePropertyName(nameof(value.useTriggers));
+            writer.WriteValue(value.useTriggers);
+            writer.WritePropertyName(nameof(value.useLayerMask));
+            writer.WriteValue(value.useLayerMask);
+            writer.WritePropertyName(nameof(value.useDepth));
+            writer.WriteValue(value.useDepth);
+            writer.WritePropertyName(nameof(value.useOutsideDepth));
+            writer.WriteValue(value.useOutsideDepth);
+            writer.WritePropertyName(nameof(value.useNormalAngle));
+            writer.WriteValue(value.useNormalAngle);
+            writer.WritePropertyName(nameof(value.useOutsideNormalAngle));
+            writer.WriteValue(value.useOutsideNormalAngle);
+            writer.WritePropertyName(nameof(value.layerMask));
+            serializer.Serialize(writer, value.layerMask, typeof(LayerMask));
+            writer.WritePropertyName(nameof(value.minDepth));
+            writer.WriteValue(value.minDepth);
+            writer.WritePropertyName(nameof(value.maxDepth));
+            writer.WriteValue(value.maxDepth);
+            writer.WritePropertyName(nameof(value.minNormalAngle));
+            writer.WriteValue(value.minNormalAngle);
+            writer.WritePropertyName(nameof(value.maxNormalAngle));
+            writer.WriteValue(value.maxNormalAngle);
+        }
+    }
+}
+#endif

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Physics2D/ContactFilter2DConverter.cs.meta

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

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/Random.meta

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