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

#include <gtest/gtest.h>

#include "../RenderingIntegrationImageAssert.h"
#include "../RenderingIntegrationMain.h"

#include <XCEngine/Components/CameraComponent.h>
#include <XCEngine/Components/GameObject.h>
#include <XCEngine/Components/VolumeRendererComponent.h>
#include <XCEngine/Core/Asset/IResource.h>
#include <XCEngine/Core/Math/Color.h>
#include <XCEngine/Core/Math/Vector2.h>
#include <XCEngine/Core/Math/Vector3.h>
#include <XCEngine/Rendering/RenderContext.h>
#include <XCEngine/Rendering/RenderSurface.h>
#include <XCEngine/Rendering/Execution/SceneRenderer.h>
#include <XCEngine/Rendering/Extraction/RenderSceneExtractor.h>
#include <XCEngine/Resources/BuiltinResources.h>
#include <XCEngine/Resources/Material/Material.h>
#include <XCEngine/Resources/Shader/Shader.h>
#include <XCEngine/Resources/Volume/VolumeField.h>
#include <XCEngine/Resources/Volume/VolumeFieldLoader.h>
#include <XCEngine/RHI/RHITexture.h>
#include <XCEngine/Scene/Scene.h>

#include "../../../RHI/integration/fixtures/RHIIntegrationFixture.h"

#include <filesystem>
#include <memory>
#include <vector>

using namespace XCEngine::Components;
using namespace XCEngine::Math;
using namespace XCEngine::Rendering;
using namespace XCEngine::Resources;
using namespace XCEngine::RHI;
using namespace XCEngine::RHI::Integration;

namespace {

constexpr const char* kD3D12Screenshot = "volume_scene_d3d12.ppm";
constexpr uint32_t kFrameWidth = 1280;
constexpr uint32_t kFrameHeight = 720;
constexpr const char* kVolumeFixtureRelativePath = "Res/Volumes/cloud.nvdb";

Material* CreateVolumetricMaterial() {
    auto* material = new Material();
    IResource::ConstructParams params = {};
    params.name = "VolumeMaterial";
    params.path = "Tests/Rendering/VolumeScene/Volume.material";
    params.guid = ResourceGUID::Generate(params.path);
    material->Initialize(params);
    material->SetShader(ResourceManager::Get().Load<Shader>(GetBuiltinVolumetricShaderPath()));
    material->SetRenderQueue(MaterialRenderQueue::Transparent);
    material->SetFloat4("_Tint", Vector4(1.0f, 1.0f, 1.0f, 1.0f));
    material->SetFloat("_DensityScale", 0.2f);
    material->SetFloat("_StepSize", 1.0f);
    material->SetFloat("_MaxSteps", 2000.0f);
    material->SetFloat("_AmbientStrength", 0.005f);
    material->SetFloat4("_LightDirection", Vector4(0.5f, 0.8f, 0.3f, 0.0f));
    material->SetFloat("_LightSamples", 8.0f);
    return material;
}

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

class VolumeSceneTest : public RHIIntegrationFixture {
protected:
    void SetUp() override;
    void TearDown() override;
    void RenderFrame() override;

private:
    RHIResourceView* GetCurrentBackBufferView();

    std::unique_ptr<Scene> mScene;
    std::unique_ptr<SceneRenderer> mSceneRenderer;
    std::vector<RHIResourceView*> mBackBufferViews;
    RHITexture* mDepthTexture = nullptr;
    RHIResourceView* mDepthView = nullptr;
    Material* mVolumeMaterial = nullptr;
    VolumeField* mVolumeField = nullptr;
};

void VolumeSceneTest::SetUp() {
    RHIIntegrationFixture::SetUp();

    mSceneRenderer = std::make_unique<SceneRenderer>();
    mScene = std::make_unique<Scene>("VolumeScene");

    mVolumeMaterial = CreateVolumetricMaterial();
    ASSERT_NE(mVolumeMaterial, nullptr);

    const std::filesystem::path fixturePath =
        RenderingIntegrationTestUtils::ResolveRuntimePath(kVolumeFixtureRelativePath);
    ASSERT_TRUE(std::filesystem::exists(fixturePath)) << fixturePath.string();

    VolumeFieldLoader volumeFieldLoader;
    LoadResult volumeResult = volumeFieldLoader.Load(fixturePath.string().c_str());
    ASSERT_TRUE(volumeResult);
    ASSERT_NE(volumeResult.resource, nullptr);
    mVolumeField = static_cast<VolumeField*>(volumeResult.resource);

    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(-10.0f, 300.0f, -1200.0f));
    cameraObject->GetTransform()->LookAt(Vector3(-10.0f, 73.0f, 0.0f));

    GameObject* volumeObject = mScene->CreateGameObject("CloudVolume");
    auto* volumeRenderer = volumeObject->AddComponent<VolumeRendererComponent>();
    volumeRenderer->SetVolumeField(mVolumeField);
    volumeRenderer->SetMaterial(mVolumeMaterial);
    volumeRenderer->SetCastShadows(false);
    volumeRenderer->SetReceiveShadows(false);

