Release 1.4.

Signed-off-by: Henri Verbeet <hverbeet@codeweavers.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>

.gitignore

@@ -19,7 +19,10 @@ vkd3d-*.tar.xz
 *.log
 *.o
 *.pc
+*.tab.c
+*.tab.h
 *.trs
+*.yy.c
 *~
 
 .deps

ANNOUNCE

@@ -1,17 +1,17 @@
-The Wine team is proud to announce that release 1.2 of vkd3d, the Direct3D to
+The Wine team is proud to announce that release 1.4 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:
 
-  - Availability of libvkd3d-shader as a public library.
+  - Many improvements to the HLSL compiler.
-  - Support for tessellation shaders.
+  - A new descriptor heap implementation using the VK_EXT_descriptor_indexing
-  - Version 1.1 root signatures.
+    extension.
-  - Stream output support.
+  - A new fence implementation using the VK_KHR_timeline_semaphore extension.
 
 The source is available from the following location:
 
-  https://dl.winehq.org/vkd3d/source/vkd3d-1.2.tar.xz
+  https://dl.winehq.org/vkd3d/source/vkd3d-1.4.tar.xz
 
 The current source can also be pulled directly from the git repository:
 
@@ -22,171 +22,75 @@ for the complete list.
 
 ----------------------------------------------------------------
 
-What's new in vkd3d 1.2
+What's new in vkd3d 1.4
 =======================
 
 
 *** libvkd3d
 
-- Newly implemented Direct3D 12 features:
+- A new descriptor heap implementation using the VK_EXT_descriptor_indexing
-  - Multi-sampling.
+  extension. In particular, the new implementation is more efficient when
-  - Reserved resources.
+  large descriptor heaps are used by multiple command lists. The new
-  - Instance data step rates. This requires the
+  `virtual_heaps' configuration option can be used to select the original
-    VK_EXT_vertex_attribute_divisor extension.
+  implementation even when the VK_EXT_descriptor_indexing extension is
-  - `Private data' APIs for all interfaces.
+  available.
-  - Shader-resource view component mappings.
+
-  - Indirect indexed draws.
+- A new fence implementation using the VK_KHR_timeline_semaphore extension.
-  - Indirect draws with a count buffer. This requires the
+  The new implementation addresses a number of edge cases the original
-    VK_KHR_draw_indirect_count extension.
+  implementation was unable to, as well as being somewhat more efficient.
-  - Stream output and stream output queries. This requires the
+
-    VK_EXT_transform_feedback extension.
+- When the VK_EXT_robustness2 extension is available, it is used to implement
-  - Predicated/conditional rendering.
+  null views. This more accurately matches Direct3D 12 behaviour. For example,
-  - Primitive restart.
+  all reads from such a null view return zeroes, while that isn't necessarily
-  - Depth rendering without a pixel shader.
+  the case for out-of-bounds reads with the original implementation.
-  - Depth clipping. This requires the VK_EXT_depth_clip_enable extension.
-  - Rasteriser discard.
-  - Dual-source blending.
-  - Mapping placed resources.
-  - The ReadFromSubresource() and WriteToSubresource() ID3D12Resource methods.
-  - Simultaneous access to resources from multiple queues.
-  - Null-views. I.e., views without an underlying resource.
-  - Several more feature support queries.
 
 - New interfaces:
-  - vkd3d_serialize_versioned_root_signature() and
+  - vkd3d_set_log_callback() allows writing log output via a custom callback.
-    vkd3d_create_versioned_root_signature_deserializer() provide support for
+    This can be used to integrate vkd3d's log output with other logging
-    versioned root signatures.
+    systems.
-  - The vkd3d_application_info structure extends the
-    vkd3d_instance_create_info structure, and can be used to pass information
-    about the application to libvkd3d. It is analogous to the
-    VkApplicationInfo structure in Vulkan. Its `api_version' field should be
-    set to the version of the libvkd3d API that the application targets.
-  - The vkd3d_optional_device_extensions_info structure extends the
-    vkd3d_device_create_info structure, and can be used to pass a list of
-    device extensions to enable only when available to libvkd3d. It is
-    analogous to the vkd3d_optional_instance_extensions_info structure for
-    instance extensions.
-
-- New environment variables:
-  - VKD3D_CONFIG can be used to set options that change the behaviour of
-    libvkd3d.
-  - VKD3D_TEST_BUG can be used to disable bug_if() conditions in the test
-    suite.
-  - VKD3D_TEST_FILTER can be used to control which tests are run.
-  - VKD3D_VULKAN_DEVICE can be used to override the Vulkan physical device
-    used by vkd3d.
-  See the README for more detailed descriptions and how to use these.
-
-- When the VK_KHR_dedicated_allocation extension is available, dedicated
-  allocations may be used for committed resources.
-
-- When the VK_KHR_image_format_list extension is available, it will be used to
-  inform the driver about the view formats that a particular mutable Vulkan
-  image can be used with. This improves performance on some Vulkan
-  implementations.
-
-- When the VK_EXT_debug_marker extension is available, object names set with
-  the ID3D12Object SetName() method will be propagated to the underlying
-  Vulkan objects.
-
-- Unordered-access view clears are supported on more formats. Previously these
-  were limited to integer formats for texture resources, and single component
-  integer formats for buffer resources.
-
-- When the D24_UNORM_S8_UINT format is not supported by the Vulkan
-  implementation, the D32_SFLOAT_S8_UINT format will be used instead to
-  implement the D24_UNORM_S8_UINT and related DXGI formats. This is required
-  because the DXGI D24_UNORM_S8_UINT format is mandatory, while the Vulkan
-  D24_UNORM_S8_UINT format is optional.
-
-- Various bug fixes.
 
 
 *** libvkd3d-shader
 
-- libvkd3d-shader is now available as a public instead of an internal library.
+- New features for the HLSL source type:
+  - Support for integer arithmetic, bitwise and shift operations.
+  - Support for matrix and vector subscripting.
+  - Support for the mul() intrinsic function.
+  - Support for matrix copying, casting, and entry-wise operations.
+  - Support for complex initialisers.
+  - Support for the `nointerpolation' modifier. This modifier is applied by
+    default to integer variables.
+  - Support for the SV_VertexID semantic.
+  - Support for matrix-typed varyings.
+  - Constant folding for a number of operators.
+  - Copy propagation across branches and loops. This allows use of non-numeric
+    variables anywhere in a program, as well as more optimised code for
+    accessing numeric variables within branches and loops.
 
-- New features:
+- The disassembler supports the shader model 5 `msad' instruction.
-  - Tessellation shaders.
-  - Root signature version 1.1 serialisation, deserialisation, and conversion.
-  - Multi-sample masks.
-  - Per-sample shading.
-  - Early depth/stencil test.
-  - Conservative depth output.
-  - Dual-source blending.
-  - Stream output.
-  - Viewport arrays.
 
-- Support for OpenGL SPIR-V target environments. This allows SPIR-V produced
+- New interfaces:
-  by libvkd3d-shader to be used with GL_ARB_gl_spirv. This includes support
+  - vkd3d_shader_set_log_callback() allows writing log output via a custom
-  for OpenGL atomic counters and combined samplers.
+    callback.
-
-- Preliminary support for shader model 5.1 shaders. This is still a work in
-  progress. Notably, support for resource arrays is not yet implemented.
-
-- When the SPV_EXT_demote_to_helper_invocation is available, it will be used
-  to implement the `discard' shader instruction instead of using SpvOpKill. In
-  particular, this ensures the `deriv_rtx' and `deriv_rty' instruction return
-  accurate results after a (conditional) `discard' instruction.
-
-- Support for using SPIR-V specialisation constants for shader parameters.
-
-- Support for more shader instructions:
-  - bufinfo,
-  - eval_centroid,
-  - eval_sample_index,
-  - ld2ms,
-  - sample_b,
-  - sample_d,
-  - sample_info,
-  - samplepos.
-
-- When built against SPIRV-Tools, libvkd3d-shader can produce SPIR-V shaders
-  in text form.
-
-- libvkd3d-shader now has its own environment variable (VKD3D_SHADER_DEBUG) to
-  control debug output.
-
-- Various shader translation fixes.
-
-
-*** vkd3d-compiler
-
-- When supported by libvkd3d-shader, text form SPIR-V is available as a target
-  format, in addition to the existing binary form SPIR-V target format.
-
-- Input from standard input, and output to standard output is supported.
 
 
 *** libvkd3d-utils
 
-- To specify the libvkd3d API version to use when creating vkd3d instances,
+- New interfaces:
-  define VKD3D_UTILS_API_VERSION to the desired version before including
+  - vkd3d_utils_set_log_callback() allows writing log output via a custom
-  vkd3d_utils.h. If VKD3D_UTILS_API_VERSION is not explicitly defined,
+    callback.
-  VKD3D_API_VERSION_1_0 will be used.
-
-- Support for versioned root signatures is provided by the
-  D3D12SerializeVersionedRootSignature() and
-  D3D12CreateVersionedRootSignatureDeserializer() entry points.
 
 
 *** build
 
 - The minimum required version of Vulkan-Headers and SPIRV-Headers for this
-  release is version 1.1.113.
+  release is version 1.2.139.
 
-- The minimum required version of widl for this release is version 3.20.
+- The SONAME_LIBVULKAN configure variable can be used to specify the shared
+  object name of the Vulkan library. Because vkd3d loads the Vulkan library
+  dynamically, specifying this removes the need for a Vulkan import library at
+  build time.
 
-- If doxygen is available, it will be used to build API documentation. By
+- The `crosstests' target no longer builds Win32/PE demos or tests when these
-  default, documentation will be generated in HTML and PDF formats.
+  were not enabled at configure time.
-
-- If debug logs are not required or desired, defining VKD3D_NO_TRACE_MESSAGES
-  and VKD3D_NO_DEBUG_MESSAGES will prevent them from being included in the
-  build. For example, a release build may want to configure with
-  `CPPFLAGS="-DNDEBUG -DVKD3D_NO_TRACE_MESSAGES -DVKD3D_NO_DEBUG_MESSAGES"'.
-
-- Microsoft Windows is now a supported target platform. To create a build for
-  Windows, either cross-compile by configuring with an appropriate --host
-  option like for example `--host=x86_64-w64-mingw32', or build on Windows
-  itself using an environment like MSYS2 or Cygwin.
 

AUTHORS

@@ -1,15 +1,28 @@
 Alexandre Julliard
 Andrew Eikum
+Andrey Gusev
+Atharva Nimbalkar
+Biswapriyo Nath
 Chip Davis
 Conor McCarthy
+David Gow
 Derek Lesho
