refactor: extract scene render request policy utils

engine/include/XCEngine/Rendering/SceneRenderRequestUtils.h

@@ -0,0 +1,133 @@
+#pragma once
+
+#include <XCEngine/Components/CameraComponent.h>
+#include <XCEngine/Components/GameObject.h>
+#include <XCEngine/Rendering/CameraRenderRequest.h>
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <vector>
+
+namespace XCEngine {
+namespace Components {
+class Scene;
+} // namespace Components
+
+namespace Rendering {
+namespace SceneRenderRequestUtils {
+
+inline bool CompareCameraRenderRequests(
+    const CameraRenderRequest& lhs,
+    const CameraRenderRequest& rhs) {
+    if (lhs.cameraStackOrder != rhs.cameraStackOrder) {
+        return lhs.cameraStackOrder < rhs.cameraStackOrder;
+    }
+
+    if (lhs.cameraDepth != rhs.cameraDepth) {
+        return lhs.cameraDepth < rhs.cameraDepth;
+    }
+
+    return false;
+}
+
+inline bool IsUsableCamera(const Components::CameraComponent* camera) {
+    return camera != nullptr &&
+           camera->IsEnabled() &&
+           camera->GetGameObject() != nullptr &&
+           camera->GetGameObject()->IsActiveInHierarchy();
+}
+
+inline bool CompareSceneCamerasForRendering(
+    const Components::CameraComponent* lhs,
+    const Components::CameraComponent* rhs) {
+    if (lhs->GetStackType() != rhs->GetStackType()) {
+        return static_cast<int>(lhs->GetStackType()) < static_cast<int>(rhs->GetStackType());
+    }
+
+    if (lhs->GetDepth() != rhs->GetDepth()) {
+        return lhs->GetDepth() < rhs->GetDepth();
+    }
+
+    return false;
+}
+
+inline void SortSceneCamerasForRendering(std::vector<Components::CameraComponent*>& cameras) {
+    std::stable_sort(
+        cameras.begin(),
+        cameras.end(),
+        CompareSceneCamerasForRendering);
+}
+
+inline void SortCameraRenderRequests(std::vector<CameraRenderRequest>& requests) {
+    std::stable_sort(
+        requests.begin(),
+        requests.end(),
+        CompareCameraRenderRequests);
+}
+
+inline RenderClearFlags ResolveClearFlags(
+    const Components::CameraComponent& camera,
+    size_t renderedBaseCameraCount,
+    size_t renderedRequestCount) {
+    switch (camera.GetClearMode()) {
+        case Components::CameraClearMode::ColorAndDepth:
+            return RenderClearFlags::All;
+        case Components::CameraClearMode::DepthOnly:
+            return RenderClearFlags::Depth;
+        case Components::CameraClearMode::None:
+            return RenderClearFlags::None;
+        case Components::CameraClearMode::Auto:
+        default:
+            if (camera.GetStackType() == Components::CameraStackType::Overlay) {
+                return renderedRequestCount == 0 ? RenderClearFlags::All : RenderClearFlags::Depth;
+            }
+
+            return renderedBaseCameraCount == 0 ? RenderClearFlags::All : RenderClearFlags::Depth;
+    }
+}
+
+inline Math::RectInt ResolveCameraRenderArea(
+    const Components::CameraComponent& camera,
+    const RenderSurface& surface) {
+    const Math::Rect viewportRect = camera.GetViewportRect();
+    const Math::RectInt parentRenderArea = surface.GetRenderArea();
+    const float parentWidth = static_cast<float>(std::max(parentRenderArea.width, 0));
+    const float parentHeight = static_cast<float>(std::max(parentRenderArea.height, 0));
+
+    const int32_t left = parentRenderArea.x +
+        static_cast<int32_t>(std::floor(viewportRect.x * parentWidth));
+    const int32_t top = parentRenderArea.y +
+        static_cast<int32_t>(std::floor(viewportRect.y * parentHeight));
+    const int32_t right = parentRenderArea.x +
+        static_cast<int32_t>(std::ceil((viewportRect.x + viewportRect.width) * parentWidth));
+    const int32_t bottom = parentRenderArea.y +
+        static_cast<int32_t>(std::ceil((viewportRect.y + viewportRect.height) * parentHeight));
+    return Math::RectInt(left, top, right - left, bottom - top);
+}
+
+inline bool BuildCameraRenderRequest(
+    const Components::Scene& scene,
+    Components::CameraComponent& camera,
+    const RenderContext& context,
+    const RenderSurface& surface,
+    size_t renderedBaseCameraCount,
+    size_t renderedRequestCount,
+    CameraRenderRequest& request) {
+    request = {};
+    request.scene = &scene;
+    request.camera = &camera;
+    request.context = context;
+    request.surface = surface;
+    request.surface.SetRenderArea(ResolveCameraRenderArea(camera, surface));
+    request.cameraDepth = camera.GetDepth();
+    request.cameraStackOrder = static_cast<uint8_t>(camera.GetStackType());
+    request.clearFlags = ResolveClearFlags(camera, renderedBaseCameraCount, renderedRequestCount);
+
+    return request.surface.GetRenderAreaWidth() > 0 &&
+           request.surface.GetRenderAreaHeight() > 0;
+}
+
+} // namespace SceneRenderRequestUtils
+} // namespace Rendering
+} // namespace XCEngine

