diff --git a/engine/src/Rendering/Internal/RenderPassGraphUtils.cpp b/engine/src/Rendering/Internal/RenderPassGraphUtils.cpp
index aabef70b..b37e5caa 100644
--- a/engine/src/Rendering/Internal/RenderPassGraphUtils.cpp
+++ b/engine/src/Rendering/Internal/RenderPassGraphUtils.cpp
@@ -166,11 +166,15 @@ bool ResolveGraphManagedOutputSurface(
 
 } // namespace
 
-bool RecordRasterRenderPass(
-    RenderPass& pass,
+bool RecordCallbackRasterRenderPass(
     const RenderPassRenderGraphContext& context,
-    const RenderPassGraphIO& io) {
-    RenderPass* const renderPass = &pass;
+    const RenderPassGraphIO& io,
+    RenderPassGraphExecutePassCallback executePassCallback,
+    std::vector<RenderGraphTextureHandle> additionalReadTextures) {
+    if (!executePassCallback) {
+        return false;
+    }
+
     const Containers::String passName = context.passName;
     const RenderContext renderContext = context.renderContext;
     const std::shared_ptr<const RenderSceneData> sceneData =
@@ -190,8 +194,7 @@ bool RecordRasterRenderPass(
 
     context.graphBuilder.AddRasterPass(
         passName,
-        [renderPass,
-         renderContext,
+        [renderContext,
          sceneData,
          surface,
          hasSourceSurface,
@@ -204,12 +207,20 @@ bool RecordRasterRenderPass(
          executionSucceeded,
          beginPassCallback,
          endPassCallback,
+         executePassCallback,
+         additionalReadTextures,
          io](
             RenderGraphPassBuilder& passBuilder) {
             if (io.readSourceColor && sourceColorTexture.IsValid()) {
                 passBuilder.ReadTexture(sourceColorTexture);
             }
 
+            for (RenderGraphTextureHandle readTexture : additionalReadTextures) {
+                if (readTexture.IsValid()) {
+                    passBuilder.ReadTexture(readTexture);
+                }
+            }
+
             if (io.writeColor) {
                 for (RenderGraphTextureHandle colorTarget : colorTargets) {
                     if (colorTarget.IsValid()) {
@@ -223,8 +234,7 @@ bool RecordRasterRenderPass(
             }
 
             passBuilder.SetExecuteCallback(
-                [renderPass,
-                 renderContext,
+                [renderContext,
                  sceneData,
                  surface,
                  hasSourceSurface,
@@ -237,6 +247,7 @@ bool RecordRasterRenderPass(
                  executionSucceeded,
                  beginPassCallback,
                  endPassCallback,
+                 executePassCallback,
                  io](
                     const RenderGraphExecutionContext& executionContext) {
                     if (executionSucceeded != nullptr && !(*executionSucceeded)) {
@@ -297,7 +308,7 @@ bool RecordRasterRenderPass(
                         return;
                     }
 
-                    const bool executeResult = renderPass->Execute(passContext);
+                    const bool executeResult = executePassCallback(passContext);
                     if (endPassCallback) {
                         endPassCallback(passContext);
                     }
@@ -309,6 +320,18 @@ bool RecordRasterRenderPass(
     return true;
 }
 
+bool RecordRasterRenderPass(
+    RenderPass& pass,
+    const RenderPassRenderGraphContext& context,
+    const RenderPassGraphIO& io) {
+    return RecordCallbackRasterRenderPass(
+        context,
+        io,
+        [&pass](const RenderPassContext& passContext) {
+            return pass.Execute(passContext);
+        });
+}
+
 } // namespace Internal
 } // namespace Rendering
 } // namespace XCEngine
diff --git a/engine/src/Rendering/Internal/RenderPassGraphUtils.h b/engine/src/Rendering/Internal/RenderPassGraphUtils.h
index cc5114d3..d88f563c 100644
--- a/engine/src/Rendering/Internal/RenderPassGraphUtils.h
+++ b/engine/src/Rendering/Internal/RenderPassGraphUtils.h
@@ -12,6 +12,15 @@ struct RenderPassGraphIO {
     bool writeDepth = false;
 };
 
+using RenderPassGraphExecutePassCallback =
+    std::function<bool(const RenderPassContext&)>;
+
+bool RecordCallbackRasterRenderPass(
+    const RenderPassRenderGraphContext& context,
+    const RenderPassGraphIO& io,
+    RenderPassGraphExecutePassCallback executePassCallback,
+    std::vector<RenderGraphTextureHandle> additionalReadTextures = {});
+
 bool RecordRasterRenderPass(
     RenderPass& pass,
     const RenderPassRenderGraphContext& context,
diff --git a/engine/src/Rendering/Pipelines/Internal/BuiltinForwardPipelineFrame.cpp b/engine/src/Rendering/Pipelines/Internal/BuiltinForwardPipelineFrame.cpp
index 57c02f8b..1c44794c 100644
--- a/engine/src/Rendering/Pipelines/Internal/BuiltinForwardPipelineFrame.cpp
+++ b/engine/src/Rendering/Pipelines/Internal/BuiltinForwardPipelineFrame.cpp
@@ -2,6 +2,7 @@
 
 #include "Debug/Logger.h"
 #include "Rendering/Graph/RenderGraph.h"
+#include "Rendering/Internal/RenderPassGraphUtils.h"
 #include "Rendering/Pipelines/Internal/BuiltinForwardSceneSetup.h"
 #include "RHI/RHICommandList.h"
 #include "Rendering/Internal/RenderSurfacePipelineUtils.h"
@@ -213,81 +214,54 @@ bool BuiltinForwardPipeline::RecordMainSceneRenderGraph(
 
         const Containers::String phasePassName =
             BuildForwardScenePhasePassName(passName, step.scenePhase);
-        context.graphBuilder.AddRasterPass(
+        const RenderPassGraphBeginCallback beginPhasePass =
+            [beginRecordedPass, clearAttachments](const RenderPassContext& passContext) {
+                return beginRecordedPass(passContext, clearAttachments);
+            };
+        const std::vector<RenderGraphTextureHandle> additionalReadTextures =
+            ScenePhaseSamplesMainDirectionalShadow(step.scenePhase) &&
+                mainDirectionalShadowTexture.IsValid()
+            ? std::vector<RenderGraphTextureHandle>{ mainDirectionalShadowTexture }
+            : std::vector<RenderGraphTextureHandle>{};
+        const RenderPassRenderGraphContext phaseContext = {
+            context.graphBuilder,
             phasePassName,
-            [this,
-             surfaceTemplate,
-             renderContext,
-             sceneData,
-             hasSourceSurface,
-             sourceSurface,
-             sourceColorView,
-             sourceColorState,
-             colorTargets,
-             depthTarget,
-             mainDirectionalShadowTexture,
-             executionSucceeded,
-             beginRecordedPass,
-             endRecordedPass,
-             clearAttachments,
-             scenePhase = step.scenePhase](
-                RenderGraphPassBuilder& passBuilder) {
-                for (RenderGraphTextureHandle colorTarget : colorTargets) {
-                    if (colorTarget.IsValid()) {
-                        passBuilder.WriteTexture(colorTarget);
-                    }
-                }
-
-                if (depthTarget.IsValid()) {
-                    passBuilder.WriteDepthTexture(depthTarget);
-                }
-                if (ScenePhaseSamplesMainDirectionalShadow(scenePhase) &&
-                    mainDirectionalShadowTexture.IsValid()) {
-                    passBuilder.ReadTexture(mainDirectionalShadowTexture);
-                }
-
-                passBuilder.SetExecuteCallback(
-                    [this,
-                     surfaceTemplate,
-                     renderContext,
-                     sceneData,
-                     hasSourceSurface,
-                     sourceSurface,
-                     sourceColorView,
-                     sourceColorState,
-                     executionSucceeded,
-                     beginRecordedPass,
-                     endRecordedPass,
-                     clearAttachments,
-                     scenePhase](
-                        const RenderGraphExecutionContext&) {
-                        if (executionSucceeded != nullptr && !(*executionSucceeded)) {
-                            return;
-                        }
-
-                        const FrameExecutionContext executionContext(
-                            renderContext,
-                            surfaceTemplate,
-                            *sceneData,
-                            hasSourceSurface ? &sourceSurface : nullptr,
-                            sourceColorView,
-                            sourceColorState);
-                        const RenderPassContext passContext =
-                            BuildRenderPassContext(executionContext);
-                        if (!beginRecordedPass(passContext, clearAttachments)) {
-                            return;
-                        }
-
-                        const ScenePhaseExecutionContext scenePhaseExecutionContext =
-                            BuildScenePhaseExecutionContext(executionContext, scenePhase);
-                        const bool renderResult =
-                            ExecuteBuiltinScenePhase(scenePhaseExecutionContext);
-                        endRecordedPass(passContext);
-                        if (executionSucceeded != nullptr) {
-                            *executionSucceeded = renderResult;
-                        }
-                    });
-            });
+            renderContext,
+            *sceneData,
+            surfaceTemplate,
+            hasSourceSurface ? &sourceSurface : nullptr,
+            sourceColorView,
+            sourceColorState,
+            {},
+            colorTargets,
+            depthTarget,
+            executionSucceeded,
+            beginPhasePass,
+            endRecordedPass,
+            context.blackboard
+        };
+        if (!::XCEngine::Rendering::Internal::RecordCallbackRasterRenderPass(
+                phaseContext,
+                {
+                    false,
+                    true,
+                    depthTarget.IsValid()
+                },
+                [this, scenePhase = step.scenePhase](const RenderPassContext& passContext) {
+                    const FrameExecutionContext executionContext(
+                        passContext.renderContext,
+                        passContext.surface,
+                        passContext.sceneData,
+                        passContext.sourceSurface,
+                        passContext.sourceColorView,
+                        passContext.sourceColorState);
+                    const ScenePhaseExecutionContext scenePhaseExecutionContext =
+                        BuildScenePhaseExecutionContext(executionContext, scenePhase);
+                    return ExecuteBuiltinScenePhase(scenePhaseExecutionContext);
+                },
+                additionalReadTextures)) {
+            return false;
+        }
         clearAttachments = false;
     }