Release 1.1.

Signed-off-by: Józef Kucia <jkucia@codeweavers.com>
Signed-off-by: Henri Verbeet <hverbeet@codeweavers.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>

ANNOUNCE

@@ -1,16 +1,16 @@
-The Wine team is proud to announce that release 1.0 of vkd3d, the
+The Wine team is proud to announce that release 1.1 of vkd3d, the
 Direct3D 12 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:
+
+  - Initial support for placed resources.
+  - MoltenVK support.
+  - Support for geometry shaders.
 
 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.1.tar.xz
 
 The current source can also be pulled directly from the git repository:
 
@@ -21,70 +21,65 @@ for the complete list.
 
 ----------------------------------------------------------------
 
-What's included in vkd3d 1.0
-============================
+What's new in vkd3d 1.1
+=======================
 
 
 *** 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.
+- Initial support for memory heaps and placed resources.
 
-- 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.
+- Improved support for resource views.
+
+- ClearUnorderedAccessViewUint() is implemented for textures.
+
+- Blend factor is implemented.
+
+- Performance improvements.
+
+- A new interface is available for enabling additional Vulkan instance
+  extensions.
+
+- A new public function is available for mapping VkFormats to DXGI_FORMATs.
+
+- Support for more DXGI formats.
+
+- 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.
+- Support for geometry shaders.
 
-- 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.
+- Pretty printing is implemented for shader code extracted from DXBC.
 
-- 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.
+- Clip and cull distances are supported.
 
-- Root signature serialization and deserialization is implemented.
+- Support for more shader instructions:
+  - round_ne,
+  - sincos,
+  - ineg,
+  - continue,
+  - continuec,
+  - gather4_po,
+  - gather4_po_c,
+  - gather4_c.
 
-- Shader model 4 and 5 bytecode parser is imported from wined3d.
+- Texel offsets are supported.
 
-- Shader model 5.1 is not supported yet.
+- Various shader translation fixes.
 
 
 *** libvkd3d-utils
 
-- libvkd3d-utils contains simple implementations of various functions which
-  might be useful for source ports of Direct3D 12 applications.
+- Vulkan WSI extensions are detected at runtime.
 
 
-*** demos
+*** build
+
+- Demos are not built by default.
+
+- libxcb is now an optional dependency required only for demos.
+
+- MoltenVK is supported.
 
-- A simple hello triangle Direct3D 12 demo.
-- A Direct3D 12 port of glxgears.

AUTHORS

@@ -1,2 +1,4 @@
+Chip Davis
 Henri Verbeet
 Józef Kucia
+Sven Hesse

Makefile.am

@@ -68,10 +68,11 @@ libvkd3d_shader_la_SOURCES = \
 	include/private/vkd3d_shader.h \
 	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_CFLAGS = $(AM_CFLAGS) @SPIRV_TOOLS_CFLAGS@
 libvkd3d_shader_la_LIBADD = @SPIRV_TOOLS_LIBS@
 if HAVE_LD_VERSION_SCRIPT
 libvkd3d_shader_la_LDFLAGS = -Wl,--version-script=$(srcdir)/libs/vkd3d-shader/vkd3d_shader.map
@@ -93,8 +94,9 @@ libvkd3d_la_SOURCES = \
 	libs/vkd3d/vkd3d.map \
 	libs/vkd3d/vkd3d_main.c \
 	libs/vkd3d/vkd3d_private.h \
-	libs/vkd3d/vulkan_procs.h
-libvkd3d_la_LDFLAGS = -version-info 1:0:0
+	libs/vkd3d/vulkan_procs.h \
+	libs/vkd3d_version.c
+libvkd3d_la_LDFLAGS = -version-info 2:0:1
 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
@@ -104,7 +106,7 @@ 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_LDFLAGS = -version-info 1:1:0
 libvkd3d_utils_la_LIBADD = libvkd3d-common.la libvkd3d.la
 if HAVE_LD_VERSION_SCRIPT
 libvkd3d_utils_la_LDFLAGS += -Wl,--version-script=$(srcdir)/libs/vkd3d-utils/vkd3d_utils.map
@@ -129,16 +131,19 @@ TESTS = $(vkd3d_tests) $(vkd3d_cross_tests)
 tests_d3d12_LDADD = $(LDADD) @PTHREAD_LIBS@
 tests_vkd3d_api_LDADD = libvkd3d.la @VULKAN_LIBS@
 
+if BUILD_DEMOS
 DEMOS_LDADD = $(LDADD) libvkd3d-shader.la @XCB_LIBS@ @VULKAN_LIBS@
-DEMOS_CFLAGS = @XCB_CFLAGS@
+DEMOS_CFLAGS = $(AM_CFLAGS) @XCB_CFLAGS@
 noinst_PROGRAMS += $(vkd3d_demos)
