Refactor rendering frame execution contracts

2026-04-13 22:16:04 +08:00
parent 48daaa1bd0
commit 712f99e723
30 changed files with 1398 additions and 247 deletions
--- a/engine/src/Rendering/Execution/CameraRenderer.cpp
+++ b/engine/src/Rendering/Execution/CameraRenderer.cpp
@@ -289,81 +289,88 @@ bool ExecuteFullscreenPassSequenceStage(

 RenderPassContext BuildFrameStagePassContext(
    CameraFrameStage stage,
-    const CameraRenderRequest& request,
+    const CameraFramePlan& plan,
    const RenderSceneData& sceneData) {
-    const RenderSurface* outputSurface = request.GetOutputSurface(stage);
+    const RenderSurface* outputSurface = plan.GetOutputSurface(stage);
    return {
-        request.context,
-        outputSurface != nullptr ? *outputSurface : request.surface,
+        plan.request.context,
+        outputSurface != nullptr ? *outputSurface : plan.request.surface,
        sceneData,
-        request.GetSourceSurface(stage),
-        request.GetSourceColorView(stage),
-        request.GetSourceColorState(stage)
+        plan.GetSourceSurface(stage),
+        plan.GetSourceColorView(stage),
+        plan.GetSourceColorState(stage)
    };
 }

 bool ExecuteFrameStage(
    CameraFrameStage stage,
-    const CameraRenderRequest& request,
+    const CameraFramePlan& plan,
    const ShadowCasterRenderRequest& resolvedShadowCaster,
    const RenderSceneData& sceneData,
    CameraFrameExecutionState& executionState) {
-    const RenderPassContext passContext = BuildFrameStagePassContext(stage, request, sceneData);
+    const RenderPassContext passContext = BuildFrameStagePassContext(stage, plan, sceneData);

    switch (stage) {
    case CameraFrameStage::PreScenePasses:
        return ExecutePassSequenceStage(
            executionState.preScenePasses,
-            request.GetPassSequence(stage),
-            request.context,
+            plan.GetPassSequence(stage),
+            plan.request.context,
            passContext);
    case CameraFrameStage::ShadowCaster:
        return ExecuteScenePassRequest(
            executionState.shadowCasterPass,
            resolvedShadowCaster,
-            request.context,
+            plan.request.context,
            sceneData);
    case CameraFrameStage::DepthOnly:
        return ExecuteScenePassRequest(
            executionState.depthOnlyPass,
-            request.depthOnly,
-            request.context,
+            plan.request.depthOnly,
+            plan.request.context,
            sceneData);
    case CameraFrameStage::MainScene:
        return executionState.pipeline != nullptr &&
-               executionState.pipeline->Render(request.context, passContext.surface, sceneData);
+               executionState.pipeline->Render(
+                   FrameExecutionContext(
+                       plan.request.context,
+                       passContext.surface,
+                       sceneData,
+                       passContext.sourceSurface,
+                       passContext.sourceColorView,
+                       passContext.sourceColorState));
    case CameraFrameStage::PostProcess:
        return ExecuteFullscreenPassSequenceStage(
            executionState.postProcessPasses,
-            request.GetPassSequence(stage),
-            request.context,
+            plan.GetPassSequence(stage),
+            plan.request.context,
            passContext,
            executionState.postProcessSurfaceCache);
    case CameraFrameStage::FinalOutput:
        return ExecuteFullscreenPassSequenceStage(
            executionState.finalOutputPasses,
-            request.GetPassSequence(stage),
-            request.context,
+            plan.GetPassSequence(stage),
+            plan.request.context,
            passContext,
            executionState.finalOutputSurfaceCache);
    case CameraFrameStage::ObjectId:
-        return !request.objectId.IsRequested() ||
+        return !plan.request.objectId.IsRequested() ||
               ExecuteStandalonePass(
                   executionState.objectIdPass,
-                   request.context,
-                   request.objectId.surface,
+                   plan.request.context,
+                   plan.request.objectId.surface,
                   sceneData);
    case CameraFrameStage::PostScenePasses:
        return ExecutePassSequenceStage(
            executionState.postScenePasses,
-            request.GetPassSequence(stage),
-            request.context,
+            plan.GetPassSequence(stage),
+            plan.request.context,
            passContext);
    case CameraFrameStage::OverlayPasses:
        return ExecutePassSequenceStage(
            executionState.overlayPasses,
-            request.GetPassSequence(stage),
-            request.context,
+            plan.GetPassSequence(stage),
+            plan.request.context,
            passContext);
    default:
        return false;
@@ -396,27 +403,27 @@ RenderDirectionalShadowData BuildDirectionalShadowData(
    return shadowData;
 }

-RenderEnvironmentData BuildEnvironmentData(const CameraRenderRequest& request) {
+RenderEnvironmentData BuildEnvironmentData(const CameraFramePlan& plan) {
    RenderEnvironmentData environment = {};
-    const RenderSurface& mainSceneSurface = request.GetMainSceneSurface();
-    if (request.camera == nullptr ||
+    const RenderSurface& mainSceneSurface = plan.GetMainSceneSurface();
+    if (plan.request.camera == nullptr ||
        mainSceneSurface.GetDepthAttachment() == nullptr ||
-        !HasRenderClearFlag(request.clearFlags, RenderClearFlags::Color) ||
-        !request.camera->IsSkyboxEnabled() ||
-        request.camera->GetProjectionType() != Components::CameraProjectionType::Perspective) {
+        !HasRenderClearFlag(plan.request.clearFlags, RenderClearFlags::Color) ||
+        !plan.request.camera->IsSkyboxEnabled() ||
+        plan.request.camera->GetProjectionType() != Components::CameraProjectionType::Perspective) {
        return environment;
    }

-    if (const Resources::Material* skyboxMaterial = request.camera->GetSkyboxMaterial()) {
+    if (const Resources::Material* skyboxMaterial = plan.request.camera->GetSkyboxMaterial()) {
        environment.mode = RenderEnvironmentMode::MaterialSkybox;
        environment.materialSkybox.material = skyboxMaterial;
        return environment;
    }

    environment.mode = RenderEnvironmentMode::ProceduralSkybox;
-    environment.skybox.topColor = request.camera->GetSkyboxTopColor();
-    environment.skybox.horizonColor = request.camera->GetSkyboxHorizonColor();
-    environment.skybox.bottomColor = request.camera->GetSkyboxBottomColor();
+    environment.skybox.topColor = plan.request.camera->GetSkyboxTopColor();
+    environment.skybox.horizonColor = plan.request.camera->GetSkyboxHorizonColor();
+    environment.skybox.bottomColor = plan.request.camera->GetSkyboxBottomColor();
    return environment;
 }

@@ -538,17 +545,17 @@ void CameraRenderer::ResetPipeline(std::unique_ptr<RenderPipeline> pipeline) {
 }

 bool CameraRenderer::ResolveShadowCasterRequest(
-    const CameraRenderRequest& request,
+    const CameraFramePlan& plan,
    ShadowCasterRenderRequest& outResolvedShadowCaster,
    RHI::RHIResourceView*& outShadowMapView) {
-    outResolvedShadowCaster = request.shadowCaster;
+    outResolvedShadowCaster = plan.shadowCaster;
    outShadowMapView = nullptr;

    if (outResolvedShadowCaster.IsRequested()) {
        return outResolvedShadowCaster.IsValid();
    }

-    if (!request.directionalShadow.IsValid()) {
+    if (!plan.directionalShadow.IsValid()) {
        return true;
    }

@@ -556,7 +563,7 @@ bool CameraRenderer::ResolveShadowCasterRequest(
        m_directionalShadowSurface = std::make_unique<DirectionalShadowSurfaceCache>();
    }

-    if (!m_directionalShadowSurface->EnsureSurface(request.context, request.directionalShadow)) {
+    if (!m_directionalShadowSurface->EnsureSurface(plan.request.context, plan.directionalShadow)) {
        return false;
    }

@@ -564,44 +571,44 @@ bool CameraRenderer::ResolveShadowCasterRequest(
    outResolvedShadowCaster.clearFlags = RenderClearFlags::Depth;
    if (!outResolvedShadowCaster.hasCameraDataOverride) {
        outResolvedShadowCaster.hasCameraDataOverride = true;
-        outResolvedShadowCaster.cameraDataOverride = request.directionalShadow.cameraData;
+        outResolvedShadowCaster.cameraDataOverride = plan.directionalShadow.cameraData;
    }

    outShadowMapView = m_directionalShadowSurface->GetDepthShaderView();
    return true;
 }

-bool CameraRenderer::BuildSceneDataForRequest(
-    const CameraRenderRequest& request,
+bool CameraRenderer::BuildSceneDataForPlan(
+    const CameraFramePlan& plan,
    RHI::RHIResourceView* shadowMapView,
    RenderSceneData& outSceneData) {
-    const RenderSurface& mainSceneSurface = request.GetMainSceneSurface();
+    const RenderSurface& mainSceneSurface = plan.GetMainSceneSurface();
    outSceneData = m_sceneExtractor.ExtractForCamera(
-        *request.scene,
-        *request.camera,
+        *plan.request.scene,
+        *plan.request.camera,
        mainSceneSurface.GetRenderAreaWidth(),
        mainSceneSurface.GetRenderAreaHeight());
    if (!outSceneData.HasCamera()) {
        return false;
    }

-    if (request.directionalShadow.IsValid()) {
+    if (plan.directionalShadow.IsValid()) {
        outSceneData.lighting.mainDirectionalShadow =
-            BuildDirectionalShadowData(request.directionalShadow, shadowMapView);
+            BuildDirectionalShadowData(plan.directionalShadow, shadowMapView);
    }
    outSceneData.globalShaderKeywords = BuildSceneGlobalShaderKeywords(outSceneData);

-    outSceneData.cameraData.clearFlags = request.clearFlags;
-    outSceneData.environment = BuildEnvironmentData(request);
-    if (request.hasClearColorOverride) {
-        outSceneData.cameraData.clearColor = request.clearColorOverride;
+    outSceneData.cameraData.clearFlags = plan.request.clearFlags;
+    outSceneData.environment = BuildEnvironmentData(plan);
+    if (plan.request.hasClearColorOverride) {
+        outSceneData.cameraData.clearColor = plan.request.clearColorOverride;
    }

    return true;
 }

 bool CameraRenderer::ExecuteRenderPlan(
-    const CameraRenderRequest& request,
+    const CameraFramePlan& plan,
    const ShadowCasterRenderRequest& resolvedShadowCaster,
    const RenderSceneData& sceneData) {
    CameraFrameExecutionState executionState = {};
@@ -613,14 +620,14 @@ bool CameraRenderer::ExecuteRenderPlan(
    executionState.finalOutputSurfaceCache = m_finalOutputSurfaceCache.get();

    for (const CameraFrameStageInfo& stageInfo : kOrderedCameraFrameStages) {
-        if (!request.HasFrameStage(stageInfo.stage) &&
+        if (!plan.HasFrameStage(stageInfo.stage) &&
            stageInfo.stage != CameraFrameStage::MainScene) {
            continue;
        }

        if (!ExecuteFrameStage(
                stageInfo.stage,
-                request,
+                plan,
                resolvedShadowCaster,
                sceneData,
                executionState)) {
@@ -633,14 +640,19 @@ bool CameraRenderer::ExecuteRenderPlan(

 bool CameraRenderer::Render(
    const CameraRenderRequest& request) {
-    if (!request.IsValid() || m_pipeline == nullptr) {
+    return Render(CameraFramePlan::FromRequest(request));
+}
+
+bool CameraRenderer::Render(
+    const CameraFramePlan& plan) {
+    if (!plan.IsValid() || m_pipeline == nullptr) {
        Debug::Logger::Get().Error(
            Debug::LogCategory::Rendering,
-            "CameraRenderer::Render failed: request invalid or pipeline missing");
+            "CameraRenderer::Render failed: plan invalid or pipeline missing");
        return false;
    }

-    const RenderSurface& mainSceneSurface = request.GetMainSceneSurface();
+    const RenderSurface& mainSceneSurface = plan.GetMainSceneSurface();
    if (mainSceneSurface.GetRenderAreaWidth() == 0 ||
        mainSceneSurface.GetRenderAreaHeight() == 0) {
        Debug::Logger::Get().Error(
@@ -648,29 +660,29 @@ bool CameraRenderer::Render(
            "CameraRenderer::Render failed: main scene surface render area is empty");
        return false;
    }
-    if (request.depthOnly.IsRequested() &&
-        !request.depthOnly.IsValid()) {
+    if (plan.request.depthOnly.IsRequested() &&
+        !plan.request.depthOnly.IsValid()) {
        Debug::Logger::Get().Error(
            Debug::LogCategory::Rendering,
            "CameraRenderer::Render failed: depth-only request invalid");
        return false;
    }
-    if (request.postProcess.IsRequested() &&
-        !request.postProcess.IsValid()) {
+    if (plan.postProcess.IsRequested() &&
+        !plan.postProcess.IsValid()) {
        Debug::Logger::Get().Error(
            Debug::LogCategory::Rendering,
            "CameraRenderer::Render failed: post-process request invalid");
        return false;
    }
-    if (request.finalOutput.IsRequested() &&
-        !request.finalOutput.IsValid()) {
+    if (plan.finalOutput.IsRequested() &&
+        !plan.finalOutput.IsValid()) {
        Debug::Logger::Get().Error(
            Debug::LogCategory::Rendering,
            "CameraRenderer::Render failed: final-output request invalid");
        return false;
    }
-    if (request.objectId.IsRequested() &&
-        !request.objectId.IsValid()) {
+    if (plan.request.objectId.IsRequested() &&
+        !plan.request.objectId.IsValid()) {
        Debug::Logger::Get().Error(
            Debug::LogCategory::Rendering,
            "CameraRenderer::Render failed: object-id request invalid");
@@ -679,7 +691,7 @@ bool CameraRenderer::Render(

    ShadowCasterRenderRequest resolvedShadowCaster = {};
    RHI::RHIResourceView* shadowMapView = nullptr;
-    if (!ResolveShadowCasterRequest(request, resolvedShadowCaster, shadowMapView)) {
+    if (!ResolveShadowCasterRequest(plan, resolvedShadowCaster, shadowMapView)) {
        Debug::Logger::Get().Error(
            Debug::LogCategory::Rendering,
            "CameraRenderer::Render failed: ResolveShadowCasterRequest returned false");
@@ -687,14 +699,14 @@ bool CameraRenderer::Render(
    }

    RenderSceneData sceneData = {};
-    if (!BuildSceneDataForRequest(request, shadowMapView, sceneData)) {
+    if (!BuildSceneDataForPlan(plan, shadowMapView, sceneData)) {
        Debug::Logger::Get().Error(
            Debug::LogCategory::Rendering,
-            "CameraRenderer::Render failed: BuildSceneDataForRequest returned false");
+            "CameraRenderer::Render failed: BuildSceneDataForPlan returned false");
        return false;
    }

-    if (!ExecuteRenderPlan(request, resolvedShadowCaster, sceneData)) {
+    if (!ExecuteRenderPlan(plan, resolvedShadowCaster, sceneData)) {
        Debug::Logger::Get().Error(
            Debug::LogCategory::Rendering,
            "CameraRenderer::Render failed: ExecuteRenderPlan returned false");
--- a/engine/src/Rendering/Execution/SceneRenderer.cpp
+++ b/engine/src/Rendering/Execution/SceneRenderer.cpp
@@ -13,6 +13,14 @@ namespace Rendering {

 namespace {

+bool CompareCameraFramePlans(
+    const CameraFramePlan& lhs,
+    const CameraFramePlan& rhs) {
+    return SceneRenderRequestUtils::CompareCameraRenderRequests(
+        lhs.request,
+        rhs.request);
+}
+
 RenderSurface ConfigureFullscreenStageSurface(
    const FullscreenPassSurfaceCache::SurfaceEntry& entry,
    const RenderSurface& templateSurface,
@@ -94,44 +102,72 @@ std::vector<CameraRenderRequest> SceneRenderer::BuildRenderRequests(
    Components::CameraComponent* overrideCamera,
    const RenderContext& context,
    const RenderSurface& surface) {
-    std::vector<CameraRenderRequest> requests =
-        m_requestPlanner.BuildRequests(scene, overrideCamera, context, surface);
-    ResolveCameraFinalColorPolicies(requests);
-    AttachFullscreenStageRequests(context, requests);
+    const std::vector<CameraFramePlan> plans =
+        BuildFramePlans(scene, overrideCamera, context, surface);
+    std::vector<CameraRenderRequest> requests = {};
+    requests.reserve(plans.size());
+    for (const CameraFramePlan& plan : plans) {
+        requests.push_back(BuildLegacyCameraRenderRequest(plan));
+    }
    return requests;
 }

+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);
+    std::vector<CameraFramePlan> plans = CreateFramePlansFromRequests(requests);
+    ResolveCameraFinalColorPolicies(plans);
+    AttachFullscreenStageRequests(context, plans);
+    return plans;
+}
+
 bool SceneRenderer::Render(const CameraRenderRequest& request) {
-    return m_cameraRenderer.Render(request);
+    return Render(CameraFramePlan::FromRequest(request));
 }

 bool SceneRenderer::Render(const std::vector<CameraRenderRequest>& requests) {
-    if (requests.empty()) {
+    std::vector<CameraFramePlan> plans = CreateFramePlansFromRequests(requests);
+    return Render(plans);
+}
+
+bool SceneRenderer::Render(const CameraFramePlan& plan) {
+    return m_cameraRenderer.Render(plan);
+}
+
+bool SceneRenderer::Render(const std::vector<CameraFramePlan>& plans) {
+    if (plans.empty()) {
        return false;
    }

-    for (const CameraRenderRequest& request : requests) {
-        if (!request.IsValid()) {
+    for (const CameraFramePlan& plan : plans) {
+        if (!plan.IsValid()) {
            return false;
        }
    }

-    std::vector<CameraRenderRequest> sortedRequests = requests;
-    SceneRenderRequestUtils::SortCameraRenderRequests(sortedRequests);
+    std::vector<CameraFramePlan> sortedPlans = plans;
+    std::stable_sort(
+        sortedPlans.begin(),
+        sortedPlans.end(),
+        CompareCameraFramePlans);

    bool rendered = false;
-    for (const CameraRenderRequest& request : sortedRequests) {
-        if (!m_cameraRenderer.Render(request)) {
+    for (const CameraFramePlan& plan : sortedPlans) {
+        if (!m_cameraRenderer.Render(plan)) {
            return false;
        }

        UpdateTrackedFullscreenSurfaceState(
            m_ownedFullscreenStageSurfaces,
-            &request.GetMainSceneSurface());
-        if (request.postProcess.IsRequested()) {
+            &plan.GetMainSceneSurface());
+        if (plan.postProcess.IsRequested()) {
            UpdateTrackedFullscreenSurfaceState(
                m_ownedFullscreenStageSurfaces,
-                &request.postProcess.destinationSurface);
+                &plan.postProcess.destinationSurface);
        }

        rendered = true;
@@ -145,7 +181,18 @@ bool SceneRenderer::Render(
    Components::CameraComponent* overrideCamera,
    const RenderContext& context,
    const RenderSurface& surface) {
-    return Render(BuildRenderRequests(scene, overrideCamera, context, surface));
+    return Render(BuildFramePlans(scene, overrideCamera, context, surface));
+}
+
+std::vector<CameraFramePlan> SceneRenderer::CreateFramePlansFromRequests(
+    const std::vector<CameraRenderRequest>& requests) const {
+    std::vector<CameraFramePlan> plans = {};
+    plans.reserve(requests.size());
+    for (const CameraRenderRequest& request : requests) {
+        plans.push_back(CameraFramePlan::FromRequest(request));
+    }
+
+    return plans;
 }

 void SceneRenderer::PrepareOwnedFullscreenStageState(size_t requestCount) {
@@ -166,39 +213,39 @@ void SceneRenderer::PrepareOwnedFullscreenStageState(size_t requestCount) {
 }

 void SceneRenderer::ResolveCameraFinalColorPolicies(
-    std::vector<CameraRenderRequest>& requests) const {
+    std::vector<CameraFramePlan>& plans) const {
    const RenderPipelineAsset* pipelineAsset = GetPipelineAsset();
    const FinalColorSettings pipelineDefaults =
        pipelineAsset != nullptr ? pipelineAsset->GetDefaultFinalColorSettings() : FinalColorSettings();

-    for (CameraRenderRequest& request : requests) {
-        if (request.camera == nullptr) {
+    for (CameraFramePlan& plan : plans) {
+        if (plan.request.camera == nullptr) {
            continue;
        }

-        request.finalColorPolicy = ResolveFinalColorPolicy(
+        plan.finalColorPolicy = ResolveFinalColorPolicy(
            pipelineDefaults,
-            &request.camera->GetFinalColorOverrides());
+            &plan.request.camera->GetFinalColorOverrides());
    }
 }

 void SceneRenderer::AttachFullscreenStageRequests(
    const RenderContext& context,
-    std::vector<CameraRenderRequest>& requests) {
-    PrepareOwnedFullscreenStageState(requests.size());
+    std::vector<CameraFramePlan>& plans) {
+    PrepareOwnedFullscreenStageState(plans.size());

-    for (size_t index = 0; index < requests.size(); ++index) {
-        CameraRenderRequest& request = requests[index];
-        if (request.camera == nullptr ||
-            request.context.device == nullptr ||
-            !HasValidColorTarget(request.surface)) {
+    for (size_t index = 0; index < plans.size(); ++index) {
+        CameraFramePlan& plan = plans[index];
+        if (plan.request.camera == nullptr ||
+            plan.request.context.device == nullptr ||
+            !HasValidColorTarget(plan.request.surface)) {
            continue;
        }

        std::unique_ptr<RenderPassSequence> postProcessSequence =
-            BuildCameraPostProcessPassSequence(request.camera->GetPostProcessPasses());
+            BuildCameraPostProcessPassSequence(plan.request.camera->GetPostProcessPasses());
        std::unique_ptr<RenderPassSequence> finalOutputSequence =
-            BuildFinalColorPassSequence(request.finalColorPolicy);
+            BuildFinalColorPassSequence(plan.finalColorPolicy);

        const bool hasPostProcess =
            postProcessSequence != nullptr && postProcessSequence->GetPassCount() > 0u;
@@ -208,14 +255,14 @@ void SceneRenderer::AttachFullscreenStageRequests(
            continue;
        }

-        if (request.surface.GetSampleCount() > 1u) {
+        if (plan.request.surface.GetSampleCount() > 1u) {
            Debug::Logger::Get().Error(
                Debug::LogCategory::Rendering,
                "SceneRenderer fullscreen post-process/final-output chain currently requires a single-sample main scene surface");
            continue;
        }

-        const std::vector<RHI::RHIResourceView*>& colorAttachments = request.surface.GetColorAttachments();
+        const std::vector<RHI::RHIResourceView*>& colorAttachments = plan.request.surface.GetColorAttachments();
        const RHI::Format colorFormat = colorAttachments[0]->GetFormat();
        if (colorFormat == RHI::Format::Unknown) {
            continue;
@@ -226,8 +273,8 @@ void SceneRenderer::AttachFullscreenStageRequests(
        if (surfaceCache == nullptr ||
            !surfaceCache->EnsureSurfaces(
                context,
-                request.surface.GetWidth(),
-                request.surface.GetHeight(),
+                plan.request.surface.GetWidth(),
+                plan.request.surface.GetHeight(),
                colorFormat,
                fullscreenSurfaceCount)) {
            continue;
@@ -246,30 +293,30 @@ void SceneRenderer::AttachFullscreenStageRequests(
        }

        if (hasPostProcess) {
-            request.postProcess.sourceSurface =
-                ConfigureFullscreenStageSurface(*sceneColorEntry, request.surface, true);
-            request.postProcess.sourceColorView = sceneColorEntry->shaderResourceView;
-            request.postProcess.sourceColorState = request.postProcess.sourceSurface.GetColorStateAfter();
-            request.postProcess.destinationSurface =
+            plan.postProcess.sourceSurface =
+                ConfigureFullscreenStageSurface(*sceneColorEntry, plan.request.surface, true);
+            plan.postProcess.sourceColorView = sceneColorEntry->shaderResourceView;
+            plan.postProcess.sourceColorState = plan.postProcess.sourceSurface.GetColorStateAfter();
+            plan.postProcess.destinationSurface =
                hasFinalOutput
-                    ? ConfigureFullscreenStageSurface(*postProcessOutputEntry, request.surface, false)
-                    : request.surface;
+                    ? ConfigureFullscreenStageSurface(*postProcessOutputEntry, plan.request.surface, false)
+                    : plan.request.surface;
            m_ownedPostProcessSequences[index] = std::move(postProcessSequence);
-            request.postProcess.passes = m_ownedPostProcessSequences[index].get();
+            plan.postProcess.passes = m_ownedPostProcessSequences[index].get();
        }

        if (hasFinalOutput) {
            const FullscreenPassSurfaceCache::SurfaceEntry* finalOutputSourceEntry =
                hasPostProcess ? postProcessOutputEntry : sceneColorEntry;
-            request.finalOutput.sourceSurface =
+            plan.finalOutput.sourceSurface =
                hasPostProcess
-                    ? request.postProcess.destinationSurface
-                    : ConfigureFullscreenStageSurface(*sceneColorEntry, request.surface, true);
-            request.finalOutput.sourceColorView = finalOutputSourceEntry->shaderResourceView;
-            request.finalOutput.sourceColorState = request.finalOutput.sourceSurface.GetColorStateAfter();
-            request.finalOutput.destinationSurface = request.surface;
+                    ? plan.postProcess.destinationSurface
+                    : ConfigureFullscreenStageSurface(*sceneColorEntry, plan.request.surface, true);
+            plan.finalOutput.sourceColorView = finalOutputSourceEntry->shaderResourceView;
+            plan.finalOutput.sourceColorState = plan.finalOutput.sourceSurface.GetColorStateAfter();
+            plan.finalOutput.destinationSurface = plan.request.surface;
            m_ownedFinalOutputSequences[index] = std::move(finalOutputSequence);
-            request.finalOutput.passes = m_ownedFinalOutputSequences[index].get();
+            plan.finalOutput.passes = m_ownedFinalOutputSequences[index].get();
        }
    }
 }
--- a/engine/src/Rendering/Extraction/RenderSceneExtractor.cpp
+++ b/engine/src/Rendering/Extraction/RenderSceneExtractor.cpp
@@ -3,6 +3,7 @@
 #include "Components/CameraComponent.h"
 #include "Components/GameObject.h"
 #include "Components/LightComponent.h"
+#include "Rendering/FrameData/RendererListUtils.h"
 #include "Rendering/Extraction/RenderSceneUtility.h"
 #include "Scene/Scene.h"

@@ -125,6 +126,21 @@ bool CompareVisibleGaussianSplats(
    return CompareVisibleGaussianSplatsStable(lhs, rhs);
 }

+void BuildRendererLists(RenderSceneData& sceneData) {
+    sceneData.cullingResults.Clear();
+    sceneData.cullingResults.rendererLists.reserve(5u);
+    sceneData.cullingResults.rendererLists.push_back(
+        BuildRendererList(RendererListType::AllVisible, sceneData.visibleItems));
+    sceneData.cullingResults.rendererLists.push_back(
+        BuildRendererList(RendererListType::Opaque, sceneData.visibleItems));
+    sceneData.cullingResults.rendererLists.push_back(
+        BuildRendererList(RendererListType::Transparent, sceneData.visibleItems));
+    sceneData.cullingResults.rendererLists.push_back(
+        BuildRendererList(RendererListType::ShadowCaster, sceneData.visibleItems));
+    sceneData.cullingResults.rendererLists.push_back(
+        BuildRendererList(RendererListType::ObjectId, sceneData.visibleItems));
+}
+
 } // namespace

 RenderSceneData RenderSceneExtractor::Extract(
@@ -165,6 +181,7 @@ RenderSceneData RenderSceneExtractor::Extract(
        sceneData.visibleVolumes.begin(),
        sceneData.visibleVolumes.end(),
        CompareVisibleVolumes);
+    BuildRendererLists(sceneData);
    ExtractLighting(scene, cameraPosition, cullingMask, sceneData.lighting);

    return sceneData;
@@ -208,6 +225,7 @@ RenderSceneData RenderSceneExtractor::ExtractForCamera(
        sceneData.visibleVolumes.begin(),
        sceneData.visibleVolumes.end(),
        CompareVisibleVolumes);
+    BuildRendererLists(sceneData);
    ExtractLighting(scene, cameraPosition, cullingMask, sceneData.lighting);

    return sceneData;
--- a/engine/src/Rendering/Passes/BuiltinDepthStylePassBase.cpp
+++ b/engine/src/Rendering/Passes/BuiltinDepthStylePassBase.cpp
@@ -2,6 +2,7 @@

 #include "RHI/RHICommandList.h"
 #include "Rendering/Extraction/RenderSceneExtractor.h"
+#include "Rendering/FrameData/RendererListUtils.h"
 #include "Rendering/Internal/RenderSurfacePipelineUtils.h"
 #include "Rendering/RenderSurface.h"
 #include "Resources/Mesh/Mesh.h"
@@ -139,13 +140,16 @@ bool BuiltinDepthStylePassBase::Execute(const RenderPassContext& context) {

    commandList->SetPrimitiveTopology(RHI::PrimitiveTopology::TriangleList);

-    for (const VisibleRenderItem& visibleItem : context.sceneData.visibleItems) {
-        if (!ShouldRenderVisibleItem(visibleItem)) {
-            continue;
-        }
+    VisitRendererListVisibleItems(
+        context.sceneData,
+        GetRendererListType(),
+        [&](const VisibleRenderItem& visibleItem) {
+            if (!ShouldRenderVisibleItem(visibleItem)) {
+                return;
+            }

-        DrawVisibleItem(context.renderContext, context.surface, context.sceneData, visibleItem);
-    }
+            DrawVisibleItem(context.renderContext, context.surface, context.sceneData, visibleItem);
+        });

    commandList->EndRenderPass();

@@ -165,6 +169,10 @@ bool BuiltinDepthStylePassBase::Execute(const RenderPassContext& context) {
    return true;
 }

+RendererListType BuiltinDepthStylePassBase::GetRendererListType() const {
+    return RendererListType::AllVisible;
+}
+
 bool BuiltinDepthStylePassBase::ShouldRenderVisibleItem(const VisibleRenderItem& visibleItem) const {
    (void)visibleItem;
    return true;
--- a/engine/src/Rendering/Passes/BuiltinGaussianSplatPass.cpp
+++ b/engine/src/Rendering/Passes/BuiltinGaussianSplatPass.cpp
@@ -222,6 +222,16 @@ bool BuiltinGaussianSplatPass::Initialize(const RenderContext& context) {
    return EnsureInitialized(context);
 }

+bool BuiltinGaussianSplatPass::IsActive(const RenderSceneData& sceneData) const {
+    return !sceneData.visibleGaussianSplats.empty();
+}
+
+bool BuiltinGaussianSplatPass::Prepare(
+    const RenderContext& context,
+    const RenderSceneData& sceneData) {
+    return PrepareGaussianSplatResources(context, sceneData);
+}
+
 bool BuiltinGaussianSplatPass::PrepareGaussianSplatResources(
    const RenderContext& context,
    const RenderSceneData& sceneData) {
--- a/engine/src/Rendering/Passes/BuiltinObjectIdPass.cpp
+++ b/engine/src/Rendering/Passes/BuiltinObjectIdPass.cpp
@@ -2,6 +2,7 @@

 #include "Core/Asset/ResourceManager.h"
 #include "RHI/RHICommandList.h"
+#include "Rendering/FrameData/RendererListUtils.h"
 #include "Rendering/Internal/RenderSurfacePipelineUtils.h"
 #include "Rendering/Extraction/RenderSceneExtractor.h"
 #include "Rendering/RenderSurface.h"
@@ -119,9 +120,12 @@ bool BuiltinObjectIdPass::Execute(const RenderPassContext& context) {
    commandList->SetPrimitiveTopology(RHI::PrimitiveTopology::TriangleList);
    commandList->SetPipelineState(m_pipelineState);

-    for (const VisibleRenderItem& visibleItem : context.sceneData.visibleItems) {
-        DrawVisibleItem(context.renderContext, context.sceneData, visibleItem);
-    }
+    VisitRendererListVisibleItems(
+        context.sceneData,
+        RendererListType::ObjectId,
+        [&](const VisibleRenderItem& visibleItem) {
+            DrawVisibleItem(context.renderContext, context.sceneData, visibleItem);
+        });

    commandList->EndRenderPass();

--- a/engine/src/Rendering/Passes/BuiltinShadowCasterPass.cpp
+++ b/engine/src/Rendering/Passes/BuiltinShadowCasterPass.cpp
@@ -22,6 +22,10 @@ const char* BuiltinShadowCasterPass::GetName() const {
    return "BuiltinShadowCasterPass";
 }

+RendererListType BuiltinShadowCasterPass::GetRendererListType() const {
+    return RendererListType::ShadowCaster;
+}
+
 bool BuiltinShadowCasterPass::ShouldRenderVisibleItem(const VisibleRenderItem& visibleItem) const {
    return visibleItem.meshRenderer == nullptr || visibleItem.meshRenderer->GetCastShadows();
 }
--- a/engine/src/Rendering/Passes/BuiltinVolumetricPass.cpp
+++ b/engine/src/Rendering/Passes/BuiltinVolumetricPass.cpp
@@ -210,6 +210,16 @@ bool BuiltinVolumetricPass::Initialize(const RenderContext& context) {
    return EnsureInitialized(context);
 }

+bool BuiltinVolumetricPass::IsActive(const RenderSceneData& sceneData) const {
+    return !sceneData.visibleVolumes.empty();
+}
+
+bool BuiltinVolumetricPass::Prepare(
+    const RenderContext& context,
+    const RenderSceneData& sceneData) {
+    return PrepareVolumeResources(context, sceneData);
+}
+
 bool BuiltinVolumetricPass::PrepareVolumeResources(
    const RenderContext& context,
    const RenderSceneData& sceneData) {
--- a/engine/src/Rendering/Pipelines/BuiltinForwardPipeline.cpp
+++ b/engine/src/Rendering/Pipelines/BuiltinForwardPipeline.cpp
@@ -143,58 +143,31 @@ RHI::InputLayoutDesc BuiltinForwardPipeline::BuildInputLayout() {

 bool BuiltinForwardPipeline::Initialize(const RenderContext& context) {
    return EnsureInitialized(context) &&
-        m_gaussianSplatPass != nullptr &&
-        m_gaussianSplatPass->Initialize(context) &&
-        m_volumetricPass != nullptr &&
-        m_volumetricPass->Initialize(context);
+        InitializeForwardSceneFeaturePasses(context);
 }

 void BuiltinForwardPipeline::Shutdown() {
-    if (m_gaussianSplatPass != nullptr) {
-        m_gaussianSplatPass->Shutdown();
-    }
-    if (m_volumetricPass != nullptr) {
-        m_volumetricPass->Shutdown();
-    }
+    ShutdownForwardSceneFeaturePasses();
    DestroyPipelineResources();
 }

 bool BuiltinForwardPipeline::Render(
-    const RenderContext& context,
-    const RenderSurface& surface,
-    const RenderSceneData& sceneData) {
-    if (!Initialize(context)) {
+    const FrameExecutionContext& executionContext) {
+    if (!Initialize(executionContext.renderContext)) {
        Debug::Logger::Get().Error(
            Debug::LogCategory::Rendering,
            "BuiltinForwardPipeline::Render failed: Initialize returned false");
        return false;
    }

-    if (m_volumetricPass != nullptr &&
-        !sceneData.visibleVolumes.empty() &&
-        !m_volumetricPass->PrepareVolumeResources(context, sceneData)) {
+    if (!PrepareForwardSceneFeaturePasses(executionContext)) {
        Debug::Logger::Get().Error(
            Debug::LogCategory::Rendering,
-            "BuiltinForwardPipeline::Render failed: PrepareVolumeResources returned false");
-        return false;
-    }
-    if (m_gaussianSplatPass != nullptr &&
-        !sceneData.visibleGaussianSplats.empty() &&
-        !m_gaussianSplatPass->PrepareGaussianSplatResources(context, sceneData)) {
-        Debug::Logger::Get().Error(
-            Debug::LogCategory::Rendering,
-            "BuiltinForwardPipeline::Render failed: PrepareGaussianSplatResources returned false");
+            "BuiltinForwardPipeline::Render failed: PrepareForwardSceneFeaturePasses returned false");
        return false;
    }

-    const RenderPassContext passContext = {
-        context,
-        surface,
-        sceneData,
-        nullptr,
-        nullptr,
-        RHI::ResourceStates::Common
-    };
+    const RenderPassContext passContext = BuildRenderPassContext(executionContext);

    if (!BeginForwardScenePass(passContext)) {
        Debug::Logger::Get().Error(
@@ -203,53 +176,33 @@ bool BuiltinForwardPipeline::Render(
        return false;
    }

-    const bool sampledDirectionalShadow = ShouldSampleMainDirectionalShadowMap(sceneData);
+    const bool sampledDirectionalShadow =
+        ShouldSampleMainDirectionalShadowMap(executionContext.sceneData);
    if (sampledDirectionalShadow) {
-        TransitionMainDirectionalShadowForSampling(context, sceneData);
+        TransitionMainDirectionalShadowForSampling(
+            executionContext.renderContext,
+            executionContext.sceneData);
    }

-    bool renderResult = ExecuteForwardOpaquePass(passContext);
-    if (renderResult) {
-        renderResult = ExecuteForwardSkyboxPass(passContext);
-        if (!renderResult) {
-            Debug::Logger::Get().Error(
-                Debug::LogCategory::Rendering,
-                "BuiltinForwardPipeline::Render failed: ExecuteForwardSkyboxPass returned false");
-        }
-    }
-    if (renderResult && m_gaussianSplatPass != nullptr) {
-        renderResult = m_gaussianSplatPass->Execute(passContext);
-        if (!renderResult) {
-            Debug::Logger::Get().Error(
-                Debug::LogCategory::Rendering,
-                "BuiltinForwardPipeline::Render failed: BuiltinGaussianSplatPass::Execute returned false");
-        }
-    }
-    if (renderResult && m_volumetricPass != nullptr) {
-        renderResult = m_volumetricPass->Execute(passContext);
-        if (!renderResult) {
-            Debug::Logger::Get().Error(
-                Debug::LogCategory::Rendering,
-                "BuiltinForwardPipeline::Render failed: BuiltinVolumetricPass::Execute returned false");
-        }
-    }
-    if (renderResult) {
-        renderResult = ExecuteForwardTransparentPass(passContext);
-        if (!renderResult) {
-            Debug::Logger::Get().Error(
-                Debug::LogCategory::Rendering,
-                "BuiltinForwardPipeline::Render failed: ExecuteForwardTransparentPass returned false");
-        }
-    }
+    const bool renderResult = ExecuteForwardScene(executionContext);

    if (sampledDirectionalShadow) {
-        RestoreMainDirectionalShadowAfterSampling(context, sceneData);
+        RestoreMainDirectionalShadowAfterSampling(
+            executionContext.renderContext,
+            executionContext.sceneData);
    }
    EndForwardScenePass(passContext);

    return renderResult;
 }

+bool BuiltinForwardPipeline::Render(
+    const RenderContext& context,
+    const RenderSurface& surface,
+    const RenderSceneData& sceneData) {
+    return Render(FrameExecutionContext(context, surface, sceneData));
+}
+
 bool BuiltinForwardPipeline::BeginForwardScenePass(const RenderPassContext& passContext) {
    const RenderContext& context = passContext.renderContext;
    const RenderSurface& surface = passContext.surface;
@@ -358,20 +311,18 @@ void BuiltinForwardPipeline::EndForwardScenePass(const RenderPassContext& passCo
    }
 }

-bool BuiltinForwardPipeline::ExecuteForwardOpaquePass(const RenderPassContext& passContext) {
-    const RenderContext& context = passContext.renderContext;
-    const RenderSurface& surface = passContext.surface;
-    const RenderSceneData& sceneData = passContext.sceneData;
-
-    return DrawVisibleItems(context, surface, sceneData, false);
+bool BuiltinForwardPipeline::ExecuteForwardOpaquePass(
+    const ScenePhaseExecutionContext& executionContext) {
+    return DrawVisibleItems(
+        executionContext.frameContext,
+        BuildDrawSettings(executionContext.scenePhase));
 }

-bool BuiltinForwardPipeline::ExecuteForwardTransparentPass(const RenderPassContext& passContext) {
-    const RenderContext& context = passContext.renderContext;
-    const RenderSurface& surface = passContext.surface;
-    const RenderSceneData& sceneData = passContext.sceneData;
-
-    return DrawVisibleItems(context, surface, sceneData, true);
+bool BuiltinForwardPipeline::ExecuteForwardTransparentPass(
+    const ScenePhaseExecutionContext& executionContext) {
+    return DrawVisibleItems(
+        executionContext.frameContext,
+        BuildDrawSettings(executionContext.scenePhase));
 }

 bool BuiltinForwardPipeline::EnsureInitialized(const RenderContext& context) {
@@ -392,6 +343,146 @@ bool BuiltinForwardPipeline::EnsureInitialized(const RenderContext& context) {
    return m_initialized;
 }

+BuiltinForwardPipeline::ForwardSceneFeaturePassArray
+BuiltinForwardPipeline::CollectForwardSceneFeaturePasses() const {
+    return {
+        m_gaussianSplatPass.get(),
+        m_volumetricPass.get()
+    };
+}
+
+bool BuiltinForwardPipeline::InitializeForwardSceneFeaturePasses(const RenderContext& context) {
+    for (SceneRenderFeaturePass* featurePass : CollectForwardSceneFeaturePasses()) {
+        if (featurePass == nullptr || !featurePass->Initialize(context)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+void BuiltinForwardPipeline::ShutdownForwardSceneFeaturePasses() {
+    for (SceneRenderFeaturePass* featurePass : CollectForwardSceneFeaturePasses()) {
+        if (featurePass != nullptr) {
+            featurePass->Shutdown();
+        }
+    }
+}
+
+bool BuiltinForwardPipeline::PrepareForwardSceneFeaturePasses(
+    const FrameExecutionContext& executionContext) const {
+    for (SceneRenderFeaturePass* featurePass : CollectForwardSceneFeaturePasses()) {
+        if (featurePass == nullptr || !featurePass->IsActive(executionContext.sceneData)) {
+            continue;
+        }
+
+        if (!featurePass->Prepare(
+                executionContext.renderContext,
+                executionContext.sceneData)) {
+            Debug::Logger::Get().Error(
+                Debug::LogCategory::Rendering,
+                (Containers::String("BuiltinForwardPipeline feature prepare failed: ") +
+                    featurePass->GetName()).CStr());
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool BuiltinForwardPipeline::ExecuteForwardSceneFeaturePasses(
+    const ScenePhaseExecutionContext& executionContext) const {
+    const RenderPassContext passContext = BuildRenderPassContext(executionContext);
+
+    for (SceneRenderFeaturePass* featurePass : CollectForwardSceneFeaturePasses()) {
+        if (featurePass == nullptr ||
+            !featurePass->IsActive(executionContext.frameContext.sceneData)) {
+            continue;
+        }
+
+        if (!featurePass->Execute(passContext)) {
+            Debug::Logger::Get().Error(
+                Debug::LogCategory::Rendering,
+                (Containers::String("BuiltinForwardPipeline feature execute failed: ") +
+                    featurePass->GetName()).CStr());
+            return false;
+        }
+    }
+
+    return true;
+}
+
+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::ExecuteScenePhase(
+    const ScenePhaseExecutionContext& executionContext) {
+    switch (executionContext.scenePhase) {
+    case ScenePhase::Opaque:
+        return ExecuteForwardOpaquePass(executionContext);
+    case ScenePhase::Skybox:
+        return ExecuteForwardSkyboxPass(BuildRenderPassContext(executionContext));
+    case ScenePhase::Feature:
+        return ExecuteForwardSceneFeaturePasses(executionContext);
+    case ScenePhase::Transparent:
+        return ExecuteForwardTransparentPass(executionContext);
+    default:
+        Debug::Logger::Get().Error(
+            Debug::LogCategory::Rendering,
+            (Containers::String("BuiltinForwardPipeline::ExecuteScenePhase does not support scene phase: ") +
+                ToString(executionContext.scenePhase)).CStr());
+        return false;
+    }
+}
+
+bool BuiltinForwardPipeline::ExecuteForwardScene(
+    const FrameExecutionContext& executionContext) {
+    static constexpr ScenePhase kForwardScenePhases[] = {
+        ScenePhase::Opaque,
+        ScenePhase::Skybox,
+        ScenePhase::Feature,
+        ScenePhase::Transparent
+    };
+
+    for (ScenePhase scenePhase : kForwardScenePhases) {
+        const ScenePhaseExecutionContext scenePhaseExecutionContext =
+            BuildScenePhaseExecutionContext(executionContext, scenePhase);
+        if (!ExecuteScenePhase(scenePhaseExecutionContext)) {
+            Debug::Logger::Get().Error(
+                Debug::LogCategory::Rendering,
+                (Containers::String("BuiltinForwardPipeline::ExecuteForwardScene failed during phase: ") +
+                    ToString(scenePhase)).CStr());
+            return false;
+        }
+    }
+
+    return true;
+}
+
 bool BuiltinForwardPipeline::CreatePipelineResources(const RenderContext& context) {
    m_builtinForwardShader = Resources::ResourceManager::Get().Load<Resources::Shader>(
        Resources::GetBuiltinForwardLitShaderPath());
--- a/engine/src/Rendering/Pipelines/Internal/BuiltinForwardPipelineResources.cpp
+++ b/engine/src/Rendering/Pipelines/Internal/BuiltinForwardPipelineResources.cpp
@@ -5,6 +5,7 @@
 #include "RHI/RHICommandList.h"
 #include "RHI/RHIDevice.h"
 #include "Rendering/Builtin/BuiltinPassLayoutUtils.h"
+#include "Rendering/FrameData/RendererListUtils.h"
 #include "Rendering/Internal/RenderSurfacePipelineUtils.h"
 #include "Rendering/Internal/ShaderVariantUtils.h"
 #include "Rendering/Materials/RenderMaterialResolve.h"
@@ -687,10 +688,12 @@ BuiltinForwardPipeline::AdditionalLightConstants BuiltinForwardPipeline::BuildAd
 }

 bool BuiltinForwardPipeline::DrawVisibleItem(
-    const RenderContext& context,
-    const RenderSurface& surface,
-    const RenderSceneData& sceneData,
+    const FrameExecutionContext& executionContext,
    const VisibleRenderItem& visibleItem) {
+    const RenderContext& context = executionContext.renderContext;
+    const RenderSurface& surface = executionContext.surface;
+    const RenderSceneData& sceneData = executionContext.sceneData;
+
    (void)surface;
    const RenderResourceCache::CachedMesh* cachedMesh = m_resourceCache.GetOrCreateMesh(m_device, visibleItem.mesh);
    if (cachedMesh == nullptr || cachedMesh->vertexBufferView == nullptr) {
@@ -861,36 +864,35 @@ bool BuiltinForwardPipeline::DrawVisibleItem(
 }

 bool BuiltinForwardPipeline::DrawVisibleItems(
-    const RenderContext& context,
-    const RenderSurface& surface,
-    const RenderSceneData& sceneData,
-    bool drawTransparentItems) {
+    const FrameExecutionContext& executionContext,
+    const DrawSettings& drawSettings) {
+    const RenderContext& context = executionContext.renderContext;
+    const RenderSurface& surface = executionContext.surface;
+    const RenderSceneData& sceneData = executionContext.sceneData;
+
    RHI::RHICommandList* commandList = context.commandList;
    RHI::RHIPipelineState* currentPipelineState = nullptr;
-    for (const VisibleRenderItem& visibleItem : sceneData.visibleItems) {
-        const bool isTransparentItem = IsTransparentRenderQueue(visibleItem.renderQueue);
-        if (isTransparentItem != drawTransparentItems) {
-            continue;
-        }

+    auto drawVisibleItem = [&](const VisibleRenderItem& visibleItem) {
        const Resources::Material* material = ResolveMaterial(visibleItem);
        BuiltinMaterialPass pass = BuiltinMaterialPass::ForwardLit;
        if (!TryResolveSurfacePassType(material, pass)) {
-            continue;
+            return;
        }

        RHI::RHIPipelineState* pipelineState = GetOrCreatePipelineState(context, surface, sceneData, material);
        if (pipelineState == nullptr) {
-            continue;
+            return;
        }
        if (pipelineState != currentPipelineState) {
            commandList->SetPipelineState(pipelineState);
            currentPipelineState = pipelineState;
        }

-        DrawVisibleItem(context, surface, sceneData, visibleItem);
-    }
+        DrawVisibleItem(executionContext, visibleItem);
+    };

+    VisitRendererListVisibleItems(sceneData, drawSettings.rendererListType, drawVisibleItem);
    return true;
 }

--- a/engine/src/Rendering/Planning/SceneRenderRequestPlanner.cpp
+++ b/engine/src/Rendering/Planning/SceneRenderRequestPlanner.cpp
@@ -81,11 +81,19 @@ std::vector<CameraRenderRequest> SceneRenderRequestPlanner::BuildRequests(
                    ? static_cast<float>(surface.GetRenderAreaWidth()) /
                        static_cast<float>(surface.GetRenderAreaHeight())
                    : 1.0f;
+                DirectionalShadowPlanningSettings effectiveShadowSettings =
+                    m_directionalShadowPlanningSettings;
+                if (mainDirectionalLight->GetOverridesDirectionalShadowSettings()) {
+                    effectiveShadowSettings.sampling =
+                        mainDirectionalLight->GetDirectionalShadowSamplingSettings();
+                    effectiveShadowSettings.casterBias =
+                        mainDirectionalLight->GetDirectionalShadowCasterBiasSettings();
+                }
                request.directionalShadow = Internal::BuildDirectionalShadowRenderPlan(
                    scene,
                    *camera,
                    *mainDirectionalLight,
-                    m_directionalShadowPlanningSettings,
+                    effectiveShadowSettings,
                    viewportAspect);
                if (request.directionalShadow.IsValid()) {
                    request.shadowCaster.clearFlags = RenderClearFlags::Depth;