[PATCH v6 0/6] 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.

--
  v6: vkd3d-shader/hlsl: Parse Buffer types.
      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.
      vkd3d-shader/hlsl: Use positive logic on add_*_method_call() functions.

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

[PATCH v6 1/6] vkd3d-shader/hlsl: Use positive logic on add_*_method_call() functions.

[Francisco Casas]

From: Francisco Casas

So we have to explicitily enumerate the sampler dimensions that don't
call raise_invalid_method_object_type().

Also, call hlsl_sampler_dim_count() and hlsl_offset_dim_count() after
type checking, to avoid reaching unreacheable cases.
---
 libs/vkd3d-shader/hlsl.y | 92 +++++++++++++++++++++++++++++-----------
 1 file changed, 68 insertions(+), 24 deletions(-)

diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y
index 5f6334a4d..8b4754bbf 100644
--- a/libs/vkd3d-shader/hlsl.y
+++ b/libs/vkd3d-shader/hlsl.y
@@ -4252,18 +4252,25 @@ static bool add_load_method_call(struct hlsl_ctx *ctx, struct hlsl_block *block,
         const char *name, const struct parse_initializer *params, const struct vkd3d_shader_location *loc)
 {
     const struct hlsl_type *object_type = object->data_type;
-    const unsigned int sampler_dim = hlsl_sampler_dim_count(object_type->sampler_dim);
-    const unsigned int offset_dim = hlsl_offset_dim_count(object_type->sampler_dim);
     struct hlsl_resource_load_params load_params = {.type = HLSL_RESOURCE_LOAD};
+    unsigned int sampler_dim, offset_dim;
     struct hlsl_ir_node *load;
     bool multisampled;

-    if (object_type->sampler_dim == HLSL_SAMPLER_DIM_CUBE
-            || object_type->sampler_dim == HLSL_SAMPLER_DIM_CUBEARRAY)
+    if (object_type->sampler_dim != HLSL_SAMPLER_DIM_1D
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_2D
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_3D
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_1DARRAY
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_2DARRAY
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_2DMS
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_2DMSARRAY)
     {
         return raise_invalid_method_object_type(ctx, object_type, name, loc);
     }

+    sampler_dim = hlsl_sampler_dim_count(object_type->sampler_dim);
+    offset_dim = hlsl_offset_dim_count(object_type->sampler_dim);
+
     multisampled = object_type->sampler_dim == HLSL_SAMPLER_DIM_2DMS
             || object_type->sampler_dim == HLSL_SAMPLER_DIM_2DMSARRAY;

@@ -4311,18 +4318,25 @@ static bool add_sample_method_call(struct hlsl_ctx *ctx, struct hlsl_block *bloc
         const char *name, const struct parse_initializer *params, const struct vkd3d_shader_location *loc)
 {
     const struct hlsl_type *object_type = object->data_type;
-    const unsigned int sampler_dim = hlsl_sampler_dim_count(object_type->sampler_dim);
-    const unsigned int offset_dim = hlsl_offset_dim_count(object_type->sampler_dim);
     struct hlsl_resource_load_params load_params = {.type = HLSL_RESOURCE_SAMPLE};
+    unsigned int sampler_dim, offset_dim;
     const struct hlsl_type *sampler_type;
     struct hlsl_ir_node *load;

-    if (object_type->sampler_dim == HLSL_SAMPLER_DIM_2DMS
-            || object_type->sampler_dim == HLSL_SAMPLER_DIM_2DMSARRAY)
+    if (object_type->sampler_dim != HLSL_SAMPLER_DIM_1D
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_2D
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_3D
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_CUBE
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_1DARRAY
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_2DARRAY
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_CUBEARRAY)
     {
         return raise_invalid_method_object_type(ctx, object_type, name, loc);
     }

+    sampler_dim = hlsl_sampler_dim_count(object_type->sampler_dim);
+    offset_dim = hlsl_offset_dim_count(object_type->sampler_dim);
+
     if (params->args_count < 2 || params->args_count > 4 + !!offset_dim)
     {
         hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_WRONG_PARAMETER_COUNT,
@@ -4375,18 +4389,25 @@ static bool add_sample_cmp_method_call(struct hlsl_ctx *ctx, struct hlsl_block *
         const char *name, const struct parse_initializer *params, const struct vkd3d_shader_location *loc)
 {
     const struct hlsl_type *object_type = object->data_type;
-    const unsigned int sampler_dim = hlsl_sampler_dim_count(object_type->sampler_dim);
-    const unsigned int offset_dim = hlsl_offset_dim_count(object_type->sampler_dim);
     struct hlsl_resource_load_params load_params = { 0 };
+    unsigned int sampler_dim, offset_dim;
     const struct hlsl_type *sampler_type;
     struct hlsl_ir_node *load;

-    if (object_type->sampler_dim == HLSL_SAMPLER_DIM_2DMS
-            || object_type->sampler_dim == HLSL_SAMPLER_DIM_2DMSARRAY)
+    if (object_type->sampler_dim != HLSL_SAMPLER_DIM_1D
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_2D
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_3D
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_CUBE
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_1DARRAY
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_2DARRAY
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_CUBEARRAY)
     {
         return raise_invalid_method_object_type(ctx, object_type, name, loc);
     }

+    sampler_dim = hlsl_sampler_dim_count(object_type->sampler_dim);
+    offset_dim = hlsl_offset_dim_count(object_type->sampler_dim);
+
     if (!strcmp(name, "SampleCmpLevelZero"))
         load_params.type = HLSL_RESOURCE_SAMPLE_CMP_LZ;
     else
@@ -4449,13 +4470,11 @@ static bool add_gather_method_call(struct hlsl_ctx *ctx, struct hlsl_block *bloc
         const char *name, const struct parse_initializer *params, const struct vkd3d_shader_location *loc)
 {
     const struct hlsl_type *object_type = object->data_type;
-    const unsigned int sampler_dim = hlsl_sampler_dim_count(object_type->sampler_dim);
-    const unsigned int offset_dim = hlsl_offset_dim_count(object_type->sampler_dim);
     struct hlsl_resource_load_params load_params = {0};
+    unsigned int sampler_dim, offset_dim;
     const struct hlsl_type *sampler_type;
     struct hlsl_ir_node *load;
     unsigned int read_channel;
-
     if (object_type->sampler_dim != HLSL_SAMPLER_DIM_2D
             && object_type->sampler_dim != HLSL_SAMPLER_DIM_2DARRAY
             && object_type->sampler_dim != HLSL_SAMPLER_DIM_CUBE
@@ -4464,6 +4483,9 @@ static bool add_gather_method_call(struct hlsl_ctx *ctx, struct hlsl_block *bloc
         return raise_invalid_method_object_type(ctx, object_type, name, loc);
     }

+    sampler_dim = hlsl_sampler_dim_count(object_type->sampler_dim);
+    offset_dim = hlsl_offset_dim_count(object_type->sampler_dim);
+
     if (!strcmp(name, "GatherGreen"))
     {
         load_params.type = HLSL_RESOURCE_GATHER_GREEN;
@@ -4616,7 +4638,15 @@ static bool add_getdimensions_method_call(struct hlsl_ctx *ctx, struct hlsl_bloc
     };
     const struct overload *o = NULL;

-    if (object_type->sampler_dim > HLSL_SAMPLER_DIM_LAST_TEXTURE)
+    if (object_type->sampler_dim != HLSL_SAMPLER_DIM_1D
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_2D
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_3D
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_CUBE
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_1DARRAY
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_2DARRAY
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_2DMS
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_2DMSARRAY
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_CUBEARRAY)
     {
         hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE, "GetDimensions() is not defined for this type.");
     }
@@ -4732,17 +4762,24 @@ static bool add_sample_lod_method_call(struct hlsl_ctx *ctx, struct hlsl_block *
 {
     const struct hlsl_type *object_type = object->data_type;
     struct hlsl_resource_load_params load_params = { 0 };
-    const unsigned int sampler_dim = hlsl_sampler_dim_count(object_type->sampler_dim);
-    const unsigned int offset_dim = hlsl_offset_dim_count(object_type->sampler_dim);
+    unsigned int sampler_dim, offset_dim;
     const struct hlsl_type *sampler_type;
     struct hlsl_ir_node *load;

-    if (object_type->sampler_dim == HLSL_SAMPLER_DIM_2DMS
-            || object_type->sampler_dim == HLSL_SAMPLER_DIM_2DMSARRAY)
+    if (object_type->sampler_dim != HLSL_SAMPLER_DIM_1D
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_2D
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_3D
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_CUBE
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_1DARRAY
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_2DARRAY
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_CUBEARRAY)
     {
         return raise_invalid_method_object_type(ctx, object_type, name, loc);
     }

+    sampler_dim = hlsl_sampler_dim_count(object_type->sampler_dim);
+    offset_dim = hlsl_offset_dim_count(object_type->sampler_dim);
+
     if (!strcmp(name, "SampleLevel"))
         load_params.type = HLSL_RESOURCE_SAMPLE_LOD;
     else
@@ -4802,17 +4839,24 @@ static bool add_sample_grad_method_call(struct hlsl_ctx *ctx, struct hlsl_block
 {
     const struct hlsl_type *object_type = object->data_type;
     struct hlsl_resource_load_params load_params = { 0 };
-    const unsigned int sampler_dim = hlsl_sampler_dim_count(object_type->sampler_dim);
-    const unsigned int offset_dim = hlsl_offset_dim_count(object_type->sampler_dim);
+    unsigned int sampler_dim, offset_dim;
     const struct hlsl_type *sampler_type;
     struct hlsl_ir_node *load;

-    if (object_type->sampler_dim == HLSL_SAMPLER_DIM_2DMS
-            || object_type->sampler_dim == HLSL_SAMPLER_DIM_2DMSARRAY)
+    if (object_type->sampler_dim != HLSL_SAMPLER_DIM_1D
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_2D
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_3D
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_CUBE
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_1DARRAY
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_2DARRAY
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_CUBEARRAY)
     {
         return raise_invalid_method_object_type(ctx, object_type, name, loc);
     }

+    sampler_dim = hlsl_sampler_dim_count(object_type->sampler_dim);
+    offset_dim = hlsl_offset_dim_count(object_type->sampler_dim);
+
     load_params.type = HLSL_RESOURCE_SAMPLE_GRAD;

if (params->args_count < 4 || params->args_count > 5 + !!offset_dim)

[PATCH v6 2/6] 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 fe5ee5972..5447a08ea 100644
--- a/tests/shader_runner.c
+++ b/tests/shader_runner.c
@@ -505,6 +505,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;
@@ -698,6 +699,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;
@@ -724,6 +726,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);
@@ -746,6 +749,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;
@@ -798,7 +802,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))
         {
@@ -1506,6 +1510,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;
@@ -1519,6 +1524,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;
@@ -1532,6 +1538,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;
@@ -1544,7 +1551,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;
@@ -1558,6 +1566,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 a17fa485b..a17ad2a80 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 1e22d44ef..c38285d07 100644
--- a/tests/shader_runner_d3d11.c
+++ b/tests/shader_runner_d3d11.c
@@ -361,12 +361,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);
@@ -375,77 +450,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);
@@ -528,7 +541,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;

@@ -615,7 +627,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;
@@ -699,25 +710,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 16cfec1ba..b320c07fd 100644
--- a/tests/shader_runner_d3d12.c
+++ b/tests/shader_runner_d3d12.c
@@ -185,39 +185,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[0].pData,
+                        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[0].pData,
-                    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;
@@ -273,7 +271,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;

if (base_resource && resource->r.type == base_resource->r.type && resource->r.slot == slot + 1)
@@ -291,7 +288,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;
@@ -395,7 +392,6 @@ static bool d3d12_runner_dispatch(struct shader_runner *r, unsigned int x, unsig
                 break;

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

case RESOURCE_TYPE_UAV:
-            case RESOURCE_TYPE_BUFFER_UAV:
                 if (resource->descriptor_range.NumDescriptors)
                     ID3D12GraphicsCommandList_SetGraphicsRootDescriptorTable(command_list, resource->root_index,
                             get_gpu_descriptor_handle(test_context, runner->heap, resource->r.slot + MAX_RESOURCES));
diff --git a/tests/shader_runner_d3d9.c b/tests/shader_runner_d3d9.c
index 3440e89c3..113073cdc 100644
--- a/tests/shader_runner_d3d9.c
+++ b/tests/shader_runner_d3d9.c
@@ -264,7 +264,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;

@@ -390,7 +389,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 a898d021b..98bc699fa 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 0aa611071..73b0149e4 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:
@@ -499,16 +513,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;
@@ -691,7 +704,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:
@@ -822,18 +834,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;
@@ -897,34 +913,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:
@@ -1132,7 +1152,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 v6 3/6] tests/shader-runner: Support SRV buffers.

[Francisco Casas]

From: Francisco Casas

---
 Makefile.am                        |   1 +
 tests/hlsl/srv-buffers.shader_test | 164 +++++++++++++++++++++++++++++
 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, 275 insertions(+), 28 deletions(-)
 create mode 100644 tests/hlsl/srv-buffers.shader_test

diff --git a/Makefile.am b/Makefile.am
index d9db8eec3..6df163168 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -173,6 +173,7 @@ vkd3d_shader_tests = \
    tests/hlsl/sm6-uav-rwtexture.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..f67901a18
--- /dev/null
+++ b/tests/hlsl/srv-buffers.shader_test
@@ -0,0 +1,164 @@
+[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 todo]
+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 todo]
+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 todo]
+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 draw quad
+probe all rgba (3.0, 4.0, -1.0, -1.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 todo]
+Buffer buffer;
+
+float4 main() : sv_target
+{
+    return buffer.Load(1);
+}
+
+[test]
+todo(sm<6) draw quad
+probe all rgba (4.0, 5.0, 6.0, 7.0)
+
+
+[pixel shader todo]
+Buffer buffer;
+
+float4 main() : sv_target
+{
+    return buffer.Load(float2(2, 9999));
+}
+
+[test]
+todo(sm<6) draw quad
+probe all rgba (8.0, 9.0, 10.0, 11.0)
+
+
+[pixel shader fail]
+Buffer buffer;
+sampler sam;
+
+float4 main() : sv_target
+{
+    return buffer.Sample(sam, 0);
+}
+
+
+[pixel shader fail]
+Buffer buffer;
+
+float4 main() : sv_target
+{
+    uint u1, u2;
+
+    buffer.GetDimensions(u1, u2);
+    return 0;
+}
+
+
+[pixel shader todo]
+Buffer buf;
+uniform int u;
+
+float4 main() : sv_target
+{
+    return buf[u];
+}
+
+[test]
+uniform 0 int 2
+todo(sm<6) draw quad
+probe all rgba (8.0, 9.0, 10.0, 11.0)
+uniform 0 int 0
+todo(sm<6) draw quad
+probe all rgba (0.0, 1.0, 2.0, 3.0)
+
+
+[require]
+shader model >= 5.0
+
+
+[pixel shader todo]
+Buffer buffer;
+
+float4 main() : sv_target
+{
+    uint width;
+
+    buffer.GetDimensions(width);
+    return width;
+}
+[test]
+todo draw quad
+probe all rgba (4.0, 4.0, 4.0, 4.0)
diff --git a/tests/shader_runner.c b/tests/shader_runner.c
index 5447a08ea..d8bd92289 100644
--- a/tests/shader_runner.c
+++ b/tests/shader_runner.c
@@ -1544,6 +1544,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 c38285d07..b5df5864b 100644
--- a/tests/shader_runner_d3d11.c
+++ b/tests/shader_runner_d3d11.c
@@ -418,6 +418,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)
 {
@@ -450,7 +468,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 b320c07fd..53eb9a413 100644
--- a/tests/shader_runner_d3d12.c
+++ b/tests/shader_runner_d3d12.c
@@ -127,7 +127,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;

@@ -169,15 +169,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 113073cdc..9ebb505c8 100644
--- a/tests/shader_runner_d3d9.c
+++ b/tests/shader_runner_d3d9.c
@@ -237,6 +237,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,
@@ -384,6 +390,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 98bc699fa..cad6fc21d 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 73b0149e4..ea9d61b39 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);
@@ -848,7 +851,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;
@@ -915,14 +921,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
@@ -1290,7 +1298,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;
@@ -1417,6 +1425,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 v6 4/6] 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 +++++-----
 ...egister-reservations-resources.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            | 16 +++---
 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, 180 insertions(+), 203 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 62f1cd28c..eb9753104 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 4d743aecf..10720fa43 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 6d2f698c7..1d780d500 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 d9c0bc91c..4f8f565b4 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 11447d262..11883c8be 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
 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 0f64bd5d5..74cb90f1a 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 155a033fe..94584ffe2 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 698df0117..0f6cfcf3b 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-resources.shader_test b/tests/hlsl/register-reservations-resources.shader_test
index 1fa1e9163..b63cf09d9 100644
--- a/tests/hlsl/register-reservations-resources.shader_test
+++ b/tests/hlsl/register-reservations-resources.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

@@ -175,15 +175,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 4750947ef..0d446af9f 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 6ea919df6..71ffc07f3 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 9a5fa6df4..0a7ad7e55 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 f67901a18..d923e362b 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
 8.0 9.0 10.0 11.0
@@ -44,16 +44,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 todo]
@@ -71,8 +71,8 @@ todo draw quad
 probe all rgba (3.0, 4.0, -1.0, -1.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
 8.0 9.0 10.0 11.0
diff --git a/tests/hlsl/static-initializer.shader_test b/tests/hlsl/static-initializer.shader_test
index 0c51bac76..e2b9ed2b0 100644
--- a/tests/hlsl/static-initializer.shader_test
+++ b/tests/hlsl/static-initializer.shader_test
@@ -61,8 +61,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

@@ -173,7 +173,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 357a3496e..769122bc7 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 52b6a5f93..7705671da 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 736b4ae1e..3b7f88232 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 0723c1384..118b59273 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 fe6350e0c..5ccab48f9 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 f31344748..1460d0288 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 5cfd969f0..b8db19128 100644
--- a/tests/hlsl/uav-rwtexture.shader_test
+++ b/tests/hlsl/uav-rwtexture.shader_test
@@ -26,13 +26,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

@@ -63,12 +63,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

@@ -105,7 +105,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

@@ -139,12 +139,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 d8bd92289..8407ff8ed 100644
--- a/tests/shader_runner.c
+++ b/tests/shader_runner.c
@@ -414,17 +414,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))
     {
@@ -1502,7 +1510,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;

@@ -1510,13 +1518,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;

@@ -1524,7 +1531,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;
@@ -1538,41 +1544,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 v6 5/6] 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 8407ff8ed..f657d4c67 100644
--- a/tests/shader_runner.c
+++ b/tests/shader_runner.c
@@ -802,17 +802,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);

