From cfe9cd379451cbcb507e5e427e4d2390d79a4aeb Mon Sep 17 00:00:00 2001 From: Henri Verbeet Date: Thu, 20 Nov 2025 12:00:00 +0100 Subject: [PATCH] Release 1.18. --- ANNOUNCE | 1212 +++++++++++++++----------------- ChangeLog.md | 100 +++ Makefile.am | 6 +- configure.ac | 2 +- demos/demo_vkd3d.h | 2 +- include/private/vkd3d_common.h | 2 +- include/vkd3d.h | 1 + include/vkd3d_shader.h | 1 + libs/vkd3d-shader/spirv.c | 2 +- 9 files changed, 683 insertions(+), 645 deletions(-) diff --git a/ANNOUNCE b/ANNOUNCE index 8a03b0bcb..ac64c97e8 100644 --- a/ANNOUNCE +++ b/ANNOUNCE @@ -1,17 +1,9 @@ -The vkd3d team is proud to announce that release 1.17 of vkd3d, the Direct3D +The vkd3d team is proud to announce that release 1.18 of vkd3d, the Direct3D to Vulkan translation library, is now available. -This release contains improvements that are listed in the release notes below. -The main highlights are: - - - Initial HLSL support for thread group shared memory. - - Several features have been implemented for the experimental Metal Shading - Language target. - - Miscellaneous bug fixes. - The source is available from the following location: - + The current source can also be pulled directly from the git repository: @@ -20,663 +12,607 @@ The current source can also be pulled directly from the git repository: Vkd3d is available thanks to the work of multiple people. See the file AUTHORS for the complete list. -# What's new in vkd3d 1.17 +# What's new in vkd3d 1.18 ### libvkd3d - - The EnumerateMetaCommands() method of the ID3D12Device5 interface is + - The CreateCommandList1() method of the ID3D12Device4 interface is implemented. ### libvkd3d-shader - Several new features and improvements for the HLSL source type: - - Initial thread group shared memory support. - - Improved support for geometry shaders: shader model 5 multiple output - streams, as well as SV_IsFrontFace, SV_RenderTargetArrayIndex, and - SV_ViewportArrayIndex outputs. - - Structure variable input/output semantics are propagated to the - constituent structure fields. - - Shader entry point return values are allocated before any other outputs - in the output signature. This matches d3dcompiler/fxc more closely. - - Hull shader control point pass-through. - - Reflection information can be retrieved using vkd3d_shader_scan(). - - Improved preprocessor handling of comments inside include directives, as - well as inclusion of empty files. - - Memory barrier intrinsics are supported in shader model 4 target - profiles. Previous these were only supported in shader model 5 target + - Flattening of branched code. I.e., code using if/else statements can be + turned into conditional moves when that's either advantageous or + necessary. Cases where this is necessary include targeting shader model + 2.0 or earlier, as well as code using the ‘flatten’ attribute. + - More constant folding improvements. For example: + - asfloat(), asint(), asuint(), cos(), mad(), round(), and sin() + operations are constant folded. + - ‘true ? x : y’ is folded to ‘x’ + - ‘x ? true : false’ is folded to ‘x’ + - ‘||x||’ is folded to ‘|x|’ + - ‘~~x’ is folded to ‘x’ + - ‘x < 0’ is folded to ‘false’ for unsigned ‘x’ + - The following intrinsic functions: + - countbits() + - firstbithigh() + - firstbitlow() + - frexp() + - texCUBEbias() + - Integer-typed conditional expressions in shader model 1-3 target + profiles. Previously these were only supported in shader model 4+ target profiles. - - Parser support for the noise() intrinsic. Although the intrinsic itself - isn't implemented, parser support for the intrinsic is required to allow - compilation of any other shaders in the same source file to succeed as - well. - - Parser support for StructuredBuffer resources. + - Resource loads from ‘StructuredBuffer’ resources. + - ‘centroid’ interpolation modifiers in shader model 1-3 target profiles. + - Support for ‘\_centroid’ modifier suffixes on I/O semantics. I.e., + ‘float2 t : TEXCOORD0_centroid’ is equivalent to ‘centroid float2 t : + TEXCOORD0’. - - Various new features and improvements for the effects (FX) source type: - - Shader blob assignments and FXLVM value expressions in ‘fx_2_0’ effects. - - Nameless structure types. - - Explicit constant buffer bind points and constant packing offsets. - - The ‘d3ds_noiseswiz’, ‘ge’, ‘lt’, and ‘noise’ FXLVM operations. + - The following legacy Direct3D byte-code instructions are implemented: + - bem + - tex + - texbem + - texbeml + - texcoord - The experimental Metal Shading Language (MSL) target supports the following features: - - Texture sampling and gather operations. - - Loops and switches. + - Compute shaders. + - Immediate-constant buffers. + - Standard, inverse, and hyperbolic trigonometric functions. + - Integer division and remainder operations. + - Floating-point remainder operations. + - Bit scanning and counting operations. + - Boolean operands, as produced by DXIL sources. + - Barrier operations. + + - When the experimental MSL target is enabled, the ‘hlsl’ source type can be + used in combination with the ‘msl’ target type to convert HLSL shaders to + MSL. + + - Signed integer operations like min() and max() are correctly translated + from DXIL to MSL. Previously these would end up getting translated as + unsigned operations, and would thus mishandle negative values. + + - The experimental OpenGL Shading Language (GLSL) target supports the + following features: - Screen-space partial derivatives. - - Various integer arithmetic and comparison operations. - - Indirect addressing of constant buffers. - - Indexable temporary registers. - - Fragment shader output sample coverage masks. - - SV_Position and SV_SampleIndex fragment shader inputs. - - SV_VertexID inputs. + - sin() and cos() operations. + - Unsigned integer division and remainder operations. + - Static texel offsets on texture load operations. + - ‘SV_Coverage’ fragment shader outputs. + - ‘SV_InstanceID’ inputs. - - When the experimental MSL target is enabled, the ‘dxbc-dxil’ source type - can be used in combination with the ‘msl’ target type to convert DXIL - shaders to MSL. - - - The new ‘tx’ source type can be used in combination with the ‘d3d-asm’ - target type to disassemble D3DX ‘tx_1_0’ texture shaders. - - - The FX target takes alignment and padding into account in ‘fx_4_0’ buffer - size calculations. - - - The SPIR-V target is capable of outputting OpSource and OpLine debug - information. - - - The core grammar for the experimental SPIR-V disassembler has been updated - to the ‘vulkan-sdk-1.4.313.0’ release. + - Textual output formats are documented to have a zero byte following their + output. This can be convenient for passing such output to functions + expecting a null-terminated string. For some output formats this was + already true in earlier versions of vkd3d, but not guaranteed by the API. - New interfaces: - - The VKD3D_SHADER_SOURCE_TX source type specifies D3DX ‘tx_1_0’ texture + - The vkd3d_shader_d3dbc_source_info structure extends the + vkd3d_shader_compile_info structure, and can be used to specify + auxiliary information for legacy Direct3D byte-code (‘d3dbc’) shaders + that's necessary for target formats like SPIR-V and GLSL, but not + specified by ‘d3dbc’ shaders. In particular, it allows specifying + resource/sampler types for shader model 1 fragment shaders, as well as + which samplers are comparison-mode samplers for shader model 1-3 shaders. + - The vkd3d_shader_scan_thread_group_size_info structure extends the + vkd3d_shader_compile_info structure, and can be used to to retrieve the + thread group size expected by a compute shader. This information is + particularly useful when targeting Metal environments, because the Metal + API requires the thread group size to be specified through its dispatch + API, instead of being specified by the shader. + - The VKD3D_SHADER_PARAMETER_NAME_BUMP_LUMINANCE_OFFSET_[0-5] shader + parameters specify the corresponding bump-mapping luminance offsets. + - The VKD3D_SHADER_PARAMETER_NAME_BUMP_LUMINANCE_SCALE_[0-5] shader + parameters specify the corresponding bump-mapping luminance scale + factors. + - The VKD3D_SHADER_PARAMETER_NAME_BUMP_MATRIX_[0-5] shader parameters + specify the corresponding bump-mapping transformation matrices. -### vkd3d-compiler - - - The new ‘tx’ source type specifies D3DX ‘tx_1_0’ texture shaders. - -### demos - - - The new vkd3d-teapot demo uses tessellation shaders to render a version of - Martin Newell's famous teapot. It should be noted that current versions of - MoltenVK unfortunately do not support all features required to execute - this demo correctly. - -### Changes since vkd3d 1.16: +### Changes since vkd3d 1.17: ``` -Anna (navi) Figueiredo Gomes (5): - vkd3d-shader/hlsl: Clone the entry point body and redirect processing to the clone. - vkd3d-shader/hlsl: Reset "extern_vars" before processing "entry_func" in hlsl_emit_bytecode(). - vkd3d-shader/hlsl: Add temporary variables to "dummy_scope" in prepend_uniform_copy(). - vkd3d-shader/hlsl: Don't create a temporary copy for a uniform if one already exists. - vkd3d-shader/hlsl: Move hlsl_ir_function_decl->extern_vars to a local variable. +Andrey Gusev (1): + vkd3d: Recognise VK_QUEUE_OPTICAL_FLOW_BIT_NV in debug_vk_queue_flags(). -Brendan Shanks (2): - include: Add additional generated files to .gitignore. - tests: Add dxcompiler.h to .gitignore. +Anna (navi) Figueiredo Gomes (3): + vkd3d-shader/hlsl: Remove the duplicate HLSL_IR_STRING_CONSTANT branch from evaluate_static_expression(). + vkd3d-shader/hlsl: Add a default value fail test with all allowed instructions. + vkd3d-shader/hlsl: Properly free default values when discarding them. Conor McCarthy (9): - vkd3d-shader/dxil: Validate the function return type after calling the handler. - vkd3d-shader/dxil: Check the destination value is invalid after calling a void function handler. - vkd3d-shader/dxil: Add a null check for the type when validating non-void operands. - vkd3d-shader/ir: Allow constant buffer loads to have a minimum precision. - vkd3d-shader/dxil: Convert constant buffer minimum-precision source registers. - tests: Replace test_ps_viewport_index() with a shader runner test. - vkd3d-shader/dxil: Handle SV_ViewportArrayIndex. - tests/hlsl: Add a test for SV_PrimitiveId inputs and outputs. - vkd3d-shader/dxil: Handle SV_PrimitiveId outputs. + tests/hlsl: Add a test for branching in a hull shader patch constant function. + vkd3d-shader: Set the program block count to the maximum for any function. + tests/hlsl: Add a test for branching in a hull shader control point function. + vkd3d-shader/spirv: Handle VSIR_DATA_SNORM and VSIR_DATA_UNORM in spirv_get_type_id(). + vkd3d-shader/spirv: Handle VSIR_DATA_SNORM and VSIR_DATA_UNORM in image_format_for_image_read(). + tests/hlsl: Add a precise MAD test where the first component is not x. + vkd3d-shader/ir: Fix the addition swizzle in vsir_program_lower_precise_mad(). + vkd3d-shader/ir: Use an SSA intermediate in vsir_program_lower_precise_mad(). + vkd3d-shader/ir: Fix the FTOU swizzle for MOVA in vsir_program_normalize_addr(). -Elizabeth Figura (31): - vkd3d-shader/ir: Use add_signature_element() to add clip planes. - vkd3d-shader/ir: Split TEXCOORD into two separate vsir opcodes. - vkd3d-shader/ir: Split TEX into two separate vsir opcodes. - vkd3d-shader: Use the correct union members for raw and structured resources. - vkd3d-shader/preproc: Parse comments in #include and #line directives. - vkd3d-shader/preproc: Swap to the INITIAL state after ending a buffer. - vkd3d-shader/preproc: Store EOF state per buffer. - vkd3d-shader/hlsl: Add a register type field to struct hlsl_reg. - vkd3d-shader/ir: Introduce a stub SSA to temp allocation pass. - vkd3d-shader/ir: Track liveness in the SSA allocator. - vkd3d-shader/ir: Allocate SSA registers to temps. - vkd3d-shader/hlsl: Output SSA registers where possible. - vkd3d-shader/d3d-asm: Handle INT_MIN in shader_print_int_literal(). - vkd3d-shader/hlsl: Convert descriptor registers to pre-5.1 form in the TPF writer. - vkd3d-shader/hlsl: Output sm1 semantics with unique register_index values. - vkd3d-shader/hlsl: Set the data type in sm4_generate_vsir_reg_from_deref(). - vkd3d-shader/hlsl: Set the destination data type to UINT in sm4_generate_vsir_cast_from_bool(). - vkd3d-shader/ir: Allow bitwise operations on VKD3D_DATA_INT. - tests/shader_runner: Add support for 3D resources. - tests/hlsl: Add tests for 3D textures. - tests/shader_runner: Add support for cube resources. - tests/hlsl: Add tests for cube textures. - vkd3d-shader/spirv: Do not use OpCopyMemory for partial writemasks in spirv_compiler_emit_mov(). - vkd3d-shader/spirv: Use left-shifted writemasks for private variables for inputs. - vkd3d-shader/ir: Record the previous temp count before allocating any SSA values. - tests/hlsl: Add a regression test for packed SV_IsFrontFace. - vkd3d-shader: Add descriptors from SAMPLE instructions if necessary. - vkd3d-shader/d3dbc: Move TEXLD lowering to d3dbc_parse(). - vkd3d-shader/d3dbc: Normalize ps 1.x output. - vkd3d-shader/d3dbc: Lower 1.4 TEXLD. - vkd3d-shader/d3dbc: Lower TEXCRD. +Elizabeth Figura (66): + vkd3d-shader/d3dbc: Move TEXLDD lowering to vsir_program_lower_d3dbc_instructions(). + vkd3d-shader/d3dbc: Move TEXLDL lowering to vsir_program_lower_d3dbc_instructions(). + vkd3d-shader/d3dbc: Move d3dbc SINCOS lowering to vsir_program_lower_d3dbc_instructions(). + vkd3d-shader/d3dbc: Move TEXKILL lowering to vsir_program_lower_d3dbc_instructions(). + vkd3d-shader/d3dbc: Move IFC lowering to vsir_program_lower_d3dbc_instructions(). + vkd3d-shader: Dump shaders in vkd3d_shader_preprocess(). + vkd3d-shader/hlsl: Ensure yacc tokens are positive. + vkd3d-shader/glsl: Do not make a copy of the buffer before returning it. + vkd3d-shader/preproc: Do not make a copy of the buffer before returning it. + vkd3d-shader/hlsl: Initialize the allocator with a type. + vkd3d-shader/ir: Reallocate temps. + vkd3d-shader/hlsl: Use unique temps for non-indexable variables. + vkd3d-shader/hlsl: Use unique temps for per-component operations. + vkd3d-shader/hlsl: Use unique temps for SINCOS. + vkd3d-shader/hlsl: Use a simple counter for indexable temps. + vkd3d-shader/hlsl: Remove liveness range tracking from the allocator. + tests: Test null-termination. + tests: Test special characters. + vkd3d-shader: Document the null terminator appended for textual formats. + vkd3d-utils: Null-terminate the output of D3DDisassemble(). + vkd3d-utils: Null-terminate the output of D3DPreprocess(). + vkd3d-shader/d3dbc: Move the error for unhandled d3dbc instructions to vsir_program_lower_d3dbc_instructions(). + vkd3d-shader/d3dbc: Lower TEXTURE to TEMP registers when written. + vkd3d-shader/d3dbc: Lower TEX instructions. + vkd3d-shader/d3dbc: Lower TEXCOORD instructions. + vkd3d-shader/ir: Validate TEXTURE registers. + vkd3d-shader/ir: Validate BEM. + vkd3d-shader/hlsl: Use the semantic.resource_type field for texture DCL instructions. + vkd3d-shader/hlsl: Use unique IDs for descriptors before 5.1. + vkd3d-shader/ir: Introduce a vsir DCE pass. + vkd3d-shader/hlsl: Make ConstructGSWithSO an intrinsic function. + vkd3d-shader/hlsl: Return a node from lower_ir(). + vkd3d-shader/hlsl: Rename lower_ir() to replace_ir(). + vkd3d-shader/hlsl: Use replace_ir() for fold_swizzle_chains(). + vkd3d-shader/hlsl: Use replace_ir() for fold_trivial_swizzles(). + vkd3d-shader/hlsl: Use replace_ir() for fold_redundant_casts(). + vkd3d-shader/d3dbc: Create vsir descriptor information in the parser. + vkd3d-shader/hlsl: Create vsir descriptor info in hlsl_parse(). + vkd3d-shader: Remove sm1-specific descriptor scanning logic. + vkd3d-shader: Remove the no longer used flat_constant_count field from struct vsir_program. + vkd3d-shader: Introduce an interface to specify 1.x texture dimensions. + vkd3d-shader: Introduce an interface to specify sm1 shadow samplers. + vkd3d-shader/glsl: Wrap gl_GlobalInvocationID in an uvec4. + vkd3d-shader/ir: Implement an initial vsir copy propagation pass. + tests: Test a shader with many semantics. + vkd3d-shader/d3dbc: Fix writing vertex input semantics. + vkd3d-shader/spirv: Allow swizzling parameters. + vkd3d-shader: Lower BEM instructions. + vkd3d-shader: Lower TEXBEM instructions. + vkd3d-shader: Lower TEXBEML instructions. + tests: Allow RTV -> SRV blits in the d3d9 runner. + tests: Set tags in the d3d9 runner. + tests: Add bump mapping tests. + vkd3d-shader/hlsl: Introduce hlsl_block_add_constant(). + vkd3d-shader/hlsl: Use replace_ir() for hlsl_fold_constant_swizzles(). + vkd3d-shader/hlsl: Use replace_ir() for hlsl_fold_constant_identities(). + vkd3d-shader/hlsl: Use replace_ir() for hlsl_fold_constant_exprs(). + vkd3d-shader/hlsl: Use replace_ir() for fold_conditional_identities(). + vkd3d-shader/hlsl: Use replace_ir() for fold_unary_identities(). + vkd3d-shader/hlsl: Use replace_ir() for hlsl_normalize_binary_exprs(). + vkd3d-shader/hlsl: Use replace_ir() for lower_resource_load_bias(). + vkd3d-shader/hlsl: Use replace_ir() for lower_discard_nz(). + vkd3d-shader/hlsl: Write the used sampler dimension for generic samplers in the CTAB. + vkd3d-shader/hlsl: Do not deduplicate sampler types in the CTAB. + vkd3d-shader/hlsl: Write a "dimx" of 4 for combined sampler types in the CTAB. + vkd3d-shader/hlsl: Only prepend a $ for parameters with the uniform keyword. -Evan Tang (4): - vkd3d: Replace the resource count field of struct d3d12_heap with an internal refcount. - vkd3d: Mask colour writes on graphics pipelines without fragment shaders. - tests/d3d12: Add a colour attachment to test_draw_depth_no_ps(). - vkd3d: Get rid of the default fragment shader from d3d12_pipeline_state_init_graphics(). +Francisco Casas (52): + vkd3d-shader/ir: Use iterators in vsir_program_insert_fragment_fog(). + vkd3d-shader/ir: Use iterators in vsir_program_insert_vertex_fog(). + vkd3d-shader/ir: Use iterators in track_liveness(). + vkd3d-shader/ir: Use iterators in vsir_allocate_temp_registers(). + vkd3d-shader/ir: Use iterators in vsir_update_dcl_temps(). + vkd3d-shader/ir: Use iterators in vsir_program_validate(). + vkd3d-shader/ir: Introduce vsir_program_iterator_insert_before_and_move(). + vkd3d-shader/ir: Use iterators in vsir_program_lower_switch_to_selection_ladder(). + vkd3d-shader/dxil: Use vsir_program_append() in sm6_function_emit_blocks(). + vkd3d-shader/dxil: Use vsir_program_append() in sm6_parser_add_instruction(). + vkd3d-shader/dxil: Use sm6_parser_add_instruction() in sm6_parser_descriptor_type_init(). + vkd3d-shader/ir: Avoid direct instruction array access in validation_error(). + vkd3d-shader/ir: Use iterators in control_point_normaliser_emit_hs_input(). + vkd3d-shader/ir: Use iterators in flattener_flatten_phases(). + vkd3d-shader/ir: Merge the hull shader phase flattener into a single pass. + vkd3d-shader/ir: Use iterators in struct vsir_cfg. + vkd3d-shader/ir: Move icbs from struct vkd3d_shader_instruction_array to struct vsir_program. + vkd3d-shader/ir: Move the outpointid_param field out of struct vkd3d_shader_instruction_array. + vkd3d-shader/ir: Store a pointer to the instruction array in struct control_point_normaliser. + vkd3d-shader/ir: Store a pointer to the vsir program in struct control_point_normaliser. + vkd3d-shader/ir: Move the source and destination operand allocators to struct vsir_program. + vkd3d-shader/ir: Use iterators in struct vsir_block. + vkd3d-shader/ir: Introduce shader_instruction_array_append(). + vkd3d-shader/ir: Use a vkd3d_shader_instruction_array in struct vsir_cfg_emit_target. + vkd3d-shader/ir: Use a vkd3d_shader_instruction_array in struct cf_flattener. + vkd3d-shader/ir: Use a vkd3d_shader_instruction_array in vsir_program_lower_switch_to_selection_ladder(). + vkd3d-shader/ir: Use a vkd3d_shader_instruction_array in vsir_program_materialise_phi_ssas_to_temps(). + vkd3d-shader: Store a vkd3d_result in struct vkd3d_shader_parser. + vkd3d-shader/dxil: Handle sm6_parser_add_instruction() returning NULL. + vkd3d-shader/dxil: Set the parser status to VKD3D_ERROR_NOT_IMPLEMENTED on missing functionality. + vkd3d-shader/dxil: Propagate the vkd3d_result of sm6_parser_declare_global(). + vkd3d-shader/dxil: Propagate parser errors in sm6_parser_init(). + vkd3d-shader/dxil: Don't preallocate instructions in sm6_parser_globals_init(). + vkd3d-shader/dxil: Don't preallocate instructions in sm6_function_emit_blocks(). + vkd3d-shader/dxil: Get rid of sm6_parser_require_space(). + vkd3d-shader/ir: Don't preallocate instructions in cf_flattener_iterate_instruction_array(). + vkd3d-shader/ir: Don't preallocate instructions in vsir_program_lower_switch_to_selection_ladder(). + vkd3d-shader/ir: Don't preallocate instructions in vsir_cfg_structure_list_emit_jump(). + vkd3d-shader/ir: Don't preallocate in vsir_program_materialise_phi_ssas_to_temps(). + vkd3d-shader/ir: Don't preallocate instructions in vsir_cfg_structure_list_emit_block(). + vkd3d-shader/ir: Don't preallocate instructions in vsir_cfg_structure_list_emit_loop(). + vkd3d-shader: Update the vsir_program_iterator_insert_before() comment. + tests/shader_runner: Introduce a "cull-distance" capability. + tests/hlsl: Add a simpler clip/cull distance test. + tests/shader_runner_gl: Enable used GL_CLIP_DISTANCEs. + vkd3d-shader/dxil: Also map destination write masks for system values. + vkd3d-shader/ir: Validate I/O destination write masks on normalised vsir. + tests/hlsl: Test which shader models allow FOG and PSIZE. + vkd3d-shader/hlsl: Actually emit 0xf write masks for FOG and PSIZE destination operands. + vkd3d-shader/ir: Make FOG and PSIZE write masks 0x1 on I/O normalization. + vkd3d-shader/hlsl: Avoid member access on NULL resource load (ubsan). + vkd3d-shader/hlsl: Retrieve error_instr instead of NULL in hlsl_block_add_resource_load(). -Francisco Casas (38): - tests/d3d12: Avoid out-of-bounds access when evaluating ok() args (ubsan). - tests/shader_runner_d3d12: Handle the "bug" qualifier on state creation failure. - tests/hlsl: Test the allocation order of return semantics. - vkd3d-shader/hlsl: Allocate return variables before other outputs. - tests/hlsl: Fix up point-sprite.shader_test. - vkd3d-shader/hlsl: Update the enum hlsl_sampler_dim comment. - vkd3d-shader/ir: Avoid a compiler warning in vsir_block_list_init(). - tests/hlsl: Add semantic cascading tests. - vkd3d-shader/hlsl: Use the index in the hlsl_semantic when appending output copies. - vkd3d-shader/hlsl: Use the index in the hlsl_semantic when prepending input copies. - vkd3d-shader/hlsl: Don't pass the semantic index in add_semantic_var(). - vkd3d-shader/hlsl: Make output semantics on structs cascade down onto the fields. - vkd3d-shader/hlsl: Make input semantics on structs cascade down onto the fields. - tests/hlsl: Add additional semantic cascading tests. - tests: Test semantic cascading signatures. - vkd3d-shader/hlsl: Dump processed function bodies. - vkd3d-shader/ir: Validate flags in SAMPLE_INFO operations. - vkd3d-shader/ir: Validate flags in RESINFO operations. - vkd3d-shader/dxil: Use iterators in sm6_parser_globals_init(). - vkd3d-shader/hlsl: Use vsir_program_append() in sm1_generate_vsir_constant_defs(). - vkd3d-shader/hlsl: Use vsir_program_append() in sm1_generate_vsir_sampler_dcls(). - vkd3d-shader/hlsl: Use vsir_program_append() in generate_vsir_add_program_instruction(). - vkd3d-shader/ir: Use iterators in vsir_program_ensure_diffuse(). - vkd3d-shader/ir: Use iterators in vsir_program_remap_output_signature(). - vkd3d-shader/ir: Use iterators in instruction_array_normalise_hull_shader_control_point_io(). - vkd3d-shader/ir: Use iterators in vsir_program_normalise_flat_constants(). - vkd3d-shader/ir: Use iterators in vsir_program_normalise_io_registers(). - vkd3d-shader/ir: Remove the io_normaliser.instructions field. - vkd3d-shader/ir: Use iterators in vsir_program_remove_dead_code(). - vkd3d-shader/ir: Use iterators in cf_flattener_iterate_instruction_array(). - vkd3d-shader/ir: Use iterators in vsir_program_flatten_hull_shader_phases(). - vkd3d-shader/ir: Use iterators in vsir_program_materialise_phi_ssas_to_temps(). - vkd3d-shader/ir: Use iterators in vsir_program_insert_alpha_test(). - vkd3d-shader/ir: Use iterators in vsir_program_insert_clip_planes(). - vkd3d-shader/ir: Use iterators in vsir_program_insert_point_size(). - vkd3d-shader/ir: Use iterators in vsir_program_insert_point_size_clamp(). - vkd3d-shader/ir: Use iterators in vsir_program_insert_point_coord(). - vkd3d-compiler: Set a default target type even when preprocessing. +Giovanni Mascellani (105): + vkd3d: Use MESSAGE when exceeding Vulkan descriptor limits in d3d12_command_list_update_descriptor_table(). + vkd3d-shader/msl: Access resources as non-multisampled if the sample count is 1. + vkd3d-shader/msl: Reject UAV stores to multi-sampled resources. + vkd3d-shader/ir: Introduce temp_allocator_compute_allocation_map(). + vkd3d-shader/ir: Use a faster TEMP allocation algorithm. + vkd3d-shader/ir: Fix r0 allocation for PS 1.x shaders. + tests/hlsl: Skip a d3d11 minimum precision array indexing test on NVIDIA. + tests/hlsl: Fix the results for the 64-bit bit searching functions. + tests/hlsl: Skip a shader model 6 floating-point comparison test on Windows NVIDIA. + tests/hlsl: Explicitly specify the mantissa to be used for the frexp() test. + tests/hlsl: Skip testing frexp(inf) for shader models < 4. + tests/hlsl: Allow a larger error tolerance on a trigonometry test. + tests/shader_runner_metal: Enable supported UAV formats. + tests/hlsl: Add a test for SV_DispatchThreadId. + vkd3d-shader/msl: Implement VKD3DSPR_THREADID. + vkd3d-shader/ir: Do not carry "ins" across loop instances in vsir_program_materialize_undominated_ssas_to_temps(). + vkd3d-shader/ir: Explicitly initialize instruction arrays. + vkd3d-shader/ir: Execute PHI SSA to TEMP materialization in a single pass. + vkd3d-shader/ir: Execute PHI SSA to TEMP materialization in each function. + ci: Run Linux tests on Debian trixie. + tests/hlsl: Add a test for SV_GroupIndex. + tests/hlsl: Add a test for SV_GroupID. + tests/hlsl: Add a test for SV_GroupThreadID. + vkd3d-shader/msl: Implement VKD3DSPR_LOCALTHREADINDEX. + vkd3d-shader/msl: Implement VKD3DSPR_LOCALTHREADID. + vkd3d-shader/msl: Implement VKD3DSPR_THREADGROUPID. + tests: Remove is_mesa_intel_device(). + tests: Introduce get_vulkan_driver_version(). + tests: Introduce get_mesa_driver_version(). + tests: Introduce get_mvk_driver_version(). + tests: Introduce get_nvidia_driver_version(). + tests: Introduce get_llvm_driver_version(). + tests/shader_runner: Introduce a new tag system. + vkd3d-shader/ir: Lower ABS modifiers to instructions. + vkd3d-shader/dxil: Generate ABS instructions instead of using modifiers. + vkd3d-shader/dxil: Rename "handler_idx" to "opcode" in sm6_parser_emit_binop(). + vkd3d-shader/dxil: Rename "handler_idx" to "opcode" in instruction_init_with_resource(). + vkd3d-shader/dxil: Rename "handler_idx" to "opcode" in sm6_parser_emit_dx_atomic_binop(). + vkd3d-shader/dxil: Rename "handler_idx" to "opcode" in sm6_parser_dcl_register_builtin(). + vkd3d-shader/dxil: Rename "handler_idx" to "opcode" in sm6_parser_emit_dx_dot(). + vkd3d-shader/dxil: Rename "handler_idx" to "opcode" in struct sm6_cmp_info. + vkd3d-shader/dxil: Rename "handler_idx" to "opcode" in sm6_parser_emit_dcl_count(). + vkd3d-shader/dxil: Rename "handler_idx" to "opcode" in sm6_parser_emit_dcl_primitive_topology(). + vkd3d-shader/ir: Introduce VSIR_OP_NEG to represent floating-point negation. + vkd3d-shader/ir: Lower NEG modifiers to instructions. + vkd3d-shader/ir: Use VSIR_OP_NEG in insert_fragment_fog_before_ret(), in the linear case. + vkd3d-shader/ir: Use VSIR_OP_NEG in insert_fragment_fog_before_ret(), in the exponential case. + vkd3d-shader/ir: Use VSIR_OP_NEG in insert_fragment_fog_before_ret(), in the doubly exponential case. + vkd3d-shader/ir: Use VSIR_OP_NEG in insert_fragment_fog_before_ret(), in the common part. + vkd3d-shader/ir: Lower ABSNEG modifiers to instructions. + vkd3d-shader/ir: Introduce VSIR_OP_SATURATE to represent floating-point clamping to [0, 1]. + vkd3d-shader/ir: Lower SATURATE modifiers to instructions. + vkd3d: Do not put immutable samplers in the push descriptor set. + tests: Print ANSI colour codes in the Windows test driver. + tests/d3d12: Use D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE in test_depth_load(). + tests/d3d12: Use D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE in test_stencil_load(). + tests/hlsl: Check the result for attribute evaluation tests more sharply. + ci: Run the Windows tests with WARP version 1.0.16.1. + vkd3d-shader/ir: Remove SATURATE modifiers after lowering them. + vkd3d-shader/ir: Process all destinations when lowering SATURATE modifiers. + vkd3d-shader/ir: Ignore and drop PARTIALPRECISION modifiers. + vkd3d-shader/ir: Error out on unsupported destination modifiers. + vkd3d-shader/ir: Error out on unsupported source modifiers. + vkd3d-shader/ir: Use VSIR_OP_SATURATE in vsir_program_lower_texcoord(). + vkd3d-shader/ir: Explicitly assert that vsir_program_normalise_ps1_output() runs before I/O normalization. + vkd3d-shader/ir: Use VSIR_OP_SATURATE in vsir_program_normalise_ps1_output(). + vkd3d-shader/ir: Use VSIR_OP_SATURATE in insert_fragment_fog_before_ret(). + vkd3d-shader/ir: Check that no modifier is added to a vsir program after lowering. + tests/hlsl: Use explicit infinities in cast-to-half.shader_test. + tests/hlsl: Do not test some details of float-to-half conversion. + tests/hlsl: Use explicit infinities in half.shader_test. + tests/hlsl: Evaluate asin() with larger error tolerance on SM6. + tests/hlsl: Add SM6 behaviour in sm1-const-folding.shader_test. + tests/hlsl: Tweak hyperbolic functions tests on WARP. + vkd3d-shader/msl: Introduce msl_get_binding(). + vkd3d-shader/msl: Return a raw index from msl_get_binding(). + vkd3d-shader/msl: Retrieve the CBV register space from the descriptor information. + tests/hlsl: Do not test overflowing a float-to-half typed buffer read. + tests/hlsl: Skip a tessellation test that is buggy on WARP with SM>=6. + vkd3d-shader/msl: Pass a descriptor to msl_get_cbv_binding(). + vkd3d-shader/msl: Pass a descriptor to msl_get_srv_binding(). + vkd3d-shader/msl: Pass a descriptor to msl_get_sampler_binding(). + vkd3d-shader/msl: Pass a descriptor to msl_get_uav_binding(). + vkd3d-shader/msl: Pass a descriptor to msl_get_binding(). + tests/shader_runner_metal: Unify the UAV and TEXTURE cases when computing descriptor bindings. + vkd3d-shader/msl: Allow binding to descriptor arrays. + vkd3d-shader/msl: Implement support for VKD3DSPR_UNDEF registers. + tests/shader_runner_d3d12: Move the uniform root parameter to the end of the root signature. + tests/shader_runner: Add support for testing explicit descriptor mapping. + tests/hlsl: Test shader model 6.2 denormal mode for 32-bit floats. + tests/hlsl: Test shader model 6.2 denormal mode for 16-bit and 64-bit floats. + ci: Exclude the WARP driver from the test-win-32 and test-win-64 artifacts. + tests/hlsl: Do not execute 64-bit wave bitwise operations on WARP. + ci: Merge job test-win-64-dxc into test-win-64. + ci: Execute DXC tests on 32-bit as well. + tests/d3d12: Do not crash when failing to create a shader cache session. + tests/shader_runner_d3d12: Appropriately set the root descriptor table for dispatching. + tests/shader_runner_d3d12: Always create a descriptor heap. + tests/shader_runner: Generate a default descriptor mapping when none is provided. + tests/shader_runner_metal: Implement explicit descriptor mapping. + vkd3d-shader/dxil: Parse the gather offset as an int2. + tests/hlsl: Test using an SRV in combination with a CBV larger than the declared uniforms. + vkd3d-shader/spirv: Clamp push constant CBV sizes to those of the push constant ranges backing them. + tests/hlsl: Mark a denormalization mode test as todo on Intel. + tests/d3d12: Mark a texture aliasing test as todo on Intel. -Giovanni Mascellani (251): - vkd3d-shader/dxil: Pass a reference to the SM6 parser to src_params_init_from_operands(). - vkd3d-shader/dxil: Pass a reference to the SM6 parser to src_param_init_from_value(). - vkd3d-shader/dxil: Pass a reference to the SM6 parser to sm6_register_from_value(). - vkd3d-shader/dxil: Reimplement aggregate indexing using specialized value types. - tests/hlsl: Test minimum precision stride in constant buffers. - tests/hlsl: Test minimum precision 16-bit unsigned integers. - tests/hlsl: Test minimum precision 16-bit signed integers. - tests/hlsl: Remove some tests from minimum-precision.shader_test. - tests/hlsl: Test casting doubles to minimum precision integers. - tests/hlsl: Test casting minimum precision integers to doubles. - tests/hlsl: Test casting 16-bit integers to doubles. - tests/hlsl: Test native 16-bit floating point numbers. - tests/hlsl: Test minimum precision floating point numbers. - tests/hlsl: Test minimum precision stride for signed integers too. - tests/hlsl: Test minimum precision stride for floating point numbers too. - tests/hlsl: Do not test for overflowing 16-bit texture sampling. - tests/hlsl: Mark a test in object-references.shader_test as todo on MoltenVK with DXIL. - tests/hlsl: Mark some tests in clip-cull-distance.shader_test as buggy on MoltenVK with d3d12. - tests/hlsl: Mark a test in gather-offset.shader_test as buggy on MoltenVK with d3d12. - tests/hlsl: Mark some tests in wave-ops-uint.shader_test as buggy on MoltenVK. - tests/hlsl: Mark some tests in wave-ops-int.shader_test as buggy on MoltenVK. - tests/hlsl: Mark some tests in uav-atomics.shader_test as working on MoltenVK. - ci: Really use DXC 1.8.2502 for macOS. - vkd3d-shader/dxil: Do not touch the parser current value in instruction_dst_param_init_temp_vector(). - vkd3d-shader/dxil: Generate CONSTANT values in sm6_parser_constants_init() for integer values. - vkd3d-shader/dxil: Generate CONSTANT values in sm6_parser_constants_init() for floating-point values. - vkd3d-shader/dxil: Generate specialized values in sm6_parser_constants_init() for casts. - vkd3d-shader/dxil: Generate CONSTANT values in sm6_parser_constants_init() for null scalars. - vkd3d-shader/dxil: Remove bitcast helpers. - tests/hlsl: Test sampling with minimum precision floating-point numbers. - tests/hlsl: Test the interstage interface for minimum precision types. - tests/hlsl: Use the appropriate RTV format in shader-interstage-interface.shader_test. - tests/hlsl: Add a test reading from a minimum precision signed integer array. - tests/hlsl: Add some more minimum precision floating-point tests. - tests/hlsl: Add a test reading from a minimum precision floating-point array. - tests/hlsl: Mark a test in sm6-uav-rwtexture.shader_test as todo on MoltenVK. - tests/hlsl: Mark a test in register-reservation-resources.shader_test as todo on MoltenVK with DXIL. - tests/hlsl: Mark a test in entry-point-semantics.shader_test as buggy on MoltenVK with DXIL. - tests/hlsl: Mark some tests in geometry.shader_test as buggy on MoltenVK. - tests/hlsl: Mark some tests in wave-ops-float.shader_test as buggy on MoltenVK. - vkd3d-shader/glsl: Accept and ignore the REFACTORING_ALLOWED global flag. - vkd3d-shader/msl: Accept and ignore the REFACTORING_ALLOWED global flag. - vkd3d-shader/glsl: Ignore the PARTIALPRECISION destination modifier. - vkd3d-shader/msl: Ignore the PARTIALPRECISION destination modifier. - tests: Add a test for the ABSNEG source modifier. - vkd3d-shader/glsl: Support the ABSNEG source modifier. - vkd3d-shader/msl: Support the ABSNEG source modifier. - vkd3d-shader/dxil: Do not use field "reg" in of sm6_value when writing bitcasts. - vkd3d-shader/dxil: Validate that floating-point truncation casts decrease bit width. - vkd3d-shader/dxil: Validate that integer extension casts increase bit width. - vkd3d-shader/dxil: Validate that floating-point extension casts increase bit width. - vkd3d-shader/dxil: Handle 16-bit values uniformly in sm6_map_cast_op(). - tests: Mark some tests in arithmetic-int-uniform.shader_test as buggy on MoltenVK < 1.2.11. - tests: Mark some tests in calculate-lod.shader_test as buggy on MoltenVK < 1.2.11. - ci: Enable testing with DXC again on macOS. - tests/hlsl: Test minimum precision IDXTEMP registers. - vkd3d-shader/hlsl: Reject programs with group shared variables. - tests/hlsl: Test some quirks of TGSMs with SM < 5.0. - tests/hlsl: Test TGSMs with minimum precision unsigned integers. - vkd3d-shader/dxil: Generate specialized values in sm6_parser_emit_cast() for trivial casts. - vkd3d-shader/dxil: Represent non uniformness in the SM6 value. - vkd3d-shader/dxil: Store a SM6 value in sm6_phi. - vkd3d-shader/dxil: Do not set the value type in sm6_parser_declare_global(). - vkd3d-shader/dxil: Do not set the value type in sm6_parser_function_init(). - tests: Skip test_graphics_compute_queue_synchronization() on paravirtualized MoltenVK. - tests: Add a test about discontiguous input swizzles in bytecode format. - tests: Fix the shader model requirements for a ps_5_0 shader. - vkd3d-shader/dxil: Rewrite sm6_value_is_constant() in terms of the value type. - vkd3d-shader/dxil: Rewrite sm6_value_is_undef() in terms of the value type. - vkd3d-shader/dxil: Rewrite sm6_value_is_ssa() in terms of the value type. - vkd3d-shader/dxil: Rewrite sm6_value_get_constant_uint() in terms of the SM6 value. - vkd3d-shader/dxil: Rewrite sm6_value_get_constant_uint64() in terms of the SM6 value. - vkd3d-shader/dxil: Rewrite sm6_value_is_constant_zero() in terms of the SM6 value. - vkd3d-shader/dxil: Rewrite sm6_parser_init_ssa_value() in terms of the SM6 value. - vkd3d-shader/dxil: Introduce sm6_value_get_constant_float(). - vkd3d-shader/dxil: Remove field "reg" from struct sm6_value. - vkd3d-shader/dxil: Emit 16-bit CONSTANT values as minimum precision registers. - vkd3d-shader/dxil: Emit 16-bit arrays as minimum precision types. - vkd3d-shader/dxil: Emit 16-bit IDXTEMP values as minimum precision registers. - vkd3d-shader/dxil: Emit 16-bit SSA values as minimum precision registers. - vkd3d-shader/dxil: Emit 16-bit ICB values as minimum precision registers. - vkd3d-shader/ir: Rename VKD3D_SHADER_ERROR_VSIR_INVALID_HANDLER to VKD3D_SHADER_ERROR_VSIR_INVALID_OPCODE. - vkd3d-shader/dxil: Allow constant zero values to be floating point. - vkd3d-shader/dxil: Emit 16-bit raw TGSMs as minimum precision. - vkd3d-shader/dxil: Emit 16-bit structured TGSMs as minimum precision. - vkd3d-shader/dxil: Emit 16-bit GROUPSHAREDMEM values as minimum precision registers. - vkd3d-shader/dxil: Emit 16-bit UNDEFINED and INVALID values as minimum precision registers. - vkd3d-shader/ir: Validate ABS instructions. - vkd3d-shader/ir: Validate ACOS instructions. - vkd3d-shader/ir: Validate ADD instructions. - vkd3d-shader/ir: Validate AND instructions. - vkd3d-shader/ir: Validate ASIN instructions. - vkd3d-shader/ir: Validate ATAN instructions. - tests: Add a test for the partial precision destination modifier. - vkd3d-shader/ir: Validate data types for NEG source modifiers. - vkd3d-shader/ir: Validate data types for BIAS source modifiers. - vkd3d-shader/ir: Validate data types for BIASNEG source modifiers. - vkd3d-shader/ir: Validate data types for SIGN source modifiers. - vkd3d-shader/ir: Validate data types for SIGNNEG source modifiers. - vkd3d-shader/ir: Introduce opcode COS. - vkd3d-shader/ir: Introduce opcode SIN. - vkd3d-shader/ir: Lower d3dbc SINCOS to the new COS and SIN instructions. - vkd3d-shader/ir: Lower tpf SINCOS to the new COS and SIN instructions. - vkd3d-shader/ir: Validate DADD instructions. - vkd3d-shader/ir: Validate DDIV instructions. - vkd3d-shader/ir: Validate DFMA instructions. - vkd3d-shader/ir: Validate DGEO instructions. - vkd3d-shader/ir: Validate DIV instructions. - vkd3d-shader/ir: Validate DLT instructions. - vkd3d-shader/ir: Validate DMAX instructions. - vkd3d-shader/ir: Validate DMIN instructions. - vkd3d-shader/ir: Validate DMOV instructions. - vkd3d-shader/ir: Validate DMUL instructions. - vkd3d-shader/ir: Validate data types for COMP source modifiers. - vkd3d-shader/ir: Validate data types for X2 source modifiers. - vkd3d-shader/ir: Validate data types for X2NEG source modifiers. - vkd3d-shader/ir: Validate data types for DZ source modifiers. - vkd3d-shader/ir: Validate data types for DW source modifiers. - vkd3d-shader/ir: Introduce VKD3DSIH_IMUL_LOW. - vkd3d-shader/ir: Lower IMUL and UMUL to IMUL_LOW. - vkd3d-shader/ir: Validate data types for ABS source modifiers. - vkd3d-shader/ir: Validate data types for ABSNEG source modifiers. - vkd3d-shader/ir: Validate data types for NOT source modifiers. - vkd3d-shader/ir: Validate data types for SATURATE destination modifiers. - vkd3d-shader/ir: Validate data types for destination shifts. - vkd3d-shader/ir: Validate DNE instructions. - vkd3d-shader/ir: Validate DRCP instructions. - vkd3d-shader/ir: Validate DSX instructions. - vkd3d-shader/ir: Validate DSX_COARSE instructions. - vkd3d-shader/ir: Validate DSX_FINE instructions. - vkd3d-shader/ir: Validate DSY instructions. - vkd3d-shader/ir: Validate DSY_COARSE instructions. - vkd3d-shader/ir: Validate DSY_FINE instructions. - vkd3d-shader/ir: Do not crash when registers cannot be resolved to signature elements. - vkd3d-shader/ir: Introduce VSIR_OP_IREM. - vkd3d-shader/ir: Repurpose IDIV to compute plain signed division. - vkd3d-shader/ir: Introduce VSIR_OP_UDIV_SIMPLE. - vkd3d-shader/ir: Introduce VSIR_OP_UREM. - vkd3d-shader/ir: Lower UDIV to UDIV_SIMPLE and UREM. - vkd3d-shader/ir: Validate EQO instructions. - vkd3d-shader/ir: Validate DEQO instructions. - vkd3d-shader/ir: Validate EQU instructions. - vkd3d-shader/ir: Validate EXP instructions. - vkd3d-shader/ir: Validate FRC instructions. - vkd3d-shader/ir: Validate FREM instructions. - vkd3d-shader/ir: Validate GEO instructions. - vkd3d-shader/ir: Validate GEU instructions. - vkd3d-shader/ir: Test the data type when validating comparison operations. - tests/hlsl: Test int64 comparisons. - tests/hlsl: Test uint64 comparisons. - vkd3d-shader/ir: Validate HCOS instructions. - vkd3d-shader/ir: Validate HSIN instructions. - vkd3d-shader/ir: Validate HTAN instructions. - vkd3d-shader/ir: Validate IADD instructions. - vkd3d-shader/ir: Validate IEQ instructions. - vkd3d-shader/ir: Validate IGE instructions. - vkd3d-shader/ir: Validate ILT instructions. - vkd3d-shader/ir: Collect the hull shader phase flattener code together. - vkd3d-shader/ir: Handle SSA registers when flattening hull shader phases. - vkd3d-shader/ir: Do not make a local copy of the instructions array in vsir_program_flatten_hull_shader_phases(). - vkd3d: Move vkd3d_vk_descriptor_set_index_from_vk_descriptor_type() to resource.c. - vkd3d/resource: Write null descriptors with their correct type when using mutable descriptor types. - vkd3d-shader/ir: Validate descriptor flags in vsir programs. - vkd3d-shader/ir: Validate UAV flags in vsir programs. - vkd3d-shader/ir: Validate IMAD operations. - vkd3d-shader/ir: Validate IMAX operations. - vkd3d-shader/ir: Validate IMIN operations. - vkd3d-shader/ir: Validate INE operations. - vkd3d-shader/ir: Validate INEG operations. - vkd3d-shader/ir: Validate IREM operations. - vkd3d-shader/ir: Validate ISHL operations. - vkd3d-shader/ir: Validate ISHR operations. - vkd3d-shader/ir: Introduce an abstraction to iterate through vsir instructions. - vkd3d-shader/ir: Use the iterator in vsir_program_lower_ifc(). - vkd3d-shader/ir: Use the iterator in vsir_program_lower_texkill(). - vkd3d-shader/ir: Use the iterator in vsir_program_lower_precise_mad(). - vkd3d-shader/ir: Sort vsir_validator_instructions[] alphabetically. - vkd3d-shader/ir: Validate ISFINITE operations. - vkd3d-shader/ir: Validate ISINF operations. - vkd3d-shader/ir: Validate ISNAN operations. - vkd3d-shader/ir: Validate ITOF operations. - vkd3d-shader/ir: Validate ITOI operations. - vkd3d-shader/ir: Validate FTOI operations. - vkd3d-shader/ir: Validate FTOU operations. - vkd3d-shader/ir: Set dimension to VEC4 when converting SSAs to TEMPs. - vkd3d-shader/ir: Do not print a message for registers that are not being allocated. - vkd3d-shader/ir: Use the iterator in vsir_program_lower_udiv(). - vkd3d-shader/ir: Use the iterator in vsir_program_lower_sm1_sincos(). - vkd3d-shader/ir: Use the iterator in vsir_program_lower_sm4_sincos(). - vkd3d-shader/ir: Use the iterator in vsir_program_lower_texldp(). - vkd3d-shader/ir: Validate LOG operations. - vkd3d-shader/ir: Validate LTO operations. - vkd3d-shader/ir: Validate LTU operations. - vkd3d-shader/ir: Validate MAD operations. - vkd3d-shader/ir: Validate MAX operations. - vkd3d-shader/ir: Validate MIN operations. - vkd3d-shader/ir: Validate MUL operations. - vkd3d-shader/ir: Check that LOCALTHREADINDEX registers have dimension VEC4. - vkd3d-shader/ir: Check that COVERAGE registers have dimension VEC4. - vkd3d-shader/ir: Check that DEPTHOUT registers have dimension SCALAR. - vkd3d-shader/ir: Check that DEPTHOUTGE registers have dimension SCALAR. - vkd3d-shader/ir: Check that DEPTHOUTLE registers have dimension SCALAR. - vkd3d-shader/ir: Check that LOCALTHREADID registers have dimension VEC4. - vkd3d-shader/ir: Check that THREADGROUPID registers have dimension VEC4. - vkd3d-shader/ir: Update the program TEMP count when allocating TEMP registers. - vkd3d-shader/ir: Split updating DCL_TEMPS instructions to a dedicated pass. - vkd3d-shader/ir: Check that THREADID registers have dimension VEC4. - vkd3d-shader/ir: Check that SAMPLEMASK registers have dimension SCALAR. - vkd3d-shader/ir: Check that GSINSTID registers have dimension SCALAR. - vkd3d-shader/ir: Check that OUTPOINTID registers have dimension SCALAR. - vkd3d-shader/ir: Check that PRIMID registers have dimension SCALAR. - vkd3d-shader/ir: Check that OUTSTENCILREF registers have dimension SCALAR. - vkd3d-shader/ir: Introduce vsir_program_append(). - vkd3d-shader/tpf: Use iterators in tpf_write_program(). - vkd3d-shader/spirv: Use iterators in spirv_compiler_generate_spirv(). - vkd3d-shader/msl: Use iterators in msl_generator_generate(). - vkd3d-shader/glsl: Use iterators in vkd3d_glsl_generator_generate(). - vkd3d-shader/d3d-asm: Use iterators in d3d_asm_compile(). - vkd3d-shader/d3dbc: Use vsir_program_append() in d3dbc_parse(). - vkd3d-shader/d3dbc: Use iterators in d3dbc_write_program_instructions(). - vkd3d-shader/ir: Validate NEO operations. - vkd3d-shader/ir: Validate NEU operations. - vkd3d-shader/ir: Validate NOT operations. - vkd3d-shader/ir: Validate OR operations. - vkd3d-shader/ir: Validate ORD instructions. - vkd3d-shader/ir: Validate RCP instructions. - vkd3d-shader/ir: Validate ROUND_NE instructions. - vkd3d-shader/ir: Validate ROUND_NI instructions. - vkd3d-shader/ir: Use size_t in the parameter allocator. - vkd3d-shader/ir: Use size_t in the instruction array. - vkd3d-shader: Use size_t in the string buffer. - vkd3d-shader/msl: Ignore the interpolation mode for output variables. - vkd3d-shader/msl: Emit indexable temps with the appropriate component count. - vkd3d-shader/msl: Use the union type for SAMPLEMASK registers. - vkd3d-shader/msl: Reject shaders with duplicate I/O target locations. - vkd3d-shader/msl: Convert the results of load and sample operations to the destination data type. - vkd3d-shader/dxil: Emit gather offsets as signed. - vkd3d-shader/d3d-asm: Emit precise flags for a number of opcodes. - vkd3d-shader/spirv: Support precise flags on RESINFO instructions. - vkd3d-shader/spirv: Support precise flags on SAMPLE_INFO instructions. - tests/hlsl: Test SV_GSInstanceID. - vkd3d-shader/ir: Check that GSINSTID registers have dimension VEC4. - vkd3d-shader/hlsl: Reject geometry shaders with instance count. - vkd3d-shader: Use iterators in vsir_program_scan(). - vkd3d-shader/ir: Use iterators in vsir_program_normalize_addr(). - vkd3d-shader/ir: Use iterators in vsir_program_ensure_ret(). - vkd3d-shader: Use the structure names when creating the parameter allocators. - vkd3d-shader: Enable converting DXIL to MSL. - vkd3d-shader/msl: Allocate SSA registers to temporaries. - tests/shader_runner_metal: Allow checking shader model 5.1 too. - tests/shader_runner_metal: Run the Metal shader runner with DXIL shaders. +Henri Verbeet (199): + tests/shader_runner: Use read_f32() to parse "uniform" directives. + tests/shader_runner: Use read_f64() to parse "uniform" directives. + vkd3d-shader: Implement scanning compute shader thread group size information. + vkd3d-shader/hlsl: Support MSL as target format. + vkd3d-shader/d3dbc: Store a pointer to the vsir program in struct vkd3d_shader_sm1_parser. + vkd3d-shader/dxil: Store a pointer to the vsir program in struct sm6_parser. + vkd3d-shader/tpf: Store a pointer to the vsir program in struct vkd3d_shader_sm4_parser. + vkd3d-common: Introduce VKD3D_SHADER_API_VERSION_CURRENT. + vkd3d-shader/ir: Generate location information in vsir_program_ensure_ret(). + vkd3d-shader/ir: Generate location information in vsir_program_ensure_diffuse(). + vkd3d-shader/ir: Pass NULL locations to vkd3d_shader_error() in use_flat_interpolation(). + vkd3d-shader/ir: Pass a NULL location to vkd3d_shader_error() in insert_alpha_test_before_ret(). + vkd3d-shader/ir: Pass NULL locations to vkd3d_shader_error() in vsir_program_insert_alpha_test(). + tests/shader_runner_metal: Implement compute shader dispatch. + vkd3d-shader/msl: Implement compute shaders. + vkd3d-shader/glsl: Implement support for static texel offsets in shader_glsl_ld(). + vkd3d-shader/glsl: Implement VSIR_OP_DSX and VSIR_OP_DSY. + vkd3d-shader/glsl: Implement VSIR_OP_COS. + vkd3d-shader/glsl: Implement VSIR_OP_SIN. + vkd3d-shader/glsl: Implement VSIR_OP_UDIV_SIMPLE. + vkd3d-shader/ir: Pass NULL locations to vkd3d_shader_error() in vsir_program_insert_clip_planes(). + vkd3d-shader/ir: Pass a NULL location to vkd3d_shader_error() in vsir_program_insert_point_size(). + vkd3d-shader/ir: Pass NULL locations to vkd3d_shader_error() in vsir_program_insert_point_size_clamp(). + vkd3d-shader/ir: Generate location information in vsir_program_insert_point_coord(). + vkd3d-shader/ir: Pass NULL locations to vkd3d_shader_error() in vsir_program_insert_fragment_fog(). + vkd3d-shader/ir: Pass NULL locations to vkd3d_shader_error() in vsir_program_insert_vertex_fog(). + vkd3d-shader/glsl: Implement VSIR_OP_UREM. + vkd3d-shader/glsl: Handle SV_INSTANCE_ID inputs. + vkd3d-shader/glsl: Implement support for VKD3DSPR_SAMPLEMASK registers. + vkd3d-shader/ir: Remove VSIR_OP_DCL_INPUT_PRIMITIVE instructions. + vkd3d-shader/ir: Remove VSIR_OP_DCL_OUTPUT_TOPOLOGY instructions. + vkd3d-shader/ir: Introduce vsir_data_type_get_name(). + vkd3d-shader/ir: Use vsir_data_type_get_name() in vsir_validate_label_register(). + vkd3d-shader/ir: Use vsir_data_type_get_name() in vsir_validate_sampler_register(). + vkd3d-shader/ir: Use vsir_data_type_get_name() in vsir_validate_resource_register(). + vkd3d-shader/ir: Use vsir_data_type_get_name() in vsir_validate_uav_register(). + vkd3d-shader/spirv: Rename vkd3d_spirv_get_type_id() to spirv_get_type_id_for_component_type(). + vkd3d-shader/spirv: Rename vkd3d_spirv_get_type_id_for_data_type() to spirv_get_type_id(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_get_type_id_for_reg(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_spec_constant(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_get_buffer_parameter(). + vkd3d-shader/d3d-asm: Check the actual index count in shader_print_register(). + vkd3d-shader/dxil: Use vkd3d_shader_parser_error() to report errors in vsir_data_type_from_dxil(). + vkd3d-shader/ir: Use vsir_data_type_get_name() in vsir_validate_ssa_register(). + vkd3d-shader/ir: Use vsir_data_type_get_name() in vsir_validate_dst_param(). + vkd3d-shader/ir: Use vsir_data_type_get_name() in vsir_validate_src_param(). + vkd3d-shader/ir: Use vsir_data_type_get_name() in vsir_validate_elementwise_operation(). + vkd3d-shader/ir: Use vsir_data_type_get_name() in vsir_validate_comparison_operation(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_register_addressing(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_get_descriptor_index(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_int_to_bool(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_bool_to_int(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_bool_to_int64(). + vkd3d-shader/msl: Do not pretend to support initialisers for indexable temporaries. + vkd3d-shader/d3d-asm: Print data types for indexable temporary declarations. + vkd3d-shader/dxil: Emit 16-bit indexable temporaries as 32-bit registers. + vkd3d-shader/hlsl: Map HLSL_TYPE_HALF to VSIR_DATA_F32. + vkd3d-shader/ir: Map 16-bit vsir types to 16-bit component types in vkd3d_component_type_from_data_type(). + vkd3d-shader/ir: Move the instruction array helpers to ir.c. + vkd3d-shader/hlsl: Implement constant folding of 'mad' expressions. + vkd3d-shader/hlsl: Implement constant folding of 'sin' expressions. + vkd3d-shader/hlsl: Implement constant folding of 'cos' expressions. + vkd3d-shader/hlsl: Implement constant folding of 'reinterpret' expressions. + tests/hlsl: Add a constant folding test for round(). + vkd3d-shader/hlsl: Implement constant folding of 'round' expressions. + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_bool_to_float(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_bool_to_double(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_draw_parameter_fixup(). + vkd3d-shader/spirv: Use spirv_get_type_id() in frag_coord_fixup(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_load_invocation_id(). + vkd3d-shader/spirv: Handle i64 component types. + vkd3d-shader/ir: Handle all component types in vsir_data_type_from_component_type(). + vkd3d-shader/ir: Use vsir_data_type_get_name() in vsir_validate_cast_operation(). + vkd3d-shader/ir: Use vsir_data_type_get_name() in vsir_validate_shift_operation(). + vkd3d-shader/ir: Use vsir_data_type_get_name() in vsir_validate_throw_invalid_dst_type_error_with_flags(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_shader_epilogue_function(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_dcl_indexable_temp(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_push_constant_buffers(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_cbv_declaration(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_resource_declaration(). + vkd3d-shader/hlsl: vsir constant buffer sizes are specified in bytes. + vkd3d-shader/hlsl: Set the "flat constant" count in sm1_generate_vsir(). + vkd3d-shader/hlsl: Use VKD3DSPR_COMBINED_SAMPLER destination operands in sm1_generate_vsir_sampler_dcls(). + vkd3d-shader/hlsl: Set the "has_point_size" flag for vertex shaders outputting point sizes. + vkd3d-shader/ir: Make the vsir assembly data type names consistent with the corresponding enum elements. + vkd3d-shader/dxil: Allow returning signed types from vsir_data_type_from_dxil(). + vkd3d-shader/dxil: Allow creating signed parameters in instruction_dst_param_init_ssa_scalar(). + vkd3d-shader/dxil: Allow creating signed parameters in src_param_init_from_value(). + vkd3d-shader/d3d-asm: Handle i64 immediate constants. + vkd3d-shader/ir: Require signed source operands for ITOF instructions. + vkd3d-shader/ir: Remove some unused fields from struct io_normaliser. + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_workgroup_memory(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_ext_glsl_instruction(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_movc(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_swapc(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_dot(). + tests/hlsl: Add a missing "}" to trigonometry.shader_test. + vkd3d-shader/ir: Require signed operands for ISHR instructions. + vkd3d-shader/ir: Validate USHR instructions. + vkd3d-shader/ir: Require signed source operands for signed integer comparison instructions. + vkd3d-shader/ir: Require signed operands for IMAX instructions. + vkd3d-shader/ir: Require signed operands for IMIN instructions. + vkd3d-shader/ir: Require default swizzles on vec4 immediate constants. + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_ftoi(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_ftou(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_dtof(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_bitfield_instruction(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_f16tof32(). + vkd3d-shader/ir: Avoid memset() in vsir_instruction_init(). + vkd3d-shader/msl: Handle VSIR_DATA_BOOL operands. + vkd3d-shader/ir: Return early for shader model < 4 in vsir_update_dcl_temps(). + vkd3d-shader/d3dbc: Don't call vsir_update_dcl_temps(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_f32tof16(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_comparison_instruction(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_float_comparison_instruction(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_lod(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_ld_tgsm(). + vkd3d-shader/spirv: Explicitly ignore HLSL compilation options. + vkd3d-shader/hlsl: Fold "x < 0" to false for unsigned x. + vkd3d-shader/hlsl: Remove a hlsl_type_is_integer() prototype. + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_store_tgsm(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_uav_counter_instruction(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_bufinfo(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_resinfo(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_query_sample_count(). + vkd3d-shader/msl: Implement VSIR_OP_COS. + vkd3d-shader/msl: Implement VSIR_OP_SIN. + vkd3d-shader/msl: Implement VSIR_OP_TAN. + vkd3d-shader/msl: Implement VSIR_OP_HCOS. + vkd3d-shader/msl: Implement VSIR_OP_HSIN. + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_sample_info(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_sample_position(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_eval_attrib(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_group_nonuniform_ballot(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_wave_bit_count(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_generate_spirv(). + vkd3d-shader/spirv: Pass a vsir_data_type to spirv_compiler_get_constant_vector(). + vkd3d-shader/spirv: Pass a vsir_data_type to spirv_compiler_get_constant(). + vkd3d-shader/spirv: Pass a vsir_data_type to spirv_compiler_get_constant64(). + vkd3d-shader/spirv: Pass a vsir_data_type to spirv_compiler_emit_construct_vector(). + vkd3d-shader/msl: Implement VSIR_OP_HTAN. + vkd3d-shader/msl: Implement VSIR_OP_ACOS. + vkd3d-shader/msl: Implement VSIR_OP_ASIN. + vkd3d-shader/msl: Implement VSIR_OP_ATAN. + vkd3d-shader/msl: Implement VSIR_OP_FREM. + vkd3d-shader/spirv: Use vsir_data_type in struct vkd3d_spirv_builtin. + vkd3d-shader/spirv: Use vsir_data_type in struct vkd3d_symbol_register_data. + vkd3d-shader/spirv: Use vsir_data_type in struct vkd3d_shader_register_info. + vkd3d-shader/spirv: Use vsir_data_type in struct vkd3d_symbol_resource_data. + vkd3d-shader/spirv: Use vsir_data_type in struct vkd3d_shader_image. + vkd3d-shader/spirv: Use vsir_data_type in struct vkd3d_shader_output_info. + vkd3d-shader/spirv: Pass a vsir_data_type to spirv_compiler_emit_array_variable(). + vkd3d-shader/spirv: Pass a vsir_data_type to spirv_compiler_emit_swizzle(). + vkd3d-shader/spirv: Pass a vsir_data_type to spirv_compiler_emit_vector_shuffle(). + vkd3d-shader/spirv: Pass a vsir_data_type to spirv_compiler_emit_store_scalar(). + vkd3d-shader/spirv: Pass a vsir_data_type to spirv_compiler_emit_store_dst_components(). + vkd3d-shader/spirv: Pass a vsir_data_type to spirv_compiler_get_image_type_id(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_ld_raw_structured_srv_uav(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_store_uav_raw_structured(). + vkd3d-shader/spirv: Use spirv_get_type_id() in spirv_compiler_emit_atomic_instruction(). + tests/shader_runner: Handle the "rgba" probe format as an alias for "f32". + vkd3d-shader/spirv: Pass a vsir_data_type to spirv_compiler_emit_load_src_with_type(). + vkd3d-shader/spirv: Pass a vsir_data_type to spirv_compiler_emit_store_dst_swizzled(). + vkd3d-shader/spirv: Pass a vsir_data_type to spirv_compiler_emit_interpolation_decorations(). + vkd3d-shader: Get rid of component_type_is_64_bit(). + vkd3d-shader/dxil: Ignore ORDERING_SEQCST. + vkd3d-shader/spirv: Do not handle division by zero for VSIR_OP_IDIV or VSIR_OP_IREM. + tests: Replace the test_shader_instructions() "ps_udiv" test with a shader runner test. + vkd3d-shader/glsl: Handle integer operands in shader_glsl_movc(). + vkd3d-shader/ir: Handle integer division by zero in vsir_program_lower_udiv(). + tests/shader_runner: Use format names if available in trace_format_cap(). + vkd3d-shader/spirv: Handle VSIR_DATA_MIXED in spirv_get_type_id(). + vkd3d-shader/msl: Implement VSIR_OP_UDIV_SIMPLE. + vkd3d-shader/ir: Validate IDIV instructions. + vkd3d-shader/msl: Implement VSIR_OP_IDIV. + vkd3d-shader/msl: Implement VSIR_OP_UREM. + vkd3d-shader/ir: Require signed operands for IREM instructions. + vkd3d-shader/msl: Implement VSIR_OP_IREM. + vkd3d-shader/spirv: Emit an error for unhandled types in spirv_get_type_id(). + tests/hlsl: Add tests for unorm and snorm buffer SRVs. + vkd3d-shader/glsl: Handle VSIR_DATA_SNORM and VSIR_DATA_UNORM in shader_glsl_vprint_assignment(). + vkd3d-shader/d3dbc: Trace the vsir program before applying any transformations. + tests: Test that ps_1_4 texld samples from the sampler corresponding to the destination operand. + vkd3d-shader/d3dbc: Get the resource/sampler index from the destination operand in vsir_program_lower_texld_sm1(). + vkd3d-shader: Avoid referencing "ins" after insertion in vsir_program_materialise_phi_ssas_to_temps_in_function(). + vkd3d-shader/spirv: Free the output on failure in spirv_compiler_generate_spirv(). + vkd3d-shader/dxil: Only add declared ICBs to the vsir program. + vkd3d-shader/ir: Remove VSIR_OP_DCL_IMMEDIATE_CONSTANT_BUFFER instructions. + vkd3d-shader/msl: Include metal_stdlib in the generated code. + vkd3d-shader/msl: Implement VSIR_OP_SYNC. + vkd3d-shader/msl: Implement support for VKD3DSPR_IMMCONSTBUFFER registers. + vkd3d-shader/msl: Implement VSIR_OP_COUNTBITS. + vkd3d-shader/msl: Implement VSIR_OP_FIRSTBIT_LO. + vkd3d-shader/msl: Implement VSIR_OP_FIRSTBIT_HI. + vkd3d-common: Get rid of "vkd3d_dbg_env_name". + vkd3d-shader/d3d-asm: Avoid shader_print_data_type() in shader_dump_resource_data_type(). + vkd3d-shader/hlsl: Consider scalars to be equivalent to 1-component vectors in hlsl_add_conditional(). + vkd3d-shader: Document vkd3d_shader_scan_thread_group_size_info as a supported chained compilation structure. + vkd3d-shader: Explicitly support all chained compilation structures with vkd3d_shader_scan(). -Henri Verbeet (148): - vkd3d-shader: Also output vkd3d_shader_verror() messages using WARN. - vkd3d-shader: Also output vkd3d_shader_vwarning() messages using WARN. - vkd3d-shader: Also output vkd3d_shader_vnote() messages using WARN. - vkd3d-shader: Remove some newlines from vkd3d-shader error messages. - tests/shader_runner_metal: Try harder to find a suitable device. - tests/shader_runner_d3d11: Direct3D 11 supports geometry shaders. - tests/hlsl: Require the "geometry-shader" cap for the relevant clip/cull-distance tests. - tests/hlsl: Get rid of a MSL todo in geometry.shader_test. - tests/hlsl: Slightly adjust the bias values in the sample-bias tests. - vkd3d-shader: Move vkd3d_siv_from_sysval_indexed() to hlsl_codegen.c. - vkd3d-shader/msl: Make the generated main function static. - tests/shader_runner: Introduce a "tessellation-shader" cap. - vkd3d-shader/msl: Ensure we have a non-NULL "resource_type_info" pointer in msl_ld(). - vkd3d-shader/msl: Reject cube and multi-sample texel fetches in msl_ld(). - vkd3d-shader/msl: Get rid of the "lod" field of struct msl_resource_type_info. - vkd3d-shader/msl: Slightly improve the error messages for unspecified descriptor bindings. - vkd3d-shader/msl: Continue when the SRV descriptor binding isn't specified in msl_ld(). - vkd3d-shader/msl: Implement support for indirect constant buffer addressing. - vkd3d-shader/msl: Handle SV_POSITION inputs. - vkd3d-shader/msl: Handle SV_VERTEX_ID inputs. - vkd3d-shader/msl: Simplify SV_DEPTH handling. - tests/shader_runner_metal: Implement multi-sample readback. - tests/shader_runner_metal: Set the pipeline sample count in metal_runner_draw(). - vkd3d-shader/msl: Handle SV_SAMPLE_INDEX inputs. - vkd3d-shader/msl: Implement support for VKD3DSPR_IDXTEMP registers. - vkd3d-shader/msl: Implement support for VKD3DSPR_SAMPLEMASK registers. - vkd3d-shader/msl: Implement VKD3DSIH_EQO. - vkd3d-shader/msl: Implement VKD3DSIH_IADD. - vkd3d-shader/msl: Implement VKD3DSIH_IGE. - vkd3d-shader/ir: Introduce vsir_opcode_get_name(). - vkd3d-shader/d3dbc: Use vsir_opcode_get_name() in shader_sm1_get_opcode_info_from_vsir_instruction(). - vkd3d-shader/d3dbc: Use vsir_opcode_get_name() in d3dbc_write_vsir_instruction(). - vkd3d-shader/glsl: Use vsir_opcode_get_name() in shader_glsl_unhandled(). - vkd3d-shader/ir: Use vsir_opcode_get_name() in vsir_program_lower_instructions(). - vkd3d-shader/msl: Implement VKD3DSIH_ILT. - vkd3d-shader/msl: Implement VKD3DSIH_IMUL. - vkd3d-shader/msl: Implement loops. - vkd3d-shader/msl: Implement switches. - vkd3d-shader/msl: Implement VKD3DSIH_DISCARD. - tests/shader_runner: Rename the "ri64" probe format to "i64". - tests/shader_runner: Introduce the "u64" probe format. - tests/shader_runner: Introduce the "f64" probe format. - tests/shader_runner: Introduce the "i32" probe format. - tests/shader_runner: Introduce the "u32" probe format. - tests/shader_runner: Introduce the "f32" probe format. - demos: Allow Vulkan to determine the swapchain image count. - vkd3d-shader/msl: Implement VKD3DSIH_INEG. - vkd3d-shader/msl: Implement VKD3DSIH_ULT. - vkd3d-shader/msl: Implement VKD3DSIH_XOR. - tests/shader_runner_metal: Implement resource copies. - vkd3d-shader/msl: Implement VKD3DSIH_LD2DMS. - vkd3d-shader/ir: Use vsir_opcode_get_name() in the validator. - vkd3d-shader/msl: Use vsir_opcode_get_name() in msl_unhandled(). - vkd3d-shader/spirv: Use vsir_opcode_get_name() in spirv_compiler_handle_instruction(). - vkd3d-shader/spirv: Use vsir_opcode_get_name() in spirv_compiler_emit_atomic_instruction(). - vkd3d-shader/spirv: Use vsir_opcode_get_name() in spirv_compiler_emit_sample(). - demos: Print the GPU and platform we're running on. - demos: Map the Win32 A-Z keys to a-z. - vkd3d-shader/spirv: Use vsir_opcode_get_name() in spirv_compiler_emit_deriv_instruction(). - vkd3d-shader/spirv: Use vsir_opcode_get_name() in spirv_compiler_emit_comparison_instruction(). - vkd3d-shader/spirv: Use vsir_opcode_get_name() in spirv_compiler_emit_bitfield_instruction(). - vkd3d-shader/spirv: Use vsir_opcode_get_name() in spirv_compiler_emit_ext_glsl_instruction(). - vkd3d-shader/spirv: Use vsir_opcode_get_name() in spirv_compiler_emit_alu_instruction(). - demos: Introduce a helper function to create a projection matrix. - vkd3d-shader/spirv: Emit an OpSource instruction with the source name. - vkd3d: Use the DXBC checksum to construct a shader source name. - demos/teapot: Add a tessellation demo. - vkd3d-shader/msl: Implement VKD3DSIH_SAMPLE. - vkd3d-shader/msl: Implement VKD3DSIH_SAMPLE_B. - vkd3d-shader/msl: Implement VKD3DSIH_SAMPLE_C. - vkd3d-shader/msl: Implement VKD3DSIH_SAMPLE_C_LZ - vkd3d-shader/msl: Implement VKD3DSIH_SAMPLE_GRAD. - vkd3d-shader/spirv: Do not require VKD3D_SHADER_BINDING_FLAG_IMAGE for sampler descriptors. - vkd3d-shader/d3dbc: Use TAG_CTAB in d3dbc_compile(). - demos/teapot: Add on-screen help. - vkd3d-shader/msl: Implement VKD3DSIH_SAMPLE_LOD. - vkd3d-shader/msl: Implement VKD3DSIH_GATHER4. - vkd3d-shader/msl: Implement VKD3DSIH_GATHER4_C. - vkd3d-shader/msl: Implement VKD3DSIH_GATHER4_PO. - vkd3d-shader/msl: Implement support for static texel offsets in msl_sample(). - vkd3d-shader/ir: Rename the VKD3DSIH_* enum elements to VSIR_OP_*. - vkd3d-shader/msl: Implement VSIR_OP_CONTINUE. - vkd3d-shader/msl: Implement VSIR_OP_DSX and VSIR_OP_DSY. - vkd3d-shader/msl: Implement VSIR_OP_DSX_COARSE and VSIR_OP_DSY_COARSE. - vkd3d-shader/msl: Implement VSIR_OP_DSX_FINE and VSIR_OP_DSY_FINE. - vkd3d-shader/msl: Implement VSIR_OP_IMAX. - vkd3d-shader/ir: Create SSA values with the corresponding dimension in vsir_program_lower_sm4_sincos(). - vkd3d-shader/ir: Create SSA values with the corresponding dimension in vsir_program_lower_udiv(). - demos/teapot: Add an fps counter. - vkd3d-shader/msl: Implement VSIR_OP_UMAX and VSIR_OP_UMIN. - tests/shader_runner_metal: Implement buffer textures. - vkd3d-shader/msl: Implement VSIR_OP_STORE_UAV_TYPED. - vkd3d-shader/msl: Implement VKD3DSGF_FORCE_EARLY_DEPTH_STENCIL. - tests/shader_runner_gl: Implement geometry shaders. - demos/teapot: Add diffuse lighting. - demos/teapot: Add a flat shading toggle. - vkd3d-shader/ir: Rename enum vkd3d_data_type to vsir_data_type. - vkd3d-shader/ir: Rename VKD3D_DATA_HALF to VSIR_DATA_F16. - vkd3d-shader/ir: Rename VKD3D_DATA_FLOAT to VSIR_DATA_F32. - vkd3d-shader/ir: Rename VKD3D_DATA_DOUBLE to VSIR_DATA_F64. - demos/teapot: Animate the camera. - vkd3d-shader/ir: Rename VKD3D_DATA_INT to VSIR_DATA_I32. - vkd3d-shader/ir: Rename VKD3D_DATA_UINT8 to VSIR_DATA_U8. - vkd3d-shader/ir: Rename VKD3D_DATA_UINT16 to VSIR_DATA_U16. - vkd3d-shader/ir: Rename VKD3D_DATA_UINT to VSIR_DATA_U32. - vkd3d-shader/ir: Rename VKD3D_DATA_UINT64 to VSIR_DATA_U64. - vkd3d-shader/ir: Consistently use VKD3D_DATA_UNUSED for STREAM registers. - vkd3d-shader/ir: Rename VKD3D_DATA_UNORM to VSIR_DATA_UNORM. - vkd3d-shader/ir: Rename VKD3D_DATA_SNORM to VSIR_DATA_SNORM. - vkd3d-shader/ir: Rename VKD3D_DATA_OPAQUE to VSIR_DATA_OPAQUE. - vkd3d-shader/ir: Rename VKD3D_DATA_MIXED to VSIR_DATA_MIXED. - vkd3d-shader/ir: Rename VKD3D_DATA_CONTINUED to VSIR_DATA_CONTINUED. - vkd3d-shader/ir: Rename VKD3D_DATA_UNUSED to VSIR_DATA_UNUSED. - vkd3d-shader/ir: Rename VKD3D_DATA_BOOL to VSIR_DATA_BOOL. - vkd3d-shader/ir: Explicitly initialise the "resource_data_type" field in vsir_instruction_init(). - vkd3d-shader/spirv: Use spirv_compiler_error() to report unhandled sample_info flags. - vkd3d-shader/spirv: Use spirv_compiler_error() to report unhandled resinfo flags. - vkd3d-shader/ir: Consistently use VSIR_DATA_U32 for sample_info_uint destination operands. - vkd3d-shader/ir: Consistently use VSIR_DATA_U32 for resinfo_uint destination operands. - vkd3d-shader/hlsl: Get rid of the "hlsl" argument to hlsl_compile_shader(). - vkd3d-shader/tpf: Update the comment describing the data type mapping in init_sm4_lookup_tables(). - vkd3d-shader/ir: Allow source operands of shift operations to have different data types. - vkd3d-shader/hlsl: Emit vsir from hlsl_emit_bytecode(). - vkd3d-shader: Call vsir_program_scan() for d3d-asm targets in vsir_program_compile(). - vkd3d-shader/spirv: Emit OpLine instructions. - demos/teapot: Add specular lighting. - vkd3d-shader/hlsl: Introduce hlsl_compile_effect(). - vkd3d-shader/hlsl: Initialise the vsir program in hlsl_emit_vsir(). - vkd3d-shader/hlsl: Generate vsir signatures in hlsl_emit_vsir(). - vkd3d-shader/spirv: Update the SPIR-V grammar JSON to the vulkan-sdk-1.4.313.0 release. - vkd3d-shader/ir: Free program parameters on failure in vsir_program_init() if needed. - include: Remove some redudant TAG_* definintions from vkd3d_shader_util.h. - vkd3d: Set the maximum viewport count in d3d12_pipeline_state_get_or_create_pipeline(). - vkd3d-shader/ir: Use vsir_program_append() in vsir_program_ensure_ret(). - tests/shader_runner: Parse hex blobs as a list of 32-bit integers. - tests: Strip reflection data from dxbc-tpf-hex shaders. - tests/d3d12: Check whether the d3d12 device supports geometry shaders. - tests/shader_runner_d3d12: Check whether the d3d12 device supports geometry shaders. - vkd3d-shader: Cleanup the vsir program on vsir_program_transform_early() failure in vsir_parse(). - vkd3d-shader: Introduce struct vkd3d_shader_source_list. - vkd3d-shader/hlsl: Pass a vkd3d_shader_source_list pointer to hlsl_ctx_init(). - vkd3d-shader/hlsl: Initialise the vsir program in hlsl_compile_shader(). - vkd3d-shader/hlsl: Return a vsir program from hlsl_compile_shader(). - vkd3d-shader/hlsl: Support HLSL sources in vkd3d_shader_scan(). - vkd3d-shader/spirv: Avoid emitting duplicate built-in inputs in spirv_compiler_emit_input(). - vkd3d-shader/d3d-asm: Resolve SSA values when outputting SM<6 assembly. - vkd3d-shader/glsl: Resolve SSA values. - vkd3d-shader: Document that vkd3d_shader_scan() supports HLSL sources. +Nikolay Sivov (3): + vkd3d: Check that the allocator type matches the list type in d3d12_command_list_Reset(). + vkd3d: Implement d3d12_device_CreateCommandList1(). + tests/hlsl: Add some tests for special semantic name suffixes. -Nikolay Sivov (45): - vkd3d-shader/fx: Handle nameless structure types. - vkd3d-shader/fx: Use the correct value range for bool initializers. - vkd3d-shader/fx: Use the correct field indices when writing structure default values. - vkd3d-shader/fx: Fix the total buffer size calculation in write_fx_4_buffer(). - vkd3d-shader/fx: Fix writing fx_2_0 structure parameters. - vkd3d-shader/fx: Use variable unpacked size when setting buffer sizes. - vkd3d-shader/fx: Print explicit buffer bind points in fx -> d3d-asm output. - vkd3d-shader/fx: Print packoffset() modifiers in fx -> d3d-asm output. - vkd3d-shader/fx: Fix some typos in fx_2_0 state names. - vkd3d-shader/fx: Use correct array sizes for the fx_2_0 states. - vkd3d-shader/fx: Fix reading the assignment value base type when parsing fx_2_0. - vkd3d-shader/fx: Fix a crash in fx -> d3d-asm when named values are not defined. - vkd3d-shader/fx: Handle bool types when parsing fx_2_0 assignment values. - vkd3d-shader/fx: Add a few missing fxlc opcode names. - vkd3d-shader/fx: Do not print padding bytes of fx_2_0 strings. - vkd3d-shader/fx: Use a separate table for sampler states in fx_2_0. - vkd3d-shader/fx: Give fxlvm-specific constants a version-neutral name. - vkd3d-shader/fx: Use a version-neutral name for the opcode table. - vkd3d-shader/fx: Read instruction arguments in full before printing them. - vkd3d-shader/fx: Use more generic names for the literal constant array. - vkd3d-shader/fx: Add a helper to print literals. - vkd3d-shader/fx: Rename the constant argument helper to be version-neutral. - vkd3d-shader/fx: Parse array selector expressions for fx_2_0. - vkd3d-shader/fx: Remove the unused fx_4_fxlc_argument type. - vkd3d-shader/fx: Explicitly check all known state assignment types for fx_2_0. - vkd3d-shader/fx: Output value expressions for fx_2_0. - vkd3d-shader/fx: Output indirect register access in arguments. - vkd3d-shader/fx: Add the "noise" opcode name. - vkd3d-shader/fx: Add support for tx -> text output. - vkd3d-shader/d3dbc: Use the actual instruction length in d3dbc_write_instruction(). - vkd3d-shader/hlsl: Add a stub for the noise() intrinsic. - vkd3d-shader/fx: Use a version-independent structure for states. - vkd3d-shader/fx: Use the same state data helpers for both fx_2_0 and fx_4+. - vkd3d-shader/fx: Move state decomposition to the fx_4_0-specific writing path. - vkd3d-shader/fx: Move entry count updates out of the state block writing helper. - vkd3d-shader/fx: Add a format-specific callback to write state assignments. - vkd3d-shader/fx: Fix the order of the "MaterialDiffuse" and "MaterialAmbient" state entries. - vkd3d-shader/fx: Improve register naming in the disassembly output. - vkd3d-shader/fx: Use the correct value range for bools in fx_4_0 state values. - vkd3d-shader/fx: Explicitly handle bool state values when parsing. - vkd3d-shader/ir: Handle TEXLDL instructions in vsir_program_lower_instructions(). - vkd3d-shader/hlsl: Handle HLSL_RESOURCE_SAMPLE_LOD in sm1_generate_vsir_instr_resource_load(). - vkd3d-shader/fx: Handle regular shader blobs when parsing the state data. - vkd3d-shader/fx: Do not attempt to parse expressions without code section. - vkd3d: Return success from d3d12_device_EnumerateMetaCommands(). +Petrichor Park (7): + tests: Normalise NAN values in compare_float() and compare_double(). + tests/hlsl: Add some tests for the frexp() intrinsic. + vkd3d-shader/hlsl: Implement the frexp() intrinsic. + tests/hlsl: Split the test for countbits()/firstbithigh()/firstbitlow(). + vkd3d-shader/hlsl: Implement the countbits() intrinsic. + vkd3d-shader/hlsl: Implement the firstbithigh() intrinsic. + vkd3d-shader/hlsl: Implement the firstbitlow() intrinsic. -Shaun Ren (19): - vkd3d-shader/tpf: Read the DCL_OUTPUT_SGV instruction. - vkd3d-shader/hlsl: Implement output semantics for geometry shaders. - tests: Test signature reflection for geometry shader outputs. - vkd3d-shader/hlsl: Fix the register string for patch arrays in debug_register(). - vkd3d-shader/hlsl: Support void pass-through hull shader control point functions. - vkd3d-shader/hlsl: Emit dcl_stream instructions for SM5 geometry shaders. - vkd3d-shader/hlsl: Generate vsir instructions for indexed output streams in geometry shaders. - vkd3d-shader/hlsl: Store stream index in struct hlsl_semantic. - vkd3d-shader/hlsl: Don't optimize semantic register allocations in SM1. - vkd3d-shader/hlsl: Remove a leftover TODO message. - vkd3d-shader/hlsl: Only dump store writemasks for single register types. - vkd3d-shader/hlsl: Handle nodes with NULL data types in hlsl_replace_node(). - vkd3d-shader/hlsl: Allow memory barriers in SM4+ target profiles. - vkd3d-shader/hlsl: Ignore the 'groupshared' modifier for non-compute shaders. - vkd3d-shader/hlsl: Allocate groupshared registers. - vkd3d-shader/hlsl: Emit dcl_tgsm_raw instructions for raw groupshared variables. - vkd3d-shader/hlsl: Support loads from groupshared variables. - vkd3d-shader/hlsl: Support stores to raw groupshared variables. - vkd3d-shader/hlsl: Support interlocked operations on non-indexed groupshared variables. +Shaun Ren (29): + vkd3d-shader/hlsl: Check whether "expr" has more than 2 operands in hlsl_normalize_binary_exprs(). + vkd3d-shader/glsl: Implement VSIR_OP_UGE. + vkd3d-shader/msl: Implement VSIR_OP_UGE. + vkd3d-shader/hlsl: Fold some general unary identities. + vkd3d-shader/hlsl: Fold some general conditional identities. + tests/shader_runner: Correct the minification filter and mipmap mode calculations. + tests/shader_runner: Correct the d3d11/d3d12 subresource indexing calculations. + tests/shader_runner: Allocate the d3d11/d3d12 resource_data arrays dynamically. + tests/hlsl: Add sample bias tests for cube textures. + vkd3d-shader/hlsl: Implement texCUBEbias(). + tests/hlsl: Test ternary operations with integral vector operands. + vkd3d-shader/hlsl: Support SM1 non-floating point CMP expressions. + vkd3d-shader/hlsl: Remove the whitespace before the closing parenthesis in dump_ir_expr(). + vkd3d-shader/hlsl: Reject SM1 programs with interpolation modifiers. + tests/shader_runner_d3d9: Add multisampling support. + tests/hlsl: Add tests for centroid interpolation in SM1. + vkd3d-shader/hlsl: Handle the "_centroid" modifier suffix in semantic names. + vkd3d-shader/hlsl: Add support for the centroid interpolation mode in SM1. + tests/shader_runner: Add a "compile shader model" require directive. + vkd3d-shader/ir: Determine the correct writemask for destinations with fixed masks. + vkd3d-shader/ir: Keep source swizzles for registers with fixed masks in temp_allocator_set_src(). + vkd3d-shader/hlsl: Dump the jump condition node in dump_ir_jump(). + tests/hlsl: Add some conditional flattening tests. + vkd3d-shader/hlsl: Cast discard_neg conditions to vec4 for d3dbc target profiles. + vkd3d-shader/hlsl: Store the flatten type in struct hlsl_ir_if. + vkd3d-shader/hlsl: Flatten conditional branches containing stores. + vkd3d-shader/hlsl: Flatten conditional blocks containing discard_nz instructions. + vkd3d-shader/hlsl: Flatten conditional blocks containing discard_neg instructions. + vkd3d-shader/hlsl: Use a bool type for "new_cond" in lower_conditional_block_discard_nz(). -Victor Chiletto (4): - tests/hlsl: Add a few extra structured buffer matrix load + swizzle tests. - vkd3d-shader/hlsl: Parse SRV structured buffers. - vkd3d-shader/hlsl: Transform hlsl_ir_index into structured buffers into field specific hlsl_ir_resource_loads. - vkd3d-shader/hlsl: Split matrix copies from resource loads. +Victor Chiletto (6): + vkd3d-shader/hlsl: Emit texture declarations for SRV structured buffers. + vkd3d-shader/hlsl: Use the packed byte size as the stride for structured buffer texture declarations. + vkd3d-shader/hlsl: Emit vsir structured loads. + vkd3d-shader/hlsl: Force default majority for resource formats. + vkd3d-shader/hlsl: Emit RDEF metadata for SRV structured buffers. + tests/hlsl: Add a reflection test for SRV structured buffers. ``` diff --git a/ChangeLog.md b/ChangeLog.md index 5e09d0052..2deafa9f0 100644 --- a/ChangeLog.md +++ b/ChangeLog.md @@ -1,3 +1,103 @@ +# What's new in vkd3d 1.18 (20 November 2025) + +### libvkd3d + + - The CreateCommandList1() method of the ID3D12Device4 interface is + implemented. + +### libvkd3d-shader + + - Several new features and improvements for the HLSL source type: + - Flattening of branched code. I.e., code using if/else statements can be + turned into conditional moves when that's either advantageous or + necessary. Cases where this is necessary include targeting shader model + 2.0 or earlier, as well as code using the ‘flatten’ attribute. + - More constant folding improvements. For example: + - asfloat(), asint(), asuint(), cos(), mad(), round(), and sin() + operations are constant folded. + - ‘true ? x : y’ is folded to ‘x’ + - ‘x ? true : false’ is folded to ‘x’ + - ‘||x||’ is folded to ‘|x|’ + - ‘~~x’ is folded to ‘x’ + - ‘x < 0’ is folded to ‘false’ for unsigned ‘x’ + - The following intrinsic functions: + - countbits() + - firstbithigh() + - firstbitlow() + - frexp() + - texCUBEbias() + - Integer-typed conditional expressions in shader model 1-3 target + profiles. Previously these were only supported in shader model 4+ target + profiles. + - Resource loads from ‘StructuredBuffer’ resources. + - ‘centroid’ interpolation modifiers in shader model 1-3 target profiles. + - Support for ‘\_centroid’ modifier suffixes on I/O semantics. I.e., + ‘float2 t : TEXCOORD0_centroid’ is equivalent to ‘centroid float2 t : + TEXCOORD0’. + + - The following legacy Direct3D byte-code instructions are implemented: + - bem + - tex + - texbem + - texbeml + - texcoord + + - The experimental Metal Shading Language (MSL) target supports the + following features: + - Compute shaders. + - Immediate-constant buffers. + - Standard, inverse, and hyperbolic trigonometric functions. + - Integer division and remainder operations. + - Floating-point remainder operations. + - Bit scanning and counting operations. + - Boolean operands, as produced by DXIL sources. + - Barrier operations. + + - When the experimental MSL target is enabled, the ‘hlsl’ source type can be + used in combination with the ‘msl’ target type to convert HLSL shaders to + MSL. + + - Signed integer operations like min() and max() are correctly translated + from DXIL to MSL. Previously these would end up getting translated as + unsigned operations, and would thus mishandle negative values. + + - The experimental OpenGL Shading Language (GLSL) target supports the + following features: + - Screen-space partial derivatives. + - sin() and cos() operations. + - Unsigned integer division and remainder operations. + - Static texel offsets on texture load operations. + - ‘SV_Coverage’ fragment shader outputs. + - ‘SV_InstanceID’ inputs. + + - Textual output formats are documented to have a zero byte following their + output. This can be convenient for passing such output to functions + expecting a null-terminated string. For some output formats this was + already true in earlier versions of vkd3d, but not guaranteed by the API. + + - New interfaces: + - The vkd3d_shader_d3dbc_source_info structure extends the + vkd3d_shader_compile_info structure, and can be used to specify + auxiliary information for legacy Direct3D byte-code (‘d3dbc’) shaders + that's necessary for target formats like SPIR-V and GLSL, but not + specified by ‘d3dbc’ shaders. In particular, it allows specifying + resource/sampler types for shader model 1 fragment shaders, as well as + which samplers are comparison-mode samplers for shader model 1-3 + shaders. + - The vkd3d_shader_scan_thread_group_size_info structure extends the + vkd3d_shader_compile_info structure, and can be used to to retrieve the + thread group size expected by a compute shader. This information is + particularly useful when targeting Metal environments, because the Metal + API requires the thread group size to be specified through its dispatch + API, instead of being specified by the shader. + - The VKD3D_SHADER_PARAMETER_NAME_BUMP_LUMINANCE_OFFSET_[0-5] shader + parameters specify the corresponding bump-mapping luminance offsets. + - The VKD3D_SHADER_PARAMETER_NAME_BUMP_LUMINANCE_SCALE_[0-5] shader + parameters specify the corresponding bump-mapping luminance scale + factors. + - The VKD3D_SHADER_PARAMETER_NAME_BUMP_MATRIX_[0-5] shader parameters + specify the corresponding bump-mapping transformation matrices. + # What's new in vkd3d 1.17 (21 August 2025) ### libvkd3d diff --git a/Makefile.am b/Makefile.am index 226ba6cbf..1f3cb9ecb 100644 --- a/Makefile.am +++ b/Makefile.am @@ -432,7 +432,7 @@ libvkd3d_shader_la_SOURCES = \ libs/vkd3d-shader/vkd3d_shader_main.c \ libs/vkd3d-shader/vkd3d_shader_private.h libvkd3d_shader_la_CFLAGS = $(AM_CFLAGS) -DLIBVKD3D_SHADER_SOURCE -DVKD3D_DEBUG_ENV=VKD3D_SHADER_DEBUG -I$(srcdir)/libs/vkd3d-shader @SPIRV_TOOLS_CFLAGS@ -libvkd3d_shader_la_LDFLAGS = $(AM_LDFLAGS) -version-info 16:0:15 +libvkd3d_shader_la_LDFLAGS = $(AM_LDFLAGS) -version-info 17:0:16 libvkd3d_shader_la_LIBADD = libvkd3d-common.la @SPIRV_TOOLS_LIBS@ -lm if HAVE_LD_VERSION_SCRIPT libvkd3d_shader_la_LDFLAGS += -Wl,--version-script=$(srcdir)/libs/vkd3d-shader/vkd3d_shader.map @@ -467,7 +467,7 @@ libvkd3d_la_SOURCES = \ libs/vkd3d/vkd3d_shaders.h \ libs/vkd3d/vulkan_procs.h libvkd3d_la_CFLAGS = $(AM_CFLAGS) -DLIBVKD3D_SOURCE -libvkd3d_la_LDFLAGS = $(AM_LDFLAGS) -version-info 18:0:17 +libvkd3d_la_LDFLAGS = $(AM_LDFLAGS) -version-info 19:0:18 libvkd3d_la_LIBADD = libvkd3d-common.la libvkd3d-shader.la @DL_LIBS@ @PTHREAD_LIBS@ if HAVE_LD_VERSION_SCRIPT libvkd3d_la_LDFLAGS += -Wl,--version-script=$(srcdir)/libs/vkd3d/vkd3d.map @@ -480,7 +480,7 @@ libvkd3d_utils_la_SOURCES = \ libs/vkd3d-utils/vkd3d_utils_main.c \ libs/vkd3d-utils/vkd3d_utils_private.h libvkd3d_utils_la_CFLAGS = $(AM_CFLAGS) -DLIBVKD3D_UTILS_SOURCE -libvkd3d_utils_la_LDFLAGS = $(AM_LDFLAGS) -version-info 7:3:6 +libvkd3d_utils_la_LDFLAGS = $(AM_LDFLAGS) -version-info 7:4:6 libvkd3d_utils_la_LIBADD = libvkd3d-common.la libvkd3d-shader.la libvkd3d.la @PTHREAD_LIBS@ if HAVE_LD_VERSION_SCRIPT libvkd3d_utils_la_LDFLAGS += -Wl,--version-script=$(srcdir)/libs/vkd3d-utils/vkd3d_utils.map diff --git a/configure.ac b/configure.ac index c552ee524..49fe6626f 100644 --- a/configure.ac +++ b/configure.ac @@ -1,5 +1,5 @@ AC_PREREQ([2.69]) -AC_INIT([vkd3d],[1.17]) +AC_INIT([vkd3d],[1.18]) AC_CONFIG_AUX_DIR([bin]) AC_CONFIG_MACRO_DIR([m4]) diff --git a/demos/demo_vkd3d.h b/demos/demo_vkd3d.h index 57bd0e716..09c43440f 100644 --- a/demos/demo_vkd3d.h +++ b/demos/demo_vkd3d.h @@ -28,7 +28,7 @@ #ifdef HAVE_XCB # define VK_USE_PLATFORM_XCB_KHR #endif -#define VKD3D_UTILS_API_VERSION VKD3D_API_VERSION_1_17 +#define VKD3D_UTILS_API_VERSION VKD3D_API_VERSION_1_18 #include #include #ifdef HAVE_XCB diff --git a/include/private/vkd3d_common.h b/include/private/vkd3d_common.h index 13b21c04c..918c33821 100644 --- a/include/private/vkd3d_common.h +++ b/include/private/vkd3d_common.h @@ -43,7 +43,7 @@ #include #endif -#define VKD3D_SHADER_API_VERSION_CURRENT VKD3D_SHADER_API_VERSION_1_17 +#define VKD3D_SHADER_API_VERSION_CURRENT VKD3D_SHADER_API_VERSION_1_18 #ifndef ARRAY_SIZE # define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x))) diff --git a/include/vkd3d.h b/include/vkd3d.h index 6ff306f20..921aff45e 100644 --- a/include/vkd3d.h +++ b/include/vkd3d.h @@ -102,6 +102,7 @@ enum vkd3d_api_version VKD3D_API_VERSION_1_15, VKD3D_API_VERSION_1_16, VKD3D_API_VERSION_1_17, + VKD3D_API_VERSION_1_18, VKD3D_FORCE_32_BIT_ENUM(VKD3D_API_VERSION), }; diff --git a/include/vkd3d_shader.h b/include/vkd3d_shader.h index 2ae30b942..352c222f2 100644 --- a/include/vkd3d_shader.h +++ b/include/vkd3d_shader.h @@ -60,6 +60,7 @@ enum vkd3d_shader_api_version VKD3D_SHADER_API_VERSION_1_15, VKD3D_SHADER_API_VERSION_1_16, VKD3D_SHADER_API_VERSION_1_17, + VKD3D_SHADER_API_VERSION_1_18, VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_API_VERSION), }; diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index 2f5dbe8c0..68177f5f5 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -38,7 +38,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 17 +#define VKD3D_SPIRV_GENERATOR_VERSION 18 #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