Add builtin GaussianSplat forward pass baseline

2026-04-10 23:11:11 +08:00
parent 15b42c248f
commit 107b320aa7
12 changed files with 1642 additions and 19 deletions
--- a/tests/Rendering/unit/test_builtin_forward_pipeline.cpp
+++ b/tests/Rendering/unit/test_builtin_forward_pipeline.cpp
@@ -1,12 +1,14 @@
 #include <gtest/gtest.h>

-#include "Rendering/Detail/ShaderVariantUtils.h"
+#include "Rendering/Internal/ShaderVariantUtils.h"

 #include <XCEngine/Rendering/Builtin/BuiltinPassLayoutUtils.h>
+#include "Rendering/Internal/RenderSurfacePipelineUtils.h"
 #include <XCEngine/Rendering/Passes/BuiltinDepthOnlyPass.h>
 #include <XCEngine/Rendering/Passes/BuiltinObjectIdPass.h>
 #include <XCEngine/Rendering/Passes/BuiltinShadowCasterPass.h>
 #include <XCEngine/Rendering/Pipelines/BuiltinForwardPipeline.h>
+#include <XCEngine/Rendering/RenderSurface.h>
 #include <XCEngine/Resources/BuiltinResources.h>
 #include <XCEngine/Resources/Mesh/Mesh.h>
 #include <XCEngine/Resources/Shader/Shader.h>
@@ -87,6 +89,46 @@ void AppendDefaultBuiltinPassResources(ShaderPass& pass) {
    }
 }