@@ -843,6 +833,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);

[PATCH v6 6/6] vkd3d-shader/hlsl: Parse Buffer types.

[Francisco Casas]

From: Francisco Casas

---
 libs/vkd3d-shader/hlsl.c           | 11 ++++++++--
 libs/vkd3d-shader/hlsl.y           | 34 ++++++++++++++++++++----------
 libs/vkd3d-shader/tpf.c            |  7 ++++++
 tests/hlsl/srv-buffers.shader_test | 26 +++++++++++------------
 4 files changed, 52 insertions(+), 26 deletions(-)

diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c
index 04c37498d..45da98765 100644
--- a/libs/vkd3d-shader/hlsl.c
+++ b/libs/vkd3d-shader/hlsl.c
@@ -2190,9 +2190,16 @@ struct vkd3d_string_buffer *hlsl_type_to_string(struct hlsl_ctx *ctx, const stru
                         return string;
                     }

-                    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
+                    {
+                        assert(type->sampler_dim < ARRAY_SIZE(dimensions));
+                        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 8b4754bbf..49bc0c3dc 100644
--- a/libs/vkd3d-shader/hlsl.y
+++ b/libs/vkd3d-shader/hlsl.y
@@ -4229,6 +4229,7 @@ static unsigned int hlsl_offset_dim_count(enum hlsl_sampler_dim dim)
             return 3;
         case HLSL_SAMPLER_DIM_CUBE:
         case HLSL_SAMPLER_DIM_CUBEARRAY:
+        case HLSL_SAMPLER_DIM_BUFFER:
             /* Offset parameters not supported for these types. */
             return 0;
         default:
@@ -4263,7 +4264,8 @@ static bool add_load_method_call(struct hlsl_ctx *ctx, struct hlsl_block *block,
             && object_type->sampler_dim != HLSL_SAMPLER_DIM_1DARRAY
             && object_type->sampler_dim != HLSL_SAMPLER_DIM_2DARRAY
             && object_type->sampler_dim != HLSL_SAMPLER_DIM_2DMS
-            && object_type->sampler_dim != HLSL_SAMPLER_DIM_2DMSARRAY)
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_2DMSARRAY
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_BUFFER)
     {
         return raise_invalid_method_object_type(ctx, object_type, name, loc);
     }
