Reworked ShaderResourceLayoutTest.FormattedRWBuffers and ShaderResourceLayoutTest.StructuredRWBuffers to validate resource bindings

5 files changed, 266 insertions, 90 deletions

diff --git a/Tests/DiligentCoreAPITest/assets/shaders/ShaderResourceLayout/RWFormattedBuffers.hlsl b/Tests/DiligentCoreAPITest/assets/shaders/ShaderResourceLayout/RWFormattedBuffers.hlsl
index 30e3d321..6609c274 100644
--- a/Tests/DiligentCoreAPITest/assets/shaders/ShaderResourceLayout/RWFormattedBuffers.hlsl
+++ b/Tests/DiligentCoreAPITest/assets/shaders/ShaderResourceLayout/RWFormattedBuffers.hlsl
@@ -6,8 +6,24 @@ RWBuffer<float4 /*format=rgba32f*/> g_RWBuffArr_Static[STATIC_BUFF_ARRAY_SIZE];
 RWBuffer<float4 /*format=rgba32f*/> g_RWBuffArr_Mut   [MUTABLE_BUFF_ARRAY_SIZE]; // 3 or 2 in D3D11
 RWBuffer<float4 /*format=rgba32f*/> g_RWBuffArr_Dyn   [DYNAMIC_BUFF_ARRAY_SIZE]; // 2
 
-void UseResources()
+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_Static[1], Buff_Static_Ref);
+    AllCorrect *= CheckValue(g_RWBuff_Mut   [2], Buff_Mut_Ref);
+    AllCorrect *= CheckValue(g_RWBuff_Dyn   [3], Buff_Dyn_Ref);
+
+    // Write to element 0
     float4 f4Data = float4(1.0, 2.0, 3.0, 4.0);
     g_RWBuff_Static[0] = f4Data;
     g_RWBuff_Mut   [0] = f4Data;
@@ -15,25 +31,49 @@ void UseResources()
 
     // glslang is not smart enough to unroll the loops even when explicitly told to do so
 
+    AllCorrect *= CheckValue(g_RWBuffArr_Static[0][1], BuffArr_Static_Ref0);
+
     g_RWBuffArr_Static[0][0] = f4Data;
 #if (STATIC_BUFF_ARRAY_SIZE == 4)
+    AllCorrect *= CheckValue(g_RWBuffArr_Static[1][1], BuffArr_Static_Ref1);
+    AllCorrect *= CheckValue(g_RWBuffArr_Static[2][2], BuffArr_Static_Ref2);
+    AllCorrect *= CheckValue(g_RWBuffArr_Static[3][3], BuffArr_Static_Ref3);
+
     g_RWBuffArr_Static[1][0] = f4Data;
     g_RWBuffArr_Static[2][0] = f4Data;
     g_RWBuffArr_Static[3][0] = f4Data;
 #endif
 
+    AllCorrect *= CheckValue(g_RWBuffArr_Mut[0][1], BuffArr_Mut_Ref0);
+    AllCorrect *= CheckValue(g_RWBuffArr_Mut[1][2], BuffArr_Mut_Ref1);
+
     g_RWBuffArr_Mut[0][0] = f4Data;
     g_RWBuffArr_Mut[1][0] = f4Data;
 #if (MUTABLE_BUFF_ARRAY_SIZE == 3)
+    AllCorrect *= CheckValue(g_RWBuffArr_Mut[2][2], BuffArr_Mut_Ref2);
+
     g_RWBuffArr_Mut[2][0] = f4Data;
 #endif
 
+    AllCorrect *= CheckValue(g_RWBuffArr_Dyn[0][1], BuffArr_Dyn_Ref0);
+    AllCorrect *= CheckValue(g_RWBuffArr_Dyn[1][2], BuffArr_Dyn_Ref1);
+
     g_RWBuffArr_Dyn[0][0] = f4Data;
     g_RWBuffArr_Dyn[1][0] = f4Data;