+class TestResourceView final : public XCEngine::RHI::RHIResourceView {
+public:
+    TestResourceView(
+        XCEngine::RHI::ResourceViewType viewType,
+        XCEngine::RHI::ResourceViewDimension dimension,
+        XCEngine::RHI::Format format)
+        : m_viewType(viewType),
+          m_dimension(dimension),
+          m_format(format) {
+    }
+
+    void Shutdown() override {
+    }
+
+    void* GetNativeHandle() override {
+        return nullptr;
+    }
+
+    bool IsValid() const override {
+        return true;
+    }
+
+    XCEngine::RHI::ResourceViewType GetViewType() const override {
+        return m_viewType;
+    }
+
+    XCEngine::RHI::ResourceViewDimension GetDimension() const override {
+        return m_dimension;
+    }
+
+    XCEngine::RHI::Format GetFormat() const override {
+        return m_format;
+    }
+
+private:
+    XCEngine::RHI::ResourceViewType m_viewType;
+    XCEngine::RHI::ResourceViewDimension m_dimension;
+    XCEngine::RHI::Format m_format;
+};
+
 } // namespace

 TEST(BuiltinForwardPipeline_Test, UsesFloat3PositionInputLayoutForStaticMeshVertices) {
@@ -116,6 +158,162 @@ TEST(BuiltinForwardPipeline_Test, UsesFloat3PositionInputLayoutForStaticMeshVert
    EXPECT_EQ(texcoord.alignedByteOffset, static_cast<uint32_t>(offsetof(StaticMeshVertex, uv0)));
 }

+TEST(RenderSurfacePipelineUtils_Test, ResolvesContiguousSurfaceAttachmentFormatsIntoPipelineDesc) {
+    TestResourceView color0(
+        ResourceViewType::RenderTarget,
+        ResourceViewDimension::Texture2D,
+        Format::R16G16B16A16_Float);
+    TestResourceView color1(
+        ResourceViewType::RenderTarget,
+        ResourceViewDimension::Texture2D,
+        Format::R8G8B8A8_UNorm);
+    TestResourceView depth(
+        ResourceViewType::DepthStencil,
+        ResourceViewDimension::Texture2D,
+        Format::D32_Float);
+
+    RenderSurface surface(1280u, 720u);
+    surface.SetColorAttachments({ &color0, &color1 });
+    surface.SetDepthAttachment(&depth);
+    surface.SetSampleDesc(4u, 0u);
+
+    GraphicsPipelineDesc pipelineDesc = {};
+    XCEngine::Rendering::Internal::ApplySurfacePropertiesToGraphicsPipelineDesc(surface, pipelineDesc);
+
+    EXPECT_EQ(pipelineDesc.renderTargetCount, 2u);
+    EXPECT_EQ(static_cast<Format>(pipelineDesc.renderTargetFormats[0]), Format::R16G16B16A16_Float);
+    EXPECT_EQ(static_cast<Format>(pipelineDesc.renderTargetFormats[1]), Format::R8G8B8A8_UNorm);
+    EXPECT_EQ(static_cast<Format>(pipelineDesc.depthStencilFormat), Format::D32_Float);
+    EXPECT_EQ(pipelineDesc.sampleCount, 4u);
+    EXPECT_EQ(pipelineDesc.sampleQuality, 0u);
+}
+
+TEST(RenderSurfacePipelineUtils_Test, PropagatesSampleQualityIntoPipelineDesc) {
+    TestResourceView color0(
+        ResourceViewType::RenderTarget,
+        ResourceViewDimension::Texture2D,
+        Format::R8G8B8A8_UNorm);
+
+    RenderSurface surface(640u, 360u);
+    surface.SetColorAttachment(&color0);
+    surface.SetSampleDesc(4u, 3u);
+
+    GraphicsPipelineDesc pipelineDesc = {};
+    XCEngine::Rendering::Internal::ApplySingleColorAttachmentPropertiesToGraphicsPipelineDesc(surface, pipelineDesc);
+
+    EXPECT_EQ(pipelineDesc.renderTargetCount, 1u);
+    EXPECT_EQ(pipelineDesc.sampleCount, 4u);
+    EXPECT_EQ(pipelineDesc.sampleQuality, 3u);
+}
+
+TEST(RenderSurfacePipelineUtils_Test, StopsAtFirstNullColorAttachmentWhenResolvingFormats) {
+    TestResourceView color0(
+        ResourceViewType::RenderTarget,
+        ResourceViewDimension::Texture2D,
+        Format::R16G16B16A16_Float);
+    TestResourceView color2(
+        ResourceViewType::RenderTarget,
+        ResourceViewDimension::Texture2D,
+        Format::R8G8B8A8_UNorm);
+
+    RenderSurface surface(1280u, 720u);
+    surface.SetColorAttachments({ &color0, nullptr, &color2 });
+
+    const uint32_t colorAttachmentCount =
+        XCEngine::Rendering::Internal::ResolveSurfaceColorAttachmentCount(surface);
+    const auto colorFormats =
+        XCEngine::Rendering::Internal::ResolveSurfaceColorFormats(surface);
+
+    EXPECT_EQ(colorAttachmentCount, 1u);
+    EXPECT_EQ(static_cast<Format>(colorFormats[0]), Format::R16G16B16A16_Float);
+    EXPECT_EQ(static_cast<Format>(colorFormats[1]), Format::Unknown);
+}
+
+TEST(RenderSurfacePipelineUtils_Test, NormalizesInvalidSampleCountToSingleSample) {
+    RenderSurface surface(640u, 480u);
+    surface.SetSampleDesc(0u, 7u);
+
+    EXPECT_EQ(surface.GetSampleCount(), 1u);
+    EXPECT_EQ(surface.GetSampleQuality(), 0u);
+    EXPECT_EQ(XCEngine::Rendering::Internal::ResolveSurfaceSampleCount(surface), 1u);
+}
+
+TEST(RenderSurfacePipelineUtils_Test, AcceptsDepthStyleSurfaceWithDepthOnlyOutput) {
+    TestResourceView depth(
+        ResourceViewType::DepthStencil,
+        ResourceViewDimension::Texture2D,
+        Format::D32_Float);
+
+    RenderSurface surface(640u, 480u);
+    surface.SetDepthAttachment(&depth);
+    surface.SetSampleDesc(1u, 0u);
+
+    EXPECT_TRUE(XCEngine::Rendering::Internal::IsDepthStyleCompatibleSurface(surface));
+}
+
+TEST(RenderSurfacePipelineUtils_Test, RejectsDepthStyleSurfaceWithoutKnownDepthFormat) {
+    TestResourceView color(
+        ResourceViewType::RenderTarget,
+        ResourceViewDimension::Texture2D,
+        Format::R8G8B8A8_UNorm);
+
+    RenderSurface surface(640u, 480u);
+    surface.SetColorAttachment(&color);
+
+    EXPECT_FALSE(XCEngine::Rendering::Internal::IsDepthStyleCompatibleSurface(surface));
+}
+
+TEST(RenderSurfacePipelineUtils_Test, RejectsDepthStyleSurfaceWithUnknownSingleColorFormat) {
+    TestResourceView color(
+        ResourceViewType::RenderTarget,
+        ResourceViewDimension::Texture2D,
+        Format::Unknown);
+    TestResourceView depth(
+        ResourceViewType::DepthStencil,
+        ResourceViewDimension::Texture2D,
+        Format::D32_Float);
+
+    RenderSurface surface(640u, 480u);
+    surface.SetColorAttachment(&color);
+    surface.SetDepthAttachment(&depth);
+
+    EXPECT_FALSE(XCEngine::Rendering::Internal::IsDepthStyleCompatibleSurface(surface));
+}
+
+TEST(RenderSurfacePipelineUtils_Test, RejectsDepthStyleSurfaceWithMultipleColorAttachments) {
+    TestResourceView color0(
+        ResourceViewType::RenderTarget,
+        ResourceViewDimension::Texture2D,
+        Format::R16G16B16A16_Float);
+    TestResourceView color1(
+        ResourceViewType::RenderTarget,
+        ResourceViewDimension::Texture2D,
+        Format::R8G8B8A8_UNorm);
+    TestResourceView depth(
+        ResourceViewType::DepthStencil,
+        ResourceViewDimension::Texture2D,
+        Format::D32_Float);
+
+    RenderSurface surface(640u, 480u);
+    surface.SetColorAttachments({ &color0, &color1 });
+    surface.SetDepthAttachment(&depth);
+
+    EXPECT_FALSE(XCEngine::Rendering::Internal::IsDepthStyleCompatibleSurface(surface));
+}
+
+TEST(RenderSurface_Test, DefaultsDepthStateToDepthWriteAndSupportsOverrides) {
+    RenderSurface surface(640u, 480u);
+
+    EXPECT_EQ(surface.GetDepthStateBefore(), ResourceStates::DepthWrite);
+    EXPECT_EQ(surface.GetDepthStateAfter(), ResourceStates::DepthWrite);
+
+    surface.SetDepthStateBefore(ResourceStates::Common);
+    surface.SetDepthStateAfter(ResourceStates::PixelShaderResource);
+
+    EXPECT_EQ(surface.GetDepthStateBefore(), ResourceStates::Common);
+    EXPECT_EQ(surface.GetDepthStateAfter(), ResourceStates::PixelShaderResource);
+}
+
 TEST(BuiltinForwardPipeline_Test, SplitsSceneItemsIntoOpaqueAndTransparentQueueRanges) {
    EXPECT_FALSE(IsTransparentRenderQueue(static_cast<int>(MaterialRenderQueue::Background)));
    EXPECT_FALSE(IsTransparentRenderQueue(static_cast<int>(MaterialRenderQueue::Geometry)));
@@ -207,7 +405,7 @@ TEST(BuiltinForwardPipeline_Test, BuiltinUnlitShaderBuildsVulkanRuntimeSourceWit
    ASSERT_NE(fragmentVariant, nullptr);

    const std::string runtimeSource =
-        ::XCEngine::Rendering::Detail::BuildRuntimeShaderSource(
+        ::XCEngine::Rendering::Internal::BuildRuntimeShaderSource(
            *pass,
            XCEngine::Resources::ShaderBackend::Vulkan,
            *fragmentVariant);
@@ -243,7 +441,7 @@ TEST(BuiltinForwardPipeline_Test, VulkanRuntimeCompileDescRewritesAuthoringUnlit
    ASSERT_NE(d3d12Fragment, nullptr);

    ShaderCompileDesc d3d12CompileDesc = {};
-    ::XCEngine::Rendering::Detail::ApplyShaderStageVariant(
+    ::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
        *pass,
        XCEngine::Resources::ShaderBackend::D3D12,
        *d3d12Fragment,
@@ -271,7 +469,7 @@ TEST(BuiltinForwardPipeline_Test, VulkanRuntimeCompileDescRewritesAuthoringUnlit
    ASSERT_NE(vulkanFragment, nullptr);

    ShaderCompileDesc vulkanCompileDesc = {};
-    ::XCEngine::Rendering::Detail::ApplyShaderStageVariant(
+    ::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
        *pass,
        XCEngine::Resources::ShaderBackend::Vulkan,
        *vulkanFragment,
@@ -314,7 +512,7 @@ TEST(BuiltinForwardPipeline_Test, VulkanRuntimeCompileDescRewritesAuthoringForwa
    ASSERT_NE(d3d12Fragment, nullptr);

    ShaderCompileDesc d3d12CompileDesc = {};
-    ::XCEngine::Rendering::Detail::ApplyShaderStageVariant(
+    ::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
        *pass,
        XCEngine::Resources::ShaderBackend::D3D12,
        *d3d12Fragment,
@@ -365,7 +563,7 @@ TEST(BuiltinForwardPipeline_Test, VulkanRuntimeCompileDescRewritesAuthoringForwa
    ASSERT_NE(vulkanFragment, nullptr);

    ShaderCompileDesc vulkanCompileDesc = {};
-    ::XCEngine::Rendering::Detail::ApplyShaderStageVariant(
+    ::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
        *pass,
        XCEngine::Resources::ShaderBackend::Vulkan,
        *vulkanFragment,
@@ -432,7 +630,7 @@ TEST(BuiltinForwardPipeline_Test, OpenGLRuntimeTranspilesForwardShadowVariantToL
    ASSERT_NE(openGLFragment, nullptr);

    ShaderCompileDesc compileDesc = {};
-    ::XCEngine::Rendering::Detail::ApplyShaderStageVariant(
+    ::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
        *pass,
        XCEngine::Resources::ShaderBackend::OpenGL,
        *openGLFragment,
@@ -509,7 +707,7 @@ TEST(BuiltinDepthStylePass_Test, OpenGLRuntimeTranspilesDepthOnlyAlphaVariantWit
                             const ShaderStageVariant& variant,
                             std::string& glslSource) {
        ShaderCompileDesc compileDesc = {};
-        ::XCEngine::Rendering::Detail::ApplyShaderStageVariant(
+        ::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
            targetPass,
            XCEngine::Resources::ShaderBackend::OpenGL,
            variant,
@@ -573,7 +771,7 @@ TEST(BuiltinDepthStylePass_Test, OpenGLRuntimeTranspilesShadowCasterAlphaVariant
                             const ShaderStageVariant& variant,
                             std::string& glslSource) {
        ShaderCompileDesc compileDesc = {};
-        ::XCEngine::Rendering::Detail::ApplyShaderStageVariant(
+        ::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
            targetPass,
            XCEngine::Resources::ShaderBackend::OpenGL,
            variant,
@@ -676,6 +874,219 @@ TEST(BuiltinForwardPipeline_Test, BuildsBuiltinPassResourceBindingPlanFromLoaded
    delete shader;
 }

+TEST(BuiltinForwardPipeline_Test, BuiltinGaussianSplatShaderUsesAuthoringContract) {
+    ShaderLoader loader;
+    LoadResult result = loader.Load(GetBuiltinGaussianSplatShaderPath());
+    ASSERT_TRUE(result);
+    ASSERT_NE(result.resource, nullptr);
+
+    Shader* shader = static_cast<Shader*>(result.resource);
+    ASSERT_NE(shader, nullptr);
+
+    const ShaderPass* pass = shader->FindPass("GaussianSplat");
+    ASSERT_NE(pass, nullptr);
+    EXPECT_EQ(pass->resources.Size(), 5u);
+    EXPECT_TRUE(pass->hasFixedFunctionState);
+    EXPECT_EQ(pass->fixedFunctionState.cullMode, MaterialCullMode::None);
+    EXPECT_FALSE(pass->fixedFunctionState.depthWriteEnable);
+    EXPECT_EQ(pass->fixedFunctionState.depthFunc, MaterialComparisonFunc::LessEqual);
+    EXPECT_TRUE(pass->fixedFunctionState.blendEnable);
+
+    const ShaderPropertyDesc* pointScale = shader->FindProperty("_PointScale");
+    ASSERT_NE(pointScale, nullptr);
+    EXPECT_EQ(pointScale->type, ShaderPropertyType::Float);
+
+    const ShaderPropertyDesc* opacityScale = shader->FindProperty("_OpacityScale");
+    ASSERT_NE(opacityScale, nullptr);
+    EXPECT_EQ(opacityScale->type, ShaderPropertyType::Float);
+
+    const ShaderResourceBindingDesc* positions =
+        shader->FindPassResourceBinding("GaussianSplat", "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* other =
+        shader->FindPassResourceBinding("GaussianSplat", "GaussianSplatOther");
+    ASSERT_NE(other, nullptr);
+    EXPECT_EQ(other->type, ShaderResourceType::StructuredBuffer);
+    EXPECT_EQ(other->set, 2u);
+    EXPECT_EQ(other->binding, 1u);
+    EXPECT_EQ(
+        ResolveBuiltinPassResourceSemantic(*other),
+        BuiltinPassResourceSemantic::GaussianSplatOtherBuffer);
+
+    const ShaderResourceBindingDesc* color =
+        shader->FindPassResourceBinding("GaussianSplat", "GaussianSplatColor");
+    ASSERT_NE(color, nullptr);
+    EXPECT_EQ(color->type, ShaderResourceType::StructuredBuffer);
+    EXPECT_EQ(color->set, 2u);
+    EXPECT_EQ(color->binding, 2u);
+    EXPECT_EQ(
+        ResolveBuiltinPassResourceSemantic(*color),
+        BuiltinPassResourceSemantic::GaussianSplatColorBuffer);
+
+    delete shader;
+}
+
+TEST(BuiltinForwardPipeline_Test, BuildsBuiltinPassResourceBindingPlanFromLoadedGaussianSplatShaderContract) {
+    ShaderLoader loader;
+    LoadResult result = loader.Load(GetBuiltinGaussianSplatShaderPath());
+    ASSERT_TRUE(result);
+    ASSERT_NE(result.resource, nullptr);
+
+    Shader* shader = static_cast<Shader*>(result.resource);
+    ASSERT_NE(shader, nullptr);
+
+    const ShaderPass* pass = shader->FindPass("GaussianSplat");
+    ASSERT_NE(pass, nullptr);
+
+    BuiltinPassResourceBindingPlan plan = {};
+    String error;
+    EXPECT_TRUE(TryBuildBuiltinPassResourceBindingPlan(*pass, plan, &error)) << error.CStr();
+    ASSERT_EQ(plan.bindings.Size(), 5u);
+    EXPECT_TRUE(plan.perObject.IsValid());
+    EXPECT_TRUE(plan.material.IsValid());
+    EXPECT_TRUE(plan.gaussianSplatPositionBuffer.IsValid());
+    EXPECT_TRUE(plan.gaussianSplatOtherBuffer.IsValid());
+    EXPECT_TRUE(plan.gaussianSplatColorBuffer.IsValid());
+    EXPECT_FALSE(plan.gaussianSplatSHBuffer.IsValid());
+    EXPECT_EQ(plan.perObject.set, 0u);
+    EXPECT_EQ(plan.material.set, 1u);
+    EXPECT_EQ(plan.gaussianSplatPositionBuffer.set, 2u);
+    EXPECT_EQ(plan.gaussianSplatPositionBuffer.binding, 0u);
+    EXPECT_EQ(plan.gaussianSplatOtherBuffer.set, 2u);
+    EXPECT_EQ(plan.gaussianSplatOtherBuffer.binding, 1u);
+    EXPECT_EQ(plan.gaussianSplatColorBuffer.set, 2u);
+    EXPECT_EQ(plan.gaussianSplatColorBuffer.binding, 2u);
+    EXPECT_EQ(plan.firstDescriptorSet, 0u);
+    EXPECT_EQ(plan.descriptorSetCount, 3u);
+
+    std::vector<BuiltinPassSetLayoutMetadata> setLayouts;
+    ASSERT_TRUE(TryBuildBuiltinPassSetLayouts(plan, setLayouts, &error)) << error.CStr();
+    ASSERT_EQ(setLayouts.size(), 3u);
+    EXPECT_TRUE(setLayouts[0].usesPerObject);
+    EXPECT_TRUE(setLayouts[1].usesMaterial);
+    EXPECT_TRUE(setLayouts[2].usesGaussianSplatPositionBuffer);
+    EXPECT_TRUE(setLayouts[2].usesGaussianSplatOtherBuffer);
+    EXPECT_TRUE(setLayouts[2].usesGaussianSplatColorBuffer);
+    ASSERT_EQ(setLayouts[2].bindings.size(), 3u);
+    EXPECT_EQ(
+        static_cast<DescriptorType>(setLayouts[2].bindings[0].type),
+        DescriptorType::SRV);
+    EXPECT_EQ(
+        static_cast<DescriptorType>(setLayouts[2].bindings[1].type),
+        DescriptorType::SRV);
+    EXPECT_EQ(
+        static_cast<DescriptorType>(setLayouts[2].bindings[2].type),
+        DescriptorType::SRV);
+    EXPECT_EQ(
+        setLayouts[2].bindings[0].resourceDimension,
+        ResourceViewDimension::StructuredBuffer);
+    EXPECT_EQ(
+        setLayouts[2].bindings[1].resourceDimension,
+        ResourceViewDimension::StructuredBuffer);
+    EXPECT_EQ(
+        setLayouts[2].bindings[2].resourceDimension,
+        ResourceViewDimension::StructuredBuffer);
+
+    delete shader;
+}
+
+TEST(BuiltinForwardPipeline_Test, VulkanRuntimeCompileDescRewritesAuthoringGaussianSplatBindingsToDescriptorSpaces) {
+    ShaderLoader loader;
+    LoadResult result = loader.Load(GetBuiltinGaussianSplatShaderPath());
+    ASSERT_TRUE(result);
+    ASSERT_NE(result.resource, nullptr);
+
+    Shader* shader = static_cast<Shader*>(result.resource);
+    ASSERT_NE(shader, nullptr);
+
+    const ShaderPass* pass = shader->FindPass("GaussianSplat");
+    ASSERT_NE(pass, nullptr);
+
+    const ShaderStageVariant* d3d12Vertex = shader->FindVariant(
+        "GaussianSplat",
+        XCEngine::Resources::ShaderType::Vertex,
+        XCEngine::Resources::ShaderBackend::D3D12);
+    ASSERT_NE(d3d12Vertex, nullptr);
+
+    ShaderCompileDesc d3d12CompileDesc = {};
+    ::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
+        *pass,
+        XCEngine::Resources::ShaderBackend::D3D12,
+        *d3d12Vertex,
+        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,
+        "cbuffer MaterialConstants",
+        "register(b1)"));
+    EXPECT_TRUE(SourceContainsRegisterBinding(
+        d3d12Source,
+        "StructuredBuffer<float3> GaussianSplatPositions",
+        "register(t0)"));
+    EXPECT_TRUE(SourceContainsRegisterBinding(
+        d3d12Source,
+        "StructuredBuffer<GaussianSplatOtherData> GaussianSplatOther",
+        "register(t1)"));
+    EXPECT_TRUE(SourceContainsRegisterBinding(
+        d3d12Source,
+        "StructuredBuffer<float4> GaussianSplatColor",
+        "register(t2)"));
+    EXPECT_EQ(d3d12Source.find("space0"), std::string::npos);
+    EXPECT_EQ(d3d12Source.find("space1"), std::string::npos);
+    EXPECT_EQ(d3d12Source.find("space2"), std::string::npos);
+
+    const ShaderStageVariant* vulkanVertex = shader->FindVariant(
+        "GaussianSplat",
+        XCEngine::Resources::ShaderType::Vertex,
+        XCEngine::Resources::ShaderBackend::Vulkan);
+    ASSERT_NE(vulkanVertex, nullptr);
+
+    ShaderCompileDesc vulkanCompileDesc = {};
+    ::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
+        *pass,
+        XCEngine::Resources::ShaderBackend::Vulkan,
+        *vulkanVertex,
+        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,
+        "cbuffer MaterialConstants",
+        "register(b0, space1)"));
+    EXPECT_TRUE(SourceContainsRegisterBinding(
+        vulkanSource,
+        "StructuredBuffer<float3> GaussianSplatPositions",
+        "register(t0, space2)"));
+    EXPECT_TRUE(SourceContainsRegisterBinding(
+        vulkanSource,
+        "StructuredBuffer<GaussianSplatOtherData> GaussianSplatOther",
+        "register(t1, space2)"));
+    EXPECT_TRUE(SourceContainsRegisterBinding(
+        vulkanSource,
+        "StructuredBuffer<float4> GaussianSplatColor",
+        "register(t2, space2)"));
+
+    delete shader;
+}
+
 TEST(BuiltinForwardPipeline_Test, BuiltinVolumetricShaderUsesAuthoringContract) {
    ShaderLoader loader;
    LoadResult result = loader.Load(GetBuiltinVolumetricShaderPath());
@@ -893,7 +1304,7 @@ TEST(BuiltinForwardPipeline_Test, VulkanRuntimeCompileDescRewritesAuthoringFinal
    ASSERT_NE(d3d12Fragment, nullptr);

    ShaderCompileDesc d3d12CompileDesc = {};
-    ::XCEngine::Rendering::Detail::ApplyShaderStageVariant(
+    ::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
        *pass,
        XCEngine::Resources::ShaderBackend::D3D12,
        *d3d12Fragment,
@@ -923,7 +1334,7 @@ TEST(BuiltinForwardPipeline_Test, VulkanRuntimeCompileDescRewritesAuthoringFinal
    ASSERT_NE(vulkanFragment, nullptr);

    const std::string runtimeSource =
-        ::XCEngine::Rendering::Detail::BuildRuntimeShaderSource(
+        ::XCEngine::Rendering::Internal::BuildRuntimeShaderSource(
            *pass,
            XCEngine::Resources::ShaderBackend::Vulkan,
            *vulkanFragment);
@@ -941,7 +1352,7 @@ TEST(BuiltinForwardPipeline_Test, VulkanRuntimeCompileDescRewritesAuthoringFinal
        "register(s0, space2)"));

    ShaderCompileDesc vulkanCompileDesc = {};
-    ::XCEngine::Rendering::Detail::ApplyShaderStageVariant(
+    ::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
        *pass,
        XCEngine::Resources::ShaderBackend::Vulkan,
        *vulkanFragment,
@@ -974,7 +1385,7 @@ TEST(BuiltinForwardPipeline_Test, VulkanRuntimeCompileDescRewritesAuthoringVolum
    ASSERT_NE(d3d12Fragment, nullptr);

    ShaderCompileDesc d3d12CompileDesc = {};
-    ::XCEngine::Rendering::Detail::ApplyShaderStageVariant(
+    ::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
        *pass,
        XCEngine::Resources::ShaderBackend::D3D12,
        *d3d12Fragment,
@@ -1006,7 +1417,7 @@ TEST(BuiltinForwardPipeline_Test, VulkanRuntimeCompileDescRewritesAuthoringVolum
    ASSERT_NE(vulkanFragment, nullptr);

    ShaderCompileDesc vulkanCompileDesc = {};
-    ::XCEngine::Rendering::Detail::ApplyShaderStageVariant(
+    ::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
        *pass,
        XCEngine::Resources::ShaderBackend::Vulkan,
        *vulkanFragment,
@@ -1053,7 +1464,7 @@ TEST(BuiltinForwardPipeline_Test, OpenGLRuntimeTranspilesFinalColorVariantToComb
    ASSERT_NE(openGLFragment, nullptr);

    ShaderCompileDesc compileDesc = {};
-    ::XCEngine::Rendering::Detail::ApplyShaderStageVariant(
+    ::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
        *pass,
        XCEngine::Resources::ShaderBackend::OpenGL,
        *openGLFragment,
@@ -1098,7 +1509,7 @@ TEST(BuiltinForwardPipeline_Test, VulkanRuntimeCompileDescRewritesAuthoringColor
    ASSERT_NE(d3d12Fragment, nullptr);

    ShaderCompileDesc d3d12CompileDesc = {};
-    ::XCEngine::Rendering::Detail::ApplyShaderStageVariant(
+    ::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
        *pass,
        XCEngine::Resources::ShaderBackend::D3D12,
        *d3d12Fragment,
@@ -1128,7 +1539,7 @@ TEST(BuiltinForwardPipeline_Test, VulkanRuntimeCompileDescRewritesAuthoringColor
    ASSERT_NE(vulkanFragment, nullptr);

    const std::string runtimeSource =
-        ::XCEngine::Rendering::Detail::BuildRuntimeShaderSource(
+        ::XCEngine::Rendering::Internal::BuildRuntimeShaderSource(
            *pass,
            XCEngine::Resources::ShaderBackend::Vulkan,
            *vulkanFragment);
@@ -1146,7 +1557,7 @@ TEST(BuiltinForwardPipeline_Test, VulkanRuntimeCompileDescRewritesAuthoringColor
        "register(s0, space2)"));

    ShaderCompileDesc vulkanCompileDesc = {};
-    ::XCEngine::Rendering::Detail::ApplyShaderStageVariant(
+    ::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
        *pass,
        XCEngine::Resources::ShaderBackend::Vulkan,
        *vulkanFragment,
@@ -1179,7 +1590,7 @@ TEST(BuiltinForwardPipeline_Test, OpenGLRuntimeTranspilesColorScaleVariantToComb
    ASSERT_NE(openGLFragment, nullptr);

    ShaderCompileDesc compileDesc = {};
-    ::XCEngine::Rendering::Detail::ApplyShaderStageVariant(
+    ::XCEngine::Rendering::Internal::ApplyShaderStageVariant(
        *pass,
        XCEngine::Resources::ShaderBackend::OpenGL,
        *openGLFragment,