refactor(rendering): centralize fullscreen stage surface resolution

engine/src/Rendering/Execution/CameraFramePlan.cpp

@@ -107,6 +107,12 @@ bool CameraFramePlan::HasFrameStage(CameraFrameStage stage) const {
     }
 
     if (IsCameraFrameSequenceStage(stage)) {
+        if (const FullscreenPassRenderRequest* fullscreenRequest =
+                GetFullscreenPassRequest(stage);
+            fullscreenRequest != nullptr) {
+            return fullscreenRequest->IsRequested();
+        }
+
         return GetPassSequence(stage) != nullptr;
     }
 
@@ -143,6 +149,18 @@ RenderPassSequence* CameraFramePlan::GetPassSequence(CameraFrameStage stage) con
     }
 }
 
+const FullscreenPassRenderRequest* CameraFramePlan::GetFullscreenPassRequest(
+    CameraFrameStage stage) const {
+    switch (stage) {
+    case CameraFrameStage::PostProcess:
+        return &postProcess;
+    case CameraFrameStage::FinalOutput:
+        return &finalOutput;
+    default:
+        return nullptr;
+    }
+}
+
 const ScenePassRenderRequest* CameraFramePlan::GetScenePassRequest(CameraFrameStage stage) const {
     switch (GetCameraFrameStageRequestKind(stage)) {
     case CameraFrameStageRequestKind::ShadowCaster:

engine/src/Rendering/Execution/Internal/CameraFrameGraph/SurfaceResolver.h

@@ -13,69 +13,79 @@ struct CameraFrameStageSourceBinding {
     RHI::ResourceStates sourceColorState = RHI::ResourceStates::Common;
 };
 
-inline const RenderSurface* ResolveCameraFrameStageOutputSurface(
+inline const ScenePassRenderRequest* ResolveCameraFrameStageOutputScenePassRequest(
     CameraFrameStage stage,
     const CameraFramePlan& plan,
     const DirectionalShadowExecutionState& shadowState) {
-    switch (stage) {
-    case CameraFrameStage::PreScenePasses:
-    case CameraFrameStage::MainScene:
-        return &plan.GetMainSceneSurface();
-    case CameraFrameStage::ShadowCaster:
+    switch (GetCameraFrameStageRequestKind(stage)) {
+    case CameraFrameStageRequestKind::ShadowCaster:
         return shadowState.shadowCasterRequest.IsRequested()
-            ? &shadowState.shadowCasterRequest.surface
+            ? &shadowState.shadowCasterRequest
             : nullptr;
-    case CameraFrameStage::DepthOnly:
-        return plan.request.depthOnly.IsRequested()
-            ? &plan.request.depthOnly.surface
-            : nullptr;
-    case CameraFrameStage::PostProcess:
-        return plan.postProcess.IsRequested() &&
-               HasValidColorTarget(plan.postProcess.destinationSurface)
-            ? &plan.postProcess.destinationSurface
-            : nullptr;
-    case CameraFrameStage::FinalOutput:
-        return plan.finalOutput.IsRequested() &&
-               HasValidColorTarget(plan.finalOutput.destinationSurface)
-            ? &plan.finalOutput.destinationSurface
-            : nullptr;
-    case CameraFrameStage::ObjectId:
-        return plan.request.objectId.IsRequested()
-            ? &plan.request.objectId.surface
-            : nullptr;
-    case CameraFrameStage::PostScenePasses:
-    case CameraFrameStage::OverlayPasses:
-        return &plan.GetFinalCompositedSurface();
+    case CameraFrameStageRequestKind::DepthOnly:
+        return plan.GetScenePassRequest(stage);
     default:
         return nullptr;
     }
 }
 
+inline const RenderSurface* ResolveCameraFrameStageOutputSurface(
+    CameraFrameStage stage,
+    const CameraFramePlan& plan,
+    const DirectionalShadowExecutionState& shadowState) {
+    if (stage == CameraFrameStage::PreScenePasses ||
+        stage == CameraFrameStage::MainScene) {
+        return &plan.GetMainSceneSurface();
+    }
+
+    if (const ScenePassRenderRequest* scenePassRequest =
+            ResolveCameraFrameStageOutputScenePassRequest(
+                stage,
+                plan,
+                shadowState);
+        scenePassRequest != nullptr && scenePassRequest->IsRequested()) {
+        return &scenePassRequest->surface;
+    }
+
+    if (const FullscreenPassRenderRequest* fullscreenRequest =
+            plan.GetFullscreenPassRequest(stage);
+        fullscreenRequest != nullptr &&
+        fullscreenRequest->IsRequested() &&
+        HasValidColorTarget(fullscreenRequest->destinationSurface)) {
+        return &fullscreenRequest->destinationSurface;
+    }
+
+    if (const ObjectIdRenderRequest* objectIdRequest =
+            plan.GetObjectIdRequest(stage);
+        objectIdRequest != nullptr && objectIdRequest->IsRequested()) {
+        return &objectIdRequest->surface;
+    }
+
+    if (stage == CameraFrameStage::PostScenePasses ||
+        stage == CameraFrameStage::OverlayPasses) {
+        return &plan.GetFinalCompositedSurface();
+    }
+
+    return nullptr;
+}
+
 inline CameraFrameStageSourceBinding ResolveCameraFrameStageSourceBinding(
     CameraFrameStage stage,
     const CameraFramePlan& plan) {
-    switch (stage) {
-    case CameraFrameStage::PostProcess:
-        return plan.postProcess.IsRequested() &&
-               plan.ResolveStageColorSource(CameraFrameStage::PostProcess) ==
+    if (const FullscreenPassRenderRequest* fullscreenRequest =
+            plan.GetFullscreenPassRequest(stage);
+        fullscreenRequest != nullptr) {
+        return fullscreenRequest->IsRequested() &&
+               plan.ResolveStageColorSource(stage) ==
                    CameraFrameColorSource::ExplicitSurface
             ? CameraFrameStageSourceBinding{
-                  &plan.postProcess.sourceSurface,
-                  plan.postProcess.sourceColorView,
-                  plan.postProcess.sourceColorState }
+                  &fullscreenRequest->sourceSurface,
+                  fullscreenRequest->sourceColorView,
+                  fullscreenRequest->sourceColorState }
             : CameraFrameStageSourceBinding{};
-    case CameraFrameStage::FinalOutput:
-        return plan.finalOutput.IsRequested() &&
-               plan.ResolveStageColorSource(CameraFrameStage::FinalOutput) ==
-                   CameraFrameColorSource::ExplicitSurface
-            ? CameraFrameStageSourceBinding{
-                  &plan.finalOutput.sourceSurface,
-                  plan.finalOutput.sourceColorView,
-                  plan.finalOutput.sourceColorState }
-            : CameraFrameStageSourceBinding{};
-    default:
-        return {};
     }
+
+    return {};
 }
 
 inline RenderPassContext BuildCameraFrameStagePassContext(