Add DXC tests.

Author: hzqst

Tests/DiligentCoreTest/CMakeLists.txt

@@ -64,6 +64,12 @@ if(WEBGPU_SUPPORTED)
     target_link_libraries(DiligentCoreTest PRIVATE libtint)
 endif()
 
+if(PLATFORM_WIN32)
+    copy_required_dlls(DiligentCoreTest
+        DXC_REQUIRED YES
+    )
+endif()
+
 source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${SOURCE} ${SHADERS}})
 
 set_target_properties(DiligentCoreTest

Tests/DiligentCoreTest/assets/shaders/SPIRV/InputAttachments.psh

@@ -11,4 +11,4 @@ float4 main() : SV_Target
 
     // Process the input color
     return color * 2.0;
-}
+}

Tests/DiligentCoreTest/assets/shaders/SPIRV/MixedResources.psh

@@ -35,12 +35,23 @@ struct PushConstants_t
     uint FrameCount;
 };
 
+#if DXC
+
+#define g_PushConstants PushConstants
+
+[[vk::push_constant]]
+PushConstants_t g_PushConstants;
+
+#else
+
 [[vk::push_constant]]
 cbuffer PushConstants
 {
     PushConstants_t g_PushConstants;
 };
 
+#endif
+
 float4 main() : SV_Target
 {
     // Use uniform buffer data
@@ -63,4 +74,4 @@ float4 main() : SV_Target
     color.rgb *= sin(g_PushConstants.Time) * 0.5 + 0.5;
 
     return color;
-}
+}

Tests/DiligentCoreTest/assets/shaders/SPIRV/PushConstants.psh

@@ -1,4 +1,4 @@
-// Test for push constants
+// Test struct for push constants
 struct PushConstants_t
 {
     float4x4 g_MVPMatrix;
@@ -8,12 +8,42 @@ struct PushConstants_t
     uint     g_Padding;
 };
 
+/*
+Note that glslang allows following declaration:
+
 [[vk::push_constant]]
 cbuffer PushConstants
 {
     PushConstants_t g_PushConstants;
 };
 
+to generate a push constant resource: "Push Constants 'PushConstants'".
+
+but DXC does not allow it.
+
+Glslang converts "[[vk::push_constant]] PushConstants_t g_PushConstants;" into an unnamed resource:
+"Uniform Buffer '$Global'" instead of what we expected: "Push Constants 'PushConstants'", 
+
+Thus we have to use "[[vk::push_constant]] cbuffer PushConstants" under glslang while "[[vk::push_constant]] PushConstants_t g_PushConstants;" under DXC.
+*/
+
+#if DXC
+
+#define g_PushConstants PushConstants
+
+[[vk::push_constant]]
+PushConstants_t g_PushConstants;
+
+#else
+
+[[vk::push_constant]]
+cbuffer PushConstants
+{
+    PushConstants_t g_PushConstants;
+};
+
+#endif
+
 float4 main() : SV_Target
 {
     // Use push constant data through the structure instance
@@ -23,4 +53,4 @@ float4 main() : SV_Target
     result.xy += g_PushConstants.g_Offset;
 
     return result;
-}
+}

Tests/DiligentCoreTest/assets/shaders/SPIRV/StorageBuffers.psh

@@ -40,4 +40,4 @@ float4 main() : SV_Target
     g_RWAtomicBuffer.Store(0, atomicValue + 1);
 
     return result;
-}
+}

Tests/DiligentCoreTest/assets/shaders/SPIRV/StorageImages.psh

@@ -17,4 +17,4 @@ float4 main() : SV_Target
     color += g_RWImage3D[uint3(0, 0, 0)];
 
     return color;
-}
+}

Tests/DiligentCoreTest/assets/shaders/SPIRV/TexelBuffers.psh

@@ -12,4 +12,4 @@ float4 main() : SV_Target
 
     // Read back from storage texel buffer
     return g_StorageTexelBuffer[0];
-}
+}

Tests/DiligentCoreTest/assets/shaders/SPIRV/Textures.psh

@@ -27,4 +27,4 @@ float4 main() : SV_Target
     float4 color6 = g_Texture.Sample(g_Texture_sampler, float2(0.5, 0.5));
 
     return color1 + color2 + color3 + color4 + color5 + color6;
-}
+}

Tests/DiligentCoreTest/assets/shaders/SPIRV/UniformBuffers.psh

@@ -1,8 +1,4 @@
 // Test for uniform buffers (constant buffers)
-cbuffer CB0 : register(b0)
-{
-    float4x4 g_WorldViewProj;
-};
 
 cbuffer CB1 : register(b1)
 {
@@ -21,4 +17,4 @@ cbuffer CB2 : register(b2)
 float4 main() : SV_Target
 {
     return g_Color * g_MaterialParams;
-}
+}

Tests/DiligentCoreTest/src/ShaderTools/SPIRVShaderResourcesTest.cpp

