diff --git a/patches/vkd3d-latest/0001-Updated-vkd3d-to-5b2d62e59a6365e32aac3fa37fe16ab3582.patch b/patches/vkd3d-latest/0001-Updated-vkd3d-to-5b2d62e59a6365e32aac3fa37fe16ab3582.patch index 4056480b..1cf463ad 100644 --- a/patches/vkd3d-latest/0001-Updated-vkd3d-to-5b2d62e59a6365e32aac3fa37fe16ab3582.patch +++ b/patches/vkd3d-latest/0001-Updated-vkd3d-to-5b2d62e59a6365e32aac3fa37fe16ab3582.patch @@ -1,4 +1,4 @@ -From 2a2567f35d07ebd3c2c56787137578bc735aa8f9 Mon Sep 17 00:00:00 2001 +From afc75effdcb3fc768be244a6d6d0291a5abfcb82 Mon Sep 17 00:00:00 2001 From: Alistair Leslie-Hughes Date: Fri, 29 Nov 2024 07:14:57 +1100 Subject: [PATCH] Updated vkd3d to 5b2d62e59a6365e32aac3fa37fe16ab3582deae4. diff --git a/patches/vkd3d-latest/0002-Updated-vkd3d-to-5bfcd811824e9ca03c09a54204bff645225.patch b/patches/vkd3d-latest/0002-Updated-vkd3d-to-5bfcd811824e9ca03c09a54204bff645225.patch index dede036e..f8f50b08 100644 --- a/patches/vkd3d-latest/0002-Updated-vkd3d-to-5bfcd811824e9ca03c09a54204bff645225.patch +++ b/patches/vkd3d-latest/0002-Updated-vkd3d-to-5bfcd811824e9ca03c09a54204bff645225.patch @@ -1,4 +1,4 @@ -From de8bae91ae7f7bd8ed11446a6039632b7f885016 Mon Sep 17 00:00:00 2001 +From fbb37e58847baa8b16d0548f3a44bcdc45552b77 Mon Sep 17 00:00:00 2001 From: Alistair Leslie-Hughes Date: Thu, 23 Jan 2025 07:16:22 +1100 Subject: [PATCH] Updated vkd3d to 5bfcd811824e9ca03c09a54204bff645225c3408. diff --git a/patches/vkd3d-latest/0003-Updated-vkd3d-to-40c225095f64dacfe8b88780a5d43ecdeaf.patch b/patches/vkd3d-latest/0003-Updated-vkd3d-to-40c225095f64dacfe8b88780a5d43ecdeaf.patch index 6f27fd76..b127ec5c 100644 --- a/patches/vkd3d-latest/0003-Updated-vkd3d-to-40c225095f64dacfe8b88780a5d43ecdeaf.patch +++ b/patches/vkd3d-latest/0003-Updated-vkd3d-to-40c225095f64dacfe8b88780a5d43ecdeaf.patch @@ -1,4 +1,4 @@ -From edd0f7568f18fc201d268fabe178d9e509e40a28 Mon Sep 17 00:00:00 2001 +From 466b9a26e43c4a9d2ddb9f28c92e43323cdbb343 Mon Sep 17 00:00:00 2001 From: Alistair Leslie-Hughes Date: Tue, 28 Jan 2025 08:24:16 +1100 Subject: [PATCH] Updated vkd3d to 40c225095f64dacfe8b88780a5d43ecdeafe4d2a. diff --git a/patches/vkd3d-latest/0004-Updated-vkd3d-to-2f77d56b7748f89ae85fd08bba956fbb603.patch b/patches/vkd3d-latest/0004-Updated-vkd3d-to-2f77d56b7748f89ae85fd08bba956fbb603.patch index e17384b2..87ed21b0 100644 --- a/patches/vkd3d-latest/0004-Updated-vkd3d-to-2f77d56b7748f89ae85fd08bba956fbb603.patch +++ b/patches/vkd3d-latest/0004-Updated-vkd3d-to-2f77d56b7748f89ae85fd08bba956fbb603.patch @@ -1,4 +1,4 @@ -From 0b997e16483a911049de4382f993a9c267c568b5 Mon Sep 17 00:00:00 2001 +From fa404622cea0d58f0aabfded908abaeaa42885a9 Mon Sep 17 00:00:00 2001 From: Alistair Leslie-Hughes Date: Tue, 4 Feb 2025 06:59:46 +1100 Subject: [PATCH] Updated vkd3d to 2f77d56b7748f89ae85fd08bba956fbb60387bd2. diff --git a/patches/vkd3d-latest/0005-Updated-vkd3d-to-fe52e696629c27abd7e4097e1e44a81b377.patch b/patches/vkd3d-latest/0005-Updated-vkd3d-to-fe52e696629c27abd7e4097e1e44a81b377.patch index 4b25b7ac..b121b62b 100644 --- a/patches/vkd3d-latest/0005-Updated-vkd3d-to-fe52e696629c27abd7e4097e1e44a81b377.patch +++ b/patches/vkd3d-latest/0005-Updated-vkd3d-to-fe52e696629c27abd7e4097e1e44a81b377.patch @@ -1,4 +1,4 @@ -From c80cc1042c1765e95e674d1d7544dd80042c1c43 Mon Sep 17 00:00:00 2001 +From 4cb706ac6d429e39fd2fc6bc346a9aa216ae5c17 Mon Sep 17 00:00:00 2001 From: Alistair Leslie-Hughes Date: Thu, 6 Feb 2025 13:52:27 +1100 Subject: [PATCH] Updated vkd3d to fe52e696629c27abd7e4097e1e44a81b377f4f4f. diff --git a/patches/vkd3d-latest/0006-Updated-vkd3d-to-c3555a34dcf291e0811b0acce8884651d4e.patch b/patches/vkd3d-latest/0006-Updated-vkd3d-to-c3555a34dcf291e0811b0acce8884651d4e.patch index 9bcf9822..a81443df 100644 --- a/patches/vkd3d-latest/0006-Updated-vkd3d-to-c3555a34dcf291e0811b0acce8884651d4e.patch +++ b/patches/vkd3d-latest/0006-Updated-vkd3d-to-c3555a34dcf291e0811b0acce8884651d4e.patch @@ -1,4 +1,4 @@ -From e3e8d077accc84b6dbb73658afc12c8eb73c72e5 Mon Sep 17 00:00:00 2001 +From 630d70bf14564ee5f380ae08720a2c8c98679bd1 Mon Sep 17 00:00:00 2001 From: Alistair Leslie-Hughes Date: Tue, 18 Feb 2025 08:11:04 +1100 Subject: [PATCH] Updated vkd3d to c3555a34dcf291e0811b0acce8884651d4e728a4. diff --git a/patches/vkd3d-latest/0007-Updated-vkd3d-to-86462db9ed051b92ad3fe007af64b8cd08d.patch b/patches/vkd3d-latest/0007-Updated-vkd3d-to-86462db9ed051b92ad3fe007af64b8cd08d.patch new file mode 100644 index 00000000..84c498a6 --- /dev/null +++ b/patches/vkd3d-latest/0007-Updated-vkd3d-to-86462db9ed051b92ad3fe007af64b8cd08d.patch @@ -0,0 +1,36 @@ +From ced946739a16c99cea79c46563048647fbf67f7e Mon Sep 17 00:00:00 2001 +From: Alistair Leslie-Hughes +Date: Wed, 19 Feb 2025 09:33:06 +1100 +Subject: [PATCH] Updated vkd3d to 86462db9ed051b92ad3fe007af64b8cd08d5a38a. + +--- + libs/vkd3d/include/vkd3d_shader.h | 4 +++- + 1 file changed, 3 insertions(+), 1 deletion(-) + +diff --git a/libs/vkd3d/include/vkd3d_shader.h b/libs/vkd3d/include/vkd3d_shader.h +index af55d63a5c8..78d6e264a64 100644 +--- a/libs/vkd3d/include/vkd3d_shader.h ++++ b/libs/vkd3d/include/vkd3d_shader.h +@@ -2746,6 +2746,7 @@ VKD3D_SHADER_API const enum vkd3d_shader_target_type *vkd3d_shader_get_supported + * - vkd3d_shader_preprocess_info + * - vkd3d_shader_scan_combined_resource_sampler_info + * - vkd3d_shader_scan_descriptor_info ++ * - vkd3d_shader_scan_hull_shader_tessellation_info + * - vkd3d_shader_scan_signature_info + * - vkd3d_shader_spirv_domain_shader_target_info + * - vkd3d_shader_spirv_target_info +@@ -2933,9 +2934,10 @@ VKD3D_SHADER_API int vkd3d_shader_convert_root_signature(struct vkd3d_shader_ver + * \param compile_info A chained structure containing scan parameters. + * \n + * The scanner supports the following chained structures: ++ * - vkd3d_shader_scan_combined_resource_sampler_info + * - vkd3d_shader_scan_descriptor_info ++ * - vkd3d_shader_scan_hull_shader_tessellation_info + * - vkd3d_shader_scan_signature_info +- * - vkd3d_shader_scan_combined_resource_sampler_info + * \n + * Although the \a compile_info parameter is read-only, chained structures + * passed to this function need not be, and may serve as output parameters, +-- +2.47.2 + diff --git a/patches/vkd3d-latest/0008-Updated-vkd3d-to-07b7975d09e8dfbdfc5a9942b4f0c9d054a.patch b/patches/vkd3d-latest/0008-Updated-vkd3d-to-07b7975d09e8dfbdfc5a9942b4f0c9d054a.patch new file mode 100644 index 00000000..80ac7a81 --- /dev/null +++ b/patches/vkd3d-latest/0008-Updated-vkd3d-to-07b7975d09e8dfbdfc5a9942b4f0c9d054a.patch @@ -0,0 +1,864 @@ +From 3841adb6528a908fe7ca203258787cba7003f13d Mon Sep 17 00:00:00 2001 +From: Alistair Leslie-Hughes +Date: Thu, 20 Feb 2025 07:19:41 +1100 +Subject: [PATCH] Updated vkd3d to 07b7975d09e8dfbdfc5a9942b4f0c9d054a5cd11. + +--- + libs/vkd3d/include/vkd3d.h | 1 + + libs/vkd3d/include/vkd3d_shader.h | 7 + + libs/vkd3d/libs/vkd3d-shader/fx.c | 2 +- + libs/vkd3d/libs/vkd3d-shader/ir.c | 221 ++++++++++-------- + libs/vkd3d/libs/vkd3d-shader/spirv.c | 2 +- + libs/vkd3d/libs/vkd3d-shader/tpf.c | 3 +- + .../libs/vkd3d-shader/vkd3d_shader_main.c | 26 ++- + libs/vkd3d/libs/vkd3d/command.c | 50 +++- + libs/vkd3d/libs/vkd3d/device.c | 2 +- + libs/vkd3d/libs/vkd3d/resource.c | 14 +- + libs/vkd3d/libs/vkd3d/state.c | 72 +++++- + libs/vkd3d/libs/vkd3d/vkd3d_private.h | 1 - + 12 files changed, 258 insertions(+), 143 deletions(-) + +diff --git a/libs/vkd3d/include/vkd3d.h b/libs/vkd3d/include/vkd3d.h +index 2376693421c..279c6b38be8 100644 +--- a/libs/vkd3d/include/vkd3d.h ++++ b/libs/vkd3d/include/vkd3d.h +@@ -99,6 +99,7 @@ enum vkd3d_api_version + VKD3D_API_VERSION_1_12, + VKD3D_API_VERSION_1_13, + VKD3D_API_VERSION_1_14, ++ VKD3D_API_VERSION_1_15, + + VKD3D_FORCE_32_BIT_ENUM(VKD3D_API_VERSION), + }; +diff --git a/libs/vkd3d/include/vkd3d_shader.h b/libs/vkd3d/include/vkd3d_shader.h +index 78d6e264a64..058166aa2f9 100644 +--- a/libs/vkd3d/include/vkd3d_shader.h ++++ b/libs/vkd3d/include/vkd3d_shader.h +@@ -57,6 +57,7 @@ enum vkd3d_shader_api_version + VKD3D_SHADER_API_VERSION_1_12, + VKD3D_SHADER_API_VERSION_1_13, + VKD3D_SHADER_API_VERSION_1_14, ++ VKD3D_SHADER_API_VERSION_1_15, + + VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_API_VERSION), + }; +@@ -540,6 +541,8 @@ enum vkd3d_shader_fog_fragment_mode + * k = 1 / (end - start) + */ + VKD3D_SHADER_FOG_FRAGMENT_LINEAR = 0x3, ++ ++ VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_FOG_FRAGMENT_MODE), + }; + + /** +@@ -577,6 +580,8 @@ enum vkd3d_shader_fog_source + * shader. + */ + VKD3D_SHADER_FOG_SOURCE_W = 0x3, ++ ++ VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_FOG_SOURCE), + }; + + /** +@@ -1116,6 +1121,8 @@ enum vkd3d_shader_d3dbc_constant_register + VKD3D_SHADER_D3DBC_INT_CONSTANT_REGISTER = 0x1, + /** The boolean constant register set, b# in Direct3D assembly. */ + VKD3D_SHADER_D3DBC_BOOL_CONSTANT_REGISTER = 0x2, ++ ++ VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_D3DBC_CONSTANT_REGISTER), + }; + + /** +diff --git a/libs/vkd3d/libs/vkd3d-shader/fx.c b/libs/vkd3d/libs/vkd3d-shader/fx.c +index 779ffa1e156..bd7e7b420db 100644 +--- a/libs/vkd3d/libs/vkd3d-shader/fx.c ++++ b/libs/vkd3d/libs/vkd3d-shader/fx.c +@@ -3237,7 +3237,7 @@ static void fx_4_parse_shader_blob(struct fx_parser *parser, unsigned int object + + static const struct vkd3d_shader_compile_option options[] = + { +- {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_14}, ++ {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_15}, + }; + + fx_parser_read_unstructured(parser, &data_size, shader->offset, sizeof(data_size)); +diff --git a/libs/vkd3d/libs/vkd3d-shader/ir.c b/libs/vkd3d/libs/vkd3d-shader/ir.c +index 3678ad0bacf..d145617ec36 100644 +--- a/libs/vkd3d/libs/vkd3d-shader/ir.c ++++ b/libs/vkd3d/libs/vkd3d-shader/ir.c +@@ -1523,6 +1523,8 @@ static enum vkd3d_result vsir_program_flatten_hull_shader_phases(struct vsir_pro + flattener.phase = VKD3DSIH_INVALID; + for (i = 0, locations.count = 0; i < instructions->count; ++i) + flattener_eliminate_phase_related_dcls(&flattener, i, &locations); ++ bitmap_clear(program->io_dcls, VKD3DSPR_FORKINSTID); ++ bitmap_clear(program->io_dcls, VKD3DSPR_JOININSTID); + + if ((result = flattener_flatten_phases(&flattener, &locations)) < 0) + return result; +@@ -1730,8 +1732,20 @@ static enum vkd3d_result instruction_array_normalise_hull_shader_control_point_i + return VKD3D_OK; + } + ++struct io_normaliser_register_data ++{ ++ struct ++ { ++ uint8_t register_count; ++ uint32_t mask; ++ uint32_t used_mask; ++ } component[VKD3D_VEC4_SIZE]; ++}; ++ ++ + struct io_normaliser + { ++ struct vkd3d_shader_message_context *message_context; + struct vkd3d_shader_instruction_array instructions; + enum vkd3d_shader_type shader_type; + uint8_t major; +@@ -1749,9 +1763,9 @@ struct io_normaliser + struct vkd3d_shader_dst_param *input_dcl_params[MAX_REG_OUTPUT]; + struct vkd3d_shader_dst_param *output_dcl_params[MAX_REG_OUTPUT]; + struct vkd3d_shader_dst_param *pc_dcl_params[MAX_REG_OUTPUT]; +- uint8_t input_range_map[MAX_REG_OUTPUT][VKD3D_VEC4_SIZE]; +- uint8_t output_range_map[MAX_REG_OUTPUT][VKD3D_VEC4_SIZE]; +- uint8_t pc_range_map[MAX_REG_OUTPUT][VKD3D_VEC4_SIZE]; ++ struct io_normaliser_register_data input_range_map[MAX_REG_OUTPUT]; ++ struct io_normaliser_register_data output_range_map[MAX_REG_OUTPUT]; ++ struct io_normaliser_register_data pc_range_map[MAX_REG_OUTPUT]; + + bool use_vocp; + }; +@@ -1792,36 +1806,44 @@ struct signature_element *vsir_signature_find_element_for_reg(const struct shade + return NULL; + } + +-static unsigned int range_map_get_register_count(uint8_t range_map[][VKD3D_VEC4_SIZE], ++static unsigned int range_map_get_register_count(struct io_normaliser_register_data range_map[], + unsigned int register_idx, uint32_t write_mask) + { +- return range_map[register_idx][vsir_write_mask_get_component_idx(write_mask)]; ++ return range_map[register_idx].component[vsir_write_mask_get_component_idx(write_mask)].register_count; + } + +-static void range_map_set_register_range(uint8_t range_map[][VKD3D_VEC4_SIZE], unsigned int register_idx, +- unsigned int register_count, uint32_t write_mask, bool is_dcl_indexrange) ++static enum vkd3d_result range_map_set_register_range(struct io_normaliser *normaliser, ++ struct io_normaliser_register_data range_map[], unsigned int register_idx, ++ unsigned int register_count, uint32_t mask, uint32_t used_mask, bool is_dcl_indexrange) + { + unsigned int i, j, r, c, component_idx, component_count; + +- VKD3D_ASSERT(write_mask <= VKD3DSP_WRITEMASK_ALL); +- component_idx = vsir_write_mask_get_component_idx(write_mask); +- component_count = vsir_write_mask_component_count(write_mask); ++ VKD3D_ASSERT(mask <= VKD3DSP_WRITEMASK_ALL); ++ component_idx = vsir_write_mask_get_component_idx(mask); ++ component_count = vsir_write_mask_component_count(mask); + + VKD3D_ASSERT(register_idx < MAX_REG_OUTPUT && MAX_REG_OUTPUT - register_idx >= register_count); + +- if (range_map[register_idx][component_idx] > register_count && is_dcl_indexrange) ++ if (range_map[register_idx].component[component_idx].register_count > register_count && is_dcl_indexrange) + { +- /* Validated in the TPF reader. */ +- VKD3D_ASSERT(range_map[register_idx][component_idx] != UINT8_MAX); +- return; ++ if (range_map[register_idx].component[component_idx].register_count == UINT8_MAX) ++ { ++ WARN("Conflicting index ranges.\n"); ++ vkd3d_shader_error(normaliser->message_context, NULL, ++ VKD3D_SHADER_ERROR_VSIR_INVALID_SIGNATURE, "Conflicting index ranges."); ++ return VKD3D_ERROR_INVALID_SHADER; ++ } ++ return VKD3D_OK; + } +- if (range_map[register_idx][component_idx] == register_count) ++ if (range_map[register_idx].component[component_idx].register_count == register_count) + { + /* Already done. This happens when fxc splits a register declaration by + * component(s). The dcl_indexrange instructions are split too. */ +- return; ++ return VKD3D_OK; + } +- range_map[register_idx][component_idx] = register_count; ++ range_map[register_idx].component[component_idx].register_count = register_count; ++ range_map[register_idx].component[component_idx].mask = mask; ++ range_map[register_idx].component[component_idx].used_mask = used_mask; + + for (i = 0; i < register_count; ++i) + { +@@ -1832,21 +1854,31 @@ static void range_map_set_register_range(uint8_t range_map[][VKD3D_VEC4_SIZE], u + /* A synthetic patch constant range which overlaps an existing range can start upstream of it + * for fork/join phase instancing, but ranges declared by dcl_indexrange should not overlap. + * The latter is validated in the TPF reader. */ +- VKD3D_ASSERT(!range_map[r][c] || !is_dcl_indexrange); +- range_map[r][c] = UINT8_MAX; ++ if (range_map[r].component[c].register_count && is_dcl_indexrange) ++ { ++ WARN("Conflicting index ranges.\n"); ++ vkd3d_shader_error(normaliser->message_context, NULL, ++ VKD3D_SHADER_ERROR_VSIR_INVALID_SIGNATURE, "Conflicting index ranges."); ++ return VKD3D_ERROR_INVALID_SHADER; ++ } ++ range_map[r].component[c].register_count = UINT8_MAX; ++ range_map[r].component[c].mask = mask; ++ range_map[r].component[c].used_mask = used_mask; + } + } ++ ++ return VKD3D_OK; + } + +-static void io_normaliser_add_index_range(struct io_normaliser *normaliser, ++static enum vkd3d_result io_normaliser_add_index_range(struct io_normaliser *normaliser, + const struct vkd3d_shader_instruction *ins) + { + const struct vkd3d_shader_index_range *range = &ins->declaration.index_range; + const struct vkd3d_shader_register *reg = &range->dst.reg; ++ struct io_normaliser_register_data *range_map; + const struct shader_signature *signature; +- uint8_t (*range_map)[VKD3D_VEC4_SIZE]; +- struct signature_element *element; +- unsigned int reg_idx, write_mask; ++ uint32_t mask, used_mask; ++ unsigned int reg_idx, i; + + switch (reg->type) + { +@@ -1877,9 +1909,21 @@ static void io_normaliser_add_index_range(struct io_normaliser *normaliser, + } + + reg_idx = reg->idx[reg->idx_count - 1].offset; +- write_mask = range->dst.write_mask; +- element = vsir_signature_find_element_for_reg(signature, reg_idx, write_mask); +- range_map_set_register_range(range_map, reg_idx, range->register_count, element->mask, true); ++ mask = range->dst.write_mask; ++ used_mask = 0; ++ ++ for (i = 0; i < range->register_count; ++i) ++ { ++ struct signature_element *element; ++ ++ if ((element = vsir_signature_find_element_for_reg(signature, reg_idx + i, mask))) ++ { ++ mask |= element->mask; ++ used_mask |= element->used_mask; ++ } ++ } ++ ++ return range_map_set_register_range(normaliser, range_map, reg_idx, range->register_count, mask, used_mask, true); + } + + static int signature_element_mask_compare(const void *a, const void *b) +@@ -1906,11 +1950,12 @@ static bool sysval_semantics_should_merge(const struct signature_element *e, con + } + + /* Merge tess factor sysvals because they are an array in SPIR-V. */ +-static void shader_signature_map_patch_constant_index_ranges(struct shader_signature *s, +- uint8_t range_map[][VKD3D_VEC4_SIZE]) ++static enum vkd3d_result shader_signature_map_patch_constant_index_ranges(struct io_normaliser *normaliser, ++ struct shader_signature *s, struct io_normaliser_register_data range_map[]) + { +- struct signature_element *e, *f; + unsigned int i, j, register_count; ++ struct signature_element *e, *f; ++ enum vkd3d_result ret; + + qsort(s->elements, s->element_count, sizeof(s->elements[0]), signature_element_mask_compare); + +@@ -1931,8 +1976,12 @@ static void shader_signature_map_patch_constant_index_ranges(struct shader_signa + if (register_count < 2) + continue; + +- range_map_set_register_range(range_map, e->register_index, register_count, e->mask, false); ++ if ((ret = range_map_set_register_range(normaliser, range_map, ++ e->register_index, register_count, e->mask, e->used_mask, false) < 0)) ++ return ret; + } ++ ++ return VKD3D_OK; + } + + static int signature_element_register_compare(const void *a, const void *b) +@@ -1975,62 +2024,19 @@ static int signature_element_index_compare(const void *a, const void *b) + return vkd3d_u32_compare(e->sort_index, f->sort_index); + } + +-static unsigned int signature_element_range_expand_mask(struct signature_element *e, unsigned int register_count, +- uint8_t range_map[][VKD3D_VEC4_SIZE]) +-{ +- unsigned int i, j, component_idx, component_count, merged_write_mask = e->mask; +- +- /* dcl_indexrange instructions can declare a subset of the full mask, and the masks of +- * the elements within the range may differ. TPF's handling of arrayed inputs with +- * dcl_indexrange is really just a hack. Here we create a mask which covers all element +- * masks, and check for collisions with other ranges. */ +- +- for (i = 1; i < register_count; ++i) +- merged_write_mask |= e[i].mask; +- +- if (merged_write_mask == e->mask) +- return merged_write_mask; +- +- /* Reaching this point is very rare to begin with, and collisions are even rarer or +- * impossible. If the latter shows up, the fallback in shader_signature_find_element_for_reg() +- * may be sufficient. */ +- +- component_idx = vsir_write_mask_get_component_idx(e->mask); +- component_count = vsir_write_mask_component_count(e->mask); +- +- for (i = e->register_index; i < e->register_index + register_count; ++i) +- { +- for (j = 0; j < component_idx; ++j) +- if (range_map[i][j]) +- break; +- for (j = component_idx + component_count; j < VKD3D_VEC4_SIZE; ++j) +- if (range_map[i][j]) +- break; +- } +- +- if (i == register_count) +- { +- WARN("Expanding mask %#x to %#x for %s, base reg %u, count %u.\n", e->mask, merged_write_mask, +- e->semantic_name, e->register_index, register_count); +- return merged_write_mask; +- } +- +- WARN("Cannot expand mask %#x to %#x for %s, base reg %u, count %u.\n", e->mask, merged_write_mask, +- e->semantic_name, e->register_index, register_count); +- return e->mask; +-} +- +-static bool shader_signature_merge(struct shader_signature *s, uint8_t range_map[][VKD3D_VEC4_SIZE], ++static enum vkd3d_result shader_signature_merge(struct io_normaliser *normaliser, ++ struct shader_signature *s, struct io_normaliser_register_data range_map[], + bool is_patch_constant) + { + unsigned int i, j, element_count, new_count, register_count; + struct signature_element *elements; ++ enum vkd3d_result ret = VKD3D_OK; + struct signature_element *e, *f; + bool used; + + element_count = s->element_count; + if (!(elements = vkd3d_malloc(element_count * sizeof(*elements)))) +- return false; ++ return VKD3D_ERROR_OUT_OF_MEMORY; + if (element_count) + memcpy(elements, s->elements, element_count * sizeof(*elements)); + +@@ -2089,42 +2095,49 @@ static bool shader_signature_merge(struct shader_signature *s, uint8_t range_map + s->elements = elements; + s->element_count = element_count; + +- if (is_patch_constant) +- shader_signature_map_patch_constant_index_ranges(s, range_map); ++ if (is_patch_constant ++ && (ret = shader_signature_map_patch_constant_index_ranges(normaliser, s, range_map)) < 0) ++ goto out; + +- for (i = 0, new_count = 0; i < element_count; i += register_count, elements[new_count++] = *e) ++ for (i = 0, new_count = 0; i < element_count; ++i) + { + e = &elements[i]; + register_count = 1; + + if (e->register_index >= MAX_REG_OUTPUT) ++ { ++ elements[new_count++] = *e; + continue; ++ } + + register_count = range_map_get_register_count(range_map, e->register_index, e->mask); +- VKD3D_ASSERT(register_count != UINT8_MAX); +- register_count += !register_count; + +- if (register_count > 1) ++ if (register_count == UINT8_MAX) + { +- TRACE("Merging %s, base reg %u, count %u.\n", e->semantic_name, e->register_index, register_count); +- e->register_count = register_count; +- e->mask = signature_element_range_expand_mask(e, register_count, range_map); ++ TRACE("Register %u mask %#x semantic %s%u has already been merged, dropping it.\n", ++ e->register_index, e->mask, e->semantic_name, e->semantic_index); ++ vkd3d_free((void *)e->semantic_name); ++ continue; ++ } + +- for (j = 1; j < register_count; ++j) +- { +- f = &elements[i + j]; +- vkd3d_free((void *)f->semantic_name); +- } ++ if (register_count > 0) ++ { ++ TRACE("Register %u mask %#x semantic %s%u is used as merge destination.\n", ++ e->register_index, e->mask, e->semantic_name, e->semantic_index); ++ e->register_count = register_count; ++ e->mask = range_map[e->register_index].component[vsir_write_mask_get_component_idx(e->mask)].mask; ++ e->used_mask = range_map[e->register_index].component[vsir_write_mask_get_component_idx(e->mask)].used_mask; + } ++ ++ elements[new_count++] = *e; + } +- element_count = new_count; ++ s->element_count = new_count; + ++out: + /* Restoring the original order is required for sensible trace output. */ +- qsort(elements, element_count, sizeof(elements[0]), signature_element_index_compare); +- +- s->element_count = element_count; ++ qsort(s->elements, s->element_count, sizeof(elements[0]), signature_element_index_compare); + +- return true; ++ return ret; + } + + static unsigned int shader_register_normalise_arrayed_addressing(struct vkd3d_shader_register *reg, +@@ -2340,8 +2353,9 @@ static void shader_instruction_normalise_io_params(struct vkd3d_shader_instructi + static enum vkd3d_result vsir_program_normalise_io_registers(struct vsir_program *program, + struct vsir_transformation_context *ctx) + { +- struct io_normaliser normaliser = {program->instructions}; ++ struct io_normaliser normaliser = {ctx->message_context, program->instructions}; + struct vkd3d_shader_instruction *ins; ++ enum vkd3d_result ret; + unsigned int i; + + VKD3D_ASSERT(program->normalisation_level == VSIR_NORMALISED_HULL_CONTROL_POINT_IO); +@@ -2363,7 +2377,8 @@ static enum vkd3d_result vsir_program_normalise_io_registers(struct vsir_program + normaliser.output_control_point_count = ins->declaration.count; + break; + case VKD3DSIH_DCL_INDEX_RANGE: +- io_normaliser_add_index_range(&normaliser, ins); ++ if ((ret = io_normaliser_add_index_range(&normaliser, ins)) < 0) ++ return ret; + vkd3d_shader_instruction_make_nop(ins); + break; + case VKD3DSIH_HS_CONTROL_POINT_PHASE: +@@ -2376,12 +2391,14 @@ static enum vkd3d_result vsir_program_normalise_io_registers(struct vsir_program + } + } + +- if (!shader_signature_merge(&program->input_signature, normaliser.input_range_map, false) +- || !shader_signature_merge(&program->output_signature, normaliser.output_range_map, false) +- || !shader_signature_merge(&program->patch_constant_signature, normaliser.pc_range_map, true)) ++ if ((ret = shader_signature_merge(&normaliser, &program->input_signature, normaliser.input_range_map, false)) < 0 ++ || (ret = shader_signature_merge(&normaliser, &program->output_signature, ++ normaliser.output_range_map, false)) < 0 ++ || (ret = shader_signature_merge(&normaliser, &program->patch_constant_signature, ++ normaliser.pc_range_map, true)) < 0) + { + program->instructions = normaliser.instructions; +- return VKD3D_ERROR_OUT_OF_MEMORY; ++ return ret; + } + + normaliser.phase = VKD3DSIH_INVALID; +diff --git a/libs/vkd3d/libs/vkd3d-shader/spirv.c b/libs/vkd3d/libs/vkd3d-shader/spirv.c +index 5be3110ed6d..db7ebab742d 100644 +--- a/libs/vkd3d/libs/vkd3d-shader/spirv.c ++++ b/libs/vkd3d/libs/vkd3d-shader/spirv.c +@@ -37,7 +37,7 @@ + #define VKD3D_SPIRV_VERSION_1_0 0x00010000 + #define VKD3D_SPIRV_VERSION_1_3 0x00010300 + #define VKD3D_SPIRV_GENERATOR_ID 18 +-#define VKD3D_SPIRV_GENERATOR_VERSION 14 ++#define VKD3D_SPIRV_GENERATOR_VERSION 15 + #define VKD3D_SPIRV_GENERATOR_MAGIC vkd3d_make_u32(VKD3D_SPIRV_GENERATOR_VERSION, VKD3D_SPIRV_GENERATOR_ID) + #ifndef VKD3D_SHADER_UNSUPPORTED_SPIRV_PARSER + # define VKD3D_SHADER_UNSUPPORTED_SPIRV_PARSER 0 +diff --git a/libs/vkd3d/libs/vkd3d-shader/tpf.c b/libs/vkd3d/libs/vkd3d-shader/tpf.c +index 82302aac666..d41f1c65fa7 100644 +--- a/libs/vkd3d/libs/vkd3d-shader/tpf.c ++++ b/libs/vkd3d/libs/vkd3d-shader/tpf.c +@@ -1051,7 +1051,8 @@ static void shader_sm4_read_dcl_index_range(struct vkd3d_shader_instruction *ins + register_idx, register_count, write_mask, e->sysval_semantic); + return; + } +- if ((io_masks[register_idx + i] & write_mask) != write_mask) ++ if ((io_masks[register_idx + i] & write_mask) != write_mask ++ && (io_masks[register_idx + i] & write_mask) != 0) + { + WARN("No matching declaration for index range base %u, count %u, mask %#x.\n", + register_idx, register_count, write_mask); +diff --git a/libs/vkd3d/libs/vkd3d-shader/vkd3d_shader_main.c b/libs/vkd3d/libs/vkd3d-shader/vkd3d_shader_main.c +index c7ad407f6fb..ef90fd125eb 100644 +--- a/libs/vkd3d/libs/vkd3d-shader/vkd3d_shader_main.c ++++ b/libs/vkd3d/libs/vkd3d-shader/vkd3d_shader_main.c +@@ -456,8 +456,15 @@ struct shader_dump_data + const char *target_suffix; + }; + ++enum shader_dump_type ++{ ++ SHADER_DUMP_TYPE_SOURCE, ++ SHADER_DUMP_TYPE_PREPROC, ++ SHADER_DUMP_TYPE_TARGET, ++}; ++ + static void vkd3d_shader_dump_shader(const struct shader_dump_data *dump_data, +- const void *data, size_t size, bool source) ++ const void *data, size_t size, enum shader_dump_type type) + { + static const char hexadecimal_digits[] = "0123456789abcdef"; + const uint8_t *checksum = dump_data->checksum; +@@ -482,8 +489,10 @@ static void vkd3d_shader_dump_shader(const struct shader_dump_data *dump_data, + if (dump_data->profile) + pos += snprintf(filename + pos, ARRAY_SIZE(filename) - pos, "-%s", dump_data->profile); + +- if (source) ++ if (type == SHADER_DUMP_TYPE_SOURCE) + pos += snprintf(filename + pos, ARRAY_SIZE(filename) - pos, "-source.%s", dump_data->source_suffix); ++ else if (type == SHADER_DUMP_TYPE_PREPROC) ++ pos += snprintf(filename + pos, ARRAY_SIZE(filename) - pos, "-preproc.%s", dump_data->source_suffix); + else + pos += snprintf(filename + pos, ARRAY_SIZE(filename) - pos, "-target.%s", dump_data->target_suffix); + +@@ -1633,7 +1642,7 @@ int vkd3d_shader_scan(const struct vkd3d_shader_compile_info *compile_info, char + vkd3d_shader_message_context_init(&message_context, compile_info->log_level); + + fill_shader_dump_data(compile_info, &dump_data); +- vkd3d_shader_dump_shader(&dump_data, compile_info->source.code, compile_info->source.size, true); ++ vkd3d_shader_dump_shader(&dump_data, compile_info->source.code, compile_info->source.size, SHADER_DUMP_TYPE_SOURCE); + + if (compile_info->source_type == VKD3D_SHADER_SOURCE_HLSL) + { +@@ -1713,7 +1722,8 @@ int vsir_program_compile(struct vsir_program *program, uint64_t config_flags, + } + + static int compile_hlsl(const struct vkd3d_shader_compile_info *compile_info, +- struct vkd3d_shader_code *out, struct vkd3d_shader_message_context *message_context) ++ const struct shader_dump_data *dump_data, struct vkd3d_shader_code *out, ++ struct vkd3d_shader_message_context *message_context) + { + struct vkd3d_shader_code preprocessed; + int ret; +@@ -1721,6 +1731,8 @@ static int compile_hlsl(const struct vkd3d_shader_compile_info *compile_info, + if ((ret = preproc_lexer_parse(compile_info, &preprocessed, message_context))) + return ret; + ++ vkd3d_shader_dump_shader(dump_data, preprocessed.code, preprocessed.size, SHADER_DUMP_TYPE_PREPROC); ++ + ret = hlsl_compile_shader(&preprocessed, compile_info, out, message_context); + + vkd3d_shader_free_shader_code(&preprocessed); +@@ -1747,11 +1759,11 @@ int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info, + vkd3d_shader_message_context_init(&message_context, compile_info->log_level); + + fill_shader_dump_data(compile_info, &dump_data); +- vkd3d_shader_dump_shader(&dump_data, compile_info->source.code, compile_info->source.size, true); ++ vkd3d_shader_dump_shader(&dump_data, compile_info->source.code, compile_info->source.size, SHADER_DUMP_TYPE_SOURCE); + + if (compile_info->source_type == VKD3D_SHADER_SOURCE_HLSL) + { +- ret = compile_hlsl(compile_info, out, &message_context); ++ ret = compile_hlsl(compile_info, &dump_data, out, &message_context); + } + else if (compile_info->source_type == VKD3D_SHADER_SOURCE_FX) + { +@@ -1770,7 +1782,7 @@ int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info, + } + + if (ret >= 0) +- vkd3d_shader_dump_shader(&dump_data, out->code, out->size, false); ++ vkd3d_shader_dump_shader(&dump_data, out->code, out->size, SHADER_DUMP_TYPE_TARGET); + + vkd3d_shader_message_context_trace_messages(&message_context); + if (!vkd3d_shader_message_context_copy_messages(&message_context, messages)) +diff --git a/libs/vkd3d/libs/vkd3d/command.c b/libs/vkd3d/libs/vkd3d/command.c +index ce0c3b9128f..1ff58f97565 100644 +--- a/libs/vkd3d/libs/vkd3d/command.c ++++ b/libs/vkd3d/libs/vkd3d/command.c +@@ -1499,7 +1499,7 @@ static VkDescriptorPool d3d12_command_allocator_allocate_descriptor_pool( + const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; + struct VkDescriptorPoolCreateInfo pool_desc; + VkDevice vk_device = device->vk_device; +- VkDescriptorPoolSize vk_pool_sizes[2]; ++ VkDescriptorPoolSize vk_pool_sizes[4]; + unsigned int pool_size, pool_limit; + VkDescriptorPool vk_pool; + VkResult vr; +@@ -1530,21 +1530,43 @@ static VkDescriptorPool d3d12_command_allocator_allocate_descriptor_pool( + } + descriptor_count = pool_size; + +- vk_pool_sizes[0].type = vk_descriptor_type_from_vkd3d_descriptor_type(descriptor_type, true); +- vk_pool_sizes[0].descriptorCount = descriptor_count; +- +- vk_pool_sizes[1].type = vk_descriptor_type_from_vkd3d_descriptor_type(descriptor_type, false); +- vk_pool_sizes[1].descriptorCount = descriptor_count; +- + pool_desc.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; + pool_desc.pNext = NULL; + pool_desc.flags = 0; + pool_desc.maxSets = 512; +- pool_desc.poolSizeCount = 1; +- if (vk_pool_sizes[1].type != vk_pool_sizes[0].type) +- ++pool_desc.poolSizeCount; + pool_desc.pPoolSizes = vk_pool_sizes; + ++ if (allocator->device->use_vk_heaps) ++ { ++ /* SRV root descriptors. */ ++ vk_pool_sizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER; ++ vk_pool_sizes[0].descriptorCount = descriptor_count; ++ ++ /* UAV root descriptors and UAV counters. */ ++ vk_pool_sizes[1].type = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER; ++ vk_pool_sizes[1].descriptorCount = descriptor_count; ++ ++ /* CBV root descriptors. */ ++ vk_pool_sizes[2].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; ++ vk_pool_sizes[2].descriptorCount = descriptor_count; ++ ++ /* Static samplers. */ ++ vk_pool_sizes[3].type = VK_DESCRIPTOR_TYPE_SAMPLER; ++ vk_pool_sizes[3].descriptorCount = descriptor_count; ++ ++ pool_desc.poolSizeCount = 4; ++ } ++ else ++ { ++ vk_pool_sizes[0].type = vk_descriptor_type_from_vkd3d_descriptor_type(descriptor_type, true); ++ vk_pool_sizes[0].descriptorCount = descriptor_count; ++ ++ vk_pool_sizes[1].type = vk_descriptor_type_from_vkd3d_descriptor_type(descriptor_type, false); ++ vk_pool_sizes[1].descriptorCount = descriptor_count; ++ ++ pool_desc.poolSizeCount = 1 + (vk_pool_sizes[0].type != vk_pool_sizes[1].type); ++ } ++ + if ((vr = VK_CALL(vkCreateDescriptorPool(vk_device, &pool_desc, NULL, &vk_pool))) < 0) + { + ERR("Failed to create descriptor pool, vr %d.\n", vr); +@@ -1578,6 +1600,10 @@ static VkDescriptorSet d3d12_command_allocator_allocate_descriptor_set(struct d3 + VkDescriptorSet vk_descriptor_set; + VkResult vr; + ++ /* With Vulkan heaps we use just one descriptor pool. */ ++ if (device->use_vk_heaps) ++ descriptor_type = 0; ++ + if (!allocator->vk_descriptor_pools[descriptor_type]) + allocator->vk_descriptor_pools[descriptor_type] = d3d12_command_allocator_allocate_descriptor_pool(allocator, + descriptor_type, descriptor_count, unbounded); +@@ -2222,7 +2248,7 @@ static bool vk_barrier_parameters_from_d3d12_resource_state(unsigned int state, + if (!stencil_state || (stencil_state & D3D12_RESOURCE_STATE_DEPTH_WRITE)) + *image_layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + else +- *image_layout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL; ++ *image_layout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR; + } + return true; + +@@ -2256,7 +2282,7 @@ static bool vk_barrier_parameters_from_d3d12_resource_state(unsigned int state, + { + if (stencil_state & D3D12_RESOURCE_STATE_DEPTH_WRITE) + { +- *image_layout = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL; ++ *image_layout = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR; + *access_mask |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; + } + else +diff --git a/libs/vkd3d/libs/vkd3d/device.c b/libs/vkd3d/libs/vkd3d/device.c +index b51e2963efa..0575b492d64 100644 +--- a/libs/vkd3d/libs/vkd3d/device.c ++++ b/libs/vkd3d/libs/vkd3d/device.c +@@ -73,6 +73,7 @@ static const struct vkd3d_optional_extension_info optional_instance_extensions[] + static const char * const required_device_extensions[] = + { + VK_KHR_MAINTENANCE1_EXTENSION_NAME, ++ VK_KHR_MAINTENANCE2_EXTENSION_NAME, + VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, + }; + +@@ -91,7 +92,6 @@ static const struct vkd3d_optional_extension_info optional_device_extensions[] = + VK_EXTENSION(KHR_DRAW_INDIRECT_COUNT, KHR_draw_indirect_count), + VK_EXTENSION(KHR_GET_MEMORY_REQUIREMENTS_2, KHR_get_memory_requirements2), + VK_EXTENSION(KHR_IMAGE_FORMAT_LIST, KHR_image_format_list), +- VK_EXTENSION(KHR_MAINTENANCE2, KHR_maintenance2), + VK_EXTENSION(KHR_MAINTENANCE3, KHR_maintenance3), + VK_EXTENSION(KHR_PORTABILITY_SUBSET, KHR_portability_subset), + VK_EXTENSION(KHR_PUSH_DESCRIPTOR, KHR_push_descriptor), +diff --git a/libs/vkd3d/libs/vkd3d/resource.c b/libs/vkd3d/libs/vkd3d/resource.c +index eab97715944..cb184986f2a 100644 +--- a/libs/vkd3d/libs/vkd3d/resource.c ++++ b/libs/vkd3d/libs/vkd3d/resource.c +@@ -3094,7 +3094,7 @@ bool vkd3d_create_texture_view(struct d3d12_device *device, uint32_t magic, VkIm + if (vk_image) + { + view_desc.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; +- view_desc.pNext = NULL; ++ view_desc.pNext = &usage_desc; + view_desc.flags = 0; + view_desc.image = vk_image; + view_desc.viewType = desc->view_type; +@@ -3107,13 +3107,11 @@ bool vkd3d_create_texture_view(struct d3d12_device *device, uint32_t magic, VkIm + view_desc.subresourceRange.levelCount = desc->miplevel_count; + view_desc.subresourceRange.baseArrayLayer = desc->layer_idx; + view_desc.subresourceRange.layerCount = desc->layer_count; +- if (device->vk_info.KHR_maintenance2) +- { +- usage_desc.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO; +- usage_desc.pNext = NULL; +- usage_desc.usage = desc->usage; +- view_desc.pNext = &usage_desc; +- } ++ ++ usage_desc.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO; ++ usage_desc.pNext = NULL; ++ usage_desc.usage = desc->usage; ++ + if ((vr = VK_CALL(vkCreateImageView(device->vk_device, &view_desc, NULL, &vk_view))) < 0) + { + WARN("Failed to create Vulkan image view, vr %d.\n", vr); +diff --git a/libs/vkd3d/libs/vkd3d/state.c b/libs/vkd3d/libs/vkd3d/state.c +index c8a67479a22..2246f49b9a5 100644 +--- a/libs/vkd3d/libs/vkd3d/state.c ++++ b/libs/vkd3d/libs/vkd3d/state.c +@@ -754,8 +754,11 @@ struct vkd3d_descriptor_set_context + unsigned int uav_counter_index; + unsigned int push_constant_index; + +- struct vk_binding_array *push_descriptor_set; ++ struct vk_binding_array *root_descriptor_set; ++ struct vk_binding_array *static_samplers_descriptor_set; + bool push_descriptor; ++ bool static_samplers; ++ bool use_vk_heaps; + }; + + static void descriptor_set_context_cleanup(struct vkd3d_descriptor_set_context *context) +@@ -806,13 +809,59 @@ static struct vk_binding_array *d3d12_root_signature_vk_binding_array_for_type( + { + struct vk_binding_array *array, **current; + ++ /* There are a few different ways we can reach this point: ++ * * If we are using virtual heaps we want to allocate descriptors to sets ++ * depending on their descriptor type, in order to minimize waste when ++ * recycling descriptor pools. ++ * + With the exception of root descriptors when we are using push ++ * descriptors: the push descriptors must be in a separate set, so we ++ * keep one specifically for them. ++ * * If we are using Vulkan heaps then all the root table descriptors don't ++ * even reach here, because they are managed by the D3D12 descriptor ++ * heap. Thus we only have to deal with root descriptors and static ++ * samplers. ++ * + If we're using push descriptors then again we have to dedicate a set ++ * for them, so static samplers will and up in their own set too. ++ * + If we're not using push descriptors then we can use the same set and ++ * save one. In this case we don't care too much about minimizing ++ * wasted descriptors, because few descriptors can end up here anyway. ++ */ ++ + if (context->push_descriptor) + { +- if (!context->push_descriptor_set) +- context->push_descriptor_set = d3d12_root_signature_append_vk_binding_array(root_signature, +- descriptor_type, VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, context); ++ /* The descriptor type is irrelevant here, it will never be used. */ ++ if (!context->root_descriptor_set) ++ context->root_descriptor_set = d3d12_root_signature_append_vk_binding_array(root_signature, ++ 0, VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, context); + +- return context->push_descriptor_set; ++ return context->root_descriptor_set; ++ } ++ ++ if (context->use_vk_heaps) ++ { ++ if (context->static_samplers) ++ { ++ if (!context->static_samplers_descriptor_set) ++ { ++ if (!context->push_descriptor && context->root_descriptor_set) ++ context->static_samplers_descriptor_set = context->root_descriptor_set; ++ else ++ /* The descriptor type is irrelevant here, it will never be used. */ ++ context->static_samplers_descriptor_set = d3d12_root_signature_append_vk_binding_array( ++ root_signature, 0, 0, context); ++ } ++ ++ return context->static_samplers_descriptor_set; ++ } ++ else ++ { ++ /* The descriptor type is irrelevant here, it will never be used. */ ++ if (!context->root_descriptor_set) ++ context->root_descriptor_set = d3d12_root_signature_append_vk_binding_array( ++ root_signature, 0, 0, context); ++ ++ return context->root_descriptor_set; ++ } + } + + current = context->current_binding_array; +@@ -1638,17 +1687,22 @@ static HRESULT d3d12_root_signature_init(struct d3d12_root_signature *root_signa + sizeof(*root_signature->static_samplers)))) + goto fail; + ++ context.use_vk_heaps = use_vk_heaps; + context.push_descriptor = vk_info->KHR_push_descriptor; + if (FAILED(hr = d3d12_root_signature_init_root_descriptors(root_signature, desc, &context))) + goto fail; +- root_signature->main_set = !!context.push_descriptor_set; ++ root_signature->main_set = context.root_descriptor_set && context.push_descriptor; + context.push_descriptor = false; + + if (FAILED(hr = d3d12_root_signature_init_push_constants(root_signature, desc, + root_signature->push_constant_ranges, &root_signature->push_constant_range_count))) + goto fail; ++ ++ context.static_samplers = true; + if (FAILED(hr = d3d12_root_signature_init_static_samplers(root_signature, device, desc, &context))) + goto fail; ++ context.static_samplers = false; ++ + context.push_constant_index = 0; + if (FAILED(hr = d3d12_root_signature_init_root_descriptor_tables(root_signature, desc, &info, &context))) + goto fail; +@@ -2333,7 +2387,7 @@ static HRESULT create_shader_stage(struct d3d12_device *device, + + const struct vkd3d_shader_compile_option options[] = + { +- {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_14}, ++ {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_15}, + {VKD3D_SHADER_COMPILE_OPTION_TYPED_UAV, typed_uav_compile_option(device)}, + {VKD3D_SHADER_COMPILE_OPTION_WRITE_TESS_GEOM_POINT_SIZE, 0}, + {VKD3D_SHADER_COMPILE_OPTION_FEATURE, feature_flags_compile_option(device)}, +@@ -2388,7 +2442,7 @@ static int vkd3d_scan_dxbc(const struct d3d12_device *device, const D3D12_SHADER + + const struct vkd3d_shader_compile_option options[] = + { +- {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_14}, ++ {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_15}, + {VKD3D_SHADER_COMPILE_OPTION_TYPED_UAV, typed_uav_compile_option(device)}, + }; + +@@ -4067,7 +4121,7 @@ static int compile_hlsl_cs(const struct vkd3d_shader_code *hlsl, struct vkd3d_sh + + static const struct vkd3d_shader_compile_option options[] = + { +- {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_14}, ++ {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_15}, + }; + + info.type = VKD3D_SHADER_STRUCTURE_TYPE_COMPILE_INFO; +diff --git a/libs/vkd3d/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/libs/vkd3d/vkd3d_private.h +index fd1fbb1679a..7015508e384 100644 +--- a/libs/vkd3d/libs/vkd3d/vkd3d_private.h ++++ b/libs/vkd3d/libs/vkd3d/vkd3d_private.h +@@ -127,7 +127,6 @@ struct vkd3d_vulkan_info + bool KHR_draw_indirect_count; + bool KHR_get_memory_requirements2; + bool KHR_image_format_list; +- bool KHR_maintenance2; + bool KHR_maintenance3; + bool KHR_portability_subset; + bool KHR_push_descriptor; +-- +2.47.2 +