-EXTRA_DIST += $(vkd3d_test_headers) $(vkd3d_demos_headers)
 
 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@)
@@ -148,16 +153,17 @@ vkd3d_v_widl_1 =
 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 $@.tmp $<
+	$(AM_V_at)$(SED) -e '/#include <rpc.h>/d' -e '/#include <rpcndr.h>/d' <$@.tmp >$@
+	$(AM_V_at)$(RM) $@.tmp
 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' \
+	$(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' \
@@ -165,13 +171,21 @@ libvkd3d-utils.pc: $(srcdir)/libs/vkd3d-utils/libvkd3d-utils.pc.in
 		$< > $@
 
 libvkd3d.pc: $(srcdir)/libs/vkd3d/libvkd3d.pc.in
-	sed -e 's![@]prefix[@]!$(prefix)!g' \
+	$(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' \
 		$< > $@
 
+libs/vkd3d_version.c: dummy-vkd3d-version
+	$(AM_V_GEN)version=`(GIT_DIR=$(top_srcdir)/.git git describe HEAD 2>/dev/null || echo "vkd3d-$(PACKAGE_VERSION)") | $(SED) -n -e '$$s/\(.*\)/const char vkd3d_build[] = "\1";/p'` && (echo $$version | cmp -s - $@) || echo $$version >$@ || ($(RM) $@ && exit 1)
+.SILENT: libs/vkd3d_version.c
+CLEANFILES += libs/vkd3d_version.c
+
+.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

configure.ac

@@ -1,16 +1,17 @@
 AC_PREREQ([2.69])
-AC_INIT([vkd3d],[1.0])
+AC_INIT([vkd3d],[1.1])
 
 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)]))
 
 AC_USE_SYSTEM_EXTENSIONS
 
@@ -76,17 +77,24 @@ AC_CHECK_LIB([pthread], [pthread_create],
              [AC_MSG_ERROR([libpthread not found.])])
 
 AC_SUBST([VULKAN_LIBS])
-AC_CHECK_LIB([vulkan], [vkGetInstanceProcAddr],
+VKD3D_CHECK_SONAME([vulkan], [vkGetInstanceProcAddr],
                    [VULKAN_LIBS="-lvulkan"],
-             [AC_MSG_ERROR([libvulkan not found.])])
+                   [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 +102,13 @@ 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"], [enable_demos=no])
+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([HAVE_WIDL], [test "x$WIDL" != "xno"])
 AM_CONDITIONAL([HAVE_CROSSTARGET32], [test "x$CROSSTARGET32" != "xno"])
 AM_CONDITIONAL([HAVE_CROSSTARGET64], [test "x$CROSSTARGET64" != "xno"])
@@ -108,7 +123,10 @@ AS_IF([test "x$CROSSTARGET32" != "xno" -o "x$CROSSTARGET64" != "xno"],
 AS_ECHO(["
   Configuration summary for $PACKAGE $VERSION
 
-  Have SPIRV-Tools: ${HAVE_SPIRV_TOOLS}
+  Have XCB: ${HAVE_XCB}
+  Have SPIRV-Tools: ${with_spirv_tools}
+
+  Building demos: ${enable_demos}
 
   Building crosstests: ${HAVE_CROSSTEST}"])
 AS_IF([test "x$CROSSTARGET32" != "xno"], [AS_ECHO(["    Using 32-bit cross compiler: $CROSSCC32"])])

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,

include/private/vkd3d_shader.h

@@ -119,15 +119,22 @@ struct vkd3d_shader_interface
      *
      * In Vulkan OpImageFetch must be used with a sampled image.
      */
-    struct vkd3d_shader_descriptor_binding default_sampler;
+    struct vkd3d_shader_descriptor_binding dummy_sampler;
 
     const struct vkd3d_shader_uav_counter_binding *uav_counters;
     unsigned int uav_counter_count;
 };
 
+struct vkd3d_shader_compile_arguments
+{
+    unsigned int *output_swizzles;
+    unsigned int output_swizzle_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);
+        const struct vkd3d_shader_interface *shader_interface,
+        const struct vkd3d_shader_compile_arguments *compile_args);
 void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *code);
 
 enum vkd3d_filter
@@ -390,6 +397,20 @@ struct vkd3d_shader_signature_element *vkd3d_shader_find_signature_element(
         unsigned int semantic_index, unsigned int stream_index);
 void vkd3d_shader_free_shader_signature(struct vkd3d_shader_signature *signature);
 
+/* swizzle bits fields: wwzzyyxx */
+#define VKD3D_SWIZZLE_X (0u)
+#define VKD3D_SWIZZLE_Y (1u)
+#define VKD3D_SWIZZLE_Z (2u)
+#define VKD3D_SWIZZLE_W (3u)
+#define VKD3D_SWIZZLE_MASK (0x3u)
+#define VKD3D_SWIZZLE_SHIFT(idx) (2u * (idx))
+#define VKD3D_SWIZZLE(x, y, z, w) (((x & VKD3D_SWIZZLE_MASK) << VKD3D_SWIZZLE_SHIFT(0)) \
+        | ((y & VKD3D_SWIZZLE_MASK) << VKD3D_SWIZZLE_SHIFT(1)) \
+        | ((z & VKD3D_SWIZZLE_MASK) << VKD3D_SWIZZLE_SHIFT(2)) \
+        | ((w & VKD3D_SWIZZLE_MASK) << VKD3D_SWIZZLE_SHIFT(3)))
+#define VKD3D_NO_SWIZZLE \
+        VKD3D_SWIZZLE(VKD3D_SWIZZLE_X, VKD3D_SWIZZLE_Y, VKD3D_SWIZZLE_Z, VKD3D_SWIZZLE_W)
+
 #ifdef __cplusplus
 }
 #endif  /* __cplusplus */

