wineopenxr: PE split.

CW-Bug-Id: #25198

wineopenxr/Makefile.in

@@ -1,9 +1,11 @@
 MODULE     = wineopenxr.dll
-IMPORTS    = advapi32 dxgi
+UNIXLIB    = wineopenxr.so
+IMPORTS    = advapi32 user32 dxgi winevulkan
 
-EXTRADLLFLAGS = -mcygwin -lvulkan
 EXTRADEFS  = -DWINE_NO_LONG_TYPES
 
 SOURCES = \
 	openxr.c \
+	openxr_loader.c \
 	openxr_thunks.c \
+	loader_thunks.c \

wineopenxr/dxvk-interop.h

@@ -38,7 +38,11 @@ interface IDXGIVkInteropDevice2;
 /* Headers for imported files */
 
 #include <d3d11.h>
+#ifdef __WINESRC__
+#include "wine/vulkan.h"
+#else
 #include <vulkan/vulkan.h>
+#endif
 
 #ifdef __cplusplus
 extern "C" {

wineopenxr/openxr_loader.h

@@ -0,0 +1,119 @@
+#ifndef __WINE_OPENXR_LOADER_H
+#define __WINE_OPENXR_LOADER_H
+
+#include <stdarg.h>
+#include <stdlib.h>
+
+#define COBJMACROS
+#include "ntstatus.h"
+#define WIN32_NO_STATUS
+#include <assert.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include "windef.h"
+#include "winbase.h"
+#include "wine/debug.h"
+#include "wine/list.h"
+#include "wine/unixlib.h"
+#include "wine/vulkan.h"
+
+#include "d3d11.h"
+#include "d3d11_3.h"
+#include "d3d12.h"
+#include "dxgi.h"
+#include "wineopenxr.h"
+#include "loader_thunks.h"
+
+static const char WINE_VULKAN_DEVICE_EXTENSION_NAME[] = "VK_WINE_openxr_device_extensions";
+static const char WINE_VULKAN_DEVICE_VARIABLE[] = "__WINE_OPENXR_VK_DEVICE_EXTENSIONS";
+
+struct IDXGIVkInteropDevice2;
+typedef struct IDXGIVkInteropDevice2 IDXGIVkInteropDevice2;
+typedef struct ID3D12DXVKInteropDevice ID3D12DXVKInteropDevice;
+
+struct vk_create_callback_context {
+  XrInstance wine_instance;
+  UINT64 create_info;
+  XrResult ret;
+};
+
+struct init_openxr_params {
+  HMODULE winevulkan;
+  UINT64 create_instance_callback;
+  UINT64 create_device_callback;
+};
+
+typedef struct {
+  XrInstance host_instance;
+  VkInstance vk_instance;
+  VkPhysicalDevice vk_phys_dev;
+
+  XrSystemId systemId;
+
+  IDXGIVkInteropDevice2 *dxvk_device;
+  ID3D12DXVKInteropDevice *d3d12_device;
+  ID3D12CommandQueue *d3d12_queue;
+
+  VkDevice vk_device;
+  VkQueue vk_queue;
+  VkCommandPool vk_command_pool;
+} wine_XrInstance;
+
+static inline wine_XrInstance *wine_instance_from_handle(XrInstance handle) {
+  return (wine_XrInstance *)(uintptr_t)handle;
+}
+
+union CompositionLayer;
+typedef union CompositionLayer CompositionLayer;
+
+typedef union {
+  XrCompositionLayerDepthInfoKHR depth_info;
+  XrCompositionLayerSpaceWarpInfoFB space_warp_info;
+} view_info;
+
+typedef struct {
+  XrSession host_session;
+  wine_XrInstance *instance;
+  uint32_t session_type;
+  struct list entry;
+  uint32_t composition_layer_count;
+  CompositionLayer *composition_layers;
+  XrCompositionLayerBaseHeader **composition_layer_ptrs;
+
+  uint32_t projection_view_count, view_info_count;
+  XrCompositionLayerProjectionView *projection_views;
+  view_info *view_infos;
+} wine_XrSession;
+
+static inline wine_XrSession *wine_session_from_handle(XrSession handle) {
+  return (wine_XrSession *)(uintptr_t)handle;
+}
+
+typedef struct {
+  XrSwapchain host_swapchain;
+  wine_XrSession *session;
+  XrSwapchainImageBaseHeader *images;
+  uint32_t image_count;
+  uint32_t acquired_count, acquired_start;
+  BOOL *acquired;
+  uint32_t *acquired_indices;
+
+  XrSwapchainCreateInfo create_info;
+  VkCommandBuffer *cmd_release;
+  VkCommandBuffer *cmd_acquire;
+} wine_XrSwapchain;
+
+static inline wine_XrSwapchain *wine_swapchain_from_handle(XrSwapchain handle) {
+  return (wine_XrSwapchain *)(uintptr_t)handle;
+}
+
+void *wine_xr_get_instance_proc_addr(const char *name);
+
+struct openxr_func {
+  const char *name;
+  void *func;
+};
+
+#define UNIX_CALL(code, params) WINE_UNIX_CALL(unix_##code, params)
+
+#endif /* __WINE_OPENXR_LOADER_H */

wineopenxr/openxr_private.h

@@ -1,117 +1,59 @@
+#ifndef __WINE_OPENXR_PRIVATE_H
+#define __WINE_OPENXR_PRIVATE_H
+
+#define WINE_XR_HOST
+
+#include <pthread.h>
+#include <stdbool.h>
+
+#include "openxr_loader.h"
 #include "openxr_thunks.h"
 
-#include "wine/list.h"
+extern struct openxr_instance_funcs g_xr_host_instance_dispatch_table;
 
-#define SESSION_TYPE_VULKAN 1
+struct conversion_context {
-#define SESSION_TYPE_OPENGL 2
+  char buffer[2048];
-#define SESSION_TYPE_D3D11 3
+  uint32_t used;
-#define SESSION_TYPE_D3D12 4
+  struct list alloc_entries;
-
-struct IDXGIVkInteropDevice2;
-typedef struct IDXGIVkInteropDevice2 IDXGIVkInteropDevice2;
-typedef struct ID3D12DXVKInteropDevice ID3D12DXVKInteropDevice;
-
-#define VK_PROCS                \
-    X(vkAllocateCommandBuffers) \
-    X(vkBeginCommandBuffer)     \
-    X(vkEndCommandBuffer)       \
-    X(vkQueueSubmit)            \
-    X(vkQueueWaitIdle)          \
-    X(vkFreeCommandBuffers)     \
-    X(vkCmdPipelineBarrier)     \
-    X(vkCreateCommandPool)      \
-    X(vkDestroyCommandPool)     \
-    X(vkDestroyFence)           \
-    X(vkCreateFence)            \
-    X(vkWaitForFences)          \
-    X(vkResetFences)
-
-typedef struct wine_XrInstance {
-    XrInstance instance;
-    struct openxr_instance_funcs funcs;
-
-    VkInstance vk_instance;
-    VkPhysicalDevice vk_phys_dev;
-
-    XrSystemId systemId;
-
-    IDXGIVkInteropDevice2 *dxvk_device;
-    ID3D12DXVKInteropDevice *d3d12_device;
-    ID3D12CommandQueue *d3d12_queue;
-
-    /* For layout transitions for vkd3d-proton */
-#define X(proc) PFN_##proc p_##proc;
-    VK_PROCS
-#undef X
-    VkDevice vk_device;
-    VkQueue vk_queue;
-    VkCommandPool vk_command_pool;
-} wine_XrInstance;
-
-union CompositionLayer;
-typedef union CompositionLayer CompositionLayer;
-
-typedef union
-{
-    XrCompositionLayerDepthInfoKHR depth_info;
-    XrCompositionLayerSpaceWarpInfoFB space_warp_info;
-} view_info;
-
-typedef struct wine_XrSession {
-    XrSession session;
-    struct wine_XrInstance *wine_instance;
-
-    uint32_t session_type;
-    struct list entry;
-
-    uint32_t composition_layer_count;
-    CompositionLayer *composition_layers;
-    XrCompositionLayerBaseHeader **composition_layer_ptrs;
-
-    uint32_t projection_view_count, view_info_count;
-    XrCompositionLayerProjectionView *projection_views;
-    view_info *view_infos;
-} wine_XrSession;
-
-typedef struct wine_XrSwapchain{
-    XrSwapchain swapchain;
-    XrSwapchainImageBaseHeader *images;
-    uint32_t image_count;
-    uint32_t acquired_count, acquired_start;
-    BOOL *acquired;
-    uint32_t *acquired_indices;
-    struct wine_XrSession *wine_session;
-
-    XrSwapchainCreateInfo create_info;
-    VkCommandBuffer *cmd_release;
-    VkCommandBuffer *cmd_acquire;
-} wine_XrSwapchain;
-
-struct openxr_func {
-    const char *name;
-    void *func;
 };
 
-extern void *wine_xr_proc_addr(const char *name);
+static inline void init_conversion_context(struct conversion_context *pool) {
+  pool->used = 0;
+  list_init(&pool->alloc_entries);
+}
 
-extern XrResult WINAPI wine_xrEnumerateInstanceExtensionProperties(const char *layerName,
+static inline void free_conversion_context(struct conversion_context *pool) {
-        uint32_t propertyCapacityInput, uint32_t *propertyCountOutput, XrExtensionProperties *properties);
+  struct list *entry, *next;
-extern XrResult WINAPI wine_xrConvertTimeToWin32PerformanceCounterKHR(XrInstance instance,
+  LIST_FOR_EACH_SAFE(entry, next, &pool->alloc_entries)
-        XrTime time, LARGE_INTEGER *performanceCounter);
+  free(entry);
-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 (*get_native_VkDevice)(VkDevice);
+static inline void *conversion_context_alloc(struct conversion_context *pool, size_t size) {
-extern VkInstance (*get_native_VkInstance)(VkInstance);
+  if (pool->used + size <= sizeof(pool->buffer)) {
-extern VkPhysicalDevice (*get_native_VkPhysicalDevice)(VkPhysicalDevice);
+    void *ret = pool->buffer + pool->used;
-extern VkPhysicalDevice (*get_wrapped_VkPhysicalDevice)(VkInstance, VkPhysicalDevice);
+    pool->used += (size + sizeof(UINT64) - 1) & ~(sizeof(UINT64) - 1);
-extern VkQueue (*get_native_VkQueue)(VkQueue);
+    return ret;
-extern XrResult load_host_openxr_loader(void);
+  } else {
+    struct list *entry;
+    if (!(entry = malloc(sizeof(*entry) + size))) {
+      return NULL;
+    }
+    list_add_tail(&pool->alloc_entries, entry);
+    return entry + 1;
+  }
+}
 
+NTSTATUS init_openxr(void *args);
+NTSTATUS get_vk_create_callback_ptrs(void *args);
 extern void register_dispatchable_handle(uint64_t handle, struct openxr_instance_funcs *funcs);
 extern void unregister_dispatchable_handle(uint64_t handle);
 extern struct openxr_instance_funcs *get_dispatch_table(uint64_t handle);
+
+#define MEMDUP(ctx, dst, src, count)                               \
+  dst = conversion_context_alloc((ctx), sizeof(*(dst)) * (count)); \
+  memcpy((void *)(dst), (src), sizeof(*(dst)) * (count));
+#define MEMDUP_VOID(ctx, dst, src, size)       \
+  dst = conversion_context_alloc((ctx), size); \
+  memcpy((void *)(dst), (src), size);
+
+#endif /* __WINE_OPENXR_PRIVATE_H */

wineopenxr/openxr_thunks.h

@@ -1,6 +1,6 @@
-/* Automatically generated from OpenXR xr.xml; DO NOT EDIT!
+/* Automatically generated from Vulkan xr.xml; DO NOT EDIT!
  *
- * This file is generated from OpenXR xr.xml file covered
+ * This file is generated from Vulkan xr.xml file covered
  * by the following copyright and permission notice:
  *
  * Copyright (c) 2017-2024, The Khronos Group Inc.
@@ -25,99 +25,14 @@
 #define WINE_XR_VERSION XR_API_VERSION_1_1
 
 /* Functions for which we have custom implementations outside of the thunks. */
-XrResult WINAPI wine_xrAcquireSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageAcquireInfo *acquireInfo, uint32_t *index);
+XrResult wine_xrCreateInstance(const XrInstanceCreateInfo *createInfo, XrInstance *instance);
-XrResult WINAPI wine_xrBeginFrame(XrSession session, const XrFrameBeginInfo *frameBeginInfo);
+XrResult wine_xrCreateSession(XrInstance instance, const XrSessionCreateInfo *createInfo, XrSession *session);
-XrResult WINAPI wine_xrConvertTimeToWin32PerformanceCounterKHR(XrInstance instance, XrTime time, LARGE_INTEGER *performanceCounter);
+XrResult wine_xrCreateSwapchain(XrSession session, const XrSwapchainCreateInfo *createInfo, XrSwapchain *swapchain);
-XrResult WINAPI wine_xrConvertWin32PerformanceCounterToTimeKHR(XrInstance instance, const LARGE_INTEGER *performanceCounter, XrTime *time);
+XrResult wine_xrEnumerateInstanceExtensionProperties(const char *layerName, uint32_t propertyCapacityInput, uint32_t *propertyCountOutput, XrExtensionProperties *properties);
-XrResult WINAPI wine_xrCreateApiLayerInstance(const XrInstanceCreateInfo *info, const XrApiLayerCreateInfo *layerInfo, XrInstance *instance);
+XrResult wine_xrGetVulkanDeviceExtensionsKHR(XrInstance instance, XrSystemId systemId, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer);
-XrResult WINAPI wine_xrCreateInstance(const XrInstanceCreateInfo *createInfo, XrInstance *instance);
+XrResult wine_xrGetVulkanGraphicsDevice2KHR(XrInstance instance, const XrVulkanGraphicsDeviceGetInfoKHR *getInfo, VkPhysicalDevice *vulkanPhysicalDevice);
-XrResult WINAPI wine_xrCreateSession(XrInstance instance, const XrSessionCreateInfo *createInfo, XrSession *session);
+XrResult wine_xrGetVulkanGraphicsDeviceKHR(XrInstance instance, XrSystemId systemId, VkInstance vkInstance, VkPhysicalDevice *vkPhysicalDevice);
-XrResult WINAPI wine_xrCreateSwapchain(XrSession session, const XrSwapchainCreateInfo *createInfo, XrSwapchain *swapchain);
+XrResult wine_xrGetVulkanInstanceExtensionsKHR(XrInstance instance, XrSystemId systemId, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer);
-XrResult WINAPI wine_xrCreateVulkanDeviceKHR(XrInstance instance, const XrVulkanDeviceCreateInfoKHR *createInfo, VkDevice *vulkanDevice, VkResult *vulkanResult);
-XrResult WINAPI wine_xrCreateVulkanInstanceKHR(XrInstance instance, const XrVulkanInstanceCreateInfoKHR *createInfo, VkInstance *vulkanInstance, VkResult *vulkanResult);
-XrResult WINAPI wine_xrDestroyInstance(XrInstance instance);
-XrResult WINAPI wine_xrDestroySession(XrSession session);
-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);
-XrResult WINAPI wine_xrGetD3D12GraphicsRequirementsKHR(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsD3D12KHR *graphicsRequirements);
-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);
-XrResult WINAPI wine_xrGetVulkanGraphicsDevice2KHR(XrInstance instance, const XrVulkanGraphicsDeviceGetInfoKHR *getInfo, VkPhysicalDevice *vulkanPhysicalDevice);
-XrResult WINAPI wine_xrGetVulkanGraphicsDeviceKHR(XrInstance instance, XrSystemId systemId, VkInstance vkInstance, VkPhysicalDevice *vkPhysicalDevice);
-XrResult WINAPI wine_xrGetVulkanInstanceExtensionsKHR(XrInstance instance, XrSystemId systemId, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer);
-XrResult WINAPI wine_xrNegotiateLoaderApiLayerInterface(const XrNegotiateLoaderInfo *loaderInfo, const char *layerName, XrNegotiateApiLayerRequest *apiLayerRequest);
-XrResult WINAPI wine_xrNegotiateLoaderRuntimeInterface(const XrNegotiateLoaderInfo *loaderInfo, XrNegotiateRuntimeRequest *runtimeRequest);
-XrResult WINAPI wine_xrPollEvent(XrInstance instance, XrEventDataBuffer *eventData);
-XrResult WINAPI wine_xrReleaseSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageReleaseInfo *releaseInfo);
-
-/* Private thunks */
-
-typedef struct XrKeyboardSpaceCreateInfoFB_host
-{
-    XrStructureType type;
-    void *next;
-    uint64_t trackedKeyboardId;
-} XrKeyboardSpaceCreateInfoFB_host;
-
-
-typedef struct XrMarkerSpaceCreateInfoVARJO_host
-{
-    XrStructureType type;
-    const void *next;
-    uint64_t markerId;
-    XrPosef poseInMarkerSpace;
-} XrMarkerSpaceCreateInfoVARJO_host;
-
-
-typedef struct XrPlaneDetectorLocationEXT_host
-{
-    XrStructureType type;
-    void *next;
-    uint64_t planeId;
-    XrSpaceLocationFlags locationFlags;
-    XrPosef pose;
-    XrExtent2Df extents;
-    XrPlaneDetectorOrientationEXT orientation;
-    XrPlaneDetectorSemanticTypeEXT semanticType;
-    uint32_t polygonBufferCount;
-} XrPlaneDetectorLocationEXT_host;
-
-
-typedef struct XrPlaneDetectorLocationsEXT_host
-{
-    XrStructureType type;
-    void *next;
-    uint32_t planeLocationCapacityInput;
-    uint32_t planeLocationCountOutput;
-    XrPlaneDetectorLocationEXT_host *planeLocations;
-} XrPlaneDetectorLocationsEXT_host;
-
-
-typedef struct XrSceneMeshBuffersGetInfoMSFT_host
-{
-    XrStructureType type;
-    const void *next;
-    uint64_t meshBufferId;
-} XrSceneMeshBuffersGetInfoMSFT_host;
-
-
-typedef struct XrKeyboardTrackingDescriptionFB_host
-{
-    uint64_t trackedKeyboardId;
-    XrVector3f size;
-    XrKeyboardTrackingFlagsFB flags;
-    char name[XR_MAX_KEYBOARD_TRACKING_NAME_SIZE_FB];
-} XrKeyboardTrackingDescriptionFB_host;
-
-
-
-XrResult convert_XrInstanceCreateInfo_struct_chain(const void *next, XrInstanceCreateInfo *out_struct);
-void free_XrInstanceCreateInfo_struct_chain(XrInstanceCreateInfo *s);
 
 /* For use by xrInstance and children */
 struct openxr_instance_funcs