+Francisco Casas
+Francois Gouget
+Giovanni Mascellani
 Hans-Kristian Arntzen
 Henri Verbeet
 Isabella Bosia
 Jactry Zeng
+Joshua Ashton
 Józef Kucia
+Matteo Bruni
+Nikolay Sivov
 Philip Rebohle
 Rémi Bernon
+Robin Kertels
+Stefan Dösinger
 Sven Hesse
+Vinson Lee
 Zebediah Figura
 Zhiyi Zhang

COPYING

@@ -1,4 +1,4 @@
-Copyright 2016-2019 the Vkd3d project authors (see the file AUTHORS for a
+Copyright 2016-2022 the Vkd3d project authors (see the file AUTHORS for a
 complete list)
 
 Vkd3d is free software; you can redistribute it and/or modify it under

Makefile.am

@@ -7,6 +7,7 @@ widl_headers = \
 	include/vkd3d_d3d12.h \
 	include/vkd3d_d3d12sdklayers.h \
 	include/vkd3d_d3dcommon.h \
+	include/vkd3d_d3dx9shader.h \
 	include/vkd3d_dxgi.h \
 	include/vkd3d_dxgi1_2.h \
 	include/vkd3d_dxgi1_3.h \
@@ -19,7 +20,10 @@ vkd3d_public_headers = \
 	include/vkd3d.h \
 	include/vkd3d_d3d12.h \
 	include/vkd3d_d3d12sdklayers.h \
+	include/vkd3d_d3d9types.h \
 	include/vkd3d_d3dcommon.h \
+	include/vkd3d_d3dcompiler.h \
+	include/vkd3d_d3dx9shader.h \
 	include/vkd3d_dxgibase.h \
 	include/vkd3d_dxgiformat.h \
 	include/vkd3d_shader.h \
@@ -43,15 +47,109 @@ vkd3d_tests = \
 
 vkd3d_cross_tests = \
 	tests/d3d12 \
-	tests/d3d12_invalid_usage
+	tests/d3d12_invalid_usage \
+	tests/hlsl_d3d12
+
+vkd3d_shader_tests = \
+	tests/abs.shader_test \
+	tests/arithmetic-float.shader_test \
+	tests/arithmetic-int.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 \
+	tests/cast-to-uint.shader_test \
+	tests/conditional.shader_test \
+	tests/floor.shader_test \
+	tests/hlsl-array-dimension.shader_test \
+	tests/hlsl-bool-cast.shader_test \
+	tests/hlsl-clamp.shader_test \
+	tests/hlsl-comma.shader_test \
+	tests/hlsl-cross.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-offset.shader_test \
+	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-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-return-implicit-conversion.shader_test \
+	tests/hlsl-return-void.shader_test \
+	tests/hlsl-shape.shader_test \
+	tests/hlsl-single-numeric-initializer.shader_test \
+	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/pow.shader_test \
+	tests/preproc-if.shader_test \
+	tests/preproc-ifdef.shader_test \
+	tests/preproc-if-expr.shader_test \
+	tests/preproc-invalid.shader_test \
+	tests/preproc-macro.shader_test \
+	tests/preproc-misc.shader_test \
+	tests/round.shader_test \
+	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 \
+	tests/swizzle-3.shader_test \
+	tests/swizzle-4.shader_test \
+	tests/swizzle-5.shader_test \
+	tests/swizzle-6.shader_test \
+	tests/swizzle-7.shader_test \
+	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 \
+	tests/writemask-assignop-3.shader_test
 
 vkd3d_test_headers = \
 	tests/d3d12_crosstest.h \
-	tests/d3d12_test_utils.h
+	tests/d3d12_test_utils.h \
+	tests/shader_runner.h \
+	tests/utils.h \
+	tests/vulkan_procs.h
 
 vkd3d_demos = \
-	demos/gears \
+	demos/vkd3d-gears \
-	demos/triangle
+	demos/vkd3d-triangle
 
 vkd3d_demos_headers = \
 	demos/demo.h \
@@ -64,12 +162,56 @@ BUILT_SOURCES = $(widl_headers) \
 noinst_LTLIBRARIES = libvkd3d-common.la
 libvkd3d_common_la_SOURCES = \
 	include/private/vkd3d_debug.h \
+	libs/vkd3d-common/blob.c \
 	libs/vkd3d-common/debug.c \
+	libs/vkd3d-common/error.c \
 	libs/vkd3d-common/memory.c \
 	libs/vkd3d-common/utf8.c
 
 lib_LTLIBRARIES = libvkd3d-shader.la libvkd3d.la libvkd3d-utils.la
 
+VKD3D_V_FLEX = $(vkd3d_v_flex_@AM_V@)
+vkd3d_v_flex_ = $(vkd3d_v_flex_@AM_DEFAULT_V@)
+vkd3d_v_flex_0 = @echo "  FLEX    " $@;
+vkd3d_v_flex_1 =
+
+VKD3D_V_BISON = $(vkd3d_v_bison_@AM_V@)
+vkd3d_v_bison_ = $(vkd3d_v_bison_@AM_DEFAULT_V@)
+vkd3d_v_bison_0 = @echo "  BISON   " $@;
+vkd3d_v_bison_1 =
+
+libs/vkd3d-shader/preproc.yy.c: libs/vkd3d-shader/preproc.l
+	@$(MKDIR_P) libs/vkd3d-shader
+	$(VKD3D_V_FLEX)$(FLEX) $(LFLAGS) -o $@ $<
+
+libs/vkd3d-shader/preproc.tab.c libs/vkd3d-shader/preproc.tab.h &: libs/vkd3d-shader/preproc.y
+	@$(MKDIR_P) libs/vkd3d-shader
+	$(VKD3D_V_BISON)$(BISON) $(YFLAGS) -d -o libs/vkd3d-shader/preproc.tab.c $<
+
+libs/vkd3d-shader/hlsl.yy.c: $(srcdir)/libs/vkd3d-shader/hlsl.l
+	@$(MKDIR_P) libs/vkd3d-shader
+	$(VKD3D_V_FLEX)$(FLEX) $(LFLAGS) -o $@ $<
+
+libs/vkd3d-shader/hlsl.tab.c libs/vkd3d-shader/hlsl.tab.h &: libs/vkd3d-shader/hlsl.y
+	@$(MKDIR_P) libs/vkd3d-shader
+	$(VKD3D_V_BISON)$(BISON) $(YFLAGS) -d -o libs/vkd3d-shader/hlsl.tab.c $<
+
+BUILT_SOURCES += \
+	libs/vkd3d-shader/hlsl.tab.h \
+	libs/vkd3d-shader/preproc.tab.h
+
+vkd3d_shader_yyfiles = \
+	libs/vkd3d-shader/hlsl.tab.c \
+	libs/vkd3d-shader/hlsl.tab.h \
+	libs/vkd3d-shader/hlsl.yy.c \
+	libs/vkd3d-shader/preproc.tab.c \
+	libs/vkd3d-shader/preproc.tab.h \
+	libs/vkd3d-shader/preproc.yy.c
+
+CLEANFILES = $(vkd3d_shader_yyfiles)
+
+nodist_libvkd3d_shader_la_SOURCES = $(vkd3d_shader_yyfiles)
+
 libvkd3d_shader_la_SOURCES = \
 	include/private/list.h \
 	include/private/rbtree.h \
@@ -78,21 +220,38 @@ libvkd3d_shader_la_SOURCES = \
 	include/private/vkd3d_memory.h \
 	include/vkd3d_shader.h \
 	libs/vkd3d-shader/checksum.c \
+	libs/vkd3d-shader/d3dbc.c \
 	libs/vkd3d-shader/dxbc.c \
+	libs/vkd3d-shader/glsl.c \
+	libs/vkd3d-shader/hlsl.c \
+	libs/vkd3d-shader/hlsl.h \
+	libs/vkd3d-shader/hlsl_codegen.c \
+	libs/vkd3d-shader/hlsl_constant_ops.c \
+	libs/vkd3d-shader/hlsl_sm1.c \
+	libs/vkd3d-shader/hlsl_sm4.c \
+	libs/vkd3d-shader/preproc.h \
+	libs/vkd3d-shader/sm4.h \
 	libs/vkd3d-shader/spirv.c \
 	libs/vkd3d-shader/trace.c \
 	libs/vkd3d-shader/vkd3d_shader.map \
 	libs/vkd3d-shader/vkd3d_shader_main.c \
 	libs/vkd3d-shader/vkd3d_shader_private.h
-libvkd3d_shader_la_CFLAGS = $(AM_CFLAGS) @SPIRV_TOOLS_CFLAGS@
+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 1:0:0
+libvkd3d_shader_la_LDFLAGS = $(AM_LDFLAGS) -version-info 3:0:2
-libvkd3d_shader_la_LIBADD = libvkd3d-common.la @SPIRV_TOOLS_LIBS@
+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
 EXTRA_libvkd3d_shader_la_DEPENDENCIES = $(srcdir)/libs/vkd3d-shader/vkd3d_shader.map
 endif
 
+EXTRA_DIST = \
+	libs/vkd3d-shader/hlsl.l \
+	libs/vkd3d-shader/hlsl.y \
+	libs/vkd3d-shader/preproc.l \
+	libs/vkd3d-shader/preproc.y
+
 libvkd3d_la_SOURCES = \
+	include/private/vkd3d_blob.h \
 	include/private/vkd3d_common.h \
 	include/private/vkd3d_debug.h \
 	include/private/vkd3d_memory.h \
@@ -111,7 +270,8 @@ libvkd3d_la_SOURCES = \
 	libs/vkd3d/vkd3d_private.h \
 	libs/vkd3d/vkd3d_shaders.h \
 	libs/vkd3d/vulkan_procs.h
-libvkd3d_la_LDFLAGS = $(AM_LDFLAGS) -version-info 3:0:2
+libvkd3d_la_CFLAGS = $(AM_CFLAGS) -DLIBVKD3D_SOURCE
+libvkd3d_la_LDFLAGS = $(AM_LDFLAGS) -version-info 5:0:4
 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
@@ -122,19 +282,20 @@ libvkd3d_utils_la_SOURCES = \
 	libs/vkd3d-utils/vkd3d_utils.map \
 	libs/vkd3d-utils/vkd3d_utils_main.c \
 	libs/vkd3d-utils/vkd3d_utils_private.h
-libvkd3d_utils_la_LDFLAGS = $(AM_LDFLAGS) -version-info 2:0:1
+libvkd3d_utils_la_CFLAGS = $(AM_CFLAGS) -DLIBVKD3D_UTILS_SOURCE
-libvkd3d_utils_la_LIBADD = libvkd3d-common.la libvkd3d.la @PTHREAD_LIBS@
+libvkd3d_utils_la_LDFLAGS = $(AM_LDFLAGS) -version-info 4:0: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
 EXTRA_libvkd3d_utils_la_DEPENDENCIES = $(srcdir)/libs/vkd3d-utils/vkd3d_utils.map
 endif
 
-EXTRA_DIST = ANNOUNCE LICENSE
+EXTRA_DIST += ANNOUNCE LICENSE
 
 pkgconfigdir = $(libdir)/pkgconfig
 pkginclude_HEADERS = $(vkd3d_public_headers)
 nodist_pkgconfig_DATA = libvkd3d.pc libvkd3d-shader.pc libvkd3d-utils.pc
-CLEANFILES = libvkd3d.pc libvkd3d-shader.pc libvkd3d-utils.pc
+CLEANFILES += libvkd3d.pc libvkd3d-shader.pc libvkd3d-utils.pc
 EXTRA_DIST += \
 	libs/vkd3d/libvkd3d.pc.in \
 	libs/vkd3d-shader/libvkd3d-shader.pc.in \
@@ -142,32 +303,47 @@ EXTRA_DIST += \
 
 bin_PROGRAMS = vkd3d-compiler
 vkd3d_compiler_SOURCES = programs/vkd3d-compiler/main.c
-vkd3d_compiler_LDADD = libvkd3d-shader.la
+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
+
 if BUILD_TESTS
-check_PROGRAMS = $(vkd3d_tests) $(vkd3d_cross_tests)
+check_PROGRAMS = $(vkd3d_tests) $(vkd3d_cross_tests) tests/shader_runner
-TESTS = $(vkd3d_tests) $(vkd3d_cross_tests)
+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_vkd3d_api_LDADD = libvkd3d.la @VULKAN_LIBS@
+tests_hlsl_d3d12_LDADD = $(LDADD) @DL_LIBS@
+tests_shader_runner_LDADD = $(LDADD) @DL_LIBS@
+tests_shader_runner_SOURCES = \
+	tests/shader_runner.c \
+	tests/shader_runner_d3d12.c \
+	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
 endif
 
+EXTRA_DIST += $(vkd3d_shader_tests)
+
 if BUILD_DEMOS
-DEMOS_LDADD = $(LDADD) libvkd3d-shader.la @XCB_LIBS@ @VULKAN_LIBS@
+DEMOS_LDADD = $(LDADD) libvkd3d-shader.la @DL_LIBS@ @DEMO_LIBS@
-DEMOS_CFLAGS = $(AM_CFLAGS) @XCB_CFLAGS@
+DEMOS_CFLAGS = $(AM_CFLAGS) @DEMO_CFLAGS@
-noinst_PROGRAMS = $(vkd3d_demos)
+bin_PROGRAMS += $(vkd3d_demos)
 
-demos_gears_CFLAGS = $(DEMOS_CFLAGS)
+demos_vkd3d_gears_SOURCES = demos/gears.c
-demos_gears_LDADD = $(DEMOS_LDADD) -lm
+demos_vkd3d_gears_CFLAGS = $(DEMOS_CFLAGS)
+demos_vkd3d_gears_LDADD = $(DEMOS_LDADD) -lm
 
-demos_triangle_CFLAGS = $(DEMOS_CFLAGS)
+demos_vkd3d_triangle_SOURCES = demos/triangle.c
-demos_triangle_LDADD = $(DEMOS_LDADD)
+demos_vkd3d_triangle_CFLAGS = $(DEMOS_CFLAGS)
+demos_vkd3d_triangle_LDADD = $(DEMOS_LDADD)
 endif
 
-EXTRA_DIST += $(vkd3d_test_headers) $(vkd3d_demos_headers)
+noinst_HEADERS = $(vkd3d_test_headers) $(vkd3d_demos_headers)
 
 VKD3D_V_WIDL = $(vkd3d_v_widl_@AM_V@)
 vkd3d_v_widl_ = $(vkd3d_v_widl_@AM_DEFAULT_V@)
@@ -227,17 +403,34 @@ dummy-vkd3d-version:
 ## Cross-compile tests
 cross_implibs = crosslibs/d3d12
 CROSS_CPPFLAGS = -I$(srcdir)/include -I$(srcdir)/include/private -I$(builddir)/include
-CROSS_CFLAGS = -g -O2 -Wall -municode ${CROSS_CPPFLAGS}
+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
 
 if HAVE_CROSSTARGET32
 CROSS32_CC = @CROSSCC32@
 CROSS32_DLLTOOL = @CROSSTARGET32@-dlltool
 CROSS32_IMPLIBS = $(cross_implibs:=.cross32.a)
-CROSS32_EXEFILES = $(vkd3d_cross_tests:=.cross32.exe) $(vkd3d_demos:=.cross32.exe)
+CROSS32_EXEFILES =
-CROSS32_FILES = $(CROSS32_IMPLIBS) $(CROSS32_EXEFILES)
+if BUILD_TESTS
+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
@@ -249,8 +442,14 @@ $(CROSS32_IMPLIBS): %.cross32.a: %.cross32.def
 
 $(CROSS32_EXEFILES): %.cross32.exe: %.c $(CROSS32_IMPLIBS) $(widl_headers)
 	$(AM_V_CCLD)depbase=`echo $@ | $(SED) 's![^/]*$$!$(DEPDIR)/&!;s!\.exe$$!!'`; \
-	$(CROSS32_CC) $(CROSS_CFLAGS) -MT $@ -MD -MP -MF $$depbase.Tpo -o $@ $< $(CROSS32_IMPLIBS) -ldxgi -lgdi32 && \
+	$(CROSS32_CC) $(CROSS_CFLAGS) -MT $@ -MD -MP -MF $$depbase.Tpo -o $@ $< $(CROSS32_IMPLIBS) -ldxgi -lgdi32 -ld3dcompiler_47 && \
 	$(am__mv) $$depbase.Tpo $$depbase.Po
+
+tests/shader_runner.cross32.exe: $(shader_runner_cross_sources) $(CROSS32_IMPLIBS) $(widl_headers)
+	$(AM_V_CCLD)depbase=`echo $@ | sed 's![^/]*$$!$(DEPDIR)/&!;s!\.exe$$!!'`; \
+	$(CROSS32_CC) $(CROSS_CFLAGS) -MT $@ -MD -MP -MF $$depbase.Tpo -o $@ $(shader_runner_cross_sources) $(CROSS32_IMPLIBS) -ldxgi -lgdi32 -ld3dcompiler_47 && \
+	$(am__mv) $$depbase.Tpo $$depbase.Po
+
 else
 crosstest32:
 endif
@@ -259,10 +458,20 @@ if HAVE_CROSSTARGET64
 CROSS64_CC = @CROSSCC64@
 CROSS64_DLLTOOL = @CROSSTARGET64@-dlltool
 CROSS64_IMPLIBS = $(cross_implibs:=.cross64.a)
-CROSS64_EXEFILES = $(vkd3d_cross_tests:=.cross64.exe) $(vkd3d_demos:=.cross64.exe)
+CROSS64_EXEFILES =
-CROSS64_FILES = $(CROSS64_IMPLIBS) $(CROSS64_EXEFILES)
+if BUILD_TESTS
+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
@@ -274,8 +483,14 @@ $(CROSS64_IMPLIBS): %.cross64.a: %.cross64.def
 
 $(CROSS64_EXEFILES): %.cross64.exe: %.c $(CROSS64_IMPLIBS) $(widl_headers)
 	$(AM_V_CCLD)depbase=`echo $@ | sed 's![^/]*$$!$(DEPDIR)/&!;s!\.exe$$!!'`; \
-	$(CROSS64_CC) $(CROSS_CFLAGS) -MT $@ -MD -MP -MF $$depbase.Tpo -o $@ $< $(CROSS64_IMPLIBS) -ldxgi -lgdi32 && \
+	$(CROSS64_CC) $(CROSS_CFLAGS) -MT $@ -MD -MP -MF $$depbase.Tpo -o $@ $< $(CROSS64_IMPLIBS) -ldxgi -lgdi32 -ld3dcompiler_47 && \
 	$(am__mv) $$depbase.Tpo $$depbase.Po
+
+tests/shader_runner.cross64.exe: $(shader_runner_cross_sources) $(CROSS64_IMPLIBS) $(widl_headers)
+	$(AM_V_CCLD)depbase=`echo $@ | sed 's![^/]*$$!$(DEPDIR)/&!;s!\.exe$$!!'`; \
+	$(CROSS64_CC) $(CROSS_CFLAGS) -MT $@ -MD -MP -MF $$depbase.Tpo -o $@ $(shader_runner_cross_sources) $(CROSS64_IMPLIBS) -ldxgi -lgdi32 -ld3dcompiler_47 && \
+	$(am__mv) $$depbase.Tpo $$depbase.Po
+
 else
 crosstest64:
 endif

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
@@ -45,7 +45,15 @@ removed in the future versions of vkd3d.
 Some of debug variables are lists of elements. Elements must be separated by
 commas or semicolons.
 
+ * NO_COLOR - this is an alias of NO_COLOUR.
+
+ * NO_COLOUR - when set, vkd3d-compiler will default to monochrome output,
+   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.2])
+AC_INIT([vkd3d],[1.4])
 
 AC_CONFIG_AUX_DIR([bin])
 AC_CONFIG_MACRO_DIR([m4])
