Refactor core systems and improve resource management

- Updated dependencies, including `Misaki.HighPerformance` and `TerraFX.Interop`.
- Refactored `Result` struct for better error handling and chaining.
- Removed `Ptr<T>` struct as it was no longer necessary.
- Enhanced `Win32Utility` with `Attach` and `Dispose` methods.
- Improved `ProjectService` and `AppStateMachine` with `Result` integration.
- Refactored `IShaderCompiler` to support SPIR-V cross-compilation and pass-level compilation.
- Standardized Direct3D12 resource management with `UniquePtr` and added `D3D12Object` base class.
- Improved shader reflection validation and pipeline creation in `D3D12PipelineLibrary`.
- Updated `SDLCompiler` for better error handling during shader generation.
- Enhanced logging, debugging, and code readability across the codebase.
- Performed general code cleanup, including unused namespace removal and naming consistency.

Ghost.Graphics/D3D12/D3D12CommandQueue.cs

@@ -1,6 +1,7 @@
 using Ghost.Core.Utilities;
 using Ghost.Graphics.D3D12.Utilities;
 using Ghost.Graphics.RHI;
+using Misaki.HighPerformance.LowLevel;
 using TerraFX.Interop.DirectX;
 using TerraFX.Interop.Windows;
 
@@ -9,19 +10,18 @@ namespace Ghost.Graphics.D3D12;
 /// <summary>
 /// D3D12 implementation of command queue interface
 /// </summary>
-internal unsafe class D3D12CommandQueue : ICommandQueue
+internal unsafe class D3D12CommandQueue : D3D12Object<ID3D12CommandQueue>, ICommandQueue
 {
-    private ComPtr<ID3D12CommandQueue> _queue;
-    private ComPtr<ID3D12Fence1> _fence;
+    private UniquePtr<ID3D12Fence1> _fence;
     private readonly AutoResetEvent _fenceEvent;
     private ulong _fenceValue;
-    private bool _disposed;
 
     public CommandQueueType Type
     {
         get;
     }
-    public ID3D12CommandQueue* NativeQueue => _queue.Get();
+
+    public ID3D12CommandQueue* NativeQueue => nativeObject.Get();
 
     public D3D12CommandQueue(ID3D12Device14* pDevice, CommandQueueType type)
     {
@@ -41,17 +41,25 @@ internal unsafe class D3D12CommandQueue : ICommandQueue
         ThrowIfFailed(pDevice->CreateCommandQueue(&queueDesc, __uuidof(pQueue), (void**)&pQueue));
         ThrowIfFailed(pDevice->CreateFence(0, D3D12_FENCE_FLAGS.D3D12_FENCE_FLAG_NONE, __uuidof(pFence), (void**)&pFence));
 
-        _queue.Attach(pQueue);
+        nativeObject.Attach(pQueue);
         _fence.Attach(pFence);
     }
 
-    ~D3D12CommandQueue()
+    private static D3D12_COMMAND_LIST_TYPE ConvertCommandQueueType(CommandQueueType type)
     {
-        Dispose();
+        return type switch
+        {
+            CommandQueueType.Graphics => D3D12_COMMAND_LIST_TYPE.D3D12_COMMAND_LIST_TYPE_DIRECT,
+            CommandQueueType.Compute => D3D12_COMMAND_LIST_TYPE.D3D12_COMMAND_LIST_TYPE_COMPUTE,
+            CommandQueueType.Copy => D3D12_COMMAND_LIST_TYPE.D3D12_COMMAND_LIST_TYPE_COPY,
+            _ => throw new ArgumentException($"Unknown command queue type: {type}")
+        };
     }
 
     public void Submit(ICommandBuffer commandBuffer)
     {
+        ThrowIfDisposed();
+
         if (commandBuffer.IsEmpty)
         {
             return;
@@ -61,7 +69,7 @@ internal unsafe class D3D12CommandQueue : ICommandQueue
         {
             var commandList = d3d12CommandBuffer.NativeCommandList;
             var commandListPtr = (ID3D12CommandList*)commandList;
-            _queue.Get()->ExecuteCommandLists(1, &commandListPtr);
+            nativeObject.Get()->ExecuteCommandLists(1, &commandListPtr);
         }
         else
         {
@@ -71,6 +79,8 @@ internal unsafe class D3D12CommandQueue : ICommandQueue
 
     public void Submit(params ReadOnlySpan<ICommandBuffer> commandBuffers)
     {
+        ThrowIfDisposed();
+
         Span<int> executableIndices = stackalloc int[commandBuffers.Length];
         executableIndices.Fill(-1);
 
@@ -107,18 +117,22 @@ internal unsafe class D3D12CommandQueue : ICommandQueue
             currentIndex++;
         }
 
-        _queue.Get()->ExecuteCommandLists((uint)currentIndex, ppCommandLists);
+        nativeObject.Get()->ExecuteCommandLists((uint)currentIndex, ppCommandLists);
     }
 
     public ulong Signal(ulong value)
     {
+        ThrowIfDisposed();
+
         _fenceValue = value;
-        _queue.Get()->Signal((ID3D12Fence*)_fence.Get(), _fenceValue);
+        nativeObject.Get()->Signal((ID3D12Fence*)_fence.Get(), _fenceValue);
         return _fenceValue;
     }
 
     public void WaitForValue(ulong value)
     {
+        ThrowIfDisposed();
+
         if (_fence.Get()->GetCompletedValue() < value)
         {
             var handle = new HANDLE((void*)_fenceEvent.SafeWaitHandle.DangerousGetHandle());
@@ -131,39 +145,28 @@ internal unsafe class D3D12CommandQueue : ICommandQueue
 
     public ulong GetCompletedValue()
     {
+        ThrowIfDisposed();
         return _fence.Get()->GetCompletedValue();
     }
 
     public void WaitIdle()
     {
+        ThrowIfDisposed();
+
         var fenceValue = Signal(Interlocked.Increment(ref _fenceValue));
         WaitForValue(fenceValue);
     }
 
-    private static D3D12_COMMAND_LIST_TYPE ConvertCommandQueueType(CommandQueueType type)
+    protected override void Dispose(bool disposing)
     {
-        return type switch
-        {
-            CommandQueueType.Graphics => D3D12_COMMAND_LIST_TYPE.D3D12_COMMAND_LIST_TYPE_DIRECT,
-            CommandQueueType.Compute => D3D12_COMMAND_LIST_TYPE.D3D12_COMMAND_LIST_TYPE_COMPUTE,
-            CommandQueueType.Copy => D3D12_COMMAND_LIST_TYPE.D3D12_COMMAND_LIST_TYPE_COPY,
-            _ => throw new ArgumentException($"Unknown command queue type: {type}")
-        };
-    }
-
-    public void Dispose()
-    {
-        if (_disposed)
+        if (Disposed)
         {
             return;
         }
 
         _fenceEvent?.Dispose();
         _fence.Dispose();
-        _queue.Dispose();
 
-        _disposed = true;
-
-        GC.SuppressFinalize(this);
+        base.Dispose(disposing);
     }
 }