@@ -4274,13 +4276,14 @@ static bool add_load_method_call(struct hlsl_ctx *ctx, struct hlsl_block *block,
     multisampled = object_type->sampler_dim == HLSL_SAMPLER_DIM_2DMS
             || object_type->sampler_dim == HLSL_SAMPLER_DIM_2DMSARRAY;

-    if (params->args_count < 1 + multisampled || params->args_count > 3 + multisampled)
+    if (params->args_count < 1 + multisampled || params->args_count > 2 + multisampled + !!offset_dim)
     {
         hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_WRONG_PARAMETER_COUNT,
                 "Wrong number of arguments to method 'Load': expected between %u and %u, but got %u.",
-                1 + multisampled, 3 + multisampled, params->args_count);
+                1 + multisampled, 2 + multisampled + !!offset_dim, params->args_count);
         return false;
     }
+
     if (multisampled)
     {
         if (!(load_params.sample_index = add_implicit_conversion(ctx, block, params->args[1],
@@ -4288,14 +4291,17 @@ static bool add_load_method_call(struct hlsl_ctx *ctx, struct hlsl_block *block,
             return false;
     }

-    assert(offset_dim);
-    if (params->args_count > 1 + multisampled)
+    if (!!offset_dim)
     {
-        if (!(load_params.texel_offset = add_implicit_conversion(ctx, block, params->args[1 + multisampled],
-                hlsl_get_vector_type(ctx, HLSL_TYPE_INT, offset_dim), loc)))
-            return false;
+        if (params->args_count > 1 + multisampled)
+        {
+            if (!(load_params.texel_offset = add_implicit_conversion(ctx, block, params->args[1 + multisampled],
+                    hlsl_get_vector_type(ctx, HLSL_TYPE_INT, offset_dim), loc)))
+                return false;
+        }
     }
-    if (params->args_count > 2 + multisampled)
+
+    if (params->args_count > 1 + multisampled + !!offset_dim)
     {
         hlsl_fixme(ctx, loc, "Tiled resource status argument.");
     }
@@ -4635,6 +4641,7 @@ static bool add_getdimensions_method_call(struct hlsl_ctx *ctx, struct hlsl_bloc
         { HLSL_SAMPLER_DIM_CUBEARRAY, 5, { ARG_MIP_LEVEL, ARG_WIDTH, ARG_HEIGHT, ARG_ELEMENT_COUNT, ARG_LEVEL_COUNT } },
         { HLSL_SAMPLER_DIM_2DMS, 3, { ARG_WIDTH, ARG_HEIGHT, ARG_SAMPLE_COUNT } },
         { HLSL_SAMPLER_DIM_2DMSARRAY, 4, { ARG_WIDTH, ARG_HEIGHT, ARG_ELEMENT_COUNT, ARG_SAMPLE_COUNT } },
+        { HLSL_SAMPLER_DIM_BUFFER, 1, { ARG_WIDTH} },
     };
     const struct overload *o = NULL;

@@ -4646,7 +4653,8 @@ static bool add_getdimensions_method_call(struct hlsl_ctx *ctx, struct hlsl_bloc
             && object_type->sampler_dim != HLSL_SAMPLER_DIM_2DARRAY
             && object_type->sampler_dim != HLSL_SAMPLER_DIM_2DMS
             && object_type->sampler_dim != HLSL_SAMPLER_DIM_2DMSARRAY
-            && object_type->sampler_dim != HLSL_SAMPLER_DIM_CUBEARRAY)
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_CUBEARRAY
+            && object_type->sampler_dim != HLSL_SAMPLER_DIM_BUFFER)
     {
         hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE, "GetDimensions() is not defined for this type.");
     }
@@ -6032,7 +6040,11 @@ parameter:
         }

texture_type:
-      KW_TEXTURE1D
+      KW_BUFFER
+        {
+            $$ = HLSL_SAMPLER_DIM_BUFFER;
+        }
+    | KW_TEXTURE1D
         {
             $$ = HLSL_SAMPLER_DIM_1D;
         }
diff --git a/libs/vkd3d-shader/tpf.c b/libs/vkd3d-shader/tpf.c
index adfddd320..efbec63e6 100644
--- a/libs/vkd3d-shader/tpf.c
+++ b/libs/vkd3d-shader/tpf.c
@@ -4761,6 +4761,13 @@ static void write_sm4_resinfo(const struct tpf_writer *tpf, const struct hlsl_ir
     const struct hlsl_ir_node *dst = &load->node;
     struct sm4_instruction instr;

+    if (resource->data_type->sampler_dim == HLSL_SAMPLER_DIM_BUFFER
+            || resource->data_type->sampler_dim == HLSL_SAMPLER_DIM_STRUCTURED_BUFFER)
+    {
+        hlsl_fixme(tpf->ctx, &load->node.loc, "resinfo for buffers.");
+        return;
+    }
+
     assert(dst->data_type->base_type == HLSL_TYPE_UINT || dst->data_type->base_type == HLSL_TYPE_FLOAT);

memset(&instr, 0, sizeof(instr));
diff --git a/tests/hlsl/srv-buffers.shader_test b/tests/hlsl/srv-buffers.shader_test
index d923e362b..5b02b2041 100644
--- a/tests/hlsl/srv-buffers.shader_test
+++ b/tests/hlsl/srv-buffers.shader_test
@@ -10,7 +10,7 @@ size (buffer, 4)
 12.0 13.0 14.0 15.0

-[pixel shader todo]
+[pixel shader]
 float4 a;
 Buffer<float4> buffer;
 float4 b;
@@ -23,11 +23,11 @@ float4 main() : sv_target
 [test]
 uniform 0 float4 100 200 300 400
 uniform 4 float4 1000 2000 3000 4000
-todo(sm<6) draw quad
+draw quad
 probe all rgba (200, 3000, 4, 7)

-[pixel shader todo]
+[pixel shader]
 float4 a;
 Buffer<float3> buffer;
 float4 b;
@@ -40,7 +40,7 @@ float4 main() : sv_target
 [test]
 uniform 0 float4 100 200 300 400
 uniform 4 float4 1000 2000 3000 4000
-todo(sm<6) draw quad
+draw quad
 probe all rgba (4000.0, 8.0, 9.0, 10.0)

@@ -56,7 +56,7 @@ address clamp clamp clamp
 size (buffer, 1)
 1.0 2.0 3.0 4.0

-[pixel shader todo]
+[pixel shader]
 Texture2D tex;
 sampler sam;
 Buffer<float4> buffer;
@@ -67,7 +67,7 @@ float4 main() : sv_target
 }

[test]
-todo draw quad
+todo(sm>=6) draw quad
 probe all rgba (3.0, 4.0, -1.0, -1.0)

@@ -79,7 +79,7 @@ size (buffer, 4)
 12.0 13.0 14.0 15.0

-[pixel shader todo]
+[pixel shader]
 Buffer buffer;

float4 main() : sv_target
@@ -88,11 +88,11 @@ float4 main() : sv_target
 }

[test]
-todo(sm<6) draw quad
+draw quad
 probe all rgba (4.0, 5.0, 6.0, 7.0)

-[pixel shader todo]
+[pixel shader]
 Buffer buffer;

float4 main() : sv_target
@@ -101,7 +101,7 @@ float4 main() : sv_target
 }

[test]
-todo(sm<6) draw quad
+draw quad
 probe all rgba (8.0, 9.0, 10.0, 11.0)

@@ -127,7 +127,7 @@ float4 main() : sv_target
 }

-[pixel shader todo]
+[pixel shader]
 Buffer buf;
 uniform int u;

@@ -138,10 +138,10 @@ float4 main() : sv_target

[test]
 uniform 0 int 2
-todo(sm<6) draw quad
+draw quad
 probe all rgba (8.0, 9.0, 10.0, 11.0)
 uniform 0 int 0
-todo(sm<6) draw quad
+draw quad
 probe all rgba (0.0, 1.0, 2.0, 3.0)

[Francisco Casas (＠fcasas)]

Oh, I see pipeline is failing because I forgot to update the "size" directives on `sm6-uav-rwtexture.shader_test`, probably because this test is failing for me on master.