From 85280c746d83861997952d67ed0f78a8740e2ceb Mon Sep 17 00:00:00 2001
From: Misaki <misaki_39@outlook.com>
Date: Sun, 30 Nov 2025 19:06:31 +0900
Subject: [PATCH] Refactor error handling and improve type safety

Refactored error handling across the codebase by replacing exceptions with `Result`-based error handling for better robustness and consistency.

- Updated `ResultExtensions` to use `EqualityComparer` for comparisons.
- Enhanced `RenderingContext` with `GetValueOrThrow` for resource validation and added type constraints for texture methods.
- Introduced `CommandError` and `RecordError` in `D3D12CommandBuffer` for improved error tracking.
- Refactored `D3D12ResourceDatabase` to use `Result` objects for resource queries.
- Updated `ICommandBuffer` and `IResourceDatabase` interfaces to return `Result` objects.
- Improved type safety by replacing `int` with `uint` where appropriate.
- Simplified texture handling in `MeshRenderPass` with new `CreateTexture` logic.
- Cleaned up project files by removing unused and redundant entries.

These changes enhance code maintainability, improve error reporting, and ensure type safety throughout the project.
---
 Ghost.Core/Result.cs                          |   2 +-
 .../Ghost.Graphics.Test.csproj                |  21 --
 Ghost.Graphics/Core/RenderingContext.cs       |  39 +++-
 Ghost.Graphics/D3D12/D3D12CommandBuffer.cs    | 187 +++++++++++++-----
 Ghost.Graphics/D3D12/D3D12GraphicsEngine.cs   |   3 +-
 Ghost.Graphics/D3D12/D3D12Renderer.cs         |   2 +-
 .../D3D12/D3D12ResourceAllocator.cs           |   1 +
 Ghost.Graphics/D3D12/D3D12ResourceDatabase.cs |  42 ++--
 Ghost.Graphics/D3D12/D3D12SwapChain.cs        |   7 +-
 Ghost.Graphics/Ghost.Graphics.csproj          |   4 -
 Ghost.Graphics/RHI/Common.cs                  |  24 ++-
 Ghost.Graphics/RHI/ICommandBuffer.cs          |   2 +-
 Ghost.Graphics/RHI/IResourceDatabase.cs       |   4 +-
 Ghost.Graphics/RHI/RHIUtility.cs              |  27 ++-
 Ghost.Graphics/RenderPasses/MeshRenderPass.cs |   5 +-
 15 files changed, 244 insertions(+), 126 deletions(-)

diff --git a/Ghost.Core/Result.cs b/Ghost.Core/Result.cs
index 9f7428d..7db37c0 100644
--- a/Ghost.Core/Result.cs
+++ b/Ghost.Core/Result.cs
@@ -178,7 +178,7 @@ public static class ResultExtensions
     public static T GetValueOrThrow<T, S>(this Result<T, S> result, S expect)
         where S : Enum
     {
-        if (result.Status?.Equals(expect) ?? false)
+        if (!EqualityComparer<S>.Default.Equals(result.Status, expect))
         {
             throw new InvalidOperationException($"Operation failed: expected status {expect}, but got {result.Status}");
         }
diff --git a/Ghost.Graphics.Test/Ghost.Graphics.Test.csproj b/Ghost.Graphics.Test/Ghost.Graphics.Test.csproj
index b85c415..7c904f9 100644
--- a/Ghost.Graphics.Test/Ghost.Graphics.Test.csproj
+++ b/Ghost.Graphics.Test/Ghost.Graphics.Test.csproj
@@ -57,18 +57,6 @@
     <ProjectReference Include="..\Ghost.Engine\Ghost.Engine.csproj" />
     <ProjectReference Include="..\Ghost.Test.Core\Ghost.Test.Core.csproj" />
   </ItemGroup>
-  
-  <ItemGroup>
-    <Page Update="Windows\DebugOutputWindow.xaml">
-      <Generator>MSBuild:Compile</Generator>
-    </Page>
-  </ItemGroup>
-  
-  <ItemGroup>
-    <Page Update="Controls\DebugConsole.xaml">
-      <Generator>MSBuild:Compile</Generator>
-    </Page>
-  </ItemGroup>
 
   <!-- 
     Defining the "HasPackageAndPublishMenuAddedByProject" property here allows the Solution 
@@ -96,13 +84,4 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
     <DebugType>embedded</DebugType>
   </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x86'">
-    <DebugType>embedded</DebugType>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <DebugType>embedded</DebugType>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
-    <DebugType>embedded</DebugType>
-  </PropertyGroup>
 </Project>
diff --git a/Ghost.Graphics/Core/RenderingContext.cs b/Ghost.Graphics/Core/RenderingContext.cs
index ce4801d..126c54b 100644
--- a/Ghost.Graphics/Core/RenderingContext.cs
+++ b/Ghost.Graphics/Core/RenderingContext.cs
@@ -102,8 +102,11 @@ public readonly unsafe ref struct RenderingContext
     public void UploadMesh(Handle<Mesh> mesh, bool markMeshStatic)
     {
         ref var meshData = ref ResourceDatabase.GetMeshReference(mesh);
-        var vertexState = ResourceDatabase.GetResourceState(meshData.VertexBuffer.AsResource());
-        var indexState = ResourceDatabase.GetResourceState(meshData.IndexBuffer.AsResource());
+        var vertexState = ResourceDatabase.GetResourceState(meshData.VertexBuffer.AsResource())
+            .GetValueOrThrow(ResultStatus.Success);
+        var indexState = ResourceDatabase.GetResourceState(meshData.IndexBuffer.AsResource())
+            .GetValueOrThrow(ResultStatus.Success);
+
         var needVertexTransition = vertexState != ResourceState.CopyDest;
         var needIndexTransition = indexState != ResourceState.CopyDest;
 
@@ -149,7 +152,9 @@ public readonly unsafe ref struct RenderingContext
         };
 
         var bufferHandle = meshData.ObjectDataBuffer.AsResource();
-        var state = ResourceDatabase.GetResourceState(bufferHandle);
+        var state = ResourceDatabase.GetResourceState(bufferHandle)
+            .GetValueOrThrow(ResultStatus.Success);
+
         var needTransition = state != ResourceState.CopyDest;
         if (needTransition)
         {
@@ -164,17 +169,31 @@ public readonly unsafe ref struct RenderingContext
         }
     }
 
