Release 1.2.

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

.gitignore

@@ -3,11 +3,13 @@ autom4te.cache
 config.log
 config.status
 configure
+doc
+Doxyfile
 libtool
 Makefile
 Makefile.in
 test-suite.log
-vkd3d-compiler
+/vkd3d-compiler
 
 vkd3d-*.tar.xz
 

ANNOUNCE

@@ -1,16 +1,17 @@
-The Wine team is proud to announce that release 1.0 of vkd3d, the
-Direct3D 12 to Vulkan translation library, is now available.
+The Wine team is proud to announce that release 1.2 of vkd3d, the Direct3D to
+Vulkan translation library, is now available.
 
-This is the first release of vkd3d. A lot of Direct3D 12 features are still
-missing and bugs are expected. The current version was tested mainly with demo
-applications. A number of features that are being worked on have been deferred
-to the next development cycle. This includes in particular geometry and
-tessellation shaders support, various shader translation improvements, as well
-as various improvements for core Direct3D 12 methods.
+This release contains improvements that are listed in the release notes below.
+The main highlights are:
+
+  - Availability of libvkd3d-shader as a public library.
+  - Support for tessellation shaders.
+  - Version 1.1 root signatures.
+  - Stream output support.
 
 The source is available from the following location:
 
-  https://dl.winehq.org/vkd3d/source/vkd3d-1.0.tar.xz
+  https://dl.winehq.org/vkd3d/source/vkd3d-1.2.tar.xz
 
 The current source can also be pulled directly from the git repository:
 
@@ -21,70 +22,171 @@ for the complete list.
 
 ----------------------------------------------------------------
 
-What's included in vkd3d 1.0
-============================
+What's new in vkd3d 1.2
+=======================
 
 
 *** libvkd3d
 
