wine/vkd3d
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/vkd3d.git synced 2025-09-12 18:50:22 -07:00
Code Issues Packages Projects Releases Wiki Activity

tests/shader_runner: Add support for 3D resources.

Browse Source
This commit is contained in:
Elizabeth Figura
2025-04-10 20:39:09 -05:00
committed by Henri Verbeet
parent 04d3996b07
commit 587c2dc76e
Notes: Henri Verbeet 2025-06-26 17:50:53 +02:00 
Approved-by: Henri Verbeet (@hverbeet)
Merge-Request: https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/1606
9 changed files with 337 additions and 140 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
tests/shader_runner.c
View File

@@ -581,24 +581,20 @@ static void parse_resource_directive(struct resource_params *resource, const cha
} }
else if (match_string(line, "size", &line)) else if (match_string(line, "size", &line))
{ {
resource->desc.height = resource->desc.depth = resource->desc.layer_count = 1;
if (sscanf(line, "( buffer , %u ) ", &resource->desc.width) == 1) if (sscanf(line, "( buffer , %u ) ", &resource->desc.width) == 1)
{ {
resource->desc.dimension = RESOURCE_DIMENSION_BUFFER; resource->desc.dimension = RESOURCE_DIMENSION_BUFFER;
resource->desc.height = 1;
resource->desc.depth = 1;
} }
else if (sscanf(line, "( raw_buffer , %u ) ", &resource->desc.width) == 1) else if (sscanf(line, "( raw_buffer , %u ) ", &resource->desc.width) == 1)
{ {
resource->desc.dimension = RESOURCE_DIMENSION_BUFFER; resource->desc.dimension = RESOURCE_DIMENSION_BUFFER;
resource->desc.height = 1;
resource->desc.depth = 1;
resource->is_raw = true; resource->is_raw = true;
} }
else if (sscanf(line, "( counter_buffer , %u ) ", &resource->desc.width) == 1) else if (sscanf(line, "( counter_buffer , %u ) ", &resource->desc.width) == 1)
{ {
resource->desc.dimension = RESOURCE_DIMENSION_BUFFER; resource->desc.dimension = RESOURCE_DIMENSION_BUFFER;
resource->desc.height = 1;
resource->desc.depth = 1;
resource->is_uav_counter = true; resource->is_uav_counter = true;
resource->stride = sizeof(uint32_t); resource->stride = sizeof(uint32_t);
resource->desc.texel_size = resource->stride; resource->desc.texel_size = resource->stride;
@@ -609,19 +605,22 @@ static void parse_resource_directive(struct resource_params *resource, const cha
else if (sscanf(line, "( 2d , %u , %u ) ", &resource->desc.width, &resource->desc.height) == 2) else if (sscanf(line, "( 2d , %u , %u ) ", &resource->desc.width, &resource->desc.height) == 2)
{ {
resource->desc.dimension = RESOURCE_DIMENSION_2D; resource->desc.dimension = RESOURCE_DIMENSION_2D;
resource->desc.depth = 1;
} }
else if (sscanf(line, "( 2dms , %u , %u , %u ) ", else if (sscanf(line, "( 2dms , %u , %u , %u ) ",
&resource->desc.sample_count, &resource->desc.width, &resource->desc.height) == 3) &resource->desc.sample_count, &resource->desc.width, &resource->desc.height) == 3)
{ {
resource->desc.dimension = RESOURCE_DIMENSION_2D; resource->desc.dimension = RESOURCE_DIMENSION_2D;
resource->desc.depth = 1;
} }
else if (sscanf(line, "( 2darray , %u , %u , %u ) ", &resource->desc.width, &resource->desc.height, else if (sscanf(line, "( 2darray , %u , %u , %u ) ", &resource->desc.width, &resource->desc.height,
&resource->desc.depth) == 3) &resource->desc.layer_count) == 3)
{ {
resource->desc.dimension = RESOURCE_DIMENSION_2D; resource->desc.dimension = RESOURCE_DIMENSION_2D;
} }
else if (sscanf(line, "( 3d , %u , %u , %u ) ", &resource->desc.width, &resource->desc.height,
&resource->desc.depth) == 3)
{
resource->desc.dimension = RESOURCE_DIMENSION_3D;
}
else else
{ {
fatal_error("Malformed resource size '%s'.\n", line); fatal_error("Malformed resource size '%s'.\n", line);
@@ -653,7 +652,7 @@ static void parse_resource_directive(struct resource_params *resource, const cha
if (rest == line) if (rest == line)
break; break;
if (resource->desc.depth > 1) if (resource->desc.layer_count > 1)
fatal_error("Upload not implemented for 2d arrays.\n"); fatal_error("Upload not implemented for 2d arrays.\n");
vkd3d_array_reserve((void **)&resource->data, &resource->data_capacity, resource->data_size + sizeof(u), 1); vkd3d_array_reserve((void **)&resource->data, &resource->data_capacity, resource->data_size + sizeof(u), 1);
@@ -768,6 +767,7 @@ static void set_default_target(struct shader_runner *runner)
params.desc.width = RENDER_TARGET_WIDTH; params.desc.width = RENDER_TARGET_WIDTH;
params.desc.height = RENDER_TARGET_HEIGHT; params.desc.height = RENDER_TARGET_HEIGHT;
params.desc.depth = 1; params.desc.depth = 1;
params.desc.layer_count = 1;
params.desc.level_count = 1; params.desc.level_count = 1;
set_resource(runner, &params); set_resource(runner, &params);

3
tests/shader_runner.h
View File

@@ -85,6 +85,7 @@ enum resource_dimension
{ {
RESOURCE_DIMENSION_BUFFER, RESOURCE_DIMENSION_BUFFER,
RESOURCE_DIMENSION_2D, RESOURCE_DIMENSION_2D,
RESOURCE_DIMENSION_3D,
}; };
struct resource_desc struct resource_desc
@@ -96,7 +97,7 @@ struct resource_desc
DXGI_FORMAT format; DXGI_FORMAT format;
unsigned int texel_size; unsigned int texel_size;
unsigned int width, height, depth; unsigned int width, height, depth;
unsigned int level_count; unsigned int layer_count, level_count;
unsigned int sample_count; unsigned int sample_count;
}; };

142
tests/shader_runner_d3d11.c
View File

@@ -46,6 +46,7 @@ struct d3d11_resource
ID3D11Resource *resource; ID3D11Resource *resource;
ID3D11Buffer *buffer; ID3D11Buffer *buffer;
ID3D11Texture2D *texture; ID3D11Texture2D *texture;
ID3D11Texture3D *texture_3d;
ID3D11RenderTargetView *rtv; ID3D11RenderTargetView *rtv;
ID3D11DepthStencilView *dsv; ID3D11DepthStencilView *dsv;
ID3D11ShaderResourceView *srv; ID3D11ShaderResourceView *srv;
@@ -394,6 +395,51 @@ static ID3D11Buffer *create_buffer(ID3D11Device *device, unsigned int bind_flags
return buffer; return buffer;
} }
static unsigned int get_bind_flags(const struct resource_params *params)
{
if (params->desc.type == RESOURCE_TYPE_UAV)
return D3D11_BIND_UNORDERED_ACCESS;
else if (params->desc.type == RESOURCE_TYPE_RENDER_TARGET)
return D3D11_BIND_RENDER_TARGET;
else if (params->desc.type == RESOURCE_TYPE_DEPTH_STENCIL)
return D3D11_BIND_DEPTH_STENCIL;
else
return D3D11_BIND_SHADER_RESOURCE;
}
static void init_subresource_data(D3D11_SUBRESOURCE_DATA *resource_data, const struct resource_params *params)
{
unsigned int buffer_offset = 0;
for (unsigned int level = 0; level < params->desc.level_count; ++level)
{
unsigned int level_width = get_level_dimension(params->desc.width, level);
unsigned int level_height = get_level_dimension(params->desc.height, level);
unsigned int level_depth = get_level_dimension(params->desc.depth, level);
resource_data[level].pSysMem = &params->data[buffer_offset];
resource_data[level].SysMemPitch = level_width * params->desc.texel_size;
resource_data[level].SysMemSlicePitch = level_height * resource_data[level].SysMemPitch;
buffer_offset += level_depth * resource_data[level].SysMemSlicePitch;
}
}
static void create_identity_view(ID3D11Device *device,
struct d3d11_resource *resource, const struct resource_params *params)
{
HRESULT hr;
if (params->desc.type == RESOURCE_TYPE_UAV)
hr = ID3D11Device_CreateUnorderedAccessView(device, resource->resource, NULL, &resource->uav);
else if (params->desc.type == RESOURCE_TYPE_RENDER_TARGET)
hr = ID3D11Device_CreateRenderTargetView(device, resource->resource, NULL, &resource->rtv);
else if (params->desc.type == RESOURCE_TYPE_DEPTH_STENCIL)
hr = ID3D11Device_CreateDepthStencilView(device, resource->resource, NULL, &resource->dsv);
else
hr = ID3D11Device_CreateShaderResourceView(device, resource->resource, NULL, &resource->srv);
ok(hr == S_OK, "Failed to create view, hr %#lx.\n", hr);
}
static bool init_resource_2d(struct d3d11_shader_runner *runner, struct d3d11_resource *resource, static bool init_resource_2d(struct d3d11_shader_runner *runner, struct d3d11_resource *resource,
const struct resource_params *params) const struct resource_params *params)
{ {
@@ -423,36 +469,18 @@ static bool init_resource_2d(struct d3d11_shader_runner *runner, struct d3d11_re
desc.Width = params->desc.width; desc.Width = params->desc.width;
desc.Height = params->desc.height; desc.Height = params->desc.height;
desc.MipLevels = params->desc.level_count; desc.MipLevels = params->desc.level_count;
desc.ArraySize = params->desc.depth; desc.ArraySize = params->desc.layer_count;
desc.Format = params->desc.format; desc.Format = params->desc.format;
desc.SampleDesc.Count = max(params->desc.sample_count, 1); desc.SampleDesc.Count = max(params->desc.sample_count, 1);
desc.Usage = D3D11_USAGE_DEFAULT; desc.Usage = D3D11_USAGE_DEFAULT;
if (params->desc.type == RESOURCE_TYPE_UAV) desc.BindFlags = get_bind_flags(params);
desc.BindFlags = D3D11_BIND_UNORDERED_ACCESS;
else if (params->desc.type == RESOURCE_TYPE_RENDER_TARGET)
desc.BindFlags = D3D11_BIND_RENDER_TARGET;
else if (params->desc.type == RESOURCE_TYPE_DEPTH_STENCIL)
desc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
else
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
if (params->data) if (params->data)
{ {
unsigned int buffer_offset = 0;
if (params->desc.sample_count > 1) if (params->desc.sample_count > 1)
fatal_error("Cannot upload data to a multisampled texture.\n"); fatal_error("Cannot upload data to a multisampled texture.\n");
for (unsigned int level = 0; level < params->desc.level_count; ++level) init_subresource_data(resource_data, params);
{
unsigned int level_width = get_level_dimension(params->desc.width, level);
unsigned int level_height = get_level_dimension(params->desc.height, level);
resource_data[level].pSysMem = &params->data[buffer_offset];
resource_data[level].SysMemPitch = level_width * params->desc.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); hr = ID3D11Device_CreateTexture2D(device, &desc, resource_data, &resource->texture);
} }
else else
@@ -462,16 +490,42 @@ static bool init_resource_2d(struct d3d11_shader_runner *runner, struct d3d11_re
ok(hr == S_OK, "Failed to create texture, hr %#lx.\n", hr); ok(hr == S_OK, "Failed to create texture, hr %#lx.\n", hr);
resource->resource = (ID3D11Resource *)resource->texture; resource->resource = (ID3D11Resource *)resource->texture;
if (params->desc.type == RESOURCE_TYPE_UAV) create_identity_view(device, resource, params);
hr = ID3D11Device_CreateUnorderedAccessView(device, resource->resource, NULL, &resource->uav); return true;
else if (params->desc.type == RESOURCE_TYPE_RENDER_TARGET) }
hr = ID3D11Device_CreateRenderTargetView(device, resource->resource, NULL, &resource->rtv);
else if (params->desc.type == RESOURCE_TYPE_DEPTH_STENCIL)
hr = ID3D11Device_CreateDepthStencilView(device, resource->resource, NULL, &resource->dsv);
else
hr = ID3D11Device_CreateShaderResourceView(device, resource->resource, NULL, &resource->srv);
ok(hr == S_OK, "Failed to create view, hr %#lx.\n", hr);
static bool init_resource_3d(struct d3d11_shader_runner *runner, struct d3d11_resource *resource,
const struct resource_params *params)
{
D3D11_SUBRESOURCE_DATA resource_data[3];
ID3D11Device *device = runner->device;
D3D11_TEXTURE3D_DESC desc = {0};
HRESULT hr;
if (params->desc.level_count > ARRAY_SIZE(resource_data))
fatal_error("Level count %u is too high.\n", params->desc.level_count);
desc.Width = params->desc.width;
desc.Height = params->desc.height;
desc.Depth = params->desc.depth;
desc.MipLevels = params->desc.level_count;
desc.Format = params->desc.format;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.BindFlags = get_bind_flags(params);
if (params->data)
{
init_subresource_data(resource_data, params);
hr = ID3D11Device_CreateTexture3D(device, &desc, resource_data, &resource->texture_3d);
}
else
{
hr = ID3D11Device_CreateTexture3D(device, &desc, NULL, &resource->texture_3d);
}
ok(hr == S_OK, "Failed to create texture, hr %#lx.\n", hr);
resource->resource = (ID3D11Resource *)resource->texture_3d;
create_identity_view(device, resource, params);
return true; return true;
} }
@@ -546,14 +600,18 @@ static struct resource *d3d11_runner_create_resource(struct shader_runner *r, co
case RESOURCE_TYPE_TEXTURE: case RESOURCE_TYPE_TEXTURE:
if (params->desc.dimension == RESOURCE_DIMENSION_BUFFER) if (params->desc.dimension == RESOURCE_DIMENSION_BUFFER)
init_resource_srv_buffer(runner, resource, params); init_resource_srv_buffer(runner, resource, params);
else if (!init_resource_2d(runner, resource, params)) else if (params->desc.dimension == RESOURCE_DIMENSION_2D && !init_resource_2d(runner, resource, params))
return NULL;
else if (params->desc.dimension == RESOURCE_DIMENSION_3D && !init_resource_3d(runner, resource, params))
return NULL; return NULL;
break; break;
case RESOURCE_TYPE_UAV: case RESOURCE_TYPE_UAV:
if (params->desc.dimension == RESOURCE_DIMENSION_BUFFER) if (params->desc.dimension == RESOURCE_DIMENSION_BUFFER)
init_resource_uav_buffer(runner, resource, params); init_resource_uav_buffer(runner, resource, params);
else if (!init_resource_2d(runner, resource, params)) else if (params->desc.dimension == RESOURCE_DIMENSION_2D && !init_resource_2d(runner, resource, params))
return NULL;
else if (params->desc.dimension == RESOURCE_DIMENSION_3D && !init_resource_3d(runner, resource, params))
return NULL; return NULL;
break; break;
@@ -945,7 +1003,6 @@ static struct resource_readback *d3d11_runner_get_resource_readback(struct shade
struct d3d11_resource_readback *rb = malloc(sizeof(*rb)); struct d3d11_resource_readback *rb = malloc(sizeof(*rb));
ID3D11Resource *resolved_resource = NULL, *src_resource; ID3D11Resource *resolved_resource = NULL, *src_resource;
struct d3d11_resource *resource = d3d11_resource(res); struct d3d11_resource *resource = d3d11_resource(res);
D3D11_TEXTURE2D_DESC texture_desc;
D3D11_MAPPED_SUBRESOURCE map_desc; D3D11_MAPPED_SUBRESOURCE map_desc;
D3D11_BUFFER_DESC buffer_desc; D3D11_BUFFER_DESC buffer_desc;
bool is_ms = false; bool is_ms = false;
@@ -967,8 +1024,10 @@ static struct resource_readback *d3d11_runner_get_resource_readback(struct shade
hr = ID3D11Device_CreateBuffer(runner->device, &buffer_desc, NULL, (ID3D11Buffer **)&rb->resource); hr = ID3D11Device_CreateBuffer(runner->device, &buffer_desc, NULL, (ID3D11Buffer **)&rb->resource);
ok(hr == S_OK, "Failed to create buffer, hr %#lx.\n", hr); ok(hr == S_OK, "Failed to create buffer, hr %#lx.\n", hr);
} }
else else if (resource->r.desc.dimension == RESOURCE_DIMENSION_2D)
{ {
D3D11_TEXTURE2D_DESC texture_desc;
ID3D11Texture2D_GetDesc(resource->texture, &texture_desc); ID3D11Texture2D_GetDesc(resource->texture, &texture_desc);
is_ms = texture_desc.SampleDesc.Count > 1; is_ms = texture_desc.SampleDesc.Count > 1;
texture_desc.SampleDesc.Count = 1; texture_desc.SampleDesc.Count = 1;
@@ -991,6 +1050,19 @@ static struct resource_readback *d3d11_runner_get_resource_readback(struct shade
src_resource = resolved_resource; src_resource = resolved_resource;
} }
} }
else if (resource->r.desc.dimension == RESOURCE_DIMENSION_3D)
{
D3D11_TEXTURE3D_DESC texture_desc;
ID3D11Texture3D_GetDesc(resource->texture_3d, &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_CreateTexture3D(runner->device, &texture_desc,
NULL, (ID3D11Texture3D **)&rb->resource);
ok(hr == S_OK, "Failed to create texture, hr %#lx.\n", hr);
}
break; break;
case RESOURCE_TYPE_VERTEX_BUFFER: case RESOURCE_TYPE_VERTEX_BUFFER:
@@ -1013,7 +1085,7 @@ static struct resource_readback *d3d11_runner_get_resource_readback(struct shade
rb->rb.row_pitch = map_desc.RowPitch; rb->rb.row_pitch = map_desc.RowPitch;
rb->rb.width = resource->r.desc.width; rb->rb.width = resource->r.desc.width;
rb->rb.height = resource->r.desc.height; rb->rb.height = resource->r.desc.height;
rb->rb.depth = 1; rb->rb.depth = resource->r.desc.depth;
rb->sub_resource_idx = sub_resource_idx; rb->sub_resource_idx = sub_resource_idx;
return &rb->rb; return &rb->rb;

45
tests/shader_runner_d3d12.c
View File

@@ -98,11 +98,12 @@ static struct resource *d3d12_runner_create_resource(struct shader_runner *r, co
{ {
unsigned int level_width = get_level_dimension(params->desc.width, level); unsigned int level_width = get_level_dimension(params->desc.width, level);
unsigned int level_height = get_level_dimension(params->desc.height, level); unsigned int level_height = get_level_dimension(params->desc.height, level);
unsigned int level_depth = get_level_dimension(params->desc.depth, level);
resource_data[level].pData = &params->data[buffer_offset]; resource_data[level].pData = &params->data[buffer_offset];
resource_data[level].RowPitch = level_width * params->desc.texel_size; resource_data[level].RowPitch = level_width * params->desc.texel_size;
resource_data[level].SlicePitch = level_height * resource_data[level].RowPitch; resource_data[level].SlicePitch = level_height * resource_data[level].RowPitch;
buffer_offset += resource_data[level].SlicePitch; buffer_offset += level_depth * resource_data[level].SlicePitch;
} }
state = resource_get_state(&resource->r); state = resource_get_state(&resource->r);
@@ -122,7 +123,7 @@ static struct resource *d3d12_runner_create_resource(struct shader_runner *r, co
resource->resource = create_default_texture_(__FILE__, __LINE__, device, resource->resource = create_default_texture_(__FILE__, __LINE__, device,
D3D12_RESOURCE_DIMENSION_TEXTURE2D, params->desc.width, params->desc.height, D3D12_RESOURCE_DIMENSION_TEXTURE2D, params->desc.width, params->desc.height,
params->desc.depth, params->desc.level_count, params->desc.sample_count, params->desc.layer_count, params->desc.level_count, params->desc.sample_count,
params->desc.format, D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET, initial_state); params->desc.format, D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET, initial_state);
ID3D12Device_CreateRenderTargetView(device, resource->resource, ID3D12Device_CreateRenderTargetView(device, resource->resource,
NULL, get_cpu_rtv_handle(test_context, runner->rtv_heap, resource->r.desc.slot)); NULL, get_cpu_rtv_handle(test_context, runner->rtv_heap, resource->r.desc.slot));
@@ -168,12 +169,26 @@ static struct resource *d3d12_runner_create_resource(struct shader_runner *r, co
} }
else else
{ {
D3D12_RESOURCE_DIMENSION dimension;
unsigned int depth;
if (params->desc.sample_count > 1 && params->desc.level_count > 1) if (params->desc.sample_count > 1 && params->desc.level_count > 1)
fatal_error("Multisampled texture has multiple levels.\n"); fatal_error("Multisampled texture has multiple levels.\n");
if (params->desc.dimension == RESOURCE_DIMENSION_2D)
{
dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
depth = params->desc.layer_count;
}
else
{
dimension = D3D12_RESOURCE_DIMENSION_TEXTURE3D;
depth = params->desc.depth;
}
resource->resource = create_default_texture_(__FILE__, __LINE__, device, resource->resource = create_default_texture_(__FILE__, __LINE__, device,
D3D12_RESOURCE_DIMENSION_TEXTURE2D, params->desc.width, params->desc.height, dimension, params->desc.width, params->desc.height, depth,
params->desc.depth, params->desc.level_count, params->desc.sample_count, params->desc.format, params->desc.level_count, params->desc.sample_count, params->desc.format,
/* Multisampled textures must have ALLOW_RENDER_TARGET set. */ /* Multisampled textures must have ALLOW_RENDER_TARGET set. */
(params->desc.sample_count > 1) ? D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET : 0, initial_state); (params->desc.sample_count > 1) ? D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET : 0, initial_state);
if (params->data) if (params->data)
@@ -220,9 +235,25 @@ static struct resource *d3d12_runner_create_resource(struct shader_runner *r, co
} }
else else
{ {
resource->resource = create_default_texture2d(device, params->desc.width, D3D12_RESOURCE_DIMENSION dimension;
params->desc.height, params->desc.depth, params->desc.level_count, unsigned int depth;
params->desc.format, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS, initial_state);
if (params->desc.dimension == RESOURCE_DIMENSION_2D)
{
dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
depth = params->desc.layer_count;
}
else
{
dimension = D3D12_RESOURCE_DIMENSION_TEXTURE3D;
depth = params->desc.depth;
}
resource->resource = create_default_texture_(__FILE__, __LINE__, device,
dimension, params->desc.width, params->desc.height, depth,
params->desc.level_count, 1, params->desc.format,
D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS, initial_state);
if (params->data) if (params->data)
{ {
upload_texture_data_with_states(resource->resource, resource_data, params->desc.level_count, upload_texture_data_with_states(resource->resource, resource_data, params->desc.level_count,

54
tests/shader_runner_d3d9.c
View File

@@ -34,6 +34,7 @@ struct d3d9_resource
IDirect3DSurface9 *surface; IDirect3DSurface9 *surface;
IDirect3DTexture9 *texture; IDirect3DTexture9 *texture;
IDirect3DVertexBuffer9 *vb; IDirect3DVertexBuffer9 *vb;
IDirect3DVolumeTexture9 *volume;
}; };
static struct d3d9_resource *d3d9_resource(struct resource *r) static struct d3d9_resource *d3d9_resource(struct resource *r)
@@ -189,7 +190,6 @@ static struct resource *d3d9_runner_create_resource(struct shader_runner *r, con
struct d3d9_shader_runner *runner = d3d9_shader_runner(r); struct d3d9_shader_runner *runner = d3d9_shader_runner(r);
IDirect3DDevice9 *device = runner->device; IDirect3DDevice9 *device = runner->device;
struct d3d9_resource *resource; struct d3d9_resource *resource;
D3DLOCKED_RECT map_desc;
D3DFORMAT format; D3DFORMAT format;
HRESULT hr; HRESULT hr;
void *data; void *data;
@@ -226,14 +226,15 @@ static struct resource *d3d9_runner_create_resource(struct shader_runner *r, con
case RESOURCE_TYPE_TEXTURE: case RESOURCE_TYPE_TEXTURE:
{ {
unsigned int src_buffer_offset = 0;
if (params->desc.dimension == RESOURCE_DIMENSION_BUFFER) if (params->desc.dimension == RESOURCE_DIMENSION_BUFFER)
{ {
fatal_error("Buffer resources are not supported.\n"); fatal_error("Buffer resources are not supported.\n");
break; break;
} }
else if (params->desc.dimension == RESOURCE_DIMENSION_2D)
unsigned int src_buffer_offset = 0; {
hr = IDirect3DDevice9_CreateTexture(device, params->desc.width, params->desc.height, hr = IDirect3DDevice9_CreateTexture(device, params->desc.width, params->desc.height,
params->desc.level_count, 0, format, D3DPOOL_MANAGED, &resource->texture, NULL); params->desc.level_count, 0, format, D3DPOOL_MANAGED, &resource->texture, NULL);
ok(hr == D3D_OK, "Failed to create texture, hr %#lx.\n", hr); ok(hr == D3D_OK, "Failed to create texture, hr %#lx.\n", hr);
@@ -244,11 +245,12 @@ static struct resource *d3d9_runner_create_resource(struct shader_runner *r, con
unsigned int level_height = get_level_dimension(params->desc.height, level); unsigned int level_height = get_level_dimension(params->desc.height, level);
unsigned int src_row_pitch = level_width * params->desc.texel_size; unsigned int src_row_pitch = level_width * params->desc.texel_size;
unsigned int src_slice_pitch = level_height * src_row_pitch; unsigned int src_slice_pitch = level_height * src_row_pitch;
D3DLOCKED_RECT map_desc;
hr = IDirect3DTexture9_LockRect(resource->texture, level, &map_desc, NULL, 0); hr = IDirect3DTexture9_LockRect(resource->texture, level, &map_desc, NULL, 0);
ok(hr == D3D_OK, "Failed to map texture, hr %#lx.\n", hr); ok(hr == D3D_OK, "Failed to map texture, hr %#lx.\n", hr);
for (unsigned int y = 0; y < level_height; ++y) for (unsigned int y = 0; y < level_height; ++y)
memcpy(&((char *)map_desc.pBits)[y * map_desc.Pitch], memcpy(&((uint8_t *)map_desc.pBits)[y * map_desc.Pitch],
&params->data[src_buffer_offset + y * src_row_pitch], src_row_pitch); &params->data[src_buffer_offset + y * src_row_pitch], src_row_pitch);
hr = IDirect3DTexture9_UnlockRect(resource->texture, level); hr = IDirect3DTexture9_UnlockRect(resource->texture, level);
ok(hr == D3D_OK, "Failed to unmap texture, hr %#lx.\n", hr); ok(hr == D3D_OK, "Failed to unmap texture, hr %#lx.\n", hr);
@@ -257,6 +259,39 @@ static struct resource *d3d9_runner_create_resource(struct shader_runner *r, con
} }
break; break;
} }
else if (params->desc.dimension == RESOURCE_DIMENSION_3D)
{
hr = IDirect3DDevice9_CreateVolumeTexture(device,
params->desc.width, params->desc.height, params->desc.depth,
params->desc.level_count, 0, format, D3DPOOL_MANAGED, &resource->volume, NULL);
ok(hr == D3D_OK, "Failed to create texture, hr %#lx.\n", hr);
for (unsigned int level = 0; level < params->desc.level_count; ++level)
{
unsigned int level_width = get_level_dimension(params->desc.width, level);
unsigned int level_height = get_level_dimension(params->desc.height, level);
unsigned int level_depth = get_level_dimension(params->desc.depth, level);
unsigned int src_row_pitch = level_width * params->desc.texel_size;
unsigned int src_slice_pitch = level_height * src_row_pitch;
D3DLOCKED_BOX map_desc;
hr = IDirect3DVolumeTexture9_LockBox(resource->volume, level, &map_desc, NULL, 0);
ok(hr == D3D_OK, "Failed to map texture, hr %#lx.\n", hr);
for (unsigned int z = 0; z < level_depth; ++z)
{
for (unsigned int y = 0; y < level_height; ++y)
memcpy(&((uint8_t *)map_desc.pBits)[z * map_desc.SlicePitch + y * map_desc.RowPitch],
&params->data[src_buffer_offset + z * src_slice_pitch + y * src_row_pitch],
src_row_pitch);
}
hr = IDirect3DVolumeTexture9_UnlockBox(resource->volume, level);
ok(hr == D3D_OK, "Failed to unmap texture, hr %#lx.\n", hr);
src_buffer_offset += (src_slice_pitch * level_depth);
}
break;
}
}
case RESOURCE_TYPE_UAV: case RESOURCE_TYPE_UAV:
fatal_error("UAVs are not supported.\n"); fatal_error("UAVs are not supported.\n");
@@ -288,6 +323,8 @@ static void d3d9_runner_destroy_resource(struct shader_runner *r, struct resourc
IDirect3DTexture9_Release(resource->texture); IDirect3DTexture9_Release(resource->texture);
if (resource->vb) if (resource->vb)
IDirect3DVertexBuffer9_Release(resource->vb); IDirect3DVertexBuffer9_Release(resource->vb);
if (resource->volume)
IDirect3DVolumeTexture9_Release(resource->volume);
free(resource); free(resource);
} }
@@ -421,7 +458,12 @@ static bool d3d9_runner_draw(struct shader_runner *r,
case RESOURCE_TYPE_TEXTURE: case RESOURCE_TYPE_TEXTURE:
assert(resource->r.desc.dimension != RESOURCE_DIMENSION_BUFFER); assert(resource->r.desc.dimension != RESOURCE_DIMENSION_BUFFER);
hr = IDirect3DDevice9_SetTexture(device, resource->r.desc.slot, (IDirect3DBaseTexture9 *)resource->texture); if (resource->r.desc.dimension == RESOURCE_DIMENSION_2D)
hr = IDirect3DDevice9_SetTexture(device, resource->r.desc.slot,
(IDirect3DBaseTexture9 *)resource->texture);
else
hr = IDirect3DDevice9_SetTexture(device, resource->r.desc.slot,
(IDirect3DBaseTexture9 *)resource->volume);
ok(hr == D3D_OK, "Failed to set texture, hr %#lx.\n", hr); ok(hr == D3D_OK, "Failed to set texture, hr %#lx.\n", hr);
break; break;

46
tests/shader_runner_gl.c
View File

@@ -441,17 +441,24 @@ static void gl_runner_cleanup(struct gl_runner *runner)
ok(ret, "Failed to terminate EGL display connection.\n"); ok(ret, "Failed to terminate EGL display connection.\n");
} }
static bool init_resource_2d(struct gl_resource *resource, const struct resource_params *params) static bool init_resource_texture(struct gl_resource *resource, const struct resource_params *params)
{ {
unsigned int offset, w, h, i; unsigned int offset, w, h, d, i;
GLenum target; GLenum target;
if (params->desc.dimension == RESOURCE_DIMENSION_2D)
{
if (params->desc.sample_count > 1) if (params->desc.sample_count > 1)
target = GL_TEXTURE_2D_MULTISAMPLE; target = GL_TEXTURE_2D_MULTISAMPLE;
else if (params->desc.depth > 1) else if (params->desc.layer_count > 1)
target = GL_TEXTURE_2D_ARRAY; target = GL_TEXTURE_2D_ARRAY;
else else
target = GL_TEXTURE_2D; target = GL_TEXTURE_2D;
}
else
{
target = GL_TEXTURE_3D;
}
resource->target = target; resource->target = target;
resource->format = get_format_info(params->desc.format, params->is_shadow); resource->format = get_format_info(params->desc.format, params->is_shadow);
@@ -477,9 +484,12 @@ static bool init_resource_2d(struct gl_resource *resource, const struct resource
} }
else else
{ {
if (params->desc.depth > 1) if (params->desc.dimension == RESOURCE_DIMENSION_3D)
glTexStorage3D(target, params->desc.level_count, resource->format->internal_format, glTexStorage3D(target, params->desc.level_count, resource->format->internal_format,
params->desc.width, params->desc.height, params->desc.depth); params->desc.width, params->desc.height, params->desc.depth);
else if (params->desc.layer_count > 1)
glTexStorage3D(target, params->desc.level_count, resource->format->internal_format,
params->desc.width, params->desc.height, params->desc.layer_count);
else else
glTexStorage2D(target, params->desc.level_count, resource->format->internal_format, glTexStorage2D(target, params->desc.level_count, resource->format->internal_format,
params->desc.width, params->desc.height); params->desc.width, params->desc.height);
@@ -493,10 +503,27 @@ static bool init_resource_2d(struct gl_resource *resource, const struct resource
{ {
w = get_level_dimension(params->desc.width, i); w = get_level_dimension(params->desc.width, i);
h = get_level_dimension(params->desc.height, i); h = get_level_dimension(params->desc.height, i);
d = get_level_dimension(params->desc.depth, i);
if (params->desc.dimension == RESOURCE_DIMENSION_3D)
{
glTexSubImage3D(target, i, 0, 0, 0, w, h, d, resource->format->format,
resource->format->type, params->data + offset);
offset += w * h * d * params->desc.texel_size;
}
else if (params->desc.layer_count > 1)
{
glTexSubImage3D(target, i, 0, 0, 0, w, h, params->desc.layer_count, resource->format->format,
resource->format->type, params->data + offset);
offset += w * h * params->desc.layer_count * params->desc.texel_size;
}
else
{
glTexSubImage2D(target, i, 0, 0, w, h, resource->format->format, glTexSubImage2D(target, i, 0, 0, w, h, resource->format->format,
resource->format->type, params->data + offset); resource->format->type, params->data + offset);
offset += w * h * params->desc.texel_size; offset += w * h * params->desc.texel_size;
} }
}
return true; return true;
} }
@@ -532,7 +559,7 @@ static struct resource *gl_runner_create_resource(struct shader_runner *r, const
case RESOURCE_TYPE_UAV: case RESOURCE_TYPE_UAV:
if (params->desc.dimension == RESOURCE_DIMENSION_BUFFER) if (params->desc.dimension == RESOURCE_DIMENSION_BUFFER)
init_resource_buffer(resource, params); init_resource_buffer(resource, params);
else if (!init_resource_2d(resource, params)) else if (!init_resource_texture(resource, params))
return NULL; return NULL;
break; break;
@@ -1349,16 +1376,17 @@ static bool gl_runner_copy(struct shader_runner *r, struct resource *src, struct
{ {
struct gl_resource *s = gl_resource(src); struct gl_resource *s = gl_resource(src);
struct gl_resource *d = gl_resource(dst); struct gl_resource *d = gl_resource(dst);
unsigned int l, w, h; unsigned int l, w, h, z;
if (src->desc.dimension == RESOURCE_DIMENSION_BUFFER || src->desc.depth > 1) if (src->desc.dimension == RESOURCE_DIMENSION_BUFFER || src->desc.layer_count > 1)
return false; return false;
for (l = 0; l < src->desc.level_count; ++l) for (l = 0; l < src->desc.level_count; ++l)
{ {
w = get_level_dimension(src->desc.width, l); w = get_level_dimension(src->desc.width, l);
h = get_level_dimension(src->desc.height, l); h = get_level_dimension(src->desc.height, l);
glCopyImageSubData(s->id, s->target, l, 0, 0, 0, d->id, d->target, l, 0, 0, 0, w, h, 1); z = get_level_dimension(src->desc.depth, l);
glCopyImageSubData(s->id, s->target, l, 0, 0, 0, d->id, d->target, l, 0, 0, 0, w, h, z);
} }
return true; return true;
@@ -1386,7 +1414,7 @@ static struct resource_readback *gl_runner_get_resource_readback(struct shader_r
rb->width = resource->r.desc.width; rb->width = resource->r.desc.width;
rb->height = resource->r.desc.height; rb->height = resource->r.desc.height;
rb->depth = 1; rb->depth = resource->r.desc.depth;
rb->row_pitch = rb->width * resource->r.desc.texel_size; rb->row_pitch = rb->width * resource->r.desc.texel_size;
slice_pitch = rb->row_pitch * rb->height; slice_pitch = rb->row_pitch * rb->height;

28
tests/shader_runner_metal.m
View File

@@ -258,16 +258,27 @@ static void init_resource_texture(struct metal_runner *runner,
} }
desc = [[MTLTextureDescriptor alloc] init]; desc = [[MTLTextureDescriptor alloc] init];
switch (params->desc.dimension)
{
case RESOURCE_DIMENSION_2D:
if (params->desc.sample_count > 1) if (params->desc.sample_count > 1)
desc.textureType = params->desc.depth > 1 ? MTLTextureType2DMultisampleArray desc.textureType = params->desc.layer_count > 1 ? MTLTextureType2DMultisampleArray
: MTLTextureType2DMultisample; : MTLTextureType2DMultisample;
else else
desc.textureType = params->desc.depth > 1 ? MTLTextureType2DArray : MTLTextureType2D; desc.textureType = params->desc.layer_count > 1 ? MTLTextureType2DArray : MTLTextureType2D;
break;
case RESOURCE_DIMENSION_3D:
desc.textureType = MTLTextureType3D;
break;
default:
fatal_error("Unhandled resource dimension %#x.\n", params->desc.dimension);
}
desc.pixelFormat = get_metal_pixel_format(params->desc.format); desc.pixelFormat = get_metal_pixel_format(params->desc.format);
ok(desc.pixelFormat != MTLPixelFormatInvalid, "Unhandled pixel format %#x.\n", params->desc.format); ok(desc.pixelFormat != MTLPixelFormatInvalid, "Unhandled pixel format %#x.\n", params->desc.format);
desc.width = params->desc.width; desc.width = params->desc.width;
desc.height = params->desc.height; desc.height = params->desc.height;
desc.arrayLength = params->desc.depth; desc.depth = params->desc.depth;
desc.arrayLength = params->desc.layer_count;
desc.mipmapLevelCount = params->desc.level_count; desc.mipmapLevelCount = params->desc.level_count;
desc.sampleCount = max(params->desc.sample_count, 1); desc.sampleCount = max(params->desc.sample_count, 1);
desc.storageMode = MTLStorageModePrivate; desc.storageMode = MTLStorageModePrivate;
@@ -293,15 +304,13 @@ static void init_resource_texture(struct metal_runner *runner,
if (params->data) if (params->data)
{ {
unsigned int buffer_offset = 0, level, level_width, level_height; unsigned int buffer_offset = 0, level, level_width, level_height, level_depth;
id<MTLCommandBuffer> command_buffer; id<MTLCommandBuffer> command_buffer;
id<MTLBlitCommandEncoder> blit; id<MTLBlitCommandEncoder> blit;
id<MTLTexture> upload_texture; id<MTLTexture> upload_texture;
if (params->desc.sample_count > 1) if (params->desc.sample_count > 1)
fatal_error("Cannot upload data to a multisampled texture.\n"); fatal_error("Cannot upload data to a multisampled texture.\n");
if (params->desc.depth > 1)
fatal_error("Uploading data to a texture array is not supported.\n");
desc.storageMode = MTLStorageModeManaged; desc.storageMode = MTLStorageModeManaged;
upload_texture = [[device newTextureWithDescriptor:desc] autorelease]; upload_texture = [[device newTextureWithDescriptor:desc] autorelease];
@@ -310,13 +319,14 @@ static void init_resource_texture(struct metal_runner *runner,
{ {
level_width = get_level_dimension(params->desc.width, level); level_width = get_level_dimension(params->desc.width, level);
level_height = get_level_dimension(params->desc.height, level); level_height = get_level_dimension(params->desc.height, level);
[upload_texture replaceRegion:MTLRegionMake2D(0, 0, level_width, level_height) level_depth = get_level_dimension(params->desc.depth, level);
[upload_texture replaceRegion:MTLRegionMake3D(0, 0, 0, level_width, level_height, level_depth)
mipmapLevel:level mipmapLevel:level
slice:0 slice:0
withBytes:&params->data[buffer_offset] withBytes:&params->data[buffer_offset]
bytesPerRow:level_width * params->desc.texel_size bytesPerRow:level_width * params->desc.texel_size
bytesPerImage:level_height * level_width * params->desc.texel_size]; bytesPerImage:level_height * level_width * params->desc.texel_size];
buffer_offset += level_height * level_width * params->desc.texel_size; buffer_offset += level_depth * level_height * level_width * params->desc.texel_size;
} }
command_buffer = [runner->queue commandBuffer]; command_buffer = [runner->queue commandBuffer];
@@ -896,7 +906,7 @@ static struct resource_readback *metal_runner_get_resource_readback(struct shade
rb = malloc(sizeof(*rb)); rb = malloc(sizeof(*rb));
rb->rb.width = resource->r.desc.width; rb->rb.width = resource->r.desc.width;
rb->rb.height = resource->r.desc.height; rb->rb.height = resource->r.desc.height;
rb->rb.depth = 1; rb->rb.depth = resource->r.desc.depth;
rb->rb.row_pitch = rb->rb.width * resource->r.desc.texel_size; rb->rb.row_pitch = rb->rb.width * resource->r.desc.texel_size;
rb->buffer = [runner->device newBufferWithLength:rb->rb.row_pitch * rb->rb.height rb->buffer = [runner->device newBufferWithLength:rb->rb.row_pitch * rb->rb.height
options:DEFAULT_BUFFER_RESOURCE_OPTIONS | MTLResourceStorageModeManaged]; options:DEFAULT_BUFFER_RESOURCE_OPTIONS | MTLResourceStorageModeManaged];

66
tests/shader_runner_vulkan.c
View File

@@ -85,7 +85,7 @@ static struct vulkan_shader_runner *vulkan_shader_runner(struct shader_runner *r
return CONTAINING_RECORD(r, struct vulkan_shader_runner, r); return CONTAINING_RECORD(r, struct vulkan_shader_runner, r);
} }
static void resource_init_2d(struct vulkan_shader_runner *runner, struct vulkan_resource *resource, static void resource_init_texture(struct vulkan_shader_runner *runner, struct vulkan_resource *resource,
const struct resource_params *params) const struct resource_params *params)
{ {
VkImageUsageFlagBits usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT; VkImageUsageFlagBits usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
@@ -93,11 +93,12 @@ static void resource_init_2d(struct vulkan_shader_runner *runner, struct vulkan_
const struct vulkan_test_context *context = &runner->context; const struct vulkan_test_context *context = &runner->context;
VkFormat format = vkd3d_get_vk_format(params->desc.format); VkFormat format = vkd3d_get_vk_format(params->desc.format);
const struct resource_desc *desc = &params->desc; const struct resource_desc *desc = &params->desc;
uint32_t layer_count = desc->depth; uint32_t layer_count = desc->layer_count;
VkDevice device = context->device; VkDevice device = context->device;
unsigned int buffer_offset = 0; unsigned int buffer_offset = 0;
VkDeviceMemory staging_memory; VkDeviceMemory staging_memory;
VkBuffer staging_buffer; VkBuffer staging_buffer;
VkImageType image_type;
void *data; void *data;
if (params->desc.type == RESOURCE_TYPE_UAV) if (params->desc.type == RESOURCE_TYPE_UAV)
@@ -106,10 +107,15 @@ static void resource_init_2d(struct vulkan_shader_runner *runner, struct vulkan_
usage |= VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT; usage |= VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
} }
resource->image = create_vulkan_2d_image(context, desc->width, desc->height, if (params->desc.dimension == RESOURCE_DIMENSION_3D)
desc->level_count, desc->depth, desc->sample_count, usage, format, &resource->memory); image_type = VK_IMAGE_TYPE_3D;
resource->image_view = create_vulkan_2d_image_view(context, else
resource->image, format, VK_IMAGE_ASPECT_COLOR_BIT, layer_count); image_type = VK_IMAGE_TYPE_2D;
resource->image = create_vulkan_image(context, image_type, desc->width, desc->height, desc->depth,
desc->level_count, desc->layer_count, desc->sample_count, usage, format, &resource->memory);
resource->image_view = create_vulkan_image_view(context,
resource->image, format, VK_IMAGE_ASPECT_COLOR_BIT, image_type, layer_count);
if (!params->data) if (!params->data)
{ {
@@ -135,6 +141,7 @@ static void resource_init_2d(struct vulkan_shader_runner *runner, struct vulkan_
{ {
unsigned int level_width = get_level_dimension(params->desc.width, level); unsigned int level_width = get_level_dimension(params->desc.width, level);
unsigned int level_height = get_level_dimension(params->desc.height, level); unsigned int level_height = get_level_dimension(params->desc.height, level);
unsigned int level_depth = get_level_dimension(params->desc.depth, level);
VkBufferImageCopy region = {0}; VkBufferImageCopy region = {0};
region.bufferOffset = buffer_offset; region.bufferOffset = buffer_offset;
@@ -143,11 +150,11 @@ static void resource_init_2d(struct vulkan_shader_runner *runner, struct vulkan_
region.imageSubresource.layerCount = 1; region.imageSubresource.layerCount = 1;
region.imageExtent.width = level_width; region.imageExtent.width = level_width;
region.imageExtent.height = level_height; region.imageExtent.height = level_height;
region.imageExtent.depth = 1; region.imageExtent.depth = level_depth;
VK_CALL(vkCmdCopyBufferToImage(context->cmd_buffer, staging_buffer, resource->image, VK_CALL(vkCmdCopyBufferToImage(context->cmd_buffer, staging_buffer, resource->image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region)); VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region));
buffer_offset += level_width * level_height * params->desc.texel_size; buffer_offset += level_depth * level_width * level_height * params->desc.texel_size;
} }
transition_image_layout(context, resource->image, VK_IMAGE_ASPECT_COLOR_BIT, transition_image_layout(context, resource->image, VK_IMAGE_ASPECT_COLOR_BIT,
@@ -191,7 +198,7 @@ static struct resource *vulkan_runner_create_resource(struct shader_runner *r, c
struct vulkan_shader_runner *runner = vulkan_shader_runner(r); struct vulkan_shader_runner *runner = vulkan_shader_runner(r);
const struct vulkan_test_context *context = &runner->context; const struct vulkan_test_context *context = &runner->context;
const struct resource_desc *desc = &params->desc; const struct resource_desc *desc = &params->desc;
unsigned int layer_count = desc->depth; unsigned int layer_count = desc->layer_count;
VkDevice device = context->device; VkDevice device = context->device;
struct vulkan_resource *resource; struct vulkan_resource *resource;
VkFormat format; VkFormat format;
@@ -205,11 +212,11 @@ static struct resource *vulkan_runner_create_resource(struct shader_runner *r, c
case RESOURCE_TYPE_RENDER_TARGET: case RESOURCE_TYPE_RENDER_TARGET:
format = vkd3d_get_vk_format(params->desc.format); format = vkd3d_get_vk_format(params->desc.format);
resource->image = create_vulkan_2d_image(context, desc->width, resource->image = create_vulkan_image(context, VK_IMAGE_TYPE_2D,
desc->height, desc->level_count, desc->depth, desc->sample_count, desc->width, desc->height, 1, desc->level_count, desc->layer_count, desc->sample_count,
VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, format, &resource->memory); VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, format, &resource->memory);
resource->image_view = create_vulkan_2d_image_view(context, resource->image_view = create_vulkan_image_view(context,
resource->image, format, VK_IMAGE_ASPECT_COLOR_BIT, layer_count); resource->image, format, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_TYPE_2D, layer_count);
begin_command_buffer(context); begin_command_buffer(context);
transition_image_layout(context, resource->image, VK_IMAGE_ASPECT_COLOR_BIT, 0, transition_image_layout(context, resource->image, VK_IMAGE_ASPECT_COLOR_BIT, 0,
@@ -220,12 +227,12 @@ static struct resource *vulkan_runner_create_resource(struct shader_runner *r, c
case RESOURCE_TYPE_DEPTH_STENCIL: case RESOURCE_TYPE_DEPTH_STENCIL:
format = vkd3d_get_vk_format(params->desc.format); format = vkd3d_get_vk_format(params->desc.format);
resource->image = create_vulkan_2d_image(context, desc->width, resource->image = create_vulkan_image(context, VK_IMAGE_TYPE_2D,
desc->height, desc->level_count, desc->depth, desc->sample_count, desc->width, desc->height, 1, desc->level_count, desc->layer_count, desc->sample_count,
VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
format, &resource->memory); format, &resource->memory);
resource->image_view = create_vulkan_2d_image_view(context, resource->image_view = create_vulkan_image_view(context,
resource->image, format, VK_IMAGE_ASPECT_DEPTH_BIT, layer_count); resource->image, format, VK_IMAGE_ASPECT_DEPTH_BIT, VK_IMAGE_TYPE_2D, layer_count);
begin_command_buffer(context); begin_command_buffer(context);
transition_image_layout(context, resource->image, VK_IMAGE_ASPECT_DEPTH_BIT, 0, layer_count, transition_image_layout(context, resource->image, VK_IMAGE_ASPECT_DEPTH_BIT, 0, layer_count,
@@ -238,7 +245,7 @@ static struct resource *vulkan_runner_create_resource(struct shader_runner *r, c
if (params->desc.dimension == RESOURCE_DIMENSION_BUFFER) if (params->desc.dimension == RESOURCE_DIMENSION_BUFFER)
resource_init_buffer(runner, resource, params); resource_init_buffer(runner, resource, params);
else else
resource_init_2d(runner, resource, params); resource_init_texture(runner, resource, params);
break; break;
case RESOURCE_TYPE_VERTEX_BUFFER: case RESOURCE_TYPE_VERTEX_BUFFER:
@@ -1133,8 +1140,8 @@ static void create_render_pass_and_framebuffer(struct vulkan_shader_runner *runn
runner->rt_size.width = resource->r.desc.width; runner->rt_size.width = resource->r.desc.width;
if (resource->r.desc.height < runner->rt_size.height) if (resource->r.desc.height < runner->rt_size.height)
runner->rt_size.height = resource->r.desc.height; runner->rt_size.height = resource->r.desc.height;
if (resource->r.desc.depth < layer_count) if (resource->r.desc.layer_count < layer_count)
layer_count = resource->r.desc.depth; layer_count = resource->r.desc.layer_count;
views[view_count++] = resource->image_view; views[view_count++] = resource->image_view;
} }
@@ -1274,7 +1281,7 @@ static void vulkan_runner_clear(struct shader_runner *r, struct resource *res, c
fb_desc.pAttachments = &resource->image_view; fb_desc.pAttachments = &resource->image_view;
fb_desc.width = width; fb_desc.width = width;
fb_desc.height = height; fb_desc.height = height;
fb_desc.layers = resource->r.desc.depth; fb_desc.layers = resource->r.desc.layer_count;
VK_CALL(vkCreateFramebuffer(device, &fb_desc, NULL, &fb)); VK_CALL(vkCreateFramebuffer(device, &fb_desc, NULL, &fb));
begin_desc.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; begin_desc.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
@@ -1376,7 +1383,7 @@ static bool vulkan_runner_copy(struct shader_runner *r, struct resource *src, st
VkImageCopy vk_image_copy; VkImageCopy vk_image_copy;
unsigned int l; unsigned int l;
if (src->desc.dimension == RESOURCE_DIMENSION_BUFFER || src->desc.depth > 1) if (src->desc.dimension == RESOURCE_DIMENSION_BUFFER || src->desc.layer_count > 1)
return false; return false;
if (src->desc.type == RESOURCE_TYPE_DEPTH_STENCIL) if (src->desc.type == RESOURCE_TYPE_DEPTH_STENCIL)
@@ -1394,7 +1401,6 @@ static bool vulkan_runner_copy(struct shader_runner *r, struct resource *src, st
vk_image_copy.srcOffset = (VkOffset3D){.x = 0, .y = 0, .z = 0}; vk_image_copy.srcOffset = (VkOffset3D){.x = 0, .y = 0, .z = 0};
vk_image_copy.dstSubresource = vk_image_copy.srcSubresource; vk_image_copy.dstSubresource = vk_image_copy.srcSubresource;
vk_image_copy.dstOffset = vk_image_copy.srcOffset; vk_image_copy.dstOffset = vk_image_copy.srcOffset;
vk_image_copy.extent.depth = 1;
for (l = 0; l < src->desc.level_count; ++l) for (l = 0; l < src->desc.level_count; ++l)
{ {
@@ -1402,6 +1408,7 @@ static bool vulkan_runner_copy(struct shader_runner *r, struct resource *src, st
vk_image_copy.dstSubresource.mipLevel = l; vk_image_copy.dstSubresource.mipLevel = l;
vk_image_copy.extent.width = get_level_dimension(src->desc.width, l); vk_image_copy.extent.width = get_level_dimension(src->desc.width, l);
vk_image_copy.extent.height = get_level_dimension(src->desc.height, l); vk_image_copy.extent.height = get_level_dimension(src->desc.height, l);
vk_image_copy.extent.depth = get_level_dimension(src->desc.depth, l);
VK_CALL(vkCmdCopyImage(context->cmd_buffer, s->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_CALL(vkCmdCopyImage(context->cmd_buffer, s->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
d->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &vk_image_copy)); d->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &vk_image_copy));
@@ -1433,14 +1440,16 @@ static struct resource_readback *vulkan_runner_get_resource_readback(struct shad
VkBufferImageCopy region = {0}; VkBufferImageCopy region = {0};
unsigned int layer, level; unsigned int layer, level;
VkImageLayout layout; VkImageLayout layout;
size_t slice_pitch;
rb->rb.width = resource->r.desc.width; rb->rb.width = resource->r.desc.width;
rb->rb.height = resource->r.desc.height; rb->rb.height = resource->r.desc.height;
rb->rb.depth = 1; rb->rb.depth = resource->r.desc.depth;
rb->rb.row_pitch = rb->rb.width * resource->r.desc.texel_size; rb->rb.row_pitch = rb->rb.width * resource->r.desc.texel_size;
slice_pitch = rb->rb.row_pitch * rb->rb.height;
rb->buffer = create_vulkan_buffer(context, rb->rb.row_pitch * rb->rb.height, rb->buffer = create_vulkan_buffer(context, slice_pitch * rb->rb.depth,
VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &rb->memory); VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &rb->memory);
if (resource->r.desc.type == RESOURCE_TYPE_UAV && resource->r.desc.dimension == RESOURCE_DIMENSION_BUFFER) if (resource->r.desc.type == RESOURCE_TYPE_UAV && resource->r.desc.dimension == RESOURCE_DIMENSION_BUFFER)
@@ -1475,7 +1484,7 @@ static struct resource_readback *vulkan_runner_get_resource_readback(struct shad
region.imageSubresource.layerCount = 1; region.imageSubresource.layerCount = 1;
region.imageExtent.width = resource->r.desc.width; region.imageExtent.width = resource->r.desc.width;
region.imageExtent.height = resource->r.desc.height; region.imageExtent.height = resource->r.desc.height;
region.imageExtent.depth = 1; region.imageExtent.depth = resource->r.desc.depth;
if (resource->r.desc.sample_count > 1) if (resource->r.desc.sample_count > 1)
{ {
@@ -1490,8 +1499,9 @@ static struct resource_readback *vulkan_runner_get_resource_readback(struct shad
resolve_region.extent.depth = 1; resolve_region.extent.depth = 1;
resolved_desc.sample_count = 1; resolved_desc.sample_count = 1;
resolved_image = create_vulkan_2d_image(context, resolved_desc.width, resolved_desc.height, resolved_image = create_vulkan_image(context, VK_IMAGE_TYPE_2D,
resolved_desc.level_count, resolved_desc.depth, resolved_desc.sample_count, resolved_desc.width, resolved_desc.height, resolved_desc.depth,
resolved_desc.level_count, resolved_desc.layer_count, resolved_desc.sample_count,
VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
vkd3d_get_vk_format(resource->r.desc.format), &resolved_memory); vkd3d_get_vk_format(resource->r.desc.format), &resolved_memory);
transition_image_layout(context, resolved_image, VK_IMAGE_ASPECT_COLOR_BIT, layer, transition_image_layout(context, resolved_image, VK_IMAGE_ASPECT_COLOR_BIT, layer,

17
tests/vulkan_utils.h
View File

@@ -167,19 +167,19 @@ static inline VkBufferView create_vulkan_buffer_view(const struct vulkan_test_co
return view; return view;
} }
static inline VkImage create_vulkan_2d_image(const struct vulkan_test_context *context, unsigned int width, static inline VkImage create_vulkan_image(const struct vulkan_test_context *context, VkImageType image_type,
unsigned int height, unsigned int level_count, unsigned int layer_count, unsigned int sample_count, unsigned int width, unsigned int height, unsigned int depth, unsigned int level_count, unsigned int layer_count,
VkImageUsageFlags usage, VkFormat format, VkDeviceMemory *memory) unsigned int sample_count, VkImageUsageFlags usage, VkFormat format, VkDeviceMemory *memory)
{ {
VkImageCreateInfo image_info = {.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO}; VkImageCreateInfo image_info = {.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};
VkMemoryRequirements memory_reqs; VkMemoryRequirements memory_reqs;
VkImage image; VkImage image;
image_info.imageType = VK_IMAGE_TYPE_2D; image_info.imageType = image_type;
image_info.format = format; image_info.format = format;
image_info.extent.width = width; image_info.extent.width = width;
image_info.extent.height = height; image_info.extent.height = height;
image_info.extent.depth = 1; image_info.extent.depth = depth;
image_info.mipLevels = level_count; image_info.mipLevels = level_count;
image_info.arrayLayers = layer_count; image_info.arrayLayers = layer_count;
image_info.samples = max(sample_count, 1); image_info.samples = max(sample_count, 1);
@@ -197,14 +197,17 @@ static inline VkImage create_vulkan_2d_image(const struct vulkan_test_context *c
return image; return image;
} }
static inline VkImageView create_vulkan_2d_image_view(const struct vulkan_test_context *context, static inline VkImageView create_vulkan_image_view(const struct vulkan_test_context *context, VkImage image,
VkImage image, VkFormat format, VkImageAspectFlags aspect_mask, unsigned int layer_count) VkFormat format, VkImageAspectFlags aspect_mask, VkImageType image_type, unsigned int layer_count)
{ {
VkImageViewCreateInfo view_info = {.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO}; VkImageViewCreateInfo view_info = {.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO};
VkImageView view; VkImageView view;
view_info.image = image; view_info.image = image;
if (image_type == VK_IMAGE_TYPE_2D)
view_info.viewType = (layer_count > 1) ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D; view_info.viewType = (layer_count > 1) ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D;
else if (image_type == VK_IMAGE_TYPE_3D)
view_info.viewType = VK_IMAGE_VIEW_TYPE_3D;
view_info.format = format; view_info.format = format;
view_info.components.r = VK_COMPONENT_SWIZZLE_IDENTITY; view_info.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
view_info.components.g = VK_COMPONENT_SWIZZLE_IDENTITY; view_info.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;