include/private/vkd3d_test.h

@@ -90,6 +90,12 @@ 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)
 {

include/vkd3d.h

@@ -40,6 +40,8 @@ enum vkd3d_structure_type
     VKD3D_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
     VKD3D_STRUCTURE_TYPE_IMAGE_RESOURCE_CREATE_INFO,
 
+    VKD3D_STRUCTURE_TYPE_OPTIONAL_INSTANCE_EXTENSIONS_INFO,
+
     VKD3D_FORCE_32_BIT_ENUM(VKD3D_STRUCTURE_TYPE),
 };
 
@@ -69,6 +71,15 @@ struct vkd3d_instance_create_info
     uint32_t instance_extension_count;
 };
 
+struct vkd3d_optional_instance_extensions_info
+{
+    enum vkd3d_structure_type type;
+    const void *next;
+
+    const char * const *extensions;
+    uint32_t extension_count;
+};
+
 struct vkd3d_device_create_info
 {
     enum vkd3d_structure_type type;
@@ -133,6 +144,7 @@ HRESULT vkd3d_serialize_root_signature(const D3D12_ROOT_SIGNATURE_DESC *desc,
 HRESULT vkd3d_create_root_signature_deserializer(const void *data, SIZE_T data_size,
         REFIID iid, void **deserializer);
 
+DXGI_FORMAT vkd3d_get_dxgi_format(VkFormat format);
 VkFormat vkd3d_get_vk_format(DXGI_FORMAT format);
 
 #endif  /* VKD3D_NO_PROTOTYPES */

include/vkd3d_d3d12.idl

@@ -30,6 +30,8 @@ const UINT D3D12_MAX_ROOT_COST = 64;
 const UINT D3D12_VIEWPORT_BOUNDS_MAX = 32767;
 const UINT D3D12_VIEWPORT_BOUNDS_MIN = -32768;
 
+const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNT = 15;
+
 const UINT D3D12_APPEND_ALIGNED_ELEMENT = 0xffffffff;
 cpp_quote("#define D3D12_DEFAULT_BLEND_FACTOR_ALPHA (1.0f)")
 cpp_quote("#define D3D12_DEFAULT_BLEND_FACTOR_BLUE (1.0f)")
@@ -53,9 +55,15 @@ const UINT D3D12_REQ_TEXTURECUBE_DIMENSION = 16384;
 const UINT D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES = 0xffffffff;
 const UINT D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT = 8;
 const UINT D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT = 256;
+const UINT D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT = 4194304;
 const UINT D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT = 65536;
+const UINT D3D12_RAW_UAV_SRV_BYTE_ALIGNMENT = 16;
+const UINT D3D12_SMALL_MSAA_RESOURCE_PLACEMENT_ALIGNMENT = 65536;
+const UINT D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT = 4096;
+const UINT D3D12_STANDARD_MAXIMUM_ELEMENT_ALIGNMENT_BYTE_MULTIPLE = 4;
 const UINT D3D12_TEXTURE_DATA_PITCH_ALIGNMENT = 256;
 const UINT D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT = 512;
+const UINT D3D12_UAV_COUNTER_PLACEMENT_ALIGNMENT = 4096;
 const UINT D3D12_VS_INPUT_REGISTER_COUNT = 32;
 const UINT D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE = 16;
 
@@ -945,7 +953,7 @@ typedef struct D3D12_TEXCUBE_ARRAY_SRV
 {
     UINT MostDetailedMip;
     UINT MipLevels;
-    UINT First2DArraySlice;
+    UINT First2DArrayFace;
     UINT NumCubes;
     FLOAT ResourceMinLODClamp;
 } D3D12_TEXCUBE_ARRAY_SRV;
@@ -1516,14 +1524,38 @@ typedef struct D3D12_FEATURE_DATA_FEATURE_LEVELS
     D3D_FEATURE_LEVEL MaxSupportedFeatureLevel;
 } D3D12_FEATURE_DATA_FEATURE_LEVELS;
 
+typedef struct D3D12_FEATURE_DATA_ROOT_SIGNATURE
+{
+    D3D_ROOT_SIGNATURE_VERSION HighestVersion;
+} D3D12_FEATURE_DATA_ROOT_SIGNATURE;
+
+typedef enum D3D_SHADER_MODEL
+{
+    D3D_SHADER_MODEL_5_1 = 0x51,
+    D3D_SHADER_MODEL_6_0 = 0x60,
+} D3D_SHADER_MODEL;
+
+typedef struct D3D12_FEATURE_DATA_SHADER_MODEL
+{
+    D3D_SHADER_MODEL HighestShaderModel;
+} D3D12_FEATURE_DATA_SHADER_MODEL;
+
 typedef enum D3D12_FEATURE
 {
     D3D12_FEATURE_D3D12_OPTIONS = 0,
     D3D12_FEATURE_ARCHITECTURE = 1,
     D3D12_FEATURE_FEATURE_LEVELS = 2,
     D3D12_FEATURE_FORMAT_SUPPORT = 3,
-    D3D12_FEATURE_FORMAT_INFO = 4,
-    D3D12_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT = 5,
+    D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS = 4,
+    D3D12_FEATURE_FORMAT_INFO = 5,
+    D3D12_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT = 6,
+    D3D12_FEATURE_SHADER_MODEL = 7,
+    D3D12_FEATURE_D3D12_OPTIONS1 = 8,
+    D3D12_FEATURE_ROOT_SIGNATURE = 12,
+    D3D12_FEATURE_ARCHITECTURE1 = 16,
+    D3D12_FEATURE_D3D12_OPTIONS2 = 18,
+    D3D12_FEATURE_SHADER_CACHE = 19,
+    D3D12_FEATURE_COMMAND_QUEUE_PRIORITY = 20,
 } D3D12_FEATURE;
 
 typedef struct D3D12_MEMCPY_DEST
@@ -1575,6 +1607,17 @@ interface ID3D12Pageable : ID3D12DeviceChild
 {
 }
 
+[
+    uuid(6b3b2502-6e51-45b3-90ee-9884265e8df3),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Heap : ID3D12Pageable
+{
+    D3D12_HEAP_DESC GetDesc();
+}
+
 [
     uuid(696442be-a72e-4059-bc79-5b5c98040fad),
     object,
@@ -2172,7 +2215,12 @@ interface ID3D12RootSignatureDeserializer : IUnknown
         const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *root_signature_desc,
         ID3DBlob **blob, ID3DBlob **error_blob);
 
+typedef HRESULT (__stdcall *PFN_D3D12_CREATE_DEVICE)(IUnknown *adapter,
+        D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device);
+
 [local] HRESULT __stdcall D3D12CreateDevice(IUnknown *adapter,
         D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device);
 
+typedef HRESULT (__stdcall *PFN_D3D12_GET_DEBUG_INTERFACE)(REFIID iid, void **debug);
+
 [local] HRESULT __stdcall D3D12GetDebugInterface(REFIID iid, void **debug);

include/vkd3d_d3dcommon.idl

@@ -28,6 +28,42 @@ typedef enum D3D_PRIMITIVE_TOPOLOGY
     D3D_PRIMITIVE_TOPOLOGY_LINESTRIP = 3,
     D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST = 4,
     D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP = 5,
+    D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ = 10,
+    D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ = 11,
+    D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ = 12,
+    D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ = 13,
+    D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST = 33,
+    D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST,
+    D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST,
 } D3D_PRIMITIVE_TOPOLOGY;
 
 typedef enum D3D_FEATURE_LEVEL

libs/.gitignore

@@ -0,0 +1 @@
+vkd3d_version.c

libs/vkd3d-shader/dxbc.c

@@ -56,6 +56,9 @@
 #define VKD3D_SM4_GLOBAL_FLAGS_SHIFT          11
 #define VKD3D_SM4_GLOBAL_FLAGS_MASK           (0xffu << VKD3D_SM4_GLOBAL_FLAGS_SHIFT)
 
+#define VKD3D_SM5_PRECISE_SHIFT               19
+#define VKD3D_SM5_PRECISE_MASK                (0xfu << VKD3D_SM5_PRECISE_SHIFT)
+
 #define VKD3D_SM5_CONTROL_POINT_COUNT_SHIFT   11
 #define VKD3D_SM5_CONTROL_POINT_COUNT_MASK    (0xffu << VKD3D_SM5_CONTROL_POINT_COUNT_SHIFT)
 
@@ -292,6 +295,7 @@ enum vkd3d_sm4_opcode
     VKD3D_SM5_OP_IMM_ATOMIC_UMAX                  = 0xbc,
     VKD3D_SM5_OP_IMM_ATOMIC_UMIN                  = 0xbd,
     VKD3D_SM5_OP_SYNC                             = 0xbe,
+    VKD3D_SM5_OP_EVAL_SAMPLE_INDEX                = 0xcc,
     VKD3D_SM5_OP_DCL_GS_INSTANCES                 = 0xce,
 };
 
