XCEngine/tests/Rendering/unit/test_camera_scene_renderer.cpp

#include <gtest/gtest.h>

#include <XCEngine/Components/CameraComponent.h>
#include <XCEngine/Rendering/CameraRenderer.h>
#include <XCEngine/Rendering/RenderSurface.h>
#include <XCEngine/Rendering/SceneRenderer.h>
#include <XCEngine/Scene/Scene.h>

#include <memory>
#include <string>
#include <vector>

using namespace XCEngine::Components;
using namespace XCEngine::Rendering;

namespace {

struct MockPipelineState {
    int initializeCalls = 0;
    int shutdownCalls = 0;
    int renderCalls = 0;
    uint32_t lastSurfaceWidth = 0;
    uint32_t lastSurfaceHeight = 0;
    CameraComponent* lastCamera = nullptr;
    size_t lastVisibleItemCount = 0;
    RenderClearFlags lastClearFlags = RenderClearFlags::All;
    std::vector<CameraComponent*> renderedCameras;
    std::vector<RenderClearFlags> renderedClearFlags;
    std::vector<std::string> eventLog;
};

class MockPipeline final : public RenderPipeline {
public:
    explicit MockPipeline(std::shared_ptr<MockPipelineState> state)
        : m_state(std::move(state)) {
    }

    bool Initialize(const RenderContext&) override {
        ++m_state->initializeCalls;
        return true;
    }

    void Shutdown() override {
        ++m_state->shutdownCalls;
    }

    bool Render(
        const RenderContext&,
        const RenderSurface& surface,
        const RenderSceneData& sceneData) override {
        m_state->eventLog.push_back("pipeline");
        ++m_state->renderCalls;
        m_state->lastSurfaceWidth = surface.GetWidth();
        m_state->lastSurfaceHeight = surface.GetHeight();
        m_state->lastCamera = sceneData.camera;
        m_state->lastVisibleItemCount = sceneData.visibleItems.size();
        m_state->lastClearFlags = sceneData.cameraData.clearFlags;
        m_state->renderedCameras.push_back(sceneData.camera);
        m_state->renderedClearFlags.push_back(sceneData.cameraData.clearFlags);
        return true;
    }

private:
    std::shared_ptr<MockPipelineState> m_state;
};

class TrackingPass final : public RenderPass {
public:
    TrackingPass(std::shared_ptr<MockPipelineState> state, const char* label)
        : m_state(std::move(state))
        , m_label(label) {
    }

    const char* GetName() const override {
        return m_label;
    }

    bool Initialize(const RenderContext&) override {
        m_state->eventLog.push_back(std::string("init:") + m_label);
        return true;
    }

