Release 1.5.

Broken for me with "AMD Radeon RX 560 Series (RADV POLARIS11)" (1002:67ef) but works with llvmpipe; Mesa 22.2.0-rc3.

ANNOUNCE

@@ -1,156 +1,50 @@
-The Wine team is proud to announce that release 1.3 of vkd3d, the Direct3D to
+The Wine team is proud to announce that release 1.5 of vkd3d, the Direct3D to
 Vulkan translation library, is now available.
 
 This release contains improvements that are listed in the release notes below.
 The main highlights are:
 
-  - Initial HLSL compilation support.
+  - Support for various HLSL features and intrinsics.
-  - Shader model 5.1 descriptor array support.
+  - Typed unordered access view loads of multicomponent formats.
-  - Support for disassembling Direct3D shaders.
+  - Miscellaneous bug fixes.
 
 The source is available from the following location:
 
-  https://dl.winehq.org/vkd3d/source/vkd3d-1.3.tar.xz
+  https://dl.winehq.org/vkd3d/source/vkd3d-1.5.tar.xz
 
 The current source can also be pulled directly from the git repository:
 
-  https://source.winehq.org/git/vkd3d.git/
+  https://gitlab.winehq.org/wine/vkd3d.git
 
 Vkd3d is available thanks to the work of multiple people. See the file AUTHORS
 for the complete list.
 
 ----------------------------------------------------------------
 
-What's new in vkd3d 1.3
+What's new in vkd3d 1.5
 =======================
 
 
-*** libvkd3d
-
-- Newly implemented Direct3D 12 features:
-  - Root signature support for unbounded descriptor tables.
-  - Unordered-access view counters in pixel shaders. These were previously
-    only supported in compute shaders.
-  - Output merger logical operations.
-  - Retrieving CPU/GPU timestamp calibration values. This requires support for
-    the VK_EXT_calibrated_timestamps extension.
-  - The `mirror_once' texture addressing mode. This requires support for the
-    VK_KHR_sampler_mirror_clamp_to_edge extension.
-
-- New interfaces:
-  - The vkd3d_host_time_domain_info structure extends the
-    vkd3d_instance_create_info structure, and can be used to specify how to
-    convert between timestamps and tick counts. If left unspecified, a tick
-    is assumed to take 100 nanoseconds.
-
-- Various bug fixes.
-
-
 *** libvkd3d-shader
 
-- New features:
+- New features for the HLSL source type:
-  - Initial support for HLSL compilation and preprocessing. This is an ongoing
+  - Improved support for HLSL object types (like e.g. `Texture2D') inside
-    effort; although support for many features is already implemented, support
+    structures and arrays.
-    for many more isn't yet.
+  - Implicitly sized array initialisers.
-  - Support for disassembling Direct3D byte-code shaders to Direct3D assembly.
+  - Support for the dot() intrinsic function.
-  - Support for parsing the legacy Direct3D byte-code format used by Direct3D
+  - Support for the ldexp() intrinsic function.
-    shader model 1, 2, and 3 shaders. In the current vkd3d-shader release,
+  - Support for the lerp() intrinsic function.
-    only Direct3D assembly is supported as a target for these; we intend to
+  - Support for the logical `and', `or', and `not' operators in shader model 4
-    support SPIR-V as a target in a future release.
+    and 5 targets.
-
+  - Support for casts from `bool' types in shader model 4 and 5 targets.
-- New features for the SPIR-V target:
+  - Constant folding for integer bitwise operations.
-  - Support for various aspects of Direct3D shader model 5.1 descriptor
+  - Constant folding for integer min() and max().
-    arrays, including unbounded descriptor arrays, UAV counter arrays, dynamic
-    indexing of descriptor arrays, and non-uniform indexing of descriptor
-    arrays. With the exception of some special cases, this requires support
-    for the SPV_EXT_descriptor_indexing extension in the target environment.
-  - Support for double precision floating-point operations.
-  - Support for indirect addressing of tessellation control shader inputs.
-  - Stencil export. I.e., writing stencil values from shaders. This requires
-    support for the SPV_EXT_shader_stencil_export extension in the target
-    environment.
-  - Support for the Direct3D shader model 4+ `precise' modifier.
-  - Support for Direct3D shader model 4+ global resource memory barriers.
-
-New interfaces:
-  - vkd3d_shader_preprocess() provides support for preprocessing shaders.
-  - The vkd3d_shader_preprocess_info structure extends the
-    vkd3d_shader_compile_info structure, and can be used to specify
-    preprocessing parameters like preprocessor macro definitions.
-  - The vkd3d_shader_hlsl_source_info structure extends the
-    vkd3d_shader_compile_info structure, and can be used to specify HLSL
-    compilation parameters like the target profile and entry point.
-  - The vkd3d_shader_descriptor_offset_info structure extends the
-    vkd3d_shader_interface_info structure, and can be used to specify offsets
-    into descriptor arrays referenced by shader interface bindings. This
-    allows mapping multiple descriptor arrays in a shader to a single binding
-    point in the target environment, and helps with mapping between the
-    Direct3D 12 and Vulkan binding models.
-  - The VKD3D_SHADER_COMPILE_OPTION_API_VERSION compile option can
-    be used to specify the version of the libvkd3d-shader API the
-    application is targetting. If left unspecified,
-    VKD3D_SHADER_API_VERSION_1_2 will be used.
-
-- Various shader translation fixes, for tessellation shaders in particular.
-
-
-*** vkd3d-compiler
-
-- New source and target types:
-  - The `hlsl' source type specifies High Level Shader Language source code.
-  - The `d3d-asm' target type specifies Direct3D assembly shaders.
-  - The `d3dbc' format specifies legacy Direct3D byte-code, which is used for
-    Direct3D shader model 1, 2, and 3 shaders.
-  - The existing `dxbc-tpf' format can now also be used as a target format.
-
-- New command line options:
-  - `-E' can be used to specify the input should only be preprocessed.
-  - `-e'/`--entry' can be used to specify the entry point for HLSL and/or
-    SPIR-V shaders.
-  - `-p'/`--profile' can be used to specify the target profile for HLSL
-    shaders.
-
-- When no source type is explicitly specified, vkd3d-compiler will attempt to
-  determine the source type from the provided input. Note that this is
-  intended as a convenience for interactive usage only, and the heuristics
-  used are subject to future change. Non-interactive usage of vkd3d-compiler,
-  for example in build scripts, should always explicitly specify source and
-  target types.
-
-- When no target type is explicitly specified, a default will be chosen based
-  on the source type. Like the earlier mentioned source type detection, this
-  is intended for interactive usage only.
-
-- vkd3d-compiler will default to colour output if it can determine that the
-  output is a colour-capable teleprinter.
-
-- New environment variables:
-  - NO_COLOUR/NO_COLOR can be used to disable default colour output.
-  See the README for more detailed descriptions and how to use these.
-
-
-*** libvkd3d-utils
 
 - New interfaces:
-  - D3DCreateBlob() provides support for creating ID3DBlob objects.
+  - The VKD3D_SHADER_COMPILE_OPTION_TYPED_UAV compile option can be used to
-  - D3DPreprocess() provides support for preprocessing HLSL source code.
+    specify the SPIR-V format to use for typed unordered access view loads.
-  - D3DCompile() and D3DCompile2() provide support for compiling HLSL source
+    When set to `Unknown', and the `shaderStorageImageReadWithoutFormat'
-    code.
+    feature is enabled in the target environment, this allows typed loads from
-
+    multicomponent format unordered access views. If left unspecified, a R32
-
+    format will be used, like in previous versions of libvkd3d-shader.
-*** build
-
-- The `gears' and `triangle' demo applications are installed as `vkd3d-gears'
-  and `vkd3d-triangle'. These were originally intended more as documentation
-  than as end-user executables, but there's some value in using them for
-  diagnostic purposes, much like e.g. `glxgears'.
-
-- The VULKAN_LIBS configure variable is used when detecting the Vulkan
-  library.
-
-- Builds for the Microsoft Windows target platform no longer require support
-  for POSIX threads. Windows synchronisation primitives are used instead.
-
-- If ncurses is available, it will be use by vkd3d-compiler to determine the
-  capabilities of the connected teleprinter, if any.
 

AUTHORS

@@ -5,8 +5,10 @@ Atharva Nimbalkar
 Biswapriyo Nath
 Chip Davis
 Conor McCarthy
+David Gow
 Derek Lesho
 Francisco Casas
+Francois Gouget
 Giovanni Mascellani
 Hans-Kristian Arntzen
 Henri Verbeet
@@ -14,6 +16,7 @@ Isabella Bosia
 Jactry Zeng
 Joshua Ashton
 Józef Kucia
+Martin Storsjö
 Matteo Bruni
 Nikolay Sivov
 Philip Rebohle

Makefile.am