@@ -309,6 +313,7 @@ enum vkd3d_sm4_register_type
     VKD3D_SM4_RT_PRIMID                  = 0x0b,
     VKD3D_SM4_RT_DEPTHOUT                = 0x0c,
     VKD3D_SM4_RT_NULL                    = 0x0d,
+    VKD3D_SM4_RT_RASTERIZER              = 0x0e,
     VKD3D_SM4_RT_OMASK                   = 0x0f,
     VKD3D_SM5_RT_STREAM                  = 0x10,
     VKD3D_SM5_RT_FUNCTION_BODY           = 0x11,
@@ -328,6 +333,8 @@ enum vkd3d_sm4_register_type
     VKD3D_SM5_RT_COVERAGE                = 0x23,
     VKD3D_SM5_RT_LOCAL_THREAD_INDEX      = 0x24,
     VKD3D_SM5_RT_GS_INSTANCE_ID          = 0x25,
+    VKD3D_SM5_RT_DEPTHOUT_GREATER_EQUAL  = 0x26,
+    VKD3D_SM5_RT_DEPTHOUT_LESS_EQUAL     = 0x27,
 };
 
 enum vkd3d_sm4_output_primitive_type
@@ -1100,6 +1107,7 @@ static const struct vkd3d_sm4_opcode_info opcode_table[] =
     {VKD3D_SM5_OP_IMM_ATOMIC_UMIN,                  VKD3DSIH_IMM_ATOMIC_UMIN,                  "uU",   "iu"},
     {VKD3D_SM5_OP_SYNC,                             VKD3DSIH_SYNC,                             "",     "",
             shader_sm5_read_sync},
