Split render-graph main scene into forward segments

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

@@ -0,0 +1,128 @@
+#include "Rendering/Pipelines/BuiltinForwardPipeline.h"
+
+#include "Debug/Logger.h"
+#include "Rendering/Pipelines/Internal/BuiltinForwardSceneSetup.h"
+
+namespace XCEngine {
+namespace Rendering {
+namespace Pipelines {
+
+ScenePhaseExecutionContext BuiltinForwardPipeline::BuildScenePhaseExecutionContext(
+    const FrameExecutionContext& executionContext,
+    ScenePhase scenePhase) const {
+    return ScenePhaseExecutionContext(
+        executionContext,
+        scenePhase,
+        ShouldSampleMainDirectionalShadowMap(executionContext.sceneData));
+}
+
+DrawSettings BuiltinForwardPipeline::BuildDrawSettings(ScenePhase scenePhase) const {
+    DrawSettings drawSettings = {};
+    drawSettings.scenePhase = scenePhase;
+    switch (scenePhase) {
+    case ScenePhase::Opaque:
+        drawSettings.rendererListType = RendererListType::Opaque;
+        break;
+    case ScenePhase::Transparent:
+        drawSettings.rendererListType = RendererListType::Transparent;
+        break;
+    default:
+        drawSettings.rendererListType = RendererListType::AllVisible;
+        break;
+    }
+
+    return drawSettings;
+}
+
+bool BuiltinForwardPipeline::ExecuteBuiltinScenePhase(
+    const ScenePhaseExecutionContext& executionContext) {
+    switch (executionContext.scenePhase) {
+    case ScenePhase::Opaque:
+        return ExecuteForwardOpaquePass(executionContext);
+    case ScenePhase::Skybox:
+        return ExecuteForwardSkyboxPass(BuildRenderPassContext(executionContext));
+    case ScenePhase::Transparent:
+        return ExecuteForwardTransparentPass(executionContext);
+    default:
+        Debug::Logger::Get().Error(
+            Debug::LogCategory::Rendering,
+            (Containers::String("BuiltinForwardPipeline::ExecuteBuiltinScenePhase does not support scene phase: ") +
+                ToString(executionContext.scenePhase)).CStr());
+        return false;
+    }
+}
+
+bool BuiltinForwardPipeline::ExecuteForwardScene(
+    const FrameExecutionContext& executionContext) {
+    return ExecuteForwardSceneSteps(
+        executionContext,
+        0u,
+        Internal::GetBuiltinForwardSceneSteps().size());
+}
+
+bool BuiltinForwardPipeline::ExecuteForwardSceneSteps(
+    const FrameExecutionContext& executionContext,
+    size_t beginStepIndex,
+    size_t endStepIndex) {
+    const auto& steps = Internal::GetBuiltinForwardSceneSteps();
+    if (beginStepIndex > endStepIndex ||
+        endStepIndex > steps.size()) {
+        Debug::Logger::Get().Error(
+            Debug::LogCategory::Rendering,
+            "BuiltinForwardPipeline::ExecuteForwardSceneSteps received an invalid step range");
+        return false;
+    }
+
+    for (size_t stepIndex = beginStepIndex; stepIndex < endStepIndex; ++stepIndex) {
+        const Internal::ForwardSceneStep& step = steps[stepIndex];
+        if (step.type == Internal::ForwardSceneStepType::InjectionPoint) {
+            if (m_forwardSceneFeatureHost.Execute(executionContext, step.injectionPoint)) {
+                continue;
+            }
+
+            Debug::Logger::Get().Error(
+                Debug::LogCategory::Rendering,
+                (Containers::String("BuiltinForwardPipeline::ExecuteForwardScene failed at injection point: ") +
+                    ToString(step.injectionPoint)).CStr());
+            return false;
+        }
+
+        const ScenePhaseExecutionContext scenePhaseExecutionContext =
+            BuildScenePhaseExecutionContext(executionContext, step.scenePhase);
+        if (!ExecuteBuiltinScenePhase(scenePhaseExecutionContext)) {
+            Debug::Logger::Get().Error(
+                Debug::LogCategory::Rendering,
+                (Containers::String("BuiltinForwardPipeline::ExecuteForwardScene failed during builtin phase: ") +
+                    ToString(step.scenePhase)).CStr());
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool BuiltinForwardPipeline::ExecuteForwardSceneSegmentPass(
+    const FrameExecutionContext& executionContext,
+    size_t beginStepIndex,
+    size_t endStepIndex,
+    bool clearAttachments) {
+    const RenderPassContext passContext = BuildRenderPassContext(executionContext);
+    if (!BeginForwardScenePass(passContext, clearAttachments)) {
+        Debug::Logger::Get().Error(
+            Debug::LogCategory::Rendering,
+            "BuiltinForwardPipeline::ExecuteForwardSceneSegmentPass failed: BeginForwardScenePass returned false");
+        return false;
+    }
+
+    const bool executeResult =
+        ExecuteForwardSceneSteps(
+            executionContext,
+            beginStepIndex,
+            endStepIndex);
+    EndForwardScenePass(passContext);
+    return executeResult;
+}
+
+} // namespace Pipelines
+} // namespace Rendering
+} // namespace XCEngine