wineopenxr: Update to 1.0.27 registry version.

CW-Bug-Id: #22244
2024-10-16 15:26:59 +03:00 · 2023-05-05 21:43:12 -06:00 · 2023-05-05 21:43:12 -06:00 · e488a6cbaf
commit e488a6cbaf
parent 2d00c9df0a
6 changed files with 7100 additions and 1572 deletions
--- a/wineopenxr/make_openxr
+++ b/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 not self.is_alias():
            if self.union:
                text = "typedef union {0} {0};\n".format(self.name)
            else:
                text = "typedef struct {0} {0};\n".format(self.name)
+        else:
+            text = ""

        for aliasee in self.aliased_by:
            text += "typedef {0} {1};\n".format(self.name, aliasee.name)
--- a/wineopenxr/openxr.c
+++ b/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:
--- a/wineopenxr/openxr_thunks.c
+++ b/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)
--- a/wineopenxr/openxr_thunks.h
+++ b/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)
--- a/wineopenxr/wineopenxr.h
+++ b/wineopenxr/wineopenxr.h
--- a/wineopenxr/xr.xml
+++ b/wineopenxr/xr.xml