From be315ed808470992d24bb20590877b7c50b24319 Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Fri, 11 Apr 2025 11:01:54 -0600 Subject: [PATCH] wineopenxr: Update to 1.1.47 registry version. CW-Bug-Id: #25198 --- wineopenxr/loader_thunks.c | 869 ++++++++++++++++++++- wineopenxr/loader_thunks.h | 597 ++++++++++++++- wineopenxr/make_openxr | 6 +- wineopenxr/openxr_thunks.c | 909 +++++++++++++++++++++- wineopenxr/openxr_thunks.h | 138 +++- wineopenxr/wineopenxr.h | 1470 +++++++++++++++++++++++++++++++++++- wineopenxr/wineopenxr.json | 2 +- 7 files changed, 3970 insertions(+), 21 deletions(-) diff --git a/wineopenxr/loader_thunks.c b/wineopenxr/loader_thunks.c index ef42e8bc..a67e9472 100644 --- a/wineopenxr/loader_thunks.c +++ b/wineopenxr/loader_thunks.c @@ -3,7 +3,7 @@ * 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. + * Copyright (c) 2017-2025 The Khronos Group Inc. * * SPDX-License-Identifier: Apache-2.0 OR MIT * @@ -35,6 +35,18 @@ XrResult WINAPI xrAcquireEnvironmentDepthImageMETA(XrEnvironmentDepthProviderMET return params.result; } +XrResult WINAPI xrAllocateWorldMeshBufferML(XrWorldMeshDetectorML detector, const XrWorldMeshBufferSizeML *size, XrWorldMeshBufferML *buffer) +{ + struct xrAllocateWorldMeshBufferML_params params; + NTSTATUS _status; + params.detector = detector; + params.size = size; + params.buffer = buffer; + _status = UNIX_CALL(xrAllocateWorldMeshBufferML, ¶ms); + assert(!_status && "xrAllocateWorldMeshBufferML"); + return params.result; +} + XrResult WINAPI xrApplyForceFeedbackCurlMNDX(XrHandTrackerEXT handTracker, const XrForceFeedbackCurlApplyLocationsMNDX *locations) { struct xrApplyForceFeedbackCurlMNDX_params params; @@ -102,6 +114,30 @@ XrResult WINAPI xrCancelFutureEXT(XrInstance instance, const XrFutureCancelInfoE return params.result; } +XrResult WINAPI xrCaptureSceneAsyncBD(XrSenseDataProviderBD provider, const XrSceneCaptureInfoBD *info, XrFutureEXT *future) +{ + struct xrCaptureSceneAsyncBD_params params; + NTSTATUS _status; + params.provider = provider; + params.info = info; + params.future = future; + _status = UNIX_CALL(xrCaptureSceneAsyncBD, ¶ms); + assert(!_status && "xrCaptureSceneAsyncBD"); + return params.result; +} + +XrResult WINAPI xrCaptureSceneCompleteBD(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT *completion) +{ + struct xrCaptureSceneCompleteBD_params params; + NTSTATUS _status; + params.provider = provider; + params.future = future; + params.completion = completion; + _status = UNIX_CALL(xrCaptureSceneCompleteBD, ¶ms); + assert(!_status && "xrCaptureSceneCompleteBD"); + return params.result; +} + XrResult WINAPI xrChangeVirtualKeyboardTextContextMETA(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardTextContextChangeInfoMETA *changeInfo) { struct xrChangeVirtualKeyboardTextContextMETA_params params; @@ -170,6 +206,30 @@ XrResult WINAPI xrCreateActionSpace(XrSession session, const XrActionSpaceCreate return params.result; } +XrResult WINAPI xrCreateAnchorSpaceBD(XrSession session, const XrAnchorSpaceCreateInfoBD *createInfo, XrSpace *space) +{ + struct xrCreateAnchorSpaceBD_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.space = space; + _status = UNIX_CALL(xrCreateAnchorSpaceBD, ¶ms); + assert(!_status && "xrCreateAnchorSpaceBD"); + return params.result; +} + +XrResult WINAPI xrCreateBodyTrackerBD(XrSession session, const XrBodyTrackerCreateInfoBD *createInfo, XrBodyTrackerBD *bodyTracker) +{ + struct xrCreateBodyTrackerBD_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.bodyTracker = bodyTracker; + _status = UNIX_CALL(xrCreateBodyTrackerBD, ¶ms); + assert(!_status && "xrCreateBodyTrackerBD"); + return params.result; +} + XrResult WINAPI xrCreateBodyTrackerFB(XrSession session, const XrBodyTrackerCreateInfoFB *createInfo, XrBodyTrackerFB *bodyTracker) { struct xrCreateBodyTrackerFB_params params; @@ -182,6 +242,18 @@ XrResult WINAPI xrCreateBodyTrackerFB(XrSession session, const XrBodyTrackerCrea return params.result; } +XrResult WINAPI xrCreateBodyTrackerHTC(XrSession session, const XrBodyTrackerCreateInfoHTC *createInfo, XrBodyTrackerHTC *bodyTracker) +{ + struct xrCreateBodyTrackerHTC_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.bodyTracker = bodyTracker; + _status = UNIX_CALL(xrCreateBodyTrackerHTC, ¶ms); + assert(!_status && "xrCreateBodyTrackerHTC"); + return params.result; +} + XrResult WINAPI xrCreateEnvironmentDepthProviderMETA(XrSession session, const XrEnvironmentDepthProviderCreateInfoMETA *createInfo, XrEnvironmentDepthProviderMETA *environmentDepthProvider) { struct xrCreateEnvironmentDepthProviderMETA_params params; @@ -254,6 +326,18 @@ XrResult WINAPI xrCreateFaceTrackerFB(XrSession session, const XrFaceTrackerCrea return params.result; } +XrResult WINAPI xrCreateFacialExpressionClientML(XrSession session, const XrFacialExpressionClientCreateInfoML *createInfo, XrFacialExpressionClientML *facialExpressionClient) +{ + struct xrCreateFacialExpressionClientML_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.facialExpressionClient = facialExpressionClient; + _status = UNIX_CALL(xrCreateFacialExpressionClientML, ¶ms); + assert(!_status && "xrCreateFacialExpressionClientML"); + return params.result; +} + XrResult WINAPI xrCreateFacialTrackerHTC(XrSession session, const XrFacialTrackerCreateInfoHTC *createInfo, XrFacialTrackerHTC *facialTracker) { struct xrCreateFacialTrackerHTC_params params; @@ -458,6 +542,18 @@ XrResult WINAPI xrCreateSceneObserverMSFT(XrSession session, const XrSceneObserv return params.result; } +XrResult WINAPI xrCreateSenseDataProviderBD(XrSession session, const XrSenseDataProviderCreateInfoBD *createInfo, XrSenseDataProviderBD *provider) +{ + struct xrCreateSenseDataProviderBD_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.provider = provider; + _status = UNIX_CALL(xrCreateSenseDataProviderBD, ¶ms); + assert(!_status && "xrCreateSenseDataProviderBD"); + return params.result; +} + XrResult WINAPI xrCreateSpaceUserFB(XrSession session, const XrSpaceUserCreateInfoFB *info, XrSpaceUserFB *user) { struct xrCreateSpaceUserFB_params params; @@ -470,6 +566,30 @@ XrResult WINAPI xrCreateSpaceUserFB(XrSession session, const XrSpaceUserCreateIn return params.result; } +XrResult WINAPI xrCreateSpatialAnchorAsyncBD(XrSenseDataProviderBD provider, const XrSpatialAnchorCreateInfoBD *info, XrFutureEXT *future) +{ + struct xrCreateSpatialAnchorAsyncBD_params params; + NTSTATUS _status; + params.provider = provider; + params.info = info; + params.future = future; + _status = UNIX_CALL(xrCreateSpatialAnchorAsyncBD, ¶ms); + assert(!_status && "xrCreateSpatialAnchorAsyncBD"); + return params.result; +} + +XrResult WINAPI xrCreateSpatialAnchorCompleteBD(XrSenseDataProviderBD provider, XrFutureEXT future, XrSpatialAnchorCreateCompletionBD *completion) +{ + struct xrCreateSpatialAnchorCompleteBD_params params; + NTSTATUS _status; + params.provider = provider; + params.future = future; + params.completion = completion; + _status = UNIX_CALL(xrCreateSpatialAnchorCompleteBD, ¶ms); + assert(!_status && "xrCreateSpatialAnchorCompleteBD"); + return params.result; +} + XrResult WINAPI xrCreateSpatialAnchorFB(XrSession session, const XrSpatialAnchorCreateInfoFB *info, XrAsyncRequestIdFB *requestId) { struct xrCreateSpatialAnchorFB_params params; @@ -541,6 +661,54 @@ XrResult WINAPI xrCreateSpatialAnchorStoreConnectionMSFT(XrSession session, XrSp return params.result; } +XrResult WINAPI xrCreateSpatialAnchorsAsyncML(XrSession session, const XrSpatialAnchorsCreateInfoBaseHeaderML *createInfo, XrFutureEXT *future) +{ + struct xrCreateSpatialAnchorsAsyncML_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.future = future; + _status = UNIX_CALL(xrCreateSpatialAnchorsAsyncML, ¶ms); + assert(!_status && "xrCreateSpatialAnchorsAsyncML"); + return params.result; +} + +XrResult WINAPI xrCreateSpatialAnchorsCompleteML(XrSession session, XrFutureEXT future, XrCreateSpatialAnchorsCompletionML *completion) +{ + struct xrCreateSpatialAnchorsCompleteML_params params; + NTSTATUS _status; + params.session = session; + params.future = future; + params.completion = completion; + _status = UNIX_CALL(xrCreateSpatialAnchorsCompleteML, ¶ms); + assert(!_status && "xrCreateSpatialAnchorsCompleteML"); + return params.result; +} + +XrResult WINAPI xrCreateSpatialAnchorsStorageML(XrSession session, const XrSpatialAnchorsCreateStorageInfoML *createInfo, XrSpatialAnchorsStorageML *storage) +{ + struct xrCreateSpatialAnchorsStorageML_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.storage = storage; + _status = UNIX_CALL(xrCreateSpatialAnchorsStorageML, ¶ms); + assert(!_status && "xrCreateSpatialAnchorsStorageML"); + return params.result; +} + +XrResult WINAPI xrCreateSpatialEntityAnchorBD(XrSenseDataProviderBD provider, const XrSpatialEntityAnchorCreateInfoBD *createInfo, XrAnchorBD *anchor) +{ + struct xrCreateSpatialEntityAnchorBD_params params; + NTSTATUS _status; + params.provider = provider; + params.createInfo = createInfo; + params.anchor = anchor; + _status = UNIX_CALL(xrCreateSpatialEntityAnchorBD, ¶ms); + assert(!_status && "xrCreateSpatialEntityAnchorBD"); + return params.result; +} + XrResult WINAPI xrCreateSpatialGraphNodeSpaceMSFT(XrSession session, const XrSpatialGraphNodeSpaceCreateInfoMSFT *createInfo, XrSpace *space) { struct xrCreateSpatialGraphNodeSpaceMSFT_params params; @@ -590,6 +758,42 @@ XrResult WINAPI xrCreateVirtualKeyboardSpaceMETA(XrSession session, XrVirtualKey return params.result; } +XrResult WINAPI xrCreateWorldMeshDetectorML(XrSession session, const XrWorldMeshDetectorCreateInfoML *createInfo, XrWorldMeshDetectorML *detector) +{ + struct xrCreateWorldMeshDetectorML_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.detector = detector; + _status = UNIX_CALL(xrCreateWorldMeshDetectorML, ¶ms); + assert(!_status && "xrCreateWorldMeshDetectorML"); + return params.result; +} + +XrResult WINAPI xrDeleteSpatialAnchorsAsyncML(XrSpatialAnchorsStorageML storage, const XrSpatialAnchorsDeleteInfoML *deleteInfo, XrFutureEXT *future) +{ + struct xrDeleteSpatialAnchorsAsyncML_params params; + NTSTATUS _status; + params.storage = storage; + params.deleteInfo = deleteInfo; + params.future = future; + _status = UNIX_CALL(xrDeleteSpatialAnchorsAsyncML, ¶ms); + assert(!_status && "xrDeleteSpatialAnchorsAsyncML"); + return params.result; +} + +XrResult WINAPI xrDeleteSpatialAnchorsCompleteML(XrSpatialAnchorsStorageML storage, XrFutureEXT future, XrSpatialAnchorsDeleteCompletionML *completion) +{ + struct xrDeleteSpatialAnchorsCompleteML_params params; + NTSTATUS _status; + params.storage = storage; + params.future = future; + params.completion = completion; + _status = UNIX_CALL(xrDeleteSpatialAnchorsCompleteML, ¶ms); + assert(!_status && "xrDeleteSpatialAnchorsCompleteML"); + return params.result; +} + XrResult WINAPI xrDeserializeSceneMSFT(XrSceneObserverMSFT sceneObserver, const XrSceneDeserializeInfoMSFT *deserializeInfo) { struct xrDeserializeSceneMSFT_params params; @@ -621,6 +825,26 @@ XrResult WINAPI xrDestroyActionSet(XrActionSet actionSet) return params.result; } +XrResult WINAPI xrDestroyAnchorBD(XrAnchorBD anchor) +{ + struct xrDestroyAnchorBD_params params; + NTSTATUS _status; + params.anchor = anchor; + _status = UNIX_CALL(xrDestroyAnchorBD, ¶ms); + assert(!_status && "xrDestroyAnchorBD"); + return params.result; +} + +XrResult WINAPI xrDestroyBodyTrackerBD(XrBodyTrackerBD bodyTracker) +{ + struct xrDestroyBodyTrackerBD_params params; + NTSTATUS _status; + params.bodyTracker = bodyTracker; + _status = UNIX_CALL(xrDestroyBodyTrackerBD, ¶ms); + assert(!_status && "xrDestroyBodyTrackerBD"); + return params.result; +} + XrResult WINAPI xrDestroyBodyTrackerFB(XrBodyTrackerFB bodyTracker) { struct xrDestroyBodyTrackerFB_params params; @@ -631,6 +855,16 @@ XrResult WINAPI xrDestroyBodyTrackerFB(XrBodyTrackerFB bodyTracker) return params.result; } +XrResult WINAPI xrDestroyBodyTrackerHTC(XrBodyTrackerHTC bodyTracker) +{ + struct xrDestroyBodyTrackerHTC_params params; + NTSTATUS _status; + params.bodyTracker = bodyTracker; + _status = UNIX_CALL(xrDestroyBodyTrackerHTC, ¶ms); + assert(!_status && "xrDestroyBodyTrackerHTC"); + return params.result; +} + XrResult WINAPI xrDestroyEnvironmentDepthProviderMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider) { struct xrDestroyEnvironmentDepthProviderMETA_params params; @@ -691,6 +925,16 @@ XrResult WINAPI xrDestroyFaceTrackerFB(XrFaceTrackerFB faceTracker) return params.result; } +XrResult WINAPI xrDestroyFacialExpressionClientML(XrFacialExpressionClientML facialExpressionClient) +{ + struct xrDestroyFacialExpressionClientML_params params; + NTSTATUS _status; + params.facialExpressionClient = facialExpressionClient; + _status = UNIX_CALL(xrDestroyFacialExpressionClientML, ¶ms); + assert(!_status && "xrDestroyFacialExpressionClientML"); + return params.result; +} + XrResult WINAPI xrDestroyFacialTrackerHTC(XrFacialTrackerHTC facialTracker) { struct xrDestroyFacialTrackerHTC_params params; @@ -811,6 +1055,26 @@ XrResult WINAPI xrDestroySceneObserverMSFT(XrSceneObserverMSFT sceneObserver) return params.result; } +XrResult WINAPI xrDestroySenseDataProviderBD(XrSenseDataProviderBD provider) +{ + struct xrDestroySenseDataProviderBD_params params; + NTSTATUS _status; + params.provider = provider; + _status = UNIX_CALL(xrDestroySenseDataProviderBD, ¶ms); + assert(!_status && "xrDestroySenseDataProviderBD"); + return params.result; +} + +XrResult WINAPI xrDestroySenseDataSnapshotBD(XrSenseDataSnapshotBD snapshot) +{ + struct xrDestroySenseDataSnapshotBD_params params; + NTSTATUS _status; + params.snapshot = snapshot; + _status = UNIX_CALL(xrDestroySenseDataSnapshotBD, ¶ms); + assert(!_status && "xrDestroySenseDataSnapshotBD"); + return params.result; +} + XrResult WINAPI xrDestroySpace(XrSpace space) { struct xrDestroySpace_params params; @@ -851,6 +1115,16 @@ XrResult WINAPI xrDestroySpatialAnchorStoreConnectionMSFT(XrSpatialAnchorStoreCo return params.result; } +XrResult WINAPI xrDestroySpatialAnchorsStorageML(XrSpatialAnchorsStorageML storage) +{ + struct xrDestroySpatialAnchorsStorageML_params params; + NTSTATUS _status; + params.storage = storage; + _status = UNIX_CALL(xrDestroySpatialAnchorsStorageML, ¶ms); + assert(!_status && "xrDestroySpatialAnchorsStorageML"); + return params.result; +} + XrResult WINAPI xrDestroySpatialGraphNodeBindingMSFT(XrSpatialGraphNodeBindingMSFT nodeBinding) { struct xrDestroySpatialGraphNodeBindingMSFT_params params; @@ -881,6 +1155,40 @@ XrResult WINAPI xrDestroyVirtualKeyboardMETA(XrVirtualKeyboardMETA keyboard) return params.result; } +XrResult WINAPI xrDestroyWorldMeshDetectorML(XrWorldMeshDetectorML detector) +{ + struct xrDestroyWorldMeshDetectorML_params params; + NTSTATUS _status; + params.detector = detector; + _status = UNIX_CALL(xrDestroyWorldMeshDetectorML, ¶ms); + assert(!_status && "xrDestroyWorldMeshDetectorML"); + return params.result; +} + +XrResult WINAPI xrDownloadSharedSpatialAnchorAsyncBD(XrSenseDataProviderBD provider, const XrSharedSpatialAnchorDownloadInfoBD *info, XrFutureEXT *future) +{ + struct xrDownloadSharedSpatialAnchorAsyncBD_params params; + NTSTATUS _status; + params.provider = provider; + params.info = info; + params.future = future; + _status = UNIX_CALL(xrDownloadSharedSpatialAnchorAsyncBD, ¶ms); + assert(!_status && "xrDownloadSharedSpatialAnchorAsyncBD"); + return params.result; +} + +XrResult WINAPI xrDownloadSharedSpatialAnchorCompleteBD(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT *completion) +{ + struct xrDownloadSharedSpatialAnchorCompleteBD_params params; + NTSTATUS _status; + params.provider = provider; + params.future = future; + params.completion = completion; + _status = UNIX_CALL(xrDownloadSharedSpatialAnchorCompleteBD, ¶ms); + assert(!_status && "xrDownloadSharedSpatialAnchorCompleteBD"); + return params.result; +} + XrResult WINAPI xrEnableLocalizationEventsML(XrSession session, const XrLocalizationEnableEventsInfoML *info) { struct xrEnableLocalizationEventsML_params params; @@ -1113,6 +1421,20 @@ XrResult WINAPI xrEnumerateSpaceSupportedComponentsFB(XrSpace space, uint32_t co return params.result; } +XrResult WINAPI xrEnumerateSpatialEntityComponentTypesBD(XrSenseDataSnapshotBD snapshot, XrSpatialEntityIdBD entityId, uint32_t componentTypeCapacityInput, uint32_t *componentTypeCountOutput, XrSpatialEntityComponentTypeBD *componentTypes) +{ + struct xrEnumerateSpatialEntityComponentTypesBD_params params; + NTSTATUS _status; + params.snapshot = snapshot; + params.entityId = entityId; + params.componentTypeCapacityInput = componentTypeCapacityInput; + params.componentTypeCountOutput = componentTypeCountOutput; + params.componentTypes = componentTypes; + _status = UNIX_CALL(xrEnumerateSpatialEntityComponentTypesBD, ¶ms); + assert(!_status && "xrEnumerateSpatialEntityComponentTypesBD"); + return params.result; +} + XrResult WINAPI xrEnumerateViewConfigurationViews(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, uint32_t viewCapacityInput, uint32_t *viewCountOutput, XrViewConfigurationView *views) { struct xrEnumerateViewConfigurationViews_params params; @@ -1167,6 +1489,17 @@ XrResult WINAPI xrEraseSpaceFB(XrSession session, const XrSpaceEraseInfoFB *info return params.result; } +XrResult WINAPI xrFreeWorldMeshBufferML(XrWorldMeshDetectorML detector, const XrWorldMeshBufferML *buffer) +{ + struct xrFreeWorldMeshBufferML_params params; + NTSTATUS _status; + params.detector = detector; + params.buffer = buffer; + _status = UNIX_CALL(xrFreeWorldMeshBufferML, ¶ms); + assert(!_status && "xrFreeWorldMeshBufferML"); + return params.result; +} + XrResult WINAPI xrGeometryInstanceSetTransformFB(XrGeometryInstanceFB instance, const XrGeometryInstanceTransformFB *transformation) { struct xrGeometryInstanceSetTransformFB_params params; @@ -1226,6 +1559,17 @@ XrResult WINAPI xrGetActionStateVector2f(XrSession session, const XrActionStateG return params.result; } +XrResult WINAPI xrGetAnchorUuidBD(XrAnchorBD anchor, XrUuidEXT *uuid) +{ + struct xrGetAnchorUuidBD_params params; + NTSTATUS _status; + params.anchor = anchor; + params.uuid = uuid; + _status = UNIX_CALL(xrGetAnchorUuidBD, ¶ms); + assert(!_status && "xrGetAnchorUuidBD"); + return params.result; +} + XrResult WINAPI xrGetAudioInputDeviceGuidOculus(XrInstance instance, wchar_t buffer[]) { struct xrGetAudioInputDeviceGuidOculus_params params; @@ -1259,6 +1603,19 @@ XrResult WINAPI xrGetBodySkeletonFB(XrBodyTrackerFB bodyTracker, XrBodySkeletonF return params.result; } +XrResult WINAPI xrGetBodySkeletonHTC(XrBodyTrackerHTC bodyTracker, XrSpace baseSpace, uint32_t skeletonGenerationId, XrBodySkeletonHTC *skeleton) +{ + struct xrGetBodySkeletonHTC_params params; + NTSTATUS _status; + params.bodyTracker = bodyTracker; + params.baseSpace = baseSpace; + params.skeletonGenerationId = skeletonGenerationId; + params.skeleton = skeleton; + _status = UNIX_CALL(xrGetBodySkeletonHTC, ¶ms); + assert(!_status && "xrGetBodySkeletonHTC"); + return params.result; +} + XrResult WINAPI xrGetControllerModelKeyMSFT(XrSession session, XrPath topLevelUserPath, XrControllerModelKeyStateMSFT *controllerModelKeyState) { struct xrGetControllerModelKeyMSFT_params params; @@ -1390,6 +1747,19 @@ XrResult WINAPI xrGetFaceExpressionWeightsFB(XrFaceTrackerFB faceTracker, const return params.result; } +XrResult WINAPI xrGetFacialExpressionBlendShapePropertiesML(XrFacialExpressionClientML facialExpressionClient, const XrFacialExpressionBlendShapeGetInfoML *blendShapeGetInfo, uint32_t blendShapeCount, XrFacialExpressionBlendShapePropertiesML *blendShapes) +{ + struct xrGetFacialExpressionBlendShapePropertiesML_params params; + NTSTATUS _status; + params.facialExpressionClient = facialExpressionClient; + params.blendShapeGetInfo = blendShapeGetInfo; + params.blendShapeCount = blendShapeCount; + params.blendShapes = blendShapes; + _status = UNIX_CALL(xrGetFacialExpressionBlendShapePropertiesML, ¶ms); + assert(!_status && "xrGetFacialExpressionBlendShapePropertiesML"); + return params.result; +} + XrResult WINAPI xrGetFacialExpressionsHTC(XrFacialTrackerHTC facialTracker, XrFacialExpressionsHTC *facialExpressions) { struct xrGetFacialExpressionsHTC_params params; @@ -1604,6 +1974,18 @@ XrResult WINAPI xrGetPlanePolygonBufferEXT(XrPlaneDetectorEXT planeDetector, uin return params.result; } +XrResult WINAPI xrGetQueriedSenseDataBD(XrSenseDataSnapshotBD snapshot, XrQueriedSenseDataGetInfoBD *getInfo, XrQueriedSenseDataBD *queriedSenseData) +{ + struct xrGetQueriedSenseDataBD_params params; + NTSTATUS _status; + params.snapshot = snapshot; + params.getInfo = getInfo; + params.queriedSenseData = queriedSenseData; + _status = UNIX_CALL(xrGetQueriedSenseDataBD, ¶ms); + assert(!_status && "xrGetQueriedSenseDataBD"); + return params.result; +} + XrResult WINAPI xrGetRecommendedLayerResolutionMETA(XrSession session, const XrRecommendedLayerResolutionGetInfoMETA *info, XrRecommendedLayerResolutionMETA *resolution) { struct xrGetRecommendedLayerResolutionMETA_params params; @@ -1703,6 +2085,17 @@ XrResult WINAPI xrGetSceneMeshBuffersMSFT(XrSceneMSFT scene, const XrSceneMeshBu return params.result; } +XrResult WINAPI xrGetSenseDataProviderStateBD(XrSenseDataProviderBD provider, XrSenseDataProviderStateBD *state) +{ + struct xrGetSenseDataProviderStateBD_params params; + NTSTATUS _status; + params.provider = provider; + params.state = state; + _status = UNIX_CALL(xrGetSenseDataProviderStateBD, ¶ms); + assert(!_status && "xrGetSenseDataProviderStateBD"); + return params.result; +} + XrResult WINAPI xrGetSerializedSceneFragmentDataMSFT(XrSceneMSFT scene, const XrSerializedSceneFragmentDataGetInfoMSFT *getInfo, uint32_t countInput, uint32_t *readOutput, uint8_t *buffer) { struct xrGetSerializedSceneFragmentDataMSFT_params params; @@ -1846,6 +2239,41 @@ XrResult WINAPI xrGetSpatialAnchorNameHTC(XrSpace anchor, XrSpatialAnchorNameHTC return params.result; } +XrResult WINAPI xrGetSpatialAnchorStateML(XrSpace anchor, XrSpatialAnchorStateML *state) +{ + struct xrGetSpatialAnchorStateML_params params; + NTSTATUS _status; + params.anchor = anchor; + params.state = state; + _status = UNIX_CALL(xrGetSpatialAnchorStateML, ¶ms); + assert(!_status && "xrGetSpatialAnchorStateML"); + return params.result; +} + +XrResult WINAPI xrGetSpatialEntityComponentDataBD(XrSenseDataSnapshotBD snapshot, const XrSpatialEntityComponentGetInfoBD *getInfo, XrSpatialEntityComponentDataBaseHeaderBD *componentData) +{ + struct xrGetSpatialEntityComponentDataBD_params params; + NTSTATUS _status; + params.snapshot = snapshot; + params.getInfo = getInfo; + params.componentData = componentData; + _status = UNIX_CALL(xrGetSpatialEntityComponentDataBD, ¶ms); + assert(!_status && "xrGetSpatialEntityComponentDataBD"); + return params.result; +} + +XrResult WINAPI xrGetSpatialEntityUuidBD(XrSenseDataSnapshotBD snapshot, XrSpatialEntityIdBD entityId, XrUuidEXT *uuid) +{ + struct xrGetSpatialEntityUuidBD_params params; + NTSTATUS _status; + params.snapshot = snapshot; + params.entityId = entityId; + params.uuid = uuid; + _status = UNIX_CALL(xrGetSpatialEntityUuidBD, ¶ms); + assert(!_status && "xrGetSpatialEntityUuidBD"); + return params.result; +} + XrResult WINAPI xrGetSpatialGraphNodeBindingPropertiesMSFT(XrSpatialGraphNodeBindingMSFT nodeBinding, const XrSpatialGraphNodeBindingPropertiesGetInfoMSFT *getInfo, XrSpatialGraphNodeBindingPropertiesMSFT *properties) { struct xrGetSpatialGraphNodeBindingPropertiesMSFT_params params; @@ -2032,6 +2460,18 @@ XrResult WINAPI xrGetVulkanInstanceExtensionsKHR(XrInstance instance, XrSystemId return params.result; } +XrResult WINAPI xrGetWorldMeshBufferRecommendSizeML(XrWorldMeshDetectorML detector, const XrWorldMeshBufferRecommendedSizeInfoML *sizeInfo, XrWorldMeshBufferSizeML *size) +{ + struct xrGetWorldMeshBufferRecommendSizeML_params params; + NTSTATUS _status; + params.detector = detector; + params.sizeInfo = sizeInfo; + params.size = size; + _status = UNIX_CALL(xrGetWorldMeshBufferRecommendSizeML, ¶ms); + assert(!_status && "xrGetWorldMeshBufferRecommendSizeML"); + return params.result; +} + XrResult WINAPI xrImportLocalizationMapML(XrSession session, const XrLocalizationMapImportInfoML *importInfo, XrUuidEXT *mapUuid) { struct xrImportLocalizationMapML_params params; @@ -2070,6 +2510,18 @@ XrResult WINAPI xrLoadRenderModelFB(XrSession session, const XrRenderModelLoadIn return params.result; } +XrResult WINAPI xrLocateBodyJointsBD(XrBodyTrackerBD bodyTracker, const XrBodyJointsLocateInfoBD *locateInfo, XrBodyJointLocationsBD *locations) +{ + struct xrLocateBodyJointsBD_params params; + NTSTATUS _status; + params.bodyTracker = bodyTracker; + params.locateInfo = locateInfo; + params.locations = locations; + _status = UNIX_CALL(xrLocateBodyJointsBD, ¶ms); + assert(!_status && "xrLocateBodyJointsBD"); + return params.result; +} + XrResult WINAPI xrLocateBodyJointsFB(XrBodyTrackerFB bodyTracker, const XrBodyJointsLocateInfoFB *locateInfo, XrBodyJointLocationsFB *locations) { struct xrLocateBodyJointsFB_params params; @@ -2082,6 +2534,18 @@ XrResult WINAPI xrLocateBodyJointsFB(XrBodyTrackerFB bodyTracker, const XrBodyJo return params.result; } +XrResult WINAPI xrLocateBodyJointsHTC(XrBodyTrackerHTC bodyTracker, const XrBodyJointsLocateInfoHTC *locateInfo, XrBodyJointLocationsHTC *locations) +{ + struct xrLocateBodyJointsHTC_params params; + NTSTATUS _status; + params.bodyTracker = bodyTracker; + params.locateInfo = locateInfo; + params.locations = locations; + _status = UNIX_CALL(xrLocateBodyJointsHTC, ¶ms); + assert(!_status && "xrLocateBodyJointsHTC"); + return params.result; +} + XrResult WINAPI xrLocateHandJointsEXT(XrHandTrackerEXT handTracker, const XrHandJointsLocateInfoEXT *locateInfo, XrHandJointLocationsEXT *locations) { struct xrLocateHandJointsEXT_params params; @@ -2246,6 +2710,30 @@ XrResult WINAPI xrPerfSettingsSetPerformanceLevelEXT(XrSession session, XrPerfSe return params.result; } +XrResult WINAPI xrPersistSpatialAnchorAsyncBD(XrSenseDataProviderBD provider, const XrSpatialAnchorPersistInfoBD *info, XrFutureEXT *future) +{ + struct xrPersistSpatialAnchorAsyncBD_params params; + NTSTATUS _status; + params.provider = provider; + params.info = info; + params.future = future; + _status = UNIX_CALL(xrPersistSpatialAnchorAsyncBD, ¶ms); + assert(!_status && "xrPersistSpatialAnchorAsyncBD"); + return params.result; +} + +XrResult WINAPI xrPersistSpatialAnchorCompleteBD(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT *completion) +{ + struct xrPersistSpatialAnchorCompleteBD_params params; + NTSTATUS _status; + params.provider = provider; + params.future = future; + params.completion = completion; + _status = UNIX_CALL(xrPersistSpatialAnchorCompleteBD, ¶ms); + assert(!_status && "xrPersistSpatialAnchorCompleteBD"); + return params.result; +} + XrResult WINAPI xrPersistSpatialAnchorMSFT(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, const XrSpatialAnchorPersistenceInfoMSFT *spatialAnchorPersistenceInfo) { struct xrPersistSpatialAnchorMSFT_params params; @@ -2269,6 +2757,30 @@ XrResult WINAPI xrPollFutureEXT(XrInstance instance, const XrFuturePollInfoEXT * return params.result; } +XrResult WINAPI xrPublishSpatialAnchorsAsyncML(XrSpatialAnchorsStorageML storage, const XrSpatialAnchorsPublishInfoML *publishInfo, XrFutureEXT *future) +{ + struct xrPublishSpatialAnchorsAsyncML_params params; + NTSTATUS _status; + params.storage = storage; + params.publishInfo = publishInfo; + params.future = future; + _status = UNIX_CALL(xrPublishSpatialAnchorsAsyncML, ¶ms); + assert(!_status && "xrPublishSpatialAnchorsAsyncML"); + return params.result; +} + +XrResult WINAPI xrPublishSpatialAnchorsCompleteML(XrSpatialAnchorsStorageML storage, XrFutureEXT future, XrSpatialAnchorsPublishCompletionML *completion) +{ + struct xrPublishSpatialAnchorsCompleteML_params params; + NTSTATUS _status; + params.storage = storage; + params.future = future; + params.completion = completion; + _status = UNIX_CALL(xrPublishSpatialAnchorsCompleteML, ¶ms); + assert(!_status && "xrPublishSpatialAnchorsCompleteML"); + return params.result; +} + XrResult WINAPI xrQueryLocalizationMapsML(XrSession session, const XrLocalizationMapQueryInfoBaseHeaderML *queryInfo, uint32_t mapCapacityInput, uint32_t *mapCountOutput, XrLocalizationMapML *maps) { struct xrQueryLocalizationMapsML_params params; @@ -2295,6 +2807,30 @@ XrResult WINAPI xrQueryPerformanceMetricsCounterMETA(XrSession session, XrPath c return params.result; } +XrResult WINAPI xrQuerySenseDataAsyncBD(XrSenseDataProviderBD provider, const XrSenseDataQueryInfoBD *queryInfo, XrFutureEXT *future) +{ + struct xrQuerySenseDataAsyncBD_params params; + NTSTATUS _status; + params.provider = provider; + params.queryInfo = queryInfo; + params.future = future; + _status = UNIX_CALL(xrQuerySenseDataAsyncBD, ¶ms); + assert(!_status && "xrQuerySenseDataAsyncBD"); + return params.result; +} + +XrResult WINAPI xrQuerySenseDataCompleteBD(XrSenseDataProviderBD provider, XrFutureEXT future, XrSenseDataQueryCompletionBD *completion) +{ + struct xrQuerySenseDataCompleteBD_params params; + NTSTATUS _status; + params.provider = provider; + params.future = future; + params.completion = completion; + _status = UNIX_CALL(xrQuerySenseDataCompleteBD, ¶ms); + assert(!_status && "xrQuerySenseDataCompleteBD"); + return params.result; +} + XrResult WINAPI xrQuerySpacesFB(XrSession session, const XrSpaceQueryInfoBaseHeaderFB *info, XrAsyncRequestIdFB *requestId) { struct xrQuerySpacesFB_params params; @@ -2307,6 +2843,30 @@ XrResult WINAPI xrQuerySpacesFB(XrSession session, const XrSpaceQueryInfoBaseHea return params.result; } +XrResult WINAPI xrQuerySpatialAnchorsAsyncML(XrSpatialAnchorsStorageML storage, const XrSpatialAnchorsQueryInfoBaseHeaderML *queryInfo, XrFutureEXT *future) +{ + struct xrQuerySpatialAnchorsAsyncML_params params; + NTSTATUS _status; + params.storage = storage; + params.queryInfo = queryInfo; + params.future = future; + _status = UNIX_CALL(xrQuerySpatialAnchorsAsyncML, ¶ms); + assert(!_status && "xrQuerySpatialAnchorsAsyncML"); + return params.result; +} + +XrResult WINAPI xrQuerySpatialAnchorsCompleteML(XrSpatialAnchorsStorageML storage, XrFutureEXT future, XrSpatialAnchorsQueryCompletionML *completion) +{ + struct xrQuerySpatialAnchorsCompleteML_params params; + NTSTATUS _status; + params.storage = storage; + params.future = future; + params.completion = completion; + _status = UNIX_CALL(xrQuerySpatialAnchorsCompleteML, ¶ms); + assert(!_status && "xrQuerySpatialAnchorsCompleteML"); + return params.result; +} + XrResult WINAPI xrQuerySystemTrackedKeyboardFB(XrSession session, const XrKeyboardTrackingQueryFB *queryInfo, XrKeyboardTrackingDescriptionFB *keyboard) { struct xrQuerySystemTrackedKeyboardFB_params params; @@ -2363,6 +2923,56 @@ XrResult WINAPI xrRequestSceneCaptureFB(XrSession session, const XrSceneCaptureR return params.result; } +XrResult WINAPI xrRequestWorldMeshAsyncML(XrWorldMeshDetectorML detector, const XrWorldMeshGetInfoML *getInfo, XrWorldMeshBufferML *buffer, XrFutureEXT *future) +{ + struct xrRequestWorldMeshAsyncML_params params; + NTSTATUS _status; + params.detector = detector; + params.getInfo = getInfo; + params.buffer = buffer; + params.future = future; + _status = UNIX_CALL(xrRequestWorldMeshAsyncML, ¶ms); + assert(!_status && "xrRequestWorldMeshAsyncML"); + return params.result; +} + +XrResult WINAPI xrRequestWorldMeshCompleteML(XrWorldMeshDetectorML detector, const XrWorldMeshRequestCompletionInfoML *completionInfo, XrFutureEXT future, XrWorldMeshRequestCompletionML *completion) +{ + struct xrRequestWorldMeshCompleteML_params params; + NTSTATUS _status; + params.detector = detector; + params.completionInfo = completionInfo; + params.future = future; + params.completion = completion; + _status = UNIX_CALL(xrRequestWorldMeshCompleteML, ¶ms); + assert(!_status && "xrRequestWorldMeshCompleteML"); + return params.result; +} + +XrResult WINAPI xrRequestWorldMeshStateAsyncML(XrWorldMeshDetectorML detector, const XrWorldMeshStateRequestInfoML *stateRequest, XrFutureEXT *future) +{ + struct xrRequestWorldMeshStateAsyncML_params params; + NTSTATUS _status; + params.detector = detector; + params.stateRequest = stateRequest; + params.future = future; + _status = UNIX_CALL(xrRequestWorldMeshStateAsyncML, ¶ms); + assert(!_status && "xrRequestWorldMeshStateAsyncML"); + return params.result; +} + +XrResult WINAPI xrRequestWorldMeshStateCompleteML(XrWorldMeshDetectorML detector, XrFutureEXT future, XrWorldMeshStateRequestCompletionML *completion) +{ + struct xrRequestWorldMeshStateCompleteML_params params; + NTSTATUS _status; + params.detector = detector; + params.future = future; + params.completion = completion; + _status = UNIX_CALL(xrRequestWorldMeshStateCompleteML, ¶ms); + assert(!_status && "xrRequestWorldMeshStateCompleteML"); + return params.result; +} + XrResult WINAPI xrResultToString(XrInstance instance, XrResult value, char buffer[]) { struct xrResultToString_params params; @@ -2591,6 +3201,17 @@ XrResult WINAPI xrSetSpaceComponentStatusFB(XrSpace space, const XrSpaceComponen return params.result; } +XrResult WINAPI xrSetSystemNotificationsML(XrInstance instance, const XrSystemNotificationsSetInfoML *info) +{ + struct xrSetSystemNotificationsML_params params; + NTSTATUS _status; + params.instance = instance; + params.info = info; + _status = UNIX_CALL(xrSetSystemNotificationsML, ¶ms); + assert(!_status && "xrSetSystemNotificationsML"); + return params.result; +} + XrResult WINAPI xrSetTrackingOptimizationSettingsHintQCOM(XrSession session, XrTrackingOptimizationSettingsDomainQCOM domain, XrTrackingOptimizationSettingsHintQCOM hint) { struct xrSetTrackingOptimizationSettingsHintQCOM_params params; @@ -2637,6 +3258,42 @@ XrResult WINAPI xrShareSpacesFB(XrSession session, const XrSpaceShareInfoFB *inf return params.result; } +XrResult WINAPI xrShareSpacesMETA(XrSession session, const XrShareSpacesInfoMETA *info, XrAsyncRequestIdFB *requestId) +{ + struct xrShareSpacesMETA_params params; + NTSTATUS _status; + params.session = session; + params.info = info; + params.requestId = requestId; + _status = UNIX_CALL(xrShareSpacesMETA, ¶ms); + assert(!_status && "xrShareSpacesMETA"); + return params.result; +} + +XrResult WINAPI xrShareSpatialAnchorAsyncBD(XrSenseDataProviderBD provider, const XrSpatialAnchorShareInfoBD *info, XrFutureEXT *future) +{ + struct xrShareSpatialAnchorAsyncBD_params params; + NTSTATUS _status; + params.provider = provider; + params.info = info; + params.future = future; + _status = UNIX_CALL(xrShareSpatialAnchorAsyncBD, ¶ms); + assert(!_status && "xrShareSpatialAnchorAsyncBD"); + return params.result; +} + +XrResult WINAPI xrShareSpatialAnchorCompleteBD(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT *completion) +{ + struct xrShareSpatialAnchorCompleteBD_params params; + NTSTATUS _status; + params.provider = provider; + params.future = future; + params.completion = completion; + _status = UNIX_CALL(xrShareSpatialAnchorCompleteBD, ¶ms); + assert(!_status && "xrShareSpatialAnchorCompleteBD"); + return params.result; +} + XrResult WINAPI xrSnapshotMarkerDetectorML(XrMarkerDetectorML markerDetector, XrMarkerDetectorSnapshotInfoML *snapshotInfo) { struct xrSnapshotMarkerDetectorML_params params; @@ -2648,6 +3305,30 @@ XrResult WINAPI xrSnapshotMarkerDetectorML(XrMarkerDetectorML markerDetector, Xr return params.result; } +XrResult WINAPI xrStartColocationAdvertisementMETA(XrSession session, const XrColocationAdvertisementStartInfoMETA *info, XrAsyncRequestIdFB *advertisementRequestId) +{ + struct xrStartColocationAdvertisementMETA_params params; + NTSTATUS _status; + params.session = session; + params.info = info; + params.advertisementRequestId = advertisementRequestId; + _status = UNIX_CALL(xrStartColocationAdvertisementMETA, ¶ms); + assert(!_status && "xrStartColocationAdvertisementMETA"); + return params.result; +} + +XrResult WINAPI xrStartColocationDiscoveryMETA(XrSession session, const XrColocationDiscoveryStartInfoMETA *info, XrAsyncRequestIdFB *discoveryRequestId) +{ + struct xrStartColocationDiscoveryMETA_params params; + NTSTATUS _status; + params.session = session; + params.info = info; + params.discoveryRequestId = discoveryRequestId; + _status = UNIX_CALL(xrStartColocationDiscoveryMETA, ¶ms); + assert(!_status && "xrStartColocationDiscoveryMETA"); + return params.result; +} + XrResult WINAPI xrStartEnvironmentDepthProviderMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider) { struct xrStartEnvironmentDepthProviderMETA_params params; @@ -2658,6 +3339,54 @@ XrResult WINAPI xrStartEnvironmentDepthProviderMETA(XrEnvironmentDepthProviderME return params.result; } +XrResult WINAPI xrStartSenseDataProviderAsyncBD(XrSenseDataProviderBD provider, const XrSenseDataProviderStartInfoBD *startInfo, XrFutureEXT *future) +{ + struct xrStartSenseDataProviderAsyncBD_params params; + NTSTATUS _status; + params.provider = provider; + params.startInfo = startInfo; + params.future = future; + _status = UNIX_CALL(xrStartSenseDataProviderAsyncBD, ¶ms); + assert(!_status && "xrStartSenseDataProviderAsyncBD"); + return params.result; +} + +XrResult WINAPI xrStartSenseDataProviderCompleteBD(XrSession session, XrFutureEXT future, XrFutureCompletionEXT *completion) +{ + struct xrStartSenseDataProviderCompleteBD_params params; + NTSTATUS _status; + params.session = session; + params.future = future; + params.completion = completion; + _status = UNIX_CALL(xrStartSenseDataProviderCompleteBD, ¶ms); + assert(!_status && "xrStartSenseDataProviderCompleteBD"); + return params.result; +} + +XrResult WINAPI xrStopColocationAdvertisementMETA(XrSession session, const XrColocationAdvertisementStopInfoMETA *info, XrAsyncRequestIdFB *requestId) +{ + struct xrStopColocationAdvertisementMETA_params params; + NTSTATUS _status; + params.session = session; + params.info = info; + params.requestId = requestId; + _status = UNIX_CALL(xrStopColocationAdvertisementMETA, ¶ms); + assert(!_status && "xrStopColocationAdvertisementMETA"); + return params.result; +} + +XrResult WINAPI xrStopColocationDiscoveryMETA(XrSession session, const XrColocationDiscoveryStopInfoMETA *info, XrAsyncRequestIdFB *requestId) +{ + struct xrStopColocationDiscoveryMETA_params params; + NTSTATUS _status; + params.session = session; + params.info = info; + params.requestId = requestId; + _status = UNIX_CALL(xrStopColocationDiscoveryMETA, ¶ms); + assert(!_status && "xrStopColocationDiscoveryMETA"); + return params.result; +} + XrResult WINAPI xrStopEnvironmentDepthProviderMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider) { struct xrStopEnvironmentDepthProviderMETA_params params; @@ -2679,6 +3408,16 @@ XrResult WINAPI xrStopHapticFeedback(XrSession session, const XrHapticActionInfo return params.result; } +XrResult WINAPI xrStopSenseDataProviderBD(XrSenseDataProviderBD provider) +{ + struct xrStopSenseDataProviderBD_params params; + NTSTATUS _status; + params.provider = provider; + _status = UNIX_CALL(xrStopSenseDataProviderBD, ¶ms); + assert(!_status && "xrStopSenseDataProviderBD"); + return params.result; +} + XrResult WINAPI xrStringToPath(XrInstance instance, const char *pathString, XrPath *path) { struct xrStringToPath_params params; @@ -2703,6 +3442,18 @@ XrResult WINAPI xrStructureTypeToString(XrInstance instance, XrStructureType val return params.result; } +XrResult WINAPI xrStructureTypeToString2KHR(XrInstance instance, XrStructureType value, char buffer[]) +{ + struct xrStructureTypeToString2KHR_params params; + NTSTATUS _status; + params.instance = instance; + params.value = value; + params.buffer = buffer; + _status = UNIX_CALL(xrStructureTypeToString2KHR, ¶ms); + assert(!_status && "xrStructureTypeToString2KHR"); + return params.result; +} + XrResult WINAPI xrSuggestInteractionProfileBindings(XrInstance instance, const XrInteractionProfileSuggestedBinding *suggestedBindings) { struct xrSuggestInteractionProfileBindings_params params; @@ -2827,6 +3578,30 @@ XrResult WINAPI xrTryCreateSpatialGraphStaticNodeBindingMSFT(XrSession session, return params.result; } +XrResult WINAPI xrUnpersistSpatialAnchorAsyncBD(XrSenseDataProviderBD provider, const XrSpatialAnchorUnpersistInfoBD *info, XrFutureEXT *future) +{ + struct xrUnpersistSpatialAnchorAsyncBD_params params; + NTSTATUS _status; + params.provider = provider; + params.info = info; + params.future = future; + _status = UNIX_CALL(xrUnpersistSpatialAnchorAsyncBD, ¶ms); + assert(!_status && "xrUnpersistSpatialAnchorAsyncBD"); + return params.result; +} + +XrResult WINAPI xrUnpersistSpatialAnchorCompleteBD(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT *completion) +{ + struct xrUnpersistSpatialAnchorCompleteBD_params params; + NTSTATUS _status; + params.provider = provider; + params.future = future; + params.completion = completion; + _status = UNIX_CALL(xrUnpersistSpatialAnchorCompleteBD, ¶ms); + assert(!_status && "xrUnpersistSpatialAnchorCompleteBD"); + return params.result; +} + XrResult WINAPI xrUnpersistSpatialAnchorMSFT(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, const XrSpatialAnchorPersistenceNameMSFT *spatialAnchorPersistenceName) { struct xrUnpersistSpatialAnchorMSFT_params params; @@ -2861,6 +3636,30 @@ XrResult WINAPI xrUpdatePassthroughColorLutMETA(XrPassthroughColorLutMETA colorL return params.result; } +XrResult WINAPI xrUpdateSpatialAnchorsExpirationAsyncML(XrSpatialAnchorsStorageML storage, const XrSpatialAnchorsUpdateExpirationInfoML *updateInfo, XrFutureEXT *future) +{ + struct xrUpdateSpatialAnchorsExpirationAsyncML_params params; + NTSTATUS _status; + params.storage = storage; + params.updateInfo = updateInfo; + params.future = future; + _status = UNIX_CALL(xrUpdateSpatialAnchorsExpirationAsyncML, ¶ms); + assert(!_status && "xrUpdateSpatialAnchorsExpirationAsyncML"); + return params.result; +} + +XrResult WINAPI xrUpdateSpatialAnchorsExpirationCompleteML(XrSpatialAnchorsStorageML storage, XrFutureEXT future, XrSpatialAnchorsUpdateExpirationCompletionML *completion) +{ + struct xrUpdateSpatialAnchorsExpirationCompleteML_params params; + NTSTATUS _status; + params.storage = storage; + params.future = future; + params.completion = completion; + _status = UNIX_CALL(xrUpdateSpatialAnchorsExpirationCompleteML, ¶ms); + assert(!_status && "xrUpdateSpatialAnchorsExpirationCompleteML"); + return params.result; +} + XrResult WINAPI xrUpdateSwapchainFB(XrSwapchain swapchain, const XrSwapchainStateBaseHeaderFB *state) { struct xrUpdateSwapchainFB_params params; @@ -2899,6 +3698,7 @@ static const struct openxr_func xr_instance_dispatch_table[] = { {"xrAcquireEnvironmentDepthImageMETA", xrAcquireEnvironmentDepthImageMETA}, {"xrAcquireSwapchainImage", xrAcquireSwapchainImage}, + {"xrAllocateWorldMeshBufferML", xrAllocateWorldMeshBufferML}, {"xrApplyForceFeedbackCurlMNDX", xrApplyForceFeedbackCurlMNDX}, {"xrApplyHapticFeedback", xrApplyHapticFeedback}, {"xrAttachSessionActionSets", xrAttachSessionActionSets}, @@ -2906,6 +3706,8 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrBeginPlaneDetectionEXT", xrBeginPlaneDetectionEXT}, {"xrBeginSession", xrBeginSession}, {"xrCancelFutureEXT", xrCancelFutureEXT}, + {"xrCaptureSceneAsyncBD", xrCaptureSceneAsyncBD}, + {"xrCaptureSceneCompleteBD", xrCaptureSceneCompleteBD}, {"xrChangeVirtualKeyboardTextContextMETA", xrChangeVirtualKeyboardTextContextMETA}, {"xrClearSpatialAnchorStoreMSFT", xrClearSpatialAnchorStoreMSFT}, {"xrComputeNewSceneMSFT", xrComputeNewSceneMSFT}, @@ -2914,14 +3716,18 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrCreateAction", xrCreateAction}, {"xrCreateActionSet", xrCreateActionSet}, {"xrCreateActionSpace", xrCreateActionSpace}, + {"xrCreateAnchorSpaceBD", xrCreateAnchorSpaceBD}, {"xrCreateApiLayerInstance", xrCreateApiLayerInstance}, + {"xrCreateBodyTrackerBD", xrCreateBodyTrackerBD}, {"xrCreateBodyTrackerFB", xrCreateBodyTrackerFB}, + {"xrCreateBodyTrackerHTC", xrCreateBodyTrackerHTC}, {"xrCreateEnvironmentDepthProviderMETA", xrCreateEnvironmentDepthProviderMETA}, {"xrCreateEnvironmentDepthSwapchainMETA", xrCreateEnvironmentDepthSwapchainMETA}, {"xrCreateExportedLocalizationMapML", xrCreateExportedLocalizationMapML}, {"xrCreateEyeTrackerFB", xrCreateEyeTrackerFB}, {"xrCreateFaceTracker2FB", xrCreateFaceTracker2FB}, {"xrCreateFaceTrackerFB", xrCreateFaceTrackerFB}, + {"xrCreateFacialExpressionClientML", xrCreateFacialExpressionClientML}, {"xrCreateFacialTrackerHTC", xrCreateFacialTrackerHTC}, {"xrCreateFoveationProfileFB", xrCreateFoveationProfileFB}, {"xrCreateGeometryInstanceFB", xrCreateGeometryInstanceFB}, @@ -2940,14 +3746,21 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrCreateReferenceSpace", xrCreateReferenceSpace}, {"xrCreateSceneMSFT", xrCreateSceneMSFT}, {"xrCreateSceneObserverMSFT", xrCreateSceneObserverMSFT}, + {"xrCreateSenseDataProviderBD", xrCreateSenseDataProviderBD}, {"xrCreateSession", xrCreateSession}, {"xrCreateSpaceUserFB", xrCreateSpaceUserFB}, + {"xrCreateSpatialAnchorAsyncBD", xrCreateSpatialAnchorAsyncBD}, + {"xrCreateSpatialAnchorCompleteBD", xrCreateSpatialAnchorCompleteBD}, {"xrCreateSpatialAnchorFB", xrCreateSpatialAnchorFB}, {"xrCreateSpatialAnchorFromPersistedNameMSFT", xrCreateSpatialAnchorFromPersistedNameMSFT}, {"xrCreateSpatialAnchorHTC", xrCreateSpatialAnchorHTC}, {"xrCreateSpatialAnchorMSFT", xrCreateSpatialAnchorMSFT}, {"xrCreateSpatialAnchorSpaceMSFT", xrCreateSpatialAnchorSpaceMSFT}, {"xrCreateSpatialAnchorStoreConnectionMSFT", xrCreateSpatialAnchorStoreConnectionMSFT}, + {"xrCreateSpatialAnchorsAsyncML", xrCreateSpatialAnchorsAsyncML}, + {"xrCreateSpatialAnchorsCompleteML", xrCreateSpatialAnchorsCompleteML}, + {"xrCreateSpatialAnchorsStorageML", xrCreateSpatialAnchorsStorageML}, + {"xrCreateSpatialEntityAnchorBD", xrCreateSpatialEntityAnchorBD}, {"xrCreateSpatialGraphNodeSpaceMSFT", xrCreateSpatialGraphNodeSpaceMSFT}, {"xrCreateSwapchain", xrCreateSwapchain}, {"xrCreateTriangleMeshFB", xrCreateTriangleMeshFB}, @@ -2955,16 +3768,23 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrCreateVirtualKeyboardSpaceMETA", xrCreateVirtualKeyboardSpaceMETA}, {"xrCreateVulkanDeviceKHR", xrCreateVulkanDeviceKHR}, {"xrCreateVulkanInstanceKHR", xrCreateVulkanInstanceKHR}, + {"xrCreateWorldMeshDetectorML", xrCreateWorldMeshDetectorML}, + {"xrDeleteSpatialAnchorsAsyncML", xrDeleteSpatialAnchorsAsyncML}, + {"xrDeleteSpatialAnchorsCompleteML", xrDeleteSpatialAnchorsCompleteML}, {"xrDeserializeSceneMSFT", xrDeserializeSceneMSFT}, {"xrDestroyAction", xrDestroyAction}, {"xrDestroyActionSet", xrDestroyActionSet}, + {"xrDestroyAnchorBD", xrDestroyAnchorBD}, + {"xrDestroyBodyTrackerBD", xrDestroyBodyTrackerBD}, {"xrDestroyBodyTrackerFB", xrDestroyBodyTrackerFB}, + {"xrDestroyBodyTrackerHTC", xrDestroyBodyTrackerHTC}, {"xrDestroyEnvironmentDepthProviderMETA", xrDestroyEnvironmentDepthProviderMETA}, {"xrDestroyEnvironmentDepthSwapchainMETA", xrDestroyEnvironmentDepthSwapchainMETA}, {"xrDestroyExportedLocalizationMapML", xrDestroyExportedLocalizationMapML}, {"xrDestroyEyeTrackerFB", xrDestroyEyeTrackerFB}, {"xrDestroyFaceTracker2FB", xrDestroyFaceTracker2FB}, {"xrDestroyFaceTrackerFB", xrDestroyFaceTrackerFB}, + {"xrDestroyFacialExpressionClientML", xrDestroyFacialExpressionClientML}, {"xrDestroyFacialTrackerHTC", xrDestroyFacialTrackerHTC}, {"xrDestroyFoveationProfileFB", xrDestroyFoveationProfileFB}, {"xrDestroyGeometryInstanceFB", xrDestroyGeometryInstanceFB}, @@ -2978,15 +3798,21 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrDestroyPlaneDetectorEXT", xrDestroyPlaneDetectorEXT}, {"xrDestroySceneMSFT", xrDestroySceneMSFT}, {"xrDestroySceneObserverMSFT", xrDestroySceneObserverMSFT}, + {"xrDestroySenseDataProviderBD", xrDestroySenseDataProviderBD}, + {"xrDestroySenseDataSnapshotBD", xrDestroySenseDataSnapshotBD}, {"xrDestroySession", xrDestroySession}, {"xrDestroySpace", xrDestroySpace}, {"xrDestroySpaceUserFB", xrDestroySpaceUserFB}, {"xrDestroySpatialAnchorMSFT", xrDestroySpatialAnchorMSFT}, {"xrDestroySpatialAnchorStoreConnectionMSFT", xrDestroySpatialAnchorStoreConnectionMSFT}, + {"xrDestroySpatialAnchorsStorageML", xrDestroySpatialAnchorsStorageML}, {"xrDestroySpatialGraphNodeBindingMSFT", xrDestroySpatialGraphNodeBindingMSFT}, {"xrDestroySwapchain", xrDestroySwapchain}, {"xrDestroyTriangleMeshFB", xrDestroyTriangleMeshFB}, {"xrDestroyVirtualKeyboardMETA", xrDestroyVirtualKeyboardMETA}, + {"xrDestroyWorldMeshDetectorML", xrDestroyWorldMeshDetectorML}, + {"xrDownloadSharedSpatialAnchorAsyncBD", xrDownloadSharedSpatialAnchorAsyncBD}, + {"xrDownloadSharedSpatialAnchorCompleteBD", xrDownloadSharedSpatialAnchorCompleteBD}, {"xrEnableLocalizationEventsML", xrEnableLocalizationEventsML}, {"xrEnableUserCalibrationEventsML", xrEnableUserCalibrationEventsML}, {"xrEndFrame", xrEndFrame}, @@ -3006,20 +3832,24 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrEnumerateReprojectionModesMSFT", xrEnumerateReprojectionModesMSFT}, {"xrEnumerateSceneComputeFeaturesMSFT", xrEnumerateSceneComputeFeaturesMSFT}, {"xrEnumerateSpaceSupportedComponentsFB", xrEnumerateSpaceSupportedComponentsFB}, + {"xrEnumerateSpatialEntityComponentTypesBD", xrEnumerateSpatialEntityComponentTypesBD}, {"xrEnumerateSwapchainFormats", xrEnumerateSwapchainFormats}, {"xrEnumerateSwapchainImages", xrEnumerateSwapchainImages}, {"xrEnumerateViewConfigurationViews", xrEnumerateViewConfigurationViews}, {"xrEnumerateViewConfigurations", xrEnumerateViewConfigurations}, {"xrEnumerateViveTrackerPathsHTCX", xrEnumerateViveTrackerPathsHTCX}, {"xrEraseSpaceFB", xrEraseSpaceFB}, + {"xrFreeWorldMeshBufferML", xrFreeWorldMeshBufferML}, {"xrGeometryInstanceSetTransformFB", xrGeometryInstanceSetTransformFB}, {"xrGetActionStateBoolean", xrGetActionStateBoolean}, {"xrGetActionStateFloat", xrGetActionStateFloat}, {"xrGetActionStatePose", xrGetActionStatePose}, {"xrGetActionStateVector2f", xrGetActionStateVector2f}, + {"xrGetAnchorUuidBD", xrGetAnchorUuidBD}, {"xrGetAudioInputDeviceGuidOculus", xrGetAudioInputDeviceGuidOculus}, {"xrGetAudioOutputDeviceGuidOculus", xrGetAudioOutputDeviceGuidOculus}, {"xrGetBodySkeletonFB", xrGetBodySkeletonFB}, + {"xrGetBodySkeletonHTC", xrGetBodySkeletonHTC}, {"xrGetControllerModelKeyMSFT", xrGetControllerModelKeyMSFT}, {"xrGetControllerModelPropertiesMSFT", xrGetControllerModelPropertiesMSFT}, {"xrGetControllerModelStateMSFT", xrGetControllerModelStateMSFT}, @@ -3033,6 +3863,7 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrGetEyeGazesFB", xrGetEyeGazesFB}, {"xrGetFaceExpressionWeights2FB", xrGetFaceExpressionWeights2FB}, {"xrGetFaceExpressionWeightsFB", xrGetFaceExpressionWeightsFB}, + {"xrGetFacialExpressionBlendShapePropertiesML", xrGetFacialExpressionBlendShapePropertiesML}, {"xrGetFacialExpressionsHTC", xrGetFacialExpressionsHTC}, {"xrGetFoveationEyeTrackedStateMETA", xrGetFoveationEyeTrackedStateMETA}, {"xrGetHandMeshFB", xrGetHandMeshFB}, @@ -3052,6 +3883,7 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrGetPlaneDetectionStateEXT", xrGetPlaneDetectionStateEXT}, {"xrGetPlaneDetectionsEXT", xrGetPlaneDetectionsEXT}, {"xrGetPlanePolygonBufferEXT", xrGetPlanePolygonBufferEXT}, + {"xrGetQueriedSenseDataBD", xrGetQueriedSenseDataBD}, {"xrGetRecommendedLayerResolutionMETA", xrGetRecommendedLayerResolutionMETA}, {"xrGetReferenceSpaceBoundsRect", xrGetReferenceSpaceBoundsRect}, {"xrGetRenderModelPropertiesFB", xrGetRenderModelPropertiesFB}, @@ -3060,6 +3892,7 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrGetSceneMarkerDecodedStringMSFT", xrGetSceneMarkerDecodedStringMSFT}, {"xrGetSceneMarkerRawDataMSFT", xrGetSceneMarkerRawDataMSFT}, {"xrGetSceneMeshBuffersMSFT", xrGetSceneMeshBuffersMSFT}, + {"xrGetSenseDataProviderStateBD", xrGetSenseDataProviderStateBD}, {"xrGetSerializedSceneFragmentDataMSFT", xrGetSerializedSceneFragmentDataMSFT}, {"xrGetSpaceBoundary2DFB", xrGetSpaceBoundary2DFB}, {"xrGetSpaceBoundingBox2DFB", xrGetSpaceBoundingBox2DFB}, @@ -3072,6 +3905,9 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrGetSpaceUserIdFB", xrGetSpaceUserIdFB}, {"xrGetSpaceUuidFB", xrGetSpaceUuidFB}, {"xrGetSpatialAnchorNameHTC", xrGetSpatialAnchorNameHTC}, + {"xrGetSpatialAnchorStateML", xrGetSpatialAnchorStateML}, + {"xrGetSpatialEntityComponentDataBD", xrGetSpatialEntityComponentDataBD}, + {"xrGetSpatialEntityUuidBD", xrGetSpatialEntityUuidBD}, {"xrGetSpatialGraphNodeBindingPropertiesMSFT", xrGetSpatialGraphNodeBindingPropertiesMSFT}, {"xrGetSwapchainStateFB", xrGetSwapchainStateFB}, {"xrGetSystem", xrGetSystem}, @@ -3088,10 +3924,13 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrGetVulkanGraphicsRequirements2KHR", xrGetVulkanGraphicsRequirements2KHR}, {"xrGetVulkanGraphicsRequirementsKHR", xrGetVulkanGraphicsRequirementsKHR}, {"xrGetVulkanInstanceExtensionsKHR", xrGetVulkanInstanceExtensionsKHR}, + {"xrGetWorldMeshBufferRecommendSizeML", xrGetWorldMeshBufferRecommendSizeML}, {"xrImportLocalizationMapML", xrImportLocalizationMapML}, {"xrLoadControllerModelMSFT", xrLoadControllerModelMSFT}, {"xrLoadRenderModelFB", xrLoadRenderModelFB}, + {"xrLocateBodyJointsBD", xrLocateBodyJointsBD}, {"xrLocateBodyJointsFB", xrLocateBodyJointsFB}, + {"xrLocateBodyJointsHTC", xrLocateBodyJointsHTC}, {"xrLocateHandJointsEXT", xrLocateHandJointsEXT}, {"xrLocateSceneComponentsMSFT", xrLocateSceneComponentsMSFT}, {"xrLocateSpace", xrLocateSpace}, @@ -3107,18 +3946,30 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrPassthroughStartFB", xrPassthroughStartFB}, {"xrPathToString", xrPathToString}, {"xrPerfSettingsSetPerformanceLevelEXT", xrPerfSettingsSetPerformanceLevelEXT}, + {"xrPersistSpatialAnchorAsyncBD", xrPersistSpatialAnchorAsyncBD}, + {"xrPersistSpatialAnchorCompleteBD", xrPersistSpatialAnchorCompleteBD}, {"xrPersistSpatialAnchorMSFT", xrPersistSpatialAnchorMSFT}, {"xrPollEvent", xrPollEvent}, {"xrPollFutureEXT", xrPollFutureEXT}, + {"xrPublishSpatialAnchorsAsyncML", xrPublishSpatialAnchorsAsyncML}, + {"xrPublishSpatialAnchorsCompleteML", xrPublishSpatialAnchorsCompleteML}, {"xrQueryLocalizationMapsML", xrQueryLocalizationMapsML}, {"xrQueryPerformanceMetricsCounterMETA", xrQueryPerformanceMetricsCounterMETA}, + {"xrQuerySenseDataAsyncBD", xrQuerySenseDataAsyncBD}, + {"xrQuerySenseDataCompleteBD", xrQuerySenseDataCompleteBD}, {"xrQuerySpacesFB", xrQuerySpacesFB}, + {"xrQuerySpatialAnchorsAsyncML", xrQuerySpatialAnchorsAsyncML}, + {"xrQuerySpatialAnchorsCompleteML", xrQuerySpatialAnchorsCompleteML}, {"xrQuerySystemTrackedKeyboardFB", xrQuerySystemTrackedKeyboardFB}, {"xrReleaseSwapchainImage", xrReleaseSwapchainImage}, {"xrRequestDisplayRefreshRateFB", xrRequestDisplayRefreshRateFB}, {"xrRequestExitSession", xrRequestExitSession}, {"xrRequestMapLocalizationML", xrRequestMapLocalizationML}, {"xrRequestSceneCaptureFB", xrRequestSceneCaptureFB}, + {"xrRequestWorldMeshAsyncML", xrRequestWorldMeshAsyncML}, + {"xrRequestWorldMeshCompleteML", xrRequestWorldMeshCompleteML}, + {"xrRequestWorldMeshStateAsyncML", xrRequestWorldMeshStateAsyncML}, + {"xrRequestWorldMeshStateCompleteML", xrRequestWorldMeshStateCompleteML}, {"xrResultToString", xrResultToString}, {"xrRetrieveSpaceQueryResultsFB", xrRetrieveSpaceQueryResultsFB}, {"xrSaveSpaceFB", xrSaveSpaceFB}, @@ -3138,16 +3989,28 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrSetMarkerTrackingVARJO", xrSetMarkerTrackingVARJO}, {"xrSetPerformanceMetricsStateMETA", xrSetPerformanceMetricsStateMETA}, {"xrSetSpaceComponentStatusFB", xrSetSpaceComponentStatusFB}, + {"xrSetSystemNotificationsML", xrSetSystemNotificationsML}, {"xrSetTrackingOptimizationSettingsHintQCOM", xrSetTrackingOptimizationSettingsHintQCOM}, {"xrSetViewOffsetVARJO", xrSetViewOffsetVARJO}, {"xrSetVirtualKeyboardModelVisibilityMETA", xrSetVirtualKeyboardModelVisibilityMETA}, {"xrShareSpacesFB", xrShareSpacesFB}, + {"xrShareSpacesMETA", xrShareSpacesMETA}, + {"xrShareSpatialAnchorAsyncBD", xrShareSpatialAnchorAsyncBD}, + {"xrShareSpatialAnchorCompleteBD", xrShareSpatialAnchorCompleteBD}, {"xrSnapshotMarkerDetectorML", xrSnapshotMarkerDetectorML}, + {"xrStartColocationAdvertisementMETA", xrStartColocationAdvertisementMETA}, + {"xrStartColocationDiscoveryMETA", xrStartColocationDiscoveryMETA}, {"xrStartEnvironmentDepthProviderMETA", xrStartEnvironmentDepthProviderMETA}, + {"xrStartSenseDataProviderAsyncBD", xrStartSenseDataProviderAsyncBD}, + {"xrStartSenseDataProviderCompleteBD", xrStartSenseDataProviderCompleteBD}, + {"xrStopColocationAdvertisementMETA", xrStopColocationAdvertisementMETA}, + {"xrStopColocationDiscoveryMETA", xrStopColocationDiscoveryMETA}, {"xrStopEnvironmentDepthProviderMETA", xrStopEnvironmentDepthProviderMETA}, {"xrStopHapticFeedback", xrStopHapticFeedback}, + {"xrStopSenseDataProviderBD", xrStopSenseDataProviderBD}, {"xrStringToPath", xrStringToPath}, {"xrStructureTypeToString", xrStructureTypeToString}, + {"xrStructureTypeToString2KHR", xrStructureTypeToString2KHR}, {"xrSuggestInteractionProfileBindings", xrSuggestInteractionProfileBindings}, {"xrSuggestVirtualKeyboardLocationMETA", xrSuggestVirtualKeyboardLocationMETA}, {"xrSyncActions", xrSyncActions}, @@ -3159,9 +4022,13 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrTriangleMeshGetIndexBufferFB", xrTriangleMeshGetIndexBufferFB}, {"xrTriangleMeshGetVertexBufferFB", xrTriangleMeshGetVertexBufferFB}, {"xrTryCreateSpatialGraphStaticNodeBindingMSFT", xrTryCreateSpatialGraphStaticNodeBindingMSFT}, + {"xrUnpersistSpatialAnchorAsyncBD", xrUnpersistSpatialAnchorAsyncBD}, + {"xrUnpersistSpatialAnchorCompleteBD", xrUnpersistSpatialAnchorCompleteBD}, {"xrUnpersistSpatialAnchorMSFT", xrUnpersistSpatialAnchorMSFT}, {"xrUpdateHandMeshMSFT", xrUpdateHandMeshMSFT}, {"xrUpdatePassthroughColorLutMETA", xrUpdatePassthroughColorLutMETA}, + {"xrUpdateSpatialAnchorsExpirationAsyncML", xrUpdateSpatialAnchorsExpirationAsyncML}, + {"xrUpdateSpatialAnchorsExpirationCompleteML", xrUpdateSpatialAnchorsExpirationCompleteML}, {"xrUpdateSwapchainFB", xrUpdateSwapchainFB}, {"xrWaitFrame", xrWaitFrame}, {"xrWaitSwapchainImage", xrWaitSwapchainImage}, diff --git a/wineopenxr/loader_thunks.h b/wineopenxr/loader_thunks.h index d6a1b6ae..6a6bc579 100644 --- a/wineopenxr/loader_thunks.h +++ b/wineopenxr/loader_thunks.h @@ -3,7 +3,7 @@ * 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. + * Copyright (c) 2017-2025 The Khronos Group Inc. * * SPDX-License-Identifier: Apache-2.0 OR MIT * @@ -27,6 +27,7 @@ enum unix_call unix_init, unix_xrAcquireEnvironmentDepthImageMETA, unix_xrAcquireSwapchainImage, + unix_xrAllocateWorldMeshBufferML, unix_xrApplyForceFeedbackCurlMNDX, unix_xrApplyHapticFeedback, unix_xrAttachSessionActionSets, @@ -34,19 +35,25 @@ enum unix_call unix_xrBeginPlaneDetectionEXT, unix_xrBeginSession, unix_xrCancelFutureEXT, + unix_xrCaptureSceneAsyncBD, + unix_xrCaptureSceneCompleteBD, unix_xrChangeVirtualKeyboardTextContextMETA, unix_xrClearSpatialAnchorStoreMSFT, unix_xrComputeNewSceneMSFT, unix_xrCreateAction, unix_xrCreateActionSet, unix_xrCreateActionSpace, + unix_xrCreateAnchorSpaceBD, + unix_xrCreateBodyTrackerBD, unix_xrCreateBodyTrackerFB, + unix_xrCreateBodyTrackerHTC, unix_xrCreateEnvironmentDepthProviderMETA, unix_xrCreateEnvironmentDepthSwapchainMETA, unix_xrCreateExportedLocalizationMapML, unix_xrCreateEyeTrackerFB, unix_xrCreateFaceTracker2FB, unix_xrCreateFaceTrackerFB, + unix_xrCreateFacialExpressionClientML, unix_xrCreateFacialTrackerHTC, unix_xrCreateFoveationProfileFB, unix_xrCreateGeometryInstanceFB, @@ -65,29 +72,43 @@ enum unix_call unix_xrCreateReferenceSpace, unix_xrCreateSceneMSFT, unix_xrCreateSceneObserverMSFT, + unix_xrCreateSenseDataProviderBD, unix_xrCreateSession, unix_xrCreateSpaceUserFB, + unix_xrCreateSpatialAnchorAsyncBD, + unix_xrCreateSpatialAnchorCompleteBD, unix_xrCreateSpatialAnchorFB, unix_xrCreateSpatialAnchorFromPersistedNameMSFT, unix_xrCreateSpatialAnchorHTC, unix_xrCreateSpatialAnchorMSFT, unix_xrCreateSpatialAnchorSpaceMSFT, unix_xrCreateSpatialAnchorStoreConnectionMSFT, + unix_xrCreateSpatialAnchorsAsyncML, + unix_xrCreateSpatialAnchorsCompleteML, + unix_xrCreateSpatialAnchorsStorageML, + unix_xrCreateSpatialEntityAnchorBD, unix_xrCreateSpatialGraphNodeSpaceMSFT, unix_xrCreateSwapchain, unix_xrCreateTriangleMeshFB, unix_xrCreateVirtualKeyboardMETA, unix_xrCreateVirtualKeyboardSpaceMETA, + unix_xrCreateWorldMeshDetectorML, + unix_xrDeleteSpatialAnchorsAsyncML, + unix_xrDeleteSpatialAnchorsCompleteML, unix_xrDeserializeSceneMSFT, unix_xrDestroyAction, unix_xrDestroyActionSet, + unix_xrDestroyAnchorBD, + unix_xrDestroyBodyTrackerBD, unix_xrDestroyBodyTrackerFB, + unix_xrDestroyBodyTrackerHTC, unix_xrDestroyEnvironmentDepthProviderMETA, unix_xrDestroyEnvironmentDepthSwapchainMETA, unix_xrDestroyExportedLocalizationMapML, unix_xrDestroyEyeTrackerFB, unix_xrDestroyFaceTracker2FB, unix_xrDestroyFaceTrackerFB, + unix_xrDestroyFacialExpressionClientML, unix_xrDestroyFacialTrackerHTC, unix_xrDestroyFoveationProfileFB, unix_xrDestroyGeometryInstanceFB, @@ -101,15 +122,21 @@ enum unix_call unix_xrDestroyPlaneDetectorEXT, unix_xrDestroySceneMSFT, unix_xrDestroySceneObserverMSFT, + unix_xrDestroySenseDataProviderBD, + unix_xrDestroySenseDataSnapshotBD, unix_xrDestroySession, unix_xrDestroySpace, unix_xrDestroySpaceUserFB, unix_xrDestroySpatialAnchorMSFT, unix_xrDestroySpatialAnchorStoreConnectionMSFT, + unix_xrDestroySpatialAnchorsStorageML, unix_xrDestroySpatialGraphNodeBindingMSFT, unix_xrDestroySwapchain, unix_xrDestroyTriangleMeshFB, unix_xrDestroyVirtualKeyboardMETA, + unix_xrDestroyWorldMeshDetectorML, + unix_xrDownloadSharedSpatialAnchorAsyncBD, + unix_xrDownloadSharedSpatialAnchorCompleteBD, unix_xrEnableLocalizationEventsML, unix_xrEnableUserCalibrationEventsML, unix_xrEndFrame, @@ -129,20 +156,24 @@ enum unix_call unix_xrEnumerateReprojectionModesMSFT, unix_xrEnumerateSceneComputeFeaturesMSFT, unix_xrEnumerateSpaceSupportedComponentsFB, + unix_xrEnumerateSpatialEntityComponentTypesBD, unix_xrEnumerateSwapchainFormats, unix_xrEnumerateSwapchainImages, unix_xrEnumerateViewConfigurationViews, unix_xrEnumerateViewConfigurations, unix_xrEnumerateViveTrackerPathsHTCX, unix_xrEraseSpaceFB, + unix_xrFreeWorldMeshBufferML, unix_xrGeometryInstanceSetTransformFB, unix_xrGetActionStateBoolean, unix_xrGetActionStateFloat, unix_xrGetActionStatePose, unix_xrGetActionStateVector2f, + unix_xrGetAnchorUuidBD, unix_xrGetAudioInputDeviceGuidOculus, unix_xrGetAudioOutputDeviceGuidOculus, unix_xrGetBodySkeletonFB, + unix_xrGetBodySkeletonHTC, unix_xrGetControllerModelKeyMSFT, unix_xrGetControllerModelPropertiesMSFT, unix_xrGetControllerModelStateMSFT, @@ -154,6 +185,7 @@ enum unix_call unix_xrGetEyeGazesFB, unix_xrGetFaceExpressionWeights2FB, unix_xrGetFaceExpressionWeightsFB, + unix_xrGetFacialExpressionBlendShapePropertiesML, unix_xrGetFacialExpressionsHTC, unix_xrGetFoveationEyeTrackedStateMETA, unix_xrGetHandMeshFB, @@ -172,6 +204,7 @@ enum unix_call unix_xrGetPlaneDetectionStateEXT, unix_xrGetPlaneDetectionsEXT, unix_xrGetPlanePolygonBufferEXT, + unix_xrGetQueriedSenseDataBD, unix_xrGetRecommendedLayerResolutionMETA, unix_xrGetReferenceSpaceBoundsRect, unix_xrGetRenderModelPropertiesFB, @@ -180,6 +213,7 @@ enum unix_call unix_xrGetSceneMarkerDecodedStringMSFT, unix_xrGetSceneMarkerRawDataMSFT, unix_xrGetSceneMeshBuffersMSFT, + unix_xrGetSenseDataProviderStateBD, unix_xrGetSerializedSceneFragmentDataMSFT, unix_xrGetSpaceBoundary2DFB, unix_xrGetSpaceBoundingBox2DFB, @@ -192,6 +226,9 @@ enum unix_call unix_xrGetSpaceUserIdFB, unix_xrGetSpaceUuidFB, unix_xrGetSpatialAnchorNameHTC, + unix_xrGetSpatialAnchorStateML, + unix_xrGetSpatialEntityComponentDataBD, + unix_xrGetSpatialEntityUuidBD, unix_xrGetSpatialGraphNodeBindingPropertiesMSFT, unix_xrGetSwapchainStateFB, unix_xrGetSystem, @@ -208,10 +245,13 @@ enum unix_call unix_xrGetVulkanGraphicsRequirements2KHR, unix_xrGetVulkanGraphicsRequirementsKHR, unix_xrGetVulkanInstanceExtensionsKHR, + unix_xrGetWorldMeshBufferRecommendSizeML, unix_xrImportLocalizationMapML, unix_xrLoadControllerModelMSFT, unix_xrLoadRenderModelFB, + unix_xrLocateBodyJointsBD, unix_xrLocateBodyJointsFB, + unix_xrLocateBodyJointsHTC, unix_xrLocateHandJointsEXT, unix_xrLocateSceneComponentsMSFT, unix_xrLocateSpace, @@ -226,18 +266,30 @@ enum unix_call unix_xrPassthroughStartFB, unix_xrPathToString, unix_xrPerfSettingsSetPerformanceLevelEXT, + unix_xrPersistSpatialAnchorAsyncBD, + unix_xrPersistSpatialAnchorCompleteBD, unix_xrPersistSpatialAnchorMSFT, unix_xrPollEvent, unix_xrPollFutureEXT, + unix_xrPublishSpatialAnchorsAsyncML, + unix_xrPublishSpatialAnchorsCompleteML, unix_xrQueryLocalizationMapsML, unix_xrQueryPerformanceMetricsCounterMETA, + unix_xrQuerySenseDataAsyncBD, + unix_xrQuerySenseDataCompleteBD, unix_xrQuerySpacesFB, + unix_xrQuerySpatialAnchorsAsyncML, + unix_xrQuerySpatialAnchorsCompleteML, unix_xrQuerySystemTrackedKeyboardFB, unix_xrReleaseSwapchainImage, unix_xrRequestDisplayRefreshRateFB, unix_xrRequestExitSession, unix_xrRequestMapLocalizationML, unix_xrRequestSceneCaptureFB, + unix_xrRequestWorldMeshAsyncML, + unix_xrRequestWorldMeshCompleteML, + unix_xrRequestWorldMeshStateAsyncML, + unix_xrRequestWorldMeshStateCompleteML, unix_xrResultToString, unix_xrRetrieveSpaceQueryResultsFB, unix_xrSaveSpaceFB, @@ -257,16 +309,28 @@ enum unix_call unix_xrSetMarkerTrackingVARJO, unix_xrSetPerformanceMetricsStateMETA, unix_xrSetSpaceComponentStatusFB, + unix_xrSetSystemNotificationsML, unix_xrSetTrackingOptimizationSettingsHintQCOM, unix_xrSetViewOffsetVARJO, unix_xrSetVirtualKeyboardModelVisibilityMETA, unix_xrShareSpacesFB, + unix_xrShareSpacesMETA, + unix_xrShareSpatialAnchorAsyncBD, + unix_xrShareSpatialAnchorCompleteBD, unix_xrSnapshotMarkerDetectorML, + unix_xrStartColocationAdvertisementMETA, + unix_xrStartColocationDiscoveryMETA, unix_xrStartEnvironmentDepthProviderMETA, + unix_xrStartSenseDataProviderAsyncBD, + unix_xrStartSenseDataProviderCompleteBD, + unix_xrStopColocationAdvertisementMETA, + unix_xrStopColocationDiscoveryMETA, unix_xrStopEnvironmentDepthProviderMETA, unix_xrStopHapticFeedback, + unix_xrStopSenseDataProviderBD, unix_xrStringToPath, unix_xrStructureTypeToString, + unix_xrStructureTypeToString2KHR, unix_xrSuggestInteractionProfileBindings, unix_xrSuggestVirtualKeyboardLocationMETA, unix_xrSyncActions, @@ -278,9 +342,13 @@ enum unix_call unix_xrTriangleMeshGetIndexBufferFB, unix_xrTriangleMeshGetVertexBufferFB, unix_xrTryCreateSpatialGraphStaticNodeBindingMSFT, + unix_xrUnpersistSpatialAnchorAsyncBD, + unix_xrUnpersistSpatialAnchorCompleteBD, unix_xrUnpersistSpatialAnchorMSFT, unix_xrUpdateHandMeshMSFT, unix_xrUpdatePassthroughColorLutMETA, + unix_xrUpdateSpatialAnchorsExpirationAsyncML, + unix_xrUpdateSpatialAnchorsExpirationCompleteML, unix_xrUpdateSwapchainFB, unix_xrWaitFrame, unix_xrWaitSwapchainImage, @@ -303,6 +371,14 @@ struct xrAcquireSwapchainImage_params XrResult result; }; +struct xrAllocateWorldMeshBufferML_params +{ + XrWorldMeshDetectorML detector; + const XrWorldMeshBufferSizeML *size; + XrWorldMeshBufferML *buffer; + XrResult result; +}; + struct xrApplyForceFeedbackCurlMNDX_params { XrHandTrackerEXT handTracker; @@ -353,6 +429,22 @@ struct xrCancelFutureEXT_params XrResult result; }; +struct xrCaptureSceneAsyncBD_params +{ + XrSenseDataProviderBD provider; + const XrSceneCaptureInfoBD *info; + XrFutureEXT *future; + XrResult result; +}; + +struct xrCaptureSceneCompleteBD_params +{ + XrSenseDataProviderBD provider; + XrFutureEXT future; + XrFutureCompletionEXT *completion; + XrResult result; +}; + struct xrChangeVirtualKeyboardTextContextMETA_params { XrVirtualKeyboardMETA keyboard; @@ -397,6 +489,22 @@ struct xrCreateActionSpace_params XrResult result; }; +struct xrCreateAnchorSpaceBD_params +{ + XrSession session; + const XrAnchorSpaceCreateInfoBD *createInfo; + XrSpace *space; + XrResult result; +}; + +struct xrCreateBodyTrackerBD_params +{ + XrSession session; + const XrBodyTrackerCreateInfoBD *createInfo; + XrBodyTrackerBD *bodyTracker; + XrResult result; +}; + struct xrCreateBodyTrackerFB_params { XrSession session; @@ -405,6 +513,14 @@ struct xrCreateBodyTrackerFB_params XrResult result; }; +struct xrCreateBodyTrackerHTC_params +{ + XrSession session; + const XrBodyTrackerCreateInfoHTC *createInfo; + XrBodyTrackerHTC *bodyTracker; + XrResult result; +}; + struct xrCreateEnvironmentDepthProviderMETA_params { XrSession session; @@ -453,6 +569,14 @@ struct xrCreateFaceTrackerFB_params XrResult result; }; +struct xrCreateFacialExpressionClientML_params +{ + XrSession session; + const XrFacialExpressionClientCreateInfoML *createInfo; + XrFacialExpressionClientML *facialExpressionClient; + XrResult result; +}; + struct xrCreateFacialTrackerHTC_params { XrSession session; @@ -596,6 +720,14 @@ struct xrCreateSceneObserverMSFT_params XrResult result; }; +struct xrCreateSenseDataProviderBD_params +{ + XrSession session; + const XrSenseDataProviderCreateInfoBD *createInfo; + XrSenseDataProviderBD *provider; + XrResult result; +}; + struct xrCreateSession_params { XrInstance instance; @@ -612,6 +744,22 @@ struct xrCreateSpaceUserFB_params XrResult result; }; +struct xrCreateSpatialAnchorAsyncBD_params +{ + XrSenseDataProviderBD provider; + const XrSpatialAnchorCreateInfoBD *info; + XrFutureEXT *future; + XrResult result; +}; + +struct xrCreateSpatialAnchorCompleteBD_params +{ + XrSenseDataProviderBD provider; + XrFutureEXT future; + XrSpatialAnchorCreateCompletionBD *completion; + XrResult result; +}; + struct xrCreateSpatialAnchorFB_params { XrSession session; @@ -659,6 +807,38 @@ struct xrCreateSpatialAnchorStoreConnectionMSFT_params XrResult result; }; +struct xrCreateSpatialAnchorsAsyncML_params +{ + XrSession session; + const XrSpatialAnchorsCreateInfoBaseHeaderML *createInfo; + XrFutureEXT *future; + XrResult result; +}; + +struct xrCreateSpatialAnchorsCompleteML_params +{ + XrSession session; + XrFutureEXT future; + XrCreateSpatialAnchorsCompletionML *completion; + XrResult result; +}; + +struct xrCreateSpatialAnchorsStorageML_params +{ + XrSession session; + const XrSpatialAnchorsCreateStorageInfoML *createInfo; + XrSpatialAnchorsStorageML *storage; + XrResult result; +}; + +struct xrCreateSpatialEntityAnchorBD_params +{ + XrSenseDataProviderBD provider; + const XrSpatialEntityAnchorCreateInfoBD *createInfo; + XrAnchorBD *anchor; + XrResult result; +}; + struct xrCreateSpatialGraphNodeSpaceMSFT_params { XrSession session; @@ -700,6 +880,30 @@ struct xrCreateVirtualKeyboardSpaceMETA_params XrResult result; }; +struct xrCreateWorldMeshDetectorML_params +{ + XrSession session; + const XrWorldMeshDetectorCreateInfoML *createInfo; + XrWorldMeshDetectorML *detector; + XrResult result; +}; + +struct xrDeleteSpatialAnchorsAsyncML_params +{ + XrSpatialAnchorsStorageML storage; + const XrSpatialAnchorsDeleteInfoML *deleteInfo; + XrFutureEXT *future; + XrResult result; +}; + +struct xrDeleteSpatialAnchorsCompleteML_params +{ + XrSpatialAnchorsStorageML storage; + XrFutureEXT future; + XrSpatialAnchorsDeleteCompletionML *completion; + XrResult result; +}; + struct xrDeserializeSceneMSFT_params { XrSceneObserverMSFT sceneObserver; @@ -719,12 +923,30 @@ struct xrDestroyActionSet_params XrResult result; }; +struct xrDestroyAnchorBD_params +{ + XrAnchorBD anchor; + XrResult result; +}; + +struct xrDestroyBodyTrackerBD_params +{ + XrBodyTrackerBD bodyTracker; + XrResult result; +}; + struct xrDestroyBodyTrackerFB_params { XrBodyTrackerFB bodyTracker; XrResult result; }; +struct xrDestroyBodyTrackerHTC_params +{ + XrBodyTrackerHTC bodyTracker; + XrResult result; +}; + struct xrDestroyEnvironmentDepthProviderMETA_params { XrEnvironmentDepthProviderMETA environmentDepthProvider; @@ -761,6 +983,12 @@ struct xrDestroyFaceTrackerFB_params XrResult result; }; +struct xrDestroyFacialExpressionClientML_params +{ + XrFacialExpressionClientML facialExpressionClient; + XrResult result; +}; + struct xrDestroyFacialTrackerHTC_params { XrFacialTrackerHTC facialTracker; @@ -839,6 +1067,18 @@ struct xrDestroySceneObserverMSFT_params XrResult result; }; +struct xrDestroySenseDataProviderBD_params +{ + XrSenseDataProviderBD provider; + XrResult result; +}; + +struct xrDestroySenseDataSnapshotBD_params +{ + XrSenseDataSnapshotBD snapshot; + XrResult result; +}; + struct xrDestroySession_params { XrSession session; @@ -869,6 +1109,12 @@ struct xrDestroySpatialAnchorStoreConnectionMSFT_params XrResult result; }; +struct xrDestroySpatialAnchorsStorageML_params +{ + XrSpatialAnchorsStorageML storage; + XrResult result; +}; + struct xrDestroySpatialGraphNodeBindingMSFT_params { XrSpatialGraphNodeBindingMSFT nodeBinding; @@ -893,6 +1139,28 @@ struct xrDestroyVirtualKeyboardMETA_params XrResult result; }; +struct xrDestroyWorldMeshDetectorML_params +{ + XrWorldMeshDetectorML detector; + XrResult result; +}; + +struct xrDownloadSharedSpatialAnchorAsyncBD_params +{ + XrSenseDataProviderBD provider; + const XrSharedSpatialAnchorDownloadInfoBD *info; + XrFutureEXT *future; + XrResult result; +}; + +struct xrDownloadSharedSpatialAnchorCompleteBD_params +{ + XrSenseDataProviderBD provider; + XrFutureEXT future; + XrFutureCompletionEXT *completion; + XrResult result; +}; + struct xrEnableLocalizationEventsML_params { XrSession session; @@ -1060,6 +1328,16 @@ struct xrEnumerateSpaceSupportedComponentsFB_params XrResult result; }; +struct xrEnumerateSpatialEntityComponentTypesBD_params +{ + XrSenseDataSnapshotBD snapshot; + XrSpatialEntityIdBD entityId; + uint32_t componentTypeCapacityInput; + uint32_t *componentTypeCountOutput; + XrSpatialEntityComponentTypeBD *componentTypes; + XrResult result; +}; + struct xrEnumerateSwapchainFormats_params { XrSession session; @@ -1116,6 +1394,13 @@ struct xrEraseSpaceFB_params XrResult result; }; +struct xrFreeWorldMeshBufferML_params +{ + XrWorldMeshDetectorML detector; + const XrWorldMeshBufferML *buffer; + XrResult result; +}; + struct xrGeometryInstanceSetTransformFB_params { XrGeometryInstanceFB instance; @@ -1155,6 +1440,13 @@ struct xrGetActionStateVector2f_params XrResult result; }; +struct xrGetAnchorUuidBD_params +{ + XrAnchorBD anchor; + XrUuidEXT *uuid; + XrResult result; +}; + struct xrGetAudioInputDeviceGuidOculus_params { XrInstance instance; @@ -1176,6 +1468,15 @@ struct xrGetBodySkeletonFB_params XrResult result; }; +struct xrGetBodySkeletonHTC_params +{ + XrBodyTrackerHTC bodyTracker; + XrSpace baseSpace; + uint32_t skeletonGenerationId; + XrBodySkeletonHTC *skeleton; + XrResult result; +}; + struct xrGetControllerModelKeyMSFT_params { XrSession session; @@ -1263,6 +1564,15 @@ struct xrGetFaceExpressionWeightsFB_params XrResult result; }; +struct xrGetFacialExpressionBlendShapePropertiesML_params +{ + XrFacialExpressionClientML facialExpressionClient; + const XrFacialExpressionBlendShapeGetInfoML *blendShapeGetInfo; + uint32_t blendShapeCount; + XrFacialExpressionBlendShapePropertiesML *blendShapes; + XrResult result; +}; + struct xrGetFacialExpressionsHTC_params { XrFacialTrackerHTC facialTracker; @@ -1405,6 +1715,14 @@ struct xrGetPlanePolygonBufferEXT_params XrResult result; }; +struct xrGetQueriedSenseDataBD_params +{ + XrSenseDataSnapshotBD snapshot; + XrQueriedSenseDataGetInfoBD *getInfo; + XrQueriedSenseDataBD *queriedSenseData; + XrResult result; +}; + struct xrGetRecommendedLayerResolutionMETA_params { XrSession session; @@ -1472,6 +1790,13 @@ struct xrGetSceneMeshBuffersMSFT_params XrResult result; }; +struct xrGetSenseDataProviderStateBD_params +{ + XrSenseDataProviderBD provider; + XrSenseDataProviderStateBD *state; + XrResult result; +}; + struct xrGetSerializedSceneFragmentDataMSFT_params { XrSceneMSFT scene; @@ -1567,6 +1892,29 @@ struct xrGetSpatialAnchorNameHTC_params XrResult result; }; +struct xrGetSpatialAnchorStateML_params +{ + XrSpace anchor; + XrSpatialAnchorStateML *state; + XrResult result; +}; + +struct xrGetSpatialEntityComponentDataBD_params +{ + XrSenseDataSnapshotBD snapshot; + const XrSpatialEntityComponentGetInfoBD *getInfo; + XrSpatialEntityComponentDataBaseHeaderBD *componentData; + XrResult result; +}; + +struct xrGetSpatialEntityUuidBD_params +{ + XrSenseDataSnapshotBD snapshot; + XrSpatialEntityIdBD entityId; + XrUuidEXT *uuid; + XrResult result; +}; + struct xrGetSpatialGraphNodeBindingPropertiesMSFT_params { XrSpatialGraphNodeBindingMSFT nodeBinding; @@ -1701,6 +2049,14 @@ struct xrGetVulkanInstanceExtensionsKHR_params XrResult result; }; +struct xrGetWorldMeshBufferRecommendSizeML_params +{ + XrWorldMeshDetectorML detector; + const XrWorldMeshBufferRecommendedSizeInfoML *sizeInfo; + XrWorldMeshBufferSizeML *size; + XrResult result; +}; + struct xrImportLocalizationMapML_params { XrSession session; @@ -1727,6 +2083,14 @@ struct xrLoadRenderModelFB_params XrResult result; }; +struct xrLocateBodyJointsBD_params +{ + XrBodyTrackerBD bodyTracker; + const XrBodyJointsLocateInfoBD *locateInfo; + XrBodyJointLocationsBD *locations; + XrResult result; +}; + struct xrLocateBodyJointsFB_params { XrBodyTrackerFB bodyTracker; @@ -1735,6 +2099,14 @@ struct xrLocateBodyJointsFB_params XrResult result; }; +struct xrLocateBodyJointsHTC_params +{ + XrBodyTrackerHTC bodyTracker; + const XrBodyJointsLocateInfoHTC *locateInfo; + XrBodyJointLocationsHTC *locations; + XrResult result; +}; + struct xrLocateHandJointsEXT_params { XrHandTrackerEXT handTracker; @@ -1843,6 +2215,22 @@ struct xrPerfSettingsSetPerformanceLevelEXT_params XrResult result; }; +struct xrPersistSpatialAnchorAsyncBD_params +{ + XrSenseDataProviderBD provider; + const XrSpatialAnchorPersistInfoBD *info; + XrFutureEXT *future; + XrResult result; +}; + +struct xrPersistSpatialAnchorCompleteBD_params +{ + XrSenseDataProviderBD provider; + XrFutureEXT future; + XrFutureCompletionEXT *completion; + XrResult result; +}; + struct xrPersistSpatialAnchorMSFT_params { XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore; @@ -1865,6 +2253,22 @@ struct xrPollFutureEXT_params XrResult result; }; +struct xrPublishSpatialAnchorsAsyncML_params +{ + XrSpatialAnchorsStorageML storage; + const XrSpatialAnchorsPublishInfoML *publishInfo; + XrFutureEXT *future; + XrResult result; +}; + +struct xrPublishSpatialAnchorsCompleteML_params +{ + XrSpatialAnchorsStorageML storage; + XrFutureEXT future; + XrSpatialAnchorsPublishCompletionML *completion; + XrResult result; +}; + struct xrQueryLocalizationMapsML_params { XrSession session; @@ -1883,6 +2287,22 @@ struct xrQueryPerformanceMetricsCounterMETA_params XrResult result; }; +struct xrQuerySenseDataAsyncBD_params +{ + XrSenseDataProviderBD provider; + const XrSenseDataQueryInfoBD *queryInfo; + XrFutureEXT *future; + XrResult result; +}; + +struct xrQuerySenseDataCompleteBD_params +{ + XrSenseDataProviderBD provider; + XrFutureEXT future; + XrSenseDataQueryCompletionBD *completion; + XrResult result; +}; + struct xrQuerySpacesFB_params { XrSession session; @@ -1891,6 +2311,22 @@ struct xrQuerySpacesFB_params XrResult result; }; +struct xrQuerySpatialAnchorsAsyncML_params +{ + XrSpatialAnchorsStorageML storage; + const XrSpatialAnchorsQueryInfoBaseHeaderML *queryInfo; + XrFutureEXT *future; + XrResult result; +}; + +struct xrQuerySpatialAnchorsCompleteML_params +{ + XrSpatialAnchorsStorageML storage; + XrFutureEXT future; + XrSpatialAnchorsQueryCompletionML *completion; + XrResult result; +}; + struct xrQuerySystemTrackedKeyboardFB_params { XrSession session; @@ -1934,6 +2370,40 @@ struct xrRequestSceneCaptureFB_params XrResult result; }; +struct xrRequestWorldMeshAsyncML_params +{ + XrWorldMeshDetectorML detector; + const XrWorldMeshGetInfoML *getInfo; + XrWorldMeshBufferML *buffer; + XrFutureEXT *future; + XrResult result; +}; + +struct xrRequestWorldMeshCompleteML_params +{ + XrWorldMeshDetectorML detector; + const XrWorldMeshRequestCompletionInfoML *completionInfo; + XrFutureEXT future; + XrWorldMeshRequestCompletionML *completion; + XrResult result; +}; + +struct xrRequestWorldMeshStateAsyncML_params +{ + XrWorldMeshDetectorML detector; + const XrWorldMeshStateRequestInfoML *stateRequest; + XrFutureEXT *future; + XrResult result; +}; + +struct xrRequestWorldMeshStateCompleteML_params +{ + XrWorldMeshDetectorML detector; + XrFutureEXT future; + XrWorldMeshStateRequestCompletionML *completion; + XrResult result; +}; + struct xrResultToString_params { XrInstance instance; @@ -2086,6 +2556,13 @@ struct xrSetSpaceComponentStatusFB_params XrResult result; }; +struct xrSetSystemNotificationsML_params +{ + XrInstance instance; + const XrSystemNotificationsSetInfoML *info; + XrResult result; +}; + struct xrSetTrackingOptimizationSettingsHintQCOM_params { XrSession session; @@ -2116,6 +2593,30 @@ struct xrShareSpacesFB_params XrResult result; }; +struct xrShareSpacesMETA_params +{ + XrSession session; + const XrShareSpacesInfoMETA *info; + XrAsyncRequestIdFB *requestId; + XrResult result; +}; + +struct xrShareSpatialAnchorAsyncBD_params +{ + XrSenseDataProviderBD provider; + const XrSpatialAnchorShareInfoBD *info; + XrFutureEXT *future; + XrResult result; +}; + +struct xrShareSpatialAnchorCompleteBD_params +{ + XrSenseDataProviderBD provider; + XrFutureEXT future; + XrFutureCompletionEXT *completion; + XrResult result; +}; + struct xrSnapshotMarkerDetectorML_params { XrMarkerDetectorML markerDetector; @@ -2123,12 +2624,60 @@ struct xrSnapshotMarkerDetectorML_params XrResult result; }; +struct xrStartColocationAdvertisementMETA_params +{ + XrSession session; + const XrColocationAdvertisementStartInfoMETA *info; + XrAsyncRequestIdFB *advertisementRequestId; + XrResult result; +}; + +struct xrStartColocationDiscoveryMETA_params +{ + XrSession session; + const XrColocationDiscoveryStartInfoMETA *info; + XrAsyncRequestIdFB *discoveryRequestId; + XrResult result; +}; + struct xrStartEnvironmentDepthProviderMETA_params { XrEnvironmentDepthProviderMETA environmentDepthProvider; XrResult result; }; +struct xrStartSenseDataProviderAsyncBD_params +{ + XrSenseDataProviderBD provider; + const XrSenseDataProviderStartInfoBD *startInfo; + XrFutureEXT *future; + XrResult result; +}; + +struct xrStartSenseDataProviderCompleteBD_params +{ + XrSession session; + XrFutureEXT future; + XrFutureCompletionEXT *completion; + XrResult result; +}; + +struct xrStopColocationAdvertisementMETA_params +{ + XrSession session; + const XrColocationAdvertisementStopInfoMETA *info; + XrAsyncRequestIdFB *requestId; + XrResult result; +}; + +struct xrStopColocationDiscoveryMETA_params +{ + XrSession session; + const XrColocationDiscoveryStopInfoMETA *info; + XrAsyncRequestIdFB *requestId; + XrResult result; +}; + struct xrStopEnvironmentDepthProviderMETA_params { XrEnvironmentDepthProviderMETA environmentDepthProvider; @@ -2142,6 +2691,12 @@ struct xrStopHapticFeedback_params XrResult result; }; +struct xrStopSenseDataProviderBD_params +{ + XrSenseDataProviderBD provider; + XrResult result; +}; + struct xrStringToPath_params { XrInstance instance; @@ -2158,6 +2713,14 @@ struct xrStructureTypeToString_params XrResult result; }; +struct xrStructureTypeToString2KHR_params +{ + XrInstance instance; + XrStructureType value; + char *buffer; + XrResult result; +}; + struct xrSuggestInteractionProfileBindings_params { XrInstance instance; @@ -2238,6 +2801,22 @@ struct xrTryCreateSpatialGraphStaticNodeBindingMSFT_params XrResult result; }; +struct xrUnpersistSpatialAnchorAsyncBD_params +{ + XrSenseDataProviderBD provider; + const XrSpatialAnchorUnpersistInfoBD *info; + XrFutureEXT *future; + XrResult result; +}; + +struct xrUnpersistSpatialAnchorCompleteBD_params +{ + XrSenseDataProviderBD provider; + XrFutureEXT future; + XrFutureCompletionEXT *completion; + XrResult result; +}; + struct xrUnpersistSpatialAnchorMSFT_params { XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore; @@ -2260,6 +2839,22 @@ struct xrUpdatePassthroughColorLutMETA_params XrResult result; }; +struct xrUpdateSpatialAnchorsExpirationAsyncML_params +{ + XrSpatialAnchorsStorageML storage; + const XrSpatialAnchorsUpdateExpirationInfoML *updateInfo; + XrFutureEXT *future; + XrResult result; +}; + +struct xrUpdateSpatialAnchorsExpirationCompleteML_params +{ + XrSpatialAnchorsStorageML storage; + XrFutureEXT future; + XrSpatialAnchorsUpdateExpirationCompletionML *completion; + XrResult result; +}; + struct xrUpdateSwapchainFB_params { XrSwapchain swapchain; diff --git a/wineopenxr/make_openxr b/wineopenxr/make_openxr index cc3bb30c..d3d49cd6 100755 --- a/wineopenxr/make_openxr +++ b/wineopenxr/make_openxr @@ -64,7 +64,7 @@ from enum import Enum LOGGER = logging.Logger("openxr") LOGGER.addHandler(logging.StreamHandler()) -XR_XML_VERSION = "1.1.36" +XR_XML_VERSION = "1.1.47" WINE_XR_VERSION = (1, 1) # Filenames to create. @@ -1631,7 +1631,7 @@ class XrParam(XrVariable): # Determine a format string used by code generation for traces. # 64-bit types need a conversion function. self.format_conv = None - if self.is_static_array() or self.is_pointer(): + if self.is_static_array() or self.is_pointer() or self.type in [ "XrFutureEXT" ]: self.format_str = "%p" else: if self.type_info["category"] in ["bitmask"]: @@ -1667,7 +1667,7 @@ class XrParam(XrVariable): self.format_conv = "wine_dbgstr_longlong({0})" elif self.type in ["HANDLE", "VkInstance"]: self.format_str = "%p" - elif self.type in ["XrSystemId", "XrPath", "XrTime", "XrDuration", "XrControllerModelKeyMSFT", "XrMarkerML"]: + elif self.type in ["XrSystemId", "XrPath", "XrTime", "XrDuration", "XrControllerModelKeyMSFT", "XrMarkerML", "XrSpatialEntityIdBD"]: self.format_str = "0x%s" self.format_conv = "wine_dbgstr_longlong({0})" elif self.type in ["XrVector2f"]: diff --git a/wineopenxr/openxr_thunks.c b/wineopenxr/openxr_thunks.c index 49acc229..20bb33b7 100644 --- a/wineopenxr/openxr_thunks.c +++ b/wineopenxr/openxr_thunks.c @@ -3,7 +3,7 @@ * 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. + * Copyright (c) 2017-2025 The Khronos Group Inc. * * SPDX-License-Identifier: Apache-2.0 OR MIT * @@ -95,6 +95,18 @@ static NTSTATUS thunk64_xrAcquireSwapchainImage(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrAllocateWorldMeshBufferML(void *args) +{ + struct xrAllocateWorldMeshBufferML_params *params = args; + + TRACE("%p, %p, %p\n", params->detector, params->size, params->buffer); + + params->result = g_xr_host_instance_dispatch_table.p_xrAllocateWorldMeshBufferML(params->detector, params->size, params->buffer); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrApplyForceFeedbackCurlMNDX(void *args) { @@ -179,6 +191,30 @@ static NTSTATUS thunk64_xrCancelFutureEXT(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrCaptureSceneAsyncBD(void *args) +{ + struct xrCaptureSceneAsyncBD_params *params = args; + + TRACE("%p, %p, %p\n", params->provider, params->info, params->future); + + params->result = g_xr_host_instance_dispatch_table.p_xrCaptureSceneAsyncBD(params->provider, params->info, params->future); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrCaptureSceneCompleteBD(void *args) +{ + struct xrCaptureSceneCompleteBD_params *params = args; + + TRACE("%p, %p, %p\n", params->provider, params->future, params->completion); + + params->result = g_xr_host_instance_dispatch_table.p_xrCaptureSceneCompleteBD(params->provider, params->future, params->completion); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrChangeVirtualKeyboardTextContextMETA(void *args) { @@ -251,6 +287,30 @@ static NTSTATUS thunk64_xrCreateActionSpace(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateAnchorSpaceBD(void *args) +{ + struct xrCreateAnchorSpaceBD_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->space); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateAnchorSpaceBD(wine_session_from_handle(params->session)->host_session, params->createInfo, params->space); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateBodyTrackerBD(void *args) +{ + struct xrCreateBodyTrackerBD_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->bodyTracker); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateBodyTrackerBD(wine_session_from_handle(params->session)->host_session, params->createInfo, params->bodyTracker); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrCreateBodyTrackerFB(void *args) { @@ -263,6 +323,18 @@ static NTSTATUS thunk64_xrCreateBodyTrackerFB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateBodyTrackerHTC(void *args) +{ + struct xrCreateBodyTrackerHTC_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->bodyTracker); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateBodyTrackerHTC(wine_session_from_handle(params->session)->host_session, params->createInfo, params->bodyTracker); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrCreateEnvironmentDepthProviderMETA(void *args) { @@ -335,6 +407,18 @@ static NTSTATUS thunk64_xrCreateFaceTrackerFB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateFacialExpressionClientML(void *args) +{ + struct xrCreateFacialExpressionClientML_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->facialExpressionClient); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateFacialExpressionClientML(wine_session_from_handle(params->session)->host_session, params->createInfo, params->facialExpressionClient); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrCreateFacialTrackerHTC(void *args) { @@ -557,6 +641,18 @@ static NTSTATUS thunk64_xrCreateSceneObserverMSFT(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSenseDataProviderBD(void *args) +{ + struct xrCreateSenseDataProviderBD_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->provider); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSenseDataProviderBD(wine_session_from_handle(params->session)->host_session, params->createInfo, params->provider); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrCreateSession(void *args) { @@ -581,6 +677,30 @@ static NTSTATUS thunk64_xrCreateSpaceUserFB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSpatialAnchorAsyncBD(void *args) +{ + struct xrCreateSpatialAnchorAsyncBD_params *params = args; + + TRACE("%p, %p, %p\n", params->provider, params->info, params->future); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSpatialAnchorAsyncBD(params->provider, params->info, params->future); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSpatialAnchorCompleteBD(void *args) +{ + struct xrCreateSpatialAnchorCompleteBD_params *params = args; + + TRACE("%p, %p, %p\n", params->provider, params->future, params->completion); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSpatialAnchorCompleteBD(params->provider, params->future, params->completion); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrCreateSpatialAnchorFB(void *args) { @@ -653,6 +773,54 @@ static NTSTATUS thunk64_xrCreateSpatialAnchorStoreConnectionMSFT(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSpatialAnchorsAsyncML(void *args) +{ + struct xrCreateSpatialAnchorsAsyncML_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->future); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSpatialAnchorsAsyncML(wine_session_from_handle(params->session)->host_session, params->createInfo, params->future); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSpatialAnchorsCompleteML(void *args) +{ + struct xrCreateSpatialAnchorsCompleteML_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->future, params->completion); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSpatialAnchorsCompleteML(wine_session_from_handle(params->session)->host_session, params->future, params->completion); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSpatialAnchorsStorageML(void *args) +{ + struct xrCreateSpatialAnchorsStorageML_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->storage); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSpatialAnchorsStorageML(wine_session_from_handle(params->session)->host_session, params->createInfo, params->storage); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSpatialEntityAnchorBD(void *args) +{ + struct xrCreateSpatialEntityAnchorBD_params *params = args; + + TRACE("%p, %p, %p\n", params->provider, params->createInfo, params->anchor); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSpatialEntityAnchorBD(params->provider, params->createInfo, params->anchor); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrCreateSpatialGraphNodeSpaceMSFT(void *args) { @@ -713,6 +881,42 @@ static NTSTATUS thunk64_xrCreateVirtualKeyboardSpaceMETA(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateWorldMeshDetectorML(void *args) +{ + struct xrCreateWorldMeshDetectorML_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->detector); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateWorldMeshDetectorML(wine_session_from_handle(params->session)->host_session, params->createInfo, params->detector); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrDeleteSpatialAnchorsAsyncML(void *args) +{ + struct xrDeleteSpatialAnchorsAsyncML_params *params = args; + + TRACE("%p, %p, %p\n", params->storage, params->deleteInfo, params->future); + + params->result = g_xr_host_instance_dispatch_table.p_xrDeleteSpatialAnchorsAsyncML(params->storage, params->deleteInfo, params->future); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrDeleteSpatialAnchorsCompleteML(void *args) +{ + struct xrDeleteSpatialAnchorsCompleteML_params *params = args; + + TRACE("%p, %p, %p\n", params->storage, params->future, params->completion); + + params->result = g_xr_host_instance_dispatch_table.p_xrDeleteSpatialAnchorsCompleteML(params->storage, params->future, params->completion); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrDeserializeSceneMSFT(void *args) { @@ -749,6 +953,30 @@ static NTSTATUS thunk64_xrDestroyActionSet(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyAnchorBD(void *args) +{ + struct xrDestroyAnchorBD_params *params = args; + + TRACE("%p\n", params->anchor); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyAnchorBD(params->anchor); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyBodyTrackerBD(void *args) +{ + struct xrDestroyBodyTrackerBD_params *params = args; + + TRACE("%p\n", params->bodyTracker); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyBodyTrackerBD(params->bodyTracker); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrDestroyBodyTrackerFB(void *args) { @@ -761,6 +989,18 @@ static NTSTATUS thunk64_xrDestroyBodyTrackerFB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyBodyTrackerHTC(void *args) +{ + struct xrDestroyBodyTrackerHTC_params *params = args; + + TRACE("%p\n", params->bodyTracker); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyBodyTrackerHTC(params->bodyTracker); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrDestroyEnvironmentDepthProviderMETA(void *args) { @@ -833,6 +1073,18 @@ static NTSTATUS thunk64_xrDestroyFaceTrackerFB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyFacialExpressionClientML(void *args) +{ + struct xrDestroyFacialExpressionClientML_params *params = args; + + TRACE("%p\n", params->facialExpressionClient); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyFacialExpressionClientML(params->facialExpressionClient); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrDestroyFacialTrackerHTC(void *args) { @@ -989,6 +1241,30 @@ static NTSTATUS thunk64_xrDestroySceneObserverMSFT(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroySenseDataProviderBD(void *args) +{ + struct xrDestroySenseDataProviderBD_params *params = args; + + TRACE("%p\n", params->provider); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroySenseDataProviderBD(params->provider); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroySenseDataSnapshotBD(void *args) +{ + struct xrDestroySenseDataSnapshotBD_params *params = args; + + TRACE("%p\n", params->snapshot); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroySenseDataSnapshotBD(params->snapshot); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrDestroySession(void *args) { @@ -1049,6 +1325,18 @@ static NTSTATUS thunk64_xrDestroySpatialAnchorStoreConnectionMSFT(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroySpatialAnchorsStorageML(void *args) +{ + struct xrDestroySpatialAnchorsStorageML_params *params = args; + + TRACE("%p\n", params->storage); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroySpatialAnchorsStorageML(params->storage); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrDestroySpatialGraphNodeBindingMSFT(void *args) { @@ -1097,6 +1385,42 @@ static NTSTATUS thunk64_xrDestroyVirtualKeyboardMETA(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyWorldMeshDetectorML(void *args) +{ + struct xrDestroyWorldMeshDetectorML_params *params = args; + + TRACE("%p\n", params->detector); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyWorldMeshDetectorML(params->detector); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrDownloadSharedSpatialAnchorAsyncBD(void *args) +{ + struct xrDownloadSharedSpatialAnchorAsyncBD_params *params = args; + + TRACE("%p, %p, %p\n", params->provider, params->info, params->future); + + params->result = g_xr_host_instance_dispatch_table.p_xrDownloadSharedSpatialAnchorAsyncBD(params->provider, params->info, params->future); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrDownloadSharedSpatialAnchorCompleteBD(void *args) +{ + struct xrDownloadSharedSpatialAnchorCompleteBD_params *params = args; + + TRACE("%p, %p, %p\n", params->provider, params->future, params->completion); + + params->result = g_xr_host_instance_dispatch_table.p_xrDownloadSharedSpatialAnchorCompleteBD(params->provider, params->future, params->completion); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrEnableLocalizationEventsML(void *args) { @@ -1325,6 +1649,18 @@ static NTSTATUS thunk64_xrEnumerateSpaceSupportedComponentsFB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateSpatialEntityComponentTypesBD(void *args) +{ + struct xrEnumerateSpatialEntityComponentTypesBD_params *params = args; + + TRACE("%p, 0x%s, %u, %p, %p\n", params->snapshot, wine_dbgstr_longlong(params->entityId), params->componentTypeCapacityInput, params->componentTypeCountOutput, params->componentTypes); + + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateSpatialEntityComponentTypesBD(params->snapshot, params->entityId, params->componentTypeCapacityInput, params->componentTypeCountOutput, params->componentTypes); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrEnumerateSwapchainFormats(void *args) { @@ -1397,6 +1733,18 @@ static NTSTATUS thunk64_xrEraseSpaceFB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrFreeWorldMeshBufferML(void *args) +{ + struct xrFreeWorldMeshBufferML_params *params = args; + + TRACE("%p, %p\n", params->detector, params->buffer); + + params->result = g_xr_host_instance_dispatch_table.p_xrFreeWorldMeshBufferML(params->detector, params->buffer); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrGeometryInstanceSetTransformFB(void *args) { @@ -1457,6 +1805,18 @@ static NTSTATUS thunk64_xrGetActionStateVector2f(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetAnchorUuidBD(void *args) +{ + struct xrGetAnchorUuidBD_params *params = args; + + TRACE("%p, %p\n", params->anchor, params->uuid); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetAnchorUuidBD(params->anchor, params->uuid); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrGetAudioInputDeviceGuidOculus(void *args) { @@ -1493,6 +1853,18 @@ static NTSTATUS thunk64_xrGetBodySkeletonFB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetBodySkeletonHTC(void *args) +{ + struct xrGetBodySkeletonHTC_params *params = args; + + TRACE("%p, %p, %u, %p\n", params->bodyTracker, params->baseSpace, params->skeletonGenerationId, params->skeleton); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetBodySkeletonHTC(params->bodyTracker, params->baseSpace, params->skeletonGenerationId, params->skeleton); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrGetControllerModelKeyMSFT(void *args) { @@ -1625,6 +1997,18 @@ static NTSTATUS thunk64_xrGetFaceExpressionWeightsFB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetFacialExpressionBlendShapePropertiesML(void *args) +{ + struct xrGetFacialExpressionBlendShapePropertiesML_params *params = args; + + TRACE("%p, %p, %u, %p\n", params->facialExpressionClient, params->blendShapeGetInfo, params->blendShapeCount, params->blendShapes); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetFacialExpressionBlendShapePropertiesML(params->facialExpressionClient, params->blendShapeGetInfo, params->blendShapeCount, params->blendShapes); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrGetFacialExpressionsHTC(void *args) { @@ -1841,6 +2225,18 @@ static NTSTATUS thunk64_xrGetPlanePolygonBufferEXT(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetQueriedSenseDataBD(void *args) +{ + struct xrGetQueriedSenseDataBD_params *params = args; + + TRACE("%p, %p, %p\n", params->snapshot, params->getInfo, params->queriedSenseData); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetQueriedSenseDataBD(params->snapshot, params->getInfo, params->queriedSenseData); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrGetRecommendedLayerResolutionMETA(void *args) { @@ -1937,6 +2333,18 @@ static NTSTATUS thunk64_xrGetSceneMeshBuffersMSFT(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSenseDataProviderStateBD(void *args) +{ + struct xrGetSenseDataProviderStateBD_params *params = args; + + TRACE("%p, %p\n", params->provider, params->state); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetSenseDataProviderStateBD(params->provider, params->state); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrGetSerializedSceneFragmentDataMSFT(void *args) { @@ -2081,6 +2489,42 @@ static NTSTATUS thunk64_xrGetSpatialAnchorNameHTC(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSpatialAnchorStateML(void *args) +{ + struct xrGetSpatialAnchorStateML_params *params = args; + + TRACE("%p, %p\n", params->anchor, params->state); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetSpatialAnchorStateML(params->anchor, params->state); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSpatialEntityComponentDataBD(void *args) +{ + struct xrGetSpatialEntityComponentDataBD_params *params = args; + + TRACE("%p, %p, %p\n", params->snapshot, params->getInfo, params->componentData); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetSpatialEntityComponentDataBD(params->snapshot, params->getInfo, params->componentData); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSpatialEntityUuidBD(void *args) +{ + struct xrGetSpatialEntityUuidBD_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->snapshot, wine_dbgstr_longlong(params->entityId), params->uuid); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetSpatialEntityUuidBD(params->snapshot, params->entityId, params->uuid); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrGetSpatialGraphNodeBindingPropertiesMSFT(void *args) { @@ -2273,6 +2717,18 @@ static NTSTATUS thunk64_xrGetVulkanInstanceExtensionsKHR(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetWorldMeshBufferRecommendSizeML(void *args) +{ + struct xrGetWorldMeshBufferRecommendSizeML_params *params = args; + + TRACE("%p, %p, %p\n", params->detector, params->sizeInfo, params->size); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetWorldMeshBufferRecommendSizeML(params->detector, params->sizeInfo, params->size); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrImportLocalizationMapML(void *args) { @@ -2309,6 +2765,18 @@ static NTSTATUS thunk64_xrLoadRenderModelFB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrLocateBodyJointsBD(void *args) +{ + struct xrLocateBodyJointsBD_params *params = args; + + TRACE("%p, %p, %p\n", params->bodyTracker, params->locateInfo, params->locations); + + params->result = g_xr_host_instance_dispatch_table.p_xrLocateBodyJointsBD(params->bodyTracker, params->locateInfo, params->locations); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrLocateBodyJointsFB(void *args) { @@ -2321,6 +2789,18 @@ static NTSTATUS thunk64_xrLocateBodyJointsFB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrLocateBodyJointsHTC(void *args) +{ + struct xrLocateBodyJointsHTC_params *params = args; + + TRACE("%p, %p, %p\n", params->bodyTracker, params->locateInfo, params->locations); + + params->result = g_xr_host_instance_dispatch_table.p_xrLocateBodyJointsHTC(params->bodyTracker, params->locateInfo, params->locations); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrLocateHandJointsEXT(void *args) { @@ -2489,6 +2969,30 @@ static NTSTATUS thunk64_xrPerfSettingsSetPerformanceLevelEXT(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrPersistSpatialAnchorAsyncBD(void *args) +{ + struct xrPersistSpatialAnchorAsyncBD_params *params = args; + + TRACE("%p, %p, %p\n", params->provider, params->info, params->future); + + params->result = g_xr_host_instance_dispatch_table.p_xrPersistSpatialAnchorAsyncBD(params->provider, params->info, params->future); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrPersistSpatialAnchorCompleteBD(void *args) +{ + struct xrPersistSpatialAnchorCompleteBD_params *params = args; + + TRACE("%p, %p, %p\n", params->provider, params->future, params->completion); + + params->result = g_xr_host_instance_dispatch_table.p_xrPersistSpatialAnchorCompleteBD(params->provider, params->future, params->completion); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrPersistSpatialAnchorMSFT(void *args) { @@ -2525,6 +3029,30 @@ static NTSTATUS thunk64_xrPollFutureEXT(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrPublishSpatialAnchorsAsyncML(void *args) +{ + struct xrPublishSpatialAnchorsAsyncML_params *params = args; + + TRACE("%p, %p, %p\n", params->storage, params->publishInfo, params->future); + + params->result = g_xr_host_instance_dispatch_table.p_xrPublishSpatialAnchorsAsyncML(params->storage, params->publishInfo, params->future); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrPublishSpatialAnchorsCompleteML(void *args) +{ + struct xrPublishSpatialAnchorsCompleteML_params *params = args; + + TRACE("%p, %p, %p\n", params->storage, params->future, params->completion); + + params->result = g_xr_host_instance_dispatch_table.p_xrPublishSpatialAnchorsCompleteML(params->storage, params->future, params->completion); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrQueryLocalizationMapsML(void *args) { @@ -2549,6 +3077,30 @@ static NTSTATUS thunk64_xrQueryPerformanceMetricsCounterMETA(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrQuerySenseDataAsyncBD(void *args) +{ + struct xrQuerySenseDataAsyncBD_params *params = args; + + TRACE("%p, %p, %p\n", params->provider, params->queryInfo, params->future); + + params->result = g_xr_host_instance_dispatch_table.p_xrQuerySenseDataAsyncBD(params->provider, params->queryInfo, params->future); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrQuerySenseDataCompleteBD(void *args) +{ + struct xrQuerySenseDataCompleteBD_params *params = args; + + TRACE("%p, %p, %p\n", params->provider, params->future, params->completion); + + params->result = g_xr_host_instance_dispatch_table.p_xrQuerySenseDataCompleteBD(params->provider, params->future, params->completion); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrQuerySpacesFB(void *args) { @@ -2561,6 +3113,30 @@ static NTSTATUS thunk64_xrQuerySpacesFB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrQuerySpatialAnchorsAsyncML(void *args) +{ + struct xrQuerySpatialAnchorsAsyncML_params *params = args; + + TRACE("%p, %p, %p\n", params->storage, params->queryInfo, params->future); + + params->result = g_xr_host_instance_dispatch_table.p_xrQuerySpatialAnchorsAsyncML(params->storage, params->queryInfo, params->future); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrQuerySpatialAnchorsCompleteML(void *args) +{ + struct xrQuerySpatialAnchorsCompleteML_params *params = args; + + TRACE("%p, %p, %p\n", params->storage, params->future, params->completion); + + params->result = g_xr_host_instance_dispatch_table.p_xrQuerySpatialAnchorsCompleteML(params->storage, params->future, params->completion); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrQuerySystemTrackedKeyboardFB(void *args) { @@ -2633,6 +3209,54 @@ static NTSTATUS thunk64_xrRequestSceneCaptureFB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrRequestWorldMeshAsyncML(void *args) +{ + struct xrRequestWorldMeshAsyncML_params *params = args; + + TRACE("%p, %p, %p, %p\n", params->detector, params->getInfo, params->buffer, params->future); + + params->result = g_xr_host_instance_dispatch_table.p_xrRequestWorldMeshAsyncML(params->detector, params->getInfo, params->buffer, params->future); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrRequestWorldMeshCompleteML(void *args) +{ + struct xrRequestWorldMeshCompleteML_params *params = args; + + TRACE("%p, %p, %p, %p\n", params->detector, params->completionInfo, params->future, params->completion); + + params->result = g_xr_host_instance_dispatch_table.p_xrRequestWorldMeshCompleteML(params->detector, params->completionInfo, params->future, params->completion); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrRequestWorldMeshStateAsyncML(void *args) +{ + struct xrRequestWorldMeshStateAsyncML_params *params = args; + + TRACE("%p, %p, %p\n", params->detector, params->stateRequest, params->future); + + params->result = g_xr_host_instance_dispatch_table.p_xrRequestWorldMeshStateAsyncML(params->detector, params->stateRequest, params->future); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrRequestWorldMeshStateCompleteML(void *args) +{ + struct xrRequestWorldMeshStateCompleteML_params *params = args; + + TRACE("%p, %p, %p\n", params->detector, params->future, params->completion); + + params->result = g_xr_host_instance_dispatch_table.p_xrRequestWorldMeshStateCompleteML(params->detector, params->future, params->completion); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrResultToString(void *args) { @@ -2861,6 +3485,18 @@ static NTSTATUS thunk64_xrSetSpaceComponentStatusFB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetSystemNotificationsML(void *args) +{ + struct xrSetSystemNotificationsML_params *params = args; + + TRACE("%p, %p\n", params->instance, params->info); + + params->result = g_xr_host_instance_dispatch_table.p_xrSetSystemNotificationsML(wine_instance_from_handle(params->instance)->host_instance, params->info); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrSetTrackingOptimizationSettingsHintQCOM(void *args) { @@ -2909,6 +3545,42 @@ static NTSTATUS thunk64_xrShareSpacesFB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrShareSpacesMETA(void *args) +{ + struct xrShareSpacesMETA_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->info, params->requestId); + + params->result = g_xr_host_instance_dispatch_table.p_xrShareSpacesMETA(wine_session_from_handle(params->session)->host_session, params->info, params->requestId); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrShareSpatialAnchorAsyncBD(void *args) +{ + struct xrShareSpatialAnchorAsyncBD_params *params = args; + + TRACE("%p, %p, %p\n", params->provider, params->info, params->future); + + params->result = g_xr_host_instance_dispatch_table.p_xrShareSpatialAnchorAsyncBD(params->provider, params->info, params->future); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrShareSpatialAnchorCompleteBD(void *args) +{ + struct xrShareSpatialAnchorCompleteBD_params *params = args; + + TRACE("%p, %p, %p\n", params->provider, params->future, params->completion); + + params->result = g_xr_host_instance_dispatch_table.p_xrShareSpatialAnchorCompleteBD(params->provider, params->future, params->completion); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrSnapshotMarkerDetectorML(void *args) { @@ -2921,6 +3593,30 @@ static NTSTATUS thunk64_xrSnapshotMarkerDetectorML(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrStartColocationAdvertisementMETA(void *args) +{ + struct xrStartColocationAdvertisementMETA_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->info, params->advertisementRequestId); + + params->result = g_xr_host_instance_dispatch_table.p_xrStartColocationAdvertisementMETA(wine_session_from_handle(params->session)->host_session, params->info, params->advertisementRequestId); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrStartColocationDiscoveryMETA(void *args) +{ + struct xrStartColocationDiscoveryMETA_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->info, params->discoveryRequestId); + + params->result = g_xr_host_instance_dispatch_table.p_xrStartColocationDiscoveryMETA(wine_session_from_handle(params->session)->host_session, params->info, params->discoveryRequestId); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrStartEnvironmentDepthProviderMETA(void *args) { @@ -2933,6 +3629,54 @@ static NTSTATUS thunk64_xrStartEnvironmentDepthProviderMETA(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrStartSenseDataProviderAsyncBD(void *args) +{ + struct xrStartSenseDataProviderAsyncBD_params *params = args; + + TRACE("%p, %p, %p\n", params->provider, params->startInfo, params->future); + + params->result = g_xr_host_instance_dispatch_table.p_xrStartSenseDataProviderAsyncBD(params->provider, params->startInfo, params->future); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrStartSenseDataProviderCompleteBD(void *args) +{ + struct xrStartSenseDataProviderCompleteBD_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->future, params->completion); + + params->result = g_xr_host_instance_dispatch_table.p_xrStartSenseDataProviderCompleteBD(wine_session_from_handle(params->session)->host_session, params->future, params->completion); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrStopColocationAdvertisementMETA(void *args) +{ + struct xrStopColocationAdvertisementMETA_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->info, params->requestId); + + params->result = g_xr_host_instance_dispatch_table.p_xrStopColocationAdvertisementMETA(wine_session_from_handle(params->session)->host_session, params->info, params->requestId); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrStopColocationDiscoveryMETA(void *args) +{ + struct xrStopColocationDiscoveryMETA_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->info, params->requestId); + + params->result = g_xr_host_instance_dispatch_table.p_xrStopColocationDiscoveryMETA(wine_session_from_handle(params->session)->host_session, params->info, params->requestId); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrStopEnvironmentDepthProviderMETA(void *args) { @@ -2957,6 +3701,18 @@ static NTSTATUS thunk64_xrStopHapticFeedback(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrStopSenseDataProviderBD(void *args) +{ + struct xrStopSenseDataProviderBD_params *params = args; + + TRACE("%p\n", params->provider); + + params->result = g_xr_host_instance_dispatch_table.p_xrStopSenseDataProviderBD(params->provider); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrStringToPath(void *args) { @@ -2981,6 +3737,18 @@ static NTSTATUS thunk64_xrStructureTypeToString(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrStructureTypeToString2KHR(void *args) +{ + struct xrStructureTypeToString2KHR_params *params = args; + + TRACE("%p, %#x, %p\n", params->instance, params->value, params->buffer); + + params->result = g_xr_host_instance_dispatch_table.p_xrStructureTypeToString2KHR(wine_instance_from_handle(params->instance)->host_instance, params->value, params->buffer); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrSuggestInteractionProfileBindings(void *args) { @@ -3113,6 +3881,30 @@ static NTSTATUS thunk64_xrTryCreateSpatialGraphStaticNodeBindingMSFT(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrUnpersistSpatialAnchorAsyncBD(void *args) +{ + struct xrUnpersistSpatialAnchorAsyncBD_params *params = args; + + TRACE("%p, %p, %p\n", params->provider, params->info, params->future); + + params->result = g_xr_host_instance_dispatch_table.p_xrUnpersistSpatialAnchorAsyncBD(params->provider, params->info, params->future); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrUnpersistSpatialAnchorCompleteBD(void *args) +{ + struct xrUnpersistSpatialAnchorCompleteBD_params *params = args; + + TRACE("%p, %p, %p\n", params->provider, params->future, params->completion); + + params->result = g_xr_host_instance_dispatch_table.p_xrUnpersistSpatialAnchorCompleteBD(params->provider, params->future, params->completion); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrUnpersistSpatialAnchorMSFT(void *args) { @@ -3149,6 +3941,30 @@ static NTSTATUS thunk64_xrUpdatePassthroughColorLutMETA(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrUpdateSpatialAnchorsExpirationAsyncML(void *args) +{ + struct xrUpdateSpatialAnchorsExpirationAsyncML_params *params = args; + + TRACE("%p, %p, %p\n", params->storage, params->updateInfo, params->future); + + params->result = g_xr_host_instance_dispatch_table.p_xrUpdateSpatialAnchorsExpirationAsyncML(params->storage, params->updateInfo, params->future); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrUpdateSpatialAnchorsExpirationCompleteML(void *args) +{ + struct xrUpdateSpatialAnchorsExpirationCompleteML_params *params = args; + + TRACE("%p, %p, %p\n", params->storage, params->future, params->completion); + + params->result = g_xr_host_instance_dispatch_table.p_xrUpdateSpatialAnchorsExpirationCompleteML(params->storage, params->future, params->completion); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrUpdateSwapchainFB(void *args) { @@ -3188,13 +4004,21 @@ static NTSTATUS thunk64_xrWaitSwapchainImage(void *args) static const char * const xr_extensions[] = { "XR_ALMALENCE_digital_lens_control", + "XR_BD_body_tracking", "XR_BD_controller_interaction", + "XR_BD_spatial_anchor", + "XR_BD_spatial_anchor_sharing", + "XR_BD_spatial_mesh", + "XR_BD_spatial_scene", + "XR_BD_spatial_sensing", "XR_EPIC_view_configuration_fov", "XR_EXTX_overlay", "XR_EXT_active_action_set_priority", + "XR_EXT_composition_layer_inverted_alpha", "XR_EXT_conformance_automation", "XR_EXT_dpad_binding", "XR_EXT_eye_gaze_interaction", + "XR_EXT_frame_synthesis", "XR_EXT_future", "XR_EXT_hand_interaction", "XR_EXT_hand_joints_motion_range", @@ -3251,6 +4075,7 @@ static const char * const xr_extensions[] = "XR_FB_triangle_mesh", "XR_HTCX_vive_tracker_interaction", "XR_HTC_anchor", + "XR_HTC_body_tracking", "XR_HTC_facial_tracking", "XR_HTC_hand_interaction", "XR_HTC_passthrough", @@ -3267,6 +4092,7 @@ static const char * const xr_extensions[] = "XR_KHR_composition_layer_depth", "XR_KHR_composition_layer_equirect", "XR_KHR_composition_layer_equirect2", + "XR_KHR_extended_struct_name_lengths", "XR_KHR_locate_spaces", "XR_KHR_maintenance1", "XR_KHR_opengl_enable", @@ -3276,25 +4102,38 @@ static const char * const xr_extensions[] = "XR_KHR_vulkan_enable2", "XR_KHR_vulkan_swapchain_format_list", "XR_KHR_win32_convert_performance_counter_time", + "XR_LOGITECH_mx_ink_stylus_interaction", "XR_META_automatic_layer_filter", + "XR_META_colocation_discovery", + "XR_META_detached_controllers", "XR_META_environment_depth", "XR_META_foveation_eye_tracked", + "XR_META_hand_tracking_microgestures", "XR_META_headset_id", "XR_META_local_dimming", "XR_META_passthrough_color_lut", + "XR_META_passthrough_layer_resumed_event", "XR_META_passthrough_preferences", "XR_META_performance_metrics", "XR_META_recommended_layer_resolution", + "XR_META_spatial_entity_group_sharing", "XR_META_spatial_entity_mesh", + "XR_META_spatial_entity_sharing", "XR_META_touch_controller_plus", "XR_META_virtual_keyboard", "XR_META_vulkan_swapchain_create_info", + "XR_ML_facial_expression", "XR_ML_frame_end_info", "XR_ML_global_dimmer", "XR_ML_localization_map", "XR_ML_marker_understanding", "XR_ML_ml2_controller_interaction", + "XR_ML_spatial_anchors", + "XR_ML_spatial_anchors_storage", + "XR_ML_system_notifications", "XR_ML_user_calibration", + "XR_ML_view_configuration_depth_range_change", + "XR_ML_world_mesh_detection", "XR_MNDX_force_feedback_curl", "XR_MND_headless", "XR_MND_swapchain_usage_input_attachment_bit", @@ -3355,6 +4194,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = init_openxr, thunk64_xrAcquireEnvironmentDepthImageMETA, thunk64_xrAcquireSwapchainImage, + thunk64_xrAllocateWorldMeshBufferML, thunk64_xrApplyForceFeedbackCurlMNDX, thunk64_xrApplyHapticFeedback, thunk64_xrAttachSessionActionSets, @@ -3362,19 +4202,25 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrBeginPlaneDetectionEXT, thunk64_xrBeginSession, thunk64_xrCancelFutureEXT, + thunk64_xrCaptureSceneAsyncBD, + thunk64_xrCaptureSceneCompleteBD, thunk64_xrChangeVirtualKeyboardTextContextMETA, thunk64_xrClearSpatialAnchorStoreMSFT, thunk64_xrComputeNewSceneMSFT, thunk64_xrCreateAction, thunk64_xrCreateActionSet, thunk64_xrCreateActionSpace, + thunk64_xrCreateAnchorSpaceBD, + thunk64_xrCreateBodyTrackerBD, thunk64_xrCreateBodyTrackerFB, + thunk64_xrCreateBodyTrackerHTC, thunk64_xrCreateEnvironmentDepthProviderMETA, thunk64_xrCreateEnvironmentDepthSwapchainMETA, thunk64_xrCreateExportedLocalizationMapML, thunk64_xrCreateEyeTrackerFB, thunk64_xrCreateFaceTracker2FB, thunk64_xrCreateFaceTrackerFB, + thunk64_xrCreateFacialExpressionClientML, thunk64_xrCreateFacialTrackerHTC, thunk64_xrCreateFoveationProfileFB, thunk64_xrCreateGeometryInstanceFB, @@ -3393,29 +4239,43 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrCreateReferenceSpace, thunk64_xrCreateSceneMSFT, thunk64_xrCreateSceneObserverMSFT, + thunk64_xrCreateSenseDataProviderBD, thunk64_xrCreateSession, thunk64_xrCreateSpaceUserFB, + thunk64_xrCreateSpatialAnchorAsyncBD, + thunk64_xrCreateSpatialAnchorCompleteBD, thunk64_xrCreateSpatialAnchorFB, thunk64_xrCreateSpatialAnchorFromPersistedNameMSFT, thunk64_xrCreateSpatialAnchorHTC, thunk64_xrCreateSpatialAnchorMSFT, thunk64_xrCreateSpatialAnchorSpaceMSFT, thunk64_xrCreateSpatialAnchorStoreConnectionMSFT, + thunk64_xrCreateSpatialAnchorsAsyncML, + thunk64_xrCreateSpatialAnchorsCompleteML, + thunk64_xrCreateSpatialAnchorsStorageML, + thunk64_xrCreateSpatialEntityAnchorBD, thunk64_xrCreateSpatialGraphNodeSpaceMSFT, thunk64_xrCreateSwapchain, thunk64_xrCreateTriangleMeshFB, thunk64_xrCreateVirtualKeyboardMETA, thunk64_xrCreateVirtualKeyboardSpaceMETA, + thunk64_xrCreateWorldMeshDetectorML, + thunk64_xrDeleteSpatialAnchorsAsyncML, + thunk64_xrDeleteSpatialAnchorsCompleteML, thunk64_xrDeserializeSceneMSFT, thunk64_xrDestroyAction, thunk64_xrDestroyActionSet, + thunk64_xrDestroyAnchorBD, + thunk64_xrDestroyBodyTrackerBD, thunk64_xrDestroyBodyTrackerFB, + thunk64_xrDestroyBodyTrackerHTC, thunk64_xrDestroyEnvironmentDepthProviderMETA, thunk64_xrDestroyEnvironmentDepthSwapchainMETA, thunk64_xrDestroyExportedLocalizationMapML, thunk64_xrDestroyEyeTrackerFB, thunk64_xrDestroyFaceTracker2FB, thunk64_xrDestroyFaceTrackerFB, + thunk64_xrDestroyFacialExpressionClientML, thunk64_xrDestroyFacialTrackerHTC, thunk64_xrDestroyFoveationProfileFB, thunk64_xrDestroyGeometryInstanceFB, @@ -3429,15 +4289,21 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrDestroyPlaneDetectorEXT, thunk64_xrDestroySceneMSFT, thunk64_xrDestroySceneObserverMSFT, + thunk64_xrDestroySenseDataProviderBD, + thunk64_xrDestroySenseDataSnapshotBD, thunk64_xrDestroySession, thunk64_xrDestroySpace, thunk64_xrDestroySpaceUserFB, thunk64_xrDestroySpatialAnchorMSFT, thunk64_xrDestroySpatialAnchorStoreConnectionMSFT, + thunk64_xrDestroySpatialAnchorsStorageML, thunk64_xrDestroySpatialGraphNodeBindingMSFT, thunk64_xrDestroySwapchain, thunk64_xrDestroyTriangleMeshFB, thunk64_xrDestroyVirtualKeyboardMETA, + thunk64_xrDestroyWorldMeshDetectorML, + thunk64_xrDownloadSharedSpatialAnchorAsyncBD, + thunk64_xrDownloadSharedSpatialAnchorCompleteBD, thunk64_xrEnableLocalizationEventsML, thunk64_xrEnableUserCalibrationEventsML, thunk64_xrEndFrame, @@ -3457,20 +4323,24 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrEnumerateReprojectionModesMSFT, thunk64_xrEnumerateSceneComputeFeaturesMSFT, thunk64_xrEnumerateSpaceSupportedComponentsFB, + thunk64_xrEnumerateSpatialEntityComponentTypesBD, thunk64_xrEnumerateSwapchainFormats, thunk64_xrEnumerateSwapchainImages, thunk64_xrEnumerateViewConfigurationViews, thunk64_xrEnumerateViewConfigurations, thunk64_xrEnumerateViveTrackerPathsHTCX, thunk64_xrEraseSpaceFB, + thunk64_xrFreeWorldMeshBufferML, thunk64_xrGeometryInstanceSetTransformFB, thunk64_xrGetActionStateBoolean, thunk64_xrGetActionStateFloat, thunk64_xrGetActionStatePose, thunk64_xrGetActionStateVector2f, + thunk64_xrGetAnchorUuidBD, thunk64_xrGetAudioInputDeviceGuidOculus, thunk64_xrGetAudioOutputDeviceGuidOculus, thunk64_xrGetBodySkeletonFB, + thunk64_xrGetBodySkeletonHTC, thunk64_xrGetControllerModelKeyMSFT, thunk64_xrGetControllerModelPropertiesMSFT, thunk64_xrGetControllerModelStateMSFT, @@ -3482,6 +4352,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrGetEyeGazesFB, thunk64_xrGetFaceExpressionWeights2FB, thunk64_xrGetFaceExpressionWeightsFB, + thunk64_xrGetFacialExpressionBlendShapePropertiesML, thunk64_xrGetFacialExpressionsHTC, thunk64_xrGetFoveationEyeTrackedStateMETA, thunk64_xrGetHandMeshFB, @@ -3500,6 +4371,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrGetPlaneDetectionStateEXT, thunk64_xrGetPlaneDetectionsEXT, thunk64_xrGetPlanePolygonBufferEXT, + thunk64_xrGetQueriedSenseDataBD, thunk64_xrGetRecommendedLayerResolutionMETA, thunk64_xrGetReferenceSpaceBoundsRect, thunk64_xrGetRenderModelPropertiesFB, @@ -3508,6 +4380,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrGetSceneMarkerDecodedStringMSFT, thunk64_xrGetSceneMarkerRawDataMSFT, thunk64_xrGetSceneMeshBuffersMSFT, + thunk64_xrGetSenseDataProviderStateBD, thunk64_xrGetSerializedSceneFragmentDataMSFT, thunk64_xrGetSpaceBoundary2DFB, thunk64_xrGetSpaceBoundingBox2DFB, @@ -3520,6 +4393,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrGetSpaceUserIdFB, thunk64_xrGetSpaceUuidFB, thunk64_xrGetSpatialAnchorNameHTC, + thunk64_xrGetSpatialAnchorStateML, + thunk64_xrGetSpatialEntityComponentDataBD, + thunk64_xrGetSpatialEntityUuidBD, thunk64_xrGetSpatialGraphNodeBindingPropertiesMSFT, thunk64_xrGetSwapchainStateFB, thunk64_xrGetSystem, @@ -3536,10 +4412,13 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrGetVulkanGraphicsRequirements2KHR, thunk64_xrGetVulkanGraphicsRequirementsKHR, thunk64_xrGetVulkanInstanceExtensionsKHR, + thunk64_xrGetWorldMeshBufferRecommendSizeML, thunk64_xrImportLocalizationMapML, thunk64_xrLoadControllerModelMSFT, thunk64_xrLoadRenderModelFB, + thunk64_xrLocateBodyJointsBD, thunk64_xrLocateBodyJointsFB, + thunk64_xrLocateBodyJointsHTC, thunk64_xrLocateHandJointsEXT, thunk64_xrLocateSceneComponentsMSFT, thunk64_xrLocateSpace, @@ -3554,18 +4433,30 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrPassthroughStartFB, thunk64_xrPathToString, thunk64_xrPerfSettingsSetPerformanceLevelEXT, + thunk64_xrPersistSpatialAnchorAsyncBD, + thunk64_xrPersistSpatialAnchorCompleteBD, thunk64_xrPersistSpatialAnchorMSFT, thunk64_xrPollEvent, thunk64_xrPollFutureEXT, + thunk64_xrPublishSpatialAnchorsAsyncML, + thunk64_xrPublishSpatialAnchorsCompleteML, thunk64_xrQueryLocalizationMapsML, thunk64_xrQueryPerformanceMetricsCounterMETA, + thunk64_xrQuerySenseDataAsyncBD, + thunk64_xrQuerySenseDataCompleteBD, thunk64_xrQuerySpacesFB, + thunk64_xrQuerySpatialAnchorsAsyncML, + thunk64_xrQuerySpatialAnchorsCompleteML, thunk64_xrQuerySystemTrackedKeyboardFB, thunk64_xrReleaseSwapchainImage, thunk64_xrRequestDisplayRefreshRateFB, thunk64_xrRequestExitSession, thunk64_xrRequestMapLocalizationML, thunk64_xrRequestSceneCaptureFB, + thunk64_xrRequestWorldMeshAsyncML, + thunk64_xrRequestWorldMeshCompleteML, + thunk64_xrRequestWorldMeshStateAsyncML, + thunk64_xrRequestWorldMeshStateCompleteML, thunk64_xrResultToString, thunk64_xrRetrieveSpaceQueryResultsFB, thunk64_xrSaveSpaceFB, @@ -3585,16 +4476,28 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrSetMarkerTrackingVARJO, thunk64_xrSetPerformanceMetricsStateMETA, thunk64_xrSetSpaceComponentStatusFB, + thunk64_xrSetSystemNotificationsML, thunk64_xrSetTrackingOptimizationSettingsHintQCOM, thunk64_xrSetViewOffsetVARJO, thunk64_xrSetVirtualKeyboardModelVisibilityMETA, thunk64_xrShareSpacesFB, + thunk64_xrShareSpacesMETA, + thunk64_xrShareSpatialAnchorAsyncBD, + thunk64_xrShareSpatialAnchorCompleteBD, thunk64_xrSnapshotMarkerDetectorML, + thunk64_xrStartColocationAdvertisementMETA, + thunk64_xrStartColocationDiscoveryMETA, thunk64_xrStartEnvironmentDepthProviderMETA, + thunk64_xrStartSenseDataProviderAsyncBD, + thunk64_xrStartSenseDataProviderCompleteBD, + thunk64_xrStopColocationAdvertisementMETA, + thunk64_xrStopColocationDiscoveryMETA, thunk64_xrStopEnvironmentDepthProviderMETA, thunk64_xrStopHapticFeedback, + thunk64_xrStopSenseDataProviderBD, thunk64_xrStringToPath, thunk64_xrStructureTypeToString, + thunk64_xrStructureTypeToString2KHR, thunk64_xrSuggestInteractionProfileBindings, thunk64_xrSuggestVirtualKeyboardLocationMETA, thunk64_xrSyncActions, @@ -3606,9 +4509,13 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrTriangleMeshGetIndexBufferFB, thunk64_xrTriangleMeshGetVertexBufferFB, thunk64_xrTryCreateSpatialGraphStaticNodeBindingMSFT, + thunk64_xrUnpersistSpatialAnchorAsyncBD, + thunk64_xrUnpersistSpatialAnchorCompleteBD, thunk64_xrUnpersistSpatialAnchorMSFT, thunk64_xrUpdateHandMeshMSFT, thunk64_xrUpdatePassthroughColorLutMETA, + thunk64_xrUpdateSpatialAnchorsExpirationAsyncML, + thunk64_xrUpdateSpatialAnchorsExpirationCompleteML, thunk64_xrUpdateSwapchainFB, thunk64_xrWaitFrame, thunk64_xrWaitSwapchainImage, diff --git a/wineopenxr/openxr_thunks.h b/wineopenxr/openxr_thunks.h index 79ce95ec..270e5093 100644 --- a/wineopenxr/openxr_thunks.h +++ b/wineopenxr/openxr_thunks.h @@ -3,7 +3,7 @@ * 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. + * Copyright (c) 2017-2025 The Khronos Group Inc. * * SPDX-License-Identifier: Apache-2.0 OR MIT * @@ -39,6 +39,7 @@ struct openxr_instance_funcs { XrResult (*p_xrAcquireEnvironmentDepthImageMETA)(XrEnvironmentDepthProviderMETA, const XrEnvironmentDepthImageAcquireInfoMETA *, XrEnvironmentDepthImageMETA *); XrResult (*p_xrAcquireSwapchainImage)(XrSwapchain, const XrSwapchainImageAcquireInfo *, uint32_t *); + XrResult (*p_xrAllocateWorldMeshBufferML)(XrWorldMeshDetectorML, const XrWorldMeshBufferSizeML *, XrWorldMeshBufferML *); XrResult (*p_xrApplyForceFeedbackCurlMNDX)(XrHandTrackerEXT, const XrForceFeedbackCurlApplyLocationsMNDX *); XrResult (*p_xrApplyHapticFeedback)(XrSession, const XrHapticActionInfo *, const XrHapticBaseHeader *); XrResult (*p_xrAttachSessionActionSets)(XrSession, const XrSessionActionSetsAttachInfo *); @@ -46,20 +47,26 @@ struct openxr_instance_funcs XrResult (*p_xrBeginPlaneDetectionEXT)(XrPlaneDetectorEXT, const XrPlaneDetectorBeginInfoEXT *); XrResult (*p_xrBeginSession)(XrSession, const XrSessionBeginInfo *); XrResult (*p_xrCancelFutureEXT)(XrInstance, const XrFutureCancelInfoEXT *); + XrResult (*p_xrCaptureSceneAsyncBD)(XrSenseDataProviderBD, const XrSceneCaptureInfoBD *, XrFutureEXT *); + XrResult (*p_xrCaptureSceneCompleteBD)(XrSenseDataProviderBD, XrFutureEXT, XrFutureCompletionEXT *); XrResult (*p_xrChangeVirtualKeyboardTextContextMETA)(XrVirtualKeyboardMETA, const XrVirtualKeyboardTextContextChangeInfoMETA *); XrResult (*p_xrClearSpatialAnchorStoreMSFT)(XrSpatialAnchorStoreConnectionMSFT); XrResult (*p_xrComputeNewSceneMSFT)(XrSceneObserverMSFT, const XrNewSceneComputeInfoMSFT *); XrResult (*p_xrCreateAction)(XrActionSet, const XrActionCreateInfo *, XrAction *); XrResult (*p_xrCreateActionSet)(XrInstance, const XrActionSetCreateInfo *, XrActionSet *); XrResult (*p_xrCreateActionSpace)(XrSession, const XrActionSpaceCreateInfo *, XrSpace *); + XrResult (*p_xrCreateAnchorSpaceBD)(XrSession, const XrAnchorSpaceCreateInfoBD *, XrSpace *); XrResult (*p_xrCreateApiLayerInstance)(const XrInstanceCreateInfo *, const XrApiLayerCreateInfo *, XrInstance *); + XrResult (*p_xrCreateBodyTrackerBD)(XrSession, const XrBodyTrackerCreateInfoBD *, XrBodyTrackerBD *); XrResult (*p_xrCreateBodyTrackerFB)(XrSession, const XrBodyTrackerCreateInfoFB *, XrBodyTrackerFB *); + XrResult (*p_xrCreateBodyTrackerHTC)(XrSession, const XrBodyTrackerCreateInfoHTC *, XrBodyTrackerHTC *); XrResult (*p_xrCreateEnvironmentDepthProviderMETA)(XrSession, const XrEnvironmentDepthProviderCreateInfoMETA *, XrEnvironmentDepthProviderMETA *); XrResult (*p_xrCreateEnvironmentDepthSwapchainMETA)(XrEnvironmentDepthProviderMETA, const XrEnvironmentDepthSwapchainCreateInfoMETA *, XrEnvironmentDepthSwapchainMETA *); XrResult (*p_xrCreateExportedLocalizationMapML)(XrSession, const XrUuidEXT *, XrExportedLocalizationMapML *); XrResult (*p_xrCreateEyeTrackerFB)(XrSession, const XrEyeTrackerCreateInfoFB *, XrEyeTrackerFB *); XrResult (*p_xrCreateFaceTracker2FB)(XrSession, const XrFaceTrackerCreateInfo2FB *, XrFaceTracker2FB *); XrResult (*p_xrCreateFaceTrackerFB)(XrSession, const XrFaceTrackerCreateInfoFB *, XrFaceTrackerFB *); + XrResult (*p_xrCreateFacialExpressionClientML)(XrSession, const XrFacialExpressionClientCreateInfoML *, XrFacialExpressionClientML *); XrResult (*p_xrCreateFacialTrackerHTC)(XrSession, const XrFacialTrackerCreateInfoHTC *, XrFacialTrackerHTC *); XrResult (*p_xrCreateFoveationProfileFB)(XrSession, const XrFoveationProfileCreateInfoFB *, XrFoveationProfileFB *); XrResult (*p_xrCreateGeometryInstanceFB)(XrSession, const XrGeometryInstanceCreateInfoFB *, XrGeometryInstanceFB *); @@ -77,14 +84,21 @@ struct openxr_instance_funcs XrResult (*p_xrCreateReferenceSpace)(XrSession, const XrReferenceSpaceCreateInfo *, XrSpace *); XrResult (*p_xrCreateSceneMSFT)(XrSceneObserverMSFT, const XrSceneCreateInfoMSFT *, XrSceneMSFT *); XrResult (*p_xrCreateSceneObserverMSFT)(XrSession, const XrSceneObserverCreateInfoMSFT *, XrSceneObserverMSFT *); + XrResult (*p_xrCreateSenseDataProviderBD)(XrSession, const XrSenseDataProviderCreateInfoBD *, XrSenseDataProviderBD *); XrResult (*p_xrCreateSession)(XrInstance, const XrSessionCreateInfo *, XrSession *); XrResult (*p_xrCreateSpaceUserFB)(XrSession, const XrSpaceUserCreateInfoFB *, XrSpaceUserFB *); + XrResult (*p_xrCreateSpatialAnchorAsyncBD)(XrSenseDataProviderBD, const XrSpatialAnchorCreateInfoBD *, XrFutureEXT *); + XrResult (*p_xrCreateSpatialAnchorCompleteBD)(XrSenseDataProviderBD, XrFutureEXT, XrSpatialAnchorCreateCompletionBD *); XrResult (*p_xrCreateSpatialAnchorFB)(XrSession, const XrSpatialAnchorCreateInfoFB *, XrAsyncRequestIdFB *); XrResult (*p_xrCreateSpatialAnchorFromPersistedNameMSFT)(XrSession, const XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT *, XrSpatialAnchorMSFT *); XrResult (*p_xrCreateSpatialAnchorHTC)(XrSession, const XrSpatialAnchorCreateInfoHTC *, XrSpace *); XrResult (*p_xrCreateSpatialAnchorMSFT)(XrSession, const XrSpatialAnchorCreateInfoMSFT *, XrSpatialAnchorMSFT *); XrResult (*p_xrCreateSpatialAnchorSpaceMSFT)(XrSession, const XrSpatialAnchorSpaceCreateInfoMSFT *, XrSpace *); XrResult (*p_xrCreateSpatialAnchorStoreConnectionMSFT)(XrSession, XrSpatialAnchorStoreConnectionMSFT *); + XrResult (*p_xrCreateSpatialAnchorsAsyncML)(XrSession, const XrSpatialAnchorsCreateInfoBaseHeaderML *, XrFutureEXT *); + XrResult (*p_xrCreateSpatialAnchorsCompleteML)(XrSession, XrFutureEXT, XrCreateSpatialAnchorsCompletionML *); + XrResult (*p_xrCreateSpatialAnchorsStorageML)(XrSession, const XrSpatialAnchorsCreateStorageInfoML *, XrSpatialAnchorsStorageML *); + XrResult (*p_xrCreateSpatialEntityAnchorBD)(XrSenseDataProviderBD, const XrSpatialEntityAnchorCreateInfoBD *, XrAnchorBD *); XrResult (*p_xrCreateSpatialGraphNodeSpaceMSFT)(XrSession, const XrSpatialGraphNodeSpaceCreateInfoMSFT *, XrSpace *); XrResult (*p_xrCreateSwapchain)(XrSession, const XrSwapchainCreateInfo *, XrSwapchain *); XrResult (*p_xrCreateTriangleMeshFB)(XrSession, const XrTriangleMeshCreateInfoFB *, XrTriangleMeshFB *); @@ -92,16 +106,23 @@ struct openxr_instance_funcs XrResult (*p_xrCreateVirtualKeyboardSpaceMETA)(XrSession, XrVirtualKeyboardMETA, const XrVirtualKeyboardSpaceCreateInfoMETA *, XrSpace *); XrResult (*p_xrCreateVulkanDeviceKHR)(XrInstance, const XrVulkanDeviceCreateInfoKHR *, VkDevice *, VkResult *); XrResult (*p_xrCreateVulkanInstanceKHR)(XrInstance, const XrVulkanInstanceCreateInfoKHR *, VkInstance *, VkResult *); + XrResult (*p_xrCreateWorldMeshDetectorML)(XrSession, const XrWorldMeshDetectorCreateInfoML *, XrWorldMeshDetectorML *); + XrResult (*p_xrDeleteSpatialAnchorsAsyncML)(XrSpatialAnchorsStorageML, const XrSpatialAnchorsDeleteInfoML *, XrFutureEXT *); + XrResult (*p_xrDeleteSpatialAnchorsCompleteML)(XrSpatialAnchorsStorageML, XrFutureEXT, XrSpatialAnchorsDeleteCompletionML *); XrResult (*p_xrDeserializeSceneMSFT)(XrSceneObserverMSFT, const XrSceneDeserializeInfoMSFT *); XrResult (*p_xrDestroyAction)(XrAction); XrResult (*p_xrDestroyActionSet)(XrActionSet); + XrResult (*p_xrDestroyAnchorBD)(XrAnchorBD); + XrResult (*p_xrDestroyBodyTrackerBD)(XrBodyTrackerBD); XrResult (*p_xrDestroyBodyTrackerFB)(XrBodyTrackerFB); + XrResult (*p_xrDestroyBodyTrackerHTC)(XrBodyTrackerHTC); XrResult (*p_xrDestroyEnvironmentDepthProviderMETA)(XrEnvironmentDepthProviderMETA); XrResult (*p_xrDestroyEnvironmentDepthSwapchainMETA)(XrEnvironmentDepthSwapchainMETA); XrResult (*p_xrDestroyExportedLocalizationMapML)(XrExportedLocalizationMapML); XrResult (*p_xrDestroyEyeTrackerFB)(XrEyeTrackerFB); XrResult (*p_xrDestroyFaceTracker2FB)(XrFaceTracker2FB); XrResult (*p_xrDestroyFaceTrackerFB)(XrFaceTrackerFB); + XrResult (*p_xrDestroyFacialExpressionClientML)(XrFacialExpressionClientML); XrResult (*p_xrDestroyFacialTrackerHTC)(XrFacialTrackerHTC); XrResult (*p_xrDestroyFoveationProfileFB)(XrFoveationProfileFB); XrResult (*p_xrDestroyGeometryInstanceFB)(XrGeometryInstanceFB); @@ -115,15 +136,21 @@ struct openxr_instance_funcs XrResult (*p_xrDestroyPlaneDetectorEXT)(XrPlaneDetectorEXT); XrResult (*p_xrDestroySceneMSFT)(XrSceneMSFT); XrResult (*p_xrDestroySceneObserverMSFT)(XrSceneObserverMSFT); + XrResult (*p_xrDestroySenseDataProviderBD)(XrSenseDataProviderBD); + XrResult (*p_xrDestroySenseDataSnapshotBD)(XrSenseDataSnapshotBD); XrResult (*p_xrDestroySession)(XrSession); XrResult (*p_xrDestroySpace)(XrSpace); XrResult (*p_xrDestroySpaceUserFB)(XrSpaceUserFB); XrResult (*p_xrDestroySpatialAnchorMSFT)(XrSpatialAnchorMSFT); XrResult (*p_xrDestroySpatialAnchorStoreConnectionMSFT)(XrSpatialAnchorStoreConnectionMSFT); + XrResult (*p_xrDestroySpatialAnchorsStorageML)(XrSpatialAnchorsStorageML); XrResult (*p_xrDestroySpatialGraphNodeBindingMSFT)(XrSpatialGraphNodeBindingMSFT); XrResult (*p_xrDestroySwapchain)(XrSwapchain); XrResult (*p_xrDestroyTriangleMeshFB)(XrTriangleMeshFB); XrResult (*p_xrDestroyVirtualKeyboardMETA)(XrVirtualKeyboardMETA); + XrResult (*p_xrDestroyWorldMeshDetectorML)(XrWorldMeshDetectorML); + XrResult (*p_xrDownloadSharedSpatialAnchorAsyncBD)(XrSenseDataProviderBD, const XrSharedSpatialAnchorDownloadInfoBD *, XrFutureEXT *); + XrResult (*p_xrDownloadSharedSpatialAnchorCompleteBD)(XrSenseDataProviderBD, XrFutureEXT, XrFutureCompletionEXT *); XrResult (*p_xrEnableLocalizationEventsML)(XrSession, const XrLocalizationEnableEventsInfoML *); XrResult (*p_xrEnableUserCalibrationEventsML)(XrInstance, const XrUserCalibrationEnableEventsInfoML *); XrResult (*p_xrEndFrame)(XrSession, const XrFrameEndInfo *); @@ -142,20 +169,24 @@ struct openxr_instance_funcs XrResult (*p_xrEnumerateReprojectionModesMSFT)(XrInstance, XrSystemId, XrViewConfigurationType, uint32_t, uint32_t *, XrReprojectionModeMSFT *); XrResult (*p_xrEnumerateSceneComputeFeaturesMSFT)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrSceneComputeFeatureMSFT *); XrResult (*p_xrEnumerateSpaceSupportedComponentsFB)(XrSpace, uint32_t, uint32_t *, XrSpaceComponentTypeFB *); + XrResult (*p_xrEnumerateSpatialEntityComponentTypesBD)(XrSenseDataSnapshotBD, XrSpatialEntityIdBD, uint32_t, uint32_t *, XrSpatialEntityComponentTypeBD *); XrResult (*p_xrEnumerateSwapchainFormats)(XrSession, uint32_t, uint32_t *, int64_t *); XrResult (*p_xrEnumerateSwapchainImages)(XrSwapchain, uint32_t, uint32_t *, XrSwapchainImageBaseHeader *); XrResult (*p_xrEnumerateViewConfigurationViews)(XrInstance, XrSystemId, XrViewConfigurationType, uint32_t, uint32_t *, XrViewConfigurationView *); XrResult (*p_xrEnumerateViewConfigurations)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrViewConfigurationType *); XrResult (*p_xrEnumerateViveTrackerPathsHTCX)(XrInstance, uint32_t, uint32_t *, XrViveTrackerPathsHTCX *); XrResult (*p_xrEraseSpaceFB)(XrSession, const XrSpaceEraseInfoFB *, XrAsyncRequestIdFB *); + XrResult (*p_xrFreeWorldMeshBufferML)(XrWorldMeshDetectorML, const XrWorldMeshBufferML *); XrResult (*p_xrGeometryInstanceSetTransformFB)(XrGeometryInstanceFB, const XrGeometryInstanceTransformFB *); XrResult (*p_xrGetActionStateBoolean)(XrSession, const XrActionStateGetInfo *, XrActionStateBoolean *); XrResult (*p_xrGetActionStateFloat)(XrSession, const XrActionStateGetInfo *, XrActionStateFloat *); XrResult (*p_xrGetActionStatePose)(XrSession, const XrActionStateGetInfo *, XrActionStatePose *); XrResult (*p_xrGetActionStateVector2f)(XrSession, const XrActionStateGetInfo *, XrActionStateVector2f *); + XrResult (*p_xrGetAnchorUuidBD)(XrAnchorBD, XrUuidEXT *); XrResult (*p_xrGetAudioInputDeviceGuidOculus)(XrInstance, wchar_t[]); XrResult (*p_xrGetAudioOutputDeviceGuidOculus)(XrInstance, wchar_t[]); XrResult (*p_xrGetBodySkeletonFB)(XrBodyTrackerFB, XrBodySkeletonFB *); + XrResult (*p_xrGetBodySkeletonHTC)(XrBodyTrackerHTC, XrSpace, uint32_t, XrBodySkeletonHTC *); XrResult (*p_xrGetControllerModelKeyMSFT)(XrSession, XrPath, XrControllerModelKeyStateMSFT *); XrResult (*p_xrGetControllerModelPropertiesMSFT)(XrSession, XrControllerModelKeyMSFT, XrControllerModelPropertiesMSFT *); XrResult (*p_xrGetControllerModelStateMSFT)(XrSession, XrControllerModelKeyMSFT, XrControllerModelStateMSFT *); @@ -167,6 +198,7 @@ struct openxr_instance_funcs XrResult (*p_xrGetEyeGazesFB)(XrEyeTrackerFB, const XrEyeGazesInfoFB *, XrEyeGazesFB *); XrResult (*p_xrGetFaceExpressionWeights2FB)(XrFaceTracker2FB, const XrFaceExpressionInfo2FB *, XrFaceExpressionWeights2FB *); XrResult (*p_xrGetFaceExpressionWeightsFB)(XrFaceTrackerFB, const XrFaceExpressionInfoFB *, XrFaceExpressionWeightsFB *); + XrResult (*p_xrGetFacialExpressionBlendShapePropertiesML)(XrFacialExpressionClientML, const XrFacialExpressionBlendShapeGetInfoML *, uint32_t, XrFacialExpressionBlendShapePropertiesML *); XrResult (*p_xrGetFacialExpressionsHTC)(XrFacialTrackerHTC, XrFacialExpressionsHTC *); XrResult (*p_xrGetFoveationEyeTrackedStateMETA)(XrSession, XrFoveationEyeTrackedStateMETA *); XrResult (*p_xrGetHandMeshFB)(XrHandTrackerEXT, XrHandTrackingMeshFB *); @@ -185,6 +217,7 @@ struct openxr_instance_funcs XrResult (*p_xrGetPlaneDetectionStateEXT)(XrPlaneDetectorEXT, XrPlaneDetectionStateEXT *); XrResult (*p_xrGetPlaneDetectionsEXT)(XrPlaneDetectorEXT, const XrPlaneDetectorGetInfoEXT *, XrPlaneDetectorLocationsEXT *); XrResult (*p_xrGetPlanePolygonBufferEXT)(XrPlaneDetectorEXT, uint64_t, uint32_t, XrPlaneDetectorPolygonBufferEXT *); + XrResult (*p_xrGetQueriedSenseDataBD)(XrSenseDataSnapshotBD, XrQueriedSenseDataGetInfoBD *, XrQueriedSenseDataBD *); XrResult (*p_xrGetRecommendedLayerResolutionMETA)(XrSession, const XrRecommendedLayerResolutionGetInfoMETA *, XrRecommendedLayerResolutionMETA *); XrResult (*p_xrGetReferenceSpaceBoundsRect)(XrSession, XrReferenceSpaceType, XrExtent2Df *); XrResult (*p_xrGetRenderModelPropertiesFB)(XrSession, XrPath, XrRenderModelPropertiesFB *); @@ -193,6 +226,7 @@ struct openxr_instance_funcs XrResult (*p_xrGetSceneMarkerDecodedStringMSFT)(XrSceneMSFT, const XrUuidMSFT *, uint32_t, uint32_t *, char *); XrResult (*p_xrGetSceneMarkerRawDataMSFT)(XrSceneMSFT, const XrUuidMSFT *, uint32_t, uint32_t *, uint8_t *); XrResult (*p_xrGetSceneMeshBuffersMSFT)(XrSceneMSFT, const XrSceneMeshBuffersGetInfoMSFT *, XrSceneMeshBuffersMSFT *); + XrResult (*p_xrGetSenseDataProviderStateBD)(XrSenseDataProviderBD, XrSenseDataProviderStateBD *); XrResult (*p_xrGetSerializedSceneFragmentDataMSFT)(XrSceneMSFT, const XrSerializedSceneFragmentDataGetInfoMSFT *, uint32_t, uint32_t *, uint8_t *); XrResult (*p_xrGetSpaceBoundary2DFB)(XrSession, XrSpace, XrBoundary2DFB *); XrResult (*p_xrGetSpaceBoundingBox2DFB)(XrSession, XrSpace, XrRect2Df *); @@ -205,6 +239,9 @@ struct openxr_instance_funcs XrResult (*p_xrGetSpaceUserIdFB)(XrSpaceUserFB, XrSpaceUserIdFB *); XrResult (*p_xrGetSpaceUuidFB)(XrSpace, XrUuidEXT *); XrResult (*p_xrGetSpatialAnchorNameHTC)(XrSpace, XrSpatialAnchorNameHTC *); + XrResult (*p_xrGetSpatialAnchorStateML)(XrSpace, XrSpatialAnchorStateML *); + XrResult (*p_xrGetSpatialEntityComponentDataBD)(XrSenseDataSnapshotBD, const XrSpatialEntityComponentGetInfoBD *, XrSpatialEntityComponentDataBaseHeaderBD *); + XrResult (*p_xrGetSpatialEntityUuidBD)(XrSenseDataSnapshotBD, XrSpatialEntityIdBD, XrUuidEXT *); XrResult (*p_xrGetSpatialGraphNodeBindingPropertiesMSFT)(XrSpatialGraphNodeBindingMSFT, const XrSpatialGraphNodeBindingPropertiesGetInfoMSFT *, XrSpatialGraphNodeBindingPropertiesMSFT *); XrResult (*p_xrGetSwapchainStateFB)(XrSwapchain, XrSwapchainStateBaseHeaderFB *); XrResult (*p_xrGetSystem)(XrInstance, const XrSystemGetInfo *, XrSystemId *); @@ -221,10 +258,13 @@ struct openxr_instance_funcs XrResult (*p_xrGetVulkanGraphicsRequirements2KHR)(XrInstance, XrSystemId, XrGraphicsRequirementsVulkanKHR *); XrResult (*p_xrGetVulkanGraphicsRequirementsKHR)(XrInstance, XrSystemId, XrGraphicsRequirementsVulkanKHR *); XrResult (*p_xrGetVulkanInstanceExtensionsKHR)(XrInstance, XrSystemId, uint32_t, uint32_t *, char *); + XrResult (*p_xrGetWorldMeshBufferRecommendSizeML)(XrWorldMeshDetectorML, const XrWorldMeshBufferRecommendedSizeInfoML *, XrWorldMeshBufferSizeML *); XrResult (*p_xrImportLocalizationMapML)(XrSession, const XrLocalizationMapImportInfoML *, XrUuidEXT *); XrResult (*p_xrLoadControllerModelMSFT)(XrSession, XrControllerModelKeyMSFT, uint32_t, uint32_t *, uint8_t *); XrResult (*p_xrLoadRenderModelFB)(XrSession, const XrRenderModelLoadInfoFB *, XrRenderModelBufferFB *); + XrResult (*p_xrLocateBodyJointsBD)(XrBodyTrackerBD, const XrBodyJointsLocateInfoBD *, XrBodyJointLocationsBD *); XrResult (*p_xrLocateBodyJointsFB)(XrBodyTrackerFB, const XrBodyJointsLocateInfoFB *, XrBodyJointLocationsFB *); + XrResult (*p_xrLocateBodyJointsHTC)(XrBodyTrackerHTC, const XrBodyJointsLocateInfoHTC *, XrBodyJointLocationsHTC *); XrResult (*p_xrLocateHandJointsEXT)(XrHandTrackerEXT, const XrHandJointsLocateInfoEXT *, XrHandJointLocationsEXT *); XrResult (*p_xrLocateSceneComponentsMSFT)(XrSceneMSFT, const XrSceneComponentsLocateInfoMSFT *, XrSceneComponentLocationsMSFT *); XrResult (*p_xrLocateSpace)(XrSpace, XrSpace, XrTime, XrSpaceLocation *); @@ -240,18 +280,30 @@ struct openxr_instance_funcs XrResult (*p_xrPassthroughStartFB)(XrPassthroughFB); XrResult (*p_xrPathToString)(XrInstance, XrPath, uint32_t, uint32_t *, char *); XrResult (*p_xrPerfSettingsSetPerformanceLevelEXT)(XrSession, XrPerfSettingsDomainEXT, XrPerfSettingsLevelEXT); + XrResult (*p_xrPersistSpatialAnchorAsyncBD)(XrSenseDataProviderBD, const XrSpatialAnchorPersistInfoBD *, XrFutureEXT *); + XrResult (*p_xrPersistSpatialAnchorCompleteBD)(XrSenseDataProviderBD, XrFutureEXT, XrFutureCompletionEXT *); XrResult (*p_xrPersistSpatialAnchorMSFT)(XrSpatialAnchorStoreConnectionMSFT, const XrSpatialAnchorPersistenceInfoMSFT *); XrResult (*p_xrPollEvent)(XrInstance, XrEventDataBuffer *); XrResult (*p_xrPollFutureEXT)(XrInstance, const XrFuturePollInfoEXT *, XrFuturePollResultEXT *); + XrResult (*p_xrPublishSpatialAnchorsAsyncML)(XrSpatialAnchorsStorageML, const XrSpatialAnchorsPublishInfoML *, XrFutureEXT *); + XrResult (*p_xrPublishSpatialAnchorsCompleteML)(XrSpatialAnchorsStorageML, XrFutureEXT, XrSpatialAnchorsPublishCompletionML *); XrResult (*p_xrQueryLocalizationMapsML)(XrSession, const XrLocalizationMapQueryInfoBaseHeaderML *, uint32_t, uint32_t *, XrLocalizationMapML *); XrResult (*p_xrQueryPerformanceMetricsCounterMETA)(XrSession, XrPath, XrPerformanceMetricsCounterMETA *); + XrResult (*p_xrQuerySenseDataAsyncBD)(XrSenseDataProviderBD, const XrSenseDataQueryInfoBD *, XrFutureEXT *); + XrResult (*p_xrQuerySenseDataCompleteBD)(XrSenseDataProviderBD, XrFutureEXT, XrSenseDataQueryCompletionBD *); XrResult (*p_xrQuerySpacesFB)(XrSession, const XrSpaceQueryInfoBaseHeaderFB *, XrAsyncRequestIdFB *); + XrResult (*p_xrQuerySpatialAnchorsAsyncML)(XrSpatialAnchorsStorageML, const XrSpatialAnchorsQueryInfoBaseHeaderML *, XrFutureEXT *); + XrResult (*p_xrQuerySpatialAnchorsCompleteML)(XrSpatialAnchorsStorageML, XrFutureEXT, XrSpatialAnchorsQueryCompletionML *); XrResult (*p_xrQuerySystemTrackedKeyboardFB)(XrSession, const XrKeyboardTrackingQueryFB *, XrKeyboardTrackingDescriptionFB *); XrResult (*p_xrReleaseSwapchainImage)(XrSwapchain, const XrSwapchainImageReleaseInfo *); XrResult (*p_xrRequestDisplayRefreshRateFB)(XrSession, float); XrResult (*p_xrRequestExitSession)(XrSession); XrResult (*p_xrRequestMapLocalizationML)(XrSession, const XrMapLocalizationRequestInfoML *); XrResult (*p_xrRequestSceneCaptureFB)(XrSession, const XrSceneCaptureRequestInfoFB *, XrAsyncRequestIdFB *); + XrResult (*p_xrRequestWorldMeshAsyncML)(XrWorldMeshDetectorML, const XrWorldMeshGetInfoML *, XrWorldMeshBufferML *, XrFutureEXT *); + XrResult (*p_xrRequestWorldMeshCompleteML)(XrWorldMeshDetectorML, const XrWorldMeshRequestCompletionInfoML *, XrFutureEXT, XrWorldMeshRequestCompletionML *); + XrResult (*p_xrRequestWorldMeshStateAsyncML)(XrWorldMeshDetectorML, const XrWorldMeshStateRequestInfoML *, XrFutureEXT *); + XrResult (*p_xrRequestWorldMeshStateCompleteML)(XrWorldMeshDetectorML, XrFutureEXT, XrWorldMeshStateRequestCompletionML *); XrResult (*p_xrResultToString)(XrInstance, XrResult, char[]); XrResult (*p_xrRetrieveSpaceQueryResultsFB)(XrSession, XrAsyncRequestIdFB, XrSpaceQueryResultsFB *); XrResult (*p_xrSaveSpaceFB)(XrSession, const XrSpaceSaveInfoFB *, XrAsyncRequestIdFB *); @@ -271,16 +323,28 @@ struct openxr_instance_funcs XrResult (*p_xrSetMarkerTrackingVARJO)(XrSession, XrBool32); XrResult (*p_xrSetPerformanceMetricsStateMETA)(XrSession, const XrPerformanceMetricsStateMETA *); XrResult (*p_xrSetSpaceComponentStatusFB)(XrSpace, const XrSpaceComponentStatusSetInfoFB *, XrAsyncRequestIdFB *); + XrResult (*p_xrSetSystemNotificationsML)(XrInstance, const XrSystemNotificationsSetInfoML *); XrResult (*p_xrSetTrackingOptimizationSettingsHintQCOM)(XrSession, XrTrackingOptimizationSettingsDomainQCOM, XrTrackingOptimizationSettingsHintQCOM); XrResult (*p_xrSetViewOffsetVARJO)(XrSession, float); XrResult (*p_xrSetVirtualKeyboardModelVisibilityMETA)(XrVirtualKeyboardMETA, const XrVirtualKeyboardModelVisibilitySetInfoMETA *); XrResult (*p_xrShareSpacesFB)(XrSession, const XrSpaceShareInfoFB *, XrAsyncRequestIdFB *); + XrResult (*p_xrShareSpacesMETA)(XrSession, const XrShareSpacesInfoMETA *, XrAsyncRequestIdFB *); + XrResult (*p_xrShareSpatialAnchorAsyncBD)(XrSenseDataProviderBD, const XrSpatialAnchorShareInfoBD *, XrFutureEXT *); + XrResult (*p_xrShareSpatialAnchorCompleteBD)(XrSenseDataProviderBD, XrFutureEXT, XrFutureCompletionEXT *); XrResult (*p_xrSnapshotMarkerDetectorML)(XrMarkerDetectorML, XrMarkerDetectorSnapshotInfoML *); + XrResult (*p_xrStartColocationAdvertisementMETA)(XrSession, const XrColocationAdvertisementStartInfoMETA *, XrAsyncRequestIdFB *); + XrResult (*p_xrStartColocationDiscoveryMETA)(XrSession, const XrColocationDiscoveryStartInfoMETA *, XrAsyncRequestIdFB *); XrResult (*p_xrStartEnvironmentDepthProviderMETA)(XrEnvironmentDepthProviderMETA); + XrResult (*p_xrStartSenseDataProviderAsyncBD)(XrSenseDataProviderBD, const XrSenseDataProviderStartInfoBD *, XrFutureEXT *); + XrResult (*p_xrStartSenseDataProviderCompleteBD)(XrSession, XrFutureEXT, XrFutureCompletionEXT *); + XrResult (*p_xrStopColocationAdvertisementMETA)(XrSession, const XrColocationAdvertisementStopInfoMETA *, XrAsyncRequestIdFB *); + XrResult (*p_xrStopColocationDiscoveryMETA)(XrSession, const XrColocationDiscoveryStopInfoMETA *, XrAsyncRequestIdFB *); XrResult (*p_xrStopEnvironmentDepthProviderMETA)(XrEnvironmentDepthProviderMETA); XrResult (*p_xrStopHapticFeedback)(XrSession, const XrHapticActionInfo *); + XrResult (*p_xrStopSenseDataProviderBD)(XrSenseDataProviderBD); XrResult (*p_xrStringToPath)(XrInstance, const char *, XrPath *); XrResult (*p_xrStructureTypeToString)(XrInstance, XrStructureType, char[]); + XrResult (*p_xrStructureTypeToString2KHR)(XrInstance, XrStructureType, char[]); XrResult (*p_xrSuggestInteractionProfileBindings)(XrInstance, const XrInteractionProfileSuggestedBinding *); XrResult (*p_xrSuggestVirtualKeyboardLocationMETA)(XrVirtualKeyboardMETA, const XrVirtualKeyboardLocationInfoMETA *); XrResult (*p_xrSyncActions)(XrSession, const XrActionsSyncInfo *); @@ -292,9 +356,13 @@ struct openxr_instance_funcs XrResult (*p_xrTriangleMeshGetIndexBufferFB)(XrTriangleMeshFB, uint32_t **); XrResult (*p_xrTriangleMeshGetVertexBufferFB)(XrTriangleMeshFB, XrVector3f **); XrResult (*p_xrTryCreateSpatialGraphStaticNodeBindingMSFT)(XrSession, const XrSpatialGraphStaticNodeBindingCreateInfoMSFT *, XrSpatialGraphNodeBindingMSFT *); + XrResult (*p_xrUnpersistSpatialAnchorAsyncBD)(XrSenseDataProviderBD, const XrSpatialAnchorUnpersistInfoBD *, XrFutureEXT *); + XrResult (*p_xrUnpersistSpatialAnchorCompleteBD)(XrSenseDataProviderBD, XrFutureEXT, XrFutureCompletionEXT *); XrResult (*p_xrUnpersistSpatialAnchorMSFT)(XrSpatialAnchorStoreConnectionMSFT, const XrSpatialAnchorPersistenceNameMSFT *); XrResult (*p_xrUpdateHandMeshMSFT)(XrHandTrackerEXT, const XrHandMeshUpdateInfoMSFT *, XrHandMeshMSFT *); XrResult (*p_xrUpdatePassthroughColorLutMETA)(XrPassthroughColorLutMETA, const XrPassthroughColorLutUpdateInfoMETA *); + XrResult (*p_xrUpdateSpatialAnchorsExpirationAsyncML)(XrSpatialAnchorsStorageML, const XrSpatialAnchorsUpdateExpirationInfoML *, XrFutureEXT *); + XrResult (*p_xrUpdateSpatialAnchorsExpirationCompleteML)(XrSpatialAnchorsStorageML, XrFutureEXT, XrSpatialAnchorsUpdateExpirationCompletionML *); XrResult (*p_xrUpdateSwapchainFB)(XrSwapchain, const XrSwapchainStateBaseHeaderFB *); XrResult (*p_xrWaitFrame)(XrSession, const XrFrameWaitInfo *, XrFrameState *); XrResult (*p_xrWaitSwapchainImage)(XrSwapchain, const XrSwapchainImageWaitInfo *); @@ -303,6 +371,7 @@ struct openxr_instance_funcs #define ALL_XR_INSTANCE_FUNCS() \ USE_XR_FUNC(xrAcquireEnvironmentDepthImageMETA) \ USE_XR_FUNC(xrAcquireSwapchainImage) \ + USE_XR_FUNC(xrAllocateWorldMeshBufferML) \ USE_XR_FUNC(xrApplyForceFeedbackCurlMNDX) \ USE_XR_FUNC(xrApplyHapticFeedback) \ USE_XR_FUNC(xrAttachSessionActionSets) \ @@ -310,20 +379,26 @@ struct openxr_instance_funcs USE_XR_FUNC(xrBeginPlaneDetectionEXT) \ USE_XR_FUNC(xrBeginSession) \ USE_XR_FUNC(xrCancelFutureEXT) \ + USE_XR_FUNC(xrCaptureSceneAsyncBD) \ + USE_XR_FUNC(xrCaptureSceneCompleteBD) \ USE_XR_FUNC(xrChangeVirtualKeyboardTextContextMETA) \ USE_XR_FUNC(xrClearSpatialAnchorStoreMSFT) \ USE_XR_FUNC(xrComputeNewSceneMSFT) \ USE_XR_FUNC(xrCreateAction) \ USE_XR_FUNC(xrCreateActionSet) \ USE_XR_FUNC(xrCreateActionSpace) \ + USE_XR_FUNC(xrCreateAnchorSpaceBD) \ USE_XR_FUNC(xrCreateApiLayerInstance) \ + USE_XR_FUNC(xrCreateBodyTrackerBD) \ USE_XR_FUNC(xrCreateBodyTrackerFB) \ + USE_XR_FUNC(xrCreateBodyTrackerHTC) \ USE_XR_FUNC(xrCreateEnvironmentDepthProviderMETA) \ USE_XR_FUNC(xrCreateEnvironmentDepthSwapchainMETA) \ USE_XR_FUNC(xrCreateExportedLocalizationMapML) \ USE_XR_FUNC(xrCreateEyeTrackerFB) \ USE_XR_FUNC(xrCreateFaceTracker2FB) \ USE_XR_FUNC(xrCreateFaceTrackerFB) \ + USE_XR_FUNC(xrCreateFacialExpressionClientML) \ USE_XR_FUNC(xrCreateFacialTrackerHTC) \ USE_XR_FUNC(xrCreateFoveationProfileFB) \ USE_XR_FUNC(xrCreateGeometryInstanceFB) \ @@ -341,14 +416,21 @@ struct openxr_instance_funcs USE_XR_FUNC(xrCreateReferenceSpace) \ USE_XR_FUNC(xrCreateSceneMSFT) \ USE_XR_FUNC(xrCreateSceneObserverMSFT) \ + USE_XR_FUNC(xrCreateSenseDataProviderBD) \ USE_XR_FUNC(xrCreateSession) \ USE_XR_FUNC(xrCreateSpaceUserFB) \ + USE_XR_FUNC(xrCreateSpatialAnchorAsyncBD) \ + USE_XR_FUNC(xrCreateSpatialAnchorCompleteBD) \ USE_XR_FUNC(xrCreateSpatialAnchorFB) \ USE_XR_FUNC(xrCreateSpatialAnchorFromPersistedNameMSFT) \ USE_XR_FUNC(xrCreateSpatialAnchorHTC) \ USE_XR_FUNC(xrCreateSpatialAnchorMSFT) \ USE_XR_FUNC(xrCreateSpatialAnchorSpaceMSFT) \ USE_XR_FUNC(xrCreateSpatialAnchorStoreConnectionMSFT) \ + USE_XR_FUNC(xrCreateSpatialAnchorsAsyncML) \ + USE_XR_FUNC(xrCreateSpatialAnchorsCompleteML) \ + USE_XR_FUNC(xrCreateSpatialAnchorsStorageML) \ + USE_XR_FUNC(xrCreateSpatialEntityAnchorBD) \ USE_XR_FUNC(xrCreateSpatialGraphNodeSpaceMSFT) \ USE_XR_FUNC(xrCreateSwapchain) \ USE_XR_FUNC(xrCreateTriangleMeshFB) \ @@ -356,16 +438,23 @@ struct openxr_instance_funcs USE_XR_FUNC(xrCreateVirtualKeyboardSpaceMETA) \ USE_XR_FUNC(xrCreateVulkanDeviceKHR) \ USE_XR_FUNC(xrCreateVulkanInstanceKHR) \ + USE_XR_FUNC(xrCreateWorldMeshDetectorML) \ + USE_XR_FUNC(xrDeleteSpatialAnchorsAsyncML) \ + USE_XR_FUNC(xrDeleteSpatialAnchorsCompleteML) \ USE_XR_FUNC(xrDeserializeSceneMSFT) \ USE_XR_FUNC(xrDestroyAction) \ USE_XR_FUNC(xrDestroyActionSet) \ + USE_XR_FUNC(xrDestroyAnchorBD) \ + USE_XR_FUNC(xrDestroyBodyTrackerBD) \ USE_XR_FUNC(xrDestroyBodyTrackerFB) \ + USE_XR_FUNC(xrDestroyBodyTrackerHTC) \ USE_XR_FUNC(xrDestroyEnvironmentDepthProviderMETA) \ USE_XR_FUNC(xrDestroyEnvironmentDepthSwapchainMETA) \ USE_XR_FUNC(xrDestroyExportedLocalizationMapML) \ USE_XR_FUNC(xrDestroyEyeTrackerFB) \ USE_XR_FUNC(xrDestroyFaceTracker2FB) \ USE_XR_FUNC(xrDestroyFaceTrackerFB) \ + USE_XR_FUNC(xrDestroyFacialExpressionClientML) \ USE_XR_FUNC(xrDestroyFacialTrackerHTC) \ USE_XR_FUNC(xrDestroyFoveationProfileFB) \ USE_XR_FUNC(xrDestroyGeometryInstanceFB) \ @@ -379,15 +468,21 @@ struct openxr_instance_funcs USE_XR_FUNC(xrDestroyPlaneDetectorEXT) \ USE_XR_FUNC(xrDestroySceneMSFT) \ USE_XR_FUNC(xrDestroySceneObserverMSFT) \ + USE_XR_FUNC(xrDestroySenseDataProviderBD) \ + USE_XR_FUNC(xrDestroySenseDataSnapshotBD) \ USE_XR_FUNC(xrDestroySession) \ USE_XR_FUNC(xrDestroySpace) \ USE_XR_FUNC(xrDestroySpaceUserFB) \ USE_XR_FUNC(xrDestroySpatialAnchorMSFT) \ USE_XR_FUNC(xrDestroySpatialAnchorStoreConnectionMSFT) \ + USE_XR_FUNC(xrDestroySpatialAnchorsStorageML) \ USE_XR_FUNC(xrDestroySpatialGraphNodeBindingMSFT) \ USE_XR_FUNC(xrDestroySwapchain) \ USE_XR_FUNC(xrDestroyTriangleMeshFB) \ USE_XR_FUNC(xrDestroyVirtualKeyboardMETA) \ + USE_XR_FUNC(xrDestroyWorldMeshDetectorML) \ + USE_XR_FUNC(xrDownloadSharedSpatialAnchorAsyncBD) \ + USE_XR_FUNC(xrDownloadSharedSpatialAnchorCompleteBD) \ USE_XR_FUNC(xrEnableLocalizationEventsML) \ USE_XR_FUNC(xrEnableUserCalibrationEventsML) \ USE_XR_FUNC(xrEndFrame) \ @@ -406,20 +501,24 @@ struct openxr_instance_funcs USE_XR_FUNC(xrEnumerateReprojectionModesMSFT) \ USE_XR_FUNC(xrEnumerateSceneComputeFeaturesMSFT) \ USE_XR_FUNC(xrEnumerateSpaceSupportedComponentsFB) \ + USE_XR_FUNC(xrEnumerateSpatialEntityComponentTypesBD) \ USE_XR_FUNC(xrEnumerateSwapchainFormats) \ USE_XR_FUNC(xrEnumerateSwapchainImages) \ USE_XR_FUNC(xrEnumerateViewConfigurationViews) \ USE_XR_FUNC(xrEnumerateViewConfigurations) \ USE_XR_FUNC(xrEnumerateViveTrackerPathsHTCX) \ USE_XR_FUNC(xrEraseSpaceFB) \ + USE_XR_FUNC(xrFreeWorldMeshBufferML) \ USE_XR_FUNC(xrGeometryInstanceSetTransformFB) \ USE_XR_FUNC(xrGetActionStateBoolean) \ USE_XR_FUNC(xrGetActionStateFloat) \ USE_XR_FUNC(xrGetActionStatePose) \ USE_XR_FUNC(xrGetActionStateVector2f) \ + USE_XR_FUNC(xrGetAnchorUuidBD) \ USE_XR_FUNC(xrGetAudioInputDeviceGuidOculus) \ USE_XR_FUNC(xrGetAudioOutputDeviceGuidOculus) \ USE_XR_FUNC(xrGetBodySkeletonFB) \ + USE_XR_FUNC(xrGetBodySkeletonHTC) \ USE_XR_FUNC(xrGetControllerModelKeyMSFT) \ USE_XR_FUNC(xrGetControllerModelPropertiesMSFT) \ USE_XR_FUNC(xrGetControllerModelStateMSFT) \ @@ -431,6 +530,7 @@ struct openxr_instance_funcs USE_XR_FUNC(xrGetEyeGazesFB) \ USE_XR_FUNC(xrGetFaceExpressionWeights2FB) \ USE_XR_FUNC(xrGetFaceExpressionWeightsFB) \ + USE_XR_FUNC(xrGetFacialExpressionBlendShapePropertiesML) \ USE_XR_FUNC(xrGetFacialExpressionsHTC) \ USE_XR_FUNC(xrGetFoveationEyeTrackedStateMETA) \ USE_XR_FUNC(xrGetHandMeshFB) \ @@ -449,6 +549,7 @@ struct openxr_instance_funcs USE_XR_FUNC(xrGetPlaneDetectionStateEXT) \ USE_XR_FUNC(xrGetPlaneDetectionsEXT) \ USE_XR_FUNC(xrGetPlanePolygonBufferEXT) \ + USE_XR_FUNC(xrGetQueriedSenseDataBD) \ USE_XR_FUNC(xrGetRecommendedLayerResolutionMETA) \ USE_XR_FUNC(xrGetReferenceSpaceBoundsRect) \ USE_XR_FUNC(xrGetRenderModelPropertiesFB) \ @@ -457,6 +558,7 @@ struct openxr_instance_funcs USE_XR_FUNC(xrGetSceneMarkerDecodedStringMSFT) \ USE_XR_FUNC(xrGetSceneMarkerRawDataMSFT) \ USE_XR_FUNC(xrGetSceneMeshBuffersMSFT) \ + USE_XR_FUNC(xrGetSenseDataProviderStateBD) \ USE_XR_FUNC(xrGetSerializedSceneFragmentDataMSFT) \ USE_XR_FUNC(xrGetSpaceBoundary2DFB) \ USE_XR_FUNC(xrGetSpaceBoundingBox2DFB) \ @@ -469,6 +571,9 @@ struct openxr_instance_funcs USE_XR_FUNC(xrGetSpaceUserIdFB) \ USE_XR_FUNC(xrGetSpaceUuidFB) \ USE_XR_FUNC(xrGetSpatialAnchorNameHTC) \ + USE_XR_FUNC(xrGetSpatialAnchorStateML) \ + USE_XR_FUNC(xrGetSpatialEntityComponentDataBD) \ + USE_XR_FUNC(xrGetSpatialEntityUuidBD) \ USE_XR_FUNC(xrGetSpatialGraphNodeBindingPropertiesMSFT) \ USE_XR_FUNC(xrGetSwapchainStateFB) \ USE_XR_FUNC(xrGetSystem) \ @@ -485,10 +590,13 @@ struct openxr_instance_funcs USE_XR_FUNC(xrGetVulkanGraphicsRequirements2KHR) \ USE_XR_FUNC(xrGetVulkanGraphicsRequirementsKHR) \ USE_XR_FUNC(xrGetVulkanInstanceExtensionsKHR) \ + USE_XR_FUNC(xrGetWorldMeshBufferRecommendSizeML) \ USE_XR_FUNC(xrImportLocalizationMapML) \ USE_XR_FUNC(xrLoadControllerModelMSFT) \ USE_XR_FUNC(xrLoadRenderModelFB) \ + USE_XR_FUNC(xrLocateBodyJointsBD) \ USE_XR_FUNC(xrLocateBodyJointsFB) \ + USE_XR_FUNC(xrLocateBodyJointsHTC) \ USE_XR_FUNC(xrLocateHandJointsEXT) \ USE_XR_FUNC(xrLocateSceneComponentsMSFT) \ USE_XR_FUNC(xrLocateSpace) \ @@ -504,18 +612,30 @@ struct openxr_instance_funcs USE_XR_FUNC(xrPassthroughStartFB) \ USE_XR_FUNC(xrPathToString) \ USE_XR_FUNC(xrPerfSettingsSetPerformanceLevelEXT) \ + USE_XR_FUNC(xrPersistSpatialAnchorAsyncBD) \ + USE_XR_FUNC(xrPersistSpatialAnchorCompleteBD) \ USE_XR_FUNC(xrPersistSpatialAnchorMSFT) \ USE_XR_FUNC(xrPollEvent) \ USE_XR_FUNC(xrPollFutureEXT) \ + USE_XR_FUNC(xrPublishSpatialAnchorsAsyncML) \ + USE_XR_FUNC(xrPublishSpatialAnchorsCompleteML) \ USE_XR_FUNC(xrQueryLocalizationMapsML) \ USE_XR_FUNC(xrQueryPerformanceMetricsCounterMETA) \ + USE_XR_FUNC(xrQuerySenseDataAsyncBD) \ + USE_XR_FUNC(xrQuerySenseDataCompleteBD) \ USE_XR_FUNC(xrQuerySpacesFB) \ + USE_XR_FUNC(xrQuerySpatialAnchorsAsyncML) \ + USE_XR_FUNC(xrQuerySpatialAnchorsCompleteML) \ USE_XR_FUNC(xrQuerySystemTrackedKeyboardFB) \ USE_XR_FUNC(xrReleaseSwapchainImage) \ USE_XR_FUNC(xrRequestDisplayRefreshRateFB) \ USE_XR_FUNC(xrRequestExitSession) \ USE_XR_FUNC(xrRequestMapLocalizationML) \ USE_XR_FUNC(xrRequestSceneCaptureFB) \ + USE_XR_FUNC(xrRequestWorldMeshAsyncML) \ + USE_XR_FUNC(xrRequestWorldMeshCompleteML) \ + USE_XR_FUNC(xrRequestWorldMeshStateAsyncML) \ + USE_XR_FUNC(xrRequestWorldMeshStateCompleteML) \ USE_XR_FUNC(xrResultToString) \ USE_XR_FUNC(xrRetrieveSpaceQueryResultsFB) \ USE_XR_FUNC(xrSaveSpaceFB) \ @@ -535,16 +655,28 @@ struct openxr_instance_funcs USE_XR_FUNC(xrSetMarkerTrackingVARJO) \ USE_XR_FUNC(xrSetPerformanceMetricsStateMETA) \ USE_XR_FUNC(xrSetSpaceComponentStatusFB) \ + USE_XR_FUNC(xrSetSystemNotificationsML) \ USE_XR_FUNC(xrSetTrackingOptimizationSettingsHintQCOM) \ USE_XR_FUNC(xrSetViewOffsetVARJO) \ USE_XR_FUNC(xrSetVirtualKeyboardModelVisibilityMETA) \ USE_XR_FUNC(xrShareSpacesFB) \ + USE_XR_FUNC(xrShareSpacesMETA) \ + USE_XR_FUNC(xrShareSpatialAnchorAsyncBD) \ + USE_XR_FUNC(xrShareSpatialAnchorCompleteBD) \ USE_XR_FUNC(xrSnapshotMarkerDetectorML) \ + USE_XR_FUNC(xrStartColocationAdvertisementMETA) \ + USE_XR_FUNC(xrStartColocationDiscoveryMETA) \ USE_XR_FUNC(xrStartEnvironmentDepthProviderMETA) \ + USE_XR_FUNC(xrStartSenseDataProviderAsyncBD) \ + USE_XR_FUNC(xrStartSenseDataProviderCompleteBD) \ + USE_XR_FUNC(xrStopColocationAdvertisementMETA) \ + USE_XR_FUNC(xrStopColocationDiscoveryMETA) \ USE_XR_FUNC(xrStopEnvironmentDepthProviderMETA) \ USE_XR_FUNC(xrStopHapticFeedback) \ + USE_XR_FUNC(xrStopSenseDataProviderBD) \ USE_XR_FUNC(xrStringToPath) \ USE_XR_FUNC(xrStructureTypeToString) \ + USE_XR_FUNC(xrStructureTypeToString2KHR) \ USE_XR_FUNC(xrSuggestInteractionProfileBindings) \ USE_XR_FUNC(xrSuggestVirtualKeyboardLocationMETA) \ USE_XR_FUNC(xrSyncActions) \ @@ -556,9 +688,13 @@ struct openxr_instance_funcs USE_XR_FUNC(xrTriangleMeshGetIndexBufferFB) \ USE_XR_FUNC(xrTriangleMeshGetVertexBufferFB) \ USE_XR_FUNC(xrTryCreateSpatialGraphStaticNodeBindingMSFT) \ + USE_XR_FUNC(xrUnpersistSpatialAnchorAsyncBD) \ + USE_XR_FUNC(xrUnpersistSpatialAnchorCompleteBD) \ USE_XR_FUNC(xrUnpersistSpatialAnchorMSFT) \ USE_XR_FUNC(xrUpdateHandMeshMSFT) \ USE_XR_FUNC(xrUpdatePassthroughColorLutMETA) \ + USE_XR_FUNC(xrUpdateSpatialAnchorsExpirationAsyncML) \ + USE_XR_FUNC(xrUpdateSpatialAnchorsExpirationCompleteML) \ USE_XR_FUNC(xrUpdateSwapchainFB) \ USE_XR_FUNC(xrWaitFrame) \ USE_XR_FUNC(xrWaitSwapchainImage) diff --git a/wineopenxr/wineopenxr.h b/wineopenxr/wineopenxr.h index a22938f4..439429b4 100644 --- a/wineopenxr/wineopenxr.h +++ b/wineopenxr/wineopenxr.h @@ -3,7 +3,7 @@ * 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. + * Copyright (c) 2017-2025 The Khronos Group Inc. * * SPDX-License-Identifier: Apache-2.0 OR MIT * @@ -69,7 +69,7 @@ #define XR_KHR_COMPOSITION_LAYER_CUBE_EXTENSION_NAME "XR_KHR_composition_layer_cube" #define XR_KHR_composition_layer_depth_SPEC_VERSION 6 #define XR_KHR_COMPOSITION_LAYER_DEPTH_EXTENSION_NAME "XR_KHR_composition_layer_depth" -#define XR_KHR_vulkan_swapchain_format_list_SPEC_VERSION 4 +#define XR_KHR_vulkan_swapchain_format_list_SPEC_VERSION 5 #define XR_KHR_VULKAN_SWAPCHAIN_FORMAT_LIST_EXTENSION_NAME "XR_KHR_vulkan_swapchain_format_list" #define XR_EXT_performance_settings_SPEC_VERSION 4 #define XR_EXT_PERFORMANCE_SETTINGS_EXTENSION_NAME "XR_EXT_performance_settings" @@ -97,7 +97,7 @@ #define XR_KHR_COMPOSITION_LAYER_COLOR_SCALE_BIAS_EXTENSION_NAME "XR_KHR_composition_layer_color_scale_bias" #define XR_KHR_win32_convert_performance_counter_time_SPEC_VERSION 1 #define XR_KHR_WIN32_CONVERT_PERFORMANCE_COUNTER_TIME_EXTENSION_NAME "XR_KHR_win32_convert_performance_counter_time" -#define XR_VARJO_quad_views_SPEC_VERSION 1 +#define XR_VARJO_quad_views_SPEC_VERSION 2 #define XR_VARJO_QUAD_VIEWS_EXTENSION_NAME "XR_VARJO_quad_views" #define XR_MSFT_unbounded_reference_space_SPEC_VERSION 1 #define XR_MSFT_UNBOUNDED_REFERENCE_SPACE_EXTENSION_NAME "XR_MSFT_unbounded_reference_space" @@ -105,7 +105,7 @@ #define XR_MSFT_SPATIAL_ANCHOR_EXTENSION_NAME "XR_MSFT_spatial_anchor" #define XR_FB_composition_layer_image_layout_SPEC_VERSION 1 #define XR_FB_COMPOSITION_LAYER_IMAGE_LAYOUT_EXTENSION_NAME "XR_FB_composition_layer_image_layout" -#define XR_FB_composition_layer_alpha_blend_SPEC_VERSION 2 +#define XR_FB_composition_layer_alpha_blend_SPEC_VERSION 3 #define XR_FB_COMPOSITION_LAYER_ALPHA_BLEND_EXTENSION_NAME "XR_FB_composition_layer_alpha_blend" #define XR_MND_headless_SPEC_VERSION 2 #define XR_MND_HEADLESS_EXTENSION_NAME "XR_MND_headless" @@ -173,7 +173,7 @@ #define XR_HTC_VIVE_COSMOS_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_HTC_vive_cosmos_controller_interaction" #define XR_HTCX_vive_tracker_interaction_SPEC_VERSION 3 #define XR_HTCX_VIVE_TRACKER_INTERACTION_EXTENSION_NAME "XR_HTCX_vive_tracker_interaction" -#define XR_HTC_facial_tracking_SPEC_VERSION 2 +#define XR_HTC_facial_tracking_SPEC_VERSION 3 #define XR_HTC_FACIAL_TRACKING_EXTENSION_NAME "XR_HTC_facial_tracking" #define XR_HTC_vive_focus3_controller_interaction_SPEC_VERSION 2 #define XR_HTC_VIVE_FOCUS3_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_HTC_vive_focus3_controller_interaction" @@ -204,7 +204,7 @@ #define XR_MAX_KEYBOARD_TRACKING_NAME_SIZE_FB 128 #define XR_FB_triangle_mesh_SPEC_VERSION 2 #define XR_FB_TRIANGLE_MESH_EXTENSION_NAME "XR_FB_triangle_mesh" -#define XR_FB_passthrough_SPEC_VERSION 3 +#define XR_FB_passthrough_SPEC_VERSION 4 #define XR_FB_PASSTHROUGH_EXTENSION_NAME "XR_FB_passthrough" #define XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB 256 #define XR_FB_render_model_SPEC_VERSION 4 @@ -222,7 +222,7 @@ #define XR_VARJO_MARKER_TRACKING_EXTENSION_NAME "XR_VARJO_marker_tracking" #define XR_VARJO_view_offset_SPEC_VERSION 1 #define XR_VARJO_VIEW_OFFSET_EXTENSION_NAME "XR_VARJO_view_offset" -#define XR_VARJO_xr4_controller_interaction_SPEC_VERSION 1 +#define XR_VARJO_xr4_controller_interaction_SPEC_VERSION 2 #define XR_VARJO_XR4_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_VARJO_xr4_controller_interaction" #define XR_ML_ml2_controller_interaction_SPEC_VERSION 1 #define XR_ML_ML2_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_ML_ml2_controller_interaction" @@ -235,6 +235,10 @@ #define XR_ML_localization_map_SPEC_VERSION 1 #define XR_ML_LOCALIZATION_MAP_EXTENSION_NAME "XR_ML_localization_map" #define XR_MAX_LOCALIZATION_MAP_NAME_LENGTH_ML 64 +#define XR_ML_spatial_anchors_SPEC_VERSION 1 +#define XR_ML_SPATIAL_ANCHORS_EXTENSION_NAME "XR_ML_spatial_anchors" +#define XR_ML_spatial_anchors_storage_SPEC_VERSION 1 +#define XR_ML_SPATIAL_ANCHORS_STORAGE_EXTENSION_NAME "XR_ML_spatial_anchors_storage" #define XR_ML_user_calibration_SPEC_VERSION 1 #define XR_ML_USER_CALIBRATION_EXTENSION_NAME "XR_ML_user_calibration" #define XR_MSFT_spatial_anchor_persistence_SPEC_VERSION 2 @@ -242,6 +246,9 @@ #define XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_MSFT 256 #define XR_MSFT_scene_marker_SPEC_VERSION 1 #define XR_MSFT_SCENE_MARKER_EXTENSION_NAME "XR_MSFT_scene_marker" +#define XR_KHR_extended_struct_name_lengths_SPEC_VERSION 1 +#define XR_KHR_EXTENDED_STRUCT_NAME_LENGTHS_EXTENSION_NAME "XR_KHR_extended_struct_name_lengths" +#define XR_MAX_STRUCTURE_NAME_SIZE_EXTENDED_KHR 256 #define XR_ULTRALEAP_hand_tracking_forearm_SPEC_VERSION 1 #define XR_ULTRALEAP_HAND_TRACKING_FOREARM_EXTENSION_NAME "XR_ULTRALEAP_hand_tracking_forearm" #define XR_FB_spatial_entity_query_SPEC_VERSION 1 @@ -290,6 +297,8 @@ #define XR_FB_TOUCH_CONTROLLER_PROXIMITY_EXTENSION_NAME "XR_FB_touch_controller_proximity" #define XR_FB_haptic_pcm_SPEC_VERSION 1 #define XR_FB_HAPTIC_PCM_EXTENSION_NAME "XR_FB_haptic_pcm" +#define XR_EXT_frame_synthesis_SPEC_VERSION 1 +#define XR_EXT_FRAME_SYNTHESIS_EXTENSION_NAME "XR_EXT_frame_synthesis" #define XR_FB_composition_layer_depth_test_SPEC_VERSION 1 #define XR_FB_COMPOSITION_LAYER_DEPTH_TEST_EXTENSION_NAME "XR_FB_composition_layer_depth_test" #define XR_META_local_dimming_SPEC_VERSION 1 @@ -308,10 +317,14 @@ #define XR_META_PERFORMANCE_METRICS_EXTENSION_NAME "XR_META_performance_metrics" #define XR_FB_spatial_entity_storage_batch_SPEC_VERSION 1 #define XR_FB_SPATIAL_ENTITY_STORAGE_BATCH_EXTENSION_NAME "XR_FB_spatial_entity_storage_batch" +#define XR_META_detached_controllers_SPEC_VERSION 1 +#define XR_META_DETACHED_CONTROLLERS_EXTENSION_NAME "XR_META_detached_controllers" #define XR_FB_spatial_entity_user_SPEC_VERSION 1 #define XR_FB_SPATIAL_ENTITY_USER_EXTENSION_NAME "XR_FB_spatial_entity_user" #define XR_META_headset_id_SPEC_VERSION 2 #define XR_META_HEADSET_ID_EXTENSION_NAME "XR_META_headset_id" +#define XR_META_hand_tracking_microgestures_SPEC_VERSION 1 +#define XR_META_HAND_TRACKING_MICROGESTURES_EXTENSION_NAME "XR_META_hand_tracking_microgestures" #define XR_META_recommended_layer_resolution_SPEC_VERSION 1 #define XR_META_RECOMMENDED_LAYER_RESOLUTION_EXTENSION_NAME "XR_META_recommended_layer_resolution" #define XR_META_passthrough_color_lut_SPEC_VERSION 1 @@ -322,8 +335,13 @@ #define XR_META_AUTOMATIC_LAYER_FILTER_EXTENSION_NAME "XR_META_automatic_layer_filter" #define XR_META_touch_controller_plus_SPEC_VERSION 1 #define XR_META_TOUCH_CONTROLLER_PLUS_EXTENSION_NAME "XR_META_touch_controller_plus" +#define XR_META_passthrough_layer_resumed_event_SPEC_VERSION 1 +#define XR_META_PASSTHROUGH_LAYER_RESUMED_EVENT_EXTENSION_NAME "XR_META_passthrough_layer_resumed_event" #define XR_FB_face_tracking2_SPEC_VERSION 1 #define XR_FB_FACE_TRACKING2_EXTENSION_NAME "XR_FB_face_tracking2" +#define XR_META_spatial_entity_sharing_SPEC_VERSION 1 +#define XR_META_SPATIAL_ENTITY_SHARING_EXTENSION_NAME "XR_META_spatial_entity_sharing" +#define XR_MAX_SPACES_PER_SHARE_REQUEST_META 32 #define XR_META_environment_depth_SPEC_VERSION 1 #define XR_META_ENVIRONMENT_DEPTH_EXTENSION_NAME "XR_META_environment_depth" #define XR_EXT_uuid_SPEC_VERSION 1 @@ -338,17 +356,31 @@ #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 +#define XR_HTC_body_tracking_SPEC_VERSION 1 +#define XR_HTC_BODY_TRACKING_EXTENSION_NAME "XR_HTC_body_tracking" #define XR_EXT_active_action_set_priority_SPEC_VERSION 1 #define XR_EXT_ACTIVE_ACTION_SET_PRIORITY_EXTENSION_NAME "XR_EXT_active_action_set_priority" #define XR_MNDX_force_feedback_curl_SPEC_VERSION 1 #define XR_MNDX_FORCE_FEEDBACK_CURL_EXTENSION_NAME "XR_MNDX_force_feedback_curl" #define XR_BD_controller_interaction_SPEC_VERSION 2 #define XR_BD_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_BD_controller_interaction" +#define XR_BD_body_tracking_SPEC_VERSION 1 +#define XR_BD_BODY_TRACKING_EXTENSION_NAME "XR_BD_body_tracking" +#define XR_BD_spatial_sensing_SPEC_VERSION 1 +#define XR_BD_SPATIAL_SENSING_EXTENSION_NAME "XR_BD_spatial_sensing" +#define XR_BD_spatial_anchor_SPEC_VERSION 1 +#define XR_BD_SPATIAL_ANCHOR_EXTENSION_NAME "XR_BD_spatial_anchor" +#define XR_BD_spatial_anchor_sharing_SPEC_VERSION 1 +#define XR_BD_SPATIAL_ANCHOR_SHARING_EXTENSION_NAME "XR_BD_spatial_anchor_sharing" +#define XR_BD_spatial_scene_SPEC_VERSION 1 +#define XR_BD_SPATIAL_SCENE_EXTENSION_NAME "XR_BD_spatial_scene" +#define XR_BD_spatial_mesh_SPEC_VERSION 1 +#define XR_BD_SPATIAL_MESH_EXTENSION_NAME "XR_BD_spatial_mesh" #define XR_EXT_local_floor_SPEC_VERSION 1 #define XR_EXT_LOCAL_FLOOR_EXTENSION_NAME "XR_EXT_local_floor" #define XR_EXT_hand_tracking_data_source_SPEC_VERSION 1 #define XR_EXT_HAND_TRACKING_DATA_SOURCE_EXTENSION_NAME "XR_EXT_hand_tracking_data_source" -#define XR_EXT_plane_detection_SPEC_VERSION 1 +#define XR_EXT_plane_detection_SPEC_VERSION 2 #define XR_EXT_PLANE_DETECTION_EXTENSION_NAME "XR_EXT_plane_detection" #define XR_OPPO_controller_interaction_SPEC_VERSION 1 #define XR_OPPO_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_OPPO_controller_interaction" @@ -359,10 +391,27 @@ #define XR_EXT_USER_PRESENCE_EXTENSION_NAME "XR_EXT_user_presence" #define XR_KHR_locate_spaces_SPEC_VERSION 1 #define XR_KHR_LOCATE_SPACES_EXTENSION_NAME "XR_KHR_locate_spaces" +#define XR_ML_system_notifications_SPEC_VERSION 1 +#define XR_ML_SYSTEM_NOTIFICATIONS_EXTENSION_NAME "XR_ML_system_notifications" +#define XR_ML_world_mesh_detection_SPEC_VERSION 1 +#define XR_ML_WORLD_MESH_DETECTION_EXTENSION_NAME "XR_ML_world_mesh_detection" +#define XR_ML_facial_expression_SPEC_VERSION 1 +#define XR_ML_FACIAL_EXPRESSION_EXTENSION_NAME "XR_ML_facial_expression" +#define XR_ML_view_configuration_depth_range_change_SPEC_VERSION 1 +#define XR_ML_VIEW_CONFIGURATION_DEPTH_RANGE_CHANGE_EXTENSION_NAME "XR_ML_view_configuration_depth_range_change" #define XR_YVR_controller_interaction_SPEC_VERSION 1 #define XR_YVR_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_YVR_controller_interaction" +#define XR_EXT_composition_layer_inverted_alpha_SPEC_VERSION 1 +#define XR_EXT_COMPOSITION_LAYER_INVERTED_ALPHA_EXTENSION_NAME "XR_EXT_composition_layer_inverted_alpha" +#define XR_META_colocation_discovery_SPEC_VERSION 1 +#define XR_META_COLOCATION_DISCOVERY_EXTENSION_NAME "XR_META_colocation_discovery" +#define XR_MAX_COLOCATION_DISCOVERY_BUFFER_SIZE_META 1024 +#define XR_META_spatial_entity_group_sharing_SPEC_VERSION 1 +#define XR_META_SPATIAL_ENTITY_GROUP_SHARING_EXTENSION_NAME "XR_META_spatial_entity_group_sharing" #define XR_KHR_maintenance1_SPEC_VERSION 1 #define XR_KHR_MAINTENANCE1_EXTENSION_NAME "XR_KHR_maintenance1" +#define XR_LOGITECH_mx_ink_stylus_interaction_SPEC_VERSION 1 +#define XR_LOGITECH_MX_INK_STYLUS_INTERACTION_EXTENSION_NAME "XR_LOGITECH_mx_ink_stylus_interaction" #define XR_MAKE_VERSION(major, minor, patch) \ @@ -375,7 +424,13 @@ #define XR_VERSION_PATCH(version) (uint32_t)((uint64_t)(version) & 0xffffffffULL) -#define XR_CURRENT_API_VERSION XR_MAKE_VERSION(1, 1, 36) +#define XR_CURRENT_API_VERSION XR_MAKE_VERSION(1, 1, 47) + + +#define XR_API_VERSION_1_0 XR_MAKE_VERSION(1, 0, XR_VERSION_PATCH(XR_CURRENT_API_VERSION)) + + +#define XR_API_VERSION_1_1 XR_MAKE_VERSION(1, 1, XR_VERSION_PATCH(XR_CURRENT_API_VERSION)) #if !defined(XR_MAY_ALIAS) @@ -485,6 +540,12 @@ #define XR_HAND_JOINT_COUNT_EXT 26 +#define XR_BODY_JOINT_COUNT_BD 24 + + +#define XR_BODY_JOINT_WITHOUT_ARM_COUNT_BD 16 + + #define XR_NULL_CONTROLLER_MODEL_KEY_MSFT 0 @@ -507,15 +568,22 @@ #define XR_MAX_HAPTIC_PCM_BUFFER_SIZE_FB 4000 + + +#define XR_BODY_JOINT_COUNT_HTC 26 XR_DEFINE_HANDLE(XrAction) XR_DEFINE_HANDLE(XrActionSet) +XR_DEFINE_HANDLE(XrAnchorBD) +XR_DEFINE_HANDLE(XrBodyTrackerBD) XR_DEFINE_HANDLE(XrBodyTrackerFB) +XR_DEFINE_HANDLE(XrBodyTrackerHTC) XR_DEFINE_HANDLE(XrEnvironmentDepthProviderMETA) XR_DEFINE_HANDLE(XrEnvironmentDepthSwapchainMETA) XR_DEFINE_HANDLE(XrExportedLocalizationMapML) XR_DEFINE_HANDLE(XrEyeTrackerFB) XR_DEFINE_HANDLE(XrFaceTracker2FB) XR_DEFINE_HANDLE(XrFaceTrackerFB) +XR_DEFINE_HANDLE(XrFacialExpressionClientML) XR_DEFINE_HANDLE(XrFacialTrackerHTC) XR_DEFINE_HANDLE(XrFoveationProfileFB) XR_DEFINE_HANDLE(XrGeometryInstanceFB) @@ -529,15 +597,19 @@ XR_DEFINE_HANDLE(XrPassthroughLayerFB) XR_DEFINE_HANDLE(XrPlaneDetectorEXT) XR_DEFINE_HANDLE(XrSceneMSFT) XR_DEFINE_HANDLE(XrSceneObserverMSFT) +XR_DEFINE_HANDLE(XrSenseDataProviderBD) +XR_DEFINE_HANDLE(XrSenseDataSnapshotBD) XR_DEFINE_HANDLE(XrSession) XR_DEFINE_HANDLE(XrSpace) XR_DEFINE_HANDLE(XrSpaceUserFB) XR_DEFINE_HANDLE(XrSpatialAnchorMSFT) XR_DEFINE_HANDLE(XrSpatialAnchorStoreConnectionMSFT) +XR_DEFINE_HANDLE(XrSpatialAnchorsStorageML) XR_DEFINE_HANDLE(XrSpatialGraphNodeBindingMSFT) XR_DEFINE_HANDLE(XrSwapchain) XR_DEFINE_HANDLE(XrTriangleMeshFB) XR_DEFINE_HANDLE(XrVirtualKeyboardMETA) +XR_DEFINE_HANDLE(XrWorldMeshDetectorML) typedef uint64_t XrAsyncRequestIdFB; typedef uint32_t XrBool32; @@ -549,6 +621,7 @@ typedef uint64_t XrMarkerML; typedef uint64_t XrPath; typedef uint64_t XrRenderModelKeyFB; typedef uint64_t XrSpaceUserIdFB; +typedef uint64_t XrSpatialEntityIdBD; typedef uint64_t XrSystemId; typedef int64_t XrTime; typedef uint64_t XrVersion; @@ -565,10 +638,12 @@ typedef XrFlags64 XrDigitalLensControlFlagsALMALENCE; typedef XrFlags64 XrEnvironmentDepthProviderCreateFlagsMETA; typedef XrFlags64 XrEnvironmentDepthSwapchainCreateFlagsMETA; typedef XrFlags64 XrExternalCameraStatusFlagsOCULUS; +typedef XrFlags64 XrFacialExpressionBlendShapePropertiesFlagsML; typedef XrFlags64 XrFoveationDynamicFlagsHTC; typedef XrFlags64 XrFoveationEyeTrackedProfileCreateFlagsMETA; typedef XrFlags64 XrFoveationEyeTrackedStateFlagsMETA; typedef XrFlags64 XrFrameEndInfoFlagsML; +typedef XrFlags64 XrFrameSynthesisInfoFlagsEXT; typedef XrFlags64 XrGlobalDimmerFrameEndInfoFlagsML; typedef XrFlags64 XrHandTrackingAimFlagsFB; typedef XrFlags64 XrInputSourceLocalizedNameFlags; @@ -590,6 +665,7 @@ typedef XrFlags64 XrSemanticLabelsSupportFlagsFB; typedef XrFlags64 XrSessionCreateFlags; typedef XrFlags64 XrSpaceLocationFlags; typedef XrFlags64 XrSpaceVelocityFlags; +typedef XrFlags64 XrSpatialMeshConfigFlagsBD; typedef XrFlags64 XrSwapchainCreateFlags; typedef XrFlags64 XrSwapchainCreateFoveationFlagsFB; typedef XrFlags64 XrSwapchainStateFoveationFlagsFB; @@ -599,6 +675,7 @@ typedef XrFlags64 XrViewStateFlags; typedef XrFlags64 XrVirtualKeyboardInputStateFlagsMETA; typedef XrFlags64 XrVulkanDeviceCreateFlagsKHR; typedef XrFlags64 XrVulkanInstanceCreateFlagsKHR; +typedef XrFlags64 XrWorldMeshDetectorFlagsML; typedef enum XrActionType { @@ -621,6 +698,43 @@ typedef enum XrBlendFactorFB XR_BLEND_FACTOR_FB_MAX_ENUM = 0x7fffffff, } XrBlendFactorFB; +typedef enum XrBodyJointBD +{ + XR_BODY_JOINT_PELVIS_BD = 0, + XR_BODY_JOINT_LEFT_HIP_BD = 1, + XR_BODY_JOINT_RIGHT_HIP_BD = 2, + XR_BODY_JOINT_SPINE1_BD = 3, + XR_BODY_JOINT_LEFT_KNEE_BD = 4, + XR_BODY_JOINT_RIGHT_KNEE_BD = 5, + XR_BODY_JOINT_SPINE2_BD = 6, + XR_BODY_JOINT_LEFT_ANKLE_BD = 7, + XR_BODY_JOINT_RIGHT_ANKLE_BD = 8, + XR_BODY_JOINT_SPINE3_BD = 9, + XR_BODY_JOINT_LEFT_FOOT_BD = 10, + XR_BODY_JOINT_RIGHT_FOOT_BD = 11, + XR_BODY_JOINT_NECK_BD = 12, + XR_BODY_JOINT_LEFT_COLLAR_BD = 13, + XR_BODY_JOINT_RIGHT_COLLAR_BD = 14, + XR_BODY_JOINT_HEAD_BD = 15, + XR_BODY_JOINT_LEFT_SHOULDER_BD = 16, + XR_BODY_JOINT_RIGHT_SHOULDER_BD = 17, + XR_BODY_JOINT_LEFT_ELBOW_BD = 18, + XR_BODY_JOINT_RIGHT_ELBOW_BD = 19, + XR_BODY_JOINT_LEFT_WRIST_BD = 20, + XR_BODY_JOINT_RIGHT_WRIST_BD = 21, + XR_BODY_JOINT_LEFT_HAND_BD = 22, + XR_BODY_JOINT_RIGHT_HAND_BD = 23, + XR_BODY_JOINT_BD_MAX_ENUM = 0x7fffffff, +} XrBodyJointBD; + +typedef enum XrBodyJointConfidenceHTC +{ + XR_BODY_JOINT_CONFIDENCE_NONE_HTC = 0, + XR_BODY_JOINT_CONFIDENCE_LOW_HTC = 1, + XR_BODY_JOINT_CONFIDENCE_HIGH_HTC = 2, + XR_BODY_JOINT_CONFIDENCE_HTC_MAX_ENUM = 0x7fffffff, +} XrBodyJointConfidenceHTC; + typedef enum XrBodyJointFB { XR_BODY_JOINT_NONE_FB = -1, @@ -698,12 +812,56 @@ typedef enum XrBodyJointFB XR_BODY_JOINT_FB_MAX_ENUM = 0x7fffffff, } XrBodyJointFB; +typedef enum XrBodyJointHTC +{ + XR_BODY_JOINT_PELVIS_HTC = 0, + XR_BODY_JOINT_LEFT_HIP_HTC = 1, + XR_BODY_JOINT_LEFT_KNEE_HTC = 2, + XR_BODY_JOINT_LEFT_ANKLE_HTC = 3, + XR_BODY_JOINT_LEFT_FEET_HTC = 4, + XR_BODY_JOINT_RIGHT_HIP_HTC = 5, + XR_BODY_JOINT_RIGHT_KNEE_HTC = 6, + XR_BODY_JOINT_RIGHT_ANKLE_HTC = 7, + XR_BODY_JOINT_RIGHT_FEET_HTC = 8, + XR_BODY_JOINT_WAIST_HTC = 9, + XR_BODY_JOINT_SPINE_LOWER_HTC = 10, + XR_BODY_JOINT_SPINE_MIDDLE_HTC = 11, + XR_BODY_JOINT_SPINE_HIGH_HTC = 12, + XR_BODY_JOINT_CHEST_HTC = 13, + XR_BODY_JOINT_NECK_HTC = 14, + XR_BODY_JOINT_HEAD_HTC = 15, + XR_BODY_JOINT_LEFT_CLAVICLE_HTC = 16, + XR_BODY_JOINT_LEFT_SCAPULA_HTC = 17, + XR_BODY_JOINT_LEFT_ARM_HTC = 18, + XR_BODY_JOINT_LEFT_ELBOW_HTC = 19, + XR_BODY_JOINT_LEFT_WRIST_HTC = 20, + XR_BODY_JOINT_RIGHT_CLAVICLE_HTC = 21, + XR_BODY_JOINT_RIGHT_SCAPULA_HTC = 22, + XR_BODY_JOINT_RIGHT_ARM_HTC = 23, + XR_BODY_JOINT_RIGHT_ELBOW_HTC = 24, + XR_BODY_JOINT_RIGHT_WRIST_HTC = 25, + XR_BODY_JOINT_HTC_MAX_ENUM = 0x7fffffff, +} XrBodyJointHTC; + +typedef enum XrBodyJointSetBD +{ + XR_BODY_JOINT_SET_BODY_WITHOUT_ARM_BD = 1, + XR_BODY_JOINT_SET_FULL_BODY_JOINTS_BD = 2, + XR_BODY_JOINT_SET_BD_MAX_ENUM = 0x7fffffff, +} XrBodyJointSetBD; + typedef enum XrBodyJointSetFB { XR_BODY_JOINT_SET_DEFAULT_FB = 0, XR_BODY_JOINT_SET_FB_MAX_ENUM = 0x7fffffff, } XrBodyJointSetFB; +typedef enum XrBodyJointSetHTC +{ + XR_BODY_JOINT_SET_FULL_HTC = 0, + XR_BODY_JOINT_SET_HTC_MAX_ENUM = 0x7fffffff, +} XrBodyJointSetHTC; + typedef enum XrColorSpaceFB { XR_COLOR_SPACE_UNMANAGED_FB = 0, @@ -735,6 +893,7 @@ 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_INVERTED_ALPHA_BIT_EXT = 0x00000008, XR_COMPOSITION_LAYER_FLAG_BITS_MAX_ENUM = 0x7fffffff, } XrCompositionLayerFlagBits; @@ -1005,6 +1164,64 @@ typedef enum XrFaceTrackingDataSource2FB XR_FACE_TRACKING_DATA_SOURCE_2FB_MAX_ENUM = 0x7fffffff, } XrFaceTrackingDataSource2FB; +typedef enum XrFacialBlendShapeML +{ + XR_FACIAL_BLEND_SHAPE_BROW_LOWERER_L_ML = 0, + XR_FACIAL_BLEND_SHAPE_BROW_LOWERER_R_ML = 1, + XR_FACIAL_BLEND_SHAPE_CHEEK_RAISER_L_ML = 2, + XR_FACIAL_BLEND_SHAPE_CHEEK_RAISER_R_ML = 3, + XR_FACIAL_BLEND_SHAPE_CHIN_RAISER_ML = 4, + XR_FACIAL_BLEND_SHAPE_DIMPLER_L_ML = 5, + XR_FACIAL_BLEND_SHAPE_DIMPLER_R_ML = 6, + XR_FACIAL_BLEND_SHAPE_EYES_CLOSED_L_ML = 7, + XR_FACIAL_BLEND_SHAPE_EYES_CLOSED_R_ML = 8, + XR_FACIAL_BLEND_SHAPE_INNER_BROW_RAISER_L_ML = 9, + XR_FACIAL_BLEND_SHAPE_INNER_BROW_RAISER_R_ML = 10, + XR_FACIAL_BLEND_SHAPE_JAW_DROP_ML = 11, + XR_FACIAL_BLEND_SHAPE_LID_TIGHTENER_L_ML = 12, + XR_FACIAL_BLEND_SHAPE_LID_TIGHTENER_R_ML = 13, + XR_FACIAL_BLEND_SHAPE_LIP_CORNER_DEPRESSOR_L_ML = 14, + XR_FACIAL_BLEND_SHAPE_LIP_CORNER_DEPRESSOR_R_ML = 15, + XR_FACIAL_BLEND_SHAPE_LIP_CORNER_PULLER_L_ML = 16, + XR_FACIAL_BLEND_SHAPE_LIP_CORNER_PULLER_R_ML = 17, + XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_LB_ML = 18, + XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_LT_ML = 19, + XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_RB_ML = 20, + XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_RT_ML = 21, + XR_FACIAL_BLEND_SHAPE_LIP_PRESSOR_L_ML = 22, + XR_FACIAL_BLEND_SHAPE_LIP_PRESSOR_R_ML = 23, + XR_FACIAL_BLEND_SHAPE_LIP_PUCKER_L_ML = 24, + XR_FACIAL_BLEND_SHAPE_LIP_PUCKER_R_ML = 25, + XR_FACIAL_BLEND_SHAPE_LIP_STRETCHER_L_ML = 26, + XR_FACIAL_BLEND_SHAPE_LIP_STRETCHER_R_ML = 27, + XR_FACIAL_BLEND_SHAPE_LIP_SUCK_LB_ML = 28, + XR_FACIAL_BLEND_SHAPE_LIP_SUCK_LT_ML = 29, + XR_FACIAL_BLEND_SHAPE_LIP_SUCK_RB_ML = 30, + XR_FACIAL_BLEND_SHAPE_LIP_SUCK_RT_ML = 31, + XR_FACIAL_BLEND_SHAPE_LIP_TIGHTENER_L_ML = 32, + XR_FACIAL_BLEND_SHAPE_LIP_TIGHTENER_R_ML = 33, + XR_FACIAL_BLEND_SHAPE_LIPS_TOWARD_ML = 34, + XR_FACIAL_BLEND_SHAPE_LOWER_LIP_DEPRESSOR_L_ML = 35, + XR_FACIAL_BLEND_SHAPE_LOWER_LIP_DEPRESSOR_R_ML = 36, + XR_FACIAL_BLEND_SHAPE_NOSE_WRINKLER_L_ML = 37, + XR_FACIAL_BLEND_SHAPE_NOSE_WRINKLER_R_ML = 38, + XR_FACIAL_BLEND_SHAPE_OUTER_BROW_RAISER_L_ML = 39, + XR_FACIAL_BLEND_SHAPE_OUTER_BROW_RAISER_R_ML = 40, + XR_FACIAL_BLEND_SHAPE_UPPER_LID_RAISER_L_ML = 41, + XR_FACIAL_BLEND_SHAPE_UPPER_LID_RAISER_R_ML = 42, + XR_FACIAL_BLEND_SHAPE_UPPER_LIP_RAISER_L_ML = 43, + XR_FACIAL_BLEND_SHAPE_UPPER_LIP_RAISER_R_ML = 44, + XR_FACIAL_BLEND_SHAPE_TONGUE_OUT_ML = 45, + XR_FACIAL_BLEND_SHAPE_ML_MAX_ENUM = 0x7fffffff, +} XrFacialBlendShapeML; + +typedef enum XrFacialExpressionBlendShapePropertiesFlagBitsML +{ + XR_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_VALID_BIT_ML = 0x00000001, + XR_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_TRACKED_BIT_ML = 0x00000002, + XR_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_FLAG_BITS_ML_MAX_ENUM = 0x7fffffff, +} XrFacialExpressionBlendShapePropertiesFlagBitsML; + typedef enum XrFacialTrackingTypeHTC { XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC = 1, @@ -1213,10 +1430,10 @@ typedef enum XrLipExpressionHTC XR_LIP_EXPRESSION_MOUTH_UPPER_OVERTURN_HTC = 9, XR_LIP_EXPRESSION_MOUTH_LOWER_OVERTURN_HTC = 10, XR_LIP_EXPRESSION_MOUTH_POUT_HTC = 11, - XR_LIP_EXPRESSION_MOUTH_SMILE_RIGHT_HTC = 12, - XR_LIP_EXPRESSION_MOUTH_SMILE_LEFT_HTC = 13, - XR_LIP_EXPRESSION_MOUTH_SAD_RIGHT_HTC = 14, - XR_LIP_EXPRESSION_MOUTH_SAD_LEFT_HTC = 15, + XR_LIP_EXPRESSION_MOUTH_RAISER_RIGHT_HTC = 12, + XR_LIP_EXPRESSION_MOUTH_RAISER_LEFT_HTC = 13, + XR_LIP_EXPRESSION_MOUTH_STRETCHER_RIGHT_HTC = 14, + XR_LIP_EXPRESSION_MOUTH_STRETCHER_LEFT_HTC = 15, XR_LIP_EXPRESSION_CHEEK_PUFF_RIGHT_HTC = 16, XR_LIP_EXPRESSION_CHEEK_PUFF_LEFT_HTC = 17, XR_LIP_EXPRESSION_CHEEK_SUCK_HTC = 18, @@ -1238,6 +1455,10 @@ typedef enum XrLipExpressionHTC XR_LIP_EXPRESSION_TONGUE_UPLEFT_MORPH_HTC = 34, XR_LIP_EXPRESSION_TONGUE_DOWNRIGHT_MORPH_HTC = 35, XR_LIP_EXPRESSION_TONGUE_DOWNLEFT_MORPH_HTC = 36, + XR_LIP_EXPRESSION_MOUTH_SMILE_RIGHT_HTC = XR_LIP_EXPRESSION_MOUTH_RAISER_RIGHT_HTC, + XR_LIP_EXPRESSION_MOUTH_SMILE_LEFT_HTC = XR_LIP_EXPRESSION_MOUTH_RAISER_LEFT_HTC, + XR_LIP_EXPRESSION_MOUTH_SAD_RIGHT_HTC = XR_LIP_EXPRESSION_MOUTH_STRETCHER_RIGHT_HTC, + XR_LIP_EXPRESSION_MOUTH_SAD_LEFT_HTC = XR_LIP_EXPRESSION_MOUTH_STRETCHER_LEFT_HTC, XR_LIP_EXPRESSION_HTC_MAX_ENUM = 0x7fffffff, } XrLipExpressionHTC; @@ -1429,6 +1650,7 @@ typedef enum XrObjectType XR_OBJECT_TYPE_GEOMETRY_INSTANCE_FB = 1000118004, XR_OBJECT_TYPE_MARKER_DETECTOR_ML = 1000138000, XR_OBJECT_TYPE_EXPORTED_LOCALIZATION_MAP_ML = 1000139000, + XR_OBJECT_TYPE_SPATIAL_ANCHORS_STORAGE_ML = 1000141000, XR_OBJECT_TYPE_SPATIAL_ANCHOR_STORE_CONNECTION_MSFT = 1000142000, XR_OBJECT_TYPE_FACE_TRACKER_FB = 1000201000, XR_OBJECT_TYPE_EYE_TRACKER_FB = 1000202000, @@ -1439,7 +1661,14 @@ typedef enum XrObjectType XR_OBJECT_TYPE_ENVIRONMENT_DEPTH_PROVIDER_META = 1000291000, XR_OBJECT_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_META = 1000291001, XR_OBJECT_TYPE_PASSTHROUGH_HTC = 1000317000, + XR_OBJECT_TYPE_BODY_TRACKER_HTC = 1000320000, + XR_OBJECT_TYPE_BODY_TRACKER_BD = 1000385000, + XR_OBJECT_TYPE_SENSE_DATA_PROVIDER_BD = 1000389000, + XR_OBJECT_TYPE_SENSE_DATA_SNAPSHOT_BD = 1000389001, + XR_OBJECT_TYPE_ANCHOR_BD = 1000389002, XR_OBJECT_TYPE_PLANE_DETECTOR_EXT = 1000429000, + XR_OBJECT_TYPE_WORLD_MESH_DETECTOR_ML = 1000474000, + XR_OBJECT_TYPE_FACIAL_EXPRESSION_CLIENT_ML = 1000482000, XR_OBJECT_TYPE_MAX_ENUM = 0x7fffffff, } XrObjectType; @@ -1529,6 +1758,12 @@ typedef enum XrPerformanceMetricsCounterUnitMETA XR_PERFORMANCE_METRICS_COUNTER_UNIT_META_MAX_ENUM = 0x7fffffff, } XrPerformanceMetricsCounterUnitMETA; +typedef enum XrPersistenceLocationBD +{ + XR_PERSISTENCE_LOCATION_LOCAL_BD = 0, + XR_PERSISTENCE_LOCATION_BD_MAX_ENUM = 0x7fffffff, +} XrPersistenceLocationBD; + typedef enum XrPlaneDetectionStateEXT { XR_PLANE_DETECTION_STATE_NONE_EXT = 0, @@ -1597,10 +1832,27 @@ typedef enum XrResult { XR_ERROR_EXTENSION_DEPENDENCY_NOT_ENABLED = -1000710001, XR_ERROR_PERMISSION_INSUFFICIENT = -1000710000, + XR_ERROR_SPACE_GROUP_NOT_FOUND_META = -1000572002, + XR_ERROR_COLOCATION_DISCOVERY_NO_DISCOVERY_METHOD_META = -1000571002, + XR_ERROR_COLOCATION_DISCOVERY_NETWORK_FAILED_META = -1000571001, + XR_ERROR_WORLD_MESH_DETECTOR_SPACE_NOT_LOCATABLE_ML = -1000474001, + XR_ERROR_WORLD_MESH_DETECTOR_PERMISSION_DENIED_ML = -1000474000, + XR_ERROR_SYSTEM_NOTIFICATION_INCOMPATIBLE_SKU_ML = -1000473001, + XR_ERROR_SYSTEM_NOTIFICATION_PERMISSION_DENIED_ML = -1000473000, XR_ERROR_FUTURE_INVALID_EXT = -1000469002, XR_ERROR_FUTURE_PENDING_EXT = -1000469001, XR_ERROR_PLANE_DETECTION_PERMISSION_DENIED_EXT = -1000429001, XR_ERROR_SPACE_NOT_LOCATABLE_EXT = -1000429000, + XR_ERROR_SCENE_CAPTURE_FAILURE_BD = -1000392000, + XR_ERROR_SPATIAL_ANCHOR_SHARING_MAP_INSUFFICIENT_BD = -1000391004, + XR_ERROR_SPATIAL_ANCHOR_SHARING_LOCALIZATION_FAIL_BD = -1000391003, + XR_ERROR_SPATIAL_ANCHOR_SHARING_NETWORK_FAILURE_BD = -1000391002, + XR_ERROR_SPATIAL_ANCHOR_SHARING_AUTHENTICATION_FAILURE_BD = -1000391001, + XR_ERROR_SPATIAL_ANCHOR_SHARING_NETWORK_TIMEOUT_BD = -1000391000, + XR_ERROR_SPATIAL_ANCHOR_NOT_FOUND_BD = -1000390000, + XR_ERROR_ANCHOR_NOT_SUPPORTED_FOR_ENTITY_BD = -1000389002, + XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD = -1000389001, + XR_ERROR_SPATIAL_ENTITY_ID_INVALID_BD = -1000389000, XR_ERROR_NOT_AN_ANCHOR_HTC = -1000319000, XR_ERROR_HINT_ALREADY_SET_QCOM = -1000306000, XR_ERROR_PASSTHROUGH_COLOR_LUT_BUFFER_SIZE_MISMATCH_META = -1000266000, @@ -1611,6 +1863,11 @@ typedef enum XrResult XR_ERROR_SPACE_MAPPING_INSUFFICIENT_FB = -1000169000, XR_ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT = -1000142002, XR_ERROR_SPATIAL_ANCHOR_NAME_NOT_FOUND_MSFT = -1000142001, + XR_ERROR_SPATIAL_ANCHORS_ANCHOR_NOT_FOUND_ML = -1000141000, + XR_ERROR_SPATIAL_ANCHORS_SPACE_NOT_LOCATABLE_ML = -1000140003, + XR_ERROR_SPATIAL_ANCHORS_OUT_OF_MAP_BOUNDS_ML = -1000140002, + XR_ERROR_SPATIAL_ANCHORS_NOT_LOCALIZED_ML = -1000140001, + XR_ERROR_SPATIAL_ANCHORS_PERMISSION_DENIED_ML = -1000140000, XR_ERROR_LOCALIZATION_MAP_CANNOT_EXPORT_CLOUD_MAP_ML = -1000139006, XR_ERROR_LOCALIZATION_MAP_ALREADY_EXISTS_ML = -1000139005, XR_ERROR_LOCALIZATION_MAP_PERMISSION_DENIED_ML = -1000139004, @@ -1706,6 +1963,9 @@ typedef enum XrResult XR_RENDER_MODEL_UNAVAILABLE_FB = 1000119020, XR_SCENE_MARKER_DATA_NOT_STRING_MSFT = 1000147000, XR_ENVIRONMENT_DEPTH_NOT_AVAILABLE_META = 1000291000, + XR_ERROR_FACIAL_EXPRESSION_PERMISSION_DENIED_ML = 1000482000, + XR_COLOCATION_DISCOVERY_ALREADY_ADVERTISING_META = 1000571003, + XR_COLOCATION_DISCOVERY_ALREADY_DISCOVERING_META = 1000571004, XR_ERROR_EXTENSION_DEPENDENCY_NOT_ENABLED_KHR = XR_ERROR_EXTENSION_DEPENDENCY_NOT_ENABLED, XR_ERROR_PERMISSION_INSUFFICIENT_KHR = XR_ERROR_PERMISSION_INSUFFICIENT, XR_RESULT_MAX_ENUM = 0x7fffffff, @@ -1784,6 +2044,36 @@ typedef enum XrScenePlaneAlignmentTypeMSFT XR_SCENE_PLANE_ALIGNMENT_TYPE_MSFT_MAX_ENUM = 0x7fffffff, } XrScenePlaneAlignmentTypeMSFT; +typedef enum XrSemanticLabelBD +{ + XR_SEMANTIC_LABEL_UNKNOWN_BD = 0, + XR_SEMANTIC_LABEL_FLOOR_BD = 1, + XR_SEMANTIC_LABEL_CEILING_BD = 2, + XR_SEMANTIC_LABEL_WALL_BD = 3, + XR_SEMANTIC_LABEL_DOOR_BD = 4, + XR_SEMANTIC_LABEL_WINDOW_BD = 5, + XR_SEMANTIC_LABEL_OPENING_BD = 6, + XR_SEMANTIC_LABEL_TABLE_BD = 7, + XR_SEMANTIC_LABEL_SOFA_BD = 8, + XR_SEMANTIC_LABEL_CHAIR_BD = 9, + XR_SEMANTIC_LABEL_HUMAN_BD = 10, + XR_SEMANTIC_LABEL_BEAM_BD = 11, + XR_SEMANTIC_LABEL_COLUMN_BD = 12, + XR_SEMANTIC_LABEL_CURTAIN_BD = 13, + XR_SEMANTIC_LABEL_CABINET_BD = 14, + XR_SEMANTIC_LABEL_BED_BD = 15, + XR_SEMANTIC_LABEL_PLANT_BD = 16, + XR_SEMANTIC_LABEL_SCREEN_BD = 17, + XR_SEMANTIC_LABEL_VIRTUAL_WALL_BD = 18, + XR_SEMANTIC_LABEL_REFRIGERATOR_BD = 19, + XR_SEMANTIC_LABEL_WASHING_MACHINE_BD = 20, + XR_SEMANTIC_LABEL_AIR_CONDITIONER_BD = 21, + XR_SEMANTIC_LABEL_LAMP_BD = 22, + XR_SEMANTIC_LABEL_WALL_ART_BD = 23, + XR_SEMANTIC_LABEL_STAIRWAY_BD = 24, + XR_SEMANTIC_LABEL_BD_MAX_ENUM = 0x7fffffff, +} XrSemanticLabelBD; + typedef enum XrSemanticLabelsSupportFlagBitsFB { XR_SEMANTIC_LABELS_SUPPORT_MULTIPLE_SEMANTIC_LABELS_BIT_FB = 0x00000001, @@ -1792,6 +2082,22 @@ typedef enum XrSemanticLabelsSupportFlagBitsFB XR_SEMANTIC_LABELS_SUPPORT_FLAG_BITS_FB_MAX_ENUM = 0x7fffffff, } XrSemanticLabelsSupportFlagBitsFB; +typedef enum XrSenseDataProviderStateBD +{ + XR_SENSE_DATA_PROVIDER_STATE_INITIALIZED_BD = 0, + XR_SENSE_DATA_PROVIDER_STATE_RUNNING_BD = 1, + XR_SENSE_DATA_PROVIDER_STATE_STOPPED_BD = 2, + XR_SENSE_DATA_PROVIDER_STATE_BD_MAX_ENUM = 0x7fffffff, +} XrSenseDataProviderStateBD; + +typedef enum XrSenseDataProviderTypeBD +{ + XR_SENSE_DATA_PROVIDER_TYPE_ANCHOR_BD = 1000390000, + XR_SENSE_DATA_PROVIDER_TYPE_SCENE_BD = 1000392000, + XR_SENSE_DATA_PROVIDER_TYPE_MESH_BD = 1000393000, + XR_SENSE_DATA_PROVIDER_TYPE_BD_MAX_ENUM = 0x7fffffff, +} XrSenseDataProviderTypeBD; + typedef enum XrSessionCreateFlagBits { XR_SESSION_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, @@ -1862,6 +2168,25 @@ typedef enum XrSpaceVelocityFlagBits XR_SPACE_VELOCITY_FLAG_BITS_MAX_ENUM = 0x7fffffff, } XrSpaceVelocityFlagBits; +typedef enum XrSpatialAnchorConfidenceML +{ + XR_SPATIAL_ANCHOR_CONFIDENCE_LOW_ML = 0, + XR_SPATIAL_ANCHOR_CONFIDENCE_MEDIUM_ML = 1, + XR_SPATIAL_ANCHOR_CONFIDENCE_HIGH_ML = 2, + XR_SPATIAL_ANCHOR_CONFIDENCE_ML_MAX_ENUM = 0x7fffffff, +} XrSpatialAnchorConfidenceML; + +typedef enum XrSpatialEntityComponentTypeBD +{ + XR_SPATIAL_ENTITY_COMPONENT_TYPE_LOCATION_BD = 0, + XR_SPATIAL_ENTITY_COMPONENT_TYPE_SEMANTIC_BD = 1, + XR_SPATIAL_ENTITY_COMPONENT_TYPE_BOUNDING_BOX_2D_BD = 2, + XR_SPATIAL_ENTITY_COMPONENT_TYPE_POLYGON_BD = 3, + XR_SPATIAL_ENTITY_COMPONENT_TYPE_BOUNDING_BOX_3D_BD = 4, + XR_SPATIAL_ENTITY_COMPONENT_TYPE_TRIANGLE_MESH_BD = 5, + XR_SPATIAL_ENTITY_COMPONENT_TYPE_BD_MAX_ENUM = 0x7fffffff, +} XrSpatialEntityComponentTypeBD; + typedef enum XrSpatialGraphNodeTypeMSFT { XR_SPATIAL_GRAPH_NODE_TYPE_STATIC_MSFT = 1, @@ -1869,6 +2194,21 @@ typedef enum XrSpatialGraphNodeTypeMSFT XR_SPATIAL_GRAPH_NODE_TYPE_MSFT_MAX_ENUM = 0x7fffffff, } XrSpatialGraphNodeTypeMSFT; +typedef enum XrSpatialMeshConfigFlagBitsBD +{ + XR_SPATIAL_MESH_CONFIG_SEMANTIC_BIT_BD = 0x00000001, + XR_SPATIAL_MESH_CONFIG_ALIGN_SEMANTIC_WITH_VERTEX_BIT_BD = 0x00000002, + XR_SPATIAL_MESH_CONFIG_FLAG_BITS_BD_MAX_ENUM = 0x7fffffff, +} XrSpatialMeshConfigFlagBitsBD; + +typedef enum XrSpatialMeshLodBD +{ + XR_SPATIAL_MESH_LOD_COARSE_BD = 0, + XR_SPATIAL_MESH_LOD_MEDIUM_BD = 1, + XR_SPATIAL_MESH_LOD_FINE_BD = 2, + XR_SPATIAL_MESH_LOD_BD_MAX_ENUM = 0x7fffffff, +} XrSpatialMeshLodBD; + typedef enum XrStructureType { XR_TYPE_UNKNOWN = 0, @@ -2084,6 +2424,22 @@ typedef enum XrStructureType XR_TYPE_MAP_LOCALIZATION_REQUEST_INFO_ML = 1000139002, XR_TYPE_LOCALIZATION_MAP_IMPORT_INFO_ML = 1000139003, XR_TYPE_LOCALIZATION_ENABLE_EVENTS_INFO_ML = 1000139004, + XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_POSE_ML = 1000140000, + XR_TYPE_CREATE_SPATIAL_ANCHORS_COMPLETION_ML = 1000140001, + XR_TYPE_SPATIAL_ANCHOR_STATE_ML = 1000140002, + XR_TYPE_SPATIAL_ANCHORS_CREATE_STORAGE_INFO_ML = 1000141000, + XR_TYPE_SPATIAL_ANCHORS_QUERY_INFO_RADIUS_ML = 1000141001, + XR_TYPE_SPATIAL_ANCHORS_QUERY_COMPLETION_ML = 1000141002, + XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_UUIDS_ML = 1000141003, + XR_TYPE_SPATIAL_ANCHORS_PUBLISH_INFO_ML = 1000141004, + XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_ML = 1000141005, + XR_TYPE_SPATIAL_ANCHORS_DELETE_INFO_ML = 1000141006, + XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_ML = 1000141007, + XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_INFO_ML = 1000141008, + XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_ML = 1000141009, + XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_DETAILS_ML = 1000141010, + XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_DETAILS_ML = 1000141011, + XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_DETAILS_ML = 1000141012, XR_TYPE_SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT = 1000142000, XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT = 1000142001, XR_TYPE_SCENE_MARKERS_MSFT = 1000147000, @@ -2130,6 +2486,8 @@ typedef enum XrStructureType XR_TYPE_COMPOSITION_LAYER_SETTINGS_FB = 1000204000, XR_TYPE_HAPTIC_PCM_VIBRATION_FB = 1000209001, XR_TYPE_DEVICE_PCM_SAMPLE_RATE_STATE_FB = 1000209002, + XR_TYPE_FRAME_SYNTHESIS_INFO_EXT = 1000211000, + XR_TYPE_FRAME_SYNTHESIS_CONFIG_VIEW_EXT = 1000211001, XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_FB = 1000212000, XR_TYPE_LOCAL_DIMMING_FRAME_END_INFO_META = 1000216000, XR_TYPE_PASSTHROUGH_PREFERENCES_META = 1000217000, @@ -2165,10 +2523,14 @@ typedef enum XrStructureType XR_TYPE_PASSTHROUGH_COLOR_MAP_INTERPOLATED_LUT_META = 1000266101, XR_TYPE_SPACE_TRIANGLE_MESH_GET_INFO_META = 1000269001, XR_TYPE_SPACE_TRIANGLE_MESH_META = 1000269002, + XR_TYPE_EVENT_DATA_PASSTHROUGH_LAYER_RESUMED_META = 1000282000, XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES2_FB = 1000287013, XR_TYPE_FACE_TRACKER_CREATE_INFO2_FB = 1000287014, XR_TYPE_FACE_EXPRESSION_INFO2_FB = 1000287015, XR_TYPE_FACE_EXPRESSION_WEIGHTS2_FB = 1000287016, + XR_TYPE_SYSTEM_SPATIAL_ENTITY_SHARING_PROPERTIES_META = 1000290000, + XR_TYPE_SHARE_SPACES_INFO_META = 1000290001, + XR_TYPE_EVENT_DATA_SHARE_SPACES_COMPLETE_META = 1000290002, XR_TYPE_ENVIRONMENT_DEPTH_PROVIDER_CREATE_INFO_META = 1000291000, XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_CREATE_INFO_META = 1000291001, XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_STATE_META = 1000291002, @@ -2183,9 +2545,52 @@ typedef enum XrStructureType XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_HTC = 1000317004, XR_TYPE_SYSTEM_ANCHOR_PROPERTIES_HTC = 1000319000, XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_HTC = 1000319001, + XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_HTC = 1000320000, + XR_TYPE_BODY_TRACKER_CREATE_INFO_HTC = 1000320001, + XR_TYPE_BODY_JOINTS_LOCATE_INFO_HTC = 1000320002, + XR_TYPE_BODY_JOINT_LOCATIONS_HTC = 1000320003, + XR_TYPE_BODY_SKELETON_HTC = 1000320004, XR_TYPE_ACTIVE_ACTION_SET_PRIORITIES_EXT = 1000373000, XR_TYPE_SYSTEM_FORCE_FEEDBACK_CURL_PROPERTIES_MNDX = 1000375000, XR_TYPE_FORCE_FEEDBACK_CURL_APPLY_LOCATIONS_MNDX = 1000375001, + XR_TYPE_BODY_TRACKER_CREATE_INFO_BD = 1000385001, + XR_TYPE_BODY_JOINTS_LOCATE_INFO_BD = 1000385002, + XR_TYPE_BODY_JOINT_LOCATIONS_BD = 1000385003, + XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_BD = 1000385004, + XR_TYPE_SYSTEM_SPATIAL_SENSING_PROPERTIES_BD = 1000389000, + XR_TYPE_SPATIAL_ENTITY_COMPONENT_GET_INFO_BD = 1000389001, + XR_TYPE_SPATIAL_ENTITY_LOCATION_GET_INFO_BD = 1000389002, + XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_LOCATION_BD = 1000389003, + XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_SEMANTIC_BD = 1000389004, + XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_BOUNDING_BOX_2D_BD = 1000389005, + XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_POLYGON_BD = 1000389006, + XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_BOUNDING_BOX_3D_BD = 1000389007, + XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_TRIANGLE_MESH_BD = 1000389008, + XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_BD = 1000389009, + XR_TYPE_SENSE_DATA_PROVIDER_START_INFO_BD = 1000389010, + XR_TYPE_EVENT_DATA_SENSE_DATA_PROVIDER_STATE_CHANGED_BD = 1000389011, + XR_TYPE_EVENT_DATA_SENSE_DATA_UPDATED_BD = 1000389012, + XR_TYPE_SENSE_DATA_QUERY_INFO_BD = 1000389013, + XR_TYPE_SENSE_DATA_QUERY_COMPLETION_BD = 1000389014, + XR_TYPE_SENSE_DATA_FILTER_UUID_BD = 1000389015, + XR_TYPE_SENSE_DATA_FILTER_SEMANTIC_BD = 1000389016, + XR_TYPE_QUERIED_SENSE_DATA_GET_INFO_BD = 1000389017, + XR_TYPE_QUERIED_SENSE_DATA_BD = 1000389018, + XR_TYPE_SPATIAL_ENTITY_STATE_BD = 1000389019, + XR_TYPE_SPATIAL_ENTITY_ANCHOR_CREATE_INFO_BD = 1000389020, + XR_TYPE_ANCHOR_SPACE_CREATE_INFO_BD = 1000389021, + XR_TYPE_SYSTEM_SPATIAL_ANCHOR_PROPERTIES_BD = 1000390000, + XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_BD = 1000390001, + XR_TYPE_SPATIAL_ANCHOR_CREATE_COMPLETION_BD = 1000390002, + XR_TYPE_SPATIAL_ANCHOR_PERSIST_INFO_BD = 1000390003, + XR_TYPE_SPATIAL_ANCHOR_UNPERSIST_INFO_BD = 1000390004, + XR_TYPE_SYSTEM_SPATIAL_ANCHOR_SHARING_PROPERTIES_BD = 1000391000, + XR_TYPE_SPATIAL_ANCHOR_SHARE_INFO_BD = 1000391001, + XR_TYPE_SHARED_SPATIAL_ANCHOR_DOWNLOAD_INFO_BD = 1000391002, + XR_TYPE_SYSTEM_SPATIAL_SCENE_PROPERTIES_BD = 1000392000, + XR_TYPE_SCENE_CAPTURE_INFO_BD = 1000392001, + XR_TYPE_SYSTEM_SPATIAL_MESH_PROPERTIES_BD = 1000393000, + XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_SPATIAL_MESH_BD = 1000393001, XR_TYPE_HAND_TRACKING_DATA_SOURCE_INFO_EXT = 1000428000, XR_TYPE_HAND_TRACKING_DATA_SOURCE_STATE_EXT = 1000428001, XR_TYPE_PLANE_DETECTOR_CREATE_INFO_EXT = 1000429001, @@ -2207,6 +2612,38 @@ typedef enum XrStructureType XR_TYPE_EVENT_DATA_HEADSET_FIT_CHANGED_ML = 1000472000, XR_TYPE_EVENT_DATA_EYE_CALIBRATION_CHANGED_ML = 1000472001, XR_TYPE_USER_CALIBRATION_ENABLE_EVENTS_INFO_ML = 1000472002, + XR_TYPE_SYSTEM_NOTIFICATIONS_SET_INFO_ML = 1000473000, + XR_TYPE_WORLD_MESH_DETECTOR_CREATE_INFO_ML = 1000474001, + XR_TYPE_WORLD_MESH_STATE_REQUEST_INFO_ML = 1000474002, + XR_TYPE_WORLD_MESH_BLOCK_STATE_ML = 1000474003, + XR_TYPE_WORLD_MESH_STATE_REQUEST_COMPLETION_ML = 1000474004, + XR_TYPE_WORLD_MESH_BUFFER_RECOMMENDED_SIZE_INFO_ML = 1000474005, + XR_TYPE_WORLD_MESH_BUFFER_SIZE_ML = 1000474006, + XR_TYPE_WORLD_MESH_BUFFER_ML = 1000474007, + XR_TYPE_WORLD_MESH_BLOCK_REQUEST_ML = 1000474008, + XR_TYPE_WORLD_MESH_GET_INFO_ML = 1000474009, + XR_TYPE_WORLD_MESH_BLOCK_ML = 1000474010, + XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_ML = 1000474011, + XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_INFO_ML = 1000474012, + XR_TYPE_SYSTEM_FACIAL_EXPRESSION_PROPERTIES_ML = 1000482004, + XR_TYPE_FACIAL_EXPRESSION_CLIENT_CREATE_INFO_ML = 1000482005, + XR_TYPE_FACIAL_EXPRESSION_BLEND_SHAPE_GET_INFO_ML = 1000482006, + XR_TYPE_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_ML = 1000482007, + XR_TYPE_COLOCATION_DISCOVERY_START_INFO_META = 1000571010, + XR_TYPE_COLOCATION_DISCOVERY_STOP_INFO_META = 1000571011, + XR_TYPE_COLOCATION_ADVERTISEMENT_START_INFO_META = 1000571012, + XR_TYPE_COLOCATION_ADVERTISEMENT_STOP_INFO_META = 1000571013, + XR_TYPE_EVENT_DATA_START_COLOCATION_ADVERTISEMENT_COMPLETE_META = 1000571020, + XR_TYPE_EVENT_DATA_STOP_COLOCATION_ADVERTISEMENT_COMPLETE_META = 1000571021, + XR_TYPE_EVENT_DATA_COLOCATION_ADVERTISEMENT_COMPLETE_META = 1000571022, + XR_TYPE_EVENT_DATA_START_COLOCATION_DISCOVERY_COMPLETE_META = 1000571023, + XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_RESULT_META = 1000571024, + XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_COMPLETE_META = 1000571025, + XR_TYPE_EVENT_DATA_STOP_COLOCATION_DISCOVERY_COMPLETE_META = 1000571026, + XR_TYPE_SYSTEM_COLOCATION_DISCOVERY_PROPERTIES_META = 1000571030, + XR_TYPE_SHARE_SPACES_RECIPIENT_GROUPS_META = 1000572000, + XR_TYPE_SPACE_GROUP_UUID_FILTER_INFO_META = 1000572001, + XR_TYPE_SYSTEM_SPATIAL_ENTITY_GROUP_SHARING_PROPERTIES_META = 1000572100, XR_TYPE_GRAPHICS_BINDING_VULKAN2_KHR = XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR, XR_TYPE_SWAPCHAIN_IMAGE_VULKAN2_KHR = XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR, XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN2_KHR = XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR, @@ -2332,6 +2769,43 @@ typedef enum XrWindingOrderFB XR_WINDING_ORDER_FB_MAX_ENUM = 0x7fffffff, } XrWindingOrderFB; +typedef enum XrWorldMeshBlockResultML +{ + XR_WORLD_MESH_BLOCK_RESULT_SUCCESS_ML = 0, + XR_WORLD_MESH_BLOCK_RESULT_FAILED_ML = 1, + XR_WORLD_MESH_BLOCK_RESULT_PENDING_ML = 2, + XR_WORLD_MESH_BLOCK_RESULT_PARTIAL_UPDATE_ML = 3, + XR_WORLD_MESH_BLOCK_RESULT_ML_MAX_ENUM = 0x7fffffff, +} XrWorldMeshBlockResultML; + +typedef enum XrWorldMeshBlockStatusML +{ + XR_WORLD_MESH_BLOCK_STATUS_NEW_ML = 0, + XR_WORLD_MESH_BLOCK_STATUS_UPDATED_ML = 1, + XR_WORLD_MESH_BLOCK_STATUS_DELETED_ML = 2, + XR_WORLD_MESH_BLOCK_STATUS_UNCHANGED_ML = 3, + XR_WORLD_MESH_BLOCK_STATUS_ML_MAX_ENUM = 0x7fffffff, +} XrWorldMeshBlockStatusML; + +typedef enum XrWorldMeshDetectorFlagBitsML +{ + XR_WORLD_MESH_DETECTOR_POINT_CLOUD_BIT_ML = 0x00000001, + XR_WORLD_MESH_DETECTOR_COMPUTE_NORMALS_BIT_ML = 0x00000002, + XR_WORLD_MESH_DETECTOR_COMPUTE_CONFIDENCE_BIT_ML = 0x00000004, + XR_WORLD_MESH_DETECTOR_PLANARIZE_BIT_ML = 0x00000008, + XR_WORLD_MESH_DETECTOR_REMOVE_MESH_SKIRT_BIT_ML = 0x00000010, + XR_WORLD_MESH_DETECTOR_INDEX_ORDER_CW_BIT_ML = 0x00000020, + XR_WORLD_MESH_DETECTOR_FLAG_BITS_ML_MAX_ENUM = 0x7fffffff, +} XrWorldMeshDetectorFlagBitsML; + +typedef enum XrWorldMeshDetectorLodML +{ + XR_WORLD_MESH_DETECTOR_LOD_MINIMUM_ML = 0, + XR_WORLD_MESH_DETECTOR_LOD_MEDIUM_ML = 1, + XR_WORLD_MESH_DETECTOR_LOD_MAXIMUM_ML = 2, + XR_WORLD_MESH_DETECTOR_LOD_ML_MAX_ENUM = 0x7fffffff, +} XrWorldMeshDetectorLodML; + typedef void (XRAPI_PTR * PFN_xrVoidFunction)( void); typedef XrResult (XRAPI_PTR * PFN_xrGetInstanceProcAddr)( @@ -2474,6 +2948,14 @@ typedef struct XrBindingModificationsKHR const XrBindingModificationBaseHeaderKHR * const*bindingModifications; } XrBindingModificationsKHR; +typedef struct XrBodyJointsLocateInfoBD +{ + XrStructureType type; + const void *next; + XrSpace baseSpace; + XrTime time; +} XrBodyJointsLocateInfoBD; + typedef struct XrBodyJointsLocateInfoFB { XrStructureType type; @@ -2482,6 +2964,21 @@ typedef struct XrBodyJointsLocateInfoFB XrTime time; } XrBodyJointsLocateInfoFB; +typedef struct XrBodyJointsLocateInfoHTC +{ + XrStructureType type; + const void *next; + XrSpace baseSpace; + XrTime time; +} XrBodyJointsLocateInfoHTC; + +typedef struct XrBodyTrackerCreateInfoBD +{ + XrStructureType type; + const void *next; + XrBodyJointSetBD jointSet; +} XrBodyTrackerCreateInfoBD; + typedef struct XrBodyTrackerCreateInfoFB { XrStructureType type; @@ -2489,6 +2986,13 @@ typedef struct XrBodyTrackerCreateInfoFB XrBodyJointSetFB bodyJointSet; } XrBodyTrackerCreateInfoFB; +typedef struct XrBodyTrackerCreateInfoHTC +{ + XrStructureType type; + const void *next; + XrBodyJointSetHTC bodyJointSet; +} XrBodyTrackerCreateInfoHTC; + typedef struct XrBoundSourcesForActionEnumerateInfo { XrStructureType type; @@ -2496,6 +3000,32 @@ typedef struct XrBoundSourcesForActionEnumerateInfo XrAction action; } XrBoundSourcesForActionEnumerateInfo; +typedef struct XrColocationAdvertisementStartInfoMETA +{ + XrStructureType type; + const void *next; + uint32_t bufferSize; + uint8_t *buffer; +} XrColocationAdvertisementStartInfoMETA; + +typedef struct XrColocationAdvertisementStopInfoMETA +{ + XrStructureType type; + const void *next; +} XrColocationAdvertisementStopInfoMETA; + +typedef struct XrColocationDiscoveryStartInfoMETA +{ + XrStructureType type; + const void *next; +} XrColocationDiscoveryStartInfoMETA; + +typedef struct XrColocationDiscoveryStopInfoMETA +{ + XrStructureType type; + const void *next; +} XrColocationDiscoveryStopInfoMETA; + typedef struct XrColor3f { float r; @@ -2615,6 +3145,15 @@ typedef struct XrControllerModelPropertiesMSFT XrControllerModelNodePropertiesMSFT *nodeProperties; } XrControllerModelPropertiesMSFT; +typedef struct XrCreateSpatialAnchorsCompletionML +{ + XrStructureType type; + void *next; + XrResult futureResult; + uint32_t spaceCount; + XrSpace *spaces; +} XrCreateSpatialAnchorsCompletionML; + typedef struct XrDeserializeSceneFragmentMSFT { uint32_t bufferSize; @@ -2687,6 +3226,22 @@ typedef struct XrEventDataBuffer uint8_t varying[4000]; } XrEventDataBuffer; +typedef struct XrEventDataColocationAdvertisementCompleteMETA +{ + XrStructureType type; + const void *next; + XrAsyncRequestIdFB advertisementRequestId; + XrResult result; +} XrEventDataColocationAdvertisementCompleteMETA; + +typedef struct XrEventDataColocationDiscoveryCompleteMETA +{ + XrStructureType type; + const void *next; + XrAsyncRequestIdFB discoveryRequestId; + XrResult result; +} XrEventDataColocationDiscoveryCompleteMETA; + typedef struct XrEventDataDisplayRefreshRateChangedFB { XrStructureType type; @@ -2749,6 +3304,13 @@ typedef struct XrEventDataMarkerTrackingUpdateVARJO XrTime time; } XrEventDataMarkerTrackingUpdateVARJO; +typedef struct XrEventDataPassthroughLayerResumedMETA +{ + XrStructureType type; + const void *next; + XrPassthroughLayerFB layer; +} XrEventDataPassthroughLayerResumedMETA; + typedef struct XrEventDataPassthroughStateChangedFB { XrStructureType type; @@ -2774,6 +3336,21 @@ typedef struct XrEventDataSceneCaptureCompleteFB XrResult result; } XrEventDataSceneCaptureCompleteFB; +typedef struct XrEventDataSenseDataProviderStateChangedBD +{ + XrStructureType type; + const void *next; + XrSenseDataProviderBD provider; + XrSenseDataProviderStateBD newState; +} XrEventDataSenseDataProviderStateChangedBD; + +typedef struct XrEventDataSenseDataUpdatedBD +{ + XrStructureType type; + const void *next; + XrSenseDataProviderBD provider; +} XrEventDataSenseDataUpdatedBD; + typedef struct XrEventDataSessionStateChanged { XrStructureType type; @@ -2783,6 +3360,14 @@ typedef struct XrEventDataSessionStateChanged XrTime time; } XrEventDataSessionStateChanged; +typedef struct XrEventDataShareSpacesCompleteMETA +{ + XrStructureType type; + const void *next; + XrAsyncRequestIdFB requestId; + XrResult result; +} XrEventDataShareSpacesCompleteMETA; + typedef struct XrEventDataSpaceListSaveCompleteFB { XrStructureType type; @@ -2814,6 +3399,30 @@ typedef struct XrEventDataSpaceShareCompleteFB XrResult result; } XrEventDataSpaceShareCompleteFB; +typedef struct XrEventDataStartColocationDiscoveryCompleteMETA +{ + XrStructureType type; + const void *next; + XrAsyncRequestIdFB discoveryRequestId; + XrResult result; +} XrEventDataStartColocationDiscoveryCompleteMETA; + +typedef struct XrEventDataStopColocationAdvertisementCompleteMETA +{ + XrStructureType type; + const void *next; + XrAsyncRequestIdFB requestId; + XrResult result; +} XrEventDataStopColocationAdvertisementCompleteMETA; + +typedef struct XrEventDataStopColocationDiscoveryCompleteMETA +{ + XrStructureType type; + const void *next; + XrAsyncRequestIdFB requestId; + XrResult result; +} XrEventDataStopColocationDiscoveryCompleteMETA; + typedef struct XrEventDataUserPresenceChangedEXT { XrStructureType type; @@ -2982,6 +3591,30 @@ typedef struct XrFaceTrackerCreateInfoFB XrFaceExpressionSetFB faceExpressionSet; } XrFaceTrackerCreateInfoFB; +typedef struct XrFacialExpressionBlendShapeGetInfoML +{ + XrStructureType type; + const void *next; +} XrFacialExpressionBlendShapeGetInfoML; + +typedef struct XrFacialExpressionBlendShapePropertiesML +{ + XrStructureType type; + void *next; + XrFacialBlendShapeML requestedFacialBlendShape; + float weight; + XrFacialExpressionBlendShapePropertiesFlagsML WINE_XR_ALIGN(8) flags; + XrTime time; +} XrFacialExpressionBlendShapePropertiesML; + +typedef struct XrFacialExpressionClientCreateInfoML +{ + XrStructureType type; + const void *next; + uint32_t requestedCount; + const XrFacialBlendShapeML *requestedFacialBlendShapes; +} XrFacialExpressionClientCreateInfoML; + typedef struct XrFacialExpressionsHTC { XrStructureType type; @@ -3083,6 +3716,14 @@ typedef struct XrFrameState XrBool32 shouldRender; } XrFrameState; +typedef struct XrFrameSynthesisConfigViewEXT +{ + XrStructureType type; + void *next; + uint32_t recommendedMotionVectorImageRectWidth; + uint32_t recommendedMotionVectorImageRectHeight; +} XrFrameSynthesisConfigViewEXT; + typedef struct XrFrameWaitInfo { XrStructureType type; @@ -3687,6 +4328,12 @@ typedef struct XrQuaternionf float w; } XrQuaternionf; +typedef struct XrQueriedSenseDataGetInfoBD +{ + XrStructureType type; + const void *next; +} XrQueriedSenseDataGetInfoBD; + typedef struct XrRecommendedLayerResolutionGetInfoMETA { XrStructureType type; @@ -3762,6 +4409,12 @@ typedef struct XrRenderModelPropertiesFB XrRenderModelFlagsFB WINE_XR_ALIGN(8) flags; } XrRenderModelPropertiesFB; +typedef struct XrSceneCaptureInfoBD +{ + XrStructureType type; + const void *next; +} XrSceneCaptureInfoBD; + typedef struct XrSceneCaptureRequestInfoFB { XrStructureType type; @@ -3975,6 +4628,49 @@ typedef struct XrSemanticLabelsSupportInfoFB const char *recognizedLabels; } XrSemanticLabelsSupportInfoFB; +typedef struct XrSenseDataFilterSemanticBD +{ + XrStructureType type; + const void *next; + uint32_t labelCount; + const XrSemanticLabelBD *labels; +} XrSenseDataFilterSemanticBD; + +typedef struct XrSenseDataProviderCreateInfoBD +{ + XrStructureType type; + const void *next; + XrSenseDataProviderTypeBD providerType; +} XrSenseDataProviderCreateInfoBD; + +typedef struct XrSenseDataProviderCreateInfoSpatialMeshBD +{ + XrStructureType type; + const void *next; + XrSpatialMeshConfigFlagsBD WINE_XR_ALIGN(8) configFlags; + XrSpatialMeshLodBD lod; +} XrSenseDataProviderCreateInfoSpatialMeshBD; + +typedef struct XrSenseDataProviderStartInfoBD +{ + XrStructureType type; + const void *next; +} XrSenseDataProviderStartInfoBD; + +typedef struct XrSenseDataQueryCompletionBD +{ + XrStructureType type; + void *next; + XrResult futureResult; + XrSenseDataSnapshotBD snapshot; +} XrSenseDataQueryCompletionBD; + +typedef struct XrSenseDataQueryInfoBD +{ + XrStructureType type; + const void *next; +} XrSenseDataQueryInfoBD; + typedef struct XrSessionActionSetsAttachInfo { XrStructureType type; @@ -4006,6 +4702,12 @@ typedef struct XrSessionCreateInfoOverlayEXTX uint32_t sessionLayersPlacement; } XrSessionCreateInfoOverlayEXTX; +typedef struct XrShareSpacesRecipientBaseHeaderMETA +{ + XrStructureType type; + const void *next; +} XrShareSpacesRecipientBaseHeaderMETA; + typedef struct XrSpaceComponentFilterInfoFB { XrStructureType type; @@ -4125,11 +4827,127 @@ typedef struct XrSpatialAnchorNameHTC char name[XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_HTC]; } XrSpatialAnchorNameHTC; +typedef struct XrSpatialAnchorPersistInfoBD +{ + XrStructureType type; + const void *next; + XrPersistenceLocationBD location; + XrAnchorBD anchor; +} XrSpatialAnchorPersistInfoBD; + typedef struct XrSpatialAnchorPersistenceNameMSFT { char name[XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_MSFT]; } XrSpatialAnchorPersistenceNameMSFT; +typedef struct XrSpatialAnchorShareInfoBD +{ + XrStructureType type; + const void *next; + XrAnchorBD anchor; +} XrSpatialAnchorShareInfoBD; + +typedef struct XrSpatialAnchorStateML +{ + XrStructureType type; + void *next; + XrSpatialAnchorConfidenceML confidence; +} XrSpatialAnchorStateML; + +typedef struct XrSpatialAnchorUnpersistInfoBD +{ + XrStructureType type; + const void *next; + XrPersistenceLocationBD location; + XrAnchorBD anchor; +} XrSpatialAnchorUnpersistInfoBD; + +typedef struct XrSpatialAnchorsCreateInfoBaseHeaderML +{ + XrStructureType type; + const void *next; +} XrSpatialAnchorsCreateInfoBaseHeaderML; + +typedef struct XrSpatialAnchorsCreateStorageInfoML +{ + XrStructureType type; + const void *next; +} XrSpatialAnchorsCreateStorageInfoML; + +typedef struct XrSpatialAnchorsDeleteCompletionML +{ + XrStructureType type; + void *next; + XrResult futureResult; +} XrSpatialAnchorsDeleteCompletionML; + +typedef struct XrSpatialAnchorsPublishInfoML +{ + XrStructureType type; + const void *next; + uint32_t anchorCount; + const XrSpace *anchors; + uint64_t WINE_XR_ALIGN(8) expiration; +} XrSpatialAnchorsPublishInfoML; + +typedef struct XrSpatialAnchorsQueryInfoBaseHeaderML +{ + XrStructureType type; + const void *next; +} XrSpatialAnchorsQueryInfoBaseHeaderML; + +typedef struct XrSpatialAnchorsUpdateExpirationCompletionML +{ + XrStructureType type; + void *next; + XrResult futureResult; +} XrSpatialAnchorsUpdateExpirationCompletionML; + +typedef struct XrSpatialEntityAnchorCreateInfoBD +{ + XrStructureType type; + const void *next; + XrSenseDataSnapshotBD snapshot; + XrSpatialEntityIdBD entityId; +} XrSpatialEntityAnchorCreateInfoBD; + +typedef struct XrSpatialEntityComponentDataBaseHeaderBD +{ + XrStructureType type; + void *next; +} XrSpatialEntityComponentDataBaseHeaderBD; + +typedef struct XrSpatialEntityComponentDataBoundingBox2DBD +{ + XrStructureType type; + void *next; + XrRect2Df boundingBox2D; +} XrSpatialEntityComponentDataBoundingBox2DBD; + +typedef struct XrSpatialEntityComponentDataSemanticBD +{ + XrStructureType type; + void *next; + uint32_t labelCapacityInput; + uint32_t labelCountOutput; + XrSemanticLabelBD *labels; +} XrSpatialEntityComponentDataSemanticBD; + +typedef struct XrSpatialEntityComponentGetInfoBD +{ + XrStructureType type; + const void *next; + XrSpatialEntityIdBD entityId; + XrSpatialEntityComponentTypeBD componentType; +} XrSpatialEntityComponentGetInfoBD; + +typedef struct XrSpatialEntityLocationGetInfoBD +{ + XrStructureType type; + const void *next; + XrSpace baseSpace; +} XrSpatialEntityLocationGetInfoBD; + typedef struct XrSpatialGraphNodeBindingPropertiesGetInfoMSFT { XrStructureType type; @@ -4266,6 +5084,13 @@ typedef struct XrSystemAnchorPropertiesHTC XrBool32 supportsAnchor; } XrSystemAnchorPropertiesHTC; +typedef struct XrSystemBodyTrackingPropertiesBD +{ + XrStructureType type; + void *next; + XrBool32 supportsBodyTracking; +} XrSystemBodyTrackingPropertiesBD; + typedef struct XrSystemBodyTrackingPropertiesFB { XrStructureType type; @@ -4273,6 +5098,20 @@ typedef struct XrSystemBodyTrackingPropertiesFB XrBool32 supportsBodyTracking; } XrSystemBodyTrackingPropertiesFB; +typedef struct XrSystemBodyTrackingPropertiesHTC +{ + XrStructureType type; + void *next; + XrBool32 supportsBodyTracking; +} XrSystemBodyTrackingPropertiesHTC; + +typedef struct XrSystemColocationDiscoveryPropertiesMETA +{ + XrStructureType type; + void *next; + XrBool32 supportsColocationDiscovery; +} XrSystemColocationDiscoveryPropertiesMETA; + typedef struct XrSystemColorSpacePropertiesFB { XrStructureType type; @@ -4317,6 +5156,13 @@ typedef struct XrSystemFaceTrackingPropertiesFB XrBool32 supportsFaceTracking; } XrSystemFaceTrackingPropertiesFB; +typedef struct XrSystemFacialExpressionPropertiesML +{ + XrStructureType type; + void *next; + XrBool32 supportsFacialExpression; +} XrSystemFacialExpressionPropertiesML; + typedef struct XrSystemFacialTrackingPropertiesHTC { XrStructureType type; @@ -4397,6 +5243,13 @@ typedef struct XrSystemMarkerUnderstandingPropertiesML XrBool32 supportsMarkerUnderstanding; } XrSystemMarkerUnderstandingPropertiesML; +typedef struct XrSystemNotificationsSetInfoML +{ + XrStructureType type; + const void *next; + XrBool32 suppressNotifications; +} XrSystemNotificationsSetInfoML; + typedef struct XrSystemPassthroughColorLutPropertiesMETA { XrStructureType type; @@ -4440,6 +5293,27 @@ typedef struct XrSystemSpaceWarpPropertiesFB uint32_t recommendedMotionVectorImageRectHeight; } XrSystemSpaceWarpPropertiesFB; +typedef struct XrSystemSpatialAnchorPropertiesBD +{ + XrStructureType type; + void *next; + XrBool32 supportsSpatialAnchor; +} XrSystemSpatialAnchorPropertiesBD; + +typedef struct XrSystemSpatialAnchorSharingPropertiesBD +{ + XrStructureType type; + void *next; + XrBool32 supportsSpatialAnchorSharing; +} XrSystemSpatialAnchorSharingPropertiesBD; + +typedef struct XrSystemSpatialEntityGroupSharingPropertiesMETA +{ + XrStructureType type; + void *next; + XrBool32 supportsSpatialEntityGroupSharing; +} XrSystemSpatialEntityGroupSharingPropertiesMETA; + typedef struct XrSystemSpatialEntityPropertiesFB { XrStructureType type; @@ -4447,6 +5321,34 @@ typedef struct XrSystemSpatialEntityPropertiesFB XrBool32 supportsSpatialEntity; } XrSystemSpatialEntityPropertiesFB; +typedef struct XrSystemSpatialEntitySharingPropertiesMETA +{ + XrStructureType type; + void *next; + XrBool32 supportsSpatialEntitySharing; +} XrSystemSpatialEntitySharingPropertiesMETA; + +typedef struct XrSystemSpatialMeshPropertiesBD +{ + XrStructureType type; + void *next; + XrBool32 supportsSpatialMesh; +} XrSystemSpatialMeshPropertiesBD; + +typedef struct XrSystemSpatialScenePropertiesBD +{ + XrStructureType type; + void *next; + XrBool32 supportsSpatialScene; +} XrSystemSpatialScenePropertiesBD; + +typedef struct XrSystemSpatialSensingPropertiesBD +{ + XrStructureType type; + void *next; + XrBool32 supportsSpatialSensing; +} XrSystemSpatialSensingPropertiesBD; + typedef struct XrSystemTrackingProperties { XrBool32 orientationTracking; @@ -4698,6 +5600,88 @@ typedef struct XrVulkanSwapchainFormatListCreateInfoKHR const VkFormat *viewFormats; } XrVulkanSwapchainFormatListCreateInfoKHR; +typedef struct XrWorldMeshBlockML +{ + XrStructureType type; + void *next; + XrUuidEXT uuid; + XrWorldMeshBlockResultML blockResult; + XrWorldMeshDetectorLodML lod; + XrWorldMeshDetectorFlagsML WINE_XR_ALIGN(8) flags; + uint32_t indexCount; + uint16_t *indexBuffer; + uint32_t vertexCount; + XrVector3f *vertexBuffer; + uint32_t normalCount; + XrVector3f *normalBuffer; + uint32_t confidenceCount; + float *confidenceBuffer; +} XrWorldMeshBlockML; + +typedef struct XrWorldMeshBlockRequestML +{ + XrStructureType type; + void *next; + XrUuidEXT uuid; + XrWorldMeshDetectorLodML lod; +} XrWorldMeshBlockRequestML; + +typedef struct XrWorldMeshBufferML +{ + XrStructureType type; + void *next; + uint32_t bufferSize; + void *buffer; +} XrWorldMeshBufferML; + +typedef struct XrWorldMeshBufferRecommendedSizeInfoML +{ + XrStructureType type; + const void *next; + uint32_t maxBlockCount; +} XrWorldMeshBufferRecommendedSizeInfoML; + +typedef struct XrWorldMeshBufferSizeML +{ + XrStructureType type; + void *next; + uint32_t size; +} XrWorldMeshBufferSizeML; + +typedef struct XrWorldMeshDetectorCreateInfoML +{ + XrStructureType type; + const void *next; +} XrWorldMeshDetectorCreateInfoML; + +typedef struct XrWorldMeshGetInfoML +{ + XrStructureType type; + const void *next; + XrWorldMeshDetectorFlagsML WINE_XR_ALIGN(8) flags; + float fillHoleLength; + float disconnectedComponentArea; + uint32_t blockCount; + XrWorldMeshBlockRequestML *blocks; +} XrWorldMeshGetInfoML; + +typedef struct XrWorldMeshRequestCompletionInfoML +{ + XrStructureType type; + const void *next; + XrSpace meshSpace; + XrTime meshSpaceLocateTime; +} XrWorldMeshRequestCompletionInfoML; + +typedef struct XrWorldMeshRequestCompletionML +{ + XrStructureType type; + void *next; + XrResult futureResult; + uint32_t blockCount; + XrWorldMeshBlockML *blocks; +} XrWorldMeshRequestCompletionML; + typedef struct XrActionStateVector2f { XrStructureType type; @@ -4785,6 +5769,16 @@ typedef struct XrCompositionLayerReprojectionPlaneOverrideMSFT XrVector3f velocity; } XrCompositionLayerReprojectionPlaneOverrideMSFT; +typedef struct XrEventDataColocationDiscoveryResultMETA +{ + XrStructureType type; + const void *next; + XrAsyncRequestIdFB discoveryRequestId; + XrUuid advertisementUuid; + uint32_t bufferSize; + uint8_t buffer[XR_MAX_COLOCATION_DISCOVERY_BUFFER_SIZE_META]; +} XrEventDataColocationDiscoveryResultMETA; + typedef struct XrEventDataSpaceEraseCompleteFB { XrStructureType type; @@ -4829,6 +5823,15 @@ typedef struct XrEventDataSpatialAnchorCreateCompleteFB XrUuidEXT uuid; } XrEventDataSpatialAnchorCreateCompleteFB; +typedef struct XrEventDataStartColocationAdvertisementCompleteMETA +{ + XrStructureType type; + const void *next; + XrAsyncRequestIdFB advertisementRequestId; + XrResult result; + XrUuid advertisementUuid; +} XrEventDataStartColocationAdvertisementCompleteMETA; + typedef struct XrEventDataViveTrackerConnectedHTCX { XrStructureType type; @@ -5039,6 +6042,14 @@ typedef struct XrSecondaryViewConfigurationFrameStateMSFT XrSecondaryViewConfigurationStateMSFT *viewConfigurationStates; } XrSecondaryViewConfigurationFrameStateMSFT; +typedef struct XrSenseDataFilterUuidBD +{ + XrStructureType type; + const void *next; + uint32_t uuidCount; + const XrUuidEXT *uuids; +} XrSenseDataFilterUuidBD; + typedef struct XrSerializedSceneFragmentDataGetInfoMSFT { XrStructureType type; @@ -5046,6 +6057,30 @@ typedef struct XrSerializedSceneFragmentDataGetInfoMSFT XrUuidMSFT sceneFragmentId; } XrSerializedSceneFragmentDataGetInfoMSFT; +typedef struct XrShareSpacesInfoMETA +{ + XrStructureType type; + const void *next; + uint32_t spaceCount; + XrSpace *spaces; + const XrShareSpacesRecipientBaseHeaderMETA *recipientInfo; +} XrShareSpacesInfoMETA; + +typedef struct XrShareSpacesRecipientGroupsMETA +{ + XrStructureType type; + const void *next; + uint32_t groupCount; + XrUuid *groups; +} XrShareSpacesRecipientGroupsMETA; + +typedef struct XrSharedSpatialAnchorDownloadInfoBD +{ + XrStructureType type; + const void *next; + XrUuidEXT uuid; +} XrSharedSpatialAnchorDownloadInfoBD; + typedef struct XrSpaceContainerFB { XrStructureType type; @@ -5055,6 +6090,13 @@ typedef struct XrSpaceContainerFB XrUuidEXT *uuids; } XrSpaceContainerFB; +typedef struct XrSpaceGroupUuidFilterInfoMETA +{ + XrStructureType type; + const void *next; + XrUuid groupUuid; +} XrSpaceGroupUuidFilterInfoMETA; + typedef struct XrSpaceLocation { XrStructureType type; @@ -5131,6 +6173,30 @@ typedef struct XrSpaceVelocityData } XrSpaceVelocityData; typedef XrSpaceVelocityData XrSpaceVelocityDataKHR; +typedef struct XrSpatialAnchorCompletionResultML +{ + XrUuidEXT uuid; + XrResult result; +} XrSpatialAnchorCompletionResultML; + +typedef struct XrSpatialAnchorCreateCompletionBD +{ + XrStructureType type; + void *next; + XrResult futureResult; + XrAnchorBD anchor; + XrUuidEXT uuid; +} XrSpatialAnchorCreateCompletionBD; + +typedef struct XrSpatialAnchorCreateInfoBD +{ + XrStructureType type; + const void *next; + XrSpace space; + XrPosef pose; + XrTime time; +} XrSpatialAnchorCreateInfoBD; + typedef struct XrSpatialAnchorCreateInfoFB { XrStructureType type; @@ -5182,6 +6248,131 @@ typedef struct XrSpatialAnchorSpaceCreateInfoMSFT XrPosef poseInAnchorSpace; } XrSpatialAnchorSpaceCreateInfoMSFT; +typedef struct XrSpatialAnchorsCreateInfoFromPoseML +{ + XrStructureType type; + const void *next; + XrSpace baseSpace; + XrPosef poseInBaseSpace; + XrTime time; +} XrSpatialAnchorsCreateInfoFromPoseML; + +typedef struct XrSpatialAnchorsCreateInfoFromUuidsML +{ + XrStructureType type; + const void *next; + XrSpatialAnchorsStorageML storage; + uint32_t uuidCount; + const XrUuidEXT *uuids; +} XrSpatialAnchorsCreateInfoFromUuidsML; + +typedef struct XrSpatialAnchorsDeleteCompletionDetailsML +{ + XrStructureType type; + void *next; + uint32_t resultCount; + XrSpatialAnchorCompletionResultML *results; +} XrSpatialAnchorsDeleteCompletionDetailsML; + +typedef struct XrSpatialAnchorsDeleteInfoML +{ + XrStructureType type; + const void *next; + uint32_t uuidCount; + const XrUuidEXT *uuids; +} XrSpatialAnchorsDeleteInfoML; + +typedef struct XrSpatialAnchorsPublishCompletionDetailsML +{ + XrStructureType type; + void *next; + uint32_t resultCount; + XrSpatialAnchorCompletionResultML *results; +} XrSpatialAnchorsPublishCompletionDetailsML; + +typedef struct XrSpatialAnchorsPublishCompletionML +{ + XrStructureType type; + void *next; + XrResult futureResult; + uint32_t uuidCount; + XrUuidEXT *uuids; +} XrSpatialAnchorsPublishCompletionML; + +typedef struct XrSpatialAnchorsQueryCompletionML +{ + XrStructureType type; + void *next; + XrResult futureResult; + uint32_t uuidCapacityInput; + uint32_t uuidCountOutput; + XrUuidEXT *uuids; +} XrSpatialAnchorsQueryCompletionML; + +typedef struct XrSpatialAnchorsQueryInfoRadiusML +{ + XrStructureType type; + const void *next; + XrSpace baseSpace; + XrVector3f center; + XrTime time; + float radius; +} XrSpatialAnchorsQueryInfoRadiusML; + +typedef struct XrSpatialAnchorsUpdateExpirationCompletionDetailsML +{ + XrStructureType type; + void *next; + uint32_t resultCount; + XrSpatialAnchorCompletionResultML *results; +} XrSpatialAnchorsUpdateExpirationCompletionDetailsML; + +typedef struct XrSpatialAnchorsUpdateExpirationInfoML +{ + XrStructureType type; + const void *next; + uint32_t uuidCount; + const XrUuidEXT *uuids; + uint64_t WINE_XR_ALIGN(8) expiration; +} XrSpatialAnchorsUpdateExpirationInfoML; + +typedef struct XrSpatialEntityComponentDataLocationBD +{ + XrStructureType type; + void *next; + XrSpaceLocation WINE_XR_ALIGN(8) location; +} XrSpatialEntityComponentDataLocationBD; + +typedef struct XrSpatialEntityComponentDataPolygonBD +{ + XrStructureType type; + void *next; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrVector2f *vertices; +} XrSpatialEntityComponentDataPolygonBD; + +typedef struct XrSpatialEntityComponentDataTriangleMeshBD +{ + XrStructureType type; + void *next; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrVector3f *vertices; + uint32_t indexCapacityInput; + uint32_t indexCountOutput; + uint16_t *indices; +} XrSpatialEntityComponentDataTriangleMeshBD; + +typedef struct XrSpatialEntityStateBD +{ + XrStructureType type; + void *next; + XrSpatialEntityIdBD entityId; + XrTime lastUpdateTime; + XrUuidEXT uuid; +} XrSpatialEntityStateBD; + typedef struct XrSpatialGraphNodeBindingPropertiesMSFT { XrStructureType type; @@ -5282,6 +6473,38 @@ typedef struct XrVirtualKeyboardSpaceCreateInfoMETA XrPosef poseInSpace; } XrVirtualKeyboardSpaceCreateInfoMETA; +typedef struct XrWorldMeshBlockStateML +{ + XrStructureType type; + void *next; + XrUuidEXT uuid; + XrPosef meshBoundingBoxCenter; + XrExtent3DfEXT meshBoundingBoxExtents; + XrTime lastUpdateTime; + XrWorldMeshBlockStatusML status; +} XrWorldMeshBlockStateML; + +typedef struct XrWorldMeshStateRequestCompletionML +{ + XrStructureType type; + void *next; + XrResult futureResult; + XrTime timestamp; + uint32_t meshBlockStateCapacityInput; + uint32_t meshBlockStateCountOutput; + XrWorldMeshBlockStateML *meshBlockStates; +} XrWorldMeshStateRequestCompletionML; + +typedef struct XrWorldMeshStateRequestInfoML +{ + XrStructureType type; + const void *next; + XrSpace baseSpace; + XrTime time; + XrPosef boundingBoxCenter; + XrExtent3DfEXT boundingBoxExtents; +} XrWorldMeshStateRequestInfoML; + typedef struct XrActionSpaceCreateInfo { XrStructureType type; @@ -5291,12 +6514,41 @@ typedef struct XrActionSpaceCreateInfo XrPosef poseInActionSpace; } XrActionSpaceCreateInfo; +typedef struct XrAnchorSpaceCreateInfoBD +{ + XrStructureType type; + const void *next; + XrAnchorBD anchor; + XrPosef poseInAnchorSpace; +} XrAnchorSpaceCreateInfoBD; + +typedef struct XrBodyJointLocationBD +{ + XrSpaceLocationFlags WINE_XR_ALIGN(8) locationFlags; + XrPosef pose; +} XrBodyJointLocationBD; + typedef struct XrBodyJointLocationFB { XrSpaceLocationFlags WINE_XR_ALIGN(8) locationFlags; XrPosef pose; } XrBodyJointLocationFB; +typedef struct XrBodyJointLocationHTC +{ + XrSpaceLocationFlags WINE_XR_ALIGN(8) locationFlags; + XrPosef pose; +} XrBodyJointLocationHTC; + +typedef struct XrBodyJointLocationsBD +{ + XrStructureType type; + void *next; + XrBool32 allJointPosesTracked; + uint32_t jointLocationCount; + XrBodyJointLocationBD *jointLocations; +} XrBodyJointLocationsBD; + typedef struct XrBodyJointLocationsFB { XrStructureType type; @@ -5309,6 +6561,17 @@ typedef struct XrBodyJointLocationsFB XrTime time; } XrBodyJointLocationsFB; +typedef struct XrBodyJointLocationsHTC +{ + XrStructureType type; + void *next; + XrSpaceLocationFlags WINE_XR_ALIGN(8) combinedLocationFlags; + XrBodyJointConfidenceHTC confidenceLevel; + uint32_t jointLocationCount; + XrBodyJointLocationHTC *jointLocations; + uint32_t skeletonGenerationId; +} XrBodyJointLocationsHTC; + typedef struct XrBodySkeletonJointFB { int32_t joint; @@ -5316,6 +6579,11 @@ typedef struct XrBodySkeletonJointFB XrPosef pose; } XrBodySkeletonJointFB; +typedef struct XrBodySkeletonJointHTC +{ + XrPosef pose; +} XrBodySkeletonJointHTC; + typedef struct XrBoxf { XrPosef center; @@ -5479,6 +6747,22 @@ typedef struct XrEyeGazesFB XrTime time; } XrEyeGazesFB; +typedef struct XrFrameSynthesisInfoEXT +{ + XrStructureType type; + const void *next; + XrFrameSynthesisInfoFlagsEXT WINE_XR_ALIGN(8) layerFlags; + XrSwapchainSubImage motionVectorSubImage; + XrVector4f motionVectorScale; + XrVector4f motionVectorOffset; + XrPosef appSpaceDeltaPose; + XrSwapchainSubImage depthSubImage; + float minDepth; + float maxDepth; + float nearZ; + float farZ; +} XrFrameSynthesisInfoEXT; + typedef struct XrFrustumf { XrPosef pose; @@ -5651,6 +6935,15 @@ typedef struct XrPlaneDetectorLocationsEXT XrPlaneDetectorLocationEXT *planeLocations; } XrPlaneDetectorLocationsEXT; +typedef struct XrQueriedSenseDataBD +{ + XrStructureType type; + void *next; + uint32_t stateCapacityInput; + uint32_t stateCountOutput; + XrSpatialEntityStateBD *states; +} XrQueriedSenseDataBD; + typedef struct XrSceneBoundsMSFT { XrSpace space; @@ -5672,6 +6965,13 @@ typedef struct XrSpaceVelocities } XrSpaceVelocities; typedef XrSpaceVelocities XrSpaceVelocitiesKHR; +typedef struct XrSpatialEntityComponentDataBoundingBox3DBD +{ + XrStructureType type; + void *next; + XrBoxf boundingBox3D; +} XrSpatialEntityComponentDataBoundingBox3DBD; + typedef struct XrBodySkeletonFB { XrStructureType type; @@ -5680,6 +6980,14 @@ typedef struct XrBodySkeletonFB XrBodySkeletonJointFB *joints; } XrBodySkeletonFB; +typedef struct XrBodySkeletonHTC +{ + XrStructureType type; + void *next; + uint32_t jointCount; + XrBodySkeletonJointHTC *joints; +} XrBodySkeletonHTC; + typedef struct XrCompositionLayerProjection { XrStructureType type; @@ -5723,6 +7031,7 @@ typedef struct 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_xrAllocateWorldMeshBufferML)(XrWorldMeshDetectorML, const XrWorldMeshBufferSizeML *, XrWorldMeshBufferML *); typedef XrResult (XRAPI_PTR *PFN_xrApplyForceFeedbackCurlMNDX)(XrHandTrackerEXT, const XrForceFeedbackCurlApplyLocationsMNDX *); typedef XrResult (XRAPI_PTR *PFN_xrApplyHapticFeedback)(XrSession, const XrHapticActionInfo *, const XrHapticBaseHeader *); typedef XrResult (XRAPI_PTR *PFN_xrAttachSessionActionSets)(XrSession, const XrSessionActionSetsAttachInfo *); @@ -5730,6 +7039,8 @@ typedef XrResult (XRAPI_PTR *PFN_xrBeginFrame)(XrSession, const XrFrameBeginInfo typedef XrResult (XRAPI_PTR *PFN_xrBeginPlaneDetectionEXT)(XrPlaneDetectorEXT, const XrPlaneDetectorBeginInfoEXT *); typedef XrResult (XRAPI_PTR *PFN_xrBeginSession)(XrSession, const XrSessionBeginInfo *); typedef XrResult (XRAPI_PTR *PFN_xrCancelFutureEXT)(XrInstance, const XrFutureCancelInfoEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrCaptureSceneAsyncBD)(XrSenseDataProviderBD, const XrSceneCaptureInfoBD *, XrFutureEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrCaptureSceneCompleteBD)(XrSenseDataProviderBD, XrFutureEXT, XrFutureCompletionEXT *); typedef XrResult (XRAPI_PTR *PFN_xrChangeVirtualKeyboardTextContextMETA)(XrVirtualKeyboardMETA, const XrVirtualKeyboardTextContextChangeInfoMETA *); typedef XrResult (XRAPI_PTR *PFN_xrClearSpatialAnchorStoreMSFT)(XrSpatialAnchorStoreConnectionMSFT); typedef XrResult (XRAPI_PTR *PFN_xrComputeNewSceneMSFT)(XrSceneObserverMSFT, const XrNewSceneComputeInfoMSFT *); @@ -5738,14 +7049,18 @@ typedef XrResult (XRAPI_PTR *PFN_xrConvertWin32PerformanceCounterToTimeKHR)(XrIn typedef XrResult (XRAPI_PTR *PFN_xrCreateAction)(XrActionSet, const XrActionCreateInfo *, XrAction *); typedef XrResult (XRAPI_PTR *PFN_xrCreateActionSet)(XrInstance, const XrActionSetCreateInfo *, XrActionSet *); typedef XrResult (XRAPI_PTR *PFN_xrCreateActionSpace)(XrSession, const XrActionSpaceCreateInfo *, XrSpace *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateAnchorSpaceBD)(XrSession, const XrAnchorSpaceCreateInfoBD *, XrSpace *); typedef XrResult (XRAPI_PTR *PFN_xrCreateApiLayerInstance)(const XrInstanceCreateInfo *, const XrApiLayerCreateInfo *, XrInstance *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateBodyTrackerBD)(XrSession, const XrBodyTrackerCreateInfoBD *, XrBodyTrackerBD *); typedef XrResult (XRAPI_PTR *PFN_xrCreateBodyTrackerFB)(XrSession, const XrBodyTrackerCreateInfoFB *, XrBodyTrackerFB *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateBodyTrackerHTC)(XrSession, const XrBodyTrackerCreateInfoHTC *, XrBodyTrackerHTC *); typedef XrResult (XRAPI_PTR *PFN_xrCreateEnvironmentDepthProviderMETA)(XrSession, const XrEnvironmentDepthProviderCreateInfoMETA *, XrEnvironmentDepthProviderMETA *); typedef XrResult (XRAPI_PTR *PFN_xrCreateEnvironmentDepthSwapchainMETA)(XrEnvironmentDepthProviderMETA, const XrEnvironmentDepthSwapchainCreateInfoMETA *, XrEnvironmentDepthSwapchainMETA *); typedef XrResult (XRAPI_PTR *PFN_xrCreateExportedLocalizationMapML)(XrSession, const XrUuidEXT *, XrExportedLocalizationMapML *); typedef XrResult (XRAPI_PTR *PFN_xrCreateEyeTrackerFB)(XrSession, const XrEyeTrackerCreateInfoFB *, XrEyeTrackerFB *); typedef XrResult (XRAPI_PTR *PFN_xrCreateFaceTracker2FB)(XrSession, const XrFaceTrackerCreateInfo2FB *, XrFaceTracker2FB *); typedef XrResult (XRAPI_PTR *PFN_xrCreateFaceTrackerFB)(XrSession, const XrFaceTrackerCreateInfoFB *, XrFaceTrackerFB *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateFacialExpressionClientML)(XrSession, const XrFacialExpressionClientCreateInfoML *, XrFacialExpressionClientML *); typedef XrResult (XRAPI_PTR *PFN_xrCreateFacialTrackerHTC)(XrSession, const XrFacialTrackerCreateInfoHTC *, XrFacialTrackerHTC *); typedef XrResult (XRAPI_PTR *PFN_xrCreateFoveationProfileFB)(XrSession, const XrFoveationProfileCreateInfoFB *, XrFoveationProfileFB *); typedef XrResult (XRAPI_PTR *PFN_xrCreateGeometryInstanceFB)(XrSession, const XrGeometryInstanceCreateInfoFB *, XrGeometryInstanceFB *); @@ -5764,14 +7079,21 @@ typedef XrResult (XRAPI_PTR *PFN_xrCreatePlaneDetectorEXT)(XrSession, const XrPl typedef XrResult (XRAPI_PTR *PFN_xrCreateReferenceSpace)(XrSession, const XrReferenceSpaceCreateInfo *, XrSpace *); typedef XrResult (XRAPI_PTR *PFN_xrCreateSceneMSFT)(XrSceneObserverMSFT, const XrSceneCreateInfoMSFT *, XrSceneMSFT *); typedef XrResult (XRAPI_PTR *PFN_xrCreateSceneObserverMSFT)(XrSession, const XrSceneObserverCreateInfoMSFT *, XrSceneObserverMSFT *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSenseDataProviderBD)(XrSession, const XrSenseDataProviderCreateInfoBD *, XrSenseDataProviderBD *); typedef XrResult (XRAPI_PTR *PFN_xrCreateSession)(XrInstance, const XrSessionCreateInfo *, XrSession *); typedef XrResult (XRAPI_PTR *PFN_xrCreateSpaceUserFB)(XrSession, const XrSpaceUserCreateInfoFB *, XrSpaceUserFB *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorAsyncBD)(XrSenseDataProviderBD, const XrSpatialAnchorCreateInfoBD *, XrFutureEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorCompleteBD)(XrSenseDataProviderBD, XrFutureEXT, XrSpatialAnchorCreateCompletionBD *); typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorFB)(XrSession, const XrSpatialAnchorCreateInfoFB *, XrAsyncRequestIdFB *); typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorFromPersistedNameMSFT)(XrSession, const XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT *, XrSpatialAnchorMSFT *); typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorHTC)(XrSession, const XrSpatialAnchorCreateInfoHTC *, XrSpace *); typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorMSFT)(XrSession, const XrSpatialAnchorCreateInfoMSFT *, XrSpatialAnchorMSFT *); typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorSpaceMSFT)(XrSession, const XrSpatialAnchorSpaceCreateInfoMSFT *, XrSpace *); typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorStoreConnectionMSFT)(XrSession, XrSpatialAnchorStoreConnectionMSFT *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorsAsyncML)(XrSession, const XrSpatialAnchorsCreateInfoBaseHeaderML *, XrFutureEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorsCompleteML)(XrSession, XrFutureEXT, XrCreateSpatialAnchorsCompletionML *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorsStorageML)(XrSession, const XrSpatialAnchorsCreateStorageInfoML *, XrSpatialAnchorsStorageML *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialEntityAnchorBD)(XrSenseDataProviderBD, const XrSpatialEntityAnchorCreateInfoBD *, XrAnchorBD *); typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialGraphNodeSpaceMSFT)(XrSession, const XrSpatialGraphNodeSpaceCreateInfoMSFT *, XrSpace *); typedef XrResult (XRAPI_PTR *PFN_xrCreateSwapchain)(XrSession, const XrSwapchainCreateInfo *, XrSwapchain *); typedef XrResult (XRAPI_PTR *PFN_xrCreateTriangleMeshFB)(XrSession, const XrTriangleMeshCreateInfoFB *, XrTriangleMeshFB *); @@ -5779,16 +7101,23 @@ typedef XrResult (XRAPI_PTR *PFN_xrCreateVirtualKeyboardMETA)(XrSession, const X typedef XrResult (XRAPI_PTR *PFN_xrCreateVirtualKeyboardSpaceMETA)(XrSession, XrVirtualKeyboardMETA, const XrVirtualKeyboardSpaceCreateInfoMETA *, XrSpace *); typedef XrResult (XRAPI_PTR *PFN_xrCreateVulkanDeviceKHR)(XrInstance, const XrVulkanDeviceCreateInfoKHR *, VkDevice *, VkResult *); typedef XrResult (XRAPI_PTR *PFN_xrCreateVulkanInstanceKHR)(XrInstance, const XrVulkanInstanceCreateInfoKHR *, VkInstance *, VkResult *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateWorldMeshDetectorML)(XrSession, const XrWorldMeshDetectorCreateInfoML *, XrWorldMeshDetectorML *); +typedef XrResult (XRAPI_PTR *PFN_xrDeleteSpatialAnchorsAsyncML)(XrSpatialAnchorsStorageML, const XrSpatialAnchorsDeleteInfoML *, XrFutureEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrDeleteSpatialAnchorsCompleteML)(XrSpatialAnchorsStorageML, XrFutureEXT, XrSpatialAnchorsDeleteCompletionML *); typedef XrResult (XRAPI_PTR *PFN_xrDeserializeSceneMSFT)(XrSceneObserverMSFT, const XrSceneDeserializeInfoMSFT *); typedef XrResult (XRAPI_PTR *PFN_xrDestroyAction)(XrAction); typedef XrResult (XRAPI_PTR *PFN_xrDestroyActionSet)(XrActionSet); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyAnchorBD)(XrAnchorBD); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyBodyTrackerBD)(XrBodyTrackerBD); typedef XrResult (XRAPI_PTR *PFN_xrDestroyBodyTrackerFB)(XrBodyTrackerFB); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyBodyTrackerHTC)(XrBodyTrackerHTC); typedef XrResult (XRAPI_PTR *PFN_xrDestroyEnvironmentDepthProviderMETA)(XrEnvironmentDepthProviderMETA); typedef XrResult (XRAPI_PTR *PFN_xrDestroyEnvironmentDepthSwapchainMETA)(XrEnvironmentDepthSwapchainMETA); typedef XrResult (XRAPI_PTR *PFN_xrDestroyExportedLocalizationMapML)(XrExportedLocalizationMapML); typedef XrResult (XRAPI_PTR *PFN_xrDestroyEyeTrackerFB)(XrEyeTrackerFB); typedef XrResult (XRAPI_PTR *PFN_xrDestroyFaceTracker2FB)(XrFaceTracker2FB); typedef XrResult (XRAPI_PTR *PFN_xrDestroyFaceTrackerFB)(XrFaceTrackerFB); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyFacialExpressionClientML)(XrFacialExpressionClientML); typedef XrResult (XRAPI_PTR *PFN_xrDestroyFacialTrackerHTC)(XrFacialTrackerHTC); typedef XrResult (XRAPI_PTR *PFN_xrDestroyFoveationProfileFB)(XrFoveationProfileFB); typedef XrResult (XRAPI_PTR *PFN_xrDestroyGeometryInstanceFB)(XrGeometryInstanceFB); @@ -5802,15 +7131,21 @@ typedef XrResult (XRAPI_PTR *PFN_xrDestroyPassthroughLayerFB)(XrPassthroughLayer typedef XrResult (XRAPI_PTR *PFN_xrDestroyPlaneDetectorEXT)(XrPlaneDetectorEXT); typedef XrResult (XRAPI_PTR *PFN_xrDestroySceneMSFT)(XrSceneMSFT); typedef XrResult (XRAPI_PTR *PFN_xrDestroySceneObserverMSFT)(XrSceneObserverMSFT); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySenseDataProviderBD)(XrSenseDataProviderBD); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySenseDataSnapshotBD)(XrSenseDataSnapshotBD); typedef XrResult (XRAPI_PTR *PFN_xrDestroySession)(XrSession); typedef XrResult (XRAPI_PTR *PFN_xrDestroySpace)(XrSpace); typedef XrResult (XRAPI_PTR *PFN_xrDestroySpaceUserFB)(XrSpaceUserFB); typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialAnchorMSFT)(XrSpatialAnchorMSFT); typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialAnchorStoreConnectionMSFT)(XrSpatialAnchorStoreConnectionMSFT); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialAnchorsStorageML)(XrSpatialAnchorsStorageML); typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialGraphNodeBindingMSFT)(XrSpatialGraphNodeBindingMSFT); typedef XrResult (XRAPI_PTR *PFN_xrDestroySwapchain)(XrSwapchain); typedef XrResult (XRAPI_PTR *PFN_xrDestroyTriangleMeshFB)(XrTriangleMeshFB); typedef XrResult (XRAPI_PTR *PFN_xrDestroyVirtualKeyboardMETA)(XrVirtualKeyboardMETA); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyWorldMeshDetectorML)(XrWorldMeshDetectorML); +typedef XrResult (XRAPI_PTR *PFN_xrDownloadSharedSpatialAnchorAsyncBD)(XrSenseDataProviderBD, const XrSharedSpatialAnchorDownloadInfoBD *, XrFutureEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrDownloadSharedSpatialAnchorCompleteBD)(XrSenseDataProviderBD, XrFutureEXT, XrFutureCompletionEXT *); typedef XrResult (XRAPI_PTR *PFN_xrEnableLocalizationEventsML)(XrSession, const XrLocalizationEnableEventsInfoML *); typedef XrResult (XRAPI_PTR *PFN_xrEnableUserCalibrationEventsML)(XrInstance, const XrUserCalibrationEnableEventsInfoML *); typedef XrResult (XRAPI_PTR *PFN_xrEndFrame)(XrSession, const XrFrameEndInfo *); @@ -5830,20 +7165,24 @@ typedef XrResult (XRAPI_PTR *PFN_xrEnumerateRenderModelPathsFB)(XrSession, uint3 typedef XrResult (XRAPI_PTR *PFN_xrEnumerateReprojectionModesMSFT)(XrInstance, XrSystemId, XrViewConfigurationType, uint32_t, uint32_t *, XrReprojectionModeMSFT *); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSceneComputeFeaturesMSFT)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrSceneComputeFeatureMSFT *); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpaceSupportedComponentsFB)(XrSpace, uint32_t, uint32_t *, XrSpaceComponentTypeFB *); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpatialEntityComponentTypesBD)(XrSenseDataSnapshotBD, XrSpatialEntityIdBD, uint32_t, uint32_t *, XrSpatialEntityComponentTypeBD *); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSwapchainFormats)(XrSession, uint32_t, uint32_t *, int64_t *); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSwapchainImages)(XrSwapchain, uint32_t, uint32_t *, XrSwapchainImageBaseHeader *); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateViewConfigurationViews)(XrInstance, XrSystemId, XrViewConfigurationType, uint32_t, uint32_t *, XrViewConfigurationView *); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateViewConfigurations)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrViewConfigurationType *); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateViveTrackerPathsHTCX)(XrInstance, uint32_t, uint32_t *, XrViveTrackerPathsHTCX *); typedef XrResult (XRAPI_PTR *PFN_xrEraseSpaceFB)(XrSession, const XrSpaceEraseInfoFB *, XrAsyncRequestIdFB *); +typedef XrResult (XRAPI_PTR *PFN_xrFreeWorldMeshBufferML)(XrWorldMeshDetectorML, const XrWorldMeshBufferML *); typedef XrResult (XRAPI_PTR *PFN_xrGeometryInstanceSetTransformFB)(XrGeometryInstanceFB, const XrGeometryInstanceTransformFB *); typedef XrResult (XRAPI_PTR *PFN_xrGetActionStateBoolean)(XrSession, const XrActionStateGetInfo *, XrActionStateBoolean *); typedef XrResult (XRAPI_PTR *PFN_xrGetActionStateFloat)(XrSession, const XrActionStateGetInfo *, XrActionStateFloat *); typedef XrResult (XRAPI_PTR *PFN_xrGetActionStatePose)(XrSession, const XrActionStateGetInfo *, XrActionStatePose *); typedef XrResult (XRAPI_PTR *PFN_xrGetActionStateVector2f)(XrSession, const XrActionStateGetInfo *, XrActionStateVector2f *); +typedef XrResult (XRAPI_PTR *PFN_xrGetAnchorUuidBD)(XrAnchorBD, XrUuidEXT *); typedef XrResult (XRAPI_PTR *PFN_xrGetAudioInputDeviceGuidOculus)(XrInstance, wchar_t[]); typedef XrResult (XRAPI_PTR *PFN_xrGetAudioOutputDeviceGuidOculus)(XrInstance, wchar_t[]); typedef XrResult (XRAPI_PTR *PFN_xrGetBodySkeletonFB)(XrBodyTrackerFB, XrBodySkeletonFB *); +typedef XrResult (XRAPI_PTR *PFN_xrGetBodySkeletonHTC)(XrBodyTrackerHTC, XrSpace, uint32_t, XrBodySkeletonHTC *); typedef XrResult (XRAPI_PTR *PFN_xrGetControllerModelKeyMSFT)(XrSession, XrPath, XrControllerModelKeyStateMSFT *); typedef XrResult (XRAPI_PTR *PFN_xrGetControllerModelPropertiesMSFT)(XrSession, XrControllerModelKeyMSFT, XrControllerModelPropertiesMSFT *); typedef XrResult (XRAPI_PTR *PFN_xrGetControllerModelStateMSFT)(XrSession, XrControllerModelKeyMSFT, XrControllerModelStateMSFT *); @@ -5857,6 +7196,7 @@ typedef XrResult (XRAPI_PTR *PFN_xrGetExportedLocalizationMapDataML)(XrExportedL typedef XrResult (XRAPI_PTR *PFN_xrGetEyeGazesFB)(XrEyeTrackerFB, const XrEyeGazesInfoFB *, XrEyeGazesFB *); typedef XrResult (XRAPI_PTR *PFN_xrGetFaceExpressionWeights2FB)(XrFaceTracker2FB, const XrFaceExpressionInfo2FB *, XrFaceExpressionWeights2FB *); typedef XrResult (XRAPI_PTR *PFN_xrGetFaceExpressionWeightsFB)(XrFaceTrackerFB, const XrFaceExpressionInfoFB *, XrFaceExpressionWeightsFB *); +typedef XrResult (XRAPI_PTR *PFN_xrGetFacialExpressionBlendShapePropertiesML)(XrFacialExpressionClientML, const XrFacialExpressionBlendShapeGetInfoML *, uint32_t, XrFacialExpressionBlendShapePropertiesML *); typedef XrResult (XRAPI_PTR *PFN_xrGetFacialExpressionsHTC)(XrFacialTrackerHTC, XrFacialExpressionsHTC *); typedef XrResult (XRAPI_PTR *PFN_xrGetFoveationEyeTrackedStateMETA)(XrSession, XrFoveationEyeTrackedStateMETA *); typedef XrResult (XRAPI_PTR *PFN_xrGetHandMeshFB)(XrHandTrackerEXT, XrHandTrackingMeshFB *); @@ -5876,6 +7216,7 @@ typedef XrResult (XRAPI_PTR *PFN_xrGetPerformanceMetricsStateMETA)(XrSession, Xr typedef XrResult (XRAPI_PTR *PFN_xrGetPlaneDetectionStateEXT)(XrPlaneDetectorEXT, XrPlaneDetectionStateEXT *); typedef XrResult (XRAPI_PTR *PFN_xrGetPlaneDetectionsEXT)(XrPlaneDetectorEXT, const XrPlaneDetectorGetInfoEXT *, XrPlaneDetectorLocationsEXT *); typedef XrResult (XRAPI_PTR *PFN_xrGetPlanePolygonBufferEXT)(XrPlaneDetectorEXT, uint64_t, uint32_t, XrPlaneDetectorPolygonBufferEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrGetQueriedSenseDataBD)(XrSenseDataSnapshotBD, XrQueriedSenseDataGetInfoBD *, XrQueriedSenseDataBD *); typedef XrResult (XRAPI_PTR *PFN_xrGetRecommendedLayerResolutionMETA)(XrSession, const XrRecommendedLayerResolutionGetInfoMETA *, XrRecommendedLayerResolutionMETA *); typedef XrResult (XRAPI_PTR *PFN_xrGetReferenceSpaceBoundsRect)(XrSession, XrReferenceSpaceType, XrExtent2Df *); typedef XrResult (XRAPI_PTR *PFN_xrGetRenderModelPropertiesFB)(XrSession, XrPath, XrRenderModelPropertiesFB *); @@ -5884,6 +7225,7 @@ typedef XrResult (XRAPI_PTR *PFN_xrGetSceneComputeStateMSFT)(XrSceneObserverMSFT typedef XrResult (XRAPI_PTR *PFN_xrGetSceneMarkerDecodedStringMSFT)(XrSceneMSFT, const XrUuidMSFT *, uint32_t, uint32_t *, char *); typedef XrResult (XRAPI_PTR *PFN_xrGetSceneMarkerRawDataMSFT)(XrSceneMSFT, const XrUuidMSFT *, uint32_t, uint32_t *, uint8_t *); typedef XrResult (XRAPI_PTR *PFN_xrGetSceneMeshBuffersMSFT)(XrSceneMSFT, const XrSceneMeshBuffersGetInfoMSFT *, XrSceneMeshBuffersMSFT *); +typedef XrResult (XRAPI_PTR *PFN_xrGetSenseDataProviderStateBD)(XrSenseDataProviderBD, XrSenseDataProviderStateBD *); typedef XrResult (XRAPI_PTR *PFN_xrGetSerializedSceneFragmentDataMSFT)(XrSceneMSFT, const XrSerializedSceneFragmentDataGetInfoMSFT *, uint32_t, uint32_t *, uint8_t *); typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceBoundary2DFB)(XrSession, XrSpace, XrBoundary2DFB *); typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceBoundingBox2DFB)(XrSession, XrSpace, XrRect2Df *); @@ -5896,6 +7238,9 @@ typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceTriangleMeshMETA)(XrSpace, const XrSp typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceUserIdFB)(XrSpaceUserFB, XrSpaceUserIdFB *); typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceUuidFB)(XrSpace, XrUuidEXT *); typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialAnchorNameHTC)(XrSpace, XrSpatialAnchorNameHTC *); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialAnchorStateML)(XrSpace, XrSpatialAnchorStateML *); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialEntityComponentDataBD)(XrSenseDataSnapshotBD, const XrSpatialEntityComponentGetInfoBD *, XrSpatialEntityComponentDataBaseHeaderBD *); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialEntityUuidBD)(XrSenseDataSnapshotBD, XrSpatialEntityIdBD, XrUuidEXT *); typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialGraphNodeBindingPropertiesMSFT)(XrSpatialGraphNodeBindingMSFT, const XrSpatialGraphNodeBindingPropertiesGetInfoMSFT *, XrSpatialGraphNodeBindingPropertiesMSFT *); typedef XrResult (XRAPI_PTR *PFN_xrGetSwapchainStateFB)(XrSwapchain, XrSwapchainStateBaseHeaderFB *); typedef XrResult (XRAPI_PTR *PFN_xrGetSystem)(XrInstance, const XrSystemGetInfo *, XrSystemId *); @@ -5912,10 +7257,13 @@ typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanGraphicsDeviceKHR)(XrInstance, XrSys typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanGraphicsRequirements2KHR)(XrInstance, XrSystemId, XrGraphicsRequirementsVulkanKHR *); typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanGraphicsRequirementsKHR)(XrInstance, XrSystemId, XrGraphicsRequirementsVulkanKHR *); typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanInstanceExtensionsKHR)(XrInstance, XrSystemId, uint32_t, uint32_t *, char *); +typedef XrResult (XRAPI_PTR *PFN_xrGetWorldMeshBufferRecommendSizeML)(XrWorldMeshDetectorML, const XrWorldMeshBufferRecommendedSizeInfoML *, XrWorldMeshBufferSizeML *); typedef XrResult (XRAPI_PTR *PFN_xrImportLocalizationMapML)(XrSession, const XrLocalizationMapImportInfoML *, XrUuidEXT *); typedef XrResult (XRAPI_PTR *PFN_xrLoadControllerModelMSFT)(XrSession, XrControllerModelKeyMSFT, uint32_t, uint32_t *, uint8_t *); typedef XrResult (XRAPI_PTR *PFN_xrLoadRenderModelFB)(XrSession, const XrRenderModelLoadInfoFB *, XrRenderModelBufferFB *); +typedef XrResult (XRAPI_PTR *PFN_xrLocateBodyJointsBD)(XrBodyTrackerBD, const XrBodyJointsLocateInfoBD *, XrBodyJointLocationsBD *); typedef XrResult (XRAPI_PTR *PFN_xrLocateBodyJointsFB)(XrBodyTrackerFB, const XrBodyJointsLocateInfoFB *, XrBodyJointLocationsFB *); +typedef XrResult (XRAPI_PTR *PFN_xrLocateBodyJointsHTC)(XrBodyTrackerHTC, const XrBodyJointsLocateInfoHTC *, XrBodyJointLocationsHTC *); typedef XrResult (XRAPI_PTR *PFN_xrLocateHandJointsEXT)(XrHandTrackerEXT, const XrHandJointsLocateInfoEXT *, XrHandJointLocationsEXT *); typedef XrResult (XRAPI_PTR *PFN_xrLocateSceneComponentsMSFT)(XrSceneMSFT, const XrSceneComponentsLocateInfoMSFT *, XrSceneComponentLocationsMSFT *); typedef XrResult (XRAPI_PTR *PFN_xrLocateSpace)(XrSpace, XrSpace, XrTime, XrSpaceLocation *); @@ -5932,18 +7280,30 @@ typedef XrResult (XRAPI_PTR *PFN_xrPassthroughPauseFB)(XrPassthroughFB); typedef XrResult (XRAPI_PTR *PFN_xrPassthroughStartFB)(XrPassthroughFB); typedef XrResult (XRAPI_PTR *PFN_xrPathToString)(XrInstance, XrPath, uint32_t, uint32_t *, char *); typedef XrResult (XRAPI_PTR *PFN_xrPerfSettingsSetPerformanceLevelEXT)(XrSession, XrPerfSettingsDomainEXT, XrPerfSettingsLevelEXT); +typedef XrResult (XRAPI_PTR *PFN_xrPersistSpatialAnchorAsyncBD)(XrSenseDataProviderBD, const XrSpatialAnchorPersistInfoBD *, XrFutureEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrPersistSpatialAnchorCompleteBD)(XrSenseDataProviderBD, XrFutureEXT, XrFutureCompletionEXT *); typedef XrResult (XRAPI_PTR *PFN_xrPersistSpatialAnchorMSFT)(XrSpatialAnchorStoreConnectionMSFT, const XrSpatialAnchorPersistenceInfoMSFT *); typedef XrResult (XRAPI_PTR *PFN_xrPollEvent)(XrInstance, XrEventDataBuffer *); typedef XrResult (XRAPI_PTR *PFN_xrPollFutureEXT)(XrInstance, const XrFuturePollInfoEXT *, XrFuturePollResultEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrPublishSpatialAnchorsAsyncML)(XrSpatialAnchorsStorageML, const XrSpatialAnchorsPublishInfoML *, XrFutureEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrPublishSpatialAnchorsCompleteML)(XrSpatialAnchorsStorageML, XrFutureEXT, XrSpatialAnchorsPublishCompletionML *); typedef XrResult (XRAPI_PTR *PFN_xrQueryLocalizationMapsML)(XrSession, const XrLocalizationMapQueryInfoBaseHeaderML *, uint32_t, uint32_t *, XrLocalizationMapML *); typedef XrResult (XRAPI_PTR *PFN_xrQueryPerformanceMetricsCounterMETA)(XrSession, XrPath, XrPerformanceMetricsCounterMETA *); +typedef XrResult (XRAPI_PTR *PFN_xrQuerySenseDataAsyncBD)(XrSenseDataProviderBD, const XrSenseDataQueryInfoBD *, XrFutureEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrQuerySenseDataCompleteBD)(XrSenseDataProviderBD, XrFutureEXT, XrSenseDataQueryCompletionBD *); typedef XrResult (XRAPI_PTR *PFN_xrQuerySpacesFB)(XrSession, const XrSpaceQueryInfoBaseHeaderFB *, XrAsyncRequestIdFB *); +typedef XrResult (XRAPI_PTR *PFN_xrQuerySpatialAnchorsAsyncML)(XrSpatialAnchorsStorageML, const XrSpatialAnchorsQueryInfoBaseHeaderML *, XrFutureEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrQuerySpatialAnchorsCompleteML)(XrSpatialAnchorsStorageML, XrFutureEXT, XrSpatialAnchorsQueryCompletionML *); typedef XrResult (XRAPI_PTR *PFN_xrQuerySystemTrackedKeyboardFB)(XrSession, const XrKeyboardTrackingQueryFB *, XrKeyboardTrackingDescriptionFB *); typedef XrResult (XRAPI_PTR *PFN_xrReleaseSwapchainImage)(XrSwapchain, const XrSwapchainImageReleaseInfo *); typedef XrResult (XRAPI_PTR *PFN_xrRequestDisplayRefreshRateFB)(XrSession, float); typedef XrResult (XRAPI_PTR *PFN_xrRequestExitSession)(XrSession); typedef XrResult (XRAPI_PTR *PFN_xrRequestMapLocalizationML)(XrSession, const XrMapLocalizationRequestInfoML *); typedef XrResult (XRAPI_PTR *PFN_xrRequestSceneCaptureFB)(XrSession, const XrSceneCaptureRequestInfoFB *, XrAsyncRequestIdFB *); +typedef XrResult (XRAPI_PTR *PFN_xrRequestWorldMeshAsyncML)(XrWorldMeshDetectorML, const XrWorldMeshGetInfoML *, XrWorldMeshBufferML *, XrFutureEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrRequestWorldMeshCompleteML)(XrWorldMeshDetectorML, const XrWorldMeshRequestCompletionInfoML *, XrFutureEXT, XrWorldMeshRequestCompletionML *); +typedef XrResult (XRAPI_PTR *PFN_xrRequestWorldMeshStateAsyncML)(XrWorldMeshDetectorML, const XrWorldMeshStateRequestInfoML *, XrFutureEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrRequestWorldMeshStateCompleteML)(XrWorldMeshDetectorML, XrFutureEXT, XrWorldMeshStateRequestCompletionML *); typedef XrResult (XRAPI_PTR *PFN_xrResultToString)(XrInstance, XrResult, char[]); typedef XrResult (XRAPI_PTR *PFN_xrRetrieveSpaceQueryResultsFB)(XrSession, XrAsyncRequestIdFB, XrSpaceQueryResultsFB *); typedef XrResult (XRAPI_PTR *PFN_xrSaveSpaceFB)(XrSession, const XrSpaceSaveInfoFB *, XrAsyncRequestIdFB *); @@ -5963,16 +7323,28 @@ typedef XrResult (XRAPI_PTR *PFN_xrSetMarkerTrackingTimeoutVARJO)(XrSession, uin typedef XrResult (XRAPI_PTR *PFN_xrSetMarkerTrackingVARJO)(XrSession, XrBool32); typedef XrResult (XRAPI_PTR *PFN_xrSetPerformanceMetricsStateMETA)(XrSession, const XrPerformanceMetricsStateMETA *); typedef XrResult (XRAPI_PTR *PFN_xrSetSpaceComponentStatusFB)(XrSpace, const XrSpaceComponentStatusSetInfoFB *, XrAsyncRequestIdFB *); +typedef XrResult (XRAPI_PTR *PFN_xrSetSystemNotificationsML)(XrInstance, const XrSystemNotificationsSetInfoML *); typedef XrResult (XRAPI_PTR *PFN_xrSetTrackingOptimizationSettingsHintQCOM)(XrSession, XrTrackingOptimizationSettingsDomainQCOM, XrTrackingOptimizationSettingsHintQCOM); typedef XrResult (XRAPI_PTR *PFN_xrSetViewOffsetVARJO)(XrSession, float); typedef XrResult (XRAPI_PTR *PFN_xrSetVirtualKeyboardModelVisibilityMETA)(XrVirtualKeyboardMETA, const XrVirtualKeyboardModelVisibilitySetInfoMETA *); typedef XrResult (XRAPI_PTR *PFN_xrShareSpacesFB)(XrSession, const XrSpaceShareInfoFB *, XrAsyncRequestIdFB *); +typedef XrResult (XRAPI_PTR *PFN_xrShareSpacesMETA)(XrSession, const XrShareSpacesInfoMETA *, XrAsyncRequestIdFB *); +typedef XrResult (XRAPI_PTR *PFN_xrShareSpatialAnchorAsyncBD)(XrSenseDataProviderBD, const XrSpatialAnchorShareInfoBD *, XrFutureEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrShareSpatialAnchorCompleteBD)(XrSenseDataProviderBD, XrFutureEXT, XrFutureCompletionEXT *); typedef XrResult (XRAPI_PTR *PFN_xrSnapshotMarkerDetectorML)(XrMarkerDetectorML, XrMarkerDetectorSnapshotInfoML *); +typedef XrResult (XRAPI_PTR *PFN_xrStartColocationAdvertisementMETA)(XrSession, const XrColocationAdvertisementStartInfoMETA *, XrAsyncRequestIdFB *); +typedef XrResult (XRAPI_PTR *PFN_xrStartColocationDiscoveryMETA)(XrSession, const XrColocationDiscoveryStartInfoMETA *, XrAsyncRequestIdFB *); typedef XrResult (XRAPI_PTR *PFN_xrStartEnvironmentDepthProviderMETA)(XrEnvironmentDepthProviderMETA); +typedef XrResult (XRAPI_PTR *PFN_xrStartSenseDataProviderAsyncBD)(XrSenseDataProviderBD, const XrSenseDataProviderStartInfoBD *, XrFutureEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrStartSenseDataProviderCompleteBD)(XrSession, XrFutureEXT, XrFutureCompletionEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrStopColocationAdvertisementMETA)(XrSession, const XrColocationAdvertisementStopInfoMETA *, XrAsyncRequestIdFB *); +typedef XrResult (XRAPI_PTR *PFN_xrStopColocationDiscoveryMETA)(XrSession, const XrColocationDiscoveryStopInfoMETA *, XrAsyncRequestIdFB *); typedef XrResult (XRAPI_PTR *PFN_xrStopEnvironmentDepthProviderMETA)(XrEnvironmentDepthProviderMETA); typedef XrResult (XRAPI_PTR *PFN_xrStopHapticFeedback)(XrSession, const XrHapticActionInfo *); +typedef XrResult (XRAPI_PTR *PFN_xrStopSenseDataProviderBD)(XrSenseDataProviderBD); typedef XrResult (XRAPI_PTR *PFN_xrStringToPath)(XrInstance, const char *, XrPath *); typedef XrResult (XRAPI_PTR *PFN_xrStructureTypeToString)(XrInstance, XrStructureType, char[]); +typedef XrResult (XRAPI_PTR *PFN_xrStructureTypeToString2KHR)(XrInstance, XrStructureType, char[]); typedef XrResult (XRAPI_PTR *PFN_xrSuggestInteractionProfileBindings)(XrInstance, const XrInteractionProfileSuggestedBinding *); typedef XrResult (XRAPI_PTR *PFN_xrSuggestVirtualKeyboardLocationMETA)(XrVirtualKeyboardMETA, const XrVirtualKeyboardLocationInfoMETA *); typedef XrResult (XRAPI_PTR *PFN_xrSyncActions)(XrSession, const XrActionsSyncInfo *); @@ -5984,9 +7356,13 @@ typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshEndVertexBufferUpdateFB)(XrTriang typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshGetIndexBufferFB)(XrTriangleMeshFB, uint32_t **); typedef XrResult (XRAPI_PTR *PFN_xrTriangleMeshGetVertexBufferFB)(XrTriangleMeshFB, XrVector3f **); typedef XrResult (XRAPI_PTR *PFN_xrTryCreateSpatialGraphStaticNodeBindingMSFT)(XrSession, const XrSpatialGraphStaticNodeBindingCreateInfoMSFT *, XrSpatialGraphNodeBindingMSFT *); +typedef XrResult (XRAPI_PTR *PFN_xrUnpersistSpatialAnchorAsyncBD)(XrSenseDataProviderBD, const XrSpatialAnchorUnpersistInfoBD *, XrFutureEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrUnpersistSpatialAnchorCompleteBD)(XrSenseDataProviderBD, XrFutureEXT, XrFutureCompletionEXT *); typedef XrResult (XRAPI_PTR *PFN_xrUnpersistSpatialAnchorMSFT)(XrSpatialAnchorStoreConnectionMSFT, const XrSpatialAnchorPersistenceNameMSFT *); typedef XrResult (XRAPI_PTR *PFN_xrUpdateHandMeshMSFT)(XrHandTrackerEXT, const XrHandMeshUpdateInfoMSFT *, XrHandMeshMSFT *); typedef XrResult (XRAPI_PTR *PFN_xrUpdatePassthroughColorLutMETA)(XrPassthroughColorLutMETA, const XrPassthroughColorLutUpdateInfoMETA *); +typedef XrResult (XRAPI_PTR *PFN_xrUpdateSpatialAnchorsExpirationAsyncML)(XrSpatialAnchorsStorageML, const XrSpatialAnchorsUpdateExpirationInfoML *, XrFutureEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrUpdateSpatialAnchorsExpirationCompleteML)(XrSpatialAnchorsStorageML, XrFutureEXT, XrSpatialAnchorsUpdateExpirationCompletionML *); typedef XrResult (XRAPI_PTR *PFN_xrUpdateSwapchainFB)(XrSwapchain, const XrSwapchainStateBaseHeaderFB *); typedef XrResult (XRAPI_PTR *PFN_xrWaitFrame)(XrSession, const XrFrameWaitInfo *, XrFrameState *); typedef XrResult (XRAPI_PTR *PFN_xrWaitSwapchainImage)(XrSwapchain, const XrSwapchainImageWaitInfo *); @@ -5994,6 +7370,7 @@ typedef XrResult (XRAPI_PTR *PFN_xrWaitSwapchainImage)(XrSwapchain, const XrSwap #ifndef XR_NO_PROTOTYPES 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 xrAllocateWorldMeshBufferML(XrWorldMeshDetectorML detector, const XrWorldMeshBufferSizeML *size, XrWorldMeshBufferML *buffer); XrResult XRAPI_CALL xrApplyForceFeedbackCurlMNDX(XrHandTrackerEXT handTracker, const XrForceFeedbackCurlApplyLocationsMNDX *locations); XrResult XRAPI_CALL xrApplyHapticFeedback(XrSession session, const XrHapticActionInfo *hapticActionInfo, const XrHapticBaseHeader *hapticFeedback); XrResult XRAPI_CALL xrAttachSessionActionSets(XrSession session, const XrSessionActionSetsAttachInfo *attachInfo); @@ -6001,6 +7378,8 @@ XrResult XRAPI_CALL xrBeginFrame(XrSession session, const XrFrameBeginInfo *fram XrResult XRAPI_CALL xrBeginPlaneDetectionEXT(XrPlaneDetectorEXT planeDetector, const XrPlaneDetectorBeginInfoEXT *beginInfo); XrResult XRAPI_CALL xrBeginSession(XrSession session, const XrSessionBeginInfo *beginInfo); XrResult XRAPI_CALL xrCancelFutureEXT(XrInstance instance, const XrFutureCancelInfoEXT *cancelInfo); +XrResult XRAPI_CALL xrCaptureSceneAsyncBD(XrSenseDataProviderBD provider, const XrSceneCaptureInfoBD *info, XrFutureEXT *future); +XrResult XRAPI_CALL xrCaptureSceneCompleteBD(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT *completion); XrResult XRAPI_CALL xrChangeVirtualKeyboardTextContextMETA(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardTextContextChangeInfoMETA *changeInfo); XrResult XRAPI_CALL xrClearSpatialAnchorStoreMSFT(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore); XrResult XRAPI_CALL xrComputeNewSceneMSFT(XrSceneObserverMSFT sceneObserver, const XrNewSceneComputeInfoMSFT *computeInfo); @@ -6009,14 +7388,18 @@ XrResult XRAPI_CALL xrConvertWin32PerformanceCounterToTimeKHR(XrInstance instanc XrResult XRAPI_CALL xrCreateAction(XrActionSet actionSet, const XrActionCreateInfo *createInfo, XrAction *action); XrResult XRAPI_CALL xrCreateActionSet(XrInstance instance, const XrActionSetCreateInfo *createInfo, XrActionSet *actionSet); XrResult XRAPI_CALL xrCreateActionSpace(XrSession session, const XrActionSpaceCreateInfo *createInfo, XrSpace *space); +XrResult XRAPI_CALL xrCreateAnchorSpaceBD(XrSession session, const XrAnchorSpaceCreateInfoBD *createInfo, XrSpace *space); XrResult XRAPI_CALL xrCreateApiLayerInstance(const XrInstanceCreateInfo *info, const XrApiLayerCreateInfo *layerInfo, XrInstance *instance); +XrResult XRAPI_CALL xrCreateBodyTrackerBD(XrSession session, const XrBodyTrackerCreateInfoBD *createInfo, XrBodyTrackerBD *bodyTracker); XrResult XRAPI_CALL xrCreateBodyTrackerFB(XrSession session, const XrBodyTrackerCreateInfoFB *createInfo, XrBodyTrackerFB *bodyTracker); +XrResult XRAPI_CALL xrCreateBodyTrackerHTC(XrSession session, const XrBodyTrackerCreateInfoHTC *createInfo, XrBodyTrackerHTC *bodyTracker); XrResult XRAPI_CALL xrCreateEnvironmentDepthProviderMETA(XrSession session, const XrEnvironmentDepthProviderCreateInfoMETA *createInfo, XrEnvironmentDepthProviderMETA *environmentDepthProvider); XrResult XRAPI_CALL xrCreateEnvironmentDepthSwapchainMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider, const XrEnvironmentDepthSwapchainCreateInfoMETA *createInfo, XrEnvironmentDepthSwapchainMETA *swapchain); XrResult XRAPI_CALL xrCreateExportedLocalizationMapML(XrSession session, const XrUuidEXT *mapUuid, XrExportedLocalizationMapML *map); XrResult XRAPI_CALL xrCreateEyeTrackerFB(XrSession session, const XrEyeTrackerCreateInfoFB *createInfo, XrEyeTrackerFB *eyeTracker); XrResult XRAPI_CALL xrCreateFaceTracker2FB(XrSession session, const XrFaceTrackerCreateInfo2FB *createInfo, XrFaceTracker2FB *faceTracker); XrResult XRAPI_CALL xrCreateFaceTrackerFB(XrSession session, const XrFaceTrackerCreateInfoFB *createInfo, XrFaceTrackerFB *faceTracker); +XrResult XRAPI_CALL xrCreateFacialExpressionClientML(XrSession session, const XrFacialExpressionClientCreateInfoML *createInfo, XrFacialExpressionClientML *facialExpressionClient); XrResult XRAPI_CALL xrCreateFacialTrackerHTC(XrSession session, const XrFacialTrackerCreateInfoHTC *createInfo, XrFacialTrackerHTC *facialTracker); XrResult XRAPI_CALL xrCreateFoveationProfileFB(XrSession session, const XrFoveationProfileCreateInfoFB *createInfo, XrFoveationProfileFB *profile); XrResult XRAPI_CALL xrCreateGeometryInstanceFB(XrSession session, const XrGeometryInstanceCreateInfoFB *createInfo, XrGeometryInstanceFB *outGeometryInstance); @@ -6035,14 +7418,21 @@ XrResult XRAPI_CALL xrCreatePlaneDetectorEXT(XrSession session, const XrPlaneDet XrResult XRAPI_CALL xrCreateReferenceSpace(XrSession session, const XrReferenceSpaceCreateInfo *createInfo, XrSpace *space); XrResult XRAPI_CALL xrCreateSceneMSFT(XrSceneObserverMSFT sceneObserver, const XrSceneCreateInfoMSFT *createInfo, XrSceneMSFT *scene); XrResult XRAPI_CALL xrCreateSceneObserverMSFT(XrSession session, const XrSceneObserverCreateInfoMSFT *createInfo, XrSceneObserverMSFT *sceneObserver); +XrResult XRAPI_CALL xrCreateSenseDataProviderBD(XrSession session, const XrSenseDataProviderCreateInfoBD *createInfo, XrSenseDataProviderBD *provider); XrResult XRAPI_CALL xrCreateSession(XrInstance instance, const XrSessionCreateInfo *createInfo, XrSession *session); XrResult XRAPI_CALL xrCreateSpaceUserFB(XrSession session, const XrSpaceUserCreateInfoFB *info, XrSpaceUserFB *user); +XrResult XRAPI_CALL xrCreateSpatialAnchorAsyncBD(XrSenseDataProviderBD provider, const XrSpatialAnchorCreateInfoBD *info, XrFutureEXT *future); +XrResult XRAPI_CALL xrCreateSpatialAnchorCompleteBD(XrSenseDataProviderBD provider, XrFutureEXT future, XrSpatialAnchorCreateCompletionBD *completion); XrResult XRAPI_CALL xrCreateSpatialAnchorFB(XrSession session, const XrSpatialAnchorCreateInfoFB *info, XrAsyncRequestIdFB *requestId); XrResult XRAPI_CALL xrCreateSpatialAnchorFromPersistedNameMSFT(XrSession session, const XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT *spatialAnchorCreateInfo, XrSpatialAnchorMSFT *spatialAnchor); XrResult XRAPI_CALL xrCreateSpatialAnchorHTC(XrSession session, const XrSpatialAnchorCreateInfoHTC *createInfo, XrSpace *anchor); XrResult XRAPI_CALL xrCreateSpatialAnchorMSFT(XrSession session, const XrSpatialAnchorCreateInfoMSFT *createInfo, XrSpatialAnchorMSFT *anchor); XrResult XRAPI_CALL xrCreateSpatialAnchorSpaceMSFT(XrSession session, const XrSpatialAnchorSpaceCreateInfoMSFT *createInfo, XrSpace *space); XrResult XRAPI_CALL xrCreateSpatialAnchorStoreConnectionMSFT(XrSession session, XrSpatialAnchorStoreConnectionMSFT *spatialAnchorStore); +XrResult XRAPI_CALL xrCreateSpatialAnchorsAsyncML(XrSession session, const XrSpatialAnchorsCreateInfoBaseHeaderML *createInfo, XrFutureEXT *future); +XrResult XRAPI_CALL xrCreateSpatialAnchorsCompleteML(XrSession session, XrFutureEXT future, XrCreateSpatialAnchorsCompletionML *completion); +XrResult XRAPI_CALL xrCreateSpatialAnchorsStorageML(XrSession session, const XrSpatialAnchorsCreateStorageInfoML *createInfo, XrSpatialAnchorsStorageML *storage); +XrResult XRAPI_CALL xrCreateSpatialEntityAnchorBD(XrSenseDataProviderBD provider, const XrSpatialEntityAnchorCreateInfoBD *createInfo, XrAnchorBD *anchor); XrResult XRAPI_CALL xrCreateSpatialGraphNodeSpaceMSFT(XrSession session, const XrSpatialGraphNodeSpaceCreateInfoMSFT *createInfo, XrSpace *space); XrResult XRAPI_CALL xrCreateSwapchain(XrSession session, const XrSwapchainCreateInfo *createInfo, XrSwapchain *swapchain); XrResult XRAPI_CALL xrCreateTriangleMeshFB(XrSession session, const XrTriangleMeshCreateInfoFB *createInfo, XrTriangleMeshFB *outTriangleMesh); @@ -6050,16 +7440,23 @@ XrResult XRAPI_CALL xrCreateVirtualKeyboardMETA(XrSession session, const XrVirtu XrResult XRAPI_CALL xrCreateVirtualKeyboardSpaceMETA(XrSession session, XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardSpaceCreateInfoMETA *createInfo, XrSpace *keyboardSpace); XrResult XRAPI_CALL xrCreateVulkanDeviceKHR(XrInstance instance, const XrVulkanDeviceCreateInfoKHR *createInfo, VkDevice *vulkanDevice, VkResult *vulkanResult); XrResult XRAPI_CALL xrCreateVulkanInstanceKHR(XrInstance instance, const XrVulkanInstanceCreateInfoKHR *createInfo, VkInstance *vulkanInstance, VkResult *vulkanResult); +XrResult XRAPI_CALL xrCreateWorldMeshDetectorML(XrSession session, const XrWorldMeshDetectorCreateInfoML *createInfo, XrWorldMeshDetectorML *detector); +XrResult XRAPI_CALL xrDeleteSpatialAnchorsAsyncML(XrSpatialAnchorsStorageML storage, const XrSpatialAnchorsDeleteInfoML *deleteInfo, XrFutureEXT *future); +XrResult XRAPI_CALL xrDeleteSpatialAnchorsCompleteML(XrSpatialAnchorsStorageML storage, XrFutureEXT future, XrSpatialAnchorsDeleteCompletionML *completion); XrResult XRAPI_CALL xrDeserializeSceneMSFT(XrSceneObserverMSFT sceneObserver, const XrSceneDeserializeInfoMSFT *deserializeInfo); XrResult XRAPI_CALL xrDestroyAction(XrAction action); XrResult XRAPI_CALL xrDestroyActionSet(XrActionSet actionSet); +XrResult XRAPI_CALL xrDestroyAnchorBD(XrAnchorBD anchor); +XrResult XRAPI_CALL xrDestroyBodyTrackerBD(XrBodyTrackerBD bodyTracker); XrResult XRAPI_CALL xrDestroyBodyTrackerFB(XrBodyTrackerFB bodyTracker); +XrResult XRAPI_CALL xrDestroyBodyTrackerHTC(XrBodyTrackerHTC bodyTracker); XrResult XRAPI_CALL xrDestroyEnvironmentDepthProviderMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider); XrResult XRAPI_CALL xrDestroyEnvironmentDepthSwapchainMETA(XrEnvironmentDepthSwapchainMETA swapchain); XrResult XRAPI_CALL xrDestroyExportedLocalizationMapML(XrExportedLocalizationMapML map); XrResult XRAPI_CALL xrDestroyEyeTrackerFB(XrEyeTrackerFB eyeTracker); XrResult XRAPI_CALL xrDestroyFaceTracker2FB(XrFaceTracker2FB faceTracker); XrResult XRAPI_CALL xrDestroyFaceTrackerFB(XrFaceTrackerFB faceTracker); +XrResult XRAPI_CALL xrDestroyFacialExpressionClientML(XrFacialExpressionClientML facialExpressionClient); XrResult XRAPI_CALL xrDestroyFacialTrackerHTC(XrFacialTrackerHTC facialTracker); XrResult XRAPI_CALL xrDestroyFoveationProfileFB(XrFoveationProfileFB profile); XrResult XRAPI_CALL xrDestroyGeometryInstanceFB(XrGeometryInstanceFB instance); @@ -6073,15 +7470,21 @@ XrResult XRAPI_CALL xrDestroyPassthroughLayerFB(XrPassthroughLayerFB layer); XrResult XRAPI_CALL xrDestroyPlaneDetectorEXT(XrPlaneDetectorEXT planeDetector); XrResult XRAPI_CALL xrDestroySceneMSFT(XrSceneMSFT scene); XrResult XRAPI_CALL xrDestroySceneObserverMSFT(XrSceneObserverMSFT sceneObserver); +XrResult XRAPI_CALL xrDestroySenseDataProviderBD(XrSenseDataProviderBD provider); +XrResult XRAPI_CALL xrDestroySenseDataSnapshotBD(XrSenseDataSnapshotBD snapshot); XrResult XRAPI_CALL xrDestroySession(XrSession session); XrResult XRAPI_CALL xrDestroySpace(XrSpace space); XrResult XRAPI_CALL xrDestroySpaceUserFB(XrSpaceUserFB user); XrResult XRAPI_CALL xrDestroySpatialAnchorMSFT(XrSpatialAnchorMSFT anchor); XrResult XRAPI_CALL xrDestroySpatialAnchorStoreConnectionMSFT(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore); +XrResult XRAPI_CALL xrDestroySpatialAnchorsStorageML(XrSpatialAnchorsStorageML storage); XrResult XRAPI_CALL xrDestroySpatialGraphNodeBindingMSFT(XrSpatialGraphNodeBindingMSFT nodeBinding); XrResult XRAPI_CALL xrDestroySwapchain(XrSwapchain swapchain); XrResult XRAPI_CALL xrDestroyTriangleMeshFB(XrTriangleMeshFB mesh); XrResult XRAPI_CALL xrDestroyVirtualKeyboardMETA(XrVirtualKeyboardMETA keyboard); +XrResult XRAPI_CALL xrDestroyWorldMeshDetectorML(XrWorldMeshDetectorML detector); +XrResult XRAPI_CALL xrDownloadSharedSpatialAnchorAsyncBD(XrSenseDataProviderBD provider, const XrSharedSpatialAnchorDownloadInfoBD *info, XrFutureEXT *future); +XrResult XRAPI_CALL xrDownloadSharedSpatialAnchorCompleteBD(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT *completion); XrResult XRAPI_CALL xrEnableLocalizationEventsML(XrSession session, const XrLocalizationEnableEventsInfoML *info); XrResult XRAPI_CALL xrEnableUserCalibrationEventsML(XrInstance instance, const XrUserCalibrationEnableEventsInfoML *enableInfo); XrResult XRAPI_CALL xrEndFrame(XrSession session, const XrFrameEndInfo *frameEndInfo); @@ -6101,20 +7504,24 @@ XrResult XRAPI_CALL xrEnumerateRenderModelPathsFB(XrSession session, uint32_t pa XrResult XRAPI_CALL xrEnumerateReprojectionModesMSFT(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, uint32_t modeCapacityInput, uint32_t *modeCountOutput, XrReprojectionModeMSFT *modes); XrResult XRAPI_CALL xrEnumerateSceneComputeFeaturesMSFT(XrInstance instance, XrSystemId systemId, uint32_t featureCapacityInput, uint32_t *featureCountOutput, XrSceneComputeFeatureMSFT *features); XrResult XRAPI_CALL xrEnumerateSpaceSupportedComponentsFB(XrSpace space, uint32_t componentTypeCapacityInput, uint32_t *componentTypeCountOutput, XrSpaceComponentTypeFB *componentTypes); +XrResult XRAPI_CALL xrEnumerateSpatialEntityComponentTypesBD(XrSenseDataSnapshotBD snapshot, XrSpatialEntityIdBD entityId, uint32_t componentTypeCapacityInput, uint32_t *componentTypeCountOutput, XrSpatialEntityComponentTypeBD *componentTypes); XrResult XRAPI_CALL xrEnumerateSwapchainFormats(XrSession session, uint32_t formatCapacityInput, uint32_t *formatCountOutput, int64_t *formats); XrResult XRAPI_CALL xrEnumerateSwapchainImages(XrSwapchain swapchain, uint32_t imageCapacityInput, uint32_t *imageCountOutput, XrSwapchainImageBaseHeader *images); XrResult XRAPI_CALL xrEnumerateViewConfigurationViews(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, uint32_t viewCapacityInput, uint32_t *viewCountOutput, XrViewConfigurationView *views); XrResult XRAPI_CALL xrEnumerateViewConfigurations(XrInstance instance, XrSystemId systemId, uint32_t viewConfigurationTypeCapacityInput, uint32_t *viewConfigurationTypeCountOutput, XrViewConfigurationType *viewConfigurationTypes); XrResult XRAPI_CALL xrEnumerateViveTrackerPathsHTCX(XrInstance instance, uint32_t pathCapacityInput, uint32_t *pathCountOutput, XrViveTrackerPathsHTCX *paths); XrResult XRAPI_CALL xrEraseSpaceFB(XrSession session, const XrSpaceEraseInfoFB *info, XrAsyncRequestIdFB *requestId); +XrResult XRAPI_CALL xrFreeWorldMeshBufferML(XrWorldMeshDetectorML detector, const XrWorldMeshBufferML *buffer); XrResult XRAPI_CALL xrGeometryInstanceSetTransformFB(XrGeometryInstanceFB instance, const XrGeometryInstanceTransformFB *transformation); XrResult XRAPI_CALL xrGetActionStateBoolean(XrSession session, const XrActionStateGetInfo *getInfo, XrActionStateBoolean *state); XrResult XRAPI_CALL xrGetActionStateFloat(XrSession session, const XrActionStateGetInfo *getInfo, XrActionStateFloat *state); XrResult XRAPI_CALL xrGetActionStatePose(XrSession session, const XrActionStateGetInfo *getInfo, XrActionStatePose *state); XrResult XRAPI_CALL xrGetActionStateVector2f(XrSession session, const XrActionStateGetInfo *getInfo, XrActionStateVector2f *state); +XrResult XRAPI_CALL xrGetAnchorUuidBD(XrAnchorBD anchor, XrUuidEXT *uuid); XrResult XRAPI_CALL xrGetAudioInputDeviceGuidOculus(XrInstance instance, wchar_t buffer[]); XrResult XRAPI_CALL xrGetAudioOutputDeviceGuidOculus(XrInstance instance, wchar_t buffer[]); XrResult XRAPI_CALL xrGetBodySkeletonFB(XrBodyTrackerFB bodyTracker, XrBodySkeletonFB *skeleton); +XrResult XRAPI_CALL xrGetBodySkeletonHTC(XrBodyTrackerHTC bodyTracker, XrSpace baseSpace, uint32_t skeletonGenerationId, XrBodySkeletonHTC *skeleton); XrResult XRAPI_CALL xrGetControllerModelKeyMSFT(XrSession session, XrPath topLevelUserPath, XrControllerModelKeyStateMSFT *controllerModelKeyState); XrResult XRAPI_CALL xrGetControllerModelPropertiesMSFT(XrSession session, XrControllerModelKeyMSFT modelKey, XrControllerModelPropertiesMSFT *properties); XrResult XRAPI_CALL xrGetControllerModelStateMSFT(XrSession session, XrControllerModelKeyMSFT modelKey, XrControllerModelStateMSFT *state); @@ -6128,6 +7535,7 @@ XrResult XRAPI_CALL xrGetExportedLocalizationMapDataML(XrExportedLocalizationMap XrResult XRAPI_CALL xrGetEyeGazesFB(XrEyeTrackerFB eyeTracker, const XrEyeGazesInfoFB *gazeInfo, XrEyeGazesFB *eyeGazes); XrResult XRAPI_CALL xrGetFaceExpressionWeights2FB(XrFaceTracker2FB faceTracker, const XrFaceExpressionInfo2FB *expressionInfo, XrFaceExpressionWeights2FB *expressionWeights); XrResult XRAPI_CALL xrGetFaceExpressionWeightsFB(XrFaceTrackerFB faceTracker, const XrFaceExpressionInfoFB *expressionInfo, XrFaceExpressionWeightsFB *expressionWeights); +XrResult XRAPI_CALL xrGetFacialExpressionBlendShapePropertiesML(XrFacialExpressionClientML facialExpressionClient, const XrFacialExpressionBlendShapeGetInfoML *blendShapeGetInfo, uint32_t blendShapeCount, XrFacialExpressionBlendShapePropertiesML *blendShapes); XrResult XRAPI_CALL xrGetFacialExpressionsHTC(XrFacialTrackerHTC facialTracker, XrFacialExpressionsHTC *facialExpressions); XrResult XRAPI_CALL xrGetFoveationEyeTrackedStateMETA(XrSession session, XrFoveationEyeTrackedStateMETA *foveationState); XrResult XRAPI_CALL xrGetHandMeshFB(XrHandTrackerEXT handTracker, XrHandTrackingMeshFB *mesh); @@ -6147,6 +7555,7 @@ XrResult XRAPI_CALL xrGetPerformanceMetricsStateMETA(XrSession session, XrPerfor XrResult XRAPI_CALL xrGetPlaneDetectionStateEXT(XrPlaneDetectorEXT planeDetector, XrPlaneDetectionStateEXT *state); XrResult XRAPI_CALL xrGetPlaneDetectionsEXT(XrPlaneDetectorEXT planeDetector, const XrPlaneDetectorGetInfoEXT *info, XrPlaneDetectorLocationsEXT *locations); XrResult XRAPI_CALL xrGetPlanePolygonBufferEXT(XrPlaneDetectorEXT planeDetector, uint64_t planeId, uint32_t polygonBufferIndex, XrPlaneDetectorPolygonBufferEXT *polygonBuffer); +XrResult XRAPI_CALL xrGetQueriedSenseDataBD(XrSenseDataSnapshotBD snapshot, XrQueriedSenseDataGetInfoBD *getInfo, XrQueriedSenseDataBD *queriedSenseData); XrResult XRAPI_CALL xrGetRecommendedLayerResolutionMETA(XrSession session, const XrRecommendedLayerResolutionGetInfoMETA *info, XrRecommendedLayerResolutionMETA *resolution); XrResult XRAPI_CALL xrGetReferenceSpaceBoundsRect(XrSession session, XrReferenceSpaceType referenceSpaceType, XrExtent2Df *bounds); XrResult XRAPI_CALL xrGetRenderModelPropertiesFB(XrSession session, XrPath path, XrRenderModelPropertiesFB *properties); @@ -6155,6 +7564,7 @@ XrResult XRAPI_CALL xrGetSceneComputeStateMSFT(XrSceneObserverMSFT sceneObserver XrResult XRAPI_CALL xrGetSceneMarkerDecodedStringMSFT(XrSceneMSFT scene, const XrUuidMSFT *markerId, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer); XrResult XRAPI_CALL xrGetSceneMarkerRawDataMSFT(XrSceneMSFT scene, const XrUuidMSFT *markerId, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, uint8_t *buffer); XrResult XRAPI_CALL xrGetSceneMeshBuffersMSFT(XrSceneMSFT scene, const XrSceneMeshBuffersGetInfoMSFT *getInfo, XrSceneMeshBuffersMSFT *buffers); +XrResult XRAPI_CALL xrGetSenseDataProviderStateBD(XrSenseDataProviderBD provider, XrSenseDataProviderStateBD *state); XrResult XRAPI_CALL xrGetSerializedSceneFragmentDataMSFT(XrSceneMSFT scene, const XrSerializedSceneFragmentDataGetInfoMSFT *getInfo, uint32_t countInput, uint32_t *readOutput, uint8_t *buffer); XrResult XRAPI_CALL xrGetSpaceBoundary2DFB(XrSession session, XrSpace space, XrBoundary2DFB *boundary2DOutput); XrResult XRAPI_CALL xrGetSpaceBoundingBox2DFB(XrSession session, XrSpace space, XrRect2Df *boundingBox2DOutput); @@ -6167,6 +7577,9 @@ XrResult XRAPI_CALL xrGetSpaceTriangleMeshMETA(XrSpace space, const XrSpaceTrian XrResult XRAPI_CALL xrGetSpaceUserIdFB(XrSpaceUserFB user, XrSpaceUserIdFB *userId); XrResult XRAPI_CALL xrGetSpaceUuidFB(XrSpace space, XrUuidEXT *uuid); XrResult XRAPI_CALL xrGetSpatialAnchorNameHTC(XrSpace anchor, XrSpatialAnchorNameHTC *name); +XrResult XRAPI_CALL xrGetSpatialAnchorStateML(XrSpace anchor, XrSpatialAnchorStateML *state); +XrResult XRAPI_CALL xrGetSpatialEntityComponentDataBD(XrSenseDataSnapshotBD snapshot, const XrSpatialEntityComponentGetInfoBD *getInfo, XrSpatialEntityComponentDataBaseHeaderBD *componentData); +XrResult XRAPI_CALL xrGetSpatialEntityUuidBD(XrSenseDataSnapshotBD snapshot, XrSpatialEntityIdBD entityId, XrUuidEXT *uuid); XrResult XRAPI_CALL xrGetSpatialGraphNodeBindingPropertiesMSFT(XrSpatialGraphNodeBindingMSFT nodeBinding, const XrSpatialGraphNodeBindingPropertiesGetInfoMSFT *getInfo, XrSpatialGraphNodeBindingPropertiesMSFT *properties); XrResult XRAPI_CALL xrGetSwapchainStateFB(XrSwapchain swapchain, XrSwapchainStateBaseHeaderFB *state); XrResult XRAPI_CALL xrGetSystem(XrInstance instance, const XrSystemGetInfo *getInfo, XrSystemId *systemId); @@ -6183,10 +7596,13 @@ XrResult XRAPI_CALL xrGetVulkanGraphicsDeviceKHR(XrInstance instance, XrSystemId XrResult XRAPI_CALL xrGetVulkanGraphicsRequirements2KHR(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsVulkanKHR *graphicsRequirements); XrResult XRAPI_CALL xrGetVulkanGraphicsRequirementsKHR(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsVulkanKHR *graphicsRequirements); XrResult XRAPI_CALL xrGetVulkanInstanceExtensionsKHR(XrInstance instance, XrSystemId systemId, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer); +XrResult XRAPI_CALL xrGetWorldMeshBufferRecommendSizeML(XrWorldMeshDetectorML detector, const XrWorldMeshBufferRecommendedSizeInfoML *sizeInfo, XrWorldMeshBufferSizeML *size); XrResult XRAPI_CALL xrImportLocalizationMapML(XrSession session, const XrLocalizationMapImportInfoML *importInfo, XrUuidEXT *mapUuid); XrResult XRAPI_CALL xrLoadControllerModelMSFT(XrSession session, XrControllerModelKeyMSFT modelKey, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, uint8_t *buffer); XrResult XRAPI_CALL xrLoadRenderModelFB(XrSession session, const XrRenderModelLoadInfoFB *info, XrRenderModelBufferFB *buffer); +XrResult XRAPI_CALL xrLocateBodyJointsBD(XrBodyTrackerBD bodyTracker, const XrBodyJointsLocateInfoBD *locateInfo, XrBodyJointLocationsBD *locations); XrResult XRAPI_CALL xrLocateBodyJointsFB(XrBodyTrackerFB bodyTracker, const XrBodyJointsLocateInfoFB *locateInfo, XrBodyJointLocationsFB *locations); +XrResult XRAPI_CALL xrLocateBodyJointsHTC(XrBodyTrackerHTC bodyTracker, const XrBodyJointsLocateInfoHTC *locateInfo, XrBodyJointLocationsHTC *locations); XrResult XRAPI_CALL xrLocateHandJointsEXT(XrHandTrackerEXT handTracker, const XrHandJointsLocateInfoEXT *locateInfo, XrHandJointLocationsEXT *locations); XrResult XRAPI_CALL xrLocateSceneComponentsMSFT(XrSceneMSFT scene, const XrSceneComponentsLocateInfoMSFT *locateInfo, XrSceneComponentLocationsMSFT *locations); XrResult XRAPI_CALL xrLocateSpace(XrSpace space, XrSpace baseSpace, XrTime time, XrSpaceLocation *location); @@ -6203,18 +7619,30 @@ XrResult XRAPI_CALL xrPassthroughPauseFB(XrPassthroughFB passthrough); XrResult XRAPI_CALL xrPassthroughStartFB(XrPassthroughFB passthrough); XrResult XRAPI_CALL xrPathToString(XrInstance instance, XrPath path, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer); XrResult XRAPI_CALL xrPerfSettingsSetPerformanceLevelEXT(XrSession session, XrPerfSettingsDomainEXT domain, XrPerfSettingsLevelEXT level); +XrResult XRAPI_CALL xrPersistSpatialAnchorAsyncBD(XrSenseDataProviderBD provider, const XrSpatialAnchorPersistInfoBD *info, XrFutureEXT *future); +XrResult XRAPI_CALL xrPersistSpatialAnchorCompleteBD(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT *completion); XrResult XRAPI_CALL xrPersistSpatialAnchorMSFT(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, const XrSpatialAnchorPersistenceInfoMSFT *spatialAnchorPersistenceInfo); XrResult XRAPI_CALL xrPollEvent(XrInstance instance, XrEventDataBuffer *eventData); XrResult XRAPI_CALL xrPollFutureEXT(XrInstance instance, const XrFuturePollInfoEXT *pollInfo, XrFuturePollResultEXT *pollResult); +XrResult XRAPI_CALL xrPublishSpatialAnchorsAsyncML(XrSpatialAnchorsStorageML storage, const XrSpatialAnchorsPublishInfoML *publishInfo, XrFutureEXT *future); +XrResult XRAPI_CALL xrPublishSpatialAnchorsCompleteML(XrSpatialAnchorsStorageML storage, XrFutureEXT future, XrSpatialAnchorsPublishCompletionML *completion); XrResult XRAPI_CALL xrQueryLocalizationMapsML(XrSession session, const XrLocalizationMapQueryInfoBaseHeaderML *queryInfo, uint32_t mapCapacityInput, uint32_t *mapCountOutput, XrLocalizationMapML *maps); XrResult XRAPI_CALL xrQueryPerformanceMetricsCounterMETA(XrSession session, XrPath counterPath, XrPerformanceMetricsCounterMETA *counter); +XrResult XRAPI_CALL xrQuerySenseDataAsyncBD(XrSenseDataProviderBD provider, const XrSenseDataQueryInfoBD *queryInfo, XrFutureEXT *future); +XrResult XRAPI_CALL xrQuerySenseDataCompleteBD(XrSenseDataProviderBD provider, XrFutureEXT future, XrSenseDataQueryCompletionBD *completion); XrResult XRAPI_CALL xrQuerySpacesFB(XrSession session, const XrSpaceQueryInfoBaseHeaderFB *info, XrAsyncRequestIdFB *requestId); +XrResult XRAPI_CALL xrQuerySpatialAnchorsAsyncML(XrSpatialAnchorsStorageML storage, const XrSpatialAnchorsQueryInfoBaseHeaderML *queryInfo, XrFutureEXT *future); +XrResult XRAPI_CALL xrQuerySpatialAnchorsCompleteML(XrSpatialAnchorsStorageML storage, XrFutureEXT future, XrSpatialAnchorsQueryCompletionML *completion); XrResult XRAPI_CALL xrQuerySystemTrackedKeyboardFB(XrSession session, const XrKeyboardTrackingQueryFB *queryInfo, XrKeyboardTrackingDescriptionFB *keyboard); XrResult XRAPI_CALL xrReleaseSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageReleaseInfo *releaseInfo); XrResult XRAPI_CALL xrRequestDisplayRefreshRateFB(XrSession session, float displayRefreshRate); XrResult XRAPI_CALL xrRequestExitSession(XrSession session); XrResult XRAPI_CALL xrRequestMapLocalizationML(XrSession session, const XrMapLocalizationRequestInfoML *requestInfo); XrResult XRAPI_CALL xrRequestSceneCaptureFB(XrSession session, const XrSceneCaptureRequestInfoFB *info, XrAsyncRequestIdFB *requestId); +XrResult XRAPI_CALL xrRequestWorldMeshAsyncML(XrWorldMeshDetectorML detector, const XrWorldMeshGetInfoML *getInfo, XrWorldMeshBufferML *buffer, XrFutureEXT *future); +XrResult XRAPI_CALL xrRequestWorldMeshCompleteML(XrWorldMeshDetectorML detector, const XrWorldMeshRequestCompletionInfoML *completionInfo, XrFutureEXT future, XrWorldMeshRequestCompletionML *completion); +XrResult XRAPI_CALL xrRequestWorldMeshStateAsyncML(XrWorldMeshDetectorML detector, const XrWorldMeshStateRequestInfoML *stateRequest, XrFutureEXT *future); +XrResult XRAPI_CALL xrRequestWorldMeshStateCompleteML(XrWorldMeshDetectorML detector, XrFutureEXT future, XrWorldMeshStateRequestCompletionML *completion); XrResult XRAPI_CALL xrResultToString(XrInstance instance, XrResult value, char buffer[]); XrResult XRAPI_CALL xrRetrieveSpaceQueryResultsFB(XrSession session, XrAsyncRequestIdFB requestId, XrSpaceQueryResultsFB *results); XrResult XRAPI_CALL xrSaveSpaceFB(XrSession session, const XrSpaceSaveInfoFB *info, XrAsyncRequestIdFB *requestId); @@ -6234,16 +7662,28 @@ XrResult XRAPI_CALL xrSetMarkerTrackingTimeoutVARJO(XrSession session, uint64_t XrResult XRAPI_CALL xrSetMarkerTrackingVARJO(XrSession session, XrBool32 enabled); XrResult XRAPI_CALL xrSetPerformanceMetricsStateMETA(XrSession session, const XrPerformanceMetricsStateMETA *state); XrResult XRAPI_CALL xrSetSpaceComponentStatusFB(XrSpace space, const XrSpaceComponentStatusSetInfoFB *info, XrAsyncRequestIdFB *requestId); +XrResult XRAPI_CALL xrSetSystemNotificationsML(XrInstance instance, const XrSystemNotificationsSetInfoML *info); XrResult XRAPI_CALL xrSetTrackingOptimizationSettingsHintQCOM(XrSession session, XrTrackingOptimizationSettingsDomainQCOM domain, XrTrackingOptimizationSettingsHintQCOM hint); XrResult XRAPI_CALL xrSetViewOffsetVARJO(XrSession session, float offset); XrResult XRAPI_CALL xrSetVirtualKeyboardModelVisibilityMETA(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardModelVisibilitySetInfoMETA *modelVisibility); XrResult XRAPI_CALL xrShareSpacesFB(XrSession session, const XrSpaceShareInfoFB *info, XrAsyncRequestIdFB *requestId); +XrResult XRAPI_CALL xrShareSpacesMETA(XrSession session, const XrShareSpacesInfoMETA *info, XrAsyncRequestIdFB *requestId); +XrResult XRAPI_CALL xrShareSpatialAnchorAsyncBD(XrSenseDataProviderBD provider, const XrSpatialAnchorShareInfoBD *info, XrFutureEXT *future); +XrResult XRAPI_CALL xrShareSpatialAnchorCompleteBD(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT *completion); XrResult XRAPI_CALL xrSnapshotMarkerDetectorML(XrMarkerDetectorML markerDetector, XrMarkerDetectorSnapshotInfoML *snapshotInfo); +XrResult XRAPI_CALL xrStartColocationAdvertisementMETA(XrSession session, const XrColocationAdvertisementStartInfoMETA *info, XrAsyncRequestIdFB *advertisementRequestId); +XrResult XRAPI_CALL xrStartColocationDiscoveryMETA(XrSession session, const XrColocationDiscoveryStartInfoMETA *info, XrAsyncRequestIdFB *discoveryRequestId); XrResult XRAPI_CALL xrStartEnvironmentDepthProviderMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider); +XrResult XRAPI_CALL xrStartSenseDataProviderAsyncBD(XrSenseDataProviderBD provider, const XrSenseDataProviderStartInfoBD *startInfo, XrFutureEXT *future); +XrResult XRAPI_CALL xrStartSenseDataProviderCompleteBD(XrSession session, XrFutureEXT future, XrFutureCompletionEXT *completion); +XrResult XRAPI_CALL xrStopColocationAdvertisementMETA(XrSession session, const XrColocationAdvertisementStopInfoMETA *info, XrAsyncRequestIdFB *requestId); +XrResult XRAPI_CALL xrStopColocationDiscoveryMETA(XrSession session, const XrColocationDiscoveryStopInfoMETA *info, XrAsyncRequestIdFB *requestId); XrResult XRAPI_CALL xrStopEnvironmentDepthProviderMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider); XrResult XRAPI_CALL xrStopHapticFeedback(XrSession session, const XrHapticActionInfo *hapticActionInfo); +XrResult XRAPI_CALL xrStopSenseDataProviderBD(XrSenseDataProviderBD provider); XrResult XRAPI_CALL xrStringToPath(XrInstance instance, const char *pathString, XrPath *path); XrResult XRAPI_CALL xrStructureTypeToString(XrInstance instance, XrStructureType value, char buffer[]); +XrResult XRAPI_CALL xrStructureTypeToString2KHR(XrInstance instance, XrStructureType value, char buffer[]); XrResult XRAPI_CALL xrSuggestInteractionProfileBindings(XrInstance instance, const XrInteractionProfileSuggestedBinding *suggestedBindings); XrResult XRAPI_CALL xrSuggestVirtualKeyboardLocationMETA(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardLocationInfoMETA *locationInfo); XrResult XRAPI_CALL xrSyncActions(XrSession session, const XrActionsSyncInfo *syncInfo); @@ -6255,9 +7695,13 @@ XrResult XRAPI_CALL xrTriangleMeshEndVertexBufferUpdateFB(XrTriangleMeshFB mesh) XrResult XRAPI_CALL xrTriangleMeshGetIndexBufferFB(XrTriangleMeshFB mesh, uint32_t **outIndexBuffer); XrResult XRAPI_CALL xrTriangleMeshGetVertexBufferFB(XrTriangleMeshFB mesh, XrVector3f **outVertexBuffer); XrResult XRAPI_CALL xrTryCreateSpatialGraphStaticNodeBindingMSFT(XrSession session, const XrSpatialGraphStaticNodeBindingCreateInfoMSFT *createInfo, XrSpatialGraphNodeBindingMSFT *nodeBinding); +XrResult XRAPI_CALL xrUnpersistSpatialAnchorAsyncBD(XrSenseDataProviderBD provider, const XrSpatialAnchorUnpersistInfoBD *info, XrFutureEXT *future); +XrResult XRAPI_CALL xrUnpersistSpatialAnchorCompleteBD(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT *completion); XrResult XRAPI_CALL xrUnpersistSpatialAnchorMSFT(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, const XrSpatialAnchorPersistenceNameMSFT *spatialAnchorPersistenceName); XrResult XRAPI_CALL xrUpdateHandMeshMSFT(XrHandTrackerEXT handTracker, const XrHandMeshUpdateInfoMSFT *updateInfo, XrHandMeshMSFT *handMesh); XrResult XRAPI_CALL xrUpdatePassthroughColorLutMETA(XrPassthroughColorLutMETA colorLut, const XrPassthroughColorLutUpdateInfoMETA *updateInfo); +XrResult XRAPI_CALL xrUpdateSpatialAnchorsExpirationAsyncML(XrSpatialAnchorsStorageML storage, const XrSpatialAnchorsUpdateExpirationInfoML *updateInfo, XrFutureEXT *future); +XrResult XRAPI_CALL xrUpdateSpatialAnchorsExpirationCompleteML(XrSpatialAnchorsStorageML storage, XrFutureEXT future, XrSpatialAnchorsUpdateExpirationCompletionML *completion); XrResult XRAPI_CALL xrUpdateSwapchainFB(XrSwapchain swapchain, const XrSwapchainStateBaseHeaderFB *state); XrResult XRAPI_CALL xrWaitFrame(XrSession session, const XrFrameWaitInfo *frameWaitInfo, XrFrameState *frameState); XrResult XRAPI_CALL xrWaitSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageWaitInfo *waitInfo); diff --git a/wineopenxr/wineopenxr.json b/wineopenxr/wineopenxr.json index df5e15fe..bd125441 100644 --- a/wineopenxr/wineopenxr.json +++ b/wineopenxr/wineopenxr.json @@ -2,6 +2,6 @@ "file_format_version": "1.0.0", "ICD": { "library_path": ".\\wineopenxr.dll", - "api_version": "1.1.36" + "api_version": "1.1.47" } }