@@ -44,18 +44,23 @@ using namespace Diligent::Testing;
 
 namespace
 {
+std::unique_ptr<IDXCompiler> g_pDXCompiler;
 
 class SPIRVShaderResourcesTest : public ::testing::Test
 {
 protected:
     static void SetUpTestSuite()
     {
         GLSLangUtils::InitializeGlslang();
+
+        g_pDXCompiler = CreateDXCompiler(DXCompilerTarget::Vulkan, 0, nullptr);
     }
 
     static void TearDownTestSuite()
     {
         GLSLangUtils::FinalizeGlslang();
+
+        g_pDXCompiler.reset();
     }
 };
 
@@ -78,8 +83,7 @@ std::vector<unsigned int> LoadSPIRVFromHLSL(const char* FilePath, SHADER_TYPE Sh
     if (UseDXC)
     {
         // Use DXC to compile HLSL to SPIR-V.
-        auto pDXC = CreateDXCompiler(DXCompilerTarget::Vulkan, 0, nullptr);
-        if (!pDXC || !pDXC->IsLoaded())
+        if (!g_pDXCompiler || !g_pDXCompiler->IsLoaded())
             return {};
 
         ShaderCreateInfo ShaderCI;
@@ -88,14 +92,24 @@ std::vector<unsigned int> LoadSPIRVFromHLSL(const char* FilePath, SHADER_TYPE Sh
         ShaderCI.Desc           = {"SPIRV test shader", ShaderType};
         ShaderCI.EntryPoint     = "main";
 
+        ShaderMacro Macros[] = {{"DXC", "1"}};
+        ShaderCI.Macros      = {Macros, _countof(Macros)};
+
         RefCntAutoPtr<IShaderSourceInputStreamFactory> pShaderSourceStreamFactory;
         CreateDefaultShaderSourceStreamFactory("shaders/SPIRV", &pShaderSourceStreamFactory);
         if (!pShaderSourceStreamFactory)
             return {};
+
         ShaderCI.pShaderSourceStreamFactory = pShaderSourceStreamFactory;
 
         RefCntAutoPtr<IDataBlob> pCompilerOutput;
-        pDXC->Compile(ShaderCI, ShaderVersion{6, 0}, nullptr, nullptr, &SPIRV, &pCompilerOutput);
+        g_pDXCompiler->Compile(ShaderCI, ShaderVersion{6, 0}, nullptr, nullptr, &SPIRV, &pCompilerOutput);
+
+        if (pCompilerOutput && pCompilerOutput->GetSize() > 0)
+        {
+            std::string CompilerOutput = static_cast<const char*>(pCompilerOutput->GetConstDataPtr());
+            LOG_INFO_MESSAGE("DXC compiler output:\n", CompilerOutput);
+        }
     }
     else
     {
@@ -219,15 +233,24 @@ void TestSPIRVResources(const char*                                       FilePa
                         bool                                              IsGLSL                = false)
 {
     const auto& SPIRV = IsGLSL ? LoadSPIRVFromGLSL(FilePath, ShaderType) : LoadSPIRVFromHLSL(FilePath, ShaderType);
-    ASSERT_FALSE(SPIRV.empty()) << "Failed to compile HLSL to SPIRV with glslang: " << FilePath;
-
+    ASSERT_FALSE(SPIRV.empty()) << 
+    (IsGLSL ? 
+        "Failed to compile GLSL to SPIRV with glslang: " : 
+        "Failed to compile HLSL to SPIRV with glslang: "
+    ) << FilePath;
+
+    LOG_INFO_MESSAGE(IsGLSL ? "Testing with GLSL->SPIRV with glslang:\n" : "Testing with HLSL->SPIRV with glslang:\n", FilePath);
+    
     TestSPIRVResourcesInternal(FilePath, RefResources, SPIRV, ShaderType, CombinedSamplerSuffix);
 
     if (!IsGLSL)
     {
         //Test with DXC
         const auto& SPIRV_DXC = LoadSPIRVFromHLSL(FilePath, ShaderType, true);
         ASSERT_FALSE(SPIRV_DXC.empty()) << "Failed to compile HLSL to SPIRV with DXC: " << FilePath;
+
+        LOG_INFO_MESSAGE("Testing with HLSL->SPIRV with DXC:\n", FilePath);
+        
         TestSPIRVResourcesInternal(FilePath, RefResources, SPIRV_DXC, ShaderType, CombinedSamplerSuffix);
     }
 }
@@ -238,7 +261,6 @@ TEST_F(SPIRVShaderResourcesTest, UniformBuffers)
 {
     TestSPIRVResources("UniformBuffers.psh",
                        {
-                           // CB0 is optimized away as it's not used in the shader
                            SPIRVShaderResourceRefAttribs{"CB1", 1, SPIRVResourceType::UniformBuffer, RESOURCE_DIM_BUFFER, 0, 48, 0},
                            SPIRVShaderResourceRefAttribs{"CB2", 1, SPIRVResourceType::UniformBuffer, RESOURCE_DIM_BUFFER, 0, 16, 0},
                        });