xuanchi/XCEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix D3D12 pipeline format mapping and add transparent material scene test

Browse Source
This commit is contained in:
ssdfasd
2026-03-27 13:01:17 +08:00
parent 79e7452245
commit 134a80b334
7 changed files with 631983 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

395
tests/Rendering/integration/transparent_material_scene/main.cpp Normal file
View File

@@ -0,0 +1,395 @@
#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/Color.h>
#include <XCEngine/Core/Math/Quaternion.h>
#include <XCEngine/Core/Math/Vector2.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/Texture/Texture.h>
#include <XCEngine/RHI/RHITexture.h>
#include <XCEngine/Scene/Scene.h>
#include "../../../RHI/integration/fixtures/RHIIntegrationFixture.h"
#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 = "transparent_material_scene_d3d12.ppm";
constexpr const char* kOpenGLScreenshot = "transparent_material_scene_opengl.ppm";
constexpr uint32_t kFrameWidth = 1280;
constexpr uint32_t kFrameHeight = 720;
Mesh* CreateQuadMesh() {
auto* mesh = new Mesh();
IResource::ConstructParams params = {};
params.name = "TransparentQuad";
params.path = "Tests/Rendering/TransparentQuad.mesh";
params.guid = ResourceGUID::Generate(params.path);
mesh->Initialize(params);
StaticMeshVertex vertices[4] = {};
vertices[0].position = Vector3(-1.0f, -1.0f, 0.0f);
vertices[0].uv0 = Vector2(0.0f, 1.0f);
vertices[1].position = Vector3(-1.0f, 1.0f, 0.0f);
vertices[1].uv0 = Vector2(0.0f, 0.0f);
vertices[2].position = Vector3(1.0f, -1.0f, 0.0f);
vertices[2].uv0 = Vector2(1.0f, 1.0f);
vertices[3].position = Vector3(1.0f, 1.0f, 0.0f);
vertices[3].uv0 = Vector2(1.0f, 0.0f);
const uint32_t indices[6] = { 0, 1, 2, 2, 1, 3 };
mesh->SetVertexData(
vertices,
sizeof(vertices),
4,
sizeof(StaticMeshVertex),
VertexAttribute::Position | VertexAttribute::UV0);
mesh->SetIndexData(indices, sizeof(indices), 6, true);
MeshSection section = {};
section.baseVertex = 0;
section.vertexCount = 4;
section.startIndex = 0;
section.indexCount = 6;
section.materialID = 0;
mesh->AddSection(section);
return mesh;
}
Texture* CreateSolidTexture(const char* name, const char* path, const unsigned char rgba[4]) {
auto* texture = new Texture();
IResource::ConstructParams params = {};
params.name = name;
params.path = path;
params.guid = ResourceGUID::Generate(params.path);
texture->Initialize(params);
texture->Create(
1,
1,
1,
1,
XCEngine::Resources::TextureType::Texture2D,
XCEngine::Resources::TextureFormat::RGBA8_UNORM,
rgba,
4);
return texture;
}
Material* CreateMaterial(
const char* name,
const char* path,
Texture* texture,
MaterialRenderQueue renderQueue,
const MaterialRenderState& renderState) {
auto* material = new Material();
IResource::ConstructParams params = {};
params.name = name;
params.path = path;
params.guid = ResourceGUID::Generate(params.path);
material->Initialize(params);
material->SetTexture("_BaseColorTexture", ResourceHandle<Texture>(texture));
material->SetRenderQueue(renderQueue);
material->SetRenderState(renderState);
return material;
}
GameObject* CreateQuadObject(
Scene& scene,
const char* name,
Mesh* mesh,
Material* material,
const Vector3& position,
const Vector3& scale,
const Quaternion& rotation = Quaternion::Identity()) {
GameObject* gameObject = scene.CreateGameObject(name);
gameObject->GetTransform()->SetLocalPosition(position);
gameObject->GetTransform()->SetLocalScale(scale);
gameObject->GetTransform()->SetLocalRotation(rotation);
auto* meshFilter = gameObject->AddComponent<MeshFilterComponent>();
auto* meshRenderer = gameObject->AddComponent<MeshRendererComponent>();
meshFilter->SetMesh(ResourceHandle<Mesh>(mesh));
meshRenderer->SetMaterial(0, ResourceHandle<Material>(material));
return gameObject;
}
const char* GetScreenshotFilename(RHIType backendType) {
return backendType == RHIType::D3D12 ? kD3D12Screenshot : kOpenGLScreenshot;
}
int GetComparisonThreshold(RHIType backendType) {
(void)backendType;
return 8;
}
class TransparentMaterialSceneTest : public RHIIntegrationFixture {
protected:
void SetUp() override;
void TearDown() override;
void RenderFrame() override;
private:
void BuildScene();
RHIResourceView* GetCurrentBackBufferView();
std::unique_ptr<Scene> mScene;
std::unique_ptr<SceneRenderer> mSceneRenderer;
std::vector<RHIResourceView*> mBackBufferViews;
std::vector<Texture*> mTextures;
std::vector<Material*> mMaterials;
RHITexture* mDepthTexture = nullptr;
RHIResourceView* mDepthView = nullptr;
Mesh* mMesh = nullptr;
};
void TransparentMaterialSceneTest::SetUp() {
RHIIntegrationFixture::SetUp();
mSceneRenderer = std::make_unique<SceneRenderer>();
mScene = std::make_unique<Scene>("TransparentMaterialScene");
mMesh = CreateQuadMesh();
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 TransparentMaterialSceneTest::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();
for (Material* material : mMaterials) {
delete material;
}
mMaterials.clear();
for (Texture* texture : mTextures) {
delete texture;
}
mTextures.clear();
delete mMesh;
mMesh = nullptr;
RHIIntegrationFixture::TearDown();
}
void TransparentMaterialSceneTest::BuildScene() {
ASSERT_NE(mScene, nullptr);
ASSERT_NE(mMesh, nullptr);
GameObject* cameraObject = mScene->CreateGameObject("MainCamera");
auto* camera = cameraObject->AddComponent<CameraComponent>();
camera->SetPrimary(true);
camera->SetProjectionType(CameraProjectionType::Perspective);
camera->SetFieldOfView(45.0f);
camera->SetNearClipPlane(0.1f);
camera->SetFarClipPlane(10.0f);
camera->SetClearColor(XCEngine::Math::Color(0.04f, 0.05f, 0.09f, 1.0f));
const unsigned char redPixel[4] = { 248, 80, 80, 160 };
const unsigned char greenPixel[4] = { 88, 240, 136, 160 };
Texture* farTexture = CreateSolidTexture(
"FarTransparentTexture",
"Tests/Rendering/TransparentScene/far.texture",
redPixel);
Texture* nearTexture = CreateSolidTexture(
"NearTransparentTexture",
"Tests/Rendering/TransparentScene/near.texture",
greenPixel);
mTextures = { farTexture, nearTexture };
MaterialRenderState transparentState = {};
transparentState.blendEnable = true;
transparentState.srcBlend = MaterialBlendFactor::SrcAlpha;
transparentState.dstBlend = MaterialBlendFactor::InvSrcAlpha;
transparentState.srcBlendAlpha = MaterialBlendFactor::One;
transparentState.dstBlendAlpha = MaterialBlendFactor::Zero;
transparentState.depthTestEnable = true;
transparentState.depthWriteEnable = false;
transparentState.depthFunc = MaterialComparisonFunc::LessEqual;
transparentState.cullMode = MaterialCullMode::None;
Material* farMaterial = CreateMaterial(
"FarTransparentMaterial",
"Tests/Rendering/TransparentScene/far.mat",
farTexture,
MaterialRenderQueue::Transparent,
transparentState);
Material* nearMaterial = CreateMaterial(
"NearTransparentMaterial",
"Tests/Rendering/TransparentScene/near.mat",
nearTexture,
MaterialRenderQueue::Transparent,
transparentState);
mMaterials = { farMaterial, nearMaterial };
CreateQuadObject(
*mScene,
"FarTransparent",
mMesh,
farMaterial,
Vector3(-0.14f, 0.0f, 3.25f),
Vector3(0.92f, 0.92f, 1.0f),
Quaternion::FromAxisAngle(Vector3::Up(), 0.62f));
CreateQuadObject(
*mScene,
"NearTransparent",
mMesh,
nearMaterial,
Vector3(0.14f, 0.0f, 2.75f),
Vector3(0.92f, 0.92f, 1.0f),
Quaternion::FromAxisAngle(Vector3::Up(), -0.62f));
}
RHIResourceView* TransparentMaterialSceneTest::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 TransparentMaterialSceneTest::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(TransparentMaterialSceneTest, RenderTransparentMaterialScene) {
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, TransparentMaterialSceneTest, ::testing::Values(RHIType::D3D12));
INSTANTIATE_TEST_SUITE_P(OpenGL, TransparentMaterialSceneTest, ::testing::Values(RHIType::OpenGL));
GTEST_API_ int main(int argc, char** argv) {
Logger::Get().Initialize();
Logger::Get().AddSink(std::make_unique<ConsoleLogSink>());
Logger::Get().SetMinimumLevel(LogLevel::Debug);
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}