update dxvk to v1.7.3-25-g842115b4 (d3d11-funny-refcount)

.gitmodules

@@ -28,3 +28,6 @@
 [submodule "vkd3d-proton"]
 	path = vkd3d-proton
 	url = https://github.com/HansKristian-Work/vkd3d-proton
+[submodule "OpenXR-SDK"]
+	path = OpenXR-SDK
+	url = https://github.com/KhronosGroup/OpenXR-SDK

Makefile

@@ -172,3 +172,8 @@ vrclient: configure
 	vagrant ssh -c 'make -C $(BUILD_DIR)/ $(UNSTRIPPED) $(CCACHE_FLAG) vrclient && \
 		cp -f $(BUILD_DIR)/dist/dist/lib/wine/vrclient.dll.so /vagrant/vrclient/lib/wine && \
 		cp -f $(BUILD_DIR)/dist/dist/lib64/wine/vrclient_x64.dll.so /vagrant/vrclient/lib64/wine'
+
+wineopenxr: configure
+	mkdir -p vagrant_share/wineopenxr/lib64/wine
+	vagrant ssh -c 'make -C $(BUILD_DIR)/ $(UNSTRIPPED) $(CCACHE_FLAG) wineopenxr && \
+		cp -f $(BUILD_DIR)/dist/dist/lib64/wine/wineopenxr.dll.so /vagrant/wineopenxr/lib64/wine'

OpenXR-SDK

@@ -0,0 +1 @@
+Subproject commit 5197afbf199c026eca82a47a8573ed10b0c6fa4e

build/makefile_base.mak

@@ -238,6 +238,15 @@ LSTEAMCLIENT64 := ./syn-lsteamclient64/lsteamclient
 LSTEAMCLIENT_OBJ32 := ./obj-lsteamclient32
 LSTEAMCLIENT_OBJ64 := ./obj-lsteamclient64
 
+WINEOPENXR := $(SRCDIR)/wineopenxr
+WINEOPENXR64 := ./syn-wineopenxr64/wineopenxr
+WINEOPENXR_OBJ64 := ./obj-wineopenxr64
+WINEOPENXR_JSON64 := $(SRCDIR)/wineopenxr/wineopenxr64.json
+WINEOPENXR_FAKEDLL64 := $(WINEOPENXR_OBJ64)/wineopenxr.dll.fake
+
+OPENXR := $(SRCDIR)/OpenXR-SDK
+OPENXR_OBJ64 := ./obj-openxr64
+
 STEAMEXE_SRC := $(SRCDIR)/steam_helper
 STEAMEXE_OBJ := ./obj-steam
 STEAMEXE_SYN := ./syn-steam/steam
@@ -289,6 +298,8 @@ OBJ_DIRS := $(TOOLS_DIR32)        $(TOOLS_DIR64)        \
             $(FAUDIO_OBJ32)       $(FAUDIO_OBJ64)       \
             $(JXRLIB_OBJ32)       $(JXRLIB_OBJ64)       \
             $(LSTEAMCLIENT_OBJ32) $(LSTEAMCLIENT_OBJ64) \
+            $(WINEOPENXR_OBJ64) \
+            $(OPENXR_OBJ64) \
             $(STEAMEXE_OBJ)                             \
             $(WINE_OBJ32)         $(WINE_OBJ64)         \
             $(VRCLIENT_OBJ32)     $(VRCLIENT_OBJ64)     \
@@ -366,6 +377,8 @@ DIST_GECKO64 := $(DIST_GECKO_DIR)/wine-gecko-$(GECKO_VER)-x86_64
 DIST_WINEMONO_DIR := $(DST_DIR)/share/wine/mono
 DIST_WINEMONO := $(DIST_WINEMONO_DIR)/wine-mono-$(WINEMONO_VER)
 DIST_FONTS := $(DST_DIR)/share/fonts
+DIST_WINEOPENXR_JSON64 := $(DIST_PREFIX)/drive_c/openxr/wineopenxr64.json
+DIST_WINEOPENXR64 := $(DIST_PREFIX)/drive_c/windows/system32/wineopenxr.dll
 
 DIST_TARGETS := $(DIST_COPY_TARGETS) $(DIST_OVR32) $(DIST_OVR64) \
                 $(DIST_GECKO32) $(DIST_GECKO64) $(DIST_WINEMONO) \