+
+    return AllCorrect;
 }
 
-[numthreads(1,1,1)]
-void main()
+
+RWTexture2D</*format=rgba8*/ float4> g_tex2DUAV;
+
+[numthreads(16, 16, 1)]
+void main(uint3 DTid : SV_DispatchThreadID)
 {
-    UseResources();
+	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();
 }
diff --git a/Tests/DiligentCoreAPITest/assets/shaders/ShaderResourceLayout/RWStructuredBuffers.glsl b/Tests/DiligentCoreAPITest/assets/shaders/ShaderResourceLayout/RWStructuredBuffers.glsl
index a4a6c257..6820c855 100644
--- a/Tests/DiligentCoreAPITest/assets/shaders/ShaderResourceLayout/RWStructuredBuffers.glsl
+++ b/Tests/DiligentCoreAPITest/assets/shaders/ShaderResourceLayout/RWStructuredBuffers.glsl
@@ -1,62 +1,102 @@
 layout(std140, binding = 0) writeonly buffer g_RWBuff_Static
 {
-    vec4 data;
+    vec4 data[4];
 }g_StorageBuff_Static;
 
 layout(std140, binding = 1) writeonly buffer g_RWBuff_Mut
 {
-    vec4 data;
+    vec4 data[4];
 }g_StorageBuff_Mut;
 
 layout(std140, binding = 2) writeonly buffer g_RWBuff_Dyn
 {
-    vec4 data;
+    vec4 data[4];
 }g_StorageBuff_Dyn;
 
 
 layout(std140, binding = 3) writeonly buffer g_RWBuffArr_Static
 {
-    vec4 data;
+    vec4 data[4];
 }g_StorageBuffArr_Static[STATIC_BUFF_ARRAY_SIZE];  // 4 or 1 in OpenGL
 
 layout(std140, binding = 7) writeonly buffer g_RWBuffArr_Mut
 {
-    vec4 data;
+    vec4 data[4];
 }g_StorageBuffArr_Mut[MUTABLE_BUFF_ARRAY_SIZE]; // 3 or 2 in OpenGL
 
 layout(std140, binding = 10) writeonly buffer g_RWBuffArr_Dyn
 {
-    vec4 data;
+    vec4 data[4];
 }g_StorageBuffArr_Dyn[DYNAMIC_BUFF_ARRAY_SIZE]; // 2
 
-void UseResources()
+
+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_Static.data[1], Buff_Static_Ref);
+    AllCorrect *= CheckValue(g_StorageBuff_Mut   .data[2], Buff_Mut_Ref);
+    AllCorrect *= CheckValue(g_StorageBuff_Dyn   .data[3], Buff_Dyn_Ref);
+
+    // Write to 0-th element
     vec4 Data = vec4(1.0, 2.0, 3.0, 4.0);
-    g_StorageBuff_Static.data = Data;
-    g_StorageBuff_Mut   .data = Data;
-    g_StorageBuff_Dyn   .data = Data;
+    g_StorageBuff_Static.data[0] = Data;
+    g_StorageBuff_Mut   .data[0] = Data;
+    g_StorageBuff_Dyn   .data[0] = Data;
 
     // glslang is not smart enough to unroll the loops even when explicitly told to do so
+    
+    AllCorrect *= CheckValue(g_StorageBuffArr_Static[0].data[1], BuffArr_Static_Ref0);
 
-    g_StorageBuffArr_Static[0].data = Data;
+    g_StorageBuffArr_Static[0].data[0] = Data;
 #if (STATIC_BUFF_ARRAY_SIZE == 4)