@@ -52,6 +52,12 @@ vkd3d_cross_tests = \
 
 vkd3d_shader_tests = \
 	tests/abs.shader_test \
+	tests/arithmetic-float.shader_test \
+	tests/arithmetic-int.shader_test \
+	tests/arithmetic-int-uniform.shader_test \
+	tests/arithmetic-uint.shader_test \
+	tests/bitwise.shader_test \
+	tests/cast-broadcast.shader_test \
 	tests/cast-to-float.shader_test \
 	tests/cast-to-half.shader_test \
 	tests/cast-to-int.shader_test \
@@ -63,6 +69,7 @@ vkd3d_shader_tests = \
 	tests/hlsl-clamp.shader_test \
 	tests/hlsl-comma.shader_test \
 	tests/hlsl-cross.shader_test \
+	tests/hlsl-dot.shader_test \
 	tests/hlsl-duplicate-modifiers.shader_test \
 	tests/hlsl-for.shader_test \
 	tests/hlsl-function.shader_test \
@@ -72,20 +79,25 @@ vkd3d_shader_tests = \
 	tests/hlsl-gather.shader_test \
 	tests/hlsl-initializer-flatten.shader_test \
 	tests/hlsl-initializer-invalid-arg-count.shader_test \
+	tests/hlsl-initializer-implicit-array.shader_test \
 	tests/hlsl-initializer-local-array.shader_test \
+	tests/hlsl-initializer-objects.shader_test \
 	tests/hlsl-initializer-nested.shader_test \
 	tests/hlsl-initializer-numeric.shader_test \
+	tests/hlsl-initializer-matrix.shader_test \
 	tests/hlsl-initializer-static-array.shader_test \
 	tests/hlsl-initializer-struct.shader_test \
 	tests/hlsl-intrinsic-override.shader_test \
 	tests/hlsl-invalid.shader_test \
+	tests/hlsl-ldexp.shader_test \
+	tests/hlsl-lerp.shader_test \
 	tests/hlsl-majority-pragma.shader_test \
 	tests/hlsl-majority-typedef.shader_test \
+	tests/hlsl-matrix-indexing.shader_test \
 	tests/hlsl-mul.shader_test \
 	tests/hlsl-nested-arrays.shader_test \
 	tests/hlsl-numeric-constructor-truncation.shader_test \
 	tests/hlsl-numeric-types.shader_test \
-	tests/hlsl-operations.shader_test \
 	tests/hlsl-return-implicit-conversion.shader_test \
 	tests/hlsl-return-void.shader_test \
 	tests/hlsl-shape.shader_test \
@@ -93,11 +105,17 @@ vkd3d_shader_tests = \
 	tests/hlsl-state-block-syntax.shader_test \
 	tests/hlsl-static-initializer.shader_test \
 	tests/hlsl-storage-qualifiers.shader_test \
+	tests/hlsl-struct-array.shader_test \
 	tests/hlsl-struct-assignment.shader_test \
 	tests/hlsl-struct-semantics.shader_test \
 	tests/hlsl-vector-indexing.shader_test \
 	tests/hlsl-vector-indexing-uniform.shader_test \
+	tests/logic-operations.shader_test \
 	tests/math.shader_test \
+	tests/matrix-semantics.shader_test \
+	tests/multiple-rt.shader_test \
+	tests/nointerpolation.shader_test \
+	tests/object-references.shader_test
 	tests/pow.shader_test \
 	tests/preproc-if.shader_test \
 	tests/preproc-ifdef.shader_test \
@@ -109,6 +127,7 @@ vkd3d_shader_tests = \
 	tests/sampler.shader_test \
 	tests/sampler-offset.shader_test \
 	tests/saturate.shader_test \
+	tests/shader-interstage-interface.shader_test \
 	tests/swizzle-0.shader_test \
 	tests/swizzle-1.shader_test \
 	tests/swizzle-2.shader_test \
@@ -120,6 +139,7 @@ vkd3d_shader_tests = \
 	tests/texture-load.shader_test \
 	tests/texture-load-typed.shader_test \
 	tests/trigonometry.shader_test \
+	tests/uav.shader_test \
 	tests/writemask-assignop-0.shader_test \
 	tests/writemask-assignop-1.shader_test \
 	tests/writemask-assignop-2.shader_test \
@@ -129,7 +149,8 @@ vkd3d_test_headers = \
 	tests/d3d12_crosstest.h \
 	tests/d3d12_test_utils.h \
 	tests/shader_runner.h \
-	tests/utils.h
+	tests/utils.h \
+	tests/vulkan_procs.h
 
 vkd3d_demos = \
 	demos/vkd3d-gears \
@@ -221,7 +242,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 2:0:1
+libvkd3d_shader_la_LDFLAGS = $(AM_LDFLAGS) -version-info 4:0:3
 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
@@ -255,7 +276,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 4:0:3
+libvkd3d_la_LDFLAGS = $(AM_LDFLAGS) -version-info 6:0:5
 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
@@ -267,7 +288,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 3:0:2
+libvkd3d_utils_la_LDFLAGS = $(AM_LDFLAGS) -version-info 4:1:3
 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
@@ -290,7 +311,7 @@ vkd3d_compiler_SOURCES = programs/vkd3d-compiler/main.c
 vkd3d_compiler_CFLAGS = $(AM_CFLAGS) @NCURSES_CFLAGS@
 vkd3d_compiler_LDADD = libvkd3d-shader.la @NCURSES_LIBS@
 
-LDADD = libvkd3d.la libvkd3d-utils.la
+LDADD = libvkd3d.la libvkd3d-shader.la libvkd3d-utils.la
 AM_DEFAULT_SOURCE_EXT = .c
 
 TEST_EXTENSIONS = .shader_test
@@ -298,59 +319,23 @@ TEST_EXTENSIONS = .shader_test
 if BUILD_TESTS
 check_PROGRAMS = $(vkd3d_tests) $(vkd3d_cross_tests) tests/shader_runner
 TESTS = $(vkd3d_tests) $(vkd3d_cross_tests) $(vkd3d_shader_tests)
-tests_d3d12_LDADD = $(LDADD) @PTHREAD_LIBS@ @VULKAN_LIBS@
+tests_d3d12_LDADD = $(LDADD) @PTHREAD_LIBS@ @DL_LIBS@
-tests_d3d12_invalid_usage_LDADD = $(LDADD) @VULKAN_LIBS@
+tests_d3d12_invalid_usage_LDADD = $(LDADD) @DL_LIBS@
-tests_hlsl_d3d12_LDADD = $(LDADD) @VULKAN_LIBS@
+tests_hlsl_d3d12_LDADD = $(LDADD) @DL_LIBS@
-tests_shader_runner_LDADD = $(LDADD) @VULKAN_LIBS@
+tests_shader_runner_LDADD = $(LDADD) @DL_LIBS@
 tests_shader_runner_SOURCES = \
 	tests/shader_runner.c \
-	tests/shader_runner_d3d12.c
+	tests/shader_runner_d3d12.c \
-tests_vkd3d_api_LDADD = libvkd3d.la @VULKAN_LIBS@
+	tests/shader_runner_vulkan.c
+tests_vkd3d_api_LDADD = libvkd3d.la @DL_LIBS@
 tests_vkd3d_shader_api_LDADD = libvkd3d-shader.la
 SHADER_TEST_LOG_COMPILER = tests/shader_runner
-XFAIL_TESTS = \
-	tests/cast-to-float.shader_test \
-	tests/cast-to-half.shader_test \
-	tests/cast-to-int.shader_test \
-	tests/cast-to-uint.shader_test \
-	tests/hlsl-array-dimension.shader_test \
-	tests/hlsl-initializer-flatten.shader_test \
-	tests/hlsl-initializer-invalid-arg-count.shader_test \
-	tests/hlsl-initializer-local-array.shader_test \
-	tests/hlsl-initializer-nested.shader_test \
-	tests/hlsl-initializer-numeric.shader_test \
-	tests/hlsl-initializer-static-array.shader_test \
-	tests/hlsl-initializer-struct.shader_test \
-	tests/hlsl-duplicate-modifiers.shader_test \
-	tests/hlsl-for.shader_test \
-	tests/hlsl-function.shader_test \
-	tests/hlsl-function-cast.shader_test \
-	tests/hlsl-function-overload.shader_test \
-	tests/hlsl-gather.shader_test \
-	tests/hlsl-intrinsic-override.shader_test \
-	tests/hlsl-majority-pragma.shader_test \
-	tests/hlsl-majority-typedef.shader_test \
-	tests/hlsl-mul.shader_test \
-	tests/hlsl-nested-arrays.shader_test \
-	tests/hlsl-numeric-constructor-truncation.shader_test \
-	tests/hlsl-numeric-types.shader_test \
-	tests/hlsl-operations.shader_test \
-	tests/hlsl-return-implicit-conversion.shader_test \
-	tests/hlsl-return-void.shader_test \
-	tests/hlsl-shape.shader_test \
-	tests/hlsl-static-initializer.shader_test \
-	tests/hlsl-storage-qualifiers.shader_test \
-	tests/hlsl-vector-indexing.shader_test \
-	tests/hlsl-vector-indexing-uniform.shader_test \
-	tests/max.shader_test \
-	tests/sampler-offset.shader_test \
-	tests/trigonometry.shader_test
 endif
 
 EXTRA_DIST += $(vkd3d_shader_tests)
 
 if BUILD_DEMOS
