ShaderResourceLayout: added CS variant of CopyStaticResources test

Author: TheMostDiligent

Tests/DiligentCoreAPITest/assets/shaders/ShaderResourceLayout/CopyStaticResourcesCS.glsl

@@ -0,0 +1,66 @@
+layout(std140, binding = 0) buffer g_RWBuff_0
+{
+    vec4 data[4];
+}g_StorageBuff_0;
+
+layout(std140, binding = 1) buffer g_RWBuff_1
+{
+    vec4 data[4];
+}g_StorageBuff_1;
+
+
+layout(std140, binding = 2) buffer g_RWBuff_2
+{
+    vec4 data[4];
+}g_StorageBuff_2;
+
+layout(rgba8, binding = 3) uniform image2D g_RWTex2D_0;
+layout(rgba8, binding = 4) uniform image2D g_RWTex2D_1;
+layout(rgba8, binding = 5) uniform image2D g_RWTex2D_2;
+
+vec4 CheckValue(vec4 Val, vec4 Expected)
+{
+    return vec4(Val.x == Expected.x ? 1.0 : 0.0,
+                Val.y == Expected.y ? 1.0 : 0.0,
+                Val.z == Expected.z ? 1.0 : 0.0,
+                Val.w == Expected.w ? 1.0 : 0.0);
+}
+
+vec4 VerifyResources()
+{
+    vec4 AllCorrect = vec4(1.0, 1.0, 1.0, 1.0);
+
+    // Read from elements 1,2,3
+    AllCorrect *= CheckValue(g_StorageBuff_0.data[1], Buff_0_Ref);
+    AllCorrect *= CheckValue(g_StorageBuff_1.data[2], Buff_1_Ref);
+    AllCorrect *= CheckValue(g_StorageBuff_2.data[3], Buff_2_Ref);
+
+    // Write to 0-th element
+    vec4 Data = vec4(1.0, 2.0, 3.0, 4.0);
+    g_StorageBuff_0.data[0] = Data;
+    g_StorageBuff_1.data[0] = Data;
+    g_StorageBuff_2.data[0] = Data;
+
+    AllCorrect *= CheckValue(imageLoad(g_RWTex2D_0, ivec2(10, 12)), RWTex2D_0_Ref);
+    AllCorrect *= CheckValue(imageLoad(g_RWTex2D_1, ivec2(14, 17)), RWTex2D_1_Ref);
+    AllCorrect *= CheckValue(imageLoad(g_RWTex2D_2, ivec2(31, 24)), RWTex2D_2_Ref);
+
+    imageStore(g_RWTex2D_0, ivec2(0, 0), vec4(1.0, 2.0, 3.0, 4.0));
+    imageStore(g_RWTex2D_1, ivec2(0, 0), vec4(1.0, 2.0, 3.0, 4.0));
+    imageStore(g_RWTex2D_2, ivec2(0, 0), vec4(1.0, 2.0, 3.0, 4.0));
+
+    return AllCorrect;
+}
+
+layout(rgba8, binding = 0) uniform writeonly image2D g_tex2DUAV;
+
+layout (local_size_x = 16, local_size_y = 16, local_size_z = 1) in;
+
+void main()
+{
+	ivec2 Dim = imageSize(g_tex2DUAV);
+	if (gl_GlobalInvocationID.x >= uint(Dim.x) || gl_GlobalInvocationID.y >= uint(Dim.y))
+		return;
+
+	imageStore(g_tex2DUAV, ivec2(gl_GlobalInvocationID.xy), vec4(vec2(gl_GlobalInvocationID.xy % 256u) / 256.0, 0.0, 1.0) * VerifyResources());
+}

Tests/DiligentCoreAPITest/assets/shaders/ShaderResourceLayout/CopyStaticResourcesCS.hlsl