@@ -125,7 +40,6 @@ struct openxr_instance_funcs
     XrResult (*p_xrAcquireEnvironmentDepthImageMETA)(XrEnvironmentDepthProviderMETA, const XrEnvironmentDepthImageAcquireInfoMETA *, XrEnvironmentDepthImageMETA *);
     XrResult (*p_xrAcquireSwapchainImage)(XrSwapchain, const XrSwapchainImageAcquireInfo *, uint32_t *);
     XrResult (*p_xrApplyForceFeedbackCurlMNDX)(XrHandTrackerEXT, const XrForceFeedbackCurlApplyLocationsMNDX *);
-    XrResult (*p_xrApplyFoveationHTC)(XrSession, const XrFoveationApplyInfoHTC *);
     XrResult (*p_xrApplyHapticFeedback)(XrSession, const XrHapticActionInfo *, const XrHapticBaseHeader *);
     XrResult (*p_xrAttachSessionActionSets)(XrSession, const XrSessionActionSetsAttachInfo *);
     XrResult (*p_xrBeginFrame)(XrSession, const XrFrameBeginInfo *);
@@ -138,6 +52,7 @@ struct openxr_instance_funcs
     XrResult (*p_xrCreateAction)(XrActionSet, const XrActionCreateInfo *, XrAction *);
     XrResult (*p_xrCreateActionSet)(XrInstance, const XrActionSetCreateInfo *, XrActionSet *);
     XrResult (*p_xrCreateActionSpace)(XrSession, const XrActionSpaceCreateInfo *, XrSpace *);
