diff --git a/ANNOUNCE b/ANNOUNCE index b4d18bd1..869204f7 100644 --- a/ANNOUNCE +++ b/ANNOUNCE @@ -1,16 +1,16 @@ -The vkd3d team is proud to announce that release 1.12 of vkd3d, the Direct3D +The vkd3d team is proud to announce that release 1.13 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: - - The HLSL compiler can directly output SPIR-V and Direct3D shader assembly. - - Improved support for shader model 1-3 profiles in the HLSL compiler. - - Miscellaneous bug fixes and performance improvements. + - Basic loop unrolling support in the HLSL compiler. + - Effects compiler support for several version 4.0+ state objects. + - Miscellaneous bug fixes. The source is available from the following location: - + The current source can also be pulled directly from the git repository: @@ -19,760 +19,399 @@ 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.12 +# What's new in vkd3d 1.13 ### libvkd3d - - When the VK_EXT_fragment_shader_interlock extension is available, libvkd3d - supports rasteriser-ordered views. + - The ID3D12CommandList6 interface is supported. - - Compute pipeline state objects can be created from compute shaders with - embedded root signatures. + - Block-compressed textures can be created with unaligned dimensions. This + corresponds to + D3D12_FEATURE_D3D12_OPTIONS8.UnalignedBlockTexturesSupported. - - When supported by the underlying Vulkan implementation, libvkd3d supports - the DXGI_FORMAT_B5G6R5_UNORM, DXGI_FORMAT_B5G5R5A1_UNORM, and - DXGI_FORMAT_B4G4R4A4_UNORM formats. - - - The ID3D12ShaderCacheSession interface is supported. - - - The ID3D12Device9 interface is supported. - - - The CreateCommittedResource2(), CreatePlacedResource1(), - GetCopyableFootprints1(), and GetResourceAllocationInfo2() methods of the - ID3D12Device8 interface are implemented. - - - Several new feature queries are supported: - - D3D12_FEATURE_D3D12_OPTIONS14 - - D3D12_FEATURE_D3D12_OPTIONS15 - - D3D12_FEATURE_D3D12_OPTIONS16 - - D3D12_FEATURE_D3D12_OPTIONS17 - - D3D12_FEATURE_D3D12_OPTIONS18 + - Some minor issues pointed out by the Vulkan validation layers have been + addressed. These are not known to affect applications in practice, but + should make libvkd3d slightly more well-behaved. ### libvkd3d-shader - - The experimental DXIL source type supports the majority of Direct3D shader - model 6.0 instructions and features. Note that this is currently still an - unsupported feature, enabled by building vkd3d with the - ‘-DVKD3D_SHADER_UNSUPPORTED_DXIL’ preprocessor option. No API or ABI - stability guarantees are provided for experimental features. - - New features for the HLSL source type: - - Support for compiling directly to Direct3D shader assembly and SPIR-V - target types. This is primarily a convenience feature, as targeting - these could previously be achieved by going through either the ‘Legacy - Direct3D byte-code’ or ‘Tokenized Program Format’ formats as - intermediates. - - Improved support for shader model 1-3 profiles. In particular: - - The ternary, comparison, and logical operators are now supported for - these profiles. - - Support for integer and Boolean types has been improved. - - Shader constants are allocated in an order compatible with the - Microsoft implementation. - - More complex array size expressions. For example, matrix and vector - swizzles are allowed, as well as (constant) array dereferences. + - Basic loop unrolling support. Some of the more complicated cases like + loops containing conditional jumps are still unsupported. + - Initialisation values for global variables, function parameters, and + annotation variables are parsed and stored in output formats supporting + them. + - Shader model 5.1 register spaces are supported when using the + corresponding target profiles, as well as shader model 5.1 reflection + data. + - Register reservations support expressions as offsets. For example: + ‘float f : register(c0[1 + 1 * 2]);’ + - The tex1D(), tex2D(), tex3D(), and texCUBE() intrinsic function variants + with explicit derivatives are supported. - The following intrinsic functions are supported: - - cosh() - - determinant() - - refract() - - sinh() - - tanh() - - Reflection data for ‘Tokenized Program Format’ targets more accurately - reflects the source shader. - - Constant folding of expressions like ‘x + 0’ and ‘x * 1’. - - Support for the ‘single’ qualifier on constant buffer declarations. - - Parser support for annotations on constant buffer declarations. - - Parser support for effect state objects. + - asint() + - f16tof32() + - faceforward() + - GetRenderTargetSampleCount() + - rcp() + - tex2Dbias() + - tex1Dgrad(), tex2Dgrad(), tex3Dgrad(), and texCUBEgrad() + - The sin() and cos() intrinsic functions are supported in shader model + 1-3 profiles. These were already supported in shader model 4+ profiles. + - The following features specific to effects target profiles: + - Types supported in version 4.0+: + - BlendState + - ComputeShader, DomainShader, GeometryShader, and HullShader + - DepthStencilState + - RasterizerState + - State application functions implemented for version 4.0+ effects: + - OMSetRenderTargets() + - SetBlendState() + - SetComputeShader(), SetDomainShader(), SetGeometryShader(), + SetHullShader(), SetPixelShader(), and SetVertexShader() + - SetDepthStencilState() + - SetRasterizerState() + - String types. These are mainly used for annotations. + - Annotations on global variables. + - Support for the ‘Texture’ field of the ‘SamplerState’ type. + - Support for NULL values. + - Stores to swizzled matrix variables. + - The ‘unsigned’ type modifier is supported. (For example, + ‘unsigned int’.) Note that ‘uint’ and related types were already + supported. + - ‘ConstantBuffer<>’ types. + - The ‘SV_Coverage’ output semantic for fragment shaders. - - When the SPV_EXT_fragment_shader_interlock extension is supported, SPIR-V - targets support rasteriser-ordered views. + - The experimental DXIL source type supports quad group operations. + + - The Direct3D shader model 2-3 ‘texldb’ instruction is correctly disassembled + when outputting Direct3D shader assembly. - New interfaces: - - The VKD3D_SHADER_PARSE_DXBC_IGNORE_CHECKSUM flag indicates that - vkd3d_shader_parse_dxbc() should skip validating the checksum of the - DXBC blob. This allows otherwise valid blobs with a missing or invalid - checksum to be parsed. - - The VKD3D_SHADER_SPIRV_ENVIRONMENT_VULKAN_1_1 enumeration value - specifies the Vulkan 1.1 environment for SPIR-V targets. Most notably, - the Vulkan 1.1 environment implies support for SPIR-V 1.3, which is a - requirement for supporting Direct3D shader model 6 wave operations on - SPIR-V targets. - - The VKD3D_SHADER_SPIRV_EXTENSION_EXT_FRAGMENT_SHADER_INTERLOCK - enumeration value indicates support for the - SPV_EXT_fragment_shader_interlock extension in the SPIR-V target - environment. - - The VKD3D_SHADER_COMPILE_OPTION_FEATURE_WAVE_OPS flag indicates support - for Direct3D shader model 6 wave operations in the SPIR-V target - environment. - - The VKD3D_SHADER_COMPILE_OPTION_FORMATTING_IO_SIGNATURES flag indicates - that vkd3d_shader_compile() should include information about input, - output, and patch constant shader signatures when targeting Direct3D - shader assembly. Note that this is a libvkd3d-shader extension, and - potentially makes the output incompatible with other implementations. - - The VKD3D_SHADER_COMPILE_OPTION_CHILD_EFFECT compile option specifies - whether libvkd3d-shader should produce child effects for ‘fx_4_0’ and - ‘fx_4_1’ HLSL target profiles. - - The VKD3D_SHADER_COMPILE_OPTION_INCLUDE_EMPTY_BUFFERS_IN_EFFECTS compile - option specifies whether empty constant buffer descriptions should be - included in the output for ‘fx_4_0’ and ‘fx_4_1’ HLSL target profiles. - - The VKD3D_SHADER_COMPILE_OPTION_WARN_IMPLICIT_TRUNCATION compile option - specifies whether the HLSL compiler should emit warnings for vector and - matrix truncation in implicit type conversions. + - The vkd3d_shader_parameter_info structure extends the + vkd3d_shader_compile_info structure, and can be used to specify shader + parameters. This is a more generic version of the shader parameter + interface for SPIR-V targets in struct vkd3d_shader_spirv_target_info. + - The VKD3D_SHADER_PARAMETER_DATA_TYPE_FLOAT32 enumeration value specifies + that a shader parameter contains 32-bit floating-point data. + - The VKD3D_SHADER_PARAMETER_NAME_ALPHA_TEST_FUNC shader parameter + specifies the alpha test function. + - The VKD3D_SHADER_PARAMETER_NAME_ALPHA_TEST_REF shader parameter + specifies the alpha test reference value. + - The VKD3D_SHADER_PARAMETER_NAME_FLAT_INTERPOLATION shader parameter + specifies the interpolation mode for colour inputs in Direct3D shader + model 1-3 fragment shaders. + - The VKD3D_SHADER_PARAMETER_TYPE_BUFFER enumeration value specifies that + the value of a shader parameter is provided at run-time through a buffer + resource. -### libvkd3d-utils - - - D3D12CreateDeviceVKD3D() and D3D12CreateDevice() no longer require the - VK_KHR_surface and VK_KHR_swapchain extensions to be available. This - allows them to be used in environments with a windowing system, for - example for off-screen rendering and compute tasks. - - - The GetConstantBufferByIndex() and GetResourceBindingDesc() methods of the - ID3D12ShaderReflection interface are implemented. - - - The GetVariableByIndex() method of the - ID3D12ShaderReflectionConstantBuffer interface is implemented. - - - The GetMemberTypeByIndex() method of the ID3D12ShaderReflectionType - interface is implemented. - - - The GetType() method of the ID3D12ShaderReflectionVariable interface is - implemented. - -### vkd3d-compiler - - - The ‘+signatures’ flag for the ‘--formatting’ option can be used to - specify that vkd3d-compiler should include information about input, - output, and patch constant shader signatures when outputting Direct3D - shader assembly. Note that this is a vkd3d-compiler extension, and - potentially makes the output incompatible with other implementations. - - - The ‘--child-effect’ option can be used to specify that vkd3d-compiler - should produce child effects for ‘fx_4_0’ and ‘fx_4_1’ HLSL target - profiles. - - - The ‘--fx-include-empty-buffers’ option can be used to specify that - vkd3d-compiler should include empty constant buffer descriptions in the - output for ‘fx_4_0’ and ‘fx_4_1’ HLSL target profiles. - -### vkd3d-dxbc - - - The ‘--ignore-checksum’ option can be used to specify that vkd3d-dxbc - should skip validating the checksum of the DXBC input blob. This allows - vkd3d-dxbc to operate on otherwise valid blobs with missing or invalid - checksums. - - - The ‘--emit’ option can be used to indicate that vkd3d-dxbc should output - a new DXBC blob. - - - The ‘--extract’ option can be used to specify a section to extract out of - the input blob. For example, ‘vkd3d-dxbc -x t:PRIV blob.dxbc > priv.bin’ - would extract the private data section of ‘blob.dxbc’ to ‘priv.bin’, and - ‘vkd3d-dxbc -x t:RTS0 blob.dxbc > root_signature.bin’ would extract the - root signature to ‘root_signature.bin’. - - - The ‘--output’ option can be used to specify where vkd3d-dxbc should write - its output for the ‘--emit’ and ‘--extract’ options. - -### Changes since vkd3d 1.11: +### Changes since vkd3d 1.12: ``` -Alexandre Julliard (1): - vkd3d-shader: Avoid non-constant initializer. +Anna (navi) Figueiredo Gomes (6): + vkd3d-shader/ir: Periodically flush buffers when tracing blocks. + Add a .editorconfig file. + vkd3d: Use D3D12_SHADER_VISIBILITY_ALL for 32-bit root constants when using vk_heaps. + vkd3d-shader/spirv: Avoid decorating variables multiple times with NonReadable. + vkd3d-shader/spirv: Use unique SPIR-V variables for descriptors where visibility differs. + vkd3d-shader/spirv: Avoid decorating variables multiple times with Coherent. -Conor McCarthy (169): - tests/shader-runner: Add raw UAV tests. - vkd3d-shader/spirv: Always use a 64-bit write mask for IMMCONST64 src params. - vkd3d: Add ID3D12Device8 interface stubs. - tests/d3d12: Add tests for GetResourceAllocationInfo2(). - tests/d3d12: Add tests for CreateCommittedResource2(). - tests/d3d12: Add tests for CreatePlacedResource1(). - tests/d3d12: Add tests for GetCopyableFootprints1(). - vkd3d: Implement GetResourceAllocationInfo2(). - vkd3d: Implement CreateCommittedResource2(). - vkd3d: Implement CreatePlacedResource1(). - vkd3d: Implement GetCopyableFootprints1(). - tests/shader-runner: Add a test for FCMP_ORD (is ordered). - vkd3d-shader/dxil: Support FCMP_ORD and FCMP_UNO for CMP2. - vkd3d-shader/spirv: Handle the ORD and UNO instructions. - tests/shader-runner: Add sampler comparison tests. - tests/shader-runner: Add a Gather test with non-constant offset. - vkd3d-shader/dxil: Implement DX intrinsic TextureGather. - vkd3d-shader/dxil: Implement DX intrinsic TextureGatherCmp. - tests/shader-runner: Add tests for minimum-precision constants. - vkd3d-shader/spirv: Introduce a data_type_is_floating_point() helper function. - vkd3d-shader/spirv: Introduce HALF and UINT16 types for minimum precision. - vkd3d-shader/dxil: Support 16-bit types. - vkd3d-shader/spirv: Emit an error if COUNTBITS has a 64-bit source. - vkd3d-shader/spirv: Emit an error if a FIRSTBIT instruction has a 64-bit source. - tests/hlsl: Add tests for countbits() and firstbit{high|low}(). - vkd3d-shader/spirv: Support zero-initialisation for workgroup memory. - vkd3d-shader/dxil: Implement raw groupshared address space global variables. - vkd3d-shader/dxil: Implement structured groupshared address space global variables. - vkd3d-shader/spirv: Emit a trace message if TGSM alignment is ignored. - vkd3d-shader/dxil: Implement DX instruction Barrier. - tests/hlsl: Add UAV counter tests. - vkd3d-shader/dxil: Implement DX intrinsic BufferUpdateCounter. - tests/hlsl: Add tests for mad() and fma(). - vkd3d-shader/spirv: Use dst register data type in spirv_compiler_emit_imad(). - vkd3d-shader/dxil: Implement DX intrinsics FMa, FMad, IMad and UMad. - vkd3d-shader/dxil: Implement DX intrinsic FAbs. - vkd3d-shader/dxil: Implement DX intrinsic Saturate. - vkd3d-shader/spirv: Do not assert if a TGSM load dst register is not UINT. - vkd3d-shader/spirv: Do not assert if a TGSM store data register is not UINT. - vkd3d-shader/spirv: Support 64-bit register info component type in spirv_compiler_emit_load_reg(). - vkd3d-shader/dxil: Emit an error if a constant code is unhandled. - tests/shader-runner: Add TGSM tests. - vkd3d-shader/dxil: Implement DX instructions ThreadId, GroupId, ThreadIdInGroup and FlattenedThreadIdInGroup. - vkd3d-shader/dxil: Implement the DXIL ATOMICRMW instruction. - vkd3d-shader/spirv: Emit a warning if the atomic instruction volatile flag is unhandled. - vkd3d-shader/spirv: Handle the sequentially consistent ordering flag for atomic instructions. - vkd3d-shader/spirv: Support bool source in spirv_compiler_emit_discard(). - vkd3d-shader/dxil: Implement DX intrinsic Discard. - tests/hlsl: Add tests for asdouble(). - vkd3d-shader/dxil: Implement DX intrinsic MakeDouble. - vkd3d-shader/dxil: Implement DX intrinsics Dot2, Dot3 and Dot4. - vkd3d-shader/ir: Materialise phis to temps in the incoming blocks. - vkd3d-shader/spirv: Emit a uint result for RESINFO_UINT if the dst register is SSA. - vkd3d-shader/spirv: Handle uint2 to double bitcast in spirv_compiler_emit_mov(). - vkd3d-shader/ir: Convert SSAs to temps only if the block of origin does not dominate all uses. - vkd3d-shader/ir: Materialise SSAs to temps before lowering switch instructions. - vkd3d-shader/dxil: Support constexpr GEP. - vkd3d-shader/spirv: Bitcast if necessary in spirv_compiler_emit_store_dst_components(). - vkd3d-shader/spirv: Ensure the data register is UINT in spirv_compiler_emit_store_tgsm(). - tests/hlsl: Add tests for CalculateLevelOfDetail(). - vkd3d-shader/dxil: Implement DX intrinsic CalculateLOD. - tests/d3d12: Test resource flags for multisampled resources. - vkd3d: Validate presence of flag ALLOW_RENDER_TARGET or ALLOW_DEPTH_STENCIL for multisampled resources. - vkd3d: Validate that a resource with initial state RENDER_TARGET is a render target. - vkd3d-shader/ir: Implement MAD in two operations if flagged as precise. - tests/hlsl: Supply data for all mip levels in calculate-lod.shader_test. - tests/hlsl: Add a tessellation test. - vkd3d-shader/dxil: Load domain shader properties. - vkd3d-shader/dxil: Load hull shader properties. - vkd3d-shader/dxil: Implement DX intrinsic PrimitiveID. - vkd3d-shader/ir: Validate tessellation declarations. - tests/hlsl: Add tests for GetSamplePosition() and GetSampleCount(). - vkd3d-shader/dxil: Implement DX intrinsics Texture2DMSGetSamplePosition and RenderTargetGetSamplePosition. - vkd3d-shader/dxil: Implement DX intrinsic RenderTargetGetSampleCount. - tests/hlsl: Add an InterlockedCompareExchange() TGSM test. - vkd3d-shader/dxil: Implement the DXIL CMPXCHG instruction. - vkd3d-shader/spirv: Emit a compiler warning if an atomic op is flagged volatile. - vkd3d-shader: Introduce SPIRV_ENVIRONMENT_VULKAN_1_1. - vkd3d: Use Vulkan 1.1 if available. - vkd3d-shader: Introduce a wave ops feature flag. - tests: Add UNORM formats B5G6R5, B5G5R5A1 and B4G4R4A4 to the UAV image clear tests. - vkd3d: Support DXGI_FORMAT_B5G6R5_UNORM. - vkd3d: Support DXGI_FORMAT_B5G5R5A1_UNORM. - vkd3d: Support DXGI_FORMAT_B4G4R4A4_UNORM. - tests/hlsl: Add tests for SV_Depth. - tests/hlsl: Add tests for SV_DepthLessEqual and SV_DepthGreaterEqual. - vkd3d-shader/dxil: Support SV_Depth, SV_DepthGreaterEqual and SV_DepthLessEqual. - tests/hlsl: Add wave op tests. - vkd3d-shader/dxil: Support patch constant functions and signatures. - vkd3d-shader/dxil: Implement DX intrinsics LoadOutputControlPoint and LoadPatchConstant. - vkd3d-shader/dxil: Implement DX intrinsic StorePatchConstant. - vkd3d-shader/dxil: Implement DX intrinsic DomainLocation. - vkd3d-shader/dxil: Implement DX intrinsic OutputControlPointID. - tests/hlsl: Add tests for min() and integer max(). - tests/hlsl: Add a test for a structured UAV scalar store. - tests/hlsl: Add a test for UAV InterlockedExchange(). - tests/hlsl: Add tests for texture UAV atomics. - tests/hlsl: Add tests for texture UAV signed atomics. - vkd3d-shader/ir: Accept undefined PHI incomings as valid. - vkd3d-shader/ir: Always check for undominated SSA use in register relative addresses. - vkd3d-shader/dxil: Emit an error if a LOAD instruction uses a forward-referenced pointer. - vkd3d-shader/dxil: Emit an error if a STORE instruction uses a forward-referenced pointer. - vkd3d-shader/dxil: Emit an error if a ATOMICRMW instruction uses a forward-referenced pointer. - vkd3d-shader/dxil: Emit an error if a CMPXCHG instruction uses a forward-referenced pointer. - tests/hlsl: Add a test for constexpr pointer cast. - vkd3d-shader/dxil: Handle constexpr pointer cast. - tests/hlsl: Add an SV_InstanceId test. - vkd3d-shader/dxil: Handle SV_InstanceId. - vkd3d-shader/dxil: Handle SV_PrimitiveId. - tests/hlsl: Add SV_Coverage tests. - vkd3d-shader/dxil: Implement DX intrinsic Coverage. - vkd3d-shader/dxil: Implement DX intrinsics WaveGetLaneCount and WaveGetLaneIndex. - vkd3d-shader/spirv: Handle the WAVELANECOUNT register. - vkd3d: Initialise wave ops feature options. - tests/shader-runner: Skip shader model 6.0 tests if the device does not support them. - tests/shader-runner: Add a 'require' directive for wave ops. - vkd3d-shader/spirv: Handle the WAVELANEINDEX register. - vkd3d-shader/dxil: Implement DX intrinsic WaveActiveAllEqual. - vkd3d-shader/spirv: Handle the WAVE_ACTIVE_ALL_EQUAL instruction. - vkd3d-shader/dxil: Implement DX intrinsic WaveAllTrue. - vkd3d-shader/spirv: Handle the WAVE_ALL_TRUE instruction. - vkd3d-shader/dxil: Implement DX intrinsic WaveAnyTrue. - vkd3d-shader/spirv: Handle the WAVE_ANY_TRUE instruction. - vkd3d-shader/dxil: Implement DX intrinsic WaveActiveBallot. - vkd3d-shader/spirv: Implement the WAVE_ACTIVE_BALLOT instruction. - vkd3d-shader/dxil: Implement DX intrinsic WaveActiveBit. - vkd3d-shader/spirv: Implement the WAVE_ACTIVE_BIT_* instructions. - vkd3d-shader/dxil: Implement DX intrinsics WaveActiveOp and WavePrefixOp. - vkd3d-shader/spirv: Implement the WAVE_OP_* instructions. - tests/shader-runner: Free the hull and domain shader source code. - tests/hlsl: Add a geometry shader test. - vkd3d-shader/dxil: Load geometry shader properties. - vkd3d-shader/ir: Validate geometry shader properties. - vkd3d-shader/dxil: Implement DX intrinsics EmitStream, CutStream and EmitThenCutStream. - vkd3d-shader/dxil: Implement DX intrinsic WaveAllBitCount. - vkd3d-shader/spirv: Implement the WAVE_ALL_BIT_COUNT instruction. - vkd3d-shader/dxil: Implement DX intrinsic WaveIsFirstLane. - vkd3d-shader/spirv: Implement the WAVE_IS_FIRST_LANE instruction. - vkd3d-shader/dxil: Implement DX intrinsic WavePrefixBitCount. - vkd3d-shader/spirv: Implement the WAVE_PREFIX_BIT_COUNT instruction. - tests: Add tests for D3D12_FEATURE_SHADER_MODEL. - vkd3d: Return a shader model no higher than the requested one for D3D12_FEATURE_SHADER_MODEL. - vkd3d: Return E_INVALIDARG if the requested shader model is unknown. - vkd3d-shader/dxil: Emit bool inputs and outputs as uint. - vkd3d-shader/spirv: Do not warn if no global flags are unhandled. - vkd3d-shader/spirv: Emit a trace instead of a warning message for ignored alignment. - vkd3d-shader/dxil: Delete bool not-equal-to-false comparison instructions. - vkd3d-shader/ir: Allow all DCL instructions to occur outside hull shader phases. - tests/hlsl: Add a test for WaveReadLaneAt() with a non-uniform index. - vkd3d-shader/dxil: Implement DX intrinsic WaveReadLaneAt. - vkd3d-shader/spirv: Implement the WAVE_READ_LANE_AT instruction. - vkd3d-shader/dxil: Implement DX intrinsic WaveReadLaneFirst. - tests/hlsl: Clear the RTV before the WaveReadLaneFirst() test. - vkd3d-shader/spirv: Implement the WAVE_READ_LANE_FIRST instruction. - tests/hlsl: Add a test for SV_Coverage out. - vkd3d-shader/dxil: Handle SV_Coverage out. - tests/hlsl: Add a test for SV_ClipDistance. - vkd3d-shader/dxil: Handle SV_ClipDistance and SV_CullDistance. - tests/d3d12: Do not test a typed UAV in test_atomic_instructions(). - tests/d3d12: Do not test 3D depth textures in test_get_copyable_footprints(). - tests/d3d12: Do not clear UAVs via a structured view. - tests/d3d12: Set the descriptor heaps for the draw call in test_graphics_uav_counters(). - tests/d3d12: Check the correct depth/stencil plane format and alignment in test_get_copyable_footprints(). - tests/d3d12: Test format D32_FLOAT_S8X24_UINT in test_get_copyable_footprints(). - tests/d3d12: Check UnalignedBlockTexturesSupported when testing GetCopyableFootprints(). - tests/d3d12: Ensure stream output BufferFilledSizeLocation is always valid. - tests/d3d12: Use get_cpu_sampler_handle() for the sampler heap in test_unbounded_samplers(). - tests/d3d12: Add a separate null 'views' pointer test in test_null_vbv(). - vkd3d: Check for mutable descriptor set allocation failure in d3d12_descriptor_heap_create_descriptor_set(). +Atharva Nimbalkar (2): + vkd3d-shader/glsl: Implement VKD3DSIH_MOV. + vkd3d-shader/glsl: Implement support for VKD3DSPR_TEMP registers. -Elizabeth Figura (62): - vkd3d-shader/spirv: Implement CMP. - vkd3d-shader/spirv: Implement SLT and SGE. - tests: Use a UAV barrier between ClearUnorderedAccessViewFloat() and a compute shader. - vkd3d-utils: Implement ID3D12ShaderReflection::GetConstantBufferByIndex(). - vkd3d-utils: Parse the RD11 section. - vkd3d-utils: Implement ID3D12ShaderReflectionConstantBuffer::GetVariableByIndex(). - vkd3d-utils: Implement ID3D12ShaderReflectionVariable::GetType(). - vkd3d-utils: Implement ID3D12ShaderReflectionType::GetMemberTypeByIndex(). - vkd3d-shader/tpf: Do not write non-numeric struct fields into the RDEF. - vkd3d-shader/hlsl: Allocate register reservations for structs as well. - vkd3d-shader/tpf: Do not write structs with no numeric fields into the RDEF. - vkd3d-shader/tpf: Explicitly write the class and base type for non-numeric types. - vkd3d-shader/tpf: Write the component count as the column count for structs. - vkd3d-shader/tpf: Set the user-packed flag for sm5.0 resources as well. - tests: Test constant and resource reflection via D3DReflect(). - tests: Add more tests for resource and struct RDEF contents. - vkd3d-shader/spirv: Implement VKD3DSIH_ABS. - vkd3d-shader: Add a compile option to control whether implicit truncation warnings are printed. - vkd3d-shader/hlsl: Remove a redundant type check. - vkd3d-shader/hlsl: Move a hlsl_fixme() to a more relevant place. - vkd3d-shader/hlsl: Simplify type_has_object_components(). - vkd3d-shader/hlsl: Use hlsl_is_numeric_type() in type_has_object_components(). - vkd3d-shader/hlsl: Move shader version helpers to hlsl.h. - vkd3d-shader/hlsl: Use hlsl_version_ge() when checking for unbounded arrays. - vkd3d-shader/hlsl: Add SM5.1 shader target strings. - tests: Test HLSL unbounded array syntax. - vkd3d-shader/hlsl: Use hlsl_type_is_resource() for unbounded array checks. - tests: Add more tests for manual packing. - vkd3d-shader/hlsl: Consider any valid register reservation to invoke manual packing. - vkd3d-shader/hlsl: Avoid using HLSL_CLASS_OBJECT without checking the base type. - vkd3d-shader/hlsl: Map HLSL_TYPE_DOUBLE to D3DXPT_FLOAT. - vkd3d-shader/d3dbc: Consider the class in sm1_base_type(). - vkd3d-shader/fx: Don't use an array to write the type class. - vkd3d-shader/fx: Move unimplemented type checks into is_type_supported_fx_2(). - vkd3d-shader/fx: Use a switch in write_fx_2_initial_value(). - vkd3d-shader/hlsl: Make HLSL_TYPE_VOID into a separate class. - vkd3d-shader/hlsl: Make HLSL_TYPE_STRING into a separate class. - vkd3d-shader/hlsl: Make HLSL_TYPE_SAMPLER into a separate class. - vkd3d-shader/hlsl: Make HLSL_TYPE_TEXTURE into a separate class. - vkd3d-shader/hlsl: Make HLSL_TYPE_UAV into a separate class. - vkd3d-shader/hlsl: Rename register_opt and packoffset_opt to register_reservation and packoffset_reservation. - vkd3d-shader/hlsl: Parse register space reservations. - tests: Do not run the d3d11 backend with shader model 5.1. - tests: Add tests for profile syntax in register reservations. - tests: Add tests for register space reservation syntax. - vkd3d-shader/hlsl: Make HLSL_TYPE_EFFECT_GROUP into a separate class. - vkd3d-shader/hlsl: Make HLSL_TYPE_PASS into a separate class. - vkd3d-shader/hlsl: Make HLSL_TYPE_TECHNIQUE into a separate class. - vkd3d-shader/hlsl: Make HLSL_TYPE_DEPTHSTENCILVIEW into a separate class. - vkd3d-shader/hlsl: Make HLSL_TYPE_RENDERTARGETVIEW into a separate class. - vkd3d-shader/hlsl: Ensure that the type is numeric before calling expr_common_base_type(). - vkd3d-shader/hlsl: Make HLSL_TYPE_VERTEXSHADER into a separate class. - vkd3d-shader/hlsl: Make HLSL_TYPE_PIXELSHADER into a separate class. - vkd3d-shader/hlsl: Use a switch in hlsl_types_are_equal(). - vkd3d-shader/hlsl: Move the "base_type" member to the class-specific union. - vkd3d-utils: Fix bounds comparison against element counts. - vkd3d-shader/tpf: Write the field offset in bytes. - vkd3d-utils: Initialize the null type vtbl. - tests: Test bounds checking in ID3D12ShaderReflection. - vkd3d-utils: Implement ID3D12ShaderReflection::GetResourceBindingDesc(). - vkd3d-shader/fx: Skip uniform copy logic for global variables. - authors: Change the full form of my name. +Conor McCarthy (16): + vkd3d-shader/dxil: Implement DX intrinsic QuadOp. + vkd3d-shader/spirv: Implement the QUAD_READ_ACROSS_* instructions. + vkd3d-shader/dxil: Implement DX intrinsic QuadReadLaneAt. + vkd3d-shader/spirv: Implement the QUAD_READ_LANE_AT instruction. + tests/d3d12: Check for unaligned block texture support in test_create_committed_resource(). + vkd3d: Allow block compressed textures to have unaligned width and height. + tests/d3d12: Test a null vertex buffer 'views' pointer on multiple slots. + vkd3d: Interpret a null vertex buffer 'views' pointer as a null buffer. + tests/shader-runner: Set the correct flag and format for raw UAVs. + tests/shader-runner: Create a new runner object for the shader model 6 tests. + vkd3d: Create a descriptor pool for static samplers when Vulkan-backed heaps are used. + tests: Add a test for clearing a large buffer UAV. + vkd3d: Limit the workgroup X count for buffer UAV clears to the supported max. + vkd3d: Add support for the ID3D12CommandList6 interface. + vkd3d-shader/spirv: Free the spirv parameter info. + vkd3d: Free descriptor range information on error paths in d3d12_root_signature_info_from_desc(). (Valgrind) -Evan Tang (2): - vkd3d-shader/spirv: Implement support for rasteriser-ordered views. - vkd3d: Enable VK_EXT_fragment_shader_interlock if available. +Elizabeth Figura (39): + vkd3d-shader/hlsl: Add a hlsl_fixme() for 5.1 resource arrays. + vkd3d-shader/hlsl: Put constant buffers into the extern_resources struct. + vkd3d-shader: Write SM5.1 register indices. + vkd3d-shader/hlsl: Allocate register spaces for constant buffers. + vkd3d-shader/hlsl: Allocate register spaces for objects. + vkd3d-shader: Write SM5.1 register spaces. + vkd3d-shader/hlsl: Write SM5.1 binding reflection data. + tests: Add reflection tests for register space. + vkd3d-shader/hlsl: Always initialize $$ when parsing modifiers from an arbitrary string. + tests: Stop probing all pixels when drawing a uniform colour. + tests: Run combined-samplers.shader_test on sm1 as well. + tests: Add another combined sampler test. + vkd3d-shader/hlsl: Respect the coords writemask in write_sm1_resource_load(). + vkd3d-shader/hlsl: Only allocate the aligned size for uniforms. + vkd3d-shader/hlsl: Separate an "array" rule. + vkd3d-shader/d3dbc: Use enum vkd3d_shader_register_type in struct sm1_instruction. + tests/shader_runner: Use resource->width instead of resource->size for buffer width. + tests/shader_runner: Factor out a resource_desc structure. + tests: Implement multisampling in the Vulkan renderer. + tests: Implement multisampling in the GL renderer. + vkd3d-shader/hlsl: Implement the GetRenderTargetSampleCount() intrinsic. + vkd3d-shader/hlsl: Implement output SV_Coverage. + vkd3d-shader: Introduce struct vkd3d_shader_parameter_info and struct vkd3d_shader_parameter1. + include: Document shader parameters. + vkd3d-shader/spirv: Support passing shader parameters through uniform buffers. + tests: Add a test for the vkd3d_shader_parameter APIs. + vkd3d-shader/spirv: Respect VKD3D_SHADER_CONDITIONAL_OP_Z when discard has a bool argument. + vkd3d-shader: Allow controlling alpha test through vkd3d-shader parameters. + tests: Offset the viewport by 0.5 when running d3dbc shaders. + tests: Factor out a set_default_target() helper. + tests: Test alpha test. + vkd3d-shader/spirv: Allocate output_info after normalization. + vkd3d-shader: Factor out a vsir_program_get_parameter() helper. + vkd3d-shader/spirv: Pass a vkd3d_data_type to spirv_compiler_emit_shader_parameter(). + vkd3d-shader: Do not make the alpha test ref parameter VSIR_DIMENSION_VEC4. + vkd3d-shader: Use the program parameters in spirv_compiler_alloc_spec_constant_id(). + vkd3d-shader: Allow controlling d3d color shade mode through vkd3d-shader parameters. + tests: Test shade mode. + vkd3d-shader: Use an extended version of vkd3d_shader_immediate_constant in vkd3d_shader_parameter1. -Francisco Casas (70): - vkd3d-shader/hlsl: Lower casts to int using REINTERPRET instead. - vkd3d-shader/hlsl: Lower non-float operators for SM1. - vkd3d-shader/d3dbc: Implement bool to float cast as MOV. - tests: Copy autotool's testsuite driver script. - tests: Get detailed information on failing tests. - tests/shader-runner: Pass uniforms to vertex shaders in d3d9 and d3d11. - vkd3d-shader/hlsl: Cast slt before multiplying on ternary operator. - tests: Test comparison and logic operators on SM1 vertex shaders. - tests: Check that -0.0f is not less than 0.0f. - tests: Avoid creating a file named "0" when calling "make check". - vkd3d-shader/d3dbc: Check profiles before writing SLT and CMP. - vkd3d-shader/hlsl: Implement SM1 comparison operators. - tests: Test equality between tiny and between large numbers on ps_2_0. - vkd3d-shader/hlsl: Lower SLT instructions for pixel shaders. - vkd3d-shader/hlsl: Use hlsl_fixme() on missing SM1 matrix writemask lowering. - vkd3d-shader/hlsl: Lower CMP instructions for vertex shaders. - tests: Add tests for LOGIC_NOT on uniforms. - vkd3d-shader/hlsl: Support LOGIC_NOT for SM1. - vkd3d-shader/hlsl: Cast to bool before applying LOGIC_NOT. - vkd3d-shader/d3dbc: Implement HLSL_OP2_LOGIC_OR for SM1. - vkd3d-shader/d3dbc: Implement HLSL_OP2_LOGIC_AND for SM1. - vkd3d-shader/spirv: Throw compiler error on unrecognized register. - tests/test-driver: Display [SIGABRT] and [SIGSEGV] tags. - tests/test-driver: Print line where vkd3d_unreachable() was hit. - vkd3d-shader/hlsl: Ensure that TERNARY condition is always bool. - vkd3d-shader/hlsl: Move lower of non-float expressions with the other SM1 passes. - vkd3d-shader/hlsl: Merge HLSL_OP3_MOVC into HLSL_OP3_TERNARY. - tests: Report missing signature element in openGL runner. - vkd3d-shader/tpf: Use the extra_bits field for _nz on discard. - tests: Add failing test for clip.shader_test in SM1. - vkd3d-shader/ir: Add missing src swizzle in vsir_program_lower_texkills(). - vkd3d-shader/hlsl: Use LOGIC_OR instead of BIT_OR in any(). - vkd3d-shader/hlsl: Use LOGIC_AND instead of MUL in all(). - vkd3d-shader/hlsl: Properly release string buffer on write_atan_or_atan2(). - vkd3d-shader/hlsl: Also call dce before lowering deref paths. - tests: Add more state block syntax tests. - tests: Test function call syntax for state blocks. - tests: Add tests for fxgroup syntax. - tests: Add tests for "compile" and CompileShader() syntax. - vkd3d-shader/hlsl: Parse and store state blocks on variables. - vkd3d-shader/hlsl: Introduce hlsl_ir_stateblock_constant. - vkd3d-shader/hlsl: Parse list of state blocks. - vkd3d-shader/hlsl: Store state block on pass variables. - vkd3d-shader/hlsl: Allow KW_PIXELSHADER and KW_VERTEXSHADER as stateblock lhs. - vkd3d-shader/hlsl: Cleanup parse_attribute_list structs (valgrind). - tests/shader-runner: Report whole-block errors on the block's starting line. - tests: Add additional conditional tests for shader model 3.0. - vkd3d-shader/d3dbc: Pass hlsl_block instead of function declaration. - vkd3d-shader/ir: Lower IFC instructions to IF instructions. - vkd3d-shader/d3dbc: Support SM1 if conditionals. - tests: Test x + 0 and x * 1 indentities. - vkd3d-shader/hlsl: Fold x + 0 identities. - vkd3d-shader/hlsl: Fold x * 1 identities. - vkd3d-shader/hlsl: Turn hlsl_state_block_entry arguments into hlsl_src. - tests: Test SM1 constant register allocation. - tests: Test SM1 constant register allocation with reservations. - tests: Test SM1 const register allocation with relative addressing. - vkd3d-shader/hlsl: Allocate unused variables with register reservations on SM1. - vkd3d-shader/hlsl: Improve tracking of used components running DCE before. - vkd3d-shader/hlsl: Track bind count according to usage for uniforms. - vkd3d-shader/hlsl: Only allocate numeric bind count for SM1 numeric uniforms. - vkd3d-shader/d3dbc: Write used bind count for numeric uniforms. - vkd3d-shader/hlsl: Allocate SM1 numeric uniforms in decreasing bind count. - vkd3d-shader: Return a valid pointer when count=0 in param allocator (ubsan). - tests: Test default values for uniform variables. - tests: Test default values for constant buffer variables. - vkd3d-shader/hlsl: Run constant passes in a separate function. - vkd3d-shader/hlsl: Run more constant passes on static expressions eval. - tests: Test complex array size expression. - vkd3d-shader/hlsl: Also lower matrix swizzles and index loads in const passes. +Francisco Casas (52): + vkd3d-shader/hlsl: Record default values for uniforms and constant buffers. + vkd3d-shader/hlsl: Initialize default values with braceless initializers. + tests: Test default values using reflection. + vkd3d-shader/tpf: Write default values for SM4. + vkd3d-shader/d3dbc: Write default values for SM1. + tests: Test matrix default value initializers. + vkd3d-shader/hlsl: Fix numeric register offset for matrix components. + vkd3d-shader/hlsl: Reorder default values for matrices for SM4. + tests: Test register reservations on unused variables. + vkd3d-shader/hlsl: Only error out on bind_count register reservation overlaps for SM1. + vkd3d-shader/d3dbc: Split hlsl_sm1_write(). + vkd3d-shader/hlsl: Generate CTAB outside d3dbc_compile(). + vkd3d-shader/d3dbc: Introduce struct d3dbc_compiler. + vkd3d-shader/d3dbc: Use program->shader_version instead of ctx->profile. + vkd3d-shader/d3dbc: Don't require a hlsl_semantic to get register and usage. + vkd3d-shader/d3dbc: Use vsir_program I/O signatures to write dcls. + vkd3d-shader/d3dbc: Don't write inconsequential MOVs. + vkd3d-shader/hlsl: Free array sizes on function parameters (Valgrind). + tests: Separate the valid stateblock function names test from the string arg test. + vkd3d-shader/hlsl: Parse function call syntax on state blocks. + tests: Test whether valid state block function names are case-sensitive. + vkd3d-shader/hlsl: Validate state block function calls. + vkd3d-shader/hlsl: Add missing src1 and src2 constants to sincos on SM2. + tests: Test string escape sequences. + vkd3d-shader/hlsl: Parse string constants. + vkd3d-shader/hlsl: Parse string escape sequences. + vkd3d-shader/hlsl: Parse string type. + tests: Add missing double precission require directives. + tests: Report tests skipped because of missing capabilities. + tests/shader-runner: Add missing trace for wave_ops caps. + tests: Introduce VKD3D_TEST_DETAILED for the test driver. + vkd3d-shader/hlsl: Avoid dereferencing rel_offset if it is NULL. + tests: Add additional non-constant array indexing tests. + vkd3d-shader/hlsl: Lower non-constant array loads for SM1. + vkd3d-shader/hlsl: Remove SM1 fixme for matrix writemasks. + vkd3d-shader/hlsl: Lower non-constant row_major matrix loads for SM1. + tests: Add additional string tests. + vkd3d-shader/hlsl: Parse string default values. + vkd3d-shader/hlsl: Skip writing string default values. + vkd3d-shader/hlsl: Always work with the extern resource's component type. + vkd3d-shader: Avoid div by zero on assert in vkd3d_calloc() (ubsan). + tests: Add additional tests for function calls in state block rhs. + tests: Test shader compilation within function definitions. + tests: Test compile syntax on effects. + tests: Test shader compilation within braces. + tests: Test shader compilation with default values. + tests/shader_runner: Require explicit formats for UAV resources. + tests/shader_runner: Move parse_format() up. + tests/shader_runner: Replace spaces with dashes in format names. + tests/shader_runner: Don't skip shader compilation on missing caps. + tests/shader_runner: Explicitly require UAV load support. + tests/test-driver: Avoid double space when printing details. -Giovanni Mascellani (124): - vkd3d-shader/d3d-asm: Do not make a copy of the buffer before returning it. - vkd3d-shader/d3d-asm: Describe the ASM dialect with a bunch of flags instead of a plain enum. - vkd3d-shader/d3d-asm: Refactor dumping a write mask to a dedicated function. - vkd3d-shader/d3d-asm: Support emitting the shader signature. - vkd3d-compiler: Add an option to emit the signature when disassembling. - tests: Test emitting the signature. - vkd3d-shader/ir: Properly handle function-local indexable temps when flattening control flow. - vkd3d-shader/ir: Add a debug buffer to struct vsir_cfg. - vkd3d-shader/ir: Introduce a helper to express block domination. - vkd3d-shader/ir: Compute the loops in the control flow graph. - vkd3d-shader/ir: Keep a reference to the message context inside struct vsir_cfg. - vkd3d-shader/ir: Keep track of loops by header block. - vkd3d-shader/ir: Dump the loops in the control flow graph. - vkd3d-shader/ir: Sort each loop by block label. - vkd3d-shader/ir: Allow adding to a block list without checking for duplicates. - vkd3d-shader/ir: Topologically sort the control flow graph. - vkd3d-shader/ir: Dump the topological order of the control flow graph. - vkd3d-shader/ir: Keep loops contiguous in the topological sort. - vkd3d-shader: Treat the HLSL case specially in vkd3d_shader_scan(). - vkd3d-shader: Treat the HLSL case specially in vkd3d_shader_compile(). - vkd3d-shader: Refactor common code for vkd3d_shader_scan(). - vkd3d-shader: Refactor common code for vkd3d_shader_compile(). - vkd3d-shader/d3d-asm: Print labels in red. - vkd3d-shader/d3d-asm: Only emit signatures for SM4-6. - vkd3d-shader/dxbc: Add flag to ignore the DXBC checksum. - vkd3d-dxbc: Add an option to ignore checksum. - vkd3d-dxbc: Add an option to re-emit the shader with the correct checksum. - vkd3d-dxbc: Add an option to choose the output filename. - vkd3d-shader/tpf: Remove a useless parameter to shader_sm4_init(). - vkd3d-shader/dxbc: Decouple vkd3d_shader_desc from DXBC parsing. - vkd3d-shader: Move shader signatures to vsir_program. - vkd3d-shader/dxbc: Remove flag is_dxil. - vkd3d-shader: Remove the bytecode fields from vkd3d_shader_desc. - tests: Mark the HS punned array test as buggy on MoltenVK. - tests: Pop the test context when leaving its scope. - tests: Mark the coverage test as buggy on MoltenVK. - tests: Relax precision a bit for an interpolation test. - tests: Clear the UAV before testing. - vkd3d-shader/ir: Compute loop as intervals of the block order. - vkd3d-shader/ir: Generate synthetic intervals for forward edges. - vkd3d-shader/ir: Sort loop intervals. - vkd3d-shader/ir: Reconstruct a structured program. - vkd3d-shader/ir: Add jumps to the structured programs. - vkd3d-shader/ir: Dump the reconstructed structured program. - vkd3d-shader/ir: Emit the reconstructed structured program. - vkd3d-shader/ir: Emit multilevel jumps in the structured program. - vkd3d-shader/d3d-asm: Indent instructions inside a block. - vkd3d-shader/d3d-asm: Do not dump a register's type if it's unused. - vkd3d-shader/ir: Use type "unused" for labels. - Add a changelog for all the released versions of vkd3d. - include: Include stddef.h in vkd3d_shader.h. - tests: Include vkd3d_d3d12.h in utils.h. - vkd3d-compiler: Clean up the shader code in all failure paths (Valgrind). - vkd3d-shader/ir: Move vsir_program_normalise() to the end of the file. - vkd3d-shader/ir: Open a loop when visiting the loop header. - vkd3d-shader/ir: Drop a useless helper. - ci: Make llvmpipe from Mesa 24.0.3 available in the CI image. - ci: Run tests on llvmpipe from Mesa 24.0.3. - vkd3d-shader/ir: Move `continue's to the false branch when possible. - vkd3d-shader/ir: Remove trailing `continue's. - vkd3d-shader/ir: Synthesize selection constructs from conditional jumps. - ci: Build the macOS image each time the Linux image is built. - ci: Delimit building each commit with a collapsible section. - vkd3d-shader/d3d-asm: Reset indent level on HS phases. - tests: Mark some test failures as todo on llvmpipe. - tests: Skip some tests that crash on llvmpipe. - tests: Print the device name. - tests: Add llvmpipe among the Mesa drivers. - tests: Pop the test context when leaving its scope. - ci: Build Mesa for release. - vkd3d-shader/hlsl: Emit half results when operating on half arguments. - tests: Check that side effects do not happen after discard. - vkd3d-shader/ir: Move `break's out of selection constructs when possible. - vkd3d-shader/ir: Count how many jumps target each loop. - vkd3d-shader/ir: Remove loops that terminate with a `break'. - vkd3d-shader/ir: Prepare for changing the destination list in vsir_cfg_optimize_recurse(). - vkd3d-shader/ir: Append code to the non-breaking branch if there is breaking one. - vkd3d-shader/ir: Move breaks out of selections again after having optimized loops. - vkd3d-shader/ir: Split program structurization. - vkd3d-shader/ir: Split undominated SSA materialization. - vkd3d-shader/ir: Refactor declaration emission outside of the CFG structure. - vkd3d-shader/ir: Split handling blocks when emitting a structured program. - vkd3d-shader/ir: Split handling loops when emitting a structured program. - vkd3d-shader/ir: Split handling selections when emitting a structured program. - vkd3d-shader/ir: Split handling jumps when emitting a structured program. - vkd3d-shader/ir: Introduce vsir_program_lower_instructions(). - vkd3d-shader/ir: Move DCL_TEMPS removal to the generic instruction lowering pass. - vkd3d-shader/ir: Swap selection branches if the if branch is empty. - vkd3d-shader/ir: Only emit trampolines when needed. - vkd3d-shader/ir: Only emit launchers when needed. - vkd3d-utils: Make all extensions optional in D3D12CreateDeviceVKD3D(). - tests: Avoid using a different UAV for SM<6 and SM>=6. - tests: Check that derivatives are still computed after discarding. - tests/shader-runner: Use OpDemoteToHelperInvocationEXT when available. - tests: Allow skipping DXC tests at runtime. - tests: Allow compiling shaders with DXC on crosstests. - ci: Run crosstests with DXC too. - include: Document struct vkd3d_instance_create_info. - include: Document struct vkd3d_structure_type. - include: Document struct vkd3d_optional_instance_extensions_info. - include: Document structure vkd3d_application_info. - include: Document structure vkd3d_host_time_domain_info. - vkd3d-shader/ir: Skip invalid blocks when materializing undominated SSAs. - vkd3d-shader/ir: Structurize each function of a hull shader. - vkd3d-shader/ir: Materialize SSAs in each function of a hull shader. - tests: Test wave reconvergence after selections and loops. - tests: Add missing test file. - vkd3d: Simplify control flow for swapchain images. - include: Document structure vkd3d_device_create_info. - include: Document structure vkd3d_optional_device_extensions_info. - include: Document structure vkd3d_image_resource_create_info. - vkd3d: Warn about missing extensions only when meaningful. - vkd3d: Move checking device extensions to a dedicated function. - vkd3d: Do not automatically succeed if no extensions are available. - vkd3d: Init physical device information after checking available extensions. - vkd3d: Only request properties and features when the corresponding extension is available. - vkd3d: Handle D3D12_FEATURE_D3D12_OPTIONS14 in CheckFeatureSupport(). - vkd3d: Handle D3D12_FEATURE_D3D12_OPTIONS15 in CheckFeatureSupport(). - vkd3d: Handle D3D12_FEATURE_D3D12_OPTIONS16 in CheckFeatureSupport(). - vkd3d: Handle D3D12_FEATURE_D3D12_OPTIONS17 in CheckFeatureSupport(). - vkd3d: Handle D3D12_FEATURE_D3D12_OPTIONS18 in CheckFeatureSupport(). - vkd3d: Move the full stops before the newline. - tests: Check device support for all the 16 bit image formats. - tests: Skip a test that freezes the GPU on NVIDIA. +Giovanni Mascellani (57): + tests: Mark some root signature unbounded range failures as todo on MoltenVK. + vkd3d: Do not request VK_EXT_debug_marker if debug is disabled. + vkd3d: Enable VK_KHR_portability_subset if available. + vkd3d: Do not synchronize with the geometry shader stage if it's not enabled. + ci: Assume an Apple Silicon-based environment for the macOS CI job. + tests: Skip sampling cube textures on Qualcomm. + tests: Transition resources to PIXEL_SHADER_RESOURCE in test_sample_c_lz(). + tests: Check that depth/stencil formats are supported before using them. + vkd3d: Do not synchronize with the tessellation shader stages if they're not enabled. + tests: Improve feedback when enabling d3d12 debug layers. + tests: Enable the d3d12 debug layer message callbacks. + tests: Support using the Agility SDK in the crosstests. + vkd3d: Propagate a failure in d3d12_descriptor_heap_init(). + tests: Define WIDL macros in utils.h. + vkd3d: Allocate temporary arrays on the stack in d3d12_command_list_update_push_descriptors(). + tests: Pad the constant buffer in test_update_compute_descriptor_tables() to 256 bytes. + tests: Terminate the Agility SDK path with a slash. + vkd3d: Document how to install "Graphics Tools" to use the Agility SDK. + vkd3d: Rebuild the vkd3d_physical_device_info chain before creating the device. + vkd3d: Remove the temporary pointers in vkd3d_physical_device_info_init(). + vkd3d: Propagate errors out of d3d12_root_signature_append_vk_binding(). + vkd3d: Disable WARN_ON() when VKD3D_NO_DEBUG_MESSAGES is defined. + vkd3d: Disable FIXME_ONCE() when VKD3D_NO_DEBUG_MESSAGES is defined. + vkd3d: Allow disabling ERR() by defining VKD3D_NO_ERROR_MESSAGES. + vkd3d: Introduce debug severity MESSAGE. + vkd3d: Introduce a softer form of assertion. + vkd3d: Allow aborting on ERR(). + vkd3d: Emit an ERR() when reaching unreachable code. + ci: Abort on assertions on the CI. + tests: Test register conflicts in a root signature. + vkd3d: Replace assert() with VKD3D_ASSERT() in command.c. + vkd3d: Replace assert() with VKD3D_ASSERT() in resource.c. + vkd3d: Replace assert() with VKD3D_ASSERT() in state.c. + vkd3d: Replace assert() with VKD3D_ASSERT() in utils.c. + vkd3d: Replace assert() with VKD3D_ASSERT() in vkd3d_private.h. + vkd3d-common: Remove an assertion in vkd3d_dbg_printf(). + vkd3d-shader: Replace assert() with VKD3D_ASSERT() in checksum.c. + vkd3d-shader: Replace assert() with VKD3D_ASSERT() in d3d_asm.c. + vkd3d-shader: Replace assert() with VKD3D_ASSERT() in d3dbc.c + vkd3d-shader: Replace assert() with VKD3D_ASSERT() in dxbc.c. + tests: Mark a couple of tests as working on recent NVIDIA GPUs. + vkd3d-shader: Replace assert() with VKD3D_ASSERT() in dxil.c. + vkd3d-shader: Replace assert() with VKD3D_ASSERT() in fx.c. + vkd3d-shader: Replace assert() with VKD3D_ASSERT() in hlsl_codegen.c. + vkd3d-shader: Replace assert() with VKD3D_ASSERT() in hlsl_constant_ops.c. + vkd3d-shader: Replace assert() with VKD3D_ASSERT() in hlsl.c. + vkd3d-shader: Replace assert() with VKD3D_ASSERT() in hlsl.h. + vkd3d-shader: Replace assert() with VKD3D_ASSERT() in hlsl.y. + vkd3d-shader: Replace assert() with VKD3D_ASSERT() in ir.c. + vkd3d-shader: Replace assert() with VKD3D_ASSERT() in preproc.h. + vkd3d-shader: Replace assert() with VKD3D_ASSERT() in preproc.l. + vkd3d-shader: Replace assert() with VKD3D_ASSERT() in preproc.y. + vkd3d: Check the entire root signature for register conflicts. + vkd3d-shader: Replace assert() with VKD3D_ASSERT() in spirv.c. + vkd3d-shader: Replace assert() with VKD3D_ASSERT() in tpf.c. + vkd3d-shader: Replace assert() with VKD3D_ASSERT() in vkd3d_shader_main.c. + vkd3d-shader: Replace assert() with VKD3D_ASSERT() in vkd3d_shader_private.h. -Henri Verbeet (85): - vkd3d-shader: Enable GLSL target support when VKD3D_SHADER_UNSUPPORTED_GLSL is defined. - vkd3d-shader/glsl: Use location information from the current instruction. - vkd3d-shader/d3d-asm: Get rid of the (now) redundant "shader_desc" parameter to vkd3d_dxbc_binary_to_text(). - vkd3d-shader/glsl: Introduce glsl_compile(). - vkd3d-shader/ir: Pass a struct vsir_program to instruction_array_lower_texkills(). - vkd3d-shader/ir: Pass a struct vsir_program to materialize_ssas_to_temps_process_reg(). - vkd3d-shader/ir: Pass a struct vsir_program to materialize_ssas_to_temps(). - vkd3d-shader/ir: Pass a struct vsir_program to simple_structurizer_run(). - vkd3d-shader/ir: Pass a struct vsir_program to remap_output_signature(). - vkd3d-shader/glsl: Store a pointer to the vsir program in struct vkd3d_glsl_generator. - vkd3d-shader/glsl: Trace the generated shader. - vkd3d-shader/glsl: Generate comments for unhandled instructions. - vkd3d-shader/ir: Pass a struct vsir_program to shader_normalise_io_registers(). - vkd3d-shader/ir: Pass a struct vsir_program to normalise_combined_samplers(). - vkd3d-shader/ir: Pass a struct vsir_program to flatten_control_flow_constructs(). - vkd3d-shader/ir: Pass a struct vsir_program to vsir_validate(). - vkd3d-shader/glsl: Keep track of the current indentation level. - vkd3d-shader/d3d-asm: Pass a prefix and suffix to shader_dump_tessellator_domain(). - vkd3d-shader/d3d-asm: Pass a prefix and suffix to shader_dump_tessellator_output_primitive(). - vkd3d-shader/d3d-asm: Pass a prefix and suffix to shader_dump_tessellator_partitioning(). - vkd3d-shader/d3d-asm: Pass a prefix and suffix to shader_dump_src_param(). - vkd3d-shader/d3d-asm: Pass a prefix and suffix to shader_dump_dst_param(). - tests/shader_runner: Add GLSL support to the GL runner. - vkd3d-shader/ir: Pass a struct vsir_program to vkd3d_shader_normalise(). - vkd3d-common: Merge vkd3d_debug.h into vkd3d_common.h. - vkd3d: Move the vkd3d_mutex implementation to vkd3d-common. - tests: Initialise resource_desc1.Layout in test_get_copyable_footprints() (Valgrind). - tests/shader_runner: Cleanup on insufficient GLSL support in gl_runner_init() (Valgrind). - vkd3d-dxbc: Close output files after writing them. - vkd3d-dxbc: Introduce a helper function to handle ACTION_TYPE_EMIT. - vkd3d-dxbc: Introduce a helper function to apply actions. - vkd3d-dxbc: Free the blob if parsing it failed. - vkd3d-dxbc: Implement extracting section data. - vkd3d-dxbc: Allow the section to extract to be specified by tag. - tests: Free the shader blobs once we're done with them in test_create_pipeline_state(). (Valgrind). - tests/test-driver: Avoid "head" with negative line count. - configure: Use AC_CHECK_TOOL to check for widl. - vkd3d-shader/d3d-asm: Pass a prefix and suffix to shader_dump_register(). - vkd3d-shader/d3d-asm: Pass a prefix and suffix to shader_dump_reg_type(). - vkd3d-shader/d3d-asm: Pass a prefix and suffix to shader_dump_shader_input_sysval_semantic(). - vkd3d-shader/d3d-asm: Pass a prefix and suffix to shader_dump_decl_usage(). - vkd3d-shader/d3d-asm: Pass a prefix and suffix to shader_dump_primitive_type(). - vkd3d-shader/d3d-asm: Pass a prefix and suffix to shader_dump_interpolation_mode(). - tests: Test creating compute pipeline states from shaders with embedded root signatures. - vkd3d: Implement creating compute pipeline states from shaders with embedded root signatures. - vkd3d-shader/d3d-asm: Get rid of shader_addline(). - vkd3d-shader/ir: Remove VKD3DSIH_DCL_CONSTANT_BUFFER instructions. - vkd3d: Avoid leaking "messages" when "error_blob" is NULL in vkd3d_serialize_root_signature(). (Valgrind). - vkd3d: Avoid leaking "messages" when "error_blob" is NULL in vkd3d_serialize_versioned_root_signature(). (Valgrind). - vkd3d-shader/glsl: Call vkd3d_shader_normalise(). - vkd3d-shader/glsl: Add vkd3d-shader version information to the generated shader. - vkd3d-shader/hlsl: Support d3d-asm as target format. - vkd3d-shader/hlsl: Support spirv-binary and spirv-text as target formats. - tests/shader_runner: Pass only valid stages to vkCreateGraphicsPipelines(). - vkd3d-shader/glsl: Implement VKD3DSIH_NOP. - vkd3d: Move the vkd3d_cond implementation to vkd3d-common. - vkd3d-common: Introduce VKD3D_BITMAP_SIZE. - vkd3d: Use WIDL_C_INLINE_WRAPPERS. - vkd3d-utils: Use WIDL_C_INLINE_WRAPPERS. - vkd3d-common: Use WIDL_C_INLINE_WRAPPERS. - tests/shader_runner: Use WIDL_C_INLINE_WRAPPERS. - vkd3d: Get rid of vkd3d_atomic_compare_exchange_pointer(). - vkd3d-common: Introduce vkd3d_atomic_compare_exchange_u32(). - vkd3d-common: Introduce vkd3d_atomic_exchange_u32(). - vkd3d-common: Introduce vkd3d_atomic_exchange_ptr(). - vkd3d-shader/hlsl: Use vkd3d_string_buffer_printf() in declare_predefined_types(). - vkd3d-shader/spirv: Use location information from the current instruction. - vkd3d-shader: Get rid of struct vkd3d_shader_desc. - configure: Build with -flto=auto when available. - vkd3d-shader/spirv: Pass a struct vsir_program to spirv_compiler_generate_spirv(). - vkd3d-shader/spirv: Pass a struct vsir_program to spirv_compile(). - vkd3d-shader: Pass a struct vsir_program to scan_with_parser(). - vkd3d-shader: Pass a struct vsir_program to vkd3d_shader_parser_compile(). - tests/shader_runner: Get rid of some redundant "| glsl" conditions. - vkd3d-shader/ir: Use a separate allocation for the vsir program in struct vkd3d_shader_parser. - vkd3d-shader/ir: Pass an initialised vsir_program structure to vkd3d_shader_parser_init(). - vkd3d-shader/ir: Do not store the vkd3d-shader configuration flags in struct vkd3d_shader_parser. - vkd3d-shader/d3dbc: Parse the shader into a vsir program in vkd3d_shader_sm1_parser_create(). - vkd3d-shader/tpf: Parse the shader into a vsir program in vkd3d_shader_sm4_parser_create(). - vkd3d-shader/dxil: Parse the shader into a vsir program in vkd3d_shader_sm6_parser_create(). - vkd3d-shader: Use a separate allocation for the "semantic_name" field of shader signature elements. - include: Document the additional HLSL transformations supported by vkd3d_shader_compile(). - include: Add a \since tag for VKD3D_FALSE. - build: Fix the order of a couple of shader runner tests. - tests: Rename VKD3D_TESTS_SKIP_DXC to VKD3D_TEST_SKIP_DXC. +Henri Verbeet (9): + vkd3d-shader/ir: Rename the "handler_idx" field of struct vkd3d_shader_instruction to "opcode". + vkd3d: Always use UINT views to clear UAVs with integer formats. + vkd3d-shader/ir: Remove VKD3DSIH_DCL instructions. + vkd3d-shader/ir: Remove VKD3DSIH_DCL_SAMPLER instructions. + vkd3d-common: Replace assert() with VKD3D_ASSERT(). + vkd3d-shader/fx: Replace assert() with VKD3D_ASSERT(). + vkd3d: Do not include assert.h. + build: Actually run bitwise-assignment.shader_test. + vkd3d-shader/spirv: Decorate non-array descriptor variables as well. -Nikolay Sivov (49): - vkd3d-shader/hlsl: Implement ternary operator for older vertex profiles. - vkd3d-shader/hlsl: Add keyword tokens for fx_5_0 shader object types. - vkd3d-shader/hlsl: Allow technique10 {} blocks for fx_2_0. - vkd3d-shader/fx: Reject fx_2_0 output without techniques. - vkd3d-shader/fx: Make sure to set error message for unimplemented cases. - tests: Add some tests for shader object type names. - vkd3d-shader/hlsl: Improve VertexShader/PixelShader types handling. - vkd3d-shader/hlsl: Add determinant() function. - vkd3d-shader/hlsl: Allow modifiers on buffer declarations. - vkd3d-shader/d3dbc: Do not write semantic declarations for unused variables. - vkd3d-shader/fx: Add initial support for writing uninitialized vertex/pixel shader objects. - vkd3d-shader: Add an option to enable child effects compilation. - vkd3d-shader/fx: Add support for writing shared object descriptions for fx_4_x. - vkd3d-shader: Remove a token for 'precise' modifier. - vkd3d-shader: Parse a 'single' modifier. - vkd3d-shader/fx: Handle 'single' modifier for buffers. - vkd3d-shader/fx: Use type writing helper only for fx_4+. - vkd3d-shader/fx: Fix an instruction block leak. - vkd3d-shader/fx: Populate global variables list during context initialization. - vkd3d-shader/fx: Add initial support for writing fx_2_0 parameters. - vkd3d-shader/fx: Remove newlines from fixme messages. - vkd3d-shader/fx: Fail effect writing on unsupported annotations. - vkd3d-shader: Adjust "child-effect" option documentation. - vkd3d-shader/fx: Mark shared variables as such for fx_2_0 effects. - vkd3d-shader/fx: Zero-pad strings when aligning them for fx_2_0. - vkd3d-shader/fx: Set initial object count to 1 for fx_2_0. - tests: Rename effect test files to make them easier to find. - vkd3d-shader/fx: Handle "half" type for fx_2_0 parameters. - vkd3d-shader/fx: Handle "uint" type for fx_2_0 parameters. - vkd3d-shader/hlsl: Treat "texture" type name as case-insensitive. - vkd3d-shader/fx: Accept texture types when writing fx_2_0 effects. - vkd3d-shader/hlsl: Allow annotations on constant buffers. - vkd3d-shader/fx: Add an option to include empty buffers in the effect binary. - vkd3d-shader/hlsl: Allow 'export' modifier on functions. - vkd3d-shader/hlsl: Test refract() intrinsic. - vkd3d-shader/hlsl: Support refract() intrinsic. - tests: Add some tests for string variables. - vkd3d-shader/fx: Write depth stencil view object variables. - vkd3d-shader/fx: Set RTV counter in the header. - vkd3d-shader/fx: Set texture count in the header. - vkd3d-shader/fx: Fix shader counter in the header. - vkd3d-shader/fx: Filter out unsupported object types. - vkd3d-shader/fx: Set UAV count in the header. - vkd3d-shader/fx: Initial support for writing sample state objects. - tests: Test SM1 constant register allocation with a row_major matrix. - vkd3d-shader/fx: Implement writing shared buffers. - vkd3d-shader/fx: Use correct type name when reusing types. - vkd3d-shader: Remove explicit newlines from hlsl_fixme() messages. - vkd3d-shader/ir: Set texture register dimension as VEC4 when normalising combined samplers. +Nikolay Sivov (66): + vkd3d-shader/hlsl: Handle "unsigned int" type. + tests: Add some basic tests for ConstantBuffer type. + tests: Add a few tests for the NULL value. + vkd3d-shader/fx: Do not write shared buffers block when not compiling as a child effect. + vkd3d-shader/hlsl: Implement tex2Dbias(). + vkd3d-shader/asm: Output 'bias' flag for 'texld'. + vkd3d-shader/d3dbc: Write load instruction for tex2Dbias(). + vkd3d-shader/hlsl: Store original semantic name. + vkd3d-shader/fx: Use original full semantic name. + vkd3d-shader/fx: Set EXPLICIT_BIND_POINT flag for packoffset() reservations as well. + vkd3d-shader/fx: Fix variable buffer offset value. + vkd3d-shader/hlsl: Add support for ConstantBuffer<> type. + vkd3d-shader/fx: Cast state block field values to target type. + vkd3d-shader/fx: Add support for writing DepthStencilState objects. + vkd3d-shader/hlsl: Add RasterizerState type. + vkd3d-shader/fx: Add support for writing RasterizerState objects. + vkd3d-shader: Implement tex*() functions variants with gradient arguments. + vkd3d-shader/hlsl: Implement tex*grad() functions. + vkd3d-shader/fx: Fix structure type data written for fx_4. + vkd3d-shader/fx: Write default numeric values. + vkd3d-shader/fx: Fix packed size for fx_4+ types. + vkd3d-shader/fx: Preserve parsing order of initializer components. + vkd3d-shader/fx: Add missing fields for structure types on fx_5_0. + vkd3d-shader/hlsl: Do not crash on initialization of a redefined variable. + vkd3d-shader/hlsl: Set default values for annotations variables. + vkd3d-shader/fx: Write annotations for fx_4+ profiles. + tests: Add some fx profiles tests for structure types containing objects. + vkd3d-shader: Disallow object structure fields for fx profiles. + vkd3d-shader/fx: Do not output empty strings for missing semantics for fx_2_0. + vkd3d-shader/hlsl: Allow annotations on global variables. + vkd3d-shader/fx: Correct empty pass check. + vkd3d-shader/fx: Set total pass count for fx_2_0. + vkd3d-shader/fx: Correct one of the object counters in the fx_2_0 header. + vkd3d-shader/fx: Decompose function-style state assignments to individual states. + vkd3d-shader/fx: Handle SetRasterizerState(). + vkd3d-shader/hlsl: Add parser support for ComputeShader, DomainShader, and HullShader types. + vkd3d-shader/fx: Fix state block entry array shifting when decomposing. + vkd3d-shader/fx: Add support for SetDomainShader(), SetComputeShader(), and SetHullShader() states. + vkd3d-shader/fx: Handle "Texture" field of the sampler state objects. + vkd3d-shader/fx: Use more descriptive names for FX-specific types. + vkd3d-shader/fx: Add an array size field to the states description table. + vkd3d-shader/fx: Add support for the OMSetRenderTargets() state. + vkd3d-shader/hlsl: Add parser support for GeometryShader type. + vkd3d-shader/fx: Check destination array index when checking for duplicate state entries. + vkd3d-shader/hlsl: Add parser support for BlendState type. + vkd3d-shader/fx: Enable writing BlendState variables. + vkd3d-shader/fx: Run full set of constants passes on state block entries values. + vkd3d-shader/fx: Handle states of a BlendState object. + vkd3d-shader/fx: Explicitly handle bool values in state entries. + vkd3d-shader/fx: Turn assignments to arrays to element assignments for certain states. + vkd3d-shader/hlsl: Check MS texture declaration without sample count only for used variables. + vkd3d-shader/hlsl: Handle NULL constants. + vkd3d-shader/hlsl: Add a test for assigning to DSV and RTV variables. + vkd3d-shader/hlsl: Tokenize 'String' the same as 'string'. + vkd3d-shader/hlsl: Treat "string" type name as case-insensitive. + vkd3d-shader/fx: Enable writing string objects for fx_4+. + vkd3d-shader/fx: Support string annotations for fx_4+. + vkd3d-shader/fx: Handle SetBlendState(). + vkd3d-shader/fx: Handle SetPixelShader() and SetVertexShader(). + vkd3d-shader/hlsl: Adjust NULL type properties to make it usable in transformations. + vkd3d-shader/fx: Support NULL constants for object fields. + vkd3d-shader/fx: Resolve NULL values for SamplerState.Texture field. + vkd3d: Fix a few typos in the comments. + vkd3d-shader/glsl: Fix a typo in a few messages. + include: Fix a few typos in the IDL files. + vkd3d-shader/fx: Fix the matrix type class for fx_2_0. -Petrichor Park (2): - vkd3d-shader/hlsl: Implement hyperbolic sin and cos. - vkd3d-shader/hlsl: Implement tanh. +Petrichor Park (5): + vkd3d-shader/hlsl: Implement the faceforward() intrinsic. + vkd3d-shader/hlsl: Implement tests for the rcp() intrinsic. + vkd3d-shader/hlsl: Implement the rcp() intrinisic. + vkd3d-shader/tpf: Implmenent HLSL_OP1_RCP. + vkd3d-shader/hlsl: Factor out add_binary_expr() and use it for assignment operators. -Stefan Dösinger (12): - vkd3d: Add ID3D12Device9 interface stubs. - vkd3d: Add an ID3D12ShaderCacheSession stub. - vkd3d: Validate and store shader cache session descriptors. - tests: Add tests for creating D3D12ShaderCacheSession objects. - tests: Add CreateShaderCacheSession pointer clearing tests. - vkd3d: Implement opening and closing shader caches. - vkd3d: Implement reopening existing caches. - vkd3d: Implement vkd3d_shader_cache_put. - vkd3d: Implement vkd3d_shader_cache_get. - vkd3d: Implement cache locking. - tests/d3d12: Add tests for storing and retrieving cache values. - vkd3d: Add a win32 version of vkd3d_get_program_name. +Shaun Ren (6): + vkd3d-shader/ir: Lower SM1 SINCOS to SM4 SINCOS. + vkd3d-shader/hlsl: Implement sin/cos for SM1. + vkd3d-shader/d3dbc: Implement HLSL_OP3_MAD for SM1. + vkd3d-shader/hlsl: Allocate registers for HLSL_OP1_{COS,SIN}_REDUCED with the required writemasks. + vkd3d-shader/d3dbc: Implement HLSL_OP1_{COS,SIN}_REDUCED for SM1. + vkd3d-shader/hlsl: Support default values for function parameters. -Victor Chiletto (4): - vkd3d-shader/hlsl: Avoid a null pointer dereference in hlsl_block_cleanup (UBSan). - tests/hlsl: Add a test for the XOR assign operator. - vkd3d-shader/hlsl: Fix XOR assign operator lexing. - vkd3d-shader/preproc: Treat CR as whitespace. +Stefan Dösinger (2): + include: Get rid of the RB_FOR_EACH* macros. + vkd3d: Pass a proper struct shader_cache_key * to rb_put() in vkd3d_shader_cache_add_entry(). + +Victor Chiletto (20): + tests: Add more register reservations tests. + vkd3d-shader/hlsl: Support expressions as register offsets. + vkd3d-shader/hlsl: Pass a pointer to struct hlsl_reg_reservation in parse_reservation_index. + vkd3d-shader/hlsl: Ignore bracket offsets for 'b' register types prior to SM 5.1. + vkd3d-shader/hlsl: Do not immediately fail parsing for malformed 'b' register reservations. + vkd3d-shader/hlsl: Validate cbuffer register allocations. + vkd3d-shader/hlsl: Reserve register slots for unused buffers. + tests: Add reflection tests for register expressions. + vkd3d-shader/d3dbc: Fix implicit enum conversion warning. + tests/hlsl: Add a test for dynamically indexed multisampled texture loads. + vkd3d-shader/hlsl: Use a switch in validate_static_object_references(). + vkd3d-shader/hlsl: Defer bounds checks to after copy propagation. + vkd3d-shader/hlsl: Pull evaluate_static_expression_as_uint() upwards. + vkd3d-shader/hlsl: Parse loop and unroll loop attributes. + vkd3d-shader/hlsl: Allow cloned blocks to contain external references. + vkd3d-shader/hlsl: Implement loop unrolling. + tests/hlsl: Test loop unrolling edge cases. + vkd3d-shader/hlsl: Implement the asint() intrinsic. + vkd3d-shader/hlsl: Push a new scope when compiling internal functions. + vkd3d-shader/hlsl: Implement f16tof32 intrinsic. + +Yuxuan Shui (2): + tests: Pass the correct buffer size to vsnprintf() in vkd3d_test_push_context(). + vkd3d-shader/hlsl: Implement storing to a swizzled matrix. ``` diff --git a/AUTHORS b/AUTHORS index b26c2819..2eb2985e 100644 --- a/AUTHORS +++ b/AUTHORS @@ -3,6 +3,7 @@ Alexandre Julliard Alistair Leslie-Hughes Andrew Eikum Andrey Gusev +Anna (navi) Figueiredo Gomes Atharva Nimbalkar Biswapriyo Nath Brendan Shanks @@ -33,8 +34,10 @@ Petrichor Park Philip Rebohle Rémi Bernon Robin Kertels +Shaun Ren Stefan Dösinger Sven Hesse Victor Chiletto Vinson Lee +Yuxuan Shui Zhiyi Zhang diff --git a/ChangeLog.md b/ChangeLog.md index 71472b71..bccf48f8 100644 --- a/ChangeLog.md +++ b/ChangeLog.md @@ -1,3 +1,89 @@ +# What's new in vkd3d 1.13 (29 August 2024) + +### libvkd3d + + - The ID3D12CommandList6 interface is supported. + + - Block-compressed textures can be created with unaligned dimensions. This + corresponds to + D3D12_FEATURE_D3D12_OPTIONS8.UnalignedBlockTexturesSupported. + + - Some minor issues pointed out by the Vulkan validation layers have been + addressed. These are not known to affect applications in practice, but + should make libvkd3d slightly more well-behaved. + +### libvkd3d-shader + + - New features for the HLSL source type: + - Basic loop unrolling support. Some of the more complicated cases like + loops containing conditional jumps are still unsupported. + - Initialisation values for global variables, function parameters, and + annotation variables are parsed and stored in output formats supporting + them. + - Shader model 5.1 register spaces are supported when using the + corresponding target profiles, as well as shader model 5.1 reflection + data. + - Register reservations support expressions as offsets. For example: + ‘float f : register(c0[1 + 1 * 2]);’ + - The tex1D(), tex2D(), tex3D(), and texCUBE() intrinsic function variants + with explicit derivatives are supported. + - The following intrinsic functions are supported: + - asint() + - f16tof32() + - faceforward() + - GetRenderTargetSampleCount() + - rcp() + - tex2Dbias() + - tex1Dgrad(), tex2Dgrad(), tex3Dgrad(), and texCUBEgrad() + - The sin() and cos() intrinsic functions are supported in shader model + 1-3 profiles. These were already supported in shader model 4+ profiles. + - The following features specific to effects target profiles: + - Types supported in version 4.0+: + - BlendState + - ComputeShader, DomainShader, GeometryShader, and HullShader + - DepthStencilState + - RasterizerState + - State application functions implemented for version 4.0+ effects: + - OMSetRenderTargets() + - SetBlendState() + - SetComputeShader(), SetDomainShader(), SetGeometryShader(), + SetHullShader(), SetPixelShader(), and SetVertexShader() + - SetDepthStencilState() + - SetRasterizerState() + - String types. These are mainly used for annotations. + - Annotations on global variables. + - Support for the ‘Texture’ field of the ‘SamplerState’ type. + - Support for NULL values. + - Stores to swizzled matrix variables. + - The ‘unsigned’ type modifier is supported. (For example, + ‘unsigned int’.) Note that ‘uint’ and related types were already + supported. + - ‘ConstantBuffer<>’ types. + - The ‘SV_Coverage’ output semantic for fragment shaders. + + - The experimental DXIL source type supports quad group operations. + + - The Direct3D shader model 2-3 ‘texldb’ instruction is correctly disassembled + when outputting Direct3D shader assembly. + + - New interfaces: + - The vkd3d_shader_parameter_info structure extends the + vkd3d_shader_compile_info structure, and can be used to specify shader + parameters. This is a more generic version of the shader parameter + interface for SPIR-V targets in struct vkd3d_shader_spirv_target_info. + - The VKD3D_SHADER_PARAMETER_DATA_TYPE_FLOAT32 enumeration value specifies + that a shader parameter contains 32-bit floating-point data. + - The VKD3D_SHADER_PARAMETER_NAME_ALPHA_TEST_FUNC shader parameter + specifies the alpha test function. + - The VKD3D_SHADER_PARAMETER_NAME_ALPHA_TEST_REF shader parameter + specifies the alpha test reference value. + - The VKD3D_SHADER_PARAMETER_NAME_FLAT_INTERPOLATION shader parameter + specifies the interpolation mode for colour inputs in Direct3D shader + model 1-3 fragment shaders. + - The VKD3D_SHADER_PARAMETER_TYPE_BUFFER enumeration value specifies that + the value of a shader parameter is provided at run-time through a buffer + resource. + # What's new in vkd3d 1.12 (28 May 2024) ### libvkd3d diff --git a/Makefile.am b/Makefile.am index 95b338c0..693d0a41 100644 --- a/Makefile.am +++ b/Makefile.am @@ -365,7 +365,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 11:0:10 +libvkd3d_shader_la_LDFLAGS = $(AM_LDFLAGS) -version-info 12:0:11 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 @@ -400,7 +400,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 13:0:12 +libvkd3d_la_LDFLAGS = $(AM_LDFLAGS) -version-info 14:0:13 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 @@ -413,7 +413,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 6:1:5 +libvkd3d_utils_la_LDFLAGS = $(AM_LDFLAGS) -version-info 6:2:5 libvkd3d_utils_la_LIBADD = libvkd3d-common.la libvkd3d-shader.la libvkd3d.la @PTHREAD_LIBS@ if HAVE_LD_VERSION_SCRIPT libvkd3d_utils_la_LDFLAGS += -Wl,--version-script=$(srcdir)/libs/vkd3d-utils/vkd3d_utils.map diff --git a/configure.ac b/configure.ac index 2a7a3e92..f104f557 100644 --- a/configure.ac +++ b/configure.ac @@ -1,5 +1,5 @@ AC_PREREQ([2.69]) -AC_INIT([vkd3d],[1.12]) +AC_INIT([vkd3d],[1.13]) AC_CONFIG_AUX_DIR([bin]) AC_CONFIG_MACRO_DIR([m4]) diff --git a/demos/demo_xcb.h b/demos/demo_xcb.h index becd740d..dd28ac59 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_12 +#define VKD3D_UTILS_API_VERSION VKD3D_API_VERSION_1_13 #include "config.h" #include #include diff --git a/include/vkd3d.h b/include/vkd3d.h index 3c50f18f..18a23448 100644 --- a/include/vkd3d.h +++ b/include/vkd3d.h @@ -97,6 +97,7 @@ enum vkd3d_api_version VKD3D_API_VERSION_1_10, VKD3D_API_VERSION_1_11, VKD3D_API_VERSION_1_12, + VKD3D_API_VERSION_1_13, VKD3D_FORCE_32_BIT_ENUM(VKD3D_API_VERSION), }; diff --git a/include/vkd3d_shader.h b/include/vkd3d_shader.h index fc583b54..d9a355d3 100644 --- a/include/vkd3d_shader.h +++ b/include/vkd3d_shader.h @@ -55,6 +55,7 @@ enum vkd3d_shader_api_version VKD3D_SHADER_API_VERSION_1_10, VKD3D_SHADER_API_VERSION_1_11, VKD3D_SHADER_API_VERSION_1_12, + VKD3D_SHADER_API_VERSION_1_13, VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_API_VERSION), }; diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index b978719a..deecc91e 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -228,7 +228,7 @@ enum vkd3d_shader_input_sysval_semantic vkd3d_siv_from_sysval_indexed(enum vkd3d #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 12 +#define VKD3D_SPIRV_GENERATOR_VERSION 13 #define VKD3D_SPIRV_GENERATOR_MAGIC vkd3d_make_u32(VKD3D_SPIRV_GENERATOR_VERSION, VKD3D_SPIRV_GENERATOR_ID) struct vkd3d_spirv_stream diff --git a/libs/vkd3d-utils/vkd3d_utils_main.c b/libs/vkd3d-utils/vkd3d_utils_main.c index 91e93b9d..b690aeb5 100644 --- a/libs/vkd3d-utils/vkd3d_utils_main.c +++ b/libs/vkd3d-utils/vkd3d_utils_main.c @@ -271,7 +271,7 @@ HRESULT WINAPI D3DCompile2(const void *data, SIZE_T data_size, const char *filen option = &options[0]; option->name = VKD3D_SHADER_COMPILE_OPTION_API_VERSION; - option->value = VKD3D_SHADER_API_VERSION_1_12; + option->value = VKD3D_SHADER_API_VERSION_1_13; compile_info.type = VKD3D_SHADER_STRUCTURE_TYPE_COMPILE_INFO; compile_info.next = &preprocess_info; @@ -403,7 +403,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_12}, + {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_13}, }; TRACE("data %p, size %"PRIuPTR", filename %s, macros %p, include %p, preprocessed_blob %p, messages_blob %p.\n", @@ -949,7 +949,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_12}, + {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_13}, }; 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 d9d200e4..682d488f 100644 --- a/libs/vkd3d/state.c +++ b/libs/vkd3d/state.c @@ -2286,7 +2286,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_12}, + {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_13}, {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)}, @@ -2341,7 +2341,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_12}, + {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_13}, {VKD3D_SHADER_COMPILE_OPTION_TYPED_UAV, typed_uav_compile_option(device)}, }; @@ -4019,7 +4019,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_12}, + {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_13}, }; info.type = VKD3D_SHADER_STRUCTURE_TYPE_COMPILE_INFO; diff --git a/programs/vkd3d-compiler/main.c b/programs/vkd3d-compiler/main.c index 18d92e8f..e2812d93 100644 --- a/programs/vkd3d-compiler/main.c +++ b/programs/vkd3d-compiler/main.c @@ -853,7 +853,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_12); + add_compile_option(&options, VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_13); if (options.target_type == VKD3D_SHADER_TARGET_SPIRV_BINARY || options.target_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 752cf248..de778ecf 100644 --- a/tests/shader_runner_gl.c +++ b/tests/shader_runner_gl.c @@ -547,7 +547,7 @@ static bool compile_shader(struct gl_runner *runner, ID3DBlob *blob, struct vkd3 const struct vkd3d_shader_compile_option options[] = { - {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_12}, + {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_13}, {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_vulkan.c b/tests/shader_runner_vulkan.c index 18864732..95e27186 100644 --- a/tests/shader_runner_vulkan.c +++ b/tests/shader_runner_vulkan.c @@ -484,7 +484,7 @@ static bool compile_shader(struct vulkan_shader_runner *runner, const char *sour option = &options[info.option_count++]; option->name = VKD3D_SHADER_COMPILE_OPTION_API_VERSION; - option->value = VKD3D_SHADER_API_VERSION_1_12; + option->value = VKD3D_SHADER_API_VERSION_1_13; compile_options = runner->r.compile_options; if (compile_options)