refactor(rendering): clean native scene graph naming

2026-04-15 20:00:30 +08:00
parent 5e841ddd1b
commit 22a2b982ef
7 changed files with 102 additions and 102 deletions
--- a/engine/include/XCEngine/Rendering/Execution/CameraFramePlan.h
+++ b/engine/include/XCEngine/Rendering/Execution/CameraFramePlan.h
@@ -18,7 +18,7 @@ struct CameraFrameFullscreenStagePlan {
 };

 struct CameraFrameColorChainPlan {
-    bool usesGraphManagedMainSceneColor = false;
+    bool usesGraphManagedSceneColor = false;
    CameraFrameFullscreenStagePlan postProcess = {};
    CameraFrameFullscreenStagePlan finalOutput = {};
 };
@@ -37,13 +37,13 @@ struct CameraFramePlan {
    RenderPassSequence* postScenePasses = nullptr;
    RenderPassSequence* overlayPasses = nullptr;
    CameraFrameColorChainPlan colorChain = {};
-    RenderSurface graphManagedMainSceneSurface = {};
+    RenderSurface graphManagedSceneSurface = {};

    static CameraFramePlan FromRequest(const CameraRenderRequest& request);

    bool IsValid() const;
-    void ConfigureGraphManagedMainSceneSurface();
-    bool UsesGraphManagedMainSceneColor() const;
+    void ConfigureGraphManagedSceneSurface();
+    bool UsesGraphManagedSceneColor() const;
    bool UsesGraphManagedOutputColor(CameraFrameStage stage) const;
    CameraFrameColorSource ResolveStageColorSource(CameraFrameStage stage) const;
    bool IsPostProcessStageValid() const;
--- a/engine/include/XCEngine/Rendering/Pipelines/ScriptableRenderPipelineHost.h
+++ b/engine/include/XCEngine/Rendering/Pipelines/ScriptableRenderPipelineHost.h
@@ -13,21 +13,21 @@ class ScriptableRenderPipelineHost final : public RenderPipeline {
 public:
    ScriptableRenderPipelineHost();
    explicit ScriptableRenderPipelineHost(
-        std::unique_ptr<RenderPipelineRenderer> mainSceneRenderer);
+        std::unique_ptr<RenderPipelineRenderer> pipelineRenderer);
    explicit ScriptableRenderPipelineHost(
-        std::shared_ptr<const RenderPipelineAsset> mainSceneRendererAsset);
+        std::shared_ptr<const RenderPipelineAsset> pipelineRendererAsset);
    ~ScriptableRenderPipelineHost() override;

    using RenderPipeline::Render;

-    void SetMainSceneRenderer(std::unique_ptr<RenderPipelineRenderer> mainSceneRenderer);
-    void SetMainSceneRendererAsset(
-        std::shared_ptr<const RenderPipelineAsset> mainSceneRendererAsset);
-    RenderPipelineRenderer* GetMainSceneRenderer() const {
-        return m_mainSceneRenderer.get();
+    void SetPipelineRenderer(std::unique_ptr<RenderPipelineRenderer> pipelineRenderer);
+    void SetPipelineRendererAsset(
+        std::shared_ptr<const RenderPipelineAsset> pipelineRendererAsset);
+    RenderPipelineRenderer* GetPipelineRenderer() const {
+        return m_pipelineRenderer.get();
    }
-    const RenderPipelineAsset* GetMainSceneRendererAsset() const {
-        return m_mainSceneRendererAsset.get();
+    const RenderPipelineAsset* GetPipelineRendererAsset() const {
+        return m_pipelineRendererAsset.get();
    }

    bool Initialize(const RenderContext& context) override;
@@ -42,23 +42,23 @@ public:
        const RenderSceneData& sceneData) override;

 private:
-    void ResetMainSceneRenderer(std::unique_ptr<RenderPipelineRenderer> mainSceneRenderer);
+    void ResetPipelineRenderer(std::unique_ptr<RenderPipelineRenderer> pipelineRenderer);

-    std::shared_ptr<const RenderPipelineAsset> m_mainSceneRendererAsset;
-    std::unique_ptr<RenderPipelineRenderer> m_mainSceneRenderer;
+    std::shared_ptr<const RenderPipelineAsset> m_pipelineRendererAsset;
+    std::unique_ptr<RenderPipelineRenderer> m_pipelineRenderer;
 };

 class ScriptableRenderPipelineHostAsset final : public RenderPipelineAsset {
 public:
    ScriptableRenderPipelineHostAsset();
    explicit ScriptableRenderPipelineHostAsset(
-        std::shared_ptr<const RenderPipelineAsset> mainSceneRendererAsset);
+        std::shared_ptr<const RenderPipelineAsset> pipelineRendererAsset);

    std::unique_ptr<RenderPipeline> CreatePipeline() const override;
    FinalColorSettings GetDefaultFinalColorSettings() const override;

 private:
-    std::shared_ptr<const RenderPipelineAsset> m_mainSceneRendererAsset;
+    std::shared_ptr<const RenderPipelineAsset> m_pipelineRendererAsset;
 };

 } // namespace Pipelines
--- a/engine/src/Rendering/Execution/CameraFramePlan.cpp
+++ b/engine/src/Rendering/Execution/CameraFramePlan.cpp
@@ -31,18 +31,18 @@ bool CameraFramePlan::IsValid() const {
    return request.IsValid();
 }

-void CameraFramePlan::ConfigureGraphManagedMainSceneSurface() {
-    graphManagedMainSceneSurface =
+void CameraFramePlan::ConfigureGraphManagedSceneSurface() {
+    graphManagedSceneSurface =
        BuildGraphManagedIntermediateSurfaceTemplate(request.surface);
 }

-bool CameraFramePlan::UsesGraphManagedMainSceneColor() const {
-    return colorChain.usesGraphManagedMainSceneColor;
+bool CameraFramePlan::UsesGraphManagedSceneColor() const {
+    return colorChain.usesGraphManagedSceneColor;
 }

 bool CameraFramePlan::UsesGraphManagedOutputColor(CameraFrameStage stage) const {
    if (SupportsCameraFramePipelineGraphRecording(stage)) {
-        return UsesGraphManagedMainSceneColor();
+        return UsesGraphManagedSceneColor();
    }

    if (const CameraFrameFullscreenStagePlan* fullscreenStagePlan =
@@ -209,9 +209,9 @@ const RenderSurface* CameraFramePlan::GetSharedStageOutputSurface(

 const RenderSurface& CameraFramePlan::GetMainSceneSurface() const {
    if (UsesGraphManagedOutputColor(CameraFrameStage::MainScene) &&
-        graphManagedMainSceneSurface.GetWidth() > 0u &&
-        graphManagedMainSceneSurface.GetHeight() > 0u) {
-        return graphManagedMainSceneSurface;
+        graphManagedSceneSurface.GetWidth() > 0u &&
+        graphManagedSceneSurface.GetHeight() > 0u) {
+        return graphManagedSceneSurface;
    }

    if (postProcess.IsRequested() &&
--- a/engine/src/Rendering/Pipelines/ScriptableRenderPipelineHost.cpp
+++ b/engine/src/Rendering/Pipelines/ScriptableRenderPipelineHost.cpp
@@ -11,18 +11,18 @@ namespace Pipelines {

 namespace {

-std::shared_ptr<const RenderPipelineAsset> CreateDefaultMainSceneRendererAsset() {
+std::shared_ptr<const RenderPipelineAsset> CreateDefaultPipelineRendererAsset() {
    static const std::shared_ptr<const RenderPipelineAsset> s_defaultRendererAsset =
        std::make_shared<BuiltinForwardPipelineAsset>();
    return s_defaultRendererAsset;
 }

-std::unique_ptr<RenderPipelineRenderer> CreateMainSceneRendererFromAsset(
-    const std::shared_ptr<const RenderPipelineAsset>& mainSceneRendererAsset) {
+std::unique_ptr<RenderPipelineRenderer> CreatePipelineRendererFromAsset(
+    const std::shared_ptr<const RenderPipelineAsset>& pipelineRendererAsset) {
    const std::shared_ptr<const RenderPipelineAsset> resolvedAsset =
-        mainSceneRendererAsset != nullptr
-            ? mainSceneRendererAsset
-            : CreateDefaultMainSceneRendererAsset();
+        pipelineRendererAsset != nullptr
+            ? pipelineRendererAsset
+            : CreateDefaultPipelineRendererAsset();
    if (resolvedAsset != nullptr) {
        if (std::unique_ptr<RenderPipeline> pipeline = resolvedAsset->CreatePipeline()) {
            return pipeline;
@@ -47,120 +47,120 @@ void InstallDefaultStandaloneStagePasses(RenderPipeline& pipeline) {
 } // namespace

 ScriptableRenderPipelineHost::ScriptableRenderPipelineHost()
-    : ScriptableRenderPipelineHost(CreateDefaultMainSceneRendererAsset()) {
+    : ScriptableRenderPipelineHost(CreateDefaultPipelineRendererAsset()) {
 }

 ScriptableRenderPipelineHost::ScriptableRenderPipelineHost(
-    std::unique_ptr<RenderPipelineRenderer> mainSceneRenderer) {
+    std::unique_ptr<RenderPipelineRenderer> pipelineRenderer) {
    InstallDefaultStandaloneStagePasses(*this);
-    ResetMainSceneRenderer(std::move(mainSceneRenderer));
+    ResetPipelineRenderer(std::move(pipelineRenderer));
 }

 ScriptableRenderPipelineHost::ScriptableRenderPipelineHost(
-    std::shared_ptr<const RenderPipelineAsset> mainSceneRendererAsset)
-    : m_mainSceneRendererAsset(
-        mainSceneRendererAsset != nullptr
-            ? std::move(mainSceneRendererAsset)
-            : CreateDefaultMainSceneRendererAsset()) {
+    std::shared_ptr<const RenderPipelineAsset> pipelineRendererAsset)
+    : m_pipelineRendererAsset(
+        pipelineRendererAsset != nullptr
+            ? std::move(pipelineRendererAsset)
+            : CreateDefaultPipelineRendererAsset()) {
    InstallDefaultStandaloneStagePasses(*this);
-    ResetMainSceneRenderer(
-        CreateMainSceneRendererFromAsset(m_mainSceneRendererAsset));
+    ResetPipelineRenderer(
+        CreatePipelineRendererFromAsset(m_pipelineRendererAsset));
 }

 ScriptableRenderPipelineHost::~ScriptableRenderPipelineHost() {
    Shutdown();
 }

-void ScriptableRenderPipelineHost::SetMainSceneRenderer(
-    std::unique_ptr<RenderPipelineRenderer> mainSceneRenderer) {
-    m_mainSceneRendererAsset.reset();
-    ResetMainSceneRenderer(std::move(mainSceneRenderer));
+void ScriptableRenderPipelineHost::SetPipelineRenderer(
+    std::unique_ptr<RenderPipelineRenderer> pipelineRenderer) {
+    m_pipelineRendererAsset.reset();
+    ResetPipelineRenderer(std::move(pipelineRenderer));
 }

-void ScriptableRenderPipelineHost::SetMainSceneRendererAsset(
-    std::shared_ptr<const RenderPipelineAsset> mainSceneRendererAsset) {
-    m_mainSceneRendererAsset =
-        mainSceneRendererAsset != nullptr
-            ? std::move(mainSceneRendererAsset)
-            : CreateDefaultMainSceneRendererAsset();
-    ResetMainSceneRenderer(
-        CreateMainSceneRendererFromAsset(m_mainSceneRendererAsset));
+void ScriptableRenderPipelineHost::SetPipelineRendererAsset(
+    std::shared_ptr<const RenderPipelineAsset> pipelineRendererAsset) {
+    m_pipelineRendererAsset =
+        pipelineRendererAsset != nullptr
+            ? std::move(pipelineRendererAsset)
+            : CreateDefaultPipelineRendererAsset();
+    ResetPipelineRenderer(
+        CreatePipelineRendererFromAsset(m_pipelineRendererAsset));
 }

 bool ScriptableRenderPipelineHost::Initialize(const RenderContext& context) {
-    return m_mainSceneRenderer != nullptr &&
-           m_mainSceneRenderer->Initialize(context);
+    return m_pipelineRenderer != nullptr &&
+           m_pipelineRenderer->Initialize(context);
 }

 void ScriptableRenderPipelineHost::Shutdown() {
-    if (m_mainSceneRenderer != nullptr) {
-        m_mainSceneRenderer->Shutdown();
+    if (m_pipelineRenderer != nullptr) {
+        m_pipelineRenderer->Shutdown();
    }
    ShutdownCameraFrameStandalonePasses();
 }

 bool ScriptableRenderPipelineHost::SupportsStageRenderGraph(
    CameraFrameStage stage) const {
-    return m_mainSceneRenderer != nullptr &&
-           m_mainSceneRenderer->SupportsStageRenderGraph(stage);
+    return m_pipelineRenderer != nullptr &&
+           m_pipelineRenderer->SupportsStageRenderGraph(stage);
 }

 bool ScriptableRenderPipelineHost::RecordStageRenderGraph(
    const RenderPipelineStageRenderGraphContext& context) {
-    return m_mainSceneRenderer != nullptr &&
-           m_mainSceneRenderer->RecordStageRenderGraph(context);
+    return m_pipelineRenderer != nullptr &&
+           m_pipelineRenderer->RecordStageRenderGraph(context);
 }

 bool ScriptableRenderPipelineHost::Render(
    const FrameExecutionContext& executionContext) {
-    return m_mainSceneRenderer != nullptr &&
-           m_mainSceneRenderer->Render(executionContext);
+    return m_pipelineRenderer != nullptr &&
+           m_pipelineRenderer->Render(executionContext);
 }

 bool ScriptableRenderPipelineHost::Render(
    const RenderContext& context,
    const RenderSurface& surface,
    const RenderSceneData& sceneData) {
-    return m_mainSceneRenderer != nullptr &&
-           m_mainSceneRenderer->Render(context, surface, sceneData);
+    return m_pipelineRenderer != nullptr &&
+           m_pipelineRenderer->Render(context, surface, sceneData);
 }

-void ScriptableRenderPipelineHost::ResetMainSceneRenderer(
-    std::unique_ptr<RenderPipelineRenderer> mainSceneRenderer) {
-    if (m_mainSceneRenderer != nullptr) {
-        m_mainSceneRenderer->Shutdown();
+void ScriptableRenderPipelineHost::ResetPipelineRenderer(
+    std::unique_ptr<RenderPipelineRenderer> pipelineRenderer) {
+    if (m_pipelineRenderer != nullptr) {
+        m_pipelineRenderer->Shutdown();
    }

-    m_mainSceneRenderer = std::move(mainSceneRenderer);
-    if (m_mainSceneRenderer == nullptr) {
-        if (m_mainSceneRendererAsset == nullptr) {
-            m_mainSceneRendererAsset = CreateDefaultMainSceneRendererAsset();
+    m_pipelineRenderer = std::move(pipelineRenderer);
+    if (m_pipelineRenderer == nullptr) {
+        if (m_pipelineRendererAsset == nullptr) {
+            m_pipelineRendererAsset = CreateDefaultPipelineRendererAsset();
        }
-        m_mainSceneRenderer =
-            CreateMainSceneRendererFromAsset(m_mainSceneRendererAsset);
+        m_pipelineRenderer =
+            CreatePipelineRendererFromAsset(m_pipelineRendererAsset);
    }
 }

 ScriptableRenderPipelineHostAsset::ScriptableRenderPipelineHostAsset()
-    : ScriptableRenderPipelineHostAsset(CreateDefaultMainSceneRendererAsset()) {
+    : ScriptableRenderPipelineHostAsset(CreateDefaultPipelineRendererAsset()) {
 }

 ScriptableRenderPipelineHostAsset::ScriptableRenderPipelineHostAsset(
-    std::shared_ptr<const RenderPipelineAsset> mainSceneRendererAsset)
-    : m_mainSceneRendererAsset(
-        mainSceneRendererAsset != nullptr
-            ? std::move(mainSceneRendererAsset)
-            : CreateDefaultMainSceneRendererAsset()) {
+    std::shared_ptr<const RenderPipelineAsset> pipelineRendererAsset)
+    : m_pipelineRendererAsset(
+        pipelineRendererAsset != nullptr
+            ? std::move(pipelineRendererAsset)
+            : CreateDefaultPipelineRendererAsset()) {
 }

 std::unique_ptr<RenderPipeline> ScriptableRenderPipelineHostAsset::CreatePipeline() const {
    return std::make_unique<ScriptableRenderPipelineHost>(
-        m_mainSceneRendererAsset);
+        m_pipelineRendererAsset);
 }

 FinalColorSettings ScriptableRenderPipelineHostAsset::GetDefaultFinalColorSettings() const {
-    return m_mainSceneRendererAsset != nullptr
-        ? m_mainSceneRendererAsset->GetDefaultFinalColorSettings()
+    return m_pipelineRendererAsset != nullptr
+        ? m_pipelineRendererAsset->GetDefaultFinalColorSettings()
        : FinalColorSettings{};
 }

--- a/engine/src/Rendering/Planning/Internal/CameraFrameFullscreenStagePlanner.cpp
+++ b/engine/src/Rendering/Planning/Internal/CameraFrameFullscreenStagePlanner.cpp
@@ -47,7 +47,7 @@ void PlanCameraFrameFullscreenStages(
    if (hasPostProcess) {
        ownedPostProcessSequence = std::move(postProcessSequence);
        plan.postProcess.passes = ownedPostProcessSequence.get();
-        plan.colorChain.usesGraphManagedMainSceneColor = true;
+        plan.colorChain.usesGraphManagedSceneColor = true;
        plan.colorChain.postProcess.source = CameraFrameColorSource::MainSceneColor;
        plan.colorChain.postProcess.usesGraphManagedOutputColor = hasFinalOutput;
        if (!hasFinalOutput) {
@@ -58,7 +58,7 @@ void PlanCameraFrameFullscreenStages(
    if (hasFinalOutput) {
        ownedFinalOutputSequence = std::move(finalOutputSequence);
        plan.finalOutput.passes = ownedFinalOutputSequence.get();
-        plan.colorChain.usesGraphManagedMainSceneColor = true;
+        plan.colorChain.usesGraphManagedSceneColor = true;
        plan.colorChain.finalOutput.source =
            hasPostProcess
                ? CameraFrameColorSource::PostProcessColor
@@ -67,7 +67,7 @@ void PlanCameraFrameFullscreenStages(
    }

    if (plan.UsesGraphManagedOutputColor(CameraFrameStage::MainScene)) {
-        plan.ConfigureGraphManagedMainSceneSurface();
+        plan.ConfigureGraphManagedSceneSurface();
    }
 }

--- a/tests/Rendering/unit/test_camera_frame_graph_stage_policy.cpp
+++ b/tests/Rendering/unit/test_camera_frame_graph_stage_policy.cpp
@@ -105,7 +105,7 @@ TEST(CameraFrameRenderGraphStagePolicy_Test, ReportsStageFullscreenAndTransition

 TEST(CameraFrameRenderGraphStagePolicy_Test, ReportsGraphManagedOutputColorStagesFromPlan) {
    CameraFramePlan plan = {};
-    plan.colorChain.usesGraphManagedMainSceneColor = true;
+    plan.colorChain.usesGraphManagedSceneColor = true;
    plan.colorChain.postProcess.usesGraphManagedOutputColor = true;

    EXPECT_TRUE(plan.UsesGraphManagedOutputColor(CameraFrameStage::MainScene));
--- a/tests/Rendering/unit/test_camera_scene_renderer.cpp
+++ b/tests/Rendering/unit/test_camera_scene_renderer.cpp
@@ -1905,8 +1905,8 @@ TEST(CameraRenderer_Test, ResolvesGraphManagedFullscreenSequenceSourcesFromFrame
    request.finalOutput.destinationSurface = request.surface;

    CameraFramePlan plan = CameraFramePlan::FromRequest(request);
-    plan.colorChain.usesGraphManagedMainSceneColor = true;
-    plan.ConfigureGraphManagedMainSceneSurface();
+    plan.colorChain.usesGraphManagedSceneColor = true;
+    plan.ConfigureGraphManagedSceneSurface();
    plan.colorChain.postProcess.usesGraphManagedOutputColor = true;
    plan.colorChain.postProcess.source = CameraFrameColorSource::MainSceneColor;
    plan.colorChain.finalOutput.source = CameraFrameColorSource::PostProcessColor;
@@ -2956,7 +2956,7 @@ TEST(SceneRenderer_Test, BuildsCameraColorScalePostProcessRequestFromCameraPassS
    EXPECT_TRUE(plan.IsPostProcessStageValid());
    EXPECT_NE(plan.postProcess.passes, nullptr);
    ASSERT_EQ(plan.postProcess.passes->GetPassCount(), 2u);
-    EXPECT_TRUE(plan.UsesGraphManagedMainSceneColor());
+    EXPECT_TRUE(plan.UsesGraphManagedSceneColor());
    EXPECT_FALSE(plan.UsesGraphManagedOutputColor(CameraFrameStage::PostProcess));
    EXPECT_EQ(
        plan.ResolveStageColorSource(CameraFrameStage::PostProcess),
@@ -3096,7 +3096,7 @@ TEST(SceneRenderer_Test, BuildsFinalOutputRequestFromResolvedFinalColorPolicy) {
    EXPECT_TRUE(plan.IsFinalOutputStageValid());
    ASSERT_NE(plan.finalOutput.passes, nullptr);
    EXPECT_EQ(plan.finalOutput.passes->GetPassCount(), 1u);
-    EXPECT_TRUE(plan.UsesGraphManagedMainSceneColor());
+    EXPECT_TRUE(plan.UsesGraphManagedSceneColor());
    EXPECT_EQ(
        plan.ResolveStageColorSource(CameraFrameStage::FinalOutput),
        CameraFrameColorSource::MainSceneColor);
@@ -3189,7 +3189,7 @@ TEST(SceneRenderer_Test, RoutesPostProcessIntoIntermediateSurfaceBeforeFinalOutp
    ASSERT_NE(plan.finalOutput.passes, nullptr);
    EXPECT_EQ(plan.postProcess.passes->GetPassCount(), 1u);
    EXPECT_EQ(plan.finalOutput.passes->GetPassCount(), 1u);
-    EXPECT_TRUE(plan.UsesGraphManagedMainSceneColor());
+    EXPECT_TRUE(plan.UsesGraphManagedSceneColor());
    EXPECT_TRUE(plan.UsesGraphManagedOutputColor(CameraFrameStage::PostProcess));
    EXPECT_EQ(
        plan.ResolveStageColorSource(CameraFrameStage::PostProcess),
@@ -3338,7 +3338,7 @@ TEST(SceneRenderer_Test, KeepsMainSceneGraphManagedWhenPostProcessIsEnabledAcros
        renderer.BuildFramePlans(scene, nullptr, context, surface);
    ASSERT_EQ(firstFramePlans.size(), 1u);
    CameraFramePlan firstFramePlan = firstFramePlans[0];
-    EXPECT_TRUE(firstFramePlan.UsesGraphManagedMainSceneColor());
+    EXPECT_TRUE(firstFramePlan.UsesGraphManagedSceneColor());
    EXPECT_EQ(
        firstFramePlan.ResolveStageColorSource(CameraFrameStage::PostProcess),
        CameraFrameColorSource::MainSceneColor);
@@ -3360,7 +3360,7 @@ TEST(SceneRenderer_Test, KeepsMainSceneGraphManagedWhenPostProcessIsEnabledAcros
        renderer.BuildFramePlans(scene, nullptr, context, surface);
    ASSERT_EQ(secondFramePlans.size(), 1u);
    const CameraFramePlan secondFramePlan = secondFramePlans[0];
-    EXPECT_TRUE(secondFramePlan.UsesGraphManagedMainSceneColor());
+    EXPECT_TRUE(secondFramePlan.UsesGraphManagedSceneColor());
    EXPECT_EQ(
        secondFramePlan.ResolveStageColorSource(CameraFrameStage::PostProcess),
        CameraFrameColorSource::MainSceneColor);
@@ -3425,7 +3425,7 @@ TEST(SceneRenderer_Test, KeepsPostProcessOutputGraphManagedWhenFinalOutputIsEnab
    CameraFramePlan firstFramePlan = firstFramePlans[0];
    EXPECT_TRUE(firstFramePlans[0].postProcess.IsRequested());
    EXPECT_TRUE(firstFramePlans[0].finalOutput.IsRequested());
-    EXPECT_TRUE(firstFramePlan.UsesGraphManagedMainSceneColor());
+    EXPECT_TRUE(firstFramePlan.UsesGraphManagedSceneColor());
    EXPECT_TRUE(firstFramePlan.UsesGraphManagedOutputColor(CameraFrameStage::PostProcess));
    EXPECT_EQ(
        firstFramePlan.ResolveStageColorSource(CameraFrameStage::PostProcess),
@@ -3457,7 +3457,7 @@ TEST(SceneRenderer_Test, KeepsPostProcessOutputGraphManagedWhenFinalOutputIsEnab
        renderer.BuildFramePlans(scene, nullptr, context, surface);
    ASSERT_EQ(secondFramePlans.size(), 1u);
    const CameraFramePlan secondFramePlan = secondFramePlans[0];
-    EXPECT_TRUE(secondFramePlan.UsesGraphManagedMainSceneColor());
+    EXPECT_TRUE(secondFramePlan.UsesGraphManagedSceneColor());
    EXPECT_TRUE(secondFramePlan.UsesGraphManagedOutputColor(CameraFrameStage::PostProcess));
    EXPECT_EQ(
        secondFramePlan.ResolveStageColorSource(CameraFrameStage::PostProcess),
@@ -3695,14 +3695,14 @@ TEST(ScriptableRenderPipelineHost_Test, ForwardsRendererLifetimeAndFrameRenderin
        auto initialRenderer = std::make_unique<MockPipeline>(initialState);
        MockPipeline* initialRendererRaw = initialRenderer.get();
        Pipelines::ScriptableRenderPipelineHost host(std::move(initialRenderer));
-        EXPECT_EQ(host.GetMainSceneRenderer(), initialRendererRaw);
+        EXPECT_EQ(host.GetPipelineRenderer(), initialRendererRaw);

        auto replacementRenderer = std::make_unique<MockPipeline>(replacementState);
        MockPipeline* replacementRendererRaw = replacementRenderer.get();
-        host.SetMainSceneRenderer(std::move(replacementRenderer));
+        host.SetPipelineRenderer(std::move(replacementRenderer));

        EXPECT_EQ(initialState->shutdownCalls, 1);
-        EXPECT_EQ(host.GetMainSceneRenderer(), replacementRendererRaw);
+        EXPECT_EQ(host.GetPipelineRenderer(), replacementRendererRaw);

        CameraRenderRequest request = {};
        request.scene = &scene;
@@ -3780,7 +3780,7 @@ TEST(ScriptableRenderPipelineHostAsset_Test, CreatesHostFromRendererAssetAndForw
    auto* host =
        dynamic_cast<Pipelines::ScriptableRenderPipelineHost*>(pipeline.get());
    ASSERT_NE(host, nullptr);
-    EXPECT_NE(host->GetMainSceneRenderer(), nullptr);
+    EXPECT_NE(host->GetPipelineRenderer(), nullptr);
    EXPECT_EQ(assetState->createCalls, 1);
 }