refactor(rendering): clean native scene graph naming

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() &&

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{};
 }
 

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();
     }
 }