@@ -444,19 +457,31 @@ $(DIST_FONTS): fonts
 	cp $(FONTS_OBJ)/*.ttf "$@"
 	cp $(FONTS_OBJ)/*.otf "$@"
 
+$(DIST_WINEOPENXR_JSON64): $(WINEOPENXR_JSON64)
+	mkdir -p $(dir $@)
+	cp -a $< $@
+
+$(DIST_WINEOPENXR64): wineopenxr64
+	mkdir -p $(dir $@)
+	cp -a $(WINEOPENXR_FAKEDLL64) $@
+
 .PHONY: dist
 
 ALL_TARGETS += dist
 GOAL_TARGETS += dist
 
-dist: $(DIST_TARGETS) wine gst_good vrclient lsteamclient steam dxvk vkd3d-proton mediaconv | $(DST_DIR)
+dist_prefix: wine gst_good
-	echo `date '+%s'` `GIT_DIR=$(abspath $(SRCDIR)/.git) git describe --tags` > $(DIST_VERSION)
-	cp $(DIST_VERSION) $(DST_BASE)/
 	find $(DST_DIR)/lib/wine -type f -execdir chmod a-w '{}' '+'
 	find $(DST_DIR)/lib64/wine -type f -execdir chmod a-w '{}' '+'
 	rm -rf $(abspath $(DIST_PREFIX))
 	python3 $(SRCDIR)/default_pfx.py $(abspath $(DIST_PREFIX)) $(abspath $(DST_DIR)) $(STEAM_RUNTIME_RUNSH)
 
+dist_wineopenxr: dist_prefix $(DIST_WINEOPENXR_JSON64) $(DIST_WINEOPENXR64)
+
+dist: $(DIST_TARGETS) vrclient lsteamclient wineopenxr steam dxvk vkd3d-proton mediaconv dist_wineopenxr | $(DST_DIR)
+	echo `date '+%s'` `GIT_DIR=$(abspath $(SRCDIR)/.git) git describe --tags` > $(DIST_VERSION)
+	cp $(DIST_VERSION) $(DST_BASE)/
+
 deploy: dist | $(filter-out dist deploy install redist,$(MAKECMDGOALS))
 	mkdir -p $(DEPLOY_DIR) && \
 	cp -a $(DEPLOY_COPY_TARGETS) $(DEPLOY_DIR) && \
@@ -1052,6 +1077,104 @@ lsteamclient32: $(LSTEAMCLIENT_CONFIGURE_FILES32) | $(WINE_BUILDTOOLS32) $(filte
 	mkdir -pv $(DST_DIR)/lib/wine/
 	cp -af $(LSTEAMCLIENT_OBJ32)/lsteamclient.dll.so $(DST_DIR)/lib/wine/
 
+
+##
+## openxr
+## Note 32-bit is not supported by SteamVR, so we don't build it.
+##
+
+OPENXR_CMAKE_FLAGS = -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_LIBDIR="lib"
+
+OPENXR_TARGETS = openxr openxr64
+
+ALL_TARGETS += $(OPENXR_TARGETS)
+GOAL_TARGETS_LIBS += openxr
+
+.PHONY: openxr openxr64
+
+openxr: openxr64
+
+OPENXR_CONFIGURE_FILES64 := $(OPENXR_OBJ64)/Makefile
+
+$(OPENXR_CONFIGURE_FILES64): SHELL = $(CONTAINER_SHELL64)
+$(OPENXR_CONFIGURE_FILES64): $(OPENXR)/CMakeLists.txt $(MAKEFILE_DEP) | $(OPENXR_OBJ64)
+	cd $(dir $@) && \
+		CFLAGS="$(OPTIMIZE_FLAGS)" \
+		cmake $(abspath $(OPENXR)) \
+			-DCMAKE_INSTALL_PREFIX="$(abspath $(TOOLS_DIR64))" \
+			$(OPENXR_CMAKE_FLAGS)
+
+openxr64: SHELL = $(CONTAINER_SHELL64)
+openxr64: $(OPENXR_CONFIGURE_FILES64)
+	+$(MAKE) -C $(OPENXR_OBJ64) VERBOSE=1
+	+$(MAKE) -C $(OPENXR_OBJ64) install VERBOSE=1
+	mkdir -p $(DST_DIR)/lib64
+	cp -a $(TOOLS_DIR64)/lib/libopenxr_loader* $(DST_DIR)/lib64/
+	[ x"$(STRIP)" = x ] || $(STRIP) $(DST_DIR)/lib64/libopenxr_loader.so
+
+##
+## wineopenxr
+## Note 32-bit is not supported by SteamVR, so we don't build it.
+##
+
+# The source directory for wineopenxr is a synthetic symlink clone of the source directory, because we need to run
+# winemaker in tree and it can stomp itself in parallel builds.
+$(WINEOPENXR64)/.created: $(WINEOPENXR) $(MAKEFILE_DEP)
+	rm -rf ./$(WINEOPENXR64)
+	mkdir -p $(WINEOPENXR64)/
+	cd $(WINEOPENXR64)/ && ln -sfv ../../$(WINEOPENXR)/* .
+	touch $@
+
+$(WINEOPENXR64): $(WINEOPENXR64)/.created
+
+## Create & configure object directory for wineopenxr
+
+WINEOPENXR_CONFIGURE_FILES64 := $(WINEOPENXR_OBJ64)/Makefile
+
+# 64bit-configure
+$(WINEOPENXR_CONFIGURE_FILES64): SHELL = $(CONTAINER_SHELL64)
+$(WINEOPENXR_CONFIGURE_FILES64): $(WINEOPENXR64) $(MAKEFILE_DEP) | $(WINEOPENXR_OBJ64) $(WINEMAKER)
+	cd $(dir $@) && \
+		$(WINEMAKER) --nosource-fix --nolower-include --nodlls --nomsvcrt \
+			-I"../$(TOOLS_DIR64)"/include/ \
+			-I"../$(TOOLS_DIR64)"/include/wine/ \
+			-I"../$(TOOLS_DIR64)"/include/wine/windows/ \
+			-I"../$(WINE)"/include/ \
+			-I"$(abspath $(OPENXR))"/include/ \
+			-L"../$(TOOLS_DIR64)"/lib/ \
+			-l"openxr_loader" \
+			-l"dxgi" \
+			-l"vulkan" \
+			--dll ../$(WINEOPENXR64) && \
+		cp ../$(WINEOPENXR64)/Makefile . && \
+		echo >> ./Makefile 'SRCDIR := ../$(WINEOPENXR64)' && \
+		echo >> ./Makefile 'vpath % $$(SRCDIR)' && \
+		echo >> ./Makefile 'wineopenxr_dll_LDFLAGS := -ldl $$(patsubst %.spec,$$(SRCDIR)/%.spec,$$(wineopenxr_dll_LDFLAGS))'
+
+#			-L"../$(TOOLS_DIR64)"/lib64/wine/ \
+## wineopenxr goals
+WINEOPENXR_TARGETS = wineopenxr wineopenxr_configure wineopenxr64 wineopenxr_configure64
+
+ALL_TARGETS += $(WINEOPENXR_TARGETS)
+GOAL_TARGETS_LIBS += wineopenxr
+
+.PHONY: $(WINEOPENXR_TARGETS)
+
+wineopenxr_configure: $(WINEOPENXR_CONFIGURE_FILES64)
+
+wineopenxr_configure64: $(WINEOPENXR_CONFIGURE_FILES64)
+
+wineopenxr: wineopenxr64
+
+wineopenxr64: SHELL = $(CONTAINER_SHELL64)
+wineopenxr64: $(WINEOPENXR_CONFIGURE_FILES64) openxr64 | $(WINE_BUILDTOOLS64) $(filter $(MAKECMDGOALS),wine64 wine32 wine)
+	+env PATH="$(abspath $(TOOLS_DIR64))/bin:$(PATH)" CFLAGS="$(COMMON_FLAGS) -g" \
+		$(MAKE) -C $(WINEOPENXR_OBJ64)
+	$(TOOLS_DIR64)/bin/winebuild -m64 --dll --fake-module -E $(abspath $(WINEOPENXR))/wineopenxr.spec -o $(WINEOPENXR_OBJ64)/wineopenxr.dll.fake
+	[ x"$(STRIP)" = x ] || $(STRIP) $(WINEOPENXR_OBJ64)/wineopenxr.dll.so
+	mkdir -pv $(DST_DIR)/lib64/wine/
+	cp -af $(WINEOPENXR_OBJ64)/wineopenxr.dll.so $(DST_DIR)/lib64/wine/
+
 ## steam.exe
 
 $(STEAMEXE_SYN)/.created: $(STEAMEXE_SRC) $(MAKEFILE_DEP)
@@ -1322,7 +1445,7 @@ DXVK_CONFIGURE_FILES32 := $(DXVK_OBJ32)/build.ninja
 DXVK_CONFIGURE_FILES64 := $(DXVK_OBJ64)/build.ninja
 
 # 64bit-configure.  Remove coredata file if already configured (due to e.g. makefile changing)
-$(DXVK_CONFIGURE_FILES64): $(MAKEFILE_DEP) $(DXVK)/build-win64.txt | $(DXVK_OBJ64)
+$(DXVK_CONFIGURE_FILES64): $(MAKEFILE_DEP) $(DXVK)/build-win64.txt wineopenxr64 | $(DXVK_OBJ64)
 	if [ -e "$(abspath $(DXVK_OBJ64))"/build.ninja ]; then \
 		rm -f "$(abspath $(DXVK_OBJ64))"/meson-private/coredata.dat; \
 	fi

dxvk

@@ -1 +1 @@
-Subproject commit c1f23643f9c8e7bf8e9d6b3e6f07da29b1ae429d
+Subproject commit bf888351f22f8e4ebe832bdf1c3dba0475508c7c

proton

@@ -540,6 +540,9 @@ class CompatData:
             try_copy(g_proton.lib_dir + "wine/dxvk/openvr_api_dxvk.dll", self.prefix_dir + "/drive_c/windows/syswow64/")
             try_copy(g_proton.lib64_dir + "wine/dxvk/openvr_api_dxvk.dll", self.prefix_dir + "/drive_c/windows/system32/")
 
+            makedirs(self.prefix_dir + "/drive_c/openxr/")
+            try_copy(g_proton.default_pfx_dir + "drive_c/openxr/wineopenxr64.json", self.prefix_dir + "/drive_c/openxr/")
+
             if use_wined3d:
                 dxvkfiles = ["dxvk_config"]
                 wined3dfiles = ["d3d11", "d3d10", "d3d10core", "d3d10_1", "d3d9"]
@@ -603,7 +606,6 @@ class Session:
         self.dlloverrides = {
                 "steam.exe": "b", #always use our special built-in steam.exe
                 "dotnetfx35.exe": "b", #replace the broken installer, as does Windows
-                "mfplay": "n" #disable built-in mfplay
         }
 
         self.compat_config = set()

vkd3d-proton

@@ -1 +1 @@
-Subproject commit e2185df7de871cdd5eb9ccb946477dc95866f2cc
+Subproject commit d003424bc826afd005c68f8a8f0d42e4dae00fd0

wine

@@ -1 +1 @@
-Subproject commit 7f9f4285c2dfb81234c01996f6d33fae07701629
+Subproject commit 0a754ca2cd2b5321a1ebce5107f5e1c46a9730cd

wineopenxr/dxvk-interop.h

@@ -0,0 +1,362 @@
+/*** Autogenerated by WIDL 3.5 from /home/yorha-2b/Valve/Proton/wine/include/wine/dxvk-interop.idl - Do not edit ***/
+
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 475
+#endif
+
+#include <rpc.h>
+#include <rpcndr.h>
+
+#ifndef COM_NO_WINDOWS_H
+#include <windows.h>
+#include <ole2.h>
+#endif
+
+#ifndef __dxvk_interop_h__
+#define __dxvk_interop_h__
+
+/* Forward declarations */
+
+#ifndef __IDXGIVkInteropSurface_FWD_DEFINED__
+#define __IDXGIVkInteropSurface_FWD_DEFINED__
+typedef interface IDXGIVkInteropSurface IDXGIVkInteropSurface;
+#ifdef __cplusplus
+interface IDXGIVkInteropSurface;
+#endif /* __cplusplus */
+#endif
+
+#ifndef __IDXGIVkInteropDevice_FWD_DEFINED__
+#define __IDXGIVkInteropDevice_FWD_DEFINED__
+typedef interface IDXGIVkInteropDevice IDXGIVkInteropDevice;
+typedef interface IDXGIVkInteropDevice2 IDXGIVkInteropDevice2;
+#ifdef __cplusplus
+interface IDXGIVkInteropDevice;
+interface IDXGIVkInteropDevice2;
+#endif /* __cplusplus */
+#endif
+
+/* Headers for imported files */
+
+#include <d3d11.h>
+#include <vulkan/vulkan.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*****************************************************************************
+ * IDXGIVkInteropSurface interface
+ */
+#ifndef __IDXGIVkInteropSurface_INTERFACE_DEFINED__
+#define __IDXGIVkInteropSurface_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_IDXGIVkInteropSurface, 0x5546cf8c, 0x77e7, 0x4341, 0xb0,0x5d, 0x8d,0x4d,0x50,0x00,0xe7,0x7d);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+MIDL_INTERFACE("5546cf8c-77e7-4341-b05d-8d4d5000e77d")
+IDXGIVkInteropSurface : public IUnknown
+{
+    virtual HRESULT STDMETHODCALLTYPE GetDevice(
+        IDXGIVkInteropDevice**  ppDevice) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE GetVulkanImageInfo(
+        VkImage *pHandle,
+        VkImageLayout *pLayout,
+        VkImageCreateInfo *pInfo) = 0;
+
+};
+#ifdef __CRT_UUID_DECL
+__CRT_UUID_DECL(IDXGIVkInteropSurface, 0x5546cf8c, 0x77e7, 0x4341, 0xb0,0x5d, 0x8d,0x4d,0x50,0x00,0xe7,0x7d)
+#endif
+#else
+typedef struct IDXGIVkInteropSurfaceVtbl {
+    BEGIN_INTERFACE
+
+    /*** IUnknown methods ***/
+    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+        IDXGIVkInteropSurface *This,
+        REFIID riid,
+        void **ppvObject);
+
+    ULONG (STDMETHODCALLTYPE *AddRef)(
+        IDXGIVkInteropSurface *This);
+
+    ULONG (STDMETHODCALLTYPE *Release)(
+        IDXGIVkInteropSurface *This);
+
+    /*** IDXGIVkInteropSurface methods ***/
+    HRESULT (STDMETHODCALLTYPE *GetDevice)(
+        IDXGIVkInteropSurface *This,
+        IDXGIVkInteropDevice **ppDevice);
+
+    HRESULT (STDMETHODCALLTYPE *GetVulkanImageInfo)(
+        IDXGIVkInteropSurface *This,
+        VkImage *pHandle,
+        VkImageLayout *pLayout,
+        VkImageCreateInfo *pInfo);
+
+    END_INTERFACE
+} IDXGIVkInteropSurfaceVtbl;
+
+interface IDXGIVkInteropSurface {
+    CONST_VTBL IDXGIVkInteropSurfaceVtbl* lpVtbl;
+};
+
+#ifdef COBJMACROS
+#ifndef WIDL_C_INLINE_WRAPPERS
+/*** IUnknown methods ***/
+#define IDXGIVkInteropSurface_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDXGIVkInteropSurface_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDXGIVkInteropSurface_Release(This) (This)->lpVtbl->Release(This)
+/*** IDXGIVkInteropSurface methods ***/
+#define IDXGIVkInteropSurface_GetVulkanImageInfo(This,pHandle,pLayout,pInfo) (This)->lpVtbl->GetVulkanImageInfo(This,pHandle,pLayout,pInfo)
+#else
+/*** IUnknown methods ***/
+static FORCEINLINE HRESULT IDXGIVkInteropSurface_QueryInterface(IDXGIVkInteropSurface* This,REFIID riid,void **ppvObject) {
+    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
+}
+static FORCEINLINE ULONG IDXGIVkInteropSurface_AddRef(IDXGIVkInteropSurface* This) {
+    return This->lpVtbl->AddRef(This);
+}
+static FORCEINLINE ULONG IDXGIVkInteropSurface_Release(IDXGIVkInteropSurface* This) {
+    return This->lpVtbl->Release(This);
+}
+/*** IDXGIVkInteropSurface methods ***/
+static FORCEINLINE HRESULT IDXGIVkInteropSurface_GetVulkanImageInfo(IDXGIVkInteropSurface* This,VkImage *pHandle,VkImageLayout *pLayout,VkImageCreateInfo *pInfo) {
+    return This->lpVtbl->GetVulkanImageInfo(This,pHandle,pLayout,pInfo);
+}
+#endif
+#endif
+
+#endif
+
+
+#endif  /* __IDXGIVkInteropSurface_INTERFACE_DEFINED__ */
+
+/*****************************************************************************
+ * IDXGIVkInteropDevice interface
+ */
+#ifndef __IDXGIVkInteropDevice_INTERFACE_DEFINED__
+#define __IDXGIVkInteropDevice_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_IDXGIVkInteropDevice, 0xe2ef5fa5, 0xdc21, 0x4af7, 0x90,0xc4, 0xf6,0x7e,0xf6,0xa0,0x93,0x23);
+DEFINE_GUID(IID_IDXGIVkInteropDevice2, 0xe2ef5fa5, 0xdc21, 0x4af7, 0x90,0xc4, 0xf6,0x7e,0xf6,0xa0,0x93,0x24);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+MIDL_INTERFACE("e2ef5fa5-dc21-4af7-90c4-f67ef6a09323")
+IDXGIVkInteropDevice : public IUnknown
+{
+    virtual void STDMETHODCALLTYPE GetVulkanHandles(
+        VkInstance *pInstance,
+        VkPhysicalDevice *pPhysDev,
+        VkDevice *pDevice) = 0;
+
+    virtual void STDMETHODCALLTYPE GetSubmissionQueue(
+        VkQueue *pQueue,
+        uint32_t *pQueueFamilyIndex) = 0;
+
+    virtual void STDMETHODCALLTYPE TransitionSurfaceLayout(
+        IDXGIVkInteropSurface *pSurface,
+        const VkImageSubresourceRange *pSubresources,
+        VkImageLayout OldLayout,
+        VkImageLayout NewLayout) = 0;
+
+    virtual void STDMETHODCALLTYPE FlushRenderingCommands(
+        ) = 0;
+
+    virtual void STDMETHODCALLTYPE LockSubmissionQueue(
+        ) = 0;
+
+    virtual void STDMETHODCALLTYPE ReleaseSubmissionQueue(
+        ) = 0;
+
+};
+MIDL_INTERFACE("e2ef5fa5-dc21-4af7-90c4-f67ef6a09324")
+IDXGIVkInteropDevice2 : public IDXGIVkInteropDevice
+{
+    virtual void STDMETHODCALLTYPE GetSubmissionQueue2(
+        VkQueue *pQueue,
+        uint32_t *pQueueIndex,
+        uint32_t *pQueueFamilyIndex) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateTexture2DFromVkImage(
+        const D3D11_TEXTURE2D_DESC1 *pDesc,
+        VkImage vkImage,
+        ID3D11Texture2D **ppTexture2D) = 0;
+};
+#ifdef __CRT_UUID_DECL
+__CRT_UUID_DECL(IDXGIVkInteropDevice, 0xe2ef5fa5, 0xdc21, 0x4af7, 0x90,0xc4, 0xf6,0x7e,0xf6,0xa0,0x93,0x23)
+__CRT_UUID_DECL(IDXGIVkInteropDevice2, 0xe2ef5fa5, 0xdc21, 0x4af7, 0x90,0xc4, 0xf6,0x7e,0xf6,0xa0,0x93,0x24)
+#endif
+#else
+typedef struct IDXGIVkInteropDeviceVtbl {
+    BEGIN_INTERFACE
+
+    /*** IUnknown methods ***/
+    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+        IDXGIVkInteropDevice *This,
+        REFIID riid,
+        void **ppvObject);
+
+    ULONG (STDMETHODCALLTYPE *AddRef)(
+        IDXGIVkInteropDevice *This);
+
+    ULONG (STDMETHODCALLTYPE *Release)(
+        IDXGIVkInteropDevice *This);
+
+    /*** IDXGIVkInteropDevice methods ***/
+    void (STDMETHODCALLTYPE *GetVulkanHandles)(
+        IDXGIVkInteropDevice *This,
+        VkInstance *pInstance,
+        VkPhysicalDevice *pPhysDev,
+        VkDevice *pDevice);
+
+    void (STDMETHODCALLTYPE *GetSubmissionQueue)(
+        IDXGIVkInteropDevice *This,
+        VkQueue *pQueue,
+        uint32_t *pQueueFamilyIndex);
+
+    void (STDMETHODCALLTYPE *TransitionSurfaceLayout)(
+        IDXGIVkInteropDevice *This,
+        IDXGIVkInteropSurface *pSurface,
+        const VkImageSubresourceRange *pSubresources,
+        VkImageLayout OldLayout,
+        VkImageLayout NewLayout);
+
+    void (STDMETHODCALLTYPE *FlushRenderingCommands)(
+        IDXGIVkInteropDevice *This);
+
+    void (STDMETHODCALLTYPE *LockSubmissionQueue)(
+        IDXGIVkInteropDevice *This);
+
+    void (STDMETHODCALLTYPE *ReleaseSubmissionQueue)(
+        IDXGIVkInteropDevice *This);
+
+    END_INTERFACE
+} IDXGIVkInteropDeviceVtbl;
+
+interface IDXGIVkInteropDevice {
+    CONST_VTBL IDXGIVkInteropDeviceVtbl* lpVtbl;
+};
+
+typedef struct IDXGIVkInteropDevice2Vtbl {
+    BEGIN_INTERFACE
+
+    /*** IUnknown methods ***/
+    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+        IDXGIVkInteropDevice2 *This,
+        REFIID riid,
+        void **ppvObject);
+
+    ULONG (STDMETHODCALLTYPE *AddRef)(
+        IDXGIVkInteropDevice2 *This);
+
+    ULONG (STDMETHODCALLTYPE *Release)(
+        IDXGIVkInteropDevice2 *This);
+
+    /*** IDXGIVkInteropDevice methods ***/
+    void (STDMETHODCALLTYPE *GetVulkanHandles)(
+        IDXGIVkInteropDevice2 *This,
+        VkInstance *pInstance,
+        VkPhysicalDevice *pPhysDev,
+        VkDevice *pDevice);
+
+    void (STDMETHODCALLTYPE *GetSubmissionQueue)(
+        IDXGIVkInteropDevice2 *This,
+        VkQueue *pQueue,
+        uint32_t *pQueueFamilyIndex);
+
+    void (STDMETHODCALLTYPE *TransitionSurfaceLayout)(
+        IDXGIVkInteropDevice2 *This,
+        IDXGIVkInteropSurface *pSurface,
+        const VkImageSubresourceRange *pSubresources,
+        VkImageLayout OldLayout,
+        VkImageLayout NewLayout);
+
+    void (STDMETHODCALLTYPE *FlushRenderingCommands)(
+        IDXGIVkInteropDevice2 *This);
+
+    void (STDMETHODCALLTYPE *LockSubmissionQueue)(
+        IDXGIVkInteropDevice2 *This);
+
+    void (STDMETHODCALLTYPE *ReleaseSubmissionQueue)(
+        IDXGIVkInteropDevice2 *This);
+
+    void (STDMETHODCALLTYPE *GetSubmissionQueue2)(
+        IDXGIVkInteropDevice2 *This,
+        VkQueue *pQueue,
+        uint32_t *pQueueIndex,
+        uint32_t *pQueueFamilyIndex);
+
+    HRESULT (STDMETHODCALLTYPE *CreateTexture2DFromVkImage)(
+        IDXGIVkInteropDevice2 *This,
+        const D3D11_TEXTURE2D_DESC1 *pDesc,
+        VkImage vkImage,
+        ID3D11Texture2D **ppTexture2D);
+
+    END_INTERFACE
+} IDXGIVkInteropDevice2Vtbl;
+
+interface IDXGIVkInteropDevice2 {
+    CONST_VTBL IDXGIVkInteropDevice2Vtbl* lpVtbl;
+};
+
+#ifdef COBJMACROS
+#ifndef WIDL_C_INLINE_WRAPPERS
+/*** IUnknown methods ***/
+#define IDXGIVkInteropDevice_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDXGIVkInteropDevice_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDXGIVkInteropDevice_Release(This) (This)->lpVtbl->Release(This)
+/*** IDXGIVkInteropDevice methods ***/
+#define IDXGIVkInteropDevice_GetVulkanHandles(This,pInstance,pPhysDev,pDevice) (This)->lpVtbl->GetVulkanHandles(This,pInstance,pPhysDev,pDevice)
+#define IDXGIVkInteropDevice_GetSubmissionQueue(This,pQueue,pQueueFamilyIndex) (This)->lpVtbl->GetSubmissionQueue(This,pQueue,pQueueFamilyIndex)
+#define IDXGIVkInteropDevice_TransitionSurfaceLayout(This,pSurface,pSubresources,OldLayout,NewLayout) (This)->lpVtbl->TransitionSurfaceLayout(This,pSurface,pSubresources,OldLayout,NewLayout)
+#define IDXGIVkInteropDevice_FlushRenderingCommands(This) (This)->lpVtbl->FlushRenderingCommands(This)
+#define IDXGIVkInteropDevice_LockSubmissionQueue(This) (This)->lpVtbl->LockSubmissionQueue(This)
+#define IDXGIVkInteropDevice_ReleaseSubmissionQueue(This) (This)->lpVtbl->ReleaseSubmissionQueue(This)
+#else
+/*** IUnknown methods ***/
+static FORCEINLINE HRESULT IDXGIVkInteropDevice_QueryInterface(IDXGIVkInteropDevice* This,REFIID riid,void **ppvObject) {
+    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
+}
+static FORCEINLINE ULONG IDXGIVkInteropDevice_AddRef(IDXGIVkInteropDevice* This) {
+    return This->lpVtbl->AddRef(This);
+}
+static FORCEINLINE ULONG IDXGIVkInteropDevice_Release(IDXGIVkInteropDevice* This) {
+    return This->lpVtbl->Release(This);
+}
+/*** IDXGIVkInteropDevice methods ***/
+static FORCEINLINE void IDXGIVkInteropDevice_GetVulkanHandles(IDXGIVkInteropDevice* This,VkInstance *pInstance,VkPhysicalDevice *pPhysDev,VkDevice *pDevice) {
+    This->lpVtbl->GetVulkanHandles(This,pInstance,pPhysDev,pDevice);
+}
+static FORCEINLINE void IDXGIVkInteropDevice_GetSubmissionQueue(IDXGIVkInteropDevice* This,VkQueue *pQueue,uint32_t *pQueueFamilyIndex) {
+    This->lpVtbl->GetSubmissionQueue(This,pQueue,pQueueFamilyIndex);
+}
+static FORCEINLINE void IDXGIVkInteropDevice_TransitionSurfaceLayout(IDXGIVkInteropDevice* This,IDXGIVkInteropSurface *pSurface,const VkImageSubresourceRange *pSubresources,VkImageLayout OldLayout,VkImageLayout NewLayout) {
+    This->lpVtbl->TransitionSurfaceLayout(This,pSurface,pSubresources,OldLayout,NewLayout);
+}
+static FORCEINLINE void IDXGIVkInteropDevice_FlushRenderingCommands(IDXGIVkInteropDevice* This) {
+    This->lpVtbl->FlushRenderingCommands(This);
+}
+static FORCEINLINE void IDXGIVkInteropDevice_LockSubmissionQueue(IDXGIVkInteropDevice* This) {
+    This->lpVtbl->LockSubmissionQueue(This);
+}
+static FORCEINLINE void IDXGIVkInteropDevice_ReleaseSubmissionQueue(IDXGIVkInteropDevice* This) {
+    This->lpVtbl->ReleaseSubmissionQueue(This);
+}
+#endif
+#endif
+
+#endif
+
+
+#endif  /* __IDXGIVkInteropDevice_INTERFACE_DEFINED__ */
+
+/* Begin additional prototypes for all interfaces */
+
+
+/* End additional prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __dxvk_interop_h__ */