-    public Handle<Texture> CreateTexture(ref readonly TextureDesc desc, bool tempResource = false)
+    public Handle<Texture> CreateTexture<T>(ref readonly TextureDesc desc, ReadOnlySpan<T> data, bool tempResource = false)
+        where T : unmanaged
     {
-        return ResourceAllocator.CreateTexture(in desc, tempResource);
+        var handle = ResourceAllocator.CreateTexture(in desc, tempResource);
+        UploadTexture(handle, data);
+
+        return handle;
     }
 
-    public void UploadTexture(Handle<Texture> texture, ReadOnlySpan<byte> data)
+    public void UploadTexture<T>(Handle<Texture> texture, ReadOnlySpan<T> data)
+        where T : unmanaged
     {
-        var desc = ResourceDatabase.GetResourceDescription(texture.AsResource());
-        desc.TextureDescription.Format.GetSurfaceInfo((int)desc.TextureDescription.Width, (int)desc.TextureDescription.Height, out var rowPitch, out var slicePitch, out _);
+        var desc = ResourceDatabase.GetResourceDescription(texture.AsResource())
+            .GetValueOrThrow(ResultStatus.Success);
+
+        if (data.Length * sizeof(T) != desc.TextureDescription.GetTotalBytes())
+        {
+            throw new ArgumentException("Data size does not match texture size.");
+        }
+
+        desc.TextureDescription.Format.GetSurfaceInfo(desc.TextureDescription.Width, desc.TextureDescription.Height, out var rowPitch, out var slicePitch, out _);
+
+        var sateBefore = ResourceDatabase.GetResourceState(texture.AsResource())
+            .GetValueOrThrow(ResultStatus.Success);
 
-        var sateBefore = ResourceDatabase.GetResourceState(texture.AsResource());
         var needTransition = sateBefore != ResourceState.CopyDest;
 
         if (needTransition)
@@ -182,7 +201,7 @@ public readonly unsafe ref struct RenderingContext
             _directCmd.ResourceBarrier(texture.AsResource(), sateBefore, ResourceState.CopyDest);
         }
 
-        fixed (byte* pData = data)
+        fixed (T* pData = data)
         {
             var subresourceData = new SubResourceData
             {
diff --git a/Ghost.Graphics/D3D12/D3D12CommandBuffer.cs b/Ghost.Graphics/D3D12/D3D12CommandBuffer.cs
index e8f2213..9d519d5 100644
--- a/Ghost.Graphics/D3D12/D3D12CommandBuffer.cs
+++ b/Ghost.Graphics/D3D12/D3D12CommandBuffer.cs
@@ -5,6 +5,7 @@ using Ghost.Graphics.D3D12.Utilities;
 using Ghost.Graphics.RHI;
 using Misaki.HighPerformance.LowLevel;
 using Misaki.HighPerformance.LowLevel.Utilities;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using TerraFX.Interop.DirectX;
 using TerraFX.Interop.Windows;
@@ -26,6 +27,7 @@ internal unsafe class D3D12CommandBuffer : ICommandBuffer
     private readonly D3D12DescriptorAllocator _descriptorAllocator;
     private readonly CommandBufferType _type;
 
+    private CommandError _lastError;
     private ushort _commandCount;
     private bool _isRecording;
     private bool _disposed;
@@ -124,6 +126,25 @@ internal unsafe class D3D12CommandBuffer : ICommandBuffer
         _commandCount++;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#if DEBUG
+    [DoesNotReturn]
+#endif
+    private void RecordError(string cmdName, ResultStatus status)
+    {
+#if DEBUG
+        throw new InvalidOperationException($"Error at {cmdName} with {status}");
+#else
+
+        _lastError = new CommandError
+        {
+            CommandName = cmdName,
+            CommandIndex = _commandCount,
+            Status = status
+        };
+#endif
+    }
+
     public void Begin()
     {
         void ResetCommandList()
@@ -154,13 +175,20 @@ internal unsafe class D3D12CommandBuffer : ICommandBuffer
         _isRecording = true;
     }
 
-    public void End()
+    public Result End()
     {
         ThrowIfDisposed();
         ThrowIfNotRecording();
 
         _commandList.Get()->Close();
         _isRecording = false;
+
+        if (_lastError.Status != ResultStatus.Success)
+        {
+            return Result.Failure($"Command buffer ended with errors at {_lastError.CommandIndex}, command '{_lastError.CommandName}': {_lastError.Status}");
+        }
+
+        return Result.Success();
     }
 
     public void SetScissorRect(RectDesc rect)
@@ -182,7 +210,7 @@ internal unsafe class D3D12CommandBuffer : ICommandBuffer
         var count = 0u;
         var pBarriers = stackalloc D3D12_RESOURCE_BARRIER[barrierDescs.Length];
 
-        for (int i = 0; i < barrierDescs.Length; i++)
+        for (var i = 0; i < barrierDescs.Length; i++)
         {
             var desc = barrierDescs[i];
             if (desc.StateBefore == desc.StateAfter)
@@ -192,23 +220,32 @@ internal unsafe class D3D12CommandBuffer : ICommandBuffer
 
             if (!desc.Resource.IsValid)
             {
-                throw new ArgumentException($"Barrier resource at index {i} is not a valid resource handle");
+                RecordError(nameof(ResourceBarrier), ResultStatus.InvalidArgument);
+                continue;
             }
 
-            ref var resourceRecord = ref _resourceDatabase.GetResourceRecord(desc.Resource.AsResource());
-            if (resourceRecord.state != desc.StateBefore)
+            var recordResult = _resourceDatabase.GetResourceRecord(desc.Resource);
+            if (recordResult.Status != ResultStatus.Success)
             {
-                throw new InvalidOperationException($"Resource state mismatch: expected {desc.StateBefore}, actual {resourceRecord.state}");
+                RecordError(nameof(ResourceBarrier), recordResult.Status);
+                continue;
             }
 
-            var barrier = D3D12_RESOURCE_BARRIER.InitTransition(resourceRecord.ResourcePtr,
+            ref var record = ref recordResult.Value;
+            if (record.state != desc.StateBefore)
+            {
+                RecordError(nameof(ResourceBarrier), ResultStatus.InvalidState);
+                continue;
+            }
+
+            var barrier = D3D12_RESOURCE_BARRIER.InitTransition(record.ResourcePtr,
                 desc.StateBefore.ToD3D12States(), desc.StateAfter.ToD3D12States());
 
             pBarriers[count] = barrier;
             count++;
 
             // Update the resource state in the database
-            resourceRecord.state = desc.StateAfter;
+            record.state = desc.StateAfter;
         }
 
         _commandList.Get()->ResourceBarrier(count, pBarriers);
@@ -216,28 +253,49 @@ internal unsafe class D3D12CommandBuffer : ICommandBuffer
 
     public void ResourceBarrier(Handle<GPUResource> resource, ResourceState stateBefore, ResourceState stateAfter)
     {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+        IncrementCommandCount();
+
         if (stateBefore == stateAfter)
         {
             return;
         }
 
-        ref var resourceRecord = ref _resourceDatabase.GetResourceRecord(resource);
-        if (resourceRecord.state != stateBefore)
+        var recordResult = _resourceDatabase.GetResourceRecord(resource);
+        if (recordResult.Status != ResultStatus.Success)
         {
-            throw new InvalidOperationException($"Resource state mismatch: expected {stateBefore}, actual {resourceRecord.state}");
+            RecordError(nameof(ResourceBarrier), recordResult.Status);
+            return;
         }
 
-        var barrier = D3D12_RESOURCE_BARRIER.InitTransition(resourceRecord.ResourcePtr,
+        ref var record = ref recordResult.Value;
+        var barrier = D3D12_RESOURCE_BARRIER.InitTransition(record.ResourcePtr,
             stateBefore.ToD3D12States(), stateAfter.ToD3D12States());
 
         _commandList.Get()->ResourceBarrier(1, &barrier);
-        resourceRecord.state = stateAfter;
+        record.state = stateAfter;
     }
 
     public void ResourceBarrier(Handle<GPUResource> resource, ResourceState stateAfter)
     {
-        var stateBefore = _resourceDatabase.GetResourceState(resource);
-        ResourceBarrier(resource, stateBefore, stateAfter);
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+        IncrementCommandCount();
+
+        var recordResult = _resourceDatabase.GetResourceRecord(resource);
+        if (recordResult.Status != ResultStatus.Success)
+        {
+            RecordError(nameof(ResourceBarrier), recordResult.Status);
+            return;
+        }
+
+        ref var record = ref recordResult.Value;
+        var barrier = D3D12_RESOURCE_BARRIER.InitTransition(record.ResourcePtr,
+            record.state.ToD3D12States(), stateAfter.ToD3D12States());
+
+        _commandList.Get()->ResourceBarrier(1, &barrier);
+        record.state = stateAfter;
     }
 
     public void SetRenderTargets(ReadOnlySpan<Handle<Texture>> renderTargets, Handle<Texture> depthTarget)
@@ -247,25 +305,44 @@ internal unsafe class D3D12CommandBuffer : ICommandBuffer
         IncrementCommandCount();
 
         var pRtvHandles = stackalloc D3D12_CPU_DESCRIPTOR_HANDLE[renderTargets.Length];
+        var rtvCount = 0u;
         for (var i = 0; i < renderTargets.Length; i++)
         {
             var handle = renderTargets[i];
             if (!handle.IsValid)
             {
-                throw new ArgumentException($"Render target at index {i} is not a valid texture handle");
+                RecordError(nameof(SetRenderTargets), ResultStatus.InvalidArgument);
+                continue;
             }
 
-            var descriptor = _resourceDatabase.GetResourceRecord(handle.AsResource()).viewGroup;
-            pRtvHandles[i] = _descriptorAllocator.GetCpuHandle(descriptor.rtv);
+            var recordResult = _resourceDatabase.GetResourceRecord(handle.AsResource());
+            if (recordResult.Status != ResultStatus.Success)
+            {
+                RecordError(nameof(SetRenderTargets), recordResult.Status);
+                continue;
+            }
+
+            var viewGroup = recordResult.Value.viewGroup;
+            pRtvHandles[i] = _descriptorAllocator.GetCpuHandle(viewGroup.rtv);
+
+            rtvCount++;
         }
 
         var pDsvHandle = stackalloc D3D12_CPU_DESCRIPTOR_HANDLE[depthTarget.IsValid ? 1 : 0];
         if (pDsvHandle != null)
         {
-            pDsvHandle[0] = _descriptorAllocator.GetCpuHandle(_resourceDatabase.GetResourceRecord(depthTarget.AsResource()).viewGroup.dsv);
+            var recordResult = _resourceDatabase.GetResourceRecord(depthTarget.AsResource());
+            if (recordResult.Status != ResultStatus.Success)
+            {
+                RecordError(nameof(SetRenderTargets), recordResult.Status);
+                return;
+            }
+
+            var viewGroup = recordResult.Value.viewGroup;
+            pDsvHandle[0] = _descriptorAllocator.GetCpuHandle(viewGroup.dsv);
         }
 
-        _commandList.Get()->OMSetRenderTargets((uint)renderTargets.Length, pRtvHandles, FALSE, pDsvHandle);
+        _commandList.Get()->OMSetRenderTargets(rtvCount, pRtvHandles, FALSE, pDsvHandle);
     }
 
     public void BeginRenderPass(ReadOnlySpan<PassRenderTargetDesc> rtDescs, PassDepthStencilDesc depthDesc, bool allowUAVWrites = false)
@@ -280,11 +357,21 @@ internal unsafe class D3D12CommandBuffer : ICommandBuffer
             var rtDesc = rtDescs[i];
             if (!rtDesc.Texture.IsValid)
             {
-                throw new ArgumentException($"Render target at index {i} is not a valid texture handle");
+                RecordError(nameof(BeginRenderPass), ResultStatus.InvalidArgument);
+                continue;
             }
 
-            var resourceInfo = _resourceDatabase.GetResourceRecord(rtDesc.Texture.AsResource());
-            var cpuHandle = _descriptorAllocator.GetCpuHandle(resourceInfo.viewGroup.rtv);
+            var recordResult = _resourceDatabase.GetResourceRecord(rtDesc.Texture.AsResource());
+            if (recordResult.Status != ResultStatus.Success)
+            {
+                RecordError(nameof(BeginRenderPass), recordResult.Status);
+                continue;
+            }
+
+            var record = recordResult.Value;
+            var cpuHandle = _descriptorAllocator.GetCpuHandle(record.viewGroup.rtv);
+            var format = record.desc.TextureDescription.Format.ToDXGIFormat();
+            var clearColor = rtDesc.ClearColor;
 
             var desc = new D3D12_RENDER_PASS_RENDER_TARGET_DESC
             {
@@ -294,10 +381,7 @@ internal unsafe class D3D12CommandBuffer : ICommandBuffer
                     Type = D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR,
                     Clear = new D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS
                     {
-                        ClearValue = new D3D12_CLEAR_VALUE
-                        {
-                            Format = resourceInfo.desc.TextureDescription.Format.ToDXGIFormat(),
-                        }
+                        ClearValue = new D3D12_CLEAR_VALUE(format, (float*)&clearColor)
                     }
                 },
                 EndingAccess = new D3D12_RENDER_PASS_ENDING_ACCESS
@@ -306,19 +390,22 @@ internal unsafe class D3D12CommandBuffer : ICommandBuffer
                 }
             };
 
-            desc.BeginningAccess.Clear.ClearValue.Color[0] = rtDesc.ClearColor.r;
-            desc.BeginningAccess.Clear.ClearValue.Color[1] = rtDesc.ClearColor.g;
-            desc.BeginningAccess.Clear.ClearValue.Color[2] = rtDesc.ClearColor.b;
-            desc.BeginningAccess.Clear.ClearValue.Color[3] = rtDesc.ClearColor.a;
-
             pRtvDescs[i] = desc;
         }
 
         var pDsvDesc = stackalloc D3D12_RENDER_PASS_DEPTH_STENCIL_DESC[depthDesc.Texture.IsValid ? 1 : 0];
         if (pDsvDesc != null)
         {
-            var resourceInfo = _resourceDatabase.GetResourceRecord(depthDesc.Texture.AsResource());
-            var cpuHandle = _descriptorAllocator.GetCpuHandle(resourceInfo.viewGroup.dsv);
+            var recordResult = _resourceDatabase.GetResourceRecord(depthDesc.Texture.AsResource());
+            if (recordResult.Status != ResultStatus.Success)
+            {
+                RecordError(nameof(BeginRenderPass), recordResult.Status);
+                return;
+            }
+
+            var record = recordResult.Value;
+            var cpuHandle = _descriptorAllocator.GetCpuHandle(record.viewGroup.dsv);
+            var format = record.desc.TextureDescription.Format.ToDXGIFormat();
 
             var desc = new D3D12_RENDER_PASS_DEPTH_STENCIL_DESC
             {
@@ -328,15 +415,7 @@ internal unsafe class D3D12CommandBuffer : ICommandBuffer
                     Type = D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR,
                     Clear = new D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS
                     {
-                        ClearValue = new D3D12_CLEAR_VALUE
-                        {
-                            Format = resourceInfo.desc.TextureDescription.Format.ToDXGIFormat(),
-                            DepthStencil = new D3D12_DEPTH_STENCIL_VALUE
-                            {
-                                Depth = depthDesc.ClearDepth,
-                                Stencil = depthDesc.ClearStencil
-                            }
-                        }
+                        ClearValue = new D3D12_CLEAR_VALUE(format, depthDesc.ClearDepth, depthDesc.ClearStencil)
                     }
                 }
             };