@@ -8,9 +8,10 @@ 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([xcb], AS_HELP_STRING([--with-xcb], [Build with XCB library (default: test)]))
+AC_ARG_WITH([ncurses], AS_HELP_STRING([--with-ncurses], [Build with the ncurses library (default: test)]))
 AC_ARG_WITH([spirv-tools], AS_HELP_STRING([--with-spirv-tools],
                                           [Build with SPIRV-Tools library (default: disabled)]))
+AC_ARG_WITH([xcb], AS_HELP_STRING([--with-xcb], [Build with XCB library (default: test)]))
 AC_ARG_ENABLE([demos],
               AS_HELP_STRING([--enable-demos], [Build demo programs (default: disabled)]),,
               [enable_demos=no])
@@ -29,6 +30,12 @@ AC_PROG_MKDIR_P
 VKD3D_PROG_WIDL(3, 20)
 AS_IF([test "x$WIDL" = "xno"], [AC_MSG_WARN([widl is required to build header files.])])
 
+AC_CHECK_PROGS([FLEX], [flex], [none])
+AS_IF([test "$FLEX" = "none"], [AC_MSG_ERROR([no suitable flex found. Please install the 'flex' package.])])
+
+AC_CHECK_PROGS([BISON], [bison], [none])
+AS_IF([test "$BISON" = "none"], [AC_MSG_ERROR([no suitable bison found. Please install the 'bison' package.])])
+
 DX_PS_FEATURE([OFF])
 DX_INIT_DOXYGEN([vkd3d], [Doxyfile], [doc])
 AC_CONFIG_FILES([Doxyfile])
