From 4ef5ee68896fa45f2773caf41e37c814a4618a8d Mon Sep 17 00:00:00 2001 From: Billy Laws Date: Thu, 27 Mar 2025 22:42:50 +0000 Subject: [PATCH] wineopenxr: PE split. CW-Bug-Id: #25198 --- wineopenxr/Makefile.in | 8 +- wineopenxr/dxvk-interop.h | 4 + wineopenxr/loader_thunks.c | 3182 ++++++ wineopenxr/loader_thunks.h | 2285 +++++ wineopenxr/make_openxr | 3031 +++--- wineopenxr/openxr.c | 2757 +---- wineopenxr/openxr_loader.c | 1961 ++++ wineopenxr/openxr_loader.h | 119 + wineopenxr/openxr_private.h | 154 +- wineopenxr/openxr_thunks.c | 4170 ++++---- wineopenxr/openxr_thunks.h | 133 +- wineopenxr/vkd3d-proton-interop.h | 4 + wineopenxr/wineopenxr.h | 6223 ++++++------ wineopenxr/wineopenxr.json | 7 + wineopenxr/wineopenxr.spec | 2 +- wineopenxr/xr.xml | 15219 ---------------------------- 16 files changed, 15193 insertions(+), 24066 deletions(-) create mode 100644 wineopenxr/loader_thunks.c create mode 100644 wineopenxr/loader_thunks.h create mode 100644 wineopenxr/openxr_loader.c create mode 100644 wineopenxr/openxr_loader.h create mode 100644 wineopenxr/wineopenxr.json delete mode 100644 wineopenxr/xr.xml diff --git a/wineopenxr/Makefile.in b/wineopenxr/Makefile.in index e2cd8b7a..05583209 100644 --- a/wineopenxr/Makefile.in +++ b/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 +EXTRADEFS = -DWINE_NO_LONG_TYPES SOURCES = \ openxr.c \ + openxr_loader.c \ openxr_thunks.c \ + loader_thunks.c \ diff --git a/wineopenxr/dxvk-interop.h b/wineopenxr/dxvk-interop.h index 0871b91f..946aa1e1 100644 --- a/wineopenxr/dxvk-interop.h +++ b/wineopenxr/dxvk-interop.h @@ -38,7 +38,11 @@ interface IDXGIVkInteropDevice2; /* Headers for imported files */ #include +#ifdef __WINESRC__ +#include "wine/vulkan.h" +#else #include +#endif #ifdef __cplusplus extern "C" { diff --git a/wineopenxr/loader_thunks.c b/wineopenxr/loader_thunks.c new file mode 100644 index 00000000..ef42e8bc --- /dev/null +++ b/wineopenxr/loader_thunks.c @@ -0,0 +1,3182 @@ +/* Automatically generated from Vulkan xr.xml; DO NOT EDIT! + * + * 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. + * + * 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 default branch of the Khronos OpenXR GitHub project. + * + */ + +#include "openxr_loader.h" + +WINE_DEFAULT_DEBUG_CHANNEL(openxr); + +XrResult WINAPI xrAcquireEnvironmentDepthImageMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider, const XrEnvironmentDepthImageAcquireInfoMETA *acquireInfo, XrEnvironmentDepthImageMETA *environmentDepthImage) +{ + struct xrAcquireEnvironmentDepthImageMETA_params params; + NTSTATUS _status; + params.environmentDepthProvider = environmentDepthProvider; + params.acquireInfo = acquireInfo; + params.environmentDepthImage = environmentDepthImage; + _status = UNIX_CALL(xrAcquireEnvironmentDepthImageMETA, ¶ms); + assert(!_status && "xrAcquireEnvironmentDepthImageMETA"); + return params.result; +} + +XrResult WINAPI xrApplyForceFeedbackCurlMNDX(XrHandTrackerEXT handTracker, const XrForceFeedbackCurlApplyLocationsMNDX *locations) +{ + struct xrApplyForceFeedbackCurlMNDX_params params; + NTSTATUS _status; + params.handTracker = handTracker; + params.locations = locations; + _status = UNIX_CALL(xrApplyForceFeedbackCurlMNDX, ¶ms); + assert(!_status && "xrApplyForceFeedbackCurlMNDX"); + return params.result; +} + +XrResult WINAPI xrApplyHapticFeedback(XrSession session, const XrHapticActionInfo *hapticActionInfo, const XrHapticBaseHeader *hapticFeedback) +{ + struct xrApplyHapticFeedback_params params; + NTSTATUS _status; + params.session = session; + params.hapticActionInfo = hapticActionInfo; + params.hapticFeedback = hapticFeedback; + _status = UNIX_CALL(xrApplyHapticFeedback, ¶ms); + assert(!_status && "xrApplyHapticFeedback"); + return params.result; +} + +XrResult WINAPI xrAttachSessionActionSets(XrSession session, const XrSessionActionSetsAttachInfo *attachInfo) +{ + struct xrAttachSessionActionSets_params params; + NTSTATUS _status; + params.session = session; + params.attachInfo = attachInfo; + _status = UNIX_CALL(xrAttachSessionActionSets, ¶ms); + assert(!_status && "xrAttachSessionActionSets"); + return params.result; +} + +XrResult WINAPI xrBeginPlaneDetectionEXT(XrPlaneDetectorEXT planeDetector, const XrPlaneDetectorBeginInfoEXT *beginInfo) +{ + struct xrBeginPlaneDetectionEXT_params params; + NTSTATUS _status; + params.planeDetector = planeDetector; + params.beginInfo = beginInfo; + _status = UNIX_CALL(xrBeginPlaneDetectionEXT, ¶ms); + assert(!_status && "xrBeginPlaneDetectionEXT"); + return params.result; +} + +XrResult WINAPI xrBeginSession(XrSession session, const XrSessionBeginInfo *beginInfo) +{ + struct xrBeginSession_params params; + NTSTATUS _status; + params.session = session; + params.beginInfo = beginInfo; + _status = UNIX_CALL(xrBeginSession, ¶ms); + assert(!_status && "xrBeginSession"); + return params.result; +} + +XrResult WINAPI xrCancelFutureEXT(XrInstance instance, const XrFutureCancelInfoEXT *cancelInfo) +{ + struct xrCancelFutureEXT_params params; + NTSTATUS _status; + params.instance = instance; + params.cancelInfo = cancelInfo; + _status = UNIX_CALL(xrCancelFutureEXT, ¶ms); + assert(!_status && "xrCancelFutureEXT"); + return params.result; +} + +XrResult WINAPI xrChangeVirtualKeyboardTextContextMETA(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardTextContextChangeInfoMETA *changeInfo) +{ + struct xrChangeVirtualKeyboardTextContextMETA_params params; + NTSTATUS _status; + params.keyboard = keyboard; + params.changeInfo = changeInfo; + _status = UNIX_CALL(xrChangeVirtualKeyboardTextContextMETA, ¶ms); + assert(!_status && "xrChangeVirtualKeyboardTextContextMETA"); + return params.result; +} + +XrResult WINAPI xrClearSpatialAnchorStoreMSFT(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore) +{ + struct xrClearSpatialAnchorStoreMSFT_params params; + NTSTATUS _status; + params.spatialAnchorStore = spatialAnchorStore; + _status = UNIX_CALL(xrClearSpatialAnchorStoreMSFT, ¶ms); + assert(!_status && "xrClearSpatialAnchorStoreMSFT"); + return params.result; +} + +XrResult WINAPI xrComputeNewSceneMSFT(XrSceneObserverMSFT sceneObserver, const XrNewSceneComputeInfoMSFT *computeInfo) +{ + struct xrComputeNewSceneMSFT_params params; + NTSTATUS _status; + params.sceneObserver = sceneObserver; + params.computeInfo = computeInfo; + _status = UNIX_CALL(xrComputeNewSceneMSFT, ¶ms); + assert(!_status && "xrComputeNewSceneMSFT"); + return params.result; +} + +XrResult WINAPI xrCreateAction(XrActionSet actionSet, const XrActionCreateInfo *createInfo, XrAction *action) +{ + struct xrCreateAction_params params; + NTSTATUS _status; + params.actionSet = actionSet; + params.createInfo = createInfo; + params.action = action; + _status = UNIX_CALL(xrCreateAction, ¶ms); + assert(!_status && "xrCreateAction"); + return params.result; +} + +XrResult WINAPI xrCreateActionSet(XrInstance instance, const XrActionSetCreateInfo *createInfo, XrActionSet *actionSet) +{ + struct xrCreateActionSet_params params; + NTSTATUS _status; + params.instance = instance; + params.createInfo = createInfo; + params.actionSet = actionSet; + _status = UNIX_CALL(xrCreateActionSet, ¶ms); + assert(!_status && "xrCreateActionSet"); + return params.result; +} + +XrResult WINAPI xrCreateActionSpace(XrSession session, const XrActionSpaceCreateInfo *createInfo, XrSpace *space) +{ + struct xrCreateActionSpace_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.space = space; + _status = UNIX_CALL(xrCreateActionSpace, ¶ms); + assert(!_status && "xrCreateActionSpace"); + return params.result; +} + +XrResult WINAPI xrCreateBodyTrackerFB(XrSession session, const XrBodyTrackerCreateInfoFB *createInfo, XrBodyTrackerFB *bodyTracker) +{ + struct xrCreateBodyTrackerFB_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.bodyTracker = bodyTracker; + _status = UNIX_CALL(xrCreateBodyTrackerFB, ¶ms); + assert(!_status && "xrCreateBodyTrackerFB"); + return params.result; +} + +XrResult WINAPI xrCreateEnvironmentDepthProviderMETA(XrSession session, const XrEnvironmentDepthProviderCreateInfoMETA *createInfo, XrEnvironmentDepthProviderMETA *environmentDepthProvider) +{ + struct xrCreateEnvironmentDepthProviderMETA_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.environmentDepthProvider = environmentDepthProvider; + _status = UNIX_CALL(xrCreateEnvironmentDepthProviderMETA, ¶ms); + assert(!_status && "xrCreateEnvironmentDepthProviderMETA"); + return params.result; +} + +XrResult WINAPI xrCreateEnvironmentDepthSwapchainMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider, const XrEnvironmentDepthSwapchainCreateInfoMETA *createInfo, XrEnvironmentDepthSwapchainMETA *swapchain) +{ + struct xrCreateEnvironmentDepthSwapchainMETA_params params; + NTSTATUS _status; + params.environmentDepthProvider = environmentDepthProvider; + params.createInfo = createInfo; + params.swapchain = swapchain; + _status = UNIX_CALL(xrCreateEnvironmentDepthSwapchainMETA, ¶ms); + assert(!_status && "xrCreateEnvironmentDepthSwapchainMETA"); + return params.result; +} + +XrResult WINAPI xrCreateExportedLocalizationMapML(XrSession session, const XrUuidEXT *mapUuid, XrExportedLocalizationMapML *map) +{ + struct xrCreateExportedLocalizationMapML_params params; + NTSTATUS _status; + params.session = session; + params.mapUuid = mapUuid; + params.map = map; + _status = UNIX_CALL(xrCreateExportedLocalizationMapML, ¶ms); + assert(!_status && "xrCreateExportedLocalizationMapML"); + return params.result; +} + +XrResult WINAPI xrCreateEyeTrackerFB(XrSession session, const XrEyeTrackerCreateInfoFB *createInfo, XrEyeTrackerFB *eyeTracker) +{ + struct xrCreateEyeTrackerFB_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.eyeTracker = eyeTracker; + _status = UNIX_CALL(xrCreateEyeTrackerFB, ¶ms); + assert(!_status && "xrCreateEyeTrackerFB"); + return params.result; +} + +XrResult WINAPI xrCreateFaceTracker2FB(XrSession session, const XrFaceTrackerCreateInfo2FB *createInfo, XrFaceTracker2FB *faceTracker) +{ + struct xrCreateFaceTracker2FB_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.faceTracker = faceTracker; + _status = UNIX_CALL(xrCreateFaceTracker2FB, ¶ms); + assert(!_status && "xrCreateFaceTracker2FB"); + return params.result; +} + +XrResult WINAPI xrCreateFaceTrackerFB(XrSession session, const XrFaceTrackerCreateInfoFB *createInfo, XrFaceTrackerFB *faceTracker) +{ + struct xrCreateFaceTrackerFB_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.faceTracker = faceTracker; + _status = UNIX_CALL(xrCreateFaceTrackerFB, ¶ms); + assert(!_status && "xrCreateFaceTrackerFB"); + return params.result; +} + +XrResult WINAPI xrCreateFacialTrackerHTC(XrSession session, const XrFacialTrackerCreateInfoHTC *createInfo, XrFacialTrackerHTC *facialTracker) +{ + struct xrCreateFacialTrackerHTC_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.facialTracker = facialTracker; + _status = UNIX_CALL(xrCreateFacialTrackerHTC, ¶ms); + assert(!_status && "xrCreateFacialTrackerHTC"); + return params.result; +} + +XrResult WINAPI xrCreateFoveationProfileFB(XrSession session, const XrFoveationProfileCreateInfoFB *createInfo, XrFoveationProfileFB *profile) +{ + struct xrCreateFoveationProfileFB_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.profile = profile; + _status = UNIX_CALL(xrCreateFoveationProfileFB, ¶ms); + assert(!_status && "xrCreateFoveationProfileFB"); + return params.result; +} + +XrResult WINAPI xrCreateGeometryInstanceFB(XrSession session, const XrGeometryInstanceCreateInfoFB *createInfo, XrGeometryInstanceFB *outGeometryInstance) +{ + struct xrCreateGeometryInstanceFB_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.outGeometryInstance = outGeometryInstance; + _status = UNIX_CALL(xrCreateGeometryInstanceFB, ¶ms); + assert(!_status && "xrCreateGeometryInstanceFB"); + return params.result; +} + +XrResult WINAPI xrCreateHandMeshSpaceMSFT(XrHandTrackerEXT handTracker, const XrHandMeshSpaceCreateInfoMSFT *createInfo, XrSpace *space) +{ + struct xrCreateHandMeshSpaceMSFT_params params; + NTSTATUS _status; + params.handTracker = handTracker; + params.createInfo = createInfo; + params.space = space; + _status = UNIX_CALL(xrCreateHandMeshSpaceMSFT, ¶ms); + assert(!_status && "xrCreateHandMeshSpaceMSFT"); + return params.result; +} + +XrResult WINAPI xrCreateHandTrackerEXT(XrSession session, const XrHandTrackerCreateInfoEXT *createInfo, XrHandTrackerEXT *handTracker) +{ + struct xrCreateHandTrackerEXT_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.handTracker = handTracker; + _status = UNIX_CALL(xrCreateHandTrackerEXT, ¶ms); + assert(!_status && "xrCreateHandTrackerEXT"); + return params.result; +} + +XrResult WINAPI xrCreateKeyboardSpaceFB(XrSession session, const XrKeyboardSpaceCreateInfoFB *createInfo, XrSpace *keyboardSpace) +{ + struct xrCreateKeyboardSpaceFB_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.keyboardSpace = keyboardSpace; + _status = UNIX_CALL(xrCreateKeyboardSpaceFB, ¶ms); + assert(!_status && "xrCreateKeyboardSpaceFB"); + return params.result; +} + +XrResult WINAPI xrCreateMarkerDetectorML(XrSession session, const XrMarkerDetectorCreateInfoML *createInfo, XrMarkerDetectorML *markerDetector) +{ + struct xrCreateMarkerDetectorML_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.markerDetector = markerDetector; + _status = UNIX_CALL(xrCreateMarkerDetectorML, ¶ms); + assert(!_status && "xrCreateMarkerDetectorML"); + return params.result; +} + +XrResult WINAPI xrCreateMarkerSpaceML(XrSession session, const XrMarkerSpaceCreateInfoML *createInfo, XrSpace *space) +{ + struct xrCreateMarkerSpaceML_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.space = space; + _status = UNIX_CALL(xrCreateMarkerSpaceML, ¶ms); + assert(!_status && "xrCreateMarkerSpaceML"); + return params.result; +} + +XrResult WINAPI xrCreateMarkerSpaceVARJO(XrSession session, const XrMarkerSpaceCreateInfoVARJO *createInfo, XrSpace *space) +{ + struct xrCreateMarkerSpaceVARJO_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.space = space; + _status = UNIX_CALL(xrCreateMarkerSpaceVARJO, ¶ms); + assert(!_status && "xrCreateMarkerSpaceVARJO"); + return params.result; +} + +XrResult WINAPI xrCreatePassthroughColorLutMETA(XrPassthroughFB passthrough, const XrPassthroughColorLutCreateInfoMETA *createInfo, XrPassthroughColorLutMETA *colorLut) +{ + struct xrCreatePassthroughColorLutMETA_params params; + NTSTATUS _status; + params.passthrough = passthrough; + params.createInfo = createInfo; + params.colorLut = colorLut; + _status = UNIX_CALL(xrCreatePassthroughColorLutMETA, ¶ms); + assert(!_status && "xrCreatePassthroughColorLutMETA"); + return params.result; +} + +XrResult WINAPI xrCreatePassthroughFB(XrSession session, const XrPassthroughCreateInfoFB *createInfo, XrPassthroughFB *outPassthrough) +{ + struct xrCreatePassthroughFB_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.outPassthrough = outPassthrough; + _status = UNIX_CALL(xrCreatePassthroughFB, ¶ms); + assert(!_status && "xrCreatePassthroughFB"); + return params.result; +} + +XrResult WINAPI xrCreatePassthroughHTC(XrSession session, const XrPassthroughCreateInfoHTC *createInfo, XrPassthroughHTC *passthrough) +{ + struct xrCreatePassthroughHTC_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.passthrough = passthrough; + _status = UNIX_CALL(xrCreatePassthroughHTC, ¶ms); + assert(!_status && "xrCreatePassthroughHTC"); + return params.result; +} + +XrResult WINAPI xrCreatePassthroughLayerFB(XrSession session, const XrPassthroughLayerCreateInfoFB *createInfo, XrPassthroughLayerFB *outLayer) +{ + struct xrCreatePassthroughLayerFB_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.outLayer = outLayer; + _status = UNIX_CALL(xrCreatePassthroughLayerFB, ¶ms); + assert(!_status && "xrCreatePassthroughLayerFB"); + return params.result; +} + +XrResult WINAPI xrCreatePlaneDetectorEXT(XrSession session, const XrPlaneDetectorCreateInfoEXT *createInfo, XrPlaneDetectorEXT *planeDetector) +{ + struct xrCreatePlaneDetectorEXT_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.planeDetector = planeDetector; + _status = UNIX_CALL(xrCreatePlaneDetectorEXT, ¶ms); + assert(!_status && "xrCreatePlaneDetectorEXT"); + return params.result; +} + +XrResult WINAPI xrCreateReferenceSpace(XrSession session, const XrReferenceSpaceCreateInfo *createInfo, XrSpace *space) +{ + struct xrCreateReferenceSpace_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.space = space; + _status = UNIX_CALL(xrCreateReferenceSpace, ¶ms); + assert(!_status && "xrCreateReferenceSpace"); + return params.result; +} + +XrResult WINAPI xrCreateSceneMSFT(XrSceneObserverMSFT sceneObserver, const XrSceneCreateInfoMSFT *createInfo, XrSceneMSFT *scene) +{ + struct xrCreateSceneMSFT_params params; + NTSTATUS _status; + params.sceneObserver = sceneObserver; + params.createInfo = createInfo; + params.scene = scene; + _status = UNIX_CALL(xrCreateSceneMSFT, ¶ms); + assert(!_status && "xrCreateSceneMSFT"); + return params.result; +} + +XrResult WINAPI xrCreateSceneObserverMSFT(XrSession session, const XrSceneObserverCreateInfoMSFT *createInfo, XrSceneObserverMSFT *sceneObserver) +{ + struct xrCreateSceneObserverMSFT_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.sceneObserver = sceneObserver; + _status = UNIX_CALL(xrCreateSceneObserverMSFT, ¶ms); + assert(!_status && "xrCreateSceneObserverMSFT"); + return params.result; +} + +XrResult WINAPI xrCreateSpaceUserFB(XrSession session, const XrSpaceUserCreateInfoFB *info, XrSpaceUserFB *user) +{ + struct xrCreateSpaceUserFB_params params; + NTSTATUS _status; + params.session = session; + params.info = info; + params.user = user; + _status = UNIX_CALL(xrCreateSpaceUserFB, ¶ms); + assert(!_status && "xrCreateSpaceUserFB"); + return params.result; +} + +XrResult WINAPI xrCreateSpatialAnchorFB(XrSession session, const XrSpatialAnchorCreateInfoFB *info, XrAsyncRequestIdFB *requestId) +{ + struct xrCreateSpatialAnchorFB_params params; + NTSTATUS _status; + params.session = session; + params.info = info; + params.requestId = requestId; + _status = UNIX_CALL(xrCreateSpatialAnchorFB, ¶ms); + assert(!_status && "xrCreateSpatialAnchorFB"); + return params.result; +} + +XrResult WINAPI xrCreateSpatialAnchorFromPersistedNameMSFT(XrSession session, const XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT *spatialAnchorCreateInfo, XrSpatialAnchorMSFT *spatialAnchor) +{ + struct xrCreateSpatialAnchorFromPersistedNameMSFT_params params; + NTSTATUS _status; + params.session = session; + params.spatialAnchorCreateInfo = spatialAnchorCreateInfo; + params.spatialAnchor = spatialAnchor; + _status = UNIX_CALL(xrCreateSpatialAnchorFromPersistedNameMSFT, ¶ms); + assert(!_status && "xrCreateSpatialAnchorFromPersistedNameMSFT"); + return params.result; +} + +XrResult WINAPI xrCreateSpatialAnchorHTC(XrSession session, const XrSpatialAnchorCreateInfoHTC *createInfo, XrSpace *anchor) +{ + struct xrCreateSpatialAnchorHTC_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.anchor = anchor; + _status = UNIX_CALL(xrCreateSpatialAnchorHTC, ¶ms); + assert(!_status && "xrCreateSpatialAnchorHTC"); + return params.result; +} + +XrResult WINAPI xrCreateSpatialAnchorMSFT(XrSession session, const XrSpatialAnchorCreateInfoMSFT *createInfo, XrSpatialAnchorMSFT *anchor) +{ + struct xrCreateSpatialAnchorMSFT_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.anchor = anchor; + _status = UNIX_CALL(xrCreateSpatialAnchorMSFT, ¶ms); + assert(!_status && "xrCreateSpatialAnchorMSFT"); + return params.result; +} + +XrResult WINAPI xrCreateSpatialAnchorSpaceMSFT(XrSession session, const XrSpatialAnchorSpaceCreateInfoMSFT *createInfo, XrSpace *space) +{ + struct xrCreateSpatialAnchorSpaceMSFT_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.space = space; + _status = UNIX_CALL(xrCreateSpatialAnchorSpaceMSFT, ¶ms); + assert(!_status && "xrCreateSpatialAnchorSpaceMSFT"); + return params.result; +} + +XrResult WINAPI xrCreateSpatialAnchorStoreConnectionMSFT(XrSession session, XrSpatialAnchorStoreConnectionMSFT *spatialAnchorStore) +{ + struct xrCreateSpatialAnchorStoreConnectionMSFT_params params; + NTSTATUS _status; + params.session = session; + params.spatialAnchorStore = spatialAnchorStore; + _status = UNIX_CALL(xrCreateSpatialAnchorStoreConnectionMSFT, ¶ms); + assert(!_status && "xrCreateSpatialAnchorStoreConnectionMSFT"); + return params.result; +} + +XrResult WINAPI xrCreateSpatialGraphNodeSpaceMSFT(XrSession session, const XrSpatialGraphNodeSpaceCreateInfoMSFT *createInfo, XrSpace *space) +{ + struct xrCreateSpatialGraphNodeSpaceMSFT_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.space = space; + _status = UNIX_CALL(xrCreateSpatialGraphNodeSpaceMSFT, ¶ms); + assert(!_status && "xrCreateSpatialGraphNodeSpaceMSFT"); + return params.result; +} + +XrResult WINAPI xrCreateTriangleMeshFB(XrSession session, const XrTriangleMeshCreateInfoFB *createInfo, XrTriangleMeshFB *outTriangleMesh) +{ + struct xrCreateTriangleMeshFB_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.outTriangleMesh = outTriangleMesh; + _status = UNIX_CALL(xrCreateTriangleMeshFB, ¶ms); + assert(!_status && "xrCreateTriangleMeshFB"); + return params.result; +} + +XrResult WINAPI xrCreateVirtualKeyboardMETA(XrSession session, const XrVirtualKeyboardCreateInfoMETA *createInfo, XrVirtualKeyboardMETA *keyboard) +{ + struct xrCreateVirtualKeyboardMETA_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.keyboard = keyboard; + _status = UNIX_CALL(xrCreateVirtualKeyboardMETA, ¶ms); + assert(!_status && "xrCreateVirtualKeyboardMETA"); + return params.result; +} + +XrResult WINAPI xrCreateVirtualKeyboardSpaceMETA(XrSession session, XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardSpaceCreateInfoMETA *createInfo, XrSpace *keyboardSpace) +{ + struct xrCreateVirtualKeyboardSpaceMETA_params params; + NTSTATUS _status; + params.session = session; + params.keyboard = keyboard; + params.createInfo = createInfo; + params.keyboardSpace = keyboardSpace; + _status = UNIX_CALL(xrCreateVirtualKeyboardSpaceMETA, ¶ms); + assert(!_status && "xrCreateVirtualKeyboardSpaceMETA"); + return params.result; +} + +XrResult WINAPI xrDeserializeSceneMSFT(XrSceneObserverMSFT sceneObserver, const XrSceneDeserializeInfoMSFT *deserializeInfo) +{ + struct xrDeserializeSceneMSFT_params params; + NTSTATUS _status; + params.sceneObserver = sceneObserver; + params.deserializeInfo = deserializeInfo; + _status = UNIX_CALL(xrDeserializeSceneMSFT, ¶ms); + assert(!_status && "xrDeserializeSceneMSFT"); + return params.result; +} + +XrResult WINAPI xrDestroyAction(XrAction action) +{ + struct xrDestroyAction_params params; + NTSTATUS _status; + params.action = action; + _status = UNIX_CALL(xrDestroyAction, ¶ms); + assert(!_status && "xrDestroyAction"); + return params.result; +} + +XrResult WINAPI xrDestroyActionSet(XrActionSet actionSet) +{ + struct xrDestroyActionSet_params params; + NTSTATUS _status; + params.actionSet = actionSet; + _status = UNIX_CALL(xrDestroyActionSet, ¶ms); + assert(!_status && "xrDestroyActionSet"); + return params.result; +} + +XrResult WINAPI xrDestroyBodyTrackerFB(XrBodyTrackerFB bodyTracker) +{ + struct xrDestroyBodyTrackerFB_params params; + NTSTATUS _status; + params.bodyTracker = bodyTracker; + _status = UNIX_CALL(xrDestroyBodyTrackerFB, ¶ms); + assert(!_status && "xrDestroyBodyTrackerFB"); + return params.result; +} + +XrResult WINAPI xrDestroyEnvironmentDepthProviderMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider) +{ + struct xrDestroyEnvironmentDepthProviderMETA_params params; + NTSTATUS _status; + params.environmentDepthProvider = environmentDepthProvider; + _status = UNIX_CALL(xrDestroyEnvironmentDepthProviderMETA, ¶ms); + assert(!_status && "xrDestroyEnvironmentDepthProviderMETA"); + return params.result; +} + +XrResult WINAPI xrDestroyEnvironmentDepthSwapchainMETA(XrEnvironmentDepthSwapchainMETA swapchain) +{ + struct xrDestroyEnvironmentDepthSwapchainMETA_params params; + NTSTATUS _status; + params.swapchain = swapchain; + _status = UNIX_CALL(xrDestroyEnvironmentDepthSwapchainMETA, ¶ms); + assert(!_status && "xrDestroyEnvironmentDepthSwapchainMETA"); + return params.result; +} + +XrResult WINAPI xrDestroyExportedLocalizationMapML(XrExportedLocalizationMapML map) +{ + struct xrDestroyExportedLocalizationMapML_params params; + NTSTATUS _status; + params.map = map; + _status = UNIX_CALL(xrDestroyExportedLocalizationMapML, ¶ms); + assert(!_status && "xrDestroyExportedLocalizationMapML"); + return params.result; +} + +XrResult WINAPI xrDestroyEyeTrackerFB(XrEyeTrackerFB eyeTracker) +{ + struct xrDestroyEyeTrackerFB_params params; + NTSTATUS _status; + params.eyeTracker = eyeTracker; + _status = UNIX_CALL(xrDestroyEyeTrackerFB, ¶ms); + assert(!_status && "xrDestroyEyeTrackerFB"); + return params.result; +} + +XrResult WINAPI xrDestroyFaceTracker2FB(XrFaceTracker2FB faceTracker) +{ + struct xrDestroyFaceTracker2FB_params params; + NTSTATUS _status; + params.faceTracker = faceTracker; + _status = UNIX_CALL(xrDestroyFaceTracker2FB, ¶ms); + assert(!_status && "xrDestroyFaceTracker2FB"); + return params.result; +} + +XrResult WINAPI xrDestroyFaceTrackerFB(XrFaceTrackerFB faceTracker) +{ + struct xrDestroyFaceTrackerFB_params params; + NTSTATUS _status; + params.faceTracker = faceTracker; + _status = UNIX_CALL(xrDestroyFaceTrackerFB, ¶ms); + assert(!_status && "xrDestroyFaceTrackerFB"); + return params.result; +} + +XrResult WINAPI xrDestroyFacialTrackerHTC(XrFacialTrackerHTC facialTracker) +{ + struct xrDestroyFacialTrackerHTC_params params; + NTSTATUS _status; + params.facialTracker = facialTracker; + _status = UNIX_CALL(xrDestroyFacialTrackerHTC, ¶ms); + assert(!_status && "xrDestroyFacialTrackerHTC"); + return params.result; +} + +XrResult WINAPI xrDestroyFoveationProfileFB(XrFoveationProfileFB profile) +{ + struct xrDestroyFoveationProfileFB_params params; + NTSTATUS _status; + params.profile = profile; + _status = UNIX_CALL(xrDestroyFoveationProfileFB, ¶ms); + assert(!_status && "xrDestroyFoveationProfileFB"); + return params.result; +} + +XrResult WINAPI xrDestroyGeometryInstanceFB(XrGeometryInstanceFB instance) +{ + struct xrDestroyGeometryInstanceFB_params params; + NTSTATUS _status; + params.instance = instance; + _status = UNIX_CALL(xrDestroyGeometryInstanceFB, ¶ms); + assert(!_status && "xrDestroyGeometryInstanceFB"); + return params.result; +} + +XrResult WINAPI xrDestroyHandTrackerEXT(XrHandTrackerEXT handTracker) +{ + struct xrDestroyHandTrackerEXT_params params; + NTSTATUS _status; + params.handTracker = handTracker; + _status = UNIX_CALL(xrDestroyHandTrackerEXT, ¶ms); + assert(!_status && "xrDestroyHandTrackerEXT"); + return params.result; +} + +XrResult WINAPI xrDestroyMarkerDetectorML(XrMarkerDetectorML markerDetector) +{ + struct xrDestroyMarkerDetectorML_params params; + NTSTATUS _status; + params.markerDetector = markerDetector; + _status = UNIX_CALL(xrDestroyMarkerDetectorML, ¶ms); + assert(!_status && "xrDestroyMarkerDetectorML"); + return params.result; +} + +XrResult WINAPI xrDestroyPassthroughColorLutMETA(XrPassthroughColorLutMETA colorLut) +{ + struct xrDestroyPassthroughColorLutMETA_params params; + NTSTATUS _status; + params.colorLut = colorLut; + _status = UNIX_CALL(xrDestroyPassthroughColorLutMETA, ¶ms); + assert(!_status && "xrDestroyPassthroughColorLutMETA"); + return params.result; +} + +XrResult WINAPI xrDestroyPassthroughFB(XrPassthroughFB passthrough) +{ + struct xrDestroyPassthroughFB_params params; + NTSTATUS _status; + params.passthrough = passthrough; + _status = UNIX_CALL(xrDestroyPassthroughFB, ¶ms); + assert(!_status && "xrDestroyPassthroughFB"); + return params.result; +} + +XrResult WINAPI xrDestroyPassthroughHTC(XrPassthroughHTC passthrough) +{ + struct xrDestroyPassthroughHTC_params params; + NTSTATUS _status; + params.passthrough = passthrough; + _status = UNIX_CALL(xrDestroyPassthroughHTC, ¶ms); + assert(!_status && "xrDestroyPassthroughHTC"); + return params.result; +} + +XrResult WINAPI xrDestroyPassthroughLayerFB(XrPassthroughLayerFB layer) +{ + struct xrDestroyPassthroughLayerFB_params params; + NTSTATUS _status; + params.layer = layer; + _status = UNIX_CALL(xrDestroyPassthroughLayerFB, ¶ms); + assert(!_status && "xrDestroyPassthroughLayerFB"); + return params.result; +} + +XrResult WINAPI xrDestroyPlaneDetectorEXT(XrPlaneDetectorEXT planeDetector) +{ + struct xrDestroyPlaneDetectorEXT_params params; + NTSTATUS _status; + params.planeDetector = planeDetector; + _status = UNIX_CALL(xrDestroyPlaneDetectorEXT, ¶ms); + assert(!_status && "xrDestroyPlaneDetectorEXT"); + return params.result; +} + +XrResult WINAPI xrDestroySceneMSFT(XrSceneMSFT scene) +{ + struct xrDestroySceneMSFT_params params; + NTSTATUS _status; + params.scene = scene; + _status = UNIX_CALL(xrDestroySceneMSFT, ¶ms); + assert(!_status && "xrDestroySceneMSFT"); + return params.result; +} + +XrResult WINAPI xrDestroySceneObserverMSFT(XrSceneObserverMSFT sceneObserver) +{ + struct xrDestroySceneObserverMSFT_params params; + NTSTATUS _status; + params.sceneObserver = sceneObserver; + _status = UNIX_CALL(xrDestroySceneObserverMSFT, ¶ms); + assert(!_status && "xrDestroySceneObserverMSFT"); + return params.result; +} + +XrResult WINAPI xrDestroySpace(XrSpace space) +{ + struct xrDestroySpace_params params; + NTSTATUS _status; + params.space = space; + _status = UNIX_CALL(xrDestroySpace, ¶ms); + assert(!_status && "xrDestroySpace"); + return params.result; +} + +XrResult WINAPI xrDestroySpaceUserFB(XrSpaceUserFB user) +{ + struct xrDestroySpaceUserFB_params params; + NTSTATUS _status; + params.user = user; + _status = UNIX_CALL(xrDestroySpaceUserFB, ¶ms); + assert(!_status && "xrDestroySpaceUserFB"); + return params.result; +} + +XrResult WINAPI xrDestroySpatialAnchorMSFT(XrSpatialAnchorMSFT anchor) +{ + struct xrDestroySpatialAnchorMSFT_params params; + NTSTATUS _status; + params.anchor = anchor; + _status = UNIX_CALL(xrDestroySpatialAnchorMSFT, ¶ms); + assert(!_status && "xrDestroySpatialAnchorMSFT"); + return params.result; +} + +XrResult WINAPI xrDestroySpatialAnchorStoreConnectionMSFT(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore) +{ + struct xrDestroySpatialAnchorStoreConnectionMSFT_params params; + NTSTATUS _status; + params.spatialAnchorStore = spatialAnchorStore; + _status = UNIX_CALL(xrDestroySpatialAnchorStoreConnectionMSFT, ¶ms); + assert(!_status && "xrDestroySpatialAnchorStoreConnectionMSFT"); + return params.result; +} + +XrResult WINAPI xrDestroySpatialGraphNodeBindingMSFT(XrSpatialGraphNodeBindingMSFT nodeBinding) +{ + struct xrDestroySpatialGraphNodeBindingMSFT_params params; + NTSTATUS _status; + params.nodeBinding = nodeBinding; + _status = UNIX_CALL(xrDestroySpatialGraphNodeBindingMSFT, ¶ms); + assert(!_status && "xrDestroySpatialGraphNodeBindingMSFT"); + return params.result; +} + +XrResult WINAPI xrDestroyTriangleMeshFB(XrTriangleMeshFB mesh) +{ + struct xrDestroyTriangleMeshFB_params params; + NTSTATUS _status; + params.mesh = mesh; + _status = UNIX_CALL(xrDestroyTriangleMeshFB, ¶ms); + assert(!_status && "xrDestroyTriangleMeshFB"); + return params.result; +} + +XrResult WINAPI xrDestroyVirtualKeyboardMETA(XrVirtualKeyboardMETA keyboard) +{ + struct xrDestroyVirtualKeyboardMETA_params params; + NTSTATUS _status; + params.keyboard = keyboard; + _status = UNIX_CALL(xrDestroyVirtualKeyboardMETA, ¶ms); + assert(!_status && "xrDestroyVirtualKeyboardMETA"); + return params.result; +} + +XrResult WINAPI xrEnableLocalizationEventsML(XrSession session, const XrLocalizationEnableEventsInfoML *info) +{ + struct xrEnableLocalizationEventsML_params params; + NTSTATUS _status; + params.session = session; + params.info = info; + _status = UNIX_CALL(xrEnableLocalizationEventsML, ¶ms); + assert(!_status && "xrEnableLocalizationEventsML"); + return params.result; +} + +XrResult WINAPI xrEnableUserCalibrationEventsML(XrInstance instance, const XrUserCalibrationEnableEventsInfoML *enableInfo) +{ + struct xrEnableUserCalibrationEventsML_params params; + NTSTATUS _status; + params.instance = instance; + params.enableInfo = enableInfo; + _status = UNIX_CALL(xrEnableUserCalibrationEventsML, ¶ms); + assert(!_status && "xrEnableUserCalibrationEventsML"); + return params.result; +} + +XrResult WINAPI xrEndSession(XrSession session) +{ + struct xrEndSession_params params; + NTSTATUS _status; + params.session = session; + _status = UNIX_CALL(xrEndSession, ¶ms); + assert(!_status && "xrEndSession"); + return params.result; +} + +XrResult WINAPI xrEnumerateApiLayerProperties(uint32_t propertyCapacityInput, uint32_t *propertyCountOutput, XrApiLayerProperties *properties) +{ + struct xrEnumerateApiLayerProperties_params params; + NTSTATUS _status; + params.propertyCapacityInput = propertyCapacityInput; + params.propertyCountOutput = propertyCountOutput; + params.properties = properties; + _status = UNIX_CALL(xrEnumerateApiLayerProperties, ¶ms); + assert(!_status && "xrEnumerateApiLayerProperties"); + return params.result; +} + +XrResult WINAPI xrEnumerateBoundSourcesForAction(XrSession session, const XrBoundSourcesForActionEnumerateInfo *enumerateInfo, uint32_t sourceCapacityInput, uint32_t *sourceCountOutput, XrPath *sources) +{ + struct xrEnumerateBoundSourcesForAction_params params; + NTSTATUS _status; + params.session = session; + params.enumerateInfo = enumerateInfo; + params.sourceCapacityInput = sourceCapacityInput; + params.sourceCountOutput = sourceCountOutput; + params.sources = sources; + _status = UNIX_CALL(xrEnumerateBoundSourcesForAction, ¶ms); + assert(!_status && "xrEnumerateBoundSourcesForAction"); + return params.result; +} + +XrResult WINAPI xrEnumerateColorSpacesFB(XrSession session, uint32_t colorSpaceCapacityInput, uint32_t *colorSpaceCountOutput, XrColorSpaceFB *colorSpaces) +{ + struct xrEnumerateColorSpacesFB_params params; + NTSTATUS _status; + params.session = session; + params.colorSpaceCapacityInput = colorSpaceCapacityInput; + params.colorSpaceCountOutput = colorSpaceCountOutput; + params.colorSpaces = colorSpaces; + _status = UNIX_CALL(xrEnumerateColorSpacesFB, ¶ms); + assert(!_status && "xrEnumerateColorSpacesFB"); + return params.result; +} + +XrResult WINAPI xrEnumerateDisplayRefreshRatesFB(XrSession session, uint32_t displayRefreshRateCapacityInput, uint32_t *displayRefreshRateCountOutput, float *displayRefreshRates) +{ + struct xrEnumerateDisplayRefreshRatesFB_params params; + NTSTATUS _status; + params.session = session; + params.displayRefreshRateCapacityInput = displayRefreshRateCapacityInput; + params.displayRefreshRateCountOutput = displayRefreshRateCountOutput; + params.displayRefreshRates = displayRefreshRates; + _status = UNIX_CALL(xrEnumerateDisplayRefreshRatesFB, ¶ms); + assert(!_status && "xrEnumerateDisplayRefreshRatesFB"); + return params.result; +} + +XrResult WINAPI xrEnumerateEnvironmentBlendModes(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, uint32_t environmentBlendModeCapacityInput, uint32_t *environmentBlendModeCountOutput, XrEnvironmentBlendMode *environmentBlendModes) +{ + struct xrEnumerateEnvironmentBlendModes_params params; + NTSTATUS _status; + params.instance = instance; + params.systemId = systemId; + params.viewConfigurationType = viewConfigurationType; + params.environmentBlendModeCapacityInput = environmentBlendModeCapacityInput; + params.environmentBlendModeCountOutput = environmentBlendModeCountOutput; + params.environmentBlendModes = environmentBlendModes; + _status = UNIX_CALL(xrEnumerateEnvironmentBlendModes, ¶ms); + assert(!_status && "xrEnumerateEnvironmentBlendModes"); + return params.result; +} + +XrResult WINAPI xrEnumerateEnvironmentDepthSwapchainImagesMETA(XrEnvironmentDepthSwapchainMETA swapchain, uint32_t imageCapacityInput, uint32_t *imageCountOutput, XrSwapchainImageBaseHeader *images) +{ + struct xrEnumerateEnvironmentDepthSwapchainImagesMETA_params params; + NTSTATUS _status; + params.swapchain = swapchain; + params.imageCapacityInput = imageCapacityInput; + params.imageCountOutput = imageCountOutput; + params.images = images; + _status = UNIX_CALL(xrEnumerateEnvironmentDepthSwapchainImagesMETA, ¶ms); + assert(!_status && "xrEnumerateEnvironmentDepthSwapchainImagesMETA"); + return params.result; +} + +XrResult WINAPI xrEnumerateExternalCamerasOCULUS(XrSession session, uint32_t cameraCapacityInput, uint32_t *cameraCountOutput, XrExternalCameraOCULUS *cameras) +{ + struct xrEnumerateExternalCamerasOCULUS_params params; + NTSTATUS _status; + params.session = session; + params.cameraCapacityInput = cameraCapacityInput; + params.cameraCountOutput = cameraCountOutput; + params.cameras = cameras; + _status = UNIX_CALL(xrEnumerateExternalCamerasOCULUS, ¶ms); + assert(!_status && "xrEnumerateExternalCamerasOCULUS"); + return params.result; +} + +XrResult WINAPI xrEnumerateInstanceExtensionProperties(const char *layerName, uint32_t propertyCapacityInput, uint32_t *propertyCountOutput, XrExtensionProperties *properties) +{ + struct xrEnumerateInstanceExtensionProperties_params params; + NTSTATUS _status; + params.layerName = layerName; + params.propertyCapacityInput = propertyCapacityInput; + params.propertyCountOutput = propertyCountOutput; + params.properties = properties; + _status = UNIX_CALL(xrEnumerateInstanceExtensionProperties, ¶ms); + assert(!_status && "xrEnumerateInstanceExtensionProperties"); + return params.result; +} + +XrResult WINAPI xrEnumeratePerformanceMetricsCounterPathsMETA(XrInstance instance, uint32_t counterPathCapacityInput, uint32_t *counterPathCountOutput, XrPath *counterPaths) +{ + struct xrEnumeratePerformanceMetricsCounterPathsMETA_params params; + NTSTATUS _status; + params.instance = instance; + params.counterPathCapacityInput = counterPathCapacityInput; + params.counterPathCountOutput = counterPathCountOutput; + params.counterPaths = counterPaths; + _status = UNIX_CALL(xrEnumeratePerformanceMetricsCounterPathsMETA, ¶ms); + assert(!_status && "xrEnumeratePerformanceMetricsCounterPathsMETA"); + return params.result; +} + +XrResult WINAPI xrEnumeratePersistedSpatialAnchorNamesMSFT(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, uint32_t spatialAnchorNameCapacityInput, uint32_t *spatialAnchorNameCountOutput, XrSpatialAnchorPersistenceNameMSFT *spatialAnchorNames) +{ + struct xrEnumeratePersistedSpatialAnchorNamesMSFT_params params; + NTSTATUS _status; + params.spatialAnchorStore = spatialAnchorStore; + params.spatialAnchorNameCapacityInput = spatialAnchorNameCapacityInput; + params.spatialAnchorNameCountOutput = spatialAnchorNameCountOutput; + params.spatialAnchorNames = spatialAnchorNames; + _status = UNIX_CALL(xrEnumeratePersistedSpatialAnchorNamesMSFT, ¶ms); + assert(!_status && "xrEnumeratePersistedSpatialAnchorNamesMSFT"); + return params.result; +} + +XrResult WINAPI xrEnumerateReferenceSpaces(XrSession session, uint32_t spaceCapacityInput, uint32_t *spaceCountOutput, XrReferenceSpaceType *spaces) +{ + struct xrEnumerateReferenceSpaces_params params; + NTSTATUS _status; + params.session = session; + params.spaceCapacityInput = spaceCapacityInput; + params.spaceCountOutput = spaceCountOutput; + params.spaces = spaces; + _status = UNIX_CALL(xrEnumerateReferenceSpaces, ¶ms); + assert(!_status && "xrEnumerateReferenceSpaces"); + return params.result; +} + +XrResult WINAPI xrEnumerateRenderModelPathsFB(XrSession session, uint32_t pathCapacityInput, uint32_t *pathCountOutput, XrRenderModelPathInfoFB *paths) +{ + struct xrEnumerateRenderModelPathsFB_params params; + NTSTATUS _status; + params.session = session; + params.pathCapacityInput = pathCapacityInput; + params.pathCountOutput = pathCountOutput; + params.paths = paths; + _status = UNIX_CALL(xrEnumerateRenderModelPathsFB, ¶ms); + assert(!_status && "xrEnumerateRenderModelPathsFB"); + return params.result; +} + +XrResult WINAPI xrEnumerateReprojectionModesMSFT(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, uint32_t modeCapacityInput, uint32_t *modeCountOutput, XrReprojectionModeMSFT *modes) +{ + struct xrEnumerateReprojectionModesMSFT_params params; + NTSTATUS _status; + params.instance = instance; + params.systemId = systemId; + params.viewConfigurationType = viewConfigurationType; + params.modeCapacityInput = modeCapacityInput; + params.modeCountOutput = modeCountOutput; + params.modes = modes; + _status = UNIX_CALL(xrEnumerateReprojectionModesMSFT, ¶ms); + assert(!_status && "xrEnumerateReprojectionModesMSFT"); + return params.result; +} + +XrResult WINAPI xrEnumerateSceneComputeFeaturesMSFT(XrInstance instance, XrSystemId systemId, uint32_t featureCapacityInput, uint32_t *featureCountOutput, XrSceneComputeFeatureMSFT *features) +{ + struct xrEnumerateSceneComputeFeaturesMSFT_params params; + NTSTATUS _status; + params.instance = instance; + params.systemId = systemId; + params.featureCapacityInput = featureCapacityInput; + params.featureCountOutput = featureCountOutput; + params.features = features; + _status = UNIX_CALL(xrEnumerateSceneComputeFeaturesMSFT, ¶ms); + assert(!_status && "xrEnumerateSceneComputeFeaturesMSFT"); + return params.result; +} + +XrResult WINAPI xrEnumerateSpaceSupportedComponentsFB(XrSpace space, uint32_t componentTypeCapacityInput, uint32_t *componentTypeCountOutput, XrSpaceComponentTypeFB *componentTypes) +{ + struct xrEnumerateSpaceSupportedComponentsFB_params params; + NTSTATUS _status; + params.space = space; + params.componentTypeCapacityInput = componentTypeCapacityInput; + params.componentTypeCountOutput = componentTypeCountOutput; + params.componentTypes = componentTypes; + _status = UNIX_CALL(xrEnumerateSpaceSupportedComponentsFB, ¶ms); + assert(!_status && "xrEnumerateSpaceSupportedComponentsFB"); + return params.result; +} + +XrResult WINAPI xrEnumerateViewConfigurationViews(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, uint32_t viewCapacityInput, uint32_t *viewCountOutput, XrViewConfigurationView *views) +{ + struct xrEnumerateViewConfigurationViews_params params; + NTSTATUS _status; + params.instance = instance; + params.systemId = systemId; + params.viewConfigurationType = viewConfigurationType; + params.viewCapacityInput = viewCapacityInput; + params.viewCountOutput = viewCountOutput; + params.views = views; + _status = UNIX_CALL(xrEnumerateViewConfigurationViews, ¶ms); + assert(!_status && "xrEnumerateViewConfigurationViews"); + return params.result; +} + +XrResult WINAPI xrEnumerateViewConfigurations(XrInstance instance, XrSystemId systemId, uint32_t viewConfigurationTypeCapacityInput, uint32_t *viewConfigurationTypeCountOutput, XrViewConfigurationType *viewConfigurationTypes) +{ + struct xrEnumerateViewConfigurations_params params; + NTSTATUS _status; + params.instance = instance; + params.systemId = systemId; + params.viewConfigurationTypeCapacityInput = viewConfigurationTypeCapacityInput; + params.viewConfigurationTypeCountOutput = viewConfigurationTypeCountOutput; + params.viewConfigurationTypes = viewConfigurationTypes; + _status = UNIX_CALL(xrEnumerateViewConfigurations, ¶ms); + assert(!_status && "xrEnumerateViewConfigurations"); + return params.result; +} + +XrResult WINAPI xrEnumerateViveTrackerPathsHTCX(XrInstance instance, uint32_t pathCapacityInput, uint32_t *pathCountOutput, XrViveTrackerPathsHTCX *paths) +{ + struct xrEnumerateViveTrackerPathsHTCX_params params; + NTSTATUS _status; + params.instance = instance; + params.pathCapacityInput = pathCapacityInput; + params.pathCountOutput = pathCountOutput; + params.paths = paths; + _status = UNIX_CALL(xrEnumerateViveTrackerPathsHTCX, ¶ms); + assert(!_status && "xrEnumerateViveTrackerPathsHTCX"); + return params.result; +} + +XrResult WINAPI xrEraseSpaceFB(XrSession session, const XrSpaceEraseInfoFB *info, XrAsyncRequestIdFB *requestId) +{ + struct xrEraseSpaceFB_params params; + NTSTATUS _status; + params.session = session; + params.info = info; + params.requestId = requestId; + _status = UNIX_CALL(xrEraseSpaceFB, ¶ms); + assert(!_status && "xrEraseSpaceFB"); + return params.result; +} + +XrResult WINAPI xrGeometryInstanceSetTransformFB(XrGeometryInstanceFB instance, const XrGeometryInstanceTransformFB *transformation) +{ + struct xrGeometryInstanceSetTransformFB_params params; + NTSTATUS _status; + params.instance = instance; + params.transformation = transformation; + _status = UNIX_CALL(xrGeometryInstanceSetTransformFB, ¶ms); + assert(!_status && "xrGeometryInstanceSetTransformFB"); + return params.result; +} + +XrResult WINAPI xrGetActionStateBoolean(XrSession session, const XrActionStateGetInfo *getInfo, XrActionStateBoolean *state) +{ + struct xrGetActionStateBoolean_params params; + NTSTATUS _status; + params.session = session; + params.getInfo = getInfo; + params.state = state; + _status = UNIX_CALL(xrGetActionStateBoolean, ¶ms); + assert(!_status && "xrGetActionStateBoolean"); + return params.result; +} + +XrResult WINAPI xrGetActionStateFloat(XrSession session, const XrActionStateGetInfo *getInfo, XrActionStateFloat *state) +{ + struct xrGetActionStateFloat_params params; + NTSTATUS _status; + params.session = session; + params.getInfo = getInfo; + params.state = state; + _status = UNIX_CALL(xrGetActionStateFloat, ¶ms); + assert(!_status && "xrGetActionStateFloat"); + return params.result; +} + +XrResult WINAPI xrGetActionStatePose(XrSession session, const XrActionStateGetInfo *getInfo, XrActionStatePose *state) +{ + struct xrGetActionStatePose_params params; + NTSTATUS _status; + params.session = session; + params.getInfo = getInfo; + params.state = state; + _status = UNIX_CALL(xrGetActionStatePose, ¶ms); + assert(!_status && "xrGetActionStatePose"); + return params.result; +} + +XrResult WINAPI xrGetActionStateVector2f(XrSession session, const XrActionStateGetInfo *getInfo, XrActionStateVector2f *state) +{ + struct xrGetActionStateVector2f_params params; + NTSTATUS _status; + params.session = session; + params.getInfo = getInfo; + params.state = state; + _status = UNIX_CALL(xrGetActionStateVector2f, ¶ms); + assert(!_status && "xrGetActionStateVector2f"); + return params.result; +} + +XrResult WINAPI xrGetAudioInputDeviceGuidOculus(XrInstance instance, wchar_t buffer[]) +{ + struct xrGetAudioInputDeviceGuidOculus_params params; + NTSTATUS _status; + params.instance = instance; + params.buffer = buffer; + _status = UNIX_CALL(xrGetAudioInputDeviceGuidOculus, ¶ms); + assert(!_status && "xrGetAudioInputDeviceGuidOculus"); + return params.result; +} + +XrResult WINAPI xrGetAudioOutputDeviceGuidOculus(XrInstance instance, wchar_t buffer[]) +{ + struct xrGetAudioOutputDeviceGuidOculus_params params; + NTSTATUS _status; + params.instance = instance; + params.buffer = buffer; + _status = UNIX_CALL(xrGetAudioOutputDeviceGuidOculus, ¶ms); + assert(!_status && "xrGetAudioOutputDeviceGuidOculus"); + return params.result; +} + +XrResult WINAPI xrGetBodySkeletonFB(XrBodyTrackerFB bodyTracker, XrBodySkeletonFB *skeleton) +{ + struct xrGetBodySkeletonFB_params params; + NTSTATUS _status; + params.bodyTracker = bodyTracker; + params.skeleton = skeleton; + _status = UNIX_CALL(xrGetBodySkeletonFB, ¶ms); + assert(!_status && "xrGetBodySkeletonFB"); + return params.result; +} + +XrResult WINAPI xrGetControllerModelKeyMSFT(XrSession session, XrPath topLevelUserPath, XrControllerModelKeyStateMSFT *controllerModelKeyState) +{ + struct xrGetControllerModelKeyMSFT_params params; + NTSTATUS _status; + params.session = session; + params.topLevelUserPath = topLevelUserPath; + params.controllerModelKeyState = controllerModelKeyState; + _status = UNIX_CALL(xrGetControllerModelKeyMSFT, ¶ms); + assert(!_status && "xrGetControllerModelKeyMSFT"); + return params.result; +} + +XrResult WINAPI xrGetControllerModelPropertiesMSFT(XrSession session, XrControllerModelKeyMSFT modelKey, XrControllerModelPropertiesMSFT *properties) +{ + struct xrGetControllerModelPropertiesMSFT_params params; + NTSTATUS _status; + params.session = session; + params.modelKey = modelKey; + params.properties = properties; + _status = UNIX_CALL(xrGetControllerModelPropertiesMSFT, ¶ms); + assert(!_status && "xrGetControllerModelPropertiesMSFT"); + return params.result; +} + +XrResult WINAPI xrGetControllerModelStateMSFT(XrSession session, XrControllerModelKeyMSFT modelKey, XrControllerModelStateMSFT *state) +{ + struct xrGetControllerModelStateMSFT_params params; + NTSTATUS _status; + params.session = session; + params.modelKey = modelKey; + params.state = state; + _status = UNIX_CALL(xrGetControllerModelStateMSFT, ¶ms); + assert(!_status && "xrGetControllerModelStateMSFT"); + return params.result; +} + +XrResult WINAPI xrGetCurrentInteractionProfile(XrSession session, XrPath topLevelUserPath, XrInteractionProfileState *interactionProfile) +{ + struct xrGetCurrentInteractionProfile_params params; + NTSTATUS _status; + params.session = session; + params.topLevelUserPath = topLevelUserPath; + params.interactionProfile = interactionProfile; + _status = UNIX_CALL(xrGetCurrentInteractionProfile, ¶ms); + assert(!_status && "xrGetCurrentInteractionProfile"); + return params.result; +} + +XrResult WINAPI xrGetDeviceSampleRateFB(XrSession session, const XrHapticActionInfo *hapticActionInfo, XrDevicePcmSampleRateGetInfoFB *deviceSampleRate) +{ + struct xrGetDeviceSampleRateFB_params params; + NTSTATUS _status; + params.session = session; + params.hapticActionInfo = hapticActionInfo; + params.deviceSampleRate = deviceSampleRate; + _status = UNIX_CALL(xrGetDeviceSampleRateFB, ¶ms); + assert(!_status && "xrGetDeviceSampleRateFB"); + return params.result; +} + +XrResult WINAPI xrGetDisplayRefreshRateFB(XrSession session, float *displayRefreshRate) +{ + struct xrGetDisplayRefreshRateFB_params params; + NTSTATUS _status; + params.session = session; + params.displayRefreshRate = displayRefreshRate; + _status = UNIX_CALL(xrGetDisplayRefreshRateFB, ¶ms); + assert(!_status && "xrGetDisplayRefreshRateFB"); + return params.result; +} + +XrResult WINAPI xrGetEnvironmentDepthSwapchainStateMETA(XrEnvironmentDepthSwapchainMETA swapchain, XrEnvironmentDepthSwapchainStateMETA *state) +{ + struct xrGetEnvironmentDepthSwapchainStateMETA_params params; + NTSTATUS _status; + params.swapchain = swapchain; + params.state = state; + _status = UNIX_CALL(xrGetEnvironmentDepthSwapchainStateMETA, ¶ms); + assert(!_status && "xrGetEnvironmentDepthSwapchainStateMETA"); + return params.result; +} + +XrResult WINAPI xrGetExportedLocalizationMapDataML(XrExportedLocalizationMapML map, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer) +{ + struct xrGetExportedLocalizationMapDataML_params params; + NTSTATUS _status; + params.map = map; + params.bufferCapacityInput = bufferCapacityInput; + params.bufferCountOutput = bufferCountOutput; + params.buffer = buffer; + _status = UNIX_CALL(xrGetExportedLocalizationMapDataML, ¶ms); + assert(!_status && "xrGetExportedLocalizationMapDataML"); + return params.result; +} + +XrResult WINAPI xrGetEyeGazesFB(XrEyeTrackerFB eyeTracker, const XrEyeGazesInfoFB *gazeInfo, XrEyeGazesFB *eyeGazes) +{ + struct xrGetEyeGazesFB_params params; + NTSTATUS _status; + params.eyeTracker = eyeTracker; + params.gazeInfo = gazeInfo; + params.eyeGazes = eyeGazes; + _status = UNIX_CALL(xrGetEyeGazesFB, ¶ms); + assert(!_status && "xrGetEyeGazesFB"); + return params.result; +} + +XrResult WINAPI xrGetFaceExpressionWeights2FB(XrFaceTracker2FB faceTracker, const XrFaceExpressionInfo2FB *expressionInfo, XrFaceExpressionWeights2FB *expressionWeights) +{ + struct xrGetFaceExpressionWeights2FB_params params; + NTSTATUS _status; + params.faceTracker = faceTracker; + params.expressionInfo = expressionInfo; + params.expressionWeights = expressionWeights; + _status = UNIX_CALL(xrGetFaceExpressionWeights2FB, ¶ms); + assert(!_status && "xrGetFaceExpressionWeights2FB"); + return params.result; +} + +XrResult WINAPI xrGetFaceExpressionWeightsFB(XrFaceTrackerFB faceTracker, const XrFaceExpressionInfoFB *expressionInfo, XrFaceExpressionWeightsFB *expressionWeights) +{ + struct xrGetFaceExpressionWeightsFB_params params; + NTSTATUS _status; + params.faceTracker = faceTracker; + params.expressionInfo = expressionInfo; + params.expressionWeights = expressionWeights; + _status = UNIX_CALL(xrGetFaceExpressionWeightsFB, ¶ms); + assert(!_status && "xrGetFaceExpressionWeightsFB"); + return params.result; +} + +XrResult WINAPI xrGetFacialExpressionsHTC(XrFacialTrackerHTC facialTracker, XrFacialExpressionsHTC *facialExpressions) +{ + struct xrGetFacialExpressionsHTC_params params; + NTSTATUS _status; + params.facialTracker = facialTracker; + params.facialExpressions = facialExpressions; + _status = UNIX_CALL(xrGetFacialExpressionsHTC, ¶ms); + assert(!_status && "xrGetFacialExpressionsHTC"); + return params.result; +} + +XrResult WINAPI xrGetFoveationEyeTrackedStateMETA(XrSession session, XrFoveationEyeTrackedStateMETA *foveationState) +{ + struct xrGetFoveationEyeTrackedStateMETA_params params; + NTSTATUS _status; + params.session = session; + params.foveationState = foveationState; + _status = UNIX_CALL(xrGetFoveationEyeTrackedStateMETA, ¶ms); + assert(!_status && "xrGetFoveationEyeTrackedStateMETA"); + return params.result; +} + +XrResult WINAPI xrGetHandMeshFB(XrHandTrackerEXT handTracker, XrHandTrackingMeshFB *mesh) +{ + struct xrGetHandMeshFB_params params; + NTSTATUS _status; + params.handTracker = handTracker; + params.mesh = mesh; + _status = UNIX_CALL(xrGetHandMeshFB, ¶ms); + assert(!_status && "xrGetHandMeshFB"); + return params.result; +} + +XrResult WINAPI xrGetInputSourceLocalizedName(XrSession session, const XrInputSourceLocalizedNameGetInfo *getInfo, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer) +{ + struct xrGetInputSourceLocalizedName_params params; + NTSTATUS _status; + params.session = session; + params.getInfo = getInfo; + params.bufferCapacityInput = bufferCapacityInput; + params.bufferCountOutput = bufferCountOutput; + params.buffer = buffer; + _status = UNIX_CALL(xrGetInputSourceLocalizedName, ¶ms); + assert(!_status && "xrGetInputSourceLocalizedName"); + return params.result; +} + +XrResult WINAPI xrGetInstanceProperties(XrInstance instance, XrInstanceProperties *instanceProperties) +{ + struct xrGetInstanceProperties_params params; + NTSTATUS _status; + params.instance = instance; + params.instanceProperties = instanceProperties; + _status = UNIX_CALL(xrGetInstanceProperties, ¶ms); + assert(!_status && "xrGetInstanceProperties"); + return params.result; +} + +XrResult WINAPI xrGetMarkerDetectorStateML(XrMarkerDetectorML markerDetector, XrMarkerDetectorStateML *state) +{ + struct xrGetMarkerDetectorStateML_params params; + NTSTATUS _status; + params.markerDetector = markerDetector; + params.state = state; + _status = UNIX_CALL(xrGetMarkerDetectorStateML, ¶ms); + assert(!_status && "xrGetMarkerDetectorStateML"); + return params.result; +} + +XrResult WINAPI xrGetMarkerLengthML(XrMarkerDetectorML markerDetector, XrMarkerML marker, float *meters) +{ + struct xrGetMarkerLengthML_params params; + NTSTATUS _status; + params.markerDetector = markerDetector; + params.marker = marker; + params.meters = meters; + _status = UNIX_CALL(xrGetMarkerLengthML, ¶ms); + assert(!_status && "xrGetMarkerLengthML"); + return params.result; +} + +XrResult WINAPI xrGetMarkerNumberML(XrMarkerDetectorML markerDetector, XrMarkerML marker, uint64_t *number) +{ + struct xrGetMarkerNumberML_params params; + NTSTATUS _status; + params.markerDetector = markerDetector; + params.marker = marker; + params.number = number; + _status = UNIX_CALL(xrGetMarkerNumberML, ¶ms); + assert(!_status && "xrGetMarkerNumberML"); + return params.result; +} + +XrResult WINAPI xrGetMarkerReprojectionErrorML(XrMarkerDetectorML markerDetector, XrMarkerML marker, float *reprojectionErrorMeters) +{ + struct xrGetMarkerReprojectionErrorML_params params; + NTSTATUS _status; + params.markerDetector = markerDetector; + params.marker = marker; + params.reprojectionErrorMeters = reprojectionErrorMeters; + _status = UNIX_CALL(xrGetMarkerReprojectionErrorML, ¶ms); + assert(!_status && "xrGetMarkerReprojectionErrorML"); + return params.result; +} + +XrResult WINAPI xrGetMarkerSizeVARJO(XrSession session, uint64_t markerId, XrExtent2Df *size) +{ + struct xrGetMarkerSizeVARJO_params params; + NTSTATUS _status; + params.session = session; + params.markerId = markerId; + params.size = size; + _status = UNIX_CALL(xrGetMarkerSizeVARJO, ¶ms); + assert(!_status && "xrGetMarkerSizeVARJO"); + return params.result; +} + +XrResult WINAPI xrGetMarkerStringML(XrMarkerDetectorML markerDetector, XrMarkerML marker, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer) +{ + struct xrGetMarkerStringML_params params; + NTSTATUS _status; + params.markerDetector = markerDetector; + params.marker = marker; + params.bufferCapacityInput = bufferCapacityInput; + params.bufferCountOutput = bufferCountOutput; + params.buffer = buffer; + _status = UNIX_CALL(xrGetMarkerStringML, ¶ms); + assert(!_status && "xrGetMarkerStringML"); + return params.result; +} + +XrResult WINAPI xrGetMarkersML(XrMarkerDetectorML markerDetector, uint32_t markerCapacityInput, uint32_t *markerCountOutput, XrMarkerML *markers) +{ + struct xrGetMarkersML_params params; + NTSTATUS _status; + params.markerDetector = markerDetector; + params.markerCapacityInput = markerCapacityInput; + params.markerCountOutput = markerCountOutput; + params.markers = markers; + _status = UNIX_CALL(xrGetMarkersML, ¶ms); + assert(!_status && "xrGetMarkersML"); + return params.result; +} + +XrResult WINAPI xrGetOpenGLGraphicsRequirementsKHR(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsOpenGLKHR *graphicsRequirements) +{ + struct xrGetOpenGLGraphicsRequirementsKHR_params params; + NTSTATUS _status; + params.instance = instance; + params.systemId = systemId; + params.graphicsRequirements = graphicsRequirements; + _status = UNIX_CALL(xrGetOpenGLGraphicsRequirementsKHR, ¶ms); + assert(!_status && "xrGetOpenGLGraphicsRequirementsKHR"); + return params.result; +} + +XrResult WINAPI xrGetPassthroughPreferencesMETA(XrSession session, XrPassthroughPreferencesMETA *preferences) +{ + struct xrGetPassthroughPreferencesMETA_params params; + NTSTATUS _status; + params.session = session; + params.preferences = preferences; + _status = UNIX_CALL(xrGetPassthroughPreferencesMETA, ¶ms); + assert(!_status && "xrGetPassthroughPreferencesMETA"); + return params.result; +} + +XrResult WINAPI xrGetPerformanceMetricsStateMETA(XrSession session, XrPerformanceMetricsStateMETA *state) +{ + struct xrGetPerformanceMetricsStateMETA_params params; + NTSTATUS _status; + params.session = session; + params.state = state; + _status = UNIX_CALL(xrGetPerformanceMetricsStateMETA, ¶ms); + assert(!_status && "xrGetPerformanceMetricsStateMETA"); + return params.result; +} + +XrResult WINAPI xrGetPlaneDetectionStateEXT(XrPlaneDetectorEXT planeDetector, XrPlaneDetectionStateEXT *state) +{ + struct xrGetPlaneDetectionStateEXT_params params; + NTSTATUS _status; + params.planeDetector = planeDetector; + params.state = state; + _status = UNIX_CALL(xrGetPlaneDetectionStateEXT, ¶ms); + assert(!_status && "xrGetPlaneDetectionStateEXT"); + return params.result; +} + +XrResult WINAPI xrGetPlaneDetectionsEXT(XrPlaneDetectorEXT planeDetector, const XrPlaneDetectorGetInfoEXT *info, XrPlaneDetectorLocationsEXT *locations) +{ + struct xrGetPlaneDetectionsEXT_params params; + NTSTATUS _status; + params.planeDetector = planeDetector; + params.info = info; + params.locations = locations; + _status = UNIX_CALL(xrGetPlaneDetectionsEXT, ¶ms); + assert(!_status && "xrGetPlaneDetectionsEXT"); + return params.result; +} + +XrResult WINAPI xrGetPlanePolygonBufferEXT(XrPlaneDetectorEXT planeDetector, uint64_t planeId, uint32_t polygonBufferIndex, XrPlaneDetectorPolygonBufferEXT *polygonBuffer) +{ + struct xrGetPlanePolygonBufferEXT_params params; + NTSTATUS _status; + params.planeDetector = planeDetector; + params.planeId = planeId; + params.polygonBufferIndex = polygonBufferIndex; + params.polygonBuffer = polygonBuffer; + _status = UNIX_CALL(xrGetPlanePolygonBufferEXT, ¶ms); + assert(!_status && "xrGetPlanePolygonBufferEXT"); + return params.result; +} + +XrResult WINAPI xrGetRecommendedLayerResolutionMETA(XrSession session, const XrRecommendedLayerResolutionGetInfoMETA *info, XrRecommendedLayerResolutionMETA *resolution) +{ + struct xrGetRecommendedLayerResolutionMETA_params params; + NTSTATUS _status; + params.session = session; + params.info = info; + params.resolution = resolution; + _status = UNIX_CALL(xrGetRecommendedLayerResolutionMETA, ¶ms); + assert(!_status && "xrGetRecommendedLayerResolutionMETA"); + return params.result; +} + +XrResult WINAPI xrGetReferenceSpaceBoundsRect(XrSession session, XrReferenceSpaceType referenceSpaceType, XrExtent2Df *bounds) +{ + struct xrGetReferenceSpaceBoundsRect_params params; + NTSTATUS _status; + params.session = session; + params.referenceSpaceType = referenceSpaceType; + params.bounds = bounds; + _status = UNIX_CALL(xrGetReferenceSpaceBoundsRect, ¶ms); + assert(!_status && "xrGetReferenceSpaceBoundsRect"); + return params.result; +} + +XrResult WINAPI xrGetRenderModelPropertiesFB(XrSession session, XrPath path, XrRenderModelPropertiesFB *properties) +{ + struct xrGetRenderModelPropertiesFB_params params; + NTSTATUS _status; + params.session = session; + params.path = path; + params.properties = properties; + _status = UNIX_CALL(xrGetRenderModelPropertiesFB, ¶ms); + assert(!_status && "xrGetRenderModelPropertiesFB"); + return params.result; +} + +XrResult WINAPI xrGetSceneComponentsMSFT(XrSceneMSFT scene, const XrSceneComponentsGetInfoMSFT *getInfo, XrSceneComponentsMSFT *components) +{ + struct xrGetSceneComponentsMSFT_params params; + NTSTATUS _status; + params.scene = scene; + params.getInfo = getInfo; + params.components = components; + _status = UNIX_CALL(xrGetSceneComponentsMSFT, ¶ms); + assert(!_status && "xrGetSceneComponentsMSFT"); + return params.result; +} + +XrResult WINAPI xrGetSceneComputeStateMSFT(XrSceneObserverMSFT sceneObserver, XrSceneComputeStateMSFT *state) +{ + struct xrGetSceneComputeStateMSFT_params params; + NTSTATUS _status; + params.sceneObserver = sceneObserver; + params.state = state; + _status = UNIX_CALL(xrGetSceneComputeStateMSFT, ¶ms); + assert(!_status && "xrGetSceneComputeStateMSFT"); + return params.result; +} + +XrResult WINAPI xrGetSceneMarkerDecodedStringMSFT(XrSceneMSFT scene, const XrUuidMSFT *markerId, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer) +{ + struct xrGetSceneMarkerDecodedStringMSFT_params params; + NTSTATUS _status; + params.scene = scene; + params.markerId = markerId; + params.bufferCapacityInput = bufferCapacityInput; + params.bufferCountOutput = bufferCountOutput; + params.buffer = buffer; + _status = UNIX_CALL(xrGetSceneMarkerDecodedStringMSFT, ¶ms); + assert(!_status && "xrGetSceneMarkerDecodedStringMSFT"); + return params.result; +} + +XrResult WINAPI xrGetSceneMarkerRawDataMSFT(XrSceneMSFT scene, const XrUuidMSFT *markerId, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, uint8_t *buffer) +{ + struct xrGetSceneMarkerRawDataMSFT_params params; + NTSTATUS _status; + params.scene = scene; + params.markerId = markerId; + params.bufferCapacityInput = bufferCapacityInput; + params.bufferCountOutput = bufferCountOutput; + params.buffer = buffer; + _status = UNIX_CALL(xrGetSceneMarkerRawDataMSFT, ¶ms); + assert(!_status && "xrGetSceneMarkerRawDataMSFT"); + return params.result; +} + +XrResult WINAPI xrGetSceneMeshBuffersMSFT(XrSceneMSFT scene, const XrSceneMeshBuffersGetInfoMSFT *getInfo, XrSceneMeshBuffersMSFT *buffers) +{ + struct xrGetSceneMeshBuffersMSFT_params params; + NTSTATUS _status; + params.scene = scene; + params.getInfo = getInfo; + params.buffers = buffers; + _status = UNIX_CALL(xrGetSceneMeshBuffersMSFT, ¶ms); + assert(!_status && "xrGetSceneMeshBuffersMSFT"); + return params.result; +} + +XrResult WINAPI xrGetSerializedSceneFragmentDataMSFT(XrSceneMSFT scene, const XrSerializedSceneFragmentDataGetInfoMSFT *getInfo, uint32_t countInput, uint32_t *readOutput, uint8_t *buffer) +{ + struct xrGetSerializedSceneFragmentDataMSFT_params params; + NTSTATUS _status; + params.scene = scene; + params.getInfo = getInfo; + params.countInput = countInput; + params.readOutput = readOutput; + params.buffer = buffer; + _status = UNIX_CALL(xrGetSerializedSceneFragmentDataMSFT, ¶ms); + assert(!_status && "xrGetSerializedSceneFragmentDataMSFT"); + return params.result; +} + +XrResult WINAPI xrGetSpaceBoundary2DFB(XrSession session, XrSpace space, XrBoundary2DFB *boundary2DOutput) +{ + struct xrGetSpaceBoundary2DFB_params params; + NTSTATUS _status; + params.session = session; + params.space = space; + params.boundary2DOutput = boundary2DOutput; + _status = UNIX_CALL(xrGetSpaceBoundary2DFB, ¶ms); + assert(!_status && "xrGetSpaceBoundary2DFB"); + return params.result; +} + +XrResult WINAPI xrGetSpaceBoundingBox2DFB(XrSession session, XrSpace space, XrRect2Df *boundingBox2DOutput) +{ + struct xrGetSpaceBoundingBox2DFB_params params; + NTSTATUS _status; + params.session = session; + params.space = space; + params.boundingBox2DOutput = boundingBox2DOutput; + _status = UNIX_CALL(xrGetSpaceBoundingBox2DFB, ¶ms); + assert(!_status && "xrGetSpaceBoundingBox2DFB"); + return params.result; +} + +XrResult WINAPI xrGetSpaceBoundingBox3DFB(XrSession session, XrSpace space, XrRect3DfFB *boundingBox3DOutput) +{ + struct xrGetSpaceBoundingBox3DFB_params params; + NTSTATUS _status; + params.session = session; + params.space = space; + params.boundingBox3DOutput = boundingBox3DOutput; + _status = UNIX_CALL(xrGetSpaceBoundingBox3DFB, ¶ms); + assert(!_status && "xrGetSpaceBoundingBox3DFB"); + return params.result; +} + +XrResult WINAPI xrGetSpaceComponentStatusFB(XrSpace space, XrSpaceComponentTypeFB componentType, XrSpaceComponentStatusFB *status) +{ + struct xrGetSpaceComponentStatusFB_params params; + NTSTATUS _status; + params.space = space; + params.componentType = componentType; + params.status = status; + _status = UNIX_CALL(xrGetSpaceComponentStatusFB, ¶ms); + assert(!_status && "xrGetSpaceComponentStatusFB"); + return params.result; +} + +XrResult WINAPI xrGetSpaceContainerFB(XrSession session, XrSpace space, XrSpaceContainerFB *spaceContainerOutput) +{ + struct xrGetSpaceContainerFB_params params; + NTSTATUS _status; + params.session = session; + params.space = space; + params.spaceContainerOutput = spaceContainerOutput; + _status = UNIX_CALL(xrGetSpaceContainerFB, ¶ms); + assert(!_status && "xrGetSpaceContainerFB"); + return params.result; +} + +XrResult WINAPI xrGetSpaceRoomLayoutFB(XrSession session, XrSpace space, XrRoomLayoutFB *roomLayoutOutput) +{ + struct xrGetSpaceRoomLayoutFB_params params; + NTSTATUS _status; + params.session = session; + params.space = space; + params.roomLayoutOutput = roomLayoutOutput; + _status = UNIX_CALL(xrGetSpaceRoomLayoutFB, ¶ms); + assert(!_status && "xrGetSpaceRoomLayoutFB"); + return params.result; +} + +XrResult WINAPI xrGetSpaceSemanticLabelsFB(XrSession session, XrSpace space, XrSemanticLabelsFB *semanticLabelsOutput) +{ + struct xrGetSpaceSemanticLabelsFB_params params; + NTSTATUS _status; + params.session = session; + params.space = space; + params.semanticLabelsOutput = semanticLabelsOutput; + _status = UNIX_CALL(xrGetSpaceSemanticLabelsFB, ¶ms); + assert(!_status && "xrGetSpaceSemanticLabelsFB"); + return params.result; +} + +XrResult WINAPI xrGetSpaceTriangleMeshMETA(XrSpace space, const XrSpaceTriangleMeshGetInfoMETA *getInfo, XrSpaceTriangleMeshMETA *triangleMeshOutput) +{ + struct xrGetSpaceTriangleMeshMETA_params params; + NTSTATUS _status; + params.space = space; + params.getInfo = getInfo; + params.triangleMeshOutput = triangleMeshOutput; + _status = UNIX_CALL(xrGetSpaceTriangleMeshMETA, ¶ms); + assert(!_status && "xrGetSpaceTriangleMeshMETA"); + return params.result; +} + +XrResult WINAPI xrGetSpaceUserIdFB(XrSpaceUserFB user, XrSpaceUserIdFB *userId) +{ + struct xrGetSpaceUserIdFB_params params; + NTSTATUS _status; + params.user = user; + params.userId = userId; + _status = UNIX_CALL(xrGetSpaceUserIdFB, ¶ms); + assert(!_status && "xrGetSpaceUserIdFB"); + return params.result; +} + +XrResult WINAPI xrGetSpaceUuidFB(XrSpace space, XrUuidEXT *uuid) +{ + struct xrGetSpaceUuidFB_params params; + NTSTATUS _status; + params.space = space; + params.uuid = uuid; + _status = UNIX_CALL(xrGetSpaceUuidFB, ¶ms); + assert(!_status && "xrGetSpaceUuidFB"); + return params.result; +} + +XrResult WINAPI xrGetSpatialAnchorNameHTC(XrSpace anchor, XrSpatialAnchorNameHTC *name) +{ + struct xrGetSpatialAnchorNameHTC_params params; + NTSTATUS _status; + params.anchor = anchor; + params.name = name; + _status = UNIX_CALL(xrGetSpatialAnchorNameHTC, ¶ms); + assert(!_status && "xrGetSpatialAnchorNameHTC"); + return params.result; +} + +XrResult WINAPI xrGetSpatialGraphNodeBindingPropertiesMSFT(XrSpatialGraphNodeBindingMSFT nodeBinding, const XrSpatialGraphNodeBindingPropertiesGetInfoMSFT *getInfo, XrSpatialGraphNodeBindingPropertiesMSFT *properties) +{ + struct xrGetSpatialGraphNodeBindingPropertiesMSFT_params params; + NTSTATUS _status; + params.nodeBinding = nodeBinding; + params.getInfo = getInfo; + params.properties = properties; + _status = UNIX_CALL(xrGetSpatialGraphNodeBindingPropertiesMSFT, ¶ms); + assert(!_status && "xrGetSpatialGraphNodeBindingPropertiesMSFT"); + return params.result; +} + +XrResult WINAPI xrGetSwapchainStateFB(XrSwapchain swapchain, XrSwapchainStateBaseHeaderFB *state) +{ + struct xrGetSwapchainStateFB_params params; + NTSTATUS _status; + params.swapchain = swapchain; + params.state = state; + _status = UNIX_CALL(xrGetSwapchainStateFB, ¶ms); + assert(!_status && "xrGetSwapchainStateFB"); + return params.result; +} + +XrResult WINAPI xrGetSystemProperties(XrInstance instance, XrSystemId systemId, XrSystemProperties *properties) +{ + struct xrGetSystemProperties_params params; + NTSTATUS _status; + params.instance = instance; + params.systemId = systemId; + params.properties = properties; + _status = UNIX_CALL(xrGetSystemProperties, ¶ms); + assert(!_status && "xrGetSystemProperties"); + return params.result; +} + +XrResult WINAPI xrGetViewConfigurationProperties(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, XrViewConfigurationProperties *configurationProperties) +{ + struct xrGetViewConfigurationProperties_params params; + NTSTATUS _status; + params.instance = instance; + params.systemId = systemId; + params.viewConfigurationType = viewConfigurationType; + params.configurationProperties = configurationProperties; + _status = UNIX_CALL(xrGetViewConfigurationProperties, ¶ms); + assert(!_status && "xrGetViewConfigurationProperties"); + return params.result; +} + +XrResult WINAPI xrGetVirtualKeyboardDirtyTexturesMETA(XrVirtualKeyboardMETA keyboard, uint32_t textureIdCapacityInput, uint32_t *textureIdCountOutput, uint64_t *textureIds) +{ + struct xrGetVirtualKeyboardDirtyTexturesMETA_params params; + NTSTATUS _status; + params.keyboard = keyboard; + params.textureIdCapacityInput = textureIdCapacityInput; + params.textureIdCountOutput = textureIdCountOutput; + params.textureIds = textureIds; + _status = UNIX_CALL(xrGetVirtualKeyboardDirtyTexturesMETA, ¶ms); + assert(!_status && "xrGetVirtualKeyboardDirtyTexturesMETA"); + return params.result; +} + +XrResult WINAPI xrGetVirtualKeyboardModelAnimationStatesMETA(XrVirtualKeyboardMETA keyboard, XrVirtualKeyboardModelAnimationStatesMETA *animationStates) +{ + struct xrGetVirtualKeyboardModelAnimationStatesMETA_params params; + NTSTATUS _status; + params.keyboard = keyboard; + params.animationStates = animationStates; + _status = UNIX_CALL(xrGetVirtualKeyboardModelAnimationStatesMETA, ¶ms); + assert(!_status && "xrGetVirtualKeyboardModelAnimationStatesMETA"); + return params.result; +} + +XrResult WINAPI xrGetVirtualKeyboardScaleMETA(XrVirtualKeyboardMETA keyboard, float *scale) +{ + struct xrGetVirtualKeyboardScaleMETA_params params; + NTSTATUS _status; + params.keyboard = keyboard; + params.scale = scale; + _status = UNIX_CALL(xrGetVirtualKeyboardScaleMETA, ¶ms); + assert(!_status && "xrGetVirtualKeyboardScaleMETA"); + return params.result; +} + +XrResult WINAPI xrGetVirtualKeyboardTextureDataMETA(XrVirtualKeyboardMETA keyboard, uint64_t textureId, XrVirtualKeyboardTextureDataMETA *textureData) +{ + struct xrGetVirtualKeyboardTextureDataMETA_params params; + NTSTATUS _status; + params.keyboard = keyboard; + params.textureId = textureId; + params.textureData = textureData; + _status = UNIX_CALL(xrGetVirtualKeyboardTextureDataMETA, ¶ms); + assert(!_status && "xrGetVirtualKeyboardTextureDataMETA"); + return params.result; +} + +XrResult WINAPI xrGetVisibilityMaskKHR(XrSession session, XrViewConfigurationType viewConfigurationType, uint32_t viewIndex, XrVisibilityMaskTypeKHR visibilityMaskType, XrVisibilityMaskKHR *visibilityMask) +{ + struct xrGetVisibilityMaskKHR_params params; + NTSTATUS _status; + params.session = session; + params.viewConfigurationType = viewConfigurationType; + params.viewIndex = viewIndex; + params.visibilityMaskType = visibilityMaskType; + params.visibilityMask = visibilityMask; + _status = UNIX_CALL(xrGetVisibilityMaskKHR, ¶ms); + assert(!_status && "xrGetVisibilityMaskKHR"); + return params.result; +} + +XrResult WINAPI xrGetVulkanDeviceExtensionsKHR(XrInstance instance, XrSystemId systemId, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer) +{ + struct xrGetVulkanDeviceExtensionsKHR_params params; + NTSTATUS _status; + params.instance = instance; + params.systemId = systemId; + params.bufferCapacityInput = bufferCapacityInput; + params.bufferCountOutput = bufferCountOutput; + params.buffer = buffer; + _status = UNIX_CALL(xrGetVulkanDeviceExtensionsKHR, ¶ms); + assert(!_status && "xrGetVulkanDeviceExtensionsKHR"); + return params.result; +} + +XrResult WINAPI xrGetVulkanGraphicsDevice2KHR(XrInstance instance, const XrVulkanGraphicsDeviceGetInfoKHR *getInfo, VkPhysicalDevice *vulkanPhysicalDevice) +{ + struct xrGetVulkanGraphicsDevice2KHR_params params; + NTSTATUS _status; + params.instance = instance; + params.getInfo = getInfo; + params.vulkanPhysicalDevice = vulkanPhysicalDevice; + _status = UNIX_CALL(xrGetVulkanGraphicsDevice2KHR, ¶ms); + assert(!_status && "xrGetVulkanGraphicsDevice2KHR"); + return params.result; +} + +XrResult WINAPI xrGetVulkanGraphicsDeviceKHR(XrInstance instance, XrSystemId systemId, VkInstance vkInstance, VkPhysicalDevice *vkPhysicalDevice) +{ + struct xrGetVulkanGraphicsDeviceKHR_params params; + NTSTATUS _status; + params.instance = instance; + params.systemId = systemId; + params.vkInstance = vkInstance; + params.vkPhysicalDevice = vkPhysicalDevice; + _status = UNIX_CALL(xrGetVulkanGraphicsDeviceKHR, ¶ms); + assert(!_status && "xrGetVulkanGraphicsDeviceKHR"); + return params.result; +} + +XrResult WINAPI xrGetVulkanGraphicsRequirements2KHR(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsVulkanKHR *graphicsRequirements) +{ + struct xrGetVulkanGraphicsRequirements2KHR_params params; + NTSTATUS _status; + params.instance = instance; + params.systemId = systemId; + params.graphicsRequirements = graphicsRequirements; + _status = UNIX_CALL(xrGetVulkanGraphicsRequirements2KHR, ¶ms); + assert(!_status && "xrGetVulkanGraphicsRequirements2KHR"); + return params.result; +} + +XrResult WINAPI xrGetVulkanGraphicsRequirementsKHR(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsVulkanKHR *graphicsRequirements) +{ + struct xrGetVulkanGraphicsRequirementsKHR_params params; + NTSTATUS _status; + params.instance = instance; + params.systemId = systemId; + params.graphicsRequirements = graphicsRequirements; + _status = UNIX_CALL(xrGetVulkanGraphicsRequirementsKHR, ¶ms); + assert(!_status && "xrGetVulkanGraphicsRequirementsKHR"); + return params.result; +} + +XrResult WINAPI xrGetVulkanInstanceExtensionsKHR(XrInstance instance, XrSystemId systemId, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer) +{ + struct xrGetVulkanInstanceExtensionsKHR_params params; + NTSTATUS _status; + params.instance = instance; + params.systemId = systemId; + params.bufferCapacityInput = bufferCapacityInput; + params.bufferCountOutput = bufferCountOutput; + params.buffer = buffer; + _status = UNIX_CALL(xrGetVulkanInstanceExtensionsKHR, ¶ms); + assert(!_status && "xrGetVulkanInstanceExtensionsKHR"); + return params.result; +} + +XrResult WINAPI xrImportLocalizationMapML(XrSession session, const XrLocalizationMapImportInfoML *importInfo, XrUuidEXT *mapUuid) +{ + struct xrImportLocalizationMapML_params params; + NTSTATUS _status; + params.session = session; + params.importInfo = importInfo; + params.mapUuid = mapUuid; + _status = UNIX_CALL(xrImportLocalizationMapML, ¶ms); + assert(!_status && "xrImportLocalizationMapML"); + return params.result; +} + +XrResult WINAPI xrLoadControllerModelMSFT(XrSession session, XrControllerModelKeyMSFT modelKey, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, uint8_t *buffer) +{ + struct xrLoadControllerModelMSFT_params params; + NTSTATUS _status; + params.session = session; + params.modelKey = modelKey; + params.bufferCapacityInput = bufferCapacityInput; + params.bufferCountOutput = bufferCountOutput; + params.buffer = buffer; + _status = UNIX_CALL(xrLoadControllerModelMSFT, ¶ms); + assert(!_status && "xrLoadControllerModelMSFT"); + return params.result; +} + +XrResult WINAPI xrLoadRenderModelFB(XrSession session, const XrRenderModelLoadInfoFB *info, XrRenderModelBufferFB *buffer) +{ + struct xrLoadRenderModelFB_params params; + NTSTATUS _status; + params.session = session; + params.info = info; + params.buffer = buffer; + _status = UNIX_CALL(xrLoadRenderModelFB, ¶ms); + assert(!_status && "xrLoadRenderModelFB"); + return params.result; +} + +XrResult WINAPI xrLocateBodyJointsFB(XrBodyTrackerFB bodyTracker, const XrBodyJointsLocateInfoFB *locateInfo, XrBodyJointLocationsFB *locations) +{ + struct xrLocateBodyJointsFB_params params; + NTSTATUS _status; + params.bodyTracker = bodyTracker; + params.locateInfo = locateInfo; + params.locations = locations; + _status = UNIX_CALL(xrLocateBodyJointsFB, ¶ms); + assert(!_status && "xrLocateBodyJointsFB"); + return params.result; +} + +XrResult WINAPI xrLocateHandJointsEXT(XrHandTrackerEXT handTracker, const XrHandJointsLocateInfoEXT *locateInfo, XrHandJointLocationsEXT *locations) +{ + struct xrLocateHandJointsEXT_params params; + NTSTATUS _status; + params.handTracker = handTracker; + params.locateInfo = locateInfo; + params.locations = locations; + _status = UNIX_CALL(xrLocateHandJointsEXT, ¶ms); + assert(!_status && "xrLocateHandJointsEXT"); + return params.result; +} + +XrResult WINAPI xrLocateSceneComponentsMSFT(XrSceneMSFT scene, const XrSceneComponentsLocateInfoMSFT *locateInfo, XrSceneComponentLocationsMSFT *locations) +{ + struct xrLocateSceneComponentsMSFT_params params; + NTSTATUS _status; + params.scene = scene; + params.locateInfo = locateInfo; + params.locations = locations; + _status = UNIX_CALL(xrLocateSceneComponentsMSFT, ¶ms); + assert(!_status && "xrLocateSceneComponentsMSFT"); + return params.result; +} + +XrResult WINAPI xrLocateSpace(XrSpace space, XrSpace baseSpace, XrTime time, XrSpaceLocation *location) +{ + struct xrLocateSpace_params params; + NTSTATUS _status; + params.space = space; + params.baseSpace = baseSpace; + params.time = time; + params.location = location; + _status = UNIX_CALL(xrLocateSpace, ¶ms); + assert(!_status && "xrLocateSpace"); + return params.result; +} + +XrResult WINAPI xrLocateSpaces(XrSession session, const XrSpacesLocateInfo *locateInfo, XrSpaceLocations *spaceLocations) +{ + struct xrLocateSpaces_params params; + NTSTATUS _status; + params.session = session; + params.locateInfo = locateInfo; + params.spaceLocations = spaceLocations; + _status = UNIX_CALL(xrLocateSpaces, ¶ms); + assert(!_status && "xrLocateSpaces"); + return params.result; +} + +XrResult WINAPI xrLocateSpacesKHR(XrSession session, const XrSpacesLocateInfo *locateInfo, XrSpaceLocations *spaceLocations) +{ + struct xrLocateSpacesKHR_params params; + NTSTATUS _status; + params.session = session; + params.locateInfo = locateInfo; + params.spaceLocations = spaceLocations; + _status = UNIX_CALL(xrLocateSpacesKHR, ¶ms); + assert(!_status && "xrLocateSpacesKHR"); + return params.result; +} + +XrResult WINAPI xrLocateViews(XrSession session, const XrViewLocateInfo *viewLocateInfo, XrViewState *viewState, uint32_t viewCapacityInput, uint32_t *viewCountOutput, XrView *views) +{ + struct xrLocateViews_params params; + NTSTATUS _status; + params.session = session; + params.viewLocateInfo = viewLocateInfo; + params.viewState = viewState; + params.viewCapacityInput = viewCapacityInput; + params.viewCountOutput = viewCountOutput; + params.views = views; + _status = UNIX_CALL(xrLocateViews, ¶ms); + assert(!_status && "xrLocateViews"); + return params.result; +} + +XrResult WINAPI xrPassthroughLayerPauseFB(XrPassthroughLayerFB layer) +{ + struct xrPassthroughLayerPauseFB_params params; + NTSTATUS _status; + params.layer = layer; + _status = UNIX_CALL(xrPassthroughLayerPauseFB, ¶ms); + assert(!_status && "xrPassthroughLayerPauseFB"); + return params.result; +} + +XrResult WINAPI xrPassthroughLayerResumeFB(XrPassthroughLayerFB layer) +{ + struct xrPassthroughLayerResumeFB_params params; + NTSTATUS _status; + params.layer = layer; + _status = UNIX_CALL(xrPassthroughLayerResumeFB, ¶ms); + assert(!_status && "xrPassthroughLayerResumeFB"); + return params.result; +} + +XrResult WINAPI xrPassthroughLayerSetKeyboardHandsIntensityFB(XrPassthroughLayerFB layer, const XrPassthroughKeyboardHandsIntensityFB *intensity) +{ + struct xrPassthroughLayerSetKeyboardHandsIntensityFB_params params; + NTSTATUS _status; + params.layer = layer; + params.intensity = intensity; + _status = UNIX_CALL(xrPassthroughLayerSetKeyboardHandsIntensityFB, ¶ms); + assert(!_status && "xrPassthroughLayerSetKeyboardHandsIntensityFB"); + return params.result; +} + +XrResult WINAPI xrPassthroughLayerSetStyleFB(XrPassthroughLayerFB layer, const XrPassthroughStyleFB *style) +{ + struct xrPassthroughLayerSetStyleFB_params params; + NTSTATUS _status; + params.layer = layer; + params.style = style; + _status = UNIX_CALL(xrPassthroughLayerSetStyleFB, ¶ms); + assert(!_status && "xrPassthroughLayerSetStyleFB"); + return params.result; +} + +XrResult WINAPI xrPassthroughPauseFB(XrPassthroughFB passthrough) +{ + struct xrPassthroughPauseFB_params params; + NTSTATUS _status; + params.passthrough = passthrough; + _status = UNIX_CALL(xrPassthroughPauseFB, ¶ms); + assert(!_status && "xrPassthroughPauseFB"); + return params.result; +} + +XrResult WINAPI xrPassthroughStartFB(XrPassthroughFB passthrough) +{ + struct xrPassthroughStartFB_params params; + NTSTATUS _status; + params.passthrough = passthrough; + _status = UNIX_CALL(xrPassthroughStartFB, ¶ms); + assert(!_status && "xrPassthroughStartFB"); + return params.result; +} + +XrResult WINAPI xrPathToString(XrInstance instance, XrPath path, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer) +{ + struct xrPathToString_params params; + NTSTATUS _status; + params.instance = instance; + params.path = path; + params.bufferCapacityInput = bufferCapacityInput; + params.bufferCountOutput = bufferCountOutput; + params.buffer = buffer; + _status = UNIX_CALL(xrPathToString, ¶ms); + assert(!_status && "xrPathToString"); + return params.result; +} + +XrResult WINAPI xrPerfSettingsSetPerformanceLevelEXT(XrSession session, XrPerfSettingsDomainEXT domain, XrPerfSettingsLevelEXT level) +{ + struct xrPerfSettingsSetPerformanceLevelEXT_params params; + NTSTATUS _status; + params.session = session; + params.domain = domain; + params.level = level; + _status = UNIX_CALL(xrPerfSettingsSetPerformanceLevelEXT, ¶ms); + assert(!_status && "xrPerfSettingsSetPerformanceLevelEXT"); + return params.result; +} + +XrResult WINAPI xrPersistSpatialAnchorMSFT(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, const XrSpatialAnchorPersistenceInfoMSFT *spatialAnchorPersistenceInfo) +{ + struct xrPersistSpatialAnchorMSFT_params params; + NTSTATUS _status; + params.spatialAnchorStore = spatialAnchorStore; + params.spatialAnchorPersistenceInfo = spatialAnchorPersistenceInfo; + _status = UNIX_CALL(xrPersistSpatialAnchorMSFT, ¶ms); + assert(!_status && "xrPersistSpatialAnchorMSFT"); + return params.result; +} + +XrResult WINAPI xrPollFutureEXT(XrInstance instance, const XrFuturePollInfoEXT *pollInfo, XrFuturePollResultEXT *pollResult) +{ + struct xrPollFutureEXT_params params; + NTSTATUS _status; + params.instance = instance; + params.pollInfo = pollInfo; + params.pollResult = pollResult; + _status = UNIX_CALL(xrPollFutureEXT, ¶ms); + assert(!_status && "xrPollFutureEXT"); + return params.result; +} + +XrResult WINAPI xrQueryLocalizationMapsML(XrSession session, const XrLocalizationMapQueryInfoBaseHeaderML *queryInfo, uint32_t mapCapacityInput, uint32_t *mapCountOutput, XrLocalizationMapML *maps) +{ + struct xrQueryLocalizationMapsML_params params; + NTSTATUS _status; + params.session = session; + params.queryInfo = queryInfo; + params.mapCapacityInput = mapCapacityInput; + params.mapCountOutput = mapCountOutput; + params.maps = maps; + _status = UNIX_CALL(xrQueryLocalizationMapsML, ¶ms); + assert(!_status && "xrQueryLocalizationMapsML"); + return params.result; +} + +XrResult WINAPI xrQueryPerformanceMetricsCounterMETA(XrSession session, XrPath counterPath, XrPerformanceMetricsCounterMETA *counter) +{ + struct xrQueryPerformanceMetricsCounterMETA_params params; + NTSTATUS _status; + params.session = session; + params.counterPath = counterPath; + params.counter = counter; + _status = UNIX_CALL(xrQueryPerformanceMetricsCounterMETA, ¶ms); + assert(!_status && "xrQueryPerformanceMetricsCounterMETA"); + return params.result; +} + +XrResult WINAPI xrQuerySpacesFB(XrSession session, const XrSpaceQueryInfoBaseHeaderFB *info, XrAsyncRequestIdFB *requestId) +{ + struct xrQuerySpacesFB_params params; + NTSTATUS _status; + params.session = session; + params.info = info; + params.requestId = requestId; + _status = UNIX_CALL(xrQuerySpacesFB, ¶ms); + assert(!_status && "xrQuerySpacesFB"); + return params.result; +} + +XrResult WINAPI xrQuerySystemTrackedKeyboardFB(XrSession session, const XrKeyboardTrackingQueryFB *queryInfo, XrKeyboardTrackingDescriptionFB *keyboard) +{ + struct xrQuerySystemTrackedKeyboardFB_params params; + NTSTATUS _status; + params.session = session; + params.queryInfo = queryInfo; + params.keyboard = keyboard; + _status = UNIX_CALL(xrQuerySystemTrackedKeyboardFB, ¶ms); + assert(!_status && "xrQuerySystemTrackedKeyboardFB"); + return params.result; +} + +XrResult WINAPI xrRequestDisplayRefreshRateFB(XrSession session, float displayRefreshRate) +{ + struct xrRequestDisplayRefreshRateFB_params params; + NTSTATUS _status; + params.session = session; + params.displayRefreshRate = displayRefreshRate; + _status = UNIX_CALL(xrRequestDisplayRefreshRateFB, ¶ms); + assert(!_status && "xrRequestDisplayRefreshRateFB"); + return params.result; +} + +XrResult WINAPI xrRequestExitSession(XrSession session) +{ + struct xrRequestExitSession_params params; + NTSTATUS _status; + params.session = session; + _status = UNIX_CALL(xrRequestExitSession, ¶ms); + assert(!_status && "xrRequestExitSession"); + return params.result; +} + +XrResult WINAPI xrRequestMapLocalizationML(XrSession session, const XrMapLocalizationRequestInfoML *requestInfo) +{ + struct xrRequestMapLocalizationML_params params; + NTSTATUS _status; + params.session = session; + params.requestInfo = requestInfo; + _status = UNIX_CALL(xrRequestMapLocalizationML, ¶ms); + assert(!_status && "xrRequestMapLocalizationML"); + return params.result; +} + +XrResult WINAPI xrRequestSceneCaptureFB(XrSession session, const XrSceneCaptureRequestInfoFB *info, XrAsyncRequestIdFB *requestId) +{ + struct xrRequestSceneCaptureFB_params params; + NTSTATUS _status; + params.session = session; + params.info = info; + params.requestId = requestId; + _status = UNIX_CALL(xrRequestSceneCaptureFB, ¶ms); + assert(!_status && "xrRequestSceneCaptureFB"); + return params.result; +} + +XrResult WINAPI xrResultToString(XrInstance instance, XrResult value, char buffer[]) +{ + struct xrResultToString_params params; + NTSTATUS _status; + params.instance = instance; + params.value = value; + params.buffer = buffer; + _status = UNIX_CALL(xrResultToString, ¶ms); + assert(!_status && "xrResultToString"); + return params.result; +} + +XrResult WINAPI xrRetrieveSpaceQueryResultsFB(XrSession session, XrAsyncRequestIdFB requestId, XrSpaceQueryResultsFB *results) +{ + struct xrRetrieveSpaceQueryResultsFB_params params; + NTSTATUS _status; + params.session = session; + params.requestId = requestId; + params.results = results; + _status = UNIX_CALL(xrRetrieveSpaceQueryResultsFB, ¶ms); + assert(!_status && "xrRetrieveSpaceQueryResultsFB"); + return params.result; +} + +XrResult WINAPI xrSaveSpaceFB(XrSession session, const XrSpaceSaveInfoFB *info, XrAsyncRequestIdFB *requestId) +{ + struct xrSaveSpaceFB_params params; + NTSTATUS _status; + params.session = session; + params.info = info; + params.requestId = requestId; + _status = UNIX_CALL(xrSaveSpaceFB, ¶ms); + assert(!_status && "xrSaveSpaceFB"); + return params.result; +} + +XrResult WINAPI xrSaveSpaceListFB(XrSession session, const XrSpaceListSaveInfoFB *info, XrAsyncRequestIdFB *requestId) +{ + struct xrSaveSpaceListFB_params params; + NTSTATUS _status; + params.session = session; + params.info = info; + params.requestId = requestId; + _status = UNIX_CALL(xrSaveSpaceListFB, ¶ms); + assert(!_status && "xrSaveSpaceListFB"); + return params.result; +} + +XrResult WINAPI xrSendVirtualKeyboardInputMETA(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardInputInfoMETA *info, XrPosef *interactorRootPose) +{ + struct xrSendVirtualKeyboardInputMETA_params params; + NTSTATUS _status; + params.keyboard = keyboard; + params.info = info; + params.interactorRootPose = interactorRootPose; + _status = UNIX_CALL(xrSendVirtualKeyboardInputMETA, ¶ms); + assert(!_status && "xrSendVirtualKeyboardInputMETA"); + return params.result; +} + +XrResult WINAPI xrSetColorSpaceFB(XrSession session, const XrColorSpaceFB colorSpace) +{ + struct xrSetColorSpaceFB_params params; + NTSTATUS _status; + params.session = session; + params.colorSpace = colorSpace; + _status = UNIX_CALL(xrSetColorSpaceFB, ¶ms); + assert(!_status && "xrSetColorSpaceFB"); + return params.result; +} + +XrResult WINAPI xrSetDigitalLensControlALMALENCE(XrSession session, const XrDigitalLensControlALMALENCE *digitalLensControl) +{ + struct xrSetDigitalLensControlALMALENCE_params params; + NTSTATUS _status; + params.session = session; + params.digitalLensControl = digitalLensControl; + _status = UNIX_CALL(xrSetDigitalLensControlALMALENCE, ¶ms); + assert(!_status && "xrSetDigitalLensControlALMALENCE"); + return params.result; +} + +XrResult WINAPI xrSetEnvironmentDepthEstimationVARJO(XrSession session, XrBool32 enabled) +{ + struct xrSetEnvironmentDepthEstimationVARJO_params params; + NTSTATUS _status; + params.session = session; + params.enabled = enabled; + _status = UNIX_CALL(xrSetEnvironmentDepthEstimationVARJO, ¶ms); + assert(!_status && "xrSetEnvironmentDepthEstimationVARJO"); + return params.result; +} + +XrResult WINAPI xrSetEnvironmentDepthHandRemovalMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider, const XrEnvironmentDepthHandRemovalSetInfoMETA *setInfo) +{ + struct xrSetEnvironmentDepthHandRemovalMETA_params params; + NTSTATUS _status; + params.environmentDepthProvider = environmentDepthProvider; + params.setInfo = setInfo; + _status = UNIX_CALL(xrSetEnvironmentDepthHandRemovalMETA, ¶ms); + assert(!_status && "xrSetEnvironmentDepthHandRemovalMETA"); + return params.result; +} + +XrResult WINAPI xrSetInputDeviceActiveEXT(XrSession session, XrPath interactionProfile, XrPath topLevelPath, XrBool32 isActive) +{ + struct xrSetInputDeviceActiveEXT_params params; + NTSTATUS _status; + params.session = session; + params.interactionProfile = interactionProfile; + params.topLevelPath = topLevelPath; + params.isActive = isActive; + _status = UNIX_CALL(xrSetInputDeviceActiveEXT, ¶ms); + assert(!_status && "xrSetInputDeviceActiveEXT"); + return params.result; +} + +XrResult WINAPI xrSetInputDeviceLocationEXT(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, XrSpace space, XrPosef pose) +{ + struct xrSetInputDeviceLocationEXT_params params; + NTSTATUS _status; + params.session = session; + params.topLevelPath = topLevelPath; + params.inputSourcePath = inputSourcePath; + params.space = space; + params.pose = pose; + _status = UNIX_CALL(xrSetInputDeviceLocationEXT, ¶ms); + assert(!_status && "xrSetInputDeviceLocationEXT"); + return params.result; +} + +XrResult WINAPI xrSetInputDeviceStateBoolEXT(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, XrBool32 state) +{ + struct xrSetInputDeviceStateBoolEXT_params params; + NTSTATUS _status; + params.session = session; + params.topLevelPath = topLevelPath; + params.inputSourcePath = inputSourcePath; + params.state = state; + _status = UNIX_CALL(xrSetInputDeviceStateBoolEXT, ¶ms); + assert(!_status && "xrSetInputDeviceStateBoolEXT"); + return params.result; +} + +XrResult WINAPI xrSetInputDeviceStateFloatEXT(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, float state) +{ + struct xrSetInputDeviceStateFloatEXT_params params; + NTSTATUS _status; + params.session = session; + params.topLevelPath = topLevelPath; + params.inputSourcePath = inputSourcePath; + params.state = state; + _status = UNIX_CALL(xrSetInputDeviceStateFloatEXT, ¶ms); + assert(!_status && "xrSetInputDeviceStateFloatEXT"); + return params.result; +} + +XrResult WINAPI xrSetInputDeviceStateVector2fEXT(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, XrVector2f state) +{ + struct xrSetInputDeviceStateVector2fEXT_params params; + NTSTATUS _status; + params.session = session; + params.topLevelPath = topLevelPath; + params.inputSourcePath = inputSourcePath; + params.state = state; + _status = UNIX_CALL(xrSetInputDeviceStateVector2fEXT, ¶ms); + assert(!_status && "xrSetInputDeviceStateVector2fEXT"); + return params.result; +} + +XrResult WINAPI xrSetMarkerTrackingPredictionVARJO(XrSession session, uint64_t markerId, XrBool32 enable) +{ + struct xrSetMarkerTrackingPredictionVARJO_params params; + NTSTATUS _status; + params.session = session; + params.markerId = markerId; + params.enable = enable; + _status = UNIX_CALL(xrSetMarkerTrackingPredictionVARJO, ¶ms); + assert(!_status && "xrSetMarkerTrackingPredictionVARJO"); + return params.result; +} + +XrResult WINAPI xrSetMarkerTrackingTimeoutVARJO(XrSession session, uint64_t markerId, XrDuration timeout) +{ + struct xrSetMarkerTrackingTimeoutVARJO_params params; + NTSTATUS _status; + params.session = session; + params.markerId = markerId; + params.timeout = timeout; + _status = UNIX_CALL(xrSetMarkerTrackingTimeoutVARJO, ¶ms); + assert(!_status && "xrSetMarkerTrackingTimeoutVARJO"); + return params.result; +} + +XrResult WINAPI xrSetMarkerTrackingVARJO(XrSession session, XrBool32 enabled) +{ + struct xrSetMarkerTrackingVARJO_params params; + NTSTATUS _status; + params.session = session; + params.enabled = enabled; + _status = UNIX_CALL(xrSetMarkerTrackingVARJO, ¶ms); + assert(!_status && "xrSetMarkerTrackingVARJO"); + return params.result; +} + +XrResult WINAPI xrSetPerformanceMetricsStateMETA(XrSession session, const XrPerformanceMetricsStateMETA *state) +{ + struct xrSetPerformanceMetricsStateMETA_params params; + NTSTATUS _status; + params.session = session; + params.state = state; + _status = UNIX_CALL(xrSetPerformanceMetricsStateMETA, ¶ms); + assert(!_status && "xrSetPerformanceMetricsStateMETA"); + return params.result; +} + +XrResult WINAPI xrSetSpaceComponentStatusFB(XrSpace space, const XrSpaceComponentStatusSetInfoFB *info, XrAsyncRequestIdFB *requestId) +{ + struct xrSetSpaceComponentStatusFB_params params; + NTSTATUS _status; + params.space = space; + params.info = info; + params.requestId = requestId; + _status = UNIX_CALL(xrSetSpaceComponentStatusFB, ¶ms); + assert(!_status && "xrSetSpaceComponentStatusFB"); + return params.result; +} + +XrResult WINAPI xrSetTrackingOptimizationSettingsHintQCOM(XrSession session, XrTrackingOptimizationSettingsDomainQCOM domain, XrTrackingOptimizationSettingsHintQCOM hint) +{ + struct xrSetTrackingOptimizationSettingsHintQCOM_params params; + NTSTATUS _status; + params.session = session; + params.domain = domain; + params.hint = hint; + _status = UNIX_CALL(xrSetTrackingOptimizationSettingsHintQCOM, ¶ms); + assert(!_status && "xrSetTrackingOptimizationSettingsHintQCOM"); + return params.result; +} + +XrResult WINAPI xrSetViewOffsetVARJO(XrSession session, float offset) +{ + struct xrSetViewOffsetVARJO_params params; + NTSTATUS _status; + params.session = session; + params.offset = offset; + _status = UNIX_CALL(xrSetViewOffsetVARJO, ¶ms); + assert(!_status && "xrSetViewOffsetVARJO"); + return params.result; +} + +XrResult WINAPI xrSetVirtualKeyboardModelVisibilityMETA(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardModelVisibilitySetInfoMETA *modelVisibility) +{ + struct xrSetVirtualKeyboardModelVisibilityMETA_params params; + NTSTATUS _status; + params.keyboard = keyboard; + params.modelVisibility = modelVisibility; + _status = UNIX_CALL(xrSetVirtualKeyboardModelVisibilityMETA, ¶ms); + assert(!_status && "xrSetVirtualKeyboardModelVisibilityMETA"); + return params.result; +} + +XrResult WINAPI xrShareSpacesFB(XrSession session, const XrSpaceShareInfoFB *info, XrAsyncRequestIdFB *requestId) +{ + struct xrShareSpacesFB_params params; + NTSTATUS _status; + params.session = session; + params.info = info; + params.requestId = requestId; + _status = UNIX_CALL(xrShareSpacesFB, ¶ms); + assert(!_status && "xrShareSpacesFB"); + return params.result; +} + +XrResult WINAPI xrSnapshotMarkerDetectorML(XrMarkerDetectorML markerDetector, XrMarkerDetectorSnapshotInfoML *snapshotInfo) +{ + struct xrSnapshotMarkerDetectorML_params params; + NTSTATUS _status; + params.markerDetector = markerDetector; + params.snapshotInfo = snapshotInfo; + _status = UNIX_CALL(xrSnapshotMarkerDetectorML, ¶ms); + assert(!_status && "xrSnapshotMarkerDetectorML"); + return params.result; +} + +XrResult WINAPI xrStartEnvironmentDepthProviderMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider) +{ + struct xrStartEnvironmentDepthProviderMETA_params params; + NTSTATUS _status; + params.environmentDepthProvider = environmentDepthProvider; + _status = UNIX_CALL(xrStartEnvironmentDepthProviderMETA, ¶ms); + assert(!_status && "xrStartEnvironmentDepthProviderMETA"); + return params.result; +} + +XrResult WINAPI xrStopEnvironmentDepthProviderMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider) +{ + struct xrStopEnvironmentDepthProviderMETA_params params; + NTSTATUS _status; + params.environmentDepthProvider = environmentDepthProvider; + _status = UNIX_CALL(xrStopEnvironmentDepthProviderMETA, ¶ms); + assert(!_status && "xrStopEnvironmentDepthProviderMETA"); + return params.result; +} + +XrResult WINAPI xrStopHapticFeedback(XrSession session, const XrHapticActionInfo *hapticActionInfo) +{ + struct xrStopHapticFeedback_params params; + NTSTATUS _status; + params.session = session; + params.hapticActionInfo = hapticActionInfo; + _status = UNIX_CALL(xrStopHapticFeedback, ¶ms); + assert(!_status && "xrStopHapticFeedback"); + return params.result; +} + +XrResult WINAPI xrStringToPath(XrInstance instance, const char *pathString, XrPath *path) +{ + struct xrStringToPath_params params; + NTSTATUS _status; + params.instance = instance; + params.pathString = pathString; + params.path = path; + _status = UNIX_CALL(xrStringToPath, ¶ms); + assert(!_status && "xrStringToPath"); + return params.result; +} + +XrResult WINAPI xrStructureTypeToString(XrInstance instance, XrStructureType value, char buffer[]) +{ + struct xrStructureTypeToString_params params; + NTSTATUS _status; + params.instance = instance; + params.value = value; + params.buffer = buffer; + _status = UNIX_CALL(xrStructureTypeToString, ¶ms); + assert(!_status && "xrStructureTypeToString"); + return params.result; +} + +XrResult WINAPI xrSuggestInteractionProfileBindings(XrInstance instance, const XrInteractionProfileSuggestedBinding *suggestedBindings) +{ + struct xrSuggestInteractionProfileBindings_params params; + NTSTATUS _status; + params.instance = instance; + params.suggestedBindings = suggestedBindings; + _status = UNIX_CALL(xrSuggestInteractionProfileBindings, ¶ms); + assert(!_status && "xrSuggestInteractionProfileBindings"); + return params.result; +} + +XrResult WINAPI xrSuggestVirtualKeyboardLocationMETA(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardLocationInfoMETA *locationInfo) +{ + struct xrSuggestVirtualKeyboardLocationMETA_params params; + NTSTATUS _status; + params.keyboard = keyboard; + params.locationInfo = locationInfo; + _status = UNIX_CALL(xrSuggestVirtualKeyboardLocationMETA, ¶ms); + assert(!_status && "xrSuggestVirtualKeyboardLocationMETA"); + return params.result; +} + +XrResult WINAPI xrSyncActions(XrSession session, const XrActionsSyncInfo *syncInfo) +{ + struct xrSyncActions_params params; + NTSTATUS _status; + params.session = session; + params.syncInfo = syncInfo; + _status = UNIX_CALL(xrSyncActions, ¶ms); + assert(!_status && "xrSyncActions"); + return params.result; +} + +XrResult WINAPI xrThermalGetTemperatureTrendEXT(XrSession session, XrPerfSettingsDomainEXT domain, XrPerfSettingsNotificationLevelEXT *notificationLevel, float *tempHeadroom, float *tempSlope) +{ + struct xrThermalGetTemperatureTrendEXT_params params; + NTSTATUS _status; + params.session = session; + params.domain = domain; + params.notificationLevel = notificationLevel; + params.tempHeadroom = tempHeadroom; + params.tempSlope = tempSlope; + _status = UNIX_CALL(xrThermalGetTemperatureTrendEXT, ¶ms); + assert(!_status && "xrThermalGetTemperatureTrendEXT"); + return params.result; +} + +XrResult WINAPI xrTriangleMeshBeginUpdateFB(XrTriangleMeshFB mesh) +{ + struct xrTriangleMeshBeginUpdateFB_params params; + NTSTATUS _status; + params.mesh = mesh; + _status = UNIX_CALL(xrTriangleMeshBeginUpdateFB, ¶ms); + assert(!_status && "xrTriangleMeshBeginUpdateFB"); + return params.result; +} + +XrResult WINAPI xrTriangleMeshBeginVertexBufferUpdateFB(XrTriangleMeshFB mesh, uint32_t *outVertexCount) +{ + struct xrTriangleMeshBeginVertexBufferUpdateFB_params params; + NTSTATUS _status; + params.mesh = mesh; + params.outVertexCount = outVertexCount; + _status = UNIX_CALL(xrTriangleMeshBeginVertexBufferUpdateFB, ¶ms); + assert(!_status && "xrTriangleMeshBeginVertexBufferUpdateFB"); + return params.result; +} + +XrResult WINAPI xrTriangleMeshEndUpdateFB(XrTriangleMeshFB mesh, uint32_t vertexCount, uint32_t triangleCount) +{ + struct xrTriangleMeshEndUpdateFB_params params; + NTSTATUS _status; + params.mesh = mesh; + params.vertexCount = vertexCount; + params.triangleCount = triangleCount; + _status = UNIX_CALL(xrTriangleMeshEndUpdateFB, ¶ms); + assert(!_status && "xrTriangleMeshEndUpdateFB"); + return params.result; +} + +XrResult WINAPI xrTriangleMeshEndVertexBufferUpdateFB(XrTriangleMeshFB mesh) +{ + struct xrTriangleMeshEndVertexBufferUpdateFB_params params; + NTSTATUS _status; + params.mesh = mesh; + _status = UNIX_CALL(xrTriangleMeshEndVertexBufferUpdateFB, ¶ms); + assert(!_status && "xrTriangleMeshEndVertexBufferUpdateFB"); + return params.result; +} + +XrResult WINAPI xrTriangleMeshGetIndexBufferFB(XrTriangleMeshFB mesh, uint32_t **outIndexBuffer) +{ + struct xrTriangleMeshGetIndexBufferFB_params params; + NTSTATUS _status; + params.mesh = mesh; + params.outIndexBuffer = outIndexBuffer; + _status = UNIX_CALL(xrTriangleMeshGetIndexBufferFB, ¶ms); + assert(!_status && "xrTriangleMeshGetIndexBufferFB"); + return params.result; +} + +XrResult WINAPI xrTriangleMeshGetVertexBufferFB(XrTriangleMeshFB mesh, XrVector3f **outVertexBuffer) +{ + struct xrTriangleMeshGetVertexBufferFB_params params; + NTSTATUS _status; + params.mesh = mesh; + params.outVertexBuffer = outVertexBuffer; + _status = UNIX_CALL(xrTriangleMeshGetVertexBufferFB, ¶ms); + assert(!_status && "xrTriangleMeshGetVertexBufferFB"); + return params.result; +} + +XrResult WINAPI xrTryCreateSpatialGraphStaticNodeBindingMSFT(XrSession session, const XrSpatialGraphStaticNodeBindingCreateInfoMSFT *createInfo, XrSpatialGraphNodeBindingMSFT *nodeBinding) +{ + struct xrTryCreateSpatialGraphStaticNodeBindingMSFT_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.nodeBinding = nodeBinding; + _status = UNIX_CALL(xrTryCreateSpatialGraphStaticNodeBindingMSFT, ¶ms); + assert(!_status && "xrTryCreateSpatialGraphStaticNodeBindingMSFT"); + return params.result; +} + +XrResult WINAPI xrUnpersistSpatialAnchorMSFT(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, const XrSpatialAnchorPersistenceNameMSFT *spatialAnchorPersistenceName) +{ + struct xrUnpersistSpatialAnchorMSFT_params params; + NTSTATUS _status; + params.spatialAnchorStore = spatialAnchorStore; + params.spatialAnchorPersistenceName = spatialAnchorPersistenceName; + _status = UNIX_CALL(xrUnpersistSpatialAnchorMSFT, ¶ms); + assert(!_status && "xrUnpersistSpatialAnchorMSFT"); + return params.result; +} + +XrResult WINAPI xrUpdateHandMeshMSFT(XrHandTrackerEXT handTracker, const XrHandMeshUpdateInfoMSFT *updateInfo, XrHandMeshMSFT *handMesh) +{ + struct xrUpdateHandMeshMSFT_params params; + NTSTATUS _status; + params.handTracker = handTracker; + params.updateInfo = updateInfo; + params.handMesh = handMesh; + _status = UNIX_CALL(xrUpdateHandMeshMSFT, ¶ms); + assert(!_status && "xrUpdateHandMeshMSFT"); + return params.result; +} + +XrResult WINAPI xrUpdatePassthroughColorLutMETA(XrPassthroughColorLutMETA colorLut, const XrPassthroughColorLutUpdateInfoMETA *updateInfo) +{ + struct xrUpdatePassthroughColorLutMETA_params params; + NTSTATUS _status; + params.colorLut = colorLut; + params.updateInfo = updateInfo; + _status = UNIX_CALL(xrUpdatePassthroughColorLutMETA, ¶ms); + assert(!_status && "xrUpdatePassthroughColorLutMETA"); + return params.result; +} + +XrResult WINAPI xrUpdateSwapchainFB(XrSwapchain swapchain, const XrSwapchainStateBaseHeaderFB *state) +{ + struct xrUpdateSwapchainFB_params params; + NTSTATUS _status; + params.swapchain = swapchain; + params.state = state; + _status = UNIX_CALL(xrUpdateSwapchainFB, ¶ms); + assert(!_status && "xrUpdateSwapchainFB"); + return params.result; +} + +XrResult WINAPI xrWaitFrame(XrSession session, const XrFrameWaitInfo *frameWaitInfo, XrFrameState *frameState) +{ + struct xrWaitFrame_params params; + NTSTATUS _status; + params.session = session; + params.frameWaitInfo = frameWaitInfo; + params.frameState = frameState; + _status = UNIX_CALL(xrWaitFrame, ¶ms); + assert(!_status && "xrWaitFrame"); + return params.result; +} + +XrResult WINAPI xrWaitSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageWaitInfo *waitInfo) +{ + struct xrWaitSwapchainImage_params params; + NTSTATUS _status; + params.swapchain = swapchain; + params.waitInfo = waitInfo; + _status = UNIX_CALL(xrWaitSwapchainImage, ¶ms); + assert(!_status && "xrWaitSwapchainImage"); + return params.result; +} + +static const struct openxr_func xr_instance_dispatch_table[] = +{ + {"xrAcquireEnvironmentDepthImageMETA", xrAcquireEnvironmentDepthImageMETA}, + {"xrAcquireSwapchainImage", xrAcquireSwapchainImage}, + {"xrApplyForceFeedbackCurlMNDX", xrApplyForceFeedbackCurlMNDX}, + {"xrApplyHapticFeedback", xrApplyHapticFeedback}, + {"xrAttachSessionActionSets", xrAttachSessionActionSets}, + {"xrBeginFrame", xrBeginFrame}, + {"xrBeginPlaneDetectionEXT", xrBeginPlaneDetectionEXT}, + {"xrBeginSession", xrBeginSession}, + {"xrCancelFutureEXT", xrCancelFutureEXT}, + {"xrChangeVirtualKeyboardTextContextMETA", xrChangeVirtualKeyboardTextContextMETA}, + {"xrClearSpatialAnchorStoreMSFT", xrClearSpatialAnchorStoreMSFT}, + {"xrComputeNewSceneMSFT", xrComputeNewSceneMSFT}, + {"xrConvertTimeToWin32PerformanceCounterKHR", xrConvertTimeToWin32PerformanceCounterKHR}, + {"xrConvertWin32PerformanceCounterToTimeKHR", xrConvertWin32PerformanceCounterToTimeKHR}, + {"xrCreateAction", xrCreateAction}, + {"xrCreateActionSet", xrCreateActionSet}, + {"xrCreateActionSpace", xrCreateActionSpace}, + {"xrCreateApiLayerInstance", xrCreateApiLayerInstance}, + {"xrCreateBodyTrackerFB", xrCreateBodyTrackerFB}, + {"xrCreateEnvironmentDepthProviderMETA", xrCreateEnvironmentDepthProviderMETA}, + {"xrCreateEnvironmentDepthSwapchainMETA", xrCreateEnvironmentDepthSwapchainMETA}, + {"xrCreateExportedLocalizationMapML", xrCreateExportedLocalizationMapML}, + {"xrCreateEyeTrackerFB", xrCreateEyeTrackerFB}, + {"xrCreateFaceTracker2FB", xrCreateFaceTracker2FB}, + {"xrCreateFaceTrackerFB", xrCreateFaceTrackerFB}, + {"xrCreateFacialTrackerHTC", xrCreateFacialTrackerHTC}, + {"xrCreateFoveationProfileFB", xrCreateFoveationProfileFB}, + {"xrCreateGeometryInstanceFB", xrCreateGeometryInstanceFB}, + {"xrCreateHandMeshSpaceMSFT", xrCreateHandMeshSpaceMSFT}, + {"xrCreateHandTrackerEXT", xrCreateHandTrackerEXT}, + {"xrCreateInstance", xrCreateInstance}, + {"xrCreateKeyboardSpaceFB", xrCreateKeyboardSpaceFB}, + {"xrCreateMarkerDetectorML", xrCreateMarkerDetectorML}, + {"xrCreateMarkerSpaceML", xrCreateMarkerSpaceML}, + {"xrCreateMarkerSpaceVARJO", xrCreateMarkerSpaceVARJO}, + {"xrCreatePassthroughColorLutMETA", xrCreatePassthroughColorLutMETA}, + {"xrCreatePassthroughFB", xrCreatePassthroughFB}, + {"xrCreatePassthroughHTC", xrCreatePassthroughHTC}, + {"xrCreatePassthroughLayerFB", xrCreatePassthroughLayerFB}, + {"xrCreatePlaneDetectorEXT", xrCreatePlaneDetectorEXT}, + {"xrCreateReferenceSpace", xrCreateReferenceSpace}, + {"xrCreateSceneMSFT", xrCreateSceneMSFT}, + {"xrCreateSceneObserverMSFT", xrCreateSceneObserverMSFT}, + {"xrCreateSession", xrCreateSession}, + {"xrCreateSpaceUserFB", xrCreateSpaceUserFB}, + {"xrCreateSpatialAnchorFB", xrCreateSpatialAnchorFB}, + {"xrCreateSpatialAnchorFromPersistedNameMSFT", xrCreateSpatialAnchorFromPersistedNameMSFT}, + {"xrCreateSpatialAnchorHTC", xrCreateSpatialAnchorHTC}, + {"xrCreateSpatialAnchorMSFT", xrCreateSpatialAnchorMSFT}, + {"xrCreateSpatialAnchorSpaceMSFT", xrCreateSpatialAnchorSpaceMSFT}, + {"xrCreateSpatialAnchorStoreConnectionMSFT", xrCreateSpatialAnchorStoreConnectionMSFT}, + {"xrCreateSpatialGraphNodeSpaceMSFT", xrCreateSpatialGraphNodeSpaceMSFT}, + {"xrCreateSwapchain", xrCreateSwapchain}, + {"xrCreateTriangleMeshFB", xrCreateTriangleMeshFB}, + {"xrCreateVirtualKeyboardMETA", xrCreateVirtualKeyboardMETA}, + {"xrCreateVirtualKeyboardSpaceMETA", xrCreateVirtualKeyboardSpaceMETA}, + {"xrCreateVulkanDeviceKHR", xrCreateVulkanDeviceKHR}, + {"xrCreateVulkanInstanceKHR", xrCreateVulkanInstanceKHR}, + {"xrDeserializeSceneMSFT", xrDeserializeSceneMSFT}, + {"xrDestroyAction", xrDestroyAction}, + {"xrDestroyActionSet", xrDestroyActionSet}, + {"xrDestroyBodyTrackerFB", xrDestroyBodyTrackerFB}, + {"xrDestroyEnvironmentDepthProviderMETA", xrDestroyEnvironmentDepthProviderMETA}, + {"xrDestroyEnvironmentDepthSwapchainMETA", xrDestroyEnvironmentDepthSwapchainMETA}, + {"xrDestroyExportedLocalizationMapML", xrDestroyExportedLocalizationMapML}, + {"xrDestroyEyeTrackerFB", xrDestroyEyeTrackerFB}, + {"xrDestroyFaceTracker2FB", xrDestroyFaceTracker2FB}, + {"xrDestroyFaceTrackerFB", xrDestroyFaceTrackerFB}, + {"xrDestroyFacialTrackerHTC", xrDestroyFacialTrackerHTC}, + {"xrDestroyFoveationProfileFB", xrDestroyFoveationProfileFB}, + {"xrDestroyGeometryInstanceFB", xrDestroyGeometryInstanceFB}, + {"xrDestroyHandTrackerEXT", xrDestroyHandTrackerEXT}, + {"xrDestroyInstance", xrDestroyInstance}, + {"xrDestroyMarkerDetectorML", xrDestroyMarkerDetectorML}, + {"xrDestroyPassthroughColorLutMETA", xrDestroyPassthroughColorLutMETA}, + {"xrDestroyPassthroughFB", xrDestroyPassthroughFB}, + {"xrDestroyPassthroughHTC", xrDestroyPassthroughHTC}, + {"xrDestroyPassthroughLayerFB", xrDestroyPassthroughLayerFB}, + {"xrDestroyPlaneDetectorEXT", xrDestroyPlaneDetectorEXT}, + {"xrDestroySceneMSFT", xrDestroySceneMSFT}, + {"xrDestroySceneObserverMSFT", xrDestroySceneObserverMSFT}, + {"xrDestroySession", xrDestroySession}, + {"xrDestroySpace", xrDestroySpace}, + {"xrDestroySpaceUserFB", xrDestroySpaceUserFB}, + {"xrDestroySpatialAnchorMSFT", xrDestroySpatialAnchorMSFT}, + {"xrDestroySpatialAnchorStoreConnectionMSFT", xrDestroySpatialAnchorStoreConnectionMSFT}, + {"xrDestroySpatialGraphNodeBindingMSFT", xrDestroySpatialGraphNodeBindingMSFT}, + {"xrDestroySwapchain", xrDestroySwapchain}, + {"xrDestroyTriangleMeshFB", xrDestroyTriangleMeshFB}, + {"xrDestroyVirtualKeyboardMETA", xrDestroyVirtualKeyboardMETA}, + {"xrEnableLocalizationEventsML", xrEnableLocalizationEventsML}, + {"xrEnableUserCalibrationEventsML", xrEnableUserCalibrationEventsML}, + {"xrEndFrame", xrEndFrame}, + {"xrEndSession", xrEndSession}, + {"xrEnumerateApiLayerProperties", xrEnumerateApiLayerProperties}, + {"xrEnumerateBoundSourcesForAction", xrEnumerateBoundSourcesForAction}, + {"xrEnumerateColorSpacesFB", xrEnumerateColorSpacesFB}, + {"xrEnumerateDisplayRefreshRatesFB", xrEnumerateDisplayRefreshRatesFB}, + {"xrEnumerateEnvironmentBlendModes", xrEnumerateEnvironmentBlendModes}, + {"xrEnumerateEnvironmentDepthSwapchainImagesMETA", xrEnumerateEnvironmentDepthSwapchainImagesMETA}, + {"xrEnumerateExternalCamerasOCULUS", xrEnumerateExternalCamerasOCULUS}, + {"xrEnumerateInstanceExtensionProperties", xrEnumerateInstanceExtensionProperties}, + {"xrEnumeratePerformanceMetricsCounterPathsMETA", xrEnumeratePerformanceMetricsCounterPathsMETA}, + {"xrEnumeratePersistedSpatialAnchorNamesMSFT", xrEnumeratePersistedSpatialAnchorNamesMSFT}, + {"xrEnumerateReferenceSpaces", xrEnumerateReferenceSpaces}, + {"xrEnumerateRenderModelPathsFB", xrEnumerateRenderModelPathsFB}, + {"xrEnumerateReprojectionModesMSFT", xrEnumerateReprojectionModesMSFT}, + {"xrEnumerateSceneComputeFeaturesMSFT", xrEnumerateSceneComputeFeaturesMSFT}, + {"xrEnumerateSpaceSupportedComponentsFB", xrEnumerateSpaceSupportedComponentsFB}, + {"xrEnumerateSwapchainFormats", xrEnumerateSwapchainFormats}, + {"xrEnumerateSwapchainImages", xrEnumerateSwapchainImages}, + {"xrEnumerateViewConfigurationViews", xrEnumerateViewConfigurationViews}, + {"xrEnumerateViewConfigurations", xrEnumerateViewConfigurations}, + {"xrEnumerateViveTrackerPathsHTCX", xrEnumerateViveTrackerPathsHTCX}, + {"xrEraseSpaceFB", xrEraseSpaceFB}, + {"xrGeometryInstanceSetTransformFB", xrGeometryInstanceSetTransformFB}, + {"xrGetActionStateBoolean", xrGetActionStateBoolean}, + {"xrGetActionStateFloat", xrGetActionStateFloat}, + {"xrGetActionStatePose", xrGetActionStatePose}, + {"xrGetActionStateVector2f", xrGetActionStateVector2f}, + {"xrGetAudioInputDeviceGuidOculus", xrGetAudioInputDeviceGuidOculus}, + {"xrGetAudioOutputDeviceGuidOculus", xrGetAudioOutputDeviceGuidOculus}, + {"xrGetBodySkeletonFB", xrGetBodySkeletonFB}, + {"xrGetControllerModelKeyMSFT", xrGetControllerModelKeyMSFT}, + {"xrGetControllerModelPropertiesMSFT", xrGetControllerModelPropertiesMSFT}, + {"xrGetControllerModelStateMSFT", xrGetControllerModelStateMSFT}, + {"xrGetCurrentInteractionProfile", xrGetCurrentInteractionProfile}, + {"xrGetD3D11GraphicsRequirementsKHR", xrGetD3D11GraphicsRequirementsKHR}, + {"xrGetD3D12GraphicsRequirementsKHR", xrGetD3D12GraphicsRequirementsKHR}, + {"xrGetDeviceSampleRateFB", xrGetDeviceSampleRateFB}, + {"xrGetDisplayRefreshRateFB", xrGetDisplayRefreshRateFB}, + {"xrGetEnvironmentDepthSwapchainStateMETA", xrGetEnvironmentDepthSwapchainStateMETA}, + {"xrGetExportedLocalizationMapDataML", xrGetExportedLocalizationMapDataML}, + {"xrGetEyeGazesFB", xrGetEyeGazesFB}, + {"xrGetFaceExpressionWeights2FB", xrGetFaceExpressionWeights2FB}, + {"xrGetFaceExpressionWeightsFB", xrGetFaceExpressionWeightsFB}, + {"xrGetFacialExpressionsHTC", xrGetFacialExpressionsHTC}, + {"xrGetFoveationEyeTrackedStateMETA", xrGetFoveationEyeTrackedStateMETA}, + {"xrGetHandMeshFB", xrGetHandMeshFB}, + {"xrGetInputSourceLocalizedName", xrGetInputSourceLocalizedName}, + {"xrGetInstanceProcAddr", xrGetInstanceProcAddr}, + {"xrGetInstanceProperties", xrGetInstanceProperties}, + {"xrGetMarkerDetectorStateML", xrGetMarkerDetectorStateML}, + {"xrGetMarkerLengthML", xrGetMarkerLengthML}, + {"xrGetMarkerNumberML", xrGetMarkerNumberML}, + {"xrGetMarkerReprojectionErrorML", xrGetMarkerReprojectionErrorML}, + {"xrGetMarkerSizeVARJO", xrGetMarkerSizeVARJO}, + {"xrGetMarkerStringML", xrGetMarkerStringML}, + {"xrGetMarkersML", xrGetMarkersML}, + {"xrGetOpenGLGraphicsRequirementsKHR", xrGetOpenGLGraphicsRequirementsKHR}, + {"xrGetPassthroughPreferencesMETA", xrGetPassthroughPreferencesMETA}, + {"xrGetPerformanceMetricsStateMETA", xrGetPerformanceMetricsStateMETA}, + {"xrGetPlaneDetectionStateEXT", xrGetPlaneDetectionStateEXT}, + {"xrGetPlaneDetectionsEXT", xrGetPlaneDetectionsEXT}, + {"xrGetPlanePolygonBufferEXT", xrGetPlanePolygonBufferEXT}, + {"xrGetRecommendedLayerResolutionMETA", xrGetRecommendedLayerResolutionMETA}, + {"xrGetReferenceSpaceBoundsRect", xrGetReferenceSpaceBoundsRect}, + {"xrGetRenderModelPropertiesFB", xrGetRenderModelPropertiesFB}, + {"xrGetSceneComponentsMSFT", xrGetSceneComponentsMSFT}, + {"xrGetSceneComputeStateMSFT", xrGetSceneComputeStateMSFT}, + {"xrGetSceneMarkerDecodedStringMSFT", xrGetSceneMarkerDecodedStringMSFT}, + {"xrGetSceneMarkerRawDataMSFT", xrGetSceneMarkerRawDataMSFT}, + {"xrGetSceneMeshBuffersMSFT", xrGetSceneMeshBuffersMSFT}, + {"xrGetSerializedSceneFragmentDataMSFT", xrGetSerializedSceneFragmentDataMSFT}, + {"xrGetSpaceBoundary2DFB", xrGetSpaceBoundary2DFB}, + {"xrGetSpaceBoundingBox2DFB", xrGetSpaceBoundingBox2DFB}, + {"xrGetSpaceBoundingBox3DFB", xrGetSpaceBoundingBox3DFB}, + {"xrGetSpaceComponentStatusFB", xrGetSpaceComponentStatusFB}, + {"xrGetSpaceContainerFB", xrGetSpaceContainerFB}, + {"xrGetSpaceRoomLayoutFB", xrGetSpaceRoomLayoutFB}, + {"xrGetSpaceSemanticLabelsFB", xrGetSpaceSemanticLabelsFB}, + {"xrGetSpaceTriangleMeshMETA", xrGetSpaceTriangleMeshMETA}, + {"xrGetSpaceUserIdFB", xrGetSpaceUserIdFB}, + {"xrGetSpaceUuidFB", xrGetSpaceUuidFB}, + {"xrGetSpatialAnchorNameHTC", xrGetSpatialAnchorNameHTC}, + {"xrGetSpatialGraphNodeBindingPropertiesMSFT", xrGetSpatialGraphNodeBindingPropertiesMSFT}, + {"xrGetSwapchainStateFB", xrGetSwapchainStateFB}, + {"xrGetSystem", xrGetSystem}, + {"xrGetSystemProperties", xrGetSystemProperties}, + {"xrGetViewConfigurationProperties", xrGetViewConfigurationProperties}, + {"xrGetVirtualKeyboardDirtyTexturesMETA", xrGetVirtualKeyboardDirtyTexturesMETA}, + {"xrGetVirtualKeyboardModelAnimationStatesMETA", xrGetVirtualKeyboardModelAnimationStatesMETA}, + {"xrGetVirtualKeyboardScaleMETA", xrGetVirtualKeyboardScaleMETA}, + {"xrGetVirtualKeyboardTextureDataMETA", xrGetVirtualKeyboardTextureDataMETA}, + {"xrGetVisibilityMaskKHR", xrGetVisibilityMaskKHR}, + {"xrGetVulkanDeviceExtensionsKHR", xrGetVulkanDeviceExtensionsKHR}, + {"xrGetVulkanGraphicsDevice2KHR", xrGetVulkanGraphicsDevice2KHR}, + {"xrGetVulkanGraphicsDeviceKHR", xrGetVulkanGraphicsDeviceKHR}, + {"xrGetVulkanGraphicsRequirements2KHR", xrGetVulkanGraphicsRequirements2KHR}, + {"xrGetVulkanGraphicsRequirementsKHR", xrGetVulkanGraphicsRequirementsKHR}, + {"xrGetVulkanInstanceExtensionsKHR", xrGetVulkanInstanceExtensionsKHR}, + {"xrImportLocalizationMapML", xrImportLocalizationMapML}, + {"xrLoadControllerModelMSFT", xrLoadControllerModelMSFT}, + {"xrLoadRenderModelFB", xrLoadRenderModelFB}, + {"xrLocateBodyJointsFB", xrLocateBodyJointsFB}, + {"xrLocateHandJointsEXT", xrLocateHandJointsEXT}, + {"xrLocateSceneComponentsMSFT", xrLocateSceneComponentsMSFT}, + {"xrLocateSpace", xrLocateSpace}, + {"xrLocateSpaces", xrLocateSpaces}, + {"xrLocateSpacesKHR", xrLocateSpacesKHR}, + {"xrLocateViews", xrLocateViews}, + {"xrNegotiateLoaderRuntimeInterface", xrNegotiateLoaderRuntimeInterface}, + {"xrPassthroughLayerPauseFB", xrPassthroughLayerPauseFB}, + {"xrPassthroughLayerResumeFB", xrPassthroughLayerResumeFB}, + {"xrPassthroughLayerSetKeyboardHandsIntensityFB", xrPassthroughLayerSetKeyboardHandsIntensityFB}, + {"xrPassthroughLayerSetStyleFB", xrPassthroughLayerSetStyleFB}, + {"xrPassthroughPauseFB", xrPassthroughPauseFB}, + {"xrPassthroughStartFB", xrPassthroughStartFB}, + {"xrPathToString", xrPathToString}, + {"xrPerfSettingsSetPerformanceLevelEXT", xrPerfSettingsSetPerformanceLevelEXT}, + {"xrPersistSpatialAnchorMSFT", xrPersistSpatialAnchorMSFT}, + {"xrPollEvent", xrPollEvent}, + {"xrPollFutureEXT", xrPollFutureEXT}, + {"xrQueryLocalizationMapsML", xrQueryLocalizationMapsML}, + {"xrQueryPerformanceMetricsCounterMETA", xrQueryPerformanceMetricsCounterMETA}, + {"xrQuerySpacesFB", xrQuerySpacesFB}, + {"xrQuerySystemTrackedKeyboardFB", xrQuerySystemTrackedKeyboardFB}, + {"xrReleaseSwapchainImage", xrReleaseSwapchainImage}, + {"xrRequestDisplayRefreshRateFB", xrRequestDisplayRefreshRateFB}, + {"xrRequestExitSession", xrRequestExitSession}, + {"xrRequestMapLocalizationML", xrRequestMapLocalizationML}, + {"xrRequestSceneCaptureFB", xrRequestSceneCaptureFB}, + {"xrResultToString", xrResultToString}, + {"xrRetrieveSpaceQueryResultsFB", xrRetrieveSpaceQueryResultsFB}, + {"xrSaveSpaceFB", xrSaveSpaceFB}, + {"xrSaveSpaceListFB", xrSaveSpaceListFB}, + {"xrSendVirtualKeyboardInputMETA", xrSendVirtualKeyboardInputMETA}, + {"xrSetColorSpaceFB", xrSetColorSpaceFB}, + {"xrSetDigitalLensControlALMALENCE", xrSetDigitalLensControlALMALENCE}, + {"xrSetEnvironmentDepthEstimationVARJO", xrSetEnvironmentDepthEstimationVARJO}, + {"xrSetEnvironmentDepthHandRemovalMETA", xrSetEnvironmentDepthHandRemovalMETA}, + {"xrSetInputDeviceActiveEXT", xrSetInputDeviceActiveEXT}, + {"xrSetInputDeviceLocationEXT", xrSetInputDeviceLocationEXT}, + {"xrSetInputDeviceStateBoolEXT", xrSetInputDeviceStateBoolEXT}, + {"xrSetInputDeviceStateFloatEXT", xrSetInputDeviceStateFloatEXT}, + {"xrSetInputDeviceStateVector2fEXT", xrSetInputDeviceStateVector2fEXT}, + {"xrSetMarkerTrackingPredictionVARJO", xrSetMarkerTrackingPredictionVARJO}, + {"xrSetMarkerTrackingTimeoutVARJO", xrSetMarkerTrackingTimeoutVARJO}, + {"xrSetMarkerTrackingVARJO", xrSetMarkerTrackingVARJO}, + {"xrSetPerformanceMetricsStateMETA", xrSetPerformanceMetricsStateMETA}, + {"xrSetSpaceComponentStatusFB", xrSetSpaceComponentStatusFB}, + {"xrSetTrackingOptimizationSettingsHintQCOM", xrSetTrackingOptimizationSettingsHintQCOM}, + {"xrSetViewOffsetVARJO", xrSetViewOffsetVARJO}, + {"xrSetVirtualKeyboardModelVisibilityMETA", xrSetVirtualKeyboardModelVisibilityMETA}, + {"xrShareSpacesFB", xrShareSpacesFB}, + {"xrSnapshotMarkerDetectorML", xrSnapshotMarkerDetectorML}, + {"xrStartEnvironmentDepthProviderMETA", xrStartEnvironmentDepthProviderMETA}, + {"xrStopEnvironmentDepthProviderMETA", xrStopEnvironmentDepthProviderMETA}, + {"xrStopHapticFeedback", xrStopHapticFeedback}, + {"xrStringToPath", xrStringToPath}, + {"xrStructureTypeToString", xrStructureTypeToString}, + {"xrSuggestInteractionProfileBindings", xrSuggestInteractionProfileBindings}, + {"xrSuggestVirtualKeyboardLocationMETA", xrSuggestVirtualKeyboardLocationMETA}, + {"xrSyncActions", xrSyncActions}, + {"xrThermalGetTemperatureTrendEXT", xrThermalGetTemperatureTrendEXT}, + {"xrTriangleMeshBeginUpdateFB", xrTriangleMeshBeginUpdateFB}, + {"xrTriangleMeshBeginVertexBufferUpdateFB", xrTriangleMeshBeginVertexBufferUpdateFB}, + {"xrTriangleMeshEndUpdateFB", xrTriangleMeshEndUpdateFB}, + {"xrTriangleMeshEndVertexBufferUpdateFB", xrTriangleMeshEndVertexBufferUpdateFB}, + {"xrTriangleMeshGetIndexBufferFB", xrTriangleMeshGetIndexBufferFB}, + {"xrTriangleMeshGetVertexBufferFB", xrTriangleMeshGetVertexBufferFB}, + {"xrTryCreateSpatialGraphStaticNodeBindingMSFT", xrTryCreateSpatialGraphStaticNodeBindingMSFT}, + {"xrUnpersistSpatialAnchorMSFT", xrUnpersistSpatialAnchorMSFT}, + {"xrUpdateHandMeshMSFT", xrUpdateHandMeshMSFT}, + {"xrUpdatePassthroughColorLutMETA", xrUpdatePassthroughColorLutMETA}, + {"xrUpdateSwapchainFB", xrUpdateSwapchainFB}, + {"xrWaitFrame", xrWaitFrame}, + {"xrWaitSwapchainImage", xrWaitSwapchainImage}, +}; + +void *wine_xr_get_instance_proc_addr(const char *name) +{ + unsigned int i; + for (i = 0; i < ARRAY_SIZE(xr_instance_dispatch_table); i++) + { + if (strcmp(xr_instance_dispatch_table[i].name, name) == 0) + { + TRACE("Found name=%s in instance table\n", debugstr_a(name)); + return xr_instance_dispatch_table[i].func; + } + } + return NULL; +} diff --git a/wineopenxr/loader_thunks.h b/wineopenxr/loader_thunks.h new file mode 100644 index 00000000..d6a1b6ae --- /dev/null +++ b/wineopenxr/loader_thunks.h @@ -0,0 +1,2285 @@ +/* Automatically generated from Vulkan xr.xml; DO NOT EDIT! + * + * 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. + * + * 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 default branch of the Khronos OpenXR GitHub project. + * + */ + +#ifndef __WINE_OPENXR_LOADER_THUNKS_H +#define __WINE_OPENXR_LOADER_THUNKS_H + +enum unix_call +{ + unix_init, + unix_xrAcquireEnvironmentDepthImageMETA, + unix_xrAcquireSwapchainImage, + unix_xrApplyForceFeedbackCurlMNDX, + unix_xrApplyHapticFeedback, + unix_xrAttachSessionActionSets, + unix_xrBeginFrame, + unix_xrBeginPlaneDetectionEXT, + unix_xrBeginSession, + unix_xrCancelFutureEXT, + unix_xrChangeVirtualKeyboardTextContextMETA, + unix_xrClearSpatialAnchorStoreMSFT, + unix_xrComputeNewSceneMSFT, + unix_xrCreateAction, + unix_xrCreateActionSet, + unix_xrCreateActionSpace, + unix_xrCreateBodyTrackerFB, + unix_xrCreateEnvironmentDepthProviderMETA, + unix_xrCreateEnvironmentDepthSwapchainMETA, + unix_xrCreateExportedLocalizationMapML, + unix_xrCreateEyeTrackerFB, + unix_xrCreateFaceTracker2FB, + unix_xrCreateFaceTrackerFB, + unix_xrCreateFacialTrackerHTC, + unix_xrCreateFoveationProfileFB, + unix_xrCreateGeometryInstanceFB, + unix_xrCreateHandMeshSpaceMSFT, + unix_xrCreateHandTrackerEXT, + unix_xrCreateInstance, + unix_xrCreateKeyboardSpaceFB, + unix_xrCreateMarkerDetectorML, + unix_xrCreateMarkerSpaceML, + unix_xrCreateMarkerSpaceVARJO, + unix_xrCreatePassthroughColorLutMETA, + unix_xrCreatePassthroughFB, + unix_xrCreatePassthroughHTC, + unix_xrCreatePassthroughLayerFB, + unix_xrCreatePlaneDetectorEXT, + unix_xrCreateReferenceSpace, + unix_xrCreateSceneMSFT, + unix_xrCreateSceneObserverMSFT, + unix_xrCreateSession, + unix_xrCreateSpaceUserFB, + unix_xrCreateSpatialAnchorFB, + unix_xrCreateSpatialAnchorFromPersistedNameMSFT, + unix_xrCreateSpatialAnchorHTC, + unix_xrCreateSpatialAnchorMSFT, + unix_xrCreateSpatialAnchorSpaceMSFT, + unix_xrCreateSpatialAnchorStoreConnectionMSFT, + unix_xrCreateSpatialGraphNodeSpaceMSFT, + unix_xrCreateSwapchain, + unix_xrCreateTriangleMeshFB, + unix_xrCreateVirtualKeyboardMETA, + unix_xrCreateVirtualKeyboardSpaceMETA, + unix_xrDeserializeSceneMSFT, + unix_xrDestroyAction, + unix_xrDestroyActionSet, + unix_xrDestroyBodyTrackerFB, + unix_xrDestroyEnvironmentDepthProviderMETA, + unix_xrDestroyEnvironmentDepthSwapchainMETA, + unix_xrDestroyExportedLocalizationMapML, + unix_xrDestroyEyeTrackerFB, + unix_xrDestroyFaceTracker2FB, + unix_xrDestroyFaceTrackerFB, + unix_xrDestroyFacialTrackerHTC, + unix_xrDestroyFoveationProfileFB, + unix_xrDestroyGeometryInstanceFB, + unix_xrDestroyHandTrackerEXT, + unix_xrDestroyInstance, + unix_xrDestroyMarkerDetectorML, + unix_xrDestroyPassthroughColorLutMETA, + unix_xrDestroyPassthroughFB, + unix_xrDestroyPassthroughHTC, + unix_xrDestroyPassthroughLayerFB, + unix_xrDestroyPlaneDetectorEXT, + unix_xrDestroySceneMSFT, + unix_xrDestroySceneObserverMSFT, + unix_xrDestroySession, + unix_xrDestroySpace, + unix_xrDestroySpaceUserFB, + unix_xrDestroySpatialAnchorMSFT, + unix_xrDestroySpatialAnchorStoreConnectionMSFT, + unix_xrDestroySpatialGraphNodeBindingMSFT, + unix_xrDestroySwapchain, + unix_xrDestroyTriangleMeshFB, + unix_xrDestroyVirtualKeyboardMETA, + unix_xrEnableLocalizationEventsML, + unix_xrEnableUserCalibrationEventsML, + unix_xrEndFrame, + unix_xrEndSession, + unix_xrEnumerateApiLayerProperties, + unix_xrEnumerateBoundSourcesForAction, + unix_xrEnumerateColorSpacesFB, + unix_xrEnumerateDisplayRefreshRatesFB, + unix_xrEnumerateEnvironmentBlendModes, + unix_xrEnumerateEnvironmentDepthSwapchainImagesMETA, + unix_xrEnumerateExternalCamerasOCULUS, + unix_xrEnumerateInstanceExtensionProperties, + unix_xrEnumeratePerformanceMetricsCounterPathsMETA, + unix_xrEnumeratePersistedSpatialAnchorNamesMSFT, + unix_xrEnumerateReferenceSpaces, + unix_xrEnumerateRenderModelPathsFB, + unix_xrEnumerateReprojectionModesMSFT, + unix_xrEnumerateSceneComputeFeaturesMSFT, + unix_xrEnumerateSpaceSupportedComponentsFB, + unix_xrEnumerateSwapchainFormats, + unix_xrEnumerateSwapchainImages, + unix_xrEnumerateViewConfigurationViews, + unix_xrEnumerateViewConfigurations, + unix_xrEnumerateViveTrackerPathsHTCX, + unix_xrEraseSpaceFB, + unix_xrGeometryInstanceSetTransformFB, + unix_xrGetActionStateBoolean, + unix_xrGetActionStateFloat, + unix_xrGetActionStatePose, + unix_xrGetActionStateVector2f, + unix_xrGetAudioInputDeviceGuidOculus, + unix_xrGetAudioOutputDeviceGuidOculus, + unix_xrGetBodySkeletonFB, + unix_xrGetControllerModelKeyMSFT, + unix_xrGetControllerModelPropertiesMSFT, + unix_xrGetControllerModelStateMSFT, + unix_xrGetCurrentInteractionProfile, + unix_xrGetDeviceSampleRateFB, + unix_xrGetDisplayRefreshRateFB, + unix_xrGetEnvironmentDepthSwapchainStateMETA, + unix_xrGetExportedLocalizationMapDataML, + unix_xrGetEyeGazesFB, + unix_xrGetFaceExpressionWeights2FB, + unix_xrGetFaceExpressionWeightsFB, + unix_xrGetFacialExpressionsHTC, + unix_xrGetFoveationEyeTrackedStateMETA, + unix_xrGetHandMeshFB, + unix_xrGetInputSourceLocalizedName, + unix_xrGetInstanceProperties, + unix_xrGetMarkerDetectorStateML, + unix_xrGetMarkerLengthML, + unix_xrGetMarkerNumberML, + unix_xrGetMarkerReprojectionErrorML, + unix_xrGetMarkerSizeVARJO, + unix_xrGetMarkerStringML, + unix_xrGetMarkersML, + unix_xrGetOpenGLGraphicsRequirementsKHR, + unix_xrGetPassthroughPreferencesMETA, + unix_xrGetPerformanceMetricsStateMETA, + unix_xrGetPlaneDetectionStateEXT, + unix_xrGetPlaneDetectionsEXT, + unix_xrGetPlanePolygonBufferEXT, + unix_xrGetRecommendedLayerResolutionMETA, + unix_xrGetReferenceSpaceBoundsRect, + unix_xrGetRenderModelPropertiesFB, + unix_xrGetSceneComponentsMSFT, + unix_xrGetSceneComputeStateMSFT, + unix_xrGetSceneMarkerDecodedStringMSFT, + unix_xrGetSceneMarkerRawDataMSFT, + unix_xrGetSceneMeshBuffersMSFT, + unix_xrGetSerializedSceneFragmentDataMSFT, + unix_xrGetSpaceBoundary2DFB, + unix_xrGetSpaceBoundingBox2DFB, + unix_xrGetSpaceBoundingBox3DFB, + unix_xrGetSpaceComponentStatusFB, + unix_xrGetSpaceContainerFB, + unix_xrGetSpaceRoomLayoutFB, + unix_xrGetSpaceSemanticLabelsFB, + unix_xrGetSpaceTriangleMeshMETA, + unix_xrGetSpaceUserIdFB, + unix_xrGetSpaceUuidFB, + unix_xrGetSpatialAnchorNameHTC, + unix_xrGetSpatialGraphNodeBindingPropertiesMSFT, + unix_xrGetSwapchainStateFB, + unix_xrGetSystem, + unix_xrGetSystemProperties, + unix_xrGetViewConfigurationProperties, + unix_xrGetVirtualKeyboardDirtyTexturesMETA, + unix_xrGetVirtualKeyboardModelAnimationStatesMETA, + unix_xrGetVirtualKeyboardScaleMETA, + unix_xrGetVirtualKeyboardTextureDataMETA, + unix_xrGetVisibilityMaskKHR, + unix_xrGetVulkanDeviceExtensionsKHR, + unix_xrGetVulkanGraphicsDevice2KHR, + unix_xrGetVulkanGraphicsDeviceKHR, + unix_xrGetVulkanGraphicsRequirements2KHR, + unix_xrGetVulkanGraphicsRequirementsKHR, + unix_xrGetVulkanInstanceExtensionsKHR, + unix_xrImportLocalizationMapML, + unix_xrLoadControllerModelMSFT, + unix_xrLoadRenderModelFB, + unix_xrLocateBodyJointsFB, + unix_xrLocateHandJointsEXT, + unix_xrLocateSceneComponentsMSFT, + unix_xrLocateSpace, + unix_xrLocateSpaces, + unix_xrLocateSpacesKHR, + unix_xrLocateViews, + unix_xrPassthroughLayerPauseFB, + unix_xrPassthroughLayerResumeFB, + unix_xrPassthroughLayerSetKeyboardHandsIntensityFB, + unix_xrPassthroughLayerSetStyleFB, + unix_xrPassthroughPauseFB, + unix_xrPassthroughStartFB, + unix_xrPathToString, + unix_xrPerfSettingsSetPerformanceLevelEXT, + unix_xrPersistSpatialAnchorMSFT, + unix_xrPollEvent, + unix_xrPollFutureEXT, + unix_xrQueryLocalizationMapsML, + unix_xrQueryPerformanceMetricsCounterMETA, + unix_xrQuerySpacesFB, + unix_xrQuerySystemTrackedKeyboardFB, + unix_xrReleaseSwapchainImage, + unix_xrRequestDisplayRefreshRateFB, + unix_xrRequestExitSession, + unix_xrRequestMapLocalizationML, + unix_xrRequestSceneCaptureFB, + unix_xrResultToString, + unix_xrRetrieveSpaceQueryResultsFB, + unix_xrSaveSpaceFB, + unix_xrSaveSpaceListFB, + unix_xrSendVirtualKeyboardInputMETA, + unix_xrSetColorSpaceFB, + unix_xrSetDigitalLensControlALMALENCE, + unix_xrSetEnvironmentDepthEstimationVARJO, + unix_xrSetEnvironmentDepthHandRemovalMETA, + unix_xrSetInputDeviceActiveEXT, + unix_xrSetInputDeviceLocationEXT, + unix_xrSetInputDeviceStateBoolEXT, + unix_xrSetInputDeviceStateFloatEXT, + unix_xrSetInputDeviceStateVector2fEXT, + unix_xrSetMarkerTrackingPredictionVARJO, + unix_xrSetMarkerTrackingTimeoutVARJO, + unix_xrSetMarkerTrackingVARJO, + unix_xrSetPerformanceMetricsStateMETA, + unix_xrSetSpaceComponentStatusFB, + unix_xrSetTrackingOptimizationSettingsHintQCOM, + unix_xrSetViewOffsetVARJO, + unix_xrSetVirtualKeyboardModelVisibilityMETA, + unix_xrShareSpacesFB, + unix_xrSnapshotMarkerDetectorML, + unix_xrStartEnvironmentDepthProviderMETA, + unix_xrStopEnvironmentDepthProviderMETA, + unix_xrStopHapticFeedback, + unix_xrStringToPath, + unix_xrStructureTypeToString, + unix_xrSuggestInteractionProfileBindings, + unix_xrSuggestVirtualKeyboardLocationMETA, + unix_xrSyncActions, + unix_xrThermalGetTemperatureTrendEXT, + unix_xrTriangleMeshBeginUpdateFB, + unix_xrTriangleMeshBeginVertexBufferUpdateFB, + unix_xrTriangleMeshEndUpdateFB, + unix_xrTriangleMeshEndVertexBufferUpdateFB, + unix_xrTriangleMeshGetIndexBufferFB, + unix_xrTriangleMeshGetVertexBufferFB, + unix_xrTryCreateSpatialGraphStaticNodeBindingMSFT, + unix_xrUnpersistSpatialAnchorMSFT, + unix_xrUpdateHandMeshMSFT, + unix_xrUpdatePassthroughColorLutMETA, + unix_xrUpdateSwapchainFB, + unix_xrWaitFrame, + unix_xrWaitSwapchainImage, + unix_count, +}; + +struct xrAcquireEnvironmentDepthImageMETA_params +{ + XrEnvironmentDepthProviderMETA environmentDepthProvider; + const XrEnvironmentDepthImageAcquireInfoMETA *acquireInfo; + XrEnvironmentDepthImageMETA *environmentDepthImage; + XrResult result; +}; + +struct xrAcquireSwapchainImage_params +{ + XrSwapchain swapchain; + const XrSwapchainImageAcquireInfo *acquireInfo; + uint32_t *index; + XrResult result; +}; + +struct xrApplyForceFeedbackCurlMNDX_params +{ + XrHandTrackerEXT handTracker; + const XrForceFeedbackCurlApplyLocationsMNDX *locations; + XrResult result; +}; + +struct xrApplyHapticFeedback_params +{ + XrSession session; + const XrHapticActionInfo *hapticActionInfo; + const XrHapticBaseHeader *hapticFeedback; + XrResult result; +}; + +struct xrAttachSessionActionSets_params +{ + XrSession session; + const XrSessionActionSetsAttachInfo *attachInfo; + XrResult result; +}; + +struct xrBeginFrame_params +{ + XrSession session; + const XrFrameBeginInfo *frameBeginInfo; + XrResult result; +}; + +struct xrBeginPlaneDetectionEXT_params +{ + XrPlaneDetectorEXT planeDetector; + const XrPlaneDetectorBeginInfoEXT *beginInfo; + XrResult result; +}; + +struct xrBeginSession_params +{ + XrSession session; + const XrSessionBeginInfo *beginInfo; + XrResult result; +}; + +struct xrCancelFutureEXT_params +{ + XrInstance instance; + const XrFutureCancelInfoEXT *cancelInfo; + XrResult result; +}; + +struct xrChangeVirtualKeyboardTextContextMETA_params +{ + XrVirtualKeyboardMETA keyboard; + const XrVirtualKeyboardTextContextChangeInfoMETA *changeInfo; + XrResult result; +}; + +struct xrClearSpatialAnchorStoreMSFT_params +{ + XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore; + XrResult result; +}; + +struct xrComputeNewSceneMSFT_params +{ + XrSceneObserverMSFT sceneObserver; + const XrNewSceneComputeInfoMSFT *computeInfo; + XrResult result; +}; + +struct xrCreateAction_params +{ + XrActionSet actionSet; + const XrActionCreateInfo *createInfo; + XrAction *action; + XrResult result; +}; + +struct xrCreateActionSet_params +{ + XrInstance instance; + const XrActionSetCreateInfo *createInfo; + XrActionSet *actionSet; + XrResult result; +}; + +struct xrCreateActionSpace_params +{ + XrSession session; + const XrActionSpaceCreateInfo *createInfo; + XrSpace *space; + XrResult result; +}; + +struct xrCreateBodyTrackerFB_params +{ + XrSession session; + const XrBodyTrackerCreateInfoFB *createInfo; + XrBodyTrackerFB *bodyTracker; + XrResult result; +}; + +struct xrCreateEnvironmentDepthProviderMETA_params +{ + XrSession session; + const XrEnvironmentDepthProviderCreateInfoMETA *createInfo; + XrEnvironmentDepthProviderMETA *environmentDepthProvider; + XrResult result; +}; + +struct xrCreateEnvironmentDepthSwapchainMETA_params +{ + XrEnvironmentDepthProviderMETA environmentDepthProvider; + const XrEnvironmentDepthSwapchainCreateInfoMETA *createInfo; + XrEnvironmentDepthSwapchainMETA *swapchain; + XrResult result; +}; + +struct xrCreateExportedLocalizationMapML_params +{ + XrSession session; + const XrUuidEXT *mapUuid; + XrExportedLocalizationMapML *map; + XrResult result; +}; + +struct xrCreateEyeTrackerFB_params +{ + XrSession session; + const XrEyeTrackerCreateInfoFB *createInfo; + XrEyeTrackerFB *eyeTracker; + XrResult result; +}; + +struct xrCreateFaceTracker2FB_params +{ + XrSession session; + const XrFaceTrackerCreateInfo2FB *createInfo; + XrFaceTracker2FB *faceTracker; + XrResult result; +}; + +struct xrCreateFaceTrackerFB_params +{ + XrSession session; + const XrFaceTrackerCreateInfoFB *createInfo; + XrFaceTrackerFB *faceTracker; + XrResult result; +}; + +struct xrCreateFacialTrackerHTC_params +{ + XrSession session; + const XrFacialTrackerCreateInfoHTC *createInfo; + XrFacialTrackerHTC *facialTracker; + XrResult result; +}; + +struct xrCreateFoveationProfileFB_params +{ + XrSession session; + const XrFoveationProfileCreateInfoFB *createInfo; + XrFoveationProfileFB *profile; + XrResult result; +}; + +struct xrCreateGeometryInstanceFB_params +{ + XrSession session; + const XrGeometryInstanceCreateInfoFB *createInfo; + XrGeometryInstanceFB *outGeometryInstance; + XrResult result; +}; + +struct xrCreateHandMeshSpaceMSFT_params +{ + XrHandTrackerEXT handTracker; + const XrHandMeshSpaceCreateInfoMSFT *createInfo; + XrSpace *space; + XrResult result; +}; + +struct xrCreateHandTrackerEXT_params +{ + XrSession session; + const XrHandTrackerCreateInfoEXT *createInfo; + XrHandTrackerEXT *handTracker; + XrResult result; +}; + +struct xrCreateInstance_params +{ + const XrInstanceCreateInfo *createInfo; + XrInstance *instance; + XrResult result; +}; + +struct xrCreateKeyboardSpaceFB_params +{ + XrSession session; + const XrKeyboardSpaceCreateInfoFB *createInfo; + XrSpace *keyboardSpace; + XrResult result; +}; + +struct xrCreateMarkerDetectorML_params +{ + XrSession session; + const XrMarkerDetectorCreateInfoML *createInfo; + XrMarkerDetectorML *markerDetector; + XrResult result; +}; + +struct xrCreateMarkerSpaceML_params +{ + XrSession session; + const XrMarkerSpaceCreateInfoML *createInfo; + XrSpace *space; + XrResult result; +}; + +struct xrCreateMarkerSpaceVARJO_params +{ + XrSession session; + const XrMarkerSpaceCreateInfoVARJO *createInfo; + XrSpace *space; + XrResult result; +}; + +struct xrCreatePassthroughColorLutMETA_params +{ + XrPassthroughFB passthrough; + const XrPassthroughColorLutCreateInfoMETA *createInfo; + XrPassthroughColorLutMETA *colorLut; + XrResult result; +}; + +struct xrCreatePassthroughFB_params +{ + XrSession session; + const XrPassthroughCreateInfoFB *createInfo; + XrPassthroughFB *outPassthrough; + XrResult result; +}; + +struct xrCreatePassthroughHTC_params +{ + XrSession session; + const XrPassthroughCreateInfoHTC *createInfo; + XrPassthroughHTC *passthrough; + XrResult result; +}; + +struct xrCreatePassthroughLayerFB_params +{ + XrSession session; + const XrPassthroughLayerCreateInfoFB *createInfo; + XrPassthroughLayerFB *outLayer; + XrResult result; +}; + +struct xrCreatePlaneDetectorEXT_params +{ + XrSession session; + const XrPlaneDetectorCreateInfoEXT *createInfo; + XrPlaneDetectorEXT *planeDetector; + XrResult result; +}; + +struct xrCreateReferenceSpace_params +{ + XrSession session; + const XrReferenceSpaceCreateInfo *createInfo; + XrSpace *space; + XrResult result; +}; + +struct xrCreateSceneMSFT_params +{ + XrSceneObserverMSFT sceneObserver; + const XrSceneCreateInfoMSFT *createInfo; + XrSceneMSFT *scene; + XrResult result; +}; + +struct xrCreateSceneObserverMSFT_params +{ + XrSession session; + const XrSceneObserverCreateInfoMSFT *createInfo; + XrSceneObserverMSFT *sceneObserver; + XrResult result; +}; + +struct xrCreateSession_params +{ + XrInstance instance; + const XrSessionCreateInfo *createInfo; + XrSession *session; + XrResult result; +}; + +struct xrCreateSpaceUserFB_params +{ + XrSession session; + const XrSpaceUserCreateInfoFB *info; + XrSpaceUserFB *user; + XrResult result; +}; + +struct xrCreateSpatialAnchorFB_params +{ + XrSession session; + const XrSpatialAnchorCreateInfoFB *info; + XrAsyncRequestIdFB *requestId; + XrResult result; +}; + +struct xrCreateSpatialAnchorFromPersistedNameMSFT_params +{ + XrSession session; + const XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT *spatialAnchorCreateInfo; + XrSpatialAnchorMSFT *spatialAnchor; + XrResult result; +}; + +struct xrCreateSpatialAnchorHTC_params +{ + XrSession session; + const XrSpatialAnchorCreateInfoHTC *createInfo; + XrSpace *anchor; + XrResult result; +}; + +struct xrCreateSpatialAnchorMSFT_params +{ + XrSession session; + const XrSpatialAnchorCreateInfoMSFT *createInfo; + XrSpatialAnchorMSFT *anchor; + XrResult result; +}; + +struct xrCreateSpatialAnchorSpaceMSFT_params +{ + XrSession session; + const XrSpatialAnchorSpaceCreateInfoMSFT *createInfo; + XrSpace *space; + XrResult result; +}; + +struct xrCreateSpatialAnchorStoreConnectionMSFT_params +{ + XrSession session; + XrSpatialAnchorStoreConnectionMSFT *spatialAnchorStore; + XrResult result; +}; + +struct xrCreateSpatialGraphNodeSpaceMSFT_params +{ + XrSession session; + const XrSpatialGraphNodeSpaceCreateInfoMSFT *createInfo; + XrSpace *space; + XrResult result; +}; + +struct xrCreateSwapchain_params +{ + XrSession session; + const XrSwapchainCreateInfo *createInfo; + XrSwapchain *swapchain; + XrResult result; +}; + +struct xrCreateTriangleMeshFB_params +{ + XrSession session; + const XrTriangleMeshCreateInfoFB *createInfo; + XrTriangleMeshFB *outTriangleMesh; + XrResult result; +}; + +struct xrCreateVirtualKeyboardMETA_params +{ + XrSession session; + const XrVirtualKeyboardCreateInfoMETA *createInfo; + XrVirtualKeyboardMETA *keyboard; + XrResult result; +}; + +struct xrCreateVirtualKeyboardSpaceMETA_params +{ + XrSession session; + XrVirtualKeyboardMETA keyboard; + const XrVirtualKeyboardSpaceCreateInfoMETA *createInfo; + XrSpace *keyboardSpace; + XrResult result; +}; + +struct xrDeserializeSceneMSFT_params +{ + XrSceneObserverMSFT sceneObserver; + const XrSceneDeserializeInfoMSFT *deserializeInfo; + XrResult result; +}; + +struct xrDestroyAction_params +{ + XrAction action; + XrResult result; +}; + +struct xrDestroyActionSet_params +{ + XrActionSet actionSet; + XrResult result; +}; + +struct xrDestroyBodyTrackerFB_params +{ + XrBodyTrackerFB bodyTracker; + XrResult result; +}; + +struct xrDestroyEnvironmentDepthProviderMETA_params +{ + XrEnvironmentDepthProviderMETA environmentDepthProvider; + XrResult result; +}; + +struct xrDestroyEnvironmentDepthSwapchainMETA_params +{ + XrEnvironmentDepthSwapchainMETA swapchain; + XrResult result; +}; + +struct xrDestroyExportedLocalizationMapML_params +{ + XrExportedLocalizationMapML map; + XrResult result; +}; + +struct xrDestroyEyeTrackerFB_params +{ + XrEyeTrackerFB eyeTracker; + XrResult result; +}; + +struct xrDestroyFaceTracker2FB_params +{ + XrFaceTracker2FB faceTracker; + XrResult result; +}; + +struct xrDestroyFaceTrackerFB_params +{ + XrFaceTrackerFB faceTracker; + XrResult result; +}; + +struct xrDestroyFacialTrackerHTC_params +{ + XrFacialTrackerHTC facialTracker; + XrResult result; +}; + +struct xrDestroyFoveationProfileFB_params +{ + XrFoveationProfileFB profile; + XrResult result; +}; + +struct xrDestroyGeometryInstanceFB_params +{ + XrGeometryInstanceFB instance; + XrResult result; +}; + +struct xrDestroyHandTrackerEXT_params +{ + XrHandTrackerEXT handTracker; + XrResult result; +}; + +struct xrDestroyInstance_params +{ + XrInstance instance; + XrResult result; +}; + +struct xrDestroyMarkerDetectorML_params +{ + XrMarkerDetectorML markerDetector; + XrResult result; +}; + +struct xrDestroyPassthroughColorLutMETA_params +{ + XrPassthroughColorLutMETA colorLut; + XrResult result; +}; + +struct xrDestroyPassthroughFB_params +{ + XrPassthroughFB passthrough; + XrResult result; +}; + +struct xrDestroyPassthroughHTC_params +{ + XrPassthroughHTC passthrough; + XrResult result; +}; + +struct xrDestroyPassthroughLayerFB_params +{ + XrPassthroughLayerFB layer; + XrResult result; +}; + +struct xrDestroyPlaneDetectorEXT_params +{ + XrPlaneDetectorEXT planeDetector; + XrResult result; +}; + +struct xrDestroySceneMSFT_params +{ + XrSceneMSFT scene; + XrResult result; +}; + +struct xrDestroySceneObserverMSFT_params +{ + XrSceneObserverMSFT sceneObserver; + XrResult result; +}; + +struct xrDestroySession_params +{ + XrSession session; + XrResult result; +}; + +struct xrDestroySpace_params +{ + XrSpace space; + XrResult result; +}; + +struct xrDestroySpaceUserFB_params +{ + XrSpaceUserFB user; + XrResult result; +}; + +struct xrDestroySpatialAnchorMSFT_params +{ + XrSpatialAnchorMSFT anchor; + XrResult result; +}; + +struct xrDestroySpatialAnchorStoreConnectionMSFT_params +{ + XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore; + XrResult result; +}; + +struct xrDestroySpatialGraphNodeBindingMSFT_params +{ + XrSpatialGraphNodeBindingMSFT nodeBinding; + XrResult result; +}; + +struct xrDestroySwapchain_params +{ + XrSwapchain swapchain; + XrResult result; +}; + +struct xrDestroyTriangleMeshFB_params +{ + XrTriangleMeshFB mesh; + XrResult result; +}; + +struct xrDestroyVirtualKeyboardMETA_params +{ + XrVirtualKeyboardMETA keyboard; + XrResult result; +}; + +struct xrEnableLocalizationEventsML_params +{ + XrSession session; + const XrLocalizationEnableEventsInfoML *info; + XrResult result; +}; + +struct xrEnableUserCalibrationEventsML_params +{ + XrInstance instance; + const XrUserCalibrationEnableEventsInfoML *enableInfo; + XrResult result; +}; + +struct xrEndFrame_params +{ + XrSession session; + const XrFrameEndInfo *frameEndInfo; + XrResult result; +}; + +struct xrEndSession_params +{ + XrSession session; + XrResult result; +}; + +struct xrEnumerateApiLayerProperties_params +{ + uint32_t propertyCapacityInput; + uint32_t *propertyCountOutput; + XrApiLayerProperties *properties; + XrResult result; +}; + +struct xrEnumerateBoundSourcesForAction_params +{ + XrSession session; + const XrBoundSourcesForActionEnumerateInfo *enumerateInfo; + uint32_t sourceCapacityInput; + uint32_t *sourceCountOutput; + XrPath *sources; + XrResult result; +}; + +struct xrEnumerateColorSpacesFB_params +{ + XrSession session; + uint32_t colorSpaceCapacityInput; + uint32_t *colorSpaceCountOutput; + XrColorSpaceFB *colorSpaces; + XrResult result; +}; + +struct xrEnumerateDisplayRefreshRatesFB_params +{ + XrSession session; + uint32_t displayRefreshRateCapacityInput; + uint32_t *displayRefreshRateCountOutput; + float *displayRefreshRates; + XrResult result; +}; + +struct xrEnumerateEnvironmentBlendModes_params +{ + XrInstance instance; + XrSystemId systemId; + XrViewConfigurationType viewConfigurationType; + uint32_t environmentBlendModeCapacityInput; + uint32_t *environmentBlendModeCountOutput; + XrEnvironmentBlendMode *environmentBlendModes; + XrResult result; +}; + +struct xrEnumerateEnvironmentDepthSwapchainImagesMETA_params +{ + XrEnvironmentDepthSwapchainMETA swapchain; + uint32_t imageCapacityInput; + uint32_t *imageCountOutput; + XrSwapchainImageBaseHeader *images; + XrResult result; +}; + +struct xrEnumerateExternalCamerasOCULUS_params +{ + XrSession session; + uint32_t cameraCapacityInput; + uint32_t *cameraCountOutput; + XrExternalCameraOCULUS *cameras; + XrResult result; +}; + +struct xrEnumerateInstanceExtensionProperties_params +{ + const char *layerName; + uint32_t propertyCapacityInput; + uint32_t *propertyCountOutput; + XrExtensionProperties *properties; + XrResult result; +}; + +struct xrEnumeratePerformanceMetricsCounterPathsMETA_params +{ + XrInstance instance; + uint32_t counterPathCapacityInput; + uint32_t *counterPathCountOutput; + XrPath *counterPaths; + XrResult result; +}; + +struct xrEnumeratePersistedSpatialAnchorNamesMSFT_params +{ + XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore; + uint32_t spatialAnchorNameCapacityInput; + uint32_t *spatialAnchorNameCountOutput; + XrSpatialAnchorPersistenceNameMSFT *spatialAnchorNames; + XrResult result; +}; + +struct xrEnumerateReferenceSpaces_params +{ + XrSession session; + uint32_t spaceCapacityInput; + uint32_t *spaceCountOutput; + XrReferenceSpaceType *spaces; + XrResult result; +}; + +struct xrEnumerateRenderModelPathsFB_params +{ + XrSession session; + uint32_t pathCapacityInput; + uint32_t *pathCountOutput; + XrRenderModelPathInfoFB *paths; + XrResult result; +}; + +struct xrEnumerateReprojectionModesMSFT_params +{ + XrInstance instance; + XrSystemId systemId; + XrViewConfigurationType viewConfigurationType; + uint32_t modeCapacityInput; + uint32_t *modeCountOutput; + XrReprojectionModeMSFT *modes; + XrResult result; +}; + +struct xrEnumerateSceneComputeFeaturesMSFT_params +{ + XrInstance instance; + XrSystemId systemId; + uint32_t featureCapacityInput; + uint32_t *featureCountOutput; + XrSceneComputeFeatureMSFT *features; + XrResult result; +}; + +struct xrEnumerateSpaceSupportedComponentsFB_params +{ + XrSpace space; + uint32_t componentTypeCapacityInput; + uint32_t *componentTypeCountOutput; + XrSpaceComponentTypeFB *componentTypes; + XrResult result; +}; + +struct xrEnumerateSwapchainFormats_params +{ + XrSession session; + uint32_t formatCapacityInput; + uint32_t *formatCountOutput; + int64_t *formats; + XrResult result; +}; + +struct xrEnumerateSwapchainImages_params +{ + XrSwapchain swapchain; + uint32_t imageCapacityInput; + uint32_t *imageCountOutput; + XrSwapchainImageBaseHeader *images; + XrResult result; +}; + +struct xrEnumerateViewConfigurationViews_params +{ + XrInstance instance; + XrSystemId systemId; + XrViewConfigurationType viewConfigurationType; + uint32_t viewCapacityInput; + uint32_t *viewCountOutput; + XrViewConfigurationView *views; + XrResult result; +}; + +struct xrEnumerateViewConfigurations_params +{ + XrInstance instance; + XrSystemId systemId; + uint32_t viewConfigurationTypeCapacityInput; + uint32_t *viewConfigurationTypeCountOutput; + XrViewConfigurationType *viewConfigurationTypes; + XrResult result; +}; + +struct xrEnumerateViveTrackerPathsHTCX_params +{ + XrInstance instance; + uint32_t pathCapacityInput; + uint32_t *pathCountOutput; + XrViveTrackerPathsHTCX *paths; + XrResult result; +}; + +struct xrEraseSpaceFB_params +{ + XrSession session; + const XrSpaceEraseInfoFB *info; + XrAsyncRequestIdFB *requestId; + XrResult result; +}; + +struct xrGeometryInstanceSetTransformFB_params +{ + XrGeometryInstanceFB instance; + const XrGeometryInstanceTransformFB *transformation; + XrResult result; +}; + +struct xrGetActionStateBoolean_params +{ + XrSession session; + const XrActionStateGetInfo *getInfo; + XrActionStateBoolean *state; + XrResult result; +}; + +struct xrGetActionStateFloat_params +{ + XrSession session; + const XrActionStateGetInfo *getInfo; + XrActionStateFloat *state; + XrResult result; +}; + +struct xrGetActionStatePose_params +{ + XrSession session; + const XrActionStateGetInfo *getInfo; + XrActionStatePose *state; + XrResult result; +}; + +struct xrGetActionStateVector2f_params +{ + XrSession session; + const XrActionStateGetInfo *getInfo; + XrActionStateVector2f *state; + XrResult result; +}; + +struct xrGetAudioInputDeviceGuidOculus_params +{ + XrInstance instance; + wchar_t *buffer; + XrResult result; +}; + +struct xrGetAudioOutputDeviceGuidOculus_params +{ + XrInstance instance; + wchar_t *buffer; + XrResult result; +}; + +struct xrGetBodySkeletonFB_params +{ + XrBodyTrackerFB bodyTracker; + XrBodySkeletonFB *skeleton; + XrResult result; +}; + +struct xrGetControllerModelKeyMSFT_params +{ + XrSession session; + XrPath topLevelUserPath; + XrControllerModelKeyStateMSFT *controllerModelKeyState; + XrResult result; +}; + +struct xrGetControllerModelPropertiesMSFT_params +{ + XrSession session; + XrControllerModelKeyMSFT modelKey; + XrControllerModelPropertiesMSFT *properties; + XrResult result; +}; + +struct xrGetControllerModelStateMSFT_params +{ + XrSession session; + XrControllerModelKeyMSFT modelKey; + XrControllerModelStateMSFT *state; + XrResult result; +}; + +struct xrGetCurrentInteractionProfile_params +{ + XrSession session; + XrPath topLevelUserPath; + XrInteractionProfileState *interactionProfile; + XrResult result; +}; + +struct xrGetDeviceSampleRateFB_params +{ + XrSession session; + const XrHapticActionInfo *hapticActionInfo; + XrDevicePcmSampleRateGetInfoFB *deviceSampleRate; + XrResult result; +}; + +struct xrGetDisplayRefreshRateFB_params +{ + XrSession session; + float *displayRefreshRate; + XrResult result; +}; + +struct xrGetEnvironmentDepthSwapchainStateMETA_params +{ + XrEnvironmentDepthSwapchainMETA swapchain; + XrEnvironmentDepthSwapchainStateMETA *state; + XrResult result; +}; + +struct xrGetExportedLocalizationMapDataML_params +{ + XrExportedLocalizationMapML map; + uint32_t bufferCapacityInput; + uint32_t *bufferCountOutput; + char *buffer; + XrResult result; +}; + +struct xrGetEyeGazesFB_params +{ + XrEyeTrackerFB eyeTracker; + const XrEyeGazesInfoFB *gazeInfo; + XrEyeGazesFB *eyeGazes; + XrResult result; +}; + +struct xrGetFaceExpressionWeights2FB_params +{ + XrFaceTracker2FB faceTracker; + const XrFaceExpressionInfo2FB *expressionInfo; + XrFaceExpressionWeights2FB *expressionWeights; + XrResult result; +}; + +struct xrGetFaceExpressionWeightsFB_params +{ + XrFaceTrackerFB faceTracker; + const XrFaceExpressionInfoFB *expressionInfo; + XrFaceExpressionWeightsFB *expressionWeights; + XrResult result; +}; + +struct xrGetFacialExpressionsHTC_params +{ + XrFacialTrackerHTC facialTracker; + XrFacialExpressionsHTC *facialExpressions; + XrResult result; +}; + +struct xrGetFoveationEyeTrackedStateMETA_params +{ + XrSession session; + XrFoveationEyeTrackedStateMETA *foveationState; + XrResult result; +}; + +struct xrGetHandMeshFB_params +{ + XrHandTrackerEXT handTracker; + XrHandTrackingMeshFB *mesh; + XrResult result; +}; + +struct xrGetInputSourceLocalizedName_params +{ + XrSession session; + const XrInputSourceLocalizedNameGetInfo *getInfo; + uint32_t bufferCapacityInput; + uint32_t *bufferCountOutput; + char *buffer; + XrResult result; +}; + +struct xrGetInstanceProperties_params +{ + XrInstance instance; + XrInstanceProperties *instanceProperties; + XrResult result; +}; + +struct xrGetMarkerDetectorStateML_params +{ + XrMarkerDetectorML markerDetector; + XrMarkerDetectorStateML *state; + XrResult result; +}; + +struct xrGetMarkerLengthML_params +{ + XrMarkerDetectorML markerDetector; + XrMarkerML marker; + float *meters; + XrResult result; +}; + +struct xrGetMarkerNumberML_params +{ + XrMarkerDetectorML markerDetector; + XrMarkerML marker; + uint64_t *number; + XrResult result; +}; + +struct xrGetMarkerReprojectionErrorML_params +{ + XrMarkerDetectorML markerDetector; + XrMarkerML marker; + float *reprojectionErrorMeters; + XrResult result; +}; + +struct xrGetMarkerSizeVARJO_params +{ + XrSession session; + uint64_t DECLSPEC_ALIGN(8) markerId; + XrExtent2Df *size; + XrResult result; +}; + +struct xrGetMarkerStringML_params +{ + XrMarkerDetectorML markerDetector; + XrMarkerML marker; + uint32_t bufferCapacityInput; + uint32_t *bufferCountOutput; + char *buffer; + XrResult result; +}; + +struct xrGetMarkersML_params +{ + XrMarkerDetectorML markerDetector; + uint32_t markerCapacityInput; + uint32_t *markerCountOutput; + XrMarkerML *markers; + XrResult result; +}; + +struct xrGetOpenGLGraphicsRequirementsKHR_params +{ + XrInstance instance; + XrSystemId systemId; + XrGraphicsRequirementsOpenGLKHR *graphicsRequirements; + XrResult result; +}; + +struct xrGetPassthroughPreferencesMETA_params +{ + XrSession session; + XrPassthroughPreferencesMETA *preferences; + XrResult result; +}; + +struct xrGetPerformanceMetricsStateMETA_params +{ + XrSession session; + XrPerformanceMetricsStateMETA *state; + XrResult result; +}; + +struct xrGetPlaneDetectionStateEXT_params +{ + XrPlaneDetectorEXT planeDetector; + XrPlaneDetectionStateEXT *state; + XrResult result; +}; + +struct xrGetPlaneDetectionsEXT_params +{ + XrPlaneDetectorEXT planeDetector; + const XrPlaneDetectorGetInfoEXT *info; + XrPlaneDetectorLocationsEXT *locations; + XrResult result; +}; + +struct xrGetPlanePolygonBufferEXT_params +{ + XrPlaneDetectorEXT planeDetector; + uint64_t DECLSPEC_ALIGN(8) planeId; + uint32_t polygonBufferIndex; + XrPlaneDetectorPolygonBufferEXT *polygonBuffer; + XrResult result; +}; + +struct xrGetRecommendedLayerResolutionMETA_params +{ + XrSession session; + const XrRecommendedLayerResolutionGetInfoMETA *info; + XrRecommendedLayerResolutionMETA *resolution; + XrResult result; +}; + +struct xrGetReferenceSpaceBoundsRect_params +{ + XrSession session; + XrReferenceSpaceType referenceSpaceType; + XrExtent2Df *bounds; + XrResult result; +}; + +struct xrGetRenderModelPropertiesFB_params +{ + XrSession session; + XrPath path; + XrRenderModelPropertiesFB *properties; + XrResult result; +}; + +struct xrGetSceneComponentsMSFT_params +{ + XrSceneMSFT scene; + const XrSceneComponentsGetInfoMSFT *getInfo; + XrSceneComponentsMSFT *components; + XrResult result; +}; + +struct xrGetSceneComputeStateMSFT_params +{ + XrSceneObserverMSFT sceneObserver; + XrSceneComputeStateMSFT *state; + XrResult result; +}; + +struct xrGetSceneMarkerDecodedStringMSFT_params +{ + XrSceneMSFT scene; + const XrUuidMSFT *markerId; + uint32_t bufferCapacityInput; + uint32_t *bufferCountOutput; + char *buffer; + XrResult result; +}; + +struct xrGetSceneMarkerRawDataMSFT_params +{ + XrSceneMSFT scene; + const XrUuidMSFT *markerId; + uint32_t bufferCapacityInput; + uint32_t *bufferCountOutput; + uint8_t *buffer; + XrResult result; +}; + +struct xrGetSceneMeshBuffersMSFT_params +{ + XrSceneMSFT scene; + const XrSceneMeshBuffersGetInfoMSFT *getInfo; + XrSceneMeshBuffersMSFT *buffers; + XrResult result; +}; + +struct xrGetSerializedSceneFragmentDataMSFT_params +{ + XrSceneMSFT scene; + const XrSerializedSceneFragmentDataGetInfoMSFT *getInfo; + uint32_t countInput; + uint32_t *readOutput; + uint8_t *buffer; + XrResult result; +}; + +struct xrGetSpaceBoundary2DFB_params +{ + XrSession session; + XrSpace space; + XrBoundary2DFB *boundary2DOutput; + XrResult result; +}; + +struct xrGetSpaceBoundingBox2DFB_params +{ + XrSession session; + XrSpace space; + XrRect2Df *boundingBox2DOutput; + XrResult result; +}; + +struct xrGetSpaceBoundingBox3DFB_params +{ + XrSession session; + XrSpace space; + XrRect3DfFB *boundingBox3DOutput; + XrResult result; +}; + +struct xrGetSpaceComponentStatusFB_params +{ + XrSpace space; + XrSpaceComponentTypeFB componentType; + XrSpaceComponentStatusFB *status; + XrResult result; +}; + +struct xrGetSpaceContainerFB_params +{ + XrSession session; + XrSpace space; + XrSpaceContainerFB *spaceContainerOutput; + XrResult result; +}; + +struct xrGetSpaceRoomLayoutFB_params +{ + XrSession session; + XrSpace space; + XrRoomLayoutFB *roomLayoutOutput; + XrResult result; +}; + +struct xrGetSpaceSemanticLabelsFB_params +{ + XrSession session; + XrSpace space; + XrSemanticLabelsFB *semanticLabelsOutput; + XrResult result; +}; + +struct xrGetSpaceTriangleMeshMETA_params +{ + XrSpace space; + const XrSpaceTriangleMeshGetInfoMETA *getInfo; + XrSpaceTriangleMeshMETA *triangleMeshOutput; + XrResult result; +}; + +struct xrGetSpaceUserIdFB_params +{ + XrSpaceUserFB user; + XrSpaceUserIdFB *userId; + XrResult result; +}; + +struct xrGetSpaceUuidFB_params +{ + XrSpace space; + XrUuidEXT *uuid; + XrResult result; +}; + +struct xrGetSpatialAnchorNameHTC_params +{ + XrSpace anchor; + XrSpatialAnchorNameHTC *name; + XrResult result; +}; + +struct xrGetSpatialGraphNodeBindingPropertiesMSFT_params +{ + XrSpatialGraphNodeBindingMSFT nodeBinding; + const XrSpatialGraphNodeBindingPropertiesGetInfoMSFT *getInfo; + XrSpatialGraphNodeBindingPropertiesMSFT *properties; + XrResult result; +}; + +struct xrGetSwapchainStateFB_params +{ + XrSwapchain swapchain; + XrSwapchainStateBaseHeaderFB *state; + XrResult result; +}; + +struct xrGetSystem_params +{ + XrInstance instance; + const XrSystemGetInfo *getInfo; + XrSystemId *systemId; + XrResult result; +}; + +struct xrGetSystemProperties_params +{ + XrInstance instance; + XrSystemId systemId; + XrSystemProperties *properties; + XrResult result; +}; + +struct xrGetViewConfigurationProperties_params +{ + XrInstance instance; + XrSystemId systemId; + XrViewConfigurationType viewConfigurationType; + XrViewConfigurationProperties *configurationProperties; + XrResult result; +}; + +struct xrGetVirtualKeyboardDirtyTexturesMETA_params +{ + XrVirtualKeyboardMETA keyboard; + uint32_t textureIdCapacityInput; + uint32_t *textureIdCountOutput; + uint64_t *textureIds; + XrResult result; +}; + +struct xrGetVirtualKeyboardModelAnimationStatesMETA_params +{ + XrVirtualKeyboardMETA keyboard; + XrVirtualKeyboardModelAnimationStatesMETA *animationStates; + XrResult result; +}; + +struct xrGetVirtualKeyboardScaleMETA_params +{ + XrVirtualKeyboardMETA keyboard; + float *scale; + XrResult result; +}; + +struct xrGetVirtualKeyboardTextureDataMETA_params +{ + XrVirtualKeyboardMETA keyboard; + uint64_t DECLSPEC_ALIGN(8) textureId; + XrVirtualKeyboardTextureDataMETA *textureData; + XrResult result; +}; + +struct xrGetVisibilityMaskKHR_params +{ + XrSession session; + XrViewConfigurationType viewConfigurationType; + uint32_t viewIndex; + XrVisibilityMaskTypeKHR visibilityMaskType; + XrVisibilityMaskKHR *visibilityMask; + XrResult result; +}; + +struct xrGetVulkanDeviceExtensionsKHR_params +{ + XrInstance instance; + XrSystemId systemId; + uint32_t bufferCapacityInput; + uint32_t *bufferCountOutput; + char *buffer; + XrResult result; +}; + +struct xrGetVulkanGraphicsDevice2KHR_params +{ + XrInstance instance; + const XrVulkanGraphicsDeviceGetInfoKHR *getInfo; + VkPhysicalDevice *vulkanPhysicalDevice; + XrResult result; +}; + +struct xrGetVulkanGraphicsDeviceKHR_params +{ + XrInstance instance; + XrSystemId systemId; + VkInstance vkInstance; + VkPhysicalDevice *vkPhysicalDevice; + XrResult result; +}; + +struct xrGetVulkanGraphicsRequirements2KHR_params +{ + XrInstance instance; + XrSystemId systemId; + XrGraphicsRequirementsVulkanKHR *graphicsRequirements; + XrResult result; +}; + +struct xrGetVulkanGraphicsRequirementsKHR_params +{ + XrInstance instance; + XrSystemId systemId; + XrGraphicsRequirementsVulkanKHR *graphicsRequirements; + XrResult result; +}; + +struct xrGetVulkanInstanceExtensionsKHR_params +{ + XrInstance instance; + XrSystemId systemId; + uint32_t bufferCapacityInput; + uint32_t *bufferCountOutput; + char *buffer; + XrResult result; +}; + +struct xrImportLocalizationMapML_params +{ + XrSession session; + const XrLocalizationMapImportInfoML *importInfo; + XrUuidEXT *mapUuid; + XrResult result; +}; + +struct xrLoadControllerModelMSFT_params +{ + XrSession session; + XrControllerModelKeyMSFT modelKey; + uint32_t bufferCapacityInput; + uint32_t *bufferCountOutput; + uint8_t *buffer; + XrResult result; +}; + +struct xrLoadRenderModelFB_params +{ + XrSession session; + const XrRenderModelLoadInfoFB *info; + XrRenderModelBufferFB *buffer; + XrResult result; +}; + +struct xrLocateBodyJointsFB_params +{ + XrBodyTrackerFB bodyTracker; + const XrBodyJointsLocateInfoFB *locateInfo; + XrBodyJointLocationsFB *locations; + XrResult result; +}; + +struct xrLocateHandJointsEXT_params +{ + XrHandTrackerEXT handTracker; + const XrHandJointsLocateInfoEXT *locateInfo; + XrHandJointLocationsEXT *locations; + XrResult result; +}; + +struct xrLocateSceneComponentsMSFT_params +{ + XrSceneMSFT scene; + const XrSceneComponentsLocateInfoMSFT *locateInfo; + XrSceneComponentLocationsMSFT *locations; + XrResult result; +}; + +struct xrLocateSpace_params +{ + XrSpace space; + XrSpace baseSpace; + XrTime time; + XrSpaceLocation *location; + XrResult result; +}; + +struct xrLocateSpaces_params +{ + XrSession session; + const XrSpacesLocateInfo *locateInfo; + XrSpaceLocations *spaceLocations; + XrResult result; +}; + +struct xrLocateSpacesKHR_params +{ + XrSession session; + const XrSpacesLocateInfo *locateInfo; + XrSpaceLocations *spaceLocations; + XrResult result; +}; + +struct xrLocateViews_params +{ + XrSession session; + const XrViewLocateInfo *viewLocateInfo; + XrViewState *viewState; + uint32_t viewCapacityInput; + uint32_t *viewCountOutput; + XrView *views; + XrResult result; +}; + +struct xrPassthroughLayerPauseFB_params +{ + XrPassthroughLayerFB layer; + XrResult result; +}; + +struct xrPassthroughLayerResumeFB_params +{ + XrPassthroughLayerFB layer; + XrResult result; +}; + +struct xrPassthroughLayerSetKeyboardHandsIntensityFB_params +{ + XrPassthroughLayerFB layer; + const XrPassthroughKeyboardHandsIntensityFB *intensity; + XrResult result; +}; + +struct xrPassthroughLayerSetStyleFB_params +{ + XrPassthroughLayerFB layer; + const XrPassthroughStyleFB *style; + XrResult result; +}; + +struct xrPassthroughPauseFB_params +{ + XrPassthroughFB passthrough; + XrResult result; +}; + +struct xrPassthroughStartFB_params +{ + XrPassthroughFB passthrough; + XrResult result; +}; + +struct xrPathToString_params +{ + XrInstance instance; + XrPath path; + uint32_t bufferCapacityInput; + uint32_t *bufferCountOutput; + char *buffer; + XrResult result; +}; + +struct xrPerfSettingsSetPerformanceLevelEXT_params +{ + XrSession session; + XrPerfSettingsDomainEXT domain; + XrPerfSettingsLevelEXT level; + XrResult result; +}; + +struct xrPersistSpatialAnchorMSFT_params +{ + XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore; + const XrSpatialAnchorPersistenceInfoMSFT *spatialAnchorPersistenceInfo; + XrResult result; +}; + +struct xrPollEvent_params +{ + XrInstance instance; + XrEventDataBuffer *eventData; + XrResult result; +}; + +struct xrPollFutureEXT_params +{ + XrInstance instance; + const XrFuturePollInfoEXT *pollInfo; + XrFuturePollResultEXT *pollResult; + XrResult result; +}; + +struct xrQueryLocalizationMapsML_params +{ + XrSession session; + const XrLocalizationMapQueryInfoBaseHeaderML *queryInfo; + uint32_t mapCapacityInput; + uint32_t *mapCountOutput; + XrLocalizationMapML *maps; + XrResult result; +}; + +struct xrQueryPerformanceMetricsCounterMETA_params +{ + XrSession session; + XrPath counterPath; + XrPerformanceMetricsCounterMETA *counter; + XrResult result; +}; + +struct xrQuerySpacesFB_params +{ + XrSession session; + const XrSpaceQueryInfoBaseHeaderFB *info; + XrAsyncRequestIdFB *requestId; + XrResult result; +}; + +struct xrQuerySystemTrackedKeyboardFB_params +{ + XrSession session; + const XrKeyboardTrackingQueryFB *queryInfo; + XrKeyboardTrackingDescriptionFB *keyboard; + XrResult result; +}; + +struct xrReleaseSwapchainImage_params +{ + XrSwapchain swapchain; + const XrSwapchainImageReleaseInfo *releaseInfo; + XrResult result; +}; + +struct xrRequestDisplayRefreshRateFB_params +{ + XrSession session; + float displayRefreshRate; + XrResult result; +}; + +struct xrRequestExitSession_params +{ + XrSession session; + XrResult result; +}; + +struct xrRequestMapLocalizationML_params +{ + XrSession session; + const XrMapLocalizationRequestInfoML *requestInfo; + XrResult result; +}; + +struct xrRequestSceneCaptureFB_params +{ + XrSession session; + const XrSceneCaptureRequestInfoFB *info; + XrAsyncRequestIdFB *requestId; + XrResult result; +}; + +struct xrResultToString_params +{ + XrInstance instance; + XrResult value; + char *buffer; + XrResult result; +}; + +struct xrRetrieveSpaceQueryResultsFB_params +{ + XrSession session; + XrAsyncRequestIdFB requestId; + XrSpaceQueryResultsFB *results; + XrResult result; +}; + +struct xrSaveSpaceFB_params +{ + XrSession session; + const XrSpaceSaveInfoFB *info; + XrAsyncRequestIdFB *requestId; + XrResult result; +}; + +struct xrSaveSpaceListFB_params +{ + XrSession session; + const XrSpaceListSaveInfoFB *info; + XrAsyncRequestIdFB *requestId; + XrResult result; +}; + +struct xrSendVirtualKeyboardInputMETA_params +{ + XrVirtualKeyboardMETA keyboard; + const XrVirtualKeyboardInputInfoMETA *info; + XrPosef *interactorRootPose; + XrResult result; +}; + +struct xrSetColorSpaceFB_params +{ + XrSession session; + XrColorSpaceFB colorSpace; + XrResult result; +}; + +struct xrSetDigitalLensControlALMALENCE_params +{ + XrSession session; + const XrDigitalLensControlALMALENCE *digitalLensControl; + XrResult result; +}; + +struct xrSetEnvironmentDepthEstimationVARJO_params +{ + XrSession session; + XrBool32 enabled; + XrResult result; +}; + +struct xrSetEnvironmentDepthHandRemovalMETA_params +{ + XrEnvironmentDepthProviderMETA environmentDepthProvider; + const XrEnvironmentDepthHandRemovalSetInfoMETA *setInfo; + XrResult result; +}; + +struct xrSetInputDeviceActiveEXT_params +{ + XrSession session; + XrPath interactionProfile; + XrPath topLevelPath; + XrBool32 isActive; + XrResult result; +}; + +struct xrSetInputDeviceLocationEXT_params +{ + XrSession session; + XrPath topLevelPath; + XrPath inputSourcePath; + XrSpace space; + XrPosef pose; + XrResult result; +}; + +struct xrSetInputDeviceStateBoolEXT_params +{ + XrSession session; + XrPath topLevelPath; + XrPath inputSourcePath; + XrBool32 state; + XrResult result; +}; + +struct xrSetInputDeviceStateFloatEXT_params +{ + XrSession session; + XrPath topLevelPath; + XrPath inputSourcePath; + float state; + XrResult result; +}; + +struct xrSetInputDeviceStateVector2fEXT_params +{ + XrSession session; + XrPath topLevelPath; + XrPath inputSourcePath; + XrVector2f state; + XrResult result; +}; + +struct xrSetMarkerTrackingPredictionVARJO_params +{ + XrSession session; + uint64_t DECLSPEC_ALIGN(8) markerId; + XrBool32 enable; + XrResult result; +}; + +struct xrSetMarkerTrackingTimeoutVARJO_params +{ + XrSession session; + uint64_t DECLSPEC_ALIGN(8) markerId; + XrDuration timeout; + XrResult result; +}; + +struct xrSetMarkerTrackingVARJO_params +{ + XrSession session; + XrBool32 enabled; + XrResult result; +}; + +struct xrSetPerformanceMetricsStateMETA_params +{ + XrSession session; + const XrPerformanceMetricsStateMETA *state; + XrResult result; +}; + +struct xrSetSpaceComponentStatusFB_params +{ + XrSpace space; + const XrSpaceComponentStatusSetInfoFB *info; + XrAsyncRequestIdFB *requestId; + XrResult result; +}; + +struct xrSetTrackingOptimizationSettingsHintQCOM_params +{ + XrSession session; + XrTrackingOptimizationSettingsDomainQCOM domain; + XrTrackingOptimizationSettingsHintQCOM hint; + XrResult result; +}; + +struct xrSetViewOffsetVARJO_params +{ + XrSession session; + float offset; + XrResult result; +}; + +struct xrSetVirtualKeyboardModelVisibilityMETA_params +{ + XrVirtualKeyboardMETA keyboard; + const XrVirtualKeyboardModelVisibilitySetInfoMETA *modelVisibility; + XrResult result; +}; + +struct xrShareSpacesFB_params +{ + XrSession session; + const XrSpaceShareInfoFB *info; + XrAsyncRequestIdFB *requestId; + XrResult result; +}; + +struct xrSnapshotMarkerDetectorML_params +{ + XrMarkerDetectorML markerDetector; + XrMarkerDetectorSnapshotInfoML *snapshotInfo; + XrResult result; +}; + +struct xrStartEnvironmentDepthProviderMETA_params +{ + XrEnvironmentDepthProviderMETA environmentDepthProvider; + XrResult result; +}; + +struct xrStopEnvironmentDepthProviderMETA_params +{ + XrEnvironmentDepthProviderMETA environmentDepthProvider; + XrResult result; +}; + +struct xrStopHapticFeedback_params +{ + XrSession session; + const XrHapticActionInfo *hapticActionInfo; + XrResult result; +}; + +struct xrStringToPath_params +{ + XrInstance instance; + const char *pathString; + XrPath *path; + XrResult result; +}; + +struct xrStructureTypeToString_params +{ + XrInstance instance; + XrStructureType value; + char *buffer; + XrResult result; +}; + +struct xrSuggestInteractionProfileBindings_params +{ + XrInstance instance; + const XrInteractionProfileSuggestedBinding *suggestedBindings; + XrResult result; +}; + +struct xrSuggestVirtualKeyboardLocationMETA_params +{ + XrVirtualKeyboardMETA keyboard; + const XrVirtualKeyboardLocationInfoMETA *locationInfo; + XrResult result; +}; + +struct xrSyncActions_params +{ + XrSession session; + const XrActionsSyncInfo *syncInfo; + XrResult result; +}; + +struct xrThermalGetTemperatureTrendEXT_params +{ + XrSession session; + XrPerfSettingsDomainEXT domain; + XrPerfSettingsNotificationLevelEXT *notificationLevel; + float *tempHeadroom; + float *tempSlope; + XrResult result; +}; + +struct xrTriangleMeshBeginUpdateFB_params +{ + XrTriangleMeshFB mesh; + XrResult result; +}; + +struct xrTriangleMeshBeginVertexBufferUpdateFB_params +{ + XrTriangleMeshFB mesh; + uint32_t *outVertexCount; + XrResult result; +}; + +struct xrTriangleMeshEndUpdateFB_params +{ + XrTriangleMeshFB mesh; + uint32_t vertexCount; + uint32_t triangleCount; + XrResult result; +}; + +struct xrTriangleMeshEndVertexBufferUpdateFB_params +{ + XrTriangleMeshFB mesh; + XrResult result; +}; + +struct xrTriangleMeshGetIndexBufferFB_params +{ + XrTriangleMeshFB mesh; + uint32_t **outIndexBuffer; + XrResult result; +}; + +struct xrTriangleMeshGetVertexBufferFB_params +{ + XrTriangleMeshFB mesh; + XrVector3f **outVertexBuffer; + XrResult result; +}; + +struct xrTryCreateSpatialGraphStaticNodeBindingMSFT_params +{ + XrSession session; + const XrSpatialGraphStaticNodeBindingCreateInfoMSFT *createInfo; + XrSpatialGraphNodeBindingMSFT *nodeBinding; + XrResult result; +}; + +struct xrUnpersistSpatialAnchorMSFT_params +{ + XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore; + const XrSpatialAnchorPersistenceNameMSFT *spatialAnchorPersistenceName; + XrResult result; +}; + +struct xrUpdateHandMeshMSFT_params +{ + XrHandTrackerEXT handTracker; + const XrHandMeshUpdateInfoMSFT *updateInfo; + XrHandMeshMSFT *handMesh; + XrResult result; +}; + +struct xrUpdatePassthroughColorLutMETA_params +{ + XrPassthroughColorLutMETA colorLut; + const XrPassthroughColorLutUpdateInfoMETA *updateInfo; + XrResult result; +}; + +struct xrUpdateSwapchainFB_params +{ + XrSwapchain swapchain; + const XrSwapchainStateBaseHeaderFB *state; + XrResult result; +}; + +struct xrWaitFrame_params +{ + XrSession session; + const XrFrameWaitInfo *frameWaitInfo; + XrFrameState *frameState; + XrResult result; +}; + +struct xrWaitSwapchainImage_params +{ + XrSwapchain swapchain; + const XrSwapchainImageWaitInfo *waitInfo; + XrResult result; +}; + +#endif /* __WINE_OPENXR_LOADER_THUNKS_H */ diff --git a/wineopenxr/make_openxr b/wineopenxr/make_openxr index ec403500..cc3bb30c 100755 --- a/wineopenxr/make_openxr +++ b/wineopenxr/make_openxr @@ -1,7 +1,8 @@ -#!/usr/bin/python3 +#!/usr/bin/env python3 # Wine Vulkan generator # # Copyright 2017-2018 Roderick Colenbrander +# Copyright 2022 Jacek Caban for CodeWeavers # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -22,7 +23,6 @@ import argparse import logging import os import re -import sys import urllib.request import xml.etree.ElementTree as ET from collections import OrderedDict @@ -39,7 +39,7 @@ from enum import Enum # most of the ugly work is carried out by these objects. # # Vulkan ICD challenges: -# - Vulkan ICD loader (vulkan-1.dll) relies on a section at the start of +# - Vulkan ICD loader (openxr-1.dll) relies on a section at the start of # 'dispatchable handles' (e.g. XrDevice, XrInstance) for it to insert # its private data. It uses this area to stare its own dispatch tables # for loader internal use. This means any dispatchable objects need wrapping. @@ -54,6 +54,9 @@ from enum import Enum # Parsing of extension information required to pull in types and functions # we really want to generate. Just tying all the data together is tricky. # +# - Extensions can affect core types e.g. add new enum values, bitflags or +# additional structure chaining through 'next' / 'type'. +# # - Arrays are used all over the place for parameters or for structure members. # Array length is often stored in a previous parameter or another structure # member and thus needs careful parsing. @@ -61,15 +64,16 @@ from enum import Enum LOGGER = logging.Logger("openxr") LOGGER.addHandler(logging.StreamHandler()) -XR_XML_VERSION = "1.0.11" +XR_XML_VERSION = "1.1.36" WINE_XR_VERSION = (1, 1) # Filenames to create. WINE_OPENXR_H = "./wineopenxr.h" -WINE_OPENXR_DRIVER_H = "./wineopenxr_driver.h" WINE_OPENXR_JSON = "./wineopenxr.json" WINE_OPENXR_THUNKS_C = "./openxr_thunks.c" WINE_OPENXR_THUNKS_H = "./openxr_thunks.h" +WINE_OPENXR_LOADER_THUNKS_C = "./loader_thunks.c" +WINE_OPENXR_LOADER_THUNKS_H = "./loader_thunks.h" # Extension enum values start at a certain offset (EXT_BASE). # Relative to the offset each extension has a block (EXT_BLOCK_SIZE) @@ -80,53 +84,15 @@ EXT_BASE = 1000000000 EXT_BLOCK_SIZE = 1000 UNSUPPORTED_EXTENSIONS = [ - # Instance extensions - "XR_EXT_debug_report", # Handling of XR_EXT_debug_report requires some consideration. The win32 # loader already provides it for us and it is somewhat usable. If we add # plumbing down to the native layer, we will get each message twice as we # use 2 loaders (win32+native), but we may get output from the driver. # In any case callback conversion is required. "XR_EXT_debug_utils", - "XR_EXT_validation_features", - "XR_EXT_validation_flags", - "XR_KHR_display", # Needs WSI work. - "XR_KHR_surface_protected_capabilities", "XR_KHR_loader_init", "XR_MSFT_perception_anchor_interop", - - # Device extensions - "XR_AMD_display_native_hdr", - "XR_EXT_display_control", # Requires XR_EXT_display_surface_counter - "XR_EXT_full_screen_exclusive", - "XR_EXT_hdr_metadata", # Needs WSI work. - "XR_EXT_pipeline_creation_feedback", - "XR_GOOGLE_display_timing", - "XR_KHR_external_fence_win32", - "XR_KHR_external_memory_win32", - "XR_KHR_external_semaphore_win32", - # Relates to external_semaphore and needs type conversions in bitflags. - "XR_KHR_shared_presentable_image", # Needs WSI work. - "XR_KHR_win32_keyed_mutex", - - # Extensions for other platforms - "XR_EXT_external_memory_dma_buf", - "XR_EXT_image_drm_format_modifier", - "XR_KHR_external_fence_fd", - "XR_KHR_external_memory_fd", - "XR_KHR_external_semaphore_fd", - - # Deprecated extensions - "XR_NV_external_memory_capabilities", - "XR_NV_external_memory_win32", -] - -ALLOWED_PROTECTS = [ - "XR_USE_PLATFORM_WIN32", - "XR_USE_GRAPHICS_API_VULKAN", - "XR_USE_GRAPHICS_API_OPENGL", - "XR_USE_GRAPHICS_API_D3D11", - "XR_USE_GRAPHICS_API_D3D12", + "XR_HTC_foveation", ] # Functions part of our wineopenxr graphics driver interface. @@ -138,104 +104,147 @@ DRIVER_VERSION = 1 # These are regular device / instance functions for which we need # to do more work compared to a regular thunk or because they are # part of the driver interface. -# - dispatch set whether we need a function pointer in the device -# / instance dispatch table. -# - driver sets whether the API is part of the driver interface. -# - thunk sets whether to create a thunk in openxr_thunks.c. +# - dispatch (default: True): set whether we need a function pointer in the device / instance dispatch table. FUNCTION_OVERRIDES = { # Global functions - "xrCreateInstance" : {"dispatch" : False, "driver" : True, "thunk" : False}, - "xrCreateApiLayerInstance" : {"dispatch" : False, "driver" : True, "thunk" : False}, - "xrNegotiateLoaderRuntimeInterface" : {"dispatch" : False, "driver" : True, "thunk" : False}, - "xrNegotiateLoaderApiLayerInterface" : {"dispatch" : False, "driver" : False, "thunk" : False}, - "xrDestroyInstance" : {"dispatch" : False, "driver" : True, "thunk" : False}, + "xrCreateInstance" : {"dispatch" : False}, - "xrCreateSession" : {"dispatch" : True, "driver" : True, "thunk" : False}, - "xrDestroySession" : {"dispatch" : True, "driver" : True, "thunk" : False}, + "xrCreateSession" : {"dispatch" : True}, - "xrGetInstanceProcAddr" : {"dispatch" : False, "driver" : True, "thunk" : False}, - "xrEnumerateInstanceExtensionProperties" : {"dispatch" : False, "driver" : True, "thunk" : False}, + "xrGetInstanceProcAddr" : {"dispatch" : False}, + "xrEnumerateInstanceExtensionProperties" : {"dispatch" : False}, - "xrConvertTimeToWin32PerformanceCounterKHR" : {"dispatch" : False, "driver" : True, "thunk" : False}, - "xrConvertWin32PerformanceCounterToTimeKHR" : {"dispatch" : False, "driver" : True, "thunk" : False}, - "xrGetD3D11GraphicsRequirementsKHR" : {"dispatch" : False, "driver" : True, "thunk" : False}, - "xrGetD3D12GraphicsRequirementsKHR" : {"dispatch" : False, "driver" : True, "thunk" : False}, + "xrConvertTimeToWin32PerformanceCounterKHR" : {"dispatch" : False}, + "xrConvertWin32PerformanceCounterToTimeKHR" : {"dispatch" : False}, + "xrGetD3D11GraphicsRequirementsKHR" : {"dispatch" : False}, + "xrGetD3D12GraphicsRequirementsKHR" : {"dispatch" : False}, - "xrGetVulkanGraphicsDeviceKHR" : {"dispatch" : True, "driver" : True, "thunk" : False}, - "xrGetVulkanGraphicsDevice2KHR" : {"dispatch" : True, "driver" : True, "thunk" : False}, - "xrGetVulkanDeviceExtensionsKHR" : {"dispatch" : True, "driver" : True, "thunk" : False}, - "xrGetVulkanInstanceExtensionsKHR" : {"dispatch" : True, "driver" : True, "thunk" : False}, - "xrCreateVulkanInstanceKHR" : {"dispatch" : True, "driver" : True, "thunk" : False}, - "xrCreateVulkanDeviceKHR" : {"dispatch" : True, "driver" : True, "thunk" : False}, + "xrGetVulkanGraphicsDeviceKHR" : {"dispatch" : True}, + "xrGetVulkanGraphicsDevice2KHR" : {"dispatch" : True}, + "xrGetVulkanDeviceExtensionsKHR" : {"dispatch" : True}, + "xrGetVulkanInstanceExtensionsKHR" : {"dispatch" : True}, - "xrPollEvent" : {"dispatch" : True, "driver" : True, "thunk" : False}, - "xrEnumerateSwapchainImages" : {"dispatch" : True, "driver" : True, "thunk" : False}, - "xrGetSystem" : {"dispatch" : True, "driver" : True, "thunk" : False}, - "xrEnumerateSwapchainFormats" : {"dispatch" : True, "driver" : True, "thunk" : False}, - "xrCreateSwapchain" : {"dispatch" : True, "driver" : True, "thunk" : False}, - "xrDestroySwapchain" : {"dispatch" : True, "driver" : True, "thunk" : False}, - "xrEndFrame" : {"dispatch" : True, "driver" : True, "thunk" : False}, - "xrBeginFrame" : {"dispatch" : True, "driver" : True, "thunk" : False}, - "xrAcquireSwapchainImage" : {"dispatch" : True, "driver" : True, "thunk" : False}, - "xrReleaseSwapchainImage" : {"dispatch" : True, "driver" : True, "thunk" : False}, + "xrCreateSwapchain" : {"dispatch" : True}, } +# functions for which a user driver entry must be generated +USER_DRIVER_FUNCS = {} + +# functions for which the unix thunk is manually implemented +MANUAL_UNIX_THUNKS = { + "xrCreateInstance", + "xrCreateSession", + "xrCreateSwapchain", + "xrGetInstanceProcAddr", + "xrEnumerateInstanceExtensionProperties", + "xrConvertTimeToWin32PerformanceCounterKHR", + "xrConvertWin32PerformanceCounterToTimeKHR", + "xrGetD3D11GraphicsRequirementsKHR", + "xrGetD3D12GraphicsRequirementsKHR", + "xrGetVulkanGraphicsDeviceKHR", + "xrGetVulkanGraphicsDevice2KHR", + "xrGetVulkanDeviceExtensionsKHR", + "xrGetVulkanInstanceExtensionsKHR", +} + +# loader functions which are entirely manually implemented +MANUAL_LOADER_FUNCTIONS = { + "xrConvertTimeToWin32PerformanceCounterKHR", + "xrConvertWin32PerformanceCounterToTimeKHR", + "xrGetD3D11GraphicsRequirementsKHR", + "xrGetD3D12GraphicsRequirementsKHR", + "xrCreateApiLayerInstance", + "xrGetInstanceProcAddr", + "xrNegotiateLoaderRuntimeInterface", + "xrNegotiateLoaderApiLayerInterface", + "xrCreateVulkanInstanceKHR", + "xrCreateVulkanDeviceKHR" +} + +# functions which loader thunks are manually implemented +MANUAL_LOADER_THUNKS = { + "xrCreateInstance", + "xrDestroyInstance", + "xrCreateSession", + "xrDestroySession", + "xrPollEvent", + "xrGetSystem", + "xrEnumerateSwapchainFormats", + "xrCreateSwapchain", + "xrDestroySwapchain", + "xrEnumerateSwapchainImages", + "xrAcquireSwapchainImage", + "xrReleaseSwapchainImage", + "xrBeginFrame", + "xrEndFrame", +} + +STRUCT_CHAIN_CONVERSIONS = { + "XrInstanceCreateInfo": [], +} + +UNEXPOSED_EXTENSIONS = {} +STRUCT_COPY = {}; + +# Some struct members are conditionally ignored and callers are free to leave them uninitialized. +# We can't deduce that from XML, so we allow expressing it here. +MEMBER_LENGTH_EXPRESSIONS = {} + +PERF_CRITICAL_FUNCTIONS = [] + +ALLOWED_PROTECTS = [ + "XR_USE_PLATFORM_WIN32", + "XR_USE_GRAPHICS_API_VULKAN", + "XR_USE_GRAPHICS_API_OPENGL", + "XR_USE_GRAPHICS_API_D3D11", + "XR_USE_GRAPHICS_API_D3D12", +] NOT_OUR_FUNCTIONS = [ # xr.xml defines that as a part of XR_LOADER_VERSION_1_0 commands but it looks like only layers should provide it # (through dll export). "xrNegotiateLoaderApiLayerInterface", ] -STRUCT_CHAIN_CONVERSIONS = [ - "XrInstanceCreateInfo", -] - -STRUCTS_PUT_FIRST = [ - "XrUuid", - "XrExtent3Df", -] - -AUTO_MAPPED_HANDLES = [ - "XrSpace", - "XrSpatialAnchorMSFT", - "XrSpatialAnchorStoreConnectionMSFT", - "XrHandTrackerEXT", - "XrExportedLocalizationMapML", - "XrMarkerDetectorML", - "XrSceneMSFT", - "XrSceneObserverMSFT", - "XrSpatialGraphNodeBindingMSFT", - "XrFoveationProfileFB", - "XrTriangleMeshFB", - "XrPassthroughFB", - "XrPassthroughLayerFB", - "XrGeometryInstanceFB", - "XrEnvironmentDepthProviderMETA", - "XrVirtualKeyboardMETA", - "XrPlaneDetectorEXT", - "XrEyeTrackerFB", - "XrSpaceUserFB", - "XrBodyTrackerFB", - "XrFaceTrackerFB", - "XrFaceTracker2FB", - "XrEnvironmentDepthSwapchainMETA", - "XrPassthroughHTC", - "XrFacialTrackerHTC", - "XrPassthroughColorLutMETA", -] - class Direction(Enum): """ Parameter direction: input, output, input_output. """ INPUT = 1 OUTPUT = 2 - INPUT_OUTPUT = 3 + + +class Unwrap(Enum): + NONE = 0 + HOST = 1 + DRIVER = 2 + + +def api_is_openxr(obj): + return "openxr" in obj.get("api", "openxr").split(",") + + +def convert_suffix(direction, win_type, unwrap, is_wrapped): + if direction == Direction.OUTPUT: + if not is_wrapped: + return "host_to_{0}".format(win_type) + if unwrap == Unwrap.NONE: + return "unwrapped_host_to_{0}".format(win_type) + if unwrap == Unwrap.DRIVER: + return "driver_to_{0}".format(win_type) + return "host_to_{0}".format(win_type) + else: + if not is_wrapped: + return "{0}_to_host".format(win_type) + if unwrap == Unwrap.NONE: + return "{0}_to_unwrapped_host".format(win_type) + if unwrap == Unwrap.DRIVER: + return "{0}_to_driver".format(win_type) + return "{0}_to_host".format(win_type) class XrBaseType(object): - def __init__(self, name, _type, text, alias=None, requires=None): - """ OpenXR base type class. + def __init__(self, name, _type, alias=None, requires=None): + """ Vulkan base type class. - XrBaseType is mostly used by OpenXR to define its own + XrBaseType is mostly used by Vulkan to define its own base types like XrFlags through typedef out of e.g. uint32_t. Args: @@ -250,12 +259,14 @@ class XrBaseType(object): self.alias = alias self.requires = requires self.required = False - self.text = text def definition(self): # Definition is similar for alias or non-alias as type # is already set to alias. - return self.text + "\n" + if not self.type is None: + return "typedef {0} {1};\n".format(self.type, self.name) + else: + return "struct {0};\n".format(self.name) def is_alias(self): return bool(self.alias) @@ -278,19 +289,20 @@ class XrDefine(object): @staticmethod def from_xml(define): + if not api_is_openxr(define): + return None + name_elem = define.find("name") if name_elem is None: # some_value - # At the time of writing there is only 1 define of this category - # 'XR_DEFINE_NON_DISPATCHABLE_HANDLE'. name = define.attrib.get("name") - # We override behavior of XR_DEFINE_NON_DISPATCHABLE handle as the default + # We override behavior of XR_USE_64_BIT_PTR_DEFINES as the default non-dispatchable handle # definition various between 64-bit (uses pointers) and 32-bit (uses uint64_t). # This complicates TRACEs in the thunks, so just use uint64_t. - if name == "XR_DEFINE_NON_DISPATCHABLE_HANDLE": - value = "#define XR_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;" + if name == "XR_USE_64_BIT_PTR_DEFINES": + value = "#define XR_USE_64_BIT_PTR_DEFINES 0" else: value = define.text return XrDefine(name, value) @@ -299,12 +311,12 @@ class XrDefine(object): # some_namesome_value name = name_elem.text - # Perform minimal parsing for constants, which we don't need, but are referenced + # Perform minimal parsing for Vulkan constants, which we don't need, but are referenced # elsewhere in xr.xml. # - XR_API_VERSION is a messy, deprecated constant and we don't want generate code for it. # - AHardwareBuffer/ANativeWindow are forward declarations for Android types, which leaked # into the define region. - if name in ["XR_API_VERSION", "ANativeWindow"]: + if name in ["XR_API_VERSION", "AHardwareBuffer", "ANativeWindow", "CAMetalLayer"]: return XrDefine(name, None) # The body of the define is basically unstructured C code. It is not meant for easy parsing. @@ -338,11 +350,13 @@ class XrDefine(object): def is_alias(self): return False - class XrEnum(object): - def __init__(self, name, values, alias=None): + def __init__(self, name, bitwidth, alias=None): + if not bitwidth in [32, 64]: + LOGGER.error("unknown bitwidth {0} for {1}".format(bitwidth, name)) self.name = name - self.values = values + self.bitwidth = bitwidth + self.values = [] if alias == None else alias.values self.required = False self.alias = alias self.aliased_by = [] @@ -350,42 +364,56 @@ class XrEnum(object): @staticmethod def from_alias(enum, alias): name = enum.attrib.get("name") - aliasee = XrEnum(name, alias.values, alias=alias) + aliasee = XrEnum(name, alias.bitwidth, alias=alias) alias.add_aliased_by(aliasee) return aliasee @staticmethod def from_xml(enum): + if not api_is_openxr(enum): + return None + name = enum.attrib.get("name") - values = [] + bitwidth = int(enum.attrib.get("bitwidth", "32")) + result = XrEnum(name, bitwidth) for v in enum.findall("enum"): + value_name = v.attrib.get("name") # Value is either a value or a bitpos, only one can exist. value = v.attrib.get("value") alias_name = v.attrib.get("alias") if alias_name: - alias = next(x for x in values if x.name == alias_name) - values.append(XrEnumValue(v.attrib.get("name"), value=alias.value, hex=alias.hex)) + result.create_alias(value_name, alias_name) elif value: - # Some values are in hex form. We want to preserve the hex representation - # at least when we convert back to a string. Internally we want to use int. - if "0x" in value: - values.append(XrEnumValue(v.attrib.get("name"), value=int(value, 0), hex=True)) - else: - values.append(XrEnumValue(v.attrib.get("name"), value=int(value, 0))) + result.create_value(value_name, value) else: # bitmask - value = 1 << int(v.attrib.get("bitpos")) - values.append(XrEnumValue(v.attrib.get("name"), value=value, hex=True)) + result.create_bitpos(value_name, int(v.attrib.get("bitpos"))) - # vulkan.h contains a *_MAX_ENUM value set to 32-bit at the time of writing, - # which is to prepare for extensions as they can add values and hence affect - # the size definition. - max_name = re.sub(r'([0-9a-z_])([A-Z0-9])',r'\1_\2', name).upper() + "_MAX_ENUM" - values.append(XrEnumValue(max_name, value=0x7fffffff, hex=True)) + if bitwidth == 32: + # openxr.h contains a *_MAX_ENUM value set to 32-bit at the time of writing, + # which is to prepare for extensions as they can add values and hence affect + # the size definition. + max_name = re.sub(r'([0-9a-z_])([A-Z0-9])',r'\1_\2', name).upper() + "_MAX_ENUM" + result.create_value(max_name, "0x7fffffff") - return XrEnum(name, values) + return result + + def create_alias(self, name, alias_name): + """ Create an aliased value for this enum """ + self.add(XrEnumValue(name, self.bitwidth, alias=alias_name)) + + def create_value(self, name, value): + """ Create a new value for this enum """ + # Some values are in hex form. We want to preserve the hex representation + # at least when we convert back to a string. Internally we want to use int. + hex = "0x" in value + self.add(XrEnumValue(name, self.bitwidth, value=int(value, 0), hex=hex)) + + def create_bitpos(self, name, pos): + """ Create a new bitmask value for this enum """ + self.add(XrEnumValue(name, self.bitwidth, value=(1 << pos), hex=True)) def add(self, value): """ Add a value to enum. """ @@ -402,17 +430,37 @@ class XrEnum(object): if not any(x.name == value.name for x in self.values): self.values.append(value) + def fixup_64bit_aliases(self): + """ Replace 64bit aliases with literal values """ + # Older GCC versions need a literal to initialize a static const uint64_t + # which is what we use for 64bit bitmasks. + if self.bitwidth != 64: + return + for value in self.values: + if not value.is_alias(): + continue + alias = next(x for x in self.values if x.name == value.alias) + value.hex = alias.hex + value.value = alias.value + def definition(self): if self.is_alias(): return "" - text = "typedef enum {0}\n{{\n".format(self.name) + default_value = 0x7ffffffe if self.bitwidth == 32 else 0xfffffffffffffffe # Print values sorted, values can have been added in a random order. - values = sorted(self.values, key=lambda value: value.value if value.value is not None else 0x7ffffffe) - for value in values: - text += " {0},\n".format(value.definition()) - text += "}} {0};\n".format(self.name) + values = sorted(self.values, key=lambda value: value.value if value.value is not None else default_value) + + if self.bitwidth == 32: + text = "typedef enum {0}\n{{\n".format(self.name) + for value in values: + text += " {0},\n".format(value.definition()) + text += "}} {0};\n".format(self.name) + elif self.bitwidth == 64: + text = "typedef XrFlags64 {0};\n\n".format(self.name) + for value in values: + text += "static const {0} {1};\n".format(self.name, value.definition()) for aliasee in self.aliased_by: text += "typedef {0} {1};\n".format(self.name, aliasee.name) @@ -428,54 +476,60 @@ class XrEnum(object): class XrEnumValue(object): - def __init__(self, name, value=None, hex=False, alias=None): + def __init__(self, name, bitwidth, value=None, hex=False, alias=None): self.name = name + self.bitwidth = bitwidth self.value = value self.hex = hex self.alias = alias def __repr__(self): - if self.is_alias(): + postfix = "ull" if self.bitwidth == 64 else "" + if self.is_alias() and self.value == None: return "{0}={1}".format(self.name, self.alias) - return "{0}={1}".format(self.name, self.value) + return "{0}={1}{2}".format(self.name, self.value, postfix) def definition(self): """ Convert to text definition e.g. XR_FOO = 1 """ - if self.is_alias(): + postfix = "ull" if self.bitwidth == 64 else "" + if self.is_alias() and self.value == None: return "{0} = {1}".format(self.name, self.alias) # Hex is commonly used for FlagBits and sometimes within # a non-FlagBits enum for a bitmask value as well. if self.hex: - return "{0} = 0x{1:08x}".format(self.name, self.value) + return "{0} = 0x{1:08x}{2}".format(self.name, self.value, postfix) else: - return "{0} = {1}".format(self.name, self.value) + return "{0} = {1}{2}".format(self.name, self.value, postfix) def is_alias(self): return self.alias is not None class XrFunction(object): - def __init__(self, _type=None, name=None, params=[], extensions=[], alias=None): - self.extensions = [] + def __init__(self, _type=None, name=None, params=[], alias=None): + self.extensions = set() self.name = name self.type = _type self.params = params self.alias = alias # For some functions we need some extra metadata from FUNCTION_OVERRIDES. - func_info = FUNCTION_OVERRIDES.get(self.name, None) - self.dispatch = func_info["dispatch"] if func_info else True - self.driver = func_info["driver"] if func_info else False - self.thunk_needed = func_info["thunk"] if func_info else True - self.private_thunk = func_info["private_thunk"] if func_info and "private_thunk" in func_info else False - if self.private_thunk: - self.thunk_needed = True + func_info = FUNCTION_OVERRIDES.get(self.name, {}) + self.dispatch = func_info.get("dispatch", True) + self.extra_param = func_info.get("extra_param", None) # Required is set while parsing which APIs and types are required # and is used by the code generation. self.required = True if func_info else False + if self.name in MANUAL_UNIX_THUNKS: + self.unwrap = Unwrap.NONE + elif self.name in USER_DRIVER_FUNCS: + self.unwrap = Unwrap.DRIVER + else: + self.unwrap = Unwrap.HOST + @staticmethod def from_alias(command, alias): """ Create XrFunction from an alias command. @@ -487,6 +541,9 @@ class XrFunction(object): Returns: XrFunction """ + if not api_is_openxr(command): + return None + func_name = command.attrib.get("name") func_type = alias.type params = alias.params @@ -495,14 +552,18 @@ class XrFunction(object): @staticmethod def from_xml(command, types): + if not api_is_openxr(command): + return None + proto = command.find("proto") func_name = proto.find("name").text func_type = proto.find("type").text params = [] for param in command.findall("param"): - xr_param = XrParam.from_xml(param, types) - params.append(xr_param) + xr_param = XrParam.from_xml(param, types, params) + if xr_param: + params.append(xr_param) return XrFunction(_type=func_type, name=func_name, params=params) @@ -515,25 +576,30 @@ class XrFunction(object): conversions = [] for param in self.params: - convs = param.get_conversions() - if convs is not None: - conversions.extend(convs) - + conversions.extend(param.get_conversions(self.unwrap)) return conversions def is_alias(self): return bool(self.alias) def is_core_func(self): - """ Returns whether the function is a core function. - Core functions are APIs defined by the spec to be part of the - Core API. + """ Returns whether the function is a Vulkan core function. + Core functions are APIs defined by the Vulkan spec to be part of the + Core API as well as several KHR WSI extensions. """ - return not self.extensions + + if not self.extensions: + return True + + return any(ext in self.extensions for ext in CORE_EXTENSIONS) + + def is_device_func(self): + # If none of the other, it must be a device function + return not self.is_global_func() and not self.is_instance_func() and not self.is_phys_dev_func() def is_driver_func(self): """ Returns if function is part of Wine driver interface. """ - return self.driver + return self.name in USER_DRIVER_FUNCS def is_global_func(self): # Treat xrGetInstanceProcAddr as a global function as it @@ -547,36 +613,40 @@ class XrFunction(object): def is_instance_func(self): # Instance functions are passed XrInstance. - if self.params[0].type in ["XrInstance"]: + if self.params[0].type == "XrInstance": + return True + return False + + def is_phys_dev_func(self): + # Physical device functions are passed XrPhysicalDevice. + if self.params[0].type == "XrPhysicalDevice": return True return False def is_required(self): return self.required - def needs_conversion(self): - """ Check if the function needs any input/output type conversion. - Functions need input/output conversion if struct parameters have - alignment differences between Win32 and Linux 32-bit. - """ - - for p in self.params: - if p.needs_conversion(): - LOGGER.debug("Parameter {0} to {1} requires conversion".format(p.name, self.name)) - return True - - return False + def returns_longlong(self): + return self.type in ["uint64_t", "XrDeviceAddress"] def needs_dispatch(self): return self.dispatch - def needs_thunk(self): - return self.thunk_needed - def needs_private_thunk(self): - return self.private_thunk + return self.needs_exposing() and self.name not in MANUAL_LOADER_FUNCTIONS and \ + self.name in MANUAL_UNIX_THUNKS - def pfn(self, prefix="p", call_conv=None, conv=False): + def needs_exposing(self): + # The function needs exposed if at-least one extension isn't both UNSUPPORTED and UNEXPOSED + return self.is_required() and (not self.extensions or not self.extensions.issubset(UNEXPOSED_EXTENSIONS)) + + def is_perf_critical(self): + # xrCmd* functions are frequently called, do not trace for performance + if self.name.startswith("xrCmd") and self.type == "void": + return True + return self.name in PERF_CRITICAL_FUNCTIONS + + def pfn(self, prefix="p", call_conv=None): """ Create function pointer. """ if call_conv: @@ -589,8 +659,6 @@ class XrFunction(object): pfn += param.const + " " pfn += param.type - if conv and param.needs_conversion(): - pfn += "_host" if param.is_pointer(): pfn += " " + param.pointer @@ -603,13 +671,12 @@ class XrFunction(object): pfn += ")" return pfn - def prototype(self, call_conv=None, prefix=None, postfix=None): + def prototype(self, call_conv=None, prefix=None, is_thunk=False): """ Generate prototype for given function. Args: call_conv (str, optional): calling convention e.g. WINAPI prefix (str, optional): prefix to append prior to function name e.g. xrFoo -> wine_xrFoo - postfix (str, optional): text to append after function name but prior to semicolon """ proto = "{0}".format(self.type) @@ -625,111 +692,153 @@ class XrFunction(object): # Add all the parameters. proto += ", ".join([p.definition() for p in self.params]) - if postfix is not None: - proto += ") {0}".format(postfix) - else: - proto += ")" + if is_thunk and self.extra_param: + extra_param_is_new = True + for p in self.params: + if p.name == self.extra_param: + extra_param_is_new = False + if extra_param_is_new: + proto += ", void *" + self.extra_param + else: + proto += ", void *win_" + self.extra_param + proto += ")" return proto - def body(self): - body = "" + def loader_body(self): + body = " struct {0}_params params;\n".format(self.name) + if not self.is_perf_critical(): + body += " NTSTATUS _status;\n" + for p in self.params: + body += " params.{0} = {0};\n".format(p.name) - if self.type != "void": - body += " {0} ret;\n\n".format(self.type) - if not self.needs_private_thunk(): - body += " {0}".format(self.trace()) - - params = ", ".join([p.variable(conv=False) for p in self.params]) - - # Call the native Vulkan function. - if self.is_core_func(): - # core functions are exported by the native loader, so avoid dispatch for those - if self.type == "void": - body += " {0}({1});\n".format(self.name, params) - else: - body += " ret = {0}({1});\n".format(self.name, params) + # Call the Unix function. + if self.is_perf_critical(): + body += " UNIX_CALL({0}, ¶ms);\n".format(self.name) else: - if self.type == "void": - body += " {0}.p_{1}({2});\n".format(self.params[0].dispatch_table(), self.name, params) - else: - body += " ret = {0}.p_{1}({2});\n".format(self.params[0].dispatch_table(), self.name, params) + body += " _status = UNIX_CALL({0}, ¶ms);\n".format(self.name) + body += " assert(!_status && \"{0}\");\n".format(self.name) - if "Destroy" in self.name: - for p in self.params: - if p.type in AUTO_MAPPED_HANDLES: - body += " unregister_dispatchable_handle((uint64_t){0});\n".format(p.name) - if "Create" in self.name: - for p in self.params: - if p.type in AUTO_MAPPED_HANDLES and p.is_pointer(): - body += " if (!ret) register_dispatchable_handle((uint64_t)*{0}, &({1}));\n".format(p.name, self.params[0].dispatch_table()) if self.type != "void": - body += " return ret;\n" + body += " return params.result;\n" return body - def body_conversion(self): + def body(self, conv, params_prefix=""): body = "" - - # Declare a variable to hold the result for non-void functions. - if self.type != "void": - body += " {0} result;\n".format(self.type) + needs_alloc = False + deferred_op = None # Declare any tmp parameters for conversion. for p in self.params: - if not p.needs_conversion(): - continue + if p.needs_variable(conv, self.unwrap): + if p.is_dynamic_array(): + body += " {2}{0} *{1}_host;\n".format( + p.type, p.name, "const " if p.is_const() else "") + elif p.optional: + body += " {0} *{1}_host = NULL;\n".format(p.type, p.name) + needs_alloc = True + else: + body += " {0} {1}_host;\n".format(p.type, p.name) + if p.needs_alloc(conv, self.unwrap): + needs_alloc = True + if p.type == "XrDeferredOperationKHR" and not p.is_pointer(): + deferred_op = p.name - if p.is_dynamic_array(): - body += " {0}_host *{1}_host;\n".format(p.type, p.name) - else: - body += " {0}_host {1}_host;\n".format(p.type, p.name) + if needs_alloc: + body += " struct conversion_context local_ctx;\n" + body += " struct conversion_context *ctx = &local_ctx;\n" + body += "\n" - if not self.needs_private_thunk(): - body += " {0}\n".format(self.trace()) + if not self.is_perf_critical(): + body += " {0}\n".format(self.trace(params_prefix=params_prefix, conv=conv)) + + if self.params[0].optional and self.params[0].is_handle(): + if self.type != "void": + LOGGER.warning("return type {0} with optional handle not supported".format(self.type)) + body += " if (!{0}{1})\n".format(params_prefix, self.params[0].name) + body += " return STATUS_SUCCESS;\n\n" + + if needs_alloc: + if deferred_op is not None: + body += " if (params->{} == XR_NULL_HANDLE)\n".format(deferred_op) + body += " " + body += " init_conversion_context(ctx);\n" + if deferred_op is not None: + body += " else\n" + body += " ctx = &wine_deferred_operation_from_handle(params->{})->ctx;\n".format(deferred_op) # Call any win_to_host conversion calls. + unwrap = self.name not in MANUAL_UNIX_THUNKS for p in self.params: - if not p.needs_input_conversion(): - continue - - body += p.copy(Direction.INPUT) + if p.needs_conversion(conv, self.unwrap, Direction.INPUT): + body += p.copy(Direction.INPUT, conv, self.unwrap, prefix=params_prefix) + elif p.is_dynamic_array() and p.needs_conversion(conv, self.unwrap, Direction.OUTPUT): + body += " {0}_host = ({2}{0} && {1}) ? conversion_context_alloc(ctx, sizeof(*{0}_host) * {1}) : NULL;\n".format( + p.name, p.get_dyn_array_len(params_prefix, conv), params_prefix) # Build list of parameters containing converted and non-converted parameters. # The param itself knows if conversion is needed and applies it when we set conv=True. - params = ", ".join([p.variable(conv=True) for p in self.params]) + unwrap = Unwrap.NONE if self.name in MANUAL_UNIX_THUNKS else self.unwrap + params = ", ".join([p.variable(conv, unwrap, params_prefix) for p in self.params]) + if self.extra_param: + if conv: + params += ", UlongToPtr({0}{1})".format(params_prefix, self.extra_param) + else: + params += ", (void *){0}{1}".format(params_prefix, self.extra_param) - # Call the native function. - if self.type == "void": - body += " {0}.p_{1}({2});\n".format(self.params[0].dispatch_table(), self.name, params) + if self.name not in MANUAL_UNIX_THUNKS: + func_prefix = "g_xr_host_instance_dispatch_table.p_" else: - body += " result = {0}.p_{1}({2});\n".format(self.params[0].dispatch_table(), self.name, params) + func_prefix = "wine_" - body += "\n" + # Call the host Vulkan function. + if self.type == "void": + body += " {0}{1}({2});\n".format(func_prefix, self.name, params) + else: + body += " {0}result = {1}{2}({3});\n".format(params_prefix, func_prefix, self.name, params) # Call any host_to_win conversion calls. for p in self.params: - if not p.needs_output_conversion(): - continue + if p.needs_conversion(conv, self.unwrap, Direction.OUTPUT): + body += p.copy(Direction.OUTPUT, conv, self.unwrap, prefix=params_prefix) - body += p.copy(Direction.OUTPUT) + if needs_alloc: + if deferred_op is not None: + body += " if (params->{} == XR_NULL_HANDLE)\n".format(deferred_op) + body += " " + body += " free_conversion_context(ctx);\n" - # Perform any required cleanups. Most of these are for array functions. - for p in self.params: - if not p.needs_free(): - continue - - body += p.free() - - # Finally return the result. - if self.type != "void": - body += " return result;\n" + # Finally return the result. Performance critical functions return void to allow tail calls. + if not self.is_perf_critical(): + body += " return STATUS_SUCCESS;\n" return body + def spec(self, prefix=None, symbol=None): + """ Generate spec file entry for this function. + + Args + prefix (str, optional): prefix to prepend to entry point name. + symbol (str, optional): allows overriding the name of the function implementing the entry point. + """ + + spec = "" + params = " ".join([p.spec() for p in self.params]) + if prefix is not None: + spec += "@ stdcall -private {0}{1}({2})".format(prefix, self.name, params) + else: + spec += "@ stdcall {0}({1})".format(self.name, params) + + if symbol is not None: + spec += " " + symbol + + spec += "\n" + return spec + def stub(self, call_conv=None, prefix=None): stub = self.prototype(call_conv=call_conv, prefix=prefix) stub += "\n{\n" - stub += " {0}".format(self.trace(message="stub: ", trace_func="WINE_FIXME")) + stub += " {0}".format(self.trace(message="stub: ", trace_func="FIXME")) if self.type == "XrResult": stub += " return XR_ERROR_OUT_OF_HOST_MEMORY;\n" @@ -741,23 +850,45 @@ class XrFunction(object): stub += "}\n\n" return stub - def thunk(self, call_conv=None, prefix=None): - thunk = self.prototype(call_conv=call_conv, prefix=prefix) - thunk += "\n{\n" - - if self.needs_conversion(): - thunk += "#if defined(USE_STRUCT_CONVERSION)\n" - thunk += self.body_conversion() - thunk += "#else\n" - thunk += self.body() - thunk += "#endif\n" + def thunk(self, prefix=None, conv=False): + thunk = "" + if not conv: + thunk += "#ifdef _WIN64\n" + if self.is_perf_critical(): + thunk += "static void {0}{1}(void *args)\n".format(prefix, self.name) else: - thunk += self.body() + thunk += "static NTSTATUS {0}{1}(void *args)\n".format(prefix, self.name) + thunk += "{\n" + if conv: + thunk += " struct\n" + thunk += " {\n" + extra_param_is_new = True + for p in self.params: + thunk += " {0};\n".format(p.definition(conv=True, is_member=True)) + if p.name == self.extra_param: + extra_param_is_new = False + if self.extra_param and extra_param_is_new: + thunk += " PTR32 {0};\n".format(self.extra_param) + if self.type != "void": + thunk += " {0} result;\n".format(self.type) + thunk += " } *params = args;\n" + else: + thunk += " struct {0}_params *params = args;\n".format(self.name) + thunk += self.body(conv, params_prefix="params->") + thunk += "}\n" + if not conv: + thunk += "#endif /* _WIN64 */\n" + thunk += "\n" + return thunk + def loader_thunk(self, prefix=None): + thunk = self.prototype(call_conv="WINAPI", prefix=prefix) + thunk += "\n{\n" + thunk += self.loader_body() thunk += "}\n\n" return thunk - def trace(self, message=None, trace_func=None): + def trace(self, message=None, trace_func=None, params_prefix="", conv=False): """ Create a trace string including all parameters. Args: @@ -767,32 +898,33 @@ class XrFunction(object): if trace_func is not None: trace = "{0}(\"".format(trace_func) else: - trace = "WINE_TRACE(\"" + trace = "TRACE(\"" if message is not None: trace += message # First loop is for all the format strings. - trace += ", ".join([p.format_string() for p in self.params]) + trace += ", ".join([p.format_string(conv) for p in self.params]) trace += "\\n\"" # Second loop for parameter names and optional conversions. for param in self.params: if param.format_conv is not None: - trace += ", " + param.format_conv.format(param.name) + trace += ", " + param.format_conv.format("{0}{1}".format(params_prefix, param.name)) else: - trace += ", {0}".format(param.name) + trace += ", {0}{1}".format(params_prefix, param.name) trace += ");\n" return trace class XrFunctionPointer(object): - def __init__(self, _type, name, members, params_text): + def __init__(self, _type, name, members, forward_decls, params_text): self.name = name self.members = members self.type = _type self.required = False + self.forward_decls = forward_decls self.params_text = params_text @staticmethod @@ -830,6 +962,10 @@ class XrFunctionPointer(object): _type = funcpointer.text name = funcpointer.find("name").text + if "requires" in funcpointer.attrib: + forward_decls = funcpointer.attrib.get("requires").split(",") + else: + forward_decls = [] params_text = None if members == []: index = 0 @@ -841,11 +977,20 @@ class XrFunctionPointer(object): if params_text: params_text = params_text[1:-1] break + + if name == "PFN_xrCreateApiLayerInstance": + forward_decls += ["XrInstanceCreateInfo"] - return XrFunctionPointer(_type, name, members, params_text) + + return XrFunctionPointer(_type, name, members, forward_decls, params_text) def definition(self): - text = "{0} {1})(\n".format(self.type, self.name) + text = "" + # forward declare required structs + for decl in self.forward_decls: + text += "typedef struct {0} {0};\n".format(decl) + + text += "{0} {1})(\n".format(self.type, self.name) first = True if len(self.members) > 0: @@ -863,6 +1008,8 @@ class XrFunctionPointer(object): text += ");\n" return text + def is_alias(self): + return False class XrHandle(object): def __init__(self, name, _type, parent, alias=None): @@ -871,6 +1018,7 @@ class XrHandle(object): self.parent = parent self.alias = alias self.required = False + self.object_type = None @staticmethod def from_alias(handle, alias): @@ -879,26 +1027,13 @@ class XrHandle(object): @staticmethod def from_xml(handle): - name = handle.find("name").text - _type = handle.find("type").text - parent = handle.attrib.get("parent") - return XrHandle(name, _type, parent) - - def dispatch_table(self): - if not self.is_dispatchable(): + if not api_is_openxr(handle): return None - if self.parent is None: - # Should only happen for XrInstance - return "funcs" - if self.parent in ["XrInstance"]: - return "wine_instance->funcs" - if self.parent in ["XrSession"]: - return "wine_session->wine_instance->funcs" - if self.parent in ["XrActionSet"]: - return "wine_action_set->wine_instance->funcs" - - LOGGER.error("Unhandled dispatchable parent: {0}".format(self.parent)) + name = handle.find("name").text + _type = handle.find("type").text + parent = handle.attrib.get("parent") # Most objects have a parent e.g. XrQueue has XrDevice. + return XrHandle(name, _type, parent) def definition(self): """ Generates handle definition e.g. XR_DEFINE_HANDLE(xrInstance) """ @@ -913,7 +1048,7 @@ class XrHandle(object): return self.alias is not None def is_dispatchable(self): - """ Some handles, like XrInstance, are dispatchable objects, + """ Some handles like XrInstance, XrDevice are dispatchable objects, which means they contain a dispatch table of function pointers. """ return self.type == "XR_DEFINE_HANDLE" @@ -921,69 +1056,291 @@ class XrHandle(object): def is_required(self): return self.required - def native_handle(self, name): - """ Provide access to the native handle of a wrapped object. """ - - # Remember to add any new native handle whose parent is XrDevice - # to unwrap_object_handle() in openxr.c - if self.name == "XrCommandPool": - return "wine_cmd_pool_from_handle({0})->command_pool".format(name) - - native_handle_name = None - - if self.name in AUTO_MAPPED_HANDLES: - return None - + def host_handle(self, name): + """ Provide access to the host handle of a wrapped object. """ if self.name == "XrInstance": - native_handle_name = "instance" + return "wine_instance_from_handle({0})->host_instance".format(name) if self.name == "XrSession": - native_handle_name = "session" + return "wine_session_from_handle({0})->host_session".format(name) if self.name == "XrSwapchain": - native_handle_name = "swapchain" - if self.name == "XrActionSet": - return None - if self.name == "XrAction": - return None + return "wine_swapchain_from_handle({0})->host_swapchain".format(name) - if native_handle_name: - return "((wine_{0} *){1})->{2}".format(self.name, name, native_handle_name) - - if self.is_dispatchable(): - LOGGER.error("Unhandled native handle for: {0}".format(self.name)) return None + def driver_handle(self, name): + """ Provide access to the handle that should be passed to the wine driver """ + return self.host_handle(name) -class XrMember(object): - def __init__(self, const=False, struct_fwd_decl=False,_type=None, pointer=None, name=None, array_len=None, - dyn_array_len=None, optional=False, values=None): + def unwrap_handle(self, name, unwrap): + if unwrap == Unwrap.DRIVER: + return self.driver_handle(name) + if unwrap == Unwrap.HOST: + return self.host_handle(name) + if unwrap == Unwrap.NONE: + return name + return None + + def is_wrapped(self): + return self.host_handle("test") is not None + + +class XrVariable(object): + def __init__(self, const=False, type_info=None, type=None, name=None, pointer=None, array_len=None, + dyn_array_len=None, object_type=None, optional=False, returnedonly=False, parent=None, + selection=None, selector=None): self.const = const - self.struct_fwd_decl = struct_fwd_decl + self.type_info = type_info + self.type = type self.name = name + self.parent = parent + self.object_type = object_type + self.optional = optional + self.returnedonly = returnedonly + self.selection = selection + self.selector = selector + self.pointer = pointer - self.type = _type - self.type_info = None self.array_len = array_len self.dyn_array_len = dyn_array_len - self.optional = optional - self.values = values + self.pointer_array = False + if isinstance(dyn_array_len, str): + i = dyn_array_len.find(",") + if i != -1: + self.dyn_array_len = dyn_array_len[0:i] + self.pointer_array = True + + if type_info: + self.set_type_info(type_info) def __eq__(self, other): - """ Compare member based on name against a string. + """ Compare member based on name against a string. """ + return self.name == other - This method is for convenience by XrStruct, which holds a number of members and needs quick checking - if certain members exist. + def set_type_info(self, type_info): + """ Helper function to set type information from the type registry. + This is needed, because not all type data is available at time of + parsing. + """ + self.type_info = type_info + self.handle = type_info["data"] if type_info["category"] == "handle" else None + self.struct = type_info["data"] if type_info["category"] == "struct" or type_info["category"] == "union" else None + + def get_dyn_array_len(self, prefix, conv): + if isinstance(self.dyn_array_len, int): + return self.dyn_array_len + + len_str = self.dyn_array_len + parent = self.parent + len = prefix + + # check if length is a member of another struct (for example pAllocateInfo->commandBufferCount) + i = len_str.find("->") + if i != -1: + var = parent[parent.index(len_str[0:i])] + len_str = len_str[i+2:] + len = "({0})->".format(var.value(len, conv)) + parent = var.struct + + if len_str in parent: + var = parent[parent.index(len_str)] + len = var.value(len, conv); + if var.is_pointer(): + len = "*" + len + else: + len += len_str + + if isinstance(self.parent, XrStruct) and self.parent.name in MEMBER_LENGTH_EXPRESSIONS: + exprs = MEMBER_LENGTH_EXPRESSIONS[self.parent.name] + if self.name in exprs: + len = exprs[self.name].format(struct=prefix, len=len) + + return len + + def is_const(self): + return self.const + + def is_pointer(self): + return self.pointer is not None + + def is_pointer_size(self): + if self.type in ["size_t", "HWND", "HINSTANCE"]: + return True + if self.is_handle() and self.handle.is_dispatchable(): + return True + return False + + def is_handle(self): + return self.handle is not None + + def is_struct(self): + return self.type_info["category"] == "struct" + + def is_union(self): + return self.type_info["category"] == "union" + + def is_bitmask(self): + return self.type_info["category"] == "bitmask" + + def is_enum(self): + return self.type_info["category"] == "enum" + + def is_dynamic_array(self): + """ Returns if the member is an array element. + Vulkan uses this for dynamically sized arrays for which + there is a 'count' parameter. + """ + return self.dyn_array_len is not None and self.array_len is None + + def is_static_array(self): + """ Returns if the member is an array. + Vulkan uses this often for fixed size arrays in which the + length is part of the member. + """ + return self.array_len is not None + + def is_generic_handle(self): + """ Returns True if the member is a unit64_t containing + a handle with a separate object type + """ + return self.object_type != None and self.type == "uint64_t" + + def needs_alignment(self): + """ Check if this member needs alignment for 64-bit data. + Various structures need alignment on 64-bit variables due + to compiler differences on 32-bit between Win32 and Linux. """ - return self.name == other + if self.is_pointer(): + return False + elif self.type == "size_t": + return False + elif self.type in ["uint64_t", "XrDeviceAddress", "XrDeviceSize"]: + return True + elif self.is_bitmask(): + return self.type_info["data"].type == "XrFlags64" + elif self.is_enum(): + return self.type_info["data"].bitwidth == 64 + elif self.is_struct() or self.is_union(): + return self.type_info["data"].needs_alignment() + elif self.is_handle(): + # Dispatchable handles are pointers to objects, while + # non-dispatchable are uint64_t and hence need alignment. + return not self.handle.is_dispatchable() + return False + + def is_wrapped(self): + """ Returns if variable needs unwrapping of handle. """ + + if self.is_struct(): + return self.struct.is_wrapped() + + if self.is_handle(): + return self.handle.is_wrapped() + + if self.is_generic_handle(): + return True + + return False + + def needs_alloc(self, conv, unwrap): + """ Returns True if conversion needs allocation """ + if self.is_dynamic_array(): + return self.needs_conversion(conv, unwrap, Direction.INPUT, False) \ + or self.needs_conversion(conv, unwrap, Direction.OUTPUT, False) + + return (self.is_struct() or (self.is_union() and self.selector)) and self.struct.needs_alloc(conv, unwrap) + + def needs_win32_type(self): + return (self.is_struct() or (self.is_union() and self.selector)) and self.struct.needs_win32_type() + + def get_conversions(self, unwrap, parent_const=False): + """ Get a list of conversions required for this parameter if any. + Parameters which are structures may require conversion between win32 + and the host platform. This function returns a list of conversions + required. + """ + + conversions = [] + + # Collect any member conversions first, so we can guarantee + # those functions will be defined prior to usage by the + # 'parent' param requiring conversion. + if self.is_struct() or (self.is_union() and self.selector): + struct = self.struct + is_const = self.is_const() if self.is_pointer() else parent_const + + conversions.extend(struct.get_conversions(unwrap, is_const)) + + for conv in [False]: + if struct.needs_conversion(conv, unwrap, Direction.INPUT, is_const): + conversions.append(StructConversionFunction(struct, Direction.INPUT, conv, unwrap, is_const)) + if struct.needs_conversion(conv, unwrap, Direction.OUTPUT, is_const): + conversions.append(StructConversionFunction(struct, Direction.OUTPUT, conv, unwrap, is_const)) + + if struct.name in STRUCT_COPY: + conversions.append(StructConversionFunction(struct, Direction.INPUT, False, unwrap, is_const, True)) + + if self.is_static_array() or self.is_dynamic_array(): + for conv in [False]: + if self.needs_conversion(conv, unwrap, Direction.INPUT, parent_const): + conversions.append(ArrayConversionFunction(self, Direction.INPUT, conv, unwrap)) + if self.needs_conversion(conv, unwrap, Direction.OUTPUT, parent_const): + conversions.append(ArrayConversionFunction(self, Direction.OUTPUT, conv, unwrap)) + + return conversions + + def needs_ptr32_type(self): + """ Check if variable needs to use PTR32 type. """ + + return self.is_pointer() or self.is_pointer_size() or self.is_static_array() + + def value(self, prefix, conv): + """ Returns code accessing member value, casting 32-bit pointers when needed. """ + + if not conv or not self.needs_ptr32_type() or (not self.is_pointer() and self.type == "size_t"): + return prefix + self.name + + cast_type = "" + if self.const: + cast_type += "const " + + if self.pointer_array or ((self.is_pointer() or self.is_static_array()) and self.is_pointer_size()): + cast_type += "PTR32 *" + else: + cast_type += self.type + if self.needs_win32_type(): + cast_type += "32" + + if self.is_pointer(): + cast_type += " {0}".format(self.pointer) + elif self.is_static_array(): + cast_type += " *" + + return "({0})UlongToPtr({1}{2})".format(cast_type, prefix, self.name) + + +class XrMember(XrVariable): + def __init__(self, const=False, struct_fwd_decl=False,_type=None, pointer=None, name=None, array_len=None, + dyn_array_len=None, optional=False, values=None, object_type=None, bit_width=None, + returnedonly=False, parent=None, selection=None, selector=None): + XrVariable.__init__(self, const=const, type=_type, name=name, pointer=pointer, array_len=array_len, + dyn_array_len=dyn_array_len, object_type=object_type, optional=optional, + returnedonly=returnedonly, parent=parent, selection=selection, selector=selector) + self.struct_fwd_decl = struct_fwd_decl + self.values = values + self.bit_width = bit_width def __repr__(self): return "{0} {1} {2} {3} {4} {5} {6}".format(self.const, self.struct_fwd_decl, self.type, self.pointer, self.name, self.array_len, self.dyn_array_len) @staticmethod - def from_xml(member): + def from_xml(member, returnedonly, parent): """ Helper function for parsing a member tag within a struct or union. """ + if not api_is_openxr(member): + return None + name_elem = member.find("name") type_elem = member.find("type") @@ -992,6 +1349,7 @@ class XrMember(object): member_type = None pointer = None array_len = None + bit_width = None values = member.get("values") @@ -1035,36 +1393,87 @@ class XrMember(object): # Remove brackets around length array_len = name_elem.tail.strip("[]") - return XrMember(const=const, struct_fwd_decl=struct_fwd_decl, _type=member_type, pointer=pointer, name=name_elem.text, - array_len=array_len, dyn_array_len=dyn_array_len, optional=optional, values=values) + object_type = member.get("objecttype", None) - def copy(self, input, output, direction): - """ Helper method for use by conversion logic to generate a C-code statement to copy this member. """ + # Some members are bit field values: + # uint32_t mask:8 + if name_elem.tail and name_elem.tail[0] == ':': + LOGGER.debug("Found bit field") + bit_width = int(name_elem.tail[1:]) - if self.needs_conversion(): + selection = member.get("selection").split(',') if member.get("selection") else None + selector = member.get("selector", None) + + return XrMember(const=const, struct_fwd_decl=struct_fwd_decl, _type=member_type, pointer=pointer, + name=name_elem.text, array_len=array_len, dyn_array_len=dyn_array_len, optional=optional, + values=values, object_type=object_type, bit_width=bit_width, returnedonly=returnedonly, + parent=parent, selection=selection, selector=selector) + + def copy(self, input, output, direction, conv, unwrap, copy): + """ Helper method for use by conversion logic to generate a C-code statement to copy this member. + - `conv` indicates whether the statement is in a struct alignment conversion path. """ + + win_type = "win32" if conv else "win64" + suffix = convert_suffix(direction, win_type, unwrap, self.is_wrapped()) + + if self.needs_conversion(conv, unwrap, direction, False): if self.is_dynamic_array(): + # Array length is either a variable name (string) or an int. + count = self.get_dyn_array_len(input, conv) + pointer_part = "pointer_" if self.pointer_array else "" if direction == Direction.OUTPUT: - LOGGER.warn("TODO: implement copying of returnedonly dynamic array for {0}.{1}".format(self.type, self.name)) + return "convert_{2}_{6}array_{5}({3}{1}, {0}, {4});\n".format(self.value(output, conv), + self.name, self.type, input, count, suffix, pointer_part) else: - # Array length is either a variable name (string) or an int. - count = self.dyn_array_len if isinstance(self.dyn_array_len, int) else "{0}{1}".format(input, self.dyn_array_len) - return "{0}{1} = convert_{2}_array_win_to_host({3}{1}, {4});\n".format(output, self.name, self.type, input, count) + return "{0}{1} = convert_{2}_{6}array_{5}(ctx, {3}, {4});\n".format(output, + self.name, self.type, self.value(input, conv), count, suffix, pointer_part) elif self.is_static_array(): count = self.array_len if direction == Direction.OUTPUT: # Needed by XrMemoryHeap.memoryHeaps - return "convert_{0}_static_array_host_to_win({2}{1}, {3}{1}, {4});\n".format(self.type, self.name, input, output, count) + return "convert_{0}_array_{5}({2}{1}, {3}{1}, {4});\n".format(self.type, + self.name, input, output, count, suffix) else: # Nothing needed this yet. LOGGER.warn("TODO: implement copying of static array for {0}.{1}".format(self.type, self.name)) - else: + elif self.is_handle() and self.is_wrapped(): + handle = self.type_info["data"] if direction == Direction.OUTPUT: - return "convert_{0}_host_to_win(&{2}{1}, &{3}{1});\n".format(self.type, self.name, input, output) + LOGGER.error("OUTPUT parameter {0}.{1} cannot be unwrapped".format(self.type, self.name)) + elif self.optional: + return "{0}{1} = {2} ? {3} : 0;\n".format(output, self.name, self.value(input, conv), + handle.unwrap_handle(self.value(input, conv), unwrap)) else: - return "convert_{0}_win_to_host(&{2}{1}, &{3}{1});\n".format(self.type, self.name, input, output) + input_name = "{0}{1}".format(input, self.name) + return "{0}{1} = {2} ? {3} : XR_NULL_HANDLE;\n".format(output, self.name, + input_name, handle.unwrap_handle(self.value(input, conv), unwrap)) + elif self.is_generic_handle(): + if direction == Direction.OUTPUT: + LOGGER.error("OUTPUT parameter {0}.{1} cannot be unwrapped".format(self.type, self.name)) + if unwrap == Unwrap.DRIVER and self.is_wrapped(Unwrap.DRIVER): + LOGGER.error("DRIVER unwrapping of {0}.{1} not implemented".format(self.type, self.name)) + return "{0}{1} = wine_xr_unwrap_handle({2}{3}, {2}{1});\n".format(output, self.name, input, self.object_type) + else: + selector_part = ", {0}{1}".format(input, self.selector) if self.selector else "" + if direction == Direction.OUTPUT: + return "convert_{0}_{4}(&{2}{1}, &{3}{1}{5});\n".format(self.type, + self.name, input, output, suffix, selector_part) + else: + ctx_param = "ctx, " if self.needs_alloc(conv, unwrap) else "" + return "convert_{0}_{4}({5}&{2}{1}, &{3}{1}{6});\n".format(self.type, + self.name, input, output, suffix, ctx_param, selector_part) elif self.is_static_array(): bytes_count = "{0} * sizeof({1})".format(self.array_len, self.type) return "memcpy({0}{1}, {2}{1}, {3});\n".format(output, self.name, input, bytes_count) + elif self.is_dynamic_array() and copy: + if self.type == "void": + return "MEMDUP_VOID(ctx, {0}{1}, {2}{1}, {3});\n".format(output, self.name, input, self.get_dyn_array_len(input, conv)) + else: + return "MEMDUP(ctx, {0}{1}, {2}{1}, {3});\n".format(output, self.name, input, self.get_dyn_array_len(input, conv)) + elif direction == Direction.INPUT: + return "{0}{1} = {2};\n".format(output, self.name, self.value(input, conv)) + elif conv and direction == Direction.OUTPUT and self.is_pointer(): + return "{0}{1} = PtrToUlong({2}{1});\n".format(output, self.name, input) else: return "{0}{1} = {2}{1};\n".format(output, self.name, input) @@ -1076,6 +1485,12 @@ class XrMember(object): conv (bool, optional): Enable conversion if a type needs it. This appends '_host' to the name. """ + if conv and (self.is_pointer() or self.is_pointer_size()): + text = "PTR32 " + self.name + if self.is_static_array(): + text += "[{0}]".format(self.array_len) + return text + text = "" if self.is_const(): text += "const " @@ -1083,171 +1498,97 @@ class XrMember(object): if self.is_struct_forward_declaration(): text += "struct " - if conv and self.is_struct(): - text += "{0}_host".format(self.type) - else: - text += self.type + text += self.type + if conv and self.needs_win32_type(): + text += "32" if self.is_pointer(): text += " {0}{1}".format(self.pointer, self.name) else: if align and self.needs_alignment(): - text += " WINE_XR_ALIGN(8) " + self.name + if conv: + text += " DECLSPEC_ALIGN(8) " + self.name + else: + text += " WINE_XR_ALIGN(8) " + self.name else: text += " " + self.name if self.is_static_array(): text += "[{0}]".format(self.array_len) + if self.is_bit_field(): + text += ":{}".format(self.bit_width) + return text - def get_conversions(self): - """ Return any conversion description for this member and its children when conversion is needed. """ - - # Check if we need conversion either for this member itself or for any child members - # in case member represents a struct. - if not self.needs_conversion(): - return None - - conversions = [] - - # Collect any conversion for any member structs. - struct = self.type_info["data"] - for m in struct: - m.needs_struct_extensions_conversion() - if m.needs_conversion(): - conversions.extend(m.get_conversions()) - - struct.needs_struct_extensions_conversion() - - struct = self.type_info["data"] - direction = Direction.OUTPUT if struct.returnedonly else Direction.INPUT - if self.is_dynamic_array(): - conversions.append(ConversionFunction(False, True, direction, struct)) - elif self.is_static_array(): - conversions.append(ConversionFunction(True, False, direction, struct)) - else: - conversions.append(ConversionFunction(False, False, direction, struct)) - - if self.needs_free(): - conversions.append(FreeFunction(self.is_dynamic_array(), struct)) - - return conversions - - def is_const(self): - return self.const - - def is_dynamic_array(self): - """ Returns if the member is an array element. - OpenXR uses this for dynamically sized arrays for which - there is a 'count' parameter. - """ - return self.dyn_array_len is not None - - def is_handle(self): - return self.type_info["category"] == "handle" - - def is_pointer(self): - return self.pointer is not None - - def is_static_array(self): - """ Returns if the member is an array. - OpenXR uses this often for fixed size arrays in which the - length is part of the member. - """ - return self.array_len is not None - - def is_struct(self): - return self.type_info["category"] == "struct" - def is_struct_forward_declaration(self): return self.struct_fwd_decl - def is_union(self): - return self.type_info["category"] == "union" + def is_bit_field(self): + return self.bit_width is not None - def needs_alignment(self): - """ Check if this member needs alignment for 64-bit data. - Various structures need alignment on 64-bit variables due - to compiler differences on 32-bit between Win32 and Linux. - """ + def needs_conversion(self, conv, unwrap, direction, struct_const): + """ Check if member needs conversion. """ - if self.is_pointer(): - return False - elif self.type == "size_t": - return False - elif self.type in ["uint64_t"]: - return True - elif self.is_struct(): - struct = self.type_info["data"] - return struct.needs_alignment() - elif self.is_handle(): - # Dispatchable handles are pointers to objects, while - # non-dispatchable are uint64_t and hence need alignment. - handle = self.type_info["data"] - return False if handle.is_dispatchable() else True - return False - - def needs_conversion(self): - """ Structures requiring alignment, need conversion between win32 and host. """ - - if not self.is_struct(): + # we can't convert unions if we don't have a selector + if self.is_union() and not self.selector: return False - struct = self.type_info["data"] - return struct.needs_conversion() + is_const = self.is_const() if self.is_pointer() else struct_const - def needs_free(self): - if not self.needs_conversion(): + # const members don't needs output conversion unless they are structs with non-const pointers + if direction == Direction.OUTPUT and is_const and not self.is_struct(): return False - if self.is_dynamic_array(): + if direction == Direction.INPUT: + # returnedonly members don't needs input conversions + if not self.is_pointer() and self.returnedonly: + return False + # pointer arrays always need input conversion + if conv and self.is_dynamic_array() and self.pointer_array: + return True + + if self.is_handle(): + if unwrap != Unwrap.NONE and self.handle.is_wrapped(): + return True + if conv and self.handle.is_dispatchable(): + return True + elif self.is_generic_handle(): + if unwrap != Unwrap.NONE: + return True + elif self.is_struct() or self.is_union(): + if self.struct.needs_conversion(conv, unwrap, direction, is_const): + return True + + # if pointer member needs output conversion, it also needs input conversion + # to allocate the pointer + if direction == Direction.INPUT and self.is_pointer() and \ + self.needs_conversion(conv, unwrap, Direction.OUTPUT, struct_const): return True - # TODO: some non-pointer structs and optional pointer structs may need freeing, - # though none of this type have been encountered yet. return False - def needs_struct_extensions_conversion(self): - if not self.is_struct(): - return False - - struct = self.type_info["data"] - return struct.needs_struct_extensions_conversion() - - def set_type_info(self, type_info): - """ Helper function to set type information from the type registry. - This is needed, because not all type data is available at time of - parsing. - """ - self.type_info = type_info - - -class XrParam(object): +class XrParam(XrVariable): """ Helper class which describes a parameter to a function call. """ - def __init__(self, type_info, const=None, pointer=None, name=None, array_len=None, dyn_array_len=None): - self.const = const - self.name = name - self.array_len = array_len - self.dyn_array_len = dyn_array_len - self.pointer = pointer - self.type_info = type_info - self.type = type_info["name"] # For convenience - self.handle = type_info["data"] if type_info["category"] == "handle" else None - self.struct = type_info["data"] if type_info["category"] == "struct" else None + def __init__(self, type_info, const=None, pointer=None, name=None, parent=None, array_len=None, + dyn_array_len=None, object_type=None, optional=False): + XrVariable.__init__(self, const=const, type_info=type_info, type=type_info["name"], name=name, + pointer=pointer, array_len=array_len, dyn_array_len=dyn_array_len, + object_type=object_type, optional=optional, parent=parent) - self._set_direction() self._set_format_string() - self._set_conversions() def __repr__(self): return "{0} {1} {2} {3} {4} {5}".format(self.const, self.type, self.pointer, self.name, self.array_len, self.dyn_array_len) @staticmethod - def from_xml(param, types): + def from_xml(param, types, parent): """ Helper function to create XrParam from xml. """ + if not api_is_openxr(param): + return None + # Parameter parsing is slightly tricky. All the data is contained within # a param tag, but some data is within subtags while others are text # before or after the type tag. @@ -1269,65 +1610,20 @@ class XrParam(object): type_elem = param.find("type") pointer = type_elem.tail.strip() if type_elem.tail.strip() != "" else None + attr = param.get("optional") + optional = attr and attr.startswith("true") + + # Some uint64_t are actually handles with a separate type param + object_type = param.get("objecttype", None) + # Since we have parsed all types before hand, this should not happen. type_info = types.get(type_elem.text, None) if type_info is None: - LOGGER.err("type info not found for: {0}".format(type_elem.text)) + LOGGER.error("type info not found for: {0}".format(type_elem.text)) - return XrParam(type_info, const=const, pointer=pointer, name=name, array_len=array_len, dyn_array_len=dyn_array_len) - - def _set_conversions(self): - """ Internal helper function to configure any needed conversion functions. """ - - self.free_func = None - self.input_conv = None - self.output_conv = None - if not self.needs_conversion(): - return - - # Input functions require win to host conversion. - if self._direction in [Direction.INPUT, Direction.INPUT_OUTPUT]: - self.input_conv = ConversionFunction(False, self.is_dynamic_array(), Direction.INPUT, self.struct) - - # Output functions require host to win conversion. - if self._direction in [Direction.INPUT_OUTPUT, Direction.OUTPUT]: - self.output_conv = ConversionFunction(False, self.is_dynamic_array(), Direction.OUTPUT, self.struct) - - # Dynamic arrays, but also some normal structs (e.g. XrCommandBufferBeginInfo) need memory - # allocation and thus some cleanup. - if self.is_dynamic_array() or self.struct.needs_free(): - self.free_func = FreeFunction(self.is_dynamic_array(), self.struct) - - def _set_direction(self): - """ Internal helper function to set parameter direction (input/output/input_output). """ - - # The parameter direction needs to be determined from hints in xr.xml like returnedonly, - # parameter constness and other heuristics. - # For now we need to get this right for structures as we need to convert these, we may have - # missed a few other edge cases (e.g. count variables). - # See also https://github.com/KhronosGroup/Vulkan-Docs/issues/610 - - if not self.is_pointer(): - self._direction = Direction.INPUT - elif self.is_const() and self.is_pointer(): - self._direction = Direction.INPUT - elif self.is_struct(): - if not self.struct.returnedonly: - self._direction = Direction.INPUT - return - - # Returnedonly hints towards output, however in some cases - # it is inputoutput. In particular if next / type exist, - # which are used to link in other structures without having - # to introduce new APIs. E.g. xrGetPhysicalDeviceProperties2KHR. - if "next" in self.struct: - self._direction = Direction.INPUT_OUTPUT - return - - self._direction = Direction.OUTPUT - else: - # This should mostly be right. Count variables can be inout, but we don't care about these yet. - self._direction = Direction.OUTPUT + return XrParam(type_info, const=const, pointer=pointer, name=name, array_len=array_len, + dyn_array_len=dyn_array_len, object_type=object_type, optional=optional, + parent=parent) def _set_format_string(self): """ Internal helper function to be used by constructor to set format string. """ @@ -1338,7 +1634,14 @@ class XrParam(object): if self.is_static_array() or self.is_pointer(): self.format_str = "%p" else: - if self.type_info["category"] in ["bitmask", "enum"]: + if self.type_info["category"] in ["bitmask"]: + # Since 1.2.170 bitmasks can be 32 or 64-bit, check the basetype. + if self.type_info["data"].type == "XrFlags64": + self.format_str = "0x%s" + self.format_conv = "wine_dbgstr_longlong({0})" + else: + self.format_str = "%#x" + elif self.type_info["category"] in ["enum"]: self.format_str = "%#x" elif self.is_handle(): # We use uint64_t for non-dispatchable handles as opposed to pointers @@ -1362,7 +1665,7 @@ class XrParam(object): elif self.type in ["uint64_t","XrAsyncRequestIdFB"]: self.format_str = "0x%s" self.format_conv = "wine_dbgstr_longlong({0})" - elif self.type == "HANDLE": + elif self.type in ["HANDLE", "VkInstance"]: self.format_str = "%p" elif self.type in ["XrSystemId", "XrPath", "XrTime", "XrDuration", "XrControllerModelKeyMSFT", "XrMarkerML"]: self.format_str = "0x%s" @@ -1373,172 +1676,157 @@ class XrParam(object): elif self.type in ["XrPosef"]: self.format_str = "{{%f, %f, %f, %f}, {%f %f %f}}" self.format_conv = "{0}.orientation.x, {0}.orientation.y, {0}.orientation.z, {0}.orientation.w, {0}.position.x, {0}.position.y, {0}.position.z" - elif self.type in ["VisualID", "xcb_visualid_t", "VkInstance"]: - # Don't care about Linux specific types. + elif self.type in ["VisualID", "xcb_visualid_t"]: + # Don't care about specific types for non-Windows platforms. self.format_str = "" else: - LOGGER.warning("Unhandled type: {0}".format(self.type_info)) + LOGGER.warn("Unhandled type: {0}".format(self.type_info)) + + def copy(self, direction, conv, unwrap, prefix=""): + win_type = "win32" if conv else "win64" + suffix = convert_suffix(direction, win_type, unwrap, self.is_wrapped()) - def copy(self, direction): if direction == Direction.INPUT: + ctx_param = "ctx, " if self.needs_alloc(conv, unwrap) else "" if self.is_dynamic_array(): - return " {0}_host = convert_{1}_array_win_to_host({0}, {2});\n".format(self.name, self.type, self.dyn_array_len) + return " {0}_host = convert_{2}_array_{4}({5}{1}, {3});\n".format(self.name, self.value(prefix, conv), + self.type, self.get_dyn_array_len(prefix, conv), suffix, ctx_param) + elif self.optional: + ret = " if ({0}{1})\n".format(prefix, self.name) + ret += " {\n" + ret += " {0}_host = conversion_context_alloc(ctx, sizeof(*{0}_host));\n".format(self.name) + ret += " convert_{0}_{3}({4}{1}, {2}_host);\n".format(self.type, self.value(prefix, conv), + self.name, suffix, ctx_param) + ret += " }\n" + return ret + elif self.is_struct(): + return " convert_{0}_{3}({4}{1}, &{2}_host);\n".format(self.type, self.value(prefix, conv), + self.name, suffix, ctx_param) + elif self.is_pointer_size() and self.type != "size_t": + return " {0}_host = UlongToPtr(*{1});\n".format(self.name, self.value(prefix, conv)) else: - return " convert_{0}_win_to_host({1}, &{1}_host);\n".format(self.type, self.name) + return " {0}_host = *{1};\n".format(self.name, self.value(prefix, conv)) else: if self.is_dynamic_array(): - LOGGER.error("Unimplemented output conversion for: {0}".format(self.name)) + return " convert_{0}_array_{1}({2}_host, {3}, {4});\n".format( + self.type, suffix, self.name, self.value(prefix, conv), + self.get_dyn_array_len(prefix, conv)) + elif self.is_struct(): + ref_part = "" if self.optional else "&" + return " convert_{0}_host_to_{3}({4}{2}_host, {1});\n".format( + self.type, self.value(prefix, conv), self.name, win_type, ref_part) + elif self.is_pointer_size() and self.type != "size_t": + return " *{0} = PtrToUlong({1}_host);\n".format(self.value(prefix, conv), self.name) else: - return " convert_{0}_host_to_win(&{1}_host, {1});\n".format(self.type, self.name) + return " *{0} = {1}_host;\n".format(self.value(prefix, conv), self.name) - def definition(self, postfix=None): + def definition(self, postfix=None, is_member=False, conv=False): """ Return prototype for the parameter. E.g. 'const char *foo' """ + if is_member and conv and self.needs_ptr32_type(): + return "PTR32 {0}".format(self.name) + proto = "" - if self.const: + if self.const and (not is_member or self.pointer): proto += self.const + " " proto += self.type + name = self.name + if conv and self.needs_win32_type(): + proto += "32" + + if is_member and self.needs_alignment(): + proto += " DECLSPEC_ALIGN(8)" if self.is_pointer(): - proto += " {0}{1}".format(self.pointer, self.name) + proto += " {0}{1}".format(self.pointer, name) + elif is_member and self.is_static_array(): + proto += " *" + name else: - proto += " " + self.name + proto += " " + name # Allows appending something to the variable name useful for # win32 to host conversion. if postfix is not None: proto += postfix - if self.is_static_array(): + if not is_member and self.is_static_array(): proto += "[{0}]".format(self.array_len) return proto - def direction(self): - """ Returns parameter direction: input, output, input_output. - - Parameter direction in OpenXR is not straight-forward, which this function determines. - """ - - return self._direction - - def dispatch_table(self): - """ Return functions dispatch table pointer for dispatchable objects. """ - - if not self.is_dispatchable(): - return None - - if self.type in AUTO_MAPPED_HANDLES: - return "(*get_dispatch_table((uint64_t)({0})))".format(self.name) - else: - return "((wine_{0} *){1})->{2}".format(self.type, self.name, self.handle.dispatch_table()) - - def format_string(self): + def format_string(self, conv): + if conv and self.needs_ptr32_type() and (self.type != "size_t" or self.is_pointer()): + return "%#x" return self.format_str - def free(self): - if self.is_dynamic_array(): - if self.struct.returnedonly: - # For returnedonly, counts is stored in a pointer. - return " free_{0}_array({1}_host, *{2});\n".format(self.type, self.name, self.dyn_array_len) - else: - return " free_{0}_array({1}_host, {2});\n".format(self.type, self.name, self.dyn_array_len) - else: - # We are operating on a single structure. Some structs (very rare) contain dynamic members, - # which would need freeing. - if self.struct.needs_free(): - return " free_{0}(&{1}_host);\n".format(self.type, self.name) - return "" - - def get_conversions(self): - """ Get a list of conversions required for this parameter if any. - Parameters which are structures may require conversion between win32 - and the host platform. This function returns a list of conversions - required. - """ - - if not self.is_struct(): - return None - - self.struct.needs_struct_extensions_conversion() - for m in self.struct: - m.needs_struct_extensions_conversion() - - if not self.needs_conversion(): - return None - - conversions = [] - - # Collect any member conversions first, so we can guarantee - # those functions will be defined prior to usage by the - # 'parent' param requiring conversion. - for m in self.struct: - if not m.is_struct(): - continue - - if not m.needs_conversion(): - continue - - conversions.extend(m.get_conversions()) - - # Conversion requirements for the 'parent' parameter. - if self.input_conv is not None: - conversions.append(self.input_conv) - if self.output_conv is not None: - conversions.append(self.output_conv) - if self.free_func is not None: - conversions.append(self.free_func) - - return conversions - - def is_const(self): - return self.const is not None - - def is_dynamic_array(self): - return self.dyn_array_len is not None - def is_dispatchable(self): if not self.is_handle(): return False return self.handle.is_dispatchable() - def is_handle(self): - return self.handle is not None + def needs_conversion(self, conv, unwrap, direction, parent_const=False): + """ Check if param needs conversion. """ - def is_pointer(self): - return self.pointer is not None + if self.is_struct(): + return self.struct.needs_conversion(conv, unwrap, direction, self.is_const()) - def is_static_array(self): - return self.array_len is not None + if self.is_handle(): + # non-pointer handles are handled inline in thunks + if not self.is_dynamic_array() and not self.is_static_array(): + return conv and self.is_pointer() and self.handle.is_dispatchable() - def is_struct(self): - return self.struct is not None + # xrAllocateCommandBuffers is a special case, we use it in our private thunk as an input param + param_direction = (Direction.INPUT if self.is_const() else Direction.OUTPUT) + if self.name == "pCommandBuffers": + param_direction = Direction.INPUT + if direction != param_direction: + return False - def needs_conversion(self): - """ Returns if parameter needs conversion between win32 and host. """ - - if not self.is_struct(): - return False - - # If a structure needs alignment changes, it means we need to - # perform parameter conversion between win32 and host. - if self.struct.needs_conversion(): - return True + if unwrap != Unwrap.NONE and self.handle.is_wrapped(): + return True + if conv and self.handle.is_dispatchable(): + return True + elif self.is_pointer() and self.is_pointer_size(): + return conv return False - def needs_free(self): - return self.free_func is not None + def needs_variable(self, conv, unwrap): + if self.needs_conversion(conv, unwrap, Direction.INPUT): + return True + if self.needs_conversion(conv, unwrap, Direction.OUTPUT): + return True + return False - def needs_input_conversion(self): - return self.input_conv is not None + def spec(self): + """ Generate spec file entry for this parameter. """ - def needs_output_conversion(self): - return self.output_conv is not None + if self.is_pointer() and self.type == "char": + return "str" + if self.is_dispatchable() or self.is_pointer() or self.is_static_array(): + return "ptr" + if self.type_info["category"] in ["bitmask"]: + # Since 1.2.170 bitmasks can be 32 or 64-bit, check the basetype. + if self.type_info["data"].type == "XrFlags64": + return "int64" + else: + return "long" + if self.type_info["category"] in ["enum"]: + return "long" + if self.is_handle() and not self.is_dispatchable(): + return "int64" + if self.type == "float": + return "float" + if self.type in ["int", "int32_t", "size_t", "uint16_t", "uint32_t", "XrBool32"]: + return "long" + if self.type in ["uint64_t", "XrDeviceSize"]: + return "int64" - def variable(self, conv=False): + LOGGER.error("Unhandled spec conversion for type: {0}".format(self.type)) + + def variable(self, conv, unwrap, params_prefix=""): """ Returns 'glue' code during generation of a function call on how to access the variable. This function handles various scenarios such as 'unwrapping' if dispatchable objects and renaming of parameters in case of win32 -> host conversion. @@ -1547,21 +1835,44 @@ class XrParam(object): conv (bool, optional): Enable conversion if the param needs it. This appends '_host' to the name. """ - if conv and self.needs_conversion(): - if self.is_dynamic_array(): + # Hack until we enable allocation callbacks from ICD to application. These are a joy + # to enable one day, because of calling convention conversion. + if unwrap != Unwrap.NONE and "XrAllocationCallbacks" in self.type: + LOGGER.debug("TODO: setting NULL XrAllocationCallbacks for {0}".format(self.name)) + return "NULL" + + if self.needs_variable(conv, unwrap): + if self.is_dynamic_array() or self.optional: return "{0}_host".format(self.name) else: return "&{0}_host".format(self.name) - else: - # We need to pass the native handle to the native calls. - native_handle = self.handle.native_handle(self.name) if self.is_handle() else None - return native_handle if native_handle else self.name + + p = self.value(params_prefix, conv) + + if unwrap != Unwrap.NONE: + unwrap_handle = None + if self.object_type != None and self.type == "uint64_t": + if unwrap == Unwrap.DRIVER and self.is_wrapped(Unwrap.DRIVER): + LOGGER.error("DRIVER unwrapping of {0}.{1} not implemented".format(self.type, self.name)) + unwrap_handle = "wine_xr_unwrap_handle({0}{1}, {0}{2})".format( + params_prefix, self.object_type, self.name) + + elif self.is_handle(): + # We need to pass the host handle to the host Vulkan calls and + # the wine driver's handle to calls which are wrapped by the driver. + unwrap_handle = self.handle.unwrap_handle(p, unwrap) + if unwrap_handle: + if self.optional: + unwrap_handle = "{0}{1} ? {2} : 0".format(params_prefix, self.name, unwrap_handle) + return unwrap_handle + + return p class XrStruct(Sequence): """ Class which represents the type union and struct. """ - def __init__(self, name, members, returnedonly, structextends, alias=None, union=False, dep_level=1000): + def __init__(self, name, members, returnedonly, structextends, alias=None, union=False): self.name = name self.members = members self.returnedonly = returnedonly @@ -1572,7 +1883,6 @@ class XrStruct(Sequence): self.type_info = None # To be set later. self.struct_extensions = [] self.aliased_by = [] - self.dep_level = dep_level def __getitem__(self, i): return self.members[i] @@ -1590,6 +1900,9 @@ class XrStruct(Sequence): @staticmethod def from_xml(struct): + if not api_is_openxr(struct): + return None + # Unions and structs are the same parsing wise, but we need to # know which one we are dealing with later on for code generation. union = True if struct.attrib["category"] == "union" else False @@ -1600,19 +1913,25 @@ class XrStruct(Sequence): # marked as 'returnedonly'. returnedonly = True if struct.attrib.get("returnedonly") else False + # Those structs seem to be broken in spec, they are specified as + # returned only, but documented as input structs. + if name in ["XrPipelineShaderStageRequiredSubgroupSizeCreateInfo"]: + returnedonly = False + + # Those structs don't have returnedonly in spec, but they could (should?). + if name in ["XrSurfaceCapabilitiesPresentBarrierNV"]: + returnedonly = True + structextends = struct.attrib.get("structextends") structextends = structextends.split(",") if structextends else [] - members = [] + s = XrStruct(name, [], returnedonly, structextends, union=union) for member in struct.findall("member"): - xr_member = XrMember.from_xml(member) - members.append(xr_member) + xr_member = XrMember.from_xml(member, returnedonly, s) + if xr_member: + s.members.append(xr_member) - if name in STRUCTS_PUT_FIRST: - dep_level = 0 - else: - dep_level = 1000 - return XrStruct(name, members, returnedonly, structextends, union=union, dep_level=dep_level) + return s @staticmethod def decouple_structs(structs): @@ -1627,7 +1946,8 @@ class XrStruct(Sequence): decoupled_structs = [] while (len(tmp_structs) > 0): - for struct in tmp_structs: + # Iterate over a copy because we want to modify the list inside the loop. + for struct in list(tmp_structs): dependends = False if not struct.required: @@ -1666,21 +1986,7 @@ class XrStruct(Sequence): return decoupled_structs - def typedef(self): - if not self.is_alias(): - if self.union: - text = "typedef union {0} {0};\n".format(self.name) - else: - text = "typedef struct {0} {0};\n".format(self.name) - else: - text = "" - - for aliasee in self.aliased_by: - text += "typedef {0} {1};\n".format(self.name, aliasee.name) - - return text - - def definition(self, align=False, conv=False, postfix=None): + def definition(self, align=False, conv=False): """ Convert structure to textual definition. Args: @@ -1689,42 +1995,28 @@ class XrStruct(Sequence): postfix (str, optional): text to append to end of struct name, useful for struct renaming. """ - # Only define alias structs when doing conversions - if self.is_alias() and not conv: + if self.is_alias(): return "" - if conv: - text = "typedef " - else: - text = "" - + suffix = "32" if conv else "" if self.union: - text += "union {0}".format(self.name) + text = "typedef union {0}".format(self.name) else: - text += "struct {0}".format(self.name) - - if postfix is not None: - text += postfix + text = "typedef struct {0}".format(self.name) + text += suffix text += "\n{\n" for m in self: if align and m.needs_alignment(): - text += " {0};\n".format(m.definition(align=align)) - elif conv and m.needs_conversion(): + text += " {0};\n".format(m.definition(align=align, conv=conv)) + else: text += " {0};\n".format(m.definition(conv=conv)) - else: - text += " {0};\n".format(m.definition()) - if postfix is not None: - if conv: - text += "}} {0}{1};\n\n".format(self.name, postfix) - else: - text += "}} {1};\n\n".format(self.name, postfix) - else: - text += "}};\n".format(self.name) + text += "}} {0}{1};\n".format(self.name, suffix) - text += "\n" + for aliasee in self.aliased_by: + text += "typedef {0}{2} {1}{2};\n".format(self.name, aliasee.name, suffix) return text @@ -1741,47 +2033,135 @@ class XrStruct(Sequence): """ for m in self.members: + if self.name == m.type: + continue if m.needs_alignment(): return True return False - def needs_conversion(self): - """ Returns if struct members needs conversion between win32 and host. - Structures need conversion if they contain members requiring alignment - or if they include other structures which need alignment. - """ + def is_wrapped(self): + """ Returns if struct members need unwrapping of handle. """ - if self.needs_alignment(): + for m in self.members: + if self.name == m.type: + continue + if m.is_wrapped(): + return True + return False + + def needs_extensions_conversion(self, conv, direction): + """ Check if struct contains extensions chain that needs to be converted """ + + if direction == Direction.INPUT and self.name in STRUCT_CHAIN_CONVERSIONS: + return True + + if not "next" in self: + return False + is_const = self.members[self.members.index("next")].is_const() + # XrOpticalFlowSessionCreateInfoNV is missing const in its next pointer + if self.name in ["XrOpticalFlowSessionCreateInfoNV", + "XrDescriptorBufferBindingInfoEXT"]: + is_const = True + + for e in self.struct_extensions: + if not e.required: + continue + if e.needs_conversion(conv, Unwrap.HOST, direction, is_const, check_extensions=False): + return True + if direction == Direction.INPUT: + # we need input conversion of structs containing struct chain even if it's returnedonly, + # so that we have a chance to allocate buffers + if e.needs_conversion(conv, Unwrap.HOST, Direction.OUTPUT, is_const, check_extensions=False): + return True + + return False + + def needs_conversion(self, conv, unwrap, direction, is_const, check_extensions=True): + """ Check if struct needs conversion. """ + + # XrAllocationCallbacks never needs conversion + if self.name == "XrAllocationCallbacks": + return False + + # pFixedRateFlags field is missing const, but it doesn't need output conversion + if direction == Direction.OUTPUT and self.name == "XrImageCompressionControlEXT": + return False + + needs_output_copy = False + + for m in self.members: + if self.name == m.type: + continue + + if m.name == "next": + # next is a pointer, so it always needs conversion + if conv and direction == Direction.INPUT: + return True + # we need input conversion of structs containing struct chain even if it's returnedonly + if direction == Direction.INPUT and \ + self.needs_conversion(conv, unwrap, Direction.OUTPUT, is_const): + return True + continue + + # for non-pointer members, check for returnedonly and const attributes + if not m.is_pointer() or m.type == "void": + if direction == Direction.INPUT: + if self.returnedonly: + continue + else: + if is_const or m.is_const(): + continue + + # check alignment and pointer-sized members for 32-bit conversions + if conv and (direction == Direction.INPUT or not is_const): + if m.is_pointer() or m.is_pointer_size(): + return True + # we don't check structs here, they will will be traversed by needs_conversion chain anyway + if not m.is_struct() and m.needs_alignment(): + return True + + if m.needs_conversion(conv, unwrap, direction, is_const): + return True + + # pointers will be handled by needs_conversion, but if we have any other non-const + # member, we may need to copy output + if direction == Direction.OUTPUT and not m.is_pointer() and not is_const and not m.is_const(): + needs_output_copy = True + + # if output needs any copy and we need input conversion, then we also need output conversion + if needs_output_copy and self.needs_conversion(conv, unwrap, Direction.INPUT, check_extensions): + return True + + return check_extensions and self.needs_extensions_conversion(conv, direction) + + def needs_alloc(self, conv, unwrap): + """ Check if any struct member needs some memory allocation.""" + + if self.needs_extensions_conversion(conv, Direction.INPUT): return True for m in self.members: - if m.type == self.name: + if self.name == m.type: continue - if m.needs_conversion(): + if m.needs_alloc(conv, unwrap): return True + return False - def needs_free(self): - """ Check if any struct member needs some memory freeing.""" + def needs_win32_type(self): + # XrAllocationCallbacks never needs conversion + if self.name == "XrAllocationCallbacks": + return False for m in self.members: - if m.needs_free(): + if self.name == m.type: + continue + if m.is_pointer() or m.is_pointer_size(): + return True + if m.needs_alignment(): + return True + if (m.is_struct() or m.is_union()) and m.struct.needs_win32_type(): return True - - continue - - return False - - def needs_struct_extensions_conversion(self): - """ Checks if structure extensions in next chain need conversion. """ - ret = False - - for e in self.struct_extensions: - if e.required and e.needs_conversion(): - LOGGER.error("Unhandled next chain conversion for {0}".format(e.name)) - ret = True - - return ret def set_type_info(self, types): """ Helper function to set type information from the type registry. @@ -1792,314 +2172,387 @@ class XrStruct(Sequence): type_info = types[m.type] m.set_type_info(type_info) + def get_conversions(self, unwrap, parent_const): + conversions = [] -class ConversionFunction(object): - def __init__(self, array, dyn_array, direction, struct): - self.array = array + # Collect any conversion for any extension structs. + for e in self.struct_extensions: + if not e.required: + continue + conversions.extend(e.get_conversions(Unwrap.HOST, parent_const)) + + # Collect any conversion for any member structs. + for m in self: + if m.type == self.name: + continue + conversions.extend(m.get_conversions(unwrap, parent_const)) + + return conversions + + +class StructConversionFunction(object): + def __init__(self, struct, direction, conv, unwrap, const, copy=False): self.direction = direction - self.dyn_array = dyn_array - self.struct = struct + self.operand = struct self.type = struct.name + self.conv = conv + self.unwrap = unwrap + self.const = const + self.copy = copy - self._set_name() - - def __eq__(self, other): - return self.name == other.name - - def _generate_array_conversion_func(self): - """ Helper function for generating a conversion function for array structs. """ - - if self.direction == Direction.OUTPUT: - params = ["const {0}_host *in".format(self.type), "uint32_t count"] - return_type = self.type + if copy: + name = "copy_{0}".format(self.type) else: - params = ["const {0} *in".format(self.type), "uint32_t count"] - return_type = "{0}_host".format(self.type) - - # Generate function prototype. - body = "static inline {0} *{1}(".format(return_type, self.name) - body += ", ".join(p for p in params) - body += ")\n{\n" - - body += " {0} *out;\n".format(return_type) - body += " unsigned int i;\n\n" - body += " if (!in) return NULL;\n\n" - - body += " out = HeapAlloc(GetProcessHeap(), 0, count * sizeof(*out));\n" - - body += " for (i = 0; i < count; i++)\n" - body += " {\n" - - for m in self.struct: - # TODO: support copying of next extension structures! - # Luckily though no extension struct at this point needs conversion. - body += " " + m.copy("in[i].", "out[i].", self.direction) - - body += " }\n\n" - body += " return out;\n" - body += "}\n\n" - return body - - def _generate_conversion_func(self): - """ Helper function for generating a conversion function for non-array structs. """ - - if self.direction == Direction.OUTPUT: - params = ["const {0}_host *in".format(self.type), "{0} *out".format(self.type)] - else: - params = ["const {0} *in".format(self.type), "{0}_host *out".format(self.type)] - - body = "static inline void {0}(".format(self.name) - - # Generate parameter list - body += ", ".join(p for p in params) - body += ")\n{\n" - - body += " if (!in) return;\n\n" - - if self.direction == Direction.INPUT and "next" in self.struct and self.struct.returnedonly: - # We are dealing with an input_output parameter. For these we only need to copy - # next and type as the other fields are filled in by the host. We do potentially - # have to iterate over next and perform conversions based on switch(type)! - # Luckily though no extension structs at this point need conversion. - # TODO: support copying of next extension structures! - body += " out->next = in->next;\n" - body += " out->type = in->type;\n" - else: - for m in self.struct: - # TODO: support copying of next extension structures! - body += " " + m.copy("in->", "out->", self.direction) - - body += "}\n\n" - return body - - def _generate_static_array_conversion_func(self): - """ Helper function for generating a conversion function for array structs. """ - - if self.direction == Direction.OUTPUT: - params = ["const {0}_host *in".format(self.type), "{0} *out".format(self.type), "uint32_t count"] - else: - params = ["const {0} *in".format(self.type), "{0} *out_host".format(self.type), "uint32_t count"] - - # Generate function prototype. - body = "static inline void {0}(".format(self.name) - body += ", ".join(p for p in params) - body += ")\n{\n" - body += " unsigned int i;\n\n" - body += " if (!in) return;\n\n" - body += " for (i = 0; i < count; i++)\n" - body += " {\n" - - for m in self.struct: - # TODO: support copying of next extension structures! - body += " " + m.copy("in[i].", "out[i].", self.direction) - - body += " }\n" - body += "}\n\n" - return body - - def _set_name(self): - if self.direction == Direction.INPUT: - if self.array: - name = "convert_{0}_static_array_win_to_host".format(self.type) - elif self.dyn_array: - name = "convert_{0}_array_win_to_host".format(self.type) - else: - name = "convert_{0}_win_to_host".format(self.type) - else: # Direction.OUTPUT - if self.array: - name = "convert_{0}_static_array_host_to_win".format(self.type) - elif self.dyn_array: - name = "convert_{0}_array_host_to_win".format(self.type) - else: - name = "convert_{0}_host_to_win".format(self.type) - + name = "convert_{0}_".format(self.type) + win_type = "win32" if self.conv else "win64" + name += convert_suffix(direction, win_type, unwrap, struct.is_wrapped()) self.name = name + def __eq__(self, other): + return self.name == other.name + + def member_needs_copy(self, struct, m): + if self.direction == Direction.OUTPUT: + if m.name in ["type", "next"]: + return False + if self.const and not m.is_pointer(): + return False + if m.is_const() and not m.needs_conversion(self.conv, self.unwrap, Direction.OUTPUT, self.const): + return False + else: + if m.name == "next": + return True + if m.name != "type" and struct.returnedonly and not m.needs_conversion( + self.conv, self.unwrap, Direction.INPUT, self.const): + return False + return True + def definition(self): - if self.array: - return self._generate_static_array_conversion_func() - elif self.dyn_array: - return self._generate_array_conversion_func() + """ Helper function for generating a struct conversion function. """ + + # It doesn't make sense to generate conversion functions for non-struct variables + # which aren't in arrays, as this should be handled by the copy() function + if not isinstance(self.operand, XrStruct): + return "" + + body = "" + + if not self.conv and not self.copy: + body += "#ifdef _WIN64\n" + + needs_alloc = self.direction != Direction.OUTPUT and self.operand.needs_alloc(self.conv, self.unwrap) + win_type = self.type + if self.conv and self.operand.needs_win32_type(): + win_type += "32" + if self.direction == Direction.OUTPUT and self.const: + win_type = "const " + win_type + + if self.copy: + body += "void {0}(".format(self.name) else: - return self._generate_conversion_func() + body += "static inline void {0}(".format(self.name) + if self.conv: + if self.direction == Direction.OUTPUT: + params = ["const {0} *in".format(self.type), "{0} *out".format(win_type)] + else: + params = ["const {0} *in".format(win_type), "{0} *out".format(self.type)] -class FreeFunction(object): - def __init__(self, dyn_array, struct): - self.dyn_array = dyn_array - self.struct = struct - self.type = struct.name + if self.operand.union: + params.append("XrFlags selector") + + # Generate parameter list + if needs_alloc: + body += "struct conversion_context *ctx, " + body += ", ".join(p for p in params) + body += ")\n" - if dyn_array: - self.name = "free_{0}_array".format(self.type) else: - self.name = "free_{0}".format(self.type) + params = ["const {0} *in".format(self.type), "{0} *out".format(self.type)] + + # Generate parameter list + if needs_alloc: + body += "struct conversion_context *ctx, " + body += ", ".join(p for p in params) + body += ")\n" + + needs_extensions = self.operand.needs_extensions_conversion(self.conv, self.direction) + + body += "{\n" + if needs_extensions: + if self.direction == Direction.INPUT: + if self.conv: + body += " const XrBaseInStructure32 *in_header;\n" + else: + body += " const XrBaseInStructure *in_header;\n" + body += " XrBaseOutStructure *out_header = (void *)out;\n\n" + else: + body += " const XrBaseInStructure *in_header;\n" + if self.conv: + body += " XrBaseOutStructure32 *out_header = (void *)out;\n\n" + else: + body += " XrBaseOutStructure *out_header = (void *)out;\n\n" + + body += " if (!in) return;\n\n" + + for m in self.operand: + if not self.member_needs_copy(self.operand, m): + continue + if m.name == "next" and (needs_extensions or self.conv): + body += " out->next = NULL;\n" + continue + + if m.selection: + body += " if (" + body += " || ".join("selector == {}".format(s) for s in m.selection) + body += ")\n " + + body += " " + m.copy("in->", "out->", self.direction, self.conv, self.unwrap, self.copy) + + if needs_extensions: + if self.conv and self.direction == Direction.INPUT: + body += "\n for (in_header = UlongToPtr(in->next); in_header; in_header = UlongToPtr(in_header->next))\n" + else: + body += "\n for (in_header = (void *)in->next; in_header; in_header = (void *)in_header->next)\n" + body += " {\n" + body += " switch (in_header->type)\n" + body += " {\n" + + ident = " " + + if self.direction == Direction.INPUT and self.type in STRUCT_CHAIN_CONVERSIONS: + has_any_chain_conversions = False + for i in STRUCT_CHAIN_CONVERSIONS[self.type]: + body += " case {0}:\n".format(i) + has_any_chain_conversions = True + if has_any_chain_conversions: + body += ident + "break;\n" + + for ext in self.operand.struct_extensions: + if not ext.required: + continue + + if self.direction == Direction.OUTPUT and not any([self.member_needs_copy(ext, m) for m in ext]): + continue + + + stype = next(x for x in ext.members if x.name == "type").values + if self.type in STRUCT_CHAIN_CONVERSIONS and stype in STRUCT_CHAIN_CONVERSIONS[self.type]: + continue + win_type = ext.name + "32" if self.conv and ext.needs_win32_type() else ext.name + if self.direction == Direction.INPUT: + in_type = "const " + win_type + out_type = ext.name + else: + in_type = "const " + ext.name + out_type = win_type + + body += " case {0}:\n".format(stype) + body += " {\n" + if self.direction == Direction.INPUT: + body += ident + "{0} *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));\n".format(out_type) + elif self.conv: + body += ident + "{0} *out_ext = find_next_struct32(out_header, {1});\n".format(out_type, stype) + else: + body += ident + "{0} *out_ext = find_next_struct(out_header, {1});\n".format(out_type, stype) + + copy_body = "" + + for m in ext: + if m.name == "type": + copy_body += ident + "out_ext->type = {0};\n".format(stype) + continue + if not self.member_needs_copy(ext, m): + continue + if m.name == "next": + copy_body += ident + "out_ext->next = NULL;\n" + continue + copy_body += ident + m.copy("in_ext->", "out_ext->", self.direction, self.conv, Unwrap.HOST, self.copy) + + # Generate the definition of "in_ext" if we need it + if "in_ext->" in copy_body: + body += ident + "{0} *in_ext = ({0} *)in_header;\n".format(in_type) + body += copy_body + + if self.direction == Direction.INPUT: + body += ident + "out_header->next = (void *)out_ext;\n" + body += ident + "out_header = (void *)out_ext;\n" + body += ident + "break;\n" + body += " }\n" + + body += " default:\n" + if self.direction == Direction.INPUT: + body += ident + "if ((in_header->type >> 16) == 0x7ead)\n" + body += ident + "{\n" + body += ident + " XrBaseOutStructure *out_ext = conversion_context_alloc(ctx, 32);\n"; + body += ident + " memcpy(out_ext, in_header, 32);\n"; + body += ident + " out_ext->next = NULL;\n"; + body += ident + " out_header->next = (void *)out_ext;\n"; + body += ident + " out_header = (void *)out_ext;\n"; + body += ident + "}\n" + body += ident + "else\n" + body += ident + "{\n" + body += ident + " FIXME(\"Unhandled type %u.\\n\", in_header->type);\n" + body += ident + "}\n" + body += " break;\n" + body += " }\n" + body += " }\n" + elif self.conv and self.direction == Direction.INPUT and "next" in self.operand: + body += " if (in->next)\n" + body += " FIXME(\"Unexpected next\\n\");\n" + + body += "}\n" + if not self.conv and not self.copy: + body += "#endif /* _WIN64 */\n" + body += "\n" + + return body + + +class ArrayConversionFunction(object): + def __init__(self, array, direction, conv, unwrap): + self.array = array + self.direction = direction + self.type = array.type + self.conv = conv + self.unwrap = unwrap + + if array.is_static_array() and direction == Direction.INPUT: + LOGGER.error("Static array input conversion is not supported") + + name = "convert_{0}_".format(array.type) + if array.pointer_array: + name += "pointer_" + name += "array_" + win_type = "win32" if self.conv else "win64" + name += convert_suffix(direction, win_type, unwrap, array.is_wrapped()) + self.name = name def __eq__(self, other): return self.name == other.name - def _generate_array_free_func(self): - """ Helper function for cleaning up temporary buffers required for array conversions. """ + def definition(self): + """ Helper function for generating a conversion function for array operands. """ + + body = "" + + if not self.conv: + body += "#ifdef _WIN64\n" + + needs_alloc = self.direction != Direction.OUTPUT and self.array.needs_alloc(self.conv, self.unwrap) + + win_type = self.type + if self.conv: + if self.array.needs_win32_type(): + win_type += "32" + elif self.array.is_handle() and self.array.handle.is_dispatchable(): + win_type = "PTR32" + if self.direction == Direction.OUTPUT and self.array.is_const(): + win_type = "const " + win_type + pointer_part = self.array.pointer if self.array.pointer else "*" + + if self.direction == Direction.OUTPUT: + params = ["const {0} {1}in".format(self.type, pointer_part), + "{0} {1}out".format(win_type, pointer_part), "uint32_t count"] + return_type = None + elif self.conv and self.array.pointer_array: + params = ["const PTR32 *in", "uint32_t count"] + return_type = self.type + else: + params = ["const {0} {1}in".format(win_type, pointer_part), "uint32_t count"] + return_type = self.type + + needs_copy = not self.array.is_struct() or self.direction != Direction.INPUT or \ + not self.array.struct.returnedonly or "next" in self.array.struct # Generate function prototype. - body = "static inline void {0}({1}_host *in, uint32_t count)\n{{\n".format(self.name, self.type) + if return_type: + body += "static inline {0}{1} {2}{3}(".format( + "const " if self.array.is_const() else "", return_type, pointer_part, self.name) + else: + body += "static inline void {0}(".format(self.name) + if needs_alloc: + body += "struct conversion_context *ctx, " + body += ", ".join(p for p in params) + body += ")\n{\n" - # E.g. XrGraphicsPipelineCreateInfo_host needs freeing for pStages. - if self.struct.needs_free(): + if return_type: + body += " {0} {1}out;\n".format(return_type, "**" if self.array.pointer_array else "*") + if needs_copy: body += " unsigned int i;\n\n" + + if return_type: + body += " if (!in || !count) return NULL;\n\n" + else: body += " if (!in) return;\n\n" + + if self.direction == Direction.INPUT: + body += " out = conversion_context_alloc(ctx, count * sizeof(*out));\n" + + if needs_copy: body += " for (i = 0; i < count; i++)\n" body += " {\n" - for m in self.struct: - if m.needs_conversion() and m.is_dynamic_array(): - if m.is_const(): - # Add a cast to ignore const on conversion structs we allocated ourselves. - body += " free_{0}_array(({0}_host *)in[i].{1}, in[i].{2});\n".format(m.type, m.name, m.dyn_array_len) + if self.array.is_struct(): + struct = self.array.struct + win_part = "win32" if self.conv else "win64" + suffix = convert_suffix(self.direction, win_part, self.unwrap, struct.is_wrapped()) + ctx_part = "" + if self.direction == Direction.INPUT and struct.needs_alloc(self.conv, self.unwrap): + ctx_part = "ctx, " + + if not self.array.pointer_array: + body += " convert_{0}_{1}({2}&in[i], &out[i]);\n".format( + struct.name, suffix, ctx_part) + else: + if struct.needs_conversion(self.conv, self.unwrap, self.direction, False): + body += " if (in[i])\n" + body += " {\n" + body += " out[i] = conversion_context_alloc(ctx, sizeof(*out[i]));\n" + if self.conv: + in_param = "({0} *)UlongToPtr(in[i])".format(win_type) + else: + in_param = "in[i]" + body += " convert_{0}_{1}({2}{3}, out[i]);\n".format( + struct.name, suffix, ctx_part, in_param) + body += " }\n" + body += " else\n" + body += " out[i] = NULL;\n" else: - body += " free_{0}_array(in[i].{1}, in[i].{2});\n".format(m.type, m.name, m.dyn_array_len) - elif m.needs_conversion(): - LOGGER.error("Unhandled conversion for {0}".format(m.name)) + body += " out[i] = UlongToPtr(in[i]);\n" + elif self.array.is_handle(): + if self.array.pointer_array: + LOGGER.error("Unhandled handle pointer arrays") + handle = self.array.handle + if not self.conv or not handle.is_dispatchable(): + input = "in[i]" + elif self.direction == Direction.INPUT: + input = "UlongToPtr(in[i])" + else: + input = "PtrToUlong(in[i])" + + if self.unwrap == Unwrap.NONE or not handle.is_wrapped(): + body += " out[i] = {0};\n".format(input) + elif self.direction == Direction.INPUT: + body += " out[i] = {0};\n".format(handle.unwrap_handle(input, self.unwrap)) + else: + LOGGER.warning("Unhandled handle output conversion") + elif self.array.pointer_array: + body += " out[i] = UlongToPtr(in[i]);\n" + else: + body += " out[i] = in[i];\n" + body += " }\n" - else: - body += " if (!in) return;\n\n" - body += " HeapFree(GetProcessHeap(), 0, in);\n" + if return_type: + body += "\n return {0}out;\n".format("(void *)" if self.array.pointer_array else "") + body += "}\n" - body += "}\n\n" - return body + if not self.conv: + body += "#endif /* _WIN64 */\n" - def _generate_free_func(self): - # E.g. XrCommandBufferBeginInfo.pInheritanceInfo needs freeing. - if not self.struct.needs_free(): - return "" + body += "\n" - # Generate function prototype. - body = "static inline void {0}({1}_host *in)\n{{\n".format(self.name, self.type) - - for m in self.struct: - if m.needs_conversion() and m.is_dynamic_array(): - count = m.dyn_array_len if isinstance(m.dyn_array_len, int) else "in->{0}".format(m.dyn_array_len) - if m.is_const(): - # Add a cast to ignore const on conversion structs we allocated ourselves. - body += " free_{0}_array(({0}_host *)in->{1}, {2});\n".format(m.type, m.name, count) - else: - body += " free_{0}_array(in->{1}, {2});\n".format(m.type, m.name, count) - - body += "}\n\n" - return body - - def definition(self): - if self.dyn_array: - return self._generate_array_free_func() - else: - # Some structures need freeing too if they contain dynamic arrays. - # E.g. XrCommandBufferBeginInfo - return self._generate_free_func() - - -class StructChainConversionFunction(object): - def __init__(self, direction, struct): - self.direction = direction - self.struct = struct - self.type = struct.name - - self.name = "convert_{0}_struct_chain".format(self.type) - - def __eq__(self, other): - return self.name == other.name - - def prototype(self, postfix=""): - return "XrResult {0}(const void *next, {1} *out_struct) {2}".format(self.name, self.type, postfix).strip() - - def definition(self): - body = self.prototype() - body += "\n{\n" - - body += " XrBaseOutStructure *out_header = (XrBaseOutStructure *)out_struct;\n"; - body += " const XrBaseInStructure *in_header;\n\n"; - - body += " out_header->next = NULL;\n\n" - - body += " for (in_header = next; in_header; in_header = in_header->next)\n" - body += " {\n" - body += " switch (in_header->type)\n" - body += " {\n" - - # Ignore to not confuse host loader. - body += " case XR_TYPE_INSTANCE_CREATE_INFO:\n" - body += " break;\n\n" - - for e in self.struct.struct_extensions: - if not e.required: - continue - - stype = next(x for x in e.members if x.name == "type") - - body += " case {0}:\n".format(stype.values) - body += " {\n" - - body += " const {0} *in = (const {0} *)in_header;\n".format(e.name) - body += " {0} *out;\n\n".format(e.name) - - body += " if (!(out = HeapAlloc(GetProcessHeap(), 0, sizeof(*out)))) goto out_of_memory;\n\n" - - for m in e: - if m.name == "next": - body += " out->next = NULL;\n" - else: - body += " " + m.copy("in->", "out->", self.direction) - - body += "\n out_header->next = (XrBaseOutStructure *)out;\n" - body += " out_header = out_header->next;\n" - body += " break;\n" - body += " }\n\n" - - body += " default:\n" - body += " WINE_FIXME(\"Application requested a linked structure of type %u.\\n\", in_header->type);\n" - - body += " }\n" - body += " }\n\n" - - body += " return XR_SUCCESS;\n" - - if any(x for x in self.struct.struct_extensions if x.required): - body += "\nout_of_memory:\n" - body += " free_{0}_struct_chain(out_struct);\n".format(self.type) - body += " return XR_ERROR_OUT_OF_HOST_MEMORY;\n" - - body += "}\n\n" - return body - -class FreeStructChainFunction(object): - def __init__(self, struct): - self.struct = struct - self.type = struct.name - - self.name = "free_{0}_struct_chain".format(self.type) - - def __eq__(self, other): - return self.name == other.name - - def prototype(self, postfix=""): - return "void {0}({1} *s) {2}".format(self.name, self.type, postfix).strip() - - def definition(self): - body = self.prototype() - body += "\n{\n" - - body += " XrBaseOutStructure *header = (void *)s->next;\n\n"; - - body += " while (header)\n" - body += " {\n" - body += " void *prev = header;\n" - body += " header = header->next;\n" - body += " HeapFree(GetProcessHeap(), 0, prev);\n" - body += " }\n\n" - - body += " s->next = NULL;\n" - - body += "}\n\n" return body @@ -2109,110 +2562,80 @@ class XrGenerator(object): # Build a list conversion functions for struct conversion. self.conversions = [] - self.struct_chain_conversions = [] - self.host_structs = [] + self.win32_structs = [] for func in self.registry.funcs.values(): - if not func.is_required(): - continue - - if not func.needs_conversion(): + if not func.needs_exposing(): continue conversions = func.get_conversions() for conv in conversions: - # Pull in any conversions for openxr_thunks.c. - if func.needs_thunk(): - # Append if we don't already have this conversion. - if not any(c == conv for c in self.conversions): - self.conversions.append(conv) + # Append if we don't already have this conversion. + if not any(c == conv for c in self.conversions): + self.conversions.append(conv) + + if not isinstance(conv, StructConversionFunction): + continue + + for e in conv.operand.struct_extensions: + if not e.required or not e.needs_win32_type(): + continue + if not any(s.name == e.name for s in self.win32_structs): + self.win32_structs.append(e) + + if not conv.operand.needs_win32_type(): + continue # Structs can be used in different ways by different conversions # e.g. array vs non-array. Just make sure we pull in each struct once. - if not any(s.name == conv.struct.name for s in self.host_structs): - self.host_structs.append(conv.struct) - - for struct in self.registry.structs: - if struct.name in STRUCT_CHAIN_CONVERSIONS: - self.struct_chain_conversions.append(StructChainConversionFunction(Direction.INPUT, struct)) - self.struct_chain_conversions.append(FreeStructChainFunction(struct)) + if not any(s.name == conv.operand.name for s in self.win32_structs): + self.win32_structs.append(conv.operand) def _generate_copyright(self, f, spec_file=False): f.write("# " if spec_file else "/* ") - f.write("Automatically generated from OpenXR xr.xml; DO NOT EDIT!\n") - lines = ["", "This file is generated from OpenXR xr.xml file covered", + f.write("Automatically generated from Vulkan xr.xml; DO NOT EDIT!\n") + lines = ["", "This file is generated from Vulkan xr.xml file covered", "by the following copyright and permission notice:"] lines.extend([l.rstrip(" ") for l in self.registry.copyright.splitlines()]) for line in lines: f.write("{0}{1}".format("# " if spec_file else " * ", line).rstrip(" ") + "\n") f.write("\n" if spec_file else " */\n\n") - def generate_thunks_c(self, f, prefix): + def generate_thunks_c(self, f): self._generate_copyright(f) - f.write("#include \"wine/debug.h\"\n") - f.write("#include \"wine/vulkan.h\"\n") - f.write("#include \"d3d11.h\"\n") - f.write("#include \"d3d12.h\"\n") - f.write("#define WINE_XR_HOST\n") - f.write("#include \"wineopenxr.h\"\n") + f.write("#if 0\n") + f.write("#pragma makedep unix\n") + f.write("#endif\n\n") + + f.write("#include \"config.h\"\n\n") + + f.write("#include \n\n") + f.write("#include \"openxr_private.h\"\n\n") f.write("WINE_DEFAULT_DEBUG_CHANNEL(openxr);\n\n") - # Generate any conversion helper functions. - f.write("#if defined(USE_STRUCT_CONVERSION)\n") for conv in self.conversions: f.write(conv.definition()) - f.write("#endif /* USE_STRUCT_CONVERSION */\n\n") - - for conv in self.struct_chain_conversions: - f.write(conv.definition()) # Create thunks for instance and device functions. # Global functions don't go through the thunks. for xr_func in self.registry.funcs.values(): - if not xr_func.is_required(): + if not xr_func.needs_exposing(): + continue + if xr_func.name in MANUAL_LOADER_FUNCTIONS: continue - #if xr_func.is_global_func(): - # continue + f.write(xr_func.thunk(prefix="thunk64_")) - if not xr_func.needs_thunk(): - continue - - # Exports symbols for Core functions. - if not xr_func.is_core_func() and not xr_func.needs_private_thunk(): - f.write("static ") - - if xr_func.needs_private_thunk(): - f.write(xr_func.thunk(prefix="thunk_")) - else: - f.write(xr_func.thunk(prefix=prefix, call_conv="WINAPI")) - - f.write("static const struct openxr_func xr_dispatch_table[] =\n{\n") - for xr_func in self.registry.instance_funcs: - if not xr_func.is_required(): - continue - f.write(" {{\"{0}\", &{1}{0}}},\n".format(xr_func.name, prefix)) - f.write("};\n\n") - - f.write("void *wine_xr_proc_addr(const char *name)\n") - f.write("{\n") - f.write(" unsigned int i;\n") - f.write(" for (i = 0; i < ARRAY_SIZE(xr_dispatch_table); i++)\n") - f.write(" {\n") - f.write(" if (strcmp(xr_dispatch_table[i].name, name) == 0)\n") - f.write(" {\n") - f.write(" WINE_TRACE(\"Found name=%s in instance table\\n\", wine_dbgstr_a(name));\n") - f.write(" return xr_dispatch_table[i].func;\n") - f.write(" }\n") - f.write(" }\n") - f.write(" return NULL;\n") - f.write("}\n\n") - - # Create array of instance extensions. + # Create array of extensions. f.write("static const char * const xr_extensions[] =\n{\n") for ext in self.registry.extensions: + if ext["type"] != "instance": + continue + if ext["name"] in UNEXPOSED_EXTENSIONS: + continue + f.write(" \"{0}\",\n".format(ext["name"])) f.write("};\n\n") @@ -2225,7 +2648,39 @@ class XrGenerator(object): f.write(" return TRUE;\n") f.write(" }\n") f.write(" return FALSE;\n") - f.write("}\n") + f.write("}\n\n") + + f.write("BOOL wine_xr_is_type_wrapped(XrObjectType type)\n") + f.write("{\n") + f.write(" return FALSE") + for handle in self.registry.handles: + if not handle.is_required() or not handle.is_wrapped() or handle.is_alias(): + continue + f.write(" ||\n type == {}".format(handle.object_type)) + f.write(";\n") + f.write("}\n\n") + + + f.write("#ifdef _WIN64\n\n") + + f.write("const unixlib_entry_t __wine_unix_call_funcs[] =\n") + f.write("{\n") + f.write(" init_openxr,\n") + for xr_func in self.registry.funcs.values(): + if not xr_func.needs_exposing(): + continue + if xr_func.name in MANUAL_LOADER_FUNCTIONS: + continue + + if xr_func.is_perf_critical(): + f.write(" (void *){1}{0},\n".format(xr_func.name, "thunk64_")) + else: + f.write(" {1}{0},\n".format(xr_func.name, "thunk64_")) + f.write("};\n") + f.write("C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);\n\n") + + f.write("#endif /* _WIN64 */\n\n") + f.write("C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);\n") def generate_thunks_h(self, f, prefix): self._generate_copyright(f) @@ -2238,55 +2693,29 @@ class XrGenerator(object): # Generate prototypes for device and instance functions requiring a custom implementation. f.write("/* Functions for which we have custom implementations outside of the thunks. */\n") for xr_func in self.registry.funcs.values(): - if not xr_func.is_required():# or xr_func.is_global_func(): - continue - if xr_func.needs_thunk() and not xr_func.needs_private_thunk(): + if not xr_func.needs_private_thunk(): continue - if xr_func.is_core_func(): - f.write("{0};\n".format(xr_func.prototype("WINAPI", prefix="wine_"))) - else: - f.write("{0};\n".format(xr_func.prototype("WINAPI", prefix="wine_"))) - f.write("\n") - - f.write("/* Private thunks */\n") - for xr_func in self.registry.funcs.values(): - if xr_func.needs_private_thunk(): - f.write("{0};\n".format(xr_func.prototype(prefix="thunk_"))) - f.write("\n") - - for struct in self.host_structs: - f.write(struct.definition(align=False, conv=True, postfix="_host")) - f.write("\n") - - for func in self.struct_chain_conversions: - f.write(func.prototype() + ";\n") + f.write("{0};\n".format(xr_func.prototype(prefix=prefix, is_thunk=True))) f.write("\n") f.write("/* For use by xrInstance and children */\n") f.write("struct openxr_instance_funcs\n{\n") for xr_func in self.registry.instance_funcs: - if not xr_func.is_required(): + if not xr_func.needs_exposing(): continue if not xr_func.needs_dispatch(): LOGGER.debug("skipping {0} in openxr_instance_funcs".format(xr_func.name)) continue - if xr_func.needs_conversion(): - f.write("#if defined(USE_STRUCT_CONVERSION)\n") - f.write(" {0};\n".format(xr_func.pfn(conv=True))) - f.write("#else\n") - f.write(" {0};\n".format(xr_func.pfn(conv=False))) - f.write("#endif\n") - else: - f.write(" {0};\n".format(xr_func.pfn(conv=False))) + f.write(" {0};\n".format(xr_func.pfn())) f.write("};\n\n") f.write("#define ALL_XR_INSTANCE_FUNCS() \\\n") first = True for xr_func in self.registry.instance_funcs: - if not xr_func.is_required(): + if not xr_func.needs_exposing(): continue if not xr_func.needs_dispatch(): @@ -2302,6 +2731,84 @@ class XrGenerator(object): f.write("#endif /* __WINE_OPENXR_THUNKS_H */\n") + def generate_loader_thunks_c(self, f): + self._generate_copyright(f) + + f.write("#include \"openxr_loader.h\"\n\n") + + f.write("WINE_DEFAULT_DEBUG_CHANNEL(openxr);\n\n") + + for xr_func in self.registry.funcs.values(): + if not xr_func.needs_exposing(): + continue + if xr_func.name in MANUAL_LOADER_THUNKS | MANUAL_LOADER_FUNCTIONS: + continue + + f.write(xr_func.loader_thunk()) + + f.write("static const struct openxr_func xr_instance_dispatch_table[] =\n{\n") + for xr_func in self.registry.instance_funcs: + if not xr_func.needs_exposing(): + continue + + f.write(" {{\"{0}\", {0}}},\n".format(xr_func.name)) + f.write("};\n\n") + + f.write("void *wine_xr_get_instance_proc_addr(const char *name)\n") + f.write("{\n") + f.write(" unsigned int i;\n") + f.write(" for (i = 0; i < ARRAY_SIZE(xr_instance_dispatch_table); i++)\n") + f.write(" {\n") + f.write(" if (strcmp(xr_instance_dispatch_table[i].name, name) == 0)\n") + f.write(" {\n") + f.write(" TRACE(\"Found name=%s in instance table\\n\", debugstr_a(name));\n") + f.write(" return xr_instance_dispatch_table[i].func;\n") + f.write(" }\n") + f.write(" }\n") + f.write(" return NULL;\n") + f.write("}\n") + + def generate_loader_thunks_h(self, f): + self._generate_copyright(f) + + f.write("#ifndef __WINE_OPENXR_LOADER_THUNKS_H\n") + f.write("#define __WINE_OPENXR_LOADER_THUNKS_H\n\n") + + f.write("enum unix_call\n") + f.write("{\n") + f.write(" unix_init,\n") + for xr_func in self.registry.funcs.values(): + if not xr_func.needs_exposing(): + continue + if xr_func.name in MANUAL_LOADER_FUNCTIONS: + continue + + f.write(" unix_{0},\n".format(xr_func.name)) + f.write(" unix_count,\n") + f.write("};\n\n") + + for xr_func in self.registry.funcs.values(): + if not xr_func.needs_exposing(): + continue + if xr_func.name in MANUAL_LOADER_FUNCTIONS: + continue + + f.write("struct {0}_params\n".format(xr_func.name)) + f.write("{\n"); + extra_param_is_new = True + for p in xr_func.params: + f.write(" {0};\n".format(p.definition(is_member=True))) + if p.name == xr_func.extra_param: + extra_param_is_new = False + + if xr_func.extra_param and extra_param_is_new: + f.write(" void *{0};\n".format(xr_func.extra_param)) + if xr_func.type != "void": + f.write(" {0} result;\n".format(xr_func.type)) + f.write("};\n\n"); + + f.write("#endif /* __WINE_OPENXR_LOADER_THUNKS_H */\n") + def generate_openxr_h(self, f): self._generate_copyright(f) f.write("#ifndef __WINE_OPENXR_H\n") @@ -2328,7 +2835,7 @@ class XrGenerator(object): f.write("#define WINE_XR_ALIGN DECLSPEC_ALIGN\n") f.write("#endif\n\n") - f.write("#ifdef __x86_64__\n") + f.write("#if defined(__x86_64__) || defined(__aarch64__)\n") f.write("#define XR_PTR_SIZE 8\n") f.write("#endif\n\n") @@ -2365,24 +2872,21 @@ class XrGenerator(object): if enum.required: f.write(enum.definition()) + for fp in self.registry.funcpointers: + if fp.required: + f.write(fp.definition()) + f.write("\n") + # This generates both structures and unions. Since structures # may depend on other structures/unions, we need a list of # decoupled structs. # Note: unions are stored in structs for dependency reasons, # see comment in parsing section. structs = XrStruct.decouple_structs(self.registry.structs) - - for struct in structs: - f.write(struct.typedef()) - - for fp in self.registry.funcpointers: - if fp.required: - f.write(fp.definition()) - f.write("\n") - for struct in structs: LOGGER.debug("Generating struct: {0}".format(struct.name)) f.write(struct.definition(align=True)) + f.write("\n") for func in self.registry.funcs.values(): if not func.is_required(): @@ -2404,7 +2908,6 @@ class XrGenerator(object): f.write("#endif /* __WINE_OPENXR_H */\n") - class XrRegistry(object): def __init__(self, reg_filename): # Used for storage of type information. @@ -2437,6 +2940,7 @@ class XrRegistry(object): # function call we want we set a member 'required' to True. tree = ET.parse(reg_filename) root = tree.getroot() + self._parse_enums(root) self._parse_types(root) self._parse_commands(root) @@ -2445,6 +2949,11 @@ class XrRegistry(object): self._parse_features(root) self._parse_extensions(root) + for enum in self.enums.values(): + enum.fixup_64bit_aliases() + + self._match_object_types() + self.copyright = root.find('./comment').text def _is_feature_supported(self, feature): @@ -2460,42 +2969,38 @@ class XrRegistry(object): # support yet or because they are for platforms other than win32. return extension not in UNSUPPORTED_EXTENSIONS - def mark_bitmask_dependencies(self, bitmask): - if bitmask.requires is not None: - self.types[bitmask.requires]["data"].required = True + def _mark_type_required(self, type_info): + """ Helper function to mark a certain types and the datatypes they needs as required.""" + def mark_bitmask_dependencies(bitmask, types): + if bitmask.requires is not None: + self._mark_type_required(types[bitmask.requires]) - def mark_funcpointer_dependencies(self, fp): - for m in fp.members: - type_info = self.types[m.type] + def mark_funcpointer_dependencies(fp, types): + for m in fp.members: + self._mark_type_required(types[m.type]) - # Complex types have a matching definition e.g. XrStruct. - # Not needed for base types such as uint32_t. - if "data" in type_info: - self.types[m.type]["data"].required = True + def mark_struct_dependencies(struct, types): + for m in struct: + type_info = types[m.type] - def mark_struct_dependencies(self, struct): - for m in struct: - type_info = self.types[m.type] + if struct.name != m.type: + self._mark_type_required(types[m.type]) + # Check if we are dealing with a complex type e.g. XrEnum, XrStruct and others. + if "data" not in type_info: + return - # Complex types have a matching definition e.g. XrStruct. - # Not needed for base types such as uint32_t. - if "data" in type_info: - if self.types[m.type]["data"].required: - continue - self.types[m.type]["data"].required = True - - if type_info["category"] == "struct": - # Yay, recurse - self.mark_struct_dependencies(type_info["data"]) - elif type_info["category"] == "funcpointer": - self.mark_funcpointer_dependencies(type_info["data"]) - elif type_info["category"] == "bitmask": - self.mark_bitmask_dependencies(type_info["data"]) + # Mark the complex type as required. + type_info["data"].required = True + if type_info["category"] == "struct": + mark_struct_dependencies(type_info["data"], self.types) + elif type_info["category"] == "funcpointer": + mark_funcpointer_dependencies(type_info["data"], self.types) + elif type_info["category"] == "bitmask": + mark_bitmask_dependencies(type_info["data"], self.types) def _mark_command_required(self, command): """ Helper function to mark a certain command and the datatypes it needs as required.""" - LOGGER.debug("marking " + command + " as required") func = self.funcs[command] func.required = True @@ -2505,22 +3010,25 @@ class XrRegistry(object): # Analyze parameter dependencies and pull in any type needed. for p in func.params: - type_info = self.types[p.type] + self._mark_type_required(self.types[p.type]) - # Check if we are dealing with a complex type e.g. XrEnum, XrStruct and others. - if "data" not in type_info: + def _match_object_types(self): + """ Matches each handle with the correct object type. """ + # Use upper case comparison for simplicity. + object_types = {} + for value in self.enums["XrObjectType"].values: + object_name = "XR" + value.name[len("XR_OBJECT_TYPE"):].replace("_", "") + object_types[object_name] = value.name + + for handle in self.handles: + if not handle.is_required(): continue - - # Mark the complex type as required. - type_info["data"].required = True - if type_info["category"] == "struct": - struct = type_info["data"] - self.mark_struct_dependencies(struct) - elif type_info["category"] == "bitmask": - self.mark_bitmask_dependencies(type_info["data"]) + handle.object_type = object_types.get(handle.name.upper()) + if not handle.object_type: + LOGGER.warning("No object type found for {}".format(handle.name)) def _parse_commands(self, root): - """ Parse command section containing the OpenXR function calls. """ + """ Parse command section containing the Vulkan function calls. """ funcs = {} commands = root.findall("./commands/") @@ -2538,16 +3046,20 @@ class XrRegistry(object): continue func = XrFunction.from_xml(command, self.types) - funcs[func.name] = func + + if func: + funcs[func.name] = func for command in alias_commands: alias_name = command.attrib.get("alias") alias = funcs[alias_name] func = XrFunction.from_alias(command, alias) - funcs[func.name] = func + if func: + funcs[func.name] = func # To make life easy for the code generation, separate all function - # calls out in the 3 types of functions: device, global and instance. + # calls out in the 4 types of Vulkan functions: + # device, global, physical device and instance. instance_funcs = [] for func in funcs.values(): if not func.name in NOT_OUR_FUNCTIONS: @@ -2569,7 +3081,9 @@ class XrRegistry(object): _type = enum.attrib.get("type") if _type in ("enum", "bitmask"): - enums[name] = XrEnum.from_xml(enum) + enum_obj = XrEnum.from_xml(enum) + if enum_obj: + enums[name] = enum_obj else: # If no type is set, we are dealing with API constants. for value in enum.findall("enum"): @@ -2607,7 +3121,7 @@ class XrRegistry(object): if "bitpos" in enum_elem.keys(): # We need to add an extra value to an existing enum type. # E.g. XR_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG to XrFormatFeatureFlagBits. - enum.add(XrEnumValue(enum_elem.attrib["name"], value=(1 << int(enum_elem.attrib["bitpos"])), hex=True)) + enum.create_bitpos(enum_elem.attrib["name"], int(enum_elem.attrib["bitpos"])) elif "offset" in enum_elem.keys(): # Extensions promoted to Core, have the extension number as part @@ -2624,24 +3138,31 @@ class XrRegistry(object): if direction is not None: value = -value - enum.add(XrEnumValue(enum_elem.attrib["name"], value=value)) + enum.create_value(enum_elem.attrib["name"], str(value)) elif "value" in enum_elem.keys(): - enum.add(XrEnumValue(enum_elem.attrib["name"], value=int(enum_elem.attrib["value"]))) + enum.create_value(enum_elem.attrib["name"], enum_elem.attrib["value"]) elif "alias" in enum_elem.keys(): - enum.add(XrEnumValue(enum_elem.attrib["name"], alias=enum_elem.attrib["alias"])) + enum.create_alias(enum_elem.attrib["name"], enum_elem.attrib["alias"]) elif "value" in enum_elem.keys(): - # Constants are not aliased, no need to add them here, they'll get added later on. + # Constant with an explicit value if only_aliased: return self.consts.append(XrConstant(enum_elem.attrib["name"], enum_elem.attrib["value"])) + elif "alias" in enum_elem.keys(): + # Aliased constant + if not only_aliased: + return + + self.consts.append(XrConstant(enum_elem.attrib["name"], enum_elem.attrib["alias"])) @staticmethod def _require_type(type_info): if type_info.is_alias(): type_info = type_info.alias + type_info.required = True if type(type_info) == XrStruct: for member in type_info.members: @@ -2653,6 +3174,7 @@ class XrRegistry(object): extensions = [] exts = root.findall("./extensions/extension") deferred_exts = [] + skipped_exts = UNSUPPORTED_EXTENSIONS.copy() def process_ext(ext, deferred=False): ext_name = ext.attrib["name"] @@ -2662,11 +3184,19 @@ class XrRegistry(object): commands = ext.findall("require/command") for command in commands: cmd_name = command.attrib["name"] - self.funcs[cmd_name].extensions.append(ext_name) + # Need to verify that the command is defined, and otherwise skip it. + # xrCreateScreenSurfaceQNX is declared in but not defined in + # . A command without a definition cannot be enabled, so it's valid for + # the XML file to handle this, but because of the manner in which we parse the XML + # file we pre-populate from before we check if a command is enabled. + if cmd_name in self.funcs: + self.funcs[cmd_name].extensions.add(ext_name) - # Some extensions are not ready or have numbers reserved as a place holder. - if ext.attrib["supported"] == "disabled": + # Some extensions are not ready or have numbers reserved as a place holder + # or are only supported for VulkanSC. + if not "openxr" in ext.attrib["supported"].split(","): LOGGER.debug("Skipping disabled extension: {0}".format(ext_name)) + skipped_exts.append(ext_name) return protect = ext.attrib.get("protect", None) @@ -2680,10 +3210,11 @@ class XrRegistry(object): return # Disable highly experimental extensions as the APIs are unstable and can - # change between minor revisions until API is final and becomes KHR + # change between minor Vulkan revisions until API is final and becomes KHR # or NV. - if "KHX" in ext_name or "NVX" in ext_name: + if ("KHX" in ext_name or "NVX" in ext_name) and ext_name not in ALLOWED_X_EXTENSIONS: LOGGER.debug("Skipping experimental extension: {0}".format(ext_name)) + skipped_exts.append(ext_name) return # Extensions can define XrEnumValues which alias to provisional extensions. Pre-process @@ -2696,15 +3227,23 @@ class XrRegistry(object): platform = ext.attrib.get("platform") if platform and platform != "win32": LOGGER.debug("Skipping extensions {0} for platform {1}".format(ext_name, platform)) + skipped_exts.append(ext_name) return if not self._is_extension_supported(ext_name): LOGGER.debug("Skipping unsupported extension: {0}".format(ext_name)) + skipped_exts.append(ext_name) return elif "requires" in ext.attrib: # Check if this extension builds on top of another unsupported extension. requires = ext.attrib["requires"].split(",") - if len(set(requires).intersection(UNSUPPORTED_EXTENSIONS)) > 0: + if len(set(requires).intersection(skipped_exts)) > 0: + skipped_exts.append(ext_name) + return + elif "depends" in ext.attrib: + # The syntax for this is more complex, but this is good enough for now. + if any([sext in ext.attrib["depends"] for sext in skipped_exts]): + skipped_exts.append(ext_name) return LOGGER.debug("Loading extension: {0}".format(ext_name)) @@ -2718,9 +3257,11 @@ class XrRegistry(object): self._process_require_enum(enum_elem, ext) for t in require.findall("type"): - if t.attrib["name"] in self.types: - type_info = self.types[t.attrib["name"]]["data"] - self._require_type(type_info) + if not t.attrib["name"] in self.types: + continue + + type_info = self.types[t.attrib["name"]]["data"] + self._require_type(type_info) feature = require.attrib.get("feature") if feature and not self._is_feature_supported(feature): continue @@ -2758,6 +3299,8 @@ class XrRegistry(object): """ Parse the feature section, which describes Core commands and types needed. """ for feature in root.findall("./feature"): + if not api_is_openxr(feature): + continue feature_name = feature.attrib["name"] for require in feature.findall("require"): LOGGER.info("Including features for {0}".format(require.attrib.get("comment"))) @@ -2768,7 +3311,6 @@ class XrRegistry(object): if not self._is_feature_supported(feature_name): continue name = tag.attrib["name"] - LOGGER.debug("found command: " + name) self._mark_command_required(name) elif tag.tag == "enum": self._process_require_enum(tag) @@ -2779,8 +3321,7 @@ class XrRegistry(object): if name == "openxr_platform_defines": continue - type_info = self.types[name] - type_info["data"].required = True + self._mark_type_required(self.types[name]) def _parse_types(self, root): """ Parse types section, which contains all data types e.g. structs, typedefs etcetera. """ @@ -2819,31 +3360,48 @@ class XrRegistry(object): _type = None if not t.find("type") is None: _type = t.find("type").text - basetype = XrBaseType(name, _type, collect_element_text(t)) - base_types.append(basetype) - type_info["data"] = basetype +# tail = t.find("type").tail +# if tail is not None: +# _type += tail.strip() + + if (_type == "XR_DEFINE_ATOM"): + _type = "uint64_t" + elif (_type == "XR_DEFINE_OPAQUE_64"): + _type = "struct " + name + "_T*" + + basetype = XrBaseType(name, _type) + if basetype: + base_types.append(basetype) + type_info["data"] = basetype + else: + continue # Basic C types don't need us to define them, but we do need data for them if type_info["requires"] == "xr_platform": requires = type_info["requires"] - basic_c = XrBaseType(name, _type, collect_element_text(t), requires=requires) + basic_c = XrBaseType(name, _type, requires=requires) type_info["data"] = basic_c if type_info["category"] == "bitmask": name = t.find("name").text _type = t.find("type").text - # Most bitmasks have a requires attribute used to pull in + # Most bitmasks have a bitvalues attribute used to pull in # required '*FlagBits" enum. + type_info["requires"] = t.attrib.get("bitvalues", None) + requires = type_info["requires"] - bitmask = XrBaseType(name, _type, collect_element_text(t), requires=requires) + bitmask = XrBaseType(name, _type, requires=requires) bitmasks.append(bitmask) type_info["data"] = bitmask if type_info["category"] == "define": define = XrDefine.from_xml(t) - defines.append(define) - type_info["data"] = define + if define: + defines.append(define) + type_info["data"] = define + else: + continue if type_info["category"] == "enum": name = t.attrib.get("name") @@ -2851,7 +3409,7 @@ class XrRegistry(object): # Since we already parsed the enum before, just link it in. try: type_info["data"] = self.enums[name] - except KeyError as e: + except KeyError: # Not all enums seem to be defined yet, typically that's for # ones ending in 'FlagBits' where future extensions may add # definitions. @@ -2859,13 +3417,19 @@ class XrRegistry(object): if type_info["category"] == "funcpointer": funcpointer = XrFunctionPointer.from_xml(t) - funcpointers.append(funcpointer) - type_info["data"] = funcpointer + if funcpointer: + funcpointers.append(funcpointer) + type_info["data"] = funcpointer + else: + continue if type_info["category"] == "handle": handle = XrHandle.from_xml(t) - handles.append(handle) - type_info["data"] = handle + if handle: + handles.append(handle) + type_info["data"] = handle + else: + continue if type_info["category"] in ["struct", "union"]: # We store unions among structs as some structs depend @@ -2873,8 +3437,11 @@ class XrRegistry(object): # generation anyway. The official Vulkan scripts use # a similar kind of hack. struct = XrStruct.from_xml(t) - structs.append(struct) - type_info["data"] = struct + if struct: + structs.append(struct) + type_info["data"] = struct + else: + continue # Name is in general within a name tag else it is an optional # attribute on the type tag. @@ -2899,7 +3466,7 @@ class XrRegistry(object): alias = t.attrib.get("alias") if type_info["category"] == "bitmask": - bitmask = XrBaseType(type_info["name"], alias, collect_element_text(t), alias=self.types[alias]["data"]) + bitmask = XrBaseType(type_info["name"], alias, alias=self.types[alias]["data"]) bitmasks.append(bitmask) type_info["data"] = bitmask @@ -2939,8 +3506,6 @@ class XrRegistry(object): s = self.types[structextend]["data"] s.struct_extensions.append(struct) - self.mark_struct_dependencies(struct) - # Guarantee everything is sorted, so code generation doesn't have # to deal with this. self.base_types = sorted(base_types, key=lambda base_type: base_type.name) @@ -2949,19 +3514,31 @@ class XrRegistry(object): self.enums = OrderedDict(sorted(self.enums.items())) self.funcpointers = funcpointers self.handles = sorted(handles, key=lambda handle: handle.name) - self.structs = sorted(structs, key=lambda struct: (struct.dep_level, struct.name)) + self.structs = sorted(structs, key=lambda struct: struct.name) -def collect_element_text(e): - return "".join(e.itertext()) +def generate_openxr_json(f): + f.write("{\n") + f.write(" \"file_format_version\": \"1.0.0\",\n") + f.write(" \"ICD\": {\n") + f.write(" \"library_path\": \".\\\\wineopenxr.dll\",\n") + f.write(" \"api_version\": \"{0}\"\n".format(XR_XML_VERSION)) + f.write(" }\n") + f.write("}\n") def set_working_directory(): path = os.path.abspath(__file__) path = os.path.dirname(path) os.chdir(path) +def download_xr_xml(filename): + url = "https://raw.githubusercontent.com/KhronosGroup/OpenXR-SDK/release-{0}/specification/registry/xr.xml".format(XR_XML_VERSION) + if not os.path.isfile(filename): + urllib.request.urlretrieve(url, filename) + def main(): parser = argparse.ArgumentParser() parser.add_argument("-v", "--verbose", action="count", default=0, help="increase output verbosity") + parser.add_argument("-x", "--xml", default=None, type=str, help="path to specification XML file") args = parser.parse_args() if args.verbose == 0: @@ -2973,7 +3550,12 @@ def main(): set_working_directory() - xr_xml = "xr.xml".format(XR_XML_VERSION) + if args.xml: + xr_xml = args.xml + else: + xr_xml = "xr-{0}.xml".format(XR_XML_VERSION) + download_xr_xml(xr_xml) + registry = XrRegistry(xr_xml) generator = XrGenerator(registry) @@ -2984,7 +3566,16 @@ def main(): generator.generate_thunks_h(f, "wine_") with open(WINE_OPENXR_THUNKS_C, "w") as f: - generator.generate_thunks_c(f, "wine_") + generator.generate_thunks_c(f) + + with open(WINE_OPENXR_LOADER_THUNKS_H, "w") as f: + generator.generate_loader_thunks_h(f) + + with open(WINE_OPENXR_LOADER_THUNKS_C, "w") as f: + generator.generate_loader_thunks_c(f) + + with open(WINE_OPENXR_JSON, "w") as f: + generate_openxr_json(f) if __name__ == "__main__": main() diff --git a/wineopenxr/openxr.c b/wineopenxr/openxr.c index d85c2121..05bf2820 100644 --- a/wineopenxr/openxr.c +++ b/wineopenxr/openxr.c @@ -1,2475 +1,438 @@ -#include -#define __USE_GNU +#if 0 +#pragma makedep unix +#endif + +#define _GNU_SOURCE #include -#define COBJMACROS -#include "initguid.h" +#include "ntstatus.h" +#define WIN32_NO_STATUS #include "windef.h" -#include "winbase.h" -#include "winnls.h" -#include "windows.h" -#include "winternl.h" -#include "wine/debug.h" -#include "dxgi.h" -#include "d3d11.h" -#include "d3d11_3.h" -#include "d3d12.h" - -#include "wine/rbtree.h" - -/* we want to use the native linux header */ -#pragma push_macro("_WIN32") -#pragma push_macro("__cdecl") -#undef _WIN32 -#undef __cdecl -#define XR_USE_GRAPHICS_API_OPENGL 1 -#define XR_USE_GRAPHICS_API_VULKAN 1 - -#define WINE_UNIX_LIB -#include "wine/vulkan.h" -PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char *pName); -VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance); -void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator); -void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties); -#undef WINE_UNIX_LIB - -#define VULKAN_H_ 1// tell dxvk-interop not to include vulkan.h -#include "dxvk-interop.h" -#include "vkd3d-proton-interop.h" -#undef WINE_VK_HOST -#define XR_USE_GRAPHICS_API_D3D11 1 -#define XR_USE_GRAPHICS_API_D3D12 1 -#include -#pragma pop_macro("_WIN32") -#pragma pop_macro("__cdecl") - -typedef struct XrApiLayerCreateInfo XrApiLayerCreateInfo; -typedef struct XrNegotiateLoaderInfo XrNegotiateLoaderInfo; -typedef struct XrNegotiateApiLayerRequest XrNegotiateApiLayerRequest; -typedef struct XrNegotiateRuntimeRequest XrNegotiateRuntimeRequest; +#include "winnt.h" +#include "wine/server_protocol.h" #include "openxr_private.h" -#include "wine/vulkan_driver.h" -#include "wine/unixlib.h" - WINE_DEFAULT_DEBUG_CHANNEL(openxr); -union CompositionLayer { - XrCompositionLayerProjection projection; - XrCompositionLayerQuad quad; - XrCompositionLayerCubeKHR cube; - XrCompositionLayerDepthInfoKHR depth_info; - XrCompositionLayerCylinderKHR cylinder; - XrCompositionLayerEquirectKHR equirect; - XrCompositionLayerEquirect2KHR equirect2; -}; - -#define heap_alloc(s) HeapAlloc(GetProcessHeap(), 0, s) -#define heap_alloc_zero(s) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, s) -#define heap_free(p) HeapFree(GetProcessHeap(), 0, p) - -static void *heap_realloc(void *p, size_t s) -{ - if(!p) return heap_alloc(s); - return HeapReAlloc(GetProcessHeap(), 0, p, s); -} - -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"; - -static struct -{ - const char *win32_ext, *linux_ext; - BOOL remove_original; - BOOL force_enable; -} -substitute_extensions[] = -{ +static struct { + const char *win32_ext, *linux_ext; + BOOL remove_original; + BOOL force_enable; +} substitute_extensions[] = { {"XR_KHR_D3D11_enable", "XR_KHR_vulkan_enable"}, {"XR_KHR_D3D12_enable", "XR_KHR_vulkan_enable"}, {"XR_KHR_win32_convert_performance_counter_time", "XR_KHR_convert_timespec_time", TRUE, TRUE}, }; -static char *wineopenxr_strdup(const char *src) -{ - const size_t l = strlen(src) + 1; - char *r = heap_alloc(l); - strcpy(r, src); - return r; +struct openxr_instance_funcs g_xr_host_instance_dispatch_table; + +VkDevice (*get_native_VkDevice)(VkDevice); +VkInstance (*get_native_VkInstance)(VkInstance); +VkPhysicalDevice (*get_native_VkPhysicalDevice)(VkPhysicalDevice); +VkPhysicalDevice (*get_wrapped_VkPhysicalDevice)(VkInstance, VkPhysicalDevice); +VkQueue (*get_native_VkQueue)(VkQueue); + +XrResult WINAPI wine_xrCreateInstance(const XrInstanceCreateInfo *createInfo, XrInstance *instance) { + XrResult res; + uint32_t i, j, count = 0; + XrInstanceCreateInfo our_createInfo; + const char *ext_name; + const char **new_list; + + TRACE("%p, %p\n", createInfo, instance); + + TRACE("Incoming extensions:\n"); + for (i = 0; i < createInfo->enabledExtensionCount; ++i) { + TRACE(" -%s\n", createInfo->enabledExtensionNames[i]); + } + + new_list = malloc(createInfo->enabledExtensionCount * sizeof(*new_list)); + + /* remove win32 extensions */ + for (i = 0; i < createInfo->enabledExtensionCount; ++i) { + ext_name = createInfo->enabledExtensionNames[i]; + for (j = 0; j < ARRAY_SIZE(substitute_extensions); ++j) { + if (!strcmp(ext_name, substitute_extensions[j].win32_ext)) { + if (substitute_extensions[j].force_enable) { + ext_name = NULL; + } else { + ext_name = substitute_extensions[j].linux_ext; + } + break; + } + } + if (ext_name) { + new_list[count++] = ext_name; + } + } + + our_createInfo = *createInfo; + our_createInfo.enabledExtensionNames = (const char *const *)new_list; + our_createInfo.enabledExtensionCount = count; + createInfo = &our_createInfo; + + TRACE("Enabled extensions:\n"); + for (i = 0; i < createInfo->enabledExtensionCount; ++i) { + TRACE(" -%s\n", createInfo->enabledExtensionNames[i]); + } + + res = xrCreateInstance(createInfo, instance); + if (res != XR_SUCCESS) { + WARN("xrCreateInstance failed: %d\n", res); + goto cleanup; + } + +#define USE_XR_FUNC(x) \ + xrGetInstanceProcAddr(*instance, #x, (PFN_xrVoidFunction *)&g_xr_host_instance_dispatch_table.p_##x); + ALL_XR_INSTANCE_FUNCS() +#undef USE_XR_FUNC + +cleanup: + free((void *)our_createInfo.enabledExtensionNames); + return res; } -struct handle_instance_lookup_entry -{ - struct rb_entry entry; - uint64_t handle; - struct openxr_instance_funcs *funcs; -}; +XrResult WINAPI wine_xrCreateSession(XrInstance instance, const XrSessionCreateInfo *createInfo, XrSession *session) { + wine_XrInstance *wine_instance = wine_instance_from_handle(instance); + XrResult res; + XrSessionCreateInfo our_create_info; + XrGraphicsBindingVulkanKHR our_vk_binding; -static struct rb_tree handle_instance_lookup; -static SRWLOCK handle_instance_lookup_lock = SRWLOCK_INIT; -static struct wine_XrInstance *last_instance; + if (createInfo->next) { + switch (((XrBaseInStructure *)createInfo->next)->type) { + case XR_TYPE_GRAPHICS_BINDING_VULKAN2_KHR /* == XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR */: { + const XrGraphicsBindingVulkanKHR *their_vk_binding = (const XrGraphicsBindingVulkanKHR *)createInfo->next; -static int wrapper_entry_compare(const void *key, const struct rb_entry *entry) -{ - struct handle_instance_lookup_entry *wrapper = RB_ENTRY_VALUE(entry, struct handle_instance_lookup_entry, entry); - const uint64_t *handle = key; - if (*handle < wrapper->handle) return -1; - if (*handle > wrapper->handle) return 1; - return 0; + our_vk_binding = *their_vk_binding; + our_vk_binding.instance = get_native_VkInstance(their_vk_binding->instance); + our_vk_binding.physicalDevice = get_native_VkPhysicalDevice(their_vk_binding->physicalDevice); + our_vk_binding.device = get_native_VkDevice(their_vk_binding->device); + + our_create_info = *createInfo; + our_create_info.next = &our_vk_binding; + createInfo = &our_create_info; + break; + } + default: + WARN("Unhandled graphics binding type: %d\n", ((XrBaseInStructure *)createInfo->next)->type); + break; + } + } + + res = g_xr_host_instance_dispatch_table.p_xrCreateSession(wine_instance->host_instance, createInfo, session); + if (res != XR_SUCCESS) { + WARN("xrCreateSession failed: %d\n", res); + return res; + } + + return XR_SUCCESS; } -VkDevice(*get_native_VkDevice)(VkDevice); -VkInstance(*get_native_VkInstance)(VkInstance); -VkPhysicalDevice(*get_native_VkPhysicalDevice)(VkPhysicalDevice); -VkPhysicalDevice(*get_wrapped_VkPhysicalDevice)(VkInstance, VkPhysicalDevice); -VkQueue(*get_native_VkQueue)(VkQueue); -VkResult (WINAPI *p_wine_vkCreateInstance)(const VkInstanceCreateInfo *create_info, - const VkAllocationCallbacks *allocator, VkInstance *ret); -VkResult (WINAPI *p_wine_vkCreateDevice)(VkPhysicalDevice phys_dev, const VkDeviceCreateInfo *create_info, - const VkAllocationCallbacks *allocator, VkDevice *ret); - -static void *get_winevulkan_unix_lib_handle(HMODULE hvulkan) -{ - unixlib_handle_t unix_funcs; - NTSTATUS status; - Dl_info info; - - status = NtQueryVirtualMemory(GetCurrentProcess(), hvulkan, (MEMORY_INFORMATION_CLASS)1000 /*MemoryWineUnixFuncs*/, - &unix_funcs, sizeof(unix_funcs), NULL); - if (status) - { - WINE_ERR("NtQueryVirtualMemory status %#x.\n", (int)status); - return NULL; - } - if (!dladdr((void *)(ULONG_PTR)unix_funcs, &info)) - { - WINE_ERR("dladdr failed.\n"); - return NULL; - } - WINE_TRACE("path %s.\n", info.dli_fname); - return dlopen(info.dli_fname, RTLD_NOW); -} - -static void load_vk_unwrappers(void) -{ - static HMODULE h = NULL; - void *unix_handle; - - if(h) - /* already loaded */ - return; - - h = LoadLibraryA("winevulkan"); - if(!h){ - WINE_ERR("unable to load winevulkan\n"); - return; - } - - p_wine_vkCreateInstance = (void *)GetProcAddress(h, "vkCreateInstance"); - p_wine_vkCreateDevice = (void *)GetProcAddress(h, "vkCreateDevice"); - - if (!(unix_handle = get_winevulkan_unix_lib_handle(h))) - { - WINE_ERR("Unable to open winevulkan.so.\n"); - return; - } - -#define L(name) \ - if (!(name = dlsym(unix_handle, "__wine_"#name))) \ - {\ - WINE_ERR("%s not found.\n", #name);\ - dlclose(unix_handle);\ - return;\ - } - - L(get_native_VkDevice); - L(get_native_VkInstance); - L(get_native_VkPhysicalDevice); - L(get_wrapped_VkPhysicalDevice); - L(get_native_VkQueue); -#undef L - - dlclose(unix_handle); -} - -#define XR_CURRENT_LOADER_API_LAYER_VERSION 1 -#define XR_CURRENT_LOADER_RUNTIME_VERSION 1 -#define XR_LOADER_INFO_STRUCT_VERSION 1 -#define XR_RUNTIME_INFO_STRUCT_VERSION 1 - -typedef enum XrLoaderInterfaceStructs { - XR_LOADER_INTERFACE_STRUCT_UNINTIALIZED = 0, - XR_LOADER_INTERFACE_STRUCT_LOADER_INFO, - XR_LOADER_INTERFACE_STRUCT_API_LAYER_REQUEST, - XR_LOADER_INTERFACE_STRUCT_RUNTIME_REQUEST, - XR_LOADER_INTERFACE_STRUCT_API_LAYER_CREATE_INFO, - XR_LOADER_INTERFACE_STRUCT_API_LAYER_NEXT_INFO, -} XrLoaderInterfaceStructs; - -typedef struct XrApiLayerNextInfo XrApiLayerNextInfo; - -#define XR_API_LAYER_MAX_SETTINGS_PATH_SIZE 512 -#define XR_API_LAYER_CREATE_INFO_STRUCT_VERSION 1 -typedef struct XrApiLayerCreateInfo { - XrLoaderInterfaceStructs structType; - uint32_t structVersion; - size_t structSize; - void *loaderInstance; - char settings_file_location[XR_API_LAYER_MAX_SETTINGS_PATH_SIZE]; - XrApiLayerNextInfo *nextInfo; -} XrApiLayerCreateInfo; - -typedef XrResult(__stdcall *PFN_xrCreateApiLayerInstance)(const XrInstanceCreateInfo *info, - const XrApiLayerCreateInfo *apiLayerInfo, XrInstance *instance); - -#define XR_API_LAYER_NEXT_INFO_STRUCT_VERSION 1 -struct XrApiLayerNextInfo { - XrLoaderInterfaceStructs structType; - uint32_t structVersion; - size_t structSize; - char layerName[XR_MAX_API_LAYER_NAME_SIZE]; - PFN_xrGetInstanceProcAddr nextGetInstanceProcAddr; - PFN_xrCreateApiLayerInstance nextCreateApiLayerInstance; - XrApiLayerNextInfo *next; -}; - -#define WINE_XR_STRUCT_NAME(x) x##_win -#define WINE_XR_STRUCT_ATTR __attribute__((ms_struct)) -#include "loader_structs.h" -#undef WINE_XR_STRUCT_ATTR -#undef WINE_XR_STRUCT_NAME - -#define WINE_XR_STRUCT_NAME(x) x##_host -#define WINE_XR_STRUCT_ATTR -#include "loader_structs.h" -#undef WINE_XR_STRUCT_ATTR -#undef WINE_XR_STRUCT_NAME - -static char *g_instance_extensions, *g_device_extensions; -static uint32_t g_physdev_vid, g_physdev_pid; -static XrVersion api_version = XR_CURRENT_API_VERSION; - -static char *strdupA(const char *s) -{ - size_t l = strlen(s) + 1; - char *r = heap_alloc(l); - memcpy(r, s, l); - return r; -} - -static CRITICAL_SECTION session_list_lock = { NULL, -1, 0, 0, 0, 0 }; -static struct list session_list = LIST_INIT(session_list); - -static wine_XrSession *get_wrapped_XrSession(XrSession native) -{ - wine_XrSession *cursor; - - EnterCriticalSection(&session_list_lock); - - LIST_FOR_EACH_ENTRY(cursor, &session_list, wine_XrSession, entry){ - if(cursor->session == native) - break; - } - - LeaveCriticalSection(&session_list_lock); - - if(&cursor->entry == &session_list) - return NULL; - - return cursor; -} - -static void parse_extensions(const char *in, uint32_t *out_count, - char ***out_strs) -{ - char *iter, *start; - char **list, *str = strdupA(in); - uint32_t extension_count = 0, o = 0; - - iter = str; - while(*iter){ - if(*iter++ == ' ') - extension_count++; - } - /* count the one ending in NUL */ - if(iter != str) - extension_count++; - if(!extension_count){ - *out_count = 0; - *out_strs = NULL; - return; - } - - list = heap_alloc(extension_count * sizeof(char *)); - - start = iter = str; - do{ - if(*iter == ' '){ - *iter = 0; - list[o++] = strdupA(start); - WINE_TRACE("added %s to list\n", list[o-1]); - iter++; - start = iter; - }else if(*iter == 0){ - list[o++] = strdupA(start); - WINE_TRACE("added %s to list\n", list[o-1]); - break; - }else{ - iter++; - } - }while(1); - - *out_count = extension_count; - *out_strs = list; -} - -static BOOL get_vulkan_extensions(void) -{ - /* Linux SteamVR's xrCreateInstance will hang forever if SteamVR hasn't - * already been launched by the user. Since that's the only way to tell if - * OpenXR is functioning, let's use OpenVR to tell whether SteamVR is - * functioning before calling xrCreateInstance. - * - * This should be removed when SteamVR's bug is fixed. */ - DWORD type, value, wait_status = 0, size; - LSTATUS status; - HANDLE event; - HKEY vr_key; - - if ((status = RegOpenKeyExA(HKEY_CURRENT_USER, "Software\\Wine\\VR", 0, KEY_READ, &vr_key))) - { - WINE_ERR("Could not create key, status %#x.\n", status); - return FALSE; - } - - size = sizeof(value); - if ((status = RegQueryValueExA(vr_key, "state", NULL, &type, (BYTE *)&value, &size))) - { - WINE_ERR("Could not query value, status %#x.\n", status); - RegCloseKey(vr_key); - return FALSE; - } - if (type != REG_DWORD) - { - WINE_ERR("Unexpected value type %#x.\n", type); - RegCloseKey(vr_key); - return FALSE; - } - - if (value) - goto done; - - event = CreateEventA( NULL, FALSE, FALSE, NULL ); - while (1) - { - if (RegNotifyChangeKeyValue(vr_key, FALSE, REG_NOTIFY_CHANGE_LAST_SET, event, TRUE)) - { - WINE_ERR("Error registering registry change notification.\n"); - CloseHandle(event); - goto done; - } - size = sizeof(value); - if ((status = RegQueryValueExA(vr_key, "state", NULL, &type, (BYTE *)&value, &size))) - { - WINE_ERR("Could not query value, status %#x.\n", status); - CloseHandle(event); - goto done; - } - if (value) - break; - while ((wait_status = WaitForSingleObject(event, 1000)) == WAIT_TIMEOUT) - WINE_ERR("VR state wait timeout.\n"); - - if (wait_status != WAIT_OBJECT_0) - { - WINE_ERR("Got unexpected wait status %#x.\n", wait_status); - break; - } - } - CloseHandle(event); - -done: - if (value == 1) - { - if ((status = RegQueryValueExA(vr_key, "openxr_vulkan_instance_extensions", NULL, &type, NULL, &size))) - { - WINE_ERR("Error getting openxr_vulkan_instance_extensions, status %#x.\n", status); - RegCloseKey(vr_key); - return FALSE; - } - g_instance_extensions = heap_alloc(size); - if ((status = RegQueryValueExA(vr_key, "openxr_vulkan_instance_extensions", NULL, &type, (BYTE *)g_instance_extensions, &size))) - { - WINE_ERR("Error getting openxr_vulkan_instance_extensions, status %#x.\n", status); - RegCloseKey(vr_key); - return FALSE; - } - if ((status = RegQueryValueExA(vr_key, "openxr_vulkan_device_extensions", NULL, &type, NULL, &size))) - { - WINE_ERR("Error getting openxr_vulkan_device_extensions, status %#x.\n", status); - RegCloseKey(vr_key); - return FALSE; - } - g_device_extensions = heap_alloc(size); - if ((status = RegQueryValueExA(vr_key, "openxr_vulkan_device_extensions", NULL, &type, (BYTE *)g_device_extensions, &size))) - { - WINE_ERR("Error getting openxr_vulkan_device_extensions, status %#x.\n", status); - RegCloseKey(vr_key); - return FALSE; - } - if ((status = RegQueryValueExA(vr_key, "openxr_vulkan_device_vid", NULL, &type, (BYTE *)&g_physdev_vid, &size))) - { - WINE_ERR("Error getting openxr_vulkan_device_vid, status: %#x.\n", status); - RegCloseKey(vr_key); - return FALSE; - } - if ((status = RegQueryValueExA(vr_key, "openxr_vulkan_device_pid", NULL, &type, (BYTE *)&g_physdev_pid, &size))) - { - WINE_ERR("Error getting openxr_vulkan_device_pid, status: %#x.\n", status); - RegCloseKey(vr_key); - return FALSE; - } - } - - RegCloseKey(vr_key); - return value == 1; -} - -static int get_extensions( char **ret_instance_extensions, char **ret_device_extensions, - uint32_t *ret_physdev_vid, uint32_t *ret_physdev_pid ) -{ - PFN_xrGetVulkanInstanceExtensionsKHR pxrGetVulkanInstanceExtensionsKHR; - PFN_xrGetSystem pxrGetSystem; - PFN_xrGetVulkanDeviceExtensionsKHR pxrGetVulkanDeviceExtensionsKHR; - PFN_xrGetVulkanGraphicsDeviceKHR pxrGetVulkanGraphicsDeviceKHR; - PFN_xrGetVulkanGraphicsRequirementsKHR pxrGetVulkanGraphicsRequirementsKHR; - PFN_xrGetInstanceProperties pxrGetInstanceProperties; - PFN_xrEnumerateViewConfigurations pxrEnumerateViewConfigurations; - char *instance_extensions, *device_extensions; - uint32_t len, i; - XrInstance instance; - XrSystemId system; - XrResult res; - VkInstance vk_instance; - VkResult vk_res; - VkPhysicalDevice vk_physdev; - VkPhysicalDeviceProperties vk_dev_props; - - static const char *xr_extensions[] = { - "XR_KHR_vulkan_enable", - }; - - XrInstanceCreateInfo xrCreateInfo = { - .type = XR_TYPE_INSTANCE_CREATE_INFO, - .next = NULL, - .createFlags = 0, - .applicationInfo = { - .applicationVersion = 0, - .engineVersion = 0, - .apiVersion = api_version, - }, - .enabledApiLayerCount = 0, - .enabledApiLayerNames = NULL, - .enabledExtensionCount = ARRAY_SIZE(xr_extensions), - .enabledExtensionNames = xr_extensions, - }; - XrInstanceProperties inst_props = { - .type = XR_TYPE_INSTANCE_PROPERTIES, - }; - XrSystemGetInfo system_info = { - .type = XR_TYPE_SYSTEM_GET_INFO, - .formFactor = XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY, - }; - XrGraphicsRequirementsVulkanKHR reqs = { - .type = XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR, - }; - VkApplicationInfo vk_appinfo = { - .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, - .pNext = NULL, - .pApplicationName = "wineopenxr test instance", - .applicationVersion = 0, - .pEngineName = "wineopenxr test instance", - .engineVersion = VK_MAKE_VERSION(1, 0, 0), - .apiVersion = VK_MAKE_VERSION(1, 1, 0), - }; - VkInstanceCreateInfo vk_createinfo = { - .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, - .pNext = NULL, - .flags = 0, - .pApplicationInfo = &vk_appinfo, - .enabledLayerCount = 0, - .ppEnabledLayerNames = NULL, - .enabledExtensionCount = 0, - .ppEnabledExtensionNames = NULL, - }; - XrViewConfigurationType *configs; - - strcpy(xrCreateInfo.applicationInfo.applicationName, "wineopenxr test instance"); - strcpy(xrCreateInfo.applicationInfo.engineName, "wineopenxr test instance"); - - res = xrCreateInstance(&xrCreateInfo, &instance); - if (res == XR_ERROR_API_VERSION_UNSUPPORTED) - { - WINE_WARN("version %#llx unsupported.\n", (long long)api_version); - api_version = XR_MAKE_VERSION(1, 0, 0); - xrCreateInfo.applicationInfo.apiVersion = api_version; - res = xrCreateInstance(&xrCreateInfo, &instance); - } - if(res != XR_SUCCESS){ - WINE_WARN("xrCreateInstance failed: %d\n", res); - return res; - } - - xrGetInstanceProcAddr(instance, "xrGetVulkanInstanceExtensionsKHR", (PFN_xrVoidFunction *)&pxrGetVulkanInstanceExtensionsKHR); - xrGetInstanceProcAddr(instance, "xrGetVulkanDeviceExtensionsKHR", (PFN_xrVoidFunction *)&pxrGetVulkanDeviceExtensionsKHR); - xrGetInstanceProcAddr(instance, "xrGetSystem", (PFN_xrVoidFunction *)&pxrGetSystem); - xrGetInstanceProcAddr(instance, "xrGetVulkanGraphicsDeviceKHR", (PFN_xrVoidFunction *)&pxrGetVulkanGraphicsDeviceKHR); - xrGetInstanceProcAddr(instance, "xrGetVulkanGraphicsRequirementsKHR", (PFN_xrVoidFunction *)&pxrGetVulkanGraphicsRequirementsKHR); - xrGetInstanceProcAddr(instance, "xrGetInstanceProperties", (PFN_xrVoidFunction *)&pxrGetInstanceProperties); - xrGetInstanceProcAddr(instance, "xrEnumerateViewConfigurations", (PFN_xrVoidFunction *)&pxrEnumerateViewConfigurations); - - res = pxrGetInstanceProperties(instance, &inst_props); - if(res != XR_SUCCESS) - WINE_WARN("xrGetInstanceProperties failed: %d\n", res); - - res = pxrGetSystem(instance, &system_info, &system); - if(res != XR_SUCCESS){ - WINE_WARN("xrGetSystem failed: %d\n", res); - xrDestroyInstance(instance); - return res; - } - - res = pxrEnumerateViewConfigurations(instance, system, 0, &len, NULL); - if(res != XR_SUCCESS) - WINE_WARN("xrEnumerateViewConfigurations failed: %d\n", res); - configs = heap_alloc(len * sizeof(*configs)); - res = pxrEnumerateViewConfigurations(instance, system, len, &len, configs); - if(res != XR_SUCCESS) - WINE_WARN("xrEnumerateViewConfigurations failed: %d\n", res); - heap_free(configs); - - res = pxrGetVulkanGraphicsRequirementsKHR(instance, system, &reqs); - if(res != XR_SUCCESS) - WINE_WARN("xrGetVulkanGraphicsRequirementsKHR failed: %d\n", res); - - res = pxrGetVulkanInstanceExtensionsKHR(instance, system, 0, &len, NULL); - if(res != XR_SUCCESS){ - WINE_WARN("xrGetVulkanInstanceExtensionsKHR failed: %d\n", res); - xrDestroyInstance(instance); - return res; - } - instance_extensions = heap_alloc(len); - res = pxrGetVulkanInstanceExtensionsKHR(instance, system, len, &len, instance_extensions); - if(res != XR_SUCCESS){ - WINE_WARN("xrGetVulkanInstanceExtensionsKHR failed: %d\n", res); - xrDestroyInstance(instance); - heap_free(instance_extensions); - return res; - } - - parse_extensions(instance_extensions, - &vk_createinfo.enabledExtensionCount, - (char ***)&vk_createinfo.ppEnabledExtensionNames); - - vk_res = vkCreateInstance(&vk_createinfo, NULL, &vk_instance); - if(vk_res != VK_SUCCESS){ - WINE_WARN("vkCreateInstance failed: %d\n", vk_res); - for(i = 0; i < vk_createinfo.enabledExtensionCount; ++i) - heap_free((void*)vk_createinfo.ppEnabledExtensionNames[i]); - heap_free((void*)vk_createinfo.ppEnabledExtensionNames); - xrDestroyInstance(instance); - heap_free(instance_extensions); - return XR_ERROR_INITIALIZATION_FAILED; - } - - for(i = 0; i < vk_createinfo.enabledExtensionCount; ++i) - heap_free((void*)vk_createinfo.ppEnabledExtensionNames[i]); - heap_free((void*)vk_createinfo.ppEnabledExtensionNames); - - res = pxrGetVulkanGraphicsDeviceKHR(instance, system, vk_instance, &vk_physdev); - if(res != XR_SUCCESS){ - WINE_WARN("xrGetVulkanGraphicsDeviceKHR failed: %d\n", res); - vkDestroyInstance(vk_instance, NULL); - xrDestroyInstance(instance); - heap_free(instance_extensions); - return res; - } - - vkGetPhysicalDeviceProperties(vk_physdev, &vk_dev_props); - *ret_physdev_vid = vk_dev_props.vendorID; - *ret_physdev_pid = vk_dev_props.deviceID; - - res = pxrGetVulkanDeviceExtensionsKHR(instance, system, 0, &len, NULL); - if(res != XR_SUCCESS){ - WINE_WARN("pxrGetVulkanDeviceExtensionsKHR fail: %d\n", res); - vkDestroyInstance(vk_instance, NULL); - xrDestroyInstance(instance); - heap_free(instance_extensions); - return res; - } - device_extensions = heap_alloc(len); - res = pxrGetVulkanDeviceExtensionsKHR(instance, system, len, &len, device_extensions); - if(res != XR_SUCCESS){ - WINE_WARN("pxrGetVulkanDeviceExtensionsKHR fail: %d\n", res); - vkDestroyInstance(vk_instance, NULL); - xrDestroyInstance(instance); - heap_free(instance_extensions); - heap_free(device_extensions); - return res; - } - - vkDestroyInstance(vk_instance, NULL); - xrDestroyInstance(instance); - - WINE_TRACE("Got required instance extensions: %s\n", instance_extensions); - WINE_TRACE("Got required device extensions: %s\n", device_extensions); - - *ret_instance_extensions = instance_extensions; - *ret_device_extensions = device_extensions; - - return XR_SUCCESS; -} - -XrResult load_host_openxr_loader(void) -{ - if(g_instance_extensions || g_device_extensions) - /* already done */ - return XR_SUCCESS; - - if(!get_vulkan_extensions()){ - return XR_ERROR_INITIALIZATION_FAILED; - } - - load_vk_unwrappers(); - - rb_init(&handle_instance_lookup, wrapper_entry_compare); - return XR_SUCCESS; +XrResult WINAPI wine_xrCreateSwapchain(XrSession session, + const XrSwapchainCreateInfo *createInfo, + XrSwapchain *swapchain) { + return g_xr_host_instance_dispatch_table.p_xrCreateSwapchain(wine_session_from_handle(session)->host_session, + createInfo, swapchain); } XrResult WINAPI wine_xrEnumerateInstanceExtensionProperties(const char *layerName, - uint32_t propertyCapacityInput, uint32_t *propertyCountOutput, XrExtensionProperties *properties) -{ - uint32_t i, j, dst, count, extra_extensions_count; - XrResult res; + uint32_t propertyCapacityInput, + uint32_t *propertyCountOutput, + XrExtensionProperties *properties) { + uint32_t i, j, dst, count, extra_extensions_count; + XrResult res; - WINE_TRACE("\n"); + TRACE("\n"); - res = xrEnumerateInstanceExtensionProperties(layerName, propertyCapacityInput, propertyCountOutput, properties); - if (res != XR_SUCCESS) - return res; - - - if (!properties) - { - extra_extensions_count = 0; - for (i = 0; i < ARRAY_SIZE(substitute_extensions); ++i) - if (!substitute_extensions[i].remove_original || substitute_extensions[i].force_enable) - ++extra_extensions_count; - - *propertyCountOutput += extra_extensions_count; - WINE_TRACE("%u extensions.\n", *propertyCountOutput); - return XR_SUCCESS; - } - - count = *propertyCountOutput; - for (i = 0; i < count; ++i) - { - for (j = 0; j < ARRAY_SIZE(substitute_extensions); ++j) - { - if (!strcmp(properties[i].extensionName, substitute_extensions[j].linux_ext)) - { - if (substitute_extensions[j].force_enable) - { - WINE_FIXME("Force enabled extension %s already supported by the runtime.\n", - substitute_extensions[j].linux_ext); - substitute_extensions[j].force_enable = FALSE; - } - - if (substitute_extensions[j].remove_original) - dst = i; - else - dst = (*propertyCountOutput)++; - strcpy(properties[dst].extensionName, substitute_extensions[j].win32_ext); - } - } - } - - - for (j = 0; j < ARRAY_SIZE(substitute_extensions); ++j) - if (substitute_extensions[j].force_enable) - { - strcpy(properties[*propertyCountOutput].extensionName, substitute_extensions[j].win32_ext); - ++*propertyCountOutput; - } - - WINE_TRACE("Enumerated extensions:\n"); - for(i = 0; i < *propertyCountOutput; ++i) - WINE_TRACE(" -%s\n", properties[i].extensionName); - - return XR_SUCCESS; -} - -XrResult WINAPI wine_xrConvertTimeToWin32PerformanceCounterKHR(XrInstance instance, - XrTime time, LARGE_INTEGER *performanceCounter) -{ - WINE_FIXME("unimplemented\n"); - /* FIXME */ - return XR_ERROR_INITIALIZATION_FAILED; -} - -XrResult WINAPI wine_xrConvertWin32PerformanceCounterToTimeKHR(XrInstance instance, - const LARGE_INTEGER *performanceCounter, XrTime *time) -{ - WINE_FIXME("unimplemented\n"); - /* FIXME */ - return XR_ERROR_INITIALIZATION_FAILED; -} - -XrResult WINAPI wine_xrGetD3D11GraphicsRequirementsKHR(XrInstance instance, - XrSystemId systemId, XrGraphicsRequirementsD3D11KHR *graphicsRequirements) -{ - IDXGIFactory1 *factory; - IDXGIAdapter *adapter; - DXGI_ADAPTER_DESC adapter_desc; - HRESULT hr; - DWORD i; - - WINE_TRACE("\n"); - - hr = CreateDXGIFactory1(&IID_IDXGIFactory1, (void**)&factory); - if(FAILED(hr)){ - WINE_WARN("CreateDXGIFactory1 failed: %08x\n", hr); - return XR_ERROR_INITIALIZATION_FAILED; - } - - i = 0; - while((hr = IDXGIFactory1_EnumAdapters(factory, i++, &adapter)) == S_OK){ - hr = IDXGIAdapter_GetDesc(adapter, &adapter_desc); - if(FAILED(hr)){ - WINE_WARN("GetDesc failed: %08x\n", hr); - IDXGIAdapter_Release(adapter); - continue; - } - - IDXGIAdapter_Release(adapter); - - /* FIXME: what if we have two of the same adapters? */ - if(adapter_desc.VendorId == g_physdev_vid && - adapter_desc.DeviceId == g_physdev_pid){ - WINE_TRACE("Found DXGI adapter for %#04x:%#04x\n", g_physdev_vid, g_physdev_pid); - break; - } - } - - if(hr == S_OK){ - graphicsRequirements->adapterLuid = adapter_desc.AdapterLuid; - }else{ - WINE_WARN("Couldn't find matching DXGI adapter for given VkPhysicalDevice! Choosing first one...\n"); - - hr = IDXGIFactory1_EnumAdapters(factory, 0, &adapter); - if(FAILED(hr)){ - WINE_WARN("EnumAdapters(0) failed: %08x\n", hr); - IDXGIFactory1_Release(factory); - return XR_ERROR_INITIALIZATION_FAILED; - } - - hr = IDXGIAdapter_GetDesc(adapter, &adapter_desc); - if(FAILED(hr)){ - WINE_WARN("GetDesc(0) failed: %08x\n", hr); - IDXGIAdapter_Release(adapter); - IDXGIFactory1_Release(factory); - return XR_ERROR_INITIALIZATION_FAILED; - } - - IDXGIAdapter_Release(adapter); - - graphicsRequirements->adapterLuid = adapter_desc.AdapterLuid; - } - - IDXGIFactory1_Release(factory); - - /* XXX */ - graphicsRequirements->minFeatureLevel = D3D_FEATURE_LEVEL_10_0; - - return XR_SUCCESS; -} - -XrResult WINAPI wine_xrGetD3D12GraphicsRequirementsKHR(XrInstance instance, - XrSystemId systemId, XrGraphicsRequirementsD3D12KHR *graphicsRequirements) -{ - XrGraphicsRequirementsD3D11KHR requirements; - XrResult result = wine_xrGetD3D11GraphicsRequirementsKHR(instance, systemId, &requirements); - if (result != XR_SUCCESS) - return result; - graphicsRequirements->adapterLuid = requirements.adapterLuid; - graphicsRequirements->minFeatureLevel = D3D_FEATURE_LEVEL_11_0; - return XR_SUCCESS; -} - -XrResult WINAPI wine_xrGetInstanceProcAddr(XrInstance instance, const char *fn_name, PFN_xrVoidFunction *out_fn) -{ - WINE_TRACE("%s\n", fn_name); - - *out_fn = wine_xr_proc_addr(fn_name); - if(!*out_fn){ - WINE_WARN("Unable to find requested function: %s\n", fn_name); - return XR_ERROR_FUNCTION_UNSUPPORTED; - } - - return XR_SUCCESS; -} - -XrResult WINAPI wine_xrCreateInstance(const XrInstanceCreateInfo *createInfo, XrInstance *instance) -{ - XrResult res; - struct wine_XrInstance *wine_instance; - uint32_t i, j, count = 0; - XrInstanceCreateInfo our_createInfo; - const char *ext_name; - char **new_list; - - WINE_TRACE("%p, %p\n", createInfo, instance); - - WINE_TRACE("Incoming extensions:\n"); - for(i = 0; i < createInfo->enabledExtensionCount; ++i){ - WINE_TRACE(" -%s\n", createInfo->enabledExtensionNames[i]); - } - - new_list = heap_alloc(createInfo->enabledExtensionCount * sizeof(*new_list)); - - count = 0; - /* remove win32 extensions */ - for(i = 0; i < createInfo->enabledExtensionCount; ++i) - { - ext_name = createInfo->enabledExtensionNames[i]; - for (j = 0; j < ARRAY_SIZE(substitute_extensions); ++j) - { - if (!strcmp(ext_name, substitute_extensions[j].win32_ext)) - { - if (substitute_extensions[j].force_enable) - ext_name = NULL; - else - ext_name = substitute_extensions[j].linux_ext; - break; - } - } - if (ext_name) - new_list[count++] = wineopenxr_strdup(ext_name); - } - - our_createInfo = *createInfo; - our_createInfo.enabledExtensionNames = (const char * const*)new_list; - our_createInfo.enabledExtensionCount = count; - createInfo = &our_createInfo; - - WINE_TRACE("Enabled extensions:\n"); - for(i = 0; i < createInfo->enabledExtensionCount; ++i){ - WINE_TRACE(" -%s\n", createInfo->enabledExtensionNames[i]); - } - - wine_instance = heap_alloc_zero(sizeof(wine_XrInstance)); - - res = xrCreateInstance(createInfo, &wine_instance->instance); - if(res != XR_SUCCESS){ - WINE_WARN("xrCreateInstance failed: %d\n", res); - heap_free(wine_instance); - goto cleanup; - } - - WINE_TRACE("allocated wine instance %p for native instance %p\n", - wine_instance, wine_instance->instance); - -#define USE_XR_FUNC(x) \ - xrGetInstanceProcAddr(wine_instance->instance, #x, (PFN_xrVoidFunction *)&wine_instance->funcs.p_##x); - ALL_XR_INSTANCE_FUNCS() -#undef USE_XR_FUNC - - *instance = (XrInstance)wine_instance; - last_instance = wine_instance; - -cleanup: - for(i = 0; i < our_createInfo.enabledExtensionCount; ++i) - heap_free((void*)our_createInfo.enabledExtensionNames[i]); - - heap_free((void*)our_createInfo.enabledExtensionNames); + res = xrEnumerateInstanceExtensionProperties(layerName, propertyCapacityInput, propertyCountOutput, properties); + if (res != XR_SUCCESS) { return res; -} + } -XrResult WINAPI wine_xrCreateApiLayerInstance(const XrInstanceCreateInfo *info, const XrApiLayerCreateInfo *layerInfo, XrInstance *instance) -{ - WINE_TRACE("%p, %p, %p\n", info, layerInfo, instance); - - return wine_xrCreateInstance(info, instance); -} - -XrResult WINAPI wine_xrDestroyInstance(XrInstance instance) -{ - wine_XrInstance *wine_instance = (wine_XrInstance *)instance; - XrResult res; - - WINE_TRACE("\n"); - - res = xrDestroyInstance(wine_instance->instance); - if(res != XR_SUCCESS){ - WINE_WARN("xrDestroyInstance failed: %d\n", res); - return res; + if (!properties) { + extra_extensions_count = 0; + for (i = 0; i < ARRAY_SIZE(substitute_extensions); ++i) { + if (!substitute_extensions[i].remove_original || substitute_extensions[i].force_enable) { + ++extra_extensions_count; + } } - if(wine_instance->dxvk_device) - wine_instance->dxvk_device->lpVtbl->Release(wine_instance->dxvk_device); - - if (wine_instance->d3d12_device) - { - wine_instance->p_vkDestroyCommandPool(wine_instance->vk_device, wine_instance->vk_command_pool, NULL); - wine_instance->d3d12_device->lpVtbl->Release(wine_instance->d3d12_device); - wine_instance->d3d12_queue->lpVtbl->Release(wine_instance->d3d12_queue); - } - - heap_free(wine_instance); - + *propertyCountOutput += extra_extensions_count; + TRACE("%u extensions.\n", *propertyCountOutput); return XR_SUCCESS; -} + } -/* SteamVR does some internal init during these functions. */ -static XrResult do_vulkan_init(wine_XrInstance *wine_instance, VkInstance vk_instance) -{ - char *instance_extensions, *device_extensions; - XrGraphicsRequirementsVulkanKHR vk_reqs; - XrResult res; - uint32_t len; - - vk_reqs.type = XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR; - vk_reqs.next = NULL; - res = wine_instance->funcs.p_xrGetVulkanGraphicsRequirementsKHR(wine_instance->instance, - wine_instance->systemId, &vk_reqs); - if(res != XR_SUCCESS) - { - WINE_WARN("xrGetVulkanGraphicsRequirementsKHR failed: %d\n", res); - return res; - } - - res = wine_instance->funcs.p_xrGetVulkanInstanceExtensionsKHR(wine_instance->instance, - wine_instance->systemId, 0, &len, NULL); - if(res != XR_SUCCESS) - { - WINE_WARN("xrGetVulkanInstanceExtensionsKHR failed: %d\n", res); - return res; - } - instance_extensions = heap_alloc(len); - res = wine_instance->funcs.p_xrGetVulkanInstanceExtensionsKHR(wine_instance->instance, wine_instance->systemId, - len, &len, instance_extensions); - if(res != XR_SUCCESS) - { - WINE_WARN("xrGetVulkanInstanceExtensionsKHR failed: %d\n", res); - heap_free(instance_extensions); - return res; - } - - res = wine_instance->funcs.p_xrGetVulkanGraphicsDeviceKHR(wine_instance->instance, wine_instance->systemId, - vk_instance, &wine_instance->vk_phys_dev); - if(res != XR_SUCCESS) - { - WINE_WARN("xrGetVulkanGraphicsDeviceKHR failed: %d\n", res); - return res; - } - - res = wine_instance->funcs.p_xrGetVulkanDeviceExtensionsKHR(wine_instance->instance, wine_instance->systemId, 0, &len, NULL); - if(res != XR_SUCCESS) - { - WINE_WARN("pxrGetVulkanDeviceExtensionsKHR fail: %d\n", res); - return res; - } - device_extensions = heap_alloc(len); - res = wine_instance->funcs.p_xrGetVulkanDeviceExtensionsKHR(wine_instance->instance, wine_instance->systemId, len, &len, device_extensions); - if(res != XR_SUCCESS) - { - WINE_WARN("pxrGetVulkanDeviceExtensionsKHR fail: %d\n", res); - heap_free(device_extensions); - return res; - } - heap_free(device_extensions); - - return XR_SUCCESS; -} - -XrResult WINAPI wine_xrCreateSession(XrInstance instance, const XrSessionCreateInfo *createInfo, XrSession *session) -{ - wine_XrInstance *wine_instance = (wine_XrInstance *)instance; - wine_XrSession *wine_session; - XrResult res; - XrSessionCreateInfo our_create_info; - XrGraphicsBindingVulkanKHR our_vk_binding; - uint32_t session_type = 0; - - WINE_TRACE("%p, %p, %p\n", instance, createInfo, session); - - if(createInfo->next){ - switch(((XrBaseInStructure *)createInfo->next)->type){ - case XR_TYPE_GRAPHICS_BINDING_VULKAN2_KHR /* == XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR */: - { - const XrGraphicsBindingVulkanKHR *their_vk_binding = (const XrGraphicsBindingVulkanKHR *)createInfo->next; - - our_vk_binding = *their_vk_binding; - our_vk_binding.instance = get_native_VkInstance(their_vk_binding->instance); - our_vk_binding.physicalDevice = get_native_VkPhysicalDevice(their_vk_binding->physicalDevice); - our_vk_binding.device = get_native_VkDevice(their_vk_binding->device); - - our_create_info = *createInfo; - our_create_info.next = &our_vk_binding; - createInfo = &our_create_info; - session_type = SESSION_TYPE_VULKAN; - - break; - } - case XR_TYPE_GRAPHICS_BINDING_D3D11_KHR: - { - const XrGraphicsBindingD3D11KHR *their_d3d11_binding = (const XrGraphicsBindingD3D11KHR *)createInfo->next; - HRESULT hr; - - hr = ID3D11Device_QueryInterface(their_d3d11_binding->device, &IID_IDXGIVkInteropDevice2, (void **)&wine_instance->dxvk_device); - if(FAILED(hr)){ - WINE_WARN("Given ID3D11Device doesn't support IDXGIVkInteropDevice. Only DXVK is supported.\n"); - return XR_ERROR_VALIDATION_FAILURE; - } - - our_vk_binding.type = XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR; - our_vk_binding.next = NULL; - - wine_instance->dxvk_device->lpVtbl->GetVulkanHandles(wine_instance->dxvk_device, - &our_vk_binding.instance, &our_vk_binding.physicalDevice, &our_vk_binding.device); - - wine_instance->dxvk_device->lpVtbl->GetSubmissionQueue2(wine_instance->dxvk_device, - NULL, &our_vk_binding.queueIndex, &our_vk_binding.queueFamilyIndex); - - our_vk_binding.instance = get_native_VkInstance(our_vk_binding.instance); - - if ((res = do_vulkan_init(wine_instance, our_vk_binding.instance)) != XR_SUCCESS) - return res; - - if (wine_instance->vk_phys_dev != get_native_VkPhysicalDevice(our_vk_binding.physicalDevice)) - WINE_WARN("VK physical device does not match that from xrGetVulkanGraphicsDeviceKHR.\n"); - - our_vk_binding.physicalDevice = wine_instance->vk_phys_dev; - our_vk_binding.device = get_native_VkDevice(our_vk_binding.device); - - our_create_info = *createInfo; - our_create_info.next = &our_vk_binding; - createInfo = &our_create_info; - session_type = SESSION_TYPE_D3D11; - - break; - } - case XR_TYPE_GRAPHICS_BINDING_D3D12_KHR: - { - const XrGraphicsBindingD3D12KHR *their_d3d12_binding = createInfo->next; - VkCommandPoolCreateInfo command_pool_create_info = { - .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, - .flags = 0, - .pNext = NULL, - }; - HRESULT hr; - UINT32 queue_index; - VkQueueFlags queue_flags; - ID3D12DeviceExt1 *device_ext; - hr = ID3D12Device_QueryInterface(their_d3d12_binding->device, &IID_ID3D12DXVKInteropDevice, (void**)&wine_instance->d3d12_device); - if (FAILED(hr)) - { - WINE_WARN("Given ID3D12Device doesn't support ID3D12DXVKInteropDevice. Only vkd3d-proton is supported.\n"); - return XR_ERROR_VALIDATION_FAILURE; - } - hr = ID3D12Device_QueryInterface(their_d3d12_binding->device, &IID_ID3D12DeviceExt1, (void **)&device_ext); - if (FAILED(hr)) - { - WINE_WARN("Given ID3D12Device doesn't support ID3D12DeviceExt1. Only vkd3d-proton is supported.\n"); - return XR_ERROR_VALIDATION_FAILURE; - } - - our_vk_binding.type = XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR; - our_vk_binding.next = NULL; - - wine_instance->d3d12_queue = their_d3d12_binding->queue; - their_d3d12_binding->queue->lpVtbl->AddRef(their_d3d12_binding->queue); - - wine_instance->d3d12_device->lpVtbl->GetVulkanHandles(wine_instance->d3d12_device, - &our_vk_binding.instance, &our_vk_binding.physicalDevice, &our_vk_binding.device); - device_ext->lpVtbl->GetVulkanQueueInfoEx(device_ext, their_d3d12_binding->queue, - &wine_instance->vk_queue, &queue_index, &queue_flags, &our_vk_binding.queueFamilyIndex); - device_ext->lpVtbl->Release(device_ext); - - wine_instance->vk_device = our_vk_binding.device = get_native_VkDevice(our_vk_binding.device); - wine_instance->vk_queue = get_native_VkQueue(wine_instance->vk_queue); - our_vk_binding.queueIndex = queue_index; - - our_vk_binding.instance = get_native_VkInstance(our_vk_binding.instance); - - if ((res = do_vulkan_init(wine_instance, our_vk_binding.instance)) != XR_SUCCESS) - return res; - - if (wine_instance->vk_phys_dev != get_native_VkPhysicalDevice(our_vk_binding.physicalDevice)) - WINE_WARN("VK physical device does not match that from xrGetVulkanGraphicsDeviceKHR.\n"); - - our_vk_binding.physicalDevice = wine_instance->vk_phys_dev; - - our_create_info = *createInfo; - our_create_info.next = &our_vk_binding; - createInfo = &our_create_info; - -#define X(proc) wine_instance->p_##proc = (void *)vkGetDeviceProcAddr(our_vk_binding.device, #proc); - VK_PROCS -#undef X - command_pool_create_info.queueFamilyIndex = our_vk_binding.queueFamilyIndex; - if (wine_instance->p_vkCreateCommandPool(wine_instance->vk_device, &command_pool_create_info, NULL, &wine_instance->vk_command_pool) != VK_SUCCESS) - { - WINE_WARN("vkCreateCommandPool failed\n"); - return XR_ERROR_RUNTIME_FAILURE; - } - - session_type = SESSION_TYPE_D3D12; - - break; - } - default: - WINE_WARN("Unhandled graphics binding type: %d\n", ((XrBaseInStructure *)createInfo->next)->type); - break; + count = *propertyCountOutput; + for (i = 0; i < count; ++i) { + for (j = 0; j < ARRAY_SIZE(substitute_extensions); ++j) { + if (!strcmp(properties[i].extensionName, substitute_extensions[j].linux_ext)) { + if (substitute_extensions[j].force_enable) { + FIXME("Force enabled extension %s already supported by the runtime.\n", substitute_extensions[j].linux_ext); + substitute_extensions[j].force_enable = FALSE; } + + if (substitute_extensions[j].remove_original) { + dst = i; + } else { + dst = (*propertyCountOutput)++; + } + strcpy(properties[dst].extensionName, substitute_extensions[j].win32_ext); + } } + } - wine_session = heap_alloc_zero(sizeof(*wine_session)); - - res = xrCreateSession(wine_instance->instance, createInfo, &wine_session->session); - if(res != XR_SUCCESS){ - WINE_WARN("xrCreateSession failed: %d\n", res); - heap_free(wine_session); - return res; + for (j = 0; j < ARRAY_SIZE(substitute_extensions); ++j) { + if (substitute_extensions[j].force_enable) { + strcpy(properties[*propertyCountOutput].extensionName, substitute_extensions[j].win32_ext); + ++*propertyCountOutput; } + } - wine_session->wine_instance = wine_instance; - wine_session->session_type = session_type; + TRACE("Enumerated extensions:\n"); + for (i = 0; i < *propertyCountOutput; ++i) { + TRACE(" -%s\n", properties[i].extensionName); + } - EnterCriticalSection(&session_list_lock); - - list_add_tail(&session_list, &wine_session->entry); - - LeaveCriticalSection(&session_list_lock); - - *session = (XrSession)wine_session; - - WINE_TRACE("allocated wine session %p for native session %p\n", - wine_session, wine_session->session); - - return XR_SUCCESS; -} - -XrResult WINAPI wine_xrDestroySession(XrSession session) -{ - wine_XrSession *wine_session = (wine_XrSession *)session; - XrResult res; - - WINE_TRACE("%p\n", session); - - res = xrDestroySession(wine_session->session); - if(res != XR_SUCCESS){ - WINE_WARN("xrDestroySession failed: %d\n", res); - return res; - } - - heap_free(wine_session->projection_views); - heap_free(wine_session->view_infos); - heap_free(wine_session->composition_layers); - heap_free(wine_session); - - return XR_SUCCESS; -} - -XrResult WINAPI wine_xrNegotiateLoaderRuntimeInterface(const XrNegotiateLoaderInfo *info, XrNegotiateRuntimeRequest *request) -{ - const XrNegotiateLoaderInfo_win *loaderInfo = (const XrNegotiateLoaderInfo_win *)info; - XrNegotiateRuntimeRequest_win *runtimeRequest = (XrNegotiateRuntimeRequest_win *)request; - XrResult res; - - WINE_TRACE("%p %p\n", loaderInfo, runtimeRequest); - - if(!loaderInfo || !runtimeRequest) - return XR_ERROR_INITIALIZATION_FAILED; - - if((res = load_host_openxr_loader()) != XR_SUCCESS){ - WINE_TRACE("host openxr loader failed to load runtime: %d\n", res); - return res; - } - - if(loaderInfo->structType != XR_LOADER_INTERFACE_STRUCT_LOADER_INFO || - loaderInfo->structVersion != XR_LOADER_INFO_STRUCT_VERSION || - loaderInfo->structSize != sizeof(XrNegotiateLoaderInfo_win)){ - return XR_ERROR_VALIDATION_FAILURE; - } - - if(loaderInfo->minInterfaceVersion > XR_CURRENT_LOADER_RUNTIME_VERSION || - loaderInfo->maxInterfaceVersion < XR_CURRENT_LOADER_RUNTIME_VERSION){ - return XR_ERROR_VALIDATION_FAILURE; - } - - if(runtimeRequest->structType != XR_LOADER_INTERFACE_STRUCT_RUNTIME_REQUEST || - runtimeRequest->structVersion != XR_RUNTIME_INFO_STRUCT_VERSION || - runtimeRequest->structSize != sizeof(XrNegotiateRuntimeRequest_win)){ - return XR_ERROR_VALIDATION_FAILURE; - } - - runtimeRequest->runtimeInterfaceVersion = XR_CURRENT_LOADER_RUNTIME_VERSION; - runtimeRequest->getInstanceProcAddr = (PFN_xrGetInstanceProcAddr)&wine_xrGetInstanceProcAddr; - runtimeRequest->runtimeApiVersion = api_version; - - return XR_SUCCESS; + return XR_SUCCESS; } XrResult WINAPI wine_xrGetVulkanGraphicsDeviceKHR(XrInstance instance, - XrSystemId systemId, VkInstance vkInstance, VkPhysicalDevice *vkPhysicalDevice) -{ - XrResult res; - WINE_TRACE("%p, 0x%s, %p, %p\n", instance, wine_dbgstr_longlong(systemId), vkInstance, vkPhysicalDevice); - res = ((wine_XrInstance *)instance)->funcs.p_xrGetVulkanGraphicsDeviceKHR(((wine_XrInstance *)instance)->instance, systemId, get_native_VkInstance(vkInstance), vkPhysicalDevice); - *vkPhysicalDevice = get_wrapped_VkPhysicalDevice(vkInstance, *vkPhysicalDevice); - return res; + XrSystemId systemId, + VkInstance vkInstance, + VkPhysicalDevice *vkPhysicalDevice) { + XrResult res; + TRACE("%p, 0x%s, %p, %p\n", instance, wine_dbgstr_longlong(systemId), vkInstance, vkPhysicalDevice); + res = g_xr_host_instance_dispatch_table.p_xrGetVulkanGraphicsDeviceKHR( + wine_instance_from_handle(instance)->host_instance, systemId, get_native_VkInstance(vkInstance), + vkPhysicalDevice); + *vkPhysicalDevice = get_wrapped_VkPhysicalDevice(vkInstance, *vkPhysicalDevice); + return res; } -XrResult WINAPI wine_xrGetVulkanGraphicsDevice2KHR(XrInstance instance, const XrVulkanGraphicsDeviceGetInfoKHR *getInfo, VkPhysicalDevice *vulkanPhysicalDevice) -{ - XrVulkanGraphicsDeviceGetInfoKHR our_getinfo; - XrResult res; +XrResult WINAPI wine_xrGetVulkanGraphicsDevice2KHR(XrInstance instance, + const XrVulkanGraphicsDeviceGetInfoKHR *getInfo, + VkPhysicalDevice *vulkanPhysicalDevice) { + XrVulkanGraphicsDeviceGetInfoKHR our_getinfo; + XrResult res; - WINE_TRACE("instance %p, getInfo %p, vulkanPhysicalDevice %p.\n", instance, getInfo, vulkanPhysicalDevice); + TRACE("instance %p, getInfo %p, vulkanPhysicalDevice %p.\n", instance, getInfo, vulkanPhysicalDevice); - if (getInfo->next) - WINE_WARN("Unsupported chained structure %p.\n", getInfo->next); + if (getInfo->next) { + WARN("Unsupported chained structure %p.\n", getInfo->next); + } - our_getinfo = *getInfo; - our_getinfo.vulkanInstance = get_native_VkInstance(our_getinfo.vulkanInstance); + our_getinfo = *getInfo; + our_getinfo.vulkanInstance = get_native_VkInstance(our_getinfo.vulkanInstance); - res = ((wine_XrInstance *)instance)->funcs.p_xrGetVulkanGraphicsDevice2KHR(((wine_XrInstance *)instance)->instance, &our_getinfo, vulkanPhysicalDevice); - if (res == XR_SUCCESS) - *vulkanPhysicalDevice = get_wrapped_VkPhysicalDevice(getInfo->vulkanInstance, *vulkanPhysicalDevice); - return res; + res = g_xr_host_instance_dispatch_table.p_xrGetVulkanGraphicsDevice2KHR( + wine_instance_from_handle(instance)->host_instance, &our_getinfo, vulkanPhysicalDevice); + if (res == XR_SUCCESS) { + *vulkanPhysicalDevice = get_wrapped_VkPhysicalDevice(getInfo->vulkanInstance, *vulkanPhysicalDevice); + } + return res; } -XrResult WINAPI wine_xrGetVulkanDeviceExtensionsKHR(XrInstance instance, XrSystemId systemId, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer) -{ - XrResult res; - uint32_t buf_len = 0; - char *buf; +XrResult WINAPI wine_xrGetVulkanDeviceExtensionsKHR(XrInstance instance, + XrSystemId systemId, + uint32_t bufferCapacityInput, + uint32_t *bufferCountOutput, + char *buffer) { + wine_XrInstance *wine_instance = wine_instance_from_handle(instance); + XrResult res; + uint32_t buf_len = 0; + char *buf; - WINE_TRACE("%p, 0x%s, %u, %p, %p\n", instance, wine_dbgstr_longlong(systemId), bufferCapacityInput, bufferCountOutput, buffer); + TRACE("%p, 0x%s, %u, %p, %p\n", instance, wine_dbgstr_longlong(systemId), bufferCapacityInput, bufferCountOutput, + buffer); - if(bufferCapacityInput == 0){ - *bufferCountOutput = sizeof(WINE_VULKAN_DEVICE_EXTENSION_NAME); - return XR_SUCCESS; - } + if (!getenv(WINE_VULKAN_DEVICE_EXTENSION_NAME)) { + return g_xr_host_instance_dispatch_table.p_xrGetVulkanDeviceExtensionsKHR( + wine_instance->host_instance, systemId, bufferCapacityInput, bufferCountOutput, buffer); + } - if(bufferCapacityInput < sizeof(WINE_VULKAN_DEVICE_EXTENSION_NAME)){ - *bufferCountOutput = sizeof(WINE_VULKAN_DEVICE_EXTENSION_NAME); - return XR_ERROR_SIZE_INSUFFICIENT; - } - - res = ((wine_XrInstance *)instance)->funcs.p_xrGetVulkanDeviceExtensionsKHR( - ((wine_XrInstance *)instance)->instance, systemId, - 0, &buf_len, NULL); - if(res != XR_SUCCESS){ - WINE_WARN("xrGetVulkanDeviceExtensionsKHR failed: %d\n", res); - return res; - } - - buf = heap_alloc(buf_len); - - res = ((wine_XrInstance *)instance)->funcs.p_xrGetVulkanDeviceExtensionsKHR( - ((wine_XrInstance *)instance)->instance, systemId, - buf_len, &buf_len, buf); - if(res != XR_SUCCESS){ - WINE_WARN("xrGetVulkanDeviceExtensionsKHR failed: %d\n", res); - heap_free(buf); - return res; - } - - WINE_TRACE("got device extensions: %s\n", buf); - setenv(WINE_VULKAN_DEVICE_VARIABLE, buf, 1); - - heap_free(buf); - - memcpy(buffer, WINE_VULKAN_DEVICE_EXTENSION_NAME, sizeof(WINE_VULKAN_DEVICE_EXTENSION_NAME)); + if (bufferCapacityInput == 0) { *bufferCountOutput = sizeof(WINE_VULKAN_DEVICE_EXTENSION_NAME); - return XR_SUCCESS; + } + + if (bufferCapacityInput < sizeof(WINE_VULKAN_DEVICE_EXTENSION_NAME)) { + *bufferCountOutput = sizeof(WINE_VULKAN_DEVICE_EXTENSION_NAME); + return XR_ERROR_SIZE_INSUFFICIENT; + } + + res = g_xr_host_instance_dispatch_table.p_xrGetVulkanDeviceExtensionsKHR(wine_instance->host_instance, systemId, 0, + &buf_len, NULL); + if (res != XR_SUCCESS) { + WARN("xrGetVulkanDeviceExtensionsKHR failed: %d\n", res); + return res; + } + + buf = malloc(buf_len); + + res = g_xr_host_instance_dispatch_table.p_xrGetVulkanDeviceExtensionsKHR(wine_instance->host_instance, systemId, + buf_len, &buf_len, buf); + if (res != XR_SUCCESS) { + WARN("xrGetVulkanDeviceExtensionsKHR failed: %d\n", res); + free(buf); + return res; + } + + TRACE("got device extensions: %s\n", buf); + setenv(WINE_VULKAN_DEVICE_VARIABLE, buf, 1); + + free(buf); + + memcpy(buffer, WINE_VULKAN_DEVICE_EXTENSION_NAME, sizeof(WINE_VULKAN_DEVICE_EXTENSION_NAME)); + *bufferCountOutput = sizeof(WINE_VULKAN_DEVICE_EXTENSION_NAME); + + return XR_SUCCESS; } XrResult WINAPI wine_xrGetVulkanInstanceExtensionsKHR(XrInstance instance, - XrSystemId systemId, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, - char *buffer) -{ - static const char win32_surface[] = "VK_KHR_surface VK_KHR_win32_surface"; + XrSystemId systemId, + uint32_t bufferCapacityInput, + uint32_t *bufferCountOutput, + char *buffer) { + static const char win32_surface[] = "VK_KHR_surface VK_KHR_win32_surface"; - XrResult res; - uint32_t lin_len; + XrResult res; + uint32_t lin_len; - WINE_TRACE("%p, 0x%s, %u, %p, %p\n", instance, wine_dbgstr_longlong(systemId), bufferCapacityInput, bufferCountOutput, buffer); + TRACE("%p, 0x%s, %u, %p, %p\n", instance, wine_dbgstr_longlong(systemId), bufferCapacityInput, bufferCountOutput, + buffer); - /* Linux SteamVR does not return xlib_surface, but Windows SteamVR _does_ - * return win32_surface. Some games (including hello_xr) depend on that, so - * add it here. */ + /* Linux SteamVR does not return xlib_surface, but Windows SteamVR _does_ + * return win32_surface. Some games (including hello_xr) depend on that, so + * add it here. */ - res = ((wine_XrInstance *)instance)->funcs.p_xrGetVulkanInstanceExtensionsKHR( - ((wine_XrInstance *)instance)->instance, systemId, - bufferCapacityInput, bufferCountOutput, buffer); - if(res == XR_SUCCESS){ + res = g_xr_host_instance_dispatch_table.p_xrGetVulkanInstanceExtensionsKHR( + wine_instance_from_handle(instance)->host_instance, systemId, bufferCapacityInput, bufferCountOutput, buffer); + if (res == XR_SUCCESS) { + if (bufferCapacityInput > 0) { + /* *bufferCountOutput is not required to (and sometimes does not) contain the offset to the NUL byte */ + lin_len = strlen(buffer) + 1; - if(bufferCapacityInput > 0){ - /* *bufferCountOutput is not required to (and sometimes does not) contain the offset to the NUL byte */ - lin_len = strlen(buffer) + 1; + if (bufferCapacityInput < lin_len + sizeof(win32_surface)) { + return XR_ERROR_SIZE_INSUFFICIENT; + } - if(bufferCapacityInput < lin_len + sizeof(win32_surface)) - return XR_ERROR_SIZE_INSUFFICIENT; + buffer[lin_len - 1] = ' '; + memcpy(&buffer[lin_len], win32_surface, sizeof(win32_surface)); - buffer[lin_len - 1] = ' '; - memcpy(&buffer[lin_len], win32_surface, sizeof(win32_surface)); - - WINE_TRACE("returning: %s\n", buffer); - *bufferCountOutput = lin_len + sizeof(win32_surface); - }else{ - *bufferCountOutput += sizeof(win32_surface) /* NUL byte included for required ' ' */; - } + TRACE("returning: %s\n", buffer); + *bufferCountOutput = lin_len + sizeof(win32_surface); + } else { + *bufferCountOutput += sizeof(win32_surface) /* NUL byte included for required ' ' */; } + } - return res; + return res; } -struct vk_create_instance_callback_context -{ - wine_XrInstance *wine_instance; - const XrVulkanInstanceCreateInfoKHR *xr_create_info; - XrResult ret; -}; +static VkResult WINAPI vk_create_instance_callback(const VkInstanceCreateInfo *create_info, + const VkAllocationCallbacks *allocator, + VkInstance *vk_instance, + void *(*pfnGetInstanceProcAddr)(VkInstance, const char *), + void *context) { + struct vk_create_callback_context *c = context; + XrVulkanInstanceCreateInfoKHR our_create_info; + VkInstanceCreateInfo our_vulkan_create_info; + const char **enabled_extensions = NULL; + unsigned int i; + VkResult ret; -static VkResult vk_create_instance_callback(const VkInstanceCreateInfo *create_info, const VkAllocationCallbacks *allocator, - VkInstance *vk_instance, void * (*pfnGetInstanceProcAddr)(VkInstance, const char *), void *context) -{ - /* Only Unix calls here, called from the Unix side. */ - struct vk_create_instance_callback_context *c = context; - XrVulkanInstanceCreateInfoKHR our_create_info; - VkInstanceCreateInfo our_vulkan_create_info; - const char **enabled_extensions = NULL; - unsigned int i; - VkResult ret; + our_create_info = *(const XrVulkanInstanceCreateInfoKHR *)c->create_info; + our_create_info.pfnGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)pfnGetInstanceProcAddr; + our_create_info.vulkanCreateInfo = create_info; + our_create_info.vulkanAllocator = allocator; - our_create_info = *c->xr_create_info; - our_create_info.pfnGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)pfnGetInstanceProcAddr; - our_create_info.vulkanCreateInfo = create_info; - our_create_info.vulkanAllocator = allocator; - - for (i = 0; i < create_info->enabledExtensionCount; ++i) - if (!strcmp(create_info->ppEnabledExtensionNames[i], "VK_KHR_surface")) - break; - - if (i == create_info->enabledExtensionCount) - { - our_vulkan_create_info = *create_info; - our_create_info.vulkanCreateInfo = &our_vulkan_create_info; - - enabled_extensions = malloc((create_info->enabledExtensionCount + 2) * sizeof(*enabled_extensions)); - memcpy(enabled_extensions, create_info->ppEnabledExtensionNames, - create_info->enabledExtensionCount * sizeof(*enabled_extensions)); - enabled_extensions[our_vulkan_create_info.enabledExtensionCount++] = "VK_KHR_surface"; - enabled_extensions[our_vulkan_create_info.enabledExtensionCount++] = "VK_KHR_xlib_surface"; - our_vulkan_create_info.ppEnabledExtensionNames = enabled_extensions; + for (i = 0; i < create_info->enabledExtensionCount; ++i) { + if (!strcmp(create_info->ppEnabledExtensionNames[i], "VK_KHR_surface")) { + break; } + } - c->ret = c->wine_instance->funcs.p_xrCreateVulkanInstanceKHR(c->wine_instance->instance, &our_create_info, vk_instance, &ret); - free(enabled_extensions); - return ret; + if (i == create_info->enabledExtensionCount) { + our_vulkan_create_info = *create_info; + our_create_info.vulkanCreateInfo = &our_vulkan_create_info; + + enabled_extensions = malloc((create_info->enabledExtensionCount + 2) * sizeof(*enabled_extensions)); + memcpy(enabled_extensions, create_info->ppEnabledExtensionNames, + create_info->enabledExtensionCount * sizeof(*enabled_extensions)); + enabled_extensions[our_vulkan_create_info.enabledExtensionCount++] = "VK_KHR_surface"; + enabled_extensions[our_vulkan_create_info.enabledExtensionCount++] = "VK_KHR_xlib_surface"; + our_vulkan_create_info.ppEnabledExtensionNames = enabled_extensions; + } + + c->ret = g_xr_host_instance_dispatch_table.p_xrCreateVulkanInstanceKHR( + wine_instance_from_handle(c->wine_instance)->host_instance, &our_create_info, vk_instance, &ret); + free(enabled_extensions); + return ret; } -XrResult WINAPI wine_xrCreateVulkanInstanceKHR(XrInstance instance, const XrVulkanInstanceCreateInfoKHR *createInfo, - VkInstance *vulkanInstance, VkResult *vulkanResult) -{ - struct vk_create_instance_callback_context context; - VkCreateInfoWineInstanceCallback callback; - VkInstanceCreateInfo vulkan_create_info; +static VkResult WINAPI vk_create_device_callback(VkPhysicalDevice phys_dev, + const VkDeviceCreateInfo *create_info, + const VkAllocationCallbacks *allocator, + VkDevice *vk_device, + void *(*pfnGetInstanceProcAddr)(VkInstance, const char *), + void *context) { + /* Only Unix calls here, called from the Unix side. */ + struct vk_create_callback_context *c = context; + XrVulkanDeviceCreateInfoKHR our_create_info; + VkResult ret; - WINE_TRACE("instance %p, createInfo %p, vulkanInstance %p, vulkanResult %p.\n", - instance, createInfo, vulkanInstance, vulkanResult); - - if (createInfo->createFlags) - WINE_WARN("Unexpected flags %#lx.\n", createInfo->createFlags); - - context.wine_instance = (wine_XrInstance *)instance; - context.xr_create_info = createInfo; - - vulkan_create_info = *createInfo->vulkanCreateInfo; - callback.sType = VK_STRUCTURE_TYPE_CREATE_INFO_WINE_INSTANCE_CALLBACK; - callback.native_create_callback = vk_create_instance_callback; - callback.context = &context; - callback.pNext = vulkan_create_info.pNext; - vulkan_create_info.pNext = &callback; - - *vulkanResult = p_wine_vkCreateInstance(&vulkan_create_info, createInfo->vulkanAllocator, vulkanInstance); - - if (context.ret == XR_SUCCESS && *vulkanResult != VK_SUCCESS) - WINE_WARN("winevulkan instance creation failed after native xrCreateVulkanInstanceKHR() success.\n"); - - WINE_TRACE("result %d, vk result %d.\n", context.ret, *vulkanResult); - return context.ret; + our_create_info = *(const XrVulkanDeviceCreateInfoKHR *)c->create_info; + our_create_info.pfnGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)pfnGetInstanceProcAddr; + our_create_info.vulkanPhysicalDevice = phys_dev; + our_create_info.vulkanCreateInfo = create_info; + our_create_info.vulkanAllocator = allocator; + c->ret = g_xr_host_instance_dispatch_table.p_xrCreateVulkanDeviceKHR( + wine_instance_from_handle(c->wine_instance)->host_instance, &our_create_info, vk_device, &ret); + return ret; } -struct vk_create_device_callback_context -{ - wine_XrInstance *wine_instance; - const XrVulkanDeviceCreateInfoKHR *xr_create_info; - XrResult ret; -}; +NTSTATUS init_openxr(void *args) { + struct init_openxr_params *params = args; + NTSTATUS status; + unixlib_handle_t unix_funcs; + Dl_info info; + void *unix_handle; -static VkResult vk_create_device_callback(VkPhysicalDevice phys_dev, const VkDeviceCreateInfo *create_info, const VkAllocationCallbacks *allocator, - VkDevice *vk_device, void * (*pfnGetInstanceProcAddr)(VkInstance, const char *), void *context) -{ - /* Only Unix calls here, called from the Unix side. */ - struct vk_create_device_callback_context *c = context; - XrVulkanDeviceCreateInfoKHR our_create_info; - VkResult ret; + status = NtQueryVirtualMemory(GetCurrentProcess(), params->winevulkan, + (MEMORY_INFORMATION_CLASS)1000 /*MemoryWineUnixFuncs*/, &unix_funcs, sizeof(unix_funcs), + NULL); + if (status) { + ERR("NtQueryVirtualMemory status %#x.\n", (int)status); + return status; + } - our_create_info = *c->xr_create_info; - our_create_info.pfnGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)pfnGetInstanceProcAddr; - our_create_info.vulkanPhysicalDevice = phys_dev; - our_create_info.vulkanCreateInfo = create_info; - our_create_info.vulkanAllocator = allocator; - c->ret = c->wine_instance->funcs.p_xrCreateVulkanDeviceKHR(c->wine_instance->instance, &our_create_info, vk_device, &ret); - return ret; -} - -XrResult WINAPI wine_xrCreateVulkanDeviceKHR(XrInstance instance, const XrVulkanDeviceCreateInfoKHR *createInfo, VkDevice *vulkanDevice, VkResult *vulkanResult) -{ - struct vk_create_device_callback_context context; - VkCreateInfoWineDeviceCallback callback; - VkDeviceCreateInfo vulkan_create_info; - - WINE_TRACE("instance %p, createInfo %p, vulkanDevice %p, vulkanResult %p.\n", - instance, createInfo, vulkanDevice, vulkanResult); - - if (createInfo->createFlags) - WINE_WARN("Unexpected flags %#lx.\n", createInfo->createFlags); - - context.wine_instance = (wine_XrInstance *)instance; - context.xr_create_info = createInfo; - - vulkan_create_info = *createInfo->vulkanCreateInfo; - callback.sType = VK_STRUCTURE_TYPE_CREATE_INFO_WINE_DEVICE_CALLBACK; - callback.native_create_callback = vk_create_device_callback; - callback.context = &context; - callback.pNext = vulkan_create_info.pNext; - vulkan_create_info.pNext = &callback; - - *vulkanResult = p_wine_vkCreateDevice(createInfo->vulkanPhysicalDevice, &vulkan_create_info, - createInfo->vulkanAllocator, vulkanDevice); - - if (context.ret == XR_SUCCESS && *vulkanResult != VK_SUCCESS) - WINE_WARN("winevulkan instance creation failed after native xrCreateVulkanInstanceKHR() success.\n"); - - WINE_TRACE("result %d, vk result %d.\n", context.ret, *vulkanResult); - return context.ret; -} - -XrResult WINAPI wine_xrPollEvent(XrInstance instance, XrEventDataBuffer *eventData) -{ - XrResult res; - - WINE_TRACE("%p, %p\n", instance, eventData); - - res = xrPollEvent(((wine_XrInstance *)instance)->instance, eventData); - - WINE_TRACE("eventData->type %#x\n", eventData->type); - - if(res == XR_SUCCESS){ - switch(eventData->type){ - case XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED: - { - XrEventDataInteractionProfileChanged *evt = (XrEventDataInteractionProfileChanged *)eventData; - evt->session = (XrSession)get_wrapped_XrSession(evt->session); - break; - } - case XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED: - { - XrEventDataSessionStateChanged *evt = (XrEventDataSessionStateChanged *)eventData; - evt->session = (XrSession)get_wrapped_XrSession(evt->session); - break; - } - case XR_TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR: - { - XrEventDataVisibilityMaskChangedKHR *evt = (XrEventDataVisibilityMaskChangedKHR *)eventData; - evt->session = (XrSession)get_wrapped_XrSession(evt->session); - break; - } - case XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING: - { - XrEventDataReferenceSpaceChangePending *evt = (XrEventDataReferenceSpaceChangePending *)eventData; - evt->session = (XrSession)get_wrapped_XrSession(evt->session); - break; - } - case XR_TYPE_EVENT_DATA_USER_PRESENCE_CHANGED_EXT: - { - XrEventDataUserPresenceChangedEXT *evt = (XrEventDataUserPresenceChangedEXT *)eventData; - evt->session = (XrSession)get_wrapped_XrSession(evt->session); - break; - } - case XR_TYPE_EVENT_DATA_LOCALIZATION_CHANGED_ML: - { - XrEventDataLocalizationChangedML *evt = (XrEventDataLocalizationChangedML *)eventData; - evt->session = (XrSession)get_wrapped_XrSession(evt->session); - break; - } - default: - break; - } - } - - return res; -} - -XrResult WINAPI wine_xrGetSystem(XrInstance instance, const XrSystemGetInfo *getInfo, XrSystemId *systemId) -{ - wine_XrInstance *wine_instance = (wine_XrInstance *)instance; - XrResult res; - - WINE_TRACE("%p, %p, %p\n", instance, getInfo, systemId); - - res = wine_instance->funcs.p_xrGetSystem(wine_instance->instance, getInfo, systemId); - if(res != XR_SUCCESS) - return res; - - wine_instance->systemId = *systemId; - return res; -} - -static BOOL is_vulkan_format_depth(VkFormat format) -{ - switch(format){ - case VK_FORMAT_B8G8R8A8_SRGB: - case VK_FORMAT_B8G8R8A8_UNORM: - case VK_FORMAT_R8G8B8A8_SRGB: - case VK_FORMAT_R8G8B8A8_UNORM: - case VK_FORMAT_R32G32B32A32_SFLOAT: - case VK_FORMAT_R32G32B32_SFLOAT: - case VK_FORMAT_R16G16B16A16_SFLOAT: - return FALSE; - case VK_FORMAT_D32_SFLOAT: - case VK_FORMAT_D16_UNORM: - case VK_FORMAT_D24_UNORM_S8_UINT: - case VK_FORMAT_D32_SFLOAT_S8_UINT: - return TRUE; - - default: - WINE_WARN("Unknown vulkan format %#x", format); - return FALSE; - } -} - -int64_t map_format_dxgi_to_vulkan(int64_t format) -{ - switch(format){ - case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB: - return VK_FORMAT_B8G8R8A8_SRGB; - - case DXGI_FORMAT_B8G8R8A8_UNORM: - return VK_FORMAT_B8G8R8A8_UNORM; - - case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: - return VK_FORMAT_R8G8B8A8_SRGB; - - case DXGI_FORMAT_R8G8B8A8_UNORM: - return VK_FORMAT_R8G8B8A8_UNORM; - - case DXGI_FORMAT_R32G32B32A32_FLOAT: - return VK_FORMAT_R32G32B32A32_SFLOAT; - - case DXGI_FORMAT_R32G32B32_FLOAT: - return VK_FORMAT_R32G32B32_SFLOAT; - - case DXGI_FORMAT_R16G16B16A16_FLOAT: - return VK_FORMAT_R16G16B16A16_SFLOAT; - - case DXGI_FORMAT_D32_FLOAT: - return VK_FORMAT_D32_SFLOAT; - - case DXGI_FORMAT_D16_UNORM: - return VK_FORMAT_D16_UNORM; - - case DXGI_FORMAT_D24_UNORM_S8_UINT: - return VK_FORMAT_D24_UNORM_S8_UINT; - - case DXGI_FORMAT_D32_FLOAT_S8X24_UINT: - return VK_FORMAT_D32_SFLOAT_S8_UINT; - - default: - WINE_WARN("Unable to map DXGI format (%lu) to Vulkan format\n", format); - return VK_FORMAT_UNDEFINED; - } -} - -int64_t map_format_vulkan_to_dxgi(int64_t format) -{ - switch(format){ - case VK_FORMAT_B8G8R8A8_SRGB: - return DXGI_FORMAT_B8G8R8A8_UNORM_SRGB; - - case VK_FORMAT_B8G8R8A8_UNORM: - return DXGI_FORMAT_B8G8R8A8_UNORM; - - case VK_FORMAT_R8G8B8A8_SRGB: - return DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; - - case VK_FORMAT_R8G8B8A8_UNORM: - return DXGI_FORMAT_R8G8B8A8_UNORM; - - case VK_FORMAT_R32G32B32A32_SFLOAT: - return DXGI_FORMAT_R32G32B32A32_FLOAT; - - case VK_FORMAT_R32G32B32_SFLOAT: - return DXGI_FORMAT_R32G32B32_FLOAT; - - case VK_FORMAT_R16G16B16A16_SFLOAT: - return DXGI_FORMAT_R16G16B16A16_FLOAT; - - case VK_FORMAT_D32_SFLOAT: - return DXGI_FORMAT_D32_FLOAT; - - case VK_FORMAT_D16_UNORM: - return DXGI_FORMAT_D16_UNORM; - - case VK_FORMAT_D24_UNORM_S8_UINT: - return DXGI_FORMAT_D24_UNORM_S8_UINT; - - case VK_FORMAT_D32_SFLOAT_S8_UINT: - return DXGI_FORMAT_D32_FLOAT_S8X24_UINT; - - default: - WINE_WARN("Unable to map Vulkan format (%lu) to DXGI format\n", format); - return DXGI_FORMAT_UNKNOWN; - } -} - -XrResult WINAPI wine_xrEnumerateSwapchainFormats(XrSession session, uint32_t formatCapacityInput, uint32_t *formatCountOutput, int64_t *formats) -{ - wine_XrSession *wine_session = (wine_XrSession *)session; - uint32_t real_format_count; - int64_t *real_formats; - uint32_t i, o; - XrResult res; - - WINE_TRACE("%p, %u, %p, %p\n", session, formatCapacityInput, formatCountOutput, formats); - - if (wine_session->session_type != SESSION_TYPE_D3D11 && wine_session->session_type != SESSION_TYPE_D3D12) - return xrEnumerateSwapchainFormats(wine_session->session, formatCapacityInput, formatCountOutput, formats); - - res = xrEnumerateSwapchainFormats(wine_session->session, 0, &real_format_count, NULL); - if (res != XR_SUCCESS) return res; - - real_formats = heap_alloc(sizeof(*real_formats) * real_format_count); - res = xrEnumerateSwapchainFormats(wine_session->session, real_format_count, formatCountOutput, real_formats); - - if (res != XR_SUCCESS) - goto done; - - o = 0; - for(i = 0; i < real_format_count; ++i) - { - int64_t mapped = map_format_vulkan_to_dxgi(real_formats[i]); - - if (mapped == DXGI_FORMAT_UNKNOWN) - continue; - - if (formatCapacityInput && formats) - { - if (o < formatCapacityInput) - formats[o] = mapped; - else - res = XR_ERROR_SIZE_INSUFFICIENT; - } - ++o; - } - *formatCountOutput = o; - -done: - heap_free(real_formats); - return res; -} - -XrResult WINAPI wine_xrCreateSwapchain(XrSession session, const XrSwapchainCreateInfo *createInfo, XrSwapchain *swapchain) -{ - wine_XrSession *wine_session = (wine_XrSession *)session; - wine_XrSwapchain *wine_swapchain; - XrSwapchainCreateInfo our_createInfo; - XrResult res; - - WINE_TRACE("%p, %p, %p\n", session, createInfo, swapchain); - - wine_swapchain = heap_alloc_zero(sizeof(*wine_swapchain)); - wine_swapchain->create_info = *createInfo; - - if(wine_session->session_type == SESSION_TYPE_D3D11 || wine_session->session_type == SESSION_TYPE_D3D12){ - BOOL format_is_depth; - our_createInfo = *createInfo; - our_createInfo.format = map_format_dxgi_to_vulkan(createInfo->format); - if(our_createInfo.format == VK_FORMAT_UNDEFINED){ - WINE_ERR("unable to set Vulkan format\n"); - heap_free(wine_swapchain); - return XR_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED; - } - createInfo = &our_createInfo; - - format_is_depth = is_vulkan_format_depth(our_createInfo.format); - if ((createInfo->usageFlags & XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT) && format_is_depth){ - WINE_WARN("Swapchain has a color attachment usage, but it's format is for depth\n"); - } - if ((createInfo->usageFlags & XR_SWAPCHAIN_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) && !format_is_depth){ - WINE_WARN("Swapchain has a depth/stencil usage, but it's format is for color\n"); - } - } - - res = xrCreateSwapchain(((wine_XrSession *)session)->session, createInfo, &wine_swapchain->swapchain); - if(res != XR_SUCCESS){ - WINE_WARN("xrCreateSwapchain failed: %d\n", res); - heap_free(wine_swapchain); - return res; - } - - wine_swapchain->wine_session = wine_session; - *swapchain = (XrSwapchain)wine_swapchain; - - WINE_TRACE("allocated wine swapchain %p for native swapchain %p\n", - wine_swapchain, wine_swapchain->swapchain); - - return XR_SUCCESS; -} - -static void release_d3d12_resources(wine_XrSwapchain *wine_swapchain, uint32_t image_count) -{ - wine_XrInstance *wine_instance = wine_swapchain->wine_session->wine_instance; - XrSwapchainImageD3D12KHR *d3d12_images = (XrSwapchainImageD3D12KHR *)wine_swapchain->images; - UINT i; - if (!image_count) - return; - - for (i = 0; i < image_count; i++) - if (d3d12_images[i].texture) - d3d12_images[i].texture->lpVtbl->Release(d3d12_images[i].texture); - wine_instance->p_vkFreeCommandBuffers(wine_instance->vk_device, wine_instance->vk_command_pool, image_count, wine_swapchain->cmd_release); - wine_instance->p_vkFreeCommandBuffers(wine_instance->vk_device, wine_instance->vk_command_pool, image_count, wine_swapchain->cmd_acquire); - heap_free(wine_swapchain->cmd_release); - heap_free(wine_swapchain->cmd_acquire); - heap_free(wine_swapchain->acquired); - heap_free(wine_swapchain->acquired_indices); -} - -XrResult WINAPI wine_xrDestroySwapchain(XrSwapchain swapchain) -{ - wine_XrSwapchain *wine_swapchain = (wine_XrSwapchain *)swapchain; - XrResult res; - - WINE_TRACE("%p\n", swapchain); - - if (wine_swapchain->image_count){ - UINT i; - if (wine_swapchain->wine_session->session_type == SESSION_TYPE_D3D11){ - XrSwapchainImageD3D11KHR *d3d11_images = (XrSwapchainImageD3D11KHR *)wine_swapchain->images; - for (i = 0; i < wine_swapchain->image_count; i++) - d3d11_images[i].texture->lpVtbl->Release(d3d11_images[i].texture); - } else if (wine_swapchain->wine_session->session_type == SESSION_TYPE_D3D12) - release_d3d12_resources(wine_swapchain, wine_swapchain->image_count); - heap_free(wine_swapchain->images); - wine_swapchain->image_count = 0; - } - - res = xrDestroySwapchain(wine_swapchain->swapchain); - if(res != XR_SUCCESS){ - WINE_WARN("xrDestroySwapchain failed: %d\n", res); - return res; - } - heap_free(wine_swapchain); - - return XR_SUCCESS; -} - -static D3D11_USAGE d3d11usage_from_XrSwapchainUsageFlags(XrSwapchainUsageFlags flags) -{ - static const D3D11_USAGE supported_flags = XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT | XR_SWAPCHAIN_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT - | XR_SWAPCHAIN_USAGE_UNORDERED_ACCESS_BIT | XR_SWAPCHAIN_USAGE_SAMPLED_BIT; - D3D11_USAGE ret = 0; - - if (flags & ~supported_flags) - WINE_FIXME("Unhandled flags %#lx.\n", flags); - - if (flags & XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT) - ret |= D3D11_BIND_RENDER_TARGET; - if (flags & XR_SWAPCHAIN_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) - ret |= D3D11_BIND_DEPTH_STENCIL; - if (flags & XR_SWAPCHAIN_USAGE_UNORDERED_ACCESS_BIT) - ret |= D3D11_BIND_UNORDERED_ACCESS; - if (flags & XR_SWAPCHAIN_USAGE_SAMPLED_BIT) - ret |= D3D11_BIND_SHADER_RESOURCE; - - return ret; -} - -static VkResult record_transition_command(wine_XrInstance *instance, VkImage image, VkImageSubresourceRange subresource, - VkImageLayout from, VkImageLayout to, VkCommandBuffer *out_cmd) -{ - VkResult ret; - VkCommandBufferAllocateInfo command_buffer_allocate_info = { - .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, - .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY, - .commandPool = instance->vk_command_pool, - .commandBufferCount = 1, - }; - VkCommandBufferBeginInfo begin_info = { - .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, - .flags = 0, - }; - VkImageMemoryBarrier barrier = { - .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, - .oldLayout = from, - .newLayout = to, - .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, - .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, - .image = image, - .subresourceRange = subresource, - .srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT, - .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT, - }; - - *out_cmd = VK_NULL_HANDLE; - if (from == to){ - return VK_SUCCESS; - } - - if ((ret = instance->p_vkAllocateCommandBuffers(instance->vk_device, &command_buffer_allocate_info, out_cmd)) != VK_SUCCESS) - return ret; - if ((ret = instance->p_vkBeginCommandBuffer(*out_cmd, &begin_info)) != VK_SUCCESS) - return ret; - instance->p_vkCmdPipelineBarrier(*out_cmd, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, - 0, 0, NULL, 0, NULL, 1, &barrier); - return instance->p_vkEndCommandBuffer(*out_cmd); -} - -XrResult WINAPI wine_xrEnumerateSwapchainImages(XrSwapchain swapchain, uint32_t imageCapacityInput, uint32_t *imageCountOutput, XrSwapchainImageBaseHeader *images) -{ - wine_XrSwapchain *wine_swapchain = (wine_XrSwapchain *)swapchain; - wine_XrInstance *wine_instance = wine_swapchain->wine_session->wine_instance; - XrResult res; - XrSwapchainImageVulkanKHR *our_vk = NULL; - HRESULT hr; - size_t image_size = 0; - uint32_t i; - - WINE_TRACE("%p, %u, %p, %p\n", swapchain, imageCapacityInput, imageCountOutput, images); - if (wine_swapchain->wine_session->session_type != SESSION_TYPE_D3D11 && wine_swapchain->wine_session->session_type != SESSION_TYPE_D3D12) - return xrEnumerateSwapchainImages(wine_swapchain->swapchain, imageCapacityInput, imageCountOutput, images); - - if (!wine_swapchain->image_count) { - uint32_t image_count; - res = xrEnumerateSwapchainImages(wine_swapchain->swapchain, 0, &image_count, NULL); - if (res != XR_SUCCESS) - return res; - - our_vk = heap_alloc(sizeof(*our_vk) * image_count); - for(i = 0; i < image_count; ++i){ - our_vk[i].type = XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR; - } - - res = xrEnumerateSwapchainImages(wine_swapchain->swapchain, image_count, &image_count, (XrSwapchainImageBaseHeader *)our_vk); - if (res != XR_SUCCESS){ - heap_free(our_vk); - return res; - } - - if(wine_swapchain->wine_session->session_type == SESSION_TYPE_D3D11){ - XrSwapchainImageD3D11KHR *our_d3d11; - D3D11_TEXTURE2D_DESC1 desc; - - desc.Width = wine_swapchain->create_info.width; - desc.Height = wine_swapchain->create_info.height; - desc.MipLevels = wine_swapchain->create_info.mipCount; - desc.ArraySize = wine_swapchain->create_info.arraySize; - desc.Format = wine_swapchain->create_info.format; - WINE_TRACE("creating dxvk texture with dxgi format %d (%x)\n", - desc.Format, desc.Format); - desc.SampleDesc.Count = wine_swapchain->create_info.sampleCount; - desc.SampleDesc.Quality = 0; - desc.Usage = D3D11_USAGE_DEFAULT; - desc.BindFlags = d3d11usage_from_XrSwapchainUsageFlags(wine_swapchain->create_info.usageFlags); - desc.CPUAccessFlags = 0; - desc.MiscFlags = 0; - desc.TextureLayout = D3D11_TEXTURE_LAYOUT_UNDEFINED; - - our_d3d11 = heap_alloc(sizeof(XrSwapchainImageD3D11KHR) * image_count); - for(i = 0; i < image_count; ++i){ - hr = wine_instance->dxvk_device->lpVtbl->CreateTexture2DFromVkImage(wine_instance->dxvk_device, - &desc, our_vk[i].image, &our_d3d11[i].texture); - if(FAILED(hr)){ - UINT j; - for (j = 0; j < i; ++j){ - our_d3d11[i].texture->lpVtbl->Release(our_d3d11[i].texture); - } - heap_free(our_d3d11); - heap_free(our_vk); - WINE_WARN("Failed to create DXVK texture from VkImage: %08x\n", hr); - return XR_ERROR_RUNTIME_FAILURE; - } - WINE_TRACE("Successfully allocated texture %p\n", our_d3d11[i].texture); - } - wine_swapchain->images = (XrSwapchainImageBaseHeader *)our_d3d11; - } else if(wine_swapchain->wine_session->session_type == SESSION_TYPE_D3D12){ - XrSwapchainImageD3D12KHR *our_d3d12; - D3D12_RESOURCE_DESC1 desc; - ID3D12DeviceExt1 *device_ext; - HRESULT hr = wine_instance->d3d12_device->lpVtbl->QueryInterface(wine_instance->d3d12_device, &IID_ID3D12DeviceExt1, (void **)&device_ext); - BOOL format_is_depth = is_vulkan_format_depth(map_format_dxgi_to_vulkan(wine_swapchain->create_info.format)); - BOOL succeeded = TRUE; - const D3D12_RESOURCE_STATES incoming_state = format_is_depth ? D3D12_RESOURCE_STATE_DEPTH_WRITE : D3D12_RESOURCE_STATE_RENDER_TARGET; - const VkImageLayout vk_layout = format_is_depth ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - const VkImageSubresourceRange subresource = - { - .layerCount = wine_swapchain->create_info.arraySize, - .baseArrayLayer = 0, - .levelCount = wine_swapchain->create_info.mipCount, - .baseMipLevel = 0, - .aspectMask = format_is_depth ? (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) : VK_IMAGE_ASPECT_COLOR_BIT, - }; - if (FAILED(hr)) - { - WINE_ERR("Cannot get vkd3d-proton interface: %08x\n", hr); - return XR_ERROR_VALIDATION_FAILURE; - } - - desc.Alignment = 0; - desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; - desc.Width = wine_swapchain->create_info.width; - desc.Height = wine_swapchain->create_info.height; - desc.MipLevels = wine_swapchain->create_info.mipCount; - desc.DepthOrArraySize = wine_swapchain->create_info.arraySize; - desc.Format = wine_swapchain->create_info.format; - WINE_TRACE("creating vkd3d-proton texture with dxgi format %d (%x)\n", - desc.Format, desc.Format); - desc.SampleDesc.Count = wine_swapchain->create_info.sampleCount; - desc.SampleDesc.Quality = 0; - desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; - desc.Flags = 0; - if (!format_is_depth) - desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET; - else - { - desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL; - if (!(wine_swapchain->create_info.usageFlags & XR_SWAPCHAIN_USAGE_SAMPLED_BIT)) - desc.Flags |= D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE; - } - if (wine_swapchain->create_info.usageFlags & XR_SWAPCHAIN_USAGE_UNORDERED_ACCESS_BIT) - desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS; - - our_d3d12 = heap_alloc_zero(sizeof(XrSwapchainImageD3D12KHR) * image_count); - for(i = 0; i < image_count; ++i) - { - hr = device_ext->lpVtbl->CreateResourceFromBorrowedHandle(device_ext, - &desc, our_vk[i].image, &our_d3d12[i].texture); - if(FAILED(hr)) - { - WINE_ERR("Failed to create vkd3d-proton texture from VkImage: %08x\n", hr); - succeeded = FALSE; - break; - } - WINE_TRACE("Successfully allocated texture %p\n", our_d3d12[i].texture); - } - device_ext->lpVtbl->Release(device_ext); - - if (succeeded) - { - wine_swapchain->acquired = heap_alloc_zero(sizeof(BOOL) * image_count); - wine_swapchain->acquired_indices = heap_alloc(sizeof(uint32_t) * (image_count + 1)); - wine_swapchain->acquired_count = wine_swapchain->acquired_start = 0; - wine_swapchain->images = (XrSwapchainImageBaseHeader *)our_d3d12; - - wine_swapchain->cmd_release = heap_alloc_zero(sizeof(VkCommandBuffer) * image_count); - wine_swapchain->cmd_acquire = heap_alloc_zero(sizeof(VkCommandBuffer) * image_count); - for (i = 0; i < image_count; i++) - { - VkImageLayout d3d12_vk_layout; - wine_instance->d3d12_device->lpVtbl->GetVulkanImageLayout(wine_instance->d3d12_device, our_d3d12[i].texture, incoming_state, &d3d12_vk_layout); - if (record_transition_command(wine_instance, our_vk[i].image, subresource, d3d12_vk_layout, vk_layout, &wine_swapchain->cmd_release[i]) != VK_SUCCESS || - record_transition_command(wine_instance, our_vk[i].image, subresource, vk_layout, d3d12_vk_layout, &wine_swapchain->cmd_acquire[i]) != VK_SUCCESS) - { - WINE_ERR("Failed to create command buffer for layout transition\n"); - succeeded = FALSE; - break; - } - } - } - if (!succeeded) - { - release_d3d12_resources(wine_swapchain, image_count); - heap_free(wine_swapchain->images); - wine_swapchain->images = NULL; - heap_free(our_vk); - return XR_ERROR_RUNTIME_FAILURE; - } - } - heap_free(our_vk); - wine_swapchain->image_count = image_count; - WINE_TRACE("image count %d\n", image_count); - } - - *imageCountOutput = wine_swapchain->image_count; - if (wine_swapchain->wine_session->session_type == SESSION_TYPE_D3D11){ - image_size = sizeof(XrSwapchainImageD3D11KHR); - } else if (wine_swapchain->wine_session->session_type == SESSION_TYPE_D3D12){ - image_size = sizeof(XrSwapchainImageD3D12KHR); - } - memcpy(images, wine_swapchain->images, image_size * min(wine_swapchain->image_count, imageCapacityInput)); - return XR_SUCCESS; -} - -static XrCompositionLayerBaseHeader *convert_XrCompositionLayer(wine_XrSession *wine_session, - const XrCompositionLayerBaseHeader *in_layer, CompositionLayer *out_layer, - uint32_t *view_idx, uint32_t *view_info_idx) -{ - uint32_t i; - - WINE_TRACE("Type %u, pNext %p.\n", in_layer->type, in_layer->next); - - switch(in_layer->type){ - case XR_TYPE_COMPOSITION_LAYER_CUBE_KHR: { - out_layer->cube = *(const XrCompositionLayerCubeKHR *)in_layer; - out_layer->cube.swapchain = ((wine_XrSwapchain *)out_layer->cube.swapchain)->swapchain; - break; - } - - case XR_TYPE_COMPOSITION_LAYER_CYLINDER_KHR: - out_layer->cylinder = *(const XrCompositionLayerCylinderKHR *)in_layer; - out_layer->cylinder.subImage.swapchain = ((wine_XrSwapchain *)out_layer->cylinder.subImage.swapchain)->swapchain; - break; - - case XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR: - out_layer->depth_info = *(const XrCompositionLayerDepthInfoKHR *)in_layer; - out_layer->depth_info.subImage.swapchain = ((wine_XrSwapchain *)out_layer->depth_info.subImage.swapchain)->swapchain; - break; - - case XR_TYPE_COMPOSITION_LAYER_EQUIRECT_KHR: - out_layer->equirect = *(const XrCompositionLayerEquirectKHR *)in_layer; - out_layer->equirect.subImage.swapchain = ((wine_XrSwapchain *)out_layer->equirect.subImage.swapchain)->swapchain; - break; - - case XR_TYPE_COMPOSITION_LAYER_EQUIRECT2_KHR: - out_layer->equirect2 = *(const XrCompositionLayerEquirect2KHR *)in_layer; - out_layer->equirect2.subImage.swapchain = ((wine_XrSwapchain *)out_layer->equirect2.subImage.swapchain)->swapchain; - break; - - case XR_TYPE_COMPOSITION_LAYER_PROJECTION: - { - const XrCompositionLayerProjectionView *view; - unsigned int view_info_count; - - out_layer->projection = *(const XrCompositionLayerProjection *)in_layer; - - view_info_count = 0; - for (i = 0; i < out_layer->projection.viewCount; ++i) - { - view = &((XrCompositionLayerProjection *)in_layer)->views[i]; - while ((view = view->next)) - ++view_info_count; - } - - if(out_layer->projection.viewCount + *view_idx > wine_session->projection_view_count){ - wine_session->projection_view_count = out_layer->projection.viewCount + *view_idx; - wine_session->projection_views = heap_realloc(wine_session->projection_views, - sizeof(XrCompositionLayerProjectionView) * wine_session->projection_view_count); - } - - if(view_info_count + *view_info_idx > wine_session->view_info_count){ - wine_session->view_info_count += view_info_count; - wine_session->view_infos = heap_realloc(wine_session->view_infos, - sizeof(*wine_session->view_infos) * wine_session->view_info_count); - } - - out_layer->projection.views = &wine_session->projection_views[*view_idx]; - memcpy((void*)out_layer->projection.views, ((const XrCompositionLayerProjection *)in_layer)->views, - sizeof(XrCompositionLayerProjectionView) * out_layer->projection.viewCount); - view_info_count = 0; - for(i = 0; i < out_layer->projection.viewCount; ++i){ - view = &out_layer->projection.views[i]; - if (view->type != XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW) - WINE_WARN("Unexpected view type %u.\n", view->type); - - ((XrCompositionLayerProjectionView *)view)->subImage.swapchain = ((wine_XrSwapchain *)view->subImage.swapchain)->swapchain; - while (view->next) - { - WINE_TRACE("Projection view type %u.\n", ((XrCompositionLayerProjectionView *)view->next)->type); - switch (((XrCompositionLayerProjectionView *)view->next)->type) - { - case XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR: - { - XrCompositionLayerDepthInfoKHR *out_depth_info, *in_depth_info; - - in_depth_info = (XrCompositionLayerDepthInfoKHR *)view->next; - out_depth_info = &wine_session->view_infos[*view_info_idx + view_info_count].depth_info; - *out_depth_info = *in_depth_info; - out_depth_info->subImage.swapchain = ((wine_XrSwapchain *)out_depth_info->subImage.swapchain)->swapchain; - ((XrCompositionLayerProjectionView *)view)->next = out_depth_info; - break; - } - case XR_TYPE_COMPOSITION_LAYER_SPACE_WARP_INFO_FB: - { - XrCompositionLayerSpaceWarpInfoFB *out_warp_info, *in_warp_info; - - in_warp_info = (XrCompositionLayerSpaceWarpInfoFB *)view->next; - out_warp_info = &wine_session->view_infos[*view_info_idx + view_info_count].space_warp_info; - *out_warp_info = *in_warp_info; - out_warp_info->motionVectorSubImage.swapchain = ((wine_XrSwapchain *)out_warp_info->motionVectorSubImage.swapchain)->swapchain; - out_warp_info->depthSubImage.swapchain = ((wine_XrSwapchain *)out_warp_info->depthSubImage.swapchain)->swapchain; - ((XrCompositionLayerProjectionView *)view)->next = out_warp_info; - break; - } - default: - WINE_WARN("Unknown view info type %u.\n", view->type); - break; - } - ++view_info_count; - view = view->next; - } - } - - *view_idx += out_layer->projection.viewCount; - *view_info_idx += view_info_count; - break; - } - case XR_TYPE_COMPOSITION_LAYER_QUAD: - out_layer->quad = *(const XrCompositionLayerQuad *)in_layer; - out_layer->quad.subImage.swapchain = ((wine_XrSwapchain *)out_layer->quad.subImage.swapchain)->swapchain; - break; - - default: - WINE_WARN("Unknown composition in_layer type: %d\n", in_layer->type); - return (XrCompositionLayerBaseHeader *)in_layer; - } - - return (XrCompositionLayerBaseHeader *)out_layer; -} - -XrResult WINAPI wine_xrEndFrame(XrSession session, const XrFrameEndInfo *frameEndInfo) -{ - wine_XrSession *wine_session = (wine_XrSession *)session; - uint32_t i, view_idx = 0, view_info_idx = 0; - IDXGIVkInteropDevice2 *dxvk_device; - ID3D12DXVKInteropDevice *d3d12_device; - XrFrameEndInfo our_frameEndInfo; - XrResult res; - - WINE_TRACE("%p, %p\n", session, frameEndInfo); - - if(frameEndInfo->layerCount > wine_session->composition_layer_count){ - heap_free(wine_session->composition_layers); - wine_session->composition_layers = heap_alloc(frameEndInfo->layerCount * sizeof(*wine_session->composition_layers)); - heap_free(wine_session->composition_layer_ptrs); - wine_session->composition_layer_ptrs = heap_alloc(frameEndInfo->layerCount * sizeof(*wine_session->composition_layer_ptrs)); - wine_session->composition_layer_count = frameEndInfo->layerCount; - } - - for(i = 0; i < frameEndInfo->layerCount; ++i){ - wine_session->composition_layer_ptrs[i] = - convert_XrCompositionLayer(wine_session, - frameEndInfo->layers[i], &wine_session->composition_layers[i], - &view_idx, &view_info_idx); - } - - our_frameEndInfo = *frameEndInfo; - our_frameEndInfo.layers = (const XrCompositionLayerBaseHeader *const *)wine_session->composition_layer_ptrs; - - if ((dxvk_device = wine_session->wine_instance->dxvk_device)) - { - WINE_TRACE("Locking submission queue.\n"); - dxvk_device->lpVtbl->FlushRenderingCommands(dxvk_device); - dxvk_device->lpVtbl->LockSubmissionQueue(dxvk_device); - } - else if ((d3d12_device = wine_session->wine_instance->d3d12_device)) - { - WINE_TRACE("Locking vkd3d-proton submission queue.\n"); - d3d12_device->lpVtbl->LockCommandQueue(d3d12_device, wine_session->wine_instance->d3d12_queue); - } - res = xrEndFrame(((wine_XrSession *)session)->session, &our_frameEndInfo); - if (dxvk_device) - dxvk_device->lpVtbl->ReleaseSubmissionQueue(dxvk_device); - else if (d3d12_device) - d3d12_device->lpVtbl->UnlockCommandQueue(d3d12_device, wine_session->wine_instance->d3d12_queue); - - return res; -} - -XrResult WINAPI wine_xrBeginFrame(XrSession session, const XrFrameBeginInfo *frameBeginInfo) -{ - wine_XrSession *wine_session = (wine_XrSession *)session; - IDXGIVkInteropDevice2 *dxvk_device; - ID3D12DXVKInteropDevice *d3d12_device; - XrResult ret; - - WINE_TRACE("%p, %p\n", session, frameBeginInfo); - - if ((dxvk_device = wine_session->wine_instance->dxvk_device)) - dxvk_device->lpVtbl->LockSubmissionQueue(dxvk_device); - else if ((d3d12_device = wine_session->wine_instance->d3d12_device)) - d3d12_device->lpVtbl->LockCommandQueue(d3d12_device, wine_session->wine_instance->d3d12_queue); - ret = xrBeginFrame(((wine_XrSession *)session)->session, frameBeginInfo); - if (dxvk_device) - dxvk_device->lpVtbl->ReleaseSubmissionQueue(dxvk_device); - else if (d3d12_device) - d3d12_device->lpVtbl->UnlockCommandQueue(d3d12_device, wine_session->wine_instance->d3d12_queue); - return ret; -} - -XrResult WINAPI wine_xrAcquireSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageAcquireInfo *acquireInfo, uint32_t *index) -{ - wine_XrSwapchain *wine_swapchain = (wine_XrSwapchain *)swapchain; - wine_XrSession *wine_session = wine_swapchain->wine_session; - IDXGIVkInteropDevice2 *dxvk_device; - ID3D12DXVKInteropDevice *d3d12_device; - XrResult ret; - - WINE_TRACE("%p, %p, %p image count %d, acquired %d\n", swapchain, acquireInfo, index, wine_swapchain->image_count, - wine_swapchain->acquired_count); - - if ((dxvk_device = wine_session->wine_instance->dxvk_device)) - dxvk_device->lpVtbl->LockSubmissionQueue(dxvk_device); - else if ((d3d12_device = wine_session->wine_instance->d3d12_device)) - { - if (wine_swapchain->acquired_count >= wine_swapchain->image_count) - { - WINE_WARN("Application has acquired all images but still tries to acquire more.\n"); - return XR_ERROR_CALL_ORDER_INVALID; - } - d3d12_device->lpVtbl->LockCommandQueue(d3d12_device, wine_session->wine_instance->d3d12_queue); - } - ret = xrAcquireSwapchainImage(((wine_XrSwapchain *)swapchain)->swapchain, acquireInfo, index); - if (dxvk_device) - { - dxvk_device->lpVtbl->ReleaseSubmissionQueue(dxvk_device); - return ret; - } - - if (!d3d12_device) - return ret; - - if (ret == XR_SUCCESS) - { - if (!wine_swapchain->acquired[*index] && wine_swapchain->cmd_acquire[*index] != VK_NULL_HANDLE) - { - VkSubmitInfo submit_info = - { - .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, - .commandBufferCount = 1, - .pCommandBuffers = &wine_swapchain->cmd_acquire[*index], - }; - - wine_session->wine_instance->p_vkQueueSubmit(wine_session->wine_instance->vk_queue, 1, &submit_info, VK_NULL_HANDLE); - } - if (!wine_swapchain->acquired[*index]) - { - uint32_t next = (wine_swapchain->acquired_start + wine_swapchain->acquired_count) % wine_swapchain->image_count; - wine_swapchain->acquired[*index] = TRUE; - wine_swapchain->acquired_indices[next] = *index; - wine_swapchain->acquired_count += 1; - } - else - WINE_WARN("the application acquired the same image (index %d) again!?", *index); - } - d3d12_device->lpVtbl->UnlockCommandQueue(d3d12_device, wine_session->wine_instance->d3d12_queue); - return ret; -} - -XrResult WINAPI wine_xrReleaseSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageReleaseInfo *releaseInfo) -{ - wine_XrSwapchain *wine_swapchain = (wine_XrSwapchain *)swapchain; - wine_XrSession *wine_session = wine_swapchain->wine_session; - IDXGIVkInteropDevice2 *dxvk_device; - ID3D12DXVKInteropDevice *d3d12_device = wine_session->wine_instance->d3d12_device; - XrResult ret; - uint32_t index; - - WINE_TRACE("%p, %p\n", swapchain, releaseInfo); - if ((dxvk_device = wine_session->wine_instance->dxvk_device)) - dxvk_device->lpVtbl->LockSubmissionQueue(dxvk_device); - else if (d3d12_device) - { - if (wine_swapchain->acquired_count == 0) - { - WINE_WARN("Application tried to release a swapchain image without having acquired it first.\n"); - return XR_ERROR_CALL_ORDER_INVALID; - } - - d3d12_device->lpVtbl->LockCommandQueue(d3d12_device, wine_session->wine_instance->d3d12_queue); - - index = wine_swapchain->acquired_indices[wine_swapchain->acquired_start]; - if (wine_swapchain->cmd_release[index] != VK_NULL_HANDLE) - { - VkSubmitInfo submit_info = - { - .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, - .commandBufferCount = 1, - .pCommandBuffers = &wine_swapchain->cmd_release[index], - }; - - wine_session->wine_instance->p_vkQueueSubmit(wine_session->wine_instance->vk_queue, 1, &submit_info, VK_NULL_HANDLE); - } - } - ret = xrReleaseSwapchainImage(((wine_XrSwapchain *)swapchain)->swapchain, releaseInfo); - if (dxvk_device) - { - dxvk_device->lpVtbl->ReleaseSubmissionQueue(dxvk_device); - return ret; - } - if (!d3d12_device) - return ret; - if (ret != XR_SUCCESS && wine_swapchain->cmd_release[index] != VK_NULL_HANDLE) - { - VkSubmitInfo submit_info = - { - .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, - .commandBufferCount = 1, - .pCommandBuffers = &wine_swapchain->cmd_acquire[index], - }; - WINE_WARN("xrReleaseSwapchainImage failed, reverting layout transition\n"); - wine_session->wine_instance->p_vkQueueSubmit(wine_session->wine_instance->vk_queue, 1, &submit_info, VK_NULL_HANDLE); - } - if (ret == XR_SUCCESS) - { - wine_swapchain->acquired[index] = FALSE; - wine_swapchain->acquired_start = (wine_swapchain->acquired_start + 1) % wine_swapchain->image_count; - wine_swapchain->acquired_count -= 1; - } - d3d12_device->lpVtbl->UnlockCommandQueue(d3d12_device, wine_session->wine_instance->d3d12_queue); - return ret; -} - -/* wineopenxr API */ -XrResult WINAPI __wineopenxr_GetVulkanInstanceExtensions(uint32_t buflen, uint32_t *outlen, char *buf) -{ - XrResult res; - - WINE_TRACE("\n"); - - if((res = load_host_openxr_loader()) != XR_SUCCESS){ - WINE_TRACE("host openxr loader failed to load runtime: %d\n", res); - return res; - } - - if(buflen < strlen(g_instance_extensions) + 1 || !buf){ - *outlen = strlen(g_instance_extensions) + 1; - return XR_SUCCESS; - } - - *outlen = strlen(g_instance_extensions) + 1; - strcpy(buf, g_instance_extensions); - - return XR_SUCCESS; -} - -/* wineopenxr API */ -XrResult WINAPI __wineopenxr_GetVulkanDeviceExtensions(uint32_t buflen, uint32_t *outlen, char *buf) -{ - XrResult res; - - WINE_TRACE("\n"); - - if((res = load_host_openxr_loader()) != XR_SUCCESS){ - WINE_TRACE("host openxr loader failed to load runtime: %d\n", res); - return res; - } - - if(buflen < strlen(WINE_VULKAN_DEVICE_EXTENSION_NAME) + 1 || !buf){ - *outlen = strlen(WINE_VULKAN_DEVICE_EXTENSION_NAME) + 1; - return XR_SUCCESS; - } - - WINE_TRACE("g_device_extensions %s.\n", g_device_extensions); - setenv(WINE_VULKAN_DEVICE_VARIABLE, g_device_extensions, 1); - *outlen = strlen(WINE_VULKAN_DEVICE_EXTENSION_NAME) + 1; - strcpy(buf, WINE_VULKAN_DEVICE_EXTENSION_NAME); - - return XR_SUCCESS; -} - -void register_dispatchable_handle(uint64_t handle, struct openxr_instance_funcs *funcs) -{ - struct handle_instance_lookup_entry *entry; - - entry = heap_alloc_zero(sizeof(*entry)); - entry->handle = handle; - entry->funcs = funcs; - AcquireSRWLockExclusive(&handle_instance_lookup_lock); - rb_put(&handle_instance_lookup, &handle, &entry->entry); - ReleaseSRWLockExclusive(&handle_instance_lookup_lock); -} - -void unregister_dispatchable_handle(uint64_t handle) -{ - struct rb_entry *entry; - - AcquireSRWLockExclusive(&handle_instance_lookup_lock); - if ((entry = rb_get(&handle_instance_lookup, &handle))) - rb_remove(&handle_instance_lookup, entry); - ReleaseSRWLockExclusive(&handle_instance_lookup_lock); - if (entry) - heap_free(entry); - else - WINE_ERR("handle %s not found.\n", wine_dbgstr_longlong(handle)); -} - -struct openxr_instance_funcs *get_dispatch_table(uint64_t handle) -{ - struct openxr_instance_funcs *funcs = NULL; - struct rb_entry *entry; - - AcquireSRWLockExclusive(&handle_instance_lookup_lock); - if ((entry = rb_get(&handle_instance_lookup, &handle))) - funcs = RB_ENTRY_VALUE(entry, struct handle_instance_lookup_entry, entry)->funcs; - ReleaseSRWLockExclusive(&handle_instance_lookup_lock); - - if (!funcs) - { - WINE_ERR("handle %s not found.\n", wine_dbgstr_longlong(handle)); - funcs = &last_instance->funcs; - } - return funcs; -} - -BOOL CDECL wineopenxr_init_registry(void) -{ - char *xr_inst_ext, *xr_dev_ext; - uint32_t vid, pid; - LSTATUS status; - HKEY vr_key; - - if ((status = RegOpenKeyExA( HKEY_CURRENT_USER, "Software\\Wine\\VR", 0, KEY_ALL_ACCESS, &vr_key ))) - { - WARN( "Could not open key, status %#x.\n", status ); - return FALSE; - } - - if (!get_extensions( &xr_inst_ext, &xr_dev_ext, &vid, &pid )) - { - TRACE( "Got XR extensions.\n" ); - if ((status = RegSetValueExA( vr_key, "openxr_vulkan_instance_extensions", 0, REG_SZ, - (BYTE *)xr_inst_ext, strlen( xr_inst_ext ) + 1 ))) - ERR( "Could not set openxr_vulkan_instance_extensions value, status %#x.\n", status ); - if ((status = RegSetValueExA( vr_key, "openxr_vulkan_device_extensions", 0, REG_SZ, - (BYTE *)xr_dev_ext, strlen( xr_dev_ext ) + 1 ))) - ERR( "Could not set openxr_vulkan_device_extensions value, status %#x.\n", status ); - if ((status = RegSetValueExA( vr_key, "openxr_vulkan_device_vid", 0, REG_DWORD, - (BYTE *)&vid, sizeof(vid) ))) - ERR( "Could not set openxr_vulkan_device_vid value, status %#x.\n", status ); - if ((status = RegSetValueExA( vr_key, "openxr_vulkan_device_pid", 0, REG_DWORD, - (BYTE *)&pid, sizeof(pid) ))) - ERR( "Could not set openxr_vulkan_device_pid value, status %#x.\n", status ); - } - - TRACE( "Initialized OpenXR registry entries\n" ); - RegCloseKey( vr_key ); - return TRUE; + if (!dladdr((void *)(ULONG_PTR)unix_funcs, &info)) { + ERR("dladdr failed.\n"); + return STATUS_INVALID_PARAMETER; + } + + TRACE("path %s.\n", info.dli_fname); + if (!(unix_handle = dlopen(info.dli_fname, RTLD_NOW))) { + ERR("dlopen failed.\n"); + return STATUS_INVALID_PARAMETER; + } + +#define L(name) \ + if (!(name = dlsym(unix_handle, "__wine_" #name))) \ + ERR("%s not found.\n", #name); + + L(get_native_VkDevice); + L(get_native_VkInstance); + L(get_native_VkPhysicalDevice); + L(get_wrapped_VkPhysicalDevice); + L(get_native_VkQueue); +#undef L + + dlclose(unix_handle); + + params->create_instance_callback = (UINT64)&vk_create_instance_callback; + params->create_device_callback = (UINT64)&vk_create_device_callback; + + return STATUS_SUCCESS; } diff --git a/wineopenxr/openxr_loader.c b/wineopenxr/openxr_loader.c new file mode 100644 index 00000000..387e471f --- /dev/null +++ b/wineopenxr/openxr_loader.c @@ -0,0 +1,1961 @@ +#include + +#include "initguid.h" +#include "openxr_loader.h" +#include "wine/unixlib.h" +#include "wine/vulkan_driver.h" +#include "dxvk-interop.h" +#include "vkd3d-proton-interop.h" + +WINE_DEFAULT_DEBUG_CHANNEL(openxr); + +static uint32_t g_physdev_vid, g_physdev_pid; +static char *g_instance_extensions, *g_device_extensions; +static XrVersion api_version = XR_CURRENT_API_VERSION; + +#define SESSION_TYPE_VULKAN 1 +#define SESSION_TYPE_OPENGL 2 +#define SESSION_TYPE_D3D11 3 +#define SESSION_TYPE_D3D12 4 + +UINT64 g_vk_create_instance_callback; +UINT64 g_vk_create_device_callback; + +union CompositionLayer { + XrCompositionLayerProjection projection; + XrCompositionLayerQuad quad; + XrCompositionLayerCubeKHR cube; + XrCompositionLayerDepthInfoKHR depth_info; + XrCompositionLayerCylinderKHR cylinder; + XrCompositionLayerEquirectKHR equirect; + XrCompositionLayerEquirect2KHR equirect2; +}; + +static CRITICAL_SECTION session_list_lock = {NULL, -1, 0, 0, 0, 0}; +static struct list session_list = LIST_INIT(session_list); + +static wine_XrSession *get_wrapped_XrSession(XrSession native) { + wine_XrSession *cursor; + + EnterCriticalSection(&session_list_lock); + + LIST_FOR_EACH_ENTRY(cursor, &session_list, wine_XrSession, entry) { + if (cursor->host_session == native) { + break; + } + } + + LeaveCriticalSection(&session_list_lock); + + if (&cursor->entry == &session_list) { + return NULL; + } + + return cursor; +} + +static void parse_extensions(const char *in, uint32_t *out_count, char ***out_strs) { + char *iter, *start; + char **list, *str = strdup(in); + uint32_t extension_count = 0, o = 0; + + iter = str; + while (*iter) { + if (*iter++ == ' ') { + extension_count++; + } + } + /* count the one ending in NUL */ + if (iter != str) { + extension_count++; + } + if (!extension_count) { + *out_count = 0; + *out_strs = NULL; + return; + } + + list = malloc(extension_count * sizeof(char *)); + + start = iter = str; + do { + if (*iter == ' ') { + *iter = 0; + list[o++] = strdup(start); + TRACE("added %s to list\n", list[o - 1]); + iter++; + start = iter; + } else if (*iter == 0) { + list[o++] = strdup(start); + TRACE("added %s to list\n", list[o - 1]); + break; + } else { + iter++; + } + } while (1); + + *out_count = extension_count; + *out_strs = list; +} + +static BOOL get_vulkan_extensions(void) { + /* Linux SteamVR's xrCreateInstance will hang forever if SteamVR hasn't + * already been launched by the user. Since that's the only way to tell if + * OpenXR is functioning, let's use OpenVR to tell whether SteamVR is + * functioning before calling xrCreateInstance. + * + * This should be removed when SteamVR's bug is fixed. */ + DWORD type, value, wait_status = 0, size; + LSTATUS status; + HANDLE event; + HKEY vr_key; + + if ((status = RegOpenKeyExA(HKEY_CURRENT_USER, "Software\\Wine\\VR", 0, KEY_READ, &vr_key))) { + ERR("Could not create key, status %#x.\n", status); + return FALSE; + } + + size = sizeof(value); + if ((status = RegQueryValueExA(vr_key, "state", NULL, &type, (BYTE *)&value, &size))) { + ERR("Could not query value, status %#x.\n", status); + RegCloseKey(vr_key); + return FALSE; + } + if (type != REG_DWORD) { + ERR("Unexpected value type %#x.\n", type); + RegCloseKey(vr_key); + return FALSE; + } + + if (value) { + goto done; + } + + event = CreateEventA(NULL, FALSE, FALSE, NULL); + while (1) { + if (RegNotifyChangeKeyValue(vr_key, FALSE, REG_NOTIFY_CHANGE_LAST_SET, event, TRUE)) { + ERR("Error registering registry change notification.\n"); + CloseHandle(event); + goto done; + } + size = sizeof(value); + if ((status = RegQueryValueExA(vr_key, "state", NULL, &type, (BYTE *)&value, &size))) { + ERR("Could not query value, status %#x.\n", status); + CloseHandle(event); + goto done; + } + if (value) { + break; + } + while ((wait_status = WaitForSingleObject(event, 1000)) == WAIT_TIMEOUT) { + ERR("VR state wait timeout.\n"); + } + + if (wait_status != WAIT_OBJECT_0) { + ERR("Got unexpected wait status %#x.\n", wait_status); + break; + } + } + CloseHandle(event); + +done: + if (value == 1) { + if ((status = RegQueryValueExA(vr_key, "openxr_vulkan_instance_extensions", NULL, &type, NULL, &size))) { + ERR("Error getting openxr_vulkan_instance_extensions, status %#x.\n", status); + RegCloseKey(vr_key); + return FALSE; + } + g_instance_extensions = malloc(size); + if ((status = RegQueryValueExA(vr_key, "openxr_vulkan_instance_extensions", NULL, &type, + (BYTE *)g_instance_extensions, &size))) { + ERR("Error getting openxr_vulkan_instance_extensions, status %#x.\n", status); + RegCloseKey(vr_key); + return FALSE; + } + if ((status = RegQueryValueExA(vr_key, "openxr_vulkan_device_extensions", NULL, &type, NULL, &size))) { + ERR("Error getting openxr_vulkan_device_extensions, status %#x.\n", status); + RegCloseKey(vr_key); + return FALSE; + } + g_device_extensions = malloc(size); + if ((status = RegQueryValueExA(vr_key, "openxr_vulkan_device_extensions", NULL, &type, (BYTE *)g_device_extensions, + &size))) { + ERR("Error getting openxr_vulkan_device_extensions, status %#x.\n", status); + RegCloseKey(vr_key); + return FALSE; + } + if ((status = RegQueryValueExA(vr_key, "openxr_vulkan_device_vid", NULL, &type, (BYTE *)&g_physdev_vid, &size))) { + ERR("Error getting openxr_vulkan_device_vid, status: %#x.\n", status); + RegCloseKey(vr_key); + return FALSE; + } + if ((status = RegQueryValueExA(vr_key, "openxr_vulkan_device_pid", NULL, &type, (BYTE *)&g_physdev_pid, &size))) { + ERR("Error getting openxr_vulkan_device_pid, status: %#x.\n", status); + RegCloseKey(vr_key); + return FALSE; + } + } + + RegCloseKey(vr_key); + return value == 1; +} + +static BOOL WINAPI wine_openxr_unix_init(INIT_ONCE *once, void *param, void **context) { + struct init_openxr_params params = {.winevulkan = LoadLibraryA("winevulkan.dll")}; + if (__wine_init_unix_call() || UNIX_CALL(init, ¶ms)) { + return FALSE; + } + g_vk_create_instance_callback = params.create_instance_callback; + g_vk_create_device_callback = params.create_device_callback; + return TRUE; +} + +static BOOL wine_openxr_unix_init_once(void) { + static INIT_ONCE init_once = INIT_ONCE_STATIC_INIT; + + return InitOnceExecuteOnce(&init_once, wine_openxr_unix_init, NULL, NULL); +} + +static XrResult wine_openxr_init_once(void) { + if (g_instance_extensions || g_device_extensions) { + /* already done */ + return XR_SUCCESS; + } + + if (!wine_openxr_unix_init_once()) { + return XR_ERROR_INITIALIZATION_FAILED; + } + + if (!get_vulkan_extensions()) { + return XR_ERROR_INITIALIZATION_FAILED; + } + + return XR_SUCCESS; +} + +static int get_extensions(char **ret_instance_extensions, char **ret_device_extensions, + uint32_t *ret_physdev_vid, uint32_t *ret_physdev_pid) { + PFN_xrGetVulkanInstanceExtensionsKHR pxrGetVulkanInstanceExtensionsKHR; + PFN_xrGetSystem pxrGetSystem; + PFN_xrGetVulkanDeviceExtensionsKHR pxrGetVulkanDeviceExtensionsKHR; + PFN_xrGetVulkanGraphicsDeviceKHR pxrGetVulkanGraphicsDeviceKHR; + PFN_xrGetVulkanGraphicsRequirementsKHR pxrGetVulkanGraphicsRequirementsKHR; + PFN_xrGetInstanceProperties pxrGetInstanceProperties; + PFN_xrEnumerateViewConfigurations pxrEnumerateViewConfigurations; + char *instance_extensions, *device_extensions; + uint32_t len, i; + XrInstance instance; + XrSystemId system; + XrResult res; + VkInstance vk_instance; + VkResult vk_res; + VkPhysicalDevice vk_physdev; + VkPhysicalDeviceProperties vk_dev_props; + + static const char *xr_extensions[] = { + "XR_KHR_vulkan_enable", + }; + + XrInstanceCreateInfo xrCreateInfo = { + .type = XR_TYPE_INSTANCE_CREATE_INFO, + .next = NULL, + .createFlags = 0, + .applicationInfo = + { + .applicationVersion = 0, + .engineVersion = 0, + .apiVersion = api_version, + }, + .enabledApiLayerCount = 0, + .enabledApiLayerNames = NULL, + .enabledExtensionCount = ARRAY_SIZE(xr_extensions), + .enabledExtensionNames = xr_extensions, + }; + XrInstanceProperties inst_props = { + .type = XR_TYPE_INSTANCE_PROPERTIES, + }; + XrSystemGetInfo system_info = { + .type = XR_TYPE_SYSTEM_GET_INFO, + .formFactor = XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY, + }; + XrGraphicsRequirementsVulkanKHR reqs = { + .type = XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR, + }; + VkApplicationInfo vk_appinfo = { + .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, + .pNext = NULL, + .pApplicationName = "wineopenxr test instance", + .applicationVersion = 0, + .pEngineName = "wineopenxr test instance", + .engineVersion = VK_MAKE_VERSION(1, 0, 0), + .apiVersion = VK_MAKE_VERSION(1, 1, 0), + }; + VkInstanceCreateInfo vk_createinfo = { + .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, + .pNext = NULL, + .flags = 0, + .pApplicationInfo = &vk_appinfo, + .enabledLayerCount = 0, + .ppEnabledLayerNames = NULL, + .enabledExtensionCount = 0, + .ppEnabledExtensionNames = NULL, + }; + XrViewConfigurationType *configs; + + if (!wine_openxr_unix_init_once()) { + WARN("unixlib initialization failed.\n"); + return XR_ERROR_INITIALIZATION_FAILED; + } + + strcpy(xrCreateInfo.applicationInfo.applicationName, "wineopenxr test instance"); + strcpy(xrCreateInfo.applicationInfo.engineName, "wineopenxr test instance"); + + res = xrCreateInstance(&xrCreateInfo, &instance); + if (res == XR_ERROR_API_VERSION_UNSUPPORTED) { + WARN("version %#lx unsupported.\n", (long)api_version); + api_version = XR_MAKE_VERSION(1, 0, 0); + xrCreateInfo.applicationInfo.apiVersion = api_version; + res = xrCreateInstance(&xrCreateInfo, &instance); + } + if (res != XR_SUCCESS) { + WARN("xrCreateInstance failed: %d\n", res); + return res; + } + + xrGetInstanceProcAddr(instance, "xrGetVulkanInstanceExtensionsKHR", + (PFN_xrVoidFunction *)&pxrGetVulkanInstanceExtensionsKHR); + xrGetInstanceProcAddr(instance, "xrGetVulkanDeviceExtensionsKHR", + (PFN_xrVoidFunction *)&pxrGetVulkanDeviceExtensionsKHR); + xrGetInstanceProcAddr(instance, "xrGetSystem", (PFN_xrVoidFunction *)&pxrGetSystem); + xrGetInstanceProcAddr(instance, "xrGetVulkanGraphicsDeviceKHR", (PFN_xrVoidFunction *)&pxrGetVulkanGraphicsDeviceKHR); + xrGetInstanceProcAddr(instance, "xrGetVulkanGraphicsRequirementsKHR", + (PFN_xrVoidFunction *)&pxrGetVulkanGraphicsRequirementsKHR); + xrGetInstanceProcAddr(instance, "xrGetInstanceProperties", (PFN_xrVoidFunction *)&pxrGetInstanceProperties); + xrGetInstanceProcAddr(instance, "xrEnumerateViewConfigurations", + (PFN_xrVoidFunction *)&pxrEnumerateViewConfigurations); + + res = pxrGetInstanceProperties(instance, &inst_props); + if (res != XR_SUCCESS) { + WARN("xrGetInstanceProperties failed: %d\n", res); + } + + res = pxrGetSystem(instance, &system_info, &system); + if (res != XR_SUCCESS) { + WARN("xrGetSystem failed: %d\n", res); + xrDestroyInstance(instance); + return res; + } + + res = pxrEnumerateViewConfigurations(instance, system, 0, &len, NULL); + if (res != XR_SUCCESS) { + WARN("xrEnumerateViewConfigurations failed: %d\n", res); + } + configs = malloc(len * sizeof(*configs)); + res = pxrEnumerateViewConfigurations(instance, system, len, &len, configs); + if (res != XR_SUCCESS) { + WARN("xrEnumerateViewConfigurations failed: %d\n", res); + } + free(configs); + + res = pxrGetVulkanGraphicsRequirementsKHR(instance, system, &reqs); + if (res != XR_SUCCESS) { + WARN("xrGetVulkanGraphicsRequirementsKHR failed: %d\n", res); + } + + res = pxrGetVulkanInstanceExtensionsKHR(instance, system, 0, &len, NULL); + if (res != XR_SUCCESS) { + WARN("xrGetVulkanInstanceExtensionsKHR failed: %d\n", res); + xrDestroyInstance(instance); + return res; + } + instance_extensions = malloc(len); + res = pxrGetVulkanInstanceExtensionsKHR(instance, system, len, &len, instance_extensions); + if (res != XR_SUCCESS) { + WARN("xrGetVulkanInstanceExtensionsKHR failed: %d\n", res); + xrDestroyInstance(instance); + free(instance_extensions); + return res; + } + + parse_extensions(instance_extensions, &vk_createinfo.enabledExtensionCount, + (char ***)&vk_createinfo.ppEnabledExtensionNames); + + vk_res = vkCreateInstance(&vk_createinfo, NULL, &vk_instance); + if (vk_res != VK_SUCCESS) { + WARN("vkCreateInstance failed: %d\n", vk_res); + for (i = 0; i < vk_createinfo.enabledExtensionCount; ++i) { + free((void *)vk_createinfo.ppEnabledExtensionNames[i]); + } + free((void *)vk_createinfo.ppEnabledExtensionNames); + xrDestroyInstance(instance); + free(instance_extensions); + return XR_ERROR_INITIALIZATION_FAILED; + } + + for (i = 0; i < vk_createinfo.enabledExtensionCount; ++i) { + free((void *)vk_createinfo.ppEnabledExtensionNames[i]); + } + free((void *)vk_createinfo.ppEnabledExtensionNames); + + res = pxrGetVulkanGraphicsDeviceKHR(instance, system, vk_instance, &vk_physdev); + if (res != XR_SUCCESS) { + WARN("xrGetVulkanGraphicsDeviceKHR failed: %d\n", res); + vkDestroyInstance(vk_instance, NULL); + xrDestroyInstance(instance); + free(instance_extensions); + return res; + } + + vkGetPhysicalDeviceProperties(vk_physdev, &vk_dev_props); + *ret_physdev_vid = vk_dev_props.vendorID; + *ret_physdev_pid = vk_dev_props.deviceID; + + res = pxrGetVulkanDeviceExtensionsKHR(instance, system, 0, &len, NULL); + if (res != XR_SUCCESS) { + WARN("pxrGetVulkanDeviceExtensionsKHR fail: %d\n", res); + vkDestroyInstance(vk_instance, NULL); + xrDestroyInstance(instance); + free(instance_extensions); + return res; + } + device_extensions = malloc(len); + res = pxrGetVulkanDeviceExtensionsKHR(instance, system, len, &len, device_extensions); + if (res != XR_SUCCESS) { + WARN("pxrGetVulkanDeviceExtensionsKHR fail: %d\n", res); + vkDestroyInstance(vk_instance, NULL); + xrDestroyInstance(instance); + free(instance_extensions); + free(device_extensions); + return res; + } + + vkDestroyInstance(vk_instance, NULL); + xrDestroyInstance(instance); + + TRACE("Got required instance extensions: %s\n", instance_extensions); + TRACE("Got required device extensions: %s\n", device_extensions); + + *ret_instance_extensions = instance_extensions; + *ret_device_extensions = device_extensions; + + return XR_SUCCESS; +} + +XrResult WINAPI xrCreateInstance(const XrInstanceCreateInfo *createInfo, XrInstance *instance) { + wine_XrInstance *wine_instance = calloc(1, sizeof(wine_XrInstance)); + struct xrCreateInstance_params params = { + .createInfo = createInfo, + .instance = &wine_instance->host_instance, + }; + NTSTATUS _status; + _status = UNIX_CALL(xrCreateInstance, ¶ms); + assert(!_status && "xrCreateInstance"); + + if (params.result != XR_SUCCESS) { + WARN("xrCreateInstance failed: %d\n", params.result); + free(wine_instance); + } else { + *instance = (XrInstance)wine_instance; + } + + return params.result; +} + +XrResult WINAPI xrDestroyInstance(XrInstance instance) { + wine_XrInstance *wine_instance = wine_instance_from_handle(instance); + struct xrDestroyInstance_params params = { + .instance = instance, + }; + NTSTATUS _status; + + TRACE("\n"); + _status = UNIX_CALL(xrDestroyInstance, ¶ms); + assert(!_status && "xrDestroyInstance"); + + if (params.result != XR_SUCCESS) { + WARN("xrDestroyInstance failed: %d\n", params.result); + return params.result; + } + + if (wine_instance->dxvk_device) { + wine_instance->dxvk_device->lpVtbl->Release(wine_instance->dxvk_device); + } + + if (wine_instance->d3d12_device) { + vkDestroyCommandPool(wine_instance->vk_device, wine_instance->vk_command_pool, NULL); + wine_instance->d3d12_device->lpVtbl->Release(wine_instance->d3d12_device); + wine_instance->d3d12_queue->lpVtbl->Release(wine_instance->d3d12_queue); + } + + free(wine_instance); + + return XR_SUCCESS; +} + +/* SteamVR does some internal init during these functions. */ +static XrResult do_vulkan_init(wine_XrInstance *wine_instance, VkInstance vk_instance) { + XrInstance instance = (XrInstance)wine_instance; + char *instance_extensions, *device_extensions; + XrGraphicsRequirementsVulkanKHR vk_reqs; + XrResult res; + uint32_t len; + + vk_reqs.type = XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR; + vk_reqs.next = NULL; + res = xrGetVulkanGraphicsRequirementsKHR(instance, wine_instance->systemId, &vk_reqs); + if (res != XR_SUCCESS) { + WINE_WARN("xrGetVulkanGraphicsRequirementsKHR failed: %d\n", res); + return res; + } + + res = xrGetVulkanInstanceExtensionsKHR(instance, wine_instance->systemId, 0, &len, NULL); + if (res != XR_SUCCESS) { + WINE_WARN("xrGetVulkanInstanceExtensionsKHR failed: %d\n", res); + return res; + } + instance_extensions = malloc(len); + res = xrGetVulkanInstanceExtensionsKHR(instance, wine_instance->systemId, len, &len, instance_extensions); + if (res != XR_SUCCESS) { + WINE_WARN("xrGetVulkanInstanceExtensionsKHR failed: %d\n", res); + free(instance_extensions); + return res; + } + + res = xrGetVulkanGraphicsDeviceKHR(instance, wine_instance->systemId, vk_instance, &wine_instance->vk_phys_dev); + if (res != XR_SUCCESS) { + WINE_WARN("xrGetVulkanGraphicsDeviceKHR failed: %d\n", res); + return res; + } + + res = xrGetVulkanDeviceExtensionsKHR(instance, wine_instance->systemId, 0, &len, NULL); + if (res != XR_SUCCESS) { + WINE_WARN("pxrGetVulkanDeviceExtensionsKHR fail: %d\n", res); + return res; + } + device_extensions = malloc(len); + res = xrGetVulkanDeviceExtensionsKHR(instance, wine_instance->systemId, len, &len, device_extensions); + if (res != XR_SUCCESS) { + WINE_WARN("pxrGetVulkanDeviceExtensionsKHR fail: %d\n", res); + free(device_extensions); + return res; + } + free(device_extensions); + + return XR_SUCCESS; +} + +XrResult WINAPI xrCreateSession(XrInstance instance, const XrSessionCreateInfo *createInfo, XrSession *session) { + wine_XrInstance *wine_instance = wine_instance_from_handle(instance); + wine_XrSession *wine_session = calloc(1, sizeof(wine_XrSession)); + XrSessionCreateInfo our_create_info = *createInfo; + XrGraphicsBindingVulkanKHR our_vk_binding; + struct xrCreateSession_params params = { + .instance = instance, + .createInfo = &our_create_info, + .session = &wine_session->host_session, + }; + XrResult res; + NTSTATUS _status; + uint32_t session_type = 0; + + TRACE("%p, %p, %p\n", instance, createInfo, session); + + if (createInfo->next) { + switch (((XrBaseInStructure *)createInfo->next)->type) { + case XR_TYPE_GRAPHICS_BINDING_VULKAN2_KHR /* == XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR */: { + session_type = SESSION_TYPE_VULKAN; + break; + } + case XR_TYPE_GRAPHICS_BINDING_D3D11_KHR: { + const XrGraphicsBindingD3D11KHR *their_d3d11_binding = (const XrGraphicsBindingD3D11KHR *)createInfo->next; + HRESULT hr; + + hr = ID3D11Device_QueryInterface(their_d3d11_binding->device, &IID_IDXGIVkInteropDevice2, + (void **)&wine_instance->dxvk_device); + if (FAILED(hr)) { + WARN("Given ID3D11Device doesn't support IDXGIVkInteropDevice. Only DXVK is supported.\n"); + return XR_ERROR_VALIDATION_FAILURE; + } + + our_vk_binding.type = XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR; + our_vk_binding.next = NULL; + + wine_instance->dxvk_device->lpVtbl->GetVulkanHandles(wine_instance->dxvk_device, &our_vk_binding.instance, + &our_vk_binding.physicalDevice, &our_vk_binding.device); + + wine_instance->dxvk_device->lpVtbl->GetSubmissionQueue2( + wine_instance->dxvk_device, NULL, &our_vk_binding.queueIndex, &our_vk_binding.queueFamilyIndex); + + if ((res = do_vulkan_init(wine_instance, our_vk_binding.instance)) != XR_SUCCESS) { + return res; + } + + our_vk_binding.physicalDevice = wine_instance->vk_phys_dev; + our_create_info = *createInfo; + our_create_info.next = &our_vk_binding; + session_type = SESSION_TYPE_D3D11; + + break; + } + case XR_TYPE_GRAPHICS_BINDING_D3D12_KHR: { + const XrGraphicsBindingD3D12KHR *their_d3d12_binding = createInfo->next; + VkCommandPoolCreateInfo command_pool_create_info = { + .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, + .flags = 0, + .pNext = NULL, + }; + HRESULT hr; + UINT32 queue_index; + VkQueueFlags queue_flags; + ID3D12DeviceExt1 *device_ext; + hr = ID3D12Device_QueryInterface(their_d3d12_binding->device, &IID_ID3D12DXVKInteropDevice, + (void **)&wine_instance->d3d12_device); + if (FAILED(hr)) { + WARN("Given ID3D12Device doesn't support ID3D12DXVKInteropDevice. Only vkd3d-proton is supported.\n"); + return XR_ERROR_VALIDATION_FAILURE; + } + hr = ID3D12Device_QueryInterface(their_d3d12_binding->device, &IID_ID3D12DeviceExt1, (void **)&device_ext); + if (FAILED(hr)) { + WARN("Given ID3D12Device doesn't support ID3D12DeviceExt1. Only vkd3d-proton is supported.\n"); + return XR_ERROR_VALIDATION_FAILURE; + } + + our_vk_binding.type = XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR; + our_vk_binding.next = NULL; + + wine_instance->d3d12_queue = their_d3d12_binding->queue; + their_d3d12_binding->queue->lpVtbl->AddRef(their_d3d12_binding->queue); + + wine_instance->d3d12_device->lpVtbl->GetVulkanHandles(wine_instance->d3d12_device, &our_vk_binding.instance, + &our_vk_binding.physicalDevice, &our_vk_binding.device); + device_ext->lpVtbl->GetVulkanQueueInfoEx(device_ext, their_d3d12_binding->queue, &wine_instance->vk_queue, + &queue_index, &queue_flags, &our_vk_binding.queueFamilyIndex); + device_ext->lpVtbl->Release(device_ext); + + wine_instance->vk_device = our_vk_binding.device; + our_vk_binding.queueIndex = queue_index; + if ((res = do_vulkan_init(wine_instance, our_vk_binding.instance)) != XR_SUCCESS) { + return res; + } + + our_vk_binding.physicalDevice = wine_instance->vk_phys_dev; + + our_create_info = *createInfo; + our_create_info.next = &our_vk_binding; + + command_pool_create_info.queueFamilyIndex = our_vk_binding.queueFamilyIndex; + if (vkCreateCommandPool(wine_instance->vk_device, &command_pool_create_info, NULL, + &wine_instance->vk_command_pool) != VK_SUCCESS) { + WARN("vkCreateCommandPool failed\n"); + return XR_ERROR_RUNTIME_FAILURE; + } + + session_type = SESSION_TYPE_D3D12; + + break; + } + default: + WARN("Unhandled graphics binding type: %d\n", ((XrBaseInStructure *)createInfo->next)->type); + break; + } + } + + _status = UNIX_CALL(xrCreateSession, ¶ms); + assert(!_status && "xrCreateSession"); + + if (params.result != XR_SUCCESS) { + WARN("xrCreateSession failed: %d\n", res); + free(wine_session); + return params.result; + } + + wine_session->instance = wine_instance; + wine_session->session_type = session_type; + + EnterCriticalSection(&session_list_lock); + + list_add_tail(&session_list, &wine_session->entry); + + LeaveCriticalSection(&session_list_lock); + + *session = (XrSession)wine_session; + + return XR_SUCCESS; +} + +XrResult WINAPI xrDestroySession(XrSession session) { + wine_XrSession *wine_session = wine_session_from_handle(session); + struct xrDestroySession_params params = {.session = session}; + NTSTATUS _status; + + TRACE("%p\n", session); + _status = UNIX_CALL(xrDestroySession, ¶ms); + assert(!_status && "xrDestroySession"); + if (params.result != XR_SUCCESS) { + WARN("xrDestroySession failed: %d\n", params.result); + return params.result; + } + + free(wine_session); + return XR_SUCCESS; +} + +XrResult WINAPI xrPollEvent(XrInstance instance, XrEventDataBuffer *eventData) { + struct xrPollEvent_params params = {.instance = instance, .eventData = eventData}; + NTSTATUS _status; + + WINE_TRACE("%p, %p\n", instance, eventData); + + _status = UNIX_CALL(xrPollEvent, ¶ms); + assert(!_status && "xrPollEvent"); + + WINE_TRACE("eventData->type %#x\n", eventData->type); + + if (params.result == XR_SUCCESS) { + switch (eventData->type) { + case XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED: { + XrEventDataInteractionProfileChanged *evt = (XrEventDataInteractionProfileChanged *)eventData; + evt->session = (XrSession)get_wrapped_XrSession(evt->session); + break; + } + case XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED: { + XrEventDataSessionStateChanged *evt = (XrEventDataSessionStateChanged *)eventData; + evt->session = (XrSession)get_wrapped_XrSession(evt->session); + break; + } + case XR_TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR: { + XrEventDataVisibilityMaskChangedKHR *evt = (XrEventDataVisibilityMaskChangedKHR *)eventData; + evt->session = (XrSession)get_wrapped_XrSession(evt->session); + break; + } + case XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING: { + XrEventDataReferenceSpaceChangePending *evt = (XrEventDataReferenceSpaceChangePending *)eventData; + evt->session = (XrSession)get_wrapped_XrSession(evt->session); + break; + } + case XR_TYPE_EVENT_DATA_USER_PRESENCE_CHANGED_EXT: { + XrEventDataUserPresenceChangedEXT *evt = (XrEventDataUserPresenceChangedEXT *)eventData; + evt->session = (XrSession)get_wrapped_XrSession(evt->session); + break; + } + case XR_TYPE_EVENT_DATA_LOCALIZATION_CHANGED_ML: { + XrEventDataLocalizationChangedML *evt = (XrEventDataLocalizationChangedML *)eventData; + evt->session = (XrSession)get_wrapped_XrSession(evt->session); + break; + } + default: + break; + } + } + + return params.result; +} +XrResult WINAPI xrGetSystem(XrInstance instance, const XrSystemGetInfo *getInfo, XrSystemId *systemId) { + wine_XrInstance *wine_instance = wine_instance_from_handle(instance); + struct xrGetSystem_params params = {.instance = instance, .getInfo = getInfo, .systemId = systemId}; + NTSTATUS _status; + + TRACE("%p, %p, %p\n", instance, getInfo, systemId); + _status = UNIX_CALL(xrGetSystem, ¶ms); + assert(!_status && "xrGetSystem"); + if (params.result != XR_SUCCESS) { + return params.result; + } + + wine_instance->systemId = *systemId; + return params.result; +} + +static BOOL is_vulkan_format_depth(VkFormat format) { + switch (format) { + case VK_FORMAT_B8G8R8A8_SRGB: + case VK_FORMAT_B8G8R8A8_UNORM: + case VK_FORMAT_R8G8B8A8_SRGB: + case VK_FORMAT_R8G8B8A8_UNORM: + case VK_FORMAT_R32G32B32A32_SFLOAT: + case VK_FORMAT_R32G32B32_SFLOAT: + case VK_FORMAT_R16G16B16A16_SFLOAT: + case VK_FORMAT_A2B10G10R10_UNORM_PACK32: + return FALSE; + case VK_FORMAT_D32_SFLOAT: + case VK_FORMAT_D16_UNORM: + case VK_FORMAT_D24_UNORM_S8_UINT: + case VK_FORMAT_D32_SFLOAT_S8_UINT: + return TRUE; + + default: + WARN("Unknown vulkan format %#x", format); + return FALSE; + } +} + +int64_t map_format_dxgi_to_vulkan(int64_t format) { + switch (format) { + case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB: + return VK_FORMAT_B8G8R8A8_SRGB; + + case DXGI_FORMAT_B8G8R8A8_UNORM: + return VK_FORMAT_B8G8R8A8_UNORM; + + case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: + return VK_FORMAT_R8G8B8A8_SRGB; + + case DXGI_FORMAT_R8G8B8A8_UNORM: + return VK_FORMAT_R8G8B8A8_UNORM; + + case DXGI_FORMAT_R32G32B32A32_FLOAT: + return VK_FORMAT_R32G32B32A32_SFLOAT; + + case DXGI_FORMAT_R32G32B32_FLOAT: + return VK_FORMAT_R32G32B32_SFLOAT; + + case DXGI_FORMAT_R16G16B16A16_FLOAT: + return VK_FORMAT_R16G16B16A16_SFLOAT; + + case DXGI_FORMAT_R10G10B10A2_UNORM: + return VK_FORMAT_A2B10G10R10_UNORM_PACK32; + + case DXGI_FORMAT_D32_FLOAT: + return VK_FORMAT_D32_SFLOAT; + + case DXGI_FORMAT_D16_UNORM: + return VK_FORMAT_D16_UNORM; + + case DXGI_FORMAT_D24_UNORM_S8_UINT: + return VK_FORMAT_D24_UNORM_S8_UINT; + + case DXGI_FORMAT_D32_FLOAT_S8X24_UINT: + return VK_FORMAT_D32_SFLOAT_S8_UINT; + + default: + WARN("Unable to map DXGI format (%lu) to Vulkan format\n", (long)format); + return VK_FORMAT_UNDEFINED; + } +} + +int64_t map_format_vulkan_to_dxgi(int64_t format) { + switch (format) { + case VK_FORMAT_B8G8R8A8_SRGB: + return DXGI_FORMAT_B8G8R8A8_UNORM_SRGB; + + case VK_FORMAT_B8G8R8A8_UNORM: + return DXGI_FORMAT_B8G8R8A8_UNORM; + + case VK_FORMAT_R8G8B8A8_SRGB: + return DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; + + case VK_FORMAT_R8G8B8A8_UNORM: + return DXGI_FORMAT_R8G8B8A8_UNORM; + + case VK_FORMAT_R32G32B32A32_SFLOAT: + return DXGI_FORMAT_R32G32B32A32_FLOAT; + + case VK_FORMAT_R32G32B32_SFLOAT: + return DXGI_FORMAT_R32G32B32_FLOAT; + + case VK_FORMAT_R16G16B16A16_SFLOAT: + return DXGI_FORMAT_R16G16B16A16_FLOAT; + + case VK_FORMAT_A2B10G10R10_UNORM_PACK32: + return DXGI_FORMAT_R10G10B10A2_UNORM; + + case VK_FORMAT_D32_SFLOAT: + return DXGI_FORMAT_D32_FLOAT; + + case VK_FORMAT_D16_UNORM: + return DXGI_FORMAT_D16_UNORM; + + case VK_FORMAT_D24_UNORM_S8_UINT: + return DXGI_FORMAT_D24_UNORM_S8_UINT; + + case VK_FORMAT_D32_SFLOAT_S8_UINT: + return DXGI_FORMAT_D32_FLOAT_S8X24_UINT; + + default: + WARN("Unable to map Vulkan format (%lu) to DXGI format\n", (long)format); + return DXGI_FORMAT_UNKNOWN; + } +} + +XrResult WINAPI xrEnumerateSwapchainFormats(XrSession session, + uint32_t formatCapacityInput, + uint32_t *formatCountOutput, + int64_t *formats) { + wine_XrSession *wine_session = wine_session_from_handle(session); + uint32_t real_format_count; + int64_t *real_formats; + uint32_t i, o; + struct xrEnumerateSwapchainFormats_params params = { + .session = session, + .formatCapacityInput = formatCapacityInput, + .formatCountOutput = formatCountOutput, + .formats = formats, + }; + NTSTATUS _status; + + TRACE("%p, %u, %p, %p\n", session, formatCapacityInput, formatCountOutput, formats); + + if (wine_session->session_type != SESSION_TYPE_D3D11 && wine_session->session_type != SESSION_TYPE_D3D12) { + _status = UNIX_CALL(xrEnumerateSwapchainFormats, ¶ms); + assert(!_status && "xrEnumerateSwapchainFormats"); + return params.result; + } + + params.formatCapacityInput = 0; + params.formatCountOutput = &real_format_count; + params.formats = NULL; + + _status = UNIX_CALL(xrEnumerateSwapchainFormats, ¶ms); + assert(!_status && "xrEnumerateSwapchainFormats"); + if (params.result != XR_SUCCESS) { + return params.result; + } + + real_formats = malloc(sizeof(*real_formats) * real_format_count); + + params.formatCapacityInput = real_format_count; + params.formats = real_formats; + + _status = UNIX_CALL(xrEnumerateSwapchainFormats, ¶ms); + assert(!_status && "xrEnumerateSwapchainFormats"); + if (params.result != XR_SUCCESS) { + goto done; + } + + o = 0; + for (i = 0; i < real_format_count; ++i) { + int64_t mapped = map_format_vulkan_to_dxgi(real_formats[i]); + + if (mapped == DXGI_FORMAT_UNKNOWN) { + continue; + } + + if (formatCapacityInput && formats) { + if (o < formatCapacityInput) { + formats[o] = mapped; + } else { + params.result = XR_ERROR_SIZE_INSUFFICIENT; + } + } + ++o; + } + *formatCountOutput = o; + +done: + free(real_formats); + return params.result; +} + +XrResult WINAPI xrCreateSwapchain(XrSession session, const XrSwapchainCreateInfo *createInfo, XrSwapchain *swapchain) { + wine_XrSession *wine_session = wine_session_from_handle(session); + wine_XrSwapchain *wine_swapchain = calloc(1, sizeof(wine_XrSwapchain)); + XrSwapchainCreateInfo our_createInfo = *createInfo; + struct xrCreateSwapchain_params params = { + .session = session, .createInfo = &our_createInfo, .swapchain = &wine_swapchain->host_swapchain}; + NTSTATUS _status; + + wine_swapchain->create_info = *createInfo; + + TRACE("%p, %p, %p\n", session, createInfo, swapchain); + + if (wine_session->session_type == SESSION_TYPE_D3D11 || wine_session->session_type == SESSION_TYPE_D3D12) { + BOOL format_is_depth; + our_createInfo.format = map_format_dxgi_to_vulkan(createInfo->format); + if (our_createInfo.format == VK_FORMAT_UNDEFINED) { + ERR("unable to set Vulkan format\n"); + free(wine_swapchain); + return XR_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED; + } + + our_createInfo.usageFlags |= XR_SWAPCHAIN_USAGE_MUTABLE_FORMAT_BIT; + + format_is_depth = is_vulkan_format_depth(our_createInfo.format); + if ((createInfo->usageFlags & XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT) && format_is_depth) { + WARN("Swapchain has a color attachment usage, but it's format is for depth\n"); + } + if ((createInfo->usageFlags & XR_SWAPCHAIN_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) && !format_is_depth) { + WARN("Swapchain has a depth/stencil usage, but it's format is for color\n"); + } + } + + _status = UNIX_CALL(xrCreateSwapchain, ¶ms); + assert(!_status && "xrCreateSwapchain"); + if (params.result != XR_SUCCESS) { + WARN("xrCreateSwapchain failed: %d\n", params.result); + free(wine_swapchain); + return params.result; + } + + wine_swapchain->session = wine_session; + *swapchain = (XrSwapchain)wine_swapchain; + + return XR_SUCCESS; +} + +static void release_d3d12_resources(wine_XrSwapchain *swapchain, uint32_t image_count) { + wine_XrInstance *instance = swapchain->session->instance; + XrSwapchainImageD3D12KHR *d3d12_images = (XrSwapchainImageD3D12KHR *)swapchain->images; + UINT i; + if (!image_count) { + return; + } + + for (i = 0; i < image_count; i++) { + if (d3d12_images[i].texture) { + d3d12_images[i].texture->lpVtbl->Release(d3d12_images[i].texture); + } + } + vkFreeCommandBuffers(instance->vk_device, instance->vk_command_pool, image_count, swapchain->cmd_release); + vkFreeCommandBuffers(instance->vk_device, instance->vk_command_pool, image_count, swapchain->cmd_acquire); + free(swapchain->cmd_release); + free(swapchain->cmd_acquire); + free(swapchain->acquired); + free(swapchain->acquired_indices); +} + +XrResult WINAPI xrDestroySwapchain(XrSwapchain swapchain) { + wine_XrSwapchain *wine_swapchain = wine_swapchain_from_handle(swapchain); + struct xrDestroySwapchain_params params = {.swapchain = swapchain}; + NTSTATUS _status; + + TRACE("%p\n", swapchain); + + _status = UNIX_CALL(xrDestroySwapchain, ¶ms); + assert(!_status && "xrDestroySwapchain"); + if (params.result != XR_SUCCESS) { + WARN("xrDestroySwapchain failed: %d\n", params.result); + return params.result; + } + + if (wine_swapchain->image_count) { + UINT i; + if (wine_swapchain->session->session_type == SESSION_TYPE_D3D11) { + XrSwapchainImageD3D11KHR *d3d11_images = (XrSwapchainImageD3D11KHR *)wine_swapchain->images; + for (i = 0; i < wine_swapchain->image_count; i++) { + d3d11_images[i].texture->lpVtbl->Release(d3d11_images[i].texture); + } + } else if (wine_swapchain->session->session_type == SESSION_TYPE_D3D12) { + release_d3d12_resources(wine_swapchain, wine_swapchain->image_count); + } + free(wine_swapchain->images); + wine_swapchain->image_count = 0; + } + + free(wine_swapchain); + + return XR_SUCCESS; +} + +static D3D11_USAGE d3d11usage_from_XrSwapchainUsageFlags(XrSwapchainUsageFlags flags) { + static const D3D11_USAGE supported_flags = XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT | + XR_SWAPCHAIN_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | + XR_SWAPCHAIN_USAGE_UNORDERED_ACCESS_BIT | XR_SWAPCHAIN_USAGE_SAMPLED_BIT; + D3D11_USAGE ret = 0; + + if (flags & ~supported_flags) { + WINE_FIXME("Unhandled flags %#lx.\n", (long)flags); + } + + if (flags & XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT) { + ret |= D3D11_BIND_RENDER_TARGET; + } + if (flags & XR_SWAPCHAIN_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) { + ret |= D3D11_BIND_DEPTH_STENCIL; + } + if (flags & XR_SWAPCHAIN_USAGE_UNORDERED_ACCESS_BIT) { + ret |= D3D11_BIND_UNORDERED_ACCESS; + } + if (flags & XR_SWAPCHAIN_USAGE_SAMPLED_BIT) { + ret |= D3D11_BIND_SHADER_RESOURCE; + } + + return ret; +} + +static VkResult record_transition_command(wine_XrInstance *instance, + VkImage image, + VkImageSubresourceRange subresource, + VkImageLayout from, + VkImageLayout to, + VkCommandBuffer *out_cmd) { + VkResult ret; + VkCommandBufferAllocateInfo command_buffer_allocate_info = { + .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, + .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY, + .commandPool = instance->vk_command_pool, + .commandBufferCount = 1, + }; + VkCommandBufferBeginInfo begin_info = { + .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, + .flags = 0, + }; + VkImageMemoryBarrier barrier = { + .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, + .oldLayout = from, + .newLayout = to, + .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .image = image, + .subresourceRange = subresource, + .srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT, + .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT, + }; + + *out_cmd = VK_NULL_HANDLE; + if (from == to) { + return VK_SUCCESS; + } + + if ((ret = vkAllocateCommandBuffers(instance->vk_device, &command_buffer_allocate_info, out_cmd)) != VK_SUCCESS) { + return ret; + } + if ((ret = vkBeginCommandBuffer(*out_cmd, &begin_info)) != VK_SUCCESS) { + return ret; + } + vkCmdPipelineBarrier(*out_cmd, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, 0, 0, NULL, 0, + NULL, 1, &barrier); + return vkEndCommandBuffer(*out_cmd); +} + +XrResult WINAPI xrEnumerateSwapchainImages(XrSwapchain swapchain, + uint32_t imageCapacityInput, + uint32_t *imageCountOutput, + XrSwapchainImageBaseHeader *images) { + wine_XrSwapchain *wine_swapchain = wine_swapchain_from_handle(swapchain); + wine_XrInstance *wine_instance = wine_swapchain->session->instance; + XrSwapchainImageVulkanKHR *our_vk; + HRESULT hr; + size_t image_size = 0; + uint32_t i; + struct xrEnumerateSwapchainImages_params params = { + .swapchain = swapchain, + .imageCapacityInput = imageCapacityInput, + .imageCountOutput = imageCountOutput, + .images = images, + }; + NTSTATUS _status; + + TRACE("%p, %u, %p, %p\n", swapchain, imageCapacityInput, imageCountOutput, images); + if (wine_swapchain->session->session_type != SESSION_TYPE_D3D11 && + wine_swapchain->session->session_type != SESSION_TYPE_D3D12) { + _status = UNIX_CALL(xrEnumerateSwapchainImages, ¶ms); + assert(!_status && "xrEnumerateSwapchainImages"); + return params.result; + } + + if (!wine_swapchain->image_count) { + uint32_t image_count; + params.imageCapacityInput = 0; + params.imageCountOutput = &image_count; + params.images = NULL; + _status = UNIX_CALL(xrEnumerateSwapchainImages, ¶ms); + assert(!_status && "xrEnumerateSwapchainImages"); + if (params.result != XR_SUCCESS) { + return params.result; + } + + our_vk = malloc(sizeof(*our_vk) * image_count); + for (i = 0; i < image_count; ++i) { + our_vk[i].type = XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR; + } + + params.imageCapacityInput = image_count; + params.images = (XrSwapchainImageBaseHeader *)our_vk; + _status = UNIX_CALL(xrEnumerateSwapchainImages, ¶ms); + assert(!_status && "xrEnumerateSwapchainImages"); + if (params.result != XR_SUCCESS) { + free(our_vk); + return params.result; + } + + if (wine_swapchain->session->session_type == SESSION_TYPE_D3D11) { + XrSwapchainImageD3D11KHR *our_d3d11; + D3D11_TEXTURE2D_DESC1 desc; + + desc.Width = wine_swapchain->create_info.width; + desc.Height = wine_swapchain->create_info.height; + desc.MipLevels = wine_swapchain->create_info.mipCount; + desc.ArraySize = wine_swapchain->create_info.arraySize; + desc.Format = wine_swapchain->create_info.format; + TRACE("creating dxvk texture with dxgi format %d (%x)\n", desc.Format, desc.Format); + desc.SampleDesc.Count = wine_swapchain->create_info.sampleCount; + desc.SampleDesc.Quality = 0; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.BindFlags = d3d11usage_from_XrSwapchainUsageFlags(wine_swapchain->create_info.usageFlags); + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + desc.TextureLayout = D3D11_TEXTURE_LAYOUT_UNDEFINED; + + our_d3d11 = malloc(sizeof(XrSwapchainImageD3D11KHR) * image_count); + for (i = 0; i < image_count; ++i) { + hr = wine_instance->dxvk_device->lpVtbl->CreateTexture2DFromVkImage(wine_instance->dxvk_device, &desc, + our_vk[i].image, &our_d3d11[i].texture); + if (FAILED(hr)) { + UINT j; + for (j = 0; j < i; ++j) { + our_d3d11[i].texture->lpVtbl->Release(our_d3d11[i].texture); + } + free(our_d3d11); + free(our_vk); + WARN("Failed to create DXVK texture from VkImage: %08x\n", hr); + return XR_ERROR_RUNTIME_FAILURE; + } + TRACE("Successfully allocated texture %p\n", our_d3d11[i].texture); + } + wine_swapchain->images = (XrSwapchainImageBaseHeader *)our_d3d11; + } else if (wine_swapchain->session->session_type == SESSION_TYPE_D3D12) { + XrSwapchainImageD3D12KHR *our_d3d12; + D3D12_RESOURCE_DESC1 desc; + ID3D12DeviceExt1 *device_ext; + HRESULT hr = wine_instance->d3d12_device->lpVtbl->QueryInterface(wine_instance->d3d12_device, + &IID_ID3D12DeviceExt1, (void **)&device_ext); + BOOL format_is_depth = is_vulkan_format_depth(map_format_dxgi_to_vulkan(wine_swapchain->create_info.format)); + BOOL succeeded = TRUE; + const D3D12_RESOURCE_STATES incoming_state = + format_is_depth ? D3D12_RESOURCE_STATE_DEPTH_WRITE : D3D12_RESOURCE_STATE_RENDER_TARGET; + const VkImageLayout vk_layout = + format_is_depth ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + const VkImageSubresourceRange subresource = { + .layerCount = wine_swapchain->create_info.arraySize, + .baseArrayLayer = 0, + .levelCount = wine_swapchain->create_info.mipCount, + .baseMipLevel = 0, + .aspectMask = + format_is_depth ? (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) : VK_IMAGE_ASPECT_COLOR_BIT, + }; + if (FAILED(hr)) { + ERR("Cannot get vkd3d-proton interface: %08x\n", hr); + return XR_ERROR_VALIDATION_FAILURE; + } + + desc.Alignment = 0; + desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; + desc.Width = wine_swapchain->create_info.width; + desc.Height = wine_swapchain->create_info.height; + desc.MipLevels = wine_swapchain->create_info.mipCount; + desc.DepthOrArraySize = wine_swapchain->create_info.arraySize; + desc.Format = wine_swapchain->create_info.format; + TRACE("creating vkd3d-proton texture with dxgi format %d (%x)\n", desc.Format, desc.Format); + desc.SampleDesc.Count = wine_swapchain->create_info.sampleCount; + desc.SampleDesc.Quality = 0; + desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; + desc.Flags = 0; + if (!format_is_depth) { + desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET; + } else { + desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL; + if (!(wine_swapchain->create_info.usageFlags & XR_SWAPCHAIN_USAGE_SAMPLED_BIT)) { + desc.Flags |= D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE; + } + } + if (wine_swapchain->create_info.usageFlags & XR_SWAPCHAIN_USAGE_UNORDERED_ACCESS_BIT) { + desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS; + } + + our_d3d12 = calloc(1, sizeof(XrSwapchainImageD3D12KHR) * image_count); + for (i = 0; i < image_count; ++i) { + hr = device_ext->lpVtbl->CreateResourceFromBorrowedHandle(device_ext, &desc, our_vk[i].image, + &our_d3d12[i].texture); + if (FAILED(hr)) { + ERR("Failed to create vkd3d-proton texture from VkImage: %08x\n", hr); + succeeded = FALSE; + break; + } + TRACE("Successfully allocated texture %p\n", our_d3d12[i].texture); + } + device_ext->lpVtbl->Release(device_ext); + + if (succeeded) { + wine_swapchain->acquired = calloc(1, sizeof(BOOL) * image_count); + wine_swapchain->acquired_indices = malloc(sizeof(uint32_t) * (image_count + 1)); + wine_swapchain->acquired_count = wine_swapchain->acquired_start = 0; + wine_swapchain->images = (XrSwapchainImageBaseHeader *)our_d3d12; + + wine_swapchain->cmd_release = calloc(1, sizeof(VkCommandBuffer) * image_count); + wine_swapchain->cmd_acquire = calloc(1, sizeof(VkCommandBuffer) * image_count); + for (i = 0; i < image_count; i++) { + VkImageLayout d3d12_vk_layout; + wine_instance->d3d12_device->lpVtbl->GetVulkanImageLayout(wine_instance->d3d12_device, our_d3d12[i].texture, + incoming_state, &d3d12_vk_layout); + if (record_transition_command(wine_instance, our_vk[i].image, subresource, d3d12_vk_layout, vk_layout, + &wine_swapchain->cmd_release[i]) != VK_SUCCESS || + record_transition_command(wine_instance, our_vk[i].image, subresource, vk_layout, d3d12_vk_layout, + &wine_swapchain->cmd_acquire[i]) != VK_SUCCESS) { + ERR("Failed to create command buffer for layout transition\n"); + succeeded = FALSE; + break; + } + } + } + if (!succeeded) { + release_d3d12_resources(wine_swapchain, image_count); + free(wine_swapchain->images); + wine_swapchain->images = NULL; + free(our_vk); + return XR_ERROR_RUNTIME_FAILURE; + } + } + free(our_vk); + wine_swapchain->image_count = image_count; + TRACE("image count %d\n", image_count); + } + + *imageCountOutput = wine_swapchain->image_count; + if (wine_swapchain->session->session_type == SESSION_TYPE_D3D11) { + image_size = sizeof(XrSwapchainImageD3D11KHR); + } else if (wine_swapchain->session->session_type == SESSION_TYPE_D3D12) { + image_size = sizeof(XrSwapchainImageD3D12KHR); + } + memcpy(images, wine_swapchain->images, image_size * min(wine_swapchain->image_count, imageCapacityInput)); + return XR_SUCCESS; +} + +XrResult WINAPI xrAcquireSwapchainImage(XrSwapchain swapchain, + const XrSwapchainImageAcquireInfo *acquireInfo, + uint32_t *index) { + wine_XrSwapchain *wine_swapchain = wine_swapchain_from_handle(swapchain); + wine_XrInstance *wine_instance = wine_swapchain->session->instance; + IDXGIVkInteropDevice2 *dxvk_device; + ID3D12DXVKInteropDevice *d3d12_device; + struct xrAcquireSwapchainImage_params params = { + .swapchain = swapchain, + .acquireInfo = acquireInfo, + .index = index, + }; + NTSTATUS _status; + + TRACE("%p, %p, %p image count %d, acquired %d\n", swapchain, acquireInfo, index, wine_swapchain->image_count, + wine_swapchain->acquired_count); + + if ((dxvk_device = wine_instance->dxvk_device)) { + dxvk_device->lpVtbl->LockSubmissionQueue(dxvk_device); + } else if ((d3d12_device = wine_instance->d3d12_device)) { + if (wine_swapchain->acquired_count >= wine_swapchain->image_count) { + WARN("Application has acquired all images but still tries to acquire more.\n"); + return XR_ERROR_CALL_ORDER_INVALID; + } + d3d12_device->lpVtbl->LockCommandQueue(d3d12_device, wine_instance->d3d12_queue); + } + + _status = UNIX_CALL(xrAcquireSwapchainImage, ¶ms); + assert(!_status && "xrAcquireSwapchainImage"); + + if (dxvk_device) { + dxvk_device->lpVtbl->ReleaseSubmissionQueue(dxvk_device); + return params.result; + } + + if (!d3d12_device) { + return params.result; + } + + if (params.result == XR_SUCCESS) { + if (!wine_swapchain->acquired[*index] && wine_swapchain->cmd_acquire[*index] != VK_NULL_HANDLE) { + VkSubmitInfo submit_info = { + .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, + .commandBufferCount = 1, + .pCommandBuffers = &wine_swapchain->cmd_acquire[*index], + }; + + vkQueueSubmit(wine_instance->vk_queue, 1, &submit_info, VK_NULL_HANDLE); + } + if (!wine_swapchain->acquired[*index]) { + uint32_t next = (wine_swapchain->acquired_start + wine_swapchain->acquired_count) % wine_swapchain->image_count; + wine_swapchain->acquired[*index] = TRUE; + wine_swapchain->acquired_indices[next] = *index; + wine_swapchain->acquired_count += 1; + } else { + WARN("the application acquired the same image (index %d) again!?", *index); + } + } + d3d12_device->lpVtbl->UnlockCommandQueue(d3d12_device, wine_instance->d3d12_queue); + return params.result; +} + +XrResult WINAPI xrReleaseSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageReleaseInfo *releaseInfo) { + wine_XrSwapchain *wine_swapchain = wine_swapchain_from_handle(swapchain); + wine_XrInstance *wine_instance = wine_swapchain->session->instance; + IDXGIVkInteropDevice2 *dxvk_device; + ID3D12DXVKInteropDevice *d3d12_device = wine_instance->d3d12_device; + uint32_t index; + struct xrReleaseSwapchainImage_params params = { + .swapchain = swapchain, + .releaseInfo = releaseInfo, + }; + NTSTATUS _status; + + TRACE("%p, %p\n", swapchain, releaseInfo); + + if ((dxvk_device = wine_instance->dxvk_device)) { + dxvk_device->lpVtbl->LockSubmissionQueue(dxvk_device); + } else if (d3d12_device) { + if (wine_swapchain->acquired_count == 0) { + WARN("Application tried to release a swapchain image without having acquired it first.\n"); + return XR_ERROR_CALL_ORDER_INVALID; + } + + d3d12_device->lpVtbl->LockCommandQueue(d3d12_device, wine_instance->d3d12_queue); + + index = wine_swapchain->acquired_indices[wine_swapchain->acquired_start]; + if (wine_swapchain->cmd_release[index] != VK_NULL_HANDLE) { + VkSubmitInfo submit_info = { + .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, + .commandBufferCount = 1, + .pCommandBuffers = &wine_swapchain->cmd_release[index], + }; + + vkQueueSubmit(wine_instance->vk_queue, 1, &submit_info, VK_NULL_HANDLE); + } + } + + _status = UNIX_CALL(xrReleaseSwapchainImage, ¶ms); + assert(!_status && "xrReleaseSwapchainImage"); + if (dxvk_device) { + dxvk_device->lpVtbl->ReleaseSubmissionQueue(dxvk_device); + return params.result; + } + if (!d3d12_device) { + return params.result; + } + + if (params.result != XR_SUCCESS && wine_swapchain->cmd_release[index] != VK_NULL_HANDLE) { + VkSubmitInfo submit_info = { + .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, + .commandBufferCount = 1, + .pCommandBuffers = &wine_swapchain->cmd_acquire[index], + }; + WARN("xrReleaseSwapchainImage failed, reverting layout transition\n"); + vkQueueSubmit(wine_instance->vk_queue, 1, &submit_info, VK_NULL_HANDLE); + } + if (params.result == XR_SUCCESS) { + wine_swapchain->acquired[index] = FALSE; + wine_swapchain->acquired_start = (wine_swapchain->acquired_start + 1) % wine_swapchain->image_count; + wine_swapchain->acquired_count -= 1; + } + d3d12_device->lpVtbl->UnlockCommandQueue(d3d12_device, wine_instance->d3d12_queue); + return params.result; +} + +XrResult WINAPI xrBeginFrame(XrSession session, const XrFrameBeginInfo *frameBeginInfo) { + wine_XrSession *wine_session = wine_session_from_handle(session); + struct xrBeginFrame_params params = { + .session = session, + .frameBeginInfo = frameBeginInfo, + }; + IDXGIVkInteropDevice2 *dxvk_device; + ID3D12DXVKInteropDevice *d3d12_device; + NTSTATUS _status; + + TRACE("%p, %p\n", session, frameBeginInfo); + + if ((dxvk_device = wine_session->instance->dxvk_device)) { + dxvk_device->lpVtbl->LockSubmissionQueue(dxvk_device); + } else if ((d3d12_device = wine_session->instance->d3d12_device)) { + d3d12_device->lpVtbl->LockCommandQueue(d3d12_device, wine_session->instance->d3d12_queue); + } + + _status = UNIX_CALL(xrBeginFrame, ¶ms); + assert(!_status && "xrBeginFrame"); + + if (dxvk_device) { + dxvk_device->lpVtbl->ReleaseSubmissionQueue(dxvk_device); + } else if (d3d12_device) { + d3d12_device->lpVtbl->UnlockCommandQueue(d3d12_device, wine_session->instance->d3d12_queue); + } + return params.result; +} + +static XrCompositionLayerBaseHeader *convert_XrCompositionLayer(wine_XrSession *wine_session, + const XrCompositionLayerBaseHeader *in_layer, + CompositionLayer *out_layer, + uint32_t *view_idx, + uint32_t *view_info_idx) { + uint32_t i; + + TRACE("Type %u, pNext %p.\n", in_layer->type, in_layer->next); + + switch (in_layer->type) { + case XR_TYPE_COMPOSITION_LAYER_CUBE_KHR: { + out_layer->cube = *(const XrCompositionLayerCubeKHR *)in_layer; + out_layer->cube.swapchain = wine_swapchain_from_handle(out_layer->cube.swapchain)->host_swapchain; + break; + } + + case XR_TYPE_COMPOSITION_LAYER_CYLINDER_KHR: + out_layer->cylinder = *(const XrCompositionLayerCylinderKHR *)in_layer; + out_layer->cylinder.subImage.swapchain = + wine_swapchain_from_handle(out_layer->cylinder.subImage.swapchain)->host_swapchain; + break; + + case XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR: + out_layer->depth_info = *(const XrCompositionLayerDepthInfoKHR *)in_layer; + out_layer->depth_info.subImage.swapchain = + wine_swapchain_from_handle(out_layer->depth_info.subImage.swapchain)->host_swapchain; + break; + + case XR_TYPE_COMPOSITION_LAYER_EQUIRECT_KHR: + out_layer->equirect = *(const XrCompositionLayerEquirectKHR *)in_layer; + out_layer->equirect.subImage.swapchain = + wine_swapchain_from_handle(out_layer->equirect.subImage.swapchain)->host_swapchain; + break; + + case XR_TYPE_COMPOSITION_LAYER_EQUIRECT2_KHR: + out_layer->equirect2 = *(const XrCompositionLayerEquirect2KHR *)in_layer; + out_layer->equirect2.subImage.swapchain = + wine_swapchain_from_handle(out_layer->equirect2.subImage.swapchain)->host_swapchain; + break; + + case XR_TYPE_COMPOSITION_LAYER_PROJECTION: { + const XrCompositionLayerProjectionView *view; + unsigned int view_info_count; + + out_layer->projection = *(const XrCompositionLayerProjection *)in_layer; + + view_info_count = 0; + for (i = 0; i < out_layer->projection.viewCount; ++i) { + view = &((XrCompositionLayerProjection *)in_layer)->views[i]; + while ((view = view->next)) { + ++view_info_count; + } + } + + if (out_layer->projection.viewCount + *view_idx > wine_session->projection_view_count) { + wine_session->projection_view_count = out_layer->projection.viewCount + *view_idx; + wine_session->projection_views = + realloc(wine_session->projection_views, + sizeof(XrCompositionLayerProjectionView) * wine_session->projection_view_count); + } + + if (view_info_count + *view_info_idx > wine_session->view_info_count) { + wine_session->view_info_count += view_info_count; + wine_session->view_infos = + realloc(wine_session->view_infos, sizeof(*wine_session->view_infos) * wine_session->view_info_count); + } + + out_layer->projection.views = &wine_session->projection_views[*view_idx]; + memcpy((void *)out_layer->projection.views, ((const XrCompositionLayerProjection *)in_layer)->views, + sizeof(XrCompositionLayerProjectionView) * out_layer->projection.viewCount); + view_info_count = 0; + for (i = 0; i < out_layer->projection.viewCount; ++i) { + view = &out_layer->projection.views[i]; + if (view->type != XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW) { + WARN("Unexpected view type %u.\n", view->type); + } + + ((XrCompositionLayerProjectionView *)view)->subImage.swapchain = + wine_swapchain_from_handle(view->subImage.swapchain)->host_swapchain; + while (view->next) { + TRACE("Projection view type %u.\n", ((XrCompositionLayerProjectionView *)view->next)->type); + switch (((XrCompositionLayerProjectionView *)view->next)->type) { + case XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR: { + XrCompositionLayerDepthInfoKHR *out_depth_info, *in_depth_info; + + in_depth_info = (XrCompositionLayerDepthInfoKHR *)view->next; + out_depth_info = &wine_session->view_infos[*view_info_idx + view_info_count].depth_info; + *out_depth_info = *in_depth_info; + out_depth_info->subImage.swapchain = + wine_swapchain_from_handle(out_depth_info->subImage.swapchain)->host_swapchain; + ((XrCompositionLayerProjectionView *)view)->next = out_depth_info; + break; + } + case XR_TYPE_COMPOSITION_LAYER_SPACE_WARP_INFO_FB: { + XrCompositionLayerSpaceWarpInfoFB *out_warp_info, *in_warp_info; + + in_warp_info = (XrCompositionLayerSpaceWarpInfoFB *)view->next; + out_warp_info = &wine_session->view_infos[*view_info_idx + view_info_count].space_warp_info; + *out_warp_info = *in_warp_info; + out_warp_info->motionVectorSubImage.swapchain = + wine_swapchain_from_handle(out_warp_info->motionVectorSubImage.swapchain)->host_swapchain; + out_warp_info->depthSubImage.swapchain = + wine_swapchain_from_handle(out_warp_info->depthSubImage.swapchain)->host_swapchain; + ((XrCompositionLayerProjectionView *)view)->next = out_warp_info; + break; + } + default: + WARN("Unknown view info type %u.\n", view->type); + break; + } + ++view_info_count; + view = view->next; + } + } + + *view_idx += out_layer->projection.viewCount; + *view_info_idx += view_info_count; + break; + } + case XR_TYPE_COMPOSITION_LAYER_QUAD: + out_layer->quad = *(const XrCompositionLayerQuad *)in_layer; + out_layer->quad.subImage.swapchain = + wine_swapchain_from_handle(out_layer->quad.subImage.swapchain)->host_swapchain; + break; + + default: + WARN("Unknown composition in_layer type: %d\n", in_layer->type); + return (XrCompositionLayerBaseHeader *)in_layer; + } + + return (XrCompositionLayerBaseHeader *)out_layer; +} + +XrResult WINAPI xrEndFrame(XrSession session, const XrFrameEndInfo *frameEndInfo) { + wine_XrSession *wine_session = wine_session_from_handle(session); + XrFrameEndInfo our_frameEndInfo; + struct xrEndFrame_params params = { + .session = session, + .frameEndInfo = &our_frameEndInfo, + }; + IDXGIVkInteropDevice2 *dxvk_device; + ID3D12DXVKInteropDevice *d3d12_device; + uint32_t i, view_idx = 0, view_info_idx = 0; + NTSTATUS _status; + + TRACE("%p, %p\n", session, frameEndInfo); + + if (frameEndInfo->layerCount > wine_session->composition_layer_count) { + free(wine_session->composition_layers); + wine_session->composition_layers = malloc(frameEndInfo->layerCount * sizeof(*wine_session->composition_layers)); + free(wine_session->composition_layer_ptrs); + wine_session->composition_layer_ptrs = + malloc(frameEndInfo->layerCount * sizeof(*wine_session->composition_layer_ptrs)); + wine_session->composition_layer_count = frameEndInfo->layerCount; + } + + for (i = 0; i < frameEndInfo->layerCount; ++i) { + wine_session->composition_layer_ptrs[i] = convert_XrCompositionLayer( + wine_session, frameEndInfo->layers[i], &wine_session->composition_layers[i], &view_idx, &view_info_idx); + } + + our_frameEndInfo = *frameEndInfo; + our_frameEndInfo.layers = (const XrCompositionLayerBaseHeader *const *)wine_session->composition_layer_ptrs; + + if ((dxvk_device = wine_session->instance->dxvk_device)) { + TRACE("Locking submission queue.\n"); + dxvk_device->lpVtbl->FlushRenderingCommands(dxvk_device); + dxvk_device->lpVtbl->LockSubmissionQueue(dxvk_device); + } else if ((d3d12_device = wine_session->instance->d3d12_device)) { + TRACE("Locking vkd3d-proton submission queue.\n"); + d3d12_device->lpVtbl->LockCommandQueue(d3d12_device, wine_session->instance->d3d12_queue); + } + + _status = UNIX_CALL(xrEndFrame, ¶ms); + assert(!_status && "xrEndFrame"); + + if (dxvk_device) { + dxvk_device->lpVtbl->ReleaseSubmissionQueue(dxvk_device); + } else if (d3d12_device) { + d3d12_device->lpVtbl->UnlockCommandQueue(d3d12_device, wine_session->instance->d3d12_queue); + } + + return params.result; +} + +XrResult WINAPI xrConvertTimeToWin32PerformanceCounterKHR(XrInstance instance, + XrTime time, + LARGE_INTEGER *performanceCounter) { + FIXME("unimplemented\n"); + /* FIXME */ + return XR_ERROR_INITIALIZATION_FAILED; +} + +XrResult WINAPI xrConvertWin32PerformanceCounterToTimeKHR(XrInstance instance, + const LARGE_INTEGER *performanceCounter, + XrTime *time) { + FIXME("unimplemented\n"); + /* FIXME */ + return XR_ERROR_INITIALIZATION_FAILED; +} + +XrResult WINAPI xrGetD3D11GraphicsRequirementsKHR(XrInstance instance, + XrSystemId systemId, + XrGraphicsRequirementsD3D11KHR *graphicsRequirements) { + IDXGIFactory1 *factory; + IDXGIAdapter *adapter; + DXGI_ADAPTER_DESC adapter_desc; + HRESULT hr; + DWORD i; + + TRACE("\n"); + + hr = CreateDXGIFactory1(&IID_IDXGIFactory1, (void **)&factory); + if (FAILED(hr)) { + WARN("CreateDXGIFactory1 failed: %08x\n", hr); + return XR_ERROR_INITIALIZATION_FAILED; + } + + i = 0; + while ((hr = IDXGIFactory1_EnumAdapters(factory, i++, &adapter)) == S_OK) { + hr = IDXGIAdapter_GetDesc(adapter, &adapter_desc); + if (FAILED(hr)) { + WARN("GetDesc failed: %08x\n", hr); + IDXGIAdapter_Release(adapter); + continue; + } + + IDXGIAdapter_Release(adapter); + + /* FIXME: what if we have two of the same adapters? */ + if (adapter_desc.VendorId == g_physdev_vid && adapter_desc.DeviceId == g_physdev_pid) { + TRACE("Found DXGI adapter for %#04x:%#04x\n", g_physdev_vid, g_physdev_pid); + break; + } + } + + if (hr == S_OK) { + graphicsRequirements->adapterLuid = adapter_desc.AdapterLuid; + } else { + WARN("Couldn't find matching DXGI adapter for given VkPhysicalDevice! Choosing first one...\n"); + + hr = IDXGIFactory1_EnumAdapters(factory, 0, &adapter); + if (FAILED(hr)) { + WARN("EnumAdapters(0) failed: %08x\n", hr); + IDXGIFactory1_Release(factory); + return XR_ERROR_INITIALIZATION_FAILED; + } + + hr = IDXGIAdapter_GetDesc(adapter, &adapter_desc); + if (FAILED(hr)) { + WARN("GetDesc(0) failed: %08x\n", hr); + IDXGIAdapter_Release(adapter); + IDXGIFactory1_Release(factory); + return XR_ERROR_INITIALIZATION_FAILED; + } + + IDXGIAdapter_Release(adapter); + + graphicsRequirements->adapterLuid = adapter_desc.AdapterLuid; + } + + IDXGIFactory1_Release(factory); + + /* XXX */ + graphicsRequirements->minFeatureLevel = D3D_FEATURE_LEVEL_10_0; + + return XR_SUCCESS; +} + +XrResult WINAPI xrGetD3D12GraphicsRequirementsKHR(XrInstance instance, + XrSystemId systemId, + XrGraphicsRequirementsD3D12KHR *graphicsRequirements) { + XrGraphicsRequirementsD3D11KHR requirements; + XrResult result = xrGetD3D11GraphicsRequirementsKHR(instance, systemId, &requirements); + if (result != XR_SUCCESS) { + return result; + } + graphicsRequirements->adapterLuid = requirements.adapterLuid; + graphicsRequirements->minFeatureLevel = D3D_FEATURE_LEVEL_11_0; + return XR_SUCCESS; +} + +XrResult WINAPI xrCreateApiLayerInstance(const XrInstanceCreateInfo *info, + const XrApiLayerCreateInfo *layerInfo, + XrInstance *instance) { + TRACE("%p, %p, %p\n", info, layerInfo, instance); + + return xrCreateInstance(info, instance); +} + +XrResult WINAPI xrCreateVulkanInstanceKHR(XrInstance instance, + const XrVulkanInstanceCreateInfoKHR *createInfo, + VkInstance *vulkanInstance, + VkResult *vulkanResult) { + struct vk_create_callback_context context; + VkCreateInfoWineInstanceCallback callback; + VkInstanceCreateInfo vulkan_create_info; + + TRACE("instance %p, createInfo %p, vulkanInstance %p, vulkanResult %p.\n", instance, createInfo, vulkanInstance, + vulkanResult); + + if (createInfo->createFlags) { + WARN("Unexpected flags %#lx.\n", (long)createInfo->createFlags); + } + + context.wine_instance = instance; + context.create_info = (UINT64)createInfo; + + vulkan_create_info = *createInfo->vulkanCreateInfo; + callback.sType = VK_STRUCTURE_TYPE_CREATE_INFO_WINE_INSTANCE_CALLBACK; + callback.native_create_callback = (PFN_native_vkCreateInstance)g_vk_create_instance_callback; + callback.context = &context; + callback.pNext = vulkan_create_info.pNext; + vulkan_create_info.pNext = &callback; + + *vulkanResult = vkCreateInstance(&vulkan_create_info, createInfo->vulkanAllocator, vulkanInstance); + + if (context.ret == XR_SUCCESS && *vulkanResult != VK_SUCCESS) { + WARN("winevulkan instance creation failed after native xrCreateVulkanInstanceKHR() success.\n"); + } + + TRACE("result %d, vk result %d.\n", context.ret, *vulkanResult); + return context.ret; +} + +XrResult WINAPI xrCreateVulkanDeviceKHR(XrInstance instance, + const XrVulkanDeviceCreateInfoKHR *createInfo, + VkDevice *vulkanDevice, + VkResult *vulkanResult) { + struct vk_create_callback_context context; + VkCreateInfoWineDeviceCallback callback; + VkDeviceCreateInfo vulkan_create_info; + + TRACE("instance %p, createInfo %p, vulkanDevice %p, vulkanResult %p.\n", instance, createInfo, vulkanDevice, + vulkanResult); + + if (createInfo->createFlags) { + WARN("Unexpected flags %#lx.\n", (long)createInfo->createFlags); + } + + context.wine_instance = instance; + context.create_info = (UINT64)createInfo; + + vulkan_create_info = *createInfo->vulkanCreateInfo; + callback.sType = VK_STRUCTURE_TYPE_CREATE_INFO_WINE_DEVICE_CALLBACK; + callback.native_create_callback = (PFN_native_vkCreateDevice)g_vk_create_device_callback; + callback.context = &context; + callback.pNext = vulkan_create_info.pNext; + vulkan_create_info.pNext = &callback; + + *vulkanResult = + vkCreateDevice(createInfo->vulkanPhysicalDevice, &vulkan_create_info, createInfo->vulkanAllocator, vulkanDevice); + + if (context.ret == XR_SUCCESS && *vulkanResult != VK_SUCCESS) { + WARN("winevulkan instance creation failed after native xrCreateVulkanInstanceKHR() success.\n"); + } + + TRACE("result %d, vk result %d.\n", context.ret, *vulkanResult); + return context.ret; +} + +XrResult WINAPI xrGetInstanceProcAddr(XrInstance instance, const char *fn_name, PFN_xrVoidFunction *out_fn) { + TRACE("%s\n", fn_name); + + *out_fn = wine_xr_get_instance_proc_addr(fn_name); + if (!*out_fn) { + WARN("Unable to find requested function: %s\n", fn_name); + return XR_ERROR_FUNCTION_UNSUPPORTED; + } + + return XR_SUCCESS; +} + +XrResult WINAPI xrNegotiateLoaderRuntimeInterface(const XrNegotiateLoaderInfo *info, + XrNegotiateRuntimeRequest *request) { + const XrNegotiateLoaderInfo *loaderInfo = (const XrNegotiateLoaderInfo *)info; + XrNegotiateRuntimeRequest *runtimeRequest = (XrNegotiateRuntimeRequest *)request; + XrResult res; + + TRACE("%p %p\n", loaderInfo, runtimeRequest); + + if (!loaderInfo || !runtimeRequest) { + return XR_ERROR_INITIALIZATION_FAILED; + } + + if ((res = wine_openxr_init_once()) != XR_SUCCESS) { + TRACE("could not initialize openxr: %d\n", res); + return res; + } + + if (loaderInfo->structType != XR_LOADER_INTERFACE_STRUCT_LOADER_INFO || + loaderInfo->structVersion != XR_LOADER_INFO_STRUCT_VERSION || + loaderInfo->structSize != sizeof(XrNegotiateLoaderInfo)) { + return XR_ERROR_VALIDATION_FAILURE; + } + + if (loaderInfo->minInterfaceVersion > XR_CURRENT_LOADER_RUNTIME_VERSION || + loaderInfo->maxInterfaceVersion < XR_CURRENT_LOADER_RUNTIME_VERSION) { + return XR_ERROR_VALIDATION_FAILURE; + } + + if (runtimeRequest->structType != XR_LOADER_INTERFACE_STRUCT_RUNTIME_REQUEST || + runtimeRequest->structVersion != XR_RUNTIME_INFO_STRUCT_VERSION || + runtimeRequest->structSize != sizeof(XrNegotiateRuntimeRequest)) { + return XR_ERROR_VALIDATION_FAILURE; + } + + runtimeRequest->runtimeInterfaceVersion = XR_CURRENT_LOADER_RUNTIME_VERSION; + runtimeRequest->getInstanceProcAddr = (PFN_xrGetInstanceProcAddr)&xrGetInstanceProcAddr; + runtimeRequest->runtimeApiVersion = api_version; + + return XR_SUCCESS; +} + +/* wineopenxr API */ +XrResult WINAPI __wineopenxr_GetVulkanInstanceExtensions(uint32_t buflen, uint32_t *outlen, char *buf) { + XrResult res; + + TRACE("\n"); + + if ((res = wine_openxr_init_once()) != XR_SUCCESS) { + TRACE("could not initialize openxr: %d\n", res); + return res; + } + + if (buflen < strlen(g_instance_extensions) + 1 || !buf) { + *outlen = strlen(g_instance_extensions) + 1; + return XR_SUCCESS; + } + + *outlen = strlen(g_instance_extensions) + 1; + strcpy(buf, g_instance_extensions); + + return XR_SUCCESS; +} + +/* wineopenxr API */ +XrResult WINAPI __wineopenxr_GetVulkanDeviceExtensions(uint32_t buflen, uint32_t *outlen, char *buf) { + XrResult res; + + TRACE("\n"); + + if ((res = wine_openxr_init_once()) != XR_SUCCESS) { + TRACE("could not initialize openxr: %d\n", res); + return res; + } + + if (buflen < strlen(WINE_VULKAN_DEVICE_EXTENSION_NAME) + 1 || !buf) { + *outlen = strlen(WINE_VULKAN_DEVICE_EXTENSION_NAME) + 1; + return XR_SUCCESS; + } + + TRACE("g_device_extensions %s.\n", g_device_extensions); + __wine_set_unix_env(WINE_VULKAN_DEVICE_VARIABLE, g_device_extensions); + *outlen = strlen(WINE_VULKAN_DEVICE_EXTENSION_NAME) + 1; + strcpy(buf, WINE_VULKAN_DEVICE_EXTENSION_NAME); + + return XR_SUCCESS; +} + +BOOL CDECL wineopenxr_init_registry(void) +{ + char *xr_inst_ext, *xr_dev_ext; + uint32_t vid, pid; + LSTATUS status; + HKEY vr_key; + + if ((status = RegOpenKeyExA( HKEY_CURRENT_USER, "Software\\Wine\\VR", 0, KEY_ALL_ACCESS, &vr_key ))) + { + WARN( "Could not open key, status %#x.\n", status ); + return FALSE; + } + + if (!get_extensions( &xr_inst_ext, &xr_dev_ext, &vid, &pid )) + { + TRACE( "Got XR extensions.\n" ); + if ((status = RegSetValueExA( vr_key, "openxr_vulkan_instance_extensions", 0, REG_SZ, + (BYTE *)xr_inst_ext, strlen( xr_inst_ext ) + 1 ))) + ERR( "Could not set openxr_vulkan_instance_extensions value, status %#x.\n", status ); + if ((status = RegSetValueExA( vr_key, "openxr_vulkan_device_extensions", 0, REG_SZ, + (BYTE *)xr_dev_ext, strlen( xr_dev_ext ) + 1 ))) + ERR( "Could not set openxr_vulkan_device_extensions value, status %#x.\n", status ); + if ((status = RegSetValueExA( vr_key, "openxr_vulkan_device_vid", 0, REG_DWORD, + (BYTE *)&vid, sizeof(vid) ))) + ERR( "Could not set openxr_vulkan_device_vid value, status %#x.\n", status ); + if ((status = RegSetValueExA( vr_key, "openxr_vulkan_device_pid", 0, REG_DWORD, + (BYTE *)&pid, sizeof(pid) ))) + ERR( "Could not set openxr_vulkan_device_pid value, status %#x.\n", status ); + } + + TRACE( "Initialized OpenXR registry entries\n" ); + RegCloseKey( vr_key ); + return TRUE; +} diff --git a/wineopenxr/openxr_loader.h b/wineopenxr/openxr_loader.h new file mode 100644 index 00000000..7b5c720d --- /dev/null +++ b/wineopenxr/openxr_loader.h @@ -0,0 +1,119 @@ +#ifndef __WINE_OPENXR_LOADER_H +#define __WINE_OPENXR_LOADER_H + +#include +#include + +#define COBJMACROS +#include "ntstatus.h" +#define WIN32_NO_STATUS +#include +#include +#include +#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 */ diff --git a/wineopenxr/openxr_private.h b/wineopenxr/openxr_private.h index 8cfada59..647b7083 100644 --- a/wineopenxr/openxr_private.h +++ b/wineopenxr/openxr_private.h @@ -1,117 +1,59 @@ +#ifndef __WINE_OPENXR_PRIVATE_H +#define __WINE_OPENXR_PRIVATE_H + +#define WINE_XR_HOST + +#include +#include + +#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 -#define SESSION_TYPE_OPENGL 2 -#define SESSION_TYPE_D3D11 3 -#define SESSION_TYPE_D3D12 4 - -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; +struct conversion_context { + char buffer[2048]; + uint32_t used; + struct list alloc_entries; }; -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, - 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); +static inline void free_conversion_context(struct conversion_context *pool) { + struct list *entry, *next; + LIST_FOR_EACH_SAFE(entry, next, &pool->alloc_entries) + free(entry); +} -extern VkDevice (*get_native_VkDevice)(VkDevice); -extern VkInstance (*get_native_VkInstance)(VkInstance); -extern VkPhysicalDevice (*get_native_VkPhysicalDevice)(VkPhysicalDevice); -extern VkPhysicalDevice (*get_wrapped_VkPhysicalDevice)(VkInstance, VkPhysicalDevice); -extern VkQueue (*get_native_VkQueue)(VkQueue); -extern XrResult load_host_openxr_loader(void); +static inline void *conversion_context_alloc(struct conversion_context *pool, size_t size) { + if (pool->used + size <= sizeof(pool->buffer)) { + void *ret = pool->buffer + pool->used; + pool->used += (size + sizeof(UINT64) - 1) & ~(sizeof(UINT64) - 1); + return ret; + } 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 */ diff --git a/wineopenxr/openxr_thunks.c b/wineopenxr/openxr_thunks.c index 06590fc3..49acc229 100644 --- a/wineopenxr/openxr_thunks.c +++ b/wineopenxr/openxr_thunks.c @@ -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. @@ -19,2713 +19,3171 @@ * */ -#include "wine/debug.h" -#include "wine/vulkan.h" -#include "d3d11.h" -#include "d3d12.h" -#define WINE_XR_HOST -#include "wineopenxr.h" +#if 0 +#pragma makedep unix +#endif + +#include "config.h" + +#include + #include "openxr_private.h" WINE_DEFAULT_DEBUG_CHANNEL(openxr); -#if defined(USE_STRUCT_CONVERSION) -static inline void convert_XrKeyboardSpaceCreateInfoFB_win_to_host(const XrKeyboardSpaceCreateInfoFB *in, XrKeyboardSpaceCreateInfoFB_host *out) +#ifdef _WIN64 +static inline void convert_XrInstanceCreateInfo_win64_to_host(struct conversion_context *ctx, const XrInstanceCreateInfo *in, XrInstanceCreateInfo *out) { - if (!in) return; - - out->type = in->type; - out->next = in->next; - out->trackedKeyboardId = in->trackedKeyboardId; -} - -static inline void convert_XrMarkerSpaceCreateInfoVARJO_win_to_host(const XrMarkerSpaceCreateInfoVARJO *in, XrMarkerSpaceCreateInfoVARJO_host *out) -{ - if (!in) return; - - out->type = in->type; - out->next = in->next; - out->markerId = in->markerId; - out->poseInMarkerSpace = in->poseInMarkerSpace; -} - -static inline XrPlaneDetectorLocationEXT_host *convert_XrPlaneDetectorLocationEXT_array_win_to_host(const XrPlaneDetectorLocationEXT *in, uint32_t count) -{ - XrPlaneDetectorLocationEXT_host *out; - unsigned int i; - - if (!in) return NULL; - - out = HeapAlloc(GetProcessHeap(), 0, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - out[i].type = in[i].type; - out[i].next = in[i].next; - out[i].planeId = in[i].planeId; - out[i].locationFlags = in[i].locationFlags; - out[i].pose = in[i].pose; - out[i].extents = in[i].extents; - out[i].orientation = in[i].orientation; - out[i].semanticType = in[i].semanticType; - out[i].polygonBufferCount = in[i].polygonBufferCount; - } - - return out; -} - -static inline void free_XrPlaneDetectorLocationEXT_array(XrPlaneDetectorLocationEXT_host *in, uint32_t count) -{ - if (!in) return; - - HeapFree(GetProcessHeap(), 0, in); -} - -static inline void convert_XrPlaneDetectorLocationsEXT_win_to_host(const XrPlaneDetectorLocationsEXT *in, XrPlaneDetectorLocationsEXT_host *out) -{ - if (!in) return; - - out->type = in->type; - out->next = in->next; - out->planeLocationCapacityInput = in->planeLocationCapacityInput; - out->planeLocationCountOutput = in->planeLocationCountOutput; - out->planeLocations = convert_XrPlaneDetectorLocationEXT_array_win_to_host(in->planeLocations, in->planeLocationCapacityInput); -} - -static inline void free_XrPlaneDetectorLocationsEXT(XrPlaneDetectorLocationsEXT_host *in) -{ - free_XrPlaneDetectorLocationEXT_array(in->planeLocations, in->planeLocationCapacityInput); -} - -static inline void convert_XrSceneMeshBuffersGetInfoMSFT_win_to_host(const XrSceneMeshBuffersGetInfoMSFT *in, XrSceneMeshBuffersGetInfoMSFT_host *out) -{ - if (!in) return; - - out->type = in->type; - out->next = in->next; - out->meshBufferId = in->meshBufferId; -} - -static inline void convert_XrKeyboardTrackingDescriptionFB_host_to_win(const XrKeyboardTrackingDescriptionFB_host *in, XrKeyboardTrackingDescriptionFB *out) -{ - if (!in) return; - - out->trackedKeyboardId = in->trackedKeyboardId; - out->size = in->size; - out->flags = in->flags; - memcpy(out->name, in->name, XR_MAX_KEYBOARD_TRACKING_NAME_SIZE_FB * sizeof(char)); -} - -#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; + XrBaseOutStructure *out_header = (void *)out; - out_header->next = NULL; + if (!in) return; - for (in_header = next; in_header; in_header = in_header->next) + out->type = in->type; + out->next = NULL; + out->createFlags = in->createFlags; + out->applicationInfo = in->applicationInfo; + out->enabledApiLayerCount = in->enabledApiLayerCount; + out->enabledApiLayerNames = in->enabledApiLayerNames; + out->enabledExtensionCount = in->enabledExtensionCount; + out->enabledExtensionNames = in->enabledExtensionNames; + + for (in_header = (void *)in->next; in_header; in_header = (void *)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); + if ((in_header->type >> 16) == 0x7ead) + { + XrBaseOutStructure *out_ext = conversion_context_alloc(ctx, 32); + memcpy(out_ext, in_header, 32); + out_ext->next = NULL; + out_header->next = (void *)out_ext; + out_header = (void *)out_ext; + } + else + { + FIXME("Unhandled type %u.\n", in_header->type); + } + break; } } +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrAcquireEnvironmentDepthImageMETA(void *args) +{ + struct xrAcquireEnvironmentDepthImageMETA_params *params = args; - return XR_SUCCESS; + TRACE("%p, %p, %p\n", params->environmentDepthProvider, params->acquireInfo, params->environmentDepthImage); + + params->result = g_xr_host_instance_dispatch_table.p_xrAcquireEnvironmentDepthImageMETA(params->environmentDepthProvider, params->acquireInfo, params->environmentDepthImage); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -void free_XrInstanceCreateInfo_struct_chain(XrInstanceCreateInfo *s) +#ifdef _WIN64 +static NTSTATUS thunk64_xrAcquireSwapchainImage(void *args) { - XrBaseOutStructure *header = (void *)s->next; + struct xrAcquireSwapchainImage_params *params = args; - while (header) - { - void *prev = header; - header = header->next; - HeapFree(GetProcessHeap(), 0, prev); - } + TRACE("%p, %p, %p\n", params->swapchain, params->acquireInfo, params->index); - s->next = NULL; + params->result = g_xr_host_instance_dispatch_table.p_xrAcquireSwapchainImage(wine_swapchain_from_handle(params->swapchain)->host_swapchain, params->acquireInfo, params->index); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrAcquireEnvironmentDepthImageMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider, const XrEnvironmentDepthImageAcquireInfoMETA *acquireInfo, XrEnvironmentDepthImageMETA *environmentDepthImage) +#ifdef _WIN64 +static NTSTATUS thunk64_xrApplyForceFeedbackCurlMNDX(void *args) { - XrResult ret; + struct xrApplyForceFeedbackCurlMNDX_params *params = args; + + TRACE("%p, %p\n", params->handTracker, params->locations); - WINE_TRACE("%p, %p, %p\n", environmentDepthProvider, acquireInfo, environmentDepthImage); - ret = (*get_dispatch_table((uint64_t)(environmentDepthProvider))).p_xrAcquireEnvironmentDepthImageMETA(environmentDepthProvider, acquireInfo, environmentDepthImage); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrApplyForceFeedbackCurlMNDX(params->handTracker, params->locations); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrApplyForceFeedbackCurlMNDX(XrHandTrackerEXT handTracker, const XrForceFeedbackCurlApplyLocationsMNDX *locations) +#ifdef _WIN64 +static NTSTATUS thunk64_xrApplyHapticFeedback(void *args) { - XrResult ret; + struct xrApplyHapticFeedback_params *params = args; - WINE_TRACE("%p, %p\n", handTracker, locations); - ret = (*get_dispatch_table((uint64_t)(handTracker))).p_xrApplyForceFeedbackCurlMNDX(handTracker, locations); - return ret; + TRACE("%p, %p, %p\n", params->session, params->hapticActionInfo, params->hapticFeedback); + + params->result = g_xr_host_instance_dispatch_table.p_xrApplyHapticFeedback(wine_session_from_handle(params->session)->host_session, params->hapticActionInfo, params->hapticFeedback); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrApplyFoveationHTC(XrSession session, const XrFoveationApplyInfoHTC *applyInfo) +#ifdef _WIN64 +static NTSTATUS thunk64_xrAttachSessionActionSets(void *args) { - XrResult ret; + struct xrAttachSessionActionSets_params *params = args; + + TRACE("%p, %p\n", params->session, params->attachInfo); - WINE_TRACE("%p, %p\n", session, applyInfo); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrApplyFoveationHTC(((wine_XrSession *)session)->session, applyInfo); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrAttachSessionActionSets(wine_session_from_handle(params->session)->host_session, params->attachInfo); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrApplyHapticFeedback(XrSession session, const XrHapticActionInfo *hapticActionInfo, const XrHapticBaseHeader *hapticFeedback) +#ifdef _WIN64 +static NTSTATUS thunk64_xrBeginFrame(void *args) { - XrResult ret; + struct xrBeginFrame_params *params = args; + + TRACE("%p, %p\n", params->session, params->frameBeginInfo); - WINE_TRACE("%p, %p, %p\n", session, hapticActionInfo, hapticFeedback); - ret = xrApplyHapticFeedback(((wine_XrSession *)session)->session, hapticActionInfo, hapticFeedback); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrBeginFrame(wine_session_from_handle(params->session)->host_session, params->frameBeginInfo); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrAttachSessionActionSets(XrSession session, const XrSessionActionSetsAttachInfo *attachInfo) +#ifdef _WIN64 +static NTSTATUS thunk64_xrBeginPlaneDetectionEXT(void *args) { - XrResult ret; + struct xrBeginPlaneDetectionEXT_params *params = args; - WINE_TRACE("%p, %p\n", session, attachInfo); - ret = xrAttachSessionActionSets(((wine_XrSession *)session)->session, attachInfo); - return ret; + TRACE("%p, %p\n", params->planeDetector, params->beginInfo); + + params->result = g_xr_host_instance_dispatch_table.p_xrBeginPlaneDetectionEXT(params->planeDetector, params->beginInfo); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrBeginPlaneDetectionEXT(XrPlaneDetectorEXT planeDetector, const XrPlaneDetectorBeginInfoEXT *beginInfo) +#ifdef _WIN64 +static NTSTATUS thunk64_xrBeginSession(void *args) { - XrResult ret; + struct xrBeginSession_params *params = args; + + TRACE("%p, %p\n", params->session, params->beginInfo); - WINE_TRACE("%p, %p\n", planeDetector, beginInfo); - ret = (*get_dispatch_table((uint64_t)(planeDetector))).p_xrBeginPlaneDetectionEXT(planeDetector, beginInfo); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrBeginSession(wine_session_from_handle(params->session)->host_session, params->beginInfo); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrBeginSession(XrSession session, const XrSessionBeginInfo *beginInfo) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCancelFutureEXT(void *args) { - XrResult ret; + struct xrCancelFutureEXT_params *params = args; - WINE_TRACE("%p, %p\n", session, beginInfo); - ret = xrBeginSession(((wine_XrSession *)session)->session, beginInfo); - return ret; + TRACE("%p, %p\n", params->instance, params->cancelInfo); + + params->result = g_xr_host_instance_dispatch_table.p_xrCancelFutureEXT(wine_instance_from_handle(params->instance)->host_instance, params->cancelInfo); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCancelFutureEXT(XrInstance instance, const XrFutureCancelInfoEXT *cancelInfo) +#ifdef _WIN64 +static NTSTATUS thunk64_xrChangeVirtualKeyboardTextContextMETA(void *args) { - XrResult ret; + struct xrChangeVirtualKeyboardTextContextMETA_params *params = args; + + TRACE("%p, %p\n", params->keyboard, params->changeInfo); - WINE_TRACE("%p, %p\n", instance, cancelInfo); - ret = ((wine_XrInstance *)instance)->funcs.p_xrCancelFutureEXT(((wine_XrInstance *)instance)->instance, cancelInfo); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrChangeVirtualKeyboardTextContextMETA(params->keyboard, params->changeInfo); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrChangeVirtualKeyboardTextContextMETA(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardTextContextChangeInfoMETA *changeInfo) +#ifdef _WIN64 +static NTSTATUS thunk64_xrClearSpatialAnchorStoreMSFT(void *args) { - XrResult ret; + struct xrClearSpatialAnchorStoreMSFT_params *params = args; + + TRACE("%p\n", params->spatialAnchorStore); - WINE_TRACE("%p, %p\n", keyboard, changeInfo); - ret = (*get_dispatch_table((uint64_t)(keyboard))).p_xrChangeVirtualKeyboardTextContextMETA(keyboard, changeInfo); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrClearSpatialAnchorStoreMSFT(params->spatialAnchorStore); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrClearSpatialAnchorStoreMSFT(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore) +#ifdef _WIN64 +static NTSTATUS thunk64_xrComputeNewSceneMSFT(void *args) { - XrResult ret; + struct xrComputeNewSceneMSFT_params *params = args; - WINE_TRACE("%p\n", spatialAnchorStore); - ret = (*get_dispatch_table((uint64_t)(spatialAnchorStore))).p_xrClearSpatialAnchorStoreMSFT(spatialAnchorStore); - return ret; + TRACE("%p, %p\n", params->sceneObserver, params->computeInfo); + + params->result = g_xr_host_instance_dispatch_table.p_xrComputeNewSceneMSFT(params->sceneObserver, params->computeInfo); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrComputeNewSceneMSFT(XrSceneObserverMSFT sceneObserver, const XrNewSceneComputeInfoMSFT *computeInfo) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateAction(void *args) { - XrResult ret; + struct xrCreateAction_params *params = args; + + TRACE("%p, %p, %p\n", params->actionSet, params->createInfo, params->action); - WINE_TRACE("%p, %p\n", sceneObserver, computeInfo); - ret = (*get_dispatch_table((uint64_t)(sceneObserver))).p_xrComputeNewSceneMSFT(sceneObserver, computeInfo); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreateAction(params->actionSet, params->createInfo, params->action); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrCreateAction(XrActionSet actionSet, const XrActionCreateInfo *createInfo, XrAction *action) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateActionSet(void *args) { - XrResult ret; + struct xrCreateActionSet_params *params = args; - WINE_TRACE("%p, %p, %p\n", actionSet, createInfo, action); - ret = xrCreateAction(actionSet, createInfo, action); - return ret; + TRACE("%p, %p, %p\n", params->instance, params->createInfo, params->actionSet); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateActionSet(wine_instance_from_handle(params->instance)->host_instance, params->createInfo, params->actionSet); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrCreateActionSet(XrInstance instance, const XrActionSetCreateInfo *createInfo, XrActionSet *actionSet) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateActionSpace(void *args) { - XrResult ret; + struct xrCreateActionSpace_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->space); - WINE_TRACE("%p, %p, %p\n", instance, createInfo, actionSet); - ret = xrCreateActionSet(((wine_XrInstance *)instance)->instance, createInfo, actionSet); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreateActionSpace(wine_session_from_handle(params->session)->host_session, params->createInfo, params->space); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrCreateActionSpace(XrSession session, const XrActionSpaceCreateInfo *createInfo, XrSpace *space) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateBodyTrackerFB(void *args) { - XrResult ret; + struct xrCreateBodyTrackerFB_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->bodyTracker); - WINE_TRACE("%p, %p, %p\n", session, createInfo, space); - ret = xrCreateActionSpace(((wine_XrSession *)session)->session, createInfo, space); - if (!ret) register_dispatchable_handle((uint64_t)*space, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreateBodyTrackerFB(wine_session_from_handle(params->session)->host_session, params->createInfo, params->bodyTracker); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateBodyTrackerFB(XrSession session, const XrBodyTrackerCreateInfoFB *createInfo, XrBodyTrackerFB *bodyTracker) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateEnvironmentDepthProviderMETA(void *args) { - XrResult ret; + struct xrCreateEnvironmentDepthProviderMETA_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, createInfo, bodyTracker); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateBodyTrackerFB(((wine_XrSession *)session)->session, createInfo, bodyTracker); - if (!ret) register_dispatchable_handle((uint64_t)*bodyTracker, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->environmentDepthProvider); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateEnvironmentDepthProviderMETA(wine_session_from_handle(params->session)->host_session, params->createInfo, params->environmentDepthProvider); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateEnvironmentDepthProviderMETA(XrSession session, const XrEnvironmentDepthProviderCreateInfoMETA *createInfo, XrEnvironmentDepthProviderMETA *environmentDepthProvider) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateEnvironmentDepthSwapchainMETA(void *args) { - XrResult ret; + struct xrCreateEnvironmentDepthSwapchainMETA_params *params = args; + + TRACE("%p, %p, %p\n", params->environmentDepthProvider, params->createInfo, params->swapchain); - WINE_TRACE("%p, %p, %p\n", session, createInfo, environmentDepthProvider); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateEnvironmentDepthProviderMETA(((wine_XrSession *)session)->session, createInfo, environmentDepthProvider); - if (!ret) register_dispatchable_handle((uint64_t)*environmentDepthProvider, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreateEnvironmentDepthSwapchainMETA(params->environmentDepthProvider, params->createInfo, params->swapchain); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateEnvironmentDepthSwapchainMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider, const XrEnvironmentDepthSwapchainCreateInfoMETA *createInfo, XrEnvironmentDepthSwapchainMETA *swapchain) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateExportedLocalizationMapML(void *args) { - XrResult ret; + struct xrCreateExportedLocalizationMapML_params *params = args; - WINE_TRACE("%p, %p, %p\n", environmentDepthProvider, createInfo, swapchain); - ret = (*get_dispatch_table((uint64_t)(environmentDepthProvider))).p_xrCreateEnvironmentDepthSwapchainMETA(environmentDepthProvider, createInfo, swapchain); - if (!ret) register_dispatchable_handle((uint64_t)*swapchain, &((*get_dispatch_table((uint64_t)(environmentDepthProvider))))); - return ret; + TRACE("%p, %p, %p\n", params->session, params->mapUuid, params->map); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateExportedLocalizationMapML(wine_session_from_handle(params->session)->host_session, params->mapUuid, params->map); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateExportedLocalizationMapML(XrSession session, const XrUuidEXT *mapUuid, XrExportedLocalizationMapML *map) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateEyeTrackerFB(void *args) { - XrResult ret; + struct xrCreateEyeTrackerFB_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->eyeTracker); - WINE_TRACE("%p, %p, %p\n", session, mapUuid, map); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateExportedLocalizationMapML(((wine_XrSession *)session)->session, mapUuid, map); - if (!ret) register_dispatchable_handle((uint64_t)*map, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreateEyeTrackerFB(wine_session_from_handle(params->session)->host_session, params->createInfo, params->eyeTracker); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateEyeTrackerFB(XrSession session, const XrEyeTrackerCreateInfoFB *createInfo, XrEyeTrackerFB *eyeTracker) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateFaceTracker2FB(void *args) { - XrResult ret; + struct xrCreateFaceTracker2FB_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->faceTracker); - WINE_TRACE("%p, %p, %p\n", session, createInfo, eyeTracker); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateEyeTrackerFB(((wine_XrSession *)session)->session, createInfo, eyeTracker); - if (!ret) register_dispatchable_handle((uint64_t)*eyeTracker, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreateFaceTracker2FB(wine_session_from_handle(params->session)->host_session, params->createInfo, params->faceTracker); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateFaceTracker2FB(XrSession session, const XrFaceTrackerCreateInfo2FB *createInfo, XrFaceTracker2FB *faceTracker) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateFaceTrackerFB(void *args) { - XrResult ret; + struct xrCreateFaceTrackerFB_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, createInfo, faceTracker); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateFaceTracker2FB(((wine_XrSession *)session)->session, createInfo, faceTracker); - if (!ret) register_dispatchable_handle((uint64_t)*faceTracker, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->faceTracker); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateFaceTrackerFB(wine_session_from_handle(params->session)->host_session, params->createInfo, params->faceTracker); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateFaceTrackerFB(XrSession session, const XrFaceTrackerCreateInfoFB *createInfo, XrFaceTrackerFB *faceTracker) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateFacialTrackerHTC(void *args) { - XrResult ret; + struct xrCreateFacialTrackerHTC_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->facialTracker); - WINE_TRACE("%p, %p, %p\n", session, createInfo, faceTracker); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateFaceTrackerFB(((wine_XrSession *)session)->session, createInfo, faceTracker); - if (!ret) register_dispatchable_handle((uint64_t)*faceTracker, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreateFacialTrackerHTC(wine_session_from_handle(params->session)->host_session, params->createInfo, params->facialTracker); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateFacialTrackerHTC(XrSession session, const XrFacialTrackerCreateInfoHTC *createInfo, XrFacialTrackerHTC *facialTracker) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateFoveationProfileFB(void *args) { - XrResult ret; + struct xrCreateFoveationProfileFB_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, createInfo, facialTracker); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateFacialTrackerHTC(((wine_XrSession *)session)->session, createInfo, facialTracker); - if (!ret) register_dispatchable_handle((uint64_t)*facialTracker, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->profile); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateFoveationProfileFB(wine_session_from_handle(params->session)->host_session, params->createInfo, params->profile); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateFoveationProfileFB(XrSession session, const XrFoveationProfileCreateInfoFB *createInfo, XrFoveationProfileFB *profile) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateGeometryInstanceFB(void *args) { - XrResult ret; + struct xrCreateGeometryInstanceFB_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->outGeometryInstance); - WINE_TRACE("%p, %p, %p\n", session, createInfo, profile); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateFoveationProfileFB(((wine_XrSession *)session)->session, createInfo, profile); - if (!ret) register_dispatchable_handle((uint64_t)*profile, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreateGeometryInstanceFB(wine_session_from_handle(params->session)->host_session, params->createInfo, params->outGeometryInstance); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateGeometryInstanceFB(XrSession session, const XrGeometryInstanceCreateInfoFB *createInfo, XrGeometryInstanceFB *outGeometryInstance) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateHandMeshSpaceMSFT(void *args) { - XrResult ret; + struct xrCreateHandMeshSpaceMSFT_params *params = args; + + TRACE("%p, %p, %p\n", params->handTracker, params->createInfo, params->space); - WINE_TRACE("%p, %p, %p\n", session, createInfo, outGeometryInstance); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateGeometryInstanceFB(((wine_XrSession *)session)->session, createInfo, outGeometryInstance); - if (!ret) register_dispatchable_handle((uint64_t)*outGeometryInstance, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreateHandMeshSpaceMSFT(params->handTracker, params->createInfo, params->space); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateHandMeshSpaceMSFT(XrHandTrackerEXT handTracker, const XrHandMeshSpaceCreateInfoMSFT *createInfo, XrSpace *space) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateHandTrackerEXT(void *args) { - XrResult ret; + struct xrCreateHandTrackerEXT_params *params = args; - WINE_TRACE("%p, %p, %p\n", handTracker, createInfo, space); - ret = (*get_dispatch_table((uint64_t)(handTracker))).p_xrCreateHandMeshSpaceMSFT(handTracker, createInfo, space); - if (!ret) register_dispatchable_handle((uint64_t)*space, &((*get_dispatch_table((uint64_t)(handTracker))))); - return ret; + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->handTracker); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateHandTrackerEXT(wine_session_from_handle(params->session)->host_session, params->createInfo, params->handTracker); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateHandTrackerEXT(XrSession session, const XrHandTrackerCreateInfoEXT *createInfo, XrHandTrackerEXT *handTracker) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateInstance(void *args) { - XrResult ret; + struct xrCreateInstance_params *params = args; + XrInstanceCreateInfo createInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%p, %p\n", params->createInfo, params->instance); - WINE_TRACE("%p, %p, %p\n", session, createInfo, handTracker); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateHandTrackerEXT(((wine_XrSession *)session)->session, createInfo, handTracker); - if (!ret) register_dispatchable_handle((uint64_t)*handTracker, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + init_conversion_context(ctx); + convert_XrInstanceCreateInfo_win64_to_host(ctx, params->createInfo, &createInfo_host); + params->result = wine_xrCreateInstance(&createInfo_host, params->instance); + free_conversion_context(ctx); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateKeyboardSpaceFB(XrSession session, const XrKeyboardSpaceCreateInfoFB *createInfo, XrSpace *keyboardSpace) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateKeyboardSpaceFB(void *args) { -#if defined(USE_STRUCT_CONVERSION) - XrResult result; - XrKeyboardSpaceCreateInfoFB_host createInfo_host; - WINE_TRACE("%p, %p, %p\n", session, createInfo, keyboardSpace); + struct xrCreateKeyboardSpaceFB_params *params = args; - convert_XrKeyboardSpaceCreateInfoFB_win_to_host(createInfo, &createInfo_host); - result = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateKeyboardSpaceFB(((wine_XrSession *)session)->session, &createInfo_host, keyboardSpace); + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->keyboardSpace); - return result; -#else - XrResult ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreateKeyboardSpaceFB(wine_session_from_handle(params->session)->host_session, params->createInfo, params->keyboardSpace); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateMarkerDetectorML(void *args) +{ + struct xrCreateMarkerDetectorML_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, createInfo, keyboardSpace); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateKeyboardSpaceFB(((wine_XrSession *)session)->session, createInfo, keyboardSpace); - if (!ret) register_dispatchable_handle((uint64_t)*keyboardSpace, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; -#endif + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->markerDetector); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateMarkerDetectorML(wine_session_from_handle(params->session)->host_session, params->createInfo, params->markerDetector); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateMarkerDetectorML(XrSession session, const XrMarkerDetectorCreateInfoML *createInfo, XrMarkerDetectorML *markerDetector) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateMarkerSpaceML(void *args) { - XrResult ret; + struct xrCreateMarkerSpaceML_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->space); - WINE_TRACE("%p, %p, %p\n", session, createInfo, markerDetector); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateMarkerDetectorML(((wine_XrSession *)session)->session, createInfo, markerDetector); - if (!ret) register_dispatchable_handle((uint64_t)*markerDetector, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreateMarkerSpaceML(wine_session_from_handle(params->session)->host_session, params->createInfo, params->space); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateMarkerSpaceML(XrSession session, const XrMarkerSpaceCreateInfoML *createInfo, XrSpace *space) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateMarkerSpaceVARJO(void *args) { - XrResult ret; + struct xrCreateMarkerSpaceVARJO_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, createInfo, space); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateMarkerSpaceML(((wine_XrSession *)session)->session, createInfo, space); - if (!ret) register_dispatchable_handle((uint64_t)*space, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->space); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateMarkerSpaceVARJO(wine_session_from_handle(params->session)->host_session, params->createInfo, params->space); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateMarkerSpaceVARJO(XrSession session, const XrMarkerSpaceCreateInfoVARJO *createInfo, XrSpace *space) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreatePassthroughColorLutMETA(void *args) { -#if defined(USE_STRUCT_CONVERSION) - XrResult result; - XrMarkerSpaceCreateInfoVARJO_host createInfo_host; - WINE_TRACE("%p, %p, %p\n", session, createInfo, space); + struct xrCreatePassthroughColorLutMETA_params *params = args; + + TRACE("%p, %p, %p\n", params->passthrough, params->createInfo, params->colorLut); - convert_XrMarkerSpaceCreateInfoVARJO_win_to_host(createInfo, &createInfo_host); - result = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateMarkerSpaceVARJO(((wine_XrSession *)session)->session, &createInfo_host, space); + params->result = g_xr_host_instance_dispatch_table.p_xrCreatePassthroughColorLutMETA(params->passthrough, params->createInfo, params->colorLut); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreatePassthroughFB(void *args) +{ + struct xrCreatePassthroughFB_params *params = args; - return result; -#else - XrResult ret; + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->outPassthrough); - WINE_TRACE("%p, %p, %p\n", session, createInfo, space); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateMarkerSpaceVARJO(((wine_XrSession *)session)->session, createInfo, space); - if (!ret) register_dispatchable_handle((uint64_t)*space, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; -#endif + params->result = g_xr_host_instance_dispatch_table.p_xrCreatePassthroughFB(wine_session_from_handle(params->session)->host_session, params->createInfo, params->outPassthrough); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreatePassthroughColorLutMETA(XrPassthroughFB passthrough, const XrPassthroughColorLutCreateInfoMETA *createInfo, XrPassthroughColorLutMETA *colorLut) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreatePassthroughHTC(void *args) { - XrResult ret; + struct xrCreatePassthroughHTC_params *params = args; - WINE_TRACE("%p, %p, %p\n", passthrough, createInfo, colorLut); - ret = (*get_dispatch_table((uint64_t)(passthrough))).p_xrCreatePassthroughColorLutMETA(passthrough, createInfo, colorLut); - if (!ret) register_dispatchable_handle((uint64_t)*colorLut, &((*get_dispatch_table((uint64_t)(passthrough))))); - return ret; + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->passthrough); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreatePassthroughHTC(wine_session_from_handle(params->session)->host_session, params->createInfo, params->passthrough); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreatePassthroughFB(XrSession session, const XrPassthroughCreateInfoFB *createInfo, XrPassthroughFB *outPassthrough) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreatePassthroughLayerFB(void *args) { - XrResult ret; + struct xrCreatePassthroughLayerFB_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->outLayer); - WINE_TRACE("%p, %p, %p\n", session, createInfo, outPassthrough); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreatePassthroughFB(((wine_XrSession *)session)->session, createInfo, outPassthrough); - if (!ret) register_dispatchable_handle((uint64_t)*outPassthrough, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreatePassthroughLayerFB(wine_session_from_handle(params->session)->host_session, params->createInfo, params->outLayer); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreatePassthroughHTC(XrSession session, const XrPassthroughCreateInfoHTC *createInfo, XrPassthroughHTC *passthrough) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreatePlaneDetectorEXT(void *args) { - XrResult ret; + struct xrCreatePlaneDetectorEXT_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->planeDetector); - WINE_TRACE("%p, %p, %p\n", session, createInfo, passthrough); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreatePassthroughHTC(((wine_XrSession *)session)->session, createInfo, passthrough); - if (!ret) register_dispatchable_handle((uint64_t)*passthrough, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreatePlaneDetectorEXT(wine_session_from_handle(params->session)->host_session, params->createInfo, params->planeDetector); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreatePassthroughLayerFB(XrSession session, const XrPassthroughLayerCreateInfoFB *createInfo, XrPassthroughLayerFB *outLayer) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateReferenceSpace(void *args) { - XrResult ret; + struct xrCreateReferenceSpace_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, createInfo, outLayer); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreatePassthroughLayerFB(((wine_XrSession *)session)->session, createInfo, outLayer); - if (!ret) register_dispatchable_handle((uint64_t)*outLayer, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->space); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateReferenceSpace(wine_session_from_handle(params->session)->host_session, params->createInfo, params->space); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreatePlaneDetectorEXT(XrSession session, const XrPlaneDetectorCreateInfoEXT *createInfo, XrPlaneDetectorEXT *planeDetector) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSceneMSFT(void *args) { - XrResult ret; + struct xrCreateSceneMSFT_params *params = args; + + TRACE("%p, %p, %p\n", params->sceneObserver, params->createInfo, params->scene); - WINE_TRACE("%p, %p, %p\n", session, createInfo, planeDetector); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreatePlaneDetectorEXT(((wine_XrSession *)session)->session, createInfo, planeDetector); - if (!ret) register_dispatchable_handle((uint64_t)*planeDetector, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSceneMSFT(params->sceneObserver, params->createInfo, params->scene); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrCreateReferenceSpace(XrSession session, const XrReferenceSpaceCreateInfo *createInfo, XrSpace *space) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSceneObserverMSFT(void *args) { - XrResult ret; + struct xrCreateSceneObserverMSFT_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, createInfo, space); - ret = xrCreateReferenceSpace(((wine_XrSession *)session)->session, createInfo, space); - if (!ret) register_dispatchable_handle((uint64_t)*space, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->sceneObserver); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSceneObserverMSFT(wine_session_from_handle(params->session)->host_session, params->createInfo, params->sceneObserver); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateSceneMSFT(XrSceneObserverMSFT sceneObserver, const XrSceneCreateInfoMSFT *createInfo, XrSceneMSFT *scene) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSession(void *args) { - XrResult ret; + struct xrCreateSession_params *params = args; + + TRACE("%p, %p, %p\n", params->instance, params->createInfo, params->session); - WINE_TRACE("%p, %p, %p\n", sceneObserver, createInfo, scene); - ret = (*get_dispatch_table((uint64_t)(sceneObserver))).p_xrCreateSceneMSFT(sceneObserver, createInfo, scene); - if (!ret) register_dispatchable_handle((uint64_t)*scene, &((*get_dispatch_table((uint64_t)(sceneObserver))))); - return ret; + params->result = wine_xrCreateSession(params->instance, params->createInfo, params->session); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateSceneObserverMSFT(XrSession session, const XrSceneObserverCreateInfoMSFT *createInfo, XrSceneObserverMSFT *sceneObserver) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSpaceUserFB(void *args) { - XrResult ret; + struct xrCreateSpaceUserFB_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->info, params->user); - WINE_TRACE("%p, %p, %p\n", session, createInfo, sceneObserver); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateSceneObserverMSFT(((wine_XrSession *)session)->session, createInfo, sceneObserver); - if (!ret) register_dispatchable_handle((uint64_t)*sceneObserver, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSpaceUserFB(wine_session_from_handle(params->session)->host_session, params->info, params->user); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateSpaceUserFB(XrSession session, const XrSpaceUserCreateInfoFB *info, XrSpaceUserFB *user) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSpatialAnchorFB(void *args) { - XrResult ret; + struct xrCreateSpatialAnchorFB_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, info, user); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateSpaceUserFB(((wine_XrSession *)session)->session, info, user); - if (!ret) register_dispatchable_handle((uint64_t)*user, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + TRACE("%p, %p, %p\n", params->session, params->info, params->requestId); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSpatialAnchorFB(wine_session_from_handle(params->session)->host_session, params->info, params->requestId); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateSpatialAnchorFB(XrSession session, const XrSpatialAnchorCreateInfoFB *info, XrAsyncRequestIdFB *requestId) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSpatialAnchorFromPersistedNameMSFT(void *args) { - XrResult ret; + struct xrCreateSpatialAnchorFromPersistedNameMSFT_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->spatialAnchorCreateInfo, params->spatialAnchor); - WINE_TRACE("%p, %p, %p\n", session, info, requestId); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateSpatialAnchorFB(((wine_XrSession *)session)->session, info, requestId); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSpatialAnchorFromPersistedNameMSFT(wine_session_from_handle(params->session)->host_session, params->spatialAnchorCreateInfo, params->spatialAnchor); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateSpatialAnchorFromPersistedNameMSFT(XrSession session, const XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT *spatialAnchorCreateInfo, XrSpatialAnchorMSFT *spatialAnchor) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSpatialAnchorHTC(void *args) { - XrResult ret; + struct xrCreateSpatialAnchorHTC_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, spatialAnchorCreateInfo, spatialAnchor); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateSpatialAnchorFromPersistedNameMSFT(((wine_XrSession *)session)->session, spatialAnchorCreateInfo, spatialAnchor); - if (!ret) register_dispatchable_handle((uint64_t)*spatialAnchor, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->anchor); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSpatialAnchorHTC(wine_session_from_handle(params->session)->host_session, params->createInfo, params->anchor); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateSpatialAnchorHTC(XrSession session, const XrSpatialAnchorCreateInfoHTC *createInfo, XrSpace *anchor) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSpatialAnchorMSFT(void *args) { - XrResult ret; + struct xrCreateSpatialAnchorMSFT_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->anchor); - WINE_TRACE("%p, %p, %p\n", session, createInfo, anchor); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateSpatialAnchorHTC(((wine_XrSession *)session)->session, createInfo, anchor); - if (!ret) register_dispatchable_handle((uint64_t)*anchor, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSpatialAnchorMSFT(wine_session_from_handle(params->session)->host_session, params->createInfo, params->anchor); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateSpatialAnchorMSFT(XrSession session, const XrSpatialAnchorCreateInfoMSFT *createInfo, XrSpatialAnchorMSFT *anchor) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSpatialAnchorSpaceMSFT(void *args) { - XrResult ret; + struct xrCreateSpatialAnchorSpaceMSFT_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->space); - WINE_TRACE("%p, %p, %p\n", session, createInfo, anchor); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateSpatialAnchorMSFT(((wine_XrSession *)session)->session, createInfo, anchor); - if (!ret) register_dispatchable_handle((uint64_t)*anchor, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSpatialAnchorSpaceMSFT(wine_session_from_handle(params->session)->host_session, params->createInfo, params->space); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateSpatialAnchorSpaceMSFT(XrSession session, const XrSpatialAnchorSpaceCreateInfoMSFT *createInfo, XrSpace *space) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSpatialAnchorStoreConnectionMSFT(void *args) { - XrResult ret; + struct xrCreateSpatialAnchorStoreConnectionMSFT_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, createInfo, space); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateSpatialAnchorSpaceMSFT(((wine_XrSession *)session)->session, createInfo, space); - if (!ret) register_dispatchable_handle((uint64_t)*space, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + TRACE("%p, %p\n", params->session, params->spatialAnchorStore); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSpatialAnchorStoreConnectionMSFT(wine_session_from_handle(params->session)->host_session, params->spatialAnchorStore); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateSpatialAnchorStoreConnectionMSFT(XrSession session, XrSpatialAnchorStoreConnectionMSFT *spatialAnchorStore) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSpatialGraphNodeSpaceMSFT(void *args) { - XrResult ret; + struct xrCreateSpatialGraphNodeSpaceMSFT_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->space); - WINE_TRACE("%p, %p\n", session, spatialAnchorStore); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateSpatialAnchorStoreConnectionMSFT(((wine_XrSession *)session)->session, spatialAnchorStore); - if (!ret) register_dispatchable_handle((uint64_t)*spatialAnchorStore, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSpatialGraphNodeSpaceMSFT(wine_session_from_handle(params->session)->host_session, params->createInfo, params->space); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateSpatialGraphNodeSpaceMSFT(XrSession session, const XrSpatialGraphNodeSpaceCreateInfoMSFT *createInfo, XrSpace *space) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSwapchain(void *args) { - XrResult ret; + struct xrCreateSwapchain_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, createInfo, space); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateSpatialGraphNodeSpaceMSFT(((wine_XrSession *)session)->session, createInfo, space); - if (!ret) register_dispatchable_handle((uint64_t)*space, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->swapchain); + + params->result = wine_xrCreateSwapchain(params->session, params->createInfo, params->swapchain); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateTriangleMeshFB(XrSession session, const XrTriangleMeshCreateInfoFB *createInfo, XrTriangleMeshFB *outTriangleMesh) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateTriangleMeshFB(void *args) { - XrResult ret; + struct xrCreateTriangleMeshFB_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->outTriangleMesh); - WINE_TRACE("%p, %p, %p\n", session, createInfo, outTriangleMesh); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateTriangleMeshFB(((wine_XrSession *)session)->session, createInfo, outTriangleMesh); - if (!ret) register_dispatchable_handle((uint64_t)*outTriangleMesh, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreateTriangleMeshFB(wine_session_from_handle(params->session)->host_session, params->createInfo, params->outTriangleMesh); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateVirtualKeyboardMETA(XrSession session, const XrVirtualKeyboardCreateInfoMETA *createInfo, XrVirtualKeyboardMETA *keyboard) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateVirtualKeyboardMETA(void *args) { - XrResult ret; + struct xrCreateVirtualKeyboardMETA_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->keyboard); - WINE_TRACE("%p, %p, %p\n", session, createInfo, keyboard); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateVirtualKeyboardMETA(((wine_XrSession *)session)->session, createInfo, keyboard); - if (!ret) register_dispatchable_handle((uint64_t)*keyboard, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrCreateVirtualKeyboardMETA(wine_session_from_handle(params->session)->host_session, params->createInfo, params->keyboard); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrCreateVirtualKeyboardSpaceMETA(XrSession session, XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardSpaceCreateInfoMETA *createInfo, XrSpace *keyboardSpace) +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateVirtualKeyboardSpaceMETA(void *args) { - XrResult ret; + struct xrCreateVirtualKeyboardSpaceMETA_params *params = args; - WINE_TRACE("%p, %p, %p, %p\n", session, keyboard, createInfo, keyboardSpace); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateVirtualKeyboardSpaceMETA(((wine_XrSession *)session)->session, keyboard, createInfo, keyboardSpace); - if (!ret) register_dispatchable_handle((uint64_t)*keyboardSpace, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + TRACE("%p, %p, %p, %p\n", params->session, params->keyboard, params->createInfo, params->keyboardSpace); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateVirtualKeyboardSpaceMETA(wine_session_from_handle(params->session)->host_session, params->keyboard, params->createInfo, params->keyboardSpace); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDeserializeSceneMSFT(XrSceneObserverMSFT sceneObserver, const XrSceneDeserializeInfoMSFT *deserializeInfo) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDeserializeSceneMSFT(void *args) { - XrResult ret; + struct xrDeserializeSceneMSFT_params *params = args; + + TRACE("%p, %p\n", params->sceneObserver, params->deserializeInfo); - WINE_TRACE("%p, %p\n", sceneObserver, deserializeInfo); - ret = (*get_dispatch_table((uint64_t)(sceneObserver))).p_xrDeserializeSceneMSFT(sceneObserver, deserializeInfo); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrDeserializeSceneMSFT(params->sceneObserver, params->deserializeInfo); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrDestroyAction(XrAction action) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyAction(void *args) { - XrResult ret; + struct xrDestroyAction_params *params = args; - WINE_TRACE("%p\n", action); - ret = xrDestroyAction(action); - return ret; + TRACE("%p\n", params->action); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyAction(params->action); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrDestroyActionSet(XrActionSet actionSet) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyActionSet(void *args) { - XrResult ret; + struct xrDestroyActionSet_params *params = args; + + TRACE("%p\n", params->actionSet); - WINE_TRACE("%p\n", actionSet); - ret = xrDestroyActionSet(actionSet); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyActionSet(params->actionSet); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroyBodyTrackerFB(XrBodyTrackerFB bodyTracker) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyBodyTrackerFB(void *args) { - XrResult ret; + struct xrDestroyBodyTrackerFB_params *params = args; + + TRACE("%p\n", params->bodyTracker); - WINE_TRACE("%p\n", bodyTracker); - ret = (*get_dispatch_table((uint64_t)(bodyTracker))).p_xrDestroyBodyTrackerFB(bodyTracker); - unregister_dispatchable_handle((uint64_t)bodyTracker); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyBodyTrackerFB(params->bodyTracker); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroyEnvironmentDepthProviderMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyEnvironmentDepthProviderMETA(void *args) { - XrResult ret; + struct xrDestroyEnvironmentDepthProviderMETA_params *params = args; - WINE_TRACE("%p\n", environmentDepthProvider); - ret = (*get_dispatch_table((uint64_t)(environmentDepthProvider))).p_xrDestroyEnvironmentDepthProviderMETA(environmentDepthProvider); - unregister_dispatchable_handle((uint64_t)environmentDepthProvider); - return ret; + TRACE("%p\n", params->environmentDepthProvider); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyEnvironmentDepthProviderMETA(params->environmentDepthProvider); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroyEnvironmentDepthSwapchainMETA(XrEnvironmentDepthSwapchainMETA swapchain) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyEnvironmentDepthSwapchainMETA(void *args) { - XrResult ret; + struct xrDestroyEnvironmentDepthSwapchainMETA_params *params = args; + + TRACE("%p\n", params->swapchain); - WINE_TRACE("%p\n", swapchain); - ret = (*get_dispatch_table((uint64_t)(swapchain))).p_xrDestroyEnvironmentDepthSwapchainMETA(swapchain); - unregister_dispatchable_handle((uint64_t)swapchain); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyEnvironmentDepthSwapchainMETA(params->swapchain); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroyExportedLocalizationMapML(XrExportedLocalizationMapML map) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyExportedLocalizationMapML(void *args) { - XrResult ret; + struct xrDestroyExportedLocalizationMapML_params *params = args; - WINE_TRACE("%p\n", map); - ret = (*get_dispatch_table((uint64_t)(map))).p_xrDestroyExportedLocalizationMapML(map); - unregister_dispatchable_handle((uint64_t)map); - return ret; + TRACE("%p\n", params->map); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyExportedLocalizationMapML(params->map); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroyEyeTrackerFB(XrEyeTrackerFB eyeTracker) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyEyeTrackerFB(void *args) { - XrResult ret; + struct xrDestroyEyeTrackerFB_params *params = args; + + TRACE("%p\n", params->eyeTracker); - WINE_TRACE("%p\n", eyeTracker); - ret = (*get_dispatch_table((uint64_t)(eyeTracker))).p_xrDestroyEyeTrackerFB(eyeTracker); - unregister_dispatchable_handle((uint64_t)eyeTracker); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyEyeTrackerFB(params->eyeTracker); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroyFaceTracker2FB(XrFaceTracker2FB faceTracker) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyFaceTracker2FB(void *args) { - XrResult ret; + struct xrDestroyFaceTracker2FB_params *params = args; + + TRACE("%p\n", params->faceTracker); - WINE_TRACE("%p\n", faceTracker); - ret = (*get_dispatch_table((uint64_t)(faceTracker))).p_xrDestroyFaceTracker2FB(faceTracker); - unregister_dispatchable_handle((uint64_t)faceTracker); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyFaceTracker2FB(params->faceTracker); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroyFaceTrackerFB(XrFaceTrackerFB faceTracker) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyFaceTrackerFB(void *args) { - XrResult ret; + struct xrDestroyFaceTrackerFB_params *params = args; - WINE_TRACE("%p\n", faceTracker); - ret = (*get_dispatch_table((uint64_t)(faceTracker))).p_xrDestroyFaceTrackerFB(faceTracker); - unregister_dispatchable_handle((uint64_t)faceTracker); - return ret; + TRACE("%p\n", params->faceTracker); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyFaceTrackerFB(params->faceTracker); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroyFacialTrackerHTC(XrFacialTrackerHTC facialTracker) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyFacialTrackerHTC(void *args) { - XrResult ret; + struct xrDestroyFacialTrackerHTC_params *params = args; + + TRACE("%p\n", params->facialTracker); - WINE_TRACE("%p\n", facialTracker); - ret = (*get_dispatch_table((uint64_t)(facialTracker))).p_xrDestroyFacialTrackerHTC(facialTracker); - unregister_dispatchable_handle((uint64_t)facialTracker); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyFacialTrackerHTC(params->facialTracker); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroyFoveationProfileFB(XrFoveationProfileFB profile) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyFoveationProfileFB(void *args) { - XrResult ret; + struct xrDestroyFoveationProfileFB_params *params = args; - WINE_TRACE("%p\n", profile); - ret = (*get_dispatch_table((uint64_t)(profile))).p_xrDestroyFoveationProfileFB(profile); - unregister_dispatchable_handle((uint64_t)profile); - return ret; + TRACE("%p\n", params->profile); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyFoveationProfileFB(params->profile); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroyGeometryInstanceFB(XrGeometryInstanceFB instance) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyGeometryInstanceFB(void *args) { - XrResult ret; + struct xrDestroyGeometryInstanceFB_params *params = args; + + TRACE("%p\n", params->instance); - WINE_TRACE("%p\n", instance); - ret = (*get_dispatch_table((uint64_t)(instance))).p_xrDestroyGeometryInstanceFB(instance); - unregister_dispatchable_handle((uint64_t)instance); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyGeometryInstanceFB(params->instance); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroyHandTrackerEXT(XrHandTrackerEXT handTracker) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyHandTrackerEXT(void *args) { - XrResult ret; + struct xrDestroyHandTrackerEXT_params *params = args; + + TRACE("%p\n", params->handTracker); - WINE_TRACE("%p\n", handTracker); - ret = (*get_dispatch_table((uint64_t)(handTracker))).p_xrDestroyHandTrackerEXT(handTracker); - unregister_dispatchable_handle((uint64_t)handTracker); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyHandTrackerEXT(params->handTracker); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroyMarkerDetectorML(XrMarkerDetectorML markerDetector) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyInstance(void *args) { - XrResult ret; + struct xrDestroyInstance_params *params = args; - WINE_TRACE("%p\n", markerDetector); - ret = (*get_dispatch_table((uint64_t)(markerDetector))).p_xrDestroyMarkerDetectorML(markerDetector); - unregister_dispatchable_handle((uint64_t)markerDetector); - return ret; + TRACE("%p\n", params->instance); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyInstance(wine_instance_from_handle(params->instance)->host_instance); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroyPassthroughColorLutMETA(XrPassthroughColorLutMETA colorLut) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyMarkerDetectorML(void *args) { - XrResult ret; + struct xrDestroyMarkerDetectorML_params *params = args; + + TRACE("%p\n", params->markerDetector); - WINE_TRACE("%p\n", colorLut); - ret = (*get_dispatch_table((uint64_t)(colorLut))).p_xrDestroyPassthroughColorLutMETA(colorLut); - unregister_dispatchable_handle((uint64_t)colorLut); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyMarkerDetectorML(params->markerDetector); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroyPassthroughFB(XrPassthroughFB passthrough) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyPassthroughColorLutMETA(void *args) { - XrResult ret; + struct xrDestroyPassthroughColorLutMETA_params *params = args; - WINE_TRACE("%p\n", passthrough); - ret = (*get_dispatch_table((uint64_t)(passthrough))).p_xrDestroyPassthroughFB(passthrough); - unregister_dispatchable_handle((uint64_t)passthrough); - return ret; + TRACE("%p\n", params->colorLut); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyPassthroughColorLutMETA(params->colorLut); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroyPassthroughHTC(XrPassthroughHTC passthrough) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyPassthroughFB(void *args) { - XrResult ret; + struct xrDestroyPassthroughFB_params *params = args; + + TRACE("%p\n", params->passthrough); - WINE_TRACE("%p\n", passthrough); - ret = (*get_dispatch_table((uint64_t)(passthrough))).p_xrDestroyPassthroughHTC(passthrough); - unregister_dispatchable_handle((uint64_t)passthrough); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyPassthroughFB(params->passthrough); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroyPassthroughLayerFB(XrPassthroughLayerFB layer) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyPassthroughHTC(void *args) { - XrResult ret; + struct xrDestroyPassthroughHTC_params *params = args; + + TRACE("%p\n", params->passthrough); - WINE_TRACE("%p\n", layer); - ret = (*get_dispatch_table((uint64_t)(layer))).p_xrDestroyPassthroughLayerFB(layer); - unregister_dispatchable_handle((uint64_t)layer); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyPassthroughHTC(params->passthrough); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroyPlaneDetectorEXT(XrPlaneDetectorEXT planeDetector) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyPassthroughLayerFB(void *args) { - XrResult ret; + struct xrDestroyPassthroughLayerFB_params *params = args; - WINE_TRACE("%p\n", planeDetector); - ret = (*get_dispatch_table((uint64_t)(planeDetector))).p_xrDestroyPlaneDetectorEXT(planeDetector); - unregister_dispatchable_handle((uint64_t)planeDetector); - return ret; + TRACE("%p\n", params->layer); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyPassthroughLayerFB(params->layer); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroySceneMSFT(XrSceneMSFT scene) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyPlaneDetectorEXT(void *args) { - XrResult ret; + struct xrDestroyPlaneDetectorEXT_params *params = args; + + TRACE("%p\n", params->planeDetector); - WINE_TRACE("%p\n", scene); - ret = (*get_dispatch_table((uint64_t)(scene))).p_xrDestroySceneMSFT(scene); - unregister_dispatchable_handle((uint64_t)scene); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyPlaneDetectorEXT(params->planeDetector); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroySceneObserverMSFT(XrSceneObserverMSFT sceneObserver) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroySceneMSFT(void *args) { - XrResult ret; + struct xrDestroySceneMSFT_params *params = args; - WINE_TRACE("%p\n", sceneObserver); - ret = (*get_dispatch_table((uint64_t)(sceneObserver))).p_xrDestroySceneObserverMSFT(sceneObserver); - unregister_dispatchable_handle((uint64_t)sceneObserver); - return ret; + TRACE("%p\n", params->scene); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroySceneMSFT(params->scene); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrDestroySpace(XrSpace space) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroySceneObserverMSFT(void *args) { - XrResult ret; + struct xrDestroySceneObserverMSFT_params *params = args; + + TRACE("%p\n", params->sceneObserver); - WINE_TRACE("%p\n", space); - ret = xrDestroySpace(space); - unregister_dispatchable_handle((uint64_t)space); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrDestroySceneObserverMSFT(params->sceneObserver); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroySpaceUserFB(XrSpaceUserFB user) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroySession(void *args) { - XrResult ret; + struct xrDestroySession_params *params = args; + + TRACE("%p\n", params->session); - WINE_TRACE("%p\n", user); - ret = (*get_dispatch_table((uint64_t)(user))).p_xrDestroySpaceUserFB(user); - unregister_dispatchable_handle((uint64_t)user); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrDestroySession(wine_session_from_handle(params->session)->host_session); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroySpatialAnchorMSFT(XrSpatialAnchorMSFT anchor) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroySpace(void *args) { - XrResult ret; + struct xrDestroySpace_params *params = args; - WINE_TRACE("%p\n", anchor); - ret = (*get_dispatch_table((uint64_t)(anchor))).p_xrDestroySpatialAnchorMSFT(anchor); - unregister_dispatchable_handle((uint64_t)anchor); - return ret; + TRACE("%p\n", params->space); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroySpace(params->space); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroySpatialAnchorStoreConnectionMSFT(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroySpaceUserFB(void *args) { - XrResult ret; + struct xrDestroySpaceUserFB_params *params = args; + + TRACE("%p\n", params->user); - WINE_TRACE("%p\n", spatialAnchorStore); - ret = (*get_dispatch_table((uint64_t)(spatialAnchorStore))).p_xrDestroySpatialAnchorStoreConnectionMSFT(spatialAnchorStore); - unregister_dispatchable_handle((uint64_t)spatialAnchorStore); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrDestroySpaceUserFB(params->user); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroySpatialGraphNodeBindingMSFT(XrSpatialGraphNodeBindingMSFT nodeBinding) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroySpatialAnchorMSFT(void *args) { - XrResult ret; + struct xrDestroySpatialAnchorMSFT_params *params = args; - WINE_TRACE("%p\n", nodeBinding); - ret = (*get_dispatch_table((uint64_t)(nodeBinding))).p_xrDestroySpatialGraphNodeBindingMSFT(nodeBinding); - unregister_dispatchable_handle((uint64_t)nodeBinding); - return ret; + TRACE("%p\n", params->anchor); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroySpatialAnchorMSFT(params->anchor); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroyTriangleMeshFB(XrTriangleMeshFB mesh) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroySpatialAnchorStoreConnectionMSFT(void *args) { - XrResult ret; + struct xrDestroySpatialAnchorStoreConnectionMSFT_params *params = args; + + TRACE("%p\n", params->spatialAnchorStore); - WINE_TRACE("%p\n", mesh); - ret = (*get_dispatch_table((uint64_t)(mesh))).p_xrDestroyTriangleMeshFB(mesh); - unregister_dispatchable_handle((uint64_t)mesh); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrDestroySpatialAnchorStoreConnectionMSFT(params->spatialAnchorStore); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrDestroyVirtualKeyboardMETA(XrVirtualKeyboardMETA keyboard) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroySpatialGraphNodeBindingMSFT(void *args) { - XrResult ret; + struct xrDestroySpatialGraphNodeBindingMSFT_params *params = args; + + TRACE("%p\n", params->nodeBinding); - WINE_TRACE("%p\n", keyboard); - ret = (*get_dispatch_table((uint64_t)(keyboard))).p_xrDestroyVirtualKeyboardMETA(keyboard); - unregister_dispatchable_handle((uint64_t)keyboard); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrDestroySpatialGraphNodeBindingMSFT(params->nodeBinding); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrEnableLocalizationEventsML(XrSession session, const XrLocalizationEnableEventsInfoML *info) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroySwapchain(void *args) { - XrResult ret; + struct xrDestroySwapchain_params *params = args; - WINE_TRACE("%p, %p\n", session, info); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrEnableLocalizationEventsML(((wine_XrSession *)session)->session, info); - return ret; + TRACE("%p\n", params->swapchain); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroySwapchain(wine_swapchain_from_handle(params->swapchain)->host_swapchain); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrEnableUserCalibrationEventsML(XrInstance instance, const XrUserCalibrationEnableEventsInfoML *enableInfo) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyTriangleMeshFB(void *args) { - XrResult ret; + struct xrDestroyTriangleMeshFB_params *params = args; + + TRACE("%p\n", params->mesh); - WINE_TRACE("%p, %p\n", instance, enableInfo); - ret = ((wine_XrInstance *)instance)->funcs.p_xrEnableUserCalibrationEventsML(((wine_XrInstance *)instance)->instance, enableInfo); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyTriangleMeshFB(params->mesh); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrEndSession(XrSession session) +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyVirtualKeyboardMETA(void *args) { - XrResult ret; + struct xrDestroyVirtualKeyboardMETA_params *params = args; - WINE_TRACE("%p\n", session); - ret = xrEndSession(((wine_XrSession *)session)->session); - return ret; + TRACE("%p\n", params->keyboard); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyVirtualKeyboardMETA(params->keyboard); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrEnumerateApiLayerProperties(uint32_t propertyCapacityInput, uint32_t *propertyCountOutput, XrApiLayerProperties *properties) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnableLocalizationEventsML(void *args) { - XrResult ret; + struct xrEnableLocalizationEventsML_params *params = args; + + TRACE("%p, %p\n", params->session, params->info); - WINE_TRACE("%u, %p, %p\n", propertyCapacityInput, propertyCountOutput, properties); - ret = xrEnumerateApiLayerProperties(propertyCapacityInput, propertyCountOutput, properties); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrEnableLocalizationEventsML(wine_session_from_handle(params->session)->host_session, params->info); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrEnumerateBoundSourcesForAction(XrSession session, const XrBoundSourcesForActionEnumerateInfo *enumerateInfo, uint32_t sourceCapacityInput, uint32_t *sourceCountOutput, XrPath *sources) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnableUserCalibrationEventsML(void *args) { - XrResult ret; + struct xrEnableUserCalibrationEventsML_params *params = args; + + TRACE("%p, %p\n", params->instance, params->enableInfo); - WINE_TRACE("%p, %p, %u, %p, %p\n", session, enumerateInfo, sourceCapacityInput, sourceCountOutput, sources); - ret = xrEnumerateBoundSourcesForAction(((wine_XrSession *)session)->session, enumerateInfo, sourceCapacityInput, sourceCountOutput, sources); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrEnableUserCalibrationEventsML(wine_instance_from_handle(params->instance)->host_instance, params->enableInfo); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrEnumerateColorSpacesFB(XrSession session, uint32_t colorSpaceCapacityInput, uint32_t *colorSpaceCountOutput, XrColorSpaceFB *colorSpaces) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEndFrame(void *args) { - XrResult ret; + struct xrEndFrame_params *params = args; - WINE_TRACE("%p, %u, %p, %p\n", session, colorSpaceCapacityInput, colorSpaceCountOutput, colorSpaces); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrEnumerateColorSpacesFB(((wine_XrSession *)session)->session, colorSpaceCapacityInput, colorSpaceCountOutput, colorSpaces); - return ret; + TRACE("%p, %p\n", params->session, params->frameEndInfo); + + params->result = g_xr_host_instance_dispatch_table.p_xrEndFrame(wine_session_from_handle(params->session)->host_session, params->frameEndInfo); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrEnumerateDisplayRefreshRatesFB(XrSession session, uint32_t displayRefreshRateCapacityInput, uint32_t *displayRefreshRateCountOutput, float *displayRefreshRates) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEndSession(void *args) { - XrResult ret; + struct xrEndSession_params *params = args; + + TRACE("%p\n", params->session); - WINE_TRACE("%p, %u, %p, %p\n", session, displayRefreshRateCapacityInput, displayRefreshRateCountOutput, displayRefreshRates); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrEnumerateDisplayRefreshRatesFB(((wine_XrSession *)session)->session, displayRefreshRateCapacityInput, displayRefreshRateCountOutput, displayRefreshRates); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrEndSession(wine_session_from_handle(params->session)->host_session); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrEnumerateEnvironmentBlendModes(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, uint32_t environmentBlendModeCapacityInput, uint32_t *environmentBlendModeCountOutput, XrEnvironmentBlendMode *environmentBlendModes) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateApiLayerProperties(void *args) { - XrResult ret; + struct xrEnumerateApiLayerProperties_params *params = args; - WINE_TRACE("%p, 0x%s, %#x, %u, %p, %p\n", instance, wine_dbgstr_longlong(systemId), viewConfigurationType, environmentBlendModeCapacityInput, environmentBlendModeCountOutput, environmentBlendModes); - ret = xrEnumerateEnvironmentBlendModes(((wine_XrInstance *)instance)->instance, systemId, viewConfigurationType, environmentBlendModeCapacityInput, environmentBlendModeCountOutput, environmentBlendModes); - return ret; + TRACE("%u, %p, %p\n", params->propertyCapacityInput, params->propertyCountOutput, params->properties); + + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateApiLayerProperties(params->propertyCapacityInput, params->propertyCountOutput, params->properties); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrEnumerateEnvironmentDepthSwapchainImagesMETA(XrEnvironmentDepthSwapchainMETA swapchain, uint32_t imageCapacityInput, uint32_t *imageCountOutput, XrSwapchainImageBaseHeader *images) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateBoundSourcesForAction(void *args) { - XrResult ret; + struct xrEnumerateBoundSourcesForAction_params *params = args; + + TRACE("%p, %p, %u, %p, %p\n", params->session, params->enumerateInfo, params->sourceCapacityInput, params->sourceCountOutput, params->sources); - WINE_TRACE("%p, %u, %p, %p\n", swapchain, imageCapacityInput, imageCountOutput, images); - ret = (*get_dispatch_table((uint64_t)(swapchain))).p_xrEnumerateEnvironmentDepthSwapchainImagesMETA(swapchain, imageCapacityInput, imageCountOutput, images); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateBoundSourcesForAction(wine_session_from_handle(params->session)->host_session, params->enumerateInfo, params->sourceCapacityInput, params->sourceCountOutput, params->sources); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrEnumerateExternalCamerasOCULUS(XrSession session, uint32_t cameraCapacityInput, uint32_t *cameraCountOutput, XrExternalCameraOCULUS *cameras) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateColorSpacesFB(void *args) { - XrResult ret; + struct xrEnumerateColorSpacesFB_params *params = args; + + TRACE("%p, %u, %p, %p\n", params->session, params->colorSpaceCapacityInput, params->colorSpaceCountOutput, params->colorSpaces); - WINE_TRACE("%p, %u, %p, %p\n", session, cameraCapacityInput, cameraCountOutput, cameras); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrEnumerateExternalCamerasOCULUS(((wine_XrSession *)session)->session, cameraCapacityInput, cameraCountOutput, cameras); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateColorSpacesFB(wine_session_from_handle(params->session)->host_session, params->colorSpaceCapacityInput, params->colorSpaceCountOutput, params->colorSpaces); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrEnumeratePerformanceMetricsCounterPathsMETA(XrInstance instance, uint32_t counterPathCapacityInput, uint32_t *counterPathCountOutput, XrPath *counterPaths) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateDisplayRefreshRatesFB(void *args) { - XrResult ret; + struct xrEnumerateDisplayRefreshRatesFB_params *params = args; - WINE_TRACE("%p, %u, %p, %p\n", instance, counterPathCapacityInput, counterPathCountOutput, counterPaths); - ret = ((wine_XrInstance *)instance)->funcs.p_xrEnumeratePerformanceMetricsCounterPathsMETA(((wine_XrInstance *)instance)->instance, counterPathCapacityInput, counterPathCountOutput, counterPaths); - return ret; + TRACE("%p, %u, %p, %p\n", params->session, params->displayRefreshRateCapacityInput, params->displayRefreshRateCountOutput, params->displayRefreshRates); + + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateDisplayRefreshRatesFB(wine_session_from_handle(params->session)->host_session, params->displayRefreshRateCapacityInput, params->displayRefreshRateCountOutput, params->displayRefreshRates); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrEnumeratePersistedSpatialAnchorNamesMSFT(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, uint32_t spatialAnchorNameCapacityInput, uint32_t *spatialAnchorNameCountOutput, XrSpatialAnchorPersistenceNameMSFT *spatialAnchorNames) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateEnvironmentBlendModes(void *args) { - XrResult ret; + struct xrEnumerateEnvironmentBlendModes_params *params = args; + + TRACE("%p, 0x%s, %#x, %u, %p, %p\n", params->instance, wine_dbgstr_longlong(params->systemId), params->viewConfigurationType, params->environmentBlendModeCapacityInput, params->environmentBlendModeCountOutput, params->environmentBlendModes); - WINE_TRACE("%p, %u, %p, %p\n", spatialAnchorStore, spatialAnchorNameCapacityInput, spatialAnchorNameCountOutput, spatialAnchorNames); - ret = (*get_dispatch_table((uint64_t)(spatialAnchorStore))).p_xrEnumeratePersistedSpatialAnchorNamesMSFT(spatialAnchorStore, spatialAnchorNameCapacityInput, spatialAnchorNameCountOutput, spatialAnchorNames); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateEnvironmentBlendModes(wine_instance_from_handle(params->instance)->host_instance, params->systemId, params->viewConfigurationType, params->environmentBlendModeCapacityInput, params->environmentBlendModeCountOutput, params->environmentBlendModes); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrEnumerateReferenceSpaces(XrSession session, uint32_t spaceCapacityInput, uint32_t *spaceCountOutput, XrReferenceSpaceType *spaces) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateEnvironmentDepthSwapchainImagesMETA(void *args) { - XrResult ret; + struct xrEnumerateEnvironmentDepthSwapchainImagesMETA_params *params = args; - WINE_TRACE("%p, %u, %p, %p\n", session, spaceCapacityInput, spaceCountOutput, spaces); - ret = xrEnumerateReferenceSpaces(((wine_XrSession *)session)->session, spaceCapacityInput, spaceCountOutput, spaces); - return ret; + TRACE("%p, %u, %p, %p\n", params->swapchain, params->imageCapacityInput, params->imageCountOutput, params->images); + + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateEnvironmentDepthSwapchainImagesMETA(params->swapchain, params->imageCapacityInput, params->imageCountOutput, params->images); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrEnumerateRenderModelPathsFB(XrSession session, uint32_t pathCapacityInput, uint32_t *pathCountOutput, XrRenderModelPathInfoFB *paths) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateExternalCamerasOCULUS(void *args) { - XrResult ret; + struct xrEnumerateExternalCamerasOCULUS_params *params = args; + + TRACE("%p, %u, %p, %p\n", params->session, params->cameraCapacityInput, params->cameraCountOutput, params->cameras); - WINE_TRACE("%p, %u, %p, %p\n", session, pathCapacityInput, pathCountOutput, paths); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrEnumerateRenderModelPathsFB(((wine_XrSession *)session)->session, pathCapacityInput, pathCountOutput, paths); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateExternalCamerasOCULUS(wine_session_from_handle(params->session)->host_session, params->cameraCapacityInput, params->cameraCountOutput, params->cameras); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrEnumerateReprojectionModesMSFT(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, uint32_t modeCapacityInput, uint32_t *modeCountOutput, XrReprojectionModeMSFT *modes) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateInstanceExtensionProperties(void *args) { - XrResult ret; + struct xrEnumerateInstanceExtensionProperties_params *params = args; + + TRACE("%p, %u, %p, %p\n", params->layerName, params->propertyCapacityInput, params->propertyCountOutput, params->properties); - WINE_TRACE("%p, 0x%s, %#x, %u, %p, %p\n", instance, wine_dbgstr_longlong(systemId), viewConfigurationType, modeCapacityInput, modeCountOutput, modes); - ret = ((wine_XrInstance *)instance)->funcs.p_xrEnumerateReprojectionModesMSFT(((wine_XrInstance *)instance)->instance, systemId, viewConfigurationType, modeCapacityInput, modeCountOutput, modes); - return ret; + params->result = wine_xrEnumerateInstanceExtensionProperties(params->layerName, params->propertyCapacityInput, params->propertyCountOutput, params->properties); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrEnumerateSceneComputeFeaturesMSFT(XrInstance instance, XrSystemId systemId, uint32_t featureCapacityInput, uint32_t *featureCountOutput, XrSceneComputeFeatureMSFT *features) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumeratePerformanceMetricsCounterPathsMETA(void *args) { - XrResult ret; + struct xrEnumeratePerformanceMetricsCounterPathsMETA_params *params = args; - WINE_TRACE("%p, 0x%s, %u, %p, %p\n", instance, wine_dbgstr_longlong(systemId), featureCapacityInput, featureCountOutput, features); - ret = ((wine_XrInstance *)instance)->funcs.p_xrEnumerateSceneComputeFeaturesMSFT(((wine_XrInstance *)instance)->instance, systemId, featureCapacityInput, featureCountOutput, features); - return ret; + TRACE("%p, %u, %p, %p\n", params->instance, params->counterPathCapacityInput, params->counterPathCountOutput, params->counterPaths); + + params->result = g_xr_host_instance_dispatch_table.p_xrEnumeratePerformanceMetricsCounterPathsMETA(wine_instance_from_handle(params->instance)->host_instance, params->counterPathCapacityInput, params->counterPathCountOutput, params->counterPaths); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrEnumerateSpaceSupportedComponentsFB(XrSpace space, uint32_t componentTypeCapacityInput, uint32_t *componentTypeCountOutput, XrSpaceComponentTypeFB *componentTypes) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumeratePersistedSpatialAnchorNamesMSFT(void *args) { - XrResult ret; + struct xrEnumeratePersistedSpatialAnchorNamesMSFT_params *params = args; + + TRACE("%p, %u, %p, %p\n", params->spatialAnchorStore, params->spatialAnchorNameCapacityInput, params->spatialAnchorNameCountOutput, params->spatialAnchorNames); - WINE_TRACE("%p, %u, %p, %p\n", space, componentTypeCapacityInput, componentTypeCountOutput, componentTypes); - ret = (*get_dispatch_table((uint64_t)(space))).p_xrEnumerateSpaceSupportedComponentsFB(space, componentTypeCapacityInput, componentTypeCountOutput, componentTypes); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrEnumeratePersistedSpatialAnchorNamesMSFT(params->spatialAnchorStore, params->spatialAnchorNameCapacityInput, params->spatialAnchorNameCountOutput, params->spatialAnchorNames); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrEnumerateViewConfigurationViews(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, uint32_t viewCapacityInput, uint32_t *viewCountOutput, XrViewConfigurationView *views) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateReferenceSpaces(void *args) { - XrResult ret; + struct xrEnumerateReferenceSpaces_params *params = args; - WINE_TRACE("%p, 0x%s, %#x, %u, %p, %p\n", instance, wine_dbgstr_longlong(systemId), viewConfigurationType, viewCapacityInput, viewCountOutput, views); - ret = xrEnumerateViewConfigurationViews(((wine_XrInstance *)instance)->instance, systemId, viewConfigurationType, viewCapacityInput, viewCountOutput, views); - return ret; + TRACE("%p, %u, %p, %p\n", params->session, params->spaceCapacityInput, params->spaceCountOutput, params->spaces); + + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateReferenceSpaces(wine_session_from_handle(params->session)->host_session, params->spaceCapacityInput, params->spaceCountOutput, params->spaces); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrEnumerateViewConfigurations(XrInstance instance, XrSystemId systemId, uint32_t viewConfigurationTypeCapacityInput, uint32_t *viewConfigurationTypeCountOutput, XrViewConfigurationType *viewConfigurationTypes) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateRenderModelPathsFB(void *args) { - XrResult ret; + struct xrEnumerateRenderModelPathsFB_params *params = args; + + TRACE("%p, %u, %p, %p\n", params->session, params->pathCapacityInput, params->pathCountOutput, params->paths); - WINE_TRACE("%p, 0x%s, %u, %p, %p\n", instance, wine_dbgstr_longlong(systemId), viewConfigurationTypeCapacityInput, viewConfigurationTypeCountOutput, viewConfigurationTypes); - ret = xrEnumerateViewConfigurations(((wine_XrInstance *)instance)->instance, systemId, viewConfigurationTypeCapacityInput, viewConfigurationTypeCountOutput, viewConfigurationTypes); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateRenderModelPathsFB(wine_session_from_handle(params->session)->host_session, params->pathCapacityInput, params->pathCountOutput, params->paths); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrEnumerateViveTrackerPathsHTCX(XrInstance instance, uint32_t pathCapacityInput, uint32_t *pathCountOutput, XrViveTrackerPathsHTCX *paths) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateReprojectionModesMSFT(void *args) { - XrResult ret; + struct xrEnumerateReprojectionModesMSFT_params *params = args; + + TRACE("%p, 0x%s, %#x, %u, %p, %p\n", params->instance, wine_dbgstr_longlong(params->systemId), params->viewConfigurationType, params->modeCapacityInput, params->modeCountOutput, params->modes); - WINE_TRACE("%p, %u, %p, %p\n", instance, pathCapacityInput, pathCountOutput, paths); - ret = ((wine_XrInstance *)instance)->funcs.p_xrEnumerateViveTrackerPathsHTCX(((wine_XrInstance *)instance)->instance, pathCapacityInput, pathCountOutput, paths); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateReprojectionModesMSFT(wine_instance_from_handle(params->instance)->host_instance, params->systemId, params->viewConfigurationType, params->modeCapacityInput, params->modeCountOutput, params->modes); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrEraseSpaceFB(XrSession session, const XrSpaceEraseInfoFB *info, XrAsyncRequestIdFB *requestId) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateSceneComputeFeaturesMSFT(void *args) { - XrResult ret; + struct xrEnumerateSceneComputeFeaturesMSFT_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, info, requestId); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrEraseSpaceFB(((wine_XrSession *)session)->session, info, requestId); - return ret; + TRACE("%p, 0x%s, %u, %p, %p\n", params->instance, wine_dbgstr_longlong(params->systemId), params->featureCapacityInput, params->featureCountOutput, params->features); + + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateSceneComputeFeaturesMSFT(wine_instance_from_handle(params->instance)->host_instance, params->systemId, params->featureCapacityInput, params->featureCountOutput, params->features); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGeometryInstanceSetTransformFB(XrGeometryInstanceFB instance, const XrGeometryInstanceTransformFB *transformation) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateSpaceSupportedComponentsFB(void *args) { - XrResult ret; + struct xrEnumerateSpaceSupportedComponentsFB_params *params = args; + + TRACE("%p, %u, %p, %p\n", params->space, params->componentTypeCapacityInput, params->componentTypeCountOutput, params->componentTypes); - WINE_TRACE("%p, %p\n", instance, transformation); - ret = (*get_dispatch_table((uint64_t)(instance))).p_xrGeometryInstanceSetTransformFB(instance, transformation); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateSpaceSupportedComponentsFB(params->space, params->componentTypeCapacityInput, params->componentTypeCountOutput, params->componentTypes); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrGetActionStateBoolean(XrSession session, const XrActionStateGetInfo *getInfo, XrActionStateBoolean *state) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateSwapchainFormats(void *args) { - XrResult ret; + struct xrEnumerateSwapchainFormats_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, getInfo, state); - ret = xrGetActionStateBoolean(((wine_XrSession *)session)->session, getInfo, state); - return ret; + TRACE("%p, %u, %p, %p\n", params->session, params->formatCapacityInput, params->formatCountOutput, params->formats); + + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateSwapchainFormats(wine_session_from_handle(params->session)->host_session, params->formatCapacityInput, params->formatCountOutput, params->formats); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrGetActionStateFloat(XrSession session, const XrActionStateGetInfo *getInfo, XrActionStateFloat *state) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateSwapchainImages(void *args) { - XrResult ret; + struct xrEnumerateSwapchainImages_params *params = args; + + TRACE("%p, %u, %p, %p\n", params->swapchain, params->imageCapacityInput, params->imageCountOutput, params->images); - WINE_TRACE("%p, %p, %p\n", session, getInfo, state); - ret = xrGetActionStateFloat(((wine_XrSession *)session)->session, getInfo, state); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateSwapchainImages(wine_swapchain_from_handle(params->swapchain)->host_swapchain, params->imageCapacityInput, params->imageCountOutput, params->images); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrGetActionStatePose(XrSession session, const XrActionStateGetInfo *getInfo, XrActionStatePose *state) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateViewConfigurationViews(void *args) { - XrResult ret; + struct xrEnumerateViewConfigurationViews_params *params = args; + + TRACE("%p, 0x%s, %#x, %u, %p, %p\n", params->instance, wine_dbgstr_longlong(params->systemId), params->viewConfigurationType, params->viewCapacityInput, params->viewCountOutput, params->views); - WINE_TRACE("%p, %p, %p\n", session, getInfo, state); - ret = xrGetActionStatePose(((wine_XrSession *)session)->session, getInfo, state); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateViewConfigurationViews(wine_instance_from_handle(params->instance)->host_instance, params->systemId, params->viewConfigurationType, params->viewCapacityInput, params->viewCountOutput, params->views); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrGetActionStateVector2f(XrSession session, const XrActionStateGetInfo *getInfo, XrActionStateVector2f *state) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateViewConfigurations(void *args) { - XrResult ret; + struct xrEnumerateViewConfigurations_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, getInfo, state); - ret = xrGetActionStateVector2f(((wine_XrSession *)session)->session, getInfo, state); - return ret; + TRACE("%p, 0x%s, %u, %p, %p\n", params->instance, wine_dbgstr_longlong(params->systemId), params->viewConfigurationTypeCapacityInput, params->viewConfigurationTypeCountOutput, params->viewConfigurationTypes); + + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateViewConfigurations(wine_instance_from_handle(params->instance)->host_instance, params->systemId, params->viewConfigurationTypeCapacityInput, params->viewConfigurationTypeCountOutput, params->viewConfigurationTypes); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetAudioInputDeviceGuidOculus(XrInstance instance, wchar_t buffer[]) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateViveTrackerPathsHTCX(void *args) { - XrResult ret; + struct xrEnumerateViveTrackerPathsHTCX_params *params = args; + + TRACE("%p, %u, %p, %p\n", params->instance, params->pathCapacityInput, params->pathCountOutput, params->paths); - WINE_TRACE("%p, %p\n", instance, buffer); - ret = ((wine_XrInstance *)instance)->funcs.p_xrGetAudioInputDeviceGuidOculus(((wine_XrInstance *)instance)->instance, buffer); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateViveTrackerPathsHTCX(wine_instance_from_handle(params->instance)->host_instance, params->pathCapacityInput, params->pathCountOutput, params->paths); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetAudioOutputDeviceGuidOculus(XrInstance instance, wchar_t buffer[]) +#ifdef _WIN64 +static NTSTATUS thunk64_xrEraseSpaceFB(void *args) { - XrResult ret; + struct xrEraseSpaceFB_params *params = args; - WINE_TRACE("%p, %p\n", instance, buffer); - ret = ((wine_XrInstance *)instance)->funcs.p_xrGetAudioOutputDeviceGuidOculus(((wine_XrInstance *)instance)->instance, buffer); - return ret; + TRACE("%p, %p, %p\n", params->session, params->info, params->requestId); + + params->result = g_xr_host_instance_dispatch_table.p_xrEraseSpaceFB(wine_session_from_handle(params->session)->host_session, params->info, params->requestId); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetBodySkeletonFB(XrBodyTrackerFB bodyTracker, XrBodySkeletonFB *skeleton) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGeometryInstanceSetTransformFB(void *args) { - XrResult ret; + struct xrGeometryInstanceSetTransformFB_params *params = args; + + TRACE("%p, %p\n", params->instance, params->transformation); - WINE_TRACE("%p, %p\n", bodyTracker, skeleton); - ret = (*get_dispatch_table((uint64_t)(bodyTracker))).p_xrGetBodySkeletonFB(bodyTracker, skeleton); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGeometryInstanceSetTransformFB(params->instance, params->transformation); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetControllerModelKeyMSFT(XrSession session, XrPath topLevelUserPath, XrControllerModelKeyStateMSFT *controllerModelKeyState) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetActionStateBoolean(void *args) { - XrResult ret; + struct xrGetActionStateBoolean_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->getInfo, params->state); - WINE_TRACE("%p, 0x%s, %p\n", session, wine_dbgstr_longlong(topLevelUserPath), controllerModelKeyState); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetControllerModelKeyMSFT(((wine_XrSession *)session)->session, topLevelUserPath, controllerModelKeyState); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetActionStateBoolean(wine_session_from_handle(params->session)->host_session, params->getInfo, params->state); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetControllerModelPropertiesMSFT(XrSession session, XrControllerModelKeyMSFT modelKey, XrControllerModelPropertiesMSFT *properties) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetActionStateFloat(void *args) { - XrResult ret; + struct xrGetActionStateFloat_params *params = args; - WINE_TRACE("%p, 0x%s, %p\n", session, wine_dbgstr_longlong(modelKey), properties); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetControllerModelPropertiesMSFT(((wine_XrSession *)session)->session, modelKey, properties); - return ret; + TRACE("%p, %p, %p\n", params->session, params->getInfo, params->state); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetActionStateFloat(wine_session_from_handle(params->session)->host_session, params->getInfo, params->state); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetControllerModelStateMSFT(XrSession session, XrControllerModelKeyMSFT modelKey, XrControllerModelStateMSFT *state) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetActionStatePose(void *args) { - XrResult ret; + struct xrGetActionStatePose_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->getInfo, params->state); - WINE_TRACE("%p, 0x%s, %p\n", session, wine_dbgstr_longlong(modelKey), state); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetControllerModelStateMSFT(((wine_XrSession *)session)->session, modelKey, state); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetActionStatePose(wine_session_from_handle(params->session)->host_session, params->getInfo, params->state); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrGetCurrentInteractionProfile(XrSession session, XrPath topLevelUserPath, XrInteractionProfileState *interactionProfile) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetActionStateVector2f(void *args) { - XrResult ret; + struct xrGetActionStateVector2f_params *params = args; - WINE_TRACE("%p, 0x%s, %p\n", session, wine_dbgstr_longlong(topLevelUserPath), interactionProfile); - ret = xrGetCurrentInteractionProfile(((wine_XrSession *)session)->session, topLevelUserPath, interactionProfile); - return ret; + TRACE("%p, %p, %p\n", params->session, params->getInfo, params->state); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetActionStateVector2f(wine_session_from_handle(params->session)->host_session, params->getInfo, params->state); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetDeviceSampleRateFB(XrSession session, const XrHapticActionInfo *hapticActionInfo, XrDevicePcmSampleRateGetInfoFB *deviceSampleRate) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetAudioInputDeviceGuidOculus(void *args) { - XrResult ret; + struct xrGetAudioInputDeviceGuidOculus_params *params = args; + + TRACE("%p, %p\n", params->instance, params->buffer); - WINE_TRACE("%p, %p, %p\n", session, hapticActionInfo, deviceSampleRate); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetDeviceSampleRateFB(((wine_XrSession *)session)->session, hapticActionInfo, deviceSampleRate); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetAudioInputDeviceGuidOculus(wine_instance_from_handle(params->instance)->host_instance, params->buffer); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetDisplayRefreshRateFB(XrSession session, float *displayRefreshRate) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetAudioOutputDeviceGuidOculus(void *args) { - XrResult ret; + struct xrGetAudioOutputDeviceGuidOculus_params *params = args; + + TRACE("%p, %p\n", params->instance, params->buffer); - WINE_TRACE("%p, %p\n", session, displayRefreshRate); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetDisplayRefreshRateFB(((wine_XrSession *)session)->session, displayRefreshRate); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetAudioOutputDeviceGuidOculus(wine_instance_from_handle(params->instance)->host_instance, params->buffer); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetEnvironmentDepthSwapchainStateMETA(XrEnvironmentDepthSwapchainMETA swapchain, XrEnvironmentDepthSwapchainStateMETA *state) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetBodySkeletonFB(void *args) { - XrResult ret; + struct xrGetBodySkeletonFB_params *params = args; - WINE_TRACE("%p, %p\n", swapchain, state); - ret = (*get_dispatch_table((uint64_t)(swapchain))).p_xrGetEnvironmentDepthSwapchainStateMETA(swapchain, state); - return ret; + TRACE("%p, %p\n", params->bodyTracker, params->skeleton); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetBodySkeletonFB(params->bodyTracker, params->skeleton); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetExportedLocalizationMapDataML(XrExportedLocalizationMapML map, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetControllerModelKeyMSFT(void *args) { - XrResult ret; + struct xrGetControllerModelKeyMSFT_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->session, wine_dbgstr_longlong(params->topLevelUserPath), params->controllerModelKeyState); - WINE_TRACE("%p, %u, %p, %p\n", map, bufferCapacityInput, bufferCountOutput, buffer); - ret = (*get_dispatch_table((uint64_t)(map))).p_xrGetExportedLocalizationMapDataML(map, bufferCapacityInput, bufferCountOutput, buffer); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetControllerModelKeyMSFT(wine_session_from_handle(params->session)->host_session, params->topLevelUserPath, params->controllerModelKeyState); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetEyeGazesFB(XrEyeTrackerFB eyeTracker, const XrEyeGazesInfoFB *gazeInfo, XrEyeGazesFB *eyeGazes) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetControllerModelPropertiesMSFT(void *args) { - XrResult ret; + struct xrGetControllerModelPropertiesMSFT_params *params = args; - WINE_TRACE("%p, %p, %p\n", eyeTracker, gazeInfo, eyeGazes); - ret = (*get_dispatch_table((uint64_t)(eyeTracker))).p_xrGetEyeGazesFB(eyeTracker, gazeInfo, eyeGazes); - return ret; + TRACE("%p, 0x%s, %p\n", params->session, wine_dbgstr_longlong(params->modelKey), params->properties); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetControllerModelPropertiesMSFT(wine_session_from_handle(params->session)->host_session, params->modelKey, params->properties); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetFaceExpressionWeights2FB(XrFaceTracker2FB faceTracker, const XrFaceExpressionInfo2FB *expressionInfo, XrFaceExpressionWeights2FB *expressionWeights) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetControllerModelStateMSFT(void *args) { - XrResult ret; + struct xrGetControllerModelStateMSFT_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->session, wine_dbgstr_longlong(params->modelKey), params->state); - WINE_TRACE("%p, %p, %p\n", faceTracker, expressionInfo, expressionWeights); - ret = (*get_dispatch_table((uint64_t)(faceTracker))).p_xrGetFaceExpressionWeights2FB(faceTracker, expressionInfo, expressionWeights); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetControllerModelStateMSFT(wine_session_from_handle(params->session)->host_session, params->modelKey, params->state); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetFaceExpressionWeightsFB(XrFaceTrackerFB faceTracker, const XrFaceExpressionInfoFB *expressionInfo, XrFaceExpressionWeightsFB *expressionWeights) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetCurrentInteractionProfile(void *args) { - XrResult ret; + struct xrGetCurrentInteractionProfile_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->session, wine_dbgstr_longlong(params->topLevelUserPath), params->interactionProfile); - WINE_TRACE("%p, %p, %p\n", faceTracker, expressionInfo, expressionWeights); - ret = (*get_dispatch_table((uint64_t)(faceTracker))).p_xrGetFaceExpressionWeightsFB(faceTracker, expressionInfo, expressionWeights); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetCurrentInteractionProfile(wine_session_from_handle(params->session)->host_session, params->topLevelUserPath, params->interactionProfile); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetFacialExpressionsHTC(XrFacialTrackerHTC facialTracker, XrFacialExpressionsHTC *facialExpressions) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetDeviceSampleRateFB(void *args) { - XrResult ret; + struct xrGetDeviceSampleRateFB_params *params = args; - WINE_TRACE("%p, %p\n", facialTracker, facialExpressions); - ret = (*get_dispatch_table((uint64_t)(facialTracker))).p_xrGetFacialExpressionsHTC(facialTracker, facialExpressions); - return ret; + TRACE("%p, %p, %p\n", params->session, params->hapticActionInfo, params->deviceSampleRate); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetDeviceSampleRateFB(wine_session_from_handle(params->session)->host_session, params->hapticActionInfo, params->deviceSampleRate); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetFoveationEyeTrackedStateMETA(XrSession session, XrFoveationEyeTrackedStateMETA *foveationState) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetDisplayRefreshRateFB(void *args) { - XrResult ret; + struct xrGetDisplayRefreshRateFB_params *params = args; + + TRACE("%p, %p\n", params->session, params->displayRefreshRate); - WINE_TRACE("%p, %p\n", session, foveationState); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetFoveationEyeTrackedStateMETA(((wine_XrSession *)session)->session, foveationState); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetDisplayRefreshRateFB(wine_session_from_handle(params->session)->host_session, params->displayRefreshRate); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetHandMeshFB(XrHandTrackerEXT handTracker, XrHandTrackingMeshFB *mesh) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetEnvironmentDepthSwapchainStateMETA(void *args) { - XrResult ret; + struct xrGetEnvironmentDepthSwapchainStateMETA_params *params = args; - WINE_TRACE("%p, %p\n", handTracker, mesh); - ret = (*get_dispatch_table((uint64_t)(handTracker))).p_xrGetHandMeshFB(handTracker, mesh); - return ret; + TRACE("%p, %p\n", params->swapchain, params->state); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetEnvironmentDepthSwapchainStateMETA(params->swapchain, params->state); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrGetInputSourceLocalizedName(XrSession session, const XrInputSourceLocalizedNameGetInfo *getInfo, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetExportedLocalizationMapDataML(void *args) { - XrResult ret; + struct xrGetExportedLocalizationMapDataML_params *params = args; + + TRACE("%p, %u, %p, %p\n", params->map, params->bufferCapacityInput, params->bufferCountOutput, params->buffer); - WINE_TRACE("%p, %p, %u, %p, %p\n", session, getInfo, bufferCapacityInput, bufferCountOutput, buffer); - ret = xrGetInputSourceLocalizedName(((wine_XrSession *)session)->session, getInfo, bufferCapacityInput, bufferCountOutput, buffer); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetExportedLocalizationMapDataML(params->map, params->bufferCapacityInput, params->bufferCountOutput, params->buffer); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrGetInstanceProperties(XrInstance instance, XrInstanceProperties *instanceProperties) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetEyeGazesFB(void *args) { - XrResult ret; + struct xrGetEyeGazesFB_params *params = args; + + TRACE("%p, %p, %p\n", params->eyeTracker, params->gazeInfo, params->eyeGazes); - WINE_TRACE("%p, %p\n", instance, instanceProperties); - ret = xrGetInstanceProperties(((wine_XrInstance *)instance)->instance, instanceProperties); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetEyeGazesFB(params->eyeTracker, params->gazeInfo, params->eyeGazes); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetMarkerDetectorStateML(XrMarkerDetectorML markerDetector, XrMarkerDetectorStateML *state) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetFaceExpressionWeights2FB(void *args) { - XrResult ret; + struct xrGetFaceExpressionWeights2FB_params *params = args; - WINE_TRACE("%p, %p\n", markerDetector, state); - ret = (*get_dispatch_table((uint64_t)(markerDetector))).p_xrGetMarkerDetectorStateML(markerDetector, state); - return ret; + TRACE("%p, %p, %p\n", params->faceTracker, params->expressionInfo, params->expressionWeights); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetFaceExpressionWeights2FB(params->faceTracker, params->expressionInfo, params->expressionWeights); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetMarkerLengthML(XrMarkerDetectorML markerDetector, XrMarkerML marker, float *meters) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetFaceExpressionWeightsFB(void *args) { - XrResult ret; + struct xrGetFaceExpressionWeightsFB_params *params = args; + + TRACE("%p, %p, %p\n", params->faceTracker, params->expressionInfo, params->expressionWeights); - WINE_TRACE("%p, 0x%s, %p\n", markerDetector, wine_dbgstr_longlong(marker), meters); - ret = (*get_dispatch_table((uint64_t)(markerDetector))).p_xrGetMarkerLengthML(markerDetector, marker, meters); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetFaceExpressionWeightsFB(params->faceTracker, params->expressionInfo, params->expressionWeights); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetMarkerNumberML(XrMarkerDetectorML markerDetector, XrMarkerML marker, uint64_t *number) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetFacialExpressionsHTC(void *args) { - XrResult ret; + struct xrGetFacialExpressionsHTC_params *params = args; - WINE_TRACE("%p, 0x%s, %p\n", markerDetector, wine_dbgstr_longlong(marker), number); - ret = (*get_dispatch_table((uint64_t)(markerDetector))).p_xrGetMarkerNumberML(markerDetector, marker, number); - return ret; + TRACE("%p, %p\n", params->facialTracker, params->facialExpressions); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetFacialExpressionsHTC(params->facialTracker, params->facialExpressions); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetMarkerReprojectionErrorML(XrMarkerDetectorML markerDetector, XrMarkerML marker, float *reprojectionErrorMeters) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetFoveationEyeTrackedStateMETA(void *args) { - XrResult ret; + struct xrGetFoveationEyeTrackedStateMETA_params *params = args; + + TRACE("%p, %p\n", params->session, params->foveationState); - WINE_TRACE("%p, 0x%s, %p\n", markerDetector, wine_dbgstr_longlong(marker), reprojectionErrorMeters); - ret = (*get_dispatch_table((uint64_t)(markerDetector))).p_xrGetMarkerReprojectionErrorML(markerDetector, marker, reprojectionErrorMeters); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetFoveationEyeTrackedStateMETA(wine_session_from_handle(params->session)->host_session, params->foveationState); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetMarkerSizeVARJO(XrSession session, uint64_t markerId, XrExtent2Df *size) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetHandMeshFB(void *args) { - XrResult ret; + struct xrGetHandMeshFB_params *params = args; + + TRACE("%p, %p\n", params->handTracker, params->mesh); - WINE_TRACE("%p, 0x%s, %p\n", session, wine_dbgstr_longlong(markerId), size); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetMarkerSizeVARJO(((wine_XrSession *)session)->session, markerId, size); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetHandMeshFB(params->handTracker, params->mesh); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetMarkerStringML(XrMarkerDetectorML markerDetector, XrMarkerML marker, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetInputSourceLocalizedName(void *args) { - XrResult ret; + struct xrGetInputSourceLocalizedName_params *params = args; - WINE_TRACE("%p, 0x%s, %u, %p, %p\n", markerDetector, wine_dbgstr_longlong(marker), bufferCapacityInput, bufferCountOutput, buffer); - ret = (*get_dispatch_table((uint64_t)(markerDetector))).p_xrGetMarkerStringML(markerDetector, marker, bufferCapacityInput, bufferCountOutput, buffer); - return ret; + TRACE("%p, %p, %u, %p, %p\n", params->session, params->getInfo, params->bufferCapacityInput, params->bufferCountOutput, params->buffer); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetInputSourceLocalizedName(wine_session_from_handle(params->session)->host_session, params->getInfo, params->bufferCapacityInput, params->bufferCountOutput, params->buffer); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetMarkersML(XrMarkerDetectorML markerDetector, uint32_t markerCapacityInput, uint32_t *markerCountOutput, XrMarkerML *markers) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetInstanceProperties(void *args) { - XrResult ret; + struct xrGetInstanceProperties_params *params = args; + + TRACE("%p, %p\n", params->instance, params->instanceProperties); - WINE_TRACE("%p, %u, %p, %p\n", markerDetector, markerCapacityInput, markerCountOutput, markers); - ret = (*get_dispatch_table((uint64_t)(markerDetector))).p_xrGetMarkersML(markerDetector, markerCapacityInput, markerCountOutput, markers); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetInstanceProperties(wine_instance_from_handle(params->instance)->host_instance, params->instanceProperties); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetOpenGLGraphicsRequirementsKHR(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsOpenGLKHR *graphicsRequirements) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetMarkerDetectorStateML(void *args) { - XrResult ret; + struct xrGetMarkerDetectorStateML_params *params = args; - WINE_TRACE("%p, 0x%s, %p\n", instance, wine_dbgstr_longlong(systemId), graphicsRequirements); - ret = ((wine_XrInstance *)instance)->funcs.p_xrGetOpenGLGraphicsRequirementsKHR(((wine_XrInstance *)instance)->instance, systemId, graphicsRequirements); - return ret; + TRACE("%p, %p\n", params->markerDetector, params->state); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetMarkerDetectorStateML(params->markerDetector, params->state); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetPassthroughPreferencesMETA(XrSession session, XrPassthroughPreferencesMETA *preferences) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetMarkerLengthML(void *args) { - XrResult ret; + struct xrGetMarkerLengthML_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->markerDetector, wine_dbgstr_longlong(params->marker), params->meters); - WINE_TRACE("%p, %p\n", session, preferences); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetPassthroughPreferencesMETA(((wine_XrSession *)session)->session, preferences); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetMarkerLengthML(params->markerDetector, params->marker, params->meters); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetPerformanceMetricsStateMETA(XrSession session, XrPerformanceMetricsStateMETA *state) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetMarkerNumberML(void *args) { - XrResult ret; + struct xrGetMarkerNumberML_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->markerDetector, wine_dbgstr_longlong(params->marker), params->number); - WINE_TRACE("%p, %p\n", session, state); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetPerformanceMetricsStateMETA(((wine_XrSession *)session)->session, state); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetMarkerNumberML(params->markerDetector, params->marker, params->number); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetPlaneDetectionStateEXT(XrPlaneDetectorEXT planeDetector, XrPlaneDetectionStateEXT *state) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetMarkerReprojectionErrorML(void *args) { - XrResult ret; + struct xrGetMarkerReprojectionErrorML_params *params = args; - WINE_TRACE("%p, %p\n", planeDetector, state); - ret = (*get_dispatch_table((uint64_t)(planeDetector))).p_xrGetPlaneDetectionStateEXT(planeDetector, state); - return ret; + TRACE("%p, 0x%s, %p\n", params->markerDetector, wine_dbgstr_longlong(params->marker), params->reprojectionErrorMeters); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetMarkerReprojectionErrorML(params->markerDetector, params->marker, params->reprojectionErrorMeters); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetPlaneDetectionsEXT(XrPlaneDetectorEXT planeDetector, const XrPlaneDetectorGetInfoEXT *info, XrPlaneDetectorLocationsEXT *locations) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetMarkerSizeVARJO(void *args) { -#if defined(USE_STRUCT_CONVERSION) - XrResult result; - XrPlaneDetectorLocationsEXT_host locations_host; - WINE_TRACE("%p, %p, %p\n", planeDetector, info, locations); + struct xrGetMarkerSizeVARJO_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->session, wine_dbgstr_longlong(params->markerId), params->size); - convert_XrPlaneDetectorLocationsEXT_win_to_host(locations, &locations_host); - result = (*get_dispatch_table((uint64_t)(planeDetector))).p_xrGetPlaneDetectionsEXT(planeDetector, info, &locations_host); + params->result = g_xr_host_instance_dispatch_table.p_xrGetMarkerSizeVARJO(wine_session_from_handle(params->session)->host_session, params->markerId, params->size); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetMarkerStringML(void *args) +{ + struct xrGetMarkerStringML_params *params = args; - free_XrPlaneDetectorLocationsEXT(&locations_host); - return result; -#else - XrResult ret; + TRACE("%p, 0x%s, %u, %p, %p\n", params->markerDetector, wine_dbgstr_longlong(params->marker), params->bufferCapacityInput, params->bufferCountOutput, params->buffer); - WINE_TRACE("%p, %p, %p\n", planeDetector, info, locations); - ret = (*get_dispatch_table((uint64_t)(planeDetector))).p_xrGetPlaneDetectionsEXT(planeDetector, info, locations); - return ret; -#endif + params->result = g_xr_host_instance_dispatch_table.p_xrGetMarkerStringML(params->markerDetector, params->marker, params->bufferCapacityInput, params->bufferCountOutput, params->buffer); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetPlanePolygonBufferEXT(XrPlaneDetectorEXT planeDetector, uint64_t planeId, uint32_t polygonBufferIndex, XrPlaneDetectorPolygonBufferEXT *polygonBuffer) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetMarkersML(void *args) { - XrResult ret; + struct xrGetMarkersML_params *params = args; - WINE_TRACE("%p, 0x%s, %u, %p\n", planeDetector, wine_dbgstr_longlong(planeId), polygonBufferIndex, polygonBuffer); - ret = (*get_dispatch_table((uint64_t)(planeDetector))).p_xrGetPlanePolygonBufferEXT(planeDetector, planeId, polygonBufferIndex, polygonBuffer); - return ret; + TRACE("%p, %u, %p, %p\n", params->markerDetector, params->markerCapacityInput, params->markerCountOutput, params->markers); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetMarkersML(params->markerDetector, params->markerCapacityInput, params->markerCountOutput, params->markers); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetRecommendedLayerResolutionMETA(XrSession session, const XrRecommendedLayerResolutionGetInfoMETA *info, XrRecommendedLayerResolutionMETA *resolution) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetOpenGLGraphicsRequirementsKHR(void *args) { - XrResult ret; + struct xrGetOpenGLGraphicsRequirementsKHR_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->systemId), params->graphicsRequirements); - WINE_TRACE("%p, %p, %p\n", session, info, resolution); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetRecommendedLayerResolutionMETA(((wine_XrSession *)session)->session, info, resolution); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetOpenGLGraphicsRequirementsKHR(wine_instance_from_handle(params->instance)->host_instance, params->systemId, params->graphicsRequirements); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrGetReferenceSpaceBoundsRect(XrSession session, XrReferenceSpaceType referenceSpaceType, XrExtent2Df *bounds) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetPassthroughPreferencesMETA(void *args) { - XrResult ret; + struct xrGetPassthroughPreferencesMETA_params *params = args; - WINE_TRACE("%p, %#x, %p\n", session, referenceSpaceType, bounds); - ret = xrGetReferenceSpaceBoundsRect(((wine_XrSession *)session)->session, referenceSpaceType, bounds); - return ret; + TRACE("%p, %p\n", params->session, params->preferences); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetPassthroughPreferencesMETA(wine_session_from_handle(params->session)->host_session, params->preferences); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetRenderModelPropertiesFB(XrSession session, XrPath path, XrRenderModelPropertiesFB *properties) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetPerformanceMetricsStateMETA(void *args) { - XrResult ret; + struct xrGetPerformanceMetricsStateMETA_params *params = args; + + TRACE("%p, %p\n", params->session, params->state); - WINE_TRACE("%p, 0x%s, %p\n", session, wine_dbgstr_longlong(path), properties); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetRenderModelPropertiesFB(((wine_XrSession *)session)->session, path, properties); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetPerformanceMetricsStateMETA(wine_session_from_handle(params->session)->host_session, params->state); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetSceneComponentsMSFT(XrSceneMSFT scene, const XrSceneComponentsGetInfoMSFT *getInfo, XrSceneComponentsMSFT *components) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetPlaneDetectionStateEXT(void *args) { - XrResult ret; + struct xrGetPlaneDetectionStateEXT_params *params = args; + + TRACE("%p, %p\n", params->planeDetector, params->state); - WINE_TRACE("%p, %p, %p\n", scene, getInfo, components); - ret = (*get_dispatch_table((uint64_t)(scene))).p_xrGetSceneComponentsMSFT(scene, getInfo, components); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetPlaneDetectionStateEXT(params->planeDetector, params->state); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetSceneComputeStateMSFT(XrSceneObserverMSFT sceneObserver, XrSceneComputeStateMSFT *state) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetPlaneDetectionsEXT(void *args) { - XrResult ret; + struct xrGetPlaneDetectionsEXT_params *params = args; - WINE_TRACE("%p, %p\n", sceneObserver, state); - ret = (*get_dispatch_table((uint64_t)(sceneObserver))).p_xrGetSceneComputeStateMSFT(sceneObserver, state); - return ret; + TRACE("%p, %p, %p\n", params->planeDetector, params->info, params->locations); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetPlaneDetectionsEXT(params->planeDetector, params->info, params->locations); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetSceneMarkerDecodedStringMSFT(XrSceneMSFT scene, const XrUuidMSFT *markerId, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetPlanePolygonBufferEXT(void *args) { - XrResult ret; + struct xrGetPlanePolygonBufferEXT_params *params = args; + + TRACE("%p, 0x%s, %u, %p\n", params->planeDetector, wine_dbgstr_longlong(params->planeId), params->polygonBufferIndex, params->polygonBuffer); - WINE_TRACE("%p, %p, %u, %p, %p\n", scene, markerId, bufferCapacityInput, bufferCountOutput, buffer); - ret = (*get_dispatch_table((uint64_t)(scene))).p_xrGetSceneMarkerDecodedStringMSFT(scene, markerId, bufferCapacityInput, bufferCountOutput, buffer); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetPlanePolygonBufferEXT(params->planeDetector, params->planeId, params->polygonBufferIndex, params->polygonBuffer); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetSceneMarkerRawDataMSFT(XrSceneMSFT scene, const XrUuidMSFT *markerId, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, uint8_t *buffer) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetRecommendedLayerResolutionMETA(void *args) { - XrResult ret; + struct xrGetRecommendedLayerResolutionMETA_params *params = args; - WINE_TRACE("%p, %p, %u, %p, %p\n", scene, markerId, bufferCapacityInput, bufferCountOutput, buffer); - ret = (*get_dispatch_table((uint64_t)(scene))).p_xrGetSceneMarkerRawDataMSFT(scene, markerId, bufferCapacityInput, bufferCountOutput, buffer); - return ret; + TRACE("%p, %p, %p\n", params->session, params->info, params->resolution); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetRecommendedLayerResolutionMETA(wine_session_from_handle(params->session)->host_session, params->info, params->resolution); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetSceneMeshBuffersMSFT(XrSceneMSFT scene, const XrSceneMeshBuffersGetInfoMSFT *getInfo, XrSceneMeshBuffersMSFT *buffers) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetReferenceSpaceBoundsRect(void *args) { -#if defined(USE_STRUCT_CONVERSION) - XrResult result; - XrSceneMeshBuffersGetInfoMSFT_host getInfo_host; - WINE_TRACE("%p, %p, %p\n", scene, getInfo, buffers); + struct xrGetReferenceSpaceBoundsRect_params *params = args; + + TRACE("%p, %#x, %p\n", params->session, params->referenceSpaceType, params->bounds); - convert_XrSceneMeshBuffersGetInfoMSFT_win_to_host(getInfo, &getInfo_host); - result = (*get_dispatch_table((uint64_t)(scene))).p_xrGetSceneMeshBuffersMSFT(scene, &getInfo_host, buffers); + params->result = g_xr_host_instance_dispatch_table.p_xrGetReferenceSpaceBoundsRect(wine_session_from_handle(params->session)->host_session, params->referenceSpaceType, params->bounds); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ - return result; -#else - XrResult ret; +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetRenderModelPropertiesFB(void *args) +{ + struct xrGetRenderModelPropertiesFB_params *params = args; - WINE_TRACE("%p, %p, %p\n", scene, getInfo, buffers); - ret = (*get_dispatch_table((uint64_t)(scene))).p_xrGetSceneMeshBuffersMSFT(scene, getInfo, buffers); - return ret; -#endif + TRACE("%p, 0x%s, %p\n", params->session, wine_dbgstr_longlong(params->path), params->properties); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetRenderModelPropertiesFB(wine_session_from_handle(params->session)->host_session, params->path, params->properties); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSceneComponentsMSFT(void *args) +{ + struct xrGetSceneComponentsMSFT_params *params = args; + + TRACE("%p, %p, %p\n", params->scene, params->getInfo, params->components); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetSceneComponentsMSFT(params->scene, params->getInfo, params->components); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSceneComputeStateMSFT(void *args) +{ + struct xrGetSceneComputeStateMSFT_params *params = args; + + TRACE("%p, %p\n", params->sceneObserver, params->state); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetSceneComputeStateMSFT(params->sceneObserver, params->state); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSceneMarkerDecodedStringMSFT(void *args) +{ + struct xrGetSceneMarkerDecodedStringMSFT_params *params = args; + + TRACE("%p, %p, %u, %p, %p\n", params->scene, params->markerId, params->bufferCapacityInput, params->bufferCountOutput, params->buffer); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetSceneMarkerDecodedStringMSFT(params->scene, params->markerId, params->bufferCapacityInput, params->bufferCountOutput, params->buffer); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetSerializedSceneFragmentDataMSFT(XrSceneMSFT scene, const XrSerializedSceneFragmentDataGetInfoMSFT *getInfo, uint32_t countInput, uint32_t *readOutput, uint8_t *buffer) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSceneMarkerRawDataMSFT(void *args) { - XrResult ret; + struct xrGetSceneMarkerRawDataMSFT_params *params = args; + + TRACE("%p, %p, %u, %p, %p\n", params->scene, params->markerId, params->bufferCapacityInput, params->bufferCountOutput, params->buffer); - WINE_TRACE("%p, %p, %u, %p, %p\n", scene, getInfo, countInput, readOutput, buffer); - ret = (*get_dispatch_table((uint64_t)(scene))).p_xrGetSerializedSceneFragmentDataMSFT(scene, getInfo, countInput, readOutput, buffer); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetSceneMarkerRawDataMSFT(params->scene, params->markerId, params->bufferCapacityInput, params->bufferCountOutput, params->buffer); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetSpaceBoundary2DFB(XrSession session, XrSpace space, XrBoundary2DFB *boundary2DOutput) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSceneMeshBuffersMSFT(void *args) { - XrResult ret; + struct xrGetSceneMeshBuffersMSFT_params *params = args; + + TRACE("%p, %p, %p\n", params->scene, params->getInfo, params->buffers); - WINE_TRACE("%p, %p, %p\n", session, space, boundary2DOutput); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetSpaceBoundary2DFB(((wine_XrSession *)session)->session, space, boundary2DOutput); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetSceneMeshBuffersMSFT(params->scene, params->getInfo, params->buffers); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetSpaceBoundingBox2DFB(XrSession session, XrSpace space, XrRect2Df *boundingBox2DOutput) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSerializedSceneFragmentDataMSFT(void *args) { - XrResult ret; + struct xrGetSerializedSceneFragmentDataMSFT_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, space, boundingBox2DOutput); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetSpaceBoundingBox2DFB(((wine_XrSession *)session)->session, space, boundingBox2DOutput); - return ret; + TRACE("%p, %p, %u, %p, %p\n", params->scene, params->getInfo, params->countInput, params->readOutput, params->buffer); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetSerializedSceneFragmentDataMSFT(params->scene, params->getInfo, params->countInput, params->readOutput, params->buffer); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetSpaceBoundingBox3DFB(XrSession session, XrSpace space, XrRect3DfFB *boundingBox3DOutput) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSpaceBoundary2DFB(void *args) { - XrResult ret; + struct xrGetSpaceBoundary2DFB_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->space, params->boundary2DOutput); - WINE_TRACE("%p, %p, %p\n", session, space, boundingBox3DOutput); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetSpaceBoundingBox3DFB(((wine_XrSession *)session)->session, space, boundingBox3DOutput); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetSpaceBoundary2DFB(wine_session_from_handle(params->session)->host_session, params->space, params->boundary2DOutput); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetSpaceComponentStatusFB(XrSpace space, XrSpaceComponentTypeFB componentType, XrSpaceComponentStatusFB *status) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSpaceBoundingBox2DFB(void *args) { - XrResult ret; + struct xrGetSpaceBoundingBox2DFB_params *params = args; - WINE_TRACE("%p, %#x, %p\n", space, componentType, status); - ret = (*get_dispatch_table((uint64_t)(space))).p_xrGetSpaceComponentStatusFB(space, componentType, status); - return ret; + TRACE("%p, %p, %p\n", params->session, params->space, params->boundingBox2DOutput); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetSpaceBoundingBox2DFB(wine_session_from_handle(params->session)->host_session, params->space, params->boundingBox2DOutput); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetSpaceContainerFB(XrSession session, XrSpace space, XrSpaceContainerFB *spaceContainerOutput) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSpaceBoundingBox3DFB(void *args) { - XrResult ret; + struct xrGetSpaceBoundingBox3DFB_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->space, params->boundingBox3DOutput); - WINE_TRACE("%p, %p, %p\n", session, space, spaceContainerOutput); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetSpaceContainerFB(((wine_XrSession *)session)->session, space, spaceContainerOutput); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetSpaceBoundingBox3DFB(wine_session_from_handle(params->session)->host_session, params->space, params->boundingBox3DOutput); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetSpaceRoomLayoutFB(XrSession session, XrSpace space, XrRoomLayoutFB *roomLayoutOutput) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSpaceComponentStatusFB(void *args) { - XrResult ret; + struct xrGetSpaceComponentStatusFB_params *params = args; + + TRACE("%p, %#x, %p\n", params->space, params->componentType, params->status); - WINE_TRACE("%p, %p, %p\n", session, space, roomLayoutOutput); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetSpaceRoomLayoutFB(((wine_XrSession *)session)->session, space, roomLayoutOutput); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetSpaceComponentStatusFB(params->space, params->componentType, params->status); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetSpaceSemanticLabelsFB(XrSession session, XrSpace space, XrSemanticLabelsFB *semanticLabelsOutput) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSpaceContainerFB(void *args) { - XrResult ret; + struct xrGetSpaceContainerFB_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, space, semanticLabelsOutput); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetSpaceSemanticLabelsFB(((wine_XrSession *)session)->session, space, semanticLabelsOutput); - return ret; + TRACE("%p, %p, %p\n", params->session, params->space, params->spaceContainerOutput); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetSpaceContainerFB(wine_session_from_handle(params->session)->host_session, params->space, params->spaceContainerOutput); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetSpaceTriangleMeshMETA(XrSpace space, const XrSpaceTriangleMeshGetInfoMETA *getInfo, XrSpaceTriangleMeshMETA *triangleMeshOutput) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSpaceRoomLayoutFB(void *args) { - XrResult ret; + struct xrGetSpaceRoomLayoutFB_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->space, params->roomLayoutOutput); - WINE_TRACE("%p, %p, %p\n", space, getInfo, triangleMeshOutput); - ret = (*get_dispatch_table((uint64_t)(space))).p_xrGetSpaceTriangleMeshMETA(space, getInfo, triangleMeshOutput); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetSpaceRoomLayoutFB(wine_session_from_handle(params->session)->host_session, params->space, params->roomLayoutOutput); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetSpaceUserIdFB(XrSpaceUserFB user, XrSpaceUserIdFB *userId) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSpaceSemanticLabelsFB(void *args) { - XrResult ret; + struct xrGetSpaceSemanticLabelsFB_params *params = args; - WINE_TRACE("%p, %p\n", user, userId); - ret = (*get_dispatch_table((uint64_t)(user))).p_xrGetSpaceUserIdFB(user, userId); - return ret; + TRACE("%p, %p, %p\n", params->session, params->space, params->semanticLabelsOutput); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetSpaceSemanticLabelsFB(wine_session_from_handle(params->session)->host_session, params->space, params->semanticLabelsOutput); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetSpaceUuidFB(XrSpace space, XrUuidEXT *uuid) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSpaceTriangleMeshMETA(void *args) { - XrResult ret; + struct xrGetSpaceTriangleMeshMETA_params *params = args; + + TRACE("%p, %p, %p\n", params->space, params->getInfo, params->triangleMeshOutput); - WINE_TRACE("%p, %p\n", space, uuid); - ret = (*get_dispatch_table((uint64_t)(space))).p_xrGetSpaceUuidFB(space, uuid); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetSpaceTriangleMeshMETA(params->space, params->getInfo, params->triangleMeshOutput); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetSpatialAnchorNameHTC(XrSpace anchor, XrSpatialAnchorNameHTC *name) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSpaceUserIdFB(void *args) { - XrResult ret; + struct xrGetSpaceUserIdFB_params *params = args; + + TRACE("%p, %p\n", params->user, params->userId); - WINE_TRACE("%p, %p\n", anchor, name); - ret = (*get_dispatch_table((uint64_t)(anchor))).p_xrGetSpatialAnchorNameHTC(anchor, name); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetSpaceUserIdFB(params->user, params->userId); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetSpatialGraphNodeBindingPropertiesMSFT(XrSpatialGraphNodeBindingMSFT nodeBinding, const XrSpatialGraphNodeBindingPropertiesGetInfoMSFT *getInfo, XrSpatialGraphNodeBindingPropertiesMSFT *properties) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSpaceUuidFB(void *args) { - XrResult ret; + struct xrGetSpaceUuidFB_params *params = args; - WINE_TRACE("%p, %p, %p\n", nodeBinding, getInfo, properties); - ret = (*get_dispatch_table((uint64_t)(nodeBinding))).p_xrGetSpatialGraphNodeBindingPropertiesMSFT(nodeBinding, getInfo, properties); - return ret; + TRACE("%p, %p\n", params->space, params->uuid); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetSpaceUuidFB(params->space, params->uuid); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetSwapchainStateFB(XrSwapchain swapchain, XrSwapchainStateBaseHeaderFB *state) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSpatialAnchorNameHTC(void *args) { - XrResult ret; + struct xrGetSpatialAnchorNameHTC_params *params = args; + + TRACE("%p, %p\n", params->anchor, params->name); - WINE_TRACE("%p, %p\n", swapchain, state); - ret = ((wine_XrSwapchain *)swapchain)->wine_session->wine_instance->funcs.p_xrGetSwapchainStateFB(((wine_XrSwapchain *)swapchain)->swapchain, state); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetSpatialAnchorNameHTC(params->anchor, params->name); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrGetSystemProperties(XrInstance instance, XrSystemId systemId, XrSystemProperties *properties) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSpatialGraphNodeBindingPropertiesMSFT(void *args) { - XrResult ret; + struct xrGetSpatialGraphNodeBindingPropertiesMSFT_params *params = args; - WINE_TRACE("%p, 0x%s, %p\n", instance, wine_dbgstr_longlong(systemId), properties); - ret = xrGetSystemProperties(((wine_XrInstance *)instance)->instance, systemId, properties); - return ret; + TRACE("%p, %p, %p\n", params->nodeBinding, params->getInfo, params->properties); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetSpatialGraphNodeBindingPropertiesMSFT(params->nodeBinding, params->getInfo, params->properties); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrGetViewConfigurationProperties(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, XrViewConfigurationProperties *configurationProperties) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSwapchainStateFB(void *args) { - XrResult ret; + struct xrGetSwapchainStateFB_params *params = args; + + TRACE("%p, %p\n", params->swapchain, params->state); - WINE_TRACE("%p, 0x%s, %#x, %p\n", instance, wine_dbgstr_longlong(systemId), viewConfigurationType, configurationProperties); - ret = xrGetViewConfigurationProperties(((wine_XrInstance *)instance)->instance, systemId, viewConfigurationType, configurationProperties); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetSwapchainStateFB(wine_swapchain_from_handle(params->swapchain)->host_swapchain, params->state); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetVirtualKeyboardDirtyTexturesMETA(XrVirtualKeyboardMETA keyboard, uint32_t textureIdCapacityInput, uint32_t *textureIdCountOutput, uint64_t *textureIds) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSystem(void *args) { - XrResult ret; + struct xrGetSystem_params *params = args; + + TRACE("%p, %p, %p\n", params->instance, params->getInfo, params->systemId); - WINE_TRACE("%p, %u, %p, %p\n", keyboard, textureIdCapacityInput, textureIdCountOutput, textureIds); - ret = (*get_dispatch_table((uint64_t)(keyboard))).p_xrGetVirtualKeyboardDirtyTexturesMETA(keyboard, textureIdCapacityInput, textureIdCountOutput, textureIds); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetSystem(wine_instance_from_handle(params->instance)->host_instance, params->getInfo, params->systemId); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetVirtualKeyboardModelAnimationStatesMETA(XrVirtualKeyboardMETA keyboard, XrVirtualKeyboardModelAnimationStatesMETA *animationStates) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSystemProperties(void *args) { - XrResult ret; + struct xrGetSystemProperties_params *params = args; - WINE_TRACE("%p, %p\n", keyboard, animationStates); - ret = (*get_dispatch_table((uint64_t)(keyboard))).p_xrGetVirtualKeyboardModelAnimationStatesMETA(keyboard, animationStates); - return ret; + TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->systemId), params->properties); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetSystemProperties(wine_instance_from_handle(params->instance)->host_instance, params->systemId, params->properties); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetVirtualKeyboardScaleMETA(XrVirtualKeyboardMETA keyboard, float *scale) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetViewConfigurationProperties(void *args) { - XrResult ret; + struct xrGetViewConfigurationProperties_params *params = args; + + TRACE("%p, 0x%s, %#x, %p\n", params->instance, wine_dbgstr_longlong(params->systemId), params->viewConfigurationType, params->configurationProperties); - WINE_TRACE("%p, %p\n", keyboard, scale); - ret = (*get_dispatch_table((uint64_t)(keyboard))).p_xrGetVirtualKeyboardScaleMETA(keyboard, scale); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetViewConfigurationProperties(wine_instance_from_handle(params->instance)->host_instance, params->systemId, params->viewConfigurationType, params->configurationProperties); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetVirtualKeyboardTextureDataMETA(XrVirtualKeyboardMETA keyboard, uint64_t textureId, XrVirtualKeyboardTextureDataMETA *textureData) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetVirtualKeyboardDirtyTexturesMETA(void *args) { - XrResult ret; + struct xrGetVirtualKeyboardDirtyTexturesMETA_params *params = args; - WINE_TRACE("%p, 0x%s, %p\n", keyboard, wine_dbgstr_longlong(textureId), textureData); - ret = (*get_dispatch_table((uint64_t)(keyboard))).p_xrGetVirtualKeyboardTextureDataMETA(keyboard, textureId, textureData); - return ret; + TRACE("%p, %u, %p, %p\n", params->keyboard, params->textureIdCapacityInput, params->textureIdCountOutput, params->textureIds); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetVirtualKeyboardDirtyTexturesMETA(params->keyboard, params->textureIdCapacityInput, params->textureIdCountOutput, params->textureIds); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetVisibilityMaskKHR(XrSession session, XrViewConfigurationType viewConfigurationType, uint32_t viewIndex, XrVisibilityMaskTypeKHR visibilityMaskType, XrVisibilityMaskKHR *visibilityMask) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetVirtualKeyboardModelAnimationStatesMETA(void *args) { - XrResult ret; + struct xrGetVirtualKeyboardModelAnimationStatesMETA_params *params = args; + + TRACE("%p, %p\n", params->keyboard, params->animationStates); - WINE_TRACE("%p, %#x, %u, %#x, %p\n", session, viewConfigurationType, viewIndex, visibilityMaskType, visibilityMask); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetVisibilityMaskKHR(((wine_XrSession *)session)->session, viewConfigurationType, viewIndex, visibilityMaskType, visibilityMask); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetVirtualKeyboardModelAnimationStatesMETA(params->keyboard, params->animationStates); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetVulkanGraphicsRequirements2KHR(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsVulkanKHR *graphicsRequirements) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetVirtualKeyboardScaleMETA(void *args) { - XrResult ret; + struct xrGetVirtualKeyboardScaleMETA_params *params = args; + + TRACE("%p, %p\n", params->keyboard, params->scale); - WINE_TRACE("%p, 0x%s, %p\n", instance, wine_dbgstr_longlong(systemId), graphicsRequirements); - ret = ((wine_XrInstance *)instance)->funcs.p_xrGetVulkanGraphicsRequirements2KHR(((wine_XrInstance *)instance)->instance, systemId, graphicsRequirements); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrGetVirtualKeyboardScaleMETA(params->keyboard, params->scale); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrGetVulkanGraphicsRequirementsKHR(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsVulkanKHR *graphicsRequirements) +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetVirtualKeyboardTextureDataMETA(void *args) { - XrResult ret; + struct xrGetVirtualKeyboardTextureDataMETA_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->keyboard, wine_dbgstr_longlong(params->textureId), params->textureData); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetVirtualKeyboardTextureDataMETA(params->keyboard, params->textureId, params->textureData); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetVisibilityMaskKHR(void *args) +{ + struct xrGetVisibilityMaskKHR_params *params = args; + + TRACE("%p, %#x, %u, %#x, %p\n", params->session, params->viewConfigurationType, params->viewIndex, params->visibilityMaskType, params->visibilityMask); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetVisibilityMaskKHR(wine_session_from_handle(params->session)->host_session, params->viewConfigurationType, params->viewIndex, params->visibilityMaskType, params->visibilityMask); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetVulkanDeviceExtensionsKHR(void *args) +{ + struct xrGetVulkanDeviceExtensionsKHR_params *params = args; + + TRACE("%p, 0x%s, %u, %p, %p\n", params->instance, wine_dbgstr_longlong(params->systemId), params->bufferCapacityInput, params->bufferCountOutput, params->buffer); + + params->result = wine_xrGetVulkanDeviceExtensionsKHR(params->instance, params->systemId, params->bufferCapacityInput, params->bufferCountOutput, params->buffer); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetVulkanGraphicsDevice2KHR(void *args) +{ + struct xrGetVulkanGraphicsDevice2KHR_params *params = args; + + TRACE("%p, %p, %p\n", params->instance, params->getInfo, params->vulkanPhysicalDevice); + + params->result = wine_xrGetVulkanGraphicsDevice2KHR(params->instance, params->getInfo, params->vulkanPhysicalDevice); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetVulkanGraphicsDeviceKHR(void *args) +{ + struct xrGetVulkanGraphicsDeviceKHR_params *params = args; + + TRACE("%p, 0x%s, %p, %p\n", params->instance, wine_dbgstr_longlong(params->systemId), params->vkInstance, params->vkPhysicalDevice); + + params->result = wine_xrGetVulkanGraphicsDeviceKHR(params->instance, params->systemId, params->vkInstance, params->vkPhysicalDevice); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetVulkanGraphicsRequirements2KHR(void *args) +{ + struct xrGetVulkanGraphicsRequirements2KHR_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->systemId), params->graphicsRequirements); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetVulkanGraphicsRequirements2KHR(wine_instance_from_handle(params->instance)->host_instance, params->systemId, params->graphicsRequirements); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetVulkanGraphicsRequirementsKHR(void *args) +{ + struct xrGetVulkanGraphicsRequirementsKHR_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->systemId), params->graphicsRequirements); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetVulkanGraphicsRequirementsKHR(wine_instance_from_handle(params->instance)->host_instance, params->systemId, params->graphicsRequirements); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetVulkanInstanceExtensionsKHR(void *args) +{ + struct xrGetVulkanInstanceExtensionsKHR_params *params = args; + + TRACE("%p, 0x%s, %u, %p, %p\n", params->instance, wine_dbgstr_longlong(params->systemId), params->bufferCapacityInput, params->bufferCountOutput, params->buffer); + + params->result = wine_xrGetVulkanInstanceExtensionsKHR(params->instance, params->systemId, params->bufferCapacityInput, params->bufferCountOutput, params->buffer); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrImportLocalizationMapML(void *args) +{ + struct xrImportLocalizationMapML_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->importInfo, params->mapUuid); - WINE_TRACE("%p, 0x%s, %p\n", instance, wine_dbgstr_longlong(systemId), graphicsRequirements); - ret = ((wine_XrInstance *)instance)->funcs.p_xrGetVulkanGraphicsRequirementsKHR(((wine_XrInstance *)instance)->instance, systemId, graphicsRequirements); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrImportLocalizationMapML(wine_session_from_handle(params->session)->host_session, params->importInfo, params->mapUuid); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrImportLocalizationMapML(XrSession session, const XrLocalizationMapImportInfoML *importInfo, XrUuidEXT *mapUuid) +#ifdef _WIN64 +static NTSTATUS thunk64_xrLoadControllerModelMSFT(void *args) { - XrResult ret; + struct xrLoadControllerModelMSFT_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, importInfo, mapUuid); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrImportLocalizationMapML(((wine_XrSession *)session)->session, importInfo, mapUuid); - return ret; + TRACE("%p, 0x%s, %u, %p, %p\n", params->session, wine_dbgstr_longlong(params->modelKey), params->bufferCapacityInput, params->bufferCountOutput, params->buffer); + + params->result = g_xr_host_instance_dispatch_table.p_xrLoadControllerModelMSFT(wine_session_from_handle(params->session)->host_session, params->modelKey, params->bufferCapacityInput, params->bufferCountOutput, params->buffer); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrLoadControllerModelMSFT(XrSession session, XrControllerModelKeyMSFT modelKey, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, uint8_t *buffer) +#ifdef _WIN64 +static NTSTATUS thunk64_xrLoadRenderModelFB(void *args) { - XrResult ret; + struct xrLoadRenderModelFB_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->info, params->buffer); - WINE_TRACE("%p, 0x%s, %u, %p, %p\n", session, wine_dbgstr_longlong(modelKey), bufferCapacityInput, bufferCountOutput, buffer); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrLoadControllerModelMSFT(((wine_XrSession *)session)->session, modelKey, bufferCapacityInput, bufferCountOutput, buffer); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrLoadRenderModelFB(wine_session_from_handle(params->session)->host_session, params->info, params->buffer); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrLoadRenderModelFB(XrSession session, const XrRenderModelLoadInfoFB *info, XrRenderModelBufferFB *buffer) +#ifdef _WIN64 +static NTSTATUS thunk64_xrLocateBodyJointsFB(void *args) { - XrResult ret; + struct xrLocateBodyJointsFB_params *params = args; + + TRACE("%p, %p, %p\n", params->bodyTracker, params->locateInfo, params->locations); - WINE_TRACE("%p, %p, %p\n", session, info, buffer); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrLoadRenderModelFB(((wine_XrSession *)session)->session, info, buffer); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrLocateBodyJointsFB(params->bodyTracker, params->locateInfo, params->locations); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrLocateBodyJointsFB(XrBodyTrackerFB bodyTracker, const XrBodyJointsLocateInfoFB *locateInfo, XrBodyJointLocationsFB *locations) +#ifdef _WIN64 +static NTSTATUS thunk64_xrLocateHandJointsEXT(void *args) { - XrResult ret; + struct xrLocateHandJointsEXT_params *params = args; - WINE_TRACE("%p, %p, %p\n", bodyTracker, locateInfo, locations); - ret = (*get_dispatch_table((uint64_t)(bodyTracker))).p_xrLocateBodyJointsFB(bodyTracker, locateInfo, locations); - return ret; + TRACE("%p, %p, %p\n", params->handTracker, params->locateInfo, params->locations); + + params->result = g_xr_host_instance_dispatch_table.p_xrLocateHandJointsEXT(params->handTracker, params->locateInfo, params->locations); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrLocateHandJointsEXT(XrHandTrackerEXT handTracker, const XrHandJointsLocateInfoEXT *locateInfo, XrHandJointLocationsEXT *locations) +#ifdef _WIN64 +static NTSTATUS thunk64_xrLocateSceneComponentsMSFT(void *args) { - XrResult ret; + struct xrLocateSceneComponentsMSFT_params *params = args; + + TRACE("%p, %p, %p\n", params->scene, params->locateInfo, params->locations); - WINE_TRACE("%p, %p, %p\n", handTracker, locateInfo, locations); - ret = (*get_dispatch_table((uint64_t)(handTracker))).p_xrLocateHandJointsEXT(handTracker, locateInfo, locations); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrLocateSceneComponentsMSFT(params->scene, params->locateInfo, params->locations); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrLocateSceneComponentsMSFT(XrSceneMSFT scene, const XrSceneComponentsLocateInfoMSFT *locateInfo, XrSceneComponentLocationsMSFT *locations) +#ifdef _WIN64 +static NTSTATUS thunk64_xrLocateSpace(void *args) { - XrResult ret; + struct xrLocateSpace_params *params = args; - WINE_TRACE("%p, %p, %p\n", scene, locateInfo, locations); - ret = (*get_dispatch_table((uint64_t)(scene))).p_xrLocateSceneComponentsMSFT(scene, locateInfo, locations); - return ret; + TRACE("%p, %p, 0x%s, %p\n", params->space, params->baseSpace, wine_dbgstr_longlong(params->time), params->location); + + params->result = g_xr_host_instance_dispatch_table.p_xrLocateSpace(params->space, params->baseSpace, params->time, params->location); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrLocateSpace(XrSpace space, XrSpace baseSpace, XrTime time, XrSpaceLocation *location) +#ifdef _WIN64 +static NTSTATUS thunk64_xrLocateSpaces(void *args) { - XrResult ret; + struct xrLocateSpaces_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->locateInfo, params->spaceLocations); - WINE_TRACE("%p, %p, 0x%s, %p\n", space, baseSpace, wine_dbgstr_longlong(time), location); - ret = xrLocateSpace(space, baseSpace, time, location); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrLocateSpaces(wine_session_from_handle(params->session)->host_session, params->locateInfo, params->spaceLocations); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrLocateSpaces(XrSession session, const XrSpacesLocateInfo *locateInfo, XrSpaceLocations *spaceLocations) +#ifdef _WIN64 +static NTSTATUS thunk64_xrLocateSpacesKHR(void *args) { - XrResult ret; + struct xrLocateSpacesKHR_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->locateInfo, params->spaceLocations); - WINE_TRACE("%p, %p, %p\n", session, locateInfo, spaceLocations); - ret = xrLocateSpaces(((wine_XrSession *)session)->session, locateInfo, spaceLocations); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrLocateSpacesKHR(wine_session_from_handle(params->session)->host_session, params->locateInfo, params->spaceLocations); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrLocateSpacesKHR(XrSession session, const XrSpacesLocateInfo *locateInfo, XrSpaceLocations *spaceLocations) +#ifdef _WIN64 +static NTSTATUS thunk64_xrLocateViews(void *args) { - XrResult ret; + struct xrLocateViews_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, locateInfo, spaceLocations); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrLocateSpacesKHR(((wine_XrSession *)session)->session, locateInfo, spaceLocations); - return ret; + TRACE("%p, %p, %p, %u, %p, %p\n", params->session, params->viewLocateInfo, params->viewState, params->viewCapacityInput, params->viewCountOutput, params->views); + + params->result = g_xr_host_instance_dispatch_table.p_xrLocateViews(wine_session_from_handle(params->session)->host_session, params->viewLocateInfo, params->viewState, params->viewCapacityInput, params->viewCountOutput, params->views); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrLocateViews(XrSession session, const XrViewLocateInfo *viewLocateInfo, XrViewState *viewState, uint32_t viewCapacityInput, uint32_t *viewCountOutput, XrView *views) +#ifdef _WIN64 +static NTSTATUS thunk64_xrPassthroughLayerPauseFB(void *args) { - XrResult ret; + struct xrPassthroughLayerPauseFB_params *params = args; + + TRACE("%p\n", params->layer); - WINE_TRACE("%p, %p, %p, %u, %p, %p\n", session, viewLocateInfo, viewState, viewCapacityInput, viewCountOutput, views); - ret = xrLocateViews(((wine_XrSession *)session)->session, viewLocateInfo, viewState, viewCapacityInput, viewCountOutput, views); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrPassthroughLayerPauseFB(params->layer); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrPassthroughLayerPauseFB(XrPassthroughLayerFB layer) +#ifdef _WIN64 +static NTSTATUS thunk64_xrPassthroughLayerResumeFB(void *args) { - XrResult ret; + struct xrPassthroughLayerResumeFB_params *params = args; - WINE_TRACE("%p\n", layer); - ret = (*get_dispatch_table((uint64_t)(layer))).p_xrPassthroughLayerPauseFB(layer); - return ret; + TRACE("%p\n", params->layer); + + params->result = g_xr_host_instance_dispatch_table.p_xrPassthroughLayerResumeFB(params->layer); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrPassthroughLayerResumeFB(XrPassthroughLayerFB layer) +#ifdef _WIN64 +static NTSTATUS thunk64_xrPassthroughLayerSetKeyboardHandsIntensityFB(void *args) { - XrResult ret; + struct xrPassthroughLayerSetKeyboardHandsIntensityFB_params *params = args; + + TRACE("%p, %p\n", params->layer, params->intensity); - WINE_TRACE("%p\n", layer); - ret = (*get_dispatch_table((uint64_t)(layer))).p_xrPassthroughLayerResumeFB(layer); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrPassthroughLayerSetKeyboardHandsIntensityFB(params->layer, params->intensity); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrPassthroughLayerSetKeyboardHandsIntensityFB(XrPassthroughLayerFB layer, const XrPassthroughKeyboardHandsIntensityFB *intensity) +#ifdef _WIN64 +static NTSTATUS thunk64_xrPassthroughLayerSetStyleFB(void *args) { - XrResult ret; + struct xrPassthroughLayerSetStyleFB_params *params = args; + + TRACE("%p, %p\n", params->layer, params->style); - WINE_TRACE("%p, %p\n", layer, intensity); - ret = (*get_dispatch_table((uint64_t)(layer))).p_xrPassthroughLayerSetKeyboardHandsIntensityFB(layer, intensity); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrPassthroughLayerSetStyleFB(params->layer, params->style); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrPassthroughLayerSetStyleFB(XrPassthroughLayerFB layer, const XrPassthroughStyleFB *style) +#ifdef _WIN64 +static NTSTATUS thunk64_xrPassthroughPauseFB(void *args) { - XrResult ret; + struct xrPassthroughPauseFB_params *params = args; - WINE_TRACE("%p, %p\n", layer, style); - ret = (*get_dispatch_table((uint64_t)(layer))).p_xrPassthroughLayerSetStyleFB(layer, style); - return ret; + TRACE("%p\n", params->passthrough); + + params->result = g_xr_host_instance_dispatch_table.p_xrPassthroughPauseFB(params->passthrough); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrPassthroughPauseFB(XrPassthroughFB passthrough) +#ifdef _WIN64 +static NTSTATUS thunk64_xrPassthroughStartFB(void *args) { - XrResult ret; + struct xrPassthroughStartFB_params *params = args; + + TRACE("%p\n", params->passthrough); - WINE_TRACE("%p\n", passthrough); - ret = (*get_dispatch_table((uint64_t)(passthrough))).p_xrPassthroughPauseFB(passthrough); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrPassthroughStartFB(params->passthrough); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrPassthroughStartFB(XrPassthroughFB passthrough) +#ifdef _WIN64 +static NTSTATUS thunk64_xrPathToString(void *args) { - XrResult ret; + struct xrPathToString_params *params = args; - WINE_TRACE("%p\n", passthrough); - ret = (*get_dispatch_table((uint64_t)(passthrough))).p_xrPassthroughStartFB(passthrough); - return ret; + TRACE("%p, 0x%s, %u, %p, %p\n", params->instance, wine_dbgstr_longlong(params->path), params->bufferCapacityInput, params->bufferCountOutput, params->buffer); + + params->result = g_xr_host_instance_dispatch_table.p_xrPathToString(wine_instance_from_handle(params->instance)->host_instance, params->path, params->bufferCapacityInput, params->bufferCountOutput, params->buffer); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrPathToString(XrInstance instance, XrPath path, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer) +#ifdef _WIN64 +static NTSTATUS thunk64_xrPerfSettingsSetPerformanceLevelEXT(void *args) { - XrResult ret; + struct xrPerfSettingsSetPerformanceLevelEXT_params *params = args; + + TRACE("%p, %#x, %#x\n", params->session, params->domain, params->level); - WINE_TRACE("%p, 0x%s, %u, %p, %p\n", instance, wine_dbgstr_longlong(path), bufferCapacityInput, bufferCountOutput, buffer); - ret = xrPathToString(((wine_XrInstance *)instance)->instance, path, bufferCapacityInput, bufferCountOutput, buffer); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrPerfSettingsSetPerformanceLevelEXT(wine_session_from_handle(params->session)->host_session, params->domain, params->level); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrPerfSettingsSetPerformanceLevelEXT(XrSession session, XrPerfSettingsDomainEXT domain, XrPerfSettingsLevelEXT level) +#ifdef _WIN64 +static NTSTATUS thunk64_xrPersistSpatialAnchorMSFT(void *args) { - XrResult ret; + struct xrPersistSpatialAnchorMSFT_params *params = args; + + TRACE("%p, %p\n", params->spatialAnchorStore, params->spatialAnchorPersistenceInfo); - WINE_TRACE("%p, %#x, %#x\n", session, domain, level); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrPerfSettingsSetPerformanceLevelEXT(((wine_XrSession *)session)->session, domain, level); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrPersistSpatialAnchorMSFT(params->spatialAnchorStore, params->spatialAnchorPersistenceInfo); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrPersistSpatialAnchorMSFT(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, const XrSpatialAnchorPersistenceInfoMSFT *spatialAnchorPersistenceInfo) +#ifdef _WIN64 +static NTSTATUS thunk64_xrPollEvent(void *args) { - XrResult ret; + struct xrPollEvent_params *params = args; - WINE_TRACE("%p, %p\n", spatialAnchorStore, spatialAnchorPersistenceInfo); - ret = (*get_dispatch_table((uint64_t)(spatialAnchorStore))).p_xrPersistSpatialAnchorMSFT(spatialAnchorStore, spatialAnchorPersistenceInfo); - return ret; + TRACE("%p, %p\n", params->instance, params->eventData); + + params->result = g_xr_host_instance_dispatch_table.p_xrPollEvent(wine_instance_from_handle(params->instance)->host_instance, params->eventData); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrPollFutureEXT(XrInstance instance, const XrFuturePollInfoEXT *pollInfo, XrFuturePollResultEXT *pollResult) +#ifdef _WIN64 +static NTSTATUS thunk64_xrPollFutureEXT(void *args) { - XrResult ret; + struct xrPollFutureEXT_params *params = args; + + TRACE("%p, %p, %p\n", params->instance, params->pollInfo, params->pollResult); - WINE_TRACE("%p, %p, %p\n", instance, pollInfo, pollResult); - ret = ((wine_XrInstance *)instance)->funcs.p_xrPollFutureEXT(((wine_XrInstance *)instance)->instance, pollInfo, pollResult); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrPollFutureEXT(wine_instance_from_handle(params->instance)->host_instance, params->pollInfo, params->pollResult); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrQueryLocalizationMapsML(XrSession session, const XrLocalizationMapQueryInfoBaseHeaderML *queryInfo, uint32_t mapCapacityInput, uint32_t *mapCountOutput, XrLocalizationMapML *maps) +#ifdef _WIN64 +static NTSTATUS thunk64_xrQueryLocalizationMapsML(void *args) { - XrResult ret; + struct xrQueryLocalizationMapsML_params *params = args; - WINE_TRACE("%p, %p, %u, %p, %p\n", session, queryInfo, mapCapacityInput, mapCountOutput, maps); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrQueryLocalizationMapsML(((wine_XrSession *)session)->session, queryInfo, mapCapacityInput, mapCountOutput, maps); - return ret; + TRACE("%p, %p, %u, %p, %p\n", params->session, params->queryInfo, params->mapCapacityInput, params->mapCountOutput, params->maps); + + params->result = g_xr_host_instance_dispatch_table.p_xrQueryLocalizationMapsML(wine_session_from_handle(params->session)->host_session, params->queryInfo, params->mapCapacityInput, params->mapCountOutput, params->maps); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrQueryPerformanceMetricsCounterMETA(XrSession session, XrPath counterPath, XrPerformanceMetricsCounterMETA *counter) +#ifdef _WIN64 +static NTSTATUS thunk64_xrQueryPerformanceMetricsCounterMETA(void *args) { - XrResult ret; + struct xrQueryPerformanceMetricsCounterMETA_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->session, wine_dbgstr_longlong(params->counterPath), params->counter); - WINE_TRACE("%p, 0x%s, %p\n", session, wine_dbgstr_longlong(counterPath), counter); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrQueryPerformanceMetricsCounterMETA(((wine_XrSession *)session)->session, counterPath, counter); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrQueryPerformanceMetricsCounterMETA(wine_session_from_handle(params->session)->host_session, params->counterPath, params->counter); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrQuerySpacesFB(XrSession session, const XrSpaceQueryInfoBaseHeaderFB *info, XrAsyncRequestIdFB *requestId) +#ifdef _WIN64 +static NTSTATUS thunk64_xrQuerySpacesFB(void *args) { - XrResult ret; + struct xrQuerySpacesFB_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->info, params->requestId); - WINE_TRACE("%p, %p, %p\n", session, info, requestId); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrQuerySpacesFB(((wine_XrSession *)session)->session, info, requestId); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrQuerySpacesFB(wine_session_from_handle(params->session)->host_session, params->info, params->requestId); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrQuerySystemTrackedKeyboardFB(XrSession session, const XrKeyboardTrackingQueryFB *queryInfo, XrKeyboardTrackingDescriptionFB *keyboard) +#ifdef _WIN64 +static NTSTATUS thunk64_xrQuerySystemTrackedKeyboardFB(void *args) { -#if defined(USE_STRUCT_CONVERSION) - XrResult result; - XrKeyboardTrackingDescriptionFB_host keyboard_host; - WINE_TRACE("%p, %p, %p\n", session, queryInfo, keyboard); + struct xrQuerySystemTrackedKeyboardFB_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->queryInfo, params->keyboard); + + params->result = g_xr_host_instance_dispatch_table.p_xrQuerySystemTrackedKeyboardFB(wine_session_from_handle(params->session)->host_session, params->queryInfo, params->keyboard); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ - result = ((wine_XrSession *)session)->wine_instance->funcs.p_xrQuerySystemTrackedKeyboardFB(((wine_XrSession *)session)->session, queryInfo, &keyboard_host); +#ifdef _WIN64 +static NTSTATUS thunk64_xrReleaseSwapchainImage(void *args) +{ + struct xrReleaseSwapchainImage_params *params = args; - convert_XrKeyboardTrackingDescriptionFB_host_to_win(&keyboard_host, keyboard); - return result; -#else - XrResult ret; + TRACE("%p, %p\n", params->swapchain, params->releaseInfo); - WINE_TRACE("%p, %p, %p\n", session, queryInfo, keyboard); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrQuerySystemTrackedKeyboardFB(((wine_XrSession *)session)->session, queryInfo, keyboard); - return ret; -#endif + params->result = g_xr_host_instance_dispatch_table.p_xrReleaseSwapchainImage(wine_swapchain_from_handle(params->swapchain)->host_swapchain, params->releaseInfo); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrRequestDisplayRefreshRateFB(XrSession session, float displayRefreshRate) +#ifdef _WIN64 +static NTSTATUS thunk64_xrRequestDisplayRefreshRateFB(void *args) { - XrResult ret; + struct xrRequestDisplayRefreshRateFB_params *params = args; + + TRACE("%p, %f\n", params->session, params->displayRefreshRate); - WINE_TRACE("%p, %f\n", session, displayRefreshRate); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrRequestDisplayRefreshRateFB(((wine_XrSession *)session)->session, displayRefreshRate); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrRequestDisplayRefreshRateFB(wine_session_from_handle(params->session)->host_session, params->displayRefreshRate); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrRequestExitSession(XrSession session) +#ifdef _WIN64 +static NTSTATUS thunk64_xrRequestExitSession(void *args) { - XrResult ret; + struct xrRequestExitSession_params *params = args; - WINE_TRACE("%p\n", session); - ret = xrRequestExitSession(((wine_XrSession *)session)->session); - return ret; + TRACE("%p\n", params->session); + + params->result = g_xr_host_instance_dispatch_table.p_xrRequestExitSession(wine_session_from_handle(params->session)->host_session); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrRequestMapLocalizationML(XrSession session, const XrMapLocalizationRequestInfoML *requestInfo) +#ifdef _WIN64 +static NTSTATUS thunk64_xrRequestMapLocalizationML(void *args) { - XrResult ret; + struct xrRequestMapLocalizationML_params *params = args; + + TRACE("%p, %p\n", params->session, params->requestInfo); - WINE_TRACE("%p, %p\n", session, requestInfo); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrRequestMapLocalizationML(((wine_XrSession *)session)->session, requestInfo); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrRequestMapLocalizationML(wine_session_from_handle(params->session)->host_session, params->requestInfo); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrRequestSceneCaptureFB(XrSession session, const XrSceneCaptureRequestInfoFB *info, XrAsyncRequestIdFB *requestId) +#ifdef _WIN64 +static NTSTATUS thunk64_xrRequestSceneCaptureFB(void *args) { - XrResult ret; + struct xrRequestSceneCaptureFB_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, info, requestId); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrRequestSceneCaptureFB(((wine_XrSession *)session)->session, info, requestId); - return ret; + TRACE("%p, %p, %p\n", params->session, params->info, params->requestId); + + params->result = g_xr_host_instance_dispatch_table.p_xrRequestSceneCaptureFB(wine_session_from_handle(params->session)->host_session, params->info, params->requestId); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrResultToString(XrInstance instance, XrResult value, char buffer[]) +#ifdef _WIN64 +static NTSTATUS thunk64_xrResultToString(void *args) { - XrResult ret; + struct xrResultToString_params *params = args; + + TRACE("%p, %#x, %p\n", params->instance, params->value, params->buffer); - WINE_TRACE("%p, %#x, %p\n", instance, value, buffer); - ret = xrResultToString(((wine_XrInstance *)instance)->instance, value, buffer); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrResultToString(wine_instance_from_handle(params->instance)->host_instance, params->value, params->buffer); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrRetrieveSpaceQueryResultsFB(XrSession session, XrAsyncRequestIdFB requestId, XrSpaceQueryResultsFB *results) +#ifdef _WIN64 +static NTSTATUS thunk64_xrRetrieveSpaceQueryResultsFB(void *args) { - XrResult ret; + struct xrRetrieveSpaceQueryResultsFB_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->session, wine_dbgstr_longlong(params->requestId), params->results); - WINE_TRACE("%p, 0x%s, %p\n", session, wine_dbgstr_longlong(requestId), results); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrRetrieveSpaceQueryResultsFB(((wine_XrSession *)session)->session, requestId, results); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrRetrieveSpaceQueryResultsFB(wine_session_from_handle(params->session)->host_session, params->requestId, params->results); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSaveSpaceFB(XrSession session, const XrSpaceSaveInfoFB *info, XrAsyncRequestIdFB *requestId) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSaveSpaceFB(void *args) { - XrResult ret; + struct xrSaveSpaceFB_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, info, requestId); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrSaveSpaceFB(((wine_XrSession *)session)->session, info, requestId); - return ret; + TRACE("%p, %p, %p\n", params->session, params->info, params->requestId); + + params->result = g_xr_host_instance_dispatch_table.p_xrSaveSpaceFB(wine_session_from_handle(params->session)->host_session, params->info, params->requestId); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSaveSpaceListFB(XrSession session, const XrSpaceListSaveInfoFB *info, XrAsyncRequestIdFB *requestId) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSaveSpaceListFB(void *args) { - XrResult ret; + struct xrSaveSpaceListFB_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->info, params->requestId); - WINE_TRACE("%p, %p, %p\n", session, info, requestId); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrSaveSpaceListFB(((wine_XrSession *)session)->session, info, requestId); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrSaveSpaceListFB(wine_session_from_handle(params->session)->host_session, params->info, params->requestId); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSendVirtualKeyboardInputMETA(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardInputInfoMETA *info, XrPosef *interactorRootPose) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSendVirtualKeyboardInputMETA(void *args) { - XrResult ret; + struct xrSendVirtualKeyboardInputMETA_params *params = args; - WINE_TRACE("%p, %p, %p\n", keyboard, info, interactorRootPose); - ret = (*get_dispatch_table((uint64_t)(keyboard))).p_xrSendVirtualKeyboardInputMETA(keyboard, info, interactorRootPose); - return ret; + TRACE("%p, %p, %p\n", params->keyboard, params->info, params->interactorRootPose); + + params->result = g_xr_host_instance_dispatch_table.p_xrSendVirtualKeyboardInputMETA(params->keyboard, params->info, params->interactorRootPose); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSetColorSpaceFB(XrSession session, const XrColorSpaceFB colorSpace) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetColorSpaceFB(void *args) { - XrResult ret; + struct xrSetColorSpaceFB_params *params = args; + + TRACE("%p, %#x\n", params->session, params->colorSpace); - WINE_TRACE("%p, %#x\n", session, colorSpace); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetColorSpaceFB(((wine_XrSession *)session)->session, colorSpace); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrSetColorSpaceFB(wine_session_from_handle(params->session)->host_session, params->colorSpace); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSetDigitalLensControlALMALENCE(XrSession session, const XrDigitalLensControlALMALENCE *digitalLensControl) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetDigitalLensControlALMALENCE(void *args) { - XrResult ret; + struct xrSetDigitalLensControlALMALENCE_params *params = args; + + TRACE("%p, %p\n", params->session, params->digitalLensControl); - WINE_TRACE("%p, %p\n", session, digitalLensControl); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetDigitalLensControlALMALENCE(((wine_XrSession *)session)->session, digitalLensControl); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrSetDigitalLensControlALMALENCE(wine_session_from_handle(params->session)->host_session, params->digitalLensControl); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSetEnvironmentDepthEstimationVARJO(XrSession session, XrBool32 enabled) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetEnvironmentDepthEstimationVARJO(void *args) { - XrResult ret; + struct xrSetEnvironmentDepthEstimationVARJO_params *params = args; - WINE_TRACE("%p, %u\n", session, enabled); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetEnvironmentDepthEstimationVARJO(((wine_XrSession *)session)->session, enabled); - return ret; + TRACE("%p, %u\n", params->session, params->enabled); + + params->result = g_xr_host_instance_dispatch_table.p_xrSetEnvironmentDepthEstimationVARJO(wine_session_from_handle(params->session)->host_session, params->enabled); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSetEnvironmentDepthHandRemovalMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider, const XrEnvironmentDepthHandRemovalSetInfoMETA *setInfo) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetEnvironmentDepthHandRemovalMETA(void *args) { - XrResult ret; + struct xrSetEnvironmentDepthHandRemovalMETA_params *params = args; + + TRACE("%p, %p\n", params->environmentDepthProvider, params->setInfo); - WINE_TRACE("%p, %p\n", environmentDepthProvider, setInfo); - ret = (*get_dispatch_table((uint64_t)(environmentDepthProvider))).p_xrSetEnvironmentDepthHandRemovalMETA(environmentDepthProvider, setInfo); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrSetEnvironmentDepthHandRemovalMETA(params->environmentDepthProvider, params->setInfo); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSetInputDeviceActiveEXT(XrSession session, XrPath interactionProfile, XrPath topLevelPath, XrBool32 isActive) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetInputDeviceActiveEXT(void *args) { - XrResult ret; + struct xrSetInputDeviceActiveEXT_params *params = args; - WINE_TRACE("%p, 0x%s, 0x%s, %u\n", session, wine_dbgstr_longlong(interactionProfile), wine_dbgstr_longlong(topLevelPath), isActive); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetInputDeviceActiveEXT(((wine_XrSession *)session)->session, interactionProfile, topLevelPath, isActive); - return ret; + TRACE("%p, 0x%s, 0x%s, %u\n", params->session, wine_dbgstr_longlong(params->interactionProfile), wine_dbgstr_longlong(params->topLevelPath), params->isActive); + + params->result = g_xr_host_instance_dispatch_table.p_xrSetInputDeviceActiveEXT(wine_session_from_handle(params->session)->host_session, params->interactionProfile, params->topLevelPath, params->isActive); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSetInputDeviceLocationEXT(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, XrSpace space, XrPosef pose) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetInputDeviceLocationEXT(void *args) { - XrResult ret; + struct xrSetInputDeviceLocationEXT_params *params = args; + + TRACE("%p, 0x%s, 0x%s, %p, {{%f, %f, %f, %f}, {%f %f %f}}\n", params->session, wine_dbgstr_longlong(params->topLevelPath), wine_dbgstr_longlong(params->inputSourcePath), params->space, params->pose.orientation.x, params->pose.orientation.y, params->pose.orientation.z, params->pose.orientation.w, params->pose.position.x, params->pose.position.y, params->pose.position.z); - WINE_TRACE("%p, 0x%s, 0x%s, %p, {{%f, %f, %f, %f}, {%f %f %f}}\n", session, wine_dbgstr_longlong(topLevelPath), wine_dbgstr_longlong(inputSourcePath), space, pose.orientation.x, pose.orientation.y, pose.orientation.z, pose.orientation.w, pose.position.x, pose.position.y, pose.position.z); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetInputDeviceLocationEXT(((wine_XrSession *)session)->session, topLevelPath, inputSourcePath, space, pose); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrSetInputDeviceLocationEXT(wine_session_from_handle(params->session)->host_session, params->topLevelPath, params->inputSourcePath, params->space, params->pose); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSetInputDeviceStateBoolEXT(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, XrBool32 state) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetInputDeviceStateBoolEXT(void *args) { - XrResult ret; + struct xrSetInputDeviceStateBoolEXT_params *params = args; + + TRACE("%p, 0x%s, 0x%s, %u\n", params->session, wine_dbgstr_longlong(params->topLevelPath), wine_dbgstr_longlong(params->inputSourcePath), params->state); - WINE_TRACE("%p, 0x%s, 0x%s, %u\n", session, wine_dbgstr_longlong(topLevelPath), wine_dbgstr_longlong(inputSourcePath), state); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetInputDeviceStateBoolEXT(((wine_XrSession *)session)->session, topLevelPath, inputSourcePath, state); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrSetInputDeviceStateBoolEXT(wine_session_from_handle(params->session)->host_session, params->topLevelPath, params->inputSourcePath, params->state); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSetInputDeviceStateFloatEXT(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, float state) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetInputDeviceStateFloatEXT(void *args) { - XrResult ret; + struct xrSetInputDeviceStateFloatEXT_params *params = args; - WINE_TRACE("%p, 0x%s, 0x%s, %f\n", session, wine_dbgstr_longlong(topLevelPath), wine_dbgstr_longlong(inputSourcePath), state); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetInputDeviceStateFloatEXT(((wine_XrSession *)session)->session, topLevelPath, inputSourcePath, state); - return ret; + TRACE("%p, 0x%s, 0x%s, %f\n", params->session, wine_dbgstr_longlong(params->topLevelPath), wine_dbgstr_longlong(params->inputSourcePath), params->state); + + params->result = g_xr_host_instance_dispatch_table.p_xrSetInputDeviceStateFloatEXT(wine_session_from_handle(params->session)->host_session, params->topLevelPath, params->inputSourcePath, params->state); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSetInputDeviceStateVector2fEXT(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, XrVector2f state) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetInputDeviceStateVector2fEXT(void *args) { - XrResult ret; + struct xrSetInputDeviceStateVector2fEXT_params *params = args; + + TRACE("%p, 0x%s, 0x%s, %f, %f\n", params->session, wine_dbgstr_longlong(params->topLevelPath), wine_dbgstr_longlong(params->inputSourcePath), params->state.x, params->state.y); - WINE_TRACE("%p, 0x%s, 0x%s, %f, %f\n", session, wine_dbgstr_longlong(topLevelPath), wine_dbgstr_longlong(inputSourcePath), state.x, state.y); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetInputDeviceStateVector2fEXT(((wine_XrSession *)session)->session, topLevelPath, inputSourcePath, state); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrSetInputDeviceStateVector2fEXT(wine_session_from_handle(params->session)->host_session, params->topLevelPath, params->inputSourcePath, params->state); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSetMarkerTrackingPredictionVARJO(XrSession session, uint64_t markerId, XrBool32 enable) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetMarkerTrackingPredictionVARJO(void *args) { - XrResult ret; + struct xrSetMarkerTrackingPredictionVARJO_params *params = args; - WINE_TRACE("%p, 0x%s, %u\n", session, wine_dbgstr_longlong(markerId), enable); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetMarkerTrackingPredictionVARJO(((wine_XrSession *)session)->session, markerId, enable); - return ret; + TRACE("%p, 0x%s, %u\n", params->session, wine_dbgstr_longlong(params->markerId), params->enable); + + params->result = g_xr_host_instance_dispatch_table.p_xrSetMarkerTrackingPredictionVARJO(wine_session_from_handle(params->session)->host_session, params->markerId, params->enable); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSetMarkerTrackingTimeoutVARJO(XrSession session, uint64_t markerId, XrDuration timeout) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetMarkerTrackingTimeoutVARJO(void *args) { - XrResult ret; + struct xrSetMarkerTrackingTimeoutVARJO_params *params = args; + + TRACE("%p, 0x%s, 0x%s\n", params->session, wine_dbgstr_longlong(params->markerId), wine_dbgstr_longlong(params->timeout)); - WINE_TRACE("%p, 0x%s, 0x%s\n", session, wine_dbgstr_longlong(markerId), wine_dbgstr_longlong(timeout)); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetMarkerTrackingTimeoutVARJO(((wine_XrSession *)session)->session, markerId, timeout); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrSetMarkerTrackingTimeoutVARJO(wine_session_from_handle(params->session)->host_session, params->markerId, params->timeout); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSetMarkerTrackingVARJO(XrSession session, XrBool32 enabled) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetMarkerTrackingVARJO(void *args) { - XrResult ret; + struct xrSetMarkerTrackingVARJO_params *params = args; + + TRACE("%p, %u\n", params->session, params->enabled); - WINE_TRACE("%p, %u\n", session, enabled); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetMarkerTrackingVARJO(((wine_XrSession *)session)->session, enabled); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrSetMarkerTrackingVARJO(wine_session_from_handle(params->session)->host_session, params->enabled); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSetPerformanceMetricsStateMETA(XrSession session, const XrPerformanceMetricsStateMETA *state) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetPerformanceMetricsStateMETA(void *args) { - XrResult ret; + struct xrSetPerformanceMetricsStateMETA_params *params = args; - WINE_TRACE("%p, %p\n", session, state); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetPerformanceMetricsStateMETA(((wine_XrSession *)session)->session, state); - return ret; + TRACE("%p, %p\n", params->session, params->state); + + params->result = g_xr_host_instance_dispatch_table.p_xrSetPerformanceMetricsStateMETA(wine_session_from_handle(params->session)->host_session, params->state); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSetSpaceComponentStatusFB(XrSpace space, const XrSpaceComponentStatusSetInfoFB *info, XrAsyncRequestIdFB *requestId) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetSpaceComponentStatusFB(void *args) { - XrResult ret; + struct xrSetSpaceComponentStatusFB_params *params = args; + + TRACE("%p, %p, %p\n", params->space, params->info, params->requestId); - WINE_TRACE("%p, %p, %p\n", space, info, requestId); - ret = (*get_dispatch_table((uint64_t)(space))).p_xrSetSpaceComponentStatusFB(space, info, requestId); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrSetSpaceComponentStatusFB(params->space, params->info, params->requestId); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSetTrackingOptimizationSettingsHintQCOM(XrSession session, XrTrackingOptimizationSettingsDomainQCOM domain, XrTrackingOptimizationSettingsHintQCOM hint) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetTrackingOptimizationSettingsHintQCOM(void *args) { - XrResult ret; + struct xrSetTrackingOptimizationSettingsHintQCOM_params *params = args; - WINE_TRACE("%p, %#x, %#x\n", session, domain, hint); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetTrackingOptimizationSettingsHintQCOM(((wine_XrSession *)session)->session, domain, hint); - return ret; + TRACE("%p, %#x, %#x\n", params->session, params->domain, params->hint); + + params->result = g_xr_host_instance_dispatch_table.p_xrSetTrackingOptimizationSettingsHintQCOM(wine_session_from_handle(params->session)->host_session, params->domain, params->hint); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSetViewOffsetVARJO(XrSession session, float offset) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetViewOffsetVARJO(void *args) { - XrResult ret; + struct xrSetViewOffsetVARJO_params *params = args; + + TRACE("%p, %f\n", params->session, params->offset); - WINE_TRACE("%p, %f\n", session, offset); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetViewOffsetVARJO(((wine_XrSession *)session)->session, offset); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrSetViewOffsetVARJO(wine_session_from_handle(params->session)->host_session, params->offset); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSetVirtualKeyboardModelVisibilityMETA(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardModelVisibilitySetInfoMETA *modelVisibility) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetVirtualKeyboardModelVisibilityMETA(void *args) { - XrResult ret; + struct xrSetVirtualKeyboardModelVisibilityMETA_params *params = args; + + TRACE("%p, %p\n", params->keyboard, params->modelVisibility); - WINE_TRACE("%p, %p\n", keyboard, modelVisibility); - ret = (*get_dispatch_table((uint64_t)(keyboard))).p_xrSetVirtualKeyboardModelVisibilityMETA(keyboard, modelVisibility); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrSetVirtualKeyboardModelVisibilityMETA(params->keyboard, params->modelVisibility); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrShareSpacesFB(XrSession session, const XrSpaceShareInfoFB *info, XrAsyncRequestIdFB *requestId) +#ifdef _WIN64 +static NTSTATUS thunk64_xrShareSpacesFB(void *args) { - XrResult ret; + struct xrShareSpacesFB_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, info, requestId); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrShareSpacesFB(((wine_XrSession *)session)->session, info, requestId); - return ret; + TRACE("%p, %p, %p\n", params->session, params->info, params->requestId); + + params->result = g_xr_host_instance_dispatch_table.p_xrShareSpacesFB(wine_session_from_handle(params->session)->host_session, params->info, params->requestId); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSnapshotMarkerDetectorML(XrMarkerDetectorML markerDetector, XrMarkerDetectorSnapshotInfoML *snapshotInfo) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSnapshotMarkerDetectorML(void *args) { - XrResult ret; + struct xrSnapshotMarkerDetectorML_params *params = args; + + TRACE("%p, %p\n", params->markerDetector, params->snapshotInfo); - WINE_TRACE("%p, %p\n", markerDetector, snapshotInfo); - ret = (*get_dispatch_table((uint64_t)(markerDetector))).p_xrSnapshotMarkerDetectorML(markerDetector, snapshotInfo); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrSnapshotMarkerDetectorML(params->markerDetector, params->snapshotInfo); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrStartEnvironmentDepthProviderMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider) +#ifdef _WIN64 +static NTSTATUS thunk64_xrStartEnvironmentDepthProviderMETA(void *args) { - XrResult ret; + struct xrStartEnvironmentDepthProviderMETA_params *params = args; - WINE_TRACE("%p\n", environmentDepthProvider); - ret = (*get_dispatch_table((uint64_t)(environmentDepthProvider))).p_xrStartEnvironmentDepthProviderMETA(environmentDepthProvider); - return ret; + TRACE("%p\n", params->environmentDepthProvider); + + params->result = g_xr_host_instance_dispatch_table.p_xrStartEnvironmentDepthProviderMETA(params->environmentDepthProvider); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrStopEnvironmentDepthProviderMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider) +#ifdef _WIN64 +static NTSTATUS thunk64_xrStopEnvironmentDepthProviderMETA(void *args) { - XrResult ret; + struct xrStopEnvironmentDepthProviderMETA_params *params = args; + + TRACE("%p\n", params->environmentDepthProvider); - WINE_TRACE("%p\n", environmentDepthProvider); - ret = (*get_dispatch_table((uint64_t)(environmentDepthProvider))).p_xrStopEnvironmentDepthProviderMETA(environmentDepthProvider); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrStopEnvironmentDepthProviderMETA(params->environmentDepthProvider); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrStopHapticFeedback(XrSession session, const XrHapticActionInfo *hapticActionInfo) +#ifdef _WIN64 +static NTSTATUS thunk64_xrStopHapticFeedback(void *args) { - XrResult ret; + struct xrStopHapticFeedback_params *params = args; + + TRACE("%p, %p\n", params->session, params->hapticActionInfo); - WINE_TRACE("%p, %p\n", session, hapticActionInfo); - ret = xrStopHapticFeedback(((wine_XrSession *)session)->session, hapticActionInfo); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrStopHapticFeedback(wine_session_from_handle(params->session)->host_session, params->hapticActionInfo); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrStringToPath(XrInstance instance, const char *pathString, XrPath *path) +#ifdef _WIN64 +static NTSTATUS thunk64_xrStringToPath(void *args) { - XrResult ret; + struct xrStringToPath_params *params = args; - WINE_TRACE("%p, %p, %p\n", instance, pathString, path); - ret = xrStringToPath(((wine_XrInstance *)instance)->instance, pathString, path); - return ret; + TRACE("%p, %p, %p\n", params->instance, params->pathString, params->path); + + params->result = g_xr_host_instance_dispatch_table.p_xrStringToPath(wine_instance_from_handle(params->instance)->host_instance, params->pathString, params->path); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrStructureTypeToString(XrInstance instance, XrStructureType value, char buffer[]) +#ifdef _WIN64 +static NTSTATUS thunk64_xrStructureTypeToString(void *args) { - XrResult ret; + struct xrStructureTypeToString_params *params = args; + + TRACE("%p, %#x, %p\n", params->instance, params->value, params->buffer); - WINE_TRACE("%p, %#x, %p\n", instance, value, buffer); - ret = xrStructureTypeToString(((wine_XrInstance *)instance)->instance, value, buffer); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrStructureTypeToString(wine_instance_from_handle(params->instance)->host_instance, params->value, params->buffer); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrSuggestInteractionProfileBindings(XrInstance instance, const XrInteractionProfileSuggestedBinding *suggestedBindings) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSuggestInteractionProfileBindings(void *args) { - XrResult ret; + struct xrSuggestInteractionProfileBindings_params *params = args; - WINE_TRACE("%p, %p\n", instance, suggestedBindings); - ret = xrSuggestInteractionProfileBindings(((wine_XrInstance *)instance)->instance, suggestedBindings); - return ret; + TRACE("%p, %p\n", params->instance, params->suggestedBindings); + + params->result = g_xr_host_instance_dispatch_table.p_xrSuggestInteractionProfileBindings(wine_instance_from_handle(params->instance)->host_instance, params->suggestedBindings); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrSuggestVirtualKeyboardLocationMETA(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardLocationInfoMETA *locationInfo) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSuggestVirtualKeyboardLocationMETA(void *args) { - XrResult ret; + struct xrSuggestVirtualKeyboardLocationMETA_params *params = args; + + TRACE("%p, %p\n", params->keyboard, params->locationInfo); - WINE_TRACE("%p, %p\n", keyboard, locationInfo); - ret = (*get_dispatch_table((uint64_t)(keyboard))).p_xrSuggestVirtualKeyboardLocationMETA(keyboard, locationInfo); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrSuggestVirtualKeyboardLocationMETA(params->keyboard, params->locationInfo); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrSyncActions(XrSession session, const XrActionsSyncInfo *syncInfo) +#ifdef _WIN64 +static NTSTATUS thunk64_xrSyncActions(void *args) { - XrResult ret; + struct xrSyncActions_params *params = args; + + TRACE("%p, %p\n", params->session, params->syncInfo); - WINE_TRACE("%p, %p\n", session, syncInfo); - ret = xrSyncActions(((wine_XrSession *)session)->session, syncInfo); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrSyncActions(wine_session_from_handle(params->session)->host_session, params->syncInfo); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrThermalGetTemperatureTrendEXT(XrSession session, XrPerfSettingsDomainEXT domain, XrPerfSettingsNotificationLevelEXT *notificationLevel, float *tempHeadroom, float *tempSlope) +#ifdef _WIN64 +static NTSTATUS thunk64_xrThermalGetTemperatureTrendEXT(void *args) { - XrResult ret; + struct xrThermalGetTemperatureTrendEXT_params *params = args; - WINE_TRACE("%p, %#x, %p, %p, %p\n", session, domain, notificationLevel, tempHeadroom, tempSlope); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrThermalGetTemperatureTrendEXT(((wine_XrSession *)session)->session, domain, notificationLevel, tempHeadroom, tempSlope); - return ret; + TRACE("%p, %#x, %p, %p, %p\n", params->session, params->domain, params->notificationLevel, params->tempHeadroom, params->tempSlope); + + params->result = g_xr_host_instance_dispatch_table.p_xrThermalGetTemperatureTrendEXT(wine_session_from_handle(params->session)->host_session, params->domain, params->notificationLevel, params->tempHeadroom, params->tempSlope); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrTriangleMeshBeginUpdateFB(XrTriangleMeshFB mesh) +#ifdef _WIN64 +static NTSTATUS thunk64_xrTriangleMeshBeginUpdateFB(void *args) { - XrResult ret; + struct xrTriangleMeshBeginUpdateFB_params *params = args; + + TRACE("%p\n", params->mesh); - WINE_TRACE("%p\n", mesh); - ret = (*get_dispatch_table((uint64_t)(mesh))).p_xrTriangleMeshBeginUpdateFB(mesh); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrTriangleMeshBeginUpdateFB(params->mesh); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrTriangleMeshBeginVertexBufferUpdateFB(XrTriangleMeshFB mesh, uint32_t *outVertexCount) +#ifdef _WIN64 +static NTSTATUS thunk64_xrTriangleMeshBeginVertexBufferUpdateFB(void *args) { - XrResult ret; + struct xrTriangleMeshBeginVertexBufferUpdateFB_params *params = args; - WINE_TRACE("%p, %p\n", mesh, outVertexCount); - ret = (*get_dispatch_table((uint64_t)(mesh))).p_xrTriangleMeshBeginVertexBufferUpdateFB(mesh, outVertexCount); - return ret; + TRACE("%p, %p\n", params->mesh, params->outVertexCount); + + params->result = g_xr_host_instance_dispatch_table.p_xrTriangleMeshBeginVertexBufferUpdateFB(params->mesh, params->outVertexCount); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrTriangleMeshEndUpdateFB(XrTriangleMeshFB mesh, uint32_t vertexCount, uint32_t triangleCount) +#ifdef _WIN64 +static NTSTATUS thunk64_xrTriangleMeshEndUpdateFB(void *args) { - XrResult ret; + struct xrTriangleMeshEndUpdateFB_params *params = args; + + TRACE("%p, %u, %u\n", params->mesh, params->vertexCount, params->triangleCount); - WINE_TRACE("%p, %u, %u\n", mesh, vertexCount, triangleCount); - ret = (*get_dispatch_table((uint64_t)(mesh))).p_xrTriangleMeshEndUpdateFB(mesh, vertexCount, triangleCount); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrTriangleMeshEndUpdateFB(params->mesh, params->vertexCount, params->triangleCount); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrTriangleMeshEndVertexBufferUpdateFB(XrTriangleMeshFB mesh) +#ifdef _WIN64 +static NTSTATUS thunk64_xrTriangleMeshEndVertexBufferUpdateFB(void *args) { - XrResult ret; + struct xrTriangleMeshEndVertexBufferUpdateFB_params *params = args; + + TRACE("%p\n", params->mesh); - WINE_TRACE("%p\n", mesh); - ret = (*get_dispatch_table((uint64_t)(mesh))).p_xrTriangleMeshEndVertexBufferUpdateFB(mesh); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrTriangleMeshEndVertexBufferUpdateFB(params->mesh); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrTriangleMeshGetIndexBufferFB(XrTriangleMeshFB mesh, uint32_t **outIndexBuffer) +#ifdef _WIN64 +static NTSTATUS thunk64_xrTriangleMeshGetIndexBufferFB(void *args) { - XrResult ret; + struct xrTriangleMeshGetIndexBufferFB_params *params = args; - WINE_TRACE("%p, %p\n", mesh, outIndexBuffer); - ret = (*get_dispatch_table((uint64_t)(mesh))).p_xrTriangleMeshGetIndexBufferFB(mesh, outIndexBuffer); - return ret; + TRACE("%p, %p\n", params->mesh, params->outIndexBuffer); + + params->result = g_xr_host_instance_dispatch_table.p_xrTriangleMeshGetIndexBufferFB(params->mesh, params->outIndexBuffer); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrTriangleMeshGetVertexBufferFB(XrTriangleMeshFB mesh, XrVector3f **outVertexBuffer) +#ifdef _WIN64 +static NTSTATUS thunk64_xrTriangleMeshGetVertexBufferFB(void *args) { - XrResult ret; + struct xrTriangleMeshGetVertexBufferFB_params *params = args; + + TRACE("%p, %p\n", params->mesh, params->outVertexBuffer); - WINE_TRACE("%p, %p\n", mesh, outVertexBuffer); - ret = (*get_dispatch_table((uint64_t)(mesh))).p_xrTriangleMeshGetVertexBufferFB(mesh, outVertexBuffer); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrTriangleMeshGetVertexBufferFB(params->mesh, params->outVertexBuffer); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrTryCreateSpatialGraphStaticNodeBindingMSFT(XrSession session, const XrSpatialGraphStaticNodeBindingCreateInfoMSFT *createInfo, XrSpatialGraphNodeBindingMSFT *nodeBinding) +#ifdef _WIN64 +static NTSTATUS thunk64_xrTryCreateSpatialGraphStaticNodeBindingMSFT(void *args) { - XrResult ret; + struct xrTryCreateSpatialGraphStaticNodeBindingMSFT_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, createInfo, nodeBinding); - ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrTryCreateSpatialGraphStaticNodeBindingMSFT(((wine_XrSession *)session)->session, createInfo, nodeBinding); - if (!ret) register_dispatchable_handle((uint64_t)*nodeBinding, &(((wine_XrSession *)session)->wine_instance->funcs)); - return ret; + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->nodeBinding); + + params->result = g_xr_host_instance_dispatch_table.p_xrTryCreateSpatialGraphStaticNodeBindingMSFT(wine_session_from_handle(params->session)->host_session, params->createInfo, params->nodeBinding); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrUnpersistSpatialAnchorMSFT(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, const XrSpatialAnchorPersistenceNameMSFT *spatialAnchorPersistenceName) +#ifdef _WIN64 +static NTSTATUS thunk64_xrUnpersistSpatialAnchorMSFT(void *args) { - XrResult ret; + struct xrUnpersistSpatialAnchorMSFT_params *params = args; + + TRACE("%p, %p\n", params->spatialAnchorStore, params->spatialAnchorPersistenceName); - WINE_TRACE("%p, %p\n", spatialAnchorStore, spatialAnchorPersistenceName); - ret = (*get_dispatch_table((uint64_t)(spatialAnchorStore))).p_xrUnpersistSpatialAnchorMSFT(spatialAnchorStore, spatialAnchorPersistenceName); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrUnpersistSpatialAnchorMSFT(params->spatialAnchorStore, params->spatialAnchorPersistenceName); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrUpdateHandMeshMSFT(XrHandTrackerEXT handTracker, const XrHandMeshUpdateInfoMSFT *updateInfo, XrHandMeshMSFT *handMesh) +#ifdef _WIN64 +static NTSTATUS thunk64_xrUpdateHandMeshMSFT(void *args) { - XrResult ret; + struct xrUpdateHandMeshMSFT_params *params = args; + + TRACE("%p, %p, %p\n", params->handTracker, params->updateInfo, params->handMesh); - WINE_TRACE("%p, %p, %p\n", handTracker, updateInfo, handMesh); - ret = (*get_dispatch_table((uint64_t)(handTracker))).p_xrUpdateHandMeshMSFT(handTracker, updateInfo, handMesh); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrUpdateHandMeshMSFT(params->handTracker, params->updateInfo, params->handMesh); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrUpdatePassthroughColorLutMETA(XrPassthroughColorLutMETA colorLut, const XrPassthroughColorLutUpdateInfoMETA *updateInfo) +#ifdef _WIN64 +static NTSTATUS thunk64_xrUpdatePassthroughColorLutMETA(void *args) { - XrResult ret; + struct xrUpdatePassthroughColorLutMETA_params *params = args; - WINE_TRACE("%p, %p\n", colorLut, updateInfo); - ret = (*get_dispatch_table((uint64_t)(colorLut))).p_xrUpdatePassthroughColorLutMETA(colorLut, updateInfo); - return ret; + TRACE("%p, %p\n", params->colorLut, params->updateInfo); + + params->result = g_xr_host_instance_dispatch_table.p_xrUpdatePassthroughColorLutMETA(params->colorLut, params->updateInfo); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -static XrResult WINAPI wine_xrUpdateSwapchainFB(XrSwapchain swapchain, const XrSwapchainStateBaseHeaderFB *state) +#ifdef _WIN64 +static NTSTATUS thunk64_xrUpdateSwapchainFB(void *args) { - XrResult ret; + struct xrUpdateSwapchainFB_params *params = args; + + TRACE("%p, %p\n", params->swapchain, params->state); - WINE_TRACE("%p, %p\n", swapchain, state); - ret = ((wine_XrSwapchain *)swapchain)->wine_session->wine_instance->funcs.p_xrUpdateSwapchainFB(((wine_XrSwapchain *)swapchain)->swapchain, state); - return ret; + params->result = g_xr_host_instance_dispatch_table.p_xrUpdateSwapchainFB(wine_swapchain_from_handle(params->swapchain)->host_swapchain, params->state); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ -XrResult WINAPI wine_xrWaitFrame(XrSession session, const XrFrameWaitInfo *frameWaitInfo, XrFrameState *frameState) +#ifdef _WIN64 +static NTSTATUS thunk64_xrWaitFrame(void *args) { - XrResult ret; + struct xrWaitFrame_params *params = args; - WINE_TRACE("%p, %p, %p\n", session, frameWaitInfo, frameState); - ret = xrWaitFrame(((wine_XrSession *)session)->session, frameWaitInfo, frameState); - return ret; + TRACE("%p, %p, %p\n", params->session, params->frameWaitInfo, params->frameState); + + params->result = g_xr_host_instance_dispatch_table.p_xrWaitFrame(wine_session_from_handle(params->session)->host_session, params->frameWaitInfo, params->frameState); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrWaitSwapchainImage(void *args) +{ + struct xrWaitSwapchainImage_params *params = args; + + TRACE("%p, %p\n", params->swapchain, params->waitInfo); -XrResult WINAPI wine_xrWaitSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageWaitInfo *waitInfo) -{ - XrResult ret; - - WINE_TRACE("%p, %p\n", swapchain, waitInfo); - ret = xrWaitSwapchainImage(((wine_XrSwapchain *)swapchain)->swapchain, waitInfo); - return ret; -} - -static const struct openxr_func xr_dispatch_table[] = -{ - {"xrAcquireEnvironmentDepthImageMETA", &wine_xrAcquireEnvironmentDepthImageMETA}, - {"xrAcquireSwapchainImage", &wine_xrAcquireSwapchainImage}, - {"xrApplyForceFeedbackCurlMNDX", &wine_xrApplyForceFeedbackCurlMNDX}, - {"xrApplyFoveationHTC", &wine_xrApplyFoveationHTC}, - {"xrApplyHapticFeedback", &wine_xrApplyHapticFeedback}, - {"xrAttachSessionActionSets", &wine_xrAttachSessionActionSets}, - {"xrBeginFrame", &wine_xrBeginFrame}, - {"xrBeginPlaneDetectionEXT", &wine_xrBeginPlaneDetectionEXT}, - {"xrBeginSession", &wine_xrBeginSession}, - {"xrCancelFutureEXT", &wine_xrCancelFutureEXT}, - {"xrChangeVirtualKeyboardTextContextMETA", &wine_xrChangeVirtualKeyboardTextContextMETA}, - {"xrClearSpatialAnchorStoreMSFT", &wine_xrClearSpatialAnchorStoreMSFT}, - {"xrComputeNewSceneMSFT", &wine_xrComputeNewSceneMSFT}, - {"xrConvertTimeToWin32PerformanceCounterKHR", &wine_xrConvertTimeToWin32PerformanceCounterKHR}, - {"xrConvertWin32PerformanceCounterToTimeKHR", &wine_xrConvertWin32PerformanceCounterToTimeKHR}, - {"xrCreateAction", &wine_xrCreateAction}, - {"xrCreateActionSet", &wine_xrCreateActionSet}, - {"xrCreateActionSpace", &wine_xrCreateActionSpace}, - {"xrCreateApiLayerInstance", &wine_xrCreateApiLayerInstance}, - {"xrCreateBodyTrackerFB", &wine_xrCreateBodyTrackerFB}, - {"xrCreateEnvironmentDepthProviderMETA", &wine_xrCreateEnvironmentDepthProviderMETA}, - {"xrCreateEnvironmentDepthSwapchainMETA", &wine_xrCreateEnvironmentDepthSwapchainMETA}, - {"xrCreateExportedLocalizationMapML", &wine_xrCreateExportedLocalizationMapML}, - {"xrCreateEyeTrackerFB", &wine_xrCreateEyeTrackerFB}, - {"xrCreateFaceTracker2FB", &wine_xrCreateFaceTracker2FB}, - {"xrCreateFaceTrackerFB", &wine_xrCreateFaceTrackerFB}, - {"xrCreateFacialTrackerHTC", &wine_xrCreateFacialTrackerHTC}, - {"xrCreateFoveationProfileFB", &wine_xrCreateFoveationProfileFB}, - {"xrCreateGeometryInstanceFB", &wine_xrCreateGeometryInstanceFB}, - {"xrCreateHandMeshSpaceMSFT", &wine_xrCreateHandMeshSpaceMSFT}, - {"xrCreateHandTrackerEXT", &wine_xrCreateHandTrackerEXT}, - {"xrCreateInstance", &wine_xrCreateInstance}, - {"xrCreateKeyboardSpaceFB", &wine_xrCreateKeyboardSpaceFB}, - {"xrCreateMarkerDetectorML", &wine_xrCreateMarkerDetectorML}, - {"xrCreateMarkerSpaceML", &wine_xrCreateMarkerSpaceML}, - {"xrCreateMarkerSpaceVARJO", &wine_xrCreateMarkerSpaceVARJO}, - {"xrCreatePassthroughColorLutMETA", &wine_xrCreatePassthroughColorLutMETA}, - {"xrCreatePassthroughFB", &wine_xrCreatePassthroughFB}, - {"xrCreatePassthroughHTC", &wine_xrCreatePassthroughHTC}, - {"xrCreatePassthroughLayerFB", &wine_xrCreatePassthroughLayerFB}, - {"xrCreatePlaneDetectorEXT", &wine_xrCreatePlaneDetectorEXT}, - {"xrCreateReferenceSpace", &wine_xrCreateReferenceSpace}, - {"xrCreateSceneMSFT", &wine_xrCreateSceneMSFT}, - {"xrCreateSceneObserverMSFT", &wine_xrCreateSceneObserverMSFT}, - {"xrCreateSession", &wine_xrCreateSession}, - {"xrCreateSpaceUserFB", &wine_xrCreateSpaceUserFB}, - {"xrCreateSpatialAnchorFB", &wine_xrCreateSpatialAnchorFB}, - {"xrCreateSpatialAnchorFromPersistedNameMSFT", &wine_xrCreateSpatialAnchorFromPersistedNameMSFT}, - {"xrCreateSpatialAnchorHTC", &wine_xrCreateSpatialAnchorHTC}, - {"xrCreateSpatialAnchorMSFT", &wine_xrCreateSpatialAnchorMSFT}, - {"xrCreateSpatialAnchorSpaceMSFT", &wine_xrCreateSpatialAnchorSpaceMSFT}, - {"xrCreateSpatialAnchorStoreConnectionMSFT", &wine_xrCreateSpatialAnchorStoreConnectionMSFT}, - {"xrCreateSpatialGraphNodeSpaceMSFT", &wine_xrCreateSpatialGraphNodeSpaceMSFT}, - {"xrCreateSwapchain", &wine_xrCreateSwapchain}, - {"xrCreateTriangleMeshFB", &wine_xrCreateTriangleMeshFB}, - {"xrCreateVirtualKeyboardMETA", &wine_xrCreateVirtualKeyboardMETA}, - {"xrCreateVirtualKeyboardSpaceMETA", &wine_xrCreateVirtualKeyboardSpaceMETA}, - {"xrCreateVulkanDeviceKHR", &wine_xrCreateVulkanDeviceKHR}, - {"xrCreateVulkanInstanceKHR", &wine_xrCreateVulkanInstanceKHR}, - {"xrDeserializeSceneMSFT", &wine_xrDeserializeSceneMSFT}, - {"xrDestroyAction", &wine_xrDestroyAction}, - {"xrDestroyActionSet", &wine_xrDestroyActionSet}, - {"xrDestroyBodyTrackerFB", &wine_xrDestroyBodyTrackerFB}, - {"xrDestroyEnvironmentDepthProviderMETA", &wine_xrDestroyEnvironmentDepthProviderMETA}, - {"xrDestroyEnvironmentDepthSwapchainMETA", &wine_xrDestroyEnvironmentDepthSwapchainMETA}, - {"xrDestroyExportedLocalizationMapML", &wine_xrDestroyExportedLocalizationMapML}, - {"xrDestroyEyeTrackerFB", &wine_xrDestroyEyeTrackerFB}, - {"xrDestroyFaceTracker2FB", &wine_xrDestroyFaceTracker2FB}, - {"xrDestroyFaceTrackerFB", &wine_xrDestroyFaceTrackerFB}, - {"xrDestroyFacialTrackerHTC", &wine_xrDestroyFacialTrackerHTC}, - {"xrDestroyFoveationProfileFB", &wine_xrDestroyFoveationProfileFB}, - {"xrDestroyGeometryInstanceFB", &wine_xrDestroyGeometryInstanceFB}, - {"xrDestroyHandTrackerEXT", &wine_xrDestroyHandTrackerEXT}, - {"xrDestroyInstance", &wine_xrDestroyInstance}, - {"xrDestroyMarkerDetectorML", &wine_xrDestroyMarkerDetectorML}, - {"xrDestroyPassthroughColorLutMETA", &wine_xrDestroyPassthroughColorLutMETA}, - {"xrDestroyPassthroughFB", &wine_xrDestroyPassthroughFB}, - {"xrDestroyPassthroughHTC", &wine_xrDestroyPassthroughHTC}, - {"xrDestroyPassthroughLayerFB", &wine_xrDestroyPassthroughLayerFB}, - {"xrDestroyPlaneDetectorEXT", &wine_xrDestroyPlaneDetectorEXT}, - {"xrDestroySceneMSFT", &wine_xrDestroySceneMSFT}, - {"xrDestroySceneObserverMSFT", &wine_xrDestroySceneObserverMSFT}, - {"xrDestroySession", &wine_xrDestroySession}, - {"xrDestroySpace", &wine_xrDestroySpace}, - {"xrDestroySpaceUserFB", &wine_xrDestroySpaceUserFB}, - {"xrDestroySpatialAnchorMSFT", &wine_xrDestroySpatialAnchorMSFT}, - {"xrDestroySpatialAnchorStoreConnectionMSFT", &wine_xrDestroySpatialAnchorStoreConnectionMSFT}, - {"xrDestroySpatialGraphNodeBindingMSFT", &wine_xrDestroySpatialGraphNodeBindingMSFT}, - {"xrDestroySwapchain", &wine_xrDestroySwapchain}, - {"xrDestroyTriangleMeshFB", &wine_xrDestroyTriangleMeshFB}, - {"xrDestroyVirtualKeyboardMETA", &wine_xrDestroyVirtualKeyboardMETA}, - {"xrEnableLocalizationEventsML", &wine_xrEnableLocalizationEventsML}, - {"xrEnableUserCalibrationEventsML", &wine_xrEnableUserCalibrationEventsML}, - {"xrEndFrame", &wine_xrEndFrame}, - {"xrEndSession", &wine_xrEndSession}, - {"xrEnumerateApiLayerProperties", &wine_xrEnumerateApiLayerProperties}, - {"xrEnumerateBoundSourcesForAction", &wine_xrEnumerateBoundSourcesForAction}, - {"xrEnumerateColorSpacesFB", &wine_xrEnumerateColorSpacesFB}, - {"xrEnumerateDisplayRefreshRatesFB", &wine_xrEnumerateDisplayRefreshRatesFB}, - {"xrEnumerateEnvironmentBlendModes", &wine_xrEnumerateEnvironmentBlendModes}, - {"xrEnumerateEnvironmentDepthSwapchainImagesMETA", &wine_xrEnumerateEnvironmentDepthSwapchainImagesMETA}, - {"xrEnumerateExternalCamerasOCULUS", &wine_xrEnumerateExternalCamerasOCULUS}, - {"xrEnumerateInstanceExtensionProperties", &wine_xrEnumerateInstanceExtensionProperties}, - {"xrEnumeratePerformanceMetricsCounterPathsMETA", &wine_xrEnumeratePerformanceMetricsCounterPathsMETA}, - {"xrEnumeratePersistedSpatialAnchorNamesMSFT", &wine_xrEnumeratePersistedSpatialAnchorNamesMSFT}, - {"xrEnumerateReferenceSpaces", &wine_xrEnumerateReferenceSpaces}, - {"xrEnumerateRenderModelPathsFB", &wine_xrEnumerateRenderModelPathsFB}, - {"xrEnumerateReprojectionModesMSFT", &wine_xrEnumerateReprojectionModesMSFT}, - {"xrEnumerateSceneComputeFeaturesMSFT", &wine_xrEnumerateSceneComputeFeaturesMSFT}, - {"xrEnumerateSpaceSupportedComponentsFB", &wine_xrEnumerateSpaceSupportedComponentsFB}, - {"xrEnumerateSwapchainFormats", &wine_xrEnumerateSwapchainFormats}, - {"xrEnumerateSwapchainImages", &wine_xrEnumerateSwapchainImages}, - {"xrEnumerateViewConfigurationViews", &wine_xrEnumerateViewConfigurationViews}, - {"xrEnumerateViewConfigurations", &wine_xrEnumerateViewConfigurations}, - {"xrEnumerateViveTrackerPathsHTCX", &wine_xrEnumerateViveTrackerPathsHTCX}, - {"xrEraseSpaceFB", &wine_xrEraseSpaceFB}, - {"xrGeometryInstanceSetTransformFB", &wine_xrGeometryInstanceSetTransformFB}, - {"xrGetActionStateBoolean", &wine_xrGetActionStateBoolean}, - {"xrGetActionStateFloat", &wine_xrGetActionStateFloat}, - {"xrGetActionStatePose", &wine_xrGetActionStatePose}, - {"xrGetActionStateVector2f", &wine_xrGetActionStateVector2f}, - {"xrGetAudioInputDeviceGuidOculus", &wine_xrGetAudioInputDeviceGuidOculus}, - {"xrGetAudioOutputDeviceGuidOculus", &wine_xrGetAudioOutputDeviceGuidOculus}, - {"xrGetBodySkeletonFB", &wine_xrGetBodySkeletonFB}, - {"xrGetControllerModelKeyMSFT", &wine_xrGetControllerModelKeyMSFT}, - {"xrGetControllerModelPropertiesMSFT", &wine_xrGetControllerModelPropertiesMSFT}, - {"xrGetControllerModelStateMSFT", &wine_xrGetControllerModelStateMSFT}, - {"xrGetCurrentInteractionProfile", &wine_xrGetCurrentInteractionProfile}, - {"xrGetD3D11GraphicsRequirementsKHR", &wine_xrGetD3D11GraphicsRequirementsKHR}, - {"xrGetD3D12GraphicsRequirementsKHR", &wine_xrGetD3D12GraphicsRequirementsKHR}, - {"xrGetDeviceSampleRateFB", &wine_xrGetDeviceSampleRateFB}, - {"xrGetDisplayRefreshRateFB", &wine_xrGetDisplayRefreshRateFB}, - {"xrGetEnvironmentDepthSwapchainStateMETA", &wine_xrGetEnvironmentDepthSwapchainStateMETA}, - {"xrGetExportedLocalizationMapDataML", &wine_xrGetExportedLocalizationMapDataML}, - {"xrGetEyeGazesFB", &wine_xrGetEyeGazesFB}, - {"xrGetFaceExpressionWeights2FB", &wine_xrGetFaceExpressionWeights2FB}, - {"xrGetFaceExpressionWeightsFB", &wine_xrGetFaceExpressionWeightsFB}, - {"xrGetFacialExpressionsHTC", &wine_xrGetFacialExpressionsHTC}, - {"xrGetFoveationEyeTrackedStateMETA", &wine_xrGetFoveationEyeTrackedStateMETA}, - {"xrGetHandMeshFB", &wine_xrGetHandMeshFB}, - {"xrGetInputSourceLocalizedName", &wine_xrGetInputSourceLocalizedName}, - {"xrGetInstanceProcAddr", &wine_xrGetInstanceProcAddr}, - {"xrGetInstanceProperties", &wine_xrGetInstanceProperties}, - {"xrGetMarkerDetectorStateML", &wine_xrGetMarkerDetectorStateML}, - {"xrGetMarkerLengthML", &wine_xrGetMarkerLengthML}, - {"xrGetMarkerNumberML", &wine_xrGetMarkerNumberML}, - {"xrGetMarkerReprojectionErrorML", &wine_xrGetMarkerReprojectionErrorML}, - {"xrGetMarkerSizeVARJO", &wine_xrGetMarkerSizeVARJO}, - {"xrGetMarkerStringML", &wine_xrGetMarkerStringML}, - {"xrGetMarkersML", &wine_xrGetMarkersML}, - {"xrGetOpenGLGraphicsRequirementsKHR", &wine_xrGetOpenGLGraphicsRequirementsKHR}, - {"xrGetPassthroughPreferencesMETA", &wine_xrGetPassthroughPreferencesMETA}, - {"xrGetPerformanceMetricsStateMETA", &wine_xrGetPerformanceMetricsStateMETA}, - {"xrGetPlaneDetectionStateEXT", &wine_xrGetPlaneDetectionStateEXT}, - {"xrGetPlaneDetectionsEXT", &wine_xrGetPlaneDetectionsEXT}, - {"xrGetPlanePolygonBufferEXT", &wine_xrGetPlanePolygonBufferEXT}, - {"xrGetRecommendedLayerResolutionMETA", &wine_xrGetRecommendedLayerResolutionMETA}, - {"xrGetReferenceSpaceBoundsRect", &wine_xrGetReferenceSpaceBoundsRect}, - {"xrGetRenderModelPropertiesFB", &wine_xrGetRenderModelPropertiesFB}, - {"xrGetSceneComponentsMSFT", &wine_xrGetSceneComponentsMSFT}, - {"xrGetSceneComputeStateMSFT", &wine_xrGetSceneComputeStateMSFT}, - {"xrGetSceneMarkerDecodedStringMSFT", &wine_xrGetSceneMarkerDecodedStringMSFT}, - {"xrGetSceneMarkerRawDataMSFT", &wine_xrGetSceneMarkerRawDataMSFT}, - {"xrGetSceneMeshBuffersMSFT", &wine_xrGetSceneMeshBuffersMSFT}, - {"xrGetSerializedSceneFragmentDataMSFT", &wine_xrGetSerializedSceneFragmentDataMSFT}, - {"xrGetSpaceBoundary2DFB", &wine_xrGetSpaceBoundary2DFB}, - {"xrGetSpaceBoundingBox2DFB", &wine_xrGetSpaceBoundingBox2DFB}, - {"xrGetSpaceBoundingBox3DFB", &wine_xrGetSpaceBoundingBox3DFB}, - {"xrGetSpaceComponentStatusFB", &wine_xrGetSpaceComponentStatusFB}, - {"xrGetSpaceContainerFB", &wine_xrGetSpaceContainerFB}, - {"xrGetSpaceRoomLayoutFB", &wine_xrGetSpaceRoomLayoutFB}, - {"xrGetSpaceSemanticLabelsFB", &wine_xrGetSpaceSemanticLabelsFB}, - {"xrGetSpaceTriangleMeshMETA", &wine_xrGetSpaceTriangleMeshMETA}, - {"xrGetSpaceUserIdFB", &wine_xrGetSpaceUserIdFB}, - {"xrGetSpaceUuidFB", &wine_xrGetSpaceUuidFB}, - {"xrGetSpatialAnchorNameHTC", &wine_xrGetSpatialAnchorNameHTC}, - {"xrGetSpatialGraphNodeBindingPropertiesMSFT", &wine_xrGetSpatialGraphNodeBindingPropertiesMSFT}, - {"xrGetSwapchainStateFB", &wine_xrGetSwapchainStateFB}, - {"xrGetSystem", &wine_xrGetSystem}, - {"xrGetSystemProperties", &wine_xrGetSystemProperties}, - {"xrGetViewConfigurationProperties", &wine_xrGetViewConfigurationProperties}, - {"xrGetVirtualKeyboardDirtyTexturesMETA", &wine_xrGetVirtualKeyboardDirtyTexturesMETA}, - {"xrGetVirtualKeyboardModelAnimationStatesMETA", &wine_xrGetVirtualKeyboardModelAnimationStatesMETA}, - {"xrGetVirtualKeyboardScaleMETA", &wine_xrGetVirtualKeyboardScaleMETA}, - {"xrGetVirtualKeyboardTextureDataMETA", &wine_xrGetVirtualKeyboardTextureDataMETA}, - {"xrGetVisibilityMaskKHR", &wine_xrGetVisibilityMaskKHR}, - {"xrGetVulkanDeviceExtensionsKHR", &wine_xrGetVulkanDeviceExtensionsKHR}, - {"xrGetVulkanGraphicsDevice2KHR", &wine_xrGetVulkanGraphicsDevice2KHR}, - {"xrGetVulkanGraphicsDeviceKHR", &wine_xrGetVulkanGraphicsDeviceKHR}, - {"xrGetVulkanGraphicsRequirements2KHR", &wine_xrGetVulkanGraphicsRequirements2KHR}, - {"xrGetVulkanGraphicsRequirementsKHR", &wine_xrGetVulkanGraphicsRequirementsKHR}, - {"xrGetVulkanInstanceExtensionsKHR", &wine_xrGetVulkanInstanceExtensionsKHR}, - {"xrImportLocalizationMapML", &wine_xrImportLocalizationMapML}, - {"xrLoadControllerModelMSFT", &wine_xrLoadControllerModelMSFT}, - {"xrLoadRenderModelFB", &wine_xrLoadRenderModelFB}, - {"xrLocateBodyJointsFB", &wine_xrLocateBodyJointsFB}, - {"xrLocateHandJointsEXT", &wine_xrLocateHandJointsEXT}, - {"xrLocateSceneComponentsMSFT", &wine_xrLocateSceneComponentsMSFT}, - {"xrLocateSpace", &wine_xrLocateSpace}, - {"xrLocateSpaces", &wine_xrLocateSpaces}, - {"xrLocateSpacesKHR", &wine_xrLocateSpacesKHR}, - {"xrLocateViews", &wine_xrLocateViews}, - {"xrNegotiateLoaderRuntimeInterface", &wine_xrNegotiateLoaderRuntimeInterface}, - {"xrPassthroughLayerPauseFB", &wine_xrPassthroughLayerPauseFB}, - {"xrPassthroughLayerResumeFB", &wine_xrPassthroughLayerResumeFB}, - {"xrPassthroughLayerSetKeyboardHandsIntensityFB", &wine_xrPassthroughLayerSetKeyboardHandsIntensityFB}, - {"xrPassthroughLayerSetStyleFB", &wine_xrPassthroughLayerSetStyleFB}, - {"xrPassthroughPauseFB", &wine_xrPassthroughPauseFB}, - {"xrPassthroughStartFB", &wine_xrPassthroughStartFB}, - {"xrPathToString", &wine_xrPathToString}, - {"xrPerfSettingsSetPerformanceLevelEXT", &wine_xrPerfSettingsSetPerformanceLevelEXT}, - {"xrPersistSpatialAnchorMSFT", &wine_xrPersistSpatialAnchorMSFT}, - {"xrPollEvent", &wine_xrPollEvent}, - {"xrPollFutureEXT", &wine_xrPollFutureEXT}, - {"xrQueryLocalizationMapsML", &wine_xrQueryLocalizationMapsML}, - {"xrQueryPerformanceMetricsCounterMETA", &wine_xrQueryPerformanceMetricsCounterMETA}, - {"xrQuerySpacesFB", &wine_xrQuerySpacesFB}, - {"xrQuerySystemTrackedKeyboardFB", &wine_xrQuerySystemTrackedKeyboardFB}, - {"xrReleaseSwapchainImage", &wine_xrReleaseSwapchainImage}, - {"xrRequestDisplayRefreshRateFB", &wine_xrRequestDisplayRefreshRateFB}, - {"xrRequestExitSession", &wine_xrRequestExitSession}, - {"xrRequestMapLocalizationML", &wine_xrRequestMapLocalizationML}, - {"xrRequestSceneCaptureFB", &wine_xrRequestSceneCaptureFB}, - {"xrResultToString", &wine_xrResultToString}, - {"xrRetrieveSpaceQueryResultsFB", &wine_xrRetrieveSpaceQueryResultsFB}, - {"xrSaveSpaceFB", &wine_xrSaveSpaceFB}, - {"xrSaveSpaceListFB", &wine_xrSaveSpaceListFB}, - {"xrSendVirtualKeyboardInputMETA", &wine_xrSendVirtualKeyboardInputMETA}, - {"xrSetColorSpaceFB", &wine_xrSetColorSpaceFB}, - {"xrSetDigitalLensControlALMALENCE", &wine_xrSetDigitalLensControlALMALENCE}, - {"xrSetEnvironmentDepthEstimationVARJO", &wine_xrSetEnvironmentDepthEstimationVARJO}, - {"xrSetEnvironmentDepthHandRemovalMETA", &wine_xrSetEnvironmentDepthHandRemovalMETA}, - {"xrSetInputDeviceActiveEXT", &wine_xrSetInputDeviceActiveEXT}, - {"xrSetInputDeviceLocationEXT", &wine_xrSetInputDeviceLocationEXT}, - {"xrSetInputDeviceStateBoolEXT", &wine_xrSetInputDeviceStateBoolEXT}, - {"xrSetInputDeviceStateFloatEXT", &wine_xrSetInputDeviceStateFloatEXT}, - {"xrSetInputDeviceStateVector2fEXT", &wine_xrSetInputDeviceStateVector2fEXT}, - {"xrSetMarkerTrackingPredictionVARJO", &wine_xrSetMarkerTrackingPredictionVARJO}, - {"xrSetMarkerTrackingTimeoutVARJO", &wine_xrSetMarkerTrackingTimeoutVARJO}, - {"xrSetMarkerTrackingVARJO", &wine_xrSetMarkerTrackingVARJO}, - {"xrSetPerformanceMetricsStateMETA", &wine_xrSetPerformanceMetricsStateMETA}, - {"xrSetSpaceComponentStatusFB", &wine_xrSetSpaceComponentStatusFB}, - {"xrSetTrackingOptimizationSettingsHintQCOM", &wine_xrSetTrackingOptimizationSettingsHintQCOM}, - {"xrSetViewOffsetVARJO", &wine_xrSetViewOffsetVARJO}, - {"xrSetVirtualKeyboardModelVisibilityMETA", &wine_xrSetVirtualKeyboardModelVisibilityMETA}, - {"xrShareSpacesFB", &wine_xrShareSpacesFB}, - {"xrSnapshotMarkerDetectorML", &wine_xrSnapshotMarkerDetectorML}, - {"xrStartEnvironmentDepthProviderMETA", &wine_xrStartEnvironmentDepthProviderMETA}, - {"xrStopEnvironmentDepthProviderMETA", &wine_xrStopEnvironmentDepthProviderMETA}, - {"xrStopHapticFeedback", &wine_xrStopHapticFeedback}, - {"xrStringToPath", &wine_xrStringToPath}, - {"xrStructureTypeToString", &wine_xrStructureTypeToString}, - {"xrSuggestInteractionProfileBindings", &wine_xrSuggestInteractionProfileBindings}, - {"xrSuggestVirtualKeyboardLocationMETA", &wine_xrSuggestVirtualKeyboardLocationMETA}, - {"xrSyncActions", &wine_xrSyncActions}, - {"xrThermalGetTemperatureTrendEXT", &wine_xrThermalGetTemperatureTrendEXT}, - {"xrTriangleMeshBeginUpdateFB", &wine_xrTriangleMeshBeginUpdateFB}, - {"xrTriangleMeshBeginVertexBufferUpdateFB", &wine_xrTriangleMeshBeginVertexBufferUpdateFB}, - {"xrTriangleMeshEndUpdateFB", &wine_xrTriangleMeshEndUpdateFB}, - {"xrTriangleMeshEndVertexBufferUpdateFB", &wine_xrTriangleMeshEndVertexBufferUpdateFB}, - {"xrTriangleMeshGetIndexBufferFB", &wine_xrTriangleMeshGetIndexBufferFB}, - {"xrTriangleMeshGetVertexBufferFB", &wine_xrTriangleMeshGetVertexBufferFB}, - {"xrTryCreateSpatialGraphStaticNodeBindingMSFT", &wine_xrTryCreateSpatialGraphStaticNodeBindingMSFT}, - {"xrUnpersistSpatialAnchorMSFT", &wine_xrUnpersistSpatialAnchorMSFT}, - {"xrUpdateHandMeshMSFT", &wine_xrUpdateHandMeshMSFT}, - {"xrUpdatePassthroughColorLutMETA", &wine_xrUpdatePassthroughColorLutMETA}, - {"xrUpdateSwapchainFB", &wine_xrUpdateSwapchainFB}, - {"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; + params->result = g_xr_host_instance_dispatch_table.p_xrWaitSwapchainImage(wine_swapchain_from_handle(params->swapchain)->host_swapchain, params->waitInfo); + return STATUS_SUCCESS; } +#endif /* _WIN64 */ static const char * const xr_extensions[] = { @@ -2794,7 +3252,6 @@ static const char * const xr_extensions[] = "XR_HTCX_vive_tracker_interaction", "XR_HTC_anchor", "XR_HTC_facial_tracking", - "XR_HTC_foveation", "XR_HTC_hand_interaction", "XR_HTC_passthrough", "XR_HTC_vive_cosmos_controller_interaction", @@ -2882,3 +3339,282 @@ BOOL wine_xr_extension_supported(const char *name) } return FALSE; } + +BOOL wine_xr_is_type_wrapped(XrObjectType type) +{ + return FALSE || + type == XR_OBJECT_TYPE_INSTANCE || + type == XR_OBJECT_TYPE_SESSION || + type == XR_OBJECT_TYPE_SWAPCHAIN; +} + +#ifdef _WIN64 + +const unixlib_entry_t __wine_unix_call_funcs[] = +{ + init_openxr, + thunk64_xrAcquireEnvironmentDepthImageMETA, + thunk64_xrAcquireSwapchainImage, + thunk64_xrApplyForceFeedbackCurlMNDX, + thunk64_xrApplyHapticFeedback, + thunk64_xrAttachSessionActionSets, + thunk64_xrBeginFrame, + thunk64_xrBeginPlaneDetectionEXT, + thunk64_xrBeginSession, + thunk64_xrCancelFutureEXT, + thunk64_xrChangeVirtualKeyboardTextContextMETA, + thunk64_xrClearSpatialAnchorStoreMSFT, + thunk64_xrComputeNewSceneMSFT, + thunk64_xrCreateAction, + thunk64_xrCreateActionSet, + thunk64_xrCreateActionSpace, + thunk64_xrCreateBodyTrackerFB, + thunk64_xrCreateEnvironmentDepthProviderMETA, + thunk64_xrCreateEnvironmentDepthSwapchainMETA, + thunk64_xrCreateExportedLocalizationMapML, + thunk64_xrCreateEyeTrackerFB, + thunk64_xrCreateFaceTracker2FB, + thunk64_xrCreateFaceTrackerFB, + thunk64_xrCreateFacialTrackerHTC, + thunk64_xrCreateFoveationProfileFB, + thunk64_xrCreateGeometryInstanceFB, + thunk64_xrCreateHandMeshSpaceMSFT, + thunk64_xrCreateHandTrackerEXT, + thunk64_xrCreateInstance, + thunk64_xrCreateKeyboardSpaceFB, + thunk64_xrCreateMarkerDetectorML, + thunk64_xrCreateMarkerSpaceML, + thunk64_xrCreateMarkerSpaceVARJO, + thunk64_xrCreatePassthroughColorLutMETA, + thunk64_xrCreatePassthroughFB, + thunk64_xrCreatePassthroughHTC, + thunk64_xrCreatePassthroughLayerFB, + thunk64_xrCreatePlaneDetectorEXT, + thunk64_xrCreateReferenceSpace, + thunk64_xrCreateSceneMSFT, + thunk64_xrCreateSceneObserverMSFT, + thunk64_xrCreateSession, + thunk64_xrCreateSpaceUserFB, + thunk64_xrCreateSpatialAnchorFB, + thunk64_xrCreateSpatialAnchorFromPersistedNameMSFT, + thunk64_xrCreateSpatialAnchorHTC, + thunk64_xrCreateSpatialAnchorMSFT, + thunk64_xrCreateSpatialAnchorSpaceMSFT, + thunk64_xrCreateSpatialAnchorStoreConnectionMSFT, + thunk64_xrCreateSpatialGraphNodeSpaceMSFT, + thunk64_xrCreateSwapchain, + thunk64_xrCreateTriangleMeshFB, + thunk64_xrCreateVirtualKeyboardMETA, + thunk64_xrCreateVirtualKeyboardSpaceMETA, + thunk64_xrDeserializeSceneMSFT, + thunk64_xrDestroyAction, + thunk64_xrDestroyActionSet, + thunk64_xrDestroyBodyTrackerFB, + thunk64_xrDestroyEnvironmentDepthProviderMETA, + thunk64_xrDestroyEnvironmentDepthSwapchainMETA, + thunk64_xrDestroyExportedLocalizationMapML, + thunk64_xrDestroyEyeTrackerFB, + thunk64_xrDestroyFaceTracker2FB, + thunk64_xrDestroyFaceTrackerFB, + thunk64_xrDestroyFacialTrackerHTC, + thunk64_xrDestroyFoveationProfileFB, + thunk64_xrDestroyGeometryInstanceFB, + thunk64_xrDestroyHandTrackerEXT, + thunk64_xrDestroyInstance, + thunk64_xrDestroyMarkerDetectorML, + thunk64_xrDestroyPassthroughColorLutMETA, + thunk64_xrDestroyPassthroughFB, + thunk64_xrDestroyPassthroughHTC, + thunk64_xrDestroyPassthroughLayerFB, + thunk64_xrDestroyPlaneDetectorEXT, + thunk64_xrDestroySceneMSFT, + thunk64_xrDestroySceneObserverMSFT, + thunk64_xrDestroySession, + thunk64_xrDestroySpace, + thunk64_xrDestroySpaceUserFB, + thunk64_xrDestroySpatialAnchorMSFT, + thunk64_xrDestroySpatialAnchorStoreConnectionMSFT, + thunk64_xrDestroySpatialGraphNodeBindingMSFT, + thunk64_xrDestroySwapchain, + thunk64_xrDestroyTriangleMeshFB, + thunk64_xrDestroyVirtualKeyboardMETA, + thunk64_xrEnableLocalizationEventsML, + thunk64_xrEnableUserCalibrationEventsML, + thunk64_xrEndFrame, + thunk64_xrEndSession, + thunk64_xrEnumerateApiLayerProperties, + thunk64_xrEnumerateBoundSourcesForAction, + thunk64_xrEnumerateColorSpacesFB, + thunk64_xrEnumerateDisplayRefreshRatesFB, + thunk64_xrEnumerateEnvironmentBlendModes, + thunk64_xrEnumerateEnvironmentDepthSwapchainImagesMETA, + thunk64_xrEnumerateExternalCamerasOCULUS, + thunk64_xrEnumerateInstanceExtensionProperties, + thunk64_xrEnumeratePerformanceMetricsCounterPathsMETA, + thunk64_xrEnumeratePersistedSpatialAnchorNamesMSFT, + thunk64_xrEnumerateReferenceSpaces, + thunk64_xrEnumerateRenderModelPathsFB, + thunk64_xrEnumerateReprojectionModesMSFT, + thunk64_xrEnumerateSceneComputeFeaturesMSFT, + thunk64_xrEnumerateSpaceSupportedComponentsFB, + thunk64_xrEnumerateSwapchainFormats, + thunk64_xrEnumerateSwapchainImages, + thunk64_xrEnumerateViewConfigurationViews, + thunk64_xrEnumerateViewConfigurations, + thunk64_xrEnumerateViveTrackerPathsHTCX, + thunk64_xrEraseSpaceFB, + thunk64_xrGeometryInstanceSetTransformFB, + thunk64_xrGetActionStateBoolean, + thunk64_xrGetActionStateFloat, + thunk64_xrGetActionStatePose, + thunk64_xrGetActionStateVector2f, + thunk64_xrGetAudioInputDeviceGuidOculus, + thunk64_xrGetAudioOutputDeviceGuidOculus, + thunk64_xrGetBodySkeletonFB, + thunk64_xrGetControllerModelKeyMSFT, + thunk64_xrGetControllerModelPropertiesMSFT, + thunk64_xrGetControllerModelStateMSFT, + thunk64_xrGetCurrentInteractionProfile, + thunk64_xrGetDeviceSampleRateFB, + thunk64_xrGetDisplayRefreshRateFB, + thunk64_xrGetEnvironmentDepthSwapchainStateMETA, + thunk64_xrGetExportedLocalizationMapDataML, + thunk64_xrGetEyeGazesFB, + thunk64_xrGetFaceExpressionWeights2FB, + thunk64_xrGetFaceExpressionWeightsFB, + thunk64_xrGetFacialExpressionsHTC, + thunk64_xrGetFoveationEyeTrackedStateMETA, + thunk64_xrGetHandMeshFB, + thunk64_xrGetInputSourceLocalizedName, + thunk64_xrGetInstanceProperties, + thunk64_xrGetMarkerDetectorStateML, + thunk64_xrGetMarkerLengthML, + thunk64_xrGetMarkerNumberML, + thunk64_xrGetMarkerReprojectionErrorML, + thunk64_xrGetMarkerSizeVARJO, + thunk64_xrGetMarkerStringML, + thunk64_xrGetMarkersML, + thunk64_xrGetOpenGLGraphicsRequirementsKHR, + thunk64_xrGetPassthroughPreferencesMETA, + thunk64_xrGetPerformanceMetricsStateMETA, + thunk64_xrGetPlaneDetectionStateEXT, + thunk64_xrGetPlaneDetectionsEXT, + thunk64_xrGetPlanePolygonBufferEXT, + thunk64_xrGetRecommendedLayerResolutionMETA, + thunk64_xrGetReferenceSpaceBoundsRect, + thunk64_xrGetRenderModelPropertiesFB, + thunk64_xrGetSceneComponentsMSFT, + thunk64_xrGetSceneComputeStateMSFT, + thunk64_xrGetSceneMarkerDecodedStringMSFT, + thunk64_xrGetSceneMarkerRawDataMSFT, + thunk64_xrGetSceneMeshBuffersMSFT, + thunk64_xrGetSerializedSceneFragmentDataMSFT, + thunk64_xrGetSpaceBoundary2DFB, + thunk64_xrGetSpaceBoundingBox2DFB, + thunk64_xrGetSpaceBoundingBox3DFB, + thunk64_xrGetSpaceComponentStatusFB, + thunk64_xrGetSpaceContainerFB, + thunk64_xrGetSpaceRoomLayoutFB, + thunk64_xrGetSpaceSemanticLabelsFB, + thunk64_xrGetSpaceTriangleMeshMETA, + thunk64_xrGetSpaceUserIdFB, + thunk64_xrGetSpaceUuidFB, + thunk64_xrGetSpatialAnchorNameHTC, + thunk64_xrGetSpatialGraphNodeBindingPropertiesMSFT, + thunk64_xrGetSwapchainStateFB, + thunk64_xrGetSystem, + thunk64_xrGetSystemProperties, + thunk64_xrGetViewConfigurationProperties, + thunk64_xrGetVirtualKeyboardDirtyTexturesMETA, + thunk64_xrGetVirtualKeyboardModelAnimationStatesMETA, + thunk64_xrGetVirtualKeyboardScaleMETA, + thunk64_xrGetVirtualKeyboardTextureDataMETA, + thunk64_xrGetVisibilityMaskKHR, + thunk64_xrGetVulkanDeviceExtensionsKHR, + thunk64_xrGetVulkanGraphicsDevice2KHR, + thunk64_xrGetVulkanGraphicsDeviceKHR, + thunk64_xrGetVulkanGraphicsRequirements2KHR, + thunk64_xrGetVulkanGraphicsRequirementsKHR, + thunk64_xrGetVulkanInstanceExtensionsKHR, + thunk64_xrImportLocalizationMapML, + thunk64_xrLoadControllerModelMSFT, + thunk64_xrLoadRenderModelFB, + thunk64_xrLocateBodyJointsFB, + thunk64_xrLocateHandJointsEXT, + thunk64_xrLocateSceneComponentsMSFT, + thunk64_xrLocateSpace, + thunk64_xrLocateSpaces, + thunk64_xrLocateSpacesKHR, + thunk64_xrLocateViews, + thunk64_xrPassthroughLayerPauseFB, + thunk64_xrPassthroughLayerResumeFB, + thunk64_xrPassthroughLayerSetKeyboardHandsIntensityFB, + thunk64_xrPassthroughLayerSetStyleFB, + thunk64_xrPassthroughPauseFB, + thunk64_xrPassthroughStartFB, + thunk64_xrPathToString, + thunk64_xrPerfSettingsSetPerformanceLevelEXT, + thunk64_xrPersistSpatialAnchorMSFT, + thunk64_xrPollEvent, + thunk64_xrPollFutureEXT, + thunk64_xrQueryLocalizationMapsML, + thunk64_xrQueryPerformanceMetricsCounterMETA, + thunk64_xrQuerySpacesFB, + thunk64_xrQuerySystemTrackedKeyboardFB, + thunk64_xrReleaseSwapchainImage, + thunk64_xrRequestDisplayRefreshRateFB, + thunk64_xrRequestExitSession, + thunk64_xrRequestMapLocalizationML, + thunk64_xrRequestSceneCaptureFB, + thunk64_xrResultToString, + thunk64_xrRetrieveSpaceQueryResultsFB, + thunk64_xrSaveSpaceFB, + thunk64_xrSaveSpaceListFB, + thunk64_xrSendVirtualKeyboardInputMETA, + thunk64_xrSetColorSpaceFB, + thunk64_xrSetDigitalLensControlALMALENCE, + thunk64_xrSetEnvironmentDepthEstimationVARJO, + thunk64_xrSetEnvironmentDepthHandRemovalMETA, + thunk64_xrSetInputDeviceActiveEXT, + thunk64_xrSetInputDeviceLocationEXT, + thunk64_xrSetInputDeviceStateBoolEXT, + thunk64_xrSetInputDeviceStateFloatEXT, + thunk64_xrSetInputDeviceStateVector2fEXT, + thunk64_xrSetMarkerTrackingPredictionVARJO, + thunk64_xrSetMarkerTrackingTimeoutVARJO, + thunk64_xrSetMarkerTrackingVARJO, + thunk64_xrSetPerformanceMetricsStateMETA, + thunk64_xrSetSpaceComponentStatusFB, + thunk64_xrSetTrackingOptimizationSettingsHintQCOM, + thunk64_xrSetViewOffsetVARJO, + thunk64_xrSetVirtualKeyboardModelVisibilityMETA, + thunk64_xrShareSpacesFB, + thunk64_xrSnapshotMarkerDetectorML, + thunk64_xrStartEnvironmentDepthProviderMETA, + thunk64_xrStopEnvironmentDepthProviderMETA, + thunk64_xrStopHapticFeedback, + thunk64_xrStringToPath, + thunk64_xrStructureTypeToString, + thunk64_xrSuggestInteractionProfileBindings, + thunk64_xrSuggestVirtualKeyboardLocationMETA, + thunk64_xrSyncActions, + thunk64_xrThermalGetTemperatureTrendEXT, + thunk64_xrTriangleMeshBeginUpdateFB, + thunk64_xrTriangleMeshBeginVertexBufferUpdateFB, + thunk64_xrTriangleMeshEndUpdateFB, + thunk64_xrTriangleMeshEndVertexBufferUpdateFB, + thunk64_xrTriangleMeshGetIndexBufferFB, + thunk64_xrTriangleMeshGetVertexBufferFB, + thunk64_xrTryCreateSpatialGraphStaticNodeBindingMSFT, + thunk64_xrUnpersistSpatialAnchorMSFT, + thunk64_xrUpdateHandMeshMSFT, + thunk64_xrUpdatePassthroughColorLutMETA, + thunk64_xrUpdateSwapchainFB, + thunk64_xrWaitFrame, + thunk64_xrWaitSwapchainImage, +}; +C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count); + +#endif /* _WIN64 */ + +C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count); diff --git a/wineopenxr/openxr_thunks.h b/wineopenxr/openxr_thunks.h index 2031aa08..79ce95ec 100644 --- a/wineopenxr/openxr_thunks.h +++ b/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 WINAPI wine_xrBeginFrame(XrSession session, const XrFrameBeginInfo *frameBeginInfo); -XrResult WINAPI wine_xrConvertTimeToWin32PerformanceCounterKHR(XrInstance instance, XrTime time, LARGE_INTEGER *performanceCounter); -XrResult WINAPI wine_xrConvertWin32PerformanceCounterToTimeKHR(XrInstance instance, const LARGE_INTEGER *performanceCounter, XrTime *time); -XrResult WINAPI wine_xrCreateApiLayerInstance(const XrInstanceCreateInfo *info, const XrApiLayerCreateInfo *layerInfo, XrInstance *instance); -XrResult WINAPI wine_xrCreateInstance(const XrInstanceCreateInfo *createInfo, XrInstance *instance); -XrResult WINAPI wine_xrCreateSession(XrInstance instance, const XrSessionCreateInfo *createInfo, XrSession *session); -XrResult WINAPI wine_xrCreateSwapchain(XrSession session, const XrSwapchainCreateInfo *createInfo, XrSwapchain *swapchain); -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); +XrResult wine_xrCreateInstance(const XrInstanceCreateInfo *createInfo, XrInstance *instance); +XrResult wine_xrCreateSession(XrInstance instance, const XrSessionCreateInfo *createInfo, XrSession *session); +XrResult wine_xrCreateSwapchain(XrSession session, const XrSwapchainCreateInfo *createInfo, XrSwapchain *swapchain); +XrResult wine_xrEnumerateInstanceExtensionProperties(const char *layerName, uint32_t propertyCapacityInput, uint32_t *propertyCountOutput, XrExtensionProperties *properties); +XrResult wine_xrGetVulkanDeviceExtensionsKHR(XrInstance instance, XrSystemId systemId, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer); +XrResult wine_xrGetVulkanGraphicsDevice2KHR(XrInstance instance, const XrVulkanGraphicsDeviceGetInfoKHR *getInfo, VkPhysicalDevice *vulkanPhysicalDevice); +XrResult wine_xrGetVulkanGraphicsDeviceKHR(XrInstance instance, XrSystemId systemId, VkInstance vkInstance, VkPhysicalDevice *vkPhysicalDevice); +XrResult wine_xrGetVulkanInstanceExtensionsKHR(XrInstance instance, XrSystemId systemId, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer); /* 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) \ diff --git a/wineopenxr/vkd3d-proton-interop.h b/wineopenxr/vkd3d-proton-interop.h index 34c2cb12..27a26e86 100644 --- a/wineopenxr/vkd3d-proton-interop.h +++ b/wineopenxr/vkd3d-proton-interop.h @@ -3,7 +3,11 @@ #pragma once #include +#ifdef __WINESRC__ +#include "wine/vulkan.h" +#else #include +#endif #ifndef __ID3D12DeviceExt1_FWD_DEFINED__ #define __ID3D12DeviceExt1_FWD_DEFINED__ diff --git a/wineopenxr/wineopenxr.h b/wineopenxr/wineopenxr.h index 4d55f8a2..a22938f4 100644 --- a/wineopenxr/wineopenxr.h +++ b/wineopenxr/wineopenxr.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. @@ -43,7 +43,7 @@ #define WINE_XR_ALIGN DECLSPEC_ALIGN #endif -#ifdef __x86_64__ +#if defined(__x86_64__) || defined(__aarch64__) #define XR_PTR_SIZE 8 #endif @@ -187,6 +187,8 @@ #define XR_FB_HAND_TRACKING_MESH_EXTENSION_NAME "XR_FB_hand_tracking_mesh" #define XR_FB_hand_tracking_aim_SPEC_VERSION 2 #define XR_FB_HAND_TRACKING_AIM_EXTENSION_NAME "XR_FB_hand_tracking_aim" +#define XR_FB_HAND_TRACKING_CAPSULE_POINT_COUNT XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB +#define XR_FB_HAND_TRACKING_CAPSULE_COUNT XR_HAND_TRACKING_CAPSULE_COUNT_FB #define XR_FB_hand_tracking_capsules_SPEC_VERSION 3 #define XR_FB_HAND_TRACKING_CAPSULES_EXTENSION_NAME "XR_FB_hand_tracking_capsules" #define XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB 2 @@ -333,8 +335,6 @@ #define XR_QCOM_TRACKING_OPTIMIZATION_SETTINGS_EXTENSION_NAME "XR_QCOM_tracking_optimization_settings" #define XR_HTC_passthrough_SPEC_VERSION 1 #define XR_HTC_PASSTHROUGH_EXTENSION_NAME "XR_HTC_passthrough" -#define XR_HTC_foveation_SPEC_VERSION 1 -#define XR_HTC_FOVEATION_EXTENSION_NAME "XR_HTC_foveation" #define XR_HTC_anchor_SPEC_VERSION 1 #define XR_HTC_ANCHOR_EXTENSION_NAME "XR_HTC_anchor" #define XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_HTC 256 @@ -539,17 +539,17 @@ XR_DEFINE_HANDLE(XrSwapchain) XR_DEFINE_HANDLE(XrTriangleMeshFB) XR_DEFINE_HANDLE(XrVirtualKeyboardMETA) -XR_DEFINE_ATOM(XrAsyncRequestIdFB) +typedef uint64_t XrAsyncRequestIdFB; typedef uint32_t XrBool32; -XR_DEFINE_ATOM(XrControllerModelKeyMSFT) +typedef uint64_t XrControllerModelKeyMSFT; typedef int64_t XrDuration; typedef uint64_t XrFlags64; -XR_DEFINE_OPAQUE_64(XrFutureEXT) -XR_DEFINE_ATOM(XrMarkerML) -XR_DEFINE_ATOM(XrPath) -XR_DEFINE_ATOM(XrRenderModelKeyFB) +typedef struct XrFutureEXT_T* XrFutureEXT; +typedef uint64_t XrMarkerML; +typedef uint64_t XrPath; +typedef uint64_t XrRenderModelKeyFB; typedef uint64_t XrSpaceUserIdFB; -XR_DEFINE_ATOM(XrSystemId) +typedef uint64_t XrSystemId; typedef int64_t XrTime; typedef uint64_t XrVersion; @@ -730,6 +730,20 @@ typedef enum XrCompareOpFB XR_COMPARE_OP_FB_MAX_ENUM = 0x7fffffff, } XrCompareOpFB; +typedef enum XrCompositionLayerFlagBits +{ + XR_COMPOSITION_LAYER_CORRECT_CHROMATIC_ABERRATION_BIT = 0x00000001, + XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT = 0x00000002, + XR_COMPOSITION_LAYER_UNPREMULTIPLIED_ALPHA_BIT = 0x00000004, + XR_COMPOSITION_LAYER_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} XrCompositionLayerFlagBits; + +typedef enum XrDigitalLensControlFlagBitsALMALENCE +{ + XR_DIGITAL_LENS_CONTROL_PROCESSING_DISABLE_BIT_ALMALENCE = 0x00000001, + XR_DIGITAL_LENS_CONTROL_FLAG_BITS_ALMALENCE_MAX_ENUM = 0x7fffffff, +} XrDigitalLensControlFlagBitsALMALENCE; + typedef enum XrEnvironmentBlendMode { XR_ENVIRONMENT_BLEND_MODE_OPAQUE = 1, @@ -757,6 +771,16 @@ typedef enum XrExternalCameraAttachedToDeviceOCULUS XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_OCULUS_MAX_ENUM = 0x7fffffff, } XrExternalCameraAttachedToDeviceOCULUS; +typedef enum XrExternalCameraStatusFlagBitsOCULUS +{ + XR_EXTERNAL_CAMERA_STATUS_CONNECTED_BIT_OCULUS = 0x00000001, + XR_EXTERNAL_CAMERA_STATUS_CALIBRATING_BIT_OCULUS = 0x00000002, + XR_EXTERNAL_CAMERA_STATUS_CALIBRATION_FAILED_BIT_OCULUS = 0x00000004, + XR_EXTERNAL_CAMERA_STATUS_CALIBRATED_BIT_OCULUS = 0x00000008, + XR_EXTERNAL_CAMERA_STATUS_CAPTURING_BIT_OCULUS = 0x00000010, + XR_EXTERNAL_CAMERA_STATUS_FLAG_BITS_OCULUS_MAX_ENUM = 0x7fffffff, +} XrExternalCameraStatusFlagBitsOCULUS; + typedef enum XrEyeCalibrationStatusML { XR_EYE_CALIBRATION_STATUS_UNKNOWN_ML = 0, @@ -1032,24 +1056,6 @@ typedef enum XrFoveationLevelFB XR_FOVEATION_LEVEL_FB_MAX_ENUM = 0x7fffffff, } XrFoveationLevelFB; -typedef enum XrFoveationLevelHTC -{ - XR_FOVEATION_LEVEL_NONE_HTC = 0, - XR_FOVEATION_LEVEL_LOW_HTC = 1, - XR_FOVEATION_LEVEL_MEDIUM_HTC = 2, - XR_FOVEATION_LEVEL_HIGH_HTC = 3, - XR_FOVEATION_LEVEL_HTC_MAX_ENUM = 0x7fffffff, -} XrFoveationLevelHTC; - -typedef enum XrFoveationModeHTC -{ - XR_FOVEATION_MODE_DISABLE_HTC = 0, - XR_FOVEATION_MODE_FIXED_HTC = 1, - XR_FOVEATION_MODE_DYNAMIC_HTC = 2, - XR_FOVEATION_MODE_CUSTOM_HTC = 3, - XR_FOVEATION_MODE_HTC_MAX_ENUM = 0x7fffffff, -} XrFoveationModeHTC; - typedef enum XrFutureStateEXT { XR_FUTURE_STATE_PENDING_EXT = 1, @@ -1164,6 +1170,35 @@ typedef enum XrHeadsetFitStatusML XR_HEADSET_FIT_STATUS_ML_MAX_ENUM = 0x7fffffff, } XrHeadsetFitStatusML; +typedef enum XrInputSourceLocalizedNameFlagBits +{ + XR_INPUT_SOURCE_LOCALIZED_NAME_USER_PATH_BIT = 0x00000001, + XR_INPUT_SOURCE_LOCALIZED_NAME_INTERACTION_PROFILE_BIT = 0x00000002, + XR_INPUT_SOURCE_LOCALIZED_NAME_COMPONENT_BIT = 0x00000004, + XR_INPUT_SOURCE_LOCALIZED_NAME_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} XrInputSourceLocalizedNameFlagBits; + +typedef enum XrInstanceCreateFlagBits +{ + XR_INSTANCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} XrInstanceCreateFlagBits; + +typedef enum XrKeyboardTrackingFlagBitsFB +{ + XR_KEYBOARD_TRACKING_EXISTS_BIT_FB = 0x00000001, + XR_KEYBOARD_TRACKING_LOCAL_BIT_FB = 0x00000002, + XR_KEYBOARD_TRACKING_REMOTE_BIT_FB = 0x00000004, + XR_KEYBOARD_TRACKING_CONNECTED_BIT_FB = 0x00000008, + XR_KEYBOARD_TRACKING_FLAG_BITS_FB_MAX_ENUM = 0x7fffffff, +} XrKeyboardTrackingFlagBitsFB; + +typedef enum XrKeyboardTrackingQueryFlagBitsFB +{ + XR_KEYBOARD_TRACKING_QUERY_LOCAL_BIT_FB = 0x00000002, + XR_KEYBOARD_TRACKING_QUERY_REMOTE_BIT_FB = 0x00000004, + XR_KEYBOARD_TRACKING_QUERY_FLAG_BITS_FB_MAX_ENUM = 0x7fffffff, +} XrKeyboardTrackingQueryFlagBitsFB; + typedef enum XrLipExpressionHTC { XR_LIP_EXPRESSION_JAW_RIGHT_HTC = 0, @@ -1415,6 +1450,13 @@ typedef enum XrPassthroughColorLutChannelsMETA XR_PASSTHROUGH_COLOR_LUT_CHANNELS_META_MAX_ENUM = 0x7fffffff, } XrPassthroughColorLutChannelsMETA; +typedef enum XrPassthroughFlagBitsFB +{ + XR_PASSTHROUGH_IS_RUNNING_AT_CREATION_BIT_FB = 0x00000001, + XR_PASSTHROUGH_LAYER_DEPTH_BIT_FB = 0x00000002, + XR_PASSTHROUGH_FLAG_BITS_FB_MAX_ENUM = 0x7fffffff, +} XrPassthroughFlagBitsFB; + typedef enum XrPassthroughFormHTC { XR_PASSTHROUGH_FORM_PLANAR_HTC = 0, @@ -1469,6 +1511,14 @@ typedef enum XrPerfSettingsSubDomainEXT XR_PERF_SETTINGS_SUB_DOMAIN_EXT_MAX_ENUM = 0x7fffffff, } XrPerfSettingsSubDomainEXT; +typedef enum XrPerformanceMetricsCounterFlagBitsMETA +{ + XR_PERFORMANCE_METRICS_COUNTER_ANY_VALUE_VALID_BIT_META = 0x00000001, + XR_PERFORMANCE_METRICS_COUNTER_UINT_VALUE_VALID_BIT_META = 0x00000002, + XR_PERFORMANCE_METRICS_COUNTER_FLOAT_VALUE_VALID_BIT_META = 0x00000004, + XR_PERFORMANCE_METRICS_COUNTER_FLAG_BITS_META_MAX_ENUM = 0x7fffffff, +} XrPerformanceMetricsCounterFlagBitsMETA; + typedef enum XrPerformanceMetricsCounterUnitMETA { XR_PERFORMANCE_METRICS_COUNTER_UNIT_GENERIC_META = 0, @@ -1489,6 +1539,12 @@ typedef enum XrPlaneDetectionStateEXT XR_PLANE_DETECTION_STATE_EXT_MAX_ENUM = 0x7fffffff, } XrPlaneDetectionStateEXT; +typedef enum XrPlaneDetectorFlagBitsEXT +{ + XR_PLANE_DETECTOR_ENABLE_CONTOUR_BIT_EXT = 0x00000001, + XR_PLANE_DETECTOR_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff, +} XrPlaneDetectorFlagBitsEXT; + typedef enum XrPlaneDetectorOrientationEXT { XR_PLANE_DETECTOR_ORIENTATION_HORIZONTAL_UPWARD_EXT = 0, @@ -1521,6 +1577,13 @@ typedef enum XrReferenceSpaceType XR_REFERENCE_SPACE_TYPE_MAX_ENUM = 0x7fffffff, } XrReferenceSpaceType; +typedef enum XrRenderModelFlagBitsFB +{ + XR_RENDER_MODEL_SUPPORTS_GLTF_2_0_SUBSET_1_BIT_FB = 0x00000001, + XR_RENDER_MODEL_SUPPORTS_GLTF_2_0_SUBSET_2_BIT_FB = 0x00000002, + XR_RENDER_MODEL_FLAG_BITS_FB_MAX_ENUM = 0x7fffffff, +} XrRenderModelFlagBitsFB; + typedef enum XrReprojectionModeMSFT { XR_REPROJECTION_MODE_DEPTH_MSFT = 1, @@ -1729,6 +1792,11 @@ typedef enum XrSemanticLabelsSupportFlagBitsFB XR_SEMANTIC_LABELS_SUPPORT_FLAG_BITS_FB_MAX_ENUM = 0x7fffffff, } XrSemanticLabelsSupportFlagBitsFB; +typedef enum XrSessionCreateFlagBits +{ + XR_SESSION_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} XrSessionCreateFlagBits; + typedef enum XrSessionState { XR_SESSION_STATE_UNKNOWN = 0, @@ -1757,6 +1825,15 @@ typedef enum XrSpaceComponentTypeFB XR_SPACE_COMPONENT_TYPE_FB_MAX_ENUM = 0x7fffffff, } XrSpaceComponentTypeFB; +typedef enum XrSpaceLocationFlagBits +{ + XR_SPACE_LOCATION_ORIENTATION_VALID_BIT = 0x00000001, + XR_SPACE_LOCATION_POSITION_VALID_BIT = 0x00000002, + XR_SPACE_LOCATION_ORIENTATION_TRACKED_BIT = 0x00000004, + XR_SPACE_LOCATION_POSITION_TRACKED_BIT = 0x00000008, + XR_SPACE_LOCATION_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} XrSpaceLocationFlagBits; + typedef enum XrSpacePersistenceModeFB { XR_SPACE_PERSISTENCE_MODE_INVALID_FB = 0, @@ -1778,6 +1855,13 @@ typedef enum XrSpaceStorageLocationFB XR_SPACE_STORAGE_LOCATION_FB_MAX_ENUM = 0x7fffffff, } XrSpaceStorageLocationFB; +typedef enum XrSpaceVelocityFlagBits +{ + XR_SPACE_VELOCITY_LINEAR_VALID_BIT = 0x00000001, + XR_SPACE_VELOCITY_ANGULAR_VALID_BIT = 0x00000002, + XR_SPACE_VELOCITY_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} XrSpaceVelocityFlagBits; + typedef enum XrSpatialGraphNodeTypeMSFT { XR_SPATIAL_GRAPH_NODE_TYPE_STATIC_MSFT = 1, @@ -2097,9 +2181,6 @@ typedef enum XrStructureType XR_TYPE_PASSTHROUGH_COLOR_HTC = 1000317002, XR_TYPE_PASSTHROUGH_MESH_TRANSFORM_INFO_HTC = 1000317003, XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_HTC = 1000317004, - XR_TYPE_FOVEATION_APPLY_INFO_HTC = 1000318000, - XR_TYPE_FOVEATION_DYNAMIC_MODE_INFO_HTC = 1000318001, - XR_TYPE_FOVEATION_CUSTOM_MODE_INFO_HTC = 1000318002, XR_TYPE_SYSTEM_ANCHOR_PROPERTIES_HTC = 1000319000, XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_HTC = 1000319001, XR_TYPE_ACTIVE_ACTION_SET_PRIORITIES_EXT = 1000373000, @@ -2136,6 +2217,27 @@ typedef enum XrStructureType XR_STRUCTURE_TYPE_MAX_ENUM = 0x7fffffff, } XrStructureType; +typedef enum XrSwapchainCreateFlagBits +{ + XR_SWAPCHAIN_CREATE_PROTECTED_CONTENT_BIT = 0x00000001, + XR_SWAPCHAIN_CREATE_STATIC_IMAGE_BIT = 0x00000002, + XR_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} XrSwapchainCreateFlagBits; + +typedef enum XrSwapchainUsageFlagBits +{ + XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT = 0x00000001, + XR_SWAPCHAIN_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000002, + XR_SWAPCHAIN_USAGE_UNORDERED_ACCESS_BIT = 0x00000004, + XR_SWAPCHAIN_USAGE_TRANSFER_SRC_BIT = 0x00000008, + XR_SWAPCHAIN_USAGE_TRANSFER_DST_BIT = 0x00000010, + XR_SWAPCHAIN_USAGE_SAMPLED_BIT = 0x00000020, + XR_SWAPCHAIN_USAGE_MUTABLE_FORMAT_BIT = 0x00000040, + XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_MND = 0x00000080, + XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_KHR = XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_MND, + XR_SWAPCHAIN_USAGE_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} XrSwapchainUsageFlagBits; + typedef enum XrTrackingOptimizationSettingsDomainQCOM { XR_TRACKING_OPTIMIZATION_SETTINGS_DOMAIN_ALL_QCOM = 1, @@ -2152,6 +2254,12 @@ typedef enum XrTrackingOptimizationSettingsHintQCOM XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_QCOM_MAX_ENUM = 0x7fffffff, } XrTrackingOptimizationSettingsHintQCOM; +typedef enum XrTriangleMeshFlagBitsFB +{ + XR_TRIANGLE_MESH_MUTABLE_BIT_FB = 0x00000001, + XR_TRIANGLE_MESH_FLAG_BITS_FB_MAX_ENUM = 0x7fffffff, +} XrTriangleMeshFlagBitsFB; + typedef enum XrViewConfigurationType { XR_VIEW_CONFIGURATION_TYPE_PRIMARY_MONO = 1, @@ -2162,6 +2270,15 @@ typedef enum XrViewConfigurationType XR_VIEW_CONFIGURATION_TYPE_MAX_ENUM = 0x7fffffff, } XrViewConfigurationType; +typedef enum XrViewStateFlagBits +{ + XR_VIEW_STATE_ORIENTATION_VALID_BIT = 0x00000001, + XR_VIEW_STATE_POSITION_VALID_BIT = 0x00000002, + XR_VIEW_STATE_ORIENTATION_TRACKED_BIT = 0x00000004, + XR_VIEW_STATE_POSITION_TRACKED_BIT = 0x00000008, + XR_VIEW_STATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} XrViewStateFlagBits; + typedef enum XrVirtualKeyboardInputSourceMETA { XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_RAY_LEFT_META = 1, @@ -2175,6 +2292,12 @@ typedef enum XrVirtualKeyboardInputSourceMETA XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_META_MAX_ENUM = 0x7fffffff, } XrVirtualKeyboardInputSourceMETA; +typedef enum XrVirtualKeyboardInputStateFlagBitsMETA +{ + XR_VIRTUAL_KEYBOARD_INPUT_STATE_PRESSED_BIT_META = 0x00000001, + XR_VIRTUAL_KEYBOARD_INPUT_STATE_FLAG_BITS_META_MAX_ENUM = 0x7fffffff, +} XrVirtualKeyboardInputStateFlagBitsMETA; + typedef enum XrVirtualKeyboardLocationTypeMETA { XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_CUSTOM_META = 0, @@ -2191,6 +2314,16 @@ typedef enum XrVisibilityMaskTypeKHR XR_VISIBILITY_MASK_TYPE_KHR_MAX_ENUM = 0x7fffffff, } XrVisibilityMaskTypeKHR; +typedef enum XrVulkanDeviceCreateFlagBitsKHR +{ + XR_VULKAN_DEVICE_CREATE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, +} XrVulkanDeviceCreateFlagBitsKHR; + +typedef enum XrVulkanInstanceCreateFlagBitsKHR +{ + XR_VULKAN_INSTANCE_CREATE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, +} XrVulkanInstanceCreateFlagBitsKHR; + typedef enum XrWindingOrderFB { XR_WINDING_ORDER_UNKNOWN_FB = 0, @@ -2199,445 +2332,11 @@ typedef enum XrWindingOrderFB XR_WINDING_ORDER_FB_MAX_ENUM = 0x7fffffff, } XrWindingOrderFB; -typedef struct XrExtent3Df XrExtent3Df; -typedef XrExtent3Df XrExtent3DfEXT; -typedef XrExtent3Df XrExtent3DfFB; -typedef XrExtent3Df XrExtent3DfKHR; -typedef struct XrActionCreateInfo XrActionCreateInfo; -typedef struct XrActionStateBoolean XrActionStateBoolean; -typedef struct XrActionStateGetInfo XrActionStateGetInfo; -typedef struct XrActionSuggestedBinding XrActionSuggestedBinding; -typedef struct XrActiveActionSet XrActiveActionSet; -typedef struct XrActiveActionSetPriorityEXT XrActiveActionSetPriorityEXT; -typedef struct XrApiLayerNextInfo XrApiLayerNextInfo; -typedef struct XrApplicationInfo XrApplicationInfo; -typedef struct XrBaseOutStructure XrBaseOutStructure; -typedef struct XrBodyJointsLocateInfoFB XrBodyJointsLocateInfoFB; -typedef struct XrBodyTrackerCreateInfoFB XrBodyTrackerCreateInfoFB; -typedef struct XrCompositionLayerAlphaBlendFB XrCompositionLayerAlphaBlendFB; -typedef struct XrCompositionLayerDepthTestFB XrCompositionLayerDepthTestFB; -typedef struct XrCompositionLayerImageLayoutFB XrCompositionLayerImageLayoutFB; -typedef struct XrCompositionLayerReprojectionInfoMSFT XrCompositionLayerReprojectionInfoMSFT; -typedef struct XrCompositionLayerSecureContentFB XrCompositionLayerSecureContentFB; -typedef struct XrControllerModelKeyStateMSFT XrControllerModelKeyStateMSFT; -typedef struct XrDeserializeSceneFragmentMSFT XrDeserializeSceneFragmentMSFT; -typedef struct XrDevicePcmSampleRateStateFB XrDevicePcmSampleRateStateFB; -typedef XrDevicePcmSampleRateStateFB XrDevicePcmSampleRateGetInfoFB; -typedef struct XrEnvironmentDepthHandRemovalSetInfoMETA XrEnvironmentDepthHandRemovalSetInfoMETA; -typedef struct XrEnvironmentDepthProviderCreateInfoMETA XrEnvironmentDepthProviderCreateInfoMETA; -typedef struct XrEnvironmentDepthSwapchainStateMETA XrEnvironmentDepthSwapchainStateMETA; -typedef struct XrEventDataBuffer XrEventDataBuffer; -typedef struct XrEventDataEventsLost XrEventDataEventsLost; -typedef struct XrEventDataHeadsetFitChangedML XrEventDataHeadsetFitChangedML; -typedef struct XrEventDataInteractionProfileChanged XrEventDataInteractionProfileChanged; -typedef struct XrEventDataMainSessionVisibilityChangedEXTX XrEventDataMainSessionVisibilityChangedEXTX; -typedef struct XrEventDataPassthroughStateChangedFB XrEventDataPassthroughStateChangedFB; -typedef struct XrEventDataSceneCaptureCompleteFB XrEventDataSceneCaptureCompleteFB; -typedef struct XrEventDataSpaceListSaveCompleteFB XrEventDataSpaceListSaveCompleteFB; -typedef struct XrEventDataSpaceQueryResultsAvailableFB XrEventDataSpaceQueryResultsAvailableFB; -typedef struct XrEventDataSpaceShareCompleteFB XrEventDataSpaceShareCompleteFB; -typedef struct XrEventDataUserPresenceChangedEXT XrEventDataUserPresenceChangedEXT; -typedef struct XrEventDataVirtualKeyboardCommitTextMETA XrEventDataVirtualKeyboardCommitTextMETA; -typedef struct XrEventDataVirtualKeyboardHiddenMETA XrEventDataVirtualKeyboardHiddenMETA; -typedef struct XrEventDataVisibilityMaskChangedKHR XrEventDataVisibilityMaskChangedKHR; -typedef struct XrExtensionProperties XrExtensionProperties; -typedef struct XrExtent2Di XrExtent2Di; -typedef struct XrEyeGazeSampleTimeEXT XrEyeGazeSampleTimeEXT; -typedef struct XrEyeGazesInfoFB XrEyeGazesInfoFB; -typedef struct XrFaceExpressionInfo2FB XrFaceExpressionInfo2FB; -typedef struct XrFaceExpressionStatusFB XrFaceExpressionStatusFB; -typedef struct XrFaceExpressionWeightsFB XrFaceExpressionWeightsFB; -typedef struct XrFaceTrackerCreateInfoFB XrFaceTrackerCreateInfoFB; -typedef struct XrFacialTrackerCreateInfoHTC XrFacialTrackerCreateInfoHTC; -typedef struct XrFoveatedViewConfigurationViewVARJO XrFoveatedViewConfigurationViewVARJO; -typedef struct XrFoveationDynamicModeInfoHTC XrFoveationDynamicModeInfoHTC; -typedef struct XrFoveationLevelProfileCreateInfoFB XrFoveationLevelProfileCreateInfoFB; -typedef struct XrFovf XrFovf; -typedef struct XrFrameEndInfoML XrFrameEndInfoML; -typedef struct XrFrameWaitInfo XrFrameWaitInfo; -typedef struct XrFutureCompletionBaseHeaderEXT XrFutureCompletionBaseHeaderEXT; -typedef struct XrFuturePollInfoEXT XrFuturePollInfoEXT; -typedef struct XrGlobalDimmerFrameEndInfoML XrGlobalDimmerFrameEndInfoML; -typedef struct XrGraphicsBindingD3D12KHR XrGraphicsBindingD3D12KHR; -typedef struct XrGraphicsBindingOpenGLWin32KHR XrGraphicsBindingOpenGLWin32KHR; -typedef struct XrGraphicsBindingVulkanKHR XrGraphicsBindingVulkanKHR; -typedef XrGraphicsBindingVulkanKHR XrGraphicsBindingVulkan2KHR; -typedef struct XrGraphicsRequirementsD3D12KHR XrGraphicsRequirementsD3D12KHR; -typedef struct XrGraphicsRequirementsOpenGLKHR XrGraphicsRequirementsOpenGLKHR; -typedef struct XrGraphicsRequirementsVulkanKHR XrGraphicsRequirementsVulkanKHR; -typedef XrGraphicsRequirementsVulkanKHR XrGraphicsRequirementsVulkan2KHR; -typedef struct XrHandJointsLocateInfoEXT XrHandJointsLocateInfoEXT; -typedef struct XrHandMeshIndexBufferMSFT XrHandMeshIndexBufferMSFT; -typedef struct XrHandMeshUpdateInfoMSFT XrHandMeshUpdateInfoMSFT; -typedef struct XrHandPoseTypeInfoMSFT XrHandPoseTypeInfoMSFT; -typedef struct XrHandTrackingDataSourceInfoEXT XrHandTrackingDataSourceInfoEXT; -typedef struct XrHandTrackingScaleFB XrHandTrackingScaleFB; -typedef struct XrHapticAmplitudeEnvelopeVibrationFB XrHapticAmplitudeEnvelopeVibrationFB; -typedef struct XrHapticPcmVibrationFB XrHapticPcmVibrationFB; -typedef struct XrHolographicWindowAttachmentMSFT XrHolographicWindowAttachmentMSFT; -typedef struct XrInstanceCreateInfo XrInstanceCreateInfo; -typedef struct XrInstanceProperties XrInstanceProperties; -typedef struct XrInteractionProfileState XrInteractionProfileState; -typedef struct XrKeyboardSpaceCreateInfoFB XrKeyboardSpaceCreateInfoFB; -typedef struct XrKeyboardTrackingQueryFB XrKeyboardTrackingQueryFB; -typedef struct XrLocalizationEnableEventsInfoML XrLocalizationEnableEventsInfoML; -typedef struct XrLocalizationMapQueryInfoBaseHeaderML XrLocalizationMapQueryInfoBaseHeaderML; -typedef struct XrMarkerDetectorAprilTagInfoML XrMarkerDetectorAprilTagInfoML; -typedef struct XrMarkerDetectorCreateInfoML XrMarkerDetectorCreateInfoML; -typedef struct XrMarkerDetectorSizeInfoML XrMarkerDetectorSizeInfoML; -typedef struct XrMarkerDetectorStateML XrMarkerDetectorStateML; -typedef struct XrNegotiateApiLayerRequest XrNegotiateApiLayerRequest; -typedef struct XrNegotiateRuntimeRequest XrNegotiateRuntimeRequest; -typedef struct XrOffset2Df XrOffset2Df; -typedef struct XrOffset3DfFB XrOffset3DfFB; -typedef struct XrPassthroughColorHTC XrPassthroughColorHTC; -typedef struct XrPassthroughColorLutDataMETA XrPassthroughColorLutDataMETA; -typedef struct XrPassthroughColorMapInterpolatedLutMETA XrPassthroughColorMapInterpolatedLutMETA; -typedef struct XrPassthroughColorMapMonoToMonoFB XrPassthroughColorMapMonoToMonoFB; -typedef struct XrPassthroughCreateInfoFB XrPassthroughCreateInfoFB; -typedef struct XrPassthroughKeyboardHandsIntensityFB XrPassthroughKeyboardHandsIntensityFB; -typedef struct XrPassthroughPreferencesMETA XrPassthroughPreferencesMETA; -typedef struct XrPerformanceMetricsCounterMETA XrPerformanceMetricsCounterMETA; -typedef struct XrPlaneDetectorCreateInfoEXT XrPlaneDetectorCreateInfoEXT; -typedef struct XrQuaternionf XrQuaternionf; -typedef struct XrRecommendedLayerResolutionMETA XrRecommendedLayerResolutionMETA; -typedef struct XrRect3DfFB XrRect3DfFB; -typedef struct XrRenderModelBufferFB XrRenderModelBufferFB; -typedef struct XrRenderModelLoadInfoFB XrRenderModelLoadInfoFB; -typedef struct XrRenderModelPropertiesFB XrRenderModelPropertiesFB; -typedef struct XrSceneCaptureRequestInfoFB XrSceneCaptureRequestInfoFB; -typedef struct XrSceneComponentsGetInfoMSFT XrSceneComponentsGetInfoMSFT; -typedef struct XrSceneCreateInfoMSFT XrSceneCreateInfoMSFT; -typedef struct XrSceneMarkerQRCodeMSFT XrSceneMarkerQRCodeMSFT; -typedef struct XrSceneMarkerTypeFilterMSFT XrSceneMarkerTypeFilterMSFT; -typedef struct XrSceneMeshBuffersGetInfoMSFT XrSceneMeshBuffersGetInfoMSFT; -typedef struct XrSceneMeshIndicesUint16MSFT XrSceneMeshIndicesUint16MSFT; -typedef struct XrSceneMeshMSFT XrSceneMeshMSFT; -typedef struct XrSceneMeshesMSFT XrSceneMeshesMSFT; -typedef struct XrSceneObjectTypesFilterInfoMSFT XrSceneObjectTypesFilterInfoMSFT; -typedef struct XrSceneObserverCreateInfoMSFT XrSceneObserverCreateInfoMSFT; -typedef struct XrScenePlaneAlignmentFilterInfoMSFT XrScenePlaneAlignmentFilterInfoMSFT; -typedef struct XrSecondaryViewConfigurationSessionBeginInfoMSFT XrSecondaryViewConfigurationSessionBeginInfoMSFT; -typedef struct XrSecondaryViewConfigurationSwapchainCreateInfoMSFT XrSecondaryViewConfigurationSwapchainCreateInfoMSFT; -typedef struct XrSemanticLabelsSupportInfoFB XrSemanticLabelsSupportInfoFB; -typedef struct XrSessionActionSetsAttachInfo XrSessionActionSetsAttachInfo; -typedef struct XrSessionCreateInfo XrSessionCreateInfo; -typedef struct XrSpaceComponentFilterInfoFB XrSpaceComponentFilterInfoFB; -typedef struct XrSpaceComponentStatusSetInfoFB XrSpaceComponentStatusSetInfoFB; -typedef struct XrSpaceEraseInfoFB XrSpaceEraseInfoFB; -typedef struct XrSpaceListSaveInfoFB XrSpaceListSaveInfoFB; -typedef struct XrSpaceSaveInfoFB XrSpaceSaveInfoFB; -typedef struct XrSpaceStorageLocationFilterInfoFB XrSpaceStorageLocationFilterInfoFB; -typedef struct XrSpaceUserCreateInfoFB XrSpaceUserCreateInfoFB; -typedef struct XrSpatialAnchorNameHTC XrSpatialAnchorNameHTC; -typedef struct XrSpatialAnchorPersistenceNameMSFT XrSpatialAnchorPersistenceNameMSFT; -typedef struct XrSpatialGraphNodeBindingPropertiesGetInfoMSFT XrSpatialGraphNodeBindingPropertiesGetInfoMSFT; -typedef struct XrSwapchainCreateInfoFoveationFB XrSwapchainCreateInfoFoveationFB; -typedef struct XrSwapchainImageBaseHeader XrSwapchainImageBaseHeader; -typedef struct XrSwapchainImageD3D12KHR XrSwapchainImageD3D12KHR; -typedef struct XrSwapchainImageReleaseInfo XrSwapchainImageReleaseInfo; -typedef struct XrSwapchainImageVulkanKHR XrSwapchainImageVulkanKHR; -typedef XrSwapchainImageVulkanKHR XrSwapchainImageVulkan2KHR; -typedef struct XrSwapchainStateBaseHeaderFB XrSwapchainStateBaseHeaderFB; -typedef struct XrSystemAnchorPropertiesHTC XrSystemAnchorPropertiesHTC; -typedef struct XrSystemColorSpacePropertiesFB XrSystemColorSpacePropertiesFB; -typedef struct XrSystemEyeGazeInteractionPropertiesEXT XrSystemEyeGazeInteractionPropertiesEXT; -typedef struct XrSystemFaceTrackingProperties2FB XrSystemFaceTrackingProperties2FB; -typedef struct XrSystemFacialTrackingPropertiesHTC XrSystemFacialTrackingPropertiesHTC; -typedef struct XrSystemFoveatedRenderingPropertiesVARJO XrSystemFoveatedRenderingPropertiesVARJO; -typedef struct XrSystemGetInfo XrSystemGetInfo; -typedef struct XrSystemHandTrackingMeshPropertiesMSFT XrSystemHandTrackingMeshPropertiesMSFT; -typedef struct XrSystemKeyboardTrackingPropertiesFB XrSystemKeyboardTrackingPropertiesFB; -typedef struct XrSystemMarkerUnderstandingPropertiesML XrSystemMarkerUnderstandingPropertiesML; -typedef struct XrSystemPassthroughProperties2FB XrSystemPassthroughProperties2FB; -typedef struct XrSystemPlaneDetectionPropertiesEXT XrSystemPlaneDetectionPropertiesEXT; -typedef struct XrSystemRenderModelPropertiesFB XrSystemRenderModelPropertiesFB; -typedef struct XrSystemSpatialEntityPropertiesFB XrSystemSpatialEntityPropertiesFB; -typedef struct XrSystemUserPresencePropertiesEXT XrSystemUserPresencePropertiesEXT; -typedef struct XrUserCalibrationEnableEventsInfoML XrUserCalibrationEnableEventsInfoML; -typedef struct XrUuidMSFT XrUuidMSFT; -typedef struct XrVector3f XrVector3f; -typedef struct XrVector4sFB XrVector4sFB; -typedef struct XrViewConfigurationDepthRangeEXT XrViewConfigurationDepthRangeEXT; -typedef struct XrViewConfigurationView XrViewConfigurationView; -typedef struct XrViewLocateFoveatedRenderingVARJO XrViewLocateFoveatedRenderingVARJO; -typedef struct XrViewState XrViewState; -typedef struct XrVirtualKeyboardCreateInfoMETA XrVirtualKeyboardCreateInfoMETA; -typedef struct XrVirtualKeyboardModelVisibilitySetInfoMETA XrVirtualKeyboardModelVisibilitySetInfoMETA; -typedef struct XrVirtualKeyboardTextContextChangeInfoMETA XrVirtualKeyboardTextContextChangeInfoMETA; -typedef struct XrVisualMeshComputeLodInfoMSFT XrVisualMeshComputeLodInfoMSFT; -typedef struct XrVulkanDeviceCreateInfoKHR XrVulkanDeviceCreateInfoKHR; -typedef struct XrVulkanInstanceCreateInfoKHR XrVulkanInstanceCreateInfoKHR; -typedef struct XrVulkanSwapchainFormatListCreateInfoKHR XrVulkanSwapchainFormatListCreateInfoKHR; -typedef struct XrUuid XrUuid; -typedef XrUuid XrUuidEXT; -typedef struct XrActionStateFloat XrActionStateFloat; -typedef struct XrActionsSyncInfo XrActionsSyncInfo; -typedef struct XrApiLayerCreateInfo XrApiLayerCreateInfo; -typedef struct XrBaseInStructure XrBaseInStructure; -typedef struct XrBoundSourcesForActionEnumerateInfo XrBoundSourcesForActionEnumerateInfo; -typedef struct XrColor3f XrColor3f; -typedef XrColor3f XrColor3fKHR; -typedef struct XrCompositionLayerBaseHeader XrCompositionLayerBaseHeader; -typedef struct XrCompositionLayerCubeKHR XrCompositionLayerCubeKHR; -typedef struct XrCompositionLayerDepthTestVARJO XrCompositionLayerDepthTestVARJO; -typedef struct XrCompositionLayerPassthroughFB XrCompositionLayerPassthroughFB; -typedef struct XrCompositionLayerReprojectionPlaneOverrideMSFT XrCompositionLayerReprojectionPlaneOverrideMSFT; -typedef struct XrControllerModelNodePropertiesMSFT XrControllerModelNodePropertiesMSFT; -typedef struct XrControllerModelPropertiesMSFT XrControllerModelPropertiesMSFT; -typedef struct XrDebugUtilsLabelEXT XrDebugUtilsLabelEXT; -typedef struct XrDebugUtilsObjectNameInfoEXT XrDebugUtilsObjectNameInfoEXT; -typedef struct XrDigitalLensControlALMALENCE XrDigitalLensControlALMALENCE; -typedef struct XrEnvironmentDepthSwapchainCreateInfoMETA XrEnvironmentDepthSwapchainCreateInfoMETA; -typedef struct XrEventDataDisplayRefreshRateChangedFB XrEventDataDisplayRefreshRateChangedFB; -typedef struct XrEventDataInstanceLossPending XrEventDataInstanceLossPending; -typedef struct XrEventDataMarkerTrackingUpdateVARJO XrEventDataMarkerTrackingUpdateVARJO; -typedef struct XrEventDataSessionStateChanged XrEventDataSessionStateChanged; -typedef struct XrEventDataSpaceQueryCompleteFB XrEventDataSpaceQueryCompleteFB; -typedef struct XrEventDataVirtualKeyboardBackspaceMETA XrEventDataVirtualKeyboardBackspaceMETA; -typedef struct XrEventDataVirtualKeyboardShownMETA XrEventDataVirtualKeyboardShownMETA; -typedef struct XrExtent2Df XrExtent2Df; -typedef struct XrExternalCameraIntrinsicsOCULUS XrExternalCameraIntrinsicsOCULUS; -typedef struct XrEyeTrackerCreateInfoFB XrEyeTrackerCreateInfoFB; -typedef struct XrFaceExpressionWeights2FB XrFaceExpressionWeights2FB; -typedef struct XrFacialExpressionsHTC XrFacialExpressionsHTC; -typedef struct XrFoveationEyeTrackedProfileCreateInfoMETA XrFoveationEyeTrackedProfileCreateInfoMETA; -typedef struct XrFoveationProfileCreateInfoFB XrFoveationProfileCreateInfoFB; -typedef struct XrFrameEndInfo XrFrameEndInfo; -typedef struct XrFutureCancelInfoEXT XrFutureCancelInfoEXT; -typedef struct XrFuturePollResultEXT XrFuturePollResultEXT; -typedef struct XrGraphicsBindingD3D11KHR XrGraphicsBindingD3D11KHR; -typedef struct XrHandCapsuleFB XrHandCapsuleFB; -typedef struct XrHandJointVelocityEXT XrHandJointVelocityEXT; -typedef struct XrHandMeshVertexMSFT XrHandMeshVertexMSFT; -typedef struct XrHandTrackingCapsulesStateFB XrHandTrackingCapsulesStateFB; -typedef struct XrHapticActionInfo XrHapticActionInfo; -typedef struct XrHapticVibration XrHapticVibration; -typedef struct XrInteractionProfileSuggestedBinding XrInteractionProfileSuggestedBinding; -typedef struct XrLocalizationMapImportInfoML XrLocalizationMapImportInfoML; -typedef struct XrMarkerDetectorArucoInfoML XrMarkerDetectorArucoInfoML; -typedef struct XrMarkerDetectorSnapshotInfoML XrMarkerDetectorSnapshotInfoML; -typedef struct XrNegotiateLoaderInfo XrNegotiateLoaderInfo; -typedef struct XrOffset2Di XrOffset2Di; -typedef struct XrPassthroughColorLutCreateInfoMETA XrPassthroughColorLutCreateInfoMETA; -typedef struct XrPassthroughColorMapLutMETA XrPassthroughColorMapLutMETA; -typedef struct XrPassthroughCreateInfoHTC XrPassthroughCreateInfoHTC; -typedef struct XrPerformanceMetricsStateMETA XrPerformanceMetricsStateMETA; -typedef struct XrPlaneDetectorGetInfoEXT XrPlaneDetectorGetInfoEXT; -typedef struct XrPosef XrPosef; -typedef struct XrRect2Df XrRect2Df; -typedef struct XrReferenceSpaceCreateInfo XrReferenceSpaceCreateInfo; -typedef struct XrRenderModelPathInfoFB XrRenderModelPathInfoFB; -typedef struct XrSceneComponentLocationMSFT XrSceneComponentLocationMSFT; -typedef struct XrSceneComponentMSFT XrSceneComponentMSFT; -typedef struct XrSceneComponentsLocateInfoMSFT XrSceneComponentsLocateInfoMSFT; -typedef struct XrSceneDeserializeInfoMSFT XrSceneDeserializeInfoMSFT; -typedef struct XrSceneMarkerMSFT XrSceneMarkerMSFT; -typedef struct XrSceneMarkersMSFT XrSceneMarkersMSFT; -typedef struct XrSceneMeshIndicesUint32MSFT XrSceneMeshIndicesUint32MSFT; -typedef struct XrSceneObjectMSFT XrSceneObjectMSFT; -typedef struct XrSceneOrientedBoxBoundMSFT XrSceneOrientedBoxBoundMSFT; -typedef struct XrSceneSphereBoundMSFT XrSceneSphereBoundMSFT; -typedef struct XrSecondaryViewConfigurationLayerInfoMSFT XrSecondaryViewConfigurationLayerInfoMSFT; -typedef struct XrSemanticLabelsFB XrSemanticLabelsFB; -typedef struct XrSessionBeginInfo XrSessionBeginInfo; -typedef struct XrSpaceComponentStatusFB XrSpaceComponentStatusFB; -typedef struct XrSpaceFilterInfoBaseHeaderFB XrSpaceFilterInfoBaseHeaderFB; -typedef struct XrSpaceLocationData XrSpaceLocationData; -typedef XrSpaceLocationData XrSpaceLocationDataKHR; -typedef struct XrSpaceQueryInfoBaseHeaderFB XrSpaceQueryInfoBaseHeaderFB; -typedef struct XrSpaceShareInfoFB XrSpaceShareInfoFB; -typedef struct XrSpaceTriangleMeshMETA XrSpaceTriangleMeshMETA; -typedef struct XrSpaceVelocity XrSpaceVelocity; -typedef struct XrSpacesLocateInfo XrSpacesLocateInfo; -typedef XrSpacesLocateInfo XrSpacesLocateInfoKHR; -typedef struct XrSpatialAnchorCreateInfoHTC XrSpatialAnchorCreateInfoHTC; -typedef struct XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT; -typedef struct XrSpatialAnchorSpaceCreateInfoMSFT XrSpatialAnchorSpaceCreateInfoMSFT; -typedef struct XrSpatialGraphNodeSpaceCreateInfoMSFT XrSpatialGraphNodeSpaceCreateInfoMSFT; -typedef struct XrSpheref XrSpheref; -typedef XrSpheref XrSpherefKHR; -typedef struct XrSwapchainImageAcquireInfo XrSwapchainImageAcquireInfo; -typedef struct XrSwapchainImageFoveationVulkanFB XrSwapchainImageFoveationVulkanFB; -typedef struct XrSwapchainStateFoveationFB XrSwapchainStateFoveationFB; -typedef struct XrSystemBodyTrackingPropertiesFB XrSystemBodyTrackingPropertiesFB; -typedef struct XrSystemEyeTrackingPropertiesFB XrSystemEyeTrackingPropertiesFB; -typedef struct XrSystemForceFeedbackCurlPropertiesMNDX XrSystemForceFeedbackCurlPropertiesMNDX; -typedef struct XrSystemGraphicsProperties XrSystemGraphicsProperties; -typedef struct XrSystemMarkerTrackingPropertiesVARJO XrSystemMarkerTrackingPropertiesVARJO; -typedef struct XrSystemPassthroughPropertiesFB XrSystemPassthroughPropertiesFB; -typedef struct XrSystemSpaceWarpPropertiesFB XrSystemSpaceWarpPropertiesFB; -typedef struct XrSystemVirtualKeyboardPropertiesMETA XrSystemVirtualKeyboardPropertiesMETA; -typedef struct XrVector4f XrVector4f; -typedef struct XrViewConfigurationProperties XrViewConfigurationProperties; -typedef struct XrViewLocateInfo XrViewLocateInfo; -typedef struct XrVirtualKeyboardInputInfoMETA XrVirtualKeyboardInputInfoMETA; -typedef struct XrVirtualKeyboardSpaceCreateInfoMETA XrVirtualKeyboardSpaceCreateInfoMETA; -typedef struct XrViveTrackerPathsHTCX XrViveTrackerPathsHTCX; -typedef struct XrVulkanSwapchainCreateInfoMETA XrVulkanSwapchainCreateInfoMETA; -typedef struct XrActionSetCreateInfo XrActionSetCreateInfo; -typedef struct XrActionStatePose XrActionStatePose; -typedef struct XrActiveActionSetPrioritiesEXT XrActiveActionSetPrioritiesEXT; -typedef struct XrBindingModificationBaseHeaderKHR XrBindingModificationBaseHeaderKHR; -typedef struct XrBodyJointLocationFB XrBodyJointLocationFB; -typedef struct XrBodySkeletonJointFB XrBodySkeletonJointFB; -typedef struct XrBoxf XrBoxf; -typedef XrBoxf XrBoxfKHR; -typedef struct XrCompositionLayerPassthroughHTC XrCompositionLayerPassthroughHTC; -typedef struct XrCompositionLayerSettingsFB XrCompositionLayerSettingsFB; -typedef struct XrControllerModelNodeStateMSFT XrControllerModelNodeStateMSFT; -typedef struct XrDebugUtilsMessengerCallbackDataEXT XrDebugUtilsMessengerCallbackDataEXT; -typedef struct XrEnvironmentDepthImageAcquireInfoMETA XrEnvironmentDepthImageAcquireInfoMETA; -typedef struct XrEnvironmentDepthImageViewMETA XrEnvironmentDepthImageViewMETA; -typedef struct XrEventDataEyeCalibrationChangedML XrEventDataEyeCalibrationChangedML; -typedef struct XrEventDataPerfSettingsEXT XrEventDataPerfSettingsEXT; -typedef struct XrEventDataSpaceEraseCompleteFB XrEventDataSpaceEraseCompleteFB; -typedef struct XrEventDataSpaceSetStatusCompleteFB XrEventDataSpaceSetStatusCompleteFB; -typedef struct XrEventDataVirtualKeyboardEnterMETA XrEventDataVirtualKeyboardEnterMETA; -typedef struct XrEyeGazeFB XrEyeGazeFB; -typedef struct XrFaceExpressionInfoFB XrFaceExpressionInfoFB; -typedef struct XrForceFeedbackCurlApplyLocationMNDX XrForceFeedbackCurlApplyLocationMNDX; -typedef struct XrFrameBeginInfo XrFrameBeginInfo; -typedef struct XrFrustumf XrFrustumf; -typedef XrFrustumf XrFrustumfKHR; -typedef struct XrGeometryInstanceCreateInfoFB XrGeometryInstanceCreateInfoFB; -typedef struct XrHandJointVelocitiesEXT XrHandJointVelocitiesEXT; -typedef struct XrHandMeshSpaceCreateInfoMSFT XrHandMeshSpaceCreateInfoMSFT; -typedef struct XrHandTrackerCreateInfoEXT XrHandTrackerCreateInfoEXT; -typedef struct XrHandTrackingDataSourceStateEXT XrHandTrackingDataSourceStateEXT; -typedef struct XrHapticBaseHeader XrHapticBaseHeader; -typedef struct XrInteractionProfileAnalogThresholdVALVE XrInteractionProfileAnalogThresholdVALVE; -typedef struct XrKeyboardTrackingDescriptionFB XrKeyboardTrackingDescriptionFB; -typedef struct XrLocalizationMapML XrLocalizationMapML; -typedef struct XrMarkerDetectorCustomProfileInfoML XrMarkerDetectorCustomProfileInfoML; -typedef struct XrMarkerSpaceCreateInfoVARJO XrMarkerSpaceCreateInfoVARJO; -typedef struct XrPassthroughBrightnessContrastSaturationFB XrPassthroughBrightnessContrastSaturationFB; -typedef struct XrPassthroughLayerCreateInfoFB XrPassthroughLayerCreateInfoFB; -typedef struct XrPlaneDetectorBeginInfoEXT XrPlaneDetectorBeginInfoEXT; -typedef struct XrRecommendedLayerResolutionGetInfoMETA XrRecommendedLayerResolutionGetInfoMETA; -typedef struct XrRenderModelCapabilitiesRequestFB XrRenderModelCapabilitiesRequestFB; -typedef struct XrSceneComponentLocationsMSFT XrSceneComponentLocationsMSFT; -typedef struct XrSceneComponentsMSFT XrSceneComponentsMSFT; -typedef struct XrSceneMarkerQRCodesMSFT XrSceneMarkerQRCodesMSFT; -typedef struct XrSceneMeshVertexBufferMSFT XrSceneMeshVertexBufferMSFT; -typedef struct XrScenePlaneMSFT XrScenePlaneMSFT; -typedef struct XrSecondaryViewConfigurationFrameEndInfoMSFT XrSecondaryViewConfigurationFrameEndInfoMSFT; -typedef struct XrSecondaryViewConfigurationStateMSFT XrSecondaryViewConfigurationStateMSFT; -typedef struct XrSessionCreateInfoOverlayEXTX XrSessionCreateInfoOverlayEXTX; -typedef struct XrSpaceLocation XrSpaceLocation; -typedef struct XrSpaceQueryInfoFB XrSpaceQueryInfoFB; -typedef struct XrSpaceTriangleMeshGetInfoMETA XrSpaceTriangleMeshGetInfoMETA; -typedef struct XrSpaceVelocityData XrSpaceVelocityData; -typedef XrSpaceVelocityData XrSpaceVelocityDataKHR; -typedef struct XrSpatialAnchorCreateInfoMSFT XrSpatialAnchorCreateInfoMSFT; -typedef struct XrSpatialGraphNodeBindingPropertiesMSFT XrSpatialGraphNodeBindingPropertiesMSFT; -typedef struct XrSwapchainCreateInfo XrSwapchainCreateInfo; -typedef struct XrSwapchainImageOpenGLKHR XrSwapchainImageOpenGLKHR; -typedef struct XrSystemEnvironmentDepthPropertiesMETA XrSystemEnvironmentDepthPropertiesMETA; -typedef struct XrSystemFoveationEyeTrackedPropertiesMETA XrSystemFoveationEyeTrackedPropertiesMETA; -typedef struct XrSystemHeadsetIdPropertiesMETA XrSystemHeadsetIdPropertiesMETA; -typedef struct XrSystemTrackingProperties XrSystemTrackingProperties; -typedef struct XrVector2f XrVector2f; -typedef struct XrViewConfigurationViewFovEPIC XrViewConfigurationViewFovEPIC; -typedef struct XrVirtualKeyboardLocationInfoMETA XrVirtualKeyboardLocationInfoMETA; -typedef struct XrVirtualKeyboardTextureDataMETA XrVirtualKeyboardTextureDataMETA; -typedef struct XrVulkanGraphicsDeviceGetInfoKHR XrVulkanGraphicsDeviceGetInfoKHR; -typedef struct XrActionSpaceCreateInfo XrActionSpaceCreateInfo; -typedef struct XrApiLayerProperties XrApiLayerProperties; -typedef struct XrBodyJointLocationsFB XrBodyJointLocationsFB; -typedef struct XrBoundary2DFB XrBoundary2DFB; -typedef struct XrControllerModelStateMSFT XrControllerModelStateMSFT; -typedef struct XrEnvironmentDepthImageMETA XrEnvironmentDepthImageMETA; -typedef struct XrEventDataLocalizationChangedML XrEventDataLocalizationChangedML; -typedef struct XrEventDataSpaceSaveCompleteFB XrEventDataSpaceSaveCompleteFB; -typedef struct XrEventDataViveTrackerConnectedHTCX XrEventDataViveTrackerConnectedHTCX; -typedef struct XrEyeGazesFB XrEyeGazesFB; -typedef struct XrForceFeedbackCurlApplyLocationsMNDX XrForceFeedbackCurlApplyLocationsMNDX; -typedef struct XrFoveationConfigurationHTC XrFoveationConfigurationHTC; -typedef struct XrFoveationEyeTrackedStateMETA XrFoveationEyeTrackedStateMETA; -typedef struct XrFutureCompletionEXT XrFutureCompletionEXT; -typedef struct XrGraphicsRequirementsD3D11KHR XrGraphicsRequirementsD3D11KHR; -typedef struct XrHandJointsMotionRangeInfoEXT XrHandJointsMotionRangeInfoEXT; -typedef struct XrHandMeshVertexBufferMSFT XrHandMeshVertexBufferMSFT; -typedef struct XrHandTrackingMeshFB XrHandTrackingMeshFB; -typedef struct XrInteractionProfileDpadBindingEXT XrInteractionProfileDpadBindingEXT; -typedef struct XrMapLocalizationRequestInfoML XrMapLocalizationRequestInfoML; -typedef struct XrPassthroughColorLutUpdateInfoMETA XrPassthroughColorLutUpdateInfoMETA; -typedef struct XrPassthroughMeshTransformInfoHTC XrPassthroughMeshTransformInfoHTC; -typedef struct XrPlaneDetectorLocationEXT XrPlaneDetectorLocationEXT; -typedef struct XrPlaneDetectorPolygonBufferEXT XrPlaneDetectorPolygonBufferEXT; -typedef struct XrRoomLayoutFB XrRoomLayoutFB; -typedef struct XrSceneComponentParentFilterInfoMSFT XrSceneComponentParentFilterInfoMSFT; -typedef struct XrSceneMeshBuffersMSFT XrSceneMeshBuffersMSFT; -typedef struct XrScenePlanesMSFT XrScenePlanesMSFT; -typedef struct XrSerializedSceneFragmentDataGetInfoMSFT XrSerializedSceneFragmentDataGetInfoMSFT; -typedef struct XrSpaceLocations XrSpaceLocations; -typedef XrSpaceLocations XrSpaceLocationsKHR; -typedef struct XrSpaceUuidFilterInfoFB XrSpaceUuidFilterInfoFB; -typedef struct XrSpatialAnchorCreateInfoFB XrSpatialAnchorCreateInfoFB; -typedef struct XrSpatialGraphStaticNodeBindingCreateInfoMSFT XrSpatialGraphStaticNodeBindingCreateInfoMSFT; -typedef struct XrSwapchainImageWaitInfo XrSwapchainImageWaitInfo; -typedef struct XrSystemFaceTrackingPropertiesFB XrSystemFaceTrackingPropertiesFB; -typedef struct XrSystemPassthroughColorLutPropertiesMETA XrSystemPassthroughColorLutPropertiesMETA; -typedef struct XrTriangleMeshCreateInfoFB XrTriangleMeshCreateInfoFB; -typedef struct XrVirtualKeyboardAnimationStateMETA XrVirtualKeyboardAnimationStateMETA; -typedef struct XrVisibilityMaskKHR XrVisibilityMaskKHR; -typedef struct XrActionStateVector2f XrActionStateVector2f; -typedef struct XrBodySkeletonFB XrBodySkeletonFB; -typedef struct XrEventDataReferenceSpaceChangePending XrEventDataReferenceSpaceChangePending; -typedef struct XrExternalCameraExtrinsicsOCULUS XrExternalCameraExtrinsicsOCULUS; -typedef struct XrFaceTrackerCreateInfo2FB XrFaceTrackerCreateInfo2FB; -typedef struct XrFoveationCustomModeInfoHTC XrFoveationCustomModeInfoHTC; -typedef struct XrGeometryInstanceTransformFB XrGeometryInstanceTransformFB; -typedef struct XrHandMeshMSFT XrHandMeshMSFT; -typedef struct XrInputSourceLocalizedNameGetInfo XrInputSourceLocalizedNameGetInfo; -typedef struct XrMarkerSpaceCreateInfoML XrMarkerSpaceCreateInfoML; -typedef struct XrPlaneDetectorLocationsEXT XrPlaneDetectorLocationsEXT; -typedef struct XrSceneFrustumBoundMSFT XrSceneFrustumBoundMSFT; -typedef struct XrSecondaryViewConfigurationFrameStateMSFT XrSecondaryViewConfigurationFrameStateMSFT; -typedef struct XrSpaceQueryResultFB XrSpaceQueryResultFB; -typedef struct XrSpaceVelocities XrSpaceVelocities; -typedef XrSpaceVelocities XrSpaceVelocitiesKHR; -typedef struct XrSwapchainImageD3D11KHR XrSwapchainImageD3D11KHR; -typedef struct XrSystemHandTrackingPropertiesEXT XrSystemHandTrackingPropertiesEXT; -typedef struct XrView XrView; -typedef struct XrBindingModificationsKHR XrBindingModificationsKHR; -typedef struct XrEventDataBaseHeader XrEventDataBaseHeader; -typedef struct XrExternalCameraOCULUS XrExternalCameraOCULUS; -typedef struct XrFrameState XrFrameState; -typedef struct XrHandTrackingAimStateFB XrHandTrackingAimStateFB; -typedef struct XrRect2Di XrRect2Di; -typedef struct XrSceneObjectsMSFT XrSceneObjectsMSFT; -typedef struct XrSpaceQueryResultsFB XrSpaceQueryResultsFB; -typedef struct XrSwapchainSubImage XrSwapchainSubImage; -typedef struct XrVirtualKeyboardModelAnimationStatesMETA XrVirtualKeyboardModelAnimationStatesMETA; -typedef struct XrColor4f XrColor4f; -typedef struct XrCompositionLayerCylinderKHR XrCompositionLayerCylinderKHR; -typedef struct XrCompositionLayerEquirect2KHR XrCompositionLayerEquirect2KHR; -typedef struct XrCompositionLayerProjectionView XrCompositionLayerProjectionView; -typedef struct XrCompositionLayerSpaceWarpInfoFB XrCompositionLayerSpaceWarpInfoFB; -typedef struct XrFoveationApplyInfoHTC XrFoveationApplyInfoHTC; -typedef struct XrLocalDimmingFrameEndInfoMETA XrLocalDimmingFrameEndInfoMETA; -typedef struct XrPassthroughColorMapMonoToRgbaFB XrPassthroughColorMapMonoToRgbaFB; -typedef struct XrSceneBoundsMSFT XrSceneBoundsMSFT; -typedef struct XrSpatialAnchorPersistenceInfoMSFT XrSpatialAnchorPersistenceInfoMSFT; -typedef struct XrSystemProperties XrSystemProperties; -typedef struct XrCompositionLayerColorScaleBiasKHR XrCompositionLayerColorScaleBiasKHR; -typedef struct XrCompositionLayerEquirectKHR XrCompositionLayerEquirectKHR; -typedef struct XrCompositionLayerQuad XrCompositionLayerQuad; -typedef struct XrHandJointLocationEXT XrHandJointLocationEXT; -typedef struct XrNewSceneComputeInfoMSFT XrNewSceneComputeInfoMSFT; -typedef struct XrSpaceContainerFB XrSpaceContainerFB; -typedef struct XrCompositionLayerDepthInfoKHR XrCompositionLayerDepthInfoKHR; -typedef struct XrEventDataSpatialAnchorCreateCompleteFB XrEventDataSpatialAnchorCreateCompleteFB; -typedef struct XrPassthroughStyleFB XrPassthroughStyleFB; -typedef struct XrCompositionLayerProjection XrCompositionLayerProjection; -typedef struct XrSwapchainStateSamplerVulkanFB XrSwapchainStateSamplerVulkanFB; -typedef struct XrHandJointLocationsEXT XrHandJointLocationsEXT; typedef void (XRAPI_PTR * PFN_xrVoidFunction)( void); typedef XrResult (XRAPI_PTR * PFN_xrGetInstanceProcAddr)( XrInstance instance, const char* name, PFN_xrVoidFunction* function); +typedef struct XrInstanceCreateInfo XrInstanceCreateInfo; typedef struct XrApiLayerCreateInfo XrApiLayerCreateInfo; typedef XrResult (XRAPI_PTR * PFN_xrCreateApiLayerInstance)( @@ -2645,22 +2344,8 @@ typedef XrResult (XRAPI_PTR * PFN_xrCreateApiLayerInstance)( const XrInstanceCreateInfo* info, const XrApiLayerCreateInfo* apiLayerInfo, XrInstance* instance); -typedef XrBool32 (XRAPI_PTR * PFN_xrDebugUtilsMessengerCallbackEXT)( - XrDebugUtilsMessageSeverityFlagsEXT messageSeverity, - XrDebugUtilsMessageTypeFlagsEXT messageTypes, - const XrDebugUtilsMessengerCallbackDataEXT *callbackData, - void *userData); -typedef PFN_xrVoidFunction (* PFN_xrEglGetProcAddressMNDX)( - char *name); -struct XrExtent3Df -{ - float width; - float height; - float depth; -}; - -struct XrActionCreateInfo +typedef struct XrActionCreateInfo { XrStructureType type; const void *next; @@ -2669,9 +2354,18 @@ struct XrActionCreateInfo uint32_t countSubactionPaths; const XrPath *subactionPaths; char localizedActionName[XR_MAX_LOCALIZED_ACTION_NAME_SIZE]; -}; +} XrActionCreateInfo; -struct XrActionStateBoolean +typedef struct XrActionSetCreateInfo +{ + XrStructureType type; + const void *next; + char actionSetName[XR_MAX_ACTION_SET_NAME_SIZE]; + char localizedActionSetName[XR_MAX_LOCALIZED_ACTION_SET_NAME_SIZE]; + uint32_t priority; +} XrActionSetCreateInfo; + +typedef struct XrActionStateBoolean { XrStructureType type; void *next; @@ -2679,35 +2373,52 @@ struct XrActionStateBoolean XrBool32 changedSinceLastSync; XrTime lastChangeTime; XrBool32 isActive; -}; +} XrActionStateBoolean; -struct XrActionStateGetInfo +typedef struct XrActionStateFloat +{ + XrStructureType type; + void *next; + float currentState; + XrBool32 changedSinceLastSync; + XrTime lastChangeTime; + XrBool32 isActive; +} XrActionStateFloat; + +typedef struct XrActionStateGetInfo { XrStructureType type; const void *next; XrAction action; XrPath subactionPath; -}; +} XrActionStateGetInfo; -struct XrActionSuggestedBinding +typedef struct XrActionStatePose +{ + XrStructureType type; + void *next; + XrBool32 isActive; +} XrActionStatePose; + +typedef struct XrActionSuggestedBinding { XrAction action; XrPath binding; -}; +} XrActionSuggestedBinding; -struct XrActiveActionSet +typedef struct XrActiveActionSet { XrActionSet actionSet; XrPath subactionPath; -}; +} XrActiveActionSet; -struct XrActiveActionSetPriorityEXT +typedef struct XrActiveActionSetPriorityEXT { XrActionSet actionSet; uint32_t priorityOverride; -}; +} XrActiveActionSetPriorityEXT; -struct XrApiLayerNextInfo +typedef struct XrApiLayerNextInfo { XrLoaderInterfaceStructs structType; uint32_t structVersion; @@ -2716,39 +2427,92 @@ struct XrApiLayerNextInfo PFN_xrGetInstanceProcAddr nextGetInstanceProcAddr; PFN_xrCreateApiLayerInstance nextCreateApiLayerInstance; struct XrApiLayerNextInfo *next; -}; +} XrApiLayerNextInfo; -struct XrApplicationInfo +typedef struct XrApiLayerProperties +{ + XrStructureType type; + void *next; + char layerName[XR_MAX_API_LAYER_NAME_SIZE]; + XrVersion specVersion; + uint32_t layerVersion; + char description[XR_MAX_API_LAYER_DESCRIPTION_SIZE]; +} XrApiLayerProperties; + +typedef struct XrApplicationInfo { char applicationName[XR_MAX_APPLICATION_NAME_SIZE]; uint32_t applicationVersion; char engineName[XR_MAX_ENGINE_NAME_SIZE]; uint32_t engineVersion; XrVersion apiVersion; -}; +} XrApplicationInfo; -struct XrBaseOutStructure +typedef struct XrBaseInStructure +{ + XrStructureType type; + const struct XrBaseInStructure *next; +} XrBaseInStructure; + +typedef struct XrBaseOutStructure { XrStructureType type; struct XrBaseOutStructure *next; -}; +} XrBaseOutStructure; -struct XrBodyJointsLocateInfoFB +typedef struct XrBindingModificationBaseHeaderKHR +{ + XrStructureType type; + const void *next; +} XrBindingModificationBaseHeaderKHR; + +typedef struct XrBindingModificationsKHR +{ + XrStructureType type; + const void *next; + uint32_t bindingModificationCount; + const XrBindingModificationBaseHeaderKHR * const*bindingModifications; +} XrBindingModificationsKHR; + +typedef struct XrBodyJointsLocateInfoFB { XrStructureType type; const void *next; XrSpace baseSpace; XrTime time; -}; +} XrBodyJointsLocateInfoFB; -struct XrBodyTrackerCreateInfoFB +typedef struct XrBodyTrackerCreateInfoFB { XrStructureType type; const void *next; XrBodyJointSetFB bodyJointSet; -}; +} XrBodyTrackerCreateInfoFB; -struct XrCompositionLayerAlphaBlendFB +typedef struct XrBoundSourcesForActionEnumerateInfo +{ + XrStructureType type; + const void *next; + XrAction action; +} XrBoundSourcesForActionEnumerateInfo; + +typedef struct XrColor3f +{ + float r; + float g; + float b; +} XrColor3f; +typedef XrColor3f XrColor3fKHR; + +typedef struct XrColor4f +{ + float r; + float g; + float b; + float a; +} XrColor4f; + +typedef struct XrCompositionLayerAlphaBlendFB { XrStructureType type; void *next; @@ -2756,1312 +2520,226 @@ struct XrCompositionLayerAlphaBlendFB XrBlendFactorFB dstFactorColor; XrBlendFactorFB srcFactorAlpha; XrBlendFactorFB dstFactorAlpha; -}; +} XrCompositionLayerAlphaBlendFB; -struct XrCompositionLayerDepthTestFB +typedef struct XrCompositionLayerBaseHeader +{ + XrStructureType type; + const void *next; + XrCompositionLayerFlags WINE_XR_ALIGN(8) layerFlags; + XrSpace space; +} XrCompositionLayerBaseHeader; + +typedef struct XrCompositionLayerColorScaleBiasKHR +{ + XrStructureType type; + const void *next; + XrColor4f colorScale; + XrColor4f colorBias; +} XrCompositionLayerColorScaleBiasKHR; + +typedef struct XrCompositionLayerDepthTestFB { XrStructureType type; const void *next; XrBool32 depthMask; XrCompareOpFB compareOp; -}; +} XrCompositionLayerDepthTestFB; -struct XrCompositionLayerImageLayoutFB -{ - XrStructureType type; - void *next; - XrCompositionLayerImageLayoutFlagsFB flags; -}; - -struct XrCompositionLayerReprojectionInfoMSFT -{ - XrStructureType type; - const void *next; - XrReprojectionModeMSFT reprojectionMode; -}; - -struct XrCompositionLayerSecureContentFB -{ - XrStructureType type; - const void *next; - XrCompositionLayerSecureContentFlagsFB flags; -}; - -struct XrControllerModelKeyStateMSFT -{ - XrStructureType type; - void *next; - XrControllerModelKeyMSFT modelKey; -}; - -struct XrDeserializeSceneFragmentMSFT -{ - uint32_t bufferSize; - const uint8_t *buffer; -}; - -struct XrDevicePcmSampleRateStateFB -{ - XrStructureType type; - void *next; - float sampleRate; -}; - -struct XrEnvironmentDepthHandRemovalSetInfoMETA -{ - XrStructureType type; - const void *next; - XrBool32 enabled; -}; - -struct XrEnvironmentDepthProviderCreateInfoMETA -{ - XrStructureType type; - const void *next; - XrEnvironmentDepthProviderCreateFlagsMETA createFlags; -}; - -struct XrEnvironmentDepthSwapchainStateMETA -{ - XrStructureType type; - void *next; - uint32_t width; - uint32_t height; -}; - -struct XrEventDataBuffer -{ - XrStructureType type; - const void *next; - uint8_t varying[4000]; -}; - -struct XrEventDataEventsLost -{ - XrStructureType type; - const void *next; - uint32_t lostEventCount; -}; - -struct XrEventDataHeadsetFitChangedML -{ - XrStructureType type; - const void *next; - XrHeadsetFitStatusML status; - XrTime time; -}; - -struct XrEventDataInteractionProfileChanged -{ - XrStructureType type; - const void *next; - XrSession session; -}; - -struct XrEventDataMainSessionVisibilityChangedEXTX -{ - XrStructureType type; - const void *next; - XrBool32 visible; - XrOverlayMainSessionFlagsEXTX flags; -}; - -struct XrEventDataPassthroughStateChangedFB -{ - XrStructureType type; - const void *next; - XrPassthroughStateChangedFlagsFB flags; -}; - -struct XrEventDataSceneCaptureCompleteFB -{ - XrStructureType type; - const void *next; - XrAsyncRequestIdFB requestId; - XrResult result; -}; - -struct XrEventDataSpaceListSaveCompleteFB -{ - XrStructureType type; - const void *next; - XrAsyncRequestIdFB requestId; - XrResult result; -}; - -struct XrEventDataSpaceQueryResultsAvailableFB -{ - XrStructureType type; - const void *next; - XrAsyncRequestIdFB requestId; -}; - -struct XrEventDataSpaceShareCompleteFB -{ - XrStructureType type; - const void *next; - XrAsyncRequestIdFB requestId; - XrResult result; -}; - -struct XrEventDataUserPresenceChangedEXT -{ - XrStructureType type; - const void *next; - XrSession session; - XrBool32 isUserPresent; -}; - -struct XrEventDataVirtualKeyboardCommitTextMETA -{ - XrStructureType type; - const void *next; - XrVirtualKeyboardMETA keyboard; - char text[XR_MAX_VIRTUAL_KEYBOARD_COMMIT_TEXT_SIZE_META]; -}; - -struct XrEventDataVirtualKeyboardHiddenMETA -{ - XrStructureType type; - const void *next; - XrVirtualKeyboardMETA keyboard; -}; - -struct XrEventDataVisibilityMaskChangedKHR -{ - XrStructureType type; - const void *next; - XrSession session; - XrViewConfigurationType viewConfigurationType; - uint32_t viewIndex; -}; - -struct XrExtensionProperties -{ - XrStructureType type; - void *next; - char extensionName[XR_MAX_EXTENSION_NAME_SIZE]; - uint32_t extensionVersion; -}; - -struct XrExtent2Di -{ - int32_t width; - int32_t height; -}; - -struct XrEyeGazeSampleTimeEXT -{ - XrStructureType type; - void *next; - XrTime time; -}; - -struct XrEyeGazesInfoFB -{ - XrStructureType type; - const void *next; - XrSpace baseSpace; - XrTime time; -}; - -struct XrFaceExpressionInfo2FB -{ - XrStructureType type; - const void *next; - XrTime time; -}; - -struct XrFaceExpressionStatusFB -{ - XrBool32 isValid; - XrBool32 isEyeFollowingBlendshapesValid; -}; - -struct XrFaceExpressionWeightsFB -{ - XrStructureType type; - void *next; - uint32_t weightCount; - float *weights; - uint32_t confidenceCount; - float *confidences; - XrFaceExpressionStatusFB status; - XrTime time; -}; - -struct XrFaceTrackerCreateInfoFB -{ - XrStructureType type; - const void *next; - XrFaceExpressionSetFB faceExpressionSet; -}; - -struct XrFacialTrackerCreateInfoHTC -{ - XrStructureType type; - const void *next; - XrFacialTrackingTypeHTC facialTrackingType; -}; - -struct XrFoveatedViewConfigurationViewVARJO -{ - XrStructureType type; - void *next; - XrBool32 foveatedRenderingActive; -}; - -struct XrFoveationDynamicModeInfoHTC -{ - XrStructureType type; - const void *next; - XrFoveationDynamicFlagsHTC dynamicFlags; -}; - -struct XrFoveationLevelProfileCreateInfoFB -{ - XrStructureType type; - void *next; - XrFoveationLevelFB level; - float verticalOffset; - XrFoveationDynamicFB dynamic; -}; - -struct XrFovf -{ - float angleLeft; - float angleRight; - float angleUp; - float angleDown; -}; - -struct XrFrameEndInfoML -{ - XrStructureType type; - const void *next; - float focusDistance; - XrFrameEndInfoFlagsML flags; -}; - -struct XrFrameWaitInfo -{ - XrStructureType type; - const void *next; -}; - -struct XrFutureCompletionBaseHeaderEXT -{ - XrStructureType type; - void *next; - XrResult futureResult; -}; - -struct XrFuturePollInfoEXT -{ - XrStructureType type; - const void *next; - XrFutureEXT future; -}; - -struct XrGlobalDimmerFrameEndInfoML -{ - XrStructureType type; - const void *next; - float dimmerValue; - XrGlobalDimmerFrameEndInfoFlagsML flags; -}; - -struct XrGraphicsBindingD3D12KHR -{ - XrStructureType type; - const void *next; - ID3D12Device *device; - ID3D12CommandQueue *queue; -}; - -struct XrGraphicsBindingOpenGLWin32KHR -{ - XrStructureType type; - const void *next; - HDC hDC; - HGLRC hGLRC; -}; - -struct XrGraphicsBindingVulkanKHR -{ - XrStructureType type; - const void *next; - VkInstance instance; - VkPhysicalDevice physicalDevice; - VkDevice device; - uint32_t queueFamilyIndex; - uint32_t queueIndex; -}; - -struct XrGraphicsRequirementsD3D12KHR -{ - XrStructureType type; - void *next; - LUID adapterLuid; - D3D_FEATURE_LEVEL minFeatureLevel; -}; - -struct XrGraphicsRequirementsOpenGLKHR -{ - XrStructureType type; - void *next; - XrVersion minApiVersionSupported; - XrVersion maxApiVersionSupported; -}; - -struct XrGraphicsRequirementsVulkanKHR -{ - XrStructureType type; - void *next; - XrVersion minApiVersionSupported; - XrVersion maxApiVersionSupported; -}; - -struct XrHandJointsLocateInfoEXT -{ - XrStructureType type; - const void *next; - XrSpace baseSpace; - XrTime time; -}; - -struct XrHandMeshIndexBufferMSFT -{ - uint32_t indexBufferKey; - uint32_t indexCapacityInput; - uint32_t indexCountOutput; - uint32_t *indices; -}; - -struct XrHandMeshUpdateInfoMSFT -{ - XrStructureType type; - const void *next; - XrTime time; - XrHandPoseTypeMSFT handPoseType; -}; - -struct XrHandPoseTypeInfoMSFT -{ - XrStructureType type; - const void *next; - XrHandPoseTypeMSFT handPoseType; -}; - -struct XrHandTrackingDataSourceInfoEXT -{ - XrStructureType type; - const void *next; - uint32_t requestedDataSourceCount; - XrHandTrackingDataSourceEXT *requestedDataSources; -}; - -struct XrHandTrackingScaleFB -{ - XrStructureType type; - void *next; - float sensorOutput; - float currentOutput; - XrBool32 overrideHandScale; - float overrideValueInput; -}; - -struct XrHapticAmplitudeEnvelopeVibrationFB -{ - XrStructureType type; - const void *next; - XrDuration duration; - uint32_t amplitudeCount; - const float *amplitudes; -}; - -struct XrHapticPcmVibrationFB -{ - XrStructureType type; - const void *next; - uint32_t bufferSize; - const float *buffer; - float sampleRate; - XrBool32 append; - uint32_t *samplesConsumed; -}; - -struct XrHolographicWindowAttachmentMSFT -{ - XrStructureType type; - const void *next; - IUnknown *holographicSpace; - IUnknown *coreWindow; -}; - -struct XrInstanceCreateInfo -{ - XrStructureType type; - const void *next; - XrInstanceCreateFlags createFlags; - XrApplicationInfo applicationInfo; - uint32_t enabledApiLayerCount; - const char * const*enabledApiLayerNames; - uint32_t enabledExtensionCount; - const char * const*enabledExtensionNames; -}; - -struct XrInstanceProperties -{ - XrStructureType type; - void *next; - XrVersion runtimeVersion; - char runtimeName[XR_MAX_RUNTIME_NAME_SIZE]; -}; - -struct XrInteractionProfileState -{ - XrStructureType type; - void *next; - XrPath interactionProfile; -}; - -struct XrKeyboardSpaceCreateInfoFB -{ - XrStructureType type; - void *next; - uint64_t WINE_XR_ALIGN(8) trackedKeyboardId; -}; - -struct XrKeyboardTrackingQueryFB -{ - XrStructureType type; - void *next; - XrKeyboardTrackingQueryFlagsFB flags; -}; - -struct XrLocalizationEnableEventsInfoML -{ - XrStructureType type; - const void *next; - XrBool32 enabled; -}; - -struct XrLocalizationMapQueryInfoBaseHeaderML -{ - XrStructureType type; - const void *next; -}; - -struct XrMarkerDetectorAprilTagInfoML -{ - XrStructureType type; - const void *next; - XrMarkerAprilTagDictML aprilTagDict; -}; - -struct XrMarkerDetectorCreateInfoML -{ - XrStructureType type; - const void *next; - XrMarkerDetectorProfileML profile; - XrMarkerTypeML markerType; -}; - -struct XrMarkerDetectorSizeInfoML -{ - XrStructureType type; - const void *next; - float markerLength; -}; - -struct XrMarkerDetectorStateML -{ - XrStructureType type; - void *next; - XrMarkerDetectorStatusML state; -}; - -struct XrNegotiateApiLayerRequest -{ - XrLoaderInterfaceStructs structType; - uint32_t structVersion; - size_t structSize; - uint32_t layerInterfaceVersion; - XrVersion layerApiVersion; - PFN_xrGetInstanceProcAddr getInstanceProcAddr; - PFN_xrCreateApiLayerInstance createApiLayerInstance; -}; - -struct XrNegotiateRuntimeRequest -{ - XrLoaderInterfaceStructs structType; - uint32_t structVersion; - size_t structSize; - uint32_t runtimeInterfaceVersion; - XrVersion runtimeApiVersion; - PFN_xrGetInstanceProcAddr getInstanceProcAddr; -}; - -struct XrOffset2Df -{ - float x; - float y; -}; - -struct XrOffset3DfFB -{ - float x; - float y; - float z; -}; - -struct XrPassthroughColorHTC -{ - XrStructureType type; - const void *next; - float alpha; -}; - -struct XrPassthroughColorLutDataMETA -{ - uint32_t bufferSize; - const uint8_t *buffer; -}; - -struct XrPassthroughColorMapInterpolatedLutMETA -{ - XrStructureType type; - const void *next; - XrPassthroughColorLutMETA sourceColorLut; - XrPassthroughColorLutMETA targetColorLut; - float weight; -}; - -struct XrPassthroughColorMapMonoToMonoFB -{ - XrStructureType type; - const void *next; - uint8_t textureColorMap[XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB]; -}; - -struct XrPassthroughCreateInfoFB -{ - XrStructureType type; - const void *next; - XrPassthroughFlagsFB flags; -}; - -struct XrPassthroughKeyboardHandsIntensityFB -{ - XrStructureType type; - const void *next; - float leftHandIntensity; - float rightHandIntensity; -}; - -struct XrPassthroughPreferencesMETA -{ - XrStructureType type; - const void *next; - XrPassthroughPreferenceFlagsMETA flags; -}; - -struct XrPerformanceMetricsCounterMETA -{ - XrStructureType type; - const void *next; - XrPerformanceMetricsCounterFlagsMETA counterFlags; - XrPerformanceMetricsCounterUnitMETA counterUnit; - uint32_t uintValue; - float floatValue; -}; - -struct XrPlaneDetectorCreateInfoEXT -{ - XrStructureType type; - const void *next; - XrPlaneDetectorFlagsEXT flags; -}; - -struct XrQuaternionf -{ - float x; - float y; - float z; - float w; -}; - -struct XrRecommendedLayerResolutionMETA -{ - XrStructureType type; - void *next; - XrExtent2Di recommendedImageDimensions; - XrBool32 isValid; -}; - -struct XrRect3DfFB -{ - XrOffset3DfFB offset; - XrExtent3DfFB extent; -}; - -struct XrRenderModelBufferFB -{ - XrStructureType type; - void *next; - uint32_t bufferCapacityInput; - uint32_t bufferCountOutput; - uint8_t *buffer; -}; - -struct XrRenderModelLoadInfoFB -{ - XrStructureType type; - void *next; - XrRenderModelKeyFB modelKey; -}; - -struct XrRenderModelPropertiesFB -{ - XrStructureType type; - void *next; - uint32_t vendorId; - char modelName[XR_MAX_RENDER_MODEL_NAME_SIZE_FB]; - XrRenderModelKeyFB modelKey; - uint32_t modelVersion; - XrRenderModelFlagsFB flags; -}; - -struct XrSceneCaptureRequestInfoFB -{ - XrStructureType type; - const void *next; - uint32_t requestByteCount; - const char *request; -}; - -struct XrSceneComponentsGetInfoMSFT -{ - XrStructureType type; - const void *next; - XrSceneComponentTypeMSFT componentType; -}; - -struct XrSceneCreateInfoMSFT -{ - XrStructureType type; - const void *next; -}; - -struct XrSceneMarkerQRCodeMSFT -{ - XrSceneMarkerQRCodeSymbolTypeMSFT symbolType; - uint8_t version; -}; - -struct XrSceneMarkerTypeFilterMSFT -{ - XrStructureType type; - const void *next; - uint32_t markerTypeCount; - XrSceneMarkerTypeMSFT *markerTypes; -}; - -struct XrSceneMeshBuffersGetInfoMSFT -{ - XrStructureType type; - const void *next; - uint64_t WINE_XR_ALIGN(8) meshBufferId; -}; - -struct XrSceneMeshIndicesUint16MSFT -{ - XrStructureType type; - void *next; - uint32_t indexCapacityInput; - uint32_t indexCountOutput; - uint16_t *indices; -}; - -struct XrSceneMeshMSFT -{ - uint64_t WINE_XR_ALIGN(8) meshBufferId; - XrBool32 supportsIndicesUint16; -}; - -struct XrSceneMeshesMSFT -{ - XrStructureType type; - void *next; - uint32_t sceneMeshCount; - XrSceneMeshMSFT *sceneMeshes; -}; - -struct XrSceneObjectTypesFilterInfoMSFT -{ - XrStructureType type; - const void *next; - uint32_t objectTypeCount; - const XrSceneObjectTypeMSFT *objectTypes; -}; - -struct XrSceneObserverCreateInfoMSFT -{ - XrStructureType type; - const void *next; -}; - -struct XrScenePlaneAlignmentFilterInfoMSFT -{ - XrStructureType type; - const void *next; - uint32_t alignmentCount; - const XrScenePlaneAlignmentTypeMSFT *alignments; -}; - -struct XrSecondaryViewConfigurationSessionBeginInfoMSFT -{ - XrStructureType type; - const void *next; - uint32_t viewConfigurationCount; - const XrViewConfigurationType *enabledViewConfigurationTypes; -}; - -struct XrSecondaryViewConfigurationSwapchainCreateInfoMSFT -{ - XrStructureType type; - const void *next; - XrViewConfigurationType viewConfigurationType; -}; - -struct XrSemanticLabelsSupportInfoFB -{ - XrStructureType type; - const void *next; - XrSemanticLabelsSupportFlagsFB flags; - const char *recognizedLabels; -}; - -struct XrSessionActionSetsAttachInfo -{ - XrStructureType type; - const void *next; - uint32_t countActionSets; - const XrActionSet *actionSets; -}; - -struct XrSessionCreateInfo -{ - XrStructureType type; - const void *next; - XrSessionCreateFlags createFlags; - XrSystemId systemId; -}; - -struct XrSpaceComponentFilterInfoFB -{ - XrStructureType type; - const void *next; - XrSpaceComponentTypeFB componentType; -}; - -struct XrSpaceComponentStatusSetInfoFB -{ - XrStructureType type; - const void *next; - XrSpaceComponentTypeFB componentType; - XrBool32 enabled; - XrDuration timeout; -}; - -struct XrSpaceEraseInfoFB -{ - XrStructureType type; - const void *next; - XrSpace space; - XrSpaceStorageLocationFB location; -}; - -struct XrSpaceListSaveInfoFB -{ - XrStructureType type; - const void *next; - uint32_t spaceCount; - XrSpace *spaces; - XrSpaceStorageLocationFB location; -}; - -struct XrSpaceSaveInfoFB -{ - XrStructureType type; - const void *next; - XrSpace space; - XrSpaceStorageLocationFB location; - XrSpacePersistenceModeFB persistenceMode; -}; - -struct XrSpaceStorageLocationFilterInfoFB -{ - XrStructureType type; - const void *next; - XrSpaceStorageLocationFB location; -}; - -struct XrSpaceUserCreateInfoFB -{ - XrStructureType type; - const void *next; - XrSpaceUserIdFB userId; -}; - -struct XrSpatialAnchorNameHTC -{ - char name[XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_HTC]; -}; - -struct XrSpatialAnchorPersistenceNameMSFT -{ - char name[XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_MSFT]; -}; - -struct XrSpatialGraphNodeBindingPropertiesGetInfoMSFT -{ - XrStructureType type; - const void *next; -}; - -struct XrSwapchainCreateInfoFoveationFB -{ - XrStructureType type; - void *next; - XrSwapchainCreateFoveationFlagsFB flags; -}; - -struct XrSwapchainImageBaseHeader -{ - XrStructureType type; - void *next; -}; - -struct XrSwapchainImageD3D12KHR -{ - XrStructureType type; - void *next; - ID3D12Resource *texture; -}; - -struct XrSwapchainImageReleaseInfo -{ - XrStructureType type; - const void *next; -}; - -struct XrSwapchainImageVulkanKHR -{ - XrStructureType type; - void *next; - VkImage image; -}; - -struct XrSwapchainStateBaseHeaderFB -{ - XrStructureType type; - void *next; -}; - -struct XrSystemAnchorPropertiesHTC -{ - XrStructureType type; - void *next; - XrBool32 supportsAnchor; -}; - -struct XrSystemColorSpacePropertiesFB -{ - XrStructureType type; - void *next; - XrColorSpaceFB colorSpace; -}; - -struct XrSystemEyeGazeInteractionPropertiesEXT -{ - XrStructureType type; - void *next; - XrBool32 supportsEyeGazeInteraction; -}; - -struct XrSystemFaceTrackingProperties2FB -{ - XrStructureType type; - void *next; - XrBool32 supportsVisualFaceTracking; - XrBool32 supportsAudioFaceTracking; -}; - -struct XrSystemFacialTrackingPropertiesHTC -{ - XrStructureType type; - void *next; - XrBool32 supportEyeFacialTracking; - XrBool32 supportLipFacialTracking; -}; - -struct XrSystemFoveatedRenderingPropertiesVARJO -{ - XrStructureType type; - void *next; - XrBool32 supportsFoveatedRendering; -}; - -struct XrSystemGetInfo -{ - XrStructureType type; - const void *next; - XrFormFactor formFactor; -}; - -struct XrSystemHandTrackingMeshPropertiesMSFT -{ - XrStructureType type; - void *next; - XrBool32 supportsHandTrackingMesh; - uint32_t maxHandMeshIndexCount; - uint32_t maxHandMeshVertexCount; -}; - -struct XrSystemKeyboardTrackingPropertiesFB -{ - XrStructureType type; - void *next; - XrBool32 supportsKeyboardTracking; -}; - -struct XrSystemMarkerUnderstandingPropertiesML -{ - XrStructureType type; - void *next; - XrBool32 supportsMarkerUnderstanding; -}; - -struct XrSystemPassthroughProperties2FB -{ - XrStructureType type; - const void *next; - XrPassthroughCapabilityFlagsFB capabilities; -}; - -struct XrSystemPlaneDetectionPropertiesEXT -{ - XrStructureType type; - void *next; - XrPlaneDetectionCapabilityFlagsEXT supportedFeatures; -}; - -struct XrSystemRenderModelPropertiesFB -{ - XrStructureType type; - void *next; - XrBool32 supportsRenderModelLoading; -}; - -struct XrSystemSpatialEntityPropertiesFB -{ - XrStructureType type; - const void *next; - XrBool32 supportsSpatialEntity; -}; - -struct XrSystemUserPresencePropertiesEXT -{ - XrStructureType type; - void *next; - XrBool32 supportsUserPresence; -}; - -struct XrUserCalibrationEnableEventsInfoML -{ - XrStructureType type; - const void *next; - XrBool32 enabled; -}; - -struct XrUuidMSFT -{ - uint8_t bytes[16]; -}; - -struct XrVector3f -{ - float x; - float y; - float z; -}; - -struct XrVector4sFB -{ - int16_t x; - int16_t y; - int16_t z; - int16_t w; -}; - -struct XrViewConfigurationDepthRangeEXT -{ - XrStructureType type; - void *next; - float recommendedNearZ; - float minNearZ; - float recommendedFarZ; - float maxFarZ; -}; - -struct XrViewConfigurationView -{ - XrStructureType type; - void *next; - uint32_t recommendedImageRectWidth; - uint32_t maxImageRectWidth; - uint32_t recommendedImageRectHeight; - uint32_t maxImageRectHeight; - uint32_t recommendedSwapchainSampleCount; - uint32_t maxSwapchainSampleCount; -}; - -struct XrViewLocateFoveatedRenderingVARJO -{ - XrStructureType type; - const void *next; - XrBool32 foveatedRenderingActive; -}; - -struct XrViewState -{ - XrStructureType type; - void *next; - XrViewStateFlags viewStateFlags; -}; - -struct XrVirtualKeyboardCreateInfoMETA -{ - XrStructureType type; - const void *next; -}; - -struct XrVirtualKeyboardModelVisibilitySetInfoMETA -{ - XrStructureType type; - const void *next; - XrBool32 visible; -}; - -struct XrVirtualKeyboardTextContextChangeInfoMETA -{ - XrStructureType type; - const void *next; - const char *textContext; -}; - -struct XrVisualMeshComputeLodInfoMSFT -{ - XrStructureType type; - const void *next; - XrMeshComputeLodMSFT lod; -}; - -struct XrVulkanDeviceCreateInfoKHR -{ - XrStructureType type; - const void *next; - XrSystemId systemId; - XrVulkanDeviceCreateFlagsKHR createFlags; - PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr; - VkPhysicalDevice vulkanPhysicalDevice; - const VkDeviceCreateInfo *vulkanCreateInfo; - const VkAllocationCallbacks *vulkanAllocator; -}; - -struct XrVulkanInstanceCreateInfoKHR -{ - XrStructureType type; - const void *next; - XrSystemId systemId; - XrVulkanInstanceCreateFlagsKHR createFlags; - PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr; - const VkInstanceCreateInfo *vulkanCreateInfo; - const VkAllocationCallbacks *vulkanAllocator; -}; - -struct XrVulkanSwapchainFormatListCreateInfoKHR -{ - XrStructureType type; - const void *next; - uint32_t viewFormatCount; - const VkFormat *viewFormats; -}; - -struct XrUuid -{ - uint8_t data[XR_UUID_SIZE]; -}; - -struct XrActionStateFloat -{ - XrStructureType type; - void *next; - float currentState; - XrBool32 changedSinceLastSync; - XrTime lastChangeTime; - XrBool32 isActive; -}; - -struct XrActionsSyncInfo -{ - XrStructureType type; - const void *next; - uint32_t countActiveActionSets; - const XrActiveActionSet *activeActionSets; -}; - -struct XrApiLayerCreateInfo -{ - XrLoaderInterfaceStructs structType; - uint32_t structVersion; - size_t structSize; - void *loaderInstance; - char settings_file_location[XR_API_LAYER_MAX_SETTINGS_PATH_SIZE]; - XrApiLayerNextInfo *nextInfo; -}; - -struct XrBaseInStructure -{ - XrStructureType type; - const struct XrBaseInStructure *next; -}; - -struct XrBoundSourcesForActionEnumerateInfo -{ - XrStructureType type; - const void *next; - XrAction action; -}; - -struct XrColor3f -{ - float r; - float g; - float b; -}; - -struct XrCompositionLayerBaseHeader -{ - XrStructureType type; - const void *next; - XrCompositionLayerFlags layerFlags; - XrSpace space; -}; - -struct XrCompositionLayerCubeKHR -{ - XrStructureType type; - const void *next; - XrCompositionLayerFlags layerFlags; - XrSpace space; - XrEyeVisibility eyeVisibility; - XrSwapchain swapchain; - uint32_t imageArrayIndex; - XrQuaternionf orientation; -}; - -struct XrCompositionLayerDepthTestVARJO +typedef struct XrCompositionLayerDepthTestVARJO { XrStructureType type; const void *next; float depthTestRangeNearZ; float depthTestRangeFarZ; -}; +} XrCompositionLayerDepthTestVARJO; -struct XrCompositionLayerPassthroughFB +typedef struct XrCompositionLayerImageLayoutFB +{ + XrStructureType type; + void *next; + XrCompositionLayerImageLayoutFlagsFB WINE_XR_ALIGN(8) flags; +} XrCompositionLayerImageLayoutFB; + +typedef struct XrCompositionLayerPassthroughFB { XrStructureType type; const void *next; - XrCompositionLayerFlags flags; + XrCompositionLayerFlags WINE_XR_ALIGN(8) flags; XrSpace space; XrPassthroughLayerFB layerHandle; -}; +} XrCompositionLayerPassthroughFB; -struct XrCompositionLayerReprojectionPlaneOverrideMSFT +typedef struct XrCompositionLayerReprojectionInfoMSFT { XrStructureType type; const void *next; - XrVector3f position; - XrVector3f normal; - XrVector3f velocity; -}; + XrReprojectionModeMSFT reprojectionMode; +} XrCompositionLayerReprojectionInfoMSFT; -struct XrControllerModelNodePropertiesMSFT +typedef struct XrCompositionLayerSecureContentFB +{ + XrStructureType type; + const void *next; + XrCompositionLayerSecureContentFlagsFB WINE_XR_ALIGN(8) flags; +} XrCompositionLayerSecureContentFB; + +typedef struct XrCompositionLayerSettingsFB +{ + XrStructureType type; + const void *next; + XrCompositionLayerSettingsFlagsFB WINE_XR_ALIGN(8) layerFlags; +} XrCompositionLayerSettingsFB; + +typedef struct XrControllerModelKeyStateMSFT +{ + XrStructureType type; + void *next; + XrControllerModelKeyMSFT modelKey; +} XrControllerModelKeyStateMSFT; + +typedef struct XrControllerModelNodePropertiesMSFT { XrStructureType type; void *next; char parentNodeName[XR_MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT]; char nodeName[XR_MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT]; -}; +} XrControllerModelNodePropertiesMSFT; -struct XrControllerModelPropertiesMSFT +typedef struct XrControllerModelPropertiesMSFT { XrStructureType type; void *next; uint32_t nodeCapacityInput; uint32_t nodeCountOutput; XrControllerModelNodePropertiesMSFT *nodeProperties; -}; +} XrControllerModelPropertiesMSFT; -struct XrDebugUtilsLabelEXT +typedef struct XrDeserializeSceneFragmentMSFT +{ + uint32_t bufferSize; + const uint8_t *buffer; +} XrDeserializeSceneFragmentMSFT; + + +typedef struct XrDevicePcmSampleRateStateFB +{ + XrStructureType type; + void *next; + float sampleRate; +} XrDevicePcmSampleRateStateFB; +typedef XrDevicePcmSampleRateStateFB XrDevicePcmSampleRateGetInfoFB; + +typedef struct XrDigitalLensControlALMALENCE { XrStructureType type; const void *next; - const char *labelName; -}; + XrDigitalLensControlFlagsALMALENCE WINE_XR_ALIGN(8) flags; +} XrDigitalLensControlALMALENCE; -struct XrDebugUtilsObjectNameInfoEXT +typedef struct XrEnvironmentDepthHandRemovalSetInfoMETA { XrStructureType type; const void *next; - XrObjectType objectType; - uint64_t WINE_XR_ALIGN(8) objectHandle; - const char *objectName; -}; + XrBool32 enabled; +} XrEnvironmentDepthHandRemovalSetInfoMETA; -struct XrDigitalLensControlALMALENCE +typedef struct XrEnvironmentDepthImageAcquireInfoMETA { XrStructureType type; const void *next; - XrDigitalLensControlFlagsALMALENCE flags; -}; + XrSpace space; + XrTime displayTime; +} XrEnvironmentDepthImageAcquireInfoMETA; -struct XrEnvironmentDepthSwapchainCreateInfoMETA +typedef struct XrEnvironmentDepthProviderCreateInfoMETA { XrStructureType type; const void *next; - XrEnvironmentDepthSwapchainCreateFlagsMETA createFlags; -}; + XrEnvironmentDepthProviderCreateFlagsMETA WINE_XR_ALIGN(8) createFlags; +} XrEnvironmentDepthProviderCreateInfoMETA; -struct XrEventDataDisplayRefreshRateChangedFB +typedef struct XrEnvironmentDepthSwapchainCreateInfoMETA +{ + XrStructureType type; + const void *next; + XrEnvironmentDepthSwapchainCreateFlagsMETA WINE_XR_ALIGN(8) createFlags; +} XrEnvironmentDepthSwapchainCreateInfoMETA; + +typedef struct XrEnvironmentDepthSwapchainStateMETA +{ + XrStructureType type; + void *next; + uint32_t width; + uint32_t height; +} XrEnvironmentDepthSwapchainStateMETA; + +typedef struct XrEventDataBaseHeader +{ + XrStructureType type; + const void *next; +} XrEventDataBaseHeader; + +typedef struct XrEventDataBuffer +{ + XrStructureType type; + const void *next; + uint8_t varying[4000]; +} XrEventDataBuffer; + +typedef struct XrEventDataDisplayRefreshRateChangedFB { XrStructureType type; const void *next; float fromDisplayRefreshRate; float toDisplayRefreshRate; -}; +} XrEventDataDisplayRefreshRateChangedFB; -struct XrEventDataInstanceLossPending +typedef struct XrEventDataEventsLost +{ + XrStructureType type; + const void *next; + uint32_t lostEventCount; +} XrEventDataEventsLost; + +typedef struct XrEventDataEyeCalibrationChangedML +{ + XrStructureType type; + const void *next; + XrEyeCalibrationStatusML status; +} XrEventDataEyeCalibrationChangedML; + +typedef struct XrEventDataHeadsetFitChangedML +{ + XrStructureType type; + const void *next; + XrHeadsetFitStatusML status; + XrTime time; +} XrEventDataHeadsetFitChangedML; + +typedef struct XrEventDataInstanceLossPending { XrStructureType type; const void *next; XrTime lossTime; -}; +} XrEventDataInstanceLossPending; -struct XrEventDataMarkerTrackingUpdateVARJO +typedef struct XrEventDataInteractionProfileChanged +{ + XrStructureType type; + const void *next; + XrSession session; +} XrEventDataInteractionProfileChanged; + +typedef struct XrEventDataMainSessionVisibilityChangedEXTX +{ + XrStructureType type; + const void *next; + XrBool32 visible; + XrOverlayMainSessionFlagsEXTX WINE_XR_ALIGN(8) flags; +} XrEventDataMainSessionVisibilityChangedEXTX; + +typedef struct XrEventDataMarkerTrackingUpdateVARJO { XrStructureType type; const void *next; @@ -4069,61 +2747,200 @@ struct XrEventDataMarkerTrackingUpdateVARJO XrBool32 isActive; XrBool32 isPredicted; XrTime time; -}; +} XrEventDataMarkerTrackingUpdateVARJO; -struct XrEventDataSessionStateChanged +typedef struct XrEventDataPassthroughStateChangedFB +{ + XrStructureType type; + const void *next; + XrPassthroughStateChangedFlagsFB WINE_XR_ALIGN(8) flags; +} XrEventDataPassthroughStateChangedFB; + +typedef struct XrEventDataPerfSettingsEXT +{ + XrStructureType type; + const void *next; + XrPerfSettingsDomainEXT domain; + XrPerfSettingsSubDomainEXT subDomain; + XrPerfSettingsNotificationLevelEXT fromLevel; + XrPerfSettingsNotificationLevelEXT toLevel; +} XrEventDataPerfSettingsEXT; + +typedef struct XrEventDataSceneCaptureCompleteFB +{ + XrStructureType type; + const void *next; + XrAsyncRequestIdFB requestId; + XrResult result; +} XrEventDataSceneCaptureCompleteFB; + +typedef struct XrEventDataSessionStateChanged { XrStructureType type; const void *next; XrSession session; XrSessionState state; XrTime time; -}; +} XrEventDataSessionStateChanged; -struct XrEventDataSpaceQueryCompleteFB +typedef struct XrEventDataSpaceListSaveCompleteFB { XrStructureType type; const void *next; XrAsyncRequestIdFB requestId; XrResult result; -}; +} XrEventDataSpaceListSaveCompleteFB; -struct XrEventDataVirtualKeyboardBackspaceMETA +typedef struct XrEventDataSpaceQueryCompleteFB +{ + XrStructureType type; + const void *next; + XrAsyncRequestIdFB requestId; + XrResult result; +} XrEventDataSpaceQueryCompleteFB; + +typedef struct XrEventDataSpaceQueryResultsAvailableFB +{ + XrStructureType type; + const void *next; + XrAsyncRequestIdFB requestId; +} XrEventDataSpaceQueryResultsAvailableFB; + +typedef struct XrEventDataSpaceShareCompleteFB +{ + XrStructureType type; + const void *next; + XrAsyncRequestIdFB requestId; + XrResult result; +} XrEventDataSpaceShareCompleteFB; + +typedef struct XrEventDataUserPresenceChangedEXT +{ + XrStructureType type; + const void *next; + XrSession session; + XrBool32 isUserPresent; +} XrEventDataUserPresenceChangedEXT; + +typedef struct XrEventDataVirtualKeyboardBackspaceMETA { XrStructureType type; const void *next; XrVirtualKeyboardMETA keyboard; -}; +} XrEventDataVirtualKeyboardBackspaceMETA; -struct XrEventDataVirtualKeyboardShownMETA +typedef struct XrEventDataVirtualKeyboardCommitTextMETA { XrStructureType type; const void *next; XrVirtualKeyboardMETA keyboard; -}; + char text[XR_MAX_VIRTUAL_KEYBOARD_COMMIT_TEXT_SIZE_META]; +} XrEventDataVirtualKeyboardCommitTextMETA; -struct XrExtent2Df +typedef struct XrEventDataVirtualKeyboardEnterMETA +{ + XrStructureType type; + const void *next; + XrVirtualKeyboardMETA keyboard; +} XrEventDataVirtualKeyboardEnterMETA; + +typedef struct XrEventDataVirtualKeyboardHiddenMETA +{ + XrStructureType type; + const void *next; + XrVirtualKeyboardMETA keyboard; +} XrEventDataVirtualKeyboardHiddenMETA; + +typedef struct XrEventDataVirtualKeyboardShownMETA +{ + XrStructureType type; + const void *next; + XrVirtualKeyboardMETA keyboard; +} XrEventDataVirtualKeyboardShownMETA; + +typedef struct XrEventDataVisibilityMaskChangedKHR +{ + XrStructureType type; + const void *next; + XrSession session; + XrViewConfigurationType viewConfigurationType; + uint32_t viewIndex; +} XrEventDataVisibilityMaskChangedKHR; + +typedef struct XrExtensionProperties +{ + XrStructureType type; + void *next; + char extensionName[XR_MAX_EXTENSION_NAME_SIZE]; + uint32_t extensionVersion; +} XrExtensionProperties; + +typedef struct XrExtent2Df { float width; float height; -}; +} XrExtent2Df; -struct XrExternalCameraIntrinsicsOCULUS +typedef struct XrExtent2Di { - XrTime lastChangeTime; - XrFovf fov; - float virtualNearPlaneDistance; - float virtualFarPlaneDistance; - XrExtent2Di imageSensorPixelResolution; -}; + int32_t width; + int32_t height; +} XrExtent2Di; -struct XrEyeTrackerCreateInfoFB +typedef struct XrExtent3Df +{ + float width; + float height; + float depth; +} XrExtent3Df; +typedef XrExtent3Df XrExtent3DfEXT; +typedef XrExtent3Df XrExtent3DfFB; +typedef XrExtent3Df XrExtent3DfKHR; + + + +typedef struct XrEyeGazeSampleTimeEXT +{ + XrStructureType type; + void *next; + XrTime time; +} XrEyeGazeSampleTimeEXT; + +typedef struct XrEyeGazesInfoFB { XrStructureType type; const void *next; -}; + XrSpace baseSpace; + XrTime time; +} XrEyeGazesInfoFB; -struct XrFaceExpressionWeights2FB +typedef struct XrEyeTrackerCreateInfoFB +{ + XrStructureType type; + const void *next; +} XrEyeTrackerCreateInfoFB; + +typedef struct XrFaceExpressionInfo2FB +{ + XrStructureType type; + const void *next; + XrTime time; +} XrFaceExpressionInfo2FB; + +typedef struct XrFaceExpressionInfoFB +{ + XrStructureType type; + const void *next; + XrTime time; +} XrFaceExpressionInfoFB; + +typedef struct XrFaceExpressionStatusFB +{ + XrBool32 isValid; + XrBool32 isEyeFollowingBlendshapesValid; +} XrFaceExpressionStatusFB; + +typedef struct XrFaceExpressionWeights2FB { XrStructureType type; void *next; @@ -4135,9 +2952,37 @@ struct XrFaceExpressionWeights2FB XrBool32 isEyeFollowingBlendshapesValid; XrFaceTrackingDataSource2FB dataSource; XrTime time; -}; +} XrFaceExpressionWeights2FB; -struct XrFacialExpressionsHTC +typedef struct XrFaceExpressionWeightsFB +{ + XrStructureType type; + void *next; + uint32_t weightCount; + float *weights; + uint32_t confidenceCount; + float *confidences; + XrFaceExpressionStatusFB status; + XrTime time; +} XrFaceExpressionWeightsFB; + +typedef struct XrFaceTrackerCreateInfo2FB +{ + XrStructureType type; + const void *next; + XrFaceExpressionSet2FB faceExpressionSet; + uint32_t requestedDataSourceCount; + XrFaceTrackingDataSource2FB *requestedDataSources; +} XrFaceTrackerCreateInfo2FB; + +typedef struct XrFaceTrackerCreateInfoFB +{ + XrStructureType type; + const void *next; + XrFaceExpressionSetFB faceExpressionSet; +} XrFaceTrackerCreateInfoFB; + +typedef struct XrFacialExpressionsHTC { XrStructureType type; const void *next; @@ -4145,22 +2990,73 @@ struct XrFacialExpressionsHTC XrTime sampleTime; uint32_t expressionCount; float *expressionWeightings; -}; +} XrFacialExpressionsHTC; -struct XrFoveationEyeTrackedProfileCreateInfoMETA +typedef struct XrFacialTrackerCreateInfoHTC { XrStructureType type; const void *next; - XrFoveationEyeTrackedProfileCreateFlagsMETA flags; -}; + XrFacialTrackingTypeHTC facialTrackingType; +} XrFacialTrackerCreateInfoHTC; -struct XrFoveationProfileCreateInfoFB +typedef struct XrForceFeedbackCurlApplyLocationMNDX +{ + XrForceFeedbackCurlLocationMNDX location; + float value; +} XrForceFeedbackCurlApplyLocationMNDX; + +typedef struct XrForceFeedbackCurlApplyLocationsMNDX +{ + XrStructureType type; + const void *next; + uint32_t locationCount; + XrForceFeedbackCurlApplyLocationMNDX *locations; +} XrForceFeedbackCurlApplyLocationsMNDX; + +typedef struct XrFoveatedViewConfigurationViewVARJO { XrStructureType type; void *next; -}; + XrBool32 foveatedRenderingActive; +} XrFoveatedViewConfigurationViewVARJO; -struct XrFrameEndInfo +typedef struct XrFoveationEyeTrackedProfileCreateInfoMETA +{ + XrStructureType type; + const void *next; + XrFoveationEyeTrackedProfileCreateFlagsMETA WINE_XR_ALIGN(8) flags; +} XrFoveationEyeTrackedProfileCreateInfoMETA; + +typedef struct XrFoveationLevelProfileCreateInfoFB +{ + XrStructureType type; + void *next; + XrFoveationLevelFB level; + float verticalOffset; + XrFoveationDynamicFB dynamic; +} XrFoveationLevelProfileCreateInfoFB; + +typedef struct XrFoveationProfileCreateInfoFB +{ + XrStructureType type; + void *next; +} XrFoveationProfileCreateInfoFB; + +typedef struct XrFovf +{ + float angleLeft; + float angleRight; + float angleUp; + float angleDown; +} XrFovf; + +typedef struct XrFrameBeginInfo +{ + XrStructureType type; + const void *next; +} XrFrameBeginInfo; + +typedef struct XrFrameEndInfo { XrStructureType type; const void *next; @@ -4168,766 +3064,294 @@ struct XrFrameEndInfo XrEnvironmentBlendMode environmentBlendMode; uint32_t layerCount; const XrCompositionLayerBaseHeader * const*layers; -}; +} XrFrameEndInfo; -struct XrFutureCancelInfoEXT +typedef struct XrFrameEndInfoML +{ + XrStructureType type; + const void *next; + float focusDistance; + XrFrameEndInfoFlagsML WINE_XR_ALIGN(8) flags; +} XrFrameEndInfoML; + +typedef struct XrFrameState +{ + XrStructureType type; + void *next; + XrTime predictedDisplayTime; + XrDuration predictedDisplayPeriod; + XrBool32 shouldRender; +} XrFrameState; + +typedef struct XrFrameWaitInfo +{ + XrStructureType type; + const void *next; +} XrFrameWaitInfo; + +typedef struct XrFutureCancelInfoEXT { XrStructureType type; const void *next; XrFutureEXT future; -}; +} XrFutureCancelInfoEXT; -struct XrFuturePollResultEXT +typedef struct XrFutureCompletionBaseHeaderEXT +{ + XrStructureType type; + void *next; + XrResult futureResult; +} XrFutureCompletionBaseHeaderEXT; + +typedef struct XrFutureCompletionEXT +{ + XrStructureType type; + void *next; + XrResult futureResult; +} XrFutureCompletionEXT; + +typedef struct XrFuturePollInfoEXT +{ + XrStructureType type; + const void *next; + XrFutureEXT future; +} XrFuturePollInfoEXT; + +typedef struct XrFuturePollResultEXT { XrStructureType type; void *next; XrFutureStateEXT state; -}; +} XrFuturePollResultEXT; -struct XrGraphicsBindingD3D11KHR +typedef struct XrGlobalDimmerFrameEndInfoML +{ + XrStructureType type; + const void *next; + float dimmerValue; + XrGlobalDimmerFrameEndInfoFlagsML WINE_XR_ALIGN(8) flags; +} XrGlobalDimmerFrameEndInfoML; + +typedef struct XrGraphicsBindingD3D11KHR { XrStructureType type; const void *next; ID3D11Device *device; -}; +} XrGraphicsBindingD3D11KHR; -struct XrHandCapsuleFB +typedef struct XrGraphicsBindingD3D12KHR { - XrVector3f points[XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB]; - float radius; - XrHandJointEXT joint; -}; + XrStructureType type; + const void *next; + ID3D12Device *device; + ID3D12CommandQueue *queue; +} XrGraphicsBindingD3D12KHR; -struct XrHandJointVelocityEXT +typedef struct XrGraphicsBindingOpenGLWin32KHR { - XrSpaceVelocityFlags velocityFlags; - XrVector3f linearVelocity; - XrVector3f angularVelocity; -}; + XrStructureType type; + const void *next; + HDC hDC; + HGLRC hGLRC; +} XrGraphicsBindingOpenGLWin32KHR; -struct XrHandMeshVertexMSFT +typedef struct XrGraphicsBindingVulkanKHR { - XrVector3f position; - XrVector3f normal; -}; + XrStructureType type; + const void *next; + VkInstance instance; + VkPhysicalDevice physicalDevice; + VkDevice device; + uint32_t queueFamilyIndex; + uint32_t queueIndex; +} XrGraphicsBindingVulkanKHR; +typedef XrGraphicsBindingVulkanKHR XrGraphicsBindingVulkan2KHR; -struct XrHandTrackingCapsulesStateFB +typedef struct XrGraphicsRequirementsD3D11KHR { XrStructureType type; void *next; - XrHandCapsuleFB capsules[XR_HAND_TRACKING_CAPSULE_COUNT_FB]; -}; + LUID adapterLuid; + D3D_FEATURE_LEVEL minFeatureLevel; +} XrGraphicsRequirementsD3D11KHR; -struct XrHapticActionInfo +typedef struct XrGraphicsRequirementsD3D12KHR +{ + XrStructureType type; + void *next; + LUID adapterLuid; + D3D_FEATURE_LEVEL minFeatureLevel; +} XrGraphicsRequirementsD3D12KHR; + +typedef struct XrGraphicsRequirementsOpenGLKHR +{ + XrStructureType type; + void *next; + XrVersion minApiVersionSupported; + XrVersion maxApiVersionSupported; +} XrGraphicsRequirementsOpenGLKHR; + +typedef struct XrGraphicsRequirementsVulkanKHR +{ + XrStructureType type; + void *next; + XrVersion minApiVersionSupported; + XrVersion maxApiVersionSupported; +} XrGraphicsRequirementsVulkanKHR; +typedef XrGraphicsRequirementsVulkanKHR XrGraphicsRequirementsVulkan2KHR; + +typedef struct XrHandJointsLocateInfoEXT +{ + XrStructureType type; + const void *next; + XrSpace baseSpace; + XrTime time; +} XrHandJointsLocateInfoEXT; + +typedef struct XrHandJointsMotionRangeInfoEXT +{ + XrStructureType type; + const void *next; + XrHandJointsMotionRangeEXT handJointsMotionRange; +} XrHandJointsMotionRangeInfoEXT; + +typedef struct XrHandMeshIndexBufferMSFT +{ + uint32_t indexBufferKey; + uint32_t indexCapacityInput; + uint32_t indexCountOutput; + uint32_t *indices; +} XrHandMeshIndexBufferMSFT; + +typedef struct XrHandMeshUpdateInfoMSFT +{ + XrStructureType type; + const void *next; + XrTime time; + XrHandPoseTypeMSFT handPoseType; +} XrHandMeshUpdateInfoMSFT; + +typedef struct XrHandPoseTypeInfoMSFT +{ + XrStructureType type; + const void *next; + XrHandPoseTypeMSFT handPoseType; +} XrHandPoseTypeInfoMSFT; + +typedef struct XrHandTrackerCreateInfoEXT +{ + XrStructureType type; + const void *next; + XrHandEXT hand; + XrHandJointSetEXT handJointSet; +} XrHandTrackerCreateInfoEXT; + +typedef struct XrHandTrackingDataSourceInfoEXT +{ + XrStructureType type; + const void *next; + uint32_t requestedDataSourceCount; + XrHandTrackingDataSourceEXT *requestedDataSources; +} XrHandTrackingDataSourceInfoEXT; + +typedef struct XrHandTrackingDataSourceStateEXT +{ + XrStructureType type; + void *next; + XrBool32 isActive; + XrHandTrackingDataSourceEXT dataSource; +} XrHandTrackingDataSourceStateEXT; + +typedef struct XrHandTrackingScaleFB +{ + XrStructureType type; + void *next; + float sensorOutput; + float currentOutput; + XrBool32 overrideHandScale; + float overrideValueInput; +} XrHandTrackingScaleFB; + +typedef struct XrHapticActionInfo { XrStructureType type; const void *next; XrAction action; XrPath subactionPath; -}; +} XrHapticActionInfo; -struct XrHapticVibration +typedef struct XrHapticAmplitudeEnvelopeVibrationFB +{ + XrStructureType type; + const void *next; + XrDuration duration; + uint32_t amplitudeCount; + const float *amplitudes; +} XrHapticAmplitudeEnvelopeVibrationFB; + +typedef struct XrHapticBaseHeader +{ + XrStructureType type; + const void *next; +} XrHapticBaseHeader; + +typedef struct XrHapticPcmVibrationFB +{ + XrStructureType type; + const void *next; + uint32_t bufferSize; + const float *buffer; + float sampleRate; + XrBool32 append; + uint32_t *samplesConsumed; +} XrHapticPcmVibrationFB; + +typedef struct XrHapticVibration { XrStructureType type; const void *next; XrDuration duration; float frequency; float amplitude; -}; +} XrHapticVibration; -struct XrInteractionProfileSuggestedBinding +typedef struct XrHolographicWindowAttachmentMSFT { XrStructureType type; const void *next; - XrPath interactionProfile; - uint32_t countSuggestedBindings; - const XrActionSuggestedBinding *suggestedBindings; -}; + IUnknown *holographicSpace; + IUnknown *coreWindow; +} XrHolographicWindowAttachmentMSFT; -struct XrLocalizationMapImportInfoML +typedef struct XrInputSourceLocalizedNameGetInfo { XrStructureType type; const void *next; - uint32_t size; - char *data; -}; + XrPath sourcePath; + XrInputSourceLocalizedNameFlags WINE_XR_ALIGN(8) whichComponents; +} XrInputSourceLocalizedNameGetInfo; -struct XrMarkerDetectorArucoInfoML +typedef struct XrInstanceCreateInfo { XrStructureType type; const void *next; - XrMarkerArucoDictML arucoDict; -}; + XrInstanceCreateFlags WINE_XR_ALIGN(8) createFlags; + XrApplicationInfo applicationInfo; + uint32_t enabledApiLayerCount; + const char * const*enabledApiLayerNames; + uint32_t enabledExtensionCount; + const char * const*enabledExtensionNames; +} XrInstanceCreateInfo; -struct XrMarkerDetectorSnapshotInfoML -{ - XrStructureType type; - const void *next; -}; - -struct XrNegotiateLoaderInfo -{ - XrLoaderInterfaceStructs structType; - uint32_t structVersion; - size_t structSize; - uint32_t minInterfaceVersion; - uint32_t maxInterfaceVersion; - XrVersion minApiVersion; - XrVersion maxApiVersion; -}; - -struct XrOffset2Di -{ - int32_t x; - int32_t y; -}; - -struct XrPassthroughColorLutCreateInfoMETA -{ - XrStructureType type; - const void *next; - XrPassthroughColorLutChannelsMETA channels; - uint32_t resolution; - XrPassthroughColorLutDataMETA data; -}; - -struct XrPassthroughColorMapLutMETA -{ - XrStructureType type; - const void *next; - XrPassthroughColorLutMETA colorLut; - float weight; -}; - -struct XrPassthroughCreateInfoHTC -{ - XrStructureType type; - const void *next; - XrPassthroughFormHTC form; -}; - -struct XrPerformanceMetricsStateMETA -{ - XrStructureType type; - const void *next; - XrBool32 enabled; -}; - -struct XrPlaneDetectorGetInfoEXT -{ - XrStructureType type; - const void *next; - XrSpace baseSpace; - XrTime time; -}; - -struct XrPosef -{ - XrQuaternionf orientation; - XrVector3f position; -}; - -struct XrRect2Df -{ - XrOffset2Df offset; - XrExtent2Df extent; -}; - -struct XrReferenceSpaceCreateInfo -{ - XrStructureType type; - const void *next; - XrReferenceSpaceType referenceSpaceType; - XrPosef poseInReferenceSpace; -}; - -struct XrRenderModelPathInfoFB +typedef struct XrInstanceProperties { XrStructureType type; void *next; - XrPath path; -}; + XrVersion runtimeVersion; + char runtimeName[XR_MAX_RUNTIME_NAME_SIZE]; +} XrInstanceProperties; -struct XrSceneComponentLocationMSFT -{ - XrSpaceLocationFlags flags; - XrPosef pose; -}; - -struct XrSceneComponentMSFT -{ - XrSceneComponentTypeMSFT componentType; - XrUuidMSFT id; - XrUuidMSFT parentId; - XrTime updateTime; -}; - -struct XrSceneComponentsLocateInfoMSFT -{ - XrStructureType type; - const void *next; - XrSpace baseSpace; - XrTime time; - uint32_t componentIdCount; - const XrUuidMSFT *componentIds; -}; - -struct XrSceneDeserializeInfoMSFT -{ - XrStructureType type; - const void *next; - uint32_t fragmentCount; - const XrDeserializeSceneFragmentMSFT *fragments; -}; - -struct XrSceneMarkerMSFT -{ - XrSceneMarkerTypeMSFT markerType; - XrTime lastSeenTime; - XrOffset2Df center; - XrExtent2Df size; -}; - -struct XrSceneMarkersMSFT -{ - XrStructureType type; - const void *next; - uint32_t sceneMarkerCapacityInput; - XrSceneMarkerMSFT *sceneMarkers; -}; - -struct XrSceneMeshIndicesUint32MSFT -{ - XrStructureType type; - void *next; - uint32_t indexCapacityInput; - uint32_t indexCountOutput; - uint32_t *indices; -}; - -struct XrSceneObjectMSFT -{ - XrSceneObjectTypeMSFT objectType; -}; - -struct XrSceneOrientedBoxBoundMSFT -{ - XrPosef pose; - XrVector3f extents; -}; - -struct XrSceneSphereBoundMSFT -{ - XrVector3f center; - float radius; -}; - -struct XrSecondaryViewConfigurationLayerInfoMSFT -{ - XrStructureType type; - const void *next; - XrViewConfigurationType viewConfigurationType; - XrEnvironmentBlendMode environmentBlendMode; - uint32_t layerCount; - const XrCompositionLayerBaseHeader * const*layers; -}; - -struct XrSemanticLabelsFB -{ - XrStructureType type; - const void *next; - uint32_t bufferCapacityInput; - uint32_t bufferCountOutput; - char *buffer; -}; - -struct XrSessionBeginInfo -{ - XrStructureType type; - const void *next; - XrViewConfigurationType primaryViewConfigurationType; -}; - -struct XrSpaceComponentStatusFB -{ - XrStructureType type; - void *next; - XrBool32 enabled; - XrBool32 changePending; -}; - -struct XrSpaceFilterInfoBaseHeaderFB -{ - XrStructureType type; - const void *next; -}; - -struct XrSpaceLocationData -{ - XrSpaceLocationFlags locationFlags; - XrPosef pose; -}; - -struct XrSpaceQueryInfoBaseHeaderFB -{ - XrStructureType type; - const void *next; -}; - -struct XrSpaceShareInfoFB -{ - XrStructureType type; - const void *next; - uint32_t spaceCount; - XrSpace *spaces; - uint32_t userCount; - XrSpaceUserFB *users; -}; - -struct XrSpaceTriangleMeshMETA -{ - XrStructureType type; - void *next; - uint32_t vertexCapacityInput; - uint32_t vertexCountOutput; - XrVector3f *vertices; - uint32_t indexCapacityInput; - uint32_t indexCountOutput; - uint32_t *indices; -}; - -struct XrSpaceVelocity -{ - XrStructureType type; - void *next; - XrSpaceVelocityFlags velocityFlags; - XrVector3f linearVelocity; - XrVector3f angularVelocity; -}; - -struct XrSpacesLocateInfo -{ - XrStructureType type; - const void *next; - XrSpace baseSpace; - XrTime time; - uint32_t spaceCount; - const XrSpace *spaces; -}; - -struct XrSpatialAnchorCreateInfoHTC -{ - XrStructureType type; - const void *next; - XrSpace space; - XrPosef poseInSpace; - XrSpatialAnchorNameHTC name; -}; - -struct XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT -{ - XrStructureType type; - const void *next; - XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore; - XrSpatialAnchorPersistenceNameMSFT spatialAnchorPersistenceName; -}; - -struct XrSpatialAnchorSpaceCreateInfoMSFT -{ - XrStructureType type; - const void *next; - XrSpatialAnchorMSFT anchor; - XrPosef poseInAnchorSpace; -}; - -struct XrSpatialGraphNodeSpaceCreateInfoMSFT -{ - XrStructureType type; - const void *next; - XrSpatialGraphNodeTypeMSFT nodeType; - uint8_t nodeId[XR_GUID_SIZE_MSFT]; - XrPosef pose; -}; - -struct XrSpheref -{ - XrPosef center; - float radius; -}; - -struct XrSwapchainImageAcquireInfo -{ - XrStructureType type; - const void *next; -}; - -struct XrSwapchainImageFoveationVulkanFB -{ - XrStructureType type; - void *next; - VkImage image; - uint32_t width; - uint32_t height; -}; - -struct XrSwapchainStateFoveationFB -{ - XrStructureType type; - void *next; - XrSwapchainStateFoveationFlagsFB flags; - XrFoveationProfileFB profile; -}; - -struct XrSystemBodyTrackingPropertiesFB -{ - XrStructureType type; - void *next; - XrBool32 supportsBodyTracking; -}; - -struct XrSystemEyeTrackingPropertiesFB -{ - XrStructureType type; - void *next; - XrBool32 supportsEyeTracking; -}; - -struct XrSystemForceFeedbackCurlPropertiesMNDX -{ - XrStructureType type; - void *next; - XrBool32 supportsForceFeedbackCurl; -}; - -struct XrSystemGraphicsProperties -{ - uint32_t maxSwapchainImageHeight; - uint32_t maxSwapchainImageWidth; - uint32_t maxLayerCount; -}; - -struct XrSystemMarkerTrackingPropertiesVARJO -{ - XrStructureType type; - void *next; - XrBool32 supportsMarkerTracking; -}; - -struct XrSystemPassthroughPropertiesFB -{ - XrStructureType type; - const void *next; - XrBool32 supportsPassthrough; -}; - -struct XrSystemSpaceWarpPropertiesFB -{ - XrStructureType type; - void *next; - uint32_t recommendedMotionVectorImageRectWidth; - uint32_t recommendedMotionVectorImageRectHeight; -}; - -struct XrSystemVirtualKeyboardPropertiesMETA -{ - XrStructureType type; - void *next; - XrBool32 supportsVirtualKeyboard; -}; - -struct XrVector4f -{ - float x; - float y; - float z; - float w; -}; - -struct XrViewConfigurationProperties -{ - XrStructureType type; - void *next; - XrViewConfigurationType viewConfigurationType; - XrBool32 fovMutable; -}; - -struct XrViewLocateInfo -{ - XrStructureType type; - const void *next; - XrViewConfigurationType viewConfigurationType; - XrTime displayTime; - XrSpace space; -}; - -struct XrVirtualKeyboardInputInfoMETA -{ - XrStructureType type; - const void *next; - XrVirtualKeyboardInputSourceMETA inputSource; - XrSpace inputSpace; - XrPosef inputPoseInSpace; - XrVirtualKeyboardInputStateFlagsMETA inputState; -}; - -struct XrVirtualKeyboardSpaceCreateInfoMETA -{ - XrStructureType type; - const void *next; - XrVirtualKeyboardLocationTypeMETA locationType; - XrSpace space; - XrPosef poseInSpace; -}; - -struct XrViveTrackerPathsHTCX -{ - XrStructureType type; - void *next; - XrPath persistentPath; - XrPath rolePath; -}; - -struct XrVulkanSwapchainCreateInfoMETA -{ - XrStructureType type; - const void *next; - VkImageCreateFlags additionalCreateFlags; - VkImageUsageFlags additionalUsageFlags; -}; - -struct XrActionSetCreateInfo -{ - XrStructureType type; - const void *next; - char actionSetName[XR_MAX_ACTION_SET_NAME_SIZE]; - char localizedActionSetName[XR_MAX_LOCALIZED_ACTION_SET_NAME_SIZE]; - uint32_t priority; -}; - -struct XrActionStatePose -{ - XrStructureType type; - void *next; - XrBool32 isActive; -}; - -struct XrActiveActionSetPrioritiesEXT -{ - XrStructureType type; - const void *next; - uint32_t actionSetPriorityCount; - const XrActiveActionSetPriorityEXT *actionSetPriorities; -}; - -struct XrBindingModificationBaseHeaderKHR -{ - XrStructureType type; - const void *next; -}; - -struct XrBodyJointLocationFB -{ - XrSpaceLocationFlags locationFlags; - XrPosef pose; -}; - -struct XrBodySkeletonJointFB -{ - int32_t joint; - int32_t parentJoint; - XrPosef pose; -}; - -struct XrBoxf -{ - XrPosef center; - XrExtent3Df extents; -}; - -struct XrCompositionLayerPassthroughHTC -{ - XrStructureType type; - const void *next; - XrCompositionLayerFlags layerFlags; - XrSpace space; - XrPassthroughHTC passthrough; - XrPassthroughColorHTC color; -}; - -struct XrCompositionLayerSettingsFB -{ - XrStructureType type; - const void *next; - XrCompositionLayerSettingsFlagsFB layerFlags; -}; - -struct XrControllerModelNodeStateMSFT -{ - XrStructureType type; - void *next; - XrPosef nodePose; -}; - -struct XrDebugUtilsMessengerCallbackDataEXT -{ - XrStructureType type; - const void *next; - const char *messageId; - const char *functionName; - const char *message; - uint32_t objectCount; - XrDebugUtilsObjectNameInfoEXT *objects; - uint32_t sessionLabelCount; - XrDebugUtilsLabelEXT *sessionLabels; -}; - -struct XrEnvironmentDepthImageAcquireInfoMETA -{ - XrStructureType type; - const void *next; - XrSpace space; - XrTime displayTime; -}; - -struct XrEnvironmentDepthImageViewMETA -{ - XrStructureType type; - const void *next; - XrFovf fov; - XrPosef pose; -}; - -struct XrEventDataEyeCalibrationChangedML -{ - XrStructureType type; - const void *next; - XrEyeCalibrationStatusML status; -}; - -struct XrEventDataPerfSettingsEXT -{ - XrStructureType type; - const void *next; - XrPerfSettingsDomainEXT domain; - XrPerfSettingsSubDomainEXT subDomain; - XrPerfSettingsNotificationLevelEXT fromLevel; - XrPerfSettingsNotificationLevelEXT toLevel; -}; - -struct XrEventDataSpaceEraseCompleteFB -{ - XrStructureType type; - const void *next; - XrAsyncRequestIdFB requestId; - XrResult result; - XrSpace space; - XrUuidEXT uuid; - XrSpaceStorageLocationFB location; -}; - -struct XrEventDataSpaceSetStatusCompleteFB -{ - XrStructureType type; - const void *next; - XrAsyncRequestIdFB requestId; - XrResult result; - XrSpace space; - XrUuidEXT uuid; - XrSpaceComponentTypeFB componentType; - XrBool32 enabled; -}; - -struct XrEventDataVirtualKeyboardEnterMETA -{ - XrStructureType type; - const void *next; - XrVirtualKeyboardMETA keyboard; -}; - -struct XrEyeGazeFB -{ - XrBool32 isValid; - XrPosef gazePose; - float gazeConfidence; -}; - -struct XrFaceExpressionInfoFB -{ - XrStructureType type; - const void *next; - XrTime time; -}; - -struct XrForceFeedbackCurlApplyLocationMNDX -{ - XrForceFeedbackCurlLocationMNDX location; - float value; -}; - -struct XrFrameBeginInfo -{ - XrStructureType type; - const void *next; -}; - -struct XrFrustumf -{ - XrPosef pose; - XrFovf fov; - float nearZ; - float farZ; -}; - -struct XrGeometryInstanceCreateInfoFB -{ - XrStructureType type; - const void *next; - XrPassthroughLayerFB layer; - XrTriangleMeshFB mesh; - XrSpace baseSpace; - XrPosef pose; - XrVector3f scale; -}; - -struct XrHandJointVelocitiesEXT -{ - XrStructureType type; - void *next; - uint32_t jointCount; - XrHandJointVelocityEXT *jointVelocities; -}; - -struct XrHandMeshSpaceCreateInfoMSFT -{ - XrStructureType type; - const void *next; - XrHandPoseTypeMSFT handPoseType; - XrPosef poseInHandMeshSpace; -}; - -struct XrHandTrackerCreateInfoEXT -{ - XrStructureType type; - const void *next; - XrHandEXT hand; - XrHandJointSetEXT handJointSet; -}; - -struct XrHandTrackingDataSourceStateEXT -{ - XrStructureType type; - void *next; - XrBool32 isActive; - XrHandTrackingDataSourceEXT dataSource; -}; - -struct XrHapticBaseHeader -{ - XrStructureType type; - const void *next; -}; - -struct XrInteractionProfileAnalogThresholdVALVE +typedef struct XrInteractionProfileAnalogThresholdVALVE { XrStructureType type; const void *next; @@ -4937,26 +3361,104 @@ struct XrInteractionProfileAnalogThresholdVALVE float offThreshold; const XrHapticBaseHeader *onHaptic; const XrHapticBaseHeader *offHaptic; -}; +} XrInteractionProfileAnalogThresholdVALVE; -struct XrKeyboardTrackingDescriptionFB +typedef struct XrInteractionProfileDpadBindingEXT { - uint64_t WINE_XR_ALIGN(8) trackedKeyboardId; - XrVector3f size; - XrKeyboardTrackingFlagsFB flags; - char name[XR_MAX_KEYBOARD_TRACKING_NAME_SIZE_FB]; -}; + XrStructureType type; + const void *next; + XrPath binding; + XrActionSet actionSet; + float forceThreshold; + float forceThresholdReleased; + float centerRegion; + float wedgeAngle; + XrBool32 isSticky; + const XrHapticBaseHeader *onHaptic; + const XrHapticBaseHeader *offHaptic; +} XrInteractionProfileDpadBindingEXT; -struct XrLocalizationMapML +typedef struct XrInteractionProfileState { XrStructureType type; void *next; - char name[XR_MAX_LOCALIZATION_MAP_NAME_LENGTH_ML]; - XrUuidEXT mapUuid; - XrLocalizationMapTypeML mapType; -}; + XrPath interactionProfile; +} XrInteractionProfileState; -struct XrMarkerDetectorCustomProfileInfoML +typedef struct XrInteractionProfileSuggestedBinding +{ + XrStructureType type; + const void *next; + XrPath interactionProfile; + uint32_t countSuggestedBindings; + const XrActionSuggestedBinding *suggestedBindings; +} XrInteractionProfileSuggestedBinding; + +typedef struct XrKeyboardSpaceCreateInfoFB +{ + XrStructureType type; + void *next; + uint64_t WINE_XR_ALIGN(8) trackedKeyboardId; +} XrKeyboardSpaceCreateInfoFB; + +typedef struct XrKeyboardTrackingQueryFB +{ + XrStructureType type; + void *next; + XrKeyboardTrackingQueryFlagsFB WINE_XR_ALIGN(8) flags; +} XrKeyboardTrackingQueryFB; + +typedef struct XrLocalDimmingFrameEndInfoMETA +{ + XrStructureType type; + const void *next; + XrLocalDimmingModeMETA localDimmingMode; +} XrLocalDimmingFrameEndInfoMETA; + +typedef struct XrLocalizationEnableEventsInfoML +{ + XrStructureType type; + const void *next; + XrBool32 enabled; +} XrLocalizationEnableEventsInfoML; + +typedef struct XrLocalizationMapImportInfoML +{ + XrStructureType type; + const void *next; + uint32_t size; + char *data; +} XrLocalizationMapImportInfoML; + +typedef struct XrLocalizationMapQueryInfoBaseHeaderML +{ + XrStructureType type; + const void *next; +} XrLocalizationMapQueryInfoBaseHeaderML; + +typedef struct XrMarkerDetectorAprilTagInfoML +{ + XrStructureType type; + const void *next; + XrMarkerAprilTagDictML aprilTagDict; +} XrMarkerDetectorAprilTagInfoML; + +typedef struct XrMarkerDetectorArucoInfoML +{ + XrStructureType type; + const void *next; + XrMarkerArucoDictML arucoDict; +} XrMarkerDetectorArucoInfoML; + +typedef struct XrMarkerDetectorCreateInfoML +{ + XrStructureType type; + const void *next; + XrMarkerDetectorProfileML profile; + XrMarkerTypeML markerType; +} XrMarkerDetectorCreateInfoML; + +typedef struct XrMarkerDetectorCustomProfileInfoML { XrStructureType type; const void *next; @@ -4966,140 +3468,598 @@ struct XrMarkerDetectorCustomProfileInfoML XrMarkerDetectorCornerRefineMethodML cornerRefineMethod; XrBool32 useEdgeRefinement; XrMarkerDetectorFullAnalysisIntervalML fullAnalysisIntervalHint; -}; +} XrMarkerDetectorCustomProfileInfoML; -struct XrMarkerSpaceCreateInfoVARJO +typedef struct XrMarkerDetectorSizeInfoML { XrStructureType type; const void *next; - uint64_t WINE_XR_ALIGN(8) markerId; - XrPosef poseInMarkerSpace; -}; + float markerLength; +} XrMarkerDetectorSizeInfoML; -struct XrPassthroughBrightnessContrastSaturationFB +typedef struct XrMarkerDetectorSnapshotInfoML +{ + XrStructureType type; + const void *next; +} XrMarkerDetectorSnapshotInfoML; + +typedef struct XrMarkerDetectorStateML +{ + XrStructureType type; + void *next; + XrMarkerDetectorStatusML state; +} XrMarkerDetectorStateML; + +typedef struct XrNegotiateApiLayerRequest +{ + XrLoaderInterfaceStructs structType; + uint32_t structVersion; + size_t structSize; + uint32_t layerInterfaceVersion; + XrVersion layerApiVersion; + PFN_xrGetInstanceProcAddr getInstanceProcAddr; + PFN_xrCreateApiLayerInstance createApiLayerInstance; +} XrNegotiateApiLayerRequest; + +typedef struct XrNegotiateLoaderInfo +{ + XrLoaderInterfaceStructs structType; + uint32_t structVersion; + size_t structSize; + uint32_t minInterfaceVersion; + uint32_t maxInterfaceVersion; + XrVersion minApiVersion; + XrVersion maxApiVersion; +} XrNegotiateLoaderInfo; + +typedef struct XrNegotiateRuntimeRequest +{ + XrLoaderInterfaceStructs structType; + uint32_t structVersion; + size_t structSize; + uint32_t runtimeInterfaceVersion; + XrVersion runtimeApiVersion; + PFN_xrGetInstanceProcAddr getInstanceProcAddr; +} XrNegotiateRuntimeRequest; + +typedef struct XrOffset2Df +{ + float x; + float y; +} XrOffset2Df; + +typedef struct XrOffset2Di +{ + int32_t x; + int32_t y; +} XrOffset2Di; + +typedef struct XrOffset3DfFB +{ + float x; + float y; + float z; +} XrOffset3DfFB; + +typedef struct XrPassthroughBrightnessContrastSaturationFB { XrStructureType type; const void *next; float brightness; float contrast; float saturation; -}; +} XrPassthroughBrightnessContrastSaturationFB; -struct XrPassthroughLayerCreateInfoFB +typedef struct XrPassthroughColorHTC +{ + XrStructureType type; + const void *next; + float alpha; +} XrPassthroughColorHTC; + +typedef struct XrPassthroughColorLutDataMETA +{ + uint32_t bufferSize; + const uint8_t *buffer; +} XrPassthroughColorLutDataMETA; + +typedef struct XrPassthroughColorLutUpdateInfoMETA +{ + XrStructureType type; + const void *next; + XrPassthroughColorLutDataMETA data; +} XrPassthroughColorLutUpdateInfoMETA; + +typedef struct XrPassthroughColorMapInterpolatedLutMETA +{ + XrStructureType type; + const void *next; + XrPassthroughColorLutMETA sourceColorLut; + XrPassthroughColorLutMETA targetColorLut; + float weight; +} XrPassthroughColorMapInterpolatedLutMETA; + +typedef struct XrPassthroughColorMapLutMETA +{ + XrStructureType type; + const void *next; + XrPassthroughColorLutMETA colorLut; + float weight; +} XrPassthroughColorMapLutMETA; + +typedef struct XrPassthroughColorMapMonoToMonoFB +{ + XrStructureType type; + const void *next; + uint8_t textureColorMap[XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB]; +} XrPassthroughColorMapMonoToMonoFB; + +typedef struct XrPassthroughColorMapMonoToRgbaFB +{ + XrStructureType type; + const void *next; + XrColor4f textureColorMap[XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB]; +} XrPassthroughColorMapMonoToRgbaFB; + +typedef struct XrPassthroughCreateInfoFB +{ + XrStructureType type; + const void *next; + XrPassthroughFlagsFB WINE_XR_ALIGN(8) flags; +} XrPassthroughCreateInfoFB; + +typedef struct XrPassthroughCreateInfoHTC +{ + XrStructureType type; + const void *next; + XrPassthroughFormHTC form; +} XrPassthroughCreateInfoHTC; + +typedef struct XrPassthroughKeyboardHandsIntensityFB +{ + XrStructureType type; + const void *next; + float leftHandIntensity; + float rightHandIntensity; +} XrPassthroughKeyboardHandsIntensityFB; + +typedef struct XrPassthroughLayerCreateInfoFB { XrStructureType type; const void *next; XrPassthroughFB passthrough; - XrPassthroughFlagsFB flags; + XrPassthroughFlagsFB WINE_XR_ALIGN(8) flags; XrPassthroughLayerPurposeFB purpose; -}; +} XrPassthroughLayerCreateInfoFB; -struct XrPlaneDetectorBeginInfoEXT +typedef struct XrPassthroughPreferencesMETA +{ + XrStructureType type; + const void *next; + XrPassthroughPreferenceFlagsMETA WINE_XR_ALIGN(8) flags; +} XrPassthroughPreferencesMETA; + +typedef struct XrPassthroughStyleFB +{ + XrStructureType type; + const void *next; + float textureOpacityFactor; + XrColor4f edgeColor; +} XrPassthroughStyleFB; + +typedef struct XrPerformanceMetricsCounterMETA +{ + XrStructureType type; + const void *next; + XrPerformanceMetricsCounterFlagsMETA WINE_XR_ALIGN(8) counterFlags; + XrPerformanceMetricsCounterUnitMETA counterUnit; + uint32_t uintValue; + float floatValue; +} XrPerformanceMetricsCounterMETA; + +typedef struct XrPerformanceMetricsStateMETA +{ + XrStructureType type; + const void *next; + XrBool32 enabled; +} XrPerformanceMetricsStateMETA; + +typedef struct XrPlaneDetectorCreateInfoEXT +{ + XrStructureType type; + const void *next; + XrPlaneDetectorFlagsEXT WINE_XR_ALIGN(8) flags; +} XrPlaneDetectorCreateInfoEXT; + +typedef struct XrPlaneDetectorGetInfoEXT { XrStructureType type; const void *next; XrSpace baseSpace; XrTime time; - uint32_t orientationCount; - const XrPlaneDetectorOrientationEXT *orientations; - uint32_t semanticTypeCount; - const XrPlaneDetectorSemanticTypeEXT *semanticTypes; - uint32_t maxPlanes; - float minArea; - XrPosef boundingBoxPose; - XrExtent3DfEXT boundingBoxExtent; -}; +} XrPlaneDetectorGetInfoEXT; -struct XrRecommendedLayerResolutionGetInfoMETA +typedef struct XrQuaternionf +{ + float x; + float y; + float z; + float w; +} XrQuaternionf; + +typedef struct XrRecommendedLayerResolutionGetInfoMETA { XrStructureType type; const void *next; const XrCompositionLayerBaseHeader *layer; XrTime predictedDisplayTime; -}; +} XrRecommendedLayerResolutionGetInfoMETA; -struct XrRenderModelCapabilitiesRequestFB +typedef struct XrRecommendedLayerResolutionMETA { XrStructureType type; void *next; - XrRenderModelFlagsFB flags; -}; + XrExtent2Di recommendedImageDimensions; + XrBool32 isValid; +} XrRecommendedLayerResolutionMETA; -struct XrSceneComponentLocationsMSFT +typedef struct XrRect2Df +{ + XrOffset2Df offset; + XrExtent2Df extent; +} XrRect2Df; + +typedef struct XrRect2Di +{ + XrOffset2Di offset; + XrExtent2Di extent; +} XrRect2Di; + +typedef struct XrRect3DfFB +{ + XrOffset3DfFB offset; + XrExtent3DfFB extent; +} XrRect3DfFB; + +typedef struct XrRenderModelBufferFB { XrStructureType type; void *next; - uint32_t locationCount; - XrSceneComponentLocationMSFT *locations; -}; + uint32_t bufferCapacityInput; + uint32_t bufferCountOutput; + uint8_t *buffer; +} XrRenderModelBufferFB; -struct XrSceneComponentsMSFT +typedef struct XrRenderModelCapabilitiesRequestFB { XrStructureType type; void *next; - uint32_t componentCapacityInput; - uint32_t componentCountOutput; - XrSceneComponentMSFT *components; -}; + XrRenderModelFlagsFB WINE_XR_ALIGN(8) flags; +} XrRenderModelCapabilitiesRequestFB; -struct XrSceneMarkerQRCodesMSFT +typedef struct XrRenderModelLoadInfoFB +{ + XrStructureType type; + void *next; + XrRenderModelKeyFB modelKey; +} XrRenderModelLoadInfoFB; + +typedef struct XrRenderModelPathInfoFB +{ + XrStructureType type; + void *next; + XrPath path; +} XrRenderModelPathInfoFB; + +typedef struct XrRenderModelPropertiesFB +{ + XrStructureType type; + void *next; + uint32_t vendorId; + char modelName[XR_MAX_RENDER_MODEL_NAME_SIZE_FB]; + XrRenderModelKeyFB modelKey; + uint32_t modelVersion; + XrRenderModelFlagsFB WINE_XR_ALIGN(8) flags; +} XrRenderModelPropertiesFB; + +typedef struct XrSceneCaptureRequestInfoFB +{ + XrStructureType type; + const void *next; + uint32_t requestByteCount; + const char *request; +} XrSceneCaptureRequestInfoFB; + +typedef struct XrSceneComponentsGetInfoMSFT +{ + XrStructureType type; + const void *next; + XrSceneComponentTypeMSFT componentType; +} XrSceneComponentsGetInfoMSFT; + +typedef struct XrSceneCreateInfoMSFT +{ + XrStructureType type; + const void *next; +} XrSceneCreateInfoMSFT; + +typedef struct XrSceneDeserializeInfoMSFT +{ + XrStructureType type; + const void *next; + uint32_t fragmentCount; + const XrDeserializeSceneFragmentMSFT *fragments; +} XrSceneDeserializeInfoMSFT; + +typedef struct XrSceneMarkerMSFT +{ + XrSceneMarkerTypeMSFT markerType; + XrTime lastSeenTime; + XrOffset2Df center; + XrExtent2Df size; +} XrSceneMarkerMSFT; + +typedef struct XrSceneMarkerQRCodeMSFT +{ + XrSceneMarkerQRCodeSymbolTypeMSFT symbolType; + uint8_t version; +} XrSceneMarkerQRCodeMSFT; + +typedef struct XrSceneMarkerQRCodesMSFT { XrStructureType type; const void *next; uint32_t qrCodeCapacityInput; XrSceneMarkerQRCodeMSFT *qrCodes; -}; +} XrSceneMarkerQRCodesMSFT; -struct XrSceneMeshVertexBufferMSFT +typedef struct XrSceneMarkerTypeFilterMSFT +{ + XrStructureType type; + const void *next; + uint32_t markerTypeCount; + XrSceneMarkerTypeMSFT *markerTypes; +} XrSceneMarkerTypeFilterMSFT; + +typedef struct XrSceneMarkersMSFT +{ + XrStructureType type; + const void *next; + uint32_t sceneMarkerCapacityInput; + XrSceneMarkerMSFT *sceneMarkers; +} XrSceneMarkersMSFT; + +typedef struct XrSceneMeshBuffersGetInfoMSFT +{ + XrStructureType type; + const void *next; + uint64_t WINE_XR_ALIGN(8) meshBufferId; +} XrSceneMeshBuffersGetInfoMSFT; + +typedef struct XrSceneMeshBuffersMSFT { XrStructureType type; void *next; - uint32_t vertexCapacityInput; - uint32_t vertexCountOutput; - XrVector3f *vertices; -}; +} XrSceneMeshBuffersMSFT; -struct XrScenePlaneMSFT +typedef struct XrSceneMeshIndicesUint16MSFT +{ + XrStructureType type; + void *next; + uint32_t indexCapacityInput; + uint32_t indexCountOutput; + uint16_t *indices; +} XrSceneMeshIndicesUint16MSFT; + +typedef struct XrSceneMeshIndicesUint32MSFT +{ + XrStructureType type; + void *next; + uint32_t indexCapacityInput; + uint32_t indexCountOutput; + uint32_t *indices; +} XrSceneMeshIndicesUint32MSFT; + +typedef struct XrSceneMeshMSFT +{ + uint64_t WINE_XR_ALIGN(8) meshBufferId; + XrBool32 supportsIndicesUint16; +} XrSceneMeshMSFT; + +typedef struct XrSceneMeshesMSFT +{ + XrStructureType type; + void *next; + uint32_t sceneMeshCount; + XrSceneMeshMSFT *sceneMeshes; +} XrSceneMeshesMSFT; + +typedef struct XrSceneObjectMSFT +{ + XrSceneObjectTypeMSFT objectType; +} XrSceneObjectMSFT; + +typedef struct XrSceneObjectTypesFilterInfoMSFT +{ + XrStructureType type; + const void *next; + uint32_t objectTypeCount; + const XrSceneObjectTypeMSFT *objectTypes; +} XrSceneObjectTypesFilterInfoMSFT; + +typedef struct XrSceneObjectsMSFT +{ + XrStructureType type; + void *next; + uint32_t sceneObjectCount; + XrSceneObjectMSFT *sceneObjects; +} XrSceneObjectsMSFT; + +typedef struct XrSceneObserverCreateInfoMSFT +{ + XrStructureType type; + const void *next; +} XrSceneObserverCreateInfoMSFT; + +typedef struct XrScenePlaneAlignmentFilterInfoMSFT +{ + XrStructureType type; + const void *next; + uint32_t alignmentCount; + const XrScenePlaneAlignmentTypeMSFT *alignments; +} XrScenePlaneAlignmentFilterInfoMSFT; + +typedef struct XrScenePlaneMSFT { XrScenePlaneAlignmentTypeMSFT alignment; XrExtent2Df size; uint64_t WINE_XR_ALIGN(8) meshBufferId; XrBool32 supportsIndicesUint16; -}; +} XrScenePlaneMSFT; -struct XrSecondaryViewConfigurationFrameEndInfoMSFT +typedef struct XrScenePlanesMSFT +{ + XrStructureType type; + void *next; + uint32_t scenePlaneCount; + XrScenePlaneMSFT *scenePlanes; +} XrScenePlanesMSFT; + +typedef struct XrSecondaryViewConfigurationLayerInfoMSFT +{ + XrStructureType type; + const void *next; + XrViewConfigurationType viewConfigurationType; + XrEnvironmentBlendMode environmentBlendMode; + uint32_t layerCount; + const XrCompositionLayerBaseHeader * const*layers; +} XrSecondaryViewConfigurationLayerInfoMSFT; + +typedef struct XrSecondaryViewConfigurationSessionBeginInfoMSFT { XrStructureType type; const void *next; uint32_t viewConfigurationCount; - const XrSecondaryViewConfigurationLayerInfoMSFT *viewConfigurationLayersInfo; -}; + const XrViewConfigurationType *enabledViewConfigurationTypes; +} XrSecondaryViewConfigurationSessionBeginInfoMSFT; -struct XrSecondaryViewConfigurationStateMSFT +typedef struct XrSecondaryViewConfigurationStateMSFT { XrStructureType type; void *next; XrViewConfigurationType viewConfigurationType; XrBool32 active; -}; +} XrSecondaryViewConfigurationStateMSFT; -struct XrSessionCreateInfoOverlayEXTX +typedef struct XrSecondaryViewConfigurationSwapchainCreateInfoMSFT { XrStructureType type; const void *next; - XrOverlaySessionCreateFlagsEXTX createFlags; - uint32_t sessionLayersPlacement; -}; + XrViewConfigurationType viewConfigurationType; +} XrSecondaryViewConfigurationSwapchainCreateInfoMSFT; -struct XrSpaceLocation +typedef struct XrSemanticLabelsFB +{ + XrStructureType type; + const void *next; + uint32_t bufferCapacityInput; + uint32_t bufferCountOutput; + char *buffer; +} XrSemanticLabelsFB; + +typedef struct XrSemanticLabelsSupportInfoFB +{ + XrStructureType type; + const void *next; + XrSemanticLabelsSupportFlagsFB WINE_XR_ALIGN(8) flags; + const char *recognizedLabels; +} XrSemanticLabelsSupportInfoFB; + +typedef struct XrSessionActionSetsAttachInfo +{ + XrStructureType type; + const void *next; + uint32_t countActionSets; + const XrActionSet *actionSets; +} XrSessionActionSetsAttachInfo; + +typedef struct XrSessionBeginInfo +{ + XrStructureType type; + const void *next; + XrViewConfigurationType primaryViewConfigurationType; +} XrSessionBeginInfo; + +typedef struct XrSessionCreateInfo +{ + XrStructureType type; + const void *next; + XrSessionCreateFlags WINE_XR_ALIGN(8) createFlags; + XrSystemId systemId; +} XrSessionCreateInfo; + +typedef struct XrSessionCreateInfoOverlayEXTX +{ + XrStructureType type; + const void *next; + XrOverlaySessionCreateFlagsEXTX WINE_XR_ALIGN(8) createFlags; + uint32_t sessionLayersPlacement; +} XrSessionCreateInfoOverlayEXTX; + +typedef struct XrSpaceComponentFilterInfoFB +{ + XrStructureType type; + const void *next; + XrSpaceComponentTypeFB componentType; +} XrSpaceComponentFilterInfoFB; + +typedef struct XrSpaceComponentStatusFB { XrStructureType type; void *next; - XrSpaceLocationFlags locationFlags; - XrPosef pose; -}; + XrBool32 enabled; + XrBool32 changePending; +} XrSpaceComponentStatusFB; -struct XrSpaceQueryInfoFB +typedef struct XrSpaceComponentStatusSetInfoFB +{ + XrStructureType type; + const void *next; + XrSpaceComponentTypeFB componentType; + XrBool32 enabled; + XrDuration timeout; +} XrSpaceComponentStatusSetInfoFB; + +typedef struct XrSpaceEraseInfoFB +{ + XrStructureType type; + const void *next; + XrSpace space; + XrSpaceStorageLocationFB location; +} XrSpaceEraseInfoFB; + +typedef struct XrSpaceFilterInfoBaseHeaderFB +{ + XrStructureType type; + const void *next; +} XrSpaceFilterInfoBaseHeaderFB; + +typedef struct XrSpaceListSaveInfoFB +{ + XrStructureType type; + const void *next; + uint32_t spaceCount; + XrSpace *spaces; + XrSpaceStorageLocationFB location; +} XrSpaceListSaveInfoFB; + +typedef struct XrSpaceQueryInfoBaseHeaderFB +{ + XrStructureType type; + const void *next; +} XrSpaceQueryInfoBaseHeaderFB; + +typedef struct XrSpaceQueryInfoFB { XrStructureType type; const void *next; @@ -5108,44 +4068,80 @@ struct XrSpaceQueryInfoFB XrDuration timeout; const XrSpaceFilterInfoBaseHeaderFB *filter; const XrSpaceFilterInfoBaseHeaderFB *excludeFilter; -}; +} XrSpaceQueryInfoFB; -struct XrSpaceTriangleMeshGetInfoMETA -{ - XrStructureType type; - const void *next; -}; - -struct XrSpaceVelocityData -{ - XrSpaceVelocityFlags velocityFlags; - XrVector3f linearVelocity; - XrVector3f angularVelocity; -}; - -struct XrSpatialAnchorCreateInfoMSFT +typedef struct XrSpaceSaveInfoFB { XrStructureType type; const void *next; XrSpace space; - XrPosef pose; - XrTime time; -}; + XrSpaceStorageLocationFB location; + XrSpacePersistenceModeFB persistenceMode; +} XrSpaceSaveInfoFB; -struct XrSpatialGraphNodeBindingPropertiesMSFT -{ - XrStructureType type; - void *next; - uint8_t nodeId[XR_GUID_SIZE_MSFT]; - XrPosef poseInNodeSpace; -}; - -struct XrSwapchainCreateInfo +typedef struct XrSpaceShareInfoFB { XrStructureType type; const void *next; - XrSwapchainCreateFlags createFlags; - XrSwapchainUsageFlags usageFlags; + uint32_t spaceCount; + XrSpace *spaces; + uint32_t userCount; + XrSpaceUserFB *users; +} XrSpaceShareInfoFB; + +typedef struct XrSpaceStorageLocationFilterInfoFB +{ + XrStructureType type; + const void *next; + XrSpaceStorageLocationFB location; +} XrSpaceStorageLocationFilterInfoFB; + +typedef struct XrSpaceTriangleMeshGetInfoMETA +{ + XrStructureType type; + const void *next; +} XrSpaceTriangleMeshGetInfoMETA; + +typedef struct XrSpaceUserCreateInfoFB +{ + XrStructureType type; + const void *next; + XrSpaceUserIdFB userId; +} XrSpaceUserCreateInfoFB; + +typedef struct XrSpacesLocateInfo +{ + XrStructureType type; + const void *next; + XrSpace baseSpace; + XrTime time; + uint32_t spaceCount; + const XrSpace *spaces; +} XrSpacesLocateInfo; +typedef XrSpacesLocateInfo XrSpacesLocateInfoKHR; + +typedef struct XrSpatialAnchorNameHTC +{ + char name[XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_HTC]; +} XrSpatialAnchorNameHTC; + +typedef struct XrSpatialAnchorPersistenceNameMSFT +{ + char name[XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_MSFT]; +} XrSpatialAnchorPersistenceNameMSFT; + +typedef struct XrSpatialGraphNodeBindingPropertiesGetInfoMSFT +{ + XrStructureType type; + const void *next; +} XrSpatialGraphNodeBindingPropertiesGetInfoMSFT; + +typedef struct XrSwapchainCreateInfo +{ + XrStructureType type; + const void *next; + XrSwapchainCreateFlags WINE_XR_ALIGN(8) createFlags; + XrSwapchainUsageFlags WINE_XR_ALIGN(8) usageFlags; int64_t format; uint32_t sampleCount; uint32_t width; @@ -5153,68 +4149,471 @@ struct XrSwapchainCreateInfo uint32_t faceCount; uint32_t arraySize; uint32_t mipCount; -}; +} XrSwapchainCreateInfo; -struct XrSwapchainImageOpenGLKHR +typedef struct XrSwapchainCreateInfoFoveationFB +{ + XrStructureType type; + void *next; + XrSwapchainCreateFoveationFlagsFB WINE_XR_ALIGN(8) flags; +} XrSwapchainCreateInfoFoveationFB; + +typedef struct XrSwapchainImageAcquireInfo +{ + XrStructureType type; + const void *next; +} XrSwapchainImageAcquireInfo; + +typedef struct XrSwapchainImageBaseHeader +{ + XrStructureType type; + void *next; +} XrSwapchainImageBaseHeader; + +typedef struct XrSwapchainImageD3D11KHR +{ + XrStructureType type; + void *next; + ID3D11Texture2D *texture; +} XrSwapchainImageD3D11KHR; + +typedef struct XrSwapchainImageD3D12KHR +{ + XrStructureType type; + void *next; + ID3D12Resource *texture; +} XrSwapchainImageD3D12KHR; + +typedef struct XrSwapchainImageFoveationVulkanFB +{ + XrStructureType type; + void *next; + VkImage image; + uint32_t width; + uint32_t height; +} XrSwapchainImageFoveationVulkanFB; + +typedef struct XrSwapchainImageOpenGLKHR { XrStructureType type; void *next; uint32_t image; -}; +} XrSwapchainImageOpenGLKHR; -struct XrSystemEnvironmentDepthPropertiesMETA +typedef struct XrSwapchainImageReleaseInfo +{ + XrStructureType type; + const void *next; +} XrSwapchainImageReleaseInfo; + +typedef struct XrSwapchainImageVulkanKHR +{ + XrStructureType type; + void *next; + VkImage image; +} XrSwapchainImageVulkanKHR; +typedef XrSwapchainImageVulkanKHR XrSwapchainImageVulkan2KHR; + +typedef struct XrSwapchainImageWaitInfo +{ + XrStructureType type; + const void *next; + XrDuration timeout; +} XrSwapchainImageWaitInfo; + +typedef struct XrSwapchainStateBaseHeaderFB +{ + XrStructureType type; + void *next; +} XrSwapchainStateBaseHeaderFB; + +typedef struct XrSwapchainStateFoveationFB +{ + XrStructureType type; + void *next; + XrSwapchainStateFoveationFlagsFB WINE_XR_ALIGN(8) flags; + XrFoveationProfileFB profile; +} XrSwapchainStateFoveationFB; + +typedef struct XrSwapchainStateSamplerVulkanFB +{ + XrStructureType type; + void *next; + VkFilter minFilter; + VkFilter magFilter; + VkSamplerMipmapMode mipmapMode; + VkSamplerAddressMode wrapModeS; + VkSamplerAddressMode wrapModeT; + VkComponentSwizzle swizzleRed; + VkComponentSwizzle swizzleGreen; + VkComponentSwizzle swizzleBlue; + VkComponentSwizzle swizzleAlpha; + float maxAnisotropy; + XrColor4f borderColor; +} XrSwapchainStateSamplerVulkanFB; + +typedef struct XrSwapchainSubImage +{ + XrSwapchain swapchain; + XrRect2Di imageRect; + uint32_t imageArrayIndex; +} XrSwapchainSubImage; + +typedef struct XrSystemAnchorPropertiesHTC +{ + XrStructureType type; + void *next; + XrBool32 supportsAnchor; +} XrSystemAnchorPropertiesHTC; + +typedef struct XrSystemBodyTrackingPropertiesFB +{ + XrStructureType type; + void *next; + XrBool32 supportsBodyTracking; +} XrSystemBodyTrackingPropertiesFB; + +typedef struct XrSystemColorSpacePropertiesFB +{ + XrStructureType type; + void *next; + XrColorSpaceFB colorSpace; +} XrSystemColorSpacePropertiesFB; + +typedef struct XrSystemEnvironmentDepthPropertiesMETA { XrStructureType type; void *next; XrBool32 supportsEnvironmentDepth; XrBool32 supportsHandRemoval; -}; +} XrSystemEnvironmentDepthPropertiesMETA; -struct XrSystemFoveationEyeTrackedPropertiesMETA +typedef struct XrSystemEyeGazeInteractionPropertiesEXT +{ + XrStructureType type; + void *next; + XrBool32 supportsEyeGazeInteraction; +} XrSystemEyeGazeInteractionPropertiesEXT; + +typedef struct XrSystemEyeTrackingPropertiesFB +{ + XrStructureType type; + void *next; + XrBool32 supportsEyeTracking; +} XrSystemEyeTrackingPropertiesFB; + +typedef struct XrSystemFaceTrackingProperties2FB +{ + XrStructureType type; + void *next; + XrBool32 supportsVisualFaceTracking; + XrBool32 supportsAudioFaceTracking; +} XrSystemFaceTrackingProperties2FB; + +typedef struct XrSystemFaceTrackingPropertiesFB +{ + XrStructureType type; + void *next; + XrBool32 supportsFaceTracking; +} XrSystemFaceTrackingPropertiesFB; + +typedef struct XrSystemFacialTrackingPropertiesHTC +{ + XrStructureType type; + void *next; + XrBool32 supportEyeFacialTracking; + XrBool32 supportLipFacialTracking; +} XrSystemFacialTrackingPropertiesHTC; + +typedef struct XrSystemForceFeedbackCurlPropertiesMNDX +{ + XrStructureType type; + void *next; + XrBool32 supportsForceFeedbackCurl; +} XrSystemForceFeedbackCurlPropertiesMNDX; + +typedef struct XrSystemFoveatedRenderingPropertiesVARJO +{ + XrStructureType type; + void *next; + XrBool32 supportsFoveatedRendering; +} XrSystemFoveatedRenderingPropertiesVARJO; + +typedef struct XrSystemFoveationEyeTrackedPropertiesMETA { XrStructureType type; void *next; XrBool32 supportsFoveationEyeTracked; -}; +} XrSystemFoveationEyeTrackedPropertiesMETA; -struct XrSystemHeadsetIdPropertiesMETA +typedef struct XrSystemGetInfo +{ + XrStructureType type; + const void *next; + XrFormFactor formFactor; +} XrSystemGetInfo; + +typedef struct XrSystemGraphicsProperties +{ + uint32_t maxSwapchainImageHeight; + uint32_t maxSwapchainImageWidth; + uint32_t maxLayerCount; +} XrSystemGraphicsProperties; + +typedef struct XrSystemHandTrackingMeshPropertiesMSFT { XrStructureType type; void *next; - XrUuidEXT id; -}; + XrBool32 supportsHandTrackingMesh; + uint32_t maxHandMeshIndexCount; + uint32_t maxHandMeshVertexCount; +} XrSystemHandTrackingMeshPropertiesMSFT; -struct XrSystemTrackingProperties +typedef struct XrSystemHandTrackingPropertiesEXT +{ + XrStructureType type; + void *next; + XrBool32 supportsHandTracking; +} XrSystemHandTrackingPropertiesEXT; + +typedef struct XrSystemKeyboardTrackingPropertiesFB +{ + XrStructureType type; + void *next; + XrBool32 supportsKeyboardTracking; +} XrSystemKeyboardTrackingPropertiesFB; + +typedef struct XrSystemMarkerTrackingPropertiesVARJO +{ + XrStructureType type; + void *next; + XrBool32 supportsMarkerTracking; +} XrSystemMarkerTrackingPropertiesVARJO; + +typedef struct XrSystemMarkerUnderstandingPropertiesML +{ + XrStructureType type; + void *next; + XrBool32 supportsMarkerUnderstanding; +} XrSystemMarkerUnderstandingPropertiesML; + +typedef struct XrSystemPassthroughColorLutPropertiesMETA +{ + XrStructureType type; + const void *next; + uint32_t maxColorLutResolution; +} XrSystemPassthroughColorLutPropertiesMETA; + +typedef struct XrSystemPassthroughProperties2FB +{ + XrStructureType type; + const void *next; + XrPassthroughCapabilityFlagsFB WINE_XR_ALIGN(8) capabilities; +} XrSystemPassthroughProperties2FB; + +typedef struct XrSystemPassthroughPropertiesFB +{ + XrStructureType type; + const void *next; + XrBool32 supportsPassthrough; +} XrSystemPassthroughPropertiesFB; + +typedef struct XrSystemPlaneDetectionPropertiesEXT +{ + XrStructureType type; + void *next; + XrPlaneDetectionCapabilityFlagsEXT WINE_XR_ALIGN(8) supportedFeatures; +} XrSystemPlaneDetectionPropertiesEXT; + +typedef struct XrSystemRenderModelPropertiesFB +{ + XrStructureType type; + void *next; + XrBool32 supportsRenderModelLoading; +} XrSystemRenderModelPropertiesFB; + +typedef struct XrSystemSpaceWarpPropertiesFB +{ + XrStructureType type; + void *next; + uint32_t recommendedMotionVectorImageRectWidth; + uint32_t recommendedMotionVectorImageRectHeight; +} XrSystemSpaceWarpPropertiesFB; + +typedef struct XrSystemSpatialEntityPropertiesFB +{ + XrStructureType type; + const void *next; + XrBool32 supportsSpatialEntity; +} XrSystemSpatialEntityPropertiesFB; + +typedef struct XrSystemTrackingProperties { XrBool32 orientationTracking; XrBool32 positionTracking; -}; +} XrSystemTrackingProperties; -struct XrVector2f +typedef struct XrSystemUserPresencePropertiesEXT +{ + XrStructureType type; + void *next; + XrBool32 supportsUserPresence; +} XrSystemUserPresencePropertiesEXT; + +typedef struct XrSystemVirtualKeyboardPropertiesMETA +{ + XrStructureType type; + void *next; + XrBool32 supportsVirtualKeyboard; +} XrSystemVirtualKeyboardPropertiesMETA; + +typedef struct XrUserCalibrationEnableEventsInfoML +{ + XrStructureType type; + const void *next; + XrBool32 enabled; +} XrUserCalibrationEnableEventsInfoML; + +typedef struct XrUuid +{ + uint8_t data[XR_UUID_SIZE]; +} XrUuid; +typedef XrUuid XrUuidEXT; + + +typedef struct XrUuidMSFT +{ + uint8_t bytes[16]; +} XrUuidMSFT; + +typedef struct XrVector2f { float x; float y; -}; +} XrVector2f; -struct XrViewConfigurationViewFovEPIC +typedef struct XrVector3f +{ + float x; + float y; + float z; +} XrVector3f; + +typedef struct XrVector4f +{ + float x; + float y; + float z; + float w; +} XrVector4f; + +typedef struct XrVector4sFB +{ + int16_t x; + int16_t y; + int16_t z; + int16_t w; +} XrVector4sFB; + +typedef struct XrViewConfigurationDepthRangeEXT +{ + XrStructureType type; + void *next; + float recommendedNearZ; + float minNearZ; + float recommendedFarZ; + float maxFarZ; +} XrViewConfigurationDepthRangeEXT; + +typedef struct XrViewConfigurationProperties +{ + XrStructureType type; + void *next; + XrViewConfigurationType viewConfigurationType; + XrBool32 fovMutable; +} XrViewConfigurationProperties; + +typedef struct XrViewConfigurationView +{ + XrStructureType type; + void *next; + uint32_t recommendedImageRectWidth; + uint32_t maxImageRectWidth; + uint32_t recommendedImageRectHeight; + uint32_t maxImageRectHeight; + uint32_t recommendedSwapchainSampleCount; + uint32_t maxSwapchainSampleCount; +} XrViewConfigurationView; + +typedef struct XrViewConfigurationViewFovEPIC { XrStructureType type; const void *next; XrFovf recommendedFov; XrFovf maxMutableFov; -}; +} XrViewConfigurationViewFovEPIC; -struct XrVirtualKeyboardLocationInfoMETA +typedef struct XrViewLocateFoveatedRenderingVARJO { XrStructureType type; const void *next; - XrVirtualKeyboardLocationTypeMETA locationType; - XrSpace space; - XrPosef poseInSpace; - float scale; -}; + XrBool32 foveatedRenderingActive; +} XrViewLocateFoveatedRenderingVARJO; -struct XrVirtualKeyboardTextureDataMETA +typedef struct XrViewLocateInfo +{ + XrStructureType type; + const void *next; + XrViewConfigurationType viewConfigurationType; + XrTime displayTime; + XrSpace space; +} XrViewLocateInfo; + +typedef struct XrViewState +{ + XrStructureType type; + void *next; + XrViewStateFlags WINE_XR_ALIGN(8) viewStateFlags; +} XrViewState; + +typedef struct XrVirtualKeyboardAnimationStateMETA +{ + XrStructureType type; + void *next; + int32_t animationIndex; + float fraction; +} XrVirtualKeyboardAnimationStateMETA; + +typedef struct XrVirtualKeyboardCreateInfoMETA +{ + XrStructureType type; + const void *next; +} XrVirtualKeyboardCreateInfoMETA; + +typedef struct XrVirtualKeyboardModelAnimationStatesMETA +{ + XrStructureType type; + void *next; + uint32_t stateCapacityInput; + uint32_t stateCountOutput; + XrVirtualKeyboardAnimationStateMETA *states; +} XrVirtualKeyboardModelAnimationStatesMETA; + +typedef struct XrVirtualKeyboardModelVisibilitySetInfoMETA +{ + XrStructureType type; + const void *next; + XrBool32 visible; +} XrVirtualKeyboardModelVisibilitySetInfoMETA; + +typedef struct XrVirtualKeyboardTextContextChangeInfoMETA +{ + XrStructureType type; + const void *next; + const char *textContext; +} XrVirtualKeyboardTextContextChangeInfoMETA; + +typedef struct XrVirtualKeyboardTextureDataMETA { XrStructureType type; void *next; @@ -5223,36 +4622,682 @@ struct XrVirtualKeyboardTextureDataMETA uint32_t bufferCapacityInput; uint32_t bufferCountOutput; uint8_t *buffer; -}; +} XrVirtualKeyboardTextureDataMETA; -struct XrVulkanGraphicsDeviceGetInfoKHR +typedef struct XrVisibilityMaskKHR +{ + XrStructureType type; + void *next; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrVector2f *vertices; + uint32_t indexCapacityInput; + uint32_t indexCountOutput; + uint32_t *indices; +} XrVisibilityMaskKHR; + +typedef struct XrVisualMeshComputeLodInfoMSFT +{ + XrStructureType type; + const void *next; + XrMeshComputeLodMSFT lod; +} XrVisualMeshComputeLodInfoMSFT; + +typedef struct XrViveTrackerPathsHTCX +{ + XrStructureType type; + void *next; + XrPath persistentPath; + XrPath rolePath; +} XrViveTrackerPathsHTCX; + +typedef struct XrVulkanDeviceCreateInfoKHR +{ + XrStructureType type; + const void *next; + XrSystemId systemId; + XrVulkanDeviceCreateFlagsKHR WINE_XR_ALIGN(8) createFlags; + PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr; + VkPhysicalDevice vulkanPhysicalDevice; + const VkDeviceCreateInfo *vulkanCreateInfo; + const VkAllocationCallbacks *vulkanAllocator; +} XrVulkanDeviceCreateInfoKHR; + +typedef struct XrVulkanGraphicsDeviceGetInfoKHR { XrStructureType type; const void *next; XrSystemId systemId; VkInstance vulkanInstance; -}; +} XrVulkanGraphicsDeviceGetInfoKHR; -struct XrActionSpaceCreateInfo +typedef struct XrVulkanInstanceCreateInfoKHR +{ + XrStructureType type; + const void *next; + XrSystemId systemId; + XrVulkanInstanceCreateFlagsKHR WINE_XR_ALIGN(8) createFlags; + PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr; + const VkInstanceCreateInfo *vulkanCreateInfo; + const VkAllocationCallbacks *vulkanAllocator; +} XrVulkanInstanceCreateInfoKHR; + +typedef struct XrVulkanSwapchainCreateInfoMETA +{ + XrStructureType type; + const void *next; + VkImageCreateFlags additionalCreateFlags; + VkImageUsageFlags additionalUsageFlags; +} XrVulkanSwapchainCreateInfoMETA; + +typedef struct XrVulkanSwapchainFormatListCreateInfoKHR +{ + XrStructureType type; + const void *next; + uint32_t viewFormatCount; + const VkFormat *viewFormats; +} XrVulkanSwapchainFormatListCreateInfoKHR; + +typedef struct XrActionStateVector2f +{ + XrStructureType type; + void *next; + XrVector2f currentState; + XrBool32 changedSinceLastSync; + XrTime lastChangeTime; + XrBool32 isActive; +} XrActionStateVector2f; + +typedef struct XrActionsSyncInfo +{ + XrStructureType type; + const void *next; + uint32_t countActiveActionSets; + const XrActiveActionSet *activeActionSets; +} XrActionsSyncInfo; + +typedef struct XrActiveActionSetPrioritiesEXT +{ + XrStructureType type; + const void *next; + uint32_t actionSetPriorityCount; + const XrActiveActionSetPriorityEXT *actionSetPriorities; +} XrActiveActionSetPrioritiesEXT; + +typedef struct XrApiLayerCreateInfo +{ + XrLoaderInterfaceStructs structType; + uint32_t structVersion; + size_t structSize; + void *loaderInstance; + char settings_file_location[XR_API_LAYER_MAX_SETTINGS_PATH_SIZE]; + XrApiLayerNextInfo *nextInfo; +} XrApiLayerCreateInfo; + +typedef struct XrBoundary2DFB +{ + XrStructureType type; + const void *next; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrVector2f *vertices; +} XrBoundary2DFB; + +typedef struct XrCompositionLayerCubeKHR +{ + XrStructureType type; + const void *next; + XrCompositionLayerFlags WINE_XR_ALIGN(8) layerFlags; + XrSpace space; + XrEyeVisibility eyeVisibility; + XrSwapchain swapchain; + uint32_t imageArrayIndex; + XrQuaternionf orientation; +} XrCompositionLayerCubeKHR; + +typedef struct XrCompositionLayerDepthInfoKHR +{ + XrStructureType type; + const void *next; + XrSwapchainSubImage subImage; + float minDepth; + float maxDepth; + float nearZ; + float farZ; +} XrCompositionLayerDepthInfoKHR; + +typedef struct XrCompositionLayerPassthroughHTC +{ + XrStructureType type; + const void *next; + XrCompositionLayerFlags WINE_XR_ALIGN(8) layerFlags; + XrSpace space; + XrPassthroughHTC passthrough; + XrPassthroughColorHTC color; +} XrCompositionLayerPassthroughHTC; + +typedef struct XrCompositionLayerReprojectionPlaneOverrideMSFT +{ + XrStructureType type; + const void *next; + XrVector3f position; + XrVector3f normal; + XrVector3f velocity; +} XrCompositionLayerReprojectionPlaneOverrideMSFT; + +typedef struct XrEventDataSpaceEraseCompleteFB +{ + XrStructureType type; + const void *next; + XrAsyncRequestIdFB requestId; + XrResult result; + XrSpace space; + XrUuidEXT uuid; + XrSpaceStorageLocationFB location; +} XrEventDataSpaceEraseCompleteFB; + +typedef struct XrEventDataSpaceSaveCompleteFB +{ + XrStructureType type; + const void *next; + XrAsyncRequestIdFB requestId; + XrResult result; + XrSpace space; + XrUuidEXT uuid; + XrSpaceStorageLocationFB location; +} XrEventDataSpaceSaveCompleteFB; + +typedef struct XrEventDataSpaceSetStatusCompleteFB +{ + XrStructureType type; + const void *next; + XrAsyncRequestIdFB requestId; + XrResult result; + XrSpace space; + XrUuidEXT uuid; + XrSpaceComponentTypeFB componentType; + XrBool32 enabled; +} XrEventDataSpaceSetStatusCompleteFB; + +typedef struct XrEventDataSpatialAnchorCreateCompleteFB +{ + XrStructureType type; + const void *next; + XrAsyncRequestIdFB requestId; + XrResult result; + XrSpace space; + XrUuidEXT uuid; +} XrEventDataSpatialAnchorCreateCompleteFB; + +typedef struct XrEventDataViveTrackerConnectedHTCX +{ + XrStructureType type; + const void *next; + XrViveTrackerPathsHTCX *paths; +} XrEventDataViveTrackerConnectedHTCX; + +typedef struct XrExternalCameraIntrinsicsOCULUS +{ + XrTime lastChangeTime; + XrFovf fov; + float virtualNearPlaneDistance; + float virtualFarPlaneDistance; + XrExtent2Di imageSensorPixelResolution; +} XrExternalCameraIntrinsicsOCULUS; + +typedef struct XrFoveationEyeTrackedStateMETA +{ + XrStructureType type; + void *next; + XrVector2f foveationCenter[XR_FOVEATION_CENTER_SIZE_META]; + XrFoveationEyeTrackedStateFlagsMETA WINE_XR_ALIGN(8) flags; +} XrFoveationEyeTrackedStateMETA; + +typedef struct XrHandCapsuleFB +{ + XrVector3f points[XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB]; + float radius; + XrHandJointEXT joint; +} XrHandCapsuleFB; + +typedef struct XrHandJointVelocityEXT +{ + XrSpaceVelocityFlags WINE_XR_ALIGN(8) velocityFlags; + XrVector3f linearVelocity; + XrVector3f angularVelocity; +} XrHandJointVelocityEXT; + +typedef struct XrHandMeshVertexMSFT +{ + XrVector3f position; + XrVector3f normal; +} XrHandMeshVertexMSFT; + +typedef struct XrHandTrackingCapsulesStateFB +{ + XrStructureType type; + void *next; + XrHandCapsuleFB capsules[XR_HAND_TRACKING_CAPSULE_COUNT_FB]; +} XrHandTrackingCapsulesStateFB; + +typedef struct XrKeyboardTrackingDescriptionFB +{ + uint64_t WINE_XR_ALIGN(8) trackedKeyboardId; + XrVector3f size; + XrKeyboardTrackingFlagsFB WINE_XR_ALIGN(8) flags; + char name[XR_MAX_KEYBOARD_TRACKING_NAME_SIZE_FB]; +} XrKeyboardTrackingDescriptionFB; + +typedef struct XrLocalizationMapML +{ + XrStructureType type; + void *next; + char name[XR_MAX_LOCALIZATION_MAP_NAME_LENGTH_ML]; + XrUuidEXT mapUuid; + XrLocalizationMapTypeML mapType; +} XrLocalizationMapML; + +typedef struct XrMapLocalizationRequestInfoML +{ + XrStructureType type; + const void *next; + XrUuidEXT mapUuid; +} XrMapLocalizationRequestInfoML; + +typedef struct XrPassthroughColorLutCreateInfoMETA +{ + XrStructureType type; + const void *next; + XrPassthroughColorLutChannelsMETA channels; + uint32_t resolution; + XrPassthroughColorLutDataMETA data; +} XrPassthroughColorLutCreateInfoMETA; + +typedef struct XrPlaneDetectorPolygonBufferEXT +{ + XrStructureType type; + void *next; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrVector2f *vertices; +} XrPlaneDetectorPolygonBufferEXT; + +typedef struct XrPosef +{ + XrQuaternionf orientation; + XrVector3f position; +} XrPosef; + +typedef struct XrReferenceSpaceCreateInfo +{ + XrStructureType type; + const void *next; + XrReferenceSpaceType referenceSpaceType; + XrPosef poseInReferenceSpace; +} XrReferenceSpaceCreateInfo; + +typedef struct XrRoomLayoutFB +{ + XrStructureType type; + const void *next; + XrUuidEXT floorUuid; + XrUuidEXT ceilingUuid; + uint32_t wallUuidCapacityInput; + uint32_t wallUuidCountOutput; + XrUuidEXT *wallUuids; +} XrRoomLayoutFB; + +typedef struct XrSceneComponentLocationMSFT +{ + XrSpaceLocationFlags WINE_XR_ALIGN(8) flags; + XrPosef pose; +} XrSceneComponentLocationMSFT; + +typedef struct XrSceneComponentLocationsMSFT +{ + XrStructureType type; + void *next; + uint32_t locationCount; + XrSceneComponentLocationMSFT *locations; +} XrSceneComponentLocationsMSFT; + +typedef struct XrSceneComponentMSFT +{ + XrSceneComponentTypeMSFT componentType; + XrUuidMSFT id; + XrUuidMSFT parentId; + XrTime updateTime; +} XrSceneComponentMSFT; + +typedef struct XrSceneComponentParentFilterInfoMSFT +{ + XrStructureType type; + const void *next; + XrUuidMSFT parentId; +} XrSceneComponentParentFilterInfoMSFT; + +typedef struct XrSceneComponentsLocateInfoMSFT +{ + XrStructureType type; + const void *next; + XrSpace baseSpace; + XrTime time; + uint32_t componentIdCount; + const XrUuidMSFT *componentIds; +} XrSceneComponentsLocateInfoMSFT; + +typedef struct XrSceneComponentsMSFT +{ + XrStructureType type; + void *next; + uint32_t componentCapacityInput; + uint32_t componentCountOutput; + XrSceneComponentMSFT *components; +} XrSceneComponentsMSFT; + +typedef struct XrSceneFrustumBoundMSFT +{ + XrPosef pose; + XrFovf fov; + float farDistance; +} XrSceneFrustumBoundMSFT; + +typedef struct XrSceneMeshVertexBufferMSFT +{ + XrStructureType type; + void *next; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrVector3f *vertices; +} XrSceneMeshVertexBufferMSFT; + +typedef struct XrSceneOrientedBoxBoundMSFT +{ + XrPosef pose; + XrVector3f extents; +} XrSceneOrientedBoxBoundMSFT; + +typedef struct XrSceneSphereBoundMSFT +{ + XrVector3f center; + float radius; +} XrSceneSphereBoundMSFT; + +typedef struct XrSecondaryViewConfigurationFrameEndInfoMSFT +{ + XrStructureType type; + const void *next; + uint32_t viewConfigurationCount; + const XrSecondaryViewConfigurationLayerInfoMSFT *viewConfigurationLayersInfo; +} XrSecondaryViewConfigurationFrameEndInfoMSFT; + +typedef struct XrSecondaryViewConfigurationFrameStateMSFT +{ + XrStructureType type; + void *next; + uint32_t viewConfigurationCount; + XrSecondaryViewConfigurationStateMSFT *viewConfigurationStates; +} XrSecondaryViewConfigurationFrameStateMSFT; + +typedef struct XrSerializedSceneFragmentDataGetInfoMSFT +{ + XrStructureType type; + const void *next; + XrUuidMSFT sceneFragmentId; +} XrSerializedSceneFragmentDataGetInfoMSFT; + +typedef struct XrSpaceContainerFB +{ + XrStructureType type; + const void *next; + uint32_t uuidCapacityInput; + uint32_t uuidCountOutput; + XrUuidEXT *uuids; +} XrSpaceContainerFB; + +typedef struct XrSpaceLocation +{ + XrStructureType type; + void *next; + XrSpaceLocationFlags WINE_XR_ALIGN(8) locationFlags; + XrPosef pose; +} XrSpaceLocation; + +typedef struct XrSpaceLocationData +{ + XrSpaceLocationFlags WINE_XR_ALIGN(8) locationFlags; + XrPosef pose; +} XrSpaceLocationData; +typedef XrSpaceLocationData XrSpaceLocationDataKHR; + +typedef struct XrSpaceLocations +{ + XrStructureType type; + void *next; + uint32_t locationCount; + XrSpaceLocationData *locations; +} XrSpaceLocations; +typedef XrSpaceLocations XrSpaceLocationsKHR; + +typedef struct XrSpaceQueryResultFB +{ + XrSpace space; + XrUuidEXT uuid; +} XrSpaceQueryResultFB; + +typedef struct XrSpaceQueryResultsFB +{ + XrStructureType type; + void *next; + uint32_t resultCapacityInput; + uint32_t resultCountOutput; + XrSpaceQueryResultFB *results; +} XrSpaceQueryResultsFB; + +typedef struct XrSpaceTriangleMeshMETA +{ + XrStructureType type; + void *next; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrVector3f *vertices; + uint32_t indexCapacityInput; + uint32_t indexCountOutput; + uint32_t *indices; +} XrSpaceTriangleMeshMETA; + +typedef struct XrSpaceUuidFilterInfoFB +{ + XrStructureType type; + const void *next; + uint32_t uuidCount; + XrUuidEXT *uuids; +} XrSpaceUuidFilterInfoFB; + +typedef struct XrSpaceVelocity +{ + XrStructureType type; + void *next; + XrSpaceVelocityFlags WINE_XR_ALIGN(8) velocityFlags; + XrVector3f linearVelocity; + XrVector3f angularVelocity; +} XrSpaceVelocity; + +typedef struct XrSpaceVelocityData +{ + XrSpaceVelocityFlags WINE_XR_ALIGN(8) velocityFlags; + XrVector3f linearVelocity; + XrVector3f angularVelocity; +} XrSpaceVelocityData; +typedef XrSpaceVelocityData XrSpaceVelocityDataKHR; + +typedef struct XrSpatialAnchorCreateInfoFB +{ + XrStructureType type; + const void *next; + XrSpace space; + XrPosef poseInSpace; + XrTime time; +} XrSpatialAnchorCreateInfoFB; + +typedef struct XrSpatialAnchorCreateInfoHTC +{ + XrStructureType type; + const void *next; + XrSpace space; + XrPosef poseInSpace; + XrSpatialAnchorNameHTC name; +} XrSpatialAnchorCreateInfoHTC; + +typedef struct XrSpatialAnchorCreateInfoMSFT +{ + XrStructureType type; + const void *next; + XrSpace space; + XrPosef pose; + XrTime time; +} XrSpatialAnchorCreateInfoMSFT; + +typedef struct XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT +{ + XrStructureType type; + const void *next; + XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore; + XrSpatialAnchorPersistenceNameMSFT spatialAnchorPersistenceName; +} XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT; + +typedef struct XrSpatialAnchorPersistenceInfoMSFT +{ + XrStructureType type; + const void *next; + XrSpatialAnchorPersistenceNameMSFT spatialAnchorPersistenceName; + XrSpatialAnchorMSFT spatialAnchor; +} XrSpatialAnchorPersistenceInfoMSFT; + +typedef struct XrSpatialAnchorSpaceCreateInfoMSFT +{ + XrStructureType type; + const void *next; + XrSpatialAnchorMSFT anchor; + XrPosef poseInAnchorSpace; +} XrSpatialAnchorSpaceCreateInfoMSFT; + +typedef struct XrSpatialGraphNodeBindingPropertiesMSFT +{ + XrStructureType type; + void *next; + uint8_t nodeId[XR_GUID_SIZE_MSFT]; + XrPosef poseInNodeSpace; +} XrSpatialGraphNodeBindingPropertiesMSFT; + +typedef struct XrSpatialGraphNodeSpaceCreateInfoMSFT +{ + XrStructureType type; + const void *next; + XrSpatialGraphNodeTypeMSFT nodeType; + uint8_t nodeId[XR_GUID_SIZE_MSFT]; + XrPosef pose; +} XrSpatialGraphNodeSpaceCreateInfoMSFT; + +typedef struct XrSpatialGraphStaticNodeBindingCreateInfoMSFT +{ + XrStructureType type; + const void *next; + XrSpace space; + XrPosef poseInSpace; + XrTime time; +} XrSpatialGraphStaticNodeBindingCreateInfoMSFT; + +typedef struct XrSpheref +{ + XrPosef center; + float radius; +} XrSpheref; +typedef XrSpheref XrSpherefKHR; + +typedef struct XrSystemHeadsetIdPropertiesMETA +{ + XrStructureType type; + void *next; + XrUuidEXT id; +} XrSystemHeadsetIdPropertiesMETA; + +typedef struct XrSystemProperties +{ + XrStructureType type; + void *next; + XrSystemId systemId; + uint32_t vendorId; + char systemName[XR_MAX_SYSTEM_NAME_SIZE]; + XrSystemGraphicsProperties graphicsProperties; + XrSystemTrackingProperties trackingProperties; +} XrSystemProperties; + +typedef struct XrTriangleMeshCreateInfoFB +{ + XrStructureType type; + const void *next; + XrTriangleMeshFlagsFB WINE_XR_ALIGN(8) flags; + XrWindingOrderFB windingOrder; + uint32_t vertexCount; + const XrVector3f *vertexBuffer; + uint32_t triangleCount; + const uint32_t *indexBuffer; +} XrTriangleMeshCreateInfoFB; + +typedef struct XrView +{ + XrStructureType type; + void *next; + XrPosef pose; + XrFovf fov; +} XrView; + +typedef struct XrVirtualKeyboardInputInfoMETA +{ + XrStructureType type; + const void *next; + XrVirtualKeyboardInputSourceMETA inputSource; + XrSpace inputSpace; + XrPosef inputPoseInSpace; + XrVirtualKeyboardInputStateFlagsMETA WINE_XR_ALIGN(8) inputState; +} XrVirtualKeyboardInputInfoMETA; + +typedef struct XrVirtualKeyboardLocationInfoMETA +{ + XrStructureType type; + const void *next; + XrVirtualKeyboardLocationTypeMETA locationType; + XrSpace space; + XrPosef poseInSpace; + float scale; +} XrVirtualKeyboardLocationInfoMETA; + +typedef struct XrVirtualKeyboardSpaceCreateInfoMETA +{ + XrStructureType type; + const void *next; + XrVirtualKeyboardLocationTypeMETA locationType; + XrSpace space; + XrPosef poseInSpace; +} XrVirtualKeyboardSpaceCreateInfoMETA; + +typedef struct XrActionSpaceCreateInfo { XrStructureType type; const void *next; XrAction action; XrPath subactionPath; XrPosef poseInActionSpace; -}; +} XrActionSpaceCreateInfo; -struct XrApiLayerProperties +typedef struct XrBodyJointLocationFB { - XrStructureType type; - void *next; - char layerName[XR_MAX_API_LAYER_NAME_SIZE]; - XrVersion specVersion; - uint32_t layerVersion; - char description[XR_MAX_API_LAYER_DESCRIPTION_SIZE]; -}; + XrSpaceLocationFlags WINE_XR_ALIGN(8) locationFlags; + XrPosef pose; +} XrBodyJointLocationFB; -struct XrBodyJointLocationsFB +typedef struct XrBodyJointLocationsFB { XrStructureType type; void *next; @@ -5262,37 +5307,125 @@ struct XrBodyJointLocationsFB XrBodyJointLocationFB *jointLocations; uint32_t skeletonChangedCount; XrTime time; -}; +} XrBodyJointLocationsFB; -struct XrBoundary2DFB +typedef struct XrBodySkeletonJointFB +{ + int32_t joint; + int32_t parentJoint; + XrPosef pose; +} XrBodySkeletonJointFB; + +typedef struct XrBoxf +{ + XrPosef center; + XrExtent3Df extents; +} XrBoxf; +typedef XrBoxf XrBoxfKHR; + +typedef struct XrCompositionLayerCylinderKHR { XrStructureType type; const void *next; - uint32_t vertexCapacityInput; - uint32_t vertexCountOutput; - XrVector2f *vertices; -}; + XrCompositionLayerFlags WINE_XR_ALIGN(8) layerFlags; + XrSpace space; + XrEyeVisibility eyeVisibility; + XrSwapchainSubImage subImage; + XrPosef pose; + float radius; + float centralAngle; + float aspectRatio; +} XrCompositionLayerCylinderKHR; -struct XrControllerModelStateMSFT +typedef struct XrCompositionLayerEquirect2KHR +{ + XrStructureType type; + const void *next; + XrCompositionLayerFlags WINE_XR_ALIGN(8) layerFlags; + XrSpace space; + XrEyeVisibility eyeVisibility; + XrSwapchainSubImage subImage; + XrPosef pose; + float radius; + float centralHorizontalAngle; + float upperVerticalAngle; + float lowerVerticalAngle; +} XrCompositionLayerEquirect2KHR; + +typedef struct XrCompositionLayerEquirectKHR +{ + XrStructureType type; + const void *next; + XrCompositionLayerFlags WINE_XR_ALIGN(8) layerFlags; + XrSpace space; + XrEyeVisibility eyeVisibility; + XrSwapchainSubImage subImage; + XrPosef pose; + float radius; + XrVector2f scale; + XrVector2f bias; +} XrCompositionLayerEquirectKHR; + +typedef struct XrCompositionLayerProjectionView +{ + XrStructureType type; + const void *next; + XrPosef pose; + XrFovf fov; + XrSwapchainSubImage subImage; +} XrCompositionLayerProjectionView; + +typedef struct XrCompositionLayerQuad +{ + XrStructureType type; + const void *next; + XrCompositionLayerFlags WINE_XR_ALIGN(8) layerFlags; + XrSpace space; + XrEyeVisibility eyeVisibility; + XrSwapchainSubImage subImage; + XrPosef pose; + XrExtent2Df size; +} XrCompositionLayerQuad; + +typedef struct XrCompositionLayerSpaceWarpInfoFB +{ + XrStructureType type; + const void *next; + XrCompositionLayerSpaceWarpInfoFlagsFB WINE_XR_ALIGN(8) layerFlags; + XrSwapchainSubImage motionVectorSubImage; + XrPosef appSpaceDeltaPose; + XrSwapchainSubImage depthSubImage; + float minDepth; + float maxDepth; + float nearZ; + float farZ; +} XrCompositionLayerSpaceWarpInfoFB; + +typedef struct XrControllerModelNodeStateMSFT +{ + XrStructureType type; + void *next; + XrPosef nodePose; +} XrControllerModelNodeStateMSFT; + +typedef struct XrControllerModelStateMSFT { XrStructureType type; void *next; uint32_t nodeCapacityInput; uint32_t nodeCountOutput; XrControllerModelNodeStateMSFT *nodeStates; -}; +} XrControllerModelStateMSFT; -struct XrEnvironmentDepthImageMETA +typedef struct XrEnvironmentDepthImageViewMETA { XrStructureType type; const void *next; - uint32_t swapchainIndex; - float nearZ; - float farZ; - XrEnvironmentDepthImageViewMETA views[2]; -}; + XrFovf fov; + XrPosef pose; +} XrEnvironmentDepthImageViewMETA; -struct XrEventDataLocalizationChangedML +typedef struct XrEventDataLocalizationChangedML { XrStructureType type; const void *next; @@ -5300,89 +5433,135 @@ struct XrEventDataLocalizationChangedML XrLocalizationMapStateML state; XrLocalizationMapML map; XrLocalizationMapConfidenceML confidence; - XrLocalizationMapErrorFlagsML errorFlags; -}; + XrLocalizationMapErrorFlagsML WINE_XR_ALIGN(8) errorFlags; +} XrEventDataLocalizationChangedML; -struct XrEventDataSpaceSaveCompleteFB +typedef struct XrEventDataReferenceSpaceChangePending { XrStructureType type; const void *next; - XrAsyncRequestIdFB requestId; - XrResult result; - XrSpace space; - XrUuidEXT uuid; - XrSpaceStorageLocationFB location; -}; + XrSession session; + XrReferenceSpaceType referenceSpaceType; + XrTime changeTime; + XrBool32 poseValid; + XrPosef poseInPreviousSpace; +} XrEventDataReferenceSpaceChangePending; -struct XrEventDataViveTrackerConnectedHTCX +typedef struct XrExternalCameraExtrinsicsOCULUS +{ + XrTime lastChangeTime; + XrExternalCameraStatusFlagsOCULUS WINE_XR_ALIGN(8) cameraStatusFlags; + XrExternalCameraAttachedToDeviceOCULUS attachedToDevice; + XrPosef relativePose; +} XrExternalCameraExtrinsicsOCULUS; + +typedef struct XrExternalCameraOCULUS { XrStructureType type; const void *next; - XrViveTrackerPathsHTCX *paths; -}; + char name[XR_MAX_EXTERNAL_CAMERA_NAME_SIZE_OCULUS]; + XrExternalCameraIntrinsicsOCULUS intrinsics; + XrExternalCameraExtrinsicsOCULUS WINE_XR_ALIGN(8) extrinsics; +} XrExternalCameraOCULUS; -struct XrEyeGazesFB +typedef struct XrEyeGazeFB +{ + XrBool32 isValid; + XrPosef gazePose; + float gazeConfidence; +} XrEyeGazeFB; + +typedef struct XrEyeGazesFB { XrStructureType type; void *next; XrEyeGazeFB gaze[XR_EYE_POSITION_COUNT_FB]; XrTime time; -}; +} XrEyeGazesFB; -struct XrForceFeedbackCurlApplyLocationsMNDX +typedef struct XrFrustumf +{ + XrPosef pose; + XrFovf fov; + float nearZ; + float farZ; +} XrFrustumf; +typedef XrFrustumf XrFrustumfKHR; + +typedef struct XrGeometryInstanceCreateInfoFB { XrStructureType type; const void *next; - uint32_t locationCount; - XrForceFeedbackCurlApplyLocationMNDX *locations; -}; + XrPassthroughLayerFB layer; + XrTriangleMeshFB mesh; + XrSpace baseSpace; + XrPosef pose; + XrVector3f scale; +} XrGeometryInstanceCreateInfoFB; -struct XrFoveationConfigurationHTC -{ - XrFoveationLevelHTC level; - float clearFovDegree; - XrVector2f focalCenterOffset; -}; - -struct XrFoveationEyeTrackedStateMETA -{ - XrStructureType type; - void *next; - XrVector2f foveationCenter[XR_FOVEATION_CENTER_SIZE_META]; - XrFoveationEyeTrackedStateFlagsMETA flags; -}; - -struct XrFutureCompletionEXT -{ - XrStructureType type; - void *next; - XrResult futureResult; -}; - -struct XrGraphicsRequirementsD3D11KHR -{ - XrStructureType type; - void *next; - LUID adapterLuid; - D3D_FEATURE_LEVEL minFeatureLevel; -}; - -struct XrHandJointsMotionRangeInfoEXT +typedef struct XrGeometryInstanceTransformFB { XrStructureType type; const void *next; - XrHandJointsMotionRangeEXT handJointsMotionRange; -}; + XrSpace baseSpace; + XrTime time; + XrPosef pose; + XrVector3f scale; +} XrGeometryInstanceTransformFB; -struct XrHandMeshVertexBufferMSFT +typedef struct XrHandJointLocationEXT +{ + XrSpaceLocationFlags WINE_XR_ALIGN(8) locationFlags; + XrPosef pose; + float radius; +} XrHandJointLocationEXT; + +typedef struct XrHandJointLocationsEXT +{ + XrStructureType type; + void *next; + XrBool32 isActive; + uint32_t jointCount; + XrHandJointLocationEXT *jointLocations; +} XrHandJointLocationsEXT; + +typedef struct XrHandJointVelocitiesEXT +{ + XrStructureType type; + void *next; + uint32_t jointCount; + XrHandJointVelocityEXT *jointVelocities; +} XrHandJointVelocitiesEXT; + +typedef struct XrHandMeshSpaceCreateInfoMSFT +{ + XrStructureType type; + const void *next; + XrHandPoseTypeMSFT handPoseType; + XrPosef poseInHandMeshSpace; +} XrHandMeshSpaceCreateInfoMSFT; + +typedef struct XrHandMeshVertexBufferMSFT { XrTime vertexUpdateTime; uint32_t vertexCapacityInput; uint32_t vertexCountOutput; XrHandMeshVertexMSFT *vertices; -}; +} XrHandMeshVertexBufferMSFT; -struct XrHandTrackingMeshFB +typedef struct XrHandTrackingAimStateFB +{ + XrStructureType type; + void *next; + XrHandTrackingAimFlagsFB WINE_XR_ALIGN(8) status; + XrPosef aimPose; + float pinchStrengthIndex; + float pinchStrengthMiddle; + float pinchStrengthRing; + float pinchStrengthLittle; +} XrHandTrackingAimStateFB; + +typedef struct XrHandTrackingMeshFB { XrStructureType type; void *next; @@ -5401,38 +5580,26 @@ struct XrHandTrackingMeshFB uint32_t indexCapacityInput; uint32_t indexCountOutput; int16_t *indices; -}; +} XrHandTrackingMeshFB; -struct XrInteractionProfileDpadBindingEXT +typedef struct XrMarkerSpaceCreateInfoML { XrStructureType type; const void *next; - XrPath binding; - XrActionSet actionSet; - float forceThreshold; - float forceThresholdReleased; - float centerRegion; - float wedgeAngle; - XrBool32 isSticky; - const XrHapticBaseHeader *onHaptic; - const XrHapticBaseHeader *offHaptic; -}; + XrMarkerDetectorML markerDetector; + XrMarkerML marker; + XrPosef poseInMarkerSpace; +} XrMarkerSpaceCreateInfoML; -struct XrMapLocalizationRequestInfoML +typedef struct XrMarkerSpaceCreateInfoVARJO { XrStructureType type; const void *next; - XrUuidEXT mapUuid; -}; + uint64_t WINE_XR_ALIGN(8) markerId; + XrPosef poseInMarkerSpace; +} XrMarkerSpaceCreateInfoVARJO; -struct XrPassthroughColorLutUpdateInfoMETA -{ - XrStructureType type; - const void *next; - XrPassthroughColorLutDataMETA data; -}; - -struct XrPassthroughMeshTransformInfoHTC +typedef struct XrPassthroughMeshTransformInfoHTC { XrStructureType type; const void *next; @@ -5444,475 +5611,47 @@ struct XrPassthroughMeshTransformInfoHTC XrTime time; XrPosef pose; XrVector3f scale; -}; +} XrPassthroughMeshTransformInfoHTC; -struct XrPlaneDetectorLocationEXT -{ - XrStructureType type; - void *next; - uint64_t WINE_XR_ALIGN(8) planeId; - XrSpaceLocationFlags locationFlags; - XrPosef pose; - XrExtent2Df extents; - XrPlaneDetectorOrientationEXT orientation; - XrPlaneDetectorSemanticTypeEXT semanticType; - uint32_t polygonBufferCount; -}; - -struct XrPlaneDetectorPolygonBufferEXT -{ - XrStructureType type; - void *next; - uint32_t vertexCapacityInput; - uint32_t vertexCountOutput; - XrVector2f *vertices; -}; - -struct XrRoomLayoutFB -{ - XrStructureType type; - const void *next; - XrUuidEXT floorUuid; - XrUuidEXT ceilingUuid; - uint32_t wallUuidCapacityInput; - uint32_t wallUuidCountOutput; - XrUuidEXT *wallUuids; -}; - -struct XrSceneComponentParentFilterInfoMSFT -{ - XrStructureType type; - const void *next; - XrUuidMSFT parentId; -}; - -struct XrSceneMeshBuffersMSFT -{ - XrStructureType type; - void *next; -}; - -struct XrScenePlanesMSFT -{ - XrStructureType type; - void *next; - uint32_t scenePlaneCount; - XrScenePlaneMSFT *scenePlanes; -}; - -struct XrSerializedSceneFragmentDataGetInfoMSFT -{ - XrStructureType type; - const void *next; - XrUuidMSFT sceneFragmentId; -}; - -struct XrSpaceLocations -{ - XrStructureType type; - void *next; - uint32_t locationCount; - XrSpaceLocationData *locations; -}; - -struct XrSpaceUuidFilterInfoFB -{ - XrStructureType type; - const void *next; - uint32_t uuidCount; - XrUuidEXT *uuids; -}; - -struct XrSpatialAnchorCreateInfoFB -{ - XrStructureType type; - const void *next; - XrSpace space; - XrPosef poseInSpace; - XrTime time; -}; - -struct XrSpatialGraphStaticNodeBindingCreateInfoMSFT -{ - XrStructureType type; - const void *next; - XrSpace space; - XrPosef poseInSpace; - XrTime time; -}; - -struct XrSwapchainImageWaitInfo -{ - XrStructureType type; - const void *next; - XrDuration timeout; -}; - -struct XrSystemFaceTrackingPropertiesFB -{ - XrStructureType type; - void *next; - XrBool32 supportsFaceTracking; -}; - -struct XrSystemPassthroughColorLutPropertiesMETA -{ - XrStructureType type; - const void *next; - uint32_t maxColorLutResolution; -}; - -struct XrTriangleMeshCreateInfoFB -{ - XrStructureType type; - const void *next; - XrTriangleMeshFlagsFB flags; - XrWindingOrderFB windingOrder; - uint32_t vertexCount; - const XrVector3f *vertexBuffer; - uint32_t triangleCount; - const uint32_t *indexBuffer; -}; - -struct XrVirtualKeyboardAnimationStateMETA -{ - XrStructureType type; - void *next; - int32_t animationIndex; - float fraction; -}; - -struct XrVisibilityMaskKHR -{ - XrStructureType type; - void *next; - uint32_t vertexCapacityInput; - uint32_t vertexCountOutput; - XrVector2f *vertices; - uint32_t indexCapacityInput; - uint32_t indexCountOutput; - uint32_t *indices; -}; - -struct XrActionStateVector2f -{ - XrStructureType type; - void *next; - XrVector2f currentState; - XrBool32 changedSinceLastSync; - XrTime lastChangeTime; - XrBool32 isActive; -}; - -struct XrBodySkeletonFB -{ - XrStructureType type; - void *next; - uint32_t jointCount; - XrBodySkeletonJointFB *joints; -}; - -struct XrEventDataReferenceSpaceChangePending -{ - XrStructureType type; - const void *next; - XrSession session; - XrReferenceSpaceType referenceSpaceType; - XrTime changeTime; - XrBool32 poseValid; - XrPosef poseInPreviousSpace; -}; - -struct XrExternalCameraExtrinsicsOCULUS -{ - XrTime lastChangeTime; - XrExternalCameraStatusFlagsOCULUS cameraStatusFlags; - XrExternalCameraAttachedToDeviceOCULUS attachedToDevice; - XrPosef relativePose; -}; - -struct XrFaceTrackerCreateInfo2FB -{ - XrStructureType type; - const void *next; - XrFaceExpressionSet2FB faceExpressionSet; - uint32_t requestedDataSourceCount; - XrFaceTrackingDataSource2FB *requestedDataSources; -}; - -struct XrFoveationCustomModeInfoHTC -{ - XrStructureType type; - const void *next; - uint32_t configCount; - const XrFoveationConfigurationHTC *configs; -}; - -struct XrGeometryInstanceTransformFB +typedef struct XrPlaneDetectorBeginInfoEXT { XrStructureType type; const void *next; XrSpace baseSpace; XrTime time; - XrPosef pose; - XrVector3f scale; -}; + uint32_t orientationCount; + const XrPlaneDetectorOrientationEXT *orientations; + uint32_t semanticTypeCount; + const XrPlaneDetectorSemanticTypeEXT *semanticTypes; + uint32_t maxPlanes; + float minArea; + XrPosef boundingBoxPose; + XrExtent3DfEXT boundingBoxExtent; +} XrPlaneDetectorBeginInfoEXT; -struct XrHandMeshMSFT +typedef struct XrPlaneDetectorLocationEXT { XrStructureType type; void *next; - XrBool32 isActive; - XrBool32 indexBufferChanged; - XrBool32 vertexBufferChanged; - XrHandMeshIndexBufferMSFT indexBuffer; - XrHandMeshVertexBufferMSFT vertexBuffer; -}; + uint64_t WINE_XR_ALIGN(8) planeId; + XrSpaceLocationFlags WINE_XR_ALIGN(8) locationFlags; + XrPosef pose; + XrExtent2Df extents; + XrPlaneDetectorOrientationEXT orientation; + XrPlaneDetectorSemanticTypeEXT semanticType; + uint32_t polygonBufferCount; +} XrPlaneDetectorLocationEXT; -struct XrInputSourceLocalizedNameGetInfo -{ - XrStructureType type; - const void *next; - XrPath sourcePath; - XrInputSourceLocalizedNameFlags whichComponents; -}; - -struct XrMarkerSpaceCreateInfoML -{ - XrStructureType type; - const void *next; - XrMarkerDetectorML markerDetector; - XrMarkerML marker; - XrPosef poseInMarkerSpace; -}; - -struct XrPlaneDetectorLocationsEXT +typedef struct XrPlaneDetectorLocationsEXT { XrStructureType type; void *next; uint32_t planeLocationCapacityInput; uint32_t planeLocationCountOutput; XrPlaneDetectorLocationEXT *planeLocations; -}; +} XrPlaneDetectorLocationsEXT; -struct XrSceneFrustumBoundMSFT -{ - XrPosef pose; - XrFovf fov; - float farDistance; -}; - -struct XrSecondaryViewConfigurationFrameStateMSFT -{ - XrStructureType type; - void *next; - uint32_t viewConfigurationCount; - XrSecondaryViewConfigurationStateMSFT *viewConfigurationStates; -}; - -struct XrSpaceQueryResultFB -{ - XrSpace space; - XrUuidEXT uuid; -}; - -struct XrSpaceVelocities -{ - XrStructureType type; - void *next; - uint32_t velocityCount; - XrSpaceVelocityData *velocities; -}; - -struct XrSwapchainImageD3D11KHR -{ - XrStructureType type; - void *next; - ID3D11Texture2D *texture; -}; - -struct XrSystemHandTrackingPropertiesEXT -{ - XrStructureType type; - void *next; - XrBool32 supportsHandTracking; -}; - -struct XrView -{ - XrStructureType type; - void *next; - XrPosef pose; - XrFovf fov; -}; - -struct XrBindingModificationsKHR -{ - XrStructureType type; - const void *next; - uint32_t bindingModificationCount; - const XrBindingModificationBaseHeaderKHR * const*bindingModifications; -}; - -struct XrEventDataBaseHeader -{ - XrStructureType type; - const void *next; -}; - -struct XrExternalCameraOCULUS -{ - XrStructureType type; - const void *next; - char name[XR_MAX_EXTERNAL_CAMERA_NAME_SIZE_OCULUS]; - XrExternalCameraIntrinsicsOCULUS intrinsics; - XrExternalCameraExtrinsicsOCULUS extrinsics; -}; - -struct XrFrameState -{ - XrStructureType type; - void *next; - XrTime predictedDisplayTime; - XrDuration predictedDisplayPeriod; - XrBool32 shouldRender; -}; - -struct XrHandTrackingAimStateFB -{ - XrStructureType type; - void *next; - XrHandTrackingAimFlagsFB status; - XrPosef aimPose; - float pinchStrengthIndex; - float pinchStrengthMiddle; - float pinchStrengthRing; - float pinchStrengthLittle; -}; - -struct XrRect2Di -{ - XrOffset2Di offset; - XrExtent2Di extent; -}; - -struct XrSceneObjectsMSFT -{ - XrStructureType type; - void *next; - uint32_t sceneObjectCount; - XrSceneObjectMSFT *sceneObjects; -}; - -struct XrSpaceQueryResultsFB -{ - XrStructureType type; - void *next; - uint32_t resultCapacityInput; - uint32_t resultCountOutput; - XrSpaceQueryResultFB *results; -}; - -struct XrSwapchainSubImage -{ - XrSwapchain swapchain; - XrRect2Di imageRect; - uint32_t imageArrayIndex; -}; - -struct XrVirtualKeyboardModelAnimationStatesMETA -{ - XrStructureType type; - void *next; - uint32_t stateCapacityInput; - uint32_t stateCountOutput; - XrVirtualKeyboardAnimationStateMETA *states; -}; - -struct XrColor4f -{ - float r; - float g; - float b; - float a; -}; - -struct XrCompositionLayerCylinderKHR -{ - XrStructureType type; - const void *next; - XrCompositionLayerFlags layerFlags; - XrSpace space; - XrEyeVisibility eyeVisibility; - XrSwapchainSubImage subImage; - XrPosef pose; - float radius; - float centralAngle; - float aspectRatio; -}; - -struct XrCompositionLayerEquirect2KHR -{ - XrStructureType type; - const void *next; - XrCompositionLayerFlags layerFlags; - XrSpace space; - XrEyeVisibility eyeVisibility; - XrSwapchainSubImage subImage; - XrPosef pose; - float radius; - float centralHorizontalAngle; - float upperVerticalAngle; - float lowerVerticalAngle; -}; - -struct XrCompositionLayerProjectionView -{ - XrStructureType type; - const void *next; - XrPosef pose; - XrFovf fov; - XrSwapchainSubImage subImage; -}; - -struct XrCompositionLayerSpaceWarpInfoFB -{ - XrStructureType type; - const void *next; - XrCompositionLayerSpaceWarpInfoFlagsFB layerFlags; - XrSwapchainSubImage motionVectorSubImage; - XrPosef appSpaceDeltaPose; - XrSwapchainSubImage depthSubImage; - float minDepth; - float maxDepth; - float nearZ; - float farZ; -}; - -struct XrFoveationApplyInfoHTC -{ - XrStructureType type; - const void *next; - XrFoveationModeHTC mode; - uint32_t subImageCount; - XrSwapchainSubImage *subImages; -}; - -struct XrLocalDimmingFrameEndInfoMETA -{ - XrStructureType type; - const void *next; - XrLocalDimmingModeMETA localDimmingMode; -}; - -struct XrPassthroughColorMapMonoToRgbaFB -{ - XrStructureType type; - const void *next; - XrColor4f textureColorMap[XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB]; -}; - -struct XrSceneBoundsMSFT +typedef struct XrSceneBoundsMSFT { XrSpace space; XrTime time; @@ -5922,69 +5661,57 @@ struct XrSceneBoundsMSFT const XrSceneOrientedBoxBoundMSFT *boxes; uint32_t frustumCount; const XrSceneFrustumBoundMSFT *frustums; -}; +} XrSceneBoundsMSFT; -struct XrSpatialAnchorPersistenceInfoMSFT -{ - XrStructureType type; - const void *next; - XrSpatialAnchorPersistenceNameMSFT spatialAnchorPersistenceName; - XrSpatialAnchorMSFT spatialAnchor; -}; - -struct XrSystemProperties +typedef struct XrSpaceVelocities { XrStructureType type; void *next; - XrSystemId systemId; - uint32_t vendorId; - char systemName[XR_MAX_SYSTEM_NAME_SIZE]; - XrSystemGraphicsProperties graphicsProperties; - XrSystemTrackingProperties trackingProperties; -}; + uint32_t velocityCount; + XrSpaceVelocityData *velocities; +} XrSpaceVelocities; +typedef XrSpaceVelocities XrSpaceVelocitiesKHR; -struct XrCompositionLayerColorScaleBiasKHR +typedef struct XrBodySkeletonFB +{ + XrStructureType type; + void *next; + uint32_t jointCount; + XrBodySkeletonJointFB *joints; +} XrBodySkeletonFB; + +typedef struct XrCompositionLayerProjection { XrStructureType type; const void *next; - XrColor4f colorScale; - XrColor4f colorBias; -}; - -struct XrCompositionLayerEquirectKHR -{ - XrStructureType type; - const void *next; - XrCompositionLayerFlags layerFlags; + XrCompositionLayerFlags WINE_XR_ALIGN(8) layerFlags; XrSpace space; - XrEyeVisibility eyeVisibility; - XrSwapchainSubImage subImage; - XrPosef pose; - float radius; - XrVector2f scale; - XrVector2f bias; -}; + uint32_t viewCount; + const XrCompositionLayerProjectionView *views; +} XrCompositionLayerProjection; -struct XrCompositionLayerQuad +typedef struct XrEnvironmentDepthImageMETA { XrStructureType type; const void *next; - XrCompositionLayerFlags layerFlags; - XrSpace space; - XrEyeVisibility eyeVisibility; - XrSwapchainSubImage subImage; - XrPosef pose; - XrExtent2Df size; -}; + uint32_t swapchainIndex; + float nearZ; + float farZ; + XrEnvironmentDepthImageViewMETA views[2]; +} XrEnvironmentDepthImageMETA; -struct XrHandJointLocationEXT +typedef struct XrHandMeshMSFT { - XrSpaceLocationFlags locationFlags; - XrPosef pose; - float radius; -}; + XrStructureType type; + void *next; + XrBool32 isActive; + XrBool32 indexBufferChanged; + XrBool32 vertexBufferChanged; + XrHandMeshIndexBufferMSFT indexBuffer; + XrHandMeshVertexBufferMSFT vertexBuffer; +} XrHandMeshMSFT; -struct XrNewSceneComputeInfoMSFT +typedef struct XrNewSceneComputeInfoMSFT { XrStructureType type; const void *next; @@ -5992,86 +5719,11 @@ struct XrNewSceneComputeInfoMSFT const XrSceneComputeFeatureMSFT *requestedFeatures; XrSceneComputeConsistencyMSFT consistency; XrSceneBoundsMSFT bounds; -}; - -struct XrSpaceContainerFB -{ - XrStructureType type; - const void *next; - uint32_t uuidCapacityInput; - uint32_t uuidCountOutput; - XrUuidEXT *uuids; -}; - -struct XrCompositionLayerDepthInfoKHR -{ - XrStructureType type; - const void *next; - XrSwapchainSubImage subImage; - float minDepth; - float maxDepth; - float nearZ; - float farZ; -}; - -struct XrEventDataSpatialAnchorCreateCompleteFB -{ - XrStructureType type; - const void *next; - XrAsyncRequestIdFB requestId; - XrResult result; - XrSpace space; - XrUuidEXT uuid; -}; - -struct XrPassthroughStyleFB -{ - XrStructureType type; - const void *next; - float textureOpacityFactor; - XrColor4f edgeColor; -}; - -struct XrCompositionLayerProjection -{ - XrStructureType type; - const void *next; - XrCompositionLayerFlags layerFlags; - XrSpace space; - uint32_t viewCount; - const XrCompositionLayerProjectionView *views; -}; - -struct XrSwapchainStateSamplerVulkanFB -{ - XrStructureType type; - void *next; - VkFilter minFilter; - VkFilter magFilter; - VkSamplerMipmapMode mipmapMode; - VkSamplerAddressMode wrapModeS; - VkSamplerAddressMode wrapModeT; - VkComponentSwizzle swizzleRed; - VkComponentSwizzle swizzleGreen; - VkComponentSwizzle swizzleBlue; - VkComponentSwizzle swizzleAlpha; - float maxAnisotropy; - XrColor4f borderColor; -}; - -struct XrHandJointLocationsEXT -{ - XrStructureType type; - void *next; - XrBool32 isActive; - uint32_t jointCount; - XrHandJointLocationEXT *jointLocations; -}; +} XrNewSceneComputeInfoMSFT; typedef XrResult (XRAPI_PTR *PFN_xrAcquireEnvironmentDepthImageMETA)(XrEnvironmentDepthProviderMETA, const XrEnvironmentDepthImageAcquireInfoMETA *, XrEnvironmentDepthImageMETA *); typedef XrResult (XRAPI_PTR *PFN_xrAcquireSwapchainImage)(XrSwapchain, const XrSwapchainImageAcquireInfo *, uint32_t *); typedef XrResult (XRAPI_PTR *PFN_xrApplyForceFeedbackCurlMNDX)(XrHandTrackerEXT, const XrForceFeedbackCurlApplyLocationsMNDX *); -typedef XrResult (XRAPI_PTR *PFN_xrApplyFoveationHTC)(XrSession, const XrFoveationApplyInfoHTC *); typedef XrResult (XRAPI_PTR *PFN_xrApplyHapticFeedback)(XrSession, const XrHapticActionInfo *, const XrHapticBaseHeader *); typedef XrResult (XRAPI_PTR *PFN_xrAttachSessionActionSets)(XrSession, const XrSessionActionSetsAttachInfo *); typedef XrResult (XRAPI_PTR *PFN_xrBeginFrame)(XrSession, const XrFrameBeginInfo *); @@ -6343,7 +5995,6 @@ typedef XrResult (XRAPI_PTR *PFN_xrWaitSwapchainImage)(XrSwapchain, const XrSwap XrResult XRAPI_CALL xrAcquireEnvironmentDepthImageMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider, const XrEnvironmentDepthImageAcquireInfoMETA *acquireInfo, XrEnvironmentDepthImageMETA *environmentDepthImage); XrResult XRAPI_CALL xrAcquireSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageAcquireInfo *acquireInfo, uint32_t *index); XrResult XRAPI_CALL xrApplyForceFeedbackCurlMNDX(XrHandTrackerEXT handTracker, const XrForceFeedbackCurlApplyLocationsMNDX *locations); -XrResult XRAPI_CALL xrApplyFoveationHTC(XrSession session, const XrFoveationApplyInfoHTC *applyInfo); XrResult XRAPI_CALL xrApplyHapticFeedback(XrSession session, const XrHapticActionInfo *hapticActionInfo, const XrHapticBaseHeader *hapticFeedback); XrResult XRAPI_CALL xrAttachSessionActionSets(XrSession session, const XrSessionActionSetsAttachInfo *attachInfo); XrResult XRAPI_CALL xrBeginFrame(XrSession session, const XrFrameBeginInfo *frameBeginInfo); diff --git a/wineopenxr/wineopenxr.json b/wineopenxr/wineopenxr.json new file mode 100644 index 00000000..df5e15fe --- /dev/null +++ b/wineopenxr/wineopenxr.json @@ -0,0 +1,7 @@ +{ + "file_format_version": "1.0.0", + "ICD": { + "library_path": ".\\wineopenxr.dll", + "api_version": "1.1.36" + } +} diff --git a/wineopenxr/wineopenxr.spec b/wineopenxr/wineopenxr.spec index 407002a9..4c522146 100644 --- a/wineopenxr/wineopenxr.spec +++ b/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) diff --git a/wineopenxr/xr.xml b/wineopenxr/xr.xml deleted file mode 100644 index c552f0b5..00000000 --- a/wineopenxr/xr.xml +++ /dev/null @@ -1,15219 +0,0 @@ - - - - - - -Copyright (c) 2017-2024, 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 default branch of the Khronos OpenXR GitHub project. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #include "openxr_platform_defines.h" - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #define XR_MAKE_VERSION(major, minor, patch) \ - ((((major) & 0xffffULL) << 48) | (((minor) & 0xffffULL) << 32) | ((patch) & 0xffffffffULL)) - #define XR_VERSION_MAJOR(version) (uint16_t)(((uint64_t)(version) >> 48)& 0xffffULL) - #define XR_VERSION_MINOR(version) (uint16_t)(((uint64_t)(version) >> 32) & 0xffffULL) - #define XR_VERSION_PATCH(version) (uint32_t)((uint64_t)(version) & 0xffffffffULL) - - - // OpenXR current version number. -#define XR_CURRENT_API_VERSION XR_MAKE_VERSION(1, 1, 36) - - - -#if !defined(XR_MAY_ALIAS) -#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4)) -#define XR_MAY_ALIAS __attribute__((__may_alias__)) -#else -#define XR_MAY_ALIAS -#endif -#endif - - -#if !defined(XR_DEFINE_HANDLE) -#if (XR_PTR_SIZE == 8) - #define XR_DEFINE_HANDLE(object) typedef struct object##_T* object; -#else - #define XR_DEFINE_HANDLE(object) typedef uint64_t object; -#endif -#endif - - -#if !defined(XR_NULL_HANDLE) -#if (XR_PTR_SIZE == 8) && XR_CPP_NULLPTR_SUPPORTED - #define XR_NULL_HANDLE nullptr -#else - #define XR_NULL_HANDLE 0 -#endif -#endif - - -#if !defined(XR_DEFINE_ATOM) - #define XR_DEFINE_ATOM(object) typedef uint64_t object; -#endif - - -#if !defined(XR_DEFINE_OPAQUE_64) - #if (XR_PTR_SIZE == 8) - #define XR_DEFINE_OPAQUE_64(object) typedef struct object##_T* object; - #else - #define XR_DEFINE_OPAQUE_64(object) typedef uint64_t object; - #endif -#endif - - -#define XR_EXTENSION_ENUM_BASE 1000000000 - - -#define XR_EXTENSION_ENUM_STRIDE 1000 - - -#define XR_NULL_PATH 0 - - -#define XR_NULL_SYSTEM_ID 0 - - -#define XR_SUCCEEDED(result) ((result) >= 0) - - -#define XR_UNQUALIFIED_SUCCESS(result) ((result) == 0) - - -#define XR_FAILED(result) ((result) < 0) - - -#define XR_NO_DURATION 0 - - -#define XR_INFINITE_DURATION 0x7fffffffffffffffLL - - -#define XR_MIN_HAPTIC_DURATION -1 - - -#define XR_FREQUENCY_UNSPECIFIED 0 - - -#define XR_MAX_EVENT_DATA_SIZE sizeof(XrEventDataBuffer) - - -#define XR_MIN_COMPOSITION_LAYERS_SUPPORTED 16 - - - -#define XR_CURRENT_LOADER_API_LAYER_VERSION 1 - -#define XR_CURRENT_LOADER_RUNTIME_VERSION 1 - -#define XR_LOADER_INFO_STRUCT_VERSION 1 - -#define XR_API_LAYER_INFO_STRUCT_VERSION 1 - -#define XR_RUNTIME_INFO_STRUCT_VERSION 1 - -#define XR_API_LAYER_NEXT_INFO_STRUCT_VERSION 1 - -#define XR_API_LAYER_CREATE_INFO_STRUCT_VERSION 1 - -#define XR_API_LAYER_MAX_SETTINGS_PATH_SIZE 512 - - - -#define XR_HAND_JOINT_COUNT_EXT 26 - - - -#define XR_NULL_CONTROLLER_MODEL_KEY_MSFT 0 - - - -#define XR_NULL_RENDER_MODEL_KEY_FB 0 - - - -#define XR_FACIAL_EXPRESSION_EYE_COUNT_HTC 14 - -#define XR_FACIAL_EXPRESSION_LIP_COUNT_HTC 37 - - - -#define XR_HAND_FOREARM_JOINT_COUNT_ULTRALEAP 27 - - - -#define XR_FACE_EXPRESSSION_SET_DEFAULT_FB XR_FACE_EXPRESSION_SET_DEFAULT_FB - - - -#define XR_MAX_HAPTIC_AMPLITUDE_ENVELOPE_SAMPLES_FB 4000u - - - -#define XR_MAX_HAPTIC_PCM_BUFFER_SIZE_FB 4000 - - - typedef uint32_t XrBool32; - typedef uint64_t XrFlags64; - typedef int64_t XrTime; - typedef int64_t XrDuration; - typedef uint64_t XrVersion; - - - typedef uint64_t XrSpaceUserIdFB; - - - XR_DEFINE_ATOM(XrPath) - XR_DEFINE_ATOM(XrSystemId) - - XR_DEFINE_ATOM(XrControllerModelKeyMSFT) - - XR_DEFINE_ATOM(XrAsyncRequestIdFB) - - XR_DEFINE_ATOM(XrRenderModelKeyFB) - - XR_DEFINE_ATOM(XrMarkerML) - - - - - - - - - - - - - - - - - - - - - - typedef XrFlags64 XrInstanceCreateFlags; - typedef XrFlags64 XrSessionCreateFlags; - typedef XrFlags64 XrSwapchainCreateFlags; - typedef XrFlags64 XrSwapchainUsageFlags; - typedef XrFlags64 XrViewStateFlags; - typedef XrFlags64 XrCompositionLayerFlags; - typedef XrFlags64 XrSpaceLocationFlags; - typedef XrFlags64 XrSpaceVelocityFlags; - typedef XrFlags64 XrInputSourceLocalizedNameFlags; - - - typedef XrFlags64 XrVulkanInstanceCreateFlagsKHR; - typedef XrFlags64 XrVulkanDeviceCreateFlagsKHR; - - - typedef XrFlags64 XrDebugUtilsMessageSeverityFlagsEXT; - typedef XrFlags64 XrDebugUtilsMessageTypeFlagsEXT; - - - typedef XrFlags64 XrOverlayMainSessionFlagsEXTX; - typedef XrFlags64 XrOverlaySessionCreateFlagsEXTX; - - - typedef XrFlags64 XrAndroidSurfaceSwapchainFlagsFB; - - - typedef XrFlags64 XrCompositionLayerImageLayoutFlagsFB; - - - typedef XrFlags64 XrCompositionLayerSecureContentFlagsFB; - - - typedef XrFlags64 XrSwapchainCreateFoveationFlagsFB; - typedef XrFlags64 XrSwapchainStateFoveationFlagsFB; - - - typedef XrFlags64 XrFoveationEyeTrackedProfileCreateFlagsMETA; - typedef XrFlags64 XrFoveationEyeTrackedStateFlagsMETA; - - - typedef XrFlags64 XrTriangleMeshFlagsFB; - - - typedef XrFlags64 XrPassthroughFlagsFB; - typedef XrFlags64 XrPassthroughStateChangedFlagsFB; - typedef XrFlags64 XrPassthroughCapabilityFlagsFB; - - - typedef XrFlags64 XrSemanticLabelsSupportFlagsFB; - - - typedef XrFlags64 XrHandTrackingAimFlagsFB; - - - typedef XrFlags64 XrKeyboardTrackingFlagsFB; - typedef XrFlags64 XrKeyboardTrackingQueryFlagsFB; - - - typedef XrFlags64 XrCompositionLayerSpaceWarpInfoFlagsFB; - - - typedef XrFlags64 XrRenderModelFlagsFB; - - - typedef XrFlags64 XrDigitalLensControlFlagsALMALENCE; - - - typedef XrFlags64 XrCompositionLayerSettingsFlagsFB; - - - typedef XrFlags64 XrExternalCameraStatusFlagsOCULUS; - - - typedef XrFlags64 XrPerformanceMetricsCounterFlagsMETA; - - - typedef XrFlags64 XrPassthroughPreferenceFlagsMETA; - - - typedef XrFlags64 XrFoveationDynamicFlagsHTC; - - - typedef XrFlags64 XrFrameEndInfoFlagsML; - - - typedef XrFlags64 XrGlobalDimmerFrameEndInfoFlagsML; - - - typedef XrFlags64 XrPlaneDetectorFlagsEXT; - typedef XrFlags64 XrPlaneDetectionCapabilityFlagsEXT; - - - typedef XrFlags64 XrVirtualKeyboardInputStateFlagsMETA; - - - typedef XrFlags64 XrLocalizationMapErrorFlagsML; - - - typedef XrFlags64 XrEnvironmentDepthProviderCreateFlagsMETA; - typedef XrFlags64 XrEnvironmentDepthSwapchainCreateFlagsMETA; - - - - XR_DEFINE_HANDLE(XrInstance) - XR_DEFINE_HANDLE(XrSession) - XR_DEFINE_HANDLE(XrActionSet) - XR_DEFINE_HANDLE(XrAction) - XR_DEFINE_HANDLE(XrSwapchain) - XR_DEFINE_HANDLE(XrSpace) - XR_DEFINE_HANDLE(XrDebugUtilsMessengerEXT) - XR_DEFINE_HANDLE(XrSpatialAnchorMSFT) - - - XR_DEFINE_HANDLE(XrHandTrackerEXT) - - - XR_DEFINE_HANDLE(XrFoveationProfileFB) - - - XR_DEFINE_HANDLE(XrTriangleMeshFB) - - - XR_DEFINE_HANDLE(XrPassthroughFB) - XR_DEFINE_HANDLE(XrPassthroughLayerFB) - XR_DEFINE_HANDLE(XrGeometryInstanceFB) - - - XR_DEFINE_HANDLE(XrFacialTrackerHTC) - - - XR_DEFINE_HANDLE(XrPassthroughHTC) - - - XR_DEFINE_HANDLE(XrFaceTrackerFB) - - - XR_DEFINE_HANDLE(XrFaceTracker2FB) - - - XR_DEFINE_HANDLE(XrBodyTrackerFB) - - - XR_DEFINE_HANDLE(XrEyeTrackerFB) - - - XR_DEFINE_HANDLE(XrSpaceUserFB) - - - XR_DEFINE_HANDLE(XrPassthroughColorLutMETA) - - - XR_DEFINE_HANDLE(XrPlaneDetectorEXT) - - - XR_DEFINE_HANDLE(XrVirtualKeyboardMETA) - - - XR_DEFINE_HANDLE(XrExportedLocalizationMapML) - - - XR_DEFINE_HANDLE(XrMarkerDetectorML) - - - XR_DEFINE_OPAQUE_64(XrFutureEXT) - - - XR_DEFINE_HANDLE(XrEnvironmentDepthProviderMETA) - XR_DEFINE_HANDLE(XrEnvironmentDepthSwapchainMETA) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - float x - float y - - - float x - float y - float z - - - float x - float y - float z - float w - - - float r - float g - float b - float a - - - float x - float y - float z - float w - - - XrQuaternionf orientation - XrVector3f position - - - float x - float y - - - float width - float height - - - - - - XrOffset2Df offset - XrExtent2Df extent - - - int32_t x - int32_t y - - - int32_t width - int32_t height - - - XrOffset2Di offset - XrExtent2Di extent - - - - - XrLoaderInterfaceStructs structType - uint32_t structVersion - size_t structSize - uint32_t minInterfaceVersion - uint32_t maxInterfaceVersion - XrVersion minApiVersion - XrVersion maxApiVersion - - - XrLoaderInterfaceStructs structType - uint32_t structVersion - size_t structSize - uint32_t layerInterfaceVersion - XrVersion layerApiVersion - PFN_xrGetInstanceProcAddr getInstanceProcAddr - PFN_xrCreateApiLayerInstance createApiLayerInstance - - - XrLoaderInterfaceStructs structType - uint32_t structVersion - size_t structSize - uint32_t runtimeInterfaceVersion - XrVersion runtimeApiVersion - PFN_xrGetInstanceProcAddr getInstanceProcAddr - - - - XrLoaderInterfaceStructs structType - uint32_t structVersion - size_t structSize - char layerName[XR_MAX_API_LAYER_NAME_SIZE] - PFN_xrGetInstanceProcAddr nextGetInstanceProcAddr - PFN_xrCreateApiLayerInstance nextCreateApiLayerInstance - struct XrApiLayerNextInfo* next - - - XrLoaderInterfaceStructs structType - uint32_t structVersion - size_t structSize - void* loaderInstance - char settings_file_location[XR_API_LAYER_MAX_SETTINGS_PATH_SIZE] - XrApiLayerNextInfo* nextInfo - - - - XrBaseInStructure and XrBaseOutStructure use "struct" in their member definitions - because they are recursive structures and this is easier than modifying the tooling - to output forward declarations. - - - XrStructureType type - const struct XrBaseInStructure* next - - - XrStructureType type - struct XrBaseOutStructure* next - - - XrStructureType type - void* next - char layerName[XR_MAX_API_LAYER_NAME_SIZE] - XrVersion specVersion - uint32_t layerVersion - char description[XR_MAX_API_LAYER_DESCRIPTION_SIZE] - - - XrStructureType type - void* next - char extensionName[XR_MAX_EXTENSION_NAME_SIZE] - uint32_t extensionVersion - - - char applicationName[XR_MAX_APPLICATION_NAME_SIZE] - uint32_t applicationVersion - char engineName[XR_MAX_ENGINE_NAME_SIZE] - uint32_t engineVersion - XrVersion apiVersion - - - XrStructureType type - const void* next - XrInstanceCreateFlags createFlags - XrApplicationInfo applicationInfo - uint32_t enabledApiLayerCount - const char* const* enabledApiLayerNames - uint32_t enabledExtensionCount - const char* const* enabledExtensionNames - - - XrStructureType type - void* next - XrVersion runtimeVersion - char runtimeName[XR_MAX_RUNTIME_NAME_SIZE] - - - XrStructureType type - const void* next - XrFormFactor formFactor - - - XrStructureType type - void* next - XrSystemId systemId - uint32_t vendorId - char systemName[XR_MAX_SYSTEM_NAME_SIZE] - XrSystemGraphicsProperties graphicsProperties - XrSystemTrackingProperties trackingProperties - - - uint32_t maxSwapchainImageHeight - uint32_t maxSwapchainImageWidth - uint32_t maxLayerCount - - - XrBool32 orientationTracking - XrBool32 positionTracking - - - XrStructureType type - const void* next - HDC hDC - HGLRC hGLRC - - - XrStructureType type - const void* next - Display* xDisplay - uint32_t visualid - GLXFBConfig glxFBConfig - GLXDrawable glxDrawable - GLXContext glxContext - - - XrStructureType type - const void* next - xcb_connection_t* connection - uint32_t screenNumber - xcb_glx_fbconfig_t fbconfigid - xcb_visualid_t visualid - xcb_glx_drawable_t glxDrawable - xcb_glx_context_t glxContext - - - XrStructureType type - const void* next - struct wl_display* display - - - XrStructureType type - const void* next - ID3D11Device* device - - - XrStructureType type - const void* next - ID3D12Device* device - ID3D12CommandQueue* queue - - - XrStructureType type - const void* next - EGLDisplay display - EGLConfig config - EGLContext context - - - XrStructureType type - const void* next - VkInstance instance - VkPhysicalDevice physicalDevice - VkDevice device - uint32_t queueFamilyIndex - uint32_t queueIndex - - - XrStructureType type - const void* next - XrSessionCreateFlags createFlags - XrSystemId systemId - - - XrStructureType type - const void* next - XrViewConfigurationType primaryViewConfigurationType - - - XrStructureType type - const void* next - XrSwapchainCreateFlags createFlags - XrSwapchainUsageFlags usageFlags - int64_t format - uint32_t sampleCount - uint32_t width - uint32_t height - uint32_t faceCount - uint32_t arraySize - uint32_t mipCount - - - XrStructureType type - void* next - - - XrStructureType type - void* next - uint32_t image - - - XrStructureType type - void* next - uint32_t image - - - XrStructureType type - void* next - VkImage image - - - XrStructureType type - void* next - ID3D11Texture2D* texture - - - XrStructureType type - void* next - ID3D12Resource* texture - - - XrStructureType type - const void* next - - - XrStructureType type - const void* next - XrDuration timeout - - - XrStructureType type - const void* next - - - XrStructureType type - const void* next - XrReferenceSpaceType referenceSpaceType - XrPosef poseInReferenceSpace - - - XrStructureType type - const void* next - XrAction action - XrPath subactionPath - XrPosef poseInActionSpace - - - XrStructureType type - void* next - XrSpaceLocationFlags locationFlags - XrPosef pose - - - XrStructureType type - void* next - XrSpaceVelocityFlags velocityFlags - XrVector3f linearVelocity - XrVector3f angularVelocity - - - float angleLeft - float angleRight - float angleUp - float angleDown - - - XrStructureType type - void* next - XrPosef pose - XrFovf fov - - - XrStructureType type - const void* next - XrViewConfigurationType viewConfigurationType - XrTime displayTime - XrSpace space - - - XrStructureType type - void* next - XrViewStateFlags viewStateFlags - - - XrStructureType type - void* next - uint32_t recommendedImageRectWidth - uint32_t maxImageRectWidth - uint32_t recommendedImageRectHeight - uint32_t maxImageRectHeight - uint32_t recommendedSwapchainSampleCount - uint32_t maxSwapchainSampleCount - - - XrSwapchain swapchain - XrRect2Di imageRect - uint32_t imageArrayIndex - - - XrStructureType type - const void* next - XrCompositionLayerFlags layerFlags - XrSpace space - - - XrStructureType type - const void* next - XrPosef pose - XrFovf fov - XrSwapchainSubImage subImage - - - XrStructureType type - const void* next - XrCompositionLayerFlags layerFlags - XrSpace space - uint32_t viewCount - const XrCompositionLayerProjectionView* views - - - XrStructureType type - const void* next - XrCompositionLayerFlags layerFlags - XrSpace space - XrEyeVisibility eyeVisibility - XrSwapchainSubImage subImage - XrPosef pose - XrExtent2Df size - - - XrStructureType type - const void* next - XrCompositionLayerFlags layerFlags - XrSpace space - XrEyeVisibility eyeVisibility - XrSwapchainSubImage subImage - XrPosef pose - float radius - float centralAngle - float aspectRatio - - - XrStructureType type - const void* next - XrCompositionLayerFlags layerFlags - XrSpace space - XrEyeVisibility eyeVisibility - XrSwapchain swapchain - uint32_t imageArrayIndex - XrQuaternionf orientation - - - XrStructureType type - const void* next - XrCompositionLayerFlags layerFlags - XrSpace space - XrEyeVisibility eyeVisibility - XrSwapchainSubImage subImage - XrPosef pose - float radius - XrVector2f scale - XrVector2f bias - - - XrStructureType type - const void* next - XrSwapchainSubImage subImage - float minDepth - float maxDepth - float nearZ - float farZ - - - XrStructureType type - const void* next - - - - XrStructureType type - const void* next - XrTime displayTime - XrEnvironmentBlendMode environmentBlendMode - uint32_t layerCount - const XrCompositionLayerBaseHeader* const* layers - - - XrStructureType type - const void* next - - - XrStructureType type - void* next - XrTime predictedDisplayTime - XrDuration predictedDisplayPeriod - XrBool32 shouldRender - - - XrStructureType type - const void* next - - - XrStructureType type - const void* next - XrDuration duration - float frequency - float amplitude - - - XrStructureType type - const void* next - - - XrStructureType type - const void* next - uint8_t varying[4000] - - - XrStructureType type - const void* next - uint32_t lostEventCount - - - XrStructureType type - const void* next - XrTime lossTime - - - XrStructureType type - const void* next - XrSession session - XrSessionState state - XrTime time - - - XrStructureType type - const void* next - XrSession session - XrReferenceSpaceType referenceSpaceType - XrTime changeTime - XrBool32 poseValid - XrPosef poseInPreviousSpace - - - XrStructureType type - const void* next - XrPerfSettingsDomainEXT domain - XrPerfSettingsSubDomainEXT subDomain - XrPerfSettingsNotificationLevelEXT fromLevel - XrPerfSettingsNotificationLevelEXT toLevel - - - XrStructureType type - const void* next - XrSession session - XrViewConfigurationType viewConfigurationType - uint32_t viewIndex - - - XrStructureType type - void* next - XrViewConfigurationType viewConfigurationType - XrBool32 fovMutable - - - XrStructureType type - void* next - XrBool32 currentState - XrBool32 changedSinceLastSync - XrTime lastChangeTime - XrBool32 isActive - - - XrStructureType type - void* next - float currentState - XrBool32 changedSinceLastSync - XrTime lastChangeTime - XrBool32 isActive - - - - XrStructureType type - void* next - XrVector2f currentState - XrBool32 changedSinceLastSync - XrTime lastChangeTime - XrBool32 isActive - - - - XrStructureType type - void* next - XrBool32 isActive - - - - XrStructureType type - const void* next - XrAction action - XrPath subactionPath - - - - XrStructureType type - const void* next - XrAction action - XrPath subactionPath - - - - XrStructureType type - const void* next - char actionSetName[XR_MAX_ACTION_SET_NAME_SIZE] - char localizedActionSetName[XR_MAX_LOCALIZED_ACTION_SET_NAME_SIZE] - uint32_t priority - - - - XrAction action - XrPath binding - - - - XrStructureType type - const void* next - XrPath interactionProfile - uint32_t countSuggestedBindings - const XrActionSuggestedBinding* suggestedBindings - - - - XrActionSet actionSet - XrPath subactionPath - - - - XrStructureType type - const void* next - uint32_t countActionSets - const XrActionSet* actionSets - - - - XrStructureType type - const void* next - uint32_t countActiveActionSets - const XrActiveActionSet* activeActionSets - - - - XrStructureType type - const void* next - XrAction action - - - - XrStructureType type - const void* next - XrPath sourcePath - XrInputSourceLocalizedNameFlags whichComponents - - - - XrStructureType type - const void* next - XrSession session - - - - XrStructureType type - void* next - XrPath interactionProfile - - - - XrStructureType type - const void* next - char actionName[XR_MAX_ACTION_NAME_SIZE] - XrActionType actionType - uint32_t countSubactionPaths - const XrPath* subactionPaths - char localizedActionName[XR_MAX_LOCALIZED_ACTION_NAME_SIZE] - - - XrStructureType type - const void* next - void* applicationVM - void* applicationActivity - - - XrStructureType type - const void* next - uint32_t viewFormatCount - const VkFormat* viewFormats - - - XrStructureType type - const void* next - XrObjectType objectType - uint64_t objectHandle - const char* objectName - - - XrStructureType type - const void* next - const char* labelName - - - XrStructureType type - const void* next - const char* messageId - const char* functionName - const char* message - uint32_t objectCount - XrDebugUtilsObjectNameInfoEXT* objects - uint32_t sessionLabelCount - XrDebugUtilsLabelEXT* sessionLabels - - - XrStructureType type - const void* next - XrDebugUtilsMessageSeverityFlagsEXT messageSeverities - XrDebugUtilsMessageTypeFlagsEXT messageTypes - PFN_xrDebugUtilsMessengerCallbackEXT userCallback - void* userData - - - - - XrStructureType type - void* next - uint32_t vertexCapacityInput - uint32_t vertexCountOutput - XrVector2f* vertices - uint32_t indexCapacityInput - uint32_t indexCountOutput - uint32_t* indices - - - - XrStructureType type - void* next - XrVersion minApiVersionSupported - XrVersion maxApiVersionSupported - - - XrStructureType type - void* next - XrVersion minApiVersionSupported - XrVersion maxApiVersionSupported - - - XrStructureType type - void* next - XrVersion minApiVersionSupported - XrVersion maxApiVersionSupported - - - XrStructureType type - void* next - LUID adapterLuid - D3D_FEATURE_LEVEL minFeatureLevel - - - XrStructureType type - void* next - LUID adapterLuid - D3D_FEATURE_LEVEL minFeatureLevel - - - - - XrStructureType type - const void* next - XrSystemId systemId - XrVulkanInstanceCreateFlagsKHR createFlags - PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr - const VkInstanceCreateInfo* vulkanCreateInfo - const VkAllocationCallbacks* vulkanAllocator - - - XrStructureType type - const void* next - XrSystemId systemId - XrVulkanDeviceCreateFlagsKHR createFlags - PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr - VkPhysicalDevice vulkanPhysicalDevice - const VkDeviceCreateInfo* vulkanCreateInfo - const VkAllocationCallbacks* vulkanAllocator - - - - XrStructureType type - const void* next - XrSystemId systemId - VkInstance vulkanInstance - - - - - - - XrStructureType type - const void* next - VkImageCreateFlags additionalCreateFlags - VkImageUsageFlags additionalUsageFlags - - - - - XrStructureType type - const void* next - XrOverlaySessionCreateFlagsEXTX createFlags - uint32_t sessionLayersPlacement - - - XrStructureType type - const void* next - XrBool32 visible - XrOverlayMainSessionFlagsEXTX flags - - - - - XrStructureType type - const void* next - float fromDisplayRefreshRate - float toDisplayRefreshRate - - - - - XrStructureType type - void* next - float recommendedNearZ - float minNearZ - float recommendedFarZ - float maxFarZ - - - - - XrStructureType type - const void* next - XrFovf recommendedFov - XrFovf maxMutableFov - - - - - XrStructureType type - const void* next - XrPath binding - XrActionSet actionSet - float forceThreshold - float forceThresholdReleased - float centerRegion - float wedgeAngle - XrBool32 isSticky - const XrHapticBaseHeader* onHaptic - const XrHapticBaseHeader* offHaptic - - - - - XrStructureType type - const void* next - XrAction action - XrPath binding - float onThreshold - float offThreshold - const XrHapticBaseHeader* onHaptic - const XrHapticBaseHeader* offHaptic - - - - - XrStructureType type - const void* next - uint32_t bindingModificationCount - const XrBindingModificationBaseHeaderKHR* const* bindingModifications - - - - XrStructureType type - const void* next - - - - typedef void (XRAPI_PTR *PFN_xrVoidFunction)(void); - - - typedef XrResult (XRAPI_PTR *PFN_xrGetInstanceProcAddr)(XrInstance instance, const char* name, PFN_xrVoidFunction* function); - - - - - - -typedef struct XrApiLayerCreateInfo XrApiLayerCreateInfo; -typedef XrResult (XRAPI_PTR *PFN_xrCreateApiLayerInstance)( - const XrInstanceCreateInfo* info, - const XrApiLayerCreateInfo* apiLayerInfo, - XrInstance* instance); - - - typedef XrBool32 (XRAPI_PTR *PFN_xrDebugUtilsMessengerCallbackEXT)( - XrDebugUtilsMessageSeverityFlagsEXT messageSeverity, - XrDebugUtilsMessageTypeFlagsEXT messageTypes, - const XrDebugUtilsMessengerCallbackDataEXT* callbackData, - void* userData); - - - - - XrStructureType type - void* next - XrBool32 supportsEyeGazeInteraction - - - - XrStructureType type - void* next - XrTime time - - - - - XrStructureType type - const void* next - XrSpace space - XrPosef pose - XrTime time - - - XrStructureType type - const void* next - XrSpatialAnchorMSFT anchor - XrPosef poseInAnchorSpace - - - - - XrStructureType type - void* next - XrCompositionLayerImageLayoutFlagsFB flags - - - - - XrStructureType type - void* next - XrBlendFactorFB srcFactorColor - XrBlendFactorFB dstFactorColor - XrBlendFactorFB srcFactorAlpha - XrBlendFactorFB dstFactorAlpha - - - - - typedef PFN_xrVoidFunction (*PFN_xrEglGetProcAddressMNDX)(const char *name); - - - XrStructureType type - const void* next - PFN_xrEglGetProcAddressMNDX getProcAddress - EGLDisplay display - EGLConfig config - EGLContext context - - - - XR_DEFINE_HANDLE(XrSpatialGraphNodeBindingMSFT) - - XrStructureType type - const void* next - XrSpatialGraphNodeTypeMSFT nodeType - uint8_t nodeId[XR_GUID_SIZE_MSFT] - XrPosef pose - - - XrStructureType type - const void* next - XrSpace space - XrPosef poseInSpace - XrTime time - - - XrStructureType type - const void* next - - - XrStructureType type - void* next - uint8_t nodeId[XR_GUID_SIZE_MSFT] - XrPosef poseInNodeSpace - - - - - - - - - XrStructureType type - void* next - XrBool32 supportsHandTracking - - - XrStructureType type - const void* next - XrHandEXT hand - XrHandJointSetEXT handJointSet - - - XrStructureType type - const void* next - XrSpace baseSpace - XrTime time - - - XrSpaceLocationFlags locationFlags - XrPosef pose - float radius - - - XrSpaceVelocityFlags velocityFlags - XrVector3f linearVelocity - XrVector3f angularVelocity - - - XrStructureType type - void* next - XrBool32 isActive - uint32_t jointCount - XrHandJointLocationEXT* jointLocations - - - XrStructureType type - void* next - uint32_t jointCount - XrHandJointVelocityEXT* jointVelocities - - - - - XrStructureType type - void* next - XrBool32 supportsFaceTracking - - - XrStructureType type - const void* next - XrFaceExpressionSetFB faceExpressionSet - - - XrStructureType type - const void* next - XrTime time - - - XrBool32 isValid - XrBool32 isEyeFollowingBlendshapesValid - - - XrStructureType type - void* next - uint32_t weightCount - float* weights - uint32_t confidenceCount - float* confidences - XrFaceExpressionStatusFB status - XrTime time - - - - - XrStructureType type - void* next - XrBool32 supportsVisualFaceTracking - XrBool32 supportsAudioFaceTracking - - - XrStructureType type - const void* next - XrFaceExpressionSet2FB faceExpressionSet - uint32_t requestedDataSourceCount - XrFaceTrackingDataSource2FB* requestedDataSources - - - XrStructureType type - const void* next - XrTime time - - - XrStructureType type - void* next - uint32_t weightCount - float* weights - uint32_t confidenceCount - float* confidences - XrBool32 isValid - XrBool32 isEyeFollowingBlendshapesValid - XrFaceTrackingDataSource2FB dataSource - XrTime time - - - - - XrStructureType type - void* next - XrBool32 supportsBodyTracking - - - XrStructureType type - const void* next - XrBodyJointSetFB bodyJointSet - - - int32_t joint - int32_t parentJoint - XrPosef pose - - - XrStructureType type - void* next - uint32_t jointCount - XrBodySkeletonJointFB* joints - - - XrStructureType type - const void* next - XrSpace baseSpace - XrTime time - - - XrSpaceLocationFlags locationFlags - XrPosef pose - - - XrStructureType type - void* next - XrBool32 isActive - float confidence - uint32_t jointCount - XrBodyJointLocationFB* jointLocations - uint32_t skeletonChangedCount - XrTime time - - - - - XrStructureType type - void* next - XrBool32 supportsEyeTracking - - - XrStructureType type - const void* next - - - XrStructureType type - const void* next - XrSpace baseSpace - XrTime time - - - XrBool32 isValid - XrPosef gazePose - float gazeConfidence - - - XrStructureType type - void* next - XrEyeGazeFB gaze[XR_EYE_POSITION_COUNT_FB] - XrTime time - - - - - - XrStructureType type - const void* next - XrHandJointsMotionRangeEXT handJointsMotionRange - - - - - - XrStructureType type - const void* next - uint32_t requestedDataSourceCount - XrHandTrackingDataSourceEXT* requestedDataSources - - - - XrStructureType type - void* next - XrBool32 isActive - XrHandTrackingDataSourceEXT dataSource - - - - - - XrStructureType type - const void* next - XrHandPoseTypeMSFT handPoseType - XrPosef poseInHandMeshSpace - - - XrStructureType type - const void* next - XrTime time - XrHandPoseTypeMSFT handPoseType - - - XrStructureType type - void* next - XrBool32 isActive - XrBool32 indexBufferChanged - XrBool32 vertexBufferChanged - XrHandMeshIndexBufferMSFT indexBuffer - XrHandMeshVertexBufferMSFT vertexBuffer - - - uint32_t indexBufferKey - uint32_t indexCapacityInput - uint32_t indexCountOutput - uint32_t* indices - - - XrTime vertexUpdateTime - uint32_t vertexCapacityInput - uint32_t vertexCountOutput - XrHandMeshVertexMSFT* vertices - - - XrVector3f position - XrVector3f normal - - - XrStructureType type - void* next - XrBool32 supportsHandTrackingMesh - uint32_t maxHandMeshIndexCount - uint32_t maxHandMeshVertexCount - - - XrStructureType type - const void* next - XrHandPoseTypeMSFT handPoseType - - - - - XrStructureType type - const void* next - uint32_t viewConfigurationCount - const XrViewConfigurationType* enabledViewConfigurationTypes - - - XrStructureType type - void* next - XrViewConfigurationType viewConfigurationType - XrBool32 active - - - XrStructureType type - void* next - uint32_t viewConfigurationCount - XrSecondaryViewConfigurationStateMSFT* viewConfigurationStates - - - XrStructureType type - const void* next - uint32_t viewConfigurationCount - const XrSecondaryViewConfigurationLayerInfoMSFT* viewConfigurationLayersInfo - - - XrStructureType type - const void* next - XrViewConfigurationType viewConfigurationType - XrEnvironmentBlendMode environmentBlendMode - uint32_t layerCount - const XrCompositionLayerBaseHeader* const* layers - - - XrStructureType type - const void* next - XrViewConfigurationType viewConfigurationType - - - - - XrStructureType type - const void* next - IUnknown* holographicSpace - IUnknown* coreWindow - - - - - XrStructureType type - const void* next - XrAndroidSurfaceSwapchainFlagsFB createFlags - - - - - XrStructureType type - void* next - - - - - XrStructureType type - void* next - uint32_t width - uint32_t height - - - - - XrStructureType type - void* next - EGLenum minFilter - EGLenum magFilter - EGLenum wrapModeS - EGLenum wrapModeT - EGLenum swizzleRed - EGLenum swizzleGreen - EGLenum swizzleBlue - EGLenum swizzleAlpha - float maxAnisotropy - XrColor4f borderColor - - - - - XrStructureType type - void* next - VkFilter minFilter - VkFilter magFilter - VkSamplerMipmapMode mipmapMode - VkSamplerAddressMode wrapModeS - VkSamplerAddressMode wrapModeT - VkComponentSwizzle swizzleRed - VkComponentSwizzle swizzleGreen - VkComponentSwizzle swizzleBlue - VkComponentSwizzle swizzleAlpha - float maxAnisotropy - XrColor4f borderColor - - - - - XrStructureType type - const void* next - XrCompositionLayerSecureContentFlagsFB flags - - - - - XrStructureType type - const void* next - - - - - XrStructureType type - const void* next - void* applicationVM - void* applicationContext - - - - - XrStructureType type - const void* next - XrCompositionLayerFlags layerFlags - XrSpace space - XrEyeVisibility eyeVisibility - XrSwapchainSubImage subImage - XrPosef pose - float radius - float centralHorizontalAngle - float upperVerticalAngle - float lowerVerticalAngle - - - - - XrStructureType type - const void* next - XrColor4f colorScale - XrColor4f colorBias - - - - - XrStructureType type - void* next - XrControllerModelKeyMSFT modelKey - - - XrStructureType type - void* next - char parentNodeName[XR_MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT] - char nodeName[XR_MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT] - - - XrStructureType type - void* next - uint32_t nodeCapacityInput - uint32_t nodeCountOutput - XrControllerModelNodePropertiesMSFT* nodeProperties - - - XrStructureType type - void* next - XrPosef nodePose - - - XrStructureType type - void* next - uint32_t nodeCapacityInput - uint32_t nodeCountOutput - XrControllerModelNodeStateMSFT* nodeStates - - - - - XR_DEFINE_HANDLE(XrSceneObserverMSFT) - - XR_DEFINE_HANDLE(XrSceneMSFT) - - - - - - - - - uint8_t bytes[16] - - - XrStructureType type - const void* next - - - XrStructureType type - const void* next - - - XrStructureType type - const void* next - uint32_t requestedFeatureCount - const XrSceneComputeFeatureMSFT* requestedFeatures - XrSceneComputeConsistencyMSFT consistency - XrSceneBoundsMSFT bounds - - - XrStructureType type - const void* next - XrMeshComputeLodMSFT lod - - - - XrVector3f center - float radius - - - - XrPosef pose - XrVector3f extents - - - - XrPosef pose - XrFovf fov - float farDistance - - - - XrSpace space - XrTime time - uint32_t sphereCount - const XrSceneSphereBoundMSFT* spheres - uint32_t boxCount - const XrSceneOrientedBoxBoundMSFT* boxes - uint32_t frustumCount - const XrSceneFrustumBoundMSFT* frustums - - - XrSceneComponentTypeMSFT componentType - XrUuidMSFT id - XrUuidMSFT parentId - XrTime updateTime - - - XrStructureType type - void* next - uint32_t componentCapacityInput - uint32_t componentCountOutput - XrSceneComponentMSFT* components - - - XrStructureType type - const void* next - XrSceneComponentTypeMSFT componentType - - - XrSpaceLocationFlags flags - XrPosef pose - - - XrStructureType type - void* next - uint32_t locationCount - XrSceneComponentLocationMSFT* locations - - - XrStructureType type - const void* next - XrSpace baseSpace - XrTime time - uint32_t componentIdCount - const XrUuidMSFT* componentIds - - - XrSceneObjectTypeMSFT objectType - - - XrStructureType type - void* next - uint32_t sceneObjectCount - XrSceneObjectMSFT* sceneObjects - - - XrStructureType type - const void* next - XrUuidMSFT parentId - - - XrStructureType type - const void* next - uint32_t objectTypeCount - const XrSceneObjectTypeMSFT* objectTypes - - - XrScenePlaneAlignmentTypeMSFT alignment - XrExtent2Df size - uint64_t meshBufferId - XrBool32 supportsIndicesUint16 - - - XrStructureType type - void* next - uint32_t scenePlaneCount - XrScenePlaneMSFT* scenePlanes - - - XrStructureType type - const void* next - uint32_t alignmentCount - const XrScenePlaneAlignmentTypeMSFT* alignments - - - uint64_t meshBufferId - XrBool32 supportsIndicesUint16 - - - XrStructureType type - void* next - uint32_t sceneMeshCount - XrSceneMeshMSFT* sceneMeshes - - - XrStructureType type - const void* next - uint64_t meshBufferId - - - XrStructureType type - void* next - - - XrStructureType type - void* next - uint32_t vertexCapacityInput - uint32_t vertexCountOutput - XrVector3f* vertices - - - XrStructureType type - void* next - uint32_t indexCapacityInput - uint32_t indexCountOutput - uint32_t* indices - - - XrStructureType type - void* next - uint32_t indexCapacityInput - uint32_t indexCountOutput - uint16_t* indices - - - - - XrStructureType type - const void* next - XrUuidMSFT sceneFragmentId - - - uint32_t bufferSize - const uint8_t* buffer - - - XrStructureType type - const void* next - uint32_t fragmentCount - const XrDeserializeSceneFragmentMSFT* fragments - - - - - - - XrSceneMarkerTypeMSFT markerType - XrTime lastSeenTime - XrOffset2Df center - XrExtent2Df size - - - XrStructureType type - const void* next - uint32_t sceneMarkerCapacityInput - XrSceneMarkerMSFT* sceneMarkers - - - XrStructureType type - const void* next - uint32_t markerTypeCount - XrSceneMarkerTypeMSFT* markerTypes - - - XrSceneMarkerQRCodeSymbolTypeMSFT symbolType - uint8_t version - - - XrStructureType type - const void* next - uint32_t qrCodeCapacityInput - XrSceneMarkerQRCodeMSFT* qrCodes - - - - - - XrStructureType type - void* next - XrColorSpaceFB colorSpace - - - - - XrStructureType type - const void* next - XrBool32 supportsSpatialEntity - - - XrStructureType type - const void* next - XrSpace space - XrPosef poseInSpace - XrTime time - - - XrStructureType type - const void* next - XrSpaceComponentTypeFB componentType - XrBool32 enabled - XrDuration timeout - - - XrStructureType type - void* next - XrBool32 enabled - XrBool32 changePending - - - XrStructureType type - const void* next - XrAsyncRequestIdFB requestId - XrResult result - XrSpace space - XrUuidEXT uuid - - - XrStructureType type - const void* next - XrAsyncRequestIdFB requestId - XrResult result - XrSpace space - XrUuidEXT uuid - XrSpaceComponentTypeFB componentType - XrBool32 enabled - - - - - XrStructureType type - void* next - - - XrStructureType type - void* next - XrSwapchainCreateFoveationFlagsFB flags - - - XrStructureType type - void* next - XrSwapchainStateFoveationFlagsFB flags - XrFoveationProfileFB profile - - - - - XrStructureType type - void* next - VkImage image - uint32_t width - uint32_t height - - - - - - - XrStructureType type - void* next - XrFoveationLevelFB level - float verticalOffset - XrFoveationDynamicFB dynamic - - - - - XrStructureType type - const void* next - XrFoveationEyeTrackedProfileCreateFlagsMETA flags - - - XrStructureType type - void* next - XrVector2f foveationCenter[XR_FOVEATION_CENTER_SIZE_META] - XrFoveationEyeTrackedStateFlagsMETA flags - - - XrStructureType type - void* next - XrBool32 supportsFoveationEyeTracked - - - - - int16_t x - int16_t y - int16_t z - int16_t w - - - XrStructureType type - void* next - uint32_t jointCapacityInput - uint32_t jointCountOutput - XrPosef* jointBindPoses - float* jointRadii - XrHandJointEXT* jointParents - uint32_t vertexCapacityInput - uint32_t vertexCountOutput - XrVector3f* vertexPositions - XrVector3f* vertexNormals - XrVector2f* vertexUVs - XrVector4sFB* vertexBlendIndices - XrVector4f* vertexBlendWeights - uint32_t indexCapacityInput - uint32_t indexCountOutput - int16_t* indices - - - XrStructureType type - void* next - float sensorOutput - float currentOutput - XrBool32 overrideHandScale - float overrideValueInput - - - - - XrStructureType type - void* next - XrHandTrackingAimFlagsFB status - XrPosef aimPose - float pinchStrengthIndex - float pinchStrengthMiddle - float pinchStrengthRing - float pinchStrengthLittle - - - - - XrVector3f points[XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB] - float radius - XrHandJointEXT joint - - - XrStructureType type - void* next - XrHandCapsuleFB capsules[XR_HAND_TRACKING_CAPSULE_COUNT_FB] - - - - - XrStructureType type - void* next - XrPath path - - - XrStructureType type - void* next - uint32_t vendorId - char modelName[XR_MAX_RENDER_MODEL_NAME_SIZE_FB] - XrRenderModelKeyFB modelKey - uint32_t modelVersion - XrRenderModelFlagsFB flags - - - XrStructureType type - void* next - XrRenderModelFlagsFB flags - - - XrStructureType type - void* next - uint32_t bufferCapacityInput - uint32_t bufferCountOutput - uint8_t* buffer - - - XrStructureType type - void* next - XrRenderModelKeyFB modelKey - - - XrStructureType type - void* next - XrBool32 supportsRenderModelLoading - - - - - XrStructureType type - const void* next - - - XrStructureType type - const void* next - - - XrStructureType type - const void* next - XrSpaceQueryActionFB queryAction - uint32_t maxResultCount - XrDuration timeout - const XrSpaceFilterInfoBaseHeaderFB* filter - const XrSpaceFilterInfoBaseHeaderFB* excludeFilter - - - XrStructureType type - const void* next - XrSpaceStorageLocationFB location - - - XrStructureType type - const void* next - uint32_t uuidCount - XrUuidEXT* uuids - - - XrStructureType type - const void* next - XrSpaceComponentTypeFB componentType - - - XrSpace space - XrUuidEXT uuid - - - XrStructureType type - void* next - uint32_t resultCapacityInput - uint32_t resultCountOutput - XrSpaceQueryResultFB* results - - - XrStructureType type - const void* next - XrAsyncRequestIdFB requestId - - - XrStructureType type - const void* next - XrAsyncRequestIdFB requestId - XrResult result - - - - - XrStructureType type - const void* next - XrSpace space - XrSpaceStorageLocationFB location - XrSpacePersistenceModeFB persistenceMode - - - XrStructureType type - const void* next - XrSpace space - XrSpaceStorageLocationFB location - - - XrStructureType type - const void* next - XrAsyncRequestIdFB requestId - XrResult result - XrSpace space - XrUuidEXT uuid - XrSpaceStorageLocationFB location - - - XrStructureType type - const void* next - XrAsyncRequestIdFB requestId - XrResult result - XrSpace space - XrUuidEXT uuid - XrSpaceStorageLocationFB location - - - - - XrStructureType type - const void* next - uint32_t spaceCount - XrSpace* spaces - uint32_t userCount - XrSpaceUserFB* users - - - XrStructureType type - const void* next - XrAsyncRequestIdFB requestId - XrResult result - - - - - XrStructureType type - const void* next - uint32_t spaceCount - XrSpace* spaces - XrSpaceStorageLocationFB location - - - XrStructureType type - const void* next - XrAsyncRequestIdFB requestId - XrResult result - - - - - XrStructureType type - const void* next - uint32_t uuidCapacityInput - uint32_t uuidCountOutput - XrUuidEXT* uuids - - - - - XrStructureType type - const void* next - - - - XrStructureType type - void* next - uint32_t vertexCapacityInput - uint32_t vertexCountOutput - XrVector3f* vertices - uint32_t indexCapacityInput - uint32_t indexCountOutput - uint32_t* indices - - - - - - - float x - float y - float z - - - - XrOffset3DfFB offset - XrExtent3DfFB extent - - - - XrStructureType type - const void* next - uint32_t bufferCapacityInput - uint32_t bufferCountOutput - char* buffer - - - XrStructureType type - const void* next - XrUuidEXT floorUuid - XrUuidEXT ceilingUuid - uint32_t wallUuidCapacityInput - uint32_t wallUuidCountOutput - XrUuidEXT* wallUuids - - - XrStructureType type - const void* next - uint32_t vertexCapacityInput - uint32_t vertexCountOutput - XrVector2f* vertices - - - XrStructureType type - const void* next - XrSemanticLabelsSupportFlagsFB flags - const char* recognizedLabels - - - - - XrStructureType type - const void* next - uint32_t requestByteCount - const char* request - - - XrStructureType type - const void* next - XrAsyncRequestIdFB requestId - XrResult result - - - - - XrStructureType type - void* next - XrBool32 supportsKeyboardTracking - - - uint64_t trackedKeyboardId - XrVector3f size - XrKeyboardTrackingFlagsFB flags - char name[XR_MAX_KEYBOARD_TRACKING_NAME_SIZE_FB] - - - XrStructureType type - void* next - uint64_t trackedKeyboardId - - - XrStructureType type - void* next - XrKeyboardTrackingQueryFlagsFB flags - - - - - XrStructureType type - const void* next - float depthTestRangeNearZ - float depthTestRangeFarZ - - - - - XrStructureType type - const void* next - XrBool32 foveatedRenderingActive - - - - XrStructureType type - void* next - XrBool32 foveatedRenderingActive - - - - XrStructureType type - void* next - XrBool32 supportsFoveatedRendering - - - - - - XrStructureType type - const void* next - XrReprojectionModeMSFT reprojectionMode - - - XrStructureType type - const void* next - XrVector3f position - XrVector3f normal - XrVector3f velocity - - - - - XrStructureType type - const void* next - XrTriangleMeshFlagsFB flags - XrWindingOrderFB windingOrder - uint32_t vertexCount - const XrVector3f* vertexBuffer - uint32_t triangleCount - const uint32_t* indexBuffer - - - - - XrStructureType type - const void* next - XrBool32 supportsPassthrough - - - XrStructureType type - const void* next - XrPassthroughCapabilityFlagsFB capabilities - - - XrStructureType type - const void* next - XrPassthroughFlagsFB flags - - - XrStructureType type - const void* next - XrPassthroughFB passthrough - XrPassthroughFlagsFB flags - XrPassthroughLayerPurposeFB purpose - - - XrStructureType type - const void* next - XrCompositionLayerFlags flags - XrSpace space - XrPassthroughLayerFB layerHandle - - - XrStructureType type - const void* next - XrPassthroughLayerFB layer - XrTriangleMeshFB mesh - XrSpace baseSpace - XrPosef pose - XrVector3f scale - - - XrStructureType type - const void* next - XrSpace baseSpace - XrTime time - XrPosef pose - XrVector3f scale - - - XrStructureType type - const void* next - float textureOpacityFactor - XrColor4f edgeColor - - - XrStructureType type - const void* next - XrColor4f textureColorMap[XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB] - - - XrStructureType type - const void* next - uint8_t textureColorMap[XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB] - - - XrStructureType type - const void* next - float brightness - float contrast - float saturation - - - XrStructureType type - const void* next - XrPassthroughStateChangedFlagsFB flags - - - - - XrStructureType type - const void* next - float leftHandIntensity - float rightHandIntensity - - - - - XrStructureType type - const void* next - XrLocalDimmingModeMETA localDimmingMode - - - - XR_DEFINE_HANDLE(XrSpatialAnchorStoreConnectionMSFT) - - - char name[XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_MSFT] - - - XrStructureType type - const void* next - XrSpatialAnchorPersistenceNameMSFT spatialAnchorPersistenceName - XrSpatialAnchorMSFT spatialAnchor - - - XrStructureType type - const void* next - XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore - XrSpatialAnchorPersistenceNameMSFT spatialAnchorPersistenceName - - - - - XrStructureType type - const void* next - XrFacialTrackingTypeHTC facialTrackingType - - - XrStructureType type - void* next - XrBool32 supportEyeFacialTracking - XrBool32 supportLipFacialTracking - - - XrStructureType type - const void* next - XrBool32 isActive - XrTime sampleTime - uint32_t expressionCount - float* expressionWeightings - - - - - XrStructureType type - const void* next - XrPassthroughFormHTC form - - - XrStructureType type - const void* next - float alpha - - - XrStructureType type - const void* next - uint32_t vertexCount - const XrVector3f* vertices - uint32_t indexCount - const uint32_t* indices - XrSpace baseSpace - XrTime time - XrPosef pose - XrVector3f scale - - - XrStructureType type - const void* next - XrCompositionLayerFlags layerFlags - XrSpace space - XrPassthroughHTC passthrough - XrPassthroughColorHTC color - - - - - XrStructureType type - const void* next - XrSpace space - XrPosef poseInSpace - XrSpatialAnchorNameHTC name - - - char name[XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_HTC] - - - XrStructureType type - void* next - XrBool32 supportsAnchor - - - - - XrStructureType type - void* next - XrPath persistentPath - XrPath rolePath - - - XrStructureType type - const void* next - XrViveTrackerPathsHTCX* paths - - - - - - XrStructureType type - const void* next - XrCompositionLayerSpaceWarpInfoFlagsFB layerFlags - XrSwapchainSubImage motionVectorSubImage - XrPosef appSpaceDeltaPose - XrSwapchainSubImage depthSubImage - float minDepth - float maxDepth - float nearZ - float farZ - - - XrStructureType type - void* next - uint32_t recommendedMotionVectorImageRectWidth - uint32_t recommendedMotionVectorImageRectHeight - - - - - - XrStructureType type - void* next - XrBool32 supportsMarkerTracking - - - - XrStructureType type - const void* next - uint64_t markerId - XrBool32 isActive - XrBool32 isPredicted - XrTime time - - - - XrStructureType type - const void* next - uint64_t markerId - XrPosef poseInMarkerSpace - - - - - - - - XrStructureType type - const void* next - float dimmerValue - XrGlobalDimmerFrameEndInfoFlagsML flags - - - - - XrStructureType type - const void* next - XrDigitalLensControlFlagsALMALENCE flags - - - - - - - - - - - XrStructureType type - const void* next - XrCompositionLayerSettingsFlagsFB layerFlags - - - - - XrTime lastChangeTime - XrFovf fov - float virtualNearPlaneDistance - float virtualFarPlaneDistance - XrExtent2Di imageSensorPixelResolution - - - - XrTime lastChangeTime - XrExternalCameraStatusFlagsOCULUS cameraStatusFlags - XrExternalCameraAttachedToDeviceOCULUS attachedToDevice - XrPosef relativePose - - - - XrStructureType type - const void* next - char name[XR_MAX_EXTERNAL_CAMERA_NAME_SIZE_OCULUS] - XrExternalCameraIntrinsicsOCULUS intrinsics - XrExternalCameraExtrinsicsOCULUS extrinsics - - - - - XrStructureType type - const void* next - XrBool32 enabled - - - - XrStructureType type - const void* next - XrPerformanceMetricsCounterFlagsMETA counterFlags - XrPerformanceMetricsCounterUnitMETA counterUnit - uint32_t uintValue - float floatValue - - - - - XrStructureType type - const void* next - XrPassthroughPreferenceFlagsMETA flags - - - - - XrStructureType type - void* next - XrUuidEXT id - - - - - uint32_t bufferSize - const uint8_t* buffer - - - - XrStructureType type - const void* next - XrPassthroughColorLutChannelsMETA channels - uint32_t resolution - XrPassthroughColorLutDataMETA data - - - - XrStructureType type - const void* next - XrPassthroughColorLutDataMETA data - - - - XrStructureType type - const void* next - XrPassthroughColorLutMETA colorLut - float weight - - - - XrStructureType type - const void* next - XrPassthroughColorLutMETA sourceColorLut - XrPassthroughColorLutMETA targetColorLut - float weight - - - - XrStructureType type - const void* next - uint32_t maxColorLutResolution - - - - - XrStructureType type - const void* next - XrFoveationModeHTC mode - uint32_t subImageCount - XrSwapchainSubImage* subImages - - - XrFoveationLevelHTC level - float clearFovDegree - XrVector2f focalCenterOffset - - - XrStructureType type - const void* next - XrFoveationDynamicFlagsHTC dynamicFlags - - - XrStructureType type - const void* next - uint32_t configCount - const XrFoveationConfigurationHTC* configs - - - - - XrStructureType type - const void* next - uint32_t actionSetPriorityCount - const XrActiveActionSetPriorityEXT* actionSetPriorities - - - - XrActionSet actionSet - uint32_t priorityOverride - - - - - XrStructureType type - const void* next - XrBool32 depthMask - XrCompareOpFB compareOp - - - - XrStructureType type - const void* next - MLCoordinateFrameUID cfuid - XrPosef poseInCoordinateSpace - - - - - - XrStructureType type - const void* next - float focusDistance - XrFrameEndInfoFlagsML flags - - - - - XrStructureType type - const void* next - XrDuration duration - uint32_t amplitudeCount - const float* amplitudes - - - - - XrStructureType type - const void* next - uint32_t bufferSize - const float* buffer - float sampleRate - XrBool32 append - uint32_t* samplesConsumed - - - XrStructureType type - void* next - float sampleRate - - - - - - - XrStructureType type - const void* next - XrSpaceUserIdFB userId - - - - - XrStructureType type - void* next - XrBool32 supportsForceFeedbackCurl - - - - XrStructureType type - const void* next - uint32_t locationCount - XrForceFeedbackCurlApplyLocationMNDX* locations - - - - XrForceFeedbackCurlLocationMNDX location - float value - - - - - XrStructureType type - void* next - XrPlaneDetectionCapabilityFlagsEXT supportedFeatures - - - - XrStructureType type - const void* next - XrPlaneDetectorFlagsEXT flags - - - - XrStructureType type - const void* next - XrSpace baseSpace - XrTime time - uint32_t orientationCount - const XrPlaneDetectorOrientationEXT* orientations - uint32_t semanticTypeCount - const XrPlaneDetectorSemanticTypeEXT* semanticTypes - uint32_t maxPlanes - float minArea - XrPosef boundingBoxPose - XrExtent3DfEXT boundingBoxExtent - - - - XrStructureType type - const void* next - XrSpace baseSpace - XrTime time - - - - XrStructureType type - void* next - uint32_t planeLocationCapacityInput - uint32_t planeLocationCountOutput - XrPlaneDetectorLocationEXT* planeLocations - - - - XrStructureType type - void* next - uint64_t planeId - XrSpaceLocationFlags locationFlags - XrPosef pose - XrExtent2Df extents - XrPlaneDetectorOrientationEXT orientation - XrPlaneDetectorSemanticTypeEXT semanticType - uint32_t polygonBufferCount - - - - XrStructureType type - void* next - uint32_t vertexCapacityInput - uint32_t vertexCountOutput - XrVector2f* vertices - - - - - XrStructureType type - void* next - XrBool32 supportsVirtualKeyboard - - - - XrStructureType type - const void* next - - - - XrStructureType type - const void* next - XrVirtualKeyboardLocationTypeMETA locationType - XrSpace space - XrPosef poseInSpace - - - - XrStructureType type - const void* next - XrVirtualKeyboardLocationTypeMETA locationType - XrSpace space - XrPosef poseInSpace - float scale - - - - XrStructureType type - const void* next - XrBool32 visible - - - - XrStructureType type - void* next - int32_t animationIndex - float fraction - - - - XrStructureType type - void* next - uint32_t stateCapacityInput - uint32_t stateCountOutput - XrVirtualKeyboardAnimationStateMETA* states - - - - XrStructureType type - void* next - uint32_t textureWidth - uint32_t textureHeight - uint32_t bufferCapacityInput - uint32_t bufferCountOutput - uint8_t* buffer - - - - XrStructureType type - const void* next - XrVirtualKeyboardInputSourceMETA inputSource - XrSpace inputSpace - XrPosef inputPoseInSpace - XrVirtualKeyboardInputStateFlagsMETA inputState - - - - XrStructureType type - const void* next - const char* textContext - - - - XrStructureType type - const void* next - XrVirtualKeyboardMETA keyboard - char text[XR_MAX_VIRTUAL_KEYBOARD_COMMIT_TEXT_SIZE_META] - - - - XrStructureType type - const void* next - XrVirtualKeyboardMETA keyboard - - - - XrStructureType type - const void* next - XrVirtualKeyboardMETA keyboard - - - - XrStructureType type - const void* next - XrVirtualKeyboardMETA keyboard - - - - XrStructureType type - const void* next - XrVirtualKeyboardMETA keyboard - - - - - XrStructureType type - const void* next - XrBool32 enabled - - - - XrStructureType type - const void* next - XrHeadsetFitStatusML status - XrTime time - - - - XrStructureType type - const void* next - XrEyeCalibrationStatusML status - - - - - XrStructureType type - void* next - char name[XR_MAX_LOCALIZATION_MAP_NAME_LENGTH_ML] - XrUuidEXT mapUuid - XrLocalizationMapTypeML mapType - - - - XrStructureType type - const void* next - XrBool32 enabled - - - - XrStructureType type - const void* next - XrSession session - XrLocalizationMapStateML state - XrLocalizationMapML map - XrLocalizationMapConfidenceML confidence - XrLocalizationMapErrorFlagsML errorFlags - - - - XrStructureType type - const void* next - - - - XrStructureType type - const void* next - XrUuidEXT mapUuid - - - - XrStructureType type - const void* next - uint32_t size - char* data - - - - - - XrStructureType type - void* next - XrBool32 supportsMarkerUnderstanding - - - - XrStructureType type - const void* next - XrMarkerDetectorProfileML profile - XrMarkerTypeML markerType - - - - XrStructureType type - const void* next - XrMarkerArucoDictML arucoDict - - - - XrStructureType type - const void* next - float markerLength - - - - XrStructureType type - const void* next - XrMarkerAprilTagDictML aprilTagDict - - - - XrStructureType type - const void* next - XrMarkerDetectorFpsML fpsHint - XrMarkerDetectorResolutionML resolutionHint - XrMarkerDetectorCameraML cameraHint - XrMarkerDetectorCornerRefineMethodML cornerRefineMethod - XrBool32 useEdgeRefinement - XrMarkerDetectorFullAnalysisIntervalML fullAnalysisIntervalHint - - - - XrStructureType type - const void* next - - - - XrStructureType type - void* next - XrMarkerDetectorStatusML state - - - - XrStructureType type - const void* next - XrMarkerDetectorML markerDetector - XrMarkerML marker - XrPosef poseInMarkerSpace - - - float r - float g - float b - - - - float width - float height - float depth - - - - XrPosef center - float radius - - - - XrPosef center - XrExtent3Df extents - - - - XrPosef pose - XrFovf fov - float nearZ - float farZ - - - - uint8_t data[XR_UUID_SIZE] - - - - - - - - - - - - - - - - XrStructureType type - void* next - XrExtent2Di recommendedImageDimensions - XrBool32 isValid - - - - XrStructureType type - const void* next - const XrCompositionLayerBaseHeader* layer - XrTime predictedDisplayTime - - - - - XrStructureType type - void* next - XrBool32 supportsUserPresence - - - - XrStructureType type - const void* next - XrSession session - XrBool32 isUserPresent - - - - - - XrStructureType type - void* next - XrResult futureResult - - - - XrStructureType type - void* next - XrResult futureResult - - - - XrStructureType type - const void* next - XrFutureEXT future - - - - XrStructureType type - const void* next - XrFutureEXT future - - - - XrStructureType type - void* next - XrFutureStateEXT state - - - - - - - XrStructureType type - const void* next - XrEnvironmentDepthProviderCreateFlagsMETA createFlags - - - XrStructureType type - const void* next - XrEnvironmentDepthSwapchainCreateFlagsMETA createFlags - - - XrStructureType type - void* next - uint32_t width - uint32_t height - - - XrStructureType type - const void* next - XrSpace space - XrTime displayTime - - - XrStructureType type - const void* next - XrFovf fov - XrPosef pose - - - XrStructureType type - const void* next - uint32_t swapchainIndex - float nearZ - float farZ - XrEnvironmentDepthImageViewMETA views[2] - - - XrStructureType type - const void* next - XrBool32 enabled - - - XrStructureType type - void* next - XrBool32 supportsEnvironmentDepth - XrBool32 supportsHandRemoval - - - - - - XrStructureType type - const void* next - XrSpace baseSpace - XrTime time - uint32_t spaceCount - const XrSpace* spaces - - - - - XrStructureType type - void* next - uint32_t locationCount - XrSpaceLocationData* locations - - - - - XrSpaceLocationFlags locationFlags - XrPosef pose - - - - - XrStructureType type - void* next - uint32_t velocityCount - XrSpaceVelocityData* velocities - - - - - XrSpaceVelocityFlags velocityFlags - XrVector3f linearVelocity - XrVector3f angularVelocity - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - XrResult xrNegotiateLoaderRuntimeInterface - const XrNegotiateLoaderInfo* loaderInfo - XrNegotiateRuntimeRequest* runtimeRequest - - - XrResult xrNegotiateLoaderApiLayerInterface - const XrNegotiateLoaderInfo* loaderInfo - const char* layerName - XrNegotiateApiLayerRequest* apiLayerRequest - - - XrResult xrCreateApiLayerInstance - const XrInstanceCreateInfo* info - const XrApiLayerCreateInfo* layerInfo - XrInstance* instance - - - - - - - - XrResult xrGetInstanceProcAddr - XrInstance instance - const char* name - PFN_xrVoidFunction* function - - - XrResult xrEnumerateApiLayerProperties - uint32_t propertyCapacityInput - uint32_t* propertyCountOutput - XrApiLayerProperties* properties - - - XrResult xrEnumerateInstanceExtensionProperties - const char* layerName - uint32_t propertyCapacityInput - uint32_t* propertyCountOutput - XrExtensionProperties* properties - - - XrResult xrCreateInstance - const XrInstanceCreateInfo* createInfo - XrInstance* instance - - - XrResult xrDestroyInstance - XrInstance instance - - - XrResult xrResultToString - XrInstance instance - XrResult value - char buffer[XR_MAX_RESULT_STRING_SIZE] - - - XrResult xrStructureTypeToString - XrInstance instance - XrStructureType value - char buffer[XR_MAX_STRUCTURE_NAME_SIZE] - - - XrResult xrGetInstanceProperties - XrInstance instance - XrInstanceProperties* instanceProperties - - - XrResult xrGetSystem - XrInstance instance - const XrSystemGetInfo* getInfo - XrSystemId* systemId - - - XrResult xrGetSystemProperties - XrInstance instance - XrSystemId systemId - XrSystemProperties* properties - - - XrResult xrCreateSession - XrInstance instance - const XrSessionCreateInfo* createInfo - XrSession* session - - - XrResult xrDestroySession - XrSession session - - - XrResult xrDestroySpace - XrSpace space - - - XrResult xrEnumerateSwapchainFormats - XrSession session - uint32_t formatCapacityInput - uint32_t* formatCountOutput - int64_t* formats - - - XrResult xrCreateSwapchain - XrSession session - const XrSwapchainCreateInfo* createInfo - XrSwapchain* swapchain - - - XrResult xrDestroySwapchain - XrSwapchain swapchain - - - XrResult xrEnumerateSwapchainImages - XrSwapchain swapchain - uint32_t imageCapacityInput - uint32_t* imageCountOutput - XrSwapchainImageBaseHeader* images - - - XrResult xrAcquireSwapchainImage - XrSwapchain swapchain - const XrSwapchainImageAcquireInfo* acquireInfo - uint32_t* index - - - XrResult xrWaitSwapchainImage - XrSwapchain swapchain - const XrSwapchainImageWaitInfo* waitInfo - - - XrResult xrReleaseSwapchainImage - XrSwapchain swapchain - const XrSwapchainImageReleaseInfo* releaseInfo - - - XrResult xrBeginSession - XrSession session - const XrSessionBeginInfo* beginInfo - - - XrResult xrEndSession - XrSession session - - - XrResult xrRequestExitSession - XrSession session - - - XrResult xrEnumerateReferenceSpaces - XrSession session - uint32_t spaceCapacityInput - uint32_t* spaceCountOutput - XrReferenceSpaceType* spaces - - - XrResult xrCreateReferenceSpace - XrSession session - const XrReferenceSpaceCreateInfo* createInfo - XrSpace* space - - - XrResult xrCreateActionSpace - XrSession session - const XrActionSpaceCreateInfo* createInfo - XrSpace* space - - - XrResult xrLocateSpace - XrSpace space - XrSpace baseSpace - XrTime time - XrSpaceLocation* location - - - XrResult xrEnumerateViewConfigurations - XrInstance instance - XrSystemId systemId - uint32_t viewConfigurationTypeCapacityInput - uint32_t* viewConfigurationTypeCountOutput - XrViewConfigurationType* viewConfigurationTypes - - - XrResult xrEnumerateEnvironmentBlendModes - XrInstance instance - XrSystemId systemId - XrViewConfigurationType viewConfigurationType - uint32_t environmentBlendModeCapacityInput - uint32_t* environmentBlendModeCountOutput - XrEnvironmentBlendMode* environmentBlendModes - - - XrResult xrGetViewConfigurationProperties - XrInstance instance - XrSystemId systemId - XrViewConfigurationType viewConfigurationType - XrViewConfigurationProperties* configurationProperties - - - XrResult xrEnumerateViewConfigurationViews - XrInstance instance - XrSystemId systemId - XrViewConfigurationType viewConfigurationType - uint32_t viewCapacityInput - uint32_t* viewCountOutput - XrViewConfigurationView* views - - - XrResult xrBeginFrame - XrSession session - const XrFrameBeginInfo* frameBeginInfo - - the pname:session parameter by any other flink:xrBeginFrame or flink:xrEndFrame call - - - - XrResult xrLocateViews - XrSession session - const XrViewLocateInfo* viewLocateInfo - XrViewState* viewState - uint32_t viewCapacityInput - uint32_t* viewCountOutput - XrView* views - - - XrResult xrEndFrame - XrSession session - const XrFrameEndInfo* frameEndInfo - - the pname:session parameter by any other flink:xrBeginFrame or flink:xrEndFrame call - - - - XrResult xrWaitFrame - XrSession session - const XrFrameWaitInfo* frameWaitInfo - XrFrameState* frameState - - the pname:session parameter by any other flink:xrWaitFrame call - - - - XrResult xrApplyHapticFeedback - XrSession session - const XrHapticActionInfo* hapticActionInfo - const XrHapticBaseHeader* hapticFeedback - - - XrResult xrStopHapticFeedback - XrSession session - const XrHapticActionInfo* hapticActionInfo - - - XrResult xrPollEvent - XrInstance instance - XrEventDataBuffer* eventData - - - XrResult xrStringToPath - XrInstance instance - const char* pathString - XrPath* path - - - XrResult xrPathToString - XrInstance instance - XrPath path - uint32_t bufferCapacityInput - uint32_t* bufferCountOutput - char* buffer - - - XrResult xrGetReferenceSpaceBoundsRect - XrSession session - XrReferenceSpaceType referenceSpaceType - XrExtent2Df* bounds - - - XrResult xrSetAndroidApplicationThreadKHR - XrSession session - XrAndroidThreadTypeKHR threadType - uint32_t threadId - - - XrResult xrCreateSwapchainAndroidSurfaceKHR - XrSession session - const XrSwapchainCreateInfo* info - XrSwapchain* swapchain - jobject* surface - - - XrResult xrGetActionStateBoolean - XrSession session - const XrActionStateGetInfo* getInfo - XrActionStateBoolean* state - - - XrResult xrGetActionStateFloat - XrSession session - const XrActionStateGetInfo* getInfo - XrActionStateFloat* state - - - XrResult xrGetActionStateVector2f - XrSession session - const XrActionStateGetInfo* getInfo - XrActionStateVector2f* state - - - XrResult xrGetActionStatePose - XrSession session - const XrActionStateGetInfo* getInfo - XrActionStatePose* state - - - XrResult xrCreateActionSet - XrInstance instance - const XrActionSetCreateInfo* createInfo - XrActionSet* actionSet - - - XrResult xrDestroyActionSet - XrActionSet actionSet - - - XrResult xrCreateAction - XrActionSet actionSet - const XrActionCreateInfo* createInfo - XrAction* action - - - XrResult xrDestroyAction - XrAction action - - - XrResult xrSuggestInteractionProfileBindings - XrInstance instance - const XrInteractionProfileSuggestedBinding* suggestedBindings - - - XrResult xrAttachSessionActionSets - XrSession session - const XrSessionActionSetsAttachInfo* attachInfo - - - XrResult xrGetCurrentInteractionProfile - XrSession session - XrPath topLevelUserPath - XrInteractionProfileState* interactionProfile - - - XrResult xrSyncActions - XrSession session - const XrActionsSyncInfo* syncInfo - - - XrResult xrEnumerateBoundSourcesForAction - XrSession session - const XrBoundSourcesForActionEnumerateInfo* enumerateInfo - uint32_t sourceCapacityInput - uint32_t* sourceCountOutput - XrPath* sources - - - XrResult xrGetInputSourceLocalizedName - XrSession session - const XrInputSourceLocalizedNameGetInfo* getInfo - uint32_t bufferCapacityInput - uint32_t* bufferCountOutput - char* buffer - - - XrResult xrGetVulkanInstanceExtensionsKHR - XrInstance instance - XrSystemId systemId - uint32_t bufferCapacityInput - uint32_t* bufferCountOutput - char* buffer - - - XrResult xrGetVulkanDeviceExtensionsKHR - XrInstance instance - XrSystemId systemId - uint32_t bufferCapacityInput - uint32_t* bufferCountOutput - char* buffer - - - XrResult xrGetVulkanGraphicsDeviceKHR - XrInstance instance - XrSystemId systemId - VkInstance vkInstance - VkPhysicalDevice* vkPhysicalDevice - - - XrResult xrGetOpenGLGraphicsRequirementsKHR - XrInstance instance - XrSystemId systemId - XrGraphicsRequirementsOpenGLKHR* graphicsRequirements - - - XrResult xrGetOpenGLESGraphicsRequirementsKHR - XrInstance instance - XrSystemId systemId - XrGraphicsRequirementsOpenGLESKHR* graphicsRequirements - - - XrResult xrGetVulkanGraphicsRequirementsKHR - XrInstance instance - XrSystemId systemId - XrGraphicsRequirementsVulkanKHR* graphicsRequirements - - - XrResult xrGetD3D11GraphicsRequirementsKHR - XrInstance instance - XrSystemId systemId - XrGraphicsRequirementsD3D11KHR* graphicsRequirements - - - XrResult xrGetD3D12GraphicsRequirementsKHR - XrInstance instance - XrSystemId systemId - XrGraphicsRequirementsD3D12KHR* graphicsRequirements - - - XrResult xrPerfSettingsSetPerformanceLevelEXT - XrSession session - XrPerfSettingsDomainEXT domain - XrPerfSettingsLevelEXT level - - - XrResult xrThermalGetTemperatureTrendEXT - XrSession session - XrPerfSettingsDomainEXT domain - XrPerfSettingsNotificationLevelEXT* notificationLevel - float* tempHeadroom - float* tempSlope - - - XrResult xrSetDebugUtilsObjectNameEXT - XrInstance instance - const XrDebugUtilsObjectNameInfoEXT* nameInfo - - - XrResult xrCreateDebugUtilsMessengerEXT - XrInstance instance - const XrDebugUtilsMessengerCreateInfoEXT* createInfo - XrDebugUtilsMessengerEXT* messenger - - - XrResult xrDestroyDebugUtilsMessengerEXT - XrDebugUtilsMessengerEXT messenger - - the slink:XrInstance used to create pname:messenger, and all of its child handles - - - - XrResult xrSubmitDebugUtilsMessageEXT - XrInstance instance - XrDebugUtilsMessageSeverityFlagsEXT messageSeverity - XrDebugUtilsMessageTypeFlagsEXT messageTypes - const XrDebugUtilsMessengerCallbackDataEXT* callbackData - - - XrResult xrSessionBeginDebugUtilsLabelRegionEXT - XrSession session - const XrDebugUtilsLabelEXT* labelInfo - - - XrResult xrSessionEndDebugUtilsLabelRegionEXT - XrSession session - - - XrResult xrSessionInsertDebugUtilsLabelEXT - XrSession session - const XrDebugUtilsLabelEXT* labelInfo - - - - - XrResult xrConvertTimeToWin32PerformanceCounterKHR - XrInstance instance - XrTime time - LARGE_INTEGER* performanceCounter - - - XrResult xrConvertWin32PerformanceCounterToTimeKHR - XrInstance instance - const LARGE_INTEGER* performanceCounter - XrTime* time - - - - - XrResult xrCreateVulkanInstanceKHR - XrInstance instance - const XrVulkanInstanceCreateInfoKHR* createInfo - VkInstance* vulkanInstance - VkResult* vulkanResult - - - XrResult xrCreateVulkanDeviceKHR - XrInstance instance - const XrVulkanDeviceCreateInfoKHR* createInfo - VkDevice* vulkanDevice - VkResult* vulkanResult - - - XrResult xrGetVulkanGraphicsDevice2KHR - XrInstance instance - const XrVulkanGraphicsDeviceGetInfoKHR* getInfo - VkPhysicalDevice* vulkanPhysicalDevice - - - - - - XrResult xrConvertTimeToTimespecTimeKHR - XrInstance instance - XrTime time - struct timespec* timespecTime - - - XrResult xrConvertTimespecTimeToTimeKHR - XrInstance instance - const struct timespec* timespecTime - XrTime* time - - - - - XrResult xrGetVisibilityMaskKHR - XrSession session - XrViewConfigurationType viewConfigurationType - uint32_t viewIndex - XrVisibilityMaskTypeKHR visibilityMaskType - XrVisibilityMaskKHR* visibilityMask - - - - - XrResult xrCreateSpatialAnchorMSFT - XrSession session - const XrSpatialAnchorCreateInfoMSFT* createInfo - XrSpatialAnchorMSFT* anchor - - - XrResult xrCreateSpatialAnchorSpaceMSFT - XrSession session - const XrSpatialAnchorSpaceCreateInfoMSFT* createInfo - XrSpace* space - - - XrResult xrDestroySpatialAnchorMSFT - XrSpatialAnchorMSFT anchor - - - - - XrResult xrSetInputDeviceActiveEXT - XrSession session - XrPath interactionProfile - XrPath topLevelPath - XrBool32 isActive - - - XrResult xrSetInputDeviceStateBoolEXT - XrSession session - XrPath topLevelPath - XrPath inputSourcePath - XrBool32 state - - - XrResult xrSetInputDeviceStateFloatEXT - XrSession session - XrPath topLevelPath - XrPath inputSourcePath - float state - - - XrResult xrSetInputDeviceStateVector2fEXT - XrSession session - XrPath topLevelPath - XrPath inputSourcePath - XrVector2f state - - - XrResult xrSetInputDeviceLocationEXT - XrSession session - XrPath topLevelPath - XrPath inputSourcePath - XrSpace space - XrPosef pose - - - - - XrResult xrInitializeLoaderKHR - const XrLoaderInitInfoBaseHeaderKHR* loaderInitInfo - - - - - XrResult xrCreateSpatialGraphNodeSpaceMSFT - XrSession session - const XrSpatialGraphNodeSpaceCreateInfoMSFT* createInfo - XrSpace* space - - - XrResult xrTryCreateSpatialGraphStaticNodeBindingMSFT - XrSession session - const XrSpatialGraphStaticNodeBindingCreateInfoMSFT* createInfo - XrSpatialGraphNodeBindingMSFT* nodeBinding - - - XrResult xrDestroySpatialGraphNodeBindingMSFT - XrSpatialGraphNodeBindingMSFT nodeBinding - - - XrResult xrGetSpatialGraphNodeBindingPropertiesMSFT - XrSpatialGraphNodeBindingMSFT nodeBinding - const XrSpatialGraphNodeBindingPropertiesGetInfoMSFT* getInfo - XrSpatialGraphNodeBindingPropertiesMSFT* properties - - - - - XrResult xrCreateHandTrackerEXT - XrSession session - const XrHandTrackerCreateInfoEXT* createInfo - XrHandTrackerEXT* handTracker - - - XrResult xrDestroyHandTrackerEXT - XrHandTrackerEXT handTracker - - - XrResult xrLocateHandJointsEXT - XrHandTrackerEXT handTracker - const XrHandJointsLocateInfoEXT* locateInfo - XrHandJointLocationsEXT* locations - - - - - XrResult xrCreateFaceTrackerFB - XrSession session - const XrFaceTrackerCreateInfoFB* createInfo - XrFaceTrackerFB* faceTracker - - - XrResult xrDestroyFaceTrackerFB - XrFaceTrackerFB faceTracker - - - XrResult xrGetFaceExpressionWeightsFB - XrFaceTrackerFB faceTracker - const XrFaceExpressionInfoFB* expressionInfo - XrFaceExpressionWeightsFB* expressionWeights - - - - - XrResult xrCreateFaceTracker2FB - XrSession session - const XrFaceTrackerCreateInfo2FB* createInfo - XrFaceTracker2FB* faceTracker - - - XrResult xrDestroyFaceTracker2FB - XrFaceTracker2FB faceTracker - - - XrResult xrGetFaceExpressionWeights2FB - XrFaceTracker2FB faceTracker - const XrFaceExpressionInfo2FB* expressionInfo - XrFaceExpressionWeights2FB* expressionWeights - - - - - XrResult xrCreateBodyTrackerFB - XrSession session - const XrBodyTrackerCreateInfoFB* createInfo - XrBodyTrackerFB* bodyTracker - - - XrResult xrDestroyBodyTrackerFB - XrBodyTrackerFB bodyTracker - - - XrResult xrLocateBodyJointsFB - XrBodyTrackerFB bodyTracker - const XrBodyJointsLocateInfoFB* locateInfo - XrBodyJointLocationsFB* locations - - - XrResult xrGetBodySkeletonFB - XrBodyTrackerFB bodyTracker - XrBodySkeletonFB* skeleton - - - - - XrResult xrCreateEyeTrackerFB - XrSession session - const XrEyeTrackerCreateInfoFB* createInfo - XrEyeTrackerFB* eyeTracker - - - XrResult xrDestroyEyeTrackerFB - XrEyeTrackerFB eyeTracker - - - XrResult xrGetEyeGazesFB - XrEyeTrackerFB eyeTracker - const XrEyeGazesInfoFB* gazeInfo - XrEyeGazesFB* eyeGazes - - - - - XrResult xrCreateHandMeshSpaceMSFT - XrHandTrackerEXT handTracker - const XrHandMeshSpaceCreateInfoMSFT* createInfo - XrSpace* space - - - XrResult xrUpdateHandMeshMSFT - XrHandTrackerEXT handTracker - const XrHandMeshUpdateInfoMSFT* updateInfo - XrHandMeshMSFT* handMesh - - - - - XrResult xrGetControllerModelKeyMSFT - XrSession session - XrPath topLevelUserPath - XrControllerModelKeyStateMSFT* controllerModelKeyState - - - XrResult xrLoadControllerModelMSFT - XrSession session - XrControllerModelKeyMSFT modelKey - uint32_t bufferCapacityInput - uint32_t* bufferCountOutput - uint8_t* buffer - - - XrResult xrGetControllerModelPropertiesMSFT - XrSession session - XrControllerModelKeyMSFT modelKey - XrControllerModelPropertiesMSFT* properties - - - XrResult xrGetControllerModelStateMSFT - XrSession session - XrControllerModelKeyMSFT modelKey - XrControllerModelStateMSFT* state - - - - - XrResult xrEnumerateSceneComputeFeaturesMSFT - XrInstance instance - XrSystemId systemId - uint32_t featureCapacityInput - uint32_t* featureCountOutput - XrSceneComputeFeatureMSFT* features - - - XrResult xrCreateSceneObserverMSFT - XrSession session - const XrSceneObserverCreateInfoMSFT* createInfo - XrSceneObserverMSFT* sceneObserver - - - XrResult xrDestroySceneObserverMSFT - XrSceneObserverMSFT sceneObserver - - - XrResult xrCreateSceneMSFT - XrSceneObserverMSFT sceneObserver - const XrSceneCreateInfoMSFT* createInfo - XrSceneMSFT* scene - - - XrResult xrDestroySceneMSFT - XrSceneMSFT scene - - - XrResult xrComputeNewSceneMSFT - XrSceneObserverMSFT sceneObserver - const XrNewSceneComputeInfoMSFT* computeInfo - - - XrResult xrGetSceneComputeStateMSFT - XrSceneObserverMSFT sceneObserver - XrSceneComputeStateMSFT* state - - - XrResult xrGetSceneComponentsMSFT - XrSceneMSFT scene - const XrSceneComponentsGetInfoMSFT* getInfo - XrSceneComponentsMSFT* components - - - XrResult xrLocateSceneComponentsMSFT - XrSceneMSFT scene - const XrSceneComponentsLocateInfoMSFT* locateInfo - XrSceneComponentLocationsMSFT* locations - - - XrResult xrGetSceneMeshBuffersMSFT - XrSceneMSFT scene - const XrSceneMeshBuffersGetInfoMSFT* getInfo - XrSceneMeshBuffersMSFT* buffers - - - - - XrResult xrDeserializeSceneMSFT - XrSceneObserverMSFT sceneObserver - const XrSceneDeserializeInfoMSFT* deserializeInfo - - - XrResult xrGetSerializedSceneFragmentDataMSFT - XrSceneMSFT scene - const XrSerializedSceneFragmentDataGetInfoMSFT* getInfo - uint32_t countInput - uint32_t* readOutput - uint8_t* buffer - - - - - XrResult xrGetSceneMarkerRawDataMSFT - XrSceneMSFT scene - const XrUuidMSFT* markerId - uint32_t bufferCapacityInput - uint32_t* bufferCountOutput - uint8_t* buffer - - - XrResult xrGetSceneMarkerDecodedStringMSFT - XrSceneMSFT scene - const XrUuidMSFT* markerId - uint32_t bufferCapacityInput - uint32_t* bufferCountOutput - char* buffer - - - - - XrResult xrEnumerateDisplayRefreshRatesFB - XrSession session - uint32_t displayRefreshRateCapacityInput - uint32_t* displayRefreshRateCountOutput - float* displayRefreshRates - - - XrResult xrGetDisplayRefreshRateFB - XrSession session - float* displayRefreshRate - - - XrResult xrRequestDisplayRefreshRateFB - XrSession session - float displayRefreshRate - - - - - XrResult xrCreateSpatialAnchorFromPerceptionAnchorMSFT - XrSession session - IUnknown* perceptionAnchor - XrSpatialAnchorMSFT* anchor - - - XrResult xrTryGetPerceptionAnchorFromSpatialAnchorMSFT - XrSession session - XrSpatialAnchorMSFT anchor - IUnknown** perceptionAnchor - - - - - XrResult xrUpdateSwapchainFB - XrSwapchain swapchain - const XrSwapchainStateBaseHeaderFB* state - - - - XrResult xrGetSwapchainStateFB - XrSwapchain swapchain - XrSwapchainStateBaseHeaderFB* state - - - - - XrResult xrEnumerateColorSpacesFB - XrSession session - uint32_t colorSpaceCapacityInput - uint32_t* colorSpaceCountOutput - XrColorSpaceFB* colorSpaces - - - XrResult xrSetColorSpaceFB - XrSession session - const XrColorSpaceFB colorSpace - - - - - XrResult xrCreateFoveationProfileFB - XrSession session - const XrFoveationProfileCreateInfoFB* createInfo - XrFoveationProfileFB* profile - - - XrResult xrDestroyFoveationProfileFB - XrFoveationProfileFB profile - - - - - XrResult xrGetFoveationEyeTrackedStateMETA - XrSession session - XrFoveationEyeTrackedStateMETA* foveationState - - - - - XrResult xrGetHandMeshFB - XrHandTrackerEXT handTracker - XrHandTrackingMeshFB* mesh - - - - - XrResult xrEnumerateRenderModelPathsFB - XrSession session - uint32_t pathCapacityInput - uint32_t* pathCountOutput - XrRenderModelPathInfoFB* paths - - - XrResult xrGetRenderModelPropertiesFB - XrSession session - XrPath path - XrRenderModelPropertiesFB* properties - - - XrResult xrLoadRenderModelFB - XrSession session - const XrRenderModelLoadInfoFB* info - XrRenderModelBufferFB* buffer - - - - - XrResult xrQuerySystemTrackedKeyboardFB - XrSession session - const XrKeyboardTrackingQueryFB* queryInfo - XrKeyboardTrackingDescriptionFB* keyboard - - - XrResult xrCreateKeyboardSpaceFB - XrSession session - const XrKeyboardSpaceCreateInfoFB* createInfo - XrSpace* keyboardSpace - - - - - XrResult xrSetEnvironmentDepthEstimationVARJO - XrSession session - XrBool32 enabled - - - - - XrResult xrEnumerateReprojectionModesMSFT - XrInstance instance - XrSystemId systemId - XrViewConfigurationType viewConfigurationType - uint32_t modeCapacityInput - uint32_t* modeCountOutput - XrReprojectionModeMSFT* modes - - - - - XrResult xrGetAudioOutputDeviceGuidOculus - XrInstance instance - wchar_t buffer[XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS] - - - - XrResult xrGetAudioInputDeviceGuidOculus - XrInstance instance - wchar_t buffer[XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS] - - - - - XrResult xrCreateSpatialAnchorFB - XrSession session - const XrSpatialAnchorCreateInfoFB* info - XrAsyncRequestIdFB* requestId - - - XrResult xrGetSpaceUuidFB - XrSpace space - XrUuidEXT* uuid - - - XrResult xrEnumerateSpaceSupportedComponentsFB - XrSpace space - uint32_t componentTypeCapacityInput - uint32_t* componentTypeCountOutput - XrSpaceComponentTypeFB* componentTypes - - - XrResult xrSetSpaceComponentStatusFB - XrSpace space - const XrSpaceComponentStatusSetInfoFB* info - XrAsyncRequestIdFB* requestId - - - XrResult xrGetSpaceComponentStatusFB - XrSpace space - XrSpaceComponentTypeFB componentType - XrSpaceComponentStatusFB* status - - - - - XrResult xrCreateTriangleMeshFB - XrSession session - const XrTriangleMeshCreateInfoFB* createInfo - XrTriangleMeshFB* outTriangleMesh - - - XrResult xrDestroyTriangleMeshFB - XrTriangleMeshFB mesh - - the buffers returned from calls to flink:xrTriangleMeshGetVertexBufferFB and flink:xrTriangleMeshGetIndexBufferFB on pname:mesh - - - - XrResult xrTriangleMeshGetVertexBufferFB - XrTriangleMeshFB mesh - XrVector3f** outVertexBuffer - - - XrResult xrTriangleMeshGetIndexBufferFB - XrTriangleMeshFB mesh - uint32_t** outIndexBuffer - - - XrResult xrTriangleMeshBeginUpdateFB - XrTriangleMeshFB mesh - - - XrResult xrTriangleMeshEndUpdateFB - XrTriangleMeshFB mesh - uint32_t vertexCount - uint32_t triangleCount - - - XrResult xrTriangleMeshBeginVertexBufferUpdateFB - XrTriangleMeshFB mesh - uint32_t* outVertexCount - - - XrResult xrTriangleMeshEndVertexBufferUpdateFB - XrTriangleMeshFB mesh - - - - - XrResult xrCreatePassthroughFB - XrSession session - const XrPassthroughCreateInfoFB* createInfo - XrPassthroughFB* outPassthrough - - - XrResult xrDestroyPassthroughFB - XrPassthroughFB passthrough - - - XrResult xrPassthroughStartFB - XrPassthroughFB passthrough - - - XrResult xrPassthroughPauseFB - XrPassthroughFB passthrough - - - XrResult xrCreatePassthroughLayerFB - XrSession session - const XrPassthroughLayerCreateInfoFB* createInfo - XrPassthroughLayerFB* outLayer - - - XrResult xrDestroyPassthroughLayerFB - XrPassthroughLayerFB layer - - - XrResult xrPassthroughLayerPauseFB - XrPassthroughLayerFB layer - - - XrResult xrPassthroughLayerResumeFB - XrPassthroughLayerFB layer - - - XrResult xrPassthroughLayerSetStyleFB - XrPassthroughLayerFB layer - const XrPassthroughStyleFB* style - - - XrResult xrCreateGeometryInstanceFB - XrSession session - const XrGeometryInstanceCreateInfoFB* createInfo - XrGeometryInstanceFB* outGeometryInstance - - - XrResult xrDestroyGeometryInstanceFB - XrGeometryInstanceFB instance - - - XrResult xrGeometryInstanceSetTransformFB - XrGeometryInstanceFB instance - const XrGeometryInstanceTransformFB* transformation - - - - - XrResult xrQuerySpacesFB - XrSession session - const XrSpaceQueryInfoBaseHeaderFB* info - XrAsyncRequestIdFB* requestId - - - XrResult xrRetrieveSpaceQueryResultsFB - XrSession session - XrAsyncRequestIdFB requestId - XrSpaceQueryResultsFB* results - - - - - XrResult xrSaveSpaceFB - XrSession session - const XrSpaceSaveInfoFB* info - XrAsyncRequestIdFB* requestId - - - XrResult xrEraseSpaceFB - XrSession session - const XrSpaceEraseInfoFB* info - XrAsyncRequestIdFB* requestId - - - - - XrResult xrSaveSpaceListFB - XrSession session - const XrSpaceListSaveInfoFB* info - XrAsyncRequestIdFB* requestId - - - - - XrResult xrShareSpacesFB - XrSession session - const XrSpaceShareInfoFB* info - XrAsyncRequestIdFB* requestId - - - - - XrResult xrGetSpaceContainerFB - XrSession session - XrSpace space - XrSpaceContainerFB* spaceContainerOutput - - - - - XrResult xrGetSpaceTriangleMeshMETA - XrSpace space - const XrSpaceTriangleMeshGetInfoMETA* getInfo - XrSpaceTriangleMeshMETA* triangleMeshOutput - - - - - XrResult xrGetSpaceBoundingBox2DFB - XrSession session - XrSpace space - XrRect2Df* boundingBox2DOutput - - - XrResult xrGetSpaceBoundingBox3DFB - XrSession session - XrSpace space - XrRect3DfFB* boundingBox3DOutput - - - XrResult xrGetSpaceSemanticLabelsFB - XrSession session - XrSpace space - XrSemanticLabelsFB* semanticLabelsOutput - - - XrResult xrGetSpaceBoundary2DFB - XrSession session - XrSpace space - XrBoundary2DFB* boundary2DOutput - - - XrResult xrGetSpaceRoomLayoutFB - XrSession session - XrSpace space - XrRoomLayoutFB* roomLayoutOutput - - - - - XrResult xrRequestSceneCaptureFB - XrSession session - const XrSceneCaptureRequestInfoFB* info - XrAsyncRequestIdFB* requestId - - - - - XrResult xrPassthroughLayerSetKeyboardHandsIntensityFB - XrPassthroughLayerFB layer - const XrPassthroughKeyboardHandsIntensityFB* intensity - - - - - XrResult xrCreateSpatialAnchorStoreConnectionMSFT - XrSession session - XrSpatialAnchorStoreConnectionMSFT* spatialAnchorStore - - - XrResult xrDestroySpatialAnchorStoreConnectionMSFT - XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore - - - XrResult xrPersistSpatialAnchorMSFT - XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore - const XrSpatialAnchorPersistenceInfoMSFT* spatialAnchorPersistenceInfo - - - XrResult xrEnumeratePersistedSpatialAnchorNamesMSFT - XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore - uint32_t spatialAnchorNameCapacityInput - uint32_t* spatialAnchorNameCountOutput - XrSpatialAnchorPersistenceNameMSFT* spatialAnchorNames - - - XrResult xrCreateSpatialAnchorFromPersistedNameMSFT - XrSession session - const XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT* spatialAnchorCreateInfo - XrSpatialAnchorMSFT* spatialAnchor - - - XrResult xrUnpersistSpatialAnchorMSFT - XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore - const XrSpatialAnchorPersistenceNameMSFT* spatialAnchorPersistenceName - - - XrResult xrClearSpatialAnchorStoreMSFT - XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore - - - - - XrResult xrCreateFacialTrackerHTC - XrSession session - const XrFacialTrackerCreateInfoHTC* createInfo - XrFacialTrackerHTC* facialTracker - - - XrResult xrDestroyFacialTrackerHTC - XrFacialTrackerHTC facialTracker - - - XrResult xrGetFacialExpressionsHTC - XrFacialTrackerHTC facialTracker - XrFacialExpressionsHTC* facialExpressions - - - - - XrResult xrCreatePassthroughHTC - XrSession session - const XrPassthroughCreateInfoHTC* createInfo - XrPassthroughHTC* passthrough - - - XrResult xrDestroyPassthroughHTC - XrPassthroughHTC passthrough - - - - - XrResult xrCreateSpatialAnchorHTC - XrSession session - const XrSpatialAnchorCreateInfoHTC* createInfo - XrSpace* anchor - - - XrResult xrGetSpatialAnchorNameHTC - XrSpace anchor - XrSpatialAnchorNameHTC* name - - - - - XrResult xrEnumerateViveTrackerPathsHTCX - XrInstance instance - uint32_t pathCapacityInput - uint32_t* pathCountOutput - XrViveTrackerPathsHTCX* paths - - - - - XrResult xrSetMarkerTrackingVARJO - XrSession session - XrBool32 enabled - - - - XrResult xrSetMarkerTrackingTimeoutVARJO - XrSession session - uint64_t markerId - XrDuration timeout - - - - XrResult xrSetMarkerTrackingPredictionVARJO - XrSession session - uint64_t markerId - XrBool32 enable - - - - XrResult xrGetMarkerSizeVARJO - XrSession session - uint64_t markerId - XrExtent2Df* size - - - - XrResult xrCreateMarkerSpaceVARJO - XrSession session - const XrMarkerSpaceCreateInfoVARJO* createInfo - XrSpace* space - - - - - XrResult xrSetDigitalLensControlALMALENCE - XrSession session - const XrDigitalLensControlALMALENCE* digitalLensControl - - - - - XrResult xrSetViewOffsetVARJO - XrSession session - float offset - - - - - XrResult xrEnumerateExternalCamerasOCULUS - XrSession session - uint32_t cameraCapacityInput - uint32_t* cameraCountOutput - XrExternalCameraOCULUS* cameras - - - - - XrResult xrCreatePassthroughColorLutMETA - XrPassthroughFB passthrough - const XrPassthroughColorLutCreateInfoMETA* createInfo - XrPassthroughColorLutMETA* colorLut - - - - XrResult xrDestroyPassthroughColorLutMETA - XrPassthroughColorLutMETA colorLut - - - - XrResult xrUpdatePassthroughColorLutMETA - XrPassthroughColorLutMETA colorLut - const XrPassthroughColorLutUpdateInfoMETA* updateInfo - - - - - XrResult xrEnumeratePerformanceMetricsCounterPathsMETA - XrInstance instance - uint32_t counterPathCapacityInput - uint32_t* counterPathCountOutput - XrPath* counterPaths - - - - XrResult xrSetPerformanceMetricsStateMETA - XrSession session - const XrPerformanceMetricsStateMETA* state - - - - XrResult xrGetPerformanceMetricsStateMETA - XrSession session - XrPerformanceMetricsStateMETA* state - - - - XrResult xrQueryPerformanceMetricsCounterMETA - XrSession session - XrPath counterPath - XrPerformanceMetricsCounterMETA* counter - - - - - XrResult xrGetPassthroughPreferencesMETA - XrSession session - XrPassthroughPreferencesMETA* preferences - - - - - XrResult xrApplyFoveationHTC - XrSession session - const XrFoveationApplyInfoHTC* applyInfo - - - - - - XrResult xrCreateSpaceFromCoordinateFrameUIDML - XrSession session - const XrCoordinateSpaceCreateInfoML *createInfo - XrSpace* space - - - - - XrResult xrGetDeviceSampleRateFB - XrSession session - const XrHapticActionInfo* hapticActionInfo - XrDevicePcmSampleRateGetInfoFB* deviceSampleRate - - - - - XrResult xrSetTrackingOptimizationSettingsHintQCOM - XrSession session - XrTrackingOptimizationSettingsDomainQCOM domain - XrTrackingOptimizationSettingsHintQCOM hint - - - - - XrResult xrCreateSpaceUserFB - XrSession session - const XrSpaceUserCreateInfoFB* info - XrSpaceUserFB* user - - - XrResult xrGetSpaceUserIdFB - XrSpaceUserFB user - XrSpaceUserIdFB* userId - - - XrResult xrDestroySpaceUserFB - XrSpaceUserFB user - - - - - XrResult xrGetRecommendedLayerResolutionMETA - XrSession session - const XrRecommendedLayerResolutionGetInfoMETA* info - XrRecommendedLayerResolutionMETA* resolution - - - - - XrResult xrApplyForceFeedbackCurlMNDX - XrHandTrackerEXT handTracker - const XrForceFeedbackCurlApplyLocationsMNDX* locations - - - - - XrResult xrCreatePlaneDetectorEXT - XrSession session - const XrPlaneDetectorCreateInfoEXT* createInfo - XrPlaneDetectorEXT* planeDetector - - - - XrResult xrDestroyPlaneDetectorEXT - XrPlaneDetectorEXT planeDetector - - - - XrResult xrBeginPlaneDetectionEXT - XrPlaneDetectorEXT planeDetector - const XrPlaneDetectorBeginInfoEXT* beginInfo - - - - XrResult xrGetPlaneDetectionStateEXT - XrPlaneDetectorEXT planeDetector - XrPlaneDetectionStateEXT* state - - - - XrResult xrGetPlaneDetectionsEXT - XrPlaneDetectorEXT planeDetector - const XrPlaneDetectorGetInfoEXT* info - XrPlaneDetectorLocationsEXT* locations - - - - XrResult xrGetPlanePolygonBufferEXT - XrPlaneDetectorEXT planeDetector - uint64_t planeId - uint32_t polygonBufferIndex - XrPlaneDetectorPolygonBufferEXT* polygonBuffer - - - - - XrResult xrCreateVirtualKeyboardMETA - XrSession session - const XrVirtualKeyboardCreateInfoMETA* createInfo - XrVirtualKeyboardMETA* keyboard - - - - XrResult xrDestroyVirtualKeyboardMETA - XrVirtualKeyboardMETA keyboard - - - - XrResult xrCreateVirtualKeyboardSpaceMETA - XrSession session - XrVirtualKeyboardMETA keyboard - const XrVirtualKeyboardSpaceCreateInfoMETA* createInfo - XrSpace* keyboardSpace - - - - XrResult xrSuggestVirtualKeyboardLocationMETA - XrVirtualKeyboardMETA keyboard - const XrVirtualKeyboardLocationInfoMETA* locationInfo - - - - XrResult xrGetVirtualKeyboardScaleMETA - XrVirtualKeyboardMETA keyboard - float* scale - - - - XrResult xrSetVirtualKeyboardModelVisibilityMETA - XrVirtualKeyboardMETA keyboard - const XrVirtualKeyboardModelVisibilitySetInfoMETA* modelVisibility - - - - XrResult xrGetVirtualKeyboardModelAnimationStatesMETA - XrVirtualKeyboardMETA keyboard - XrVirtualKeyboardModelAnimationStatesMETA* animationStates - - - - XrResult xrGetVirtualKeyboardDirtyTexturesMETA - XrVirtualKeyboardMETA keyboard - uint32_t textureIdCapacityInput - uint32_t* textureIdCountOutput - uint64_t* textureIds - - - - XrResult xrGetVirtualKeyboardTextureDataMETA - XrVirtualKeyboardMETA keyboard - uint64_t textureId - XrVirtualKeyboardTextureDataMETA* textureData - - - - XrResult xrSendVirtualKeyboardInputMETA - XrVirtualKeyboardMETA keyboard - const XrVirtualKeyboardInputInfoMETA* info - XrPosef* interactorRootPose - - - - XrResult xrChangeVirtualKeyboardTextContextMETA - XrVirtualKeyboardMETA keyboard - const XrVirtualKeyboardTextContextChangeInfoMETA* changeInfo - - - - - XrResult xrEnableUserCalibrationEventsML - XrInstance instance - const XrUserCalibrationEnableEventsInfoML* enableInfo - - - - - XrResult xrEnableLocalizationEventsML - XrSession session - const XrLocalizationEnableEventsInfoML * info - - - - XrResult xrQueryLocalizationMapsML - XrSession session - const XrLocalizationMapQueryInfoBaseHeaderML* queryInfo - uint32_t mapCapacityInput - uint32_t * mapCountOutput - XrLocalizationMapML* maps - - - - XrResult xrRequestMapLocalizationML - XrSession session - const XrMapLocalizationRequestInfoML* requestInfo - - - - XrResult xrImportLocalizationMapML - XrSession session - const XrLocalizationMapImportInfoML* importInfo - XrUuidEXT* mapUuid - - - - XrResult xrCreateExportedLocalizationMapML - XrSession session - const XrUuidEXT* mapUuid - XrExportedLocalizationMapML* map - - - - XrResult xrDestroyExportedLocalizationMapML - XrExportedLocalizationMapML map - - - - XrResult xrGetExportedLocalizationMapDataML - XrExportedLocalizationMapML map - uint32_t bufferCapacityInput - uint32_t* bufferCountOutput - char* buffer - - - - - XrResult xrCreateMarkerDetectorML - XrSession session - const XrMarkerDetectorCreateInfoML* createInfo - XrMarkerDetectorML* markerDetector - - - XrResult xrDestroyMarkerDetectorML - XrMarkerDetectorML markerDetector - - - XrResult xrSnapshotMarkerDetectorML - XrMarkerDetectorML markerDetector - XrMarkerDetectorSnapshotInfoML* snapshotInfo - - - XrResult xrGetMarkerDetectorStateML - XrMarkerDetectorML markerDetector - XrMarkerDetectorStateML* state - - - XrResult xrGetMarkersML - XrMarkerDetectorML markerDetector - uint32_t markerCapacityInput - uint32_t* markerCountOutput - XrMarkerML* markers - - - XrResult xrGetMarkerReprojectionErrorML - XrMarkerDetectorML markerDetector - XrMarkerML marker - float* reprojectionErrorMeters - - - XrResult xrGetMarkerLengthML - XrMarkerDetectorML markerDetector - XrMarkerML marker - float* meters - - - XrResult xrGetMarkerNumberML - XrMarkerDetectorML markerDetector - XrMarkerML marker - uint64_t* number - - - XrResult xrGetMarkerStringML - XrMarkerDetectorML markerDetector - XrMarkerML marker - uint32_t bufferCapacityInput - uint32_t* bufferCountOutput - char* buffer - - - XrResult xrCreateMarkerSpaceML - XrSession session - const XrMarkerSpaceCreateInfoML* createInfo - XrSpace* space - - - - - XrResult xrPollFutureEXT - XrInstance instance - const XrFuturePollInfoEXT* pollInfo - XrFuturePollResultEXT* pollResult - - - - XrResult xrCancelFutureEXT - XrInstance instance - const XrFutureCancelInfoEXT* cancelInfo - - - - - - XrResult xrCreateEnvironmentDepthProviderMETA - XrSession session - const XrEnvironmentDepthProviderCreateInfoMETA* createInfo - XrEnvironmentDepthProviderMETA* environmentDepthProvider - - - XrResult xrDestroyEnvironmentDepthProviderMETA - XrEnvironmentDepthProviderMETA environmentDepthProvider - - - XrResult xrStartEnvironmentDepthProviderMETA - XrEnvironmentDepthProviderMETA environmentDepthProvider - - - XrResult xrStopEnvironmentDepthProviderMETA - XrEnvironmentDepthProviderMETA environmentDepthProvider - - - XrResult xrCreateEnvironmentDepthSwapchainMETA - XrEnvironmentDepthProviderMETA environmentDepthProvider - const XrEnvironmentDepthSwapchainCreateInfoMETA* createInfo - XrEnvironmentDepthSwapchainMETA* swapchain - - - XrResult xrDestroyEnvironmentDepthSwapchainMETA - XrEnvironmentDepthSwapchainMETA swapchain - - - XrResult xrEnumerateEnvironmentDepthSwapchainImagesMETA - XrEnvironmentDepthSwapchainMETA swapchain - uint32_t imageCapacityInput - uint32_t* imageCountOutput - XrSwapchainImageBaseHeader* images - - - XrResult xrGetEnvironmentDepthSwapchainStateMETA - XrEnvironmentDepthSwapchainMETA swapchain - XrEnvironmentDepthSwapchainStateMETA* state - - - XrResult xrAcquireEnvironmentDepthImageMETA - XrEnvironmentDepthProviderMETA environmentDepthProvider - const XrEnvironmentDepthImageAcquireInfoMETA* acquireInfo - XrEnvironmentDepthImageMETA* environmentDepthImage - - - XrResult xrSetEnvironmentDepthHandRemovalMETA - XrEnvironmentDepthProviderMETA environmentDepthProvider - const XrEnvironmentDepthHandRemovalSetInfoMETA* setInfo - - - - - - - XrResult xrLocateSpaces - XrSession session - const XrSpacesLocateInfo* locateInfo - XrSpaceLocations* spaceLocations - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -