Release 1.14.

I/O normalisation is already a rather complicated pass that does a
lot of things, so it's better to keep anything not strictly
related to it somewhere else.

AUTHORS

@@ -4,6 +4,7 @@ Alistair Leslie-Hughes
 Andrew Eikum
 Andrey Gusev
 Anna (navi) Figueiredo Gomes
+Arkadiusz Hiler
 Atharva Nimbalkar
 Biswapriyo Nath
 Brendan Shanks
@@ -15,6 +16,7 @@ Elizabeth Figura
 Ethan Lee
 Evan Tang
 Fabian Maurer
+Feifan He
 Florian Weimer
 Francisco Casas
 Francois Gouget

ChangeLog.md

@@ -1,3 +1,130 @@
+# What's new in vkd3d 1.14 (21 November 2024)
+
+### 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
+
+  - New features for the HLSL source type:
+    - Interstage I/O variable packing matches d3dcompiler/fxc more closely.
+    - The following intrinsic functions are supported:
+      - dst()
+      - f32tof16()
+      - mad()
+      - modf()
+      - sincos()
+    - ‘discard’ support for shader model 1-3 target profiles.
+    - The ‘SV_SampleIndex’ input semantic for fragment shaders.
+    - The ‘SV_GroupIndex’ input semantic for compute shaders.
+    - The ‘earlydepthstencil’ function attribute.
+    - Constant folding of expressions like ‘x && c’ and ‘x || c’, where ‘c’ is a
+      constant.
+    - Preprocessor support for namespaces in macro identifiers. I.e., syntax
+      like ‘#define NAME1::NAME2::NAME3 1’ works as intended now.
+    - Structure inheritance. Multiple inheritance is not supported.
+    - Register assignments for unused constant buffers are allowed to overlap
+      register assignments for used constant buffers.
+    - Instruction count reflection data for shader model 4+ target profiles.
+      This data is contained in the ‘STAT’ DXBC section, and can be queried with
+      the GetDesc() method of the ID3D11ShaderReflection and
+      ID3D12ShaderReflection interfaces. Note that the ID3D12ShaderReflection
+      implementation provided by vkd3d-utils does not currently correctly report
+      this information.
+    - ‘unorm’ and ‘snorm’ resource format modifiers. For example,
+      ‘Texture2D<unorm float4> t;’
+    - Parser support for ‘ByteAddressBuffer’ resources, as well as their
+      Load()/Load2()/Load3()/Load4() methods.
+    - Parser support for ‘RWByteAddressBuffer’ resources, as well as their
+      Store()/Store2()/Store3()/Store4() methods.
+    - Parser support for the ‘compile’ keyword, as well as the CompileShader()
+      and ConstructGSWithSO() intrinsic functions. Actual compilation of
+      embedded shaders is not implemented yet, but parser support is sufficient
+      for allowing compilation of HLSL sources containing this syntax to succeed
+      when targetting shader target profiles like ‘vs_5_0’ or ‘ps_5_0’.
+    - Initial support for tessellation shaders. Only the most trivial shaders
+      are supported in this release. Perhaps most notably, both ‘InputPatch’ and
+      ‘OutputPatch’ are not implemented yet.
+
+  - The new ‘fx’ source type can be used in combination with the ‘d3d-asm’
+    target type to disassemble binary effects.
+
+  - More complete support for fx_2_0 binary effect output, including support for
+    annotations, default values, as well as object initialiser data used for e.g.
+    string, texture, and shader objects.
+
+  - A significant number of instructions have been implemented for the
+    experimental GLSL target. The GLSL output currently targets version 4.40
+    without extensions, but the intention is to make this configurable in a
+    future release of vkd3d.
+
+  - Experimental support for Metal Shading Language (MSL) output, enabled by
+    building vkd3d with the ‘-DVKD3D_SHADER_UNSUPPORTED_MSL’ preprocessor
+    option. The current release is only able to compile the most basic shaders
+    when targetting MSL. Being an experimental feature, both the ABI and API may
+    change in future releases; the feature may even go away completely.
+    Nevertheless, we hope our users find this feature useful, and welcome
+    feedback and contributions.
+
+  - Shader code generation for various legacy fixed-function features, including
+    clip planes, point sizes, and point sprites. This is mainly relevant for
+    executing shader model 1-3 sources in modern target environments like
+    Vulkan, because those target environments do not implement equivalent
+    fixed-function features.
+
+  - The amount of shader validation done by the internal validator has been
+    greatly extended. The validator is enabled by the ‘force_validation’ option,
+    specified through the VKD3D_SHADER_CONFIG environment variable.
+
+  - New interfaces:
+    - The VKD3D_SHADER_COMPILE_OPTION_DOUBLE_AS_FLOAT_ALIAS flag specifies that
+      the ‘double’ type behaves as an alias for the ‘float’ type in HLSL sources
+      with shader model 1-3 target profiles.
+    - The VKD3D_SHADER_PARAMETER_DATA_TYPE_FLOAT32_VEC4 enumeration value
+      specifies that a shader parameter contains a 4-dimensional vector of
+      32-bit floating-point data.
+    - The VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_MASK shader parameter specifies
+      which clip planes are enabled.
+    - The VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_[0-7] shader parameters specify
+      the corresponding clip planes.
+    - The VKD3D_SHADER_PARAMETER_NAME_POINT_SIZE shader parameter specifies the
+      point size to output when the source shader does not explicitly output a
+      point size.
+    - The VKD3D_SHADER_PARAMETER_NAME_POINT_SIZE_MIN shader parameter specifies
+      the minimum point size to clamp point size outputs to.
+    - The VKD3D_SHADER_PARAMETER_NAME_POINT_SIZE_MAX shader parameter specifies
+      the maximum point size to clamp point size outputs to.
+    - The VKD3D_SHADER_PARAMETER_NAME_POINT_SPRITE shader parameter specifies
+      whether texture coordinate inputs in fragment shaders should be replaced
+      with point coordinates.
+    - The VKD3D_SHADER_SOURCE_FX source type specifies binary Direct3D effects.
+    - The VKD3D_SHADER_TARGET_MSL target type specifies Metal Shading Language
+      shaders.
+
+### libvkd3d-utils
+
+  - The GetDesc() method of the ID3D12ShaderReflection interface returned by
+    D3DReflect() returns shader version information.
+
+  - New interfaces:
+    - D3DCompile2VKD3D() is a variant of D3DCompile2() that allows targeting the
+      behaviour of a specific d3dcompiler version.
+
+### 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.
+
 # What's new in vkd3d 1.13 (29 August 2024)
 
 ### libvkd3d

Doxyfile.in

@@ -10,6 +10,7 @@ OPTIMIZE_OUTPUT_FOR_C  = YES
 EXTRACT_STATIC         = YES
 QUIET                  = YES
 WARN_IF_UNDOCUMENTED   = NO
+WARN_IF_INCOMPLETE_DOC = NO
 LATEX_BATCHMODE        = YES
 
 INPUT                  = @srcdir@/include/vkd3d.h \

Makefile.am

@@ -50,7 +50,6 @@ vkd3d_shader_tests = \
 	tests/hlsl/all.shader_test \
 	tests/hlsl/alpha-test.shader_test \
 	tests/hlsl/angle-unit.shader_test \
-	tests/hlsl/annotations.shader_test \
 	tests/hlsl/any.shader_test \
 	tests/hlsl/arithmetic-float-uniform.shader_test \
 	tests/hlsl/arithmetic-float.shader_test \
@@ -82,24 +81,33 @@ vkd3d_shader_tests = \
 	tests/hlsl/cf-cond-types.shader_test \
 	tests/hlsl/clamp.shader_test \
 	tests/hlsl/clip-distance.shader_test \
+	tests/hlsl/clip-planes.shader_test \
 	tests/hlsl/clip.shader_test \
 	tests/hlsl/combined-samplers.shader_test \
 	tests/hlsl/comma.shader_test \
 	tests/hlsl/compute.shader_test \
 	tests/hlsl/conditional.shader_test \
 	tests/hlsl/const.shader_test \
+	tests/hlsl/constructgswithso.shader_test \
 	tests/hlsl/coverage.shader_test \
 	tests/hlsl/cross.shader_test \
 	tests/hlsl/d3dcolor-to-ubyte4.shader_test \
 	tests/hlsl/ddxddy.shader_test \
 	tests/hlsl/default-values.shader_test \
+	tests/hlsl/depth-bounds.shader_test \
 	tests/hlsl/depth-out.shader_test \
 	tests/hlsl/determinant.shader_test \
 	tests/hlsl/discard.shader_test \
 	tests/hlsl/distance.shader_test \
 	tests/hlsl/dot.shader_test \
 	tests/hlsl/duplicate-modifiers.shader_test \
+	tests/hlsl/early-depth-stencil.shader_test \
+	tests/hlsl/effect-annotations-fx_2.shader_test \
+	tests/hlsl/effect-annotations-fx_4.shader_test \
+	tests/hlsl/effect-assignments-fx_5.shader_test \
 	tests/hlsl/effect-compile.shader_test \
