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

rendering: unify builtin forward and depth-style shaders

Browse Source
This commit is contained in:
ssdfasd
2026-04-07 03:35:06 +08:00
parent 503ffbc4ff
commit 5f9f3386ab
27 changed files with 1135 additions and 1151 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1547,7 +1547,7 @@ TEST(ShaderLoader, AssetDatabaseReimportsShaderWhenStageDependencyChanges) {
fs::remove_all(projectRoot);
}
TEST(ShaderLoader, LoadBuiltinForwardLitShaderBuildsBackendVariants) {
TEST(ShaderLoader, LoadBuiltinForwardLitShaderBuildsUnityStyleSingleSourceVariants) {
ShaderLoader loader;
LoadResult result = loader.Load(GetBuiltinForwardLitShaderPath());
ASSERT_TRUE(result);
@@ -1560,9 +1560,13 @@ TEST(ShaderLoader, LoadBuiltinForwardLitShaderBuildsBackendVariants) {
const ShaderPass* pass = shader->FindPass("ForwardLit");
ASSERT_NE(pass, nullptr);
ASSERT_EQ(shader->GetProperties().Size(), 3u);
ASSERT_EQ(pass->variants.Size(), 24u);
ASSERT_EQ(pass->variants.Size(), 8u);
ASSERT_EQ(pass->tags.Size(), 1u);
ASSERT_EQ(pass->resources.Size(), 8u);
EXPECT_TRUE(pass->resources.Empty());
EXPECT_TRUE(pass->hasFixedFunctionState);
EXPECT_EQ(pass->fixedFunctionState.cullMode, MaterialCullMode::Back);
EXPECT_TRUE(pass->fixedFunctionState.depthWriteEnable);
EXPECT_EQ(pass->fixedFunctionState.depthFunc, MaterialComparisonFunc::LessEqual);
EXPECT_EQ(pass->tags[0].name, "LightMode");
EXPECT_EQ(pass->tags[0].value, "ForwardBase");
@@ -1581,45 +1585,11 @@ TEST(ShaderLoader, LoadBuiltinForwardLitShaderBuildsBackendVariants) {
EXPECT_EQ(cutoffProperty->type, ShaderPropertyType::Range);
EXPECT_EQ(cutoffProperty->semantic, "AlphaCutoff");
const ShaderResourceBindingDesc* perObjectBinding =
shader->FindPassResourceBinding("ForwardLit", "PerObjectConstants");
ASSERT_NE(perObjectBinding, nullptr);
EXPECT_EQ(perObjectBinding->type, ShaderResourceType::ConstantBuffer);
EXPECT_EQ(perObjectBinding->set, 0u);
EXPECT_EQ(perObjectBinding->binding, 0u);
EXPECT_EQ(perObjectBinding->semantic, "PerObject");
const ShaderResourceBindingDesc* lightingBinding =
shader->FindPassResourceBinding("ForwardLit", "LightingConstants");
ASSERT_NE(lightingBinding, nullptr);
EXPECT_EQ(lightingBinding->type, ShaderResourceType::ConstantBuffer);
EXPECT_EQ(lightingBinding->set, 1u);
EXPECT_EQ(lightingBinding->binding, 0u);
EXPECT_EQ(lightingBinding->semantic, "Lighting");
const ShaderResourceBindingDesc* shadowReceiverBinding =
shader->FindPassResourceBinding("ForwardLit", "ShadowReceiverConstants");
ASSERT_NE(shadowReceiverBinding, nullptr);
EXPECT_EQ(shadowReceiverBinding->type, ShaderResourceType::ConstantBuffer);
EXPECT_EQ(shadowReceiverBinding->set, 3u);
EXPECT_EQ(shadowReceiverBinding->binding, 0u);
EXPECT_EQ(shadowReceiverBinding->semantic, "ShadowReceiver");
const ShaderResourceBindingDesc* baseColorBinding =
shader->FindPassResourceBinding("ForwardLit", "BaseColorTexture");
ASSERT_NE(baseColorBinding, nullptr);
EXPECT_EQ(baseColorBinding->type, ShaderResourceType::Texture2D);
EXPECT_EQ(baseColorBinding->set, 4u);
EXPECT_EQ(baseColorBinding->binding, 0u);
EXPECT_EQ(baseColorBinding->semantic, "BaseColorTexture");
const ShaderResourceBindingDesc* shadowTextureBinding =
shader->FindPassResourceBinding("ForwardLit", "ShadowMapTexture");
ASSERT_NE(shadowTextureBinding, nullptr);
EXPECT_EQ(shadowTextureBinding->type, ShaderResourceType::Texture2D);
EXPECT_EQ(shadowTextureBinding->set, 6u);
EXPECT_EQ(shadowTextureBinding->binding, 0u);
EXPECT_EQ(shadowTextureBinding->semantic, "ShadowMapTexture");
EXPECT_EQ(shader->FindPassResourceBinding("ForwardLit", "PerObjectConstants"), nullptr);
EXPECT_EQ(shader->FindPassResourceBinding("ForwardLit", "LightingConstants"), nullptr);
EXPECT_EQ(shader->FindPassResourceBinding("ForwardLit", "ShadowReceiverConstants"), nullptr);
EXPECT_EQ(shader->FindPassResourceBinding("ForwardLit", "BaseColorTexture"), nullptr);
EXPECT_EQ(shader->FindPassResourceBinding("ForwardLit", "ShadowMapTexture"), nullptr);
ASSERT_EQ(pass->keywordDeclarations.Size(), 2u);
EXPECT_EQ(pass->keywordDeclarations[0].type, ShaderKeywordDeclarationType::MultiCompile);
ASSERT_EQ(pass->keywordDeclarations[0].options.Size(), 2u);
@@ -1631,7 +1601,7 @@ TEST(ShaderLoader, LoadBuiltinForwardLitShaderBuildsBackendVariants) {
EXPECT_EQ(pass->keywordDeclarations[1].options[1], "XC_ALPHA_TEST");
EXPECT_TRUE(shader->PassDeclaresKeyword("ForwardLit", "XC_MAIN_LIGHT_SHADOWS"));
EXPECT_TRUE(shader->PassDeclaresKeyword("ForwardLit", "XC_ALPHA_TEST"));
ASSERT_EQ(pass->variants.Size(), 24u);
ASSERT_EQ(pass->variants.Size(), 8u);
EXPECT_NE(shader->FindVariant("ForwardLit", ShaderType::Vertex, ShaderBackend::D3D12), nullptr);
EXPECT_NE(shader->FindVariant("ForwardLit", ShaderType::Fragment, ShaderBackend::D3D12), nullptr);
@@ -1645,13 +1615,21 @@ TEST(ShaderLoader, LoadBuiltinForwardLitShaderBuildsBackendVariants) {
ShaderType::Vertex,
ShaderBackend::D3D12);
ASSERT_NE(d3d12Vertex, nullptr);
EXPECT_NE(std::string(d3d12Vertex->sourceCode.CStr()).find("XC_BUILTIN_FORWARD_LIT_D3D12_VS"), std::string::npos);
EXPECT_EQ(d3d12Vertex->backend, ShaderBackend::Generic);
EXPECT_EQ(d3d12Vertex->language, ShaderLanguage::HLSL);
EXPECT_EQ(d3d12Vertex->entryPoint, "MainVS");
EXPECT_EQ(d3d12Vertex->profile, "vs_5_0");
EXPECT_NE(std::string(d3d12Vertex->sourceCode.CStr()).find("cbuffer LightingConstants"), std::string::npos);
const ShaderStageVariant* d3d12Fragment = shader->FindVariant(
"ForwardLit",
ShaderType::Fragment,
ShaderBackend::D3D12);
ASSERT_NE(d3d12Fragment, nullptr);
EXPECT_EQ(d3d12Fragment->backend, ShaderBackend::Generic);
EXPECT_EQ(d3d12Fragment->language, ShaderLanguage::HLSL);
EXPECT_EQ(d3d12Fragment->entryPoint, "MainPS");
EXPECT_EQ(d3d12Fragment->profile, "ps_5_0");
EXPECT_NE(std::string(d3d12Fragment->sourceCode.CStr()).find("gAdditionalLights"), std::string::npos);
EXPECT_NE(std::string(d3d12Fragment->sourceCode.CStr()).find("gLightingParams"), std::string::npos);
EXPECT_EQ(std::string(d3d12Fragment->sourceCode.CStr()).find("#define XC_MAIN_LIGHT_SHADOWS 1"), std::string::npos);
@@ -1669,7 +1647,7 @@ TEST(ShaderLoader, LoadBuiltinForwardLitShaderBuildsBackendVariants) {
std::string(shadowD3D12Fragment->sourceCode.CStr()).find("#define XC_MAIN_LIGHT_SHADOWS 1"),
std::string::npos);
EXPECT_NE(
std::string(shadowD3D12Fragment->sourceCode.CStr()).find("gShadowMapTexture.Sample"),
std::string(shadowD3D12Fragment->sourceCode.CStr()).find("ShadowMapTexture.Sample"),
std::string::npos);
ShaderKeywordSet alphaShadowKeywords = {};
@@ -1695,13 +1673,13 @@ TEST(ShaderLoader, LoadBuiltinForwardLitShaderBuildsBackendVariants) {
ShaderBackend::OpenGL,
alphaShadowKeywords);
ASSERT_NE(alphaShadowOpenGLFragment, nullptr);
EXPECT_EQ(alphaShadowOpenGLFragment->backend, ShaderBackend::Generic);
EXPECT_EQ(alphaShadowOpenGLFragment->language, ShaderLanguage::HLSL);
EXPECT_EQ(alphaShadowOpenGLFragment->entryPoint, "MainPS");
EXPECT_EQ(alphaShadowOpenGLFragment->profile, "ps_5_0");
const std::string alphaShadowOpenGLSource = alphaShadowOpenGLFragment->sourceCode.CStr();
EXPECT_NE(alphaShadowOpenGLSource.find("#version 430"), std::string::npos);
EXPECT_NE(alphaShadowOpenGLSource.find("#define XC_ALPHA_TEST 1"), std::string::npos);
EXPECT_LT(
alphaShadowOpenGLSource.find("#version 430"),
alphaShadowOpenGLSource.find("#define XC_ALPHA_TEST 1"));
EXPECT_NE(alphaShadowOpenGLSource.find("discard;"), std::string::npos);
EXPECT_NE(alphaShadowOpenGLSource.find("clip(baseColor.a - gAlphaCutoffParams.x);"), std::string::npos);
const ShaderStageVariant* alphaShadowVulkanFragment = shader->FindVariant(
"ForwardLit",
@@ -1709,19 +1687,23 @@ TEST(ShaderLoader, LoadBuiltinForwardLitShaderBuildsBackendVariants) {
ShaderBackend::Vulkan,
alphaShadowKeywords);
ASSERT_NE(alphaShadowVulkanFragment, nullptr);
EXPECT_EQ(alphaShadowVulkanFragment->backend, ShaderBackend::Generic);
EXPECT_EQ(alphaShadowVulkanFragment->language, ShaderLanguage::HLSL);
EXPECT_EQ(alphaShadowVulkanFragment->entryPoint, "MainPS");
EXPECT_EQ(alphaShadowVulkanFragment->profile, "ps_5_0");
const std::string alphaShadowVulkanSource = alphaShadowVulkanFragment->sourceCode.CStr();
EXPECT_NE(alphaShadowVulkanSource.find("#version 450"), std::string::npos);
EXPECT_NE(alphaShadowVulkanSource.find("#define XC_ALPHA_TEST 1"), std::string::npos);
EXPECT_LT(
alphaShadowVulkanSource.find("#version 450"),
alphaShadowVulkanSource.find("#define XC_ALPHA_TEST 1"));
EXPECT_NE(alphaShadowVulkanSource.find("ShadowMapTexture.Sample"), std::string::npos);
const ShaderStageVariant* openglFragment = shader->FindVariant(
"ForwardLit",
ShaderType::Fragment,
ShaderBackend::OpenGL);
ASSERT_NE(openglFragment, nullptr);
EXPECT_NE(std::string(openglFragment->sourceCode.CStr()).find("XC_BUILTIN_FORWARD_LIT_OPENGL_PS"), std::string::npos);
EXPECT_EQ(openglFragment->backend, ShaderBackend::Generic);
EXPECT_EQ(openglFragment->language, ShaderLanguage::HLSL);
EXPECT_EQ(openglFragment->entryPoint, "MainPS");
EXPECT_EQ(openglFragment->profile, "ps_5_0");
EXPECT_NE(std::string(openglFragment->sourceCode.CStr()).find("gAdditionalLights"), std::string::npos);
EXPECT_NE(std::string(openglFragment->sourceCode.CStr()).find("gLightingParams"), std::string::npos);
@@ -1730,14 +1712,17 @@ TEST(ShaderLoader, LoadBuiltinForwardLitShaderBuildsBackendVariants) {
ShaderType::Fragment,
ShaderBackend::Vulkan);
ASSERT_NE(vulkanFragment, nullptr);
EXPECT_NE(std::string(vulkanFragment->sourceCode.CStr()).find("XC_BUILTIN_FORWARD_LIT_VULKAN_PS"), std::string::npos);
EXPECT_EQ(vulkanFragment->backend, ShaderBackend::Generic);
EXPECT_EQ(vulkanFragment->language, ShaderLanguage::HLSL);
EXPECT_EQ(vulkanFragment->entryPoint, "MainPS");
EXPECT_EQ(vulkanFragment->profile, "ps_5_0");
EXPECT_NE(std::string(vulkanFragment->sourceCode.CStr()).find("gAdditionalLights"), std::string::npos);
EXPECT_NE(std::string(vulkanFragment->sourceCode.CStr()).find("gLightingParams"), std::string::npos);
delete shader;
}
TEST(ShaderLoader, LoadBuiltinUnlitShaderBuildsBackendVariants) {
TEST(ShaderLoader, LoadBuiltinUnlitShaderBuildsUnityStyleSingleSourceVariants) {
ShaderLoader loader;
LoadResult result = loader.Load(GetBuiltinUnlitShaderPath());
ASSERT_TRUE(result);
@@ -1750,9 +1735,13 @@ TEST(ShaderLoader, LoadBuiltinUnlitShaderBuildsBackendVariants) {
const ShaderPass* pass = shader->FindPass("Unlit");
ASSERT_NE(pass, nullptr);
ASSERT_EQ(shader->GetProperties().Size(), 2u);
ASSERT_EQ(pass->variants.Size(), 6u);
ASSERT_EQ(pass->variants.Size(), 2u);
ASSERT_EQ(pass->tags.Size(), 1u);
ASSERT_EQ(pass->resources.Size(), 4u);
EXPECT_TRUE(pass->resources.Empty());
EXPECT_TRUE(pass->hasFixedFunctionState);
EXPECT_EQ(pass->fixedFunctionState.cullMode, MaterialCullMode::Back);
EXPECT_TRUE(pass->fixedFunctionState.depthWriteEnable);
EXPECT_EQ(pass->fixedFunctionState.depthFunc, MaterialComparisonFunc::LessEqual);
EXPECT_EQ(pass->tags[0].name, "LightMode");
EXPECT_EQ(pass->tags[0].value, "Unlit");
@@ -1766,13 +1755,7 @@ TEST(ShaderLoader, LoadBuiltinUnlitShaderBuildsBackendVariants) {
EXPECT_EQ(baseMapProperty->type, ShaderPropertyType::Texture2D);
EXPECT_EQ(baseMapProperty->semantic, "BaseColorTexture");
const ShaderResourceBindingDesc* perObjectBinding =
shader->FindPassResourceBinding("Unlit", "PerObjectConstants");
ASSERT_NE(perObjectBinding, nullptr);
EXPECT_EQ(perObjectBinding->type, ShaderResourceType::ConstantBuffer);
EXPECT_EQ(perObjectBinding->set, 0u);
EXPECT_EQ(perObjectBinding->binding, 0u);
EXPECT_EQ(perObjectBinding->semantic, "PerObject");
EXPECT_EQ(shader->FindPassResourceBinding("Unlit", "PerObjectConstants"), nullptr);
EXPECT_NE(shader->FindVariant("Unlit", ShaderType::Vertex, ShaderBackend::D3D12), nullptr);
EXPECT_NE(shader->FindVariant("Unlit", ShaderType::Fragment, ShaderBackend::D3D12), nullptr);
@@ -1786,26 +1769,38 @@ TEST(ShaderLoader, LoadBuiltinUnlitShaderBuildsBackendVariants) {
ShaderType::Vertex,
ShaderBackend::D3D12);
ASSERT_NE(d3d12Vertex, nullptr);
EXPECT_NE(std::string(d3d12Vertex->sourceCode.CStr()).find("XC_BUILTIN_UNLIT_D3D12_VS"), std::string::npos);
EXPECT_EQ(d3d12Vertex->backend, ShaderBackend::Generic);
EXPECT_EQ(d3d12Vertex->language, ShaderLanguage::HLSL);
EXPECT_EQ(d3d12Vertex->entryPoint, "MainVS");
EXPECT_EQ(d3d12Vertex->profile, "vs_5_0");
EXPECT_NE(std::string(d3d12Vertex->sourceCode.CStr()).find("gProjectionMatrix"), std::string::npos);
const ShaderStageVariant* openglFragment = shader->FindVariant(
"Unlit",
ShaderType::Fragment,
ShaderBackend::OpenGL);
ASSERT_NE(openglFragment, nullptr);
EXPECT_NE(std::string(openglFragment->sourceCode.CStr()).find("XC_BUILTIN_UNLIT_OPENGL_PS"), std::string::npos);
EXPECT_EQ(openglFragment->backend, ShaderBackend::Generic);
EXPECT_EQ(openglFragment->language, ShaderLanguage::HLSL);
EXPECT_EQ(openglFragment->entryPoint, "MainPS");
EXPECT_EQ(openglFragment->profile, "ps_5_0");
EXPECT_NE(std::string(openglFragment->sourceCode.CStr()).find("BaseColorTexture.Sample"), std::string::npos);
const ShaderStageVariant* vulkanFragment = shader->FindVariant(
"Unlit",
ShaderType::Fragment,
ShaderBackend::Vulkan);
ASSERT_NE(vulkanFragment, nullptr);
EXPECT_NE(std::string(vulkanFragment->sourceCode.CStr()).find("XC_BUILTIN_UNLIT_VULKAN_PS"), std::string::npos);
EXPECT_EQ(vulkanFragment->backend, ShaderBackend::Generic);
EXPECT_EQ(vulkanFragment->language, ShaderLanguage::HLSL);
EXPECT_EQ(vulkanFragment->entryPoint, "MainPS");
EXPECT_EQ(vulkanFragment->profile, "ps_5_0");
EXPECT_NE(std::string(vulkanFragment->sourceCode.CStr()).find("gBaseColorFactor"), std::string::npos);
delete shader;
}
TEST(ShaderLoader, LoadBuiltinObjectIdShaderBuildsBackendVariants) {
TEST(ShaderLoader, LoadBuiltinObjectIdShaderBuildsUnityStyleSingleSourceVariants) {
ShaderLoader loader;
LoadResult result = loader.Load(GetBuiltinObjectIdShaderPath());
ASSERT_TRUE(result);
@@ -1817,12 +1812,12 @@ TEST(ShaderLoader, LoadBuiltinObjectIdShaderBuildsBackendVariants) {
const ShaderPass* pass = shader->FindPass("ObjectId");
ASSERT_NE(pass, nullptr);
ASSERT_EQ(pass->resources.Size(), 1u);
EXPECT_EQ(pass->resources[0].semantic, "PerObject");
EXPECT_EQ(pass->resources[0].type, ShaderResourceType::ConstantBuffer);
EXPECT_EQ(pass->resources[0].set, 0u);
EXPECT_EQ(pass->resources[0].binding, 0u);
ASSERT_EQ(pass->variants.Size(), 6u);
EXPECT_TRUE(pass->resources.Empty());
EXPECT_TRUE(pass->hasFixedFunctionState);
EXPECT_EQ(pass->fixedFunctionState.cullMode, MaterialCullMode::Back);
EXPECT_TRUE(pass->fixedFunctionState.depthWriteEnable);
EXPECT_EQ(pass->fixedFunctionState.depthFunc, MaterialComparisonFunc::LessEqual);
ASSERT_EQ(pass->variants.Size(), 2u);
ASSERT_EQ(pass->tags.Size(), 1u);
EXPECT_EQ(pass->tags[0].name, "LightMode");
EXPECT_EQ(pass->tags[0].value, "ObjectId");
@@ -1839,26 +1834,38 @@ TEST(ShaderLoader, LoadBuiltinObjectIdShaderBuildsBackendVariants) {
ShaderType::Vertex,
ShaderBackend::D3D12);
ASSERT_NE(d3d12Vertex, nullptr);
EXPECT_NE(std::string(d3d12Vertex->sourceCode.CStr()).find("XC_BUILTIN_OBJECT_ID_D3D12_VS"), std::string::npos);
EXPECT_EQ(d3d12Vertex->backend, ShaderBackend::Generic);
EXPECT_EQ(d3d12Vertex->language, ShaderLanguage::HLSL);
EXPECT_EQ(d3d12Vertex->entryPoint, "MainVS");
EXPECT_EQ(d3d12Vertex->profile, "vs_5_0");
EXPECT_NE(std::string(d3d12Vertex->sourceCode.CStr()).find("gObjectIdColor"), std::string::npos);
const ShaderStageVariant* openglFragment = shader->FindVariant(
"ObjectId",
ShaderType::Fragment,
ShaderBackend::OpenGL);
ASSERT_NE(openglFragment, nullptr);
EXPECT_NE(std::string(openglFragment->sourceCode.CStr()).find("XC_BUILTIN_OBJECT_ID_OPENGL_PS"), std::string::npos);
EXPECT_EQ(openglFragment->backend, ShaderBackend::Generic);
EXPECT_EQ(openglFragment->language, ShaderLanguage::HLSL);
EXPECT_EQ(openglFragment->entryPoint, "MainPS");
EXPECT_EQ(openglFragment->profile, "ps_5_0");
EXPECT_NE(std::string(openglFragment->sourceCode.CStr()).find("return gObjectIdColor;"), std::string::npos);
const ShaderStageVariant* vulkanFragment = shader->FindVariant(
"ObjectId",
ShaderType::Fragment,
ShaderBackend::Vulkan);
ASSERT_NE(vulkanFragment, nullptr);
EXPECT_NE(std::string(vulkanFragment->sourceCode.CStr()).find("XC_BUILTIN_OBJECT_ID_VULKAN_PS"), std::string::npos);
EXPECT_EQ(vulkanFragment->backend, ShaderBackend::Generic);
EXPECT_EQ(vulkanFragment->language, ShaderLanguage::HLSL);
EXPECT_EQ(vulkanFragment->entryPoint, "MainPS");
EXPECT_EQ(vulkanFragment->profile, "ps_5_0");
EXPECT_NE(std::string(vulkanFragment->sourceCode.CStr()).find("gModelMatrix"), std::string::npos);
delete shader;
}
TEST(ShaderLoader, LoadBuiltinDepthOnlyShaderBuildsBackendVariants) {
TEST(ShaderLoader, LoadBuiltinDepthOnlyShaderBuildsUnityStyleSingleSourceVariants) {
ShaderLoader loader;
LoadResult result = loader.Load(GetBuiltinDepthOnlyShaderPath());
ASSERT_TRUE(result);
@@ -1871,24 +1878,12 @@ TEST(ShaderLoader, LoadBuiltinDepthOnlyShaderBuildsBackendVariants) {
const ShaderPass* pass = shader->FindPass("DepthOnly");
ASSERT_NE(pass, nullptr);
ASSERT_EQ(shader->GetProperties().Size(), 3u);
ASSERT_EQ(pass->resources.Size(), 4u);
EXPECT_EQ(pass->resources[0].semantic, "PerObject");
EXPECT_EQ(pass->resources[0].type, ShaderResourceType::ConstantBuffer);
EXPECT_EQ(pass->resources[0].set, 0u);
EXPECT_EQ(pass->resources[0].binding, 0u);
EXPECT_EQ(pass->resources[1].semantic, "Material");
EXPECT_EQ(pass->resources[1].type, ShaderResourceType::ConstantBuffer);
EXPECT_EQ(pass->resources[1].set, 1u);
EXPECT_EQ(pass->resources[1].binding, 0u);
EXPECT_EQ(pass->resources[2].semantic, "BaseColorTexture");
EXPECT_EQ(pass->resources[2].type, ShaderResourceType::Texture2D);
EXPECT_EQ(pass->resources[2].set, 2u);
EXPECT_EQ(pass->resources[2].binding, 0u);
EXPECT_EQ(pass->resources[3].semantic, "LinearClampSampler");
EXPECT_EQ(pass->resources[3].type, ShaderResourceType::Sampler);
EXPECT_EQ(pass->resources[3].set, 3u);
EXPECT_EQ(pass->resources[3].binding, 0u);
ASSERT_EQ(pass->variants.Size(), 12u);
EXPECT_TRUE(pass->resources.Empty());
EXPECT_TRUE(pass->hasFixedFunctionState);
EXPECT_EQ(pass->fixedFunctionState.cullMode, MaterialCullMode::Back);
EXPECT_TRUE(pass->fixedFunctionState.depthWriteEnable);
EXPECT_EQ(pass->fixedFunctionState.depthFunc, MaterialComparisonFunc::LessEqual);
ASSERT_EQ(pass->variants.Size(), 4u);
ASSERT_EQ(pass->tags.Size(), 1u);
EXPECT_EQ(pass->tags[0].name, "LightMode");
EXPECT_EQ(pass->tags[0].value, "DepthOnly");
@@ -1897,6 +1892,27 @@ TEST(ShaderLoader, LoadBuiltinDepthOnlyShaderBuildsBackendVariants) {
ASSERT_EQ(pass->keywordDeclarations[0].options.Size(), 2u);
EXPECT_EQ(pass->keywordDeclarations[0].options[0], "_");
EXPECT_EQ(pass->keywordDeclarations[0].options[1], "XC_ALPHA_TEST");
EXPECT_TRUE(shader->PassDeclaresKeyword("DepthOnly", "XC_ALPHA_TEST"));
const ShaderPropertyDesc* baseColorProperty = shader->FindProperty("_BaseColor");
ASSERT_NE(baseColorProperty, nullptr);
EXPECT_EQ(baseColorProperty->type, ShaderPropertyType::Color);
EXPECT_EQ(baseColorProperty->semantic, "BaseColor");
const ShaderPropertyDesc* cutoffProperty = shader->FindProperty("_Cutoff");
ASSERT_NE(cutoffProperty, nullptr);
EXPECT_EQ(cutoffProperty->type, ShaderPropertyType::Range);
EXPECT_EQ(cutoffProperty->semantic, "AlphaCutoff");
const ShaderPropertyDesc* baseMapProperty = shader->FindProperty("_MainTex");
ASSERT_NE(baseMapProperty, nullptr);
EXPECT_EQ(baseMapProperty->type, ShaderPropertyType::Texture2D);
EXPECT_EQ(baseMapProperty->semantic, "BaseColorTexture");
EXPECT_EQ(shader->FindPassResourceBinding("DepthOnly", "PerObjectConstants"), nullptr);
EXPECT_EQ(shader->FindPassResourceBinding("DepthOnly", "MaterialConstants"), nullptr);
EXPECT_EQ(shader->FindPassResourceBinding("DepthOnly", "BaseColorTexture"), nullptr);
EXPECT_EQ(shader->FindPassResourceBinding("DepthOnly", "LinearClampSampler"), nullptr);
EXPECT_NE(shader->FindVariant("DepthOnly", ShaderType::Vertex, ShaderBackend::D3D12), nullptr);
EXPECT_NE(shader->FindVariant("DepthOnly", ShaderType::Fragment, ShaderBackend::D3D12), nullptr);
@@ -1910,21 +1926,33 @@ TEST(ShaderLoader, LoadBuiltinDepthOnlyShaderBuildsBackendVariants) {
ShaderType::Vertex,
ShaderBackend::D3D12);
ASSERT_NE(d3d12Vertex, nullptr);
EXPECT_NE(std::string(d3d12Vertex->sourceCode.CStr()).find("XC_BUILTIN_DEPTH_ONLY_D3D12_VS"), std::string::npos);
EXPECT_EQ(d3d12Vertex->backend, ShaderBackend::Generic);
EXPECT_EQ(d3d12Vertex->language, ShaderLanguage::HLSL);
EXPECT_EQ(d3d12Vertex->entryPoint, "MainVS");
EXPECT_EQ(d3d12Vertex->profile, "vs_5_0");
EXPECT_NE(std::string(d3d12Vertex->sourceCode.CStr()).find("gProjectionMatrix"), std::string::npos);
const ShaderStageVariant* openglFragment = shader->FindVariant(
"DepthOnly",
ShaderType::Fragment,
ShaderBackend::OpenGL);
ASSERT_NE(openglFragment, nullptr);
EXPECT_NE(std::string(openglFragment->sourceCode.CStr()).find("XC_BUILTIN_DEPTH_ONLY_OPENGL_PS"), std::string::npos);
EXPECT_EQ(openglFragment->backend, ShaderBackend::Generic);
EXPECT_EQ(openglFragment->language, ShaderLanguage::HLSL);
EXPECT_EQ(openglFragment->entryPoint, "MainPS");
EXPECT_EQ(openglFragment->profile, "ps_5_0");
EXPECT_NE(std::string(openglFragment->sourceCode.CStr()).find("BaseColorTexture.Sample"), std::string::npos);
const ShaderStageVariant* vulkanFragment = shader->FindVariant(
"DepthOnly",
ShaderType::Fragment,
ShaderBackend::Vulkan);
ASSERT_NE(vulkanFragment, nullptr);
EXPECT_NE(std::string(vulkanFragment->sourceCode.CStr()).find("XC_BUILTIN_DEPTH_ONLY_VULKAN_PS"), std::string::npos);
EXPECT_EQ(vulkanFragment->backend, ShaderBackend::Generic);
EXPECT_EQ(vulkanFragment->language, ShaderLanguage::HLSL);
EXPECT_EQ(vulkanFragment->entryPoint, "MainPS");
EXPECT_EQ(vulkanFragment->profile, "ps_5_0");
EXPECT_NE(std::string(vulkanFragment->sourceCode.CStr()).find("gAlphaCutoffParams"), std::string::npos);
ShaderKeywordSet alphaKeywords = {};
alphaKeywords.enabledKeywords.PushBack("XC_ALPHA_TEST");
@@ -1935,6 +1963,10 @@ TEST(ShaderLoader, LoadBuiltinDepthOnlyShaderBuildsBackendVariants) {
ShaderBackend::D3D12,
alphaKeywords);
ASSERT_NE(alphaD3D12Fragment, nullptr);
EXPECT_EQ(alphaD3D12Fragment->backend, ShaderBackend::Generic);
EXPECT_EQ(alphaD3D12Fragment->language, ShaderLanguage::HLSL);
EXPECT_EQ(alphaD3D12Fragment->entryPoint, "MainPS");
EXPECT_EQ(alphaD3D12Fragment->profile, "ps_5_0");
EXPECT_NE(
std::string(alphaD3D12Fragment->sourceCode.CStr()).find("#define XC_ALPHA_TEST 1"),
std::string::npos);
@@ -1948,18 +1980,18 @@ TEST(ShaderLoader, LoadBuiltinDepthOnlyShaderBuildsBackendVariants) {
ShaderBackend::OpenGL,
alphaKeywords);
ASSERT_NE(alphaOpenGLFragment, nullptr);
EXPECT_EQ(alphaOpenGLFragment->backend, ShaderBackend::Generic);
EXPECT_EQ(alphaOpenGLFragment->language, ShaderLanguage::HLSL);
EXPECT_EQ(alphaOpenGLFragment->entryPoint, "MainPS");
EXPECT_EQ(alphaOpenGLFragment->profile, "ps_5_0");
const std::string alphaOpenGLSource = alphaOpenGLFragment->sourceCode.CStr();
EXPECT_NE(alphaOpenGLSource.find("#version 430"), std::string::npos);
EXPECT_NE(alphaOpenGLSource.find("#define XC_ALPHA_TEST 1"), std::string::npos);
EXPECT_LT(
alphaOpenGLSource.find("#version 430"),
alphaOpenGLSource.find("#define XC_ALPHA_TEST 1"));
EXPECT_NE(alphaOpenGLSource.find("discard;"), std::string::npos);
EXPECT_NE(alphaOpenGLSource.find("clip(baseColor.a - gAlphaCutoffParams.x);"), std::string::npos);
delete shader;
}
TEST(ShaderLoader, LoadBuiltinShadowCasterShaderBuildsBackendVariants) {
TEST(ShaderLoader, LoadBuiltinShadowCasterShaderBuildsUnityStyleSingleSourceVariants) {
ShaderLoader loader;
LoadResult result = loader.Load(GetBuiltinShadowCasterShaderPath());
ASSERT_TRUE(result);
@@ -1972,24 +2004,12 @@ TEST(ShaderLoader, LoadBuiltinShadowCasterShaderBuildsBackendVariants) {
const ShaderPass* pass = shader->FindPass("ShadowCaster");
ASSERT_NE(pass, nullptr);
ASSERT_EQ(shader->GetProperties().Size(), 3u);
ASSERT_EQ(pass->resources.Size(), 4u);
EXPECT_EQ(pass->resources[0].semantic, "PerObject");
EXPECT_EQ(pass->resources[0].type, ShaderResourceType::ConstantBuffer);
EXPECT_EQ(pass->resources[0].set, 0u);
EXPECT_EQ(pass->resources[0].binding, 0u);
EXPECT_EQ(pass->resources[1].semantic, "Material");
EXPECT_EQ(pass->resources[1].type, ShaderResourceType::ConstantBuffer);
EXPECT_EQ(pass->resources[1].set, 1u);
EXPECT_EQ(pass->resources[1].binding, 0u);
EXPECT_EQ(pass->resources[2].semantic, "BaseColorTexture");
EXPECT_EQ(pass->resources[2].type, ShaderResourceType::Texture2D);
EXPECT_EQ(pass->resources[2].set, 2u);
EXPECT_EQ(pass->resources[2].binding, 0u);
EXPECT_EQ(pass->resources[3].semantic, "LinearClampSampler");
EXPECT_EQ(pass->resources[3].type, ShaderResourceType::Sampler);
EXPECT_EQ(pass->resources[3].set, 3u);
EXPECT_EQ(pass->resources[3].binding, 0u);
ASSERT_EQ(pass->variants.Size(), 12u);
EXPECT_TRUE(pass->resources.Empty());
EXPECT_TRUE(pass->hasFixedFunctionState);
EXPECT_EQ(pass->fixedFunctionState.cullMode, MaterialCullMode::Back);
EXPECT_TRUE(pass->fixedFunctionState.depthWriteEnable);
EXPECT_EQ(pass->fixedFunctionState.depthFunc, MaterialComparisonFunc::LessEqual);
ASSERT_EQ(pass->variants.Size(), 4u);
ASSERT_EQ(pass->tags.Size(), 1u);
EXPECT_EQ(pass->tags[0].name, "LightMode");
EXPECT_EQ(pass->tags[0].value, "ShadowCaster");
@@ -1998,6 +2018,27 @@ TEST(ShaderLoader, LoadBuiltinShadowCasterShaderBuildsBackendVariants) {
ASSERT_EQ(pass->keywordDeclarations[0].options.Size(), 2u);
EXPECT_EQ(pass->keywordDeclarations[0].options[0], "_");
EXPECT_EQ(pass->keywordDeclarations[0].options[1], "XC_ALPHA_TEST");
EXPECT_TRUE(shader->PassDeclaresKeyword("ShadowCaster", "XC_ALPHA_TEST"));
const ShaderPropertyDesc* baseColorProperty = shader->FindProperty("_BaseColor");
ASSERT_NE(baseColorProperty, nullptr);
EXPECT_EQ(baseColorProperty->type, ShaderPropertyType::Color);
EXPECT_EQ(baseColorProperty->semantic, "BaseColor");
const ShaderPropertyDesc* cutoffProperty = shader->FindProperty("_Cutoff");
ASSERT_NE(cutoffProperty, nullptr);
EXPECT_EQ(cutoffProperty->type, ShaderPropertyType::Range);
EXPECT_EQ(cutoffProperty->semantic, "AlphaCutoff");
const ShaderPropertyDesc* baseMapProperty = shader->FindProperty("_MainTex");
ASSERT_NE(baseMapProperty, nullptr);
EXPECT_EQ(baseMapProperty->type, ShaderPropertyType::Texture2D);
EXPECT_EQ(baseMapProperty->semantic, "BaseColorTexture");
EXPECT_EQ(shader->FindPassResourceBinding("ShadowCaster", "PerObjectConstants"), nullptr);
EXPECT_EQ(shader->FindPassResourceBinding("ShadowCaster", "MaterialConstants"), nullptr);
EXPECT_EQ(shader->FindPassResourceBinding("ShadowCaster", "BaseColorTexture"), nullptr);
EXPECT_EQ(shader->FindPassResourceBinding("ShadowCaster", "LinearClampSampler"), nullptr);
EXPECT_NE(shader->FindVariant("ShadowCaster", ShaderType::Vertex, ShaderBackend::D3D12), nullptr);
EXPECT_NE(shader->FindVariant("ShadowCaster", ShaderType::Fragment, ShaderBackend::D3D12), nullptr);
@@ -2011,27 +2052,33 @@ TEST(ShaderLoader, LoadBuiltinShadowCasterShaderBuildsBackendVariants) {
ShaderType::Vertex,
ShaderBackend::D3D12);
ASSERT_NE(d3d12Vertex, nullptr);
EXPECT_NE(
std::string(d3d12Vertex->sourceCode.CStr()).find("XC_BUILTIN_SHADOW_CASTER_D3D12_VS"),
std::string::npos);
EXPECT_EQ(d3d12Vertex->backend, ShaderBackend::Generic);
EXPECT_EQ(d3d12Vertex->language, ShaderLanguage::HLSL);
EXPECT_EQ(d3d12Vertex->entryPoint, "MainVS");
EXPECT_EQ(d3d12Vertex->profile, "vs_5_0");
EXPECT_NE(std::string(d3d12Vertex->sourceCode.CStr()).find("gProjectionMatrix"), std::string::npos);
const ShaderStageVariant* openglFragment = shader->FindVariant(
"ShadowCaster",
ShaderType::Fragment,
ShaderBackend::OpenGL);
ASSERT_NE(openglFragment, nullptr);
EXPECT_NE(
std::string(openglFragment->sourceCode.CStr()).find("XC_BUILTIN_SHADOW_CASTER_OPENGL_PS"),
std::string::npos);
EXPECT_EQ(openglFragment->backend, ShaderBackend::Generic);
EXPECT_EQ(openglFragment->language, ShaderLanguage::HLSL);
EXPECT_EQ(openglFragment->entryPoint, "MainPS");
EXPECT_EQ(openglFragment->profile, "ps_5_0");
EXPECT_NE(std::string(openglFragment->sourceCode.CStr()).find("return input.position.z;"), std::string::npos);
const ShaderStageVariant* vulkanFragment = shader->FindVariant(
"ShadowCaster",
ShaderType::Fragment,
ShaderBackend::Vulkan);
ASSERT_NE(vulkanFragment, nullptr);
EXPECT_NE(
std::string(vulkanFragment->sourceCode.CStr()).find("XC_BUILTIN_SHADOW_CASTER_VULKAN_PS"),
std::string::npos);
EXPECT_EQ(vulkanFragment->backend, ShaderBackend::Generic);
EXPECT_EQ(vulkanFragment->language, ShaderLanguage::HLSL);
EXPECT_EQ(vulkanFragment->entryPoint, "MainPS");
EXPECT_EQ(vulkanFragment->profile, "ps_5_0");
EXPECT_NE(std::string(vulkanFragment->sourceCode.CStr()).find("gAlphaCutoffParams"), std::string::npos);
ShaderKeywordSet alphaKeywords = {};
alphaKeywords.enabledKeywords.PushBack("XC_ALPHA_TEST");
@@ -2042,6 +2089,10 @@ TEST(ShaderLoader, LoadBuiltinShadowCasterShaderBuildsBackendVariants) {
ShaderBackend::D3D12,
alphaKeywords);
ASSERT_NE(alphaD3D12Fragment, nullptr);
EXPECT_EQ(alphaD3D12Fragment->backend, ShaderBackend::Generic);
EXPECT_EQ(alphaD3D12Fragment->language, ShaderLanguage::HLSL);
EXPECT_EQ(alphaD3D12Fragment->entryPoint, "MainPS");
EXPECT_EQ(alphaD3D12Fragment->profile, "ps_5_0");
EXPECT_NE(
std::string(alphaD3D12Fragment->sourceCode.CStr()).find("#define XC_ALPHA_TEST 1"),
std::string::npos);
@@ -2055,13 +2106,13 @@ TEST(ShaderLoader, LoadBuiltinShadowCasterShaderBuildsBackendVariants) {
ShaderBackend::OpenGL,
alphaKeywords);
ASSERT_NE(alphaOpenGLFragment, nullptr);
EXPECT_EQ(alphaOpenGLFragment->backend, ShaderBackend::Generic);
EXPECT_EQ(alphaOpenGLFragment->language, ShaderLanguage::HLSL);
EXPECT_EQ(alphaOpenGLFragment->entryPoint, "MainPS");
EXPECT_EQ(alphaOpenGLFragment->profile, "ps_5_0");
const std::string alphaOpenGLSource = alphaOpenGLFragment->sourceCode.CStr();
EXPECT_NE(alphaOpenGLSource.find("#version 430"), std::string::npos);
EXPECT_NE(alphaOpenGLSource.find("#define XC_ALPHA_TEST 1"), std::string::npos);
EXPECT_LT(
alphaOpenGLSource.find("#version 430"),
alphaOpenGLSource.find("#define XC_ALPHA_TEST 1"));
EXPECT_NE(alphaOpenGLSource.find("discard;"), std::string::npos);
EXPECT_NE(alphaOpenGLSource.find("clip(baseColor.a - gAlphaCutoffParams.x);"), std::string::npos);
delete shader;
}
@@ -2125,19 +2176,19 @@ TEST(ShaderLoader, ResourceManagerLoadsBuiltinShadersOutsideProjectWorkingDirect
"ForwardLit",
ShaderType::Vertex,
ShaderBackend::D3D12,
"XC_BUILTIN_FORWARD_LIT_D3D12_VS");
"cbuffer LightingConstants");
expectBuiltinShader(
GetBuiltinUnlitShaderPath(),
"Unlit",
ShaderType::Fragment,
ShaderBackend::OpenGL,
"XC_BUILTIN_UNLIT_OPENGL_PS");
"BaseColorTexture");
expectBuiltinShader(
GetBuiltinObjectIdShaderPath(),
"ObjectId",
ShaderType::Fragment,
ShaderBackend::Vulkan,
"XC_BUILTIN_OBJECT_ID_VULKAN_PS");
"return gObjectIdColor;");
fs::current_path(previousPath);
manager.SetResourceRoot(previousResourceRoot);