Refactor: variant-aware shader/material pipeline overhaul

Major architectural update to graphics/material/shader system:
- Introduced strongly-typed key structs (Key64/Key128) for passes, variants, and pipelines; removed legacy key types.
- Implemented robust hashing and key generation utilities for efficient variant and pipeline lookup/caching.
- Shader compiler now compiles/caches all keyword variants using new key system; includes handled as lists.
- Switched to push constant root signature for per-draw data; updated HLSL and C# codegen accordingly.
- Refactored Material, Shader, and Pass data structures for cache efficiency and variant support.
- Pipeline library and PSO management now use 128-bit keys and variant-specific caching.
- Replaced WorldNode with SceneNode in editor/scene graph; introduced ComponentManager for archetype/query management.
- Migrated math utilities to Misaki.HighPerformance.Mathematics; updated editor controls.
- Updated all HLSL and codegen for new buffer/push constant layouts and macros.
- Misc: project reference cleanup, D3D12 Work Graph support, doc updates, and code modernization.

Ghost.Engine/Utilities/MathUtility.cs

@@ -1,31 +1,54 @@
+using Misaki.HighPerformance.Mathematics;
 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)
+    extension(float4x4 matrix)
     {
-        return radians * RAD_TO_DEG;
-    }
+        /// <summary>
+        /// Creates 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 float4x4 TRS(float3 position, quaternion rotation, float3 scale)
+        {
+            var R = new float3x3(rotation);
+            return new float4x4(
+                    R[0][0] * scale.x, R[0][1] * scale.y, R[0][2] * scale.z, position.x,
+                    R[1][0] * scale.x, R[1][1] * scale.y, R[1][2] * scale.z, position.y,
+                    R[2][0] * scale.x, R[2][1] * scale.y, R[2][2] * scale.z, position.z,
+                    0f, 0f, 0f, 1f
+                );
+        }
 
-    /// <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;
+        /// <summary>
+        /// Gets the translation, rotation, and scale components from a transformation matrix.
+        /// </summary>
+        /// <param name="position">The position component extracted from the matrix.</param>
+        /// <param name="rotation">The rotation component extracted from the matrix as a quaternion.</param>
+        /// <param name="scale">The scale component extracted from the matrix.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetTRS(out float3 position, out quaternion rotation, out float3 scale)
+        {
+            position = matrix.c3.xyz;
+
+            var scaleX = math.length(matrix.c0.xyz);
+            var scaleY = math.length(matrix.c1.xyz);
+            var scaleZ = math.length(matrix.c2.xyz);
+            scale = new float3(scaleX, scaleY, scaleZ);
+
+            var rotationMatrix = new float3x3(
+                matrix.c0.x / scale.x, matrix.c0.y / scale.x, matrix.c0.z / scale.x,
+                matrix.c1.x / scale.y, matrix.c1.y / scale.y, matrix.c1.z / scale.y,
+                matrix.c2.x / scale.z, matrix.c2.y / scale.z, matrix.c2.z / scale.z
+            );
+
+            rotation = new quaternion(rotationMatrix);
+        }
     }
-}
+}