diff --git a/docs/used/SRP_NativeSceneDrawSubstrateRefactorPlan_2026-04-21_完成归档.md b/docs/used/SRP_NativeSceneDrawSubstrateRefactorPlan_2026-04-21_完成归档.md
new file mode 100644
index 00000000..423b248f
--- /dev/null
+++ b/docs/used/SRP_NativeSceneDrawSubstrateRefactorPlan_2026-04-21_完成归档.md
@@ -0,0 +1,84 @@
+# SRP Native Scene Draw Substrate Refactor Plan
+
+日期：2026-04-21
+
+## 背景
+
+当前 managed SRP/URP 侧已经基本使用 `ScriptableRenderContext.DrawRenderers(...)`、`RecordScenePhase(...)`、`RecordSceneInjectionPoint(...)` 这套抽象驱动场景绘制，方向是对的。
+
+但 native 桥接层仍然把这套能力挂在 `NativeSceneRenderer` 上，接口命名和职责仍然带有明显的“内建 forward pipeline 执行器”语义：
+
+- `Initialize`
+- `PrepareScene`
+- `BeginScenePass`
+- `EndScenePass`
+- `ExecuteScenePhase`
+- `ExecuteSceneDrawSettings`
+
+这会导致两个问题：
+
+1. managed SRP 表面上已经在驱动 renderer/passes，但底层依然像是在偷偷调用一个 builtin pipeline。
+2. 后续要继续按 Unity 的 SRP + URP 路线推进时，native 侧缺少一个稳定的“场景绘制 substrate”概念，URP 很容易继续耦合到 builtin forward 的实现细节。
+
+## 本阶段目标
+
+在不改动现有渲染行为的前提下，把 native scene recording 依赖的底层 contract 明确为“scene draw substrate”，而不是“scene renderer / hidden pipeline”：
+
+- 把接口命名调整为更贴近底层 scene draw substrate 的语义
+- 让 `NativeSceneRecorder` 明确依赖 scene draw substrate，而不是 pipeline 名义对象
+- 同步清理 `MonoScriptRuntime` 与 `RenderPipelineFactory` 上的调用链命名
+- 保持现有 managed SRP / URP 录制路径、RenderGraph 行为与 editor 运行结果不变
+
+## 为什么现在做
+
+现在继续往前堆 renderer、deferred、shadow 拆分都不是优先级最高的事。
+
+如果 scene draw substrate 这一层不先收干净，后面做：
+
+- 多 renderer 支持
+- URP renderer data / renderer instance
+- C# 自定义 scene pass
+- 更完整的 RenderGraph ownership
+
+都会继续建立在一个命名混乱、职责暧昧的 native bridge 上，之后再返工代价更高。
+
+## 重构范围
+
+本阶段只处理 C++ native scene draw substrate 的 contract 收口，不扩功能，不改 editor，不碰 new_editor，不处理 deferred。
+
+涉及方向：
+
+- `engine/include/XCEngine/Rendering/NativeSceneRenderer.h`
+- `engine/include/XCEngine/Rendering/Pipelines/NativeSceneRecorder.h`
+- `engine/include/XCEngine/Rendering/Pipelines/BuiltinForwardPipeline.h`
+- `engine/src/Rendering/Pipelines/NativeSceneRecorder.cpp`
+- `engine/src/Rendering/Internal/RenderPipelineFactory.*`
+- `engine/src/Scripting/Mono/MonoScriptRuntime.cpp`
+
+## 预期结果
+
+重构后，native 侧应该表达成下面这个结构：
+
+- managed `ScriptableRenderer` 负责决定何时画什么
+- `ScriptableRenderContext` 负责把 managed 请求传到 native
+- `NativeSceneRecorder` 负责把这些请求录进 RenderGraph
+- native scene draw substrate 负责执行稳定的场景绘制原语
+- `BuiltinForwardPipeline` 只是当前默认的一种 native scene draw substrate 实现
+
+## 实施步骤
+
+1. 重命名并收窄 native scene draw contract，去掉 `NativeSceneRenderer` 的误导性语义。
+2. 清理 `NativeSceneRecorder` 内部调用与错误信息，使其围绕 scene draw substrate 组织。
+3. 清理 `MonoScriptRuntime` 中 scene renderer 的解析和持有逻辑命名。
+4. 清理 `RenderPipelineFactory` 中相关工厂命名，让默认 builtin forward 只表现为默认 substrate 实现。
+5. 编译 `XCEditor` 并运行旧版 editor 冒烟，确认 `SceneReady`。
+6. 归档本计划，提交并推送。
+
+## 验证标准
+
+- `cmake --build . --config Debug --target XCEditor` 成功
+- 运行 `editor/bin/Debug/XCEngine.exe`
+- 冒烟至少 10 秒
+- `editor/bin/Debug/editor.log` 出现新的 `SceneReady`
+- 本阶段仅包含 SRP/rendering 相关代码与本计划文档
+
diff --git a/engine/CMakeLists.txt b/engine/CMakeLists.txt
index 963917d0..7fee873d 100644
--- a/engine/CMakeLists.txt
+++ b/engine/CMakeLists.txt
@@ -544,6 +544,7 @@ add_library(XCEngine STATIC
     ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Internal/RenderSurfacePipelineUtils.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Internal/ShaderVariantUtils.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Execution/RenderPipelineHost.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Execution/SceneRenderSequence.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Caches/RenderResourceCache.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Caches/DirectionalShadowSurfaceCache.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Shadow/DirectionalShadowData.h
@@ -557,6 +558,7 @@ add_library(XCEngine STATIC
     ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Features/BuiltinGaussianSplatPass.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Features/BuiltinVolumetricPass.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/GraphicsSettingsState.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/SceneDrawBackend.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Pipelines/BuiltinForwardPipeline.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Pipelines/NativeSceneRecorder.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h
@@ -564,6 +566,7 @@ add_library(XCEngine STATIC
     ${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/Execution/CameraFramePlan.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/Execution/CameraRenderer.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/Execution/RenderPipelineHost.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/Execution/SceneRenderSequence.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/Execution/Internal/CameraFrameGraph/Executor.h
     ${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/Execution/Internal/CameraFrameGraph/Executor.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/Execution/Internal/CameraFrameGraph/BuilderContext.h
diff --git a/engine/include/XCEngine/Rendering/Execution/SceneRenderSequence.h b/engine/include/XCEngine/Rendering/Execution/SceneRenderSequence.h
new file mode 100644
index 00000000..74828570
--- /dev/null
+++ b/engine/include/XCEngine/Rendering/Execution/SceneRenderSequence.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <XCEngine/Core/Types.h>
+#include <XCEngine/Rendering/Execution/ScenePhase.h>
+#include <XCEngine/Rendering/Execution/SceneRenderInjectionPoint.h>
+
+#include <array>
+
+namespace XCEngine {
+namespace Rendering {
+
+enum class SceneRenderStepType : Core::uint8 {
+    InjectionPoint,
+    ScenePhase
+};
+
+struct SceneRenderStep {
+    SceneRenderStepType type = SceneRenderStepType::ScenePhase;
+    SceneRenderInjectionPoint injectionPoint =
+        SceneRenderInjectionPoint::BeforeOpaque;
+    ScenePhase scenePhase = ScenePhase::Opaque;
+};
+
+const std::array<SceneRenderStep, 9>&
+GetDefaultSceneRenderSequence();
+
+} // namespace Rendering
+} // namespace XCEngine
diff --git a/engine/include/XCEngine/Rendering/Pipelines/BuiltinForwardPipeline.h b/engine/include/XCEngine/Rendering/Pipelines/BuiltinForwardPipeline.h
index 27447632..e79981a5 100644
--- a/engine/include/XCEngine/Rendering/Pipelines/BuiltinForwardPipeline.h
+++ b/engine/include/XCEngine/Rendering/Pipelines/BuiltinForwardPipeline.h
@@ -5,10 +5,10 @@
 #include <XCEngine/Rendering/Builtin/BuiltinPassTypes.h>
 #include <XCEngine/Rendering/Materials/RenderMaterialResolve.h>
 #include <XCEngine/Rendering/Materials/RenderMaterialStateUtils.h>
-#include <XCEngine/Rendering/NativeSceneRenderer.h>
 #include <XCEngine/Rendering/RenderPass.h>
 #include <XCEngine/Rendering/RenderPipeline.h>
 #include <XCEngine/Rendering/RenderPipelineAsset.h>
+#include <XCEngine/Rendering/SceneDrawBackend.h>
 #include <XCEngine/Rendering/SceneRenderFeatureHost.h>
 #include <XCEngine/Rendering/Caches/RenderResourceCache.h>
 
@@ -47,7 +47,7 @@ struct BuiltinForwardStageGraphBuilder;
 
 namespace Pipelines {
 
-class BuiltinForwardPipeline : public RenderPipeline, public NativeSceneRenderer {
+class BuiltinForwardPipeline : public RenderPipeline, public SceneDrawBackend {
 public:
     BuiltinForwardPipeline();
     ~BuiltinForwardPipeline() override;
@@ -61,16 +61,16 @@ public:
     SceneRenderFeaturePass* GetForwardSceneFeaturePass(size_t index) const;
 
     bool Initialize(const RenderContext& context) override;
-    bool PrepareScene(const FrameExecutionContext& executionContext) override;
-    SceneRenderFeatureHost* GetFeatureHost() override;
-    bool BeginScenePass(
+    bool PrepareSceneDraw(const FrameExecutionContext& executionContext) override;
+    SceneRenderFeatureHost* GetSceneFeatureHost() override;
+    bool BeginSceneDrawPass(
         const RenderPassContext& context,
         bool clearAttachments = true) override;
-    void EndScenePass(const RenderPassContext& context) override;
-    bool ExecuteScenePhase(
+    void EndSceneDrawPass(const RenderPassContext& context) override;
+    bool DrawScenePhase(
         const RenderPassContext& context,
         ScenePhase scenePhase) override;
-    bool ExecuteSceneDrawSettings(
+    bool DrawSceneRenderers(
         const RenderPassContext& context,
         const DrawSettings& drawSettings) override;
     void Shutdown() override;
diff --git a/engine/include/XCEngine/Rendering/Pipelines/NativeSceneRecorder.h b/engine/include/XCEngine/Rendering/Pipelines/NativeSceneRecorder.h
index a9c9f2ce..6f026bf1 100644
--- a/engine/include/XCEngine/Rendering/Pipelines/NativeSceneRecorder.h
+++ b/engine/include/XCEngine/Rendering/Pipelines/NativeSceneRecorder.h
@@ -4,8 +4,8 @@
 #include <XCEngine/Rendering/Execution/ScenePhase.h>
 #include <XCEngine/Rendering/Execution/SceneRenderInjectionPoint.h>
 #include <XCEngine/Rendering/Graph/RenderGraphTypes.h>
-#include <XCEngine/Rendering/NativeSceneRenderer.h>
 #include <XCEngine/Rendering/RenderSurface.h>
+#include <XCEngine/Rendering/SceneDrawBackend.h>
 #include <XCEngine/Rendering/SceneRenderFeaturePass.h>
 
 #include <memory>
@@ -22,7 +22,7 @@ struct NativeSceneRecorderState;
 class NativeSceneRecorder {
 public:
     NativeSceneRecorder(
-        NativeSceneRenderer& sceneRenderer,
+        SceneDrawBackend& sceneDrawBackend,
         const RenderPipelineStageRenderGraphContext& context);
     ~NativeSceneRecorder();
 
@@ -38,7 +38,7 @@ private:
     SceneRenderFeaturePassEndCallback BuildEndRecordedPassCallback() const;
     RenderPipelineStageRenderGraphContext BuildGraphContext() const;
 
-    NativeSceneRenderer& m_sceneRenderer;
+    SceneDrawBackend& m_sceneDrawBackend;
     const RenderPipelineStageRenderGraphContext& m_context;
     RenderSurface m_graphManagedSurface = {};
     RenderGraphTextureHandle m_mainDirectionalShadowTexture = {};
diff --git a/engine/include/XCEngine/Rendering/NativeSceneRenderer.h b/engine/include/XCEngine/Rendering/SceneDrawBackend.h
similarity index 62%
rename from engine/include/XCEngine/Rendering/NativeSceneRenderer.h
rename to engine/include/XCEngine/Rendering/SceneDrawBackend.h
index 3573ee96..395ec30a 100644
--- a/engine/include/XCEngine/Rendering/NativeSceneRenderer.h
+++ b/engine/include/XCEngine/Rendering/SceneDrawBackend.h
@@ -8,22 +8,24 @@
 namespace XCEngine {
 namespace Rendering {
 
-class NativeSceneRenderer {
+class SceneDrawBackend {
 public:
-    virtual ~NativeSceneRenderer() = default;
+    virtual ~SceneDrawBackend() = default;
 
     virtual bool Initialize(const RenderContext& context) = 0;
     virtual void Shutdown() = 0;
-    virtual bool PrepareScene(const FrameExecutionContext& executionContext) = 0;
-    virtual SceneRenderFeatureHost* GetFeatureHost() = 0;
-    virtual bool BeginScenePass(
+    virtual bool PrepareSceneDraw(
+        const FrameExecutionContext& executionContext) = 0;
+    virtual SceneRenderFeatureHost* GetSceneFeatureHost() = 0;
+    virtual bool BeginSceneDrawPass(
         const RenderPassContext& context,
         bool clearAttachments = true) = 0;
-    virtual void EndScenePass(const RenderPassContext& context) = 0;
-    virtual bool ExecuteScenePhase(
+    virtual void EndSceneDrawPass(
+        const RenderPassContext& context) = 0;
+    virtual bool DrawScenePhase(
         const RenderPassContext& context,
         ScenePhase scenePhase) = 0;
-    virtual bool ExecuteSceneDrawSettings(
+    virtual bool DrawSceneRenderers(
         const RenderPassContext& context,
         const DrawSettings& drawSettings) = 0;
 };
diff --git a/engine/src/Rendering/Execution/SceneRenderSequence.cpp b/engine/src/Rendering/Execution/SceneRenderSequence.cpp
new file mode 100644
index 00000000..d497c8f7
--- /dev/null
+++ b/engine/src/Rendering/Execution/SceneRenderSequence.cpp
@@ -0,0 +1,49 @@
+#include <XCEngine/Rendering/Execution/SceneRenderSequence.h>
+
+namespace XCEngine {
+namespace Rendering {
+namespace {
+
+constexpr SceneRenderStep MakeInjectionPointStep(
+    SceneRenderInjectionPoint injectionPoint) {
+    SceneRenderStep step = {};
+    step.type = SceneRenderStepType::InjectionPoint;
+    step.injectionPoint = injectionPoint;
+    return step;
+}
+
+constexpr SceneRenderStep MakeScenePhaseStep(
+    ScenePhase scenePhase) {
+    SceneRenderStep step = {};
+    step.type = SceneRenderStepType::ScenePhase;
+    step.scenePhase = scenePhase;
+    return step;
+}
+
+} // namespace
+
+const std::array<SceneRenderStep, 9>&
+GetDefaultSceneRenderSequence() {
+    static constexpr std::array<SceneRenderStep, 9>
+        kDefaultSceneRenderSequence = {
+            MakeInjectionPointStep(
+                SceneRenderInjectionPoint::BeforeOpaque),
+            MakeScenePhaseStep(ScenePhase::Opaque),
+            MakeInjectionPointStep(
+                SceneRenderInjectionPoint::AfterOpaque),
+            MakeInjectionPointStep(
+                SceneRenderInjectionPoint::BeforeSkybox),
+            MakeScenePhaseStep(ScenePhase::Skybox),
+            MakeInjectionPointStep(
+                SceneRenderInjectionPoint::AfterSkybox),
+            MakeInjectionPointStep(
+                SceneRenderInjectionPoint::BeforeTransparent),
+            MakeScenePhaseStep(ScenePhase::Transparent),
+            MakeInjectionPointStep(
+                SceneRenderInjectionPoint::AfterTransparent)
+        };
+    return kDefaultSceneRenderSequence;
+}
+
+} // namespace Rendering
+} // namespace XCEngine
diff --git a/engine/src/Rendering/Internal/RenderPipelineFactory.cpp b/engine/src/Rendering/Internal/RenderPipelineFactory.cpp
index 1f61a2f6..3c51b0b1 100644
--- a/engine/src/Rendering/Internal/RenderPipelineFactory.cpp
+++ b/engine/src/Rendering/Internal/RenderPipelineFactory.cpp
@@ -190,7 +190,7 @@ void EnsureBuiltinDirectionalShadowExecutionPolicyRegistryInitialized() {
     (void)initialized;
 }
 
-std::unique_ptr<NativeSceneRenderer> TryCreateNativeSceneRendererFromAsset(
+std::unique_ptr<SceneDrawBackend> TryCreateSceneDrawBackendFromAsset(
     const std::shared_ptr<const RenderPipelineAsset>& asset) {
     if (asset == nullptr) {
         return nullptr;
@@ -201,14 +201,14 @@ std::unique_ptr<NativeSceneRenderer> TryCreateNativeSceneRendererFromAsset(
         return nullptr;
     }
 
-    NativeSceneRenderer* const sceneRenderer =
-        dynamic_cast<NativeSceneRenderer*>(pipeline.get());
-    if (sceneRenderer == nullptr) {
+    SceneDrawBackend* const sceneDrawBackend =
+        dynamic_cast<SceneDrawBackend*>(pipeline.get());
+    if (sceneDrawBackend == nullptr) {
         return nullptr;
     }
 
     (void)pipeline.release();
-    return std::unique_ptr<NativeSceneRenderer>(sceneRenderer);
+    return std::unique_ptr<SceneDrawBackend>(sceneDrawBackend);
 }
 
 } // namespace
@@ -549,24 +549,24 @@ std::unique_ptr<RenderPipeline> CreateRenderPipelineOrDefault(
     return std::make_unique<Pipelines::ScriptableRenderPipelineHost>();
 }
 
-std::unique_ptr<NativeSceneRenderer> CreateNativeSceneRendererFromAsset(
+std::unique_ptr<SceneDrawBackend> CreateSceneDrawBackendFromAsset(
     const std::shared_ptr<const RenderPipelineAsset>& preferredAsset,
     std::shared_ptr<const RenderPipelineAsset>* outResolvedAsset) {
-    if (std::unique_ptr<NativeSceneRenderer> sceneRenderer =
-            TryCreateNativeSceneRendererFromAsset(preferredAsset)) {
+    if (std::unique_ptr<SceneDrawBackend> sceneDrawBackend =
+            TryCreateSceneDrawBackendFromAsset(preferredAsset)) {
         if (outResolvedAsset != nullptr) {
             *outResolvedAsset = preferredAsset;
         }
-        return sceneRenderer;
+        return sceneDrawBackend;
     }
 
     if (outResolvedAsset != nullptr) {
         outResolvedAsset->reset();
     }
-    return CreateDefaultNativeSceneRenderer();
+    return CreateDefaultSceneDrawBackend();
 }
 
-std::unique_ptr<NativeSceneRenderer> CreateDefaultNativeSceneRenderer() {
+std::unique_ptr<SceneDrawBackend> CreateDefaultSceneDrawBackend() {
     return std::make_unique<Pipelines::BuiltinForwardPipeline>();
 }
 
diff --git a/engine/src/Rendering/Internal/RenderPipelineFactory.h b/engine/src/Rendering/Internal/RenderPipelineFactory.h
index ab657fd2..4ca21ab6 100644
--- a/engine/src/Rendering/Internal/RenderPipelineFactory.h
+++ b/engine/src/Rendering/Internal/RenderPipelineFactory.h
@@ -7,7 +7,7 @@
 namespace XCEngine {
 namespace Rendering {
 
-class NativeSceneRenderer;
+class SceneDrawBackend;
 class RenderPipeline;
 class RenderPipelineAsset;
 class RenderPass;
@@ -74,10 +74,10 @@ std::shared_ptr<const RenderPipelineAsset> ResolveRenderPipelineAssetOrDefault(
 std::unique_ptr<RenderPipeline> CreateRenderPipelineOrDefault(
     const std::shared_ptr<const RenderPipelineAsset>& preferredAsset,
     std::shared_ptr<const RenderPipelineAsset>* outResolvedAsset = nullptr);
-std::unique_ptr<NativeSceneRenderer> CreateNativeSceneRendererFromAsset(
+std::unique_ptr<SceneDrawBackend> CreateSceneDrawBackendFromAsset(
     const std::shared_ptr<const RenderPipelineAsset>& preferredAsset,
     std::shared_ptr<const RenderPipelineAsset>* outResolvedAsset = nullptr);
-std::unique_ptr<NativeSceneRenderer> CreateDefaultNativeSceneRenderer();
+std::unique_ptr<SceneDrawBackend> CreateDefaultSceneDrawBackend();
 
 } // namespace Internal
 } // namespace Rendering
diff --git a/engine/src/Rendering/Pipelines/Internal/BuiltinForwardPipelineFrame.cpp b/engine/src/Rendering/Pipelines/Internal/BuiltinForwardPipelineFrame.cpp
index 61d5bfb4..66638491 100644
--- a/engine/src/Rendering/Pipelines/Internal/BuiltinForwardPipelineFrame.cpp
+++ b/engine/src/Rendering/Pipelines/Internal/BuiltinForwardPipelineFrame.cpp
@@ -59,12 +59,12 @@ bool BuiltinForwardPipeline::ShouldSampleMainDirectionalShadowMap(const RenderSc
         IsDepthFormat(sceneData.lighting.mainDirectionalShadow.shadowMap->GetFormat());
 }
 
-bool BuiltinForwardPipeline::PrepareScene(
+bool BuiltinForwardPipeline::PrepareSceneDraw(
     const FrameExecutionContext& executionContext) {
     return m_forwardSceneFeatureHost.Prepare(executionContext);
 }
 
-SceneRenderFeatureHost* BuiltinForwardPipeline::GetFeatureHost() {
+SceneRenderFeatureHost* BuiltinForwardPipeline::GetSceneFeatureHost() {
     return &m_forwardSceneFeatureHost;
 }
 
@@ -94,19 +94,19 @@ bool BuiltinForwardPipeline::ExecuteForwardSceneFrame(
         return false;
     }
 
-    if (!PrepareScene(executionContext)) {
+    if (!PrepareSceneDraw(executionContext)) {
         Debug::Logger::Get().Error(
             Debug::LogCategory::Rendering,
-            "BuiltinForwardPipeline::Render failed: PrepareScene returned false");
+            "BuiltinForwardPipeline::Render failed: PrepareSceneDraw returned false");
         return false;
     }
 
     const RenderPassContext passContext = BuildRenderPassContext(executionContext);
 
-    if (!BeginScenePass(passContext)) {
+    if (!BeginSceneDrawPass(passContext)) {
         Debug::Logger::Get().Error(
             Debug::LogCategory::Rendering,
-            "BuiltinForwardPipeline::Render failed: BeginScenePass returned false");
+            "BuiltinForwardPipeline::Render failed: BeginSceneDrawPass returned false");
         return false;
     }
 
@@ -126,12 +126,12 @@ bool BuiltinForwardPipeline::ExecuteForwardSceneFrame(
             executionContext.renderContext,
             executionContext.sceneData);
     }
-    EndScenePass(passContext);
+    EndSceneDrawPass(passContext);
 
     return renderResult;
 }
 
-bool BuiltinForwardPipeline::BeginScenePass(
+bool BuiltinForwardPipeline::BeginSceneDrawPass(
     const RenderPassContext& context,
     bool clearAttachments) {
     return BeginForwardScenePass(
@@ -232,7 +232,7 @@ bool BuiltinForwardPipeline::Render(
     return Render(FrameExecutionContext(context, surface, sceneData));
 }
 
-void BuiltinForwardPipeline::EndScenePass(const RenderPassContext& passContext) {
+void BuiltinForwardPipeline::EndSceneDrawPass(const RenderPassContext& passContext) {
     EndForwardScenePass(passContext);
 }
 
diff --git a/engine/src/Rendering/Pipelines/Internal/BuiltinForwardPipelineScenePhases.cpp b/engine/src/Rendering/Pipelines/Internal/BuiltinForwardPipelineScenePhases.cpp
index dfb5b2d6..d9224eee 100644
--- a/engine/src/Rendering/Pipelines/Internal/BuiltinForwardPipelineScenePhases.cpp
+++ b/engine/src/Rendering/Pipelines/Internal/BuiltinForwardPipelineScenePhases.cpp
@@ -1,8 +1,8 @@
 #include "Rendering/Pipelines/BuiltinForwardPipeline.h"
 
 #include "Debug/Logger.h"
+#include "Rendering/Execution/SceneRenderSequence.h"
 #include "Rendering/FrameData/RendererListUtils.h"
-#include "Rendering/Pipelines/Internal/BuiltinForwardSceneSetup.h"
 
 namespace XCEngine {
 namespace Rendering {
@@ -59,7 +59,7 @@ bool BuiltinForwardPipeline::ExecuteBuiltinScenePhase(
     }
 }
 
-bool BuiltinForwardPipeline::ExecuteScenePhase(
+bool BuiltinForwardPipeline::DrawScenePhase(
     const RenderPassContext& context,
     ScenePhase scenePhase) {
     const FrameExecutionContext executionContext(
@@ -75,7 +75,7 @@ bool BuiltinForwardPipeline::ExecuteScenePhase(
             scenePhase));
 }
 
-bool BuiltinForwardPipeline::ExecuteSceneDrawSettings(
+bool BuiltinForwardPipeline::DrawSceneRenderers(
     const RenderPassContext& context,
     const DrawSettings& drawSettings) {
     const FrameExecutionContext executionContext(
@@ -94,7 +94,7 @@ bool BuiltinForwardPipeline::ExecuteSceneDrawSettings(
     default:
         Debug::Logger::Get().Error(
             Debug::LogCategory::Rendering,
-            (Containers::String("BuiltinForwardPipeline::ExecuteSceneDrawSettings does not support scene phase: ") +
+            (Containers::String("BuiltinForwardPipeline::DrawSceneRenderers does not support scene phase: ") +
                 ToString(drawSettings.scenePhase)).CStr());
         return false;
     }
@@ -105,14 +105,14 @@ bool BuiltinForwardPipeline::ExecuteForwardScene(
     return ExecuteForwardSceneSteps(
         executionContext,
         0u,
-        Internal::GetBuiltinForwardSceneSteps().size());
+        GetDefaultSceneRenderSequence().size());
 }
 
 bool BuiltinForwardPipeline::ExecuteForwardSceneSteps(
     const FrameExecutionContext& executionContext,
     size_t beginStepIndex,
     size_t endStepIndex) {
-    const auto& steps = Internal::GetBuiltinForwardSceneSteps();
+    const auto& steps = GetDefaultSceneRenderSequence();
     if (beginStepIndex > endStepIndex ||
         endStepIndex > steps.size()) {
         Debug::Logger::Get().Error(
@@ -122,8 +122,8 @@ bool BuiltinForwardPipeline::ExecuteForwardSceneSteps(
     }
 
     for (size_t stepIndex = beginStepIndex; stepIndex < endStepIndex; ++stepIndex) {
-        const Internal::ForwardSceneStep& step = steps[stepIndex];
-        if (step.type == Internal::ForwardSceneStepType::InjectionPoint) {
+        const SceneRenderStep& step = steps[stepIndex];
+        if (step.type == SceneRenderStepType::InjectionPoint) {
             if (m_forwardSceneFeatureHost.Execute(executionContext, step.injectionPoint)) {
                 continue;
             }
diff --git a/engine/src/Rendering/Pipelines/Internal/BuiltinForwardSceneSetup.cpp b/engine/src/Rendering/Pipelines/Internal/BuiltinForwardSceneSetup.cpp
index c2a23a84..48145cbf 100644
--- a/engine/src/Rendering/Pipelines/Internal/BuiltinForwardSceneSetup.cpp
+++ b/engine/src/Rendering/Pipelines/Internal/BuiltinForwardSceneSetup.cpp
@@ -10,38 +10,6 @@ namespace XCEngine {
 namespace Rendering {
 namespace Pipelines {
 namespace Internal {
-namespace {
-
-constexpr ForwardSceneStep MakeForwardSceneInjectionStep(SceneRenderInjectionPoint injectionPoint) {
-    ForwardSceneStep step = {};
-    step.type = ForwardSceneStepType::InjectionPoint;
-    step.injectionPoint = injectionPoint;
-    return step;
-}
-
-constexpr ForwardSceneStep MakeForwardSceneBuiltinPhaseStep(ScenePhase scenePhase) {
-    ForwardSceneStep step = {};
-    step.type = ForwardSceneStepType::BuiltinPhase;
-    step.scenePhase = scenePhase;
-    return step;
-}
-
-} // namespace
-
-const std::array<ForwardSceneStep, 9>& GetBuiltinForwardSceneSteps() {
-    static constexpr std::array<ForwardSceneStep, 9> kForwardSceneSteps = {
-        MakeForwardSceneInjectionStep(SceneRenderInjectionPoint::BeforeOpaque),
-        MakeForwardSceneBuiltinPhaseStep(ScenePhase::Opaque),
-        MakeForwardSceneInjectionStep(SceneRenderInjectionPoint::AfterOpaque),
-        MakeForwardSceneInjectionStep(SceneRenderInjectionPoint::BeforeSkybox),
-        MakeForwardSceneBuiltinPhaseStep(ScenePhase::Skybox),
-        MakeForwardSceneInjectionStep(SceneRenderInjectionPoint::AfterSkybox),
-        MakeForwardSceneInjectionStep(SceneRenderInjectionPoint::BeforeTransparent),
-        MakeForwardSceneBuiltinPhaseStep(ScenePhase::Transparent),
-        MakeForwardSceneInjectionStep(SceneRenderInjectionPoint::AfterTransparent)
-    };
-    return kForwardSceneSteps;
-}
 
 void RegisterBuiltinForwardSceneFeatures(SceneRenderFeatureHost& featureHost) {
     featureHost.AddFeaturePass(std::make_unique<Features::BuiltinGaussianSplatPass>());
diff --git a/engine/src/Rendering/Pipelines/Internal/BuiltinForwardSceneSetup.h b/engine/src/Rendering/Pipelines/Internal/BuiltinForwardSceneSetup.h
index a855ce70..31e0ee04 100644
--- a/engine/src/Rendering/Pipelines/Internal/BuiltinForwardSceneSetup.h
+++ b/engine/src/Rendering/Pipelines/Internal/BuiltinForwardSceneSetup.h
@@ -1,11 +1,5 @@
 #pragma once
 
-#include <XCEngine/Core/Types.h>
-#include <XCEngine/Rendering/Execution/ScenePhase.h>
-#include <XCEngine/Rendering/Execution/SceneRenderInjectionPoint.h>
-
-#include <array>
-
 namespace XCEngine {
 namespace Rendering {
 
@@ -14,18 +8,6 @@ class SceneRenderFeatureHost;
 namespace Pipelines {
 namespace Internal {
 
-enum class ForwardSceneStepType : Core::uint8 {
-    InjectionPoint,
-    BuiltinPhase
-};
-
-struct ForwardSceneStep {
-    ForwardSceneStepType type = ForwardSceneStepType::BuiltinPhase;
-    SceneRenderInjectionPoint injectionPoint = SceneRenderInjectionPoint::BeforeOpaque;
-    ScenePhase scenePhase = ScenePhase::Opaque;
-};
-
-const std::array<ForwardSceneStep, 9>& GetBuiltinForwardSceneSteps();
 void RegisterBuiltinForwardSceneFeatures(SceneRenderFeatureHost& featureHost);
 
 } // namespace Internal
diff --git a/engine/src/Rendering/Pipelines/NativeSceneRecorder.cpp b/engine/src/Rendering/Pipelines/NativeSceneRecorder.cpp
index f94ef758..e1afcfac 100644
--- a/engine/src/Rendering/Pipelines/NativeSceneRecorder.cpp
+++ b/engine/src/Rendering/Pipelines/NativeSceneRecorder.cpp
@@ -1,8 +1,8 @@
 #include <XCEngine/Rendering/Pipelines/NativeSceneRecorder.h>
 
 #include "Debug/Logger.h"
+#include "Rendering/Execution/SceneRenderSequence.h"
 #include "Rendering/FrameData/RendererListUtils.h"
-#include "Rendering/Pipelines/Internal/BuiltinForwardSceneSetup.h"
 
 #include <XCEngine/Rendering/Execution/CameraFrameRenderGraphFrameData.h>
 #include <XCEngine/Rendering/Graph/RenderGraphRecordingContext.h>
@@ -119,9 +119,9 @@ void ApplyStandaloneScenePassDefaults(
 } // namespace
 
 NativeSceneRecorder::NativeSceneRecorder(
-    NativeSceneRenderer& sceneRenderer,
+    SceneDrawBackend& sceneDrawBackend,
     const RenderPipelineStageRenderGraphContext& context)
-    : m_sceneRenderer(sceneRenderer)
+    : m_sceneDrawBackend(sceneDrawBackend)
     , m_context(context)
     , m_graphManagedSurface(
         BuildRenderGraphManagedSurfaceTemplate(context.surfaceTemplate))
@@ -138,9 +138,9 @@ NativeSceneRecorder::~NativeSceneRecorder() = default;
 SceneRenderFeaturePassBeginCallback
 NativeSceneRecorder::BuildBeginRecordedPassCallback(
     bool* executionSucceeded) const {
-    NativeSceneRenderer& sceneRenderer = m_sceneRenderer;
+    SceneDrawBackend& sceneDrawBackend = m_sceneDrawBackend;
     const std::shared_ptr<NativeSceneRecorderState> state = m_state;
-    return [&sceneRenderer, state, executionSucceeded](
+    return [&sceneDrawBackend, state, executionSucceeded](
                const RenderPassContext& passContext,
                bool clearAttachments) -> bool {
         if (executionSucceeded != nullptr &&
@@ -149,7 +149,7 @@ NativeSceneRecorder::BuildBeginRecordedPassCallback(
         }
 
         if (!state->initialized) {
-            if (!sceneRenderer.Initialize(passContext.renderContext)) {
+            if (!sceneDrawBackend.Initialize(passContext.renderContext)) {
                 Debug::Logger::Get().Error(
                     Debug::LogCategory::Rendering,
                     "NativeSceneRecorder failed during execution: Initialize returned false");
@@ -166,10 +166,10 @@ NativeSceneRecorder::BuildBeginRecordedPassCallback(
                 passContext.sourceSurface,
                 passContext.sourceColorView,
                 passContext.sourceColorState);
-            if (!sceneRenderer.PrepareScene(executionContext)) {
+            if (!sceneDrawBackend.PrepareSceneDraw(executionContext)) {
                 Debug::Logger::Get().Error(
                     Debug::LogCategory::Rendering,
-                    "NativeSceneRecorder failed during execution: NativeSceneRenderer::PrepareScene returned false");
+                    "NativeSceneRecorder failed during execution: SceneDrawBackend::PrepareSceneDraw returned false");
                 if (executionSucceeded != nullptr) {
                     *executionSucceeded = false;
                 }
@@ -179,12 +179,12 @@ NativeSceneRecorder::BuildBeginRecordedPassCallback(
             state->initialized = true;
         }
 
-        if (!sceneRenderer.BeginScenePass(
+        if (!sceneDrawBackend.BeginSceneDrawPass(
                 passContext,
                 clearAttachments)) {
             Debug::Logger::Get().Error(
                 Debug::LogCategory::Rendering,
-                "NativeSceneRecorder failed during execution: NativeSceneRenderer::BeginScenePass returned false");
+                "NativeSceneRecorder failed during execution: SceneDrawBackend::BeginSceneDrawPass returned false");
             if (executionSucceeded != nullptr) {
                 *executionSucceeded = false;
             }
@@ -197,9 +197,9 @@ NativeSceneRecorder::BuildBeginRecordedPassCallback(
 
 SceneRenderFeaturePassEndCallback
 NativeSceneRecorder::BuildEndRecordedPassCallback() const {
-    NativeSceneRenderer& sceneRenderer = m_sceneRenderer;
-    return [&sceneRenderer](const RenderPassContext& passContext) {
-        sceneRenderer.EndScenePass(passContext);
+    SceneDrawBackend& sceneDrawBackend = m_sceneDrawBackend;
+    return [&sceneDrawBackend](const RenderPassContext& passContext) {
+        sceneDrawBackend.EndSceneDrawPass(passContext);
     };
 }
 
@@ -208,9 +208,9 @@ bool NativeSceneRecorder::RecordDefaultScene() {
         return false;
     }
 
-    for (const Internal::ForwardSceneStep& step :
-         Internal::GetBuiltinForwardSceneSteps()) {
-        if (step.type == Internal::ForwardSceneStepType::InjectionPoint) {
+    for (const SceneRenderStep& step :
+         GetDefaultSceneRenderSequence()) {
+        if (step.type == SceneRenderStepType::InjectionPoint) {
             if (!RecordInjectionPoint(step.injectionPoint)) {
                 return false;
             }
@@ -253,9 +253,9 @@ bool NativeSceneRecorder::RecordScenePhase(
         if (!::XCEngine::Rendering::RecordRenderPipelineStagePhasePass(
                 graphContext,
                 scenePhase,
-                [&sceneRenderer = m_sceneRenderer, scenePhase](
+                [&sceneDrawBackend = m_sceneDrawBackend, scenePhase](
                     const RenderPassContext& passContext) {
-                    return sceneRenderer.ExecuteScenePhase(
+                    return sceneDrawBackend.DrawScenePhase(
                         passContext,
                         scenePhase);
                 },
@@ -322,9 +322,9 @@ bool NativeSceneRecorder::RecordSceneDrawSettings(
     if (!::XCEngine::Rendering::RecordRenderPipelineStagePhasePass(
             graphContext,
             effectiveDrawSettings.scenePhase,
-            [&sceneRenderer = m_sceneRenderer, effectiveDrawSettings](
+            [&sceneDrawBackend = m_sceneDrawBackend, effectiveDrawSettings](
                 const RenderPassContext& passContext) {
-                return sceneRenderer.ExecuteSceneDrawSettings(
+                return sceneDrawBackend.DrawSceneRenderers(
                     passContext,
                     effectiveDrawSettings);
             },
@@ -351,7 +351,7 @@ bool NativeSceneRecorder::RecordInjectionPoint(
     const SceneRenderFeaturePassEndCallback endRecordedPass =
         BuildEndRecordedPassCallback();
     SceneRenderFeatureHost* const featureHost =
-        m_sceneRenderer.GetFeatureHost();
+        m_sceneDrawBackend.GetSceneFeatureHost();
     if (featureHost == nullptr) {
         return false;
     }
@@ -387,7 +387,7 @@ bool NativeSceneRecorder::RecordFeaturePass(
     const SceneRenderFeaturePassEndCallback endRecordedPass =
         BuildEndRecordedPassCallback();
     SceneRenderFeatureHost* const featureHost =
-        m_sceneRenderer.GetFeatureHost();
+        m_sceneDrawBackend.GetSceneFeatureHost();
     if (featureHost == nullptr) {
         return false;
     }
diff --git a/engine/src/Scripting/Mono/MonoScriptRuntime.cpp b/engine/src/Scripting/Mono/MonoScriptRuntime.cpp
index 5f9281e3..04435265 100644
--- a/engine/src/Scripting/Mono/MonoScriptRuntime.cpp
+++ b/engine/src/Scripting/Mono/MonoScriptRuntime.cpp
@@ -1604,21 +1604,21 @@ public:
             }
         }
         m_fullscreenPassPool.clear();
-        if (m_ownedSceneRenderer != nullptr) {
-            m_ownedSceneRenderer->Shutdown();
+        if (m_ownedSceneDrawBackend != nullptr) {
+            m_ownedSceneDrawBackend->Shutdown();
         }
         m_ownedPipelineRendererAsset.reset();
         m_supportsStageContextualMethod = nullptr;
         m_supportsStageMethod = nullptr;
         m_recordStageMethod = nullptr;
         m_resolvedPipelineHandle = 0;
-        m_boundSceneRenderer = nullptr;
+        m_boundSceneDrawBackend = nullptr;
     }
 
     void SetPipelineRenderer(
         Rendering::RenderPipelineRenderer* pipelineRenderer) override {
-        m_boundSceneRenderer =
-            dynamic_cast<Rendering::NativeSceneRenderer*>(pipelineRenderer);
+        m_boundSceneDrawBackend =
+            dynamic_cast<Rendering::SceneDrawBackend*>(pipelineRenderer);
     }
 
     bool SupportsStageRenderGraph(Rendering::CameraFrameStage stage) const override {
@@ -1717,13 +1717,13 @@ public:
         ManagedScriptableRenderContextState managedContextState = {};
         managedContextState.stage = context.stage;
         managedContextState.graphContext = &context;
-        Rendering::NativeSceneRenderer* const sceneRenderer =
-            ResolveSceneRenderer(context.rendererIndex);
-        if (sceneRenderer == nullptr) {
+        Rendering::SceneDrawBackend* const sceneDrawBackend =
+            ResolveSceneDrawBackend(context.rendererIndex);
+        if (sceneDrawBackend == nullptr) {
             return false;
         }
         Rendering::Pipelines::NativeSceneRecorder sceneRecorder(
-            *sceneRenderer,
+            *sceneDrawBackend,
             context);
         managedContextState.sceneRecorder = &sceneRecorder;
         const uint64_t managedContextHandle =
@@ -1904,7 +1904,7 @@ private:
         return true;
     }
 
-    Rendering::NativeSceneRenderer* ResolveSceneRenderer(
+    Rendering::SceneDrawBackend* ResolveSceneDrawBackend(
         int32_t rendererIndex) {
         const std::shared_ptr<const Rendering::RenderPipelineAsset>
             contextualPipelineRendererAsset =
@@ -1917,30 +1917,30 @@ private:
                 m_assetRuntime != nullptr
                     ? m_assetRuntime->GetPipelineRendererAsset()
                     : nullptr;
-        if (m_boundSceneRenderer != nullptr &&
+        if (m_boundSceneDrawBackend != nullptr &&
             contextualPipelineRendererAsset != nullptr &&
             contextualPipelineRendererAsset ==
                 defaultPipelineRendererAsset) {
-            return m_boundSceneRenderer;
+            return m_boundSceneDrawBackend;
         }
 
         if (contextualPipelineRendererAsset == nullptr) {
             return nullptr;
         }
 
-        if (m_ownedSceneRenderer == nullptr ||
+        if (m_ownedSceneDrawBackend == nullptr ||
             contextualPipelineRendererAsset != m_ownedPipelineRendererAsset) {
-            if (m_ownedSceneRenderer != nullptr) {
-                m_ownedSceneRenderer->Shutdown();
+            if (m_ownedSceneDrawBackend != nullptr) {
+                m_ownedSceneDrawBackend->Shutdown();
             }
-            m_ownedSceneRenderer =
-                Rendering::Internal::CreateNativeSceneRendererFromAsset(
+            m_ownedSceneDrawBackend =
+                Rendering::Internal::CreateSceneDrawBackendFromAsset(
                     contextualPipelineRendererAsset);
             m_ownedPipelineRendererAsset =
                 contextualPipelineRendererAsset;
         }
 
-        return m_ownedSceneRenderer.get();
+        return m_ownedSceneDrawBackend.get();
     }
 
     std::shared_ptr<const MonoManagedRenderPipelineAssetRuntime> m_assetRuntime;
@@ -1950,10 +1950,10 @@ private:
     mutable MonoMethod* m_recordStageMethod = nullptr;
     mutable uint32_t m_resolvedPipelineHandle = 0;
     std::vector<std::unique_ptr<Rendering::RenderPass>> m_fullscreenPassPool = {};
-    Rendering::NativeSceneRenderer* m_boundSceneRenderer = nullptr;
+    Rendering::SceneDrawBackend* m_boundSceneDrawBackend = nullptr;
     std::shared_ptr<const Rendering::RenderPipelineAsset>
         m_ownedPipelineRendererAsset = nullptr;
-    std::unique_ptr<Rendering::NativeSceneRenderer> m_ownedSceneRenderer =
+    std::unique_ptr<Rendering::SceneDrawBackend> m_ownedSceneDrawBackend =
         nullptr;
 };