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

Add gaussian splat compute shader contracts

Browse Source
This commit is contained in:
ssdfasd
2026-04-11 01:30:59 +08:00
parent 4080b2e5fe
commit d9bc0f1457
9 changed files with 442 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
engine/assets/builtin/shaders/gaussian-splat-utilities.shader Normal file
View File

@@ -0,0 +1,56 @@
Shader "Builtin Gaussian Splat Utilities"
{
HLSLINCLUDE
uint FloatToSortableUint(float value)
{
const uint rawValue = asuint(value);
const uint mask = (rawValue & 0x80000000u) != 0u ? 0xffffffffu : 0x80000000u;
return rawValue ^ mask;
}
ENDHLSL
SubShader
{
Pass
{
Name "GaussianSplatPrepareOrder"
HLSLPROGRAM
#pragma target 4.5
#pragma compute GaussianSplatPrepareOrderCS
cbuffer PerObjectConstants
{
float4x4 gProjectionMatrix;
float4x4 gViewMatrix;
float4x4 gModelMatrix;
float4 gCameraRight;
float4 gCameraUp;
};
StructuredBuffer<float3> GaussianSplatPositions;
RWStructuredBuffer<uint> GaussianSplatSortDistances;
RWStructuredBuffer<uint> GaussianSplatOrderBuffer;
[numthreads(64, 1, 1)]
void GaussianSplatPrepareOrderCS(uint3 dispatchThreadId : SV_DispatchThreadID)
{
uint splatCount = 0u;
GaussianSplatOrderBuffer.GetDimensions(splatCount);
const uint index = dispatchThreadId.x;
if (index >= splatCount)
{
return;
}
GaussianSplatOrderBuffer[index] = index;
const float3 localCenter = GaussianSplatPositions[index];
const float3 viewCenter =
mul(gViewMatrix, mul(gModelMatrix, float4(localCenter, 1.0))).xyz;
GaussianSplatSortDistances[index] = FloatToSortableUint(viewCenter.z);
}
ENDHLSL
}
}
}

18
engine/include/XCEngine/Rendering/Builtin/BuiltinPassLayoutUtils.h
View File