+	tests/hlsl/effect-initial-values-fx_2.shader_test \
+	tests/hlsl/effect-initial-values-fx_4.shader_test \
 	tests/hlsl/effect-pass-states-fx_5.shader_test \
 	tests/hlsl/effect-shader-objects-fx_2.shader_test \
 	tests/hlsl/effect-shader-objects-fx_5.shader_test \
@@ -113,7 +121,10 @@ vkd3d_shader_tests = \
 	tests/hlsl/exp.shader_test \
 	tests/hlsl/expr-indexing.shader_test \
 	tests/hlsl/f16tof32.shader_test \
+	tests/hlsl/f32tof16.shader_test \
 	tests/hlsl/faceforward.shader_test \
+	tests/hlsl/fog.shader_test \
+	tests/hlsl/ffp-point-size.shader_test \
 	tests/hlsl/float-comparison.shader_test \
 	tests/hlsl/floor.shader_test \
 	tests/hlsl/fmod.shader_test \
@@ -132,6 +143,8 @@ vkd3d_shader_tests = \
 	tests/hlsl/getdimensions.shader_test \
 	tests/hlsl/half.shader_test \
 	tests/hlsl/hard-copy-prop.shader_test \
+	tests/hlsl/hull-shader-attributes.shader_test \
+	tests/hlsl/hull-shader-syntax.shader_test \
 	tests/hlsl/initializer-flatten.shader_test \
 	tests/hlsl/initializer-implicit-array.shader_test \
 	tests/hlsl/initializer-invalid-arg-count.shader_test \
@@ -144,6 +157,7 @@ vkd3d_shader_tests = \
 	tests/hlsl/initializer-static-array.shader_test \
 	tests/hlsl/initializer-struct.shader_test \
 	tests/hlsl/instance-id.shader_test \
+	tests/hlsl/interface-packing.shader_test \
 	tests/hlsl/intrinsic-override.shader_test \
 	tests/hlsl/invalid.shader_test \
 	tests/hlsl/inverse-trig.shader_test \
@@ -164,6 +178,7 @@ vkd3d_shader_tests = \
 	tests/hlsl/matrix-semantics.shader_test \
 	tests/hlsl/max-min.shader_test \
 	tests/hlsl/minimum-precision.shader_test \
+	tests/hlsl/modf.shader_test \
 	tests/hlsl/mul.shader_test \
 	tests/hlsl/multiple-rt.shader_test \
 	tests/hlsl/nested-arrays.shader_test \
@@ -177,6 +192,7 @@ vkd3d_shader_tests = \
 	tests/hlsl/object-field-offsets.shader_test \
 	tests/hlsl/object-parameters.shader_test \
 	tests/hlsl/object-references.shader_test \
+	tests/hlsl/point-sprite.shader_test \
 	tests/hlsl/pointer-cast.shader_test \
 	tests/hlsl/pow.shader_test \
 	tests/hlsl/precise-modifier.shader_test \
@@ -191,27 +207,32 @@ vkd3d_shader_tests = \
 	tests/hlsl/return-implicit-conversion.shader_test \
 	tests/hlsl/return.shader_test \
 	tests/hlsl/round.shader_test \
+	tests/hlsl/rt-format-mismatch.shader_test \
 	tests/hlsl/rt-get-sample-info.shader_test \
 	tests/hlsl/sample-bias.shader_test \
 	tests/hlsl/sample-cmp.shader_test \
 	tests/hlsl/sample-grad.shader_test \
 	tests/hlsl/sample-level.shader_test \
 	tests/hlsl/sampler-offset.shader_test \
+	tests/hlsl/sampler-state.shader_test \
 	tests/hlsl/sampler.shader_test \
 	tests/hlsl/saturate.shader_test \
 	tests/hlsl/shade-mode.shader_test \
 	tests/hlsl/shader-interstage-interface.shader_test \
+	tests/hlsl/shader-point-size.shader_test \
 	tests/hlsl/shape.shader_test \
 	tests/hlsl/side-effects.shader_test \
 	tests/hlsl/sign.shader_test \
 	tests/hlsl/single-numeric-initializer.shader_test \
 	tests/hlsl/sm1-const-allocation.shader_test \
 	tests/hlsl/sm1-const-folding.shader_test \
+	tests/hlsl/sm1-interstage-interface.shader_test \
 	tests/hlsl/sm6-ternary.shader_test \
 	tests/hlsl/sm6-uav-rwtexture.shader_test \
 	tests/hlsl/smoothstep.shader_test \
 	tests/hlsl/sqrt.shader_test \
 	tests/hlsl/srv-buffers.shader_test \
+	tests/hlsl/srv-byteaddressbuffer.shader_test \
 	tests/hlsl/state-block-function-syntax.shader_test \
 	tests/hlsl/state-block-syntax.shader_test \
 	tests/hlsl/static-initializer.shader_test \
@@ -220,12 +241,14 @@ vkd3d_shader_tests = \
 	tests/hlsl/strings.shader_test \
 	tests/hlsl/struct-array.shader_test \
 	tests/hlsl/struct-assignment.shader_test \
+	tests/hlsl/struct-inheritance.shader_test \
 	tests/hlsl/struct-semantics.shader_test \
 	tests/hlsl/switch.shader_test \
 	tests/hlsl/swizzle-constant-prop.shader_test \
 	tests/hlsl/swizzle-matrix.shader_test \
 	tests/hlsl/swizzles.shader_test \
 	tests/hlsl/ternary.shader_test \
+	tests/hlsl/tessellation-patch-vars.shader_test \
 	tests/hlsl/tessellation.shader_test \
 	tests/hlsl/texture-load-offset.shader_test \
 	tests/hlsl/texture-load-typed.shader_test \
@@ -247,6 +270,8 @@ vkd3d_shader_tests = \
 	tests/hlsl/unbounded-array-5.1.shader_test \
 	tests/hlsl/uniform-parameters.shader_test \
 	tests/hlsl/uniform-semantics.shader_test \
+	tests/hlsl/uninitialized-varyings.shader_test \
+	tests/hlsl/unorm-snorm.shader_test \
 	tests/hlsl/unroll.shader_test \
 	tests/hlsl/unsigned.shader_test \
 	tests/hlsl/vector-indexing-uniform.shader_test \
@@ -273,7 +298,8 @@ vkd3d_test_headers = \
 	tests/dxcompiler.h \
 	tests/shader_runner.h \
 	tests/utils.h \
-	tests/vulkan_procs.h
+	tests/vulkan_procs.h \
+	tests/vulkan_utils.h
 
 vkd3d_demos = \
 	demos/vkd3d-gears \
@@ -358,6 +384,7 @@ libvkd3d_shader_la_SOURCES = \
 	libs/vkd3d-shader/hlsl_codegen.c \
 	libs/vkd3d-shader/hlsl_constant_ops.c \
 	libs/vkd3d-shader/ir.c \
+	libs/vkd3d-shader/msl.c \
 	libs/vkd3d-shader/preproc.h \
 	libs/vkd3d-shader/spirv.c \
 	libs/vkd3d-shader/tpf.c \
@@ -365,7 +392,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 12:0:11
+libvkd3d_shader_la_LDFLAGS = $(AM_LDFLAGS) -version-info 13:0:12
 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 +427,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 14:0:13
+libvkd3d_la_LDFLAGS = $(AM_LDFLAGS) -version-info 15:0:14
 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 +440,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:2:5
+libvkd3d_utils_la_LDFLAGS = $(AM_LDFLAGS) -version-info 7:0:6
 libvkd3d_utils_la_LIBADD = libvkd3d-common.la libvkd3d-shader.la libvkd3d.la @PTHREAD_LIBS@
 if HAVE_LD_VERSION_SCRIPT
 libvkd3d_utils_la_LDFLAGS += -Wl,--version-script=$(srcdir)/libs/vkd3d-utils/vkd3d_utils.map
@@ -445,15 +472,20 @@ LDADD = libvkd3d.la libvkd3d-shader.la libvkd3d-utils.la
 AM_DEFAULT_SOURCE_EXT = .c
 
 TEST_EXTENSIONS = .shader_test
+TEST_CPPFLAGS = -I$(builddir)/tests
 
 if BUILD_TESTS
 check_PROGRAMS = $(vkd3d_tests) $(vkd3d_cross_tests) tests/shader_runner
 dist_check_SCRIPTS = tests/test-driver.sh
 TESTS = $(vkd3d_tests) $(vkd3d_cross_tests) $(vkd3d_shader_tests)
+tests_d3d12_CPPFLAGS = $(AM_CPPFLAGS) $(TEST_CPPFLAGS)
 tests_d3d12_LDADD = $(LDADD) @PTHREAD_LIBS@ @DL_LIBS@