-    g_StorageBuffArr_Static[1].data = Data;
-    g_StorageBuffArr_Static[2].data = Data;
-    g_StorageBuffArr_Static[3].data = Data;
+    AllCorrect *= CheckValue(g_StorageBuffArr_Static[1].data[1], BuffArr_Static_Ref1);
+    AllCorrect *= CheckValue(g_StorageBuffArr_Static[2].data[2], BuffArr_Static_Ref2);
+    AllCorrect *= CheckValue(g_StorageBuffArr_Static[3].data[3], BuffArr_Static_Ref3);
+
+    g_StorageBuffArr_Static[1].data[0] = Data;
+    g_StorageBuffArr_Static[2].data[0] = Data;
+    g_StorageBuffArr_Static[3].data[0] = Data;
 #endif
 
-    g_StorageBuffArr_Mut[0].data = Data;
-    g_StorageBuffArr_Mut[1].data = Data;
+    AllCorrect *= CheckValue(g_StorageBuffArr_Mut[0].data[1], BuffArr_Mut_Ref0);
+    AllCorrect *= CheckValue(g_StorageBuffArr_Mut[1].data[2], BuffArr_Mut_Ref1);
+
+    g_StorageBuffArr_Mut[0].data[0] = Data;
+    g_StorageBuffArr_Mut[1].data[0] = Data;
 #if (MUTABLE_BUFF_ARRAY_SIZE == 3)
-    g_StorageBuffArr_Mut[2].data = Data;
+    AllCorrect *= CheckValue(g_StorageBuffArr_Mut[2].data[1], BuffArr_Mut_Ref2);
+
+    g_StorageBuffArr_Mut[2].data[0] = Data;
 #endif
 
-    g_StorageBuffArr_Dyn[0].data = Data;
-    g_StorageBuffArr_Dyn[1].data = Data;
+    AllCorrect *= CheckValue(g_StorageBuffArr_Dyn[0].data[1], BuffArr_Dyn_Ref0);
+    AllCorrect *= CheckValue(g_StorageBuffArr_Dyn[1].data[2], BuffArr_Dyn_Ref1);
+
+    g_StorageBuffArr_Dyn[0].data[0] = Data;
+    g_StorageBuffArr_Dyn[1].data[0] = Data;
+
+    return AllCorrect;
 }
 
-layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+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()
 {
-    UseResources();
+	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());
 }
diff --git a/Tests/DiligentCoreAPITest/assets/shaders/ShaderResourceLayout/RWStructuredBuffers.hlsl b/Tests/DiligentCoreAPITest/assets/shaders/ShaderResourceLayout/RWStructuredBuffers.hlsl
index 99e68ca8..5d882c10 100644
--- a/Tests/DiligentCoreAPITest/assets/shaders/ShaderResourceLayout/RWStructuredBuffers.hlsl
+++ b/Tests/DiligentCoreAPITest/assets/shaders/ShaderResourceLayout/RWStructuredBuffers.hlsl
@@ -11,8 +11,24 @@ RWStructuredBuffer<BufferData> g_RWBuffArr_Static[STATIC_BUFF_ARRAY_SIZE];  // 4
 RWStructuredBuffer<BufferData> g_RWBuffArr_Mut   [MUTABLE_BUFF_ARRAY_SIZE]; // 3 or 2 in D3D11
 RWStructuredBuffer<BufferData> g_RWBuffArr_Dyn   [DYNAMIC_BUFF_ARRAY_SIZE]; // 2
 
-void UseResources()
+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_Static[1].data, Buff_Static_Ref);
+    AllCorrect *= CheckValue(g_RWBuff_Mut   [2].data, Buff_Mut_Ref);
+    AllCorrect *= CheckValue(g_RWBuff_Dyn   [3].data, Buff_Dyn_Ref);
+
+    // Write to 0-th element
     float4 f4Data = float4(1.0, 2.0, 3.0, 4.0);
     g_RWBuff_Static[0].data = f4Data;
     g_RWBuff_Mut   [0].data = f4Data;
@@ -20,25 +36,46 @@ void UseResources()
 
     // glslang is not smart enough to unroll the loops even when explicitly told to do so
 