@@ -402,12 +481,19 @@ internal unsafe class D3D12CommandBuffer : ICommandBuffer
         ThrowIfNotRecording();
         IncrementCommandCount();
 
-        var resource = _resourceDatabase.GetResource(buffer.AsResource());
+        var recordResult = _resourceDatabase.GetResourceRecord(buffer.AsResource());
+        if (recordResult.Status != ResultStatus.Success)
+        {
+            RecordError(nameof(BeginRenderPass), recordResult.Status);
+            return;
+        }
+
+        var record = recordResult.Value;
         var vbView = new D3D12_VERTEX_BUFFER_VIEW
         {
-            BufferLocation = resource.Get()->GetGPUVirtualAddress() + offset,
-            SizeInBytes = (uint)(resource.Get()->GetDesc().Width - offset),
-            StrideInBytes = _resourceDatabase.GetResourceDescription(buffer.AsResource()).BufferDescription.Stride
+            BufferLocation = record.ResourcePtr.Get()->GetGPUVirtualAddress() + offset,
+            SizeInBytes = (uint)(record.ResourcePtr.Get()->GetDesc().Width - offset),
+            StrideInBytes = record.desc.BufferDescription.Stride
         };
 
         _commandList.Get()->IASetVertexBuffers(slot, 1, &vbView);