-DEMOS_LDADD = $(LDADD) libvkd3d-shader.la @DEMO_LIBS@ @VULKAN_LIBS@
+DEMOS_LDADD = $(LDADD) libvkd3d-shader.la @DL_LIBS@ @DEMO_LIBS@
 DEMOS_CFLAGS = $(AM_CFLAGS) @DEMO_CFLAGS@
 bin_PROGRAMS += $(vkd3d_demos)
 
@@ -425,9 +410,11 @@ cross_implibs = crosslibs/d3d12
 CROSS_CPPFLAGS = -I$(srcdir)/include -I$(srcdir)/include/private -I$(builddir)/include
 CROSS_CFLAGS = -g -O2 -Wall -municode ${CROSS_CPPFLAGS} -D__USE_MINGW_ANSI_STDIO=0
 EXTRA_DIST += $(cross_implibs:=.cross32.def) $(cross_implibs:=.cross64.def)
+EXTRA_DIST += tests/shader_runner_d3d11.c tests/shader_runner_d3d9.c
 
 shader_runner_cross_sources = \
 	$(srcdir)/tests/shader_runner.c \
+	$(srcdir)/tests/shader_runner_d3d9.c \
 	$(srcdir)/tests/shader_runner_d3d11.c \
 	$(srcdir)/tests/shader_runner_d3d12.c
 
@@ -435,11 +422,20 @@ if HAVE_CROSSTARGET32
 CROSS32_CC = @CROSSCC32@
 CROSS32_DLLTOOL = @CROSSTARGET32@-dlltool
 CROSS32_IMPLIBS = $(cross_implibs:=.cross32.a)
-CROSS32_EXEFILES = $(vkd3d_cross_tests:=.cross32.exe) \
+CROSS32_EXEFILES =
-	$(vkd3d_demos:demos/vkd3d-%=demos/%.cross32.exe)
+if BUILD_TESTS
-CROSS32_FILES = $(CROSS32_IMPLIBS) $(CROSS32_EXEFILES) tests/shader_runner.cross32.exe
+CROSS32_EXEFILES += $(vkd3d_cross_tests:=.cross32.exe)
+endif
+if BUILD_DEMOS
+CROSS32_EXEFILES += $(vkd3d_demos:demos/vkd3d-%=demos/%.cross32.exe)
+endif
 
-CLEANFILES += $(CROSS32_FILES)
+CROSS32_FILES = $(CROSS32_EXEFILES)
+if BUILD_TESTS
+CROSS32_FILES += tests/shader_runner.cross32.exe
+endif
+
+CLEANFILES += $(CROSS32_IMPLIBS) $(CROSS32_FILES)
 crosstest32: $(CROSS32_FILES)
 
 -include tests/$(DEPDIR)/*.cross32.Po
@@ -467,11 +463,20 @@ if HAVE_CROSSTARGET64
 CROSS64_CC = @CROSSCC64@
 CROSS64_DLLTOOL = @CROSSTARGET64@-dlltool
 CROSS64_IMPLIBS = $(cross_implibs:=.cross64.a)
-CROSS64_EXEFILES = $(vkd3d_cross_tests:=.cross64.exe) \
+CROSS64_EXEFILES =
-	$(vkd3d_demos:demos/vkd3d-%=demos/%.cross64.exe)
+if BUILD_TESTS
-CROSS64_FILES = $(CROSS64_IMPLIBS) $(CROSS64_EXEFILES) tests/shader_runner.cross64.exe
+CROSS64_EXEFILES += $(vkd3d_cross_tests:=.cross64.exe)
+endif
+if BUILD_DEMOS
+CROSS64_EXEFILES += $(vkd3d_demos:demos/vkd3d-%=demos/%.cross64.exe)
+endif
 
-CLEANFILES += $(CROSS64_FILES)
+CROSS64_FILES = $(CROSS64_EXEFILES)
+if BUILD_TESTS
+CROSS64_FILES += tests/shader_runner.cross64.exe
+endif
+
+CLEANFILES += $(CROSS64_IMPLIBS) $(CROSS64_FILES)
 crosstest64: $(CROSS64_FILES)
 
 -include tests/$(DEPDIR)/*.cross64.Po

README

@@ -9,7 +9,7 @@ similar, but not identical, to Direct3D 12.
 Building vkd3d
 ==============
 
-Vkd3d depends on SPIRV-Headers and Vulkan-Headers (>= 1.1.113).
+Vkd3d depends on SPIRV-Headers and Vulkan-Headers (>= 1.2.139).
 
 Vkd3d generates some of its headers from IDL files. If you are using the
 release tarballs, then these headers are pre-generated and are included. If
@@ -51,6 +51,9 @@ commas or semicolons.
    even when the output supports colour.
 
  * VKD3D_CONFIG - a list of options that change the behavior of libvkd3d.
+    * virtual_heaps - Create descriptors for each D3D12 root signature
+      descriptor range instead of entire descriptor heaps. Useful when push
+      constant or bound descriptor limits are exceeded.
     * vk_debug - enables Vulkan debug extensions.
 
  * VKD3D_DEBUG - controls the debug level for log messages produced by

configure.ac

@@ -1,5 +1,5 @@
 AC_PREREQ([2.69])
-AC_INIT([vkd3d],[1.3])
+AC_INIT([vkd3d],[1.5])
 
 AC_CONFIG_AUX_DIR([bin])
 AC_CONFIG_MACRO_DIR([m4])
@@ -81,7 +81,7 @@ AS_IF([test "x$ac_cv_header_spirv_unified1_GLSL_std_450_h" != "xyes" \
        -a "x$ac_cv_header_vulkan_GLSL_std_450_h" != "xyes"],
       [AC_MSG_ERROR([GLSL.std.450.h not found.])])
 
-VKD3D_CHECK_VULKAN_HEADER_VERSION([113], [AC_MSG_ERROR([Vulkan headers are too old, 1.1.113 is required.])])
+VKD3D_CHECK_VULKAN_HEADER_VERSION([139], [AC_MSG_ERROR([Vulkan headers are too old, 1.2.139 is required.])])
 
 AC_CHECK_DECL([SpvCapabilityDemoteToHelperInvocationEXT],, [AC_MSG_ERROR([SPIR-V headers are too old.])], [
 #ifdef HAVE_SPIRV_UNIFIED1_SPIRV_H
@@ -112,8 +112,11 @@ case $host_os in
      ;;
 esac
 
+AC_ARG_VAR([SONAME_LIBVULKAN], [shared object name for the Vulkan library])
 AC_ARG_VAR([VULKAN_LIBS], [linker flags for the Vulkan library])
-VKD3D_CHECK_VULKAN
+AS_IF([test "x$SONAME_LIBVULKAN" = "x"],
+      [VKD3D_CHECK_VULKAN],
+      [AC_DEFINE_UNQUOTED([SONAME_LIBVULKAN],["$SONAME_LIBVULKAN"],[Define to the shared object name of the Vulkan library.])])
 
 AS_IF([test "x$with_ncurses" != "xno"],
       [PKG_CHECK_MODULES([NCURSES], [ncurses],
@@ -126,7 +129,7 @@ AS_IF([test "x$with_spirv_tools" = "xyes"],
 
 HAVE_XCB=no
 AS_IF([test "x$with_xcb" != "xno"],
-      [PKG_CHECK_MODULES([XCB], [xcb xcb-keysyms],
+      [PKG_CHECK_MODULES([XCB], [xcb xcb-event xcb-icccm xcb-keysyms],
                                 [AC_DEFINE([HAVE_XCB], [1], [Define to 1 if you have libxcb.])
                                 HAVE_XCB=yes],
                                 [HAVE_XCB=no])])
@@ -162,9 +165,11 @@ AC_OUTPUT
 
 dnl Output configuration summary
 AS_IF([test "x$CROSSTARGET32" != "xno" -o "x$CROSSTARGET64" != "xno"],
-      [HAVE_CROSSTEST=yes], [HAVE_CROSSTEST=no])
+      [HAVE_CROSSTARGET=yes], [HAVE_CROSSTARGET=no])
 AS_IF([test $DX_FLAG_doc = 1], [HAVE_DOCS=yes], [HAVE_DOCS=no])
 
+AS_IF([test "x$enable_demos" != "xyes" -a "x$enable_tests" = "xno"], [CROSSTARGET64=no CROSSTARGET32=no])
+
 AS_ECHO(["
   Configuration summary for $PACKAGE $VERSION
 
@@ -177,8 +182,10 @@ AS_ECHO(["
   Building demos: ${enable_demos}
   Building tests: ${enable_tests}
   Building documentation: ${HAVE_DOCS}
+"])
 
-  Building crosstests: ${HAVE_CROSSTEST}"])
+AS_IF([test "x$enable_demos" = "xyes"], [AS_ECHO(["  Cross-compiling demos: ${HAVE_CROSSTARGET}"])])
+AS_IF([test "x$enable_tests" != "xno"], [AS_ECHO(["  Cross-compiling tests: ${HAVE_CROSSTARGET}"])])
 AS_IF([test "x$CROSSTARGET32" != "xno"], [AS_ECHO(["    Using 32-bit cross compiler: $CROSSCC32"])])
 AS_IF([test "x$CROSSTARGET64" != "xno"], [AS_ECHO(["    Using 64-bit cross compiler: $CROSSCC64"])])
 AS_ECHO([])

demos/demo_xcb.h

@@ -17,18 +17,65 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
+#define VK_NO_PROTOTYPES
 #define VK_USE_PLATFORM_XCB_KHR
-#define VKD3D_UTILS_API_VERSION VKD3D_API_VERSION_1_3
+#define VKD3D_UTILS_API_VERSION VKD3D_API_VERSION_1_5
+#include "config.h"
 #include <vkd3d.h>
 #include <vkd3d_utils.h>
 #include <xcb/xcb_event.h>
 #include <xcb/xcb_icccm.h>
 #include <xcb/xcb_keysyms.h>
 #include <sys/stat.h>
+#include <dlfcn.h>
 #include <limits.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <stdbool.h>
+#include <stdio.h>
+
+#define DECLARE_VK_PFN(name) PFN_##name name;
+DECLARE_VK_PFN(vkAcquireNextImageKHR)
+DECLARE_VK_PFN(vkCreateFence)
+DECLARE_VK_PFN(vkCreateSwapchainKHR)
+DECLARE_VK_PFN(vkCreateXcbSurfaceKHR)
+DECLARE_VK_PFN(vkDestroyFence)
+DECLARE_VK_PFN(vkDestroySurfaceKHR)
+DECLARE_VK_PFN(vkDestroySwapchainKHR)
+DECLARE_VK_PFN(vkGetPhysicalDeviceSurfaceCapabilitiesKHR)
+DECLARE_VK_PFN(vkGetPhysicalDeviceSurfaceFormatsKHR)
+DECLARE_VK_PFN(vkGetPhysicalDeviceSurfaceSupportKHR)
+DECLARE_VK_PFN(vkGetSwapchainImagesKHR)
+DECLARE_VK_PFN(vkQueuePresentKHR)
+DECLARE_VK_PFN(vkResetFences)
+DECLARE_VK_PFN(vkWaitForFences)
+
+static void load_vulkan_procs(void)
+{
+    void *libvulkan;
+
+    if (!(libvulkan = dlopen(SONAME_LIBVULKAN, RTLD_NOW)))
+    {
+        fprintf(stderr, "Failed to load %s: %s.\n", SONAME_LIBVULKAN, dlerror());
+        exit(1);
+    }
+
+#define LOAD_VK_PFN(name) name = (void *)dlsym(libvulkan, #name);
+    LOAD_VK_PFN(vkAcquireNextImageKHR)
+    LOAD_VK_PFN(vkCreateFence)
+    LOAD_VK_PFN(vkCreateSwapchainKHR)
+    LOAD_VK_PFN(vkCreateXcbSurfaceKHR)
+    LOAD_VK_PFN(vkDestroyFence)
+    LOAD_VK_PFN(vkDestroySurfaceKHR)
+    LOAD_VK_PFN(vkDestroySwapchainKHR)
+    LOAD_VK_PFN(vkGetPhysicalDeviceSurfaceCapabilitiesKHR)
+    LOAD_VK_PFN(vkGetPhysicalDeviceSurfaceFormatsKHR)
+    LOAD_VK_PFN(vkGetPhysicalDeviceSurfaceSupportKHR)
+    LOAD_VK_PFN(vkGetSwapchainImagesKHR)
+    LOAD_VK_PFN(vkQueuePresentKHR)
+    LOAD_VK_PFN(vkResetFences)
+    LOAD_VK_PFN(vkWaitForFences)
+}
 
 struct demo
 {
@@ -330,6 +377,8 @@ static inline struct demo_swapchain *demo_swapchain_create(ID3D12CommandQueue *c
     VkImage *vk_images;
     VkFormat format;
 
+    load_vulkan_procs();
+
     if ((format = vkd3d_get_vk_format(desc->format)) == VK_FORMAT_UNDEFINED)
         return NULL;
 

include/private/list.h

@@ -150,8 +150,8 @@ static inline unsigned int list_count( const struct list *list )
     return count;
 }
 
-/* move all elements from src to the tail of dst */
+/* move all elements from src to before the specified element */
-static inline void list_move_tail( struct list *dst, struct list *src )
+static inline void list_move_before( struct list *dst, struct list *src )
 {
     if (list_empty(src)) return;
 
@@ -162,8 +162,8 @@ static inline void list_move_tail( struct list *dst, struct list *src )
     list_init(src);
 }
 
