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

package/.config/dotnet-tools.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "isRoot": true,
+  "tools": {
+    "CSharpier": {
+      "version": "0.30.6",
+      "commands": ["dotnet-csharpier"]
+    }
+  }
+}

package/.editorconfig

@@ -0,0 +1,184 @@
+
+[*]
+charset = utf-8-bom
+end_of_line = crlf
+trim_trailing_whitespace = false
+insert_final_newline = false
+indent_style = space
+indent_size = 4
+
+# Microsoft .NET properties
+csharp_new_line_before_members_in_object_initializers = false
+csharp_preferred_modifier_order = public, private, protected, internal, file, new, static, abstract, virtual, sealed, readonly, override, extern, unsafe, volatile, async, required:suggestion
+csharp_prefer_braces = true:suggestion
+csharp_style_prefer_utf8_string_literals = true:suggestion
+csharp_style_var_elsewhere = false:suggestion
+csharp_style_var_for_built_in_types = false:suggestion
+csharp_style_var_when_type_is_apparent = false:suggestion
+csharp_using_directive_placement = inside_namespace:silent
+dotnet_naming_rule.event_rule.import_to_resharper = True
+dotnet_naming_rule.event_rule.resharper_description = Events
+dotnet_naming_rule.event_rule.resharper_guid = 0c4c6401-2a1f-4db1-a21f-562f51542cf8
+dotnet_naming_rule.event_rule.severity = warning
+dotnet_naming_rule.event_rule.style = on_upper_camel_case_style
+dotnet_naming_rule.event_rule.symbols = event_symbols
+dotnet_naming_rule.interfaces_rule.import_to_resharper = True
+dotnet_naming_rule.interfaces_rule.resharper_description = Interfaces
+dotnet_naming_rule.interfaces_rule.resharper_guid = a7a3339e-4e89-4319-9735-a9dc4cb74cc7
+dotnet_naming_rule.interfaces_rule.severity = warning
+dotnet_naming_rule.interfaces_rule.style = i_upper_camel_case_style
+dotnet_naming_rule.interfaces_rule.symbols = interfaces_symbols
+dotnet_naming_rule.local_constants_rule.import_to_resharper = True
+dotnet_naming_rule.local_constants_rule.resharper_description = Local constants
+dotnet_naming_rule.local_constants_rule.resharper_guid = a4f433b8-abcd-4e55-a08f-82e78cef0f0c
+dotnet_naming_rule.local_constants_rule.resharper_style = AaBb, aaBb
+dotnet_naming_rule.local_constants_rule.severity = warning
+dotnet_naming_rule.local_constants_rule.style = upper_camel_case_style
+dotnet_naming_rule.local_constants_rule.symbols = local_constants_symbols
+dotnet_naming_rule.public_fields_override_rule.import_to_resharper = False
+dotnet_naming_rule.public_fields_override_rule.severity = warning
+dotnet_naming_rule.public_fields_override_rule.style = upper_camel_case_style
+dotnet_naming_rule.public_fields_override_rule.symbols = public_fields_override_symbols
+dotnet_naming_rule.public_fields_override_rule_1.import_to_resharper = False
+dotnet_naming_rule.public_fields_override_rule_1.severity = warning
+dotnet_naming_rule.public_fields_override_rule_1.style = upper_camel_case_style
+dotnet_naming_rule.public_fields_override_rule_1.symbols = public_fields_override_symbols_1
+dotnet_naming_rule.public_fields_rule.import_to_resharper = True
+dotnet_naming_rule.public_fields_rule.resharper_description = Instance fields (not private)
+dotnet_naming_rule.public_fields_rule.resharper_guid = 53eecf85-d821-40e8-ac97-fdb734542b84
+dotnet_naming_rule.public_fields_rule.severity = warning
+dotnet_naming_rule.public_fields_rule.style = lower_camel_case_style
+dotnet_naming_rule.public_fields_rule.symbols = public_fields_symbols
+dotnet_naming_rule.public_static_fields_rule.import_to_resharper = True
+dotnet_naming_rule.public_static_fields_rule.resharper_description = Static fields (not private)
+dotnet_naming_rule.public_static_fields_rule.resharper_guid = 70345118-4b40-4ece-937c-bbeb7a0b2e70
+dotnet_naming_rule.public_static_fields_rule.severity = warning
+dotnet_naming_rule.public_static_fields_rule.style = upper_camel_case_style
+dotnet_naming_rule.public_static_fields_rule.symbols = public_static_fields_symbols
+dotnet_naming_rule.type_parameters_rule.import_to_resharper = True
+dotnet_naming_rule.type_parameters_rule.resharper_description = Type parameters
+dotnet_naming_rule.type_parameters_rule.resharper_guid = 2c62818f-621b-4425-adc9-78611099bfcb
+dotnet_naming_rule.type_parameters_rule.severity = warning
+dotnet_naming_rule.type_parameters_rule.style = t_upper_camel_case_style
+dotnet_naming_rule.type_parameters_rule.symbols = type_parameters_symbols
+dotnet_naming_rule.unity_serialized_field_rule.import_to_resharper = True
+dotnet_naming_rule.unity_serialized_field_rule.resharper_description = Unity serialized field
+dotnet_naming_rule.unity_serialized_field_rule.resharper_guid = 5f0fdb63-c892-4d2c-9324-15c80b22a7ef
+dotnet_naming_rule.unity_serialized_field_rule.severity = none
+dotnet_naming_rule.unity_serialized_field_rule.style = lower_camel_case_style
+dotnet_naming_rule.unity_serialized_field_rule.symbols = unity_serialized_field_symbols
+dotnet_naming_style.i_upper_camel_case_style.capitalization = pascal_case
+dotnet_naming_style.i_upper_camel_case_style.required_prefix = I
+dotnet_naming_style.lower_camel_case_style.capitalization = camel_case
+dotnet_naming_style.on_upper_camel_case_style.capitalization = pascal_case
+dotnet_naming_style.on_upper_camel_case_style.required_prefix = On
+dotnet_naming_style.t_upper_camel_case_style.capitalization = pascal_case
+dotnet_naming_style.t_upper_camel_case_style.required_prefix = T
+dotnet_naming_style.upper_camel_case_style.capitalization = pascal_case
+dotnet_naming_symbols.event_symbols.applicable_accessibilities = *
+dotnet_naming_symbols.event_symbols.applicable_kinds = event
+dotnet_naming_symbols.event_symbols.resharper_applicable_kinds = event
+dotnet_naming_symbols.event_symbols.resharper_required_modifiers = any
+dotnet_naming_symbols.interfaces_symbols.applicable_accessibilities = *
+dotnet_naming_symbols.interfaces_symbols.applicable_kinds = interface
+dotnet_naming_symbols.interfaces_symbols.resharper_applicable_kinds = interface
+dotnet_naming_symbols.interfaces_symbols.resharper_required_modifiers = any
+dotnet_naming_symbols.local_constants_symbols.applicable_accessibilities = *
+dotnet_naming_symbols.local_constants_symbols.applicable_kinds = local
+dotnet_naming_symbols.local_constants_symbols.required_modifiers = const
+dotnet_naming_symbols.local_constants_symbols.resharper_applicable_kinds = local_constant
+dotnet_naming_symbols.local_constants_symbols.resharper_required_modifiers = any
+dotnet_naming_symbols.public_fields_override_symbols.applicable_accessibilities = public
+dotnet_naming_symbols.public_fields_override_symbols.applicable_kinds = field
+dotnet_naming_symbols.public_fields_override_symbols.required_modifiers = const
+dotnet_naming_symbols.public_fields_override_symbols_1.applicable_accessibilities = public
+dotnet_naming_symbols.public_fields_override_symbols_1.applicable_kinds = field
+dotnet_naming_symbols.public_fields_override_symbols_1.required_modifiers = readonly,static
+dotnet_naming_symbols.public_fields_symbols.applicable_accessibilities = public
+dotnet_naming_symbols.public_fields_symbols.applicable_kinds = field
+dotnet_naming_symbols.public_fields_symbols.resharper_applicable_kinds = field,readonly_field
+dotnet_naming_symbols.public_fields_symbols.resharper_required_modifiers = instance
+dotnet_naming_symbols.public_static_fields_symbols.applicable_accessibilities = public
+dotnet_naming_symbols.public_static_fields_symbols.applicable_kinds = field
+dotnet_naming_symbols.public_static_fields_symbols.required_modifiers = static
+dotnet_naming_symbols.public_static_fields_symbols.resharper_applicable_kinds = field
+dotnet_naming_symbols.public_static_fields_symbols.resharper_required_modifiers = static
+dotnet_naming_symbols.type_parameters_symbols.applicable_accessibilities = *
+dotnet_naming_symbols.type_parameters_symbols.applicable_kinds = type_parameter
+dotnet_naming_symbols.type_parameters_symbols.resharper_applicable_kinds = type_parameter
+dotnet_naming_symbols.type_parameters_symbols.resharper_required_modifiers = any
+dotnet_naming_symbols.unity_serialized_field_symbols.applicable_accessibilities = *
+dotnet_naming_symbols.unity_serialized_field_symbols.applicable_kinds = 
+dotnet_naming_symbols.unity_serialized_field_symbols.resharper_applicable_kinds = unity_serialised_field
+dotnet_naming_symbols.unity_serialized_field_symbols.resharper_required_modifiers = instance
+dotnet_style_parentheses_in_arithmetic_binary_operators = never_if_unnecessary:none
+dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:none
+dotnet_style_parentheses_in_relational_binary_operators = never_if_unnecessary:none
+dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion
+dotnet_style_predefined_type_for_member_access = true:suggestion
+dotnet_style_qualification_for_event = false:suggestion
+dotnet_style_qualification_for_field = false:suggestion
+dotnet_style_qualification_for_method = false:suggestion
+dotnet_style_qualification_for_property = false:suggestion
+dotnet_style_require_accessibility_modifiers = for_non_interface_members:suggestion
+
+# ReSharper properties
+resharper_autodetect_indent_settings = true
+resharper_braces_redundant = true
+resharper_csharp_wrap_lines = false
+resharper_formatter_off_tag = @formatter:off
+resharper_formatter_on_tag = @formatter:on
+resharper_formatter_tags_enabled = true
+resharper_indent_preprocessor_directives = normal
+resharper_keep_existing_attribute_arrangement = true
+resharper_place_attribute_on_same_line = false
+resharper_show_autodetect_configure_formatting_tip = false
+resharper_use_indent_from_vs = false
+
+# ReSharper inspection severities
+resharper_arrange_redundant_parentheses_highlighting = hint
+resharper_arrange_this_qualifier_highlighting = hint
+resharper_arrange_trailing_comma_in_multiline_lists_highlighting = none
+resharper_arrange_type_member_modifiers_highlighting = hint
+resharper_arrange_type_modifiers_highlighting = hint
+resharper_built_in_type_reference_style_for_member_access_highlighting = hint
+resharper_built_in_type_reference_style_highlighting = hint
+resharper_mvc_action_not_resolved_highlighting = warning
+resharper_mvc_area_not_resolved_highlighting = warning
+resharper_mvc_controller_not_resolved_highlighting = warning
+resharper_mvc_masterpage_not_resolved_highlighting = warning
+resharper_mvc_partial_view_not_resolved_highlighting = warning
+resharper_mvc_template_not_resolved_highlighting = warning
+resharper_mvc_view_component_not_resolved_highlighting = warning
+resharper_mvc_view_component_view_not_resolved_highlighting = warning
+resharper_mvc_view_not_resolved_highlighting = warning
+resharper_prefer_concrete_value_over_default_highlighting = none
+resharper_razor_assembly_not_resolved_highlighting = warning
+resharper_redundant_base_qualifier_highlighting = warning
+resharper_suggest_var_or_type_built_in_types_highlighting = hint
+resharper_suggest_var_or_type_elsewhere_highlighting = hint
+resharper_suggest_var_or_type_simple_types_highlighting = hint
+resharper_web_config_module_not_resolved_highlighting = warning
+resharper_web_config_type_not_resolved_highlighting = warning
+resharper_web_config_wrong_module_highlighting = warning
+
+[{*.har,*.inputactions,*.jsb2,*.jsb3,*.json,*.jsonc,*.postman_collection,*.postman_collection.json,*.postman_environment,*.postman_environment.json,.babelrc,.eslintrc,.prettierrc,.stylelintrc,.ws-context,jest.config}]
+indent_style = space
+indent_size = 2
+
+[{*.yaml,*.yml}]
+indent_style = space
+indent_size = 2
+
+[*.asmdef]
+indent_style = space
+indent_size = 2
+
+[*.asmref]
+indent_style = space
+indent_size = 2
+
+[*.{appxmanifest,asax,ascx,aspx,axaml,blockshader,build,c,c++,c++m,cc,ccm,cginc,compute,cp,cpp,cppm,cs,cshtml,cu,cuh,cxx,cxxm,dtd,fs,fsi,fsscript,fsx,fx,fxh,h,h++,hh,hlsl,hlsli,hlslinc,hp,hpp,hxx,icc,inc,inl,ino,ipp,ixx,master,ml,mli,mpp,mq4,mq5,mqh,mxx,nuspec,paml,razor,resw,resx,shader,shaderFoundry,skin,tcc,tpp,urtshader,usf,ush,uxml,vb,xaml,xamlx,xoml,xsd}]
+indent_style = space
+indent_size = 4
+tab_width = 4

