[PATCH v10 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.

--
  v10: 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: Record valid methods in object_methods[].

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

[PATCH v10 1/6] vkd3d-shader/hlsl: Record valid methods in object_methods[].

[Francisco Casas]

From: Francisco Casas

Also, call hlsl_sampler_dim_count() and hlsl_offset_dim_count() after
type checking, to avoid reaching unreacheable cases.
---
 libs/vkd3d-shader/hlsl.h |   7 +--
 libs/vkd3d-shader/hlsl.y | 105 +++++++++++++++++----------------------
 2 files changed, 50 insertions(+), 62 deletions(-)

diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h
index 43bc079db..50c22fa55 100644
--- a/libs/vkd3d-shader/hlsl.h
+++ b/libs/vkd3d-shader/hlsl.h
@@ -104,7 +104,7 @@ enum hlsl_base_type

enum hlsl_sampler_dim
 {
-    HLSL_SAMPLER_DIM_GENERIC,
+    HLSL_SAMPLER_DIM_GENERIC = 0,
     HLSL_SAMPLER_DIM_COMPARISON,
     HLSL_SAMPLER_DIM_1D,
     HLSL_SAMPLER_DIM_2D,
@@ -116,10 +116,10 @@ enum hlsl_sampler_dim
     HLSL_SAMPLER_DIM_2DMS,
     HLSL_SAMPLER_DIM_2DMSARRAY,
     HLSL_SAMPLER_DIM_CUBEARRAY,
-    HLSL_SAMPLER_DIM_LAST_TEXTURE = HLSL_SAMPLER_DIM_CUBEARRAY,
     HLSL_SAMPLER_DIM_BUFFER,
     HLSL_SAMPLER_DIM_STRUCTURED_BUFFER,
     HLSL_SAMPLER_DIM_MAX = HLSL_SAMPLER_DIM_STRUCTURED_BUFFER,
+    /* NOTE: Remember to update object_methods[] in hlsl.y if this enum is modified. */
 };

enum hlsl_regset
@@ -149,7 +149,8 @@ struct hlsl_type
     enum hlsl_base_type base_type;

/* If base_type is HLSL_TYPE_SAMPLER, then sampler_dim is <= HLSL_SAMPLER_DIM_LAST_SAMPLER.
-     * If base_type is HLSL_TYPE_TEXTURE, then sampler_dim is <= HLSL_SAMPLER_DIM_LAST_TEXTURE.
+     * If base_type is HLSL_TYPE_TEXTURE, then sampler_dim can be any value of the enum except
+     *   HLSL_SAMPLER_DIM_GENERIC and HLSL_SAMPLER_DIM_COMPARISON.
      * If base_type is HLSL_TYPE_UAV, then sampler_dim must be one of HLSL_SAMPLER_DIM_1D,
      *   HLSL_SAMPLER_DIM_2D, HLSL_SAMPLER_DIM_3D, HLSL_SAMPLER_DIM_1DARRAY, HLSL_SAMPLER_DIM_2DARRAY,
      *   HLSL_SAMPLER_DIM_BUFFER, or HLSL_SAMPLER_DIM_STRUCTURED_BUFFER.
diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y
index 37a372893..f4c9a17b2 100644
--- a/libs/vkd3d-shader/hlsl.y
+++ b/libs/vkd3d-shader/hlsl.y
@@ -4252,18 +4252,21 @@ 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_BUFFER
+            || object_type->sampler_dim == HLSL_SAMPLER_DIM_STRUCTURED_BUFFER)
     {
-        return raise_invalid_method_object_type(ctx, object_type, name, loc);
+        hlsl_fixme(ctx, loc, "Method '%s' for buffers.", name);
+        return false;
     }

+    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,17 +4314,13 @@ 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)
-    {
-        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)
     {
@@ -4375,17 +4374,13 @@ 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)
-    {
-        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;
@@ -4449,20 +4444,14 @@ 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
-            && 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, "GatherGreen"))
     {
@@ -4616,9 +4605,11 @@ 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_BUFFER
+            || object_type->sampler_dim == HLSL_SAMPLER_DIM_STRUCTURED_BUFFER)
     {
-        hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE, "GetDimensions() is not defined for this type.");
+        hlsl_fixme(ctx, loc, "Method '%s' for buffers.", name);
+        return false;
     }

uint_type = hlsl_get_scalar_type(ctx, HLSL_TYPE_UINT);
@@ -4732,16 +4723,12 @@ 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)
-    {
-        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;
@@ -4802,16 +4789,12 @@ 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)
-    {
-        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;

@@ -4873,25 +4856,27 @@ static const struct method_function
     const char *name;
     bool (*handler)(struct hlsl_ctx *ctx, struct hlsl_block *block, struct hlsl_ir_node *object,
             const char *name, const struct parse_initializer *params, const struct vkd3d_shader_location *loc);
+    bool valid_dims[HLSL_SAMPLER_DIM_MAX + 1];
 }
 object_methods[] =
 {
-    { "Gather",             add_gather_method_call },
-    { "GatherAlpha",        add_gather_method_call },
-    { "GatherBlue",         add_gather_method_call },
-    { "GatherGreen",        add_gather_method_call },
-    { "GatherRed",          add_gather_method_call },
+                                                        /*  g c   1d  2d  3d  cube  1darr  2darr  2dms  2dmsarr  cubearr  buff  sbuff*/
+    { "Gather",             add_gather_method_call,        {0,0,  0,  1,  0,  1,    0,     1,     0,    0,       1,       0,    0}},
+    { "GatherAlpha",        add_gather_method_call,        {0,0,  0,  1,  0,  1,    0,     1,     0,    0,       1,       0,    0}},
+    { "GatherBlue",         add_gather_method_call,        {0,0,  0,  1,  0,  1,    0,     1,     0,    0,       1,       0,    0}},
+    { "GatherGreen",        add_gather_method_call,        {0,0,  0,  1,  0,  1,    0,     1,     0,    0,       1,       0,    0}},
+    { "GatherRed",          add_gather_method_call,        {0,0,  0,  1,  0,  1,    0,     1,     0,    0,       1,       0,    0}},

-    { "GetDimensions",      add_getdimensions_method_call },
+    { "GetDimensions",      add_getdimensions_method_call, {0,0,  1,  1,  1,  1,    1,     1,     1,    1,       1,       1,    1}},

-    { "Load",               add_load_method_call },
+    { "Load",               add_load_method_call,          {0,0,  1,  1,  1,  0,    1,     1,     1,    1,       0,       1,    1}},

-    { "Sample",             add_sample_method_call },
-    { "SampleBias",         add_sample_lod_method_call },
-    { "SampleCmp",          add_sample_cmp_method_call },
-    { "SampleCmpLevelZero", add_sample_cmp_method_call },
-    { "SampleGrad",         add_sample_grad_method_call },
-    { "SampleLevel",        add_sample_lod_method_call },
+    { "Sample",             add_sample_method_call,        {0,0,  1,  1,  1,  1,    1,     1,     0,    0,       1,       0,    0}},
+    { "SampleBias",         add_sample_lod_method_call,    {0,0,  1,  1,  1,  1,    1,     1,     0,    0,       1,       0,    0}},
+    { "SampleCmp",          add_sample_cmp_method_call,    {0,0,  1,  1,  1,  1,    1,     1,     0,    0,       1,       0,    0}},
+    { "SampleCmpLevelZero", add_sample_cmp_method_call,    {0,0,  1,  1,  1,  1,    1,     1,     0,    0,       1,       0,    0}},
+    { "SampleGrad",         add_sample_grad_method_call,   {0,0,  1,  1,  1,  1,    1,     1,     0,    0,       1,       0,    0}},
+    { "SampleLevel",        add_sample_lod_method_call,    {0,0,  1,  1,  1,  1,    1,     1,     0,    0,       1,       0,    0}},
 };

