XCEngine/tests/Rendering/integration/volume_transform_scene/main.cpp

#include <gtest/gtest.h>

#include "../VolumeIntegrationSceneFixture.h"

#include <XCEngine/Components/CameraComponent.h>
#include <XCEngine/Components/GameObject.h>
#include <XCEngine/Components/MeshFilterComponent.h>
#include <XCEngine/Components/MeshRendererComponent.h>
#include <XCEngine/Components/VolumeRendererComponent.h>
#include <XCEngine/Core/Math/Math.h>
#include <XCEngine/Core/Math/Quaternion.h>
#include <XCEngine/Core/Math/Vector3.h>
#include <XCEngine/Rendering/Extraction/RenderSceneExtractor.h>

using namespace VolumeIntegrationTestUtils;

namespace {

constexpr const char* kD3D12Screenshot = "volume_transform_scene_d3d12.ppm";
constexpr const char* kOpenGLScreenshot = "volume_transform_scene_opengl.ppm";
constexpr const char* kVulkanScreenshot = "volume_transform_scene_vulkan.ppm";

const char* GetScreenshotFilename(RHIType backendType) {
    switch (backendType) {
        case RHIType::OpenGL:
            return kOpenGLScreenshot;
        case RHIType::Vulkan:
            return kVulkanScreenshot;
        case RHIType::D3D12:
        default:
            return kD3D12Screenshot;
    }
}

class VolumeTransformSceneTest : public VolumeIntegrationSceneFixture {
protected:
    const char* GetSceneName() const override { return "VolumeTransformScene"; }

    void BuildScene() override {
        mVolumeMaterial = CreateVolumetricMaterial(
            "VolumeTransformMaterial",
            "Tests/Rendering/VolumeTransformScene/Volume.material",
            Vector4(0.98f, 0.99f, 1.0f, 1.0f),
            0.22f,
            0.75f,
            2400.0f,
            0.003f,
            Vector3(-0.28f, 0.91f, 0.31f),
            10.0f);
        ASSERT_NE(mVolumeMaterial, nullptr);

        mBackplateMaterial = CreateUnlitMaterial(
            "VolumeTransformBackplateMaterial",
            "Tests/Rendering/VolumeTransformScene/Backplate.material",
            Vector4(0.16f, 0.20f, 0.24f, 1.0f));
        ASSERT_NE(mBackplateMaterial, nullptr);

        mOriginMarkerMaterial = CreateUnlitMaterial(
            "VolumeTransformOriginMarkerMaterial",
            "Tests/Rendering/VolumeTransformScene/OriginMarker.material",
            Vector4(0.90f, 0.10f, 0.70f, 1.0f));
        ASSERT_NE(mOriginMarkerMaterial, nullptr);

        mVolumeField = LoadCloudVolumeField();
        ASSERT_NE(mVolumeField, nullptr);

        mCubeMesh = LoadBuiltinPrimitiveMesh(BuiltinPrimitiveType::Cube);
        ASSERT_TRUE(mCubeMesh.IsValid());

        GameObject* cameraObject = mScene->CreateGameObject("MainCamera");
        auto* camera = cameraObject->AddComponent<CameraComponent>();
        camera->SetPrimary(true);
        camera->SetFieldOfView(45.0f);
        camera->SetNearClipPlane(0.1f);
        camera->SetFarClipPlane(5000.0f);
        camera->SetClearColor(XCEngine::Math::Color(0.03f, 0.04f, 0.06f, 1.0f));
        cameraObject->GetTransform()->SetLocalPosition(Vector3(-120.0f, 320.0f, -1280.0f));
        cameraObject->GetTransform()->LookAt(Vector3(140.0f, 125.0f, 120.0f));

        GameObject* volumeObject = mScene->CreateGameObject("CloudVolume");
        volumeObject->GetTransform()->SetLocalPosition(Vector3(220.0f, 60.0f, 160.0f));
        volumeObject->GetTransform()->SetLocalRotation(Quaternion::FromEulerAngles(
            Vector3(-12.0f, 37.0f, 19.0f) * XCEngine::Math::DEG_TO_RAD));
        volumeObject->GetTransform()->SetLocalScale(Vector3(0.82f, 0.82f, 0.82f));
        auto* volumeRenderer = volumeObject->AddComponent<VolumeRendererComponent>();
        volumeRenderer->SetVolumeField(mVolumeField);
        volumeRenderer->SetMaterial(mVolumeMaterial);
        volumeRenderer->SetCastShadows(false);
        volumeRenderer->SetReceiveShadows(false);

        GameObject* backplateObject = mScene->CreateGameObject("Backplate");
        backplateObject->GetTransform()->SetLocalPosition(Vector3(230.0f, 115.0f, 650.0f));
        backplateObject->GetTransform()->SetLocalScale(Vector3(900.0f, 700.0f, 10.0f));
        auto* backplateMeshFilter = backplateObject->AddComponent<MeshFilterComponent>();
        auto* backplateMeshRenderer = backplateObject->AddComponent<MeshRendererComponent>();
        backplateMeshFilter->SetMesh(mCubeMesh);
        backplateMeshRenderer->SetMaterial(0, mBackplateMaterial);
        backplateMeshRenderer->SetCastShadows(false);
        backplateMeshRenderer->SetReceiveShadows(false);

        GameObject* originMarkerObject = mScene->CreateGameObject("OriginMarker");
        originMarkerObject->GetTransform()->SetLocalPosition(Vector3(-10.0f, 73.0f, 0.0f));
        originMarkerObject->GetTransform()->SetLocalScale(Vector3(40.0f, 40.0f, 40.0f));
        auto* originMarkerMeshFilter = originMarkerObject->AddComponent<MeshFilterComponent>();
        auto* originMarkerMeshRenderer = originMarkerObject->AddComponent<MeshRendererComponent>();
        originMarkerMeshFilter->SetMesh(mCubeMesh);
        originMarkerMeshRenderer->SetMaterial(0, mOriginMarkerMaterial);
        originMarkerMeshRenderer->SetCastShadows(false);
        originMarkerMeshRenderer->SetReceiveShadows(false);

        RenderSceneExtractor extractor;
        const RenderSceneData sceneData = extractor.Extract(*mScene, nullptr, kFrameWidth, kFrameHeight);
        ASSERT_EQ(sceneData.visibleItems.size(), 2u);
        ASSERT_EQ(sceneData.visibleVolumes.size(), 1u);
        EXPECT_EQ(sceneData.visibleVolumes[0].localToWorld.GetTranslation(), Vector3(220.0f, 60.0f, 160.0f));
    }