+    XrResult (*p_xrCreateApiLayerInstance)(const XrInstanceCreateInfo *, const XrApiLayerCreateInfo *, XrInstance *);
     XrResult (*p_xrCreateBodyTrackerFB)(XrSession, const XrBodyTrackerCreateInfoFB *, XrBodyTrackerFB *);
     XrResult (*p_xrCreateEnvironmentDepthProviderMETA)(XrSession, const XrEnvironmentDepthProviderCreateInfoMETA *, XrEnvironmentDepthProviderMETA *);
     XrResult (*p_xrCreateEnvironmentDepthSwapchainMETA)(XrEnvironmentDepthProviderMETA, const XrEnvironmentDepthSwapchainCreateInfoMETA *, XrEnvironmentDepthSwapchainMETA *);
@@ -150,18 +65,10 @@ struct openxr_instance_funcs
     XrResult (*p_xrCreateGeometryInstanceFB)(XrSession, const XrGeometryInstanceCreateInfoFB *, XrGeometryInstanceFB *);
     XrResult (*p_xrCreateHandMeshSpaceMSFT)(XrHandTrackerEXT, const XrHandMeshSpaceCreateInfoMSFT *, XrSpace *);
     XrResult (*p_xrCreateHandTrackerEXT)(XrSession, const XrHandTrackerCreateInfoEXT *, XrHandTrackerEXT *);