@@ -0,0 +1,60 @@
+RWTexture2D<unorm float4 /*format=rgba8*/> g_RWTex2D_0;
+RWTexture2D<unorm float4 /*format=rgba8*/> g_RWTex2D_1;
+RWTexture2D<unorm float4 /*format=rgba8*/> g_RWTex2D_2;
+
+struct BufferData
+{
+    float4 data;
+};
+
+RWStructuredBuffer<BufferData> g_RWBuff_0;
+RWStructuredBuffer<BufferData> g_RWBuff_1;
+RWStructuredBuffer<BufferData> g_RWBuff_2;
+
+float4 CheckValue(float4 Val, float4 Expected)
+{
+    return float4(Val.x == Expected.x ? 1.0 : 0.0,
+                  Val.y == Expected.y ? 1.0 : 0.0,
+                  Val.z == Expected.z ? 1.0 : 0.0,
+                  Val.w == Expected.w ? 1.0 : 0.0);
+}
+
+float4 VerifyResources()
+{
+    float4 AllCorrect = float4(1.0, 1.0, 1.0, 1.0);
+
+    // Read from elements 1,2,3
+    AllCorrect *= CheckValue(g_RWBuff_0[1].data, Buff_0_Ref);
+    AllCorrect *= CheckValue(g_RWBuff_1[2].data, Buff_1_Ref);
+    AllCorrect *= CheckValue(g_RWBuff_2[3].data, Buff_2_Ref);
+
+    // Write to 0-th element
+    float4 f4Data = float4(1.0, 2.0, 3.0, 4.0);
+    g_RWBuff_0[0].data = f4Data;
+    g_RWBuff_1[0].data = f4Data;
+    g_RWBuff_2[0].data = f4Data;
+
+    AllCorrect *= CheckValue(g_RWTex2D_0[int2(10, 12)], RWTex2D_0_Ref);
+    AllCorrect *= CheckValue(g_RWTex2D_1[int2(14, 17)], RWTex2D_1_Ref);
+    AllCorrect *= CheckValue(g_RWTex2D_2[int2(31, 24)], RWTex2D_2_Ref);
+        
+    float4 f4Color = float4(1.0, 2.0, 3.0, 4.0);
+    g_RWTex2D_0[int2(0,0)] = f4Color;
+    g_RWTex2D_1[int2(0,0)] = f4Color;
+    g_RWTex2D_2[int2(0,0)] = f4Color;
+
+    return AllCorrect;
+}
+
+RWTexture2D</*format=rgba8*/ float4> g_tex2DUAV;
+
+[numthreads(16, 16, 1)]
+void main(uint3 DTid : SV_DispatchThreadID)
+{
+	uint2 ui2Dim;
+	g_tex2DUAV.GetDimensions(ui2Dim.x, ui2Dim.y);
+	if (DTid.x >= ui2Dim.x || DTid.y >= ui2Dim.y)
+        return;
+
+	g_tex2DUAV[DTid.xy] = float4(float2(DTid.xy % 256u) / 256.0, 0.0, 1.0) * VerifyResources();
+}

Tests/DiligentCoreAPITest/src/ShaderResourceLayoutTest.cpp

@@ -1812,4 +1812,131 @@ TEST_F(ShaderResourceLayoutTest, CopyStaticResources)
     pSwapChain->Present();
 }
 