wineopenxr/loader_structs.h

@@ -0,0 +1,30 @@
+typedef struct WINE_XR_STRUCT_NAME(XrNegotiateLoaderInfo) {
+    XrLoaderInterfaceStructs structType;  // XR_LOADER_INTERFACE_STRUCT_LOADER_INFO
+    uint32_t structVersion;               // XR_LOADER_INFO_STRUCT_VERSION
+    size_t structSize;                    // sizeof(XrNegotiateLoaderInfo)
+    uint32_t minInterfaceVersion;
+    uint32_t maxInterfaceVersion;
+    XrVersion minApiVersion;
+    XrVersion maxApiVersion;
+} WINE_XR_STRUCT_ATTR WINE_XR_STRUCT_NAME(XrNegotiateLoaderInfo);
+
+typedef struct WINE_XR_STRUCT_NAME(XrNegotiateRuntimeRequest) {
+    XrLoaderInterfaceStructs structType;  // XR_LOADER_INTERFACE_STRUCT_RUNTIME_REQUEST
+    uint32_t structVersion;               // XR_RUNTIME_INFO_STRUCT_VERSION
+    size_t structSize;                    // sizeof(XrNegotiateRuntimeRequest)
+    uint32_t runtimeInterfaceVersion;     // CURRENT_LOADER_RUNTIME_VERSION
+    XrVersion runtimeApiVersion;
+    PFN_xrGetInstanceProcAddr getInstanceProcAddr;
+} WINE_XR_STRUCT_ATTR WINE_XR_STRUCT_NAME(XrNegotiateRuntimeRequest);
+
+/*
+typedef struct WINE_XR_STRUCT_NAME(XrNegotiateApiLayerRequest) {
+    XrLoaderInterfaceStructs structType;
+    uint32_t structVersion;
+    size_t structSize;
+    uint32_t layerInterfaceVersion;
+    XrVersion layerApiVersion;
+    PFN_xrGetInstanceProcAddr getInstanceProcAddr;
+    PFN_xrCreateApiLayerInstance createApiLayerInstance;
+} WINE_XR_STRUCT_ATTR WINE_XR_STRUCT_NAME(XrNegotiateApiLayerRequest);
+*/

wineopenxr/openxr_private.h

