com.wallstop-studios.unity-helpers 2.0.0-rc49 → 2.0.0-rc50

package/Runtime/Core/Serialization/JsonConverters/ColorConverter.cs

@@ -0,0 +1,88 @@
+namespace UnityHelpers.Core.Serialization.JsonConverters
+{
+    using System;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+    using UnityEngine;
+
+    public sealed class ColorConverter : JsonConverter<Color>
+    {
+        public static readonly ColorConverter Instance = new();
+
+        private ColorConverter() { }
+
+        public override Color Read(
+            ref Utf8JsonReader reader,
+            Type typeToConvert,
+            JsonSerializerOptions options
+        )
+        {
+            if (reader.TokenType != JsonTokenType.StartObject)
+            {
+                throw new JsonException($"Invalid token type {reader.TokenType}");
+            }
+
+            float r = 0;
+            float g = 0;
+            float b = 0;
+            float a = 1;
+
+            while (reader.Read())
+            {
+                if (reader.TokenType == JsonTokenType.EndObject)
+                {
+                    return new Color(r, g, b, a);
+                }
+
+                if (reader.TokenType == JsonTokenType.PropertyName)
+                {
+                    string propertyName = reader.GetString();
+                    reader.Read();
+                    switch (propertyName)
+                    {
+                        case "r":
+                        {
+                            r = reader.GetSingle();
+                            break;
+                        }
+                        case "g":
+                        {
+                            g = reader.GetSingle();
+                            break;
+                        }
+                        case "b":
+                        {
+                            b = reader.GetSingle();
+                            break;
+                        }
+                        case "a":
+                        {
+                            a = reader.GetSingle();
+                            break;
+                        }
+                        default:
+                        {
+                            throw new JsonException($"Unknown property: {propertyName}");
+                        }
+                    }
+                }
+            }
+
+            throw new JsonException("Incomplete JSON for Color");
+        }
+
+        public override void Write(
+            Utf8JsonWriter writer,
+            Color value,
+            JsonSerializerOptions options
+        )
+        {
+            writer.WriteStartObject();
+            writer.WriteNumber("r", value.r);
+            writer.WriteNumber("g", value.g);
+            writer.WriteNumber("b", value.b);
+            writer.WriteNumber("a", value.a);
+            writer.WriteEndObject();
+        }
+    }
+}

package/Runtime/Core/Serialization/JsonConverters/ColorConverter.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 637013e97e6d436a880092e239d12e4e
+timeCreated: 1743567974

package/Runtime/Core/Serialization/JsonConverters/GameObjectConverter.cs

@@ -0,0 +1,37 @@
+namespace UnityHelpers.Core.Serialization.JsonConverters
+{
+    using System;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+    using UnityEngine;
+    using Object = UnityEngine.Object;
+
+    public sealed class GameObjectConverter : JsonConverter<GameObject>
+    {
+        public static readonly GameObjectConverter Instance = new();
+
+        private GameObjectConverter() { }
+
+        public override GameObject Read(
+            ref Utf8JsonReader reader,
+            Type typeToConvert,
+            JsonSerializerOptions options
+        )
+        {
+            throw new NotImplementedException(nameof(Read));
+        }
+
+        public override void Write(
+            Utf8JsonWriter writer,
+            GameObject value,
+            JsonSerializerOptions options
+        )
+        {
+            writer.WriteStringValue(
+                value == null
+                    ? "{}"
+                    : new { name = value.name, type = value.GetType().FullName }.ToString()
+            );
+        }
+    }
+}

package/Runtime/Core/Serialization/JsonConverters/GameObjectConverter.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6c12adc5c56c4be9bb536628749979b0
+timeCreated: 1743567258

package/Runtime/Core/Serialization/JsonConverters/Matrix4x4Converter.cs

