January 2024 - Wine-Commits

Henri Verbeet : vkd3d-utils: Use debugstr_hresult() in D3DCreateBlob().
by Alexandre Julliard Jan. 17, 2024

Jan. 17, 2024

Module: vkd3d Branch: master Commit: 2476d6bd6c79e051e40846689034313252dc3bce URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/2476d6bd6c79e051e408466890343… Author: Henri Verbeet <hverbeet(a)codeweavers.com> Date: Thu Jan 11 21:39:25 2024 +0100 vkd3d-utils: Use debugstr_hresult() in D3DCreateBlob(). --- libs/vkd3d-utils/vkd3d_utils_main.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/vkd3d-utils/vkd3d_utils_main.c b/libs/vkd3d-utils/vkd3d_utils_main.c index 214ae06c..f1d6c1a5 100644 --- a/libs/vkd3d-utils/vkd3d_utils_main.c +++ b/libs/vkd3d-utils/vkd3d_utils_main.c @@ -619,7 +619,7 @@ HRESULT WINAPI D3DCreateBlob(SIZE_T data_size, ID3DBlob **blob) if (FAILED(hr = vkd3d_blob_create(data, data_size, blob))) { - WARN("Failed to create blob object, hr %#x.\n", hr); + WARN("Failed to create blob object, hr %s.\n", debugstr_hresult(hr)); vkd3d_free(data); } return hr;

1 0

Conor McCarthy : vkd3d-shader: Make the control point count the outer dimension of I/O arrays.
by Alexandre Julliard Jan. 17, 2024

Jan. 17, 2024

Module: vkd3d Branch: master Commit: 4c30b23821952d0f588046a82376f95eba361548 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/4c30b23821952d0f588046a82376f… Author: Conor McCarthy <cmccarthy(a)codeweavers.com> Date: Wed Jan 10 13:51:59 2024 +1000 vkd3d-shader: Make the control point count the outer dimension of I/O arrays. The relative-addressed case in shader_register_normalise_arrayed_addressing() leaves the control point id in idx[0], while for constant register indices it is placed in idx[1]. The latter case could be fixed instead, but placing the control point count in the outer dimension is more logical. --- libs/vkd3d-shader/ir.c | 7 +++++++ libs/vkd3d-shader/spirv.c | 20 ++++++++++---------- tests/d3d12.c | 1 - 3 files changed, 17 insertions(+), 11 deletions(-) diff --git a/libs/vkd3d-shader/ir.c b/libs/vkd3d-shader/ir.c index bdb02169..d6978171 100644 --- a/libs/vkd3d-shader/ir.c +++ b/libs/vkd3d-shader/ir.c @@ -929,6 +929,13 @@ static unsigned int shader_register_normalise_arrayed_addressing(struct vkd3d_sh reg->idx[id_idx + 1].rel_addr = NULL; reg->idx[id_idx + 1].offset = reg->idx[id_idx].offset; reg->idx[id_idx].offset -= register_index; + if (id_idx) + { + /* idx[id_idx] now contains the array index, which must be moved below the control point id. */ + struct vkd3d_shader_register_index tmp = reg->idx[id_idx]; + reg->idx[id_idx] = reg->idx[id_idx - 1]; + reg->idx[id_idx - 1] = tmp; + } ++id_idx; } /* Otherwise we have no address for the arrayed register, so insert one. This happens e.g. where diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index ad818ff4..5798f262 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -4722,7 +4722,7 @@ static uint32_t spirv_compiler_emit_builtin_variable_v(struct spirv_compiler *co assert(size_count <= ARRAY_SIZE(sizes)); memcpy(sizes, array_sizes, size_count * sizeof(sizes[0])); array_sizes = sizes; - sizes[size_count - 1] = max(sizes[size_count - 1], builtin->spirv_array_size); + sizes[0] = max(sizes[0], builtin->spirv_array_size); id = spirv_compiler_emit_array_variable(compiler, &builder->global_stream, storage_class, builtin->component_type, builtin->component_count, array_sizes, size_count); @@ -4793,12 +4793,12 @@ static uint32_t spirv_compiler_emit_input(struct spirv_compiler *compiler, builtin = get_spirv_builtin_for_sysval(compiler, sysval); - array_sizes[0] = (reg_type == VKD3DSPR_PATCHCONST ? 0 : compiler->input_control_point_count); - array_sizes[1] = signature_element->register_count; - if (array_sizes[1] == 1 && !vsir_sysval_semantic_is_tess_factor(signature_element->sysval_semantic) - && (!vsir_sysval_semantic_is_clip_cull(signature_element->sysval_semantic) || array_sizes[0])) + array_sizes[0] = signature_element->register_count; + array_sizes[1] = (reg_type == VKD3DSPR_PATCHCONST ? 0 : compiler->input_control_point_count); + if (array_sizes[0] == 1 && !vsir_sysval_semantic_is_tess_factor(signature_element->sysval_semantic) + && (!vsir_sysval_semantic_is_clip_cull(signature_element->sysval_semantic) || array_sizes[1])) { - array_sizes[1] = 0; + array_sizes[0] = 0; } write_mask = signature_element->mask; @@ -5135,10 +5135,10 @@ static void spirv_compiler_emit_output(struct spirv_compiler *compiler, /* Don't use builtins for TCS -> TES varyings. See spirv_compiler_emit_input(). */ if (compiler->shader_type == VKD3D_SHADER_TYPE_HULL && !is_patch_constant) sysval = VKD3D_SHADER_SV_NONE; - array_sizes[0] = (reg_type == VKD3DSPR_PATCHCONST ? 0 : compiler->output_control_point_count); - array_sizes[1] = signature_element->register_count; - if (array_sizes[1] == 1 && !vsir_sysval_semantic_is_tess_factor(signature_element->sysval_semantic)) - array_sizes[1] = 0; + array_sizes[0] = signature_element->register_count; + array_sizes[1] = (reg_type == VKD3DSPR_PATCHCONST ? 0 : compiler->output_control_point_count); + if (array_sizes[0] == 1 && !vsir_sysval_semantic_is_tess_factor(signature_element->sysval_semantic)) + array_sizes[0] = 0; builtin = vkd3d_get_spirv_builtin(compiler, reg_type, sysval); diff --git a/tests/d3d12.c b/tests/d3d12.c index 9154db13..6bdb5f7a 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -37822,7 +37822,6 @@ static void test_hull_shader_punned_array(void) transition_resource_state(command_list, context.render_target, D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE); - todo check_sub_resource_uint(context.render_target, 0, queue, command_list, 0xcc996633, 0); destroy_test_context(&context);