@@ -47,8 +54,10 @@ AC_SUBST([VKD3D_CFLAGS])
 AS_IF([test "x${GCC}" = "xyes"],
       [VKD3D_CFLAGS="-Wall -pipe"
       VKD3D_CHECK_CFLAGS([-std=c99])
+      VKD3D_CHECK_CFLAGS([-fvisibility=hidden])
       VKD3D_CHECK_CFLAGS([-Wdeclaration-after-statement])
       VKD3D_CHECK_CFLAGS([-Wimplicit-fallthrough])
+      VKD3D_CHECK_CFLAGS([-Winit-self])
       VKD3D_CHECK_CFLAGS([-Wmissing-prototypes])
       VKD3D_CHECK_CFLAGS([-Wunused-but-set-parameter])
       VKD3D_CHECK_CFLAGS([-Wvla])
@@ -60,11 +69,10 @@ VKD3D_CHECK_MINGW32_PROG([CROSSCC32], [CROSSTARGET32], [no])
 VKD3D_CHECK_MINGW64_PROG([CROSSCC64], [CROSSTARGET64], [no])
 
 dnl Check for headers
-AC_CHECK_HEADERS([dlfcn.h pthread.h \
+AC_CHECK_HEADERS([dlfcn.h \
                   vulkan/vulkan.h \
                   vulkan/spirv.h vulkan/GLSL.std.450.h \
                   spirv/unified1/spirv.h spirv/unified1/GLSL.std.450.h])
-AS_IF([test "x$ac_cv_header_pthread_h" != "xyes"], [AC_MSG_ERROR([pthread.h not found.])])
 AS_IF([test "x$ac_cv_header_vulkan_vulkan_h" != "xyes"], [AC_MSG_ERROR([vulkan.h not found.])])
 AS_IF([test "x$ac_cv_header_spirv_unified1_spirv_h" != "xyes" \
        -a "x$ac_cv_header_vulkan_spirv_h" != "xyes"],
@@ -73,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
@@ -94,21 +102,26 @@ AC_CHECK_LIB([dl], [dlopen],
              [DL_LIBS="-ldl"],
              [AS_IF([test "$ac_cv_header_dlfnc_h" = "xyes"], [AC_MSG_ERROR([libdl not found.])])])
 
-AC_ARG_VAR([PTHREAD_LIBS], [linker flags for pthreads])
+case $host_os in
-VKD3D_CHECK_PTHREAD
+  mingw32*) ;;
+  *) AC_CHECK_HEADERS([pthread.h])
+     AS_IF([test "x$ac_cv_header_pthread_h" != "xyes"], [AC_MSG_ERROR([pthread.h not found.])])
+     AC_ARG_VAR([PTHREAD_LIBS], [linker flags for pthreads])
+     VKD3D_CHECK_PTHREAD
+     VKD3D_CHECK_PTHREAD_SETNAME_NP
+     ;;
+esac
 
-AC_SUBST([VULKAN_LIBS])
+AC_ARG_VAR([SONAME_LIBVULKAN], [shared object name for the Vulkan library])
-VKD3D_CHECK_SONAME([vulkan], [vkGetInstanceProcAddr],
+AC_ARG_VAR([VULKAN_LIBS], [linker flags for the Vulkan library])
-                   [VULKAN_LIBS="-lvulkan"],
+AS_IF([test "x$SONAME_LIBVULKAN" = "x"],
-                   [VKD3D_CHECK_SONAME([vulkan-1], [vkGetInstanceProcAddr],
+      [VKD3D_CHECK_VULKAN],
-                                       [VULKAN_LIBS="-lvulkan-1"
+      [AC_DEFINE_UNQUOTED([SONAME_LIBVULKAN],["$SONAME_LIBVULKAN"],[Define to the shared object name of the Vulkan library.])])
-                                        AC_DEFINE_UNQUOTED([SONAME_LIBVULKAN], ["$ac_cv_lib_soname_vulkan_1"])],
-                                       [VKD3D_CHECK_SONAME([MoltenVK], [vkGetInstanceProcAddr],
-                                                           [VULKAN_LIBS="-lMoltenVK"
-                                                            AC_DEFINE_UNQUOTED([SONAME_LIBVULKAN],
-                                                                               ["$ac_cv_lib_soname_MoltenVK"])],
-                                                           [AC_MSG_ERROR([libvulkan and libMoltenVK not found.])])])])
 
+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],
+                         [with_ncurses=no])])
 AS_IF([test "x$with_spirv_tools" = "xyes"],
       [PKG_CHECK_MODULES([SPIRV_TOOLS], [SPIRV-Tools-shared],
       [AC_DEFINE([HAVE_SPIRV_TOOLS], [1], [Define to 1 if you have SPIRV-Tools.])])],
@@ -116,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])])
@@ -124,14 +137,22 @@ AS_IF([test "x$with_xcb" != "xno"],
 dnl Check for functions
 VKD3D_CHECK_FUNC([HAVE_BUILTIN_CLZ], [__builtin_clz], [__builtin_clz(0)])
 VKD3D_CHECK_FUNC([HAVE_BUILTIN_POPCOUNT], [__builtin_popcount], [__builtin_popcount(0)])
+VKD3D_CHECK_FUNC([HAVE_BUILTIN_ADD_OVERFLOW], [__builtin_add_overflow], [__builtin_add_overflow(0, 0, (int *)0)])
 VKD3D_CHECK_FUNC([HAVE_SYNC_ADD_AND_FETCH], [__sync_add_and_fetch], [__sync_add_and_fetch((int *)0, 0)])
 VKD3D_CHECK_FUNC([HAVE_SYNC_SUB_AND_FETCH], [__sync_sub_and_fetch], [__sync_sub_and_fetch((int *)0, 0)])
 
-VKD3D_CHECK_PTHREAD_SETNAME_NP
-
 dnl Makefiles
-AS_IF([test "x$enable_demos" = "xyes" -a "x$HAVE_XCB" != "xyes"],
+case $host_os in
+  mingw32*)
+      AC_SUBST([DEMO_LIBS],["-ld3d12 -ldxgi -lgdi32"])
+      AC_SUBST([DEMO_CFLAGS],["-municode"])
+      ;;
+  *) AS_IF([test "x$enable_demos" = "xyes" -a "x$HAVE_XCB" != "xyes"],
       [AC_MSG_ERROR([libxcb is required for demos.])])
+      AC_SUBST([DEMO_LIBS],[$XCB_LIBS])
+      AC_SUBST([DEMO_CFLAGS],[$XCB_CFLAGS])
+      ;;
+esac
 AM_CONDITIONAL([BUILD_DEMOS], [test "x$enable_demos" = "xyes"])
 AM_CONDITIONAL([BUILD_DOC], [test $DX_FLAG_doc = 1])
 AM_CONDITIONAL([BUILD_TESTS], [test "x$enable_tests" != "xno"])
@@ -144,22 +165,27 @@ 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
 
   widl: ${WIDL}
 
-  Have XCB: ${HAVE_XCB}
+  Have ncurses: ${with_ncurses}
   Have SPIRV-Tools: ${with_spirv_tools}
+  Have xcb: ${HAVE_XCB}
 
   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_2
+#define VKD3D_UTILS_API_VERSION VKD3D_API_VERSION_1_4
+#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/.gitignore

@@ -5,6 +5,7 @@ stamp-h1
 vkd3d_d3d12.h
 vkd3d_d3d12sdklayers.h
 vkd3d_d3dcommon.h
+vkd3d_d3dx9shader.h
 vkd3d_dxgi.h
 vkd3d_dxgi1_2.h
 vkd3d_dxgi1_3.h

include/private/rbtree.h

@@ -133,7 +133,7 @@ static inline struct rb_entry *rb_postorder_next(struct rb_entry *iter)
 /* iterate through the tree using a tree entry */
 #define RB_FOR_EACH_ENTRY(elem, tree, type, field) \
     for ((elem) = RB_ENTRY_VALUE(rb_head((tree)->root), type, field); \
-         &(elem)->field; \
+         (elem) != RB_ENTRY_VALUE(0, type, field); \
          (elem) = RB_ENTRY_VALUE(rb_next(&elem->field), type, field))
 
 /* iterate through the tree using using postorder, making it safe to free the entry */
@@ -145,7 +145,7 @@ static inline struct rb_entry *rb_postorder_next(struct rb_entry *iter)
 /* iterate through the tree using a tree entry and postorder, making it safe to free the entry */
 #define RB_FOR_EACH_ENTRY_DESTRUCTOR(elem, elem2, tree, type, field) \
     for ((elem) = RB_ENTRY_VALUE(rb_postorder_head((tree)->root), type, field); \
-         &(elem)->field \
+         (elem) != WINE_RB_ENTRY_VALUE(0, type, field) \
              && (((elem2) = RB_ENTRY_VALUE(rb_postorder_next(&(elem)->field), type, field)) || 1); \
          (elem) = (elem2))
 

include/private/vkd3d_blob.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2017 Józef Kucia for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef __VKD3D_BLOB_H
+#define __VKD3D_BLOB_H
+
+#include "vkd3d_windows.h"
+#include "vkd3d_d3dcommon.h"
+
+HRESULT vkd3d_blob_create(void *buffer, SIZE_T size, ID3D10Blob **blob);
+
+#endif  /* __VKD3D_BLOB_H */

include/private/vkd3d_common.h

@@ -21,10 +21,13 @@
 
 #include "config.h"
 #include "vkd3d_windows.h"
+#include "vkd3d_types.h"
 
 #include <ctype.h>
 #include <limits.h>
 #include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
 
 #ifdef _MSC_VER
 #include <intrin.h>
@@ -40,15 +43,21 @@
 
 #define MEMBER_SIZE(t, m) sizeof(((t *)0)->m)
 
+#define VKD3D_MAKE_TAG(ch0, ch1, ch2, ch3) \
+        ((uint32_t)(ch0) | ((uint32_t)(ch1) << 8) \
+        | ((uint32_t)(ch2) << 16) | ((uint32_t)(ch3) << 24))
+
 static inline size_t align(size_t addr, size_t alignment)
 {
     return (addr + (alignment - 1)) & ~(alignment - 1);
 }
 
 #ifdef __GNUC__