+    AllCorrect *= CheckValue(g_RWBuffArr_Static[0][1].data, BuffArr_Static_Ref0);
+
     g_RWBuffArr_Static[0][0].data = f4Data;
 #if (STATIC_BUFF_ARRAY_SIZE == 4)
+    AllCorrect *= CheckValue(g_RWBuffArr_Static[1][1].data, BuffArr_Static_Ref1);
+    AllCorrect *= CheckValue(g_RWBuffArr_Static[2][2].data, BuffArr_Static_Ref2);
+    AllCorrect *= CheckValue(g_RWBuffArr_Static[3][3].data, BuffArr_Static_Ref3);
+
     g_RWBuffArr_Static[1][0].data = f4Data;
     g_RWBuffArr_Static[2][0].data = f4Data;
     g_RWBuffArr_Static[3][0].data = f4Data;
 #endif
 
+    AllCorrect *= CheckValue(g_RWBuffArr_Mut[0][1].data, BuffArr_Mut_Ref0);
+    AllCorrect *= CheckValue(g_RWBuffArr_Mut[1][2].data, BuffArr_Mut_Ref1);
+
     g_RWBuffArr_Mut[0][0].data = f4Data;
     g_RWBuffArr_Mut[1][0].data = f4Data;
 #if (MUTABLE_BUFF_ARRAY_SIZE == 3)
+    AllCorrect *= CheckValue(g_RWBuffArr_Mut[2][1].data, BuffArr_Mut_Ref2);
+
     g_RWBuffArr_Mut[2][0].data = f4Data;
 #endif
 
+    AllCorrect *= CheckValue(g_RWBuffArr_Dyn[0][1].data, BuffArr_Dyn_Ref0);
+    AllCorrect *= CheckValue(g_RWBuffArr_Dyn[1][2].data, BuffArr_Dyn_Ref1);
+
     g_RWBuffArr_Dyn[0][0].data = f4Data;
     g_RWBuffArr_Dyn[1][0].data = f4Data;
 }
 
-[numthreads(1,1,1)]
-void main()
+RWTexture2D</*format=rgba8*/ float4> g_tex2DUAV;
+
+[numthreads(16, 16, 1)]
+void main(uint3 DTid : SV_DispatchThreadID)
 {
-    UseResources();
+	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();
 }
diff --git a/Tests/DiligentCoreAPITest/src/ComputeShaderTest.cpp b/Tests/DiligentCoreAPITest/src/ComputeShaderTest.cpp
index a9318b3c..e674401d 100644
--- a/Tests/DiligentCoreAPITest/src/ComputeShaderTest.cpp
+++ b/Tests/DiligentCoreAPITest/src/ComputeShaderTest.cpp
@@ -58,38 +58,10 @@ void ComputeShaderReferenceVk(ISwapChain* pSwapChain);
 void ComputeShaderReferenceMtl(ISwapChain* pSwapChain);
 #endif
 