1 0

Conor McCarthy : tests: Test punned array access in patch constant functions.
by Alexandre Julliard Jan. 17, 2024

Jan. 17, 2024

Module: vkd3d Branch: master Commit: b8561d6fd208b6ee887d0501e4e841ba4a4aad4b URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/b8561d6fd208b6ee887d0501e4e84… Author: Conor McCarthy <cmccarthy(a)codeweavers.com> Date: Tue Jan 9 13:52:14 2024 +1000 tests: Test punned array access in patch constant functions. The FXC optimiser sometimes converts a local array of input values into direct array addressing of the inputs, which can result in a dcl_indexrange instruction spanning input elements with different masks. --- tests/d3d12.c | 262 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 262 insertions(+)

1 0

Conor McCarthy : vkd3d-shader/tpf: Validate sysvals in index range declarations.
by Alexandre Julliard Jan. 17, 2024

Jan. 17, 2024

Module: vkd3d Branch: master Commit: c40093474e27ad3eb2c37d59b67cbfb99b10c352 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/c40093474e27ad3eb2c37d59b67cb… Author: Conor McCarthy <cmccarthy(a)codeweavers.com> Date: Tue Jan 9 14:20:16 2024 +1000 vkd3d-shader/tpf: Validate sysvals in index range declarations. --- libs/vkd3d-shader/tpf.c | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/libs/vkd3d-shader/tpf.c b/libs/vkd3d-shader/tpf.c index f96e4145..e4dfb523 100644 --- a/libs/vkd3d-shader/tpf.c +++ b/libs/vkd3d-shader/tpf.c @@ -919,6 +919,7 @@ static void shader_sm4_read_dcl_index_range(struct vkd3d_shader_instruction *ins { struct vkd3d_shader_index_range *index_range = &ins->declaration.index_range; unsigned int i, register_idx, register_count; + const struct shader_signature *signature; enum vkd3d_shader_register_type type; struct sm4_index_range_array *ranges; unsigned int *io_masks; @@ -938,27 +939,32 @@ static void shader_sm4_read_dcl_index_range(struct vkd3d_shader_instruction *ins case VKD3DSPR_INCONTROLPOINT: io_masks = priv->input_register_masks; ranges = &priv->input_index_ranges; + signature = &priv->p.shader_desc.input_signature; break; case VKD3DSPR_OUTPUT: if (sm4_parser_is_in_fork_or_join_phase(priv)) { io_masks = priv->patch_constant_register_masks; ranges = &priv->patch_constant_index_ranges; + signature = &priv->p.shader_desc.patch_constant_signature; } else { io_masks = priv->output_register_masks; ranges = &priv->output_index_ranges; + signature = &priv->p.shader_desc.output_signature; } break; case VKD3DSPR_COLOROUT: case VKD3DSPR_OUTCONTROLPOINT: io_masks = priv->output_register_masks; ranges = &priv->output_index_ranges; + signature = &priv->p.shader_desc.output_signature; break; case VKD3DSPR_PATCHCONST: io_masks = priv->patch_constant_register_masks; ranges = &priv->patch_constant_index_ranges; + signature = &priv->p.shader_desc.patch_constant_signature; break; default: @@ -996,6 +1002,18 @@ static void shader_sm4_read_dcl_index_range(struct vkd3d_shader_instruction *ins for (i = 0; i < register_count; ++i) { + const struct signature_element *e = vsir_signature_find_element_for_reg(signature, register_idx + i, write_mask); + /* Index ranges should not contain non-arrayed sysvals. FXC tries to forbid this but it is buggy, + * and can emit a range containing a sysval if the sysval is not actually accessed. */ + if (e && e->sysval_semantic && register_count > 1 && !vsir_sysval_semantic_is_tess_factor(e->sysval_semantic) + && !vsir_sysval_semantic_is_clip_cull(e->sysval_semantic)) + { + WARN("Sysval %u included in an index range declaration.\n", e->sysval_semantic); + vkd3d_shader_parser_error(&priv->p, VKD3D_SHADER_ERROR_TPF_INVALID_INDEX_RANGE_DCL, + "Index range base %u, count %u, mask %#x contains sysval %u.", + register_idx, register_count, write_mask, e->sysval_semantic); + return; + } if ((io_masks[register_idx + i] & write_mask) != write_mask) { WARN("No matching declaration for index range base %u, count %u, mask %#x.\n",

1 0

Henri Verbeet : vkd3d-common: Introduce vkd3d_atomic_increment_u64().
by Alexandre Julliard Jan. 17, 2024

Jan. 17, 2024

Module: vkd3d Branch: master Commit: 71decc927f1c9621efabe41114de4ac80fe54c02 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/71decc927f1c9621efabe41114de4… Author: Henri Verbeet <hverbeet(a)codeweavers.com> Date: Thu Jan 11 00:54:53 2024 +0100 vkd3d-common: Introduce vkd3d_atomic_increment_u64(). --- include/private/vkd3d_common.h | 20 ++++++++++++++++---- libs/vkd3d/resource.c | 4 ++-- libs/vkd3d/vkd3d_private.h | 2 +- 3 files changed, 19 insertions(+), 7 deletions(-) diff --git a/include/private/vkd3d_common.h b/include/private/vkd3d_common.h index cc9e4326..f01c7125 100644 --- a/include/private/vkd3d_common.h +++ b/include/private/vkd3d_common.h @@ -267,16 +267,28 @@ static inline int ascii_strcasecmp(const char *a, const char *b) return c_a - c_b; } +static inline uint64_t vkd3d_atomic_add_fetch_u64(uint64_t volatile *x, uint64_t val) +{ +#if HAVE_SYNC_ADD_AND_FETCH + return __sync_add_and_fetch(x, val); +#elif defined(_WIN32) + return InterlockedAdd64((LONG64 *)x, val); +#else +# error "vkd3d_atomic_add_fetch_u64() not implemented for this platform" +#endif +} + +static inline uint64_t vkd3d_atomic_increment_u64(uint64_t volatile *x) +{ + return vkd3d_atomic_add_fetch_u64(x, 1); +} + #ifndef _WIN32 # if HAVE_SYNC_ADD_AND_FETCH static inline LONG InterlockedIncrement(LONG volatile *x) { return __sync_add_and_fetch(x, 1); } -static inline LONG64 InterlockedIncrement64(LONG64 volatile *x) -{ - return __sync_add_and_fetch(x, 1); -} # else # error "InterlockedIncrement() not implemented for this platform" # endif /* HAVE_SYNC_ADD_AND_FETCH */ diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index 163dd6ce..f9e50335 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -22,7 +22,7 @@ #define VKD3D_NULL_BUFFER_SIZE 16 #define VKD3D_NULL_VIEW_FORMAT DXGI_FORMAT_R8G8B8A8_UNORM -LONG64 object_global_serial_id; +uint64_t object_global_serial_id; static inline bool is_cpu_accessible_heap(const D3D12_HEAP_PROPERTIES *properties) { @@ -4314,7 +4314,7 @@ static HRESULT d3d12_descriptor_heap_init(struct d3d12_descriptor_heap *descript descriptor_heap->ID3D12DescriptorHeap_iface.lpVtbl = &d3d12_descriptor_heap_vtbl; descriptor_heap->refcount = 1; - descriptor_heap->serial_id = InterlockedIncrement64(&object_global_serial_id); + descriptor_heap->serial_id = vkd3d_atomic_increment_u64(&object_global_serial_id); descriptor_heap->desc = *desc; diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 71945ea1..7d159a17 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -67,7 +67,7 @@ * this number to prevent excessive pool memory use. */ #define VKD3D_MAX_VIRTUAL_HEAP_DESCRIPTORS_PER_TYPE (16 * 1024u) -extern LONG64 object_global_serial_id; +extern uint64_t object_global_serial_id; struct d3d12_command_list; struct d3d12_device;

1 0

Conor McCarthy : vkd3d-shader/ir: Expand index range write masks to cover all element masks.
by Alexandre Julliard Jan. 17, 2024

Jan. 17, 2024

Module: vkd3d Branch: master Commit: 418e8d8100334b2819e8b0a56a021bb555cfb99e URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/418e8d8100334b2819e8b0a56a021… Author: Conor McCarthy <cmccarthy(a)codeweavers.com> Date: Thu Jan 4 16:05:15 2024 +1000 vkd3d-shader/ir: Expand index range write masks to cover all element masks. For example, this occurred in a shader: reg_idx write_mask 0 xyz 1 xyzw 2 xyzw 3 xyz The dcl_indexrange instruction covered only xyz, so once merged, searching for xyzw failed. It is impossible to declare an input array where elements have different component counts, but the optimiser can create this case. One way for this to occur is to dynamically index input values via a local array containing copies of the input values. The optimiser converts this to dynamically indexed inputs. --- libs/vkd3d-shader/ir.c | 57 +++++++++++++++++++++++++++++++++++++++++++++++-- libs/vkd3d-shader/tpf.c | 7 ------ 2 files changed, 55 insertions(+), 9 deletions(-) diff --git a/libs/vkd3d-shader/ir.c b/libs/vkd3d-shader/ir.c index 5455d7d6..bdb02169 100644 --- a/libs/vkd3d-shader/ir.c +++ b/libs/vkd3d-shader/ir.c @@ -603,7 +603,7 @@ static bool io_normaliser_is_in_control_point_phase(const struct io_normaliser * static unsigned int shader_signature_find_element_for_reg(const struct shader_signature *signature, unsigned int reg_idx, unsigned int write_mask) { - unsigned int i; + unsigned int i, base_write_mask; for (i = 0; i < signature->element_count; ++i) { @@ -615,7 +615,14 @@ static unsigned int shader_signature_find_element_for_reg(const struct shader_si } } - /* Validated in the TPF reader. */ + /* Validated in the TPF reader, but failure in signature_element_range_expand_mask() + * can land us here on an unmatched vector mask. */ + FIXME("Failed to find signature element for register index %u, mask %#x; using scalar mask.\n", + reg_idx, write_mask); + base_write_mask = 1u << vsir_write_mask_get_component_idx(write_mask); + if (base_write_mask != write_mask) + return shader_signature_find_element_for_reg(signature, reg_idx, base_write_mask); + vkd3d_unreachable(); } @@ -782,6 +789,51 @@ 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], bool is_patch_constant) { @@ -852,6 +904,7 @@ static bool shader_signature_merge(struct shader_signature *s, uint8_t range_map { 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); } } element_count = new_count; diff --git a/libs/vkd3d-shader/tpf.c b/libs/vkd3d-shader/tpf.c index 932f185d..f96e4145 100644 --- a/libs/vkd3d-shader/tpf.c +++ b/libs/vkd3d-shader/tpf.c @@ -932,13 +932,6 @@ static void shader_sm4_read_dcl_index_range(struct vkd3d_shader_instruction *ins register_count = index_range->register_count; write_mask = index_range->dst.write_mask; - if (vsir_write_mask_component_count(write_mask) != 1) - { - WARN("Unhandled write mask %#x.\n", write_mask); - vkd3d_shader_parser_warning(&priv->p, VKD3D_SHADER_WARNING_TPF_UNHANDLED_INDEX_RANGE_MASK, - "Index range mask %#x is not scalar.", write_mask); - } - switch ((type = index_range->dst.reg.type)) { case VKD3DSPR_INPUT:

1 0

Zebediah Figura : vkd3d-shader/hlsl: Separate an add_ternary() helper.
by Alexandre Julliard Jan. 17, 2024

Jan. 17, 2024

Module: vkd3d Branch: master Commit: 46bd0993412f918a3620dfe89731a19b53ef8312 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/46bd0993412f918a3620dfe89731a… Author: Zebediah Figura <zfigura(a)codeweavers.com> Date: Fri Jun 30 18:09:51 2023 -0500 vkd3d-shader/hlsl: Separate an add_ternary() helper. --- libs/vkd3d-shader/hlsl.y | 37 ++++++++++++++++++++++--------------- 1 file changed, 22 insertions(+), 15 deletions(-) diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y index b11cbde2..ccd087eb 100644 --- a/libs/vkd3d-shader/hlsl.y +++ b/libs/vkd3d-shader/hlsl.y @@ -4085,6 +4085,27 @@ static struct hlsl_block *add_constructor(struct hlsl_ctx *ctx, struct hlsl_type return params->instrs; } +static bool add_ternary(struct hlsl_ctx *ctx, struct hlsl_block *block, + struct hlsl_ir_node *cond, struct hlsl_ir_node *first, struct hlsl_ir_node *second) +{ + struct hlsl_ir_node *args[HLSL_MAX_OPERANDS] = {0}; + struct hlsl_type *common_type; + + if (!(common_type = get_common_numeric_type(ctx, first, second, &first->loc))) + return false; + + if (!(first = add_implicit_conversion(ctx, block, first, common_type, &first->loc))) + return false; + + if (!(second = add_implicit_conversion(ctx, block, second, common_type, &second->loc))) + return false; + + args[0] = cond; + args[1] = first; + args[2] = second; + return add_expr(ctx, block, HLSL_OP3_TERNARY, args, common_type, &first->loc); +} + static unsigned int hlsl_offset_dim_count(enum hlsl_sampler_dim dim) { switch (dim) @@ -7202,27 +7223,13 @@ conditional_expr: struct hlsl_ir_node *cond = node_from_block($1); struct hlsl_ir_node *first = node_from_block($3); struct hlsl_ir_node *second = node_from_block($5); - struct hlsl_ir_node *args[HLSL_MAX_OPERANDS] = { 0 }; - struct hlsl_type *common_type; hlsl_block_add_block($1, $3); hlsl_block_add_block($1, $5); destroy_block($3); destroy_block($5); - if (!(common_type = get_common_numeric_type(ctx, first, second, &@3))) - YYABORT; - - if (!(first = add_implicit_conversion(ctx, $1, first, common_type, &@3))) - YYABORT; - - if (!(second = add_implicit_conversion(ctx, $1, second, common_type, &@5))) - YYABORT; - - args[0] = cond; - args[1] = first; - args[2] = second; - if (!add_expr(ctx, $1, HLSL_OP3_TERNARY, args, common_type, &@1)) + if (!add_ternary(ctx, $1, cond, first, second)) YYABORT; $$ = $1; }

1 0

Zebediah Figura : vkd3d-shader/hlsl: Allow non-numeric types in the ternary operator.
by Alexandre Julliard Jan. 17, 2024

Jan. 17, 2024

Module: vkd3d Branch: master Commit: 16962ac6f10e85472a80f5f5ff90879d69320884 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/16962ac6f10e85472a80f5f5ff908… Author: Zebediah Figura <zfigura(a)codeweavers.com> Date: Thu Nov 9 19:43:31 2023 -0600 vkd3d-shader/hlsl: Allow non-numeric types in the ternary operator. --- libs/vkd3d-shader/hlsl.y | 34 ++++++++++++++++++++++++++++------ tests/hlsl/ternary.shader_test | 2 +- 2 files changed, 29 insertions(+), 7 deletions(-) diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y index ccd087eb..e30b3dc5 100644 --- a/libs/vkd3d-shader/hlsl.y +++ b/libs/vkd3d-shader/hlsl.y @@ -4091,14 +4091,36 @@ static bool add_ternary(struct hlsl_ctx *ctx, struct hlsl_block *block, struct hlsl_ir_node *args[HLSL_MAX_OPERANDS] = {0}; struct hlsl_type *common_type; - if (!(common_type = get_common_numeric_type(ctx, first, second, &first->loc))) - return false; + if (first->data_type->class <= HLSL_CLASS_LAST_NUMERIC + && second->data_type->class <= HLSL_CLASS_LAST_NUMERIC) + { + if (!(common_type = get_common_numeric_type(ctx, first, second, &first->loc))) + return false; - if (!(first = add_implicit_conversion(ctx, block, first, common_type, &first->loc))) - return false; + if (!(first = add_implicit_conversion(ctx, block, first, common_type, &first->loc))) + return false; - if (!(second = add_implicit_conversion(ctx, block, second, common_type, &second->loc))) - return false; + if (!(second = add_implicit_conversion(ctx, block, second, common_type, &second->loc))) + return false; + } + else + { + struct vkd3d_string_buffer *first_string, *second_string; + + if (!hlsl_types_are_equal(first->data_type, second->data_type)) + { + first_string = hlsl_type_to_string(ctx, first->data_type); + second_string = hlsl_type_to_string(ctx, second->data_type); + if (first_string && second_string) + hlsl_error(ctx, &first->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE, + "Ternary argument types '%s' and '%s' do not match.", + first_string->buffer, second_string->buffer); + hlsl_release_string_buffer(ctx, first_string); + hlsl_release_string_buffer(ctx, second_string); + } + + common_type = first->data_type; + } args[0] = cond; args[1] = first; diff --git a/tests/hlsl/ternary.shader_test b/tests/hlsl/ternary.shader_test index e91f0329..50f40201 100644 --- a/tests/hlsl/ternary.shader_test +++ b/tests/hlsl/ternary.shader_test @@ -329,7 +329,7 @@ float4 main() : sv_target } -[pixel shader fail] +[pixel shader fail todo] Texture2D t; float4 f;

1 0

Zebediah Figura : tests: Add many more tests for ternary expressions.
by Alexandre Julliard Jan. 17, 2024

Jan. 17, 2024

Module: vkd3d Branch: master Commit: 9ac210eb1efb5d705a7aaba5ae8b36f84cc740a8 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/9ac210eb1efb5d705a7aaba5ae8b3… Author: Zebediah Figura <zfigura(a)codeweavers.com> Date: Thu Nov 9 19:41:10 2023 -0600 tests: Add many more tests for ternary expressions. --- Makefile.am | 1 + tests/hlsl/sm6-ternary.shader_test | 46 ++++++ tests/hlsl/ternary.shader_test | 315 +++++++++++++++++++++++++++++++++++-- 3 files changed, 347 insertions(+), 15 deletions(-) diff --git a/Makefile.am b/Makefile.am index bc648b63..648dfb25 100644 --- a/Makefile.am +++ b/Makefile.am @@ -163,6 +163,7 @@ vkd3d_shader_tests = \ tests/hlsl/side-effects.shader_test \ tests/hlsl/sign.shader_test \ tests/hlsl/single-numeric-initializer.shader_test \ + tests/hlsl/sm6-ternary.shader_test \ tests/hlsl/smoothstep.shader_test \ tests/hlsl/sqrt.shader_test \ tests/hlsl/state-block-syntax.shader_test \ diff --git a/tests/hlsl/sm6-ternary.shader_test b/tests/hlsl/sm6-ternary.shader_test new file mode 100644 index 00000000..349d3267 --- /dev/null +++ b/tests/hlsl/sm6-ternary.shader_test @@ -0,0 +1,46 @@ +% The ternary operator works differently in sm6. +% It now shortcuts, and is no longer per-component. + +[require] +shader model >= 6.0 + +[pixel shader] +uniform float4 x; + +float4 main() : sv_target +{ + return x.x ? x : x - 1; +} + +[test] +uniform 0 float4 2.0 3.0 4.0 5.0 +todo draw quad +probe all rgba (2.0, 3.0, 4.0, 5.0) +uniform 0 float4 0.0 10.0 11.0 12.0 +todo draw quad +probe all rgba (-1.0, 9.0, 10.0, 11.0) + + +[pixel shader] +float4 f; + +float4 main() : sv_target +{ + float f1 = 0.1, f2 = 0.2, f3; + f3 = f.x ? (f1 = 0.5) + 0.2 : (f2 = 0.6); + return float4(f1, f2, f3, 0.0); +} + +[test] +uniform 0 float4 1.0 0.0 0.0 0.0 +draw quad +probe all rgba (0.5, 0.2, 0.7, 0.0) + + +[pixel shader fail] +float4 x, y, z; + +float4 main() : sv_target +{ + return x ? y : z; +} diff --git a/tests/hlsl/ternary.shader_test b/tests/hlsl/ternary.shader_test index 7b4c71f7..e91f0329 100644 --- a/tests/hlsl/ternary.shader_test +++ b/tests/hlsl/ternary.shader_test @@ -1,3 +1,8 @@ +[require] +% The ternary operator works differently in sm6. See sm6-ternary.shader_test. +shader model < 6.0 + + [pixel shader] uniform float4 x; @@ -8,12 +13,13 @@ float4 main() : sv_target [test] uniform 0 float4 2.0 3.0 4.0 5.0 -todo(sm>=6) draw quad +draw quad probe all rgba (2.0, 3.0, 4.0, 5.0) uniform 0 float4 0.0 10.0 11.0 12.0 -todo(sm>=6) draw quad +draw quad probe all rgba (-1.0, 9.0, 10.0, 11.0) + [pixel shader] uniform float4 x; @@ -32,6 +38,7 @@ uniform 0 float4 1.1 3.0 4.0 5.0 draw quad probe all rgba (1.1, 2.0, 0.0, 0.0) + [pixel shader] float4 f; @@ -42,37 +49,315 @@ float4 main() : sv_target return float4(f1, f2, f3, 0.0); } -[require] -shader model < 6.0 [test] uniform 0 float4 1.0 0.0 0.0 0.0 draw quad probe all rgba (0.5, 0.6, 0.7, 0.0) -[require] -shader model >= 6.0 + +[pixel shader] +float4 x, y, z; + +float4 main() : sv_target +{ + return x ? y : z; +} [test] -uniform 0 float4 1.0 0.0 0.0 0.0 +uniform 0 float4 0.0 1.0 0.0 -3.0 +uniform 4 float4 1.0 2.0 3.0 4.0 +uniform 8 float4 5.0 6.0 7.0 8.0 draw quad -probe all rgba (0.5, 0.2, 0.7, 0.0) +probe all rgba (5.0, 2.0, 7.0, 4.0) -[require] -% reset requirements +% The usual type conversion is applied to the first and second expression, as +% long as they are numeric. -[pixel shader fail(sm>=6)] -float4 x, y, z; +[pixel shader fail] + +uniform float2x4 a; +uniform float3x2 b; float4 main() : sv_target { - return x ? y : z; + 0 ? a : b; + return 0; +} + + +[pixel shader] + +static float3x3 a = {0, 1, 2, 3, 4, 5, 6, 7, 8}; +static float2x2 b = {.1, .2, .3, .4}; + +float4 main() : sv_target +{ + return float4(1 ? a : b); } [test] -uniform 0 float4 0.0 1.0 0.0 -3.0 +draw quad +probe all rgba (0.0, 1.0, 3.0, 4.0) + + +[pixel shader] + +static float3 a = {0, 1, 2}; +static float4 b = {5, 6, 7, 8}; + +float4 main() : sv_target +{ + return float4(0 ? a : b, 1.0); +} + +[test] +draw quad +todo probe all rgba (5.0, 6.0, 7.0, 1.0) + + +% More restrictions are placed on the type of the first (condition) operand, +% relative to the common type computed from the other two (result). Either: +% * the class and dimensions must match exactly; +% * the condition operand is scalar; +% * the result operands are scalar; +% * one is a typeN and the other is a type1xN + +[pixel shader fail todo] + +uniform float4 cond; +uniform float2x2 a, b; + +float4 main() : sv_target +{ + return float4(cond ? a : b); +} + + +[pixel shader fail todo] + +uniform float2x2 cond; +uniform float4 a, b; + +float4 main() : sv_target +{ + return float4(cond ? a : b); +} + + +[pixel shader] + +static float2x2 cond = {1, 0, 0, 1}; +static float2x2 a = {1, 2, 3, 4}; +static float2x2 b = {5, 6, 7, 8}; + +float4 main() : sv_target +{ + return float4(cond ? a : b); +} + +[test] +draw quad +probe all rgba (1.0, 6.0, 7.0, 4.0) + + +[pixel shader fail todo] + +uniform float3 cond; +uniform float4 a, b; + +float4 main() : sv_target +{ + (cond ? a : b); + return 0; +} + + +[pixel shader fail todo] + +uniform float4 cond; +uniform float4x1 a, b; + +float4 main() : sv_target +{ + (cond ? a : b); + return 0; +} + + +% As may be expected, this yields the type of the arguments, not the conditional. + +[pixel shader] + +static float4 cond = {1, 0, 0, 1}; +static float1x4 a = {1, 2, 3, 4}; +static float1x4 b = {5, 6, 7, 8}; + +float4 main() : sv_target +{ + return (cond ? a : b)[0]; +} + +[test] +draw quad +probe all rgba (1.0, 6.0, 7.0, 4.0) + + +[pixel shader todo] + +static float1x4 cond = {1, 0, 0, 1}; +static float4 a = {1, 2, 3, 4}; +static float4 b = {5, 6, 7, 8}; + +float4 main() : sv_target +{ + return (cond ? a : b)[0]; +} + +[test] +todo draw quad +probe all rgba (1.0, 1.0, 1.0, 1.0) + + +[pixel shader fail] + +uniform float1x4 cond; +uniform float4 a, b; + +float4 main() : sv_target +{ + return (cond ? a : b)[0][0]; +} + + +[pixel shader] + +static float1 cond = {0}; +static float1x1 a = {2}; +static float1x1 b = {3}; + +float4 main() : sv_target +{ + return (cond ? a : b)[0][0]; +} + +[test] +draw quad +probe all rgba (3.0, 3.0, 3.0, 3.0) + + +[pixel shader] + +uniform float cond; +uniform float4 a, b; + +float4 main() : sv_target +{ + return float4(cond ? a : b); +} + +[test] +uniform 0 float4 1.0 0.0 0.0 0.0 uniform 4 float4 1.0 2.0 3.0 4.0 uniform 8 float4 5.0 6.0 7.0 8.0 draw quad -probe all rgba (5.0, 2.0, 7.0, 4.0) +probe all rgba (1.0, 2.0, 3.0, 4.0) + + +[pixel shader todo] + +// "scalar" can mean any 1-component numeric type. +static float1x1 cond = {0}; +static float4 a = {1, 2, 3, 4}; +static float4 b = {5, 6, 7, 8}; + +float4 main() : sv_target +{ + return float4(cond ? a : b); +} + +[test] +todo draw quad +probe all rgba (5.0, 6.0, 7.0, 8.0) + + +[pixel shader todo] + +uniform float4 cond; +uniform float4 a, b; + +float4 main() : sv_target +{ + return float4(cond ? a.x : b.x); +} + +[test] +uniform 0 float4 1.0 0.0 1.0 0.0 +uniform 4 float4 1.0 2.0 3.0 4.0 +uniform 8 float4 5.0 6.0 7.0 8.0 +todo draw quad +probe all rgba (1.0, 5.0, 1.0, 5.0) + + +[pixel shader todo] + +// "scalar" can mean any 1-component numeric type. +static float4 cond = {1, 0, 0, 1}; +static float1x1 a = {2}; +static float1x1 b = {3}; + +float4 main() : sv_target +{ + return float4(cond ? a : b); +} + +[test] +todo draw quad +probe all rgba (2.0, 3.0, 3.0, 2.0) + + +% Objects can be used, but their types have to be identical. + +[pixel shader todo] +Texture2D t; + +float4 main() : sv_target +{ + Texture2D tmp = 0 ? t : t; + return 0; +} + + +[pixel shader fail] +Texture2D t; +float4 f; + +float4 main() : sv_target +{ + f ? t : t; + return 0; +} + + +[pixel shader fail] +Texture2D t; +Texture3D u; + +float4 main() : sv_target +{ + 0 ? t : u; + return 0; +} + + +% Of course objects cannot be used as the condition. + +[pixel shader fail todo] +Texture2D t; + +float4 main() : sv_target +{ + t ? 0 : 1; + return 0; +}

1 0

Zebediah Figura : vkd3d-shader/hlsl: Remove a redundant definition of the "float" type.
by Alexandre Julliard Jan. 17, 2024

Jan. 17, 2024

Module: vkd3d Branch: master Commit: e0b1f2e2732b9c1de7b0a8a657631c22040a3a65 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/e0b1f2e2732b9c1de7b0a8a657631… Author: Zebediah Figura <zfigura(a)codeweavers.com> Date: Fri Sep 8 17:01:46 2023 -0500 vkd3d-shader/hlsl: Remove a redundant definition of the "float" type. --- libs/vkd3d-shader/hlsl.c | 1 - 1 file changed, 1 deletion(-) diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c index 1e247445..6a5a6d0e 100644 --- a/libs/vkd3d-shader/hlsl.c +++ b/libs/vkd3d-shader/hlsl.c @@ -3363,7 +3363,6 @@ static void declare_predefined_types(struct hlsl_ctx *ctx) effect_types[] = { {"dword", HLSL_CLASS_SCALAR, HLSL_TYPE_UINT, 1, 1}, - {"float", HLSL_CLASS_SCALAR, HLSL_TYPE_FLOAT, 1, 1}, {"vector", HLSL_CLASS_VECTOR, HLSL_TYPE_FLOAT, 4, 1}, {"matrix", HLSL_CLASS_MATRIX, HLSL_TYPE_FLOAT, 4, 4}, {"fxgroup", HLSL_CLASS_OBJECT, HLSL_TYPE_EFFECT_GROUP, 1, 1},

1 0