@@ -0,0 +1,218 @@
+namespace UnityHelpers.Core.Serialization.JsonConverters
+{
+    using System;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+    using UnityEngine;
+
+    public sealed class Matrix4x4Converter : JsonConverter<Matrix4x4>
+    {
+        private static readonly string[] PropertyNames =
+        {
+            "m00",
+            "m01",
+            "m02",
+            "m03",
+            "m10",
+            "m11",
+            "m12",
+            "m13",
+            "m20",
+            "m21",
+            "m22",
+            "m23",
+            "m30",
+            "m31",
+            "m32",
+            "m33",
+        };
+
+        public static readonly Matrix4x4Converter Instance = new();
+
+        private Matrix4x4Converter() { }
+
+        public override Matrix4x4 Read(
+            ref Utf8JsonReader reader,
+            Type typeToConvert,
+            JsonSerializerOptions options
+        )
+        {
+            if (reader.TokenType != JsonTokenType.StartObject)
+            {
+                throw new JsonException("Expected StartObject token when parsing Matrix4x4.");
+            }
+
+            float m00 = 0;
+            float m01 = 0;
+            float m02 = 0;
+            float m03 = 0;
+            float m10 = 0;
+            float m11 = 0;
+            float m12 = 0;
+            float m13 = 0;
+            float m20 = 0;
+            float m21 = 0;
+            float m22 = 0;
+            float m23 = 0;
+            float m30 = 0;
+            float m31 = 0;
+            float m32 = 0;
+            float m33 = 0;
+
+            bool[] found = new bool[16];
+
+            while (reader.Read())
+            {
+                if (reader.TokenType == JsonTokenType.EndObject)
+                {
+                    break;
+                }
+                if (reader.TokenType != JsonTokenType.PropertyName)
+                {
+                    throw new JsonException("Expected property name in Matrix4x4 JSON.");
+                }
+                string propertyName = reader.GetString();
+                if (!reader.Read())
+                {
+                    throw new JsonException($"Expected value for property '{propertyName}'.");
+                }
+                float value;
+                try
+                {
+                    value = reader.GetSingle();
+                }
+                catch (Exception ex)
+                {
+                    throw new JsonException($"Invalid value for property '{propertyName}'.", ex);
+                }
+                switch (propertyName)
+                {
+                    case "m00":
+                        m00 = value;
+                        found[0] = true;
+                        break;
+                    case "m01":
+                        m01 = value;
+                        found[1] = true;
+                        break;
+                    case "m02":
+                        m02 = value;
+                        found[2] = true;
+                        break;
+                    case "m03":
+                        m03 = value;
+                        found[3] = true;
+                        break;
+                    case "m10":
+                        m10 = value;
+                        found[4] = true;
+                        break;
+                    case "m11":
+                        m11 = value;
+                        found[5] = true;
+                        break;
+                    case "m12":
+                        m12 = value;
+                        found[6] = true;
+                        break;
+                    case "m13":
+                        m13 = value;
+                        found[7] = true;
+                        break;
+                    case "m20":
+                        m20 = value;
+                        found[8] = true;
+                        break;
+                    case "m21":
+                        m21 = value;
+                        found[9] = true;
+                        break;
+                    case "m22":
+                        m22 = value;
+                        found[10] = true;
+                        break;
+                    case "m23":
+                        m23 = value;
+                        found[11] = true;
+                        break;
+                    case "m30":
+                        m30 = value;
+                        found[12] = true;
+                        break;
+                    case "m31":
+                        m31 = value;
+                        found[13] = true;
+                        break;
+                    case "m32":
+                        m32 = value;
+                        found[14] = true;
+                        break;
+                    case "m33":
+                        m33 = value;
+                        found[15] = true;
+                        break;
+                }
+            }
+
+            for (int i = 0; i < found.Length; i++)
+            {
+                if (!found[i])
+                {
+                    throw new JsonException(
+                        $"Missing property '{PropertyNames[i]}' for Matrix4x4."
+                    );
+                }
+            }
+
+            Matrix4x4 matrix = new()
+            {
+                m00 = m00,
+                m01 = m01,
+                m02 = m02,
+                m03 = m03,
+                m10 = m10,
+                m11 = m11,
+                m12 = m12,
+                m13 = m13,
+                m20 = m20,
+                m21 = m21,
+                m22 = m22,
+                m23 = m23,
+                m30 = m30,
+                m31 = m31,
+                m32 = m32,
+                m33 = m33,
+            };
+
+            return matrix;
+        }
+
+        public override void Write(
+            Utf8JsonWriter writer,
+            Matrix4x4 matrix,
+            JsonSerializerOptions options
+        )
+        {
+            writer.WriteStartObject();
+
+            writer.WriteNumber("m00", matrix.m00);
+            writer.WriteNumber("m01", matrix.m01);
+            writer.WriteNumber("m02", matrix.m02);
+            writer.WriteNumber("m03", matrix.m03);
+            writer.WriteNumber("m10", matrix.m10);
+            writer.WriteNumber("m11", matrix.m11);
+            writer.WriteNumber("m12", matrix.m12);
+            writer.WriteNumber("m13", matrix.m13);
+            writer.WriteNumber("m20", matrix.m20);
+            writer.WriteNumber("m21", matrix.m21);
+            writer.WriteNumber("m22", matrix.m22);
+            writer.WriteNumber("m23", matrix.m23);
+            writer.WriteNumber("m30", matrix.m30);
+            writer.WriteNumber("m31", matrix.m31);
+            writer.WriteNumber("m32", matrix.m32);
+            writer.WriteNumber("m33", matrix.m33);
+
+            writer.WriteEndObject();
+        }
+    }
+}

