Introduce native render pipeline host

engine/src/Rendering/Execution/SceneRenderer.cpp

@@ -1,46 +1,30 @@
 #include "Rendering/Execution/SceneRenderer.h"
 
 #include "Components/CameraComponent.h"
-#include "Rendering/Planning/CameraFramePlanBuilder.h"
-#include "Rendering/Planning/SceneRenderRequestUtils.h"
+#include "Rendering/Execution/RenderPipelineHost.h"
 
 namespace XCEngine {
 namespace Rendering {
 
-namespace {
-
-bool CompareCameraFramePlans(
-    const CameraFramePlan& lhs,
-    const CameraFramePlan& rhs) {
-    return SceneRenderRequestUtils::CompareCameraRenderRequests(
-        lhs.request,
-        rhs.request);
-}
-
-} // namespace
-
-SceneRenderer::SceneRenderer()
-    : m_framePlanBuilder(std::make_unique<CameraFramePlanBuilder>()) {
+SceneRenderer::SceneRenderer() {
 }
 
 SceneRenderer::SceneRenderer(std::unique_ptr<RenderPipeline> pipeline)
-    : m_cameraRenderer(std::move(pipeline))
-    , m_framePlanBuilder(std::make_unique<CameraFramePlanBuilder>()) {
+    : m_pipelineHost(std::move(pipeline)) {
 }
 
 SceneRenderer::SceneRenderer(std::shared_ptr<const RenderPipelineAsset> pipelineAsset)
-    : m_cameraRenderer(std::move(pipelineAsset))
-    , m_framePlanBuilder(std::make_unique<CameraFramePlanBuilder>()) {
+    : m_pipelineHost(std::move(pipelineAsset)) {
 }
 
 SceneRenderer::~SceneRenderer() = default;
 
 void SceneRenderer::SetPipeline(std::unique_ptr<RenderPipeline> pipeline) {
-    m_cameraRenderer.SetPipeline(std::move(pipeline));
+    m_pipelineHost.SetPipeline(std::move(pipeline));
 }
 
 void SceneRenderer::SetPipelineAsset(std::shared_ptr<const RenderPipelineAsset> pipelineAsset) {
-    m_cameraRenderer.SetPipelineAsset(std::move(pipelineAsset));
+    m_pipelineHost.SetPipelineAsset(std::move(pipelineAsset));
 }
 
 std::vector<CameraFramePlan> SceneRenderer::BuildFramePlans(
@@ -50,42 +34,15 @@ std::vector<CameraFramePlan> SceneRenderer::BuildFramePlans(
     const RenderSurface& surface) {
     const std::vector<CameraRenderRequest> requests =
         m_requestPlanner.BuildRequests(scene, overrideCamera, context, surface);
-    return m_framePlanBuilder != nullptr
-        ? m_framePlanBuilder->BuildPlans(requests, GetPipelineAsset())
-        : std::vector<CameraFramePlan>();
+    return m_pipelineHost.BuildFramePlans(requests);
 }
 
 bool SceneRenderer::Render(const CameraFramePlan& plan) {
-    return m_cameraRenderer.Render(plan);
+    return m_pipelineHost.Render(plan);
 }
 
 bool SceneRenderer::Render(const std::vector<CameraFramePlan>& plans) {
-    if (plans.empty()) {
-        return false;
-    }
-
-    for (const CameraFramePlan& plan : plans) {
-        if (!plan.IsValid()) {
-            return false;
-        }
-    }
-
-    std::vector<CameraFramePlan> sortedPlans = plans;
-    std::stable_sort(
-        sortedPlans.begin(),
-        sortedPlans.end(),
-        CompareCameraFramePlans);
-
-    bool rendered = false;
-    for (const CameraFramePlan& plan : sortedPlans) {
-        if (!m_cameraRenderer.Render(plan)) {
-            return false;
-        }
-
-        rendered = true;
-    }
-
-    return rendered;
+    return m_pipelineHost.Render(plans);
 }
 
 bool SceneRenderer::Render(