    void ReleaseSceneResources() override {
        delete mVolumeField;
        mVolumeField = nullptr;
        delete mVolumeMaterial;
        mVolumeMaterial = nullptr;
        delete mBackplateMaterial;
        mBackplateMaterial = nullptr;
        delete mOriginMarkerMaterial;
        mOriginMarkerMaterial = nullptr;
        mCubeMesh.Reset();
    }

private:
    Material* mVolumeMaterial = nullptr;
    Material* mBackplateMaterial = nullptr;
    Material* mOriginMarkerMaterial = nullptr;
    VolumeField* mVolumeField = nullptr;
    ResourceHandle<Mesh> mCubeMesh;
};

TEST_P(VolumeTransformSceneTest, RenderNanoVdbVolumeTransformScene) {
    const char* screenshotFilename = GetScreenshotFilename(GetBackendType());
    RenderAndCompare(screenshotFilename, 0.0f);

    const RenderingIntegrationTestUtils::PpmImage image =
        RenderingIntegrationTestUtils::LoadPpmImage(screenshotFilename);
    RenderingIntegrationTestUtils::ExpectPixelLuminanceAtLeast(
        image,
        840u,
        320u,
        120,
        "transformed volume should stay visible over the backplate");
}

} // namespace

INSTANTIATE_TEST_SUITE_P(D3D12, VolumeTransformSceneTest, ::testing::Values(XCEngine::RHI::RHIType::D3D12));
#if defined(XCENGINE_SUPPORT_OPENGL)
INSTANTIATE_TEST_SUITE_P(OpenGL, VolumeTransformSceneTest, ::testing::Values(XCEngine::RHI::RHIType::OpenGL));
#endif
#if defined(XCENGINE_SUPPORT_VULKAN)
INSTANTIATE_TEST_SUITE_P(Vulkan, VolumeTransformSceneTest, ::testing::Values(XCEngine::RHI::RHIType::Vulkan));
#endif

GTEST_API_ int main(int argc, char** argv) {
    return RunRenderingIntegrationTestMain(argc, argv);
}