@@ -0,0 +1,85 @@
+#include "openxr_thunks.h"
+
+#include "wine/list.h"
+
+#define INSTANCE_TYPE_VULKAN 1
+#define INSTANCE_TYPE_OPENGL 2
+#define INSTANCE_TYPE_D3D11 3
+#define INSTANCE_TYPE_D3D12 4
+
+struct IDXGIVkInteropDevice2;
+typedef struct IDXGIVkInteropDevice2 IDXGIVkInteropDevice2;
+
+typedef struct wine_XrInstance {
+    XrInstance instance;
+    struct openxr_instance_funcs funcs;
+
+    VkInstance vk_instance;
+    VkPhysicalDevice vk_phys_dev;
+
+    uint32_t instance_type;
+    XrSystemId systemId;
+
+    IDXGIVkInteropDevice2 *dxvk_device;
+} wine_XrInstance;
+
+union CompositionLayer;
+typedef union CompositionLayer CompositionLayer;
+
+typedef struct wine_XrSession {
+    XrSession session;
+    struct wine_XrInstance *wine_instance;
+
+    struct list entry;
+
+    uint32_t composition_layer_count;
+    CompositionLayer *composition_layers;
+    XrCompositionLayerBaseHeader **composition_layer_ptrs;
+
+    uint32_t projection_view_count;
+    XrCompositionLayerProjectionView *projection_views;
+} wine_XrSession;
+
+typedef struct wine_XrHandTrackerEXT {
+    XrHandTrackerEXT hand_tracker;
+    struct wine_XrSession *wine_session;
+} wine_XrHandTrackerEXT;
+
+typedef struct wine_XrSpatialAnchorMSFT {
+    XrSpatialAnchorMSFT spatial_anchor;
+    struct wine_XrSession *wine_session;
+} wine_XrSpatialAnchorMSFT;
+
+typedef struct wine_XrSwapchain{
+    XrSwapchain swapchain;
+    struct wine_XrSession *wine_session;
+
+    XrSwapchainCreateInfo create_info;
+} wine_XrSwapchain;
+
+struct openxr_func {
+    const char *name;
+    void *func;
+};
+
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*a))
+
+extern void *wine_xr_proc_addr(const char *name);
+
+extern XrResult WINAPI wine_xrEnumerateInstanceExtensionProperties(const char *layerName,
+        uint32_t propertyCapacityInput, uint32_t *propertyCountOutput, XrExtensionProperties *properties);
+extern XrResult WINAPI wine_xrConvertTimeToWin32PerformanceCounterKHR(XrInstance instance,
+        XrTime time, LARGE_INTEGER *performanceCounter);
+extern XrResult WINAPI wine_xrConvertWin32PerformanceCounterToTimeKHR(XrInstance instance,
+        const LARGE_INTEGER *performanceCounter, XrTime *time);
+extern XrResult WINAPI wine_xrGetD3D11GraphicsRequirementsKHR(XrInstance instance,
+        XrSystemId systemId, XrGraphicsRequirementsD3D11KHR *graphicsRequirements);
+extern XrResult WINAPI wine_xrGetD3D12GraphicsRequirementsKHR(XrInstance instance,
+        XrSystemId systemId, XrGraphicsRequirementsD3D12KHR *graphicsRequirements);
+
+extern VkDevice (WINAPI *get_native_VkDevice)(VkDevice);
+extern VkInstance (WINAPI *get_native_VkInstance)(VkInstance);
+extern VkPhysicalDevice (WINAPI *get_native_VkPhysicalDevice)(VkPhysicalDevice);
+extern VkPhysicalDevice (WINAPI *get_wrapped_VkPhysicalDevice)(VkInstance, VkPhysicalDevice);
+extern VkQueue (WINAPI *get_native_VkQueue)(VkQueue);
+extern XrResult load_host_openxr_loader(void);

wineopenxr/openxr_thunks.c