    TextureDesc depthDesc = {};
    depthDesc.width = kFrameWidth;
    depthDesc.height = kFrameHeight;
    depthDesc.depth = 1;
    depthDesc.mipLevels = 1;
    depthDesc.arraySize = 1;
    depthDesc.format = static_cast<uint32_t>(Format::D24_UNorm_S8_UInt);
    depthDesc.textureType = static_cast<uint32_t>(XCEngine::RHI::TextureType::Texture2D);
    depthDesc.sampleCount = 1;
    depthDesc.sampleQuality = 0;
    depthDesc.flags = 0;
    mDepthTexture = GetDevice()->CreateTexture(depthDesc);
    ASSERT_NE(mDepthTexture, nullptr);

    ResourceViewDesc depthViewDesc = {};
    depthViewDesc.format = static_cast<uint32_t>(Format::D24_UNorm_S8_UInt);
    depthViewDesc.dimension = ResourceViewDimension::Texture2D;
    depthViewDesc.mipLevel = 0;
    mDepthView = GetDevice()->CreateDepthStencilView(mDepthTexture, depthViewDesc);
    ASSERT_NE(mDepthView, nullptr);

    mBackBufferViews.resize(2, nullptr);

    RenderSceneExtractor extractor;
    const RenderSceneData sceneData = extractor.Extract(*mScene, nullptr, kFrameWidth, kFrameHeight);
    ASSERT_EQ(sceneData.visibleItems.size(), 0u);
    ASSERT_EQ(sceneData.visibleVolumes.size(), 1u);
}

void VolumeSceneTest::TearDown() {
    mSceneRenderer.reset();

    if (mDepthView != nullptr) {
        mDepthView->Shutdown();
        delete mDepthView;
        mDepthView = nullptr;
    }

    if (mDepthTexture != nullptr) {
        mDepthTexture->Shutdown();
        delete mDepthTexture;
        mDepthTexture = nullptr;
    }

    for (RHIResourceView*& backBufferView : mBackBufferViews) {
        if (backBufferView != nullptr) {
            backBufferView->Shutdown();
            delete backBufferView;
            backBufferView = nullptr;
        }
    }
    mBackBufferViews.clear();

    mScene.reset();

    delete mVolumeField;
    mVolumeField = nullptr;
    delete mVolumeMaterial;
    mVolumeMaterial = nullptr;

    RHIIntegrationFixture::TearDown();
}

RHIResourceView* VolumeSceneTest::GetCurrentBackBufferView() {
    const int backBufferIndex = GetCurrentBackBufferIndex();
    if (backBufferIndex < 0) {
        return nullptr;
    }

    if (static_cast<size_t>(backBufferIndex) >= mBackBufferViews.size()) {
        mBackBufferViews.resize(static_cast<size_t>(backBufferIndex) + 1, nullptr);
    }

    if (mBackBufferViews[backBufferIndex] == nullptr) {
        ResourceViewDesc viewDesc = {};
        viewDesc.format = static_cast<uint32_t>(Format::R8G8B8A8_UNorm);
        viewDesc.dimension = ResourceViewDimension::Texture2D;
        viewDesc.mipLevel = 0;
        mBackBufferViews[backBufferIndex] = GetDevice()->CreateRenderTargetView(GetCurrentBackBuffer(), viewDesc);
    }

    return mBackBufferViews[backBufferIndex];
}

void VolumeSceneTest::RenderFrame() {
    ASSERT_NE(mScene, nullptr);
    ASSERT_NE(mSceneRenderer, nullptr);

    RHICommandList* commandList = GetCommandList();
    ASSERT_NE(commandList, nullptr);

    commandList->Reset();

    RenderSurface surface(kFrameWidth, kFrameHeight);
    surface.SetColorAttachment(GetCurrentBackBufferView());
    surface.SetDepthAttachment(mDepthView);

    RenderContext renderContext = {};
    renderContext.device = GetDevice();
    renderContext.commandList = commandList;
    renderContext.commandQueue = GetCommandQueue();
    renderContext.backendType = GetBackendType();

    ASSERT_TRUE(mSceneRenderer->Render(*mScene, nullptr, renderContext, surface));

    commandList->Close();
    void* commandLists[] = { commandList };
    GetCommandQueue()->ExecuteCommandLists(1, commandLists);
}

TEST_P(VolumeSceneTest, RenderNanoVdbVolumeScene) {
    RHICommandQueue* commandQueue = GetCommandQueue();
    RHISwapChain* swapChain = GetSwapChain();
    ASSERT_NE(swapChain, nullptr);

    const int targetFrameCount = 30;
    const char* screenshotFilename = GetScreenshotFilename(GetBackendType());

    for (int frameCount = 0; frameCount <= targetFrameCount; ++frameCount) {
        if (frameCount > 0) {
            commandQueue->WaitForPreviousFrame();
        }

        BeginRender();
        RenderFrame();

        if (frameCount >= targetFrameCount) {
            commandQueue->WaitForIdle();
            ASSERT_TRUE(TakeScreenshot(screenshotFilename));
            ASSERT_TRUE(CompareWithGoldenTemplate(screenshotFilename, "GT.ppm", 0.0f));
            break;
        }

        swapChain->Present(0, 0);
    }
}

} // namespace

INSTANTIATE_TEST_SUITE_P(D3D12, VolumeSceneTest, ::testing::Values(RHIType::D3D12));

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