Release 1.9.

It was originally intended that this structure could hold other information
about the next stage which compilation might depend on. For example, compilation
to GLSL needs to know the type of the next shader in some circumstances.

That was never actualized, and since the API is fixed at this point for 1.9, it
makes the most sense to rename the structure to match its actual scope.

The documentation was written and arranged to imply that the structure would
hold other information about the next shader than the varying map; this is
changed accordingly as well.

.gitignore

@@ -3,12 +3,16 @@ autom4te.cache
 config.log
 config.status
 configure
+doc
+Doxyfile
 libtool
 Makefile
 Makefile.in
 test-suite.log
+/vkd3d-compiler
+/vkd3d-dxbc
 
-vkd3d-*.tar.gz
+vkd3d-*.tar.xz
 
 *.exe
 *.la
@@ -16,7 +20,10 @@ vkd3d-*.tar.gz
 *.log
 *.o
 *.pc
+*.tab.c
+*.tab.h
 *.trs
+*.yy.c
 *~
 
 .deps

.gitlab-ci.yml

@@ -0,0 +1,7 @@
+stages:
+  - image
+  - build
+
+include:
+  - local: "/gitlab/image.yml"
+  - local: "/gitlab/build.yml"

ANNOUNCE

@@ -0,0 +1,103 @@
+The Wine team is proud to announce that release 1.9 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:
+
+  - Yet more improvements to the HLSL compiler.
+  - A new utility to inspect the contents of DXBC blobs.
+  - Miscellaneous bug fixes.
+
+The source is available from the following location:
+
+  https://dl.winehq.org/vkd3d/source/vkd3d-1.9.tar.xz
+
+The current source can also be pulled directly from the git repository:
+
+  https://gitlab.winehq.org/wine/vkd3d.git
+
+Vkd3d is available thanks to the work of multiple people. See the file AUTHORS
+for the complete list.
+
+----------------------------------------------------------------
+
+What's new in vkd3d 1.9
+=======================
+
+
+*** libvkd3d
+
+- Copying between depth/stencil and colour formats in
+  ID3D12GraphicsCommandList::CopyResource() is supported.
+- The ID3D12Fence1 interface is supported.
+
+
+*** libvkd3d-shader
+
+- vkd3d_shader_scan() supports retrieving descriptor information for `d3dbc'
+  shaders. This is one of the requirements for eventual SPIR-V generation from
+  `d3dbc' sources.
+
+- New features for the HLSL source type:
+  - Support for the following intrinsic functions:
+    - clip()
+    - ddx_coarse() and ddy_coarse()
+    - ddx_fine() and ddy_fine()
+    - tex1D(), tex2D(), texCUBE(), and tex3D()
+  - Constant folding support for more expression types. In particular:
+    - comparison operators
+    - floating-point min() and max()
+    - logical `and' and `or'
+    - dot products
+    - square roots
+    - logarithms
+  - Support for multi-sample texture object declarations without explicit
+    sample counts in shader model 4.1 and later shaders.
+  - Support for using constant expressions as sample counts in multi-sample
+    texture object declarations.
+  - Support for variable initialisers using variables declared earlier in the
+    same declaration list. E.g., `float a = 1, b = a, c = b + 1;'.
+  - The GetDimensions() texture object method is implemented.
+  - Matrix swizzles are implemented.
+  - Parser support for if-statement attributes like `[branch]' and
+    `[flatten]'.
+  - Support for the `inline' function modifier.
+
+- Previously, vkd3d_shader_compile() would in some cases return VKD3D_OK
+  despite compilation failing when targeting legacy Direct3D bytecode. These
+  cases have been fixed.
+
+- Various HLSL preprocessor fixes for edge cases related to stringification.
+
+- SPIR-V target support for the `linear noperspective centroid' input
+  interpolation mode.
+
+- New interfaces:
+  - The vkd3d_shader_scan_signature_info structure extends the
+    vkd3d_shader_compile_info structure, and can be used to retrieve
+    descriptions of `dxbc-tpf' and `d3dbc' shader inputs and outputs.
+  - vkd3d_shader_free_scan_signature_info() is used to free
+    vkd3d_shader_scan_signature_info structures.
+  - The VKD3D_SHADER_COMPILE_OPTION_PACK_MATRIX_ORDER compile option can be
+    used to specify the default matrix packing order for HLSL sources.
+  - The vkd3d_shader_varying_map_info structure extends the
+    vkd3d_shader_compile_info structure, and can be used to specify a mapping
+    between the outputs of a shader stage and the inputs of the next shader
+    stage.
+  - vkd3d_shader_build_varying_map() is used to build a mapping between the
+    outputs of a shader stage and the inputs of the next shader stage.
+  - The VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_RAW_BUFFER flag returned as part of
+    the vkd3d_shader_descriptor_info structure indicates the descriptor refers
+    to a byte-addressed (`raw') buffer resource.
+
+
+*** vkd3d-compiler
+
+- The `--matrix-storage-order' option can used to specify the default matrix
+  storage order for HLSL sources.
+
+
+*** vkd3d-dxbc
+
+- vkd3d-dxbc is a new utility that can be used to inspect the contents of DXBC
+  blobs.

AUTHORS

@@ -1,2 +1,35 @@
+Alexandre Julliard
+Alistair Leslie-Hughes
+Andrew Eikum
+Andrey Gusev
+Atharva Nimbalkar
+Biswapriyo Nath
+Brendan Shanks
+Chip Davis
+Conor McCarthy
+David Gow
+Derek Lesho
+Ethan Lee
+Evan Tang
+Fabian Maurer
+Francisco Casas
+Francois Gouget
+Giovanni Mascellani
+Hans-Kristian Arntzen
 Henri Verbeet
+Isabella Bosia
+Jactry Zeng
+Jan Sikorski
+Joshua Ashton
 Józef Kucia
+Martin Storsjö
+Matteo Bruni
+Nikolay Sivov
+Philip Rebohle
+Rémi Bernon
+Robin Kertels
+Stefan Dösinger
+Sven Hesse
+Vinson Lee
+Zebediah Figura
+Zhiyi Zhang

COPYING

@@ -1,20 +1,16 @@
-Copyright 2016 Józef Kucia for CodeWeavers
+Copyright 2016-2023 the Vkd3d project authors (see the file AUTHORS for a
-Copyright 2016 Henri Verbeet for CodeWeavers
+complete list)
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
+Vkd3d is free software; you can redistribute it and/or modify it under
-of this software and associated documentation files (the "Software"), to deal
+the terms of the GNU Lesser General Public License as published by the
-in the Software without restriction, including without limitation the rights
+Free Software Foundation; either version 2.1 of the License, or (at
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+your option) any later version.
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all
+This library is distributed in the hope that it will be useful, but
-copies or substantial portions of the Software.
+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.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+You should have received a copy of the GNU Lesser General Public
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+License along with this library; if not, write to the Free Software
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA, 02110-1301 USA.
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

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

README

@@ -4,3 +4,92 @@ 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.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
+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.21), then you can build Wine with `make
+tools/widl/widl' to avoid building all of Wine. You can then point vkd3d's
+configure at that widl binary with `WIDL="/path/to/widl"'.
+
+For release builds, you may want to define NDEBUG. If you do not need debug log
+messages, you may also consider VKD3D_NO_TRACE_MESSAGES and
+VKD3D_NO_DEBUG_MESSAGES. For example, you can pass `CPPFLAGS="-DNDEBUG
+-DVKD3D_NO_TRACE_MESSAGES"' to configure.
+
+===========
+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.
+
+ * NO_COLOR - this is an alias of NO_COLOUR.
+
+ * NO_COLOUR - when set, vkd3d-compiler and vkd3d-dxbc 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
+   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.
+
+================
+Developing vkd3d
+================
+
+Development of vkd3d happens on the Wine GitLab instance
+(https://gitlab.winehq.org/wine/vkd3d/). Contributors are encouraged
+to submit their patches using the merge request tool.
+
+Each merge request is automatically tested with the GitLab CI
+system. See gitlab/README in the Git tree for more details.

configure.ac

@@ -1,15 +1,25 @@
 AC_PREREQ([2.69])
-AC_INIT([vkd3d], 0.0.1)
+AC_INIT([vkd3d],[1.9])
 
 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([GLSLANG], [glslangValidator GLSL compiler])
 AC_ARG_VAR([CROSSCC32], [32-bit Windows cross compiler])
 AC_ARG_VAR([CROSSCC64], [64-bit Windows cross compiler])
+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])
+AC_ARG_ENABLE([tests],
+              AS_HELP_STRING([--enable-tests], [Build tests (default: enabled)]),,
+              [enable_tests=yes])
+
+AC_USE_SYSTEM_EXTENSIONS
 
 dnl Check for progs
 AM_PROG_AR
@@ -17,67 +27,170 @@ 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, 21)
 AS_IF([test "x$WIDL" = "xno"], [AC_MSG_WARN([widl is required to build header files.])])
-AC_CHECK_PROG([GLSLANG], [glslangValidator], [glslangValidator], [no])
+
-AS_IF([test "x$GLSLANG" = "xno"], [AC_MSG_ERROR([glslangValidator is required to compile shaders.])])
+AC_CHECK_PROGS([FLEX], [flex], [none])
+AS_IF([test "$FLEX" = "none"], [AC_MSG_ERROR([no suitable flex found. Please install the 'flex' package.])])
+AC_ARG_VAR([LFLAGS], [extra flags for flex])
+
+AC_CHECK_PROGS([BISON], [bison], [none])
+AS_IF([test "$BISON" = "none"], [AC_MSG_ERROR([no suitable bison found. Please install the 'bison' package.])])
+AC_ARG_VAR([YFLAGS], [extra flags for bison])
+
+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
 
 dnl Check compiler specific flags
-AC_SUBST([VKD3D_CFLAGS], [""])
+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])])
+      VKD3D_CHECK_CFLAGS([-Wvla])
+      VKD3D_CHECK_CFLAGS([-Wpointer-arith])
+      VKD3D_CHECK_CFLAGS([-Wl,--no-undefined])])
 
 dnl Check for cross compilers
 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 \
-AS_IF([test "x$ac_cv_header_pthread_h" != "xyes"], [AC_MSG_ERROR([pthread.h not found.])])
+                  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_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"],
+      [AC_MSG_ERROR([spirv.h not found.])])
+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([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
+# 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_ARG_VAR([PTHREAD_LIBS], [linker flags for pthreads])
+AC_CHECK_LIB([m], [ceilf])
-AC_CHECK_LIB([pthread], [pthread_create],
-             [AC_SUBST(PTHREAD_LIBS, "-lpthread")],
-             [AC_MSG_ERROR(libpthread not found.)])
 
-AC_CHECK_LIB([vulkan], [vkGetInstanceProcAddr], [], [AC_MSG_ERROR([libvulkan not found.])])
+AC_SUBST([DL_LIBS])
+AC_CHECK_LIB([dl], [dlopen],
+             [DL_LIBS="-ldl"],
+             [AS_IF([test "$ac_cv_header_dlfnc_h" = "xyes"], [AC_MSG_ERROR([libdl not found.])])])
 
-PKG_CHECK_MODULES([XCB], [xcb xcb-keysyms])
+case $host_os in
+  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_ARG_VAR([SONAME_LIBVULKAN], [shared object name for the Vulkan library])
+AC_ARG_VAR([VULKAN_LIBS], [linker flags for the Vulkan library])
+AS_IF([test "x$SONAME_LIBVULKAN" = "x"],
+      [VKD3D_CHECK_VULKAN],
+      [AC_DEFINE_UNQUOTED([SONAME_LIBVULKAN],["$SONAME_LIBVULKAN"],[Define to the shared object name of the Vulkan library.])])
+
+AS_IF([test "x$with_ncurses" != "xno"],
+      [PKG_CHECK_MODULES([NCURSES], [ncurses],
+                         [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.])])],
+      [with_spirv_tools=no])
+
+HAVE_XCB=no
+AS_IF([test "x$with_xcb" != "xno"],
+      [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])])
 
 dnl Check for functions
-VKD3D_CHECK_SYNC_ADD_AND_FETCH_FUNC
+VKD3D_CHECK_FUNC([HAVE_BUILTIN_CLZ], [__builtin_clz], [__builtin_clz(0)])
-VKD3D_CHECK_SYNC_SUB_AND_FETCH_FUNC
+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_FUNC([HAVE_SYNC_BOOL_COMPARE_AND_SWAP], [__sync_bool_compare_and_swap], [__sync_bool_compare_and_swap((int *)0, 0, 0)])
+VKD3D_CHECK_FUNC([HAVE_ATOMIC_EXCHANGE_N], [__atomic_exchange_n], [__atomic_exchange_n((int *)0, 0, 0)])
+VKD3D_CHECK_FUNC([HAVE_GETTID], [gettid], [gettid()])
 
-AM_CONDITIONAL([HAS_CROSSTARGET32], [test "x$CROSSTARGET32" != "xno"])
+dnl Makefiles
-AM_CONDITIONAL([HAS_CROSSTARGET64], [test "x$CROSSTARGET64" != "xno"])
+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"])
+AM_CONDITIONAL([HAVE_WIDL], [test "x$WIDL" != "xno"])
+AM_CONDITIONAL([HAVE_CROSSTARGET32], [test "x$CROSSTARGET32" != "xno"])
+AM_CONDITIONAL([HAVE_CROSSTARGET64], [test "x$CROSSTARGET64" != "xno"])
 
 AC_CONFIG_FILES([Makefile])
 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
 
-  Building crosstests: ${HAVE_CROSSTEST}"])
+  widl: ${WIDL}
+
+  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}
+"])
+
+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.h

@@ -1,23 +1,19 @@
 /*
  * Copyright 2016 Henri Verbeet for CodeWeavers
  *
- * Permission is hereby granted, free of charge, to any person obtaining a
+ * This library is free software; you can redistribute it and/or
- * copy of this software and associated documentation files (the "Software"),
+ * modify it under the terms of the GNU Lesser General Public
- * to deal in the Software without restriction, including without limitation
+ * License as published by the Free Software Foundation; either
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * version 2.1 of the License, or (at your option) any later version.
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
  *
- * The above copyright notice and this permission notice shall be included in
+ * This library is distributed in the hope that it will be useful,
- * all copies or substantial portions of the Software.
+ * 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.
  *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * You should have received a copy of the GNU Lesser General Public
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * License along with this library; if not, write to the Free Software
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
  */
 
 /* Hack for MinGW-w64 headers.
@@ -40,7 +36,7 @@
 #include <vkd3d_windows.h>
 #define WIDL_C_INLINE_WRAPPERS
 #define COBJMACROS
-#include <d3d12.h>
+#include <vkd3d_d3d12.h>
 #include <inttypes.h>
 
 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(*x))
@@ -127,9 +123,24 @@ static inline void demo_blend_desc_init_default(D3D12_BLEND_DESC *desc)
     }
 }
 
+static inline HRESULT demo_create_root_signature(ID3D12Device *device,
+        const D3D12_ROOT_SIGNATURE_DESC *desc, ID3D12RootSignature **signature)
+{
+    ID3DBlob *blob;
+    HRESULT hr;
+
+    if (FAILED(hr = D3D12SerializeRootSignature(desc, D3D_ROOT_SIGNATURE_VERSION_1, &blob, NULL)))
+        return hr;
+    hr = ID3D12Device_CreateRootSignature(device, 0, ID3D10Blob_GetBufferPointer(blob),
+            ID3D10Blob_GetBufferSize(blob), &IID_ID3D12RootSignature, (void **)signature);
+    ID3D10Blob_Release(blob);
+
+    return hr;
+}
+
 #ifdef _WIN32
 #include "demo_win32.h"
 #else
-#include <vkd3d_utils.h>
+#define INFINITE VKD3D_INFINITE
 #include "demo_xcb.h"
 #endif

demos/demo_win32.h

@@ -2,26 +2,23 @@
  * Copyright 2016 Józef Kucia for CodeWeavers
  * Copyright 2016 Henri Verbeet for CodeWeavers
  *
- * Permission is hereby granted, free of charge, to any person obtaining a
+ * This library is free software; you can redistribute it and/or
- * copy of this software and associated documentation files (the "Software"),
+ * modify it under the terms of the GNU Lesser General Public
- * to deal in the Software without restriction, including without limitation
+ * License as published by the Free Software Foundation; either
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * version 2.1 of the License, or (at your option) any later version.
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
  *
- * The above copyright notice and this permission notice shall be included in
+ * This library is distributed in the hope that it will be useful,
- * all copies or substantial portions of the Software.
+ * 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.
  *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * You should have received a copy of the GNU Lesser General Public
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * License along with this library; if not, write to the Free Software
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
  */
 
-#include <dxgi1_4.h>
+#include <vkd3d_dxgi1_4.h>
+#include <vkd3d_d3dcompiler.h>
 #include <stdbool.h>
 #include <stdio.h>
 
@@ -29,10 +26,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;
 
@@ -202,11 +195,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;
@@ -220,7 +208,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;
@@ -228,16 +216,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,
@@ -329,46 +312,3 @@ static inline void demo_destroy_event(HANDLE event)
 {
     CloseHandle(event);
 }
-
-static inline HRESULT demo_create_root_signature(ID3D12Device *device,
-        const D3D12_ROOT_SIGNATURE_DESC *desc, ID3D12RootSignature **signature)
-{
-    ID3DBlob *blob;
-    HRESULT hr;
-
-    if (FAILED(hr = D3D12SerializeRootSignature(desc, D3D_ROOT_SIGNATURE_VERSION_1, &blob, NULL)))
-        return hr;
-    hr = ID3D12Device_CreateRootSignature(device, 0, ID3D10Blob_GetBufferPointer(blob),
-            ID3D10Blob_GetBufferSize(blob), &IID_ID3D12RootSignature, (void **)signature);
-    ID3D10Blob_Release(blob);
-
-    return hr;
-}
-
-static inline bool demo_load_shader(struct demo *demo, const wchar_t *hlsl_name, const char *entry_point,
-        const char *profile, const char *spv_name, D3D12_SHADER_BYTECODE *shader)
-{
-    ID3D10Blob *blob, *errors;
-    HRESULT hr;
-
-    hr = demo->compile_from_file(hlsl_name, NULL, NULL, entry_point, profile, 0, 0, &blob, &errors);
-    if (errors)
-    {
-        fprintf(stderr, "%.*s\n", (int)ID3D10Blob_GetBufferSize(errors), (char *)ID3D10Blob_GetBufferPointer(errors));
-        ID3D10Blob_Release(errors);
-    }
-    if (FAILED(hr))
-        return false;
-
-    shader->BytecodeLength = ID3D10Blob_GetBufferSize(blob);
-    if (!(shader->pShaderBytecode = malloc(shader->BytecodeLength)))
-    {
-        ID3D10Blob_Release(blob);
-        return false;
-    }
-
-    memcpy((void *)shader->pShaderBytecode, ID3D10Blob_GetBufferPointer(blob), shader->BytecodeLength);
-
-    ID3D10Blob_Release(blob);
-    return true;
-}

demos/demo_xcb.h

@@ -2,34 +2,80 @@
  * Copyright 2016 Józef Kucia for CodeWeavers
  * Copyright 2016 Henri Verbeet for CodeWeavers
  *
- * Permission is hereby granted, free of charge, to any person obtaining a
+ * This library is free software; you can redistribute it and/or
- * copy of this software and associated documentation files (the "Software"),
+ * modify it under the terms of the GNU Lesser General Public
- * to deal in the Software without restriction, including without limitation
+ * License as published by the Free Software Foundation; either
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * version 2.1 of the License, or (at your option) any later version.
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
  *
- * The above copyright notice and this permission notice shall be included in
+ * This library is distributed in the hope that it will be useful,
- * all copies or substantial portions of the Software.
+ * 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.
  *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * You should have received a copy of the GNU Lesser General Public
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * License along with this library; if not, write to the Free Software
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
  */
 
+#define VK_NO_PROTOTYPES
 #define VK_USE_PLATFORM_XCB_KHR
+#define VKD3D_UTILS_API_VERSION VKD3D_API_VERSION_1_9
+#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
 {
@@ -37,6 +83,7 @@ struct demo
     xcb_atom_t wm_protocols_atom;
     xcb_atom_t wm_delete_window_atom;
     xcb_key_symbols_t *xcb_keysyms;
+    int screen;
 
     struct demo_window **windows;
     size_t windows_size;
@@ -64,7 +111,10 @@ struct demo_swapchain
 
     VkInstance vk_instance;
     VkDevice vk_device;
-    VkQueue vk_queue;
+    ID3D12CommandQueue *command_queue;
+
+    ID3D12Fence *present_fence;
+    unsigned long long present_count;
 
     uint32_t current_buffer;
     unsigned int buffer_count;
@@ -134,6 +184,20 @@ static inline struct demo_window *demo_find_window(struct demo *demo, xcb_window
     return NULL;
 }
 
+static inline xcb_screen_t *demo_get_screen(xcb_connection_t *c, int idx)
+{
+    xcb_screen_iterator_t iter;
+
+    iter = xcb_setup_roots_iterator(xcb_get_setup(c));
+    for (; iter.rem; xcb_screen_next(&iter), --idx)
+    {
+        if (!idx)
+            return iter.data;
+    }
+
+    return NULL;
+}
+
 static inline struct demo_window *demo_window_create(struct demo *demo, const char *title,
         unsigned int width, unsigned int height, void *user_data)
 {
@@ -143,6 +207,9 @@ static inline struct demo_window *demo_window_create(struct demo *demo, const ch
     xcb_size_hints_t hints;
     xcb_screen_t *screen;
 
+    if (!(screen = demo_get_screen(demo->connection, demo->screen)))
+        return NULL;
+
     if (!(window = malloc(sizeof(*window))))
         return NULL;
 
@@ -157,7 +224,6 @@ static inline struct demo_window *demo_window_create(struct demo *demo, const ch
     window->user_data = user_data;
     window->expose_func = NULL;
     window->key_press_func = NULL;
-    screen = xcb_setup_roots_iterator(xcb_get_setup(demo->connection)).data;
     xcb_create_window(demo->connection, XCB_COPY_FROM_PARENT, window->window, screen->root, 0, 0,
             width, height, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, screen->root_visual,
             XCB_CW_EVENT_MASK, &window_events);
@@ -254,7 +320,7 @@ static inline void demo_process_events(struct demo *demo)
 
 static inline bool demo_init(struct demo *demo, void *user_data)
 {
-    if (!(demo->connection = xcb_connect(NULL, NULL)))
+    if (!(demo->connection = xcb_connect(NULL, &demo->screen)))
         return false;
     if (xcb_connection_has_error(demo->connection) > 0)
         goto fail;
@@ -291,27 +357,16 @@ static inline void demo_set_idle_func(struct demo *demo,
     demo->idle_func = idle_func;
 }
 
-static inline DXGI_FORMAT demo_get_srgb_format(DXGI_FORMAT format)
-{
-    switch (format)
-    {
-        case DXGI_FORMAT_B8G8R8A8_UNORM:
-            return DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
-        default:
-            return DXGI_FORMAT_UNKNOWN;
-    }
-}
-
 static inline struct demo_swapchain *demo_swapchain_create(ID3D12CommandQueue *command_queue,
         struct demo_window *window, const struct demo_swapchain_desc *desc)
 {
+    struct vkd3d_image_resource_create_info resource_create_info;
     struct VkSwapchainCreateInfoKHR vk_swapchain_desc;
     struct VkXcbSurfaceCreateInfoKHR surface_desc;
     VkSwapchainKHR vk_swapchain = VK_NULL_HANDLE;
     uint32_t format_count, queue_family_index;
     VkSurfaceCapabilitiesKHR surface_caps;
     VkPhysicalDevice vk_physical_device;
-    D3D12_RESOURCE_DESC resource_desc;
     VkFence vk_fence = VK_NULL_HANDLE;
     struct demo_swapchain *swapchain;
     unsigned int image_count, i, j;
@@ -325,13 +380,15 @@ static inline struct demo_swapchain *demo_swapchain_create(ID3D12CommandQueue *c
     VkImage *vk_images;
     VkFormat format;
 
-    if ((format = vkd3d_get_vk_format(demo_get_srgb_format(desc->format))) == VK_FORMAT_UNDEFINED)
+    load_vulkan_procs();
+
+    if ((format = vkd3d_get_vk_format(desc->format)) == VK_FORMAT_UNDEFINED)
         return NULL;
 
     if (FAILED(ID3D12CommandQueue_GetDevice(command_queue, &IID_ID3D12Device, (void **)&d3d12_device)))
         return NULL;
 
-    vk_instance = vkd3d_get_vk_instance(d3d12_device);
+    vk_instance = vkd3d_instance_get_vk_instance(vkd3d_instance_from_device(d3d12_device));
     vk_physical_device = vkd3d_get_vk_physical_device(d3d12_device);
     vk_device = vkd3d_get_vk_device(d3d12_device);
 
@@ -372,11 +429,11 @@ static inline struct demo_swapchain *demo_swapchain_create(ID3D12CommandQueue *c
     }
 
     if (format_count != 1 || formats->format != VK_FORMAT_UNDEFINED
-            || formats->colorSpace != VK_COLORSPACE_SRGB_NONLINEAR_KHR)
+            || formats->colorSpace != VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
     {
         for (i = 0; i < format_count; ++i)
         {
-            if (formats[i].format == format && formats[i].colorSpace == VK_COLORSPACE_SRGB_NONLINEAR_KHR)
+            if (formats[i].format == format && formats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
                 break;
         }
 
@@ -396,7 +453,7 @@ static inline struct demo_swapchain *demo_swapchain_create(ID3D12CommandQueue *c
     vk_swapchain_desc.surface = vk_surface;
     vk_swapchain_desc.minImageCount = desc->buffer_count;
     vk_swapchain_desc.imageFormat = format;
-    vk_swapchain_desc.imageColorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
+    vk_swapchain_desc.imageColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
     vk_swapchain_desc.imageExtent.width = desc->width;
     vk_swapchain_desc.imageExtent.height = desc->height;
     vk_swapchain_desc.imageArrayLayers = 1;
@@ -438,29 +495,31 @@ static inline struct demo_swapchain *demo_swapchain_create(ID3D12CommandQueue *c
     swapchain->vk_fence = vk_fence;
     swapchain->vk_instance = vk_instance;
     swapchain->vk_device = vk_device;
-    swapchain->vk_queue = vkd3d_get_vk_queue(command_queue);
 
     vkAcquireNextImageKHR(vk_device, vk_swapchain, UINT64_MAX,
             VK_NULL_HANDLE, vk_fence, &swapchain->current_buffer);
     vkWaitForFences(vk_device, 1, &vk_fence, VK_TRUE, UINT64_MAX);
     vkResetFences(vk_device, 1, &vk_fence);
 
-    resource_desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
+    resource_create_info.type = VKD3D_STRUCTURE_TYPE_IMAGE_RESOURCE_CREATE_INFO;
-    resource_desc.Alignment = 0;
+    resource_create_info.next = NULL;
-    resource_desc.Width = desc->width;
+    resource_create_info.desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
-    resource_desc.Height = desc->height;
+    resource_create_info.desc.Alignment = 0;
-    resource_desc.DepthOrArraySize = 1;
+    resource_create_info.desc.Width = desc->width;
-    resource_desc.MipLevels = 1;
+    resource_create_info.desc.Height = desc->height;
-    resource_desc.Format = desc->format;
+    resource_create_info.desc.DepthOrArraySize = 1;
-    resource_desc.SampleDesc.Count = 1;
+    resource_create_info.desc.MipLevels = 1;
-    resource_desc.SampleDesc.Quality = 0;
+    resource_create_info.desc.Format = desc->format;
-    resource_desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
+    resource_create_info.desc.SampleDesc.Count = 1;
-    resource_desc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
+    resource_create_info.desc.SampleDesc.Quality = 0;
+    resource_create_info.desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
+    resource_create_info.desc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
+    resource_create_info.flags = VKD3D_RESOURCE_INITIAL_STATE_TRANSITION | VKD3D_RESOURCE_PRESENT_STATE_TRANSITION;
+    resource_create_info.present_state = D3D12_RESOURCE_STATE_PRESENT;
     for (i = 0; i < image_count; ++i)
     {
-        if (FAILED(vkd3d_create_image_resource(d3d12_device, &resource_desc, vk_images[i],
+        resource_create_info.vk_image = vk_images[i];
-                VKD3D_RESOURCE_INITIAL_STATE_TRANSITION | VKD3D_RESOURCE_SWAPCHAIN_IMAGE,
+        if (FAILED(vkd3d_create_image_resource(d3d12_device, &resource_create_info, &swapchain->buffers[i])))
-                &swapchain->buffers[i])))
         {
             for (j = 0; j < i; ++j)
             {
@@ -473,8 +532,21 @@ static inline struct demo_swapchain *demo_swapchain_create(ID3D12CommandQueue *c
     }
     swapchain->buffer_count = image_count;
     free(vk_images);
+
+    if (FAILED(ID3D12Device_CreateFence(d3d12_device, 0, 0, &IID_ID3D12Fence, (void **)&swapchain->present_fence)))
+    {
+        for (i = 0; i < image_count; ++i)
+        {
+            ID3D12Resource_Release(swapchain->buffers[i]);
+        }
+        free(swapchain);
+        goto fail;
+    }
+    swapchain->present_count = 0;
     ID3D12Device_Release(d3d12_device);
 
+    ID3D12CommandQueue_AddRef(swapchain->command_queue = command_queue);
+
     return swapchain;
 
 fail:
@@ -505,6 +577,7 @@ static inline ID3D12Resource *demo_swapchain_get_back_buffer(struct demo_swapcha
 static inline void demo_swapchain_present(struct demo_swapchain *swapchain)
 {
     VkPresentInfoKHR present_desc;
+    VkQueue vk_queue;
 
     present_desc.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
     present_desc.pNext = NULL;
@@ -515,7 +588,15 @@ static inline void demo_swapchain_present(struct demo_swapchain *swapchain)
     present_desc.pImageIndices = &swapchain->current_buffer;
     present_desc.pResults = NULL;
 
-    vkQueuePresentKHR(swapchain->vk_queue, &present_desc);
+    /* Synchronize vkd3d_acquire_vk_queue() with the Direct3D 12 work
+     * already submitted to the command queue. */
+    ++swapchain->present_count;
+    ID3D12CommandQueue_Signal(swapchain->command_queue, swapchain->present_fence, swapchain->present_count);
+    ID3D12Fence_SetEventOnCompletion(swapchain->present_fence, swapchain->present_count, NULL);
+
+    vk_queue = vkd3d_acquire_vk_queue(swapchain->command_queue);
+    vkQueuePresentKHR(vk_queue, &present_desc);
+    vkd3d_release_vk_queue(swapchain->command_queue);
 
     vkAcquireNextImageKHR(swapchain->vk_device, swapchain->vk_swapchain, UINT64_MAX,
             VK_NULL_HANDLE, swapchain->vk_fence, &swapchain->current_buffer);
@@ -527,6 +608,8 @@ static inline void demo_swapchain_destroy(struct demo_swapchain *swapchain)
 {
     unsigned int i;
 
+    ID3D12CommandQueue_Release(swapchain->command_queue);
+    ID3D12Fence_Release(swapchain->present_fence);
     for (i = 0; i < swapchain->buffer_count; ++i)
     {
         ID3D12Resource_Release(swapchain->buffers[i]);
@@ -551,47 +634,3 @@ static inline void demo_destroy_event(HANDLE event)
 {
     vkd3d_destroy_event(event);
 }
-
-static inline HRESULT demo_create_root_signature(ID3D12Device *device,
-        const D3D12_ROOT_SIGNATURE_DESC *desc, ID3D12RootSignature **signature)
-{
-    return ID3D12Device_CreateRootSignature(device, 0, desc, ~(SIZE_T)0,
-            &IID_ID3D12RootSignature, (void **)signature);
-}
-
-static inline bool demo_load_shader(struct demo *demo, const wchar_t *hlsl_name, const char *entry_point,
-        const char *profile, const char *spv_name, D3D12_SHADER_BYTECODE *shader)
-{
-    size_t data_size;
-    struct stat st;
-    ssize_t res;
-    void *data;
-    int fd;
-
-    if ((fd = open(spv_name, O_RDONLY)) == -1)
-        return false;
-
-    if (fstat(fd, &st) == -1)
-        goto fail;
-
-    data_size = st.st_size;
-    if (!(data = malloc(data_size)))
-        goto fail;
-
-    res = read(fd, data, data_size);
-    close(fd);
-    if (res != data_size)
-    {
-        free(data);
-        return false;
-    }
-
-    shader->pShaderBytecode = data;
-    shader->BytecodeLength = data_size;
-
-    return true;
-
-fail:
-    close(fd);
-    return false;
-}

demos/gears.c

@@ -1,23 +1,19 @@
 /*
  * Copyright 2016 Henri Verbeet for CodeWeavers
  *
- * Permission is hereby granted, free of charge, to any person obtaining a
+ * This library is free software; you can redistribute it and/or
- * copy of this software and associated documentation files (the "Software"),
+ * modify it under the terms of the GNU Lesser General Public
- * to deal in the Software without restriction, including without limitation
+ * License as published by the Free Software Foundation; either
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * version 2.1 of the License, or (at your option) any later version.
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
  *
- * The above copyright notice and this permission notice shall be included in
+ * This library is distributed in the hope that it will be useful,
- * all copies or substantial portions of the Software.
+ * 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.
  *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * You should have received a copy of the GNU Lesser General Public
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * License along with this library; if not, write to the Free Software
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
  */
 
 /*
@@ -52,6 +48,8 @@
 #include <math.h>
 #include "demo.h"
 
+#include "gears_hlsl.h"
+
 struct cxg_fence
 {
     ID3D12Fence *fence;
@@ -124,12 +122,12 @@ struct cx_gears
     struct demo_swapchain *swapchain;
     ID3D12DescriptorHeap *rtv_heap, *dsv_heap;
     unsigned int rtv_descriptor_size;
-    ID3D12Resource *render_targets[2];
+    ID3D12Resource *render_targets[3];
-    ID3D12CommandAllocator *command_allocator[2];
+    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 +216,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 +304,10 @@ static void cxg_destroy_pipeline(struct cx_gears *cxg)
 {
     unsigned int i;
 
-    ID3D12CommandAllocator_Release(cxg->command_allocator[1]);
+    for (i = 0; i < ARRAY_SIZE(cxg->command_allocator); ++i)
-    ID3D12CommandAllocator_Release(cxg->command_allocator[0]);
+    {
+        ID3D12CommandAllocator_Release(cxg->command_allocator[i]);
+    }
     for (i = 0; i < ARRAY_SIZE(cxg->render_targets); ++i)
     {
         ID3D12Resource_Release(cxg->render_targets[i]);
@@ -370,12 +371,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,
+    for (i = 0; i < ARRAY_SIZE(cxg->command_allocator); ++i)
-            &IID_ID3D12CommandAllocator, (void **)&cxg->command_allocator[0]);
+    {
-    assert(SUCCEEDED(hr));
+        hr = ID3D12Device_CreateCommandAllocator(cxg->device, D3D12_COMMAND_LIST_TYPE_DIRECT,
-    hr = ID3D12Device_CreateCommandAllocator(cxg->device, D3D12_COMMAND_LIST_TYPE_DIRECT,
+                &IID_ID3D12CommandAllocator, (void **)&cxg->command_allocator[i]);
-            &IID_ID3D12CommandAllocator, (void **)&cxg->command_allocator[1]);
+        assert(SUCCEEDED(hr));
-    assert(SUCCEEDED(hr));
+    }
 }
 
 static void cxg_fence_destroy(struct cxg_fence *cxg_fence)
@@ -386,6 +387,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 +397,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]);
+    for (i = 0; i < ARRAY_SIZE(cxg->command_list); ++i)
-    ID3D12GraphicsCommandList_Release(cxg->command_list[0]);
+        ID3D12GraphicsCommandList_Release(cxg->command_list[i]);
     ID3D12PipelineState_Release(cxg->pipeline_state_smooth);
     ID3D12PipelineState_Release(cxg->pipeline_state_flat);
     ID3D12RootSignature_Release(cxg->root_signature);
@@ -654,12 +657,13 @@ static void cxg_load_assets(struct cx_gears *cxg)
     D3D12_GRAPHICS_PIPELINE_STATE_DESC pso_desc;
     D3D12_CPU_DESCRIPTOR_HANDLE dsv_handle;
     D3D12_ROOT_PARAMETER root_parameter;
+    ID3DBlob *vs, *ps_flat, *ps_smooth;
     D3D12_RESOURCE_DESC resource_desc;
     D3D12_HEAP_PROPERTIES heap_desc;
     D3D12_RANGE read_range = {0, 0};
     D3D12_CLEAR_VALUE clear_value;
+    unsigned int i;
     HRESULT hr;
-    bool ret;
 
     root_parameter.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
     root_parameter.Descriptor.ShaderRegister = 0;
@@ -677,15 +681,21 @@ static void cxg_load_assets(struct cx_gears *cxg)
     hr = demo_create_root_signature(cxg->device, &root_signature_desc, &cxg->root_signature);
     assert(SUCCEEDED(hr));
 
+    hr = D3DCompile(gears_hlsl, strlen(gears_hlsl), NULL, NULL, NULL, "vs_main", "vs_5_0", 0, 0, &vs, NULL);
+    assert(SUCCEEDED(hr));
+    hr = D3DCompile(gears_hlsl, strlen(gears_hlsl), NULL, NULL, NULL, "ps_main_flat", "ps_5_0", 0, 0, &ps_flat, NULL);
+    assert(SUCCEEDED(hr));
+    hr = D3DCompile(gears_hlsl, strlen(gears_hlsl), NULL, NULL, NULL, "ps_main_smooth", "ps_5_0", 0, 0, &ps_smooth, NULL);
+    assert(SUCCEEDED(hr));
+
     memset(&pso_desc, 0, sizeof(pso_desc));
     pso_desc.InputLayout.pInputElementDescs = il_desc;
     pso_desc.InputLayout.NumElements = ARRAY_SIZE(il_desc);
     pso_desc.pRootSignature = cxg->root_signature;
-    ret = demo_load_shader(&cxg->demo, L"gears.hlsl", "vs_main", "vs_5_0", "gears.vert.spv", &pso_desc.VS);
+    pso_desc.VS.pShaderBytecode = ID3D10Blob_GetBufferPointer(vs);
-    assert(ret);
+    pso_desc.VS.BytecodeLength = ID3D10Blob_GetBufferSize(vs);
-    ret = demo_load_shader(&cxg->demo, L"gears.hlsl", "ps_main_flat",
+    pso_desc.PS.pShaderBytecode = ID3D10Blob_GetBufferPointer(ps_flat);
-            "ps_5_0", "gears_flat.frag.spv", &pso_desc.PS);
+    pso_desc.PS.BytecodeLength = ID3D10Blob_GetBufferSize(ps_flat);
-    assert(ret);
 
     demo_rasterizer_desc_init_default(&pso_desc.RasterizerState);
     pso_desc.RasterizerState.FrontCounterClockwise = TRUE;
@@ -704,27 +714,25 @@ static void cxg_load_assets(struct cx_gears *cxg)
             &IID_ID3D12PipelineState, (void **)&cxg->pipeline_state_flat);
     assert(SUCCEEDED(hr));
 
-    free((void *)pso_desc.PS.pShaderBytecode);
+    pso_desc.PS.pShaderBytecode = ID3D10Blob_GetBufferPointer(ps_smooth);
-    ret = demo_load_shader(&cxg->demo, L"gears.hlsl", "ps_main_smooth",
+    pso_desc.PS.BytecodeLength = ID3D10Blob_GetBufferSize(ps_smooth);
-            "ps_5_0", "gears_smooth.frag.spv", &pso_desc.PS);
-    assert(ret);
     hr = ID3D12Device_CreateGraphicsPipelineState(cxg->device, &pso_desc,
             &IID_ID3D12PipelineState, (void **)&cxg->pipeline_state_smooth);
     assert(SUCCEEDED(hr));
 
-    free((void *)pso_desc.PS.pShaderBytecode);
+    ID3D10Blob_Release(vs);
-    free((void *)pso_desc.VS.pShaderBytecode);
+    ID3D10Blob_Release(ps_flat);
+    ID3D10Blob_Release(ps_smooth);
 
-    hr = ID3D12Device_CreateCommandList(cxg->device, 0, D3D12_COMMAND_LIST_TYPE_DIRECT, cxg->command_allocator[0],
+    for (i = 0; i < ARRAY_SIZE(cxg->command_list); ++i)
-            cxg->pipeline_state_flat, &IID_ID3D12GraphicsCommandList, (void **)&cxg->command_list[0]);
+    {
-    assert(SUCCEEDED(hr));
+        hr = ID3D12Device_CreateCommandList(cxg->device, 0, D3D12_COMMAND_LIST_TYPE_DIRECT,
-    hr = ID3D12GraphicsCommandList_Close(cxg->command_list[0]);
+                cxg->command_allocator[i], cxg->pipeline_state_flat,
-    assert(SUCCEEDED(hr));
+                &IID_ID3D12GraphicsCommandList, (void **)&cxg->command_list[i]);
-    hr = ID3D12Device_CreateCommandList(cxg->device, 0, D3D12_COMMAND_LIST_TYPE_DIRECT, cxg->command_allocator[1],
+        assert(SUCCEEDED(hr));
-            cxg->pipeline_state_flat, &IID_ID3D12GraphicsCommandList, (void **)&cxg->command_list[1]);
+        hr = ID3D12GraphicsCommandList_Close(cxg->command_list[i]);
-    assert(SUCCEEDED(hr));
+        assert(SUCCEEDED(hr));
-    hr = ID3D12GraphicsCommandList_Close(cxg->command_list[1]);
+    }
-    assert(SUCCEEDED(hr));
 
     heap_desc.Type = D3D12_HEAP_TYPE_DEFAULT;
     heap_desc.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
@@ -867,6 +875,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/gears.hlsl

@@ -1,55 +0,0 @@
-cbuffer gear_block : register(b0)
-{
-    float4x4 mvp_matrix;
-    float3x3 normal_matrix;
-};
-
-struct vs_in
-{
-    float4 position : POSITION;
-    float3 normal : NORMAL;
-    float3 diffuse : DIFFUSE;
-    float4 transform : TRANSFORM;
-};
-
-struct vs_out
-{
-    float4 position : SV_POSITION;
-    float4 colour : COLOR;
-};
-
-struct vs_out vs_main(struct vs_in i)
-{
-    const float3 l_pos = float3(5.0, 5.0, 10.0);
-    float3 dir, normal;
-    float4 position;
-    struct vs_out o;
-    float att;
-
-    position.x = i.transform.x * i.position.x - i.transform.y * i.position.y + i.transform.z;
-    position.y = i.transform.x * i.position.y + i.transform.y * i.position.x + i.transform.w;
-    position.zw = i.position.zw;
-
-    o.position = mul(mvp_matrix, position);
-    dir = normalize(l_pos - o.position.xyz / o.position.w);
-
-    normal.x = i.transform.x * i.normal.x - i.transform.y * i.normal.y;
-    normal.y = i.transform.x * i.normal.y + i.transform.y * i.normal.x;
-    normal.z = i.normal.z;
-    att = 0.2 + dot(dir, normalize(mul(normal_matrix, normal)));
-
-    o.colour.xyz = i.diffuse.xyz * att;
-    o.colour.w = 1.0;
-
-    return o;
-}
-
-float4 ps_main_smooth(float4 position : SV_POSITION, float4 colour : COLOR) : SV_TARGET
-{
-    return colour;
-}
-
-float4 ps_main_flat(float4 position : SV_POSITION, nointerpolation float4 colour : COLOR) : SV_TARGET
-{
-    return colour;
-}

demos/gears.vert

@@ -1,40 +0,0 @@
-#version 150
-#extension GL_ARB_separate_shader_objects : enable
-
-layout(location = 0) in vec4 position_in;
-layout(location = 1) in vec3 normal_in;
-layout(location = 2) in vec3 diffuse_in;
-layout(location = 3) in vec4 transform_in;
-
-layout(location = 0) out vec4 colour_out;
-
-uniform gear_block
-{
-    uniform mat4 mvp_matrix;
-    uniform mat3 normal_matrix;
-} gear;
-
-void main()
-{
-    const vec3 l_pos = vec3(5.0, 5.0, 10.0);
-    vec3 dir, normal;
-    vec4 position;
-    float att;
-
-    position.x = transform_in.x * position_in.x - transform_in.y * position_in.y + transform_in.z;
-    position.y = transform_in.x * position_in.y + transform_in.y * position_in.x + transform_in.w;
-    position.zw = position_in.zw;
-
-    gl_Position = gear.mvp_matrix * position;
-    dir = normalize(l_pos - gl_Position.xyz / gl_Position.w);
-
-    normal.x = transform_in.x * normal_in.x - transform_in.y * normal_in.y;
-    normal.y = transform_in.x * normal_in.y + transform_in.y * normal_in.x;
-    normal.z = normal_in.z;
-    att = 0.2 + dot(dir, normalize(gear.normal_matrix * normal));
-
-    colour_out.xyz = diffuse_in.xyz * att;
-    colour_out.w = 1.0;
-
-    gl_Position.y = -gl_Position.y;
-}

demos/gears_flat.frag

@@ -1,10 +0,0 @@
-#version 150
-#extension GL_ARB_separate_shader_objects : enable
-
-layout(location = 0) flat in vec4 colour_in;
-layout(location = 0) out vec4 colour_out;
-
-void main(void)
-{
-    colour_out = colour_in;
-}

demos/gears_hlsl.h

@@ -0,0 +1,56 @@
+static const char gears_hlsl[] =
+"cbuffer gear_block : register(b0)\n"
+"{\n"
+"    float4x4 mvp_matrix;\n"
+"    float3x3 normal_matrix;\n"
+"};\n"
+"\n"
+"struct vs_in\n"
+"{\n"
+"    float4 position : POSITION;\n"
+"    float3 normal : NORMAL;\n"
+"    float3 diffuse : DIFFUSE;\n"
+"    float4 transform : TRANSFORM;\n"
+"};\n"
+"\n"
+"struct vs_out\n"
+"{\n"
+"    float4 position : SV_POSITION;\n"
+"    float4 colour : COLOR;\n"
+"};\n"
+"\n"
+"struct vs_out vs_main(struct vs_in i)\n"
+"{\n"
+"    const float3 l_pos = float3(5.0, 5.0, 10.0);\n"
+"    float3 dir, normal;\n"
+"    float4 position;\n"
+"    struct vs_out o;\n"
+"    float att;\n"
+"\n"
+"    position.x = i.transform.x * i.position.x - i.transform.y * i.position.y + i.transform.z;\n"
+"    position.y = i.transform.x * i.position.y + i.transform.y * i.position.x + i.transform.w;\n"
+"    position.zw = i.position.zw;\n"
+"\n"
+"    o.position = mul(mvp_matrix, position);\n"
+"    dir = normalize(l_pos - o.position.xyz / o.position.w);\n"
+"\n"
+"    normal.x = i.transform.x * i.normal.x - i.transform.y * i.normal.y;\n"
+"    normal.y = i.transform.x * i.normal.y + i.transform.y * i.normal.x;\n"
+"    normal.z = i.normal.z;\n"
+"    att = 0.2 + dot(dir, normalize(mul(normal_matrix, normal)));\n"
+"\n"
+"    o.colour.xyz = i.diffuse.xyz * att;\n"
+"    o.colour.w = 1.0;\n"
+"\n"
+"    return o;\n"
+"}\n"
+"\n"
+"float4 ps_main_smooth(float4 position : SV_POSITION, float4 colour : COLOR) : SV_TARGET\n"
+"{\n"
+"    return colour;\n"
+"}\n"
+"\n"
+"float4 ps_main_flat(float4 position : SV_POSITION, nointerpolation float4 colour : COLOR) : SV_TARGET\n"
+"{\n"
+"    return colour;\n"
+"}\n";

demos/gears_smooth.frag

@@ -1,10 +0,0 @@
-#version 150
-#extension GL_ARB_separate_shader_objects : enable
-
-layout(location = 0) in vec4 colour_in;
-layout(location = 0) out vec4 colour_out;
-
-void main(void)
-{
-    colour_out = colour_in;
-}

demos/triangle.c

@@ -1,23 +1,19 @@
 /*
  * Copyright 2016 Henri Verbeet for CodeWeavers
  *
- * Permission is hereby granted, free of charge, to any person obtaining a
+ * This library is free software; you can redistribute it and/or
- * copy of this software and associated documentation files (the "Software"),
+ * modify it under the terms of the GNU Lesser General Public
- * to deal in the Software without restriction, including without limitation
+ * License as published by the Free Software Foundation; either
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * version 2.1 of the License, or (at your option) any later version.
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
  *
- * The above copyright notice and this permission notice shall be included in
+ * This library is distributed in the hope that it will be useful,
- * all copies or substantial portions of the Software.
+ * 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.
  *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * You should have received a copy of the GNU Lesser General Public
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * License along with this library; if not, write to the Free Software
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
  */
 
 /*
@@ -49,6 +45,8 @@
 #include <assert.h>
 #include "demo.h"
 
+#include "triangle_hlsl.h"
+
 struct cxt_fence
 {
     ID3D12Fence *fence;
@@ -74,7 +72,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;
@@ -143,7 +141,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);
     }
 
@@ -240,16 +239,6 @@ static void cxt_destroy_assets(struct cx_triangle *cxt)
     ID3D12RootSignature_Release(cxt->root_signature);
 }
 
-static void cxt_load_shaders(struct cx_triangle *cxt, D3D12_SHADER_BYTECODE *vs, D3D12_SHADER_BYTECODE *ps)
-{
-    bool ret;
-
-    ret = demo_load_shader(&cxt->demo, L"triangle.hlsl", "vs_main", "vs_5_0", "triangle.vert.spv", vs);
-    assert(ret);
-    ret = demo_load_shader(&cxt->demo, L"triangle.hlsl", "ps_main", "ps_5_0", "triangle.frag.spv", ps);
-    assert(ret);
-}
-
 static void cxt_fence_create(struct cxt_fence *fence, ID3D12Device *device)
 {
     HRESULT hr;
@@ -287,6 +276,7 @@ static void cxt_load_assets(struct cx_triangle *cxt)
     D3D12_RESOURCE_DESC resource_desc;
     D3D12_HEAP_PROPERTIES heap_desc;
     D3D12_RANGE read_range = {0, 0};
+    ID3DBlob *vs, *ps;
     HRESULT hr;
     void *data;
 
@@ -295,11 +285,19 @@ static void cxt_load_assets(struct cx_triangle *cxt)
     hr = demo_create_root_signature(cxt->device, &root_signature_desc, &cxt->root_signature);
     assert(SUCCEEDED(hr));
 
+    hr = D3DCompile(triangle_hlsl, strlen(triangle_hlsl), NULL, NULL, NULL, "vs_main", "vs_5_0", 0, 0, &vs, NULL);
+    assert(SUCCEEDED(hr));
+    hr = D3DCompile(triangle_hlsl, strlen(triangle_hlsl), NULL, NULL, NULL, "ps_main", "ps_5_0", 0, 0, &ps, NULL);
+    assert(SUCCEEDED(hr));
+
     memset(&pso_desc, 0, sizeof(pso_desc));
     pso_desc.InputLayout.pInputElementDescs = il_desc;
     pso_desc.InputLayout.NumElements = ARRAY_SIZE(il_desc);
     pso_desc.pRootSignature = cxt->root_signature;
-    cxt_load_shaders(cxt, &pso_desc.VS, &pso_desc.PS);
+    pso_desc.VS.pShaderBytecode = ID3D10Blob_GetBufferPointer(vs);
+    pso_desc.VS.BytecodeLength = ID3D10Blob_GetBufferSize(vs);
+    pso_desc.PS.pShaderBytecode = ID3D10Blob_GetBufferPointer(ps);
+    pso_desc.PS.BytecodeLength = ID3D10Blob_GetBufferSize(ps);
     demo_rasterizer_desc_init_default(&pso_desc.RasterizerState);
     demo_blend_desc_init_default(&pso_desc.BlendState);
     pso_desc.DepthStencilState.DepthEnable = FALSE;
@@ -313,8 +311,8 @@ static void cxt_load_assets(struct cx_triangle *cxt)
             &IID_ID3D12PipelineState, (void **)&cxt->pipeline_state);
     assert(SUCCEEDED(hr));
 
-    free((void *)pso_desc.PS.pShaderBytecode);
+    ID3D10Blob_Release(vs);
-    free((void *)pso_desc.VS.pShaderBytecode);
+    ID3D10Blob_Release(ps);
 
     hr = ID3D12Device_CreateCommandList(cxt->device, 0, D3D12_COMMAND_LIST_TYPE_DIRECT, cxt->command_allocator,
             cxt->pipeline_state, &IID_ID3D12GraphicsCommandList, (void **)&cxt->command_list);