@@ -0,0 +1,561 @@
+/* Automatically generated from OpenXR xr.xml; DO NOT EDIT!
+ *
+ * This file is generated from OpenXR xr.xml file covered
+ * by the following copyright and permission notice:
+ *
+ * Copyright (c) 2017-2020 The Khronos Group Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ * ------------------------------------------------------------------------
+ *
+ * This file, xr.xml, is the OpenXR API Registry. It is a critically important
+ * and normative part of the OpenXR Specification, including a canonical
+ * machine-readable definition of the API, parameter and member validation
+ * language incorporated into the Specification and reference pages, and other
+ * material which is registered by Khronos, such as tags used by extension and
+ * layer authors. The only authoritative version of xr.xml is the one
+ * maintained in the master branch of the Khronos OpenXR GitHub project.
+ *
+ */
+
+#include "wine/debug.h"
+#include "wine/vulkan.h"
+#include "d3d11.h"
+#include "d3d12.h"
+#define WINE_XR_HOST
+#include "wineopenxr.h"
+#include "openxr_private.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(openxr);
+
+#if defined(USE_STRUCT_CONVERSION)
+#endif /* USE_STRUCT_CONVERSION */
+
+XrResult convert_XrInstanceCreateInfo_struct_chain(const void *next, XrInstanceCreateInfo *out_struct)
+{
+    XrBaseOutStructure *out_header = (XrBaseOutStructure *)out_struct;
+    const XrBaseInStructure *in_header;
+
+    out_header->next = NULL;
+
+    for (in_header = next; in_header; in_header = in_header->next)
+    {
+        switch (in_header->type)
+        {
+        case XR_TYPE_INSTANCE_CREATE_INFO:
+            break;
+
+        default:
+            WINE_FIXME("Application requested a linked structure of type %u.\n", in_header->type);
+        }
+    }
+
+    return XR_SUCCESS;
+}
+
+void free_XrInstanceCreateInfo_struct_chain(XrInstanceCreateInfo *s)
+{
+    XrBaseOutStructure *header = (void *)s->next;
+
+    while (header)
+    {
+        void *prev = header;
+        header = header->next;
+        HeapFree(GetProcessHeap(), 0, prev);
+    }
+
+    s->next = NULL;
+}
+
+XrResult WINAPI wine_xrAcquireSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageAcquireInfo *acquireInfo, uint32_t *index)
+{
+    WINE_TRACE("%p, %p, %p\n", swapchain, acquireInfo, index);
+    return xrAcquireSwapchainImage(((wine_XrSwapchain *)swapchain)->swapchain, acquireInfo, index);
+}
+
+XrResult WINAPI wine_xrApplyHapticFeedback(XrSession session, const XrHapticActionInfo *hapticActionInfo, const XrHapticBaseHeader *hapticFeedback)
+{
+    WINE_TRACE("%p, %p, %p\n", session, hapticActionInfo, hapticFeedback);
+    return xrApplyHapticFeedback(((wine_XrSession *)session)->session, hapticActionInfo, hapticFeedback);
+}
+
+XrResult WINAPI wine_xrAttachSessionActionSets(XrSession session, const XrSessionActionSetsAttachInfo *attachInfo)
+{
+    WINE_TRACE("%p, %p\n", session, attachInfo);
+    return xrAttachSessionActionSets(((wine_XrSession *)session)->session, attachInfo);
+}
+
+XrResult WINAPI wine_xrBeginFrame(XrSession session, const XrFrameBeginInfo *frameBeginInfo)
+{
+    WINE_TRACE("%p, %p\n", session, frameBeginInfo);
+    return xrBeginFrame(((wine_XrSession *)session)->session, frameBeginInfo);
+}
+
+XrResult WINAPI wine_xrBeginSession(XrSession session, const XrSessionBeginInfo *beginInfo)
+{
+    WINE_TRACE("%p, %p\n", session, beginInfo);
+    return xrBeginSession(((wine_XrSession *)session)->session, beginInfo);
+}
+
+XrResult WINAPI wine_xrCreateAction(XrActionSet actionSet, const XrActionCreateInfo *createInfo, XrAction *action)
+{
+    WINE_TRACE("%p, %p, %p\n", actionSet, createInfo, action);
+    return xrCreateAction(actionSet, createInfo, action);
+}
+
+XrResult WINAPI wine_xrCreateActionSet(XrInstance instance, const XrActionSetCreateInfo *createInfo, XrActionSet *actionSet)
+{
+    WINE_TRACE("%p, %p, %p\n", instance, createInfo, actionSet);
+    return xrCreateActionSet(((wine_XrInstance *)instance)->instance, createInfo, actionSet);
+}
+
+XrResult WINAPI wine_xrCreateActionSpace(XrSession session, const XrActionSpaceCreateInfo *createInfo, XrSpace *space)
+{
+    WINE_TRACE("%p, %p, %p\n", session, createInfo, space);
+    return xrCreateActionSpace(((wine_XrSession *)session)->session, createInfo, space);
+}
+
+static XrResult WINAPI wine_xrCreateHandMeshSpaceMSFT(XrHandTrackerEXT handTracker, const XrHandMeshSpaceCreateInfoMSFT *createInfo, XrSpace *space)
+{
+    WINE_TRACE("%p, %p, %p\n", handTracker, createInfo, space);
+    return ((wine_XrHandTrackerEXT *)handTracker)->wine_session->wine_instance->funcs.p_xrCreateHandMeshSpaceMSFT(((wine_XrHandTrackerEXT *)handTracker)->hand_tracker, createInfo, space);
+}
+
+XrResult WINAPI wine_xrCreateReferenceSpace(XrSession session, const XrReferenceSpaceCreateInfo *createInfo, XrSpace *space)
+{
+    WINE_TRACE("%p, %p, %p\n", session, createInfo, space);
+    return xrCreateReferenceSpace(((wine_XrSession *)session)->session, createInfo, space);
+}
+
+static XrResult WINAPI wine_xrCreateSpatialAnchorSpaceMSFT(XrSession session, const XrSpatialAnchorSpaceCreateInfoMSFT *createInfo, XrSpace *space)
+{
+    WINE_TRACE("%p, %p, %p\n", session, createInfo, space);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateSpatialAnchorSpaceMSFT(((wine_XrSession *)session)->session, createInfo, space);
+}
+
+static XrResult WINAPI wine_xrCreateSpatialGraphNodeSpaceMSFT(XrSession session, const XrSpatialGraphNodeSpaceCreateInfoMSFT *createInfo, XrSpace *space)
+{
+    WINE_TRACE("%p, %p, %p\n", session, createInfo, space);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateSpatialGraphNodeSpaceMSFT(((wine_XrSession *)session)->session, createInfo, space);
+}
+
+XrResult WINAPI wine_xrDestroyAction(XrAction action)
+{
+    WINE_TRACE("%p\n", action);
+    return xrDestroyAction(action);
+}
+
+XrResult WINAPI wine_xrDestroyActionSet(XrActionSet actionSet)
+{
+    WINE_TRACE("%p\n", actionSet);
+    return xrDestroyActionSet(actionSet);
+}
+
+XrResult WINAPI wine_xrDestroySpace(XrSpace space)
+{
+    WINE_TRACE("%p\n", space);
+    return xrDestroySpace(space);
+}
+
+XrResult WINAPI wine_xrEndSession(XrSession session)
+{
+    WINE_TRACE("%p\n", session);
+    return xrEndSession(((wine_XrSession *)session)->session);
+}
+
+XrResult WINAPI wine_xrEnumerateApiLayerProperties(uint32_t propertyCapacityInput, uint32_t *propertyCountOutput, XrApiLayerProperties *properties)
+{
+    WINE_TRACE("%u, %p, %p\n", propertyCapacityInput, propertyCountOutput, properties);
+    return xrEnumerateApiLayerProperties(propertyCapacityInput, propertyCountOutput, properties);
+}
+
+XrResult WINAPI wine_xrEnumerateBoundSourcesForAction(XrSession session, const XrBoundSourcesForActionEnumerateInfo *enumerateInfo, uint32_t sourceCapacityInput, uint32_t *sourceCountOutput, XrPath *sources)
+{
+    WINE_TRACE("%p, %p, %u, %p, %p\n", session, enumerateInfo, sourceCapacityInput, sourceCountOutput, sources);
+    return xrEnumerateBoundSourcesForAction(((wine_XrSession *)session)->session, enumerateInfo, sourceCapacityInput, sourceCountOutput, sources);
+}
+
+XrResult WINAPI wine_xrEnumerateEnvironmentBlendModes(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, uint32_t environmentBlendModeCapacityInput, uint32_t *environmentBlendModeCountOutput, XrEnvironmentBlendMode *environmentBlendModes)
+{
+    WINE_TRACE("%p, 0x%s, %#x, %u, %p, %p\n", instance, wine_dbgstr_longlong(systemId), viewConfigurationType, environmentBlendModeCapacityInput, environmentBlendModeCountOutput, environmentBlendModes);
+    return xrEnumerateEnvironmentBlendModes(((wine_XrInstance *)instance)->instance, systemId, viewConfigurationType, environmentBlendModeCapacityInput, environmentBlendModeCountOutput, environmentBlendModes);
+}
+
+XrResult WINAPI wine_xrEnumerateReferenceSpaces(XrSession session, uint32_t spaceCapacityInput, uint32_t *spaceCountOutput, XrReferenceSpaceType *spaces)
+{
+    WINE_TRACE("%p, %u, %p, %p\n", session, spaceCapacityInput, spaceCountOutput, spaces);
+    return xrEnumerateReferenceSpaces(((wine_XrSession *)session)->session, spaceCapacityInput, spaceCountOutput, spaces);
+}
+
+XrResult WINAPI wine_xrEnumerateViewConfigurationViews(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, uint32_t viewCapacityInput, uint32_t *viewCountOutput, XrViewConfigurationView *views)
+{
+    WINE_TRACE("%p, 0x%s, %#x, %u, %p, %p\n", instance, wine_dbgstr_longlong(systemId), viewConfigurationType, viewCapacityInput, viewCountOutput, views);
+    return xrEnumerateViewConfigurationViews(((wine_XrInstance *)instance)->instance, systemId, viewConfigurationType, viewCapacityInput, viewCountOutput, views);
+}
+
+XrResult WINAPI wine_xrEnumerateViewConfigurations(XrInstance instance, XrSystemId systemId, uint32_t viewConfigurationTypeCapacityInput, uint32_t *viewConfigurationTypeCountOutput, XrViewConfigurationType *viewConfigurationTypes)
+{
+    WINE_TRACE("%p, 0x%s, %u, %p, %p\n", instance, wine_dbgstr_longlong(systemId), viewConfigurationTypeCapacityInput, viewConfigurationTypeCountOutput, viewConfigurationTypes);
+    return xrEnumerateViewConfigurations(((wine_XrInstance *)instance)->instance, systemId, viewConfigurationTypeCapacityInput, viewConfigurationTypeCountOutput, viewConfigurationTypes);
+}
+
+XrResult WINAPI wine_xrGetActionStateBoolean(XrSession session, const XrActionStateGetInfo *getInfo, XrActionStateBoolean *state)
+{
+    WINE_TRACE("%p, %p, %p\n", session, getInfo, state);
+    return xrGetActionStateBoolean(((wine_XrSession *)session)->session, getInfo, state);
+}
+
+XrResult WINAPI wine_xrGetActionStateFloat(XrSession session, const XrActionStateGetInfo *getInfo, XrActionStateFloat *state)
+{
+    WINE_TRACE("%p, %p, %p\n", session, getInfo, state);
+    return xrGetActionStateFloat(((wine_XrSession *)session)->session, getInfo, state);
+}
+
+XrResult WINAPI wine_xrGetActionStatePose(XrSession session, const XrActionStateGetInfo *getInfo, XrActionStatePose *state)
+{
+    WINE_TRACE("%p, %p, %p\n", session, getInfo, state);
+    return xrGetActionStatePose(((wine_XrSession *)session)->session, getInfo, state);
+}
+
+XrResult WINAPI wine_xrGetActionStateVector2f(XrSession session, const XrActionStateGetInfo *getInfo, XrActionStateVector2f *state)
+{
+    WINE_TRACE("%p, %p, %p\n", session, getInfo, state);
+    return xrGetActionStateVector2f(((wine_XrSession *)session)->session, getInfo, state);
+}
+
+XrResult WINAPI wine_xrGetCurrentInteractionProfile(XrSession session, XrPath topLevelUserPath, XrInteractionProfileState *interactionProfile)
+{
+    WINE_TRACE("%p, 0x%s, %p\n", session, wine_dbgstr_longlong(topLevelUserPath), interactionProfile);
+    return xrGetCurrentInteractionProfile(((wine_XrSession *)session)->session, topLevelUserPath, interactionProfile);
+}
+
+XrResult WINAPI wine_xrGetInputSourceLocalizedName(XrSession session, const XrInputSourceLocalizedNameGetInfo *getInfo, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer)
+{
+    WINE_TRACE("%p, %p, %u, %p, %p\n", session, getInfo, bufferCapacityInput, bufferCountOutput, buffer);
+    return xrGetInputSourceLocalizedName(((wine_XrSession *)session)->session, getInfo, bufferCapacityInput, bufferCountOutput, buffer);
+}
+
+XrResult WINAPI wine_xrGetInstanceProperties(XrInstance instance, XrInstanceProperties *instanceProperties)
+{
+    WINE_TRACE("%p, %p\n", instance, instanceProperties);
+    return xrGetInstanceProperties(((wine_XrInstance *)instance)->instance, instanceProperties);
+}
+
+static XrResult WINAPI wine_xrGetOpenGLGraphicsRequirementsKHR(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsOpenGLKHR *graphicsRequirements)
+{
+    WINE_TRACE("%p, 0x%s, %p\n", instance, wine_dbgstr_longlong(systemId), graphicsRequirements);
+    return ((wine_XrInstance *)instance)->funcs.p_xrGetOpenGLGraphicsRequirementsKHR(((wine_XrInstance *)instance)->instance, systemId, graphicsRequirements);
+}
+
+XrResult WINAPI wine_xrGetReferenceSpaceBoundsRect(XrSession session, XrReferenceSpaceType referenceSpaceType, XrExtent2Df *bounds)
+{
+    WINE_TRACE("%p, %#x, %p\n", session, referenceSpaceType, bounds);
+    return xrGetReferenceSpaceBoundsRect(((wine_XrSession *)session)->session, referenceSpaceType, bounds);
+}
+
+XrResult WINAPI wine_xrGetSystemProperties(XrInstance instance, XrSystemId systemId, XrSystemProperties *properties)
+{
+    WINE_TRACE("%p, 0x%s, %p\n", instance, wine_dbgstr_longlong(systemId), properties);
+    return xrGetSystemProperties(((wine_XrInstance *)instance)->instance, systemId, properties);
+}
+
+XrResult WINAPI wine_xrGetViewConfigurationProperties(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, XrViewConfigurationProperties *configurationProperties)
+{
+    WINE_TRACE("%p, 0x%s, %#x, %p\n", instance, wine_dbgstr_longlong(systemId), viewConfigurationType, configurationProperties);
+    return xrGetViewConfigurationProperties(((wine_XrInstance *)instance)->instance, systemId, viewConfigurationType, configurationProperties);
+}
+
+static XrResult WINAPI wine_xrGetVisibilityMaskKHR(XrSession session, XrViewConfigurationType viewConfigurationType, uint32_t viewIndex, XrVisibilityMaskTypeKHR visibilityMaskType, XrVisibilityMaskKHR *visibilityMask)
+{
+    WINE_TRACE("%p, %#x, %u, %#x, %p\n", session, viewConfigurationType, viewIndex, visibilityMaskType, visibilityMask);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetVisibilityMaskKHR(((wine_XrSession *)session)->session, viewConfigurationType, viewIndex, visibilityMaskType, visibilityMask);
+}
+
+static XrResult WINAPI wine_xrGetVulkanGraphicsRequirementsKHR(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsVulkanKHR *graphicsRequirements)
+{
+    WINE_TRACE("%p, 0x%s, %p\n", instance, wine_dbgstr_longlong(systemId), graphicsRequirements);
+    return ((wine_XrInstance *)instance)->funcs.p_xrGetVulkanGraphicsRequirementsKHR(((wine_XrInstance *)instance)->instance, systemId, graphicsRequirements);
+}
+
+static XrResult WINAPI wine_xrLocateHandJointsEXT(XrHandTrackerEXT handTracker, const XrHandJointsLocateInfoEXT *locateInfo, XrHandJointLocationsEXT *locations)
+{
+    WINE_TRACE("%p, %p, %p\n", handTracker, locateInfo, locations);
+    return ((wine_XrHandTrackerEXT *)handTracker)->wine_session->wine_instance->funcs.p_xrLocateHandJointsEXT(((wine_XrHandTrackerEXT *)handTracker)->hand_tracker, locateInfo, locations);
+}
+
+XrResult WINAPI wine_xrLocateSpace(XrSpace space, XrSpace baseSpace, XrTime time, XrSpaceLocation *location)
+{
+    WINE_TRACE("%p, %p, 0x%s, %p\n", space, baseSpace, wine_dbgstr_longlong(time), location);
+    return xrLocateSpace(space, baseSpace, time, location);
+}
+
+XrResult WINAPI wine_xrLocateViews(XrSession session, const XrViewLocateInfo *viewLocateInfo, XrViewState *viewState, uint32_t viewCapacityInput, uint32_t *viewCountOutput, XrView *views)
+{
+    WINE_TRACE("%p, %p, %p, %u, %p, %p\n", session, viewLocateInfo, viewState, viewCapacityInput, viewCountOutput, views);
+    return xrLocateViews(((wine_XrSession *)session)->session, viewLocateInfo, viewState, viewCapacityInput, viewCountOutput, views);
+}
+
+XrResult WINAPI wine_xrPathToString(XrInstance instance, XrPath path, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer)
+{
+    WINE_TRACE("%p, 0x%s, %u, %p, %p\n", instance, wine_dbgstr_longlong(path), bufferCapacityInput, bufferCountOutput, buffer);
+    return xrPathToString(((wine_XrInstance *)instance)->instance, path, bufferCapacityInput, bufferCountOutput, buffer);
+}
+
+static XrResult WINAPI wine_xrPerfSettingsSetPerformanceLevelEXT(XrSession session, XrPerfSettingsDomainEXT domain, XrPerfSettingsLevelEXT level)
+{
+    WINE_TRACE("%p, %#x, %#x\n", session, domain, level);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrPerfSettingsSetPerformanceLevelEXT(((wine_XrSession *)session)->session, domain, level);
+}
+
+XrResult WINAPI wine_xrReleaseSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageReleaseInfo *releaseInfo)
+{
+    WINE_TRACE("%p, %p\n", swapchain, releaseInfo);
+    return xrReleaseSwapchainImage(((wine_XrSwapchain *)swapchain)->swapchain, releaseInfo);
+}
+
+XrResult WINAPI wine_xrRequestExitSession(XrSession session)
+{
+    WINE_TRACE("%p\n", session);
+    return xrRequestExitSession(((wine_XrSession *)session)->session);
+}
+
+XrResult WINAPI wine_xrResultToString(XrInstance instance, XrResult value, char buffer[])
+{
+    WINE_TRACE("%p, %#x, %p\n", instance, value, buffer);
+    return xrResultToString(((wine_XrInstance *)instance)->instance, value, buffer);
+}
+
+static XrResult WINAPI wine_xrSetInputDeviceActiveEXT(XrSession session, XrPath interactionProfile, XrPath topLevelPath, XrBool32 isActive)
+{
+    WINE_TRACE("%p, 0x%s, 0x%s, %u\n", session, wine_dbgstr_longlong(interactionProfile), wine_dbgstr_longlong(topLevelPath), isActive);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetInputDeviceActiveEXT(((wine_XrSession *)session)->session, interactionProfile, topLevelPath, isActive);
+}
+
+static XrResult WINAPI wine_xrSetInputDeviceLocationEXT(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, XrSpace space, XrPosef pose)
+{
+    WINE_TRACE("%p, 0x%s, 0x%s, %p, \n", session, wine_dbgstr_longlong(topLevelPath), wine_dbgstr_longlong(inputSourcePath), space, pose);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetInputDeviceLocationEXT(((wine_XrSession *)session)->session, topLevelPath, inputSourcePath, space, pose);
+}
+
+static XrResult WINAPI wine_xrSetInputDeviceStateBoolEXT(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, XrBool32 state)
+{
+    WINE_TRACE("%p, 0x%s, 0x%s, %u\n", session, wine_dbgstr_longlong(topLevelPath), wine_dbgstr_longlong(inputSourcePath), state);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetInputDeviceStateBoolEXT(((wine_XrSession *)session)->session, topLevelPath, inputSourcePath, state);
+}
+
+static XrResult WINAPI wine_xrSetInputDeviceStateFloatEXT(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, float state)
+{
+    WINE_TRACE("%p, 0x%s, 0x%s, %f\n", session, wine_dbgstr_longlong(topLevelPath), wine_dbgstr_longlong(inputSourcePath), state);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetInputDeviceStateFloatEXT(((wine_XrSession *)session)->session, topLevelPath, inputSourcePath, state);
+}
+
+static XrResult WINAPI wine_xrSetInputDeviceStateVector2fEXT(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, XrVector2f state)
+{
+    WINE_TRACE("%p, 0x%s, 0x%s, %f, %f\n", session, wine_dbgstr_longlong(topLevelPath), wine_dbgstr_longlong(inputSourcePath), state.x, state.y);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetInputDeviceStateVector2fEXT(((wine_XrSession *)session)->session, topLevelPath, inputSourcePath, state);
+}
+
+XrResult WINAPI wine_xrStopHapticFeedback(XrSession session, const XrHapticActionInfo *hapticActionInfo)
+{
+    WINE_TRACE("%p, %p\n", session, hapticActionInfo);
+    return xrStopHapticFeedback(((wine_XrSession *)session)->session, hapticActionInfo);
+}
+
+XrResult WINAPI wine_xrStringToPath(XrInstance instance, const char *pathString, XrPath *path)
+{
+    WINE_TRACE("%p, %p, %p\n", instance, pathString, path);
+    return xrStringToPath(((wine_XrInstance *)instance)->instance, pathString, path);
+}
+
+XrResult WINAPI wine_xrStructureTypeToString(XrInstance instance, XrStructureType value, char buffer[])
+{
+    WINE_TRACE("%p, %#x, %p\n", instance, value, buffer);
+    return xrStructureTypeToString(((wine_XrInstance *)instance)->instance, value, buffer);
+}
+
+XrResult WINAPI wine_xrSuggestInteractionProfileBindings(XrInstance instance, const XrInteractionProfileSuggestedBinding *suggestedBindings)
+{
+    WINE_TRACE("%p, %p\n", instance, suggestedBindings);
+    return xrSuggestInteractionProfileBindings(((wine_XrInstance *)instance)->instance, suggestedBindings);
+}
+
+XrResult WINAPI wine_xrSyncActions(XrSession session, const XrActionsSyncInfo *syncInfo)
+{
+    WINE_TRACE("%p, %p\n", session, syncInfo);
+    return xrSyncActions(((wine_XrSession *)session)->session, syncInfo);
+}
+
+static XrResult WINAPI wine_xrThermalGetTemperatureTrendEXT(XrSession session, XrPerfSettingsDomainEXT domain, XrPerfSettingsNotificationLevelEXT *notificationLevel, float *tempHeadroom, float *tempSlope)
+{
+    WINE_TRACE("%p, %#x, %p, %p, %p\n", session, domain, notificationLevel, tempHeadroom, tempSlope);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrThermalGetTemperatureTrendEXT(((wine_XrSession *)session)->session, domain, notificationLevel, tempHeadroom, tempSlope);
+}
+
+static XrResult WINAPI wine_xrUpdateHandMeshMSFT(XrHandTrackerEXT handTracker, const XrHandMeshUpdateInfoMSFT *updateInfo, XrHandMeshMSFT *handMesh)
+{
+    WINE_TRACE("%p, %p, %p\n", handTracker, updateInfo, handMesh);
+    return ((wine_XrHandTrackerEXT *)handTracker)->wine_session->wine_instance->funcs.p_xrUpdateHandMeshMSFT(((wine_XrHandTrackerEXT *)handTracker)->hand_tracker, updateInfo, handMesh);
+}
+
+XrResult WINAPI wine_xrWaitFrame(XrSession session, const XrFrameWaitInfo *frameWaitInfo, XrFrameState *frameState)
+{
+    WINE_TRACE("%p, %p, %p\n", session, frameWaitInfo, frameState);
+    return xrWaitFrame(((wine_XrSession *)session)->session, frameWaitInfo, frameState);
+}
+
+XrResult WINAPI wine_xrWaitSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageWaitInfo *waitInfo)
+{
+    WINE_TRACE("%p, %p\n", swapchain, waitInfo);
+    return xrWaitSwapchainImage(((wine_XrSwapchain *)swapchain)->swapchain, waitInfo);
+}
+
+static const struct openxr_func xr_dispatch_table[] =
+{
+    {"xrAcquireSwapchainImage", &wine_xrAcquireSwapchainImage},
+    {"xrApplyHapticFeedback", &wine_xrApplyHapticFeedback},
+    {"xrAttachSessionActionSets", &wine_xrAttachSessionActionSets},
+    {"xrBeginFrame", &wine_xrBeginFrame},
+    {"xrBeginSession", &wine_xrBeginSession},
+    {"xrConvertTimeToWin32PerformanceCounterKHR", &wine_xrConvertTimeToWin32PerformanceCounterKHR},
+    {"xrConvertWin32PerformanceCounterToTimeKHR", &wine_xrConvertWin32PerformanceCounterToTimeKHR},
+    {"xrCreateAction", &wine_xrCreateAction},
+    {"xrCreateActionSet", &wine_xrCreateActionSet},
+    {"xrCreateActionSpace", &wine_xrCreateActionSpace},
+    {"xrCreateHandMeshSpaceMSFT", &wine_xrCreateHandMeshSpaceMSFT},
+    {"xrCreateHandTrackerEXT", &wine_xrCreateHandTrackerEXT},
+    {"xrCreateInstance", &wine_xrCreateInstance},
+    {"xrCreateReferenceSpace", &wine_xrCreateReferenceSpace},
+    {"xrCreateSession", &wine_xrCreateSession},
+    {"xrCreateSpatialAnchorMSFT", &wine_xrCreateSpatialAnchorMSFT},
+    {"xrCreateSpatialAnchorSpaceMSFT", &wine_xrCreateSpatialAnchorSpaceMSFT},
+    {"xrCreateSpatialGraphNodeSpaceMSFT", &wine_xrCreateSpatialGraphNodeSpaceMSFT},
+    {"xrCreateSwapchain", &wine_xrCreateSwapchain},
+    {"xrDestroyAction", &wine_xrDestroyAction},
+    {"xrDestroyActionSet", &wine_xrDestroyActionSet},
+    {"xrDestroyHandTrackerEXT", &wine_xrDestroyHandTrackerEXT},
+    {"xrDestroyInstance", &wine_xrDestroyInstance},
+    {"xrDestroySession", &wine_xrDestroySession},
+    {"xrDestroySpace", &wine_xrDestroySpace},
+    {"xrDestroySpatialAnchorMSFT", &wine_xrDestroySpatialAnchorMSFT},
+    {"xrDestroySwapchain", &wine_xrDestroySwapchain},
+    {"xrEndFrame", &wine_xrEndFrame},
+    {"xrEndSession", &wine_xrEndSession},
+    {"xrEnumerateApiLayerProperties", &wine_xrEnumerateApiLayerProperties},
+    {"xrEnumerateBoundSourcesForAction", &wine_xrEnumerateBoundSourcesForAction},
+    {"xrEnumerateEnvironmentBlendModes", &wine_xrEnumerateEnvironmentBlendModes},
+    {"xrEnumerateInstanceExtensionProperties", &wine_xrEnumerateInstanceExtensionProperties},
+    {"xrEnumerateReferenceSpaces", &wine_xrEnumerateReferenceSpaces},
+    {"xrEnumerateSwapchainFormats", &wine_xrEnumerateSwapchainFormats},
+    {"xrEnumerateSwapchainImages", &wine_xrEnumerateSwapchainImages},
+    {"xrEnumerateViewConfigurationViews", &wine_xrEnumerateViewConfigurationViews},
+    {"xrEnumerateViewConfigurations", &wine_xrEnumerateViewConfigurations},
+    {"xrGetActionStateBoolean", &wine_xrGetActionStateBoolean},
+    {"xrGetActionStateFloat", &wine_xrGetActionStateFloat},
+    {"xrGetActionStatePose", &wine_xrGetActionStatePose},
+    {"xrGetActionStateVector2f", &wine_xrGetActionStateVector2f},
+    {"xrGetCurrentInteractionProfile", &wine_xrGetCurrentInteractionProfile},
+    {"xrGetD3D11GraphicsRequirementsKHR", &wine_xrGetD3D11GraphicsRequirementsKHR},
+    {"xrGetD3D12GraphicsRequirementsKHR", &wine_xrGetD3D12GraphicsRequirementsKHR},
+    {"xrGetInputSourceLocalizedName", &wine_xrGetInputSourceLocalizedName},
+    {"xrGetInstanceProcAddr", &wine_xrGetInstanceProcAddr},
+    {"xrGetInstanceProperties", &wine_xrGetInstanceProperties},
+    {"xrGetOpenGLGraphicsRequirementsKHR", &wine_xrGetOpenGLGraphicsRequirementsKHR},
+    {"xrGetReferenceSpaceBoundsRect", &wine_xrGetReferenceSpaceBoundsRect},
+    {"xrGetSystem", &wine_xrGetSystem},
+    {"xrGetSystemProperties", &wine_xrGetSystemProperties},
+    {"xrGetViewConfigurationProperties", &wine_xrGetViewConfigurationProperties},
+    {"xrGetVisibilityMaskKHR", &wine_xrGetVisibilityMaskKHR},
+    {"xrGetVulkanDeviceExtensionsKHR", &wine_xrGetVulkanDeviceExtensionsKHR},
+    {"xrGetVulkanGraphicsDeviceKHR", &wine_xrGetVulkanGraphicsDeviceKHR},
+    {"xrGetVulkanGraphicsRequirementsKHR", &wine_xrGetVulkanGraphicsRequirementsKHR},
+    {"xrGetVulkanInstanceExtensionsKHR", &wine_xrGetVulkanInstanceExtensionsKHR},
+    {"xrLocateHandJointsEXT", &wine_xrLocateHandJointsEXT},
+    {"xrLocateSpace", &wine_xrLocateSpace},
+    {"xrLocateViews", &wine_xrLocateViews},
+    {"xrPathToString", &wine_xrPathToString},
+    {"xrPerfSettingsSetPerformanceLevelEXT", &wine_xrPerfSettingsSetPerformanceLevelEXT},
+    {"xrPollEvent", &wine_xrPollEvent},
+    {"xrReleaseSwapchainImage", &wine_xrReleaseSwapchainImage},
+    {"xrRequestExitSession", &wine_xrRequestExitSession},
+    {"xrResultToString", &wine_xrResultToString},
+    {"xrSetInputDeviceActiveEXT", &wine_xrSetInputDeviceActiveEXT},
+    {"xrSetInputDeviceLocationEXT", &wine_xrSetInputDeviceLocationEXT},
+    {"xrSetInputDeviceStateBoolEXT", &wine_xrSetInputDeviceStateBoolEXT},
+    {"xrSetInputDeviceStateFloatEXT", &wine_xrSetInputDeviceStateFloatEXT},
+    {"xrSetInputDeviceStateVector2fEXT", &wine_xrSetInputDeviceStateVector2fEXT},
+    {"xrStopHapticFeedback", &wine_xrStopHapticFeedback},
+    {"xrStringToPath", &wine_xrStringToPath},
+    {"xrStructureTypeToString", &wine_xrStructureTypeToString},
+    {"xrSuggestInteractionProfileBindings", &wine_xrSuggestInteractionProfileBindings},
+    {"xrSyncActions", &wine_xrSyncActions},
+    {"xrThermalGetTemperatureTrendEXT", &wine_xrThermalGetTemperatureTrendEXT},
+    {"xrUpdateHandMeshMSFT", &wine_xrUpdateHandMeshMSFT},
+    {"xrWaitFrame", &wine_xrWaitFrame},
+    {"xrWaitSwapchainImage", &wine_xrWaitSwapchainImage},
+};
+
+void *wine_xr_proc_addr(const char *name)
+{
+    unsigned int i;
+    for (i = 0; i < ARRAY_SIZE(xr_dispatch_table); i++)
+    {
+        if (strcmp(xr_dispatch_table[i].name, name) == 0)
+        {
+            WINE_TRACE("Found name=%s in instance table\n", wine_dbgstr_a(name));
+            return xr_dispatch_table[i].func;
+        }
+    }
+    return NULL;
+}
+
+static const char * const xr_extensions[] =
+{
+    "XR_EPIC_view_configuration_fov",
+    "XR_EXTX_overlay",
+    "XR_EXT_conformance_automation",
+    "XR_EXT_eye_gaze_interaction",
+    "XR_EXT_hand_tracking",
+    "XR_EXT_hp_mixed_reality_controller",
+    "XR_EXT_performance_settings",
+    "XR_EXT_samsung_odyssey_controller",
+    "XR_EXT_thermal_query",
+    "XR_EXT_view_configuration_depth_range",
+    "XR_EXT_win32_appcontainer_compatible",
+    "XR_HUAWEI_controller_interaction",
+    "XR_KHR_D3D11_enable",
+    "XR_KHR_D3D12_enable",
+    "XR_KHR_composition_layer_cube",
+    "XR_KHR_composition_layer_cylinder",
+    "XR_KHR_composition_layer_depth",
+    "XR_KHR_composition_layer_equirect",
+    "XR_KHR_opengl_enable",
+    "XR_KHR_visibility_mask",
+    "XR_KHR_vulkan_enable",
+    "XR_KHR_vulkan_swapchain_format_list",
+    "XR_KHR_win32_convert_performance_counter_time",
+    "XR_MND_headless",
+    "XR_MND_swapchain_usage_input_attachment_bit",
+    "XR_MSFT_first_person_observer",
+    "XR_MSFT_hand_interaction",
+    "XR_MSFT_hand_tracking_mesh",
+    "XR_MSFT_holographic_window_attachment",
+    "XR_MSFT_secondary_view_configuration",
+    "XR_MSFT_spatial_anchor",
+    "XR_MSFT_spatial_graph_bridge",
+    "XR_MSFT_unbounded_reference_space",
+    "XR_OCULUS_android_session_state_enable",
+    "XR_VALVE_analog_threshold",
+    "XR_VARJO_quad_views",
+};
+
+BOOL wine_xr_extension_supported(const char *name)
+{
+    unsigned int i;
+    for (i = 0; i < ARRAY_SIZE(xr_extensions); i++)
+    {
+        if (strcmp(xr_extensions[i], name) == 0)
+            return TRUE;
+    }
+    return FALSE;
+}

