wine/vkd3d
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/vkd3d.git synced 2024-09-13 09:16:14 -07:00
Code Issues Packages Projects Releases Wiki Activity

tests/shader_runner: Make the render target into a resource.

Browse Source 
Signed-off-by: Giovanni Mascellani <gmascellani@codeweavers.com>
Signed-off-by: Zebediah Figura <zfigura@codeweavers.com>
Signed-off-by: Henri Verbeet <hverbeet@codeweavers.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
Zebediah Figura 2022-06-08 18:18:37 -05:00 committed by Alexandre Julliard
parent d2d29d1b88
commit 2b69ee67bd
6 changed files with 270 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
tests/shader_runner.c
View File

@ -317,7 +317,27 @@ void init_resource(struct resource *resource, const struct resource_params *para
{
resource->type = params->type;
resource->slot = params->slot;
resource->format = params->format;
resource->size = params->data_size;
resource->texel_size = params->texel_size;
resource->width = params->width;
resource->height = params->height;
}
static struct resource *get_resource(struct shader_runner *runner, enum resource_type type, unsigned int slot)
{
struct resource *resource;
size_t i;
for (i = 0; i < runner->resource_count; ++i)
{
resource = runner->resources[i];
if (resource->type == type && resource->slot == slot)
return resource;
}
return NULL;
}
static void set_resource(struct shader_runner *runner, struct resource *resource)
@ -373,6 +393,20 @@ static void parse_test_directive(struct shader_runner *runner, const char *line)
"{\n"
"}";
if (!get_resource(runner, RESOURCE_TYPE_RENDER_TARGET, 0))
{
memset(&params, 0, sizeof(params));
params.slot = 0;
params.type = RESOURCE_TYPE_RENDER_TARGET;
params.format = DXGI_FORMAT_R32G32B32A32_FLOAT;
params.data_type = TEXTURE_DATA_FLOAT;
params.texel_size = 16;
params.width = RENDER_TARGET_WIDTH;
params.height = RENDER_TARGET_HEIGHT;
set_resource(runner, runner->ops->create_resource(runner, &params));
}
vkd3d_array_reserve((void **)&runner->input_elements, &runner->input_element_capacity,
1, sizeof(*runner->input_elements));
element = &runner->input_elements[0];
@ -399,9 +433,24 @@ static void parse_test_directive(struct shader_runner *runner, const char *line)
else if (match_string(line, "draw", &line))
{
D3D_PRIMITIVE_TOPOLOGY topology;
struct resource_params params;
unsigned int vertex_count;
char *rest;
if (!get_resource(runner, RESOURCE_TYPE_RENDER_TARGET, 0))
{
memset(&params, 0, sizeof(params));
params.slot = 0;
params.type = RESOURCE_TYPE_RENDER_TARGET;
params.format = DXGI_FORMAT_R32G32B32A32_FLOAT;
params.data_type = TEXTURE_DATA_FLOAT;
params.texel_size = 16;
params.width = RENDER_TARGET_WIDTH;
params.height = RENDER_TARGET_HEIGHT;
set_resource(runner, runner->ops->create_resource(runner, &params));
}
if (match_string(line, "triangle list", &line))
topology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
else if (match_string(line, "triangle strip", &line))
@ -419,15 +468,19 @@ static void parse_test_directive(struct shader_runner *runner, const char *line)
{
unsigned int left, top, right, bottom, ulps;
struct resource_readback *rb;
struct resource *resource;
int ret, len;
RECT rect;
if (runner->last_render_failed)
return;
resource = get_resource(runner, RESOURCE_TYPE_RENDER_TARGET, 0);
rb = runner->ops->get_resource_readback(runner, resource);
if (match_string(line, "all", &line))
{
set_rect(&rect, 0, 0, RENDER_TARGET_WIDTH, RENDER_TARGET_HEIGHT);
set_rect(&rect, 0, 0, resource->width, resource->height);
}
else if (sscanf(line, "( %d , %d , %d , %d )%n", &left, &top, &right, &bottom, &len) == 4)
{
@ -444,8 +497,6 @@ static void parse_test_directive(struct shader_runner *runner, const char *line)
fatal_error("Malformed probe arguments '%s'.\n", line);
}
rb = runner->ops->get_rt_readback(runner);
if (match_string(line, "rgba", &line))
{
struct vec4 v;

6
tests/shader_runner.h
View File

@ -53,6 +53,7 @@ struct sampler
enum resource_type
{
RESOURCE_TYPE_RENDER_TARGET,
RESOURCE_TYPE_TEXTURE,
RESOURCE_TYPE_UAV,
RESOURCE_TYPE_VERTEX_BUFFER,
@ -76,7 +77,10 @@ struct resource
unsigned int slot;
enum resource_type type;
DXGI_FORMAT format;
unsigned int size;
unsigned int texel_size;
unsigned int width, height;
};
struct input_element
@ -124,7 +128,7 @@ struct shader_runner_ops
struct resource *(*create_resource)(struct shader_runner *runner, const struct resource_params *params);
void (*destroy_resource)(struct shader_runner *runner, struct resource *resource);
bool (*draw)(struct shader_runner *runner, D3D_PRIMITIVE_TOPOLOGY primitive_topology, unsigned int vertex_count);
struct resource_readback *(*get_rt_readback)(struct shader_runner *runner);
struct resource_readback *(*get_resource_readback)(struct shader_runner *runner, struct resource *resource);
void (*release_readback)(struct shader_runner *runner, struct resource_readback *rb);
};

70
tests/shader_runner_d3d11.c
View File

@ -43,6 +43,8 @@ struct d3d11_resource
struct resource r;
ID3D11Resource *resource;
ID3D11Texture2D *texture;
ID3D11RenderTargetView *rtv;
ID3D11ShaderResourceView *srv;
ID3D11UnorderedAccessView *uav;
};
@ -59,8 +61,6 @@ struct d3d11_shader_runner
ID3D11Device *device;
HWND window;
IDXGISwapChain *swapchain;
ID3D11Texture2D *rt;
ID3D11RenderTargetView *rtv;
ID3D11DeviceContext *immediate_context;
};
@ -276,20 +276,8 @@ static IDXGISwapChain *create_swapchain(ID3D11Device *device, HWND window)
static BOOL init_test_context(struct d3d11_shader_runner *runner)
{
const D3D11_TEXTURE2D_DESC texture_desc =
{
.Width = RENDER_TARGET_WIDTH,
.Height = RENDER_TARGET_HEIGHT,
.MipLevels = 1,
.ArraySize = 1,
.Format = DXGI_FORMAT_R32G32B32A32_FLOAT,
.SampleDesc.Count = 1,
.Usage = D3D11_USAGE_DEFAULT,
.BindFlags = D3D11_BIND_RENDER_TARGET,
};
unsigned int rt_width, rt_height;
D3D11_VIEWPORT vp;
HRESULT hr;
RECT rect;
memset(runner, 0, sizeof(*runner));
@ -308,16 +296,8 @@ static BOOL init_test_context(struct d3d11_shader_runner *runner)
0, 0, rect.right - rect.left, rect.bottom - rect.top, NULL, NULL, NULL, NULL);
runner->swapchain = create_swapchain(runner->device, runner->window);
hr = ID3D11Device_CreateTexture2D(runner->device, &texture_desc, NULL, &runner->rt);
ok(hr == S_OK, "Failed to create texture, hr %#lx.\n", hr);
hr = ID3D11Device_CreateRenderTargetView(runner->device, (ID3D11Resource *)runner->rt, NULL, &runner->rtv);
ok(hr == S_OK, "Failed to create rendertarget view, hr %#lx.\n", hr);
ID3D11Device_GetImmediateContext(runner->device, &runner->immediate_context);
ID3D11DeviceContext_OMSetRenderTargets(runner->immediate_context, 1, &runner->rtv, NULL);
vp.TopLeftX = 0.0f;
vp.TopLeftY = 0.0f;
vp.Width = rt_width;
@ -334,8 +314,6 @@ static void destroy_test_context(struct d3d11_shader_runner *runner)
ULONG ref;
ID3D11DeviceContext_Release(runner->immediate_context);
ID3D11RenderTargetView_Release(runner->rtv);
ID3D11Texture2D_Release(runner->rt);
IDXGISwapChain_Release(runner->swapchain);
DestroyWindow(runner->window);
@ -379,6 +357,7 @@ static struct resource *d3d11_runner_create_resource(struct shader_runner *r, co
switch (params->type)
{
case RESOURCE_TYPE_RENDER_TARGET:
case RESOURCE_TYPE_TEXTURE:
case RESOURCE_TYPE_UAV:
{
@ -393,17 +372,29 @@ static struct resource *d3d11_runner_create_resource(struct shader_runner *r, co
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;
resource_data.pSysMem = params->data;
resource_data.SysMemPitch = params->width * params->texel_size;
resource_data.SysMemSlicePitch = params->height * resource_data.SysMemPitch;
hr = ID3D11Device_CreateTexture2D(device, &desc, &resource_data, (ID3D11Texture2D **)&resource->resource);
if (params->data)
{
resource_data.pSysMem = params->data;
resource_data.SysMemPitch = params->width * params->texel_size;
resource_data.SysMemSlicePitch = params->height * resource_data.SysMemPitch;
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);
@ -424,6 +415,8 @@ static void d3d11_runner_destroy_resource(struct shader_runner *r, struct resour
struct d3d11_resource *resource = d3d11_resource(res);
ID3D11Resource_Release(resource->resource);
if (resource->rtv)
ID3D11RenderTargetView_Release(resource->rtv);
if (resource->srv)
ID3D11ShaderResourceView_Release(resource->srv);
if (resource->uav)
@ -435,11 +428,13 @@ static bool d3d11_runner_draw(struct shader_runner *r,
D3D_PRIMITIVE_TOPOLOGY primitive_topology, unsigned int vertex_count)
{
ID3D11UnorderedAccessView *uavs[D3D11_PS_CS_UAV_REGISTER_COUNT] = {0};
ID3D11RenderTargetView *rtvs[D3D11_PS_CS_UAV_REGISTER_COUNT] = {0};
struct d3d11_shader_runner *runner = d3d11_shader_runner(r);
ID3D11DeviceContext *context = runner->immediate_context;
unsigned int min_uav_slot = ARRAY_SIZE(uavs);
ID3D11Device *device = runner->device;
ID3D10Blob *vs_code, *ps_code;
unsigned int rtv_count = 0;
ID3D11Buffer *cb = NULL;
ID3D11VertexShader *vs;
ID3D11PixelShader *ps;
@ -478,6 +473,11 @@ static bool d3d11_runner_draw(struct shader_runner *r,
switch (resource->r.type)
{
case RESOURCE_TYPE_RENDER_TARGET:
rtvs[resource->r.slot] = resource->rtv;
rtv_count = max(rtv_count, resource->r.slot + 1);
break;
case RESOURCE_TYPE_TEXTURE:
ID3D11DeviceContext_PSSetShaderResources(context, resource->r.slot, 1, &resource->srv);
break;
@ -494,8 +494,7 @@ static bool d3d11_runner_draw(struct shader_runner *r,
}
}
ID3D11DeviceContext_OMSetRenderTargetsAndUnorderedAccessViews(context,
D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL, NULL, NULL,
ID3D11DeviceContext_OMSetRenderTargetsAndUnorderedAccessViews(context, rtv_count, rtvs, NULL,
min_uav_slot, ARRAY_SIZE(uavs) - min_uav_slot, &uavs[min_uav_slot], NULL);
for (i = 0; i < runner->r.sampler_count; ++i)
@ -565,15 +564,16 @@ struct d3d11_resource_readback
ID3D11Resource *resource;
};
static struct resource_readback *d3d11_runner_get_rt_readback(struct shader_runner *r)
static struct resource_readback *d3d11_runner_get_resource_readback(struct shader_runner *r, struct resource *res)
{
struct d3d11_shader_runner *runner = d3d11_shader_runner(r);
struct d3d11_resource_readback *rb = malloc(sizeof(*rb));
struct d3d11_resource *resource = d3d11_resource(res);
D3D11_TEXTURE2D_DESC texture_desc;
D3D11_MAPPED_SUBRESOURCE map_desc;
HRESULT hr;
ID3D11Texture2D_GetDesc(runner->rt, &texture_desc);
ID3D11Texture2D_GetDesc(resource->texture, &texture_desc);
texture_desc.Usage = D3D11_USAGE_STAGING;
texture_desc.BindFlags = 0;
texture_desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
@ -581,7 +581,7 @@ static struct resource_readback *d3d11_runner_get_rt_readback(struct shader_runn
hr = ID3D11Device_CreateTexture2D(runner->device, &texture_desc, NULL, (ID3D11Texture2D **)&rb->resource);
ok(hr == S_OK, "Failed to create texture, hr %#lx.\n", hr);
ID3D11DeviceContext_CopyResource(runner->immediate_context, rb->resource, (ID3D11Resource *)runner->rt);
ID3D11DeviceContext_CopyResource(runner->immediate_context, rb->resource, resource->resource);
hr = ID3D11DeviceContext_Map(runner->immediate_context, rb->resource, 0, D3D11_MAP_READ, 0, &map_desc);
ok(hr == S_OK, "Failed to map texture, hr %#lx.\n", hr);
@ -608,7 +608,7 @@ static const struct shader_runner_ops d3d11_runner_ops =
.create_resource = d3d11_runner_create_resource,
.destroy_resource = d3d11_runner_destroy_resource,
.draw = d3d11_runner_draw,
.get_rt_readback = d3d11_runner_get_rt_readback,
.get_resource_readback = d3d11_runner_get_resource_readback,
.release_readback = d3d11_runner_release_readback,
};

86
tests/shader_runner_d3d12.c
View File

@ -44,7 +44,7 @@ struct d3d12_shader_runner
struct test_context test_context;
ID3D12DescriptorHeap *heap;
ID3D12DescriptorHeap *heap, *rtv_heap;
};
static struct d3d12_shader_runner *d3d12_shader_runner(struct shader_runner *r)
@ -94,6 +94,20 @@ static struct resource *d3d12_runner_create_resource(struct shader_runner *r, co
switch (params->type)
{
case RESOURCE_TYPE_RENDER_TARGET:
if (!runner->rtv_heap)
runner->rtv_heap = create_cpu_descriptor_heap(device,
D3D12_DESCRIPTOR_HEAP_TYPE_RTV, MAX_RESOURCE_DESCRIPTORS);
if (params->slot >= D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT)
fatal_error("RTV slot %u is too high.\n", params->slot);
resource->resource = create_default_texture(device, params->width, params->height,
params->format, D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET, D3D12_RESOURCE_STATE_RENDER_TARGET);
ID3D12Device_CreateRenderTargetView(device, resource->resource,
NULL, get_cpu_rtv_handle(test_context, runner->rtv_heap, resource->r.slot));
break;
case RESOURCE_TYPE_TEXTURE:
if (!runner->heap)
runner->heap = create_gpu_descriptor_heap(device,
@ -150,18 +164,19 @@ static bool d3d12_runner_draw(struct shader_runner *r,
struct d3d12_shader_runner *runner = d3d12_shader_runner(r);
struct test_context *test_context = &runner->test_context;
D3D12_CPU_DESCRIPTOR_HANDLE rtvs[D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT] = {0};
ID3D12GraphicsCommandList *command_list = test_context->list;
D3D12_ROOT_SIGNATURE_DESC root_signature_desc = {0};
D3D12_GRAPHICS_PIPELINE_STATE_DESC pso_desc = {0};
D3D12_ROOT_PARAMETER root_params[3], *root_param;
ID3D12CommandQueue *queue = test_context->queue;
D3D12_INPUT_ELEMENT_DESC *input_element_descs;
D3D12_STATIC_SAMPLER_DESC static_samplers[1];
ID3D12Device *device = test_context->device;
D3D12_INPUT_LAYOUT_DESC input_layout;
static const float clear_color[4];
unsigned int uniform_index = 0;
ID3D10Blob *vs_code, *ps_code;
D3D12_SHADER_BYTECODE vs, ps;
unsigned int uniform_index;
unsigned int rtv_count = 0;
ID3D12PipelineState *pso;
HRESULT hr;
size_t i;
@ -185,6 +200,16 @@ static bool d3d12_runner_draw(struct shader_runner *r,
root_signature_desc.pStaticSamplers = static_samplers;
root_signature_desc.Flags = D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT;
pso_desc.VS.pShaderBytecode = ID3D10Blob_GetBufferPointer(vs_code);
pso_desc.VS.BytecodeLength = ID3D10Blob_GetBufferSize(vs_code);
pso_desc.PS.pShaderBytecode = ID3D10Blob_GetBufferPointer(ps_code);
pso_desc.PS.BytecodeLength = ID3D10Blob_GetBufferSize(ps_code);
pso_desc.RasterizerState.FillMode = D3D12_FILL_MODE_SOLID;
pso_desc.RasterizerState.CullMode = D3D12_CULL_MODE_BACK;
pso_desc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
pso_desc.SampleDesc.Count = 1;
pso_desc.SampleMask = ~(UINT)0;
if (runner->r.uniform_count)
{
uniform_index = root_signature_desc.NumParameters++;
@ -224,6 +249,12 @@ static bool d3d12_runner_draw(struct shader_runner *r,
range->OffsetInDescriptorsFromTableStart = 0;
break;
case RESOURCE_TYPE_RENDER_TARGET:
pso_desc.RTVFormats[resource->r.slot] = resource->r.format;
pso_desc.NumRenderTargets = max(pso_desc.NumRenderTargets, resource->r.slot + 1);
pso_desc.BlendState.RenderTarget[resource->r.slot].RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL;
break;
case RESOURCE_TYPE_VERTEX_BUFFER:
break;
}
@ -251,6 +282,8 @@ static bool d3d12_runner_draw(struct shader_runner *r,
hr = create_root_signature(device, &root_signature_desc, &test_context->root_signature);
ok(hr == S_OK, "Failed to create root signature, hr %#x.\n", hr);
pso_desc.pRootSignature = test_context->root_signature;
input_element_descs = calloc(runner->r.input_element_count, sizeof(*input_element_descs));
for (i = 0; i < runner->r.input_element_count; ++i)
{
@ -265,15 +298,12 @@ static bool d3d12_runner_draw(struct shader_runner *r,
desc->InputSlotClass = D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA;
}
input_layout.pInputElementDescs = input_element_descs;
input_layout.NumElements = runner->r.input_element_count;
pso_desc.InputLayout.pInputElementDescs = input_element_descs;
pso_desc.InputLayout.NumElements = runner->r.input_element_count;
vs.pShaderBytecode = ID3D10Blob_GetBufferPointer(vs_code);
vs.BytecodeLength = ID3D10Blob_GetBufferSize(vs_code);
ps.pShaderBytecode = ID3D10Blob_GetBufferPointer(ps_code);
ps.BytecodeLength = ID3D10Blob_GetBufferSize(ps_code);
pso = create_pipeline_state(device, test_context->root_signature,
test_context->render_target_desc.Format, &vs, &ps, &input_layout);
hr = ID3D12Device_CreateGraphicsPipelineState(device, &pso_desc,
&IID_ID3D12PipelineState, (void **)&pso);
ok(hr == S_OK, "Failed to create state, hr %#x.\n", hr);
ID3D10Blob_Release(vs_code);
ID3D10Blob_Release(ps_code);
free(input_element_descs);
@ -292,6 +322,13 @@ static bool d3d12_runner_draw(struct shader_runner *r,
switch (resource->r.type)
{
case RESOURCE_TYPE_RENDER_TARGET:
rtvs[resource->r.slot] = get_cpu_rtv_handle(test_context, runner->rtv_heap, resource->r.slot);
ID3D12GraphicsCommandList_ClearRenderTargetView(command_list,
rtvs[resource->r.slot], clear_color, 0, NULL);
rtv_count = max(rtv_count, resource->r.slot + 1);
break;
case RESOURCE_TYPE_TEXTURE:
ID3D12GraphicsCommandList_SetGraphicsRootDescriptorTable(command_list, resource->root_index,
get_gpu_descriptor_handle(test_context, runner->heap, resource->r.slot));
@ -312,11 +349,11 @@ static bool d3d12_runner_draw(struct shader_runner *r,
}
}
ID3D12GraphicsCommandList_OMSetRenderTargets(command_list, 1, &test_context->rtv, false, NULL);
ID3D12GraphicsCommandList_OMSetRenderTargets(command_list, rtv_count, rtvs, false, NULL);
ID3D12GraphicsCommandList_RSSetScissorRects(command_list, 1, &test_context->scissor_rect);
ID3D12GraphicsCommandList_RSSetViewports(command_list, 1, &test_context->viewport);
ID3D12GraphicsCommandList_IASetPrimitiveTopology(command_list, primitive_topology);
ID3D12GraphicsCommandList_ClearRenderTargetView(command_list, test_context->rtv, clear_color, 0, NULL);
ID3D12GraphicsCommandList_SetPipelineState(command_list, pso);
ID3D12GraphicsCommandList_DrawInstanced(command_list, vertex_count, 1, 0, 0);
@ -330,16 +367,22 @@ static bool d3d12_runner_draw(struct shader_runner *r,
return true;
}
static struct resource_readback *d3d12_runner_get_rt_readback(struct shader_runner *r)
static struct resource_readback *d3d12_runner_get_resource_readback(struct shader_runner *r, struct resource *res)
{
struct d3d12_shader_runner *runner = d3d12_shader_runner(r);
struct test_context *test_context = &runner->test_context;
struct d3d12_resource_readback *rb = malloc(sizeof(*rb));
struct d3d12_resource *resource = d3d12_resource(res);
transition_resource_state(test_context->list, test_context->render_target,
assert(resource->r.type == RESOURCE_TYPE_RENDER_TARGET);
transition_resource_state(test_context->list, resource->resource,
D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE);
get_texture_readback_with_command_list(test_context->render_target, 0, rb,
get_texture_readback_with_command_list(resource->resource, 0, rb,
test_context->queue, test_context->list);
reset_command_list(test_context->list, test_context->allocator);
transition_resource_state(test_context->list, resource->resource,
D3D12_RESOURCE_STATE_COPY_SOURCE, D3D12_RESOURCE_STATE_RENDER_TARGET);
return &rb->rb;
}
@ -347,13 +390,8 @@ static struct resource_readback *d3d12_runner_get_rt_readback(struct shader_runn
static void d3d12_runner_release_readback(struct shader_runner *r, struct resource_readback *rb)
{
struct d3d12_resource_readback *d3d12_rb = CONTAINING_RECORD(rb, struct d3d12_resource_readback, rb);
struct d3d12_shader_runner *runner = d3d12_shader_runner(r);
struct test_context *test_context = &runner->test_context;
release_resource_readback(d3d12_rb);
reset_command_list(test_context->list, test_context->allocator);
transition_resource_state(test_context->list, test_context->render_target,
D3D12_RESOURCE_STATE_COPY_SOURCE, D3D12_RESOURCE_STATE_RENDER_TARGET);
free(d3d12_rb);
}
@ -362,7 +400,7 @@ static const struct shader_runner_ops d3d12_runner_ops =
.create_resource = d3d12_runner_create_resource,
.destroy_resource = d3d12_runner_destroy_resource,
.draw = d3d12_runner_draw,
.get_rt_readback = d3d12_runner_get_rt_readback,
.get_resource_readback = d3d12_runner_get_resource_readback,
.release_readback = d3d12_runner_release_readback,
};
@ -386,5 +424,7 @@ void run_shader_tests_d3d12(int argc, char **argv)
if (runner.heap)
ID3D12DescriptorHeap_Release(runner.heap);
if (runner.rtv_heap)
ID3D12DescriptorHeap_Release(runner.rtv_heap);
destroy_test_context(&runner.test_context);
}

69
tests/shader_runner_d3d9.c
View File

@ -29,6 +29,7 @@ struct d3d9_resource
{
struct resource r;
IDirect3DSurface9 *surface;
IDirect3DTexture9 *texture;
IDirect3DVertexBuffer9 *vb;
};
@ -43,7 +44,6 @@ struct d3d9_shader_runner
struct shader_runner r;
IDirect3DDevice9 *device;
IDirect3DSurface9 *rt;
HWND window;
};
@ -151,18 +151,6 @@ static bool init_test_context(struct d3d9_shader_runner *runner)
return false;
}
if (FAILED(hr = IDirect3DDevice9_CreateRenderTarget(runner->device, RENDER_TARGET_WIDTH, RENDER_TARGET_HEIGHT,
D3DFMT_A32B32G32R32F, D3DMULTISAMPLE_NONE, 0, FALSE, &runner->rt, NULL)))
{
skip("Failed to create an A32B32G32R32F surface, hr %#lx.\n", hr);
IDirect3DDevice9_Release(runner->device);
DestroyWindow(runner->window);
return false;
}
ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
hr = IDirect3DDevice9_SetRenderTarget(runner->device, 0, runner->rt);
ok(hr == D3D_OK, "Failed to set render target, hr %#lx.\n", hr);
return true;
}
@ -170,7 +158,6 @@ static void destroy_test_context(struct d3d9_shader_runner *runner)
{
ULONG ref;
IDirect3DSurface9_Release(runner->rt);
ref = IDirect3DDevice9_Release(runner->device);
ok(!ref, "Device has %lu references left.\n", ref);
DestroyWindow(runner->window);
@ -224,24 +211,30 @@ static struct resource *d3d9_runner_create_resource(struct shader_runner *r, con
resource = calloc(1, sizeof(*resource));
init_resource(&resource->r, params);
switch (params->format)
{
case DXGI_FORMAT_R32G32B32A32_FLOAT:
format = D3DFMT_A32B32G32R32F;
break;
case DXGI_FORMAT_R32_FLOAT:
format = D3DFMT_R32F;
break;
default:
format = D3DFMT_UNKNOWN;
break;
}
switch (params->type)
{
case RESOURCE_TYPE_RENDER_TARGET:
hr = IDirect3DDevice9_CreateRenderTarget(device, params->width, params->height,
format, D3DMULTISAMPLE_NONE, 0, FALSE, &resource->surface, NULL);
ok(hr == D3D_OK, "Failed to create render target, hr %#lx.\n", hr);
break;
case RESOURCE_TYPE_TEXTURE:
switch (params->format)
{
case DXGI_FORMAT_R32G32B32A32_FLOAT:
format = D3DFMT_A32B32G32R32F;
break;
case DXGI_FORMAT_R32_FLOAT:
format = D3DFMT_R32F;
break;
default:
format = D3DFMT_UNKNOWN;
break;
}
hr = IDirect3DDevice9_CreateTexture(device, params->width, params->height,
1, D3DUSAGE_DYNAMIC, format, D3DPOOL_DEFAULT, &resource->texture, NULL);
ok(hr == D3D_OK, "Failed to create texture, hr %#lx.\n", hr);
@ -279,6 +272,8 @@ static void d3d9_runner_destroy_resource(struct shader_runner *r, struct resourc
{
struct d3d9_resource *resource = d3d9_resource(res);
if (resource->surface)
IDirect3DSurface9_Release(resource->surface);
if (resource->texture)
IDirect3DTexture9_Release(resource->texture);
if (resource->vb)
@ -363,6 +358,11 @@ static bool d3d9_runner_draw(struct shader_runner *r,
switch (resource->r.type)
{
case RESOURCE_TYPE_RENDER_TARGET:
hr = IDirect3DDevice9_SetRenderTarget(device, resource->r.slot, resource->surface);
ok(hr == D3D_OK, "Failed to set render target, hr %#lx.\n", hr);
break;
case RESOURCE_TYPE_TEXTURE:
hr = IDirect3DDevice9_SetTexture(device, resource->r.slot, (IDirect3DBaseTexture9 *)resource->texture);
ok(hr == D3D_OK, "Failed to set texture, hr %#lx.\n", hr);
@ -461,21 +461,24 @@ struct d3d9_resource_readback
IDirect3DSurface9 *surface;
};
static struct resource_readback *d3d9_runner_get_rt_readback(struct shader_runner *r)
static struct resource_readback *d3d9_runner_get_resource_readback(struct shader_runner *r, struct resource *res)
{
struct d3d9_shader_runner *runner = d3d9_shader_runner(r);
struct d3d9_resource_readback *rb = malloc(sizeof(*rb));
struct d3d9_resource *resource = d3d9_resource(res);
D3DLOCKED_RECT map_desc;
D3DSURFACE_DESC desc;
HRESULT hr;
hr = IDirect3DSurface9_GetDesc(runner->rt, &desc);
assert(resource->r.type == RESOURCE_TYPE_RENDER_TARGET);
hr = IDirect3DSurface9_GetDesc(resource->surface, &desc);
ok(hr == D3D_OK, "Failed to get surface desc, hr %#lx.\n", hr);
hr = IDirect3DDevice9Ex_CreateOffscreenPlainSurface(runner->device, desc.Width,
desc.Height, desc.Format, D3DPOOL_SYSTEMMEM, &rb->surface, NULL);
ok(hr == D3D_OK, "Failed to create surface, hr %#lx.\n", hr);
hr = IDirect3DDevice9Ex_GetRenderTargetData(runner->device, runner->rt, rb->surface);
hr = IDirect3DDevice9Ex_GetRenderTargetData(runner->device, resource->surface, rb->surface);
ok(hr == D3D_OK, "Failed to get render target data, hr %#lx.\n", hr);
hr = IDirect3DSurface9_LockRect(rb->surface, &map_desc, NULL, D3DLOCK_READONLY);
@ -504,7 +507,7 @@ static const struct shader_runner_ops d3d9_runner_ops =
.create_resource = d3d9_runner_create_resource,
.destroy_resource = d3d9_runner_destroy_resource,
.draw = d3d9_runner_draw,
.get_rt_readback = d3d9_runner_get_rt_readback,
.get_resource_readback = d3d9_runner_get_resource_readback,
.release_readback = d3d9_runner_release_readback,
};

133
tests/shader_runner_vulkan.c
View File

@ -60,10 +60,6 @@ struct vulkan_shader_runner
VkCommandBuffer cmd_buffer;
VkDescriptorPool descriptor_pool;
VkImage render_target;
VkDeviceMemory rt_memory;
VkImageView rtv;
struct vulkan_sampler
{
VkSampler vk_sampler;
@ -247,6 +243,19 @@ static struct resource *vulkan_runner_create_resource(struct shader_runner *r, c
switch (params->type)
{
case RESOURCE_TYPE_RENDER_TARGET:
format = vkd3d_get_vk_format(params->format);
resource->image = create_2d_image(runner, params->width, params->height,
VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, format, &resource->memory);
resource->view = create_2d_image_view(runner, resource->image, format);
begin_command_buffer(runner);
transition_image_layout(runner, resource->image,
VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
end_command_buffer(runner);
break;
case RESOURCE_TYPE_TEXTURE:
case RESOURCE_TYPE_UAV:
{
@ -385,6 +394,7 @@ static bool compile_shader(const struct vulkan_shader_runner *runner, const char
switch (resource->r.type)
{
case RESOURCE_TYPE_RENDER_TARGET:
case RESOURCE_TYPE_VERTEX_BUFFER:
break;
@ -514,7 +524,7 @@ static VkPipeline create_pipeline(const struct vulkan_shader_runner *runner, VkR
VkPipelineViewportStateCreateInfo vp_desc = {.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO};
static const VkRect2D rt_rect = {.extent.width = RENDER_TARGET_WIDTH, .extent.height = RENDER_TARGET_HEIGHT};
VkGraphicsPipelineCreateInfo pipeline_desc = {.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO};
VkPipelineColorBlendAttachmentState attachment_desc = {0};
VkPipelineColorBlendAttachmentState attachment_desc[MAX_RESOURCES] = {0};
VkVertexInputAttributeDescription input_attributes[32];
VkVertexInputBindingDescription input_bindings[32];
struct vkd3d_shader_signature vs_input_signature;
@ -560,6 +570,9 @@ static VkPipeline create_pipeline(const struct vulkan_shader_runner *runner, VkR
input_desc.pVertexAttributeDescriptions = input_attributes;
input_desc.pVertexBindingDescriptions = input_bindings;
blend_desc.attachmentCount = 0;
blend_desc.pAttachments = attachment_desc;
for (i = 0; i < runner->r.resource_count; ++i)
{
const struct vulkan_resource *resource = vulkan_resource(runner->r.resources[i]);
@ -570,6 +583,12 @@ static VkPipeline create_pipeline(const struct vulkan_shader_runner *runner, VkR
case RESOURCE_TYPE_UAV:
break;
case RESOURCE_TYPE_RENDER_TARGET:
attachment_desc[blend_desc.attachmentCount++].colorWriteMask =
VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT
| VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
break;
case RESOURCE_TYPE_VERTEX_BUFFER:
{
VkVertexInputBindingDescription *binding = &input_bindings[input_desc.vertexBindingDescriptionCount++];
@ -603,12 +622,6 @@ static VkPipeline create_pipeline(const struct vulkan_shader_runner *runner, VkR
ms_desc.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
blend_desc.attachmentCount = 1;
blend_desc.pAttachments = &attachment_desc;
attachment_desc.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT
| VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
pipeline_desc.stageCount = ARRAY_SIZE(stage_desc);
pipeline_desc.pStages = stage_desc;
pipeline_desc.pVertexInputState = &input_desc;
@ -669,6 +682,7 @@ static VkDescriptorSetLayout create_descriptor_set_layout(struct vulkan_shader_r
switch (resource->r.type)
{
case RESOURCE_TYPE_RENDER_TARGET:
case RESOURCE_TYPE_VERTEX_BUFFER:
break;
@ -768,6 +782,9 @@ static void bind_resources(struct vulkan_shader_runner *runner, VkPipelineBindPo
if (bind_point == VK_PIPELINE_BIND_POINT_GRAPHICS)
VK_CALL(vkCmdBindVertexBuffers(cmd_buffer, resource->r.slot, 1, &resource->buffer, &zero_offset));
break;
case RESOURCE_TYPE_RENDER_TARGET:
break;
}
}
@ -785,36 +802,53 @@ static void create_render_pass_and_framebuffer(struct vulkan_shader_runner *runn
{
VkRenderPassCreateInfo render_pass_desc = {.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO};
VkFramebufferCreateInfo fb_desc = {.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO};
VkAttachmentDescription attachment_desc = {0};
VkAttachmentDescription attachment_descs[MAX_RESOURCES] = {0};
VkAttachmentReference color_refs[MAX_RESOURCES] = {0};
VkSubpassDescription subpass_desc = {0};
VkAttachmentReference color_ref = {0};
VkImageView rtvs[MAX_RESOURCES];
unsigned int rt_count = 0;
unsigned int i;
attachment_desc.format = VK_FORMAT_R32G32B32A32_SFLOAT;
attachment_desc.samples = VK_SAMPLE_COUNT_1_BIT;
attachment_desc.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
attachment_desc.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
attachment_desc.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
attachment_desc.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attachment_desc.initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
attachment_desc.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
for (i = 0; i < runner->r.resource_count; ++i)
{
const struct vulkan_resource *resource = vulkan_resource(runner->r.resources[i]);
VkAttachmentDescription *attachment_desc = &attachment_descs[rt_count];
VkAttachmentReference *color_ref = &color_refs[rt_count];
color_ref.attachment = 0;
color_ref.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
if (resource->r.type != RESOURCE_TYPE_RENDER_TARGET)
continue;
attachment_desc->format = vkd3d_get_vk_format(resource->r.format);
attachment_desc->samples = VK_SAMPLE_COUNT_1_BIT;
attachment_desc->loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
attachment_desc->storeOp = VK_ATTACHMENT_STORE_OP_STORE;
attachment_desc->stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
attachment_desc->stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attachment_desc->initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
attachment_desc->finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
color_ref->attachment = rt_count;
color_ref->layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
rtvs[rt_count] = resource->view;
++rt_count;
}
subpass_desc.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass_desc.colorAttachmentCount = 1;
subpass_desc.pColorAttachments = &color_ref;
subpass_desc.colorAttachmentCount = rt_count;
subpass_desc.pColorAttachments = color_refs;
render_pass_desc.attachmentCount = 1;
render_pass_desc.pAttachments = &attachment_desc;
render_pass_desc.attachmentCount = rt_count;
render_pass_desc.pAttachments = attachment_descs;
render_pass_desc.subpassCount = 1;
render_pass_desc.pSubpasses = &subpass_desc;
VK_CALL(vkCreateRenderPass(runner->device, &render_pass_desc, NULL, render_pass));
fb_desc.renderPass = *render_pass;
fb_desc.attachmentCount = 1;
fb_desc.pAttachments = &runner->rtv;
fb_desc.attachmentCount = rt_count;
fb_desc.pAttachments = rtvs;
fb_desc.width = RENDER_TARGET_WIDTH;
fb_desc.height = RENDER_TARGET_HEIGHT;
fb_desc.layers = 1;
@ -902,37 +936,40 @@ struct vulkan_resource_readback
VkBuffer buffer;
};
static struct resource_readback *vulkan_runner_get_rt_readback(struct shader_runner *r)
static struct resource_readback *vulkan_runner_get_resource_readback(struct shader_runner *r, struct resource *res)
{
struct vulkan_shader_runner *runner = vulkan_shader_runner(r);
struct vulkan_resource_readback *rb = malloc(sizeof(*rb));
struct vulkan_resource *resource = vulkan_resource(res);
VkDevice device = runner->device;
VkBufferImageCopy region = {0};
rb->rb.width = RENDER_TARGET_WIDTH;
rb->rb.height = RENDER_TARGET_HEIGHT;
assert(resource->r.type == RESOURCE_TYPE_RENDER_TARGET);
rb->rb.width = resource->r.width;
rb->rb.height = resource->r.height;
rb->rb.depth = 1;
rb->rb.row_pitch = rb->rb.width * sizeof(struct vec4);
rb->rb.row_pitch = rb->rb.width * resource->r.texel_size;
rb->buffer = create_buffer(runner, rb->rb.row_pitch * RENDER_TARGET_HEIGHT,
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);
begin_command_buffer(runner);
transition_image_layout(runner, runner->render_target,
transition_image_layout(runner, resource->image,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
region.imageSubresource.layerCount = 1;
region.imageExtent.width = RENDER_TARGET_WIDTH;
region.imageExtent.height = RENDER_TARGET_HEIGHT;
region.imageExtent.width = resource->r.width;
region.imageExtent.height = resource->r.height;
region.imageExtent.depth = 1;
VK_CALL(vkCmdCopyImageToBuffer(runner->cmd_buffer, runner->render_target,
VK_CALL(vkCmdCopyImageToBuffer(runner->cmd_buffer, resource->image,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, rb->buffer, 1, &region));
transition_image_layout(runner, runner->render_target,
transition_image_layout(runner, resource->image,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
end_command_buffer(runner);
@ -959,7 +996,7 @@ static const struct shader_runner_ops vulkan_runner_ops =
.create_resource = vulkan_runner_create_resource,
.destroy_resource = vulkan_runner_destroy_resource,
.draw = vulkan_runner_draw,
.get_rt_readback = vulkan_runner_get_rt_readback,
.get_resource_readback = vulkan_runner_get_resource_readback,
.release_readback = vulkan_runner_release_readback,
};
@ -1141,11 +1178,6 @@ static bool init_vulkan_runner(struct vulkan_shader_runner *runner)
VK_CALL(vkAllocateCommandBuffers(device, &cmd_buffer_desc, &runner->cmd_buffer));
runner->render_target = create_2d_image(runner, RENDER_TARGET_WIDTH, RENDER_TARGET_HEIGHT,
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
VK_FORMAT_R32G32B32A32_SFLOAT, &runner->rt_memory);
runner->rtv = create_2d_image_view(runner, runner->render_target, VK_FORMAT_R32G32B32A32_SFLOAT);
descriptor_pool_sizes[0].type = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
descriptor_pool_sizes[0].descriptorCount = MAX_RESOURCES;
descriptor_pool_sizes[1].type = VK_DESCRIPTOR_TYPE_SAMPLER;
@ -1159,13 +1191,6 @@ static bool init_vulkan_runner(struct vulkan_shader_runner *runner)
VK_CALL(vkCreateDescriptorPool(device, &descriptor_pool_desc, NULL, &runner->descriptor_pool));
begin_command_buffer(runner);
transition_image_layout(runner, runner->render_target,
VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
end_command_buffer(runner);
return true;
out_destroy_instance:
@ -1177,10 +1202,6 @@ static void cleanup_vulkan_runner(struct vulkan_shader_runner *runner)
{
VkDevice device = runner->device;
VK_CALL(vkFreeMemory(device, runner->rt_memory, NULL));
VK_CALL(vkDestroyImageView(device, runner->rtv, NULL));
VK_CALL(vkDestroyImage(device, runner->render_target, NULL));
VK_CALL(vkDestroyDescriptorPool(device, runner->descriptor_pool, NULL));
VK_CALL(vkFreeCommandBuffers(device, runner->command_pool, 1, &runner->cmd_buffer));
VK_CALL(vkDestroyCommandPool(device, runner->command_pool, NULL));