feat(render): support per-frame render payloads

Refactored the render pipeline system to introduce per-frame IRenderPayload management.
IRenderPipelineSettings now requires CreatePipeline and CreatePayload methods.
Updated RenderSystem and test pipeline to use the new payload model.
Removed legacy GhostRenderPipeline and test code.
Added RenderPipelineSystemAttribute for pipeline system registration.
Includes minor fixes such as version field type corrections and typo fixes.

BREAKING CHANGE: Render pipeline and payload creation APIs have changed; implementers must update to the new interface methods.

src/Test/Ghost.Graphics.Test/RenderPipeline/TestRenderPipeline.cs

@@ -104,11 +104,10 @@ public unsafe partial class TestRenderPipeline : IRenderPipeline
     {
         var testPayload = (TestRenderPayload)payload;
 
-        var renderSystem = testPayload.RenderSystem;
-        var resourceManager = renderSystem.ResourceManager;
-        var resourceDatabase = renderSystem.GraphicsEngine.ResourceDatabase;
+        var resourceManager = _renderSystem.ResourceManager;
+        var resourceDatabase = _renderSystem.GraphicsEngine.ResourceDatabase;
 
-        var requests = testPayload.FrameRequestData[frameIndex].renderRequests;
+        var requests = testPayload.renderRequests;
 
         for (var i = 0; i < requests.Count; i++)
         {
@@ -126,7 +125,7 @@ public unsafe partial class TestRenderPipeline : IRenderPipeline
             {
                 rt = request.colorTarget;
             }
-            else if (renderSystem.SwapChainManager.TryGetSwapChain(request.swapChainIndex, out var swapChain))
+            else if (_renderSystem.SwapChainManager.TryGetSwapChain(request.swapChainIndex, out var swapChain))
             {
                 rt = swapChain.GetCurrentBackBuffer();
             }
@@ -137,7 +136,7 @@ public unsafe partial class TestRenderPipeline : IRenderPipeline
 
             try
             {
-                var rtResult = renderSystem.GraphicsEngine.ResourceDatabase.GetResourceDescription(rt.AsResource());
+                var rtResult = _renderSystem.GraphicsEngine.ResourceDatabase.GetResourceDescription(rt.AsResource());
                 if (rtResult.IsFailure)
                 {
                     continue;
@@ -312,7 +311,7 @@ public unsafe partial class TestRenderPipeline : IRenderPipeline
             {
                 if (request.swapChainIndex >= 0)
                 {
-                    renderSystem.SwapChainManager.ReleaseSwapChain(request.swapChainIndex);
+                    _renderSystem.SwapChainManager.ReleaseSwapChain(request.swapChainIndex);
                 }
             }
         }

src/Test/Ghost.Graphics.Test/RenderPipeline/TestRenderPipelineSettings.cs

@@ -7,48 +7,38 @@ namespace Ghost.Graphics.Test.RenderPipeline;
 
 internal sealed class TestRenderPayload : IRenderPayload
 {
-    public class FrameData
+    public UnsafeList<RenderRequest> renderRequests;
+
+    public TestRenderPayload()
     {
-        public UnsafeList<RenderRequest> renderRequests;
+        renderRequests = new UnsafeList<RenderRequest>(2, Allocator.Persistent);
     }
 
-    private readonly RenderSystem _renderSystem;
-    private readonly FrameData[] _frameData;
-
-    public RenderSystem RenderSystem => _renderSystem;
-    public ReadOnlySpan<FrameData> FrameRequestData => _frameData;
-
-    public TestRenderPayload(RenderSystem renderSystem)
+    public void Reset()
     {
-        _renderSystem = renderSystem;
-        _frameData = new FrameData[renderSystem.MaxFrameLatency];
-
-        for (int i = 0; i < _frameData.Length; i++)
+        for (int i = 0; i < renderRequests.Count; i++)
         {
-            _frameData[i].renderRequests = new UnsafeList<RenderRequest>(2, Allocator.Persistent);
+            renderRequests[i].Dispose();
         }
-    }
 
-    public void AddRenderRequest(RenderRequest request)
-    {
-        var index = (int)(_renderSystem.CPUFenceValue % (uint)_frameData.Length);
-        _frameData[index].renderRequests.Add(request);
+        renderRequests.Clear();
     }
 
     public void Dispose()
     {
-        for (int i = 0; i < _frameData.Length; i++)
-        {
-            _frameData[i].renderRequests.Dispose();
-        }
+        renderRequests.Dispose();
     }
 }
 
 internal sealed class TestRenderPipelineSettings : IRenderPipelineSettings
 {
-    public void CreatePipeline(RenderSystem renderSystem, out IRenderPipeline renderPipeline, out IRenderPayload renderPayload)
+    public IRenderPipeline CreatePipeline(RenderSystem renderSystem)
     {
-        renderPipeline = new TestRenderPipeline(renderSystem);
-        renderPayload = new TestRenderPayload(renderSystem);
+        return new TestRenderPipeline(renderSystem);
+    }
+
+    public IRenderPayload CreatePayload(RenderSystem renderSystem)
+    {
+        return new TestRenderPayload();
     }
 }

src/Test/Ghost.Graphics.Test/Systems/RenderExtractionSystem.cs

@@ -1,6 +1,7 @@
 using Ghost.Core;
 using Ghost.Engine;
 using Ghost.Engine.Components;
+using Ghost.Engine.Systems;
 using Ghost.Entities;
 using Ghost.Graphics.Core;
 using Ghost.Graphics.Test.RenderPipeline;
@@ -9,6 +10,7 @@ using Misaki.HighPerformance.Mathematics;
 
 namespace Ghost.Graphics.Test.Systems;
 
+[RenderPipelineSystem<TestRenderPipelineSettings>]
 public class RenderExtractionSystem : ISystem
 {
     private RenderSystem _renderSystem = null!;
@@ -135,7 +137,7 @@ public class RenderExtractionSystem : ISystem
                 },
             };
 
-            ((TestRenderPayload)_renderSystem.RenderPayload).AddRenderRequest(request);
+            ((TestRenderPayload)_renderSystem.GetCurrentFramePayload()).renderRequests.Add(request);
         }
     }
 