+tests_d3d12_invalid_usage_CPPFLAGS = $(AM_CPPFLAGS) $(TEST_CPPFLAGS)
 tests_d3d12_invalid_usage_LDADD = $(LDADD) @DL_LIBS@
+tests_hlsl_d3d12_CPPFLAGS = $(AM_CPPFLAGS) $(TEST_CPPFLAGS)
 tests_hlsl_d3d12_LDADD = $(LDADD) @DL_LIBS@
-tests_shader_runner_CFLAGS = $(AM_CFLAGS) -I$(builddir)/tests @OPENGL_CFLAGS@
+tests_shader_runner_CPPFLAGS = $(AM_CPPFLAGS) $(TEST_CPPFLAGS)
+tests_shader_runner_CFLAGS = $(AM_CFLAGS) @OPENGL_CFLAGS@
 tests_shader_runner_LDADD = $(LDADD) @OPENGL_LIBS@ @DL_LIBS@
 tests_shader_runner_SOURCES = \
 	tests/shader_runner.c \
@@ -462,7 +494,16 @@ tests_shader_runner_SOURCES = \
 	tests/shader_runner_d3d12.c \
 	tests/shader_runner_gl.c \
 	tests/shader_runner_vulkan.c
+if HAVE_METAL
+tests_shader_runner_OBJCFLAGS = $(AM_CFLAGS)
+tests_shader_runner_SOURCES += tests/shader_runner_metal.m
+tests_shader_runner_LINK = $(OBJCLINK) -framework Foundation -framework Metal
+else
+tests_shader_runner_LINK = $(LINK)
+endif
+tests_vkd3d_api_CPPFLAGS = $(AM_CPPFLAGS) $(TEST_CPPFLAGS)
 tests_vkd3d_api_LDADD = libvkd3d.la @DL_LIBS@
+tests_vkd3d_shader_api_CPPFLAGS = $(AM_CPPFLAGS) $(TEST_CPPFLAGS)
 tests_vkd3d_shader_api_CFLAGS = $(AM_CFLAGS) @OPENGL_CFLAGS@
 tests_vkd3d_shader_api_LDADD = libvkd3d-shader.la @OPENGL_LIBS@
 SHADER_TEST_LOG_COMPILER = tests/shader_runner

README

@@ -19,10 +19,20 @@ available or is not recent (>= 3.21), then you can build Wine with `make
 tools/widl/widl' to avoid building all of Wine. You can then point vkd3d's
 configure at that widl binary with `WIDL="/path/to/widl"'.
 
