תוסף OpenXR‏ XR_ANDROID_trackables

מחרוזת שם

XR_ANDROID_trackables

סוג התוסף

תוסף למכונה

מספר תוסף רשום

456

גרסה

1

תלות בתוספים ובגרסאות

OpenXR 1.0

תאריך השינוי האחרון

2024-09-30

סטטוס כתובת ה-IP

לא ידוע על תלונות על הפרת זכויות יוצרים בנושא כתובת IP.

שותפים ביצירת התוכן

ספנסר קווין (Spencer Quin), Google

Nihav Jain, ‏ Google

ג'ון פורסי (John Pursey), Google

Jared Finder, ‏ Google

לונן צ'ן, Google

Kenny Vercaemer, ‏ Google

סקירה כללית

התוסף הזה מאפשר לאפליקציה לגשת לפריטים שניתן לעקוב אחריהם מהסביבה הפיזית, וליצור עוגנים שמצורפים לפריטים שניתן לעקוב אחריהם.

התוסף הזה מגדיר אובייקטים שניתנים למעקב במטוס. תוספים אחרים עשויים להוסיף עוד סוגים שניתן לעקוב אחריהם. לדוגמה, XR_ANDROID_trackables_object מוסיף אובייקטים שניתנים למעקב, ו-XR_ANDROID_depth_texture מוסיף מאגרי עומק שמאפשרים הקרנת קרניים לנקודות שרירותיות בסביבה.

אובייקט שניתן לעקוב אחריו הוא אובייקט שאפשר לעקוב אחריו בסביבה הפיזית (ראו XrTrackableTypeANDROID):

  • מישור (למשל, קיר, רצפה, תקרה, שולחן)
  • אובייקט (למשל מקלדת, עכבר, מחשב נייד)

יצירת מכשיר מעקב שניתן לעקוב אחריו

XrTrackableTrackerANDROID הוא כינוי שמייצג את המשאבים הנדרשים כדי לגלות ולעדכן אובייקטים שניתן לעקוב אחריהם מסוג XrTrackableTypeANDROID בסביבה.

XR_DEFINE_HANDLE(XrTrackableTrackerANDROID)

הפונקציה xrCreateTrackableTrackerANDROID מוגדרת באופן הבא: 

XrResult xrCreateTrackableTrackerANDROID(
    XrSession                                   session,
    const XrTrackableTrackerCreateInfoANDROID*  createInfo,
    XrTrackableTrackerANDROID*                  trackableTracker);

תיאורי פרמטרים

האפליקציה יכולה להשתמש בפונקציה xrCreateTrackableTrackerANDROID כדי ליצור מכשיר מעקב שניתן לעקוב אחריו.

  • הערך XR_ERROR_FEATURE_UNSUPPORTED יוחזר אם המערכת לא תומכת באובייקטים שניתן לעקוב אחריהם מהסוג שצוין.
  • הערך XR_ERROR_PERMISSION_INSUFFICIENT יוחזר אם ההרשאות הנדרשות לא הוענקו לאפליקציה ששלחה את הקריאה.

האפליקציה יכולה להשתמש במזהה המעקב שהוחזר בקריאות API הבאות. צריך לפנות את הטיפולן של XrTrackableTrackerANDROID בסופו של דבר באמצעות הפונקציה xrDestroyTrackableTrackerANDROID.

שימוש תקין (מרומז)

קודי החזרה

הצלחה

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

כישלון

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_VALIDATION_FAILURE
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_OUT_OF_MEMORY
  • XR_ERROR_LIMIT_REACHED
  • XR_ERROR_FEATURE_UNSUPPORTED

המבנה XrTrackableTrackerCreateInfoANDROID מוגדר כך: 

typedef struct XrTrackableTrackerCreateInfoANDROID {
    XrStructureType           type;
    void*                     next;
    XrTrackableTypeANDROID    trackableType;
} XrTrackableTrackerCreateInfoANDROID;

תיאורי חברים

  • type הוא XrStructureType של המבנה הזה.
  • next הוא NULL או הפניה למבנה הבא בשרשרת המבנים. אין מבנים כאלה מוגדרים ב-OpenXR או בתוסף הזה.
  • trackableType הוא הערך של XrTrackableTypeANDROID שמערכת המעקב תעקוב אחריו.