src/Test/Ghost.Graphics.Test/Windows/GraphicsTestWindow.xaml.cs

@@ -1,10 +1,10 @@
 using Ghost.Core;
 using Ghost.Engine.Components;
-using Ghost.Engine.Systems;
 using Ghost.Engine.Utilities;
 using Ghost.Entities;
 using Ghost.Graphics.Core;
 using Ghost.Graphics.RHI;
+using Ghost.Graphics.Test.Systems;
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Controls;
 using Microsoft.UI.Xaml.Media;
@@ -53,7 +53,7 @@ public sealed partial class GraphicsTestWindow : Window
         {
             FrameBufferCount = 2,
             GraphicsAPI = GraphicsAPI.Direct3D12,
-            InitialRenderPipelineSettings = new RenderPasses.TestRenderPipelineSettings()
+            InitialRenderPipelineSettings = new RenderPipeline.TestRenderPipelineSettings()
         });
 
         _swapChain = _renderSystem.SwapChainManager.EnsureSwapChain(0, new SwapChainDesc
@@ -159,6 +159,9 @@ public sealed partial class GraphicsTestWindow : Window
         }
         catch (Exception ex)
         {
+#if DEBUG
+            System.Diagnostics.Debugger.Break();
+#endif
             Environment.FailFast("Failed to close the window properly.", ex);
         }
         finally

src/Test/Ghost.MicroTest/MeshoptBenchmark.cs

@@ -52,7 +52,7 @@ internal class MeshoptBenchmark : ITest
         };
         var error = new ufbx_error();
 
-        using var pool = new MemoryPool<VirtualStack, VirtualStack.CreationOpts>(new VirtualStack.CreationOpts
+        using var pool = new MemoryPool<VirtualStack, VirtualStack.CreationOptions>(new VirtualStack.CreationOptions
         {
             reserveCapacity = 256 * 1024 * 1024 // 256 MB should be enough for most models, adjust as needed. Note that this use virtual memory and does not actually consume physical memory until allocations are made.
         });