+# define VKD3D_NORETURN __attribute__((noreturn))
 # define VKD3D_PRINTF_FUNC(fmt, args) __attribute__((format(printf, fmt, args)))
 # define VKD3D_UNUSED __attribute__((unused))
 #else
+# define VKD3D_NORETURN
 # define VKD3D_PRINTF_FUNC(fmt, args)
 # define VKD3D_UNUSED
 #endif  /* __GNUC__ */
@@ -84,10 +93,10 @@ static inline bool vkd3d_bitmask_is_contiguous(unsigned int mask)
 /* Undefined for x == 0. */
 static inline unsigned int vkd3d_log2i(unsigned int x)
 {
-#ifdef _MSC_VER
+#ifdef _WIN32
     /* _BitScanReverse returns the index of the highest set bit,
      * unlike clz which is 31 - index. */
-    unsigned long result;
+    ULONG result;
     _BitScanReverse(&result, x);
     return (unsigned int)result;
 #elif defined(HAVE_BUILTIN_CLZ)
@@ -119,6 +128,46 @@ static inline unsigned int vkd3d_log2i(unsigned int x)
 #endif
 }
 
+static inline void *vkd3d_memmem( const void *haystack, size_t haystack_len, const void *needle, size_t needle_len)
+{
+    const char *str = haystack;
+
+    while (haystack_len >= needle_len)
+    {
+        if (!memcmp(str, needle, needle_len))
+            return (char *)str;
+        ++str;
+        --haystack_len;
+    }
+    return NULL;
+}
+
+static inline bool vkd3d_bound_range(size_t start, size_t count, size_t limit)
+{
+#ifdef HAVE_BUILTIN_ADD_OVERFLOW
+    size_t sum;
+
+    return !__builtin_add_overflow(start, count, &sum) && sum <= limit;
+#else
+    return start <= limit && count <= limit - start;
+#endif
+}
+
+static inline uint16_t vkd3d_make_u16(uint8_t low, uint8_t high)
+{
+    return low | ((uint16_t)high << 8);
+}
+
+static inline uint32_t vkd3d_make_u32(uint16_t low, uint16_t high)
+{
+    return low | ((uint32_t)high << 16);
+}
+
+static inline int vkd3d_u32_compare(uint32_t x, uint32_t y)
+{
+    return (x > y) - (x < y);
+}
+
 static inline int ascii_isupper(int c)
 {
     return 'A' <= c && c <= 'Z';
@@ -129,6 +178,20 @@ static inline int ascii_tolower(int c)
     return ascii_isupper(c) ? c - 'A' + 'a' : c;
 }
 
+static inline int ascii_strncasecmp(const char *a, const char *b, size_t n)
+{
+    int c_a, c_b;
+
+    while (n--)
+    {
+        c_a = ascii_tolower(*a++);
+        c_b = ascii_tolower(*b++);
+        if (c_a != c_b || !c_a)
+            return c_a - c_b;
+    }
+    return 0;
+}
+
 static inline int ascii_strcasecmp(const char *a, const char *b)
 {
     int c_a, c_b;
@@ -148,6 +211,14 @@ 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);
+}
 # else
 #  error "InterlockedIncrement() not implemented for this platform"
 # endif  /* HAVE_SYNC_ADD_AND_FETCH */
@@ -162,15 +233,6 @@ static inline LONG InterlockedDecrement(LONG volatile *x)
 # endif
 #endif  /* _WIN32 */
 
-#if HAVE_SYNC_ADD_AND_FETCH
-# define atomic_add_fetch(ptr, val) __sync_add_and_fetch(ptr, val)
-#elif defined(_MSC_VER)
-/* InterlockedAdd returns value after increment, like add_and_fetch. */
-# define atomic_add_fetch(ptr, val) InterlockedAdd(ptr, val)
-#else
-# error "atomic_add_fetch() not implemented for this platform"
-#endif  /* HAVE_SYNC_ADD_AND_FETCH */
-
 static inline void vkd3d_parse_version(const char *version, int *major, int *minor)
 {
     *major = atoi(version);
@@ -183,4 +245,76 @@ static inline void vkd3d_parse_version(const char *version, int *major, int *min
     *minor = atoi(version);
 }
 
+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

@@ -44,15 +44,16 @@ enum vkd3d_dbg_level
     VKD3D_DBG_LEVEL_TRACE,
 };
 
-enum vkd3d_dbg_level vkd3d_dbg_get_level(void) DECLSPEC_HIDDEN;
+enum vkd3d_dbg_level vkd3d_dbg_get_level(void);
 
-void vkd3d_dbg_printf(enum vkd3d_dbg_level level, const char *function,
+void vkd3d_dbg_printf(enum vkd3d_dbg_level level, const char *function, const char *fmt, ...) VKD3D_PRINTF_FUNC(3, 4);
-        const char *fmt, ...) VKD3D_PRINTF_FUNC(3, 4) DECLSPEC_HIDDEN;
+void vkd3d_dbg_set_log_callback(PFN_vkd3d_log callback);
 
-const char *vkd3d_dbg_sprintf(const char *fmt, ...) VKD3D_PRINTF_FUNC(1, 2) DECLSPEC_HIDDEN;
+const char *vkd3d_dbg_sprintf(const char *fmt, ...) VKD3D_PRINTF_FUNC(1, 2);
-const char *vkd3d_dbg_vsprintf(const char *fmt, va_list args) DECLSPEC_HIDDEN;
+const char *vkd3d_dbg_vsprintf(const char *fmt, va_list args);
-const char *debugstr_a(const char *str) DECLSPEC_HIDDEN;
+const char *debugstr_a(const char *str);
-const char *debugstr_w(const WCHAR *wstr, size_t wchar_size) DECLSPEC_HIDDEN;
+const char *debugstr_an(const char *str, size_t n);
+const char *debugstr_w(const WCHAR *wstr, size_t wchar_size);
 
 #define VKD3D_DBG_LOG(level) \
         do { \
@@ -103,7 +104,7 @@ static inline const char *debugstr_guid(const GUID *guid)
             guid->Data4[5], guid->Data4[6], guid->Data4[7]);
 }
 
-unsigned int vkd3d_env_var_as_uint(const char *name, unsigned int default_value) DECLSPEC_HIDDEN;
+unsigned int vkd3d_env_var_as_uint(const char *name, unsigned int default_value);
 
 struct vkd3d_debug_option
 {
@@ -111,8 +112,8 @@ struct vkd3d_debug_option
     uint64_t flag;
 };
 
-bool vkd3d_debug_list_has_member(const char *string, const char *member) DECLSPEC_HIDDEN;
+bool vkd3d_debug_list_has_member(const char *string, const char *member);
 uint64_t vkd3d_parse_debug_options(const char *string,
-        const struct vkd3d_debug_option *options, unsigned int option_count) DECLSPEC_HIDDEN;
+        const struct vkd3d_debug_option *options, unsigned int option_count);
 
 #endif  /* __VKD3D_DEBUG_H */

include/private/vkd3d_memory.h

@@ -22,6 +22,7 @@
 #include <assert.h>
 #include <stdbool.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "vkd3d_debug.h"
 
@@ -36,7 +37,7 @@ static inline void *vkd3d_malloc(size_t size)
 static inline void *vkd3d_realloc(void *ptr, size_t size)
 {
     if (!(ptr = realloc(ptr, size)))
-        ERR("Out of memory.\n");
+        ERR("Out of memory, size %zu.\n", size);
     return ptr;
 }
 
@@ -54,7 +55,16 @@ static inline void vkd3d_free(void *ptr)
     free(ptr);
 }
 
-bool vkd3d_array_reserve(void **elements, size_t *capacity,
+static inline char *vkd3d_strdup(const char *string)
-        size_t element_count, size_t element_size) DECLSPEC_HIDDEN;
+{
+    size_t len = strlen(string) + 1;
+    char *ptr;
+
+    if ((ptr = vkd3d_malloc(len)))
+        memcpy(ptr, string, len);
+    return ptr;
+}
+
+bool vkd3d_array_reserve(void **elements, size_t *capacity, size_t element_count, size_t element_size);
 
 #endif  /* __VKD3D_MEMORY_H */

include/private/vkd3d_test.h

@@ -28,16 +28,15 @@
 #include <stdlib.h>
 #include <string.h>
 
-static void vkd3d_test_main(int argc, char **argv);
+extern const char *vkd3d_test_name;
-static const char *vkd3d_test_name;
+extern const char *vkd3d_test_platform;
-static const char *vkd3d_test_platform = "other";
 
 static void vkd3d_test_start_todo(bool is_todo);
 static int vkd3d_test_loop_todo(void);
 static void vkd3d_test_end_todo(void);
 
 #define START_TEST(name) \
-        static const char *vkd3d_test_name = #name; \
+        const char *vkd3d_test_name = #name; \
         static void vkd3d_test_main(int argc, char **argv)
 
 /*
@@ -100,7 +99,7 @@ static void vkd3d_test_end_todo(void);
 
 #define todo todo_if(true)
 
-static struct
+struct vkd3d_test_state
 {
     LONG success_count;
     LONG failure_count;
@@ -120,7 +119,8 @@ static struct
 
     const char *test_name_filter;
     char context[1024];
-} vkd3d_test_state;
+};
+extern struct vkd3d_test_state vkd3d_test_state;
 
 static bool
 vkd3d_test_platform_is_windows(void)
@@ -253,6 +253,12 @@ vkd3d_test_debug(const char *fmt, ...)
         printf("%s\n", buffer);
 }
 
+#ifndef VKD3D_TEST_NO_DEFS
+const char *vkd3d_test_platform = "other";
+struct vkd3d_test_state vkd3d_test_state;
+
+static void vkd3d_test_main(int argc, char **argv);
+
 int main(int argc, char **argv)
 {
     const char *test_filter = getenv("VKD3D_TEST_FILTER");
@@ -339,6 +345,7 @@ int wmain(int argc, WCHAR **wargv)
     return ret;
 }
 #endif  /* _WIN32 */
+#endif /* VKD3D_TEST_NO_DEFS */
 
 typedef void (*vkd3d_test_pfn)(void);
 

include/private/vkd3d_utf8.h

@@ -21,6 +21,6 @@
 
 #include "vkd3d_common.h"
 
-char *vkd3d_strdup_w_utf8(const WCHAR *wstr, size_t wchar_size) DECLSPEC_HIDDEN;
+char *vkd3d_strdup_w_utf8(const WCHAR *wstr, size_t wchar_size);
 
 #endif /* __VKD3D_UTF8_H */

include/vkd3d.h

@@ -48,6 +48,9 @@ enum vkd3d_structure_type
     VKD3D_STRUCTURE_TYPE_OPTIONAL_DEVICE_EXTENSIONS_INFO,
     VKD3D_STRUCTURE_TYPE_APPLICATION_INFO,
 