static int object_method_function_name_compare(const void *a, const void *b)
@@ -4919,8 +4904,10 @@ static bool add_method_call(struct hlsl_ctx *ctx, struct hlsl_block *block, stru
         return false;
     }

-    if ((method = bsearch(name, object_methods, ARRAY_SIZE(object_methods),
-            sizeof(*method), object_method_function_name_compare)))
+    method = bsearch(name, object_methods, ARRAY_SIZE(object_methods), sizeof(*method),
+            object_method_function_name_compare);
+
+    if (method && method->valid_dims[object_type->sampler_dim])
     {
         return method->handler(ctx, block, object, name, params, loc);
     }

[PATCH v10 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 | 238 +++++++++++++++++++----------------
 7 files changed, 351 insertions(+), 289 deletions(-)

diff --git a/tests/shader_runner.c b/tests/shader_runner.c
index 1fa92210b..486809bbd 100644
--- a/tests/shader_runner.c
+++ b/tests/shader_runner.c
@@ -509,6 +509,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;
@@ -738,6 +739,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;
@@ -764,6 +766,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);
@@ -786,6 +789,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;
@@ -838,7 +842,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))
         {
@@ -1545,6 +1549,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;
@@ -1558,6 +1563,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;
@@ -1571,6 +1577,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;
@@ -1583,7 +1590,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;
@@ -1597,6 +1605,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 7e184fc5e..da4b2efce 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 d0d9e9273..2e6b4ced9 100644
--- a/tests/shader_runner_d3d11.c
+++ b/tests/shader_runner_d3d11.c
@@ -371,12 +371,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);
@@ -385,77 +460,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);
@@ -538,7 +551,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;

