July 2023 - Wine-commits - list.winehq.org

Zebediah Figura : vkd3d-shader/hlsl: Free the constant defs array in hlsl_ctx_cleanup().
by Alexandre Julliard 17 Jul '23

17 Jul '23

Module: vkd3d Branch: master Commit: 44bf5556ae00f7d82093a8302aa8597f1b350b4d URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/44bf5556ae00f7d82093a8302aa85… Author: Zebediah Figura <zfigura(a)codeweavers.com> Date: Tue Jul 11 17:36:59 2023 -0500 vkd3d-shader/hlsl: Free the constant defs array in hlsl_ctx_cleanup(). Spotted by Francisco Casas. --- libs/vkd3d-shader/hlsl.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c index ab508502..369af86b 100644 --- a/libs/vkd3d-shader/hlsl.c +++ b/libs/vkd3d-shader/hlsl.c @@ -3380,6 +3380,8 @@ static void hlsl_ctx_cleanup(struct hlsl_ctx *ctx) vkd3d_free((void *)buffer->name); vkd3d_free(buffer); } + + vkd3d_free(ctx->constant_defs.regs); } int hlsl_compile_shader(const struct vkd3d_shader_code *hlsl, const struct vkd3d_shader_compile_info *compile_info,

1 0

Nikolay Sivov : tests: Add a test for side effects of ternary operator.
by Alexandre Julliard 17 Jul '23

17 Jul '23

Module: vkd3d Branch: master Commit: a18ace731d3da2aaf88906c115ee3417fcbb4a72 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/a18ace731d3da2aaf88906c115ee3… Author: Nikolay Sivov <nsivov(a)codeweavers.com> Date: Mon Jul 10 16:04:21 2023 +0200 tests: Add a test for side effects of ternary operator. Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- tests/hlsl/ternary.shader_test | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/tests/hlsl/ternary.shader_test b/tests/hlsl/ternary.shader_test index 1fc2f070..99fee241 100644 --- a/tests/hlsl/ternary.shader_test +++ b/tests/hlsl/ternary.shader_test @@ -31,3 +31,18 @@ float4 main() : sv_target 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; + +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.6, 0.7, 0.0)

1 0

Zebediah Figura : include: Define an API for d3dbc constants.
by Alexandre Julliard 17 Jul '23

17 Jul '23

