Introduce CameraRenderRequest scheduling and fix Vulkan build

engine/src/Rendering/SceneRenderer.cpp

@@ -1,8 +1,24 @@
 #include "Rendering/SceneRenderer.h"
 
+#include "Components/CameraComponent.h"
+
+#include <algorithm>
+
 namespace XCEngine {
 namespace Rendering {
 
+namespace {
+
+bool CompareCameraRenderRequest(const CameraRenderRequest& lhs, const CameraRenderRequest& rhs) {
+    if (lhs.cameraDepth != rhs.cameraDepth) {
+        return lhs.cameraDepth < rhs.cameraDepth;
+    }
+
+    return lhs.camera < rhs.camera;
+}
+
+} // namespace
+
 SceneRenderer::SceneRenderer() = default;
 
 SceneRenderer::SceneRenderer(std::unique_ptr<RenderPipeline> pipeline)
@@ -13,12 +29,66 @@ void SceneRenderer::SetPipeline(std::unique_ptr<RenderPipeline> pipeline) {
     m_cameraRenderer.SetPipeline(std::move(pipeline));
 }
 
+std::vector<CameraRenderRequest> SceneRenderer::BuildRenderRequests(
+    const Components::Scene& scene,
+    Components::CameraComponent* overrideCamera,
+    const RenderContext& context,
+    const RenderSurface& surface) const {
+    std::vector<CameraRenderRequest> requests;
+
+    Components::CameraComponent* camera = m_sceneExtractor.SelectCamera(scene, overrideCamera);
+    if (camera == nullptr) {
+        return requests;
+    }
+
+    CameraRenderRequest request;
+    request.scene = &scene;
+    request.camera = camera;
+    request.context = context;
+    request.surface = surface;
+    request.cameraDepth = camera->GetDepth();
+    requests.push_back(request);
+    return requests;
+}
+
+bool SceneRenderer::Render(const CameraRenderRequest& request) {
+    return m_cameraRenderer.Render(request);
+}
+
+bool SceneRenderer::Render(const std::vector<CameraRenderRequest>& requests) {
+    if (requests.empty()) {
+        return false;
+    }
+
+    for (const CameraRenderRequest& request : requests) {
+        if (!request.IsValid()) {
+            return false;
+        }
+    }
+
+    std::vector<CameraRenderRequest> sortedRequests = requests;
+    std::stable_sort(
+        sortedRequests.begin(),
+        sortedRequests.end(),
+        CompareCameraRenderRequest);
+
+    bool rendered = false;
+    for (const CameraRenderRequest& request : sortedRequests) {
+        if (!m_cameraRenderer.Render(request)) {
+            return false;
+        }
+        rendered = true;
+    }
+
+    return rendered;
+}
+
 bool SceneRenderer::Render(
     const Components::Scene& scene,
     Components::CameraComponent* overrideCamera,
     const RenderContext& context,
     const RenderSurface& surface) {
-    return m_cameraRenderer.Render(scene, overrideCamera, context, surface);
+    return Render(BuildRenderRequests(scene, overrideCamera, context, surface));
 }
 
 } // namespace Rendering