@@ -541,8 +627,8 @@ internal unsafe class D3D12CommandBuffer : ICommandBuffer
             d3d12Subresources[i] = new D3D12_SUBRESOURCE_DATA
             {
                 pData = subresources[i].pData,
-                RowPitch = subresources[i].rowPitch,
-                SlicePitch = subresources[i].slicePitch
+                RowPitch = (nint)subresources[i].rowPitch,
+                SlicePitch = (nint)subresources[i].slicePitch
             };
         }
 
@@ -566,7 +652,8 @@ internal unsafe class D3D12CommandBuffer : ICommandBuffer
         var pSrcResource = _resourceDatabase.GetResource(src.AsResource());
         if (pSrcResource == null || pDestResource == null)
         {
-            throw new ArgumentException("Source or destination buffer is not valid");
+            RecordError(nameof(CopyBuffer), ResultStatus.InvalidArgument);
+            return;
         }
 
         if (numBytes == 0)
diff --git a/Ghost.Graphics/D3D12/D3D12GraphicsEngine.cs b/Ghost.Graphics/D3D12/D3D12GraphicsEngine.cs
index f87700a..6b8a796 100644
--- a/Ghost.Graphics/D3D12/D3D12GraphicsEngine.cs
+++ b/Ghost.Graphics/D3D12/D3D12GraphicsEngine.cs
@@ -1,3 +1,4 @@
+using Ghost.Core;
 using Ghost.Graphics.Contracts;
 using Ghost.Graphics.RHI;
 using Ghost.Graphics.Utilities;
