From 985d317e0e44a654eee2dd9f34da92038d7c2e0f Mon Sep 17 00:00:00 2001 From: Henri Verbeet Date: Wed, 19 Feb 2025 12:00:00 +0100 Subject: [PATCH] Release 1.15. --- ANNOUNCE | 1278 ++++++++++----------------- COPYING | 2 +- ChangeLog.md | 86 ++ Makefile.am | 6 +- commits | 2 - configure.ac | 2 +- demos/demo_xcb.h | 2 +- include/vkd3d.h | 1 + include/vkd3d_shader.h | 1 + libs/vkd3d-shader/fx.c | 2 +- libs/vkd3d-shader/spirv.c | 2 +- libs/vkd3d-utils/vkd3d_utils_main.c | 6 +- libs/vkd3d/state.c | 6 +- programs/vkd3d-compiler/main.c | 2 +- tests/shader_runner_gl.c | 2 +- tests/shader_runner_metal.m | 2 +- tests/shader_runner_vulkan.c | 2 +- 17 files changed, 566 insertions(+), 838 deletions(-) delete mode 100644 commits diff --git a/ANNOUNCE b/ANNOUNCE index f3eeac29..65a1013d 100644 --- a/ANNOUNCE +++ b/ANNOUNCE @@ -1,16 +1,16 @@ -The vkd3d team is proud to announce that release 1.14 of vkd3d, the Direct3D +The vkd3d team is proud to announce that release 1.15 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: - - Disassembler support for binary effects. - - Initial support for Metal Shading Language output. + - Much more complete support for tessellation shaders in the HLSL compiler. + - Improved function overload resolution in the HLSL compiler. - Miscellaneous bug fixes. The source is available from the following location: - + The current source can also be pulled directly from the git repository: @@ -19,846 +19,488 @@ 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.14 +# What's new in vkd3d 1.15 ### libvkd3d - - Depth bounds can be changed dynamically using the OMSetDepthBounds() method - of the ID3D12GraphicsCommandList1 interface. - - - The new VKD3D_CAPS_OVERRIDE environment variable can be used to override the - value of capabilities like the maximum feature level and resource binding - tier reported to applications. + - New interfaces: + - vkd3d_queue_signal_on_cpu() allows a Direct3D 12 fence to be signalled + when all preceding work on a Direct3D 12 command queue has been submitted + to the corresponding Vulkan queue. ### libvkd3d-shader - New features for the HLSL source type: - - Interstage I/O variable packing matches d3dcompiler/fxc more closely. + - ‘InputPatch’ and ‘OutputPatch’ tessellation shader objects. This was the + main feature required by most tessellation shaders that was still missing, + and tessellation shaders should be considered generally usable now. + - Unrolling of loops containing conditional jumps. + - Improved function overload resolution. Previously the compiler was unable + to decide between multiple function overloads with the same number of + parameters. + - The parser is able to continue parsing in a larger number of error cases. + This allows more issues in the input to be reported during a single + compilaton attempt. - The following intrinsic functions are supported: - - dst() - - f32tof16() - - mad() - - modf() - - sincos() - - ‘discard’ support for shader model 1-3 target profiles. - - The ‘SV_SampleIndex’ input semantic for fragment shaders. - - The ‘SV_GroupIndex’ input semantic for compute shaders. - - The ‘earlydepthstencil’ function attribute. - - Constant folding of expressions like ‘x && c’ and ‘x || c’, where ‘c’ is a - constant. - - Preprocessor support for namespaces in macro identifiers. I.e., syntax - like ‘#define NAME1::NAME2::NAME3 1’ works as intended now. - - Structure inheritance. Multiple inheritance is not supported. - - Register assignments for unused constant buffers are allowed to overlap - register assignments for used constant buffers. - - Instruction count reflection data for shader model 4+ target profiles. - This data is contained in the ‘STAT’ DXBC section, and can be queried with - the GetDesc() method of the ID3D11ShaderReflection and - ID3D12ShaderReflection interfaces. Note that the ID3D12ShaderReflection - implementation provided by vkd3d-utils does not currently correctly report - this information. - - ‘unorm’ and ‘snorm’ resource format modifiers. For example, - ‘Texture2D t;’ - - Parser support for ‘ByteAddressBuffer’ resources, as well as their - Load()/Load2()/Load3()/Load4() methods. - - Parser support for ‘RWByteAddressBuffer’ resources, as well as their - Store()/Store2()/Store3()/Store4() methods. - - Parser support for the ‘compile’ keyword, as well as the CompileShader() - and ConstructGSWithSO() intrinsic functions. Actual compilation of - embedded shaders is not implemented yet, but parser support is sufficient - for allowing compilation of HLSL sources containing this syntax to succeed - when targetting shader target profiles like ‘vs_5_0’ or ‘ps_5_0’. - - Initial support for tessellation shaders. Only the most trivial shaders - are supported in this release. Perhaps most notably, both ‘InputPatch’ and - ‘OutputPatch’ are not implemented yet. + - GatherCmp() + - GatherCmpAlpha(), GatherCmpBlue(), GatherCmpGreen(), and GatherCmpRed() + - InterlockedAdd(), InterlockedAnd(), InterlockedCompareExchange(), + InterlockedCompareStore(), InterlockedExchange(), InterlockedMax(), + InterlockedMin(), InterlockedOr(), and InterlockedXor() + - isinf() + - Separate resource and sampler support for shader model 1-3 target + profiles. + - Casts on the left hand side of assignments. + - Reassociation and redistribution of constants in binary expressions, to + facilitate constant folding. + - Packing of interstage I/O variables with the ‘SV_IsFrontFace’, + ‘SV_PrimitiveID’, ‘SV_RenderTargetArrayIndex’, ‘SV_SampleIndex’, and + ‘SV_ViewPortArrayIndex’ semantics matches d3dcompiler/fxc more closely. + - Parser support for the ‘LineStream’, ‘PointStream’, and ‘TriangleStream’ + Stream-Output objects. - - The new ‘fx’ source type can be used in combination with the ‘d3d-asm’ - target type to disassemble binary effects. + - A number of instructions have been implemented for the experimental MSL + target. Although more and more shaders are starting to work, support is + still fairly limited. For example, shader resource views and unordered + access views are still entirely unsupported. - - More complete support for fx_2_0 binary effect output, including support for - annotations, default values, as well as object initialiser data used for e.g. - string, texture, and shader objects. - - - A significant number of instructions have been implemented for the - experimental GLSL target. The GLSL output currently targets version 4.40 - without extensions, but the intention is to make this configurable in a - future release of vkd3d. - - - Experimental support for Metal Shading Language (MSL) output, enabled by - building vkd3d with the ‘-DVKD3D_SHADER_UNSUPPORTED_MSL’ preprocessor - option. The current release is only able to compile the most basic shaders - when targetting MSL. Being an experimental feature, both the ABI and API may - change in future releases; the feature may even go away completely. - Nevertheless, we hope our users find this feature useful, and welcome - feedback and contributions. - - - Shader code generation for various legacy fixed-function features, including - clip planes, point sizes, and point sprites. This is mainly relevant for + - Shader code generation for fixed-function fog. Like the existing shader code + generation for other fixed-function features, this is mainly relevant for executing shader model 1-3 sources in modern target environments like - Vulkan, because those target environments do not implement equivalent - fixed-function features. + Vulkan. - - The amount of shader validation done by the internal validator has been - greatly extended. The validator is enabled by the ‘force_validation’ option, - specified through the VKD3D_SHADER_CONFIG environment variable. + - The ‘fx’ parser can parse binary effects containing inline shader blobs. + + - Internal validator support for validating I/O signatures, as well as I/O + source and destination parameters. The validator is enabled by the + ‘force_validation’ option, specified through the VKD3D_SHADER_CONFIG + environment variable. + + - Internal validator support for validating the number of indices used with a + register, as well as basic bounds checking for static indices. - New interfaces: - - The VKD3D_SHADER_COMPILE_OPTION_DOUBLE_AS_FLOAT_ALIAS flag specifies that - the ‘double’ type behaves as an alias for the ‘float’ type in HLSL sources - with shader model 1-3 target profiles. - - The VKD3D_SHADER_PARAMETER_DATA_TYPE_FLOAT32_VEC4 enumeration value - specifies that a shader parameter contains a 4-dimensional vector of - 32-bit floating-point data. - - The VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_MASK shader parameter specifies - which clip planes are enabled. - - The VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_[0-7] shader parameters specify - the corresponding clip planes. - - The VKD3D_SHADER_PARAMETER_NAME_POINT_SIZE shader parameter specifies the - point size to output when the source shader does not explicitly output a - point size. - - The VKD3D_SHADER_PARAMETER_NAME_POINT_SIZE_MIN shader parameter specifies - the minimum point size to clamp point size outputs to. - - The VKD3D_SHADER_PARAMETER_NAME_POINT_SIZE_MAX shader parameter specifies - the maximum point size to clamp point size outputs to. - - The VKD3D_SHADER_PARAMETER_NAME_POINT_SPRITE shader parameter specifies - whether texture coordinate inputs in fragment shaders should be replaced - with point coordinates. - - The VKD3D_SHADER_SOURCE_FX source type specifies binary Direct3D effects. - - The VKD3D_SHADER_TARGET_MSL target type specifies Metal Shading Language - shaders. - -### libvkd3d-utils - - - The GetDesc() method of the ID3D12ShaderReflection interface returned by - D3DReflect() returns shader version information. - - - New interfaces: - - D3DCompile2VKD3D() is a variant of D3DCompile2() that allows targeting the - behaviour of a specific d3dcompiler version. + - The vkd3d_shader_scan_hull_shader_tessellation_info structure extends the + vkd3d_shader_compile_info structure, and can be used to retrieve the + output primitive type and partitioning mode used by a hull shader. This + information is particularly useful for specifying + vkd3d_shader_spirv_domain_shader_target_info structures when targetting + SPIR-V in OpenGL environments. + - The VKD3D_SHADER_PARAMETER_NAME_FOG_FRAGMENT_MODE shader parameter + specifies the kind of fog to generate in a fragment shader. + - The VKD3D_SHADER_PARAMETER_NAME_FOG_COLOUR shader parameter + specifies the fog colour. + - The VKD3D_SHADER_PARAMETER_NAME_FOG_END shader parameter + specifies the ‘end’ parameter used for linear fog generation. + - The VKD3D_SHADER_PARAMETER_NAME_FOG_SCALE shader parameter + specifies the ‘scale’ parameter used for fog generation. + - The VKD3D_SHADER_PARAMETER_NAME_FOG_SOURCE shader parameter + specifies the kind of fog coordinate to output from a pre-rasterisation + shader. ### vkd3d-compiler - - The ‘--alias-double-as-float’ option specifies that the ‘double’ type - behaves as an alias for the ‘float’ type in HLSL sources with shader model - 1-3 target profiles. + - The new ‘dxbc-fx’ source type specifies an effect binary embedded in a DXBC + container. This is a convenience feature; + ‘vkd3d-compiler -x dxbc-fx blob.dxbc’ is equivalent to + ‘vkd3d-dxbc -x t:FX10 blob.dxbc | vkd3d-compiler -x fx’. - - The ‘fx’ source type specifies binary Direct3D effects. - - - The ‘msl’ target type specifies Metal Shading Language shaders. - -### Changes since vkd3d 1.13: +### Changes since vkd3d 1.14: ``` -Andrey Gusev (3): - vkd3d: Recognise VK_QUEUE_VIDEO_ENCODE_BIT_KHR in debug_vk_queue_flags(). - vkd3d-utils: Store the actual serialisation return value in get_blob_part(). - vkd3d-utils: Store the actual serialisation return value in D3DStripShader(). +Anna (navi) Figueiredo Gomes (6): + vkd3d-shader/hlsl: Implement cast from bool to int for SM1. + tests/hlsl: Add GatherCmp() tests. + vkd3d-shader/hlsl: Implement the GatherCmp() methods. + tests/shader_runner: Add a "mesa<23.3" tag. + tests/hlsl: Add mixed argument size tests. + vkd3d-shader/hlsl: Consider conversions across all parameters in function_compare(). -Anna (navi) Figueiredo Gomes (14): - vkd3d-shader/spirv: Pass a vkd3d_shader_descriptor_info1 structure to spirv_compiler_emit_resource_declaration(). - vkd3d-shader/spirv: Pass a vkd3d_shader_descriptor_info1 structure to spirv_compiler_emit_cbv_declaration(). - vkd3d-shader/spirv: Pass a vkd3d_shader_descriptor_info1 structure to spirv_compiler_emit_sampler_declaration(). - vkd3d-shader/spirv: Pass a vkd3d_shader_descriptor_info1 structure to spirv_compiler_build_descriptor_variable(). - vkd3d-shader/spirv: Break long assembly lines. - vkd3d/state: Replace ERR with WARN in vkd3d_validate_descriptor_set_count(). - tests/shader_runner: Extract a pipeline creation function from d3d12_runner_draw(). - tests/shader_runner: Use ID3D12Device2_CreatePipelineState() when available. - tests/shader_runner: Introduce a 'depth-bounds' test option. - tests/shader_runner: Introduce a "d3d12" tag. - tests: Test depth bounds. - vkd3d: Implement d3d12_command_list_OMSetDepthBounds(). - tests/shader_runner: Test the "earlydepthstencil" attribute. - vkd3d-shader/hlsl: Implement the "earlydepthstencil" attribute. +Conor McCarthy (29): + vkd3d: Store only a single vkd3d descriptor type in each Vulkan descriptor set. + vkd3d: Introduce struct vkd3d_vk_descriptor_pool_array. + vkd3d: Introduce vkd3d_vk_descriptor_pool_array_push_array(). + vkd3d: Introduce vkd3d_vk_descriptor_pool_array_push(). + vkd3d: Introduce vkd3d_vk_descriptor_pool_array_pop(). + vkd3d: Introduce vkd3d_vk_descriptor_pool_array_destroy_pools(). + vkd3d: Create separate descriptor pools for each vkd3d descriptor type. + vkd3d: Create descriptor pools of geometrically increasing size. + tests/hlsl: Add float64 wave op tests. + tests/hlsl: Add uint64 wave op tests. + tests/hlsl: Add int64 wave op tests. + vkd3d-shader/dxil: Implement DX intrinsic EvalSampleIndex. + vkd3d-shader/dxil: Implement DX intrinsic EvalCentroid. + vkd3d: Return the correct depth/stencil plane format from GetCopyableFootprints(). + vkd3d: Return correctly aligned depth/stencil sizes from GetCopyableFootprints(). + vkd3d: Do not require the ALLOW_DEPTH_STENCIL flag for depth/stencil formats in GetCopyableFootprints(). + tests/hlsl: Add a test for SV_RenderTargetArrayIndex. + vkd3d-shader/dxil: Handle SV_RenderTargetArrayIndex. + tests/hlsl: Pass a profile string instead of a shader type to dxc_compiler_compile_shader(). + tests/hlsl: Add some arithmetic uint16 shader tests. + tests/hlsl: Add more arithmetic uint16 tests. + tests/hlsl: Add arithmetic int16 tests. + tests/hlsl: Add arithmetic float16 tests. + tests/hlsl: Add a numeric types 16-bit test. + tests/hlsl: Add constant buffer 16-bit tests. + tests/hlsl: Add GetDimensions() 16-bit tests. + tests/hlsl: Add typed buffer UAV 16-bit tests. + tests/hlsl: Add a raw buffer UAV 16-bit test. + tests/hlsl: Add structured buffer UAV 16-bit tests. -Arkadiusz Hiler (1): - vkd3d-shader/preproc: Support namespaces in macro identifiers. +Elizabeth Figura (65): + vkd3d-shader/spirv: Handle SSA registers in spirv_compiler_get_register_info(). + vkd3d-shader/ir: Allow controlling fog through parameters. + vkd3d-shader/ir: Add a couple of traces for signature remapping. + vkd3d-shader/ir: Allow controlling the fog source through a parameter. + vkd3d-shader/ir: Implement exponential fog. + vkd3d-shader/hlsl: Do not abort when modifying a const expression. + vkd3d-shader/hlsl: Do not abort parsing when invalid modifiers are used. + vkd3d-shader/hlsl: Move the numeric type check to add_constructor(). + vkd3d-shader/hlsl: Return an error expression when a function is used as a variable. + vkd3d-shader/hlsl: Translate invalid implicit-size arrays to an error type. + vkd3d-shader/d3dbc: Omit unnecessary instruction maximum versions. + vkd3d-shader/d3dbc: Mark some more instructions as version-limited. + vkd3d-shader: Fix the disassembly names of IFC and BREAKC. + vkd3d-shader: Correct the disassembly for POSITIONT. + tests: Add a reflection test for shader model 4.0. + vkd3d-shader/hlsl: Remove unused expr ops. + vkd3d-shader/ir: Always initialise "*control_point_count" in vsir_signature_from_register_type(). + vkd3d-shader/hlsl: Document matrix swizzles. + vkd3d-shader/hlsl: Use a structure for matrix swizzles. + vkd3d-shader/hlsl: Use swizzle helpers in more places. + vkd3d-shader/hlsl: Store swizzles in vsir format. + tests/shader_runner: Use is_todo instead of separate shader states. + tests/shader_runner: Use a separate variable for shader type. + tests/shader_runner: Don't bother distinguishing directive substrings. + vkd3d-shader/d3dbc: Use struct vkd3d_shader_dst_param instead of struct sm1_dst_register. + vkd3d-shader/d3dbc: Use struct vkd3d_shader_src_param instead of struct sm1_src_register. + vkd3d-shader/d3dbc: Use struct vkd3d_shader_instruction instead of struct sm1_instruction. + tests/shader_runner: Record HLSL todo/fail state for each shader model. + tests/shader_runner: Test HLSL compilation in a separate pass. + tests/shader_runner: Test versions where the compilation result changes. + tests: Use fail(sm<5) instead of [require] for uav-atomics. + vkd3d-shader/spirv: Correctly implement DTOF. + vkd3d-shader/spirv: Correctly implement DTOI. + vkd3d-shader/spirv: Correctly implement DTOU. + tests/d3d12: Make the dtof test a bit more interesting. + vkd3d-shader: Explicitly translate between d3dbc and vsir register types. + vkd3d-shader/d3dbc: Normalize to a single VKD3DSPR_CONST register set when reading. + vkd3d-shader/d3d-asm: Define register names in a table. + vkd3d-shader/ir: Separate VKD3DSPR_ADDR and VKD3DSPR_TEXTURE. + vkd3d-shader/ir: Separate VKD3DSPR_OUTPUT and VKD3DSPR_TEXCRDOUT. + vkd3d-shader/d3dbc: Introduce d3dbc_parse_register(). + vkd3d-shader/hlsl: Avoid some uses of the default case when switching over hlsl_base_type. + vkd3d-shader/d3dbc: Do not access the type dimensions for non-numeric types. + vkd3d-shader/hlsl: Move the "dimx" and "dimy" fields to the type-specific union. + tests: Adjust angle-unit.shader_test to pass with 1.x. + tests: Adjust arithmetic-float.shader_test to pass with 1.x. + tests: Adjust arithmetic-float-uniform.shader_test to pass with 1.x. + tests: Adjust arithmetic-int.shader_test to pass with 1.x. + tests: Adjust array-parameters.shader_test to pass with 1.x. + tests: Adjust array-size-expr.shader_test to pass with 1.x. + tests: Adjust abs.shader_test to pass with 1.x. + tests: Add another unrolling test. + vkd3d-shader/hlsl: Implement broadcasts in constant folding. + vkd3d-utils: Fix matrix packing precedence in D3DCompile2VKD3D(). + vkd3d-shader/hlsl: Use the casted value in exp(). + tests: Add some stress tests for scope and variable definition. + vkd3d-shader/hlsl: Do not define a separate scope for function parameters. + vkd3d-shader/hlsl: Factor out the error message into hlsl_add_var(). + vkd3d-shader/hlsl: Do not abort on variable redefinition. + vkd3d-shader/hlsl: Handle error instructions in add_shader_compilation(). + vkd3d-shader/hlsl: Add an add_switch() helper. + vkd3d-shader/hlsl: Handle error instructions in add_switch(). + vkd3d-shader/hlsl: Pass the block to add_zero_mipmap_level(). + vkd3d-shader/hlsl: Use a block in prepend_input_var_copy(). + vkd3d-shader/hlsl: Use a block in hlsl_normalize_binary_exprs(). -Atharva Nimbalkar (7): - vkd3d-shader/glsl: Implement VKD3DSIH_ADD. - vkd3d-shader/glsl: Implement support for VKD3DSPR_IMMCONST registers. - vkd3d-shader/glsl: Implement VKD3DSIH_AND. - vkd3d-shader/glsl: Implement support for VSIR_DIMENSION_VEC4 immediate constants. - vkd3d-shader/glsl: Implement VKD3DSIH_MOVC. - vkd3d-shader/glsl: Implement VKD3DSIH_ITOF. - vkd3d-shader/glsl: Implement VKD3DSIH_UTOF. +Feifan He (46): + vkd3d-shader/msl: Implement VKD3DSIH_ADD. + vkd3d-shader/msl: Implement support for VKD3DSPR_IMMCONST registers. + vkd3d-shader/msl: Implement support for VKD3DSPSM_ABS modifiers. + vkd3d-shader/msl: Implement VKD3DSIH_AND. + vkd3d-shader/msl: Implement VKD3DSIH_NEU. + vkd3d-shader/msl: Implement support for VSIR_DIMENSION_VEC4 immediate constants. + vkd3d-shader/msl: Implement VKD3DSIH_MUL. + vkd3d-shader/msl: Implement VKD3DSIH_INE. + vkd3d-shader/msl: Implement VKD3DSIH_OR. + vkd3d-shader/msl: Implement VKD3DSIH_DIV. + vkd3d-shader/msl: Implement support for VKD3DSPSM_NEG modifiers. + vkd3d-shader/msl: Implement VKD3DSIH_GEO. + vkd3d-shader/msl: Implement VKD3DSIH_FRC. + vkd3d-shader/msl: Implement VKD3DSIH_MOVC. + vkd3d-shader/msl: Implement VKD3DSIH_ITOF. + vkd3d-shader/msl: Implement VKD3DSIH_FTOI. + vkd3d-shader/msl: Implement VKD3DSIH_UTOF. + vkd3d-shader/msl: Implement VKD3DSIH_FTOU. + vkd3d-shader/msl: Implement VKD3DSIH_ROUND_PI. + vkd3d-shader/msl: Implement VKD3DSIH_ROUND_Z. + tests/shader_runner_metal: Implement depth texture and state. + tests/shader_runner_metal: Implement clears. + vkd3d-shader/msl: Implement support for the VKD3DSPR_DEPTHOUT register. + vkd3d-shader/msl: Implement VKD3DSIH_DP3. + vkd3d-shader/msl: Implement VKD3DSIH_DP4. + vkd3d-shader/msl: Implement VKD3DSIH_DP2. + vkd3d-shader/msl: Implement VKD3DSIH_SQRT. + vkd3d-shader/msl: Handle the VKD3DSIM_LINEAR interpolation modifier on inputs. + vkd3d-shader/msl: Implement VKD3DSIH_IEQ. + vkd3d-shader/msl: Implement VKD3DSIH_EXP. + vkd3d-shader/msl: Implement VKD3DSIH_LTO. + vkd3d-shader/msl: Implement VKD3DSIH_ROUND_NI. + vkd3d-shader/msl: Implement VKD3DSIH_IF and VKD3DSIH_ENDIF. + vkd3d-shader/msl: Implement VKD3DSIH_ROUND_NE. + vkd3d-shader/msl: Handle SV_IS_FRONT_FACE inputs. + vkd3d-shader/msl: Implement VKD3DSIH_LOG. + vkd3d-shader/msl: Implement VKD3DSIH_MAX. + vkd3d-shader/msl: Implement VKD3DSIH_MIN. + vkd3d-shader/msl: Implement VKD3DSIH_RSQ. + vkd3d-shader/msl: Implement VKD3DSIH_NOT. + vkd3d-shader/msl: Implement VKD3DSIH_ELSE. + vkd3d-shader/msl: Implement support for VKD3DSPDM_SATURATE modifiers. + vkd3d-shader/msl: Implement VKD3DSIH_MAD. + vkd3d-shader/msl: Implement VKD3DSIH_ISHL. + vkd3d-shader/msl: Implement VKD3DSIH_ISHR. + vkd3d-shader/msl: Implement VKD3DSIH_USHR. -Conor McCarthy (21): - vkd3d-shader/ir: Free the semantic names of deleted signature elements in shader_signature_merge(). (Valgrind) - tests/d3d12: Test a bounded range at the same offset as an unbounded one in test_unbounded_resource_arrays(). - vkd3d: Sort bounded descriptor ranges after unbounded ones of equal offset. - tests/d3d12: Test invalid bytecode in test_root_signature_byte_code(). - vkd3d: Clear the output pointer on failure in vkd3d_create_versioned_root_signature_deserializer(). - vkd3d-shader/dxil: Load forward-referenced comparands as value/type pairs in sm6_parser_emit_cmpxchg(). - vkd3d-shader/dxil: Load forward-referenced sources as value/type pairs in sm6_parser_emit_store(). - tests: Move the dxc compilation helpers to utils.h. - tests/shader_runner: Introduce struct vulkan_test_context for the Vulkan runner. - tests/shader-runner: Move struct vulkan_test_context to vulkan_utils.h. - tests/shader-runner: Move the Vulkan helper functions to vulkan_utils.h. - tests/d3d12: Test buffer and texture SRVs in test_unbounded_resource_arrays(). - vkd3d: Access the current range via the declared pointer in d3d12_root_signature_init_root_descriptor_tables(). - vkd3d: Introduce a separate structure for storing Vulkan descriptor binding arrays. - vkd3d: Create a separate Vulkan descriptor binding array for each descriptor set. - vkd3d: Lay out virtual descriptor heap buffer and image bindings consecutively instead of interleaving them. - vkd3d: Zero the pipeline state UAV counter view array when the state is invalidated. (Valgrind) - tests: Use state RESOLVE_SOURCE for readback from multisampled textures. - vkd3d: Check the IASetVertexBuffers() view count against the device limits. - vkd3d-shader/ir: Add a secondary sort by sysval for signature element register merges. - vkd3d-shader/dxil: Implement DX intrinsic SampleIndex. +Francisco Casas (55): + vkd3d-shader/tpf: Remove HLSL_IR_SWIZZLE handling. + vkd3d-shader/hlsl: Store SM4 stores in the vsir program. + vkd3d-shader/hlsl: Store SM4 loads in the vsir program. + vkd3d-shader/hlsl: Store SM4 resource stores in the vsir program. + tests: Test signature reflection for PRIMID, RTINDEX and VPINDEX. + vkd3d-shader/hlsl: Add special allocation rules for PRIMID, RTINDEX, and VPINDEX. + tests: Test allocation rules for FFACE and SAMPLE. + vkd3d-shader/hlsl: Add special allocation rules for FFACE and SAMPLE. + vkd3d-shader/hlsl: Store SM4 HLSL_RESOURCE_LOADs in the vsir program. + vkd3d-shader/hlsl: Store SM4 HLSL_RESOURCE_SAMPLEs in the vsir program. + vkd3d-shader/hlsl: Store SM4 HLSL_RESOURCE_GATHERs in the vsir program. + vkd3d-shader/hlsl: Store SM4 HLSL_RESOURCE_SAMPLE_INFOs in the vsir program. + vkd3d-shader/hlsl: Store SM4 HLSL_RESOURCE_RESINFOs in the vsir program. + vkd3d-shader/hlsl: Store SM4 jumps in the vsir program. + vkd3d-shader/tpf: Apply extra bits to all conditional ops. + vkd3d-shader/hlsl: Migrate SM4 control flow instructions to the vsir program. + vkd3d-shader/hlsl: Remove hlsl_ir_vsir_instruction_ref, again. + vkd3d-shader/dxbc: Parse the SFI0 ROV requirement. + vkd3d-shader/hlsl: Store ROV feature requirement in the vsir_program. + vkd3d-shader/hlsl: Store the global flags in the vsir program. + vkd3d-shader/hlsl: Store SM4 sampler declarations in the vsir program. + vkd3d-shader/hlsl: Store SM4 texture declarations in the vsir program. + tests: Add additional sampler allocation tests for SM1. + tests: Test sampler array allocation. + vkd3d-shader/hlsl: Lower separated samplers for SM1. + vkd3d-shader/hlsl: Support combined samplers from texture arrays. + vkd3d-shader/hlsl: Allocate samplers by decreasing bind count in SM1. + vkd3d-shader/hlsl: Allow lowering separate sampler arrays on deref offset 0. + vkd3d-shader/hlsl: Store SM4 constant buffer declarations in vsir program. + vkd3d-shader/hlsl: Generate RDEF outside tpf_compile(). + vkd3d-shader/hlsl: Generate CTAB outside sm1_generate_vsir(). + vkd3d-shader/hlsl: Store hull and domain shader properties in vsir_program. + vkd3d-shader/tpf: Remove hlsl_ctx from tpf_compiler. + vkd3d-shader/hlsl: Lower sample lods for SM1. + vkd3d-shader/ir: Properly lower texldb. + tests/hlsl: Test tex2Dproj(). + vkd3d-shader/ir: Properly lower texldp. + vkd3d-shader: Avoid passing NULL to memcpy(). (ubsan) + vkd3d-shader: Avoid passing NULL to qsort(). (ubsan) + vkd3d-shader: Avoid passing NULL to memset(). (ubsan) + vkd3d-shader: Avoid left shifting signed integers. (ubsan) + tests: Test SampleGrad() on ps_3_0. + vkd3d-shader/hlsl: Lower separate SampleGrad() for SM1. + vkd3d-shader/hlsl: Don't lower separate samples with texel offsets. + tests: Test casting negative floats to int. + vkd3d-shader/hlsl: Properly lower casts to int for negative numbers. + vkd3d-shader/hlsl: Specialize lowering SM1 casts to int for vertex shaders. + tests/hlsl: Add lhs cast tests. + tests/hlsl: Test partial assignments due to lhs casts. + tests/hlsl: Add more function cast tests. + vkd3d-shader/hlsl: Delay lowering complex casts until after parse time. + vkd3d-shader/hlsl: Support non-size-changing lhs casts. + vkd3d-shader/hlsl: Don't count cast to param type on IN as part of OUT var's lhs. + vkd3d-shader/hlsl: Don't forbid first base type cast on var assignments. + tests/shader_runner: Pass the correct buffer size to swprintf() in dxc_compiler_compile_shader(). -Elizabeth Figura (92): - vkd3d-utils: Add a D3DCompile2VKD3D() that allows configuring DLL version. - vkd3d-utils: Do not emit implicit truncation warnings from D3DCompile2VKD3D() before version 42. - build: Do not warn on incomplete documentation. - vkd3d-shader: Mention the structure name when referring to a struct field. - vkd3d-shader: Escape a hash in Doxygen documentation. - vkd3d-shader: Do not use \ref for parameters. - vkd3d-shader/hlsl: Use elementwise_intrinsic_float_convert_args() in write_atan_or_atan2(). - vkd3d-shader/hlsl: Use elementwise_intrinsic_convert_args() in intrinsic_dst(). - vkd3d-shader/hlsl: Use elementwise_intrinsic_float_convert_args() in intrinsic_faceforward(). - vkd3d-shader/hlsl: Use elementwise_intrinsic_float_convert_args() in intrinsic_smoothstep(). - vkd3d-shader/hlsl: Preserve halves in intrinsic_step(). - vkd3d-shader/hlsl: Use elementwise_intrinsic_float_convert_args() in refract(). - vkd3d-shader/hlsl: Use intrinsic_float_convert_arg() in write_acos_or_asin(). - vkd3d-shader/hlsl: Use expr_common_base_type() in intrinsic_cross(). - vkd3d-shader/hlsl: Preserve doubles in intrinsic_float_convert_arg(). - vkd3d-shader/hlsl: Preserve doubles in elementwise_intrinsic_float_convert_args(). - vkd3d-shader/hlsl: Preserve doubles in intrinsic_cross(). - vkd3d-shader/hlsl: Preserve doubles in intrinsic_determinant(). - vkd3d-shader/hlsl: Store a pointer to the block's "value" instruction in the block. - vkd3d-shader/hlsl: Return bool from add_assignment(). - vkd3d-shader/hlsl: Do not create a copy in add_assignment(). - vkd3d-shader/hlsl: Do not handle HLSL_CLASS_CONSTANT_BUFFER in copy_propagation_transform_load(). - vkd3d-shader/hlsl: Clarify a comment. - vkd3d-shader/hlsl: Introduce the "error" type. - vkd3d-shader/hlsl: Return an "error" expression when constructing an arithmetic expression from incompatible types. - vkd3d-shader/hlsl: Handle error expressions in unary expressions. - vkd3d-shader/hlsl: Use add_cast() in append_conditional_break(). - vkd3d-shader/hlsl: Fix a corner case in ternary type conversion. - vkd3d-shader/ir: Remove newlines from some vkd3d_shader_error() calls. - vkd3d-shader: Allow controlling clip planes through vkd3d-shader parameters. - tests: Test clip planes. - vkd3d-shader/hlsl: Free static initializers after functions. - vkd3d-shader/hlsl: Return an "error" expression when using an undeclared variable. - vkd3d-shader/hlsl: Handle error expressions in function calls. - vkd3d-shader/hlsl: Handle error expressions in binary expressions. - vkd3d-shader/hlsl: Handle error expressions in assignments. - vkd3d-shader/hlsl: Handle error expressions in method calls. - vkd3d-shader/preproc: Store argument values per expansion, not per macro. - vkd3d-shader/hlsl: Introduce an add_explicit_conversion() helper. - vkd3d-shader/hlsl: Handle error expressions in explicit casts. - vkd3d-shader/hlsl: Handle error expressions in array indexes. - vkd3d-shader/hlsl: Handle error expressions in subscripts. - vkd3d-shader/hlsl: Handle error expressions in increments. - vkd3d-shader/spirv: Always write the point size in vertex shaders. - tests: Add a test for shader point size output. - vkd3d-shader/spirv: Implement shader point size. - vkd3d-shader/ir: Allow controlling FFP point size through a vkd3d-shader parameter. - tests: Test FFP point size. - vkd3d-shader/ir: Allow controlling FFP point size clamping through vkd3d-shader parameters. - tests: Test FFP point size clamping. - vkd3d-shader/hlsl: Factor out an initialize_var() helper. - vkd3d-shader/hlsl: Store the initializer location in struct parse_initializer. - vkd3d-shader/hlsl: Factor the component count check into initialize_var(). - vkd3d-shader/hlsl: Handle error expressions in initializers. - vkd3d-shader/hlsl: Handle error expressions in ternary expressions. - vkd3d-shader/ir: Allow controlling point sprite through a parameter. - tests: Test point sprite. - vkd3d-shader: Factor out a vsir_parse() helper. - vkd3d-shader: Validate the parsed shader in vsir_parse(). - vkd3d-shader/hlsl: Handle error expressions in conditions. - vkd3d-shader/hlsl: Handle error expressions in return statements. - vkd3d-shader/hlsl: Handle error expressions in array sizes. - vkd3d-shader/hlsl: Return an error expression when an invalid subscript is used. - vkd3d-shader/hlsl: Avoid leaking the block in the subscript rule. - tests/shader_runner: Store shader caps using an array. - tests/shader_runner: Get rid of the "dxbc_ptr" parameter to create_shader_stage(). - tests/shader_runner: Store shader sources as an array. - tests/shader_runner: Store the dxc_compiler in the shader_runner. - tests/shader_runner: Centralize the compile_hlsl() helper in shader_runner.c. - tests/shader_runner: Split HLSL and SPIRV compilation in the Vulkan shader runner. - tests/shader_runner: Compile HLSL for all stages before compiling SPIRV. - tests/shader_runner: Build a varying map in the Vulkan runner. - tests: Add a test for sm1 inter-stage interface matching. - vkd3d: Initialize vk_extensions in vk_init_device_caps(). - vkd3d-shader/fx: Remove an unnecessary hlsl_is_numeric_type(). - vkd3d-shader: Make an assert into an explicit check. - vkd3d-shader/hlsl: Use early return in allocate_register(). - tests: Silence a bogus -Wmaybe-uninitialized. - tests: Add a test for uninitialized varyings. - vkd3d-shader: Always ensure a RET at the end of a program. - vkd3d-shader: Reduce masks to only read components in vsir_program_remap_output_signature(). - vkd3d-shader: Write uninitialized components of COLOR0 as 1. - vkd3d-shader: Write zeroes for uninitialized outputs in vsir_program_remap_output_signature(). - vkd3d-shader/fx: Fix checking for a GS with stream output. - tests: Add some tests for FOG and PSIZE writemask restrictions. - vkd3d-shader/hlsl: Enforce PSIZE component count for sm1 VS output. - vkd3d-shader/hlsl: Enforce FOG component count for sm1 VS output. - vkd3d-shader/ir: Force fog and point size to 1 component when normalizing I/O. - vkd3d-shader/hlsl: Write all writemask components for PSIZE and FOG outputs. - vkd3d-shader/ir: Add an is_pre_rasterization_shader() helper. - vkd3d-shader/hlsl: Silence a spurious -Wmaybe-uninitialized in sm4_generate_vsir_instr_dcl_semantic(). - vkd3d-shader: Silence a spurious -Wmaybe-uninitialized in vsir_program_insert_alpha_test(). +Giovanni Mascellani (87): + vkd3d-shader/ir: Validate the semantic index for tessellation system values. + vkd3d-shader/ir: Check that semantic indices for tessellation system values are not duplicated. + vkd3d-shader/ir: Keep track of the tessellator domain in struct vsir_program. + vkd3d-shader/ir: Validate tessellation system values for the given tessellator domain. + vkd3d-shader/ir: Check that tessellation system values only appear in the patch constant signature. + vkd3d-shader/ir: Validate index count for PRIMID registers. + vkd3d-shader/ir: Validate index count for OUTPOINTID registers. + vkd3d-shader/ir: Validate index count for FORKINSTID registers. + vkd3d-shader/ir: Validate index count for JOININSTID registers. + vkd3d-shader/ir: Validate index count for TESSCOORD registers. + vkd3d-shader/ir: Validate index count for THREADID registers. + vkd3d-shader/ir: Validate index count for THREADGROUPID registers. + vkd3d-shader/ir: Validate index count for LOCALTHREADID registers. + vkd3d-shader/ir: Validate index count for LOCALTHREADINDEX registers. + vkd3d-shader/ir: Check that all tessellation system values appear in the patch constant signature. + vkd3d-shader/ir: Check that tessellation system value registers are consecutive. + vkd3d-shader/ir: Validate index count for COVERAGE registers. + vkd3d-shader/ir: Validate index count for SAMPLEMASK registers. + vkd3d-shader/ir: Validate index count for GSINSTID registers. + vkd3d-shader/ir: Validate index count for WAVELANECOUNT registers. + vkd3d-shader/ir: Validate index count for WAVELANEINDEX registers. + vkd3d-shader/ir: Validate index count for OUTSTENCILREF registers. + vkd3d-shader/dxil: Emit register SAMPLEMASK for output sysval SV_Coverage. + vkd3d-shader/ir: Validate the register type for DCL_INPUT instructions. + vkd3d-shader/ir: Validate the register type for DCL_INPUT_SIV instructions. + vkd3d-shader/ir: Validate the register type for DCL_INPUT_SGV instructions. + vkd3d-shader/ir: Validate the register type for DCL_INPUT_PS instructions. + vkd3d-shader/ir: Validate the register type for DCL_INPUT_PS_SIV instructions. + vkd3d-shader/ir: Validate the register type for DCL_INPUT_PS_SGV instructions. + vkd3d-shader/ir: Validate the register type for DCL_OUTPUT instructions. + vkd3d-shader/ir: Validate the register type for DCL_OUTPUT_SIV instructions. + vkd3d-shader/ir: Synthesize the default control point phase in the HS control point I/O normaliser. + vkd3d-shader/ir: Evaluate OUTCONTROLPOINT usage in the patch constant phase directly. + tests: Use plain skip() when skipping a test in the shader runner. + tests: Print the file name instead of the test name in test logs. + vkd3d-shader/spirv: Merge emitting input and output registers. + vkd3d-shader/ir: Encode I/O declarations in vsir_program. + vkd3d-shader/ir: Remove I/O declarations before I/O normalisation. + vkd3d-shader/ir: Remove I/O declarations before normalising hull shader control point I/O. + vkd3d-shader/ir: Remove I/O declarations before flattening hull shader phases. + vkd3d-shader/ir: Merge removing I/O declarations in the general instruction lowering pass. + vkd3d-shader/ir: Validate the control point index when it is statically known. + vkd3d: Do not use more than a few million descriptors in Vulkan heap set layouts. + vkd3d-shader/ir: Validate the array index when it is statically known. + vkd3d-shader/ir: Validate the register type for registers used as relative addresses. + vkd3d-shader/ir: Introduce a helper function to determine the signature for a register type. + vkd3d-shader/ir: Validate the DCL_INDEX_RANGE instruction. + vkd3d-shader/ir: Check that DCL_INDEX_RANGE ranges do not overlap with unrelated signature elements. + vkd3d-shader/spirv: Introduce a SPIR-V parser. + vkd3d-shader/spirv: Parse the SPIR-V magic number. + vkd3d-shader/spirv: Parse the SPIR-V version number. + vkd3d-shader/spirv: Parse the SPIR-V generator magic number. + vkd3d-shader/spirv: Parse the SPIR-V id bound. + vkd3d-shader/spirv: Parse the SPIR-V instruction schema. + vkd3d-shader/ir: Check that the DCL_INDEX_RANGE effective mask stabilizes after one iteration. + vkd3d-shader/ir: Check that signature element masks are left-aligned with in a DCL_INDEX_RANGE. + vkd3d-shader/ir: Validate the register index and count for signature elements. + vkd3d-shader/ir: Validate the signature element stream index. + vkd3d-shader/ir: Validate the signature element register index, for some sysvals. + vkd3d-shader/ir: Check that signature elements do not conflict with each other. + vkd3d-shader/ir: Give more meaningful names to I/O normalisation levels. + vkd3d-shader/d3dbc: Normalise I/O register write masks when not disassembling. + vkd3d-shader/ir: Represent information about I/O registers with a table. + vkd3d-shader/ir: Validate INPUT destination parameters using a uniform helper. + vkd3d-shader/ir: Validate PATCHCONST destination parameters using a uniform helper. + vkd3d-shader/ir: Validate OUTPUT destination parameters. + vkd3d-shader/ir: Validate INCONTROLPOINT destination parameters. + vkd3d-shader/ir: Validate OUTCONTROLPOINT destination parameters. + vkd3d-shader/ir: Remove a redundant assignment. + vkd3d-shader/ir: Simplify shader_register_normalise_arrayed_addressing(). + tests/hlsl: Add tests for the EvaluateAttribute*() intrinsics. + tests/hlsl: Add some clip/cull distance tests. + vkd3d-shader/ir: Disallow array signature elements for normalisation levels < SM6. + vkd3d-shader/ir: Validate OUTPUT source parameters using a uniform helper. + vkd3d-shader/ir: Validate PATCHCONST source parameters using a uniform helper. + vkd3d-shader/ir: Validate INPUT source parameters. + vkd3d-shader/ir: Validate INCONTROLPOINT source parameters. + vkd3d-shader/ir: Validate OUTCONTROLPOINT source parameters. + vkd3d: Log the requested feature levels for D3D12_FEATURE_FEATURE_LEVELS. + vkd3d: Describe DXGI_UNKNOWN as having one plane. + vkd3d: Only call d3d12_fence_garbage_collect_vk_semaphores_locked() when using binary semaphores. + vkd3d: Release queued fences when stopping the fence worker. + vkd3d: Support signalling a fence once all outstanding work is submitted to Vulkan. + vkd3d: Explicitly call the appropriate waiting function in the fence worker. + vkd3d-shader/spirv: Interpret the write mask as a destination swizzle for double comparison operations. + vkd3d-common: Write a thread id in the log on macOS too. + ci: Explicitly install SPIRV-Tools in the macOS CI environment. -Evan Tang (4): - vkd3d-shader/ir: Remove an unnecessary typecast in shader_instruction_eliminate_phase_instance_id(). - vkd3d-shader/ir: Don't shift register write masks by the component index in shader_dst_param_io_normalise(). - tests: Add a test for shader interstage register packing. - tests: Add a test for writing patch constants during tessellation. +Henri Verbeet (31): + tests: Get rid of some redundant "glsl" todo's. + vkd3d-shader/hlsl: Use hlsl_error() instead of hlsl_fixme() for ambiguous function calls. + vkd3d-shader/hlsl: Introduce hlsl_dump_type(). + vkd3d-shader/hlsl: Introduce hlsl_dump_ir_function_decl(). + vkd3d-shader/hlsl: Output the candidates for ambiguous function calls. + vkd3d: Introduce d3d12_descriptor_set_layout_init(). + vkd3d-shader/spirv: Parse SPIR-V instructions. + vkd3d: Drop smaller pools in d3d12_command_allocator_reset_descriptor_pool_array(). + tests: Add yet more overload resolution tests. + vkd3d-shader/hlsl: Prefer overload candidates without component count narrowing. + vkd3d-shader/hlsl: Prefer overload candidates with matching component type classes. + vkd3d-shader/hlsl: Prefer overload candidates with matching component types. + vkd3d-shader/hlsl: Prefer overload candidates without component type narrowing. + vkd3d-shader/hlsl: Prefer overload candidates without component count widening. + vkd3d-shader/d3dbc: Separate writing the comment bytecode from write_sm1_uniforms(). + vkd3d-shader/hlsl: Move CTAB generation to hlsl_codegen.c. + tests/shader_runner: Ignore the "backcompat" option for shader model 5.1+. + vkd3d-shader/hlsl: Make sm4_get_interpolation_mode() static. + vkd3d-shader/hlsl: Move sm4_get_extern_resources() to hlsl_codegen.c. + vkd3d-shader/hlsl: Move sm4_free_extern_resources() to hlsl_codegen.c. + tests/shader_runner: Do not use skip() for shader model requirements. + vkd3d-shader/hlsl: Move RDEF generation to hlsl_codegen.c. + demos: Use the assembler to embed HLSL sources. + vkd3d-shader/msl: Get rid of a stray vkd3d_string_buffer_printf() in the VEC4 UINT immediate constant handling. + vkd3d: Avoid freeing the input signature twice on error paths in d3d12_pipeline_state_init_graphics(). + vkd3d-compiler: Store the target type as a struct target_type_info pointer. + vkd3d-compiler: Store the source type as a struct source_type_info pointer. + vkd3d-compiler: Introduce "dxbc-fx" as a source type. + include: Add vkd3d_shader_scan_hull_shader_tessellation_info to the list of chained compilation structures. + include: Add missing VKD3D_FORCE_32_BIT_ENUM enum elements. + vkd3d-shader/ir: Remove vForkInstanceId and vJoinInstanceId declarations in vsir_program_flatten_hull_shader_phases(). -Feifan He (30): - vkd3d-shader: Introduce VKD3D_SHADER_TARGET_MSL. - vkd3d-shader/msl: Generate comments for unhandled instructions. - vkd3d-shader/msl: Call vsir_program_transform() before generating code. - vkd3d-shader/msl: Keep track of the current indentation level - vkd3d-shader/msl: Add vkd3d-shader version information to the generated shader. - vkd3d-shader/msl: Implement VKD3DSIH_NOP. - vkd3d-shader/msl: Implement VKD3DSIH_MOV. - vkd3d-shader/msl: Implement VKD3DSIH_RET. - vkd3d-shader/msl: Implement support for VKD3DSPR_TEMP registers. - vkd3d-shader/msl: Generate shader output structure declarations. - vkd3d-shader/msl: Generate shader input structure declarations. - vkd3d-shader/msl: Generate the shader entry point. - vkd3d-shader/msl: Generate the shader entry point epilogue. - vkd3d-shader/msl: Generate the shader entry point prologue. - vkd3d-shader/msl: Handle signature element masks in the prologue and epilogue. - vkd3d-shader/msl: Generate shader descriptor structure declarations. - vkd3d-shader/msl: Implement support for VKD3DSPR_CONSTBUFFER registers. - vkd3d-shader/msl: Implement support for VKD3DSPR_INPUT registers. - vkd3d-shader/msl: Implement support for VKD3DSPR_OUTPUT registers. - tests/shader_runner: Introduce a Metal shader runner. - vkd3d-shader/msl: Add the missing output register index in msl_generate_entrypoint_epilogue(). - vkd3d-shader/msl: Use pointers for constant buffer descriptors. - tests/shader_runner_metal: Implement graphics shader compilation. - vkd3d-shader/msl: Output the generated shader code. - tests/shader_runner_metal: Create vertex descriptors. - tests/shader_runner_metal: Create Metal render targets. - tests/shader_runner_metal: Create Metal vertex buffers. - tests/shader_runner_metal: Implement render target readback. - tests/shader_runner_metal: Create Metal constant buffers. - tests/shader_runner_metal: Implement draws. +Nikolay Sivov (5): + vkd3d-shader/hlsl: Add parser support for stream-output object types. + vkd3d-shader/fx: Implement parsing inline shader blobs. + vkd3d-shader/fx: Remove newlines from the parser error messages. + vkd3d-compiler: Support fx_4_0 sources embedded in DXBC containers. + vkd3d-shader/hlsl: Implement the isinf() intrinsic. -Francisco Casas (77): - vkd3d-shader/hlsl: Introduce hlsl_ir_vsir_instruction_ref. - vkd3d-shader/hlsl: Store SM1 constant dcls on the vsir_program. - vkd3d-shader/hlsl: Store SM1 sampler dcls on the vsir_program. - vkd3d-shader/hlsl: Save hlsl_ir_constants in the vsir_program for SM1. - vkd3d-shader/hlsl: Save hlsl_ir_loads in the vsir_program for SM1. - vkd3d-shader/hlsl: Save hlsl_ir_stores in the vsir_program for SM1. - vkd3d-shader/hlsl: Save hlsl_ir_swizzles in the vsir_program for SM1. - vkd3d-shader/hlsl: Parse the shader 'compile' syntax. - vkd3d-shader/hlsl: Parse the CompileShader() syntax. - vkd3d-shader/hlsl: Save simple hlsl_ir_exprs in the vsir_program for SM1. - vkd3d-shader/hlsl: Save per-component hlsl_ir_exprs in the vsir_program for SM1. - vkd3d-shader/hlsl: Save DOT hlsl_ir_exprs in the vsir_program for SM1. - vkd3d-shader/hlsl: Save COS_REDUCED and SIN_REDUCED in the vsir_program for SM1. - vkd3d-shader/hlsl: Save DP2ADD hlsl_ir_exprs in the vsir_program for SM1. - vkd3d-shader/hlsl: Save REINTERPRET hlsl_ir_exprs as vsir_program MOVs for SM1. - vkd3d-shader/hlsl: Save CAST hlsl_ir_exprs in the vsir_program for SM1. - vkd3d-shader/hlsl: Save hlsl_ir_resource_load in the vsir_program for SM1. - vkd3d-shader/hlsl: Save hlsl_ir_jump in the vsir_program for SM1. - vkd3d-shader/hlsl: Introduce enum hlsl_compile_type. - tests: Test ConstructGSWithSO() parsing. - vkd3d-shader/hlsl: Process GeometryShader as a valid stateblock lhs. - vkd3d-shader/hlsl: Parse ConstructGSWithSO(). - vkd3d-shader/hlsl: Allow effect calls on default value initializers. - vkd3d-shader/hlsl: Save hlsl_ir_if in the vsir_program for SM1. - vkd3d-shader/hlsl: Remove hlsl_ir_vsir_instruction_ref. - vkd3d-shader/d3dbc: Remove ctx and entry_func args in d3dbc_compile(). - tests/shader_runner: Skip the GLSL tests when GLSL support is not enabled. - tests/shader_runner: Skip the DXIL tests when DXIL support is not enabled. - tests/shader_runner: Use skip() when the d3d12 device doesn't support shader model 6. - tests/shader_runner: Query for GLSL target support instead of checking VKD3D_SHADER_UNSUPPORTED_GLSL. - tests/shader-runner: Query for SM6 support instead of checking VKD3D_SHADER_UNSUPPORTED_DXIL. - tests: Test sampler_state keyword syntax. - vkd3d-shader/hlsl: Process 'texture' as a valid stateblock lhs. - vkd3d-shader/hlsl: Parse sampler_state. - vkd3d-shader/hlsl: Fix the conditions to discard default values. - vkd3d-shader/tpf: Write sysval semantic consistently. - vkd3d-shader/tpf: Use dcl_input_ps_sgv for sv_isfrontface. - tests: Test interstage signature optimizations. - tests: Test interstage signature with arrays. - vkd3d-shader/d3dbc: Remove the "hlsl_" prefix from external functions. - vkd3d-shader/hlsl: Split hlsl_sm4_write(). - vkd3d-shader/tpf: Rename "tpf_writer" to "tpf_compiler". - vkd3d-shader/tpf: Pass a tpf_compiler structure to tpf_compile() callees. - vkd3d-shader/tpf: Use the I/O signatures from the vsir program in tpf_write_signature(). - vkd3d-shader/tpf: Replace uses of ctx->profile with tpf->program->shader_version. - vkd3d-shader/tpf: Make sysval_semantic_from_hlsl() independent of HLSL IR. - vkd3d-shader/tpf: Make hlsl_sm4_register_from_semantic() independent of HLSL IR. - tests: Add signature reflection test with structs. - vkd3d-shader/hlsl: Add mode field to register_allocator allocations. - vkd3d-shader/hlsl: Use a register_allocator to allocate semantic registers. - vkd3d-shader/hlsl: Also pass field storage modifiers to output signature elements. - vkd3d-shader/hlsl: Allow accounting for interpolation mode when allocating semantics. - vkd3d-shader/hlsl: Allow to force alignment on some semantic vars. - vkd3d-shader/hlsl: Allow prioritizing smaller writemasks when allocating signature elements. - vkd3d-shader/hlsl: Optimize interstage signatures. - vkd3d-shader/hlsl: Sort signature elements by register id. - vkd3d-shader/hlsl: Store the thread group size in the vsir program. - vkd3d-shader/hlsl: Introduce hlsl_ir_vsir_instruction_ref, again. - vkd3d-shader/hlsl: Store temp declarations in the vsir program. - vkd3d-shader/hlsl: Make allocation functions static again. - vkd3d-shader/tpf: Use instr.extra_bits for IF. - vkd3d-shader/hlsl: Store SM4 swizzles in the vsir program. - vkd3d-shader/hlsl: Introduce vsir_src_from_hlsl_node(). - vkd3d-shader/hlsl: Store SM4 ABS instructions in the vsir program. - vkd3d-shader/hlsl: Run sm4_generate_vsir_block() recursively. - vkd3d-shader/tpf: Remove HLSL IR ABS handling. - vkd3d-shader/hlsl: Store simple SM4 expressions in the vsir program. - vkd3d-shader/hlsl: Store RASTERIZER_SAMPLE_COUNT in the vsir program. - vkd3d-shader/tpf: Use SCALAR swizzle dimension for RASTERIZER registers. - vkd3d-shader/hlsl: Store SM4 casts in the vsir program. - vkd3d-shader/hlsl: Store SM4 SIN and COS in the vsir program. - vkd3d-shader/hlsl: Store SM4 RCP in the vsir program. - vkd3d-shader/hlsl: Store SM4 SAT in the vsir program. - vkd3d-shader/hlsl: Store SM4 MUL in the vsir program. - vkd3d-shader/hlsl: Store SM4 DIV in the vsir program. - vkd3d-shader/hlsl: Store SM4 DOT in the vsir program. - vkd3d-shader/hlsl: Store SM4 MOD in the vsir program. +Shaun Ren (43): + vkd3d-shader/dxil: Allow zero domain input control point count. + vkd3d-shader: Implement scanning hull shader tessellation information. + tests/shader_runner_vulkan: Enable patch list topology support. + tests/shader_runner_gl: Implement tessellation support. + vkd3d-shader/hlsl: Implement normalization of binary expressions. + vkd3d-shader/hlsl: Collect together terms with constant coefficients. + tests/shader_runner_vulkan: Check if create_shader_stage() fails in create_compute_pipeline(). + tests/shader_runner_gl: Add "opengl" tag. + tests/shader_runner_gl: Bind buffer UAVs for compute shaders. + tests/hlsl: Add a test for UAV InterlockedCompareExchange(). + tests/hlsl: Add tests to check the types of the value arguments of atomic ops. + tests/hlsl: Add tests to check the void return type of atomic ops. + tests/hlsl: Add tests for valid destination types of atomic operations. + vkd3d-shader/hlsl: Implement the InterlockedAdd() intrinsic. + vkd3d-shader/hlsl: Implement the InterlockedAnd() intrinsic. + vkd3d-shader/hlsl: Implement the InterlockedCompareExchange() intrinsic. + vkd3d-shader/hlsl: Implement the InterlockedCompareStore() intrinsic. + vkd3d-shader/hlsl: Implement the InterlockedExchange() intrinsic. + vkd3d-shader/hlsl: Implement the InterlockedMax() intrinsic. + vkd3d-shader/hlsl: Implement the InterlockedMin() intrinsic. + vkd3d-shader/hlsl: Implement the InterlockedOr() intrinsic. + vkd3d-shader/hlsl: Implement the InterlockedXor() intrinsic. + vkd3d-shader/spirv: Emit the tessellator domain for domain shaders. + vkd3d-shader/hlsl: Forbid declaring parameters as both out and const. + tests: Test invalid out const parameters. + vkd3d-shader/d3d-asm: Print vocp registers with subscript. + vkd3d-shader/hlsl: Forbid declaring const variables with no initializer. + tests/hlsl: Test invalid const variables with no initializer. + vkd3d-shader/hlsl: Parse InputPatch and OutputPatch objects. + vkd3d-shader/hlsl: Validate and record InputPatch/OutputPatch types. + tests/hlsl: Test the syntax of InputPatch/OutputPatch variables. + tests/hlsl: Test passthrough hull shader control point function. + tests/hlsl: Test hull shader control point function output parameters. + tests/hlsl: Test OutputPatch usage in patch constant functions. + vkd3d-shader/hlsl: Add an "is_patch_constant_func" field to struct hlsl_ctx. + vkd3d-shader/hlsl: Implement input semantic variable copies for patch variables. + vkd3d-shader/tpf: Improve readability of compat mapping in sm4_sysval_semantic_from_semantic_name(). + vkd3d-shader/hlsl: Generate vsir signature entries for patch variables. + vkd3d-shader/hlsl: Declare semantics for patch variables in vsir. + vkd3d-shader/hlsl: Allocate semantic registers for patch variables. + tests/shader_runner: Support the negation of tag matches. + vkd3d-shader/hlsl: Generate vsir registers from patch variable derefs. + tests: Test signature reflection for patch inputs in hull/domain shaders. -Giovanni Mascellani (203): - vkd3d-shader: Use a hash to build the filename when dumping shaders. - vkd3d-shader: Dump the converted shader too. - vkd3d-shader/ir: Emit a warning instead of an error on validation failures. - vkd3d-shader/ir: Do not decide the control flow type on NOPs. - vkd3d-shader/ir: Run validation after lowering instructions. - vkd3d-shader/ir: Run validation after materializing PHI SSAs to TEMPs. - vkd3d-shader/ir: Run validation after lowering switches to selection ladders. - vkd3d-shader/ir: Run validation after structurization. - vkd3d-shader/ir: Run validation after flattening control flow constructs. - vkd3d-shader/ir: Run validation after materializing undominated SSAs to TEMPs. - vkd3d-shader/ir: Assume that Hull Shaders have a control point phase in vsir_program_normalise_io_registers(). - vkd3d-shader/ir: Run validation after remapping the output signature. - vkd3d-shader/ir: Run validation after flattening hull shader phases. - vkd3d-shader/ir: Run validation after normalising Hull Shader control points I/O registers. - vkd3d-shader/ir: Run validation after normalising I/O registers. - vkd3d-shader/ir: Run validation after normalising flat constants. - vkd3d: Directly call the function to update descriptors. - vkd3d: Do not keep track of descriptor heaps when using virtual heaps. - vkd3d-shader/ir: Run validation after removing dead code. - vkd3d-shader/ir: Run validation after normalising combined samplers. - vkd3d-shader/ir: Run validation after flattening control flow constructs. - vkd3d-shader/ir: Run validation after inserting the alpha test. - vkd3d-shader/ir: Rename vsir_program_normalise() to vsir_program_transform(). - vkd3d-shader/ir: Print results as signed numbers. - vkd3d-shader/ir: Move the control flow type enumeration to vkd3d_shader_private.h. - vkd3d-shader/ir: Record the control flow type in the program. - vkd3d-shader/ir: Introduce a helper for validating DCL_TEMPS. - vkd3d-shader/ir: Introduce a helper for validating IF. - vkd3d-shader/ir: Introduce a helper for validating IFC. - vkd3d-shader/ir: Introduce a helper for validating ELSE. - vkd3d-shader/ir: Introduce a helper for validating ENDIF. - vkd3d-shader/ir: Introduce a helper for validating LOOP. - vkd3d-shader/ir: Introduce a helper for validating ENDLOOP. - vkd3d-shader/ir: Introduce a helper for validating REP. - vkd3d-shader/ir: Introduce a helper for validating ENDREP. - vkd3d-shader/ir: Introduce a helper for validating SWITCH. - vkd3d-shader/ir: Introduce a helper for validating ENDSWITCH. - vkd3d-shader/ir: Introduce a helper for validating RET. - vkd3d-shader/ir: Introduce a helper for validating LABEL. - vkd3d-shader/ir: Introduce a helper for validating BRANCH. - vkd3d-shader/ir: Introduce a helper for validating SWITCH_MONOLITHIC. - vkd3d-shader/ir: Introduce a helper for validating PHI. - vkd3d-shader/ir: Do not access a missing destination register when validating PHI. - vkd3d-shader/ir: Validate NOP instructions. - vkd3d-shader/ir: Record leaving a block in the relevant validation handlers. - vkd3d-shader/ir: Record entering a block in the LABEL validation handler. - vkd3d-shader/ir: Introduce a helper for validating DCL_HS_MAX_TESSFACTOR. - vkd3d-shader/ir: Introduce a helper for validating DCL_INPUT_PRIMITIVE. - vkd3d-shader/ir: Introduce a helper for validating DCL_VERTICES_OUT. - vkd3d-shader/ir: Introduce a helper for validating DCL_OUTPUT_TOPOLOGY. - vkd3d-shader/ir: Introduce a helper for validating DCL_GL_INSTANCES. - vkd3d-shader/ir: Introduce a helper for validating DCL_OUTPUT_CONTROL_POINT_COUNT. - vkd3d-shader/ir: Introduce a helper for validating DCL_TESSELLATOR_DOMAIN. - vkd3d-shader/ir: Introduce a helper for validating DCL_TESSELLATOR_OUTPUT_PRIMITIVE. - vkd3d-shader/ir: Introduce a helper for validating DCL_TESSELLATOR_PARTITIONING. - vkd3d-shader/ir: Introduce a helper for validating Hull Shader phases. - vkd3d-shader/ir: Allow failure in shader_signature_find_element_for_reg(). - vkd3d-shader/spirv: Propagate errors from vkd3d_spirv_stream_append(). - vkd3d-shader/spirv: Do not reallocate the SPIR-V program. - vkd3d-shader/spirv: Rewrite vkd3d_spirv_get_type_id_for_data_type() in terms of vkd3d_spirv_get_type_id(). - vkd3d-shader/spirv: Cache numeric types without through the general declaration cache. - vkd3d-shader/spirv: Do not specify depth for SPIR-V images. - vkd3d-shader/dxil: Release memory on exceptional paths in sm6_parser_read_signature(). (Valgrind) - vkd3d-shader/dxil: Release memory on exceptional paths when parsing DXIL code. (Valgrind) - vkd3d-shader: Get rid of the SAMPLER data type. - vkd3d-shader: Get rid of the UAV data type. - vkd3d-shader: Get rid of the RESOURCE data type. - vkd3d-shader/ir: Do not allow NULL registers in source parameters. - vkd3d-shader/ir: Disallow SAMPLER registers in destination parameters. - vkd3d-shader/ir: Disallow RESOURCE registers in destination parameters. - vkd3d-shader/dxil: Emit RESOURCE and UAV registers with data type UNUSED. - vkd3d-shader/ir: Validate SAMPLER registers. - vkd3d-shader/ir: Validate RESOURCE registers. - vkd3d-shader/ir: Validate UAV registers. - vkd3d-shader/d3d-asm: Dump all indices when tracing VSIR code. - vkd3d-shader/tpf: Propagate validation errors after parsing. - vkd3d-shader/d3dbc: Trace the program when validation fails after parsing. - vkd3d-shader/dxil: Trace the program when validation fails after parsing. - vkd3d-shader/d3dbc: Do not emit indices for DEPTHOUT registers. - vkd3d-shader/ir: Validate index count for DEPTHOUT registers. - vkd3d-shader/ir: Validate index count for DEPTHOUTGE registers. - vkd3d-shader/ir: Validate index count for DEPTHOUTLE registers. - vkd3d-shader/ir: Validate index count for RASTOUT registers. - vkd3d-shader/ir: Validate index count for MISCTYPE registers. - readme: Move the "Developing vkd3d" section upwards. - readme: Document some preprocessor definitions used by vkd3d. - vkd3d-shader/spirv: Handle all possible destination modifiers. - vkd3d-shader/dxil: Emit SAMPLER, UAV and RESOURCE registers with only 2 indices. - vkd3d-shader/ir: Validate indices for SAMPLER registers. - vkd3d-shader/ir: Validate indices for RESOURCE registers. - vkd3d-shader/ir: Validate indices for UAV registers. - tests/shader-runner: Print the WARP driver version. - vkd3d-shader/dxil: Emit double arithmetic operations when appropriate. - vkd3d-shader/d3d-asm: Rename vkd3d_shader_trace() to vsir_program_trace(). - vkd3d-shader/d3d-asm: Rename dump_signature() to dump_dxbc_signature(). - vkd3d-shader/d3d-asm: Rename dump_signatures() to dump_dxbc_signatures(). - vkd3d-shader/d3d-asm: Dump signatures when tracing a VSIR program. - vkd3d-shader/ir: Set the signature sort indices in shader_signature_merge(). - vkd3d-shader: Ignore the patch constant signature when it doesn't make sense. - vkd3d-shader/ir: Allow a patch constant signature only for Hull and Domain Shaders. - vkd3d-shader/ir: Validate register counts in input signatures. - vkd3d-shader/ir: Validate register counts in output signatures. - vkd3d-shader/ir: Validate register counts in patch constant signatures. - vkd3d-shader/ir: Validate masks in shader signatures. - vkd3d-shader/spirv: Write spirv_compiler_emit_variable() in terms of spirv_compiler_emit_array_variable(). - tests: Only destroy the device if the context has one in vulkan_test_context_destroy(). - vkd3d-shader/ir: Do not emit an instruction number before starting validating instructions. - vkd3d-shader/ir: Validate usage masks in shader signatures. - vkd3d-shader/ir: Validate system value semantics in shader signatures. - vkd3d-shader/ir: Validate component types in shader signatures. - vkd3d-shader/ir: Validate minimum precision in shader signatures. - vkd3d-shader/ir: Validate interpolation mode in shader signatures. - vkd3d-shader/ir: Validate that constant interpolation is used with integer types. - vkd3d-shader/ir: Do not search for signature elements using a scalar write mask. - vkd3d-shader/ir: Disallow INPUT registers in destination parameters. - vkd3d-shader/ir: Disallow OUTPUT registers in source parameters. - vkd3d-shader/ir: Only allow PATCHCONST registers as source parameteres in Hull and Domain Shaders. - vkd3d-shader/ir: Only allow PATCHCONST registers as destination parameteres in Hull Shaders. - vkd3d-shader/ir: Introduce a helper for validating TEMP registers. - vkd3d-shader/ir: Introduce a helper for validating SSA registers. - vkd3d-shader/ir: Introduce a helper for validating LABEL registers. - vkd3d-shader/ir: Introduce a helper for validating registers without indices. - vkd3d-shader/ir: Introduce a helper for validating SAMPLER registers. - vkd3d-shader/ir: Introduce a helper for validating RESOURCE registers. - vkd3d-shader/ir: Introduce a helper for validating UAV registers. - vkd3d-shader/ir: Introduce a helper for validating RASTOUT registers. - vkd3d-shader/ir: Introduce a helper for validating MISCTYPE registers. - vkd3d-shader/ir: Validate the allowed signatures and stages for SV_Position. - vkd3d-shader/ir: Validate the allowed data type and component count for SV_Position. - vkd3d-shader/ir: Validate the allowed signatures and stages for SV_ClipDistance. - vkd3d-shader/ir: Validate the allowed data type and component count for SV_ClipDistance. - vkd3d-shader/ir: Validate the allowed signatures and stages for SV_CullDistance. - vkd3d-shader/ir: Validate the allowed data type and component count for SV_CullDistance. - vkd3d-shader/ir: Validate the input control point count. - vkd3d-shader/ir: Validate the output control point count. - vkd3d-shader/ir: Validate that signatures are sensible for shader type. - tests/shader-runner: Make geometry shaders optional. - vkd3d-shader/ir: Validate SV_TessFactor signature elements for quad domains. - vkd3d-shader/ir: Validate SV_InsideTessFactor signature elements for quad domains. - vkd3d-shader/ir: Validate SV_TessFactor signature elements for tri domains. - vkd3d-shader/ir: Validate SV_InsideTessFactor signature elements for tri domains. - vkd3d-shader/ir: Validate the line detail SV_TessFactor signature element for isolines domains. - vkd3d-shader/ir: Validate the line density SV_TessFactor signature element for isolines domains. - ci: Use the macOS image from the master vkd3d repository. - vkd3d: Introduce a helper function to add bindings to struct vk_binding_array. - vkd3d: Use vk_binding_array_add_binding() in d3d12_root_signature_init_static_samplers(). - vkd3d: Use vk_binding_array_add_binding() in d3d12_root_signature_init_root_descriptors(). - vkd3d: Create Vulkan bindings in d3d12_root_signature_append_vk_binding(). - vkd3d-shader/d3dbc: Make signature masks contiguous. - vkd3d-shader/ir: Check that signature masks are contiguous. - tests: Test discontiguous signature masks with SM<4 shaders. - ci: Remove the tart username and password environment variables. - ci: Use widl from the mingw-w64 brew package on macOS. - ci: Stop building widl for the macOS image. - ci: Build the DirectX shader compiler for macOS. - ci: Test DXIL shaders on macOS. - vkd3d-shader: Keep track of whether programs have normalised I/O. - vkd3d-shader: Keep track of whether programs have normalised hull shader control point I/O. - vkd3d-shader/ir: Validate INPUT registers. - vkd3d-shader/ir: Validate OUTPUT registers. - vkd3d-shader/ir: Validate PATCHCONST registers. - vkd3d-shader/ir: Validate INCONTROLPOINT registers. - vkd3d-shader/ir: Validate OUTCONTROLPOINT registers. - vkd3d: Allow overriding the device capabilities. - tests: Mark a sampling test as buggy on llvmpipe. - tests: Mark creating an 8x MSAA render target as buggy on llvmpipe. - tests: Mark latching the predicated value as todo on llvmpipe. - vkd3d-shader/ir: Represent the normalisation level with an enumeration. - vkd3d/device: Trace which descriptor heap implementation is being used. - vkd3d: Disable push descriptors when that's helpful to stay within 8 descriptor sets. - tests: Compute the correct value for condition conjunctions. - tests: Use appropriate RTV formats in max-min.shader_test. - tests: Use the appropriate RTV format in minimum-precision.shader_test. - tests: Mark interface packing pipeline creation as todo on MoltenVK. - ci: Build DXC for release. - tests: Test mismatching RTV and pixel shader output types. - vkd3d: Introduce an enumerant for the mutable descriptor set. - vkd3d: Move descriptor sets backing the SRV-UAV-CBV heap at the end. - vkd3d: Only put the mutable descriptor set once in the pipeline layout. - vkd3d: Incorporate mutable descriptors in the push descriptor disabling logic. - vkd3d-shader: Do not dump the target shader if compilation failed. - vkd3d-shader: Warn instead of erroring out when failing to dump a shader. - tests: Consider LOD miscalculation a todo rather than a driver bug. - tests: Use the appropriate RTV format in bitwise.shader_test. - tests: Dispatch just four invocations when testing for wave reconvergence. - tests: Mark geometry.shader_test as todo on MoltenVK. - tests: Mark tessellation.shader_test as todo on MoltenVK. - ci: Update the DXC version used on the CI to 1.8.2407. - tests: Mark tessellation-patch-vars.shader_test as todo on MoltenVK. - ci: Error out on Objective-C warnings. - tests: Mark fog.shader_test as todo with MSL. - tests: Use the appropriate RTV format in f32tof16.shader_test. - tests: Mark some tests in wave-reconvergence.shader_test as buggy on MoltenVK. - tests: Work around a Metal bug in switch.shader_test. - tests: Mark a couple of tests in register-reservations-numeric.shader_test as todo with MSL. - tests/shader_runner_vulkan: Avoid using ok() for shader compilation failues in create_graphics_pipeline(). - tests: Remove some todo markings on MoltenVK in interface-packing.shader_test. - vkd3d-shader/spirv: Get rid of the "offset_component_count" field of struct vkd3d_spirv_resource_type. - tests: Mark a conditional rendering test as buggy on llvmpipe. - ci: Update Mesa to version 24.2.4. - vkd3d: Use WARN rather than ERR in vkd3d_instance_init(). - vkd3d-shader/ir: Move applying flat interpolation to a dedicated pass. - vkd3d-shader/ir: Return an error when the FLAT_INTERPOLATION parameter is invalid. - -Henri Verbeet (130): - vkd3d-shader/tpf: Return a vkd3d_shader_sysval_semantic from hlsl_sm4_usage_from_semantic(). - vkd3d-shader/d3dbc: Return a vkd3d_decl_usage from hlsl_sm1_usage_from_semantic(). - vkd3d-shader/tpf: Use enum vkd3d_shader_component_type in write_sm4_signature(). - vkd3d-shader/tpf: Use enum vkd3d_sm4_data_type in sm4_resource_format(). - vkd3d-shader/d3dbc: Store a enum vkd3d_sm1_opcode in struct sm1_instruction. - vkd3d-shader/d3dbc: Use VKD3D_SM1_INSTRUCTION_LENGTH_SHIFT instead of D3DSI_INSTLENGTH_SHIFT. - vkd3d-shader/d3dbc: Avoid D3DVS_VERSION and D3DPS_VERSION. - vkd3d-shader/d3dbc: Use VKD3D_SM1_REGISTER_TYPE_SHIFT and related constants in sm1_encode_register_type(). - vkd3d-shader/d3dbc: Use enum vkd3d_shader_dst_modifier in struct sm1_dst_register. - vkd3d-shader/d3dbc: Use enum vkd3d_shader_src_modifier in struct sm1_src_register. - vkd3d-shader/d3dbc: Use VKD3D_SM1_DCL_USAGE_SHIFT and VKD3D_SM1_DCL_USAGE_INDEX_SHIFT in d3dbc_write_semantic_dcl(). - vkd3d-shader/tpf: Include vkd3d_d3dcommon.h only from tpf.c. - vkd3d-shader/ir: Move the source parameter helpers up. - vkd3d-shader/ir: Move the destination parameter helpers up. - vkd3d-shader/ir: Move the instruction helpers together. - vkd3d-shader/ir: Introduce vsir_src_param_init_resource(). - vkd3d-shader/ir: Introduce vsir_src_param_init_sampler(). - vkd3d-shader/ir: Merge vsir_program_normalise_combined_samplers() into vsir_program_lower_instructions(). - vkd3d-shader/glsl: Implement support for VKD3DSPR_INPUT registers. - vkd3d-shader/glsl: Implement support for VKD3DSPR_OUTPUT registers. - build: Use a tab to indent the "tests/hlsl/constructgswithso.shader_test" line in Makefile.am. - vkd3d-shader/d3dbc: Introduce enum vkd3d_sm1_misc_register. - vkd3d-shader/glsl: Handle SV_TARGET outputs. - vkd3d-shader/glsl: Implement support for VKD3DSPR_CONSTBUFFER registers. - vkd3d-shader/glsl: Implement support for VKD3DSPSM_ABS modifiers. - vkd3d-shader/d3dbc: Introduce enum vkd3d_sm1_rastout_register. - vkd3d-shader/glsl: Implement VKD3DSIH_NEU. - vkd3d-shader/glsl: Implement VKD3DSIH_MUL. - vkd3d-shader/glsl: Implement VKD3DSIH_INE. - vkd3d-shader/glsl: Implement VKD3DSIH_OR. - vkd3d-utils: Make D3D12CreateDevice a variadic macro, if possible. - vkd3d-shader/glsl: Implement VKD3DSIH_DIV. - vkd3d-shader/glsl: Implement support for VKD3DSPSM_NEG modifiers. - vkd3d-shader/glsl: Implement VKD3DSIH_GEO. - vkd3d-shader/glsl: Implement VKD3DSIH_FRC. - vkd3d-shader/d3dbc: Write the actual constant info offset in write_sm1_uniforms(). - vkd3d-shader/glsl: Implement VKD3DSIH_FTOI. - vkd3d-shader/glsl: Implement VKD3DSIH_FTOU. - vkd3d-shader/glsl: Implement VKD3DSIH_ROUND_PI. - vkd3d-shader/ir: Properly check the register bounds in shader_signature_find_element_for_reg(). - vkd3d-shader/glsl: Implement VKD3DSIH_ROUND_Z. - vkd3d-shader/glsl: Implement support for the VKD3DSPR_DEPTHOUT register. - vkd3d-shader/glsl: Implement VKD3DSIH_DP3. - vkd3d-shader/glsl: Implement VKD3DSIH_DP4. - vkd3d-shader/glsl: Implement VKD3DSIH_DP2. - vkd3d-shader/glsl: Implement VKD3DSIH_SQRT. - vkd3d-shader/glsl: Implement VKD3DSIH_DCL_INPUT_PS. - vkd3d-shader/glsl: Implement VKD3DSIH_IEQ. - vkd3d-shader/glsl: Implement VKD3DSIH_EXP. - vkd3d-shader/glsl: Implement VKD3DSIH_LTO. - vkd3d-shader/glsl: Implement VKD3DSIH_ROUND_NI. - vkd3d-shader/glsl: Implement VKD3DSIH_IF and VKD3DSIH_ENDIF. - vkd3d-shader/glsl: Implement VKD3DSIH_ROUND_NE. - vkd3d-shader/glsl: Handle SV_IS_FRONT_FACE inputs. - vkd3d-shader/glsl: Implement VKD3DSIH_LOG. - vkd3d-shader/glsl: Implement VKD3DSIH_MAX. - vkd3d-shader/glsl: Implement VKD3DSIH_MIN. - vkd3d-shader/glsl: Implement VKD3DSIH_RSQ. - vkd3d-shader/glsl: Implement VKD3DSIH_NOT. - vkd3d-shader/glsl: Implement VKD3DSIH_ELSE. - vkd3d-shader/glsl: Implement support for VKD3DSPDM_SATURATE modifiers. - vkd3d-shader/glsl: Implement VKD3DSIH_MAD. - vkd3d-shader/glsl: Implement VKD3DSIH_ISHL. - vkd3d-shader/glsl: Implement VKD3DSIH_ISHR. - vkd3d-shader/glsl: Implement VKD3DSIH_USHR. - vkd3d-shader/glsl: Implement VKD3DSIH_LD. - vkd3d-shader/glsl: Implement VKD3DSIH_SAMPLE. - vkd3d-shader/glsl: Implement VKD3DSIH_IGE. - vkd3d-shader/glsl: Implement VKD3DSIH_ILT. - vkd3d-shader/glsl: Implement VKD3DSIH_IMUL. - vkd3d-shader/glsl: Implement VKD3DSIH_EQO. - vkd3d-shader/glsl: Handle SV_VERTEX_ID inputs. - vkd3d-shader/glsl: Add interpolation modifiers to interstage inputs and outputs. - vkd3d-shader/glsl: Implement VKD3DSIH_IADD. - vkd3d-shader/glsl: Implement support for VKD3DSPR_IDXTEMP registers. - vkd3d-shader/glsl: Handle SV_POSITION inputs in fragment shaders. - vkd3d-shader/glsl: Implement support for VKD3D_SHADER_COMPONENT_UINT outputs. - vkd3d-shader/glsl: Implement support for VKD3D_SHADER_COMPONENT_UINT inputs. - vkd3d-shader/glsl: Implement VKD3DSIH_INEG. - vkd3d-shader/glsl: Implement VKD3DSIH_IMAX. - vkd3d-shader/ir: Store the thread group size in struct vsir_program. - vkd3d-shader/glsl: vkd3d-shader/glsl: Implement support for VKD3D_SHADER_COMPONENT_INT inputs. - vkd3d-shader/glsl: Implement loops. - vkd3d-shader/glsl: Implement switches. - vkd3d-shader/glsl: Implement VKD3DSIH_ULT. - vkd3d-shader/glsl: Implement VKD3DSIH_CONTINUE. - vkd3d-shader/ir: Remove VKD3DSIH_DCL_UAV_TYPED instructions. - vkd3d-shader/glsl: Use VKD3D_SHADER_ERROR_GLSL_UNSUPPORTED for unsupported CBV descriptor arrays. - vkd3d-shader/glsl: Use the semantic index for shader_out_* declarations. - vkd3d-shader/glsl: Implement VKD3DSIH_STORE_UAV_TYPED. - vkd3d-shader/glsl: Implement support for compute shaders. - tests/shader_runner: Trace the "clip-planes" cap. - build: Actually run interface-packing.shader_test and tessellation-patch-vars.shader_test. - tests: Add a basic shader model 6 interface packing test as well. - vkd3d-shader/dxil: Shift register write masks by the component index in sm6_parser_emit_dx_store_output(). - vkd3d-shader/d3dbc: Avoid D3DXSHADER_CONSTANTTABLE. - vkd3d: Slightly simplify the SRV/UAV logic in vk_write_descriptor_set_from_d3d12_desc(). - vkd3d-shader/glsl: Implement VKD3DSIH_LD_UAV_TYPED. - vkd3d-shader/glsl: Implement support for the VKD3DSPR_THREADID register. - vkd3d-shader/glsl: Implement VKD3DSIH_SAMPLE_B. - vkd3d-shader/glsl: Implement VKD3DSIH_SAMPLE_C. - vkd3d-shader/glsl: Implement VKD3DSIH_SAMPLE_C_LZ. - vkd3d-shader/ir: Store the global flags in struct vsir_program. - vkd3d-shader/glsl: Implement VKD3DSGF_FORCE_EARLY_DEPTH_STENCIL. - vkd3d-shader/glsl: Implement VKD3DSIH_UMAX and VKD3DSIH_UMIN. - vkd3d-shader/glsl: Implement VKD3DSIH_SAMPLE_LOD. - vkd3d-shader/glsl: Implement VKD3DSIH_SAMPLE_GRAD. - vkd3d-shader/glsl: Implement VKD3DSIH_GATHER4. - tests/shader_runner: Print the test context in fatal_error(). - vkd3d-shader/d3d-asm: Implement support for VKD3DSPR_PARAMETER registers. - vkd3d-shader/spirv: Handle oPts in spirv_compiler_get_register_name(). - tests/shader_runner: Handle render target sizes other than 640x480. - tests/shader_runner_d3d12: Introduce a helper to get the default resource state for a resource. - tests: Add a test for actual multisample loads. - tests/shader_runner: Set "properties2.sType" in get_physical_device_info() in the Vulkan runner. - tests/shader_runner: Print "(none)" for an empty caps list in trace_shader_caps(). - tests/shader_runner: Check whether copy/dispatch/draw succeeded in parse_test_directive(). - vkd3d-shader/ir: Specifically search for SV_POSITION0 in vsir_program_insert_clip_planes(). - vkd3d-shader/ir: Search for SV_TARGET0 vsir_program_insert_alpha_test(). - vkd3d-shader/glsl: Implement support for VKD3D_SHADER_COMPONENT_INT outputs. - vkd3d-shader/glsl: Implement VKD3DSIH_GATHER4_PO. - vkd3d-shader/glsl: Implement support for static texel offsets in shader_glsl_sample(). - vkd3d-shader/glsl: Handle SV_SAMPLE_INDEX inputs. - vkd3d-shader/glsl: Implement VKD3DSIH_LD2DMS. - tests/shader_runner: Slightly simplify dxc handling. - tests/shader_runner_metal: Get rid of some stray semicolons. - vkd3d-shader/msl: Implement VKD3DSIH_DCL_INPUT. - vkd3d-shader/msl: Implement VKD3DSIH_DCL_OUTPUT_SIV. - vkd3d-shader/msl: Implement VKD3DSIH_DCL_OUTPUT. - include: Document the binary effect transformations supported by vkd3d_shader_compile(). - -Nikolay Sivov (61): - vkd3d-shader/fx: Set structure field offsets in bytes. - vkd3d-shader/fx: Only add numeric variables when writing buffers. - vkd3d-shader/fx: Expand BlendState array fields for fx_4_1 as well. - vkd3d-shader/fx: Fix the unpacked size and stride fields of the fx_4_0 types. - vkd3d-shader/tpf: Fix a typo when adding the SFI0 section. - vkd3d-shader: Handle the SV_SampleIndex semantic. - vkd3d-shader/hlsl: Implement the mad() intrinsic. - vkd3d-shader/fx: Check modifiers when reusing types. - vkd3d-shader/tpf: Create a stub STAT section. - vkd3d-shader/tpf: Handle conversion instructions in STAT. - vkd3d-shader/tpf: Handle arithmetic instructions in STAT. - vkd3d-shader/tpf: Handle 'emit' and 'cut' in STAT. - vkd3d-shader/tpf: Handle 'movc' in STAT. - vkd3d-shader/tpf: Handle texture instructions in STAT. - vkd3d-shader/d3d-asm: Tweak some GS declaration names. - vkd3d-shader/tpf: Handle GS reflection fields in the STAT section. - vkd3d-shader/tpf: Handle bitwise instructions in STAT. - vkd3d-shader/tpf: Handle atomic instructions in STAT. - vkd3d-shader/tpf: Handle tessellation stage fields in STAT. - vkd3d-shader/tpf: Handle barrier instructions in STAT. - vkd3d-shader/tpf: Add a 'lod' counter to the STAT. - vkd3d-shader/tpf: Set 'gather' instructions counter in the STAT. - vkd3d-shader/tpf: Move STAT fields update to a separate helper. - vkd3d-shader/tpf: Set temps count in the STAT section. - vkd3d-shader: Explicitly set indices for the numeric type names array. - tests: Add some more tests for type name handling. - vkd3d-shader/hlsl: Remove the 'double' keyword. - vkd3d-shader/d3dbc: Add an option to treat doubles as floats. - tests: Add some tests for initial values in effects. - vkd3d-shader/fx: Handle the 'half' type in fx_4+. - vkd3d-shader/fx: Add initial support for writing default values for fx_2_0. - vkd3d-shader/fx: Add support for writing annotations for fx_2_0. - vkd3d-shader/hlsl: Move default values indexing fixup to the tpf writer stage. - tests: Add some tests for state value assignments. - vkd3d-shader/hlsl: Do not lower index expressions for effects. - vkd3d-shader/fx: Handle assignments with array RHS indexed with a constant or a single variable. - vkd3d-shader/fx: Implement writing fx_2_0 object initializer data sections. - vkd3d-shader/hlsl: Remove the type equality assertion for binary expression arguments. - tests: Add a test for uniform array indexing. - vkd3d-shader/fx: Introduce a parser/disassembler. - vkd3d-shader/fx: Add support for parsing constant buffer elements. - vkd3d-shader/fx: Add support for tracing string variables. - vkd3d-shader/hlsl: Implement the modf() intrinsic. - vkd3d-shader/fx: Add support for tracing annotations. - vkd3d-compiler: Add missing 'fx' source type to the CLI output. - vkd3d-shader/fx: Implement parsing groups and techniques. - vkd3d-shader/hlsl: Handle snorm/unorm types as resource formats. - vkd3d-shader/hlsl: Implement the f32tof16() intrinsic. - vkd3d-shader/hlsl: Handle SV_GroupIndex. - vkd3d-shader/hlsl: Use a more compact way to store object method configurations. - vkd3d-shader/hlsl: Add parser support for the RWByteAddressBuffer type. - tests: Add some more tests for RWByteAddressBuffer store methods. - vkd3d-shader/hlsl: Implement RWByteAddressBuffer.Store*() methods. - vkd3d-shader/fx: Implement parsing shader objects. - vkd3d-shader/fx: Implement parsing shader resources types. - vkd3d-shader/hlsl: Accept multiple colon-separated attributes. - vkd3d-shader/spriv: Only lookup resource symbols for UAVs in the ld_raw/ld_structured handler. - vkd3d-shader/hlsl: Add parser support for the ByteAddressBuffer type. - vkd3d-shader/hlsl: Implement the ByteAddressBuffer.Load*() methods. - vkd3d-shader/fx: Implement parsing the remaining fx_5_0 object types. - vkd3d-shader/fx: Implement parsing states objects. - -Petrichor Park (2): - vkd3d-shader/hlsl: Implement the dst() intrinsic. - vkd3d-shader/hlsl: Implement the sincos() intrinsic. - -Shaun Ren (36): - vkd3d-shader/hlsl: Check for duplicate attributes in function declaration. - tests: Test hull shader attributes. - tests: Test hull shader function overloads. - vkd3d-shader/hlsl: Introduce parse_entry_function_attributes() helper. - vkd3d-shader/hlsl: Parse the domain attribute. - vkd3d-shader/hlsl: Parse the outputcontrolpoints attribute. - vkd3d-shader/hlsl: Parse the outputtopology attribute. - vkd3d-shader/hlsl: Parse the partitioning attribute. - vkd3d-shader/hlsl: Parse the patchconstantfunc attribute. - vkd3d-shader/hlsl: Validate hull shader attributes. - vkd3d-shader/hlsl: Introduce process_entry_function() helper. - vkd3d-shader/hlsl: Clone static_initializers for each entry function. - vkd3d-shader/hlsl: Record semantic extern vars separately for each entry function. - vkd3d-shader/hlsl: Track whether a variable is read in any entry function. - vkd3d-shader/hlsl: Allocate temporary registers separately for each entry function. - vkd3d-shader/hlsl: Invoke prepend_uniform_copy() only once for global uniforms. - tests: Test struct single inheritance. - vkd3d-shader/hlsl: Implement struct single inheritance. - vkd3d-shader/tpf: Write hull shader declarations. - vkd3d-shader/tpf: Implement semantics for hull shaders. - tests: Test hull shader uniform input parameters. - vkd3d-shader/hlsl: Process the patch constant function in hlsl_emit_bytecode(). - vkd3d-shader/tpf: Introduce tpf_write_shader_function(). - vkd3d-shader/tpf: Determine SIV from SV and index in write_sm4_dcl_semantic(). - tests: Test signature reflection for hull shaders. - vkd3d-shader/tpf: Write the patch constant function in hull shaders. - vkd3d-utils: Implement version reflection. - vkd3d-utils: Return correct use masks during reflection. - vkd3d-shader/ir: Validate control point counts correctly. - vkd3d-shader/tpf: Write the input signature of domain shaders as PCSG. - vkd3d-shader/tpf: Use vpc input registers for domain shaders. - vkd3d-shader/tpf: Write domain shader declarations. - vkd3d-shader/tpf: Implement semantics for domain shaders. - tests: Test signature reflection for domain shaders. - vkd3d-shader/hlsl: Support discard for SM1. - vkd3d-shader/hlsl: Store SM4 semantic declarations in the vsir program. - -Victor Chiletto (3): - vkd3d-shader/hlsl: Fold logic AND and logic OR identities. - tests: Add a test for unused overlapping cbuffer reservations. - vkd3d-shader/hlsl: Allow cbuffer reservations to overlap if only one of them is allocated. +Victor Chiletto (10): + tests: Add more function overloading tests. + vkd3d-shader/hlsl: Explicitly track the copy propagation state stack. + vkd3d-shader/hlsl: Allow copy propagation to be stopped early. + vkd3d-shader/hlsl: Constant fold casts to boolean. + vkd3d-shader/hlsl: Run copy propagation incrementally during loop unrolling. + vkd3d-shader/hlsl: Do not clone the entire program for loop unrolling. + vkd3d-shader/hlsl: Remove loop_unrolling_find_unrollable_loop(). + vkd3d-shader/hlsl: Partially defer continue resolution. + vkd3d-shader/hlsl: Unroll loops with conditional jumps. + vkd3d-shader/hlsl: Drop the _ir_ infix from enum hlsl_loop_unroll_type. ``` diff --git a/COPYING b/COPYING index f5b3d6f2..38300301 100644 --- a/COPYING +++ b/COPYING @@ -1,4 +1,4 @@ -Copyright 2016-2024 the Vkd3d project authors (see the file AUTHORS for a +Copyright 2016-2025 the Vkd3d project authors (see the file AUTHORS for a complete list) Vkd3d is free software; you can redistribute it and/or modify it under diff --git a/ChangeLog.md b/ChangeLog.md index 80574695..26bbc467 100644 --- a/ChangeLog.md +++ b/ChangeLog.md @@ -1,3 +1,89 @@ +# What's new in vkd3d 1.15 (19 February 2025) + +### libvkd3d + + - New interfaces: + - vkd3d_queue_signal_on_cpu() allows a Direct3D 12 fence to be signalled + when all preceding work on a Direct3D 12 command queue has been submitted + to the corresponding Vulkan queue. + +### libvkd3d-shader + + - New features for the HLSL source type: + - ‘InputPatch’ and ‘OutputPatch’ tessellation shader objects. This was the + main feature required by most tessellation shaders that was still missing, + and tessellation shaders should be considered generally usable now. + - Unrolling of loops containing conditional jumps. + - Improved function overload resolution. Previously the compiler was unable + to decide between multiple function overloads with the same number of + parameters. + - The parser is able to continue parsing in a larger number of error cases. + This allows more issues in the input to be reported during a single + compilaton attempt. + - The following intrinsic functions are supported: + - GatherCmp() + - GatherCmpAlpha(), GatherCmpBlue(), GatherCmpGreen(), and GatherCmpRed() + - InterlockedAdd(), InterlockedAnd(), InterlockedCompareExchange(), + InterlockedCompareStore(), InterlockedExchange(), InterlockedMax(), + InterlockedMin(), InterlockedOr(), and InterlockedXor() + - isinf() + - Separate resource and sampler support for shader model 1-3 target + profiles. + - Casts on the left hand side of assignments. + - Reassociation and redistribution of constants in binary expressions, to + facilitate constant folding. + - Packing of interstage I/O variables with the ‘SV_IsFrontFace’, + ‘SV_PrimitiveID’, ‘SV_RenderTargetArrayIndex’, ‘SV_SampleIndex’, and + ‘SV_ViewPortArrayIndex’ semantics matches d3dcompiler/fxc more closely. + - Parser support for the ‘LineStream’, ‘PointStream’, and ‘TriangleStream’ + Stream-Output objects. + + - A number of instructions have been implemented for the experimental MSL + target. Although more and more shaders are starting to work, support is + still fairly limited. For example, shader resource views and unordered + access views are still entirely unsupported. + + - Shader code generation for fixed-function fog. Like the existing shader code + generation for other fixed-function features, this is mainly relevant for + executing shader model 1-3 sources in modern target environments like + Vulkan. + + - The ‘fx’ parser can parse binary effects containing inline shader blobs. + + - Internal validator support for validating I/O signatures, as well as I/O + source and destination parameters. The validator is enabled by the + ‘force_validation’ option, specified through the VKD3D_SHADER_CONFIG + environment variable. + + - Internal validator support for validating the number of indices used with a + register, as well as basic bounds checking for static indices. + + - New interfaces: + - The vkd3d_shader_scan_hull_shader_tessellation_info structure extends the + vkd3d_shader_compile_info structure, and can be used to retrieve the + output primitive type and partitioning mode used by a hull shader. This + information is particularly useful for specifying + vkd3d_shader_spirv_domain_shader_target_info structures when targetting + SPIR-V in OpenGL environments. + - The VKD3D_SHADER_PARAMETER_NAME_FOG_FRAGMENT_MODE shader parameter + specifies the kind of fog to generate in a fragment shader. + - The VKD3D_SHADER_PARAMETER_NAME_FOG_COLOUR shader parameter + specifies the fog colour. + - The VKD3D_SHADER_PARAMETER_NAME_FOG_END shader parameter + specifies the ‘end’ parameter used for linear fog generation. + - The VKD3D_SHADER_PARAMETER_NAME_FOG_SCALE shader parameter + specifies the ‘scale’ parameter used for fog generation. + - The VKD3D_SHADER_PARAMETER_NAME_FOG_SOURCE shader parameter + specifies the kind of fog coordinate to output from a pre-rasterisation + shader. + +### vkd3d-compiler + + - The new ‘dxbc-fx’ source type specifies an effect binary embedded in a DXBC + container. This is a convenience feature; + ‘vkd3d-compiler -x dxbc-fx blob.dxbc’ is equivalent to + ‘vkd3d-dxbc -x t:FX10 blob.dxbc | vkd3d-compiler -x fx’. + # What's new in vkd3d 1.14 (21 November 2024) ### libvkd3d diff --git a/Makefile.am b/Makefile.am index 6e4d73b6..ba7da6b3 100644 --- a/Makefile.am +++ b/Makefile.am @@ -400,7 +400,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 -I$(srcdir)/libs/vkd3d-shader @SPIRV_TOOLS_CFLAGS@ -libvkd3d_shader_la_LDFLAGS = $(AM_LDFLAGS) -version-info 13:0:12 +libvkd3d_shader_la_LDFLAGS = $(AM_LDFLAGS) -version-info 14:0:13 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 @@ -435,7 +435,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 15:0:14 +libvkd3d_la_LDFLAGS = $(AM_LDFLAGS) -version-info 16:0:15 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 @@ -448,7 +448,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:0:6 +libvkd3d_utils_la_LDFLAGS = $(AM_LDFLAGS) -version-info 7:1: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/commits b/commits deleted file mode 100644 index f573fabb..00000000 --- a/commits +++ /dev/null @@ -1,2 +0,0 @@ -- -0dc07f5cce72cce47b1a2787a910aeb5edc2a65e vkd3d-shader: Silence a spurious -Wmaybe-uninitialized in vsir_program_insert_alpha_test(). diff --git a/configure.ac b/configure.ac index fb57e1a4..dae9c63c 100644 --- a/configure.ac +++ b/configure.ac @@ -1,5 +1,5 @@ AC_PREREQ([2.69]) -AC_INIT([vkd3d],[1.14]) +AC_INIT([vkd3d],[1.15]) AC_CONFIG_AUX_DIR([bin]) AC_CONFIG_MACRO_DIR([m4]) diff --git a/demos/demo_xcb.h b/demos/demo_xcb.h index b9209b12..f0ce8bc0 100644 --- a/demos/demo_xcb.h +++ b/demos/demo_xcb.h @@ -19,7 +19,7 @@ #define VK_NO_PROTOTYPES #define VK_USE_PLATFORM_XCB_KHR -#define VKD3D_UTILS_API_VERSION VKD3D_API_VERSION_1_14 +#define VKD3D_UTILS_API_VERSION VKD3D_API_VERSION_1_15 #include "config.h" #include #include diff --git a/include/vkd3d.h b/include/vkd3d.h index 1daf6605..847d0eb8 100644 --- a/include/vkd3d.h +++ b/include/vkd3d.h @@ -99,6 +99,7 @@ enum vkd3d_api_version VKD3D_API_VERSION_1_12, VKD3D_API_VERSION_1_13, VKD3D_API_VERSION_1_14, + VKD3D_API_VERSION_1_15, VKD3D_FORCE_32_BIT_ENUM(VKD3D_API_VERSION), }; diff --git a/include/vkd3d_shader.h b/include/vkd3d_shader.h index 2a114bb9..058166aa 100644 --- a/include/vkd3d_shader.h +++ b/include/vkd3d_shader.h @@ -57,6 +57,7 @@ enum vkd3d_shader_api_version VKD3D_SHADER_API_VERSION_1_12, VKD3D_SHADER_API_VERSION_1_13, VKD3D_SHADER_API_VERSION_1_14, + VKD3D_SHADER_API_VERSION_1_15, VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_API_VERSION), }; diff --git a/libs/vkd3d-shader/fx.c b/libs/vkd3d-shader/fx.c index 779ffa1e..bd7e7b42 100644 --- a/libs/vkd3d-shader/fx.c +++ b/libs/vkd3d-shader/fx.c @@ -3237,7 +3237,7 @@ static void fx_4_parse_shader_blob(struct fx_parser *parser, unsigned int object static const struct vkd3d_shader_compile_option options[] = { - {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_14}, + {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_15}, }; fx_parser_read_unstructured(parser, &data_size, shader->offset, sizeof(data_size)); diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index c8dc6de4..010f076e 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -37,7 +37,7 @@ #define VKD3D_SPIRV_VERSION_1_0 0x00010000 #define VKD3D_SPIRV_VERSION_1_3 0x00010300 #define VKD3D_SPIRV_GENERATOR_ID 18 -#define VKD3D_SPIRV_GENERATOR_VERSION 14 +#define VKD3D_SPIRV_GENERATOR_VERSION 15 #define VKD3D_SPIRV_GENERATOR_MAGIC vkd3d_make_u32(VKD3D_SPIRV_GENERATOR_VERSION, VKD3D_SPIRV_GENERATOR_ID) #ifndef VKD3D_SHADER_UNSUPPORTED_SPIRV_PARSER # define VKD3D_SHADER_UNSUPPORTED_SPIRV_PARSER 0 diff --git a/libs/vkd3d-utils/vkd3d_utils_main.c b/libs/vkd3d-utils/vkd3d_utils_main.c index 7ced0671..d3aa1d79 100644 --- a/libs/vkd3d-utils/vkd3d_utils_main.c +++ b/libs/vkd3d-utils/vkd3d_utils_main.c @@ -271,7 +271,7 @@ HRESULT WINAPI D3DCompile2VKD3D(const void *data, SIZE_T data_size, const char * option = &options[0]; option->name = VKD3D_SHADER_COMPILE_OPTION_API_VERSION; - option->value = VKD3D_SHADER_API_VERSION_1_14; + option->value = VKD3D_SHADER_API_VERSION_1_15; compile_info.type = VKD3D_SHADER_STRUCTURE_TYPE_COMPILE_INFO; compile_info.next = &preprocess_info; @@ -435,7 +435,7 @@ HRESULT WINAPI D3DPreprocess(const void *data, SIZE_T size, const char *filename static const struct vkd3d_shader_compile_option options[] = { - {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_14}, + {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_15}, }; TRACE("data %p, size %"PRIuPTR", filename %s, macros %p, include %p, preprocessed_blob %p, messages_blob %p.\n", @@ -981,7 +981,7 @@ HRESULT WINAPI D3DDisassemble(const void *data, SIZE_T data_size, static const struct vkd3d_shader_compile_option options[] = { - {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_14}, + {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_15}, }; TRACE("data %p, data_size %"PRIuPTR", flags %#x, comments %p, blob %p.\n", diff --git a/libs/vkd3d/state.c b/libs/vkd3d/state.c index c8a67479..aa08dc98 100644 --- a/libs/vkd3d/state.c +++ b/libs/vkd3d/state.c @@ -2333,7 +2333,7 @@ static HRESULT create_shader_stage(struct d3d12_device *device, const struct vkd3d_shader_compile_option options[] = { - {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_14}, + {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_15}, {VKD3D_SHADER_COMPILE_OPTION_TYPED_UAV, typed_uav_compile_option(device)}, {VKD3D_SHADER_COMPILE_OPTION_WRITE_TESS_GEOM_POINT_SIZE, 0}, {VKD3D_SHADER_COMPILE_OPTION_FEATURE, feature_flags_compile_option(device)}, @@ -2388,7 +2388,7 @@ static int vkd3d_scan_dxbc(const struct d3d12_device *device, const D3D12_SHADER const struct vkd3d_shader_compile_option options[] = { - {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_14}, + {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_15}, {VKD3D_SHADER_COMPILE_OPTION_TYPED_UAV, typed_uav_compile_option(device)}, }; @@ -4067,7 +4067,7 @@ static int compile_hlsl_cs(const struct vkd3d_shader_code *hlsl, struct vkd3d_sh static const struct vkd3d_shader_compile_option options[] = { - {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_14}, + {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_15}, }; info.type = VKD3D_SHADER_STRUCTURE_TYPE_COMPILE_INFO; diff --git a/programs/vkd3d-compiler/main.c b/programs/vkd3d-compiler/main.c index 94e7e121..fb7bf361 100644 --- a/programs/vkd3d-compiler/main.c +++ b/programs/vkd3d-compiler/main.c @@ -932,7 +932,7 @@ int main(int argc, char **argv) if (!options.explicit_colour && !getenv("NO_COLOUR") && !getenv("NO_COLOR") && has_colour(output)) options.formatting |= VKD3D_SHADER_COMPILE_OPTION_FORMATTING_COLOUR; add_compile_option(&options, VKD3D_SHADER_COMPILE_OPTION_FORMATTING, options.formatting); - add_compile_option(&options, VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_14); + add_compile_option(&options, VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_15); if (options.target_type->type == VKD3D_SHADER_TARGET_SPIRV_BINARY || options.target_type->type == VKD3D_SHADER_TARGET_SPIRV_TEXT) add_compile_option(&options, VKD3D_SHADER_COMPILE_OPTION_FEATURE, diff --git a/tests/shader_runner_gl.c b/tests/shader_runner_gl.c index 83e659b3..95ba35d7 100644 --- a/tests/shader_runner_gl.c +++ b/tests/shader_runner_gl.c @@ -593,7 +593,7 @@ static bool compile_shader(struct gl_runner *runner, enum shader_type shader_typ const struct vkd3d_shader_compile_option options[] = { - {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_14}, + {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_15}, {VKD3D_SHADER_COMPILE_OPTION_FRAGMENT_COORDINATE_ORIGIN, VKD3D_SHADER_COMPILE_OPTION_FRAGMENT_COORDINATE_ORIGIN_LOWER_LEFT}, {VKD3D_SHADER_COMPILE_OPTION_FEATURE, shader_runner_caps_get_feature_flags(&runner->caps)}, diff --git a/tests/shader_runner_metal.m b/tests/shader_runner_metal.m index 5ecd24cf..27fbcdaa 100644 --- a/tests/shader_runner_metal.m +++ b/tests/shader_runner_metal.m @@ -254,7 +254,7 @@ static bool compile_shader(struct metal_runner *runner, enum shader_type type, s const struct vkd3d_shader_compile_option options[] = { - {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_13}, + {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_15}, {VKD3D_SHADER_COMPILE_OPTION_FEATURE, shader_runner_caps_get_feature_flags(&runner->caps)}, }; diff --git a/tests/shader_runner_vulkan.c b/tests/shader_runner_vulkan.c index de2c487c..83fedf33 100644 --- a/tests/shader_runner_vulkan.c +++ b/tests/shader_runner_vulkan.c @@ -354,7 +354,7 @@ static bool compile_d3d_code(struct vulkan_shader_runner *runner, int ret; options[0].name = VKD3D_SHADER_COMPILE_OPTION_API_VERSION; - options[0].value = VKD3D_SHADER_API_VERSION_1_14; + options[0].value = VKD3D_SHADER_API_VERSION_1_15; options[1].name = VKD3D_SHADER_COMPILE_OPTION_FEATURE; options[1].value = shader_runner_caps_get_feature_flags(&runner->caps);