package/Runtime/Core/Serialization/JsonConverters/Matrix4x4Converter.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 456d0090c1d744de924e8f18a895b87b
+timeCreated: 1743568330

package/Runtime/Core/Serialization/JsonConverters/Vector2Converter.cs

@@ -22,8 +22,8 @@
                 throw new JsonException($"Invalid token type {reader.TokenType}");
             }
 
-            float x = 0,
-                y = 0;
+            float x = 0;
+            float y = 0;
 
             while (reader.Read())
             {

package/Runtime/Core/Serialization/JsonConverters/Vector3Converter.cs

@@ -22,9 +22,9 @@
                 throw new JsonException($"Invalid token type {reader.TokenType}");
             }
 
-            float x = 0,
-                y = 0,
-                z = 0;
+            float x = 0;
+            float y = 0;
+            float z = 0;
 
             while (reader.Read())
             {

package/Runtime/Core/Serialization/JsonConverters/Vector4Converter.cs

@@ -0,0 +1,88 @@
+namespace UnityHelpers.Core.Serialization.JsonConverters
+{
+    using System;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+    using UnityEngine;
+
+    public sealed class Vector4Converter : JsonConverter<Vector4>
+    {
+        public static readonly Vector4Converter Instance = new();
+
+        private Vector4Converter() { }
+
+        public override Vector4 Read(
+            ref Utf8JsonReader reader,
+            Type typeToConvert,
+            JsonSerializerOptions options
+        )
+        {
+            if (reader.TokenType != JsonTokenType.StartObject)
+            {
+                throw new JsonException($"Invalid token type {reader.TokenType}");
+            }
+
+            float x = 0;
+            float y = 0;
+            float z = 0;
+            float w = 0;
+
+            while (reader.Read())
+            {
+                if (reader.TokenType == JsonTokenType.EndObject)
+                {
+                    return new Vector4(x, y, z, w);
+                }
+
+                if (reader.TokenType == JsonTokenType.PropertyName)
+                {
+                    string propertyName = reader.GetString();
+                    reader.Read();
+                    switch (propertyName)
+                    {
+                        case "x":
+                        {
+                            x = reader.GetSingle();
+                            break;
+                        }
+                        case "y":
+                        {
+                            y = reader.GetSingle();
+                            break;
+                        }
+                        case "z":
+                        {
+                            z = reader.GetSingle();
+                            break;
+                        }
+                        case "w":
+                        {
+                            w = reader.GetSingle();
+                            break;
+                        }
+                        default:
+                        {
+                            throw new JsonException($"Unknown property: {propertyName}");
+                        }
+                    }
+                }
+            }
+
+            throw new JsonException("Incomplete JSON for Vector4");
+        }
+
+        public override void Write(
+            Utf8JsonWriter writer,
+            Vector4 value,
+            JsonSerializerOptions options
+        )
+        {
+            writer.WriteStartObject();
+            writer.WriteNumber("x", value.x);
+            writer.WriteNumber("y", value.y);
+            writer.WriteNumber("z", value.z);
+            writer.WriteNumber("w", value.w);
+            writer.WriteEndObject();
+        }
+    }
+}

package/Runtime/Core/Serialization/JsonConverters/Vector4Converter.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 89ed188581124a3abc07f3645220ef56
+timeCreated: 1743568183

package/Runtime/Core/Serialization/Serializer.cs

@@ -32,7 +32,11 @@
                     new JsonStringEnumConverter(),
                     Vector3Converter.Instance,
                     Vector2Converter.Instance,
+                    Vector4Converter.Instance,
+                    Matrix4x4Converter.Instance,
                     TypeConverter.Instance,
+                    GameObjectConverter.Instance,
+                    ColorConverter.Instance,
                 },
             };
 