-#if defined(USE_STRUCT_CONVERSION)
-    XrResult (*p_xrCreateKeyboardSpaceFB)(XrSession, const XrKeyboardSpaceCreateInfoFB_host *, XrSpace *);
-#else
     XrResult (*p_xrCreateKeyboardSpaceFB)(XrSession, const XrKeyboardSpaceCreateInfoFB *, XrSpace *);
-#endif
     XrResult (*p_xrCreateMarkerDetectorML)(XrSession, const XrMarkerDetectorCreateInfoML *, XrMarkerDetectorML *);
     XrResult (*p_xrCreateMarkerSpaceML)(XrSession, const XrMarkerSpaceCreateInfoML *, XrSpace *);
-#if defined(USE_STRUCT_CONVERSION)
-    XrResult (*p_xrCreateMarkerSpaceVARJO)(XrSession, const XrMarkerSpaceCreateInfoVARJO_host *, XrSpace *);
-#else
     XrResult (*p_xrCreateMarkerSpaceVARJO)(XrSession, const XrMarkerSpaceCreateInfoVARJO *, XrSpace *);
-#endif
     XrResult (*p_xrCreatePassthroughColorLutMETA)(XrPassthroughFB, const XrPassthroughColorLutCreateInfoMETA *, XrPassthroughColorLutMETA *);
     XrResult (*p_xrCreatePassthroughFB)(XrSession, const XrPassthroughCreateInfoFB *, XrPassthroughFB *);
     XrResult (*p_xrCreatePassthroughHTC)(XrSession, const XrPassthroughCreateInfoHTC *, XrPassthroughHTC *);
