xuanchi/XCEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
56f596548d005e3d56039981d6648ad60389a010
XCEngine/tests/Rendering/integration/directional_shadow_scene/main.cpp

1111 lines
40 KiB
C++
Raw Blame History

#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/LightComponent.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/RenderPass.h>
#include <XCEngine/Rendering/RenderSurface.h>
#include <XCEngine/Rendering/SceneRenderer.h>
#include <XCEngine/Resources/BuiltinResources.h>
#include <XCEngine/Resources/Material/Material.h>
#include <XCEngine/Resources/Mesh/Mesh.h>
#include <XCEngine/Resources/Shader/Shader.h>
#include <XCEngine/RHI/RHIDescriptorPool.h>
#include <XCEngine/RHI/RHIDescriptorSet.h>
#include <XCEngine/RHI/RHIPipelineLayout.h>
#include <XCEngine/RHI/RHIPipelineState.h>
#include <XCEngine/RHI/RHISampler.h>
#include <XCEngine/RHI/RHITexture.h>
#include <XCEngine/Scene/Scene.h>
#include "../../../RHI/integration/fixtures/RHIIntegrationFixture.h"
#include <cstring>
#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 = "directional_shadow_scene_d3d12.ppm";
constexpr const char* kOpenGLScreenshot = "directional_shadow_scene_opengl.ppm";
constexpr const char* kVulkanScreenshot = "directional_shadow_scene_vulkan.ppm";
constexpr const char* kD3D12ShadowMapScreenshot = "directional_shadow_map_d3d12.ppm";
constexpr const char* kOpenGLShadowMapScreenshot = "directional_shadow_map_opengl.ppm";
constexpr const char* kVulkanShadowMapScreenshot = "directional_shadow_map_vulkan.ppm";
constexpr uint32_t kFrameWidth = 1280;
constexpr uint32_t kFrameHeight = 720;
const char kShadowMapDebugHlsl[] = R"(
Texture2D<float> gShadowMap : register(t0);
SamplerState gShadowSampler : register(s0);
struct VSOutput {
float4 position : SV_POSITION;
float2 uv : TEXCOORD0;
};
VSOutput MainVS(uint vertexId : SV_VertexID) {
VSOutput output;
const float2 positions[3] = {
float2(-1.0f, -1.0f),
float2(-1.0f, 3.0f),
float2( 3.0f, -1.0f)
};
const float2 uvs[3] = {
float2(0.0f, 0.0f),
float2(0.0f, 2.0f),
float2(2.0f, 0.0f)
};
output.position = float4(positions[vertexId], 0.0f, 1.0f);
output.uv = uvs[vertexId];
return output;
}
float4 MainPS(VSOutput input) : SV_TARGET {
const float depth = gShadowMap.Sample(gShadowSampler, input.uv);
return float4(depth, depth, depth, 1.0f);
}
)";
const char kShadowMapDebugVertexShader[] = R"(#version 430
out vec2 vTexCoord;
void main() {
const vec2 positions[3] = vec2[](
vec2(-1.0, -1.0),
vec2(-1.0, 3.0),
vec2( 3.0, -1.0)
);
const vec2 uvs[3] = vec2[](
vec2(0.0, 0.0),
vec2(0.0, 2.0),
vec2(2.0, 0.0)
);
gl_Position = vec4(positions[gl_VertexID], 0.0, 1.0);
vTexCoord = uvs[gl_VertexID];
}
)";
const char kShadowMapDebugFragmentShader[] = R"(#version 430
layout(binding = 0) uniform sampler2D uShadowMap;
in vec2 vTexCoord;
layout(location = 0) out vec4 fragColor;
void main() {
const float depth = texture(uShadowMap, vTexCoord).r;
fragColor = vec4(depth, depth, depth, 1.0);
}
)";
void AppendQuadFace(
std::vector<StaticMeshVertex>& vertices,
std::vector<uint32_t>& indices,
const Vector3& v0,
const Vector3& v1,
const Vector3& v2,
const Vector3& v3,
const Vector3& normal) {
const uint32_t baseIndex = static_cast<uint32_t>(vertices.size());
StaticMeshVertex vertex = {};
vertex.normal = normal;
vertex.position = v0;
vertex.uv0 = Vector2(0.0f, 1.0f);
vertices.push_back(vertex);
vertex.position = v1;
vertex.uv0 = Vector2(1.0f, 1.0f);
vertices.push_back(vertex);
vertex.position = v2;
vertex.uv0 = Vector2(0.0f, 0.0f);
vertices.push_back(vertex);
vertex.position = v3;
vertex.uv0 = Vector2(1.0f, 0.0f);
vertices.push_back(vertex);
indices.push_back(baseIndex + 0);
indices.push_back(baseIndex + 2);
indices.push_back(baseIndex + 1);
indices.push_back(baseIndex + 1);
indices.push_back(baseIndex + 2);
indices.push_back(baseIndex + 3);
}
Mesh* CreateGroundMesh() {
auto* mesh = new Mesh();
IResource::ConstructParams params = {};
params.name = "DirectionalShadowGroundMesh";
params.path = "Tests/Rendering/DirectionalShadowGround.mesh";
params.guid = ResourceGUID::Generate(params.path);
mesh->Initialize(params);
StaticMeshVertex vertices[4] = {};
vertices[0].position = Vector3(-12.0f, 0.0f, 1.0f);
vertices[0].normal = Vector3::Up();
vertices[0].uv0 = Vector2(0.0f, 1.0f);
vertices[1].position = Vector3(-12.0f, 0.0f, 20.0f);
vertices[1].normal = Vector3::Up();
vertices[1].uv0 = Vector2(0.0f, 0.0f);
vertices[2].position = Vector3(12.0f, 0.0f, 1.0f);
vertices[2].normal = Vector3::Up();
vertices[2].uv0 = Vector2(1.0f, 1.0f);
vertices[3].position = Vector3(12.0f, 0.0f, 20.0f);
vertices[3].normal = Vector3::Up();
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::Normal | VertexAttribute::UV0);
mesh->SetIndexData(indices, sizeof(indices), 6, true);
const Bounds bounds(Vector3(0.0f, 0.0f, 10.5f), Vector3(24.0f, 0.1f, 19.0f));
mesh->SetBounds(bounds);
MeshSection section = {};
section.baseVertex = 0;
section.vertexCount = 4;
section.startIndex = 0;
section.indexCount = 6;
section.materialID = 0;
section.bounds = bounds;
mesh->AddSection(section);
return mesh;
}
Mesh* CreateCubeMesh() {
auto* mesh = new Mesh();
IResource::ConstructParams params = {};
params.name = "DirectionalShadowCubeMesh";
params.path = "Tests/Rendering/DirectionalShadowCube.mesh";
params.guid = ResourceGUID::Generate(params.path);
mesh->Initialize(params);
std::vector<StaticMeshVertex> vertices;
std::vector<uint32_t> indices;
vertices.reserve(24);
indices.reserve(36);
constexpr float half = 0.5f;
AppendQuadFace(
vertices, indices,
Vector3(-half, -half, half),
Vector3(half, -half, half),
Vector3(-half, half, half),
Vector3(half, half, half),
Vector3::Forward());
AppendQuadFace(
vertices, indices,
Vector3(half, -half, -half),
Vector3(-half, -half, -half),
Vector3(half, half, -half),
Vector3(-half, half, -half),
Vector3::Back());
AppendQuadFace(
vertices, indices,
Vector3(-half, -half, -half),
Vector3(-half, -half, half),
Vector3(-half, half, -half),
Vector3(-half, half, half),
Vector3::Left());
AppendQuadFace(
vertices, indices,
Vector3(half, -half, half),
Vector3(half, -half, -half),
Vector3(half, half, half),
Vector3(half, half, -half),
Vector3::Right());
AppendQuadFace(
vertices, indices,
Vector3(-half, half, half),
Vector3(half, half, half),
Vector3(-half, half, -half),
Vector3(half, half, -half),
Vector3::Up());
AppendQuadFace(
vertices, indices,
Vector3(-half, -half, -half),
Vector3(half, -half, -half),
Vector3(-half, -half, half),
Vector3(half, -half, half),
Vector3::Down());
mesh->SetVertexData(
vertices.data(),
vertices.size() * sizeof(StaticMeshVertex),
static_cast<uint32_t>(vertices.size()),
sizeof(StaticMeshVertex),
VertexAttribute::Position | VertexAttribute::Normal | VertexAttribute::UV0);
mesh->SetIndexData(
indices.data(),
indices.size() * sizeof(uint32_t),
static_cast<uint32_t>(indices.size()),
true);
const Bounds bounds(Vector3::Zero(), Vector3::One());
mesh->SetBounds(bounds);
MeshSection section = {};
section.baseVertex = 0;
section.vertexCount = static_cast<uint32_t>(vertices.size());
section.startIndex = 0;
section.indexCount = static_cast<uint32_t>(indices.size());
section.materialID = 0;
section.bounds = bounds;
mesh->AddSection(section);
return mesh;
}
Material* CreateForwardLitMaterial(
const char* name,
const char* path,
const Vector4& baseColor) {
auto* material = new Material();
IResource::ConstructParams params = {};
params.name = name;
params.path = path;
params.guid = ResourceGUID::Generate(params.path);
material->Initialize(params);
material->SetShader(ResourceManager::Get().Load<Shader>(GetBuiltinForwardLitShaderPath()));
material->SetShaderPass("ForwardLit");
material->SetFloat4("_BaseColor", baseColor);
return material;
}
const char* GetScreenshotFilename(RHIType backendType) {
switch (backendType) {
case RHIType::D3D12:
return kD3D12Screenshot;
case RHIType::Vulkan:
return kVulkanScreenshot;
case RHIType::OpenGL:
default:
return kOpenGLScreenshot;
}
}
const char* GetShadowMapScreenshotFilename(RHIType backendType) {
switch (backendType) {
case RHIType::D3D12:
return kD3D12ShadowMapScreenshot;
case RHIType::Vulkan:
return kVulkanShadowMapScreenshot;
case RHIType::OpenGL:
default:
return kOpenGLShadowMapScreenshot;
}
}
int GetComparisonThreshold(RHIType backendType) {
return backendType == RHIType::D3D12 ? 10 : 10;
}
struct ShadowProjectionDebugPoint {
Vector4 clip = Vector4::Zero();
Vector3 ndc = Vector3::Zero();
Vector2 uvFlipY = Vector2::Zero();
Vector2 uvNoFlipY = Vector2::Zero();
};
ShadowProjectionDebugPoint ProjectShadowPoint(
const Matrix4x4& gpuWorldToShadowMatrix,
const Vector3& worldPoint) {
ShadowProjectionDebugPoint result = {};
const Matrix4x4 worldToShadow = gpuWorldToShadowMatrix.Transpose();
result.clip = worldToShadow * Vector4(worldPoint.x, worldPoint.y, worldPoint.z, 1.0f);
if (std::abs(result.clip.w) > EPSILON) {
result.ndc = Vector3(
result.clip.x / result.clip.w,
result.clip.y / result.clip.w,
result.clip.z / result.clip.w);
result.uvFlipY = Vector2(
result.ndc.x * 0.5f + 0.5f,
result.ndc.y * -0.5f + 0.5f);
result.uvNoFlipY = Vector2(
result.ndc.x * 0.5f + 0.5f,
result.ndc.y * 0.5f + 0.5f);
}
return result;
}
void LogShadowProjection(
const char* label,
const ShadowProjectionDebugPoint& point,
uint32_t shadowMapWidth,
uint32_t shadowMapHeight) {
Log(
"[TEST] ShadowProbe %s clip=(%.4f, %.4f, %.4f, %.4f) "
"ndc=(%.4f, %.4f, %.4f) uvFlip=(%.4f, %.4f) uvNoFlip=(%.4f, %.4f) "
"texelFlip=(%d, %d) texelNoFlip=(%d, %d)",
label,
point.clip.x, point.clip.y, point.clip.z, point.clip.w,
point.ndc.x, point.ndc.y, point.ndc.z,
point.uvFlipY.x, point.uvFlipY.y,
point.uvNoFlipY.x, point.uvNoFlipY.y,
static_cast<int>(point.uvFlipY.x * static_cast<float>(shadowMapWidth)),
static_cast<int>(point.uvFlipY.y * static_cast<float>(shadowMapHeight)),
static_cast<int>(point.uvNoFlipY.x * static_cast<float>(shadowMapWidth)),
static_cast<int>(point.uvNoFlipY.y * static_cast<float>(shadowMapHeight)));
}
void LogShadowAlignmentAnalysis(
const Scene& scene,
const CameraRenderRequest& request) {
if (!request.directionalShadow.IsValid()) {
Log("[TEST] ShadowProbe skipped because directional shadow plan was invalid");
return;
}
const GameObject* casterObject = scene.Find("CasterCube");
const GameObject* groundObject = scene.Find("Ground");
if (casterObject == nullptr || groundObject == nullptr) {
Log("[TEST] ShadowProbe skipped because test scene objects were missing");
return;
}
const Vector3 casterCenter = casterObject->GetTransform()->GetPosition();
const Vector3 casterScale = casterObject->GetTransform()->GetScale();
const Vector3 groundCenter = groundObject->GetTransform()->GetPosition();
const Vector3 groundScale = groundObject->GetTransform()->GetScale();
const float groundTopY = groundCenter.y + groundScale.y * 0.5f;
const Vector3 lightDirectionToLight = request.directionalShadow.lightDirection.Normalized();
const Vector3 shadowRayDirection = lightDirectionToLight * -1.0f;
if (std::abs(shadowRayDirection.y) <= EPSILON) {
Log("[TEST] ShadowProbe skipped because shadow ray direction was parallel to the ground");
return;
}
const Vector3 casterBottomCenter = casterCenter - Vector3(0.0f, casterScale.y * 0.5f, 0.0f);
const float centerTravel = (groundTopY - casterCenter.y) / shadowRayDirection.y;
const float bottomTravel = (groundTopY - casterBottomCenter.y) / shadowRayDirection.y;
const Vector3 receiverFromCenter = casterCenter + shadowRayDirection * centerTravel;
const Vector3 receiverFromBottom = casterBottomCenter + shadowRayDirection * bottomTravel;
const ShadowProjectionDebugPoint casterCenterProjection =
ProjectShadowPoint(request.directionalShadow.cameraData.viewProjection, casterCenter);
const ShadowProjectionDebugPoint casterBottomProjection =
ProjectShadowPoint(request.directionalShadow.cameraData.viewProjection, casterBottomCenter);
const ShadowProjectionDebugPoint receiverFromCenterProjection =
ProjectShadowPoint(request.directionalShadow.cameraData.viewProjection, receiverFromCenter);
const ShadowProjectionDebugPoint receiverFromBottomProjection =
ProjectShadowPoint(request.directionalShadow.cameraData.viewProjection, receiverFromBottom);
Log(
"[TEST] ShadowProbe lightDirToLight=(%.4f, %.4f, %.4f) shadowRay=(%.4f, %.4f, %.4f) "
"groundTopY=%.4f centerTravel=%.4f bottomTravel=%.4f",
lightDirectionToLight.x, lightDirectionToLight.y, lightDirectionToLight.z,
shadowRayDirection.x, shadowRayDirection.y, shadowRayDirection.z,
groundTopY,
centerTravel,
bottomTravel);
LogShadowProjection(
"CasterCenter",
casterCenterProjection,
request.directionalShadow.mapWidth,
request.directionalShadow.mapHeight);
LogShadowProjection(
"CasterBottom",
casterBottomProjection,
request.directionalShadow.mapWidth,
request.directionalShadow.mapHeight);
LogShadowProjection(
"ReceiverFromCenter",
receiverFromCenterProjection,
request.directionalShadow.mapWidth,
request.directionalShadow.mapHeight);
LogShadowProjection(
"ReceiverFromBottom",
receiverFromBottomProjection,
request.directionalShadow.mapWidth,
request.directionalShadow.mapHeight);
Log(
"[TEST] ShadowProbe deltaUvFlip center=%.6f bottom=%.6f deltaUvNoFlip center=%.6f bottom=%.6f",
(receiverFromCenterProjection.uvFlipY - casterCenterProjection.uvFlipY).Magnitude(),
(receiverFromBottomProjection.uvFlipY - casterBottomProjection.uvFlipY).Magnitude(),
(receiverFromCenterProjection.uvNoFlipY - casterCenterProjection.uvNoFlipY).Magnitude(),
(receiverFromBottomProjection.uvNoFlipY - casterBottomProjection.uvNoFlipY).Magnitude());
}
class ShadowMapDebugOverlayPass final : public RenderPass {
public:
~ShadowMapDebugOverlayPass() override {
DestroyResources();
}
const char* GetName() const override {
return "ShadowMapDebugOverlayPass";
}
bool Initialize(const RenderContext& context) override {
return EnsureInitialized(context);
}
void ReleaseResources() {
DestroyResources();
}
void Shutdown() override {
Log("[TEST] ShadowMapDebugOverlayPass: Shutdown (deferred)");
}
bool Execute(const RenderPassContext& context) override {
Log("[TEST] ShadowMapDebugOverlayPass: Execute begin");
if (!context.renderContext.IsValid() ||
!context.sceneData.lighting.HasMainDirectionalShadow()) {
Log("[TEST] ShadowMapDebugOverlayPass: invalid context or missing shadow");
return false;
}
const std::vector<RHIResourceView*>& colorAttachments = context.surface.GetColorAttachments();
if (colorAttachments.empty() || colorAttachments[0] == nullptr) {
Log("[TEST] ShadowMapDebugOverlayPass: missing color attachment");
return false;
}
if (!EnsureInitialized(context.renderContext)) {
Log("[TEST] ShadowMapDebugOverlayPass: EnsureInitialized failed");
return false;
}
RHIResourceView* shadowMap = context.sceneData.lighting.mainDirectionalShadow.shadowMap;
if (shadowMap == nullptr) {
Log("[TEST] ShadowMapDebugOverlayPass: shadowMap null");
return false;
}
Log("[TEST] ShadowMapDebugOverlayPass: updating descriptors");
mTextureSet->Update(0, shadowMap);
RHICommandList* commandList = context.renderContext.commandList;
RHIResourceView* renderTarget = colorAttachments[0];
const XCEngine::Math::RectInt renderArea = context.surface.GetRenderArea();
const XCEngine::RHI::ResourceStates restoredColorState = context.surface.GetColorStateAfter();
if (context.surface.IsAutoTransitionEnabled()) {
Log("[TEST] ShadowMapDebugOverlayPass: transition color -> RT");
commandList->TransitionBarrier(
renderTarget,
restoredColorState,
XCEngine::RHI::ResourceStates::RenderTarget);
}
Log("[TEST] ShadowMapDebugOverlayPass: transition shadow -> SRV");
commandList->TransitionBarrier(
shadowMap,
XCEngine::RHI::ResourceStates::DepthWrite,
XCEngine::RHI::ResourceStates::PixelShaderResource);
Log("[TEST] ShadowMapDebugOverlayPass: bind RT");
commandList->SetRenderTargets(1, &renderTarget, nullptr);
const XCEngine::RHI::Viewport viewport = {
static_cast<float>(renderArea.x),
static_cast<float>(renderArea.y),
static_cast<float>(renderArea.width),
static_cast<float>(renderArea.height),
0.0f,
1.0f
};
const XCEngine::RHI::Rect scissorRect = {
renderArea.x,
renderArea.y,
renderArea.x + renderArea.width,
renderArea.y + renderArea.height
};
Log("[TEST] ShadowMapDebugOverlayPass: set viewport/scissor");
commandList->SetViewport(viewport);
commandList->SetScissorRect(scissorRect);
commandList->SetPrimitiveTopology(XCEngine::RHI::PrimitiveTopology::TriangleList);
Log("[TEST] ShadowMapDebugOverlayPass: set pipeline");
commandList->SetPipelineState(mPipelineState);
RHIDescriptorSet* descriptorSets[] = { mTextureSet, mSamplerSet };
Log("[TEST] ShadowMapDebugOverlayPass: bind descriptors");
commandList->SetGraphicsDescriptorSets(0, 2, descriptorSets, mPipelineLayout);
Log("[TEST] ShadowMapDebugOverlayPass: draw");
commandList->Draw(3, 1, 0, 0);
Log("[TEST] ShadowMapDebugOverlayPass: end render pass");
commandList->EndRenderPass();
Log("[TEST] ShadowMapDebugOverlayPass: transition shadow -> DepthWrite");
commandList->TransitionBarrier(
shadowMap,
XCEngine::RHI::ResourceStates::PixelShaderResource,
XCEngine::RHI::ResourceStates::DepthWrite);
if (context.surface.IsAutoTransitionEnabled()) {
Log("[TEST] ShadowMapDebugOverlayPass: transition color -> restore");
commandList->TransitionBarrier(
renderTarget,
XCEngine::RHI::ResourceStates::RenderTarget,
restoredColorState);
}
Log("[TEST] ShadowMapDebugOverlayPass: Execute end");
return true;
}
private:
bool EnsureInitialized(const RenderContext& context) {
if (mPipelineLayout != nullptr &&
mPipelineState != nullptr &&
mTexturePool != nullptr &&
mTextureSet != nullptr &&
mSamplerPool != nullptr &&
mSamplerSet != nullptr &&
mSampler != nullptr &&
mDevice == context.device &&
mBackendType == context.backendType) {
return true;
}
DestroyResources();
return CreateResources(context);
}
bool CreateResources(const RenderContext& context) {
Log("[TEST] ShadowMapDebugOverlayPass: CreateResources backend=%d", static_cast<int>(context.backendType));
mDevice = context.device;
mBackendType = context.backendType;
SamplerDesc samplerDesc = {};
samplerDesc.filter = static_cast<uint32_t>(FilterMode::Point);
samplerDesc.addressU = static_cast<uint32_t>(TextureAddressMode::Clamp);
samplerDesc.addressV = static_cast<uint32_t>(TextureAddressMode::Clamp);
samplerDesc.addressW = static_cast<uint32_t>(TextureAddressMode::Clamp);
samplerDesc.comparisonFunc = static_cast<uint32_t>(ComparisonFunc::Always);
samplerDesc.maxAnisotropy = 1;
samplerDesc.minLod = 0.0f;
samplerDesc.maxLod = 1000.0f;
mSampler = mDevice->CreateSampler(samplerDesc);
if (mSampler == nullptr) {
Log("[TEST] ShadowMapDebugOverlayPass: CreateSampler failed");
DestroyResources();
return false;
}
DescriptorSetLayoutBinding textureBinding = {};
textureBinding.binding = 0;
textureBinding.type = static_cast<uint32_t>(DescriptorType::SRV);
textureBinding.count = 1;
textureBinding.visibility = static_cast<uint32_t>(ShaderVisibility::Pixel);
DescriptorSetLayoutDesc textureLayout = {};
textureLayout.bindings = &textureBinding;
textureLayout.bindingCount = 1;
DescriptorPoolDesc texturePoolDesc = {};
texturePoolDesc.type = DescriptorHeapType::CBV_SRV_UAV;
texturePoolDesc.descriptorCount = 1;
texturePoolDesc.shaderVisible = true;
mTexturePool = mDevice->CreateDescriptorPool(texturePoolDesc);
if (mTexturePool == nullptr) {
Log("[TEST] ShadowMapDebugOverlayPass: texture pool failed");
DestroyResources();
return false;
}
mTextureSet = mTexturePool->AllocateSet(textureLayout);
if (mTextureSet == nullptr) {
Log("[TEST] ShadowMapDebugOverlayPass: texture set failed");
DestroyResources();
return false;
}
DescriptorSetLayoutBinding samplerBinding = {};
samplerBinding.binding = 0;
samplerBinding.type = static_cast<uint32_t>(DescriptorType::Sampler);
samplerBinding.count = 1;
samplerBinding.visibility = static_cast<uint32_t>(ShaderVisibility::Pixel);
DescriptorSetLayoutDesc samplerLayout = {};
samplerLayout.bindings = &samplerBinding;
samplerLayout.bindingCount = 1;
DescriptorPoolDesc samplerPoolDesc = {};
samplerPoolDesc.type = DescriptorHeapType::Sampler;
samplerPoolDesc.descriptorCount = 1;
samplerPoolDesc.shaderVisible = true;
mSamplerPool = mDevice->CreateDescriptorPool(samplerPoolDesc);
if (mSamplerPool == nullptr) {
Log("[TEST] ShadowMapDebugOverlayPass: sampler pool failed");
DestroyResources();
return false;
}
mSamplerSet = mSamplerPool->AllocateSet(samplerLayout);
if (mSamplerSet == nullptr) {
Log("[TEST] ShadowMapDebugOverlayPass: sampler set failed");
DestroyResources();
return false;
}
mSamplerSet->UpdateSampler(0, mSampler);
DescriptorSetLayoutDesc setLayouts[] = { textureLayout, samplerLayout };
RHIPipelineLayoutDesc pipelineLayoutDesc = {};
pipelineLayoutDesc.setLayouts = setLayouts;
pipelineLayoutDesc.setLayoutCount = 2;
mPipelineLayout = mDevice->CreatePipelineLayout(pipelineLayoutDesc);
if (mPipelineLayout == nullptr) {
Log("[TEST] ShadowMapDebugOverlayPass: pipeline layout failed");
DestroyResources();
return false;
}
GraphicsPipelineDesc pipelineDesc = {};
pipelineDesc.pipelineLayout = mPipelineLayout;
pipelineDesc.topologyType = static_cast<uint32_t>(PrimitiveTopologyType::Triangle);
pipelineDesc.renderTargetCount = 1;
pipelineDesc.renderTargetFormats[0] = static_cast<uint32_t>(Format::R8G8B8A8_UNorm);
pipelineDesc.depthStencilFormat = static_cast<uint32_t>(Format::Unknown);
pipelineDesc.sampleCount = 1;
pipelineDesc.rasterizerState.fillMode = static_cast<uint32_t>(FillMode::Solid);
pipelineDesc.rasterizerState.cullMode = static_cast<uint32_t>(CullMode::None);
pipelineDesc.rasterizerState.frontFace = static_cast<uint32_t>(FrontFace::CounterClockwise);
pipelineDesc.rasterizerState.depthClipEnable = true;
pipelineDesc.blendState.blendEnable = false;
pipelineDesc.blendState.colorWriteMask = static_cast<uint8_t>(ColorWriteMask::All);
pipelineDesc.depthStencilState.depthTestEnable = false;
pipelineDesc.depthStencilState.depthWriteEnable = false;
pipelineDesc.depthStencilState.depthFunc = static_cast<uint32_t>(ComparisonFunc::Always);
if (mBackendType == RHIType::D3D12) {
pipelineDesc.vertexShader.source.assign(
kShadowMapDebugHlsl,
kShadowMapDebugHlsl + strlen(kShadowMapDebugHlsl));
pipelineDesc.vertexShader.sourceLanguage = XCEngine::RHI::ShaderLanguage::HLSL;
pipelineDesc.vertexShader.entryPoint = L"MainVS";
pipelineDesc.vertexShader.profile = L"vs_5_0";
pipelineDesc.fragmentShader.source.assign(
kShadowMapDebugHlsl,
kShadowMapDebugHlsl + strlen(kShadowMapDebugHlsl));
pipelineDesc.fragmentShader.sourceLanguage = XCEngine::RHI::ShaderLanguage::HLSL;
pipelineDesc.fragmentShader.entryPoint = L"MainPS";
pipelineDesc.fragmentShader.profile = L"ps_5_0";
} else {
pipelineDesc.vertexShader.source.assign(
kShadowMapDebugVertexShader,
kShadowMapDebugVertexShader + strlen(kShadowMapDebugVertexShader));
pipelineDesc.vertexShader.sourceLanguage = XCEngine::RHI::ShaderLanguage::GLSL;
pipelineDesc.vertexShader.entryPoint = L"main";
if (mBackendType == RHIType::OpenGL) {
pipelineDesc.vertexShader.profile = L"vs_4_30";
}
pipelineDesc.fragmentShader.source.assign(
kShadowMapDebugFragmentShader,
kShadowMapDebugFragmentShader + strlen(kShadowMapDebugFragmentShader));
pipelineDesc.fragmentShader.sourceLanguage = XCEngine::RHI::ShaderLanguage::GLSL;
pipelineDesc.fragmentShader.entryPoint = L"main";
if (mBackendType == RHIType::OpenGL) {
pipelineDesc.fragmentShader.profile = L"fs_4_30";
}
}
mPipelineState = mDevice->CreatePipelineState(pipelineDesc);
if (mPipelineState == nullptr || !mPipelineState->IsValid()) {
Log("[TEST] ShadowMapDebugOverlayPass: pipeline state failed");
DestroyResources();
return false;
}
Log("[TEST] ShadowMapDebugOverlayPass: CreateResources success");
return true;
}
void DestroyResources() {
Log("[TEST] ShadowMapDebugOverlayPass: DestroyResources begin");
if (mPipelineState != nullptr) {
Log("[TEST] ShadowMapDebugOverlayPass: destroy pipeline state");
mPipelineState->Shutdown();
delete mPipelineState;
mPipelineState = nullptr;
}
if (mPipelineLayout != nullptr) {
Log("[TEST] ShadowMapDebugOverlayPass: destroy pipeline layout");
mPipelineLayout->Shutdown();
delete mPipelineLayout;
mPipelineLayout = nullptr;
}
if (mTextureSet != nullptr) {
Log("[TEST] ShadowMapDebugOverlayPass: destroy texture set");
mTextureSet->Shutdown();
delete mTextureSet;
mTextureSet = nullptr;
}
if (mTexturePool != nullptr) {
Log("[TEST] ShadowMapDebugOverlayPass: destroy texture pool");
mTexturePool->Shutdown();
delete mTexturePool;
mTexturePool = nullptr;
}
if (mSamplerSet != nullptr) {
Log("[TEST] ShadowMapDebugOverlayPass: destroy sampler set");
mSamplerSet->Shutdown();
delete mSamplerSet;
mSamplerSet = nullptr;
}
if (mSamplerPool != nullptr) {
Log("[TEST] ShadowMapDebugOverlayPass: destroy sampler pool");
mSamplerPool->Shutdown();
delete mSamplerPool;
mSamplerPool = nullptr;
}
if (mSampler != nullptr) {
Log("[TEST] ShadowMapDebugOverlayPass: destroy sampler");
mSampler->Shutdown();
delete mSampler;
mSampler = nullptr;
}
mDevice = nullptr;
mBackendType = RHIType::D3D12;
Log("[TEST] ShadowMapDebugOverlayPass: DestroyResources end");
}
RHIDevice* mDevice = nullptr;
RHIType mBackendType = RHIType::D3D12;
RHIPipelineLayout* mPipelineLayout = nullptr;
RHIPipelineState* mPipelineState = nullptr;
RHIDescriptorPool* mTexturePool = nullptr;
RHIDescriptorSet* mTextureSet = nullptr;
RHIDescriptorPool* mSamplerPool = nullptr;
RHIDescriptorSet* mSamplerSet = nullptr;
RHISampler* mSampler = nullptr;
};
class DirectionalShadowSceneTest : public RHIIntegrationFixture {
protected:
void SetUp() override;
void TearDown() override;
void RenderFrame() override;
void RenderSceneFrame(bool visualizeShadowMap);
private:
void BuildScene();
RHIResourceView* GetCurrentBackBufferView();
std::unique_ptr<Scene> mScene;
std::unique_ptr<SceneRenderer> mSceneRenderer;
RenderPassSequence mShadowMapDebugPasses;
ShadowMapDebugOverlayPass* mShadowMapDebugOverlayPass = nullptr;
bool mLoggedShadowProbe = false;
std::vector<RHIResourceView*> mBackBufferViews;
RHITexture* mDepthTexture = nullptr;
RHIResourceView* mDepthView = nullptr;
Mesh* mGroundMesh = nullptr;
Mesh* mCubeMesh = nullptr;
Material* mGroundMaterial = nullptr;
Material* mCasterMaterial = nullptr;
};
void DirectionalShadowSceneTest::SetUp() {
RHIIntegrationFixture::SetUp();
mSceneRenderer = std::make_unique<SceneRenderer>();
mScene = std::make_unique<Scene>("DirectionalShadowScene");
mGroundMesh = CreateGroundMesh();
ASSERT_NE(mGroundMesh, nullptr);
mCubeMesh = CreateCubeMesh();
ASSERT_NE(mCubeMesh, nullptr);
mGroundMaterial = CreateForwardLitMaterial(
"DirectionalShadowGround",
"Tests/Rendering/DirectionalShadowGround.material",
Vector4(0.92f, 0.93f, 0.96f, 1.0f));
mCasterMaterial = CreateForwardLitMaterial(
"DirectionalShadowCaster",
"Tests/Rendering/DirectionalShadowCaster.material",
Vector4(0.72f, 0.22f, 0.16f, 1.0f));
auto shadowMapDebugPass = std::make_unique<ShadowMapDebugOverlayPass>();
mShadowMapDebugOverlayPass = shadowMapDebugPass.get();
mShadowMapDebugPasses.AddPass(std::move(shadowMapDebugPass));
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 DirectionalShadowSceneTest::TearDown() {
mSceneRenderer.reset();
if (mShadowMapDebugOverlayPass != nullptr) {
mShadowMapDebugOverlayPass->ReleaseResources();
mShadowMapDebugOverlayPass = nullptr;
}
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 mGroundMaterial;
mGroundMaterial = nullptr;
delete mCasterMaterial;
mCasterMaterial = nullptr;
delete mGroundMesh;
mGroundMesh = nullptr;
delete mCubeMesh;
mCubeMesh = nullptr;
RHIIntegrationFixture::TearDown();
}
void DirectionalShadowSceneTest::BuildScene() {
ASSERT_NE(mScene, nullptr);
ASSERT_NE(mGroundMesh, nullptr);
ASSERT_NE(mCubeMesh, nullptr);
ASSERT_NE(mGroundMaterial, nullptr);
ASSERT_NE(mCasterMaterial, nullptr);
GameObject* cameraObject = mScene->CreateGameObject("MainCamera");
auto* camera = cameraObject->AddComponent<CameraComponent>();
camera->SetPrimary(true);
camera->SetFieldOfView(42.0f);
camera->SetNearClipPlane(0.1f);
camera->SetFarClipPlane(40.0f);
camera->SetClearColor(XCEngine::Math::Color(0.03f, 0.03f, 0.05f, 1.0f));
cameraObject->GetTransform()->SetLocalPosition(Vector3(0.2f, 3.4f, -7.2f));
cameraObject->GetTransform()->SetLocalRotation(
Quaternion::LookRotation(Vector3(-0.12f, -0.14f, 1.0f).Normalized()));
GameObject* lightObject = mScene->CreateGameObject("MainDirectionalLight");
auto* light = lightObject->AddComponent<LightComponent>();
light->SetLightType(LightType::Directional);
light->SetColor(XCEngine::Math::Color(1.0f, 1.0f, 0.97f, 1.0f));
light->SetIntensity(2.3f);
light->SetCastsShadows(true);
lightObject->GetTransform()->SetLocalRotation(
Quaternion::LookRotation(Vector3(0.84f, -0.52f, -0.14f).Normalized()));
GameObject* groundObject = mScene->CreateGameObject("Ground");
auto* groundMeshFilter = groundObject->AddComponent<MeshFilterComponent>();
auto* groundMeshRenderer = groundObject->AddComponent<MeshRendererComponent>();
groundObject->GetTransform()->SetLocalPosition(Vector3(0.0f, -0.18f, 10.5f));
groundObject->GetTransform()->SetLocalScale(Vector3(12.0f, 0.18f, 9.5f));
groundMeshFilter->SetMesh(ResourceHandle<Mesh>(mCubeMesh));
groundMeshRenderer->SetMaterial(0, mGroundMaterial);
groundMeshRenderer->SetCastShadows(false);
groundMeshRenderer->SetReceiveShadows(true);
GameObject* casterObject = mScene->CreateGameObject("CasterCube");
casterObject->GetTransform()->SetLocalPosition(Vector3(-1.2f, 1.71f, 8.8f));
casterObject->GetTransform()->SetLocalScale(Vector3(1.8f, 3.6f, 1.8f));
auto* casterMeshFilter = casterObject->AddComponent<MeshFilterComponent>();
auto* casterMeshRenderer = casterObject->AddComponent<MeshRendererComponent>();
casterMeshFilter->SetMesh(ResourceHandle<Mesh>(mCubeMesh));
casterMeshRenderer->SetMaterial(0, mCasterMaterial);
casterMeshRenderer->SetCastShadows(true);
casterMeshRenderer->SetReceiveShadows(true);
}
RHIResourceView* DirectionalShadowSceneTest::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 DirectionalShadowSceneTest::RenderFrame() {
RenderSceneFrame(false);
}
void DirectionalShadowSceneTest::RenderSceneFrame(bool visualizeShadowMap) {
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();
std::vector<CameraRenderRequest> requests =
mSceneRenderer->BuildRenderRequests(*mScene, nullptr, renderContext, surface);
ASSERT_FALSE(requests.empty());
if (!mLoggedShadowProbe) {
LogShadowAlignmentAnalysis(*mScene, requests[0]);
mLoggedShadowProbe = true;
}
if (visualizeShadowMap) {
requests[0].overlayPasses = &mShadowMapDebugPasses;
}
ASSERT_TRUE(mSceneRenderer->Render(requests));
Log("[TEST] DirectionalShadowSceneTest: closing command list");
commandList->Close();
void* commandLists[] = { commandList };
Log("[TEST] DirectionalShadowSceneTest: executing command list");
GetCommandQueue()->ExecuteCommandLists(1, commandLists);
Log("[TEST] DirectionalShadowSceneTest: execute submitted");
}
TEST_P(DirectionalShadowSceneTest, RenderDirectionalShadowScene) {
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);
}
}
TEST_P(DirectionalShadowSceneTest, RenderDirectionalShadowMapDebug) {
RHICommandQueue* commandQueue = GetCommandQueue();
RHISwapChain* swapChain = GetSwapChain();
const int targetFrameCount = 30;
const char* screenshotFilename = GetShadowMapScreenshotFilename(GetBackendType());
for (int frameCount = 0; frameCount <= targetFrameCount; ++frameCount) {
if (frameCount > 0) {
commandQueue->WaitForPreviousFrame();
}
BeginRender();
RenderSceneFrame(true);
if (frameCount >= targetFrameCount) {
commandQueue->WaitForIdle();
ASSERT_TRUE(TakeScreenshot(screenshotFilename));
break;
}
swapChain->Present(0, 0);
}
}
} // namespace
INSTANTIATE_TEST_SUITE_P(D3D12, DirectionalShadowSceneTest, ::testing::Values(RHIType::D3D12));
INSTANTIATE_TEST_SUITE_P(OpenGL, DirectionalShadowSceneTest, ::testing::Values(RHIType::OpenGL));
#if defined(XCENGINE_SUPPORT_VULKAN)
INSTANTIATE_TEST_SUITE_P(Vulkan, DirectionalShadowSceneTest, ::testing::Values(RHIType::Vulkan));
#endif
GTEST_API_ int main(int argc, char** argv) {
return RunRenderingIntegrationTestMain(argc, argv);
}
Reference in New Issue View Git Blame Copy Permalink