@@ -625,7 +637,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;
@@ -709,25 +720,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 7ba61d117..c7f9d4f72 100644
--- a/tests/shader_runner_d3d12.c
+++ b/tests/shader_runner_d3d12.c
@@ -189,43 +189,41 @@ 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);

-            state = params->data ? D3D12_RESOURCE_STATE_COPY_DEST : D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
-            resource->resource = create_default_texture2d(device, params->width, params->height, 1,
-                    params->level_count, params->format, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS, state);
-            if (params->data)
+            if (params->dimension == RESOURCE_DIMENSION_BUFFER)
             {
-                upload_texture_data_with_states(resource->resource, resource_data,
-                        params->level_count, test_context->queue, test_context->list,
+                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);
-            }
-            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;
+                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));
+                ID3D12Device_CreateUnorderedAccessView(device, resource->resource,
+                        NULL, &uav_desc, get_cpu_descriptor_handle(test_context, runner->heap, resource->r.slot + MAX_RESOURCES));
+            }
+            else
+            {
+                state = params->data ? D3D12_RESOURCE_STATE_COPY_DEST : D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
+                resource->resource = create_default_texture2d(device, params->width, params->height, 1, params->level_count,
+                        params->format, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS, state);
+                if (params->data)
+                {
+                    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_VERTEX_BUFFER:
             resource->resource = create_upload_buffer(device, params->data_size, params->data);
             break;
@@ -281,7 +279,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)
@@ -299,7 +296,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;
@@ -403,7 +400,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));
@@ -546,7 +542,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 824aca01f..773a27ff7 100644
--- a/tests/shader_runner_d3d9.c
+++ b/tests/shader_runner_d3d9.c
@@ -267,7 +267,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;

@@ -393,7 +392,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 13bbf2e39..3ce319b99 100644
--- a/tests/shader_runner_gl.c
+++ b/tests/shader_runner_gl.c
@@ -328,10 +328,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);
@@ -340,37 +376,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:
@@ -391,13 +404,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;
@@ -515,13 +536,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;
@@ -650,16 +670,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;
         }
     }
@@ -886,13 +903,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:
@@ -973,8 +993,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));
@@ -986,7 +1005,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 4edf7f046..ca88dc999 100644
--- a/tests/shader_runner_vulkan.c
+++ b/tests/shader_runner_vulkan.c
@@ -264,14 +264,96 @@ 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);
+
+    if (!params->data)
+    {
+        begin_command_buffer(runner);
+        transition_image_layout(runner, resource->image,
+                VK_IMAGE_LAYOUT_UNDEFINED, layout);
+        end_command_buffer(runner);
+        return;
+    }
+
+    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;

@@ -294,82 +376,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);
-
-            if (!params->data)
-            {
-                begin_command_buffer(runner);
-                transition_image_layout(runner, resource->image,
-                        VK_IMAGE_LAYOUT_UNDEFINED, layout);
-                end_command_buffer(runner);
-                break;
-            }
-
-            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:
@@ -510,16 +524,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;
@@ -702,7 +715,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:
@@ -833,18 +845,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;
@@ -908,34 +924,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:
@@ -1143,7 +1163,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 v10 3/6] tests/shader-runner: Support SRV buffers.

[Francisco Casas]

From: Francisco Casas

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