@@ -48,7 +52,11 @@
                     new JsonStringEnumConverter(),
                     Vector3Converter.Instance,
                     Vector2Converter.Instance,
+                    Vector4Converter.Instance,
+                    Matrix4x4Converter.Instance,
                     TypeConverter.Instance,
+                    GameObjectConverter.Instance,
+                    ColorConverter.Instance,
                 },
                 WriteIndented = true,
             };

package/Tests/Runtime/Serialization/JsonSerializationTest.cs

@@ -6,9 +6,11 @@
     using System.Runtime.Serialization;
     using System.Text.Json.Serialization;
     using Core.Extension;
+    using Core.Helper;
     using Core.Random;
     using Core.Serialization;
     using NUnit.Framework;
+    using UnityEngine;
 
     [DataContract]
     public sealed class TestDataObject
@@ -26,8 +28,69 @@
         public List<Type> TypeProperties { get; set; } = new();
     }
 
-    public class JsonSerializationTest
+    public sealed class JsonSerializationTest
     {
+        [Test]
+        public void UnityEngineObjectSerializationWorks()
+        {
+            GameObject testGo = new("Test GameObject", typeof(SpriteRenderer));
+            string json = testGo.ToJson();
+            Assert.IsFalse(string.IsNullOrWhiteSpace(json), json);
+            Assert.AreNotEqual("{}", json);
+            Assert.IsTrue(json.Contains("name = Test GameObject"), json);
+            Assert.IsTrue(json.Contains("type = UnityEngine.GameObject"), json);
+        }
+
+        [Test]
+        public void NullGameObjectSerializationWorks()
+        {
+            GameObject testGo = null;
+            string json = testGo.ToJson();
+            Assert.AreEqual("null", json);
+
+            testGo = new GameObject();
+            testGo.Destroy();
+            Assert.IsFalse(string.IsNullOrWhiteSpace(json), json);
+            Assert.AreEqual("null", json);
+        }
+
+        [Test]
+        public void TransformSerializationWorks()
+        {
+            GameObject testGo = new("Test GameObject", typeof(SpriteRenderer));
+            Transform transform = testGo.transform;
+            string json = transform.ToJson();
+            Assert.AreEqual("[]", json);
+        }
+
+        [Test]
+        public void ColorSerializationWorks()
+        {
+            Color color = new(0.5f, 0.5f, 0.5f, 0.5f);
+            string json = color.ToJson();
+            Color deserialized = Serializer.JsonDeserialize<Color>(json);
+            Assert.AreEqual(color, deserialized);
+
+            color = new Color(0.7f, 0.1f, 0.3f);
+            json = color.ToJson();
+            deserialized = Serializer.JsonDeserialize<Color>(json);
+            Assert.AreEqual(color, deserialized);
+        }
+
+        [Test]
+        public void Vector4SerializationWorks()
+        {
+            Vector4 vector = new(0.5f, 0.5f, 0.5f, 0.5f);
+            string json = vector.ToJson();
+            Vector4 deserialized = Serializer.JsonDeserialize<Vector4>(json);
+            Assert.AreEqual(vector, deserialized);
+
+            vector = new Vector4(0.7f, 0.1f, 0.3f);
+            json = vector.ToJson();
+            deserialized = Serializer.JsonDeserialize<Vector4>(json);
+            Assert.AreEqual(vector, deserialized);
+        }
+
         [Test]
         public void SerializationWorks()
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "2.0.0-rc49",
+  "version": "2.0.0-rc50",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},