-/* move all elements from src to the head of dst */
+/* move all elements from src to after the specified element */
-static inline void list_move_head( struct list *dst, struct list *src )
+static inline void list_move_after( struct list *dst, struct list *src )
 {
     if (list_empty(src)) return;
 
@@ -174,6 +174,18 @@ static inline void list_move_head( struct list *dst, struct list *src )
     list_init(src);
 }
 
+/* move all elements from src to the head of dst */
+static inline void list_move_head( struct list *dst, struct list *src )
+{
+    list_move_after( dst, src );
+}
+
+/* move all elements from src to the tail of dst */
+static inline void list_move_tail( struct list *dst, struct list *src )
+{
+    list_move_before( dst, src );
+}
+
 /* iterate through the list */
 #define LIST_FOR_EACH(cursor,list) \
     for ((cursor) = (list)->next; (cursor) != (list); (cursor) = (cursor)->next)

include/private/vkd3d_common.h

@@ -27,6 +27,7 @@
 #include <limits.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include <stdio.h>
 
 #ifdef _MSC_VER
 #include <intrin.h>
@@ -210,6 +211,10 @@ static inline LONG InterlockedIncrement(LONG volatile *x)
 {
     return __sync_add_and_fetch(x, 1);
 }
+static inline LONG64 InterlockedIncrement64(LONG64 volatile *x)
+{
+    return __sync_add_and_fetch(x, 1);
+}
 static inline LONG InterlockedAdd(LONG volatile *x, LONG val)
 {
     return __sync_add_and_fetch(x, val);
@@ -242,4 +247,74 @@ static inline void vkd3d_parse_version(const char *version, int *major, int *min
 
 HRESULT hresult_from_vkd3d_result(int vkd3d_result);
 
+#ifdef _WIN32
+static inline void *vkd3d_dlopen(const char *name)
+{
+    return LoadLibraryA(name);
+}
+
+static inline void *vkd3d_dlsym(void *handle, const char *symbol)
+{
+    return GetProcAddress(handle, symbol);
+}
+
+static inline int vkd3d_dlclose(void *handle)
+{
+    return FreeLibrary(handle);
+}
+
+static inline const char *vkd3d_dlerror(void)
+{
+    unsigned int error = GetLastError();
+    static char message[256];
+
+    if (FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, error, 0, message, sizeof(message), NULL))
+        return message;
+    sprintf(message, "Unknown error %u.\n", error);
+    return message;
+}
+#elif defined(HAVE_DLFCN_H)
+#include <dlfcn.h>
+
+static inline void *vkd3d_dlopen(const char *name)
+{
+    return dlopen(name, RTLD_NOW);
+}
+
+static inline void *vkd3d_dlsym(void *handle, const char *symbol)
+{
+    return dlsym(handle, symbol);
+}
+
+static inline int vkd3d_dlclose(void *handle)
+{
+    return dlclose(handle);
+}
+
+static inline const char *vkd3d_dlerror(void)
+{
+    return dlerror();
+}
+#else
+static inline void *vkd3d_dlopen(const char *name)
+{
+    return NULL;
+}
+
+static inline void *vkd3d_dlsym(void *handle, const char *symbol)
+{
+    return NULL;
+}
+
+static inline int vkd3d_dlclose(void *handle)
+{
+    return 0;
+}
+
+static inline const char *vkd3d_dlerror(void)
+{
+    return "Not implemented for this platform.\n";
+}
+#endif
+
 #endif  /* __VKD3D_COMMON_H */

include/private/vkd3d_debug.h

@@ -47,6 +47,7 @@ enum vkd3d_dbg_level
 enum vkd3d_dbg_level vkd3d_dbg_get_level(void);
 
 void vkd3d_dbg_printf(enum vkd3d_dbg_level level, const char *function, const char *fmt, ...) VKD3D_PRINTF_FUNC(3, 4);
+void vkd3d_dbg_set_log_callback(PFN_vkd3d_log callback);
 
 const char *vkd3d_dbg_sprintf(const char *fmt, ...) VKD3D_PRINTF_FUNC(1, 2);
 const char *vkd3d_dbg_vsprintf(const char *fmt, va_list args);

include/vkd3d.h

@@ -60,6 +60,10 @@ enum vkd3d_api_version
     VKD3D_API_VERSION_1_1,
     VKD3D_API_VERSION_1_2,
     VKD3D_API_VERSION_1_3,
+    VKD3D_API_VERSION_1_4,
+    VKD3D_API_VERSION_1_5,
+
+    VKD3D_FORCE_32_BIT_ENUM(VKD3D_API_VERSION),
 };
 
 typedef HRESULT (*PFN_vkd3d_signal_event)(HANDLE event);
