Refactor: add command allocator & render target strategies

Major refactor of graphics infrastructure:
- Introduce ICommandAllocator and D3D12CommandAllocator for explicit command buffer management.
- Change ICommandBuffer.Begin to require an allocator.
- Add IRenderTargetStrategy abstraction with swap chain and texture implementations.
- Update IRenderer to use RenderTargetStrategy instead of direct handle.
- Add DPI scaling support to swap chains (ScaleX/ScaleY, SetScale).
- RenderSystem now supports thread-safe swap chain resize requests.
- Remove persistent copy command buffer; use per-frame allocators.
- Make Logger public/static and clean up API visibility.
- Update .editorconfig and debug layer enablement.
These changes improve modularity, DPI-awareness, and future extensibility.

Ghost.Graphics/D3D12/D3D12Renderer.cs

@@ -2,6 +2,7 @@ using Ghost.Core;
 using Ghost.Graphics.RHI;
 using Ghost.Graphics.Core;
 using Ghost.Graphics.RenderPasses;
+using Ghost.Graphics.Contracts;
 
 namespace Ghost.Graphics.D3D12;
 
@@ -10,48 +11,30 @@ namespace Ghost.Graphics.D3D12;
 /// </summary>
 internal class D3D12Renderer : IRenderer
 {
-    private struct FrameResource : IDisposable
-    {
-        public ICommandBuffer commandBuffer;
-        public ulong fenceValue;
-
-        public FrameResource(D3D12GraphicsEngine graphicsEngine, int index)
-        {
-            commandBuffer = graphicsEngine.CreateCommandBuffer();
-            commandBuffer.Name = $"Frame Command Buffer {index}";
-            fenceValue = 0;
-        }
-
-        public readonly void Dispose()
-        {
-            commandBuffer?.Dispose();
-        }
-    }
-
     private readonly D3D12GraphicsEngine _graphicsEngine;
-    private uint _frameIndex;
-
     private readonly D3D12ResourceDatabase _resourceDatabase;
 
-    private Handle<Texture> _renderTarget;
+    private readonly ICommandBuffer _commandBuffer;
 
+    private uint _frameIndex;
     private bool _disposed;
 
     // NOTE: Testing only.
     private readonly MeshRenderPass _pass;
 
-    public Handle<Texture> RenderTarget => _renderTarget;
+    public IRenderTargetStrategy? RenderTargetStrategy
+    {
+        get; set;
+    }
 
-    // TODO: Add render passes support
-    // private ImmutableArray<IRenderPass> _renderPasses;
+    // TODO: Add render graph support
 
     public D3D12Renderer(D3D12GraphicsEngine graphicsEngine, D3D12ResourceDatabase resourceDatabase)
     {
         _graphicsEngine = graphicsEngine;
         _resourceDatabase = resourceDatabase;
 
-        _renderTarget = Handle<Texture>.Invalid;
-
+        _commandBuffer = _graphicsEngine.CreateCommandBuffer(CommandBufferType.Graphics);
 
         // NOTE: Testing only.
         _pass = new();
@@ -62,36 +45,47 @@ internal class D3D12Renderer : IRenderer
         Dispose();
     }
 
-    public void SetRenderTarget(Handle<Texture> renderTarget)
+    public Result Render(ICommandAllocator commandAllocator)
     {
-        _resourceDatabase.ReleaseResource(_renderTarget.AsResource());
-        _renderTarget = renderTarget;
-    }
-
-    public Result Render(ICommandBuffer commandBuffer)
-    {
-        if (!_renderTarget.IsValid)
+        if (RenderTargetStrategy is null)
         {
-            return Result.Failure("Render target is not set.");
+            return Result.Failure("Render target strategy is not set.");
         }
 
-        commandBuffer.Begin();
+        var target = RenderTargetStrategy.GetRenderTarget();
+        if (target.IsNotValid)
+        {
+            return Result.Failure("Render target is invalid.");
+        }
+
+        _commandBuffer.Begin(commandAllocator);
+        RenderTargetStrategy.BeginRender(_commandBuffer);
 
         // NOTE: Temperary solution: render directly to the swap chain back buffer if available.
         // HACK: This is hard coded for testing purposes only.
 
-        var error = RenderScene(_renderTarget, commandBuffer);
+        var error = RenderScene(target);
         if (error != ErrorStatus.None)
         {
-            commandBuffer.End();
+            _commandBuffer.End();
             return Result.Failure(error);
         }
 
-        return commandBuffer.End();
+        RenderTargetStrategy.EndRender(_commandBuffer);
+        var r = _commandBuffer.End();
+        if (r.IsFailure)
+        {
+            return r;
+        }
+
+        _graphicsEngine.Device.GraphicsQueue.Submit(_commandBuffer);
+        RenderTargetStrategy.Present();
+
+        return Result.Success();
     }
 
     // TODO: A proper render graph integration.
-    private ErrorStatus RenderScene(Handle<Texture> target, ICommandBuffer cmd)
+    private ErrorStatus RenderScene(Handle<Texture> target)
     {
         var clearColor = new Color128 { r = 1.0f, g = 0.0f, b = 1.0f, a = 1.0f };
 
@@ -112,7 +106,7 @@ internal class D3D12Renderer : IRenderer
         };
 
         // NOTE: Testing only.
-        var ctx = new RenderingContext(_graphicsEngine, cmd, _graphicsEngine.CopyCommandBuffer, null!);
+        var ctx = new RenderingContext(_graphicsEngine, _commandBuffer);
         if (_frameIndex == 0)
         {
             _pass.Initialize(ref ctx);
@@ -124,18 +118,20 @@ internal class D3D12Renderer : IRenderer
             return result.Error;
         }
 
+        // TODO: Decouple viewport and scissor from the texture size.
         var texDesc = result.Value.TextureDescription;
         var viewport = new ViewportDesc { Width = texDesc.Width, Height = texDesc.Height, MinDepth = 0, MaxDepth = 1 };
         var scissor = new RectDesc { Right = texDesc.Width, Bottom = texDesc.Height };
 
-        cmd.BeginRenderPass(rtDesc, depthDesc, false);
-        cmd.SetViewport(viewport);
-        cmd.SetScissorRect(scissor);
+        _commandBuffer.BeginRenderPass(rtDesc, depthDesc, false);
+        _commandBuffer.SetViewport(viewport);
+        _commandBuffer.SetScissorRect(scissor);
 
         // NOTE: Testing only.
         _pass.Execute(ref ctx);
 
-        cmd.EndRenderPass();
+        _commandBuffer.EndRenderPass();
+        _frameIndex++;
 
         return ErrorStatus.None;
     }
@@ -150,6 +146,8 @@ internal class D3D12Renderer : IRenderer
         // NOTE: Testing only.
         _pass.Cleanup(_resourceDatabase);
 
+        _commandBuffer.Dispose();
+
         _disposed = true;
 
         GC.SuppressFinalize(this);