+    {VKD3D_SM5_OP_EVAL_SAMPLE_INDEX,                VKD3DSIH_EVAL_SAMPLE_INDEX,                "f",    "fi"},
     {VKD3D_SM5_OP_DCL_GS_INSTANCES,                 VKD3DSIH_DCL_GS_INSTANCES,                 "",     "",
             shader_sm4_read_declaration_count},
 };
@@ -1120,7 +1128,7 @@ static const enum vkd3d_shader_register_type register_type_table[] =
     /* VKD3D_SM4_RT_PRIMID */                  VKD3DSPR_PRIMID,
     /* VKD3D_SM4_RT_DEPTHOUT */                VKD3DSPR_DEPTHOUT,
     /* VKD3D_SM4_RT_NULL */                    VKD3DSPR_NULL,
-    /* UNKNOWN */                              ~0u,
+    /* VKD3D_SM4_RT_RASTERIZER */              VKD3DSPR_RASTERIZER,
     /* VKD3D_SM4_RT_OMASK */                   VKD3DSPR_SAMPLEMASK,
     /* VKD3D_SM5_RT_STREAM */                  VKD3DSPR_STREAM,
     /* VKD3D_SM5_RT_FUNCTION_BODY */           VKD3DSPR_FUNCTIONBODY,
@@ -1144,6 +1152,8 @@ static const enum vkd3d_shader_register_type register_type_table[] =
     /* VKD3D_SM5_RT_COVERAGE */                VKD3DSPR_COVERAGE,
     /* VKD3D_SM5_RT_LOCAL_THREAD_INDEX */      VKD3DSPR_LOCALTHREADINDEX,
     /* VKD3D_SM5_RT_GS_INSTANCE_ID */          VKD3DSPR_GSINSTID,
+    /* VKD3D_SM5_RT_DEPTHOUT_GREATER_EQUAL */  VKD3DSPR_DEPTHOUTGE,
+    /* VKD3D_SM5_RT_DEPTHOUT_LESS_EQUAL */     VKD3DSPR_DEPTHOUTLE,
 };
 
 static const struct vkd3d_sm4_opcode_info *get_opcode_info(enum vkd3d_sm4_opcode opcode)
@@ -1475,18 +1485,18 @@ static BOOL shader_sm4_read_param(struct vkd3d_sm4_data *priv, const DWORD **ptr
                     WARN("Invalid ptr %p, end %p.\n", *ptr, end);
                     return FALSE;
                 }
-                memcpy(param->u.immconst_data, *ptr, 1 * sizeof(DWORD));
+                memcpy(param->u.immconst_uint, *ptr, 1 * sizeof(DWORD));
                 *ptr += 1;
                 break;
 
             case VKD3D_SM4_IMMCONST_VEC4:
                 param->immconst_type = VKD3D_IMMCONST_VEC4;
-                if (end - *ptr < 4)
+                if (end - *ptr < VKD3D_VEC4_SIZE)
                 {
                     WARN("Invalid ptr %p, end %p.\n", *ptr, end);
                     return FALSE;
                 }