המבנה XrTrackableTrackerCreateInfoANDROID מספק אפשרויות יצירה ל-XrTrackableTrackerANDROID כשהוא מועבר ל-xrCreateTrackableTrackerANDROID.

תוספים יכולים להגדיר מבנים שאפשר לצרף ל-next כדי לאפשר הגדרה נוספת של השירותים למעקב שניתן לעקוב אחריהם.

שימוש תקין (מרומז)

המאפיין המסווג XrTrackableTypeANDROID מוגדר כך: 

typedef enum XrTrackableTypeANDROID {
    XR_TRACKABLE_TYPE_NOT_VALID_ANDROID = 0,
    XR_TRACKABLE_TYPE_PLANE_ANDROID = 1,
    XR_TRACKABLE_TYPE_DEPTH_ANDROID = 1000463000,
    XR_TRACKABLE_TYPE_OBJECT_ANDROID = 1000466000
} XrTrackableTypeANDROID;

הפונקציה xrDestroyTrackableTrackerANDROID מוגדרת כך: 

XrResult xrDestroyTrackableTrackerANDROID(
    XrTrackableTrackerANDROID                   trackableTracker);

תיאורי פרמטרים

הפונקציה xrDestroyTrackableTrackerANDROID משמידה את מכשיר המעקב שניתן לעקוב אחריו.

אם אין XrTrackableTrackerANDROID תקף אחר שנוצר עם אותו XrTrackableTypeANDROID, המערכת עשויה להשבית את שירותי המעקב הנדרשים לסוג הזה של אובייקט למעקב כדי לחסוך במשאבי המערכת.

שימוש תקין (מרומז)

בטיחות בשרשור

  • חובה לסנכרן באופן חיצוני את הגישה ל-trackableTracker ולכל כינויים משניים

קודי החזרה

הצלחה

  • XR_SUCCESS

כישלון

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID

הצגת כל הפריטים שניתן לעקוב אחריהם

האטום XrTrackableANDROID מוגדר כך:

XR_DEFINE_ATOM(XrTrackableANDROID)

השדה XrTrackableANDROID משמש לייצוג אובייקט אחד שניתן לעקוב אחריו, והוא תקף רק במהלך מחזור החיים של XrTrackableTrackerANDROID המשויך אליו.

הפונקציה xrGetAllTrackablesANDROID מוגדרת באופן הבא: 

XrResult xrGetAllTrackablesANDROID(
    XrTrackableTrackerANDROID                   trackableTracker,
    uint32_t                                    trackableCapacityInput,
    uint32_t*                                   trackableCountOutput,
    XrTrackableANDROID*                         trackables);

תיאורי פרמטרים

  • trackableTracker הוא XrTrackableTrackerANDROID שרוצים לשלוח לו שאילתה.

  • trackableCapacityInput הוא הקיבולת של מערך trackables, או 0 כדי לציין בקשה לאחזור הקיבולת הנדרשת.

  • trackableCountOutput הוא הפניה למספר הפעמים ש-trackables נכתב, או הפניה לקיבולת הנדרשת במקרה ש-trackables לא מספיק.

  • trackables הוא מצביע למערך של XrTrackableANDROID. הערך יכול להיות NULL אם הערך של trackableCapacityInput הוא 0.

  • בקטע פרמטרים של גודל מאגר מפורט תיאור של אחזור הגודל הנדרש של trackables.

הפונקציה xrGetAllTrackablesANDROID ממלאת מערך של XrTrackableANDROID שמייצג את הפריטים שניתן לעקוב אחריהם שנמצאים בסביבה. הערך של XrTrackableTypeANDROID ב-trackables המוחזר חייב להתאים לערך של XrTrackableTypeANDROID ב-trackableTracker.

אחזור מטוס שניתן לעקוב אחריו

הפונקציה xrGetTrackablePlaneANDROID מוגדרת כך:

XrResult xrGetTrackablePlaneANDROID(
    XrTrackableTrackerANDROID                   trackableTracker,
    const XrTrackableGetInfoANDROID*            getInfo,
    XrTrackablePlaneANDROID*                    planeOutput);

תיאורי פרמטרים

הפונקציה xrGetTrackablePlaneANDROID מחזירה פרטים על המשטח שניתן לעקוב אחריו, כמו הגיאומטריה, הכיוון וסטטוס המעקב שלו.