@@ -199,6 +106,7 @@ struct openxr_instance_funcs
     XrResult (*p_xrDestroyFoveationProfileFB)(XrFoveationProfileFB);
     XrResult (*p_xrDestroyGeometryInstanceFB)(XrGeometryInstanceFB);
     XrResult (*p_xrDestroyHandTrackerEXT)(XrHandTrackerEXT);
+    XrResult (*p_xrDestroyInstance)(XrInstance);
     XrResult (*p_xrDestroyMarkerDetectorML)(XrMarkerDetectorML);
     XrResult (*p_xrDestroyPassthroughColorLutMETA)(XrPassthroughColorLutMETA);
     XrResult (*p_xrDestroyPassthroughFB)(XrPassthroughFB);
@@ -275,11 +183,7 @@ struct openxr_instance_funcs
     XrResult (*p_xrGetPassthroughPreferencesMETA)(XrSession, XrPassthroughPreferencesMETA *);
     XrResult (*p_xrGetPerformanceMetricsStateMETA)(XrSession, XrPerformanceMetricsStateMETA *);
     XrResult (*p_xrGetPlaneDetectionStateEXT)(XrPlaneDetectorEXT, XrPlaneDetectionStateEXT *);
-#if defined(USE_STRUCT_CONVERSION)
-    XrResult (*p_xrGetPlaneDetectionsEXT)(XrPlaneDetectorEXT, const XrPlaneDetectorGetInfoEXT *, XrPlaneDetectorLocationsEXT_host *);
-#else
     XrResult (*p_xrGetPlaneDetectionsEXT)(XrPlaneDetectorEXT, const XrPlaneDetectorGetInfoEXT *, XrPlaneDetectorLocationsEXT *);