+    /* 1.3 */
+    VKD3D_STRUCTURE_TYPE_HOST_TIME_DOMAIN_INFO,
+
     VKD3D_FORCE_32_BIT_ENUM(VKD3D_STRUCTURE_TYPE),
 };
 
@@ -56,6 +59,8 @@ enum vkd3d_api_version
     VKD3D_API_VERSION_1_0,
     VKD3D_API_VERSION_1_1,
     VKD3D_API_VERSION_1_2,
+    VKD3D_API_VERSION_1_3,
+    VKD3D_API_VERSION_1_4,
 };
 
 typedef HRESULT (*PFN_vkd3d_signal_event)(HANDLE event);
@@ -109,6 +114,15 @@ struct vkd3d_application_info
     enum vkd3d_api_version api_version;
 };
 
+/* Extends vkd3d_instance_create_info. Available since 1.3. */
+struct vkd3d_host_time_domain_info
+{
+    enum vkd3d_structure_type type;
+    const void *next;
+
+    uint64_t ticks_per_second;
+};
+
 struct vkd3d_device_create_info
 {
     enum vkd3d_structure_type type;
@@ -153,46 +167,66 @@ struct vkd3d_image_resource_create_info
     D3D12_RESOURCE_STATES present_state;
 };
 
+#ifdef LIBVKD3D_SOURCE
+# define VKD3D_API VKD3D_EXPORT
+#else
+# define VKD3D_API VKD3D_IMPORT
+#endif
+
 #ifndef VKD3D_NO_PROTOTYPES
 