@@ -212,6 +216,20 @@ VKD3D_API HRESULT vkd3d_serialize_versioned_root_signature(const D3D12_VERSIONED
 VKD3D_API HRESULT vkd3d_create_versioned_root_signature_deserializer(const void *data, SIZE_T data_size,
         REFIID iid, void **deserializer);
 
+/**
+ * Set a callback to be called when vkd3d outputs debug logging.
+ *
+ * If NULL, or if this function has not been called, libvkd3d will print all
+ * enabled log output to stderr.
+ *
+ * Calling this function will also set the log callback for libvkd3d-shader.
+ *
+ * \param callback Callback function to set.
+ *
+ * \since 1.4
+ */
+VKD3D_API void vkd3d_set_log_callback(PFN_vkd3d_log callback);
+
 #endif  /* VKD3D_NO_PROTOTYPES */
 
 /*
@@ -255,6 +273,9 @@ typedef HRESULT (*PFN_vkd3d_serialize_versioned_root_signature)(const D3D12_VERS
 typedef HRESULT (*PFN_vkd3d_create_versioned_root_signature_deserializer)(const void *data, SIZE_T data_size,
         REFIID iid, void **deserializer);
 
+/** Type of vkd3d_set_log_callback(). \since 1.4 */
+typedef void (*PFN_vkd3d_set_log_callback)(PFN_vkd3d_log callback);
+
 #ifdef __cplusplus
 }
 #endif  /* __cplusplus */

include/vkd3d_d3d12.idl

@@ -250,6 +250,13 @@ typedef enum D3D12_RAYTRACING_TIER
     D3D12_RAYTRACING_TIER_1_0 = 0xa,
 } D3D12_RAYTRACING_TIER;
 
+typedef enum D3D12_RESIDENCY_FLAGS
+{
+    D3D12_RESIDENCY_FLAG_NONE = 0x0,
+    D3D12_RESIDENCY_FLAG_DENY_OVERBUDGET = 0x1,
+} D3D12_RESIDENCY_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RESIDENCY_FLAGS);")
+
 interface ID3D12Fence;
 interface ID3D12RootSignature;
 interface ID3D12Heap;
@@ -413,6 +420,11 @@ typedef enum D3D12_HEAP_FLAGS
     D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER = 0x20,
     D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES = 0x40,
     D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES = 0x80,
+    D3D12_HEAP_FLAG_HARDWARE_PROTECTED = 0x100,
+    D3D12_HEAP_FLAG_ALLOW_WRITE_WATCH = 0x200,
+    D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS = 0x400,
+    D3D12_HEAP_FLAG_CREATE_NOT_RESIDENT = 0x800,
+    D3D12_HEAP_FLAG_CREATE_NOT_ZEROED = 0x1000,
     D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES = 0x00,
     D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS = 0xc0,
     D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES = 0x44,
@@ -916,6 +928,11 @@ typedef enum D3D12_ROOT_SIGNATURE_FLAGS
     D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS = 0x10,
     D3D12_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS = 0x20,
     D3D12_ROOT_SIGNATURE_FLAG_ALLOW_STREAM_OUTPUT = 0x40,
+    D3D12_ROOT_SIGNATURE_FLAG_LOCAL_ROOT_SIGNATURE = 0x80,
+    D3D12_ROOT_SIGNATURE_FLAG_DENY_AMPLIFICATION_SHADER_ROOT_ACCESS = 0x100,
+    D3D12_ROOT_SIGNATURE_FLAG_DENY_MESH_SHADER_ROOT_ACCESS = 0x200,
+    D3D12_ROOT_SIGNATURE_FLAG_CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED = 0x400,
+    D3D12_ROOT_SIGNATURE_FLAG_SAMPLER_HEAP_DIRECTLY_INDEXED = 0x800,
 } D3D12_ROOT_SIGNATURE_FLAGS;
 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_ROOT_SIGNATURE_FLAGS);")
 
@@ -1636,6 +1653,12 @@ typedef struct D3D12_COMPUTE_PIPELINE_STATE_DESC
     D3D12_PIPELINE_STATE_FLAGS Flags;
 } D3D12_COMPUTE_PIPELINE_STATE_DESC;
 
+typedef struct D3D12_PIPELINE_STATE_STREAM_DESC
+{
+    SIZE_T SizeInBytes;
+    void *pPipelineStateSubobjectStream;
+} D3D12_PIPELINE_STATE_STREAM_DESC;
+
 typedef enum D3D12_COMMAND_LIST_TYPE
 {
     D3D12_COMMAND_LIST_TYPE_DIRECT = 0,
@@ -2533,6 +2556,46 @@ interface ID3D12Device1 : ID3D12Device
             const D3D12_RESIDENCY_PRIORITY *priorities);
 }
 
+[
+    uuid(30baa41e-b15b-475c-a0bb-1af5c5b64328),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Device2 : ID3D12Device1
+{
+    HRESULT CreatePipelineState(
+        [in] const D3D12_PIPELINE_STATE_STREAM_DESC *desc,
+        [in] REFIID riid,
+        [out, iid_is(riid)] void **pipeline_state);
+}
+
+[
+    uuid(81dadc15-2bad-4392-93c5-101345c4aa98),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Device3 : ID3D12Device2
+{
+    HRESULT OpenExistingHeapFromAddress(
+        [in] const void *address,
+        [in] REFIID riid,
+        [out, iid_is(riid)] void **heap);
+
+    HRESULT OpenExistingHeapFromFileMapping(
+        [in] HANDLE file_mapping,
+        [in] REFIID riid,
+        [out, iid_is(riid)] void **heap);
+
+    HRESULT EnqueueMakeResident(
+        [in] D3D12_RESIDENCY_FLAGS flags,
+        [in] UINT num_objects,
+        [in] ID3D12Pageable *const *objects,
+        [in] ID3D12Fence *fence,
+        [in] UINT64 fence_value);
+}
+
 [
     uuid(34ab647b-3cc8-46ac-841b-c0965645c046),
     object,

include/vkd3d_d3d12sdklayers.idl

@@ -899,6 +899,61 @@ typedef enum D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE
     NUM_D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODES = 0x4,
 } D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE;
 
+typedef enum D3D12_GPU_BASED_VALIDATION_FLAGS
+{
+    D3D12_GPU_BASED_VALIDATION_FLAGS_NONE = 0x00,
+    D3D12_GPU_BASED_VALIDATION_FLAGS_DISABLE_STATE_TRACKING = 0x01,
+} D3D12_GPU_BASED_VALIDATION_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_GPU_BASED_VALIDATION_FLAGS)")
+
+typedef enum D3D12_RLDO_FLAGS
+{
+    D3D12_RLDO_NONE = 0x0,
+    D3D12_RLDO_SUMMARY = 0x1,
+    D3D12_RLDO_DETAIL = 0x2,
+    D3D12_RLDO_IGNORE_INTERNAL = 0x4,
+} D3D12_RLDO_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RLDO_FLAGS)")
+
+typedef enum D3D12_DEBUG_DEVICE_PARAMETER_TYPE
+{
+    D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS,
+    D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS,
+    D3D12_DEBUG_DEVICE_PARAMETER_GPU_SLOWDOWN_PERFORMANCE_FACTOR,
+} D3D12_DEBUG_DEVICE_PARAMETER_TYPE;
+
+typedef enum D3D12_DEBUG_FEATURE
+{
+    D3D12_DEBUG_FEATURE_NONE = 0x00,
+    D3D12_DEBUG_FEATURE_ALLOW_BEHAVIOR_CHANGING_DEBUG_AIDS = 0x01,
+    D3D12_DEBUG_FEATURE_CONSERVATIVE_RESOURCE_STATE_TRACKING = 0x02,
+    D3D12_DEBUG_FEATURE_DISABLE_VIRTUALIZED_BUNDLES_VALIDATION = 0x04,
+    D3D12_DEBUG_FEATURE_EMULATE_WINDOWS7 = 0x08,
+} D3D12_DEBUG_FEATURE;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_DEBUG_FEATURE)")
+
+typedef enum D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS
+{
+    D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_NONE = 0x00,
+    D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_TRACKING_ONLY_SHADERS = 0x01,
+    D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_UNGUARDED_VALIDATION_SHADERS = 0x02,
+    D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_GUARDED_VALIDATION_SHADERS = 0x04,
+    D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS_VALID_MASK = 0x07
+} D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS)")
+
+typedef struct D3D12_DEBUG_DEVICE_GPU_BASED_VALIDATION_SETTINGS
+{
+    UINT MaxMessagesPerCommandList;
+    D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE DefaultShaderPatchMode;
+    D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS PipelineStateCreateFlags;
+} D3D12_DEBUG_DEVICE_GPU_BASED_VALIDATION_SETTINGS;
+
+typedef struct D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR
+{
+    FLOAT SlowdownFactor;
+} D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR;
+
 typedef struct D3D12_MESSAGE
 {
     D3D12_MESSAGE_CATEGORY Category;
@@ -948,6 +1003,104 @@ interface ID3D12Debug1 : IUnknown
     void SetEnableSynchronizedCommandQueueValidation(BOOL enable);
 }
 