+TEST_F(ShaderResourceLayoutTest, CopyStaticResourcesCS)
+{
+    GPUTestingEnvironment::ScopedReset EnvironmentAutoReset;
+
+    auto* const pEnv       = GPUTestingEnvironment::GetInstance();
+    auto* const pDevice    = pEnv->GetDevice();
+    auto* const pSwapChain = pEnv->GetSwapChain();
+    auto* const pContext   = pEnv->GetDeviceContext();
+
+    ComputeShaderReference(pSwapChain);
+
+    const auto& DeviceInfo = pDevice->GetDeviceInfo();
+
+    // Prepare buffers with reference values
+    ReferenceBuffers RefBuffers{
+        3,
+        USAGE_DEFAULT,
+        BIND_UNORDERED_ACCESS,
+        BUFFER_VIEW_UNORDERED_ACCESS,
+        BUFFER_MODE_STRUCTURED //
+    };
+
+    ReferenceTextures RefTextures{
+        3,
+        128, 128,
+        USAGE_DEFAULT,
+        BIND_UNORDERED_ACCESS,
+        TEXTURE_VIEW_UNORDERED_ACCESS //
+    };
+
+    // clang-format off
+    ShaderResourceDesc Resources[] =
+    {
+        {"g_tex2DUAV",  SHADER_RESOURCE_TYPE_TEXTURE_UAV, 1},
+        {"g_RWTex2D_0", SHADER_RESOURCE_TYPE_TEXTURE_UAV, 1},
+        {"g_RWTex2D_1", SHADER_RESOURCE_TYPE_TEXTURE_UAV, 1},
+        {"g_RWTex2D_2", SHADER_RESOURCE_TYPE_TEXTURE_UAV, 1},
+        {"g_RWBuff_0",  SHADER_RESOURCE_TYPE_BUFFER_UAV,  1},
+        {"g_RWBuff_1",  SHADER_RESOURCE_TYPE_BUFFER_UAV,  1},
+        {"g_RWBuff_2",  SHADER_RESOURCE_TYPE_BUFFER_UAV,  1}
+    };
+    // clang-format on
+
+    const char*            ShaderFileName = nullptr;
+    SHADER_SOURCE_LANGUAGE SrcLang        = SHADER_SOURCE_LANGUAGE_DEFAULT;
+    if (pDevice->GetDeviceInfo().IsD3DDevice())
+    {
+        ShaderFileName = "CopyStaticResourcesCS.hlsl";
+        SrcLang        = SHADER_SOURCE_LANGUAGE_HLSL;
+    }
+    else if (DeviceInfo.IsVulkanDevice() || DeviceInfo.IsGLDevice() || DeviceInfo.IsMetalDevice())
+    {
+        ShaderFileName = "CopyStaticResourcesCS.glsl";
+        SrcLang        = SHADER_SOURCE_LANGUAGE_GLSL;
+    }
+    else
+    {
+        GTEST_FAIL() << "Unexpected device type";
+    }
+
+    ShaderMacroHelper Macros;
+    if (SrcLang == SHADER_SOURCE_LANGUAGE_GLSL)
+        Macros.AddShaderMacro("float4", "vec4");
+
+    // Add macros that define reference colors
+    Macros.AddShaderMacro("Buff_0_Ref", RefBuffers.GetValue(0));
+    Macros.AddShaderMacro("Buff_1_Ref", RefBuffers.GetValue(1));
+    Macros.AddShaderMacro("Buff_2_Ref", RefBuffers.GetValue(2));
+    Macros.AddShaderMacro("RWTex2D_0_Ref", RefTextures.GetColor(0));
+    Macros.AddShaderMacro("RWTex2D_1_Ref", RefTextures.GetColor(1));
+    Macros.AddShaderMacro("RWTex2D_2_Ref", RefTextures.GetColor(2));
+
+    auto ModifyShaderCI = [pEnv](ShaderCreateInfo& ShaderCI) {
+        if (pEnv->NeedWARPResourceArrayIndexingBugWorkaround())
+        {
+            // Due to bug in D3D12 WARP, we have to use SM5.0 with old compiler
+            ShaderCI.ShaderCompiler = SHADER_COMPILER_DEFAULT;
+            ShaderCI.HLSLVersion    = ShaderVersion{5, 0};
+        }
+    };
+
+    auto pCS = CreateShader("ShaderResourceLayoutTest.CopyStaticResourcesCS",
+                            ShaderFileName, "main",
+                            SHADER_TYPE_COMPUTE, SrcLang, Macros,
+                            Resources, _countof(Resources), ModifyShaderCI);
+    ASSERT_NE(pCS, nullptr);
+
+    PipelineResourceLayoutDesc ResourceLayout;
+    ResourceLayout.DefaultVariableType = SHADER_RESOURCE_VARIABLE_TYPE_STATIC;
+
+    RefCntAutoPtr<IPipelineState>         pPSO1;
+    RefCntAutoPtr<IShaderResourceBinding> pSRB1;
+    CreateComputePSO(pCS, ResourceLayout, pPSO1, pSRB1);
+    ASSERT_NE(pPSO1, nullptr);
+    ASSERT_NE(pSRB1, nullptr);
+
+    RefCntAutoPtr<ITestingSwapChain> pTestingSwapChain{pSwapChain, IID_TestingSwapChain};
+    ASSERT_TRUE(pTestingSwapChain);
+    SET_STATIC_VAR(pPSO1, SHADER_TYPE_COMPUTE, "g_tex2DUAV", Set, pTestingSwapChain->GetCurrentBackBufferUAV());
+    SET_STATIC_VAR(pPSO1, SHADER_TYPE_COMPUTE, "g_RWBuff_0", Set, RefBuffers.GetView(0));
+    SET_STATIC_VAR(pPSO1, SHADER_TYPE_COMPUTE, "g_RWTex2D_0", Set, RefTextures.GetView(0));
+
+    RefCntAutoPtr<IPipelineState>         pPSO2;
+    RefCntAutoPtr<IShaderResourceBinding> pSRB2;
+    CreateComputePSO(pCS, ResourceLayout, pPSO2, pSRB2);
+    ASSERT_NE(pPSO2, nullptr);
+    ASSERT_NE(pSRB2, nullptr);
+
+    SET_STATIC_VAR(pPSO2, SHADER_TYPE_COMPUTE, "g_RWBuff_1", Set, RefBuffers.GetView(1));
+    SET_STATIC_VAR(pPSO2, SHADER_TYPE_COMPUTE, "g_RWTex2D_1", Set, RefTextures.GetView(1));
+    pPSO1->CopyStaticResources(pPSO2);
+    SET_STATIC_VAR(pPSO2, SHADER_TYPE_COMPUTE, "g_RWBuff_2", Set, RefBuffers.GetView(2));
+    SET_STATIC_VAR(pPSO2, SHADER_TYPE_COMPUTE, "g_RWTex2D_2", Set, RefTextures.GetView(2));
+
+    pPSO2->InitializeStaticSRBResources(pSRB2);
+
+    pContext->SetPipelineState(pPSO2);
+    pContext->CommitShaderResources(pSRB2, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);
+
+    const auto&            SCDesc = pSwapChain->GetDesc();
+    DispatchComputeAttribs DispatchAttribs((SCDesc.Width + 15) / 16, (SCDesc.Height + 15) / 16, 1);
+    pContext->CommitShaderResources(pSRB2, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);
+    pContext->DispatchCompute(DispatchAttribs);
+
+    pSwapChain->Present();
+}
+
 } // namespace