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.Graphics/D3D12/Utilities/D3D12Utility.cs

@@ -77,41 +77,136 @@ internal unsafe static class D3D12Utility
 
     public static D3D12_RESOURCE_STATES ToD3D12States(this ResourceState state)
     {
-        return state switch
+        var d3dStates = D3D12_RESOURCE_STATES.D3D12_RESOURCE_STATE_COMMON;
+
+        if (state.HasFlag(ResourceState.VertexAndConstantBuffer))
         {
-            ResourceState.Common or ResourceState.Present => D3D12_RESOURCE_STATE_COMMON,
-            ResourceState.VertexAndConstantBuffer => D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER,
-            ResourceState.IndexBuffer => D3D12_RESOURCE_STATE_INDEX_BUFFER,
-            ResourceState.RenderTarget => D3D12_RESOURCE_STATE_RENDER_TARGET,
-            ResourceState.UnorderedAccess => D3D12_RESOURCE_STATE_UNORDERED_ACCESS,
-            ResourceState.DepthWrite => D3D12_RESOURCE_STATE_DEPTH_WRITE,
-            ResourceState.DepthRead => D3D12_RESOURCE_STATE_DEPTH_READ,
-            ResourceState.PixelShaderResource => D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE,
-            ResourceState.CopyDest => D3D12_RESOURCE_STATE_COPY_DEST,
-            ResourceState.CopySource => D3D12_RESOURCE_STATE_COPY_SOURCE,
-            ResourceState.GenericRead => D3D12_RESOURCE_STATE_GENERIC_READ,
-            ResourceState.IndirectArgument => D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT,
-            ResourceState.NonPixelShaderResource => D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,
-            _ => throw new ArgumentException($"Unknown resource state: {state}")
-        };
+            d3dStates |= D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER;
+        }
+
+        if (state.HasFlag(ResourceState.IndexBuffer))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_INDEX_BUFFER;
+        }
+
+        if (state.HasFlag(ResourceState.RenderTarget))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_RENDER_TARGET;
+        }
+
+        if (state.HasFlag(ResourceState.UnorderedAccess))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
+        }
+
+        if (state.HasFlag(ResourceState.DepthWrite))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_DEPTH_WRITE;
+        }
+
+        if (state.HasFlag(ResourceState.DepthRead))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_DEPTH_READ;
+        }
+
+        if (state.HasFlag(ResourceState.PixelShaderResource))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
+        }
+
+        if (state.HasFlag(ResourceState.CopyDest))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_COPY_DEST;
+        }
+
+        if (state.HasFlag(ResourceState.CopySource))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_COPY_SOURCE;
+        }
+
+        if (state.HasFlag(ResourceState.GenericRead))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_GENERIC_READ;
+        }
+
+        if (state.HasFlag(ResourceState.IndirectArgument))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT;
+        }
+
+        if (state.HasFlag(ResourceState.NonPixelShaderResource))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE;
+        }
+
+        return d3dStates;
     }
 
     public static ResourceState ToResourceState(this D3D12_RESOURCE_STATES states)
     {
-        return states switch
+        var resourceState = ResourceState.Common;
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER))
         {
-            D3D12_RESOURCE_STATE_COMMON => ResourceState.Common,
-            D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER => ResourceState.VertexAndConstantBuffer,
-            D3D12_RESOURCE_STATE_INDEX_BUFFER => ResourceState.IndexBuffer,
-            D3D12_RESOURCE_STATE_RENDER_TARGET => ResourceState.RenderTarget,
-            D3D12_RESOURCE_STATE_UNORDERED_ACCESS => ResourceState.UnorderedAccess,
-            D3D12_RESOURCE_STATE_DEPTH_WRITE => ResourceState.DepthWrite,
-            D3D12_RESOURCE_STATE_DEPTH_READ => ResourceState.DepthRead,
-            D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE => ResourceState.PixelShaderResource,
-            D3D12_RESOURCE_STATE_COPY_DEST => ResourceState.CopyDest,
-            D3D12_RESOURCE_STATE_COPY_SOURCE => ResourceState.CopySource,
-            _ => throw new ArgumentException($"Unknown D3D12 resource state: {states}")
-        };
+            resourceState |= ResourceState.VertexAndConstantBuffer;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_INDEX_BUFFER))
+        {
+            resourceState |= ResourceState.IndexBuffer;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_RENDER_TARGET))
+        {
+            resourceState |= ResourceState.RenderTarget;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_UNORDERED_ACCESS))
+        {
+            resourceState |= ResourceState.UnorderedAccess;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_DEPTH_WRITE))
+        {
+            resourceState |= ResourceState.DepthWrite;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_DEPTH_READ))
+        {
+            resourceState |= ResourceState.DepthRead;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE))
+        {
+            resourceState |= ResourceState.PixelShaderResource;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_COPY_DEST))
+        {
+            resourceState |= ResourceState.CopyDest;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_COPY_SOURCE))
+        {
+            resourceState |= ResourceState.CopySource;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_GENERIC_READ))
+        {
+            resourceState |= ResourceState.GenericRead;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT))
+        {
+            resourceState |= ResourceState.IndirectArgument;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE))
+        {
+            resourceState |= ResourceState.NonPixelShaderResource;
+        }
+
+        return resourceState;
     }
 
     public static D3D12_FILTER ToD3D12Filter(this TextureFilterMode filterMode)