-- libvkd3d is the main component of the vkd3d project. It's a 3D graphics
-  library built on top of Vulkan with an API very similar to Direct3D 12.
+- Newly implemented Direct3D 12 features:
+  - Multi-sampling.
+  - Reserved resources.
+  - Instance data step rates. This requires the
+    VK_EXT_vertex_attribute_divisor extension.
+  - `Private data' APIs for all interfaces.
+  - Shader-resource view component mappings.
+  - Indirect indexed draws.
+  - Indirect draws with a count buffer. This requires the
+    VK_KHR_draw_indirect_count extension.
+  - Stream output and stream output queries. This requires the
+    VK_EXT_transform_feedback extension.
+  - Predicated/conditional rendering.
+  - Primitive restart.
+  - Depth rendering without a pixel shader.
+  - 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.
 
-- A significant number of Direct3D 12 features are implemented, including:
-  - Graphics and compute pipelines.
-  - Command lists, command allocators and command queues.
-  - Descriptors and descriptor heaps.
-  - Root signatures.
-  - Constant buffer, shader resource, unordered access, render target and depth
-    stencil views.
-  - Samplers.
-  - Static samplers.
-  - Descriptors copying.
-  - Committed resources.
-  - Fences.
-  - Queries and query heaps.
-  - Resource barriers.
-  - Root constants.
-  - Basic support for indirect draws and dispatches.
-  - Basic support for command signatures.
-  - Various Clear*() methods.
-  - Various Copy*() methods.
+- New interfaces:
+  - vkd3d_serialize_versioned_root_signature() and
+    vkd3d_create_versioned_root_signature_deserializer() provide support for
+    versioned root signatures.
+  - 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 a library which translates shader model 4 and 5 bytecode
-  to SPIR-V. In this release, libvkd3d-shader is an internal library. Its API
-  isn't set in stone yet.
+- libvkd3d-shader is now available as a public instead of an internal library.
 
-- Vertex, pixel and compute shaders are supported. Also, very simple geometry
-  shaders should be translated correctly. Issues are expected when trying to
-  translate tessellation shaders or more complex geometry shaders.
+- New features:
+  - 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.
 
-- A significant number of shader instructions are supported in this release,
-  including:
-  - Arithmetic instructions.
-  - Bit instructions.
-  - Comparison instructions.
-  - Control flow instructions.
-  - Sample, gather and load instructions.
-  - Atomic instructions.
-  - UAV instructions.
+- Support for OpenGL SPIR-V target environments. This allows SPIR-V produced
+  by libvkd3d-shader to be used with GL_ARB_gl_spirv. This includes support
+  for OpenGL atomic counters and combined samplers.
 
-- Root signature serialization and deserialization is implemented.
+- Preliminary support for shader model 5.1 shaders. This is still a work in
+  progress. Notably, support for resource arrays is not yet implemented.
 
-- Shader model 4 and 5 bytecode parser is imported from wined3d.
+- 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.
 
-- Shader model 5.1 is not supported yet.
+- 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
 
-- libvkd3d-utils contains simple implementations of various functions which
-  might be useful for source ports of Direct3D 12 applications.
+- To specify the libvkd3d API version to use when creating vkd3d instances,
+  define VKD3D_UTILS_API_VERSION to the desired version before including
+  vkd3d_utils.h. If VKD3D_UTILS_API_VERSION is not explicitly defined,
+  VKD3D_API_VERSION_1_0 will be used.
+
+- Support for versioned root signatures is provided by the
+  D3D12SerializeVersionedRootSignature() and
+  D3D12CreateVersionedRootSignatureDeserializer() entry points.
 
 
-*** demos
+*** build
+
+- The minimum required version of Vulkan-Headers and SPIRV-Headers for this
+  release is version 1.1.113.
+
+- The minimum required version of widl for this release is version 3.20.
+
+- If doxygen is available, it will be used to build API documentation. By
+  default, documentation will be generated in HTML and PDF formats.
+
+- 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.
 
-- A simple hello triangle Direct3D 12 demo.
-- A Direct3D 12 port of glxgears.

AUTHORS

@@ -1,2 +1,15 @@
+Alexandre Julliard
+Andrew Eikum
+Chip Davis
+Conor McCarthy
+Derek Lesho
+Hans-Kristian Arntzen
 Henri Verbeet
+Isabella Bosia
+Jactry Zeng
 Józef Kucia
+Philip Rebohle
+Rémi Bernon
+Sven Hesse
+Zebediah Figura
+Zhiyi Zhang

COPYING

@@ -1,4 +1,4 @@
-Copyright 2016-2018 the Vkd3d project authors (see the file AUTHORS for a
+Copyright 2016-2019 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

Doxyfile.in

@@ -0,0 +1,17 @@
+# Doxyfile 1.8.18
+
+DOXYFILE_ENCODING      = UTF-8
+PROJECT_NAME           = @PACKAGE_NAME@
+PROJECT_NUMBER         = @PACKAGE_VERSION@
+PROJECT_BRIEF          = "The vkd3d 3D Graphics Library"
+OUTPUT_DIRECTORY       = doc
+JAVADOC_AUTOBRIEF      = YES
+OPTIMIZE_OUTPUT_FOR_C  = YES
+EXTRACT_STATIC         = YES
+
+INPUT                  = @srcdir@/include/vkd3d.h \
+                         @srcdir@/include/vkd3d_shader.h \
+                         @srcdir@/include/vkd3d_types.h \
+                         @srcdir@/include/vkd3d_utils.h
+
+EXCLUDE_SYMBOLS        = VKD3D_FORCE_32_BIT_ENUM

Makefile.am

@@ -1,9 +1,11 @@
 ACLOCAL_AMFLAGS = -I m4
 AM_CFLAGS = @VKD3D_CFLAGS@
-AM_CPPFLAGS = -I$(srcdir)/include -I$(srcdir)/include/dummy -I$(srcdir)/include/private
+AM_CPPFLAGS = -I$(srcdir)/include -I$(srcdir)/include/private -I$(builddir)/include/private
+AM_LDFLAGS = -no-undefined
 
 widl_headers = \
 	include/vkd3d_d3d12.h \
+	include/vkd3d_d3d12sdklayers.h \
 	include/vkd3d_d3dcommon.h \
 	include/vkd3d_dxgi.h \
 	include/vkd3d_dxgi1_2.h \
@@ -16,9 +18,12 @@ widl_headers = \
 vkd3d_public_headers = \
 	include/vkd3d.h \
 	include/vkd3d_d3d12.h \
+	include/vkd3d_d3d12sdklayers.h \
 	include/vkd3d_d3dcommon.h \
 	include/vkd3d_dxgibase.h \
 	include/vkd3d_dxgiformat.h \
+	include/vkd3d_shader.h \
+	include/vkd3d_types.h \
 	include/vkd3d_utils.h \
 	include/vkd3d_windows.h
 
@@ -32,13 +37,17 @@ vkd3d_demos_shaders = \
 	demos/triangle_vs.h
 
 vkd3d_tests = \
-	tests/vkd3d_api
+	tests/vkd3d_api \
+	tests/vkd3d_common \
+	tests/vkd3d_shader_api
 
 vkd3d_cross_tests = \
-	tests/d3d12
+	tests/d3d12 \
+	tests/d3d12_invalid_usage
 
 vkd3d_test_headers = \
-	tests/vkd3d_d3d12_test.h
+	tests/d3d12_crosstest.h \
+	tests/d3d12_test_utils.h
 
 vkd3d_demos = \
 	demos/gears \
@@ -49,15 +58,17 @@ vkd3d_demos_headers = \
 	demos/demo_win32.h \
 	demos/demo_xcb.h
 
-BUILT_SOURCES = $(widl_headers)
+BUILT_SOURCES = $(widl_headers) \
+	include/private/vkd3d_version.h
 
-noinst_LTLIBRARIES = libvkd3d-common.la libvkd3d-shader.la
+noinst_LTLIBRARIES = libvkd3d-common.la
 libvkd3d_common_la_SOURCES = \
 	include/private/vkd3d_debug.h \
 	libs/vkd3d-common/debug.c \
-	libs/vkd3d-common/memory.c
+	libs/vkd3d-common/memory.c \
+	libs/vkd3d-common/utf8.c
 
-lib_LTLIBRARIES = libvkd3d.la libvkd3d-utils.la
+lib_LTLIBRARIES = libvkd3d-shader.la libvkd3d.la libvkd3d-utils.la
 
 libvkd3d_shader_la_SOURCES = \
 	include/private/list.h \
@@ -65,22 +76,27 @@ libvkd3d_shader_la_SOURCES = \
 	include/private/vkd3d_common.h \
 	include/private/vkd3d_debug.h \
 	include/private/vkd3d_memory.h \
-	include/private/vkd3d_shader.h \
+	include/vkd3d_shader.h \
+	libs/vkd3d-shader/checksum.c \
 	libs/vkd3d-shader/dxbc.c \
 	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 = @SPIRV_TOOLS_CFLAGS@
-libvkd3d_shader_la_LIBADD = @SPIRV_TOOLS_LIBS@
+libvkd3d_shader_la_CFLAGS = $(AM_CFLAGS) @SPIRV_TOOLS_CFLAGS@
+libvkd3d_shader_la_LDFLAGS = $(AM_LDFLAGS) -version-info 1:0:0
+libvkd3d_shader_la_LIBADD = libvkd3d-common.la @SPIRV_TOOLS_LIBS@
 if HAVE_LD_VERSION_SCRIPT
-libvkd3d_shader_la_LDFLAGS = -Wl,--version-script=$(srcdir)/libs/vkd3d-shader/vkd3d_shader.map
+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
 
 libvkd3d_la_SOURCES = \
 	include/private/vkd3d_common.h \
 	include/private/vkd3d_debug.h \
 	include/private/vkd3d_memory.h \
+	include/private/vkd3d_utf8.h \
 	include/private/vkd3d_test.h \
 	include/vkd3d_d3d12.idl \
 	include/vkd3d_d3dcommon.idl \
@@ -93,85 +109,121 @@ libvkd3d_la_SOURCES = \
 	libs/vkd3d/vkd3d.map \
 	libs/vkd3d/vkd3d_main.c \
 	libs/vkd3d/vkd3d_private.h \
+	libs/vkd3d/vkd3d_shaders.h \
 	libs/vkd3d/vulkan_procs.h
-libvkd3d_la_LDFLAGS = -version-info 1:0:0
+libvkd3d_la_LDFLAGS = $(AM_LDFLAGS) -version-info 3:0:2
 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
+EXTRA_libvkd3d_la_DEPENDENCIES = $(srcdir)/libs/vkd3d/vkd3d.map
 endif
 
 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 = -version-info 1:0:0
-libvkd3d_utils_la_LIBADD = libvkd3d-common.la libvkd3d.la
+libvkd3d_utils_la_LDFLAGS = $(AM_LDFLAGS) -version-info 2:0:1
+libvkd3d_utils_la_LIBADD = libvkd3d-common.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 = LICENSE
+EXTRA_DIST = ANNOUNCE LICENSE
 
 pkgconfigdir = $(libdir)/pkgconfig
 pkginclude_HEADERS = $(vkd3d_public_headers)
-nodist_pkgconfig_DATA = libvkd3d.pc libvkd3d-utils.pc
-CLEANFILES = libvkd3d.pc libvkd3d-utils.pc
-EXTRA_DIST += libs/vkd3d/libvkd3d.pc.in libs/vkd3d-utils/libvkd3d-utils.pc.in
+nodist_pkgconfig_DATA = 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 \
+	libs/vkd3d-utils/libvkd3d-utils.pc.in
 
-noinst_PROGRAMS = vkd3d-compiler
+bin_PROGRAMS = vkd3d-compiler
 vkd3d_compiler_SOURCES = programs/vkd3d-compiler/main.c
-vkd3d_compiler_LDADD = libvkd3d-shader.la libvkd3d-common.la
+vkd3d_compiler_LDADD = libvkd3d-shader.la
 
 LDADD = libvkd3d.la libvkd3d-utils.la
-check_PROGRAMS = $(vkd3d_tests) $(vkd3d_cross_tests)
 AM_DEFAULT_SOURCE_EXT = .c
+if BUILD_TESTS
+check_PROGRAMS = $(vkd3d_tests) $(vkd3d_cross_tests)
 TESTS = $(vkd3d_tests) $(vkd3d_cross_tests)
-tests_d3d12_LDADD = $(LDADD) @PTHREAD_LIBS@
+tests_d3d12_LDADD = $(LDADD) @PTHREAD_LIBS@ @VULKAN_LIBS@
+tests_d3d12_invalid_usage_LDADD = $(LDADD) @VULKAN_LIBS@
 tests_vkd3d_api_LDADD = libvkd3d.la @VULKAN_LIBS@
+tests_vkd3d_shader_api_LDADD = libvkd3d-shader.la
+endif
 
+if BUILD_DEMOS
 DEMOS_LDADD = $(LDADD) libvkd3d-shader.la @XCB_LIBS@ @VULKAN_LIBS@
-DEMOS_CFLAGS = @XCB_CFLAGS@
-noinst_PROGRAMS += $(vkd3d_demos)
-EXTRA_DIST += $(vkd3d_test_headers) $(vkd3d_demos_headers)
+DEMOS_CFLAGS = $(AM_CFLAGS) @XCB_CFLAGS@
+noinst_PROGRAMS = $(vkd3d_demos)
 
 demos_gears_CFLAGS = $(DEMOS_CFLAGS)
 demos_gears_LDADD = $(DEMOS_LDADD) -lm
 
 demos_triangle_CFLAGS = $(DEMOS_CFLAGS)
 demos_triangle_LDADD = $(DEMOS_LDADD)
+endif
+
+EXTRA_DIST += $(vkd3d_test_headers) $(vkd3d_demos_headers)
 
 VKD3D_V_WIDL = $(vkd3d_v_widl_@AM_V@)
 vkd3d_v_widl_ = $(vkd3d_v_widl_@AM_DEFAULT_V@)
 vkd3d_v_widl_0 = @echo "  WIDL    " $@;
 vkd3d_v_widl_1 =
 
+if HAVE_WIDL
+CLEANFILES += $(widl_headers)
+endif
 EXTRA_DIST += $(widl_headers) $(widl_headers:.h=.idl)
 $(widl_headers): %.h: %.idl
 if HAVE_WIDL
-	$(VKD3D_V_WIDL)$(WIDL) -o $@ $<
-	sed -e '/#include <\(rpc.h\|rpcndr.h\)>/d' -i $@
+	$(VKD3D_V_WIDL)$(WIDL) -h -o $@ $<
 else
-	echo "widl is required to generate $<"
+	@echo "widl is required to generate $@"
 endif
 
 EXTRA_DIST += $(vkd3d_demos_shaders)
 
-libvkd3d-utils.pc: $(srcdir)/libs/vkd3d-utils/libvkd3d-utils.pc.in
-	sed -e 's![@]prefix[@]!$(prefix)!g' \
+libvkd3d-utils.pc: $(srcdir)/libs/vkd3d-utils/libvkd3d-utils.pc.in Makefile
+	$(AM_V_GEN)$(SED) -e 's![@]prefix[@]!$(prefix)!g' \
 		-e 's![@]exec_prefix[@]!$(exec_prefix)!g' \
 		-e 's![@]includedir[@]!$(includedir)!g' \
 		-e 's![@]libdir[@]!$(libdir)!g' \
 		-e 's![@]PACKAGE_VERSION[@]!$(PACKAGE_VERSION)!g' \
 		$< > $@
 
-libvkd3d.pc: $(srcdir)/libs/vkd3d/libvkd3d.pc.in
-	sed -e 's![@]prefix[@]!$(prefix)!g' \
+libvkd3d-shader.pc: $(srcdir)/libs/vkd3d-shader/libvkd3d-shader.pc.in Makefile
+	$(AM_V_GEN)$(SED) -e 's![@]prefix[@]!$(prefix)!g' \
 		-e 's![@]exec_prefix[@]!$(exec_prefix)!g' \
 		-e 's![@]includedir[@]!$(includedir)!g' \
 		-e 's![@]libdir[@]!$(libdir)!g' \
 		-e 's![@]PACKAGE_VERSION[@]!$(PACKAGE_VERSION)!g' \
 		$< > $@
 
+libvkd3d.pc: $(srcdir)/libs/vkd3d/libvkd3d.pc.in Makefile
+	$(AM_V_GEN)$(SED) -e 's![@]prefix[@]!$(prefix)!g' \
+		-e 's![@]exec_prefix[@]!$(exec_prefix)!g' \
+		-e 's![@]includedir[@]!$(includedir)!g' \
+		-e 's![@]libdir[@]!$(libdir)!g' \
+		-e 's![@]PACKAGE_VERSION[@]!$(PACKAGE_VERSION)!g' \
+		$< > $@
+
+include/private/vkd3d_version.h: dummy-vkd3d-version
+	@$(MKDIR_P) include/private
+	version=`(GIT_DIR=$(top_srcdir)/.git git rev-parse --short HEAD 2>/dev/null || echo '') \
+		| $(SED) -e 's!\(..*\)! (git \1)!' \
+		| $(SED) -n -e '$$s!\(.*\)!#define VKD3D_VCS_ID "\1"!p'` \
+		&& (echo $$version | cmp -s - $@) \
+		|| echo $$version >$@ || ($(RM) $@ && exit 1)
+.SILENT: include/private/vkd3d_version.h
+CLEANFILES += include/private/vkd3d_version.h
+
+.PHONY: dummy-vkd3d-version
+dummy-vkd3d-version:
+
 ## Cross-compile tests
 cross_implibs = crosslibs/d3d12
 CROSS_CPPFLAGS = -I$(srcdir)/include -I$(srcdir)/include/private -I$(builddir)/include
@@ -196,7 +248,7 @@ $(CROSS32_IMPLIBS): %.cross32.a: %.cross32.def
 	$(AM_V_GEN)$(CROSS32_DLLTOOL) -k -m i386 --as-flags=-32 -d $< -l $@
 
 $(CROSS32_EXEFILES): %.cross32.exe: %.c $(CROSS32_IMPLIBS) $(widl_headers)
-	$(AM_V_CCLD)depbase=`echo $@ | sed 's![^/]*$$!$(DEPDIR)/&!;s!\.exe$$!!'`; \
+	$(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 && \
 	$(am__mv) $$depbase.Tpo $$depbase.Po
 else
@@ -230,3 +282,9 @@ endif
 
 .PHONY: crosstest crosstest32 crosstest64
 crosstest: crosstest32 crosstest64
+
+if BUILD_DOC
+@DX_RULES@
+all: doxygen-doc
+CLEANFILES += $(DX_CLEANFILES)
+endif

README

@@ -4,3 +4,73 @@ The vkd3d 3D Graphics Library
 
 Vkd3d is a 3D graphics library built on top of Vulkan. It has an API very
 similar, but not identical, to Direct3D 12.
+
+==============
+Building vkd3d
+==============
+
+Vkd3d depends on SPIRV-Headers and Vulkan-Headers (>= 1.1.113).
+
+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
+you are building from git, then they will be generated at build-time using
+widl. By default, vkd3d will use the widl found in `PATH'. If widl is not
+available or is not recent (>= 3.20), then you can build Wine with `make
+tools/widl' to avoid building all of Wine. You can then point vkd3d's
+configure at that widl binary with `WIDL="/path/to/widl"'.
+
+For release builds, you may want to define NDEBUG. If you do not need debug log
+messages, you may also consider VKD3D_NO_TRACE_MESSAGES and
+VKD3D_NO_DEBUG_MESSAGES. For example, you can pass `CPPFLAGS="-DNDEBUG
+-DVKD3D_NO_TRACE_MESSAGES"' to configure.
+
+===========
+Using vkd3d
+===========
+
+Vkd3d can be used by projects that target Direct3D 12 as a drop-in replacement
+at build-time with some modest source modifications.
+
+If vkd3d is available when building Wine, then Wine will use it to support
+Direct3D 12 applications.
+
+=====================
+Environment variables
+=====================
+
+Most of the environment variables used by vkd3d are for debugging purposes. The
+environment variables are not considered a part of API and might be changed or
+removed in the future versions of vkd3d.
+
+Some of debug variables are lists of elements. Elements must be separated by
+commas or semicolons.
+
+ * VKD3D_CONFIG - a list of options that change the behavior of libvkd3d.
+    * vk_debug - enables Vulkan debug extensions.
+
+ * VKD3D_DEBUG - controls the debug level for log messages produced by
+   libvkd3d. Accepts the following values: none, err, fixme, warn, trace.
+
+ * VKD3D_VULKAN_DEVICE - a zero-based device index. Use to force the selected
+   Vulkan device.
+
+ * VKD3D_DISABLE_EXTENSIONS - a list of Vulkan extensions that libvkd3d should
+   not use even if available.
+
+ * VKD3D_SHADER_DEBUG - controls the debug level for log messages produced by
+   libvkd3d-shader. See VKD3D_DEBUG for accepted values.
+
+ * VKD3D_SHADER_DUMP_PATH - path where shader bytecode is dumped.
+
+ * VKD3D_TEST_DEBUG - enables additional debug messages in tests. Set to 0, 1
+   or 2.
+
+ * VKD3D_TEST_FILTER - a filter string. Only the tests whose names matches the
+   filter string will be run, e.g. VKD3D_TEST_FILTER=clear_render_target.
+   Useful for debugging or developing new tests.
+
+ * VKD3D_TEST_PLATFORM - can be set to "wine", "windows" or "other". The test
+   platform controls the behavior of todo(), todo_if(), bug_if() and broken()
+   conditions in tests.
+
+ * VKD3D_TEST_BUG - set to 0 to disable bug_if() conditions in tests.

configure.ac

@@ -1,16 +1,22 @@
 AC_PREREQ([2.69])
-AC_INIT([vkd3d],[1.0])
+AC_INIT([vkd3d],[1.2])
 
 AC_CONFIG_AUX_DIR([bin])
 AC_CONFIG_MACRO_DIR([m4])
-AC_CONFIG_LIBOBJ_DIR([portable])
 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([spirv-tools], AS_HELP_STRING([--with-spirv-tools],
                                           [Build with SPIRV-Tools library (default: disabled)]))
+AC_ARG_ENABLE([demos],
+              AS_HELP_STRING([--enable-demos], [Build demo programs (default: disabled)]),,
+              [enable_demos=no])
+AC_ARG_ENABLE([tests],
+              AS_HELP_STRING([--enable-tests], [Build tests (default: enabled)]),,
+              [enable_tests=yes])
 
 AC_USE_SYSTEM_EXTENSIONS
 
@@ -20,15 +26,19 @@ AC_PROG_CC
 AM_PROG_CC_C_O
 AC_PROG_SED
 AC_PROG_MKDIR_P
-AC_CHECK_PROG([WIDL], [widl], [widl], [no])
+VKD3D_PROG_WIDL(3, 20)
 AS_IF([test "x$WIDL" = "xno"], [AC_MSG_WARN([widl is required to build header files.])])
 
+DX_PS_FEATURE([OFF])
+DX_INIT_DOXYGEN([vkd3d], [Doxyfile], [doc])
+AC_CONFIG_FILES([Doxyfile])
+
 AM_INIT_AUTOMAKE([1.11 foreign silent-rules subdir-objects no-dist-gzip dist-xz -Wall -Werror])
 AM_MAINTAINER_MODE([enable])
 AM_SILENT_RULES([yes])
 
 LT_PREREQ([2.4.2])
-LT_INIT
+LT_INIT([win32-dll])
 
 gl_LD_VERSION_SCRIPT
 
@@ -38,9 +48,11 @@ AS_IF([test "x${GCC}" = "xyes"],
       [VKD3D_CFLAGS="-Wall -pipe"
       VKD3D_CHECK_CFLAGS([-std=c99])
       VKD3D_CHECK_CFLAGS([-Wdeclaration-after-statement])
+      VKD3D_CHECK_CFLAGS([-Wimplicit-fallthrough])
       VKD3D_CHECK_CFLAGS([-Wmissing-prototypes])
       VKD3D_CHECK_CFLAGS([-Wunused-but-set-parameter])
       VKD3D_CHECK_CFLAGS([-Wvla])
+      VKD3D_CHECK_CFLAGS([-Wpointer-arith])
       VKD3D_CHECK_CFLAGS([-Wl,--no-undefined])])
 
 dnl Check for cross compilers
@@ -48,7 +60,8 @@ VKD3D_CHECK_MINGW32_PROG([CROSSCC32], [CROSSTARGET32], [no])
 VKD3D_CHECK_MINGW64_PROG([CROSSCC64], [CROSSTARGET64], [no])
 
 dnl Check for headers
-AC_CHECK_HEADERS([pthread.h vulkan/vulkan.h \
+AC_CHECK_HEADERS([dlfcn.h pthread.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.])])
@@ -60,33 +73,53 @@ 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.])])
+
+AC_CHECK_DECL([SpvCapabilityDemoteToHelperInvocationEXT],, [AC_MSG_ERROR([SPIR-V headers are too old.])], [
+#ifdef HAVE_SPIRV_UNIFIED1_SPIRV_H
+# include "spirv/unified1/spirv.h"
+#else
+# include "vulkan/spirv.h"
+#endif])
+
+AC_CHECK_DECLS([program_invocation_name],,,[#include <errno.h>])
+
 dnl Check for libraries
 m4_ifdef([PKG_PROG_PKG_CONFIG], [PKG_PROG_PKG_CONFIG], [m4_fatal([pkg-config autoconf macros not found.])])
 
 AC_CHECK_LIB([m], [ceilf])
 
-AC_ARG_VAR([DL_LIBS], [linker flags for dl])
+AC_SUBST([DL_LIBS])
 AC_CHECK_LIB([dl], [dlopen],
-             [AC_SUBST([DL_LIBS], ["-ldl"])],
-             [AC_MSG_ERROR([libdl not found.])])
+             [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])
-AC_CHECK_LIB([pthread], [pthread_create],
-             [AC_SUBST([PTHREAD_LIBS], ["-lpthread"])],
-             [AC_MSG_ERROR([libpthread not found.])])
+VKD3D_CHECK_PTHREAD
 
 AC_SUBST([VULKAN_LIBS])
-AC_CHECK_LIB([vulkan], [vkGetInstanceProcAddr],
-             [VULKAN_LIBS="-lvulkan"],
-             [AC_MSG_ERROR([libvulkan not found.])])
+VKD3D_CHECK_SONAME([vulkan], [vkGetInstanceProcAddr],
+                   [VULKAN_LIBS="-lvulkan"],
+                   [VKD3D_CHECK_SONAME([vulkan-1], [vkGetInstanceProcAddr],
+                                       [VULKAN_LIBS="-lvulkan-1"
+                                        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.])])])])
 
-HAVE_SPIRV_TOOLS=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.])
-      HAVE_SPIRV_TOOLS=yes])])
+      [AC_DEFINE([HAVE_SPIRV_TOOLS], [1], [Define to 1 if you have SPIRV-Tools.])])],
+      [with_spirv_tools=no])
 
-PKG_CHECK_MODULES([XCB], [xcb xcb-keysyms])
+HAVE_XCB=no
+AS_IF([test "x$with_xcb" != "xno"],
+      [PKG_CHECK_MODULES([XCB], [xcb xcb-keysyms],
+                                [AC_DEFINE([HAVE_XCB], [1], [Define to 1 if you have libxcb.])
+                                HAVE_XCB=yes],
+                                [HAVE_XCB=no])])
 
 dnl Check for functions
 VKD3D_CHECK_FUNC([HAVE_BUILTIN_CLZ], [__builtin_clz], [__builtin_clz(0)])
@@ -94,6 +127,14 @@ VKD3D_CHECK_FUNC([HAVE_BUILTIN_POPCOUNT], [__builtin_popcount], [__builtin_popco
 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"],
+      [AC_MSG_ERROR([libxcb is required for demos.])])
+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"])
 AM_CONDITIONAL([HAVE_WIDL], [test "x$WIDL" != "xno"])
 AM_CONDITIONAL([HAVE_CROSSTARGET32], [test "x$CROSSTARGET32" != "xno"])
 AM_CONDITIONAL([HAVE_CROSSTARGET64], [test "x$CROSSTARGET64" != "xno"])
@@ -104,11 +145,19 @@ AC_OUTPUT
 dnl Output configuration summary
 AS_IF([test "x$CROSSTARGET32" != "xno" -o "x$CROSSTARGET64" != "xno"],
       [HAVE_CROSSTEST=yes], [HAVE_CROSSTEST=no])
+AS_IF([test $DX_FLAG_doc = 1], [HAVE_DOCS=yes], [HAVE_DOCS=no])
 
 AS_ECHO(["
   Configuration summary for $PACKAGE $VERSION
 
-  Have SPIRV-Tools: ${HAVE_SPIRV_TOOLS}
+  widl: ${WIDL}
+
+  Have XCB: ${HAVE_XCB}
+  Have SPIRV-Tools: ${with_spirv_tools}
+
+  Building demos: ${enable_demos}
+  Building tests: ${enable_tests}
+  Building documentation: ${HAVE_DOCS}
 
   Building crosstests: ${HAVE_CROSSTEST}"])
 AS_IF([test "x$CROSSTARGET32" != "xno"], [AS_ECHO(["    Using 32-bit cross compiler: $CROSSCC32"])])

demos/demo.h

@@ -141,7 +141,6 @@ static inline HRESULT demo_create_root_signature(ID3D12Device *device,
 #ifdef _WIN32
 #include "demo_win32.h"
 #else
-#include <vkd3d_utils.h>
 #define INFINITE VKD3D_INFINITE
 #include "demo_xcb.h"
 #endif

demos/demo_win32.h

@@ -25,10 +25,6 @@
 
 struct demo
 {
-    HMODULE d3dcompiler;
-    HRESULT (WINAPI *compile_from_file)(const WCHAR *filename, const void *defines, void *include,
-            const char *entry_point, const char *profile, UINT flags1, UINT flags2,
-            ID3DBlob **code, ID3DBlob **errors);
     size_t window_count;
     bool quit;
 
@@ -198,11 +194,6 @@ static inline bool demo_init(struct demo *demo, void *user_data)
 {
     WNDCLASSEXW wc;
 
-    if (!(demo->d3dcompiler = LoadLibraryW(L"d3dcompiler_47")))
-        return false;
-    if (!(demo->compile_from_file = (void *)GetProcAddress(demo->d3dcompiler, "D3DCompileFromFile")))
-        goto fail;
-
     wc.cbSize = sizeof(wc);
     wc.style = CS_HREDRAW | CS_VREDRAW;
     wc.lpfnWndProc = demo_window_proc;
@@ -216,7 +207,7 @@ static inline bool demo_init(struct demo *demo, void *user_data)
     wc.lpszClassName = DEMO_WINDOW_CLASS_NAME;
     wc.hIconSm = LoadIconW(NULL, IDI_WINLOGO);
     if (!RegisterClassExW(&wc))
-        goto fail;
+        return false;
 
     demo->window_count = 0;
     demo->quit = false;
@@ -224,16 +215,11 @@ static inline bool demo_init(struct demo *demo, void *user_data)
     demo->idle_func = NULL;
 
     return true;
-
-fail:
-    FreeLibrary(demo->d3dcompiler);
-    return false;
 }
 
 static inline void demo_cleanup(struct demo *demo)
 {
     UnregisterClassW(DEMO_WINDOW_CLASS_NAME, GetModuleHandle(NULL));
-    FreeLibrary(demo->d3dcompiler);
 }
 
 static inline void demo_set_idle_func(struct demo *demo,

demos/demo_xcb.h

@@ -18,7 +18,9 @@
  */
 
 #define VK_USE_PLATFORM_XCB_KHR
+#define VKD3D_UTILS_API_VERSION VKD3D_API_VERSION_1_2
 #include <vkd3d.h>
+#include <vkd3d_utils.h>
 #include <xcb/xcb_event.h>
 #include <xcb/xcb_icccm.h>
 #include <xcb/xcb_keysyms.h>

demos/gears.c

@@ -124,12 +124,12 @@ struct cx_gears
     struct demo_swapchain *swapchain;
     ID3D12DescriptorHeap *rtv_heap, *dsv_heap;
     unsigned int rtv_descriptor_size;
-    ID3D12Resource *render_targets[2];
-    ID3D12CommandAllocator *command_allocator[2];
+    ID3D12Resource *render_targets[3];
+    ID3D12CommandAllocator *command_allocator[3];
 
     ID3D12RootSignature *root_signature;
     ID3D12PipelineState *pipeline_state_smooth, *pipeline_state_flat;
-    ID3D12GraphicsCommandList *command_list[2];
+    ID3D12GraphicsCommandList *command_list[3];
     ID3D12Resource *ds, *cb, *vb[2], *ib;
     D3D12_VERTEX_BUFFER_VIEW vbv[2];
     D3D12_INDEX_BUFFER_VIEW ibv;
@@ -218,7 +218,8 @@ static void cxg_wait_for_previous_frame(struct cx_gears *cxg)
 
     if (ID3D12Fence_GetCompletedValue(fence->fence) < v)
     {
-        ID3D12Fence_SetEventOnCompletion(fence->fence, v, fence->event);
+        hr = ID3D12Fence_SetEventOnCompletion(fence->fence, v, fence->event);
+        assert(SUCCEEDED(hr));
         demo_wait_event(fence->event, INFINITE);
     }
 
@@ -305,8 +306,10 @@ static void cxg_destroy_pipeline(struct cx_gears *cxg)
 {
     unsigned int i;
 
-    ID3D12CommandAllocator_Release(cxg->command_allocator[1]);
-    ID3D12CommandAllocator_Release(cxg->command_allocator[0]);
+    for (i = 0; i < ARRAY_SIZE(cxg->command_allocator); ++i)
+    {
+        ID3D12CommandAllocator_Release(cxg->command_allocator[i]);
+    }
     for (i = 0; i < ARRAY_SIZE(cxg->render_targets); ++i)
     {
         ID3D12Resource_Release(cxg->render_targets[i]);
@@ -370,12 +373,12 @@ static void cxg_load_pipeline(struct cx_gears *cxg)
             &IID_ID3D12DescriptorHeap, (void **)&cxg->dsv_heap);
     assert(SUCCEEDED(hr));
 
-    hr = ID3D12Device_CreateCommandAllocator(cxg->device, D3D12_COMMAND_LIST_TYPE_DIRECT,
-            &IID_ID3D12CommandAllocator, (void **)&cxg->command_allocator[0]);
-    assert(SUCCEEDED(hr));
-    hr = ID3D12Device_CreateCommandAllocator(cxg->device, D3D12_COMMAND_LIST_TYPE_DIRECT,
-            &IID_ID3D12CommandAllocator, (void **)&cxg->command_allocator[1]);
-    assert(SUCCEEDED(hr));
+    for (i = 0; i < ARRAY_SIZE(cxg->command_allocator); ++i)
+    {
+        hr = ID3D12Device_CreateCommandAllocator(cxg->device, D3D12_COMMAND_LIST_TYPE_DIRECT,
+                &IID_ID3D12CommandAllocator, (void **)&cxg->command_allocator[i]);
+        assert(SUCCEEDED(hr));
+    }
 }
 
 static void cxg_fence_destroy(struct cxg_fence *cxg_fence)
@@ -386,6 +389,8 @@ static void cxg_fence_destroy(struct cxg_fence *cxg_fence)
 
 static void cxg_destroy_assets(struct cx_gears *cxg)
 {
+    unsigned int i;
+
     cxg_fence_destroy(&cxg->fence);
     ID3D12Resource_Release(cxg->ib);
     ID3D12Resource_Unmap(cxg->vb[1], 0, NULL);
@@ -394,8 +399,8 @@ static void cxg_destroy_assets(struct cx_gears *cxg)
     ID3D12Resource_Unmap(cxg->cb, 0, NULL);
     ID3D12Resource_Release(cxg->cb);
     ID3D12Resource_Release(cxg->ds);
-    ID3D12GraphicsCommandList_Release(cxg->command_list[1]);
-    ID3D12GraphicsCommandList_Release(cxg->command_list[0]);
+    for (i = 0; i < ARRAY_SIZE(cxg->command_list); ++i)
+        ID3D12GraphicsCommandList_Release(cxg->command_list[i]);
     ID3D12PipelineState_Release(cxg->pipeline_state_smooth);
     ID3D12PipelineState_Release(cxg->pipeline_state_flat);
     ID3D12RootSignature_Release(cxg->root_signature);
@@ -658,6 +663,7 @@ static void cxg_load_assets(struct cx_gears *cxg)
     D3D12_HEAP_PROPERTIES heap_desc;
     D3D12_RANGE read_range = {0, 0};
     D3D12_CLEAR_VALUE clear_value;
+    unsigned int i;
     HRESULT hr;
 
     root_parameter.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
@@ -708,16 +714,15 @@ static void cxg_load_assets(struct cx_gears *cxg)
             &IID_ID3D12PipelineState, (void **)&cxg->pipeline_state_smooth);
     assert(SUCCEEDED(hr));
 
-    hr = ID3D12Device_CreateCommandList(cxg->device, 0, D3D12_COMMAND_LIST_TYPE_DIRECT, cxg->command_allocator[0],
-            cxg->pipeline_state_flat, &IID_ID3D12GraphicsCommandList, (void **)&cxg->command_list[0]);
-    assert(SUCCEEDED(hr));
-    hr = ID3D12GraphicsCommandList_Close(cxg->command_list[0]);
-    assert(SUCCEEDED(hr));
-    hr = ID3D12Device_CreateCommandList(cxg->device, 0, D3D12_COMMAND_LIST_TYPE_DIRECT, cxg->command_allocator[1],
-            cxg->pipeline_state_flat, &IID_ID3D12GraphicsCommandList, (void **)&cxg->command_list[1]);
-    assert(SUCCEEDED(hr));
-    hr = ID3D12GraphicsCommandList_Close(cxg->command_list[1]);
-    assert(SUCCEEDED(hr));
+    for (i = 0; i < ARRAY_SIZE(cxg->command_list); ++i)
+    {
+        hr = ID3D12Device_CreateCommandList(cxg->device, 0, D3D12_COMMAND_LIST_TYPE_DIRECT,
+                cxg->command_allocator[i], cxg->pipeline_state_flat,
+                &IID_ID3D12GraphicsCommandList, (void **)&cxg->command_list[i]);
+        assert(SUCCEEDED(hr));
+        hr = ID3D12GraphicsCommandList_Close(cxg->command_list[i]);
+        assert(SUCCEEDED(hr));
+    }
 
     heap_desc.Type = D3D12_HEAP_TYPE_DEFAULT;
     heap_desc.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
@@ -860,6 +865,7 @@ static int cxg_main(void)
     cxg_load_assets(&cxg);
     cxg_populate_command_list(&cxg, 0);
     cxg_populate_command_list(&cxg, 1);
+    cxg_populate_command_list(&cxg, 2);
 
     demo_process_events(&cxg.demo);
 

demos/triangle.c

@@ -73,7 +73,7 @@ struct cx_triangle
     struct demo_swapchain *swapchain;
     ID3D12DescriptorHeap *rtv_heap;
     unsigned int rtv_descriptor_size;
-    ID3D12Resource *render_targets[2];
+    ID3D12Resource *render_targets[3];
     ID3D12CommandAllocator *command_allocator;
 
     ID3D12RootSignature *root_signature;
@@ -142,7 +142,8 @@ static void cxt_wait_for_previous_frame(struct cx_triangle *cxt)
 
     if (ID3D12Fence_GetCompletedValue(fence->fence) < v)
     {
-        ID3D12Fence_SetEventOnCompletion(fence->fence, v, fence->event);
+        hr = ID3D12Fence_SetEventOnCompletion(fence->fence, v, fence->event);
+        assert(SUCCEEDED(hr));
         demo_wait_event(fence->event, INFINITE);
     }
 

include/.gitignore

@@ -1,7 +1,9 @@
 config.h
 config.h.in
+private/vkd3d_version.h
 stamp-h1
 vkd3d_d3d12.h
+vkd3d_d3d12sdklayers.h
 vkd3d_d3dcommon.h
 vkd3d_dxgi.h
 vkd3d_dxgi1_2.h

include/private/rbtree.h

@@ -34,15 +34,15 @@ struct rb_entry
     unsigned int flags;
 };
 
-typedef int (*rb_compare_func_t)(const void *key, const struct rb_entry *entry);
+typedef int (*rb_compare_func)(const void *key, const struct rb_entry *entry);
 
 struct rb_tree
 {
-    rb_compare_func_t compare;
+    rb_compare_func compare;
     struct rb_entry *root;
 };
 
-typedef void (rb_traverse_func_t)(struct rb_entry *entry, void *context);
+typedef void (rb_traverse_func)(struct rb_entry *entry, void *context);
 
 #define RB_FLAG_RED                0x1
 
@@ -127,55 +127,55 @@ static inline struct rb_entry *rb_postorder_next(struct rb_entry *iter)
 }
 
 /* iterate through the tree */
-#define rb_FOR_EACH(cursor, tree) \
+#define RB_FOR_EACH(cursor, tree) \
     for ((cursor) = rb_head((tree)->root); (cursor); (cursor) = rb_next(cursor))
 
 /* 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); \
+#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(rb_next(&elem->field), 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 */
-#define rb_FOR_EACH_DESTRUCTOR(cursor, cursor2, tree) \
+#define RB_FOR_EACH_DESTRUCTOR(cursor, cursor2, tree) \
     for ((cursor) = rb_postorder_head((tree)->root); \
          (cursor) && (((cursor2) = rb_postorder_next(cursor)) || 1); \
          (cursor) = (cursor2))
 
 /* 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); \
+#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 \
-             && (((elem2) = rb_ENTRY_VALUE(rb_postorder_next(&(elem)->field), type, field)) || 1); \
+             && (((elem2) = RB_ENTRY_VALUE(rb_postorder_next(&(elem)->field), type, field)) || 1); \
          (elem) = (elem2))
 
 
-static inline void rb_postorder(struct rb_tree *tree, rb_traverse_func_t *callback, void *context)
+static inline void rb_postorder(struct rb_tree *tree, rb_traverse_func *callback, void *context)
 {
     struct rb_entry *iter, *next;
-    rb_FOR_EACH_DESTRUCTOR(iter, next, tree) callback(iter, context);
+    RB_FOR_EACH_DESTRUCTOR(iter, next, tree) callback(iter, context);
 }
 
-static inline void rb_init(struct rb_tree *tree, rb_compare_func_t compare)
+static inline void rb_init(struct rb_tree *tree, rb_compare_func compare)
 {
     tree->compare = compare;
     tree->root = NULL;
 }
 
-static inline void rb_for_each_entry(struct rb_tree *tree, rb_traverse_func_t *callback, void *context)
+static inline void rb_for_each_entry(struct rb_tree *tree, rb_traverse_func *callback, void *context)
 {
     struct rb_entry *iter;
-    rb_FOR_EACH(iter, tree) callback(iter, context);
+    RB_FOR_EACH(iter, tree) callback(iter, context);
 }
 
-static inline void rb_clear(struct rb_tree *tree, rb_traverse_func_t *callback, void *context)
+static inline void rb_clear(struct rb_tree *tree, rb_traverse_func *callback, void *context)
 {
     /* Note that we use postorder here because the callback will likely free the entry. */
     if (callback) rb_postorder(tree, callback, context);
     tree->root = NULL;
 }
 
-static inline void rb_destroy(struct rb_tree *tree, rb_traverse_func_t *callback, void *context)
+static inline void rb_destroy(struct rb_tree *tree, rb_traverse_func *callback, void *context)
 {
     rb_clear(tree, callback, context);
 }

include/private/vkd3d_common.h

@@ -22,10 +22,24 @@
 #include "config.h"
 #include "vkd3d_windows.h"
 
-#define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x)))
+#include <ctype.h>
+#include <limits.h>
+#include <stdbool.h>
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#endif
+
+#ifndef ARRAY_SIZE
+# define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x)))
+#endif
 
 #define DIV_ROUND_UP(a, b) ((a) % (b) == 0 ? (a) / (b) : (a) / (b) + 1)
 
+#define STATIC_ASSERT(e) extern void __VKD3D_STATIC_ASSERT__(int [(e) ? 1 : -1])
+
+#define MEMBER_SIZE(t, m) sizeof(((t *)0)->m)
+
 static inline size_t align(size_t addr, size_t alignment)
 {
     return (addr + (alignment - 1)) & ~(alignment - 1);
@@ -41,7 +55,9 @@ static inline size_t align(size_t addr, size_t alignment)
 
 static inline unsigned int vkd3d_popcount(unsigned int v)
 {
-#ifdef HAVE_BUILTIN_POPCOUNT
+#ifdef _MSC_VER
+    return __popcnt(v);
+#elif defined(HAVE_BUILTIN_POPCOUNT)
     return __builtin_popcount(v);
 #else
     v -= (v >> 1) & 0x55555555;
@@ -50,10 +66,31 @@ static inline unsigned int vkd3d_popcount(unsigned int v)
 #endif
 }
 
+static inline bool vkd3d_bitmask_is_contiguous(unsigned int mask)
+{
+    unsigned int i, j;
+
+    for (i = 0, j = 0; i < sizeof(mask) * CHAR_BIT; ++i)
+    {
+        if (mask & (1u << i))
+            ++j;
+        else if (j)
+            break;
+    }
+
+    return vkd3d_popcount(mask) == j;
+}
+
 /* Undefined for x == 0. */
 static inline unsigned int vkd3d_log2i(unsigned int x)
 {
-#ifdef HAVE_BUILTIN_CLZ
+#ifdef _MSC_VER
+    /* _BitScanReverse returns the index of the highest set bit,
+     * unlike clz which is 31 - index. */
+    unsigned long result;
+    _BitScanReverse(&result, x);
+    return (unsigned int)result;
+#elif defined(HAVE_BUILTIN_CLZ)
     return __builtin_clz(x) ^ 0x1f;
 #else
     static const unsigned int l[] =
@@ -82,6 +119,29 @@ static inline unsigned int vkd3d_log2i(unsigned int x)
 #endif
 }
 
+static inline int ascii_isupper(int c)
+{
+    return 'A' <= c && c <= 'Z';
+}
+
+static inline int ascii_tolower(int c)
+{
+    return ascii_isupper(c) ? c - 'A' + 'a' : c;
+}
+
+static inline int ascii_strcasecmp(const char *a, const char *b)
+{
+    int c_a, c_b;
+
+    do
+    {
+        c_a = ascii_tolower(*a++);
+        c_b = ascii_tolower(*b++);
+    } while (c_a == c_b && c_a != '\0');
+
+    return c_a - c_b;
+}
+
 #ifndef _WIN32
 # if HAVE_SYNC_ADD_AND_FETCH
 static inline LONG InterlockedIncrement(LONG volatile *x)
@@ -89,7 +149,7 @@ static inline LONG InterlockedIncrement(LONG volatile *x)
     return __sync_add_and_fetch(x, 1);
 }
 # else
-#  error "InterlockedIncrement not implemented for this platform"
+#  error "InterlockedIncrement() not implemented for this platform"
 # endif  /* HAVE_SYNC_ADD_AND_FETCH */
 
 # if HAVE_SYNC_SUB_AND_FETCH
@@ -98,8 +158,29 @@ static inline LONG InterlockedDecrement(LONG volatile *x)
     return __sync_sub_and_fetch(x, 1);
 }
 # else
-#  error "InterlockedDecrement not implemented for this platform"
+#  error "InterlockedDecrement() not implemented for this platform"
 # 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);
+
+    while (isdigit(*version))
+        ++version;
+    if (*version == '.')
+        ++version;
+
+    *minor = atoi(version);
+}
+
 #endif  /* __VKD3D_COMMON_H */

include/private/vkd3d_debug.h

@@ -22,6 +22,18 @@
 #include "vkd3d_common.h"
 
 #include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef VKD3D_NO_TRACE_MESSAGES
+#define TRACE(args...) do { } while (0)
+#define TRACE_ON() (false)
+#endif
+
+#ifdef VKD3D_NO_DEBUG_MESSAGES
+#define WARN(args...) do { } while (0)
+#define FIXME(args...) do { } while (0)
+#endif
 
 enum vkd3d_dbg_level
 {
@@ -47,15 +59,38 @@ const char *debugstr_w(const WCHAR *wstr, size_t wchar_size) DECLSPEC_HIDDEN;
         const enum vkd3d_dbg_level vkd3d_dbg_level = VKD3D_DBG_LEVEL_##level; \
         VKD3D_DBG_PRINTF
 
-#define VKD3D_DBG_PRINTF(args...) \
-        vkd3d_dbg_printf(vkd3d_dbg_level, __FUNCTION__, args); } while (0)
+#define VKD3D_DBG_LOG_ONCE(first_time_level, level) \
+        do { \
+        static bool vkd3d_dbg_next_time; \
+        const enum vkd3d_dbg_level vkd3d_dbg_level = vkd3d_dbg_next_time \
+        ? VKD3D_DBG_LEVEL_##level : VKD3D_DBG_LEVEL_##first_time_level; \
+        vkd3d_dbg_next_time = true; \
+        VKD3D_DBG_PRINTF
 
+#define VKD3D_DBG_PRINTF(...) \
+        vkd3d_dbg_printf(vkd3d_dbg_level, __FUNCTION__, __VA_ARGS__); } while (0)
+
+#ifndef TRACE
 #define TRACE VKD3D_DBG_LOG(TRACE)
+#endif
+
+#ifndef WARN
 #define WARN  VKD3D_DBG_LOG(WARN)
+#endif
+
+#ifndef FIXME
 #define FIXME VKD3D_DBG_LOG(FIXME)
+#endif
+
 #define ERR   VKD3D_DBG_LOG(ERR)
 
+#ifndef TRACE_ON
 #define TRACE_ON() (vkd3d_dbg_get_level() == VKD3D_DBG_LEVEL_TRACE)
+#endif
+
+#define FIXME_ONCE VKD3D_DBG_LOG_ONCE(FIXME, WARN)
+
+#define VKD3D_DEBUG_ENV_NAME(name) const char *vkd3d_dbg_env_name = name
 
 static inline const char *debugstr_guid(const GUID *guid)
 {
@@ -68,4 +103,16 @@ 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;
+
+struct vkd3d_debug_option
+{
+    const char *name;
+    uint64_t flag;
+};
+
+bool vkd3d_debug_list_has_member(const char *string, const char *member) DECLSPEC_HIDDEN;
+uint64_t vkd3d_parse_debug_options(const char *string,
+        const struct vkd3d_debug_option *options, unsigned int option_count) DECLSPEC_HIDDEN;
+
 #endif  /* __VKD3D_DEBUG_H */

include/private/vkd3d_memory.h

@@ -21,6 +21,7 @@
 
 #include <assert.h>
 #include <stdbool.h>
+#include <stdlib.h>
 
 #include "vkd3d_debug.h"
 

include/private/vkd3d_shader.h

@@ -1,397 +0,0 @@
-/*
- * 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_SHADER_H
-#define __VKD3D_SHADER_H
-
-#include <stdbool.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif  /* __cplusplus */
-
-#define VKD3D_FORCE_32_BIT_ENUM(name) name##_FORCE_32BIT = 0x7fffffff
-
-enum vkd3d_result
-{
-    VKD3D_OK = 0,
-    VKD3D_ERROR = -1, /* unspecified failure */
-    VKD3D_ERROR_OUT_OF_MEMORY = -2,
-    VKD3D_ERROR_INVALID_ARGUMENT = -3,
-    VKD3D_ERROR_NOT_IMPLEMENTED = -4,
-
-    VKD3D_FORCE_32_BIT_ENUM(VKD3D_RESULT),
-};
-
-enum vkd3d_shader_compiler_option
-{
-    VKD3D_SHADER_STRIP_DEBUG = 0x00000001,
-
-    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPILER_OPTION),
-};
-
-enum vkd3d_shader_visibility
-{
-    VKD3D_SHADER_VISIBILITY_ALL = 0,
-    VKD3D_SHADER_VISIBILITY_VERTEX = 1,
-    VKD3D_SHADER_VISIBILITY_HULL = 2,
-    VKD3D_SHADER_VISIBILITY_DOMAIN = 3,
-    VKD3D_SHADER_VISIBILITY_GEOMETRY = 4,
-    VKD3D_SHADER_VISIBILITY_PIXEL = 5,
-
-    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_VISIBILITY),
-};
-
-struct vkd3d_shader_code
-{
-    const void *code;
-    size_t size;
-};
-
-enum vkd3d_shader_descriptor_type
-{
-    VKD3D_SHADER_DESCRIPTOR_TYPE_UNKNOWN,
-    VKD3D_SHADER_DESCRIPTOR_TYPE_CBV,     /* cb# */
-    VKD3D_SHADER_DESCRIPTOR_TYPE_SRV,     /* t#  */
-    VKD3D_SHADER_DESCRIPTOR_TYPE_UAV,     /* u#  */
-    VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER, /* s#  */
-
-    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_DESCRIPTOR_TYPE),
-};
-
-struct vkd3d_shader_descriptor_binding
-{
-    uint32_t set;
-    uint32_t binding;
-};
-
-struct vkd3d_shader_resource_binding
-{
-    enum vkd3d_shader_descriptor_type type;
-    unsigned int register_index;
-    enum vkd3d_shader_visibility shader_visibility;
-    bool is_buffer;
-
-    struct vkd3d_shader_descriptor_binding binding;
-};
-
-struct vkd3d_shader_uav_counter_binding
-{
-    unsigned int register_index; /* u# */
-
-    struct vkd3d_shader_descriptor_binding binding;
-};
-
-struct vkd3d_shader_push_constant_buffer
-{
-    unsigned int register_index;
-    enum vkd3d_shader_visibility shader_visibility;
-
-    unsigned int offset; /* in bytes */
-    unsigned int size;   /* in bytes */
-};
-
-struct vkd3d_shader_interface
-{
-    const struct vkd3d_shader_resource_binding *bindings;
-    unsigned int binding_count;
-
-    const struct vkd3d_shader_push_constant_buffer *push_constant_buffers;
-    unsigned int push_constant_buffer_count;
-
-    /* A sampler used by OpImageFetches generated for SM4 ld instructions.
-     *
-     * In Vulkan OpImageFetch must be used with a sampled image.
-     */
-    struct vkd3d_shader_descriptor_binding default_sampler;
-
-    const struct vkd3d_shader_uav_counter_binding *uav_counters;
-    unsigned int uav_counter_count;
-};
-
-int vkd3d_shader_compile_dxbc(const struct vkd3d_shader_code *dxbc,
-        struct vkd3d_shader_code *spirv, uint32_t compiler_options,
-        const struct vkd3d_shader_interface *shader_interface);
-void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *code);
-
-enum vkd3d_filter
-{
-    VKD3D_FILTER_MIN_MAG_MIP_POINT = 0x0,
-    VKD3D_FILTER_MIN_MAG_POINT_MIP_LINEAR = 0x1,
-    VKD3D_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x4,
-    VKD3D_FILTER_MIN_POINT_MAG_MIP_LINEAR = 0x5,
-    VKD3D_FILTER_MIN_LINEAR_MAG_MIP_POINT = 0x10,
-    VKD3D_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x11,
-    VKD3D_FILTER_MIN_MAG_LINEAR_MIP_POINT = 0x14,
-    VKD3D_FILTER_MIN_MAG_MIP_LINEAR = 0x15,
-    VKD3D_FILTER_ANISOTROPIC = 0x55,
-    VKD3D_FILTER_COMPARISON_MIN_MAG_MIP_POINT = 0x80,
-    VKD3D_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR = 0x81,
-    VKD3D_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x84,
-    VKD3D_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR = 0x85,
-    VKD3D_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT = 0x90,
-    VKD3D_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x91,
-    VKD3D_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT = 0x94,
-    VKD3D_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR = 0x95,
-    VKD3D_FILTER_COMPARISON_ANISOTROPIC = 0xd5,
-    VKD3D_FILTER_MINIMUM_MIN_MAG_MIP_POINT = 0x100,
-    VKD3D_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR = 0x101,
-    VKD3D_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x104,
-    VKD3D_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR = 0x105,
-    VKD3D_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT = 0x110,
-    VKD3D_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x111,
-    VKD3D_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT = 0x114,
-    VKD3D_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR = 0x115,
-    VKD3D_FILTER_MINIMUM_ANISOTROPIC = 0x155,
-    VKD3D_FILTER_MAXIMUM_MIN_MAG_MIP_POINT = 0x180,
-    VKD3D_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR = 0x181,
-    VKD3D_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x184,
-    VKD3D_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR = 0x185,
-    VKD3D_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT = 0x190,
-    VKD3D_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x191,
-    VKD3D_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT = 0x194,
-    VKD3D_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR = 0x195,
-    VKD3D_FILTER_MAXIMUM_ANISOTROPIC = 0x1d5,
-
-    VKD3D_FORCE_32_BIT_ENUM(VKD3D_FILTER),
-};
-
-enum vkd3d_texture_address_mode
-{
-    VKD3D_TEXTURE_ADDRESS_MODE_WRAP = 1,
-    VKD3D_TEXTURE_ADDRESS_MODE_MIRROR = 2,
-    VKD3D_TEXTURE_ADDRESS_MODE_CLAMP = 3,
-    VKD3D_TEXTURE_ADDRESS_MODE_BORDER = 4,
-    VKD3D_TEXTURE_ADDRESS_MODE_MIRROR_ONCE = 5,
-
-    VKD3D_FORCE_32_BIT_ENUM(VKD3D_TEXTURE_ADDRESS_MODE),
-};
-
-enum vkd3d_comparison_func
-{
-    VKD3D_COMPARISON_FUNC_NEVER = 1,
-    VKD3D_COMPARISON_FUNC_LESS = 2,
-    VKD3D_COMPARISON_FUNC_EQUAL = 3,
-    VKD3D_COMPARISON_FUNC_LESS_EQUAL = 4,
-    VKD3D_COMPARISON_FUNC_GREATER = 5,
-    VKD3D_COMPARISON_FUNC_NOT_EQUAL = 6,
-    VKD3D_COMPARISON_FUNC_GREATER_EQUAL = 7,
-    VKD3D_COMPARISON_FUNC_ALWAYS = 8,
-
-    VKD3D_FORCE_32_BIT_ENUM(VKD3D_COMPARISON_FUNC),
-};
-
-enum vkd3d_static_border_color
-{
-    VKD3D_STATIC_BORDER_COLOR_TRANSPARENT_BLACK = 0,
-    VKD3D_STATIC_BORDER_COLOR_OPAQUE_BLACK = 1,
-    VKD3D_STATIC_BORDER_COLOR_OPAQUE_WHITE = 2,
-
-    VKD3D_FORCE_32_BIT_ENUM(VKD3D_STATIC_BORDER_COLOR),
-};
-
-struct vkd3d_static_sampler_desc
-{
-    enum vkd3d_filter filter;
-    enum vkd3d_texture_address_mode address_u;
-    enum vkd3d_texture_address_mode address_v;
-    enum vkd3d_texture_address_mode address_w;
-    float mip_lod_bias;
-    unsigned int max_anisotropy;
-    enum vkd3d_comparison_func comparison_func;
-    enum vkd3d_static_border_color border_color;
-    float min_lod;
-    float max_lod;
-    unsigned int shader_register;
-    unsigned int register_space;
-    enum vkd3d_shader_visibility shader_visibility;
-};
-
-enum vkd3d_descriptor_range_type
-{
-    VKD3D_DESCRIPTOR_RANGE_TYPE_SRV = 0,
-    VKD3D_DESCRIPTOR_RANGE_TYPE_UAV = 1,
-    VKD3D_DESCRIPTOR_RANGE_TYPE_CBV = 2,
-    VKD3D_DESCRIPTOR_RANGE_TYPE_SAMPLER = 3,
-
-    VKD3D_FORCE_32_BIT_ENUM(VKD3D_DESCRIPTOR_RANGE_TYPE),
-};
-
-struct vkd3d_descriptor_range
-{
-    enum vkd3d_descriptor_range_type range_type;
-    unsigned int descriptor_count;
-    unsigned int base_shader_register;
-    unsigned int register_space;
-    unsigned int descriptor_table_offset;
-};
-
-struct vkd3d_root_descriptor_table
-{
-    unsigned int descriptor_range_count;
-    const struct vkd3d_descriptor_range *descriptor_ranges;
-};
-
-struct vkd3d_root_constants
-{
-    unsigned int shader_register;
-    unsigned int register_space;
-    unsigned int value_count;
-};
-
-struct vkd3d_root_descriptor
-{
-    unsigned int shader_register;
-    unsigned int register_space;
-};
-
-enum vkd3d_root_parameter_type
-{
-    VKD3D_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE = 0,
-    VKD3D_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS = 1,
-    VKD3D_ROOT_PARAMETER_TYPE_CBV = 2,
-    VKD3D_ROOT_PARAMETER_TYPE_SRV = 3,
-    VKD3D_ROOT_PARAMETER_TYPE_UAV = 4,
-
-    VKD3D_FORCE_32_BIT_ENUM(VKD3D_ROOT_PARAMETER_TYPE),
-};
-
-struct vkd3d_root_parameter
-{
-    enum vkd3d_root_parameter_type parameter_type;
-    union
-    {
-        struct vkd3d_root_descriptor_table descriptor_table;
-        struct vkd3d_root_constants constants;
-        struct vkd3d_root_descriptor descriptor;
-    } u;
-    enum vkd3d_shader_visibility shader_visibility;
-};
-
-enum vkd3d_root_signature_flags
-{
-    VKD3D_ROOT_SIGNATURE_FLAG_NONE = 0x0,
-    VKD3D_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT = 0x1,
-    VKD3D_ROOT_SIGNATURE_FLAG_DENY_VERTEX_SHADER_ROOT_ACCESS = 0x2,
-    VKD3D_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS = 0x4,
-    VKD3D_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS = 0x8,
-    VKD3D_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS = 0x10,
-    VKD3D_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS = 0x20,
-    VKD3D_ROOT_SIGNATURE_FLAG_ALLOW_STREAM_OUTPUT = 0x40,
-
-    VKD3D_FORCE_32_BIT_ENUM(VKD3D_ROOT_SIGNATURE_FLAGS),
-};
-
-struct vkd3d_root_signature_desc
-{
-    unsigned int parameter_count;
-    const struct vkd3d_root_parameter *parameters;
-    unsigned int static_sampler_count;
-    const struct vkd3d_static_sampler_desc *static_samplers;
-    enum vkd3d_root_signature_flags flags;
-};
-
-int vkd3d_shader_parse_root_signature(const struct vkd3d_shader_code *dxbc,
-        struct vkd3d_root_signature_desc *root_signature);
-void vkd3d_shader_free_root_signature(struct vkd3d_root_signature_desc *root_signature);
-
-enum vkd3d_root_signature_version
-{
-    VKD3D_ROOT_SIGNATURE_VERSION_1_0 = 0x1,
-
-    VKD3D_FORCE_32_BIT_ENUM(VKD3D_ROOT_SIGNATURE_VERSION),
-};
-
-int vkd3d_shader_serialize_root_signature(const struct vkd3d_root_signature_desc *root_signature,
-        enum vkd3d_root_signature_version version, struct vkd3d_shader_code *dxbc);
-
-#define VKD3D_SHADER_MAX_UNORDERED_ACCESS_VIEWS 8
-
-struct vkd3d_shader_scan_info
-{
-    unsigned int uav_read_mask : VKD3D_SHADER_MAX_UNORDERED_ACCESS_VIEWS;
-    unsigned int uav_counter_mask : VKD3D_SHADER_MAX_UNORDERED_ACCESS_VIEWS;
-};
-
-int vkd3d_shader_scan_dxbc(const struct vkd3d_shader_code *dxbc,
-        struct vkd3d_shader_scan_info *scan_info);
-
-enum vkd3d_component_type
-{
-    VKD3D_TYPE_VOID    = 0,
-    VKD3D_TYPE_UINT    = 1,
-    VKD3D_TYPE_INT     = 2,
-    VKD3D_TYPE_FLOAT   = 3,
-    VKD3D_TYPE_BOOL,
-    VKD3D_TYPE_COUNT,
-
-    VKD3D_FORCE_32_BIT_ENUM(VKD3D_COMPONENT_TYPE),
-};
-
-enum vkd3d_sysval_semantic
-{
-    VKD3D_SV_POSITION                  = 1,
-    VKD3D_SV_CLIP_DISTANCE             = 2,
-    VKD3D_SV_CULL_DISTANCE             = 3,
-    VKD3D_SV_RENDER_TARGET_ARRAY_INDEX = 4,
-    VKD3D_SV_VIEWPORT_ARRAY_INDEX      = 5,
-    VKD3D_SV_VERTEX_ID                 = 6,
-    VKD3D_SV_PRIMITIVE_ID              = 7,
-    VKD3D_SV_INSTANCE_ID               = 8,
-    VKD3D_SV_IS_FRONT_FACE             = 9,
-    VKD3D_SV_SAMPLE_INDEX              = 10,
-    VKD3D_SV_TESS_FACTOR_QUADEDGE      = 11,
-    VKD3D_SV_TESS_FACTOR_QUADINT       = 12,
-    VKD3D_SV_TESS_FACTOR_TRIEDGE       = 13,
-    VKD3D_SV_TESS_FACTOR_TRIINT        = 14,
-    VKD3D_SV_TESS_FACTOR_LINEDET       = 15,
-    VKD3D_SV_TESS_FACTOR_LINEDEN       = 16,
-
-    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SYSVAL_SEMANTIC),
-};
-
-struct vkd3d_shader_signature_element
-{
-    const char *semantic_name;
-    unsigned int semantic_index;
-    unsigned int stream_index;
-    enum vkd3d_sysval_semantic sysval_semantic;
-    enum vkd3d_component_type component_type;
-    unsigned int register_index;
-    unsigned int mask;
-};
-
-struct vkd3d_shader_signature
-{
-    struct vkd3d_shader_signature_element *elements;
-    unsigned int element_count;
-};
-
-int vkd3d_shader_parse_input_signature(const struct vkd3d_shader_code *dxbc,
-        struct vkd3d_shader_signature *signature);
-struct vkd3d_shader_signature_element *vkd3d_shader_find_signature_element(
-        const struct vkd3d_shader_signature *signature, const char *semantic_name,
-        unsigned int semantic_index, unsigned int stream_index);
-void vkd3d_shader_free_shader_signature(struct vkd3d_shader_signature *signature);
-
-#ifdef __cplusplus
-}
-#endif  /* __cplusplus */
-
-#endif  /* __VKD3D_SHADER_H */

include/private/vkd3d_test.h

@@ -32,46 +32,73 @@ static void vkd3d_test_main(int argc, char **argv);
 static const char *vkd3d_test_name;
 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; \
         static void vkd3d_test_main(int argc, char **argv)
 
+/*
+ * Use assert_that() for conditions that should always be true.
+ * todo_if() and bug_if() do not influence assert_that().
+ */
+#define assert_that assert_that_(__LINE__)
+
 #define ok ok_(__LINE__)
-#define todo todo_(__LINE__)
+
 #define skip skip_(__LINE__)
+
 #define trace trace_(__LINE__)
 
+#define assert_that_(line) \
+        do { \
+        unsigned int vkd3d_line = line; \
+        VKD3D_TEST_ASSERT_THAT
+
+#define VKD3D_TEST_ASSERT_THAT(...) \
+        vkd3d_test_assert_that(vkd3d_line, __VA_ARGS__); } while (0)
+
 #define ok_(line) \
         do { \
         unsigned int vkd3d_line = line; \
         VKD3D_TEST_OK
 
-#define VKD3D_TEST_OK(args...) \
-        vkd3d_test_ok(vkd3d_line, args); } while (0)
+#define VKD3D_TEST_OK(...) \
+        vkd3d_test_ok(vkd3d_line, __VA_ARGS__); } while (0)
 
 #define todo_(line) \
         do { \
         unsigned int vkd3d_line = line; \
         VKD3D_TEST_TODO
 
-# define VKD3D_TEST_TODO(args...) \
-        vkd3d_test_todo(vkd3d_line, args); } while (0)
+#define VKD3D_TEST_TODO(...) \
+        vkd3d_test_todo(vkd3d_line, __VA_ARGS__); } while (0)
 
 #define skip_(line) \
         do { \
         unsigned int vkd3d_line = line; \
         VKD3D_TEST_SKIP
 
-#define VKD3D_TEST_SKIP(args...) \
-        vkd3d_test_skip(vkd3d_line, args); } while (0)
+#define VKD3D_TEST_SKIP(...) \
+        vkd3d_test_skip(vkd3d_line, __VA_ARGS__); } while (0)
 
 #define trace_(line) \
         do { \
         unsigned int vkd3d_line = line; \
         VKD3D_TEST_TRACE
 
-#define VKD3D_TEST_TRACE(args...) \
-        vkd3d_test_trace(vkd3d_line, args); } while (0)
+#define VKD3D_TEST_TRACE(...) \
+        vkd3d_test_trace(vkd3d_line, __VA_ARGS__); } while (0)
+
+#define todo_if(is_todo) \
+    for (vkd3d_test_start_todo(is_todo); vkd3d_test_loop_todo(); vkd3d_test_end_todo())
+
+#define bug_if(is_bug) \
+    for (vkd3d_test_start_bug(is_bug); vkd3d_test_loop_bug(); vkd3d_test_end_bug())
+
+#define todo todo_if(true)
 
 static struct
 {
@@ -80,8 +107,19 @@ static struct
     LONG skip_count;
     LONG todo_count;
     LONG todo_success_count;
+    LONG bug_count;
 
     unsigned int debug_level;
+
+    unsigned int todo_level;
+    bool todo_do_loop;
+
+    unsigned int bug_level;
+    bool bug_do_loop;
+    bool bug_enabled;
+
+    const char *test_name_filter;
+    char context[1024];
 } vkd3d_test_state;
 
 static bool
@@ -90,20 +128,73 @@ vkd3d_test_platform_is_windows(void)
     return !strcmp(vkd3d_test_platform, "windows");
 }
 
+static inline bool
+broken(bool condition)
+{
+    return condition && vkd3d_test_platform_is_windows();
+}
+
 static void
-vkd3d_test_check_ok(unsigned int line, bool result, const char *fmt, va_list args)
+vkd3d_test_check_assert_that(unsigned int line, bool result, const char *fmt, va_list args)
 {
     if (result)
     {
-        if (vkd3d_test_state.debug_level > 1)
-            printf("%s:%d: Test succeeded.\n", vkd3d_test_name, line);
         InterlockedIncrement(&vkd3d_test_state.success_count);
+        if (vkd3d_test_state.debug_level > 1)
+            printf("%s:%d%s: Test succeeded.\n", vkd3d_test_name, line, vkd3d_test_state.context);
     }
     else
     {
-        printf("%s:%d: Test failed: ", vkd3d_test_name, line);
-        vprintf(fmt, args);
         InterlockedIncrement(&vkd3d_test_state.failure_count);
+        printf("%s:%d%s: Test failed: ", vkd3d_test_name, line, vkd3d_test_state.context);
+        vprintf(fmt, args);
+    }
+}
+
+static void VKD3D_PRINTF_FUNC(3, 4) VKD3D_UNUSED
+vkd3d_test_assert_that(unsigned int line, bool result, const char *fmt, ...)
+{
+    va_list args;
+
+    va_start(args, fmt);
+    vkd3d_test_check_assert_that(line, result, fmt, args);
+    va_end(args);
+}
+
+static void
+vkd3d_test_check_ok(unsigned int line, bool result, const char *fmt, va_list args)
+{
+    bool is_todo = vkd3d_test_state.todo_level && !vkd3d_test_platform_is_windows();
+    bool is_bug = vkd3d_test_state.bug_level && !vkd3d_test_platform_is_windows();
+
+    if (is_bug && vkd3d_test_state.bug_enabled)
+    {
+        InterlockedIncrement(&vkd3d_test_state.bug_count);
+        if (is_todo)
+            result = !result;
+        if (result)
+            printf("%s:%d%s: Fixed bug: ", vkd3d_test_name, line, vkd3d_test_state.context);
+        else
+            printf("%s:%d%s: Bug: ", vkd3d_test_name, line, vkd3d_test_state.context);
+        vprintf(fmt, args);
+    }
+    else if (is_todo)
+    {
+        if (result)
+        {
+            InterlockedIncrement(&vkd3d_test_state.todo_success_count);
+            printf("%s:%d%s: Todo succeeded: ", vkd3d_test_name, line, vkd3d_test_state.context);
+        }
+        else
+        {
+            InterlockedIncrement(&vkd3d_test_state.todo_count);
+            printf("%s:%d%s: Todo: ", vkd3d_test_name, line, vkd3d_test_state.context);
+        }
+        vprintf(fmt, args);
+    }
+    else
+    {
+        vkd3d_test_check_assert_that(line, result, fmt, args);
     }
 }
 
@@ -117,37 +208,12 @@ vkd3d_test_ok(unsigned int line, bool result, const char *fmt, ...)
     va_end(args);
 }
 
-static void VKD3D_PRINTF_FUNC(3, 4) VKD3D_UNUSED
-vkd3d_test_todo(unsigned int line, bool result, const char *fmt, ...)
-{
-    va_list args;
-
-    va_start(args, fmt);
-    if (vkd3d_test_platform_is_windows())
-    {
-        vkd3d_test_check_ok(line, result, fmt, args);
-    }
-    else if (result)
-    {
-        printf("%s:%d Todo succeeded: ", vkd3d_test_name, line);
-        vprintf(fmt, args);
-        InterlockedIncrement(&vkd3d_test_state.todo_success_count);
-    }
-    else
-    {
-        printf("%s:%d: Todo: ", vkd3d_test_name, line);
-        vprintf(fmt, args);
-        InterlockedIncrement(&vkd3d_test_state.todo_count);
-    }
-    va_end(args);
-}
-
 static void VKD3D_PRINTF_FUNC(2, 3) VKD3D_UNUSED
 vkd3d_test_skip(unsigned int line, const char *fmt, ...)
 {
     va_list args;
     va_start(args, fmt);
-    printf("%s:%d: Test skipped: ", vkd3d_test_name, line);
+    printf("%s:%d%s: Test skipped: ", vkd3d_test_name, line, vkd3d_test_state.context);
     vprintf(fmt, args);
     va_end(args);
     InterlockedIncrement(&vkd3d_test_state.skip_count);
@@ -158,7 +224,7 @@ vkd3d_test_trace(unsigned int line, const char *fmt, ...)
 {
     va_list args;
     va_start(args, fmt);
-    printf("%s:%d: ", vkd3d_test_name, line);
+    printf("%s:%d%s: ", vkd3d_test_name, line, vkd3d_test_state.context);
     vprintf(fmt, args);
     va_end(args);
 }
@@ -189,11 +255,15 @@ vkd3d_test_debug(const char *fmt, ...)
 
 int main(int argc, char **argv)
 {
+    const char *test_filter = getenv("VKD3D_TEST_FILTER");
     const char *debug_level = getenv("VKD3D_TEST_DEBUG");
     char *test_platform = getenv("VKD3D_TEST_PLATFORM");
+    const char *bug = getenv("VKD3D_TEST_BUG");
 
     memset(&vkd3d_test_state, 0, sizeof(vkd3d_test_state));
-    vkd3d_test_state.debug_level = !debug_level ? 0 : atoi(debug_level);
+    vkd3d_test_state.debug_level = debug_level ? atoi(debug_level) : 0;
+    vkd3d_test_state.bug_enabled = bug ? atoi(bug) : true;
+    vkd3d_test_state.test_name_filter = test_filter;
 
     if (test_platform)
     {
@@ -206,7 +276,7 @@ int main(int argc, char **argv)
 
     vkd3d_test_main(argc, argv);
 
-    printf("%s: %lu tests executed (%lu failures, %lu skipped, %lu todo).\n",
+    printf("%s: %lu tests executed (%lu failures, %lu skipped, %lu todo, %lu bugs).\n",
             vkd3d_test_name,
             (unsigned long)(vkd3d_test_state.success_count
             + vkd3d_test_state.failure_count + vkd3d_test_state.todo_count
@@ -214,7 +284,8 @@ int main(int argc, char **argv)
             (unsigned long)(vkd3d_test_state.failure_count
             + vkd3d_test_state.todo_success_count),
             (unsigned long)vkd3d_test_state.skip_count,
-            (unsigned long)vkd3d_test_state.todo_count);
+            (unsigned long)vkd3d_test_state.todo_count,
+            (unsigned long)vkd3d_test_state.bug_count);
 
     if (test_platform)
         free(test_platform);
@@ -273,10 +344,66 @@ typedef void (*vkd3d_test_pfn)(void);
 
 static inline void vkd3d_run_test(const char *name, vkd3d_test_pfn test_pfn)
 {
+    if (vkd3d_test_state.test_name_filter && !strstr(name, vkd3d_test_state.test_name_filter))
+        return;
+
     vkd3d_test_debug("%s", name);
     test_pfn();
 }
 
+static inline void vkd3d_test_start_todo(bool is_todo)
+{
+    vkd3d_test_state.todo_level = (vkd3d_test_state.todo_level << 1) | is_todo;
+    vkd3d_test_state.todo_do_loop = true;
+}
+
+static inline int vkd3d_test_loop_todo(void)
+{
+    bool do_loop = vkd3d_test_state.todo_do_loop;
+    vkd3d_test_state.todo_do_loop = false;
+    return do_loop;
+}
+
+static inline void vkd3d_test_end_todo(void)
+{
+    vkd3d_test_state.todo_level >>= 1;
+}
+
+static inline void vkd3d_test_start_bug(bool is_bug)
+{
+    vkd3d_test_state.bug_level = (vkd3d_test_state.bug_level << 1) | is_bug;
+    vkd3d_test_state.bug_do_loop = true;
+}
+
+static inline int vkd3d_test_loop_bug(void)
+{
+    bool do_loop = vkd3d_test_state.bug_do_loop;
+    vkd3d_test_state.bug_do_loop = false;
+    return do_loop;
+}
+
+static inline void vkd3d_test_end_bug(void)
+{
+    vkd3d_test_state.bug_level >>= 1;
+}
+
+static inline void vkd3d_test_set_context(const char *fmt, ...)
+{
+    va_list args;
+
+    if (!fmt)
+    {
+        vkd3d_test_state.context[0] = '\0';
+        return;
+    }
+
+    vkd3d_test_state.context[0] = ':';
+    va_start(args, fmt);
+    vsnprintf(&vkd3d_test_state.context[1], sizeof(vkd3d_test_state.context) - 1, fmt, args);
+    va_end(args);
+    vkd3d_test_state.context[sizeof(vkd3d_test_state.context) - 1] = '\0';
+}
+
 #define run_test(test_pfn) \
         vkd3d_run_test(#test_pfn, test_pfn)