diff --git a/editor/src/Viewport/ViewportHostService.h b/editor/src/Viewport/ViewportHostService.h
index 56815a61..78facc9b 100644
--- a/editor/src/Viewport/ViewportHostService.h
+++ b/editor/src/Viewport/ViewportHostService.h
@@ -529,6 +529,177 @@ private:
         return surface;
     }
 
+    void AddSceneSelectionMaskPass(
+        ViewportEntry& entry,
+        const Rendering::RenderSurface& selectionMaskSurface,
+        const Rendering::RenderCameraData& cameraData,
+        const std::vector<Rendering::VisibleRenderItem>& selectionRenderables,
+        Rendering::RenderPassSequence& outPostPasses) {
+        outPostPasses.AddPass(MakeLambdaRenderPass(
+            "SceneSelectionMask",
+            [this, &entry, selectionMaskSurface, &cameraData, &selectionRenderables](
+                const Rendering::RenderPassContext& context) mutable {
+                context.renderContext.commandList->TransitionBarrier(
+                    entry.selectionMaskView,
+                    entry.selectionMaskState,
+                    RHI::ResourceStates::RenderTarget);
+                entry.selectionMaskState = RHI::ResourceStates::RenderTarget;
+
+                const float maskClearColor[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
+                RHI::RHIResourceView* maskView = entry.selectionMaskView;
+                context.renderContext.commandList->SetRenderTargets(1, &maskView, entry.depthView);
+                context.renderContext.commandList->ClearRenderTarget(maskView, maskClearColor);
+
+                const bool rendered = m_sceneSelectionMaskPass.Render(
+                    context.renderContext,
+                    selectionMaskSurface,
+                    cameraData,
+                    selectionRenderables);
+                if (!rendered) {
+                    SetViewportStatusIfEmpty(entry.statusText, "Scene selection mask pass failed");
+                }
+
+                context.renderContext.commandList->TransitionBarrier(
+                    entry.selectionMaskView,
+                    entry.selectionMaskState,
+                    RHI::ResourceStates::PixelShaderResource);
+                entry.selectionMaskState = RHI::ResourceStates::PixelShaderResource;
+                return rendered;
+            }));
+    }
+
+    void AddSceneColorToRenderTargetPass(
+        ViewportEntry& entry,
+        Rendering::RenderPassSequence& outPostPasses) {
+        outPostPasses.AddPass(MakeLambdaRenderPass(
+            "SceneColorToRenderTarget",
+            [&entry](const Rendering::RenderPassContext& context) {
+                context.renderContext.commandList->TransitionBarrier(
+                    entry.colorView,
+                    context.surface.GetColorStateAfter(),
+                    RHI::ResourceStates::RenderTarget);
+                entry.colorState = RHI::ResourceStates::RenderTarget;
+                return true;
+            }));
+    }
+
+    void AddSceneInfiniteGridPass(
+        ViewportEntry& entry,
+        const SceneViewportOverlayData& overlay,
+        Rendering::RenderPassSequence& outPostPasses) {
+        outPostPasses.AddPass(MakeLambdaRenderPass(
+            "SceneInfiniteGrid",
+            [this, overlay, &entry](const Rendering::RenderPassContext& context) {
+                const bool rendered = m_sceneGridPass.Render(
+                    context.renderContext,
+                    context.surface,
+                    overlay);
+                if (!rendered) {
+                    SetViewportStatusIfEmpty(entry.statusText, "Scene grid pass failed");
+                }
+                return rendered;
+            }));
+    }
+
+    void AddSceneSelectionOutlinePass(
+        ViewportEntry& entry,
+        Rendering::RenderPassSequence& outPostPasses) {
+        outPostPasses.AddPass(MakeLambdaRenderPass(
+            "SceneSelectionOutline",
+            [this, &entry](const Rendering::RenderPassContext& context) {
+                const bool rendered = m_sceneSelectionOutlinePass.Render(
+                    context.renderContext,
+                    context.surface,
+                    entry.selectionMaskShaderView);
+                if (!rendered) {
+                    SetViewportStatusIfEmpty(entry.statusText, "Scene selection outline pass failed");
+                }
+                return rendered;
+            }));
+    }
+
+    void AddSceneColorToShaderResourcePass(
+        ViewportEntry& entry,
+        Rendering::RenderPassSequence& outPostPasses) {
+        outPostPasses.AddPass(MakeLambdaRenderPass(
+            "SceneColorToShaderResource",
+            [&entry](const Rendering::RenderPassContext& context) {
+                context.renderContext.commandList->TransitionBarrier(
+                    entry.colorView,
+                    RHI::ResourceStates::RenderTarget,
+                    context.surface.GetColorStateAfter());
+                entry.colorState = context.surface.GetColorStateAfter();
+                return true;
+            }));
+    }
+
+    void AddSceneSelectionMaskDebugPass(
+        ViewportEntry& entry,
+        const Rendering::RenderCameraData& cameraData,
+        const std::vector<Rendering::VisibleRenderItem>& selectionRenderables,
+        Rendering::RenderPassSequence& outPostPasses) {
+        outPostPasses.AddPass(MakeLambdaRenderPass(
+            "SceneSelectionMaskDebug",
+            [this, &entry, &cameraData, &selectionRenderables](
+                const Rendering::RenderPassContext& context) {
+                const float debugClearColor[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
+                RHI::RHIResourceView* colorView = entry.colorView;
+                context.renderContext.commandList->SetRenderTargets(1, &colorView, entry.depthView);
+                context.renderContext.commandList->ClearRenderTarget(colorView, debugClearColor);
+
+                const bool rendered = m_sceneSelectionMaskPass.Render(
+                    context.renderContext,
+                    context.surface,
+                    cameraData,
+                    selectionRenderables);
+                if (!rendered) {
+                    SetViewportStatusIfEmpty(entry.statusText, "Scene selection mask debug pass failed");
+                }
+                return rendered;
+            }));
+    }
+
+    void AddSceneViewPostPassStep(
+        SceneViewportPostPassStep step,
+        ViewportEntry& entry,
+        const SceneViewportOverlayData& overlay,
+        const Rendering::RenderSurface& selectionMaskSurface,
+        const Rendering::RenderCameraData& cameraData,
+        const std::vector<Rendering::VisibleRenderItem>& selectionRenderables,
+        Rendering::RenderPassSequence& outPostPasses) {
+        switch (step) {
+        case SceneViewportPostPassStep::SelectionMask:
+            AddSceneSelectionMaskPass(
+                entry,
+                selectionMaskSurface,
+                cameraData,
+                selectionRenderables,
+                outPostPasses);
+            break;
+        case SceneViewportPostPassStep::ColorToRenderTarget:
+            AddSceneColorToRenderTargetPass(entry, outPostPasses);
+            break;
+        case SceneViewportPostPassStep::InfiniteGrid:
+            AddSceneInfiniteGridPass(entry, overlay, outPostPasses);
+            break;
+        case SceneViewportPostPassStep::SelectionOutline:
+            AddSceneSelectionOutlinePass(entry, outPostPasses);
+            break;
+        case SceneViewportPostPassStep::ColorToShaderResource:
+            AddSceneColorToShaderResourcePass(entry, outPostPasses);
+            break;
+        case SceneViewportPostPassStep::SelectionMaskDebug:
+            AddSceneSelectionMaskDebugPass(
+                entry,
+                cameraData,
+                selectionRenderables,
+                outPostPasses);
+            break;
+        default:
+            break;
+        }
+    }
+
     bool BuildSceneViewPostPassSequence(
         ViewportEntry& entry,
         const SceneViewportOverlayData& overlay,
@@ -562,116 +733,14 @@ private:
         }
 
         for (const SceneViewportPostPassStep step : plan.steps) {
-            switch (step) {
-            case SceneViewportPostPassStep::SelectionMask:
-                outPostPasses.AddPass(MakeLambdaRenderPass(
-                    "SceneSelectionMask",
-                    [this, &entry, selectionMaskSurface, &cameraData, &selectionRenderables](
-                        const Rendering::RenderPassContext& context) mutable {
-                        context.renderContext.commandList->TransitionBarrier(
-                            entry.selectionMaskView,
-                            entry.selectionMaskState,
-                            RHI::ResourceStates::RenderTarget);
-                        entry.selectionMaskState = RHI::ResourceStates::RenderTarget;
-
-                        const float maskClearColor[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
-                        RHI::RHIResourceView* maskView = entry.selectionMaskView;
-                        context.renderContext.commandList->SetRenderTargets(1, &maskView, entry.depthView);
-                        context.renderContext.commandList->ClearRenderTarget(maskView, maskClearColor);
-
-                        const bool rendered = m_sceneSelectionMaskPass.Render(
-                            context.renderContext,
-                            selectionMaskSurface,
-                            cameraData,
-                            selectionRenderables);
-                        if (!rendered) {
-                            SetViewportStatusIfEmpty(entry.statusText, "Scene selection mask pass failed");
-                        }
-
-                        context.renderContext.commandList->TransitionBarrier(
-                            entry.selectionMaskView,
-                            entry.selectionMaskState,
-                            RHI::ResourceStates::PixelShaderResource);
-                        entry.selectionMaskState = RHI::ResourceStates::PixelShaderResource;
-                        return rendered;
-                    }));
-                break;
-            case SceneViewportPostPassStep::ColorToRenderTarget:
-                outPostPasses.AddPass(MakeLambdaRenderPass(
-                    "SceneColorToRenderTarget",
-                    [&entry](const Rendering::RenderPassContext& context) {
-                        context.renderContext.commandList->TransitionBarrier(
-                            entry.colorView,
-                            context.surface.GetColorStateAfter(),
-                            RHI::ResourceStates::RenderTarget);
-                        entry.colorState = RHI::ResourceStates::RenderTarget;
-                        return true;
-                    }));
-                break;
-            case SceneViewportPostPassStep::InfiniteGrid:
-                outPostPasses.AddPass(MakeLambdaRenderPass(
-                    "SceneInfiniteGrid",
-                    [this, overlay, &entry](const Rendering::RenderPassContext& context) {
-                        const bool rendered = m_sceneGridPass.Render(
-                            context.renderContext,
-                            context.surface,
-                            overlay);
-                        if (!rendered) {
-                            SetViewportStatusIfEmpty(entry.statusText, "Scene grid pass failed");
-                        }
-                        return rendered;
-                    }));
-                break;
-            case SceneViewportPostPassStep::SelectionOutline:
-                outPostPasses.AddPass(MakeLambdaRenderPass(
-                    "SceneSelectionOutline",
-                    [this, &entry](const Rendering::RenderPassContext& context) {
-                        const bool rendered = m_sceneSelectionOutlinePass.Render(
-                            context.renderContext,
-                            context.surface,
-                            entry.selectionMaskShaderView);
-                        if (!rendered) {
-                            SetViewportStatusIfEmpty(entry.statusText, "Scene selection outline pass failed");
-                        }
-                        return rendered;
-                    }));
-                break;
-            case SceneViewportPostPassStep::ColorToShaderResource:
-                outPostPasses.AddPass(MakeLambdaRenderPass(
-                    "SceneColorToShaderResource",
-                    [&entry](const Rendering::RenderPassContext& context) {
-                        context.renderContext.commandList->TransitionBarrier(
-                            entry.colorView,
-                            RHI::ResourceStates::RenderTarget,
-                            context.surface.GetColorStateAfter());
-                        entry.colorState = context.surface.GetColorStateAfter();
-                        return true;
-                    }));
-                break;
-            case SceneViewportPostPassStep::SelectionMaskDebug:
-                outPostPasses.AddPass(MakeLambdaRenderPass(
-                    "SceneSelectionMaskDebug",
-                    [this, &entry, &cameraData, &selectionRenderables](
-                        const Rendering::RenderPassContext& context) {
-                        const float debugClearColor[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
-                        RHI::RHIResourceView* colorView = entry.colorView;
-                        context.renderContext.commandList->SetRenderTargets(1, &colorView, entry.depthView);
-                        context.renderContext.commandList->ClearRenderTarget(colorView, debugClearColor);
-
-                        const bool rendered = m_sceneSelectionMaskPass.Render(
-                            context.renderContext,
-                            context.surface,
-                            cameraData,
-                            selectionRenderables);
-                        if (!rendered) {
-                            SetViewportStatusIfEmpty(entry.statusText, "Scene selection mask debug pass failed");
-                        }
-                        return rendered;
-                    }));
-                break;
-            default:
-                break;
-            }
+            AddSceneViewPostPassStep(
+                step,
+                entry,
+                overlay,
+                selectionMaskSurface,
+                cameraData,
+                selectionRenderables,
+                outPostPasses);
         }
 
         return true;