From: Conor McCarthy cmccarthy@codeweavers.com
--- Makefile.am | 1 + tests/d3d12_test_utils.h | 6 ++ tests/hlsl/depth-out.shader_test | 29 ++++++ tests/shader_runner.c | 106 +++++++++++++------ tests/shader_runner.h | 6 ++ tests/shader_runner_d3d11.c | 20 +++- tests/shader_runner_d3d12.c | 39 ++++++- tests/shader_runner_d3d9.c | 7 ++ tests/shader_runner_gl.c | 10 ++ tests/shader_runner_vulkan.c | 171 +++++++++++++++++++++---------- 10 files changed, 305 insertions(+), 90 deletions(-) create mode 100644 tests/hlsl/depth-out.shader_test
diff --git a/Makefile.am b/Makefile.am index 39b041502..83de64cdc 100644 --- a/Makefile.am +++ b/Makefile.am @@ -86,6 +86,7 @@ vkd3d_shader_tests = \ tests/hlsl/cross.shader_test \ tests/hlsl/d3dcolor-to-ubyte4.shader_test \ tests/hlsl/ddxddy.shader_test \ + tests/hlsl/depth-out.shader_test \ tests/hlsl/determinant.shader_test \ tests/hlsl/discard.shader_test \ tests/hlsl/distance.shader_test \ diff --git a/tests/d3d12_test_utils.h b/tests/d3d12_test_utils.h index 4fe6fa716..60512aec6 100644 --- a/tests/d3d12_test_utils.h +++ b/tests/d3d12_test_utils.h @@ -1245,6 +1245,12 @@ static inline D3D12_CPU_DESCRIPTOR_HANDLE get_cpu_rtv_handle(struct test_context return get_cpu_handle(context->device, heap, D3D12_DESCRIPTOR_HEAP_TYPE_RTV, offset); }
+static inline D3D12_CPU_DESCRIPTOR_HANDLE get_cpu_dsv_handle(struct test_context *context, + ID3D12DescriptorHeap *heap, unsigned int offset) +{ + return get_cpu_handle(context->device, heap, D3D12_DESCRIPTOR_HEAP_TYPE_DSV, offset); +} + static inline D3D12_GPU_DESCRIPTOR_HANDLE get_gpu_descriptor_handle(struct test_context *context, ID3D12DescriptorHeap *heap, unsigned int offset) { diff --git a/tests/hlsl/depth-out.shader_test b/tests/hlsl/depth-out.shader_test new file mode 100644 index 000000000..6c76b307b --- /dev/null +++ b/tests/hlsl/depth-out.shader_test @@ -0,0 +1,29 @@ +[require] +shader model >= 4.0 +dsv + +[dsv] +size (2d, 640, 480) + +[pixel shader] +float depth; + +float main() : SV_Depth +{ + return depth; +} + +[test] +uniform 0 float 0.0 +clear dsv 1.0 +todo(sm>=6) draw quad depth less +probe dsv all r (0.0) +uniform 0 float 0.75 +clear dsv 1.0 +todo(sm>=6) draw quad depth less +probe dsv all r (0.75) +clear dsv 0.5 +todo(sm>=6) draw quad depth greater +probe dsv all r (0.75) +todo(sm>=6) draw quad depth less +probe dsv all r (0.5) diff --git a/tests/shader_runner.c b/tests/shader_runner.c index f800ded32..b825fd7cb 100644 --- a/tests/shader_runner.c +++ b/tests/shader_runner.c @@ -333,6 +333,10 @@ static void parse_require_directive(struct shader_runner *runner, const char *li { runner->require_rov = true; } + else if (match_string(line, "dsv", &line)) + { + runner->require_dsv = true; + } else { fatal_error("Unknown require directive '%s'.\n", line); @@ -381,6 +385,35 @@ static DXGI_FORMAT parse_format(const char *line, enum texture_data_type *data_t fatal_error("Unknown format '%s'.\n", line); }
+static D3D12_COMPARISON_FUNC parse_comparison_func(const char *line) +{ + static const struct + { + const char *string; + D3D12_COMPARISON_FUNC func; + } + funcs[] = + { + {"less equal", D3D12_COMPARISON_FUNC_LESS_EQUAL}, + {"not equal", D3D12_COMPARISON_FUNC_NOT_EQUAL}, + {"greater equal", D3D12_COMPARISON_FUNC_GREATER_EQUAL}, + {"never", D3D12_COMPARISON_FUNC_NEVER}, + {"less", D3D12_COMPARISON_FUNC_LESS}, + {"equal", D3D12_COMPARISON_FUNC_EQUAL}, + {"greater", D3D12_COMPARISON_FUNC_GREATER}, + {"always", D3D12_COMPARISON_FUNC_ALWAYS}, + }; + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(funcs); ++i) + { + if (match_string(line, funcs[i].string, &line)) + return funcs[i].func; + } + + fatal_error("Unknown comparison func '%s'.\n", line); +} + static D3D12_TEXTURE_ADDRESS_MODE parse_sampler_address_mode(const char *line, const char **rest) { if (match_string(line, "border", rest)) @@ -440,35 +473,9 @@ static void parse_sampler_directive(struct sampler *sampler, const char *line) } else if (match_string(line, "comparison", &line)) { - static const struct - { - const char *string; - D3D12_COMPARISON_FUNC func; - } - funcs[] = - { - {"less equal", D3D12_COMPARISON_FUNC_LESS_EQUAL}, - {"not equal", D3D12_COMPARISON_FUNC_NOT_EQUAL}, - {"greater equal", D3D12_COMPARISON_FUNC_GREATER_EQUAL}, - {"never", D3D12_COMPARISON_FUNC_NEVER}, - {"less", D3D12_COMPARISON_FUNC_LESS}, - {"equal", D3D12_COMPARISON_FUNC_EQUAL}, - {"greater", D3D12_COMPARISON_FUNC_GREATER}, - {"always", D3D12_COMPARISON_FUNC_ALWAYS}, - }; - unsigned int i; - - for (i = 0; i < ARRAY_SIZE(funcs); ++i) - { - if (match_string(line, funcs[i].string, &line)) - { - sampler->filter |= D3D12_FILTER_REDUCTION_TYPE_COMPARISON << D3D12_FILTER_REDUCTION_TYPE_SHIFT; - sampler->func = funcs[i].func; - return; - } - } - - fatal_error("Unknown sampler func '%s'.\n", line); + sampler->filter |= D3D12_FILTER_REDUCTION_TYPE_COMPARISON << D3D12_FILTER_REDUCTION_TYPE_SHIFT; + sampler->func = parse_comparison_func(line); + return; } else { @@ -618,6 +625,12 @@ struct resource *shader_runner_get_resource(struct shader_runner *runner, enum r return NULL; }
+static bool shader_runner_has_target(struct shader_runner *runner) +{ + return shader_runner_get_resource(runner, RESOURCE_TYPE_RENDER_TARGET, 0) + || shader_runner_get_resource(runner, RESOURCE_TYPE_DEPTH_STENCIL_TARGET, 0); +} + static void set_resource(struct shader_runner *runner, struct resource *resource) { size_t i; @@ -798,6 +811,15 @@ static void parse_test_directive(struct shader_runner *runner, const char *line)
runner->last_render_failed = !runner->ops->dispatch(runner, x, y, z); } + else if (match_string(line, "clear dsv", &line)) + { + float f; + + ret = sscanf(line, "%f", &f); + if (!ret) + fatal_error("Malformed dispatch arguments '%s'.\n", line); + runner->dsv_clear_value = f; + } else if (match_string(line, "draw quad", &line)) { struct resource_params params; @@ -818,7 +840,7 @@ static void parse_test_directive(struct shader_runner *runner, const char *line) " return pos;\n" "}";
- if (!shader_runner_get_resource(runner, RESOURCE_TYPE_RENDER_TARGET, 0)) + if (!shader_runner_has_target(runner)) { memset(¶ms, 0, sizeof(params)); params.slot = 0; @@ -834,6 +856,9 @@ static void parse_test_directive(struct shader_runner *runner, const char *line) set_resource(runner, runner->ops->create_resource(runner, ¶ms)); }
+ if (match_string(line, "depth", &line)) + runner->comparison = parse_comparison_func(line); + for (i = 0; i < runner->input_element_count; ++i) free(runner->input_elements[i].name);
@@ -868,7 +893,7 @@ static void parse_test_directive(struct shader_runner *runner, const char *line) struct resource_params params; unsigned int vertex_count;
- if (!shader_runner_get_resource(runner, RESOURCE_TYPE_RENDER_TARGET, 0)) + if (!shader_runner_has_target(runner)) { memset(¶ms, 0, sizeof(params)); params.slot = 0; @@ -929,6 +954,10 @@ static void parse_test_directive(struct shader_runner *runner, const char *line)
resource = shader_runner_get_resource(runner, RESOURCE_TYPE_RENDER_TARGET, slot); } + else if (match_string(line, "dsv", &line)) + { + resource = shader_runner_get_resource(runner, RESOURCE_TYPE_DEPTH_STENCIL_TARGET, 0); + } else { resource = shader_runner_get_resource(runner, RESOURCE_TYPE_RENDER_TARGET, 0); @@ -1442,6 +1471,8 @@ static bool check_requirements(const struct shader_runner *runner, const struct return false; if (runner->require_rov && !caps->rov) return false; + if (runner->require_dsv && !caps->dsv) + return false;
return true; } @@ -1734,6 +1765,19 @@ void run_shader_tests(struct shader_runner *runner, const struct shader_runner_c current_resource.texel_size = 16; current_resource.level_count = 1; } + else if (!strcmp(line, "[dsv]\n")) + { + state = STATE_RESOURCE; + + memset(¤t_resource, 0, sizeof(current_resource)); + + current_resource.slot = 0; + current_resource.type = RESOURCE_TYPE_DEPTH_STENCIL_TARGET; + current_resource.format = DXGI_FORMAT_D32_FLOAT; + current_resource.data_type = TEXTURE_DATA_FLOAT; + current_resource.texel_size = 4; + current_resource.level_count = 1; + } else if (sscanf(line, "[srv %u]\n", &index)) { state = STATE_RESOURCE; diff --git a/tests/shader_runner.h b/tests/shader_runner.h index 2f7e8fb25..9e2850098 100644 --- a/tests/shader_runner.h +++ b/tests/shader_runner.h @@ -69,6 +69,7 @@ struct sampler enum resource_type { RESOURCE_TYPE_RENDER_TARGET, + RESOURCE_TYPE_DEPTH_STENCIL_TARGET, RESOURCE_TYPE_TEXTURE, RESOURCE_TYPE_UAV, RESOURCE_TYPE_VERTEX_BUFFER, @@ -132,6 +133,7 @@ struct shader_runner_caps bool float64; bool int64; bool rov; + bool dsv; };
static inline unsigned int shader_runner_caps_get_feature_flags(const struct shader_runner_caps *caps) @@ -162,6 +164,7 @@ struct shader_runner bool require_float64; bool require_int64; bool require_rov; + bool require_dsv;
bool last_render_failed;
@@ -178,6 +181,9 @@ struct shader_runner size_t input_element_count, input_element_capacity;
unsigned int compile_options; + + float dsv_clear_value; + D3D12_COMPARISON_FUNC comparison; };
struct shader_runner_ops diff --git a/tests/shader_runner_d3d11.c b/tests/shader_runner_d3d11.c index 1285ca41f..5c357ffa2 100644 --- a/tests/shader_runner_d3d11.c +++ b/tests/shader_runner_d3d11.c @@ -47,6 +47,7 @@ struct d3d11_resource ID3D11Buffer *buffer; ID3D11Texture2D *texture; ID3D11RenderTargetView *rtv; + ID3D11DepthStencilView *dsv; ID3D11ShaderResourceView *srv; ID3D11UnorderedAccessView *uav; bool is_uav_counter; @@ -284,6 +285,8 @@ static BOOL init_test_context(struct d3d11_shader_runner *runner) ok(hr == S_OK, "Got hr %#lx.\n", hr); runner->caps.rov = options2.ROVsSupported;
+ runner->caps.dsv = true; + rt_width = RENDER_TARGET_WIDTH; rt_height = RENDER_TARGET_HEIGHT; SetRect(&rect, 0, 0, rt_width, rt_height); @@ -377,6 +380,8 @@ static void init_resource_2d(struct d3d11_shader_runner *runner, struct d3d11_re desc.BindFlags = D3D11_BIND_UNORDERED_ACCESS; else if (params->type == RESOURCE_TYPE_RENDER_TARGET) desc.BindFlags = D3D11_BIND_RENDER_TARGET; + else if (params->type == RESOURCE_TYPE_DEPTH_STENCIL_TARGET) + desc.BindFlags = D3D11_BIND_DEPTH_STENCIL; else desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
@@ -407,6 +412,8 @@ static void init_resource_2d(struct d3d11_shader_runner *runner, struct d3d11_re 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 if (params->type == RESOURCE_TYPE_DEPTH_STENCIL_TARGET) + 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); @@ -462,6 +469,7 @@ static struct resource *d3d11_runner_create_resource(struct shader_runner *r, co switch (params->type) { case RESOURCE_TYPE_RENDER_TARGET: + case RESOURCE_TYPE_DEPTH_STENCIL_TARGET: case RESOURCE_TYPE_TEXTURE: if (params->dimension == RESOURCE_DIMENSION_BUFFER) init_resource_srv_buffer(runner, resource, params); @@ -492,6 +500,8 @@ static void d3d11_runner_destroy_resource(struct shader_runner *r, struct resour ID3D11Resource_Release(resource->resource); if (resource->rtv) ID3D11RenderTargetView_Release(resource->rtv); + if (resource->dsv) + ID3D11DepthStencilView_Release(resource->dsv); if (resource->srv) ID3D11ShaderResourceView_Release(resource->srv); if (resource->uav) @@ -561,6 +571,7 @@ static bool d3d11_runner_dispatch(struct shader_runner *r, unsigned int x, unsig break;
case RESOURCE_TYPE_RENDER_TARGET: + case RESOURCE_TYPE_DEPTH_STENCIL_TARGET: case RESOURCE_TYPE_VERTEX_BUFFER: break; } @@ -593,6 +604,7 @@ static bool d3d11_runner_draw(struct shader_runner *r, ID3D11DeviceContext *context = runner->immediate_context; unsigned int min_uav_slot = ARRAY_SIZE(uavs); ID3D11Device *device = runner->device; + ID3D11DepthStencilView *dsv = NULL; ID3D10Blob *vs_code, *ps_code; unsigned int rtv_count = 0; ID3D11Buffer *cb = NULL; @@ -639,6 +651,11 @@ static bool d3d11_runner_draw(struct shader_runner *r, rtv_count = max(rtv_count, resource->r.slot + 1); break;
+ case RESOURCE_TYPE_DEPTH_STENCIL_TARGET: + dsv = resource->dsv; + ID3D11DeviceContext_ClearDepthStencilView(context, dsv, D3D11_CLEAR_DEPTH, 1.0f, 0); + break; + case RESOURCE_TYPE_TEXTURE: ID3D11DeviceContext_PSSetShaderResources(context, resource->r.slot, 1, &resource->srv); break; @@ -655,7 +672,7 @@ static bool d3d11_runner_draw(struct shader_runner *r, } }
- ID3D11DeviceContext_OMSetRenderTargetsAndUnorderedAccessViews(context, rtv_count, rtvs, NULL, + ID3D11DeviceContext_OMSetRenderTargetsAndUnorderedAccessViews(context, rtv_count, rtvs, dsv, min_uav_slot, ARRAY_SIZE(uavs) - min_uav_slot, &uavs[min_uav_slot], NULL);
for (i = 0; i < runner->r.sampler_count; ++i) @@ -728,6 +745,7 @@ static struct resource_readback *d3d11_runner_get_resource_readback(struct shade switch (resource->r.type) { case RESOURCE_TYPE_RENDER_TARGET: + case RESOURCE_TYPE_DEPTH_STENCIL_TARGET: case RESOURCE_TYPE_UAV: if (resource->r.dimension == RESOURCE_DIMENSION_BUFFER) { diff --git a/tests/shader_runner_d3d12.c b/tests/shader_runner_d3d12.c index 9bf7bb248..e30063292 100644 --- a/tests/shader_runner_d3d12.c +++ b/tests/shader_runner_d3d12.c @@ -46,7 +46,7 @@ struct d3d12_shader_runner
struct test_context test_context;
- ID3D12DescriptorHeap *heap, *rtv_heap; + ID3D12DescriptorHeap *heap, *rtv_heap, *dsv_heap;
ID3D12CommandQueue *compute_queue; ID3D12CommandAllocator *compute_allocator; @@ -142,6 +142,19 @@ static struct resource *d3d12_runner_create_resource(struct shader_runner *r, co NULL, get_cpu_rtv_handle(test_context, runner->rtv_heap, resource->r.slot)); break;
+ case RESOURCE_TYPE_DEPTH_STENCIL_TARGET: + if (!runner->dsv_heap) + runner->dsv_heap = create_cpu_descriptor_heap(device, D3D12_DESCRIPTOR_HEAP_TYPE_DSV, 1); + + if (params->slot) + fatal_error("Non-zero DSV slot %u is invalid.\n", params->slot); + + resource->resource = create_default_texture2d(device, params->width, params->height, 1, params->level_count, + params->format, D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL, D3D12_RESOURCE_STATE_DEPTH_WRITE); + ID3D12Device_CreateDepthStencilView(device, resource->resource, + NULL, get_cpu_dsv_handle(test_context, runner->dsv_heap, 0)); + break; + case RESOURCE_TYPE_TEXTURE: if (!runner->heap) runner->heap = create_gpu_descriptor_heap(device, @@ -309,6 +322,7 @@ static ID3D12RootSignature *d3d12_runner_create_root_signature(struct d3d12_shad break;
case RESOURCE_TYPE_RENDER_TARGET: + case RESOURCE_TYPE_DEPTH_STENCIL_TARGET: case RESOURCE_TYPE_VERTEX_BUFFER: break; } @@ -406,6 +420,7 @@ static bool d3d12_runner_dispatch(struct shader_runner *r, unsigned int x, unsig break;
case RESOURCE_TYPE_RENDER_TARGET: + case RESOURCE_TYPE_DEPTH_STENCIL_TARGET: case RESOURCE_TYPE_VERTEX_BUFFER: break; } @@ -439,6 +454,7 @@ static bool d3d12_runner_draw(struct shader_runner *r, ID3D12CommandQueue *queue = test_context->queue; D3D12_INPUT_ELEMENT_DESC *input_element_descs; ID3D12Device *device = test_context->device; + D3D12_CPU_DESCRIPTOR_HANDLE dsv = {0}; ID3D10Blob *vs_code, *ps_code; unsigned int uniform_index; unsigned int rtv_count = 0; @@ -475,6 +491,14 @@ static bool d3d12_runner_draw(struct shader_runner *r, pso_desc.NumRenderTargets = max(pso_desc.NumRenderTargets, resource->r.slot + 1); pso_desc.BlendState.RenderTarget[resource->r.slot].RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL; } + else if (resource->r.type == RESOURCE_TYPE_DEPTH_STENCIL_TARGET) + { + assert(!resource->r.slot); + pso_desc.DSVFormat = resource->r.format; + pso_desc.DepthStencilState.DepthEnable = true; + pso_desc.DepthStencilState.DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL; + pso_desc.DepthStencilState.DepthFunc = runner->r.comparison; + } }
pso_desc.VS.pShaderBytecode = ID3D10Blob_GetBufferPointer(vs_code); @@ -535,6 +559,12 @@ static bool d3d12_runner_draw(struct shader_runner *r, rtv_count = max(rtv_count, resource->r.slot + 1); break;
+ case RESOURCE_TYPE_DEPTH_STENCIL_TARGET: + dsv = get_cpu_dsv_handle(test_context, runner->dsv_heap, 0); + ID3D12GraphicsCommandList_ClearDepthStencilView(command_list, dsv, + D3D12_CLEAR_FLAG_DEPTH, runner->r.dsv_clear_value, 0, 0, NULL); + break; + case RESOURCE_TYPE_TEXTURE: if (resource->descriptor_range.NumDescriptors) ID3D12GraphicsCommandList_SetGraphicsRootDescriptorTable(command_list, resource->root_index, @@ -557,7 +587,7 @@ static bool d3d12_runner_draw(struct shader_runner *r, } }
- ID3D12GraphicsCommandList_OMSetRenderTargets(command_list, rtv_count, rtvs, false, NULL); + ID3D12GraphicsCommandList_OMSetRenderTargets(command_list, rtv_count, rtvs, false, dsv.ptr ? &dsv : NULL);
ID3D12GraphicsCommandList_RSSetScissorRects(command_list, 1, &test_context->scissor_rect); ID3D12GraphicsCommandList_RSSetViewports(command_list, 1, &test_context->viewport); @@ -585,6 +615,8 @@ static struct resource_readback *d3d12_runner_get_resource_readback(struct shade
if (resource->r.type == RESOURCE_TYPE_RENDER_TARGET) state = D3D12_RESOURCE_STATE_RENDER_TARGET; + else if (resource->r.type == RESOURCE_TYPE_DEPTH_STENCIL_TARGET) + state = D3D12_RESOURCE_STATE_DEPTH_WRITE; else state = D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
@@ -635,6 +667,7 @@ static void d3d12_runner_init_caps(struct d3d12_shader_runner *runner) runner->caps.float64 = options.DoublePrecisionFloatShaderOps; runner->caps.int64 = options1.Int64ShaderOps; runner->caps.rov = options.ROVsSupported; + runner->caps.dsv = true; }
void run_shader_tests_d3d12(void *dxc_compiler) @@ -686,5 +719,7 @@ void run_shader_tests_d3d12(void *dxc_compiler) ID3D12DescriptorHeap_Release(runner.heap); if (runner.rtv_heap) ID3D12DescriptorHeap_Release(runner.rtv_heap); + if (runner.dsv_heap) + ID3D12DescriptorHeap_Release(runner.dsv_heap); destroy_test_context(&runner.test_context); } diff --git a/tests/shader_runner_d3d9.c b/tests/shader_runner_d3d9.c index e4e1c6435..b7e9de7d4 100644 --- a/tests/shader_runner_d3d9.c +++ b/tests/shader_runner_d3d9.c @@ -224,6 +224,10 @@ static struct resource *d3d9_runner_create_resource(struct shader_runner *r, con ok(hr == D3D_OK, "Failed to create render target, hr %#lx.\n", hr); break;
+ case RESOURCE_TYPE_DEPTH_STENCIL_TARGET: + fatal_error("DSVs are not supported.\n"); + break; + case RESOURCE_TYPE_TEXTURE: { if (params->dimension == RESOURCE_DIMENSION_BUFFER) @@ -382,6 +386,9 @@ static bool d3d9_runner_draw(struct shader_runner *r, ok(hr == D3D_OK, "Failed to set render target, hr %#lx.\n", hr); break;
+ case RESOURCE_TYPE_DEPTH_STENCIL_TARGET: + vkd3d_unreachable(); + case RESOURCE_TYPE_TEXTURE: assert(resource->r.dimension != RESOURCE_DIMENSION_BUFFER);
diff --git a/tests/shader_runner_gl.c b/tests/shader_runner_gl.c index 2045950e3..3c4ec52c9 100644 --- a/tests/shader_runner_gl.c +++ b/tests/shader_runner_gl.c @@ -402,6 +402,9 @@ static struct resource *gl_runner_create_resource(struct shader_runner *r, const init_resource_2d(resource, params); break;
+ case RESOURCE_TYPE_DEPTH_STENCIL_TARGET: + vkd3d_unreachable(); + case RESOURCE_TYPE_VERTEX_BUFFER: glGenBuffers(1, &resource->id); glBindBuffer(GL_ARRAY_BUFFER, resource->id); @@ -432,6 +435,9 @@ static void gl_runner_destroy_resource(struct shader_runner *r, struct resource } break;
+ case RESOURCE_TYPE_DEPTH_STENCIL_TARGET: + vkd3d_unreachable(); + case RESOURCE_TYPE_VERTEX_BUFFER: glDeleteBuffers(1, &resource->id); break; @@ -705,6 +711,7 @@ static bool gl_runner_dispatch(struct shader_runner *r, unsigned int x, unsigned switch (resource->r.type) { case RESOURCE_TYPE_RENDER_TARGET: + case RESOURCE_TYPE_DEPTH_STENCIL_TARGET: case RESOURCE_TYPE_VERTEX_BUFFER: case RESOURCE_TYPE_TEXTURE: break; @@ -997,6 +1004,9 @@ static bool gl_runner_draw(struct shader_runner *r, rt_count = resource->r.slot + 1; break;
+ case RESOURCE_TYPE_DEPTH_STENCIL_TARGET: + vkd3d_unreachable(); + case RESOURCE_TYPE_TEXTURE: break;
diff --git a/tests/shader_runner_vulkan.c b/tests/shader_runner_vulkan.c index a3bbf170c..4950f4846 100644 --- a/tests/shader_runner_vulkan.c +++ b/tests/shader_runner_vulkan.c @@ -118,7 +118,7 @@ static void end_command_buffer(struct vulkan_shader_runner *runner) }
static void transition_image_layout(struct vulkan_shader_runner *runner, - VkImage image, VkImageLayout src_layout, VkImageLayout dst_layout) + VkImage image, VkImageAspectFlags aspect_mask, VkImageLayout src_layout, VkImageLayout dst_layout) { VkImageMemoryBarrier barrier = {.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER};
@@ -129,7 +129,7 @@ static void transition_image_layout(struct vulkan_shader_runner *runner, barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barrier.image = image; - barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + barrier.subresourceRange.aspectMask = aspect_mask; barrier.subresourceRange.baseMipLevel = 0; barrier.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS; barrier.subresourceRange.baseArrayLayer = 0; @@ -238,7 +238,8 @@ static VkImage create_2d_image(const struct vulkan_shader_runner *runner, uint32 return image; }
-static VkImageView create_2d_image_view(const struct vulkan_shader_runner *runner, VkImage image, VkFormat format) +static VkImageView create_2d_image_view(const struct vulkan_shader_runner *runner, VkImage image, VkFormat format, + VkImageAspectFlags aspect_mask) { VkImageViewCreateInfo view_info = {.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO}; VkImageView view; @@ -250,7 +251,7 @@ static VkImageView create_2d_image_view(const struct vulkan_shader_runner *runne view_info.components.g = VK_COMPONENT_SWIZZLE_IDENTITY; view_info.components.b = VK_COMPONENT_SWIZZLE_IDENTITY; view_info.components.a = VK_COMPONENT_SWIZZLE_IDENTITY; - view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + view_info.subresourceRange.aspectMask = aspect_mask; view_info.subresourceRange.baseMipLevel = 0; view_info.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS; view_info.subresourceRange.baseArrayLayer = 0; @@ -280,12 +281,12 @@ static void resource_init_2d(struct vulkan_shader_runner *runner, struct vulkan_
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); + resource->image_view = create_2d_image_view(runner, resource->image, format, VK_IMAGE_ASPECT_COLOR_BIT);
if (!params->data) { begin_command_buffer(runner); - transition_image_layout(runner, resource->image, + transition_image_layout(runner, resource->image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_UNDEFINED, layout); end_command_buffer(runner); return; @@ -299,7 +300,7 @@ static void resource_init_2d(struct vulkan_shader_runner *runner, struct vulkan_
begin_command_buffer(runner);
- transition_image_layout(runner, resource->image, + transition_image_layout(runner, resource->image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
for (unsigned int level = 0; level < params->level_count; ++level) @@ -321,7 +322,7 @@ static void resource_init_2d(struct vulkan_shader_runner *runner, struct vulkan_ buffer_offset += level_width * level_height * params->texel_size; }
- transition_image_layout(runner, resource->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, layout); + transition_image_layout(runner, resource->image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, layout);
end_command_buffer(runner);
@@ -373,14 +374,28 @@ static struct resource *vulkan_runner_create_resource(struct shader_runner *r, c
resource->image = create_2d_image(runner, params->width, params->height, params->level_count, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, format, &resource->memory); - resource->image_view = create_2d_image_view(runner, resource->image, format); + resource->image_view = create_2d_image_view(runner, resource->image, format, VK_IMAGE_ASPECT_COLOR_BIT);
begin_command_buffer(runner); - transition_image_layout(runner, resource->image, + transition_image_layout(runner, resource->image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); end_command_buffer(runner); break;
+ case RESOURCE_TYPE_DEPTH_STENCIL_TARGET: + format = vkd3d_get_vk_format(params->format); + + resource->image = create_2d_image(runner, params->width, params->height, params->level_count, + VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, format, + &resource->memory); + resource->image_view = create_2d_image_view(runner, resource->image, format, VK_IMAGE_ASPECT_DEPTH_BIT); + + begin_command_buffer(runner); + transition_image_layout(runner, resource->image, VK_IMAGE_ASPECT_DEPTH_BIT, + VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); + end_command_buffer(runner); + break; + case RESOURCE_TYPE_TEXTURE: case RESOURCE_TYPE_UAV: if (params->dimension == RESOURCE_DIMENSION_BUFFER) @@ -541,6 +556,7 @@ static bool compile_shader(struct vulkan_shader_runner *runner, const char *sour switch (resource->r.type) { case RESOURCE_TYPE_RENDER_TARGET: + case RESOURCE_TYPE_DEPTH_STENCIL_TARGET: case RESOURCE_TYPE_VERTEX_BUFFER: break;
@@ -669,6 +685,31 @@ static VkPipelineLayout create_pipeline_layout(const struct vulkan_shader_runner return pipeline_layout; }
+static enum VkCompareOp vk_compare_op_from_d3d12(D3D12_COMPARISON_FUNC op) +{ + switch (op) + { + case D3D12_COMPARISON_FUNC_NEVER: + return VK_COMPARE_OP_NEVER; + case D3D12_COMPARISON_FUNC_LESS: + return VK_COMPARE_OP_LESS; + case D3D12_COMPARISON_FUNC_EQUAL: + return VK_COMPARE_OP_EQUAL; + case D3D12_COMPARISON_FUNC_LESS_EQUAL: + return VK_COMPARE_OP_LESS_OR_EQUAL; + case D3D12_COMPARISON_FUNC_GREATER: + return VK_COMPARE_OP_GREATER; + case D3D12_COMPARISON_FUNC_NOT_EQUAL: + return VK_COMPARE_OP_NOT_EQUAL; + case D3D12_COMPARISON_FUNC_GREATER_EQUAL: + return VK_COMPARE_OP_GREATER_OR_EQUAL; + case D3D12_COMPARISON_FUNC_ALWAYS: + return VK_COMPARE_OP_ALWAYS; + default: + fatal_error("Unhandled compare op %#x.\n", op); + } +} + static VkPipeline create_graphics_pipeline(struct vulkan_shader_runner *runner, VkRenderPass render_pass, VkPipelineLayout pipeline_layout, D3D_PRIMITIVE_TOPOLOGY primitive_topology) { @@ -684,6 +725,7 @@ static VkPipeline create_graphics_pipeline(struct vulkan_shader_runner *runner, VkGraphicsPipelineCreateInfo pipeline_desc = {.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO}; VkPipelineColorBlendAttachmentState attachment_desc[MAX_RESOURCES] = {0}; VkVertexInputAttributeDescription input_attributes[32]; + VkPipelineDepthStencilStateCreateInfo ds_desc = {0}; VkVertexInputBindingDescription input_bindings[32]; VkPipelineShaderStageCreateInfo stage_desc[2]; struct vkd3d_shader_code vs_dxbc; @@ -745,6 +787,20 @@ static VkPipeline create_graphics_pipeline(struct vulkan_shader_runner *runner, | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; break;
+ case RESOURCE_TYPE_DEPTH_STENCIL_TARGET: + ds_desc.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + ds_desc.pNext = NULL; + ds_desc.flags = 0; + ds_desc.depthTestEnable = VK_TRUE; + ds_desc.depthWriteEnable = VK_TRUE; + ds_desc.depthCompareOp = vk_compare_op_from_d3d12(runner->r.comparison); + ds_desc.depthBoundsTestEnable = VK_FALSE; + ds_desc.stencilTestEnable = VK_FALSE; + ds_desc.minDepthBounds = 0.0f; + ds_desc.maxDepthBounds = 1.0f; + pipeline_desc.pDepthStencilState = &ds_desc; + break; + case RESOURCE_TYPE_VERTEX_BUFFER: { VkVertexInputBindingDescription *binding = &input_bindings[input_desc.vertexBindingDescriptionCount++]; @@ -841,31 +897,6 @@ static VkSamplerAddressMode vk_address_mode_from_d3d12(D3D12_TEXTURE_ADDRESS_MOD } }
-static enum VkCompareOp vk_compare_op_from_d3d12(D3D12_COMPARISON_FUNC op) -{ - switch (op) - { - case D3D12_COMPARISON_FUNC_NEVER: - return VK_COMPARE_OP_NEVER; - case D3D12_COMPARISON_FUNC_LESS: - return VK_COMPARE_OP_LESS; - case D3D12_COMPARISON_FUNC_EQUAL: - return VK_COMPARE_OP_EQUAL; - case D3D12_COMPARISON_FUNC_LESS_EQUAL: - return VK_COMPARE_OP_LESS_OR_EQUAL; - case D3D12_COMPARISON_FUNC_GREATER: - return VK_COMPARE_OP_GREATER; - case D3D12_COMPARISON_FUNC_NOT_EQUAL: - return VK_COMPARE_OP_NOT_EQUAL; - case D3D12_COMPARISON_FUNC_GREATER_EQUAL: - return VK_COMPARE_OP_GREATER_OR_EQUAL; - case D3D12_COMPARISON_FUNC_ALWAYS: - return VK_COMPARE_OP_ALWAYS; - default: - fatal_error("Unhandled compare op %#x.\n", op); - } -} - static VkDescriptorSetLayout create_descriptor_set_layout(struct vulkan_shader_runner *runner) { VkDescriptorSetLayoutCreateInfo set_desc = {.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO}; @@ -887,6 +918,7 @@ static VkDescriptorSetLayout create_descriptor_set_layout(struct vulkan_shader_r switch (resource->r.type) { case RESOURCE_TYPE_RENDER_TARGET: + case RESOURCE_TYPE_DEPTH_STENCIL_TARGET: case RESOURCE_TYPE_VERTEX_BUFFER: break;
@@ -1018,6 +1050,7 @@ static void bind_resources(struct vulkan_shader_runner *runner, VkPipelineBindPo break;
case RESOURCE_TYPE_RENDER_TARGET: + case RESOURCE_TYPE_DEPTH_STENCIL_TARGET: break; } } @@ -1036,44 +1069,57 @@ 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}; + VkAttachmentReference ds_ref = {0}, color_refs[MAX_RESOURCES] = {0}; VkAttachmentDescription attachment_descs[MAX_RESOURCES] = {0}; - VkAttachmentReference color_refs[MAX_RESOURCES] = {0}; VkSubpassDescription subpass_desc = {0}; - VkImageView rtvs[MAX_RESOURCES]; - unsigned int rt_count = 0; + VkImageView views[MAX_RESOURCES]; + unsigned int color_ref_count = 0, view_count = 0; + VkImageLayout layout; unsigned int i; + bool is_ds;
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]; + VkAttachmentDescription *attachment_desc = &attachment_descs[view_count]; + VkAttachmentReference *color_ref = &color_refs[color_ref_count];
- if (resource->r.type != RESOURCE_TYPE_RENDER_TARGET) + if (resource->r.type != RESOURCE_TYPE_RENDER_TARGET && resource->r.type != RESOURCE_TYPE_DEPTH_STENCIL_TARGET) continue;
+ is_ds = resource->r.type == RESOURCE_TYPE_DEPTH_STENCIL_TARGET; + layout = is_ds ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + 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->loadOp = is_ds ? VK_ATTACHMENT_LOAD_OP_CLEAR : 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; + attachment_desc->initialLayout = layout; + attachment_desc->finalLayout = layout;
- rtvs[rt_count] = resource->image_view; + if (resource->r.type == RESOURCE_TYPE_DEPTH_STENCIL_TARGET) + { + ds_ref.attachment = view_count; + ds_ref.layout = layout; + subpass_desc.pDepthStencilAttachment = &ds_ref; + } + else + { + color_ref->attachment = view_count; + color_ref->layout = layout; + ++color_ref_count; + }
- ++rt_count; + views[view_count++] = resource->image_view; }
subpass_desc.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; - subpass_desc.colorAttachmentCount = rt_count; + subpass_desc.colorAttachmentCount = color_ref_count; subpass_desc.pColorAttachments = color_refs;
- render_pass_desc.attachmentCount = rt_count; + render_pass_desc.attachmentCount = view_count; render_pass_desc.pAttachments = attachment_descs; render_pass_desc.subpassCount = 1; render_pass_desc.pSubpasses = &subpass_desc; @@ -1081,8 +1127,8 @@ static void create_render_pass_and_framebuffer(struct vulkan_shader_runner *runn VK_CALL(vkCreateRenderPass(runner->device, &render_pass_desc, NULL, render_pass));
fb_desc.renderPass = *render_pass; - fb_desc.attachmentCount = rt_count; - fb_desc.pAttachments = rtvs; + fb_desc.attachmentCount = view_count; + fb_desc.pAttachments = views; fb_desc.width = RENDER_TARGET_WIDTH; fb_desc.height = RENDER_TARGET_HEIGHT; fb_desc.layers = 1; @@ -1144,6 +1190,7 @@ static bool vulkan_runner_draw(struct shader_runner *r, VkDescriptorSetLayout set_layout; VkPipelineLayout pipeline_layout; VkDevice device = runner->device; + union VkClearValue clear_value; VkRenderPass render_pass; VkPipeline pipeline; VkFramebuffer fb; @@ -1164,6 +1211,10 @@ static bool vulkan_runner_draw(struct shader_runner *r, pass_begin_desc.renderPass = render_pass; pass_begin_desc.framebuffer = fb; pass_begin_desc.renderArea = rt_rect; + pass_begin_desc.clearValueCount = 1; + pass_begin_desc.pClearValues = &clear_value; + clear_value.depthStencil.depth = runner->r.dsv_clear_value; + clear_value.depthStencil.stencil = 0;
VK_CALL(vkCmdBeginRenderPass(cmd_buffer, &pass_begin_desc, VK_SUBPASS_CONTENTS_INLINE));
@@ -1205,6 +1256,7 @@ static struct resource_readback *vulkan_runner_get_resource_readback(struct shad struct vulkan_resource_readback *rb = malloc(sizeof(*rb)); struct vulkan_resource *resource = vulkan_resource(res); VkDevice device = runner->device; + VkImageAspectFlags aspect_mask; VkBufferImageCopy region = {0}; VkImageLayout layout;
@@ -1228,16 +1280,21 @@ static struct resource_readback *vulkan_runner_get_resource_readback(struct shad } else { + aspect_mask = (resource->r.type == RESOURCE_TYPE_DEPTH_STENCIL_TARGET) + ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT; + if (resource->r.type == RESOURCE_TYPE_RENDER_TARGET) layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + else if (resource->r.type == RESOURCE_TYPE_DEPTH_STENCIL_TARGET) + layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; else layout = VK_IMAGE_LAYOUT_GENERAL;
begin_command_buffer(runner);
- transition_image_layout(runner, resource->image, layout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); + transition_image_layout(runner, resource->image, aspect_mask, layout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
- region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + region.imageSubresource.aspectMask = aspect_mask; region.imageSubresource.layerCount = 1; region.imageExtent.width = resource->r.width; region.imageExtent.height = resource->r.height; @@ -1246,7 +1303,7 @@ static struct resource_readback *vulkan_runner_get_resource_readback(struct shad VK_CALL(vkCmdCopyImageToBuffer(runner->cmd_buffer, resource->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, rb->buffer, 1, ®ion));
- transition_image_layout(runner, resource->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, layout); + transition_image_layout(runner, resource->image, aspect_mask, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, layout);
end_command_buffer(runner);
@@ -1544,6 +1601,8 @@ static bool init_vulkan_runner(struct vulkan_shader_runner *runner) runner->caps.rov = false; }
+ runner->caps.dsv = true; + vr = VK_CALL(vkCreateDevice(runner->phys_device, &device_desc, NULL, &device)); free(enabled_extensions.names); if (vr)