suyu/Yucom
25
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

wineopenxr: Drop extensions from UNSUPPORTED_EXTENSIONS which can now be auto generated.

Browse source 
CW-Bug-Id: #23689
This commit is contained in:
Paul Gofman 2024-04-19 19:11:40 -06:00 committed by Arkadiusz Hiler
parent ded1941e73
commit 3661124333
4 changed files with 1921 additions and 337 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
wineopenxr/make_openxr
View file

@ -119,20 +119,6 @@ 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 = [

545
wineopenxr/openxr_thunks.c
View file

@ -30,6 +30,25 @@
WINE_DEFAULT_DEBUG_CHANNEL(openxr);
#if defined(USE_STRUCT_CONVERSION)
static inline void convert_XrKeyboardSpaceCreateInfoFB_win_to_host(const XrKeyboardSpaceCreateInfoFB *in, XrKeyboardSpaceCreateInfoFB_host *out)
{
if (!in) return;
out->type = in->type;
out->next = in->next;
out->trackedKeyboardId = in->trackedKeyboardId;
}
static inline void convert_XrMarkerSpaceCreateInfoVARJO_win_to_host(const XrMarkerSpaceCreateInfoVARJO *in, XrMarkerSpaceCreateInfoVARJO_host *out)
{
if (!in) return;
out->type = in->type;
out->next = in->next;
out->markerId = in->markerId;
out->poseInMarkerSpace = in->poseInMarkerSpace;
}
static inline void convert_XrSceneMeshBuffersGetInfoMSFT_win_to_host(const XrSceneMeshBuffersGetInfoMSFT *in, XrSceneMeshBuffersGetInfoMSFT_host *out)
{
if (!in) return;
@ -39,6 +58,16 @@ static inline void convert_XrSceneMeshBuffersGetInfoMSFT_win_to_host(const XrSce
out->meshBufferId = in->meshBufferId;
}
static inline void convert_XrKeyboardTrackingDescriptionFB_host_to_win(const XrKeyboardTrackingDescriptionFB_host *in, XrKeyboardTrackingDescriptionFB *out)
{
if (!in) return;
out->trackedKeyboardId = in->trackedKeyboardId;
out->size = in->size;
out->flags = in->flags;
memcpy(out->name, in->name, XR_MAX_KEYBOARD_TRACKING_NAME_SIZE_FB * sizeof(char));
}
#endif /* USE_STRUCT_CONVERSION */
XrResult convert_XrInstanceCreateInfo_struct_chain(const void *next, XrInstanceCreateInfo *out_struct)
@ -186,6 +215,46 @@ XrResult WINAPI wine_xrCreateActionSpace(XrSession session, const XrActionSpaceC
return ret;
}
static XrResult WINAPI wine_xrCreateBodyTrackerFB(XrSession session, const XrBodyTrackerCreateInfoFB *createInfo, XrBodyTrackerFB *bodyTracker)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, createInfo, bodyTracker);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateBodyTrackerFB(((wine_XrSession *)session)->session, createInfo, bodyTracker);
if (!ret) register_dispatchable_handle((uint64_t)*bodyTracker, &(((wine_XrSession *)session)->wine_instance->funcs));
return ret;
}
static XrResult WINAPI wine_xrCreateEyeTrackerFB(XrSession session, const XrEyeTrackerCreateInfoFB *createInfo, XrEyeTrackerFB *eyeTracker)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, createInfo, eyeTracker);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateEyeTrackerFB(((wine_XrSession *)session)->session, createInfo, eyeTracker);
if (!ret) register_dispatchable_handle((uint64_t)*eyeTracker, &(((wine_XrSession *)session)->wine_instance->funcs));
return ret;
}
static XrResult WINAPI wine_xrCreateFaceTrackerFB(XrSession session, const XrFaceTrackerCreateInfoFB *createInfo, XrFaceTrackerFB *faceTracker)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, createInfo, faceTracker);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateFaceTrackerFB(((wine_XrSession *)session)->session, createInfo, faceTracker);
if (!ret) register_dispatchable_handle((uint64_t)*faceTracker, &(((wine_XrSession *)session)->wine_instance->funcs));
return ret;
}
static XrResult WINAPI wine_xrCreateFacialTrackerHTC(XrSession session, const XrFacialTrackerCreateInfoHTC *createInfo, XrFacialTrackerHTC *facialTracker)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, createInfo, facialTracker);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateFacialTrackerHTC(((wine_XrSession *)session)->session, createInfo, facialTracker);
if (!ret) register_dispatchable_handle((uint64_t)*facialTracker, &(((wine_XrSession *)session)->wine_instance->funcs));
return ret;
}
static XrResult WINAPI wine_xrCreateFoveationProfileFB(XrSession session, const XrFoveationProfileCreateInfoFB *createInfo, XrFoveationProfileFB *profile)
{
XrResult ret;
@ -206,6 +275,16 @@ static XrResult WINAPI wine_xrCreateGeometryInstanceFB(XrSession session, const
return ret;
}
static XrResult WINAPI wine_xrCreateHandMeshSpaceMSFT(XrHandTrackerEXT handTracker, const XrHandMeshSpaceCreateInfoMSFT *createInfo, XrSpace *space)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", handTracker, createInfo, space);
ret = (*get_dispatch_table((uint64_t)(handTracker))).p_xrCreateHandMeshSpaceMSFT(handTracker, createInfo, space);
if (!ret) register_dispatchable_handle((uint64_t)*space, &((*get_dispatch_table((uint64_t)(handTracker)))));
return ret;
}
static XrResult WINAPI wine_xrCreateHandTrackerEXT(XrSession session, const XrHandTrackerCreateInfoEXT *createInfo, XrHandTrackerEXT *handTracker)
{
XrResult ret;
@ -216,6 +295,48 @@ static XrResult WINAPI wine_xrCreateHandTrackerEXT(XrSession session, const XrHa
return ret;
}
static XrResult WINAPI wine_xrCreateKeyboardSpaceFB(XrSession session, const XrKeyboardSpaceCreateInfoFB *createInfo, XrSpace *keyboardSpace)
{
#if defined(USE_STRUCT_CONVERSION)
XrResult result;
XrKeyboardSpaceCreateInfoFB_host createInfo_host;
WINE_TRACE("%p, %p, %p\n", session, createInfo, keyboardSpace);
convert_XrKeyboardSpaceCreateInfoFB_win_to_host(createInfo, &createInfo_host);
result = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateKeyboardSpaceFB(((wine_XrSession *)session)->session, &createInfo_host, keyboardSpace);
return result;
#else
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, createInfo, keyboardSpace);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateKeyboardSpaceFB(((wine_XrSession *)session)->session, createInfo, keyboardSpace);
if (!ret) register_dispatchable_handle((uint64_t)*keyboardSpace, &(((wine_XrSession *)session)->wine_instance->funcs));
return ret;
#endif
}
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
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, createInfo, space);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateMarkerSpaceVARJO(((wine_XrSession *)session)->session, createInfo, space);
if (!ret) register_dispatchable_handle((uint64_t)*space, &(((wine_XrSession *)session)->wine_instance->funcs));
return ret;
#endif
}
static XrResult WINAPI wine_xrCreatePassthroughFB(XrSession session, const XrPassthroughCreateInfoFB *createInfo, XrPassthroughFB *outPassthrough)
{
XrResult ret;
@ -226,6 +347,16 @@ static XrResult WINAPI wine_xrCreatePassthroughFB(XrSession session, const XrPas
return ret;
}
static XrResult WINAPI wine_xrCreatePassthroughHTC(XrSession session, const XrPassthroughCreateInfoHTC *createInfo, XrPassthroughHTC *passthrough)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, createInfo, passthrough);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreatePassthroughHTC(((wine_XrSession *)session)->session, createInfo, passthrough);
if (!ret) register_dispatchable_handle((uint64_t)*passthrough, &(((wine_XrSession *)session)->wine_instance->funcs));
return ret;
}
static XrResult WINAPI wine_xrCreatePassthroughLayerFB(XrSession session, const XrPassthroughLayerCreateInfoFB *createInfo, XrPassthroughLayerFB *outLayer)
{
XrResult ret;
@ -266,6 +397,25 @@ static XrResult WINAPI wine_xrCreateSceneObserverMSFT(XrSession session, const X
return ret;
}
static XrResult WINAPI wine_xrCreateSpaceUserFB(XrSession session, const XrSpaceUserCreateInfoFB *info, XrSpaceUserFB *user)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, info, user);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateSpaceUserFB(((wine_XrSession *)session)->session, info, user);
if (!ret) register_dispatchable_handle((uint64_t)*user, &(((wine_XrSession *)session)->wine_instance->funcs));
return ret;
}
static XrResult WINAPI wine_xrCreateSpatialAnchorFB(XrSession session, const XrSpatialAnchorCreateInfoFB *info, XrAsyncRequestIdFB *requestId)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, info, requestId);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateSpatialAnchorFB(((wine_XrSession *)session)->session, info, requestId);
return ret;
}
static XrResult WINAPI wine_xrCreateSpatialAnchorFromPersistedNameMSFT(XrSession session, const XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT *spatialAnchorCreateInfo, XrSpatialAnchorMSFT *spatialAnchor)
{
XrResult ret;
@ -306,6 +456,16 @@ static XrResult WINAPI wine_xrCreateSpatialAnchorStoreConnectionMSFT(XrSession s
return ret;
}
static XrResult WINAPI wine_xrCreateSpatialGraphNodeSpaceMSFT(XrSession session, const XrSpatialGraphNodeSpaceCreateInfoMSFT *createInfo, XrSpace *space)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, createInfo, space);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrCreateSpatialGraphNodeSpaceMSFT(((wine_XrSession *)session)->session, createInfo, space);
if (!ret) register_dispatchable_handle((uint64_t)*space, &(((wine_XrSession *)session)->wine_instance->funcs));
return ret;
}
static XrResult WINAPI wine_xrCreateTriangleMeshFB(XrSession session, const XrTriangleMeshCreateInfoFB *createInfo, XrTriangleMeshFB *outTriangleMesh)
{
XrResult ret;
@ -343,6 +503,46 @@ XrResult WINAPI wine_xrDestroyActionSet(XrActionSet actionSet)
return ret;
}
static XrResult WINAPI wine_xrDestroyBodyTrackerFB(XrBodyTrackerFB bodyTracker)
{
XrResult ret;
WINE_TRACE("%p\n", bodyTracker);
ret = (*get_dispatch_table((uint64_t)(bodyTracker))).p_xrDestroyBodyTrackerFB(bodyTracker);
unregister_dispatchable_handle((uint64_t)bodyTracker);
return ret;
}
static XrResult WINAPI wine_xrDestroyEyeTrackerFB(XrEyeTrackerFB eyeTracker)
{
XrResult ret;
WINE_TRACE("%p\n", eyeTracker);
ret = (*get_dispatch_table((uint64_t)(eyeTracker))).p_xrDestroyEyeTrackerFB(eyeTracker);
unregister_dispatchable_handle((uint64_t)eyeTracker);
return ret;
}
static XrResult WINAPI wine_xrDestroyFaceTrackerFB(XrFaceTrackerFB faceTracker)
{
XrResult ret;
WINE_TRACE("%p\n", faceTracker);
ret = (*get_dispatch_table((uint64_t)(faceTracker))).p_xrDestroyFaceTrackerFB(faceTracker);
unregister_dispatchable_handle((uint64_t)faceTracker);
return ret;
}
static XrResult WINAPI wine_xrDestroyFacialTrackerHTC(XrFacialTrackerHTC facialTracker)
{
XrResult ret;
WINE_TRACE("%p\n", facialTracker);
ret = (*get_dispatch_table((uint64_t)(facialTracker))).p_xrDestroyFacialTrackerHTC(facialTracker);
unregister_dispatchable_handle((uint64_t)facialTracker);
return ret;
}
static XrResult WINAPI wine_xrDestroyFoveationProfileFB(XrFoveationProfileFB profile)
{
XrResult ret;
@ -383,6 +583,16 @@ static XrResult WINAPI wine_xrDestroyPassthroughFB(XrPassthroughFB passthrough)
return ret;
}
static XrResult WINAPI wine_xrDestroyPassthroughHTC(XrPassthroughHTC passthrough)
{
XrResult ret;
WINE_TRACE("%p\n", passthrough);
ret = (*get_dispatch_table((uint64_t)(passthrough))).p_xrDestroyPassthroughHTC(passthrough);
unregister_dispatchable_handle((uint64_t)passthrough);
return ret;
}
static XrResult WINAPI wine_xrDestroyPassthroughLayerFB(XrPassthroughLayerFB layer)
{
XrResult ret;
@ -423,6 +633,16 @@ XrResult WINAPI wine_xrDestroySpace(XrSpace space)
return ret;
}
static XrResult WINAPI wine_xrDestroySpaceUserFB(XrSpaceUserFB user)
{
XrResult ret;
WINE_TRACE("%p\n", user);
ret = (*get_dispatch_table((uint64_t)(user))).p_xrDestroySpaceUserFB(user);
unregister_dispatchable_handle((uint64_t)user);
return ret;
}
static XrResult WINAPI wine_xrDestroySpatialAnchorMSFT(XrSpatialAnchorMSFT anchor)
{
XrResult ret;
@ -443,6 +663,16 @@ static XrResult WINAPI wine_xrDestroySpatialAnchorStoreConnectionMSFT(XrSpatialA
return ret;
}
static XrResult WINAPI wine_xrDestroySpatialGraphNodeBindingMSFT(XrSpatialGraphNodeBindingMSFT nodeBinding)
{
XrResult ret;
WINE_TRACE("%p\n", nodeBinding);
ret = (*get_dispatch_table((uint64_t)(nodeBinding))).p_xrDestroySpatialGraphNodeBindingMSFT(nodeBinding);
unregister_dispatchable_handle((uint64_t)nodeBinding);
return ret;
}
static XrResult WINAPI wine_xrDestroyTriangleMeshFB(XrTriangleMeshFB mesh)
{
XrResult ret;
@ -570,6 +800,15 @@ static XrResult WINAPI wine_xrEnumerateSceneComputeFeaturesMSFT(XrInstance insta
return ret;
}
static XrResult WINAPI wine_xrEnumerateSpaceSupportedComponentsFB(XrSpace space, uint32_t componentTypeCapacityInput, uint32_t *componentTypeCountOutput, XrSpaceComponentTypeFB *componentTypes)
{
XrResult ret;
WINE_TRACE("%p, %u, %p, %p\n", space, componentTypeCapacityInput, componentTypeCountOutput, componentTypes);
ret = (*get_dispatch_table((uint64_t)(space))).p_xrEnumerateSpaceSupportedComponentsFB(space, componentTypeCapacityInput, componentTypeCountOutput, componentTypes);
return ret;
}
XrResult WINAPI wine_xrEnumerateViewConfigurationViews(XrInstance instance, XrSystemId systemId, XrViewConfigurationType viewConfigurationType, uint32_t viewCapacityInput, uint32_t *viewCountOutput, XrViewConfigurationView *views)
{
XrResult ret;
@ -597,6 +836,15 @@ static XrResult WINAPI wine_xrEnumerateViveTrackerPathsHTCX(XrInstance instance,
return ret;
}
static XrResult WINAPI wine_xrEraseSpaceFB(XrSession session, const XrSpaceEraseInfoFB *info, XrAsyncRequestIdFB *requestId)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, info, requestId);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrEraseSpaceFB(((wine_XrSession *)session)->session, info, requestId);
return ret;
}
static XrResult WINAPI wine_xrGeometryInstanceSetTransformFB(XrGeometryInstanceFB instance, const XrGeometryInstanceTransformFB *transformation)
{
XrResult ret;
@ -660,6 +908,15 @@ static XrResult WINAPI wine_xrGetAudioOutputDeviceGuidOculus(XrInstance instance
return ret;
}
static XrResult WINAPI wine_xrGetBodySkeletonFB(XrBodyTrackerFB bodyTracker, XrBodySkeletonFB *skeleton)
{
XrResult ret;
WINE_TRACE("%p, %p\n", bodyTracker, skeleton);
ret = (*get_dispatch_table((uint64_t)(bodyTracker))).p_xrGetBodySkeletonFB(bodyTracker, skeleton);
return ret;
}
static XrResult WINAPI wine_xrGetControllerModelKeyMSFT(XrSession session, XrPath topLevelUserPath, XrControllerModelKeyStateMSFT *controllerModelKeyState)
{
XrResult ret;
@ -714,6 +971,33 @@ static XrResult WINAPI wine_xrGetDisplayRefreshRateFB(XrSession session, float *
return ret;
}
static XrResult WINAPI wine_xrGetEyeGazesFB(XrEyeTrackerFB eyeTracker, const XrEyeGazesInfoFB *gazeInfo, XrEyeGazesFB *eyeGazes)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", eyeTracker, gazeInfo, eyeGazes);
ret = (*get_dispatch_table((uint64_t)(eyeTracker))).p_xrGetEyeGazesFB(eyeTracker, gazeInfo, eyeGazes);
return ret;
}
static XrResult WINAPI wine_xrGetFaceExpressionWeightsFB(XrFaceTrackerFB faceTracker, const XrFaceExpressionInfoFB *expressionInfo, XrFaceExpressionWeightsFB *expressionWeights)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", faceTracker, expressionInfo, expressionWeights);
ret = (*get_dispatch_table((uint64_t)(faceTracker))).p_xrGetFaceExpressionWeightsFB(faceTracker, expressionInfo, expressionWeights);
return ret;
}
static XrResult WINAPI wine_xrGetFacialExpressionsHTC(XrFacialTrackerHTC facialTracker, XrFacialExpressionsHTC *facialExpressions)
{
XrResult ret;
WINE_TRACE("%p, %p\n", facialTracker, facialExpressions);
ret = (*get_dispatch_table((uint64_t)(facialTracker))).p_xrGetFacialExpressionsHTC(facialTracker, facialExpressions);
return ret;
}
static XrResult WINAPI wine_xrGetFoveationEyeTrackedStateMETA(XrSession session, XrFoveationEyeTrackedStateMETA *foveationState)
{
XrResult ret;
@ -750,6 +1034,15 @@ XrResult WINAPI wine_xrGetInstanceProperties(XrInstance instance, XrInstanceProp
return ret;
}
static XrResult WINAPI wine_xrGetMarkerSizeVARJO(XrSession session, uint64_t markerId, XrExtent2Df *size)
{
XrResult ret;
WINE_TRACE("%p, 0x%s, %p\n", session, wine_dbgstr_longlong(markerId), size);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetMarkerSizeVARJO(((wine_XrSession *)session)->session, markerId, size);
return ret;
}
static XrResult WINAPI wine_xrGetOpenGLGraphicsRequirementsKHR(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsOpenGLKHR *graphicsRequirements)
{
XrResult ret;
@ -833,6 +1126,96 @@ static XrResult WINAPI wine_xrGetSerializedSceneFragmentDataMSFT(XrSceneMSFT sce
return ret;
}
static XrResult WINAPI wine_xrGetSpaceBoundary2DFB(XrSession session, XrSpace space, XrBoundary2DFB *boundary2DOutput)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, space, boundary2DOutput);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetSpaceBoundary2DFB(((wine_XrSession *)session)->session, space, boundary2DOutput);
return ret;
}
static XrResult WINAPI wine_xrGetSpaceBoundingBox2DFB(XrSession session, XrSpace space, XrRect2Df *boundingBox2DOutput)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, space, boundingBox2DOutput);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetSpaceBoundingBox2DFB(((wine_XrSession *)session)->session, space, boundingBox2DOutput);
return ret;
}
static XrResult WINAPI wine_xrGetSpaceBoundingBox3DFB(XrSession session, XrSpace space, XrRect3DfFB *boundingBox3DOutput)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, space, boundingBox3DOutput);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetSpaceBoundingBox3DFB(((wine_XrSession *)session)->session, space, boundingBox3DOutput);
return ret;
}
static XrResult WINAPI wine_xrGetSpaceComponentStatusFB(XrSpace space, XrSpaceComponentTypeFB componentType, XrSpaceComponentStatusFB *status)
{
XrResult ret;
WINE_TRACE("%p, %#x, %p\n", space, componentType, status);
ret = (*get_dispatch_table((uint64_t)(space))).p_xrGetSpaceComponentStatusFB(space, componentType, status);
return ret;
}
static XrResult WINAPI wine_xrGetSpaceContainerFB(XrSession session, XrSpace space, XrSpaceContainerFB *spaceContainerOutput)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, space, spaceContainerOutput);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetSpaceContainerFB(((wine_XrSession *)session)->session, space, spaceContainerOutput);
return ret;
}
static XrResult WINAPI wine_xrGetSpaceRoomLayoutFB(XrSession session, XrSpace space, XrRoomLayoutFB *roomLayoutOutput)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, space, roomLayoutOutput);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetSpaceRoomLayoutFB(((wine_XrSession *)session)->session, space, roomLayoutOutput);
return ret;
}
static XrResult WINAPI wine_xrGetSpaceSemanticLabelsFB(XrSession session, XrSpace space, XrSemanticLabelsFB *semanticLabelsOutput)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, space, semanticLabelsOutput);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrGetSpaceSemanticLabelsFB(((wine_XrSession *)session)->session, space, semanticLabelsOutput);
return ret;
}
static XrResult WINAPI wine_xrGetSpaceUserIdFB(XrSpaceUserFB user, XrSpaceUserIdFB *userId)
{
XrResult ret;
WINE_TRACE("%p, %p\n", user, userId);
ret = (*get_dispatch_table((uint64_t)(user))).p_xrGetSpaceUserIdFB(user, userId);
return ret;
}
static XrResult WINAPI wine_xrGetSpaceUuidFB(XrSpace space, XrUuidEXT *uuid)
{
XrResult ret;
WINE_TRACE("%p, %p\n", space, uuid);
ret = (*get_dispatch_table((uint64_t)(space))).p_xrGetSpaceUuidFB(space, uuid);
return ret;
}
static XrResult WINAPI wine_xrGetSpatialGraphNodeBindingPropertiesMSFT(XrSpatialGraphNodeBindingMSFT nodeBinding, const XrSpatialGraphNodeBindingPropertiesGetInfoMSFT *getInfo, XrSpatialGraphNodeBindingPropertiesMSFT *properties)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", nodeBinding, getInfo, properties);
ret = (*get_dispatch_table((uint64_t)(nodeBinding))).p_xrGetSpatialGraphNodeBindingPropertiesMSFT(nodeBinding, getInfo, properties);
return ret;
}
static XrResult WINAPI wine_xrGetSwapchainStateFB(XrSwapchain swapchain, XrSwapchainStateBaseHeaderFB *state)
{
XrResult ret;
@ -905,6 +1288,15 @@ static XrResult WINAPI wine_xrLoadRenderModelFB(XrSession session, const XrRende
return ret;
}
static XrResult WINAPI wine_xrLocateBodyJointsFB(XrBodyTrackerFB bodyTracker, const XrBodyJointsLocateInfoFB *locateInfo, XrBodyJointLocationsFB *locations)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", bodyTracker, locateInfo, locations);
ret = (*get_dispatch_table((uint64_t)(bodyTracker))).p_xrLocateBodyJointsFB(bodyTracker, locateInfo, locations);
return ret;
}
static XrResult WINAPI wine_xrLocateHandJointsEXT(XrHandTrackerEXT handTracker, const XrHandJointsLocateInfoEXT *locateInfo, XrHandJointLocationsEXT *locations)
{
XrResult ret;
@ -1040,6 +1432,26 @@ static XrResult WINAPI wine_xrQuerySpacesFB(XrSession session, const XrSpaceQuer
return ret;
}
static XrResult WINAPI wine_xrQuerySystemTrackedKeyboardFB(XrSession session, const XrKeyboardTrackingQueryFB *queryInfo, XrKeyboardTrackingDescriptionFB *keyboard)
{
#if defined(USE_STRUCT_CONVERSION)
XrResult result;
XrKeyboardTrackingDescriptionFB_host keyboard_host;
WINE_TRACE("%p, %p, %p\n", session, queryInfo, keyboard);
result = ((wine_XrSession *)session)->wine_instance->funcs.p_xrQuerySystemTrackedKeyboardFB(((wine_XrSession *)session)->session, queryInfo, &keyboard_host);
convert_XrKeyboardTrackingDescriptionFB_host_to_win(&keyboard_host, keyboard);
return result;
#else
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, queryInfo, keyboard);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrQuerySystemTrackedKeyboardFB(((wine_XrSession *)session)->session, queryInfo, keyboard);
return ret;
#endif
}
XrResult WINAPI wine_xrReleaseSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageReleaseInfo *releaseInfo)
{
XrResult ret;
@ -1094,6 +1506,15 @@ static XrResult WINAPI wine_xrRetrieveSpaceQueryResultsFB(XrSession session, XrA
return ret;
}
static XrResult WINAPI wine_xrSaveSpaceFB(XrSession session, const XrSpaceSaveInfoFB *info, XrAsyncRequestIdFB *requestId)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, info, requestId);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrSaveSpaceFB(((wine_XrSession *)session)->session, info, requestId);
return ret;
}
static XrResult WINAPI wine_xrSaveSpaceListFB(XrSession session, const XrSpaceListSaveInfoFB *info, XrAsyncRequestIdFB *requestId)
{
XrResult ret;
@ -1175,6 +1596,33 @@ static XrResult WINAPI wine_xrSetInputDeviceStateVector2fEXT(XrSession session,
return ret;
}
static XrResult WINAPI wine_xrSetMarkerTrackingPredictionVARJO(XrSession session, uint64_t markerId, XrBool32 enabled)
{
XrResult ret;
WINE_TRACE("%p, 0x%s, %u\n", session, wine_dbgstr_longlong(markerId), enabled);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetMarkerTrackingPredictionVARJO(((wine_XrSession *)session)->session, markerId, enabled);
return ret;
}
static XrResult WINAPI wine_xrSetMarkerTrackingTimeoutVARJO(XrSession session, uint64_t markerId, XrDuration timeout)
{
XrResult ret;
WINE_TRACE("%p, 0x%s, 0x%s\n", session, wine_dbgstr_longlong(markerId), wine_dbgstr_longlong(timeout));
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetMarkerTrackingTimeoutVARJO(((wine_XrSession *)session)->session, markerId, timeout);
return ret;
}
static XrResult WINAPI wine_xrSetMarkerTrackingVARJO(XrSession session, XrBool32 enabled)
{
XrResult ret;
WINE_TRACE("%p, %u\n", session, enabled);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrSetMarkerTrackingVARJO(((wine_XrSession *)session)->session, enabled);
return ret;
}
static XrResult WINAPI wine_xrSetPerformanceMetricsStateMETA(XrSession session, const XrPerformanceMetricsStateMETA *state)
{
XrResult ret;
@ -1184,6 +1632,15 @@ static XrResult WINAPI wine_xrSetPerformanceMetricsStateMETA(XrSession session,
return ret;
}
static XrResult WINAPI wine_xrSetSpaceComponentStatusFB(XrSpace space, const XrSpaceComponentStatusSetInfoFB *info, XrAsyncRequestIdFB *requestId)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", space, info, requestId);
ret = (*get_dispatch_table((uint64_t)(space))).p_xrSetSpaceComponentStatusFB(space, info, requestId);
return ret;
}
static XrResult WINAPI wine_xrSetTrackingOptimizationSettingsHintQCOM(XrSession session, XrTrackingOptimizationSettingsDomainQCOM domain, XrTrackingOptimizationSettingsHintQCOM hint)
{
XrResult ret;
@ -1202,6 +1659,15 @@ static XrResult WINAPI wine_xrSetViewOffsetVARJO(XrSession session, float offset
return ret;
}
static XrResult WINAPI wine_xrShareSpacesFB(XrSession session, const XrSpaceShareInfoFB *info, XrAsyncRequestIdFB *requestId)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, info, requestId);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrShareSpacesFB(((wine_XrSession *)session)->session, info, requestId);
return ret;
}
XrResult WINAPI wine_xrStopHapticFeedback(XrSession session, const XrHapticActionInfo *hapticActionInfo)
{
XrResult ret;
@ -1310,6 +1776,16 @@ static XrResult WINAPI wine_xrTriangleMeshGetVertexBufferFB(XrTriangleMeshFB mes
return ret;
}
static XrResult WINAPI wine_xrTryCreateSpatialGraphStaticNodeBindingMSFT(XrSession session, const XrSpatialGraphStaticNodeBindingCreateInfoMSFT *createInfo, XrSpatialGraphNodeBindingMSFT *nodeBinding)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", session, createInfo, nodeBinding);
ret = ((wine_XrSession *)session)->wine_instance->funcs.p_xrTryCreateSpatialGraphStaticNodeBindingMSFT(((wine_XrSession *)session)->session, createInfo, nodeBinding);
if (!ret) register_dispatchable_handle((uint64_t)*nodeBinding, &(((wine_XrSession *)session)->wine_instance->funcs));
return ret;
}
static XrResult WINAPI wine_xrUnpersistSpatialAnchorMSFT(XrSpatialAnchorStoreConnectionMSFT spatialAnchorStore, const XrSpatialAnchorPersistenceNameMSFT *spatialAnchorPersistenceName)
{
XrResult ret;
@ -1319,6 +1795,15 @@ static XrResult WINAPI wine_xrUnpersistSpatialAnchorMSFT(XrSpatialAnchorStoreCon
return ret;
}
static XrResult WINAPI wine_xrUpdateHandMeshMSFT(XrHandTrackerEXT handTracker, const XrHandMeshUpdateInfoMSFT *updateInfo, XrHandMeshMSFT *handMesh)
{
XrResult ret;
WINE_TRACE("%p, %p, %p\n", handTracker, updateInfo, handMesh);
ret = (*get_dispatch_table((uint64_t)(handTracker))).p_xrUpdateHandMeshMSFT(handTracker, updateInfo, handMesh);
return ret;
}
static XrResult WINAPI wine_xrUpdateSwapchainFB(XrSwapchain swapchain, const XrSwapchainStateBaseHeaderFB *state)
{
XrResult ret;
@ -1362,20 +1847,31 @@ static const struct openxr_func xr_dispatch_table[] =
{"xrCreateAction", &wine_xrCreateAction},
{"xrCreateActionSet", &wine_xrCreateActionSet},
{"xrCreateActionSpace", &wine_xrCreateActionSpace},
{"xrCreateBodyTrackerFB", &wine_xrCreateBodyTrackerFB},
{"xrCreateEyeTrackerFB", &wine_xrCreateEyeTrackerFB},
{"xrCreateFaceTrackerFB", &wine_xrCreateFaceTrackerFB},
{"xrCreateFacialTrackerHTC", &wine_xrCreateFacialTrackerHTC},
{"xrCreateFoveationProfileFB", &wine_xrCreateFoveationProfileFB},
{"xrCreateGeometryInstanceFB", &wine_xrCreateGeometryInstanceFB},
{"xrCreateHandMeshSpaceMSFT", &wine_xrCreateHandMeshSpaceMSFT},
{"xrCreateHandTrackerEXT", &wine_xrCreateHandTrackerEXT},
{"xrCreateInstance", &wine_xrCreateInstance},
{"xrCreateKeyboardSpaceFB", &wine_xrCreateKeyboardSpaceFB},
{"xrCreateMarkerSpaceVARJO", &wine_xrCreateMarkerSpaceVARJO},
{"xrCreatePassthroughFB", &wine_xrCreatePassthroughFB},
{"xrCreatePassthroughHTC", &wine_xrCreatePassthroughHTC},
{"xrCreatePassthroughLayerFB", &wine_xrCreatePassthroughLayerFB},
{"xrCreateReferenceSpace", &wine_xrCreateReferenceSpace},
{"xrCreateSceneMSFT", &wine_xrCreateSceneMSFT},
{"xrCreateSceneObserverMSFT", &wine_xrCreateSceneObserverMSFT},
{"xrCreateSession", &wine_xrCreateSession},
{"xrCreateSpaceUserFB", &wine_xrCreateSpaceUserFB},
{"xrCreateSpatialAnchorFB", &wine_xrCreateSpatialAnchorFB},
{"xrCreateSpatialAnchorFromPersistedNameMSFT", &wine_xrCreateSpatialAnchorFromPersistedNameMSFT},
{"xrCreateSpatialAnchorMSFT", &wine_xrCreateSpatialAnchorMSFT},
{"xrCreateSpatialAnchorSpaceMSFT", &wine_xrCreateSpatialAnchorSpaceMSFT},
{"xrCreateSpatialAnchorStoreConnectionMSFT", &wine_xrCreateSpatialAnchorStoreConnectionMSFT},
{"xrCreateSpatialGraphNodeSpaceMSFT", &wine_xrCreateSpatialGraphNodeSpaceMSFT},
{"xrCreateSwapchain", &wine_xrCreateSwapchain},
{"xrCreateTriangleMeshFB", &wine_xrCreateTriangleMeshFB},
{"xrCreateVulkanDeviceKHR", &wine_xrCreateVulkanDeviceKHR},
@ -1383,18 +1879,25 @@ static const struct openxr_func xr_dispatch_table[] =
{"xrDeserializeSceneMSFT", &wine_xrDeserializeSceneMSFT},
{"xrDestroyAction", &wine_xrDestroyAction},
{"xrDestroyActionSet", &wine_xrDestroyActionSet},
{"xrDestroyBodyTrackerFB", &wine_xrDestroyBodyTrackerFB},
{"xrDestroyEyeTrackerFB", &wine_xrDestroyEyeTrackerFB},
{"xrDestroyFaceTrackerFB", &wine_xrDestroyFaceTrackerFB},
{"xrDestroyFacialTrackerHTC", &wine_xrDestroyFacialTrackerHTC},
{"xrDestroyFoveationProfileFB", &wine_xrDestroyFoveationProfileFB},
{"xrDestroyGeometryInstanceFB", &wine_xrDestroyGeometryInstanceFB},
{"xrDestroyHandTrackerEXT", &wine_xrDestroyHandTrackerEXT},
{"xrDestroyInstance", &wine_xrDestroyInstance},
{"xrDestroyPassthroughFB", &wine_xrDestroyPassthroughFB},
{"xrDestroyPassthroughHTC", &wine_xrDestroyPassthroughHTC},
{"xrDestroyPassthroughLayerFB", &wine_xrDestroyPassthroughLayerFB},
{"xrDestroySceneMSFT", &wine_xrDestroySceneMSFT},
{"xrDestroySceneObserverMSFT", &wine_xrDestroySceneObserverMSFT},
{"xrDestroySession", &wine_xrDestroySession},
{"xrDestroySpace", &wine_xrDestroySpace},
{"xrDestroySpaceUserFB", &wine_xrDestroySpaceUserFB},
{"xrDestroySpatialAnchorMSFT", &wine_xrDestroySpatialAnchorMSFT},
{"xrDestroySpatialAnchorStoreConnectionMSFT", &wine_xrDestroySpatialAnchorStoreConnectionMSFT},
{"xrDestroySpatialGraphNodeBindingMSFT", &wine_xrDestroySpatialGraphNodeBindingMSFT},
{"xrDestroySwapchain", &wine_xrDestroySwapchain},
{"xrDestroyTriangleMeshFB", &wine_xrDestroyTriangleMeshFB},
{"xrEndFrame", &wine_xrEndFrame},
@ -1412,11 +1915,13 @@ static const struct openxr_func xr_dispatch_table[] =
{"xrEnumerateRenderModelPathsFB", &wine_xrEnumerateRenderModelPathsFB},
{"xrEnumerateReprojectionModesMSFT", &wine_xrEnumerateReprojectionModesMSFT},
{"xrEnumerateSceneComputeFeaturesMSFT", &wine_xrEnumerateSceneComputeFeaturesMSFT},
{"xrEnumerateSpaceSupportedComponentsFB", &wine_xrEnumerateSpaceSupportedComponentsFB},
{"xrEnumerateSwapchainFormats", &wine_xrEnumerateSwapchainFormats},
{"xrEnumerateSwapchainImages", &wine_xrEnumerateSwapchainImages},
{"xrEnumerateViewConfigurationViews", &wine_xrEnumerateViewConfigurationViews},
{"xrEnumerateViewConfigurations", &wine_xrEnumerateViewConfigurations},
{"xrEnumerateViveTrackerPathsHTCX", &wine_xrEnumerateViveTrackerPathsHTCX},
{"xrEraseSpaceFB", &wine_xrEraseSpaceFB},
{"xrGeometryInstanceSetTransformFB", &wine_xrGeometryInstanceSetTransformFB},
{"xrGetActionStateBoolean", &wine_xrGetActionStateBoolean},
{"xrGetActionStateFloat", &wine_xrGetActionStateFloat},
@ -1424,6 +1929,7 @@ static const struct openxr_func xr_dispatch_table[] =
{"xrGetActionStateVector2f", &wine_xrGetActionStateVector2f},
{"xrGetAudioInputDeviceGuidOculus", &wine_xrGetAudioInputDeviceGuidOculus},
{"xrGetAudioOutputDeviceGuidOculus", &wine_xrGetAudioOutputDeviceGuidOculus},
{"xrGetBodySkeletonFB", &wine_xrGetBodySkeletonFB},
{"xrGetControllerModelKeyMSFT", &wine_xrGetControllerModelKeyMSFT},
{"xrGetControllerModelPropertiesMSFT", &wine_xrGetControllerModelPropertiesMSFT},
{"xrGetControllerModelStateMSFT", &wine_xrGetControllerModelStateMSFT},
@ -1432,11 +1938,15 @@ static const struct openxr_func xr_dispatch_table[] =
{"xrGetD3D12GraphicsRequirementsKHR", &wine_xrGetD3D12GraphicsRequirementsKHR},
{"xrGetDeviceSampleRateFB", &wine_xrGetDeviceSampleRateFB},
{"xrGetDisplayRefreshRateFB", &wine_xrGetDisplayRefreshRateFB},
{"xrGetEyeGazesFB", &wine_xrGetEyeGazesFB},
{"xrGetFaceExpressionWeightsFB", &wine_xrGetFaceExpressionWeightsFB},
{"xrGetFacialExpressionsHTC", &wine_xrGetFacialExpressionsHTC},
{"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},
@ -1445,6 +1955,16 @@ static const struct openxr_func xr_dispatch_table[] =
{"xrGetSceneComputeStateMSFT", &wine_xrGetSceneComputeStateMSFT},
{"xrGetSceneMeshBuffersMSFT", &wine_xrGetSceneMeshBuffersMSFT},
{"xrGetSerializedSceneFragmentDataMSFT", &wine_xrGetSerializedSceneFragmentDataMSFT},
{"xrGetSpaceBoundary2DFB", &wine_xrGetSpaceBoundary2DFB},
{"xrGetSpaceBoundingBox2DFB", &wine_xrGetSpaceBoundingBox2DFB},
{"xrGetSpaceBoundingBox3DFB", &wine_xrGetSpaceBoundingBox3DFB},
{"xrGetSpaceComponentStatusFB", &wine_xrGetSpaceComponentStatusFB},
{"xrGetSpaceContainerFB", &wine_xrGetSpaceContainerFB},
{"xrGetSpaceRoomLayoutFB", &wine_xrGetSpaceRoomLayoutFB},
{"xrGetSpaceSemanticLabelsFB", &wine_xrGetSpaceSemanticLabelsFB},
{"xrGetSpaceUserIdFB", &wine_xrGetSpaceUserIdFB},
{"xrGetSpaceUuidFB", &wine_xrGetSpaceUuidFB},
{"xrGetSpatialGraphNodeBindingPropertiesMSFT", &wine_xrGetSpatialGraphNodeBindingPropertiesMSFT},
{"xrGetSwapchainStateFB", &wine_xrGetSwapchainStateFB},
{"xrGetSystem", &wine_xrGetSystem},
{"xrGetSystemProperties", &wine_xrGetSystemProperties},
@ -1458,6 +1978,7 @@ static const struct openxr_func xr_dispatch_table[] =
{"xrGetVulkanInstanceExtensionsKHR", &wine_xrGetVulkanInstanceExtensionsKHR},
{"xrLoadControllerModelMSFT", &wine_xrLoadControllerModelMSFT},
{"xrLoadRenderModelFB", &wine_xrLoadRenderModelFB},
{"xrLocateBodyJointsFB", &wine_xrLocateBodyJointsFB},
{"xrLocateHandJointsEXT", &wine_xrLocateHandJointsEXT},
{"xrLocateSceneComponentsMSFT", &wine_xrLocateSceneComponentsMSFT},
{"xrLocateSpace", &wine_xrLocateSpace},
@ -1474,12 +1995,14 @@ static const struct openxr_func xr_dispatch_table[] =
{"xrPollEvent", &wine_xrPollEvent},
{"xrQueryPerformanceMetricsCounterMETA", &wine_xrQueryPerformanceMetricsCounterMETA},
{"xrQuerySpacesFB", &wine_xrQuerySpacesFB},
{"xrQuerySystemTrackedKeyboardFB", &wine_xrQuerySystemTrackedKeyboardFB},
{"xrReleaseSwapchainImage", &wine_xrReleaseSwapchainImage},
{"xrRequestDisplayRefreshRateFB", &wine_xrRequestDisplayRefreshRateFB},
{"xrRequestExitSession", &wine_xrRequestExitSession},
{"xrRequestSceneCaptureFB", &wine_xrRequestSceneCaptureFB},
{"xrResultToString", &wine_xrResultToString},
{"xrRetrieveSpaceQueryResultsFB", &wine_xrRetrieveSpaceQueryResultsFB},
{"xrSaveSpaceFB", &wine_xrSaveSpaceFB},
{"xrSaveSpaceListFB", &wine_xrSaveSpaceListFB},
{"xrSetColorSpaceFB", &wine_xrSetColorSpaceFB},
{"xrSetDigitalLensControlALMALENCE", &wine_xrSetDigitalLensControlALMALENCE},
@ -1489,9 +2012,14 @@ static const struct openxr_func xr_dispatch_table[] =
{"xrSetInputDeviceStateBoolEXT", &wine_xrSetInputDeviceStateBoolEXT},
{"xrSetInputDeviceStateFloatEXT", &wine_xrSetInputDeviceStateFloatEXT},
{"xrSetInputDeviceStateVector2fEXT", &wine_xrSetInputDeviceStateVector2fEXT},
{"xrSetMarkerTrackingPredictionVARJO", &wine_xrSetMarkerTrackingPredictionVARJO},
{"xrSetMarkerTrackingTimeoutVARJO", &wine_xrSetMarkerTrackingTimeoutVARJO},
{"xrSetMarkerTrackingVARJO", &wine_xrSetMarkerTrackingVARJO},
{"xrSetPerformanceMetricsStateMETA", &wine_xrSetPerformanceMetricsStateMETA},
{"xrSetSpaceComponentStatusFB", &wine_xrSetSpaceComponentStatusFB},
{"xrSetTrackingOptimizationSettingsHintQCOM", &wine_xrSetTrackingOptimizationSettingsHintQCOM},
{"xrSetViewOffsetVARJO", &wine_xrSetViewOffsetVARJO},
{"xrShareSpacesFB", &wine_xrShareSpacesFB},
{"xrStopHapticFeedback", &wine_xrStopHapticFeedback},
{"xrStringToPath", &wine_xrStringToPath},
{"xrStructureTypeToString", &wine_xrStructureTypeToString},
@ -1504,7 +2032,9 @@ static const struct openxr_func xr_dispatch_table[] =
{"xrTriangleMeshEndVertexBufferUpdateFB", &wine_xrTriangleMeshEndVertexBufferUpdateFB},
{"xrTriangleMeshGetIndexBufferFB", &wine_xrTriangleMeshGetIndexBufferFB},
{"xrTriangleMeshGetVertexBufferFB", &wine_xrTriangleMeshGetVertexBufferFB},
{"xrTryCreateSpatialGraphStaticNodeBindingMSFT", &wine_xrTryCreateSpatialGraphStaticNodeBindingMSFT},
{"xrUnpersistSpatialAnchorMSFT", &wine_xrUnpersistSpatialAnchorMSFT},
{"xrUpdateHandMeshMSFT", &wine_xrUpdateHandMeshMSFT},
{"xrUpdateSwapchainFB", &wine_xrUpdateSwapchainFB},
{"xrWaitFrame", &wine_xrWaitFrame},
{"xrWaitSwapchainImage", &wine_xrWaitSwapchainImage},
@ -1545,6 +2075,7 @@ static const char * const xr_extensions[] =
"XR_EXT_uuid",
"XR_EXT_view_configuration_depth_range",
"XR_EXT_win32_appcontainer_compatible",
"XR_FB_body_tracking",
"XR_FB_color_space",
"XR_FB_composition_layer_alpha_blend",
"XR_FB_composition_layer_depth_test",
@ -1552,6 +2083,8 @@ static const char * const xr_extensions[] =
"XR_FB_composition_layer_secure_content",
"XR_FB_composition_layer_settings",
"XR_FB_display_refresh_rate",
"XR_FB_eye_tracking_social",
"XR_FB_face_tracking",
"XR_FB_foveation",
"XR_FB_foveation_configuration",
"XR_FB_foveation_vulkan",
@ -1560,21 +2093,30 @@ static const char * const xr_extensions[] =
"XR_FB_hand_tracking_mesh",
"XR_FB_haptic_amplitude_envelope",
"XR_FB_haptic_pcm",
"XR_FB_keyboard_tracking",
"XR_FB_passthrough",
"XR_FB_passthrough_keyboard_hands",
"XR_FB_render_model",
"XR_FB_scene",
"XR_FB_scene_capture",
"XR_FB_space_warp",
"XR_FB_spatial_entity",
"XR_FB_spatial_entity_container",
"XR_FB_spatial_entity_query",
"XR_FB_spatial_entity_sharing",
"XR_FB_spatial_entity_storage",
"XR_FB_spatial_entity_storage_batch",
"XR_FB_spatial_entity_user",
"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_facial_tracking",
"XR_HTC_foveation",
"XR_HTC_hand_interaction",
"XR_HTC_passthrough",
"XR_HTC_vive_cosmos_controller_interaction",
"XR_HTC_vive_focus3_controller_interaction",
"XR_HTC_vive_wrist_tracker_interaction",
@ -1610,12 +2152,14 @@ static const char * const xr_extensions[] =
"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",
@ -1626,6 +2170,7 @@ static const char * const xr_extensions[] =
"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",
};

128
wineopenxr/openxr_thunks.h
View file

@ -51,6 +51,23 @@ XrResult WINAPI wine_xrPollEvent(XrInstance instance, XrEventDataBuffer *eventDa
/* Private thunks */
typedef struct XrKeyboardSpaceCreateInfoFB_host
{
XrStructureType type;
void *next;
uint64_t trackedKeyboardId;
} XrKeyboardSpaceCreateInfoFB_host;
typedef struct XrMarkerSpaceCreateInfoVARJO_host
{
XrStructureType type;
const void *next;
uint64_t markerId;
XrPosef poseInMarkerSpace;
} XrMarkerSpaceCreateInfoVARJO_host;
typedef struct XrSceneMeshBuffersGetInfoMSFT_host
{
XrStructureType type;
@ -59,6 +76,15 @@ typedef struct XrSceneMeshBuffersGetInfoMSFT_host
} XrSceneMeshBuffersGetInfoMSFT_host;
typedef struct XrKeyboardTrackingDescriptionFB_host
{
uint64_t trackedKeyboardId;
XrVector3f size;
XrKeyboardTrackingFlagsFB flags;
char name[XR_MAX_KEYBOARD_TRACKING_NAME_SIZE_FB];
} XrKeyboardTrackingDescriptionFB_host;
XrResult convert_XrInstanceCreateInfo_struct_chain(const void *next, XrInstanceCreateInfo *out_struct);
void free_XrInstanceCreateInfo_struct_chain(XrInstanceCreateInfo *s);
@ -78,19 +104,38 @@ struct openxr_instance_funcs
XrResult (*p_xrCreateAction)(XrActionSet, const XrActionCreateInfo *, XrAction *);
XrResult (*p_xrCreateActionSet)(XrInstance, const XrActionSetCreateInfo *, XrActionSet *);
XrResult (*p_xrCreateActionSpace)(XrSession, const XrActionSpaceCreateInfo *, XrSpace *);
XrResult (*p_xrCreateBodyTrackerFB)(XrSession, const XrBodyTrackerCreateInfoFB *, XrBodyTrackerFB *);
XrResult (*p_xrCreateEyeTrackerFB)(XrSession, const XrEyeTrackerCreateInfoFB *, XrEyeTrackerFB *);
XrResult (*p_xrCreateFaceTrackerFB)(XrSession, const XrFaceTrackerCreateInfoFB *, XrFaceTrackerFB *);
XrResult (*p_xrCreateFacialTrackerHTC)(XrSession, const XrFacialTrackerCreateInfoHTC *, XrFacialTrackerHTC *);
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_xrCreateKeyboardSpaceFB)(XrSession, const XrKeyboardSpaceCreateInfoFB_host *, XrSpace *);
#else
XrResult (*p_xrCreateKeyboardSpaceFB)(XrSession, const XrKeyboardSpaceCreateInfoFB *, XrSpace *);
#endif
#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_xrCreatePassthroughHTC)(XrSession, const XrPassthroughCreateInfoHTC *, XrPassthroughHTC *);
XrResult (*p_xrCreatePassthroughLayerFB)(XrSession, const XrPassthroughLayerCreateInfoFB *, XrPassthroughLayerFB *);
XrResult (*p_xrCreateReferenceSpace)(XrSession, const XrReferenceSpaceCreateInfo *, XrSpace *);
XrResult (*p_xrCreateSceneMSFT)(XrSceneObserverMSFT, const XrSceneCreateInfoMSFT *, XrSceneMSFT *);
XrResult (*p_xrCreateSceneObserverMSFT)(XrSession, const XrSceneObserverCreateInfoMSFT *, XrSceneObserverMSFT *);
XrResult (*p_xrCreateSession)(XrInstance, const XrSessionCreateInfo *, XrSession *);
XrResult (*p_xrCreateSpaceUserFB)(XrSession, const XrSpaceUserCreateInfoFB *, XrSpaceUserFB *);
XrResult (*p_xrCreateSpatialAnchorFB)(XrSession, const XrSpatialAnchorCreateInfoFB *, XrAsyncRequestIdFB *);
XrResult (*p_xrCreateSpatialAnchorFromPersistedNameMSFT)(XrSession, const XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT *, XrSpatialAnchorMSFT *);
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 *);
@ -98,17 +143,24 @@ struct openxr_instance_funcs
XrResult (*p_xrDeserializeSceneMSFT)(XrSceneObserverMSFT, const XrSceneDeserializeInfoMSFT *);
XrResult (*p_xrDestroyAction)(XrAction);
XrResult (*p_xrDestroyActionSet)(XrActionSet);
XrResult (*p_xrDestroyBodyTrackerFB)(XrBodyTrackerFB);
XrResult (*p_xrDestroyEyeTrackerFB)(XrEyeTrackerFB);
XrResult (*p_xrDestroyFaceTrackerFB)(XrFaceTrackerFB);
XrResult (*p_xrDestroyFacialTrackerHTC)(XrFacialTrackerHTC);
XrResult (*p_xrDestroyFoveationProfileFB)(XrFoveationProfileFB);
XrResult (*p_xrDestroyGeometryInstanceFB)(XrGeometryInstanceFB);
XrResult (*p_xrDestroyHandTrackerEXT)(XrHandTrackerEXT);
XrResult (*p_xrDestroyPassthroughFB)(XrPassthroughFB);
XrResult (*p_xrDestroyPassthroughHTC)(XrPassthroughHTC);
XrResult (*p_xrDestroyPassthroughLayerFB)(XrPassthroughLayerFB);
XrResult (*p_xrDestroySceneMSFT)(XrSceneMSFT);
XrResult (*p_xrDestroySceneObserverMSFT)(XrSceneObserverMSFT);
XrResult (*p_xrDestroySession)(XrSession);
XrResult (*p_xrDestroySpace)(XrSpace);
XrResult (*p_xrDestroySpaceUserFB)(XrSpaceUserFB);
XrResult (*p_xrDestroySpatialAnchorMSFT)(XrSpatialAnchorMSFT);
XrResult (*p_xrDestroySpatialAnchorStoreConnectionMSFT)(XrSpatialAnchorStoreConnectionMSFT);
XrResult (*p_xrDestroySpatialGraphNodeBindingMSFT)(XrSpatialGraphNodeBindingMSFT);
XrResult (*p_xrDestroySwapchain)(XrSwapchain);
XrResult (*p_xrDestroyTriangleMeshFB)(XrTriangleMeshFB);
XrResult (*p_xrEndFrame)(XrSession, const XrFrameEndInfo *);
@ -125,11 +177,13 @@ struct openxr_instance_funcs
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_xrEnumerateSpaceSupportedComponentsFB)(XrSpace, uint32_t, uint32_t *, XrSpaceComponentTypeFB *);
XrResult (*p_xrEnumerateSwapchainFormats)(XrSession, uint32_t, uint32_t *, int64_t *);
XrResult (*p_xrEnumerateSwapchainImages)(XrSwapchain, uint32_t, uint32_t *, XrSwapchainImageBaseHeader *);
XrResult (*p_xrEnumerateViewConfigurationViews)(XrInstance, XrSystemId, XrViewConfigurationType, uint32_t, uint32_t *, XrViewConfigurationView *);
XrResult (*p_xrEnumerateViewConfigurations)(XrInstance, XrSystemId, uint32_t, uint32_t *, XrViewConfigurationType *);
XrResult (*p_xrEnumerateViveTrackerPathsHTCX)(XrInstance, uint32_t, uint32_t *, XrViveTrackerPathsHTCX *);
XrResult (*p_xrEraseSpaceFB)(XrSession, const XrSpaceEraseInfoFB *, XrAsyncRequestIdFB *);
XrResult (*p_xrGeometryInstanceSetTransformFB)(XrGeometryInstanceFB, const XrGeometryInstanceTransformFB *);
XrResult (*p_xrGetActionStateBoolean)(XrSession, const XrActionStateGetInfo *, XrActionStateBoolean *);
XrResult (*p_xrGetActionStateFloat)(XrSession, const XrActionStateGetInfo *, XrActionStateFloat *);
@ -137,16 +191,21 @@ struct openxr_instance_funcs
XrResult (*p_xrGetActionStateVector2f)(XrSession, const XrActionStateGetInfo *, XrActionStateVector2f *);
XrResult (*p_xrGetAudioInputDeviceGuidOculus)(XrInstance, wchar_t[]);
XrResult (*p_xrGetAudioOutputDeviceGuidOculus)(XrInstance, wchar_t[]);
XrResult (*p_xrGetBodySkeletonFB)(XrBodyTrackerFB, XrBodySkeletonFB *);
XrResult (*p_xrGetControllerModelKeyMSFT)(XrSession, XrPath, XrControllerModelKeyStateMSFT *);
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_xrGetEyeGazesFB)(XrEyeTrackerFB, const XrEyeGazesInfoFB *, XrEyeGazesFB *);
XrResult (*p_xrGetFaceExpressionWeightsFB)(XrFaceTrackerFB, const XrFaceExpressionInfoFB *, XrFaceExpressionWeightsFB *);
XrResult (*p_xrGetFacialExpressionsHTC)(XrFacialTrackerHTC, XrFacialExpressionsHTC *);
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 *);
@ -159,6 +218,16 @@ struct openxr_instance_funcs
XrResult (*p_xrGetSceneMeshBuffersMSFT)(XrSceneMSFT, const XrSceneMeshBuffersGetInfoMSFT *, XrSceneMeshBuffersMSFT *);
#endif
XrResult (*p_xrGetSerializedSceneFragmentDataMSFT)(XrSceneMSFT, const XrSerializedSceneFragmentDataGetInfoMSFT *, uint32_t, uint32_t *, uint8_t *);
XrResult (*p_xrGetSpaceBoundary2DFB)(XrSession, XrSpace, XrBoundary2DFB *);
XrResult (*p_xrGetSpaceBoundingBox2DFB)(XrSession, XrSpace, XrRect2Df *);
XrResult (*p_xrGetSpaceBoundingBox3DFB)(XrSession, XrSpace, XrRect3DfFB *);
XrResult (*p_xrGetSpaceComponentStatusFB)(XrSpace, XrSpaceComponentTypeFB, XrSpaceComponentStatusFB *);
XrResult (*p_xrGetSpaceContainerFB)(XrSession, XrSpace, XrSpaceContainerFB *);
XrResult (*p_xrGetSpaceRoomLayoutFB)(XrSession, XrSpace, XrRoomLayoutFB *);
XrResult (*p_xrGetSpaceSemanticLabelsFB)(XrSession, XrSpace, XrSemanticLabelsFB *);
XrResult (*p_xrGetSpaceUserIdFB)(XrSpaceUserFB, XrSpaceUserIdFB *);
XrResult (*p_xrGetSpaceUuidFB)(XrSpace, XrUuidEXT *);
XrResult (*p_xrGetSpatialGraphNodeBindingPropertiesMSFT)(XrSpatialGraphNodeBindingMSFT, const XrSpatialGraphNodeBindingPropertiesGetInfoMSFT *, XrSpatialGraphNodeBindingPropertiesMSFT *);
XrResult (*p_xrGetSwapchainStateFB)(XrSwapchain, XrSwapchainStateBaseHeaderFB *);
XrResult (*p_xrGetSystem)(XrInstance, const XrSystemGetInfo *, XrSystemId *);
XrResult (*p_xrGetSystemProperties)(XrInstance, XrSystemId, XrSystemProperties *);
@ -172,6 +241,7 @@ struct openxr_instance_funcs
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_xrLocateBodyJointsFB)(XrBodyTrackerFB, const XrBodyJointsLocateInfoFB *, XrBodyJointLocationsFB *);
XrResult (*p_xrLocateHandJointsEXT)(XrHandTrackerEXT, const XrHandJointsLocateInfoEXT *, XrHandJointLocationsEXT *);
XrResult (*p_xrLocateSceneComponentsMSFT)(XrSceneMSFT, const XrSceneComponentsLocateInfoMSFT *, XrSceneComponentLocationsMSFT *);
XrResult (*p_xrLocateSpace)(XrSpace, XrSpace, XrTime, XrSpaceLocation *);
@ -188,12 +258,18 @@ struct openxr_instance_funcs
XrResult (*p_xrPollEvent)(XrInstance, XrEventDataBuffer *);
XrResult (*p_xrQueryPerformanceMetricsCounterMETA)(XrSession, XrPath, XrPerformanceMetricsCounterMETA *);
XrResult (*p_xrQuerySpacesFB)(XrSession, const XrSpaceQueryInfoBaseHeaderFB *, XrAsyncRequestIdFB *);
#if defined(USE_STRUCT_CONVERSION)
XrResult (*p_xrQuerySystemTrackedKeyboardFB)(XrSession, const XrKeyboardTrackingQueryFB *, XrKeyboardTrackingDescriptionFB_host *);
#else
XrResult (*p_xrQuerySystemTrackedKeyboardFB)(XrSession, const XrKeyboardTrackingQueryFB *, XrKeyboardTrackingDescriptionFB *);
#endif
XrResult (*p_xrReleaseSwapchainImage)(XrSwapchain, const XrSwapchainImageReleaseInfo *);
XrResult (*p_xrRequestDisplayRefreshRateFB)(XrSession, float);
XrResult (*p_xrRequestExitSession)(XrSession);
XrResult (*p_xrRequestSceneCaptureFB)(XrSession, const XrSceneCaptureRequestInfoFB *, XrAsyncRequestIdFB *);
XrResult (*p_xrResultToString)(XrInstance, XrResult, char[]);
XrResult (*p_xrRetrieveSpaceQueryResultsFB)(XrSession, XrAsyncRequestIdFB, XrSpaceQueryResultsFB *);
XrResult (*p_xrSaveSpaceFB)(XrSession, const XrSpaceSaveInfoFB *, XrAsyncRequestIdFB *);
XrResult (*p_xrSaveSpaceListFB)(XrSession, const XrSpaceListSaveInfoFB *, XrAsyncRequestIdFB *);
XrResult (*p_xrSetColorSpaceFB)(XrSession, const XrColorSpaceFB);
XrResult (*p_xrSetDigitalLensControlALMALENCE)(XrSession, const XrDigitalLensControlALMALENCE *);
@ -203,9 +279,14 @@ struct openxr_instance_funcs
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_xrSetSpaceComponentStatusFB)(XrSpace, const XrSpaceComponentStatusSetInfoFB *, XrAsyncRequestIdFB *);
XrResult (*p_xrSetTrackingOptimizationSettingsHintQCOM)(XrSession, XrTrackingOptimizationSettingsDomainQCOM, XrTrackingOptimizationSettingsHintQCOM);
XrResult (*p_xrSetViewOffsetVARJO)(XrSession, float);
XrResult (*p_xrShareSpacesFB)(XrSession, const XrSpaceShareInfoFB *, XrAsyncRequestIdFB *);
XrResult (*p_xrStopHapticFeedback)(XrSession, const XrHapticActionInfo *);
XrResult (*p_xrStringToPath)(XrInstance, const char *, XrPath *);
XrResult (*p_xrStructureTypeToString)(XrInstance, XrStructureType, char[]);
@ -218,7 +299,9 @@ struct openxr_instance_funcs
XrResult (*p_xrTriangleMeshEndVertexBufferUpdateFB)(XrTriangleMeshFB);
XrResult (*p_xrTriangleMeshGetIndexBufferFB)(XrTriangleMeshFB, uint32_t **);
XrResult (*p_xrTriangleMeshGetVertexBufferFB)(XrTriangleMeshFB, XrVector3f **);
XrResult (*p_xrTryCreateSpatialGraphStaticNodeBindingMSFT)(XrSession, const XrSpatialGraphStaticNodeBindingCreateInfoMSFT *, XrSpatialGraphNodeBindingMSFT *);
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 *);
@ -237,19 +320,30 @@ struct openxr_instance_funcs
USE_XR_FUNC(xrCreateAction) \
USE_XR_FUNC(xrCreateActionSet) \
USE_XR_FUNC(xrCreateActionSpace) \
USE_XR_FUNC(xrCreateBodyTrackerFB) \
USE_XR_FUNC(xrCreateEyeTrackerFB) \
USE_XR_FUNC(xrCreateFaceTrackerFB) \
USE_XR_FUNC(xrCreateFacialTrackerHTC) \
USE_XR_FUNC(xrCreateFoveationProfileFB) \
USE_XR_FUNC(xrCreateGeometryInstanceFB) \
USE_XR_FUNC(xrCreateHandMeshSpaceMSFT) \
USE_XR_FUNC(xrCreateHandTrackerEXT) \
USE_XR_FUNC(xrCreateKeyboardSpaceFB) \
USE_XR_FUNC(xrCreateMarkerSpaceVARJO) \
USE_XR_FUNC(xrCreatePassthroughFB) \
USE_XR_FUNC(xrCreatePassthroughHTC) \
USE_XR_FUNC(xrCreatePassthroughLayerFB) \
USE_XR_FUNC(xrCreateReferenceSpace) \
USE_XR_FUNC(xrCreateSceneMSFT) \
USE_XR_FUNC(xrCreateSceneObserverMSFT) \
USE_XR_FUNC(xrCreateSession) \
USE_XR_FUNC(xrCreateSpaceUserFB) \
USE_XR_FUNC(xrCreateSpatialAnchorFB) \
USE_XR_FUNC(xrCreateSpatialAnchorFromPersistedNameMSFT) \
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) \
@ -257,17 +351,24 @@ struct openxr_instance_funcs
USE_XR_FUNC(xrDeserializeSceneMSFT) \
USE_XR_FUNC(xrDestroyAction) \
USE_XR_FUNC(xrDestroyActionSet) \
USE_XR_FUNC(xrDestroyBodyTrackerFB) \
USE_XR_FUNC(xrDestroyEyeTrackerFB) \
USE_XR_FUNC(xrDestroyFaceTrackerFB) \
USE_XR_FUNC(xrDestroyFacialTrackerHTC) \
USE_XR_FUNC(xrDestroyFoveationProfileFB) \
USE_XR_FUNC(xrDestroyGeometryInstanceFB) \
USE_XR_FUNC(xrDestroyHandTrackerEXT) \
USE_XR_FUNC(xrDestroyPassthroughFB) \
USE_XR_FUNC(xrDestroyPassthroughHTC) \
USE_XR_FUNC(xrDestroyPassthroughLayerFB) \
USE_XR_FUNC(xrDestroySceneMSFT) \
USE_XR_FUNC(xrDestroySceneObserverMSFT) \
USE_XR_FUNC(xrDestroySession) \
USE_XR_FUNC(xrDestroySpace) \
USE_XR_FUNC(xrDestroySpaceUserFB) \
USE_XR_FUNC(xrDestroySpatialAnchorMSFT) \
USE_XR_FUNC(xrDestroySpatialAnchorStoreConnectionMSFT) \
USE_XR_FUNC(xrDestroySpatialGraphNodeBindingMSFT) \
USE_XR_FUNC(xrDestroySwapchain) \
USE_XR_FUNC(xrDestroyTriangleMeshFB) \
USE_XR_FUNC(xrEndFrame) \
@ -284,11 +385,13 @@ struct openxr_instance_funcs
USE_XR_FUNC(xrEnumerateRenderModelPathsFB) \
USE_XR_FUNC(xrEnumerateReprojectionModesMSFT) \
USE_XR_FUNC(xrEnumerateSceneComputeFeaturesMSFT) \
USE_XR_FUNC(xrEnumerateSpaceSupportedComponentsFB) \
USE_XR_FUNC(xrEnumerateSwapchainFormats) \
USE_XR_FUNC(xrEnumerateSwapchainImages) \
USE_XR_FUNC(xrEnumerateViewConfigurationViews) \
USE_XR_FUNC(xrEnumerateViewConfigurations) \
USE_XR_FUNC(xrEnumerateViveTrackerPathsHTCX) \
USE_XR_FUNC(xrEraseSpaceFB) \
USE_XR_FUNC(xrGeometryInstanceSetTransformFB) \
USE_XR_FUNC(xrGetActionStateBoolean) \
USE_XR_FUNC(xrGetActionStateFloat) \
@ -296,16 +399,21 @@ struct openxr_instance_funcs
USE_XR_FUNC(xrGetActionStateVector2f) \
USE_XR_FUNC(xrGetAudioInputDeviceGuidOculus) \
USE_XR_FUNC(xrGetAudioOutputDeviceGuidOculus) \
USE_XR_FUNC(xrGetBodySkeletonFB) \
USE_XR_FUNC(xrGetControllerModelKeyMSFT) \
USE_XR_FUNC(xrGetControllerModelPropertiesMSFT) \
USE_XR_FUNC(xrGetControllerModelStateMSFT) \
USE_XR_FUNC(xrGetCurrentInteractionProfile) \
USE_XR_FUNC(xrGetDeviceSampleRateFB) \
USE_XR_FUNC(xrGetDisplayRefreshRateFB) \
USE_XR_FUNC(xrGetEyeGazesFB) \
USE_XR_FUNC(xrGetFaceExpressionWeightsFB) \
USE_XR_FUNC(xrGetFacialExpressionsHTC) \
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) \
@ -314,6 +422,16 @@ struct openxr_instance_funcs
USE_XR_FUNC(xrGetSceneComputeStateMSFT) \
USE_XR_FUNC(xrGetSceneMeshBuffersMSFT) \
USE_XR_FUNC(xrGetSerializedSceneFragmentDataMSFT) \
USE_XR_FUNC(xrGetSpaceBoundary2DFB) \
USE_XR_FUNC(xrGetSpaceBoundingBox2DFB) \
USE_XR_FUNC(xrGetSpaceBoundingBox3DFB) \
USE_XR_FUNC(xrGetSpaceComponentStatusFB) \
USE_XR_FUNC(xrGetSpaceContainerFB) \
USE_XR_FUNC(xrGetSpaceRoomLayoutFB) \
USE_XR_FUNC(xrGetSpaceSemanticLabelsFB) \
USE_XR_FUNC(xrGetSpaceUserIdFB) \
USE_XR_FUNC(xrGetSpaceUuidFB) \
USE_XR_FUNC(xrGetSpatialGraphNodeBindingPropertiesMSFT) \
USE_XR_FUNC(xrGetSwapchainStateFB) \
USE_XR_FUNC(xrGetSystem) \
USE_XR_FUNC(xrGetSystemProperties) \
@ -327,6 +445,7 @@ struct openxr_instance_funcs
USE_XR_FUNC(xrGetVulkanInstanceExtensionsKHR) \
USE_XR_FUNC(xrLoadControllerModelMSFT) \
USE_XR_FUNC(xrLoadRenderModelFB) \
USE_XR_FUNC(xrLocateBodyJointsFB) \
USE_XR_FUNC(xrLocateHandJointsEXT) \
USE_XR_FUNC(xrLocateSceneComponentsMSFT) \
USE_XR_FUNC(xrLocateSpace) \
@ -343,12 +462,14 @@ struct openxr_instance_funcs
USE_XR_FUNC(xrPollEvent) \
USE_XR_FUNC(xrQueryPerformanceMetricsCounterMETA) \
USE_XR_FUNC(xrQuerySpacesFB) \
USE_XR_FUNC(xrQuerySystemTrackedKeyboardFB) \
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(xrSaveSpaceFB) \
USE_XR_FUNC(xrSaveSpaceListFB) \
USE_XR_FUNC(xrSetColorSpaceFB) \
USE_XR_FUNC(xrSetDigitalLensControlALMALENCE) \
@ -358,9 +479,14 @@ struct openxr_instance_funcs
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(xrSetSpaceComponentStatusFB) \
USE_XR_FUNC(xrSetTrackingOptimizationSettingsHintQCOM) \
USE_XR_FUNC(xrSetViewOffsetVARJO) \
USE_XR_FUNC(xrShareSpacesFB) \
USE_XR_FUNC(xrStopHapticFeedback) \
USE_XR_FUNC(xrStringToPath) \
USE_XR_FUNC(xrStructureTypeToString) \
@ -373,7 +499,9 @@ struct openxr_instance_funcs
USE_XR_FUNC(xrTriangleMeshEndVertexBufferUpdateFB) \
USE_XR_FUNC(xrTriangleMeshGetIndexBufferFB) \
USE_XR_FUNC(xrTriangleMeshGetVertexBufferFB) \
USE_XR_FUNC(xrTryCreateSpatialGraphStaticNodeBindingMSFT) \
USE_XR_FUNC(xrUnpersistSpatialAnchorMSFT) \
USE_XR_FUNC(xrUpdateHandMeshMSFT) \
USE_XR_FUNC(xrUpdateSwapchainFB) \
USE_XR_FUNC(xrWaitFrame) \
USE_XR_FUNC(xrWaitSwapchainImage)

1571
wineopenxr/wineopenxr.h
View file

File diff suppressed because it is too large Load diff