Move scene request planning behind pipeline asset

engine/src/Rendering/Execution/RenderPipelineHost.cpp

@@ -2,6 +2,7 @@
 
 #include "Rendering/Planning/CameraFramePlanBuilder.h"
 #include "Rendering/Planning/SceneRenderRequestUtils.h"
+#include "Rendering/RenderPipelineAsset.h"
 
 #include <algorithm>
 #include <utility>
@@ -53,6 +54,53 @@ void RenderPipelineHost::SetPipelineAsset(std::shared_ptr<const RenderPipelineAs
     m_cameraRenderer.SetPipelineAsset(std::move(pipelineAsset));
 }
 
+void RenderPipelineHost::SetDirectionalShadowPlanningSettings(
+    const DirectionalShadowPlanningSettings& settings) {
+    m_requestPlanner.SetDirectionalShadowPlanningSettings(
+        settings);
+}
+
+const DirectionalShadowPlanningSettings&
+RenderPipelineHost::GetDirectionalShadowPlanningSettings() const {
+    return m_requestPlanner.GetDirectionalShadowPlanningSettings();
+}
+
+std::vector<CameraRenderRequest> RenderPipelineHost::BuildSceneRenderRequests(
+    const Components::Scene& scene,
+    Components::CameraComponent* overrideCamera,
+    const RenderContext& context,
+    const RenderSurface& surface) const {
+    if (const RenderPipelineAsset* const pipelineAsset =
+            GetPipelineAsset();
+        pipelineAsset != nullptr) {
+        return pipelineAsset->BuildSceneRenderRequests(
+            scene,
+            overrideCamera,
+            context,
+            surface,
+            m_requestPlanner.GetDirectionalShadowPlanningSettings());
+    }
+
+    return m_requestPlanner.BuildRequests(
+        scene,
+        overrideCamera,
+        context,
+        surface);
+}
+
+std::vector<CameraFramePlan> RenderPipelineHost::BuildFramePlans(
+    const Components::Scene& scene,
+    Components::CameraComponent* overrideCamera,
+    const RenderContext& context,
+    const RenderSurface& surface) {
+    return BuildFramePlans(
+        BuildSceneRenderRequests(
+            scene,
+            overrideCamera,
+            context,
+            surface));
+}
+
 std::vector<CameraFramePlan> RenderPipelineHost::BuildFramePlans(
     const std::vector<CameraRenderRequest>& requests) {
     return m_framePlanBuilder != nullptr
@@ -62,6 +110,19 @@ std::vector<CameraFramePlan> RenderPipelineHost::BuildFramePlans(
         : std::vector<CameraFramePlan>();
 }
 
+std::vector<CameraStackFramePlan> RenderPipelineHost::BuildStackFramePlans(
+    const Components::Scene& scene,
+    Components::CameraComponent* overrideCamera,
+    const RenderContext& context,
+    const RenderSurface& surface) {
+    return BuildStackFramePlans(
+        BuildSceneRenderRequests(
+            scene,
+            overrideCamera,
+            context,
+            surface));
+}
+
 std::vector<CameraStackFramePlan> RenderPipelineHost::BuildStackFramePlans(
     const std::vector<CameraRenderRequest>& requests) {
     return m_framePlanBuilder != nullptr

engine/src/Rendering/Execution/SceneRenderer.cpp

@@ -19,19 +19,27 @@ void SceneRenderer::SetPipelineAsset(std::shared_ptr<const RenderPipelineAsset>
     m_pipelineHost.SetPipelineAsset(std::move(pipelineAsset));
 }
 
+void SceneRenderer::SetDirectionalShadowPlanningSettings(
+    const DirectionalShadowPlanningSettings& settings) {
+    m_pipelineHost.SetDirectionalShadowPlanningSettings(
+        settings);
+}
+
+const DirectionalShadowPlanningSettings&
+SceneRenderer::GetDirectionalShadowPlanningSettings() const {
+    return m_pipelineHost.GetDirectionalShadowPlanningSettings();
+}
+
 std::vector<CameraFramePlan> SceneRenderer::BuildFramePlans(
     const Components::Scene& scene,
     Components::CameraComponent* overrideCamera,
     const RenderContext& context,
     const RenderSurface& surface) {
-    const std::vector<CameraRenderRequest> requests =
-        m_requestPlanner.BuildRequests(
-            scene,
-            overrideCamera,
-            context,
-            surface,
-            m_pipelineHost.GetPipelineAsset());
-    return m_pipelineHost.BuildFramePlans(requests);
+    return m_pipelineHost.BuildFramePlans(
+        scene,
+        overrideCamera,
+        context,
+        surface);
 }
 
 std::vector<CameraStackFramePlan> SceneRenderer::BuildStackFramePlans(
@@ -39,14 +47,11 @@ std::vector<CameraStackFramePlan> SceneRenderer::BuildStackFramePlans(
     Components::CameraComponent* overrideCamera,
     const RenderContext& context,
     const RenderSurface& surface) {
-    const std::vector<CameraRenderRequest> requests =
-        m_requestPlanner.BuildRequests(
-            scene,
-            overrideCamera,
-            context,
-            surface,
-            m_pipelineHost.GetPipelineAsset());
-    return m_pipelineHost.BuildStackFramePlans(requests);
+    return m_pipelineHost.BuildStackFramePlans(
+        scene,
+        overrideCamera,
+        context,
+        surface);
 }
 
 bool SceneRenderer::Render(const CameraFramePlan& plan) {

engine/src/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.cpp

@@ -118,6 +118,36 @@ std::unique_ptr<RenderPipeline> ManagedScriptableRenderPipelineAsset::CreatePipe
     return pipeline;
 }
 
+std::vector<CameraRenderRequest>
+ManagedScriptableRenderPipelineAsset::BuildSceneRenderRequests(
+    const Components::Scene& scene,
+    Components::CameraComponent* overrideCamera,
+    const RenderContext& context,
+    const RenderSurface& surface,
+    const DirectionalShadowPlanningSettings& directionalShadowSettings) const {
+    if (const std::shared_ptr<const ManagedRenderPipelineAssetRuntime> runtime =
+            ResolveManagedAssetRuntime();
+        runtime != nullptr) {
+        std::vector<CameraRenderRequest> requests;
+        if (runtime->BuildSceneRenderRequests(
+                scene,
+                overrideCamera,
+                context,
+                surface,
+                directionalShadowSettings,
+                requests)) {
+            return requests;
+        }
+    }
+
+    return RenderPipelineAsset::BuildSceneRenderRequests(
+        scene,
+        overrideCamera,
+        context,
+        surface,
+        directionalShadowSettings);
+}
+
 void ManagedScriptableRenderPipelineAsset::ConfigureCameraRenderRequest(
     CameraRenderRequest& request,
     size_t renderedBaseCameraCount,

engine/src/Rendering/RenderPipelineAsset.cpp

@@ -95,6 +95,23 @@ void RenderPipelineAsset::ConfigureCameraRenderRequest(
         directionalShadowSettings);
 }
 
+std::vector<CameraRenderRequest> RenderPipelineAsset::BuildSceneRenderRequests(
+    const Components::Scene& scene,
+    Components::CameraComponent* overrideCamera,
+    const RenderContext& context,
+    const RenderSurface& surface,
+    const DirectionalShadowPlanningSettings& directionalShadowSettings) const {
+    SceneRenderRequestPlanner requestPlanner = {};
+    requestPlanner.SetDirectionalShadowPlanningSettings(
+        directionalShadowSettings);
+    return requestPlanner.BuildRequests(
+        scene,
+        overrideCamera,
+        context,
+        surface,
+        this);
+}
+
 void RenderPipelineAsset::ConfigureCameraFramePlan(CameraFramePlan& plan) const {
     ApplyDefaultRenderPipelineAssetCameraFramePlanPolicy(
         plan,