From 22a2b982ef9e369fe2a90ad3bd154f5e2b5e410c Mon Sep 17 00:00:00 2001 From: ssdfasd <2156608475@qq.com> Date: Wed, 15 Apr 2026 20:00:30 +0800 Subject: [PATCH] refactor(rendering): clean native scene graph naming --- .../Rendering/Execution/CameraFramePlan.h | 8 +- .../Pipelines/ScriptableRenderPipelineHost.h | 28 ++--- .../Rendering/Execution/CameraFramePlan.cpp | 16 +-- .../ScriptableRenderPipelineHost.cpp | 118 +++++++++--------- .../CameraFrameFullscreenStagePlanner.cpp | 6 +- .../test_camera_frame_graph_stage_policy.cpp | 2 +- .../unit/test_camera_scene_renderer.cpp | 26 ++-- 7 files changed, 102 insertions(+), 102 deletions(-) diff --git a/engine/include/XCEngine/Rendering/Execution/CameraFramePlan.h b/engine/include/XCEngine/Rendering/Execution/CameraFramePlan.h index 9170f57e..88188194 100644 --- 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; diff --git a/engine/include/XCEngine/Rendering/Pipelines/ScriptableRenderPipelineHost.h b/engine/include/XCEngine/Rendering/Pipelines/ScriptableRenderPipelineHost.h index fcfe288c..5cbbf3b7 100644 --- 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 mainSceneRenderer); + std::unique_ptr pipelineRenderer); explicit ScriptableRenderPipelineHost( - std::shared_ptr mainSceneRendererAsset); + std::shared_ptr pipelineRendererAsset); ~ScriptableRenderPipelineHost() override; using RenderPipeline::Render; - void SetMainSceneRenderer(std::unique_ptr mainSceneRenderer); - void SetMainSceneRendererAsset( - std::shared_ptr mainSceneRendererAsset); - RenderPipelineRenderer* GetMainSceneRenderer() const { - return m_mainSceneRenderer.get(); + void SetPipelineRenderer(std::unique_ptr pipelineRenderer); + void SetPipelineRendererAsset( + std::shared_ptr 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 mainSceneRenderer); + void ResetPipelineRenderer(std::unique_ptr pipelineRenderer); - std::shared_ptr m_mainSceneRendererAsset; - std::unique_ptr m_mainSceneRenderer; + std::shared_ptr m_pipelineRendererAsset; + std::unique_ptr m_pipelineRenderer; }; class ScriptableRenderPipelineHostAsset final : public RenderPipelineAsset { public: ScriptableRenderPipelineHostAsset(); explicit ScriptableRenderPipelineHostAsset( - std::shared_ptr mainSceneRendererAsset); + std::shared_ptr pipelineRendererAsset); std::unique_ptr CreatePipeline() const override; FinalColorSettings GetDefaultFinalColorSettings() const override; private: - std::shared_ptr m_mainSceneRendererAsset; + std::shared_ptr m_pipelineRendererAsset; }; } // namespace Pipelines diff --git a/engine/src/Rendering/Execution/CameraFramePlan.cpp b/engine/src/Rendering/Execution/CameraFramePlan.cpp index 00de8316..67df545d 100644 --- 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() && diff --git a/engine/src/Rendering/Pipelines/ScriptableRenderPipelineHost.cpp b/engine/src/Rendering/Pipelines/ScriptableRenderPipelineHost.cpp index 11ccef06..52767ac3 100644 --- a/engine/src/Rendering/Pipelines/ScriptableRenderPipelineHost.cpp +++ b/engine/src/Rendering/Pipelines/ScriptableRenderPipelineHost.cpp @@ -11,18 +11,18 @@ namespace Pipelines { namespace { -std::shared_ptr CreateDefaultMainSceneRendererAsset() { +std::shared_ptr CreateDefaultPipelineRendererAsset() { static const std::shared_ptr s_defaultRendererAsset = std::make_shared(); return s_defaultRendererAsset; } -std::unique_ptr CreateMainSceneRendererFromAsset( - const std::shared_ptr& mainSceneRendererAsset) { +std::unique_ptr CreatePipelineRendererFromAsset( + const std::shared_ptr& pipelineRendererAsset) { const std::shared_ptr resolvedAsset = - mainSceneRendererAsset != nullptr - ? mainSceneRendererAsset - : CreateDefaultMainSceneRendererAsset(); + pipelineRendererAsset != nullptr + ? pipelineRendererAsset + : CreateDefaultPipelineRendererAsset(); if (resolvedAsset != nullptr) { if (std::unique_ptr 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 mainSceneRenderer) { + std::unique_ptr pipelineRenderer) { InstallDefaultStandaloneStagePasses(*this); - ResetMainSceneRenderer(std::move(mainSceneRenderer)); + ResetPipelineRenderer(std::move(pipelineRenderer)); } ScriptableRenderPipelineHost::ScriptableRenderPipelineHost( - std::shared_ptr mainSceneRendererAsset) - : m_mainSceneRendererAsset( - mainSceneRendererAsset != nullptr - ? std::move(mainSceneRendererAsset) - : CreateDefaultMainSceneRendererAsset()) { + std::shared_ptr 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 mainSceneRenderer) { - m_mainSceneRendererAsset.reset(); - ResetMainSceneRenderer(std::move(mainSceneRenderer)); +void ScriptableRenderPipelineHost::SetPipelineRenderer( + std::unique_ptr pipelineRenderer) { + m_pipelineRendererAsset.reset(); + ResetPipelineRenderer(std::move(pipelineRenderer)); } -void ScriptableRenderPipelineHost::SetMainSceneRendererAsset( - std::shared_ptr mainSceneRendererAsset) { - m_mainSceneRendererAsset = - mainSceneRendererAsset != nullptr - ? std::move(mainSceneRendererAsset) - : CreateDefaultMainSceneRendererAsset(); - ResetMainSceneRenderer( - CreateMainSceneRendererFromAsset(m_mainSceneRendererAsset)); +void ScriptableRenderPipelineHost::SetPipelineRendererAsset( + std::shared_ptr 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 mainSceneRenderer) { - if (m_mainSceneRenderer != nullptr) { - m_mainSceneRenderer->Shutdown(); +void ScriptableRenderPipelineHost::ResetPipelineRenderer( + std::unique_ptr 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 mainSceneRendererAsset) - : m_mainSceneRendererAsset( - mainSceneRendererAsset != nullptr - ? std::move(mainSceneRendererAsset) - : CreateDefaultMainSceneRendererAsset()) { + std::shared_ptr pipelineRendererAsset) + : m_pipelineRendererAsset( + pipelineRendererAsset != nullptr + ? std::move(pipelineRendererAsset) + : CreateDefaultPipelineRendererAsset()) { } std::unique_ptr ScriptableRenderPipelineHostAsset::CreatePipeline() const { return std::make_unique( - m_mainSceneRendererAsset); + m_pipelineRendererAsset); } FinalColorSettings ScriptableRenderPipelineHostAsset::GetDefaultFinalColorSettings() const { - return m_mainSceneRendererAsset != nullptr - ? m_mainSceneRendererAsset->GetDefaultFinalColorSettings() + return m_pipelineRendererAsset != nullptr + ? m_pipelineRendererAsset->GetDefaultFinalColorSettings() : FinalColorSettings{}; } diff --git a/engine/src/Rendering/Planning/Internal/CameraFrameFullscreenStagePlanner.cpp b/engine/src/Rendering/Planning/Internal/CameraFrameFullscreenStagePlanner.cpp index a6df48c2..31a74346 100644 --- 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(); } } diff --git a/tests/Rendering/unit/test_camera_frame_graph_stage_policy.cpp b/tests/Rendering/unit/test_camera_frame_graph_stage_policy.cpp index a04823db..a4c803a6 100644 --- 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)); diff --git a/tests/Rendering/unit/test_camera_scene_renderer.cpp b/tests/Rendering/unit/test_camera_scene_renderer.cpp index 258fe9d4..084aaf60 100644 --- 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(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(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(pipeline.get()); ASSERT_NE(host, nullptr); - EXPECT_NE(host->GetMainSceneRenderer(), nullptr); + EXPECT_NE(host->GetPipelineRenderer(), nullptr); EXPECT_EQ(assetState->createCalls, 1); }