| Index | index by Group | index by Distribution | index by Vendor | index by creation date | index by Name | Mirrors | Help | Search |
| Name: vkd3d-devel-32bit | Distribution: openSUSE Tumbleweed |
| Version: 2.0 | Vendor: openSUSE |
| Release: 1.5 | Build date: Thu May 21 23:04:09 2026 |
| Group: Development/Libraries/X11 | Build host: reproducible |
| Size: 689 | Source RPM: vkd3d-2.0-1.5.src.rpm |
| Packager: https://bugs.opensuse.org | |
| Url: https://winehq.org | |
| Summary: Development headers for the Direct3D 12 to Vulkan translation library | |
This is a Direct3D 12 to Vulkan translation library for use by e.g. Wine. These are its development libraries and headers.
LGPL-2.1-or-later
* Thu May 21 2026 Simon Vogl <simon.vogl@gmx.net>
- Update to version 2.0:
- libvkd3d
Resources with a combined depth/stencil format like
DXGI_FORMAT_R32G8X24_TYPELESS can be created without the
D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL flag being set. It's
somewhat rare for applications to create such resources;
typically resources with a combined depth/stencil format are
either used with both a depth/stencil view and a shader
resource view, or exclusively with a depth/stencil view.
The syntax for the VKD3D_DEBUG environment variable has been
extended to allow more precise control over the debug output.
See the ‘Environment variables’ section of the README for a
description of the extended syntax.
- libvkd3d-shader
New features and improvements for the HLSL source type:
Store operations to structured thread group shared memory.
Interlocked operations on structured and/or arrayed
unordered access views and thread group shared memory.
A new common subexpression elimination optimisation pass.
Initial support for loops in shader model 2-3 target
profiles.
More efficient usage of temporary registers, primarily
due to improvements to the register allocator and the
introduction of an output write hoisting pass. This is
particularly relevant for shader model 1-3 target
profiles, where the number of temporary registers is
relatively limited, and we may otherwise not be able to
compile some shaders.
The tex3Dbias(), tex3Dlod(), and texCUBElod() intrinsic
functions.
The ‘SV_ClipDistance’ and ‘SV_CullDistance’ input/output
semantics.
The ‘SV_StencilRef’ pixel shader output semantic.
Corrected handling of InterlockedMin() and
InterlockedMax() operations on inputs with differing
signedness. When either of the inputs has an ‘uint’ type,
the other is converted/promoted to ‘uint’ as well.
The
VKD3D_SHADER_COMPILE_OPTION_BACKCOMPAT_MAP_SEMANTIC_NAMES
flag now additionally maps the shader model 3 ‘VFACE’ and
‘VPOS’ semantic names to their shader model 4+
equivalents.
Constant folding of floating-point modulo expressions.
I.e., ‘x % y’ where ‘x’ and ‘y’ are floating-point
constants.
The scope of variables declared in ‘for’ loop
initialisation clauses has been expanded to extend beyond
the end of the loop. I.e.,
‘for (int i = 0; i < 10; ++i); return i;’ is valid HLSL.
That's different from e.g. C99, where the scope of ‘i’
would be limited to the loop.
Floating-point literal parsing has been made independent
of the current locale. Previously, the HLSL parser would
use the current locale's decimal separator when parsing
floating-point literals, instead of the HLSL decimal
separator, which is always the ‘.’ character. Note that
this only affects programs that set a locale other than
the initial ‘C’ locale, for example by calling the
setlocale() function.
New features and improvements for the effects (FX) source
type:
Parsing of operand indices in eval() block was broken and
has been fixed.
The ‘umod’ FXLVM operation is recognised.
New features and improvements for the legacy Direct3D
byte-code source type:
The following instructions:
m4x4, m3x4, m4x3, m3x3, and m3x2
phase
texdepth
texreg2ar, texreg2gb, and texreg2rgb
The ‘_dz’, ‘_db’, ‘_dw’, and ‘_da’ source modifiers. These
are used with the ‘texcrd’ and ‘texld’ instructions.
The ‘vFace’ and ‘vPos’ pixel shader input registers.
Shader model 3 vertex shader point size outputs. In shader
model 1 and 2 point size output uses the ‘oPts’ output
register; shader model 3 uses a generic ‘o’ register with
a ‘dcl_psize’ declaration.
Shader model 1 and 2 vertex shader outputs are clamped to
the 0 to 1 range.
The DXIL source type supports forward-referencing pointers in
load, store, atomic read/modify/write, and compare/exchange
operations.
The DXIL source type supports pixel shader specified stencil
reference values.
The experimental Metal Shading Language (MSL) target supports
pixel shader specified stencil reference values.
The Direct3D shader assembly target supports 16-bit immediate
constants. These are typically produced by DXIL sources.
The Direct3D shader assembly target supports the following
global flags:
‘64UAVs’
‘ROVs’
‘UAVLoadAdditionalFormats’
‘UAVsAtEveryStage’
‘allResourcesBound’
‘enable11_1ShaderExtensions’
‘int64Ops’
‘nativeLowPrecision’
‘stencilRef’
‘viewportAndRTArrayIndex’
‘waveOps’
New interfaces:
The vkd3d_shader_scan_denormal_mode_info structure extends
the vkd3d_shader_compile_info structure, and can be used
to retrieve the denormal mode used for floating-point
numbers.
The VKD3D_SHADER_SPIRV_EXTENSION_KHR_FLOAT_CONTROLS
enumeration value indicates support for the
SPV_KHR_float_controls extension in the SPIR-V target
environment.
The VKD3D_SHADER_COMPILE_OPTION_DENORMAL_MODE_F16 compile
option specifies the denormal mode to use for 16-bit
floating-point numbers.
The VKD3D_SHADER_COMPILE_OPTION_DENORMAL_MODE_F32 compile
option specifies the denormal mode to use for 32-bit
floating-point numbers.
The VKD3D_SHADER_COMPILE_OPTION_DENORMAL_MODE_F64 compile
option specifies the denormal mode to use for 64-bit
floating-point numbers.
The VKD3D_SHADER_COMPILE_OPTION_CONST_GLOBAL_UNIFORMS flag
specifies that all uniforms with global scope should be
considered ‘const’ in HLSL sources.
When targeting VKD3D_SHADER_API_2_0, compilation will fail
when a required floating-point denormal mode can't be
specified in the target shader. For the SPIR-V target,
this requires the SPV_KHR_float_controls extension, as
well as the corresponding capabilities in the target
environment. The earlier mentioned compile options allow
overriding the denormal modes specified by the source
shader.
The syntax for the VKD3D_SHADER_DEBUG environment variable has
been extended to allow more precise control over the debug
output. See the ‘Environment variables’ section of the README
for a description of the extended syntax.
- libvkd3d-utils
The D3DCompile(), D3DCompile2(), D3DCompile2VKD3D(), and
D3DPreprocess() functions support using
D3D_COMPILE_STANDARD_FILE_INCLUDE as include handler.
Unless the D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY flags is
specified, D3DCompile2VKD3D() will consider all uniforms with
global scope to be ‘const’ for compiler versions 37 and up.
This is also the case for D3DCompile() and D3DCompile2(),
which behave like compiler version 47.
* Sat May 09 2026 Simon Vogl <simon.vogl@gmx.net>
- Update to version 1.19:
- libvkd3d
Barriers are inserted as required between render passes
targeting the same images. Typical desktop GPUs tend to not
care much about these, but this is important for correctness
on tile-based renderers.
The ‘minimum’ and ‘maximum’ texture filtering reduction modes
are supported.
- libvkd3d-shader
Much improved handling of clip and cull distance shader
input/output arrays for SPIR-V targets. Direct3D source
formats represent clip and cull distances as 2 4-component
registers, while SPIR-V represents them as scalar arrays. The
previous code for mapping between these conventions was
unfortunately relatively fragile and unable to handle a number
of cases.
Several new features and improvements for the HLSL source
type:
Effects (FX) target profiles can output embedded shader
blobs. These are created by the CompileShader() and
ConstructGSWithSO() intrinsic functions.
Statically initialised variables are considered to be
static expressions. For example,
‘int count = 4; float4 array[count];’ is now accepted as
valid by the compiler.
Store operations to ‘RWStructuredBuffer’ resources.
Load operations from structured thread group shared
memory.
Copy operations involving structured resources.
Casts of floating-point constants to Boolean values now
correctly fold any non-zero value to ‘true’. Previously
‘(bool)0.25f’ for example would get constant folded to
‘false’.
The ‘static’ storage-class specifier is allowed on
functions.
The ‘Buffer’, ‘StructuredBuffer’, and ‘ByteAddressBuffer’
types are supported in effects (FX) target profiles.
The following legacy Direct3D byte-code instructions are
implemented:
dp2add
loop/endloop
lrp
nrm
pow
rep/endrep
When the VKD3D_SHADER_DUMP_PATH environment variable is used
to dump input and output shaders, compilation messages like
errors and warnings produced by the compiler will be dumped as
well.
New interfaces:
The VKD3D_SHADER_PARAMETER_NAME_PROJECTED_TEXTURE_MASK
shader parameter specifies which textures in a shader
model 1.0-1.3 pixel shader should be considered to be
projected textures.
- build
New environment variables:
VKD3D_TEST_WRAPPER can be used to wrap test execution.
* Wed Jan 14 2026 Simon Vogl <simon.vogl@gmx.net>
- Update to version 1.18:
- libvkd3d
The CreateCommandList1() method of the ID3D12Device4 interface
is implemented.
- libvkd3d-shader
Several new features and improvements for the HLSL source
type:
Flattening of branched code. I.e., code using if/else
statements can beturned into conditional moves when that's
either advantageous or necessary. Cases where this is
necessary include targeting shader model 2.0 or earlier, as
well as code using the ‘flatten’ attribute.
More constant folding improvements. For example:
Iasfloat(), asint(), asuint(), cos(), mad(), round(), and
sin() operations are constant folded.
‘true ? x : y’ is folded to ‘x’
‘x ? true : false’ is folded to ‘x’
‘||x||’ is folded to ‘|x|’
‘~~x’ is folded to ‘x’
‘x < 0’ is folded to ‘false’ for unsigned ‘x’
The following intrinsic functions:
countbits()
firstbithigh()
firstbitlow()
frexp()
texCUBEbias()
Integer-typed conditional expressions in shader model 1-3
target profiles. Previously these were only supported in
shader model 4+ target profiles.
Resource loads from ‘StructuredBuffer’ resources.
‘centroid’ interpolation modifiers in shader model 1-3
target profiles.
Support for ‘_centroid’ modifier suffixes on I/O semantics.
I.e., ‘float2 t : TEXCOORD0_centroid’ is equivalent to
‘centroid float2 t : TEXCOORD0’.
The following legacy Direct3D byte-code instructions are
implemented:
bem
tex
texbem
texbeml
texcoord
The experimental Metal Shading Language (MSL) target supports
the following features:
Compute shaders.
Immediate-constant buffers.
Standard, inverse, and hyperbolic trigonometric functions.
Integer division and remainder operations.
Floating-point remainder operations.
Bit scanning and counting operations.
Boolean operands, as produced by DXIL sources.
Barrier operations.
When the experimental MSL target is enabled, the ‘hlsl’ source
type can be used in combination with the ‘msl’ target type to
convert HLSL shaders to MSL.
Signed integer operations like min() and max() are correctly
translated from DXIL to MSL. Previously these would end up
getting translated as unsigned operations, and would thus
mishandle negative values.
The experimental OpenGL Shading Language (GLSL) target
supports the following features:
Screen-space partial derivatives.
sin() and cos() operations.
Unsigned integer division and remainder operations.
Static texel offsets on texture load operations.
‘SV_Coverage’ fragment shader outputs.
‘SV_InstanceID’ inputs.
Textual output formats are documented to have a zero byte
following their output. This can be convenient for passing
such output to functions expecting a null-terminated string.
For some output formats this was already true in earlier
versions of vkd3d, but not guaranteed by the API.
New interfaces:
The vkd3d_shader_d3dbc_source_info structure extends the
vkd3d_shader_compile_info structure, and can be used to
specify auxiliary information for legacy Direct3D byte-code
(‘d3dbc’) shaders that's necessary for target formats like
SPIR-V and GLSL, but not specified by ‘d3dbc’ shaders.
In particular, it allows specifying resource/sampler types
for shader model 1 fragment shaders, as well as which
samplers are comparison-mode samplers for shader model 1-3
shaders.
The vkd3d_shader_scan_thread_group_size_info structure
extends the vkd3d_shader_compile_info structure, and can be
used to to retrieve the thread group size expected by a
compute shader. This information is particularly useful when
targeting Metal environments, because the Metal API requires
the thread group size to be specified through its dispatch
API, instead of being specified by the shader.
The VKD3D_SHADER_PARAMETER_NAME_BUMP_LUMINANCE_OFFSET_[0-5]
shader parameters specify the corresponding bump-mapping
luminance offsets.
The VKD3D_SHADER_PARAMETER_NAME_BUMP_LUMINANCE_SCALE_[0-5]
shader parameters specify the corresponding bump-mapping
luminance scale factors.
The VKD3D_SHADER_PARAMETER_NAME_BUMP_MATRIX_[0-5] shader
parameters specify the corresponding bump-mapping
transformation matrices.
* Sun Aug 24 2025 Marcus Meissner <meissner@suse.com>
- Update to version 1.17:
- Initial HLSL support for thread group shared memory.
- Several features have been implemented for the experimental Metal Shading Language target.
- Miscellaneous bug fixes.
* Thu Jun 12 2025 Simon Vogl <simon.vogl@gmx.net>
- Update to version 1.16:
- libvkd3d
DXIL shaders are supported in the default configuration.
Previously this required building vkd3d with the
‘-DVKD3D_SHADER_UNSUPPORTED_DXIL’ preprocessor option. The
also raises the maximum supported shader model to version 6.0.
Graphics pipeline state objects can be created from shaders
with embedded root signatures. This was already possible for
compute pipeline state objects.
The SetEventOnMultipleFenceCompletion() method of the
ID3D12Device1 interface is implemented.
When the VK_KHR_zero_initialize_workgroup_memory extension is
supported, libvkd3d supports zero-initialising compute shader
thread group shared memory.
The VK_KHR_maintenance2 extension is now explicitly required.
libvkd3d already unconditionally used features provided by
this extension, but unfortunately didn't explicitly require it.
Support for this extension is widespread, and the extension is
part of Vulkan 1.1.
- libvkd3d-shader
The previously experimental support for compiling DXIL shaders
is now a supported feature and enabled by default. Please note
that this feature is nevertheless still far from perfect.
New features for the HLSL source type:
Initial support for geometry shaders.
Indirect addressing in shader model 1-3 target profiles.
Modulus and truncation operations in shader model 1-3 target
profiles.
Vectorised output code.
Further improved constant folding and propagation.
The following intrinsic functions are supported:
AllMemoryBarrier()
AllMemoryBarrierWithGroupSync()
DeviceMemoryBarrier()
DeviceMemoryBarrierWithGroupSync()
GroupMemoryBarrier()
GroupMemoryBarrierWithGroupSync()
The ‘.Length’ Texture object property.
The ‘SV_RenderTargetArrayIndex’ and ‘SV_ViewportArrayIndex’
semantics in tessellation shaders.
Disassembler support for binary ‘fx_2_0’ effects.
Experimental built-in support for disassembling SPIR-V
shaders, enabled by building vkd3d with the
‘-DVKD3D_SHADER_UNSUPPORTED_SPIRV_PARSER’ preprocessor option.
When enabled, the built-in SPIR-V disassembler is used instead
of SPIRV-Tools for the ‘spirv-text’ target type, as well as
for the debug output enabled by the VKD3D_SHADER_DEBUG
environment variable.
The experimental OpenGL Shading Language (GLSL) target
supports indirect addressing of constant buffers.
The experimental Metal Shading Language (MSL) target supports
texture loads.
New interfaces:
The VKD3D_SHADER_COMPILE_OPTION_FEATURE_ZERO_INITIALIZE
_WORKGROUP_MEMORY flag indicates support for
zero-initialising workgroup memory in the SPIR-V target
environment.
The VKD3D_SHADER_COMPONENT_INT64 enumeration value indicates
a 64-bit signed integer value.
The VKD3D_SHADER_COMPONENT_FLOAT16 enumeration value
indicates a 16-bit IEEE floating-point value.
The VKD3D_SHADER_COMPONENT_UINT16 enumeration value
indicates a 16-bit unsigned integer value.
The VKD3D_SHADER_COMPONENT_INT16 enumeration value indicates
a 16-bit signed integer value.
When targeting VKD3D_SHADER_API_1_16, the
VKD3D_SHADER_RESOURCE_DATA_NONE enumeration value is
returned for the ‘resource_data_type’ field in the
vkd3d_shader_descriptor_info structure for sampler
descriptors. VKD3D_SHADER_API_1_15 and before use the
VKD3D_SHADER_RESOURCE_DATA_UINT enumeration value for this.
- demos
The vkd3d demos now work on both the Microsoft Windows and
Apple macOS builds. The macOS versions of the vkd3d demos are
completely new in vkd3d 1.16, while the Windows demos could
previously be built, but only worked on Wine. Note that the
vkd3d demos produced by a Windows build of vkd3d are distinct
from those produced by the ‘make crosstest’ target: the former
are Vulkan applications using vkd3d, while the latter are
Direct3D 12 applications.
The vkd3d demos have basic support for DPI scaling.
- build
Perl and the ‘JSON’ Perl module have been added as build
dependencies.
These are used for the experimental built-in SPIR-V
disassembler, as well as for the macOS versions of the vkd3d
demos.
* Wed Mar 05 2025 llyyr <llyyr@yukari.in>
- Update to version 1.15:
- libvkd3d
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’.
* Sat Nov 23 2024 Simon Vogl <simon.vogl@gmx.net>
- Update to version 1.14:
- 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.
- libvkd3d-shader
Too long for changelog, for full changes, visit:
https://gitlab.winehq.org/wine/vkd3d/-/blob/master/ChangeLog.md
- 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.
- 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 ‘fx’ source type specifies binary Direct3D effects.
The ‘msl’ target type specifies Metal Shading Language
shaders.
* Thu Oct 31 2024 Richard Rahl <rrahl0@opensuse.org>
- generate demo and docs, seperating them out into their own packages
- be more explicit with buildflags, enabling opengl
- write the spec file in more modern layout
* Sat Sep 28 2024 Simon Vogl <simon.vogl@gmx.net>
- Update to version 1.13:
- 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.
* Thu Mar 07 2024 Tobias Klausmann <tobias.klausmann@freenet.de>
- Update to version 1.11:
- libvkd3d
Descriptor updates happen asynchronously on an internal worker thread, for
a minor performance improvement in applications that update many
descriptors per frame.
When the VK_EXT_mutable_descriptor_type extension is available, libvkd3d
will make more efficient use of descriptor pools and sets.
When the VK_EXT_shader_viewport_index_layer extension is available,
libvkd3d supports indexing viewport and render target arrays from vertex
and tessellation evaluation shaders.
Support for standard (i.e., black and white) border colours is implemented.
The GetResourceAllocationInfo1() method of the ID3D12Device4 interface is
implemented.
The ID3D12Device7 and ID3D12Resource2 interface is supported.
Several new feature queries are supported: D3D12_FEATURE_D3D12_OPTIONS6,
D3D12_FEATURE_D3D12_OPTIONS7, D3D12_FEATURE_D3D12_OPTIONS8,
D3D12_FEATURE_D3D12_OPTIONS9, D3D12_FEATURE_D3D12_OPTIONS10,
D3D12_FEATURE_D3D12_OPTIONS11, D3D12_FEATURE_D3D12_OPTIONS12 and
D3D12_FEATURE_D3D12_OPTIONS13
- libvkd3d-shader
Initial support for compiling legacy Direct3D bytecode to SPIR-V.
Experimental support for compiling DirectX Intermediate Language (DXIL) to
SPIR-V and Direct3D shader assembly. Being an experimental feature, this
requires building vkd3d with the ‘-DVKD3D_SHADER_UNSUPPORTED_DXIL’
preprocessor option. Note that enabling this feature will affect the
capabilities reported by libvkd3d as well, and may cause previously working
applications to break due to attempting to use incomplete DXIL support. No
API or ABI stability guarantees are provided for experimental features.
New features for the HLSL source type:
Initial support for the ‘fx_2_0’, ‘fx_4_0’, ‘fx_4_1’, and ‘fx_5_0’
profiles, using the new ‘VKD3D_SHADER_TARGET_FX’ target type.
Support for ‘Buffer’ resources.
The acos(), asin(), atan(), and atan2() intrinsic functions are supported.
Explicit register assignment using the ‘register()’ keyword in shader model
1-3 profiles. This was previously only supported in shader model 4+
profiles.
Casts from integer to floating-point types in shader model 1-3 profiles.
Support for various input/output semantics:
SV_InstanceID in shader model 4+ fragment shaders.
SV_PrimitiveID in shader model 4+ fragment shaders. In previous versions
this was only supported in shader model 4+ geometry shaders.
SV_RenderTargetArrayIndex in shader model 4+ vertex and fragment shaders.
SV_ViewportArrayIndex in shader model 4+ vertex and fragment shaders.
Support for various rasteriser-ordered view types. Specifically:
RasterizerOrderedBuffer, RasterizerOrderedStructuredBuffer,
RasterizerOrderedTexture1D, RasterizerOrderedTexture1DArray,
RasterizerOrderedTexture2D, RasterizerOrderedTexture2DArray,
RasterizerOrderedTexture3D
New features for the SPIR-V target type:
Support for globally coherent unordered access views. These have the
‘globallycoherent’ storage class in HLSL, and the ‘_glc’ suffix in Direct3D
assembly.
Support for thread group unordered access view barriers. This corresponds
to ‘sync_ugroup’ instructions in Direct3D assembly.
When the SPV_EXT_viewport_index_layer extension is supported, vertex and
tessellation evaluation shaders can write render target and viewport array
indices. This corresponds to the ‘SV_RenderTargetArrayIndex’ and
‘SV_ViewportArrayIndex’ HLSL output semantics.
New interfaces:
The VKD3D_SHADER_COMPILE_OPTION_FEATURE compile option can be used to
specify features available in the target environment. The
VKD3D_SHADER_COMPILE_OPTION_FEATURE_INT64 flag indicates support for 64-bit
integer types in the SPIR-V target environment. The
VKD3D_SHADER_COMPILE_OPTION_FEATURE_FLOAT64 flag indicates support for
64-bit floating-point types in the SPIR-V target environment. For backward
compatibility, VKD3D_SHADER_API_VERSION_1_10 and earlier also imply support
for 64-bit floating-point types.
The VKD3D_SHADER_SPIRV_EXTENSION_EXT_VIEWPORT_INDEX_LAYER enumeration value
indicates support for the SPV_EXT_viewport_index_layer extension in the
SPIR-V target environment.
- libvkd3d-utils
When available, the following Vulkan extensions are enabled by
D3D12CreateDeviceVKD3D() and D3D12CreateDevice(): VK_KHR_android_surface,
VK_KHR_wayland_surface, VK_KHR_win32_surface, VK_KHR_xlib_surface,
VK_EXT_metal_surface, VK_MVK_ios_surface
Previous versions of vkd3d-utils enabled VK_KHR_xcb_surface and
VK_MVK_macos_surface. In practice this means that D3D12CreateDevice() /
D3D12CreateDeviceVKD3D() can be used on the corresponding additional window
systems.
New interfaces:
D3DReflect() is used to retrieve information about shaders. It currently
supports retrieving information about input, output, and patch constant
parameters using the ID3D12ShaderReflection interface.
D3DDisassemble() is used to disassemble legacy Direct3D bytecode (shader
model 1-3) and ‘Tokenized Program Format’ (shader model 4 and 5) shaders.
- vkd3d-compiler
The new ‘fx’ target is used for outputting Direct3D effects when compiling
HLSL ‘fx_2_0’, ‘fx_4_0’, ‘fx_4_1’, and ‘fx_5_0’ profiles.
- build
The minimum required version of Vulkan-Headers for this release is version
1.3.228.
* Thu Dec 07 2023 Tobias Klausmann <tobias.klausmann@freenet.de>
- Update to version 1.10:
- libvkd3d
Creating pipeline state objects from pipeline state stream descriptions is
implemented.
Depth-bounds testing is implemented.
When the VK_KHR_maintenance2 extension is available, libvkd3d will
explicitly specify the usage flags of Vulkan image views. This is
particularly useful on MoltenVK, where 2D-array views of 3D textures are
subject to usage restrictions.
The D3D12_FORMAT_SUPPORT2_UAV_TYPED_LOAD and/or
D3D12_FORMAT_SUPPORT2_UAV_TYPED_STORE feature flags are reported for
UAV formats when the ‘shaderStorageImageReadWithoutFormat’ and/or
‘shaderStorageImageWriteWithoutFormat’ Vulkan device features are supported.
The ID3D12Device5 interface is supported.
The ID3D12GraphicsCommandList5 interface is supported.
The ID3D12Resource1 interface is supported.
- libvkd3d-shader
New features for the HLSL source type:
Support for the following intrinsic functions: ceil(), degrees(), radians(),
fwidth(), tan() tex2Dlod(), tex2Dproj(), texCUBEproj(), and tex3Dproj()
Constant folding support for more expression types. In particular:
ternary operators and branches, reciprocal square roots, exponentials,
logical ‘not’ on booleans, bitwise complements, left/right shifts, ceil(),
floor(), frac(), and saturate()
Support for dynamic indexing of arrays.
Support for ‘break’ and ‘continue’ statements.
Support for ‘switch’ statements.
The ‘linear’, ‘centroid’, and ‘noperspective’ interpolation modifiers are
supported.
The ‘RWTexture1DArray’ and ‘RWTexture2DArray’ unordered access view types
are supported.
‘[loop]’ attributes are accepted on loops.
u/U and l/L suffixes on integer constants.
Floating-point values are explicitly clamped to the upper and lower bounds
of the target type by ‘ftoi’ and ‘ftou’ instructions when targeting SPIR-V.
Similarly, NaNs are flushed to zero. Some hardware/drivers would already do
this implicitly, but behaviour for such inputs is undefined as far as
SPIR-V is concerned.
The VKD3D_SHADER_CONFIG environment variable can be used to modify the
behaviour of libvkd3d-shader at run-time, analogous to the existing
VKD3D_CONFIG environment variable for libvkd3d. See the README for a list
of supported options.
When scanning legacy Direct3D bytecode using vkd3d_shader_scan(),
descriptor information for shader model 2 and 3 combined resource-sampler
pairs is returned in the vkd3d_shader_scan_descriptor_info structure.
Note that this information is not yet available for shader model 1 sources,
although this will likely be added in a future release.
The Direct3D shader assembly target supports the ‘rasteriser ordered view’
flag (‘_rov’) on unordered access view declarations.
New interfaces:
The VKD3D_SHADER_COMPILE_OPTION_BACKWARD_COMPATIBILITY compile option can
be used to specify backward compatibility options. The
VKD3D_SHADER_COMPILE_OPTION_BACKCOMPAT_MAP_SEMANTIC_NAMES flag is the only
currently supported flag, and can be used to specify that shader model 1-3
semantic names should be mapped to their shader model 4+ system value
equivalents when compiling HLSL sources.
The VKD3D_SHADER_COMPILE_OPTION_FRAGMENT_COORDINATE_ORIGIN compile option
can be used to specify the origin of fragment coordinates for SPIR-V
targets. This is especially useful in OpenGL environments, where the origin
may be different than in Direct3D or Vulkan environments.
The vkd3d_shader_scan_combined_resource_sampler_info structure extends the
vkd3d_shader_compile_info structure, and can be used to retrieve
information about the combined resource-sampler pairs used by a shader.
This is especially useful when compiling shaders for usage in environments
without separate binding points for samplers and resources, like OpenGL.
vkd3d_shader_free_scan_combined_resource_sampler_info() is used to free
vkd3d_shader_scan_combined_resource_sampler_info structures.
- libvkd3d-utils
Passing the D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY flag to D3DCompile()
and D3DCompile2() will enable mapping shader model 1-3 semantic names to
their shader model 4+ system value equivalents.
New interfaces:
D3DGetBlobPart() is used to retrieve specific parts of DXBC blobs.
D3DGetDebugInfo() is used to retrieve debug information from DXBC blobs.
D3DGetInputAndOutputSignatureBlob() is used to retrieve input and output
signatures from DXBC blobs.
D3DGetInputSignatureBlob() is used to retrieve input signatures from DXBC
blobs.
D3DGetOutputSignatureBlob() is used to retrieve output signatures from DXBC
blobs.
D3DStripShader() is used to remove specific parts from DXBC blobs.
- vkd3d-compiler
The ‘--fragment-coordinate-origin’ option can be used to specify the origin
of fragment coordinates for SPIR-V targets.
The ‘--semantic-compat-map’ option can be used to specify that shader model
1-3 semantic names should be mapped to their shader model 4+ system value
equivalents when compiling HLSL sources.
- vkd3d-dxbc
The ‘--list’ and ‘--list-data’ options now also output the offsets of
sections inside the input data.
- build
The minimum required version of Vulkan-Headers for this release is version
1.2.148.
When available, the libEGL and libOpenGL libraries are used to run the
vkd3d tests in additional configurations. These libraries are not used by
vkd3d itself.
The SONAME_LIBDXCOMPILER configure variable can be used specify the shared
object name of the dxcompiler library. When available, it's used to run the
vkd3d tests in additional configurations. The dxcompiler library is not
used by vkd3d itself.
* Sat Sep 23 2023 Tobias Klausmann <tobias.klausmann@freenet.de>
- Update to version 1.9:
- libvkd3d
Copying between depth/stencil and colour formats in
ID3D12GraphicsCommandList::CopyResource() is supported.
The ID3D12Fence1 interface is supported.
- libvkd3d-shader
vkd3d_shader_scan() supports retrieving descriptor information for d3dbc'
shaders. This is one of the requirements for eventual SPIR-V generation
from d3dbc' sources.
New features for the HLSL source type:
Support for the following intrinsic functions: clip(), ddx_coarse(),
ddy_coarse(), ddx_fine(), ddy_fine(), tex1D(), tex2D(), texCUBE(), and
tex3D()
Constant folding support for more expression types. In particular:
comparison operators, floating-point min(), max(), logical and' and or',
dot products, square roots and logarithms
Support for multi-sample texture object declarations without explicit
sample counts in shader model 4.1 and later shaders.
Support for using constant expressions as sample counts in multi-sample
texture object declarations.
Support for variable initialisers using variables declared earlier in the
same declaration list. E.g., `float a = 1, b = a, c = b + 1;'.
The GetDimensions() texture object method is implemented.
Matrix swizzles are implemented.
Parser support for if-statement attributes like [branch]' and [flatten]'.
Support for the `inline' function modifier.
Previously, vkd3d_shader_compile() would in some cases return VKD3D_OK
despite compilation failing when targeting legacy Direct3D bytecode. These
cases have been fixed.
Various HLSL preprocessor fixes for edge cases related to stringification.
SPIR-V target support for the `linear noperspective centroid' input
interpolation mode.
New interfaces:
The vkd3d_shader_scan_signature_info structure extends the
vkd3d_shader_compile_info structure, and can be used to retrieve
descriptions of dxbc-tpf' and d3dbc' shader inputs and outputs.
vkd3d_shader_free_scan_signature_info() is used to free
vkd3d_shader_scan_signature_info structures.
The VKD3D_SHADER_COMPILE_OPTION_PACK_MATRIX_ORDER compile option can be
used to specify the default matrix packing order for HLSL sources.
The vkd3d_shader_varying_map_info structure extends the
vkd3d_shader_compile_info structure, and can be used to specify a mapping
between the outputs of a shader stage and the inputs of the next shader
stage.
vkd3d_shader_build_varying_map() is used to build a mapping between the
outputs of a shader stage and the inputs of the next shader stage.
The VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_RAW_BUFFER flag returned as part of
the vkd3d_shader_descriptor_info structure indicates the descriptor refers
to a byte-addressed (`raw') buffer resource.
- vkd3d-compiler
The `--matrix-storage-order' option can used to specify the default matrix
storage order for HLSL sources.
- vkd3d-dxbc
vkd3d-dxbc is a new utility that can be used to inspect the contents of DXBC
blobs.
* Sun Aug 06 2023 Tobias Klausmann <tobias.klausmann@freenet.de>
- Update to version 1.8:
- Performance improvements have been made to the code that handles descriptor
updates. In some applications the improvement can be quite significant.
- Host-visible descriptor heaps are persistently mapped on creation. Some
applications access resource data from the CPU after calling Unmap(), and
that's supposed to work in practice.
- 1-dimensional texture unordered-access views and shader resource views are
implemented.
- Shader resource view, unordered access view, and constant buffer view root
descriptors with NULL GPU addresses are supported.
- Direct3D 12 descriptor heap destruction is delayed until all contained
resources are destroyed.
- libvkd3d-shader
- New features for the HLSL source type:
- Support for the ternary conditional operator "?:".
- Support for "discard" statements.
- Support for the "packoffset" keyword.
- Support for semantics on array types.
- Support for RWBuffer loads and stores.
- Register allocation for arrays and structures of resources and samplers
is implemented.
- Support for the SV_IsFrontFace pixel shader system-value semantics.
- Support for using constant expressions as array sizes and indices.
- Support for dynamic selection of vector components.
- Support for the following intrinsic functions: D3DCOLORtoUBYTE4(),
any(), asfloat(), ddx(), ddy(), fmod(), log(), log2(), log10(), sign()
and trunc().
- The SampleBias(), SampleCmp(), SampleCmpLevelZero(), and SampleGrad()
texture object methods are implemented.
- Support for the case-insensitive variants of the "vector" and "matrix"
data types.
- Parser support for the "unroll" loop attribute. A warning is output for
"unroll" without iteration count, and an error is output when an
iteration count is specified. Actual unrolling is not implemented yet.
- Parser support for RWStructuredBuffer resources.
- Parser support for SamplerComparisonState objects. Note that outputting
compiled effects is not supported yet, but parsing these allows shaders
containing SamplerComparisonState state objects to be compiled.
- More improvements to HLSL support for the Direct3D shader model 1/2/3
profiles.
- The section alignment of DXBC blobs produced by
vkd3d_shader_serialize_dxbc() matches those produced by d3dcompiler more
closely.
- The "main" function for shaders produced by the SPIR-V target is always
terminated, even when the source was a TPF shader without explicit "ret"
instruction.
- Relative addressing of shader input registers is supported by SPIR-V
targets.
* Wed May 17 2023 Tobias Klausmann <tobias.klausmann@freenet.de>
- Update to version 1.7.1:
- Release 1.7 has a bug that causes an internal mutex in its command queue
implementation to be unlocked too early under certain usage patterns. This
is known to further cause internal inconsistencies that manifest as program
deadlocks for some programs. In release 1.7.1 the mutex is correctly kept
locked until required.
- Symbol D3D12CreateDevice is mistakenly not exported in release 1.7,
breaking library clients that need it. The symbol is exported again in
release 1.7.1.
* Sat Apr 01 2023 Tobias Klausmann <tobias.klausmann@freenet.de>
- Update to version 1.7:
- Support for many more HLSL features and intrinsics.
- Much improved support for the Direct3D shader model 1/2/3 HLSL profiles.
- Public vkd3d-shader API for parsing and serialising DXBC blobs.
- Miscellaneous bug fixes.
/usr/lib/libvkd3d-shader.so /usr/lib/libvkd3d-utils.so /usr/lib/libvkd3d.so /usr/lib/pkgconfig/libvkd3d-shader.pc /usr/lib/pkgconfig/libvkd3d-utils.pc /usr/lib/pkgconfig/libvkd3d.pc
Generated by rpm2html 1.8.1
Fabrice Bellet, Sun Aug 2 01:54:38 2026