פרטי המטוס ממוינים ביחס למרחב הבסיס בזמן הקריאה ל-xrGetTrackablePlaneANDROID באמצעות XrTrackableGetInfoANDROID::time,‏ XrTrackableGetInfoANDROID::baseSpace.

שימוש תקין (מרומז)

קודי החזרה

הצלחה

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

כישלון

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_VALIDATION_FAILURE
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_LIMIT_REACHED
  • XR_ERROR_TIME_INVALID

המבנה XrTrackableGetInfoANDROID מוגדר כך: 

typedef struct XrTrackableGetInfoANDROID {
    XrStructureType       type;
    void*                 next;
    XrTrackableANDROID    trackable;
    XrSpace               baseSpace;
    XrTime                time;
} XrTrackableGetInfoANDROID;

תיאורי חברים

  • type הוא XrStructureType של המבנה הזה.
  • next הוא NULL או הפניה למבנה הבא בשרשרת המבנים. אין מבנים כאלה מוגדרים ב-OpenXR או בתוסף הזה.
  • trackable הוא המטוס XrTrackableANDROID שרוצים לשלוח עליו שאילתה.
  • baseSpace תנוחת המטוס תהיה ביחס ל-XrSpace הזה ב-time.
  • time הוא XrTime שבו צריך להעריך את הקואורדינטות ביחס ל-baseSpace.

המבנה XrTrackableGetInfoANDROID מספק אפשרויות לשאילתות כשהוא מועבר אל xrGetTrackablePlaneANDROID. הערך של trackable חייב להתאים לערך של trackableTracker שמופיע ב-xrGetTrackablePlaneANDROID.

הערך XR_ERROR_MISMATCHING_TRACKABLE_TYPE_ANDROID יוחזר אם הסוג שניתן למעקב של trackable הוא לא XR_TRACKABLE_TYPE_PLANE_ANDROID.

שימוש תקין (מרומז)

המבנה XrTrackablePlaneANDROID מוגדר כך: 

typedef struct XrTrackablePlaneANDROID {
    XrStructureType           type;
    void*                     next;
    XrTrackingStateANDROID    trackingState;
    XrPosef                   centerPose;
    XrExtent2Df               extents;
    XrPlaneTypeANDROID        planeType;
    XrPlaneLabelANDROID       planeLabel;
    XrTrackableANDROID        subsumedByPlane;
    XrTime                    lastUpdatedTime;
    uint32_t                  vertexCapacityInput;
    uint32_t*                 vertexCountOutput;
    XrVector2f*               vertices;
} XrTrackablePlaneANDROID;

תיאורי חברים

  • type הוא XrStructureType של המבנה הזה.
  • next הוא NULL או הפניה למבנה הבא בשרשרת המבנים. אין מבנים כאלה מוגדרים ב-OpenXR או בתוסף הזה.
  • trackingState הוא XrTrackingStateANDROID של המטוס.
  • centerPose הוא XrPosef שמגדיר את המיקום והכיוון של המטוס בתוך מסגרת העזר של XrTrackableGetInfoANDROID::baseSpace התואם. כאן, כיוון זהות מייצג צירי קואורדינטות עם Y+ מקביל לנורמלית של המישן.
  • extents הוא המאפיין XrExtent2Df של המטוס.
  • planeType הוא הערך של XrPlaneTypeANDROID שהוגדר למטוס הזה בסביבת זמן הריצה.
  • planeLabel הוא הערך של XrPlaneLabelANDROID שהוגדר למטוס הזה בסביבת זמן הריצה.
  • subsumedByPlane הוא XrTrackableANDROID של המישן שמכיל את המישן הזה (XR_NULL_TRACKABLE_ANDROID אם לא קיים כזה).
  • lastUpdatedTime הוא XrTime של העדכון האחרון של המטוס.
  • vertexCapacityInput הוא הקיבולת של מערך vertices, או 0 כדי לציין בקשה לאחזור הקיבולת הנדרשת.
  • vertexCountOutput הוא הפניה למספר הפעמים ש-vertices נכתב, או הפניה לקיבולת הנדרשת במקרה ש-vertices לא מספיק.
  • vertices הוא הפניה למערך של XrVector2f. הערך יכול להיות NULL אם הערך של vertexCapacityInput הוא 0. הקודקודים מופיעים בסדר נגד כיוון השעון. הפוליגון יכול להיות קעור, ואסור שהוא יתחכך בעצמו.
  • בקטע פרמטרים של גודל מאגר מפורט תיאור של אחזור הגודל הנדרש של vertices.