@@ -134,7 +135,7 @@ internal class D3D12GraphicsEngine : IGraphicsEngine
     {
         ThrowIfDisposed();
 
-        _copyCommandBuffer.End();
+        _copyCommandBuffer.End().ThrowIfFailed();
         _resourceAllocator.ReleaseTempResources();
         _descriptorAllocator.ResetCbvSrvUavDynamicHeap();
         _descriptorAllocator.ResetDSVDynamicHeap();
diff --git a/Ghost.Graphics/D3D12/D3D12Renderer.cs b/Ghost.Graphics/D3D12/D3D12Renderer.cs
index 223bd7e..0e1ce3a 100644
--- a/Ghost.Graphics/D3D12/D3D12Renderer.cs
+++ b/Ghost.Graphics/D3D12/D3D12Renderer.cs
@@ -198,7 +198,7 @@ internal class D3D12Renderer : IRenderer
             //     BlitToDestination(_renderTarget, backBufferRT, frame.commandBuffer);
             // }
 
-            frame.commandBuffer.End();
+            frame.commandBuffer.End().ThrowIfFailed();
 
             _graphicsEngine.Device.GraphicsQueue.Submit(frame.commandBuffer);
             _swapChain?.Present();
diff --git a/Ghost.Graphics/D3D12/D3D12ResourceAllocator.cs b/Ghost.Graphics/D3D12/D3D12ResourceAllocator.cs
index e412b40..52818cc 100644
--- a/Ghost.Graphics/D3D12/D3D12ResourceAllocator.cs
+++ b/Ghost.Graphics/D3D12/D3D12ResourceAllocator.cs
@@ -10,6 +10,7 @@ using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using TerraFX.Interop.DirectX;
 using TerraFX.Interop.Windows;
+
 using static TerraFX.Aliases.D3D12_Alias;
 using static TerraFX.Aliases.D3D12MA_Alias;
 using static TerraFX.Aliases.DXGI_Alias;
diff --git a/Ghost.Graphics/D3D12/D3D12ResourceDatabase.cs b/Ghost.Graphics/D3D12/D3D12ResourceDatabase.cs
index 2531431..c89e95d 100644
--- a/Ghost.Graphics/D3D12/D3D12ResourceDatabase.cs
+++ b/Ghost.Graphics/D3D12/D3D12ResourceDatabase.cs
@@ -6,6 +6,7 @@ using Misaki.HighPerformance.Collections;
 using Misaki.HighPerformance.LowLevel;
 using Misaki.HighPerformance.LowLevel.Buffer;
 using Misaki.HighPerformance.LowLevel.Collections;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using TerraFX.Interop.DirectX;
 
@@ -13,7 +14,7 @@ namespace Ghost.Graphics.D3D12;
 
 internal class D3D12ResourceDatabase : IResourceDatabase
 {
-    internal unsafe struct ResourceRecord
+    internal unsafe record struct ResourceRecord
     {
         [StructLayout(LayoutKind.Explicit)]
         public struct ResourceUnion
@@ -171,17 +172,17 @@ internal class D3D12ResourceDatabase : IResourceDatabase
         return _resources.Contains(handle.id, handle.generation);
     }
 
-    public ref ResourceRecord GetResourceRecord(Handle<GPUResource> handle)
+    public RefResult<ResourceRecord, ResultStatus> GetResourceRecord(Handle<GPUResource> handle)
     {
         ObjectDisposedException.ThrowIf(_disposed, this);
 
         ref var info = ref _resources.GetElementReferenceAt(handle.id, handle.generation, out var exist);
         if (!exist)
         {
-            throw new KeyNotFoundException($"Resource with handle {handle} not found.");
+            return Result.CreateRef(ref Unsafe.NullRef<ResourceRecord>(), ResultStatus.NotFound);
         }
 
-        return ref info;
+        return Result.CreateRef(ref info, ResultStatus.Success);
     }
 
     public ref ResourceRecord GetResourceRecord(Handle<GPUResource> handle, out bool exist)
@@ -190,23 +191,30 @@ internal class D3D12ResourceDatabase : IResourceDatabase
         return ref _resources.GetElementReferenceAt(handle.id, handle.generation, out exist);
     }
 
-    public unsafe SharedPtr<ID3D12Resource> GetResource(Handle<GPUResource> handle)
+    public SharedPtr<ID3D12Resource> GetResource(Handle<GPUResource> handle)
     {
         ObjectDisposedException.ThrowIf(_disposed, this);
 
-        ref var info = ref GetResourceRecord(handle);
-        if (!info.Allocated)
+        var r = GetResourceRecord(handle);
+        if (r.Status != ResultStatus.Success)
         {
             return null;
         }
 
-        return info.ResourcePtr;
+        return r.Value.ResourcePtr;
     }
 
-    public ResourceState GetResourceState(Handle<GPUResource> handle)
+    public Result<ResourceState, ResultStatus> GetResourceState(Handle<GPUResource> handle)
     {
         ObjectDisposedException.ThrowIf(_disposed, this);
-        return GetResourceRecord(handle).state;
+
+        var r = GetResourceRecord(handle);
+        if (r.Status != ResultStatus.Success)
+        {
+            return Result.Create(ResourceState.Common, r.Status);
+        }
+
+        return Result.Create(r.Value.state, ResultStatus.Success);
     }
 
     public void SetResourceState(Handle<GPUResource> handle, ResourceState state)
@@ -222,10 +230,18 @@ internal class D3D12ResourceDatabase : IResourceDatabase
         info.state = state;
     }
 
