Add component editors and UI controls

Added the `HierarchyEditor` and `LocalToWorldEditor` classes to implement custom component editing functionality.
Added the `Vector3Field` control for 3D vector manipulation and its corresponding XAML definition.
Added the `ComponentDataView` and `ComponentObject` classes to manage component data display and access.
Added the `CustomEditorAttribute` to mark classes as custom editors for specific components.

Changed the `IInspectable` interface to use properties for `Icon`, `HeaderContent`, and `InspectorContent`.
Changed the `PropertyField` class to enhance UI control binding capabilities.
Changed the `EditorWorldManager` to improve world data loading and deserialization processes.
Changed the `EntityNode` and `WorldNode` classes to update entity construction and component querying.
Changed the `StaticResource` class to include new binding flags for component properties.
Changed the `InspectorService` to remove old contract references and adopt new interfaces.
Changed the `QueryEnumerable` and related files to update generic constraints for improved type safety.
Changed the `QueryItem` class to reflect new generic constraints and enhance deconstruction.
Changed the `World.Query` methods to utilize the updated generic constraints.

Updated the `SerializationTest` to align with new entity creation and management practices.

Ghost.Engine/Utilities/MathUtility.cs

@@ -0,0 +1,31 @@
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Engine.Utilities;
+
+public static class MathUtility
+{
+    public const float RAD_TO_DEG = 180f / MathF.PI;
+    public const float DEG_TO_RAD = MathF.PI / 180f;
+
+    /// <summary>
+    /// Converts radians to degrees.
+    /// </summary>
+    /// <param name="radians">The angle in radians to convert.</param>
+    /// <returns>The angle in degrees.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static float RadToDeg(float radians)
+    {
+        return radians * RAD_TO_DEG;
+    }
+
+    /// <summary>
+    /// Converts degrees to radians.
+    /// </summary>
+    /// <param name="degrees">The angle in degrees to convert.</param>
+    /// <returns>The angle in radians.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static float DegToRad(float degrees)
+    {
+        return degrees * DEG_TO_RAD;
+    }
+}

Ghost.Engine/Utilities/MatrixUtilities.cs

@@ -1,20 +0,0 @@
-using System.Numerics;
-using System.Runtime.CompilerServices;
-
-namespace Ghost.Engine.Utilities;
-
-public static class MatrixUtilities
-{
-    /// <summary>
-    /// Generates a transformation matrix from position, rotation, and scale vectors.
-    /// </summary>
-    /// <param name="position">Defines the translation component of the transformation matrix.</param>
-    /// <param name="rotation">Specifies the orientation of the object in 3D space.</param>
-    /// <param name="scale">Determines the size of the object along each axis.</param>
-    /// <returns>Returns a transformation matrix that combines the specified position, rotation, and scale.</returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Matrix4x4 CreateTRS(Vector3 position, Quaternion rotation, Vector3 scale)
-    {
-        return Matrix4x4.CreateScale(scale) * Matrix4x4.CreateFromQuaternion(rotation) * Matrix4x4.CreateTranslation(position);
-    }
-}

Ghost.Engine/Utilities/MatrixUtility.cs

