diff --git a/FEX b/FEX index 9681559d56e..4b02c04afce 160000 --- a/FEX +++ b/FEX @@ -1 +1 @@ -Subproject commit 9681559d56eee7eff5cd9232ca3b49ba419cb62b +Subproject commit 4b02c04afce5055234e212af206c08abd054375f diff --git a/Makefile.in b/Makefile.in index bdcf1da4c5b..b4cbe38d39a 100644 --- a/Makefile.in +++ b/Makefile.in @@ -1233,7 +1233,7 @@ all-dist: $(DIST_WINEMONO) ## xalia ## -XALIA_VER := 0.4.8 +XALIA_VER := 0.4.9 XALIA_ZIP := xalia-$(XALIA_VER)-net48-mono.zip DIST_XALIA_DIR := $(DST_DIR)/share/xalia DIST_XALIA := $(OBJ)/.xalia-dist diff --git a/dxvk b/dxvk index 83e503b4ae6..e3d3f69fe37 160000 --- a/dxvk +++ b/dxvk @@ -1 +1 @@ -Subproject commit 83e503b4ae6de849ed9d2633e76e5dc5fb12119a +Subproject commit e3d3f69fe3707a6c0b6886262d404f5af92b4b33 diff --git a/dxvk-nvapi b/dxvk-nvapi index c68c3507112..efb17dd4355 160000 --- a/dxvk-nvapi +++ b/dxvk-nvapi @@ -1 +1 @@ -Subproject commit c68c35071128c2bda31916c50080c07062f23fe6 +Subproject commit efb17dd43557d497af1f314a677cbf4807d657f5 diff --git a/proton b/proton index 40124a8175e..3bc26d828bb 100755 --- a/proton +++ b/proton @@ -35,6 +35,12 @@ from ctypes import c_void_p from ctypes import c_size_t from ctypes import c_ssize_t +# PYTHONSAFEPATH might be set, so add the script directory to the path for relative imports +try: + sys.path.insert(0, os.path.dirname(os.path.realpath(__file__))) +except NameError: + pass + from filelock import FileLock from random import randrange diff --git a/vkd3d b/vkd3d index 30b93dcea8b..fad7fcf2150 160000 --- a/vkd3d +++ b/vkd3d @@ -1 +1 @@ -Subproject commit 30b93dcea8b0597f7d964fafc907d3e9609a4651 +Subproject commit fad7fcf2150aa04c599e7553549710daeb06c356 diff --git a/vkd3d-proton b/vkd3d-proton index 0103de63b5d..004fe379bd2 160000 --- a/vkd3d-proton +++ b/vkd3d-proton @@ -1 +1 @@ -Subproject commit 0103de63b5d649d2e0947052789723adc893f601 +Subproject commit 004fe379bd2a5b27b1e8d0de22eb5652330cdb11 diff --git a/vrclient_x64/Makefile.in b/vrclient_x64/Makefile.in index dc7e885407c..80a4dd16076 100644 --- a/vrclient_x64/Makefile.in +++ b/vrclient_x64/Makefile.in @@ -13,6 +13,7 @@ EXTRADEFS = -DGNUC SOURCES = \ flatapi.c \ + vrapplications_manual.c \ vrclient_generated.c \ vrclient_main.c \ vrcompositor_manual.c \ diff --git a/vrclient_x64/gen_wrapper.py b/vrclient_x64/gen_wrapper.py index cad4cd0bbb6..89685324240 100755 --- a/vrclient_x64/gen_wrapper.py +++ b/vrclient_x64/gen_wrapper.py @@ -245,7 +245,7 @@ ] MANUAL_METHODS = { - "IVRApplications_LaunchInternalProcess": lambda ver, abi: abi == 'u', + "IVRApplications_LaunchInternalProcess": True, "IVRApplications_RegisterSubprocess": lambda ver, abi: abi == 'u', "IVRClientCore_BIsHmdPresent": lambda ver, abi: abi == 'w', "IVRClientCore_Init": lambda ver, abi: True, diff --git a/vrclient_x64/vrapplications_manual.c b/vrclient_x64/vrapplications_manual.c new file mode 100644 index 00000000000..c6bf3942d6c --- /dev/null +++ b/vrclient_x64/vrapplications_manual.c @@ -0,0 +1,120 @@ +#include "vrclient_private.h" +#include "winreg.h" + +WINE_DEFAULT_DEBUG_CHANNEL(vrclient); + +static BOOL launch_through_register_subprocess(struct w_iface *_this, const char *pchBinaryPath, const char *pchArguments, + const char *pchWorkingDirectory, uint32_t *ret) +{ + static struct u_iface apps_iface; + struct IVRApplications_IVRApplications_008_RegisterSubprocess_params params = { 0 }; + PROCESS_INFORMATION pi; + STARTUPINFOA si = { sizeof(si) }; + + TRACE("pchBinaryPath %s, pchArguments %s, pchWorkingDirectory %s.\n", + debugstr_a(pchBinaryPath), debugstr_a(pchArguments), debugstr_a(pchWorkingDirectory)); + + if (!apps_iface.handle) + { + int return_code; + struct vrclient_VRClientCoreFactory_params params = {.name = "IVRApplications_008", .return_code = &return_code}; + VRCLIENT_CALL( vrclient_VRClientCoreFactory, ¶ms ); + apps_iface = params._ret; + } + if (!apps_iface.handle) + { + FIXME("IVRApplications_008 not found.\n"); + return FALSE; + } + + *ret = 104; /* VRApplicationError_UnknownApplication */ + if (!CreateProcessA(pchBinaryPath, (char *)pchArguments, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, pchWorkingDirectory, &si, &pi)) + { + ERR( "CreateProcessW failed, err %lu.\n", GetLastError() ); + return TRUE; + } + params.u_iface = apps_iface; + params.nPid = GetProcessId(pi.hProcess); + VRCLIENT_CALL( IVRApplications_IVRApplications_008_RegisterSubprocess, ¶ms ); + *ret = params._ret; + if (params._ret) TerminateProcess(pi.hProcess, -1); + else ResumeThread(pi.hThread); + CloseHandle(pi.hProcess); + CloseHandle(pi.hThread); + return TRUE; +} + +uint32_t __thiscall winIVRApplications_IVRApplications_004_LaunchInternalProcess(struct w_iface *_this, const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory) +{ + struct IVRApplications_IVRApplications_004_LaunchInternalProcess_params params = + { + .u_iface = _this->u_iface, + .pchBinaryPath = pchBinaryPath, + .pchArguments = pchArguments, + .pchWorkingDirectory = pchWorkingDirectory, + }; + TRACE("%p\n", _this); + if (!launch_through_register_subprocess(_this, pchBinaryPath, pchArguments, pchWorkingDirectory, ¶ms._ret)) + VRCLIENT_CALL( IVRApplications_IVRApplications_004_LaunchInternalProcess, ¶ms ); + return params._ret; +} + +uint32_t __thiscall winIVRApplications_IVRApplications_005_LaunchInternalProcess(struct w_iface *_this, const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory) +{ + struct IVRApplications_IVRApplications_005_LaunchInternalProcess_params params = + { + .u_iface = _this->u_iface, + .pchBinaryPath = pchBinaryPath, + .pchArguments = pchArguments, + .pchWorkingDirectory = pchWorkingDirectory, + }; + TRACE("%p\n", _this); + if (!launch_through_register_subprocess(_this, pchBinaryPath, pchArguments, pchWorkingDirectory, ¶ms._ret)) + VRCLIENT_CALL( IVRApplications_IVRApplications_005_LaunchInternalProcess, ¶ms ); + return params._ret; +} + +uint32_t __thiscall winIVRApplications_IVRApplications_006_LaunchInternalProcess(struct w_iface *_this, const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory) +{ + struct IVRApplications_IVRApplications_006_LaunchInternalProcess_params params = + { + .u_iface = _this->u_iface, + .pchBinaryPath = pchBinaryPath, + .pchArguments = pchArguments, + .pchWorkingDirectory = pchWorkingDirectory, + }; + TRACE("%p\n", _this); + if (!launch_through_register_subprocess(_this, pchBinaryPath, pchArguments, pchWorkingDirectory, ¶ms._ret)) + VRCLIENT_CALL( IVRApplications_IVRApplications_006_LaunchInternalProcess, ¶ms ); + return params._ret; +} + +uint32_t __thiscall winIVRApplications_IVRApplications_007_LaunchInternalProcess(struct w_iface *_this, const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory) +{ + struct IVRApplications_IVRApplications_007_LaunchInternalProcess_params params = + { + .u_iface = _this->u_iface, + .pchBinaryPath = pchBinaryPath, + .pchArguments = pchArguments, + .pchWorkingDirectory = pchWorkingDirectory, + }; + TRACE("%p\n", _this); + if (!launch_through_register_subprocess(_this, pchBinaryPath, pchArguments, pchWorkingDirectory, ¶ms._ret)) + VRCLIENT_CALL( IVRApplications_IVRApplications_007_LaunchInternalProcess, ¶ms ); + return params._ret; +} + +uint32_t __thiscall winIVRApplications_IVRApplications_008_LaunchInternalProcess(struct w_iface *_this, const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory) +{ + struct IVRApplications_IVRApplications_008_LaunchInternalProcess_params params = + { + .u_iface = _this->u_iface, + .pchBinaryPath = pchBinaryPath, + .pchArguments = pchArguments, + .pchWorkingDirectory = pchWorkingDirectory, + }; + TRACE("%p\n", _this); + if (!launch_through_register_subprocess(_this, pchBinaryPath, pchArguments, pchWorkingDirectory, ¶ms._ret)) + VRCLIENT_CALL( IVRApplications_IVRApplications_008_LaunchInternalProcess, ¶ms ); + return params._ret; +} diff --git a/vrclient_x64/winIVRApplications.c b/vrclient_x64/winIVRApplications.c index 7f75a12ff47..d2e770b5e48 100644 --- a/vrclient_x64/winIVRApplications.c +++ b/vrclient_x64/winIVRApplications.c @@ -1420,19 +1420,7 @@ int8_t __thiscall winIVRApplications_IVRApplications_004_IsQuitUserPromptRequest return params._ret; } -uint32_t __thiscall winIVRApplications_IVRApplications_004_LaunchInternalProcess(struct w_iface *_this, const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory) -{ - struct IVRApplications_IVRApplications_004_LaunchInternalProcess_params params = - { - .u_iface = _this->u_iface, - .pchBinaryPath = pchBinaryPath, - .pchArguments = pchArguments, - .pchWorkingDirectory = pchWorkingDirectory, - }; - TRACE("%p\n", _this); - VRCLIENT_CALL( IVRApplications_IVRApplications_004_LaunchInternalProcess, ¶ms ); - return params._ret; -} +extern uint32_t __thiscall winIVRApplications_IVRApplications_004_LaunchInternalProcess(struct w_iface *_this, const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory); extern vtable_ptr winIVRApplications_IVRApplications_004_vtable; @@ -1844,19 +1832,7 @@ int8_t __thiscall winIVRApplications_IVRApplications_005_IsQuitUserPromptRequest return params._ret; } -uint32_t __thiscall winIVRApplications_IVRApplications_005_LaunchInternalProcess(struct w_iface *_this, const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory) -{ - struct IVRApplications_IVRApplications_005_LaunchInternalProcess_params params = - { - .u_iface = _this->u_iface, - .pchBinaryPath = pchBinaryPath, - .pchArguments = pchArguments, - .pchWorkingDirectory = pchWorkingDirectory, - }; - TRACE("%p\n", _this); - VRCLIENT_CALL( IVRApplications_IVRApplications_005_LaunchInternalProcess, ¶ms ); - return params._ret; -} +extern uint32_t __thiscall winIVRApplications_IVRApplications_005_LaunchInternalProcess(struct w_iface *_this, const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory); extern vtable_ptr winIVRApplications_IVRApplications_005_vtable; @@ -2359,19 +2335,7 @@ int8_t __thiscall winIVRApplications_IVRApplications_006_IsQuitUserPromptRequest return params._ret; } -uint32_t __thiscall winIVRApplications_IVRApplications_006_LaunchInternalProcess(struct w_iface *_this, const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory) -{ - struct IVRApplications_IVRApplications_006_LaunchInternalProcess_params params = - { - .u_iface = _this->u_iface, - .pchBinaryPath = pchBinaryPath, - .pchArguments = pchArguments, - .pchWorkingDirectory = pchWorkingDirectory, - }; - TRACE("%p\n", _this); - VRCLIENT_CALL( IVRApplications_IVRApplications_006_LaunchInternalProcess, ¶ms ); - return params._ret; -} +extern uint32_t __thiscall winIVRApplications_IVRApplications_006_LaunchInternalProcess(struct w_iface *_this, const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory); uint32_t __thiscall winIVRApplications_IVRApplications_006_GetCurrentSceneProcessId(struct w_iface *_this) { @@ -2887,19 +2851,7 @@ const char * __thiscall winIVRApplications_IVRApplications_007_GetSceneApplicati return get_unix_buffer( params._ret ); } -uint32_t __thiscall winIVRApplications_IVRApplications_007_LaunchInternalProcess(struct w_iface *_this, const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory) -{ - struct IVRApplications_IVRApplications_007_LaunchInternalProcess_params params = - { - .u_iface = _this->u_iface, - .pchBinaryPath = pchBinaryPath, - .pchArguments = pchArguments, - .pchWorkingDirectory = pchWorkingDirectory, - }; - TRACE("%p\n", _this); - VRCLIENT_CALL( IVRApplications_IVRApplications_007_LaunchInternalProcess, ¶ms ); - return params._ret; -} +extern uint32_t __thiscall winIVRApplications_IVRApplications_007_LaunchInternalProcess(struct w_iface *_this, const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory); uint32_t __thiscall winIVRApplications_IVRApplications_007_GetCurrentSceneProcessId(struct w_iface *_this) { @@ -3414,19 +3366,7 @@ const char * __thiscall winIVRApplications_IVRApplications_008_GetSceneApplicati return get_unix_buffer( params._ret ); } -uint32_t __thiscall winIVRApplications_IVRApplications_008_LaunchInternalProcess(struct w_iface *_this, const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory) -{ - struct IVRApplications_IVRApplications_008_LaunchInternalProcess_params params = - { - .u_iface = _this->u_iface, - .pchBinaryPath = pchBinaryPath, - .pchArguments = pchArguments, - .pchWorkingDirectory = pchWorkingDirectory, - }; - TRACE("%p\n", _this); - VRCLIENT_CALL( IVRApplications_IVRApplications_008_LaunchInternalProcess, ¶ms ); - return params._ret; -} +extern uint32_t __thiscall winIVRApplications_IVRApplications_008_LaunchInternalProcess(struct w_iface *_this, const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory); uint32_t __thiscall winIVRApplications_IVRApplications_008_RegisterSubprocess(struct w_iface *_this, uint32_t nPid) { diff --git a/wine b/wine index 79604fd6795..8bb4e716970 160000 --- a/wine +++ b/wine @@ -1 +1 @@ -Subproject commit 79604fd6795ba6c774c4a3cc2044cab8fb22772e +Subproject commit 8bb4e7169707986385388fd5ec1f50b54dab1a2f diff --git a/wineopenxr/loader_thunks.c b/wineopenxr/loader_thunks.c index f0e1c198bd2..f9b42aa0206 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-2025 The Khronos Group Inc. + * Copyright (c) 2017-2026 The Khronos Group Inc. * * SPDX-License-Identifier: Apache-2.0 OR MIT * @@ -35,6 +35,17 @@ XrResult WINAPI xrAcquireEnvironmentDepthImageMETA(XrEnvironmentDepthProviderMET return params.result; } +XrResult WINAPI xrAddTrackableImageDatabaseANDROID(XrTrackableTrackerANDROID tracker, XrTrackableImageDatabaseANDROID database) +{ + struct xrAddTrackableImageDatabaseANDROID_params params; + NTSTATUS _status; + params.tracker = tracker; + params.database = database; + _status = UNIX_CALL(xrAddTrackableImageDatabaseANDROID, ¶ms); + assert(!_status && "xrAddTrackableImageDatabaseANDROID"); + return params.result; +} + XrResult WINAPI xrAllocateWorldMeshBufferML(XrWorldMeshDetectorML detector, const XrWorldMeshBufferSizeML *size, XrWorldMeshBufferML *buffer) { struct xrAllocateWorldMeshBufferML_params params; @@ -326,6 +337,30 @@ XrResult WINAPI xrCreateEnvironmentDepthSwapchainMETA(XrEnvironmentDepthProvider return params.result; } +XrResult WINAPI xrCreateEnvironmentRaycasterAsyncMETA(XrSession session, const XrEnvironmentRaycasterCreateInfoMETA *info, XrFutureEXT *future) +{ + struct xrCreateEnvironmentRaycasterAsyncMETA_params params; + NTSTATUS _status; + params.session = session; + params.info = info; + params.future = future; + _status = UNIX_CALL(xrCreateEnvironmentRaycasterAsyncMETA, ¶ms); + assert(!_status && "xrCreateEnvironmentRaycasterAsyncMETA"); + return params.result; +} + +XrResult WINAPI xrCreateEnvironmentRaycasterCompleteMETA(XrSession session, XrFutureEXT future, XrEnvironmentRaycasterCreateCompletionMETA *completion) +{ + struct xrCreateEnvironmentRaycasterCompleteMETA_params params; + NTSTATUS _status; + params.session = session; + params.future = future; + params.completion = completion; + _status = UNIX_CALL(xrCreateEnvironmentRaycasterCompleteMETA, ¶ms); + assert(!_status && "xrCreateEnvironmentRaycasterCompleteMETA"); + return params.result; +} + XrResult WINAPI xrCreateExportedLocalizationMapML(XrSession session, const XrUuidEXT *mapUuid, XrExportedLocalizationMapML *map) { struct xrCreateExportedLocalizationMapML_params params; @@ -362,6 +397,30 @@ XrResult WINAPI xrCreateFaceTracker2FB(XrSession session, const XrFaceTrackerCre return params.result; } +XrResult WINAPI xrCreateFaceTrackerANDROID(XrSession session, const XrFaceTrackerCreateInfoANDROID *createInfo, XrFaceTrackerANDROID *faceTracker) +{ + struct xrCreateFaceTrackerANDROID_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.faceTracker = faceTracker; + _status = UNIX_CALL(xrCreateFaceTrackerANDROID, ¶ms); + assert(!_status && "xrCreateFaceTrackerANDROID"); + return params.result; +} + +XrResult WINAPI xrCreateFaceTrackerBD(XrSession session, const XrFaceTrackerCreateInfoBD *createInfo, XrFaceTrackerBD *tracker) +{ + struct xrCreateFaceTrackerBD_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.tracker = tracker; + _status = UNIX_CALL(xrCreateFaceTrackerBD, ¶ms); + assert(!_status && "xrCreateFaceTrackerBD"); + return params.result; +} + XrResult WINAPI xrCreateFaceTrackerFB(XrSession session, const XrFaceTrackerCreateInfoFB *createInfo, XrFaceTrackerFB *faceTracker) { struct xrCreateFaceTrackerFB_params params; @@ -530,6 +589,18 @@ XrResult WINAPI xrCreatePassthroughHTC(XrSession session, const XrPassthroughCre return params.result; } +XrResult WINAPI xrCreatePassthroughLayerANDROID(XrSession session, const XrPassthroughLayerCreateInfoANDROID *createInfo, XrPassthroughLayerANDROID *layer) +{ + struct xrCreatePassthroughLayerANDROID_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.layer = layer; + _status = UNIX_CALL(xrCreatePassthroughLayerANDROID, ¶ms); + assert(!_status && "xrCreatePassthroughLayerANDROID"); + return params.result; +} + XrResult WINAPI xrCreatePassthroughLayerFB(XrSession session, const XrPassthroughLayerCreateInfoFB *createInfo, XrPassthroughLayerFB *outLayer) { struct xrCreatePassthroughLayerFB_params params; @@ -626,6 +697,30 @@ XrResult WINAPI xrCreateSceneMSFT(XrSceneObserverMSFT sceneObserver, const XrSce return params.result; } +XrResult WINAPI xrCreateSceneMeshSnapshotANDROID(XrSceneMeshingTrackerANDROID tracker, const XrSceneMeshSnapshotCreateInfoANDROID *createInfo, XrSceneMeshSnapshotCreationResultANDROID *outSnapshotCreationResult) +{ + struct xrCreateSceneMeshSnapshotANDROID_params params; + NTSTATUS _status; + params.tracker = tracker; + params.createInfo = createInfo; + params.outSnapshotCreationResult = outSnapshotCreationResult; + _status = UNIX_CALL(xrCreateSceneMeshSnapshotANDROID, ¶ms); + assert(!_status && "xrCreateSceneMeshSnapshotANDROID"); + return params.result; +} + +XrResult WINAPI xrCreateSceneMeshingTrackerANDROID(XrSession session, const XrSceneMeshingTrackerCreateInfoANDROID *createInfo, XrSceneMeshingTrackerANDROID *tracker) +{ + struct xrCreateSceneMeshingTrackerANDROID_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.tracker = tracker; + _status = UNIX_CALL(xrCreateSceneMeshingTrackerANDROID, ¶ms); + assert(!_status && "xrCreateSceneMeshingTrackerANDROID"); + return params.result; +} + XrResult WINAPI xrCreateSceneObserverMSFT(XrSession session, const XrSceneObserverCreateInfoMSFT *createInfo, XrSceneObserverMSFT *sceneObserver) { struct xrCreateSceneObserverMSFT_params params; @@ -650,6 +745,55 @@ XrResult WINAPI xrCreateSenseDataProviderBD(XrSession session, const XrSenseData return params.result; } +XrResult WINAPI xrCreateSoundFieldBD(XrSpatialAudioRendererBD renderer, const XrSoundFieldConfigBD *config, XrSoundFieldBD *soundField) +{ + struct xrCreateSoundFieldBD_params params; + NTSTATUS _status; + params.renderer = renderer; + params.config = config; + params.soundField = soundField; + _status = UNIX_CALL(xrCreateSoundFieldBD, ¶ms); + assert(!_status && "xrCreateSoundFieldBD"); + return params.result; +} + +XrResult WINAPI xrCreateSoundObjectBD(XrSpatialAudioRendererBD renderer, const XrSoundObjectConfigBD *config, XrSoundObjectBD *soundObject) +{ + struct xrCreateSoundObjectBD_params params; + NTSTATUS _status; + params.renderer = renderer; + params.config = config; + params.soundObject = soundObject; + _status = UNIX_CALL(xrCreateSoundObjectBD, ¶ms); + assert(!_status && "xrCreateSoundObjectBD"); + return params.result; +} + +XrResult WINAPI xrCreateSoundObstacleBD(XrSpatialAudioRendererBD renderer, const XrSoundObstacleConfigBD *config, const XrSoundTriangleMeshBD *mesh, XrSoundObstacleBD *soundObstacle) +{ + struct xrCreateSoundObstacleBD_params params; + NTSTATUS _status; + params.renderer = renderer; + params.config = config; + params.mesh = mesh; + params.soundObstacle = soundObstacle; + _status = UNIX_CALL(xrCreateSoundObstacleBD, ¶ms); + assert(!_status && "xrCreateSoundObstacleBD"); + return params.result; +} + +XrResult WINAPI xrCreateSoundObstacleMaterialBD(XrSpatialAudioRendererBD renderer, const XrSoundObstacleMaterialConfigBD *config, XrSoundObstacleMaterialBD *material) +{ + struct xrCreateSoundObstacleMaterialBD_params params; + NTSTATUS _status; + params.renderer = renderer; + params.config = config; + params.material = material; + _status = UNIX_CALL(xrCreateSoundObstacleMaterialBD, ¶ms); + assert(!_status && "xrCreateSoundObstacleMaterialBD"); + return params.result; +} + XrResult WINAPI xrCreateSpaceUserFB(XrSession session, const XrSpaceUserCreateInfoFB *info, XrSpaceUserFB *user) { struct xrCreateSpaceUserFB_params params; @@ -747,6 +891,33 @@ XrResult WINAPI xrCreateSpatialAnchorMSFT(XrSession session, const XrSpatialAnch return params.result; } +XrResult WINAPI xrCreateSpatialAnchorSpaceANDROID(XrSession session, XrSpatialContextEXT spatialContext, const XrSpatialAnchorCreateInfoEXT *createInfo, XrSpatialEntityIdEXT *anchorEntityId, XrSpace *anchorSpace) +{ + struct xrCreateSpatialAnchorSpaceANDROID_params params; + NTSTATUS _status; + params.session = session; + params.spatialContext = spatialContext; + params.createInfo = createInfo; + params.anchorEntityId = anchorEntityId; + params.anchorSpace = anchorSpace; + _status = UNIX_CALL(xrCreateSpatialAnchorSpaceANDROID, ¶ms); + assert(!_status && "xrCreateSpatialAnchorSpaceANDROID"); + return params.result; +} + +XrResult WINAPI xrCreateSpatialAnchorSpaceFromIdANDROID(XrSession session, XrSpatialContextEXT spatialContext, const XrSpatialAnchorSpaceFromIdCreateInfoANDROID *createInfo, XrSpace *anchorSpace) +{ + struct xrCreateSpatialAnchorSpaceFromIdANDROID_params params; + NTSTATUS _status; + params.session = session; + params.spatialContext = spatialContext; + params.createInfo = createInfo; + params.anchorSpace = anchorSpace; + _status = UNIX_CALL(xrCreateSpatialAnchorSpaceFromIdANDROID, ¶ms); + assert(!_status && "xrCreateSpatialAnchorSpaceFromIdANDROID"); + return params.result; +} + XrResult WINAPI xrCreateSpatialAnchorSpaceMSFT(XrSession session, const XrSpatialAnchorSpaceCreateInfoMSFT *createInfo, XrSpace *space) { struct xrCreateSpatialAnchorSpaceMSFT_params params; @@ -806,6 +977,18 @@ XrResult WINAPI xrCreateSpatialAnchorsStorageML(XrSession session, const XrSpati return params.result; } +XrResult WINAPI xrCreateSpatialAudioRendererBD(XrSession session, const XrSpatialAudioRendererCreateInfoBD *createInfo, XrSpatialAudioRendererBD *renderer) +{ + struct xrCreateSpatialAudioRendererBD_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.renderer = renderer; + _status = UNIX_CALL(xrCreateSpatialAudioRendererBD, ¶ms); + assert(!_status && "xrCreateSpatialAudioRendererBD"); + return params.result; +} + XrResult WINAPI xrCreateSpatialContextAsyncEXT(XrSession session, const XrSpatialContextCreateInfoEXT *createInfo, XrFutureEXT *future) { struct xrCreateSpatialContextAsyncEXT_params params; @@ -914,6 +1097,18 @@ XrResult WINAPI xrCreateSpatialPersistenceContextCompleteEXT(XrSession session, return params.result; } +XrResult WINAPI xrCreateSpatialRaycastSnapshotANDROID(XrSpatialContextEXT spatialContext, const XrSpatialRaycastSnapshotCreateInfoANDROID *createInfo, XrSpatialSnapshotEXT *snapshot) +{ + struct xrCreateSpatialRaycastSnapshotANDROID_params params; + NTSTATUS _status; + params.spatialContext = spatialContext; + params.createInfo = createInfo; + params.snapshot = snapshot; + _status = UNIX_CALL(xrCreateSpatialRaycastSnapshotANDROID, ¶ms); + assert(!_status && "xrCreateSpatialRaycastSnapshotANDROID"); + return params.result; +} + XrResult WINAPI xrCreateSpatialUpdateSnapshotEXT(XrSpatialContextEXT spatialContext, const XrSpatialUpdateSnapshotCreateInfoEXT *createInfo, XrSpatialSnapshotEXT *snapshot) { struct xrCreateSpatialUpdateSnapshotEXT_params params; @@ -926,6 +1121,30 @@ XrResult WINAPI xrCreateSpatialUpdateSnapshotEXT(XrSpatialContextEXT spatialCont return params.result; } +XrResult WINAPI xrCreateTrackableImageDatabaseAsyncANDROID(XrSession session, const XrTrackableImageDatabaseCreateInfoANDROID *createInfo, XrFutureEXT *future) +{ + struct xrCreateTrackableImageDatabaseAsyncANDROID_params params; + NTSTATUS _status; + params.session = session; + params.createInfo = createInfo; + params.future = future; + _status = UNIX_CALL(xrCreateTrackableImageDatabaseAsyncANDROID, ¶ms); + assert(!_status && "xrCreateTrackableImageDatabaseAsyncANDROID"); + return params.result; +} + +XrResult WINAPI xrCreateTrackableImageDatabaseCompleteANDROID(XrSession session, XrFutureEXT future, XrCreateTrackableImageDatabaseCompletionANDROID *completion) +{ + struct xrCreateTrackableImageDatabaseCompleteANDROID_params params; + NTSTATUS _status; + params.session = session; + params.future = future; + params.completion = completion; + _status = UNIX_CALL(xrCreateTrackableImageDatabaseCompleteANDROID, ¶ms); + assert(!_status && "xrCreateTrackableImageDatabaseCompleteANDROID"); + return params.result; +} + XrResult WINAPI xrCreateTrackableTrackerANDROID(XrSession session, const XrTrackableTrackerCreateInfoANDROID *createInfo, XrTrackableTrackerANDROID *trackableTracker) { struct xrCreateTrackableTrackerANDROID_params params; @@ -1112,6 +1331,16 @@ XrResult WINAPI xrDestroyEnvironmentDepthSwapchainMETA(XrEnvironmentDepthSwapcha return params.result; } +XrResult WINAPI xrDestroyEnvironmentRaycasterMETA(XrEnvironmentRaycasterMETA environmentRaycaster) +{ + struct xrDestroyEnvironmentRaycasterMETA_params params; + NTSTATUS _status; + params.environmentRaycaster = environmentRaycaster; + _status = UNIX_CALL(xrDestroyEnvironmentRaycasterMETA, ¶ms); + assert(!_status && "xrDestroyEnvironmentRaycasterMETA"); + return params.result; +} + XrResult WINAPI xrDestroyExportedLocalizationMapML(XrExportedLocalizationMapML map) { struct xrDestroyExportedLocalizationMapML_params params; @@ -1142,6 +1371,26 @@ XrResult WINAPI xrDestroyFaceTracker2FB(XrFaceTracker2FB faceTracker) return params.result; } +XrResult WINAPI xrDestroyFaceTrackerANDROID(XrFaceTrackerANDROID faceTracker) +{ + struct xrDestroyFaceTrackerANDROID_params params; + NTSTATUS _status; + params.faceTracker = faceTracker; + _status = UNIX_CALL(xrDestroyFaceTrackerANDROID, ¶ms); + assert(!_status && "xrDestroyFaceTrackerANDROID"); + return params.result; +} + +XrResult WINAPI xrDestroyFaceTrackerBD(XrFaceTrackerBD tracker) +{ + struct xrDestroyFaceTrackerBD_params params; + NTSTATUS _status; + params.tracker = tracker; + _status = UNIX_CALL(xrDestroyFaceTrackerBD, ¶ms); + assert(!_status && "xrDestroyFaceTrackerBD"); + return params.result; +} + XrResult WINAPI xrDestroyFaceTrackerFB(XrFaceTrackerFB faceTracker) { struct xrDestroyFaceTrackerFB_params params; @@ -1242,6 +1491,16 @@ XrResult WINAPI xrDestroyPassthroughHTC(XrPassthroughHTC passthrough) return params.result; } +XrResult WINAPI xrDestroyPassthroughLayerANDROID(XrPassthroughLayerANDROID layer) +{ + struct xrDestroyPassthroughLayerANDROID_params params; + NTSTATUS _status; + params.layer = layer; + _status = UNIX_CALL(xrDestroyPassthroughLayerANDROID, ¶ms); + assert(!_status && "xrDestroyPassthroughLayerANDROID"); + return params.result; +} + XrResult WINAPI xrDestroyPassthroughLayerFB(XrPassthroughLayerFB layer) { struct xrDestroyPassthroughLayerFB_params params; @@ -1292,6 +1551,26 @@ XrResult WINAPI xrDestroySceneMSFT(XrSceneMSFT scene) return params.result; } +XrResult WINAPI xrDestroySceneMeshSnapshotANDROID(XrSceneMeshSnapshotANDROID snapshot) +{ + struct xrDestroySceneMeshSnapshotANDROID_params params; + NTSTATUS _status; + params.snapshot = snapshot; + _status = UNIX_CALL(xrDestroySceneMeshSnapshotANDROID, ¶ms); + assert(!_status && "xrDestroySceneMeshSnapshotANDROID"); + return params.result; +} + +XrResult WINAPI xrDestroySceneMeshingTrackerANDROID(XrSceneMeshingTrackerANDROID tracker) +{ + struct xrDestroySceneMeshingTrackerANDROID_params params; + NTSTATUS _status; + params.tracker = tracker; + _status = UNIX_CALL(xrDestroySceneMeshingTrackerANDROID, ¶ms); + assert(!_status && "xrDestroySceneMeshingTrackerANDROID"); + return params.result; +} + XrResult WINAPI xrDestroySceneObserverMSFT(XrSceneObserverMSFT sceneObserver) { struct xrDestroySceneObserverMSFT_params params; @@ -1322,6 +1601,46 @@ XrResult WINAPI xrDestroySenseDataSnapshotBD(XrSenseDataSnapshotBD snapshot) return params.result; } +XrResult WINAPI xrDestroySoundFieldBD(XrSoundFieldBD soundField) +{ + struct xrDestroySoundFieldBD_params params; + NTSTATUS _status; + params.soundField = soundField; + _status = UNIX_CALL(xrDestroySoundFieldBD, ¶ms); + assert(!_status && "xrDestroySoundFieldBD"); + return params.result; +} + +XrResult WINAPI xrDestroySoundObjectBD(XrSoundObjectBD soundObject) +{ + struct xrDestroySoundObjectBD_params params; + NTSTATUS _status; + params.soundObject = soundObject; + _status = UNIX_CALL(xrDestroySoundObjectBD, ¶ms); + assert(!_status && "xrDestroySoundObjectBD"); + return params.result; +} + +XrResult WINAPI xrDestroySoundObstacleBD(XrSoundObstacleBD soundObstacle) +{ + struct xrDestroySoundObstacleBD_params params; + NTSTATUS _status; + params.soundObstacle = soundObstacle; + _status = UNIX_CALL(xrDestroySoundObstacleBD, ¶ms); + assert(!_status && "xrDestroySoundObstacleBD"); + return params.result; +} + +XrResult WINAPI xrDestroySoundObstacleMaterialBD(XrSoundObstacleMaterialBD material) +{ + struct xrDestroySoundObstacleMaterialBD_params params; + NTSTATUS _status; + params.material = material; + _status = UNIX_CALL(xrDestroySoundObstacleMaterialBD, ¶ms); + assert(!_status && "xrDestroySoundObstacleMaterialBD"); + return params.result; +} + XrResult WINAPI xrDestroySpace(XrSpace space) { struct xrDestroySpace_params params; @@ -1372,6 +1691,16 @@ XrResult WINAPI xrDestroySpatialAnchorsStorageML(XrSpatialAnchorsStorageML stora return params.result; } +XrResult WINAPI xrDestroySpatialAudioRendererBD(XrSpatialAudioRendererBD renderer) +{ + struct xrDestroySpatialAudioRendererBD_params params; + NTSTATUS _status; + params.renderer = renderer; + _status = UNIX_CALL(xrDestroySpatialAudioRendererBD, ¶ms); + assert(!_status && "xrDestroySpatialAudioRendererBD"); + return params.result; +} + XrResult WINAPI xrDestroySpatialContextEXT(XrSpatialContextEXT spatialContext) { struct xrDestroySpatialContextEXT_params params; @@ -1422,6 +1751,16 @@ XrResult WINAPI xrDestroySpatialSnapshotEXT(XrSpatialSnapshotEXT snapshot) return params.result; } +XrResult WINAPI xrDestroyTrackableImageDatabaseANDROID(XrTrackableImageDatabaseANDROID database) +{ + struct xrDestroyTrackableImageDatabaseANDROID_params params; + NTSTATUS _status; + params.database = database; + _status = UNIX_CALL(xrDestroyTrackableImageDatabaseANDROID, ¶ms); + assert(!_status && "xrDestroyTrackableImageDatabaseANDROID"); + return params.result; +} + XrResult WINAPI xrDestroyTrackableTrackerANDROID(XrTrackableTrackerANDROID trackableTracker) { struct xrDestroyTrackableTrackerANDROID_params params; @@ -1520,6 +1859,16 @@ XrResult WINAPI xrEnableUserCalibrationEventsML(XrInstance instance, const XrUse return params.result; } +XrResult WINAPI xrEndAudioPeriodBD(XrSpatialAudioRendererBD renderer) +{ + struct xrEndAudioPeriodBD_params params; + NTSTATUS _status; + params.renderer = renderer; + _status = UNIX_CALL(xrEndAudioPeriodBD, ¶ms); + assert(!_status && "xrEndAudioPeriodBD"); + return params.result; +} + XrResult WINAPI xrEndSession(XrSession session) { struct xrEndSession_params params; @@ -1623,6 +1972,19 @@ XrResult WINAPI xrEnumerateExternalCamerasOCULUS(XrSession session, uint32_t cam return params.result; } +XrResult WINAPI xrEnumerateFacialSimulationModesBD(XrSession session, uint32_t modeCapacityInput, uint32_t *modeCountOutput, XrFacialSimulationModeBD *modes) +{ + struct xrEnumerateFacialSimulationModesBD_params params; + NTSTATUS _status; + params.session = session; + params.modeCapacityInput = modeCapacityInput; + params.modeCountOutput = modeCountOutput; + params.modes = modes; + _status = UNIX_CALL(xrEnumerateFacialSimulationModesBD, ¶ms); + assert(!_status && "xrEnumerateFacialSimulationModesBD"); + return params.result; +} + XrResult WINAPI xrEnumerateInstanceExtensionProperties(const char *layerName, uint32_t propertyCapacityInput, uint32_t *propertyCountOutput, XrExtensionProperties *properties) { struct xrEnumerateInstanceExtensionProperties_params params; @@ -1650,6 +2012,19 @@ XrResult WINAPI xrEnumerateInteractionRenderModelIdsEXT(XrSession session, const return params.result; } +XrResult WINAPI xrEnumeratePerformanceMetricsCounterPathsANDROID(XrInstance instance, uint32_t counterPathCapacityInput, uint32_t *counterPathCountOutput, XrPath *counterPaths) +{ + struct xrEnumeratePerformanceMetricsCounterPathsANDROID_params params; + NTSTATUS _status; + params.instance = instance; + params.counterPathCapacityInput = counterPathCapacityInput; + params.counterPathCountOutput = counterPathCountOutput; + params.counterPaths = counterPaths; + _status = UNIX_CALL(xrEnumeratePerformanceMetricsCounterPathsANDROID, ¶ms); + assert(!_status && "xrEnumeratePerformanceMetricsCounterPathsANDROID"); + return params.result; +} + XrResult WINAPI xrEnumeratePerformanceMetricsCounterPathsMETA(XrInstance instance, uint32_t counterPathCapacityInput, uint32_t *counterPathCountOutput, XrPath *counterPaths) { struct xrEnumeratePerformanceMetricsCounterPathsMETA_params params; @@ -1785,6 +2160,20 @@ XrResult WINAPI xrEnumerateSpaceSupportedComponentsFB(XrSpace space, uint32_t co return params.result; } +XrResult WINAPI xrEnumerateSpatialAnchorAttachableComponentsANDROID(XrInstance instance, XrSystemId systemId, uint32_t attachableComponentCapacityInput, uint32_t *attachableComponentCountOutput, XrSpatialComponentTypeEXT *attachableComponents) +{ + struct xrEnumerateSpatialAnchorAttachableComponentsANDROID_params params; + NTSTATUS _status; + params.instance = instance; + params.systemId = systemId; + params.attachableComponentCapacityInput = attachableComponentCapacityInput; + params.attachableComponentCountOutput = attachableComponentCountOutput; + params.attachableComponents = attachableComponents; + _status = UNIX_CALL(xrEnumerateSpatialAnchorAttachableComponentsANDROID, ¶ms); + assert(!_status && "xrEnumerateSpatialAnchorAttachableComponentsANDROID"); + return params.result; +} + XrResult WINAPI xrEnumerateSpatialCapabilitiesEXT(XrInstance instance, XrSystemId systemId, uint32_t capabilityCapacityInput, uint32_t *capabilityCountOutput, XrSpatialCapabilityEXT *capabilities) { struct xrEnumerateSpatialCapabilitiesEXT_params params; @@ -1869,6 +2258,19 @@ XrResult WINAPI xrEnumerateSupportedAnchorTrackableTypesANDROID(XrInstance insta return params.result; } +XrResult WINAPI xrEnumerateSupportedAudioSampleRateBD(XrSession session, uint32_t sampleRateCapacityInput, uint32_t *sampleRateCountOutput, XrAudioSampleRateBD *sampleRates) +{ + struct xrEnumerateSupportedAudioSampleRateBD_params params; + NTSTATUS _status; + params.session = session; + params.sampleRateCapacityInput = sampleRateCapacityInput; + params.sampleRateCountOutput = sampleRateCountOutput; + params.sampleRates = sampleRates; + _status = UNIX_CALL(xrEnumerateSupportedAudioSampleRateBD, ¶ms); + assert(!_status && "xrEnumerateSupportedAudioSampleRateBD"); + return params.result; +} + XrResult WINAPI xrEnumerateSupportedPersistenceAnchorTypesANDROID(XrInstance instance, XrSystemId systemId, uint32_t trackableTypeCapacityInput, uint32_t *trackableTypeCountOutput, XrTrackableTypeANDROID *trackableTypes) { struct xrEnumerateSupportedPersistenceAnchorTypesANDROID_params params; @@ -1883,6 +2285,20 @@ XrResult WINAPI xrEnumerateSupportedPersistenceAnchorTypesANDROID(XrInstance ins return params.result; } +XrResult WINAPI xrEnumerateSupportedSemanticLabelSetsANDROID(XrInstance instance, XrSystemId systemId, uint32_t supportedSemanticLabelSetsInputCapacity, uint32_t *supportedSemanticLabelSetsOutputCount, XrSceneMeshSemanticLabelSetANDROID *supportedSemanticLabelSets) +{ + struct xrEnumerateSupportedSemanticLabelSetsANDROID_params params; + NTSTATUS _status; + params.instance = instance; + params.systemId = systemId; + params.supportedSemanticLabelSetsInputCapacity = supportedSemanticLabelSetsInputCapacity; + params.supportedSemanticLabelSetsOutputCount = supportedSemanticLabelSetsOutputCount; + params.supportedSemanticLabelSets = supportedSemanticLabelSets; + _status = UNIX_CALL(xrEnumerateSupportedSemanticLabelSetsANDROID, ¶ms); + assert(!_status && "xrEnumerateSupportedSemanticLabelSetsANDROID"); + return params.result; +} + XrResult WINAPI xrEnumerateSupportedTrackableTypesANDROID(XrInstance instance, XrSystemId systemId, uint32_t trackableTypeCapacityInput, uint32_t *trackableTypeCountOutput, XrTrackableTypeANDROID *trackableTypes) { struct xrEnumerateSupportedTrackableTypesANDROID_params params; @@ -2033,6 +2449,19 @@ XrResult WINAPI xrGetActionStateVector2f(XrSession session, const XrActionStateG return params.result; } +XrResult WINAPI xrGetAllSubmeshStatesANDROID(XrSceneMeshSnapshotANDROID snapshot, uint32_t submeshStateCapacityInput, uint32_t *submeshStateCountOutput, XrSceneSubmeshStateANDROID *submeshStates) +{ + struct xrGetAllSubmeshStatesANDROID_params params; + NTSTATUS _status; + params.snapshot = snapshot; + params.submeshStateCapacityInput = submeshStateCapacityInput; + params.submeshStateCountOutput = submeshStateCountOutput; + params.submeshStates = submeshStates; + _status = UNIX_CALL(xrGetAllSubmeshStatesANDROID, ¶ms); + assert(!_status && "xrGetAllSubmeshStatesANDROID"); + return params.result; +} + XrResult WINAPI xrGetAllTrackablesANDROID(XrTrackableTrackerANDROID trackableTracker, uint32_t trackableCapacityInput, uint32_t *trackableCountOutput, XrTrackableANDROID *trackables) { struct xrGetAllTrackablesANDROID_params params; @@ -2222,6 +2651,17 @@ XrResult WINAPI xrGetEyeGazesFB(XrEyeTrackerFB eyeTracker, const XrEyeGazesInfoF return params.result; } +XrResult WINAPI xrGetFaceCalibrationStateANDROID(XrFaceTrackerANDROID faceTracker, XrBool32 *faceIsCalibratedOutput) +{ + struct xrGetFaceCalibrationStateANDROID_params params; + NTSTATUS _status; + params.faceTracker = faceTracker; + params.faceIsCalibratedOutput = faceIsCalibratedOutput; + _status = UNIX_CALL(xrGetFaceCalibrationStateANDROID, ¶ms); + assert(!_status && "xrGetFaceCalibrationStateANDROID"); + return params.result; +} + XrResult WINAPI xrGetFaceExpressionWeights2FB(XrFaceTracker2FB faceTracker, const XrFaceExpressionInfo2FB *expressionInfo, XrFaceExpressionWeights2FB *expressionWeights) { struct xrGetFaceExpressionWeights2FB_params params; @@ -2246,6 +2686,18 @@ XrResult WINAPI xrGetFaceExpressionWeightsFB(XrFaceTrackerFB faceTracker, const return params.result; } +XrResult WINAPI xrGetFaceStateANDROID(XrFaceTrackerANDROID faceTracker, const XrFaceStateGetInfoANDROID *getInfo, XrFaceStateANDROID *faceStateOutput) +{ + struct xrGetFaceStateANDROID_params params; + NTSTATUS _status; + params.faceTracker = faceTracker; + params.getInfo = getInfo; + params.faceStateOutput = faceStateOutput; + _status = UNIX_CALL(xrGetFaceStateANDROID, ¶ms); + assert(!_status && "xrGetFaceStateANDROID"); + return params.result; +} + XrResult WINAPI xrGetFacialExpressionBlendShapePropertiesML(XrFacialExpressionClientML facialExpressionClient, const XrFacialExpressionBlendShapeGetInfoML *blendShapeGetInfo, uint32_t blendShapeCount, XrFacialExpressionBlendShapePropertiesML *blendShapes) { struct xrGetFacialExpressionBlendShapePropertiesML_params params; @@ -2270,6 +2722,29 @@ XrResult WINAPI xrGetFacialExpressionsHTC(XrFacialTrackerHTC facialTracker, XrFa return params.result; } +XrResult WINAPI xrGetFacialSimulationDataBD(XrFaceTrackerBD tracker, const XrFacialSimulationDataGetInfoBD *info, XrFacialSimulationDataBD *facialData) +{ + struct xrGetFacialSimulationDataBD_params params; + NTSTATUS _status; + params.tracker = tracker; + params.info = info; + params.facialData = facialData; + _status = UNIX_CALL(xrGetFacialSimulationDataBD, ¶ms); + assert(!_status && "xrGetFacialSimulationDataBD"); + return params.result; +} + +XrResult WINAPI xrGetFacialSimulationModeBD(XrFaceTrackerBD tracker, XrFacialSimulationModeBD *mode) +{ + struct xrGetFacialSimulationModeBD_params params; + NTSTATUS _status; + params.tracker = tracker; + params.mode = mode; + _status = UNIX_CALL(xrGetFacialSimulationModeBD, ¶ms); + assert(!_status && "xrGetFacialSimulationModeBD"); + return params.result; +} + XrResult WINAPI xrGetFoveationEyeTrackedStateMETA(XrSession session, XrFoveationEyeTrackedStateMETA *foveationState) { struct xrGetFoveationEyeTrackedStateMETA_params params; @@ -2281,6 +2756,18 @@ XrResult WINAPI xrGetFoveationEyeTrackedStateMETA(XrSession session, XrFoveation return params.result; } +XrResult WINAPI xrGetHandGestureQCOM(XrHandTrackerEXT handTracker, XrTime time, XrHandGestureQCOM *handGesture) +{ + struct xrGetHandGestureQCOM_params params; + NTSTATUS _status; + params.handTracker = handTracker; + params.time = time; + params.handGesture = handGesture; + _status = UNIX_CALL(xrGetHandGestureQCOM, ¶ms); + assert(!_status && "xrGetHandGestureQCOM"); + return params.result; +} + XrResult WINAPI xrGetHandMeshFB(XrHandTrackerEXT handTracker, XrHandTrackingMeshFB *mesh) { struct xrGetHandMeshFB_params params; @@ -2438,6 +2925,17 @@ XrResult WINAPI xrGetPassthroughPreferencesMETA(XrSession session, XrPassthrough return params.result; } +XrResult WINAPI xrGetPerformanceMetricsStateANDROID(XrSession session, XrPerformanceMetricsStateANDROID *state) +{ + struct xrGetPerformanceMetricsStateANDROID_params params; + NTSTATUS _status; + params.session = session; + params.state = state; + _status = UNIX_CALL(xrGetPerformanceMetricsStateANDROID, ¶ms); + assert(!_status && "xrGetPerformanceMetricsStateANDROID"); + return params.result; +} + XrResult WINAPI xrGetPerformanceMetricsStateMETA(XrSession session, XrPerformanceMetricsStateMETA *state) { struct xrGetPerformanceMetricsStateMETA_params params; @@ -2955,6 +3453,18 @@ XrResult WINAPI xrGetSpatialGraphNodeBindingPropertiesMSFT(XrSpatialGraphNodeBin return params.result; } +XrResult WINAPI xrGetSubmeshDataANDROID(XrSceneMeshSnapshotANDROID snapshot, uint32_t submeshDataCount, XrSceneSubmeshDataANDROID *inoutSubmeshData) +{ + struct xrGetSubmeshDataANDROID_params params; + NTSTATUS _status; + params.snapshot = snapshot; + params.submeshDataCount = submeshDataCount; + params.inoutSubmeshData = inoutSubmeshData; + _status = UNIX_CALL(xrGetSubmeshDataANDROID, ¶ms); + assert(!_status && "xrGetSubmeshDataANDROID"); + return params.result; +} + XrResult WINAPI xrGetSwapchainStateFB(XrSwapchain swapchain, XrSwapchainStateBaseHeaderFB *state) { struct xrGetSwapchainStateFB_params params; @@ -2978,6 +3488,18 @@ XrResult WINAPI xrGetSystemProperties(XrInstance instance, XrSystemId systemId, return params.result; } +XrResult WINAPI xrGetTrackableImageANDROID(XrTrackableTrackerANDROID tracker, const XrTrackableGetInfoANDROID *getInfo, XrTrackableImageANDROID *trackable) +{ + struct xrGetTrackableImageANDROID_params params; + NTSTATUS _status; + params.tracker = tracker; + params.getInfo = getInfo; + params.trackable = trackable; + _status = UNIX_CALL(xrGetTrackableImageANDROID, ¶ms); + assert(!_status && "xrGetTrackableImageANDROID"); + return params.result; +} + XrResult WINAPI xrGetTrackableMarkerANDROID(XrTrackableTrackerANDROID tracker, const XrTrackableGetInfoANDROID *getInfo, XrTrackableMarkerANDROID *markerOutput) { struct xrGetTrackableMarkerANDROID_params params; @@ -3014,6 +3536,18 @@ XrResult WINAPI xrGetTrackablePlaneANDROID(XrTrackableTrackerANDROID trackableTr return params.result; } +XrResult WINAPI xrGetTrackableQrCodeANDROID(XrTrackableTrackerANDROID tracker, const XrTrackableGetInfoANDROID *getInfo, XrTrackableQrCodeANDROID *qrCodeOutput) +{ + struct xrGetTrackableQrCodeANDROID_params params; + NTSTATUS _status; + params.tracker = tracker; + params.getInfo = getInfo; + params.qrCodeOutput = qrCodeOutput; + _status = UNIX_CALL(xrGetTrackableQrCodeANDROID, ¶ms); + assert(!_status && "xrGetTrackableQrCodeANDROID"); + return params.result; +} + XrResult WINAPI xrGetViewConfigurationProperties(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, XrViewConfigurationProperties *configurationProperties) { struct xrGetViewConfigurationProperties_params params; @@ -3412,6 +3946,18 @@ XrResult WINAPI xrPerfSettingsSetPerformanceLevelEXT(XrSession session, XrPerfSe return params.result; } +XrResult WINAPI xrPerformEnvironmentRaycastMETA(XrEnvironmentRaycasterMETA environmentRaycaster, const XrEnvironmentRaycastHitGetInfoMETA *info, XrEnvironmentRaycastHitMETA *hitPoint) +{ + struct xrPerformEnvironmentRaycastMETA_params params; + NTSTATUS _status; + params.environmentRaycaster = environmentRaycaster; + params.info = info; + params.hitPoint = hitPoint; + _status = UNIX_CALL(xrPerformEnvironmentRaycastMETA, ¶ms); + assert(!_status && "xrPerformEnvironmentRaycastMETA"); + return params.result; +} + XrResult WINAPI xrPersistAnchorANDROID(XrDeviceAnchorPersistenceANDROID handle, const XrPersistedAnchorSpaceInfoANDROID *persistedInfo, XrUuidEXT *anchorIdOutput) { struct xrPersistAnchorANDROID_params params; @@ -3519,6 +4065,19 @@ XrResult WINAPI xrPublishSpatialAnchorsCompleteML(XrSpatialAnchorsStorageML stor return params.result; } +XrResult WINAPI xrQueryFramesPerBufferRangeBD(XrSession session, XrAudioSampleRateBD sampleRate, uint32_t *min, uint32_t *max) +{ + struct xrQueryFramesPerBufferRangeBD_params params; + NTSTATUS _status; + params.session = session; + params.sampleRate = sampleRate; + params.min = min; + params.max = max; + _status = UNIX_CALL(xrQueryFramesPerBufferRangeBD, ¶ms); + assert(!_status && "xrQueryFramesPerBufferRangeBD"); + return params.result; +} + XrResult WINAPI xrQueryLocalizationMapsML(XrSession session, const XrLocalizationMapQueryInfoBaseHeaderML *queryInfo, uint32_t mapCapacityInput, uint32_t *mapCountOutput, XrLocalizationMapML *maps) { struct xrQueryLocalizationMapsML_params params; @@ -3533,6 +4092,18 @@ XrResult WINAPI xrQueryLocalizationMapsML(XrSession session, const XrLocalizatio return params.result; } +XrResult WINAPI xrQueryPerformanceMetricsCounterANDROID(XrSession session, XrPath counterPath, XrPerformanceMetricsCounterANDROID *counter) +{ + struct xrQueryPerformanceMetricsCounterANDROID_params params; + NTSTATUS _status; + params.session = session; + params.counterPath = counterPath; + params.counter = counter; + _status = UNIX_CALL(xrQueryPerformanceMetricsCounterANDROID, ¶ms); + assert(!_status && "xrQueryPerformanceMetricsCounterANDROID"); + return params.result; +} + XrResult WINAPI xrQueryPerformanceMetricsCounterMETA(XrSession session, XrPath counterPath, XrPerformanceMetricsCounterMETA *counter) { struct xrQueryPerformanceMetricsCounterMETA_params params; @@ -3641,6 +4212,28 @@ XrResult WINAPI xrRaycastANDROID(XrSession session, const XrRaycastInfoANDROID * return params.result; } +XrResult WINAPI xrRemoveTrackableImageDatabaseANDROID(XrTrackableTrackerANDROID tracker, XrTrackableImageDatabaseANDROID database) +{ + struct xrRemoveTrackableImageDatabaseANDROID_params params; + NTSTATUS _status; + params.tracker = tracker; + params.database = database; + _status = UNIX_CALL(xrRemoveTrackableImageDatabaseANDROID, ¶ms); + assert(!_status && "xrRemoveTrackableImageDatabaseANDROID"); + return params.result; +} + +XrResult WINAPI xrRequestBodyTrackingFidelityMETA(XrBodyTrackerFB bodyTracker, const XrBodyTrackingFidelityMETA fidelity) +{ + struct xrRequestBodyTrackingFidelityMETA_params params; + NTSTATUS _status; + params.bodyTracker = bodyTracker; + params.fidelity = fidelity; + _status = UNIX_CALL(xrRequestBodyTrackingFidelityMETA, ¶ms); + assert(!_status && "xrRequestBodyTrackingFidelityMETA"); + return params.result; +} + XrResult WINAPI xrRequestDisplayRefreshRateFB(XrSession session, float displayRefreshRate) { struct xrRequestDisplayRefreshRateFB_params params; @@ -3884,6 +4477,17 @@ XrResult WINAPI xrSetEnvironmentDepthHandRemovalMETA(XrEnvironmentDepthProviderM return params.result; } +XrResult WINAPI xrSetFacialSimulationModeBD(XrFaceTrackerBD tracker, XrFacialSimulationModeBD mode) +{ + struct xrSetFacialSimulationModeBD_params params; + NTSTATUS _status; + params.tracker = tracker; + params.mode = mode; + _status = UNIX_CALL(xrSetFacialSimulationModeBD, ¶ms); + assert(!_status && "xrSetFacialSimulationModeBD"); + return params.result; +} + XrResult WINAPI xrSetInputDeviceActiveEXT(XrSession session, XrPath interactionProfile, XrPath topLevelPath, XrBool32 isActive) { struct xrSetInputDeviceActiveEXT_params params; @@ -3985,6 +4589,28 @@ XrResult WINAPI xrSetMarkerTrackingVARJO(XrSession session, XrBool32 enabled) return params.result; } +XrResult WINAPI xrSetPassthroughLayerMeshANDROID(XrPassthroughLayerANDROID layer, const XrPassthroughLayerMeshANDROID *mesh) +{ + struct xrSetPassthroughLayerMeshANDROID_params params; + NTSTATUS _status; + params.layer = layer; + params.mesh = mesh; + _status = UNIX_CALL(xrSetPassthroughLayerMeshANDROID, ¶ms); + assert(!_status && "xrSetPassthroughLayerMeshANDROID"); + return params.result; +} + +XrResult WINAPI xrSetPerformanceMetricsStateANDROID(XrSession session, const XrPerformanceMetricsStateANDROID *state) +{ + struct xrSetPerformanceMetricsStateANDROID_params params; + NTSTATUS _status; + params.session = session; + params.state = state; + _status = UNIX_CALL(xrSetPerformanceMetricsStateANDROID, ¶ms); + assert(!_status && "xrSetPerformanceMetricsStateANDROID"); + return params.result; +} + XrResult WINAPI xrSetPerformanceMetricsStateMETA(XrSession session, const XrPerformanceMetricsStateMETA *state) { struct xrSetPerformanceMetricsStateMETA_params params; @@ -4019,6 +4645,17 @@ XrResult WINAPI xrSetSystemNotificationsML(XrInstance instance, const XrSystemNo return params.result; } +XrResult WINAPI xrSetTilePropertiesHintMETA(XrSession session, const XrTilePropertiesHintMETA *properties) +{ + struct xrSetTilePropertiesHintMETA_params params; + NTSTATUS _status; + params.session = session; + params.properties = properties; + _status = UNIX_CALL(xrSetTilePropertiesHintMETA, ¶ms); + assert(!_status && "xrSetTilePropertiesHintMETA"); + return params.result; +} + XrResult WINAPI xrSetTrackingOptimizationSettingsHintQCOM(XrSession session, XrTrackingOptimizationSettingsDomainQCOM domain, XrTrackingOptimizationSettingsHintQCOM hint) { struct xrSetTrackingOptimizationSettingsHintQCOM_params params; @@ -4261,6 +4898,28 @@ XrResult WINAPI xrStructureTypeToString2KHR(XrInstance instance, XrStructureType return params.result; } +XrResult WINAPI xrSubmitSoundFieldBufferBD(XrSoundFieldBD soundField, const XrAudioBufferBD *buffer) +{ + struct xrSubmitSoundFieldBufferBD_params params; + NTSTATUS _status; + params.soundField = soundField; + params.buffer = buffer; + _status = UNIX_CALL(xrSubmitSoundFieldBufferBD, ¶ms); + assert(!_status && "xrSubmitSoundFieldBufferBD"); + return params.result; +} + +XrResult WINAPI xrSubmitSoundObjectBufferBD(XrSoundObjectBD soundObject, const XrAudioBufferBD *buffer) +{ + struct xrSubmitSoundObjectBufferBD_params params; + NTSTATUS _status; + params.soundObject = soundObject; + params.buffer = buffer; + _status = UNIX_CALL(xrSubmitSoundObjectBufferBD, ¶ms); + assert(!_status && "xrSubmitSoundObjectBufferBD"); + return params.result; +} + XrResult WINAPI xrSuggestBodyTrackingCalibrationOverrideMETA(XrBodyTrackerFB bodyTracker, const XrBodyTrackingCalibrationInfoMETA *calibrationInfo) { struct xrSuggestBodyTrackingCalibrationOverrideMETA_params params; @@ -4489,6 +5148,54 @@ XrResult WINAPI xrUpdatePassthroughColorLutMETA(XrPassthroughColorLutMETA colorL return params.result; } +XrResult WINAPI xrUpdateSoundFieldConfigBD(XrSoundFieldBD soundField, const XrSoundFieldConfigBD *config, XrSoundFieldFlagsBD flags) +{ + struct xrUpdateSoundFieldConfigBD_params params; + NTSTATUS _status; + params.soundField = soundField; + params.config = config; + params.flags = flags; + _status = UNIX_CALL(xrUpdateSoundFieldConfigBD, ¶ms); + assert(!_status && "xrUpdateSoundFieldConfigBD"); + return params.result; +} + +XrResult WINAPI xrUpdateSoundObjectConfigBD(XrSoundObjectBD soundObject, const XrSoundObjectConfigBD *config, XrSoundObjectFlagsBD flags) +{ + struct xrUpdateSoundObjectConfigBD_params params; + NTSTATUS _status; + params.soundObject = soundObject; + params.config = config; + params.flags = flags; + _status = UNIX_CALL(xrUpdateSoundObjectConfigBD, ¶ms); + assert(!_status && "xrUpdateSoundObjectConfigBD"); + return params.result; +} + +XrResult WINAPI xrUpdateSoundObstacleConfigBD(XrSoundObstacleBD soundObstacle, const XrSoundObstacleConfigBD *config, const XrSoundTriangleMeshBD *mesh, XrSoundObstacleFlagsBD flags) +{ + struct xrUpdateSoundObstacleConfigBD_params params; + NTSTATUS _status; + params.soundObstacle = soundObstacle; + params.config = config; + params.mesh = mesh; + params.flags = flags; + _status = UNIX_CALL(xrUpdateSoundObstacleConfigBD, ¶ms); + assert(!_status && "xrUpdateSoundObstacleConfigBD"); + return params.result; +} + +XrResult WINAPI xrUpdateSoundObstacleMaterialConfigBD(XrSoundObstacleMaterialBD material, const XrSoundObstacleMaterialConfigBD *config) +{ + struct xrUpdateSoundObstacleMaterialConfigBD_params params; + NTSTATUS _status; + params.material = material; + params.config = config; + _status = UNIX_CALL(xrUpdateSoundObstacleMaterialConfigBD, ¶ms); + assert(!_status && "xrUpdateSoundObstacleMaterialConfigBD"); + return params.result; +} + XrResult WINAPI xrUpdateSpatialAnchorsExpirationAsyncML(XrSpatialAnchorsStorageML storage, const XrSpatialAnchorsUpdateExpirationInfoML *updateInfo, XrFutureEXT *future) { struct xrUpdateSpatialAnchorsExpirationAsyncML_params params; @@ -4524,6 +5231,17 @@ XrResult WINAPI xrUpdateSwapchainFB(XrSwapchain swapchain, const XrSwapchainStat return params.result; } +XrResult WINAPI xrWaitAudioPeriodBD(XrSpatialAudioRendererBD renderer, XrDuration timeout) +{ + struct xrWaitAudioPeriodBD_params params; + NTSTATUS _status; + params.renderer = renderer; + params.timeout = timeout; + _status = UNIX_CALL(xrWaitAudioPeriodBD, ¶ms); + assert(!_status && "xrWaitAudioPeriodBD"); + return params.result; +} + XrResult WINAPI xrWaitFrame(XrSession session, const XrFrameWaitInfo *frameWaitInfo, XrFrameState *frameState) { struct xrWaitFrame_params params; @@ -4551,6 +5269,7 @@ static const struct openxr_func xr_instance_dispatch_table[] = { {"xrAcquireEnvironmentDepthImageMETA", xrAcquireEnvironmentDepthImageMETA}, {"xrAcquireSwapchainImage", xrAcquireSwapchainImage}, + {"xrAddTrackableImageDatabaseANDROID", xrAddTrackableImageDatabaseANDROID}, {"xrAllocateWorldMeshBufferML", xrAllocateWorldMeshBufferML}, {"xrApplyForceFeedbackCurlMNDX", xrApplyForceFeedbackCurlMNDX}, {"xrApplyHapticFeedback", xrApplyHapticFeedback}, @@ -4578,9 +5297,13 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrCreateDeviceAnchorPersistenceANDROID", xrCreateDeviceAnchorPersistenceANDROID}, {"xrCreateEnvironmentDepthProviderMETA", xrCreateEnvironmentDepthProviderMETA}, {"xrCreateEnvironmentDepthSwapchainMETA", xrCreateEnvironmentDepthSwapchainMETA}, + {"xrCreateEnvironmentRaycasterAsyncMETA", xrCreateEnvironmentRaycasterAsyncMETA}, + {"xrCreateEnvironmentRaycasterCompleteMETA", xrCreateEnvironmentRaycasterCompleteMETA}, {"xrCreateExportedLocalizationMapML", xrCreateExportedLocalizationMapML}, {"xrCreateEyeTrackerFB", xrCreateEyeTrackerFB}, {"xrCreateFaceTracker2FB", xrCreateFaceTracker2FB}, + {"xrCreateFaceTrackerANDROID", xrCreateFaceTrackerANDROID}, + {"xrCreateFaceTrackerBD", xrCreateFaceTrackerBD}, {"xrCreateFaceTrackerFB", xrCreateFaceTrackerFB}, {"xrCreateFacialExpressionClientML", xrCreateFacialExpressionClientML}, {"xrCreateFacialTrackerHTC", xrCreateFacialTrackerHTC}, @@ -4596,6 +5319,7 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrCreatePassthroughColorLutMETA", xrCreatePassthroughColorLutMETA}, {"xrCreatePassthroughFB", xrCreatePassthroughFB}, {"xrCreatePassthroughHTC", xrCreatePassthroughHTC}, + {"xrCreatePassthroughLayerANDROID", xrCreatePassthroughLayerANDROID}, {"xrCreatePassthroughLayerFB", xrCreatePassthroughLayerFB}, {"xrCreatePersistedAnchorSpaceANDROID", xrCreatePersistedAnchorSpaceANDROID}, {"xrCreatePlaneDetectorEXT", xrCreatePlaneDetectorEXT}, @@ -4604,9 +5328,15 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrCreateRenderModelEXT", xrCreateRenderModelEXT}, {"xrCreateRenderModelSpaceEXT", xrCreateRenderModelSpaceEXT}, {"xrCreateSceneMSFT", xrCreateSceneMSFT}, + {"xrCreateSceneMeshSnapshotANDROID", xrCreateSceneMeshSnapshotANDROID}, + {"xrCreateSceneMeshingTrackerANDROID", xrCreateSceneMeshingTrackerANDROID}, {"xrCreateSceneObserverMSFT", xrCreateSceneObserverMSFT}, {"xrCreateSenseDataProviderBD", xrCreateSenseDataProviderBD}, {"xrCreateSession", xrCreateSession}, + {"xrCreateSoundFieldBD", xrCreateSoundFieldBD}, + {"xrCreateSoundObjectBD", xrCreateSoundObjectBD}, + {"xrCreateSoundObstacleBD", xrCreateSoundObstacleBD}, + {"xrCreateSoundObstacleMaterialBD", xrCreateSoundObstacleMaterialBD}, {"xrCreateSpaceUserFB", xrCreateSpaceUserFB}, {"xrCreateSpatialAnchorAsyncBD", xrCreateSpatialAnchorAsyncBD}, {"xrCreateSpatialAnchorCompleteBD", xrCreateSpatialAnchorCompleteBD}, @@ -4615,11 +5345,14 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrCreateSpatialAnchorFromPersistedNameMSFT", xrCreateSpatialAnchorFromPersistedNameMSFT}, {"xrCreateSpatialAnchorHTC", xrCreateSpatialAnchorHTC}, {"xrCreateSpatialAnchorMSFT", xrCreateSpatialAnchorMSFT}, + {"xrCreateSpatialAnchorSpaceANDROID", xrCreateSpatialAnchorSpaceANDROID}, + {"xrCreateSpatialAnchorSpaceFromIdANDROID", xrCreateSpatialAnchorSpaceFromIdANDROID}, {"xrCreateSpatialAnchorSpaceMSFT", xrCreateSpatialAnchorSpaceMSFT}, {"xrCreateSpatialAnchorStoreConnectionMSFT", xrCreateSpatialAnchorStoreConnectionMSFT}, {"xrCreateSpatialAnchorsAsyncML", xrCreateSpatialAnchorsAsyncML}, {"xrCreateSpatialAnchorsCompleteML", xrCreateSpatialAnchorsCompleteML}, {"xrCreateSpatialAnchorsStorageML", xrCreateSpatialAnchorsStorageML}, + {"xrCreateSpatialAudioRendererBD", xrCreateSpatialAudioRendererBD}, {"xrCreateSpatialContextAsyncEXT", xrCreateSpatialContextAsyncEXT}, {"xrCreateSpatialContextCompleteEXT", xrCreateSpatialContextCompleteEXT}, {"xrCreateSpatialDiscoverySnapshotAsyncEXT", xrCreateSpatialDiscoverySnapshotAsyncEXT}, @@ -4629,8 +5362,11 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrCreateSpatialGraphNodeSpaceMSFT", xrCreateSpatialGraphNodeSpaceMSFT}, {"xrCreateSpatialPersistenceContextAsyncEXT", xrCreateSpatialPersistenceContextAsyncEXT}, {"xrCreateSpatialPersistenceContextCompleteEXT", xrCreateSpatialPersistenceContextCompleteEXT}, + {"xrCreateSpatialRaycastSnapshotANDROID", xrCreateSpatialRaycastSnapshotANDROID}, {"xrCreateSpatialUpdateSnapshotEXT", xrCreateSpatialUpdateSnapshotEXT}, {"xrCreateSwapchain", xrCreateSwapchain}, + {"xrCreateTrackableImageDatabaseAsyncANDROID", xrCreateTrackableImageDatabaseAsyncANDROID}, + {"xrCreateTrackableImageDatabaseCompleteANDROID", xrCreateTrackableImageDatabaseCompleteANDROID}, {"xrCreateTrackableTrackerANDROID", xrCreateTrackableTrackerANDROID}, {"xrCreateTriangleMeshFB", xrCreateTriangleMeshFB}, {"xrCreateVirtualKeyboardMETA", xrCreateVirtualKeyboardMETA}, @@ -4650,9 +5386,12 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrDestroyDeviceAnchorPersistenceANDROID", xrDestroyDeviceAnchorPersistenceANDROID}, {"xrDestroyEnvironmentDepthProviderMETA", xrDestroyEnvironmentDepthProviderMETA}, {"xrDestroyEnvironmentDepthSwapchainMETA", xrDestroyEnvironmentDepthSwapchainMETA}, + {"xrDestroyEnvironmentRaycasterMETA", xrDestroyEnvironmentRaycasterMETA}, {"xrDestroyExportedLocalizationMapML", xrDestroyExportedLocalizationMapML}, {"xrDestroyEyeTrackerFB", xrDestroyEyeTrackerFB}, {"xrDestroyFaceTracker2FB", xrDestroyFaceTracker2FB}, + {"xrDestroyFaceTrackerANDROID", xrDestroyFaceTrackerANDROID}, + {"xrDestroyFaceTrackerBD", xrDestroyFaceTrackerBD}, {"xrDestroyFaceTrackerFB", xrDestroyFaceTrackerFB}, {"xrDestroyFacialExpressionClientML", xrDestroyFacialExpressionClientML}, {"xrDestroyFacialTrackerHTC", xrDestroyFacialTrackerHTC}, @@ -4664,26 +5403,35 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrDestroyPassthroughColorLutMETA", xrDestroyPassthroughColorLutMETA}, {"xrDestroyPassthroughFB", xrDestroyPassthroughFB}, {"xrDestroyPassthroughHTC", xrDestroyPassthroughHTC}, + {"xrDestroyPassthroughLayerANDROID", xrDestroyPassthroughLayerANDROID}, {"xrDestroyPassthroughLayerFB", xrDestroyPassthroughLayerFB}, {"xrDestroyPlaneDetectorEXT", xrDestroyPlaneDetectorEXT}, {"xrDestroyRenderModelAssetEXT", xrDestroyRenderModelAssetEXT}, {"xrDestroyRenderModelEXT", xrDestroyRenderModelEXT}, {"xrDestroySceneMSFT", xrDestroySceneMSFT}, + {"xrDestroySceneMeshSnapshotANDROID", xrDestroySceneMeshSnapshotANDROID}, + {"xrDestroySceneMeshingTrackerANDROID", xrDestroySceneMeshingTrackerANDROID}, {"xrDestroySceneObserverMSFT", xrDestroySceneObserverMSFT}, {"xrDestroySenseDataProviderBD", xrDestroySenseDataProviderBD}, {"xrDestroySenseDataSnapshotBD", xrDestroySenseDataSnapshotBD}, {"xrDestroySession", xrDestroySession}, + {"xrDestroySoundFieldBD", xrDestroySoundFieldBD}, + {"xrDestroySoundObjectBD", xrDestroySoundObjectBD}, + {"xrDestroySoundObstacleBD", xrDestroySoundObstacleBD}, + {"xrDestroySoundObstacleMaterialBD", xrDestroySoundObstacleMaterialBD}, {"xrDestroySpace", xrDestroySpace}, {"xrDestroySpaceUserFB", xrDestroySpaceUserFB}, {"xrDestroySpatialAnchorMSFT", xrDestroySpatialAnchorMSFT}, {"xrDestroySpatialAnchorStoreConnectionMSFT", xrDestroySpatialAnchorStoreConnectionMSFT}, {"xrDestroySpatialAnchorsStorageML", xrDestroySpatialAnchorsStorageML}, + {"xrDestroySpatialAudioRendererBD", xrDestroySpatialAudioRendererBD}, {"xrDestroySpatialContextEXT", xrDestroySpatialContextEXT}, {"xrDestroySpatialEntityEXT", xrDestroySpatialEntityEXT}, {"xrDestroySpatialGraphNodeBindingMSFT", xrDestroySpatialGraphNodeBindingMSFT}, {"xrDestroySpatialPersistenceContextEXT", xrDestroySpatialPersistenceContextEXT}, {"xrDestroySpatialSnapshotEXT", xrDestroySpatialSnapshotEXT}, {"xrDestroySwapchain", xrDestroySwapchain}, + {"xrDestroyTrackableImageDatabaseANDROID", xrDestroyTrackableImageDatabaseANDROID}, {"xrDestroyTrackableTrackerANDROID", xrDestroyTrackableTrackerANDROID}, {"xrDestroyTriangleMeshFB", xrDestroyTriangleMeshFB}, {"xrDestroyVirtualKeyboardMETA", xrDestroyVirtualKeyboardMETA}, @@ -4693,6 +5441,7 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrDownloadSharedSpatialAnchorCompleteBD", xrDownloadSharedSpatialAnchorCompleteBD}, {"xrEnableLocalizationEventsML", xrEnableLocalizationEventsML}, {"xrEnableUserCalibrationEventsML", xrEnableUserCalibrationEventsML}, + {"xrEndAudioPeriodBD", xrEndAudioPeriodBD}, {"xrEndFrame", xrEndFrame}, {"xrEndSession", xrEndSession}, {"xrEnumerateApiLayerProperties", xrEnumerateApiLayerProperties}, @@ -4702,8 +5451,10 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrEnumerateEnvironmentBlendModes", xrEnumerateEnvironmentBlendModes}, {"xrEnumerateEnvironmentDepthSwapchainImagesMETA", xrEnumerateEnvironmentDepthSwapchainImagesMETA}, {"xrEnumerateExternalCamerasOCULUS", xrEnumerateExternalCamerasOCULUS}, + {"xrEnumerateFacialSimulationModesBD", xrEnumerateFacialSimulationModesBD}, {"xrEnumerateInstanceExtensionProperties", xrEnumerateInstanceExtensionProperties}, {"xrEnumerateInteractionRenderModelIdsEXT", xrEnumerateInteractionRenderModelIdsEXT}, + {"xrEnumeratePerformanceMetricsCounterPathsANDROID", xrEnumeratePerformanceMetricsCounterPathsANDROID}, {"xrEnumeratePerformanceMetricsCounterPathsMETA", xrEnumeratePerformanceMetricsCounterPathsMETA}, {"xrEnumeratePersistedAnchorsANDROID", xrEnumeratePersistedAnchorsANDROID}, {"xrEnumeratePersistedSpatialAnchorNamesMSFT", xrEnumeratePersistedSpatialAnchorNamesMSFT}, @@ -4714,13 +5465,16 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrEnumerateReprojectionModesMSFT", xrEnumerateReprojectionModesMSFT}, {"xrEnumerateSceneComputeFeaturesMSFT", xrEnumerateSceneComputeFeaturesMSFT}, {"xrEnumerateSpaceSupportedComponentsFB", xrEnumerateSpaceSupportedComponentsFB}, + {"xrEnumerateSpatialAnchorAttachableComponentsANDROID", xrEnumerateSpatialAnchorAttachableComponentsANDROID}, {"xrEnumerateSpatialCapabilitiesEXT", xrEnumerateSpatialCapabilitiesEXT}, {"xrEnumerateSpatialCapabilityComponentTypesEXT", xrEnumerateSpatialCapabilityComponentTypesEXT}, {"xrEnumerateSpatialCapabilityFeaturesEXT", xrEnumerateSpatialCapabilityFeaturesEXT}, {"xrEnumerateSpatialEntityComponentTypesBD", xrEnumerateSpatialEntityComponentTypesBD}, {"xrEnumerateSpatialPersistenceScopesEXT", xrEnumerateSpatialPersistenceScopesEXT}, {"xrEnumerateSupportedAnchorTrackableTypesANDROID", xrEnumerateSupportedAnchorTrackableTypesANDROID}, + {"xrEnumerateSupportedAudioSampleRateBD", xrEnumerateSupportedAudioSampleRateBD}, {"xrEnumerateSupportedPersistenceAnchorTypesANDROID", xrEnumerateSupportedPersistenceAnchorTypesANDROID}, + {"xrEnumerateSupportedSemanticLabelSetsANDROID", xrEnumerateSupportedSemanticLabelSetsANDROID}, {"xrEnumerateSupportedTrackableTypesANDROID", xrEnumerateSupportedTrackableTypesANDROID}, {"xrEnumerateSwapchainFormats", xrEnumerateSwapchainFormats}, {"xrEnumerateSwapchainImages", xrEnumerateSwapchainImages}, @@ -4735,6 +5489,7 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrGetActionStateFloat", xrGetActionStateFloat}, {"xrGetActionStatePose", xrGetActionStatePose}, {"xrGetActionStateVector2f", xrGetActionStateVector2f}, + {"xrGetAllSubmeshStatesANDROID", xrGetAllSubmeshStatesANDROID}, {"xrGetAllTrackablesANDROID", xrGetAllTrackablesANDROID}, {"xrGetAnchorPersistStateANDROID", xrGetAnchorPersistStateANDROID}, {"xrGetAnchorUuidBD", xrGetAnchorUuidBD}, @@ -4753,11 +5508,16 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrGetEnvironmentDepthSwapchainStateMETA", xrGetEnvironmentDepthSwapchainStateMETA}, {"xrGetExportedLocalizationMapDataML", xrGetExportedLocalizationMapDataML}, {"xrGetEyeGazesFB", xrGetEyeGazesFB}, + {"xrGetFaceCalibrationStateANDROID", xrGetFaceCalibrationStateANDROID}, {"xrGetFaceExpressionWeights2FB", xrGetFaceExpressionWeights2FB}, {"xrGetFaceExpressionWeightsFB", xrGetFaceExpressionWeightsFB}, + {"xrGetFaceStateANDROID", xrGetFaceStateANDROID}, {"xrGetFacialExpressionBlendShapePropertiesML", xrGetFacialExpressionBlendShapePropertiesML}, {"xrGetFacialExpressionsHTC", xrGetFacialExpressionsHTC}, + {"xrGetFacialSimulationDataBD", xrGetFacialSimulationDataBD}, + {"xrGetFacialSimulationModeBD", xrGetFacialSimulationModeBD}, {"xrGetFoveationEyeTrackedStateMETA", xrGetFoveationEyeTrackedStateMETA}, + {"xrGetHandGestureQCOM", xrGetHandGestureQCOM}, {"xrGetHandMeshFB", xrGetHandMeshFB}, {"xrGetInputSourceLocalizedName", xrGetInputSourceLocalizedName}, {"xrGetInstanceProcAddr", xrGetInstanceProcAddr}, @@ -4772,6 +5532,7 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrGetOpenGLGraphicsRequirementsKHR", xrGetOpenGLGraphicsRequirementsKHR}, {"xrGetPassthroughCameraStateANDROID", xrGetPassthroughCameraStateANDROID}, {"xrGetPassthroughPreferencesMETA", xrGetPassthroughPreferencesMETA}, + {"xrGetPerformanceMetricsStateANDROID", xrGetPerformanceMetricsStateANDROID}, {"xrGetPerformanceMetricsStateMETA", xrGetPerformanceMetricsStateMETA}, {"xrGetPlaneDetectionStateEXT", xrGetPlaneDetectionStateEXT}, {"xrGetPlaneDetectionsEXT", xrGetPlaneDetectionsEXT}, @@ -4814,12 +5575,15 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrGetSpatialEntityComponentDataBD", xrGetSpatialEntityComponentDataBD}, {"xrGetSpatialEntityUuidBD", xrGetSpatialEntityUuidBD}, {"xrGetSpatialGraphNodeBindingPropertiesMSFT", xrGetSpatialGraphNodeBindingPropertiesMSFT}, + {"xrGetSubmeshDataANDROID", xrGetSubmeshDataANDROID}, {"xrGetSwapchainStateFB", xrGetSwapchainStateFB}, {"xrGetSystem", xrGetSystem}, {"xrGetSystemProperties", xrGetSystemProperties}, + {"xrGetTrackableImageANDROID", xrGetTrackableImageANDROID}, {"xrGetTrackableMarkerANDROID", xrGetTrackableMarkerANDROID}, {"xrGetTrackableObjectANDROID", xrGetTrackableObjectANDROID}, {"xrGetTrackablePlaneANDROID", xrGetTrackablePlaneANDROID}, + {"xrGetTrackableQrCodeANDROID", xrGetTrackableQrCodeANDROID}, {"xrGetViewConfigurationProperties", xrGetViewConfigurationProperties}, {"xrGetVirtualKeyboardDirtyTexturesMETA", xrGetVirtualKeyboardDirtyTexturesMETA}, {"xrGetVirtualKeyboardModelAnimationStatesMETA", xrGetVirtualKeyboardModelAnimationStatesMETA}, @@ -4855,6 +5619,7 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrPathToString", xrPathToString}, {"xrPauseSimultaneousHandsAndControllersTrackingMETA", xrPauseSimultaneousHandsAndControllersTrackingMETA}, {"xrPerfSettingsSetPerformanceLevelEXT", xrPerfSettingsSetPerformanceLevelEXT}, + {"xrPerformEnvironmentRaycastMETA", xrPerformEnvironmentRaycastMETA}, {"xrPersistAnchorANDROID", xrPersistAnchorANDROID}, {"xrPersistSpatialAnchorAsyncBD", xrPersistSpatialAnchorAsyncBD}, {"xrPersistSpatialAnchorCompleteBD", xrPersistSpatialAnchorCompleteBD}, @@ -4865,7 +5630,9 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrPollFutureEXT", xrPollFutureEXT}, {"xrPublishSpatialAnchorsAsyncML", xrPublishSpatialAnchorsAsyncML}, {"xrPublishSpatialAnchorsCompleteML", xrPublishSpatialAnchorsCompleteML}, + {"xrQueryFramesPerBufferRangeBD", xrQueryFramesPerBufferRangeBD}, {"xrQueryLocalizationMapsML", xrQueryLocalizationMapsML}, + {"xrQueryPerformanceMetricsCounterANDROID", xrQueryPerformanceMetricsCounterANDROID}, {"xrQueryPerformanceMetricsCounterMETA", xrQueryPerformanceMetricsCounterMETA}, {"xrQuerySenseDataAsyncBD", xrQuerySenseDataAsyncBD}, {"xrQuerySenseDataCompleteBD", xrQuerySenseDataCompleteBD}, @@ -4876,6 +5643,8 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrQuerySystemTrackedKeyboardFB", xrQuerySystemTrackedKeyboardFB}, {"xrRaycastANDROID", xrRaycastANDROID}, {"xrReleaseSwapchainImage", xrReleaseSwapchainImage}, + {"xrRemoveTrackableImageDatabaseANDROID", xrRemoveTrackableImageDatabaseANDROID}, + {"xrRequestBodyTrackingFidelityMETA", xrRequestBodyTrackingFidelityMETA}, {"xrRequestDisplayRefreshRateFB", xrRequestDisplayRefreshRateFB}, {"xrRequestExitSession", xrRequestExitSession}, {"xrRequestMapLocalizationML", xrRequestMapLocalizationML}, @@ -4897,6 +5666,7 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrSetDigitalLensControlALMALENCE", xrSetDigitalLensControlALMALENCE}, {"xrSetEnvironmentDepthEstimationVARJO", xrSetEnvironmentDepthEstimationVARJO}, {"xrSetEnvironmentDepthHandRemovalMETA", xrSetEnvironmentDepthHandRemovalMETA}, + {"xrSetFacialSimulationModeBD", xrSetFacialSimulationModeBD}, {"xrSetInputDeviceActiveEXT", xrSetInputDeviceActiveEXT}, {"xrSetInputDeviceLocationEXT", xrSetInputDeviceLocationEXT}, {"xrSetInputDeviceStateBoolEXT", xrSetInputDeviceStateBoolEXT}, @@ -4905,9 +5675,12 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrSetMarkerTrackingPredictionVARJO", xrSetMarkerTrackingPredictionVARJO}, {"xrSetMarkerTrackingTimeoutVARJO", xrSetMarkerTrackingTimeoutVARJO}, {"xrSetMarkerTrackingVARJO", xrSetMarkerTrackingVARJO}, + {"xrSetPassthroughLayerMeshANDROID", xrSetPassthroughLayerMeshANDROID}, + {"xrSetPerformanceMetricsStateANDROID", xrSetPerformanceMetricsStateANDROID}, {"xrSetPerformanceMetricsStateMETA", xrSetPerformanceMetricsStateMETA}, {"xrSetSpaceComponentStatusFB", xrSetSpaceComponentStatusFB}, {"xrSetSystemNotificationsML", xrSetSystemNotificationsML}, + {"xrSetTilePropertiesHintMETA", xrSetTilePropertiesHintMETA}, {"xrSetTrackingOptimizationSettingsHintQCOM", xrSetTrackingOptimizationSettingsHintQCOM}, {"xrSetViewOffsetVARJO", xrSetViewOffsetVARJO}, {"xrSetVirtualKeyboardModelVisibilityMETA", xrSetVirtualKeyboardModelVisibilityMETA}, @@ -4929,6 +5702,8 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrStringToPath", xrStringToPath}, {"xrStructureTypeToString", xrStructureTypeToString}, {"xrStructureTypeToString2KHR", xrStructureTypeToString2KHR}, + {"xrSubmitSoundFieldBufferBD", xrSubmitSoundFieldBufferBD}, + {"xrSubmitSoundObjectBufferBD", xrSubmitSoundObjectBufferBD}, {"xrSuggestBodyTrackingCalibrationOverrideMETA", xrSuggestBodyTrackingCalibrationOverrideMETA}, {"xrSuggestInteractionProfileBindings", xrSuggestInteractionProfileBindings}, {"xrSuggestVirtualKeyboardLocationMETA", xrSuggestVirtualKeyboardLocationMETA}, @@ -4949,9 +5724,14 @@ static const struct openxr_func xr_instance_dispatch_table[] = {"xrUnpersistSpatialEntityCompleteEXT", xrUnpersistSpatialEntityCompleteEXT}, {"xrUpdateHandMeshMSFT", xrUpdateHandMeshMSFT}, {"xrUpdatePassthroughColorLutMETA", xrUpdatePassthroughColorLutMETA}, + {"xrUpdateSoundFieldConfigBD", xrUpdateSoundFieldConfigBD}, + {"xrUpdateSoundObjectConfigBD", xrUpdateSoundObjectConfigBD}, + {"xrUpdateSoundObstacleConfigBD", xrUpdateSoundObstacleConfigBD}, + {"xrUpdateSoundObstacleMaterialConfigBD", xrUpdateSoundObstacleMaterialConfigBD}, {"xrUpdateSpatialAnchorsExpirationAsyncML", xrUpdateSpatialAnchorsExpirationAsyncML}, {"xrUpdateSpatialAnchorsExpirationCompleteML", xrUpdateSpatialAnchorsExpirationCompleteML}, {"xrUpdateSwapchainFB", xrUpdateSwapchainFB}, + {"xrWaitAudioPeriodBD", xrWaitAudioPeriodBD}, {"xrWaitFrame", xrWaitFrame}, {"xrWaitSwapchainImage", xrWaitSwapchainImage}, }; diff --git a/wineopenxr/loader_thunks.h b/wineopenxr/loader_thunks.h index 1dac24780a1..24d4ff18bdd 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-2025 The Khronos Group Inc. + * Copyright (c) 2017-2026 The Khronos Group Inc. * * SPDX-License-Identifier: Apache-2.0 OR MIT * @@ -28,6 +28,7 @@ enum unix_call unix_is_available_instance_function, unix_xrAcquireEnvironmentDepthImageMETA, unix_xrAcquireSwapchainImage, + unix_xrAddTrackableImageDatabaseANDROID, unix_xrAllocateWorldMeshBufferML, unix_xrApplyForceFeedbackCurlMNDX, unix_xrApplyHapticFeedback, @@ -54,9 +55,13 @@ enum unix_call unix_xrCreateDeviceAnchorPersistenceANDROID, unix_xrCreateEnvironmentDepthProviderMETA, unix_xrCreateEnvironmentDepthSwapchainMETA, + unix_xrCreateEnvironmentRaycasterAsyncMETA, + unix_xrCreateEnvironmentRaycasterCompleteMETA, unix_xrCreateExportedLocalizationMapML, unix_xrCreateEyeTrackerFB, unix_xrCreateFaceTracker2FB, + unix_xrCreateFaceTrackerANDROID, + unix_xrCreateFaceTrackerBD, unix_xrCreateFaceTrackerFB, unix_xrCreateFacialExpressionClientML, unix_xrCreateFacialTrackerHTC, @@ -72,6 +77,7 @@ enum unix_call unix_xrCreatePassthroughColorLutMETA, unix_xrCreatePassthroughFB, unix_xrCreatePassthroughHTC, + unix_xrCreatePassthroughLayerANDROID, unix_xrCreatePassthroughLayerFB, unix_xrCreatePersistedAnchorSpaceANDROID, unix_xrCreatePlaneDetectorEXT, @@ -80,9 +86,15 @@ enum unix_call unix_xrCreateRenderModelEXT, unix_xrCreateRenderModelSpaceEXT, unix_xrCreateSceneMSFT, + unix_xrCreateSceneMeshSnapshotANDROID, + unix_xrCreateSceneMeshingTrackerANDROID, unix_xrCreateSceneObserverMSFT, unix_xrCreateSenseDataProviderBD, unix_xrCreateSession, + unix_xrCreateSoundFieldBD, + unix_xrCreateSoundObjectBD, + unix_xrCreateSoundObstacleBD, + unix_xrCreateSoundObstacleMaterialBD, unix_xrCreateSpaceUserFB, unix_xrCreateSpatialAnchorAsyncBD, unix_xrCreateSpatialAnchorCompleteBD, @@ -91,11 +103,14 @@ enum unix_call unix_xrCreateSpatialAnchorFromPersistedNameMSFT, unix_xrCreateSpatialAnchorHTC, unix_xrCreateSpatialAnchorMSFT, + unix_xrCreateSpatialAnchorSpaceANDROID, + unix_xrCreateSpatialAnchorSpaceFromIdANDROID, unix_xrCreateSpatialAnchorSpaceMSFT, unix_xrCreateSpatialAnchorStoreConnectionMSFT, unix_xrCreateSpatialAnchorsAsyncML, unix_xrCreateSpatialAnchorsCompleteML, unix_xrCreateSpatialAnchorsStorageML, + unix_xrCreateSpatialAudioRendererBD, unix_xrCreateSpatialContextAsyncEXT, unix_xrCreateSpatialContextCompleteEXT, unix_xrCreateSpatialDiscoverySnapshotAsyncEXT, @@ -105,8 +120,11 @@ enum unix_call unix_xrCreateSpatialGraphNodeSpaceMSFT, unix_xrCreateSpatialPersistenceContextAsyncEXT, unix_xrCreateSpatialPersistenceContextCompleteEXT, + unix_xrCreateSpatialRaycastSnapshotANDROID, unix_xrCreateSpatialUpdateSnapshotEXT, unix_xrCreateSwapchain, + unix_xrCreateTrackableImageDatabaseAsyncANDROID, + unix_xrCreateTrackableImageDatabaseCompleteANDROID, unix_xrCreateTrackableTrackerANDROID, unix_xrCreateTriangleMeshFB, unix_xrCreateVirtualKeyboardMETA, @@ -124,9 +142,12 @@ enum unix_call unix_xrDestroyDeviceAnchorPersistenceANDROID, unix_xrDestroyEnvironmentDepthProviderMETA, unix_xrDestroyEnvironmentDepthSwapchainMETA, + unix_xrDestroyEnvironmentRaycasterMETA, unix_xrDestroyExportedLocalizationMapML, unix_xrDestroyEyeTrackerFB, unix_xrDestroyFaceTracker2FB, + unix_xrDestroyFaceTrackerANDROID, + unix_xrDestroyFaceTrackerBD, unix_xrDestroyFaceTrackerFB, unix_xrDestroyFacialExpressionClientML, unix_xrDestroyFacialTrackerHTC, @@ -138,26 +159,35 @@ enum unix_call unix_xrDestroyPassthroughColorLutMETA, unix_xrDestroyPassthroughFB, unix_xrDestroyPassthroughHTC, + unix_xrDestroyPassthroughLayerANDROID, unix_xrDestroyPassthroughLayerFB, unix_xrDestroyPlaneDetectorEXT, unix_xrDestroyRenderModelAssetEXT, unix_xrDestroyRenderModelEXT, unix_xrDestroySceneMSFT, + unix_xrDestroySceneMeshSnapshotANDROID, + unix_xrDestroySceneMeshingTrackerANDROID, unix_xrDestroySceneObserverMSFT, unix_xrDestroySenseDataProviderBD, unix_xrDestroySenseDataSnapshotBD, unix_xrDestroySession, + unix_xrDestroySoundFieldBD, + unix_xrDestroySoundObjectBD, + unix_xrDestroySoundObstacleBD, + unix_xrDestroySoundObstacleMaterialBD, unix_xrDestroySpace, unix_xrDestroySpaceUserFB, unix_xrDestroySpatialAnchorMSFT, unix_xrDestroySpatialAnchorStoreConnectionMSFT, unix_xrDestroySpatialAnchorsStorageML, + unix_xrDestroySpatialAudioRendererBD, unix_xrDestroySpatialContextEXT, unix_xrDestroySpatialEntityEXT, unix_xrDestroySpatialGraphNodeBindingMSFT, unix_xrDestroySpatialPersistenceContextEXT, unix_xrDestroySpatialSnapshotEXT, unix_xrDestroySwapchain, + unix_xrDestroyTrackableImageDatabaseANDROID, unix_xrDestroyTrackableTrackerANDROID, unix_xrDestroyTriangleMeshFB, unix_xrDestroyVirtualKeyboardMETA, @@ -167,6 +197,7 @@ enum unix_call unix_xrDownloadSharedSpatialAnchorCompleteBD, unix_xrEnableLocalizationEventsML, unix_xrEnableUserCalibrationEventsML, + unix_xrEndAudioPeriodBD, unix_xrEndFrame, unix_xrEndSession, unix_xrEnumerateApiLayerProperties, @@ -176,8 +207,10 @@ enum unix_call unix_xrEnumerateEnvironmentBlendModes, unix_xrEnumerateEnvironmentDepthSwapchainImagesMETA, unix_xrEnumerateExternalCamerasOCULUS, + unix_xrEnumerateFacialSimulationModesBD, unix_xrEnumerateInstanceExtensionProperties, unix_xrEnumerateInteractionRenderModelIdsEXT, + unix_xrEnumeratePerformanceMetricsCounterPathsANDROID, unix_xrEnumeratePerformanceMetricsCounterPathsMETA, unix_xrEnumeratePersistedAnchorsANDROID, unix_xrEnumeratePersistedSpatialAnchorNamesMSFT, @@ -188,13 +221,16 @@ enum unix_call unix_xrEnumerateReprojectionModesMSFT, unix_xrEnumerateSceneComputeFeaturesMSFT, unix_xrEnumerateSpaceSupportedComponentsFB, + unix_xrEnumerateSpatialAnchorAttachableComponentsANDROID, unix_xrEnumerateSpatialCapabilitiesEXT, unix_xrEnumerateSpatialCapabilityComponentTypesEXT, unix_xrEnumerateSpatialCapabilityFeaturesEXT, unix_xrEnumerateSpatialEntityComponentTypesBD, unix_xrEnumerateSpatialPersistenceScopesEXT, unix_xrEnumerateSupportedAnchorTrackableTypesANDROID, + unix_xrEnumerateSupportedAudioSampleRateBD, unix_xrEnumerateSupportedPersistenceAnchorTypesANDROID, + unix_xrEnumerateSupportedSemanticLabelSetsANDROID, unix_xrEnumerateSupportedTrackableTypesANDROID, unix_xrEnumerateSwapchainFormats, unix_xrEnumerateSwapchainImages, @@ -209,6 +245,7 @@ enum unix_call unix_xrGetActionStateFloat, unix_xrGetActionStatePose, unix_xrGetActionStateVector2f, + unix_xrGetAllSubmeshStatesANDROID, unix_xrGetAllTrackablesANDROID, unix_xrGetAnchorPersistStateANDROID, unix_xrGetAnchorUuidBD, @@ -225,11 +262,16 @@ enum unix_call unix_xrGetEnvironmentDepthSwapchainStateMETA, unix_xrGetExportedLocalizationMapDataML, unix_xrGetEyeGazesFB, + unix_xrGetFaceCalibrationStateANDROID, unix_xrGetFaceExpressionWeights2FB, unix_xrGetFaceExpressionWeightsFB, + unix_xrGetFaceStateANDROID, unix_xrGetFacialExpressionBlendShapePropertiesML, unix_xrGetFacialExpressionsHTC, + unix_xrGetFacialSimulationDataBD, + unix_xrGetFacialSimulationModeBD, unix_xrGetFoveationEyeTrackedStateMETA, + unix_xrGetHandGestureQCOM, unix_xrGetHandMeshFB, unix_xrGetInputSourceLocalizedName, unix_xrGetInstanceProperties, @@ -243,6 +285,7 @@ enum unix_call unix_xrGetOpenGLGraphicsRequirementsKHR, unix_xrGetPassthroughCameraStateANDROID, unix_xrGetPassthroughPreferencesMETA, + unix_xrGetPerformanceMetricsStateANDROID, unix_xrGetPerformanceMetricsStateMETA, unix_xrGetPlaneDetectionStateEXT, unix_xrGetPlaneDetectionsEXT, @@ -285,12 +328,15 @@ enum unix_call unix_xrGetSpatialEntityComponentDataBD, unix_xrGetSpatialEntityUuidBD, unix_xrGetSpatialGraphNodeBindingPropertiesMSFT, + unix_xrGetSubmeshDataANDROID, unix_xrGetSwapchainStateFB, unix_xrGetSystem, unix_xrGetSystemProperties, + unix_xrGetTrackableImageANDROID, unix_xrGetTrackableMarkerANDROID, unix_xrGetTrackableObjectANDROID, unix_xrGetTrackablePlaneANDROID, + unix_xrGetTrackableQrCodeANDROID, unix_xrGetViewConfigurationProperties, unix_xrGetVirtualKeyboardDirtyTexturesMETA, unix_xrGetVirtualKeyboardModelAnimationStatesMETA, @@ -325,6 +371,7 @@ enum unix_call unix_xrPathToString, unix_xrPauseSimultaneousHandsAndControllersTrackingMETA, unix_xrPerfSettingsSetPerformanceLevelEXT, + unix_xrPerformEnvironmentRaycastMETA, unix_xrPersistAnchorANDROID, unix_xrPersistSpatialAnchorAsyncBD, unix_xrPersistSpatialAnchorCompleteBD, @@ -335,7 +382,9 @@ enum unix_call unix_xrPollFutureEXT, unix_xrPublishSpatialAnchorsAsyncML, unix_xrPublishSpatialAnchorsCompleteML, + unix_xrQueryFramesPerBufferRangeBD, unix_xrQueryLocalizationMapsML, + unix_xrQueryPerformanceMetricsCounterANDROID, unix_xrQueryPerformanceMetricsCounterMETA, unix_xrQuerySenseDataAsyncBD, unix_xrQuerySenseDataCompleteBD, @@ -346,6 +395,8 @@ enum unix_call unix_xrQuerySystemTrackedKeyboardFB, unix_xrRaycastANDROID, unix_xrReleaseSwapchainImage, + unix_xrRemoveTrackableImageDatabaseANDROID, + unix_xrRequestBodyTrackingFidelityMETA, unix_xrRequestDisplayRefreshRateFB, unix_xrRequestExitSession, unix_xrRequestMapLocalizationML, @@ -367,6 +418,7 @@ enum unix_call unix_xrSetDigitalLensControlALMALENCE, unix_xrSetEnvironmentDepthEstimationVARJO, unix_xrSetEnvironmentDepthHandRemovalMETA, + unix_xrSetFacialSimulationModeBD, unix_xrSetInputDeviceActiveEXT, unix_xrSetInputDeviceLocationEXT, unix_xrSetInputDeviceStateBoolEXT, @@ -375,9 +427,12 @@ enum unix_call unix_xrSetMarkerTrackingPredictionVARJO, unix_xrSetMarkerTrackingTimeoutVARJO, unix_xrSetMarkerTrackingVARJO, + unix_xrSetPassthroughLayerMeshANDROID, + unix_xrSetPerformanceMetricsStateANDROID, unix_xrSetPerformanceMetricsStateMETA, unix_xrSetSpaceComponentStatusFB, unix_xrSetSystemNotificationsML, + unix_xrSetTilePropertiesHintMETA, unix_xrSetTrackingOptimizationSettingsHintQCOM, unix_xrSetViewOffsetVARJO, unix_xrSetVirtualKeyboardModelVisibilityMETA, @@ -399,6 +454,8 @@ enum unix_call unix_xrStringToPath, unix_xrStructureTypeToString, unix_xrStructureTypeToString2KHR, + unix_xrSubmitSoundFieldBufferBD, + unix_xrSubmitSoundObjectBufferBD, unix_xrSuggestBodyTrackingCalibrationOverrideMETA, unix_xrSuggestInteractionProfileBindings, unix_xrSuggestVirtualKeyboardLocationMETA, @@ -419,9 +476,14 @@ enum unix_call unix_xrUnpersistSpatialEntityCompleteEXT, unix_xrUpdateHandMeshMSFT, unix_xrUpdatePassthroughColorLutMETA, + unix_xrUpdateSoundFieldConfigBD, + unix_xrUpdateSoundObjectConfigBD, + unix_xrUpdateSoundObstacleConfigBD, + unix_xrUpdateSoundObstacleMaterialConfigBD, unix_xrUpdateSpatialAnchorsExpirationAsyncML, unix_xrUpdateSpatialAnchorsExpirationCompleteML, unix_xrUpdateSwapchainFB, + unix_xrWaitAudioPeriodBD, unix_xrWaitFrame, unix_xrWaitSwapchainImage, unix_count, @@ -443,6 +505,13 @@ struct xrAcquireSwapchainImage_params XrResult result; }; +struct xrAddTrackableImageDatabaseANDROID_params +{ + XrTrackableTrackerANDROID tracker; + XrTrackableImageDatabaseANDROID database; + XrResult result; +}; + struct xrAllocateWorldMeshBufferML_params { XrWorldMeshDetectorML detector; @@ -641,6 +710,22 @@ struct xrCreateEnvironmentDepthSwapchainMETA_params XrResult result; }; +struct xrCreateEnvironmentRaycasterAsyncMETA_params +{ + XrSession session; + const XrEnvironmentRaycasterCreateInfoMETA *info; + XrFutureEXT *future; + XrResult result; +}; + +struct xrCreateEnvironmentRaycasterCompleteMETA_params +{ + XrSession session; + XrFutureEXT future; + XrEnvironmentRaycasterCreateCompletionMETA *completion; + XrResult result; +}; + struct xrCreateExportedLocalizationMapML_params { XrSession session; @@ -665,6 +750,22 @@ struct xrCreateFaceTracker2FB_params XrResult result; }; +struct xrCreateFaceTrackerANDROID_params +{ + XrSession session; + const XrFaceTrackerCreateInfoANDROID *createInfo; + XrFaceTrackerANDROID *faceTracker; + XrResult result; +}; + +struct xrCreateFaceTrackerBD_params +{ + XrSession session; + const XrFaceTrackerCreateInfoBD *createInfo; + XrFaceTrackerBD *tracker; + XrResult result; +}; + struct xrCreateFaceTrackerFB_params { XrSession session; @@ -784,6 +885,14 @@ struct xrCreatePassthroughHTC_params XrResult result; }; +struct xrCreatePassthroughLayerANDROID_params +{ + XrSession session; + const XrPassthroughLayerCreateInfoANDROID *createInfo; + XrPassthroughLayerANDROID *layer; + XrResult result; +}; + struct xrCreatePassthroughLayerFB_params { XrSession session; @@ -848,6 +957,22 @@ struct xrCreateSceneMSFT_params XrResult result; }; +struct xrCreateSceneMeshSnapshotANDROID_params +{ + XrSceneMeshingTrackerANDROID tracker; + const XrSceneMeshSnapshotCreateInfoANDROID *createInfo; + XrSceneMeshSnapshotCreationResultANDROID *outSnapshotCreationResult; + XrResult result; +}; + +struct xrCreateSceneMeshingTrackerANDROID_params +{ + XrSession session; + const XrSceneMeshingTrackerCreateInfoANDROID *createInfo; + XrSceneMeshingTrackerANDROID *tracker; + XrResult result; +}; + struct xrCreateSceneObserverMSFT_params { XrSession session; @@ -872,6 +997,39 @@ struct xrCreateSession_params XrResult result; }; +struct xrCreateSoundFieldBD_params +{ + XrSpatialAudioRendererBD renderer; + const XrSoundFieldConfigBD *config; + XrSoundFieldBD *soundField; + XrResult result; +}; + +struct xrCreateSoundObjectBD_params +{ + XrSpatialAudioRendererBD renderer; + const XrSoundObjectConfigBD *config; + XrSoundObjectBD *soundObject; + XrResult result; +}; + +struct xrCreateSoundObstacleBD_params +{ + XrSpatialAudioRendererBD renderer; + const XrSoundObstacleConfigBD *config; + const XrSoundTriangleMeshBD *mesh; + XrSoundObstacleBD *soundObstacle; + XrResult result; +}; + +struct xrCreateSoundObstacleMaterialBD_params +{ + XrSpatialAudioRendererBD renderer; + const XrSoundObstacleMaterialConfigBD *config; + XrSoundObstacleMaterialBD *material; + XrResult result; +}; + struct xrCreateSpaceUserFB_params { XrSession session; @@ -937,6 +1095,25 @@ struct xrCreateSpatialAnchorMSFT_params XrResult result; }; +struct xrCreateSpatialAnchorSpaceANDROID_params +{ + XrSession session; + XrSpatialContextEXT spatialContext; + const XrSpatialAnchorCreateInfoEXT *createInfo; + XrSpatialEntityIdEXT *anchorEntityId; + XrSpace *anchorSpace; + XrResult result; +}; + +struct xrCreateSpatialAnchorSpaceFromIdANDROID_params +{ + XrSession session; + XrSpatialContextEXT spatialContext; + const XrSpatialAnchorSpaceFromIdCreateInfoANDROID *createInfo; + XrSpace *anchorSpace; + XrResult result; +}; + struct xrCreateSpatialAnchorSpaceMSFT_params { XrSession session; @@ -976,6 +1153,14 @@ struct xrCreateSpatialAnchorsStorageML_params XrResult result; }; +struct xrCreateSpatialAudioRendererBD_params +{ + XrSession session; + const XrSpatialAudioRendererCreateInfoBD *createInfo; + XrSpatialAudioRendererBD *renderer; + XrResult result; +}; + struct xrCreateSpatialContextAsyncEXT_params { XrSession session; @@ -1048,6 +1233,14 @@ struct xrCreateSpatialPersistenceContextCompleteEXT_params XrResult result; }; +struct xrCreateSpatialRaycastSnapshotANDROID_params +{ + XrSpatialContextEXT spatialContext; + const XrSpatialRaycastSnapshotCreateInfoANDROID *createInfo; + XrSpatialSnapshotEXT *snapshot; + XrResult result; +}; + struct xrCreateSpatialUpdateSnapshotEXT_params { XrSpatialContextEXT spatialContext; @@ -1064,6 +1257,22 @@ struct xrCreateSwapchain_params XrResult result; }; +struct xrCreateTrackableImageDatabaseAsyncANDROID_params +{ + XrSession session; + const XrTrackableImageDatabaseCreateInfoANDROID *createInfo; + XrFutureEXT *future; + XrResult result; +}; + +struct xrCreateTrackableImageDatabaseCompleteANDROID_params +{ + XrSession session; + XrFutureEXT future; + XrCreateTrackableImageDatabaseCompletionANDROID *completion; + XrResult result; +}; + struct xrCreateTrackableTrackerANDROID_params { XrSession session; @@ -1182,6 +1391,12 @@ struct xrDestroyEnvironmentDepthSwapchainMETA_params XrResult result; }; +struct xrDestroyEnvironmentRaycasterMETA_params +{ + XrEnvironmentRaycasterMETA environmentRaycaster; + XrResult result; +}; + struct xrDestroyExportedLocalizationMapML_params { XrExportedLocalizationMapML map; @@ -1200,6 +1415,18 @@ struct xrDestroyFaceTracker2FB_params XrResult result; }; +struct xrDestroyFaceTrackerANDROID_params +{ + XrFaceTrackerANDROID faceTracker; + XrResult result; +}; + +struct xrDestroyFaceTrackerBD_params +{ + XrFaceTrackerBD tracker; + XrResult result; +}; + struct xrDestroyFaceTrackerFB_params { XrFaceTrackerFB faceTracker; @@ -1266,6 +1493,12 @@ struct xrDestroyPassthroughHTC_params XrResult result; }; +struct xrDestroyPassthroughLayerANDROID_params +{ + XrPassthroughLayerANDROID layer; + XrResult result; +}; + struct xrDestroyPassthroughLayerFB_params { XrPassthroughLayerFB layer; @@ -1296,6 +1529,18 @@ struct xrDestroySceneMSFT_params XrResult result; }; +struct xrDestroySceneMeshSnapshotANDROID_params +{ + XrSceneMeshSnapshotANDROID snapshot; + XrResult result; +}; + +struct xrDestroySceneMeshingTrackerANDROID_params +{ + XrSceneMeshingTrackerANDROID tracker; + XrResult result; +}; + struct xrDestroySceneObserverMSFT_params { XrSceneObserverMSFT sceneObserver; @@ -1320,6 +1565,30 @@ struct xrDestroySession_params XrResult result; }; +struct xrDestroySoundFieldBD_params +{ + XrSoundFieldBD soundField; + XrResult result; +}; + +struct xrDestroySoundObjectBD_params +{ + XrSoundObjectBD soundObject; + XrResult result; +}; + +struct xrDestroySoundObstacleBD_params +{ + XrSoundObstacleBD soundObstacle; + XrResult result; +}; + +struct xrDestroySoundObstacleMaterialBD_params +{ + XrSoundObstacleMaterialBD material; + XrResult result; +}; + struct xrDestroySpace_params { XrSpace space; @@ -1350,6 +1619,12 @@ struct xrDestroySpatialAnchorsStorageML_params XrResult result; }; +struct xrDestroySpatialAudioRendererBD_params +{ + XrSpatialAudioRendererBD renderer; + XrResult result; +}; + struct xrDestroySpatialContextEXT_params { XrSpatialContextEXT spatialContext; @@ -1386,6 +1661,12 @@ struct xrDestroySwapchain_params XrResult result; }; +struct xrDestroyTrackableImageDatabaseANDROID_params +{ + XrTrackableImageDatabaseANDROID database; + XrResult result; +}; + struct xrDestroyTrackableTrackerANDROID_params { XrTrackableTrackerANDROID trackableTracker; @@ -1448,6 +1729,12 @@ struct xrEnableUserCalibrationEventsML_params XrResult result; }; +struct xrEndAudioPeriodBD_params +{ + XrSpatialAudioRendererBD renderer; + XrResult result; +}; + struct xrEndFrame_params { XrSession session; @@ -1526,6 +1813,15 @@ struct xrEnumerateExternalCamerasOCULUS_params XrResult result; }; +struct xrEnumerateFacialSimulationModesBD_params +{ + XrSession session; + uint32_t modeCapacityInput; + uint32_t *modeCountOutput; + XrFacialSimulationModeBD *modes; + XrResult result; +}; + struct xrEnumerateInstanceExtensionProperties_params { const char *layerName; @@ -1545,6 +1841,15 @@ struct xrEnumerateInteractionRenderModelIdsEXT_params XrResult result; }; +struct xrEnumeratePerformanceMetricsCounterPathsANDROID_params +{ + XrInstance instance; + uint32_t counterPathCapacityInput; + uint32_t *counterPathCountOutput; + XrPath *counterPaths; + XrResult result; +}; + struct xrEnumeratePerformanceMetricsCounterPathsMETA_params { XrInstance instance; @@ -1640,6 +1945,16 @@ struct xrEnumerateSpaceSupportedComponentsFB_params XrResult result; }; +struct xrEnumerateSpatialAnchorAttachableComponentsANDROID_params +{ + XrInstance instance; + XrSystemId systemId; + uint32_t attachableComponentCapacityInput; + uint32_t *attachableComponentCountOutput; + XrSpatialComponentTypeEXT *attachableComponents; + XrResult result; +}; + struct xrEnumerateSpatialCapabilitiesEXT_params { XrInstance instance; @@ -1700,6 +2015,15 @@ struct xrEnumerateSupportedAnchorTrackableTypesANDROID_params XrResult result; }; +struct xrEnumerateSupportedAudioSampleRateBD_params +{ + XrSession session; + uint32_t sampleRateCapacityInput; + uint32_t *sampleRateCountOutput; + XrAudioSampleRateBD *sampleRates; + XrResult result; +}; + struct xrEnumerateSupportedPersistenceAnchorTypesANDROID_params { XrInstance instance; @@ -1710,6 +2034,16 @@ struct xrEnumerateSupportedPersistenceAnchorTypesANDROID_params XrResult result; }; +struct xrEnumerateSupportedSemanticLabelSetsANDROID_params +{ + XrInstance instance; + XrSystemId systemId; + uint32_t supportedSemanticLabelSetsInputCapacity; + uint32_t *supportedSemanticLabelSetsOutputCount; + XrSceneMeshSemanticLabelSetANDROID *supportedSemanticLabelSets; + XrResult result; +}; + struct xrEnumerateSupportedTrackableTypesANDROID_params { XrInstance instance; @@ -1830,6 +2164,15 @@ struct xrGetActionStateVector2f_params XrResult result; }; +struct xrGetAllSubmeshStatesANDROID_params +{ + XrSceneMeshSnapshotANDROID snapshot; + uint32_t submeshStateCapacityInput; + uint32_t *submeshStateCountOutput; + XrSceneSubmeshStateANDROID *submeshStates; + XrResult result; +}; + struct xrGetAllTrackablesANDROID_params { XrTrackableTrackerANDROID trackableTracker; @@ -1955,6 +2298,13 @@ struct xrGetEyeGazesFB_params XrResult result; }; +struct xrGetFaceCalibrationStateANDROID_params +{ + XrFaceTrackerANDROID faceTracker; + XrBool32 *faceIsCalibratedOutput; + XrResult result; +}; + struct xrGetFaceExpressionWeights2FB_params { XrFaceTracker2FB faceTracker; @@ -1971,6 +2321,14 @@ struct xrGetFaceExpressionWeightsFB_params XrResult result; }; +struct xrGetFaceStateANDROID_params +{ + XrFaceTrackerANDROID faceTracker; + const XrFaceStateGetInfoANDROID *getInfo; + XrFaceStateANDROID *faceStateOutput; + XrResult result; +}; + struct xrGetFacialExpressionBlendShapePropertiesML_params { XrFacialExpressionClientML facialExpressionClient; @@ -1987,6 +2345,21 @@ struct xrGetFacialExpressionsHTC_params XrResult result; }; +struct xrGetFacialSimulationDataBD_params +{ + XrFaceTrackerBD tracker; + const XrFacialSimulationDataGetInfoBD *info; + XrFacialSimulationDataBD *facialData; + XrResult result; +}; + +struct xrGetFacialSimulationModeBD_params +{ + XrFaceTrackerBD tracker; + XrFacialSimulationModeBD *mode; + XrResult result; +}; + struct xrGetFoveationEyeTrackedStateMETA_params { XrSession session; @@ -1994,6 +2367,14 @@ struct xrGetFoveationEyeTrackedStateMETA_params XrResult result; }; +struct xrGetHandGestureQCOM_params +{ + XrHandTrackerEXT handTracker; + XrTime time; + XrHandGestureQCOM *handGesture; + XrResult result; +}; + struct xrGetHandMeshFB_params { XrHandTrackerEXT handTracker; @@ -2099,6 +2480,13 @@ struct xrGetPassthroughPreferencesMETA_params XrResult result; }; +struct xrGetPerformanceMetricsStateANDROID_params +{ + XrSession session; + XrPerformanceMetricsStateANDROID *state; + XrResult result; +}; + struct xrGetPerformanceMetricsStateMETA_params { XrSession session; @@ -2448,6 +2836,14 @@ struct xrGetSpatialGraphNodeBindingPropertiesMSFT_params XrResult result; }; +struct xrGetSubmeshDataANDROID_params +{ + XrSceneMeshSnapshotANDROID snapshot; + uint32_t submeshDataCount; + XrSceneSubmeshDataANDROID *inoutSubmeshData; + XrResult result; +}; + struct xrGetSwapchainStateFB_params { XrSwapchain swapchain; @@ -2471,6 +2867,14 @@ struct xrGetSystemProperties_params XrResult result; }; +struct xrGetTrackableImageANDROID_params +{ + XrTrackableTrackerANDROID tracker; + const XrTrackableGetInfoANDROID *getInfo; + XrTrackableImageANDROID *trackable; + XrResult result; +}; + struct xrGetTrackableMarkerANDROID_params { XrTrackableTrackerANDROID tracker; @@ -2495,6 +2899,14 @@ struct xrGetTrackablePlaneANDROID_params XrResult result; }; +struct xrGetTrackableQrCodeANDROID_params +{ + XrTrackableTrackerANDROID tracker; + const XrTrackableGetInfoANDROID *getInfo; + XrTrackableQrCodeANDROID *qrCodeOutput; + XrResult result; +}; + struct xrGetViewConfigurationProperties_params { XrInstance instance; @@ -2771,6 +3183,14 @@ struct xrPerfSettingsSetPerformanceLevelEXT_params XrResult result; }; +struct xrPerformEnvironmentRaycastMETA_params +{ + XrEnvironmentRaycasterMETA environmentRaycaster; + const XrEnvironmentRaycastHitGetInfoMETA *info; + XrEnvironmentRaycastHitMETA *hitPoint; + XrResult result; +}; + struct xrPersistAnchorANDROID_params { XrDeviceAnchorPersistenceANDROID handle; @@ -2849,6 +3269,15 @@ struct xrPublishSpatialAnchorsCompleteML_params XrResult result; }; +struct xrQueryFramesPerBufferRangeBD_params +{ + XrSession session; + XrAudioSampleRateBD sampleRate; + uint32_t *min; + uint32_t *max; + XrResult result; +}; + struct xrQueryLocalizationMapsML_params { XrSession session; @@ -2859,6 +3288,14 @@ struct xrQueryLocalizationMapsML_params XrResult result; }; +struct xrQueryPerformanceMetricsCounterANDROID_params +{ + XrSession session; + XrPath counterPath; + XrPerformanceMetricsCounterANDROID *counter; + XrResult result; +}; + struct xrQueryPerformanceMetricsCounterMETA_params { XrSession session; @@ -2938,6 +3375,20 @@ struct xrReleaseSwapchainImage_params XrResult result; }; +struct xrRemoveTrackableImageDatabaseANDROID_params +{ + XrTrackableTrackerANDROID tracker; + XrTrackableImageDatabaseANDROID database; + XrResult result; +}; + +struct xrRequestBodyTrackingFidelityMETA_params +{ + XrBodyTrackerFB bodyTracker; + XrBodyTrackingFidelityMETA fidelity; + XrResult result; +}; + struct xrRequestDisplayRefreshRateFB_params { XrSession session; @@ -3097,6 +3548,13 @@ struct xrSetEnvironmentDepthHandRemovalMETA_params XrResult result; }; +struct xrSetFacialSimulationModeBD_params +{ + XrFaceTrackerBD tracker; + XrFacialSimulationModeBD mode; + XrResult result; +}; + struct xrSetInputDeviceActiveEXT_params { XrSession session; @@ -3166,6 +3624,20 @@ struct xrSetMarkerTrackingVARJO_params XrResult result; }; +struct xrSetPassthroughLayerMeshANDROID_params +{ + XrPassthroughLayerANDROID layer; + const XrPassthroughLayerMeshANDROID *mesh; + XrResult result; +}; + +struct xrSetPerformanceMetricsStateANDROID_params +{ + XrSession session; + const XrPerformanceMetricsStateANDROID *state; + XrResult result; +}; + struct xrSetPerformanceMetricsStateMETA_params { XrSession session; @@ -3188,6 +3660,13 @@ struct xrSetSystemNotificationsML_params XrResult result; }; +struct xrSetTilePropertiesHintMETA_params +{ + XrSession session; + const XrTilePropertiesHintMETA *properties; + XrResult result; +}; + struct xrSetTrackingOptimizationSettingsHintQCOM_params { XrSession session; @@ -3346,6 +3825,20 @@ struct xrStructureTypeToString2KHR_params XrResult result; }; +struct xrSubmitSoundFieldBufferBD_params +{ + XrSoundFieldBD soundField; + const XrAudioBufferBD *buffer; + XrResult result; +}; + +struct xrSubmitSoundObjectBufferBD_params +{ + XrSoundObjectBD soundObject; + const XrAudioBufferBD *buffer; + XrResult result; +}; + struct xrSuggestBodyTrackingCalibrationOverrideMETA_params { XrBodyTrackerFB bodyTracker; @@ -3494,6 +3987,38 @@ struct xrUpdatePassthroughColorLutMETA_params XrResult result; }; +struct xrUpdateSoundFieldConfigBD_params +{ + XrSoundFieldBD soundField; + const XrSoundFieldConfigBD *config; + XrSoundFieldFlagsBD DECLSPEC_ALIGN(8) flags; + XrResult result; +}; + +struct xrUpdateSoundObjectConfigBD_params +{ + XrSoundObjectBD soundObject; + const XrSoundObjectConfigBD *config; + XrSoundObjectFlagsBD DECLSPEC_ALIGN(8) flags; + XrResult result; +}; + +struct xrUpdateSoundObstacleConfigBD_params +{ + XrSoundObstacleBD soundObstacle; + const XrSoundObstacleConfigBD *config; + const XrSoundTriangleMeshBD *mesh; + XrSoundObstacleFlagsBD DECLSPEC_ALIGN(8) flags; + XrResult result; +}; + +struct xrUpdateSoundObstacleMaterialConfigBD_params +{ + XrSoundObstacleMaterialBD material; + const XrSoundObstacleMaterialConfigBD *config; + XrResult result; +}; + struct xrUpdateSpatialAnchorsExpirationAsyncML_params { XrSpatialAnchorsStorageML storage; @@ -3517,6 +4042,13 @@ struct xrUpdateSwapchainFB_params XrResult result; }; +struct xrWaitAudioPeriodBD_params +{ + XrSpatialAudioRendererBD renderer; + XrDuration timeout; + XrResult result; +}; + struct xrWaitFrame_params { XrSession session; diff --git a/wineopenxr/make_openxr b/wineopenxr/make_openxr index 11f96197f92..42e52eec98e 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.52" +XR_XML_VERSION = "1.1.58" WINE_XR_VERSION = (1, 1) # Filenames to create. diff --git a/wineopenxr/openxr_thunks.c b/wineopenxr/openxr_thunks.c index 66b03232cba..e5eaca731de 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-2025 The Khronos Group Inc. + * Copyright (c) 2017-2026 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_xrAddTrackableImageDatabaseANDROID(void *args) +{ + struct xrAddTrackableImageDatabaseANDROID_params *params = args; + + TRACE("%p, %p\n", params->tracker, params->database); + + params->result = g_xr_host_instance_dispatch_table.p_xrAddTrackableImageDatabaseANDROID(params->tracker, params->database); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrAllocateWorldMeshBufferML(void *args) { @@ -407,6 +419,30 @@ static NTSTATUS thunk64_xrCreateEnvironmentDepthSwapchainMETA(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateEnvironmentRaycasterAsyncMETA(void *args) +{ + struct xrCreateEnvironmentRaycasterAsyncMETA_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->info, params->future); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateEnvironmentRaycasterAsyncMETA(wine_session_from_handle(params->session)->host_session, params->info, params->future); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateEnvironmentRaycasterCompleteMETA(void *args) +{ + struct xrCreateEnvironmentRaycasterCompleteMETA_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->future, params->completion); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateEnvironmentRaycasterCompleteMETA(wine_session_from_handle(params->session)->host_session, params->future, params->completion); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrCreateExportedLocalizationMapML(void *args) { @@ -443,6 +479,30 @@ static NTSTATUS thunk64_xrCreateFaceTracker2FB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateFaceTrackerANDROID(void *args) +{ + struct xrCreateFaceTrackerANDROID_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->faceTracker); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateFaceTrackerANDROID(wine_session_from_handle(params->session)->host_session, params->createInfo, params->faceTracker); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateFaceTrackerBD(void *args) +{ + struct xrCreateFaceTrackerBD_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->tracker); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateFaceTrackerBD(wine_session_from_handle(params->session)->host_session, params->createInfo, params->tracker); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrCreateFaceTrackerFB(void *args) { @@ -629,6 +689,18 @@ static NTSTATUS thunk64_xrCreatePassthroughHTC(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreatePassthroughLayerANDROID(void *args) +{ + struct xrCreatePassthroughLayerANDROID_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->layer); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreatePassthroughLayerANDROID(wine_session_from_handle(params->session)->host_session, params->createInfo, params->layer); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrCreatePassthroughLayerFB(void *args) { @@ -725,6 +797,30 @@ static NTSTATUS thunk64_xrCreateSceneMSFT(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSceneMeshSnapshotANDROID(void *args) +{ + struct xrCreateSceneMeshSnapshotANDROID_params *params = args; + + TRACE("%p, %p, %p\n", params->tracker, params->createInfo, params->outSnapshotCreationResult); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSceneMeshSnapshotANDROID(params->tracker, params->createInfo, params->outSnapshotCreationResult); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSceneMeshingTrackerANDROID(void *args) +{ + struct xrCreateSceneMeshingTrackerANDROID_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->tracker); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSceneMeshingTrackerANDROID(wine_session_from_handle(params->session)->host_session, params->createInfo, params->tracker); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrCreateSceneObserverMSFT(void *args) { @@ -761,6 +857,54 @@ static NTSTATUS thunk64_xrCreateSession(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSoundFieldBD(void *args) +{ + struct xrCreateSoundFieldBD_params *params = args; + + TRACE("%p, %p, %p\n", params->renderer, params->config, params->soundField); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSoundFieldBD(params->renderer, params->config, params->soundField); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSoundObjectBD(void *args) +{ + struct xrCreateSoundObjectBD_params *params = args; + + TRACE("%p, %p, %p\n", params->renderer, params->config, params->soundObject); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSoundObjectBD(params->renderer, params->config, params->soundObject); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSoundObstacleBD(void *args) +{ + struct xrCreateSoundObstacleBD_params *params = args; + + TRACE("%p, %p, %p, %p\n", params->renderer, params->config, params->mesh, params->soundObstacle); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSoundObstacleBD(params->renderer, params->config, params->mesh, params->soundObstacle); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSoundObstacleMaterialBD(void *args) +{ + struct xrCreateSoundObstacleMaterialBD_params *params = args; + + TRACE("%p, %p, %p\n", params->renderer, params->config, params->material); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSoundObstacleMaterialBD(params->renderer, params->config, params->material); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrCreateSpaceUserFB(void *args) { @@ -857,6 +1001,30 @@ static NTSTATUS thunk64_xrCreateSpatialAnchorMSFT(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSpatialAnchorSpaceANDROID(void *args) +{ + struct xrCreateSpatialAnchorSpaceANDROID_params *params = args; + + TRACE("%p, %p, %p, %p, %p\n", params->session, params->spatialContext, params->createInfo, params->anchorEntityId, params->anchorSpace); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSpatialAnchorSpaceANDROID(wine_session_from_handle(params->session)->host_session, params->spatialContext, params->createInfo, params->anchorEntityId, params->anchorSpace); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSpatialAnchorSpaceFromIdANDROID(void *args) +{ + struct xrCreateSpatialAnchorSpaceFromIdANDROID_params *params = args; + + TRACE("%p, %p, %p, %p\n", params->session, params->spatialContext, params->createInfo, params->anchorSpace); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSpatialAnchorSpaceFromIdANDROID(wine_session_from_handle(params->session)->host_session, params->spatialContext, params->createInfo, params->anchorSpace); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrCreateSpatialAnchorSpaceMSFT(void *args) { @@ -917,6 +1085,18 @@ static NTSTATUS thunk64_xrCreateSpatialAnchorsStorageML(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSpatialAudioRendererBD(void *args) +{ + struct xrCreateSpatialAudioRendererBD_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->renderer); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSpatialAudioRendererBD(wine_session_from_handle(params->session)->host_session, params->createInfo, params->renderer); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrCreateSpatialContextAsyncEXT(void *args) { @@ -1025,6 +1205,18 @@ static NTSTATUS thunk64_xrCreateSpatialPersistenceContextCompleteEXT(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateSpatialRaycastSnapshotANDROID(void *args) +{ + struct xrCreateSpatialRaycastSnapshotANDROID_params *params = args; + + TRACE("%p, %p, %p\n", params->spatialContext, params->createInfo, params->snapshot); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateSpatialRaycastSnapshotANDROID(params->spatialContext, params->createInfo, params->snapshot); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrCreateSpatialUpdateSnapshotEXT(void *args) { @@ -1049,6 +1241,30 @@ static NTSTATUS thunk64_xrCreateSwapchain(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateTrackableImageDatabaseAsyncANDROID(void *args) +{ + struct xrCreateTrackableImageDatabaseAsyncANDROID_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->createInfo, params->future); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateTrackableImageDatabaseAsyncANDROID(wine_session_from_handle(params->session)->host_session, params->createInfo, params->future); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrCreateTrackableImageDatabaseCompleteANDROID(void *args) +{ + struct xrCreateTrackableImageDatabaseCompleteANDROID_params *params = args; + + TRACE("%p, %p, %p\n", params->session, params->future, params->completion); + + params->result = g_xr_host_instance_dispatch_table.p_xrCreateTrackableImageDatabaseCompleteANDROID(wine_session_from_handle(params->session)->host_session, params->future, params->completion); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrCreateTrackableTrackerANDROID(void *args) { @@ -1253,6 +1469,18 @@ static NTSTATUS thunk64_xrDestroyEnvironmentDepthSwapchainMETA(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyEnvironmentRaycasterMETA(void *args) +{ + struct xrDestroyEnvironmentRaycasterMETA_params *params = args; + + TRACE("%p\n", params->environmentRaycaster); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyEnvironmentRaycasterMETA(params->environmentRaycaster); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrDestroyExportedLocalizationMapML(void *args) { @@ -1289,6 +1517,30 @@ static NTSTATUS thunk64_xrDestroyFaceTracker2FB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyFaceTrackerANDROID(void *args) +{ + struct xrDestroyFaceTrackerANDROID_params *params = args; + + TRACE("%p\n", params->faceTracker); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyFaceTrackerANDROID(params->faceTracker); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyFaceTrackerBD(void *args) +{ + struct xrDestroyFaceTrackerBD_params *params = args; + + TRACE("%p\n", params->tracker); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyFaceTrackerBD(params->tracker); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrDestroyFaceTrackerFB(void *args) { @@ -1421,6 +1673,18 @@ static NTSTATUS thunk64_xrDestroyPassthroughHTC(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyPassthroughLayerANDROID(void *args) +{ + struct xrDestroyPassthroughLayerANDROID_params *params = args; + + TRACE("%p\n", params->layer); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyPassthroughLayerANDROID(params->layer); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrDestroyPassthroughLayerFB(void *args) { @@ -1481,6 +1745,30 @@ static NTSTATUS thunk64_xrDestroySceneMSFT(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroySceneMeshSnapshotANDROID(void *args) +{ + struct xrDestroySceneMeshSnapshotANDROID_params *params = args; + + TRACE("%p\n", params->snapshot); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroySceneMeshSnapshotANDROID(params->snapshot); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroySceneMeshingTrackerANDROID(void *args) +{ + struct xrDestroySceneMeshingTrackerANDROID_params *params = args; + + TRACE("%p\n", params->tracker); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroySceneMeshingTrackerANDROID(params->tracker); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrDestroySceneObserverMSFT(void *args) { @@ -1529,6 +1817,54 @@ static NTSTATUS thunk64_xrDestroySession(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroySoundFieldBD(void *args) +{ + struct xrDestroySoundFieldBD_params *params = args; + + TRACE("%p\n", params->soundField); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroySoundFieldBD(params->soundField); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroySoundObjectBD(void *args) +{ + struct xrDestroySoundObjectBD_params *params = args; + + TRACE("%p\n", params->soundObject); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroySoundObjectBD(params->soundObject); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroySoundObstacleBD(void *args) +{ + struct xrDestroySoundObstacleBD_params *params = args; + + TRACE("%p\n", params->soundObstacle); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroySoundObstacleBD(params->soundObstacle); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroySoundObstacleMaterialBD(void *args) +{ + struct xrDestroySoundObstacleMaterialBD_params *params = args; + + TRACE("%p\n", params->material); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroySoundObstacleMaterialBD(params->material); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrDestroySpace(void *args) { @@ -1589,6 +1925,18 @@ static NTSTATUS thunk64_xrDestroySpatialAnchorsStorageML(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroySpatialAudioRendererBD(void *args) +{ + struct xrDestroySpatialAudioRendererBD_params *params = args; + + TRACE("%p\n", params->renderer); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroySpatialAudioRendererBD(params->renderer); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrDestroySpatialContextEXT(void *args) { @@ -1661,6 +2009,18 @@ static NTSTATUS thunk64_xrDestroySwapchain(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrDestroyTrackableImageDatabaseANDROID(void *args) +{ + struct xrDestroyTrackableImageDatabaseANDROID_params *params = args; + + TRACE("%p\n", params->database); + + params->result = g_xr_host_instance_dispatch_table.p_xrDestroyTrackableImageDatabaseANDROID(params->database); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrDestroyTrackableTrackerANDROID(void *args) { @@ -1769,6 +2129,18 @@ static NTSTATUS thunk64_xrEnableUserCalibrationEventsML(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrEndAudioPeriodBD(void *args) +{ + struct xrEndAudioPeriodBD_params *params = args; + + TRACE("%p\n", params->renderer); + + params->result = g_xr_host_instance_dispatch_table.p_xrEndAudioPeriodBD(params->renderer); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrEndFrame(void *args) { @@ -1877,6 +2249,18 @@ static NTSTATUS thunk64_xrEnumerateExternalCamerasOCULUS(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateFacialSimulationModesBD(void *args) +{ + struct xrEnumerateFacialSimulationModesBD_params *params = args; + + TRACE("%p, %u, %p, %p\n", params->session, params->modeCapacityInput, params->modeCountOutput, params->modes); + + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateFacialSimulationModesBD(wine_session_from_handle(params->session)->host_session, params->modeCapacityInput, params->modeCountOutput, params->modes); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrEnumerateInstanceExtensionProperties(void *args) { @@ -1901,6 +2285,18 @@ static NTSTATUS thunk64_xrEnumerateInteractionRenderModelIdsEXT(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumeratePerformanceMetricsCounterPathsANDROID(void *args) +{ + struct xrEnumeratePerformanceMetricsCounterPathsANDROID_params *params = args; + + TRACE("%p, %u, %p, %p\n", params->instance, params->counterPathCapacityInput, params->counterPathCountOutput, params->counterPaths); + + params->result = g_xr_host_instance_dispatch_table.p_xrEnumeratePerformanceMetricsCounterPathsANDROID(wine_instance_from_handle(params->instance)->host_instance, params->counterPathCapacityInput, params->counterPathCountOutput, params->counterPaths); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrEnumeratePerformanceMetricsCounterPathsMETA(void *args) { @@ -2021,6 +2417,18 @@ static NTSTATUS thunk64_xrEnumerateSpaceSupportedComponentsFB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateSpatialAnchorAttachableComponentsANDROID(void *args) +{ + struct xrEnumerateSpatialAnchorAttachableComponentsANDROID_params *params = args; + + TRACE("%p, 0x%s, %u, %p, %p\n", params->instance, wine_dbgstr_longlong(params->systemId), params->attachableComponentCapacityInput, params->attachableComponentCountOutput, params->attachableComponents); + + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateSpatialAnchorAttachableComponentsANDROID(wine_instance_from_handle(params->instance)->host_instance, params->systemId, params->attachableComponentCapacityInput, params->attachableComponentCountOutput, params->attachableComponents); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrEnumerateSpatialCapabilitiesEXT(void *args) { @@ -2093,6 +2501,18 @@ static NTSTATUS thunk64_xrEnumerateSupportedAnchorTrackableTypesANDROID(void *ar } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateSupportedAudioSampleRateBD(void *args) +{ + struct xrEnumerateSupportedAudioSampleRateBD_params *params = args; + + TRACE("%p, %u, %p, %p\n", params->session, params->sampleRateCapacityInput, params->sampleRateCountOutput, params->sampleRates); + + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateSupportedAudioSampleRateBD(wine_session_from_handle(params->session)->host_session, params->sampleRateCapacityInput, params->sampleRateCountOutput, params->sampleRates); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrEnumerateSupportedPersistenceAnchorTypesANDROID(void *args) { @@ -2105,6 +2525,18 @@ static NTSTATUS thunk64_xrEnumerateSupportedPersistenceAnchorTypesANDROID(void * } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrEnumerateSupportedSemanticLabelSetsANDROID(void *args) +{ + struct xrEnumerateSupportedSemanticLabelSetsANDROID_params *params = args; + + TRACE("%p, 0x%s, %u, %p, %p\n", params->instance, wine_dbgstr_longlong(params->systemId), params->supportedSemanticLabelSetsInputCapacity, params->supportedSemanticLabelSetsOutputCount, params->supportedSemanticLabelSets); + + params->result = g_xr_host_instance_dispatch_table.p_xrEnumerateSupportedSemanticLabelSetsANDROID(wine_instance_from_handle(params->instance)->host_instance, params->systemId, params->supportedSemanticLabelSetsInputCapacity, params->supportedSemanticLabelSetsOutputCount, params->supportedSemanticLabelSets); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrEnumerateSupportedTrackableTypesANDROID(void *args) { @@ -2273,6 +2705,18 @@ static NTSTATUS thunk64_xrGetActionStateVector2f(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetAllSubmeshStatesANDROID(void *args) +{ + struct xrGetAllSubmeshStatesANDROID_params *params = args; + + TRACE("%p, %u, %p, %p\n", params->snapshot, params->submeshStateCapacityInput, params->submeshStateCountOutput, params->submeshStates); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetAllSubmeshStatesANDROID(params->snapshot, params->submeshStateCapacityInput, params->submeshStateCountOutput, params->submeshStates); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrGetAllTrackablesANDROID(void *args) { @@ -2465,6 +2909,18 @@ static NTSTATUS thunk64_xrGetEyeGazesFB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetFaceCalibrationStateANDROID(void *args) +{ + struct xrGetFaceCalibrationStateANDROID_params *params = args; + + TRACE("%p, %p\n", params->faceTracker, params->faceIsCalibratedOutput); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetFaceCalibrationStateANDROID(params->faceTracker, params->faceIsCalibratedOutput); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrGetFaceExpressionWeights2FB(void *args) { @@ -2489,6 +2945,18 @@ static NTSTATUS thunk64_xrGetFaceExpressionWeightsFB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetFaceStateANDROID(void *args) +{ + struct xrGetFaceStateANDROID_params *params = args; + + TRACE("%p, %p, %p\n", params->faceTracker, params->getInfo, params->faceStateOutput); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetFaceStateANDROID(params->faceTracker, params->getInfo, params->faceStateOutput); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrGetFacialExpressionBlendShapePropertiesML(void *args) { @@ -2513,6 +2981,30 @@ static NTSTATUS thunk64_xrGetFacialExpressionsHTC(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetFacialSimulationDataBD(void *args) +{ + struct xrGetFacialSimulationDataBD_params *params = args; + + TRACE("%p, %p, %p\n", params->tracker, params->info, params->facialData); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetFacialSimulationDataBD(params->tracker, params->info, params->facialData); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetFacialSimulationModeBD(void *args) +{ + struct xrGetFacialSimulationModeBD_params *params = args; + + TRACE("%p, %p\n", params->tracker, params->mode); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetFacialSimulationModeBD(params->tracker, params->mode); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrGetFoveationEyeTrackedStateMETA(void *args) { @@ -2525,6 +3017,18 @@ static NTSTATUS thunk64_xrGetFoveationEyeTrackedStateMETA(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetHandGestureQCOM(void *args) +{ + struct xrGetHandGestureQCOM_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->handTracker, wine_dbgstr_longlong(params->time), params->handGesture); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetHandGestureQCOM(params->handTracker, params->time, params->handGesture); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrGetHandMeshFB(void *args) { @@ -2681,6 +3185,18 @@ static NTSTATUS thunk64_xrGetPassthroughPreferencesMETA(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetPerformanceMetricsStateANDROID(void *args) +{ + struct xrGetPerformanceMetricsStateANDROID_params *params = args; + + TRACE("%p, %p\n", params->session, params->state); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetPerformanceMetricsStateANDROID(wine_session_from_handle(params->session)->host_session, params->state); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrGetPerformanceMetricsStateMETA(void *args) { @@ -3185,6 +3701,18 @@ static NTSTATUS thunk64_xrGetSpatialGraphNodeBindingPropertiesMSFT(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetSubmeshDataANDROID(void *args) +{ + struct xrGetSubmeshDataANDROID_params *params = args; + + TRACE("%p, %u, %p\n", params->snapshot, params->submeshDataCount, params->inoutSubmeshData); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetSubmeshDataANDROID(params->snapshot, params->submeshDataCount, params->inoutSubmeshData); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrGetSwapchainStateFB(void *args) { @@ -3221,6 +3749,18 @@ static NTSTATUS thunk64_xrGetSystemProperties(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetTrackableImageANDROID(void *args) +{ + struct xrGetTrackableImageANDROID_params *params = args; + + TRACE("%p, %p, %p\n", params->tracker, params->getInfo, params->trackable); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetTrackableImageANDROID(params->tracker, params->getInfo, params->trackable); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrGetTrackableMarkerANDROID(void *args) { @@ -3257,6 +3797,18 @@ static NTSTATUS thunk64_xrGetTrackablePlaneANDROID(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrGetTrackableQrCodeANDROID(void *args) +{ + struct xrGetTrackableQrCodeANDROID_params *params = args; + + TRACE("%p, %p, %p\n", params->tracker, params->getInfo, params->qrCodeOutput); + + params->result = g_xr_host_instance_dispatch_table.p_xrGetTrackableQrCodeANDROID(params->tracker, params->getInfo, params->qrCodeOutput); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrGetViewConfigurationProperties(void *args) { @@ -3665,6 +4217,18 @@ static NTSTATUS thunk64_xrPerfSettingsSetPerformanceLevelEXT(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrPerformEnvironmentRaycastMETA(void *args) +{ + struct xrPerformEnvironmentRaycastMETA_params *params = args; + + TRACE("%p, %p, %p\n", params->environmentRaycaster, params->info, params->hitPoint); + + params->result = g_xr_host_instance_dispatch_table.p_xrPerformEnvironmentRaycastMETA(params->environmentRaycaster, params->info, params->hitPoint); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrPersistAnchorANDROID(void *args) { @@ -3785,6 +4349,18 @@ static NTSTATUS thunk64_xrPublishSpatialAnchorsCompleteML(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrQueryFramesPerBufferRangeBD(void *args) +{ + struct xrQueryFramesPerBufferRangeBD_params *params = args; + + TRACE("%p, %#x, %p, %p\n", params->session, params->sampleRate, params->min, params->max); + + params->result = g_xr_host_instance_dispatch_table.p_xrQueryFramesPerBufferRangeBD(wine_session_from_handle(params->session)->host_session, params->sampleRate, params->min, params->max); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrQueryLocalizationMapsML(void *args) { @@ -3797,6 +4373,18 @@ static NTSTATUS thunk64_xrQueryLocalizationMapsML(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrQueryPerformanceMetricsCounterANDROID(void *args) +{ + struct xrQueryPerformanceMetricsCounterANDROID_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->session, wine_dbgstr_longlong(params->counterPath), params->counter); + + params->result = g_xr_host_instance_dispatch_table.p_xrQueryPerformanceMetricsCounterANDROID(wine_session_from_handle(params->session)->host_session, params->counterPath, params->counter); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrQueryPerformanceMetricsCounterMETA(void *args) { @@ -3917,6 +4505,30 @@ static NTSTATUS thunk64_xrReleaseSwapchainImage(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrRemoveTrackableImageDatabaseANDROID(void *args) +{ + struct xrRemoveTrackableImageDatabaseANDROID_params *params = args; + + TRACE("%p, %p\n", params->tracker, params->database); + + params->result = g_xr_host_instance_dispatch_table.p_xrRemoveTrackableImageDatabaseANDROID(params->tracker, params->database); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrRequestBodyTrackingFidelityMETA(void *args) +{ + struct xrRequestBodyTrackingFidelityMETA_params *params = args; + + TRACE("%p, %#x\n", params->bodyTracker, params->fidelity); + + params->result = g_xr_host_instance_dispatch_table.p_xrRequestBodyTrackingFidelityMETA(params->bodyTracker, params->fidelity); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrRequestDisplayRefreshRateFB(void *args) { @@ -4169,6 +4781,18 @@ static NTSTATUS thunk64_xrSetEnvironmentDepthHandRemovalMETA(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetFacialSimulationModeBD(void *args) +{ + struct xrSetFacialSimulationModeBD_params *params = args; + + TRACE("%p, %#x\n", params->tracker, params->mode); + + params->result = g_xr_host_instance_dispatch_table.p_xrSetFacialSimulationModeBD(params->tracker, params->mode); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrSetInputDeviceActiveEXT(void *args) { @@ -4265,6 +4889,30 @@ static NTSTATUS thunk64_xrSetMarkerTrackingVARJO(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetPassthroughLayerMeshANDROID(void *args) +{ + struct xrSetPassthroughLayerMeshANDROID_params *params = args; + + TRACE("%p, %p\n", params->layer, params->mesh); + + params->result = g_xr_host_instance_dispatch_table.p_xrSetPassthroughLayerMeshANDROID(params->layer, params->mesh); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetPerformanceMetricsStateANDROID(void *args) +{ + struct xrSetPerformanceMetricsStateANDROID_params *params = args; + + TRACE("%p, %p\n", params->session, params->state); + + params->result = g_xr_host_instance_dispatch_table.p_xrSetPerformanceMetricsStateANDROID(wine_session_from_handle(params->session)->host_session, params->state); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrSetPerformanceMetricsStateMETA(void *args) { @@ -4301,6 +4949,18 @@ static NTSTATUS thunk64_xrSetSystemNotificationsML(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrSetTilePropertiesHintMETA(void *args) +{ + struct xrSetTilePropertiesHintMETA_params *params = args; + + TRACE("%p, %p\n", params->session, params->properties); + + params->result = g_xr_host_instance_dispatch_table.p_xrSetTilePropertiesHintMETA(wine_session_from_handle(params->session)->host_session, params->properties); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrSetTrackingOptimizationSettingsHintQCOM(void *args) { @@ -4553,6 +5213,30 @@ static NTSTATUS thunk64_xrStructureTypeToString2KHR(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrSubmitSoundFieldBufferBD(void *args) +{ + struct xrSubmitSoundFieldBufferBD_params *params = args; + + TRACE("%p, %p\n", params->soundField, params->buffer); + + params->result = g_xr_host_instance_dispatch_table.p_xrSubmitSoundFieldBufferBD(params->soundField, params->buffer); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrSubmitSoundObjectBufferBD(void *args) +{ + struct xrSubmitSoundObjectBufferBD_params *params = args; + + TRACE("%p, %p\n", params->soundObject, params->buffer); + + params->result = g_xr_host_instance_dispatch_table.p_xrSubmitSoundObjectBufferBD(params->soundObject, params->buffer); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrSuggestBodyTrackingCalibrationOverrideMETA(void *args) { @@ -4793,6 +5477,54 @@ static NTSTATUS thunk64_xrUpdatePassthroughColorLutMETA(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrUpdateSoundFieldConfigBD(void *args) +{ + struct xrUpdateSoundFieldConfigBD_params *params = args; + + TRACE("%p, %p, 0x%s\n", params->soundField, params->config, wine_dbgstr_longlong(params->flags)); + + params->result = g_xr_host_instance_dispatch_table.p_xrUpdateSoundFieldConfigBD(params->soundField, params->config, params->flags); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrUpdateSoundObjectConfigBD(void *args) +{ + struct xrUpdateSoundObjectConfigBD_params *params = args; + + TRACE("%p, %p, 0x%s\n", params->soundObject, params->config, wine_dbgstr_longlong(params->flags)); + + params->result = g_xr_host_instance_dispatch_table.p_xrUpdateSoundObjectConfigBD(params->soundObject, params->config, params->flags); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrUpdateSoundObstacleConfigBD(void *args) +{ + struct xrUpdateSoundObstacleConfigBD_params *params = args; + + TRACE("%p, %p, %p, 0x%s\n", params->soundObstacle, params->config, params->mesh, wine_dbgstr_longlong(params->flags)); + + params->result = g_xr_host_instance_dispatch_table.p_xrUpdateSoundObstacleConfigBD(params->soundObstacle, params->config, params->mesh, params->flags); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static NTSTATUS thunk64_xrUpdateSoundObstacleMaterialConfigBD(void *args) +{ + struct xrUpdateSoundObstacleMaterialConfigBD_params *params = args; + + TRACE("%p, %p\n", params->material, params->config); + + params->result = g_xr_host_instance_dispatch_table.p_xrUpdateSoundObstacleMaterialConfigBD(params->material, params->config); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrUpdateSpatialAnchorsExpirationAsyncML(void *args) { @@ -4829,6 +5561,18 @@ static NTSTATUS thunk64_xrUpdateSwapchainFB(void *args) } #endif /* _WIN64 */ +#ifdef _WIN64 +static NTSTATUS thunk64_xrWaitAudioPeriodBD(void *args) +{ + struct xrWaitAudioPeriodBD_params *params = args; + + TRACE("%p, 0x%s\n", params->renderer, wine_dbgstr_longlong(params->timeout)); + + params->result = g_xr_host_instance_dispatch_table.p_xrWaitAudioPeriodBD(params->renderer, params->timeout); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + #ifdef _WIN64 static NTSTATUS thunk64_xrWaitFrame(void *args) { @@ -4856,21 +5600,37 @@ static NTSTATUS thunk64_xrWaitSwapchainImage(void *args) static const char * const xr_extensions[] = { "XR_ALMALENCE_digital_lens_control", + "XR_ANDROID_composition_layer_passthrough_mesh", "XR_ANDROID_device_anchor_persistence", + "XR_ANDROID_face_tracking", + "XR_ANDROID_mouse_interaction", "XR_ANDROID_passthrough_camera_state", + "XR_ANDROID_performance_metrics", "XR_ANDROID_raycast", + "XR_ANDROID_scene_meshing", + "XR_ANDROID_spatial_anchor_space", + "XR_ANDROID_spatial_component_subsumed_by", + "XR_ANDROID_spatial_discovery_raycast", + "XR_ANDROID_spatial_entity_bound_anchor", + "XR_ANDROID_spatial_object_tracking", "XR_ANDROID_trackables", + "XR_ANDROID_trackables_image", "XR_ANDROID_trackables_marker", "XR_ANDROID_trackables_object", + "XR_ANDROID_trackables_qr_code", + "XR_ANDROID_unbounded_reference_space", "XR_BD_body_tracking", "XR_BD_controller_interaction", + "XR_BD_facial_simulation", "XR_BD_future_progress", "XR_BD_spatial_anchor", "XR_BD_spatial_anchor_sharing", + "XR_BD_spatial_audio_rendering", "XR_BD_spatial_mesh", "XR_BD_spatial_plane", "XR_BD_spatial_scene", "XR_BD_spatial_sensing", + "XR_BD_ultra_controller_interaction", "XR_EPIC_view_configuration_fov", "XR_EXTX_overlay", "XR_EXT_active_action_set_priority", @@ -4885,6 +5645,7 @@ static const char * const xr_extensions[] = "XR_EXT_hand_tracking", "XR_EXT_hand_tracking_data_source", "XR_EXT_hp_mixed_reality_controller", + "XR_EXT_interaction_profile_battery_state_display", "XR_EXT_interaction_render_model", "XR_EXT_loader_init_properties", "XR_EXT_local_floor", @@ -4903,6 +5664,7 @@ static const char * const xr_extensions[] = "XR_EXT_user_presence", "XR_EXT_uuid", "XR_EXT_view_configuration_depth_range", + "XR_EXT_view_configuration_views_change", "XR_EXT_win32_appcontainer_compatible", "XR_FB_body_tracking", "XR_FB_color_space", @@ -4975,10 +5737,12 @@ static const char * const xr_extensions[] = "XR_LOGITECH_mx_ink_stylus_interaction", "XR_META_automatic_layer_filter", "XR_META_body_tracking_calibration", + "XR_META_body_tracking_fidelity", "XR_META_body_tracking_full_body", "XR_META_colocation_discovery", "XR_META_detached_controllers", "XR_META_environment_depth", + "XR_META_environment_raycast", "XR_META_foveation_eye_tracked", "XR_META_hand_tracking_microgestures", "XR_META_headset_id", @@ -4993,7 +5757,9 @@ static const char * const xr_extensions[] = "XR_META_spatial_entity_group_sharing", "XR_META_spatial_entity_mesh", "XR_META_spatial_entity_persistence", + "XR_META_spatial_entity_semantic_label", "XR_META_spatial_entity_sharing", + "XR_META_tile_properties_hint", "XR_META_touch_controller_plus", "XR_META_virtual_keyboard", "XR_META_vulkan_swapchain_create_info", @@ -5030,6 +5796,7 @@ static const char * const xr_extensions[] = "XR_OCULUS_audio_device_guid", "XR_OCULUS_external_camera", "XR_OPPO_controller_interaction", + "XR_QCOM_hand_tracking_gesture", "XR_QCOM_tracking_optimization_settings", "XR_ULTRALEAP_hand_tracking_forearm", "XR_VALVE_analog_threshold", @@ -5070,6 +5837,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = is_available_instance_function_openxr, thunk64_xrAcquireEnvironmentDepthImageMETA, thunk64_xrAcquireSwapchainImage, + thunk64_xrAddTrackableImageDatabaseANDROID, thunk64_xrAllocateWorldMeshBufferML, thunk64_xrApplyForceFeedbackCurlMNDX, thunk64_xrApplyHapticFeedback, @@ -5096,9 +5864,13 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrCreateDeviceAnchorPersistenceANDROID, thunk64_xrCreateEnvironmentDepthProviderMETA, thunk64_xrCreateEnvironmentDepthSwapchainMETA, + thunk64_xrCreateEnvironmentRaycasterAsyncMETA, + thunk64_xrCreateEnvironmentRaycasterCompleteMETA, thunk64_xrCreateExportedLocalizationMapML, thunk64_xrCreateEyeTrackerFB, thunk64_xrCreateFaceTracker2FB, + thunk64_xrCreateFaceTrackerANDROID, + thunk64_xrCreateFaceTrackerBD, thunk64_xrCreateFaceTrackerFB, thunk64_xrCreateFacialExpressionClientML, thunk64_xrCreateFacialTrackerHTC, @@ -5114,6 +5886,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrCreatePassthroughColorLutMETA, thunk64_xrCreatePassthroughFB, thunk64_xrCreatePassthroughHTC, + thunk64_xrCreatePassthroughLayerANDROID, thunk64_xrCreatePassthroughLayerFB, thunk64_xrCreatePersistedAnchorSpaceANDROID, thunk64_xrCreatePlaneDetectorEXT, @@ -5122,9 +5895,15 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrCreateRenderModelEXT, thunk64_xrCreateRenderModelSpaceEXT, thunk64_xrCreateSceneMSFT, + thunk64_xrCreateSceneMeshSnapshotANDROID, + thunk64_xrCreateSceneMeshingTrackerANDROID, thunk64_xrCreateSceneObserverMSFT, thunk64_xrCreateSenseDataProviderBD, thunk64_xrCreateSession, + thunk64_xrCreateSoundFieldBD, + thunk64_xrCreateSoundObjectBD, + thunk64_xrCreateSoundObstacleBD, + thunk64_xrCreateSoundObstacleMaterialBD, thunk64_xrCreateSpaceUserFB, thunk64_xrCreateSpatialAnchorAsyncBD, thunk64_xrCreateSpatialAnchorCompleteBD, @@ -5133,11 +5912,14 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrCreateSpatialAnchorFromPersistedNameMSFT, thunk64_xrCreateSpatialAnchorHTC, thunk64_xrCreateSpatialAnchorMSFT, + thunk64_xrCreateSpatialAnchorSpaceANDROID, + thunk64_xrCreateSpatialAnchorSpaceFromIdANDROID, thunk64_xrCreateSpatialAnchorSpaceMSFT, thunk64_xrCreateSpatialAnchorStoreConnectionMSFT, thunk64_xrCreateSpatialAnchorsAsyncML, thunk64_xrCreateSpatialAnchorsCompleteML, thunk64_xrCreateSpatialAnchorsStorageML, + thunk64_xrCreateSpatialAudioRendererBD, thunk64_xrCreateSpatialContextAsyncEXT, thunk64_xrCreateSpatialContextCompleteEXT, thunk64_xrCreateSpatialDiscoverySnapshotAsyncEXT, @@ -5147,8 +5929,11 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrCreateSpatialGraphNodeSpaceMSFT, thunk64_xrCreateSpatialPersistenceContextAsyncEXT, thunk64_xrCreateSpatialPersistenceContextCompleteEXT, + thunk64_xrCreateSpatialRaycastSnapshotANDROID, thunk64_xrCreateSpatialUpdateSnapshotEXT, thunk64_xrCreateSwapchain, + thunk64_xrCreateTrackableImageDatabaseAsyncANDROID, + thunk64_xrCreateTrackableImageDatabaseCompleteANDROID, thunk64_xrCreateTrackableTrackerANDROID, thunk64_xrCreateTriangleMeshFB, thunk64_xrCreateVirtualKeyboardMETA, @@ -5166,9 +5951,12 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrDestroyDeviceAnchorPersistenceANDROID, thunk64_xrDestroyEnvironmentDepthProviderMETA, thunk64_xrDestroyEnvironmentDepthSwapchainMETA, + thunk64_xrDestroyEnvironmentRaycasterMETA, thunk64_xrDestroyExportedLocalizationMapML, thunk64_xrDestroyEyeTrackerFB, thunk64_xrDestroyFaceTracker2FB, + thunk64_xrDestroyFaceTrackerANDROID, + thunk64_xrDestroyFaceTrackerBD, thunk64_xrDestroyFaceTrackerFB, thunk64_xrDestroyFacialExpressionClientML, thunk64_xrDestroyFacialTrackerHTC, @@ -5180,26 +5968,35 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrDestroyPassthroughColorLutMETA, thunk64_xrDestroyPassthroughFB, thunk64_xrDestroyPassthroughHTC, + thunk64_xrDestroyPassthroughLayerANDROID, thunk64_xrDestroyPassthroughLayerFB, thunk64_xrDestroyPlaneDetectorEXT, thunk64_xrDestroyRenderModelAssetEXT, thunk64_xrDestroyRenderModelEXT, thunk64_xrDestroySceneMSFT, + thunk64_xrDestroySceneMeshSnapshotANDROID, + thunk64_xrDestroySceneMeshingTrackerANDROID, thunk64_xrDestroySceneObserverMSFT, thunk64_xrDestroySenseDataProviderBD, thunk64_xrDestroySenseDataSnapshotBD, thunk64_xrDestroySession, + thunk64_xrDestroySoundFieldBD, + thunk64_xrDestroySoundObjectBD, + thunk64_xrDestroySoundObstacleBD, + thunk64_xrDestroySoundObstacleMaterialBD, thunk64_xrDestroySpace, thunk64_xrDestroySpaceUserFB, thunk64_xrDestroySpatialAnchorMSFT, thunk64_xrDestroySpatialAnchorStoreConnectionMSFT, thunk64_xrDestroySpatialAnchorsStorageML, + thunk64_xrDestroySpatialAudioRendererBD, thunk64_xrDestroySpatialContextEXT, thunk64_xrDestroySpatialEntityEXT, thunk64_xrDestroySpatialGraphNodeBindingMSFT, thunk64_xrDestroySpatialPersistenceContextEXT, thunk64_xrDestroySpatialSnapshotEXT, thunk64_xrDestroySwapchain, + thunk64_xrDestroyTrackableImageDatabaseANDROID, thunk64_xrDestroyTrackableTrackerANDROID, thunk64_xrDestroyTriangleMeshFB, thunk64_xrDestroyVirtualKeyboardMETA, @@ -5209,6 +6006,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrDownloadSharedSpatialAnchorCompleteBD, thunk64_xrEnableLocalizationEventsML, thunk64_xrEnableUserCalibrationEventsML, + thunk64_xrEndAudioPeriodBD, thunk64_xrEndFrame, thunk64_xrEndSession, thunk64_xrEnumerateApiLayerProperties, @@ -5218,8 +6016,10 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrEnumerateEnvironmentBlendModes, thunk64_xrEnumerateEnvironmentDepthSwapchainImagesMETA, thunk64_xrEnumerateExternalCamerasOCULUS, + thunk64_xrEnumerateFacialSimulationModesBD, thunk64_xrEnumerateInstanceExtensionProperties, thunk64_xrEnumerateInteractionRenderModelIdsEXT, + thunk64_xrEnumeratePerformanceMetricsCounterPathsANDROID, thunk64_xrEnumeratePerformanceMetricsCounterPathsMETA, thunk64_xrEnumeratePersistedAnchorsANDROID, thunk64_xrEnumeratePersistedSpatialAnchorNamesMSFT, @@ -5230,13 +6030,16 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrEnumerateReprojectionModesMSFT, thunk64_xrEnumerateSceneComputeFeaturesMSFT, thunk64_xrEnumerateSpaceSupportedComponentsFB, + thunk64_xrEnumerateSpatialAnchorAttachableComponentsANDROID, thunk64_xrEnumerateSpatialCapabilitiesEXT, thunk64_xrEnumerateSpatialCapabilityComponentTypesEXT, thunk64_xrEnumerateSpatialCapabilityFeaturesEXT, thunk64_xrEnumerateSpatialEntityComponentTypesBD, thunk64_xrEnumerateSpatialPersistenceScopesEXT, thunk64_xrEnumerateSupportedAnchorTrackableTypesANDROID, + thunk64_xrEnumerateSupportedAudioSampleRateBD, thunk64_xrEnumerateSupportedPersistenceAnchorTypesANDROID, + thunk64_xrEnumerateSupportedSemanticLabelSetsANDROID, thunk64_xrEnumerateSupportedTrackableTypesANDROID, thunk64_xrEnumerateSwapchainFormats, thunk64_xrEnumerateSwapchainImages, @@ -5251,6 +6054,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrGetActionStateFloat, thunk64_xrGetActionStatePose, thunk64_xrGetActionStateVector2f, + thunk64_xrGetAllSubmeshStatesANDROID, thunk64_xrGetAllTrackablesANDROID, thunk64_xrGetAnchorPersistStateANDROID, thunk64_xrGetAnchorUuidBD, @@ -5267,11 +6071,16 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrGetEnvironmentDepthSwapchainStateMETA, thunk64_xrGetExportedLocalizationMapDataML, thunk64_xrGetEyeGazesFB, + thunk64_xrGetFaceCalibrationStateANDROID, thunk64_xrGetFaceExpressionWeights2FB, thunk64_xrGetFaceExpressionWeightsFB, + thunk64_xrGetFaceStateANDROID, thunk64_xrGetFacialExpressionBlendShapePropertiesML, thunk64_xrGetFacialExpressionsHTC, + thunk64_xrGetFacialSimulationDataBD, + thunk64_xrGetFacialSimulationModeBD, thunk64_xrGetFoveationEyeTrackedStateMETA, + thunk64_xrGetHandGestureQCOM, thunk64_xrGetHandMeshFB, thunk64_xrGetInputSourceLocalizedName, thunk64_xrGetInstanceProperties, @@ -5285,6 +6094,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrGetOpenGLGraphicsRequirementsKHR, thunk64_xrGetPassthroughCameraStateANDROID, thunk64_xrGetPassthroughPreferencesMETA, + thunk64_xrGetPerformanceMetricsStateANDROID, thunk64_xrGetPerformanceMetricsStateMETA, thunk64_xrGetPlaneDetectionStateEXT, thunk64_xrGetPlaneDetectionsEXT, @@ -5327,12 +6137,15 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrGetSpatialEntityComponentDataBD, thunk64_xrGetSpatialEntityUuidBD, thunk64_xrGetSpatialGraphNodeBindingPropertiesMSFT, + thunk64_xrGetSubmeshDataANDROID, thunk64_xrGetSwapchainStateFB, thunk64_xrGetSystem, thunk64_xrGetSystemProperties, + thunk64_xrGetTrackableImageANDROID, thunk64_xrGetTrackableMarkerANDROID, thunk64_xrGetTrackableObjectANDROID, thunk64_xrGetTrackablePlaneANDROID, + thunk64_xrGetTrackableQrCodeANDROID, thunk64_xrGetViewConfigurationProperties, thunk64_xrGetVirtualKeyboardDirtyTexturesMETA, thunk64_xrGetVirtualKeyboardModelAnimationStatesMETA, @@ -5367,6 +6180,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrPathToString, thunk64_xrPauseSimultaneousHandsAndControllersTrackingMETA, thunk64_xrPerfSettingsSetPerformanceLevelEXT, + thunk64_xrPerformEnvironmentRaycastMETA, thunk64_xrPersistAnchorANDROID, thunk64_xrPersistSpatialAnchorAsyncBD, thunk64_xrPersistSpatialAnchorCompleteBD, @@ -5377,7 +6191,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrPollFutureEXT, thunk64_xrPublishSpatialAnchorsAsyncML, thunk64_xrPublishSpatialAnchorsCompleteML, + thunk64_xrQueryFramesPerBufferRangeBD, thunk64_xrQueryLocalizationMapsML, + thunk64_xrQueryPerformanceMetricsCounterANDROID, thunk64_xrQueryPerformanceMetricsCounterMETA, thunk64_xrQuerySenseDataAsyncBD, thunk64_xrQuerySenseDataCompleteBD, @@ -5388,6 +6204,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrQuerySystemTrackedKeyboardFB, thunk64_xrRaycastANDROID, thunk64_xrReleaseSwapchainImage, + thunk64_xrRemoveTrackableImageDatabaseANDROID, + thunk64_xrRequestBodyTrackingFidelityMETA, thunk64_xrRequestDisplayRefreshRateFB, thunk64_xrRequestExitSession, thunk64_xrRequestMapLocalizationML, @@ -5409,6 +6227,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrSetDigitalLensControlALMALENCE, thunk64_xrSetEnvironmentDepthEstimationVARJO, thunk64_xrSetEnvironmentDepthHandRemovalMETA, + thunk64_xrSetFacialSimulationModeBD, thunk64_xrSetInputDeviceActiveEXT, thunk64_xrSetInputDeviceLocationEXT, thunk64_xrSetInputDeviceStateBoolEXT, @@ -5417,9 +6236,12 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrSetMarkerTrackingPredictionVARJO, thunk64_xrSetMarkerTrackingTimeoutVARJO, thunk64_xrSetMarkerTrackingVARJO, + thunk64_xrSetPassthroughLayerMeshANDROID, + thunk64_xrSetPerformanceMetricsStateANDROID, thunk64_xrSetPerformanceMetricsStateMETA, thunk64_xrSetSpaceComponentStatusFB, thunk64_xrSetSystemNotificationsML, + thunk64_xrSetTilePropertiesHintMETA, thunk64_xrSetTrackingOptimizationSettingsHintQCOM, thunk64_xrSetViewOffsetVARJO, thunk64_xrSetVirtualKeyboardModelVisibilityMETA, @@ -5441,6 +6263,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrStringToPath, thunk64_xrStructureTypeToString, thunk64_xrStructureTypeToString2KHR, + thunk64_xrSubmitSoundFieldBufferBD, + thunk64_xrSubmitSoundObjectBufferBD, thunk64_xrSuggestBodyTrackingCalibrationOverrideMETA, thunk64_xrSuggestInteractionProfileBindings, thunk64_xrSuggestVirtualKeyboardLocationMETA, @@ -5461,9 +6285,14 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_xrUnpersistSpatialEntityCompleteEXT, thunk64_xrUpdateHandMeshMSFT, thunk64_xrUpdatePassthroughColorLutMETA, + thunk64_xrUpdateSoundFieldConfigBD, + thunk64_xrUpdateSoundObjectConfigBD, + thunk64_xrUpdateSoundObstacleConfigBD, + thunk64_xrUpdateSoundObstacleMaterialConfigBD, thunk64_xrUpdateSpatialAnchorsExpirationAsyncML, thunk64_xrUpdateSpatialAnchorsExpirationCompleteML, thunk64_xrUpdateSwapchainFB, + thunk64_xrWaitAudioPeriodBD, thunk64_xrWaitFrame, thunk64_xrWaitSwapchainImage, }; diff --git a/wineopenxr/openxr_thunks.h b/wineopenxr/openxr_thunks.h index 5f42ced9fa2..38b1fd7ae15 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-2025 The Khronos Group Inc. + * Copyright (c) 2017-2026 The Khronos Group Inc. * * SPDX-License-Identifier: Apache-2.0 OR MIT * @@ -40,6 +40,7 @@ struct openxr_instance_funcs { XrResult (*p_xrAcquireEnvironmentDepthImageMETA)(XrEnvironmentDepthProviderMETA, const XrEnvironmentDepthImageAcquireInfoMETA *, XrEnvironmentDepthImageMETA *); XrResult (*p_xrAcquireSwapchainImage)(XrSwapchain, const XrSwapchainImageAcquireInfo *, uint32_t *); + XrResult (*p_xrAddTrackableImageDatabaseANDROID)(XrTrackableTrackerANDROID, XrTrackableImageDatabaseANDROID); XrResult (*p_xrAllocateWorldMeshBufferML)(XrWorldMeshDetectorML, const XrWorldMeshBufferSizeML *, XrWorldMeshBufferML *); XrResult (*p_xrApplyForceFeedbackCurlMNDX)(XrHandTrackerEXT, const XrForceFeedbackCurlApplyLocationsMNDX *); XrResult (*p_xrApplyHapticFeedback)(XrSession, const XrHapticActionInfo *, const XrHapticBaseHeader *); @@ -65,9 +66,13 @@ struct openxr_instance_funcs XrResult (*p_xrCreateDeviceAnchorPersistenceANDROID)(XrSession, const XrDeviceAnchorPersistenceCreateInfoANDROID *, XrDeviceAnchorPersistenceANDROID *); XrResult (*p_xrCreateEnvironmentDepthProviderMETA)(XrSession, const XrEnvironmentDepthProviderCreateInfoMETA *, XrEnvironmentDepthProviderMETA *); XrResult (*p_xrCreateEnvironmentDepthSwapchainMETA)(XrEnvironmentDepthProviderMETA, const XrEnvironmentDepthSwapchainCreateInfoMETA *, XrEnvironmentDepthSwapchainMETA *); + XrResult (*p_xrCreateEnvironmentRaycasterAsyncMETA)(XrSession, const XrEnvironmentRaycasterCreateInfoMETA *, XrFutureEXT *); + XrResult (*p_xrCreateEnvironmentRaycasterCompleteMETA)(XrSession, XrFutureEXT, XrEnvironmentRaycasterCreateCompletionMETA *); XrResult (*p_xrCreateExportedLocalizationMapML)(XrSession, const XrUuidEXT *, XrExportedLocalizationMapML *); XrResult (*p_xrCreateEyeTrackerFB)(XrSession, const XrEyeTrackerCreateInfoFB *, XrEyeTrackerFB *); XrResult (*p_xrCreateFaceTracker2FB)(XrSession, const XrFaceTrackerCreateInfo2FB *, XrFaceTracker2FB *); + XrResult (*p_xrCreateFaceTrackerANDROID)(XrSession, const XrFaceTrackerCreateInfoANDROID *, XrFaceTrackerANDROID *); + XrResult (*p_xrCreateFaceTrackerBD)(XrSession, const XrFaceTrackerCreateInfoBD *, XrFaceTrackerBD *); XrResult (*p_xrCreateFaceTrackerFB)(XrSession, const XrFaceTrackerCreateInfoFB *, XrFaceTrackerFB *); XrResult (*p_xrCreateFacialExpressionClientML)(XrSession, const XrFacialExpressionClientCreateInfoML *, XrFacialExpressionClientML *); XrResult (*p_xrCreateFacialTrackerHTC)(XrSession, const XrFacialTrackerCreateInfoHTC *, XrFacialTrackerHTC *); @@ -82,6 +87,7 @@ struct openxr_instance_funcs XrResult (*p_xrCreatePassthroughColorLutMETA)(XrPassthroughFB, const XrPassthroughColorLutCreateInfoMETA *, XrPassthroughColorLutMETA *); XrResult (*p_xrCreatePassthroughFB)(XrSession, const XrPassthroughCreateInfoFB *, XrPassthroughFB *); XrResult (*p_xrCreatePassthroughHTC)(XrSession, const XrPassthroughCreateInfoHTC *, XrPassthroughHTC *); + XrResult (*p_xrCreatePassthroughLayerANDROID)(XrSession, const XrPassthroughLayerCreateInfoANDROID *, XrPassthroughLayerANDROID *); XrResult (*p_xrCreatePassthroughLayerFB)(XrSession, const XrPassthroughLayerCreateInfoFB *, XrPassthroughLayerFB *); XrResult (*p_xrCreatePersistedAnchorSpaceANDROID)(XrDeviceAnchorPersistenceANDROID, const XrPersistedAnchorSpaceCreateInfoANDROID *, XrSpace *); XrResult (*p_xrCreatePlaneDetectorEXT)(XrSession, const XrPlaneDetectorCreateInfoEXT *, XrPlaneDetectorEXT *); @@ -90,9 +96,15 @@ struct openxr_instance_funcs XrResult (*p_xrCreateRenderModelEXT)(XrSession, const XrRenderModelCreateInfoEXT *, XrRenderModelEXT *); XrResult (*p_xrCreateRenderModelSpaceEXT)(XrSession, const XrRenderModelSpaceCreateInfoEXT *, XrSpace *); XrResult (*p_xrCreateSceneMSFT)(XrSceneObserverMSFT, const XrSceneCreateInfoMSFT *, XrSceneMSFT *); + XrResult (*p_xrCreateSceneMeshSnapshotANDROID)(XrSceneMeshingTrackerANDROID, const XrSceneMeshSnapshotCreateInfoANDROID *, XrSceneMeshSnapshotCreationResultANDROID *); + XrResult (*p_xrCreateSceneMeshingTrackerANDROID)(XrSession, const XrSceneMeshingTrackerCreateInfoANDROID *, XrSceneMeshingTrackerANDROID *); XrResult (*p_xrCreateSceneObserverMSFT)(XrSession, const XrSceneObserverCreateInfoMSFT *, XrSceneObserverMSFT *); XrResult (*p_xrCreateSenseDataProviderBD)(XrSession, const XrSenseDataProviderCreateInfoBD *, XrSenseDataProviderBD *); XrResult (*p_xrCreateSession)(XrInstance, const XrSessionCreateInfo *, XrSession *); + XrResult (*p_xrCreateSoundFieldBD)(XrSpatialAudioRendererBD, const XrSoundFieldConfigBD *, XrSoundFieldBD *); + XrResult (*p_xrCreateSoundObjectBD)(XrSpatialAudioRendererBD, const XrSoundObjectConfigBD *, XrSoundObjectBD *); + XrResult (*p_xrCreateSoundObstacleBD)(XrSpatialAudioRendererBD, const XrSoundObstacleConfigBD *, const XrSoundTriangleMeshBD *, XrSoundObstacleBD *); + XrResult (*p_xrCreateSoundObstacleMaterialBD)(XrSpatialAudioRendererBD, const XrSoundObstacleMaterialConfigBD *, XrSoundObstacleMaterialBD *); XrResult (*p_xrCreateSpaceUserFB)(XrSession, const XrSpaceUserCreateInfoFB *, XrSpaceUserFB *); XrResult (*p_xrCreateSpatialAnchorAsyncBD)(XrSenseDataProviderBD, const XrSpatialAnchorCreateInfoBD *, XrFutureEXT *); XrResult (*p_xrCreateSpatialAnchorCompleteBD)(XrSenseDataProviderBD, XrFutureEXT, XrSpatialAnchorCreateCompletionBD *); @@ -101,11 +113,14 @@ struct openxr_instance_funcs XrResult (*p_xrCreateSpatialAnchorFromPersistedNameMSFT)(XrSession, const XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT *, XrSpatialAnchorMSFT *); XrResult (*p_xrCreateSpatialAnchorHTC)(XrSession, const XrSpatialAnchorCreateInfoHTC *, XrSpace *); XrResult (*p_xrCreateSpatialAnchorMSFT)(XrSession, const XrSpatialAnchorCreateInfoMSFT *, XrSpatialAnchorMSFT *); + XrResult (*p_xrCreateSpatialAnchorSpaceANDROID)(XrSession, XrSpatialContextEXT, const XrSpatialAnchorCreateInfoEXT *, XrSpatialEntityIdEXT *, XrSpace *); + XrResult (*p_xrCreateSpatialAnchorSpaceFromIdANDROID)(XrSession, XrSpatialContextEXT, const XrSpatialAnchorSpaceFromIdCreateInfoANDROID *, XrSpace *); 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_xrCreateSpatialAudioRendererBD)(XrSession, const XrSpatialAudioRendererCreateInfoBD *, XrSpatialAudioRendererBD *); XrResult (*p_xrCreateSpatialContextAsyncEXT)(XrSession, const XrSpatialContextCreateInfoEXT *, XrFutureEXT *); XrResult (*p_xrCreateSpatialContextCompleteEXT)(XrSession, XrFutureEXT, XrCreateSpatialContextCompletionEXT *); XrResult (*p_xrCreateSpatialDiscoverySnapshotAsyncEXT)(XrSpatialContextEXT, const XrSpatialDiscoverySnapshotCreateInfoEXT *, XrFutureEXT *); @@ -115,8 +130,11 @@ struct openxr_instance_funcs XrResult (*p_xrCreateSpatialGraphNodeSpaceMSFT)(XrSession, const XrSpatialGraphNodeSpaceCreateInfoMSFT *, XrSpace *); XrResult (*p_xrCreateSpatialPersistenceContextAsyncEXT)(XrSession, const XrSpatialPersistenceContextCreateInfoEXT *, XrFutureEXT *); XrResult (*p_xrCreateSpatialPersistenceContextCompleteEXT)(XrSession, XrFutureEXT, XrCreateSpatialPersistenceContextCompletionEXT *); + XrResult (*p_xrCreateSpatialRaycastSnapshotANDROID)(XrSpatialContextEXT, const XrSpatialRaycastSnapshotCreateInfoANDROID *, XrSpatialSnapshotEXT *); XrResult (*p_xrCreateSpatialUpdateSnapshotEXT)(XrSpatialContextEXT, const XrSpatialUpdateSnapshotCreateInfoEXT *, XrSpatialSnapshotEXT *); XrResult (*p_xrCreateSwapchain)(XrSession, const XrSwapchainCreateInfo *, XrSwapchain *); + XrResult (*p_xrCreateTrackableImageDatabaseAsyncANDROID)(XrSession, const XrTrackableImageDatabaseCreateInfoANDROID *, XrFutureEXT *); + XrResult (*p_xrCreateTrackableImageDatabaseCompleteANDROID)(XrSession, XrFutureEXT, XrCreateTrackableImageDatabaseCompletionANDROID *); XrResult (*p_xrCreateTrackableTrackerANDROID)(XrSession, const XrTrackableTrackerCreateInfoANDROID *, XrTrackableTrackerANDROID *); XrResult (*p_xrCreateTriangleMeshFB)(XrSession, const XrTriangleMeshCreateInfoFB *, XrTriangleMeshFB *); XrResult (*p_xrCreateVirtualKeyboardMETA)(XrSession, const XrVirtualKeyboardCreateInfoMETA *, XrVirtualKeyboardMETA *); @@ -136,9 +154,12 @@ struct openxr_instance_funcs XrResult (*p_xrDestroyDeviceAnchorPersistenceANDROID)(XrDeviceAnchorPersistenceANDROID); XrResult (*p_xrDestroyEnvironmentDepthProviderMETA)(XrEnvironmentDepthProviderMETA); XrResult (*p_xrDestroyEnvironmentDepthSwapchainMETA)(XrEnvironmentDepthSwapchainMETA); + XrResult (*p_xrDestroyEnvironmentRaycasterMETA)(XrEnvironmentRaycasterMETA); XrResult (*p_xrDestroyExportedLocalizationMapML)(XrExportedLocalizationMapML); XrResult (*p_xrDestroyEyeTrackerFB)(XrEyeTrackerFB); XrResult (*p_xrDestroyFaceTracker2FB)(XrFaceTracker2FB); + XrResult (*p_xrDestroyFaceTrackerANDROID)(XrFaceTrackerANDROID); + XrResult (*p_xrDestroyFaceTrackerBD)(XrFaceTrackerBD); XrResult (*p_xrDestroyFaceTrackerFB)(XrFaceTrackerFB); XrResult (*p_xrDestroyFacialExpressionClientML)(XrFacialExpressionClientML); XrResult (*p_xrDestroyFacialTrackerHTC)(XrFacialTrackerHTC); @@ -150,26 +171,35 @@ struct openxr_instance_funcs XrResult (*p_xrDestroyPassthroughColorLutMETA)(XrPassthroughColorLutMETA); XrResult (*p_xrDestroyPassthroughFB)(XrPassthroughFB); XrResult (*p_xrDestroyPassthroughHTC)(XrPassthroughHTC); + XrResult (*p_xrDestroyPassthroughLayerANDROID)(XrPassthroughLayerANDROID); XrResult (*p_xrDestroyPassthroughLayerFB)(XrPassthroughLayerFB); XrResult (*p_xrDestroyPlaneDetectorEXT)(XrPlaneDetectorEXT); XrResult (*p_xrDestroyRenderModelAssetEXT)(XrRenderModelAssetEXT); XrResult (*p_xrDestroyRenderModelEXT)(XrRenderModelEXT); XrResult (*p_xrDestroySceneMSFT)(XrSceneMSFT); + XrResult (*p_xrDestroySceneMeshSnapshotANDROID)(XrSceneMeshSnapshotANDROID); + XrResult (*p_xrDestroySceneMeshingTrackerANDROID)(XrSceneMeshingTrackerANDROID); XrResult (*p_xrDestroySceneObserverMSFT)(XrSceneObserverMSFT); XrResult (*p_xrDestroySenseDataProviderBD)(XrSenseDataProviderBD); XrResult (*p_xrDestroySenseDataSnapshotBD)(XrSenseDataSnapshotBD); XrResult (*p_xrDestroySession)(XrSession); + XrResult (*p_xrDestroySoundFieldBD)(XrSoundFieldBD); + XrResult (*p_xrDestroySoundObjectBD)(XrSoundObjectBD); + XrResult (*p_xrDestroySoundObstacleBD)(XrSoundObstacleBD); + XrResult (*p_xrDestroySoundObstacleMaterialBD)(XrSoundObstacleMaterialBD); XrResult (*p_xrDestroySpace)(XrSpace); XrResult (*p_xrDestroySpaceUserFB)(XrSpaceUserFB); XrResult (*p_xrDestroySpatialAnchorMSFT)(XrSpatialAnchorMSFT); XrResult (*p_xrDestroySpatialAnchorStoreConnectionMSFT)(XrSpatialAnchorStoreConnectionMSFT); XrResult (*p_xrDestroySpatialAnchorsStorageML)(XrSpatialAnchorsStorageML); + XrResult (*p_xrDestroySpatialAudioRendererBD)(XrSpatialAudioRendererBD); XrResult (*p_xrDestroySpatialContextEXT)(XrSpatialContextEXT); XrResult (*p_xrDestroySpatialEntityEXT)(XrSpatialEntityEXT); XrResult (*p_xrDestroySpatialGraphNodeBindingMSFT)(XrSpatialGraphNodeBindingMSFT); XrResult (*p_xrDestroySpatialPersistenceContextEXT)(XrSpatialPersistenceContextEXT); XrResult (*p_xrDestroySpatialSnapshotEXT)(XrSpatialSnapshotEXT); XrResult (*p_xrDestroySwapchain)(XrSwapchain); + XrResult (*p_xrDestroyTrackableImageDatabaseANDROID)(XrTrackableImageDatabaseANDROID); XrResult (*p_xrDestroyTrackableTrackerANDROID)(XrTrackableTrackerANDROID); XrResult (*p_xrDestroyTriangleMeshFB)(XrTriangleMeshFB); XrResult (*p_xrDestroyVirtualKeyboardMETA)(XrVirtualKeyboardMETA); @@ -179,6 +209,7 @@ struct openxr_instance_funcs XrResult (*p_xrDownloadSharedSpatialAnchorCompleteBD)(XrSenseDataProviderBD, XrFutureEXT, XrFutureCompletionEXT *); XrResult (*p_xrEnableLocalizationEventsML)(XrSession, const XrLocalizationEnableEventsInfoML *); XrResult (*p_xrEnableUserCalibrationEventsML)(XrInstance, const XrUserCalibrationEnableEventsInfoML *); + XrResult (*p_xrEndAudioPeriodBD)(XrSpatialAudioRendererBD); XrResult (*p_xrEndFrame)(XrSession, const XrFrameEndInfo *); XrResult (*p_xrEndSession)(XrSession); XrResult (*p_xrEnumerateApiLayerProperties)(uint32_t, uint32_t *, XrApiLayerProperties *); @@ -188,7 +219,9 @@ struct openxr_instance_funcs XrResult (*p_xrEnumerateEnvironmentBlendModes)(XrInstance, XrSystemId, XrViewConfigurationType, uint32_t, uint32_t *, XrEnvironmentBlendMode *); XrResult (*p_xrEnumerateEnvironmentDepthSwapchainImagesMETA)(XrEnvironmentDepthSwapchainMETA, uint32_t, uint32_t *, XrSwapchainImageBaseHeader *); XrResult (*p_xrEnumerateExternalCamerasOCULUS)(XrSession, uint32_t, uint32_t *, XrExternalCameraOCULUS *); + XrResult (*p_xrEnumerateFacialSimulationModesBD)(XrSession, uint32_t, uint32_t *, XrFacialSimulationModeBD *); XrResult (*p_xrEnumerateInteractionRenderModelIdsEXT)(XrSession, const XrInteractionRenderModelIdsEnumerateInfoEXT *, uint32_t, uint32_t *, XrRenderModelIdEXT *); + XrResult (*p_xrEnumeratePerformanceMetricsCounterPathsANDROID)(XrInstance, uint32_t, uint32_t *, XrPath *); XrResult (*p_xrEnumeratePerformanceMetricsCounterPathsMETA)(XrInstance, uint32_t, uint32_t *, XrPath *); XrResult (*p_xrEnumeratePersistedAnchorsANDROID)(XrDeviceAnchorPersistenceANDROID, uint32_t, uint32_t *, XrUuidEXT *); XrResult (*p_xrEnumeratePersistedSpatialAnchorNamesMSFT)(XrSpatialAnchorStoreConnectionMSFT, uint32_t, uint32_t *, XrSpatialAnchorPersistenceNameMSFT *); @@ -199,13 +232,16 @@ 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_xrEnumerateSpatialAnchorAttachableComponentsANDROID)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrSpatialComponentTypeEXT *); XrResult (*p_xrEnumerateSpatialCapabilitiesEXT)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrSpatialCapabilityEXT *); XrResult (*p_xrEnumerateSpatialCapabilityComponentTypesEXT)(XrInstance, XrSystemId, XrSpatialCapabilityEXT, XrSpatialCapabilityComponentTypesEXT *); XrResult (*p_xrEnumerateSpatialCapabilityFeaturesEXT)(XrInstance, XrSystemId, XrSpatialCapabilityEXT, uint32_t, uint32_t *, XrSpatialCapabilityFeatureEXT *); XrResult (*p_xrEnumerateSpatialEntityComponentTypesBD)(XrSenseDataSnapshotBD, XrSpatialEntityIdBD, uint32_t, uint32_t *, XrSpatialEntityComponentTypeBD *); XrResult (*p_xrEnumerateSpatialPersistenceScopesEXT)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrSpatialPersistenceScopeEXT *); XrResult (*p_xrEnumerateSupportedAnchorTrackableTypesANDROID)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrTrackableTypeANDROID *); + XrResult (*p_xrEnumerateSupportedAudioSampleRateBD)(XrSession, uint32_t, uint32_t *, XrAudioSampleRateBD *); XrResult (*p_xrEnumerateSupportedPersistenceAnchorTypesANDROID)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrTrackableTypeANDROID *); + XrResult (*p_xrEnumerateSupportedSemanticLabelSetsANDROID)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrSceneMeshSemanticLabelSetANDROID *); XrResult (*p_xrEnumerateSupportedTrackableTypesANDROID)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrTrackableTypeANDROID *); XrResult (*p_xrEnumerateSwapchainFormats)(XrSession, uint32_t, uint32_t *, int64_t *); XrResult (*p_xrEnumerateSwapchainImages)(XrSwapchain, uint32_t, uint32_t *, XrSwapchainImageBaseHeader *); @@ -220,6 +256,7 @@ struct openxr_instance_funcs XrResult (*p_xrGetActionStateFloat)(XrSession, const XrActionStateGetInfo *, XrActionStateFloat *); XrResult (*p_xrGetActionStatePose)(XrSession, const XrActionStateGetInfo *, XrActionStatePose *); XrResult (*p_xrGetActionStateVector2f)(XrSession, const XrActionStateGetInfo *, XrActionStateVector2f *); + XrResult (*p_xrGetAllSubmeshStatesANDROID)(XrSceneMeshSnapshotANDROID, uint32_t, uint32_t *, XrSceneSubmeshStateANDROID *); XrResult (*p_xrGetAllTrackablesANDROID)(XrTrackableTrackerANDROID, uint32_t, uint32_t *, XrTrackableANDROID *); XrResult (*p_xrGetAnchorPersistStateANDROID)(XrDeviceAnchorPersistenceANDROID, const XrUuidEXT *, XrAnchorPersistStateANDROID *); XrResult (*p_xrGetAnchorUuidBD)(XrAnchorBD, XrUuidEXT *); @@ -236,11 +273,16 @@ struct openxr_instance_funcs XrResult (*p_xrGetEnvironmentDepthSwapchainStateMETA)(XrEnvironmentDepthSwapchainMETA, XrEnvironmentDepthSwapchainStateMETA *); XrResult (*p_xrGetExportedLocalizationMapDataML)(XrExportedLocalizationMapML, uint32_t, uint32_t *, char *); XrResult (*p_xrGetEyeGazesFB)(XrEyeTrackerFB, const XrEyeGazesInfoFB *, XrEyeGazesFB *); + XrResult (*p_xrGetFaceCalibrationStateANDROID)(XrFaceTrackerANDROID, XrBool32 *); XrResult (*p_xrGetFaceExpressionWeights2FB)(XrFaceTracker2FB, const XrFaceExpressionInfo2FB *, XrFaceExpressionWeights2FB *); XrResult (*p_xrGetFaceExpressionWeightsFB)(XrFaceTrackerFB, const XrFaceExpressionInfoFB *, XrFaceExpressionWeightsFB *); + XrResult (*p_xrGetFaceStateANDROID)(XrFaceTrackerANDROID, const XrFaceStateGetInfoANDROID *, XrFaceStateANDROID *); XrResult (*p_xrGetFacialExpressionBlendShapePropertiesML)(XrFacialExpressionClientML, const XrFacialExpressionBlendShapeGetInfoML *, uint32_t, XrFacialExpressionBlendShapePropertiesML *); XrResult (*p_xrGetFacialExpressionsHTC)(XrFacialTrackerHTC, XrFacialExpressionsHTC *); + XrResult (*p_xrGetFacialSimulationDataBD)(XrFaceTrackerBD, const XrFacialSimulationDataGetInfoBD *, XrFacialSimulationDataBD *); + XrResult (*p_xrGetFacialSimulationModeBD)(XrFaceTrackerBD, XrFacialSimulationModeBD *); XrResult (*p_xrGetFoveationEyeTrackedStateMETA)(XrSession, XrFoveationEyeTrackedStateMETA *); + XrResult (*p_xrGetHandGestureQCOM)(XrHandTrackerEXT, XrTime, XrHandGestureQCOM *); XrResult (*p_xrGetHandMeshFB)(XrHandTrackerEXT, XrHandTrackingMeshFB *); XrResult (*p_xrGetInputSourceLocalizedName)(XrSession, const XrInputSourceLocalizedNameGetInfo *, uint32_t, uint32_t *, char *); XrResult (*p_xrGetInstanceProperties)(XrInstance, XrInstanceProperties *); @@ -254,6 +296,7 @@ struct openxr_instance_funcs XrResult (*p_xrGetOpenGLGraphicsRequirementsKHR)(XrInstance, XrSystemId, XrGraphicsRequirementsOpenGLKHR *); XrResult (*p_xrGetPassthroughCameraStateANDROID)(XrSession, const XrPassthroughCameraStateGetInfoANDROID *, XrPassthroughCameraStateANDROID *); XrResult (*p_xrGetPassthroughPreferencesMETA)(XrSession, XrPassthroughPreferencesMETA *); + XrResult (*p_xrGetPerformanceMetricsStateANDROID)(XrSession, XrPerformanceMetricsStateANDROID *); XrResult (*p_xrGetPerformanceMetricsStateMETA)(XrSession, XrPerformanceMetricsStateMETA *); XrResult (*p_xrGetPlaneDetectionStateEXT)(XrPlaneDetectorEXT, XrPlaneDetectionStateEXT *); XrResult (*p_xrGetPlaneDetectionsEXT)(XrPlaneDetectorEXT, const XrPlaneDetectorGetInfoEXT *, XrPlaneDetectorLocationsEXT *); @@ -296,12 +339,15 @@ struct openxr_instance_funcs XrResult (*p_xrGetSpatialEntityComponentDataBD)(XrSenseDataSnapshotBD, const XrSpatialEntityComponentGetInfoBD *, XrSpatialEntityComponentDataBaseHeaderBD *); XrResult (*p_xrGetSpatialEntityUuidBD)(XrSenseDataSnapshotBD, XrSpatialEntityIdBD, XrUuidEXT *); XrResult (*p_xrGetSpatialGraphNodeBindingPropertiesMSFT)(XrSpatialGraphNodeBindingMSFT, const XrSpatialGraphNodeBindingPropertiesGetInfoMSFT *, XrSpatialGraphNodeBindingPropertiesMSFT *); + XrResult (*p_xrGetSubmeshDataANDROID)(XrSceneMeshSnapshotANDROID, uint32_t, XrSceneSubmeshDataANDROID *); XrResult (*p_xrGetSwapchainStateFB)(XrSwapchain, XrSwapchainStateBaseHeaderFB *); XrResult (*p_xrGetSystem)(XrInstance, const XrSystemGetInfo *, XrSystemId *); XrResult (*p_xrGetSystemProperties)(XrInstance, XrSystemId, XrSystemProperties *); + XrResult (*p_xrGetTrackableImageANDROID)(XrTrackableTrackerANDROID, const XrTrackableGetInfoANDROID *, XrTrackableImageANDROID *); XrResult (*p_xrGetTrackableMarkerANDROID)(XrTrackableTrackerANDROID, const XrTrackableGetInfoANDROID *, XrTrackableMarkerANDROID *); XrResult (*p_xrGetTrackableObjectANDROID)(XrTrackableTrackerANDROID, const XrTrackableGetInfoANDROID *, XrTrackableObjectANDROID *); XrResult (*p_xrGetTrackablePlaneANDROID)(XrTrackableTrackerANDROID, const XrTrackableGetInfoANDROID *, XrTrackablePlaneANDROID *); + XrResult (*p_xrGetTrackableQrCodeANDROID)(XrTrackableTrackerANDROID, const XrTrackableGetInfoANDROID *, XrTrackableQrCodeANDROID *); XrResult (*p_xrGetViewConfigurationProperties)(XrInstance, XrSystemId, XrViewConfigurationType, XrViewConfigurationProperties *); XrResult (*p_xrGetVirtualKeyboardDirtyTexturesMETA)(XrVirtualKeyboardMETA, uint32_t, uint32_t *, uint64_t *); XrResult (*p_xrGetVirtualKeyboardModelAnimationStatesMETA)(XrVirtualKeyboardMETA, XrVirtualKeyboardModelAnimationStatesMETA *); @@ -337,6 +383,7 @@ struct openxr_instance_funcs XrResult (*p_xrPathToString)(XrInstance, XrPath, uint32_t, uint32_t *, char *); XrResult (*p_xrPauseSimultaneousHandsAndControllersTrackingMETA)(XrSession, const XrSimultaneousHandsAndControllersTrackingPauseInfoMETA *); XrResult (*p_xrPerfSettingsSetPerformanceLevelEXT)(XrSession, XrPerfSettingsDomainEXT, XrPerfSettingsLevelEXT); + XrResult (*p_xrPerformEnvironmentRaycastMETA)(XrEnvironmentRaycasterMETA, const XrEnvironmentRaycastHitGetInfoMETA *, XrEnvironmentRaycastHitMETA *); XrResult (*p_xrPersistAnchorANDROID)(XrDeviceAnchorPersistenceANDROID, const XrPersistedAnchorSpaceInfoANDROID *, XrUuidEXT *); XrResult (*p_xrPersistSpatialAnchorAsyncBD)(XrSenseDataProviderBD, const XrSpatialAnchorPersistInfoBD *, XrFutureEXT *); XrResult (*p_xrPersistSpatialAnchorCompleteBD)(XrSenseDataProviderBD, XrFutureEXT, XrFutureCompletionEXT *); @@ -347,7 +394,9 @@ struct openxr_instance_funcs XrResult (*p_xrPollFutureEXT)(XrInstance, const XrFuturePollInfoEXT *, XrFuturePollResultEXT *); XrResult (*p_xrPublishSpatialAnchorsAsyncML)(XrSpatialAnchorsStorageML, const XrSpatialAnchorsPublishInfoML *, XrFutureEXT *); XrResult (*p_xrPublishSpatialAnchorsCompleteML)(XrSpatialAnchorsStorageML, XrFutureEXT, XrSpatialAnchorsPublishCompletionML *); + XrResult (*p_xrQueryFramesPerBufferRangeBD)(XrSession, XrAudioSampleRateBD, uint32_t *, uint32_t *); XrResult (*p_xrQueryLocalizationMapsML)(XrSession, const XrLocalizationMapQueryInfoBaseHeaderML *, uint32_t, uint32_t *, XrLocalizationMapML *); + XrResult (*p_xrQueryPerformanceMetricsCounterANDROID)(XrSession, XrPath, XrPerformanceMetricsCounterANDROID *); XrResult (*p_xrQueryPerformanceMetricsCounterMETA)(XrSession, XrPath, XrPerformanceMetricsCounterMETA *); XrResult (*p_xrQuerySenseDataAsyncBD)(XrSenseDataProviderBD, const XrSenseDataQueryInfoBD *, XrFutureEXT *); XrResult (*p_xrQuerySenseDataCompleteBD)(XrSenseDataProviderBD, XrFutureEXT, XrSenseDataQueryCompletionBD *); @@ -358,6 +407,8 @@ struct openxr_instance_funcs XrResult (*p_xrQuerySystemTrackedKeyboardFB)(XrSession, const XrKeyboardTrackingQueryFB *, XrKeyboardTrackingDescriptionFB *); XrResult (*p_xrRaycastANDROID)(XrSession, const XrRaycastInfoANDROID *, XrRaycastHitResultsANDROID *); XrResult (*p_xrReleaseSwapchainImage)(XrSwapchain, const XrSwapchainImageReleaseInfo *); + XrResult (*p_xrRemoveTrackableImageDatabaseANDROID)(XrTrackableTrackerANDROID, XrTrackableImageDatabaseANDROID); + XrResult (*p_xrRequestBodyTrackingFidelityMETA)(XrBodyTrackerFB, const XrBodyTrackingFidelityMETA); XrResult (*p_xrRequestDisplayRefreshRateFB)(XrSession, float); XrResult (*p_xrRequestExitSession)(XrSession); XrResult (*p_xrRequestMapLocalizationML)(XrSession, const XrMapLocalizationRequestInfoML *); @@ -379,6 +430,7 @@ struct openxr_instance_funcs XrResult (*p_xrSetDigitalLensControlALMALENCE)(XrSession, const XrDigitalLensControlALMALENCE *); XrResult (*p_xrSetEnvironmentDepthEstimationVARJO)(XrSession, XrBool32); XrResult (*p_xrSetEnvironmentDepthHandRemovalMETA)(XrEnvironmentDepthProviderMETA, const XrEnvironmentDepthHandRemovalSetInfoMETA *); + XrResult (*p_xrSetFacialSimulationModeBD)(XrFaceTrackerBD, XrFacialSimulationModeBD); XrResult (*p_xrSetInputDeviceActiveEXT)(XrSession, XrPath, XrPath, XrBool32); XrResult (*p_xrSetInputDeviceLocationEXT)(XrSession, XrPath, XrPath, XrSpace, XrPosef); XrResult (*p_xrSetInputDeviceStateBoolEXT)(XrSession, XrPath, XrPath, XrBool32); @@ -387,9 +439,12 @@ struct openxr_instance_funcs XrResult (*p_xrSetMarkerTrackingPredictionVARJO)(XrSession, uint64_t, XrBool32); XrResult (*p_xrSetMarkerTrackingTimeoutVARJO)(XrSession, uint64_t, XrDuration); XrResult (*p_xrSetMarkerTrackingVARJO)(XrSession, XrBool32); + XrResult (*p_xrSetPassthroughLayerMeshANDROID)(XrPassthroughLayerANDROID, const XrPassthroughLayerMeshANDROID *); + XrResult (*p_xrSetPerformanceMetricsStateANDROID)(XrSession, const XrPerformanceMetricsStateANDROID *); XrResult (*p_xrSetPerformanceMetricsStateMETA)(XrSession, const XrPerformanceMetricsStateMETA *); XrResult (*p_xrSetSpaceComponentStatusFB)(XrSpace, const XrSpaceComponentStatusSetInfoFB *, XrAsyncRequestIdFB *); XrResult (*p_xrSetSystemNotificationsML)(XrInstance, const XrSystemNotificationsSetInfoML *); + XrResult (*p_xrSetTilePropertiesHintMETA)(XrSession, const XrTilePropertiesHintMETA *); XrResult (*p_xrSetTrackingOptimizationSettingsHintQCOM)(XrSession, XrTrackingOptimizationSettingsDomainQCOM, XrTrackingOptimizationSettingsHintQCOM); XrResult (*p_xrSetViewOffsetVARJO)(XrSession, float); XrResult (*p_xrSetVirtualKeyboardModelVisibilityMETA)(XrVirtualKeyboardMETA, const XrVirtualKeyboardModelVisibilitySetInfoMETA *); @@ -411,6 +466,8 @@ struct openxr_instance_funcs XrResult (*p_xrStringToPath)(XrInstance, const char *, XrPath *); XrResult (*p_xrStructureTypeToString)(XrInstance, XrStructureType, char[]); XrResult (*p_xrStructureTypeToString2KHR)(XrInstance, XrStructureType, char[]); + XrResult (*p_xrSubmitSoundFieldBufferBD)(XrSoundFieldBD, const XrAudioBufferBD *); + XrResult (*p_xrSubmitSoundObjectBufferBD)(XrSoundObjectBD, const XrAudioBufferBD *); XrResult (*p_xrSuggestBodyTrackingCalibrationOverrideMETA)(XrBodyTrackerFB, const XrBodyTrackingCalibrationInfoMETA *); XrResult (*p_xrSuggestInteractionProfileBindings)(XrInstance, const XrInteractionProfileSuggestedBinding *); XrResult (*p_xrSuggestVirtualKeyboardLocationMETA)(XrVirtualKeyboardMETA, const XrVirtualKeyboardLocationInfoMETA *); @@ -431,9 +488,14 @@ struct openxr_instance_funcs XrResult (*p_xrUnpersistSpatialEntityCompleteEXT)(XrSpatialPersistenceContextEXT, XrFutureEXT, XrUnpersistSpatialEntityCompletionEXT *); XrResult (*p_xrUpdateHandMeshMSFT)(XrHandTrackerEXT, const XrHandMeshUpdateInfoMSFT *, XrHandMeshMSFT *); XrResult (*p_xrUpdatePassthroughColorLutMETA)(XrPassthroughColorLutMETA, const XrPassthroughColorLutUpdateInfoMETA *); + XrResult (*p_xrUpdateSoundFieldConfigBD)(XrSoundFieldBD, const XrSoundFieldConfigBD *, XrSoundFieldFlagsBD); + XrResult (*p_xrUpdateSoundObjectConfigBD)(XrSoundObjectBD, const XrSoundObjectConfigBD *, XrSoundObjectFlagsBD); + XrResult (*p_xrUpdateSoundObstacleConfigBD)(XrSoundObstacleBD, const XrSoundObstacleConfigBD *, const XrSoundTriangleMeshBD *, XrSoundObstacleFlagsBD); + XrResult (*p_xrUpdateSoundObstacleMaterialConfigBD)(XrSoundObstacleMaterialBD, const XrSoundObstacleMaterialConfigBD *); XrResult (*p_xrUpdateSpatialAnchorsExpirationAsyncML)(XrSpatialAnchorsStorageML, const XrSpatialAnchorsUpdateExpirationInfoML *, XrFutureEXT *); XrResult (*p_xrUpdateSpatialAnchorsExpirationCompleteML)(XrSpatialAnchorsStorageML, XrFutureEXT, XrSpatialAnchorsUpdateExpirationCompletionML *); XrResult (*p_xrUpdateSwapchainFB)(XrSwapchain, const XrSwapchainStateBaseHeaderFB *); + XrResult (*p_xrWaitAudioPeriodBD)(XrSpatialAudioRendererBD, XrDuration); XrResult (*p_xrWaitFrame)(XrSession, const XrFrameWaitInfo *, XrFrameState *); XrResult (*p_xrWaitSwapchainImage)(XrSwapchain, const XrSwapchainImageWaitInfo *); }; @@ -441,6 +503,7 @@ struct openxr_instance_funcs #define ALL_XR_INSTANCE_FUNCS() \ USE_XR_FUNC(xrAcquireEnvironmentDepthImageMETA) \ USE_XR_FUNC(xrAcquireSwapchainImage) \ + USE_XR_FUNC(xrAddTrackableImageDatabaseANDROID) \ USE_XR_FUNC(xrAllocateWorldMeshBufferML) \ USE_XR_FUNC(xrApplyForceFeedbackCurlMNDX) \ USE_XR_FUNC(xrApplyHapticFeedback) \ @@ -466,9 +529,13 @@ struct openxr_instance_funcs USE_XR_FUNC(xrCreateDeviceAnchorPersistenceANDROID) \ USE_XR_FUNC(xrCreateEnvironmentDepthProviderMETA) \ USE_XR_FUNC(xrCreateEnvironmentDepthSwapchainMETA) \ + USE_XR_FUNC(xrCreateEnvironmentRaycasterAsyncMETA) \ + USE_XR_FUNC(xrCreateEnvironmentRaycasterCompleteMETA) \ USE_XR_FUNC(xrCreateExportedLocalizationMapML) \ USE_XR_FUNC(xrCreateEyeTrackerFB) \ USE_XR_FUNC(xrCreateFaceTracker2FB) \ + USE_XR_FUNC(xrCreateFaceTrackerANDROID) \ + USE_XR_FUNC(xrCreateFaceTrackerBD) \ USE_XR_FUNC(xrCreateFaceTrackerFB) \ USE_XR_FUNC(xrCreateFacialExpressionClientML) \ USE_XR_FUNC(xrCreateFacialTrackerHTC) \ @@ -483,6 +550,7 @@ struct openxr_instance_funcs USE_XR_FUNC(xrCreatePassthroughColorLutMETA) \ USE_XR_FUNC(xrCreatePassthroughFB) \ USE_XR_FUNC(xrCreatePassthroughHTC) \ + USE_XR_FUNC(xrCreatePassthroughLayerANDROID) \ USE_XR_FUNC(xrCreatePassthroughLayerFB) \ USE_XR_FUNC(xrCreatePersistedAnchorSpaceANDROID) \ USE_XR_FUNC(xrCreatePlaneDetectorEXT) \ @@ -491,9 +559,15 @@ struct openxr_instance_funcs USE_XR_FUNC(xrCreateRenderModelEXT) \ USE_XR_FUNC(xrCreateRenderModelSpaceEXT) \ USE_XR_FUNC(xrCreateSceneMSFT) \ + USE_XR_FUNC(xrCreateSceneMeshSnapshotANDROID) \ + USE_XR_FUNC(xrCreateSceneMeshingTrackerANDROID) \ USE_XR_FUNC(xrCreateSceneObserverMSFT) \ USE_XR_FUNC(xrCreateSenseDataProviderBD) \ USE_XR_FUNC(xrCreateSession) \ + USE_XR_FUNC(xrCreateSoundFieldBD) \ + USE_XR_FUNC(xrCreateSoundObjectBD) \ + USE_XR_FUNC(xrCreateSoundObstacleBD) \ + USE_XR_FUNC(xrCreateSoundObstacleMaterialBD) \ USE_XR_FUNC(xrCreateSpaceUserFB) \ USE_XR_FUNC(xrCreateSpatialAnchorAsyncBD) \ USE_XR_FUNC(xrCreateSpatialAnchorCompleteBD) \ @@ -502,11 +576,14 @@ struct openxr_instance_funcs USE_XR_FUNC(xrCreateSpatialAnchorFromPersistedNameMSFT) \ USE_XR_FUNC(xrCreateSpatialAnchorHTC) \ USE_XR_FUNC(xrCreateSpatialAnchorMSFT) \ + USE_XR_FUNC(xrCreateSpatialAnchorSpaceANDROID) \ + USE_XR_FUNC(xrCreateSpatialAnchorSpaceFromIdANDROID) \ USE_XR_FUNC(xrCreateSpatialAnchorSpaceMSFT) \ USE_XR_FUNC(xrCreateSpatialAnchorStoreConnectionMSFT) \ USE_XR_FUNC(xrCreateSpatialAnchorsAsyncML) \ USE_XR_FUNC(xrCreateSpatialAnchorsCompleteML) \ USE_XR_FUNC(xrCreateSpatialAnchorsStorageML) \ + USE_XR_FUNC(xrCreateSpatialAudioRendererBD) \ USE_XR_FUNC(xrCreateSpatialContextAsyncEXT) \ USE_XR_FUNC(xrCreateSpatialContextCompleteEXT) \ USE_XR_FUNC(xrCreateSpatialDiscoverySnapshotAsyncEXT) \ @@ -516,8 +593,11 @@ struct openxr_instance_funcs USE_XR_FUNC(xrCreateSpatialGraphNodeSpaceMSFT) \ USE_XR_FUNC(xrCreateSpatialPersistenceContextAsyncEXT) \ USE_XR_FUNC(xrCreateSpatialPersistenceContextCompleteEXT) \ + USE_XR_FUNC(xrCreateSpatialRaycastSnapshotANDROID) \ USE_XR_FUNC(xrCreateSpatialUpdateSnapshotEXT) \ USE_XR_FUNC(xrCreateSwapchain) \ + USE_XR_FUNC(xrCreateTrackableImageDatabaseAsyncANDROID) \ + USE_XR_FUNC(xrCreateTrackableImageDatabaseCompleteANDROID) \ USE_XR_FUNC(xrCreateTrackableTrackerANDROID) \ USE_XR_FUNC(xrCreateTriangleMeshFB) \ USE_XR_FUNC(xrCreateVirtualKeyboardMETA) \ @@ -537,9 +617,12 @@ struct openxr_instance_funcs USE_XR_FUNC(xrDestroyDeviceAnchorPersistenceANDROID) \ USE_XR_FUNC(xrDestroyEnvironmentDepthProviderMETA) \ USE_XR_FUNC(xrDestroyEnvironmentDepthSwapchainMETA) \ + USE_XR_FUNC(xrDestroyEnvironmentRaycasterMETA) \ USE_XR_FUNC(xrDestroyExportedLocalizationMapML) \ USE_XR_FUNC(xrDestroyEyeTrackerFB) \ USE_XR_FUNC(xrDestroyFaceTracker2FB) \ + USE_XR_FUNC(xrDestroyFaceTrackerANDROID) \ + USE_XR_FUNC(xrDestroyFaceTrackerBD) \ USE_XR_FUNC(xrDestroyFaceTrackerFB) \ USE_XR_FUNC(xrDestroyFacialExpressionClientML) \ USE_XR_FUNC(xrDestroyFacialTrackerHTC) \ @@ -551,26 +634,35 @@ struct openxr_instance_funcs USE_XR_FUNC(xrDestroyPassthroughColorLutMETA) \ USE_XR_FUNC(xrDestroyPassthroughFB) \ USE_XR_FUNC(xrDestroyPassthroughHTC) \ + USE_XR_FUNC(xrDestroyPassthroughLayerANDROID) \ USE_XR_FUNC(xrDestroyPassthroughLayerFB) \ USE_XR_FUNC(xrDestroyPlaneDetectorEXT) \ USE_XR_FUNC(xrDestroyRenderModelAssetEXT) \ USE_XR_FUNC(xrDestroyRenderModelEXT) \ USE_XR_FUNC(xrDestroySceneMSFT) \ + USE_XR_FUNC(xrDestroySceneMeshSnapshotANDROID) \ + USE_XR_FUNC(xrDestroySceneMeshingTrackerANDROID) \ USE_XR_FUNC(xrDestroySceneObserverMSFT) \ USE_XR_FUNC(xrDestroySenseDataProviderBD) \ USE_XR_FUNC(xrDestroySenseDataSnapshotBD) \ USE_XR_FUNC(xrDestroySession) \ + USE_XR_FUNC(xrDestroySoundFieldBD) \ + USE_XR_FUNC(xrDestroySoundObjectBD) \ + USE_XR_FUNC(xrDestroySoundObstacleBD) \ + USE_XR_FUNC(xrDestroySoundObstacleMaterialBD) \ USE_XR_FUNC(xrDestroySpace) \ USE_XR_FUNC(xrDestroySpaceUserFB) \ USE_XR_FUNC(xrDestroySpatialAnchorMSFT) \ USE_XR_FUNC(xrDestroySpatialAnchorStoreConnectionMSFT) \ USE_XR_FUNC(xrDestroySpatialAnchorsStorageML) \ + USE_XR_FUNC(xrDestroySpatialAudioRendererBD) \ USE_XR_FUNC(xrDestroySpatialContextEXT) \ USE_XR_FUNC(xrDestroySpatialEntityEXT) \ USE_XR_FUNC(xrDestroySpatialGraphNodeBindingMSFT) \ USE_XR_FUNC(xrDestroySpatialPersistenceContextEXT) \ USE_XR_FUNC(xrDestroySpatialSnapshotEXT) \ USE_XR_FUNC(xrDestroySwapchain) \ + USE_XR_FUNC(xrDestroyTrackableImageDatabaseANDROID) \ USE_XR_FUNC(xrDestroyTrackableTrackerANDROID) \ USE_XR_FUNC(xrDestroyTriangleMeshFB) \ USE_XR_FUNC(xrDestroyVirtualKeyboardMETA) \ @@ -580,6 +672,7 @@ struct openxr_instance_funcs USE_XR_FUNC(xrDownloadSharedSpatialAnchorCompleteBD) \ USE_XR_FUNC(xrEnableLocalizationEventsML) \ USE_XR_FUNC(xrEnableUserCalibrationEventsML) \ + USE_XR_FUNC(xrEndAudioPeriodBD) \ USE_XR_FUNC(xrEndFrame) \ USE_XR_FUNC(xrEndSession) \ USE_XR_FUNC(xrEnumerateApiLayerProperties) \ @@ -589,7 +682,9 @@ struct openxr_instance_funcs USE_XR_FUNC(xrEnumerateEnvironmentBlendModes) \ USE_XR_FUNC(xrEnumerateEnvironmentDepthSwapchainImagesMETA) \ USE_XR_FUNC(xrEnumerateExternalCamerasOCULUS) \ + USE_XR_FUNC(xrEnumerateFacialSimulationModesBD) \ USE_XR_FUNC(xrEnumerateInteractionRenderModelIdsEXT) \ + USE_XR_FUNC(xrEnumeratePerformanceMetricsCounterPathsANDROID) \ USE_XR_FUNC(xrEnumeratePerformanceMetricsCounterPathsMETA) \ USE_XR_FUNC(xrEnumeratePersistedAnchorsANDROID) \ USE_XR_FUNC(xrEnumeratePersistedSpatialAnchorNamesMSFT) \ @@ -600,13 +695,16 @@ struct openxr_instance_funcs USE_XR_FUNC(xrEnumerateReprojectionModesMSFT) \ USE_XR_FUNC(xrEnumerateSceneComputeFeaturesMSFT) \ USE_XR_FUNC(xrEnumerateSpaceSupportedComponentsFB) \ + USE_XR_FUNC(xrEnumerateSpatialAnchorAttachableComponentsANDROID) \ USE_XR_FUNC(xrEnumerateSpatialCapabilitiesEXT) \ USE_XR_FUNC(xrEnumerateSpatialCapabilityComponentTypesEXT) \ USE_XR_FUNC(xrEnumerateSpatialCapabilityFeaturesEXT) \ USE_XR_FUNC(xrEnumerateSpatialEntityComponentTypesBD) \ USE_XR_FUNC(xrEnumerateSpatialPersistenceScopesEXT) \ USE_XR_FUNC(xrEnumerateSupportedAnchorTrackableTypesANDROID) \ + USE_XR_FUNC(xrEnumerateSupportedAudioSampleRateBD) \ USE_XR_FUNC(xrEnumerateSupportedPersistenceAnchorTypesANDROID) \ + USE_XR_FUNC(xrEnumerateSupportedSemanticLabelSetsANDROID) \ USE_XR_FUNC(xrEnumerateSupportedTrackableTypesANDROID) \ USE_XR_FUNC(xrEnumerateSwapchainFormats) \ USE_XR_FUNC(xrEnumerateSwapchainImages) \ @@ -621,6 +719,7 @@ struct openxr_instance_funcs USE_XR_FUNC(xrGetActionStateFloat) \ USE_XR_FUNC(xrGetActionStatePose) \ USE_XR_FUNC(xrGetActionStateVector2f) \ + USE_XR_FUNC(xrGetAllSubmeshStatesANDROID) \ USE_XR_FUNC(xrGetAllTrackablesANDROID) \ USE_XR_FUNC(xrGetAnchorPersistStateANDROID) \ USE_XR_FUNC(xrGetAnchorUuidBD) \ @@ -637,11 +736,16 @@ struct openxr_instance_funcs USE_XR_FUNC(xrGetEnvironmentDepthSwapchainStateMETA) \ USE_XR_FUNC(xrGetExportedLocalizationMapDataML) \ USE_XR_FUNC(xrGetEyeGazesFB) \ + USE_XR_FUNC(xrGetFaceCalibrationStateANDROID) \ USE_XR_FUNC(xrGetFaceExpressionWeights2FB) \ USE_XR_FUNC(xrGetFaceExpressionWeightsFB) \ + USE_XR_FUNC(xrGetFaceStateANDROID) \ USE_XR_FUNC(xrGetFacialExpressionBlendShapePropertiesML) \ USE_XR_FUNC(xrGetFacialExpressionsHTC) \ + USE_XR_FUNC(xrGetFacialSimulationDataBD) \ + USE_XR_FUNC(xrGetFacialSimulationModeBD) \ USE_XR_FUNC(xrGetFoveationEyeTrackedStateMETA) \ + USE_XR_FUNC(xrGetHandGestureQCOM) \ USE_XR_FUNC(xrGetHandMeshFB) \ USE_XR_FUNC(xrGetInputSourceLocalizedName) \ USE_XR_FUNC(xrGetInstanceProperties) \ @@ -655,6 +759,7 @@ struct openxr_instance_funcs USE_XR_FUNC(xrGetOpenGLGraphicsRequirementsKHR) \ USE_XR_FUNC(xrGetPassthroughCameraStateANDROID) \ USE_XR_FUNC(xrGetPassthroughPreferencesMETA) \ + USE_XR_FUNC(xrGetPerformanceMetricsStateANDROID) \ USE_XR_FUNC(xrGetPerformanceMetricsStateMETA) \ USE_XR_FUNC(xrGetPlaneDetectionStateEXT) \ USE_XR_FUNC(xrGetPlaneDetectionsEXT) \ @@ -697,12 +802,15 @@ struct openxr_instance_funcs USE_XR_FUNC(xrGetSpatialEntityComponentDataBD) \ USE_XR_FUNC(xrGetSpatialEntityUuidBD) \ USE_XR_FUNC(xrGetSpatialGraphNodeBindingPropertiesMSFT) \ + USE_XR_FUNC(xrGetSubmeshDataANDROID) \ USE_XR_FUNC(xrGetSwapchainStateFB) \ USE_XR_FUNC(xrGetSystem) \ USE_XR_FUNC(xrGetSystemProperties) \ + USE_XR_FUNC(xrGetTrackableImageANDROID) \ USE_XR_FUNC(xrGetTrackableMarkerANDROID) \ USE_XR_FUNC(xrGetTrackableObjectANDROID) \ USE_XR_FUNC(xrGetTrackablePlaneANDROID) \ + USE_XR_FUNC(xrGetTrackableQrCodeANDROID) \ USE_XR_FUNC(xrGetViewConfigurationProperties) \ USE_XR_FUNC(xrGetVirtualKeyboardDirtyTexturesMETA) \ USE_XR_FUNC(xrGetVirtualKeyboardModelAnimationStatesMETA) \ @@ -738,6 +846,7 @@ struct openxr_instance_funcs USE_XR_FUNC(xrPathToString) \ USE_XR_FUNC(xrPauseSimultaneousHandsAndControllersTrackingMETA) \ USE_XR_FUNC(xrPerfSettingsSetPerformanceLevelEXT) \ + USE_XR_FUNC(xrPerformEnvironmentRaycastMETA) \ USE_XR_FUNC(xrPersistAnchorANDROID) \ USE_XR_FUNC(xrPersistSpatialAnchorAsyncBD) \ USE_XR_FUNC(xrPersistSpatialAnchorCompleteBD) \ @@ -748,7 +857,9 @@ struct openxr_instance_funcs USE_XR_FUNC(xrPollFutureEXT) \ USE_XR_FUNC(xrPublishSpatialAnchorsAsyncML) \ USE_XR_FUNC(xrPublishSpatialAnchorsCompleteML) \ + USE_XR_FUNC(xrQueryFramesPerBufferRangeBD) \ USE_XR_FUNC(xrQueryLocalizationMapsML) \ + USE_XR_FUNC(xrQueryPerformanceMetricsCounterANDROID) \ USE_XR_FUNC(xrQueryPerformanceMetricsCounterMETA) \ USE_XR_FUNC(xrQuerySenseDataAsyncBD) \ USE_XR_FUNC(xrQuerySenseDataCompleteBD) \ @@ -759,6 +870,8 @@ struct openxr_instance_funcs USE_XR_FUNC(xrQuerySystemTrackedKeyboardFB) \ USE_XR_FUNC(xrRaycastANDROID) \ USE_XR_FUNC(xrReleaseSwapchainImage) \ + USE_XR_FUNC(xrRemoveTrackableImageDatabaseANDROID) \ + USE_XR_FUNC(xrRequestBodyTrackingFidelityMETA) \ USE_XR_FUNC(xrRequestDisplayRefreshRateFB) \ USE_XR_FUNC(xrRequestExitSession) \ USE_XR_FUNC(xrRequestMapLocalizationML) \ @@ -780,6 +893,7 @@ struct openxr_instance_funcs USE_XR_FUNC(xrSetDigitalLensControlALMALENCE) \ USE_XR_FUNC(xrSetEnvironmentDepthEstimationVARJO) \ USE_XR_FUNC(xrSetEnvironmentDepthHandRemovalMETA) \ + USE_XR_FUNC(xrSetFacialSimulationModeBD) \ USE_XR_FUNC(xrSetInputDeviceActiveEXT) \ USE_XR_FUNC(xrSetInputDeviceLocationEXT) \ USE_XR_FUNC(xrSetInputDeviceStateBoolEXT) \ @@ -788,9 +902,12 @@ struct openxr_instance_funcs USE_XR_FUNC(xrSetMarkerTrackingPredictionVARJO) \ USE_XR_FUNC(xrSetMarkerTrackingTimeoutVARJO) \ USE_XR_FUNC(xrSetMarkerTrackingVARJO) \ + USE_XR_FUNC(xrSetPassthroughLayerMeshANDROID) \ + USE_XR_FUNC(xrSetPerformanceMetricsStateANDROID) \ USE_XR_FUNC(xrSetPerformanceMetricsStateMETA) \ USE_XR_FUNC(xrSetSpaceComponentStatusFB) \ USE_XR_FUNC(xrSetSystemNotificationsML) \ + USE_XR_FUNC(xrSetTilePropertiesHintMETA) \ USE_XR_FUNC(xrSetTrackingOptimizationSettingsHintQCOM) \ USE_XR_FUNC(xrSetViewOffsetVARJO) \ USE_XR_FUNC(xrSetVirtualKeyboardModelVisibilityMETA) \ @@ -812,6 +929,8 @@ struct openxr_instance_funcs USE_XR_FUNC(xrStringToPath) \ USE_XR_FUNC(xrStructureTypeToString) \ USE_XR_FUNC(xrStructureTypeToString2KHR) \ + USE_XR_FUNC(xrSubmitSoundFieldBufferBD) \ + USE_XR_FUNC(xrSubmitSoundObjectBufferBD) \ USE_XR_FUNC(xrSuggestBodyTrackingCalibrationOverrideMETA) \ USE_XR_FUNC(xrSuggestInteractionProfileBindings) \ USE_XR_FUNC(xrSuggestVirtualKeyboardLocationMETA) \ @@ -832,9 +951,14 @@ struct openxr_instance_funcs USE_XR_FUNC(xrUnpersistSpatialEntityCompleteEXT) \ USE_XR_FUNC(xrUpdateHandMeshMSFT) \ USE_XR_FUNC(xrUpdatePassthroughColorLutMETA) \ + USE_XR_FUNC(xrUpdateSoundFieldConfigBD) \ + USE_XR_FUNC(xrUpdateSoundObjectConfigBD) \ + USE_XR_FUNC(xrUpdateSoundObstacleConfigBD) \ + USE_XR_FUNC(xrUpdateSoundObstacleMaterialConfigBD) \ USE_XR_FUNC(xrUpdateSpatialAnchorsExpirationAsyncML) \ USE_XR_FUNC(xrUpdateSpatialAnchorsExpirationCompleteML) \ USE_XR_FUNC(xrUpdateSwapchainFB) \ + USE_XR_FUNC(xrWaitAudioPeriodBD) \ USE_XR_FUNC(xrWaitFrame) \ USE_XR_FUNC(xrWaitSwapchainImage) diff --git a/wineopenxr/wineopenxr.h b/wineopenxr/wineopenxr.h index 412cc7cd11d..b284a30622c 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-2025 The Khronos Group Inc. + * Copyright (c) 2017-2026 The Khronos Group Inc. * * SPDX-License-Identifier: Apache-2.0 OR MIT * @@ -79,13 +79,13 @@ #define XR_KHR_COMPOSITION_LAYER_CYLINDER_EXTENSION_NAME "XR_KHR_composition_layer_cylinder" #define XR_KHR_composition_layer_equirect_SPEC_VERSION 3 #define XR_KHR_COMPOSITION_LAYER_EQUIRECT_EXTENSION_NAME "XR_KHR_composition_layer_equirect" -#define XR_KHR_opengl_enable_SPEC_VERSION 11 +#define XR_KHR_opengl_enable_SPEC_VERSION 12 #define XR_KHR_OPENGL_ENABLE_EXTENSION_NAME "XR_KHR_opengl_enable" -#define XR_KHR_vulkan_enable_SPEC_VERSION 9 +#define XR_KHR_vulkan_enable_SPEC_VERSION 10 #define XR_KHR_VULKAN_ENABLE_EXTENSION_NAME "XR_KHR_vulkan_enable" -#define XR_KHR_D3D11_enable_SPEC_VERSION 10 +#define XR_KHR_D3D11_enable_SPEC_VERSION 11 #define XR_KHR_D3D11_ENABLE_EXTENSION_NAME "XR_KHR_D3D11_enable" -#define XR_KHR_D3D12_enable_SPEC_VERSION 10 +#define XR_KHR_D3D12_enable_SPEC_VERSION 11 #define XR_KHR_D3D12_ENABLE_EXTENSION_NAME "XR_KHR_D3D12_enable" #define XR_EXT_eye_gaze_interaction_SPEC_VERSION 2 #define XR_EXT_EYE_GAZE_INTERACTION_EXTENSION_NAME "XR_EXT_eye_gaze_interaction" @@ -107,7 +107,7 @@ #define XR_FB_COMPOSITION_LAYER_IMAGE_LAYOUT_EXTENSION_NAME "XR_FB_composition_layer_image_layout" #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_SPEC_VERSION 3 #define XR_MND_HEADLESS_EXTENSION_NAME "XR_MND_headless" #define XR_OCULUS_android_session_state_enable_SPEC_VERSION 1 #define XR_OCULUS_ANDROID_SESSION_STATE_ENABLE_EXTENSION_NAME "XR_OCULUS_android_session_state_enable" @@ -153,7 +153,7 @@ #define XR_VALVE_ANALOG_THRESHOLD_EXTENSION_NAME "XR_VALVE_analog_threshold" #define XR_EXT_hand_joints_motion_range_SPEC_VERSION 1 #define XR_EXT_HAND_JOINTS_MOTION_RANGE_EXTENSION_NAME "XR_EXT_hand_joints_motion_range" -#define XR_KHR_vulkan_enable2_SPEC_VERSION 3 +#define XR_KHR_vulkan_enable2_SPEC_VERSION 4 #define XR_KHR_VULKAN_ENABLE2_EXTENSION_NAME "XR_KHR_vulkan_enable2" #define XR_KHR_composition_layer_equirect2_SPEC_VERSION 1 #define XR_KHR_COMPOSITION_LAYER_EQUIRECT2_EXTENSION_NAME "XR_KHR_composition_layer_equirect2" @@ -246,7 +246,7 @@ #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_SPEC_VERSION 2 #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 @@ -345,12 +345,14 @@ #define XR_META_PASSTHROUGH_LAYER_RESUMED_EVENT_EXTENSION_NAME "XR_META_passthrough_layer_resumed_event" #define XR_META_body_tracking_calibration_SPEC_VERSION 1 #define XR_META_BODY_TRACKING_CALIBRATION_EXTENSION_NAME "XR_META_body_tracking_calibration" +#define XR_META_body_tracking_fidelity_SPEC_VERSION 1 +#define XR_META_BODY_TRACKING_FIDELITY_EXTENSION_NAME "XR_META_body_tracking_fidelity" #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_SPEC_VERSION 2 #define XR_META_ENVIRONMENT_DEPTH_EXTENSION_NAME "XR_META_environment_depth" #define XR_EXT_uuid_SPEC_VERSION 1 #define XR_EXT_UUID_EXTENSION_NAME "XR_EXT_uuid" @@ -365,6 +367,8 @@ #define XR_EXT_HAND_INTERACTION_EXTENSION_NAME "XR_EXT_hand_interaction" #define XR_QCOM_tracking_optimization_settings_SPEC_VERSION 1 #define XR_QCOM_TRACKING_OPTIMIZATION_SETTINGS_EXTENSION_NAME "XR_QCOM_tracking_optimization_settings" +#define XR_QCOM_hand_tracking_gesture_SPEC_VERSION 1 +#define XR_QCOM_HAND_TRACKING_GESTURE_EXTENSION_NAME "XR_QCOM_hand_tracking_gesture" #define XR_HTC_passthrough_SPEC_VERSION 1 #define XR_HTC_PASSTHROUGH_EXTENSION_NAME "XR_HTC_passthrough" #define XR_HTC_anchor_SPEC_VERSION 1 @@ -380,6 +384,8 @@ #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_facial_simulation_SPEC_VERSION 1 +#define XR_BD_FACIAL_SIMULATION_EXTENSION_NAME "XR_BD_facial_simulation" #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 2 @@ -394,6 +400,10 @@ #define XR_BD_FUTURE_PROGRESS_EXTENSION_NAME "XR_BD_future_progress" #define XR_BD_spatial_plane_SPEC_VERSION 1 #define XR_BD_SPATIAL_PLANE_EXTENSION_NAME "XR_BD_spatial_plane" +#define XR_BD_ultra_controller_interaction_SPEC_VERSION 1 +#define XR_BD_ULTRA_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_BD_ultra_controller_interaction" +#define XR_BD_spatial_audio_rendering_SPEC_VERSION 1 +#define XR_BD_SPATIAL_AUDIO_RENDERING_EXTENSION_NAME "XR_BD_spatial_audio_rendering" #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 @@ -406,13 +416,23 @@ #define XR_ANDROID_TRACKABLES_EXTENSION_NAME "XR_ANDROID_trackables" #define XR_ANDROID_device_anchor_persistence_SPEC_VERSION 1 #define XR_ANDROID_DEVICE_ANCHOR_PERSISTENCE_EXTENSION_NAME "XR_ANDROID_device_anchor_persistence" +#define XR_ANDROID_face_tracking_SPEC_VERSION 1 +#define XR_ANDROID_FACE_TRACKING_EXTENSION_NAME "XR_ANDROID_face_tracking" +#define XR_FACE_PARAMETER_COUNT_ANDROID 68 +#define XR_FACE_REGION_CONFIDENCE_COUNT_ANDROID 3 #define XR_ANDROID_passthrough_camera_state_SPEC_VERSION 1 #define XR_ANDROID_PASSTHROUGH_CAMERA_STATE_EXTENSION_NAME "XR_ANDROID_passthrough_camera_state" +#define XR_ANDROID_composition_layer_passthrough_mesh_SPEC_VERSION 1 +#define XR_ANDROID_COMPOSITION_LAYER_PASSTHROUGH_MESH_EXTENSION_NAME "XR_ANDROID_composition_layer_passthrough_mesh" #define XR_ANDROID_raycast_SPEC_VERSION 1 #define XR_ANDROID_RAYCAST_EXTENSION_NAME "XR_ANDROID_raycast" -#define XR_ANDROID_trackables_object_SPEC_VERSION 1 +#define XR_ANDROID_performance_metrics_SPEC_VERSION 1 +#define XR_ANDROID_PERFORMANCE_METRICS_EXTENSION_NAME "XR_ANDROID_performance_metrics" +#define XR_ANDROID_trackables_object_SPEC_VERSION 2 #define XR_ANDROID_TRACKABLES_OBJECT_EXTENSION_NAME "XR_ANDROID_trackables_object" -#define XR_EXT_future_SPEC_VERSION 1 +#define XR_ANDROID_unbounded_reference_space_SPEC_VERSION 1 +#define XR_ANDROID_UNBOUNDED_REFERENCE_SPACE_EXTENSION_NAME "XR_ANDROID_unbounded_reference_space" +#define XR_EXT_future_SPEC_VERSION 2 #define XR_EXT_FUTURE_EXTENSION_NAME "XR_EXT_future" #define XR_NULL_FUTURE_EXT 0 #define XR_EXT_user_presence_SPEC_VERSION 1 @@ -431,6 +451,8 @@ #define XR_YVR_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_YVR_controller_interaction" #define XR_META_simultaneous_hands_and_controllers_SPEC_VERSION 1 #define XR_META_SIMULTANEOUS_HANDS_AND_CONTROLLERS_EXTENSION_NAME "XR_META_simultaneous_hands_and_controllers" +#define XR_META_spatial_entity_semantic_label_SPEC_VERSION 1 +#define XR_META_SPATIAL_ENTITY_SEMANTIC_LABEL_EXTENSION_NAME "XR_META_spatial_entity_semantic_label" #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 @@ -438,12 +460,24 @@ #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_META_environment_raycast_SPEC_VERSION 1 +#define XR_META_ENVIRONMENT_RAYCAST_EXTENSION_NAME "XR_META_environment_raycast" +#define XR_META_tile_properties_hint_SPEC_VERSION 1 +#define XR_META_TILE_PROPERTIES_HINT_EXTENSION_NAME "XR_META_tile_properties_hint" +#define XR_ANDROID_mouse_interaction_SPEC_VERSION 1 +#define XR_ANDROID_MOUSE_INTERACTION_EXTENSION_NAME "XR_ANDROID_mouse_interaction" #define XR_ANDROID_trackables_marker_SPEC_VERSION 1 #define XR_ANDROID_TRACKABLES_MARKER_EXTENSION_NAME "XR_ANDROID_trackables_marker" +#define XR_ANDROID_trackables_qr_code_SPEC_VERSION 1 +#define XR_ANDROID_TRACKABLES_QR_CODE_EXTENSION_NAME "XR_ANDROID_trackables_qr_code" +#define XR_ANDROID_trackables_image_SPEC_VERSION 1 +#define XR_ANDROID_TRACKABLES_IMAGE_EXTENSION_NAME "XR_ANDROID_trackables_image" #define XR_KHR_maintenance1_SPEC_VERSION 1 #define XR_KHR_MAINTENANCE1_EXTENSION_NAME "XR_KHR_maintenance1" #define XR_KHR_generic_controller_SPEC_VERSION 1 #define XR_KHR_GENERIC_CONTROLLER_EXTENSION_NAME "XR_KHR_generic_controller" +#define XR_ANDROID_scene_meshing_SPEC_VERSION 3 +#define XR_ANDROID_SCENE_MESHING_EXTENSION_NAME "XR_ANDROID_scene_meshing" #define XR_EXT_spatial_entity_SPEC_VERSION 1 #define XR_EXT_SPATIAL_ENTITY_EXTENSION_NAME "XR_EXT_spatial_entity" #define XR_EXT_spatial_plane_tracking_SPEC_VERSION 1 @@ -458,8 +492,22 @@ #define XR_EXT_SPATIAL_PERSISTENCE_EXTENSION_NAME "XR_EXT_spatial_persistence" #define XR_EXT_spatial_persistence_operations_SPEC_VERSION 1 #define XR_EXT_SPATIAL_PERSISTENCE_OPERATIONS_EXTENSION_NAME "XR_EXT_spatial_persistence_operations" +#define XR_ANDROID_spatial_object_tracking_SPEC_VERSION 2 +#define XR_ANDROID_SPATIAL_OBJECT_TRACKING_EXTENSION_NAME "XR_ANDROID_spatial_object_tracking" +#define XR_ANDROID_spatial_discovery_raycast_SPEC_VERSION 1 +#define XR_ANDROID_SPATIAL_DISCOVERY_RAYCAST_EXTENSION_NAME "XR_ANDROID_spatial_discovery_raycast" +#define XR_ANDROID_spatial_entity_bound_anchor_SPEC_VERSION 2 +#define XR_ANDROID_SPATIAL_ENTITY_BOUND_ANCHOR_EXTENSION_NAME "XR_ANDROID_spatial_entity_bound_anchor" +#define XR_ANDROID_spatial_component_subsumed_by_SPEC_VERSION 1 +#define XR_ANDROID_SPATIAL_COMPONENT_SUBSUMED_BY_EXTENSION_NAME "XR_ANDROID_spatial_component_subsumed_by" +#define XR_ANDROID_spatial_anchor_space_SPEC_VERSION 1 +#define XR_ANDROID_SPATIAL_ANCHOR_SPACE_EXTENSION_NAME "XR_ANDROID_spatial_anchor_space" +#define XR_EXT_interaction_profile_battery_state_display_SPEC_VERSION 1 +#define XR_EXT_INTERACTION_PROFILE_BATTERY_STATE_DISPLAY_EXTENSION_NAME "XR_EXT_interaction_profile_battery_state_display" #define XR_EXT_loader_init_properties_SPEC_VERSION 1 #define XR_EXT_LOADER_INIT_PROPERTIES_EXTENSION_NAME "XR_EXT_loader_init_properties" +#define XR_EXT_view_configuration_views_change_SPEC_VERSION 1 +#define XR_EXT_VIEW_CONFIGURATION_VIEWS_CHANGE_EXTENSION_NAME "XR_EXT_view_configuration_views_change" #define XR_MAKE_VERSION(major, minor, patch) \ @@ -472,7 +520,7 @@ #define XR_VERSION_PATCH(version) (uint32_t)((uint64_t)(version) & 0xffffffffULL) -#define XR_CURRENT_API_VERSION XR_MAKE_VERSION(1, 1, 52) +#define XR_CURRENT_API_VERSION XR_MAKE_VERSION(1, 1, 58) #define XR_API_VERSION_1_0 XR_MAKE_VERSION(1, 0, XR_VERSION_PATCH(XR_CURRENT_API_VERSION)) @@ -628,6 +676,12 @@ #define XR_BODY_JOINT_COUNT_HTC 26 + + +#define XR_FACE_EXPRESSION_COUNT_BD 52 + + +#define XR_LIP_EXPRESSION_COUNT_BD 20 XR_DEFINE_HANDLE(XrAction) XR_DEFINE_HANDLE(XrActionSet) XR_DEFINE_HANDLE(XrAnchorBD) @@ -637,9 +691,12 @@ XR_DEFINE_HANDLE(XrBodyTrackerHTC) XR_DEFINE_HANDLE(XrDeviceAnchorPersistenceANDROID) XR_DEFINE_HANDLE(XrEnvironmentDepthProviderMETA) XR_DEFINE_HANDLE(XrEnvironmentDepthSwapchainMETA) +XR_DEFINE_HANDLE(XrEnvironmentRaycasterMETA) XR_DEFINE_HANDLE(XrExportedLocalizationMapML) XR_DEFINE_HANDLE(XrEyeTrackerFB) XR_DEFINE_HANDLE(XrFaceTracker2FB) +XR_DEFINE_HANDLE(XrFaceTrackerANDROID) +XR_DEFINE_HANDLE(XrFaceTrackerBD) XR_DEFINE_HANDLE(XrFaceTrackerFB) XR_DEFINE_HANDLE(XrFacialExpressionClientML) XR_DEFINE_HANDLE(XrFacialTrackerHTC) @@ -651,26 +708,35 @@ XR_DEFINE_HANDLE(XrMarkerDetectorML) XR_DEFINE_HANDLE(XrPassthroughColorLutMETA) XR_DEFINE_HANDLE(XrPassthroughFB) XR_DEFINE_HANDLE(XrPassthroughHTC) +XR_DEFINE_HANDLE(XrPassthroughLayerANDROID) XR_DEFINE_HANDLE(XrPassthroughLayerFB) XR_DEFINE_HANDLE(XrPlaneDetectorEXT) XR_DEFINE_HANDLE(XrRenderModelAssetEXT) XR_DEFINE_HANDLE(XrRenderModelEXT) XR_DEFINE_HANDLE(XrSceneMSFT) +XR_DEFINE_HANDLE(XrSceneMeshSnapshotANDROID) +XR_DEFINE_HANDLE(XrSceneMeshingTrackerANDROID) XR_DEFINE_HANDLE(XrSceneObserverMSFT) XR_DEFINE_HANDLE(XrSenseDataProviderBD) XR_DEFINE_HANDLE(XrSenseDataSnapshotBD) XR_DEFINE_HANDLE(XrSession) +XR_DEFINE_HANDLE(XrSoundFieldBD) +XR_DEFINE_HANDLE(XrSoundObjectBD) +XR_DEFINE_HANDLE(XrSoundObstacleBD) +XR_DEFINE_HANDLE(XrSoundObstacleMaterialBD) XR_DEFINE_HANDLE(XrSpace) XR_DEFINE_HANDLE(XrSpaceUserFB) XR_DEFINE_HANDLE(XrSpatialAnchorMSFT) XR_DEFINE_HANDLE(XrSpatialAnchorStoreConnectionMSFT) XR_DEFINE_HANDLE(XrSpatialAnchorsStorageML) +XR_DEFINE_HANDLE(XrSpatialAudioRendererBD) XR_DEFINE_HANDLE(XrSpatialContextEXT) XR_DEFINE_HANDLE(XrSpatialEntityEXT) XR_DEFINE_HANDLE(XrSpatialGraphNodeBindingMSFT) XR_DEFINE_HANDLE(XrSpatialPersistenceContextEXT) XR_DEFINE_HANDLE(XrSpatialSnapshotEXT) XR_DEFINE_HANDLE(XrSwapchain) +XR_DEFINE_HANDLE(XrTrackableImageDatabaseANDROID) XR_DEFINE_HANDLE(XrTrackableTrackerANDROID) XR_DEFINE_HANDLE(XrTriangleMeshFB) XR_DEFINE_HANDLE(XrVirtualKeyboardMETA) @@ -696,6 +762,7 @@ typedef uint64_t XrTrackableANDROID; typedef uint64_t XrVersion; typedef XrFlags64 XrAndroidSurfaceSwapchainFlagsFB; +typedef XrFlags64 XrBatteryStateDisplayStateFlagsEXT; typedef XrFlags64 XrCompositionLayerFlags; typedef XrFlags64 XrCompositionLayerImageLayoutFlagsFB; typedef XrFlags64 XrCompositionLayerSecureContentFlagsFB; @@ -726,12 +793,16 @@ typedef XrFlags64 XrPassthroughCapabilityFlagsFB; typedef XrFlags64 XrPassthroughFlagsFB; typedef XrFlags64 XrPassthroughPreferenceFlagsMETA; typedef XrFlags64 XrPassthroughStateChangedFlagsFB; +typedef XrFlags64 XrPerformanceMetricsCounterFlagsANDROID; typedef XrFlags64 XrPerformanceMetricsCounterFlagsMETA; typedef XrFlags64 XrPlaneDetectionCapabilityFlagsEXT; typedef XrFlags64 XrPlaneDetectorFlagsEXT; typedef XrFlags64 XrRenderModelFlagsFB; typedef XrFlags64 XrSemanticLabelsSupportFlagsFB; typedef XrFlags64 XrSessionCreateFlags; +typedef XrFlags64 XrSoundFieldFlagsBD; +typedef XrFlags64 XrSoundObjectFlagsBD; +typedef XrFlags64 XrSoundObstacleFlagsBD; typedef XrFlags64 XrSpaceLocationFlags; typedef XrFlags64 XrSpaceVelocityFlags; typedef XrFlags64 XrSpatialMeshConfigFlagsBD; @@ -764,6 +835,38 @@ typedef enum XrAnchorPersistStateANDROID XR_ANCHOR_PERSIST_STATE_ANDROID_MAX_ENUM = 0x7fffffff, } XrAnchorPersistStateANDROID; +typedef enum XrAudioBufferChannelLayoutBD +{ + XR_AUDIO_BUFFER_CHANNEL_LAYOUT_INTERLEAVED_BD = 0, + XR_AUDIO_BUFFER_CHANNEL_LAYOUT_PLANAR_BD = 1, + XR_AUDIO_BUFFER_CHANNEL_LAYOUT_BD_MAX_ENUM = 0x7fffffff, +} XrAudioBufferChannelLayoutBD; + +typedef enum XrAudioSampleRateBD +{ + XR_AUDIO_SAMPLE_RATE_192000_HZ_BD = 1, + XR_AUDIO_SAMPLE_RATE_96000_HZ_BD = 2, + XR_AUDIO_SAMPLE_RATE_48000_HZ_BD = 3, + XR_AUDIO_SAMPLE_RATE_44100_HZ_BD = 4, + XR_AUDIO_SAMPLE_RATE_32000_HZ_BD = 5, + XR_AUDIO_SAMPLE_RATE_24000_HZ_BD = 6, + XR_AUDIO_SAMPLE_RATE_22050_HZ_BD = 7, + XR_AUDIO_SAMPLE_RATE_16000_HZ_BD = 8, + XR_AUDIO_SAMPLE_RATE_12000_HZ_BD = 9, + XR_AUDIO_SAMPLE_RATE_11025_HZ_BD = 10, + XR_AUDIO_SAMPLE_RATE_8000_HZ_BD = 11, + XR_AUDIO_SAMPLE_RATE_BD_MAX_ENUM = 0x7fffffff, +} XrAudioSampleRateBD; + +typedef enum XrBatteryStateDisplayStateFlagBitsEXT +{ + XR_BATTERY_STATE_DISPLAY_STATE_VALID_BIT_EXT = 0x00000001, + XR_BATTERY_STATE_DISPLAY_STATE_CHARGING_BIT_EXT = 0x00000002, + XR_BATTERY_STATE_DISPLAY_STATE_PLUGGED_IN_BIT_EXT = 0x00000004, + XR_BATTERY_STATE_DISPLAY_STATE_NO_BATTERY_BIT_EXT = 0x00000008, + XR_BATTERY_STATE_DISPLAY_STATE_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff, +} XrBatteryStateDisplayStateFlagBitsEXT; + typedef enum XrBlendFactorFB { XR_BLEND_FACTOR_ZERO_FB = 0, @@ -948,6 +1051,13 @@ typedef enum XrBodyTrackingCalibrationStateMETA XR_BODY_TRACKING_CALIBRATION_STATE_META_MAX_ENUM = 0x7fffffff, } XrBodyTrackingCalibrationStateMETA; +typedef enum XrBodyTrackingFidelityMETA +{ + XR_BODY_TRACKING_FIDELITY_LOW_META = 1, + XR_BODY_TRACKING_FIDELITY_HIGH_META = 2, + XR_BODY_TRACKING_FIDELITY_META_MAX_ENUM = 0x7fffffff, +} XrBodyTrackingFidelityMETA; + typedef enum XrColorSpaceFB { XR_COLOR_SPACE_UNMANAGED_FB = 0, @@ -1007,6 +1117,17 @@ typedef enum XrEnvironmentDepthSwapchainCreateFlagBitsMETA XR_ENVIRONMENT_DEPTH_SWAPCHAIN_CREATE_FLAG_BITS_META_MAX_ENUM = 0x7fffffff, } XrEnvironmentDepthSwapchainCreateFlagBitsMETA; +typedef enum XrEnvironmentRaycastHitStatusMETA +{ + XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_META = 1, + XR_ENVIRONMENT_RAYCAST_HIT_STATUS_NO_HIT_META = 2, + XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_POINT_OCCLUDED_META = 3, + XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_POINT_OUTSIDE_OF_FOV_META = 4, + XR_ENVIRONMENT_RAYCAST_HIT_STATUS_RAY_OCCLUDED_META = 5, + XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_INVALID_ORIENTATION_META = 6, + XR_ENVIRONMENT_RAYCAST_HIT_STATUS_META_MAX_ENUM = 0x7fffffff, +} XrEnvironmentRaycastHitStatusMETA; + typedef enum XrExternalCameraAttachedToDeviceOCULUS { XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_NONE_OCULUS = 0, @@ -1086,6 +1207,14 @@ typedef enum XrFaceConfidenceFB XR_FACE_CONFIDENCE_FB_MAX_ENUM = 0x7fffffff, } XrFaceConfidenceFB; +typedef enum XrFaceConfidenceRegionsANDROID +{ + XR_FACE_CONFIDENCE_REGIONS_LOWER_ANDROID = 0, + XR_FACE_CONFIDENCE_REGIONS_LEFT_UPPER_ANDROID = 1, + XR_FACE_CONFIDENCE_REGIONS_RIGHT_UPPER_ANDROID = 2, + XR_FACE_CONFIDENCE_REGIONS_ANDROID_MAX_ENUM = 0x7fffffff, +} XrFaceConfidenceRegionsANDROID; + typedef enum XrFaceExpression2FB { XR_FACE_EXPRESSION2_BROW_LOWERER_L_FB = 0, @@ -1162,6 +1291,63 @@ typedef enum XrFaceExpression2FB XR_FACE_EXPRESSION_2FB_MAX_ENUM = 0x7fffffff, } XrFaceExpression2FB; +typedef enum XrFaceExpressionBD +{ + XR_FACE_EXPRESSION_BROW_DROP_L_BD = 0, + XR_FACE_EXPRESSION_BROW_DROP_R_BD = 1, + XR_FACE_EXPRESSION_BROW_INNER_UPWARDS_BD = 2, + XR_FACE_EXPRESSION_BROW_OUTER_UPWARDS_L_BD = 3, + XR_FACE_EXPRESSION_BROW_OUTER_UPWARDS_R_BD = 4, + XR_FACE_EXPRESSION_EYE_BLINK_L_BD = 5, + XR_FACE_EXPRESSION_EYE_LOOK_DROP_L_BD = 6, + XR_FACE_EXPRESSION_EYE_LOOK_IN_L_BD = 7, + XR_FACE_EXPRESSION_EYE_LOOK_OUT_L_BD = 8, + XR_FACE_EXPRESSION_EYE_LOOK_UPWARDS_L_BD = 9, + XR_FACE_EXPRESSION_EYE_LOOK_SQUINT_L_BD = 10, + XR_FACE_EXPRESSION_EYE_LOOK_WIDE_L_BD = 11, + XR_FACE_EXPRESSION_EYE_BLINK_R_BD = 12, + XR_FACE_EXPRESSION_EYE_LOOK_DROP_R_BD = 13, + XR_FACE_EXPRESSION_EYE_LOOK_IN_R_BD = 14, + XR_FACE_EXPRESSION_EYE_LOOK_OUT_R_BD = 15, + XR_FACE_EXPRESSION_EYE_LOOK_UPWARDS_R_BD = 16, + XR_FACE_EXPRESSION_EYE_LOOK_SQUINT_R_BD = 17, + XR_FACE_EXPRESSION_EYE_LOOK_WIDE_R_BD = 18, + XR_FACE_EXPRESSION_NOSE_SNEER_L_BD = 19, + XR_FACE_EXPRESSION_NOSE_SNEER_R_BD = 20, + XR_FACE_EXPRESSION_CHEEK_PUFF_BD = 21, + XR_FACE_EXPRESSION_CHEEK_SQUINT_L_BD = 22, + XR_FACE_EXPRESSION_CHEEK_SQUINT_R_BD = 23, + XR_FACE_EXPRESSION_MOUTH_CLOSE_BD = 24, + XR_FACE_EXPRESSION_MOUTH_FUNNEL_BD = 25, + XR_FACE_EXPRESSION_MOUTH_PUCKER_BD = 26, + XR_FACE_EXPRESSION_MOUTH_L_BD = 27, + XR_FACE_EXPRESSION_MOUTH_R_BD = 28, + XR_FACE_EXPRESSION_MOUTH_SMILE_L_BD = 29, + XR_FACE_EXPRESSION_MOUTH_SMILE_R_BD = 30, + XR_FACE_EXPRESSION_MOUTH_FROWN_L_BD = 31, + XR_FACE_EXPRESSION_MOUTH_FROWN_R_BD = 32, + XR_FACE_EXPRESSION_MOUTH_DIMPLE_L_BD = 33, + XR_FACE_EXPRESSION_MOUTH_DIMPLE_R_BD = 34, + XR_FACE_EXPRESSION_MOUTH_STRETCH_L_BD = 35, + XR_FACE_EXPRESSION_MOUTH_STRETCH_R_BD = 36, + XR_FACE_EXPRESSION_MOUTH_ROLL_LOWER_BD = 37, + XR_FACE_EXPRESSION_MOUTH_ROLL_UPPER_BD = 38, + XR_FACE_EXPRESSION_MOUTH_SHRUG_LOWER_BD = 39, + XR_FACE_EXPRESSION_MOUTH_SHRUG_UPPER_BD = 40, + XR_FACE_EXPRESSION_MOUTH_PRESS_L_BD = 41, + XR_FACE_EXPRESSION_MOUTH_PRESS_R_BD = 42, + XR_FACE_EXPRESSION_MOUTH_LOWER_DROP_L_BD = 43, + XR_FACE_EXPRESSION_MOUTH_LOWER_DROP_R_BD = 44, + XR_FACE_EXPRESSION_MOUTH_UPPER_UPWARDS_L_BD = 45, + XR_FACE_EXPRESSION_MOUTH_UPPER_UPWARDS_R_BD = 46, + XR_FACE_EXPRESSION_JAW_FORWARD_BD = 47, + XR_FACE_EXPRESSION_JAW_L_BD = 48, + XR_FACE_EXPRESSION_JAW_R_BD = 49, + XR_FACE_EXPRESSION_JAW_OPEN_BD = 50, + XR_FACE_EXPRESSION_TONGUE_OUT_BD = 51, + XR_FACE_EXPRESSION_BD_MAX_ENUM = 0x7fffffff, +} XrFaceExpressionBD; + typedef enum XrFaceExpressionFB { XR_FACE_EXPRESSION_BROW_LOWERER_L_FB = 0, @@ -1243,6 +1429,79 @@ typedef enum XrFaceExpressionSetFB XR_FACE_EXPRESSION_SET_FB_MAX_ENUM = 0x7fffffff, } XrFaceExpressionSetFB; +typedef enum XrFaceParameterIndicesANDROID +{ + XR_FACE_PARAMETER_INDICES_BROW_LOWERER_L_ANDROID = 0, + XR_FACE_PARAMETER_INDICES_BROW_LOWERER_R_ANDROID = 1, + XR_FACE_PARAMETER_INDICES_CHEEK_PUFF_L_ANDROID = 2, + XR_FACE_PARAMETER_INDICES_CHEEK_PUFF_R_ANDROID = 3, + XR_FACE_PARAMETER_INDICES_CHEEK_RAISER_L_ANDROID = 4, + XR_FACE_PARAMETER_INDICES_CHEEK_RAISER_R_ANDROID = 5, + XR_FACE_PARAMETER_INDICES_CHEEK_SUCK_L_ANDROID = 6, + XR_FACE_PARAMETER_INDICES_CHEEK_SUCK_R_ANDROID = 7, + XR_FACE_PARAMETER_INDICES_CHIN_RAISER_B_ANDROID = 8, + XR_FACE_PARAMETER_INDICES_CHIN_RAISER_T_ANDROID = 9, + XR_FACE_PARAMETER_INDICES_DIMPLER_L_ANDROID = 10, + XR_FACE_PARAMETER_INDICES_DIMPLER_R_ANDROID = 11, + XR_FACE_PARAMETER_INDICES_EYES_CLOSED_L_ANDROID = 12, + XR_FACE_PARAMETER_INDICES_EYES_CLOSED_R_ANDROID = 13, + XR_FACE_PARAMETER_INDICES_EYES_LOOK_DOWN_L_ANDROID = 14, + XR_FACE_PARAMETER_INDICES_EYES_LOOK_DOWN_R_ANDROID = 15, + XR_FACE_PARAMETER_INDICES_EYES_LOOK_LEFT_L_ANDROID = 16, + XR_FACE_PARAMETER_INDICES_EYES_LOOK_LEFT_R_ANDROID = 17, + XR_FACE_PARAMETER_INDICES_EYES_LOOK_RIGHT_L_ANDROID = 18, + XR_FACE_PARAMETER_INDICES_EYES_LOOK_RIGHT_R_ANDROID = 19, + XR_FACE_PARAMETER_INDICES_EYES_LOOK_UP_L_ANDROID = 20, + XR_FACE_PARAMETER_INDICES_EYES_LOOK_UP_R_ANDROID = 21, + XR_FACE_PARAMETER_INDICES_INNER_BROW_RAISER_L_ANDROID = 22, + XR_FACE_PARAMETER_INDICES_INNER_BROW_RAISER_R_ANDROID = 23, + XR_FACE_PARAMETER_INDICES_JAW_DROP_ANDROID = 24, + XR_FACE_PARAMETER_INDICES_JAW_SIDEWAYS_LEFT_ANDROID = 25, + XR_FACE_PARAMETER_INDICES_JAW_SIDEWAYS_RIGHT_ANDROID = 26, + XR_FACE_PARAMETER_INDICES_JAW_THRUST_ANDROID = 27, + XR_FACE_PARAMETER_INDICES_LID_TIGHTENER_L_ANDROID = 28, + XR_FACE_PARAMETER_INDICES_LID_TIGHTENER_R_ANDROID = 29, + XR_FACE_PARAMETER_INDICES_LIP_CORNER_DEPRESSOR_L_ANDROID = 30, + XR_FACE_PARAMETER_INDICES_LIP_CORNER_DEPRESSOR_R_ANDROID = 31, + XR_FACE_PARAMETER_INDICES_LIP_CORNER_PULLER_L_ANDROID = 32, + XR_FACE_PARAMETER_INDICES_LIP_CORNER_PULLER_R_ANDROID = 33, + XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_LB_ANDROID = 34, + XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_LT_ANDROID = 35, + XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_RB_ANDROID = 36, + XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_RT_ANDROID = 37, + XR_FACE_PARAMETER_INDICES_LIP_PRESSOR_L_ANDROID = 38, + XR_FACE_PARAMETER_INDICES_LIP_PRESSOR_R_ANDROID = 39, + XR_FACE_PARAMETER_INDICES_LIP_PUCKER_L_ANDROID = 40, + XR_FACE_PARAMETER_INDICES_LIP_PUCKER_R_ANDROID = 41, + XR_FACE_PARAMETER_INDICES_LIP_STRETCHER_L_ANDROID = 42, + XR_FACE_PARAMETER_INDICES_LIP_STRETCHER_R_ANDROID = 43, + XR_FACE_PARAMETER_INDICES_LIP_SUCK_LB_ANDROID = 44, + XR_FACE_PARAMETER_INDICES_LIP_SUCK_LT_ANDROID = 45, + XR_FACE_PARAMETER_INDICES_LIP_SUCK_RB_ANDROID = 46, + XR_FACE_PARAMETER_INDICES_LIP_SUCK_RT_ANDROID = 47, + XR_FACE_PARAMETER_INDICES_LIP_TIGHTENER_L_ANDROID = 48, + XR_FACE_PARAMETER_INDICES_LIP_TIGHTENER_R_ANDROID = 49, + XR_FACE_PARAMETER_INDICES_LIPS_TOWARD_ANDROID = 50, + XR_FACE_PARAMETER_INDICES_LOWER_LIP_DEPRESSOR_L_ANDROID = 51, + XR_FACE_PARAMETER_INDICES_LOWER_LIP_DEPRESSOR_R_ANDROID = 52, + XR_FACE_PARAMETER_INDICES_MOUTH_LEFT_ANDROID = 53, + XR_FACE_PARAMETER_INDICES_MOUTH_RIGHT_ANDROID = 54, + XR_FACE_PARAMETER_INDICES_NOSE_WRINKLER_L_ANDROID = 55, + XR_FACE_PARAMETER_INDICES_NOSE_WRINKLER_R_ANDROID = 56, + XR_FACE_PARAMETER_INDICES_OUTER_BROW_RAISER_L_ANDROID = 57, + XR_FACE_PARAMETER_INDICES_OUTER_BROW_RAISER_R_ANDROID = 58, + XR_FACE_PARAMETER_INDICES_UPPER_LID_RAISER_L_ANDROID = 59, + XR_FACE_PARAMETER_INDICES_UPPER_LID_RAISER_R_ANDROID = 60, + XR_FACE_PARAMETER_INDICES_UPPER_LIP_RAISER_L_ANDROID = 61, + XR_FACE_PARAMETER_INDICES_UPPER_LIP_RAISER_R_ANDROID = 62, + XR_FACE_PARAMETER_INDICES_TONGUE_OUT_ANDROID = 63, + XR_FACE_PARAMETER_INDICES_TONGUE_LEFT_ANDROID = 64, + XR_FACE_PARAMETER_INDICES_TONGUE_RIGHT_ANDROID = 65, + XR_FACE_PARAMETER_INDICES_TONGUE_UP_ANDROID = 66, + XR_FACE_PARAMETER_INDICES_TONGUE_DOWN_ANDROID = 67, + XR_FACE_PARAMETER_INDICES_ANDROID_MAX_ENUM = 0x7fffffff, +} XrFaceParameterIndicesANDROID; + typedef enum XrFaceTrackingDataSource2FB { XR_FACE_TRACKING_DATA_SOURCE2_VISUAL_FB = 0, @@ -1250,6 +1509,14 @@ typedef enum XrFaceTrackingDataSource2FB XR_FACE_TRACKING_DATA_SOURCE_2FB_MAX_ENUM = 0x7fffffff, } XrFaceTrackingDataSource2FB; +typedef enum XrFaceTrackingStateANDROID +{ + XR_FACE_TRACKING_STATE_PAUSED_ANDROID = 0, + XR_FACE_TRACKING_STATE_STOPPED_ANDROID = 1, + XR_FACE_TRACKING_STATE_TRACKING_ANDROID = 2, + XR_FACE_TRACKING_STATE_ANDROID_MAX_ENUM = 0x7fffffff, +} XrFaceTrackingStateANDROID; + typedef enum XrFacialBlendShapeML { XR_FACIAL_BLEND_SHAPE_BROW_LOWERER_L_ML = 0, @@ -1308,6 +1575,15 @@ typedef enum XrFacialExpressionBlendShapePropertiesFlagBitsML XR_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_FLAG_BITS_ML_MAX_ENUM = 0x7fffffff, } XrFacialExpressionBlendShapePropertiesFlagBitsML; +typedef enum XrFacialSimulationModeBD +{ + XR_FACIAL_SIMULATION_MODE_DEFAULT_BD = 0, + XR_FACIAL_SIMULATION_MODE_COMBINED_AUDIO_BD = 1, + XR_FACIAL_SIMULATION_MODE_COMBINED_AUDIO_WITH_LIP_BD = 2, + XR_FACIAL_SIMULATION_MODE_ONLY_AUDIO_WITH_LIP_BD = 3, + XR_FACIAL_SIMULATION_MODE_BD_MAX_ENUM = 0x7fffffff, +} XrFacialSimulationModeBD; + typedef enum XrFacialTrackingTypeHTC { XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC = 1, @@ -1496,6 +1772,15 @@ typedef enum XrHandForearmJointULTRALEAP XR_HAND_FOREARM_JOINT_ULTRALEAP_MAX_ENUM = 0x7fffffff, } XrHandForearmJointULTRALEAP; +typedef enum XrHandGestureTypeQCOM +{ + XR_HAND_GESTURE_TYPE_UNKNOWN_QCOM = -1, + XR_HAND_GESTURE_TYPE_OPEN_HAND_QCOM = 0, + XR_HAND_GESTURE_TYPE_GRAB_QCOM = 2, + XR_HAND_GESTURE_TYPE_PINCH_QCOM = 7, + XR_HAND_GESTURE_TYPE_QCOM_MAX_ENUM = 0x7fffffff, +} XrHandGestureTypeQCOM; + typedef enum XrHandJointEXT { XR_HAND_JOINT_PALM_EXT = 0, @@ -1593,6 +1878,31 @@ typedef enum XrKeyboardTrackingQueryFlagBitsFB XR_KEYBOARD_TRACKING_QUERY_FLAG_BITS_FB_MAX_ENUM = 0x7fffffff, } XrKeyboardTrackingQueryFlagBitsFB; +typedef enum XrLipExpressionBD +{ + XR_LIP_EXPRESSION_PP_BD = 0, + XR_LIP_EXPRESSION_CH_BD = 1, + XR_LIP_EXPRESSION_LO_BD = 2, + XR_LIP_EXPRESSION_O_BD = 3, + XR_LIP_EXPRESSION_I_BD = 4, + XR_LIP_EXPRESSION_LU_BD = 5, + XR_LIP_EXPRESSION_RR_BD = 6, + XR_LIP_EXPRESSION_XX_BD = 7, + XR_LIP_EXPRESSION_LAA_BD = 8, + XR_LIP_EXPRESSION_LI_BD = 9, + XR_LIP_EXPRESSION_FF_BD = 10, + XR_LIP_EXPRESSION_U_BD = 11, + XR_LIP_EXPRESSION_TH_BD = 12, + XR_LIP_EXPRESSION_LKK_BD = 13, + XR_LIP_EXPRESSION_SS_BD = 14, + XR_LIP_EXPRESSION_LE_BD = 15, + XR_LIP_EXPRESSION_DD_BD = 16, + XR_LIP_EXPRESSION_E_BD = 17, + XR_LIP_EXPRESSION_LNN_BD = 18, + XR_LIP_EXPRESSION_SIL_BD = 19, + XR_LIP_EXPRESSION_BD_MAX_ENUM = 0x7fffffff, +} XrLipExpressionBD; + typedef enum XrLipExpressionHTC { XR_LIP_EXPRESSION_JAW_RIGHT_HTC = 0, @@ -1851,14 +2161,26 @@ typedef enum XrObjectType XR_OBJECT_TYPE_PASSTHROUGH_HTC = 1000317000, XR_OBJECT_TYPE_BODY_TRACKER_HTC = 1000320000, XR_OBJECT_TYPE_BODY_TRACKER_BD = 1000385000, + XR_OBJECT_TYPE_FACE_TRACKER_BD = 1000386000, 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_SPATIAL_AUDIO_RENDERER_BD = 1000409000, + XR_OBJECT_TYPE_SOUND_FIELD_BD = 1000409001, + XR_OBJECT_TYPE_SOUND_OBJECT_BD = 1000409002, + XR_OBJECT_TYPE_SOUND_OBSTACLE_BD = 1000409003, + XR_OBJECT_TYPE_SOUND_OBSTACLE_MATERIAL_BD = 1000409004, XR_OBJECT_TYPE_PLANE_DETECTOR_EXT = 1000429000, XR_OBJECT_TYPE_TRACKABLE_TRACKER_ANDROID = 1000455001, XR_OBJECT_TYPE_DEVICE_ANCHOR_PERSISTENCE_ANDROID = 1000457000, + XR_OBJECT_TYPE_FACE_TRACKER_ANDROID = 1000458000, + XR_OBJECT_TYPE_PASSTHROUGH_LAYER_ANDROID = 1000462000, XR_OBJECT_TYPE_WORLD_MESH_DETECTOR_ML = 1000474000, XR_OBJECT_TYPE_FACIAL_EXPRESSION_CLIENT_ML = 1000482000, + XR_OBJECT_TYPE_ENVIRONMENT_RAYCASTER_META = 1000592000, + XR_OBJECT_TYPE_TRACKABLE_IMAGE_DATABASE_ANDROID = 1000709000, + XR_OBJECT_TYPE_SCENE_MESHING_TRACKER_ANDROID = 1000718000, + XR_OBJECT_TYPE_SCENE_MESH_SNAPSHOT_ANDROID = 1000718001, XR_OBJECT_TYPE_SPATIAL_ENTITY_EXT = 1000740000, XR_OBJECT_TYPE_SPATIAL_CONTEXT_EXT = 1000740001, XR_OBJECT_TYPE_SPATIAL_SNAPSHOT_EXT = 1000740002, @@ -1943,6 +2265,14 @@ typedef enum XrPerfSettingsSubDomainEXT XR_PERF_SETTINGS_SUB_DOMAIN_EXT_MAX_ENUM = 0x7fffffff, } XrPerfSettingsSubDomainEXT; +typedef enum XrPerformanceMetricsCounterFlagBitsANDROID +{ + XR_PERFORMANCE_METRICS_COUNTER_ANY_VALUE_VALID_BIT_ANDROID = 0x00000001, + XR_PERFORMANCE_METRICS_COUNTER_UINT_VALUE_VALID_BIT_ANDROID = 0x00000002, + XR_PERFORMANCE_METRICS_COUNTER_FLOAT_VALUE_VALID_BIT_ANDROID = 0x00000004, + XR_PERFORMANCE_METRICS_COUNTER_FLAG_BITS_ANDROID_MAX_ENUM = 0x7fffffff, +} XrPerformanceMetricsCounterFlagBitsANDROID; + typedef enum XrPerformanceMetricsCounterFlagBitsMETA { XR_PERFORMANCE_METRICS_COUNTER_ANY_VALUE_VALID_BIT_META = 0x00000001, @@ -1951,6 +2281,16 @@ typedef enum XrPerformanceMetricsCounterFlagBitsMETA XR_PERFORMANCE_METRICS_COUNTER_FLAG_BITS_META_MAX_ENUM = 0x7fffffff, } XrPerformanceMetricsCounterFlagBitsMETA; +typedef enum XrPerformanceMetricsCounterUnitANDROID +{ + XR_PERFORMANCE_METRICS_COUNTER_UNIT_GENERIC_ANDROID = 0, + XR_PERFORMANCE_METRICS_COUNTER_UNIT_PERCENTAGE_ANDROID = 1, + XR_PERFORMANCE_METRICS_COUNTER_UNIT_MILLISECONDS_ANDROID = 2, + XR_PERFORMANCE_METRICS_COUNTER_UNIT_BYTES_ANDROID = 3, + XR_PERFORMANCE_METRICS_COUNTER_UNIT_HERTZ_ANDROID = 4, + XR_PERFORMANCE_METRICS_COUNTER_UNIT_ANDROID_MAX_ENUM = 0x7fffffff, +} XrPerformanceMetricsCounterUnitANDROID; + typedef enum XrPerformanceMetricsCounterUnitMETA { XR_PERFORMANCE_METRICS_COUNTER_UNIT_GENERIC_META = 0, @@ -2030,6 +2370,13 @@ typedef enum XrPlaneTypeANDROID XR_PLANE_TYPE_ANDROID_MAX_ENUM = 0x7fffffff, } XrPlaneTypeANDROID; +typedef enum XrQrCodeTrackingModeANDROID +{ + XR_QR_CODE_TRACKING_MODE_DYNAMIC_ANDROID = 0, + XR_QR_CODE_TRACKING_MODE_STATIC_ANDROID = 1, + XR_QR_CODE_TRACKING_MODE_ANDROID_MAX_ENUM = 0x7fffffff, +} XrQrCodeTrackingModeANDROID; + typedef enum XrReferenceSpaceType { XR_REFERENCE_SPACE_TYPE_VIEW = 1, @@ -2039,6 +2386,7 @@ typedef enum XrReferenceSpaceType XR_REFERENCE_SPACE_TYPE_COMBINED_EYE_VARJO = 1000121000, XR_REFERENCE_SPACE_TYPE_LOCALIZATION_MAP_ML = 1000139000, XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR = 1000426000, + XR_REFERENCE_SPACE_TYPE_UNBOUNDED_ANDROID = 1000467000, XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR_EXT = XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR, XR_REFERENCE_SPACE_TYPE_MAX_ENUM = 0x7fffffff, } XrReferenceSpaceType; @@ -2061,6 +2409,8 @@ typedef enum XrReprojectionModeMSFT typedef enum XrResult { + XR_ERROR_SPATIAL_ANCHOR_ENTITY_ID_INVALID_ANDROID = -1000795001, + XR_ERROR_SPATIAL_ANCHOR_ATTACHABLE_COMPONENT_NOT_FOUND_ANDROID = -1000790001, XR_ERROR_SPATIAL_PERSISTENCE_SCOPE_INCOMPATIBLE_EXT = -1000781001, XR_ERROR_SPATIAL_PERSISTENCE_SCOPE_UNSUPPORTED_EXT = -1000763001, XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT = -1000740006, @@ -2071,6 +2421,7 @@ typedef enum XrResult XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT = -1000740001, XR_ERROR_EXTENSION_DEPENDENCY_NOT_ENABLED = -1000710001, XR_ERROR_PERMISSION_INSUFFICIENT = -1000710000, + XR_ERROR_IMAGE_FORMAT_UNSUPPORTED_ANDROID = -1000709000, 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, @@ -2080,6 +2431,8 @@ typedef enum XrResult XR_ERROR_SYSTEM_NOTIFICATION_PERMISSION_DENIED_ML = -1000473000, XR_ERROR_FUTURE_INVALID_EXT = -1000469002, XR_ERROR_FUTURE_PENDING_EXT = -1000469001, + XR_ERROR_MESH_DATA_LIMIT_EXCEEDED_ANDROID = -1000462000, + XR_ERROR_SERVICE_NOT_READY_ANDROID = -1000458000, XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID = -1000457003, XR_ERROR_ANCHOR_NOT_TRACKING_ANDROID = -1000457002, XR_ERROR_ANCHOR_ALREADY_PERSISTED_ANDROID = -1000457001, @@ -2280,6 +2633,32 @@ typedef enum XrSceneMarkerTypeMSFT XR_SCENE_MARKER_TYPE_MSFT_MAX_ENUM = 0x7fffffff, } XrSceneMarkerTypeMSFT; +typedef enum XrSceneMeshSemanticLabelANDROID +{ + XR_SCENE_MESH_SEMANTIC_LABEL_OTHER_ANDROID = 0, + XR_SCENE_MESH_SEMANTIC_LABEL_FLOOR_ANDROID = 1, + XR_SCENE_MESH_SEMANTIC_LABEL_CEILING_ANDROID = 2, + XR_SCENE_MESH_SEMANTIC_LABEL_WALL_ANDROID = 3, + XR_SCENE_MESH_SEMANTIC_LABEL_TABLE_ANDROID = 4, + XR_SCENE_MESH_SEMANTIC_LABEL_ANDROID_MAX_ENUM = 0x7fffffff, +} XrSceneMeshSemanticLabelANDROID; + +typedef enum XrSceneMeshSemanticLabelSetANDROID +{ + XR_SCENE_MESH_SEMANTIC_LABEL_SET_NONE_ANDROID = 0, + XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT_ANDROID = 1, + XR_SCENE_MESH_SEMANTIC_LABEL_SET_ANDROID_MAX_ENUM = 0x7fffffff, +} XrSceneMeshSemanticLabelSetANDROID; + +typedef enum XrSceneMeshTrackingStateANDROID +{ + XR_SCENE_MESH_TRACKING_STATE_INITIALIZING_ANDROID = 0, + XR_SCENE_MESH_TRACKING_STATE_TRACKING_ANDROID = 1, + XR_SCENE_MESH_TRACKING_STATE_WAITING_ANDROID = 2, + XR_SCENE_MESH_TRACKING_STATE_ERROR_ANDROID = 3, + XR_SCENE_MESH_TRACKING_STATE_ANDROID_MAX_ENUM = 0x7fffffff, +} XrSceneMeshTrackingStateANDROID; + typedef enum XrSceneObjectTypeMSFT { XR_SCENE_OBJECT_TYPE_UNCATEGORIZED_MSFT = -1, @@ -2330,6 +2709,19 @@ typedef enum XrSemanticLabelBD XR_SEMANTIC_LABEL_BD_MAX_ENUM = 0x7fffffff, } XrSemanticLabelBD; +typedef enum XrSemanticLabelMETA +{ + XR_SEMANTIC_LABEL_UNKNOWN_META = 0, + XR_SEMANTIC_LABEL_FLOOR_META = 1, + XR_SEMANTIC_LABEL_CEILING_META = 2, + XR_SEMANTIC_LABEL_WALL_FACE_META = 3, + XR_SEMANTIC_LABEL_INNER_WALL_FACE_META = 4, + XR_SEMANTIC_LABEL_INVISIBLE_WALL_FACE_META = 5, + XR_SEMANTIC_LABEL_DOOR_FRAME_META = 6, + XR_SEMANTIC_LABEL_WINDOW_FRAME_META = 7, + XR_SEMANTIC_LABEL_META_MAX_ENUM = 0x7fffffff, +} XrSemanticLabelMETA; + typedef enum XrSemanticLabelsSupportFlagBitsFB { XR_SEMANTIC_LABELS_SUPPORT_MULTIPLE_SEMANTIC_LABELS_BIT_FB = 0x00000001, @@ -2374,6 +2766,138 @@ typedef enum XrSessionState XR_SESSION_STATE_MAX_ENUM = 0x7fffffff, } XrSessionState; +typedef enum XrSoundFieldChannelMaskAmbixBD +{ + XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_1ST_ORDER_BD = 1, + XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_2ND_ORDER_BD = 2, + XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_3RD_ORDER_BD = 3, + XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_4TH_ORDER_BD = 4, + XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_5TH_ORDER_BD = 5, + XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_6TH_ORDER_BD = 6, + XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_7TH_ORDER_BD = 7, + XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_BD_MAX_ENUM = 0x7fffffff, +} XrSoundFieldChannelMaskAmbixBD; + +typedef enum XrSoundFieldChannelMaskFumaBD +{ + XR_SOUND_FIELD_CHANNEL_MASK_FUMA_1ST_ORDER_BD = 1, + XR_SOUND_FIELD_CHANNEL_MASK_FUMA_BD_MAX_ENUM = 0x7fffffff, +} XrSoundFieldChannelMaskFumaBD; + +typedef enum XrSoundFieldChannelMaskSurroundBD +{ + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_LEFT_BD = 1, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_RIGHT_BD = 2, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_STEREO_BD = 3, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_CENTER_BD = 4, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_3_0_BD = 7, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_LOW_FREQUENCY_BD = 8, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_2_1_BD = 11, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_3_1_BD = 15, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_LEFT_BD = 16, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_RIGHT_BD = 32, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_BACK_SURROUND_BD = 48, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_QUAD_BD = 51, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_0_BD = 55, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_BD = 63, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SIDE_LEFT_BD = 64, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SIDE_RIGHT_BD = 128, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_SIDE_SURROUND_BD = 192, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_0_SIDE_BD = 199, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_SIDE_BD = 207, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_0_BD = 247, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_BD = 255, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_LEFT_BD = 256, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_RIGHT_BD = 512, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_2_BD = 831, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_BACK_LEFT_BD = 1024, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_BACK_RIGHT_BD = 2048, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_4_BD = 3903, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_4_BD = 4095, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_CENTER_BD = 4096, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_4_0_BD = 4099, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_SIDE_LEFT_BD = 8192, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_SIDE_RIGHT_BD = 16384, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_2_BD = 24831, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BD_MAX_ENUM = 0x7fffffff, +} XrSoundFieldChannelMaskSurroundBD; + +typedef enum XrSoundFieldFlagBitsBD +{ + XR_SOUND_FIELD_ENABLED_BIT_BD = 0x00000001, + XR_SOUND_FIELD_ORIENTATION_BIT_BD = 0x00000002, + XR_SOUND_FIELD_MAIN_VOLUME_BIT_BD = 0x00000004, + XR_SOUND_FIELD_LFE_GAIN_BIT_BD = 0x00000008, + XR_SOUND_FIELD_FLAG_BITS_BD_MAX_ENUM = 0x7fffffff, +} XrSoundFieldFlagBitsBD; + +typedef enum XrSoundObjectDistanceAttenuationTypeBD +{ + XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_NONE_BD = 0, + XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_INVERSE_SQUARE_BD = 1, + XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_ROLLOFF_BD = 2, + XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_CUSTOMIZED_BD = 100, + XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_BD_MAX_ENUM = 0x7fffffff, +} XrSoundObjectDistanceAttenuationTypeBD; + +typedef enum XrSoundObjectFlagBitsBD +{ + XR_SOUND_OBJECT_ENABLED_BIT_BD = 0x00000001, + XR_SOUND_OBJECT_POSE_BIT_BD = 0x00000002, + XR_SOUND_OBJECT_DIRECTIVITY_BIT_BD = 0x00000004, + XR_SOUND_OBJECT_SHAPE_BIT_BD = 0x00000008, + XR_SOUND_OBJECT_MAIN_VOLUME_BIT_BD = 0x00000010, + XR_SOUND_OBJECT_REFLECTION_GAIN_BIT_BD = 0x00000020, + XR_SOUND_OBJECT_ENABLE_DOPPLER_BIT_BD = 0x00000040, + XR_SOUND_OBJECT_DIRECT_SOUND_ATTENUATION_BIT_BD = 0x00000080, + XR_SOUND_OBJECT_INDIRECT_SOUND_ATTENUATION_BIT_BD = 0x00000100, + XR_SOUND_OBJECT_FLAG_BITS_BD_MAX_ENUM = 0x7fffffff, +} XrSoundObjectFlagBitsBD; + +typedef enum XrSoundObstacleFlagBitsBD +{ + XR_SOUND_OBSTACLE_ENABLED_BIT_BD = 0x00000001, + XR_SOUND_OBSTACLE_POSE_BIT_BD = 0x00000002, + XR_SOUND_OBSTACLE_MESH_BIT_BD = 0x00000004, + XR_SOUND_OBSTACLE_MATERIALS_BIT_BD = 0x00000008, + XR_SOUND_OBSTACLE_FLAG_BITS_BD_MAX_ENUM = 0x7fffffff, +} XrSoundObstacleFlagBitsBD; + +typedef enum XrSoundObstacleMaterialTypeBD +{ + XR_SOUND_OBSTACLE_MATERIAL_TYPE_ACOUSTIC_TILE_BD = 0, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_BRICK_BD = 1, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_BRICK_PAINTED_BD = 2, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_CARPET_BD = 3, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_CARPET_HEAVY_BD = 4, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_CARPET_HEAVY_PADDED_BD = 5, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_CERAMIC_TILE_BD = 6, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_BD = 7, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_ROUGH_BD = 8, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_BLOCK_BD = 9, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_BLOCK_PAINTED_BD = 10, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_CURTAIN_BD = 11, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_FOLIAGE_BD = 12, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_GLASS_BD = 13, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_GLASS_HEAVY_BD = 14, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_GRASS_BD = 15, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_GRAVEL_BD = 16, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_GYPSUM_BOARD_BD = 17, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_PLASTER_ON_BRICK_BD = 18, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_PLASTER_ON_CONCRETE_BLOCK_BD = 19, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_SOIL_BD = 20, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_SOUND_PROOF_BD = 21, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_SNOW_BD = 22, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_STEEL_BD = 23, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_WATER_BD = 24, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_THIN_BD = 25, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_THICK_BD = 26, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_FLOOR_BD = 27, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_ON_CONCRETE_BD = 28, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_CUSTOM_BD = 29, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_BD_MAX_ENUM = 0x7fffffff, +} XrSoundObstacleMaterialTypeBD; + typedef enum XrSpaceComponentTypeFB { XR_SPACE_COMPONENT_TYPE_LOCATABLE_FB = 0, @@ -2454,6 +2978,8 @@ typedef enum XrSpatialCapabilityEXT XR_SPATIAL_CAPABILITY_MARKER_TRACKING_ARUCO_MARKER_EXT = 1000743002, XR_SPATIAL_CAPABILITY_MARKER_TRACKING_APRIL_TAG_EXT = 1000743003, XR_SPATIAL_CAPABILITY_ANCHOR_EXT = 1000762000, + XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_ANDROID = 1000785000, + XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID = 1000786000, XR_SPATIAL_CAPABILITY_EXT_MAX_ENUM = 0x7fffffff, } XrSpatialCapabilityEXT; @@ -2477,6 +3003,9 @@ typedef enum XrSpatialComponentTypeEXT XR_SPATIAL_COMPONENT_TYPE_MARKER_EXT = 1000743000, XR_SPATIAL_COMPONENT_TYPE_ANCHOR_EXT = 1000762000, XR_SPATIAL_COMPONENT_TYPE_PERSISTENCE_EXT = 1000763000, + XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_ANDROID = 1000785000, + XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID = 1000786000, + XR_SPATIAL_COMPONENT_TYPE_SUBSUMED_BY_ANDROID = 1000791000, XR_SPATIAL_COMPONENT_TYPE_EXT_MAX_ENUM = 0x7fffffff, } XrSpatialComponentTypeEXT; @@ -2552,6 +3081,15 @@ typedef enum XrSpatialMeshLodBD XR_SPATIAL_MESH_LOD_BD_MAX_ENUM = 0x7fffffff, } XrSpatialMeshLodBD; +typedef enum XrSpatialObjectSemanticLabelANDROID +{ + XR_SPATIAL_OBJECT_SEMANTIC_LABEL_UNCATEGORIZED_ANDROID = 0, + XR_SPATIAL_OBJECT_SEMANTIC_LABEL_KEYBOARD_ANDROID = 1, + XR_SPATIAL_OBJECT_SEMANTIC_LABEL_MOUSE_ANDROID = 2, + XR_SPATIAL_OBJECT_SEMANTIC_LABEL_LAPTOP_BASE_ANDROID = 3, + XR_SPATIAL_OBJECT_SEMANTIC_LABEL_ANDROID_MAX_ENUM = 0x7fffffff, +} XrSpatialObjectSemanticLabelANDROID; + typedef enum XrSpatialPersistenceContextResultEXT { XR_SPATIAL_PERSISTENCE_CONTEXT_RESULT_PERSIST_UUID_NOT_FOUND_EXT = -1000781002, @@ -2925,6 +3463,8 @@ typedef enum XrStructureType XR_TYPE_BODY_TRACKING_CALIBRATION_INFO_META = 1000283002, XR_TYPE_BODY_TRACKING_CALIBRATION_STATUS_META = 1000283003, XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_CALIBRATION_META = 1000283004, + XR_TYPE_BODY_TRACKING_FIDELITY_STATUS_META = 1000284000, + XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_FIDELITY_META = 1000284001, XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES2_FB = 1000287013, XR_TYPE_FACE_TRACKER_CREATE_INFO2_FB = 1000287014, XR_TYPE_FACE_EXPRESSION_INFO2_FB = 1000287015, @@ -2940,6 +3480,7 @@ typedef enum XrStructureType XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_META = 1000291005, XR_TYPE_ENVIRONMENT_DEPTH_HAND_REMOVAL_SET_INFO_META = 1000291006, XR_TYPE_SYSTEM_ENVIRONMENT_DEPTH_PROPERTIES_META = 1000291007, + XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_TIMESTAMP_META = 1000291008, XR_TYPE_RENDER_MODEL_CREATE_INFO_EXT = 1000300000, XR_TYPE_RENDER_MODEL_PROPERTIES_GET_INFO_EXT = 1000300001, XR_TYPE_RENDER_MODEL_PROPERTIES_EXT = 1000300002, @@ -2973,6 +3514,11 @@ typedef enum XrStructureType 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_FACIAL_SIMULATION_PROPERTIES_BD = 1000386001, + XR_TYPE_FACE_TRACKER_CREATE_INFO_BD = 1000386002, + XR_TYPE_FACIAL_SIMULATION_DATA_GET_INFO_BD = 1000386003, + XR_TYPE_FACIAL_SIMULATION_DATA_BD = 1000386004, + XR_TYPE_LIP_EXPRESSION_DATA_BD = 1000386005, 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, @@ -3011,6 +3557,20 @@ typedef enum XrStructureType XR_TYPE_SYSTEM_SPATIAL_PLANE_PROPERTIES_BD = 1000396000, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_PLANE_ORIENTATION_BD = 1000396001, XR_TYPE_SENSE_DATA_FILTER_PLANE_ORIENTATION_BD = 1000396002, + XR_TYPE_SPATIAL_AUDIO_RENDERER_CREATE_INFO_BD = 1000409000, + XR_TYPE_AUDIO_BUFFER_BD = 1000409001, + XR_TYPE_SOUND_OBJECT_DIRECTIVITY_CARDIOID_BD = 1000409003, + XR_TYPE_SOUND_OBJECT_SHAPE_SPHERE_BD = 1000409004, + XR_TYPE_SOUND_OBJECT_DISTANCE_ATTENUATION_BD = 1000409005, + XR_TYPE_SOUND_OBJECT_DISTANCE_ATTENUATION_CURVE_BD = 1000409006, + XR_TYPE_SOUND_OBJECT_CONFIG_BD = 1000409007, + XR_TYPE_SOUND_FIELD_CONFIG_BD = 1000409008, + XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_SURROUND_BD = 1000409009, + XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_AMBIX_BD = 1000409010, + XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_FUMA_BD = 1000409011, + XR_TYPE_SOUND_TRIANGLE_MESH_BD = 1000409012, + XR_TYPE_SOUND_OBSTACLE_CONFIG_BD = 1000409013, + XR_TYPE_SOUND_OBSTACLE_MATERIAL_CONFIG_BD = 1000409014, 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, @@ -3029,10 +3589,20 @@ typedef enum XrStructureType XR_TYPE_PERSISTED_ANCHOR_SPACE_INFO_ANDROID = 1000457002, XR_TYPE_DEVICE_ANCHOR_PERSISTENCE_CREATE_INFO_ANDROID = 1000457003, XR_TYPE_SYSTEM_DEVICE_ANCHOR_PERSISTENCE_PROPERTIES_ANDROID = 1000457004, + XR_TYPE_FACE_TRACKER_CREATE_INFO_ANDROID = 1000458000, + XR_TYPE_FACE_STATE_GET_INFO_ANDROID = 1000458001, + XR_TYPE_FACE_STATE_ANDROID = 1000458002, + XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_ANDROID = 1000458003, XR_TYPE_PASSTHROUGH_CAMERA_STATE_GET_INFO_ANDROID = 1000460000, XR_TYPE_SYSTEM_PASSTHROUGH_CAMERA_STATE_PROPERTIES_ANDROID = 1000460001, + XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_ANDROID = 1000462000, + XR_TYPE_PASSTHROUGH_LAYER_MESH_ANDROID = 1000462001, + XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_ANDROID = 1000462002, + XR_TYPE_SYSTEM_PASSTHROUGH_LAYER_PROPERTIES_ANDROID = 1000462003, XR_TYPE_RAYCAST_INFO_ANDROID = 1000463000, XR_TYPE_RAYCAST_HIT_RESULTS_ANDROID = 1000463001, + XR_TYPE_PERFORMANCE_METRICS_STATE_ANDROID = 1000465000, + XR_TYPE_PERFORMANCE_METRICS_COUNTER_ANDROID = 1000465001, XR_TYPE_TRACKABLE_OBJECT_ANDROID = 1000466000, XR_TYPE_TRACKABLE_OBJECT_CONFIGURATION_ANDROID = 1000466001, XR_TYPE_FUTURE_CANCEL_INFO_EXT = 1000469000, @@ -3082,9 +3652,33 @@ typedef enum XrStructureType 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_SYSTEM_ENVIRONMENT_RAYCAST_PROPERTIES_META = 1000592000, + XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_INFO_META = 1000592001, + XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_COMPLETION_META = 1000592002, + XR_TYPE_ENVIRONMENT_RAYCAST_HIT_GET_INFO_META = 1000592003, + XR_TYPE_ENVIRONMENT_RAYCAST_HIT_META = 1000592004, + XR_TYPE_ENVIRONMENT_RAYCAST_FILTER_DISTANCE_META = 1000592005, + XR_TYPE_TILE_PROPERTIES_META = 1000609000, + XR_TYPE_TILE_PROPERTIES_HINT_META = 1000609001, XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_ANDROID = 1000707000, XR_TYPE_TRACKABLE_MARKER_CONFIGURATION_ANDROID = 1000707001, XR_TYPE_TRACKABLE_MARKER_ANDROID = 1000707002, + XR_TYPE_SYSTEM_QR_CODE_TRACKING_PROPERTIES_ANDROID = 1000708000, + XR_TYPE_TRACKABLE_QR_CODE_CONFIGURATION_ANDROID = 1000708001, + XR_TYPE_TRACKABLE_QR_CODE_ANDROID = 1000708002, + XR_TYPE_SYSTEM_IMAGE_TRACKING_PROPERTIES_ANDROID = 1000709000, + XR_TYPE_TRACKABLE_IMAGE_DATABASE_ENTRY_ANDROID = 1000709001, + XR_TYPE_TRACKABLE_IMAGE_DATABASE_CREATE_INFO_ANDROID = 1000709002, + XR_TYPE_CREATE_TRACKABLE_IMAGE_DATABASE_COMPLETION_ANDROID = 1000709003, + XR_TYPE_TRACKABLE_IMAGE_CONFIGURATION_ANDROID = 1000709004, + XR_TYPE_TRACKABLE_IMAGE_ANDROID = 1000709005, + XR_TYPE_EVENT_DATA_IMAGE_TRACKING_LOST_ANDROID = 1000709006, + XR_TYPE_SYSTEM_SCENE_MESHING_PROPERTIES_ANDROID = 1000718000, + XR_TYPE_SCENE_MESHING_TRACKER_CREATE_INFO_ANDROID = 1000718001, + XR_TYPE_SCENE_MESH_SNAPSHOT_CREATE_INFO_ANDROID = 1000718002, + XR_TYPE_SCENE_MESH_SNAPSHOT_CREATION_RESULT_ANDROID = 1000718003, + XR_TYPE_SCENE_SUBMESH_STATE_ANDROID = 1000718004, + XR_TYPE_SCENE_SUBMESH_DATA_ANDROID = 1000718005, XR_TYPE_SPATIAL_CAPABILITY_COMPONENT_TYPES_EXT = 1000740000, XR_TYPE_SPATIAL_CONTEXT_CREATE_INFO_EXT = 1000740001, XR_TYPE_CREATE_SPATIAL_CONTEXT_COMPLETION_EXT = 1000740002, @@ -3126,7 +3720,19 @@ typedef enum XrStructureType XR_TYPE_PERSIST_SPATIAL_ENTITY_COMPLETION_EXT = 1000781001, XR_TYPE_SPATIAL_ENTITY_UNPERSIST_INFO_EXT = 1000781002, XR_TYPE_UNPERSIST_SPATIAL_ENTITY_COMPLETION_EXT = 1000781003, + XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_OBJECT_TRACKING_ANDROID = 1000785000, + XR_TYPE_SPATIAL_COMPONENT_OBJECT_SEMANTIC_LABEL_LIST_ANDROID = 1000785001, + XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_DEPTH_RAYCAST_ANDROID = 1000786000, + XR_TYPE_SPATIAL_RAYCAST_INFO_ANDROID = 1000786001, + XR_TYPE_SPATIAL_COMPONENT_RAYCAST_RESULT_LIST_ANDROID = 1000786002, + XR_TYPE_SPATIAL_RAYCAST_SNAPSHOT_CREATE_INFO_ANDROID = 1000786003, + XR_TYPE_SPATIAL_ANCHOR_PARENT_ANDROID = 1000790000, + XR_TYPE_SPATIAL_DISCOVERY_UNIQUE_ENTITIES_FILTER_ANDROID = 1000791001, + XR_TYPE_SPATIAL_COMPONENT_SUBSUMED_BY_LIST_ANDROID = 1000791002, + XR_TYPE_SPATIAL_ANCHOR_SPACE_FROM_ID_CREATE_INFO_ANDROID = 1000795000, + XR_TYPE_BATTERY_STATE_DISPLAY_EXT = 1000836000, XR_TYPE_LOADER_INIT_INFO_PROPERTIES_EXT = 1000838000, + XR_TYPE_EVENT_DATA_VIEW_CONFIGURATION_VIEWS_CHANGED_EXT = 1000839000, 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, @@ -3158,6 +3764,19 @@ typedef enum XrSwapchainUsageFlagBits XR_SWAPCHAIN_USAGE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } XrSwapchainUsageFlagBits; +typedef enum XrTrackableImageFormatANDROID +{ + XR_TRACKABLE_IMAGE_FORMAT_R8G8B8A8_ANDROID = 1, + XR_TRACKABLE_IMAGE_FORMAT_ANDROID_MAX_ENUM = 0x7fffffff, +} XrTrackableImageFormatANDROID; + +typedef enum XrTrackableImageTrackingModeANDROID +{ + XR_TRACKABLE_IMAGE_TRACKING_MODE_DYNAMIC_ANDROID = 1, + XR_TRACKABLE_IMAGE_TRACKING_MODE_STATIC_ANDROID = 2, + XR_TRACKABLE_IMAGE_TRACKING_MODE_ANDROID_MAX_ENUM = 0x7fffffff, +} XrTrackableImageTrackingModeANDROID; + typedef enum XrTrackableMarkerDictionaryANDROID { XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_50_ANDROID = 0, @@ -3197,6 +3816,8 @@ typedef enum XrTrackableTypeANDROID XR_TRACKABLE_TYPE_DEPTH_ANDROID = 1000463000, XR_TRACKABLE_TYPE_OBJECT_ANDROID = 1000466000, XR_TRACKABLE_TYPE_MARKER_ANDROID = 1000707000, + XR_TRACKABLE_TYPE_QR_CODE_ANDROID = 1000708000, + XR_TRACKABLE_TYPE_IMAGE_ANDROID = 1000709000, XR_TRACKABLE_TYPE_ANDROID_MAX_ENUM = 0x7fffffff, } XrTrackableTypeANDROID; @@ -3294,6 +3915,14 @@ typedef enum XrVulkanInstanceCreateFlagBitsKHR XR_VULKAN_INSTANCE_CREATE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } XrVulkanInstanceCreateFlagBitsKHR; +typedef enum XrWindingOrderANDROID +{ + XR_WINDING_ORDER_UNKNOWN_ANDROID = 0, + XR_WINDING_ORDER_CW_ANDROID = 1, + XR_WINDING_ORDER_CCW_ANDROID = 2, + XR_WINDING_ORDER_ANDROID_MAX_ENUM = 0x7fffffff, +} XrWindingOrderANDROID; + typedef enum XrWindingOrderFB { XR_WINDING_ORDER_UNKNOWN_FB = 0, @@ -3455,6 +4084,22 @@ typedef struct XrApplicationInfo XrVersion apiVersion; } XrApplicationInfo; +typedef struct XrAttenuationCurvePointBD +{ + float distance; + float gain; +} XrAttenuationCurvePointBD; + +typedef struct XrAudioBufferBD +{ + XrStructureType type; + const void *next; + XrAudioBufferChannelLayoutBD channelLayout; + uint32_t bufferChannels; + uint32_t bufferLength; + float *buffer; +} XrAudioBufferBD; + typedef struct XrBaseInStructure { XrStructureType type; @@ -3467,6 +4112,14 @@ typedef struct XrBaseOutStructure struct XrBaseOutStructure *next; } XrBaseOutStructure; +typedef struct XrBatteryStateDisplayEXT +{ + XrStructureType type; + void *next; + XrBatteryStateDisplayStateFlagsEXT WINE_XR_ALIGN(8) stateFlags; + float batteryLevel; +} XrBatteryStateDisplayEXT; + typedef struct XrBindingModificationBaseHeaderKHR { XrStructureType type; @@ -3540,6 +4193,13 @@ typedef struct XrBodyTrackingCalibrationStatusMETA XrBodyTrackingCalibrationStateMETA status; } XrBodyTrackingCalibrationStatusMETA; +typedef struct XrBodyTrackingFidelityStatusMETA +{ + XrStructureType type; + void *next; + XrBodyTrackingFidelityMETA fidelity; +} XrBodyTrackingFidelityStatusMETA; + typedef struct XrBoundSourcesForActionEnumerateInfo { XrStructureType type; @@ -3735,6 +4395,14 @@ typedef struct XrCreateSpatialPersistenceContextCompletionEXT XrSpatialPersistenceContextEXT persistenceContext; } XrCreateSpatialPersistenceContextCompletionEXT; +typedef struct XrCreateTrackableImageDatabaseCompletionANDROID +{ + XrStructureType type; + void *next; + XrResult futureResult; + XrTrackableImageDatabaseANDROID database; +} XrCreateTrackableImageDatabaseCompletionANDROID; + typedef struct XrDeserializeSceneFragmentMSFT { uint32_t bufferSize; @@ -3778,6 +4446,13 @@ typedef struct XrEnvironmentDepthImageAcquireInfoMETA XrTime displayTime; } XrEnvironmentDepthImageAcquireInfoMETA; +typedef struct XrEnvironmentDepthImageTimestampMETA +{ + XrStructureType type; + const void *next; + XrTime captureTime; +} XrEnvironmentDepthImageTimestampMETA; + typedef struct XrEnvironmentDepthProviderCreateInfoMETA { XrStructureType type; @@ -3800,6 +4475,33 @@ typedef struct XrEnvironmentDepthSwapchainStateMETA uint32_t height; } XrEnvironmentDepthSwapchainStateMETA; +typedef struct XrEnvironmentRaycastFilterBaseHeaderMETA +{ + XrStructureType type; + const void *next; +} XrEnvironmentRaycastFilterBaseHeaderMETA; + +typedef struct XrEnvironmentRaycastFilterDistanceMETA +{ + XrStructureType type; + const void *next; + float maxDistance; +} XrEnvironmentRaycastFilterDistanceMETA; + +typedef struct XrEnvironmentRaycasterCreateCompletionMETA +{ + XrStructureType type; + void *next; + XrResult futureResult; + XrEnvironmentRaycasterMETA environmentRaycaster; +} XrEnvironmentRaycasterCreateCompletionMETA; + +typedef struct XrEnvironmentRaycasterCreateInfoMETA +{ + XrStructureType type; + const void *next; +} XrEnvironmentRaycasterCreateInfoMETA; + typedef struct XrEventDataBaseHeader { XrStructureType type; @@ -3859,6 +4561,13 @@ typedef struct XrEventDataHeadsetFitChangedML XrTime time; } XrEventDataHeadsetFitChangedML; +typedef struct XrEventDataImageTrackingLostANDROID +{ + XrStructureType type; + const void *next; + XrTime time; +} XrEventDataImageTrackingLostANDROID; + typedef struct XrEventDataInstanceLossPending { XrStructureType type; @@ -4062,6 +4771,14 @@ typedef struct XrEventDataUserPresenceChangedEXT XrBool32 isUserPresent; } XrEventDataUserPresenceChangedEXT; +typedef struct XrEventDataViewConfigurationViewsChangedEXT +{ + XrStructureType type; + const void *next; + XrSystemId systemId; + XrViewConfigurationType viewConfigurationType; +} XrEventDataViewConfigurationViewsChangedEXT; + typedef struct XrEventDataVirtualKeyboardBackspaceMETA { XrStructureType type; @@ -4139,6 +4856,13 @@ typedef XrExtent3Df XrExtent3DfKHR; +typedef struct XrExtent3DiMETA +{ + int32_t width; + int32_t height; + int32_t depth; +} XrExtent3DiMETA; + typedef struct XrEyeGazeSampleTimeEXT { XrStructureType type; @@ -4206,6 +4930,28 @@ typedef struct XrFaceExpressionWeightsFB XrTime time; } XrFaceExpressionWeightsFB; +typedef struct XrFaceStateANDROID +{ + XrStructureType type; + void *next; + uint32_t parametersCapacityInput; + uint32_t parametersCountOutput; + float *parameters; + XrFaceTrackingStateANDROID faceTrackingState; + XrTime sampleTime; + XrBool32 isValid; + uint32_t regionConfidencesCapacityInput; + uint32_t regionConfidencesCountOutput; + float *regionConfidences; +} XrFaceStateANDROID; + +typedef struct XrFaceStateGetInfoANDROID +{ + XrStructureType type; + const void *next; + XrTime time; +} XrFaceStateGetInfoANDROID; + typedef struct XrFaceTrackerCreateInfo2FB { XrStructureType type; @@ -4215,6 +4961,19 @@ typedef struct XrFaceTrackerCreateInfo2FB XrFaceTrackingDataSource2FB *requestedDataSources; } XrFaceTrackerCreateInfo2FB; +typedef struct XrFaceTrackerCreateInfoANDROID +{ + XrStructureType type; + const void *next; +} XrFaceTrackerCreateInfoANDROID; + +typedef struct XrFaceTrackerCreateInfoBD +{ + XrStructureType type; + const void *next; + XrFacialSimulationModeBD mode; +} XrFaceTrackerCreateInfoBD; + typedef struct XrFaceTrackerCreateInfoFB { XrStructureType type; @@ -4256,6 +5015,24 @@ typedef struct XrFacialExpressionsHTC float *expressionWeightings; } XrFacialExpressionsHTC; +typedef struct XrFacialSimulationDataBD +{ + XrStructureType type; + void *next; + uint32_t faceExpressionWeightCount; + float *faceExpressionWeights; + XrBool32 isUpperFaceDataValid; + XrBool32 isLowerFaceDataValid; + XrTime time; +} XrFacialSimulationDataBD; + +typedef struct XrFacialSimulationDataGetInfoBD +{ + XrStructureType type; + const void *next; + XrTime time; +} XrFacialSimulationDataGetInfoBD; + typedef struct XrFacialTrackerCreateInfoHTC { XrStructureType type; @@ -4480,6 +5257,13 @@ typedef struct XrGraphicsRequirementsVulkanKHR } XrGraphicsRequirementsVulkanKHR; typedef XrGraphicsRequirementsVulkanKHR XrGraphicsRequirementsVulkan2KHR; +typedef struct XrHandGestureQCOM +{ + XrHandGestureTypeQCOM gesture; + float gestureRatio; + float flipRatio; +} XrHandGestureQCOM; + typedef struct XrHandJointsLocateInfoEXT { XrStructureType type; @@ -4708,6 +5492,14 @@ typedef struct XrKeyboardTrackingQueryFB XrKeyboardTrackingQueryFlagsFB WINE_XR_ALIGN(8) flags; } XrKeyboardTrackingQueryFB; +typedef struct XrLipExpressionDataBD +{ + XrStructureType type; + void *next; + uint32_t lipsyncExpressionWeightCount; + float *lipsyncExpressionWeights; +} XrLipExpressionDataBD; + typedef struct XrLoaderInitPropertyValueEXT { const char *name; @@ -4935,6 +5727,14 @@ typedef struct XrPassthroughKeyboardHandsIntensityFB float rightHandIntensity; } XrPassthroughKeyboardHandsIntensityFB; +typedef struct XrPassthroughLayerCreateInfoANDROID +{ + XrStructureType type; + const void *next; + uint32_t vertexCapacity; + uint32_t indexCapacity; +} XrPassthroughLayerCreateInfoANDROID; + typedef struct XrPassthroughLayerCreateInfoFB { XrStructureType type; @@ -4959,6 +5759,16 @@ typedef struct XrPassthroughStyleFB XrColor4f edgeColor; } XrPassthroughStyleFB; +typedef struct XrPerformanceMetricsCounterANDROID +{ + XrStructureType type; + void *next; + XrPerformanceMetricsCounterFlagsANDROID WINE_XR_ALIGN(8) counterFlags; + XrPerformanceMetricsCounterUnitANDROID counterUnit; + uint32_t uintValue; + float floatValue; +} XrPerformanceMetricsCounterANDROID; + typedef struct XrPerformanceMetricsCounterMETA { XrStructureType type; @@ -4969,6 +5779,13 @@ typedef struct XrPerformanceMetricsCounterMETA float floatValue; } XrPerformanceMetricsCounterMETA; +typedef struct XrPerformanceMetricsStateANDROID +{ + XrStructureType type; + void *next; + XrBool32 enabled; +} XrPerformanceMetricsStateANDROID; + typedef struct XrPerformanceMetricsStateMETA { XrStructureType type; @@ -5260,6 +6077,14 @@ typedef struct XrSceneMeshMSFT XrBool32 supportsIndicesUint16; } XrSceneMeshMSFT; +typedef struct XrSceneMeshSnapshotCreationResultANDROID +{ + XrStructureType type; + const void *next; + XrSceneMeshSnapshotANDROID snapshot; + XrSceneMeshTrackingStateANDROID trackingState; +} XrSceneMeshSnapshotCreationResultANDROID; + typedef struct XrSceneMeshesMSFT { XrStructureType type; @@ -5268,6 +6093,14 @@ typedef struct XrSceneMeshesMSFT XrSceneMeshMSFT *sceneMeshes; } XrSceneMeshesMSFT; +typedef struct XrSceneMeshingTrackerCreateInfoANDROID +{ + XrStructureType type; + const void *next; + XrSceneMeshSemanticLabelSetANDROID semanticLabelSet; + XrBool32 enableNormals; +} XrSceneMeshingTrackerCreateInfoANDROID; + typedef struct XrSceneObjectMSFT { XrSceneObjectTypeMSFT objectType; @@ -5469,6 +6302,73 @@ typedef struct XrSimultaneousHandsAndControllersTrackingResumeInfoMETA const void *next; } XrSimultaneousHandsAndControllersTrackingResumeInfoMETA; +typedef struct XrSoundFieldChannelDefinitionAmbixBD +{ + XrStructureType type; + const void *next; + XrSoundFieldChannelMaskAmbixBD channelMask; +} XrSoundFieldChannelDefinitionAmbixBD; + +typedef struct XrSoundFieldChannelDefinitionFumaBD +{ + XrStructureType type; + const void *next; + XrSoundFieldChannelMaskFumaBD channelMask; +} XrSoundFieldChannelDefinitionFumaBD; + +typedef struct XrSoundFieldChannelDefinitionSurroundBD +{ + XrStructureType type; + const void *next; + XrSoundFieldChannelMaskSurroundBD channelMask; +} XrSoundFieldChannelDefinitionSurroundBD; + +typedef struct XrSoundFieldConfigBD +{ + XrStructureType type; + const void *next; + XrBool32 enabled; + XrQuaternionf orientation; + XrSpace baseSpace; + float mainVolume; + float lfeGain; +} XrSoundFieldConfigBD; + +typedef struct XrSoundObjectDirectivityCardioidBD +{ + XrStructureType type; + const void *next; + float alpha; + float order; +} XrSoundObjectDirectivityCardioidBD; + +typedef struct XrSoundObjectDistanceAttenuationCurveBD +{ + XrStructureType type; + const void *next; + uint32_t curvePointCount; + XrAttenuationCurvePointBD *curvePoints; +} XrSoundObjectDistanceAttenuationCurveBD; + +typedef struct XrSoundObjectShapeSphereBD +{ + XrStructureType type; + const void *next; + float radius; +} XrSoundObjectShapeSphereBD; + +typedef struct XrSoundObstacleMaterialConfigBD +{ + XrStructureType type; + const void *next; + XrSoundObstacleMaterialTypeBD materialType; + uint32_t bandCount; + float *bandFrequencies; + float *bandAbsorptions; + float *bandScatterings; + float *bandTransmissions; +} XrSoundObstacleMaterialConfigBD; + typedef struct XrSpaceComponentFilterInfoFB { XrStructureType type; @@ -5609,6 +6509,13 @@ typedef struct XrSpatialAnchorNameHTC char name[XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_HTC]; } XrSpatialAnchorNameHTC; +typedef struct XrSpatialAnchorParentANDROID +{ + XrStructureType type; + const void *next; + XrSpatialEntityIdEXT parentId; +} XrSpatialAnchorParentANDROID; + typedef struct XrSpatialAnchorPersistInfoBD { XrStructureType type; @@ -5629,6 +6536,13 @@ typedef struct XrSpatialAnchorShareInfoBD XrAnchorBD anchor; } XrSpatialAnchorShareInfoBD; +typedef struct XrSpatialAnchorSpaceFromIdCreateInfoANDROID +{ + XrStructureType type; + const void *next; + XrSpatialEntityIdEXT anchorEntityId; +} XrSpatialAnchorSpaceFromIdCreateInfoANDROID; + typedef struct XrSpatialAnchorStateML { XrStructureType type; @@ -5685,6 +6599,14 @@ typedef struct XrSpatialAnchorsUpdateExpirationCompletionML XrResult futureResult; } XrSpatialAnchorsUpdateExpirationCompletionML; +typedef struct XrSpatialAudioRendererCreateInfoBD +{ + XrStructureType type; + const void *next; + uint32_t framesPerBuffer; + XrAudioSampleRateBD sampleRate; +} XrSpatialAudioRendererCreateInfoBD; + typedef struct XrSpatialBufferEXT { XrSpatialBufferIdEXT bufferId; @@ -5745,6 +6667,15 @@ typedef struct XrSpatialCapabilityConfigurationBaseHeaderEXT const XrSpatialComponentTypeEXT *enabledComponents; } XrSpatialCapabilityConfigurationBaseHeaderEXT; +typedef struct XrSpatialCapabilityConfigurationDepthRaycastANDROID +{ + XrStructureType type; + const void *next; + XrSpatialCapabilityEXT capability; + uint32_t enabledComponentCount; + const XrSpatialComponentTypeEXT *enabledComponents; +} XrSpatialCapabilityConfigurationDepthRaycastANDROID; + typedef struct XrSpatialCapabilityConfigurationMicroQrCodeEXT { XrStructureType type; @@ -5754,6 +6685,17 @@ typedef struct XrSpatialCapabilityConfigurationMicroQrCodeEXT const XrSpatialComponentTypeEXT *enabledComponents; } XrSpatialCapabilityConfigurationMicroQrCodeEXT; +typedef struct XrSpatialCapabilityConfigurationObjectTrackingANDROID +{ + XrStructureType type; + const void *next; + XrSpatialCapabilityEXT capability; + uint32_t enabledComponentCount; + const XrSpatialComponentTypeEXT *enabledComponents; + uint32_t activeSemanticLabelCount; + const XrSpatialObjectSemanticLabelANDROID *activeSemanticLabels; +} XrSpatialCapabilityConfigurationObjectTrackingANDROID; + typedef struct XrSpatialCapabilityConfigurationPlaneTrackingEXT { XrStructureType type; @@ -5792,6 +6734,14 @@ typedef struct XrSpatialComponentDataQueryResultEXT XrSpatialEntityTrackingStateEXT *entityStates; } XrSpatialComponentDataQueryResultEXT; +typedef struct XrSpatialComponentObjectSemanticLabelListANDROID +{ + XrStructureType type; + void *next; + uint32_t semanticLabelCount; + XrSpatialObjectSemanticLabelANDROID *semanticLabels; +} XrSpatialComponentObjectSemanticLabelListANDROID; + typedef struct XrSpatialComponentParentListEXT { XrStructureType type; @@ -5816,6 +6766,14 @@ typedef struct XrSpatialComponentPlaneSemanticLabelListEXT XrSpatialPlaneSemanticLabelEXT *semanticLabels; } XrSpatialComponentPlaneSemanticLabelListEXT; +typedef struct XrSpatialComponentSubsumedByListANDROID +{ + XrStructureType type; + void *next; + uint32_t subsumedUniqueIdCount; + XrSpatialEntityIdEXT *subsumedUniqueIds; +} XrSpatialComponentSubsumedByListANDROID; + typedef struct XrSpatialContextCreateInfoEXT { XrStructureType type; @@ -5840,6 +6798,12 @@ typedef struct XrSpatialDiscoverySnapshotCreateInfoEXT const XrSpatialComponentTypeEXT *componentTypes; } XrSpatialDiscoverySnapshotCreateInfoEXT; +typedef struct XrSpatialDiscoveryUniqueEntitiesFilterANDROID +{ + XrStructureType type; + const void *next; +} XrSpatialDiscoveryUniqueEntitiesFilterANDROID; + typedef struct XrSpatialEntityAnchorCreateInfoBD { XrStructureType type; @@ -6140,6 +7104,13 @@ typedef struct XrSystemEnvironmentDepthPropertiesMETA XrBool32 supportsHandRemoval; } XrSystemEnvironmentDepthPropertiesMETA; +typedef struct XrSystemEnvironmentRaycastPropertiesMETA +{ + XrStructureType type; + void *next; + XrBool32 supportsEnvironmentRaycast; +} XrSystemEnvironmentRaycastPropertiesMETA; + typedef struct XrSystemEyeGazeInteractionPropertiesEXT { XrStructureType type; @@ -6162,6 +7133,13 @@ typedef struct XrSystemFaceTrackingProperties2FB XrBool32 supportsAudioFaceTracking; } XrSystemFaceTrackingProperties2FB; +typedef struct XrSystemFaceTrackingPropertiesANDROID +{ + XrStructureType type; + void *next; + XrBool32 supportsFaceTracking; +} XrSystemFaceTrackingPropertiesANDROID; + typedef struct XrSystemFaceTrackingPropertiesFB { XrStructureType type; @@ -6176,6 +7154,13 @@ typedef struct XrSystemFacialExpressionPropertiesML XrBool32 supportsFacialExpression; } XrSystemFacialExpressionPropertiesML; +typedef struct XrSystemFacialSimulationPropertiesBD +{ + XrStructureType type; + void *next; + XrBool32 supportsFaceTracking; +} XrSystemFacialSimulationPropertiesBD; + typedef struct XrSystemFacialTrackingPropertiesHTC { XrStructureType type; @@ -6235,6 +7220,16 @@ typedef struct XrSystemHandTrackingPropertiesEXT XrBool32 supportsHandTracking; } XrSystemHandTrackingPropertiesEXT; +typedef struct XrSystemImageTrackingPropertiesANDROID +{ + XrStructureType type; + void *next; + XrBool32 supportsImageTracking; + XrBool32 supportsPhysicalSizeEstimation; + uint32_t maxTrackedImageCount; + uint32_t maxLoadedImageCount; +} XrSystemImageTrackingPropertiesANDROID; + typedef struct XrSystemKeyboardTrackingPropertiesFB { XrStructureType type; @@ -6286,6 +7281,15 @@ typedef struct XrSystemPassthroughColorLutPropertiesMETA uint32_t maxColorLutResolution; } XrSystemPassthroughColorLutPropertiesMETA; +typedef struct XrSystemPassthroughLayerPropertiesANDROID +{ + XrStructureType type; + void *next; + XrBool32 supportsPassthroughLayer; + uint32_t maxMeshIndexCount; + uint32_t maxMeshVertexCount; +} XrSystemPassthroughLayerPropertiesANDROID; + typedef struct XrSystemPassthroughProperties2FB { XrStructureType type; @@ -6314,6 +7318,13 @@ typedef struct XrSystemPropertiesBodyTrackingCalibrationMETA XrBool32 supportsHeightOverride; } XrSystemPropertiesBodyTrackingCalibrationMETA; +typedef struct XrSystemPropertiesBodyTrackingFidelityMETA +{ + XrStructureType type; + void *next; + XrBool32 supportsBodyTrackingFidelity; +} XrSystemPropertiesBodyTrackingFidelityMETA; + typedef struct XrSystemPropertiesBodyTrackingFullBodyMETA { XrStructureType type; @@ -6321,6 +7332,15 @@ typedef struct XrSystemPropertiesBodyTrackingFullBodyMETA XrBool32 supportsFullBodyTracking; } XrSystemPropertiesBodyTrackingFullBodyMETA; +typedef struct XrSystemQrCodeTrackingPropertiesANDROID +{ + XrStructureType type; + void *next; + XrBool32 supportsQrCodeTracking; + XrBool32 supportsQrCodeSizeEstimation; + uint16_t maxQrCodeCount; +} XrSystemQrCodeTrackingPropertiesANDROID; + typedef struct XrSystemRenderModelPropertiesFB { XrStructureType type; @@ -6328,6 +7348,13 @@ typedef struct XrSystemRenderModelPropertiesFB XrBool32 supportsRenderModelLoading; } XrSystemRenderModelPropertiesFB; +typedef struct XrSystemSceneMeshingPropertiesANDROID +{ + XrStructureType type; + void *next; + XrBool32 supportsSceneMeshing; +} XrSystemSceneMeshingPropertiesANDROID; + typedef struct XrSystemSimultaneousHandsAndControllersPropertiesMETA { XrStructureType type; @@ -6448,6 +7475,15 @@ typedef struct XrSystemVirtualKeyboardPropertiesMETA XrBool32 supportsVirtualKeyboard; } XrSystemVirtualKeyboardPropertiesMETA; +typedef struct XrTilePropertiesMETA +{ + XrStructureType type; + void *next; + XrExtent3DiMETA tileDimensions; + XrExtent2Di apronDimensions; + XrOffset2Di origin; +} XrTilePropertiesMETA; + typedef struct XrTrackableGetInfoANDROID { XrStructureType type; @@ -6457,6 +7493,27 @@ typedef struct XrTrackableGetInfoANDROID XrTime time; } XrTrackableGetInfoANDROID; +typedef struct XrTrackableImageConfigurationANDROID +{ + XrStructureType type; + const void *next; + uint32_t databaseCount; + const XrTrackableImageDatabaseANDROID *databases; +} XrTrackableImageConfigurationANDROID; + +typedef struct XrTrackableImageDatabaseEntryANDROID +{ + XrStructureType type; + const void *next; + XrTrackableImageTrackingModeANDROID trackingMode; + float physicalWidth; + uint32_t imageWidth; + uint32_t imageHeight; + XrTrackableImageFormatANDROID format; + uint32_t bufferSize; + const uint8_t *buffer; +} XrTrackableImageDatabaseEntryANDROID; + typedef struct XrTrackableMarkerDatabaseEntryANDROID { int32_t id; @@ -6471,6 +7528,14 @@ typedef struct XrTrackableObjectConfigurationANDROID const XrObjectLabelANDROID *activeLabels; } XrTrackableObjectConfigurationANDROID; +typedef struct XrTrackableQrCodeConfigurationANDROID +{ + XrStructureType type; + void *next; + XrQrCodeTrackingModeANDROID trackingMode; + float qrCodeEdgeSize; +} XrTrackableQrCodeConfigurationANDROID; + typedef struct XrTrackableTrackerCreateInfoANDROID { XrStructureType type; @@ -6886,6 +7951,18 @@ typedef struct XrCompositionLayerReprojectionPlaneOverrideMSFT XrVector3f velocity; } XrCompositionLayerReprojectionPlaneOverrideMSFT; +typedef struct XrEnvironmentRaycastHitGetInfoMETA +{ + XrStructureType type; + const void *next; + XrSpace baseSpace; + XrTime time; + XrVector3f origin; + XrVector3f direction; + uint32_t filterCount; + const XrEnvironmentRaycastFilterBaseHeaderMETA * const *filters; +} XrEnvironmentRaycastHitGetInfoMETA; + typedef struct XrEventDataColocationDiscoveryResultMETA { XrStructureType type; @@ -7041,6 +8118,17 @@ typedef struct XrPassthroughColorLutCreateInfoMETA XrPassthroughColorLutDataMETA data; } XrPassthroughColorLutCreateInfoMETA; +typedef struct XrPassthroughLayerMeshANDROID +{ + XrStructureType type; + const void *next; + XrWindingOrderANDROID windingOrder; + uint32_t vertexCount; + const XrVector3f *vertices; + uint32_t indexCount; + const uint16_t *indices; +} XrPassthroughLayerMeshANDROID; + typedef struct XrPersistSpatialEntityCompletionEXT { XrStructureType type; @@ -7225,6 +8313,31 @@ typedef struct XrSceneSphereBoundMSFT float radius; } XrSceneSphereBoundMSFT; +typedef struct XrSceneSubmeshDataANDROID +{ + XrStructureType type; + const void *next; + XrUuid submeshId; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrVector3f *vertexPositions; + XrVector3f *vertexNormals; + uint8_t *vertexSemantics; + uint32_t indexCapacityInput; + uint32_t indexCountOutput; + uint32_t *indices; +} XrSceneSubmeshDataANDROID; + +typedef struct XrSceneSubmeshStateANDROID +{ + XrStructureType type; + void *next; + XrUuid submeshId; + XrTime lastUpdatedTime; + XrPosef submeshPoseInBaseSpace; + XrExtent3Df bounds; +} XrSceneSubmeshStateANDROID; + typedef struct XrSecondaryViewConfigurationFrameEndInfoMSFT { XrStructureType type; @@ -7280,6 +8393,39 @@ typedef struct XrSharedSpatialAnchorDownloadInfoBD XrUuidEXT uuid; } XrSharedSpatialAnchorDownloadInfoBD; +typedef struct XrSoundObjectDistanceAttenuationBD +{ + XrStructureType type; + const void *next; + XrSoundObjectDistanceAttenuationTypeBD distanceAttenuationType; + float minAttenuationRange; + float maxAttenuationRange; + float referenceDistance; + float rolloffFactor; + XrSoundObjectDistanceAttenuationCurveBD *customDistanceAttenuationCurve; +} XrSoundObjectDistanceAttenuationBD; + +typedef struct XrSoundObstacleConfigBD +{ + XrStructureType type; + const void *next; + XrBool32 enabled; + XrPosef pose; + XrSpace baseSpace; + uint32_t materialCount; + XrSoundObstacleMaterialBD *materials; +} XrSoundObstacleConfigBD; + +typedef struct XrSoundTriangleMeshBD +{ + XrStructureType type; + const void *next; + uint32_t vertexCount; + XrVector3f *vertices; + uint32_t indexCount; + uint32_t *indices; +} XrSoundTriangleMeshBD; + typedef struct XrSpaceContainerFB { XrStructureType type; @@ -7712,6 +8858,32 @@ typedef struct XrSpatialPolygon2DDataEXT XrSpatialBufferEXT vertexBuffer; } XrSpatialPolygon2DDataEXT; +typedef struct XrSpatialRaycastInfoANDROID +{ + XrStructureType type; + const void *next; + XrSpace space; + XrTime time; + XrVector3f origin; + XrVector3f direction; + float maxDistance; +} XrSpatialRaycastInfoANDROID; + +typedef struct XrSpatialRaycastResultDataANDROID +{ + XrPosef hitPose; + float distanceSquared; +} XrSpatialRaycastResultDataANDROID; + +typedef struct XrSpatialRaycastSnapshotCreateInfoANDROID +{ + XrStructureType type; + const void *next; + uint32_t componentTypeCount; + const XrSpatialComponentTypeEXT *componentTypes; + const XrSpatialRaycastInfoANDROID *raycastInfo; +} XrSpatialRaycastSnapshotCreateInfoANDROID; + typedef struct XrSpheref { XrPosef center; @@ -7737,6 +8909,34 @@ typedef struct XrSystemProperties XrSystemTrackingProperties trackingProperties; } XrSystemProperties; +typedef struct XrTilePropertiesHintMETA +{ + XrStructureType type; + void *next; + uint32_t propertiesCount; + const XrTilePropertiesMETA *properties; +} XrTilePropertiesHintMETA; + +typedef struct XrTrackableImageANDROID +{ + XrStructureType type; + const void *next; + XrTrackingStateANDROID trackingState; + XrTime lastUpdatedTime; + XrTrackableImageDatabaseANDROID database; + uint32_t databaseEntryIndex; + XrPosef centerPose; + XrExtent2Df extents; +} XrTrackableImageANDROID; + +typedef struct XrTrackableImageDatabaseCreateInfoANDROID +{ + XrStructureType type; + const void *next; + uint32_t entryCount; + const XrTrackableImageDatabaseEntryANDROID *entries; +} XrTrackableImageDatabaseCreateInfoANDROID; + typedef struct XrTrackableMarkerANDROID { XrStructureType type; @@ -7783,6 +8983,19 @@ typedef struct XrTrackablePlaneANDROID XrVector2f *vertices; } XrTrackablePlaneANDROID; +typedef struct XrTrackableQrCodeANDROID +{ + XrStructureType type; + void *next; + XrTrackingStateANDROID trackingState; + XrTime lastUpdatedTime; + XrPosef centerPose; + XrExtent2Df extents; + uint32_t bufferCapacityInput; + uint32_t bufferCountOutput; + char *buffer; +} XrTrackableQrCodeANDROID; + typedef struct XrTriangleMeshCreateInfoFB { XrStructureType type; @@ -8003,6 +9216,18 @@ typedef struct XrCompositionLayerEquirectKHR XrVector2f bias; } XrCompositionLayerEquirectKHR; +typedef struct XrCompositionLayerPassthroughANDROID +{ + XrStructureType type; + const void *next; + XrCompositionLayerFlags WINE_XR_ALIGN(8) layerFlags; + XrSpace space; + XrPosef pose; + XrVector3f scale; + float opacity; + XrPassthroughLayerANDROID layer; +} XrCompositionLayerPassthroughANDROID; + typedef struct XrCompositionLayerProjectionView { XrStructureType type; @@ -8062,6 +9287,14 @@ typedef struct XrEnvironmentDepthImageViewMETA XrPosef pose; } XrEnvironmentDepthImageViewMETA; +typedef struct XrEnvironmentRaycastHitMETA +{ + XrStructureType type; + const void *next; + XrEnvironmentRaycastHitStatusMETA status; + XrPosef pose; +} XrEnvironmentRaycastHitMETA; + typedef struct XrEventDataLocalizationChangedML { XrStructureType type; @@ -8325,6 +9558,29 @@ typedef struct XrSceneBoundsMSFT const XrSceneFrustumBoundMSFT *frustums; } XrSceneBoundsMSFT; +typedef struct XrSceneMeshSnapshotCreateInfoANDROID +{ + XrStructureType type; + const void *next; + XrSpace baseSpace; + XrTime time; + XrBoxf boundingBox; +} XrSceneMeshSnapshotCreateInfoANDROID; + +typedef struct XrSoundObjectConfigBD +{ + XrStructureType type; + const void *next; + XrBool32 enabled; + XrPosef pose; + XrSpace baseSpace; + float mainVolume; + float reflectionGain; + XrBool32 enableDoppler; + const XrSoundObjectDistanceAttenuationBD *directSoundAttenuation; + const XrSoundObjectDistanceAttenuationBD *indirectSoundAttenuation; +} XrSoundObjectConfigBD; + typedef struct XrSpaceVelocities { XrStructureType type; @@ -8374,6 +9630,14 @@ typedef struct XrSpatialComponentPolygon2DListEXT XrSpatialPolygon2DDataEXT *polygons; } XrSpatialComponentPolygon2DListEXT; +typedef struct XrSpatialComponentRaycastResultListANDROID +{ + XrStructureType type; + void *next; + uint32_t raycastResultCount; + XrSpatialRaycastResultDataANDROID *raycastResults; +} XrSpatialComponentRaycastResultListANDROID; + typedef struct XrSpatialEntityComponentDataBoundingBox3DBD { XrStructureType type; @@ -8449,6 +9713,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_xrAddTrackableImageDatabaseANDROID)(XrTrackableTrackerANDROID, XrTrackableImageDatabaseANDROID); 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 *); @@ -8476,9 +9741,13 @@ typedef XrResult (XRAPI_PTR *PFN_xrCreateBodyTrackerHTC)(XrSession, const XrBody typedef XrResult (XRAPI_PTR *PFN_xrCreateDeviceAnchorPersistenceANDROID)(XrSession, const XrDeviceAnchorPersistenceCreateInfoANDROID *, XrDeviceAnchorPersistenceANDROID *); 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_xrCreateEnvironmentRaycasterAsyncMETA)(XrSession, const XrEnvironmentRaycasterCreateInfoMETA *, XrFutureEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateEnvironmentRaycasterCompleteMETA)(XrSession, XrFutureEXT, XrEnvironmentRaycasterCreateCompletionMETA *); 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_xrCreateFaceTrackerANDROID)(XrSession, const XrFaceTrackerCreateInfoANDROID *, XrFaceTrackerANDROID *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateFaceTrackerBD)(XrSession, const XrFaceTrackerCreateInfoBD *, XrFaceTrackerBD *); 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 *); @@ -8494,6 +9763,7 @@ typedef XrResult (XRAPI_PTR *PFN_xrCreateMarkerSpaceVARJO)(XrSession, const XrMa typedef XrResult (XRAPI_PTR *PFN_xrCreatePassthroughColorLutMETA)(XrPassthroughFB, const XrPassthroughColorLutCreateInfoMETA *, XrPassthroughColorLutMETA *); typedef XrResult (XRAPI_PTR *PFN_xrCreatePassthroughFB)(XrSession, const XrPassthroughCreateInfoFB *, XrPassthroughFB *); typedef XrResult (XRAPI_PTR *PFN_xrCreatePassthroughHTC)(XrSession, const XrPassthroughCreateInfoHTC *, XrPassthroughHTC *); +typedef XrResult (XRAPI_PTR *PFN_xrCreatePassthroughLayerANDROID)(XrSession, const XrPassthroughLayerCreateInfoANDROID *, XrPassthroughLayerANDROID *); typedef XrResult (XRAPI_PTR *PFN_xrCreatePassthroughLayerFB)(XrSession, const XrPassthroughLayerCreateInfoFB *, XrPassthroughLayerFB *); typedef XrResult (XRAPI_PTR *PFN_xrCreatePersistedAnchorSpaceANDROID)(XrDeviceAnchorPersistenceANDROID, const XrPersistedAnchorSpaceCreateInfoANDROID *, XrSpace *); typedef XrResult (XRAPI_PTR *PFN_xrCreatePlaneDetectorEXT)(XrSession, const XrPlaneDetectorCreateInfoEXT *, XrPlaneDetectorEXT *); @@ -8502,9 +9772,15 @@ typedef XrResult (XRAPI_PTR *PFN_xrCreateRenderModelAssetEXT)(XrSession, const X typedef XrResult (XRAPI_PTR *PFN_xrCreateRenderModelEXT)(XrSession, const XrRenderModelCreateInfoEXT *, XrRenderModelEXT *); typedef XrResult (XRAPI_PTR *PFN_xrCreateRenderModelSpaceEXT)(XrSession, const XrRenderModelSpaceCreateInfoEXT *, XrSpace *); typedef XrResult (XRAPI_PTR *PFN_xrCreateSceneMSFT)(XrSceneObserverMSFT, const XrSceneCreateInfoMSFT *, XrSceneMSFT *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSceneMeshSnapshotANDROID)(XrSceneMeshingTrackerANDROID, const XrSceneMeshSnapshotCreateInfoANDROID *, XrSceneMeshSnapshotCreationResultANDROID *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSceneMeshingTrackerANDROID)(XrSession, const XrSceneMeshingTrackerCreateInfoANDROID *, XrSceneMeshingTrackerANDROID *); 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_xrCreateSoundFieldBD)(XrSpatialAudioRendererBD, const XrSoundFieldConfigBD *, XrSoundFieldBD *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSoundObjectBD)(XrSpatialAudioRendererBD, const XrSoundObjectConfigBD *, XrSoundObjectBD *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSoundObstacleBD)(XrSpatialAudioRendererBD, const XrSoundObstacleConfigBD *, const XrSoundTriangleMeshBD *, XrSoundObstacleBD *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSoundObstacleMaterialBD)(XrSpatialAudioRendererBD, const XrSoundObstacleMaterialConfigBD *, XrSoundObstacleMaterialBD *); 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 *); @@ -8513,11 +9789,14 @@ typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorFB)(XrSession, const XrSpa 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_xrCreateSpatialAnchorSpaceANDROID)(XrSession, XrSpatialContextEXT, const XrSpatialAnchorCreateInfoEXT *, XrSpatialEntityIdEXT *, XrSpace *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorSpaceFromIdANDROID)(XrSession, XrSpatialContextEXT, const XrSpatialAnchorSpaceFromIdCreateInfoANDROID *, XrSpace *); 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_xrCreateSpatialAudioRendererBD)(XrSession, const XrSpatialAudioRendererCreateInfoBD *, XrSpatialAudioRendererBD *); typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialContextAsyncEXT)(XrSession, const XrSpatialContextCreateInfoEXT *, XrFutureEXT *); typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialContextCompleteEXT)(XrSession, XrFutureEXT, XrCreateSpatialContextCompletionEXT *); typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialDiscoverySnapshotAsyncEXT)(XrSpatialContextEXT, const XrSpatialDiscoverySnapshotCreateInfoEXT *, XrFutureEXT *); @@ -8527,8 +9806,11 @@ typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialEntityFromIdEXT)(XrSpatialContex typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialGraphNodeSpaceMSFT)(XrSession, const XrSpatialGraphNodeSpaceCreateInfoMSFT *, XrSpace *); typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialPersistenceContextAsyncEXT)(XrSession, const XrSpatialPersistenceContextCreateInfoEXT *, XrFutureEXT *); typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialPersistenceContextCompleteEXT)(XrSession, XrFutureEXT, XrCreateSpatialPersistenceContextCompletionEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialRaycastSnapshotANDROID)(XrSpatialContextEXT, const XrSpatialRaycastSnapshotCreateInfoANDROID *, XrSpatialSnapshotEXT *); typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialUpdateSnapshotEXT)(XrSpatialContextEXT, const XrSpatialUpdateSnapshotCreateInfoEXT *, XrSpatialSnapshotEXT *); typedef XrResult (XRAPI_PTR *PFN_xrCreateSwapchain)(XrSession, const XrSwapchainCreateInfo *, XrSwapchain *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateTrackableImageDatabaseAsyncANDROID)(XrSession, const XrTrackableImageDatabaseCreateInfoANDROID *, XrFutureEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrCreateTrackableImageDatabaseCompleteANDROID)(XrSession, XrFutureEXT, XrCreateTrackableImageDatabaseCompletionANDROID *); typedef XrResult (XRAPI_PTR *PFN_xrCreateTrackableTrackerANDROID)(XrSession, const XrTrackableTrackerCreateInfoANDROID *, XrTrackableTrackerANDROID *); typedef XrResult (XRAPI_PTR *PFN_xrCreateTriangleMeshFB)(XrSession, const XrTriangleMeshCreateInfoFB *, XrTriangleMeshFB *); typedef XrResult (XRAPI_PTR *PFN_xrCreateVirtualKeyboardMETA)(XrSession, const XrVirtualKeyboardCreateInfoMETA *, XrVirtualKeyboardMETA *); @@ -8548,9 +9830,12 @@ typedef XrResult (XRAPI_PTR *PFN_xrDestroyBodyTrackerHTC)(XrBodyTrackerHTC); typedef XrResult (XRAPI_PTR *PFN_xrDestroyDeviceAnchorPersistenceANDROID)(XrDeviceAnchorPersistenceANDROID); typedef XrResult (XRAPI_PTR *PFN_xrDestroyEnvironmentDepthProviderMETA)(XrEnvironmentDepthProviderMETA); typedef XrResult (XRAPI_PTR *PFN_xrDestroyEnvironmentDepthSwapchainMETA)(XrEnvironmentDepthSwapchainMETA); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyEnvironmentRaycasterMETA)(XrEnvironmentRaycasterMETA); 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_xrDestroyFaceTrackerANDROID)(XrFaceTrackerANDROID); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyFaceTrackerBD)(XrFaceTrackerBD); typedef XrResult (XRAPI_PTR *PFN_xrDestroyFaceTrackerFB)(XrFaceTrackerFB); typedef XrResult (XRAPI_PTR *PFN_xrDestroyFacialExpressionClientML)(XrFacialExpressionClientML); typedef XrResult (XRAPI_PTR *PFN_xrDestroyFacialTrackerHTC)(XrFacialTrackerHTC); @@ -8562,26 +9847,35 @@ typedef XrResult (XRAPI_PTR *PFN_xrDestroyMarkerDetectorML)(XrMarkerDetectorML); typedef XrResult (XRAPI_PTR *PFN_xrDestroyPassthroughColorLutMETA)(XrPassthroughColorLutMETA); typedef XrResult (XRAPI_PTR *PFN_xrDestroyPassthroughFB)(XrPassthroughFB); typedef XrResult (XRAPI_PTR *PFN_xrDestroyPassthroughHTC)(XrPassthroughHTC); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyPassthroughLayerANDROID)(XrPassthroughLayerANDROID); typedef XrResult (XRAPI_PTR *PFN_xrDestroyPassthroughLayerFB)(XrPassthroughLayerFB); typedef XrResult (XRAPI_PTR *PFN_xrDestroyPlaneDetectorEXT)(XrPlaneDetectorEXT); typedef XrResult (XRAPI_PTR *PFN_xrDestroyRenderModelAssetEXT)(XrRenderModelAssetEXT); typedef XrResult (XRAPI_PTR *PFN_xrDestroyRenderModelEXT)(XrRenderModelEXT); typedef XrResult (XRAPI_PTR *PFN_xrDestroySceneMSFT)(XrSceneMSFT); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySceneMeshSnapshotANDROID)(XrSceneMeshSnapshotANDROID); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySceneMeshingTrackerANDROID)(XrSceneMeshingTrackerANDROID); 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_xrDestroySoundFieldBD)(XrSoundFieldBD); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySoundObjectBD)(XrSoundObjectBD); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySoundObstacleBD)(XrSoundObstacleBD); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySoundObstacleMaterialBD)(XrSoundObstacleMaterialBD); 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_xrDestroySpatialAudioRendererBD)(XrSpatialAudioRendererBD); typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialContextEXT)(XrSpatialContextEXT); typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialEntityEXT)(XrSpatialEntityEXT); typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialGraphNodeBindingMSFT)(XrSpatialGraphNodeBindingMSFT); typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialPersistenceContextEXT)(XrSpatialPersistenceContextEXT); typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialSnapshotEXT)(XrSpatialSnapshotEXT); typedef XrResult (XRAPI_PTR *PFN_xrDestroySwapchain)(XrSwapchain); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyTrackableImageDatabaseANDROID)(XrTrackableImageDatabaseANDROID); typedef XrResult (XRAPI_PTR *PFN_xrDestroyTrackableTrackerANDROID)(XrTrackableTrackerANDROID); typedef XrResult (XRAPI_PTR *PFN_xrDestroyTriangleMeshFB)(XrTriangleMeshFB); typedef XrResult (XRAPI_PTR *PFN_xrDestroyVirtualKeyboardMETA)(XrVirtualKeyboardMETA); @@ -8591,6 +9885,7 @@ typedef XrResult (XRAPI_PTR *PFN_xrDownloadSharedSpatialAnchorAsyncBD)(XrSenseDa 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_xrEndAudioPeriodBD)(XrSpatialAudioRendererBD); typedef XrResult (XRAPI_PTR *PFN_xrEndFrame)(XrSession, const XrFrameEndInfo *); typedef XrResult (XRAPI_PTR *PFN_xrEndSession)(XrSession); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateApiLayerProperties)(uint32_t, uint32_t *, XrApiLayerProperties *); @@ -8600,8 +9895,10 @@ typedef XrResult (XRAPI_PTR *PFN_xrEnumerateDisplayRefreshRatesFB)(XrSession, ui typedef XrResult (XRAPI_PTR *PFN_xrEnumerateEnvironmentBlendModes)(XrInstance, XrSystemId, XrViewConfigurationType, uint32_t, uint32_t *, XrEnvironmentBlendMode *); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateEnvironmentDepthSwapchainImagesMETA)(XrEnvironmentDepthSwapchainMETA, uint32_t, uint32_t *, XrSwapchainImageBaseHeader *); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateExternalCamerasOCULUS)(XrSession, uint32_t, uint32_t *, XrExternalCameraOCULUS *); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateFacialSimulationModesBD)(XrSession, uint32_t, uint32_t *, XrFacialSimulationModeBD *); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateInstanceExtensionProperties)(const char *, uint32_t, uint32_t *, XrExtensionProperties *); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateInteractionRenderModelIdsEXT)(XrSession, const XrInteractionRenderModelIdsEnumerateInfoEXT *, uint32_t, uint32_t *, XrRenderModelIdEXT *); +typedef XrResult (XRAPI_PTR *PFN_xrEnumeratePerformanceMetricsCounterPathsANDROID)(XrInstance, uint32_t, uint32_t *, XrPath *); typedef XrResult (XRAPI_PTR *PFN_xrEnumeratePerformanceMetricsCounterPathsMETA)(XrInstance, uint32_t, uint32_t *, XrPath *); typedef XrResult (XRAPI_PTR *PFN_xrEnumeratePersistedAnchorsANDROID)(XrDeviceAnchorPersistenceANDROID, uint32_t, uint32_t *, XrUuidEXT *); typedef XrResult (XRAPI_PTR *PFN_xrEnumeratePersistedSpatialAnchorNamesMSFT)(XrSpatialAnchorStoreConnectionMSFT, uint32_t, uint32_t *, XrSpatialAnchorPersistenceNameMSFT *); @@ -8612,13 +9909,16 @@ typedef XrResult (XRAPI_PTR *PFN_xrEnumerateRenderModelSubactionPathsEXT)(XrRend 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_xrEnumerateSpatialAnchorAttachableComponentsANDROID)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrSpatialComponentTypeEXT *); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpatialCapabilitiesEXT)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrSpatialCapabilityEXT *); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpatialCapabilityComponentTypesEXT)(XrInstance, XrSystemId, XrSpatialCapabilityEXT, XrSpatialCapabilityComponentTypesEXT *); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpatialCapabilityFeaturesEXT)(XrInstance, XrSystemId, XrSpatialCapabilityEXT, uint32_t, uint32_t *, XrSpatialCapabilityFeatureEXT *); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpatialEntityComponentTypesBD)(XrSenseDataSnapshotBD, XrSpatialEntityIdBD, uint32_t, uint32_t *, XrSpatialEntityComponentTypeBD *); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpatialPersistenceScopesEXT)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrSpatialPersistenceScopeEXT *); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSupportedAnchorTrackableTypesANDROID)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrTrackableTypeANDROID *); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSupportedAudioSampleRateBD)(XrSession, uint32_t, uint32_t *, XrAudioSampleRateBD *); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSupportedPersistenceAnchorTypesANDROID)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrTrackableTypeANDROID *); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSupportedSemanticLabelSetsANDROID)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrSceneMeshSemanticLabelSetANDROID *); typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSupportedTrackableTypesANDROID)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrTrackableTypeANDROID *); 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 *); @@ -8633,6 +9933,7 @@ typedef XrResult (XRAPI_PTR *PFN_xrGetActionStateBoolean)(XrSession, const XrAct 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_xrGetAllSubmeshStatesANDROID)(XrSceneMeshSnapshotANDROID, uint32_t, uint32_t *, XrSceneSubmeshStateANDROID *); typedef XrResult (XRAPI_PTR *PFN_xrGetAllTrackablesANDROID)(XrTrackableTrackerANDROID, uint32_t, uint32_t *, XrTrackableANDROID *); typedef XrResult (XRAPI_PTR *PFN_xrGetAnchorPersistStateANDROID)(XrDeviceAnchorPersistenceANDROID, const XrUuidEXT *, XrAnchorPersistStateANDROID *); typedef XrResult (XRAPI_PTR *PFN_xrGetAnchorUuidBD)(XrAnchorBD, XrUuidEXT *); @@ -8651,11 +9952,16 @@ typedef XrResult (XRAPI_PTR *PFN_xrGetDisplayRefreshRateFB)(XrSession, float *); typedef XrResult (XRAPI_PTR *PFN_xrGetEnvironmentDepthSwapchainStateMETA)(XrEnvironmentDepthSwapchainMETA, XrEnvironmentDepthSwapchainStateMETA *); typedef XrResult (XRAPI_PTR *PFN_xrGetExportedLocalizationMapDataML)(XrExportedLocalizationMapML, uint32_t, uint32_t *, char *); typedef XrResult (XRAPI_PTR *PFN_xrGetEyeGazesFB)(XrEyeTrackerFB, const XrEyeGazesInfoFB *, XrEyeGazesFB *); +typedef XrResult (XRAPI_PTR *PFN_xrGetFaceCalibrationStateANDROID)(XrFaceTrackerANDROID, XrBool32 *); 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_xrGetFaceStateANDROID)(XrFaceTrackerANDROID, const XrFaceStateGetInfoANDROID *, XrFaceStateANDROID *); 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_xrGetFacialSimulationDataBD)(XrFaceTrackerBD, const XrFacialSimulationDataGetInfoBD *, XrFacialSimulationDataBD *); +typedef XrResult (XRAPI_PTR *PFN_xrGetFacialSimulationModeBD)(XrFaceTrackerBD, XrFacialSimulationModeBD *); typedef XrResult (XRAPI_PTR *PFN_xrGetFoveationEyeTrackedStateMETA)(XrSession, XrFoveationEyeTrackedStateMETA *); +typedef XrResult (XRAPI_PTR *PFN_xrGetHandGestureQCOM)(XrHandTrackerEXT, XrTime, XrHandGestureQCOM *); typedef XrResult (XRAPI_PTR *PFN_xrGetHandMeshFB)(XrHandTrackerEXT, XrHandTrackingMeshFB *); typedef XrResult (XRAPI_PTR *PFN_xrGetInputSourceLocalizedName)(XrSession, const XrInputSourceLocalizedNameGetInfo *, uint32_t, uint32_t *, char *); typedef XrResult (XRAPI_PTR *PFN_xrGetInstanceProcAddr)(XrInstance, const char *, PFN_xrVoidFunction *); @@ -8670,6 +9976,7 @@ typedef XrResult (XRAPI_PTR *PFN_xrGetMarkersML)(XrMarkerDetectorML, uint32_t, u typedef XrResult (XRAPI_PTR *PFN_xrGetOpenGLGraphicsRequirementsKHR)(XrInstance, XrSystemId, XrGraphicsRequirementsOpenGLKHR *); typedef XrResult (XRAPI_PTR *PFN_xrGetPassthroughCameraStateANDROID)(XrSession, const XrPassthroughCameraStateGetInfoANDROID *, XrPassthroughCameraStateANDROID *); typedef XrResult (XRAPI_PTR *PFN_xrGetPassthroughPreferencesMETA)(XrSession, XrPassthroughPreferencesMETA *); +typedef XrResult (XRAPI_PTR *PFN_xrGetPerformanceMetricsStateANDROID)(XrSession, XrPerformanceMetricsStateANDROID *); typedef XrResult (XRAPI_PTR *PFN_xrGetPerformanceMetricsStateMETA)(XrSession, XrPerformanceMetricsStateMETA *); typedef XrResult (XRAPI_PTR *PFN_xrGetPlaneDetectionStateEXT)(XrPlaneDetectorEXT, XrPlaneDetectionStateEXT *); typedef XrResult (XRAPI_PTR *PFN_xrGetPlaneDetectionsEXT)(XrPlaneDetectorEXT, const XrPlaneDetectorGetInfoEXT *, XrPlaneDetectorLocationsEXT *); @@ -8712,12 +10019,15 @@ typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialBufferVector3fEXT)(XrSpatialSnapsho 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_xrGetSubmeshDataANDROID)(XrSceneMeshSnapshotANDROID, uint32_t, XrSceneSubmeshDataANDROID *); typedef XrResult (XRAPI_PTR *PFN_xrGetSwapchainStateFB)(XrSwapchain, XrSwapchainStateBaseHeaderFB *); typedef XrResult (XRAPI_PTR *PFN_xrGetSystem)(XrInstance, const XrSystemGetInfo *, XrSystemId *); typedef XrResult (XRAPI_PTR *PFN_xrGetSystemProperties)(XrInstance, XrSystemId, XrSystemProperties *); +typedef XrResult (XRAPI_PTR *PFN_xrGetTrackableImageANDROID)(XrTrackableTrackerANDROID, const XrTrackableGetInfoANDROID *, XrTrackableImageANDROID *); typedef XrResult (XRAPI_PTR *PFN_xrGetTrackableMarkerANDROID)(XrTrackableTrackerANDROID, const XrTrackableGetInfoANDROID *, XrTrackableMarkerANDROID *); typedef XrResult (XRAPI_PTR *PFN_xrGetTrackableObjectANDROID)(XrTrackableTrackerANDROID, const XrTrackableGetInfoANDROID *, XrTrackableObjectANDROID *); typedef XrResult (XRAPI_PTR *PFN_xrGetTrackablePlaneANDROID)(XrTrackableTrackerANDROID, const XrTrackableGetInfoANDROID *, XrTrackablePlaneANDROID *); +typedef XrResult (XRAPI_PTR *PFN_xrGetTrackableQrCodeANDROID)(XrTrackableTrackerANDROID, const XrTrackableGetInfoANDROID *, XrTrackableQrCodeANDROID *); typedef XrResult (XRAPI_PTR *PFN_xrGetViewConfigurationProperties)(XrInstance, XrSystemId, XrViewConfigurationType, XrViewConfigurationProperties *); typedef XrResult (XRAPI_PTR *PFN_xrGetVirtualKeyboardDirtyTexturesMETA)(XrVirtualKeyboardMETA, uint32_t, uint32_t *, uint64_t *); typedef XrResult (XRAPI_PTR *PFN_xrGetVirtualKeyboardModelAnimationStatesMETA)(XrVirtualKeyboardMETA, XrVirtualKeyboardModelAnimationStatesMETA *); @@ -8754,6 +10064,7 @@ 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_xrPauseSimultaneousHandsAndControllersTrackingMETA)(XrSession, const XrSimultaneousHandsAndControllersTrackingPauseInfoMETA *); typedef XrResult (XRAPI_PTR *PFN_xrPerfSettingsSetPerformanceLevelEXT)(XrSession, XrPerfSettingsDomainEXT, XrPerfSettingsLevelEXT); +typedef XrResult (XRAPI_PTR *PFN_xrPerformEnvironmentRaycastMETA)(XrEnvironmentRaycasterMETA, const XrEnvironmentRaycastHitGetInfoMETA *, XrEnvironmentRaycastHitMETA *); typedef XrResult (XRAPI_PTR *PFN_xrPersistAnchorANDROID)(XrDeviceAnchorPersistenceANDROID, const XrPersistedAnchorSpaceInfoANDROID *, XrUuidEXT *); typedef XrResult (XRAPI_PTR *PFN_xrPersistSpatialAnchorAsyncBD)(XrSenseDataProviderBD, const XrSpatialAnchorPersistInfoBD *, XrFutureEXT *); typedef XrResult (XRAPI_PTR *PFN_xrPersistSpatialAnchorCompleteBD)(XrSenseDataProviderBD, XrFutureEXT, XrFutureCompletionEXT *); @@ -8764,7 +10075,9 @@ 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_xrQueryFramesPerBufferRangeBD)(XrSession, XrAudioSampleRateBD, uint32_t *, uint32_t *); typedef XrResult (XRAPI_PTR *PFN_xrQueryLocalizationMapsML)(XrSession, const XrLocalizationMapQueryInfoBaseHeaderML *, uint32_t, uint32_t *, XrLocalizationMapML *); +typedef XrResult (XRAPI_PTR *PFN_xrQueryPerformanceMetricsCounterANDROID)(XrSession, XrPath, XrPerformanceMetricsCounterANDROID *); 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 *); @@ -8775,6 +10088,8 @@ typedef XrResult (XRAPI_PTR *PFN_xrQuerySpatialComponentDataEXT)(XrSpatialSnapsh typedef XrResult (XRAPI_PTR *PFN_xrQuerySystemTrackedKeyboardFB)(XrSession, const XrKeyboardTrackingQueryFB *, XrKeyboardTrackingDescriptionFB *); typedef XrResult (XRAPI_PTR *PFN_xrRaycastANDROID)(XrSession, const XrRaycastInfoANDROID *, XrRaycastHitResultsANDROID *); typedef XrResult (XRAPI_PTR *PFN_xrReleaseSwapchainImage)(XrSwapchain, const XrSwapchainImageReleaseInfo *); +typedef XrResult (XRAPI_PTR *PFN_xrRemoveTrackableImageDatabaseANDROID)(XrTrackableTrackerANDROID, XrTrackableImageDatabaseANDROID); +typedef XrResult (XRAPI_PTR *PFN_xrRequestBodyTrackingFidelityMETA)(XrBodyTrackerFB, const XrBodyTrackingFidelityMETA); typedef XrResult (XRAPI_PTR *PFN_xrRequestDisplayRefreshRateFB)(XrSession, float); typedef XrResult (XRAPI_PTR *PFN_xrRequestExitSession)(XrSession); typedef XrResult (XRAPI_PTR *PFN_xrRequestMapLocalizationML)(XrSession, const XrMapLocalizationRequestInfoML *); @@ -8796,6 +10111,7 @@ typedef XrResult (XRAPI_PTR *PFN_xrSetColorSpaceFB)(XrSession, const XrColorSpac typedef XrResult (XRAPI_PTR *PFN_xrSetDigitalLensControlALMALENCE)(XrSession, const XrDigitalLensControlALMALENCE *); typedef XrResult (XRAPI_PTR *PFN_xrSetEnvironmentDepthEstimationVARJO)(XrSession, XrBool32); typedef XrResult (XRAPI_PTR *PFN_xrSetEnvironmentDepthHandRemovalMETA)(XrEnvironmentDepthProviderMETA, const XrEnvironmentDepthHandRemovalSetInfoMETA *); +typedef XrResult (XRAPI_PTR *PFN_xrSetFacialSimulationModeBD)(XrFaceTrackerBD, XrFacialSimulationModeBD); typedef XrResult (XRAPI_PTR *PFN_xrSetInputDeviceActiveEXT)(XrSession, XrPath, XrPath, XrBool32); typedef XrResult (XRAPI_PTR *PFN_xrSetInputDeviceLocationEXT)(XrSession, XrPath, XrPath, XrSpace, XrPosef); typedef XrResult (XRAPI_PTR *PFN_xrSetInputDeviceStateBoolEXT)(XrSession, XrPath, XrPath, XrBool32); @@ -8804,9 +10120,12 @@ typedef XrResult (XRAPI_PTR *PFN_xrSetInputDeviceStateVector2fEXT)(XrSession, Xr typedef XrResult (XRAPI_PTR *PFN_xrSetMarkerTrackingPredictionVARJO)(XrSession, uint64_t, XrBool32); typedef XrResult (XRAPI_PTR *PFN_xrSetMarkerTrackingTimeoutVARJO)(XrSession, uint64_t, XrDuration); typedef XrResult (XRAPI_PTR *PFN_xrSetMarkerTrackingVARJO)(XrSession, XrBool32); +typedef XrResult (XRAPI_PTR *PFN_xrSetPassthroughLayerMeshANDROID)(XrPassthroughLayerANDROID, const XrPassthroughLayerMeshANDROID *); +typedef XrResult (XRAPI_PTR *PFN_xrSetPerformanceMetricsStateANDROID)(XrSession, const XrPerformanceMetricsStateANDROID *); 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_xrSetTilePropertiesHintMETA)(XrSession, const XrTilePropertiesHintMETA *); 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 *); @@ -8828,6 +10147,8 @@ typedef XrResult (XRAPI_PTR *PFN_xrStopSenseDataProviderBD)(XrSenseDataProviderB 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_xrSubmitSoundFieldBufferBD)(XrSoundFieldBD, const XrAudioBufferBD *); +typedef XrResult (XRAPI_PTR *PFN_xrSubmitSoundObjectBufferBD)(XrSoundObjectBD, const XrAudioBufferBD *); typedef XrResult (XRAPI_PTR *PFN_xrSuggestBodyTrackingCalibrationOverrideMETA)(XrBodyTrackerFB, const XrBodyTrackingCalibrationInfoMETA *); typedef XrResult (XRAPI_PTR *PFN_xrSuggestInteractionProfileBindings)(XrInstance, const XrInteractionProfileSuggestedBinding *); typedef XrResult (XRAPI_PTR *PFN_xrSuggestVirtualKeyboardLocationMETA)(XrVirtualKeyboardMETA, const XrVirtualKeyboardLocationInfoMETA *); @@ -8848,15 +10169,21 @@ typedef XrResult (XRAPI_PTR *PFN_xrUnpersistSpatialEntityAsyncEXT)(XrSpatialPers typedef XrResult (XRAPI_PTR *PFN_xrUnpersistSpatialEntityCompleteEXT)(XrSpatialPersistenceContextEXT, XrFutureEXT, XrUnpersistSpatialEntityCompletionEXT *); typedef XrResult (XRAPI_PTR *PFN_xrUpdateHandMeshMSFT)(XrHandTrackerEXT, const XrHandMeshUpdateInfoMSFT *, XrHandMeshMSFT *); typedef XrResult (XRAPI_PTR *PFN_xrUpdatePassthroughColorLutMETA)(XrPassthroughColorLutMETA, const XrPassthroughColorLutUpdateInfoMETA *); +typedef XrResult (XRAPI_PTR *PFN_xrUpdateSoundFieldConfigBD)(XrSoundFieldBD, const XrSoundFieldConfigBD *, XrSoundFieldFlagsBD); +typedef XrResult (XRAPI_PTR *PFN_xrUpdateSoundObjectConfigBD)(XrSoundObjectBD, const XrSoundObjectConfigBD *, XrSoundObjectFlagsBD); +typedef XrResult (XRAPI_PTR *PFN_xrUpdateSoundObstacleConfigBD)(XrSoundObstacleBD, const XrSoundObstacleConfigBD *, const XrSoundTriangleMeshBD *, XrSoundObstacleFlagsBD); +typedef XrResult (XRAPI_PTR *PFN_xrUpdateSoundObstacleMaterialConfigBD)(XrSoundObstacleMaterialBD, const XrSoundObstacleMaterialConfigBD *); 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_xrWaitAudioPeriodBD)(XrSpatialAudioRendererBD, XrDuration); typedef XrResult (XRAPI_PTR *PFN_xrWaitFrame)(XrSession, const XrFrameWaitInfo *, XrFrameState *); typedef XrResult (XRAPI_PTR *PFN_xrWaitSwapchainImage)(XrSwapchain, const XrSwapchainImageWaitInfo *); #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 xrAddTrackableImageDatabaseANDROID(XrTrackableTrackerANDROID tracker, XrTrackableImageDatabaseANDROID database); 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); @@ -8884,9 +10211,13 @@ XrResult XRAPI_CALL xrCreateBodyTrackerHTC(XrSession session, const XrBodyTracke XrResult XRAPI_CALL xrCreateDeviceAnchorPersistenceANDROID(XrSession session, const XrDeviceAnchorPersistenceCreateInfoANDROID *createInfo, XrDeviceAnchorPersistenceANDROID *outHandle); 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 xrCreateEnvironmentRaycasterAsyncMETA(XrSession session, const XrEnvironmentRaycasterCreateInfoMETA *info, XrFutureEXT *future); +XrResult XRAPI_CALL xrCreateEnvironmentRaycasterCompleteMETA(XrSession session, XrFutureEXT future, XrEnvironmentRaycasterCreateCompletionMETA *completion); 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 xrCreateFaceTrackerANDROID(XrSession session, const XrFaceTrackerCreateInfoANDROID *createInfo, XrFaceTrackerANDROID *faceTracker); +XrResult XRAPI_CALL xrCreateFaceTrackerBD(XrSession session, const XrFaceTrackerCreateInfoBD *createInfo, XrFaceTrackerBD *tracker); 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); @@ -8902,6 +10233,7 @@ XrResult XRAPI_CALL xrCreateMarkerSpaceVARJO(XrSession session, const XrMarkerSp XrResult XRAPI_CALL xrCreatePassthroughColorLutMETA(XrPassthroughFB passthrough, const XrPassthroughColorLutCreateInfoMETA *createInfo, XrPassthroughColorLutMETA *colorLut); XrResult XRAPI_CALL xrCreatePassthroughFB(XrSession session, const XrPassthroughCreateInfoFB *createInfo, XrPassthroughFB *outPassthrough); XrResult XRAPI_CALL xrCreatePassthroughHTC(XrSession session, const XrPassthroughCreateInfoHTC *createInfo, XrPassthroughHTC *passthrough); +XrResult XRAPI_CALL xrCreatePassthroughLayerANDROID(XrSession session, const XrPassthroughLayerCreateInfoANDROID *createInfo, XrPassthroughLayerANDROID *layer); XrResult XRAPI_CALL xrCreatePassthroughLayerFB(XrSession session, const XrPassthroughLayerCreateInfoFB *createInfo, XrPassthroughLayerFB *outLayer); XrResult XRAPI_CALL xrCreatePersistedAnchorSpaceANDROID(XrDeviceAnchorPersistenceANDROID handle, const XrPersistedAnchorSpaceCreateInfoANDROID *createInfo, XrSpace *anchorOutput); XrResult XRAPI_CALL xrCreatePlaneDetectorEXT(XrSession session, const XrPlaneDetectorCreateInfoEXT *createInfo, XrPlaneDetectorEXT *planeDetector); @@ -8910,9 +10242,15 @@ XrResult XRAPI_CALL xrCreateRenderModelAssetEXT(XrSession session, const XrRende XrResult XRAPI_CALL xrCreateRenderModelEXT(XrSession session, const XrRenderModelCreateInfoEXT *createInfo, XrRenderModelEXT *renderModel); XrResult XRAPI_CALL xrCreateRenderModelSpaceEXT(XrSession session, const XrRenderModelSpaceCreateInfoEXT *createInfo, XrSpace *space); XrResult XRAPI_CALL xrCreateSceneMSFT(XrSceneObserverMSFT sceneObserver, const XrSceneCreateInfoMSFT *createInfo, XrSceneMSFT *scene); +XrResult XRAPI_CALL xrCreateSceneMeshSnapshotANDROID(XrSceneMeshingTrackerANDROID tracker, const XrSceneMeshSnapshotCreateInfoANDROID *createInfo, XrSceneMeshSnapshotCreationResultANDROID *outSnapshotCreationResult); +XrResult XRAPI_CALL xrCreateSceneMeshingTrackerANDROID(XrSession session, const XrSceneMeshingTrackerCreateInfoANDROID *createInfo, XrSceneMeshingTrackerANDROID *tracker); 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 xrCreateSoundFieldBD(XrSpatialAudioRendererBD renderer, const XrSoundFieldConfigBD *config, XrSoundFieldBD *soundField); +XrResult XRAPI_CALL xrCreateSoundObjectBD(XrSpatialAudioRendererBD renderer, const XrSoundObjectConfigBD *config, XrSoundObjectBD *soundObject); +XrResult XRAPI_CALL xrCreateSoundObstacleBD(XrSpatialAudioRendererBD renderer, const XrSoundObstacleConfigBD *config, const XrSoundTriangleMeshBD *mesh, XrSoundObstacleBD *soundObstacle); +XrResult XRAPI_CALL xrCreateSoundObstacleMaterialBD(XrSpatialAudioRendererBD renderer, const XrSoundObstacleMaterialConfigBD *config, XrSoundObstacleMaterialBD *material); 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); @@ -8921,11 +10259,14 @@ XrResult XRAPI_CALL xrCreateSpatialAnchorFB(XrSession session, const XrSpatialAn 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 xrCreateSpatialAnchorSpaceANDROID(XrSession session, XrSpatialContextEXT spatialContext, const XrSpatialAnchorCreateInfoEXT *createInfo, XrSpatialEntityIdEXT *anchorEntityId, XrSpace *anchorSpace); +XrResult XRAPI_CALL xrCreateSpatialAnchorSpaceFromIdANDROID(XrSession session, XrSpatialContextEXT spatialContext, const XrSpatialAnchorSpaceFromIdCreateInfoANDROID *createInfo, XrSpace *anchorSpace); 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 xrCreateSpatialAudioRendererBD(XrSession session, const XrSpatialAudioRendererCreateInfoBD *createInfo, XrSpatialAudioRendererBD *renderer); XrResult XRAPI_CALL xrCreateSpatialContextAsyncEXT(XrSession session, const XrSpatialContextCreateInfoEXT *createInfo, XrFutureEXT *future); XrResult XRAPI_CALL xrCreateSpatialContextCompleteEXT(XrSession session, XrFutureEXT future, XrCreateSpatialContextCompletionEXT *completion); XrResult XRAPI_CALL xrCreateSpatialDiscoverySnapshotAsyncEXT(XrSpatialContextEXT spatialContext, const XrSpatialDiscoverySnapshotCreateInfoEXT *createInfo, XrFutureEXT *future); @@ -8935,8 +10276,11 @@ XrResult XRAPI_CALL xrCreateSpatialEntityFromIdEXT(XrSpatialContextEXT spatialCo XrResult XRAPI_CALL xrCreateSpatialGraphNodeSpaceMSFT(XrSession session, const XrSpatialGraphNodeSpaceCreateInfoMSFT *createInfo, XrSpace *space); XrResult XRAPI_CALL xrCreateSpatialPersistenceContextAsyncEXT(XrSession session, const XrSpatialPersistenceContextCreateInfoEXT *createInfo, XrFutureEXT *future); XrResult XRAPI_CALL xrCreateSpatialPersistenceContextCompleteEXT(XrSession session, XrFutureEXT future, XrCreateSpatialPersistenceContextCompletionEXT *completion); +XrResult XRAPI_CALL xrCreateSpatialRaycastSnapshotANDROID(XrSpatialContextEXT spatialContext, const XrSpatialRaycastSnapshotCreateInfoANDROID *createInfo, XrSpatialSnapshotEXT *snapshot); XrResult XRAPI_CALL xrCreateSpatialUpdateSnapshotEXT(XrSpatialContextEXT spatialContext, const XrSpatialUpdateSnapshotCreateInfoEXT *createInfo, XrSpatialSnapshotEXT *snapshot); XrResult XRAPI_CALL xrCreateSwapchain(XrSession session, const XrSwapchainCreateInfo *createInfo, XrSwapchain *swapchain); +XrResult XRAPI_CALL xrCreateTrackableImageDatabaseAsyncANDROID(XrSession session, const XrTrackableImageDatabaseCreateInfoANDROID *createInfo, XrFutureEXT *future); +XrResult XRAPI_CALL xrCreateTrackableImageDatabaseCompleteANDROID(XrSession session, XrFutureEXT future, XrCreateTrackableImageDatabaseCompletionANDROID *completion); XrResult XRAPI_CALL xrCreateTrackableTrackerANDROID(XrSession session, const XrTrackableTrackerCreateInfoANDROID *createInfo, XrTrackableTrackerANDROID *trackableTracker); XrResult XRAPI_CALL xrCreateTriangleMeshFB(XrSession session, const XrTriangleMeshCreateInfoFB *createInfo, XrTriangleMeshFB *outTriangleMesh); XrResult XRAPI_CALL xrCreateVirtualKeyboardMETA(XrSession session, const XrVirtualKeyboardCreateInfoMETA *createInfo, XrVirtualKeyboardMETA *keyboard); @@ -8956,9 +10300,12 @@ XrResult XRAPI_CALL xrDestroyBodyTrackerHTC(XrBodyTrackerHTC bodyTracker); XrResult XRAPI_CALL xrDestroyDeviceAnchorPersistenceANDROID(XrDeviceAnchorPersistenceANDROID handle); XrResult XRAPI_CALL xrDestroyEnvironmentDepthProviderMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider); XrResult XRAPI_CALL xrDestroyEnvironmentDepthSwapchainMETA(XrEnvironmentDepthSwapchainMETA swapchain); +XrResult XRAPI_CALL xrDestroyEnvironmentRaycasterMETA(XrEnvironmentRaycasterMETA environmentRaycaster); XrResult XRAPI_CALL xrDestroyExportedLocalizationMapML(XrExportedLocalizationMapML map); XrResult XRAPI_CALL xrDestroyEyeTrackerFB(XrEyeTrackerFB eyeTracker); XrResult XRAPI_CALL xrDestroyFaceTracker2FB(XrFaceTracker2FB faceTracker); +XrResult XRAPI_CALL xrDestroyFaceTrackerANDROID(XrFaceTrackerANDROID faceTracker); +XrResult XRAPI_CALL xrDestroyFaceTrackerBD(XrFaceTrackerBD tracker); XrResult XRAPI_CALL xrDestroyFaceTrackerFB(XrFaceTrackerFB faceTracker); XrResult XRAPI_CALL xrDestroyFacialExpressionClientML(XrFacialExpressionClientML facialExpressionClient); XrResult XRAPI_CALL xrDestroyFacialTrackerHTC(XrFacialTrackerHTC facialTracker); @@ -8970,26 +10317,35 @@ XrResult XRAPI_CALL xrDestroyMarkerDetectorML(XrMarkerDetectorML markerDetector) XrResult XRAPI_CALL xrDestroyPassthroughColorLutMETA(XrPassthroughColorLutMETA colorLut); XrResult XRAPI_CALL xrDestroyPassthroughFB(XrPassthroughFB passthrough); XrResult XRAPI_CALL xrDestroyPassthroughHTC(XrPassthroughHTC passthrough); +XrResult XRAPI_CALL xrDestroyPassthroughLayerANDROID(XrPassthroughLayerANDROID layer); XrResult XRAPI_CALL xrDestroyPassthroughLayerFB(XrPassthroughLayerFB layer); XrResult XRAPI_CALL xrDestroyPlaneDetectorEXT(XrPlaneDetectorEXT planeDetector); XrResult XRAPI_CALL xrDestroyRenderModelAssetEXT(XrRenderModelAssetEXT asset); XrResult XRAPI_CALL xrDestroyRenderModelEXT(XrRenderModelEXT renderModel); XrResult XRAPI_CALL xrDestroySceneMSFT(XrSceneMSFT scene); +XrResult XRAPI_CALL xrDestroySceneMeshSnapshotANDROID(XrSceneMeshSnapshotANDROID snapshot); +XrResult XRAPI_CALL xrDestroySceneMeshingTrackerANDROID(XrSceneMeshingTrackerANDROID tracker); 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 xrDestroySoundFieldBD(XrSoundFieldBD soundField); +XrResult XRAPI_CALL xrDestroySoundObjectBD(XrSoundObjectBD soundObject); +XrResult XRAPI_CALL xrDestroySoundObstacleBD(XrSoundObstacleBD soundObstacle); +XrResult XRAPI_CALL xrDestroySoundObstacleMaterialBD(XrSoundObstacleMaterialBD material); 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 xrDestroySpatialAudioRendererBD(XrSpatialAudioRendererBD renderer); XrResult XRAPI_CALL xrDestroySpatialContextEXT(XrSpatialContextEXT spatialContext); XrResult XRAPI_CALL xrDestroySpatialEntityEXT(XrSpatialEntityEXT spatialEntity); XrResult XRAPI_CALL xrDestroySpatialGraphNodeBindingMSFT(XrSpatialGraphNodeBindingMSFT nodeBinding); XrResult XRAPI_CALL xrDestroySpatialPersistenceContextEXT(XrSpatialPersistenceContextEXT persistenceContext); XrResult XRAPI_CALL xrDestroySpatialSnapshotEXT(XrSpatialSnapshotEXT snapshot); XrResult XRAPI_CALL xrDestroySwapchain(XrSwapchain swapchain); +XrResult XRAPI_CALL xrDestroyTrackableImageDatabaseANDROID(XrTrackableImageDatabaseANDROID database); XrResult XRAPI_CALL xrDestroyTrackableTrackerANDROID(XrTrackableTrackerANDROID trackableTracker); XrResult XRAPI_CALL xrDestroyTriangleMeshFB(XrTriangleMeshFB mesh); XrResult XRAPI_CALL xrDestroyVirtualKeyboardMETA(XrVirtualKeyboardMETA keyboard); @@ -8999,6 +10355,7 @@ XrResult XRAPI_CALL xrDownloadSharedSpatialAnchorAsyncBD(XrSenseDataProviderBD p 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 xrEndAudioPeriodBD(XrSpatialAudioRendererBD renderer); XrResult XRAPI_CALL xrEndFrame(XrSession session, const XrFrameEndInfo *frameEndInfo); XrResult XRAPI_CALL xrEndSession(XrSession session); XrResult XRAPI_CALL xrEnumerateApiLayerProperties(uint32_t propertyCapacityInput, uint32_t *propertyCountOutput, XrApiLayerProperties *properties); @@ -9008,8 +10365,10 @@ XrResult XRAPI_CALL xrEnumerateDisplayRefreshRatesFB(XrSession session, uint32_t XrResult XRAPI_CALL xrEnumerateEnvironmentBlendModes(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, uint32_t environmentBlendModeCapacityInput, uint32_t *environmentBlendModeCountOutput, XrEnvironmentBlendMode *environmentBlendModes); XrResult XRAPI_CALL xrEnumerateEnvironmentDepthSwapchainImagesMETA(XrEnvironmentDepthSwapchainMETA swapchain, uint32_t imageCapacityInput, uint32_t *imageCountOutput, XrSwapchainImageBaseHeader *images); XrResult XRAPI_CALL xrEnumerateExternalCamerasOCULUS(XrSession session, uint32_t cameraCapacityInput, uint32_t *cameraCountOutput, XrExternalCameraOCULUS *cameras); +XrResult XRAPI_CALL xrEnumerateFacialSimulationModesBD(XrSession session, uint32_t modeCapacityInput, uint32_t *modeCountOutput, XrFacialSimulationModeBD *modes); XrResult XRAPI_CALL xrEnumerateInstanceExtensionProperties(const char *layerName, uint32_t propertyCapacityInput, uint32_t *propertyCountOutput, XrExtensionProperties *properties); XrResult XRAPI_CALL xrEnumerateInteractionRenderModelIdsEXT(XrSession session, const XrInteractionRenderModelIdsEnumerateInfoEXT *getInfo, uint32_t renderModelIdCapacityInput, uint32_t *renderModelIdCountOutput, XrRenderModelIdEXT *renderModelIds); +XrResult XRAPI_CALL xrEnumeratePerformanceMetricsCounterPathsANDROID(XrInstance instance, uint32_t counterPathCapacityInput, uint32_t *counterPathCountOutput, XrPath *counterPaths); XrResult XRAPI_CALL xrEnumeratePerformanceMetricsCounterPathsMETA(XrInstance instance, uint32_t counterPathCapacityInput, uint32_t *counterPathCountOutput, XrPath *counterPaths); XrResult XRAPI_CALL xrEnumeratePersistedAnchorsANDROID(XrDeviceAnchorPersistenceANDROID handle, uint32_t anchorIdCapacityInput, uint32_t *anchorIdCountOutput, XrUuidEXT *anchorIds); XrResult XRAPI_CALL xrEnumeratePersistedSpatialAnchorNamesMSFT(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, uint32_t spatialAnchorNameCapacityInput, uint32_t *spatialAnchorNameCountOutput, XrSpatialAnchorPersistenceNameMSFT *spatialAnchorNames); @@ -9020,13 +10379,16 @@ XrResult XRAPI_CALL xrEnumerateRenderModelSubactionPathsEXT(XrRenderModelEXT ren 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 xrEnumerateSpatialAnchorAttachableComponentsANDROID(XrInstance instance, XrSystemId systemId, uint32_t attachableComponentCapacityInput, uint32_t *attachableComponentCountOutput, XrSpatialComponentTypeEXT *attachableComponents); XrResult XRAPI_CALL xrEnumerateSpatialCapabilitiesEXT(XrInstance instance, XrSystemId systemId, uint32_t capabilityCapacityInput, uint32_t *capabilityCountOutput, XrSpatialCapabilityEXT *capabilities); XrResult XRAPI_CALL xrEnumerateSpatialCapabilityComponentTypesEXT(XrInstance instance, XrSystemId systemId, XrSpatialCapabilityEXT capability, XrSpatialCapabilityComponentTypesEXT *capabilityComponents); XrResult XRAPI_CALL xrEnumerateSpatialCapabilityFeaturesEXT(XrInstance instance, XrSystemId systemId, XrSpatialCapabilityEXT capability, uint32_t capabilityFeatureCapacityInput, uint32_t *capabilityFeatureCountOutput, XrSpatialCapabilityFeatureEXT *capabilityFeatures); XrResult XRAPI_CALL xrEnumerateSpatialEntityComponentTypesBD(XrSenseDataSnapshotBD snapshot, XrSpatialEntityIdBD entityId, uint32_t componentTypeCapacityInput, uint32_t *componentTypeCountOutput, XrSpatialEntityComponentTypeBD *componentTypes); XrResult XRAPI_CALL xrEnumerateSpatialPersistenceScopesEXT(XrInstance instance, XrSystemId systemId, uint32_t persistenceScopeCapacityInput, uint32_t *persistenceScopeCountOutput, XrSpatialPersistenceScopeEXT *persistenceScopes); XrResult XRAPI_CALL xrEnumerateSupportedAnchorTrackableTypesANDROID(XrInstance instance, XrSystemId systemId, uint32_t trackableTypeCapacityInput, uint32_t *trackableTypeCountOutput, XrTrackableTypeANDROID *trackableTypes); +XrResult XRAPI_CALL xrEnumerateSupportedAudioSampleRateBD(XrSession session, uint32_t sampleRateCapacityInput, uint32_t *sampleRateCountOutput, XrAudioSampleRateBD *sampleRates); XrResult XRAPI_CALL xrEnumerateSupportedPersistenceAnchorTypesANDROID(XrInstance instance, XrSystemId systemId, uint32_t trackableTypeCapacityInput, uint32_t *trackableTypeCountOutput, XrTrackableTypeANDROID *trackableTypes); +XrResult XRAPI_CALL xrEnumerateSupportedSemanticLabelSetsANDROID(XrInstance instance, XrSystemId systemId, uint32_t supportedSemanticLabelSetsInputCapacity, uint32_t *supportedSemanticLabelSetsOutputCount, XrSceneMeshSemanticLabelSetANDROID *supportedSemanticLabelSets); XrResult XRAPI_CALL xrEnumerateSupportedTrackableTypesANDROID(XrInstance instance, XrSystemId systemId, uint32_t trackableTypeCapacityInput, uint32_t *trackableTypeCountOutput, XrTrackableTypeANDROID *trackableTypes); 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); @@ -9041,6 +10403,7 @@ XrResult XRAPI_CALL xrGetActionStateBoolean(XrSession session, const XrActionSta 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 xrGetAllSubmeshStatesANDROID(XrSceneMeshSnapshotANDROID snapshot, uint32_t submeshStateCapacityInput, uint32_t *submeshStateCountOutput, XrSceneSubmeshStateANDROID *submeshStates); XrResult XRAPI_CALL xrGetAllTrackablesANDROID(XrTrackableTrackerANDROID trackableTracker, uint32_t trackableCapacityInput, uint32_t *trackableCountOutput, XrTrackableANDROID *trackables); XrResult XRAPI_CALL xrGetAnchorPersistStateANDROID(XrDeviceAnchorPersistenceANDROID handle, const XrUuidEXT *anchorId, XrAnchorPersistStateANDROID *persistState); XrResult XRAPI_CALL xrGetAnchorUuidBD(XrAnchorBD anchor, XrUuidEXT *uuid); @@ -9059,11 +10422,16 @@ XrResult XRAPI_CALL xrGetDisplayRefreshRateFB(XrSession session, float *displayR XrResult XRAPI_CALL xrGetEnvironmentDepthSwapchainStateMETA(XrEnvironmentDepthSwapchainMETA swapchain, XrEnvironmentDepthSwapchainStateMETA *state); XrResult XRAPI_CALL xrGetExportedLocalizationMapDataML(XrExportedLocalizationMapML map, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer); XrResult XRAPI_CALL xrGetEyeGazesFB(XrEyeTrackerFB eyeTracker, const XrEyeGazesInfoFB *gazeInfo, XrEyeGazesFB *eyeGazes); +XrResult XRAPI_CALL xrGetFaceCalibrationStateANDROID(XrFaceTrackerANDROID faceTracker, XrBool32 *faceIsCalibratedOutput); 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 xrGetFaceStateANDROID(XrFaceTrackerANDROID faceTracker, const XrFaceStateGetInfoANDROID *getInfo, XrFaceStateANDROID *faceStateOutput); 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 xrGetFacialSimulationDataBD(XrFaceTrackerBD tracker, const XrFacialSimulationDataGetInfoBD *info, XrFacialSimulationDataBD *facialData); +XrResult XRAPI_CALL xrGetFacialSimulationModeBD(XrFaceTrackerBD tracker, XrFacialSimulationModeBD *mode); XrResult XRAPI_CALL xrGetFoveationEyeTrackedStateMETA(XrSession session, XrFoveationEyeTrackedStateMETA *foveationState); +XrResult XRAPI_CALL xrGetHandGestureQCOM(XrHandTrackerEXT handTracker, XrTime time, XrHandGestureQCOM *handGesture); XrResult XRAPI_CALL xrGetHandMeshFB(XrHandTrackerEXT handTracker, XrHandTrackingMeshFB *mesh); XrResult XRAPI_CALL xrGetInputSourceLocalizedName(XrSession session, const XrInputSourceLocalizedNameGetInfo *getInfo, uint32_t bufferCapacityInput, uint32_t *bufferCountOutput, char *buffer); XrResult XRAPI_CALL xrGetInstanceProcAddr(XrInstance instance, const char *name, PFN_xrVoidFunction *function); @@ -9078,6 +10446,7 @@ XrResult XRAPI_CALL xrGetMarkersML(XrMarkerDetectorML markerDetector, uint32_t m XrResult XRAPI_CALL xrGetOpenGLGraphicsRequirementsKHR(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsOpenGLKHR *graphicsRequirements); XrResult XRAPI_CALL xrGetPassthroughCameraStateANDROID(XrSession session, const XrPassthroughCameraStateGetInfoANDROID *getInfo, XrPassthroughCameraStateANDROID *cameraStateOutput); XrResult XRAPI_CALL xrGetPassthroughPreferencesMETA(XrSession session, XrPassthroughPreferencesMETA *preferences); +XrResult XRAPI_CALL xrGetPerformanceMetricsStateANDROID(XrSession session, XrPerformanceMetricsStateANDROID *state); XrResult XRAPI_CALL xrGetPerformanceMetricsStateMETA(XrSession session, XrPerformanceMetricsStateMETA *state); XrResult XRAPI_CALL xrGetPlaneDetectionStateEXT(XrPlaneDetectorEXT planeDetector, XrPlaneDetectionStateEXT *state); XrResult XRAPI_CALL xrGetPlaneDetectionsEXT(XrPlaneDetectorEXT planeDetector, const XrPlaneDetectorGetInfoEXT *info, XrPlaneDetectorLocationsEXT *locations); @@ -9120,12 +10489,15 @@ XrResult XRAPI_CALL xrGetSpatialBufferVector3fEXT(XrSpatialSnapshotEXT snapshot, 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 xrGetSubmeshDataANDROID(XrSceneMeshSnapshotANDROID snapshot, uint32_t submeshDataCount, XrSceneSubmeshDataANDROID *inoutSubmeshData); XrResult XRAPI_CALL xrGetSwapchainStateFB(XrSwapchain swapchain, XrSwapchainStateBaseHeaderFB *state); XrResult XRAPI_CALL xrGetSystem(XrInstance instance, const XrSystemGetInfo *getInfo, XrSystemId *systemId); XrResult XRAPI_CALL xrGetSystemProperties(XrInstance instance, XrSystemId systemId, XrSystemProperties *properties); +XrResult XRAPI_CALL xrGetTrackableImageANDROID(XrTrackableTrackerANDROID tracker, const XrTrackableGetInfoANDROID *getInfo, XrTrackableImageANDROID *trackable); XrResult XRAPI_CALL xrGetTrackableMarkerANDROID(XrTrackableTrackerANDROID tracker, const XrTrackableGetInfoANDROID *getInfo, XrTrackableMarkerANDROID *markerOutput); XrResult XRAPI_CALL xrGetTrackableObjectANDROID(XrTrackableTrackerANDROID tracker, const XrTrackableGetInfoANDROID *getInfo, XrTrackableObjectANDROID *objectOutput); XrResult XRAPI_CALL xrGetTrackablePlaneANDROID(XrTrackableTrackerANDROID trackableTracker, const XrTrackableGetInfoANDROID *getInfo, XrTrackablePlaneANDROID *planeOutput); +XrResult XRAPI_CALL xrGetTrackableQrCodeANDROID(XrTrackableTrackerANDROID tracker, const XrTrackableGetInfoANDROID *getInfo, XrTrackableQrCodeANDROID *qrCodeOutput); XrResult XRAPI_CALL xrGetViewConfigurationProperties(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, XrViewConfigurationProperties *configurationProperties); XrResult XRAPI_CALL xrGetVirtualKeyboardDirtyTexturesMETA(XrVirtualKeyboardMETA keyboard, uint32_t textureIdCapacityInput, uint32_t *textureIdCountOutput, uint64_t *textureIds); XrResult XRAPI_CALL xrGetVirtualKeyboardModelAnimationStatesMETA(XrVirtualKeyboardMETA keyboard, XrVirtualKeyboardModelAnimationStatesMETA *animationStates); @@ -9162,6 +10534,7 @@ 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 xrPauseSimultaneousHandsAndControllersTrackingMETA(XrSession session, const XrSimultaneousHandsAndControllersTrackingPauseInfoMETA *pauseInfo); XrResult XRAPI_CALL xrPerfSettingsSetPerformanceLevelEXT(XrSession session, XrPerfSettingsDomainEXT domain, XrPerfSettingsLevelEXT level); +XrResult XRAPI_CALL xrPerformEnvironmentRaycastMETA(XrEnvironmentRaycasterMETA environmentRaycaster, const XrEnvironmentRaycastHitGetInfoMETA *info, XrEnvironmentRaycastHitMETA *hitPoint); XrResult XRAPI_CALL xrPersistAnchorANDROID(XrDeviceAnchorPersistenceANDROID handle, const XrPersistedAnchorSpaceInfoANDROID *persistedInfo, XrUuidEXT *anchorIdOutput); XrResult XRAPI_CALL xrPersistSpatialAnchorAsyncBD(XrSenseDataProviderBD provider, const XrSpatialAnchorPersistInfoBD *info, XrFutureEXT *future); XrResult XRAPI_CALL xrPersistSpatialAnchorCompleteBD(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT *completion); @@ -9172,7 +10545,9 @@ XrResult XRAPI_CALL xrPollEvent(XrInstance instance, XrEventDataBuffer *eventDat 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 xrQueryFramesPerBufferRangeBD(XrSession session, XrAudioSampleRateBD sampleRate, uint32_t *min, uint32_t *max); XrResult XRAPI_CALL xrQueryLocalizationMapsML(XrSession session, const XrLocalizationMapQueryInfoBaseHeaderML *queryInfo, uint32_t mapCapacityInput, uint32_t *mapCountOutput, XrLocalizationMapML *maps); +XrResult XRAPI_CALL xrQueryPerformanceMetricsCounterANDROID(XrSession session, XrPath counterPath, XrPerformanceMetricsCounterANDROID *counter); 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); @@ -9183,6 +10558,8 @@ XrResult XRAPI_CALL xrQuerySpatialComponentDataEXT(XrSpatialSnapshotEXT snapshot XrResult XRAPI_CALL xrQuerySystemTrackedKeyboardFB(XrSession session, const XrKeyboardTrackingQueryFB *queryInfo, XrKeyboardTrackingDescriptionFB *keyboard); XrResult XRAPI_CALL xrRaycastANDROID(XrSession session, const XrRaycastInfoANDROID *rayInfo, XrRaycastHitResultsANDROID *results); XrResult XRAPI_CALL xrReleaseSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageReleaseInfo *releaseInfo); +XrResult XRAPI_CALL xrRemoveTrackableImageDatabaseANDROID(XrTrackableTrackerANDROID tracker, XrTrackableImageDatabaseANDROID database); +XrResult XRAPI_CALL xrRequestBodyTrackingFidelityMETA(XrBodyTrackerFB bodyTracker, const XrBodyTrackingFidelityMETA fidelity); XrResult XRAPI_CALL xrRequestDisplayRefreshRateFB(XrSession session, float displayRefreshRate); XrResult XRAPI_CALL xrRequestExitSession(XrSession session); XrResult XRAPI_CALL xrRequestMapLocalizationML(XrSession session, const XrMapLocalizationRequestInfoML *requestInfo); @@ -9204,6 +10581,7 @@ XrResult XRAPI_CALL xrSetColorSpaceFB(XrSession session, const XrColorSpaceFB co XrResult XRAPI_CALL xrSetDigitalLensControlALMALENCE(XrSession session, const XrDigitalLensControlALMALENCE *digitalLensControl); XrResult XRAPI_CALL xrSetEnvironmentDepthEstimationVARJO(XrSession session, XrBool32 enabled); XrResult XRAPI_CALL xrSetEnvironmentDepthHandRemovalMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider, const XrEnvironmentDepthHandRemovalSetInfoMETA *setInfo); +XrResult XRAPI_CALL xrSetFacialSimulationModeBD(XrFaceTrackerBD tracker, XrFacialSimulationModeBD mode); XrResult XRAPI_CALL xrSetInputDeviceActiveEXT(XrSession session, XrPath interactionProfile, XrPath topLevelPath, XrBool32 isActive); XrResult XRAPI_CALL xrSetInputDeviceLocationEXT(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, XrSpace space, XrPosef pose); XrResult XRAPI_CALL xrSetInputDeviceStateBoolEXT(XrSession session, XrPath topLevelPath, XrPath inputSourcePath, XrBool32 state); @@ -9212,9 +10590,12 @@ XrResult XRAPI_CALL xrSetInputDeviceStateVector2fEXT(XrSession session, XrPath t XrResult XRAPI_CALL xrSetMarkerTrackingPredictionVARJO(XrSession session, uint64_t markerId, XrBool32 enable); XrResult XRAPI_CALL xrSetMarkerTrackingTimeoutVARJO(XrSession session, uint64_t markerId, XrDuration timeout); XrResult XRAPI_CALL xrSetMarkerTrackingVARJO(XrSession session, XrBool32 enabled); +XrResult XRAPI_CALL xrSetPassthroughLayerMeshANDROID(XrPassthroughLayerANDROID layer, const XrPassthroughLayerMeshANDROID *mesh); +XrResult XRAPI_CALL xrSetPerformanceMetricsStateANDROID(XrSession session, const XrPerformanceMetricsStateANDROID *state); 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 xrSetTilePropertiesHintMETA(XrSession session, const XrTilePropertiesHintMETA *properties); 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); @@ -9236,6 +10617,8 @@ 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 xrSubmitSoundFieldBufferBD(XrSoundFieldBD soundField, const XrAudioBufferBD *buffer); +XrResult XRAPI_CALL xrSubmitSoundObjectBufferBD(XrSoundObjectBD soundObject, const XrAudioBufferBD *buffer); XrResult XRAPI_CALL xrSuggestBodyTrackingCalibrationOverrideMETA(XrBodyTrackerFB bodyTracker, const XrBodyTrackingCalibrationInfoMETA *calibrationInfo); XrResult XRAPI_CALL xrSuggestInteractionProfileBindings(XrInstance instance, const XrInteractionProfileSuggestedBinding *suggestedBindings); XrResult XRAPI_CALL xrSuggestVirtualKeyboardLocationMETA(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardLocationInfoMETA *locationInfo); @@ -9256,9 +10639,14 @@ XrResult XRAPI_CALL xrUnpersistSpatialEntityAsyncEXT(XrSpatialPersistenceContext XrResult XRAPI_CALL xrUnpersistSpatialEntityCompleteEXT(XrSpatialPersistenceContextEXT persistenceContext, XrFutureEXT future, XrUnpersistSpatialEntityCompletionEXT *completion); XrResult XRAPI_CALL xrUpdateHandMeshMSFT(XrHandTrackerEXT handTracker, const XrHandMeshUpdateInfoMSFT *updateInfo, XrHandMeshMSFT *handMesh); XrResult XRAPI_CALL xrUpdatePassthroughColorLutMETA(XrPassthroughColorLutMETA colorLut, const XrPassthroughColorLutUpdateInfoMETA *updateInfo); +XrResult XRAPI_CALL xrUpdateSoundFieldConfigBD(XrSoundFieldBD soundField, const XrSoundFieldConfigBD *config, XrSoundFieldFlagsBD flags); +XrResult XRAPI_CALL xrUpdateSoundObjectConfigBD(XrSoundObjectBD soundObject, const XrSoundObjectConfigBD *config, XrSoundObjectFlagsBD flags); +XrResult XRAPI_CALL xrUpdateSoundObstacleConfigBD(XrSoundObstacleBD soundObstacle, const XrSoundObstacleConfigBD *config, const XrSoundTriangleMeshBD *mesh, XrSoundObstacleFlagsBD flags); +XrResult XRAPI_CALL xrUpdateSoundObstacleMaterialConfigBD(XrSoundObstacleMaterialBD material, const XrSoundObstacleMaterialConfigBD *config); 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 xrWaitAudioPeriodBD(XrSpatialAudioRendererBD renderer, XrDuration timeout); XrResult XRAPI_CALL xrWaitFrame(XrSession session, const XrFrameWaitInfo *frameWaitInfo, XrFrameState *frameState); XrResult XRAPI_CALL xrWaitSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageWaitInfo *waitInfo); #endif /* XR_NO_PROTOTYPES */ diff --git a/wineopenxr/wineopenxr.json b/wineopenxr/wineopenxr.json index 8d12c7f044c..efa83922ccb 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.52" + "api_version": "1.1.58" } } diff --git a/xalia-fixups.gudl b/xalia-fixups.gudl index 136a8d32148..c897b3a9d9a 100644 --- a/xalia-fixups.gudl +++ b/xalia-fixups.gudl @@ -1,9 +1,2 @@ // Fixes applied to Xalia's main.gudl for Proton. Update these in xalia-fixups.gudl. -if (class_name == "GameNxApp") { - application_supports_gamepad: true; -} - -dialog (parent.is_root and root.child_matches(class_name == "GameNxApp").pid == pid) { - application_supports_gamepad: true; -}