323 lines
11 KiB
C++
323 lines
11 KiB
C++
#define NOMINMAX
|
|
#include <windows.h>
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#include "../RenderingIntegrationMain.h"
|
|
|
|
#include <XCEngine/Components/CameraComponent.h>
|
|
#include <XCEngine/Components/GameObject.h>
|
|
#include <XCEngine/Components/MeshFilterComponent.h>
|
|
#include <XCEngine/Components/MeshRendererComponent.h>
|
|
#include <XCEngine/Core/Math/Color.h>
|
|
#include <XCEngine/Core/Math/Quaternion.h>
|
|
#include <XCEngine/Core/Math/Vector3.h>
|
|
#include <XCEngine/Debug/ConsoleLogSink.h>
|
|
#include <XCEngine/Debug/Logger.h>
|
|
#include <XCEngine/Rendering/RenderContext.h>
|
|
#include <XCEngine/Rendering/RenderSurface.h>
|
|
#include <XCEngine/Rendering/SceneRenderer.h>
|
|
#include <XCEngine/Resources/Material/Material.h>
|
|
#include <XCEngine/Resources/Mesh/Mesh.h>
|
|
#include <XCEngine/Resources/Mesh/MeshImportSettings.h>
|
|
#include <XCEngine/Resources/Mesh/MeshLoader.h>
|
|
#include <XCEngine/Resources/Texture/Texture.h>
|
|
#include <XCEngine/RHI/RHITexture.h>
|
|
#include <XCEngine/Scene/Scene.h>
|
|
|
|
#include "../../../RHI/integration/fixtures/RHIIntegrationFixture.h"
|
|
|
|
#include <algorithm>
|
|
#include <filesystem>
|
|
#include <memory>
|
|
#include <vector>
|
|
|
|
using namespace XCEngine::Components;
|
|
using namespace XCEngine::Debug;
|
|
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 = "backpack_scene_d3d12.ppm";
|
|
constexpr const char* kOpenGLScreenshot = "backpack_scene_opengl.ppm";
|
|
constexpr const char* kVulkanScreenshot = "backpack_scene_vulkan.ppm";
|
|
constexpr uint32_t kFrameWidth = 1280;
|
|
constexpr uint32_t kFrameHeight = 720;
|
|
|
|
std::filesystem::path GetExecutableDirectory() {
|
|
char exePath[MAX_PATH] = {};
|
|
const DWORD length = GetModuleFileNameA(nullptr, exePath, MAX_PATH);
|
|
if (length == 0 || length >= MAX_PATH) {
|
|
return std::filesystem::current_path();
|
|
}
|
|
|
|
return std::filesystem::path(exePath).parent_path();
|
|
}
|
|
|
|
std::filesystem::path ResolveRuntimePath(const char* relativePath) {
|
|
return GetExecutableDirectory() / relativePath;
|
|
}
|
|
|
|
const char* GetScreenshotFilename(RHIType backendType) {
|
|
switch (backendType) {
|
|
case RHIType::D3D12:
|
|
return kD3D12Screenshot;
|
|
case RHIType::Vulkan:
|
|
return kVulkanScreenshot;
|
|
case RHIType::OpenGL:
|
|
default:
|
|
return kOpenGLScreenshot;
|
|
}
|
|
}
|
|
|
|
int GetComparisonThreshold(RHIType backendType) {
|
|
return backendType == RHIType::D3D12 ? 8 : 8;
|
|
}
|
|
|
|
class BackpackSceneTest : public RHIIntegrationFixture {
|
|
protected:
|
|
void SetUp() override;
|
|
void TearDown() override;
|
|
void RenderFrame() override;
|
|
|
|
private:
|
|
void LoadBackpackMesh();
|
|
void BuildScene();
|
|
RHIResourceView* GetCurrentBackBufferView();
|
|
|
|
std::unique_ptr<Scene> mScene;
|
|
std::unique_ptr<SceneRenderer> mSceneRenderer;
|
|
std::vector<RHIResourceView*> mBackBufferViews;
|
|
RHITexture* mDepthTexture = nullptr;
|
|
RHIResourceView* mDepthView = nullptr;
|
|
Mesh* mMesh = nullptr;
|
|
};
|
|
|
|
void BackpackSceneTest::SetUp() {
|
|
RHIIntegrationFixture::SetUp();
|
|
|
|
mSceneRenderer = std::make_unique<SceneRenderer>();
|
|
mScene = std::make_unique<Scene>("BackpackScene");
|
|
|
|
LoadBackpackMesh();
|
|
BuildScene();
|
|
|
|
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);
|
|
}
|
|
|
|
void BackpackSceneTest::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();
|
|
|
|
if (mMesh != nullptr) {
|
|
for (size_t materialIndex = 0; materialIndex < mMesh->GetMaterials().Size(); ++materialIndex) {
|
|
delete mMesh->GetMaterials()[materialIndex];
|
|
}
|
|
for (size_t textureIndex = 0; textureIndex < mMesh->GetTextures().Size(); ++textureIndex) {
|
|
delete mMesh->GetTextures()[textureIndex];
|
|
}
|
|
delete mMesh;
|
|
mMesh = nullptr;
|
|
}
|
|
|
|
RHIIntegrationFixture::TearDown();
|
|
}
|
|
|
|
void BackpackSceneTest::LoadBackpackMesh() {
|
|
const std::filesystem::path meshPath = ResolveRuntimePath("Res/models/backpack/backpack.obj");
|
|
|
|
MeshLoader loader;
|
|
// Keep import behavior aligned with the editor/runtime resource path.
|
|
MeshImportSettings settings;
|
|
LoadResult result = loader.Load(meshPath.string().c_str(), &settings);
|
|
ASSERT_TRUE(result);
|
|
ASSERT_NE(result.resource, nullptr);
|
|
|
|
mMesh = static_cast<Mesh*>(result.resource);
|
|
ASSERT_NE(mMesh, nullptr);
|
|
ASSERT_TRUE(mMesh->IsValid());
|
|
ASSERT_GT(mMesh->GetVertexCount(), 0u);
|
|
ASSERT_GT(mMesh->GetSections().Size(), 0u);
|
|
}
|
|
|
|
void BackpackSceneTest::BuildScene() {
|
|
ASSERT_NE(mScene, nullptr);
|
|
ASSERT_NE(mMesh, nullptr);
|
|
|
|
GameObject* cameraObject = mScene->CreateGameObject("MainCamera");
|
|
auto* camera = cameraObject->AddComponent<CameraComponent>();
|
|
camera->SetPrimary(true);
|
|
camera->SetFieldOfView(45.0f);
|
|
camera->SetNearClipPlane(0.1f);
|
|
camera->SetFarClipPlane(100.0f);
|
|
camera->SetClearColor(XCEngine::Math::Color(0.05f, 0.05f, 0.08f, 1.0f));
|
|
|
|
const Vector3 boundsMin = mMesh->GetBounds().GetMin();
|
|
const Vector3 boundsMax = mMesh->GetBounds().GetMax();
|
|
const Vector3 center(
|
|
(boundsMin.x + boundsMax.x) * 0.5f,
|
|
(boundsMin.y + boundsMax.y) * 0.5f,
|
|
(boundsMin.z + boundsMax.z) * 0.5f);
|
|
const float sizeX = std::max(boundsMax.x - boundsMin.x, 0.001f);
|
|
const float sizeY = std::max(boundsMax.y - boundsMin.y, 0.001f);
|
|
const float sizeZ = std::max(boundsMax.z - boundsMin.z, 0.001f);
|
|
const float maxExtent = std::max(sizeX, std::max(sizeY, sizeZ));
|
|
const float uniformScale = 1.8f / maxExtent;
|
|
|
|
GameObject* root = mScene->CreateGameObject("BackpackRoot");
|
|
root->GetTransform()->SetLocalPosition(Vector3(0.0f, 0.08f, 3.0f));
|
|
|
|
GameObject* rotateY = mScene->CreateGameObject("BackpackRotateY");
|
|
rotateY->SetParent(root, false);
|
|
rotateY->GetTransform()->SetLocalRotation(Quaternion::FromAxisAngle(Vector3::Up(), -0.35f));
|
|
|
|
GameObject* rotateX = mScene->CreateGameObject("BackpackRotateX");
|
|
rotateX->SetParent(rotateY, false);
|
|
rotateX->GetTransform()->SetLocalRotation(Quaternion::FromAxisAngle(Vector3::Right(), -0.18f));
|
|
|
|
GameObject* scale = mScene->CreateGameObject("BackpackScale");
|
|
scale->SetParent(rotateX, false);
|
|
scale->GetTransform()->SetLocalScale(Vector3(uniformScale, uniformScale, uniformScale));
|
|
|
|
GameObject* meshObject = mScene->CreateGameObject("BackpackMesh");
|
|
meshObject->SetParent(scale, false);
|
|
meshObject->GetTransform()->SetLocalPosition(Vector3(-center.x, -center.y, -center.z));
|
|
|
|
auto* meshFilter = meshObject->AddComponent<MeshFilterComponent>();
|
|
auto* meshRenderer = meshObject->AddComponent<MeshRendererComponent>();
|
|
meshFilter->SetMesh(ResourceHandle<Mesh>(mMesh));
|
|
meshRenderer->ClearMaterials();
|
|
}
|
|
|
|
RHIResourceView* BackpackSceneTest::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 BackpackSceneTest::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(BackpackSceneTest, RenderBackpackScene) {
|
|
RHICommandQueue* commandQueue = GetCommandQueue();
|
|
RHISwapChain* swapChain = GetSwapChain();
|
|
const int targetFrameCount = 30;
|
|
const char* screenshotFilename = GetScreenshotFilename(GetBackendType());
|
|
const int comparisonThreshold = GetComparisonThreshold(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", static_cast<float>(comparisonThreshold)));
|
|
break;
|
|
}
|
|
|
|
swapChain->Present(0, 0);
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
INSTANTIATE_TEST_SUITE_P(D3D12, BackpackSceneTest, ::testing::Values(RHIType::D3D12));
|
|
INSTANTIATE_TEST_SUITE_P(OpenGL, BackpackSceneTest, ::testing::Values(RHIType::OpenGL));
|
|
#if defined(XCENGINE_SUPPORT_VULKAN)
|
|
INSTANTIATE_TEST_SUITE_P(Vulkan, BackpackSceneTest, ::testing::Values(RHIType::Vulkan));
|
|
#endif
|
|
|
|
GTEST_API_ int main(int argc, char** argv) {
|
|
return RunRenderingIntegrationTestMain(argc, argv);
|
|
}
|