XCEngine/tests/Rendering/unit/test_render_scene_extractor.cpp

#include <gtest/gtest.h>

#include <XCEngine/Components/CameraComponent.h>
#include <XCEngine/Components/GameObject.h>
#include <XCEngine/Components/MeshFilterComponent.h>
#include <XCEngine/Components/MeshRendererComponent.h>
#include <XCEngine/Core/Asset/IResource.h>
#include <XCEngine/Core/Math/Vector3.h>
#include <XCEngine/Rendering/RenderMaterialUtility.h>
#include <XCEngine/Rendering/RenderSceneExtractor.h>
#include <XCEngine/Resources/Material/Material.h>
#include <XCEngine/Resources/Mesh/Mesh.h>
#include <XCEngine/Scene/Scene.h>

using namespace XCEngine::Components;
using namespace XCEngine::Core;
using namespace XCEngine::Math;
using namespace XCEngine::Rendering;
using namespace XCEngine::Resources;

namespace {

Mesh* CreateTestMesh(const char* path) {
    auto* mesh = new Mesh();
    IResource::ConstructParams params = {};
    params.name = "TestMesh";
    params.path = path;
    params.guid = ResourceGUID::Generate(path);
    mesh->Initialize(params);
    return mesh;
}

Mesh* CreateSectionedTestMesh(const char* path, std::initializer_list<uint32_t> materialIds) {
    Mesh* mesh = CreateTestMesh(path);
    uint32_t startIndex = 0;
    for (uint32_t materialId : materialIds) {
        MeshSection section = {};
        section.baseVertex = 0;
        section.vertexCount = 3;
        section.startIndex = startIndex;
        section.indexCount = 3;
        section.materialID = materialId;
        mesh->AddSection(section);
        startIndex += 3;
    }

    return mesh;
}

Material* CreateTestMaterial(const char* path, int32_t renderQueue, const char* shaderPass = nullptr, const char* lightMode = nullptr) {
    auto* material = new Material();
    IResource::ConstructParams params = {};
    params.name = "TestMaterial";
    params.path = path;
    params.guid = ResourceGUID::Generate(path);
    material->Initialize(params);
    material->SetRenderQueue(renderQueue);
    if (shaderPass != nullptr) {
        material->SetShaderPass(shaderPass);
    }
    if (lightMode != nullptr) {
        material->SetTag("LightMode", lightMode);
    }
    return material;
}

TEST(RenderSceneExtractor_Test, SelectsHighestDepthPrimaryCameraAndVisibleObjects) {
    Scene scene("RenderScene");

    GameObject* cameraObjectA = scene.CreateGameObject("CameraA");
    auto* cameraA = cameraObjectA->AddComponent<CameraComponent>();
    cameraA->SetPrimary(true);
    cameraA->SetDepth(0.0f);

    GameObject* cameraObjectB = scene.CreateGameObject("CameraB");
    auto* cameraB = cameraObjectB->AddComponent<CameraComponent>();
    cameraB->SetPrimary(true);
    cameraB->SetDepth(5.0f);
    cameraObjectB->GetTransform()->SetLocalPosition(Vector3(2.0f, 3.0f, 4.0f));

    GameObject* visibleObject = scene.CreateGameObject("VisibleQuad");
    visibleObject->GetTransform()->SetLocalPosition(Vector3(1.0f, 2.0f, 3.0f));
    auto* meshFilter = visibleObject->AddComponent<MeshFilterComponent>();
    visibleObject->AddComponent<MeshRendererComponent>();
    Mesh* visibleMesh = CreateTestMesh("Meshes/visible.mesh");
    meshFilter->SetMesh(visibleMesh);

    GameObject* hiddenObject = scene.CreateGameObject("HiddenQuad");
    hiddenObject->SetActive(false);
    auto* hiddenMeshFilter = hiddenObject->AddComponent<MeshFilterComponent>();
    hiddenObject->AddComponent<MeshRendererComponent>();
    Mesh* hiddenMesh = CreateTestMesh("Meshes/hidden.mesh");
    hiddenMeshFilter->SetMesh(hiddenMesh);

    RenderSceneExtractor extractor;
    const RenderSceneData sceneData = extractor.Extract(scene, nullptr, 1280, 720);

    ASSERT_TRUE(sceneData.HasCamera());
    EXPECT_EQ(sceneData.camera, cameraB);
    EXPECT_EQ(sceneData.cameraData.viewportWidth, 1280u);
    EXPECT_EQ(sceneData.cameraData.viewportHeight, 720u);
    EXPECT_EQ(sceneData.cameraData.worldPosition, Vector3(2.0f, 3.0f, 4.0f));

    ASSERT_EQ(sceneData.visibleItems.size(), 1u);
    EXPECT_EQ(sceneData.visibleItems[0].gameObject, visibleObject);
    EXPECT_EQ(sceneData.visibleItems[0].mesh, visibleMesh);
    EXPECT_EQ(sceneData.visibleItems[0].localToWorld.GetTranslation(), Vector3(1.0f, 2.0f, 3.0f));
    EXPECT_FALSE(sceneData.visibleItems[0].hasSection);
    EXPECT_EQ(sceneData.visibleItems[0].renderQueue, static_cast<int32_t>(MaterialRenderQueue::Geometry));

    meshFilter->ClearMesh();
    hiddenMeshFilter->ClearMesh();
    delete visibleMesh;
    delete hiddenMesh;
}

TEST(RenderSceneExtractor_Test, OverrideCameraTakesPriority) {
    Scene scene("OverrideScene");

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

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

    RenderSceneExtractor extractor;
    const RenderSceneData sceneData = extractor.Extract(scene, overrideCamera, 640, 480);

    ASSERT_TRUE(sceneData.HasCamera());
    EXPECT_EQ(sceneData.camera, overrideCamera);
    EXPECT_NE(sceneData.camera, primaryCamera);
    EXPECT_EQ(sceneData.cameraData.viewportWidth, 640u);
    EXPECT_EQ(sceneData.cameraData.viewportHeight, 480u);
}

TEST(RenderSceneExtractor_Test, ExtractsSectionLevelVisibleItemsAndSortsByRenderQueue) {
    Scene scene("SectionScene");

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

    GameObject* renderObject = scene.CreateGameObject("MultiSectionMesh");
    renderObject->GetTransform()->SetLocalPosition(Vector3(0.0f, 0.0f, 5.0f));
    auto* meshFilter = renderObject->AddComponent<MeshFilterComponent>();
    auto* meshRenderer = renderObject->AddComponent<MeshRendererComponent>();

    Mesh* mesh = CreateSectionedTestMesh("Meshes/sectioned.mesh", { 1u, 0u });
    Material* opaqueMaterial = CreateTestMaterial(
        "Materials/opaque.mat",
        static_cast<int32_t>(MaterialRenderQueue::Geometry),
        "ForwardLit",
        "ForwardBase");
    Material* transparentMaterial = CreateTestMaterial(
        "Materials/transparent.mat",
        static_cast<int32_t>(MaterialRenderQueue::Transparent),
        "ForwardLit",
        "ForwardBase");

    meshFilter->SetMesh(mesh);
    meshRenderer->SetMaterial(0, opaqueMaterial);
    meshRenderer->SetMaterial(1, transparentMaterial);

    RenderSceneExtractor extractor;
    const RenderSceneData sceneData = extractor.Extract(scene, nullptr, 800, 600);

    ASSERT_TRUE(sceneData.HasCamera());
    ASSERT_EQ(sceneData.visibleItems.size(), 2u);

    EXPECT_TRUE(sceneData.visibleItems[0].hasSection);
    EXPECT_EQ(sceneData.visibleItems[0].sectionIndex, 1u);
    EXPECT_EQ(sceneData.visibleItems[0].materialIndex, 0u);
    EXPECT_EQ(sceneData.visibleItems[0].material, opaqueMaterial);
    EXPECT_EQ(sceneData.visibleItems[0].renderQueue, static_cast<int32_t>(MaterialRenderQueue::Geometry));

    EXPECT_TRUE(sceneData.visibleItems[1].hasSection);
    EXPECT_EQ(sceneData.visibleItems[1].sectionIndex, 0u);
    EXPECT_EQ(sceneData.visibleItems[1].materialIndex, 1u);
    EXPECT_EQ(sceneData.visibleItems[1].material, transparentMaterial);
    EXPECT_EQ(sceneData.visibleItems[1].renderQueue, static_cast<int32_t>(MaterialRenderQueue::Transparent));

    meshRenderer->ClearMaterials();
    meshFilter->ClearMesh();
    delete opaqueMaterial;
    delete transparentMaterial;
    delete mesh;
}

TEST(RenderSceneExtractor_Test, SortsOpaqueFrontToBackAndTransparentBackToFront) {
    Scene scene("QueueSortScene");

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

    auto createRenderable = [&](const char* name, float z, int32_t renderQueue) -> Mesh* {
        GameObject* object = scene.CreateGameObject(name);
        object->GetTransform()->SetLocalPosition(Vector3(0.0f, 0.0f, z));
        auto* meshFilter = object->AddComponent<MeshFilterComponent>();
        auto* meshRenderer = object->AddComponent<MeshRendererComponent>();
        Mesh* mesh = CreateTestMesh(name);
        Material* material = CreateTestMaterial(name, renderQueue, "ForwardLit", "ForwardBase");
        meshFilter->SetMesh(mesh);
        meshRenderer->SetMaterial(0, material);
        return mesh;
    };

    Mesh* opaqueFarMesh = createRenderable("OpaqueFar", 10.0f, static_cast<int32_t>(MaterialRenderQueue::Geometry));
    Mesh* transparentNearMesh = createRenderable("TransparentNear", 2.0f, static_cast<int32_t>(MaterialRenderQueue::Transparent));
    Mesh* opaqueNearMesh = createRenderable("OpaqueNear", 2.0f, static_cast<int32_t>(MaterialRenderQueue::Geometry));
    Mesh* transparentFarMesh = createRenderable("TransparentFar", 10.0f, static_cast<int32_t>(MaterialRenderQueue::Transparent));

    RenderSceneExtractor extractor;
    const RenderSceneData sceneData = extractor.Extract(scene, nullptr, 800, 600);

    ASSERT_EQ(sceneData.visibleItems.size(), 4u);
    EXPECT_STREQ(sceneData.visibleItems[0].gameObject->GetName().c_str(), "OpaqueNear");
    EXPECT_STREQ(sceneData.visibleItems[1].gameObject->GetName().c_str(), "OpaqueFar");
    EXPECT_STREQ(sceneData.visibleItems[2].gameObject->GetName().c_str(), "TransparentFar");
    EXPECT_STREQ(sceneData.visibleItems[3].gameObject->GetName().c_str(), "TransparentNear");

    auto cleanupObject = [](GameObject* object) {
        auto* meshFilter = object->GetComponent<MeshFilterComponent>();
        auto* meshRenderer = object->GetComponent<MeshRendererComponent>();
        Material* material = meshRenderer != nullptr ? meshRenderer->GetMaterial(0) : nullptr;
        if (meshRenderer != nullptr) {
            meshRenderer->ClearMaterials();
        }
        if (meshFilter != nullptr) {
            meshFilter->ClearMesh();
        }
        delete material;
    };

    cleanupObject(scene.Find("OpaqueFar"));
    cleanupObject(scene.Find("TransparentNear"));
    cleanupObject(scene.Find("OpaqueNear"));
    cleanupObject(scene.Find("TransparentFar"));

    delete opaqueFarMesh;
    delete transparentNearMesh;
    delete opaqueNearMesh;
    delete transparentFarMesh;
}

TEST(RenderMaterialUtility_Test, MatchesBuiltinForwardPassMetadata) {
    Material forwardMaterial;
    forwardMaterial.SetShaderPass("ForwardLit");
    forwardMaterial.SetTag("LightMode", "ForwardBase");
    EXPECT_TRUE(MatchesBuiltinPass(&forwardMaterial, BuiltinMaterialPass::Forward));

    Material noMetadataMaterial;
    EXPECT_TRUE(MatchesBuiltinPass(&noMetadataMaterial, BuiltinMaterialPass::Forward));

    Material shadowMaterial;
    shadowMaterial.SetShaderPass("ShadowCaster");
    EXPECT_FALSE(MatchesBuiltinPass(&shadowMaterial, BuiltinMaterialPass::Forward));

    Material depthOnlyMaterial;
    depthOnlyMaterial.SetTag("LightMode", "DepthOnly");
    EXPECT_FALSE(MatchesBuiltinPass(&depthOnlyMaterial, BuiltinMaterialPass::Forward));
}

} // namespace