diff --git a/Makefile.am b/Makefile.am
index c02ec026a..ec9420866 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -174,6 +174,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..af72544b4
--- /dev/null
+++ b/tests/hlsl/srv-buffers.shader_test
@@ -0,0 +1,189 @@
+[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)
+
+
+% Buffer doesn't have offset_dim or sample_index arguments allowed.
+[pixel shader fail]
+Buffer buffer;
+
+float4 main() : sv_target
+{
+    // This test fails because the output status must be an l-value.
+    buffer.Load(0, 0);
+    return 0;
+}
+
+[pixel shader fail]
+Buffer buffer;
+
+float4 main() : sv_target
+{
+    uint u;
+
+    // This test fails because there is no overload for an argument in-between the load index and
+    // the output status.
+    buffer.Load(0, 0, u);
+    return 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 486809bbd..59ff7bb74 100644
--- a/tests/shader_runner.c
+++ b/tests/shader_runner.c
@@ -1583,6 +1583,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 2e6b4ced9..e7fb38001 100644
--- a/tests/shader_runner_d3d11.c
+++ b/tests/shader_runner_d3d11.c
@@ -428,6 +428,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)
 {
@@ -460,7 +478,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 c7f9d4f72..88a341008 100644
--- a/tests/shader_runner_d3d12.c
+++ b/tests/shader_runner_d3d12.c
@@ -130,7 +130,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;
     D3D12_RESOURCE_STATES state;
@@ -173,15 +173,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 773a27ff7..c8ec532ac 100644
--- a/tests/shader_runner_d3d9.c
+++ b/tests/shader_runner_d3d9.c
@@ -240,6 +240,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,
@@ -387,6 +393,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 3ce319b99..a24beb7be 100644
--- a/tests/shader_runner_gl.c
+++ b/tests/shader_runner_gl.c
@@ -376,9 +376,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);
@@ -404,9 +401,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)
             {
@@ -505,7 +499,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;
@@ -872,8 +869,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 ca88dc999..f95fabc59 100644
--- a/tests/shader_runner_vulkan.c
+++ b/tests/shader_runner_vulkan.c
@@ -338,9 +338,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);

@@ -376,9 +382,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);
@@ -859,7 +862,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;
@@ -926,14 +932,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
@@ -1301,7 +1309,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;
@@ -1428,6 +1436,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 v10 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 +++++-----
 .../hlsl/rasteriser-ordered-views.shader_test | 10 ++--
 ...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/sm6-uav-rwtexture.shader_test      | 15 ++---
 tests/hlsl/srv-buffers.shader_test            | 18 +++---
 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           |  9 ++-
 tests/hlsl/uav-rwtexture.shader_test          | 16 +++---
 tests/shader_runner.c                         | 55 ++++++-------------
 38 files changed, 191 insertions(+), 220 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 ee19ea5f0..bb0937ed0 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 26f7a52ad..ab5c1017b 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 @@ 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/rasteriser-ordered-views.shader_test b/tests/hlsl/rasteriser-ordered-views.shader_test
index ad75cd0c2..12af779c2 100644
--- a/tests/hlsl/rasteriser-ordered-views.shader_test
+++ b/tests/hlsl/rasteriser-ordered-views.shader_test
@@ -1,17 +1,17 @@
 [require]
 shader model >= 5.0

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

[uav 1]
 format r32 uint
-size (640, 480)
+size (2d, 640, 480)

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

[vertex shader]
diff --git a/tests/hlsl/register-reservations-resources.shader_test b/tests/hlsl/register-reservations-resources.shader_test
index b1007de63..5b53a625a 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 c37da299c..eab8fdbf8 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 6f8357dfa..a906b3aa7 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 17b09c0ec..51f477c9f 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/sm6-uav-rwtexture.shader_test b/tests/hlsl/sm6-uav-rwtexture.shader_test
index 48b9d391c..1e4cc639d 100644
--- a/tests/hlsl/sm6-uav-rwtexture.shader_test
+++ b/tests/hlsl/sm6-uav-rwtexture.shader_test
@@ -3,14 +3,12 @@ shader model >= 6.0

[uav 0]
 format r32 float
-size (2, 2)
-
+size (2d, 2, 2)
 0.1 0.2
 0.3 0.4

[uav 1]
-size (1, 1)
-
+size (2d, 1, 1)
 0.5 0.6 0.7 0.8