    bool Execute(const RenderPassContext&) override {
        m_state->eventLog.push_back(m_label);
        return true;
    }

private:
    std::shared_ptr<MockPipelineState> m_state;
    const char* m_label = "";
};

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(CameraRenderer_Test, UsesOverrideCameraAndSurfaceSizeWhenSubmittingScene) {
    Scene scene("CameraRendererScene");

    GameObject* primaryCameraObject = scene.CreateGameObject("PrimaryCamera");
    auto* primaryCamera = primaryCameraObject->AddComponent<CameraComponent>();
    primaryCamera->SetPrimary(true);
    primaryCamera->SetDepth(10.0f);

    GameObject* overrideCameraObject = scene.CreateGameObject("OverrideCamera");
    auto* overrideCamera = overrideCameraObject->AddComponent<CameraComponent>();
    overrideCamera->SetPrimary(false);
    overrideCamera->SetDepth(-1.0f);

    auto state = std::make_shared<MockPipelineState>();
    CameraRenderer renderer(std::make_unique<MockPipeline>(state));

    CameraRenderRequest request;
    request.scene = &scene;
    request.camera = overrideCamera;
    request.context = CreateValidContext();
    request.surface = RenderSurface(640, 480);
    request.cameraDepth = overrideCamera->GetDepth();
    request.clearFlags = RenderClearFlags::None;

    ASSERT_TRUE(renderer.Render(request));
    EXPECT_EQ(state->renderCalls, 1);
    EXPECT_EQ(state->lastSurfaceWidth, 640u);
    EXPECT_EQ(state->lastSurfaceHeight, 480u);
    EXPECT_EQ(state->lastCamera, overrideCamera);
    EXPECT_NE(state->lastCamera, primaryCamera);
    EXPECT_EQ(state->lastVisibleItemCount, 0u);
    EXPECT_EQ(state->lastClearFlags, RenderClearFlags::None);
}

TEST(CameraRenderer_Test, ExecutesInjectedPreAndPostPassSequencesAroundPipelineRender) {
    Scene scene("CameraRendererPassScene");

    GameObject* cameraObject = scene.CreateGameObject("Camera");
    auto* camera = cameraObject->AddComponent<CameraComponent>();
    camera->SetPrimary(true);
    camera->SetDepth(3.0f);

    auto state = std::make_shared<MockPipelineState>();
    CameraRenderer renderer(std::make_unique<MockPipeline>(state));

    RenderPassSequence prePasses;
    prePasses.AddPass(std::make_unique<TrackingPass>(state, "pre"));

    RenderPassSequence postPasses;
    postPasses.AddPass(std::make_unique<TrackingPass>(state, "post"));

    CameraRenderRequest request;
    request.scene = &scene;
    request.camera = camera;
    request.context = CreateValidContext();
    request.surface = RenderSurface(320, 180);
    request.cameraDepth = camera->GetDepth();
    request.preScenePasses = &prePasses;
    request.postScenePasses = &postPasses;

    ASSERT_TRUE(renderer.Render(request));
    EXPECT_EQ(
        state->eventLog,
        (std::vector<std::string>{ "init:pre", "pre", "pipeline", "init:post", "post" }));
}

TEST(SceneRenderer_Test, BuildsSingleExplicitRequestFromSelectedCamera) {
    Scene scene("SceneRendererRequestScene");

    GameObject* lowCameraObject = scene.CreateGameObject("LowCamera");
    auto* lowCamera = lowCameraObject->AddComponent<CameraComponent>();
    lowCamera->SetPrimary(true);
    lowCamera->SetDepth(1.0f);

    GameObject* highCameraObject = scene.CreateGameObject("HighCamera");
    auto* highCamera = highCameraObject->AddComponent<CameraComponent>();
    highCamera->SetPrimary(true);
    highCamera->SetDepth(5.0f);

    SceneRenderer renderer;
    const RenderContext context = CreateValidContext();
    const RenderSurface surface(320, 180);

    const std::vector<CameraRenderRequest> defaultRequests =
        renderer.BuildRenderRequests(scene, nullptr, context, surface);
    ASSERT_EQ(defaultRequests.size(), 1u);
    EXPECT_EQ(defaultRequests[0].camera, highCamera);
    EXPECT_EQ(defaultRequests[0].cameraDepth, 5.0f);
    EXPECT_EQ(defaultRequests[0].clearFlags, RenderClearFlags::All);
    EXPECT_EQ(defaultRequests[0].surface.GetWidth(), 320u);
    EXPECT_EQ(defaultRequests[0].surface.GetHeight(), 180u);

    const std::vector<CameraRenderRequest> overrideRequests =
        renderer.BuildRenderRequests(scene, lowCamera, context, surface);
    ASSERT_EQ(overrideRequests.size(), 1u);
    EXPECT_EQ(overrideRequests[0].camera, lowCamera);
}

TEST(SceneRenderer_Test, ForwardsPipelineLifetimeAndRenderCallsToCameraRenderer) {
    Scene scene("SceneRendererScene");

    GameObject* cameraObject = scene.CreateGameObject("Camera");
    auto* camera = cameraObject->AddComponent<CameraComponent>();
    camera->SetPrimary(true);
    camera->SetDepth(2.0f);

    auto initialState = std::make_shared<MockPipelineState>();
    auto replacementState = std::make_shared<MockPipelineState>();

    {
        auto initialPipeline = std::make_unique<MockPipeline>(initialState);
        MockPipeline* initialPipelineRaw = initialPipeline.get();
        SceneRenderer renderer(std::move(initialPipeline));
        EXPECT_EQ(renderer.GetPipeline(), initialPipelineRaw);

        auto replacementPipeline = std::make_unique<MockPipeline>(replacementState);
        MockPipeline* replacementPipelineRaw = replacementPipeline.get();
        renderer.SetPipeline(std::move(replacementPipeline));

        EXPECT_EQ(initialState->shutdownCalls, 1);
        EXPECT_EQ(renderer.GetPipeline(), replacementPipelineRaw);

        const RenderSurface surface(800, 600);
        ASSERT_TRUE(renderer.Render(scene, nullptr, CreateValidContext(), surface));
        EXPECT_EQ(replacementState->renderCalls, 1);
        EXPECT_EQ(replacementState->lastSurfaceWidth, 800u);
        EXPECT_EQ(replacementState->lastSurfaceHeight, 600u);
        EXPECT_EQ(replacementState->lastCamera, camera);
    }

    EXPECT_EQ(initialState->shutdownCalls, 1);
    EXPECT_EQ(replacementState->shutdownCalls, 1);
}

TEST(SceneRenderer_Test, SortsManualCameraRequestsByDepthBeforeRendering) {
    Scene scene("SceneRendererManualRequests");

    GameObject* farCameraObject = scene.CreateGameObject("FarCamera");
    auto* farCamera = farCameraObject->AddComponent<CameraComponent>();
    farCamera->SetPrimary(true);
    farCamera->SetDepth(10.0f);

    GameObject* nearCameraObject = scene.CreateGameObject("NearCamera");
    auto* nearCamera = nearCameraObject->AddComponent<CameraComponent>();
    nearCamera->SetPrimary(false);
    nearCamera->SetDepth(1.0f);

    auto state = std::make_shared<MockPipelineState>();
    SceneRenderer renderer(std::make_unique<MockPipeline>(state));

    CameraRenderRequest farRequest;
    farRequest.scene = &scene;
    farRequest.camera = farCamera;
    farRequest.context = CreateValidContext();
    farRequest.surface = RenderSurface(800, 600);
    farRequest.cameraDepth = farCamera->GetDepth();
    farRequest.clearFlags = RenderClearFlags::None;

    CameraRenderRequest nearRequest = farRequest;
    nearRequest.camera = nearCamera;
    nearRequest.cameraDepth = nearCamera->GetDepth();
    nearRequest.clearFlags = RenderClearFlags::Depth;

    const std::vector<CameraRenderRequest> requests = { farRequest, nearRequest };
    ASSERT_TRUE(renderer.Render(requests));
    ASSERT_EQ(state->renderedCameras.size(), 2u);
    ASSERT_EQ(state->renderedClearFlags.size(), 2u);
    EXPECT_EQ(state->renderedCameras[0], nearCamera);
    EXPECT_EQ(state->renderedClearFlags[0], RenderClearFlags::Depth);
    EXPECT_EQ(state->renderedCameras[1], farCamera);
    EXPECT_EQ(state->renderedClearFlags[1], RenderClearFlags::None);
}