Formalize chained fullscreen post-process execution

engine/include/XCEngine/Rendering/Execution/CameraRenderer.h

@@ -20,6 +20,7 @@ class RHIResourceView;
 namespace Rendering {
 
 class DirectionalShadowSurfaceCache;
+class FullscreenPassSurfaceCache;
 class RenderSurface;
 class RenderPipelineAsset;
 struct RenderContext;
@@ -71,6 +72,8 @@ private:
     std::unique_ptr<RenderPass> m_depthOnlyPass;
     std::unique_ptr<RenderPass> m_shadowCasterPass;
     std::unique_ptr<DirectionalShadowSurfaceCache> m_directionalShadowSurface;
+    std::unique_ptr<FullscreenPassSurfaceCache> m_postProcessSurfaceCache;
+    std::unique_ptr<FullscreenPassSurfaceCache> m_finalOutputSurfaceCache;
 };
 
 } // namespace Rendering

engine/include/XCEngine/Rendering/Planning/CameraRenderRequest.h

@@ -14,6 +14,10 @@ class CameraComponent;
 class Scene;
 } // namespace Components
 
+namespace RHI {
+class RHIResourceView;
+} // namespace RHI
+
 namespace Rendering {
 
 enum class CameraFrameStage : uint8_t {
@@ -143,16 +147,26 @@ struct ObjectIdRenderRequest {
 
 struct FullscreenPassRenderRequest {
     RenderSurface sourceSurface;
+    RHI::RHIResourceView* sourceColorView = nullptr;
     RenderSurface destinationSurface;
     RenderPassSequence* passes = nullptr;
 
+    size_t GetPassCount() const {
+        return passes != nullptr ? passes->GetPassCount() : 0u;
+    }
+
     bool IsRequested() const {
         return passes != nullptr;
     }
 
+    bool RequiresIntermediateSurface() const {
+        return GetPassCount() > 1u;
+    }
+
     bool IsValid() const {
         return passes != nullptr &&
                HasValidColorTarget(sourceSurface) &&
+               sourceColorView != nullptr &&
                HasValidColorTarget(destinationSurface);
     }
 };
@@ -295,6 +309,17 @@ struct CameraRenderRequest {
         }
     }
 
+    RHI::RHIResourceView* GetSourceColorView(CameraFrameStage stage) const {
+        switch (stage) {
+        case CameraFrameStage::PostProcess:
+            return postProcess.IsRequested() ? postProcess.sourceColorView : nullptr;
+        case CameraFrameStage::FinalOutput:
+            return finalOutput.IsRequested() ? finalOutput.sourceColorView : nullptr;
+        default:
+            return nullptr;
+        }
+    }
+
     bool RequiresIntermediateSceneColor() const {
         return postProcess.IsRequested() || finalOutput.IsRequested();
     }

engine/include/XCEngine/Rendering/RenderPass.h

@@ -7,6 +7,10 @@
 #include <vector>
 
 namespace XCEngine {
+namespace RHI {
+class RHIResourceView;
+} // namespace RHI
+
 namespace Rendering {
 
 struct RenderSceneData;
@@ -17,6 +21,7 @@ struct RenderPassContext {
     const RenderSurface& surface;
     const RenderSceneData& sceneData;
     const RenderSurface* sourceSurface = nullptr;
+    RHI::RHIResourceView* sourceColorView = nullptr;
 };
 
 class RenderPass {
@@ -47,6 +52,10 @@ public:
         return m_passes.size();
     }
 
+    bool Empty() const {
+        return m_passes.empty();
+    }
+
     bool Initialize(const RenderContext& context) {
         for (const std::unique_ptr<RenderPass>& pass : m_passes) {
             if (pass == nullptr) {
@@ -83,6 +92,14 @@ public:
         return true;
     }
 
+    bool ExecutePass(size_t index, const RenderPassContext& context) {
+        if (index >= m_passes.size() || m_passes[index] == nullptr) {
+            return false;
+        }
+
+        return m_passes[index]->Execute(context);
+    }
+
 private:
     std::vector<std::unique_ptr<RenderPass>> m_passes;
 };