wineopenxr/openxr_thunks.h

@@ -0,0 +1,212 @@
+/* Automatically generated from OpenXR xr.xml; DO NOT EDIT!
+ *
+ * This file is generated from OpenXR xr.xml file covered
+ * by the following copyright and permission notice:
+ *
+ * Copyright (c) 2017-2020 The Khronos Group Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ * ------------------------------------------------------------------------
+ *
+ * This file, xr.xml, is the OpenXR API Registry. It is a critically important
+ * and normative part of the OpenXR Specification, including a canonical
+ * machine-readable definition of the API, parameter and member validation
+ * language incorporated into the Specification and reference pages, and other
+ * material which is registered by Khronos, such as tags used by extension and
+ * layer authors. The only authoritative version of xr.xml is the one
+ * maintained in the master branch of the Khronos OpenXR GitHub project.
+ *
+ */
+
+#ifndef __WINE_OPENXR_THUNKS_H
+#define __WINE_OPENXR_THUNKS_H
+
+#define WINE_XR_VERSION XR_API_VERSION_1_0
+
+/* Functions for which we have custom implementations outside of the thunks. */
+XrResult WINAPI wine_xrConvertTimeToWin32PerformanceCounterKHR(XrInstance instance, XrTime time, LARGE_INTEGER *performanceCounter) DECLSPEC_HIDDEN;
+XrResult WINAPI wine_xrConvertWin32PerformanceCounterToTimeKHR(XrInstance instance, const LARGE_INTEGER *performanceCounter, XrTime *time) DECLSPEC_HIDDEN;
+XrResult WINAPI wine_xrCreateHandTrackerEXT(XrSession session, const XrHandTrackerCreateInfoEXT *createInfo, XrHandTrackerEXT *handTracker) DECLSPEC_HIDDEN;
+XrResult WINAPI wine_xrCreateInstance(const XrInstanceCreateInfo *createInfo, XrInstance *instance);
+XrResult WINAPI wine_xrCreateSession(XrInstance instance, const XrSessionCreateInfo *createInfo, XrSession *session);
+XrResult WINAPI wine_xrCreateSpatialAnchorMSFT(XrSession session, const XrSpatialAnchorCreateInfoMSFT *createInfo, XrSpatialAnchorMSFT *anchor) DECLSPEC_HIDDEN;
+XrResult WINAPI wine_xrCreateSwapchain(XrSession session, const XrSwapchainCreateInfo *createInfo, XrSwapchain *swapchain);
+XrResult WINAPI wine_xrDestroyHandTrackerEXT(XrHandTrackerEXT handTracker) DECLSPEC_HIDDEN;
+XrResult WINAPI wine_xrDestroyInstance(XrInstance instance);
+XrResult WINAPI wine_xrDestroySession(XrSession session);
+XrResult WINAPI wine_xrDestroySpatialAnchorMSFT(XrSpatialAnchorMSFT anchor) DECLSPEC_HIDDEN;
+XrResult WINAPI wine_xrDestroySwapchain(XrSwapchain swapchain);
+XrResult WINAPI wine_xrEndFrame(XrSession session, const XrFrameEndInfo *frameEndInfo);
+XrResult WINAPI wine_xrEnumerateInstanceExtensionProperties(const char *layerName, uint32_t propertyCapacityInput, uint32_t *propertyCountOutput, XrExtensionProperties *properties);
+XrResult WINAPI wine_xrEnumerateSwapchainFormats(XrSession session, uint32_t formatCapacityInput, uint32_t *formatCountOutput, int64_t *formats);
+XrResult WINAPI wine_xrEnumerateSwapchainImages(XrSwapchain swapchain, uint32_t imageCapacityInput, uint32_t *imageCountOutput, XrSwapchainImageBaseHeader *images);
+XrResult WINAPI wine_xrGetD3D11GraphicsRequirementsKHR(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsD3D11KHR *graphicsRequirements) DECLSPEC_HIDDEN;
+XrResult WINAPI wine_xrGetD3D12GraphicsRequirementsKHR(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsD3D12KHR *graphicsRequirements) DECLSPEC_HIDDEN;
+XrResult WINAPI wine_xrGetInstanceProcAddr(XrInstance instance, const char *name, PFN_xrVoidFunction *function);
+XrResult WINAPI wine_xrGetSystem(XrInstance instance, const XrSystemGetInfo *getInfo, XrSystemId *systemId);
+XrResult WINAPI wine_xrGetVulkanDeviceExtensionsKHR(XrInstance instance, XrSystemId systemId, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer) DECLSPEC_HIDDEN;
+XrResult WINAPI wine_xrGetVulkanGraphicsDeviceKHR(XrInstance instance, XrSystemId systemId, VkInstance vkInstance, VkPhysicalDevice *vkPhysicalDevice) DECLSPEC_HIDDEN;
+XrResult WINAPI wine_xrGetVulkanInstanceExtensionsKHR(XrInstance instance, XrSystemId systemId, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer) DECLSPEC_HIDDEN;
+XrResult WINAPI wine_xrPollEvent(XrInstance instance, XrEventDataBuffer *eventData);
+
+/* Private thunks */
+
+
+XrResult convert_XrInstanceCreateInfo_struct_chain(const void *next, XrInstanceCreateInfo *out_struct) DECLSPEC_HIDDEN;
+void free_XrInstanceCreateInfo_struct_chain(XrInstanceCreateInfo *s) DECLSPEC_HIDDEN;
+
+/* For use by xrInstance and children */
+struct openxr_instance_funcs
+{
+    XrResult (*p_xrAcquireSwapchainImage)(XrSwapchain, const XrSwapchainImageAcquireInfo *, uint32_t *);
+    XrResult (*p_xrApplyHapticFeedback)(XrSession, const XrHapticActionInfo *, const XrHapticBaseHeader *);
+    XrResult (*p_xrAttachSessionActionSets)(XrSession, const XrSessionActionSetsAttachInfo *);
+    XrResult (*p_xrBeginFrame)(XrSession, const XrFrameBeginInfo *);
+    XrResult (*p_xrBeginSession)(XrSession, const XrSessionBeginInfo *);
+    XrResult (*p_xrCreateAction)(XrActionSet, const XrActionCreateInfo *, XrAction *);
+    XrResult (*p_xrCreateActionSet)(XrInstance, const XrActionSetCreateInfo *, XrActionSet *);
+    XrResult (*p_xrCreateActionSpace)(XrSession, const XrActionSpaceCreateInfo *, XrSpace *);
+    XrResult (*p_xrCreateHandMeshSpaceMSFT)(XrHandTrackerEXT, const XrHandMeshSpaceCreateInfoMSFT *, XrSpace *);
+    XrResult (*p_xrCreateHandTrackerEXT)(XrSession, const XrHandTrackerCreateInfoEXT *, XrHandTrackerEXT *);
+    XrResult (*p_xrCreateReferenceSpace)(XrSession, const XrReferenceSpaceCreateInfo *, XrSpace *);
+    XrResult (*p_xrCreateSession)(XrInstance, const XrSessionCreateInfo *, XrSession *);
+    XrResult (*p_xrCreateSpatialAnchorMSFT)(XrSession, const XrSpatialAnchorCreateInfoMSFT *, XrSpatialAnchorMSFT *);
+    XrResult (*p_xrCreateSpatialAnchorSpaceMSFT)(XrSession, const XrSpatialAnchorSpaceCreateInfoMSFT *, XrSpace *);
+    XrResult (*p_xrCreateSpatialGraphNodeSpaceMSFT)(XrSession, const XrSpatialGraphNodeSpaceCreateInfoMSFT *, XrSpace *);
+    XrResult (*p_xrCreateSwapchain)(XrSession, const XrSwapchainCreateInfo *, XrSwapchain *);
+    XrResult (*p_xrDestroyAction)(XrAction);
+    XrResult (*p_xrDestroyActionSet)(XrActionSet);
+    XrResult (*p_xrDestroyHandTrackerEXT)(XrHandTrackerEXT);
+    XrResult (*p_xrDestroySession)(XrSession);
+    XrResult (*p_xrDestroySpace)(XrSpace);
+    XrResult (*p_xrDestroySpatialAnchorMSFT)(XrSpatialAnchorMSFT);
+    XrResult (*p_xrDestroySwapchain)(XrSwapchain);
+    XrResult (*p_xrEndFrame)(XrSession, const XrFrameEndInfo *);
+    XrResult (*p_xrEndSession)(XrSession);
+    XrResult (*p_xrEnumerateApiLayerProperties)(uint32_t, uint32_t *, XrApiLayerProperties *);
+    XrResult (*p_xrEnumerateBoundSourcesForAction)(XrSession, const XrBoundSourcesForActionEnumerateInfo *, uint32_t, uint32_t *, XrPath *);
+    XrResult (*p_xrEnumerateEnvironmentBlendModes)(XrInstance, XrSystemId, XrViewConfigurationType, uint32_t, uint32_t *, XrEnvironmentBlendMode *);
+    XrResult (*p_xrEnumerateReferenceSpaces)(XrSession, uint32_t, uint32_t *, XrReferenceSpaceType *);
+    XrResult (*p_xrEnumerateSwapchainFormats)(XrSession, uint32_t, uint32_t *, int64_t *);
+    XrResult (*p_xrEnumerateSwapchainImages)(XrSwapchain, uint32_t, uint32_t *, XrSwapchainImageBaseHeader *);
+    XrResult (*p_xrEnumerateViewConfigurationViews)(XrInstance, XrSystemId, XrViewConfigurationType, uint32_t, uint32_t *, XrViewConfigurationView *);
+    XrResult (*p_xrEnumerateViewConfigurations)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrViewConfigurationType *);
+    XrResult (*p_xrGetActionStateBoolean)(XrSession, const XrActionStateGetInfo *, XrActionStateBoolean *);
+    XrResult (*p_xrGetActionStateFloat)(XrSession, const XrActionStateGetInfo *, XrActionStateFloat *);
+    XrResult (*p_xrGetActionStatePose)(XrSession, const XrActionStateGetInfo *, XrActionStatePose *);
+    XrResult (*p_xrGetActionStateVector2f)(XrSession, const XrActionStateGetInfo *, XrActionStateVector2f *);
+    XrResult (*p_xrGetCurrentInteractionProfile)(XrSession, XrPath, XrInteractionProfileState *);
+    XrResult (*p_xrGetInputSourceLocalizedName)(XrSession, const XrInputSourceLocalizedNameGetInfo *, uint32_t, uint32_t *, char *);
+    XrResult (*p_xrGetInstanceProperties)(XrInstance, XrInstanceProperties *);
+    XrResult (*p_xrGetOpenGLGraphicsRequirementsKHR)(XrInstance, XrSystemId, XrGraphicsRequirementsOpenGLKHR *);
+    XrResult (*p_xrGetReferenceSpaceBoundsRect)(XrSession, XrReferenceSpaceType, XrExtent2Df *);
+    XrResult (*p_xrGetSystem)(XrInstance, const XrSystemGetInfo *, XrSystemId *);
+    XrResult (*p_xrGetSystemProperties)(XrInstance, XrSystemId, XrSystemProperties *);
+    XrResult (*p_xrGetViewConfigurationProperties)(XrInstance, XrSystemId, XrViewConfigurationType, XrViewConfigurationProperties *);
+    XrResult (*p_xrGetVisibilityMaskKHR)(XrSession, XrViewConfigurationType, uint32_t, XrVisibilityMaskTypeKHR, XrVisibilityMaskKHR *);
+    XrResult (*p_xrGetVulkanDeviceExtensionsKHR)(XrInstance, XrSystemId, uint32_t, uint32_t *, char *);
+    XrResult (*p_xrGetVulkanGraphicsDeviceKHR)(XrInstance, XrSystemId, VkInstance, VkPhysicalDevice *);
+    XrResult (*p_xrGetVulkanGraphicsRequirementsKHR)(XrInstance, XrSystemId, XrGraphicsRequirementsVulkanKHR *);
+    XrResult (*p_xrGetVulkanInstanceExtensionsKHR)(XrInstance, XrSystemId, uint32_t, uint32_t *, char *);
+    XrResult (*p_xrLocateHandJointsEXT)(XrHandTrackerEXT, const XrHandJointsLocateInfoEXT *, XrHandJointLocationsEXT *);
+    XrResult (*p_xrLocateSpace)(XrSpace, XrSpace, XrTime, XrSpaceLocation *);
+    XrResult (*p_xrLocateViews)(XrSession, const XrViewLocateInfo *, XrViewState *, uint32_t, uint32_t *, XrView *);
+    XrResult (*p_xrPathToString)(XrInstance, XrPath, uint32_t, uint32_t *, char *);
+    XrResult (*p_xrPerfSettingsSetPerformanceLevelEXT)(XrSession, XrPerfSettingsDomainEXT, XrPerfSettingsLevelEXT);
+    XrResult (*p_xrPollEvent)(XrInstance, XrEventDataBuffer *);
+    XrResult (*p_xrReleaseSwapchainImage)(XrSwapchain, const XrSwapchainImageReleaseInfo *);
+    XrResult (*p_xrRequestExitSession)(XrSession);
+    XrResult (*p_xrResultToString)(XrInstance, XrResult, char[]);
+    XrResult (*p_xrSetInputDeviceActiveEXT)(XrSession, XrPath, XrPath, XrBool32);
+    XrResult (*p_xrSetInputDeviceLocationEXT)(XrSession, XrPath, XrPath, XrSpace, XrPosef);
+    XrResult (*p_xrSetInputDeviceStateBoolEXT)(XrSession, XrPath, XrPath, XrBool32);
+    XrResult (*p_xrSetInputDeviceStateFloatEXT)(XrSession, XrPath, XrPath, float);
+    XrResult (*p_xrSetInputDeviceStateVector2fEXT)(XrSession, XrPath, XrPath, XrVector2f);
+    XrResult (*p_xrStopHapticFeedback)(XrSession, const XrHapticActionInfo *);
+    XrResult (*p_xrStringToPath)(XrInstance, const char *, XrPath *);
+    XrResult (*p_xrStructureTypeToString)(XrInstance, XrStructureType, char[]);
+    XrResult (*p_xrSuggestInteractionProfileBindings)(XrInstance, const XrInteractionProfileSuggestedBinding *);
+    XrResult (*p_xrSyncActions)(XrSession, const XrActionsSyncInfo *);
+    XrResult (*p_xrThermalGetTemperatureTrendEXT)(XrSession, XrPerfSettingsDomainEXT, XrPerfSettingsNotificationLevelEXT *, float *, float *);
+    XrResult (*p_xrUpdateHandMeshMSFT)(XrHandTrackerEXT, const XrHandMeshUpdateInfoMSFT *, XrHandMeshMSFT *);
+    XrResult (*p_xrWaitFrame)(XrSession, const XrFrameWaitInfo *, XrFrameState *);
+    XrResult (*p_xrWaitSwapchainImage)(XrSwapchain, const XrSwapchainImageWaitInfo *);
+};
+
+#define ALL_XR_INSTANCE_FUNCS() \
+    USE_XR_FUNC(xrAcquireSwapchainImage) \
+    USE_XR_FUNC(xrApplyHapticFeedback) \
+    USE_XR_FUNC(xrAttachSessionActionSets) \
+    USE_XR_FUNC(xrBeginFrame) \
+    USE_XR_FUNC(xrBeginSession) \
+    USE_XR_FUNC(xrCreateAction) \
+    USE_XR_FUNC(xrCreateActionSet) \
+    USE_XR_FUNC(xrCreateActionSpace) \
+    USE_XR_FUNC(xrCreateHandMeshSpaceMSFT) \
+    USE_XR_FUNC(xrCreateHandTrackerEXT) \
+    USE_XR_FUNC(xrCreateReferenceSpace) \
+    USE_XR_FUNC(xrCreateSession) \
+    USE_XR_FUNC(xrCreateSpatialAnchorMSFT) \
+    USE_XR_FUNC(xrCreateSpatialAnchorSpaceMSFT) \
+    USE_XR_FUNC(xrCreateSpatialGraphNodeSpaceMSFT) \
+    USE_XR_FUNC(xrCreateSwapchain) \
+    USE_XR_FUNC(xrDestroyAction) \
+    USE_XR_FUNC(xrDestroyActionSet) \
+    USE_XR_FUNC(xrDestroyHandTrackerEXT) \
+    USE_XR_FUNC(xrDestroySession) \
+    USE_XR_FUNC(xrDestroySpace) \
+    USE_XR_FUNC(xrDestroySpatialAnchorMSFT) \
+    USE_XR_FUNC(xrDestroySwapchain) \
+    USE_XR_FUNC(xrEndFrame) \
+    USE_XR_FUNC(xrEndSession) \
+    USE_XR_FUNC(xrEnumerateApiLayerProperties) \
+    USE_XR_FUNC(xrEnumerateBoundSourcesForAction) \
+    USE_XR_FUNC(xrEnumerateEnvironmentBlendModes) \
+    USE_XR_FUNC(xrEnumerateReferenceSpaces) \
+    USE_XR_FUNC(xrEnumerateSwapchainFormats) \
+    USE_XR_FUNC(xrEnumerateSwapchainImages) \
+    USE_XR_FUNC(xrEnumerateViewConfigurationViews) \
+    USE_XR_FUNC(xrEnumerateViewConfigurations) \
+    USE_XR_FUNC(xrGetActionStateBoolean) \
+    USE_XR_FUNC(xrGetActionStateFloat) \
+    USE_XR_FUNC(xrGetActionStatePose) \
+    USE_XR_FUNC(xrGetActionStateVector2f) \
+    USE_XR_FUNC(xrGetCurrentInteractionProfile) \
+    USE_XR_FUNC(xrGetInputSourceLocalizedName) \
+    USE_XR_FUNC(xrGetInstanceProperties) \
+    USE_XR_FUNC(xrGetOpenGLGraphicsRequirementsKHR) \
+    USE_XR_FUNC(xrGetReferenceSpaceBoundsRect) \
+    USE_XR_FUNC(xrGetSystem) \
+    USE_XR_FUNC(xrGetSystemProperties) \
+    USE_XR_FUNC(xrGetViewConfigurationProperties) \
+    USE_XR_FUNC(xrGetVisibilityMaskKHR) \
+    USE_XR_FUNC(xrGetVulkanDeviceExtensionsKHR) \
+    USE_XR_FUNC(xrGetVulkanGraphicsDeviceKHR) \
+    USE_XR_FUNC(xrGetVulkanGraphicsRequirementsKHR) \
+    USE_XR_FUNC(xrGetVulkanInstanceExtensionsKHR) \
+    USE_XR_FUNC(xrLocateHandJointsEXT) \
+    USE_XR_FUNC(xrLocateSpace) \
+    USE_XR_FUNC(xrLocateViews) \
+    USE_XR_FUNC(xrPathToString) \
+    USE_XR_FUNC(xrPerfSettingsSetPerformanceLevelEXT) \
+    USE_XR_FUNC(xrPollEvent) \
+    USE_XR_FUNC(xrReleaseSwapchainImage) \
+    USE_XR_FUNC(xrRequestExitSession) \
+    USE_XR_FUNC(xrResultToString) \
+    USE_XR_FUNC(xrSetInputDeviceActiveEXT) \
+    USE_XR_FUNC(xrSetInputDeviceLocationEXT) \
+    USE_XR_FUNC(xrSetInputDeviceStateBoolEXT) \
+    USE_XR_FUNC(xrSetInputDeviceStateFloatEXT) \
+    USE_XR_FUNC(xrSetInputDeviceStateVector2fEXT) \
+    USE_XR_FUNC(xrStopHapticFeedback) \
+    USE_XR_FUNC(xrStringToPath) \
+    USE_XR_FUNC(xrStructureTypeToString) \
+    USE_XR_FUNC(xrSuggestInteractionProfileBindings) \
+    USE_XR_FUNC(xrSyncActions) \
+    USE_XR_FUNC(xrThermalGetTemperatureTrendEXT) \
+    USE_XR_FUNC(xrUpdateHandMeshMSFT) \
+    USE_XR_FUNC(xrWaitFrame) \
+    USE_XR_FUNC(xrWaitSwapchainImage)
+
+#endif /* __WINE_OPENXR_THUNKS_H */

wineopenxr/wineopenxr.spec

@@ -0,0 +1,3 @@
+@ stdcall xrNegotiateLoaderRuntimeInterface(ptr ptr) wine_xrNegotiateLoaderRuntimeInterface
+@ stdcall __wineopenxr_GetVulkanInstanceExtensions(ptr)
+@ stdcall __wineopenxr_GetVulkanDeviceExtensions(ptr)

wineopenxr/wineopenxr64.json

@@ -0,0 +1,6 @@
+{
+   "file_format_version": "1.0.0",
+   "runtime": {
+      "library_path": "C:\\windows\\system32\\wineopenxr.dll"
+   }
+}