Rendering: formalize main-scene graph contract

engine/src/Rendering/Pipelines/Internal/BuiltinForwardMainSceneGraphBuilder.cpp

@@ -2,14 +2,12 @@
 
 #include "Debug/Logger.h"
 #include "Rendering/Graph/RenderGraph.h"
-#include <XCEngine/Rendering/Graph/RenderGraphRecordingContext.h>
-#include <XCEngine/Rendering/RenderPassGraphContract.h>
 #include "Rendering/Pipelines/BuiltinForwardPipeline.h"
 #include "Rendering/Pipelines/Internal/BuiltinForwardSceneSetup.h"
 #include "Rendering/RenderSurface.h"
+#include <XCEngine/Rendering/RenderPipelineMainSceneGraphContract.h>
 
 #include <memory>
-#include <string>
 
 namespace XCEngine {
 namespace Rendering {
@@ -28,15 +26,6 @@ struct ForwardSceneGraphExecutionState {
     bool initialized = false;
 };
 
-Containers::String BuildForwardScenePhasePassName(
-    const Containers::String& baseName,
-    ScenePhase scenePhase) {
-    std::string name = baseName.CStr();
-    name += '.';
-    name += ToString(scenePhase);
-    return Containers::String(name.c_str());
-}
-
 bool ScenePhaseSamplesMainDirectionalShadow(ScenePhase scenePhase) {
     return scenePhase == ScenePhase::Opaque ||
            scenePhase == ScenePhase::Transparent;
@@ -47,10 +36,7 @@ bool ScenePhaseSamplesMainDirectionalShadow(ScenePhase scenePhase) {
 bool BuiltinForwardMainSceneGraphBuilder::Record(
     BuiltinForwardPipeline& pipeline,
     const RenderPipelineMainSceneRenderGraphContext& context) {
-    const Containers::String passName = context.passName;
     const RenderContext renderContext = context.renderContext;
-    const std::shared_ptr<const RenderSceneData> sceneData =
-        std::make_shared<RenderSceneData>(context.sceneData);
     const RenderSurface surfaceTemplate =
         BuildGraphManagedForwardSceneSurface(context.surfaceTemplate);
     const bool hasSourceSurface = context.sourceSurface != nullptr;
@@ -58,8 +44,6 @@ bool BuiltinForwardMainSceneGraphBuilder::Record(
         hasSourceSurface ? *context.sourceSurface : RenderSurface();
     RHI::RHIResourceView* const sourceColorView = context.sourceColorView;
     const RHI::ResourceStates sourceColorState = context.sourceColorState;
-    const std::vector<RenderGraphTextureHandle> colorTargets = context.colorTargets;
-    const RenderGraphTextureHandle depthTarget = context.depthTarget;
     const CameraFrameRenderGraphResources* const frameResources =
         TryGetCameraFrameRenderGraphResources(context.blackboard);
     const RenderGraphTextureHandle mainDirectionalShadowTexture =
@@ -67,13 +51,27 @@ bool BuiltinForwardMainSceneGraphBuilder::Record(
             ? frameResources->mainDirectionalShadow
             : RenderGraphTextureHandle{};
     bool* const executionSucceeded = context.executionSucceeded;
+    const RenderPipelineMainSceneRenderGraphContext graphContext = {
+        context.graphBuilder,
+        context.passName,
+        renderContext,
+        context.sceneData,
+        surfaceTemplate,
+        hasSourceSurface ? &sourceSurface : nullptr,
+        sourceColorView,
+        sourceColorState,
+        context.sourceColorTexture,
+        context.colorTargets,
+        context.depthTarget,
+        executionSucceeded,
+        context.blackboard
+    };
     const std::shared_ptr<ForwardSceneGraphExecutionState> graphExecutionState =
         std::make_shared<ForwardSceneGraphExecutionState>();
     const SceneRenderFeaturePassBeginCallback beginRecordedPass =
         [&pipeline,
          graphExecutionState,
          renderContext,
-         sceneData,
          hasSourceSurface,
          sourceSurface,
          sourceColorView,
@@ -97,9 +95,9 @@ bool BuiltinForwardMainSceneGraphBuilder::Record(
                 }
 
                 const FrameExecutionContext executionContext(
-                    renderContext,
+                    passContext.renderContext,
                     passContext.surface,
-                    *sceneData,
+                    passContext.sceneData,
                     hasSourceSurface ? &sourceSurface : nullptr,
                     sourceColorView,
                     sourceColorState);
@@ -132,35 +130,18 @@ bool BuiltinForwardMainSceneGraphBuilder::Record(
         [&pipeline](const RenderPassContext& passContext) {
             pipeline.EndForwardScenePass(passContext);
         };
-    const ::XCEngine::Rendering::RenderGraphRecordingContext commonContext = {
-        context.graphBuilder,
-        passName,
-        renderContext,
-        *sceneData,
-        surfaceTemplate,
-        hasSourceSurface ? &sourceSurface : nullptr,
-        sourceColorView,
-        sourceColorState,
-        {},
-        colorTargets,
-        depthTarget,
-        executionSucceeded,
-        context.blackboard
-    };
 
     bool clearAttachments = true;
     for (const ForwardSceneStep& step : GetBuiltinForwardSceneSteps()) {
         if (step.type == ForwardSceneStepType::InjectionPoint) {
-            const SceneRenderFeaturePassRenderGraphContext featureContext =
-                ::XCEngine::Rendering::BuildSceneRenderFeaturePassRenderGraphContext(
-                    commonContext,
+            bool recordedAnyPass = false;
+            if (!::XCEngine::Rendering::RecordRenderPipelineMainSceneFeaturePasses(
+                    graphContext,
+                    pipeline.m_forwardSceneFeatureHost,
+                    step.injectionPoint,
                     clearAttachments,
                     beginRecordedPass,
-                    endRecordedPass);
-            bool recordedAnyPass = false;
-            if (!pipeline.m_forwardSceneFeatureHost.Record(
-                    featureContext,
-                    step.injectionPoint,
+                    endRecordedPass,
                     &recordedAnyPass)) {
                 return false;
             }
@@ -171,8 +152,6 @@ bool BuiltinForwardMainSceneGraphBuilder::Record(
             continue;
         }
 
-        const Containers::String phasePassName =
-            BuildForwardScenePhasePassName(passName, step.scenePhase);
         const RenderPassGraphBeginCallback beginPhasePass =
             [beginRecordedPass, clearAttachments](const RenderPassContext& passContext) {
                 return beginRecordedPass(passContext, clearAttachments);
@@ -182,20 +161,9 @@ bool BuiltinForwardMainSceneGraphBuilder::Record(
                 mainDirectionalShadowTexture.IsValid()
             ? std::vector<RenderGraphTextureHandle>{ mainDirectionalShadowTexture }
             : std::vector<RenderGraphTextureHandle>{};
-        ::XCEngine::Rendering::RenderGraphRecordingContext phaseCommonContext = commonContext;
-        phaseCommonContext.passName = phasePassName;
-        const RenderPassRenderGraphContext phaseContext =
-            ::XCEngine::Rendering::BuildRenderPassRenderGraphContext(
-                phaseCommonContext,
-                beginPhasePass,
-                endRecordedPass);
-        if (!::XCEngine::Rendering::RecordCallbackRasterRenderPass(
-                phaseContext,
-                {
-                    false,
-                    true,
-                    depthTarget.IsValid()
-                },
+        if (!::XCEngine::Rendering::RecordRenderPipelineMainScenePhasePass(
+                graphContext,
+                step.scenePhase,
                 [&pipeline, scenePhase = step.scenePhase](const RenderPassContext& passContext) {
                     const FrameExecutionContext executionContext(
                         passContext.renderContext,
@@ -208,6 +176,8 @@ bool BuiltinForwardMainSceneGraphBuilder::Record(
                         pipeline.BuildScenePhaseExecutionContext(executionContext, scenePhase);
                     return pipeline.ExecuteBuiltinScenePhase(scenePhaseExecutionContext);
                 },
+                beginPhasePass,
+                endRecordedPass,
                 additionalReadTextures)) {
             return false;
         }

engine/src/Rendering/RenderPipelineMainSceneGraphContract.cpp

@@ -0,0 +1,95 @@
+#include <XCEngine/Rendering/RenderPipelineMainSceneGraphContract.h>
+
+#include <XCEngine/Rendering/Graph/RenderGraphRecordingContext.h>
+#include <XCEngine/Rendering/SceneRenderFeatureHost.h>
+
+#include <string>
+#include <utility>
+
+namespace XCEngine {
+namespace Rendering {
+namespace {
+
+RenderGraphRecordingContext BuildCommonContext(
+    const RenderPipelineMainSceneRenderGraphContext& context,
+    Containers::String passName) {
+    return {
+        context.graphBuilder,
+        passName,
+        context.renderContext,
+        context.sceneData,
+        context.surfaceTemplate,
+        context.sourceSurface,
+        context.sourceColorView,
+        context.sourceColorState,
+        context.sourceColorTexture,
+        context.colorTargets,
+        context.depthTarget,
+        context.executionSucceeded,
+        context.blackboard
+    };
+}
+
+} // namespace
+
+Containers::String BuildRenderPipelineMainScenePhasePassName(
+    const Containers::String& baseName,
+    ScenePhase scenePhase) {
+    std::string name = baseName.CStr();
+    if (!name.empty()) {
+        name += '.';
+    }
+
+    name += ToString(scenePhase);
+    return Containers::String(name.c_str());
+}
+
+bool RecordRenderPipelineMainSceneFeaturePasses(
+    const RenderPipelineMainSceneRenderGraphContext& context,
+    SceneRenderFeatureHost& featureHost,
+    SceneRenderInjectionPoint injectionPoint,
+    bool clearAttachments,
+    SceneRenderFeaturePassBeginCallback beginPassCallback,
+    SceneRenderFeaturePassEndCallback endPassCallback,
+    bool* recordedAnyPass) {
+    const SceneRenderFeaturePassRenderGraphContext featureContext =
+        BuildSceneRenderFeaturePassRenderGraphContext(
+            BuildCommonContext(context, context.passName),
+            clearAttachments,
+            beginPassCallback,
+            endPassCallback);
+    return featureHost.Record(
+        featureContext,
+        injectionPoint,
+        recordedAnyPass);
+}
+
+bool RecordRenderPipelineMainScenePhasePass(
+    const RenderPipelineMainSceneRenderGraphContext& context,
+    ScenePhase scenePhase,
+    RenderPassGraphExecutePassCallback executePassCallback,
+    RenderPassGraphBeginCallback beginPassCallback,
+    RenderPassGraphEndCallback endPassCallback,
+    std::vector<RenderGraphTextureHandle> additionalReadTextures) {
+    const RenderPassRenderGraphContext passContext =
+        BuildRenderPassRenderGraphContext(
+            BuildCommonContext(
+                context,
+                BuildRenderPipelineMainScenePhasePassName(
+                    context.passName,
+                    scenePhase)),
+            beginPassCallback,
+            endPassCallback);
+    return RecordCallbackRasterRenderPass(
+        passContext,
+        {
+            false,
+            true,
+            context.depthTarget.IsValid()
+        },
+        std::move(executePassCallback),
+        std::move(additionalReadTextures));
+}
+
+} // namespace Rendering
+} // namespace XCEngine