-For release builds, you may want to define NDEBUG. If you do not need debug log
-messages, you may also consider VKD3D_NO_TRACE_MESSAGES and
-VKD3D_NO_DEBUG_MESSAGES. For example, you can pass `CPPFLAGS="-DNDEBUG
--DVKD3D_NO_TRACE_MESSAGES"' to configure.
+For release builds, you may want to disable debug log messages defining
+preprocessor macros VKD3D_NO_TRACE_MESSAGES and VKD3D_NO_DEBUG_MESSAGES.
+See the `Preprocessor definitions' section below for more details.
+
+================
+Developing vkd3d
+================
+
+Development of vkd3d happens on the Wine GitLab instance
+(https://gitlab.winehq.org/wine/vkd3d/). Contributors are encouraged
+to submit their patches using the merge request tool.
+
+Each merge request is automatically tested with the GitLab CI
+system. See gitlab/README in the Git tree for more details.
 
 ===========
 Using vkd3d
@@ -39,8 +49,8 @@ Environment variables
 =====================
 
 Most of the environment variables used by vkd3d are for debugging purposes. The
-environment variables are not considered a part of API and might be changed or
-removed in the future versions of vkd3d.
+environment variables are not considered a stable interface and might be changed
+or removed in future versions of vkd3d.
 
 Some of debug variables are lists of elements. Elements must be separated by
 commas or semicolons.
@@ -65,6 +75,14 @@ commas or semicolons.
  * VKD3D_DISABLE_EXTENSIONS - a list of Vulkan extensions that libvkd3d should
    not use even if available.
 
+ * VKD3D_CAPS_OVERRIDE - a list of Direct3D 12 capabilities for which the
+   default value detected by vkd3d should be overridden, in the form
+   `capability1=value1,capability2=value2'. This doesn't change the vkd3d
+   behaviour, only the information reported to the application. The following
+   capabilities can currently be overridden:
+    * feature_level (allowed values: 11.0, 11.1, 12.0, 12.1, 12.2)
+    * resource_binding_tier (allowed values: 1, 2, 3)
+
  * VKD3D_SHADER_CONFIG - a list of options that change the behavior of
    libvkd3d-shader.
     * force_validation - Enable (additional) validation of libvkd3d-shader's
@@ -105,16 +123,47 @@ code for adding DXBC checksums, so the official release should be installed
 from:
 https://github.com/microsoft/DirectXShaderCompiler/releases
 
-================
-Developing vkd3d
-================
+========================
+Preprocessor definitions
+========================
 
-Development of vkd3d happens on the Wine GitLab instance
-(https://gitlab.winehq.org/wine/vkd3d/). Contributors are encouraged
-to submit their patches using the merge request tool.
+A number of preprocessor definitions can be used at compilation time to control
+the behaviour of the generated binary. You can pass something like
+`CPPFLAGS="-DVKD3D_VAR1 -DVKD3D_VAR2"' to the configure script. The preprocessor
+variables are not considered a stable interface and might be changed or removed
+in future versions of vkd3d.
 
-Each merge request is automatically tested with the GitLab CI
-system. See gitlab/README in the Git tree for more details.
+ * VKD3D_NO_TRACE_MESSAGES - do not emit trace messages in the debug log; this
+   can be useful in release builds to reduce the size of the binary and make it
+   slightly faster.
+
+ * VKD3D_NO_DEBUG_MESSAGES - do not emit warn and fixme messages in the debug
+   log; this will further optimise the binary, but may omit messages that could
+   help debug problems with vkd3d.
+
+ * VKD3D_NO_ERROR_MESSAGES - do not emit error messages; this will optimise the
+   binary even more, but may omit very important messages, so it is not
+   recommended in most circumstances.
+
+ * VKD3D_ABORT_ON_ERR - abort the process as soon as an error message is
+   emitted; this can be useful for developers to make error conditions as
+   conspicuous as possible.
+
+ * VKD3D_SHADER_UNSUPPORTED_DXIL - enable DXIL (DirectX Intermediate Language)
+   support in vkd3d-shader, which is disabled by default because it is not
+   considered ready for release yet. Please note that this feature is not
+   currently supported, and it might change in a non-compatible way before it is
+   released.
+
+ * VKD3D_SHADER_UNSUPPORTED_GLSL - enable GLSL (GL Shading Language) support in
+   vkd3d-shader, which is disabled by default because it is not considered ready
+   for release yet. Please note that this feature is not currently supported,
+   and it might change in a non-compatible way before it is released.
+
+ * VKD3D_SHADER_UNSUPPORTED_MSL - enable MSL (Metal Shading Language) support in
+   vkd3d-shader, which is disabled by default because it is not considered ready
+   for release yet. Please note that this feature is not currently supported,
+   and it might change in a non-compatible way before it is released.
 
 ============================
 Testing with the Agility SDK

commits

@@ -0,0 +1,2 @@
+-
+0dc07f5cce72cce47b1a2787a910aeb5edc2a65e vkd3d-shader: Silence a spurious -Wmaybe-uninitialized in vsir_program_insert_alpha_test().

configure.ac

@@ -1,5 +1,5 @@
 AC_PREREQ([2.69])
-AC_INIT([vkd3d],[1.13])
+AC_INIT([vkd3d],[1.14])
 
 AC_CONFIG_AUX_DIR([bin])
 AC_CONFIG_MACRO_DIR([m4])
@@ -8,6 +8,7 @@ AC_CONFIG_HEADERS(include/config.h)
 AC_ARG_VAR([WIDL], [widl IDL compiler])
 AC_ARG_VAR([CROSSCC32], [32-bit Windows cross compiler])
 AC_ARG_VAR([CROSSCC64], [64-bit Windows cross compiler])
+AC_ARG_WITH([metal], AS_HELP_STRING([--with-metal], [Build with the Metal library (default: test)]))
 AC_ARG_WITH([ncurses], AS_HELP_STRING([--with-ncurses], [Build with the ncurses library (default: test)]))
 AC_ARG_WITH([opengl], AS_HELP_STRING([--with-opengl], [Build with the OpenGL library (default: test)]))
 AC_ARG_WITH([spirv-tools], AS_HELP_STRING([--with-spirv-tools],
@@ -134,6 +135,16 @@ AS_IF([test "x$SONAME_LIBDXCOMPILER" = "x"],
       [VKD3D_CHECK_SONAME([dxcompiler], [DxcCreateInstance], [HAVE_DXCOMPILER=yes], [HAVE_DXCOMPILER=no], [$DXCOMPILER_LIBS])],
       [AC_DEFINE_UNQUOTED([SONAME_LIBDXCOMPILER],["$SONAME_LIBDXCOMPILER"],[Define to the shared object name of the dxcompiler library.])])
 
+AS_IF([test "x$with_metal" != "xno"],
+      [AC_MSG_CHECKING([for Metal])]
+      [AC_PREPROC_IFELSE([AC_LANG_PROGRAM([#include <Metal/Metal.h>])],
+                         [AC_MSG_RESULT([yes])
+                          AC_PROG_OBJC
+                          AC_DEFINE([HAVE_METAL], [1], [Define to 1 if you have Metal.])
+                          with_metal=yes],
+                         [AC_MSG_RESULT([no])
+                          AM_CONDITIONAL([am__fastdepOBJC], [false])
+                          with_metal=no])])
 AS_IF([test "x$with_ncurses" != "xno"],
       [PKG_CHECK_MODULES([NCURSES], [ncurses],
                          [AC_DEFINE([HAVE_NCURSES], [1], [Define to 1 if you have ncurses.]) with_ncurses=yes],
@@ -181,6 +192,7 @@ AM_CONDITIONAL([BUILD_TESTS], [test "x$enable_tests" != "xno"])
 AM_CONDITIONAL([HAVE_WIDL], [test "x$WIDL" != "xno"])
 AM_CONDITIONAL([HAVE_CROSSTARGET32], [test "x$CROSSTARGET32" != "xno"])
 AM_CONDITIONAL([HAVE_CROSSTARGET64], [test "x$CROSSTARGET64" != "xno"])
+AM_CONDITIONAL([HAVE_METAL], [test "${host_os#darwin}" != "$host_os"])
 
 AC_CONFIG_FILES([Makefile])
 AC_OUTPUT
@@ -197,11 +209,12 @@ AS_ECHO(["
 
   widl: ${WIDL}
 
+  Have dxcompiler: ${HAVE_DXCOMPILER}
+  Have Metal: ${with_metal}
   Have ncurses: ${with_ncurses}
   Have OpenGL: ${with_opengl}
   Have SPIRV-Tools: ${with_spirv_tools}
   Have xcb: ${HAVE_XCB}
-  Have dxcompiler: ${HAVE_DXCOMPILER}
 
   Building demos: ${enable_demos}
   Building tests: ${enable_tests}

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_13
+#define VKD3D_UTILS_API_VERSION VKD3D_API_VERSION_1_14
 #include "config.h"
 #include <vkd3d.h>
 #include <vkd3d_utils.h>

gitlab/build-mac

@@ -11,7 +11,8 @@ rm -fr build
 mkdir build
 cd build
 if ../configure CFLAGS="-I/opt/homebrew/opt/vulkan-headers/include -I/opt/homebrew/opt/spirv-headers/include -g -O2 -Wno-implicit-fallthrough -Wno-ignored-attributes -Wno-unknown-attributes -Wno-unused-but-set-variable -Werror" \
-        CPPFLAGS="-DVKD3D_ABORT_ON_ERR" \
+        OBJCFLAGS="-g -O2 -Wno-unknown-attributes -Wno-ignored-attributes -Werror" \
+        CPPFLAGS="-DVKD3D_ABORT_ON_ERR -DVKD3D_SHADER_UNSUPPORTED_DXIL -DVKD3D_SHADER_UNSUPPORTED_MSL" \
         VULKAN_LIBS=-L/opt/homebrew/opt/vulkan-loader/lib --with-spirv-tools && \
         make -j$(sysctl -n hw.ncpu) ; then
     make -j$(sysctl -n hw.ncpu) AM_COLOR_TESTS=always check || \

gitlab/build.yml

@@ -63,9 +63,6 @@ build-llvmpipe-32:
 
 build-llvmpipe-64-mesa24:
   extends: .build-linux
-  allow_failure:
-    exit_codes:
-      - 2
   variables:
     VK_DRIVER_FILES: '/opt/mesa24/share/vulkan/icd.d/lvp_icd.x86_64.json'
     LD_LIBRARY_PATH: '/opt/mesa24/lib/x86_64-linux-gnu'
@@ -138,9 +135,6 @@ build-mac:
   rules:
     - if: $CI_PIPELINE_SOURCE == 'merge_request_event'
   image: winehq-sonoma-pristine
-  variables:
-    TART_EXECUTOR_SSH_USERNAME: "gitlab"
-    TART_EXECUTOR_SSH_PASSWORD: "gitlab"
   allow_failure: true
   interruptible: true
   needs:
@@ -150,16 +144,17 @@ build-mac:
   tags:
     - mac
   script:
-    - brew install vulkan-tools libtool spirv-headers vulkan-loader
+    - brew install vulkan-tools libtool spirv-headers vulkan-loader mingw-w64
     - git config --global --add safe.directory $CI_PROJECT_DIR
     - git clean -fdx
     - git reset --hard
     - rm -fr .git/rebase-merge
-    - curl -o image.zip https://gitlab.winehq.org/api/v4/projects/giomasce%2Fvkd3d/jobs/artifacts/ci-image/download?job=image-mac
+    - curl -o image.zip https://gitlab.winehq.org/api/v4/projects/wine%2Fvkd3d/jobs/artifacts/master/download?job=image-mac
     - unzip image.zip
     - mkdir artifacts
-    - export PATH="/opt/homebrew/opt/bison/bin:/opt/homebrew/opt/flex/bin:$PWD/image/bin:$PATH"
+    - export PATH="/opt/homebrew/opt/bison/bin:/opt/homebrew/opt/flex/bin:$PATH"
     - export VK_DRIVER_FILES="$PWD/image/moltenvk/MoltenVK_icd.json"
+    - export SONAME_LIBDXCOMPILER="$PWD/image/dxc/libdxcompiler.dylib"
     - system_profiler SPSoftwareDataType SPHardwareDataType > artifacts/systeminfo.txt
     - vulkaninfo > artifacts/vulkaninfo.txt
     - git rebase $CI_MERGE_REQUEST_DIFF_BASE_SHA --exec ./gitlab/build-mac
@@ -170,6 +165,7 @@ build-mac:
     VKD3D_SHADER_CONFIG: 'force_validation'
     MVK_CONFIG_LOG_LEVEL: 2
     SONAME_LIBVULKAN: "/opt/homebrew/opt/vulkan-loader/lib/libvulkan.1.dylib"
+    WIDL: "x86_64-w64-mingw32-widl"
   artifacts:
     when: always
     paths:

gitlab/image.docker

@@ -8,6 +8,12 @@ WORKDIR /tmp
 # we also have to drop the executables, but we don't care about those
 # anyway.
 
+# Mesa requires Meson >= 1.1.0, which is not available on Debian bookworm.
+# Fortunately that can be worked around by removing some features from
+# meson.build, which are not needed for llvmpipe. Notice that we use
+# "git show | patch -R" instead of "git revert" so we don't have to configure
+# a valid email and user name for git.
+
 RUN export DEBIAN_FRONTEND=noninteractive; \
     echo 'path-exclude=/usr/share/doc/*' > /etc/dpkg/dpkg.cfg.d/99-exclude-cruft && \
     echo 'path-exclude=/usr/share/locale/*' >> /etc/dpkg/dpkg.cfg.d/99-exclude-cruft && \
@@ -71,8 +77,10 @@ RUN export DEBIAN_FRONTEND=noninteractive; \
     dpkg -i spirv-tools_*.deb && \
     rm -fr * && \
 
-    git clone --depth 1 --branch mesa-24.0.3 https://gitlab.freedesktop.org/mesa/mesa.git && \
+    git clone --branch mesa-24.2.4 https://gitlab.freedesktop.org/mesa/mesa.git && \
     cd mesa && \
+    git show 876db9135048 | patch -p1 -R && \
+    sed -i -e '981,991d' meson.build && \
     mkdir build && \
     cd build && \
     meson setup --buildtype release -Dprefix=/opt/mesa24 -Dplatforms= -Dvideo-codecs= -Dvulkan-drivers=swrast -Dgallium-drivers=swrast -Dopengl=true -Degl=enabled -Dglvnd=true -Dshared-glapi=enabled -Dglx=disabled -Dgles1=disabled -Dgles2=disabled .. && \
@@ -81,7 +89,7 @@ RUN export DEBIAN_FRONTEND=noninteractive; \
     rm -fr mesa && \
 
     apt-get clean && \
-    curl -L -s https://github.com/microsoft/DirectXShaderCompiler/releases/download/v1.7.2308/linux_dxc_2023_08_14.x86_64.tar.gz | tar zx -C /usr/local ./lib/libdxcompiler.so ./lib/libdxil.so && \
+    curl -L -s https://github.com/microsoft/DirectXShaderCompiler/releases/download/v1.8.2407/linux_dxc_2024_07_31.x86_64.tar.gz | tar zx -C /usr/local ./lib/libdxcompiler.so ./lib/libdxil.so && \
     groupadd host-render -g 800 && \
     useradd -m gitlab -G host-render
 

gitlab/image.yml

@@ -32,17 +32,26 @@ image-mac:
         - gitlab/image.yml
         - gitlab/image.docker
   image: winehq-sonoma-pristine
-  variables:
-    TART_EXECUTOR_SSH_USERNAME: "gitlab"
-    TART_EXECUTOR_SSH_PASSWORD: "gitlab"
   interruptible: true
   tags:
     - mac
   script:
+    - brew install cmake clang-format
     - mkdir image
-    - mkdir image/bin
+    - mkdir image/dxc
     - mkdir image/moltenvk
-    - export PATH="/usr/local/opt/bison/bin:/usr/local/opt/flex/bin:$PATH"
+
+    # The specified commit includes the open sourced libdxil.dylib,
+    # which is not available yet in any released version
+    - git clone --recursive https://github.com/microsoft/DirectXShaderCompiler.git
+    - cd DirectXShaderCompiler
+    - git checkout dfa1c814cc4c912ba982854b72f64527baa3e7e5
+    - mkdir build
+    - cd build
+    - cmake .. -C ../cmake/caches/PredefinedParams.cmake -D CMAKE_BUILD_TYPE=Release
+    - make -j$(sysctl -n hw.ncpu)
+    - cd ../..
+    - cp DirectXShaderCompiler/build/lib/libdxcompiler.dylib DirectXShaderCompiler/build/lib/libdxil.dylib image/dxc
 
     - git clone --depth 1 --branch v1.2.9 https://github.com/KhronosGroup/MoltenVK.git
     - cd MoltenVK
@@ -54,15 +63,6 @@ image-mac:
     - cd ..
     - cp MoltenVK/Package/Release/MoltenVK/dylib/macOS/MoltenVK_icd.json image/moltenvk
     - cp MoltenVK/Package/Release/MoltenVK/dylib/macOS/libMoltenVK.dylib image/moltenvk
-
-    - git clone --depth 1 --branch wine-3.21 https://gitlab.winehq.org/wine/wine.git
-    - cd wine
-    - mkdir build
-    - cd build
-    - arch -x86_64 ../configure --enable-win64 --without-x --without-freetype
-    - arch -x86_64 make tools/widl/widl
-    - cd ../..
-    - cp wine/build/tools/widl/widl image/bin
   artifacts:
     paths:
       - image

gitlab/test.yml

@@ -38,7 +38,7 @@ test-win-64-dxc:
   tags:
     - win10-21h2
   script:
-    - 'Invoke-WebRequest -Uri "https://github.com/microsoft/DirectXShaderCompiler/releases/download/v1.7.2308/dxc_2023_08_14.zip" -OutFile ".\dxc.zip"'
+    - 'Invoke-WebRequest -Uri "https://github.com/microsoft/DirectXShaderCompiler/releases/download/v1.8.2407/dxc_2024_07_31.zip" -OutFile ".\dxc.zip"'
     - 'Expand-Archive -Path "dxc.zip" -DestinationPath ".\dxc"'
     - '$Env:PATH += ";" + (Convert-Path ".\dxc\bin\x64")'
     - git rebase $CI_MERGE_REQUEST_DIFF_BASE_SHA --exec './artifacts/driver.cross64.exe $(git cherry $CI_MERGE_REQUEST_DIFF_BASE_SHA HEAD^ | wc -l) $(git rev-parse --short HEAD)'

include/private/vkd3d_common.h

@@ -62,6 +62,8 @@
 #define VKD3D_STRINGIFY(x) #x
 #define VKD3D_EXPAND_AND_STRINGIFY(x) VKD3D_EXPAND(VKD3D_STRINGIFY(x))
 
+#define vkd3d_clamp(value, lower, upper) max(min(value, upper), lower)
+
 #define TAG_AON9 VKD3D_MAKE_TAG('A', 'o', 'n', '9')
 #define TAG_DXBC VKD3D_MAKE_TAG('D', 'X', 'B', 'C')
 #define TAG_DXIL VKD3D_MAKE_TAG('D', 'X', 'I', 'L')

include/vkd3d.h

@@ -98,6 +98,7 @@ enum vkd3d_api_version
     VKD3D_API_VERSION_1_11,
     VKD3D_API_VERSION_1_12,
     VKD3D_API_VERSION_1_13,
+    VKD3D_API_VERSION_1_14,
 
     VKD3D_FORCE_32_BIT_ENUM(VKD3D_API_VERSION),
 };

include/vkd3d_shader.h

@@ -56,6 +56,7 @@ enum vkd3d_shader_api_version
     VKD3D_SHADER_API_VERSION_1_11,
     VKD3D_SHADER_API_VERSION_1_12,
     VKD3D_SHADER_API_VERSION_1_13,
+    VKD3D_SHADER_API_VERSION_1_14,
 
     VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_API_VERSION),
 };
@@ -190,6 +191,17 @@ enum vkd3d_shader_compile_option_backward_compatibility
      *  - DEPTH to SV_Depth for pixel shader outputs.
      */
     VKD3D_SHADER_COMPILE_OPTION_BACKCOMPAT_MAP_SEMANTIC_NAMES = 0x00000001,
+    /**
+     *  Causes 'double' to behave as an alias for 'float'. This option only
+     *  applies to HLSL sources with shader model 1-3 target profiles. Without
+     *  this option using the 'double' type produces compilation errors in
+     *  these target profiles.
+     *
+     *  This option is disabled by default.
+     *
+     *  \since 1.14
+     */
+    VKD3D_SHADER_COMPILE_OPTION_DOUBLE_AS_FLOAT_ALIAS = 0x00000002,
 
     VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPILE_OPTION_BACKWARD_COMPATIBILITY),
 };
@@ -469,8 +481,8 @@ enum vkd3d_shader_parameter_type
     /** The parameter value is embedded directly in the shader. */
     VKD3D_SHADER_PARAMETER_TYPE_IMMEDIATE_CONSTANT,
     /**
-     * The parameter value is provided to the shader via a specialization
-     * constant. This value is only supported for the SPIR-V target type.
+     * The parameter value is provided to the shader via specialization
+     * constants. This value is only supported for the SPIR-V target type.
      */
     VKD3D_SHADER_PARAMETER_TYPE_SPECIALIZATION_CONSTANT,
     /**
@@ -495,6 +507,13 @@ enum vkd3d_shader_parameter_data_type
     VKD3D_SHADER_PARAMETER_DATA_TYPE_UINT32,
     /** The parameter is provided as a 32-bit float. \since 1.13 */
     VKD3D_SHADER_PARAMETER_DATA_TYPE_FLOAT32,
+    /**
+     * The parameter is provided as a 4-dimensional vector of 32-bit floats.
+     * This parameter must be used with struct vkd3d_shader_parameter1;
+     * it cannot be used with struct vkd3d_shader_parameter.
+     * \since 1.14
+     */
+    VKD3D_SHADER_PARAMETER_DATA_TYPE_FLOAT32_VEC4,
 
     VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_PARAMETER_DATA_TYPE),
 };
@@ -578,6 +597,143 @@ enum vkd3d_shader_parameter_name
      * \since 1.13
      */
     VKD3D_SHADER_PARAMETER_NAME_FLAT_INTERPOLATION,
+    /**
+     * A mask of enabled clip planes.
+     *
+     * When this parameter is provided to a vertex shader, for each nonzero bit
+     * of this mask, a user clip distance will be generated from vertex position
+     * in clip space, and the clip plane defined by the indexed vector, taken
+     * from the VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_# parameter.
+     *
+     * Regardless of the specific clip planes which are enabled, the clip
+     * distances which are output are a contiguous array starting from clip
+     * distance 0. This affects the interface of OpenGL. For example, if only
+     * clip planes 1 and 3 are enabled (and so the value of the mask is 0xa),
+     * the user should enable only GL_CLIP_DISTANCE0 and GL_CLIP_DISTANCE1.
+     *
+     * The default value is zero, i.e. do not enable any clip planes.
+     *
+     * The data type for this parameter must be
+     * VKD3D_SHADER_PARAMETER_DATA_TYPE_UINT32.
+     *
+     * Only VKD3D_SHADER_PARAMETER_TYPE_IMMEDIATE_CONSTANT is supported in this
+     * version of vkd3d-shader.
+     *
+     * If the source shader writes clip distances and this parameter is nonzero,
+     * compilation fails.
+     *
+     * \since 1.14
+     */
+    VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_MASK,
+    /**
+     * Clip plane values.
+     * See VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_MASK for documentation of
+     * clip planes.
+     *
+     * These enum values are contiguous and arithmetic may safely be performed
+     * on them. That is, VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_[n] is
+     * VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_0 plus n.
+     *
+     * The data type for each parameter must be
+     * VKD3D_SHADER_PARAMETER_DATA_TYPE_FLOAT32_VEC4.
+     *
+     * The default value for each plane is a (0, 0, 0, 0) vector.
+     *
+     * \since 1.14
+     */
+    VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_0,
+    VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_1,
+    VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_2,
+    VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_3,
+    VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_4,
+    VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_5,
+    VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_6,
+    VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_7,
+    /**
+     * Point size.
+     *
+     * When this parameter is provided to a vertex, tessellation, or geometry
+     * shader, and the source shader does not write point size, it specifies a
+     * uniform value which will be written to point size.
+     * If the source shader writes point size, this parameter is ignored.
+     *
+     * This parameter can be used to implement fixed function point size, as
+     * present in Direct3D versions 8 and 9, if the target environment does not
+     * support point size as part of its own fixed-function API (as Vulkan and
+     * core OpenGL).
+     *
+     * The data type for this parameter must be
+     * VKD3D_SHADER_PARAMETER_DATA_TYPE_FLOAT32.
+     *
+     * \since 1.14
+     */
+    VKD3D_SHADER_PARAMETER_NAME_POINT_SIZE,
+    /**
+     * Minimum point size.
+     *
+     * When this parameter is provided to a vertex, tessellation, or geometry
+     * shader, and the source shader writes point size or uses the
+     * VKD3D_SHADER_PARAMETER_NAME_POINT_SIZE parameter, the point size will
+     * be clamped to the provided minimum value.
+     * If point size is not written in one of these ways,
+     * this parameter is ignored.
+     * If this parameter is not provided, the point size will not be clamped
+     * to a minimum size by vkd3d-shader.
+     *
+     * This parameter can be used to implement fixed function point size, as
+     * present in Direct3D versions 8 and 9, if the target environment does not
+     * support point size as part of its own fixed-function API (as Vulkan and
+     * core OpenGL).
+     *
+     * The data type for this parameter must be
+     * VKD3D_SHADER_PARAMETER_DATA_TYPE_FLOAT32.
+     *
+     * \since 1.14
+     */
+    VKD3D_SHADER_PARAMETER_NAME_POINT_SIZE_MIN,
+    /**
+     * Maximum point size.
+     *
+     * This parameter has identical behaviour to
+     * VKD3D_SHADER_PARAMETER_NAME_POINT_SIZE_MIN, except that it provides
+     * the maximum size rather than the minimum.
+     *
+     * \since 1.14
+     */
+    VKD3D_SHADER_PARAMETER_NAME_POINT_SIZE_MAX,
+    /**
+     * Whether texture coordinate inputs should take their values from the
+     * point coordinate.
+     *
+     * When this parameter is provided to a pixel shader, and the value is
+     * nonzero, any fragment shader input with the semantic name "TEXCOORD"
+     * takes its value from the point coordinates instead of from the previous
+     * shader. The point coordinates here are defined as a four-component vector
+     * whose X and Y components are the X and Y coordinates of the fragment
+     * within a point being rasterized, and whose Z and W components are zero.
+     *
+     * In GLSL, the X and Y components are drawn from gl_PointCoord; in SPIR-V,
+     * they are drawn from a variable with the BuiltinPointCoord decoration.
+     *
+     * This includes t# fragment shader inputs in shader model 2 shaders,
+     * as well as texture sampling in shader model 1 shaders.
+     *
+     * This parameter can be used to implement fixed function point sprite, as
+     * present in Direct3D versions 8 and 9, if the target environment does not
+     * support point sprite as part of its own fixed-function API (as Vulkan and
+     * core OpenGL).
+     *
+     * The data type for this parameter must be
+     * VKD3D_SHADER_PARAMETER_DATA_TYPE_UINT32.
+     *
+     * The default value is zero, i.e. use the original varyings.
+     *
+     * Only VKD3D_SHADER_PARAMETER_TYPE_IMMEDIATE_CONSTANT is supported in this
+     * version of vkd3d-shader.
+     *
+     * \since 1.14
+     */
+    VKD3D_SHADER_PARAMETER_NAME_POINT_SPRITE,
 
     VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_PARAMETER_NAME),
 };
@@ -625,6 +781,13 @@ struct vkd3d_shader_parameter_immediate_constant1
          * VKD3D_SHADER_PARAMETER_DATA_TYPE_FLOAT32.
          */
         float f32;
+        /**
+         * A pointer to the value if the parameter's data type is
+         * VKD3D_SHADER_PARAMETER_DATA_TYPE_FLOAT32_VEC4.
+         *
+         * \since 1.14
+         */
+        float f32_vec4[4];
         void *_pointer_pad;
         uint32_t _pad[4];
     } u;
@@ -636,7 +799,13 @@ struct vkd3d_shader_parameter_immediate_constant1
  */
 struct vkd3d_shader_parameter_specialization_constant
 {
-    /** The ID of the specialization constant. */
+    /**
+     * The ID of the specialization constant.
+     * If the type comprises more than one constant, such as
+     * VKD3D_SHADER_PARAMETER_DATA_TYPE_FLOAT32_VEC4, then a contiguous
+     * array of specialization constants should be used, one for each component,
+     * and this ID should point to the first component.
+     */
     uint32_t id;
 };
 
@@ -1046,6 +1215,11 @@ enum vkd3d_shader_source_type
      * the format used for Direct3D shader model 6 shaders. \since 1.9
      */
     VKD3D_SHADER_SOURCE_DXBC_DXIL,
+    /**
+     * Binary format used by Direct3D 9/10.x/11 effects.
+     * Input is a raw FX section without container. \since 1.14
+     */
+    VKD3D_SHADER_SOURCE_FX,
 
     VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_SOURCE_TYPE),
 };