שימוש תקין (מרומז)

המאפיין המסווג XrTrackingStateANDROID מתאר את סטטוס המעקב של XrTrackableANDROID. 

typedef enum XrTrackingStateANDROID {
    XR_TRACKING_STATE_PAUSED_ANDROID = 0,
    XR_TRACKING_STATE_STOPPED_ANDROID = 1,
    XR_TRACKING_STATE_TRACKING_ANDROID = 2
} XrTrackingStateANDROID;

XrTrackingStateANDROID

תיאור

XR_TRACKING_STATE_PAUSED_ANDROID

מציין שהמעקב אחר הרכיבים שניתן לעקוב אחריהם או אחר הרכיבים המוצמדים מושהה, אבל יכול להימשך בעתיד.

XR_TRACKING_STATE_STOPPED_ANDROID

המעקב אחר הפריט הזה הופסק ולא יחודש לעולם.

XR_TRACKING_STATE_TRACKING_ANDROID

האובייקט במעקב והתנוחה שלו עדכנית.

המאפיין XrPlaneTypeANDROID הוא הסוג של המטוס XrTrackableANDROID. 

typedef enum XrPlaneTypeANDROID {
    XR_PLANE_TYPE_HORIZONTAL_DOWNWARD_FACING_ANDROID = 0,
    XR_PLANE_TYPE_HORIZONTAL_UPWARD_FACING_ANDROID = 1,
    XR_PLANE_TYPE_VERTICAL_ANDROID = 2,
    XR_PLANE_TYPE_ARBITRARY_ANDROID = 3
} XrPlaneTypeANDROID;

המאפיין XrPlaneLabelANDROID הוא תווית של מישור XrTrackableANDROID. 

typedef enum XrPlaneLabelANDROID {
    XR_PLANE_LABEL_UNKNOWN_ANDROID = 0,
    XR_PLANE_LABEL_WALL_ANDROID = 1,
    XR_PLANE_LABEL_FLOOR_ANDROID = 2,
    XR_PLANE_LABEL_CEILING_ANDROID = 3,
    XR_PLANE_LABEL_TABLE_ANDROID = 4
} XrPlaneLabelANDROID;

יצירת מרחב משותף מרכזי

XrResult xrCreateAnchorSpaceANDROID(
    XrSession                                   session,
    const XrAnchorSpaceCreateInfoANDROID*       createInfo,
    XrSpace*                                    anchorOutput);

תיאורי פרמטרים

  • session הוא XrSession שיוצר את מרחב העוגן.
  • createInfo הוא הפניה למבנה XrAnchorSpaceCreateInfoANDROID שמכיל פרמטרים שישמשו ליצירת מרחב העוגן.
  • anchorOutput הוא הפניה למזהה שבו מוחזר XrSpace שנוצר.

בכל שלב, אפשר לעקוב אחרי המיקום והכיוון של הצ'אט או להפסיק את המעקב אחריהם. כלומר, צריך להגדיר את XR_SPACE_LOCATION_POSITION_TRACKED_BIT ואת XR_SPACE_LOCATION_ORIENTATION_TRACKED_BIT או לנקות את שניהם כשהאפליקציה קוראת ל-xrLocateSpace או ל-xrLocateSpaces עבור anchorOutput.

האפליקציה חייבת לפנות את XrSpace המוחזר באמצעות xrDestroySpace.

  • צריך להחזיר את הערך XR_ERROR_FEATURE_UNSUPPORTED אם המערכת לא תומכת בעוגנים.
  • צריך להחזיר את הערך XR_ERROR_TRACKABLE_TYPE_NOT_SUPPORTED_ANDROID אם אין תמיכה בקובץ המוצמד הספציפי של העוגן.

שימוש תקין (מרומז)

קודי החזרה

הצלחה

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

כישלון

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_TRACKABLE_TYPE_NOT_SUPPORTED_ANDROID
  • XR_ERROR_VALIDATION_FAILURE
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_LIMIT_REACHED
  • XR_ERROR_POSE_INVALID
  • XR_ERROR_TIME_INVALID
  • XR_ERROR_OUT_OF_MEMORY

המבנה XrAnchorSpaceCreateInfoANDROID מוגדר כך: 