-HRESULT vkd3d_create_instance(const struct vkd3d_instance_create_info *create_info,
+VKD3D_API HRESULT vkd3d_create_instance(const struct vkd3d_instance_create_info *create_info,
         struct vkd3d_instance **instance);
-ULONG vkd3d_instance_decref(struct vkd3d_instance *instance);
+VKD3D_API ULONG vkd3d_instance_decref(struct vkd3d_instance *instance);
-VkInstance vkd3d_instance_get_vk_instance(struct vkd3d_instance *instance);
+VKD3D_API VkInstance vkd3d_instance_get_vk_instance(struct vkd3d_instance *instance);
-ULONG vkd3d_instance_incref(struct vkd3d_instance *instance);
+VKD3D_API ULONG vkd3d_instance_incref(struct vkd3d_instance *instance);
 
-HRESULT vkd3d_create_device(const struct vkd3d_device_create_info *create_info,
+VKD3D_API HRESULT vkd3d_create_device(const struct vkd3d_device_create_info *create_info,
         REFIID iid, void **device);
-IUnknown *vkd3d_get_device_parent(ID3D12Device *device);
+VKD3D_API IUnknown *vkd3d_get_device_parent(ID3D12Device *device);
-VkDevice vkd3d_get_vk_device(ID3D12Device *device);
+VKD3D_API VkDevice vkd3d_get_vk_device(ID3D12Device *device);
-VkPhysicalDevice vkd3d_get_vk_physical_device(ID3D12Device *device);
+VKD3D_API VkPhysicalDevice vkd3d_get_vk_physical_device(ID3D12Device *device);
-struct vkd3d_instance *vkd3d_instance_from_device(ID3D12Device *device);
+VKD3D_API struct vkd3d_instance *vkd3d_instance_from_device(ID3D12Device *device);
 
-uint32_t vkd3d_get_vk_queue_family_index(ID3D12CommandQueue *queue);
+VKD3D_API uint32_t vkd3d_get_vk_queue_family_index(ID3D12CommandQueue *queue);
-VkQueue vkd3d_acquire_vk_queue(ID3D12CommandQueue *queue);
+VKD3D_API VkQueue vkd3d_acquire_vk_queue(ID3D12CommandQueue *queue);
-void vkd3d_release_vk_queue(ID3D12CommandQueue *queue);
+VKD3D_API void vkd3d_release_vk_queue(ID3D12CommandQueue *queue);
 
-HRESULT vkd3d_create_image_resource(ID3D12Device *device,
+VKD3D_API HRESULT vkd3d_create_image_resource(ID3D12Device *device,
         const struct vkd3d_image_resource_create_info *create_info, ID3D12Resource **resource);
-ULONG vkd3d_resource_decref(ID3D12Resource *resource);
+VKD3D_API ULONG vkd3d_resource_decref(ID3D12Resource *resource);
-ULONG vkd3d_resource_incref(ID3D12Resource *resource);
+VKD3D_API ULONG vkd3d_resource_incref(ID3D12Resource *resource);
 
-HRESULT vkd3d_serialize_root_signature(const D3D12_ROOT_SIGNATURE_DESC *desc,
+VKD3D_API HRESULT vkd3d_serialize_root_signature(const D3D12_ROOT_SIGNATURE_DESC *desc,
         D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob);
-HRESULT vkd3d_create_root_signature_deserializer(const void *data, SIZE_T data_size,
+VKD3D_API HRESULT vkd3d_create_root_signature_deserializer(const void *data, SIZE_T data_size,
         REFIID iid, void **deserializer);
 
-VkFormat vkd3d_get_vk_format(DXGI_FORMAT format);
+VKD3D_API VkFormat vkd3d_get_vk_format(DXGI_FORMAT format);
 
 /* 1.1 */
-DXGI_FORMAT vkd3d_get_dxgi_format(VkFormat format);
+VKD3D_API DXGI_FORMAT vkd3d_get_dxgi_format(VkFormat format);
 
 /* 1.2 */
-HRESULT vkd3d_serialize_versioned_root_signature(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc,
+VKD3D_API HRESULT vkd3d_serialize_versioned_root_signature(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc,
         ID3DBlob **blob, ID3DBlob **error_blob);
-HRESULT vkd3d_create_versioned_root_signature_deserializer(const void *data, SIZE_T data_size,
+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 */
 
 /*
@@ -236,6 +270,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

@@ -89,6 +89,7 @@ typedef enum D3D12_SHADER_MIN_PRECISION_SUPPORT
     D3D12_SHADER_MIN_PRECISION_SUPPORT_10_BIT = 0x1,
     D3D12_SHADER_MIN_PRECISION_SUPPORT_16_BIT = 0x2,
 } D3D12_SHADER_MIN_PRECISION_SUPPORT;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_SHADER_MIN_PRECISION_SUPPORT);")
 
 typedef enum D3D12_TILED_RESOURCES_TIER
 {
@@ -160,6 +161,7 @@ typedef enum D3D12_FORMAT_SUPPORT1
     D3D12_FORMAT_SUPPORT1_VIDEO_PROCESSOR_INPUT = 0x20000000,
     D3D12_FORMAT_SUPPORT1_VIDEO_ENCODER = 0x40000000,
 } D3D12_FORMAT_SUPPORT1;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_FORMAT_SUPPORT1);")
 
 typedef enum D3D12_FORMAT_SUPPORT2
 {
@@ -176,6 +178,7 @@ typedef enum D3D12_FORMAT_SUPPORT2
     D3D12_FORMAT_SUPPORT2_TILED = 0x00000200,
     D3D12_FORMAT_SUPPORT2_MULTIPLANE_OVERLAY = 0x00004000,
 } D3D12_FORMAT_SUPPORT2;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_FORMAT_SUPPORT2);")
 
 typedef enum D3D12_WRITEBUFFERIMMEDIATE_MODE
 {
@@ -199,6 +202,7 @@ typedef enum D3D12_SHADER_CACHE_SUPPORT_FLAGS
     D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_INPROC_CACHE = 0x4,
     D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_DISK_CACHE = 0x8,
 }  D3D12_SHADER_CACHE_SUPPORT_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_SHADER_CACHE_SUPPORT_FLAGS);")
 
 typedef enum D3D12_COMMAND_LIST_SUPPORT_FLAGS
 {
@@ -211,6 +215,7 @@ typedef enum D3D12_COMMAND_LIST_SUPPORT_FLAGS
     D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_PROCESS = 0x20,
     D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_ENCODE = 0x40,
 } D3D12_COMMAND_LIST_SUPPORT_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_COMMAND_LIST_SUPPORT_FLAGS);")
 
 typedef enum D3D12_VIEW_INSTANCING_TIER
 {
@@ -245,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;
@@ -357,6 +369,7 @@ typedef enum D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS
     D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_NONE = 0x00000000,
     D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_TILED_RESOURCE = 0x00000001,
 } D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS);")
 
 typedef struct D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS
 {
@@ -407,11 +420,17 @@ 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,
     D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES = 0x84,
 } D3D12_HEAP_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_HEAP_FLAGS);")
 
 typedef struct D3D12_HEAP_DESC
 {
@@ -503,6 +522,12 @@ typedef enum D3D12_RESOURCE_STATES
     D3D12_RESOURCE_STATE_GENERIC_READ = 0x1 | 0x2 | 0x40 | 0x80 | 0x200 | 0x800,
     D3D12_RESOURCE_STATE_PRESENT = 0x0,
     D3D12_RESOURCE_STATE_PREDICATION = 0x200,
+    D3D12_RESOURCE_STATE_VIDEO_DECODE_READ = 0x10000,
+    D3D12_RESOURCE_STATE_VIDEO_DECODE_WRITE = 0x20000,
+    D3D12_RESOURCE_STATE_VIDEO_PROCESS_READ = 0x40000,
+    D3D12_RESOURCE_STATE_VIDEO_PROCESS_WRITE = 0x80000,
+    D3D12_RESOURCE_STATE_VIDEO_ENCODE_READ = 0x200000,
+    D3D12_RESOURCE_STATE_VIDEO_ENCODE_WRITE = 0x800000,
 } D3D12_RESOURCE_STATES;
 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RESOURCE_STATES);")
 
@@ -519,6 +544,7 @@ typedef enum D3D12_RESOURCE_BARRIER_FLAGS
     D3D12_RESOURCE_BARRIER_FLAG_BEGIN_ONLY = 0x1,
     D3D12_RESOURCE_BARRIER_FLAG_END_ONLY = 0x2,
 } D3D12_RESOURCE_BARRIER_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RESOURCE_BARRIER_FLAGS);")
 
 typedef struct D3D12_RESOURCE_TRANSITION_BARRIER
 {
@@ -665,6 +691,7 @@ typedef enum D3D12_DESCRIPTOR_RANGE_FLAGS
     D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE = 0x4,
     D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC = 0x8,
 } D3D12_DESCRIPTOR_RANGE_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_DESCRIPTOR_RANGE_FLAGS);")
 
 typedef struct D3D12_DESCRIPTOR_RANGE1
 {
@@ -708,6 +735,7 @@ typedef enum D3D12_ROOT_DESCRIPTOR_FLAGS
     D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE = 0x4,
     D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC = 0x8,
 } D3D12_ROOT_DESCRIPTOR_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_ROOT_DESCRIPTOR_FLAGS);")
 
 typedef struct D3D12_ROOT_DESCRIPTOR1
 {
@@ -900,7 +928,13 @@ 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);")
 
 typedef struct D3D12_ROOT_SIGNATURE_DESC
 {
@@ -951,6 +985,7 @@ typedef enum D3D12_DESCRIPTOR_HEAP_FLAGS
     D3D12_DESCRIPTOR_HEAP_FLAG_NONE = 0x0,
     D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE = 0x1,
 } D3D12_DESCRIPTOR_HEAP_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_DESCRIPTOR_HEAP_FLAGS);")
 
 typedef struct D3D12_DESCRIPTOR_HEAP_DESC
 {
@@ -988,6 +1023,7 @@ typedef enum D3D12_BUFFER_SRV_FLAGS
     D3D12_BUFFER_SRV_FLAG_NONE = 0x0,
     D3D12_BUFFER_SRV_FLAG_RAW = 0x1,
 } D3D12_BUFFER_SRV_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_BUFFER_SRV_FLAGS);")
 
 typedef enum D3D12_SHADER_COMPONENT_MAPPING
 {
@@ -1123,6 +1159,7 @@ typedef enum D3D12_BUFFER_UAV_FLAGS
     D3D12_BUFFER_UAV_FLAG_NONE = 0x0,
     D3D12_BUFFER_UAV_FLAG_RAW = 0x1,
 } D3D12_BUFFER_UAV_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_BUFFER_UAV_FLAGS);")
 
 typedef struct D3D12_BUFFER_UAV
 {
@@ -1425,11 +1462,22 @@ typedef enum D3D12_BLEND_OP
 
 typedef enum D3D12_LOGIC_OP
 {
-    D3D12_LOGIC_OP_CLEAR = 0,
+    D3D12_LOGIC_OP_CLEAR = 0x0,
-    D3D12_LOGIC_OP_SET = 1,
+    D3D12_LOGIC_OP_SET = 0x1,
-    D3D12_LOGIC_OP_COPY = 2,
+    D3D12_LOGIC_OP_COPY = 0x2,
-    D3D12_LOGIC_OP_COPY_INVERTED = 3,
+    D3D12_LOGIC_OP_COPY_INVERTED = 0x3,
-    D3D12_LOGIC_OP_NOOP = 4,
+    D3D12_LOGIC_OP_NOOP = 0x4,
+    D3D12_LOGIC_OP_INVERT = 0x5,
+    D3D12_LOGIC_OP_AND = 0x6,
+    D3D12_LOGIC_OP_NAND = 0x7,
+    D3D12_LOGIC_OP_OR = 0x8,
+    D3D12_LOGIC_OP_NOR = 0x9,
+    D3D12_LOGIC_OP_XOR = 0xa,
+    D3D12_LOGIC_OP_EQUIV = 0xb,
+    D3D12_LOGIC_OP_AND_REVERSE = 0xc,
+    D3D12_LOGIC_OP_AND_INVERTED = 0xd,
+    D3D12_LOGIC_OP_OR_REVERSE = 0xe,
+    D3D12_LOGIC_OP_OR_INVERTED = 0xf,
 } D3D12_LOGIC_OP;
 
 typedef enum D3D12_COLOR_WRITE_ENABLE
@@ -1438,8 +1486,8 @@ typedef enum D3D12_COLOR_WRITE_ENABLE
     D3D12_COLOR_WRITE_ENABLE_GREEN = 0x2,
     D3D12_COLOR_WRITE_ENABLE_BLUE = 0x4,
     D3D12_COLOR_WRITE_ENABLE_ALPHA = 0x8,
-    D3D12_COLOR_WRITE_ENABLE_ALL = (D3D12_COLOR_WRITE_ENABLE_RED\
+    D3D12_COLOR_WRITE_ENABLE_ALL = (D3D12_COLOR_WRITE_ENABLE_RED
-            | D3D12_COLOR_WRITE_ENABLE_GREEN | D3D12_COLOR_WRITE_ENABLE_BLUE\
+            | D3D12_COLOR_WRITE_ENABLE_GREEN | D3D12_COLOR_WRITE_ENABLE_BLUE
             | D3D12_COLOR_WRITE_ENABLE_ALPHA),
 } D3D12_COLOR_WRITE_ENABLE;
 
@@ -1569,6 +1617,7 @@ typedef enum D3D12_PIPELINE_STATE_FLAGS
     D3D12_PIPELINE_STATE_FLAG_NONE = 0x0,
     D3D12_PIPELINE_STATE_FLAG_DEBUG = 0x1,
 } D3D12_PIPELINE_STATE_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_PIPELINE_STATE_FLAGS);")
 
 typedef struct D3D12_GRAPHICS_PIPELINE_STATE_DESC
 {
@@ -1604,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,
@@ -1624,6 +1679,7 @@ typedef enum D3D12_COMMAND_QUEUE_FLAGS
     D3D12_COMMAND_QUEUE_FLAG_NONE = 0x0,
     D3D12_COMMAND_QUEUE_FLAG_DISABLE_GPU_TIMEOUT = 0x1,
 } D3D12_COMMAND_QUEUE_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_COMMAND_QUEUE_FLAGS);")
 
 typedef struct D3D12_COMMAND_QUEUE_DESC
 {
@@ -1764,6 +1820,7 @@ typedef enum D3D12_FEATURE
     D3D12_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT = 6,
     D3D12_FEATURE_SHADER_MODEL = 7,
     D3D12_FEATURE_D3D12_OPTIONS1 = 8,
+    D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_SUPPORT = 10,
     D3D12_FEATURE_ROOT_SIGNATURE = 12,
     D3D12_FEATURE_ARCHITECTURE1 = 16,
     D3D12_FEATURE_D3D12_OPTIONS2 = 18,
@@ -1775,6 +1832,11 @@ typedef enum D3D12_FEATURE
     D3D12_FEATURE_SERIALIZATION = 24,
     D3D12_FEATURE_CROSS_NODE = 25,
     D3D12_FEATURE_D3D12_OPTIONS5 = 27,
+    D3D12_FEATURE_D3D12_OPTIONS6 = 30,
+    D3D12_FEATURE_QUERY_META_COMMAND = 31,
+    D3D12_FEATURE_D3D12_OPTIONS7 = 32,
+    D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPE_COUNT = 33,
+    D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPES = 34,
 } D3D12_FEATURE;
 
 typedef struct D3D12_MEMCPY_DEST
@@ -1901,6 +1963,7 @@ typedef enum D3D12_TILE_COPY_FLAGS
     D3D12_TILE_COPY_FLAG_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE = 0x2,
     D3D12_TILE_COPY_FLAG_SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER = 0x4,
 } D3D12_TILE_COPY_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_TILE_COPY_FLAGS);")
 
 typedef struct D3D12_INDEX_BUFFER_VIEW
 {
@@ -2023,7 +2086,7 @@ interface ID3D12GraphicsCommandList : ID3D12CommandList
 
     HRESULT Reset(ID3D12CommandAllocator *allocator, ID3D12PipelineState *initial_state);
 
-    HRESULT ClearState(ID3D12PipelineState *pipeline_state);
+    void ClearState(ID3D12PipelineState *pipeline_state);
 
     void DrawInstanced(UINT vertex_count_per_instance, UINT instance_count,
             UINT start_vertex_location, UINT start_instance_location);
@@ -2187,6 +2250,7 @@ typedef enum D3D12_TILE_MAPPING_FLAGS
     D3D12_TILE_MAPPING_FLAG_NONE = 0x0,
     D3D12_TILE_MAPPING_FLAG_NO_HAZARD = 0x1,
 } D3D12_TILE_MAPPING_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_TILE_MAPPING_FLAGS);")
 
 [
     uuid(0ec870a6-5d7e-4c22-8cfc-5baae07616ed),
@@ -2234,6 +2298,7 @@ typedef enum D3D12_FENCE_FLAGS
     D3D12_FENCE_FLAG_SHARED = 0x1,
     D3D12_FENCE_FLAG_SHARED_CROSS_ADAPTER = 0x2,
 } D3D12_FENCE_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_FENCE_FLAGS);")
 
 typedef enum D3D12_QUERY_HEAP_TYPE
 {
@@ -2491,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,
@@ -2545,3 +2650,6 @@ typedef HRESULT (__stdcall *PFN_D3D12_CREATE_DEVICE)(IUnknown *adapter,
 typedef HRESULT (__stdcall *PFN_D3D12_GET_DEBUG_INTERFACE)(REFIID iid, void **debug);
 
 [local] HRESULT __stdcall D3D12GetDebugInterface(REFIID iid, void **debug);
+
+[local] HRESULT __stdcall D3D12EnableExperimentalFeatures(UINT feature_count,
+        const IID *iids, void *configurations, UINT *configurations_sizes);

include/vkd3d_d3d9types.h

@@ -0,0 +1,237 @@
+/*
+ * Copyright 2002-2003 Jason Edmeades
+ * Copyright 2002-2003 Raphael Junqueira
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef __VKD3D_D3D9TYPES_H
+#define __VKD3D_D3D9TYPES_H
+#ifndef _d3d9TYPES_H_
+
+#ifndef MAKEFOURCC
+#define MAKEFOURCC(ch0, ch1, ch2, ch3)  \
+    ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) |  \
+    ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))
+#endif
+
+#define D3DSI_INSTLENGTH_SHIFT  24
+
+#define D3DSP_DCL_USAGE_SHIFT       0
+#define D3DSP_DCL_USAGEINDEX_SHIFT  16
+#define D3DSP_DSTMOD_SHIFT          20
+
+#define D3DSP_SRCMOD_SHIFT      24
+
+#define D3DSP_REGTYPE_SHIFT     28
+#define D3DSP_REGTYPE_SHIFT2    8
+#define D3DSP_REGTYPE_MASK      (0x7 << D3DSP_REGTYPE_SHIFT)
+#define D3DSP_REGTYPE_MASK2     0x00001800
+
+#define D3DSP_WRITEMASK_0       0x00010000
+#define D3DSP_WRITEMASK_1       0x00020000
+#define D3DSP_WRITEMASK_2       0x00040000
+#define D3DSP_WRITEMASK_3       0x00080000
+#define D3DSP_WRITEMASK_ALL     0x000f0000
+
+#define D3DPS_VERSION(major, minor) (0xffff0000 | ((major) << 8) | (minor))
+#define D3DVS_VERSION(major, minor) (0xfffe0000 | ((major) << 8) | (minor))
+
+typedef enum _D3DDECLUSAGE
+{
+    D3DDECLUSAGE_POSITION       = 0x0,
+    D3DDECLUSAGE_BLENDWEIGHT    = 0x1,
+    D3DDECLUSAGE_BLENDINDICES   = 0x2,
+    D3DDECLUSAGE_NORMAL         = 0x3,
+    D3DDECLUSAGE_PSIZE          = 0x4,
+    D3DDECLUSAGE_TEXCOORD       = 0x5,
+    D3DDECLUSAGE_TANGENT        = 0x6,
+    D3DDECLUSAGE_BINORMAL       = 0x7,
+    D3DDECLUSAGE_TESSFACTOR     = 0x8,
+    D3DDECLUSAGE_POSITIONT      = 0x9,
+    D3DDECLUSAGE_COLOR          = 0xa,
+    D3DDECLUSAGE_FOG            = 0xb,
+    D3DDECLUSAGE_DEPTH          = 0xc,
+    D3DDECLUSAGE_SAMPLE         = 0xd,
+} D3DDECLUSAGE;
+
+typedef enum _D3DSHADER_INSTRUCTION_OPCODE_TYPE
+{
+    D3DSIO_NOP          = 0x00,
+    D3DSIO_MOV          = 0x01,
+    D3DSIO_ADD          = 0x02,
+    D3DSIO_SUB          = 0x03,
+    D3DSIO_MAD          = 0x04,
+    D3DSIO_MUL          = 0x05,
+    D3DSIO_RCP          = 0x06,
+    D3DSIO_RSQ          = 0x07,
+    D3DSIO_DP3          = 0x08,
+    D3DSIO_DP4          = 0x09,
+    D3DSIO_MIN          = 0x0a,
+    D3DSIO_MAX          = 0x0b,
+    D3DSIO_SLT          = 0x0c,
+    D3DSIO_SGE          = 0x0d,
+    D3DSIO_EXP          = 0x0e,
+    D3DSIO_LOG          = 0x0f,
+    D3DSIO_LIT          = 0x10,
+    D3DSIO_DST          = 0x11,
+    D3DSIO_LRP          = 0x12,
+    D3DSIO_FRC          = 0x13,
+    D3DSIO_M4x4         = 0x14,
+    D3DSIO_M4x3         = 0x15,
+    D3DSIO_M3x4         = 0x16,
+    D3DSIO_M3x3         = 0x17,
+    D3DSIO_M3x2         = 0x18,
+    D3DSIO_CALL         = 0x19,
+    D3DSIO_CALLNZ       = 0x1a,
+    D3DSIO_LOOP         = 0x1b,
+    D3DSIO_RET          = 0x1c,
+    D3DSIO_ENDLOOP      = 0x1d,
+    D3DSIO_LABEL        = 0x1e,
+    D3DSIO_DCL          = 0x1f,
+    D3DSIO_POW          = 0x20,
+    D3DSIO_CRS          = 0x21,
+    D3DSIO_SGN          = 0x22,
+    D3DSIO_ABS          = 0x23,
+    D3DSIO_NRM          = 0x24,
+    D3DSIO_SINCOS       = 0x25,
+    D3DSIO_REP          = 0x26,
+    D3DSIO_ENDREP       = 0x27,
+    D3DSIO_IF           = 0x28,
+    D3DSIO_IFC          = 0x29,
+    D3DSIO_ELSE         = 0x2a,
+    D3DSIO_ENDIF        = 0x2b,
+    D3DSIO_BREAK        = 0x2c,
+    D3DSIO_BREAKC       = 0x2d,
+    D3DSIO_MOVA         = 0x2e,
+    D3DSIO_DEFB         = 0x2f,
+    D3DSIO_DEFI         = 0x30,
+
+    D3DSIO_TEXCOORD     = 0x40,
+    D3DSIO_TEXKILL      = 0x41,
+    D3DSIO_TEX          = 0x42,
+    D3DSIO_TEXBEM       = 0x43,
+    D3DSIO_TEXBEML      = 0x44,
+    D3DSIO_TEXREG2AR    = 0x45,
+    D3DSIO_TEXREG2GB    = 0x46,
+    D3DSIO_TEXM3x2PAD   = 0x47,
+    D3DSIO_TEXM3x2TEX   = 0x48,
+    D3DSIO_TEXM3x3PAD   = 0x49,
+    D3DSIO_TEXM3x3TEX   = 0x4a,
+    D3DSIO_TEXM3x3DIFF  = 0x4b,
+    D3DSIO_TEXM3x3SPEC  = 0x4c,
+    D3DSIO_TEXM3x3VSPEC = 0x4d,
+    D3DSIO_EXPP         = 0x4e,
+    D3DSIO_LOGP         = 0x4f,
+    D3DSIO_CND          = 0x50,
+    D3DSIO_DEF          = 0x51,
+    D3DSIO_TEXREG2RGB   = 0x52,
+    D3DSIO_TEXDP3TEX    = 0x53,
+    D3DSIO_TEXM3x2DEPTH = 0x54,
+    D3DSIO_TEXDP3       = 0x55,
+    D3DSIO_TEXM3x3      = 0x56,
+    D3DSIO_TEXDEPTH     = 0x57,
+    D3DSIO_CMP          = 0x58,
+    D3DSIO_BEM          = 0x59,
+    D3DSIO_DP2ADD       = 0x5a,
+    D3DSIO_DSX          = 0x5b,
+    D3DSIO_DSY          = 0x5c,
+    D3DSIO_TEXLDD       = 0x5d,
+    D3DSIO_SETP         = 0x5e,
+    D3DSIO_TEXLDL       = 0x5f,
+    D3DSIO_BREAKP       = 0x60,
+
+    D3DSIO_PHASE        = 0xfffd,
+    D3DSIO_COMMENT      = 0xfffe,
+    D3DSIO_END          = 0xffff,
+
+    D3DSIO_FORCE_DWORD  = 0x7fffffff,
+} D3DSHADER_INSTRUCTION_OPCODE_TYPE;
+
+typedef enum _D3DSHADER_PARAM_DSTMOD_TYPE
+{
+    D3DSPDM_NONE                = 0 << D3DSP_DSTMOD_SHIFT,
+    D3DSPDM_SATURATE            = 1 << D3DSP_DSTMOD_SHIFT,
+    D3DSPDM_PARTIALPRECISION    = 2 << D3DSP_DSTMOD_SHIFT,
+    D3DSPDM_MSAMPCENTROID       = 4 << D3DSP_DSTMOD_SHIFT,
+
+    D3DSPDM_FORCE_DWORD         = 0x7fffffff,
+} D3DSHADER_PARAM_DSTMOD_TYPE;
+
+typedef enum _D3DSHADER_PARAM_REGISTER_TYPE
+{
+    D3DSPR_TEMP         = 0x00,
+    D3DSPR_INPUT        = 0x01,
+    D3DSPR_CONST        = 0x02,
+    D3DSPR_ADDR         = 0x03,
+    D3DSPR_TEXTURE      = 0x03,
+    D3DSPR_RASTOUT      = 0x04,
+    D3DSPR_ATTROUT      = 0x05,
+    D3DSPR_TEXCRDOUT    = 0x06,
+    D3DSPR_OUTPUT       = 0x06,
+    D3DSPR_CONSTINT     = 0x07,
+    D3DSPR_COLOROUT     = 0x08,
+    D3DSPR_DEPTHOUT     = 0x09,
+    D3DSPR_SAMPLER      = 0x0a,
+    D3DSPR_CONST2       = 0x0b,
+    D3DSPR_CONST3       = 0x0c,
+    D3DSPR_CONST4       = 0x0d,
+    D3DSPR_CONSTBOOL    = 0x0e,
+    D3DSPR_LOOP         = 0x0f,
+    D3DSPR_TEMPFLOAT16  = 0x10,
+    D3DSPR_MISCTYPE     = 0x11,
+    D3DSPR_LABEL        = 0x12,
+    D3DSPR_PREDICATE    = 0x13,
+
+    D3DSPR_FORCE_DWORD  = 0x7fffffff,
+} D3DSHADER_PARAM_REGISTER_TYPE;
+
+typedef enum _D3DSHADER_PARAM_SRCMOD_TYPE
+{
+    D3DSPSM_NONE        = 0x0 << D3DSP_SRCMOD_SHIFT,
+    D3DSPSM_NEG         = 0x1 << D3DSP_SRCMOD_SHIFT,
+    D3DSPSM_BIAS        = 0x2 << D3DSP_SRCMOD_SHIFT,
+    D3DSPSM_BIASNEG     = 0x3 << D3DSP_SRCMOD_SHIFT,
+    D3DSPSM_SIGN        = 0x4 << D3DSP_SRCMOD_SHIFT,
+    D3DSPSM_SIGNNEG     = 0x5 << D3DSP_SRCMOD_SHIFT,
+    D3DSPSM_COMP        = 0x6 << D3DSP_SRCMOD_SHIFT,
+    D3DSPSM_X2          = 0x7 << D3DSP_SRCMOD_SHIFT,
+    D3DSPSM_X2NEG       = 0x8 << D3DSP_SRCMOD_SHIFT,
+    D3DSPSM_DZ          = 0x9 << D3DSP_SRCMOD_SHIFT,
+    D3DSPSM_DW          = 0xa << D3DSP_SRCMOD_SHIFT,
+    D3DSPSM_ABS         = 0xb << D3DSP_SRCMOD_SHIFT,
+    D3DSPSM_ABSNEG      = 0xc << D3DSP_SRCMOD_SHIFT,
+    D3DSPSM_NOT         = 0xd << D3DSP_SRCMOD_SHIFT,
+
+    D3DSPSM_FORCE_DWORD = 0x7fffffff,
+} D3DSHADER_PARAM_SRCMOD_TYPE;
+
+typedef enum _D3DSHADER_MISCTYPE_OFFSETS
+{
+    D3DSMO_POSITION  = 0x0,
+    D3DSMO_FACE      = 0x1,
+} D3DSHADER_MISCTYPE_OFFSETS;
+
+typedef enum _D3DVS_RASTOUT_OFFSETS
+{
+    D3DSRO_POSITION     = 0x0,
+    D3DSRO_FOG          = 0x1,
+    D3DSRO_POINT_SIZE   = 0x2,
+
+    D3DSRO_FORCE_DWORD  = 0x7fffffff,
+} D3DVS_RASTOUT_OFFSETS;
+
+#endif  /* _d3d9TYPES_H_ */
+#endif  /* __VKD3D_D3D9TYPES_H */