@@ -1087,6 +1261,10 @@ enum vkd3d_shader_target_type
      * Output is a raw FX section without container. \since 1.11
      */
     VKD3D_SHADER_TARGET_FX,
+    /**
+     * A 'Metal Shading Language' shader. \since 1.14
+     */
+    VKD3D_SHADER_TARGET_MSL,
 
     VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_TARGET_TYPE),
 };
@@ -1292,7 +1470,8 @@ typedef int (*PFN_vkd3d_shader_open_include)(const char *filename, bool local,
  * vkd3d_shader_preprocess_info.
  *
  * \param code Contents of the included file, which were allocated by the
- * \ref pfn_open_include callback. The user must free them.
+ * vkd3d_shader_preprocess_info.pfn_open_include callback.
+ * The user must free them.
  *
  * \param context The user-defined pointer passed to struct
  * vkd3d_shader_preprocess_info.
@@ -1319,8 +1498,8 @@ struct vkd3d_shader_preprocess_info
 
     /**
      * Pointer to an array of predefined macros. Each macro in this array will
-     * be expanded as if a corresponding #define statement were prepended to the
-     * source code.
+     * be expanded as if a corresponding \#define statement were prepended to
+     * the source code.
      *
      * If the same macro is specified multiple times, only the last value is
      * used.
@@ -2333,6 +2512,7 @@ VKD3D_SHADER_API const enum vkd3d_shader_target_type *vkd3d_shader_get_supported
  * - VKD3D_SHADER_SOURCE_HLSL to VKD3D_SHADER_TARGET_D3D_BYTECODE
  * - VKD3D_SHADER_SOURCE_HLSL to VKD3D_SHADER_TARGET_DXBC_TPF
  * - VKD3D_SHADER_SOURCE_HLSL to VKD3D_SHADER_TARGET_FX
+ * - VKD3D_SHADER_SOURCE_FX to VKD3D_SHADER_TARGET_D3D_ASM
  *
  * Supported transformations can also be detected at runtime with the functions
  * vkd3d_shader_get_supported_source_types() and
@@ -2798,7 +2978,7 @@ VKD3D_SHADER_API void vkd3d_shader_free_scan_signature_info(struct vkd3d_shader_
  * \param input_signature The input signature of the second shader.
  *
  * \param count On output, contains the number of entries written into
- * \ref varyings.
+ * "varyings".
  *
  * \param varyings Pointer to an output array of varyings.
  * This must point to space for N varyings, where N is the number of elements

include/vkd3d_utils.h

@@ -58,7 +58,11 @@ VKD3D_UTILS_API HRESULT vkd3d_signal_event(HANDLE event);
 VKD3D_UTILS_API unsigned int vkd3d_wait_event(HANDLE event, unsigned int milliseconds);
 VKD3D_UTILS_API void vkd3d_destroy_event(HANDLE event);
 
+#if __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L
+# define D3D12CreateDevice(...) D3D12CreateDeviceVKD3D(__VA_ARGS__, VKD3D_UTILS_API_VERSION)
+#else
 # define D3D12CreateDevice(a, b, c, d) D3D12CreateDeviceVKD3D(a, b, c, d, VKD3D_UTILS_API_VERSION)
+#endif
 VKD3D_UTILS_API HRESULT WINAPI D3D12CreateRootSignatureDeserializer(
         const void *data, SIZE_T data_size, REFIID iid, void **deserializer);
 VKD3D_UTILS_API HRESULT WINAPI D3D12GetDebugInterface(REFIID iid, void **debug);
@@ -77,6 +81,12 @@ VKD3D_UTILS_API HRESULT WINAPI D3D12SerializeVersionedRootSignature(const D3D12_
 VKD3D_UTILS_API HRESULT WINAPI D3DCompile(const void *data, SIZE_T data_size, const char *filename,
         const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint,
         const char *target, UINT flags, UINT effect_flags, ID3DBlob **shader, ID3DBlob **error_messages);
+/**
+ * D3DCompile2() targets the behaviour of d3dcompiler_47.dll. To target the
+ * behaviour of other d3dcompiler versions, use D3DCompile2VKD3D().
+ *
+ * \since 1.3
+ */
 VKD3D_UTILS_API HRESULT WINAPI D3DCompile2(const void *data, SIZE_T data_size, const char *filename,
         const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint,
         const char *target, UINT flags, UINT effect_flags, UINT secondary_flags,
@@ -122,6 +132,22 @@ VKD3D_UTILS_API HRESULT WINAPI D3DDisassemble(const void *data,
 /** \since 1.11 */
 VKD3D_UTILS_API HRESULT WINAPI D3DReflect(const void *data, SIZE_T data_size, REFIID iid, void **reflection);
 
+/**
+ * As D3DCompile2(), but with an extra argument that allows targeting
+ * different d3dcompiler versions.
+ *
+ * \param compiler_version The d3dcompiler version to target. This should be
+ * set to the numerical value in the d3dcompiler library name. E.g. to target
+ * the behaviour of d3dcompiler_36.dll, set this parameter to 36.
+ *
+ * \since 1.14
+ */
+VKD3D_UTILS_API HRESULT WINAPI D3DCompile2VKD3D(const void *data, SIZE_T data_size, const char *filename,
+        const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint,
+        const char *target, UINT flags, UINT effect_flags, UINT secondary_flags,
+        const void *secondary_data, SIZE_T secondary_data_size, ID3DBlob **shader,
+        ID3DBlob **error_messages, unsigned int compiler_version);
+
 #ifdef __cplusplus
 }
 #endif  /* __cplusplus */

libs/vkd3d-shader/checksum.c

@@ -33,6 +33,11 @@
  * will fill a supplied 16-byte array with the digest.
  */
 
+/*
+ * DXBC uses a variation of the MD5 algorithm, which only changes the way
+ * the message is padded in the final step.
+ */
+
 #include "vkd3d_shader_private.h"
 
 #define DXBC_CHECKSUM_BLOCK_SIZE 64
@@ -230,10 +235,9 @@ static void md5_update(struct md5_ctx *ctx, const unsigned char *buf, unsigned i
     memcpy(ctx->in, buf, len);
 }
 
-static void dxbc_checksum_final(struct md5_ctx *ctx)
+static void md5_final(struct md5_ctx *ctx, enum vkd3d_md5_variant variant)
 {
     unsigned int padding;
-    unsigned int length;
     unsigned int count;
     unsigned char *p;
 
@@ -260,7 +264,7 @@ static void dxbc_checksum_final(struct md5_ctx *ctx)
         /* Now fill the next block */
         memset(ctx->in, 0, DXBC_CHECKSUM_BLOCK_SIZE);
     }
-    else
+    else if (variant == VKD3D_MD5_DXBC)
     {
         /* Make place for bitcount at the beginning of the block */
         memmove(&ctx->in[4], ctx->in, count);
@@ -268,33 +272,44 @@ static void dxbc_checksum_final(struct md5_ctx *ctx)
         /* Pad block to 60 bytes */
         memset(p + 4, 0, padding - 4);
     }
+    else
+    {
+        /* Pad block to 56 bytes */
+        memset(p, 0, padding - 8);
+    }
 
     /* Append length in bits and transform */
+    if (variant == VKD3D_MD5_DXBC)
+    {
+        unsigned int length;
+
         length = ctx->i[0];
         memcpy(&ctx->in[0], &length, sizeof(length));
         byte_reverse(&ctx->in[4], 14);
         length = ctx->i[0] >> 2 | 0x1;
         memcpy(&ctx->in[DXBC_CHECKSUM_BLOCK_SIZE - 4], &length, sizeof(length));
+    }
+    else
+    {
+        byte_reverse(ctx->in, 14);
+
+        ((unsigned int *)ctx->in)[14] = ctx->i[0];
+        ((unsigned int *)ctx->in)[15] = ctx->i[1];
+    }
 
     md5_transform(ctx->buf, (unsigned int *)ctx->in);
     byte_reverse((unsigned char *)ctx->buf, 4);
     memcpy(ctx->digest, ctx->buf, 16);
 }
 
-#define DXBC_CHECKSUM_SKIP_BYTE_COUNT 20
-
-void vkd3d_compute_dxbc_checksum(const void *dxbc, size_t size, uint32_t checksum[4])
+void vkd3d_compute_md5(const void *data, size_t size, uint32_t checksum[4], enum vkd3d_md5_variant variant)
 {
-    const uint8_t *ptr = dxbc;
+    const uint8_t *ptr = data;
     struct md5_ctx ctx;
 
-    VKD3D_ASSERT(size > DXBC_CHECKSUM_SKIP_BYTE_COUNT);
-    ptr += DXBC_CHECKSUM_SKIP_BYTE_COUNT;
-    size -= DXBC_CHECKSUM_SKIP_BYTE_COUNT;
-
     md5_init(&ctx);
     md5_update(&ctx, ptr, size);
-    dxbc_checksum_final(&ctx);
+    md5_final(&ctx, variant);
 
     memcpy(checksum, ctx.digest, sizeof(ctx.digest));
 }

libs/vkd3d-shader/d3d_asm.c

@@ -79,7 +79,7 @@ static const char * const shader_opcode_names[] =
     [VKD3DSIH_DCL_INDEXABLE_TEMP              ] = "dcl_indexableTemp",
     [VKD3DSIH_DCL_INPUT                       ] = "dcl_input",
     [VKD3DSIH_DCL_INPUT_CONTROL_POINT_COUNT   ] = "dcl_input_control_point_count",
-    [VKD3DSIH_DCL_INPUT_PRIMITIVE             ] = "dcl_inputPrimitive",
+    [VKD3DSIH_DCL_INPUT_PRIMITIVE             ] = "dcl_inputprimitive",
     [VKD3DSIH_DCL_INPUT_PS                    ] = "dcl_input_ps",
     [VKD3DSIH_DCL_INPUT_PS_SGV                ] = "dcl_input_ps_sgv",
     [VKD3DSIH_DCL_INPUT_PS_SIV                ] = "dcl_input_ps_siv",
@@ -89,7 +89,7 @@ static const char * const shader_opcode_names[] =
     [VKD3DSIH_DCL_OUTPUT                      ] = "dcl_output",
     [VKD3DSIH_DCL_OUTPUT_CONTROL_POINT_COUNT  ] = "dcl_output_control_point_count",
     [VKD3DSIH_DCL_OUTPUT_SIV                  ] = "dcl_output_siv",
-    [VKD3DSIH_DCL_OUTPUT_TOPOLOGY             ] = "dcl_outputTopology",
+    [VKD3DSIH_DCL_OUTPUT_TOPOLOGY             ] = "dcl_outputtopology",
     [VKD3DSIH_DCL_RESOURCE_RAW                ] = "dcl_resource_raw",
     [VKD3DSIH_DCL_RESOURCE_STRUCTURED         ] = "dcl_resource_structured",
     [VKD3DSIH_DCL_SAMPLER                     ] = "dcl_sampler",
@@ -104,7 +104,7 @@ static const char * const shader_opcode_names[] =
     [VKD3DSIH_DCL_UAV_RAW                     ] = "dcl_uav_raw",
     [VKD3DSIH_DCL_UAV_STRUCTURED              ] = "dcl_uav_structured",
     [VKD3DSIH_DCL_UAV_TYPED                   ] = "dcl_uav_typed",
-    [VKD3DSIH_DCL_VERTICES_OUT                ] = "dcl_maxOutputVertexCount",
+    [VKD3DSIH_DCL_VERTICES_OUT                ] = "dcl_maxout",
     [VKD3DSIH_DDIV                            ] = "ddiv",
     [VKD3DSIH_DEF                             ] = "def",
     [VKD3DSIH_DEFAULT                         ] = "default",
@@ -393,14 +393,13 @@ static unsigned int shader_get_float_offset(enum vkd3d_shader_register_type regi
     }
 }
 