typedef struct XrAnchorSpaceCreateInfoANDROID {
    XrStructureType       type;
    void*                 next;
    XrSpace               space;
    XrTime                time;
    XrPosef               pose;
    XrTrackableANDROID    trackable;
} XrAnchorSpaceCreateInfoANDROID;

תיאורי חברים

  • type הוא XrStructureType של המבנה הזה.
  • next הוא NULL או הפניה למבנה הבא בשרשרת המבנים. אין מבנים כאלה מוגדרים ב-OpenXR או בתוסף הזה.
  • space הוא XrSpace שבו תיווצר העוגן.
  • time הוא XrTime של יצירת העוגן.
  • pose הוא XrPosef של העוגן.
  • trackable הוא ה-XrTrackableANDROID שאליו יצורף האוגר. יכול להיות ש-XR_NULL_TRACKABLE_ANDROID יוצר עוגן מרחבי.

שימוש תקין (מרומז)

קוד לדוגמה לאחזור כל הפריטים שניתן לעקוב אחריהם

הקוד לדוגמה הבא מראה איך לקבל את כל הפריטים שניתן לעקוב אחריהם מסוג נתון.

XrSession session; // previously initialized

// The function pointers are previously initialized using xrGetInstanceProcAddr.
PFN_xrCreateTrackableTrackerANDROID xrCreateTrackableTrackerANDROID; // previously initialized
PFN_xrGetAllTrackablesANDROID xrGetAllTrackablesANDROID; // previously initialized
PFN_xrDestroyTrackableTrackerANDROID xrDestroyTrackableTrackerANDROID; // previously initialized

XrTrackableTrackerCreateInfoANDROID createInfo{XR_TYPE_TRACKABLE_TRACKER_CREATE_INFO_ANDROID};
createInfo.trackableType = XR_TRACKABLE_TYPE_PLANE_ANDROID;
XrTrackableTrackerANDROID planeTrackableTracker;
XrResult result = xrCreateTrackableTrackerANDROID(
  session,
  &createInfo,
  &planeTrackableTracker);
if (result != XR_SUCCESS) { /* Handle failures. */ }

uint32_t trackableCountOutput = 0;
std::vector<XrTrackableANDROID> allPlaneTrackables;

// Query the number of trackables available.
result = xrGetAllTrackablesANDROID(
  planeTrackableTracker,
  0,
  &trackableCountOutput,
  nullptr
);

if (result == XR_SUCCESS) {
  allPlaneTrackables.resize(trackableCountOutput, XR_NULL_HANDLE);

  // Fetch the actual trackable handles in the appropriately resized array.
  result = xrGetAllTrackablesANDROID(
    planeTrackableTracker,
    trackableCountOutput,
    &trackableCountOutput,
    allPlaneTrackables.data());

  if (result == XR_SUCCESS) {
    for (XrTrackableANDROID trackable : allPlaneTrackables) {
      // You now have all trackables of the specified type.
    }
  }
}

// Release trackable tracker.
result = xrDestroyTrackableTrackerANDROID(planeTrackableTracker);

קוד לדוגמה לאיתור מטוס שניתן לעקוב אחריו

בקוד לדוגמה הבא מוסבר איך לקבל מטוס שניתן לעקוב אחריו מ-XrTrackableANDROID קיים, שנוצר כתוצאה מהיט XR_ANDROID_raycast או xrGetTrackablesANDROID.

XrTrackableTrackerANDROID planeTracker; // previously created

// The function pointers are previously initialized using xrGetInstanceProcAddr.
PFN_xrGetTrackablePlaneANDROID xrGetTrackablePlaneANDROID; // previously initialized

XrTime updateTime; // Time used for the current frame's simulation update.
XrSpace appSpace; // Space created for XR_REFERENCE_SPACE_TYPE_LOCAL.
XrTrackableANDROID planeTrackable; // Acquired from a hit result or getTrackables().

XrTrackableGetInfoANDROID planeGetInfo;
planeGetInfo.type = XR_TYPE_TRACKABLE_GET_INFO_ANDROID;
planeGetInfo.next = nullptr;
planeGetInfo.trackable = planeTrackable;
planeGetInfo.space = appSpace;
planeGetInfo.time = updateTime;