engine/src/Rendering/SceneRenderer.cpp

@@ -1,78 +1,14 @@
 #include "Rendering/SceneRenderer.h"
+#include "Rendering/SceneRenderRequestUtils.h"
 
-#include "Components/CameraComponent.h"
 #include "Components/GameObject.h"
 #include "Scene/Scene.h"
 
 #include <algorithm>
-#include <cmath>
 
 namespace XCEngine {
 namespace Rendering {
 
-namespace {
-
-bool CompareCameraRenderRequest(const CameraRenderRequest& lhs, const CameraRenderRequest& rhs) {
-    if (lhs.cameraStackOrder != rhs.cameraStackOrder) {
-        return lhs.cameraStackOrder < rhs.cameraStackOrder;
-    }
-
-    if (lhs.cameraDepth != rhs.cameraDepth) {
-        return lhs.cameraDepth < rhs.cameraDepth;
-    }
-
-    return false;
-}
-
-bool IsUsableCamera(const Components::CameraComponent* camera) {
-    return camera != nullptr &&
-           camera->IsEnabled() &&
-           camera->GetGameObject() != nullptr &&
-           camera->GetGameObject()->IsActiveInHierarchy();
-}
-
-RenderClearFlags ResolveClearFlags(
-    const Components::CameraComponent& camera,
-    size_t renderedBaseCameraCount,
-    size_t renderedRequestCount) {
-    switch (camera.GetClearMode()) {
-        case Components::CameraClearMode::ColorAndDepth:
-            return RenderClearFlags::All;
-        case Components::CameraClearMode::DepthOnly:
-            return RenderClearFlags::Depth;
-        case Components::CameraClearMode::None:
-            return RenderClearFlags::None;
-        case Components::CameraClearMode::Auto:
-        default:
-            if (camera.GetStackType() == Components::CameraStackType::Overlay) {
-                return renderedRequestCount == 0 ? RenderClearFlags::All : RenderClearFlags::Depth;
-            }
-
-            return renderedBaseCameraCount == 0 ? RenderClearFlags::All : RenderClearFlags::Depth;
-    }
-}
-
-Math::RectInt ResolveCameraRenderArea(
-    const Components::CameraComponent& camera,
-    const RenderSurface& surface) {
-    const Math::Rect viewportRect = camera.GetViewportRect();
-    const Math::RectInt parentRenderArea = surface.GetRenderArea();
-    const float parentWidth = static_cast<float>(std::max(parentRenderArea.width, 0));
-    const float parentHeight = static_cast<float>(std::max(parentRenderArea.height, 0));
-
-    const int32_t left = parentRenderArea.x +
-        static_cast<int32_t>(std::floor(viewportRect.x * parentWidth));
-    const int32_t top = parentRenderArea.y +
-        static_cast<int32_t>(std::floor(viewportRect.y * parentHeight));
-    const int32_t right = parentRenderArea.x +
-        static_cast<int32_t>(std::ceil((viewportRect.x + viewportRect.width) * parentWidth));
-    const int32_t bottom = parentRenderArea.y +
-        static_cast<int32_t>(std::ceil((viewportRect.y + viewportRect.height) * parentHeight));
-    return Math::RectInt(left, top, right - left, bottom - top);
-}
-
-} // namespace
-
 SceneRenderer::SceneRenderer() = default;
 
 SceneRenderer::SceneRenderer(std::unique_ptr<RenderPipeline> pipeline)
@@ -99,7 +35,7 @@ std::vector<CameraRenderRequest> SceneRenderer::BuildRenderRequests(
     std::vector<CameraRenderRequest> requests;
 
     std::vector<Components::CameraComponent*> cameras;
-    if (IsUsableCamera(overrideCamera)) {
+    if (SceneRenderRequestUtils::IsUsableCamera(overrideCamera)) {
         cameras.push_back(overrideCamera);
     } else {
         cameras = scene.FindObjectsOfType<Components::CameraComponent>();
@@ -108,40 +44,24 @@ std::vector<CameraRenderRequest> SceneRenderer::BuildRenderRequests(
                 cameras.begin(),
                 cameras.end(),
                 [](const Components::CameraComponent* camera) {
-                    return !IsUsableCamera(camera);
+                    return !SceneRenderRequestUtils::IsUsableCamera(camera);
                 }),
             cameras.end());
     }
 
-    std::stable_sort(
+    SceneRenderRequestUtils::SortSceneCamerasForRendering(cameras);
-        cameras.begin(),
-        cameras.end(),
-        [](const Components::CameraComponent* lhs, const Components::CameraComponent* rhs) {
-            if (lhs->GetStackType() != rhs->GetStackType()) {
-                return static_cast<int>(lhs->GetStackType()) < static_cast<int>(rhs->GetStackType());
-            }
-
-            if (lhs->GetDepth() != rhs->GetDepth()) {
-                return lhs->GetDepth() < rhs->GetDepth();
-            }
-
-            return false;
-        });
 
     size_t renderedBaseCameraCount = 0;
     for (Components::CameraComponent* camera : cameras) {
-
         CameraRenderRequest request;
-        request.scene = &scene;
+        if (SceneRenderRequestUtils::BuildCameraRenderRequest(
-        request.camera = camera;
+                scene,
-        request.context = context;
+                *camera,
-        request.surface = surface;
+                context,
-        request.surface.SetRenderArea(ResolveCameraRenderArea(*camera, surface));
+                surface,
-        request.cameraDepth = camera->GetDepth();
+                renderedBaseCameraCount,
-        request.cameraStackOrder = static_cast<uint8_t>(camera->GetStackType());
+                requests.size(),
-        request.clearFlags = ResolveClearFlags(*camera, renderedBaseCameraCount, requests.size());
+                request)) {
-        if (request.surface.GetRenderAreaWidth() > 0 &&
-            request.surface.GetRenderAreaHeight() > 0) {
             requests.push_back(request);
             if (camera->GetStackType() == Components::CameraStackType::Base) {
                 ++renderedBaseCameraCount;
@@ -168,10 +88,7 @@ bool SceneRenderer::Render(const std::vector<CameraRenderRequest>& requests) {
     }
 
     std::vector<CameraRenderRequest> sortedRequests = requests;
-    std::stable_sort(
+    SceneRenderRequestUtils::SortCameraRenderRequests(sortedRequests);
-        sortedRequests.begin(),
-        sortedRequests.end(),
-        CompareCameraRenderRequest);
 
     bool rendered = false;
     for (const CameraRenderRequest& request : sortedRequests) {

tests/Rendering/unit/CMakeLists.txt

@@ -7,6 +7,7 @@ set(RENDERING_UNIT_TEST_SOURCES
     test_builtin_forward_pipeline.cpp
     test_builtin_scene_view_post_pass_plan.cpp
     test_camera_scene_renderer.cpp
+    test_scene_render_request_utils.cpp
     test_render_scene_utility.cpp
     test_render_scene_extractor.cpp
 )

tests/Rendering/unit/test_scene_render_request_utils.cpp

@@ -0,0 +1,213 @@
+#include <gtest/gtest.h>
+
+#include <XCEngine/Components/CameraComponent.h>
+#include <XCEngine/Rendering/SceneRenderRequestUtils.h>
+#include <XCEngine/Scene/Scene.h>
+
+#include <vector>
+
+using namespace XCEngine::Components;
+using namespace XCEngine::Rendering;
+
+namespace {
+
+RenderContext CreateValidContext() {
+    RenderContext context;
+    context.device = reinterpret_cast<XCEngine::RHI::RHIDevice*>(1);
+    context.commandList = reinterpret_cast<XCEngine::RHI::RHICommandList*>(1);
+    context.commandQueue = reinterpret_cast<XCEngine::RHI::RHICommandQueue*>(1);
+    return context;
+}
+
+} // namespace
+
+TEST(SceneRenderRequestUtils_Test, RejectsNullDisabledAndInactiveCameras) {
+    Scene scene("SceneRenderRequestUtilsUsableCameraScene");
+
+    GameObject* activeObject = scene.CreateGameObject("ActiveCamera");
+    auto* activeCamera = activeObject->AddComponent<CameraComponent>();
+
+    GameObject* disabledObject = scene.CreateGameObject("DisabledCamera");
+    auto* disabledCamera = disabledObject->AddComponent<CameraComponent>();
+    disabledCamera->SetEnabled(false);
+
+    GameObject* inactiveObject = scene.CreateGameObject("InactiveCamera");
+    auto* inactiveCamera = inactiveObject->AddComponent<CameraComponent>();
+    inactiveObject->SetActive(false);
+
+    EXPECT_FALSE(SceneRenderRequestUtils::IsUsableCamera(nullptr));
+    EXPECT_TRUE(SceneRenderRequestUtils::IsUsableCamera(activeCamera));
+    EXPECT_FALSE(SceneRenderRequestUtils::IsUsableCamera(disabledCamera));
+    EXPECT_FALSE(SceneRenderRequestUtils::IsUsableCamera(inactiveCamera));
+}
+
+TEST(SceneRenderRequestUtils_Test, SortsSceneCamerasByStackDepthAndKeepsStableTieOrder) {
+    Scene scene("SceneRenderRequestUtilsSortSceneCameras");
+
+    GameObject* lateBaseObject = scene.CreateGameObject("LateBase");
+    auto* lateBase = lateBaseObject->AddComponent<CameraComponent>();
+    lateBase->SetDepth(10.0f);
+    lateBase->SetStackType(CameraStackType::Base);
+
+    GameObject* firstTieObject = scene.CreateGameObject("FirstTie");
+    auto* firstTie = firstTieObject->AddComponent<CameraComponent>();
+    firstTie->SetDepth(2.0f);
+    firstTie->SetStackType(CameraStackType::Base);
+
+    GameObject* secondTieObject = scene.CreateGameObject("SecondTie");
+    auto* secondTie = secondTieObject->AddComponent<CameraComponent>();
+    secondTie->SetDepth(2.0f);
+    secondTie->SetStackType(CameraStackType::Base);
+
+    GameObject* overlayObject = scene.CreateGameObject("Overlay");
+    auto* overlay = overlayObject->AddComponent<CameraComponent>();
+    overlay->SetDepth(-50.0f);
+    overlay->SetStackType(CameraStackType::Overlay);
+
+    std::vector<CameraComponent*> cameras = { overlay, lateBase, secondTie, firstTie };
+    SceneRenderRequestUtils::SortSceneCamerasForRendering(cameras);
+
+    ASSERT_EQ(cameras.size(), 4u);
+    EXPECT_EQ(cameras[0], secondTie);
+    EXPECT_EQ(cameras[1], firstTie);
+    EXPECT_EQ(cameras[2], lateBase);
+    EXPECT_EQ(cameras[3], overlay);
+}
+
+TEST(SceneRenderRequestUtils_Test, SortsRequestsByPriorityAndKeepsStableTieOrder) {
+    Scene scene("SceneRenderRequestUtilsSortRequests");
+
+    GameObject* firstObject = scene.CreateGameObject("First");
+    auto* firstCamera = firstObject->AddComponent<CameraComponent>();
+
+    GameObject* secondObject = scene.CreateGameObject("Second");
+    auto* secondCamera = secondObject->AddComponent<CameraComponent>();
+
+    CameraRenderRequest overlayRequest;
+    overlayRequest.scene = &scene;
+    overlayRequest.camera = secondCamera;
+    overlayRequest.context = CreateValidContext();
+    overlayRequest.surface = RenderSurface(320, 180);
+    overlayRequest.cameraDepth = 100.0f;
+    overlayRequest.cameraStackOrder = 1;
+
+    CameraRenderRequest secondTieRequest = overlayRequest;
+    secondTieRequest.camera = secondCamera;
+    secondTieRequest.cameraDepth = 5.0f;
+    secondTieRequest.cameraStackOrder = 0;
+
+    CameraRenderRequest firstTieRequest = overlayRequest;
+    firstTieRequest.camera = firstCamera;
+    firstTieRequest.cameraDepth = 5.0f;
+    firstTieRequest.cameraStackOrder = 0;
+
+    std::vector<CameraRenderRequest> requests = { overlayRequest, secondTieRequest, firstTieRequest };
+    SceneRenderRequestUtils::SortCameraRenderRequests(requests);
+
+    ASSERT_EQ(requests.size(), 3u);
+    EXPECT_EQ(requests[0].camera, secondCamera);
+    EXPECT_EQ(requests[1].camera, firstCamera);
+    EXPECT_EQ(requests[2].camera, secondCamera);
+    EXPECT_EQ(requests[2].cameraStackOrder, 1u);
+}
+
+TEST(SceneRenderRequestUtils_Test, ResolvesClearFlagsForExplicitAndAutoModes) {
+    Scene scene("SceneRenderRequestUtilsClearFlags");
+
+    GameObject* baseObject = scene.CreateGameObject("Base");
+    auto* baseCamera = baseObject->AddComponent<CameraComponent>();
+    baseCamera->SetStackType(CameraStackType::Base);
+
+    GameObject* overlayObject = scene.CreateGameObject("Overlay");
+    auto* overlayCamera = overlayObject->AddComponent<CameraComponent>();
+    overlayCamera->SetStackType(CameraStackType::Overlay);
+
+    baseCamera->SetClearMode(CameraClearMode::ColorAndDepth);
+    EXPECT_EQ(
+        SceneRenderRequestUtils::ResolveClearFlags(*baseCamera, 0u, 0u),
+        RenderClearFlags::All);
+
+    baseCamera->SetClearMode(CameraClearMode::DepthOnly);
+    EXPECT_EQ(
+        SceneRenderRequestUtils::ResolveClearFlags(*baseCamera, 0u, 0u),
+        RenderClearFlags::Depth);
+
+    baseCamera->SetClearMode(CameraClearMode::None);
+    EXPECT_EQ(
+        SceneRenderRequestUtils::ResolveClearFlags(*baseCamera, 0u, 0u),
+        RenderClearFlags::None);
+
+    baseCamera->SetClearMode(CameraClearMode::Auto);
+    EXPECT_EQ(
+        SceneRenderRequestUtils::ResolveClearFlags(*baseCamera, 0u, 0u),
+        RenderClearFlags::All);
+    EXPECT_EQ(
+        SceneRenderRequestUtils::ResolveClearFlags(*baseCamera, 1u, 1u),
+        RenderClearFlags::Depth);
+
+    overlayCamera->SetClearMode(CameraClearMode::Auto);
+    EXPECT_EQ(
+        SceneRenderRequestUtils::ResolveClearFlags(*overlayCamera, 0u, 0u),
+        RenderClearFlags::All);
+    EXPECT_EQ(
+        SceneRenderRequestUtils::ResolveClearFlags(*overlayCamera, 0u, 1u),
+        RenderClearFlags::Depth);
+}
+
+TEST(SceneRenderRequestUtils_Test, ComposesCameraViewportWithinNestedSurfaceRenderArea) {
+    Scene scene("SceneRenderRequestUtilsViewport");
+
+    GameObject* cameraObject = scene.CreateGameObject("Camera");
+    auto* camera = cameraObject->AddComponent<CameraComponent>();
+    camera->SetViewportRect(XCEngine::Math::Rect(0.25f, 0.1f, 0.5f, 0.4f));
+
+    RenderSurface surface(800, 600);
+    surface.SetRenderArea(XCEngine::Math::RectInt(100, 50, 400, 300));
+
+    const XCEngine::Math::RectInt renderArea =
+        SceneRenderRequestUtils::ResolveCameraRenderArea(*camera, surface);
+    EXPECT_EQ(renderArea.x, 200);
+    EXPECT_EQ(renderArea.y, 80);
+    EXPECT_EQ(renderArea.width, 200);
+    EXPECT_EQ(renderArea.height, 120);
+}
+
+TEST(SceneRenderRequestUtils_Test, BuildsRequestMetadataAndRejectsZeroSizedRenderAreas) {
+    Scene scene("SceneRenderRequestUtilsBuildRequest");
+
+    GameObject* cameraObject = scene.CreateGameObject("Camera");
+    auto* camera = cameraObject->AddComponent<CameraComponent>();
+    camera->SetDepth(3.0f);
+    camera->SetStackType(CameraStackType::Overlay);
+    camera->SetClearMode(CameraClearMode::Auto);
+    camera->SetViewportRect(XCEngine::Math::Rect(0.25f, 0.5f, 0.5f, 0.25f));
+
+    CameraRenderRequest request;
+    ASSERT_TRUE(SceneRenderRequestUtils::BuildCameraRenderRequest(
+        scene,
+        *camera,
+        CreateValidContext(),
+        RenderSurface(800, 600),
+        1u,
+        1u,
+        request));
+    EXPECT_EQ(request.scene, &scene);
+    EXPECT_EQ(request.camera, camera);
+    EXPECT_FLOAT_EQ(request.cameraDepth, 3.0f);
+    EXPECT_EQ(request.cameraStackOrder, 1u);
+    EXPECT_EQ(request.clearFlags, RenderClearFlags::Depth);
+    EXPECT_EQ(request.surface.GetRenderArea().x, 200);
+    EXPECT_EQ(request.surface.GetRenderArea().y, 300);
+    EXPECT_EQ(request.surface.GetRenderArea().width, 400);
+    EXPECT_EQ(request.surface.GetRenderArea().height, 150);
+
+    camera->SetViewportRect(XCEngine::Math::Rect(0.5f, 0.5f, 0.0f, 1.0f));
+    EXPECT_FALSE(SceneRenderRequestUtils::BuildCameraRenderRequest(
+        scene,
+        *camera,
+        CreateValidContext(),
+        RenderSurface(800, 600),
+        0u,
+        0u,
+        request));
+}