-static void shader_dump_global_flags(struct vkd3d_d3d_asm_compiler *compiler,
-        enum vkd3d_shader_global_flags global_flags)
+static void shader_dump_global_flags(struct vkd3d_d3d_asm_compiler *compiler, enum vsir_global_flags global_flags)
 {
     unsigned int i;
 
     static const struct
     {
-        enum vkd3d_shader_global_flags flag;
+        enum vsir_global_flags flag;
         const char *name;
     }
     global_flag_info[] =
@@ -675,9 +674,6 @@ static void shader_dump_data_type(struct vkd3d_d3d_asm_compiler *compiler, enum
     {
         [VKD3D_DATA_FLOAT    ] = "float",
         [VKD3D_DATA_INT      ] = "int",
-        [VKD3D_DATA_RESOURCE ] = "resource",
-        [VKD3D_DATA_SAMPLER  ] = "sampler",
-        [VKD3D_DATA_UAV      ] = "uav",
         [VKD3D_DATA_UINT     ] = "uint",
         [VKD3D_DATA_UNORM    ] = "unorm",
         [VKD3D_DATA_SNORM    ] = "snorm",
@@ -1193,6 +1189,14 @@ static void shader_print_register(struct vkd3d_d3d_asm_compiler *compiler, const
             vkd3d_string_buffer_printf(buffer, "vWaveLaneIndex");
             break;
 
+        case VKD3DSPR_PARAMETER:
+            vkd3d_string_buffer_printf(buffer, "parameter");
+            break;
+
+        case VKD3DSPR_POINT_COORD:
+            vkd3d_string_buffer_printf(buffer, "vPointCoord");
+            break;
+
         default:
             vkd3d_string_buffer_printf(buffer, "%s<unhandled register type %#x>%s",
                     compiler->colours.error, reg->type, compiler->colours.reset);
@@ -1229,8 +1233,6 @@ static void shader_print_register(struct vkd3d_d3d_asm_compiler *compiler, const
                     case VKD3D_DATA_INT:
                         shader_print_int_literal(compiler, "", reg->u.immconst_u32[0], "");
                         break;
-                    case VKD3D_DATA_RESOURCE:
-                    case VKD3D_DATA_SAMPLER:
                     case VKD3D_DATA_UINT:
                         shader_print_uint_literal(compiler, "", reg->u.immconst_u32[0], "");
                         break;
@@ -1266,8 +1268,6 @@ static void shader_print_register(struct vkd3d_d3d_asm_compiler *compiler, const
                         shader_print_int_literal(compiler, ", ", reg->u.immconst_u32[2], "");
                         shader_print_int_literal(compiler, ", ", reg->u.immconst_u32[3], "");
                         break;
-                    case VKD3D_DATA_RESOURCE:
-                    case VKD3D_DATA_SAMPLER:
                     case VKD3D_DATA_UINT:
                         shader_print_uint_literal(compiler, "", reg->u.immconst_u32[0], "");
                         shader_print_uint_literal(compiler, ", ", reg->u.immconst_u32[1], "");
@@ -1319,6 +1319,23 @@ static void shader_print_register(struct vkd3d_d3d_asm_compiler *compiler, const
         }
         vkd3d_string_buffer_printf(buffer, ")");
     }
+    else if (compiler->flags & VSIR_ASM_FLAG_DUMP_ALL_INDICES)
+    {
+        unsigned int i = 0;
+
+        if (reg->idx_count == 0 || reg->idx[0].rel_addr)
+        {
+            vkd3d_string_buffer_printf(buffer, "%s", compiler->colours.reset);
+        }
+        else
+        {
+            vkd3d_string_buffer_printf(buffer, "%u%s", offset, compiler->colours.reset);
+            i = 1;
+        }
+
+        for (; i < reg->idx_count; ++i)
+            shader_print_subscript(compiler, reg->idx[i].offset, reg->idx[i].rel_addr);
+    }
     else if (reg->type != VKD3DSPR_RASTOUT
             && reg->type != VKD3DSPR_MISCTYPE
             && reg->type != VKD3DSPR_NULL
@@ -2258,7 +2275,7 @@ static const char *get_semantic_register_name(enum vkd3d_shader_sysval_semantic
     }
 }
 
-static enum vkd3d_result dump_signature(struct vkd3d_d3d_asm_compiler *compiler,
+static enum vkd3d_result dump_dxbc_signature(struct vkd3d_d3d_asm_compiler *compiler,
         const char *name, const char *register_name, const struct shader_signature *signature)
 {
     struct vkd3d_string_buffer *buffer = &compiler->buffer;
@@ -2325,21 +2342,21 @@ static enum vkd3d_result dump_signature(struct vkd3d_d3d_asm_compiler *compiler,
     return VKD3D_OK;
 }
 
-static enum vkd3d_result dump_signatures(struct vkd3d_d3d_asm_compiler *compiler,
+static enum vkd3d_result dump_dxbc_signatures(struct vkd3d_d3d_asm_compiler *compiler,
         const struct vsir_program *program)
 {
     enum vkd3d_result ret;
 
-    if ((ret = dump_signature(compiler, ".input",
+    if ((ret = dump_dxbc_signature(compiler, ".input",
             program->shader_version.type == VKD3D_SHADER_TYPE_DOMAIN ? "vicp" : "v",
             &program->input_signature)) < 0)
         return ret;
 
-    if ((ret = dump_signature(compiler, ".output", "o",
+    if ((ret = dump_dxbc_signature(compiler, ".output", "o",
             &program->output_signature)) < 0)
         return ret;
 
-    if ((ret = dump_signature(compiler, ".patch_constant",
+    if ((ret = dump_dxbc_signature(compiler, ".patch_constant",
             program->shader_version.type == VKD3D_SHADER_TYPE_DOMAIN ? "vpc" : "o",
             &program->patch_constant_signature)) < 0)
         return ret;
@@ -2427,7 +2444,7 @@ enum vkd3d_result d3d_asm_compile(const struct vsir_program *program,
      * doesn't even have an explicit concept of signature. */
     if (formatting & VKD3D_SHADER_COMPILE_OPTION_FORMATTING_IO_SIGNATURES && shader_version->major >= 4)
     {
-        if ((result = dump_signatures(&compiler, program)) < 0)
+        if ((result = dump_dxbc_signatures(&compiler, program)) < 0)
         {
             vkd3d_string_buffer_cleanup(buffer);
             return result;
@@ -2489,12 +2506,58 @@ enum vkd3d_result d3d_asm_compile(const struct vsir_program *program,
     return result;
 }
 
-void vkd3d_shader_trace(const struct vsir_program *program)
+/* This is meant exclusively for development use. Therefore, differently from
+ * dump_dxbc_signature(), it doesn't try particularly hard to make the output
+ * nice or easily parsable, and it dumps all fields, not just the DXBC ones.
+ * This format isn't meant to be stable. */
+static void trace_signature(const struct shader_signature *signature, const char *signature_type)
 {
-    const char *p, *q, *end;
-    struct vkd3d_shader_code code;
+    struct vkd3d_string_buffer buffer;
+    unsigned int i;
 
-    if (d3d_asm_compile(program, NULL, &code, VSIR_ASM_FLAG_DUMP_TYPES) != VKD3D_OK)
+    TRACE("%s signature:%s\n", signature_type, signature->element_count == 0 ? " empty" : "");
+
+    vkd3d_string_buffer_init(&buffer);
+
+    for (i = 0; i < signature->element_count; ++i)
+    {
+        const struct signature_element *element = &signature->elements[i];
+
+        vkd3d_string_buffer_clear(&buffer);
+
+        vkd3d_string_buffer_printf(&buffer, "Element %u: %s %u-%u %s", i,
+                get_component_type_name(element->component_type),
+                element->register_index, element->register_index + element->register_count,
+                element->semantic_name);
+        if (element->semantic_index != -1)
+            vkd3d_string_buffer_printf(&buffer, "%u", element->semantic_index);
+        vkd3d_string_buffer_printf(&buffer,
+                " mask %#x used_mask %#x sysval %s min_precision %s interpolation %u stream %u",
+                element->mask, element->used_mask, get_sysval_semantic_name(element->sysval_semantic),
+                get_minimum_precision_name(element->min_precision), element->interpolation_mode,
+                element->stream_index);
+        if (element->target_location != -1)
+            vkd3d_string_buffer_printf(&buffer, " target %u", element->target_location);
+        else
+            vkd3d_string_buffer_printf(&buffer, " unused");
+
+        TRACE("%s\n", buffer.buffer);
+    }
+
+    vkd3d_string_buffer_cleanup(&buffer);
+}
+
+void vsir_program_trace(const struct vsir_program *program)
+{
+    const unsigned int flags = VSIR_ASM_FLAG_DUMP_TYPES | VSIR_ASM_FLAG_DUMP_ALL_INDICES;
+    struct vkd3d_shader_code code;
+    const char *p, *q, *end;
+
+    trace_signature(&program->input_signature, "Input");
+    trace_signature(&program->output_signature, "Output");
+    trace_signature(&program->patch_constant_signature, "Patch-constant");
+
+    if (d3d_asm_compile(program, NULL, &code, flags) != VKD3D_OK)
         return;
 
     end = (const char *)code.code + code.size;