-    public ResourceDesc GetResourceDescription(Handle<GPUResource> handle)
+    public Result<ResourceDesc, ResultStatus> GetResourceDescription(Handle<GPUResource> handle)
     {
         ObjectDisposedException.ThrowIf(_disposed, this);
-        return GetResourceRecord(handle).desc;
+
+        var r = GetResourceRecord(handle);
+
+        if (r.Status != ResultStatus.Success)
+        {
+            return Result.Create(default(ResourceDesc), r.Status);
+        }
+
+        return Result.Create(r.Value.desc, ResultStatus.Success);
     }
 
     public Result<uint, ResultStatus> GetBindlessIndex(Handle<GPUResource> handle)
@@ -238,7 +254,7 @@ internal class D3D12ResourceDatabase : IResourceDatabase
             return Result.Create(0u, ResultStatus.NotFound);
         }
 
-        return Result.Create((uint)info.viewGroup.srv.value, ResultStatus.NotFound);
+        return Result.Create((uint)info.viewGroup.srv.value, ResultStatus.Success);
     }
 
     public string? GetResourceName(Handle<GPUResource> handle)
diff --git a/Ghost.Graphics/D3D12/D3D12SwapChain.cs b/Ghost.Graphics/D3D12/D3D12SwapChain.cs
index 9ab3ba7..1bd4d75 100644
--- a/Ghost.Graphics/D3D12/D3D12SwapChain.cs
+++ b/Ghost.Graphics/D3D12/D3D12SwapChain.cs
@@ -186,16 +186,11 @@ internal unsafe class D3D12SwapChain : ISwapChain
             _resourceDatabase.ReleaseResource(_backBuffers[i].AsResource());
         }
 
-        // Resize the swap chain
-        if (_swapChain.Get()->ResizeBuffers(BufferCount, width, height, DXGI_FORMAT_B8G8R8A8_UNORM, (uint)DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING).FAILED)
-        {
-            throw new InvalidOperationException("Failed to resize swap chain buffers.");
-        }
+        ThrowIfFailed(_swapChain.Get()->ResizeBuffers(BufferCount, width, height, DXGI_FORMAT_B8G8R8A8_UNORM, (uint)DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING));
 
         Width = width;
         Height = height;
 
-        // Recreate back buffers
         CreateBackBuffers();
     }
 
diff --git a/Ghost.Graphics/Ghost.Graphics.csproj b/Ghost.Graphics/Ghost.Graphics.csproj
index 14138e6..96697ce 100644
--- a/Ghost.Graphics/Ghost.Graphics.csproj
+++ b/Ghost.Graphics/Ghost.Graphics.csproj
@@ -5,19 +5,15 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
-    <LangVersion>preview</LangVersion>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
-    <IsAotCompatible>True</IsAotCompatible>
-    <IsTrimmable>True</IsTrimmable>
     <DebugType>embedded</DebugType>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
     <IsAotCompatible>True</IsAotCompatible>
     <IsTrimmable>True</IsTrimmable>
-    <DebugType>embedded</DebugType>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/Ghost.Graphics/RHI/Common.cs b/Ghost.Graphics/RHI/Common.cs
index fd77c06..c93608f 100644
--- a/Ghost.Graphics/RHI/Common.cs
+++ b/Ghost.Graphics/RHI/Common.cs
@@ -263,8 +263,8 @@ public struct RectDesc
 public struct SubResourceData
 {
     public unsafe void* pData;
-    public nint rowPitch;
-    public nint slicePitch;
+    public uint rowPitch;
+    public uint slicePitch;
 }
 
 public struct PassRenderTargetDesc
@@ -303,7 +303,7 @@ public struct PassDepthStencilDesc
 
 public struct BarrierDesc
 {
-    public Handle<GraphicsBuffer> Resource
+    public Handle<GPUResource> Resource
     {
         get; set;
     }
@@ -681,6 +681,24 @@ public struct BufferDesc
     }
 }
 
+public struct CommandError
+{
+    public int CommandIndex
+    {
+        get; set;
+    }
+
+    public string CommandName
+    {
+        get; set;
+    }
+
+    public ResultStatus Status
+    {
+        get; set;
+    }
+}
+
 /// <summary>
 /// Swap chain description
 /// </summary>
diff --git a/Ghost.Graphics/RHI/ICommandBuffer.cs b/Ghost.Graphics/RHI/ICommandBuffer.cs
index 5b9a7e0..c4337f9 100644
--- a/Ghost.Graphics/RHI/ICommandBuffer.cs
+++ b/Ghost.Graphics/RHI/ICommandBuffer.cs
@@ -38,7 +38,7 @@ public interface ICommandBuffer : IDisposable
     /// <summary>
     /// Ends recording commands and prepares for submission
     /// </summary>
-    void End();
+    Result End();
 
     /// <summary>
     /// Sets the viewport for rendering