XrTrackablePlaneANDROID plane = { XR_TYPE_TRACKABLE_PLANE_ANDROID };
result = xrGetTrackablePlaneANDROID(
  planeTracker,
  &planeGetInfo,
  &plane
);

if (result == XR_SUCCESS) {
  // Plane tracking state, center pose, extents, type now available in plane.
}

קוד לדוגמה ליצירת מרחב עגינה

הקוד לדוגמה הבא מראה איך יוצרים מרחב מרכזי שמצורף לנכס שניתן למעקב.

XrSession session; // Created at app startup.
XrTime updateTime; // Time used for the current frame's simulation update.
XrSpace appSpace; // Space created for XR_REFERENCE_SPACE_TYPE_LOCAL.
XrTrackableANDROID planeTrackable; // Acquired from a hit result or getTrackables().

// Create an anchor at (2, 2, 2) world-coordinates.
XrAnchorSpaceCreateInfoANDROID spatialAnchorCreateInfo;
spatialAnchorCreateInfo.type = XR_TYPE_ANCHOR_SPACE_CREATE_INFO_ANDROID;
spatialAnchorCreateInfo.next = nullptr;
spatialAnchorCreateInfo.space = appSpace;
spatialAnchorCreateInfo.time = updateTime;
spatialAnchorCreateInfo.pose = { { 0, 0, 0, 1 }, { 2, 2, 2 } };

XrSpace spatialAnchor = XR_NULL_HANDLE;
XrResult result = xrCreateAnchorSpaceANDROID(
  session,
  &spatialAnchorCreateInfo,
  &spatialAnchor
);

// Create an anchor attached to a trackable.
XrTrackablePlane plane = ...;
XrAnchorSpaceCreateInfoANDROID trackableAnchorCreateInfo;
trackableAnchorCreateInfo.type = XR_TYPE_ANCHOR_SPACE_CREATE_INFO_ANDROID;
trackableAnchorCreateInfo.next = nullptr;
trackableAnchorCreateInfo.space = appState;
trackableAnchorCreateInfo.pose = plane.centerPose;
trackableAnchorCreateInfo.trackable = planeTrackable;

XrSpace trackableAnchor = XR_NULL_HANDLE;
XrResult result = xrCreateAnchorSpaceANDROID(
  session,
  &trackableAnchorCreateInfo,
  &trackableAnchor
);
while (true) {
  // app update loop
  // ...

  // Get the current location of the anchor's space w.r.t the world.
  XrSpaceLocation anchorLocation = { XR_TYPE_SPACE_LOCATION };
  result = xrLocateSpace(trackableAnchor, appSpace, updateTime, &anchorLocation);

  if (anchor.trackingState == XR_TRACKING_STATE_TRACKING_ANDROID) {
    // Update anchor pose.
    doDrawingForAnchor(anchorLocation.pose);
  } else {
    // ...
  }
}

// Cleanup - destroy the space, detatch the anchor so its no longer tracked by the
// runtime and then release all resources held by it.
xrDestroySpace(spatialAnchor);
xrDestroySpace(trackableAnchor);

סוגים חדשים של בסיסים

סוגי אובייקטים חדשים

קבועים חדשים של Enum

המניין XrStructureType הורחב עם:

  • XR_TYPE_TRACKABLE_GET_INFO_ANDROID
  • XR_TYPE_ANCHOR_SPACE_CREATE_INFO_ANDROID
  • XR_TYPE_TRACKABLE_PLANE_ANDROID
  • XR_TYPE_TRACKABLE_TRACKER_CREATE_INFO_ANDROID

המניין XrObjectType הורחב עם:

  • XR_OBJECT_TYPE_TRACKABLE_TRACKER_ANDROID

המניין XrResult הורחב עם:

  • XR_ERROR_MISMATCHING_TRACKABLE_TYPE_ANDROID
  • XR_ERROR_TRACKABLE_TYPE_NOT_SUPPORTED_ANDROID

משתני Enum חדשים

מבנים חדשים

פונקציות חדשות

בעיות

היסטוריית הגרסאות

  • גרסה 1, 27 בספטמבר 2024 (Kenny Vercaemer)
    • תיאור ראשוני של התוסף.

OpenXR™‎ והלוגו של OpenXR הם סימנים מסחריים בבעלות The Khronos Group Inc., והם רשומים כסימנים מסחריים בסין, באיחוד האירופי, ביפן ובבריטניה.