-#endif
     XrResult (*p_xrGetPlanePolygonBufferEXT)(XrPlaneDetectorEXT, uint64_t, uint32_t, XrPlaneDetectorPolygonBufferEXT *);
     XrResult (*p_xrGetRecommendedLayerResolutionMETA)(XrSession, const XrRecommendedLayerResolutionGetInfoMETA *, XrRecommendedLayerResolutionMETA *);
     XrResult (*p_xrGetReferenceSpaceBoundsRect)(XrSession, XrReferenceSpaceType, XrExtent2Df *);
@@ -288,11 +192,7 @@ struct openxr_instance_funcs
     XrResult (*p_xrGetSceneComputeStateMSFT)(XrSceneObserverMSFT, XrSceneComputeStateMSFT *);
     XrResult (*p_xrGetSceneMarkerDecodedStringMSFT)(XrSceneMSFT, const XrUuidMSFT *, uint32_t, uint32_t *, char *);
     XrResult (*p_xrGetSceneMarkerRawDataMSFT)(XrSceneMSFT, const XrUuidMSFT *, uint32_t, uint32_t *, uint8_t *);
-#if defined(USE_STRUCT_CONVERSION)
-    XrResult (*p_xrGetSceneMeshBuffersMSFT)(XrSceneMSFT, const XrSceneMeshBuffersGetInfoMSFT_host *, XrSceneMeshBuffersMSFT *);
-#else
     XrResult (*p_xrGetSceneMeshBuffersMSFT)(XrSceneMSFT, const XrSceneMeshBuffersGetInfoMSFT *, XrSceneMeshBuffersMSFT *);