Module: vkd3d Branch: master Commit: 55c5129ad9ee138b46e66a07e0ca5c37f97d2288 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/55c5129ad9ee138b46e66a07e0ca5… Author: Zebediah Figura <zfigura(a)codeweavers.com> Date: Mon Feb 27 23:56:09 2023 -0600 include: Define an API for d3dbc constants. --- include/vkd3d_shader.h | 42 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 41 insertions(+), 1 deletion(-) diff --git a/include/vkd3d_shader.h b/include/vkd3d_shader.h index 6c17a07b..8133d240 100644 --- a/include/vkd3d_shader.h +++ b/include/vkd3d_shader.h @@ -332,6 +332,25 @@ struct vkd3d_shader_parameter } u; }; +/** + * Symbolic register indices for mapping uniform constant register sets in + * legacy Direct3D bytecode to constant buffer views in the target environment. + * + * Members of this enumeration are used in + * \ref vkd3d_shader_resource_binding.register_index. + * + * \since 1.9 + */ +enum vkd3d_shader_d3dbc_constant_register +{ + /** The float constant register set, c# in Direct3D assembly. */ + VKD3D_SHADER_D3DBC_FLOAT_CONSTANT_REGISTER = 0x0, + /** The integer constant register set, i# in Direct3D assembly. */ + VKD3D_SHADER_D3DBC_INT_CONSTANT_REGISTER = 0x1, + /** The boolean constant register set, b# in Direct3D assembly. */ + VKD3D_SHADER_D3DBC_BOOL_CONSTANT_REGISTER = 0x2, +}; + /** * Describes the mapping of a single resource or resource array to its binding * point in the target environment. @@ -356,7 +375,14 @@ struct vkd3d_shader_resource_binding * support multiple register spaces, this parameter must be set to 0. */ unsigned int register_space; - /** Register index of the DXBC resource. */ + /** + * Register index of the Direct3D resource. + * + * For legacy Direct3D shaders, vkd3d-shader maps each constant register + * set to a single constant buffer view. This parameter names the register + * set to map, and must be a member of + * enum vkd3d_shader_d3dbc_constant_register. + */ unsigned int register_index; /** Shader stage(s) to which the resource is visible. */ enum vkd3d_shader_visibility shader_visibility; @@ -1330,6 +1356,20 @@ struct vkd3d_shader_descriptor_info * A chained structure enumerating the descriptors declared by a shader. * * This structure extends vkd3d_shader_compile_info. + * + * When scanning a legacy Direct3D shader, vkd3d-shader enumerates each + * constant register set used by the shader as a single constant buffer + * descriptor, as follows: + * - The \ref vkd3d_shader_descriptor_info.type field is set to + * VKD3D_SHADER_DESCRIPTOR_TYPE_CBV. + * - The \ref vkd3d_shader_descriptor_info.register_space field is set to zero. + * - The \ref vkd3d_shader_descriptor_info.register_index field is set to a + * member of enum vkd3d_shader_d3dbc_constant_register denoting which set + * is used. + * - The \ref vkd3d_shader_descriptor_info.count field is set to one. + * + * In summary, there may be up to three such descriptors, one for each register + * set used by the shader: float, integer, and boolean. */ struct vkd3d_shader_scan_descriptor_info {

1 0

Zebediah Figura : vkd3d-shader/d3dbc: Scan descriptors for constant register sets.
by Alexandre Julliard 17 Jul '23

17 Jul '23

Module: vkd3d Branch: master Commit: d077562f797639b2882bf547fbf566e8ebf6e891 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/d077562f797639b2882bf547fbf56… Author: Zebediah Figura <zfigura(a)codeweavers.com> Date: Tue Feb 28 00:07:14 2023 -0600 vkd3d-shader/d3dbc: Scan descriptors for constant register sets. --- include/private/vkd3d_common.h | 15 +++++ libs/vkd3d-shader/d3dbc.c | 85 ++++++++++++++++++++++++++-- libs/vkd3d-shader/vkd3d_shader_main.c | 9 +++ libs/vkd3d-shader/vkd3d_shader_private.h | 5 ++ tests/vkd3d_shader_api.c | 95 ++++++++++++++++++++++++++++++++ 5 files changed, 204 insertions(+), 5 deletions(-)

1 0

Zebediah Figura : vkd3d-shader/ir: Move normalization code from spirv.c to ir.c.
by Alexandre Julliard 17 Jul '23

17 Jul '23

Module: vkd3d Branch: master Commit: e9fb067d4c1f60925d3ef7389f673cc034a686cf URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/e9fb067d4c1f60925d3ef7389f673… Author: Zebediah Figura <zfigura(a)codeweavers.com> Date: Sun Jul 2 20:23:07 2023 -0500 vkd3d-shader/ir: Move normalization code from spirv.c to ir.c. It is not spirv-specific and will (presumably) be used for GLSL as well. --- libs/vkd3d-shader/ir.c | 28 +++++++++++++++++++++++++--- libs/vkd3d-shader/spirv.c | 29 ++++++++++------------------- libs/vkd3d-shader/vkd3d_shader_private.h | 7 +------ 3 files changed, 36 insertions(+), 28 deletions(-) diff --git a/libs/vkd3d-shader/ir.c b/libs/vkd3d-shader/ir.c index 9eefb82c..0e574e27 100644 --- a/libs/vkd3d-shader/ir.c +++ b/libs/vkd3d-shader/ir.c @@ -253,7 +253,7 @@ static void shader_instruction_init(struct vkd3d_shader_instruction *ins, enum v ins->handler_idx = handler_idx; } -enum vkd3d_result instruction_array_flatten_hull_shader_phases(struct vkd3d_shader_instruction_array *src_instructions) +static enum vkd3d_result instruction_array_flatten_hull_shader_phases(struct vkd3d_shader_instruction_array *src_instructions) { struct hull_flattener flattener = {*src_instructions}; struct vkd3d_shader_instruction_array *instructions; @@ -388,7 +388,7 @@ static enum vkd3d_result control_point_normaliser_emit_hs_input(struct control_p return VKD3D_OK; } -enum vkd3d_result instruction_array_normalise_hull_shader_control_point_io( +static enum vkd3d_result instruction_array_normalise_hull_shader_control_point_io( struct vkd3d_shader_instruction_array *src_instructions, const struct shader_signature *input_signature) { struct vkd3d_shader_instruction_array *instructions; @@ -999,7 +999,7 @@ static void shader_instruction_normalise_io_params(struct vkd3d_shader_instructi shader_instruction_init(ins, VKD3DSIH_NOP); } -enum vkd3d_result instruction_array_normalise_io_registers(struct vkd3d_shader_instruction_array *instructions, +static enum vkd3d_result instruction_array_normalise_io_registers(struct vkd3d_shader_instruction_array *instructions, enum vkd3d_shader_type shader_type, struct shader_signature *input_signature, struct shader_signature *output_signature, struct shader_signature *patch_constant_signature) { @@ -1070,3 +1070,25 @@ enum vkd3d_result instruction_array_normalise_io_registers(struct vkd3d_shader_i *instructions = normaliser.instructions; return VKD3D_OK; } + +enum vkd3d_result vkd3d_shader_normalise(struct vkd3d_shader_parser *parser) +{ + struct vkd3d_shader_instruction_array *instructions = &parser->instructions; + enum vkd3d_result result = VKD3D_OK; + + if (parser->shader_version.type == VKD3D_SHADER_TYPE_HULL + && (result = instruction_array_flatten_hull_shader_phases(instructions)) >= 0) + { + result = instruction_array_normalise_hull_shader_control_point_io(instructions, + &parser->shader_desc.input_signature); + } + if (result >= 0) + result = instruction_array_normalise_io_registers(instructions, parser->shader_version.type, + &parser->shader_desc.input_signature, &parser->shader_desc.output_signature, + &parser->shader_desc.patch_constant_signature); + + if (result >= 0 && TRACE_ON()) + vkd3d_shader_trace(instructions, &parser->shader_version); + + return result; +} diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index 9725a5c7..f46c7e0b 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -2429,13 +2429,6 @@ static struct spirv_compiler *spirv_compiler_create(const struct vkd3d_shader_ve compiler->shader_type = shader_version->type; - compiler->input_signature = shader_desc->input_signature; - compiler->output_signature = shader_desc->output_signature; - compiler->patch_constant_signature = shader_desc->patch_constant_signature; - memset(&shader_desc->input_signature, 0, sizeof(shader_desc->input_signature)); - memset(&shader_desc->output_signature, 0, sizeof(shader_desc->output_signature)); - memset(&shader_desc->patch_constant_signature, 0, sizeof(shader_desc->patch_constant_signature)); - if ((shader_interface = vkd3d_find_struct(compile_info->next, INTERFACE_INFO))) { compiler->xfb_info = vkd3d_find_struct(compile_info->next, TRANSFORM_FEEDBACK_INFO); @@ -9443,6 +9436,7 @@ static int spirv_compiler_generate_spirv(struct spirv_compiler *compiler, const struct vkd3d_shader_spirv_target_info *info = compiler->spirv_target_info; const struct vkd3d_shader_spirv_domain_shader_target_info *ds_info; struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; + struct vkd3d_shader_desc *shader_desc = &parser->shader_desc; struct vkd3d_shader_instruction_array instructions; enum vkd3d_result result = VKD3D_OK; unsigned int i; @@ -9453,21 +9447,18 @@ static int spirv_compiler_generate_spirv(struct spirv_compiler *compiler, compiler->location.column = 0; compiler->location.line = 1; + if ((result = vkd3d_shader_normalise(parser)) < 0) + return result; + instructions = parser->instructions; memset(&parser->instructions, 0, sizeof(parser->instructions)); - if (compiler->shader_type == VKD3D_SHADER_TYPE_HULL - && (result = instruction_array_flatten_hull_shader_phases(&instructions)) >= 0) - { - result = instruction_array_normalise_hull_shader_control_point_io(&instructions, - &compiler->input_signature); - } - if (result >= 0) - result = instruction_array_normalise_io_registers(&instructions, parser->shader_version.type, - &compiler->input_signature, &compiler->output_signature, &compiler->patch_constant_signature); - - if (result >= 0 && TRACE_ON()) - vkd3d_shader_trace(&instructions, &parser->shader_version); + compiler->input_signature = shader_desc->input_signature; + compiler->output_signature = shader_desc->output_signature; + compiler->patch_constant_signature = shader_desc->patch_constant_signature; + memset(&shader_desc->input_signature, 0, sizeof(shader_desc->input_signature)); + memset(&shader_desc->output_signature, 0, sizeof(shader_desc->output_signature)); + memset(&shader_desc->patch_constant_signature, 0, sizeof(shader_desc->patch_constant_signature)); if (compiler->shader_type != VKD3D_SHADER_TYPE_HULL) spirv_compiler_emit_shader_signature_outputs(compiler); diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index 577db85f..49ad7b3e 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -1403,11 +1403,6 @@ void dxbc_writer_add_section(struct dxbc_writer *dxbc, uint32_t tag, const void void dxbc_writer_init(struct dxbc_writer *dxbc); int dxbc_writer_write(struct dxbc_writer *dxbc, struct vkd3d_shader_code *code); -enum vkd3d_result instruction_array_flatten_hull_shader_phases(struct vkd3d_shader_instruction_array *instructions); -enum vkd3d_result instruction_array_normalise_hull_shader_control_point_io( - struct vkd3d_shader_instruction_array *instructions, const struct shader_signature *input_signature); -enum vkd3d_result instruction_array_normalise_io_registers(struct vkd3d_shader_instruction_array *instructions, - enum vkd3d_shader_type shader_type, struct shader_signature *input_signature, - struct shader_signature *output_signature, struct shader_signature *patch_constant_signature); +enum vkd3d_result vkd3d_shader_normalise(struct vkd3d_shader_parser *parser); #endif /* __VKD3D_SHADER_PRIVATE_H */

1 0

Zebediah Figura : vkd3d-shader/ir: Normalise sm1-style constants.
by Alexandre Julliard 17 Jul '23

17 Jul '23

Module: vkd3d Branch: master Commit: 25cf6a720b1f9aeec961ea456cab77aef66e2ea1 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/25cf6a720b1f9aeec961ea456cab7… Author: Zebediah Figura <zfigura(a)codeweavers.com> Date: Sun Jul 9 17:46:04 2023 -0500 vkd3d-shader/ir: Normalise sm1-style constants. --- libs/vkd3d-shader/ir.c | 126 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 126 insertions(+) diff --git a/libs/vkd3d-shader/ir.c b/libs/vkd3d-shader/ir.c index 0e574e27..1ce05247 100644 --- a/libs/vkd3d-shader/ir.c +++ b/libs/vkd3d-shader/ir.c @@ -1071,6 +1071,129 @@ static enum vkd3d_result instruction_array_normalise_io_registers(struct vkd3d_s return VKD3D_OK; } +struct flat_constant_def +{ + enum vkd3d_shader_d3dbc_constant_register set; + uint32_t index; + uint32_t value[4]; +}; + +struct flat_constants_normaliser +{ + struct vkd3d_shader_parser *parser; + struct flat_constant_def *defs; + size_t def_count, defs_capacity; +}; + +static bool get_flat_constant_register_type(const struct vkd3d_shader_register *reg, + enum vkd3d_shader_d3dbc_constant_register *set, uint32_t *index) +{ + static const struct + { + enum vkd3d_shader_register_type type; + enum vkd3d_shader_d3dbc_constant_register set; + uint32_t offset; + } + regs[] = + { + {VKD3DSPR_CONST, VKD3D_SHADER_D3DBC_FLOAT_CONSTANT_REGISTER, 0}, + {VKD3DSPR_CONST2, VKD3D_SHADER_D3DBC_FLOAT_CONSTANT_REGISTER, 2048}, + {VKD3DSPR_CONST3, VKD3D_SHADER_D3DBC_FLOAT_CONSTANT_REGISTER, 4096}, + {VKD3DSPR_CONST4, VKD3D_SHADER_D3DBC_FLOAT_CONSTANT_REGISTER, 6144}, + {VKD3DSPR_CONSTINT, VKD3D_SHADER_D3DBC_INT_CONSTANT_REGISTER, 0}, + {VKD3DSPR_CONSTBOOL, VKD3D_SHADER_D3DBC_BOOL_CONSTANT_REGISTER, 0}, + }; + + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(regs); ++i) + { + if (reg->type == regs[i].type) + { + if (reg->idx[0].rel_addr) + { + FIXME("Unhandled relative address.\n"); + return false; + } + + *set = regs[i].set; + *index = regs[i].offset + reg->idx[0].offset; + return true; + } + } + + return false; +} + +static void shader_register_normalise_flat_constants(struct vkd3d_shader_src_param *param, + const struct flat_constants_normaliser *normaliser) +{ + enum vkd3d_shader_d3dbc_constant_register set; + uint32_t index; + size_t i, j; + + if (!get_flat_constant_register_type(&param->reg, &set, &index)) + return; + + for (i = 0; i < normaliser->def_count; ++i) + { + if (normaliser->defs[i].set == set && normaliser->defs[i].index == index) + { + param->reg.type = VKD3DSPR_IMMCONST; + param->reg.idx_count = 0; + param->reg.immconst_type = VKD3D_IMMCONST_VEC4; + for (j = 0; j < 4; ++j) + param->reg.u.immconst_uint[j] = normaliser->defs[i].value[j]; + return; + } + } + + param->reg.type = VKD3DSPR_CONSTBUFFER; + param->reg.idx[0].offset = set; /* register ID */ + param->reg.idx[1].offset = set; /* register index */ + param->reg.idx[2].offset = index; /* buffer index */ + param->reg.idx_count = 3; +} + +static enum vkd3d_result instruction_array_normalise_flat_constants(struct vkd3d_shader_parser *parser) +{ + struct flat_constants_normaliser normaliser = {.parser = parser}; + unsigned int i, j; + + for (i = 0; i < parser->instructions.count; ++i) + { + struct vkd3d_shader_instruction *ins = &parser->instructions.elements[i]; + + if (ins->handler_idx == VKD3DSIH_DEF || ins->handler_idx == VKD3DSIH_DEFI || ins->handler_idx == VKD3DSIH_DEFB) + { + struct flat_constant_def *def; + + if (!vkd3d_array_reserve((void **)&normaliser.defs, &normaliser.defs_capacity, + normaliser.def_count + 1, sizeof(*normaliser.defs))) + { + vkd3d_free(normaliser.defs); + return VKD3D_ERROR_OUT_OF_MEMORY; + } + + def = &normaliser.defs[normaliser.def_count++]; + + get_flat_constant_register_type((struct vkd3d_shader_register *)&ins->dst[0].reg, &def->set, &def->index); + for (j = 0; j < 4; ++j) + def->value[j] = ins->src[0].reg.u.immconst_uint[j]; + + vkd3d_shader_instruction_make_nop(ins); + } + else + { + for (j = 0; j < ins->src_count; ++j) + shader_register_normalise_flat_constants((struct vkd3d_shader_src_param *)&ins->src[j], &normaliser); + } + } + + vkd3d_free(normaliser.defs); + return VKD3D_OK; +} + enum vkd3d_result vkd3d_shader_normalise(struct vkd3d_shader_parser *parser) { struct vkd3d_shader_instruction_array *instructions = &parser->instructions; @@ -1087,6 +1210,9 @@ enum vkd3d_result vkd3d_shader_normalise(struct vkd3d_shader_parser *parser) &parser->shader_desc.input_signature, &parser->shader_desc.output_signature, &parser->shader_desc.patch_constant_signature); + if (result >= 0) + result = instruction_array_normalise_flat_constants(parser); + if (result >= 0 && TRACE_ON()) vkd3d_shader_trace(instructions, &parser->shader_version);

1 0

Zebediah Figura : vkd3d-shader/spirv: Emit variables for flat constant buffers.
by Alexandre Julliard 17 Jul '23

17 Jul '23

Module: vkd3d Branch: master Commit: e0e261eac3315648f52b296e47ff04a01caaddcb URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/e0e261eac3315648f52b296e47ff0… Author: Zebediah Figura <zfigura(a)codeweavers.com> Date: Sun Jul 9 19:57:39 2023 -0500 vkd3d-shader/spirv: Emit variables for flat constant buffers. --- libs/vkd3d-shader/spirv.c | 65 +++++++++++++++++++++++++++++++++++------------ 1 file changed, 49 insertions(+), 16 deletions(-) diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index f46c7e0b..dcf957ea 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -2529,13 +2529,13 @@ static bool spirv_compiler_check_shader_visibility(const struct spirv_compiler * } static struct vkd3d_push_constant_buffer_binding *spirv_compiler_find_push_constant_buffer( - const struct spirv_compiler *compiler, const struct vkd3d_shader_constant_buffer *cb) + const struct spirv_compiler *compiler, const struct vkd3d_shader_register_range *range) { - unsigned int register_space = cb->range.space; - unsigned int reg_idx = cb->range.first; + unsigned int register_space = range->space; + unsigned int reg_idx = range->first; unsigned int i; - if (cb->range.first != cb->range.last) + if (range->first != range->last) return NULL; for (i = 0; i < compiler->shader_interface.push_constant_buffer_count; ++i) @@ -5470,28 +5470,24 @@ static uint32_t spirv_compiler_build_descriptor_variable(struct spirv_compiler * return var_id; } -static void spirv_compiler_emit_dcl_constant_buffer(struct spirv_compiler *compiler, - const struct vkd3d_shader_instruction *instruction) +static void spirv_compiler_emit_constant_buffer(struct spirv_compiler *compiler, unsigned int size, + const struct vkd3d_shader_register_range *range, const struct vkd3d_shader_register *reg) { - const struct vkd3d_shader_constant_buffer *cb = &instruction->declaration.cb; struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; uint32_t vec4_id, array_type_id, length_id, struct_id, var_id; const SpvStorageClass storage_class = SpvStorageClassUniform; - const struct vkd3d_shader_register *reg = &cb->src.reg; struct vkd3d_push_constant_buffer_binding *push_cb; struct vkd3d_descriptor_variable_info var_info; struct vkd3d_symbol reg_symbol; - assert(!(instruction->flags & ~VKD3DSI_INDEXED_DYNAMIC)); - - if ((push_cb = spirv_compiler_find_push_constant_buffer(compiler, cb))) + if ((push_cb = spirv_compiler_find_push_constant_buffer(compiler, range))) { /* Push constant buffers are handled in * spirv_compiler_emit_push_constant_buffers(). */ - unsigned int cb_size_in_bytes = cb->size * VKD3D_VEC4_SIZE * sizeof(uint32_t); + unsigned int cb_size_in_bytes = size * VKD3D_VEC4_SIZE * sizeof(uint32_t); push_cb->reg = *reg; - push_cb->size = cb->size; + push_cb->size = size; if (cb_size_in_bytes > push_cb->pc.size) { WARN("Constant buffer size %u exceeds push constant size %u.\n", @@ -5501,17 +5497,17 @@ static void spirv_compiler_emit_dcl_constant_buffer(struct spirv_compiler *compi } vec4_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE); - length_id = spirv_compiler_get_constant_uint(compiler, cb->size); + length_id = spirv_compiler_get_constant_uint(compiler, size); array_type_id = vkd3d_spirv_build_op_type_array(builder, vec4_id, length_id); vkd3d_spirv_build_op_decorate1(builder, array_type_id, SpvDecorationArrayStride, 16); struct_id = vkd3d_spirv_build_op_type_struct(builder, &array_type_id, 1); vkd3d_spirv_build_op_decorate(builder, struct_id, SpvDecorationBlock, NULL, 0); vkd3d_spirv_build_op_member_decorate1(builder, struct_id, 0, SpvDecorationOffset, 0); - vkd3d_spirv_build_op_name(builder, struct_id, "cb%u_struct", cb->size); + vkd3d_spirv_build_op_name(builder, struct_id, "cb%u_struct", size); var_id = spirv_compiler_build_descriptor_variable(compiler, storage_class, struct_id, - reg, &cb->range, VKD3D_SHADER_RESOURCE_BUFFER, false, &var_info); + reg, range, VKD3D_SHADER_RESOURCE_BUFFER, false, &var_info); vkd3d_symbol_make_register(&reg_symbol, reg); vkd3d_symbol_set_register_info(&reg_symbol, var_id, storage_class, @@ -5521,6 +5517,16 @@ static void spirv_compiler_emit_dcl_constant_buffer(struct spirv_compiler *compi spirv_compiler_put_symbol(compiler, &reg_symbol); } +static void spirv_compiler_emit_dcl_constant_buffer(struct spirv_compiler *compiler, + const struct vkd3d_shader_instruction *instruction) +{ + const struct vkd3d_shader_constant_buffer *cb = &instruction->declaration.cb; + + assert(!(instruction->flags & ~VKD3DSI_INDEXED_DYNAMIC)); + + spirv_compiler_emit_constant_buffer(compiler, cb->size, &cb->range, &cb->src.reg); +} + static void spirv_compiler_emit_dcl_immediate_constant_buffer(struct spirv_compiler *compiler, const struct vkd3d_shader_instruction *instruction) { @@ -9429,6 +9435,26 @@ static int spirv_compiler_handle_instruction(struct spirv_compiler *compiler, return ret; } +static void spirv_compiler_emit_sm1_constant_buffer(struct spirv_compiler *compiler, + const struct vkd3d_shader_desc *desc, enum vkd3d_shader_d3dbc_constant_register set, + enum vkd3d_data_type data_type) +{ + struct vkd3d_shader_register_range range = {.space = 0, .first = set, .last = set}; + uint32_t count = desc->flat_constant_count[set].external; + struct vkd3d_shader_register reg = + { + .type = VKD3DSPR_CONSTBUFFER, + .idx[0].offset = set, /* register ID */ + .idx[1].offset = set, /* register index */ + .idx[2].offset = count, /* size */ + .idx_count = 3, + .data_type = data_type, + }; + + if (count) + spirv_compiler_emit_constant_buffer(compiler, count, &range, &reg); +} + static int spirv_compiler_generate_spirv(struct spirv_compiler *compiler, const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_parser *parser, struct vkd3d_shader_code *spirv) @@ -9444,6 +9470,13 @@ static int spirv_compiler_generate_spirv(struct spirv_compiler *compiler, if (parser->shader_desc.temp_count) spirv_compiler_emit_temps(compiler, parser->shader_desc.temp_count); + spirv_compiler_emit_sm1_constant_buffer(compiler, &parser->shader_desc, + VKD3D_SHADER_D3DBC_FLOAT_CONSTANT_REGISTER, VKD3D_DATA_FLOAT); + spirv_compiler_emit_sm1_constant_buffer(compiler, &parser->shader_desc, + VKD3D_SHADER_D3DBC_INT_CONSTANT_REGISTER, VKD3D_DATA_INT); + spirv_compiler_emit_sm1_constant_buffer(compiler, &parser->shader_desc, + VKD3D_SHADER_D3DBC_BOOL_CONSTANT_REGISTER, VKD3D_DATA_UINT); + compiler->location.column = 0; compiler->location.line = 1;

1 0

Francisco Casas : tests: Add lowering combined samplers tests.
by Alexandre Julliard 17 Jul '23

17 Jul '23

Module: vkd3d Branch: master Commit: b8a85c6ad5e466b7a3fec64344ad0ed07ce004e8 URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/b8a85c6ad5e466b7a3fec64344ad0… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Thu Dec 1 16:50:17 2022 -0300 tests: Add lowering combined samplers tests. --- Makefile.am | 1 + tests/hlsl/combined-samplers.shader_test | 153 +++++++++++++++++++++++++++++++ 2 files changed, 154 insertions(+) diff --git a/Makefile.am b/Makefile.am index cafa8f2f..b5e77f4e 100644 --- a/Makefile.am +++ b/Makefile.am @@ -70,6 +70,7 @@ vkd3d_shader_tests = \ tests/hlsl/cbuffer.shader_test \ tests/hlsl/clamp.shader_test \ tests/hlsl/clip.shader_test \ + tests/hlsl/combined-samplers.shader_test \ tests/hlsl/comma.shader_test \ tests/hlsl/compute.shader_test \ tests/hlsl/conditional.shader_test \ diff --git a/tests/hlsl/combined-samplers.shader_test b/tests/hlsl/combined-samplers.shader_test new file mode 100644 index 00000000..c14de4bc --- /dev/null +++ b/tests/hlsl/combined-samplers.shader_test @@ -0,0 +1,153 @@ +[require] +shader model >= 4.0 + + +[sampler 0] +filter linear linear linear +address clamp clamp clamp + +[sampler 1] +filter linear linear linear +address clamp clamp clamp + +[sampler 2] +filter linear linear linear +address clamp clamp clamp + +[texture 0] +size (1, 1) +0.0 0.0 0.0 1.0 + +[texture 1] +size (1, 1) +1.0 1.0 1.0 1.0 + +[texture 2] +size (1, 1) +2.0 2.0 2.0 1.0 + +[texture 3] +size (1, 1) +3.0 3.0 3.0 1.0 + +[texture 4] +size (1, 1) +4.0 4.0 4.0 1.0 + + +[pixel shader todo] +sampler sam; + +float4 main() : sv_target +{ + return tex2D(sam, float2(0, 0)); +} + +[test] +todo draw quad +todo probe all rgba (0, 0, 0, 1) + + +% Textures for new separated samplers are allocated before regular textures. +[pixel shader todo] +Texture2D tex; +sampler sam; + +float4 main() : sv_target +{ + return 10 * tex.Sample(sam, float2(0, 0)) + tex2D(sam, float2(0, 0)); +} + +[test] +todo draw quad +todo probe all rgba (10, 10, 10, 11) + + +[pixel shader todo] +Texture2D tex; +sampler sam[2]; + +float4 main() : sv_target +{ + return 10 * tex.Sample(sam[0], float2(0, 0)) + tex2D(sam[1], float2(0, 0)); +} + +[test] +todo draw quad +todo probe all rgba (21, 21, 21, 11) + + +[pixel shader todo] +sampler sam0; +sampler sam1; +sampler sam2; + +float4 main() : sv_target +{ + return 100 * tex2D(sam1, float2(0, 0)) + 10 * tex2D(sam0, float2(0, 0)) + + tex2D(sam2, float2(0, 0)); +} + +[test] +todo draw quad +todo probe all rgba (12, 12, 12, 111) + + +[pixel shader todo] +Texture2D tex[2][2]; +sampler sam; + +float4 main() : sv_target +{ + return 100 * tex[0][0].Load(int3(0, 0, 0)) + 10 * tex2D(sam, float2(0, 0)) + + tex[1][1].Sample(sam, float2(0, 0)); +} + +[test] +todo draw quad +todo probe all rgba (104, 104, 104, 111) + + +% Sampler arrays with components that have different usage dimensions are only forbidden in SM4 upwards. +% However, tex2D and tex1D are considered the same dimension for these purposes. +[pixel shader fail todo] +sampler sam[2]; + +float4 main() : sv_target +{ + return tex2D(sam[0], float2(0, 0)) + tex3D(sam[1], float3(0, 0, 0)); +} + + +[pixel shader todo] +sampler sam[2]; + +float4 main() : sv_target +{ + return 10 * tex2D(sam[0], float2(0, 0)) + tex1D(sam[1], 0); +} + +[test] +todo draw quad +todo probe all rgba (1, 1, 1, 11) + + +[require] +shader model >= 5.0 + + +[pixel shader todo] +struct +{ + Texture2D tex; + sampler sam; +} foo; + +float4 main() : sv_target +{ + return 10 * foo.tex.Sample(foo.sam, float2(0, 0)) + tex2D(foo.sam, float2(0, 0)); +} + +[test] +todo draw quad +todo probe all rgba (10, 10, 10, 11)

1 0

Francisco Casas : vkd3d-shader/hlsl: Check is_uniform instead of HLSL_STORAGE_UNIFORM when validating object refs.
by Alexandre Julliard 17 Jul '23

17 Jul '23

Module: vkd3d Branch: master Commit: 866c5d953159b2b497561a4e39d93c6e8edb97af URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/866c5d953159b2b497561a4e39d93… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Fri Jan 20 20:37:15 2023 -0300 vkd3d-shader/hlsl: Check is_uniform instead of HLSL_STORAGE_UNIFORM when validating object refs. We are using the hlsl_ir_var.is_uniform flag to indicate when an object is a uniform copy created from a variable with the HLSL_STORAGE_UNIFORM modifier. We should be checking for this instead of the HLSL_STORAGE_UNIFORM flag which is also set to 1 for the original variables, and there should be no reason to use this flag instead of "is_uniform" after the uniform copies and combined/separated samplers are created. --- libs/vkd3d-shader/hlsl_codegen.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c index 8242c193..7406cda9 100644 --- a/libs/vkd3d-shader/hlsl_codegen.c +++ b/libs/vkd3d-shader/hlsl_codegen.c @@ -1690,7 +1690,7 @@ static bool validate_static_object_references(struct hlsl_ctx *ctx, struct hlsl_ { struct hlsl_ir_resource_load *load = hlsl_ir_resource_load(instr); - if (!(load->resource.var->storage_modifiers & HLSL_STORAGE_UNIFORM)) + if (!load->resource.var->is_uniform) { hlsl_error(ctx, &instr->loc, VKD3D_SHADER_ERROR_HLSL_NON_STATIC_OBJECT_REF, "Loaded resource must have a single uniform source."); @@ -1705,7 +1705,7 @@ static bool validate_static_object_references(struct hlsl_ctx *ctx, struct hlsl_ if (load->sampler.var) { - if (!(load->sampler.var->storage_modifiers & HLSL_STORAGE_UNIFORM)) + if (!load->sampler.var->is_uniform) { hlsl_error(ctx, &instr->loc, VKD3D_SHADER_ERROR_HLSL_NON_STATIC_OBJECT_REF, "Resource load sampler must have a single uniform source."); @@ -1723,7 +1723,7 @@ static bool validate_static_object_references(struct hlsl_ctx *ctx, struct hlsl_ { struct hlsl_ir_resource_store *store = hlsl_ir_resource_store(instr); - if (!(store->resource.var->storage_modifiers & HLSL_STORAGE_UNIFORM)) + if (!store->resource.var->is_uniform) { hlsl_error(ctx, &instr->loc, VKD3D_SHADER_ERROR_HLSL_NON_STATIC_OBJECT_REF, "Accessed resource must have a single uniform source.");

1 0

Francisco Casas : vkd3d-shader/hlsl: Introduce hlsl_new_synthetic_var_named().
by Alexandre Julliard 17 Jul '23

17 Jul '23

Module: vkd3d Branch: master Commit: c4f074d25d962d8f81aeea12a43a57fd06c288db URL: https://gitlab.winehq.org/wine/vkd3d/-/commit/c4f074d25d962d8f81aeea12a43a5… Author: Francisco Casas <fcasas(a)codeweavers.com> Date: Tue May 16 11:35:14 2023 -0400 vkd3d-shader/hlsl: Introduce hlsl_new_synthetic_var_named(). --- libs/vkd3d-shader/hlsl.c | 27 +++++++++++++++++++-------- libs/vkd3d-shader/hlsl.h | 2 ++ 2 files changed, 21 insertions(+), 8 deletions(-) diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c index eb5e4e4c..8f2bc520 100644 --- a/libs/vkd3d-shader/hlsl.c +++ b/libs/vkd3d-shader/hlsl.c @@ -1039,20 +1039,31 @@ struct hlsl_ir_var *hlsl_new_synthetic_var(struct hlsl_ctx *ctx, const char *tem struct vkd3d_string_buffer *string; struct hlsl_ir_var *var; static LONG counter; - const char *name; if (!(string = hlsl_get_string_buffer(ctx))) return NULL; vkd3d_string_buffer_printf(string, "<%s-%u>", template, InterlockedIncrement(&counter)); - if (!(name = hlsl_strdup(ctx, string->buffer))) - { - hlsl_release_string_buffer(ctx, string); - return NULL; - } - var = hlsl_new_var(ctx, name, type, loc, NULL, 0, NULL); + var = hlsl_new_synthetic_var_named(ctx, string->buffer, type, loc, true); hlsl_release_string_buffer(ctx, string); + return var; +} + +struct hlsl_ir_var *hlsl_new_synthetic_var_named(struct hlsl_ctx *ctx, const char *name, + struct hlsl_type *type, const struct vkd3d_shader_location *loc, bool dummy_scope) +{ + struct hlsl_ir_var *var; + const char *name_copy; + + if (!(name_copy = hlsl_strdup(ctx, name))) + return NULL; + var = hlsl_new_var(ctx, name_copy, type, loc, NULL, 0, NULL); if (var) - list_add_tail(&ctx->dummy_scope->vars, &var->scope_entry); + { + if (dummy_scope) + list_add_tail(&ctx->dummy_scope->vars, &var->scope_entry); + else + list_add_tail(&ctx->globals->vars, &var->scope_entry); + } return var; } diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h index 7b41f085..80072d5b 100644 --- a/libs/vkd3d-shader/hlsl.h +++ b/libs/vkd3d-shader/hlsl.h @@ -1173,6 +1173,8 @@ struct hlsl_ir_node *hlsl_new_swizzle(struct hlsl_ctx *ctx, DWORD s, unsigned in struct hlsl_ir_node *val, const struct vkd3d_shader_location *loc); struct hlsl_ir_var *hlsl_new_synthetic_var(struct hlsl_ctx *ctx, const char *template, struct hlsl_type *type, const struct vkd3d_shader_location *loc); +struct hlsl_ir_var *hlsl_new_synthetic_var_named(struct hlsl_ctx *ctx, const char *name, + struct hlsl_type *type, const struct vkd3d_shader_location *loc, bool dummy_scope); struct hlsl_type *hlsl_new_texture_type(struct hlsl_ctx *ctx, enum hlsl_sampler_dim dim, struct hlsl_type *format, unsigned int sample_count); struct hlsl_type *hlsl_new_uav_type(struct hlsl_ctx *ctx, enum hlsl_sampler_dim dim, struct hlsl_type *format);

1 0