+[
+    uuid(93a665c4-a3b2-4e5d-b692-a26ae14e3374),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Debug2 : IUnknown
+{
+    void SetGPUBasedValidationFlags(D3D12_GPU_BASED_VALIDATION_FLAGS flags);
+}
+
+[
+    uuid(5cf4e58f-f671-4ff1-a542-3686e3d153d1),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Debug3 : ID3D12Debug
+{
+    void SetEnableGPUBasedValidation(BOOL enable);
+    void SetEnableSynchronizedCommandQueueValidation(BOOL enable);
+    void SetGPUBasedValidationFlags(D3D12_GPU_BASED_VALIDATION_FLAGS flags);
+}
+
+[
+    uuid(014b816e-9ec5-4a2f-a845-ffbe441ce13a),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Debug4 : ID3D12Debug3
+{
+    void DisableDebugLayer();
+}
+
+[
+    uuid(548d6b12-09fa-40e0-9069-5dcd589a52c9),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Debug5 : ID3D12Debug4
+{
+    void SetEnableAutoName(BOOL enable);
+}
+
+[
+    uuid(3febd6dd-4973-4787-8194-e45f9e28923e),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12DebugDevice : IUnknown
+{
+    HRESULT SetFeatureMask(D3D12_DEBUG_FEATURE mask);
+    D3D12_DEBUG_FEATURE GetFeatureMask();
+    HRESULT ReportLiveDeviceObjects(D3D12_RLDO_FLAGS flags);
+}
+
+[
+    uuid(a9b71770-d099-4a65-a698-3dee10020f88),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12DebugDevice1 : IUnknown
+{
+    HRESULT SetDebugParameter(D3D12_DEBUG_DEVICE_PARAMETER_TYPE type, const void *data, UINT size);
+    HRESULT GetDebugParameter(D3D12_DEBUG_DEVICE_PARAMETER_TYPE type, void *data, UINT size);
+    HRESULT ReportLiveDeviceObjects(D3D12_RLDO_FLAGS flags);
+}
+
+[
+    uuid(60eccbc1-378d-4df1-894c-f8ac5ce4d7dd),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12DebugDevice2 : ID3D12DebugDevice
+{
+    HRESULT SetDebugParameter(D3D12_DEBUG_DEVICE_PARAMETER_TYPE type, const void *data, UINT size);
+    HRESULT GetDebugParameter(D3D12_DEBUG_DEVICE_PARAMETER_TYPE type, void *data, UINT size);
+}
+
+[
+    uuid(0adf7d52-929c-4e61-addb-ffed30de66ef),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12SharingContract : IUnknown
+{
+    void Present(ID3D12Resource *resource, UINT sub_resource, HWND window);
+    void SharedFenceSignal(ID3D12Fence *fence, UINT64 fence_value);
+    void BeginCapturableWork(REFGUID guid);
+    void EndCapturableWork(REFGUID guid);
+}
+
 [
     uuid(0742a90b-c387-483f-b946-30a7e4e61458),
     object,

include/vkd3d_shader.h

@@ -45,6 +45,10 @@ enum vkd3d_shader_api_version
     VKD3D_SHADER_API_VERSION_1_1,
     VKD3D_SHADER_API_VERSION_1_2,
     VKD3D_SHADER_API_VERSION_1_3,
+    VKD3D_SHADER_API_VERSION_1_4,
+    VKD3D_SHADER_API_VERSION_1_5,
+
+    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_API_VERSION),
 };
 
 /** The type of a chained structure. */
@@ -98,6 +102,23 @@ enum vkd3d_shader_compile_option_buffer_uav
     VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPILE_OPTION_BUFFER_UAV),
 };
 
+/**
+ * Determines how typed UAVs are declared.
+ * \since 1.5
+ */
+enum vkd3d_shader_compile_option_typed_uav
+{
+    /** Use R32(u)i/R32f format for UAVs which are read from. This is the default value. */
+    VKD3D_SHADER_COMPILE_OPTION_TYPED_UAV_READ_FORMAT_R32     = 0x00000000,
+    /**
+     * Use Unknown format for UAVs which are read from. This should only be set if
+     * shaderStorageImageReadWithoutFormat is enabled in the target environment.
+     */
+    VKD3D_SHADER_COMPILE_OPTION_TYPED_UAV_READ_FORMAT_UNKNOWN = 0x00000001,
+
+    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPILE_OPTION_TYPED_UAV),
+};
+
 enum vkd3d_shader_compile_option_formatting_flags
 {
     VKD3D_SHADER_COMPILE_OPTION_FORMATTING_NONE    = 0x00000000,
@@ -126,6 +147,8 @@ enum vkd3d_shader_compile_option_name
     VKD3D_SHADER_COMPILE_OPTION_FORMATTING  = 0x00000003,
     /** \a value is a member of enum vkd3d_shader_api_version. \since 1.3 */
     VKD3D_SHADER_COMPILE_OPTION_API_VERSION = 0x00000004,
+    /** \a value is a member of enum vkd3d_shader_compile_option_typed_uav. \since 1.5 */
+    VKD3D_SHADER_COMPILE_OPTION_TYPED_UAV   = 0x00000005,
 
     VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPILE_OPTION_NAME),
 };
@@ -1806,6 +1829,18 @@ VKD3D_SHADER_API void vkd3d_shader_free_shader_signature(struct vkd3d_shader_sig
 VKD3D_SHADER_API int vkd3d_shader_preprocess(const struct vkd3d_shader_compile_info *compile_info,
         struct vkd3d_shader_code *out, char **messages);
 
+/**
+ * Set a callback to be called when vkd3d-shader outputs debug logging.
+ *
+ * If NULL, or if this function has not been called, libvkd3d-shader will print
+ * all enabled log output to stderr.
+ *
+ * \param callback Callback function to set.
+ *
+ * \since 1.4
+ */
+VKD3D_SHADER_API void vkd3d_shader_set_log_callback(PFN_vkd3d_log callback);
+
 #endif  /* VKD3D_SHADER_NO_PROTOTYPES */
 
 /** Type of vkd3d_shader_get_version(). */
@@ -1859,6 +1894,9 @@ typedef void (*PFN_vkd3d_shader_free_shader_signature)(struct vkd3d_shader_signa
 typedef void (*PFN_vkd3d_shader_preprocess)(struct vkd3d_shader_compile_info *compile_info,
         struct vkd3d_shader_code *out, char **messages);
 
+/** Type of vkd3d_shader_set_log_callback(). \since 1.4 */
+typedef void (*PFN_vkd3d_shader_set_log_callback)(PFN_vkd3d_log callback);
+
 #ifdef __cplusplus
 }
 #endif  /* __cplusplus */

include/vkd3d_types.h

@@ -19,6 +19,8 @@
 #ifndef __VKD3D_TYPES_H
 #define __VKD3D_TYPES_H
 
+#include <stdarg.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif  /* __cplusplus */
@@ -53,6 +55,8 @@ enum vkd3d_result
     VKD3D_FORCE_32_BIT_ENUM(VKD3D_RESULT),
 };
 
+typedef void (*PFN_vkd3d_log)(const char *format, va_list args);
+
 #ifdef _WIN32
 # define VKD3D_IMPORT __declspec(dllimport)
 # define VKD3D_EXPORT __declspec(dllexport)

include/vkd3d_utils.h

@@ -75,6 +75,21 @@ VKD3D_UTILS_API HRESULT WINAPI D3DPreprocess(const void *data, SIZE_T size, cons
         const D3D_SHADER_MACRO *defines, ID3DInclude *include,
         ID3DBlob **shader, ID3DBlob **error_messages);
 
+/**
+ * Set a callback to be called when vkd3d-utils outputs debug logging.
+ *
+ * If NULL, or if this function has not been called, libvkd3d-utils will print
+ * all enabled log output to stderr.
+ *
+ * Calling this function will also set the log callback for libvkd3d and
+ * libvkd3d-shader.
+ *
+ * \param callback Callback function to set.
+ *
+ * \since 1.4
+ */
+VKD3D_UTILS_API void vkd3d_utils_set_log_callback(PFN_vkd3d_log callback);
+
 #ifdef __cplusplus
 }
 #endif  /* __cplusplus */

include/vkd3d_windows.h

@@ -91,6 +91,7 @@ typedef unsigned __int64 UINT64;
 typedef int64_t DECLSPEC_ALIGN(8) INT64;
 typedef uint64_t DECLSPEC_ALIGN(8) UINT64;
 # endif
+typedef INT64 LONG64;
 typedef long LONG_PTR;
 typedef unsigned long ULONG_PTR;
 

libs/vkd3d-common/debug.c

@@ -68,6 +68,25 @@ enum vkd3d_dbg_level vkd3d_dbg_get_level(void)
     return level;
 }
 
+static PFN_vkd3d_log log_callback;
+
+static void vkd3d_dbg_voutput(const char *fmt, va_list args)
+{
+    if (log_callback)
+        log_callback(fmt, args);
+    else
+        vfprintf(stderr, fmt, args);
+}
+
+static void vkd3d_dbg_output(const char *fmt, ...)
+{
+    va_list args;
+
+    va_start(args, fmt);
+    vkd3d_dbg_voutput(fmt, args);
+    va_end(args);
+}
+
 void vkd3d_dbg_printf(enum vkd3d_dbg_level level, const char *function, const char *fmt, ...)
 {
     va_list args;
@@ -77,12 +96,17 @@ void vkd3d_dbg_printf(enum vkd3d_dbg_level level, const char *function, const ch
 
     assert(level < ARRAY_SIZE(debug_level_names));
 
-    fprintf(stderr, "%s:%s: ", debug_level_names[level], function);
+    vkd3d_dbg_output("%s:%s ", debug_level_names[level], function);
     va_start(args, fmt);
-    vfprintf(stderr, fmt, args);
+    vkd3d_dbg_voutput(fmt, args);
     va_end(args);
 }
 
+void vkd3d_dbg_set_log_callback(PFN_vkd3d_log callback)
+{
+    log_callback = callback;
+}
+
 static char *get_buffer(void)
 {
     static char buffers[VKD3D_DEBUG_BUFFER_COUNT][VKD3D_DEBUG_BUFFER_SIZE];

libs/vkd3d-shader/dxbc.c

@@ -837,6 +837,7 @@ static const struct vkd3d_sm4_opcode_info opcode_table[] =
     {VKD3D_SM5_OP_DDIV,                             VKD3DSIH_DDIV,                             "d",    "dd"},
     {VKD3D_SM5_OP_DFMA,                             VKD3DSIH_DFMA,                             "d",    "ddd"},
     {VKD3D_SM5_OP_DRCP,                             VKD3DSIH_DRCP,                             "d",    "d"},
+    {VKD3D_SM5_OP_MSAD,                             VKD3DSIH_MSAD,                             "u",    "uuu"},
     {VKD3D_SM5_OP_DTOI,                             VKD3DSIH_DTOI,                             "i",    "d"},
     {VKD3D_SM5_OP_DTOU,                             VKD3DSIH_DTOU,                             "u",    "d"},
     {VKD3D_SM5_OP_ITOD,                             VKD3DSIH_ITOD,                             "d",    "i"},

libs/vkd3d-shader/hlsl.h

@@ -126,7 +126,11 @@ struct hlsl_type
     unsigned int dimy;
     union
     {
-        struct list *elements;
+        struct
+        {
+            struct hlsl_struct_field *fields;
+            size_t field_count;
+        } record;
         struct
         {
             struct hlsl_type *type;
@@ -147,11 +151,11 @@ struct hlsl_semantic
 
 struct hlsl_struct_field
 {
-    struct list entry;
     struct vkd3d_shader_location loc;
     struct hlsl_type *type;
     const char *name;
     struct hlsl_semantic semantic;
+    unsigned int modifiers;
     unsigned int reg_offset;
 
     size_t name_bytecode_offset;
@@ -226,6 +230,8 @@ struct hlsl_src
 
 #define HLSL_MODIFIERS_MAJORITY_MASK (HLSL_MODIFIER_ROW_MAJOR | HLSL_MODIFIER_COLUMN_MAJOR)
 
+#define HLSL_ARRAY_ELEMENTS_COUNT_IMPLICIT 0
+
 struct hlsl_reg_reservation
 {
     char type;
@@ -370,6 +376,10 @@ struct hlsl_ir_swizzle
 struct hlsl_deref
 {
     struct hlsl_ir_var *var;
+
+    unsigned int path_len;
+    struct hlsl_src *path;
+
     struct hlsl_src offset;
 };
 
@@ -383,6 +393,7 @@ enum hlsl_resource_load_type
 {
     HLSL_RESOURCE_LOAD,
     HLSL_RESOURCE_SAMPLE,
+    HLSL_RESOURCE_SAMPLE_LOD,
     HLSL_RESOURCE_GATHER_RED,
     HLSL_RESOURCE_GATHER_GREEN,
     HLSL_RESOURCE_GATHER_BLUE,
@@ -394,8 +405,7 @@ struct hlsl_ir_resource_load
     struct hlsl_ir_node node;
     enum hlsl_resource_load_type load_type;
     struct hlsl_deref resource, sampler;
-    struct hlsl_src coords;
+    struct hlsl_src coords, lod, texel_offset;
-    struct hlsl_src texel_offset;
 };
 
 struct hlsl_ir_store
@@ -415,7 +425,6 @@ struct hlsl_ir_constant
         int32_t i;
         float f;
         double d;
-        bool b;
     } value[4];
     struct hlsl_reg reg;
 };
@@ -714,6 +723,9 @@ void hlsl_dump_function(struct hlsl_ctx *ctx, const struct hlsl_ir_function_decl
 int hlsl_emit_bytecode(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_func,
         enum vkd3d_shader_target_type target_type, struct vkd3d_shader_code *out);
 
+bool hlsl_copy_deref(struct hlsl_ctx *ctx, struct hlsl_deref *deref, struct hlsl_deref *other);
+void hlsl_cleanup_deref(struct hlsl_deref *deref);
+
 void hlsl_replace_node(struct hlsl_ir_node *old, struct hlsl_ir_node *new);
 
 void hlsl_free_instr(struct hlsl_ir_node *node);
@@ -726,6 +738,9 @@ struct hlsl_ir_function_decl *hlsl_get_func_decl(struct hlsl_ctx *ctx, const cha
 struct hlsl_type *hlsl_get_type(struct hlsl_scope *scope, const char *name, bool recursive);
 struct hlsl_ir_var *hlsl_get_var(struct hlsl_scope *scope, const char *name);
 
+struct hlsl_type *hlsl_get_element_type_from_path_index(struct hlsl_ctx *ctx, const struct hlsl_type *type,
+        struct hlsl_ir_node *idx);
+
 struct hlsl_type *hlsl_new_array_type(struct hlsl_ctx *ctx, struct hlsl_type *basic_type, unsigned int array_size);
 struct hlsl_ir_node *hlsl_new_binary_expr(struct hlsl_ctx *ctx, enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg1,
         struct hlsl_ir_node *arg2);
@@ -733,38 +748,53 @@ struct hlsl_buffer *hlsl_new_buffer(struct hlsl_ctx *ctx, enum hlsl_buffer_type
         const struct hlsl_reg_reservation *reservation, struct vkd3d_shader_location loc);
 struct hlsl_ir_expr *hlsl_new_cast(struct hlsl_ctx *ctx, struct hlsl_ir_node *node, struct hlsl_type *type,
         const struct vkd3d_shader_location *loc);
+struct hlsl_ir_constant *hlsl_new_constant(struct hlsl_ctx *ctx, struct hlsl_type *type,
+        const struct vkd3d_shader_location *loc);
 struct hlsl_ir_expr *hlsl_new_copy(struct hlsl_ctx *ctx, struct hlsl_ir_node *node);
 struct hlsl_ir_function_decl *hlsl_new_func_decl(struct hlsl_ctx *ctx, struct hlsl_type *return_type,
         struct list *parameters, const struct hlsl_semantic *semantic, struct vkd3d_shader_location loc);
 struct hlsl_ir_if *hlsl_new_if(struct hlsl_ctx *ctx, struct hlsl_ir_node *condition, struct vkd3d_shader_location loc);
 struct hlsl_ir_constant *hlsl_new_int_constant(struct hlsl_ctx *ctx, int n,
-        const struct vkd3d_shader_location loc);
+        const struct vkd3d_shader_location *loc);
 struct hlsl_ir_jump *hlsl_new_jump(struct hlsl_ctx *ctx, enum hlsl_ir_jump_type type, struct vkd3d_shader_location loc);
-struct hlsl_ir_load *hlsl_new_load(struct hlsl_ctx *ctx, struct hlsl_ir_var *var, struct hlsl_ir_node *offset,
+
-        struct hlsl_type *type, struct vkd3d_shader_location loc);
+void hlsl_init_simple_deref_from_var(struct hlsl_deref *deref, struct hlsl_ir_var *var);
-struct hlsl_ir_loop *hlsl_new_loop(struct hlsl_ctx *ctx, struct vkd3d_shader_location loc);
+
-struct hlsl_ir_resource_load *hlsl_new_resource_load(struct hlsl_ctx *ctx, struct hlsl_type *data_type,
+struct hlsl_ir_load *hlsl_new_var_load(struct hlsl_ctx *ctx, struct hlsl_ir_var *var,
-        enum hlsl_resource_load_type type, struct hlsl_ir_var *resource, struct hlsl_ir_node *resource_offset,
+        struct vkd3d_shader_location loc);
-        struct hlsl_ir_var *sampler, struct hlsl_ir_node *sampler_offset, struct hlsl_ir_node *coords,
+struct hlsl_ir_load *hlsl_new_load_index(struct hlsl_ctx *ctx, const struct hlsl_deref *deref,
-        struct hlsl_ir_node *texel_offset, const struct vkd3d_shader_location *loc);
+        struct hlsl_ir_node *idx, const struct vkd3d_shader_location *loc);
+struct hlsl_ir_load *hlsl_new_load_component(struct hlsl_ctx *ctx, struct hlsl_block *block,
+        const struct hlsl_deref *deref, unsigned int comp, const struct vkd3d_shader_location *loc);
+
 struct hlsl_ir_store *hlsl_new_simple_store(struct hlsl_ctx *ctx, struct hlsl_ir_var *lhs, struct hlsl_ir_node *rhs);
-struct hlsl_ir_store *hlsl_new_store(struct hlsl_ctx *ctx, struct hlsl_ir_var *var, struct hlsl_ir_node *offset,
+struct hlsl_ir_store *hlsl_new_store_index(struct hlsl_ctx *ctx, const struct hlsl_deref *lhs,
-        struct hlsl_ir_node *rhs, unsigned int writemask, struct vkd3d_shader_location loc);
+        struct hlsl_ir_node *idx, struct hlsl_ir_node *rhs, unsigned int writemask, const struct vkd3d_shader_location *loc);
-struct hlsl_type *hlsl_new_struct_type(struct hlsl_ctx *ctx, const char *name, struct list *fields);
+struct hlsl_ir_store *hlsl_new_store_component(struct hlsl_ctx *ctx, struct hlsl_block *block,
+        const struct hlsl_deref *lhs, unsigned int comp, struct hlsl_ir_node *rhs);
+
+struct hlsl_ir_resource_load *hlsl_new_resource_load(struct hlsl_ctx *ctx, struct hlsl_type *data_type,
+        enum hlsl_resource_load_type type, struct hlsl_deref *resource, struct hlsl_deref *sampler,
+        struct hlsl_ir_node *coords, struct hlsl_ir_node *texel_offset, const struct vkd3d_shader_location *loc);
+struct hlsl_ir_resource_load *hlsl_new_sample_lod(struct hlsl_ctx *ctx, struct hlsl_type *data_type,
+        struct hlsl_deref *resource, struct hlsl_deref *sampler, struct hlsl_ir_node *coords,
+        struct hlsl_ir_node *texel_offset, struct hlsl_ir_node *lod, const struct vkd3d_shader_location *loc);
+
+struct hlsl_ir_loop *hlsl_new_loop(struct hlsl_ctx *ctx, struct vkd3d_shader_location loc);
+struct hlsl_type *hlsl_new_struct_type(struct hlsl_ctx *ctx, const char *name,
+        struct hlsl_struct_field *fields, size_t field_count);
 struct hlsl_ir_swizzle *hlsl_new_swizzle(struct hlsl_ctx *ctx, DWORD s, unsigned int components,
         struct hlsl_ir_node *val, const struct vkd3d_shader_location *loc);
 struct hlsl_ir_var *hlsl_new_synthetic_var(struct hlsl_ctx *ctx, const char *name, struct hlsl_type *type,
         const struct vkd3d_shader_location loc);
 struct hlsl_type *hlsl_new_texture_type(struct hlsl_ctx *ctx, enum hlsl_sampler_dim dim, struct hlsl_type *format);
 struct hlsl_ir_constant *hlsl_new_uint_constant(struct hlsl_ctx *ctx, unsigned int n,
-        const struct vkd3d_shader_location loc);
+        const struct vkd3d_shader_location *loc);
 struct hlsl_ir_node *hlsl_new_unary_expr(struct hlsl_ctx *ctx, enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg,
         struct vkd3d_shader_location loc);
 struct hlsl_ir_var *hlsl_new_var(struct hlsl_ctx *ctx, const char *name, struct hlsl_type *type,
         const struct vkd3d_shader_location loc, const struct hlsl_semantic *semantic, unsigned int modifiers,
         const struct hlsl_reg_reservation *reg_reservation);
-struct hlsl_ir_load *hlsl_new_var_load(struct hlsl_ctx *ctx, struct hlsl_ir_var *var,
-        const struct vkd3d_shader_location loc);
 
 void hlsl_error(struct hlsl_ctx *ctx, const struct vkd3d_shader_location *loc,
         enum vkd3d_shader_error error, const char *fmt, ...) VKD3D_PRINTF_FUNC(4, 5);
@@ -782,7 +812,14 @@ bool hlsl_scope_add_type(struct hlsl_scope *scope, struct hlsl_type *type);
 
 struct hlsl_type *hlsl_type_clone(struct hlsl_ctx *ctx, struct hlsl_type *old,
         unsigned int default_majority, unsigned int modifiers);
-unsigned int hlsl_type_component_count(struct hlsl_type *type);
+unsigned int hlsl_type_component_count(const struct hlsl_type *type);
+unsigned int hlsl_type_get_array_element_reg_size(const struct hlsl_type *type);
+struct hlsl_type *hlsl_type_get_component_type(struct hlsl_ctx *ctx, struct hlsl_type *type,
+        unsigned int index);
+bool hlsl_type_is_row_major(const struct hlsl_type *type);
+unsigned int hlsl_type_minor_size(const struct hlsl_type *type);
+unsigned int hlsl_type_major_size(const struct hlsl_type *type);
+unsigned int hlsl_type_element_count(const struct hlsl_type *type);
 unsigned int hlsl_type_get_sm4_offset(const struct hlsl_type *type, unsigned int offset);
 bool hlsl_types_are_equal(const struct hlsl_type *t1, const struct hlsl_type *t2);
 
@@ -791,12 +828,14 @@ unsigned int hlsl_combine_writemasks(unsigned int first, unsigned int second);
 unsigned int hlsl_map_swizzle(unsigned int swizzle, unsigned int writemask);
 unsigned int hlsl_swizzle_from_writemask(unsigned int writemask);
 
+bool hlsl_component_index_range_from_deref(struct hlsl_ctx *ctx, const struct hlsl_deref *deref,
+        unsigned int *start, unsigned int *count);
 bool hlsl_offset_from_deref(struct hlsl_ctx *ctx, const struct hlsl_deref *deref, unsigned int *offset);
 unsigned int hlsl_offset_from_deref_safe(struct hlsl_ctx *ctx, const struct hlsl_deref *deref);
-struct hlsl_reg hlsl_reg_from_deref(struct hlsl_ctx *ctx, const struct hlsl_deref *deref,
+struct hlsl_reg hlsl_reg_from_deref(struct hlsl_ctx *ctx, const struct hlsl_deref *deref);
-        const struct hlsl_type *type);
 
-bool hlsl_fold_constants(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context);
+bool hlsl_fold_constant_exprs(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context);
+bool hlsl_fold_constant_swizzles(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context);
 
 bool hlsl_sm1_register_from_semantic(struct hlsl_ctx *ctx, const struct hlsl_semantic *semantic,
         bool output, D3DSHADER_PARAM_REGISTER_TYPE *type, unsigned int *reg);