diff --git a/KhronosRegistry/xr.xml b/KhronosRegistry/xr.xml
index ecfe015..be125c3 100644
--- a/KhronosRegistry/xr.xml
+++ b/KhronosRegistry/xr.xml
@@ -135,7 +135,7 @@ maintained in the default branch of the Khronos OpenXR GitHub project.
updates them automatically by processing a line at a time.
-->
// OpenXR current version number.
-#define XR_CURRENT_API_VERSION XR_MAKE_VERSION(1, 1, 40)
+#define XR_CURRENT_API_VERSION XR_MAKE_VERSION(1, 1, 41)
+
+#define XR_BODY_JOINT_COUNT_HTC 26
+
typedef uint32_t XrBool32;
typedef uint64_t XrFlags64;
@@ -427,6 +431,9 @@ maintained in the default branch of the Khronos OpenXR GitHub project.
typedef XrFlags64 XrEnvironmentDepthProviderCreateFlagsMETA;
typedef XrFlags64 XrEnvironmentDepthSwapchainCreateFlagsMETA;
+
+ typedef XrFlags64 XrWorldMeshDetectorFlagsML;
+
XR_DEFINE_HANDLE(XrInstance)
@@ -482,6 +489,9 @@ maintained in the default branch of the Khronos OpenXR GitHub project.
XR_DEFINE_HANDLE(XrVirtualKeyboardMETA)
+
+ XR_DEFINE_HANDLE(XrSpatialAnchorsStorageML)
+
XR_DEFINE_HANDLE(XrExportedLocalizationMapML)
@@ -495,6 +505,12 @@ maintained in the default branch of the Khronos OpenXR GitHub project.
XR_DEFINE_HANDLE(XrEnvironmentDepthProviderMETA)
XR_DEFINE_HANDLE(XrEnvironmentDepthSwapchainMETA)
+
+ XR_DEFINE_HANDLE(XrBodyTrackerHTC)
+
+
+ XR_DEFINE_HANDLE(XrWorldMeshDetectorML)
+
@@ -703,6 +719,20 @@ maintained in the default branch of the Khronos OpenXR GitHub project.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
float x
@@ -3025,6 +3055,45 @@ typedef XrResult (XRAPI_PTR *PFN_xrCreateApiLayerInstance)(
XrViveTrackerPathsHTCX* paths
+
+
+ XrStructureType type
+ void* next
+ XrBool32 supportsBodyTracking
+
+
+ XrStructureType type
+ const void* next
+ XrBodyJointSetHTC bodyJointSet
+
+
+ XrPosef pose
+
+
+ XrStructureType type
+ void* next
+ uint32_t jointCount
+ XrBodySkeletonJointHTC* joints
+
+
+ XrStructureType type
+ const void* next
+ XrSpace baseSpace
+ XrTime time
+
+
+ XrSpaceLocationFlags locationFlags
+ XrPosef pose
+
+
+ XrStructureType type
+ void* next
+ XrSpaceLocationFlags combinedLocationFlags
+ XrBodyJointConfidenceHTC confidenceLevel
+ uint32_t jointLocationCount
+ XrBodyJointLocationHTC* jointLocations
+ uint32_t skeletonGenerationId
+
@@ -3801,6 +3870,250 @@ typedef XrResult (XRAPI_PTR *PFN_xrCreateApiLayerInstance)(
XrVector3f angularVelocity
+
+
+ XrStructureType type
+ const void* next
+ XrBool32 suppressNotifications
+
+
+
+
+ XrStructureType type
+ const void* next
+
+
+
+ XrStructureType type
+ const void* next
+ XrSpace baseSpace
+ XrPosef poseInBaseSpace
+ XrTime time
+
+
+
+ XrStructureType type
+ void* next
+ XrResult futureResult
+ uint32_t spaceCount
+ XrSpace* spaces
+
+
+
+ XrStructureType type
+ void* next
+ XrSpatialAnchorConfidenceML confidence
+
+
+
+
+ XrStructureType type
+ const void* next
+
+
+
+ XrStructureType type
+ const void* next
+
+
+
+ XrStructureType type
+ const void* next
+ XrSpace baseSpace
+ XrVector3f center
+ XrTime time
+ float radius
+
+
+
+ XrStructureType type
+ void* next
+ XrResult futureResult
+ uint32_t uuidCapacityInput
+ uint32_t uuidCountOutput
+ XrUuidEXT* uuids
+
+
+
+ XrStructureType type
+ const void* next
+ XrSpatialAnchorsStorageML storage
+ uint32_t uuidCount
+ const XrUuidEXT* uuids
+
+
+
+ XrStructureType type
+ const void* next
+ uint32_t anchorCount
+ const XrSpace* anchors
+ uint64_t expiration
+
+
+
+ XrStructureType type
+ void* next
+ XrResult futureResult
+ uint32_t uuidCount
+ XrUuidEXT* uuids
+
+
+
+ XrStructureType type
+ const void* next
+ uint32_t uuidCount
+ const XrUuidEXT* uuids
+
+
+
+ XrStructureType type
+ void* next
+ XrResult futureResult
+
+
+
+ XrStructureType type
+ const void* next
+ uint32_t uuidCount
+ const XrUuidEXT* uuids
+ uint64_t expiration
+
+
+
+ XrStructureType type
+ void* next
+ XrResult futureResult
+
+
+
+ XrUuidEXT uuid
+ XrResult result
+
+
+
+ XrStructureType type
+ void* next
+ uint32_t resultCount
+ XrSpatialAnchorCompletionResultML* results
+
+
+
+ XrStructureType type
+ void* next
+ uint32_t resultCount
+ XrSpatialAnchorCompletionResultML* results
+
+
+
+ XrStructureType type
+ void* next
+ uint32_t resultCount
+ XrSpatialAnchorCompletionResultML* results
+
+
+
+
+ XrStructureType type
+ const void* next
+
+
+
+ XrStructureType type
+ const void* next
+ XrSpace baseSpace
+ XrTime time
+ XrPosef boundingBoxCenter
+ XrExtent3DfEXT boundingBoxExtents
+
+
+
+ XrStructureType type
+ void* next
+ XrUuidEXT uuid
+ XrPosef meshBoundingBoxCenter
+ XrExtent3DfEXT meshBoundingBoxExtents
+ XrTime lastUpdateTime
+ XrWorldMeshBlockStatusML status
+
+
+
+ XrStructureType type
+ void* next
+ XrResult futureResult
+ XrTime timestamp
+ uint32_t meshBlockStateCapacityInput
+ uint32_t meshBlockStateCountOutput
+ XrWorldMeshBlockStateML* meshBlockStates
+
+
+
+ XrStructureType type
+ const void* next
+ uint32_t maxBlockCount
+
+
+
+ XrStructureType type
+ void* next
+ uint32_t size
+
+
+
+ XrStructureType type
+ void* next
+ uint32_t bufferSize
+ void* buffer
+
+
+
+ XrStructureType type
+ void* next
+ XrUuidEXT uuid
+ XrWorldMeshDetectorLodML lod
+
+
+
+ XrStructureType type
+ const void* next
+ XrWorldMeshDetectorFlagsML flags
+ float fillHoleLength
+ float disconnectedComponentArea
+ uint32_t blockCount
+ XrWorldMeshBlockRequestML* blocks
+
+
+
+ XrStructureType type
+ void* next
+ XrUuidEXT uuid
+ XrWorldMeshBlockResultML blockResult
+ XrWorldMeshDetectorLodML lod
+ XrWorldMeshDetectorFlagsML flags
+ uint32_t indexCount
+ uint16_t* indexBuffer
+ uint32_t vertexCount
+ XrVector3f* vertexBuffer
+ uint32_t normalCount
+ XrVector3f* normalBuffer
+ uint32_t confidenceCount
+ float* confidenceBuffer
+
+
+
+ XrStructureType type
+ const void* next
+ XrSpace meshSpace
+ XrTime meshSpaceLocateTime
+
+
+
+ XrStructureType type
+ void* next
+ XrResult futureResult
+ uint32_t blockCount
+ XrWorldMeshBlockML* blocks
+
+
@@ -4923,6 +5236,45 @@ typedef XrResult (XRAPI_PTR *PFN_xrCreateApiLayerInstance)(
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -5086,6 +5438,13 @@ typedef XrResult (XRAPI_PTR *PFN_xrCreateApiLayerInstance)(
+
+
+
+
+
+
+
@@ -5110,6 +5469,36 @@ typedef XrResult (XRAPI_PTR *PFN_xrCreateApiLayerInstance)(
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -6429,6 +6818,31 @@ typedef XrResult (XRAPI_PTR *PFN_xrCreateApiLayerInstance)(
XrViveTrackerPathsHTCX* paths
+
+
+ XrResult xrCreateBodyTrackerHTC
+ XrSession session
+ const XrBodyTrackerCreateInfoHTC* createInfo
+ XrBodyTrackerHTC* bodyTracker
+
+
+ XrResult xrDestroyBodyTrackerHTC
+ XrBodyTrackerHTC bodyTracker
+
+
+ XrResult xrLocateBodyJointsHTC
+ XrBodyTrackerHTC bodyTracker
+ const XrBodyJointsLocateInfoHTC* locateInfo
+ XrBodyJointLocationsHTC* locations
+
+
+ XrResult xrGetBodySkeletonHTC
+ XrBodyTrackerHTC bodyTracker
+ XrSpace baseSpace
+ uint32_t skeletonGenerationId
+ XrBodySkeletonHTC* skeleton
+
+
XrResult xrSetMarkerTrackingVARJO
@@ -6913,6 +7327,166 @@ typedef XrResult (XRAPI_PTR *PFN_xrCreateApiLayerInstance)(
XrSpaceLocations* spaceLocations
+
+
+ XrResult xrSetSystemNotificationsML
+ XrInstance instance
+ const XrSystemNotificationsSetInfoML* info
+
+
+
+
+ XrResult xrCreateSpatialAnchorsAsyncML
+ XrSession session
+ const XrSpatialAnchorsCreateInfoBaseHeaderML* createInfo
+ XrFutureEXT* future
+
+
+
+ XrResult xrCreateSpatialAnchorsCompleteML
+ XrSession session
+ XrFutureEXT future
+ XrCreateSpatialAnchorsCompletionML* completion
+
+
+
+ XrResult xrGetSpatialAnchorStateML
+ XrSpace anchor
+ XrSpatialAnchorStateML* state
+
+
+
+
+ XrResult xrCreateSpatialAnchorsStorageML
+ XrSession session
+ const XrSpatialAnchorsCreateStorageInfoML* createInfo
+ XrSpatialAnchorsStorageML* storage
+
+
+
+ XrResult xrDestroySpatialAnchorsStorageML
+ XrSpatialAnchorsStorageML storage
+
+
+
+ XrResult xrQuerySpatialAnchorsAsyncML
+ XrSpatialAnchorsStorageML storage
+ const XrSpatialAnchorsQueryInfoBaseHeaderML* queryInfo
+ XrFutureEXT* future
+
+
+
+ XrResult xrQuerySpatialAnchorsCompleteML
+ XrSpatialAnchorsStorageML storage
+ XrFutureEXT future
+ XrSpatialAnchorsQueryCompletionML* completion
+
+
+
+ XrResult xrPublishSpatialAnchorsAsyncML
+ XrSpatialAnchorsStorageML storage
+ const XrSpatialAnchorsPublishInfoML* publishInfo
+ XrFutureEXT* future
+
+
+
+ XrResult xrPublishSpatialAnchorsCompleteML
+ XrSpatialAnchorsStorageML storage
+ XrFutureEXT future
+ XrSpatialAnchorsPublishCompletionML* completion
+
+
+
+ XrResult xrDeleteSpatialAnchorsAsyncML
+ XrSpatialAnchorsStorageML storage
+ const XrSpatialAnchorsDeleteInfoML* deleteInfo
+ XrFutureEXT* future
+
+
+
+ XrResult xrDeleteSpatialAnchorsCompleteML
+ XrSpatialAnchorsStorageML storage
+ XrFutureEXT future
+ XrSpatialAnchorsDeleteCompletionML* completion
+
+
+
+ XrResult xrUpdateSpatialAnchorsExpirationAsyncML
+ XrSpatialAnchorsStorageML storage
+ const XrSpatialAnchorsUpdateExpirationInfoML* updateInfo
+ XrFutureEXT* future
+
+
+
+ XrResult xrUpdateSpatialAnchorsExpirationCompleteML
+ XrSpatialAnchorsStorageML storage
+ XrFutureEXT future
+ XrSpatialAnchorsUpdateExpirationCompletionML* completion
+
+
+
+
+ XrResult xrCreateWorldMeshDetectorML
+ XrSession session
+ const XrWorldMeshDetectorCreateInfoML* createInfo
+ XrWorldMeshDetectorML* detector
+
+
+
+ XrResult xrDestroyWorldMeshDetectorML
+ XrWorldMeshDetectorML detector
+
+
+
+ XrResult xrRequestWorldMeshStateAsyncML
+ XrWorldMeshDetectorML detector
+ const XrWorldMeshStateRequestInfoML* stateRequest
+ XrFutureEXT* future
+
+
+
+ XrResult xrRequestWorldMeshStateCompleteML
+ XrWorldMeshDetectorML detector
+ XrFutureEXT future
+ XrWorldMeshStateRequestCompletionML* completion
+
+
+
+ XrResult xrGetWorldMeshBufferRecommendSizeML
+ XrWorldMeshDetectorML detector
+ const XrWorldMeshBufferRecommendedSizeInfoML* sizeInfo
+ XrWorldMeshBufferSizeML* size
+
+
+
+ XrResult xrAllocateWorldMeshBufferML
+ XrWorldMeshDetectorML detector
+ const XrWorldMeshBufferSizeML* size
+ XrWorldMeshBufferML* buffer
+
+
+
+ XrResult xrFreeWorldMeshBufferML
+ XrWorldMeshDetectorML detector
+ const XrWorldMeshBufferML* buffer
+
+
+
+ XrResult xrRequestWorldMeshAsyncML
+ XrWorldMeshDetectorML detector
+ const XrWorldMeshGetInfoML* getInfo
+ XrWorldMeshBufferML* buffer
+ XrFutureEXT* future
+
+
+
+ XrResult xrRequestWorldMeshCompleteML
+ XrWorldMeshDetectorML detector
+ const XrWorldMeshRequestCompletionInfoML* completionInfo
+ XrFutureEXT future
+ XrWorldMeshRequestCompletionML* completion
+
+
@@ -10278,17 +10852,85 @@ typedef XrResult (XRAPI_PTR *PFN_xrCreateApiLayerInstance)(
-
+
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
+
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -12121,10 +12763,36 @@ typedef XrResult (XRAPI_PTR *PFN_xrCreateApiLayerInstance)(
-
+
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -13337,17 +14005,78 @@ typedef XrResult (XRAPI_PTR *PFN_xrCreateApiLayerInstance)(
-
+
-
-
+
+
+
+
+
+
+
+
+
+
+
-
+
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -13407,10 +14136,10 @@ typedef XrResult (XRAPI_PTR *PFN_xrCreateApiLayerInstance)(
-
+
-
-
+
+
diff --git a/OpenXRGen/Evergine.Bindings.OpenXR/Generated/Commands.cs b/OpenXRGen/Evergine.Bindings.OpenXR/Generated/Commands.cs
index 3b79b3e..f61e016 100644
--- a/OpenXRGen/Evergine.Bindings.OpenXR/Generated/Commands.cs
+++ b/OpenXRGen/Evergine.Bindings.OpenXR/Generated/Commands.cs
@@ -1187,6 +1187,84 @@ public static XrResult xrDestroyExportedLocalizationMapML(XrExportedLocalization
public static XrResult xrGetExportedLocalizationMapDataML(XrExportedLocalizationMapML map, uint bufferCapacityInput, uint* bufferCountOutput, byte* buffer)
=> xrGetExportedLocalizationMapDataML_ptr(map, bufferCapacityInput, bufferCountOutput, buffer);
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrCreateSpatialAnchorsAsyncMLDelegate(XrSession session, XrSpatialAnchorsCreateInfoBaseHeaderML* createInfo, ulong* future);
+ private static xrCreateSpatialAnchorsAsyncMLDelegate xrCreateSpatialAnchorsAsyncML_ptr;
+ public static XrResult xrCreateSpatialAnchorsAsyncML(XrSession session, XrSpatialAnchorsCreateInfoBaseHeaderML* createInfo, ulong* future)
+ => xrCreateSpatialAnchorsAsyncML_ptr(session, createInfo, future);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrCreateSpatialAnchorsCompleteMLDelegate(XrSession session, ulong future, XrCreateSpatialAnchorsCompletionML* completion);
+ private static xrCreateSpatialAnchorsCompleteMLDelegate xrCreateSpatialAnchorsCompleteML_ptr;
+ public static XrResult xrCreateSpatialAnchorsCompleteML(XrSession session, ulong future, XrCreateSpatialAnchorsCompletionML* completion)
+ => xrCreateSpatialAnchorsCompleteML_ptr(session, future, completion);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrGetSpatialAnchorStateMLDelegate(XrSpace anchor, XrSpatialAnchorStateML* state);
+ private static xrGetSpatialAnchorStateMLDelegate xrGetSpatialAnchorStateML_ptr;
+ public static XrResult xrGetSpatialAnchorStateML(XrSpace anchor, XrSpatialAnchorStateML* state)
+ => xrGetSpatialAnchorStateML_ptr(anchor, state);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrCreateSpatialAnchorsStorageMLDelegate(XrSession session, XrSpatialAnchorsCreateStorageInfoML* createInfo, XrSpatialAnchorsStorageML* storage);
+ private static xrCreateSpatialAnchorsStorageMLDelegate xrCreateSpatialAnchorsStorageML_ptr;
+ public static XrResult xrCreateSpatialAnchorsStorageML(XrSession session, XrSpatialAnchorsCreateStorageInfoML* createInfo, XrSpatialAnchorsStorageML* storage)
+ => xrCreateSpatialAnchorsStorageML_ptr(session, createInfo, storage);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrDestroySpatialAnchorsStorageMLDelegate(XrSpatialAnchorsStorageML storage);
+ private static xrDestroySpatialAnchorsStorageMLDelegate xrDestroySpatialAnchorsStorageML_ptr;
+ public static XrResult xrDestroySpatialAnchorsStorageML(XrSpatialAnchorsStorageML storage)
+ => xrDestroySpatialAnchorsStorageML_ptr(storage);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrQuerySpatialAnchorsAsyncMLDelegate(XrSpatialAnchorsStorageML storage, XrSpatialAnchorsQueryInfoBaseHeaderML* queryInfo, ulong* future);
+ private static xrQuerySpatialAnchorsAsyncMLDelegate xrQuerySpatialAnchorsAsyncML_ptr;
+ public static XrResult xrQuerySpatialAnchorsAsyncML(XrSpatialAnchorsStorageML storage, XrSpatialAnchorsQueryInfoBaseHeaderML* queryInfo, ulong* future)
+ => xrQuerySpatialAnchorsAsyncML_ptr(storage, queryInfo, future);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrQuerySpatialAnchorsCompleteMLDelegate(XrSpatialAnchorsStorageML storage, ulong future, XrSpatialAnchorsQueryCompletionML* completion);
+ private static xrQuerySpatialAnchorsCompleteMLDelegate xrQuerySpatialAnchorsCompleteML_ptr;
+ public static XrResult xrQuerySpatialAnchorsCompleteML(XrSpatialAnchorsStorageML storage, ulong future, XrSpatialAnchorsQueryCompletionML* completion)
+ => xrQuerySpatialAnchorsCompleteML_ptr(storage, future, completion);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrPublishSpatialAnchorsAsyncMLDelegate(XrSpatialAnchorsStorageML storage, XrSpatialAnchorsPublishInfoML* publishInfo, ulong* future);
+ private static xrPublishSpatialAnchorsAsyncMLDelegate xrPublishSpatialAnchorsAsyncML_ptr;
+ public static XrResult xrPublishSpatialAnchorsAsyncML(XrSpatialAnchorsStorageML storage, XrSpatialAnchorsPublishInfoML* publishInfo, ulong* future)
+ => xrPublishSpatialAnchorsAsyncML_ptr(storage, publishInfo, future);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrPublishSpatialAnchorsCompleteMLDelegate(XrSpatialAnchorsStorageML storage, ulong future, XrSpatialAnchorsPublishCompletionML* completion);
+ private static xrPublishSpatialAnchorsCompleteMLDelegate xrPublishSpatialAnchorsCompleteML_ptr;
+ public static XrResult xrPublishSpatialAnchorsCompleteML(XrSpatialAnchorsStorageML storage, ulong future, XrSpatialAnchorsPublishCompletionML* completion)
+ => xrPublishSpatialAnchorsCompleteML_ptr(storage, future, completion);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrDeleteSpatialAnchorsAsyncMLDelegate(XrSpatialAnchorsStorageML storage, XrSpatialAnchorsDeleteInfoML* deleteInfo, ulong* future);
+ private static xrDeleteSpatialAnchorsAsyncMLDelegate xrDeleteSpatialAnchorsAsyncML_ptr;
+ public static XrResult xrDeleteSpatialAnchorsAsyncML(XrSpatialAnchorsStorageML storage, XrSpatialAnchorsDeleteInfoML* deleteInfo, ulong* future)
+ => xrDeleteSpatialAnchorsAsyncML_ptr(storage, deleteInfo, future);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrDeleteSpatialAnchorsCompleteMLDelegate(XrSpatialAnchorsStorageML storage, ulong future, XrSpatialAnchorsDeleteCompletionML* completion);
+ private static xrDeleteSpatialAnchorsCompleteMLDelegate xrDeleteSpatialAnchorsCompleteML_ptr;
+ public static XrResult xrDeleteSpatialAnchorsCompleteML(XrSpatialAnchorsStorageML storage, ulong future, XrSpatialAnchorsDeleteCompletionML* completion)
+ => xrDeleteSpatialAnchorsCompleteML_ptr(storage, future, completion);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrUpdateSpatialAnchorsExpirationAsyncMLDelegate(XrSpatialAnchorsStorageML storage, XrSpatialAnchorsUpdateExpirationInfoML* updateInfo, ulong* future);
+ private static xrUpdateSpatialAnchorsExpirationAsyncMLDelegate xrUpdateSpatialAnchorsExpirationAsyncML_ptr;
+ public static XrResult xrUpdateSpatialAnchorsExpirationAsyncML(XrSpatialAnchorsStorageML storage, XrSpatialAnchorsUpdateExpirationInfoML* updateInfo, ulong* future)
+ => xrUpdateSpatialAnchorsExpirationAsyncML_ptr(storage, updateInfo, future);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrUpdateSpatialAnchorsExpirationCompleteMLDelegate(XrSpatialAnchorsStorageML storage, ulong future, XrSpatialAnchorsUpdateExpirationCompletionML* completion);
+ private static xrUpdateSpatialAnchorsExpirationCompleteMLDelegate xrUpdateSpatialAnchorsExpirationCompleteML_ptr;
+ public static XrResult xrUpdateSpatialAnchorsExpirationCompleteML(XrSpatialAnchorsStorageML storage, ulong future, XrSpatialAnchorsUpdateExpirationCompletionML* completion)
+ => xrUpdateSpatialAnchorsExpirationCompleteML_ptr(storage, future, completion);
+
[UnmanagedFunctionPointer(CallConv)]
private delegate XrResult xrEnableUserCalibrationEventsMLDelegate(XrInstance instance, XrUserCalibrationEnableEventsInfoML* enableInfo);
private static xrEnableUserCalibrationEventsMLDelegate xrEnableUserCalibrationEventsML_ptr;
@@ -1661,6 +1739,30 @@ public static XrResult xrCreateSpatialAnchorHTC(XrSession session, XrSpatialAnch
public static XrResult xrGetSpatialAnchorNameHTC(XrSpace anchor, XrSpatialAnchorNameHTC* name)
=> xrGetSpatialAnchorNameHTC_ptr(anchor, name);
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrCreateBodyTrackerHTCDelegate(XrSession session, XrBodyTrackerCreateInfoHTC* createInfo, XrBodyTrackerHTC* bodyTracker);
+ private static xrCreateBodyTrackerHTCDelegate xrCreateBodyTrackerHTC_ptr;
+ public static XrResult xrCreateBodyTrackerHTC(XrSession session, XrBodyTrackerCreateInfoHTC* createInfo, XrBodyTrackerHTC* bodyTracker)
+ => xrCreateBodyTrackerHTC_ptr(session, createInfo, bodyTracker);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrDestroyBodyTrackerHTCDelegate(XrBodyTrackerHTC bodyTracker);
+ private static xrDestroyBodyTrackerHTCDelegate xrDestroyBodyTrackerHTC_ptr;
+ public static XrResult xrDestroyBodyTrackerHTC(XrBodyTrackerHTC bodyTracker)
+ => xrDestroyBodyTrackerHTC_ptr(bodyTracker);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrLocateBodyJointsHTCDelegate(XrBodyTrackerHTC bodyTracker, XrBodyJointsLocateInfoHTC* locateInfo, XrBodyJointLocationsHTC* locations);
+ private static xrLocateBodyJointsHTCDelegate xrLocateBodyJointsHTC_ptr;
+ public static XrResult xrLocateBodyJointsHTC(XrBodyTrackerHTC bodyTracker, XrBodyJointsLocateInfoHTC* locateInfo, XrBodyJointLocationsHTC* locations)
+ => xrLocateBodyJointsHTC_ptr(bodyTracker, locateInfo, locations);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrGetBodySkeletonHTCDelegate(XrBodyTrackerHTC bodyTracker, XrSpace baseSpace, uint skeletonGenerationId, XrBodySkeletonHTC* skeleton);
+ private static xrGetBodySkeletonHTCDelegate xrGetBodySkeletonHTC_ptr;
+ public static XrResult xrGetBodySkeletonHTC(XrBodyTrackerHTC bodyTracker, XrSpace baseSpace, uint skeletonGenerationId, XrBodySkeletonHTC* skeleton)
+ => xrGetBodySkeletonHTC_ptr(bodyTracker, baseSpace, skeletonGenerationId, skeleton);
+
[UnmanagedFunctionPointer(CallConv)]
private delegate XrResult xrApplyForceFeedbackCurlMNDXDelegate(XrHandTrackerEXT handTracker, XrForceFeedbackCurlApplyLocationsMNDX* locations);
private static xrApplyForceFeedbackCurlMNDXDelegate xrApplyForceFeedbackCurlMNDX_ptr;
@@ -1715,6 +1817,66 @@ public static XrResult xrPollFutureEXT(XrInstance instance, XrFuturePollInfoEXT*
public static XrResult xrCancelFutureEXT(XrInstance instance, XrFutureCancelInfoEXT* cancelInfo)
=> xrCancelFutureEXT_ptr(instance, cancelInfo);
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrSetSystemNotificationsMLDelegate(XrInstance instance, XrSystemNotificationsSetInfoML* info);
+ private static xrSetSystemNotificationsMLDelegate xrSetSystemNotificationsML_ptr;
+ public static XrResult xrSetSystemNotificationsML(XrInstance instance, XrSystemNotificationsSetInfoML* info)
+ => xrSetSystemNotificationsML_ptr(instance, info);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrCreateWorldMeshDetectorMLDelegate(XrSession session, XrWorldMeshDetectorCreateInfoML* createInfo, XrWorldMeshDetectorML* detector);
+ private static xrCreateWorldMeshDetectorMLDelegate xrCreateWorldMeshDetectorML_ptr;
+ public static XrResult xrCreateWorldMeshDetectorML(XrSession session, XrWorldMeshDetectorCreateInfoML* createInfo, XrWorldMeshDetectorML* detector)
+ => xrCreateWorldMeshDetectorML_ptr(session, createInfo, detector);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrDestroyWorldMeshDetectorMLDelegate(XrWorldMeshDetectorML detector);
+ private static xrDestroyWorldMeshDetectorMLDelegate xrDestroyWorldMeshDetectorML_ptr;
+ public static XrResult xrDestroyWorldMeshDetectorML(XrWorldMeshDetectorML detector)
+ => xrDestroyWorldMeshDetectorML_ptr(detector);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrRequestWorldMeshStateAsyncMLDelegate(XrWorldMeshDetectorML detector, XrWorldMeshStateRequestInfoML* stateRequest, ulong* future);
+ private static xrRequestWorldMeshStateAsyncMLDelegate xrRequestWorldMeshStateAsyncML_ptr;
+ public static XrResult xrRequestWorldMeshStateAsyncML(XrWorldMeshDetectorML detector, XrWorldMeshStateRequestInfoML* stateRequest, ulong* future)
+ => xrRequestWorldMeshStateAsyncML_ptr(detector, stateRequest, future);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrRequestWorldMeshStateCompleteMLDelegate(XrWorldMeshDetectorML detector, ulong future, XrWorldMeshStateRequestCompletionML* completion);
+ private static xrRequestWorldMeshStateCompleteMLDelegate xrRequestWorldMeshStateCompleteML_ptr;
+ public static XrResult xrRequestWorldMeshStateCompleteML(XrWorldMeshDetectorML detector, ulong future, XrWorldMeshStateRequestCompletionML* completion)
+ => xrRequestWorldMeshStateCompleteML_ptr(detector, future, completion);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrGetWorldMeshBufferRecommendSizeMLDelegate(XrWorldMeshDetectorML detector, XrWorldMeshBufferRecommendedSizeInfoML* sizeInfo, XrWorldMeshBufferSizeML* size);
+ private static xrGetWorldMeshBufferRecommendSizeMLDelegate xrGetWorldMeshBufferRecommendSizeML_ptr;
+ public static XrResult xrGetWorldMeshBufferRecommendSizeML(XrWorldMeshDetectorML detector, XrWorldMeshBufferRecommendedSizeInfoML* sizeInfo, XrWorldMeshBufferSizeML* size)
+ => xrGetWorldMeshBufferRecommendSizeML_ptr(detector, sizeInfo, size);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrAllocateWorldMeshBufferMLDelegate(XrWorldMeshDetectorML detector, XrWorldMeshBufferSizeML* size, XrWorldMeshBufferML* buffer);
+ private static xrAllocateWorldMeshBufferMLDelegate xrAllocateWorldMeshBufferML_ptr;
+ public static XrResult xrAllocateWorldMeshBufferML(XrWorldMeshDetectorML detector, XrWorldMeshBufferSizeML* size, XrWorldMeshBufferML* buffer)
+ => xrAllocateWorldMeshBufferML_ptr(detector, size, buffer);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrFreeWorldMeshBufferMLDelegate(XrWorldMeshDetectorML detector, XrWorldMeshBufferML* buffer);
+ private static xrFreeWorldMeshBufferMLDelegate xrFreeWorldMeshBufferML_ptr;
+ public static XrResult xrFreeWorldMeshBufferML(XrWorldMeshDetectorML detector, XrWorldMeshBufferML* buffer)
+ => xrFreeWorldMeshBufferML_ptr(detector, buffer);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrRequestWorldMeshAsyncMLDelegate(XrWorldMeshDetectorML detector, XrWorldMeshGetInfoML* getInfo, XrWorldMeshBufferML* buffer, ulong* future);
+ private static xrRequestWorldMeshAsyncMLDelegate xrRequestWorldMeshAsyncML_ptr;
+ public static XrResult xrRequestWorldMeshAsyncML(XrWorldMeshDetectorML detector, XrWorldMeshGetInfoML* getInfo, XrWorldMeshBufferML* buffer, ulong* future)
+ => xrRequestWorldMeshAsyncML_ptr(detector, getInfo, buffer, future);
+
+ [UnmanagedFunctionPointer(CallConv)]
+ private delegate XrResult xrRequestWorldMeshCompleteMLDelegate(XrWorldMeshDetectorML detector, XrWorldMeshRequestCompletionInfoML* completionInfo, ulong future, XrWorldMeshRequestCompletionML* completion);
+ private static xrRequestWorldMeshCompleteMLDelegate xrRequestWorldMeshCompleteML_ptr;
+ public static XrResult xrRequestWorldMeshCompleteML(XrWorldMeshDetectorML detector, XrWorldMeshRequestCompletionInfoML* completionInfo, ulong future, XrWorldMeshRequestCompletionML* completion)
+ => xrRequestWorldMeshCompleteML_ptr(detector, completionInfo, future, completion);
+
public static void LoadFunctionPointers(XrInstance instance = default)
{
if (instance != default)
@@ -1919,6 +2081,19 @@ public static void LoadFunctionPointers(XrInstance instance = default)
nativeLib.LoadFunction("xrCreateExportedLocalizationMapML", out xrCreateExportedLocalizationMapML_ptr);
nativeLib.LoadFunction("xrDestroyExportedLocalizationMapML", out xrDestroyExportedLocalizationMapML_ptr);
nativeLib.LoadFunction("xrGetExportedLocalizationMapDataML", out xrGetExportedLocalizationMapDataML_ptr);
+ nativeLib.LoadFunction("xrCreateSpatialAnchorsAsyncML", out xrCreateSpatialAnchorsAsyncML_ptr);
+ nativeLib.LoadFunction("xrCreateSpatialAnchorsCompleteML", out xrCreateSpatialAnchorsCompleteML_ptr);
+ nativeLib.LoadFunction("xrGetSpatialAnchorStateML", out xrGetSpatialAnchorStateML_ptr);
+ nativeLib.LoadFunction("xrCreateSpatialAnchorsStorageML", out xrCreateSpatialAnchorsStorageML_ptr);
+ nativeLib.LoadFunction("xrDestroySpatialAnchorsStorageML", out xrDestroySpatialAnchorsStorageML_ptr);
+ nativeLib.LoadFunction("xrQuerySpatialAnchorsAsyncML", out xrQuerySpatialAnchorsAsyncML_ptr);
+ nativeLib.LoadFunction("xrQuerySpatialAnchorsCompleteML", out xrQuerySpatialAnchorsCompleteML_ptr);
+ nativeLib.LoadFunction("xrPublishSpatialAnchorsAsyncML", out xrPublishSpatialAnchorsAsyncML_ptr);
+ nativeLib.LoadFunction("xrPublishSpatialAnchorsCompleteML", out xrPublishSpatialAnchorsCompleteML_ptr);
+ nativeLib.LoadFunction("xrDeleteSpatialAnchorsAsyncML", out xrDeleteSpatialAnchorsAsyncML_ptr);
+ nativeLib.LoadFunction("xrDeleteSpatialAnchorsCompleteML", out xrDeleteSpatialAnchorsCompleteML_ptr);
+ nativeLib.LoadFunction("xrUpdateSpatialAnchorsExpirationAsyncML", out xrUpdateSpatialAnchorsExpirationAsyncML_ptr);
+ nativeLib.LoadFunction("xrUpdateSpatialAnchorsExpirationCompleteML", out xrUpdateSpatialAnchorsExpirationCompleteML_ptr);
nativeLib.LoadFunction("xrEnableUserCalibrationEventsML", out xrEnableUserCalibrationEventsML_ptr);
nativeLib.LoadFunction("xrCreateSpatialAnchorStoreConnectionMSFT", out xrCreateSpatialAnchorStoreConnectionMSFT_ptr);
nativeLib.LoadFunction("xrDestroySpatialAnchorStoreConnectionMSFT", out xrDestroySpatialAnchorStoreConnectionMSFT_ptr);
@@ -1998,6 +2173,10 @@ public static void LoadFunctionPointers(XrInstance instance = default)
nativeLib.LoadFunction("xrApplyFoveationHTC", out xrApplyFoveationHTC_ptr);
nativeLib.LoadFunction("xrCreateSpatialAnchorHTC", out xrCreateSpatialAnchorHTC_ptr);
nativeLib.LoadFunction("xrGetSpatialAnchorNameHTC", out xrGetSpatialAnchorNameHTC_ptr);
+ nativeLib.LoadFunction("xrCreateBodyTrackerHTC", out xrCreateBodyTrackerHTC_ptr);
+ nativeLib.LoadFunction("xrDestroyBodyTrackerHTC", out xrDestroyBodyTrackerHTC_ptr);
+ nativeLib.LoadFunction("xrLocateBodyJointsHTC", out xrLocateBodyJointsHTC_ptr);
+ nativeLib.LoadFunction("xrGetBodySkeletonHTC", out xrGetBodySkeletonHTC_ptr);
nativeLib.LoadFunction("xrApplyForceFeedbackCurlMNDX", out xrApplyForceFeedbackCurlMNDX_ptr);
nativeLib.LoadFunction("xrCreatePlaneDetectorEXT", out xrCreatePlaneDetectorEXT_ptr);
nativeLib.LoadFunction("xrDestroyPlaneDetectorEXT", out xrDestroyPlaneDetectorEXT_ptr);
@@ -2007,6 +2186,16 @@ public static void LoadFunctionPointers(XrInstance instance = default)
nativeLib.LoadFunction("xrGetPlanePolygonBufferEXT", out xrGetPlanePolygonBufferEXT_ptr);
nativeLib.LoadFunction("xrPollFutureEXT", out xrPollFutureEXT_ptr);
nativeLib.LoadFunction("xrCancelFutureEXT", out xrCancelFutureEXT_ptr);
+ nativeLib.LoadFunction("xrSetSystemNotificationsML", out xrSetSystemNotificationsML_ptr);
+ nativeLib.LoadFunction("xrCreateWorldMeshDetectorML", out xrCreateWorldMeshDetectorML_ptr);
+ nativeLib.LoadFunction("xrDestroyWorldMeshDetectorML", out xrDestroyWorldMeshDetectorML_ptr);
+ nativeLib.LoadFunction("xrRequestWorldMeshStateAsyncML", out xrRequestWorldMeshStateAsyncML_ptr);
+ nativeLib.LoadFunction("xrRequestWorldMeshStateCompleteML", out xrRequestWorldMeshStateCompleteML_ptr);
+ nativeLib.LoadFunction("xrGetWorldMeshBufferRecommendSizeML", out xrGetWorldMeshBufferRecommendSizeML_ptr);
+ nativeLib.LoadFunction("xrAllocateWorldMeshBufferML", out xrAllocateWorldMeshBufferML_ptr);
+ nativeLib.LoadFunction("xrFreeWorldMeshBufferML", out xrFreeWorldMeshBufferML_ptr);
+ nativeLib.LoadFunction("xrRequestWorldMeshAsyncML", out xrRequestWorldMeshAsyncML_ptr);
+ nativeLib.LoadFunction("xrRequestWorldMeshCompleteML", out xrRequestWorldMeshCompleteML_ptr);
}
}
}
diff --git a/OpenXRGen/Evergine.Bindings.OpenXR/Generated/Constants.cs b/OpenXRGen/Evergine.Bindings.OpenXR/Generated/Constants.cs
index e9055ac..7887b77 100644
--- a/OpenXRGen/Evergine.Bindings.OpenXR/Generated/Constants.cs
+++ b/OpenXRGen/Evergine.Bindings.OpenXR/Generated/Constants.cs
@@ -216,6 +216,10 @@ public static partial class OpenXRNative
public const uint XR_ML_localization_map_SPEC_VERSION = 1;
public const string XR_ML_LOCALIZATION_MAP_EXTENSION_NAME = "XR_ML_localization_map";
public const uint XR_MAX_LOCALIZATION_MAP_NAME_LENGTH_ML = 64;
+ public const uint XR_ML_spatial_anchors_SPEC_VERSION = 1;
+ public const string XR_ML_SPATIAL_ANCHORS_EXTENSION_NAME = "XR_ML_spatial_anchors";
+ public const uint XR_ML_spatial_anchors_storage_SPEC_VERSION = 1;
+ public const string XR_ML_SPATIAL_ANCHORS_STORAGE_EXTENSION_NAME = "XR_ML_spatial_anchors_storage";
public const uint XR_ML_user_calibration_SPEC_VERSION = 1;
public const string XR_ML_USER_CALIBRATION_EXTENSION_NAME = "XR_ML_user_calibration";
public const uint XR_MSFT_spatial_anchor_persistence_SPEC_VERSION = 2;
@@ -325,6 +329,8 @@ public static partial class OpenXRNative
public const uint XR_HTC_anchor_SPEC_VERSION = 1;
public const string XR_HTC_ANCHOR_EXTENSION_NAME = "XR_HTC_anchor";
public const uint XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_HTC = 256;
+ public const uint XR_HTC_body_tracking_SPEC_VERSION = 1;
+ public const string XR_HTC_BODY_TRACKING_EXTENSION_NAME = "XR_HTC_body_tracking";
public const uint XR_EXT_active_action_set_priority_SPEC_VERSION = 1;
public const string XR_EXT_ACTIVE_ACTION_SET_PRIORITY_EXTENSION_NAME = "XR_EXT_active_action_set_priority";
public const uint XR_MNDX_force_feedback_curl_SPEC_VERSION = 1;
@@ -346,6 +352,12 @@ public static partial class OpenXRNative
public const string XR_EXT_USER_PRESENCE_EXTENSION_NAME = "XR_EXT_user_presence";
public const uint XR_KHR_locate_spaces_SPEC_VERSION = 1;
public const string XR_KHR_LOCATE_SPACES_EXTENSION_NAME = "XR_KHR_locate_spaces";
+ public const uint XR_ML_system_notifications_SPEC_VERSION = 1;
+ public const string XR_ML_SYSTEM_NOTIFICATIONS_EXTENSION_NAME = "XR_ML_system_notifications";
+ public const uint XR_ML_world_mesh_detection_SPEC_VERSION = 1;
+ public const string XR_ML_WORLD_MESH_DETECTION_EXTENSION_NAME = "XR_ML_world_mesh_detection";
+ public const uint XR_ML_view_configuration_depth_range_change_SPEC_VERSION = 1;
+ public const string XR_ML_VIEW_CONFIGURATION_DEPTH_RANGE_CHANGE_EXTENSION_NAME = "XR_ML_view_configuration_depth_range_change";
public const uint XR_YVR_controller_interaction_SPEC_VERSION = 1;
public const string XR_YVR_CONTROLLER_INTERACTION_EXTENSION_NAME = "XR_YVR_controller_interaction";
public const uint XR_EXT_composition_layer_inverted_alpha_SPEC_VERSION = 1;
diff --git a/OpenXRGen/Evergine.Bindings.OpenXR/Generated/Enums.cs b/OpenXRGen/Evergine.Bindings.OpenXR/Generated/Enums.cs
index e8bee09..016fdd3 100644
--- a/OpenXRGen/Evergine.Bindings.OpenXR/Generated/Enums.cs
+++ b/OpenXRGen/Evergine.Bindings.OpenXR/Generated/Enums.cs
@@ -235,6 +235,22 @@ public enum XrStructureType
XR_TYPE_MAP_LOCALIZATION_REQUEST_INFO_ML = 1000139002,
XR_TYPE_LOCALIZATION_MAP_IMPORT_INFO_ML = 1000139003,
XR_TYPE_LOCALIZATION_ENABLE_EVENTS_INFO_ML = 1000139004,
+ XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_POSE_ML = 1000140000,
+ XR_TYPE_CREATE_SPATIAL_ANCHORS_COMPLETION_ML = 1000140001,
+ XR_TYPE_SPATIAL_ANCHOR_STATE_ML = 1000140002,
+ XR_TYPE_SPATIAL_ANCHORS_CREATE_STORAGE_INFO_ML = 1000141000,
+ XR_TYPE_SPATIAL_ANCHORS_QUERY_INFO_RADIUS_ML = 1000141001,
+ XR_TYPE_SPATIAL_ANCHORS_QUERY_COMPLETION_ML = 1000141002,
+ XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_UUIDS_ML = 1000141003,
+ XR_TYPE_SPATIAL_ANCHORS_PUBLISH_INFO_ML = 1000141004,
+ XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_ML = 1000141005,
+ XR_TYPE_SPATIAL_ANCHORS_DELETE_INFO_ML = 1000141006,
+ XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_ML = 1000141007,
+ XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_INFO_ML = 1000141008,
+ XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_ML = 1000141009,
+ XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_DETAILS_ML = 1000141010,
+ XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_DETAILS_ML = 1000141011,
+ XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_DETAILS_ML = 1000141012,
XR_TYPE_EVENT_DATA_HEADSET_FIT_CHANGED_ML = 1000472000,
XR_TYPE_EVENT_DATA_EYE_CALIBRATION_CHANGED_ML = 1000472001,
XR_TYPE_USER_CALIBRATION_ENABLE_EVENTS_INFO_ML = 1000472002,
@@ -342,6 +358,11 @@ public enum XrStructureType
XR_TYPE_FOVEATION_CUSTOM_MODE_INFO_HTC = 1000318002,
XR_TYPE_SYSTEM_ANCHOR_PROPERTIES_HTC = 1000319000,
XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_HTC = 1000319001,
+ XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_HTC = 1000320000,
+ XR_TYPE_BODY_TRACKER_CREATE_INFO_HTC = 1000320001,
+ XR_TYPE_BODY_JOINTS_LOCATE_INFO_HTC = 1000320002,
+ XR_TYPE_BODY_JOINT_LOCATIONS_HTC = 1000320003,
+ XR_TYPE_BODY_SKELETON_HTC = 1000320004,
XR_TYPE_ACTIVE_ACTION_SET_PRIORITIES_EXT = 1000373000,
XR_TYPE_SYSTEM_FORCE_FEEDBACK_CURL_PROPERTIES_MNDX = 1000375000,
XR_TYPE_FORCE_FEEDBACK_CURL_APPLY_LOCATIONS_MNDX = 1000375001,
@@ -360,6 +381,19 @@ public enum XrStructureType
XR_TYPE_FUTURE_POLL_RESULT_EXT = 1000469003,
XR_TYPE_EVENT_DATA_USER_PRESENCE_CHANGED_EXT = 1000470000,
XR_TYPE_SYSTEM_USER_PRESENCE_PROPERTIES_EXT = 1000470001,
+ XR_TYPE_SYSTEM_NOTIFICATIONS_SET_INFO_ML = 1000473000,
+ XR_TYPE_WORLD_MESH_DETECTOR_CREATE_INFO_ML = 1000474001,
+ XR_TYPE_WORLD_MESH_STATE_REQUEST_INFO_ML = 1000474002,
+ XR_TYPE_WORLD_MESH_BLOCK_STATE_ML = 1000474003,
+ XR_TYPE_WORLD_MESH_STATE_REQUEST_COMPLETION_ML = 1000474004,
+ XR_TYPE_WORLD_MESH_BUFFER_RECOMMENDED_SIZE_INFO_ML = 1000474005,
+ XR_TYPE_WORLD_MESH_BUFFER_SIZE_ML = 1000474006,
+ XR_TYPE_WORLD_MESH_BUFFER_ML = 1000474007,
+ XR_TYPE_WORLD_MESH_BLOCK_REQUEST_ML = 1000474008,
+ XR_TYPE_WORLD_MESH_GET_INFO_ML = 1000474009,
+ XR_TYPE_WORLD_MESH_BLOCK_ML = 1000474010,
+ XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_ML = 1000474011,
+ XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_INFO_ML = 1000474012,
}
public enum XrResult
@@ -461,6 +495,11 @@ public enum XrResult
XR_ERROR_LOCALIZATION_MAP_PERMISSION_DENIED_ML = -1000139004,
XR_ERROR_LOCALIZATION_MAP_ALREADY_EXISTS_ML = -1000139005,
XR_ERROR_LOCALIZATION_MAP_CANNOT_EXPORT_CLOUD_MAP_ML = -1000139006,
+ XR_ERROR_SPATIAL_ANCHORS_PERMISSION_DENIED_ML = -1000140000,
+ XR_ERROR_SPATIAL_ANCHORS_NOT_LOCALIZED_ML = -1000140001,
+ XR_ERROR_SPATIAL_ANCHORS_OUT_OF_MAP_BOUNDS_ML = -1000140002,
+ XR_ERROR_SPATIAL_ANCHORS_SPACE_NOT_LOCATABLE_ML = -1000140003,
+ XR_ERROR_SPATIAL_ANCHORS_ANCHOR_NOT_FOUND_ML = -1000141000,
XR_ERROR_SPATIAL_ANCHOR_NAME_NOT_FOUND_MSFT = -1000142001,
XR_ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT = -1000142002,
XR_SCENE_MARKER_DATA_NOT_STRING_MSFT = 1000147000,
@@ -477,6 +516,10 @@ public enum XrResult
XR_ERROR_PLANE_DETECTION_PERMISSION_DENIED_EXT = -1000429001,
XR_ERROR_FUTURE_PENDING_EXT = -1000469001,
XR_ERROR_FUTURE_INVALID_EXT = -1000469002,
+ XR_ERROR_SYSTEM_NOTIFICATION_PERMISSION_DENIED_ML = -1000473000,
+ XR_ERROR_SYSTEM_NOTIFICATION_INCOMPATIBLE_SKU_ML = -1000473001,
+ XR_ERROR_WORLD_MESH_DETECTOR_PERMISSION_DENIED_ML = -1000474000,
+ XR_ERROR_WORLD_MESH_DETECTOR_SPACE_NOT_LOCATABLE_ML = -1000474001,
}
public enum XrObjectType
@@ -503,6 +546,7 @@ public enum XrObjectType
XR_OBJECT_TYPE_GEOMETRY_INSTANCE_FB = 1000118004,
XR_OBJECT_TYPE_MARKER_DETECTOR_ML = 1000138000,
XR_OBJECT_TYPE_EXPORTED_LOCALIZATION_MAP_ML = 1000139000,
+ XR_OBJECT_TYPE_SPATIAL_ANCHORS_STORAGE_ML = 1000141000,
XR_OBJECT_TYPE_SPATIAL_ANCHOR_STORE_CONNECTION_MSFT = 1000142000,
XR_OBJECT_TYPE_FACE_TRACKER_FB = 1000201000,
XR_OBJECT_TYPE_EYE_TRACKER_FB = 1000202000,
@@ -513,7 +557,9 @@ public enum XrObjectType
XR_OBJECT_TYPE_ENVIRONMENT_DEPTH_PROVIDER_META = 1000291000,
XR_OBJECT_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_META = 1000291001,
XR_OBJECT_TYPE_PASSTHROUGH_HTC = 1000317000,
+ XR_OBJECT_TYPE_BODY_TRACKER_HTC = 1000320000,
XR_OBJECT_TYPE_PLANE_DETECTOR_EXT = 1000429000,
+ XR_OBJECT_TYPE_WORLD_MESH_DETECTOR_ML = 1000474000,
}
public enum XrAndroidThreadTypeKHR
@@ -1703,6 +1749,48 @@ public enum XrFoveationLevelHTC
XR_FOVEATION_LEVEL_HIGH_HTC = 3,
}
+ public enum XrBodyJointHTC
+ {
+ XR_BODY_JOINT_PELVIS_HTC = 0,
+ XR_BODY_JOINT_LEFT_HIP_HTC = 1,
+ XR_BODY_JOINT_LEFT_KNEE_HTC = 2,
+ XR_BODY_JOINT_LEFT_ANKLE_HTC = 3,
+ XR_BODY_JOINT_LEFT_FEET_HTC = 4,
+ XR_BODY_JOINT_RIGHT_HIP_HTC = 5,
+ XR_BODY_JOINT_RIGHT_KNEE_HTC = 6,
+ XR_BODY_JOINT_RIGHT_ANKLE_HTC = 7,
+ XR_BODY_JOINT_RIGHT_FEET_HTC = 8,
+ XR_BODY_JOINT_WAIST_HTC = 9,
+ XR_BODY_JOINT_SPINE_LOWER_HTC = 10,
+ XR_BODY_JOINT_SPINE_MIDDLE_HTC = 11,
+ XR_BODY_JOINT_SPINE_HIGH_HTC = 12,
+ XR_BODY_JOINT_CHEST_HTC = 13,
+ XR_BODY_JOINT_NECK_HTC = 14,
+ XR_BODY_JOINT_HEAD_HTC = 15,
+ XR_BODY_JOINT_LEFT_CLAVICLE_HTC = 16,
+ XR_BODY_JOINT_LEFT_SCAPULA_HTC = 17,
+ XR_BODY_JOINT_LEFT_ARM_HTC = 18,
+ XR_BODY_JOINT_LEFT_ELBOW_HTC = 19,
+ XR_BODY_JOINT_LEFT_WRIST_HTC = 20,
+ XR_BODY_JOINT_RIGHT_CLAVICLE_HTC = 21,
+ XR_BODY_JOINT_RIGHT_SCAPULA_HTC = 22,
+ XR_BODY_JOINT_RIGHT_ARM_HTC = 23,
+ XR_BODY_JOINT_RIGHT_ELBOW_HTC = 24,
+ XR_BODY_JOINT_RIGHT_WRIST_HTC = 25,
+ }
+
+ public enum XrBodyJointSetHTC
+ {
+ XR_BODY_JOINT_SET_FULL_HTC = 0,
+ }
+
+ public enum XrBodyJointConfidenceHTC
+ {
+ XR_BODY_JOINT_CONFIDENCE_NONE_HTC = 0,
+ XR_BODY_JOINT_CONFIDENCE_LOW_HTC = 1,
+ XR_BODY_JOINT_CONFIDENCE_HIGH_HTC = 2,
+ }
+
public enum XrCompareOpFB
{
XR_COMPARE_OP_NEVER_FB = 0,
@@ -1896,4 +1984,46 @@ public enum XrEnvironmentDepthSwapchainCreateFlagsMETA
None = 0,
}
+ public enum XrSpatialAnchorConfidenceML
+ {
+ XR_SPATIAL_ANCHOR_CONFIDENCE_LOW_ML = 0,
+ XR_SPATIAL_ANCHOR_CONFIDENCE_MEDIUM_ML = 1,
+ XR_SPATIAL_ANCHOR_CONFIDENCE_HIGH_ML = 2,
+ }
+
+ [Flags]
+ public enum XrWorldMeshDetectorFlagsML
+ {
+ None = 0,
+ XR_WORLD_MESH_DETECTOR_POINT_CLOUD_BIT_ML = 1,
+ XR_WORLD_MESH_DETECTOR_COMPUTE_NORMALS_BIT_ML = 2,
+ XR_WORLD_MESH_DETECTOR_COMPUTE_CONFIDENCE_BIT_ML = 4,
+ XR_WORLD_MESH_DETECTOR_PLANARIZE_BIT_ML = 8,
+ XR_WORLD_MESH_DETECTOR_REMOVE_MESH_SKIRT_BIT_ML = 16,
+ XR_WORLD_MESH_DETECTOR_INDEX_ORDER_CW_BIT_ML = 32,
+ }
+
+ public enum XrWorldMeshDetectorLodML
+ {
+ XR_WORLD_MESH_DETECTOR_LOD_MINIMUM_ML = 0,
+ XR_WORLD_MESH_DETECTOR_LOD_MEDIUM_ML = 1,
+ XR_WORLD_MESH_DETECTOR_LOD_MAXIMUM_ML = 2,
+ }
+
+ public enum XrWorldMeshBlockStatusML
+ {
+ XR_WORLD_MESH_BLOCK_STATUS_NEW_ML = 0,
+ XR_WORLD_MESH_BLOCK_STATUS_UPDATED_ML = 1,
+ XR_WORLD_MESH_BLOCK_STATUS_DELETED_ML = 2,
+ XR_WORLD_MESH_BLOCK_STATUS_UNCHANGED_ML = 3,
+ }
+
+ public enum XrWorldMeshBlockResultML
+ {
+ XR_WORLD_MESH_BLOCK_RESULT_SUCCESS_ML = 0,
+ XR_WORLD_MESH_BLOCK_RESULT_FAILED_ML = 1,
+ XR_WORLD_MESH_BLOCK_RESULT_PENDING_ML = 2,
+ XR_WORLD_MESH_BLOCK_RESULT_PARTIAL_UPDATE_ML = 3,
+ }
+
}
diff --git a/OpenXRGen/Evergine.Bindings.OpenXR/Generated/Handles.cs b/OpenXRGen/Evergine.Bindings.OpenXR/Generated/Handles.cs
index 4956c30..73bb98b 100644
--- a/OpenXRGen/Evergine.Bindings.OpenXR/Generated/Handles.cs
+++ b/OpenXRGen/Evergine.Bindings.OpenXR/Generated/Handles.cs
@@ -362,6 +362,21 @@ public partial struct XrVirtualKeyboardMETA : IEquatable
public override int GetHashCode() => Handle.GetHashCode();
}
+ public partial struct XrSpatialAnchorsStorageML : IEquatable
+{
+ public readonly ulong Handle;
+ public XrSpatialAnchorsStorageML(ulong existingHandle) { Handle = existingHandle; }
+ public static XrSpatialAnchorsStorageML Null => new XrSpatialAnchorsStorageML(0);
+ public static implicit operator XrSpatialAnchorsStorageML(ulong handle) => new XrSpatialAnchorsStorageML(handle);
+ public static bool operator ==(XrSpatialAnchorsStorageML left, XrSpatialAnchorsStorageML right) => left.Handle == right.Handle;
+ public static bool operator !=(XrSpatialAnchorsStorageML left, XrSpatialAnchorsStorageML right) => left.Handle != right.Handle;
+ public static bool operator ==(XrSpatialAnchorsStorageML left, ulong right) => left.Handle == right;
+ public static bool operator !=(XrSpatialAnchorsStorageML left, ulong right) => left.Handle != right;
+ public bool Equals(XrSpatialAnchorsStorageML h) => Handle == h.Handle;
+ public override bool Equals(object o) => o is XrSpatialAnchorsStorageML h && Equals(h);
+ public override int GetHashCode() => Handle.GetHashCode();
+}
+
public partial struct XrExportedLocalizationMapML : IEquatable
{
public readonly ulong Handle;
@@ -422,6 +437,36 @@ public partial struct XrEnvironmentDepthSwapchainMETA : IEquatable Handle.GetHashCode();
}
+ public partial struct XrBodyTrackerHTC : IEquatable
+{
+ public readonly ulong Handle;
+ public XrBodyTrackerHTC(ulong existingHandle) { Handle = existingHandle; }
+ public static XrBodyTrackerHTC Null => new XrBodyTrackerHTC(0);
+ public static implicit operator XrBodyTrackerHTC(ulong handle) => new XrBodyTrackerHTC(handle);
+ public static bool operator ==(XrBodyTrackerHTC left, XrBodyTrackerHTC right) => left.Handle == right.Handle;
+ public static bool operator !=(XrBodyTrackerHTC left, XrBodyTrackerHTC right) => left.Handle != right.Handle;
+ public static bool operator ==(XrBodyTrackerHTC left, ulong right) => left.Handle == right;
+ public static bool operator !=(XrBodyTrackerHTC left, ulong right) => left.Handle != right;
+ public bool Equals(XrBodyTrackerHTC h) => Handle == h.Handle;
+ public override bool Equals(object o) => o is XrBodyTrackerHTC h && Equals(h);
+ public override int GetHashCode() => Handle.GetHashCode();
+}
+
+ public partial struct XrWorldMeshDetectorML : IEquatable
+{
+ public readonly ulong Handle;
+ public XrWorldMeshDetectorML(ulong existingHandle) { Handle = existingHandle; }
+ public static XrWorldMeshDetectorML Null => new XrWorldMeshDetectorML(0);
+ public static implicit operator XrWorldMeshDetectorML(ulong handle) => new XrWorldMeshDetectorML(handle);
+ public static bool operator ==(XrWorldMeshDetectorML left, XrWorldMeshDetectorML right) => left.Handle == right.Handle;
+ public static bool operator !=(XrWorldMeshDetectorML left, XrWorldMeshDetectorML right) => left.Handle != right.Handle;
+ public static bool operator ==(XrWorldMeshDetectorML left, ulong right) => left.Handle == right;
+ public static bool operator !=(XrWorldMeshDetectorML left, ulong right) => left.Handle != right;
+ public bool Equals(XrWorldMeshDetectorML h) => Handle == h.Handle;
+ public override bool Equals(object o) => o is XrWorldMeshDetectorML h && Equals(h);
+ public override int GetHashCode() => Handle.GetHashCode();
+}
+
public partial struct XrSpatialGraphNodeBindingMSFT : IEquatable
{
public readonly ulong Handle;
diff --git a/OpenXRGen/Evergine.Bindings.OpenXR/Generated/Structs.cs b/OpenXRGen/Evergine.Bindings.OpenXR/Generated/Structs.cs
index d4c4567..87b9a59 100644
--- a/OpenXRGen/Evergine.Bindings.OpenXR/Generated/Structs.cs
+++ b/OpenXRGen/Evergine.Bindings.OpenXR/Generated/Structs.cs
@@ -7362,6 +7362,65 @@ public unsafe partial struct XrEventDataViveTrackerConnectedHTCX
public XrViveTrackerPathsHTCX* paths;
}
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrSystemBodyTrackingPropertiesHTC
+ {
+ public XrStructureType type;
+ public void* next;
+ public XrBool32 supportsBodyTracking;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrBodyTrackerCreateInfoHTC
+ {
+ public XrStructureType type;
+ public void* next;
+ public XrBodyJointSetHTC bodyJointSet;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrBodySkeletonJointHTC
+ {
+ public XrPosef pose;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrBodySkeletonHTC
+ {
+ public XrStructureType type;
+ public void* next;
+ public uint jointCount;
+ public XrBodySkeletonJointHTC* joints;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrBodyJointsLocateInfoHTC
+ {
+ public XrStructureType type;
+ public void* next;
+ public XrSpace baseSpace;
+ public long time;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrBodyJointLocationHTC
+ {
+ public ulong locationFlags;
+ public XrPosef pose;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrBodyJointLocationsHTC
+ {
+ public XrStructureType type;
+ public void* next;
+ public ulong combinedLocationFlags;
+ public XrBodyJointConfidenceHTC confidenceLevel;
+ public uint jointLocationCount;
+ public XrBodyJointLocationHTC* jointLocations;
+ public uint skeletonGenerationId;
+ }
+
[StructLayout(LayoutKind.Sequential)]
public unsafe partial struct XrCompositionLayerSpaceWarpInfoFB
{
@@ -8300,5 +8359,309 @@ public unsafe partial struct XrSpaceVelocityData
public XrVector3f angularVelocity;
}
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrSystemNotificationsSetInfoML
+ {
+ public XrStructureType type;
+ public void* next;
+ public XrBool32 suppressNotifications;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrSpatialAnchorsCreateInfoBaseHeaderML
+ {
+ public XrStructureType type;
+ public void* next;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrSpatialAnchorsCreateInfoFromPoseML
+ {
+ public XrStructureType type;
+ public void* next;
+ public XrSpace baseSpace;
+ public XrPosef poseInBaseSpace;
+ public long time;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrCreateSpatialAnchorsCompletionML
+ {
+ public XrStructureType type;
+ public void* next;
+ public XrResult futureResult;
+ public uint spaceCount;
+ public XrSpace* spaces;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrSpatialAnchorStateML
+ {
+ public XrStructureType type;
+ public void* next;
+ public XrSpatialAnchorConfidenceML confidence;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrSpatialAnchorsCreateStorageInfoML
+ {
+ public XrStructureType type;
+ public void* next;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrSpatialAnchorsQueryInfoBaseHeaderML
+ {
+ public XrStructureType type;
+ public void* next;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrSpatialAnchorsQueryInfoRadiusML
+ {
+ public XrStructureType type;
+ public void* next;
+ public XrSpace baseSpace;
+ public XrVector3f center;
+ public long time;
+ public float radius;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrSpatialAnchorsQueryCompletionML
+ {
+ public XrStructureType type;
+ public void* next;
+ public XrResult futureResult;
+ public uint uuidCapacityInput;
+ public uint uuidCountOutput;
+ public XrUuid* uuids;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrSpatialAnchorsCreateInfoFromUuidsML
+ {
+ public XrStructureType type;
+ public void* next;
+ public XrSpatialAnchorsStorageML storage;
+ public uint uuidCount;
+ public XrUuid* uuids;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrSpatialAnchorsPublishInfoML
+ {
+ public XrStructureType type;
+ public void* next;
+ public uint anchorCount;
+ public XrSpace* anchors;
+ public ulong expiration;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrSpatialAnchorsPublishCompletionML
+ {
+ public XrStructureType type;
+ public void* next;
+ public XrResult futureResult;
+ public uint uuidCount;
+ public XrUuid* uuids;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrSpatialAnchorsDeleteInfoML
+ {
+ public XrStructureType type;
+ public void* next;
+ public uint uuidCount;
+ public XrUuid* uuids;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrSpatialAnchorsDeleteCompletionML
+ {
+ public XrStructureType type;
+ public void* next;
+ public XrResult futureResult;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrSpatialAnchorsUpdateExpirationInfoML
+ {
+ public XrStructureType type;
+ public void* next;
+ public uint uuidCount;
+ public XrUuid* uuids;
+ public ulong expiration;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrSpatialAnchorsUpdateExpirationCompletionML
+ {
+ public XrStructureType type;
+ public void* next;
+ public XrResult futureResult;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrSpatialAnchorCompletionResultML
+ {
+ public XrUuid uuid;
+ public XrResult result;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrSpatialAnchorsPublishCompletionDetailsML
+ {
+ public XrStructureType type;
+ public void* next;
+ public uint resultCount;
+ public XrSpatialAnchorCompletionResultML* results;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrSpatialAnchorsDeleteCompletionDetailsML
+ {
+ public XrStructureType type;
+ public void* next;
+ public uint resultCount;
+ public XrSpatialAnchorCompletionResultML* results;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrSpatialAnchorsUpdateExpirationCompletionDetailsML
+ {
+ public XrStructureType type;
+ public void* next;
+ public uint resultCount;
+ public XrSpatialAnchorCompletionResultML* results;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrWorldMeshDetectorCreateInfoML
+ {
+ public XrStructureType type;
+ public void* next;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrWorldMeshStateRequestInfoML
+ {
+ public XrStructureType type;
+ public void* next;
+ public XrSpace baseSpace;
+ public long time;
+ public XrPosef boundingBoxCenter;
+ public XrExtent3Df boundingBoxExtents;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrWorldMeshBlockStateML
+ {
+ public XrStructureType type;
+ public void* next;
+ public XrUuid uuid;
+ public XrPosef meshBoundingBoxCenter;
+ public XrExtent3Df meshBoundingBoxExtents;
+ public long lastUpdateTime;
+ public XrWorldMeshBlockStatusML status;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrWorldMeshStateRequestCompletionML
+ {
+ public XrStructureType type;
+ public void* next;
+ public XrResult futureResult;
+ public long timestamp;
+ public uint meshBlockStateCapacityInput;
+ public uint meshBlockStateCountOutput;
+ public XrWorldMeshBlockStateML* meshBlockStates;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrWorldMeshBufferRecommendedSizeInfoML
+ {
+ public XrStructureType type;
+ public void* next;
+ public uint maxBlockCount;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrWorldMeshBufferSizeML
+ {
+ public XrStructureType type;
+ public void* next;
+ public uint size;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrWorldMeshBufferML
+ {
+ public XrStructureType type;
+ public void* next;
+ public uint bufferSize;
+ public void* buffer;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrWorldMeshBlockRequestML
+ {
+ public XrStructureType type;
+ public void* next;
+ public XrUuid uuid;
+ public XrWorldMeshDetectorLodML lod;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrWorldMeshGetInfoML
+ {
+ public XrStructureType type;
+ public void* next;
+ public ulong flags;
+ public float fillHoleLength;
+ public float disconnectedComponentArea;
+ public uint blockCount;
+ public XrWorldMeshBlockRequestML* blocks;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrWorldMeshBlockML
+ {
+ public XrStructureType type;
+ public void* next;
+ public XrUuid uuid;
+ public XrWorldMeshBlockResultML blockResult;
+ public XrWorldMeshDetectorLodML lod;
+ public ulong flags;
+ public uint indexCount;
+ public ushort* indexBuffer;
+ public uint vertexCount;
+ public XrVector3f* vertexBuffer;
+ public uint normalCount;
+ public XrVector3f* normalBuffer;
+ public uint confidenceCount;
+ public float* confidenceBuffer;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrWorldMeshRequestCompletionInfoML
+ {
+ public XrStructureType type;
+ public void* next;
+ public XrSpace meshSpace;
+ public long meshSpaceLocateTime;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ public unsafe partial struct XrWorldMeshRequestCompletionML
+ {
+ public XrStructureType type;
+ public void* next;
+ public XrResult futureResult;
+ public uint blockCount;
+ public XrWorldMeshBlockML* blocks;
+ }
+
}