package/.pre-commit-config.yaml

@@ -0,0 +1,22 @@
+repos:
+  - repo: local
+    hooks:
+      - id: dotnet-tool-restore
+        name: Install .NET tools
+        entry: dotnet tool restore
+        language: system
+        always_run: true
+        pass_filenames: false
+        stages:
+          - pre-commit
+          - pre-push
+          - post-checkout
+          - post-rewrite
+        description: Install the .NET tools listed at .config/dotnet-tools.json.
+      - id: csharpier
+        name: Run CSharpier on C# files
+        entry: dotnet tool run dotnet-csharpier
+        language: system
+        types:
+          - c#
+        description: CSharpier is an opinionated C# formatter inspired by Prettier.

package/README.md

@@ -171,4 +171,8 @@ Assert.AreEqual(myCoolGameObject, nearestNeighbors[0]);
 ```
 
 ## Note
-All spatial trees expect the positional data to be *immutable*. It is very important that the positions do not change. If they do, you will need to reconstruct the tree.
+All spatial trees expect the positional data to be *immutable*. It is very important that the positions do not change. If they do, you will need to reconstruct the tree.
+
+## Contributing
+
+This project uses [CSharpier](https://csharpier.com/) with the default configuration to enable an enforced, consistent style. If you would like to contribute, recommendation is to ensure that changed files are ran through CSharpier prior to merge. This can be done automatically through editor plugins, or, minimally, by installing a [pre-commit hook](https://pre-commit.com/#3-install-the-git-hook-scripts).

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/TypeConverter.cs

@@ -0,0 +1,28 @@
+namespace UnityHelpers.Core.Serialization.JsonConverters
+{
+    using System;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+
+    public sealed class TypeConverter : JsonConverter<Type>
+    {
+        public static readonly TypeConverter Instance = new();
+
+        private TypeConverter() { }
+
+        public override Type Read(
+            ref Utf8JsonReader reader,
+            Type typeToConvert,
+            JsonSerializerOptions options
+        )
+        {
+            string typeName = reader.GetString();
+            return string.IsNullOrWhiteSpace(typeName) ? null : Type.GetType(typeName);
+        }
+
+        public override void Write(Utf8JsonWriter writer, Type value, JsonSerializerOptions options)
+        {
+            writer.WriteStringValue(value?.AssemblyQualifiedName);
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ffebfa399370464baa7e9d9065db60f5
+timeCreated: 1743566193

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

@@ -9,6 +9,7 @@
     using System.Text.Json.Serialization;
     using Extension;
     using JsonConverters;
+    using TypeConverter = JsonConverters.TypeConverter;
 
     internal static class SerializerEncoding
     {
@@ -31,6 +32,11 @@
                     new JsonStringEnumConverter(),
                     Vector3Converter.Instance,
                     Vector2Converter.Instance,
+                    Vector4Converter.Instance,
+                    Matrix4x4Converter.Instance,
+                    TypeConverter.Instance,
+                    GameObjectConverter.Instance,
+                    ColorConverter.Instance,
                 },
             };
 
@@ -46,6 +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
@@ -22,10 +24,73 @@
         public Dictionary<string, bool> DictionaryProperty { get; set; } = new();
 
         public List<int> ListProperty { get; set; } = new();
+
+        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()
         {
@@ -35,6 +100,12 @@
                 field = Guid.NewGuid().ToString(),
                 Property = random.Next(),
                 NamedProperty = random.NextFloat(),
+                TypeProperties = new List<Type>()
+                {
+                    typeof(int),
+                    typeof(Serializer),
+                    typeof(TestDataObject),
+                },
             };
 
             int dictionaryProperties = random.Next(4, 10);
@@ -79,6 +150,7 @@
                 input.ListProperty.SequenceEqual(deserialized.ListProperty),
                 $"Unexpected {nameof(deserialized.ListProperty)}! JSON: {json}"
             );
+            Assert.That(input.TypeProperties, Is.EquivalentTo(deserialized.TypeProperties));
         }
     }
 }

package/package.json

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