refactor(rendering): clean native scene graph naming

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