wineopenxr: Update to 1.0.27 registry version.

CW-Bug-Id: #22244

wineopenxr/make_openxr

@@ -119,6 +119,20 @@ UNSUPPORTED_EXTENSIONS = [
     # Deprecated extensions
     "XR_NV_external_memory_capabilities",
     "XR_NV_external_memory_win32",
+
+    # Not widely supported extensions which require handler wrapping
+    "XR_MSFT_spatial_graph_bridge",
+    "XR_ML_compat",
+    "XR_MSFT_hand_tracking_mesh",
+    "XR_FB_keyboard_tracking",
+    "XR_VARJO_marker_tracking",
+    "XR_HTC_facial_tracking",
+    "XR_FB_face_tracking",
+    "XR_HTC_passthrough",
+    "XR_FB_eye_tracking_social",
+    "XR_FB_spatial_entity_user",
+    "XR_FB_body_tracking",
+    "XR_FB_spatial_entity",
 ]
 
 ALLOWED_PROTECTS = [
@@ -1333,7 +1347,7 @@ class XrParam(object):
                 self.format_conv = "wine_dbgstr_longlong({0})"
             elif self.type in ["uint16_t", "uint32_t", "XrBool32"]:
                 self.format_str = "%u"
-            elif self.type in ["uint64_t"]:
+            elif self.type in ["uint64_t","XrAsyncRequestIdFB"]:
                 self.format_str = "0x%s"
                 self.format_conv = "wine_dbgstr_longlong({0})"
             elif self.type == "HANDLE":
@@ -1630,10 +1644,13 @@ class XrStruct(Sequence):
         return decoupled_structs
 
     def typedef(self):
-        if self.union:
-            text = "typedef union {0} {0};\n".format(self.name)
+        if not self.is_alias():
+            if self.union:
+                text = "typedef union {0} {0};\n".format(self.name)
+            else:
+                text = "typedef struct {0} {0};\n".format(self.name)
         else:
-            text = "typedef struct {0} {0};\n".format(self.name)
+            text = ""
 
         for aliasee in self.aliased_by:
             text += "typedef {0} {1};\n".format(self.name, aliasee.name)

wineopenxr/openxr.c

@@ -2145,6 +2145,8 @@ static XrCompositionLayerBaseHeader *convert_XrCompositionLayer(wine_XrSession *
 {
     uint32_t i;
 
+    WINE_TRACE("Type %u, pNext %p.\n", in_layer->type, in_layer->next);
+
     switch(in_layer->type){
     case XR_TYPE_COMPOSITION_LAYER_CUBE_KHR: {
         out_layer->cube = *(const XrCompositionLayerCubeKHR *)in_layer;
@@ -2211,6 +2213,7 @@ static XrCompositionLayerBaseHeader *convert_XrCompositionLayer(wine_XrSession *
             ((XrCompositionLayerProjectionView *)view)->subImage.swapchain = ((wine_XrSwapchain *)view->subImage.swapchain)->swapchain;
             while (view->next)
             {
+                WINE_TRACE("Projection view type %u.\n", ((XrCompositionLayerProjectionView *)view->next)->type);
                 switch (((XrCompositionLayerProjectionView *)view->next)->type)
                 {
                     case XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR:

wineopenxr/openxr_thunks.c

@@ -3,7 +3,7 @@
  * This file is generated from OpenXR xr.xml file covered
  * by the following copyright and permission notice:
  *
- * Copyright (c) 2017-2021, The Khronos Group Inc.
+ * Copyright (c) 2017-2023, The Khronos Group Inc.
  *
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
@@ -30,16 +30,6 @@
 WINE_DEFAULT_DEBUG_CHANNEL(openxr);
 
 #if defined(USE_STRUCT_CONVERSION)
-static inline void convert_XrMarkerSpaceCreateInfoVARJO_win_to_host(const XrMarkerSpaceCreateInfoVARJO *in, XrMarkerSpaceCreateInfoVARJO_host *out)
-{
-    if (!in) return;
-
-    out->type = in->type;
-    out->next = in->next;
-    out->markerId = in->markerId;
-    out->poseInMarkerSpace = in->poseInMarkerSpace;
-}
-
 static inline void convert_XrSceneMeshBuffersGetInfoMSFT_win_to_host(const XrSceneMeshBuffersGetInfoMSFT *in, XrSceneMeshBuffersGetInfoMSFT_host *out)
 {
     if (!in) return;
@@ -93,6 +83,18 @@ XrResult WINAPI wine_xrAcquireSwapchainImage(XrSwapchain swapchain, const XrSwap
     return xrAcquireSwapchainImage(((wine_XrSwapchain *)swapchain)->swapchain, acquireInfo, index);
 }
 
+static XrResult WINAPI wine_xrApplyForceFeedbackCurlMNDX(XrHandTrackerEXT handTracker, const XrForceFeedbackCurlApplyLocationsMNDX *locations)
+{
+    WINE_TRACE("%p, %p\n", handTracker, locations);
+    return ((wine_XrHandTrackerEXT *)handTracker)->wine_session->wine_instance->funcs.p_xrApplyForceFeedbackCurlMNDX(((wine_XrHandTrackerEXT *)handTracker)->hand_tracker, locations);
+}
+
+static XrResult WINAPI wine_xrApplyFoveationHTC(XrSession session, const XrFoveationApplyInfoHTC *applyInfo)
+{
+    WINE_TRACE("%p, %p\n", session, applyInfo);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrApplyFoveationHTC(((wine_XrSession *)session)->session, applyInfo);
+}
+
 XrResult WINAPI wine_xrApplyHapticFeedback(XrSession session, const XrHapticActionInfo *hapticActionInfo, const XrHapticBaseHeader *hapticFeedback)
 {
     WINE_TRACE("%p, %p, %p\n", session, hapticActionInfo, hapticFeedback);
@@ -147,29 +149,6 @@ XrResult WINAPI wine_xrCreateActionSpace(XrSession session, const XrActionSpaceC
     return xrCreateActionSpace(((wine_XrSession *)session)->session, createInfo, space);
 }
 
-static XrResult WINAPI wine_xrCreateHandMeshSpaceMSFT(XrHandTrackerEXT handTracker, const XrHandMeshSpaceCreateInfoMSFT *createInfo, XrSpace *space)
-{
-    WINE_TRACE("%p, %p, %p\n", handTracker, createInfo, space);
-    return ((wine_XrHandTrackerEXT *)handTracker)->wine_session->wine_instance->funcs.p_xrCreateHandMeshSpaceMSFT(((wine_XrHandTrackerEXT *)handTracker)->hand_tracker, createInfo, space);
-}
-
-static XrResult WINAPI wine_xrCreateMarkerSpaceVARJO(XrSession session, const XrMarkerSpaceCreateInfoVARJO *createInfo, XrSpace *space)
-{
-#if defined(USE_STRUCT_CONVERSION)
-    XrResult result;
-    XrMarkerSpaceCreateInfoVARJO_host createInfo_host;
-    WINE_TRACE("%p, %p, %p\n", session, createInfo, space);
-
-    convert_XrMarkerSpaceCreateInfoVARJO_win_to_host(createInfo, &createInfo_host);
-    result = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateMarkerSpaceVARJO(((wine_XrSession *)session)->session, &createInfo_host, space);
-
-    return result;
-#else
-    WINE_TRACE("%p, %p, %p\n", session, createInfo, space);
-    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateMarkerSpaceVARJO(((wine_XrSession *)session)->session, createInfo, space);
-#endif
-}
-
 XrResult WINAPI wine_xrCreateReferenceSpace(XrSession session, const XrReferenceSpaceCreateInfo *createInfo, XrSpace *space)
 {
     WINE_TRACE("%p, %p, %p\n", session, createInfo, space);
@@ -182,12 +161,6 @@ static XrResult WINAPI wine_xrCreateSpatialAnchorSpaceMSFT(XrSession session, co
     return ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateSpatialAnchorSpaceMSFT(((wine_XrSession *)session)->session, createInfo, space);
 }
 
-static XrResult WINAPI wine_xrCreateSpatialGraphNodeSpaceMSFT(XrSession session, const XrSpatialGraphNodeSpaceCreateInfoMSFT *createInfo, XrSpace *space)
-{
-    WINE_TRACE("%p, %p, %p\n", session, createInfo, space);
-    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateSpatialGraphNodeSpaceMSFT(((wine_XrSession *)session)->session, createInfo, space);
-}
-
 static XrResult WINAPI wine_xrDeserializeSceneMSFT(XrSceneObserverMSFT sceneObserver, const XrSceneDeserializeInfoMSFT *deserializeInfo)
 {
     WINE_TRACE("%p, %p\n", sceneObserver, deserializeInfo);
@@ -248,6 +221,18 @@ XrResult WINAPI wine_xrEnumerateEnvironmentBlendModes(XrInstance instance, XrSys
     return xrEnumerateEnvironmentBlendModes(((wine_XrInstance *)instance)->instance, systemId, viewConfigurationType, environmentBlendModeCapacityInput, environmentBlendModeCountOutput, environmentBlendModes);
 }
 
+static XrResult WINAPI wine_xrEnumerateExternalCamerasOCULUS(XrSession session, uint32_t cameraCapacityInput, uint32_t *cameraCountOutput, XrExternalCameraOCULUS *cameras)
+{
+    WINE_TRACE("%p, %u, %p, %p\n", session, cameraCapacityInput, cameraCountOutput, cameras);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrEnumerateExternalCamerasOCULUS(((wine_XrSession *)session)->session, cameraCapacityInput, cameraCountOutput, cameras);
+}
+
+static XrResult WINAPI wine_xrEnumeratePerformanceMetricsCounterPathsMETA(XrInstance instance, uint32_t counterPathCapacityInput, uint32_t *counterPathCountOutput, XrPath *counterPaths)
+{
+    WINE_TRACE("%p, %u, %p, %p\n", instance, counterPathCapacityInput, counterPathCountOutput, counterPaths);
+    return ((wine_XrInstance *)instance)->funcs.p_xrEnumeratePerformanceMetricsCounterPathsMETA(((wine_XrInstance *)instance)->instance, counterPathCapacityInput, counterPathCountOutput, counterPaths);
+}
+
 static XrResult WINAPI wine_xrEnumeratePersistedSpatialAnchorNamesMSFT(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, uint32_t spatialAnchorNamesCapacityInput, uint32_t *spatialAnchorNamesCountOutput, XrSpatialAnchorPersistenceNameMSFT *persistedAnchorNames)
 {
     WINE_TRACE("%p, %u, %p, %p\n", spatialAnchorStore, spatialAnchorNamesCapacityInput, spatialAnchorNamesCountOutput, persistedAnchorNames);
@@ -260,6 +245,12 @@ XrResult WINAPI wine_xrEnumerateReferenceSpaces(XrSession session, uint32_t spac
     return xrEnumerateReferenceSpaces(((wine_XrSession *)session)->session, spaceCapacityInput, spaceCountOutput, spaces);
 }
 
+static XrResult WINAPI wine_xrEnumerateRenderModelPathsFB(XrSession session, uint32_t pathCapacityInput, uint32_t *pathCountOutput, XrRenderModelPathInfoFB *paths)
+{
+    WINE_TRACE("%p, %u, %p, %p\n", session, pathCapacityInput, pathCountOutput, paths);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrEnumerateRenderModelPathsFB(((wine_XrSession *)session)->session, pathCapacityInput, pathCountOutput, paths);
+}
+
 static XrResult WINAPI wine_xrEnumerateReprojectionModesMSFT(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, uint32_t modeCapacityInput, uint32_t *modeCountOutput, XrReprojectionModeMSFT *modes)
 {
     WINE_TRACE("%p, 0x%s, %#x, %u, %p, %p\n", instance, wine_dbgstr_longlong(systemId), viewConfigurationType, modeCapacityInput, modeCountOutput, modes);
@@ -356,12 +347,24 @@ XrResult WINAPI wine_xrGetCurrentInteractionProfile(XrSession session, XrPath to
     return xrGetCurrentInteractionProfile(((wine_XrSession *)session)->session, topLevelUserPath, interactionProfile);
 }
 
+static XrResult WINAPI wine_xrGetDeviceSampleRateFB(XrSession session, const XrHapticActionInfo *hapticActionInfo, XrDevicePcmSampleRateGetInfoFB *deviceSampleRate)
+{
+    WINE_TRACE("%p, %p, %p\n", session, hapticActionInfo, deviceSampleRate);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetDeviceSampleRateFB(((wine_XrSession *)session)->session, hapticActionInfo, deviceSampleRate);
+}
+
 static XrResult WINAPI wine_xrGetDisplayRefreshRateFB(XrSession session, float *displayRefreshRate)
 {
     WINE_TRACE("%p, %p\n", session, displayRefreshRate);
     return ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetDisplayRefreshRateFB(((wine_XrSession *)session)->session, displayRefreshRate);
 }
 
+static XrResult WINAPI wine_xrGetFoveationEyeTrackedStateMETA(XrSession session, XrFoveationEyeTrackedStateMETA *foveationState)
+{
+    WINE_TRACE("%p, %p\n", session, foveationState);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetFoveationEyeTrackedStateMETA(((wine_XrSession *)session)->session, foveationState);
+}
+
 static XrResult WINAPI wine_xrGetHandMeshFB(XrHandTrackerEXT handTracker, XrHandTrackingMeshFB *mesh)
 {
     WINE_TRACE("%p, %p\n", handTracker, mesh);
@@ -380,24 +383,30 @@ XrResult WINAPI wine_xrGetInstanceProperties(XrInstance instance, XrInstanceProp
     return xrGetInstanceProperties(((wine_XrInstance *)instance)->instance, instanceProperties);
 }
 
-static XrResult WINAPI wine_xrGetMarkerSizeVARJO(XrSession session, uint64_t markerId, XrExtent2Df *size)
-{
-    WINE_TRACE("%p, 0x%s, %p\n", session, wine_dbgstr_longlong(markerId), size);
-    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetMarkerSizeVARJO(((wine_XrSession *)session)->session, markerId, size);
-}
-
 static XrResult WINAPI wine_xrGetOpenGLGraphicsRequirementsKHR(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsOpenGLKHR *graphicsRequirements)
 {
     WINE_TRACE("%p, 0x%s, %p\n", instance, wine_dbgstr_longlong(systemId), graphicsRequirements);
     return ((wine_XrInstance *)instance)->funcs.p_xrGetOpenGLGraphicsRequirementsKHR(((wine_XrInstance *)instance)->instance, systemId, graphicsRequirements);
 }
 
+static XrResult WINAPI wine_xrGetPerformanceMetricsStateMETA(XrSession session, XrPerformanceMetricsStateMETA *state)
+{
+    WINE_TRACE("%p, %p\n", session, state);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetPerformanceMetricsStateMETA(((wine_XrSession *)session)->session, state);
+}
+
 XrResult WINAPI wine_xrGetReferenceSpaceBoundsRect(XrSession session, XrReferenceSpaceType referenceSpaceType, XrExtent2Df *bounds)
 {
     WINE_TRACE("%p, %#x, %p\n", session, referenceSpaceType, bounds);
     return xrGetReferenceSpaceBoundsRect(((wine_XrSession *)session)->session, referenceSpaceType, bounds);
 }
 
+static XrResult WINAPI wine_xrGetRenderModelPropertiesFB(XrSession session, XrPath path, XrRenderModelPropertiesFB *properties)
+{
+    WINE_TRACE("%p, 0x%s, %p\n", session, wine_dbgstr_longlong(path), properties);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetRenderModelPropertiesFB(((wine_XrSession *)session)->session, path, properties);
+}
+
 static XrResult WINAPI wine_xrGetSceneComponentsMSFT(XrSceneMSFT scene, const XrSceneComponentsGetInfoMSFT *getInfo, XrSceneComponentsMSFT *components)
 {
     WINE_TRACE("%p, %p, %p\n", scene, getInfo, components);
@@ -475,6 +484,12 @@ static XrResult WINAPI wine_xrLoadControllerModelMSFT(XrSession session, XrContr
     return ((wine_XrSession *)session)->wine_instance->funcs.p_xrLoadControllerModelMSFT(((wine_XrSession *)session)->session, modelKey, bufferCapacityInput, bufferCountOutput, buffer);
 }
 
+static XrResult WINAPI wine_xrLoadRenderModelFB(XrSession session, const XrRenderModelLoadInfoFB *info, XrRenderModelBufferFB *buffer)
+{
+    WINE_TRACE("%p, %p, %p\n", session, info, buffer);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrLoadRenderModelFB(((wine_XrSession *)session)->session, info, buffer);
+}
+
 static XrResult WINAPI wine_xrLocateHandJointsEXT(XrHandTrackerEXT handTracker, const XrHandJointsLocateInfoEXT *locateInfo, XrHandJointLocationsEXT *locations)
 {
     WINE_TRACE("%p, %p, %p\n", handTracker, locateInfo, locations);
@@ -511,6 +526,12 @@ static XrResult WINAPI wine_xrPassthroughLayerResumeFB(XrPassthroughLayerFB laye
     return ((wine_XrPassthroughLayerFB *)layer)->wine_session->wine_instance->funcs.p_xrPassthroughLayerResumeFB(((wine_XrPassthroughLayerFB *)layer)->layer);
 }
 
+static XrResult WINAPI wine_xrPassthroughLayerSetKeyboardHandsIntensityFB(XrPassthroughLayerFB layer, const XrPassthroughKeyboardHandsIntensityFB *intensity)
+{
+    WINE_TRACE("%p, %p\n", layer, intensity);
+    return ((wine_XrPassthroughLayerFB *)layer)->wine_session->wine_instance->funcs.p_xrPassthroughLayerSetKeyboardHandsIntensityFB(((wine_XrPassthroughLayerFB *)layer)->layer, intensity);
+}
+
 static XrResult WINAPI wine_xrPassthroughLayerSetStyleFB(XrPassthroughLayerFB layer, const XrPassthroughStyleFB *style)
 {
     WINE_TRACE("%p, %p\n", layer, style);
@@ -547,6 +568,18 @@ static XrResult WINAPI wine_xrPersistSpatialAnchorMSFT(XrSpatialAnchorStoreConne
     return ((wine_XrSpatialAnchorStoreConnectionMSFT *)spatialAnchorStore)->wine_session->wine_instance->funcs.p_xrPersistSpatialAnchorMSFT(((wine_XrSpatialAnchorStoreConnectionMSFT *)spatialAnchorStore)->spatial_anchor_store_connection, spatialAnchorPersistenceInfo);
 }
 
+static XrResult WINAPI wine_xrQueryPerformanceMetricsCounterMETA(XrSession session, XrPath counterPath, XrPerformanceMetricsCounterMETA *counter)
+{
+    WINE_TRACE("%p, 0x%s, %p\n", session, wine_dbgstr_longlong(counterPath), counter);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrQueryPerformanceMetricsCounterMETA(((wine_XrSession *)session)->session, counterPath, counter);
+}
+
+static XrResult WINAPI wine_xrQuerySpacesFB(XrSession session, const XrSpaceQueryInfoBaseHeaderFB *info, XrAsyncRequestIdFB *requestId)
+{
+    WINE_TRACE("%p, %p, %p\n", session, info, requestId);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrQuerySpacesFB(((wine_XrSession *)session)->session, info, requestId);
+}
+
 XrResult WINAPI wine_xrReleaseSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageReleaseInfo *releaseInfo)
 {
     WINE_TRACE("%p, %p\n", swapchain, releaseInfo);
@@ -565,18 +598,42 @@ XrResult WINAPI wine_xrRequestExitSession(XrSession session)
     return xrRequestExitSession(((wine_XrSession *)session)->session);
 }
 
+static XrResult WINAPI wine_xrRequestSceneCaptureFB(XrSession session, const XrSceneCaptureRequestInfoFB *info, XrAsyncRequestIdFB *requestId)
+{
+    WINE_TRACE("%p, %p, %p\n", session, info, requestId);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrRequestSceneCaptureFB(((wine_XrSession *)session)->session, info, requestId);
+}
+
 XrResult WINAPI wine_xrResultToString(XrInstance instance, XrResult value, char buffer[])
 {
     WINE_TRACE("%p, %#x, %p\n", instance, value, buffer);
     return xrResultToString(((wine_XrInstance *)instance)->instance, value, buffer);
 }
 
+static XrResult WINAPI wine_xrRetrieveSpaceQueryResultsFB(XrSession session, XrAsyncRequestIdFB requestId, XrSpaceQueryResultsFB *results)
+{
+    WINE_TRACE("%p, 0x%s, %p\n", session, wine_dbgstr_longlong(requestId), results);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrRetrieveSpaceQueryResultsFB(((wine_XrSession *)session)->session, requestId, results);
+}
+
+static XrResult WINAPI wine_xrSaveSpaceListFB(XrSession session, const XrSpaceListSaveInfoFB *info, XrAsyncRequestIdFB *requestId)
+{
+    WINE_TRACE("%p, %p, %p\n", session, info, requestId);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrSaveSpaceListFB(((wine_XrSession *)session)->session, info, requestId);
+}
+
 static XrResult WINAPI wine_xrSetColorSpaceFB(XrSession session, const XrColorSpaceFB colorspace)
 {
     WINE_TRACE("%p, %#x\n", session, colorspace);
     return ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetColorSpaceFB(((wine_XrSession *)session)->session, colorspace);
 }
 
+static XrResult WINAPI wine_xrSetDigitalLensControlALMALENCE(XrSession session, const XrDigitalLensControlALMALENCE *digitalLensControl)
+{
+    WINE_TRACE("%p, %p\n", session, digitalLensControl);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetDigitalLensControlALMALENCE(((wine_XrSession *)session)->session, digitalLensControl);
+}
+
 static XrResult WINAPI wine_xrSetEnvironmentDepthEstimationVARJO(XrSession session, XrBool32 enabled)
 {
     WINE_TRACE("%p, %u\n", session, enabled);
@@ -613,22 +670,22 @@ static XrResult WINAPI wine_xrSetInputDeviceStateVector2fEXT(XrSession session,
     return ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetInputDeviceStateVector2fEXT(((wine_XrSession *)session)->session, topLevelPath, inputSourcePath, state);
 }
 
-static XrResult WINAPI wine_xrSetMarkerTrackingPredictionVARJO(XrSession session, uint64_t markerId, XrBool32 enabled)
+static XrResult WINAPI wine_xrSetPerformanceMetricsStateMETA(XrSession session, const XrPerformanceMetricsStateMETA *state)
 {
-    WINE_TRACE("%p, 0x%s, %u\n", session, wine_dbgstr_longlong(markerId), enabled);
-    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetMarkerTrackingPredictionVARJO(((wine_XrSession *)session)->session, markerId, enabled);
+    WINE_TRACE("%p, %p\n", session, state);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetPerformanceMetricsStateMETA(((wine_XrSession *)session)->session, state);
 }
 
-static XrResult WINAPI wine_xrSetMarkerTrackingTimeoutVARJO(XrSession session, uint64_t markerId, XrDuration timeout)
+static XrResult WINAPI wine_xrSetTrackingOptimizationSettingsHintQCOM(XrSession session, XrTrackingOptimizationSettingsDomainQCOM domain, XrTrackingOptimizationSettingsHintQCOM hint)
 {
-    WINE_TRACE("%p, 0x%s, 0x%s\n", session, wine_dbgstr_longlong(markerId), wine_dbgstr_longlong(timeout));
-    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetMarkerTrackingTimeoutVARJO(((wine_XrSession *)session)->session, markerId, timeout);
+    WINE_TRACE("%p, %#x, %#x\n", session, domain, hint);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetTrackingOptimizationSettingsHintQCOM(((wine_XrSession *)session)->session, domain, hint);
 }
 
-static XrResult WINAPI wine_xrSetMarkerTrackingVARJO(XrSession session, XrBool32 enabled)
+static XrResult WINAPI wine_xrSetViewOffsetVARJO(XrSession session, float offset)
 {
-    WINE_TRACE("%p, %u\n", session, enabled);
-    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetMarkerTrackingVARJO(((wine_XrSession *)session)->session, enabled);
+    WINE_TRACE("%p, %f\n", session, offset);
+    return ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetViewOffsetVARJO(((wine_XrSession *)session)->session, offset);
 }
 
 XrResult WINAPI wine_xrStopHapticFeedback(XrSession session, const XrHapticActionInfo *hapticActionInfo)
@@ -709,12 +766,6 @@ static XrResult WINAPI wine_xrUnpersistSpatialAnchorMSFT(XrSpatialAnchorStoreCon
     return ((wine_XrSpatialAnchorStoreConnectionMSFT *)spatialAnchorStore)->wine_session->wine_instance->funcs.p_xrUnpersistSpatialAnchorMSFT(((wine_XrSpatialAnchorStoreConnectionMSFT *)spatialAnchorStore)->spatial_anchor_store_connection, spatialAnchorPersistenceName);
 }
 
-static XrResult WINAPI wine_xrUpdateHandMeshMSFT(XrHandTrackerEXT handTracker, const XrHandMeshUpdateInfoMSFT *updateInfo, XrHandMeshMSFT *handMesh)
-{
-    WINE_TRACE("%p, %p, %p\n", handTracker, updateInfo, handMesh);
-    return ((wine_XrHandTrackerEXT *)handTracker)->wine_session->wine_instance->funcs.p_xrUpdateHandMeshMSFT(((wine_XrHandTrackerEXT *)handTracker)->hand_tracker, updateInfo, handMesh);
-}
-
 static XrResult WINAPI wine_xrUpdateSwapchainFB(XrSwapchain swapchain, const XrSwapchainStateBaseHeaderFB *state)
 {
     WINE_TRACE("%p, %p\n", swapchain, state);
@@ -736,6 +787,8 @@ XrResult WINAPI wine_xrWaitSwapchainImage(XrSwapchain swapchain, const XrSwapcha
 static const struct openxr_func xr_dispatch_table[] =
 {
     {"xrAcquireSwapchainImage", &wine_xrAcquireSwapchainImage},
+    {"xrApplyForceFeedbackCurlMNDX", &wine_xrApplyForceFeedbackCurlMNDX},
+    {"xrApplyFoveationHTC", &wine_xrApplyFoveationHTC},
     {"xrApplyHapticFeedback", &wine_xrApplyHapticFeedback},
     {"xrAttachSessionActionSets", &wine_xrAttachSessionActionSets},
     {"xrBeginFrame", &wine_xrBeginFrame},
@@ -749,10 +802,8 @@ static const struct openxr_func xr_dispatch_table[] =
     {"xrCreateActionSpace", &wine_xrCreateActionSpace},
     {"xrCreateFoveationProfileFB", &wine_xrCreateFoveationProfileFB},
     {"xrCreateGeometryInstanceFB", &wine_xrCreateGeometryInstanceFB},
-    {"xrCreateHandMeshSpaceMSFT", &wine_xrCreateHandMeshSpaceMSFT},
     {"xrCreateHandTrackerEXT", &wine_xrCreateHandTrackerEXT},
     {"xrCreateInstance", &wine_xrCreateInstance},
-    {"xrCreateMarkerSpaceVARJO", &wine_xrCreateMarkerSpaceVARJO},
     {"xrCreatePassthroughFB", &wine_xrCreatePassthroughFB},
     {"xrCreatePassthroughLayerFB", &wine_xrCreatePassthroughLayerFB},
     {"xrCreateReferenceSpace", &wine_xrCreateReferenceSpace},
@@ -763,7 +814,6 @@ static const struct openxr_func xr_dispatch_table[] =
     {"xrCreateSpatialAnchorMSFT", &wine_xrCreateSpatialAnchorMSFT},
     {"xrCreateSpatialAnchorSpaceMSFT", &wine_xrCreateSpatialAnchorSpaceMSFT},
     {"xrCreateSpatialAnchorStoreConnectionMSFT", &wine_xrCreateSpatialAnchorStoreConnectionMSFT},
-    {"xrCreateSpatialGraphNodeSpaceMSFT", &wine_xrCreateSpatialGraphNodeSpaceMSFT},
     {"xrCreateSwapchain", &wine_xrCreateSwapchain},
     {"xrCreateTriangleMeshFB", &wine_xrCreateTriangleMeshFB},
     {"xrCreateVulkanDeviceKHR", &wine_xrCreateVulkanDeviceKHR},
@@ -792,9 +842,12 @@ static const struct openxr_func xr_dispatch_table[] =
     {"xrEnumerateColorSpacesFB", &wine_xrEnumerateColorSpacesFB},
     {"xrEnumerateDisplayRefreshRatesFB", &wine_xrEnumerateDisplayRefreshRatesFB},
     {"xrEnumerateEnvironmentBlendModes", &wine_xrEnumerateEnvironmentBlendModes},
+    {"xrEnumerateExternalCamerasOCULUS", &wine_xrEnumerateExternalCamerasOCULUS},
     {"xrEnumerateInstanceExtensionProperties", &wine_xrEnumerateInstanceExtensionProperties},
+    {"xrEnumeratePerformanceMetricsCounterPathsMETA", &wine_xrEnumeratePerformanceMetricsCounterPathsMETA},
     {"xrEnumeratePersistedSpatialAnchorNamesMSFT", &wine_xrEnumeratePersistedSpatialAnchorNamesMSFT},
     {"xrEnumerateReferenceSpaces", &wine_xrEnumerateReferenceSpaces},
+    {"xrEnumerateRenderModelPathsFB", &wine_xrEnumerateRenderModelPathsFB},
     {"xrEnumerateReprojectionModesMSFT", &wine_xrEnumerateReprojectionModesMSFT},
     {"xrEnumerateSceneComputeFeaturesMSFT", &wine_xrEnumerateSceneComputeFeaturesMSFT},
     {"xrEnumerateSwapchainFormats", &wine_xrEnumerateSwapchainFormats},
@@ -815,14 +868,17 @@ static const struct openxr_func xr_dispatch_table[] =
     {"xrGetCurrentInteractionProfile", &wine_xrGetCurrentInteractionProfile},
     {"xrGetD3D11GraphicsRequirementsKHR", &wine_xrGetD3D11GraphicsRequirementsKHR},
     {"xrGetD3D12GraphicsRequirementsKHR", &wine_xrGetD3D12GraphicsRequirementsKHR},
+    {"xrGetDeviceSampleRateFB", &wine_xrGetDeviceSampleRateFB},
     {"xrGetDisplayRefreshRateFB", &wine_xrGetDisplayRefreshRateFB},
+    {"xrGetFoveationEyeTrackedStateMETA", &wine_xrGetFoveationEyeTrackedStateMETA},
     {"xrGetHandMeshFB", &wine_xrGetHandMeshFB},
     {"xrGetInputSourceLocalizedName", &wine_xrGetInputSourceLocalizedName},
     {"xrGetInstanceProcAddr", &wine_xrGetInstanceProcAddr},
     {"xrGetInstanceProperties", &wine_xrGetInstanceProperties},
-    {"xrGetMarkerSizeVARJO", &wine_xrGetMarkerSizeVARJO},
     {"xrGetOpenGLGraphicsRequirementsKHR", &wine_xrGetOpenGLGraphicsRequirementsKHR},
+    {"xrGetPerformanceMetricsStateMETA", &wine_xrGetPerformanceMetricsStateMETA},
     {"xrGetReferenceSpaceBoundsRect", &wine_xrGetReferenceSpaceBoundsRect},
+    {"xrGetRenderModelPropertiesFB", &wine_xrGetRenderModelPropertiesFB},
     {"xrGetSceneComponentsMSFT", &wine_xrGetSceneComponentsMSFT},
     {"xrGetSceneComputeStateMSFT", &wine_xrGetSceneComputeStateMSFT},
     {"xrGetSceneMeshBuffersMSFT", &wine_xrGetSceneMeshBuffersMSFT},
@@ -839,12 +895,14 @@ static const struct openxr_func xr_dispatch_table[] =
     {"xrGetVulkanGraphicsRequirementsKHR", &wine_xrGetVulkanGraphicsRequirementsKHR},
     {"xrGetVulkanInstanceExtensionsKHR", &wine_xrGetVulkanInstanceExtensionsKHR},
     {"xrLoadControllerModelMSFT", &wine_xrLoadControllerModelMSFT},
+    {"xrLoadRenderModelFB", &wine_xrLoadRenderModelFB},
     {"xrLocateHandJointsEXT", &wine_xrLocateHandJointsEXT},
     {"xrLocateSceneComponentsMSFT", &wine_xrLocateSceneComponentsMSFT},
     {"xrLocateSpace", &wine_xrLocateSpace},
     {"xrLocateViews", &wine_xrLocateViews},
     {"xrPassthroughLayerPauseFB", &wine_xrPassthroughLayerPauseFB},
     {"xrPassthroughLayerResumeFB", &wine_xrPassthroughLayerResumeFB},
+    {"xrPassthroughLayerSetKeyboardHandsIntensityFB", &wine_xrPassthroughLayerSetKeyboardHandsIntensityFB},
     {"xrPassthroughLayerSetStyleFB", &wine_xrPassthroughLayerSetStyleFB},
     {"xrPassthroughPauseFB", &wine_xrPassthroughPauseFB},
     {"xrPassthroughStartFB", &wine_xrPassthroughStartFB},
@@ -852,20 +910,26 @@ static const struct openxr_func xr_dispatch_table[] =
     {"xrPerfSettingsSetPerformanceLevelEXT", &wine_xrPerfSettingsSetPerformanceLevelEXT},
     {"xrPersistSpatialAnchorMSFT", &wine_xrPersistSpatialAnchorMSFT},
     {"xrPollEvent", &wine_xrPollEvent},
+    {"xrQueryPerformanceMetricsCounterMETA", &wine_xrQueryPerformanceMetricsCounterMETA},
+    {"xrQuerySpacesFB", &wine_xrQuerySpacesFB},
     {"xrReleaseSwapchainImage", &wine_xrReleaseSwapchainImage},
     {"xrRequestDisplayRefreshRateFB", &wine_xrRequestDisplayRefreshRateFB},
     {"xrRequestExitSession", &wine_xrRequestExitSession},
+    {"xrRequestSceneCaptureFB", &wine_xrRequestSceneCaptureFB},
     {"xrResultToString", &wine_xrResultToString},
+    {"xrRetrieveSpaceQueryResultsFB", &wine_xrRetrieveSpaceQueryResultsFB},
+    {"xrSaveSpaceListFB", &wine_xrSaveSpaceListFB},
     {"xrSetColorSpaceFB", &wine_xrSetColorSpaceFB},
+    {"xrSetDigitalLensControlALMALENCE", &wine_xrSetDigitalLensControlALMALENCE},
     {"xrSetEnvironmentDepthEstimationVARJO", &wine_xrSetEnvironmentDepthEstimationVARJO},
     {"xrSetInputDeviceActiveEXT", &wine_xrSetInputDeviceActiveEXT},
     {"xrSetInputDeviceLocationEXT", &wine_xrSetInputDeviceLocationEXT},
     {"xrSetInputDeviceStateBoolEXT", &wine_xrSetInputDeviceStateBoolEXT},
     {"xrSetInputDeviceStateFloatEXT", &wine_xrSetInputDeviceStateFloatEXT},
     {"xrSetInputDeviceStateVector2fEXT", &wine_xrSetInputDeviceStateVector2fEXT},
-    {"xrSetMarkerTrackingPredictionVARJO", &wine_xrSetMarkerTrackingPredictionVARJO},
-    {"xrSetMarkerTrackingTimeoutVARJO", &wine_xrSetMarkerTrackingTimeoutVARJO},
-    {"xrSetMarkerTrackingVARJO", &wine_xrSetMarkerTrackingVARJO},
+    {"xrSetPerformanceMetricsStateMETA", &wine_xrSetPerformanceMetricsStateMETA},
+    {"xrSetTrackingOptimizationSettingsHintQCOM", &wine_xrSetTrackingOptimizationSettingsHintQCOM},
+    {"xrSetViewOffsetVARJO", &wine_xrSetViewOffsetVARJO},
     {"xrStopHapticFeedback", &wine_xrStopHapticFeedback},
     {"xrStringToPath", &wine_xrStringToPath},
     {"xrStructureTypeToString", &wine_xrStructureTypeToString},
@@ -879,7 +943,6 @@ static const struct openxr_func xr_dispatch_table[] =
     {"xrTriangleMeshGetIndexBufferFB", &wine_xrTriangleMeshGetIndexBufferFB},
     {"xrTriangleMeshGetVertexBufferFB", &wine_xrTriangleMeshGetVertexBufferFB},
     {"xrUnpersistSpatialAnchorMSFT", &wine_xrUnpersistSpatialAnchorMSFT},
-    {"xrUpdateHandMeshMSFT", &wine_xrUpdateHandMeshMSFT},
     {"xrUpdateSwapchainFB", &wine_xrUpdateSwapchainFB},
     {"xrWaitFrame", &wine_xrWaitFrame},
     {"xrWaitSwapchainImage", &wine_xrWaitSwapchainImage},
@@ -901,22 +964,31 @@ void *wine_xr_proc_addr(const char *name)
 
 static const char * const xr_extensions[] =
 {
+    "XR_ALMALENCE_digital_lens_control",
+    "XR_BD_controller_interaction",
     "XR_EPIC_view_configuration_fov",
     "XR_EXTX_overlay",
+    "XR_EXT_active_action_set_priority",
     "XR_EXT_conformance_automation",
+    "XR_EXT_dpad_binding",
     "XR_EXT_eye_gaze_interaction",
     "XR_EXT_hand_joints_motion_range",
     "XR_EXT_hand_tracking",
     "XR_EXT_hp_mixed_reality_controller",
+    "XR_EXT_local_floor",
+    "XR_EXT_palm_pose",
     "XR_EXT_performance_settings",
     "XR_EXT_samsung_odyssey_controller",
     "XR_EXT_thermal_query",
+    "XR_EXT_uuid",
     "XR_EXT_view_configuration_depth_range",
     "XR_EXT_win32_appcontainer_compatible",
     "XR_FB_color_space",
     "XR_FB_composition_layer_alpha_blend",
+    "XR_FB_composition_layer_depth_test",
     "XR_FB_composition_layer_image_layout",
     "XR_FB_composition_layer_secure_content",
+    "XR_FB_composition_layer_settings",
     "XR_FB_display_refresh_rate",
     "XR_FB_foveation",
     "XR_FB_foveation_configuration",
@@ -924,13 +996,26 @@ static const char * const xr_extensions[] =
     "XR_FB_hand_tracking_aim",
     "XR_FB_hand_tracking_capsules",
     "XR_FB_hand_tracking_mesh",
+    "XR_FB_haptic_amplitude_envelope",
+    "XR_FB_haptic_pcm",
     "XR_FB_passthrough",
+    "XR_FB_passthrough_keyboard_hands",
+    "XR_FB_render_model",
+    "XR_FB_scene_capture",
     "XR_FB_space_warp",
+    "XR_FB_spatial_entity_query",
+    "XR_FB_spatial_entity_storage_batch",
     "XR_FB_swapchain_update_state",
     "XR_FB_swapchain_update_state_vulkan",
+    "XR_FB_touch_controller_pro",
+    "XR_FB_touch_controller_proximity",
     "XR_FB_triangle_mesh",
     "XR_HTCX_vive_tracker_interaction",
+    "XR_HTC_foveation",
+    "XR_HTC_hand_interaction",
     "XR_HTC_vive_cosmos_controller_interaction",
+    "XR_HTC_vive_focus3_controller_interaction",
+    "XR_HTC_vive_wrist_tracker_interaction",
     "XR_HUAWEI_controller_interaction",
     "XR_KHR_D3D11_enable",
     "XR_KHR_D3D12_enable",
@@ -948,29 +1033,39 @@ static const char * const xr_extensions[] =
     "XR_KHR_vulkan_enable2",
     "XR_KHR_vulkan_swapchain_format_list",
     "XR_KHR_win32_convert_performance_counter_time",
+    "XR_META_foveation_eye_tracked",
+    "XR_META_headset_id",
+    "XR_META_local_dimming",
+    "XR_META_performance_metrics",
+    "XR_META_vulkan_swapchain_create_info",
+    "XR_ML_frame_end_info",
+    "XR_ML_global_dimmer",
+    "XR_ML_ml2_controller_interaction",
+    "XR_MNDX_force_feedback_curl",
     "XR_MND_headless",
     "XR_MND_swapchain_usage_input_attachment_bit",
     "XR_MSFT_composition_layer_reprojection",
     "XR_MSFT_controller_model",
     "XR_MSFT_first_person_observer",
     "XR_MSFT_hand_interaction",
-    "XR_MSFT_hand_tracking_mesh",
     "XR_MSFT_holographic_window_attachment",
     "XR_MSFT_scene_understanding",
     "XR_MSFT_scene_understanding_serialization",
     "XR_MSFT_secondary_view_configuration",
     "XR_MSFT_spatial_anchor",
     "XR_MSFT_spatial_anchor_persistence",
-    "XR_MSFT_spatial_graph_bridge",
     "XR_MSFT_unbounded_reference_space",
     "XR_OCULUS_android_session_state_enable",
     "XR_OCULUS_audio_device_guid",
+    "XR_OCULUS_external_camera",
+    "XR_QCOM_tracking_optimization_settings",
+    "XR_ULTRALEAP_hand_tracking_forearm",
     "XR_VALVE_analog_threshold",
     "XR_VARJO_composition_layer_depth_test",
     "XR_VARJO_environment_depth_estimation",
     "XR_VARJO_foveated_rendering",
-    "XR_VARJO_marker_tracking",
     "XR_VARJO_quad_views",
+    "XR_VARJO_view_offset",
 };
 
 BOOL wine_xr_extension_supported(const char *name)

wineopenxr/openxr_thunks.h

@@ -3,7 +3,7 @@
  * This file is generated from OpenXR xr.xml file covered
  * by the following copyright and permission notice:
  *
- * Copyright (c) 2017-2021, The Khronos Group Inc.
+ * Copyright (c) 2017-2023, The Khronos Group Inc.
  *
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
@@ -72,15 +72,6 @@ XrResult WINAPI wine_xrPollEvent(XrInstance instance, XrEventDataBuffer *eventDa
 
 /* Private thunks */
 
-typedef struct XrMarkerSpaceCreateInfoVARJO_host
-{
-    XrStructureType type;
-    const void *next;
-    uint64_t markerId;
-    XrPosef poseInMarkerSpace;
-} XrMarkerSpaceCreateInfoVARJO_host;
-
-
 typedef struct XrSceneMeshBuffersGetInfoMSFT_host
 {
     XrStructureType type;
@@ -97,6 +88,8 @@ void free_XrInstanceCreateInfo_struct_chain(XrInstanceCreateInfo *s) DECLSPEC_HI
 struct openxr_instance_funcs
 {
     XrResult (*p_xrAcquireSwapchainImage)(XrSwapchain, const XrSwapchainImageAcquireInfo *, uint32_t *);
+    XrResult (*p_xrApplyForceFeedbackCurlMNDX)(XrHandTrackerEXT, const XrForceFeedbackCurlApplyLocationsMNDX *);
+    XrResult (*p_xrApplyFoveationHTC)(XrSession, const XrFoveationApplyInfoHTC *);
     XrResult (*p_xrApplyHapticFeedback)(XrSession, const XrHapticActionInfo *, const XrHapticBaseHeader *);
     XrResult (*p_xrAttachSessionActionSets)(XrSession, const XrSessionActionSetsAttachInfo *);
     XrResult (*p_xrBeginFrame)(XrSession, const XrFrameBeginInfo *);
@@ -108,13 +101,7 @@ struct openxr_instance_funcs
     XrResult (*p_xrCreateActionSpace)(XrSession, const XrActionSpaceCreateInfo *, XrSpace *);
     XrResult (*p_xrCreateFoveationProfileFB)(XrSession, const XrFoveationProfileCreateInfoFB *, XrFoveationProfileFB *);
     XrResult (*p_xrCreateGeometryInstanceFB)(XrSession, const XrGeometryInstanceCreateInfoFB *, XrGeometryInstanceFB *);
-    XrResult (*p_xrCreateHandMeshSpaceMSFT)(XrHandTrackerEXT, const XrHandMeshSpaceCreateInfoMSFT *, XrSpace *);
     XrResult (*p_xrCreateHandTrackerEXT)(XrSession, const XrHandTrackerCreateInfoEXT *, XrHandTrackerEXT *);
-#if defined(USE_STRUCT_CONVERSION)
-    XrResult (*p_xrCreateMarkerSpaceVARJO)(XrSession, const XrMarkerSpaceCreateInfoVARJO_host *, XrSpace *);
-#else
-    XrResult (*p_xrCreateMarkerSpaceVARJO)(XrSession, const XrMarkerSpaceCreateInfoVARJO *, XrSpace *);
-#endif
     XrResult (*p_xrCreatePassthroughFB)(XrSession, const XrPassthroughCreateInfoFB *, XrPassthroughFB *);
     XrResult (*p_xrCreatePassthroughLayerFB)(XrSession, const XrPassthroughLayerCreateInfoFB *, XrPassthroughLayerFB *);
     XrResult (*p_xrCreateReferenceSpace)(XrSession, const XrReferenceSpaceCreateInfo *, XrSpace *);
@@ -125,7 +112,6 @@ struct openxr_instance_funcs
     XrResult (*p_xrCreateSpatialAnchorMSFT)(XrSession, const XrSpatialAnchorCreateInfoMSFT *, XrSpatialAnchorMSFT *);
     XrResult (*p_xrCreateSpatialAnchorSpaceMSFT)(XrSession, const XrSpatialAnchorSpaceCreateInfoMSFT *, XrSpace *);
     XrResult (*p_xrCreateSpatialAnchorStoreConnectionMSFT)(XrSession, XrSpatialAnchorStoreConnectionMSFT *);
-    XrResult (*p_xrCreateSpatialGraphNodeSpaceMSFT)(XrSession, const XrSpatialGraphNodeSpaceCreateInfoMSFT *, XrSpace *);
     XrResult (*p_xrCreateSwapchain)(XrSession, const XrSwapchainCreateInfo *, XrSwapchain *);
     XrResult (*p_xrCreateTriangleMeshFB)(XrSession, const XrTriangleMeshCreateInfoFB *, XrTriangleMeshFB *);
     XrResult (*p_xrCreateVulkanDeviceKHR)(XrInstance, const XrVulkanDeviceCreateInfoKHR *, VkDevice *, VkResult *);
@@ -153,8 +139,11 @@ struct openxr_instance_funcs
     XrResult (*p_xrEnumerateColorSpacesFB)(XrSession, uint32_t, uint32_t *, XrColorSpaceFB *);
     XrResult (*p_xrEnumerateDisplayRefreshRatesFB)(XrSession, uint32_t, uint32_t *, float *);
     XrResult (*p_xrEnumerateEnvironmentBlendModes)(XrInstance, XrSystemId, XrViewConfigurationType, uint32_t, uint32_t *, XrEnvironmentBlendMode *);
+    XrResult (*p_xrEnumerateExternalCamerasOCULUS)(XrSession, uint32_t, uint32_t *, XrExternalCameraOCULUS *);
+    XrResult (*p_xrEnumeratePerformanceMetricsCounterPathsMETA)(XrInstance, uint32_t, uint32_t *, XrPath *);
     XrResult (*p_xrEnumeratePersistedSpatialAnchorNamesMSFT)(XrSpatialAnchorStoreConnectionMSFT, uint32_t, uint32_t *, XrSpatialAnchorPersistenceNameMSFT *);
     XrResult (*p_xrEnumerateReferenceSpaces)(XrSession, uint32_t, uint32_t *, XrReferenceSpaceType *);
+    XrResult (*p_xrEnumerateRenderModelPathsFB)(XrSession, uint32_t, uint32_t *, XrRenderModelPathInfoFB *);
     XrResult (*p_xrEnumerateReprojectionModesMSFT)(XrInstance, XrSystemId, XrViewConfigurationType, uint32_t, uint32_t *, XrReprojectionModeMSFT *);
     XrResult (*p_xrEnumerateSceneComputeFeaturesMSFT)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrSceneComputeFeatureMSFT *);
     XrResult (*p_xrEnumerateSwapchainFormats)(XrSession, uint32_t, uint32_t *, int64_t *);
@@ -173,13 +162,16 @@ struct openxr_instance_funcs
     XrResult (*p_xrGetControllerModelPropertiesMSFT)(XrSession, XrControllerModelKeyMSFT, XrControllerModelPropertiesMSFT *);
     XrResult (*p_xrGetControllerModelStateMSFT)(XrSession, XrControllerModelKeyMSFT, XrControllerModelStateMSFT *);
     XrResult (*p_xrGetCurrentInteractionProfile)(XrSession, XrPath, XrInteractionProfileState *);
+    XrResult (*p_xrGetDeviceSampleRateFB)(XrSession, const XrHapticActionInfo *, XrDevicePcmSampleRateGetInfoFB *);
     XrResult (*p_xrGetDisplayRefreshRateFB)(XrSession, float *);
+    XrResult (*p_xrGetFoveationEyeTrackedStateMETA)(XrSession, XrFoveationEyeTrackedStateMETA *);
     XrResult (*p_xrGetHandMeshFB)(XrHandTrackerEXT, XrHandTrackingMeshFB *);
     XrResult (*p_xrGetInputSourceLocalizedName)(XrSession, const XrInputSourceLocalizedNameGetInfo *, uint32_t, uint32_t *, char *);
     XrResult (*p_xrGetInstanceProperties)(XrInstance, XrInstanceProperties *);
-    XrResult (*p_xrGetMarkerSizeVARJO)(XrSession, uint64_t, XrExtent2Df *);
     XrResult (*p_xrGetOpenGLGraphicsRequirementsKHR)(XrInstance, XrSystemId, XrGraphicsRequirementsOpenGLKHR *);
+    XrResult (*p_xrGetPerformanceMetricsStateMETA)(XrSession, XrPerformanceMetricsStateMETA *);
     XrResult (*p_xrGetReferenceSpaceBoundsRect)(XrSession, XrReferenceSpaceType, XrExtent2Df *);
+    XrResult (*p_xrGetRenderModelPropertiesFB)(XrSession, XrPath, XrRenderModelPropertiesFB *);
     XrResult (*p_xrGetSceneComponentsMSFT)(XrSceneMSFT, const XrSceneComponentsGetInfoMSFT *, XrSceneComponentsMSFT *);
     XrResult (*p_xrGetSceneComputeStateMSFT)(XrSceneObserverMSFT, XrSceneComputeStateMSFT *);
 #if defined(USE_STRUCT_CONVERSION)
@@ -200,12 +192,14 @@ struct openxr_instance_funcs
     XrResult (*p_xrGetVulkanGraphicsRequirementsKHR)(XrInstance, XrSystemId, XrGraphicsRequirementsVulkanKHR *);
     XrResult (*p_xrGetVulkanInstanceExtensionsKHR)(XrInstance, XrSystemId, uint32_t, uint32_t *, char *);
     XrResult (*p_xrLoadControllerModelMSFT)(XrSession, XrControllerModelKeyMSFT, uint32_t, uint32_t *, uint8_t *);
+    XrResult (*p_xrLoadRenderModelFB)(XrSession, const XrRenderModelLoadInfoFB *, XrRenderModelBufferFB *);
     XrResult (*p_xrLocateHandJointsEXT)(XrHandTrackerEXT, const XrHandJointsLocateInfoEXT *, XrHandJointLocationsEXT *);
     XrResult (*p_xrLocateSceneComponentsMSFT)(XrSceneMSFT, const XrSceneComponentsLocateInfoMSFT *, XrSceneComponentLocationsMSFT *);
     XrResult (*p_xrLocateSpace)(XrSpace, XrSpace, XrTime, XrSpaceLocation *);
     XrResult (*p_xrLocateViews)(XrSession, const XrViewLocateInfo *, XrViewState *, uint32_t, uint32_t *, XrView *);
     XrResult (*p_xrPassthroughLayerPauseFB)(XrPassthroughLayerFB);
     XrResult (*p_xrPassthroughLayerResumeFB)(XrPassthroughLayerFB);
+    XrResult (*p_xrPassthroughLayerSetKeyboardHandsIntensityFB)(XrPassthroughLayerFB, const XrPassthroughKeyboardHandsIntensityFB *);
     XrResult (*p_xrPassthroughLayerSetStyleFB)(XrPassthroughLayerFB, const XrPassthroughStyleFB *);
     XrResult (*p_xrPassthroughPauseFB)(XrPassthroughFB);
     XrResult (*p_xrPassthroughStartFB)(XrPassthroughFB);
@@ -213,20 +207,26 @@ struct openxr_instance_funcs
     XrResult (*p_xrPerfSettingsSetPerformanceLevelEXT)(XrSession, XrPerfSettingsDomainEXT, XrPerfSettingsLevelEXT);
     XrResult (*p_xrPersistSpatialAnchorMSFT)(XrSpatialAnchorStoreConnectionMSFT, const XrSpatialAnchorPersistenceInfoMSFT *);
     XrResult (*p_xrPollEvent)(XrInstance, XrEventDataBuffer *);
+    XrResult (*p_xrQueryPerformanceMetricsCounterMETA)(XrSession, XrPath, XrPerformanceMetricsCounterMETA *);
+    XrResult (*p_xrQuerySpacesFB)(XrSession, const XrSpaceQueryInfoBaseHeaderFB *, XrAsyncRequestIdFB *);
     XrResult (*p_xrReleaseSwapchainImage)(XrSwapchain, const XrSwapchainImageReleaseInfo *);
     XrResult (*p_xrRequestDisplayRefreshRateFB)(XrSession, float);
     XrResult (*p_xrRequestExitSession)(XrSession);
+    XrResult (*p_xrRequestSceneCaptureFB)(XrSession, const XrSceneCaptureRequestInfoFB *, XrAsyncRequestIdFB *);
     XrResult (*p_xrResultToString)(XrInstance, XrResult, char[]);
+    XrResult (*p_xrRetrieveSpaceQueryResultsFB)(XrSession, XrAsyncRequestIdFB, XrSpaceQueryResultsFB *);
+    XrResult (*p_xrSaveSpaceListFB)(XrSession, const XrSpaceListSaveInfoFB *, XrAsyncRequestIdFB *);
     XrResult (*p_xrSetColorSpaceFB)(XrSession, const XrColorSpaceFB);
+    XrResult (*p_xrSetDigitalLensControlALMALENCE)(XrSession, const XrDigitalLensControlALMALENCE *);
     XrResult (*p_xrSetEnvironmentDepthEstimationVARJO)(XrSession, XrBool32);
     XrResult (*p_xrSetInputDeviceActiveEXT)(XrSession, XrPath, XrPath, XrBool32);
     XrResult (*p_xrSetInputDeviceLocationEXT)(XrSession, XrPath, XrPath, XrSpace, XrPosef);
     XrResult (*p_xrSetInputDeviceStateBoolEXT)(XrSession, XrPath, XrPath, XrBool32);
     XrResult (*p_xrSetInputDeviceStateFloatEXT)(XrSession, XrPath, XrPath, float);
     XrResult (*p_xrSetInputDeviceStateVector2fEXT)(XrSession, XrPath, XrPath, XrVector2f);
-    XrResult (*p_xrSetMarkerTrackingPredictionVARJO)(XrSession, uint64_t, XrBool32);
-    XrResult (*p_xrSetMarkerTrackingTimeoutVARJO)(XrSession, uint64_t, XrDuration);
-    XrResult (*p_xrSetMarkerTrackingVARJO)(XrSession, XrBool32);
+    XrResult (*p_xrSetPerformanceMetricsStateMETA)(XrSession, const XrPerformanceMetricsStateMETA *);
+    XrResult (*p_xrSetTrackingOptimizationSettingsHintQCOM)(XrSession, XrTrackingOptimizationSettingsDomainQCOM, XrTrackingOptimizationSettingsHintQCOM);
+    XrResult (*p_xrSetViewOffsetVARJO)(XrSession, float);
     XrResult (*p_xrStopHapticFeedback)(XrSession, const XrHapticActionInfo *);
     XrResult (*p_xrStringToPath)(XrInstance, const char *, XrPath *);
     XrResult (*p_xrStructureTypeToString)(XrInstance, XrStructureType, char[]);
@@ -240,7 +240,6 @@ struct openxr_instance_funcs
     XrResult (*p_xrTriangleMeshGetIndexBufferFB)(XrTriangleMeshFB, uint32_t **);
     XrResult (*p_xrTriangleMeshGetVertexBufferFB)(XrTriangleMeshFB, XrVector3f **);
     XrResult (*p_xrUnpersistSpatialAnchorMSFT)(XrSpatialAnchorStoreConnectionMSFT, const XrSpatialAnchorPersistenceNameMSFT *);
-    XrResult (*p_xrUpdateHandMeshMSFT)(XrHandTrackerEXT, const XrHandMeshUpdateInfoMSFT *, XrHandMeshMSFT *);
     XrResult (*p_xrUpdateSwapchainFB)(XrSwapchain, const XrSwapchainStateBaseHeaderFB *);
     XrResult (*p_xrWaitFrame)(XrSession, const XrFrameWaitInfo *, XrFrameState *);
     XrResult (*p_xrWaitSwapchainImage)(XrSwapchain, const XrSwapchainImageWaitInfo *);
@@ -248,6 +247,8 @@ struct openxr_instance_funcs
 
 #define ALL_XR_INSTANCE_FUNCS() \
     USE_XR_FUNC(xrAcquireSwapchainImage) \
+    USE_XR_FUNC(xrApplyForceFeedbackCurlMNDX) \
+    USE_XR_FUNC(xrApplyFoveationHTC) \
     USE_XR_FUNC(xrApplyHapticFeedback) \
     USE_XR_FUNC(xrAttachSessionActionSets) \
     USE_XR_FUNC(xrBeginFrame) \
@@ -259,9 +260,7 @@ struct openxr_instance_funcs
     USE_XR_FUNC(xrCreateActionSpace) \
     USE_XR_FUNC(xrCreateFoveationProfileFB) \
     USE_XR_FUNC(xrCreateGeometryInstanceFB) \
-    USE_XR_FUNC(xrCreateHandMeshSpaceMSFT) \
     USE_XR_FUNC(xrCreateHandTrackerEXT) \
-    USE_XR_FUNC(xrCreateMarkerSpaceVARJO) \
     USE_XR_FUNC(xrCreatePassthroughFB) \
     USE_XR_FUNC(xrCreatePassthroughLayerFB) \
     USE_XR_FUNC(xrCreateReferenceSpace) \
@@ -272,7 +271,6 @@ struct openxr_instance_funcs
     USE_XR_FUNC(xrCreateSpatialAnchorMSFT) \
     USE_XR_FUNC(xrCreateSpatialAnchorSpaceMSFT) \
     USE_XR_FUNC(xrCreateSpatialAnchorStoreConnectionMSFT) \
-    USE_XR_FUNC(xrCreateSpatialGraphNodeSpaceMSFT) \
     USE_XR_FUNC(xrCreateSwapchain) \
     USE_XR_FUNC(xrCreateTriangleMeshFB) \
     USE_XR_FUNC(xrCreateVulkanDeviceKHR) \
@@ -300,8 +298,11 @@ struct openxr_instance_funcs
     USE_XR_FUNC(xrEnumerateColorSpacesFB) \
     USE_XR_FUNC(xrEnumerateDisplayRefreshRatesFB) \
     USE_XR_FUNC(xrEnumerateEnvironmentBlendModes) \
+    USE_XR_FUNC(xrEnumerateExternalCamerasOCULUS) \
+    USE_XR_FUNC(xrEnumeratePerformanceMetricsCounterPathsMETA) \
     USE_XR_FUNC(xrEnumeratePersistedSpatialAnchorNamesMSFT) \
     USE_XR_FUNC(xrEnumerateReferenceSpaces) \
+    USE_XR_FUNC(xrEnumerateRenderModelPathsFB) \
     USE_XR_FUNC(xrEnumerateReprojectionModesMSFT) \
     USE_XR_FUNC(xrEnumerateSceneComputeFeaturesMSFT) \
     USE_XR_FUNC(xrEnumerateSwapchainFormats) \
@@ -320,13 +321,16 @@ struct openxr_instance_funcs
     USE_XR_FUNC(xrGetControllerModelPropertiesMSFT) \
     USE_XR_FUNC(xrGetControllerModelStateMSFT) \
     USE_XR_FUNC(xrGetCurrentInteractionProfile) \
+    USE_XR_FUNC(xrGetDeviceSampleRateFB) \
     USE_XR_FUNC(xrGetDisplayRefreshRateFB) \
+    USE_XR_FUNC(xrGetFoveationEyeTrackedStateMETA) \
     USE_XR_FUNC(xrGetHandMeshFB) \
     USE_XR_FUNC(xrGetInputSourceLocalizedName) \
     USE_XR_FUNC(xrGetInstanceProperties) \
-    USE_XR_FUNC(xrGetMarkerSizeVARJO) \
     USE_XR_FUNC(xrGetOpenGLGraphicsRequirementsKHR) \
+    USE_XR_FUNC(xrGetPerformanceMetricsStateMETA) \
     USE_XR_FUNC(xrGetReferenceSpaceBoundsRect) \
+    USE_XR_FUNC(xrGetRenderModelPropertiesFB) \
     USE_XR_FUNC(xrGetSceneComponentsMSFT) \
     USE_XR_FUNC(xrGetSceneComputeStateMSFT) \
     USE_XR_FUNC(xrGetSceneMeshBuffersMSFT) \
@@ -343,12 +347,14 @@ struct openxr_instance_funcs
     USE_XR_FUNC(xrGetVulkanGraphicsRequirementsKHR) \
     USE_XR_FUNC(xrGetVulkanInstanceExtensionsKHR) \
     USE_XR_FUNC(xrLoadControllerModelMSFT) \
+    USE_XR_FUNC(xrLoadRenderModelFB) \
     USE_XR_FUNC(xrLocateHandJointsEXT) \
     USE_XR_FUNC(xrLocateSceneComponentsMSFT) \
     USE_XR_FUNC(xrLocateSpace) \
     USE_XR_FUNC(xrLocateViews) \
     USE_XR_FUNC(xrPassthroughLayerPauseFB) \
     USE_XR_FUNC(xrPassthroughLayerResumeFB) \
+    USE_XR_FUNC(xrPassthroughLayerSetKeyboardHandsIntensityFB) \
     USE_XR_FUNC(xrPassthroughLayerSetStyleFB) \
     USE_XR_FUNC(xrPassthroughPauseFB) \
     USE_XR_FUNC(xrPassthroughStartFB) \
@@ -356,20 +362,26 @@ struct openxr_instance_funcs
     USE_XR_FUNC(xrPerfSettingsSetPerformanceLevelEXT) \
     USE_XR_FUNC(xrPersistSpatialAnchorMSFT) \
     USE_XR_FUNC(xrPollEvent) \
+    USE_XR_FUNC(xrQueryPerformanceMetricsCounterMETA) \
+    USE_XR_FUNC(xrQuerySpacesFB) \
     USE_XR_FUNC(xrReleaseSwapchainImage) \
     USE_XR_FUNC(xrRequestDisplayRefreshRateFB) \
     USE_XR_FUNC(xrRequestExitSession) \
+    USE_XR_FUNC(xrRequestSceneCaptureFB) \
     USE_XR_FUNC(xrResultToString) \
+    USE_XR_FUNC(xrRetrieveSpaceQueryResultsFB) \
+    USE_XR_FUNC(xrSaveSpaceListFB) \
     USE_XR_FUNC(xrSetColorSpaceFB) \
+    USE_XR_FUNC(xrSetDigitalLensControlALMALENCE) \
     USE_XR_FUNC(xrSetEnvironmentDepthEstimationVARJO) \
     USE_XR_FUNC(xrSetInputDeviceActiveEXT) \
     USE_XR_FUNC(xrSetInputDeviceLocationEXT) \
     USE_XR_FUNC(xrSetInputDeviceStateBoolEXT) \
     USE_XR_FUNC(xrSetInputDeviceStateFloatEXT) \
     USE_XR_FUNC(xrSetInputDeviceStateVector2fEXT) \
-    USE_XR_FUNC(xrSetMarkerTrackingPredictionVARJO) \
-    USE_XR_FUNC(xrSetMarkerTrackingTimeoutVARJO) \
-    USE_XR_FUNC(xrSetMarkerTrackingVARJO) \
+    USE_XR_FUNC(xrSetPerformanceMetricsStateMETA) \
+    USE_XR_FUNC(xrSetTrackingOptimizationSettingsHintQCOM) \
+    USE_XR_FUNC(xrSetViewOffsetVARJO) \
     USE_XR_FUNC(xrStopHapticFeedback) \
     USE_XR_FUNC(xrStringToPath) \
     USE_XR_FUNC(xrStructureTypeToString) \
@@ -383,7 +395,6 @@ struct openxr_instance_funcs
     USE_XR_FUNC(xrTriangleMeshGetIndexBufferFB) \
     USE_XR_FUNC(xrTriangleMeshGetVertexBufferFB) \
     USE_XR_FUNC(xrUnpersistSpatialAnchorMSFT) \
-    USE_XR_FUNC(xrUpdateHandMeshMSFT) \
     USE_XR_FUNC(xrUpdateSwapchainFB) \
     USE_XR_FUNC(xrWaitFrame) \
     USE_XR_FUNC(xrWaitSwapchainImage)