@@ -62,6 +62,12 @@ inline bool TryBuildBuiltinPassResourceBindingPlan(
case BuiltinPassResourceSemantic::VolumeField:
location = &outPlan.volumeField;
break;
case BuiltinPassResourceSemantic::GaussianSplatSortDistanceBuffer:
location = &outPlan.gaussianSplatSortDistanceBuffer;
break;
case BuiltinPassResourceSemantic::GaussianSplatOrderBuffer:
location = &outPlan.gaussianSplatOrderBuffer;
break;
case BuiltinPassResourceSemantic::GaussianSplatPositionBuffer:
location = &outPlan.gaussianSplatPositionBuffer;
break;
@@ -74,6 +80,9 @@ inline bool TryBuildBuiltinPassResourceBindingPlan(
case BuiltinPassResourceSemantic::GaussianSplatSHBuffer:
location = &outPlan.gaussianSplatSHBuffer;
break;
case BuiltinPassResourceSemantic::GaussianSplatViewDataBuffer:
location = &outPlan.gaussianSplatViewDataBuffer;
break;
case BuiltinPassResourceSemantic::BaseColorTexture:
location = &outPlan.baseColorTexture;
break;
@@ -600,6 +609,12 @@ inline bool TryBuildBuiltinPassSetLayouts(
case BuiltinPassResourceSemantic::VolumeField:
setLayout.usesVolumeField = true;
break;
case BuiltinPassResourceSemantic::GaussianSplatSortDistanceBuffer:
setLayout.usesGaussianSplatSortDistanceBuffer = true;
break;
case BuiltinPassResourceSemantic::GaussianSplatOrderBuffer:
setLayout.usesGaussianSplatOrderBuffer = true;
break;
case BuiltinPassResourceSemantic::GaussianSplatPositionBuffer:
setLayout.usesGaussianSplatPositionBuffer = true;
break;
@@ -612,6 +627,9 @@ inline bool TryBuildBuiltinPassSetLayouts(
case BuiltinPassResourceSemantic::GaussianSplatSHBuffer:
setLayout.usesGaussianSplatSHBuffer = true;
break;
case BuiltinPassResourceSemantic::GaussianSplatViewDataBuffer:
setLayout.usesGaussianSplatViewDataBuffer = true;
break;
case BuiltinPassResourceSemantic::BaseColorTexture:
setLayout.usesTexture = true;
setLayout.usesBaseColorTexture = true;

31
engine/include/XCEngine/Rendering/Builtin/BuiltinPassMetadataUtils.h
View File

@@ -147,6 +147,18 @@ inline BuiltinPassResourceSemantic ResolveBuiltinPassResourceSemantic(
return BuiltinPassResourceSemantic::VolumeField;
}
if (semantic == Containers::String("gaussiansplatsortdistancebuffer") ||
semantic == Containers::String("gaussiansplatsortdistances") ||
semantic == Containers::String("splatsortdistances")) {
return BuiltinPassResourceSemantic::GaussianSplatSortDistanceBuffer;
}
if (semantic == Containers::String("gaussiansplatorderbuffer") ||
semantic == Containers::String("gaussiansplatorder") ||
semantic == Containers::String("orderbuffer")) {
return BuiltinPassResourceSemantic::GaussianSplatOrderBuffer;
}
if (semantic == Containers::String("gaussiansplatpositionbuffer") ||
semantic == Containers::String("gaussiansplatpositions") ||
semantic == Containers::String("splatpositions")) {
@@ -171,6 +183,12 @@ inline BuiltinPassResourceSemantic ResolveBuiltinPassResourceSemantic(
return BuiltinPassResourceSemantic::GaussianSplatSHBuffer;
}
if (semantic == Containers::String("gaussiansplatviewdatabuffer") ||
semantic == Containers::String("gaussiansplatviewdata") ||
semantic == Containers::String("splatviewdata")) {
return BuiltinPassResourceSemantic::GaussianSplatViewDataBuffer;
}
if (semantic == Containers::String("basecolortexture") ||
semantic == Containers::String("maintex")) {
return BuiltinPassResourceSemantic::BaseColorTexture;
@@ -233,6 +251,10 @@ inline const char* BuiltinPassResourceSemanticToString(BuiltinPassResourceSemant
return "PassConstants";
case BuiltinPassResourceSemantic::VolumeField:
return "VolumeField";
case BuiltinPassResourceSemantic::GaussianSplatSortDistanceBuffer:
return "GaussianSplatSortDistanceBuffer";
case BuiltinPassResourceSemantic::GaussianSplatOrderBuffer:
return "GaussianSplatOrderBuffer";
case BuiltinPassResourceSemantic::GaussianSplatPositionBuffer:
return "GaussianSplatPositionBuffer";
case BuiltinPassResourceSemantic::GaussianSplatOtherBuffer:
@@ -241,6 +263,8 @@ inline const char* BuiltinPassResourceSemanticToString(BuiltinPassResourceSemant
return "GaussianSplatColorBuffer";
case BuiltinPassResourceSemantic::GaussianSplatSHBuffer:
return "GaussianSplatSHBuffer";
case BuiltinPassResourceSemantic::GaussianSplatViewDataBuffer:
return "GaussianSplatViewDataBuffer";
case BuiltinPassResourceSemantic::BaseColorTexture:
return "BaseColorTexture";
case BuiltinPassResourceSemantic::SourceColorTexture:
@@ -329,12 +353,17 @@ inline bool IsBuiltinPassResourceTypeCompatible(
case BuiltinPassResourceSemantic::VolumeField:
return type == Resources::ShaderResourceType::StructuredBuffer ||
type == Resources::ShaderResourceType::RawBuffer;
case BuiltinPassResourceSemantic::GaussianSplatSortDistanceBuffer:
case BuiltinPassResourceSemantic::GaussianSplatOrderBuffer:
case BuiltinPassResourceSemantic::GaussianSplatPositionBuffer:
case BuiltinPassResourceSemantic::GaussianSplatOtherBuffer:
case BuiltinPassResourceSemantic::GaussianSplatColorBuffer:
case BuiltinPassResourceSemantic::GaussianSplatSHBuffer:
case BuiltinPassResourceSemantic::GaussianSplatViewDataBuffer:
return type == Resources::ShaderResourceType::StructuredBuffer ||
type == Resources::ShaderResourceType::RawBuffer;
type == Resources::ShaderResourceType::RawBuffer ||
type == Resources::ShaderResourceType::RWStructuredBuffer ||
type == Resources::ShaderResourceType::RWRawBuffer;
case BuiltinPassResourceSemantic::BaseColorTexture:
case BuiltinPassResourceSemantic::SourceColorTexture:
case BuiltinPassResourceSemantic::SkyboxPanoramicTexture:

6
engine/include/XCEngine/Rendering/Builtin/BuiltinPassTypes.h
View File

@@ -46,11 +46,13 @@ enum class BuiltinPassResourceSemantic : Core::uint8 {
Environment,
PassConstants,
VolumeField,
GaussianSplatSortDistanceBuffer,
GaussianSplatOrderBuffer,
GaussianSplatPositionBuffer,
GaussianSplatOtherBuffer,
GaussianSplatColorBuffer,
GaussianSplatSHBuffer,
GaussianSplatViewDataBuffer,
BaseColorTexture,
SourceColorTexture,
SkyboxPanoramicTexture,
@@ -84,11 +86,13 @@ struct BuiltinPassResourceBindingPlan {
PassResourceBindingLocation shadowReceiver = {};
PassResourceBindingLocation environment = {};
PassResourceBindingLocation passConstants = {};
PassResourceBindingLocation gaussianSplatSortDistanceBuffer = {};
PassResourceBindingLocation gaussianSplatOrderBuffer = {};
PassResourceBindingLocation gaussianSplatPositionBuffer = {};
PassResourceBindingLocation gaussianSplatOtherBuffer = {};
PassResourceBindingLocation gaussianSplatColorBuffer = {};
PassResourceBindingLocation gaussianSplatSHBuffer = {};
PassResourceBindingLocation gaussianSplatViewDataBuffer = {};
PassResourceBindingLocation baseColorTexture = {};
PassResourceBindingLocation sourceColorTexture = {};
PassResourceBindingLocation skyboxPanoramicTexture = {};
@@ -122,11 +126,13 @@ struct BuiltinPassSetLayoutMetadata {
bool usesPassConstants = false;
bool usesMaterialBuffers = false;
bool usesVolumeField = false;
bool usesGaussianSplatSortDistanceBuffer = false;
bool usesGaussianSplatOrderBuffer = false;
bool usesGaussianSplatPositionBuffer = false;
bool usesGaussianSplatOtherBuffer = false;
bool usesGaussianSplatColorBuffer = false;
bool usesGaussianSplatSHBuffer = false;
bool usesGaussianSplatViewDataBuffer = false;
bool usesTexture = false;
bool usesBaseColorTexture = false;
bool usesSourceColorTexture = false;

1
engine/include/XCEngine/Resources/BuiltinResources.h
View File

@@ -39,6 +39,7 @@ Containers::String GetBuiltinSelectionMaskShaderPath();
Containers::String GetBuiltinSelectionOutlineShaderPath();
Containers::String GetBuiltinSkyboxShaderPath();
Containers::String GetBuiltinGaussianSplatShaderPath();
Containers::String GetBuiltinGaussianSplatUtilitiesShaderPath();
Containers::String GetBuiltinVolumetricShaderPath();
Containers::String GetBuiltinColorScalePostProcessShaderPath();
Containers::String GetBuiltinFinalColorShaderPath();

20
engine/src/Resources/BuiltinResources.cpp
View File

@@ -37,6 +37,8 @@ constexpr const char* kBuiltinSelectionMaskShaderPath = "builtin://shaders/selec
constexpr const char* kBuiltinSelectionOutlineShaderPath = "builtin://shaders/selection-outline";
constexpr const char* kBuiltinSkyboxShaderPath = "builtin://shaders/skybox";
constexpr const char* kBuiltinGaussianSplatShaderPath = "builtin://shaders/gaussian-splat";
constexpr const char* kBuiltinGaussianSplatUtilitiesShaderPath =
"builtin://shaders/gaussian-splat-utilities";
constexpr const char* kBuiltinVolumetricShaderPath = "builtin://shaders/volumetric";
constexpr const char* kBuiltinColorScalePostProcessShaderPath =
"builtin://shaders/color-scale-post-process";
@@ -71,6 +73,8 @@ constexpr const char* kBuiltinSkyboxShaderAssetRelativePath =
"engine/assets/builtin/shaders/skybox.shader";
constexpr const char* kBuiltinGaussianSplatShaderAssetRelativePath =
"engine/assets/builtin/shaders/gaussian-splat.shader";
constexpr const char* kBuiltinGaussianSplatUtilitiesShaderAssetRelativePath =
"engine/assets/builtin/shaders/gaussian-splat-utilities.shader";
constexpr const char* kBuiltinVolumetricShaderAssetRelativePath =
"engine/assets/builtin/shaders/volumetric.shader";
constexpr const char* kBuiltinColorScalePostProcessShaderAssetRelativePath =
@@ -170,6 +174,9 @@ const char* GetBuiltinShaderAssetRelativePath(const Containers::String& builtinS
if (builtinShaderPath == Containers::String(kBuiltinGaussianSplatShaderPath)) {
return kBuiltinGaussianSplatShaderAssetRelativePath;
}
if (builtinShaderPath == Containers::String(kBuiltinGaussianSplatUtilitiesShaderPath)) {
return kBuiltinGaussianSplatUtilitiesShaderAssetRelativePath;
}
if (builtinShaderPath == Containers::String(kBuiltinVolumetricShaderPath)) {
return kBuiltinVolumetricShaderAssetRelativePath;
}
@@ -698,6 +705,9 @@ size_t CalculateBuiltinShaderMemorySize(const Shader& shader) {
memorySize += variant.profile.Length();
memorySize += variant.sourceCode.Length();
memorySize += variant.compiledBinary.Size();
for (const ShaderBackendCompiledBinary& record : variant.backendCompiledBinaries) {
memorySize += record.payload.Size();
}
}
}
@@ -866,6 +876,10 @@ bool TryGetBuiltinShaderPathByShaderName(
outPath = GetBuiltinGaussianSplatShaderPath();
return true;
}
if (shaderName == "Builtin Gaussian Splat Utilities") {
outPath = GetBuiltinGaussianSplatUtilitiesShaderPath();
return true;
}
if (shaderName == "Builtin Volumetric") {
outPath = GetBuiltinVolumetricShaderPath();
return true;
@@ -957,6 +971,10 @@ Containers::String GetBuiltinGaussianSplatShaderPath() {
return Containers::String(kBuiltinGaussianSplatShaderPath);
}
Containers::String GetBuiltinGaussianSplatUtilitiesShaderPath() {
return Containers::String(kBuiltinGaussianSplatUtilitiesShaderPath);
}
Containers::String GetBuiltinVolumetricShaderPath() {
return Containers::String(kBuiltinVolumetricShaderPath);
}
@@ -1077,6 +1095,8 @@ LoadResult CreateBuiltinShaderResource(const Containers::String& path) {
shader = BuildBuiltinSkyboxShader(path);
} else if (path == GetBuiltinGaussianSplatShaderPath()) {
shader = BuildBuiltinGaussianSplatShader(path);
} else if (path == GetBuiltinGaussianSplatUtilitiesShaderPath()) {
shader = TryLoadBuiltinShaderFromAsset(path);
} else if (path == GetBuiltinVolumetricShaderPath()) {
shader = BuildBuiltinVolumetricShader(path);
} else if (path == GetBuiltinColorScalePostProcessShaderPath()) {

27
engine/src/Resources/Shader/Internal/ShaderRuntimeBuildUtils.cpp
View File

@@ -192,8 +192,9 @@ void ImportConcretePass(Shader& shader, const ShaderPass& sourcePass) {
shader.AddPass(sourcePass);
}
bool IsBufferShaderResourceType(ShaderResourceType type) {
return type == ShaderResourceType::StructuredBuffer ||
bool IsScannedAuthoringResourceType(ShaderResourceType type) {
return type == ShaderResourceType::ConstantBuffer ||
type == ShaderResourceType::StructuredBuffer ||
type == ShaderResourceType::RawBuffer ||
type == ShaderResourceType::RWStructuredBuffer ||
type == ShaderResourceType::RWRawBuffer;
@@ -239,10 +240,13 @@ Core::uint32 FindNextBindingInSet(
return nextBinding;
}
bool TryParseHlslBufferResourceLine(
bool TryParseHlslAuthoringResourceLine(
const std::string& line,
ShaderResourceType& outType,
Containers::String& outName) {
static const std::regex kConstantBufferPattern(
R"(^\s*cbuffer\s+([A-Za-z_][A-Za-z0-9_]*)\s*(?::\s*register\s*\([^\)]*\))?\s*(?:\{\s*)?$)",
std::regex::ECMAScript);
static const std::regex kStructuredPattern(
R"(^\s*(?:globallycoherent\s+)?(RWStructuredBuffer|StructuredBuffer)\s*<[^;\r\n>]+>\s+([A-Za-z_][A-Za-z0-9_]*)\s*(?::\s*register\s*\([^\)]*\))?\s*;)",
std::regex::ECMAScript);
@@ -251,6 +255,12 @@ bool TryParseHlslBufferResourceLine(
std::regex::ECMAScript);
std::smatch match;
if (std::regex_match(line, match, kConstantBufferPattern) && match.size() >= 2u) {
outType = ShaderResourceType::ConstantBuffer;
outName = match[1].str().c_str();
return true;
}
if (std::regex_match(line, match, kStructuredPattern) && match.size() >= 3u) {
outType =
match[1].str() == "RWStructuredBuffer"
@@ -272,7 +282,7 @@ bool TryParseHlslBufferResourceLine(
return false;
}
void AppendScannedBufferResourceBindings(
void AppendScannedAuthoringResourceBindings(
const Containers::String& sourceText,
Containers::Array<ShaderResourceBindingDesc>& ioBindings) {
if (sourceText.Empty()) {
@@ -286,11 +296,11 @@ void AppendScannedBufferResourceBindings(
const std::string line = Internal::StripAuthoringLineComment(rawLine);
ShaderResourceType resourceType = ShaderResourceType::ConstantBuffer;
Containers::String resourceName;
if (!TryParseHlslBufferResourceLine(line, resourceType, resourceName)) {
if (!TryParseHlslAuthoringResourceLine(line, resourceType, resourceName)) {
continue;
}
if (!IsBufferShaderResourceType(resourceType) ||
if (!IsScannedAuthoringResourceType(resourceType) ||
resourceName.Empty() ||
HasResourceBindingNamed(ioBindings, resourceName)) {
continue;
@@ -354,7 +364,7 @@ ShaderPass BuildConcretePass(
}
}
}
AppendScannedBufferResourceBindings(strippedCombinedSource, shaderPass.resources);
AppendScannedAuthoringResourceBindings(strippedCombinedSource, shaderPass.resources);
const std::vector<ShaderKeywordSet> keywordSets =
BuildShaderKeywordVariantSets(pass.keywordDeclarations);
@@ -615,6 +625,9 @@ size_t CalculateShaderMemorySize(const Shader& shader) {
memorySize += variant.profile.Length();
memorySize += variant.sourceCode.Length();
memorySize += variant.compiledBinary.Size();
for (const ShaderBackendCompiledBinary& record : variant.backendCompiledBinaries) {
memorySize += record.payload.Size();
}
}
}

195
tests/Rendering/unit/test_builtin_forward_pipeline.cpp
View File

@@ -1087,6 +1087,201 @@ TEST(BuiltinForwardPipeline_Test, VulkanRuntimeCompileDescRewritesAuthoringGauss
delete shader;
}
TEST(BuiltinForwardPipeline_Test, BuiltinGaussianSplatUtilitiesShaderUsesComputeAuthoringContract) {
ShaderLoader loader;
LoadResult result = loader.Load(GetBuiltinGaussianSplatUtilitiesShaderPath());
ASSERT_TRUE(result);
ASSERT_NE(result.resource, nullptr);
Shader* shader = static_cast<Shader*>(result.resource);
ASSERT_NE(shader, nullptr);
const ShaderPass* pass = shader->FindPass("GaussianSplatPrepareOrder");
ASSERT_NE(pass, nullptr);
EXPECT_EQ(pass->resources.Size(), 4u);
const ShaderResourceBindingDesc* perObject =
shader->FindPassResourceBinding("GaussianSplatPrepareOrder", "PerObjectConstants");
ASSERT_NE(perObject, nullptr);
EXPECT_EQ(perObject->type, ShaderResourceType::ConstantBuffer);
EXPECT_EQ(perObject->set, 0u);
EXPECT_EQ(perObject->binding, 0u);
EXPECT_EQ(
ResolveBuiltinPassResourceSemantic(*perObject),
BuiltinPassResourceSemantic::PerObject);
const ShaderResourceBindingDesc* positions =
shader->FindPassResourceBinding("GaussianSplatPrepareOrder", "GaussianSplatPositions");
ASSERT_NE(positions, nullptr);
EXPECT_EQ(positions->type, ShaderResourceType::StructuredBuffer);
EXPECT_EQ(positions->set, 2u);
EXPECT_EQ(positions->binding, 0u);
EXPECT_EQ(
ResolveBuiltinPassResourceSemantic(*positions),
BuiltinPassResourceSemantic::GaussianSplatPositionBuffer);
const ShaderResourceBindingDesc* sortDistances =
shader->FindPassResourceBinding("GaussianSplatPrepareOrder", "GaussianSplatSortDistances");
ASSERT_NE(sortDistances, nullptr);
EXPECT_EQ(sortDistances->type, ShaderResourceType::RWStructuredBuffer);
EXPECT_EQ(sortDistances->set, 4u);
EXPECT_EQ(sortDistances->binding, 0u);
EXPECT_EQ(
ResolveBuiltinPassResourceSemantic(*sortDistances),
BuiltinPassResourceSemantic::GaussianSplatSortDistanceBuffer);
const ShaderResourceBindingDesc* orderBuffer =
shader->FindPassResourceBinding("GaussianSplatPrepareOrder", "GaussianSplatOrderBuffer");
ASSERT_NE(orderBuffer, nullptr);
EXPECT_EQ(orderBuffer->type, ShaderResourceType::RWStructuredBuffer);
EXPECT_EQ(orderBuffer->set, 4u);
EXPECT_EQ(orderBuffer->binding, 1u);
EXPECT_EQ(
ResolveBuiltinPassResourceSemantic(*orderBuffer),
BuiltinPassResourceSemantic::GaussianSplatOrderBuffer);
const ShaderStageVariant* computeVariant = shader->FindVariant(
"GaussianSplatPrepareOrder",
XCEngine::Resources::ShaderType::Compute,
XCEngine::Resources::ShaderBackend::D3D12);
ASSERT_NE(computeVariant, nullptr);
EXPECT_EQ(computeVariant->entryPoint, "GaussianSplatPrepareOrderCS");
delete shader;
}
TEST(BuiltinForwardPipeline_Test, BuildsBuiltinPassResourceBindingPlanFromLoadedGaussianSplatUtilitiesShaderContract) {
ShaderLoader loader;
LoadResult result = loader.Load(GetBuiltinGaussianSplatUtilitiesShaderPath());
ASSERT_TRUE(result);
ASSERT_NE(result.resource, nullptr);
Shader* shader = static_cast<Shader*>(result.resource);
ASSERT_NE(shader, nullptr);
const ShaderPass* pass = shader->FindPass("GaussianSplatPrepareOrder");
ASSERT_NE(pass, nullptr);
BuiltinPassResourceBindingPlan plan = {};
String error;
EXPECT_TRUE(TryBuildBuiltinPassResourceBindingPlan(*pass, plan, &error)) << error.CStr();
ASSERT_EQ(plan.bindings.Size(), 4u);
EXPECT_TRUE(plan.perObject.IsValid());
EXPECT_TRUE(plan.gaussianSplatPositionBuffer.IsValid());
EXPECT_TRUE(plan.gaussianSplatSortDistanceBuffer.IsValid());
EXPECT_TRUE(plan.gaussianSplatOrderBuffer.IsValid());
EXPECT_EQ(plan.perObject.set, 0u);
EXPECT_EQ(plan.gaussianSplatPositionBuffer.set, 2u);
EXPECT_EQ(plan.gaussianSplatSortDistanceBuffer.set, 4u);
EXPECT_EQ(plan.gaussianSplatSortDistanceBuffer.binding, 0u);
EXPECT_EQ(plan.gaussianSplatOrderBuffer.set, 4u);
EXPECT_EQ(plan.gaussianSplatOrderBuffer.binding, 1u);
EXPECT_EQ(plan.firstDescriptorSet, 0u);
EXPECT_EQ(plan.descriptorSetCount, 5u);
std::vector<BuiltinPassSetLayoutMetadata> setLayouts;
ASSERT_TRUE(TryBuildBuiltinPassSetLayouts(plan, setLayouts, &error)) << error.CStr();
ASSERT_EQ(setLayouts.size(), 5u);
EXPECT_TRUE(setLayouts[0].usesPerObject);
EXPECT_TRUE(setLayouts[2].usesGaussianSplatPositionBuffer);
EXPECT_TRUE(setLayouts[4].usesGaussianSplatSortDistanceBuffer);
EXPECT_TRUE(setLayouts[4].usesGaussianSplatOrderBuffer);
ASSERT_EQ(setLayouts[4].bindings.size(), 2u);
EXPECT_EQ(
static_cast<DescriptorType>(setLayouts[4].bindings[0].type),
DescriptorType::UAV);
EXPECT_EQ(
static_cast<DescriptorType>(setLayouts[4].bindings[1].type),
DescriptorType::UAV);
EXPECT_EQ(
setLayouts[4].bindings[0].resourceDimension,
ResourceViewDimension::StructuredBuffer);
EXPECT_EQ(
setLayouts[4].bindings[1].resourceDimension,
ResourceViewDimension::StructuredBuffer);
delete shader;
}
TEST(BuiltinForwardPipeline_Test, VulkanRuntimeCompileDescRewritesGaussianSplatUtilitiesComputeBindingsToDescriptorSpaces) {
ShaderLoader loader;
LoadResult result = loader.Load(GetBuiltinGaussianSplatUtilitiesShaderPath());
ASSERT_TRUE(result);
ASSERT_NE(result.resource, nullptr);
Shader* shader = static_cast<Shader*>(result.resource);
ASSERT_NE(shader, nullptr);
const ShaderPass* pass = shader->FindPass("GaussianSplatPrepareOrder");
ASSERT_NE(pass, nullptr);
const ShaderStageVariant* d3d12Compute = shader->FindVariant(
"GaussianSplatPrepareOrder",
XCEngine::Resources::ShaderType::Compute,
XCEngine::Resources::ShaderBackend::D3D12);
ASSERT_NE(d3d12Compute, nullptr);
ShaderCompileDesc d3d12CompileDesc = {};
::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
*pass,
XCEngine::Resources::ShaderBackend::D3D12,
*d3d12Compute,
d3d12CompileDesc);
const std::string d3d12Source(
reinterpret_cast<const char*>(d3d12CompileDesc.source.data()),
d3d12CompileDesc.source.size());
EXPECT_TRUE(SourceContainsRegisterBinding(
d3d12Source,
"cbuffer PerObjectConstants",
"register(b0)"));
EXPECT_TRUE(SourceContainsRegisterBinding(
d3d12Source,
"StructuredBuffer<float3> GaussianSplatPositions",
"register(t0)"));
EXPECT_TRUE(SourceContainsRegisterBinding(
d3d12Source,
"RWStructuredBuffer<uint> GaussianSplatSortDistances",
"register(u0)"));
EXPECT_TRUE(SourceContainsRegisterBinding(
d3d12Source,
"RWStructuredBuffer<uint> GaussianSplatOrderBuffer",
"register(u1)"));
const ShaderStageVariant* vulkanCompute = shader->FindVariant(
"GaussianSplatPrepareOrder",
XCEngine::Resources::ShaderType::Compute,
XCEngine::Resources::ShaderBackend::Vulkan);
ASSERT_NE(vulkanCompute, nullptr);
ShaderCompileDesc vulkanCompileDesc = {};
::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
*pass,
XCEngine::Resources::ShaderBackend::Vulkan,
*vulkanCompute,
vulkanCompileDesc);
const std::string vulkanSource(
reinterpret_cast<const char*>(vulkanCompileDesc.source.data()),
vulkanCompileDesc.source.size());
EXPECT_TRUE(SourceContainsRegisterBinding(
vulkanSource,
"cbuffer PerObjectConstants",
"register(b0, space0)"));
EXPECT_TRUE(SourceContainsRegisterBinding(
vulkanSource,
"StructuredBuffer<float3> GaussianSplatPositions",
"register(t0, space2)"));
EXPECT_TRUE(SourceContainsRegisterBinding(
vulkanSource,
"RWStructuredBuffer<uint> GaussianSplatSortDistances",
"register(u0, space4)"));
EXPECT_TRUE(SourceContainsRegisterBinding(
vulkanSource,
"RWStructuredBuffer<uint> GaussianSplatOrderBuffer",
"register(u1, space4)"));
delete shader;
}
TEST(BuiltinForwardPipeline_Test, BuiltinVolumetricShaderUsesAuthoringContract) {
ShaderLoader loader;
LoadResult result = loader.Load(GetBuiltinVolumetricShaderPath());

96
tests/Resources/Shader/test_shader_loader.cpp
View File

@@ -13,6 +13,7 @@
#include <cstdio>
#include <filesystem>
#include <fstream>
#include <regex>
#include <thread>
using namespace XCEngine::Resources;
@@ -71,6 +72,7 @@ TEST(ShaderLoader, CanLoad) {
EXPECT_TRUE(loader.CanLoad(GetBuiltinObjectIdOutlineShaderPath()));
EXPECT_TRUE(loader.CanLoad(GetBuiltinSelectionMaskShaderPath()));
EXPECT_TRUE(loader.CanLoad(GetBuiltinSelectionOutlineShaderPath()));
EXPECT_TRUE(loader.CanLoad(GetBuiltinGaussianSplatUtilitiesShaderPath()));
EXPECT_FALSE(loader.CanLoad("test.vert"));
EXPECT_FALSE(loader.CanLoad("test.frag"));
EXPECT_FALSE(loader.CanLoad("test.glsl"));
@@ -603,6 +605,100 @@ TEST(ShaderLoader, LoadShaderAuthoringBuildsComputeOnlyPassVariant) {
fs::remove_all(shaderRoot);
}
TEST(ShaderLoader, LoadShaderAuthoringBuildsComputeOnlyPassConstantBufferBindings) {
namespace fs = std::filesystem;
const fs::path shaderRoot = fs::temp_directory_path() / "xc_shader_authoring_compute_constants";
const fs::path shaderPath = shaderRoot / "compute_constants.shader";
fs::remove_all(shaderRoot);
fs::create_directories(shaderRoot);
WriteTextFile(
shaderPath,
R"(Shader "ComputeConstantsShader"
{
SubShader
{
Pass
{
Name "Prepare"
HLSLPROGRAM
#pragma target 4.5
#pragma compute PrepareCS
cbuffer PerObjectConstants
{
float4x4 ObjectToWorld;
};
StructuredBuffer<float4> InputData;
RWStructuredBuffer<uint> OutputOrder;
[numthreads(64, 1, 1)]
void PrepareCS(uint3 dispatchThreadId : SV_DispatchThreadID)
{
OutputOrder[dispatchThreadId.x] =
(uint)mul(ObjectToWorld, InputData[dispatchThreadId.x]).x;
}
ENDHLSL
}
}
}
)");
ShaderLoader loader;
LoadResult result = loader.Load(shaderPath.string().c_str());
ASSERT_TRUE(result);
ASSERT_NE(result.resource, nullptr);
Shader* shader = static_cast<Shader*>(result.resource);
ASSERT_NE(shader, nullptr);
const ShaderPass* pass = shader->FindPass("Prepare");
ASSERT_NE(pass, nullptr);
EXPECT_EQ(pass->resources.Size(), 3u);
const ShaderResourceBindingDesc* perObject =
shader->FindPassResourceBinding("Prepare", "PerObjectConstants");
ASSERT_NE(perObject, nullptr);
EXPECT_EQ(perObject->type, ShaderResourceType::ConstantBuffer);
EXPECT_EQ(perObject->set, 0u);
EXPECT_EQ(perObject->binding, 0u);
const ShaderStageVariant* computeVariant =
shader->FindVariant("Prepare", ShaderType::Compute, ShaderBackend::D3D12);
ASSERT_NE(computeVariant, nullptr);
XCEngine::RHI::ShaderCompileDesc d3d12CompileDesc = {};
::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
*pass,
ShaderBackend::D3D12,
*computeVariant,
d3d12CompileDesc);
const std::string d3d12Source(
reinterpret_cast<const char*>(d3d12CompileDesc.source.data()),
d3d12CompileDesc.source.size());
EXPECT_TRUE(std::regex_search(
d3d12Source,
std::regex(R"(cbuffer\s+PerObjectConstants\s*:\s*register\(b0\))", std::regex::ECMAScript)));
XCEngine::RHI::ShaderCompileDesc vulkanCompileDesc = {};
::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
*pass,
ShaderBackend::Vulkan,
*computeVariant,
vulkanCompileDesc);
const std::string vulkanSource(
reinterpret_cast<const char*>(vulkanCompileDesc.source.data()),
vulkanCompileDesc.source.size());
EXPECT_TRUE(std::regex_search(
vulkanSource,
std::regex(
R"(cbuffer\s+PerObjectConstants\s*:\s*register\(b0,\s*space0\))",
std::regex::ECMAScript)));
delete shader;
fs::remove_all(shaderRoot);
}
TEST(ShaderLoader, LoadShaderAuthoringRejectsPassMixingComputeAndGraphicsPragmas) {
namespace fs = std::filesystem;