refactor(rendering): unify stage runtime request dispatch

engine/src/Rendering/Execution/Internal/CameraFrameGraph/StageContract.cpp

@@ -12,33 +12,79 @@ namespace Rendering {
 
 namespace {
 
-bool ExecuteCameraFrameScenePassRequestStage(
-    RenderPass* pass,
-    const ScenePassRenderRequest& request,
-    const RenderContext& renderContext,
-    const RenderSceneData& baseSceneData,
-    const RenderSurface& passSurface) {
-    if (!request.IsRequested()) {
-        return true;
+struct CameraFrameStageRuntimeRequestBinding {
+    CameraFrameStageRequestKind requestKind =
+        CameraFrameStageRequestKind::None;
+    const ScenePassRenderRequest* scenePassRequest = nullptr;
+    const ObjectIdRenderRequest* objectIdRequest = nullptr;
+
+    bool IsRequested() const {
+        switch (requestKind) {
+        case CameraFrameStageRequestKind::ShadowCaster:
+        case CameraFrameStageRequestKind::DepthOnly:
+            return scenePassRequest != nullptr;
+        case CameraFrameStageRequestKind::ObjectId:
+            return objectIdRequest != nullptr;
+        default:
+            return false;
+        }
+    }
+};
+
+const ScenePassRenderRequest* ResolveRequestedScenePassRequest(
+    const ScenePassRenderRequest* request) {
+    return request != nullptr && request->IsRequested()
+        ? request
+        : nullptr;
+}
+
+const ObjectIdRenderRequest* ResolveRequestedObjectIdRequest(
+    const ObjectIdRenderRequest* request) {
+    return request != nullptr && request->IsRequested()
+        ? request
+        : nullptr;
+}
+
+CameraFrameStageRuntimeRequestBinding ResolveCameraFrameStageRuntimeRequestBinding(
+    CameraFrameStage stage,
+    const CameraFrameRenderGraphStageContext& context) {
+    CameraFrameStageRuntimeRequestBinding binding = {};
+    binding.requestKind = GetCameraFrameStageRequestKind(stage);
+    switch (binding.requestKind) {
+    case CameraFrameStageRequestKind::ShadowCaster:
+        binding.scenePassRequest =
+            ResolveRequestedScenePassRequest(
+                &context.shadowState.shadowCasterRequest);
+        break;
+    case CameraFrameStageRequestKind::DepthOnly:
+        binding.scenePassRequest =
+            ResolveRequestedScenePassRequest(
+                context.plan.GetScenePassRequest(stage));
+        break;
+    case CameraFrameStageRequestKind::ObjectId:
+        binding.objectIdRequest =
+            ResolveRequestedObjectIdRequest(
+                context.plan.GetObjectIdRequest(stage));
+        break;
+    default:
+        break;
     }
 
-    if (!InitializeCameraFrameStandaloneStagePass(pass, renderContext)) {
-        return false;
-    }
+    return binding;
+}
 
-    const RenderSceneData sceneData =
-        BuildCameraFrameScenePassRequestSceneData(
-            request,
-            passSurface,
+RenderSceneData BuildCameraFrameStandaloneStageSceneDataFromRequestBinding(
+    const CameraFrameStageRuntimeRequestBinding& binding,
+    const RenderSurface& stageSurface,
+    const RenderSceneData& baseSceneData) {
+    if (binding.scenePassRequest != nullptr) {
+        return BuildCameraFrameScenePassRequestSceneData(
+            *binding.scenePassRequest,
+            stageSurface,
             baseSceneData);
-    return pass->Execute({
-        renderContext,
-        passSurface,
-        sceneData,
-        nullptr,
-        nullptr,
-        RHI::ResourceStates::Common
-    });
+    }
+
+    return baseSceneData;
 }
 
 bool ExecuteCameraFrameStandaloneStagePass(
@@ -93,28 +139,19 @@ CameraFrameRenderGraphSourceBinding BuildCameraFrameStageGraphSourceBinding(
 const ScenePassRenderRequest* ResolveCameraFrameStageScenePassRequest(
     CameraFrameStage stage,
     const CameraFrameRenderGraphStageContext& context) {
-    switch (GetCameraFrameStageRequestKind(stage)) {
-    case CameraFrameStageRequestKind::ShadowCaster:
-        return context.shadowState.shadowCasterRequest.IsRequested()
-            ? &context.shadowState.shadowCasterRequest
-            : nullptr;
-    case CameraFrameStageRequestKind::DepthOnly:
-        return context.plan.request.depthOnly.IsRequested()
-            ? &context.plan.request.depthOnly
-            : nullptr;
-    default:
-        return nullptr;
-    }
+    return ResolveCameraFrameStageRuntimeRequestBinding(
+        stage,
+        context)
+        .scenePassRequest;
 }
 
 const ObjectIdRenderRequest* ResolveCameraFrameStageObjectIdRequest(
     CameraFrameStage stage,
     const CameraFrameRenderGraphStageContext& context) {
-    return GetCameraFrameStageRequestKind(stage) ==
-               CameraFrameStageRequestKind::ObjectId &&
-           context.plan.request.objectId.IsRequested()
-        ? &context.plan.request.objectId
-        : nullptr;
+    return ResolveCameraFrameStageRuntimeRequestBinding(
+        stage,
+        context)
+        .objectIdRequest;
 }
 
 RenderSceneData BuildCameraFrameScenePassRequestSceneData(
@@ -157,18 +194,12 @@ RenderSceneData BuildCameraFrameStandaloneStageSceneData(
     CameraFrameStage stage,
     const CameraFrameRenderGraphStageContext& context,
     const RenderSurface& stageSurface) {
-    if (const ScenePassRenderRequest* request =
-            ResolveCameraFrameStageScenePassRequest(
-                stage,
-                context);
-        request != nullptr) {
-        return BuildCameraFrameScenePassRequestSceneData(
-            *request,
-            stageSurface,
-            context.sceneData);
-    }
-
-    return context.sceneData;
+    return BuildCameraFrameStandaloneStageSceneDataFromRequestBinding(
+        ResolveCameraFrameStageRuntimeRequestBinding(
+            stage,
+            context),
+        stageSurface,
+        context.sceneData);
 }
 
 RenderPass* ResolveCameraFrameStandaloneStagePass(
@@ -199,43 +230,13 @@ bool ExecuteCameraFrameRecordedStagePass(
     const CameraFrameRenderGraphStageContext& context,
     CameraFrameExecutionState& executionState,
     const RenderPassContext& passContext) {
-    if (IsCameraFrameScenePassRequestStage(stage)) {
-        const ScenePassRenderRequest* const request =
-            ResolveCameraFrameStageScenePassRequest(
-                stage,
-                context);
-        if (request == nullptr) {
-            return true;
-        }
-
-        RenderPass* const standaloneStagePass =
-            ResolveCameraFrameStandaloneStagePass(
-                stage,
-                executionState);
-        return ExecuteCameraFrameScenePassRequestStage(
-            standaloneStagePass,
-            *request,
-            context.plan.request.context,
-            context.sceneData,
-            passContext.surface);
-    }
-
-    if (GetCameraFrameStageExecutionKind(stage) ==
-        CameraFrameStageExecutionKind::MainScenePipeline) {
-        return executionState.pipeline != nullptr &&
-               executionState.pipeline->Render(
-                   FrameExecutionContext(
-                       context.plan.request.context,
-                       passContext.surface,
-                       context.sceneData,
-                       passContext.sourceSurface,
-                       passContext.sourceColorView,
-                       passContext.sourceColorState));
-    }
-
-    if (GetCameraFrameStageRequestKind(stage) ==
-        CameraFrameStageRequestKind::ObjectId) {
-        if (ResolveCameraFrameStageObjectIdRequest(stage, context) == nullptr) {
+    const CameraFrameStageRuntimeRequestBinding requestBinding =
+        ResolveCameraFrameStageRuntimeRequestBinding(
+            stage,
+            context);
+    switch (GetCameraFrameStageExecutionKind(stage)) {
+    case CameraFrameStageExecutionKind::StandalonePass: {
+        if (!requestBinding.IsRequested()) {
             return true;
         }
 
@@ -247,10 +248,24 @@ bool ExecuteCameraFrameRecordedStagePass(
             standaloneStagePass,
             context.plan.request.context,
             passContext.surface,
-            context.sceneData);
+            BuildCameraFrameStandaloneStageSceneDataFromRequestBinding(
+                requestBinding,
+                passContext.surface,
+                context.sceneData));
+    }
+    case CameraFrameStageExecutionKind::MainScenePipeline:
+        return executionState.pipeline != nullptr &&
+               executionState.pipeline->Render(
+                   FrameExecutionContext(
+                       context.plan.request.context,
+                       passContext.surface,
+                       context.sceneData,
+                       passContext.sourceSurface,
+                       passContext.sourceColorView,
+                       passContext.sourceColorState));
+    default:
+        return false;
     }
-
-    return false;
 }
 
 RenderPassContext BuildCameraFrameStageGraphPassContext(