-} // namespace Testing
-
-} // namespace Diligent
-
-using namespace Diligent;
-using namespace Diligent::Testing;
-
-namespace
-{
-
-TEST(ComputeShaderTest, FillTexture)
+void ComputeShaderReference(ISwapChain* pSwapChain)
 {
     auto* pEnv    = TestingEnvironment::GetInstance();
     auto* pDevice = pEnv->GetDevice();
-    if (!pDevice->GetDeviceCaps().Features.ComputeShaders)
-    {
-        GTEST_SKIP() << "Compute shaders are not supported by this device";
-    }
-
-    auto* pSwapChain = pEnv->GetSwapChain();
-    auto* pContext   = pEnv->GetDeviceContext();
-
-    TestingEnvironment::ScopedReset EnvironmentAutoReset;
-
-    RefCntAutoPtr<ITestingSwapChain> pTestingSwapChain(pSwapChain, IID_TestingSwapChain);
-    if (!pTestingSwapChain)
-    {
-        GTEST_SKIP() << "Compute shader test requires testing swap chain";
-    }
-
-    pContext->Flush();
-    pContext->InvalidateState();
 
     auto deviceType = pDevice->GetDeviceCaps().DevType;
     switch (deviceType)
@@ -130,8 +102,46 @@ TEST(ComputeShaderTest, FillTexture)
             LOG_ERROR_AND_THROW("Unsupported device type");
     }
 
-    pTestingSwapChain->TakeSnapshot();
+    if (RefCntAutoPtr<ITestingSwapChain> pTestingSwapChain{pSwapChain, IID_TestingSwapChain})
+    {
+        pTestingSwapChain->TakeSnapshot();
+    }
+}
+
+} // namespace Testing
+
+} // namespace Diligent
+
+using namespace Diligent;
+using namespace Diligent::Testing;
+
+namespace
+{
+
+TEST(ComputeShaderTest, FillTexture)
+{
+    auto* pEnv    = TestingEnvironment::GetInstance();
+    auto* pDevice = pEnv->GetDevice();
+    if (!pDevice->GetDeviceCaps().Features.ComputeShaders)
+    {
+        GTEST_SKIP() << "Compute shaders are not supported by this device";
+    }
+
+    auto* pSwapChain = pEnv->GetSwapChain();
+    auto* pContext   = pEnv->GetDeviceContext();
+
+    TestingEnvironment::ScopedReset EnvironmentAutoReset;
+
+    RefCntAutoPtr<ITestingSwapChain> pTestingSwapChain{pSwapChain, IID_TestingSwapChain};
+    if (!pTestingSwapChain)
+    {
+        GTEST_SKIP() << "Compute shader test requires testing swap chain";
+    }
+
+    pContext->Flush();
+    pContext->InvalidateState();
 
+    ComputeShaderReference(pSwapChain);
 
     ShaderCreateInfo ShaderCI;
     ShaderCI.SourceLanguage             = SHADER_SOURCE_LANGUAGE_HLSL;
diff --git a/Tests/DiligentCoreAPITest/src/ShaderResourceLayoutTest.cpp b/Tests/DiligentCoreAPITest/src/ShaderResourceLayoutTest.cpp
index 8507405a..e8a9d38e 100644
--- a/Tests/DiligentCoreAPITest/src/ShaderResourceLayoutTest.cpp
+++ b/Tests/DiligentCoreAPITest/src/ShaderResourceLayoutTest.cpp
@@ -33,6 +33,7 @@
 #include "ShaderMacroHelper.hpp"
 #include "GraphicsAccessories.hpp"
 #include "BasicMath.hpp"
+#include "TestingSwapChainBase.hpp"
 
 #include "gtest/gtest.h"
 
@@ -47,6 +48,7 @@ namespace Testing
 
 void PrintShaderResources(IShader* pShader);
 void RenderDrawCommandReference(ISwapChain* pSwapChain, const float* pClearColor = nullptr);
+void ComputeShaderReference(ISwapChain* pSwapChain);
 
 } // namespace Testing
 
@@ -804,8 +806,26 @@ void ShaderResourceLayoutTest::TestRWStructuredOrFormattedBuffer(bool IsFormatte
 {
     TestingEnvironment::ScopedReset EnvironmentAutoReset;
 
-    auto* pEnv    = TestingEnvironment::GetInstance();
-    auto* pDevice = pEnv->GetDevice();
+    auto* pEnv       = TestingEnvironment::GetInstance();
+    auto* pDevice    = pEnv->GetDevice();
+    auto* pSwapChain = pEnv->GetSwapChain();
+
+    ComputeShaderReference(pSwapChain);
+
+    constexpr size_t NumReferenceBuffers = 12;
+
+    std::array<RefCntAutoPtr<IBufferView>, NumReferenceBuffers> pBufferViews;
+    std::array<IDeviceObject*, NumReferenceBuffers>             pBuffUAVs;
+    std::array<float4, NumReferenceBuffers>                     RefColors;
+
+    for (Uint32 i = 0; i < NumReferenceBuffers; ++i)
+    {
+        const float v   = static_cast<float>(i * 10);
+        RefColors[i]    = float4{v + 1, v + 2, v + 3, v + 4};
+        pBufferViews[i] = CreateResourceBufferView(IsFormatted ? BUFFER_MODE_FORMATTED : BUFFER_MODE_STRUCTURED, BUFFER_VIEW_UNORDERED_ACCESS, RefColors[i]);
+        ASSERT_NE(pBufferViews[i], nullptr) << "Unable to formatted buffer view ";
+        pBuffUAVs[i] = pBufferViews[i];
+    }
 
     const auto& deviceCaps = pDevice->GetDeviceCaps();
     auto        deviceType = deviceCaps.DevType;
@@ -814,14 +834,18 @@ void ShaderResourceLayoutTest::TestRWStructuredOrFormattedBuffer(bool IsFormatte
     const Uint32 MutableBuffArraySize = deviceType == RENDER_DEVICE_TYPE_D3D11 || deviceCaps.IsGLDevice() ? 2 : 3;
     const Uint32 DynamicBuffArraySize = 2;
 
-    ShaderMacroHelper Macros;
-    Macros.AddShaderMacro("STATIC_BUFF_ARRAY_SIZE", static_cast<int>(StaticBuffArraySize));
-    Macros.AddShaderMacro("MUTABLE_BUFF_ARRAY_SIZE", static_cast<int>(MutableBuffArraySize));
-    Macros.AddShaderMacro("DYNAMIC_BUFF_ARRAY_SIZE", static_cast<int>(DynamicBuffArraySize));
+    static constexpr size_t Buff_StaticIdx = 0;
+    static constexpr size_t Buff_MutIdx    = 1;
+    static constexpr size_t Buff_DynIdx    = 2;
+
+    static constexpr size_t BuffArr_StaticIdx = 3;
+    static constexpr size_t BuffArr_MutIdx    = 7;
+    static constexpr size_t BuffArr_DynIdx    = 10;
 
     // clang-format off
     ShaderResourceDesc Resources[] = 
     {
+        {"g_tex2DUAV",         SHADER_RESOURCE_TYPE_TEXTURE_UAV, 1},
         {"g_RWBuff_Static",    SHADER_RESOURCE_TYPE_BUFFER_UAV, 1},
         {"g_RWBuff_Mut",       SHADER_RESOURCE_TYPE_BUFFER_UAV, 1},
         {"g_RWBuff_Dyn",       SHADER_RESOURCE_TYPE_BUFFER_UAV, 1},
@@ -829,6 +853,7 @@ void ShaderResourceLayoutTest::TestRWStructuredOrFormattedBuffer(bool IsFormatte
         {"g_RWBuffArr_Mut",    SHADER_RESOURCE_TYPE_BUFFER_UAV, MutableBuffArraySize},
         {"g_RWBuffArr_Dyn",    SHADER_RESOURCE_TYPE_BUFFER_UAV, DynamicBuffArraySize}
     };
+    // clang-format on
 
     const char*            ShaderFileName = nullptr;
     SHADER_SOURCE_LANGUAGE SrcLang        = SHADER_SOURCE_LANGUAGE_DEFAULT;
@@ -846,6 +871,38 @@ void ShaderResourceLayoutTest::TestRWStructuredOrFormattedBuffer(bool IsFormatte
     {
         GTEST_FAIL() << "Unexpected device type";
     }
+
+    ShaderMacroHelper Macros;
+    if (SrcLang == SHADER_SOURCE_LANGUAGE_GLSL)
+        Macros.AddShaderMacro("float4", "vec4");
+
+    Macros.AddShaderMacro("STATIC_BUFF_ARRAY_SIZE", static_cast<int>(StaticBuffArraySize));
+    Macros.AddShaderMacro("MUTABLE_BUFF_ARRAY_SIZE", static_cast<int>(MutableBuffArraySize));
+    Macros.AddShaderMacro("DYNAMIC_BUFF_ARRAY_SIZE", static_cast<int>(DynamicBuffArraySize));
+
+    std::array<bool, NumReferenceBuffers> UsedBuffers;
+    UsedBuffers.fill(false);
+    auto GetRefColor = [&](size_t idx) {
+        VERIFY(!UsedBuffers[idx], "Buffer ", idx, " has already been used. Every buffer should only be used once.");
+        UsedBuffers[idx] = true;
+        return RefColors[idx];
+    };
+
+    // Add macros that define reference colors
+    Macros.AddShaderMacro("Buff_Static_Ref", GetRefColor(Buff_StaticIdx));
+    Macros.AddShaderMacro("Buff_Mut_Ref", GetRefColor(Buff_MutIdx));
+    Macros.AddShaderMacro("Buff_Dyn_Ref", GetRefColor(Buff_DynIdx));
+
+    for (Uint32 i = 0; i < StaticBuffArraySize; ++i)
+        Macros.AddShaderMacro((std::string{"BuffArr_Static_Ref"} + std::to_string(i)).c_str(), GetRefColor(BuffArr_StaticIdx + i));
+
+    for (Uint32 i = 0; i < MutableBuffArraySize; ++i)
+        Macros.AddShaderMacro((std::string{"BuffArr_Mut_Ref"} + std::to_string(i)).c_str(), GetRefColor(BuffArr_MutIdx + i));
+
+    for (Uint32 i = 0; i < DynamicBuffArraySize; ++i)
+        Macros.AddShaderMacro((std::string{"BuffArr_Dyn_Ref"} + std::to_string(i)).c_str(), GetRefColor(BuffArr_DynIdx + i));
+
+
     auto pCS = CreateShader(IsFormatted ? "ShaderResourceLayoutTest.RWFormattedBuffers - CS" : "ShaderResourceLayoutTest.RWtructuredBuffers - CS",
                             ShaderFileName, "main",
                             SHADER_TYPE_COMPUTE, SrcLang, Macros,
@@ -876,30 +933,17 @@ void ShaderResourceLayoutTest::TestRWStructuredOrFormattedBuffer(bool IsFormatte
     ASSERT_NE(pPSO, nullptr);
     ASSERT_NE(pSRB, nullptr);
 
-    const auto TotalBuffers = StaticBuffArraySize + MutableBuffArraySize + DynamicBuffArraySize + 3 + 2;
-
-    std::vector<RefCntAutoPtr<IBufferView>> pBufferViews(TotalBuffers);
-    std::vector<IDeviceObject*>             pBuffUAVs(TotalBuffers);
+    RefCntAutoPtr<ITestingSwapChain> pTestingSwapChain{pSwapChain, IID_TestingSwapChain};
+    ASSERT_TRUE(pTestingSwapChain);
+    SET_STATIC_VAR(pPSO, SHADER_TYPE_COMPUTE, "g_tex2DUAV", Set, pTestingSwapChain->GetCurrentBackBufferUAV());
 
-    for (Uint32 i = 0; i < TotalBuffers; ++i)
-    {
-        pBufferViews[i] = CreateResourceBufferView(IsFormatted ? BUFFER_MODE_FORMATTED : BUFFER_MODE_STRUCTURED, BUFFER_VIEW_UNORDERED_ACCESS, float4{});
-        ASSERT_NE(pBufferViews[i], nullptr) << "Unable to craeate " << (IsFormatted ? "formatted" : "structured") << " buffer view ";
-        pBuffUAVs[i] = pBufferViews[i];
-    }
+    SET_STATIC_VAR(pPSO, SHADER_TYPE_COMPUTE, "g_RWBuff_Static", Set, pBuffUAVs[Buff_StaticIdx]);
+    SET_STATIC_VAR(pPSO, SHADER_TYPE_COMPUTE, "g_RWBuffArr_Static", SetArray, &pBuffUAVs[BuffArr_StaticIdx], 0, StaticBuffArraySize);
 
-    Uint32 uav = 0;
-    SET_STATIC_VAR(pPSO, SHADER_TYPE_COMPUTE, "g_RWBuff_Static", Set, pBuffUAVs[uav++]);
-    SET_STATIC_VAR(pPSO, SHADER_TYPE_COMPUTE, "g_RWBuffArr_Static", SetArray, &pBuffUAVs[uav], 0, StaticBuffArraySize);
-    uav += StaticBuffArraySize;
-
-    SET_SRB_VAR(pSRB, SHADER_TYPE_COMPUTE, "g_RWBuff_Mut", Set, pBuffUAVs[uav++]);
-    SET_SRB_VAR(pSRB, SHADER_TYPE_COMPUTE, "g_RWBuff_Dyn", Set, pBuffUAVs[uav++]);
-    SET_SRB_VAR(pSRB, SHADER_TYPE_COMPUTE, "g_RWBuffArr_Mut", SetArray, &pBuffUAVs[uav], 0, MutableBuffArraySize);
-    uav += MutableBuffArraySize;
-    SET_SRB_VAR(pSRB, SHADER_TYPE_COMPUTE, "g_RWBuffArr_Dyn", SetArray, &pBuffUAVs[uav], 0, DynamicBuffArraySize);
-    uav += DynamicBuffArraySize;
-    VERIFY_EXPR(uav + 2 == pBuffUAVs.size());
+    SET_SRB_VAR(pSRB, SHADER_TYPE_COMPUTE, "g_RWBuff_Mut", Set, pBuffUAVs[Buff_MutIdx]);
+    SET_SRB_VAR(pSRB, SHADER_TYPE_COMPUTE, "g_RWBuff_Dyn", Set, pBuffUAVs[0]);
+    SET_SRB_VAR(pSRB, SHADER_TYPE_COMPUTE, "g_RWBuffArr_Mut", SetArray, &pBuffUAVs[BuffArr_MutIdx], 0, MutableBuffArraySize);
+    SET_SRB_VAR(pSRB, SHADER_TYPE_COMPUTE, "g_RWBuffArr_Dyn", SetArray, &pBuffUAVs[0], 0, DynamicBuffArraySize);
 
     pSRB->InitializeStaticResources(pPSO);
 
@@ -908,12 +952,17 @@ void ShaderResourceLayoutTest::TestRWStructuredOrFormattedBuffer(bool IsFormatte
     pContext->SetPipelineState(pPSO);
     pContext->CommitShaderResources(pSRB, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);
 
-    DispatchComputeAttribs DispatchAttribs(1, 1, 1);
+    const auto&            SCDesc = pSwapChain->GetDesc();
+    DispatchComputeAttribs DispatchAttribs((SCDesc.Width + 15) / 16, (SCDesc.Height + 15) / 16, 1);
     pContext->DispatchCompute(DispatchAttribs);
 
-    SET_SRB_VAR(pSRB, SHADER_TYPE_COMPUTE, "g_RWBuff_Dyn", Set, pBuffUAVs[uav++]);
-    SET_SRB_VAR(pSRB, SHADER_TYPE_COMPUTE, "g_RWBuffArr_Dyn", SetArray, &pBuffUAVs[uav++], 1, 1);
+    SET_SRB_VAR(pSRB, SHADER_TYPE_COMPUTE, "g_RWBuff_Dyn", Set, pBuffUAVs[Buff_DynIdx]);
+    SET_SRB_VAR(pSRB, SHADER_TYPE_COMPUTE, "g_RWBuffArr_Dyn", SetArray, &pBuffUAVs[BuffArr_DynIdx], 0, DynamicBuffArraySize);
+    pContext->CommitShaderResources(pSRB, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);
+
     pContext->DispatchCompute(DispatchAttribs);
+
+    pSwapChain->Present();
 }
 
 TEST_F(ShaderResourceLayoutTest, FormattedRWBuffers)