-#endif
     XrResult (*p_xrGetSerializedSceneFragmentDataMSFT)(XrSceneMSFT, const XrSerializedSceneFragmentDataGetInfoMSFT *, uint32_t, uint32_t *, uint8_t *);
     XrResult (*p_xrGetSpaceBoundary2DFB)(XrSession, XrSpace, XrBoundary2DFB *);
     XrResult (*p_xrGetSpaceBoundingBox2DFB)(XrSession, XrSpace, XrRect2Df *);
@@ -331,6 +231,7 @@ struct openxr_instance_funcs
     XrResult (*p_xrLocateSpaces)(XrSession, const XrSpacesLocateInfo *, XrSpaceLocations *);
     XrResult (*p_xrLocateSpacesKHR)(XrSession, const XrSpacesLocateInfo *, XrSpaceLocations *);
     XrResult (*p_xrLocateViews)(XrSession, const XrViewLocateInfo *, XrViewState *, uint32_t, uint32_t *, XrView *);
+    XrResult (*p_xrNegotiateLoaderRuntimeInterface)(const XrNegotiateLoaderInfo *, XrNegotiateRuntimeRequest *);
     XrResult (*p_xrPassthroughLayerPauseFB)(XrPassthroughLayerFB);
     XrResult (*p_xrPassthroughLayerResumeFB)(XrPassthroughLayerFB);
     XrResult (*p_xrPassthroughLayerSetKeyboardHandsIntensityFB)(XrPassthroughLayerFB, const XrPassthroughKeyboardHandsIntensityFB *);
@@ -345,11 +246,7 @@ struct openxr_instance_funcs
     XrResult (*p_xrQueryLocalizationMapsML)(XrSession, const XrLocalizationMapQueryInfoBaseHeaderML *, uint32_t, uint32_t *, XrLocalizationMapML *);
     XrResult (*p_xrQueryPerformanceMetricsCounterMETA)(XrSession, XrPath, XrPerformanceMetricsCounterMETA *);
     XrResult (*p_xrQuerySpacesFB)(XrSession, const XrSpaceQueryInfoBaseHeaderFB *, XrAsyncRequestIdFB *);