diff --git a/Ghost.Graphics/RHI/IResourceDatabase.cs b/Ghost.Graphics/RHI/IResourceDatabase.cs
index 72432e3..1e4babf 100644
--- a/Ghost.Graphics/RHI/IResourceDatabase.cs
+++ b/Ghost.Graphics/RHI/IResourceDatabase.cs
@@ -39,7 +39,7 @@ public interface IResourceDatabase : IDisposable
     /// </summary>
     /// <param name="handle">The handle that uniquely identifies the resource whose state is to be retrieved.</param>
     /// <returns>A ResourceState Value representing the current state of the resource associated with the specified handle.</returns>
-    ResourceState GetResourceState(Handle<GPUResource> handle);
+    Result<ResourceState, ResultStatus> GetResourceState(Handle<GPUResource> handle);
 
     /// <summary>
     /// Sets the state of the specified resource handle to the given Value.
@@ -53,7 +53,7 @@ public interface IResourceDatabase : IDisposable
     /// </summary>
     /// <param name="handle">A handle that identifies the GPU resource for which to obtain the description. Must reference a valid resource.</param>
     /// <returns>A ResourceDesc structure containing details about the specified GPU resource.</returns>
-    ResourceDesc GetResourceDescription(Handle<GPUResource> handle);
+    Result<ResourceDesc, ResultStatus> GetResourceDescription(Handle<GPUResource> handle);
 
     /// <summary>
     /// Retrieves the bindless index associated with the specified GPU resource handle.
diff --git a/Ghost.Graphics/RHI/RHIUtility.cs b/Ghost.Graphics/RHI/RHIUtility.cs
index a829160..8880921 100644
--- a/Ghost.Graphics/RHI/RHIUtility.cs
+++ b/Ghost.Graphics/RHI/RHIUtility.cs
@@ -2,7 +2,7 @@ namespace Ghost.Graphics.RHI;
 
 internal static class RHIUtility
 {
-    public static int GetBytesPerPixel(this TextureFormat format)
+    public static uint GetBytesPerPixel(this TextureFormat format)
     {
         return format switch
         {
@@ -16,12 +16,17 @@ internal static class RHIUtility
         };
     }
 
-    public static void GetSurfaceInfo(this TextureFormat format, int width, int height, out int rowPitch, out int slicePitch, out int rowCount)
+    public static uint GetTotalBytes(this TextureDesc desc)
+    {
+        return desc.Format.GetBytesPerPixel() * desc.Width * desc.Height * desc.Slice;
+    }
+
+    public static void GetSurfaceInfo(this TextureFormat format, uint width, uint height, out uint rowPitch, out uint slicePitch, out uint rowCount)
     {
         var bc = false;
         var packed = false;
         var planar = false;
-        var bpe = 0;
+        var bpe = 0u;
         
         //switch (Format)
         //{
@@ -86,31 +91,33 @@ internal static class RHIUtility
 
         if (bc)
         {
-            var numBlocksWide = 0;
+            var numBlocksWide = 0u;
             if (width > 0)
             {
-                numBlocksWide = Math.Max(1, (width + 3) / 4);
+                numBlocksWide = Math.Max(1u, (width + 3) / 4u);
             }
-            var numBlocksHigh = 0;
+
+            var numBlocksHigh = 0u;
             if (height > 0)
             {
-                numBlocksHigh = Math.Max(1, (height + 3) / 4);
+                numBlocksHigh = Math.Max(1u, (height + 3) / 4u);
             }
+
             rowPitch = numBlocksWide * bpe;
             rowCount = numBlocksHigh;
             slicePitch = rowPitch * numBlocksHigh;
         }
         else if (packed)
         {
-            rowPitch = ((width + 1) >> 1) * bpe;
+            rowPitch = ((width + 1u) >> 1) * bpe;
             rowCount = height;
             slicePitch = rowPitch * height;
         }
         else if (planar)
         {
-            rowPitch = ((width + 1) >> 1) * bpe;
+            rowPitch = ((width + 1u) >> 1) * bpe;
             slicePitch = (rowPitch * height) + ((rowPitch * height + 1) >> 1);
-            rowCount = (int)(height + ((height + 1u) >> 1));
+            rowCount = height + ((height + 1u) >> 1);
         }
         else
         {
diff --git a/Ghost.Graphics/RenderPasses/MeshRenderPass.cs b/Ghost.Graphics/RenderPasses/MeshRenderPass.cs
index ebf0bba..ff918ea 100644
--- a/Ghost.Graphics/RenderPasses/MeshRenderPass.cs
+++ b/Ghost.Graphics/RenderPasses/MeshRenderPass.cs
@@ -91,7 +91,7 @@ internal class MeshRenderPass : IRenderPass
         {
             using var stream = File.OpenRead(_textureFiles[i]);
             using var imageData = ImageResult.FromStream(stream, ColorComponents.RGBA);
-
+            
             var desc = new TextureDesc
             {
                 Width = imageData.Width,
@@ -103,8 +103,7 @@ internal class MeshRenderPass : IRenderPass
                 Usage = TextureUsage.ShaderResource,
             };
 
-            _textures[i] = ctx.CreateTexture(ref desc);
-            ctx.UploadTexture(_textures[i], imageData.AsSpan());
+            _textures[i] = ctx.CreateTexture(ref desc, imageData.AsSpan());
         }
 
         var samplerDesc = new SamplerDesc