Added new RHI abstraction layer;

Added new console debug page to UnitTest;

Ghost.Graphics/D3D12/D3D12SwapChain.cs

@@ -0,0 +1,174 @@
+using Ghost.Graphics.Contracts;
+using Ghost.Graphics.RHI;
+using Ghost.Graphics.D3D12.Utilities;
+using Win32;
+using Win32.Graphics.Direct3D12;
+using Win32.Graphics.Dxgi;
+using Win32.Graphics.Dxgi.Common;
+
+namespace Ghost.Graphics.D3D12;
+
+/// <summary>
+/// D3D12 implementation of swap chain interface
+/// </summary>
+internal unsafe class D3D12SwapChain : ISwapChain
+{
+    private ComPtr<IDXGISwapChain4> _swapChain;
+    private readonly D3D12Texture[] _backBuffers;
+    private uint _currentBackBufferIndex;
+    private bool _disposed;
+
+    public uint Width { get; private set; }
+    public uint Height { get; private set; }
+    public uint BufferCount { get; }
+
+    public D3D12SwapChain(ComPtr<IDXGIFactory7> factory, ID3D12CommandQueue* commandQueue, SwapChainDesc desc)
+    {
+        _backBuffers = new D3D12Texture[desc.BufferCount];
+
+        Width = desc.Width;
+        Height = desc.Height;
+        BufferCount = desc.BufferCount;
+
+        CreateSwapChain(factory, commandQueue, desc);
+        CreateBackBuffers();
+    }
+
+    private void CreateSwapChain(ComPtr<IDXGIFactory7> factory, ID3D12CommandQueue* commandQueue, SwapChainDesc desc)
+    {
+        var swapChainDesc = new SwapChainDescription1
+        {
+            Width = desc.Width,
+            Height = desc.Height,
+            Format = ConvertTextureFormat(desc.Format),
+            SampleDesc = new SampleDescription(1, 0),
+            BufferUsage = Usage.BackBuffer | Usage.RenderTargetOutput,
+            BufferCount = desc.BufferCount,
+            Scaling = Scaling.Stretch,
+            SwapEffect = SwapEffect.FlipDiscard,
+            AlphaMode = AlphaMode.Ignore,
+            Flags = SwapChainFlags.AllowTearing,
+            Stereo = false,
+        };
+
+        using ComPtr<IDXGISwapChain1> tempSwapChain = default;
+
+        switch (desc.Target.Type)
+        {
+            case SwapChainTargetType.Composition:
+                factory.Get()->CreateSwapChainForComposition((IUnknown*)commandQueue, &swapChainDesc, null, tempSwapChain.GetAddressOf());
+
+                // Set the composition surface
+                if (desc.Target.CompositionSurface != null)
+                {
+                    var swapChainPanelNative = ISwapChainPanelNative.FromSwapChainPanel(desc.Target.CompositionSurface);
+                    swapChainPanelNative.SetSwapChain((IntPtr)tempSwapChain.Get());
+                }
+                break;
+
+            case SwapChainTargetType.WindowHandle:
+                var swapChainFullscreenDesc = new SwapChainFullscreenDescription
+                {
+                    Windowed = true,
+                };
+
+                factory.Get()->CreateSwapChainForHwnd(
+                    (IUnknown*)commandQueue,
+                    desc.Target.WindowHandle,
+                    &swapChainDesc,
+                    &swapChainFullscreenDesc,
+                    null,
+                    tempSwapChain.GetAddressOf());
+                break;
+
+            default:
+                throw new ArgumentException("Unsupported swap chain target type.");
+        }
+
+        if (tempSwapChain.Get()->QueryInterface(__uuidof<IDXGISwapChain4>(), _swapChain.GetVoidAddressOf()).Failure)
+        {
+            throw new InvalidOperationException("Failed to create IDXGISwapChain4 interface.");
+        }
+
+        _currentBackBufferIndex = _swapChain.Get()->GetCurrentBackBufferIndex();
+    }
+
+    private void CreateBackBuffers()
+    {
+        for (uint i = 0; i < BufferCount; i++)
+        {
+            ComPtr<ID3D12Resource> backBuffer = default;
+            _swapChain.Get()->GetBuffer(i, __uuidof<ID3D12Resource>(), backBuffer.GetVoidAddressOf());
+            backBuffer.Get()->SetName($"SwapChain_BackBuffer_{i}");
+
+            _backBuffers[i] = new D3D12Texture(backBuffer.Move(), Width, Height, TextureFormat.B8G8R8A8_UNorm);
+        }
+    }
+
+    public ITexture GetCurrentBackBuffer()
+    {
+        _currentBackBufferIndex = _swapChain.Get()->GetCurrentBackBufferIndex();
+        return _backBuffers[_currentBackBufferIndex];
+    }
+
+    public void Present(bool vsync = true)
+    {
+        var presentFlags = PresentFlags.None;
+        var syncInterval = vsync ? 1u : 0u;
+
+        if (_swapChain.Get()->Present(syncInterval, presentFlags).Failure)
+        {
+            throw new InvalidOperationException("Failed to present swap chain.");
+        }
+    }
+
+    public void Resize(uint width, uint height)
+    {
+        if (Width == width && Height == height)
+            return;
+
+        // Release old back buffers
+        for (int i = 0; i < _backBuffers.Length; i++)
+        {
+            _backBuffers[i]?.Dispose();
+        }
+
+        // Resize the swap chain
+        if (_swapChain.Get()->ResizeBuffers(BufferCount, width, height, Format.B8G8R8A8Unorm, SwapChainFlags.AllowTearing).Failure)
+        {
+            throw new InvalidOperationException("Failed to resize swap chain buffers.");
+        }
+
+        Width = width;
+        Height = height;
+
+        // Recreate back buffers
+        CreateBackBuffers();
+        _currentBackBufferIndex = _swapChain.Get()->GetCurrentBackBufferIndex();
+    }
+
+    private static Format ConvertTextureFormat(TextureFormat format)
+    {
+        return format switch
+        {
+            TextureFormat.R8G8B8A8_UNorm => Format.R8G8B8A8Unorm,
+            TextureFormat.B8G8R8A8_UNorm => Format.B8G8R8A8Unorm,
+            TextureFormat.R16G16B16A16_Float => Format.R16G16B16A16Float,
+            TextureFormat.R32G32B32A32_Float => Format.R32G32B32A32Float,
+            _ => throw new ArgumentException($"Unsupported texture format: {format}")
+        };
+    }
+
+    public void Dispose()
+    {
+        if (_disposed) return;
+
+        for (int i = 0; i < _backBuffers.Length; i++)
+        {
+            _backBuffers[i]?.Dispose();
+        }
+
+        _swapChain.Dispose();
+        _disposed = true;
+    }
+}