[pixel shader]
@@ -61,8 +59,7 @@ probe uav 1 (0, 0) rgba (2.0, 1.0, 4.0, 3.0)

[uav 2]
-size (1, 1)
-
+size (2d, 1, 1)
 0.1 0.2 0.3 0.4

[pixel shader]
@@ -95,13 +92,11 @@ probe uav 2 (0, 0) rgba (0.9, 0.8, 0.7, 0.6)
 % Test that we can declare and use an array of UAVs.

[uav 1]
-size (1, 1)
-
+size (2d, 1, 1)
 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

[pixel shader]
diff --git a/tests/hlsl/srv-buffers.shader_test b/tests/hlsl/srv-buffers.shader_test
index af72544b4..7ddfdeeda 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]
@@ -67,12 +67,12 @@ float4 main() : sv_target
 }

[test]
-todo draw quad
+todo(sm<6) 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 e7cfa9f55..ee2103bb1 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 a9d7997d7..bbc48ee8c 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
@@ -164,9 +164,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

[pixel shader]
diff --git a/tests/hlsl/uav-rwtexture.shader_test b/tests/hlsl/uav-rwtexture.shader_test
index 8f9ec24ec..b63a8324f 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 59ff7bb74..b20bf9a2d 100644
--- a/tests/shader_runner.c
+++ b/tests/shader_runner.c
@@ -418,17 +418,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))
     {
@@ -1541,7 +1549,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;

@@ -1549,13 +1557,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;

@@ -1563,7 +1570,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;
@@ -1577,41 +1583,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 v10 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 bbc48ee8c..ec8937b33 100644
--- a/tests/hlsl/uav-rwbuffer.shader_test
+++ b/tests/hlsl/uav-rwbuffer.shader_test
@@ -179,4 +179,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 b20bf9a2d..3fa00101c 100644
--- a/tests/shader_runner.c
+++ b/tests/shader_runner.c
@@ -842,17 +842,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);

@@ -883,6 +873,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 v10 6/6] vkd3d-shader/hlsl: Parse Buffer types.

[Francisco Casas]

From: Francisco Casas

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

diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c
index 3d068ac6d..6af62784a 100644
--- a/libs/vkd3d-shader/hlsl.c
+++ b/libs/vkd3d-shader/hlsl.c
@@ -2192,9 +2192,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 f4c9a17b2..3da3d00bc 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:
@@ -4257,10 +4258,9 @@ static bool add_load_method_call(struct hlsl_ctx *ctx, struct hlsl_block *block,
     struct hlsl_ir_node *load;
     bool multisampled;

-    if (object_type->sampler_dim == HLSL_SAMPLER_DIM_BUFFER
-            || object_type->sampler_dim == HLSL_SAMPLER_DIM_STRUCTURED_BUFFER)
+    if (object_type->sampler_dim == HLSL_SAMPLER_DIM_STRUCTURED_BUFFER)
     {
-        hlsl_fixme(ctx, loc, "Method '%s' for buffers.", name);
+        hlsl_fixme(ctx, loc, "Method '%s' for structured buffers.", name);
         return false;
     }

@@ -4270,13 +4270,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],
@@ -4284,14 +4285,14 @@ 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 && 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.");
     }
@@ -4602,13 +4603,13 @@ 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;

-    if (object_type->sampler_dim == HLSL_SAMPLER_DIM_BUFFER
-            || object_type->sampler_dim == HLSL_SAMPLER_DIM_STRUCTURED_BUFFER)
+    if (object_type->sampler_dim == HLSL_SAMPLER_DIM_STRUCTURED_BUFFER)
     {
-        hlsl_fixme(ctx, loc, "Method '%s' for buffers.", name);
+        hlsl_fixme(ctx, loc, "Method '%s' for structured buffers.", name);
         return false;
     }

@@ -6024,7 +6025,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 f70606e6f..d4a00a690 100644
--- a/libs/vkd3d-shader/tpf.c
+++ b/libs/vkd3d-shader/tpf.c
@@ -4764,6 +4764,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 7ddfdeeda..8ba73cc8b 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(sm<6) draw quad
+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,15 +138,15 @@ 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)

% Buffer doesn't have offset_dim or sample_index arguments allowed.
-[pixel shader fail]
+[pixel shader fail todo]
 Buffer buffer;

float4 main() : sv_target