[PATCH v4 0/5] MR569: tests/shader_runer: Support SRV buffers.

[Francisco Casas (＠fcasas)]

This allows to declare SRV buffers in the shader tests using `[buffer srv n]` blocks, and passing them to the different backends.

Also, 1/2 includes a missing bit required to parse `Buffer<>` types in the HLSL compiler.

This is a step towards supporting StructuredBuffer types in further patches.

--
  v4: tests/shader-runner: Change probe directive syntax on shader_test files.
      tests/shader-runner: Change resource declaration syntax on shader_test files.
      tests/shader_runner: Support SRV buffers.
      tests/shader-runner: Separate resource_type into type and dimension.

https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/569

[PATCH v4 1/5] vkd3d-shader/hlsl: Parse Buffer types.

[Francisco Casas]

From: Francisco Casas

---
 libs/vkd3d-shader/hlsl.c | 5 ++++-
 libs/vkd3d-shader/hlsl.y | 6 +++++-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c
index 1e2474451..e2ae8fa50 100644
--- a/libs/vkd3d-shader/hlsl.c
+++ b/libs/vkd3d-shader/hlsl.c
@@ -2190,7 +2190,10 @@ struct vkd3d_string_buffer *hlsl_type_to_string(struct hlsl_ctx *ctx, const stru

assert(type->sampler_dim < ARRAY_SIZE(dimensions));
                     assert(type->e.resource_format->base_type < ARRAY_SIZE(base_types));
-                    vkd3d_string_buffer_printf(string, "Texture%s", dimensions[type->sampler_dim]);
+                    if (type->sampler_dim == HLSL_SAMPLER_DIM_BUFFER)
+                        vkd3d_string_buffer_printf(string, "Buffer");
+                    else
+                        vkd3d_string_buffer_printf(string, "Texture%s", dimensions[type->sampler_dim]);
                     if ((inner_string = hlsl_type_to_string(ctx, type->e.resource_format)))
                     {
                         vkd3d_string_buffer_printf(string, "<%s>", inner_string->buffer);
diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y
index b11cbde26..3258446f3 100644
--- a/libs/vkd3d-shader/hlsl.y
+++ b/libs/vkd3d-shader/hlsl.y
@@ -5827,7 +5827,11 @@ parameter:
         }

texture_type:
-      KW_TEXTURE1D
+      KW_BUFFER
+        {
+            $$ = HLSL_SAMPLER_DIM_BUFFER;
+        }
+    | KW_TEXTURE1D
         {
             $$ = HLSL_SAMPLER_DIM_1D;
         }

[PATCH v4 2/5] tests/shader-runner: Separate resource_type into type and dimension.

[Francisco Casas]

From: Francisco Casas

If in the same shader_test file we have both a [buffer uav n] and a
[uav n] with the same slot "n", we want the last one to override the
first one instead of passing both resources to the backends.

Same for [buffer srv n] and [texture n] after we introduce SRV buffers.
---
 tests/shader_runner.c        |  13 ++-
 tests/shader_runner.h        |   9 +-
 tests/shader_runner_d3d11.c  | 190 ++++++++++++++++--------------
 tests/shader_runner_d3d12.c  |  65 +++++------
 tests/shader_runner_d3d9.c   |   2 -
 tests/shader_runner_gl.c     | 123 +++++++++++---------
 tests/shader_runner_vulkan.c | 220 +++++++++++++++++++----------------
 7 files changed, 342 insertions(+), 280 deletions(-)

diff --git a/tests/shader_runner.c b/tests/shader_runner.c
index bac3a8f26..e95f830d7 100644
--- a/tests/shader_runner.c
+++ b/tests/shader_runner.c
@@ -395,6 +395,7 @@ static void parse_input_layout_directive(struct shader_runner *runner, const cha
 void init_resource(struct resource *resource, const struct resource_params *params)
 {
     resource->type = params->type;
+    resource->dimension = params->dimension;
     resource->slot = params->slot;
     resource->format = params->format;
     resource->size = params->data_size;
@@ -589,6 +590,7 @@ static void parse_test_directive(struct shader_runner *runner, const char *line)
             memset(&params, 0, sizeof(params));
             params.slot = 0;
             params.type = RESOURCE_TYPE_RENDER_TARGET;
+            params.dimension = RESOURCE_DIMENSION_2D;
             params.format = DXGI_FORMAT_R32G32B32A32_FLOAT;
             params.data_type = TEXTURE_DATA_FLOAT;
             params.texel_size = 16;
@@ -612,6 +614,7 @@ static void parse_test_directive(struct shader_runner *runner, const char *line)
         memset(&params, 0, sizeof(params));
         params.slot = 0;
         params.type = RESOURCE_TYPE_VERTEX_BUFFER;
+        params.dimension = RESOURCE_DIMENSION_BUFFER;
         params.data = malloc(sizeof(quad));
         memcpy(params.data, quad, sizeof(quad));
         params.data_size = sizeof(quad);
@@ -633,6 +636,7 @@ static void parse_test_directive(struct shader_runner *runner, const char *line)
             memset(&params, 0, sizeof(params));
             params.slot = 0;
             params.type = RESOURCE_TYPE_RENDER_TARGET;
+            params.dimension = RESOURCE_DIMENSION_2D;
             params.format = DXGI_FORMAT_R32G32B32A32_FLOAT;
             params.data_type = TEXTURE_DATA_FLOAT;
             params.texel_size = 16;
@@ -685,7 +689,7 @@ static void parse_test_directive(struct shader_runner *runner, const char *line)
                 fatal_error("Malformed buffer UAV index '%s'.\n", line);
             line = rest;

-            resource = shader_runner_get_resource(runner, RESOURCE_TYPE_BUFFER_UAV, slot);
+            resource = shader_runner_get_resource(runner, RESOURCE_TYPE_UAV, slot);
         }
         else if (match_string(line, "render target", &line))
         {
@@ -1362,6 +1366,7 @@ void run_shader_tests(struct shader_runner *runner, const struct shader_runner_o

current_resource.slot = index;
                 current_resource.type = RESOURCE_TYPE_RENDER_TARGET;
+                current_resource.dimension = RESOURCE_DIMENSION_2D;
                 current_resource.format = DXGI_FORMAT_R32G32B32A32_FLOAT;
                 current_resource.data_type = TEXTURE_DATA_FLOAT;
                 current_resource.texel_size = 16;
@@ -1375,6 +1380,7 @@ void run_shader_tests(struct shader_runner *runner, const struct shader_runner_o

current_resource.slot = index;
                 current_resource.type = RESOURCE_TYPE_TEXTURE;
+                current_resource.dimension = RESOURCE_DIMENSION_2D;
                 current_resource.format = DXGI_FORMAT_R32G32B32A32_FLOAT;
                 current_resource.data_type = TEXTURE_DATA_FLOAT;
                 current_resource.texel_size = 16;
@@ -1388,6 +1394,7 @@ void run_shader_tests(struct shader_runner *runner, const struct shader_runner_o

current_resource.slot = index;
                 current_resource.type = RESOURCE_TYPE_UAV;
+                current_resource.dimension = RESOURCE_DIMENSION_2D;
                 current_resource.format = DXGI_FORMAT_R32G32B32A32_FLOAT;
                 current_resource.data_type = TEXTURE_DATA_FLOAT;
                 current_resource.texel_size = 16;
@@ -1400,7 +1407,8 @@ void run_shader_tests(struct shader_runner *runner, const struct shader_runner_o
                 memset(&current_resource, 0, sizeof(current_resource));

current_resource.slot = index;
-                current_resource.type = RESOURCE_TYPE_BUFFER_UAV;
+                current_resource.type = RESOURCE_TYPE_UAV;
+                current_resource.dimension = RESOURCE_DIMENSION_BUFFER;
                 current_resource.format = DXGI_FORMAT_R32G32B32A32_FLOAT;
                 current_resource.data_type = TEXTURE_DATA_FLOAT;
                 current_resource.texel_size = 16;
@@ -1414,6 +1422,7 @@ void run_shader_tests(struct shader_runner *runner, const struct shader_runner_o

current_resource.slot = index;
                 current_resource.type = RESOURCE_TYPE_VERTEX_BUFFER;
+                current_resource.dimension = RESOURCE_DIMENSION_BUFFER;
                 current_resource.data_type = TEXTURE_DATA_FLOAT;
             }
             else if (!strcmp(line, "[test]\n"))
diff --git a/tests/shader_runner.h b/tests/shader_runner.h
index 163439477..a8ed347eb 100644
--- a/tests/shader_runner.h
+++ b/tests/shader_runner.h
@@ -69,14 +69,20 @@ enum resource_type
     RESOURCE_TYPE_RENDER_TARGET,
     RESOURCE_TYPE_TEXTURE,
     RESOURCE_TYPE_UAV,
-    RESOURCE_TYPE_BUFFER_UAV,
     RESOURCE_TYPE_VERTEX_BUFFER,
 };

+enum resource_dimension
+{
+    RESOURCE_DIMENSION_BUFFER,
+    RESOURCE_DIMENSION_2D,
+};
+
 struct resource_params
 {
     unsigned int slot;
     enum resource_type type;
+    enum resource_dimension dimension;

DXGI_FORMAT format;
     enum texture_data_type data_type;
@@ -91,6 +97,7 @@ struct resource
 {
     unsigned int slot;
     enum resource_type type;
+    enum resource_dimension dimension;

DXGI_FORMAT format;
     unsigned int size;
diff --git a/tests/shader_runner_d3d11.c b/tests/shader_runner_d3d11.c
index 1a62b20cd..b2c97cdd3 100644
--- a/tests/shader_runner_d3d11.c
+++ b/tests/shader_runner_d3d11.c
@@ -355,12 +355,87 @@ static ID3D11Buffer *create_buffer(ID3D11Device *device, unsigned int bind_flags
     return buffer;
 }

+static void init_resource_2d(struct d3d11_shader_runner *runner, struct d3d11_resource *resource,
+        const struct resource_params *params)
+{
+    D3D11_SUBRESOURCE_DATA resource_data[2];
+    ID3D11Device *device = runner->device;
+    D3D11_TEXTURE2D_DESC desc = {0};
+    HRESULT hr;
+
+    if (params->level_count > ARRAY_SIZE(resource_data))
+        fatal_error("Level count %u is too high.\n", params->level_count);
+
+    desc.Width = params->width;
+    desc.Height = params->height;
+    desc.MipLevels = params->level_count;
+    desc.ArraySize = 1;
+    desc.Format = params->format;
+    desc.SampleDesc.Count = 1;
+    desc.Usage = D3D11_USAGE_DEFAULT;
+    if (params->type == RESOURCE_TYPE_UAV)
+        desc.BindFlags = D3D11_BIND_UNORDERED_ACCESS;
+    else if (params->type == RESOURCE_TYPE_RENDER_TARGET)
+        desc.BindFlags = D3D11_BIND_RENDER_TARGET;
+    else
+        desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
+
+    if (params->data)
+    {
+        unsigned int buffer_offset = 0;
+
+        for (unsigned int level = 0; level < params->level_count; ++level)
+        {
+            unsigned int level_width = get_level_dimension(params->width, level);
+            unsigned int level_height = get_level_dimension(params->height, level);
+
+            resource_data[level].pSysMem = &params->data[buffer_offset];
+            resource_data[level].SysMemPitch = level_width * params->texel_size;
+            resource_data[level].SysMemSlicePitch = level_height * resource_data[level].SysMemPitch;
+            buffer_offset += resource_data[level].SysMemSlicePitch;
+        }
+        hr = ID3D11Device_CreateTexture2D(device, &desc, resource_data, &resource->texture);
+    }
+    else
+    {
+        hr = ID3D11Device_CreateTexture2D(device, &desc, NULL, &resource->texture);
+    }
+    ok(hr == S_OK, "Failed to create texture, hr %#lx.\n", hr);
+
+    resource->resource = (ID3D11Resource *)resource->texture;
+    if (params->type == RESOURCE_TYPE_UAV)
+        hr = ID3D11Device_CreateUnorderedAccessView(device, resource->resource, NULL, &resource->uav);
+    else if (params->type == RESOURCE_TYPE_RENDER_TARGET)
+        hr = ID3D11Device_CreateRenderTargetView(device, resource->resource, NULL, &resource->rtv);
+    else
+        hr = ID3D11Device_CreateShaderResourceView(device, resource->resource, NULL, &resource->srv);
+    ok(hr == S_OK, "Failed to create view, hr %#lx.\n", hr);
+}
+
+static void init_resource_uav_buffer(struct d3d11_shader_runner *runner, struct d3d11_resource *resource,
+        const struct resource_params *params)
+{
+    D3D11_UNORDERED_ACCESS_VIEW_DESC uav_desc;
+    ID3D11Device *device = runner->device;
+    HRESULT hr;
+
+    resource->buffer = create_buffer(device, D3D11_BIND_UNORDERED_ACCESS, params->data_size, params->data);
+    resource->resource = (ID3D11Resource *)resource->buffer;
+
+    uav_desc.Format = params->format;
+    uav_desc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
+    uav_desc.Buffer.FirstElement = 0;
+    uav_desc.Buffer.NumElements = params->data_size / params->texel_size;
+    uav_desc.Buffer.Flags = 0;
+    hr = ID3D11Device_CreateUnorderedAccessView(device, resource->resource, &uav_desc, &resource->uav);
+    ok(hr == S_OK, "Failed to create view, hr %#lx.\n", hr);
+}
+
 static struct resource *d3d11_runner_create_resource(struct shader_runner *r, const struct resource_params *params)
 {
     struct d3d11_shader_runner *runner = d3d11_shader_runner(r);
     ID3D11Device *device = runner->device;
     struct d3d11_resource *resource;
-    HRESULT hr;

resource = calloc(1, sizeof(*resource));
     init_resource(&resource->r, params);
@@ -369,77 +444,15 @@ static struct resource *d3d11_runner_create_resource(struct shader_runner *r, co
     {
         case RESOURCE_TYPE_RENDER_TARGET:
         case RESOURCE_TYPE_TEXTURE:
-        case RESOURCE_TYPE_UAV:
-        {
-            D3D11_SUBRESOURCE_DATA resource_data[2];
-            D3D11_TEXTURE2D_DESC desc = {0};
-
-            if (params->level_count > ARRAY_SIZE(resource_data))
-                fatal_error("Level count %u is too high.\n", params->level_count);
-
-            desc.Width = params->width;
-            desc.Height = params->height;
-            desc.MipLevels = params->level_count;
-            desc.ArraySize = 1;
-            desc.Format = params->format;
-            desc.SampleDesc.Count = 1;
-            desc.Usage = D3D11_USAGE_DEFAULT;
-            if (params->type == RESOURCE_TYPE_UAV)
-                desc.BindFlags = D3D11_BIND_UNORDERED_ACCESS;
-            else if (params->type == RESOURCE_TYPE_RENDER_TARGET)
-                desc.BindFlags = D3D11_BIND_RENDER_TARGET;
-            else
-                desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
-
-            if (params->data)
-            {
-                unsigned int buffer_offset = 0;
-
-                for (unsigned int level = 0; level < params->level_count; ++level)
-                {
-                    unsigned int level_width = get_level_dimension(params->width, level);
-                    unsigned int level_height = get_level_dimension(params->height, level);
-
-                    resource_data[level].pSysMem = &params->data[buffer_offset];
-                    resource_data[level].SysMemPitch = level_width * params->texel_size;
-                    resource_data[level].SysMemSlicePitch = level_height * resource_data[level].SysMemPitch;
-                    buffer_offset += resource_data[level].SysMemSlicePitch;
-                }
-                hr = ID3D11Device_CreateTexture2D(device, &desc, resource_data, &resource->texture);
-            }
-            else
-            {
-                hr = ID3D11Device_CreateTexture2D(device, &desc, NULL, &resource->texture);
-            }
-            ok(hr == S_OK, "Failed to create texture, hr %#lx.\n", hr);
-
-            resource->resource = (ID3D11Resource *)resource->texture;
-            if (params->type == RESOURCE_TYPE_UAV)
-                hr = ID3D11Device_CreateUnorderedAccessView(device, resource->resource, NULL, &resource->uav);
-            else if (params->type == RESOURCE_TYPE_RENDER_TARGET)
-                hr = ID3D11Device_CreateRenderTargetView(device, resource->resource, NULL, &resource->rtv);
-            else
-                hr = ID3D11Device_CreateShaderResourceView(device, resource->resource, NULL, &resource->srv);
-            ok(hr == S_OK, "Failed to create view, hr %#lx.\n", hr);
+            init_resource_2d(runner, resource, params);
             break;
-        }
-
-        case RESOURCE_TYPE_BUFFER_UAV:
-        {
-            D3D11_UNORDERED_ACCESS_VIEW_DESC uav_desc;
-
-            resource->buffer = create_buffer(device, D3D11_BIND_UNORDERED_ACCESS, params->data_size, params->data);
-            resource->resource = (ID3D11Resource *)resource->buffer;

-            uav_desc.Format = params->format;
-            uav_desc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
-            uav_desc.Buffer.FirstElement = 0;
-            uav_desc.Buffer.NumElements = params->data_size / params->texel_size;
-            uav_desc.Buffer.Flags = 0;
-            hr = ID3D11Device_CreateUnorderedAccessView(device, resource->resource, &uav_desc, &resource->uav);
-            ok(hr == S_OK, "Failed to create view, hr %#lx.\n", hr);
+        case RESOURCE_TYPE_UAV:
+            if (params->dimension == RESOURCE_DIMENSION_BUFFER)
+                init_resource_uav_buffer(runner, resource, params);
+            else
+                init_resource_2d(runner, resource, params);
             break;
-        }

case RESOURCE_TYPE_VERTEX_BUFFER:
             resource->buffer = create_buffer(device, D3D11_BIND_VERTEX_BUFFER, params->data_size, params->data);
@@ -522,7 +535,6 @@ static bool d3d11_runner_dispatch(struct shader_runner *r, unsigned int x, unsig
                 break;

case RESOURCE_TYPE_UAV:
-            case RESOURCE_TYPE_BUFFER_UAV:
                 ID3D11DeviceContext_CSSetUnorderedAccessViews(context, resource->r.slot, 1, &resource->uav, NULL);
                 break;

@@ -609,7 +621,6 @@ static bool d3d11_runner_draw(struct shader_runner *r,
                 break;

case RESOURCE_TYPE_UAV:
-            case RESOURCE_TYPE_BUFFER_UAV:
                 uavs[resource->r.slot] = resource->uav;
                 min_uav_slot = min(min_uav_slot, resource->r.slot);
                 break;
@@ -693,25 +704,28 @@ static struct resource_readback *d3d11_runner_get_resource_readback(struct shade

switch (resource->r.type)
     {
-        case RESOURCE_TYPE_BUFFER_UAV:
-            ID3D11Buffer_GetDesc(resource->buffer, &buffer_desc);
-            buffer_desc.Usage = D3D11_USAGE_STAGING;
-            buffer_desc.BindFlags = 0;
-            buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
-            buffer_desc.MiscFlags = 0;
-            hr = ID3D11Device_CreateBuffer(runner->device, &buffer_desc, NULL, (ID3D11Buffer **)&rb->resource);
-            ok(hr == S_OK, "Failed to create buffer, hr %#lx.\n", hr);
-            break;
-
         case RESOURCE_TYPE_RENDER_TARGET:
         case RESOURCE_TYPE_UAV:
-            ID3D11Texture2D_GetDesc(resource->texture, &texture_desc);
-            texture_desc.Usage = D3D11_USAGE_STAGING;
-            texture_desc.BindFlags = 0;
-            texture_desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
-            texture_desc.MiscFlags = 0;
-            hr = ID3D11Device_CreateTexture2D(runner->device, &texture_desc, NULL, (ID3D11Texture2D **)&rb->resource);
-            ok(hr == S_OK, "Failed to create texture, hr %#lx.\n", hr);
+            if (resource->r.dimension == RESOURCE_DIMENSION_BUFFER)
+            {
+                ID3D11Buffer_GetDesc(resource->buffer, &buffer_desc);
+                buffer_desc.Usage = D3D11_USAGE_STAGING;
+                buffer_desc.BindFlags = 0;
+                buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+                buffer_desc.MiscFlags = 0;
+                hr = ID3D11Device_CreateBuffer(runner->device, &buffer_desc, NULL, (ID3D11Buffer **)&rb->resource);
+                ok(hr == S_OK, "Failed to create buffer, hr %#lx.\n", hr);
+            }
+            else
+            {
+                ID3D11Texture2D_GetDesc(resource->texture, &texture_desc);
+                texture_desc.Usage = D3D11_USAGE_STAGING;
+                texture_desc.BindFlags = 0;
+                texture_desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+                texture_desc.MiscFlags = 0;
+                hr = ID3D11Device_CreateTexture2D(runner->device, &texture_desc, NULL, (ID3D11Texture2D **)&rb->resource);
+                ok(hr == S_OK, "Failed to create texture, hr %#lx.\n", hr);
+            }
             break;

case RESOURCE_TYPE_VERTEX_BUFFER:
diff --git a/tests/shader_runner_d3d12.c b/tests/shader_runner_d3d12.c
index d6b80d9ea..ae8c3b125 100644
--- a/tests/shader_runner_d3d12.c
+++ b/tests/shader_runner_d3d12.c
@@ -177,39 +177,37 @@ static struct resource *d3d12_runner_create_resource(struct shader_runner *r, co
                 runner->heap = create_gpu_descriptor_heap(device,
                         D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, MAX_RESOURCE_DESCRIPTORS);

-            resource->resource = create_default_texture2d(device, params->width, params->height, 1, params->level_count,
-                    params->format, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_COPY_DEST);
-            upload_texture_data_with_states(resource->resource, resource_data,
-                    params->level_count, test_context->queue, test_context->list,
-                    RESOURCE_STATE_DO_NOT_CHANGE, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
-            reset_command_list(test_context->list, test_context->allocator);
-            ID3D12Device_CreateUnorderedAccessView(device, resource->resource,
-                    NULL, NULL, get_cpu_descriptor_handle(test_context, runner->heap, resource->r.slot + MAX_RESOURCES));
+            if (params->dimension == RESOURCE_DIMENSION_BUFFER)
+            {
+                D3D12_UNORDERED_ACCESS_VIEW_DESC uav_desc = { 0 };
+
+                resource->resource = create_default_buffer(device, params->data_size,
+                        D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_COPY_DEST);
+                upload_buffer_data_with_states(resource->resource, 0, params->data_size, resource_data,
+                        test_context->queue, test_context->list,
+                        RESOURCE_STATE_DO_NOT_CHANGE, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
+                reset_command_list(test_context->list, test_context->allocator);
+
+                uav_desc.Format = params->format;
+                uav_desc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
+                uav_desc.Buffer.NumElements = params->width * params->height;
+
+                ID3D12Device_CreateUnorderedAccessView(device, resource->resource,
+                        NULL, &uav_desc, get_cpu_descriptor_handle(test_context, runner->heap, resource->r.slot + MAX_RESOURCES));
+            }
+            else
+            {
+                resource->resource = create_default_texture2d(device, params->width, params->height, 1, params->level_count,
+                        params->format, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_COPY_DEST);
+                upload_texture_data_with_states(resource->resource, resource_data,
+                        params->level_count, test_context->queue, test_context->list,
+                        RESOURCE_STATE_DO_NOT_CHANGE, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
+                reset_command_list(test_context->list, test_context->allocator);
+                ID3D12Device_CreateUnorderedAccessView(device, resource->resource,
+                        NULL, NULL, get_cpu_descriptor_handle(test_context, runner->heap, resource->r.slot + MAX_RESOURCES));
+            }
             break;

-        case RESOURCE_TYPE_BUFFER_UAV:
-        {
-            D3D12_UNORDERED_ACCESS_VIEW_DESC uav_desc = { 0 };
-
-            if (!runner->heap)
-                runner->heap = create_gpu_descriptor_heap(device,
-                        D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, MAX_RESOURCE_DESCRIPTORS);
-
-            resource->resource = create_default_buffer(device, params->data_size,
-                    D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_COPY_DEST);
-            upload_buffer_data_with_states(resource->resource, 0, params->data_size, resource_data,
-                    test_context->queue, test_context->list,
-                    RESOURCE_STATE_DO_NOT_CHANGE, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
-            reset_command_list(test_context->list, test_context->allocator);
-
-            uav_desc.Format = params->format;
-            uav_desc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
-            uav_desc.Buffer.NumElements = params->width * params->height;
-
-            ID3D12Device_CreateUnorderedAccessView(device, resource->resource,
-                    NULL, &uav_desc, get_cpu_descriptor_handle(test_context, runner->heap, resource->r.slot + MAX_RESOURCES));
-            break;
-        }
         case RESOURCE_TYPE_VERTEX_BUFFER:
             resource->resource = create_upload_buffer(device, params->data_size, params->data);
             break;
@@ -263,7 +261,6 @@ static ID3D12RootSignature *d3d12_runner_create_root_signature(struct d3d12_shad
         {
             case RESOURCE_TYPE_TEXTURE:
             case RESOURCE_TYPE_UAV:
-            case RESOURCE_TYPE_BUFFER_UAV:
                 range = &resource->descriptor_range;

resource->root_index = root_signature_desc.NumParameters++;
@@ -273,7 +270,7 @@ static ID3D12RootSignature *d3d12_runner_create_root_signature(struct d3d12_shad
                 root_param->DescriptorTable.pDescriptorRanges = range;
                 root_param->ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL;

-                if (resource->r.type == RESOURCE_TYPE_UAV || resource->r.type == RESOURCE_TYPE_BUFFER_UAV)
+                if (resource->r.type == RESOURCE_TYPE_UAV)
                     range->RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_UAV;
                 else
                     range->RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV;
@@ -373,7 +370,6 @@ static bool d3d12_runner_dispatch(struct shader_runner *r, unsigned int x, unsig
                 break;

case RESOURCE_TYPE_UAV:
-            case RESOURCE_TYPE_BUFFER_UAV:
                 ID3D12GraphicsCommandList_SetComputeRootDescriptorTable(command_list, resource->root_index,
                         get_gpu_descriptor_handle(test_context, runner->heap, resource->r.slot + MAX_RESOURCES));
                 break;
@@ -514,7 +510,6 @@ static bool d3d12_runner_draw(struct shader_runner *r,
                 break;

case RESOURCE_TYPE_UAV:
-            case RESOURCE_TYPE_BUFFER_UAV:
                 ID3D12GraphicsCommandList_SetGraphicsRootDescriptorTable(command_list, resource->root_index,
                         get_gpu_descriptor_handle(test_context, runner->heap, resource->r.slot + MAX_RESOURCES));
                 break;
diff --git a/tests/shader_runner_d3d9.c b/tests/shader_runner_d3d9.c
index 0b33c1c53..9f142b551 100644
--- a/tests/shader_runner_d3d9.c
+++ b/tests/shader_runner_d3d9.c
@@ -258,7 +258,6 @@ static struct resource *d3d9_runner_create_resource(struct shader_runner *r, con
         }

case RESOURCE_TYPE_UAV:
-        case RESOURCE_TYPE_BUFFER_UAV:
             fatal_error("UAVs are not supported.\n");
             break;

@@ -384,7 +383,6 @@ static bool d3d9_runner_draw(struct shader_runner *r,
                 break;

case RESOURCE_TYPE_UAV:
-            case RESOURCE_TYPE_BUFFER_UAV:
                 vkd3d_unreachable();

case RESOURCE_TYPE_VERTEX_BUFFER:
diff --git a/tests/shader_runner_gl.c b/tests/shader_runner_gl.c
index 9a3dd7104..d1e90a203 100644
--- a/tests/shader_runner_gl.c
+++ b/tests/shader_runner_gl.c
@@ -299,10 +299,46 @@ static const struct format_info *get_format_info(enum DXGI_FORMAT format)
     fatal_error("Failed to find format info for format %#x.\n", format);
 }

+static void init_resource_2d(struct gl_resource *resource, const struct resource_params *params)
+{
+    unsigned int offset, w, h, i;
+
+    resource->format = get_format_info(params->format);
+    glGenTextures(1, &resource->id);
+    glBindTexture(GL_TEXTURE_2D, resource->id);
+    glTexStorage2D(GL_TEXTURE_2D, params->level_count,
+            resource->format->internal_format, params->width, params->height);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
+    if (!params->data)
+        return;
+
+    for (i = 0, offset = 0; i < params->level_count; ++i)
+    {
+        w = get_level_dimension(params->width, i);
+        h = get_level_dimension(params->height, i);
+        glTexSubImage2D(GL_TEXTURE_2D, i, 0, 0, w, h, resource->format->format,
+                resource->format->type, params->data + offset);
+        offset += w * h * params->texel_size;
+    }
+}
+
+static void init_resource_buffer(struct gl_resource *resource, const struct resource_params *params)
+{
+    resource->format = get_format_info(params->format);
+
+    glGenBuffers(1, &resource->id);
+    glBindBuffer(GL_TEXTURE_BUFFER, resource->id);
+    glBufferData(GL_TEXTURE_BUFFER, params->data_size, params->data, GL_STATIC_DRAW);
+
+    glGenTextures(1, &resource->tbo_id);
+    glBindTexture(GL_TEXTURE_BUFFER, resource->tbo_id);
+    glTexBuffer(GL_TEXTURE_BUFFER, resource->format->internal_format, resource->id);
+}
+
 static struct resource *gl_runner_create_resource(struct shader_runner *r, const struct resource_params *params)
 {
     struct gl_resource *resource;
-    unsigned int offset, w, h, i;

resource = calloc(1, sizeof(*resource));
     init_resource(&resource->r, params);
@@ -311,37 +347,14 @@ static struct resource *gl_runner_create_resource(struct shader_runner *r, const
     {
         case RESOURCE_TYPE_RENDER_TARGET:
         case RESOURCE_TYPE_TEXTURE:
-        case RESOURCE_TYPE_UAV:
-            resource->format = get_format_info(params->format);
-            glGenTextures(1, &resource->id);
-            glBindTexture(GL_TEXTURE_2D, resource->id);
-            glTexStorage2D(GL_TEXTURE_2D, params->level_count,
-                    resource->format->internal_format, params->width, params->height);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
-            if (!params->data)
-                break;
-
-            for (i = 0, offset = 0; i < params->level_count; ++i)
-            {
-                w = get_level_dimension(params->width, i);
-                h = get_level_dimension(params->height, i);
-                glTexSubImage2D(GL_TEXTURE_2D, i, 0, 0, w, h, resource->format->format,
-                        resource->format->type, params->data + offset);
-                offset += w * h * params->texel_size;
-            }
+            init_resource_2d(resource, params);
             break;

-        case RESOURCE_TYPE_BUFFER_UAV:
-            resource->format = get_format_info(params->format);
-
-            glGenBuffers(1, &resource->id);
-            glBindBuffer(GL_TEXTURE_BUFFER, resource->id);
-            glBufferData(GL_TEXTURE_BUFFER, params->data_size, params->data, GL_STATIC_DRAW);
-
-            glGenTextures(1, &resource->tbo_id);
-            glBindTexture(GL_TEXTURE_BUFFER, resource->tbo_id);
-            glTexBuffer(GL_TEXTURE_BUFFER, resource->format->internal_format, resource->id);
+        case RESOURCE_TYPE_UAV:
+            if (params->dimension == RESOURCE_DIMENSION_BUFFER)
+                init_resource_buffer(resource, params);
+            else
+                init_resource_2d(resource, params);
             break;

case RESOURCE_TYPE_VERTEX_BUFFER:
@@ -362,13 +375,21 @@ static void gl_runner_destroy_resource(struct shader_runner *r, struct resource
     {
         case RESOURCE_TYPE_RENDER_TARGET:
         case RESOURCE_TYPE_TEXTURE:
-        case RESOURCE_TYPE_UAV:
             glDeleteTextures(1, &resource->id);
             break;

-        case RESOURCE_TYPE_BUFFER_UAV:
-            glDeleteTextures(1, &resource->tbo_id);
-            /* Fall-through. */
+        case RESOURCE_TYPE_UAV:
+            if (res->dimension == RESOURCE_DIMENSION_BUFFER)
+            {
+                glDeleteTextures(1, &resource->tbo_id);
+                glDeleteBuffers(1, &resource->id);
+            }
+            else
+            {
+                glDeleteTextures(1, &resource->id);
+            }
+            break;
+
         case RESOURCE_TYPE_VERTEX_BUFFER:
             glDeleteBuffers(1, &resource->id);
             break;
@@ -486,13 +507,12 @@ static bool compile_shader(struct gl_runner *runner, ID3DBlob *blob, struct vkd3
         switch (resource->r.type)
         {
             case RESOURCE_TYPE_UAV:
-            case RESOURCE_TYPE_BUFFER_UAV:
                 binding = &bindings[interface_info.binding_count++];
                 binding->type = VKD3D_SHADER_DESCRIPTOR_TYPE_UAV;
                 binding->register_space = 0;
                 binding->register_index = resource->r.slot;
                 binding->shader_visibility = VKD3D_SHADER_VISIBILITY_ALL;
-                if (resource->r.type == RESOURCE_TYPE_BUFFER_UAV)
+                if (resource->r.dimension == RESOURCE_DIMENSION_BUFFER)
                     binding->flags = VKD3D_SHADER_BINDING_FLAG_BUFFER;
                 else
                     binding->flags = VKD3D_SHADER_BINDING_FLAG_IMAGE;
@@ -621,16 +641,13 @@ static bool gl_runner_dispatch(struct shader_runner *r, unsigned int x, unsigned
         {
             case RESOURCE_TYPE_RENDER_TARGET:
             case RESOURCE_TYPE_VERTEX_BUFFER:
-                break;
-
             case RESOURCE_TYPE_TEXTURE:
-            case RESOURCE_TYPE_BUFFER_UAV:
-                trace("RESOURCE TYPE %#x.\n", resource->r.type);
                 break;

case RESOURCE_TYPE_UAV:
-                glBindImageTexture(resource->r.slot, resource->id, 0, GL_TRUE,
-                        0, GL_READ_WRITE, resource->format->internal_format);
+                if (resource->r.dimension != RESOURCE_DIMENSION_BUFFER)
+                    glBindImageTexture(resource->r.slot, resource->id, 0, GL_TRUE,
+                            0, GL_READ_WRITE, resource->format->internal_format);
                 break;
         }
     }
@@ -857,13 +874,16 @@ static bool gl_runner_draw(struct shader_runner *r,
                 break;

case RESOURCE_TYPE_UAV:
-                glBindImageTexture(resource->r.slot, resource->id, 0, GL_TRUE,
-                        0, GL_READ_WRITE, resource->format->internal_format);
-                break;
-
-            case RESOURCE_TYPE_BUFFER_UAV:
-                glBindImageTexture(resource->r.slot, resource->tbo_id, 0, GL_TRUE,
-                        0, GL_READ_WRITE, resource->format->internal_format);
+                if (resource->r.dimension == RESOURCE_DIMENSION_BUFFER)
+                {
+                    glBindImageTexture(resource->r.slot, resource->tbo_id, 0, GL_TRUE,
+                            0, GL_READ_WRITE, resource->format->internal_format);
+                }
+                else
+                {
+                    glBindImageTexture(resource->r.slot, resource->id, 0, GL_TRUE,
+                            0, GL_READ_WRITE, resource->format->internal_format);
+                }
                 break;

case RESOURCE_TYPE_VERTEX_BUFFER:
@@ -944,8 +964,7 @@ static struct resource_readback *gl_runner_get_resource_readback(struct shader_r
     struct gl_resource *resource = gl_resource(res);
     struct resource_readback *rb;

-    if (resource->r.type != RESOURCE_TYPE_RENDER_TARGET && resource->r.type != RESOURCE_TYPE_UAV
-            && resource->r.type != RESOURCE_TYPE_BUFFER_UAV)
+    if (resource->r.type != RESOURCE_TYPE_RENDER_TARGET && resource->r.type != RESOURCE_TYPE_UAV)
         fatal_error("Unhandled resource type %#x.\n", resource->r.type);

rb = malloc(sizeof(*rb));
@@ -957,7 +976,7 @@ static struct resource_readback *gl_runner_get_resource_readback(struct shader_r
     rb->row_pitch = rb->width * resource->r.texel_size;
     rb->data = malloc(rb->row_pitch * rb->height);

-    if (resource->r.type == RESOURCE_TYPE_BUFFER_UAV)
+    if (resource->r.dimension == RESOURCE_DIMENSION_BUFFER)
     {
         glBindBuffer(GL_TEXTURE_BUFFER, resource->id);
         glGetBufferSubData(GL_TEXTURE_BUFFER, 0, rb->row_pitch * rb->height, rb->data);
diff --git a/tests/shader_runner_vulkan.c b/tests/shader_runner_vulkan.c
index bb6b3a30a..4968c478a 100644
--- a/tests/shader_runner_vulkan.c
+++ b/tests/shader_runner_vulkan.c
@@ -262,14 +262,87 @@ static VkImageView create_2d_image_view(const struct vulkan_shader_runner *runne
     return view;
 }

+static void resource_init_2d(struct vulkan_shader_runner *runner, struct vulkan_resource *resource,
+        const struct resource_params *params)
+{
+    VkImageUsageFlagBits usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
+    VkImageLayout layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+    VkFormat format = vkd3d_get_vk_format(params->format);
+    VkDevice device = runner->device;
+    unsigned int buffer_offset = 0;
+    VkDeviceMemory staging_memory;
+    VkBuffer staging_buffer;
+    void *data;
+
+    if (params->type == RESOURCE_TYPE_UAV)
+    {
+        layout = VK_IMAGE_LAYOUT_GENERAL;
+        usage |= VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+    }
+
+    resource->image = create_2d_image(runner, params->width, params->height, params->level_count,
+            usage, format, &resource->memory);
+    resource->image_view = create_2d_image_view(runner, resource->image, format);
+
+    staging_buffer = create_buffer(runner, params->data_size,
+            VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &staging_memory);
+    VK_CALL(vkMapMemory(device, staging_memory, 0, VK_WHOLE_SIZE, 0, &data));
+    memcpy(data, params->data, params->data_size);
+    VK_CALL(vkUnmapMemory(device, staging_memory));
+
+    begin_command_buffer(runner);
+
+    transition_image_layout(runner, resource->image,
+            VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+
+    for (unsigned int level = 0; level < params->level_count; ++level)
+    {
+        unsigned int level_width = get_level_dimension(params->width, level);
+        unsigned int level_height = get_level_dimension(params->height, level);
+        VkBufferImageCopy region = {0};
+
+        region.bufferOffset = buffer_offset;
+        region.imageSubresource.mipLevel = level;
+        region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+        region.imageSubresource.layerCount = 1;
+        region.imageExtent.width = level_width;
+        region.imageExtent.height = level_height;
+        region.imageExtent.depth = 1;
+        VK_CALL(vkCmdCopyBufferToImage(runner->cmd_buffer, staging_buffer, resource->image,
+                VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region));
+
+        buffer_offset += level_width * level_height * params->texel_size;
+    }
+
+    transition_image_layout(runner, resource->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, layout);
+
+    end_command_buffer(runner);
+
+    VK_CALL(vkFreeMemory(device, staging_memory, NULL));
+    VK_CALL(vkDestroyBuffer(device, staging_buffer, NULL));
+}
+
+static void resource_init_buffer(struct vulkan_shader_runner *runner, struct vulkan_resource *resource,
+        const struct resource_params *params)
+{
+    VkFormat format = vkd3d_get_vk_format(params->format);
+    VkDevice device = runner->device;
+    void *data;
+
+    resource->buffer = create_buffer(runner, params->data_size, VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT,
+            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &resource->memory);
+    resource->buffer_view = create_buffer_view(runner, resource->buffer, format);
+
+    VK_CALL(vkMapMemory(device, resource->memory, 0, VK_WHOLE_SIZE, 0, &data));
+    memcpy(data, params->data, params->data_size);
+    VK_CALL(vkUnmapMemory(device, resource->memory));
+}
+
 static struct resource *vulkan_runner_create_resource(struct shader_runner *r, const struct resource_params *params)
 {
     struct vulkan_shader_runner *runner = vulkan_shader_runner(r);
-
     struct vulkan_resource *resource;
     VkDevice device = runner->device;
-    VkDeviceMemory staging_memory;
-    VkBuffer staging_buffer;
     VkFormat format;
     void *data;

@@ -292,73 +365,14 @@ static struct resource *vulkan_runner_create_resource(struct shader_runner *r, c
             break;

case RESOURCE_TYPE_TEXTURE:
-        case RESOURCE_TYPE_UAV:
-        {
-            VkImageUsageFlagBits usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
-            VkImageLayout layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-            unsigned int buffer_offset = 0;
-
-            format = vkd3d_get_vk_format(params->format);
-
-            if (params->type == RESOURCE_TYPE_UAV)
-            {
-                layout = VK_IMAGE_LAYOUT_GENERAL;
-                usage |= VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
-            }
-
-            resource->image = create_2d_image(runner, params->width, params->height, params->level_count,
-                    usage, format, &resource->memory);
-            resource->image_view = create_2d_image_view(runner, resource->image, format);
-
-            staging_buffer = create_buffer(runner, params->data_size,
-                    VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &staging_memory);
-            VK_CALL(vkMapMemory(device, staging_memory, 0, VK_WHOLE_SIZE, 0, &data));
-            memcpy(data, params->data, params->data_size);
-            VK_CALL(vkUnmapMemory(device, staging_memory));
-
-            begin_command_buffer(runner);
-
-            transition_image_layout(runner, resource->image,
-                    VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
-
-            for (unsigned int level = 0; level < params->level_count; ++level)
-            {
-                unsigned int level_width = get_level_dimension(params->width, level);
-                unsigned int level_height = get_level_dimension(params->height, level);
-                VkBufferImageCopy region = {0};
-
-                region.bufferOffset = buffer_offset;
-                region.imageSubresource.mipLevel = level;
-                region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-                region.imageSubresource.layerCount = 1;
-                region.imageExtent.width = level_width;
-                region.imageExtent.height = level_height;
-                region.imageExtent.depth = 1;
-                VK_CALL(vkCmdCopyBufferToImage(runner->cmd_buffer, staging_buffer, resource->image,
-                        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region));
-
-                buffer_offset += level_width * level_height * params->texel_size;
-            }
-
-            transition_image_layout(runner, resource->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, layout);
-
-            end_command_buffer(runner);
-
-            VK_CALL(vkFreeMemory(device, staging_memory, NULL));
-            VK_CALL(vkDestroyBuffer(device, staging_buffer, NULL));
+            resource_init_2d(runner, resource, params);
             break;
-        }
-
-        case RESOURCE_TYPE_BUFFER_UAV:
-            format = vkd3d_get_vk_format(params->format);

-            resource->buffer = create_buffer(runner, params->data_size, VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT,
-                    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &resource->memory);
-            resource->buffer_view = create_buffer_view(runner, resource->buffer, format);
-
-            VK_CALL(vkMapMemory(device, resource->memory, 0, VK_WHOLE_SIZE, 0, &data));
-            memcpy(data, params->data, params->data_size);
-            VK_CALL(vkUnmapMemory(device, resource->memory));
+        case RESOURCE_TYPE_UAV:
+            if (params->dimension == RESOURCE_DIMENSION_BUFFER)
+                resource_init_buffer(runner, resource, params);
+            else
+                resource_init_2d(runner, resource, params);
             break;

case RESOURCE_TYPE_VERTEX_BUFFER:
@@ -492,16 +506,15 @@ static bool compile_shader(struct vulkan_shader_runner *runner, const char *sour

case RESOURCE_TYPE_TEXTURE:
             case RESOURCE_TYPE_UAV:
-            case RESOURCE_TYPE_BUFFER_UAV:
                 binding = &bindings[interface_info.binding_count++];
-                if (resource->r.type == RESOURCE_TYPE_UAV || resource->r.type == RESOURCE_TYPE_BUFFER_UAV)
+                if (resource->r.type == RESOURCE_TYPE_UAV)
                     binding->type = VKD3D_SHADER_DESCRIPTOR_TYPE_UAV;
                 else
                     binding->type = VKD3D_SHADER_DESCRIPTOR_TYPE_SRV;
                 binding->register_space = 0;
                 binding->register_index = resource->r.slot;
                 binding->shader_visibility = VKD3D_SHADER_VISIBILITY_ALL;
-                if (resource->r.type == RESOURCE_TYPE_BUFFER_UAV)
+                if (resource->r.dimension == RESOURCE_DIMENSION_BUFFER)
                     binding->flags = VKD3D_SHADER_BINDING_FLAG_BUFFER;
                 else
                     binding->flags = VKD3D_SHADER_BINDING_FLAG_IMAGE;
@@ -684,7 +697,6 @@ static VkPipeline create_graphics_pipeline(struct vulkan_shader_runner *runner,
         {
             case RESOURCE_TYPE_TEXTURE:
             case RESOURCE_TYPE_UAV:
-            case RESOURCE_TYPE_BUFFER_UAV:
                 break;

case RESOURCE_TYPE_RENDER_TARGET:
@@ -815,18 +827,22 @@ static VkDescriptorSetLayout create_descriptor_set_layout(struct vulkan_shader_r

case RESOURCE_TYPE_TEXTURE:
             case RESOURCE_TYPE_UAV:
-            case RESOURCE_TYPE_BUFFER_UAV:
                 binding = &bindings[set_desc.bindingCount++];

resource->binding = binding_index++;

binding->binding = resource->binding;
                 if (resource->r.type == RESOURCE_TYPE_UAV)
-                    binding->descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
-                else if (resource->r.type == RESOURCE_TYPE_BUFFER_UAV)
-                    binding->descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
+                {
+                    if (resource->r.dimension == RESOURCE_DIMENSION_BUFFER)
+                        binding->descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
+                    else
+                        binding->descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
+                }
                 else
+                {
                     binding->descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
+                }
                 binding->descriptorCount = 1;
                 binding->stageFlags = VK_SHADER_STAGE_ALL;
                 binding->pImmutableSamplers = NULL;
@@ -890,34 +906,38 @@ static void bind_resources(struct vulkan_shader_runner *runner, VkPipelineBindPo
         {
             case RESOURCE_TYPE_TEXTURE:
             case RESOURCE_TYPE_UAV:
-                image_info.imageView = resource->image_view;
-                image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-
-                write.dstSet = descriptor_set;
-                write.dstBinding = resource->binding;
-                write.dstArrayElement = 0;
-                write.descriptorCount = 1;
-                write.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
-                write.pImageInfo = &image_info;
-
-                if (resource->r.type == RESOURCE_TYPE_UAV)
+                if (resource->r.dimension == RESOURCE_DIMENSION_BUFFER)
                 {
-                    image_info.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
-                    write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
+                    assert(resource->r.type == RESOURCE_TYPE_UAV);
+                    write.dstSet = descriptor_set;
+                    write.dstBinding = resource->binding;
+                    write.dstArrayElement = 0;
+                    write.descriptorCount = 1;
+                    write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
+                    write.pTexelBufferView = &resource->buffer_view;
+
+                    VK_CALL(vkUpdateDescriptorSets(runner->device, 1, &write, 0, NULL));
                 }
+                else
+                {
+                    image_info.imageView = resource->image_view;
+                    image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;

-                VK_CALL(vkUpdateDescriptorSets(runner->device, 1, &write, 0, NULL));
-                break;
+                    write.dstSet = descriptor_set;
+                    write.dstBinding = resource->binding;
+                    write.dstArrayElement = 0;
+                    write.descriptorCount = 1;
+                    write.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
+                    write.pImageInfo = &image_info;

-            case RESOURCE_TYPE_BUFFER_UAV:
-                write.dstSet = descriptor_set;
-                write.dstBinding = resource->binding;
-                write.dstArrayElement = 0;
-                write.descriptorCount = 1;
-                write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
-                write.pTexelBufferView = &resource->buffer_view;
+                    if (resource->r.type == RESOURCE_TYPE_UAV)
+                    {
+                        image_info.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
+                        write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
+                    }

-                VK_CALL(vkUpdateDescriptorSets(runner->device, 1, &write, 0, NULL));
+                    VK_CALL(vkUpdateDescriptorSets(runner->device, 1, &write, 0, NULL));
+                }
                 break;

case RESOURCE_TYPE_VERTEX_BUFFER:
@@ -1125,7 +1145,7 @@ static struct resource_readback *vulkan_runner_get_resource_readback(struct shad
     rb->buffer = create_buffer(runner, rb->rb.row_pitch * rb->rb.height,
             VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &rb->memory);

-    if (resource->r.type == RESOURCE_TYPE_BUFFER_UAV)
+    if (resource->r.type == RESOURCE_TYPE_UAV && resource->r.dimension == RESOURCE_DIMENSION_BUFFER)
     {
         void *data;

[PATCH v4 3/5] tests/shader_runner: Support SRV buffers.

[Francisco Casas]

From: Francisco Casas

---
 Makefile.am                        |  1 +
 tests/hlsl/srv-buffers.shader_test | 72 ++++++++++++++++++++++++++++++
 tests/shader_runner.c              | 14 ++++++
 tests/shader_runner_d3d11.c        | 23 +++++++++-
 tests/shader_runner_d3d12.c        | 43 +++++++++++++-----
 tests/shader_runner_d3d9.c         |  8 ++++
 tests/shader_runner_gl.c           | 24 ++++++----
 tests/shader_runner_vulkan.c       | 26 +++++++----
 8 files changed, 183 insertions(+), 28 deletions(-)
 create mode 100644 tests/hlsl/srv-buffers.shader_test

diff --git a/Makefile.am b/Makefile.am
index bc648b631..5315094e8 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -165,6 +165,7 @@ vkd3d_shader_tests = \
    tests/hlsl/single-numeric-initializer.shader_test \
    tests/hlsl/smoothstep.shader_test \
    tests/hlsl/sqrt.shader_test \
+	tests/hlsl/srv-buffers.shader_test \
    tests/hlsl/state-block-syntax.shader_test \
    tests/hlsl/static-initializer.shader_test \
    tests/hlsl/step.shader_test \
diff --git a/tests/hlsl/srv-buffers.shader_test b/tests/hlsl/srv-buffers.shader_test
new file mode 100644
index 000000000..5b7443cc4
--- /dev/null
+++ b/tests/hlsl/srv-buffers.shader_test
@@ -0,0 +1,72 @@
+[require]
+shader model >= 4.0
+
+
+[buffer srv 0]
+size (1, 4)
+
+0.0 1.0 2.0 3.0
+4.0 5.0 6.0 7.0
+8.0 9.0 10.0 11.0
+12.0 13.0 14.0 15.0
+
+
+[pixel shader]
+float4 a;
+Buffer<float4> buffer;
+float4 b;
+
+float4 main() : sv_target
+{
+    return float4(a.y, b.z, buffer[1].xw);
+}
+
+[test]
+uniform 0 float4 100 200 300 400
+uniform 4 float4 1000 2000 3000 4000
+todo(sm>=6) draw quad
+probe all rgba (200, 3000, 4, 7)
+
+
+[pixel shader]
+float4 a;
+Buffer<float3> buffer;
+float4 b;
+
+float4 main() : sv_target
+{
+    return float4(b.w, buffer[2]);
+}
+
+[test]
+uniform 0 float4 100 200 300 400
+uniform 4 float4 1000 2000 3000 4000
+todo(sm>=6) draw quad
+probe all rgba (4000.0, 8.0, 9.0, 10.0)
+
+
+[texture 0]
+size (1, 1)
+-1.0 -1.0 -1.0 -1.0
+
+[sampler 0]
+filter linear linear linear
+address clamp clamp clamp
+
+[buffer srv 1]
+size (1, 1)
+1.0 2.0 3.0 4.0
+
+[pixel shader]
+Texture2D tex;
+sampler sam;
+Buffer<float4> buffer;
+
+float4 main() : sv_target
+{
+    return float4(buffer[0].zw, tex.Sample(sam, float2(0, 0)).zw);
+}
+
+[test]
+todo(sm>=6) draw quad
+probe all rgba (3.0, 4.0, -1.0, -1.0)
diff --git a/tests/shader_runner.c b/tests/shader_runner.c
index e95f830d7..a814ffd6e 100644
--- a/tests/shader_runner.c
+++ b/tests/shader_runner.c
@@ -1400,6 +1400,20 @@ void run_shader_tests(struct shader_runner *runner, const struct shader_runner_o
                 current_resource.texel_size = 16;
                 current_resource.level_count = 1;
             }
+            else if (sscanf(line, "[buffer srv %u]\n", &index))
+            {
+                state = STATE_RESOURCE;
+
+                memset(&current_resource, 0, sizeof(current_resource));
+
+                current_resource.slot = index;
+                current_resource.type = RESOURCE_TYPE_TEXTURE;
+                current_resource.dimension = RESOURCE_DIMENSION_BUFFER;
+                current_resource.format = DXGI_FORMAT_R32G32B32A32_FLOAT;
+                current_resource.data_type = TEXTURE_DATA_FLOAT;
+                current_resource.texel_size = 16;
+                current_resource.level_count = 1;
+            }
             else if (sscanf(line, "[buffer uav %u]\n", &index))
             {
                 state = STATE_RESOURCE;
diff --git a/tests/shader_runner_d3d11.c b/tests/shader_runner_d3d11.c
index b2c97cdd3..b16c3c9ea 100644
--- a/tests/shader_runner_d3d11.c
+++ b/tests/shader_runner_d3d11.c
@@ -412,6 +412,24 @@ static void init_resource_2d(struct d3d11_shader_runner *runner, struct d3d11_re
     ok(hr == S_OK, "Failed to create view, hr %#lx.\n", hr);
 }

+static void init_resource_srv_buffer(struct d3d11_shader_runner *runner, struct d3d11_resource *resource,
+        const struct resource_params *params)
+{
+    D3D11_SHADER_RESOURCE_VIEW_DESC srv_desc;
+    ID3D11Device *device = runner->device;
+    HRESULT hr;
+
+    resource->buffer = create_buffer(device, D3D11_BIND_SHADER_RESOURCE, params->data_size, params->data);
+    resource->resource = (ID3D11Resource *)resource->buffer;
+
+    srv_desc.Format = params->format;
+    srv_desc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
+    srv_desc.Buffer.FirstElement = 0;
+    srv_desc.Buffer.NumElements = params->data_size / params->texel_size;
+    hr = ID3D11Device_CreateShaderResourceView(device, resource->resource, &srv_desc, &resource->srv);
+    ok(hr == S_OK, "Failed to create view, hr %#lx.\n", hr);
+}
+
 static void init_resource_uav_buffer(struct d3d11_shader_runner *runner, struct d3d11_resource *resource,
         const struct resource_params *params)
 {
@@ -444,7 +462,10 @@ static struct resource *d3d11_runner_create_resource(struct shader_runner *r, co
     {
         case RESOURCE_TYPE_RENDER_TARGET:
         case RESOURCE_TYPE_TEXTURE:
-            init_resource_2d(runner, resource, params);
+            if (params->dimension == RESOURCE_DIMENSION_BUFFER)
+                init_resource_srv_buffer(runner, resource, params);
+            else
+                init_resource_2d(runner, resource, params);
             break;

case RESOURCE_TYPE_UAV:
diff --git a/tests/shader_runner_d3d12.c b/tests/shader_runner_d3d12.c
index ae8c3b125..61812c830 100644
--- a/tests/shader_runner_d3d12.c
+++ b/tests/shader_runner_d3d12.c
@@ -119,7 +119,7 @@ static struct resource *d3d12_runner_create_resource(struct shader_runner *r, co
     struct d3d12_shader_runner *runner = d3d12_shader_runner(r);
     struct test_context *test_context = &runner->test_context;
     ID3D12Device *device = test_context->device;
-    D3D12_SUBRESOURCE_DATA resource_data[2];
+    D3D12_SUBRESOURCE_DATA resource_data[2] = {0};
     struct d3d12_resource *resource;
     unsigned int buffer_offset = 0;

@@ -161,15 +161,38 @@ static struct resource *d3d12_runner_create_resource(struct shader_runner *r, co
                 runner->heap = create_gpu_descriptor_heap(device,
                         D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, MAX_RESOURCE_DESCRIPTORS);

-            resource->resource = create_default_texture2d(device, params->width, params->height, 1, params->level_count,
-                    params->format, 0, D3D12_RESOURCE_STATE_COPY_DEST);
-            upload_texture_data_with_states(resource->resource, resource_data,
-                    params->level_count, test_context->queue, test_context->list,
-                    RESOURCE_STATE_DO_NOT_CHANGE,
-                    D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE | D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
-            reset_command_list(test_context->list, test_context->allocator);
-            ID3D12Device_CreateShaderResourceView(device, resource->resource,
-                    NULL, get_cpu_descriptor_handle(test_context, runner->heap, resource->r.slot));
+            if (params->dimension == RESOURCE_DIMENSION_BUFFER)
+            {
+                D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc = { 0 };
+
+                resource->resource = create_default_buffer(device, params->data_size,
+                        0, D3D12_RESOURCE_STATE_COPY_DEST);
+                upload_buffer_data_with_states(resource->resource, 0, params->data_size, resource_data[0].pData,
+                        test_context->queue, test_context->list,
+                        RESOURCE_STATE_DO_NOT_CHANGE,
+                        D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE | D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
+                reset_command_list(test_context->list, test_context->allocator);
+
+                srv_desc.Format = params->format;
+                srv_desc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
+                srv_desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
+                srv_desc.Buffer.NumElements = params->width * params->height;
+
+                ID3D12Device_CreateShaderResourceView(device, resource->resource,
+                        &srv_desc, get_cpu_descriptor_handle(test_context, runner->heap, resource->r.slot));
+            }
+            else
+            {
+                resource->resource = create_default_texture2d(device, params->width, params->height, 1, params->level_count,
+                        params->format, 0, D3D12_RESOURCE_STATE_COPY_DEST);
+                upload_texture_data_with_states(resource->resource, resource_data,
+                        params->level_count, test_context->queue, test_context->list,
+                        RESOURCE_STATE_DO_NOT_CHANGE,
+                        D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE | D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
+                reset_command_list(test_context->list, test_context->allocator);
+                ID3D12Device_CreateShaderResourceView(device, resource->resource,
+                        NULL, get_cpu_descriptor_handle(test_context, runner->heap, resource->r.slot));
+            }
             break;

case RESOURCE_TYPE_UAV:
diff --git a/tests/shader_runner_d3d9.c b/tests/shader_runner_d3d9.c
index 9f142b551..a78658e70 100644
--- a/tests/shader_runner_d3d9.c
+++ b/tests/shader_runner_d3d9.c
@@ -231,6 +231,12 @@ static struct resource *d3d9_runner_create_resource(struct shader_runner *r, con

case RESOURCE_TYPE_TEXTURE:
         {
+            if (params->dimension == RESOURCE_DIMENSION_BUFFER)
+            {
+                fatal_error("Buffer resources are not supported.\n");
+                break;
+            }
+
             unsigned int src_buffer_offset = 0;

hr = IDirect3DDevice9_CreateTexture(device, params->width, params->height,
@@ -378,6 +384,8 @@ static bool d3d9_runner_draw(struct shader_runner *r,
                 break;

case RESOURCE_TYPE_TEXTURE:
+                assert(resource->r.dimension != RESOURCE_DIMENSION_BUFFER);
+
                 hr = IDirect3DDevice9_SetTexture(device, resource->r.slot, (IDirect3DBaseTexture9 *)resource->texture);
                 ok(hr == D3D_OK, "Failed to set texture, hr %#lx.\n", hr);
                 break;
diff --git a/tests/shader_runner_gl.c b/tests/shader_runner_gl.c
index d1e90a203..22268c866 100644
--- a/tests/shader_runner_gl.c
+++ b/tests/shader_runner_gl.c
@@ -347,9 +347,6 @@ static struct resource *gl_runner_create_resource(struct shader_runner *r, const
     {
         case RESOURCE_TYPE_RENDER_TARGET:
         case RESOURCE_TYPE_TEXTURE:
-            init_resource_2d(resource, params);
-            break;
-
         case RESOURCE_TYPE_UAV:
             if (params->dimension == RESOURCE_DIMENSION_BUFFER)
                 init_resource_buffer(resource, params);
@@ -375,9 +372,6 @@ static void gl_runner_destroy_resource(struct shader_runner *r, struct resource
     {
         case RESOURCE_TYPE_RENDER_TARGET:
         case RESOURCE_TYPE_TEXTURE:
-            glDeleteTextures(1, &resource->id);
-            break;
-
         case RESOURCE_TYPE_UAV:
             if (res->dimension == RESOURCE_DIMENSION_BUFFER)
             {
@@ -476,7 +470,10 @@ static bool compile_shader(struct gl_runner *runner, ID3DBlob *blob, struct vkd3
         sampler->sampler_space = s->sampler_space;
         sampler->sampler_index = s->sampler_index;
         sampler->shader_visibility = VKD3D_SHADER_VISIBILITY_ALL;
-        sampler->flags = VKD3D_SHADER_BINDING_FLAG_IMAGE;
+        /* We don't know if this combined sampler was created from a SRV buffer or a SRV image, so
+         * we pass both flags, otherwise the combined sampler won't be recognized when emitting the
+         * SPIR-V, which will result in a failing assertion. */
+        sampler->flags = VKD3D_SHADER_BINDING_FLAG_IMAGE | VKD3D_SHADER_BINDING_FLAG_BUFFER;
         sampler->binding.set = 0;
         sampler->binding.binding = runner->combined_sampler_count++;
         sampler->binding.count = 1;
@@ -843,8 +840,17 @@ static bool gl_runner_draw(struct shader_runner *r,
         if (!(resource = shader_runner_get_resource(r, RESOURCE_TYPE_TEXTURE, s->resource_index)))
             fatal_error("Resource not found.\n");

-        glActiveTexture(GL_TEXTURE0 + s->binding.binding);
-        glBindTexture(GL_TEXTURE_2D, gl_resource(resource)->id);
+        if (resource->dimension == RESOURCE_DIMENSION_BUFFER)
+        {
+            glActiveTexture(GL_TEXTURE0 + s->binding.binding);
+            glBindTexture(GL_TEXTURE_BUFFER, gl_resource(resource)->tbo_id);
+        }
+        else
+        {
+            glActiveTexture(GL_TEXTURE0 + s->binding.binding);
+            glBindTexture(GL_TEXTURE_2D, gl_resource(resource)->id);
+        }
+
         if (s->sampler_index == VKD3D_SHADER_DUMMY_SAMPLER_INDEX)
             continue;

diff --git a/tests/shader_runner_vulkan.c b/tests/shader_runner_vulkan.c
index 4968c478a..a1d296c18 100644
--- a/tests/shader_runner_vulkan.c
+++ b/tests/shader_runner_vulkan.c
@@ -327,9 +327,15 @@ static void resource_init_buffer(struct vulkan_shader_runner *runner, struct vul
 {
     VkFormat format = vkd3d_get_vk_format(params->format);
     VkDevice device = runner->device;
+    VkBufferUsageFlagBits usage;
     void *data;

-    resource->buffer = create_buffer(runner, params->data_size, VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT,
+    if (params->type == RESOURCE_TYPE_UAV)
+        usage = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT;
+    else
+        usage = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT;
+
+    resource->buffer = create_buffer(runner, params->data_size, usage,
             VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &resource->memory);
     resource->buffer_view = create_buffer_view(runner, resource->buffer, format);

@@ -365,9 +371,6 @@ static struct resource *vulkan_runner_create_resource(struct shader_runner *r, c
             break;

case RESOURCE_TYPE_TEXTURE:
-            resource_init_2d(runner, resource, params);
-            break;
-
         case RESOURCE_TYPE_UAV:
             if (params->dimension == RESOURCE_DIMENSION_BUFFER)
                 resource_init_buffer(runner, resource, params);
@@ -841,7 +844,10 @@ static VkDescriptorSetLayout create_descriptor_set_layout(struct vulkan_shader_r
                 }
                 else
                 {
-                    binding->descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
+                    if (resource->r.dimension == RESOURCE_DIMENSION_BUFFER)
+                        binding->descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
+                    else
+                        binding->descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
                 }
                 binding->descriptorCount = 1;
                 binding->stageFlags = VK_SHADER_STAGE_ALL;
@@ -908,14 +914,16 @@ static void bind_resources(struct vulkan_shader_runner *runner, VkPipelineBindPo
             case RESOURCE_TYPE_UAV:
                 if (resource->r.dimension == RESOURCE_DIMENSION_BUFFER)
                 {
-                    assert(resource->r.type == RESOURCE_TYPE_UAV);
                     write.dstSet = descriptor_set;
                     write.dstBinding = resource->binding;
                     write.dstArrayElement = 0;
                     write.descriptorCount = 1;
-                    write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
+                    write.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
                     write.pTexelBufferView = &resource->buffer_view;

+                    if (resource->r.type == RESOURCE_TYPE_UAV)
+                        write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
+
                     VK_CALL(vkUpdateDescriptorSets(runner->device, 1, &write, 0, NULL));
                 }
                 else
@@ -1281,7 +1289,7 @@ static bool init_vulkan_runner(struct vulkan_shader_runner *runner)
     VkInstanceCreateInfo instance_desc = {.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO};
     VkDeviceCreateInfo device_desc = {.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO};
     VkPhysicalDeviceFeatures ret_features, features;
-    VkDescriptorPoolSize descriptor_pool_sizes[4];
+    VkDescriptorPoolSize descriptor_pool_sizes[5];
     static const float queue_priority = 1.0f;
     VkFormatProperties format_props;
     uint32_t count, graphics_index;
@@ -1408,6 +1416,8 @@ static bool init_vulkan_runner(struct vulkan_shader_runner *runner)
     descriptor_pool_sizes[2].descriptorCount = MAX_RESOURCES;
     descriptor_pool_sizes[3].type = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
     descriptor_pool_sizes[3].descriptorCount = MAX_RESOURCES;
+    descriptor_pool_sizes[4].type = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
+    descriptor_pool_sizes[4].descriptorCount = MAX_RESOURCES;

descriptor_pool_desc.maxSets = 1;
     descriptor_pool_desc.poolSizeCount = ARRAY_SIZE(descriptor_pool_sizes);

[PATCH v4 4/5] tests/shader-runner: Change resource declaration syntax on shader_test files.

[Francisco Casas]

From: Francisco Casas

On shader_test files, now resources should be declared this way:

[texture n]       -> [srv n]
    [srv buffer n]    -> [srv n]
    [uav n]           -> [uav n]
    [uav buffer n]    -> [uav n]
    [vertex buffer n] -> [vb n]
    [render target n] -> [rtv n]

The dimension (buffer or 2D) is now specified as an additional parameter
in the "size" directive:

For 2D resources:
  size (n, m)         -> size (2d, n, m)

For buffers:
  size (n, 1)         -> size (buffer, n)
---
 tests/hlsl/bool-semantics.shader_test         |  2 +-
 tests/hlsl/cbuffer.shader_test                | 16 +++---
 tests/hlsl/combined-samplers.shader_test      | 20 +++----
 tests/hlsl/compute.shader_test                |  2 +-
 tests/hlsl/gather-offset.shader_test          |  4 +-
 tests/hlsl/gather.shader_test                 |  4 +-
 tests/hlsl/getdimensions.shader_test          |  8 +--
 tests/hlsl/initializer-objects.shader_test    |  8 +--
 tests/hlsl/is-front-face.shader_test          |  4 +-
 tests/hlsl/load-level.shader_test             |  4 +-
 tests/hlsl/matrix-semantics.shader_test       | 20 +++----
 tests/hlsl/multiple-rt.shader_test            |  8 +--
 tests/hlsl/nointerpolation.shader_test        |  2 +-
 tests/hlsl/numthreads.shader_test             |  2 +-
 tests/hlsl/object-parameters.shader_test      | 24 ++++----
 tests/hlsl/object-references.shader_test      | 28 +++++-----
 tests/hlsl/register-reservations.shader_test  | 28 +++++-----
 tests/hlsl/sample-bias.shader_test            |  4 +-
 tests/hlsl/sample-grad.shader_test            |  4 +-
 tests/hlsl/sample-level.shader_test           |  4 +-
 tests/hlsl/sampler-offset.shader_test         |  4 +-
 tests/hlsl/sampler.shader_test                |  4 +-
 .../shader-interstage-interface.shader_test   |  4 +-
 tests/hlsl/srv-buffers.shader_test            | 12 ++--
 tests/hlsl/static-initializer.shader_test     |  6 +-
 tests/hlsl/struct-semantics.shader_test       |  2 +-
 tests/hlsl/swizzle-constant-prop.shader_test  |  4 +-
 tests/hlsl/texture-load-offset.shader_test    |  4 +-
 tests/hlsl/texture-load-typed.shader_test     | 12 ++--
 tests/hlsl/texture-load.shader_test           |  4 +-
 tests/hlsl/texture-ordering.shader_test       | 40 +++++++-------
 tests/hlsl/uav-load.shader_test               |  4 +-
 tests/hlsl/uav-out-param.shader_test          |  4 +-
 tests/hlsl/uav-rwbuffer.shader_test           |  8 +--
 tests/hlsl/uav-rwtexture.shader_test          | 16 +++---
 tests/shader_runner.c                         | 55 ++++++-------------
 36 files changed, 178 insertions(+), 201 deletions(-)

diff --git a/tests/hlsl/bool-semantics.shader_test b/tests/hlsl/bool-semantics.shader_test
index d8df96a2a..a30254a5e 100644
--- a/tests/hlsl/bool-semantics.shader_test
+++ b/tests/hlsl/bool-semantics.shader_test
@@ -5,7 +5,7 @@ shader model >= 4.0
 0 r32g32b32a32 uint apple
 0 r32g32 int sv_position

-[vertex buffer 0]
+[vb 0]
 format r32 uint
 0 1 0x80000000 0xffffffff   -2 -2
 0 1 0x80000000 0xffffffff   -2  2
diff --git a/tests/hlsl/cbuffer.shader_test b/tests/hlsl/cbuffer.shader_test
index b4dc01edd..c776555ff 100644
--- a/tests/hlsl/cbuffer.shader_test
+++ b/tests/hlsl/cbuffer.shader_test
@@ -471,8 +471,8 @@ float4 main() : sv_target
 }

-[texture 0]
-size (1, 1)
+[srv 0]
+size (2d, 1, 1)
 0.0 0.0 0.0 4.0

[sampler 0]
@@ -527,12 +527,12 @@ float4 main() : sv_target
 }

-[texture 0]
-size (1, 1)
+[srv 0]
+size (2d, 1, 1)
 1.0 1.0 1.0 1.0

-[texture 1]
-size (1, 1)
+[srv 1]
+size (2d, 1, 1)
 2.0 2.0 2.0 2.0

@@ -698,8 +698,8 @@ float4 main() : sv_target
 [require]
 shader model >= 5.0

-[texture 0]
-size (1, 1)
+[srv 0]
+size (2d, 1, 1)
 0.0 0.0 0.0 0.5

[pixel shader]
diff --git a/tests/hlsl/combined-samplers.shader_test b/tests/hlsl/combined-samplers.shader_test
index 235537594..91e1908e7 100644
--- a/tests/hlsl/combined-samplers.shader_test
+++ b/tests/hlsl/combined-samplers.shader_test
@@ -16,24 +16,24 @@ address clamp clamp clamp
 filter linear linear linear
 address clamp clamp clamp

-[texture 0]
-size (1, 1)
+[srv 0]
+size (2d, 1, 1)
 0.0 0.0 0.0 1.0

-[texture 1]
-size (1, 1)
+[srv 1]
+size (2d, 1, 1)
 1.0 1.0 1.0 1.0

-[texture 2]
-size (1, 1)
+[srv 2]
+size (2d, 1, 1)
 2.0 2.0 2.0 1.0

-[texture 3]
-size (1, 1)
+[srv 3]
+size (2d, 1, 1)
 3.0 3.0 3.0 1.0

-[texture 4]
-size (1, 1)
+[srv 4]
+size (2d, 1, 1)
 4.0 4.0 4.0 1.0

[pixel shader]
diff --git a/tests/hlsl/compute.shader_test b/tests/hlsl/compute.shader_test
index 2f2af9fc8..4f99221c2 100644
--- a/tests/hlsl/compute.shader_test
+++ b/tests/hlsl/compute.shader_test
@@ -3,7 +3,7 @@ shader model >= 5.0

[uav 0]
 format r32 float
-size (1, 1)
+size (2d, 1, 1)

0.1

diff --git a/tests/hlsl/gather-offset.shader_test b/tests/hlsl/gather-offset.shader_test
index 6360d1fc8..ce063c149 100644
--- a/tests/hlsl/gather-offset.shader_test
+++ b/tests/hlsl/gather-offset.shader_test
@@ -6,8 +6,8 @@ shader model >= 4.1
 filter linear linear linear
 address clamp clamp clamp

-[texture 0]
-size (3, 3)
+[srv 0]
+size (2d, 3, 3)
 0.0 0.0 0.0 0.4     0.1 0.0 0.5 0.0     0.2 0.0 0.0 0.4
 0.0 0.1 0.5 0.0     0.1 0.1 0.0 0.4     0.2 0.1 0.5 0.0
 0.0 0.2 0.0 0.4     0.1 0.2 0.5 0.0     0.2 0.2 0.0 0.4
diff --git a/tests/hlsl/gather.shader_test b/tests/hlsl/gather.shader_test
index 9cfc2d599..ab0824054 100644
--- a/tests/hlsl/gather.shader_test
+++ b/tests/hlsl/gather.shader_test
@@ -6,8 +6,8 @@ shader model >= 4.1
 filter linear linear linear
 address clamp clamp clamp

-[texture 0]
-size (3, 3)
+[srv 0]
+size (2d, 3, 3)
 0.0 0.0 0.0 0.4     0.1 0.0 0.5 0.0     0.2 0.0 0.0 0.4
 0.0 0.1 0.5 0.0     0.1 0.1 0.0 0.4     0.2 0.1 0.5 0.0
 0.0 0.2 0.0 0.4     0.1 0.2 0.5 0.0     0.2 0.2 0.0 0.4
diff --git a/tests/hlsl/getdimensions.shader_test b/tests/hlsl/getdimensions.shader_test
index 01d12f87a..0528d1419 100644
--- a/tests/hlsl/getdimensions.shader_test
+++ b/tests/hlsl/getdimensions.shader_test
@@ -1,8 +1,8 @@
 [require]
 shader model >= 4.0

-[texture 0]
-size (2, 3)
+[srv 0]
+size (2d, 2, 3)

1.0 0.0 1.0 0.0     1.0 0.0 1.0 0.0     1.0 0.0 1.0 0.0
 1.0 0.0 1.0 0.0     1.0 0.0 1.0 0.0     1.0 0.0 1.0 0.0
@@ -31,8 +31,8 @@ float4 main() : sv_target
 todo(sm>=6) draw quad
 probe all rgba (2.0, 3.0, 2.0, 3.0)

-[texture 1]
-size (2, 2)
+[srv 1]
+size (2d, 2, 2)
 levels 2

1.0 0.0 1.0 0.0     1.0 0.0 1.0 0.0
diff --git a/tests/hlsl/initializer-objects.shader_test b/tests/hlsl/initializer-objects.shader_test
index 514a7cebb..d839d82a4 100644
--- a/tests/hlsl/initializer-objects.shader_test
+++ b/tests/hlsl/initializer-objects.shader_test
@@ -1,14 +1,14 @@
 [require]
 shader model >= 4.0

-[texture 0]
-size (3, 3)
+[srv 0]
+size (2d, 3, 3)
 0.1 0.1 0.1 0.1     0.2 0.2 0.2 0.2     0.3 0.3 0.3 0.3
 0.4 0.4 0.4 0.4     0.5 0.5 0.5 0.5     0.6 0.6 0.6 0.6
 0.7 0.7 0.7 0.7     0.8 0.8 0.8 0.8     0.9 0.9 0.9 0.9

-[texture 1]
-size (2, 2)
+[srv 1]
+size (2d, 2, 2)
 0.1 0.1 0.1 0.0     0.2 0.2 0.2 0.0
 0.4 0.4 0.4 0.0     0.5 0.5 0.5 0.0

diff --git a/tests/hlsl/is-front-face.shader_test b/tests/hlsl/is-front-face.shader_test
index 162d4e634..2838c260f 100644
--- a/tests/hlsl/is-front-face.shader_test
+++ b/tests/hlsl/is-front-face.shader_test
@@ -4,7 +4,7 @@ shader model >= 4.0
 [input layout]
 0 r32g32 float sv_position

-[vertex buffer 0]
+[vb 0]
 -2.0 -2.0
  2.0 -2.0
 -2.0  2.0
@@ -25,7 +25,7 @@ float4 main(bool face : sv_isfrontface) : sv_target
 todo(sm>=6) draw triangle strip 4
 probe all rgba (0.0, 1.0, 0.0, 1.0)

-[vertex buffer 0]
+[vb 0]
 -2.0 -2.0
 -2.0  2.0
  2.0 -2.0
diff --git a/tests/hlsl/load-level.shader_test b/tests/hlsl/load-level.shader_test
index 9df2f01fb..de40d8e84 100644
--- a/tests/hlsl/load-level.shader_test
+++ b/tests/hlsl/load-level.shader_test
@@ -1,8 +1,8 @@
 [require]
 shader model >= 4.0

-[texture 0]
-size (2, 2)
+[srv 0]
+size (2d, 2, 2)
 levels 2

1.0 0.0 1.0 0.0     1.0 0.0 1.0 0.0
diff --git a/tests/hlsl/matrix-semantics.shader_test b/tests/hlsl/matrix-semantics.shader_test
index e19b6b48c..ec2d191b7 100644
--- a/tests/hlsl/matrix-semantics.shader_test
+++ b/tests/hlsl/matrix-semantics.shader_test
@@ -21,21 +21,21 @@ row_major float1x4 main() : sv_target
 draw quad
 probe all rgba (1.0, 2.0, 3.0, 4.0)

-[render target 0]
+[rtv 0]
 format r32 float
-size (640, 480)
+size (2d, 640, 480)

-[render target 1]
+[rtv 1]
 format r32 float
-size (640, 480)
+size (2d, 640, 480)

-[render target 2]
+[rtv 2]
 format r32 float
-size (640, 480)
+size (2d, 640, 480)

-[render target 3]
+[rtv 3]
 format r32 float
-size (640, 480)
+size (2d, 640, 480)

[pixel shader fail(sm>=6)]
 row_major float4x1 main() : sv_target
@@ -84,9 +84,9 @@ probe render target 1 all r (2.0)
 probe render target 2 all r (5.0)
 probe render target 3 all r (6.0)

-[render target 0]
+[rtv 0]
 format r32g32b32a32 float
-size (640, 480)
+size (2d, 640, 480)

[pixel shader fail(sm>=6)]
 void main(out row_major float1x4 x : sv_target0, out float1x2 y : sv_target1)
diff --git a/tests/hlsl/multiple-rt.shader_test b/tests/hlsl/multiple-rt.shader_test
index 59e4acbbe..85bfd269f 100644
--- a/tests/hlsl/multiple-rt.shader_test
+++ b/tests/hlsl/multiple-rt.shader_test
@@ -1,10 +1,10 @@
-[render target 0]
+[rtv 0]
 format r32g32b32a32 float
-size (640, 480)
+size (2d, 640, 480)

-[render target 1]
+[rtv 1]
 format r32g32b32a32 float
-size (640, 480)
+size (2d, 640, 480)

[pixel shader]
 void main(out float4 o0 : sv_target0, out float4 o1 : sv_target1)
diff --git a/tests/hlsl/nointerpolation.shader_test b/tests/hlsl/nointerpolation.shader_test
index a3c9edfd1..5fe4e9a33 100644
--- a/tests/hlsl/nointerpolation.shader_test
+++ b/tests/hlsl/nointerpolation.shader_test
@@ -4,7 +4,7 @@ shader model >= 4.0
 [input layout]
 0 r32g32b32a32 float texcoord

-[vertex buffer 0]
+[vb 0]
 0.0 1.0 0.0 1.0
 1.0 0.0 0.0 1.0
 0.0 0.0 1.0 1.0
diff --git a/tests/hlsl/numthreads.shader_test b/tests/hlsl/numthreads.shader_test
index fb11dc480..e8f7900bf 100644
--- a/tests/hlsl/numthreads.shader_test
+++ b/tests/hlsl/numthreads.shader_test
@@ -166,7 +166,7 @@ void main() { func(); }

[uav 0]
 format r32 float
-size (2, 2)
+size (2d, 2, 2)

1.0 1.0
 1.0 1.0
diff --git a/tests/hlsl/object-parameters.shader_test b/tests/hlsl/object-parameters.shader_test
index 0d279fb27..4a44a0c7e 100644
--- a/tests/hlsl/object-parameters.shader_test
+++ b/tests/hlsl/object-parameters.shader_test
@@ -48,33 +48,33 @@ float4 main(struct apple input, uniform float param) : sv_target
 }

-[texture 0]
-size (2, 2)
+[srv 0]
+size (2d, 2, 2)
 1.0 1.0 1.0 1.0     0.0 0.0 0.0 1.0
 1.0 1.0 1.0 1.0     0.0 0.0 0.0 1.0

-[texture 1]
-size (2, 2)
+[srv 1]
+size (2d, 2, 2)
 2.0 2.0 2.0 1.0     0.0 0.0 0.0 1.0
 2.0 2.0 2.0 1.0     0.0 0.0 0.0 1.0

-[texture 2]
-size (2, 2)
+[srv 2]
+size (2d, 2, 2)
 3.0 3.0 3.0 1.0     0.0 0.0 0.0 1.0
 3.0 3.0 3.0 1.0     0.0 0.0 0.0 1.0

-[texture 3]
-size (2, 2)
+[srv 3]
+size (2d, 2, 2)
 4.0 4.0 4.0 1.0     0.0 0.0 0.0 1.0
 4.0 4.0 4.0 1.0     0.0 0.0 0.0 1.0

-[texture 4]
-size (2, 2)
+[srv 4]
+size (2d, 2, 2)
 5.0 5.0 5.0 1.0     0.0 0.0 0.0 1.0
 5.0 5.0 5.0 1.0     0.0 0.0 0.0 1.0

-[texture 5]
-size (2, 2)
+[srv 5]
+size (2d, 2, 2)
 6.0 6.0 6.0 1.0     0.0 0.0 0.0 1.0
 6.0 6.0 6.0 1.0     0.0 0.0 0.0 1.0

diff --git a/tests/hlsl/object-references.shader_test b/tests/hlsl/object-references.shader_test
index c857f3885..6216d9557 100644
--- a/tests/hlsl/object-references.shader_test
+++ b/tests/hlsl/object-references.shader_test
@@ -14,12 +14,12 @@ float4 main() : sv_target
 shader model >= 4.0

-[texture 0]
-size (1, 1)
+[srv 0]
+size (2d, 1, 1)
 0.77 0.77 0.77 0.77

-[texture 1]
-size (1, 1)
+[srv 1]
+size (2d, 1, 1)
 0.64 0.64 0.64 0.64

[sampler 0]
@@ -50,8 +50,8 @@ todo(sm>=6) draw quad
 probe all rgba (77.77, 77.77, 77.77, 77.77)

-[texture 0]
-size (2, 2)
+[srv 0]
+size (2d, 2, 2)
 0.1 0.2 0.3 0.4     0.5 0.7 0.6 0.8
 0.6 0.5 0.2 0.1     0.8 0.0 0.7 1.0

@@ -80,16 +80,16 @@ probe (0, 1) rgba (0.6, 0.5, 0.2, 0.1)
 probe (1, 1) rgba (0.8, 0.0, 0.7, 1.0)

-[texture 0]
-size (1, 1)
+[srv 0]
+size (2d, 1, 1)
 1.0 1.0 1.0 1.0

-[texture 1]
-size (1, 1)
+[srv 1]
+size (2d, 1, 1)
 2.0 2.0 2.0 1.0

-[texture 2]
-size (1, 1)
+[srv 2]
+size (2d, 1, 1)
 3.0 3.0 3.0 1.0

[pixel shader]
@@ -219,8 +219,8 @@ float4 main(Texture2D tex2) : sv_target
 shader model >= 5.0

-[texture 0]
-size (1, 1)
+[srv 0]
+size (2d, 1, 1)
 1.0 2.0 3.0 4.0

[pixel shader todo fail(sm>=6)]
diff --git a/tests/hlsl/register-reservations.shader_test b/tests/hlsl/register-reservations.shader_test
index 9539b05ff..0c593d11b 100644
--- a/tests/hlsl/register-reservations.shader_test
+++ b/tests/hlsl/register-reservations.shader_test
@@ -2,24 +2,24 @@
 shader model >= 4.0

-[texture 0]
-size (1, 1)
+[srv 0]
+size (2d, 1, 1)
 0.0 0.0 0.0 99.0

-[texture 1]
-size (1, 1)
+[srv 1]
+size (2d, 1, 1)
 1.0 1.0 1.0 99.0

-[texture 2]
-size (1, 1)
+[srv 2]
+size (2d, 1, 1)
 2.0 2.0 2.0 99.0

-[texture 3]
-size (1, 1)
+[srv 3]
+size (2d, 1, 1)
 3.0 3.0 3.0 99.0

-[texture 4]
-size (1, 1)
+[srv 4]
+size (2d, 1, 1)
 4.0 4.0 4.0 99.0

@@ -161,15 +161,15 @@ probe all rgba (2.0, 2.0, 2.0, 99.0)
 [require]
 shader model >= 5.0

-[texture 0]
-size (2, 2)
+[srv 0]
+size (2d, 2, 2)
 0.0 0.0 0.0 99.0
 0.0 0.0 0.0 99.0
 0.0 0.0 0.0 99.0
 0.0 0.0 0.0 99.0

-[texture 1]
-size (2, 2)
+[srv 1]
+size (2d, 2, 2)
 1.0 1.0 1.0 99.0
 1.0 1.0 1.0 99.0
 0.0 0.0 0.0 99.0
diff --git a/tests/hlsl/sample-bias.shader_test b/tests/hlsl/sample-bias.shader_test
index 5b7067b52..cb956c6ae 100644
--- a/tests/hlsl/sample-bias.shader_test
+++ b/tests/hlsl/sample-bias.shader_test
@@ -2,8 +2,8 @@
 filter linear linear linear
 address clamp clamp clamp

-[texture 0]
-size (2, 2)
+[srv 0]
+size (2d, 2, 2)
 levels 2

1.0 0.0 1.0 0.0     1.0 0.0 1.0 0.0
diff --git a/tests/hlsl/sample-grad.shader_test b/tests/hlsl/sample-grad.shader_test
index 298037a77..00953c55f 100644
--- a/tests/hlsl/sample-grad.shader_test
+++ b/tests/hlsl/sample-grad.shader_test
@@ -5,8 +5,8 @@ shader model >= 4.0
 filter linear linear linear
 address clamp clamp clamp

-[texture 0]
-size (2, 2)
+[srv 0]
+size (2d, 2, 2)
 levels 2

1.0 0.0 1.0 0.0     1.0 0.0 1.0 0.0
diff --git a/tests/hlsl/sample-level.shader_test b/tests/hlsl/sample-level.shader_test
index 8b2890ff7..337d6a6da 100644
--- a/tests/hlsl/sample-level.shader_test
+++ b/tests/hlsl/sample-level.shader_test
@@ -5,8 +5,8 @@ shader model >= 3.0
 filter linear linear linear
 address clamp clamp clamp

-[texture 0]
-size (2, 2)
+[srv 0]
+size (2d, 2, 2)
 levels 2

1.0 0.0 1.0 0.0     1.0 0.0 1.0 0.0
diff --git a/tests/hlsl/sampler-offset.shader_test b/tests/hlsl/sampler-offset.shader_test
index 498a8ed3a..f569d8805 100644
--- a/tests/hlsl/sampler-offset.shader_test
+++ b/tests/hlsl/sampler-offset.shader_test
@@ -5,8 +5,8 @@ shader model >= 4.0
 filter point point point
 address clamp clamp clamp

-[texture 0]
-size (3, 3)
+[srv 0]
+size (2d, 3, 3)
 0.0 0.0 0.0 0.4     0.1 0.0 0.5 0.0     0.2 0.0 0.0 0.4
 0.0 0.1 0.5 0.0     0.1 0.1 0.0 0.4     0.2 0.1 0.5 0.0
 0.0 0.2 0.0 0.4     0.1 0.2 0.5 0.0     0.2 0.2 0.0 0.4
diff --git a/tests/hlsl/sampler.shader_test b/tests/hlsl/sampler.shader_test
index caff7b2fa..2b0b02f4f 100644
--- a/tests/hlsl/sampler.shader_test
+++ b/tests/hlsl/sampler.shader_test
@@ -2,8 +2,8 @@
 filter linear linear linear
 address clamp clamp clamp

-[texture 0]
-size (2, 2)
+[srv 0]
+size (2d, 2, 2)
 0.0 0.0 0.0 0.0     0.0 0.0 0.0 0.0
 0.0 0.0 0.0 0.0     1.0 0.0 1.0 0.0

diff --git a/tests/hlsl/shader-interstage-interface.shader_test b/tests/hlsl/shader-interstage-interface.shader_test
index 584b88cf9..ea0cbb979 100644
--- a/tests/hlsl/shader-interstage-interface.shader_test
+++ b/tests/hlsl/shader-interstage-interface.shader_test
@@ -9,13 +9,13 @@ shader model >= 4.0
 1 r32 uint TEXCOORD 3
 0 r32 float TEXCOORD 4

-[vertex buffer 0]
+[vb 0]
 -1.0 -1.0   3.0 5.0   5.0   7.0
 -1.0  1.0   3.0 5.0   5.0   7.0
  1.0 -1.0   3.0 5.0   5.0   7.0
  1.0  1.0   3.0 5.0   5.0   7.0

-[vertex buffer 1]
+[vb 1]
 format r32 uint
 2   6
 2   6
diff --git a/tests/hlsl/srv-buffers.shader_test b/tests/hlsl/srv-buffers.shader_test
index 5b7443cc4..c43e47592 100644
--- a/tests/hlsl/srv-buffers.shader_test
+++ b/tests/hlsl/srv-buffers.shader_test
@@ -2,8 +2,8 @@
 shader model >= 4.0

-[buffer srv 0]
-size (1, 4)
+[srv 0]
+size (buffer, 4)

0.0 1.0 2.0 3.0
 4.0 5.0 6.0 7.0
@@ -45,16 +45,16 @@ todo(sm>=6) draw quad
 probe all rgba (4000.0, 8.0, 9.0, 10.0)

-[texture 0]
-size (1, 1)
+[srv 0]
+size (2d, 1, 1)
 -1.0 -1.0 -1.0 -1.0

[sampler 0]
 filter linear linear linear
 address clamp clamp clamp

-[buffer srv 1]
-size (1, 1)
+[srv 1]
+size (buffer, 1)
 1.0 2.0 3.0 4.0

[pixel shader]
diff --git a/tests/hlsl/static-initializer.shader_test b/tests/hlsl/static-initializer.shader_test
index 217444308..d505b651d 100644
--- a/tests/hlsl/static-initializer.shader_test
+++ b/tests/hlsl/static-initializer.shader_test
@@ -60,8 +60,8 @@ filter linear linear linear
 address clamp clamp clamp

-[texture 0]
-size (1, 1)
+[srv 0]
+size (2d, 1, 1)
 1.0 2.0 3.0 4.0

@@ -172,7 +172,7 @@ shader model >= 5.0

[uav 1]
 format r32 float
-size (1, 1)
+size (2d, 1, 1)

0.5

diff --git a/tests/hlsl/struct-semantics.shader_test b/tests/hlsl/struct-semantics.shader_test
index c88006eb8..a23f490db 100644
--- a/tests/hlsl/struct-semantics.shader_test
+++ b/tests/hlsl/struct-semantics.shader_test
@@ -2,7 +2,7 @@
 0 r32g32b32a32 float texcoord
 0 r32g32 float position

-[vertex buffer 0]
+[vb 0]
 0.0 1.0 0.0 1.0   -2.0 -2.0
 0.0 1.0 0.0 1.0   -2.0  2.0
 0.0 1.0 0.0 1.0    2.0 -2.0
diff --git a/tests/hlsl/swizzle-constant-prop.shader_test b/tests/hlsl/swizzle-constant-prop.shader_test
index a0ec18e45..f40cc4901 100644
--- a/tests/hlsl/swizzle-constant-prop.shader_test
+++ b/tests/hlsl/swizzle-constant-prop.shader_test
@@ -5,8 +5,8 @@
 shader model >= 4.0

-[texture 0]
-size (4, 4)
+[srv 0]
+size (2d, 4, 4)
  1  1  1  1    2  2  2  2    3  3  3  3    4  4  4  4
  5  5  5  5    6  6  6  6    7  7  7  7    8  8  8  8
  9  9  9  9   10 10 10 10   11 11 11 11   12 12 12 12
diff --git a/tests/hlsl/texture-load-offset.shader_test b/tests/hlsl/texture-load-offset.shader_test
index f32b2191f..41e6d22ca 100644
--- a/tests/hlsl/texture-load-offset.shader_test
+++ b/tests/hlsl/texture-load-offset.shader_test
@@ -1,8 +1,8 @@
 [require]
 shader model >= 4.0

-[texture 0]
-size (3, 3)
+[srv 0]
+size (2d, 3, 3)
 0 0 0 1     1 0 0 1     2 0 0 1
 0 1 0 1     1 1 0 1     2 1 0 1
 0 2 0 1     1 2 0 1     2 2 0 1
diff --git a/tests/hlsl/texture-load-typed.shader_test b/tests/hlsl/texture-load-typed.shader_test
index 67a13f10d..24a735ab5 100644
--- a/tests/hlsl/texture-load-typed.shader_test
+++ b/tests/hlsl/texture-load-typed.shader_test
@@ -18,21 +18,21 @@ float4 main() : sv_target
     return float4(0, 0, 0, 0);
 }

-[texture 0]
+[srv 0]
 format r32 float
-size (1, 1)
+size (2d, 1, 1)

0.8

-[texture 1]
+[srv 1]
 format r32 sint
-size (1, 1)
+size (2d, 1, 1)

-3

-[texture 2]
+[srv 2]
 format r32g32 uint
-size (1, 1)
+size (2d, 1, 1)

4294967295 123

diff --git a/tests/hlsl/texture-load.shader_test b/tests/hlsl/texture-load.shader_test
index 30a33a4a4..3b7260825 100644
--- a/tests/hlsl/texture-load.shader_test
+++ b/tests/hlsl/texture-load.shader_test
@@ -1,8 +1,8 @@
 [require]
 shader model >= 4.0

-[texture 0]
-size (2, 2)
+[srv 0]
+size (2d, 2, 2)
 0.1 0.2 0.3 0.4     0.5 0.7 0.6 0.8
 0.6 0.5 0.2 0.1     0.8 0.0 0.7 1.0

diff --git a/tests/hlsl/texture-ordering.shader_test b/tests/hlsl/texture-ordering.shader_test
index 24cd986ca..25819e658 100644
--- a/tests/hlsl/texture-ordering.shader_test
+++ b/tests/hlsl/texture-ordering.shader_test
@@ -30,44 +30,44 @@ address clamp clamp clamp
 filter linear linear linear
 address clamp clamp clamp

-[texture 0]
-size (1, 1)
+[srv 0]
+size (2d, 1, 1)
 0.0 0.0 0.0 1.0

-[texture 1]
-size (1, 1)
+[srv 1]
+size (2d, 1, 1)
 1.0 1.0 1.0 1.0

-[texture 2]
-size (1, 1)
+[srv 2]
+size (2d, 1, 1)
 2.0 2.0 2.0 1.0

-[texture 3]
-size (1, 1)
+[srv 3]
+size (2d, 1, 1)
 3.0 3.0 3.0 1.0

-[texture 4]
-size (1, 1)
+[srv 4]
+size (2d, 1, 1)
 4.0 4.0 4.0 1.0

-[texture 5]
-size (1, 1)
+[srv 5]
+size (2d, 1, 1)
 5.0 5.0 5.0 1.0

-[texture 6]
-size (1, 1)
+[srv 6]
+size (2d, 1, 1)
 6.0 6.0 6.0 1.0

-[texture 7]
-size (1, 1)
+[srv 7]
+size (2d, 1, 1)
 7.0 7.0 7.0 1.0

-[texture 8]
-size (1, 1)
+[srv 8]
+size (2d, 1, 1)
 8.0 8.0 8.0 1.0

-[texture 9]
-size (1, 1)
+[srv 9]
+size (2d, 1, 1)
 9.0 9.0 9.0 1.0

diff --git a/tests/hlsl/uav-load.shader_test b/tests/hlsl/uav-load.shader_test
index 9088ffa0d..2b3e542b6 100644
--- a/tests/hlsl/uav-load.shader_test
+++ b/tests/hlsl/uav-load.shader_test
@@ -3,13 +3,13 @@ shader model >= 5.0

[uav 0]
 format r32 float
-size (3, 1)
+size (2d, 3, 1)

0.1 0.2 0.3

[uav 1]
 format r32 float
-size (1, 1)
+size (2d, 1, 1)

0.5

diff --git a/tests/hlsl/uav-out-param.shader_test b/tests/hlsl/uav-out-param.shader_test
index 796c4bf1f..5be5fffb3 100644
--- a/tests/hlsl/uav-out-param.shader_test
+++ b/tests/hlsl/uav-out-param.shader_test
@@ -3,7 +3,7 @@ shader model >= 5.0

[uav 0]
 format r32g32b32a32 float
-size (1, 1)
+size (2d, 1, 1)

0.1 0.2 0.3 0.4

@@ -31,7 +31,7 @@ probe uav 0 (0, 0) rgba (0.4, 0.1, 0.2, 0.3)

[uav 0]
 format r32 float
-size (1, 1)
+size (2d, 1, 1)

0.1

diff --git a/tests/hlsl/uav-rwbuffer.shader_test b/tests/hlsl/uav-rwbuffer.shader_test
index b476c7854..1a236e998 100644
--- a/tests/hlsl/uav-rwbuffer.shader_test
+++ b/tests/hlsl/uav-rwbuffer.shader_test
@@ -6,9 +6,9 @@ shader model >= 5.0
 % lower than the highest render target.
 % This ceases to be true with shader model 5.1.

-[render target 1]
+[rtv 1]
 format r32g32b32a32 float
-size (640, 480)
+size (2d, 640, 480)

[pixel shader]
 struct s
@@ -88,8 +88,8 @@ float4 main() : sv_target1
     return 0;
 }

-[buffer uav 2]
-size (1, 1)
+[uav 2]
+size (buffer, 1)

0.1 0.2 0.3 0.4

diff --git a/tests/hlsl/uav-rwtexture.shader_test b/tests/hlsl/uav-rwtexture.shader_test
index 76535bd59..9eda4e046 100644
--- a/tests/hlsl/uav-rwtexture.shader_test
+++ b/tests/hlsl/uav-rwtexture.shader_test
@@ -25,13 +25,13 @@ float4 main() : sv_target

[uav 1]
 format r32 float
-size (2, 2)
+size (2d, 2, 2)

0.1 0.2
 0.3 0.4

[uav 2]
-size (1, 1)
+size (2d, 1, 1)

0.5 0.6 0.7 0.8

@@ -62,12 +62,12 @@ probe uav 2 (0, 0) rgba (2.0, 1.0, 4.0, 3.0)
 % lower than the highest render target.
 % This ceases to be true with shader model 5.1.

-[render target 1]
+[rtv 1]
 format r32g32b32a32 float
-size (640, 480)
+size (2d, 640, 480)

[uav 2]
-size (1, 1)
+size (2d, 1, 1)

0.1 0.2 0.3 0.4

@@ -104,7 +104,7 @@ probe uav 2 (0, 0) rgba (0.9, 0.8, 0.7, 0.6)

[uav 3]
-size (1, 1)
+size (2d, 1, 1)

0.1 0.2 0.3 0.4

@@ -138,12 +138,12 @@ probe uav 3 (0, 0) rgba (0.9, 0.8, 0.7, 0.6)
 % Test that we can declare and use an array of UAVs.

[uav 2]
-size (1, 1)
+size (2d, 1, 1)

0.1 0.2 0.3 0.4

[uav 3]
-size (1, 1)
+size (2d, 1, 1)

0.5 0.6 0.7 0.8

diff --git a/tests/shader_runner.c b/tests/shader_runner.c
index a814ffd6e..25bfa643d 100644
--- a/tests/shader_runner.c
+++ b/tests/shader_runner.c
@@ -304,17 +304,25 @@ static void parse_sampler_directive(struct sampler *sampler, const char *line)

static void parse_resource_directive(struct resource_params *resource, const char *line)
 {
-    int ret;
-
     if (match_string(line, "format", &line))
     {
         resource->format = parse_format(line, &resource->data_type, &resource->texel_size, &line);
     }
     else if (match_string(line, "size", &line))
     {
-        ret = sscanf(line, "( %u , %u )", &resource->width, &resource->height);
-        if (ret < 2)
-            fatal_error("Malformed texture size '%s'.\n", line);
+        if (sscanf(line, "( buffer , %u ) ", &resource->width) == 1)
+        {
+            resource->dimension = RESOURCE_DIMENSION_BUFFER;
+            resource->height = 1;
+        }
+        else if (sscanf(line, "( 2d , %u , %u ) ", &resource->width, &resource->height) == 2)
+        {
+            resource->dimension = RESOURCE_DIMENSION_2D;
+        }
+        else
+        {
+            fatal_error("Malformed resource size '%s'.\n", line);
+        }
     }
     else if (match_string(line, "levels", &line))
     {
@@ -1358,7 +1366,7 @@ void run_shader_tests(struct shader_runner *runner, const struct shader_runner_o
                 current_sampler->v_address = D3D12_TEXTURE_ADDRESS_MODE_CLAMP;
                 current_sampler->w_address = D3D12_TEXTURE_ADDRESS_MODE_CLAMP;
             }
-            else if (sscanf(line, "[render target %u]\n", &index))
+            else if (sscanf(line, "[rtv %u]\n", &index))
             {
                 state = STATE_RESOURCE;

@@ -1366,13 +1374,12 @@ void run_shader_tests(struct shader_runner *runner, const struct shader_runner_o

current_resource.slot = index;
                 current_resource.type = RESOURCE_TYPE_RENDER_TARGET;
-                current_resource.dimension = RESOURCE_DIMENSION_2D;
                 current_resource.format = DXGI_FORMAT_R32G32B32A32_FLOAT;
                 current_resource.data_type = TEXTURE_DATA_FLOAT;
                 current_resource.texel_size = 16;
                 current_resource.level_count = 1;
             }
-            else if (sscanf(line, "[texture %u]\n", &index))
+            else if (sscanf(line, "[srv %u]\n", &index))
             {
                 state = STATE_RESOURCE;

@@ -1380,7 +1387,6 @@ void run_shader_tests(struct shader_runner *runner, const struct shader_runner_o

current_resource.slot = index;
                 current_resource.type = RESOURCE_TYPE_TEXTURE;
-                current_resource.dimension = RESOURCE_DIMENSION_2D;
                 current_resource.format = DXGI_FORMAT_R32G32B32A32_FLOAT;
                 current_resource.data_type = TEXTURE_DATA_FLOAT;
                 current_resource.texel_size = 16;
@@ -1394,41 +1400,12 @@ void run_shader_tests(struct shader_runner *runner, const struct shader_runner_o

current_resource.slot = index;
                 current_resource.type = RESOURCE_TYPE_UAV;
-                current_resource.dimension = RESOURCE_DIMENSION_2D;
-                current_resource.format = DXGI_FORMAT_R32G32B32A32_FLOAT;
-                current_resource.data_type = TEXTURE_DATA_FLOAT;
-                current_resource.texel_size = 16;
-                current_resource.level_count = 1;
-            }
-            else if (sscanf(line, "[buffer srv %u]\n", &index))
-            {
-                state = STATE_RESOURCE;
-
-                memset(&current_resource, 0, sizeof(current_resource));
-
-                current_resource.slot = index;
-                current_resource.type = RESOURCE_TYPE_TEXTURE;
-                current_resource.dimension = RESOURCE_DIMENSION_BUFFER;
-                current_resource.format = DXGI_FORMAT_R32G32B32A32_FLOAT;
-                current_resource.data_type = TEXTURE_DATA_FLOAT;
-                current_resource.texel_size = 16;
-                current_resource.level_count = 1;
-            }
-            else if (sscanf(line, "[buffer uav %u]\n", &index))
-            {
-                state = STATE_RESOURCE;
-
-                memset(&current_resource, 0, sizeof(current_resource));
-
-                current_resource.slot = index;
-                current_resource.type = RESOURCE_TYPE_UAV;
-                current_resource.dimension = RESOURCE_DIMENSION_BUFFER;
                 current_resource.format = DXGI_FORMAT_R32G32B32A32_FLOAT;
                 current_resource.data_type = TEXTURE_DATA_FLOAT;
                 current_resource.texel_size = 16;
                 current_resource.level_count = 1;
             }
-            else if (sscanf(line, "[vertex buffer %u]\n", &index))
+            else if (sscanf(line, "[vb %u]\n", &index))
             {
                 state = STATE_RESOURCE;

[PATCH v4 5/5] tests/shader-runner: Change probe directive syntax on shader_test files.

[Francisco Casas]

From: Francisco Casas

For consistency with the previous commit.
---
 tests/hlsl/matrix-semantics.shader_test | 30 ++++++++++++-------------
 tests/hlsl/multiple-rt.shader_test      |  4 ++--
 tests/hlsl/uav-rwbuffer.shader_test     |  2 +-
 tests/shader_runner.c                   | 17 +++++---------
 4 files changed, 24 insertions(+), 29 deletions(-)

diff --git a/tests/hlsl/matrix-semantics.shader_test b/tests/hlsl/matrix-semantics.shader_test
index ec2d191b7..476b56bf1 100644
--- a/tests/hlsl/matrix-semantics.shader_test
+++ b/tests/hlsl/matrix-semantics.shader_test
@@ -45,10 +45,10 @@ row_major float4x1 main() : sv_target

[test]
 todo(sm>=6) draw quad
-probe render target 0 all r (1.0)
-probe render target 1 all r (2.0)
-probe render target 2 all r (3.0)
-probe render target 3 all r (4.0)
+probe rtv 0 all r (1.0)
+probe rtv 1 all r (2.0)
+probe rtv 2 all r (3.0)
+probe rtv 3 all r (4.0)

[pixel shader fail(sm>=6)]
 float1x4 main() : sv_target
@@ -58,10 +58,10 @@ float1x4 main() : sv_target

[test]
 todo(sm>=6) draw quad
-probe render target 0 all r (1.0)
-probe render target 1 all r (2.0)
-probe render target 2 all r (3.0)
-probe render target 3 all r (4.0)
+probe rtv 0 all r (1.0)
+probe rtv 1 all r (2.0)
+probe rtv 2 all r (3.0)
+probe rtv 3 all r (4.0)

[pixel shader fail]
 void main(out float1x2 x : sv_target0, out float1x2 y : sv_target1)
@@ -79,10 +79,10 @@ void main(out float1x2 x : sv_target0, out float1x2 y : sv_target2)

[test]
 todo(sm>=6) draw quad
-probe render target 0 all r (1.0)
-probe render target 1 all r (2.0)
-probe render target 2 all r (5.0)
-probe render target 3 all r (6.0)
+probe rtv 0 all r (1.0)
+probe rtv 1 all r (2.0)
+probe rtv 2 all r (5.0)
+probe rtv 3 all r (6.0)

[rtv 0]
 format r32g32b32a32 float
@@ -97,6 +97,6 @@ void main(out row_major float1x4 x : sv_target0, out float1x2 y : sv_target1)

[test]
 todo(sm>=6) draw quad
-probe render target 0 all rgba (1.0, 2.0, 3.0, 4.0)
-probe render target 1 all r (5.0)
-probe render target 2 all r (6.0)
+probe rtv 0 all rgba (1.0, 2.0, 3.0, 4.0)
+probe rtv 1 all r (5.0)
+probe rtv 2 all r (6.0)
diff --git a/tests/hlsl/multiple-rt.shader_test b/tests/hlsl/multiple-rt.shader_test
index 85bfd269f..23c661b33 100644
--- a/tests/hlsl/multiple-rt.shader_test
+++ b/tests/hlsl/multiple-rt.shader_test
@@ -15,5 +15,5 @@ void main(out float4 o0 : sv_target0, out float4 o1 : sv_target1)

[test]
 draw quad
-probe render target 0 all rgba (0.1, 0.2, 0.3, 0.4)
-probe render target 1 all rgba (0.5, 0.6, 0.7, 0.8)
+probe rtv 0 all rgba (0.1, 0.2, 0.3, 0.4)
+probe rtv 1 all rgba (0.5, 0.6, 0.7, 0.8)
diff --git a/tests/hlsl/uav-rwbuffer.shader_test b/tests/hlsl/uav-rwbuffer.shader_test
index 1a236e998..394e32842 100644
--- a/tests/hlsl/uav-rwbuffer.shader_test
+++ b/tests/hlsl/uav-rwbuffer.shader_test
@@ -104,4 +104,4 @@ float4 main() : sv_target1

[test]
 todo(sm>=6) draw quad
-probe buffer uav 2 (0, 0) rgba (11.1, 12.2, 13.3, 14.4)
+probe uav 2 (0) rgba (11.1, 12.2, 13.3, 14.4)
diff --git a/tests/shader_runner.c b/tests/shader_runner.c
index 25bfa643d..e84eb4d07 100644
--- a/tests/shader_runner.c
+++ b/tests/shader_runner.c
@@ -689,17 +689,7 @@ static void parse_test_directive(struct shader_runner *runner, const char *line)

resource = shader_runner_get_resource(runner, RESOURCE_TYPE_UAV, slot);
         }
-        else if (match_string(line, "buffer uav", &line))
-        {
-            slot = strtoul(line, &rest, 10);
-
-            if (rest == line)
-                fatal_error("Malformed buffer UAV index '%s'.\n", line);
-            line = rest;
-
-            resource = shader_runner_get_resource(runner, RESOURCE_TYPE_UAV, slot);
-        }
-        else if (match_string(line, "render target", &line))
+        else if (match_string(line, "rtv", &line))
         {
             slot = strtoul(line, &rest, 10);

@@ -730,6 +720,11 @@ static void parse_test_directive(struct shader_runner *runner, const char *line)
             set_rect(&rect, left, top, left + 1, top + 1);
             line += len;
         }
+        else if (sscanf(line, " ( %u )%n", &left, &len) == 1)
+        {
+            set_rect(&rect, left, 0, left + 1, 1);
+            line += len;
+        }
         else
         {
             fatal_error("Malformed probe arguments '%s'.\n", line);

[Francisco Casas (＠fcasas)]

> Broadly, I like it better than the alternative. I do notice you're checking for RESOURCE_DIMENSION_2D in a number of places, and that's likely a mistake. In general, buffer resources are the special case, and e.g. 2D, 2D-array, and 3D textures can all be handled by the same code.

Makes sense, I modified the proposal so that the check for RESOURCE_DIMENSION_BUFFER goes first and the other cases go in the `else`.
> I think we should also adjust the .shader_test syntax. Instead of [...]

I implemented the suggested syntax in 4/5 and also changed the "probe" syntax in 5/5 for consistency.

[Giovanni Mascellani (＠giomasce)]

Giovanni Mascellani (@giomasce) commented about libs/vkd3d-shader/hlsl.y:
>      }
>
> texture_type:
> -
>  KW_TEXTURE1D
> -
>  KW_BUFFER
> -
>    {
> -
>        $$ = HLSL_SAMPLER_DIM_BUFFER;
> -
>    }

Unless I'm missing something, this means that it is not possible to, say, call `Sample()` on a buffer, which I'm not sure it's right. Could you please add a few tests checking that the various places in which we accept `HLSL_TYPE_TEXTURE` types also make sense with buffers? It might be the occasion to convert `add_*_method_call()` to a positive logic rather than the current negative logic that some of those functions have.

[Giovanni Mascellani (＠giomasce)]

Giovanni Mascellani (@giomasce) commented about tests/shader_runner_vulkan.c:
>          case RESOURCE_TYPE_UAV:
>              if (resource->r.dimension == RESOURCE_DIMENSION_BUFFER)
>              {
> -
>                assert(resource->r.type == RESOURCE_TYPE_UAV);
>                write.dstSet = descriptor_set;
>                write.dstBinding = resource->binding;
>                write.dstArrayElement = 0;
>                write.descriptorCount = 1;
> -
>                write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
> -
>                write.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
>                write.pTexelBufferView = &resource->buffer_view;
>
> -
>                if (resource->r.type == RESOURCE_TYPE_UAV)
> -
>                    write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;

Nitpick, but this looks better to me:
```c
if (resource->r.type == RESOURCE_TYPE_UAV)
    write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
else
    write.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
```