-#if defined(USE_STRUCT_CONVERSION)
-    XrResult (*p_xrQuerySystemTrackedKeyboardFB)(XrSession, const XrKeyboardTrackingQueryFB *, XrKeyboardTrackingDescriptionFB_host *);
-#else
     XrResult (*p_xrQuerySystemTrackedKeyboardFB)(XrSession, const XrKeyboardTrackingQueryFB *, XrKeyboardTrackingDescriptionFB *);
-#endif
     XrResult (*p_xrReleaseSwapchainImage)(XrSwapchain, const XrSwapchainImageReleaseInfo *);
     XrResult (*p_xrRequestDisplayRefreshRateFB)(XrSession, float);
     XrResult (*p_xrRequestExitSession)(XrSession);
@@ -407,7 +304,6 @@ struct openxr_instance_funcs
     USE_XR_FUNC(xrAcquireEnvironmentDepthImageMETA) \
     USE_XR_FUNC(xrAcquireSwapchainImage) \
     USE_XR_FUNC(xrApplyForceFeedbackCurlMNDX) \
-    USE_XR_FUNC(xrApplyFoveationHTC) \
     USE_XR_FUNC(xrApplyHapticFeedback) \
     USE_XR_FUNC(xrAttachSessionActionSets) \
     USE_XR_FUNC(xrBeginFrame) \
@@ -420,6 +316,7 @@ struct openxr_instance_funcs
     USE_XR_FUNC(xrCreateAction) \
     USE_XR_FUNC(xrCreateActionSet) \
     USE_XR_FUNC(xrCreateActionSpace) \
+    USE_XR_FUNC(xrCreateApiLayerInstance) \
     USE_XR_FUNC(xrCreateBodyTrackerFB) \
     USE_XR_FUNC(xrCreateEnvironmentDepthProviderMETA) \
     USE_XR_FUNC(xrCreateEnvironmentDepthSwapchainMETA) \
@@ -473,6 +370,7 @@ struct openxr_instance_funcs
     USE_XR_FUNC(xrDestroyFoveationProfileFB) \
     USE_XR_FUNC(xrDestroyGeometryInstanceFB) \
     USE_XR_FUNC(xrDestroyHandTrackerEXT) \
+    USE_XR_FUNC(xrDestroyInstance) \
     USE_XR_FUNC(xrDestroyMarkerDetectorML) \
     USE_XR_FUNC(xrDestroyPassthroughColorLutMETA) \
     USE_XR_FUNC(xrDestroyPassthroughFB) \
@@ -597,6 +495,7 @@ struct openxr_instance_funcs
     USE_XR_FUNC(xrLocateSpaces) \
     USE_XR_FUNC(xrLocateSpacesKHR) \
     USE_XR_FUNC(xrLocateViews) \
+    USE_XR_FUNC(xrNegotiateLoaderRuntimeInterface) \
     USE_XR_FUNC(xrPassthroughLayerPauseFB) \
     USE_XR_FUNC(xrPassthroughLayerResumeFB) \
     USE_XR_FUNC(xrPassthroughLayerSetKeyboardHandsIntensityFB) \

wineopenxr/vkd3d-proton-interop.h

@@ -3,7 +3,11 @@
 #pragma once
 
 #include <d3d12.h>
+#ifdef __WINESRC__
+#include "wine/vulkan.h"
+#else
 #include <vulkan/vulkan.h>
+#endif
 
 #ifndef __ID3D12DeviceExt1_FWD_DEFINED__
 #define __ID3D12DeviceExt1_FWD_DEFINED__

wineopenxr/wineopenxr.json

@@ -0,0 +1,7 @@
+{
+    "file_format_version": "1.0.0",
+    "ICD": {
+        "library_path": ".\\wineopenxr.dll",
+        "api_version": "1.1.36"
+    }
+}

wineopenxr/wineopenxr.spec

@@ -1,4 +1,4 @@
-@ stdcall xrNegotiateLoaderRuntimeInterface(ptr ptr) wine_xrNegotiateLoaderRuntimeInterface
+@ stdcall xrNegotiateLoaderRuntimeInterface(ptr ptr)
 @ stdcall __wineopenxr_GetVulkanInstanceExtensions(long ptr ptr)
 @ stdcall __wineopenxr_GetVulkanDeviceExtensions(long ptr ptr)