Added new RHI abstraction layer;

Added new console debug page to UnitTest;

Ghost.Graphics/Examples/ModernRenderingExample.cs

@@ -0,0 +1,123 @@
+using Ghost.Graphics;
+using Ghost.Graphics.RHI;
+using Ghost.Graphics.D3D12;
+
+namespace Ghost.Graphics.Examples;
+
+/// <summary>
+/// Example showing how to use the new RHI architecture
+/// </summary>
+public class ModernRenderingExample
+{
+    private IRenderDevice _device;
+    private RenderSystem _renderSystem;
+    private IRenderer _forwardRenderer;
+    private ISwapChain _swapChain;
+
+    public void Initialize()
+    {
+        // Create modern RHI device
+        _device = new D3D12RenderDevice();
+
+        // Create render system for frame management
+        _renderSystem = new RenderSystem(_device);
+
+        // Create a renderer using RHI abstractions
+        _forwardRenderer = new D3D12Renderer(_device);
+
+        // Create swap chain for presentation
+        var swapChainDesc = new SwapChainDesc
+        {
+            Width = 1920,
+            Height = 1080,
+            BufferCount = 2,
+            Format = TextureFormat.R8G8B8A8_UNorm,
+            // Presenter would be set based on your window system
+        };
+        _swapChain = _device.CreateSwapChain(swapChainDesc);
+
+        // Configure renderer
+        _forwardRenderer.SetSwapChain(_swapChain);
+
+        // Register renderer with render system
+        _renderSystem.AddRenderer(_forwardRenderer);
+
+        // Start rendering loop
+        _renderSystem.Start();
+    }
+
+    public void RenderOffscreen()
+    {
+        // Example of rendering to off-screen color target
+        var colorRenderTarget = RenderTargetDesc.Color(1024, 1024, TextureFormat.R8G8B8A8_UNorm);
+        var offscreenColorTarget = _device.CreateRenderTarget(colorRenderTarget);
+
+        var colorRenderer = new D3D12Renderer(_device);
+        colorRenderer.SetRenderTarget(offscreenColorTarget);
+        _renderSystem.AddRenderer(colorRenderer);
+
+        // Example of rendering to depth target
+        var depthRenderTarget = RenderTargetDesc.Depth(1024, 1024, TextureFormat.D24_UNorm_S8_UInt);
+        var offscreenDepthTarget = _device.CreateRenderTarget(depthRenderTarget);
+
+        var depthRenderer = new D3D12Renderer(_device);
+        depthRenderer.SetRenderTarget(offscreenDepthTarget);
+        _renderSystem.AddRenderer(depthRenderer);
+    }
+
+    public void Update()
+    {
+        // Signal that CPU work is ready
+        _renderSystem.SignalCPUReady();
+
+        // Wait for GPU to complete previous frame (optional)
+        _renderSystem.WaitForGPUReady(16); // 16ms timeout for 60fps
+    }
+
+    public void Dispose()
+    {
+        _renderSystem?.Stop();
+        _renderSystem?.Dispose();
+
+        _forwardRenderer?.Dispose();
+        _swapChain?.Dispose();
+        _device?.Dispose();
+    }
+}
+
+/// <summary>
+/// Example showing legacy vs modern usage
+/// </summary>
+public static class LegacyVsModernExample
+{
+    public static void LegacyApproach()
+    {
+        // OLD WAY - tightly coupled to D3D12
+        GraphicsPipeline.Initialize();
+
+        var graphicsDevice = GraphicsPipeline.GraphicsDevice;
+        // Renderer creation and management handled internally
+        // Frame synchronization handled by GraphicsPipeline
+
+        GraphicsPipeline.Start();
+        GraphicsPipeline.SignalCPUReady();
+        GraphicsPipeline.WaitForGPUReady();
+    }
+
+    public static void ModernApproach()
+    {
+        // NEW WAY - clean RHI abstractions
+        var device = new D3D12RenderDevice();
+        var renderSystem = new RenderSystem(device);
+
+        var renderer = new D3D12Renderer(device);
+        var swapChain = device.CreateSwapChain(new SwapChainDesc { /* ... */ });
+
+        renderer.SetSwapChain(swapChain);
+        renderSystem.AddRenderer(renderer);
+
+        renderSystem.Start();
+        renderSystem.SignalCPUReady();
+        renderSystem.WaitForGPUReady();
+    }
+}