-                memcpy(param->u.immconst_data, *ptr, 4 * sizeof(DWORD));
+                memcpy(param->u.immconst_uint, *ptr, VKD3D_VEC4_SIZE * sizeof(DWORD));
                 *ptr += 4;
                 break;
 
@@ -1521,7 +1531,7 @@ static BOOL shader_sm4_read_src_param(struct vkd3d_sm4_data *priv, const DWORD *
 
     if (src_param->reg.type == VKD3DSPR_IMMCONST)
     {
-        src_param->swizzle = VKD3DSP_NOSWIZZLE;
+        src_param->swizzle = VKD3D_NO_SWIZZLE;
     }
     else
     {
@@ -1531,7 +1541,7 @@ static BOOL shader_sm4_read_src_param(struct vkd3d_sm4_data *priv, const DWORD *
         switch (swizzle_type)
         {
             case VKD3D_SM4_SWIZZLE_NONE:
-                src_param->swizzle = VKD3DSP_NOSWIZZLE;
+                src_param->swizzle = VKD3D_NO_SWIZZLE;
                 break;
 
             case VKD3D_SM4_SWIZZLE_SCALAR:
@@ -1612,7 +1622,7 @@ static void shader_sm4_read_instruction_modifier(DWORD modifier, struct vkd3d_sh
 
     if (modifier & ~recognized_bits)
     {
-        FIXME("Unhandled modifier 0x%08x.\n", modifier);
+        WARN("Unhandled modifier 0x%08x.\n", modifier);
     }
     else
     {
@@ -1641,6 +1651,7 @@ void shader_sm4_read_instruction(void *data, const DWORD **ptr, struct vkd3d_sha
     unsigned int i, len;
     SIZE_T remaining;
     const DWORD *p;
+    DWORD precise;
 
     list_move_head(&priv->src_free, &priv->src);
 
@@ -1681,6 +1692,8 @@ void shader_sm4_read_instruction(void *data, const DWORD **ptr, struct vkd3d_sha
 
     ins->handler_idx = opcode_info->handler_idx;
     ins->flags = 0;
+    ins->coissue = false;
+    ins->predicate = NULL;
     ins->dst_count = strlen(opcode_info->dst_info);
     ins->dst = priv->dst_param;
     ins->src_count = strlen(opcode_info->src_info);
@@ -1703,12 +1716,13 @@ void shader_sm4_read_instruction(void *data, const DWORD **ptr, struct vkd3d_sha
             shader_sm4_read_instruction_modifier(previous_token = *p++, ins);
 
         ins->flags = (opcode_token & VKD3D_SM4_INSTRUCTION_FLAGS_MASK) >> VKD3D_SM4_INSTRUCTION_FLAGS_SHIFT;
-
         if (ins->flags & VKD3D_SM4_INSTRUCTION_FLAG_SATURATE)
         {
             ins->flags &= ~VKD3D_SM4_INSTRUCTION_FLAG_SATURATE;
             instruction_dst_modifier = VKD3DSPDM_SATURATE;
         }
+        precise = (opcode_token & VKD3D_SM5_PRECISE_MASK) >> VKD3D_SM5_PRECISE_SHIFT;
+        ins->flags |= precise << VKD3DSI_PRECISE_SHIFT;
 
         for (i = 0; i < ins->dst_count; ++i)
         {
@@ -2026,7 +2040,7 @@ static int shdr_handler(const char *data, DWORD data_size, DWORD tag, void *cont
             break;
 
         default:
-            FIXME("Unhandled chunk %#x.\n", tag);
+            TRACE("Skipping chunk %#x.\n", tag);
             break;
     }
 

libs/vkd3d-shader/vkd3d_shader_main.c

@@ -58,7 +58,8 @@ static void vkd3d_shader_parser_destroy(struct vkd3d_shader_parser *parser)
 
 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)
+        const struct vkd3d_shader_interface *shader_interface,
+        const struct vkd3d_shader_compile_arguments *compile_args)
 {
     struct vkd3d_shader_instruction instruction;
     struct vkd3d_dxbc_compiler *spirv_compiler;
@@ -66,8 +67,8 @@ int vkd3d_shader_compile_dxbc(const struct vkd3d_shader_code *dxbc,
     struct vkd3d_shader_parser parser;
     int ret;
 
-    TRACE("dxbc {%p, %zu}, spirv %p, compiler_options %#x, shader_interface %p.\n",
-            dxbc->code, dxbc->size, spirv, compiler_options, shader_interface);
+    TRACE("dxbc {%p, %zu}, spirv %p, compiler_options %#x, shader_interface %p, compile_args %p.\n",
+            dxbc->code, dxbc->size, spirv, compiler_options, shader_interface, compile_args);
 
     if ((ret = vkd3d_shader_scan_dxbc(dxbc, &scan_info)) < 0)
         return ret;
@@ -75,8 +76,11 @@ int vkd3d_shader_compile_dxbc(const struct vkd3d_shader_code *dxbc,
     if ((ret = vkd3d_shader_parser_init(&parser, dxbc)) < 0)
         return ret;
 
+    if (TRACE_ON())
+        vkd3d_shader_trace(parser.data);
+
     if (!(spirv_compiler = vkd3d_dxbc_compiler_create(&parser.shader_version,
-            &parser.shader_desc, compiler_options, shader_interface, &scan_info)))
+            &parser.shader_desc, compiler_options, shader_interface, compile_args, &scan_info)))
     {
         ERR("Failed to create DXBC compiler.\n");
         vkd3d_shader_parser_destroy(&parser);

libs/vkd3d-shader/vkd3d_shader_private.h

@@ -156,6 +156,7 @@ enum VKD3D_SHADER_INSTRUCTION_HANDLER
     VKD3DSIH_ENDREP,
     VKD3DSIH_ENDSWITCH,
     VKD3DSIH_EQ,
+    VKD3DSIH_EVAL_SAMPLE_INDEX,
     VKD3DSIH_EXP,
     VKD3DSIH_EXPP,
     VKD3DSIH_F16TOF32,
@@ -352,6 +353,9 @@ enum vkd3d_shader_register_type
     VKD3DSPR_COVERAGE,
     VKD3DSPR_SAMPLEMASK,
     VKD3DSPR_GSINSTID,
+    VKD3DSPR_DEPTHOUTGE,
+    VKD3DSPR_DEPTHOUTLE,
+    VKD3DSPR_RASTERIZER,
 
     VKD3DSPR_INVALID = ~0u,
 };
@@ -390,8 +394,6 @@ enum vkd3d_immconst_type
     VKD3D_IMMCONST_VEC4,
 };
 
-#define VKD3DSP_NOSWIZZLE (0u | (1u << 2) | (2u << 4) | (3u << 6))
-
 enum vkd3d_shader_src_modifier
 {
     VKD3DSPSM_NONE = 0,
@@ -438,6 +440,7 @@ enum vkd3d_shader_interpolation_mode
 enum vkd3d_shader_global_flags
 {
     VKD3DSGF_REFACTORING_ALLOWED               = 0x1,
+    VKD3DSGF_FORCE_EARLY_DEPTH_STENCIL         = 0x4,
     VKD3DSGF_ENABLE_RAW_AND_STRUCTURED_BUFFERS = 0x8,
 };
 
@@ -476,12 +479,23 @@ enum vkd3d_tessellator_partitioning
     VKD3D_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN = 4,
 };
 
+
+#define VKD3DSI_NONE                    0x0
+#define VKD3DSI_TEXLD_PROJECT           0x1
 #define VKD3DSI_INDEXED_DYNAMIC         0x4
 #define VKD3DSI_RESINFO_RCP_FLOAT       0x1
 #define VKD3DSI_RESINFO_UINT            0x2
 #define VKD3DSI_SAMPLE_INFO_UINT        0x1
 #define VKD3DSI_SAMPLER_COMPARISON_MODE 0x1
 
+#define VKD3DSI_PRECISE_X         0x100
+#define VKD3DSI_PRECISE_Y         0x200
+#define VKD3DSI_PRECISE_Z         0x400
+#define VKD3DSI_PRECISE_W         0x800
+#define VKD3DSI_PRECISE_XYZW      (VKD3DSI_PRECISE_X | VKD3DSI_PRECISE_Y \
+                                  | VKD3DSI_PRECISE_Z | VKD3DSI_PRECISE_W)
+#define VKD3DSI_PRECISE_SHIFT     8
+
 enum vkd3d_shader_rel_op
 {
     VKD3D_SHADER_REL_OP_GT = 1,
@@ -562,7 +576,8 @@ struct vkd3d_shader_register
     enum vkd3d_immconst_type immconst_type;
     union
     {
-        DWORD immconst_data[VKD3D_VEC4_SIZE];
+        DWORD immconst_uint[VKD3D_VEC4_SIZE];
+        float immconst_float[VKD3D_VEC4_SIZE];
         unsigned fp_body_idx;
     } u;
 };
@@ -732,6 +747,8 @@ struct vkd3d_shader_instruction
     const struct vkd3d_shader_dst_param *dst;
     const struct vkd3d_shader_src_param *src;
     struct vkd3d_shader_texel_offset texel_offset;
+    bool coissue;
+    const struct vkd3d_shader_src_param *predicate;
     union
     {
         struct vkd3d_shader_semantic semantic;
@@ -761,6 +778,13 @@ static inline BOOL vkd3d_shader_instruction_has_texel_offset(const struct vkd3d_
     return ins->texel_offset.u || ins->texel_offset.v || ins->texel_offset.w;
 }
 
+static inline bool vkd3d_shader_register_is_input(const struct vkd3d_shader_register *reg)
+{
+    return reg->type == VKD3DSPR_INPUT || reg->type == VKD3DSPR_INCONTROLPOINT;
+}
+
+void vkd3d_shader_trace(void *data) DECLSPEC_HIDDEN;
+
 void *shader_sm4_init(const DWORD *byte_code, size_t byte_code_size,
         const struct vkd3d_shader_signature *output_signature) DECLSPEC_HIDDEN;
 void shader_sm4_free(void *data) DECLSPEC_HIDDEN;
@@ -782,6 +806,7 @@ struct vkd3d_dxbc_compiler;
 struct vkd3d_dxbc_compiler *vkd3d_dxbc_compiler_create(const struct vkd3d_shader_version *shader_version,
         const struct vkd3d_shader_desc *shader_desc, uint32_t compiler_options,
         const struct vkd3d_shader_interface *shader_interface,
+        const struct vkd3d_shader_compile_arguments *compile_args,
         const struct vkd3d_shader_scan_info *scan_info) DECLSPEC_HIDDEN;
 void vkd3d_dxbc_compiler_handle_instruction(struct vkd3d_dxbc_compiler *compiler,
         const struct vkd3d_shader_instruction *instruction) DECLSPEC_HIDDEN;
@@ -852,11 +877,16 @@ static inline unsigned int vkd3d_write_mask_component_count(DWORD write_mask)
     return count;
 }
 
+static inline unsigned int vkd3d_write_mask_from_component_count(unsigned int component_count)
+{
+    assert(component_count <= 4);
+    return (VKD3DSP_WRITEMASK_0 << component_count) - 1;
+}
+
 static inline unsigned int vkd3d_swizzle_get_component(DWORD swizzle,
         unsigned int idx)
 {
-    /* swizzle bits fields: wwzzyyxx */
-    return (swizzle >> (2 * idx)) & 0x3;
+    return (swizzle >> VKD3D_SWIZZLE_SHIFT(idx)) & VKD3D_SWIZZLE_MASK;
 }
 
 #define VKD3D_DXBC_MAX_SOURCE_COUNT 6

libs/vkd3d-utils/vkd3d_utils_main.c

@@ -28,13 +28,18 @@ HRESULT WINAPI D3D12GetDebugInterface(REFIID iid, void **debug)
 HRESULT WINAPI D3D12CreateDevice(IUnknown *adapter,
         D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device)
 {
+    struct vkd3d_optional_instance_extensions_info optional_extensions_info;
     struct vkd3d_instance_create_info instance_create_info;
     struct vkd3d_device_create_info device_create_info;
 
     static const char * const instance_extensions[] =
     {
         VK_KHR_SURFACE_EXTENSION_NAME,
-        VK_KHR_XCB_SURFACE_EXTENSION_NAME,
+    };
+    static const char * const optional_instance_extensions[] =
+    {
+        "VK_KHR_xcb_surface",
+        "VK_MVK_macos_surface",
     };
     static const char * const device_extensions[] =
     {
@@ -47,9 +52,14 @@ HRESULT WINAPI D3D12CreateDevice(IUnknown *adapter,
     if (adapter)
         FIXME("Ignoring adapter %p.\n", adapter);
 
+    memset(&optional_extensions_info, 0, sizeof(optional_extensions_info));
+    optional_extensions_info.type = VKD3D_STRUCTURE_TYPE_OPTIONAL_INSTANCE_EXTENSIONS_INFO;
+    optional_extensions_info.extensions = optional_instance_extensions;
+    optional_extensions_info.extension_count = ARRAY_SIZE(optional_instance_extensions);
+
     memset(&instance_create_info, 0, sizeof(instance_create_info));
     instance_create_info.type = VKD3D_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
-    instance_create_info.next = NULL;
+    instance_create_info.next = &optional_extensions_info;
     instance_create_info.pfn_signal_event = vkd3d_signal_event;
     instance_create_info.wchar_size = sizeof(WCHAR);
     instance_create_info.instance_extensions = instance_extensions;

libs/vkd3d-utils/vkd3d_utils_private.h

@@ -19,16 +19,15 @@
 #ifndef __VKD3D_UTILS_PRIVATE_H
 #define __VKD3D_UTILS_PRIVATE_H
 
+#define COBJMACROS
+#define NONAMELESSUNION
 #define VK_NO_PROTOTYPES
-#define VK_USE_PLATFORM_XCB_KHR
 
 #include <pthread.h>
 #include <vkd3d.h>
 
-#define COBJMACROS
-#define NONAMELESSUNION
 #include "vkd3d_memory.h"
-#include "vkd3d_utils.h"
+#include <vkd3d_utils.h>
 
 struct vkd3d_event
 {