@@ -0,0 +1,49 @@
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Engine.Utilities;
+
+public static class MatrixUtility
+{
+    /// <summary>
+    /// Generates a transformation matrix from position, rotation, and scale vectors.
+    /// </summary>
+    /// <param name="position">Defines the translation component of the transformation matrix.</param>
+    /// <param name="rotation">Specifies the orientation of the object in 3D space.</param>
+    /// <param name="scale">Determines the size of the object along each axis.</param>
+    /// <returns>Returns a transformation matrix that combines the specified position, rotation, and scale.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Matrix4x4 CreateTRS(Vector3 position, Quaternion rotation, Vector3 scale)
+    {
+        return Matrix4x4.CreateScale(scale) * Matrix4x4.CreateFromQuaternion(rotation) * Matrix4x4.CreateTranslation(position);
+    }
+
+    /// <summary>
+    /// Decomposes a transformation matrix into its position, rotation, and scale components.
+    /// </summary>
+    /// <remarks>This method assumes the input matrix represents a valid affine transformation, including
+    /// translation, rotation, and scaling. If the matrix contains skew or other non-standard transformations, the
+    /// results may be undefined.</remarks>
+    /// <param name="matrix">The <see cref="Matrix4x4"/> to decompose. Must represent a valid transformation matrix.</param>
+    /// <param name="position">When the method returns, contains the position component extracted from the matrix.</param>
+    /// <param name="rotation">When the method returns, contains the rotation component extracted from the matrix as a <see
+    /// cref="Quaternion"/>.</param>
+    /// <param name="scale">When the method returns, contains the scale component extracted from the matrix.</param>
+    public static void GetTRS(Matrix4x4 matrix, out Vector3 position, out Quaternion rotation, out Vector3 scale)
+    {
+        position = new(matrix.M41, matrix.M42, matrix.M43);
+
+        var scaleX = new Vector3(matrix.M11, matrix.M12, matrix.M13).Length();
+        var scaleY = new Vector3(matrix.M21, matrix.M22, matrix.M23).Length();
+        var scaleZ = new Vector3(matrix.M31, matrix.M32, matrix.M33).Length();
+        scale = new(scaleX, scaleY, scaleZ);
+
+        Matrix4x4 rotationMatrix = new(
+            matrix.M11 / scale.X, matrix.M12 / scale.X, matrix.M13 / scale.X, 0,
+            matrix.M21 / scale.Y, matrix.M22 / scale.Y, matrix.M23 / scale.Y, 0,
+            matrix.M31 / scale.Z, matrix.M32 / scale.Z, matrix.M33 / scale.Z, 0,
+            0, 0, 0, 1);
+
+        rotation = Quaternion.CreateFromRotationMatrix(rotationMatrix);
+    }
+}

Ghost.Engine/Utilities/Utf8JsonWriterExtension.cs

@@ -2,7 +2,7 @@
 
 namespace Ghost.Engine.Utilities;
 
-public static class Utf8JsonWriterExtensions
+public static class Utf8JsonWriterExtension
 {
     public static void WriteArray<T>(this Utf8JsonWriter writer, ReadOnlySpan<char> name, IEnumerable<T> source, Action<T> writeAction)
     {

Ghost.Engine/Utilities/VectorUtility.cs

@@ -0,0 +1,45 @@
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Engine.Utilities;
+
+public static class VectorUtility
+{
+    /// <summary>
+    /// Converts a Vector3 representing Euler angles (in degrees) to a Quaternion.
+    /// </summary>
+    /// <param name="v">The Vector3 containing Euler angles (X: Pitch, Y: Yaw, Z: Roll) in degrees.</param>
+    /// <returns>A Quaternion representing the rotation defined by the Euler angles.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Quaternion ToQuaternion(this Vector3 v)
+    {
+        return Quaternion.CreateFromYawPitchRoll(MathUtility.DegToRad(v.Y), MathUtility.DegToRad(v.X), MathUtility.DegToRad(v.Z));
+    }
+
+    public static Vector3 CreateFromQuaternion(Quaternion quaternion)
+    {
+        // Convert quaternion to Euler angles (Yaw, Pitch, Roll)
+        quaternion = Quaternion.Normalize(quaternion);
+
+        // Extract pitch (X), yaw (Y), roll (Z)
+        var ysqr = quaternion.Y * quaternion.Y;
+
+        // Pitch (X-axis rotation)
+        var t0 = +2.0 * (quaternion.W * quaternion.X + quaternion.Y * quaternion.Z);
+        var t1 = +1.0 - 2.0 * (quaternion.X * quaternion.X + ysqr);
+        var pitch = Math.Atan2(t0, t1);
+
+        // Yaw (Y-axis rotation)
+        var t2 = +2.0 * (quaternion.W * quaternion.Y - quaternion.Z * quaternion.X);
+        t2 = Math.Clamp(t2, -1.0, 1.0);
+        var yaw = Math.Asin(t2);
+
+        // Roll (Z-axis rotation)
+        var t3 = +2.0 * (quaternion.W * quaternion.Z + quaternion.X * quaternion.Y);
+        var t4 = +1.0 - 2.0 * (ysqr + quaternion.Z * quaternion.Z);
+        var roll = Math.Atan2(t3, t4);
+
+        const float radToDeg = 180f / MathF.PI;
+        return new Vector3((float)pitch, (float)yaw, (float)roll) * radToDeg;
+    }
+}