XR_EXT_spatial_entity

מחרוזת שם

XR_EXT_spatial_entity

סוג התוסף

תוסף למכונה

מספר השלוחה הרשום

741

גרסה

1

סטטוס האישור

אושר

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

XR_EXT_future

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

Nihav Jain, Google
Jared Finder, Google
Natalie Fleury, Meta
Yuichi Taguchi, Meta
Ron Bessems, Meta
Yin Li, Microsoft
Karthik Kadappan, Magic Leap
Jimmy Alamparambil, ByteDance
Zhipeng Liu, ByteDance
Jun Yan, ByteDance

סקירה כללית

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

החלקים העיקריים של התוסף הזה הם:

  • ישויות מרחביות : הפונקציונליות מתמקדת בישויות , שמספקות מעט מאוד פונקציונליות בפני עצמן.
  • רכיבים מרחביים : לישויות האלה יש רכיבים שמשויכים אליהן ומספקים נתונים והתנהגויות.
  • סוגי רכיבים מרחביים : כל רכיב מרחבי הוא סוג רכיב ספציפי, ולכל ישות נתונה יש לכל היותר רכיב אחד מכל סוג רכיב נתון.
  • הקשר מרחבי : כל האינטראקציות של ישויות מרחביות מתרחשות בהקשר אחרי שלב האתחול וההגדרה.
  • יכולות מרחביות : מניפולציה של ישויות מרחביות מסופקת באופן נרחב על ידי יכולות . יכולת היא יחידה כלשהי של פונקציונליות, למשל (מבלי להגביל) עוגנים שמוגדרים על ידי האפליקציה, זיהוי מישור או מעקב אחר תמונות. כל יכולת מוגדרת בדרך כלל בתוסף נפרד (שמופעל בזמן יצירת המכונה כרגיל) ומופעלת עבור הקשר ספציפי בזמן היצירה.
  • כל יכולת משויכת לקבוצה של סוגי רכיבים, שהרכיבים שלהם קיימים בכל ישות שנחשפת על ידי היכולת הזו. התוסף שמגדיר יכולת מציין אילו סוגי רכיבים נדרשים ליכולת ("מובטחים"), ואותו תוסף או תוספים אחרים עשויים לציין סוגי רכיבים אופציונליים שסופקו על ידי הטמעות פוטנציאליות מסוימות. כל מספר של יכולות יכול לספק לישויות רכיבים של סוג רכיב נתון, שניתן להשתמש בהם באופן אחיד, בלי קשר ליכולת שיצרה אותם.
  • תכונות של יכולות מרחביות : בנוסף, יכולות מסוימות דורשות הגדרה, ולכן הן מוגדרות באמצעות פרמטרים של תכונות של יכולות .

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

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

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

ישות מרחבית

ישויות מרחביות הן ישויות שקיימות במרחב מסוים, ויש להן נתונים משויכים שונים שמאורגנים ברכיבים. הם יכולים להיות כל אחד מהבאים:

  • פיזיים (למשל משטחים מישוריים כמו קירות ורצפות, חפצים כמו כיסאות וכונניות וכו')
  • וירטואלי (למשל, תוכן שמוצב ומשותף על ידי אפליקציה או משתמש אחרים),
  • מוגדר על ידי האפליקציה (למשל, אפליקציה שמסמנת אזור כ"Living Room" או כ"מטבח", או מסמנת נקודה כמיקום להצבת הטלוויזיה וכו')

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

ישויות מרחביות ב-OpenXR מעוצבות כמערכת של רכיבי ישויות . לכל ישות מרחבית יש קבוצה של רכיבים, וכל רכיב מספק קבוצה ייחודית של נתונים והתנהגויות לישות הזו.

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

סוגי רכיבים מרחביים

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

typedef enum XrSpatialComponentTypeEXT {
    XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT = 1,
    XR_SPATIAL_COMPONENT_TYPE_BOUNDED_3D_EXT = 2,
    XR_SPATIAL_COMPONENT_TYPE_PARENT_EXT = 3,
    XR_SPATIAL_COMPONENT_TYPE_MESH_3D_EXT = 4,
    XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT = 1000741000,
    XR_SPATIAL_COMPONENT_TYPE_MESH_2D_EXT = 1000741001,
    XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT = 1000741002,
    XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT = 1000741003,
    XR_SPATIAL_COMPONENT_TYPE_MARKER_EXT = 1000743000,
    XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_EXT = 1000744000,
    XR_SPATIAL_COMPONENT_TYPE_KEYBOARD_SEMANTIC_LABEL_EXT = 1000744001,
    XR_SPATIAL_COMPONENT_TYPE_MOUSE_SEMANTIC_LABEL_EXT = 1000744002,
    XR_SPATIAL_COMPONENT_TYPE_ANCHOR_EXT = 1000762000,
    XR_SPATIAL_COMPONENT_TYPE_PERSISTENCE_EXT = 1000763000,
    XR_SPATIAL_COMPONENT_TYPE_IMAGE_2D_EXT = 1000782000,
    XR_SPATIAL_COMPONENT_TYPE_MESH_3D_NORMALS_EXT = 1000783000,
    XR_SPATIAL_COMPONENT_TYPE_MESH_3D_VERTEX_SEMANTIC_LABELS_EXT = 1000783001,
    XR_SPATIAL_COMPONENT_TYPE_MESH_3D_TRIANGLE_SEMANTIC_LABELS_EXT = 1000783002,
    XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_ANDROID = 1000785000,
    XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID = 1000786000,
    XR_SPATIAL_COMPONENT_TYPE_SUBSUMED_BY_ANDROID = 1000791000,
    XR_SPATIAL_COMPONENT_TYPE_ROOM_ANDROIDSYS = 1000792002,
    XR_SPATIAL_COMPONENT_TYPE_MATERIAL_TYPE_ANDROIDSYS = 1000792003,
    XR_SPATIAL_COMPONENT_TYPE_CONFIDENCE_ANDROIDSYS = 1000792004,
    XR_SPATIAL_COMPONENT_TYPE_ROOM_EMPTINESS_ANDROIDSYS = 1000792005,
    XR_SPATIAL_COMPONENT_TYPE_OCCUPANCY_GRID_ANDROIDX1 = 1000793000,
    XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID = 1000794000,
    XR_SPATIAL_COMPONENT_TYPE_STREETSCAPE_GEOMETRY_METADATA_ANDROIDX2 = 1000798000,
    XR_SPATIAL_COMPONENT_TYPE_GEOMETRY_POINT_ANDROID = 1000803000,
    XR_SPATIAL_COMPONENT_TYPE_PERSISTENCE_SCOPES_ANDROIDX1 = 1000808000,
    XR_SPATIAL_COMPONENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
} XrSpatialComponentTypeEXT;

הספירה XrSpatialComponentTypeEXT מזהה את סוגי הרכיבים השונים שזמן הריצה עשוי לתמוך בהם.

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

הערכים של ה-enumerants הם:

תיאור הטיפוס בן המנייה (enum)

XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT

רכיב שמספק את הגבולות הדו-ממדיים של ישות מרחבית. מבנה הרשימה התואם הוא XrSpatialComponentBounded2DListEXT; מבנה הנתונים התואם הוא XrSpatialBounded2DDataEXT

XR_SPATIAL_COMPONENT_TYPE_BOUNDED_3D_EXT

רכיב שמספק את הגבולות התלת-ממדיים של ישות מרחבית. מבנה הרשימה התואם הוא XrSpatialComponentBounded3DListEXT; מבנה הנתונים התואם הוא XrBoxf

XR_SPATIAL_COMPONENT_TYPE_PARENT_EXT

רכיב שמספק את XrSpatialEntityIdEXT של ההורה של ישות מרחבית. מבנה הרשימה התואם הוא XrSpatialComponentParentListEXT; מבנה הנתונים התואם הוא XrSpatialEntityIdEXT

XR_SPATIAL_COMPONENT_TYPE_MESH_3D_EXT

רכיב שמספק רשת תלת-ממדית לישות מרחבית. מבנה הרשימה התואם הוא XrSpatialComponentMesh3DListEXT; מבנה הנתונים התואם הוא XrSpatialMeshDataEXT

XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT

רכיב שמספק את המאפיין enum של יישור המישור לישות מרחבית. מבנה הרשימה התואם הוא XrSpatialComponentPlaneAlignmentListEXT; מבנה הנתונים התואם הוא XrSpatialPlaneAlignmentEXT (נוסף על ידי התוסף XR_EXT_spatial_plane_tracking)

XR_SPATIAL_COMPONENT_TYPE_MESH_2D_EXT

רכיב שמספק רשת דו-ממדית לישות מרחבית. מבנה הרשימה התואם הוא XrSpatialComponentMesh2DListEXT; מבנה הנתונים התואם הוא XrSpatialMeshDataEXT (נוסף על ידי התוסף XR_EXT_spatial_plane_tracking)

XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT

רכיב שמספק פוליגון גבול דו-ממדי לישות מרחבית. מבנה הרשימה התואם הוא XrSpatialComponentPolygon2DListEXT; מבנה הנתונים התואם הוא XrSpatialPolygon2DDataEXT (נוסף על ידי התוסף XR_EXT_spatial_plane_tracking)

XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT

רכיב שמספק תווית סמנטית למישור. מבנה הרשימה התואם הוא XrSpatialComponentPlaneSemanticLabelListEXT; מבנה הנתונים התואם הוא XrSpatialPlaneSemanticLabelEXT (נוסף על ידי התוסף XR_EXT_spatial_plane_tracking)

XR_SPATIAL_COMPONENT_TYPE_MARKER_EXT

רכיב שמתאר את סוג הסמן, המזהה והמיקום שלו. מבנה הרשימה התואם הוא XrSpatialComponentMarkerListEXT. מבנה הנתונים התואם הוא XrSpatialMarkerDataEXT (נוסף על ידי התוסף XR_EXT_spatial_marker_tracking)

XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_EXT

רכיב שמספק תווית סמנטית לסצנה. מבנה הרשימה התואם הוא XrSpatialComponentObjectSemanticLabelListEXT. מבנה הנתונים התואם הוא XrSpatialObjectSemanticLabelEXT . (נוסף על ידי התוסף XR_EXT_spatial_object_tracking)

XR_SPATIAL_COMPONENT_TYPE_KEYBOARD_SEMANTIC_LABEL_EXT

רכיב שמספק תווית סמנטית למקלדת. מבנה הרשימה התואם הוא XrSpatialComponentKeyboardSemanticLabelListEXT. מבנה הנתונים התואם הוא XrSpatialKeyboardSemanticLabelEXT (נוסף על ידי התוסף XR_EXT_spatial_object_tracking)

XR_SPATIAL_COMPONENT_TYPE_MOUSE_SEMANTIC_LABEL_EXT

רכיב שמספק תווית סמנטית לעכבר. מבנה הרשימה התואם הוא XrSpatialComponentMouseSemanticLabelListEXT. מבנה הנתונים התואם הוא XrSpatialMouseSemanticLabelEXT (נוסף על ידי התוסף XR_EXT_spatial_object_tracking)

XR_SPATIAL_COMPONENT_TYPE_ANCHOR_EXT

רכיב שמספק את המיקום של עוגן. מבנה הרשימה התואם הוא XrSpatialComponentAnchorListEXT; מבנה הנתונים התואם הוא XrPosef (נוסף על ידי התוסף XR_EXT_spatial_anchor)

XR_SPATIAL_COMPONENT_TYPE_PERSISTENCE_EXT

רכיב שמספק את ה-UUID הקבוע של ישות מרחבית. מבנה הרשימה התואם הוא XrSpatialComponentPersistenceListEXT; מבנה הנתונים התואם הוא XrSpatialPersistenceDataEXT (נוסף על ידי התוסף XR_EXT_spatial_persistence)

XR_SPATIAL_COMPONENT_TYPE_IMAGE_2D_EXT

רכיב שמתאר את סוג התמונה המישורית. מבנה הרשימה התואם הוא XrSpatialComponentImage2DListEXT, ומבנה הנתונים התואם הוא XrSpatialImageSizeEXT . (נוסף על ידי התוסף XR_EXT_spatial_image_tracking)

XR_SPATIAL_COMPONENT_TYPE_MESH_3D_NORMALS_EXT

רכיב שמספק את הנורמלים לרשת התלת-ממדית של ישות מרחבית. מבנה הרשימה התואם הוא XrSpatialComponentMesh3DNormalsListEXT; מבנה הנתונים התואם הוא XrSpatialBufferEXT (נוסף על ידי התוסף XR_EXT_spatial_mesh_tracking)

XR_SPATIAL_COMPONENT_TYPE_MESH_3D_VERTEX_SEMANTIC_LABELS_EXT

רכיב שמספק את התוויות הסמנטיות לכל קודקוד ברשת התלת-ממדית של ישות מרחבית. מבנה הרשימה התואם הוא XrSpatialComponentMesh3DVertexSemanticLabelsListEXT; מבנה הנתונים התואם הוא XrSpatialBufferEXT; הנתונים במאגר ממפים אל XrSpatialMeshSemanticLabelEXT (נוסף על ידי התוסף XR_EXT_spatial_mesh_tracking)

XR_SPATIAL_COMPONENT_TYPE_MESH_3D_TRIANGLE_SEMANTIC_LABELS_EXT

רכיב שמספק את התוויות הסמנטיות לכל פאה של משולש ברשת התלת-ממדית של ישות מרחבית. מבנה הרשימה התואם הוא XrSpatialComponentMesh3DTriangleSemanticLabelsListEXT; מבנה הנתונים התואם הוא XrSpatialBufferEXT; הנתונים במאגר הנתונים הזמני ממופים אל XrSpatialMeshSemanticLabelEXT (נוסף על ידי התוסף XR_EXT_spatial_mesh_tracking)

XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_ANDROID

רכיב שמספק תווית סמנטית לאובייקט. מבנה הרשימה התואם הוא XrSpatialComponentObjectSemanticLabelListANDROID. מבנה הנתונים התואם הוא XrSpatialObjectSemanticLabelANDROID (נוסף על ידי התוסף XR_ANDROID_spatial_object_tracking)

XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID

רכיב שמספק את התנוחה של פגיעת raycast בישות. מבנה הרשימה התואם הוא XrSpatialComponentRaycastResultListANDROID; מבנה הנתונים התואם הוא XrSpatialRaycastResultDataANDROID (נוסף על ידי התוסף XR_ANDROID_spatial_discovery_raycast)

XR_SPATIAL_COMPONENT_TYPE_SUBSUMED_BY_ANDROID

רכיב שמספק את מזהה הישות של הישות שכוללת את הישות המצורפת. מבנה הרשימה התואם הוא XrSpatialComponentSubsumedByListANDROID; מבנה הנתונים התואם הוא XrSpatialEntityIdEXT (נוסף על ידי התוסף XR_ANDROID_spatial_component_subsumed_by)

XR_SPATIAL_COMPONENT_TYPE_ROOM_ANDROIDSYS

רכיב שמספק את המידות ואת סוג החדר של קופסת נעליים. מבנה הרשימה התואם הוא XrSpatialComponentRoomListANDROIDSYS. מבנה הנתונים התואם הוא XrSpatialRoomDataANDROIDSYS (נוסף על ידי התוסף XR_ANDROIDSYS_spatial_room_tracking)

XR_SPATIAL_COMPONENT_TYPE_MATERIAL_TYPE_ANDROIDSYS

רכיב שמספק את סוג החומר של משטח גבול. מבנה הרשימה התואם הוא XrSpatialComponentMaterialTypeListANDROIDSYS. מבנה הנתונים התואם הוא XrSpatialMaterialTypeANDROIDSYS (נוסף על ידי התוסף XR_ANDROIDSYS_spatial_room_tracking)

XR_SPATIAL_COMPONENT_TYPE_CONFIDENCE_ANDROIDSYS

רכיב שמספק את רמת הסמך של רכיב שניתן למעקב. מבנה הרשימה התואם הוא XrSpatialComponentConfidenceListANDROIDSYS, מבנה הנתונים התואם הוא float (נוסף על ידי התוסף XR_ANDROIDSYS_spatial_room_tracking)

XR_SPATIAL_COMPONENT_TYPE_ROOM_EMPTINESS_ANDROIDSYS

רכיב שמספק את הריקנות של חדר. מבנה הרשימה התואם הוא XrSpatialComponentRoomEmptinessListANDROIDSYS. מבנה הנתונים התואם הוא float (נוסף על ידי התוסף XR_ANDROIDSYS_spatial_room_tracking)

XR_SPATIAL_COMPONENT_TYPE_OCCUPANCY_GRID_ANDROIDX1

רכיב שמספק מידע על רשת התפוסה בישות המצורפת. מבנה הרשימה התואם הוא XrSpatialComponentOccupancyGridListANDROIDX1; מבנה הנתונים התואם הוא XrSpatialOccupancyGridDataANDROIDX1 (נוסף על ידי התוסף XR_ANDROIDX1_spatial_occupancy_grid)

XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

רכיב שמתאר הערה מרובעת. מבנה הרשימה התואם הוא XrSpatialComponentAnnotationQuadListANDROID; מבנה הנתונים התואם הוא XrSpatialAnnotationQuadDataANDROID (נוסף על ידי התוסף XR_ANDROID_spatial_annotation_tracking)

XR_SPATIAL_COMPONENT_TYPE_STREETSCAPE_GEOMETRY_METADATA_ANDROIDX2

רכיב שמספק את המטא-נתונים של גיאומטריית Streetscape. מבנה הרשימה התואם הוא XrSpatialComponentStreetscapeGeometryMetadataListANDROIDX2. מבנה הנתונים התואם הוא XrSpatialStreetscapeGeometryMetadataANDROIDX2 (נוסף על ידי התוסף XR_ANDROIDX2_geospatial_streetscape)

XR_SPATIAL_COMPONENT_TYPE_GEOMETRY_POINT_ANDROID

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

XR_SPATIAL_COMPONENT_TYPE_PERSISTENCE_SCOPES_ANDROIDX1

רכיב שמתאר את היקפי השמירה שבהם הישות נשמרת. אם סביבת זמן הריצה תומכת ב-XR_SPATIAL_COMPONENT_TYPE_PERSISTENCE_EXT, היא חייבת לתמוך גם ברכיב הזה. מבנה הנתונים התואם הוא XrSpatialBufferEXT . מבנה הרשימה המתאים הוא XrSpatialComponentPersistenceScopeDataListANDROIDX1 . (נוסף על ידי התוסף XR_ANDROIDX1_spatial_anchor_cloud_sharing)

יכולות מרחביות והגדרה

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

typedef enum XrSpatialCapabilityEXT {
    XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT = 1000741000,
    XR_SPATIAL_CAPABILITY_MARKER_TRACKING_QR_CODE_EXT = 1000743000,
    XR_SPATIAL_CAPABILITY_MARKER_TRACKING_MICRO_QR_CODE_EXT = 1000743001,
    XR_SPATIAL_CAPABILITY_MARKER_TRACKING_ARUCO_MARKER_EXT = 1000743002,
    XR_SPATIAL_CAPABILITY_MARKER_TRACKING_APRIL_TAG_EXT = 1000743003,
    XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_EXT = 1000744000,
    XR_SPATIAL_CAPABILITY_ANCHOR_EXT = 1000762000,
    XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT = 1000782000,
    XR_SPATIAL_CAPABILITY_MESH_TRACKING_EXT = 1000783000,
    XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_ANDROID = 1000785000,
    XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID = 1000786000,
    XR_SPATIAL_CAPABILITY_ROOM_TRACKING_ANDROIDSYS = 1000792000,
    XR_SPATIAL_CAPABILITY_ROOM_BOUNDARY_TRACKING_ANDROIDSYS = 1000792001,
    XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID = 1000794000,
    XR_SPATIAL_CAPABILITY_STREETSCAPE_GEOMETRY_ANDROIDX2 = 1000798000,
    XR_SPATIAL_CAPABILITY_MAX_ENUM_EXT = 0x7FFFFFFF
} XrSpatialCapabilityEXT;

הספירה XrSpatialCapabilityEXT מזהה את סוגי היכולות השונים שזמן הריצה עשוי לתמוך בהם.

הערכים של ה-enumerants הם:

תיאור הטיפוס בן המנייה (enum)

XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT

מעקב אחר טיסות (נוסף על ידי התוסף XR_EXT_spatial_plane_tracking)

XR_SPATIAL_CAPABILITY_MARKER_TRACKING_QR_CODE_EXT

יכולת לזהות קודי QR ולעקוב אחריהם. (נוסף על ידי התוסף XR_EXT_spatial_marker_tracking)

XR_SPATIAL_CAPABILITY_MARKER_TRACKING_MICRO_QR_CODE_EXT

יכולת לזהות ולעקוב אחרי קודי Micro QR. (נוסף על ידי התוסף XR_EXT_spatial_marker_tracking)

XR_SPATIAL_CAPABILITY_MARKER_TRACKING_ARUCO_MARKER_EXT

יכולת לזהות ולעקוב אחרי סמני Aruco. (נוסף על ידי התוסף XR_EXT_spatial_marker_tracking)

XR_SPATIAL_CAPABILITY_MARKER_TRACKING_APRIL_TAG_EXT

יכולת לזהות ולעקוב אחרי AprilTags. (נוסף על ידי התוסף XR_EXT_spatial_marker_tracking)

XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_EXT

מעקב אחר אובייקטים (נוסף על ידי התוסף XR_EXT_spatial_object_tracking)

XR_SPATIAL_CAPABILITY_ANCHOR_EXT

יכולת ליצור עוגנים מרחביים (נוספה על ידי התוסף XR_EXT_spatial_anchor)

XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT

יכולת לזהות ולעקוב אחרי תמונות רפרנס מישוריות. (נוסף על ידי התוסף XR_EXT_spatial_image_tracking)

XR_SPATIAL_CAPABILITY_MESH_TRACKING_EXT

יכולת לעקוב אחרי הרשת של הסביבה. (נוסף על ידי התוסף XR_EXT_spatial_mesh_tracking)

XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_ANDROID

מעקב אחר אובייקטים (נוסף על ידי התוסף XR_ANDROID_spatial_object_tracking)

XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID

Raycast against depth buffer (Added by the XR_ANDROID_spatial_discovery_raycast extension)

XR_SPATIAL_CAPABILITY_ROOM_TRACKING_ANDROIDSYS

יכולת לעקוב אחרי חדר (נוספה על ידי התוסף XR_ANDROIDSYS_spatial_room_tracking)

XR_SPATIAL_CAPABILITY_ROOM_BOUNDARY_TRACKING_ANDROIDSYS

יכולת לעקוב אחרי גבולות החדר (נוספה על ידי התוסף XR_ANDROIDSYS_spatial_room_tracking)

XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID

מעקב אחרי הערות (נוסף על ידי התוסף XR_ANDROID_spatial_annotation_tracking)

XR_SPATIAL_CAPABILITY_STREETSCAPE_GEOMETRY_ANDROIDX2

גיאומטריה של נוף הרחוב (נוספה על ידי התוסף XR_ANDROIDX2_geospatial_streetscape)

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

XrResult xrEnumerateSpatialCapabilitiesEXT(
    XrInstance                                  instance,
    XrSystemId                                  systemId,
    uint32_t                                    capabilityCapacityInput,
    uint32_t*                                   capabilityCountOutput,
    XrSpatialCapabilityEXT*                     capabilities);

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

  • ‫instance הוא כינוי ל-XrInstance .
  • ‫systemId הוא ה-XrSystemId שהיכולות המרחביות שלו יפורטו.
  • ‫capabilityCapacityInput הוא הקיבולת של המערך capabilities, או 0 כדי לציין בקשה לאחזור הקיבולת הנדרשת.
  • ‫capabilityCountOutput הוא מספר היכולות, או הקיבולת הנדרשת במקרה ש-capabilityCapacityInput לא מספיק.
  • ‫capabilities הוא מערך של XrSpatialCapabilityEXT . הערך של NULL יכול להיות capabilityCapacityInput אם הוא 0.
  • בקטע פרמטרים של שטח אחסון זמני יש תיאור מפורט של אחזור הגודל הנדרש של capabilities.

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

סביבת זמן הריצה לא יכולה למנות את היכולות המרחביות שהתוסף שלהן לא מופעל עבור instance .

שימוש תקין (משתמע)

  • חובה להפעיל את התוסף XR_EXT_spatial_entity לפני שקוראים ל-xrEnumerateSpatialCapabilitiesEXT
  • ‫ instance חייב להיות כינוי תקין של XrInstance
  • capabilityCountOutput חייב להיות מצביע לערך uint32_t
  • אם capabilityCapacityInput הוא לא 0 , capabilities חייב להיות מצביע למערך של ערכי capabilityCapacityInput XrSpatialCapabilityEXT

קודי החזרה

הצלחה

  • XR_SUCCESS

נכשל

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SIZE_INSUFFICIENT
  • XR_ERROR_SYSTEM_INVALID
  • XR_ERROR_VALIDATION_FAILURE

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

XrResult xrEnumerateSpatialCapabilityComponentTypesEXT(
    XrInstance                                  instance,
    XrSystemId                                  systemId,
    XrSpatialCapabilityEXT                      capability,
    XrSpatialCapabilityComponentTypesEXT*       capabilityComponents);

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

  • ‫instance הוא כינוי ל-XrInstance .
  • ‫systemId הוא ה-XrSystemId שרכיבי היכולת המרחבית שלו יפורטו.
  • ‫capability הוא ה-XrSpatialCapabilityEXT שעבורו הרכיבים ימוספרו.
  • ‫capabilityComponents הוא מצביע ל-XrSpatialCapabilityComponentTypesEXT , שהוא מבנה קלט/פלט שבו מאוכלס מערך שהוקצה לאפליקציה.

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

האפליקציה יכולה להשתמש בסוגי הרכיבים שמפורטים ב-XrSpatialCapabilityComponentTypesEXT :: componentTypes כדי להבין את קבוצת הרכיבים המלאה ש-systemId תומך בהם עבור capability, ויכולה להשתמש ברשימה הזו כדי לקבוע מהי הגדרה תקינה של capability כשיוצרים בשבילו XrSpatialContextEXT.

זמן הריצה חייב להחזיר את הערך XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT אם capability לא מופיע ברשימה של xrEnumerateSpatialCapabilitiesEXT .

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

שימוש תקין (משתמע)

קודי החזרה

הצלחה

  • XR_SUCCESS

נכשל

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SIZE_INSUFFICIENT
  • XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT
  • XR_ERROR_SYSTEM_INVALID
  • XR_ERROR_VALIDATION_FAILURE

המבנה של XrSpatialCapabilityComponentTypesEXT מוגדר כך:

typedef struct XrSpatialCapabilityComponentTypesEXT {
    XrStructureType               type;
    void*                         next;
    uint32_t                      componentTypeCapacityInput;
    uint32_t                      componentTypeCountOutput;
    XrSpatialComponentTypeEXT*    componentTypes;
} XrSpatialCapabilityComponentTypesEXT;

תיאורי חברים

  • ‫type הוא ה-XrStructureType של המבנה הזה.
  • ‫next הוא NULL או מצביע למבנה הבא בשרשרת מבנים. מבנים כאלה לא מוגדרים ב-OpenXR או בתוסף הזה.
  • ‫componentTypeCapacityInput הוא הקיבולת של המערך, או 0 כדי לציין בקשה לאחזור הקיבולת הנדרשת.
  • ‫componentTypeCountOutput הוא מספר סוגי הרכיבים, או הקיבולת הנדרשת במקרה ש-componentTypeCapacityInput לא מספיק.
  • ‫componentTypes הוא מערך של XrSpatialComponentTypeEXT . הערך של NULL יכול להיות componentTypeCapacityInput אם הוא 0.
  • בקטע פרמטרים של שטח אחסון זמני יש תיאור מפורט של אחזור הגודל הנדרש של componentTypes.

שימוש תקין (משתמע)

תכונות של יכולות מרחביות

typedef enum XrSpatialCapabilityFeatureEXT {
    XR_SPATIAL_CAPABILITY_FEATURE_MARKER_TRACKING_FIXED_SIZE_MARKERS_EXT = 1000743000,
    XR_SPATIAL_CAPABILITY_FEATURE_MARKER_TRACKING_STATIC_MARKERS_EXT = 1000743001,
    XR_SPATIAL_CAPABILITY_FEATURE_OBJECT_SEMANTIC_LABEL_SUBSET_EXT = 1000744000,
    XR_SPATIAL_CAPABILITY_FEATURE_SPHERE_BOUNDS_FILTER_ANDROID = 1000761000,
    XR_SPATIAL_CAPABILITY_FEATURE_BOX_BOUNDS_FILTER_ANDROID = 1000761001,
    XR_SPATIAL_CAPABILITY_FEATURE_FRUSTUM_BOUNDS_FILTER_ANDROID = 1000761002,
    XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_AUTOMATIC_SIZE_IMAGES_EXT = 1000782000,
    XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_STATIC_IMAGES_EXT = 1000782001,
    XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_FIXED_SIZE_IMAGES_EXT = 1000782002,
    XR_SPATIAL_CAPABILITY_FEATURE_TRACK_WATERTIGHT_MESH_EXT = 1000783000,
    XR_SPATIAL_CAPABILITY_FEATURE_MAX_ENUM_EXT = 0x7FFFFFFF
} XrSpatialCapabilityFeatureEXT;

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

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

התכונות האלה מיוצגות על ידי XrSpatialCapabilityFeatureEXT והאפליקציה מונה אותן באמצעות xrEnumerateSpatialCapabilityFeaturesEXT .

לכל תכונה של יכולת יש מבנה הגדרה תואם שמאפשר להפעיל אותה. מבני הגדרות כאלה חייבים להיות משורשרים אל XrSpatialCapabilityConfigurationBaseHeaderEXT :: next של היכולת המתאימה.

הערכים של ה-enumerants הם:

תיאור הטיפוס בן המנייה (enum)

XR_SPATIAL_CAPABILITY_FEATURE_MARKER_TRACKING_FIXED_SIZE_MARKERS_EXT

תכונה שמאפשרת לאפליקציות לציין את גודל הסמנים. מבנה ההגדרה התואם הוא XrSpatialMarkerSizeEXT (נוסף על ידי התוסף XR_EXT_spatial_marker_tracking)

XR_SPATIAL_CAPABILITY_FEATURE_MARKER_TRACKING_STATIC_MARKERS_EXT

תכונה שמאפשרת לאפליקציות לציין אם הסמנים סטטיים. מבנה ההגדרה התואם הוא XrSpatialMarkerStaticOptimizationEXT (נוסף על ידי התוסף XR_EXT_spatial_marker_tracking)

XR_SPATIAL_CAPABILITY_FEATURE_OBJECT_SEMANTIC_LABEL_SUBSET_EXT

תכונה מרחבית שמאפשרת לאפליקציות לציין קבוצת משנה של תוויות מ-XrSpatialObjectSemanticLabelEXT כדי שזמן הריצה יעקוב אחריהן. מבנה ההגדרות התואם הוא XrSpatialFeatureObjectSemanticLabelSubsetEXT . (נוסף על ידי התוסף XR_EXT_spatial_object_tracking)

XR_SPATIAL_CAPABILITY_FEATURE_SPHERE_BOUNDS_FILTER_ANDROID

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

XR_SPATIAL_CAPABILITY_FEATURE_BOX_BOUNDS_FILTER_ANDROID

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

XR_SPATIAL_CAPABILITY_FEATURE_FRUSTUM_BOUNDS_FILTER_ANDROID

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

XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_AUTOMATIC_SIZE_IMAGES_EXT

סביבת זמן הריצה תומכת בהסקה אוטומטית של הגודל הפיזי של תמונות שזוהו ונוספו למעקב. מבנה ההגדרה התואם הוא XrSpatialImageSizeEXT (נוסף על ידי התוסף XR_EXT_spatial_image_tracking)

XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_STATIC_IMAGES_EXT

סביבת זמן הריצה תומכת ב-XrSpatialImageStaticOptimizationEXT . מבנה ההגדרה התואם הוא XrSpatialImageStaticOptimizationEXT . (נוסף על ידי התוסף XR_EXT_spatial_image_tracking)

XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_FIXED_SIZE_IMAGES_EXT

סביבת זמן הריצה תומכת ב-XrSpatialImageSizeEXT . מבנה ההגדרה התואם הוא XrSpatialImageSizeEXT (נוסף על ידי התוסף XR_EXT_spatial_image_tracking)

XR_SPATIAL_CAPABILITY_FEATURE_TRACK_WATERTIGHT_MESH_EXT

תכונה שמאפשרת לעקוב אחרי רשת אטומה של הסביבה. מבנה ההגדרה התואם הוא XrSpatialFeatureTrackWatertightMeshEXT . (נוסף על ידי התוסף XR_EXT_spatial_mesh_tracking)

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

XrResult xrEnumerateSpatialCapabilityFeaturesEXT(
    XrInstance                                  instance,
    XrSystemId                                  systemId,
    XrSpatialCapabilityEXT                      capability,
    uint32_t                                    capabilityFeatureCapacityInput,
    uint32_t*                                   capabilityFeatureCountOutput,
    XrSpatialCapabilityFeatureEXT*              capabilityFeatures);

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

  • ‫instance הוא כינוי ל-XrInstance .
  • ‫systemId הוא ה-XrSystemId שתכונות היכולת המרחבית שלו יפורטו.
  • ‫capability הוא XrSpatialCapabilityEXT שעבורו התכונות יפורטו.
  • ‫capabilityFeatureCapacityInput הוא הקיבולת של המערך, או 0 כדי לציין בקשה לאחזור הקיבולת הנדרשת.
  • ‫capabilityFeatureCountOutput הוא מספר התכונות, או הקיבולת הנדרשת במקרה ש-capabilityFeatureCapacityInput לא מספיק.
  • ‫capabilityFeatures הוא מערך של XrSpatialCapabilityFeatureEXT . הערך של NULL יכול להיות capabilityFeatureCapacityInput אם הוא 0.
  • בקטע פרמטרים של שטח אחסון זמני יש תיאור מפורט של אחזור הגודל הנדרש של capabilityFeatures.

האפליקציה מזהה את התכונות שנתמכות על ידי מערכת נתונה עבור XrSpatialCapabilityEXT באמצעות xrEnumerateSpatialCapabilityFeaturesEXT .

ביכולות שכוללות תכונות חשופות, האפליקציה בוחרת את התכונה או התכונות שצריך להפעיל ומספקת את מבנה ההגדרות התואם בשרשרת הבאה של מבני הגדרות היכולות ב-XrSpatialContextCreateInfoEXT :: capabilityConfigs .

אם capability היא לא יכולת שמופיעה ברשימה של xrEnumerateSpatialCapabilitiesEXT , זמן הריצה חייב להחזיר את הערך XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT .

סביבת זמן הריצה לא יכולה למנות את התכונות של יכולות המרחב שהתוסף שלהן לא מופעל ב-instance .

שימוש תקין (משתמע)

  • ‫ חובה להפעיל את התוסף XR_EXT_spatial_entity לפני שמפעילים את xrEnumerateSpatialCapabilityFeaturesEXT
  • ‫ instance חייב להיות כינוי תקין של XrInstance
  • capability חייב להיות ערך XrSpatialCapabilityEXT תקין
  • capabilityFeatureCountOutput חייב להיות מצביע לערך uint32_t
  • אם capabilityFeatureCapacityInput הוא לא 0 , capabilityFeatures חייב להיות מצביע למערך של ערכי capabilityFeatureCapacityInput XrSpatialCapabilityFeatureEXT

קודי החזרה

הצלחה

  • XR_SUCCESS

נכשל

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SIZE_INSUFFICIENT
  • XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT
  • XR_ERROR_SYSTEM_INVALID
  • XR_ERROR_VALIDATION_FAILURE

הקשר מרחבי

יצירת הקשר מרחבי

XR_DEFINE_HANDLE(XrSpatialContextEXT)

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

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

XrResult xrCreateSpatialContextAsyncEXT(
    XrSession                                   session,
    const XrSpatialContextCreateInfoEXT*        createInfo,
    XrFutureEXT*                                future);

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

  • ‫session הוא XrSession שבו ההקשר המרחבי יהיה פעיל.
  • ‫createInfo הוא XrSpatialContextCreateInfoEXT שמשמש לציון הפרמטרים של ההקשר המרחבי.
  • ‫future הוא מצביע ל-XrFutureEXT .

האפליקציה יכולה ליצור נקודת אחיזה (handle) מסוג XrSpatialContextEXT באמצעות:

זמן הריצה חייב להחזיר את הערך XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT אם הערך של XrSpatialContextCreateInfoEXT ::capabilityConfigCount הוא 0. למזהה של הקשר מרחבי צריכה להיות לפחות יכולת אחת.

זמן הריצה חייב להחזיר את הערך XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT אם יכולת כלשהי במערך XrSpatialContextCreateInfoEXT :: capabilityConfigs לא נספרת על ידי xrEnumerateSpatialCapabilitiesEXT .

זמן הריצה חייב להחזיר את הערך XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT אם הערך של XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponentCount ב-XrSpatialContextCreateInfoEXT :: capabilityConfigs הוא 0. הגדרת יכולת לא תהיה שלמה בלי רשימה של סוגי רכיבים שצריך להפעיל בשביל היכולת הזו.

זמן הריצה חייב להחזיר את הערך XR_ERROR_SPATIAL_COMPONENT_UNSUPPORTED_FOR_CAPABILITY_EXT אם סוג רכיב כלשהו שמופיע ב-XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents לא מופיע ב-XrSpatialCapabilityConfigurationBaseHeaderEXT :: capability ב-xrEnumerateSpatialCapabilityComponentTypesEXT .

אם אחד מהמבנים בשרשרת הבאה של XrSpatialContextCreateInfoEXT :: capabilityConfigs תואם ל-XrSpatialCapabilityFeatureEXT שלא מופיע ברשימה של היכולת הזו ב-xrEnumerateSpatialCapabilityFeaturesEXT , זמן הריצה חייב להתעלם מהמבנה הזה של XrSpatialCapabilityFeatureEXT.

זמן הריצה חייב להחזיר את הערך XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT אם XrSpatialContextCreateInfoEXT :: capabilityConfigs מכיל כמה מבנים עם אותו XrSpatialCapabilityConfigurationBaseHeaderEXT :: capability .

כדי להבטיח שימוש אופטימלי במשאבי המערכת, יכול להיות שזמן הריצה ישתמש בהגדרות שסופקו במערך XrSpatialContextCreateInfoEXT כדי להכין את עצמו לבקשות מרחביות שיגיעו. לדוגמה, סביבת זמן ריצה שתומכת ביכולת מעקב אחר מישור עשויה להתחיל את צינור עיבוד הנתונים של מעקב אחר מישור רק אם האפליקציה יוצרת נקודת אחיזה של הקשר מרחבי שמכילה את יכולת המעקב אחר מישור. אם ליכולות שהוגדרו יש זמן חימום ארוך, קריאות ל-xrCreateSpatialDiscoverySnapshotAsyncEXT עשויות להוביל לתמונת מצב ריקה. האפליקציה יכולה להמתין ל-XrEventDataSpatialDiscoveryRecommendedEXT לפני השימוש ב-xrCreateSpatialDiscoverySnapshotAsyncEXT כדי לוודא ששירותי המעקב הבסיסיים הופעלו.

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

הפונקציה הזו מתחילה פעולה אסינכרונית ויוצרת XrFutureEXT תואם, שאפשר להשתמש בו עם xrPollFutureEXT ופונקציות קשורות. ערך ההחזרה של הפונקציה הזו מציין רק אם הפרמטרים היו קבילים לתזמון הפעולה האסינכרונית. פונקציית ההשלמה המתאימה היא xrCreateSpatialContextCompleteEXT , ואפשר להשתמש בה כשהעתיד מהפונקציה הזו נמצא במצב READY, עם פלטים שאוכלסו על ידי הפונקציה הזו במבנה ההשלמה XrCreateSpatialContextCompletionEXT .

שימוש תקין (משתמע)

  • חובה להפעיל את התוסף XR_EXT_spatial_entity לפני שקוראים ל-xrCreateSpatialContextAsyncEXT
  • ‫ session חייב להיות כינוי תקין של XrSession
  • ‫ createInfo חייב להיות מצביע למבנה XrSpatialContextCreateInfoEXT תקין
  • ‫ future חייב להיות מצביע לערך XrFutureEXT

קודי החזרה

הצלחה

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

נכשל

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_LIMIT_REACHED
  • XR_ERROR_OUT_OF_MEMORY
  • XR_ERROR_PERMISSION_INSUFFICIENT
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT
  • XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT
  • XR_ERROR_SPATIAL_COMPONENT_UNSUPPORTED_FOR_CAPABILITY_EXT
  • XR_ERROR_VALIDATION_FAILURE
  • ‫XR_ERROR_TIME_INVALID (אם XR_ANDROID_spatial_annotation_tracking מופעל)

המבנה של XrSpatialContextCreateInfoEXT מוגדר כך:

typedef struct XrSpatialContextCreateInfoEXT {
    XrStructureType                                                type;
    const void*                                                    next;
    uint32_t                                                       capabilityConfigCount;
    const XrSpatialCapabilityConfigurationBaseHeaderEXT* const*    capabilityConfigs;
} XrSpatialContextCreateInfoEXT;

תיאורי חברים

  • ‫type הוא ה-XrStructureType של המבנה הזה.
  • ‫next הוא NULL או מצביע למבנה הבא בשרשרת מבנים. מבנים כאלה לא מוגדרים ב-OpenXR או בתוסף הזה.
  • ‫capabilityConfigCount הוא uint32_t שמתאר את מספר הרכיבים במערך capabilityConfigs.
  • ‫capabilityConfigs הוא מצביע למערך של מצביעי XrSpatialCapabilityConfigurationBaseHeaderEXT.

המבנה XrSpatialContextCreateInfoEXT מתאר את המידע ליצירת נקודת אחיזה (handle) של XrSpatialContextEXT.

שימוש תקין (משתמע)

המבנה של XrSpatialCapabilityConfigurationBaseHeaderEXT מוגדר כך:

typedef struct XrSpatialCapabilityConfigurationBaseHeaderEXT {
    XrStructureType                     type;
    const void*                         next;
    XrSpatialCapabilityEXT              capability;
    uint32_t                            enabledComponentCount;
    const XrSpatialComponentTypeEXT*    enabledComponents;
} XrSpatialCapabilityConfigurationBaseHeaderEXT;

המבנה הזה לא משמש ישירות ב-API, אבל אפשר להשתמש במבני הצאצא שלו עם XrSpatialContextCreateInfoEXT כדי להגדיר יכולות מרחביות.

תיאורי חברים

  • ‫type הוא ה-XrStructureType של המבנה הזה.
  • ‫next הוא NULL או מצביע למבנה הבא בשרשרת מבנים.
  • capability הוא XrSpatialCapabilityEXT .
  • ‫enabledComponentCount הוא uint32_t שמתאר את מספר הרכיבים במערך enabledComponents.
  • ‫enabledComponents הוא מצביע למערך של XrSpatialComponentTypeEXT .

זמן הריצה חייב להחזיר את הערך XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT אם capability לא מופיע ברשימה של xrEnumerateSpatialCapabilitiesEXT . זמן הריצה חייב להחזיר את הערך XR_ERROR_SPATIAL_COMPONENT_UNSUPPORTED_FOR_CAPABILITY_EXT אם סוג רכיב כלשהו שמופיע ב-enabledComponents לא נספר עבור capability ב-xrEnumerateSpatialCapabilityComponentTypesEXT .

שימוש תקין (משתמע)

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

XrResult xrCreateSpatialContextCompleteEXT(
    XrSession                                   session,
    XrFutureEXT                                 future,
    XrCreateSpatialContextCompletionEXT*        completion);

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

הפונקציה xrCreateSpatialContextCompleteEXT משלימה את הפעולה האסינכרונית שהתחילה על ידי xrCreateSpatialContextAsyncEXT . זמן הריצה חייב להחזיר את הערך XR_ERROR_FUTURE_PENDING_EXT אם future לא במצב מוכן. זמן הריצה חייב להחזיר את הערך XR_ERROR_FUTURE_INVALID_EXT אם הפעולה future כבר הושלמה או בוטלה.

שימוש תקין (משתמע)

קודי החזרה

הצלחה

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

נכשל

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_FUTURE_INVALID_EXT
  • XR_ERROR_FUTURE_PENDING_EXT
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_LIMIT_REACHED
  • XR_ERROR_OUT_OF_MEMORY
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_VALIDATION_FAILURE

המבנה של XrCreateSpatialContextCompletionEXT מוגדר כך:

typedef struct XrCreateSpatialContextCompletionEXT {
    XrStructureType        type;
    void*                  next;
    XrResult               futureResult;
    XrSpatialContextEXT    spatialContext;
} XrCreateSpatialContextCompletionEXT;

תיאורי חברים

  • ‫type הוא ה-XrStructureType של המבנה הזה.
  • ‫next הוא NULL או מצביע למבנה הבא בשרשרת מבנים.
  • ‫futureResult הוא ה-XrResult של פעולת היצירה של ההקשר המרחבי.
  • spatialContext הוא XrSpatialContextEXT שנוצר באמצעות הנתונים וההגדרות ב-xrCreateSpatialContextAsyncEXT :: createInfo .

קודי החזרה עתידיים

ערכי futureResult:

הצלחה

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

נכשל

  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_OUT_OF_MEMORY
  • XR_ERROR_LIMIT_REACHED
  • XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT

אם futureResult הוא קוד הצלחה, spatialContext חייב להיות תקין. אם spatialContext תקין, הוא נשאר תקין רק במהלך מחזור החיים של xrCreateSpatialContextAsyncEXT :: session או עד שהאפליקציה משמידה את spatialContext באמצעות xrDestroySpatialContextEXT , המוקדם מביניהם.

שימוש תקין (משתמע)

הורסים את ההקשר המרחבי

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

XrResult xrDestroySpatialContextEXT(
    XrSpatialContextEXT                         spatialContext);

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

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

שימוש תקין (משתמע)

Thread Safety

  • הגישה אל spatialContext , ואל כל נקודות האחיזה הצאצאות, חייבת להיות מסונכרנת באופן חיצוני

קודי החזרה

הצלחה

  • XR_SUCCESS

נכשל

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_RUNTIME_FAILURE

ייצוגים של ישויות מרחביות

מזהה ישות מרחבית

XR_DEFINE_ATOM(XrSpatialEntityIdEXT)

התג XrSpatialEntityIdEXT מייצג כל סוג של ישות שזוהתה על ידי סביבת זמן הריצה בסביבה המרחבית של המשתמש. ‫XrSpatialEntityIdEXT תקף ל-XrSpatialContextEXT שבו הוא מתגלה, וזמן הריצה לא יכול לעשות שימוש חוזר באותו XrSpatialEntityIdEXT לישויות שונות באותו XrSpatialContextEXT . בנוסף, אסור לסביבת זמן הריצה להשתמש שוב באותו XrSpatialEntityIdEXT בכמה XrSpatialContextEXT באותו XrSession, גם אם הוא מייצג את אותה ישות וגם אם הוא מייצג ישויות שונות.

#define XR_NULL_SPATIAL_ENTITY_ID_EXT 0

XR_NULL_SPATIAL_ENTITY_ID_EXT הוא ערך שמור שמייצג XrSpatialEntityIdEXT לא חוקי. אפשר להעביר אותו לפונקציות API ולקבל אותו מהן רק אם זה מותר באופן ספציפי.

נקודת אחיזה של ישות מרחבית

XR_DEFINE_HANDLE(XrSpatialEntityEXT)

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

יצירת נקודת אחיזה של ישות מרחבית ממזהה

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

XrResult xrCreateSpatialEntityFromIdEXT(
    XrSpatialContextEXT                         spatialContext,
    const XrSpatialEntityFromIdCreateInfoEXT*   createInfo,
    XrSpatialEntityEXT*                         spatialEntity);

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

האפליקציה יכולה להשתמש ב-xrCreateSpatialEntityFromIdEXT כדי ליצור נקודת אחיזה (handle) מסוג XrSpatialEntityEXT, שהיא הפניה לישות שקיימת בסביבה של המשתמש.

זמן הריצה חייב להחזיר את הערך XR_ERROR_SPATIAL_ENTITY_ID_INVALID_EXT אם XrSpatialEntityFromIdCreateInfoEXT :: entityId הוא לא מזהה תקין של spatialContext .

שימוש תקין (משתמע)

קודי החזרה

הצלחה

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

נכשל

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

המבנה של XrSpatialEntityFromIdCreateInfoEXT מוגדר כך:

typedef struct XrSpatialEntityFromIdCreateInfoEXT {
    XrStructureType         type;
    const void*             next;
    XrSpatialEntityIdEXT    entityId;
} XrSpatialEntityFromIdCreateInfoEXT;

תיאורי חברים

  • ‫type הוא ה-XrStructureType של המבנה הזה.
  • ‫next הוא NULL או מצביע למבנה הבא בשרשרת מבנים. מבנים כאלה לא מוגדרים ב-OpenXR או בתוסף הזה.
  • ‫entityId הוא ה-XrSpatialEntityIdEXT של הישות שהאפליקציה רוצה ליצור לה כינוי.

שימוש תקין (משתמע)

השמדת נקודת האחיזה של הישות המרחבית

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

XrResult xrDestroySpatialEntityEXT(
    XrSpatialEntityEXT                          spatialEntity);

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

האפליקציה יכולה להשתמש ב-xrDestroySpatialEntityEXT כדי לשחרר את נקודת האחיזה spatialEntity כשהיא כבר לא מעוניינת בישות שאליה מפנה נקודת האחיזה הזו.

שימוש תקין (משתמע)

Thread Safety

  • הגישה אל spatialEntity , ואל כל נקודות האחיזה הצאצאות, חייבת להיות מסונכרנת באופן חיצוני

קודי החזרה

הצלחה

  • XR_SUCCESS

נכשל

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_RUNTIME_FAILURE

תמונת מצב מרחבית

XR_DEFINE_HANDLE(XrSpatialSnapshotEXT)

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

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

יצירת תמונת מצב של הגילוי

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

XrResult xrCreateSpatialDiscoverySnapshotAsyncEXT(
    XrSpatialContextEXT                         spatialContext,
    const XrSpatialDiscoverySnapshotCreateInfoEXT* createInfo,
    XrFutureEXT*                                future);

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

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

הפונקציה הזו מתחילה פעולה אסינכרונית ויוצרת XrFutureEXT תואם, שאפשר להשתמש בו עם xrPollFutureEXT ופונקציות קשורות. ערך ההחזרה של הפונקציה הזו מציין רק אם הפרמטרים היו קבילים לתזמון הפעולה האסינכרונית. פונקציית ההשלמה המתאימה היא xrCreateSpatialDiscoverySnapshotCompleteEXT , ואפשר להשתמש בה כש-future מהפונקציה הזו נמצא במצב READY, עם פלטים שמאוכלסים על ידי הפונקציה הזו במבנה ההשלמה XrCreateSpatialDiscoverySnapshotCompletionEXT .

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

האפליקציה יכולה להשתמש ב-XrSpatialDiscoverySnapshotCreateInfoEXT :: componentTypes כדי לסנן את רשימת הישויות והרכיבים שהנתונים שלהם חייבים להיכלל בתמונת המצב של זמן הריצה. אם האפליקציה מספקת רשימה תקינה של סוגי רכיבים מרחביים ב-XrSpatialDiscoverySnapshotCreateInfoEXT :: componentTypes , אז זמן הריצה חייב לכלול בתמונת המצב רק ישויות מרחביות שיש להן לפחות אחד מהרכיבים שסופקו ב-XrSpatialDiscoverySnapshotCreateInfoEXT :: componentTypes . בנוסף, זמן הריצה חייב לכלול רק נתונים של הרכיבים האלה בתמונת המצב.

זמן הריצה חייב להחזיר את הערך XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT אם אחד מהערכים של XrSpatialComponentTypeEXT ב-XrSpatialDiscoverySnapshotCreateInfoEXT :: componentTypes לא מופעל ליכולות המרחביות שהועברו אל XrSpatialContextCreateInfoEXT :: capabilityConfigs בזמן היצירה של spatialContext .

אם האפליקציה לא מספקת רשימה של סוגי רכיבים מרחביים ב-XrSpatialDiscoverySnapshotCreateInfoEXT :: componentTypes , זמן הריצה חייב לכלול את כל הישויות המרחביות בתמונת המצב שיש להן את קבוצת הרכיבים שמפורטים ב-XrSpatialCapabilityConfigurationBaseHeaderEXT ::enabledComponents עבור היכולות שהוגדרו ל-spatialContext . זמן הריצה חייב לכלול את הנתונים של כל הרכיבים המופעלים של היכולות שהוגדרו עבור spatialContext .

אם XrEventDataReferenceSpaceChangePending נמצא בתור לפני השלמת future , ו-XrEventDataReferenceSpaceChangePending :: poseValid הוא False, אז זמן הריצה עשוי ליצור XrSpatialSnapshotEXT שאין בו ישויות או להגדיר את XrSpatialEntityTrackingStateEXT של הישויות שכבר לא ניתן לאתר ב-XrCreateSpatialDiscoverySnapshotCompletionInfoEXT :: baseSpace ב-XrCreateSpatialDiscoverySnapshotCompletionInfoEXT :: time ל-XR_SPATIAL_ENTITY_TRACKING_STATE_PAUSED_EXT או ל-XR_SPATIAL_ENTITY_TRACKING_STATE_STOPPED_EXT . בזמן הריצה אסור להגדיר את XrCreateSpatialContextCompletionEXT :: futureResult לקוד שגיאה בגלל XrEventDataReferenceSpaceChangePending .

שימוש תקין (משתמע)

קודי החזרה

הצלחה

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

נכשל

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

המבנה של XrSpatialDiscoverySnapshotCreateInfoEXT מוגדר כך:

typedef struct XrSpatialDiscoverySnapshotCreateInfoEXT {
    XrStructureType                     type;
    const void*                         next;
    uint32_t                            componentTypeCount;
    const XrSpatialComponentTypeEXT*    componentTypes;
} XrSpatialDiscoverySnapshotCreateInfoEXT;

תיאורי חברים

  • ‫type הוא ה-XrStructureType של המבנה הזה.
  • ‫next הוא NULL או מצביע למבנה הבא בשרשרת מבנים. מבנים כאלה לא מוגדרים ב-OpenXR או בתוסף הזה.
  • ‫componentTypeCount הוא uint32_t שמתאר את מספר הרכיבים במערך componentTypes.
  • ‫componentTypes הוא מערך של XrSpatialComponentTypeEXT .

המבנה XrSpatialDiscoverySnapshotCreateInfoEXT מתאר את המידע ליצירת נקודת אחיזה (handle) מסוג XrSpatialSnapshotEXT כשמגלים ישויות מרחביות.

שימוש תקין (משתמע)

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

XrResult xrCreateSpatialDiscoverySnapshotCompleteEXT(
    XrSpatialContextEXT                         spatialContext,
    const XrCreateSpatialDiscoverySnapshotCompletionInfoEXT* createSnapshotCompletionInfo,
    XrCreateSpatialDiscoverySnapshotCompletionEXT* completion);

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

הפונקציה xrCreateSpatialDiscoverySnapshotCompleteEXT משלימה את הפעולה האסינכרונית שהתחילה על ידי xrCreateSpatialDiscoverySnapshotAsyncEXT . זמן הריצה חייב להחזיר את הערך XR_ERROR_FUTURE_PENDING_EXT אם XrCreateSpatialDiscoverySnapshotCompletionInfoEXT :: future לא במצב מוכן. זמן הריצה חייב להחזיר את הערך XR_ERROR_FUTURE_INVALID_EXT אם הפעולה XrCreateSpatialDiscoverySnapshotCompletionInfoEXT :: future כבר הושלמה או בוטלה.

שימוש תקין (משתמע)

קודי החזרה

הצלחה

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

נכשל

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_FUTURE_INVALID_EXT
  • XR_ERROR_FUTURE_PENDING_EXT
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_LIMIT_REACHED
  • XR_ERROR_OUT_OF_MEMORY
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_TIME_INVALID
  • XR_ERROR_VALIDATION_FAILURE

המבנה של XrCreateSpatialDiscoverySnapshotCompletionInfoEXT מוגדר כך:

typedef struct XrCreateSpatialDiscoverySnapshotCompletionInfoEXT {
    XrStructureType    type;
    const void*        next;
    XrSpace            baseSpace;
    XrTime             time;
    XrFutureEXT        future;
} XrCreateSpatialDiscoverySnapshotCompletionInfoEXT;

תיאורי חברים

המיקומים בנתוני הרכיבים השונים שנכללים בתמונת המצב שנוצרה ייוצגו ב-baseSpace , שנמצא ב-time .

שימוש תקין (משתמע)

המבנה של XrCreateSpatialDiscoverySnapshotCompletionEXT מוגדר כך:

typedef struct XrCreateSpatialDiscoverySnapshotCompletionEXT {
    XrStructureType         type;
    void*                   next;
    XrResult                futureResult;
    XrSpatialSnapshotEXT    snapshot;
} XrCreateSpatialDiscoverySnapshotCompletionEXT;

תיאורי חברים

  • ‫type הוא ה-XrStructureType של המבנה הזה.
  • ‫next הוא NULL או מצביע למבנה הבא בשרשרת מבנים.
  • ‫futureResult הוא ה-XrResult של פעולת היצירה של תמונת המצב של הגילוי המרחבי.
  • ‫snapshot הוא XrSpatialSnapshotEXT שאפשר להשתמש בו כדי לשלוח שאילתות לגבי נתוני הרכיבים של הישויות המרחביות שזוהו.

קודי החזרה עתידיים

ערכי futureResult:

הצלחה

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

נכשל

  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_OUT_OF_MEMORY
  • XR_ERROR_LIMIT_REACHED

שימוש תקין (משתמע)

אירוע של המלצה ב-Discovery

המבנה של XrEventDataSpatialDiscoveryRecommendedEXT מוגדר כך:

typedef struct XrEventDataSpatialDiscoveryRecommendedEXT {
    XrStructureType        type;
    const void*            next;
    XrSpatialContextEXT    spatialContext;
} XrEventDataSpatialDiscoveryRecommendedEXT;

תיאורי חברים

  • ‫type הוא ה-XrStructureType של המבנה הזה.
  • ‫next הוא NULL או מצביע למבנה הבא בשרשרת מבנים.
  • ‫spatialContext הוא XrSpatialContextEXT שזמן הריצה ממליץ לגלות.

האפליקציה יכולה לאחזר את האירוע הזה באמצעות xrPollEvent . כדי להימנע מקריאות מרובות ל-xrCreateSpatialDiscoverySnapshotAsyncEXT לצורך גילוי ישויות מרחביות, האפליקציה יכולה להמתין לאירוע הזה. אם האפליקציה יוצרת כמה תמונות מצב של גילוי עם אותו XrSpatialDiscoverySnapshotCreateInfoEXT בין שני אירועי XrEventDataSpatialDiscoveryRecommendedEXT, יכול להיות שתמונות המצב שנוצרות יכילו את אותן ישויות, ולכן יצירת תמונת המצב ושאילתות הנתונים יהיו מיותרות.

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

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

זמן ריצה עשוי להוסיף לתור אירוע של המלצה לחיפוש בלי להמתין שהאפליקציה תפעיל קודם את xrCreateSpatialDiscoverySnapshotAsyncEXT . לדוגמה, סביבת זמן ריצה עשויה לבסס את ההחלטה להוסיף לתור את אירוע ההמלצה לגילוי על ההגדרה של XrSpatialContextEXT , על ההבנה שלה לגבי הסביבה של המשתמש (גילוי של ישויות חדשות או אובדן של ישויות קיימות), או כדי לרמוז לאפליקציה על קצב מתאים של בקשות גילוי כדי לא להעמיס על משאבי המערכת. יכול להיות שסביבת זמן הריצה לא תכניס את האירוע הזה לתור של XrSpatialContextEXT אם לא יימצאו ישויות בסביבה של המשתמש במהלך כל משך החיים של XrSpatialContextEXT .

זמן הריצה לא יכול להוסיף את האירוע הזה לתור של spatialContext נתון עד שהאפליקציה תשלים את היצירה שלו באמצעות xrCreateSpatialContextCompleteEXT .

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

שימוש תקין (משתמע)

נתוני רכיב השאילתה

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

XrResult xrQuerySpatialComponentDataEXT(
    XrSpatialSnapshotEXT                        snapshot,
    const XrSpatialComponentDataQueryConditionEXT* queryCondition,
    XrSpatialComponentDataQueryResultEXT*       queryResult);

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

האפליקציה יכולה להשתמש ב-xrQuerySpatialComponentDataEXT כדי לשלוח שאילתה על נתוני הרכיבים של הישויות בתמונת המצב, על ידי צירוף מבנה רשימה ל-XrSpatialComponentDataQueryResultEXT :: next שתואם לכל XrSpatialComponentTypeEXT ב-XrSpatialComponentDataQueryConditionEXT :: componentTypes .

אם האפליקציה מצרפת מבנה רשימה אל XrSpatialComponentDataQueryResultEXT :: next שלא תואם לאף אחד מהרכיבים שמופיעים ב-XrSpatialComponentDataQueryConditionEXT :: componentTypes , זמן הריצה חייב להחזיר את XR_ERROR_VALIDATION_FAILURE .

האפליקציה יכולה לבחור לצרף את מבני הרשימה שתואמים רק לקבוצת משנה של רכיבים שרשומים ב-XrSpatialComponentDataQueryConditionEXT :: componentTypes . האפליקציה יכולה לבחור להשמיט את מבני הרשימה לגמרי אם היא רק רוצה לדעת את המזהים ואת מצב המעקב של הישויות המרחביות שעומדות בתנאי של queryCondition . סביבת זמן הריצה לא צריכה להתייחס להיעדר מבני רשימה מהשרשרת XrSpatialComponentDataQueryResultEXT :: next ככשל.

אם XrEventDataReferenceSpaceChangePending נמצא בתור ו-XrEventDataReferenceSpaceChangePending :: changeTime חלף בזמן שהאפליקציה שולחת שאילתה לגבי נתוני רכיבים מ-XrSpatialSnapshotEXT , האפליקציה יכולה להשתמש בנתוני האירועים כדי לשנות את התנוחות בהתאם.

זמן הריצה חייב לאכלס את XrSpatialComponentDataQueryResultEXT :: entityIds רק בישויות שכוללות את כל הרכיבים שצוינו ב-XrSpatialComponentDataQueryConditionEXT :: componentTypes . אם הערך של XrSpatialComponentDataQueryConditionEXT :: componentTypeCount הוא 0, זמן הריצה חייב לאכלס את queryResult בכל הישויות (ומצבי המעקב שלהן) שנמצאות בתמונת המצב. אם מוסיפים תנאי שאילתה נוספים ל-XrSpatialComponentDataQueryConditionEXT :: next , זמן הריצה חייב להתייחס אליהם כאל "AND" עם הזמינות של סוגי הרכיבים, כלומר זמן הריצה חייב לאכלס את XrSpatialComponentDataQueryResultEXT ::entityIds רק בישויות שעומדות בכל התנאים שצוינו. זמן הריצה חייב לאכלס את נתוני הרכיבים במבני הרשימה באותו סדר כמו הישויות ב-XrSpatialComponentDataQueryResultEXT :: entityIds, כלומר נתוני הרכיבים באינדקס נתון במערך מבנה הרשימה חייבים להתאים לישות באותו אינדקס.

אם מצב המעקב של ישות הוא לא XR_SPATIAL_ENTITY_TRACKING_STATE_TRACKING_EXT , זמן הריצה לא יכול לשנות את הנתונים באינדקס שתואם לישות הזו במערך שכלול במבני הרשימה שמצורפים ל-XrSpatialComponentDataQueryResultEXT .

שימוש תקין (משתמע)

קודי החזרה

הצלחה

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

נכשל

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_OUT_OF_MEMORY
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_SIZE_INSUFFICIENT
  • XR_ERROR_VALIDATION_FAILURE

לדוגמה, האפליקציה יוצרת XrSpatialSnapshotEXT שמכיל 5 ישויות, כאשר:

  • לישויות 1 ו-2 יש את הרכיבים XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT ו-XR_SPATIAL_COMPONENT_TYPE_PARENT_EXT
  • לישויות 3 ו-4 יש את הרכיבים XR_SPATIAL_COMPONENT_TYPE_BOUNDED_3D_EXT ו-XR_SPATIAL_COMPONENT_TYPE_MESH_3D_EXT
  • ישות 5 כוללת את הרכיבים XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT ו-XR_SPATIAL_COMPONENT_TYPE_MESH_3D_EXT .

XrSpatialEntityIdEXT

XrSpatialEntityIdEXT

1

1

2

2

3

3

4

4

5

5

Bounded2D

Bounded2D

כן

כן

כן

כן

לא

לא

לא

לא

כן

כן

הורה

הורה

כן

כן

כן

כן

לא

לא

לא

לא

לא

לא

Mesh3D

Mesh3D

לא

לא

לא

לא

כן

כן

כן

כן

כן

כן

Bounded3D

Bounded3D

לא

לא

לא

לא

כן

כן

כן

כן

לא

לא הטקסט הוא לא SVG – אי אפשר להציג אותו

איור 20. תמונת מצב לדוגמה

הפונקציה xrQuerySpatialComponentDataEXT בתמונת המצב שלמעלה עם XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT שרשום בתנאי השאילתה תגרום להחזרת ישויות מס' 1, מס' 2 ומס' 5 לאפליקציה, והאפליקציה תוכל לצרף מערך של XrSpatialBounded2DDataEXT כחלק מהמבנה של XrSpatialComponentBounded2DListEXT לשרשרת הבאה של XrSpatialComponentDataQueryResultEXT כדי לקבל את הנתונים של bounded2D.

XrSpatialEntityIdEXT

XrSpatialEntityIdEXT

1

1

2

2

5

5

Bounded2D

Bounded2D

נתונים של entityId מס' 1

נתונים לגבי ישו...

נתונים של entityId מס' 2

נתונים לגבי ישו...

נתונים של entityId מספר 5

נתונים לגבי ישו...

entityIds

entityIds

הבא

הבא

XrSpatialComponent
DataQueryResultEXT

XrSpatialComponent
Dat...

גבולות

גבולות

XrSpatialComponent
Bounded2DListEXT

XrSpatialComponent
Bou... הטקסט הוא לא SVG – אי אפשר להציג אותו

איור 21. תוצאת שאילתה לדוגמה

הפונקציה xrQuerySpatialComponentDataEXT בתמונת המצב שלמעלה עם הרכיבים XR_SPATIAL_COMPONENT_TYPE_BOUNDED_3D_EXT ו-XR_SPATIAL_COMPONENT_TYPE_MESH_3D_EXT שרשומים בתנאי השאילתה תגרום להחזרת ישות מס' 3 ו-4 לאפליקציה, והאפליקציה תוכל לצרף מערכים של XrBoxf ו-XrSpatialMeshDataEXT כחלק מהמבנים XrSpatialComponentBounded3DListEXT ו-XrSpatialComponentMesh3DListEXT בהתאמה לשרשרת הבאה של XrSpatialComponentDataQueryResultEXT כדי לקבל את נתוני הרכיב.

XrSpatialEntityIdEXT

XrSpatialEntityIdEXT

3

3

4

4

Bounded3D

Bounded3D

נתונים של entityId מס' 3

נתונים לגבי ישו...

נתונים של entityId מס' 4

נתונים לגבי ישו...

Mesh3D

Mesh3D

נתונים של entityId מס' 3

נתונים לגבי ישו...

נתונים של entityId מס' 4

נתונים לגבי ישו...

entityIds

entityIds

הבא

הבא

XrSpatialComponent
DataQueryResultEXT

XrSpatialComponent
Da...

גבולות

גבולות

הבא

הבא

XrSpatialComponent
Bounded3DListEXT

XrSpatialComponent
Bo...

XrSpatialComponent
Mesh3DListEXT

XrSpatialComponent
Me...

רשתות Mesh

meshes Text is not SVG - cannot display

איור 22. תוצאת שאילתה לדוגמה

המבנה של XrSpatialComponentDataQueryConditionEXT מוגדר כך:

typedef struct XrSpatialComponentDataQueryConditionEXT {
    XrStructureType                     type;
    const void*                         next;
    uint32_t                            componentTypeCount;
    const XrSpatialComponentTypeEXT*    componentTypes;
} XrSpatialComponentDataQueryConditionEXT;

תיאורי חברים

  • ‫type הוא ה-XrStructureType של המבנה הזה.
  • ‫next הוא NULL או מצביע למבנה הבא בשרשרת מבנים.
  • ‫componentTypeCount הוא uint32_t שמתאר את מספר הרכיבים במערך componentTypes.
  • ‫componentTypes הוא מערך של XrSpatialComponentTypeEXT שממנו אפשר לקבל את הנתונים מתמונת המצב.

שימוש תקין (משתמע)

המבנה של XrSpatialComponentDataQueryResultEXT מוגדר כך:

typedef struct XrSpatialComponentDataQueryResultEXT {
    XrStructureType                     type;
    void*                               next;
    uint32_t                            entityIdCapacityInput;
    uint32_t                            entityIdCountOutput;
    XrSpatialEntityIdEXT*               entityIds;
    uint32_t                            entityStateCapacityInput;
    uint32_t                            entityStateCountOutput;
    XrSpatialEntityTrackingStateEXT*    entityStates;
} XrSpatialComponentDataQueryResultEXT;

תיאורי חברים

  • ‫type הוא ה-XrStructureType של המבנה הזה.
  • ‫next הוא NULL או מצביע למבנה הבא בשרשרת מבנים.
  • ‫entityIdCapacityInput הוא הקיבולת של המערך entityIds, או 0 כדי לציין בקשה לאחזור הקיבולת הנדרשת.
  • ‫entityIdCountOutput הוא מספר ה-XrSpatialEntityIdEXT ב-entityIds , או הקיבולת הנדרשת במקרה ש-entityIdCapacityInput לא מספיק.
  • ‫entityIds הוא מערך של XrSpatialEntityIdEXT . הערך של NULL יכול להיות entityIdCapacityInput אם הוא 0.
  • ‫entityStateCapacityInput הוא הקיבולת של המערך entityStates, או 0 כדי לציין בקשה לאחזור הקיבולת הנדרשת.
  • ‫entityStateCountOutput הוא מספר המופעים של XrSpatialEntityTrackingStateEXT ב-entityStates , או הקיבולת הנדרשת במקרה ש-entityStateCapacityInput לא מספיק. הערך הזה חייב תמיד להיות זהה לערך של entityIdCountOutput .
  • ‫entityStates הוא מערך של XrSpatialEntityTrackingStateEXT . הערך של NULL יכול להיות entityStateCapacityInput אם הוא 0.
  • בקטע פרמטרים של שטח אחסון זמני יש תיאור מפורט של אחזור הגודל הנדרש של entityIds.

אפליקציה יכולה להשתמש ב-entityIds עם xrCreateSpatialEntityFromIdEXT כדי ליצור נקודות אחיזה של XrSpatialEntityEXT לישויות שהיא רוצה לקבל עדכונים שוטפים לגביהן. לאחר מכן, האפליקציה יכולה להשתמש במזהי ה-XrSpatialEntityEXT האלה עם xrCreateSpatialUpdateSnapshotEXT כדי ליצור תמונת מצב של עדכון שמכילה את הנתונים העדכניים ביותר שידועים לסביבת זמן הריצה לגבי הרכיבים של הישויות שסופקו.

שימוש תקין (משתמע)

typedef enum XrSpatialEntityTrackingStateEXT {
    XR_SPATIAL_ENTITY_TRACKING_STATE_STOPPED_EXT = 1,
    XR_SPATIAL_ENTITY_TRACKING_STATE_PAUSED_EXT = 2,
    XR_SPATIAL_ENTITY_TRACKING_STATE_TRACKING_EXT = 3,
    XR_SPATIAL_ENTITY_TRACKING_STATE_MAX_ENUM_EXT = 0x7FFFFFFF
} XrSpatialEntityTrackingStateEXT;

ה-XrSpatialEntityTrackingStateEXT מפרט את מצבי המעקב האפשריים של ישויות מרחביות:

אלה המשמעויות של ה-enums:

תיאור הטיפוס בן המנייה (enum)

XR_SPATIAL_ENTITY_TRACKING_STATE_STOPPED_EXT

זמן הריצה הפסיק לעקוב אחרי הישות הזו ולא ימשיך לעקוב אחריה.

XR_SPATIAL_ENTITY_TRACKING_STATE_PAUSED_EXT

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

XR_SPATIAL_ENTITY_TRACKING_STATE_TRACKING_EXT

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

מעקב

מושהה

הופסקה

איור 23. XrSpatialEntityTrackingStateEXT

  • זמן הריצה עשוי לשנות את המצב של הישות המרחבית מ-XR_SPATIAL_ENTITY_TRACKING_STATE_TRACKING_EXT ל-XR_SPATIAL_ENTITY_TRACKING_STATE_PAUSED_EXT אם הוא משעה את המעקב אחרי הישות המרחבית הזו, אבל יש אפשרות להמשיך את המעקב אחריה בעתיד. דוגמאות למקרים שבהם סביבת זמן הריצה עשויה לעשות זאת כוללות (אך לא מוגבלות למקרים הבאים): אם האפליקציה מאבדת את המיקוד של הקלט, אם הישות המרחבית הנתונה רחוקה מדי מהמשתמש מכדי לעקוב אחריה בצורה מדויקת, או אם יש יותר מדי ישויות במעקב וסביבת זמן הריצה רוצה להפחית את עלות המעקב. האפליקציה יכולה להשתמש ב-XrSpatialEntityTrackingStateEXT כדי לבודד את עצמה ממדיניות המעקב השונה של כל סביבת זמן ריצה.
  • סביבת זמן הריצה עשויה לשנות את הסטטוס של ישות מ-XR_SPATIAL_ENTITY_TRACKING_STATE_PAUSED_EXT ל-XR_SPATIAL_ENTITY_TRACKING_STATE_TRACKING_EXT או ל-XR_SPATIAL_ENTITY_TRACKING_STATE_STOPPED_EXT .
  • סביבת זמן הריצה חייבת לשנות את המצב של הישות המרחבית מ-XR_SPATIAL_ENTITY_TRACKING_STATE_TRACKING_EXT או XR_SPATIAL_ENTITY_TRACKING_STATE_PAUSED_EXT ל-XR_SPATIAL_ENTITY_TRACKING_STATE_STOPPED_EXT אם הישות המרחבית אבדה והמעקב אחריה לא ישוחזר או יתחדש אף פעם. דוגמה למקרה כזה: המכשיר מאבד את המעקב, מפעיל מחדש את סשן המעקב אבל לא מצליח לבצע לוקליזציה מחדש בסביבה שלו, ולכן מתייחס לישויות שזוהו בסשן המעקב הזה כישויות חדשות.
  • אחרי שמצב המעקב של ישות מוגדר כ-XR_SPATIAL_ENTITY_TRACKING_STATE_STOPPED_EXT , זמן הריצה לא יכול לשנות אותו למצב אחר.
  • כששולחים שאילתה לנתוני הרכיבים של ישות מרחבית באמצעות xrQuerySpatialComponentDataEXT , זמן הריצה חייב להגדיר נתונים תקינים בתוכן של מאגרי הנתונים שהאפליקציה מספקת בשרשרת הבאה של XrSpatialComponentDataQueryResultEXT אם מצב הישות הוא XR_SPATIAL_ENTITY_TRACKING_STATE_TRACKING_EXT . אם מצב הישות הוא XR_SPATIAL_ENTITY_TRACKING_STATE_STOPPED_EXT או XR_SPATIAL_ENTITY_TRACKING_STATE_PAUSED_EXT , זמן הריצה לא יכול לשנות את התוכן של המאגרים.

Two-call idiom for component data

המבנה של XrSpatialBufferEXT מוגדר כך:

typedef struct XrSpatialBufferEXT {
    XrSpatialBufferIdEXT      bufferId;
    XrSpatialBufferTypeEXT    bufferType;
} XrSpatialBufferEXT;

תיאורי חברים

  • bufferId את XrSpatialBufferIdEXT של נתוני המאגר.
  • ‫bufferType הוא XrSpatialBufferTypeEXT כדי לציין את סוג הנתונים ב-bufferId . האפליקציה יכולה להשתמש ב-bufferType כדי לקבוע באיזו פונקציה להשתמש כדי לאחזר את הנתונים בפועל של המאגר.

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

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

שימוש תקין (משתמע)

XR_DEFINE_ATOM(XrSpatialBufferIdEXT)

‫XrSpatialBufferIdEXT משמש לייצוג כל סוג של נתונים בגודל משתנה של רכיב מרחבי.

סביבת זמן הריצה חייבת לשמור את XrSpatialBufferIdEXT והנתונים שלו בזיכרון לפחות למשך מחזור החיים של XrSpatialSnapshotEXT שמכיל אותו. יכול להיות שסביבת זמן הריצה תשמור את XrSpatialBufferIdEXT והנתונים שלו בזיכרון למשך זמן ארוך יותר ממחזור החיים של XrSpatialSnapshotEXT כדי להחזיר את אותו מזהה כחלק מתמונות מצב שנוצרו מאוחר יותר על ידי האפליקציה. עבור אותו XrSpatialBufferIdEXT , זמן הריצה חייב תמיד להחזיר את אותם נתונים באמצעות הפונקציה המתאימה של xrGetSpatialBuffer*.

typedef enum XrSpatialBufferTypeEXT {
    XR_SPATIAL_BUFFER_TYPE_UNKNOWN_EXT = 0,
    XR_SPATIAL_BUFFER_TYPE_STRING_EXT = 1,
    XR_SPATIAL_BUFFER_TYPE_UINT8_EXT = 2,
    XR_SPATIAL_BUFFER_TYPE_UINT16_EXT = 3,
    XR_SPATIAL_BUFFER_TYPE_UINT32_EXT = 4,
    XR_SPATIAL_BUFFER_TYPE_FLOAT_EXT = 5,
    XR_SPATIAL_BUFFER_TYPE_VECTOR2F_EXT = 6,
    XR_SPATIAL_BUFFER_TYPE_VECTOR3F_EXT = 7,
    XR_SPATIAL_BUFFER_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
} XrSpatialBufferTypeEXT;

הספירה XrSpatialBufferTypeEXT מזהה את סוגי הנתונים השונים של המאגר שמיוצג על ידי XrSpatialBufferIdEXT .

תיאורי ערכים מספריים

  • XR_SPATIAL_BUFFER_TYPE_STRING_EXT . אפשר להעביר את XrSpatialBufferIdEXT אל xrGetSpatialBufferStringEXT כדי לאחזר מאגר נתונים זמני של מחרוזות.
  • XR_SPATIAL_BUFFER_TYPE_UINT8_EXT . אפשר להעביר את XrSpatialBufferIdEXT אל xrGetSpatialBufferUint8EXT כדי לאחזר מאגר נתונים זמני של uint8_t.
  • XR_SPATIAL_BUFFER_TYPE_UINT16_EXT . אפשר להעביר את XrSpatialBufferIdEXT אל xrGetSpatialBufferUint16EXT כדי לאחזר מאגר נתונים זמני של uint16_t.
  • XR_SPATIAL_BUFFER_TYPE_UINT32_EXT . אפשר להעביר את XrSpatialBufferIdEXT אל xrGetSpatialBufferUint32EXT כדי לאחזר מאגר נתונים זמני של uint32_t.
  • XR_SPATIAL_BUFFER_TYPE_FLOAT_EXT . אפשר להעביר את XrSpatialBufferIdEXT אל xrGetSpatialBufferFloatEXT כדי לאחזר מאגר נתונים זמני של float.
  • XR_SPATIAL_BUFFER_TYPE_VECTOR2F_EXT . אפשר להעביר את XrSpatialBufferIdEXT אל xrGetSpatialBufferVector2fEXT כדי לאחזר מאגר נתונים זמני מסוג XrVector2f.
  • XR_SPATIAL_BUFFER_TYPE_VECTOR3F_EXT . אפשר להעביר את XrSpatialBufferIdEXT אל xrGetSpatialBufferVector3fEXT כדי לאחזר מאגר נתונים זמני של XrVector3f.

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

XrResult xrGetSpatialBufferStringEXT(
    XrSpatialSnapshotEXT                        snapshot,
    const XrSpatialBufferGetInfoEXT*            info,
    uint32_t                                    bufferCapacityInput,
    uint32_t*                                   bufferCountOutput,
    char*                                       buffer);

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

  • ‫snapshot הוא נקודת אחיזה ל-XrSpatialSnapshotEXT .
  • השדה info מכיל את המידע על המאגר הזמני לשאילתה.
  • ‫bufferCapacityInput הוא הקיבולת של המערך, או 0 כדי לציין בקשה לאחזור הקיבולת הנדרשת.
  • ‫bufferCountOutput הוא מספר התווים, או הקיבולת הנדרשת במקרה ש-bufferCapacityInput לא מספיק.
  • ‫buffer הוא מערך של char . הערך של NULL יכול להיות bufferCapacityInput אם הוא 0.
  • בקטע פרמטרים של שטח אחסון זמני יש תיאור מפורט של אחזור הגודל הנדרש של buffer.

האפליקציה יכולה לקבל את הנתונים של XrSpatialBufferEXT שסופקו על ידי רכיב, כאשר XrSpatialBufferEXT :: bufferType הוא XR_SPATIAL_BUFFER_TYPE_STRING_EXT באמצעות xrGetSpatialBufferStringEXT .

זמן הריצה חייב להחזיר את הערך XR_ERROR_VALIDATION_FAILURE אם XrSpatialBufferTypeEXT עבור XrSpatialBufferGetInfoEXT :: bufferId הוא לא XR_SPATIAL_BUFFER_TYPE_STRING_EXT .

זמן הריצה חייב להחזיר את XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT אם XrSpatialBufferGetInfoEXT :: bufferId לא שייך ל-snapshot .

הערך של buffer שזמן הריצה ממלא חייב להיות מחרוזת UTF-8 שמסתיימת ב-null.

שימוש תקין (משתמע)

  • חובה להפעיל את התוסף XR_EXT_spatial_entity לפני שקוראים ל-xrGetSpatialBufferStringEXT
  • ‫ snapshot חייב להיות כינוי XrSpatialSnapshotEXT תקין
  • ‫ info חייב להיות מצביע למבנה XrSpatialBufferGetInfoEXT תקין
  • bufferCountOutput חייב להיות מצביע לערך uint32_t
  • אם bufferCapacityInput הוא לא 0 , buffer חייב להיות מצביע למערך של ערכי תו bufferCapacityInput

קודי החזרה

הצלחה

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

נכשל

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_OUT_OF_MEMORY
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_SIZE_INSUFFICIENT
  • XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT
  • XR_ERROR_VALIDATION_FAILURE

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

XrResult xrGetSpatialBufferUint8EXT(
    XrSpatialSnapshotEXT                        snapshot,
    const XrSpatialBufferGetInfoEXT*            info,
    uint32_t                                    bufferCapacityInput,
    uint32_t*                                   bufferCountOutput,
    uint8_t*                                    buffer);

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

  • ‫snapshot הוא נקודת אחיזה ל-XrSpatialSnapshotEXT .
  • השדה info מכיל את המידע על המאגר הזמני לשאילתה.
  • ‫bufferCapacityInput הוא הקיבולת של המערך, או 0 כדי לציין בקשה לאחזור הקיבולת הנדרשת.
  • ‫bufferCountOutput הוא מספר הרכיבים במערך buffer, או הקיבולת הנדרשת במקרה ש-bufferCapacityInput לא מספיק.
  • ‫buffer הוא מערך של uint8_t . הערך של NULL יכול להיות bufferCapacityInput אם הוא 0.
  • בקטע פרמטרים של שטח אחסון זמני יש תיאור מפורט של אחזור הגודל הנדרש של buffer.

האפליקציה יכולה לקבל את הנתונים של XrSpatialBufferEXT שסופקו על ידי רכיב, כאשר XrSpatialBufferEXT :: bufferType הוא XR_SPATIAL_BUFFER_TYPE_UINT8_EXT באמצעות xrGetSpatialBufferUint8EXT .

זמן הריצה חייב להחזיר את הערך XR_ERROR_VALIDATION_FAILURE אם XrSpatialBufferTypeEXT עבור XrSpatialBufferGetInfoEXT :: bufferId הוא לא XR_SPATIAL_BUFFER_TYPE_UINT8_EXT .

זמן הריצה חייב להחזיר את XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT אם XrSpatialBufferGetInfoEXT :: bufferId לא שייך ל-snapshot .

שימוש תקין (משתמע)

  • צריך להפעיל את התוסף XR_EXT_spatial_entity לפני שקוראים ל-xrGetSpatialBufferUint8EXT
  • ‫ snapshot חייב להיות כינוי XrSpatialSnapshotEXT תקין
  • ‫ info חייב להיות מצביע למבנה XrSpatialBufferGetInfoEXT תקין
  • bufferCountOutput חייב להיות מצביע לערך uint32_t
  • אם bufferCapacityInput הוא לא 0, אז buffer חייב להיות מצביע למערך של ערכי uint8_t מסוג bufferCapacityInput

קודי החזרה

הצלחה

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

נכשל

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_OUT_OF_MEMORY
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_SIZE_INSUFFICIENT
  • XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT
  • XR_ERROR_VALIDATION_FAILURE

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

XrResult xrGetSpatialBufferUint16EXT(
    XrSpatialSnapshotEXT                        snapshot,
    const XrSpatialBufferGetInfoEXT*            info,
    uint32_t                                    bufferCapacityInput,
    uint32_t*                                   bufferCountOutput,
    uint16_t*                                   buffer);

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

  • ‫snapshot הוא נקודת אחיזה ל-XrSpatialSnapshotEXT .
  • השדה info מכיל את המידע על המאגר הזמני לשאילתה.
  • ‫bufferCapacityInput הוא הקיבולת של המערך, או 0 כדי לציין בקשה לאחזור הקיבולת הנדרשת.
  • ‫bufferCountOutput הוא מספר הרכיבים במערך buffer, או הקיבולת הנדרשת במקרה ש-bufferCapacityInput לא מספיק.
  • ‫buffer הוא מערך של uint16_t . הערך של NULL יכול להיות bufferCapacityInput אם הוא 0.
  • בקטע פרמטרים של שטח אחסון זמני יש תיאור מפורט של אחזור הגודל הנדרש של buffer.

האפליקציה יכולה לקבל את הנתונים של XrSpatialBufferEXT שסופקו על ידי רכיב, כאשר XrSpatialBufferEXT :: bufferType הוא XR_SPATIAL_BUFFER_TYPE_UINT16_EXT באמצעות xrGetSpatialBufferUint16EXT .

זמן הריצה חייב להחזיר את הערך XR_ERROR_VALIDATION_FAILURE אם XrSpatialBufferTypeEXT עבור XrSpatialBufferGetInfoEXT :: bufferId הוא לא XR_SPATIAL_BUFFER_TYPE_UINT16_EXT .

זמן הריצה חייב להחזיר את XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT אם XrSpatialBufferGetInfoEXT :: bufferId לא שייך ל-snapshot .

שימוש תקין (משתמע)

  • חובה להפעיל את התוסף XR_EXT_spatial_entity לפני שקוראים לפונקציה xrGetSpatialBufferUint16EXT
  • ‫ snapshot חייב להיות כינוי XrSpatialSnapshotEXT תקין
  • ‫ info חייב להיות מצביע למבנה XrSpatialBufferGetInfoEXT תקין
  • bufferCountOutput חייב להיות מצביע לערך uint32_t
  • אם bufferCapacityInput הוא לא 0, אז buffer חייב להיות מצביע למערך של ערכי uint16_t מסוג bufferCapacityInput

קודי החזרה

הצלחה

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

נכשל

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_OUT_OF_MEMORY
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_SIZE_INSUFFICIENT
  • XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT
  • XR_ERROR_VALIDATION_FAILURE

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

XrResult xrGetSpatialBufferUint32EXT(
    XrSpatialSnapshotEXT                        snapshot,
    const XrSpatialBufferGetInfoEXT*            info,
    uint32_t                                    bufferCapacityInput,
    uint32_t*                                   bufferCountOutput,
    uint32_t*                                   buffer);

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

  • ‫snapshot הוא נקודת אחיזה ל-XrSpatialSnapshotEXT .
  • השדה info מכיל את המידע על המאגר שרוצים לשלוח אליו שאילתה.
  • ‫bufferCapacityInput הוא הקיבולת של המערך, או 0 כדי לציין בקשה לאחזור הקיבולת הנדרשת.
  • ‫bufferCountOutput הוא מספר הרכיבים במערך buffer, או הקיבולת הנדרשת במקרה ש-bufferCapacityInput לא מספיק.
  • ‫buffer הוא מערך של uint32_t . הערך של NULL יכול להיות bufferCapacityInput אם הוא 0.
  • בקטע פרמטרים של שטח אחסון זמני יש תיאור מפורט של אחזור הגודל הנדרש של buffer.

האפליקציה יכולה לקבל את הנתונים של XrSpatialBufferEXT שסופקו על ידי רכיב, כאשר XrSpatialBufferEXT :: bufferType הוא XR_SPATIAL_BUFFER_TYPE_UINT32_EXT באמצעות xrGetSpatialBufferUint32EXT .

זמן הריצה חייב להחזיר את הערך XR_ERROR_VALIDATION_FAILURE אם XrSpatialBufferTypeEXT של XrSpatialBufferGetInfoEXT :: bufferId הוא לא XR_SPATIAL_BUFFER_TYPE_UINT32_EXT .

זמן הריצה חייב להחזיר את XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT אם XrSpatialBufferGetInfoEXT :: bufferId לא שייך ל-snapshot .

שימוש תקין (משתמע)

  • ‫ חובה להפעיל את התוסף XR_EXT_spatial_entity לפני שקוראים לפונקציה xrGetSpatialBufferUint32EXT
  • ‫ snapshot חייב להיות כינוי XrSpatialSnapshotEXT תקין
  • ‫ info חייב להיות מצביע למבנה XrSpatialBufferGetInfoEXT תקין
  • bufferCountOutput חייב להיות מצביע לערך uint32_t
  • אם bufferCapacityInput הוא לא 0, אז buffer חייב להיות מצביע למערך של ערכי uint32_t מסוג bufferCapacityInput

קודי החזרה

הצלחה

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

נכשל

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_OUT_OF_MEMORY
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_SIZE_INSUFFICIENT
  • XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT
  • XR_ERROR_VALIDATION_FAILURE

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

XrResult xrGetSpatialBufferFloatEXT(
    XrSpatialSnapshotEXT                        snapshot,
    const XrSpatialBufferGetInfoEXT*            info,
    uint32_t                                    bufferCapacityInput,
    uint32_t*                                   bufferCountOutput,
    float*                                      buffer);

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

  • ‫snapshot הוא נקודת אחיזה ל-XrSpatialSnapshotEXT .
  • השדה info מכיל את המידע על המאגר שרוצים לשלוח אליו שאילתה.
  • ‫bufferCapacityInput הוא הקיבולת של המערך, או 0 כדי לציין בקשה לאחזור הקיבולת הנדרשת.
  • ‫bufferCountOutput הוא מספר הרכיבים במערך buffer, או הקיבולת הנדרשת במקרה ש-bufferCapacityInput לא מספיק.
  • ‫buffer הוא מערך של float . הערך של NULL יכול להיות bufferCapacityInput אם הוא 0.
  • בקטע פרמטרים של שטח אחסון זמני יש תיאור מפורט של אחזור הגודל הנדרש של buffer.

האפליקציה יכולה לקבל את הנתונים של XrSpatialBufferEXT שסופקו על ידי רכיב, כאשר XrSpatialBufferEXT :: bufferType הוא XR_SPATIAL_BUFFER_TYPE_FLOAT_EXT באמצעות xrGetSpatialBufferFloatEXT .

זמן הריצה חייב להחזיר את הערך XR_ERROR_VALIDATION_FAILURE אם XrSpatialBufferTypeEXT עבור XrSpatialBufferGetInfoEXT :: bufferId הוא לא XR_SPATIAL_BUFFER_TYPE_FLOAT_EXT .

זמן הריצה חייב להחזיר את XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT אם XrSpatialBufferGetInfoEXT :: bufferId לא שייך ל-snapshot .

שימוש תקין (משתמע)

  • ‫ חובה להפעיל את התוסף XR_EXT_spatial_entity לפני שקוראים לפונקציה xrGetSpatialBufferFloatEXT
  • ‫ snapshot חייב להיות כינוי XrSpatialSnapshotEXT תקין
  • ‫ info חייב להיות מצביע למבנה XrSpatialBufferGetInfoEXT תקין
  • bufferCountOutput חייב להיות מצביע לערך uint32_t
  • אם bufferCapacityInput הוא לא 0, אז buffer חייב להיות מצביע למערך של ערכי float מסוג bufferCapacityInput

קודי החזרה

הצלחה

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

נכשל

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_OUT_OF_MEMORY
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_SIZE_INSUFFICIENT
  • XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT
  • XR_ERROR_VALIDATION_FAILURE

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

XrResult xrGetSpatialBufferVector2fEXT(
    XrSpatialSnapshotEXT                        snapshot,
    const XrSpatialBufferGetInfoEXT*            info,
    uint32_t                                    bufferCapacityInput,
    uint32_t*                                   bufferCountOutput,
    XrVector2f*                                 buffer);

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

  • ‫snapshot הוא נקודת אחיזה ל-XrSpatialSnapshotEXT .
  • השדה info מכיל את המידע על המאגר שרוצים לשלוח אליו שאילתה.
  • ‫bufferCapacityInput הוא הקיבולת של המערך, או 0 כדי לציין בקשה לאחזור הקיבולת הנדרשת.
  • ‫bufferCountOutput הוא מספר הרכיבים במערך buffer, או הקיבולת הנדרשת במקרה ש-bufferCapacityInput לא מספיק.
  • ‫buffer הוא מערך של XrVector2f . הערך של NULL יכול להיות bufferCapacityInput אם הוא 0.
  • בקטע פרמטרים של שטח אחסון זמני יש תיאור מפורט של אחזור הגודל הנדרש של buffer.

האפליקציה יכולה לקבל את הנתונים של XrSpatialBufferEXT שסופקו על ידי רכיב, כאשר XrSpatialBufferEXT :: bufferType הוא XR_SPATIAL_BUFFER_TYPE_VECTOR2F_EXT באמצעות xrGetSpatialBufferVector2fEXT .

זמן הריצה חייב להחזיר את הערך XR_ERROR_VALIDATION_FAILURE אם XrSpatialBufferTypeEXT עבור XrSpatialBufferGetInfoEXT :: bufferId הוא לא XR_SPATIAL_BUFFER_TYPE_VECTOR2F_EXT .

זמן הריצה חייב להחזיר את XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT אם XrSpatialBufferGetInfoEXT :: bufferId לא שייך ל-snapshot .

שימוש תקין (משתמע)

  • ‫ צריך להפעיל את התוסף XR_EXT_spatial_entity לפני שקוראים ל-xrGetSpatialBufferVector2fEXT
  • ‫ snapshot חייב להיות כינוי XrSpatialSnapshotEXT תקין
  • ‫ info חייב להיות מצביע למבנה XrSpatialBufferGetInfoEXT תקין
  • bufferCountOutput חייב להיות מצביע לערך uint32_t
  • אם bufferCapacityInput הוא לא 0 , buffer חייב להיות מצביע למערך של מבני bufferCapacityInput XrVector2f

קודי החזרה

הצלחה

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

נכשל

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_OUT_OF_MEMORY
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_SIZE_INSUFFICIENT
  • XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT
  • XR_ERROR_VALIDATION_FAILURE

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

XrResult xrGetSpatialBufferVector3fEXT(
    XrSpatialSnapshotEXT                        snapshot,
    const XrSpatialBufferGetInfoEXT*            info,
    uint32_t                                    bufferCapacityInput,
    uint32_t*                                   bufferCountOutput,
    XrVector3f*                                 buffer);

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

  • ‫snapshot הוא נקודת אחיזה ל-XrSpatialSnapshotEXT .
  • השדה info מכיל את המידע על המאגר הזמני לשאילתה.
  • ‫bufferCapacityInput הוא הקיבולת של המערך, או 0 כדי לציין בקשה לאחזור הקיבולת הנדרשת.
  • ‫bufferCountOutput הוא מספר הרכיבים במערך buffer, או הקיבולת הנדרשת במקרה ש-bufferCapacityInput לא מספיק.
  • ‫buffer הוא מערך של XrVector3f . הערך של NULL יכול להיות bufferCapacityInput אם הוא 0.
  • בקטע פרמטרים של שטח אחסון זמני יש תיאור מפורט של אחזור הגודל הנדרש של buffer.

האפליקציה יכולה לקבל את הנתונים של XrSpatialBufferEXT שסופקו על ידי רכיב, כאשר XrSpatialBufferEXT :: bufferType הוא XR_SPATIAL_BUFFER_TYPE_VECTOR3F_EXT באמצעות xrGetSpatialBufferVector3fEXT .

זמן הריצה חייב להחזיר את הערך XR_ERROR_VALIDATION_FAILURE אם XrSpatialBufferTypeEXT עבור XrSpatialBufferGetInfoEXT :: bufferId הוא לא XR_SPATIAL_BUFFER_TYPE_VECTOR3F_EXT .

זמן הריצה חייב להחזיר את XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT אם XrSpatialBufferGetInfoEXT :: bufferId לא שייך ל-snapshot .

שימוש תקין (משתמע)

  • חובה להפעיל את התוסף XR_EXT_spatial_entity לפני שקוראים ל-xrGetSpatialBufferVector3fEXT
  • ‫ snapshot חייב להיות כינוי XrSpatialSnapshotEXT תקין
  • ‫ info חייב להיות מצביע למבנה XrSpatialBufferGetInfoEXT תקין
  • bufferCountOutput חייב להיות מצביע לערך uint32_t
  • אם bufferCapacityInput הוא לא 0, אז buffer חייב להיות מצביע למערך של מבני bufferCapacityInput XrVector3f

קודי החזרה

הצלחה

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

נכשל

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_OUT_OF_MEMORY
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_SIZE_INSUFFICIENT
  • XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT
  • XR_ERROR_VALIDATION_FAILURE

המבנה של XrSpatialBufferGetInfoEXT מוגדר כך:

typedef struct XrSpatialBufferGetInfoEXT {
    XrStructureType         type;
    const void*             next;
    XrSpatialBufferIdEXT    bufferId;
} XrSpatialBufferGetInfoEXT;

תיאורי חברים

  • ‫type הוא ה-XrStructureType של המבנה הזה.
  • ‫next הוא NULL או מצביע למבנה הבא בשרשרת מבנים.
  • bufferId XrSpatialBufferIdEXT למאגר הנתונים שרוצים לאחזר את הנתונים שלו.

שימוש תקין (משתמע)

#define XR_NULL_SPATIAL_BUFFER_ID_EXT 0

‫XR_NULL_SPATIAL_BUFFER_ID_EXT הוא ערך שמור שמייצג XrSpatialBufferIdEXT לא חוקי. אפשר להעביר אותו לפונקציות API ולקבל אותו מהן רק אם זה מותר באופן ספציפי.

יצירת תמונת מצב של העדכון

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

XrResult xrCreateSpatialUpdateSnapshotEXT(
    XrSpatialContextEXT                         spatialContext,
    const XrSpatialUpdateSnapshotCreateInfoEXT* createInfo,
    XrSpatialSnapshotEXT*                       snapshot);

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

האפליקציה יכולה להשתמש ב-xrCreateSpatialUpdateSnapshotEXT כדי ליצור תמונת מצב ולקבל את נתוני הרכיבים העדכניים ביותר של ישויות ספציפיות, כפי שהם ידועים לסביבת זמן הריצה. אפליקציות יכולות לספק את נקודות האחיזה של XrSpatialEntityEXT ואת סוגי הרכיבים שמעניינים אותן כשהן יוצרות את קובץ ה-snapshot.

האפליקציה יכולה להשתמש ב-XrSpatialUpdateSnapshotCreateInfoEXT :: componentTypes כדי לסנן את רשימת הרכיבים שהנתונים שלהם חייבים להיכלל בתמונת המצב. אם האפליקציה מספקת רשימה תקינה של סוגי רכיבים מרחביים ב-XrSpatialUpdateSnapshotCreateInfoEXT :: componentTypes , אז זמן הריצה חייב לכלול בתמונת המצב רק ישויות מרחביות שיש להן לפחות אחד מהרכיבים שסופקו ב-XrSpatialUpdateSnapshotCreateInfoEXT :: componentTypes . בנוסף, זמן הריצה חייב לכלול רק נתונים של הרכיבים האלה בתמונת המצב.

זמן הריצה חייב להחזיר את הערך XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT אם אחד מהערכים של XrSpatialComponentTypeEXT ב-XrSpatialUpdateSnapshotCreateInfoEXT :: componentTypes לא מופעל ליכולות המרחביות שהועברו אל XrSpatialContextCreateInfoEXT :: capabilityConfigs בזמן היצירה של spatialContext .

אם האפליקציה לא מספקת רשימה של סוגי רכיבים מרחביים ב-XrSpatialUpdateSnapshotCreateInfoEXT :: componentTypes , זמן הריצה חייב לכלול את כל הישויות המרחביות שרשומות ב-XrSpatialUpdateSnapshotCreateInfoEXT :: entities בתמונת המצב, והוא חייב לכלול את הנתונים של כל הרכיבים המופעלים של היכולות שהוגדרו עבור spatialContext .

סביבת זמן הריצה לא יכולה לכלול ישויות מרחביות שלא מופיעות ב-XrSpatialUpdateSnapshotCreateInfoEXT :: entities ב-snapshot .

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

שימוש תקין (משתמע)

קודי החזרה

הצלחה

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

נכשל

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

המבנה של XrSpatialUpdateSnapshotCreateInfoEXT מוגדר כך:

typedef struct XrSpatialUpdateSnapshotCreateInfoEXT {
    XrStructureType                     type;
    const void*                         next;
    uint32_t                            entityCount;
    const XrSpatialEntityEXT*           entities;
    uint32_t                            componentTypeCount;
    const XrSpatialComponentTypeEXT*    componentTypes;
    XrSpace                             baseSpace;
    XrTime                              time;
} XrSpatialUpdateSnapshotCreateInfoEXT;

תיאורי חברים

  • ‫type הוא ה-XrStructureType של המבנה הזה.
  • ‫next הוא NULL או מצביע למבנה הבא בשרשרת מבנים. מבנים כאלה לא מוגדרים ב-OpenXR או בתוסף הזה.
  • ‫entityCount הוא uint32_t שמתאר את מספר הרכיבים במערך entities.
  • ‫entities הוא מערך של XrSpatialEntityEXT שבו זמן הריצה חייב לכלול את נתוני הרכיב בתמונת המצב.
  • ‫componentTypeCount הוא uint32_t שמתאר את מספר הרכיבים במערך componentTypes.
  • ‫componentTypes הוא מערך של XrSpatialComponentTypeEXT שבו זמן הריצה חייב לכלול את הנתונים בתמונת המצב.
  • ‫baseSpace הוא ה-XrSpace שביחס אליו ימוקמו כל המיקומים של העדכון XrSpatialSnapshotEXT.
  • ‫time הוא ה-XrTime שבו כל המיקומים של העדכון XrSpatialSnapshotEXT יהיו ממוקמים.

שימוש תקין (משתמע)

  • ‫ חובה להפעיל את התוסף XR_EXT_spatial_entity לפני שמשתמשים ב-XrSpatialUpdateSnapshotCreateInfoEXT
  • type חייב להיות XR_TYPE_SPATIAL_UPDATE_SNAPSHOT_CREATE_INFO_EXT
  • next חייב להיות NULL או מצביע תקין למבנה הבא בשרשרת מבנים
  • entities חייב להיות מצביע למערך של entityCount נקודות אחיזה חוקיות של XrSpatialEntityEXT
  • אם componentTypeCount הוא לא 0 , componentTypes חייב להיות מצביע למערך של ערכי XrSpatialComponentTypeEXT תקינים של componentTypeCount
  • ‫ baseSpace חייב להיות כינוי תקין ב-XrSpace
  • ‫ הפרמטר entityCount חייב להיות גדול מ-0
  • גם baseSpace וגם הרכיבים של entities חייבים להיווצר, להיות מוקצים או להישלף מאותו XrSession

השמדת תמונת המצב

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

XrResult xrDestroySpatialSnapshotEXT(
    XrSpatialSnapshotEXT                        snapshot);

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

האפליקציה יכולה להפעיל את xrDestroySpatialSnapshotEXT כדי להשמיד את נקודת האחיזה XrSpatialSnapshotEXT ואת המשאבים שמשויכים אליה.

שימוש תקין (משתמע)

Thread Safety

  • הגישה אל snapshot , ואל כל נקודות האחיזה הצאצאות, חייבת להיות מסונכרנת באופן חיצוני

קודי החזרה

הצלחה

  • XR_SUCCESS

נכשל

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_RUNTIME_FAILURE

רכיבים נפוצים

דו-ממדי מוגבל

נתוני רכיבים

המבנה של XrSpatialBounded2DDataEXT מוגדר כך:

typedef struct XrSpatialBounded2DDataEXT {
    XrPosef        center;
    XrExtent2Df    extents;
} XrSpatialBounded2DDataEXT;

תיאורי חברים

  • ‫center הוא XrPosef שמגדיר את המרכז הגיאומטרי של הרכיב הדו-ממדי התחום.
  • ‫extents הוא המידות של הרכיב הדו-ממדי התחום לאורך ציר ה-X‏ (extents.width), ציר ה-Y‏ (extents.height), במרכז של center .

הערכים extents של XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT מתייחסים לגודל הישות במישור x-y של מערכת הקואורדינטות של המישור. מישור עם מיקום של {0, 0, 0}, סיבוב של {0, 0, 0, 1} (ללא סיבוב) וגודל של {1, 1} מתייחס למישור של מטר אחד על מטר אחד שמרכזו ב-{0, 0, 0} כשהוקטור הנורמלי של החזית שלו פונה לכיוון +Z במרחב של הרכיב.

X X Y Y Z Z גובה גובה Y Y Z Z X X מישור אנכי מישור אנכי מישור אופקי מישור אופקי רוחב רוחב רוחב רוחב גובה גובה

איור 24. מערכת קואורדינטות של רכיב Bounded2D

הערה

ב-OpenXR משתמשים במישור X-Y עם ‎+Z כנורמל למישור, אבל בממשקי API אחרים יכול להיות שמשתמשים במישור X-Z עם ‎+Y כנורמל למישור. אפשר להמיר את מישור X-Y למישור X-Z על ידי סיבוב של ‎-π/2 רדיאנים סביב ציר ‎+X.

שימוש תקין (משתמע)

מבנה רשימת הרכיבים לשליפת נתונים

המבנה של XrSpatialComponentBounded2DListEXT מוגדר כך:

typedef struct XrSpatialComponentBounded2DListEXT {
    XrStructureType               type;
    void*                         next;
    uint32_t                      boundCount;
    XrSpatialBounded2DDataEXT*    bounds;
} XrSpatialComponentBounded2DListEXT;

תיאורי חברים

  • ‫type הוא ה-XrStructureType של המבנה הזה.
  • ‫next הוא NULL או מצביע למבנה הבא בשרשרת מבנים. מבנים כאלה לא מוגדרים ב-OpenXR או בתוסף הזה.
  • ‫boundCount הוא uint32_t שמתאר את מספר הרכיבים במערך bounds.
  • ‫bounds הוא מערך של XrSpatialBounded2DDataEXT .

זמן הריצה חייב להחזיר את הערך XR_ERROR_VALIDATION_FAILURE מ-xrQuerySpatialComponentDataEXT אם XrSpatialComponentBounded2DListEXT נמצא בשרשרת הבאה של XrSpatialComponentDataQueryResultEXT :: next אבל XrSpatialComponentDataQueryConditionEXT ::componentTypeCount הוא לא אפס ו-XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT לא נכלל ב-XrSpatialComponentDataQueryConditionEXT :: componentTypes .

זמן הריצה חייב להחזיר את הערך XR_ERROR_SIZE_INSUFFICIENT מ-xrQuerySpatialComponentDataEXT אם boundCount קטן מ-XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput .

אם xrQuerySpatialComponentDataEXT :: snapshot נוצר מ-xrCreateSpatialDiscoverySnapshotCompleteEXT , אז זמן הריצה חייב לספק את XrSpatialBounded2DDataEXT :: center ב-XrCreateSpatialDiscoverySnapshotCompletionInfoEXT :: baseSpace וב-XrCreateSpatialDiscoverySnapshotCompletionInfoEXT :: time .

אם xrQuerySpatialComponentDataEXT :: snapshot נוצר מ-xrCreateSpatialUpdateSnapshotEXT , אז זמן הריצה חייב לספק את XrSpatialBounded2DDataEXT :: center ב-XrSpatialUpdateSnapshotCreateInfoEXT :: baseSpace וב-XrSpatialUpdateSnapshotCreateInfoEXT :: time .

שימוש תקין (משתמע)

הגדרות אישיות

אם XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT מופיע ב-XrSpatialCapabilityComponentTypesEXT :: componentTypes עבור יכולת מסוימת, האפליקציה יכולה להפעיל אותה על ידי הכללת ערך ה-enum ברשימה XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents. הרכיב הזה לא דורש הגדרה מיוחדת כדי להיכלל בשרשרת הבאה של XrSpatialCapabilityConfigurationBaseHeaderEXT .

תלת-ממד מוגבל

נתוני רכיבים

XrBoxf הוא מקור הנתונים של XR_SPATIAL_COMPONENT_TYPE_BOUNDED_3D_EXT.

מבנה רשימת הרכיבים לשליפת נתונים

המבנה של XrSpatialComponentBounded3DListEXT מוגדר כך:

typedef struct XrSpatialComponentBounded3DListEXT {
    XrStructureType    type;
    void*              next;
    uint32_t           boundCount;
    XrBoxf*            bounds;
} XrSpatialComponentBounded3DListEXT;

תיאורי חברים

  • ‫type הוא ה-XrStructureType של המבנה הזה.
  • ‫next הוא NULL או מצביע למבנה הבא בשרשרת מבנים. מבנים כאלה לא מוגדרים ב-OpenXR או בתוסף הזה.
  • ‫boundCount הוא uint32_t שמתאר את מספר הרכיבים במערך bounds.
  • ‫bounds הוא מערך של XrBoxf .

זמן הריצה חייב להחזיר את XR_ERROR_VALIDATION_FAILURE מ-xrQuerySpatialComponentDataEXT אם XrSpatialComponentBounded3DListEXT נמצא בשרשרת הבאה של XrSpatialComponentDataQueryResultEXT :: next אבל XrSpatialComponentDataQueryConditionEXT ::componentTypeCount הוא לא אפס ו-XR_SPATIAL_COMPONENT_TYPE_BOUNDED_3D_EXT לא כלול ב-XrSpatialComponentDataQueryConditionEXT :: componentTypes .

זמן הריצה חייב להחזיר את הערך XR_ERROR_SIZE_INSUFFICIENT מ-xrQuerySpatialComponentDataEXT אם boundCount קטן מ-XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput .

אם xrQuerySpatialComponentDataEXT :: snapshot נוצר מ-xrCreateSpatialDiscoverySnapshotCompleteEXT , זמן הריצה חייב לספק את XrBoxf :: center ב-XrCreateSpatialDiscoverySnapshotCompletionInfoEXT :: baseSpace ב-XrCreateSpatialDiscoverySnapshotCompletionInfoEXT :: time .

אם xrQuerySpatialComponentDataEXT :: snapshot נוצר מ-xrCreateSpatialUpdateSnapshotEXT , זמן הריצה חייב לספק את XrBoxf :: center ב-XrSpatialUpdateSnapshotCreateInfoEXT :: baseSpace ב-XrSpatialUpdateSnapshotCreateInfoEXT :: time .

שימוש תקין (משתמע)

  • חובה להפעיל את התוסף XR_EXT_spatial_entity לפני שמשתמשים ב-XrSpatialComponentBounded3DListEXT
  • type חייב להיות XR_TYPE_SPATIAL_COMPONENT_BOUNDED_3D_LIST_EXT
  • next חייב להיות NULL או מצביע תקין למבנה הבא בשרשרת מבנים
  • bounds חייב להיות מצביע למערך של מבני boundCount XrBoxf
  • ‫ הפרמטר boundCount חייב להיות גדול מ-0
הגדרות אישיות

אם XR_SPATIAL_COMPONENT_TYPE_BOUNDED_3D_EXT מופיע ב-XrSpatialCapabilityComponentTypesEXT :: componentTypes עבור יכולת מסוימת, האפליקציה יכולה להפעיל אותה על ידי הכללת ה-enum ברשימה XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents. הרכיב הזה לא דורש הגדרה מיוחדת כדי להיכלל בשרשרת הבאה של XrSpatialCapabilityConfigurationBaseHeaderEXT .

הורה

נתוני רכיבים

‫XR_SPATIAL_COMPONENT_TYPE_PARENT_EXT משתמש ב-XrSpatialEntityIdEXT לנתונים שלו.

מבנה רשימת הרכיבים לשאילתת נתונים

המבנה של XrSpatialComponentParentListEXT מוגדר כך:

typedef struct XrSpatialComponentParentListEXT {
    XrStructureType          type;
    void*                    next;
    uint32_t                 parentCount;
    XrSpatialEntityIdEXT*    parents;
} XrSpatialComponentParentListEXT;

תיאורי חברים

  • ‫type הוא ה-XrStructureType של המבנה הזה.
  • ‫next הוא NULL או מצביע למבנה הבא בשרשרת מבנים. מבנים כאלה לא מוגדרים ב-OpenXR או בתוסף הזה.
  • ‫parentCount הוא uint32_t שמתאר את מספר הרכיבים במערך parents.
  • ‫parents הוא מערך של XrSpatialEntityIdEXT .

זמן הריצה חייב להחזיר את הערך XR_ERROR_VALIDATION_FAILURE מ-xrQuerySpatialComponentDataEXT אם XrSpatialComponentParentListEXT נמצא בשרשרת הבאה של XrSpatialComponentDataQueryResultEXT :: next אבל XrSpatialComponentDataQueryConditionEXT ::componentTypeCount הוא לא אפס ו-XR_SPATIAL_COMPONENT_TYPE_PARENT_EXT לא כלול ב-XrSpatialComponentDataQueryConditionEXT :: componentTypes .

זמן הריצה חייב להחזיר את הערך XR_ERROR_SIZE_INSUFFICIENT מ-xrQuerySpatialComponentDataEXT אם parentCount קטן מ-XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput .

שימוש תקין (משתמע)

  • ‫ חובה להפעיל את התוסף XR_EXT_spatial_entity לפני שמשתמשים ב-XrSpatialComponentParentListEXT
  • type חייב להיות XR_TYPE_SPATIAL_COMPONENT_PARENT_LIST_EXT
  • next חייב להיות NULL או מצביע תקין למבנה הבא בשרשרת מבנים
  • ‫ parents חייב להיות מצביע למערך של ערכי parentCount XrSpatialEntityIdEXT
  • ‫ הפרמטר parentCount חייב להיות גדול מ-0
הגדרות אישיות

אם XR_SPATIAL_COMPONENT_TYPE_PARENT_EXT מופיע ב-XrSpatialCapabilityComponentTypesEXT :: componentTypes עבור יכולת מסוימת, האפליקציה יכולה להפעיל אותה על ידי הכללת ה-enum ברשימה XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents. הרכיב הזה לא דורש הגדרה מיוחדת כדי להיכלל בשרשרת הבאה של XrSpatialCapabilityConfigurationBaseHeaderEXT .

רשת תלת-ממדית

נתוני רכיבים

המבנה של XrSpatialMeshDataEXT מוגדר כך:

typedef struct XrSpatialMeshDataEXT {
    XrPosef               origin;
    XrSpatialBufferEXT    vertexBuffer;
    XrSpatialBufferEXT    indexBuffer;
} XrSpatialMeshDataEXT;

תיאורי חברים

  • ‫origin הוא XrPosef שמגדיר את נקודת המוצא של הרשת. כל הקודקודים של הרשת חייבים להיות יחסיים לנקודת המוצא הזו.
  • ‫vertexBuffer הוא XrSpatialBufferEXT שמספק את המזהה של מאגר נתונים שמייצג את מאגר הנתונים של הקודקודים של הישות שהרכיב הזה נמצא בה. המיקום של הקודקודים חייב להיות יחסי ל-origin .
  • ‫indexBuffer הוא XrSpatialBufferEXT שמספק את המזהה של מאגר נתונים שמייצג מערך של אינדקסים של משולשים, ומציין את האינדקסים של קודקודי הרשת ב-vertexBuffer . האינדקסים של המשולשים חייבים להיות מוחזרים בסדר נגד כיוון השעון, ושלושה אינדקסים מציינים משולש אחד.

סוג הרכיב שמשתמש ב-XrSpatialMeshDataEXT חייב לציין את ה-XrSpatialBufferTypeEXT של vertexBuffer ו-indexBuffer .

שימוש תקין (משתמע)

מבנה רשימת הרכיבים לשליפת נתונים

המבנה של XrSpatialComponentMesh3DListEXT מוגדר כך:

typedef struct XrSpatialComponentMesh3DListEXT {
    XrStructureType          type;
    void*                    next;
    uint32_t                 meshCount;
    XrSpatialMeshDataEXT*    meshes;
} XrSpatialComponentMesh3DListEXT;

תיאורי חברים

  • ‫type הוא ה-XrStructureType של המבנה הזה.
  • ‫next הוא NULL או מצביע למבנה הבא בשרשרת מבנים.
  • ‫meshCount הוא uint32_t שמתאר את מספר הרכיבים במערך meshes.
  • ‫meshes הוא מערך של XrSpatialMeshDataEXT .

האפליקציה יכולה לשלוח שאילתה לרכיב התלת-ממדי של הרשת של הישויות המרחביות ב-XrSpatialSnapshotEXT על ידי הוספת XR_SPATIAL_COMPONENT_TYPE_MESH_3D_EXT ב-XrSpatialComponentDataQueryConditionEXT :: componentTypes והוספת XrSpatialComponentMesh3DListEXT לשרשרת המצביעים הבאה של XrSpatialComponentDataQueryResultEXT .

זמן הריצה חייב להחזיר את הערך XR_ERROR_VALIDATION_FAILURE מ-xrQuerySpatialComponentDataEXT אם XrSpatialComponentMesh3DListEXT נמצא בשרשרת הבאה של XrSpatialComponentDataQueryResultEXT :: next אבל XrSpatialComponentDataQueryConditionEXT ::componentTypeCount הוא לא אפס ו-XR_SPATIAL_COMPONENT_TYPE_MESH_3D_EXT לא נכלל ב-XrSpatialComponentDataQueryConditionEXT :: componentTypes .

זמן הריצה חייב להחזיר את הערך XR_ERROR_SIZE_INSUFFICIENT מ-xrQuerySpatialComponentDataEXT אם meshCount קטן מ-XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput .

ב-XrSpatialMeshDataEXT שמולא על ידי זמן הריצה במערך meshes, הערך של XrSpatialBufferEXT :: bufferType עבור XrSpatialMeshDataEXT :: vertexBuffer חייב להיות XR_SPATIAL_BUFFER_TYPE_VECTOR3F_EXT והערך של XrSpatialBufferEXT :: bufferType עבור XrSpatialMeshDataEXT :: indexBuffer חייב להיות XR_SPATIAL_BUFFER_TYPE_UINT32_EXT .

שימוש תקין (משתמע)

הגדרות אישיות

אם XR_SPATIAL_COMPONENT_TYPE_MESH_3D_EXT מופיע ב-XrSpatialCapabilityComponentTypesEXT :: componentTypes עבור יכולת מסוימת, האפליקציה יכולה להפעיל אותה על ידי הכללת ה-enum ברשימה XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents של המבנה הנגזר XrSpatialCapabilityConfigurationBaseHeaderEXT של היכולת שתומכת ברכיב הזה.

הרכיב הזה לא דורש הגדרה מיוחדת כדי להיכלל בשרשרת הבאה של XrSpatialCapabilityConfigurationBaseHeaderEXT .

מסננים של מצבי מעקב

המבנה של XrSpatialFilterTrackingStateEXT מוגדר כך:

typedef struct XrSpatialFilterTrackingStateEXT {
    XrStructureType                    type;
    const void*                        next;
    XrSpatialEntityTrackingStateEXT    trackingState;
} XrSpatialFilterTrackingStateEXT;

תיאורי חברים

  • ‫type הוא ה-XrStructureType של המבנה הזה.
  • ‫next הוא NULL או מצביע למבנה הבא בשרשרת מבנים.
  • ‫trackingState הוא XrSpatialEntityTrackingStateEXT שהאפליקציה רוצה להחיל עליו את המסנן.

האפליקציה יכולה להשתמש ב-XrSpatialFilterTrackingStateEXT בשרשרת הבאה של XrSpatialDiscoverySnapshotCreateInfoEXT כדי להגביל את החיפוש רק לישויות שמצב המעקב שלהן הוא trackingState .

האפליקציה יכולה להשתמש ב-XrSpatialFilterTrackingStateEXT בשרשרת הבאה של XrSpatialComponentDataQueryConditionEXT כדי להגדיר את היקף השאילתה של נתוני הרכיבים מתמונת מצב רק לישויות שמצב המעקב שלהן הוא trackingState .

שימוש תקין (משתמע)

קוד לדוגמה

שימוש באפליקציות

בדרך כלל, אפליקציות משתמשות בתוסף הישות המרחבית בתבנית הבאה:

איך למצוא ישויות מרחביות ולשאול נתונים של רכיבים

הקוד לדוגמה הבא מדגים איך לגלות ישויות מרחביות עבור היכולת "Foo" ולשאול את נתוני הרכיבים שלה.

/****************************/
/* Capability definition    */
/****************************/
// Foo capability has the following components -
// - XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT
#define XR_SPATIAL_CAPABILITY_FOO ((XrSpatialCapabilityEXT)1000740000U)

#define XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_FOO_EXT ((XrStructureType)1000740000U)
// Derives from XrSpatialCapabilityConfigurationBaseHeaderEXT
typedef struct XrSpatialCapabilityConfigurationFooEXT {
  XrStructureType                     type;
  const void* XR_MAY_ALIAS            next;
  XrSpatialCapabilityEXT              capability;
  uint32_t                            enabledComponentCount;
  const XrSpatialComponentTypeEXT*    enabledComponents;
} XrSpatialCapabilityConfigurationFooEXT;

/******************************/
/* End capability definition  */
/******************************/

auto waitUntilReady = [](XrFutureEXT future) {
  XrFuturePollInfoEXT pollInfo{XR_TYPE_FUTURE_POLL_INFO_EXT};
  XrFuturePollResultEXT pollResult{XR_TYPE_FUTURE_POLL_RESULT_EXT};
  pollInfo.future = future;
  do {
    // sleep(1);
    CHK_XR(xrPollFutureEXT(instance, &pollInfo, &pollResult));
  } while (pollResult.state != XR_FUTURE_STATE_READY_EXT);
};

// Create a spatial spatial context
XrSpatialContextEXT spatialContext{};
{
  const std::array<XrSpatialComponentTypeEXT, 1> enabledComponents = {
    XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT,
  };

  // Configure Foo capability for the spatial context
  XrSpatialCapabilityConfigurationFooEXT fooConfig{XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_FOO_EXT};
  fooConfig.capability = XR_SPATIAL_CAPABILITY_FOO;
  fooConfig.enabledComponentCount = enabledComponents.size();
  fooConfig.enabledComponents = enabledComponents.data();

  std::vector<XrSpatialCapabilityConfigurationBaseHeaderEXT*> capabilityConfigs;
  capabilityConfigs.push_back(reinterpret_cast<XrSpatialCapabilityConfigurationBaseHeaderEXT*>(&fooConfig));

  XrSpatialContextCreateInfoEXT spatialContextCreateInfo{XR_TYPE_SPATIAL_CONTEXT_CREATE_INFO_EXT};
  spatialContextCreateInfo.capabilityConfigCount = capabilityConfigs.size();
  spatialContextCreateInfo.capabilityConfigs = capabilityConfigs.data();
  XrFutureEXT createContextFuture;
  CHK_XR(xrCreateSpatialContextAsyncEXT(session, &spatialContextCreateInfo, &createContextFuture));

  waitUntilReady(createContextFuture);

  XrCreateSpatialContextCompletionEXT completion{XR_TYPE_CREATE_SPATIAL_CONTEXT_COMPLETION_EXT};
  CHK_XR(xrCreateSpatialContextCompleteEXT(session, createContextFuture, &completion));
  if (completion.futureResult != XR_SUCCESS) {
    return;
  }

  spatialContext = completion.spatialContext;
}

auto discoverSpatialEntities = [&](XrSpatialContextEXT spatialContext, XrTime time) {
  // We want to look for entities that have the following components.
  std::array<XrSpatialComponentTypeEXT, 1> snapshotComponents {XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT};

  XrSpatialDiscoverySnapshotCreateInfoEXT snapshotCreateInfo{XR_TYPE_SPATIAL_DISCOVERY_SNAPSHOT_CREATE_INFO_EXT};
  snapshotCreateInfo.componentTypeCount = snapshotComponents.size();
  snapshotCreateInfo.componentTypes = snapshotComponents.data();
  XrFutureEXT future = XR_NULL_FUTURE_EXT;
  CHK_XR(xrCreateSpatialDiscoverySnapshotAsyncEXT(spatialContext, &snapshotCreateInfo, &future));

  waitUntilReady(future);

  XrCreateSpatialDiscoverySnapshotCompletionInfoEXT completionInfo{XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_INFO_EXT};
  completionInfo.baseSpace = localSpace;
  completionInfo.time = time;
  completionInfo.future = future;

  XrCreateSpatialDiscoverySnapshotCompletionEXT completion{XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_EXT};
  CHK_XR(xrCreateSpatialDiscoverySnapshotCompleteEXT(spatialContext, &completionInfo, &completion));
  if (completion.futureResult == XR_SUCCESS) {
    // Query for the bounded2d component data
    XrSpatialComponentTypeEXT componentToQuery = XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT;
    XrSpatialComponentDataQueryConditionEXT queryCond{XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_CONDITION_EXT};
    queryCond.componentTypes = &componentToQuery;

    XrSpatialComponentDataQueryResultEXT queryResult{XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_RESULT_EXT};
    queryResult.entityIdCapacityInput = 0;
    queryResult.entityIds = nullptr;
    queryResult.entityStateCapacityInput = 0;
    queryResult.entityStates = nullptr;
    CHK_XR(xrQuerySpatialComponentDataEXT(completion.snapshot, &queryCond, &queryResult));

    std::vector<XrSpatialEntityIdEXT> entityIds(queryResult.entityIdCountOutput);
    std::vector<XrSpatialEntityTrackingStateEXT> entityStates(queryResult.entityStateCountOutput);
    queryResult.entityIdCapacityInput = entityIds.size();
    queryResult.entityIds = entityIds.data();
    queryResult.entityStateCapacityInput = entityStates.size();
    queryResult.entityStates = entityStates.data();

    std::vector<XrSpatialBounded2DDataEXT> bounded2d(queryResult.entityIdCountOutput);
    XrSpatialComponentBounded2DListEXT boundsList{XR_TYPE_SPATIAL_COMPONENT_BOUNDED_2D_LIST_EXT};
    boundsList.boundCount = bounded2d.size();
    boundsList.bounds = bounded2d.data();
    queryResult.next = &boundsList;

    CHK_XR(xrQuerySpatialComponentDataEXT(completion.snapshot, &queryCond, &queryResult));

    for (int32_t i = 0; i < queryResult.entityIdCountOutput; ++i) {
      if (entityStates[i] == XR_SPATIAL_ENTITY_TRACKING_STATE_TRACKING_EXT) {
        // 2D extents for entity entityIds[i] is bounded2d[i].extents.
      }
    }

    CHK_XR(xrDestroySpatialSnapshotEXT(completion.snapshot));
  }
};

while (1) {
  // ...
  // For every frame in frame loop
  // ...

  XrFrameState frameState;  // previously returned from xrWaitFrame
  const XrTime time = frameState.predictedDisplayTime;

  // Poll for the XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT event
  XrEventDataBuffer event = {XR_TYPE_EVENT_DATA_BUFFER};
  XrResult result = xrPollEvent(instance, &event);
  if (result == XR_SUCCESS) {
      switch (event.type) {
          case XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT: {
              const XrEventDataSpatialDiscoveryRecommendedEXT& eventdata =
                  *reinterpret_cast<XrEventDataSpatialDiscoveryRecommendedEXT*>(&event);
              // Discover spatial entities for the context that we received the "discovery
              // recommended" event for.
              discoverSpatialEntities(eventdata.spatialContext, time);
              break;
          }
      }
  }

  // ...
  // Finish frame loop
  // ...
}

CHK_XR(xrDestroySpatialContextEXT(spatialContext));

נתוני מאגר זמני של שאילתות

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

/****************************/
/* Component definition     */
/****************************/
// Foo component that provides an XrVector3f buffer
#define XR_SPATIAL_COMPONENT_TYPE_FOO_EXT ((XrSpatialComponentTypeEXT)1000740000U)

#define XR_TYPE_SPATIAL_COMPONENT_FOO_LIST_EXT ((XrStructureType)1000740000U)

// XrSpatialComponentFooListEXT extends XrSpatialComponentDataQueryResultEXT
typedef struct XrSpatialComponentFooListEXT {
    XrStructureType                   type;
    void* XR_MAY_ALIAS                next;
    uint32_t                          fooCount;
    XrSpatialBufferEXT*               foo;
} XrSpatialComponentFooListEXT;

/******************************/
/* End Component definition  */
/******************************/

// Query for the foo component data
XrSpatialComponentTypeEXT componentToQuery = XR_SPATIAL_COMPONENT_TYPE_FOO_EXT;
XrSpatialComponentDataQueryConditionEXT queryCond{XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_CONDITION_EXT};
queryCond.componentTypeCount = 1;
queryCond.componentTypes = &componentToQuery;

XrSpatialComponentDataQueryResultEXT queryResult{XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_RESULT_EXT};
CHK_XR(xrQuerySpatialComponentDataEXT(snapshot, &queryCond, &queryResult));

std::vector<XrSpatialEntityIdEXT> entityIds(queryResult.entityIdCountOutput);
queryResult.entityIdCapacityInput = entityIds.size();
queryResult.entityIds = entityIds.data();

std::vector<XrSpatialBufferEXT> fooBuffers(queryResult.entityIdCountOutput);
XrSpatialComponentFooListEXT fooList{XR_TYPE_SPATIAL_COMPONENT_FOO_LIST_EXT};
fooList.fooCount = fooBuffers.size();
fooList.foo = fooBuffers.data();
queryResult.next = &fooList;

CHK_XR(xrQuerySpatialComponentDataEXT(snapshot, &queryCond, &queryResult));

for (int32_t i = 0; i < queryResult.entityIdCountOutput; ++i) {
  // foo component data for entity entityIds[i]
  if (fooBuffers[i].bufferType == XR_SPATIAL_BUFFER_TYPE_VECTOR3F_EXT) {
    XrSpatialBufferGetInfoEXT getInfo{XR_TYPE_SPATIAL_BUFFER_GET_INFO_EXT};
    getInfo.bufferId = fooBuffers[i].bufferId;
    uint32_t bufferCountOutput;
    CHK_XR(xrGetSpatialBufferVector3fEXT(snapshot, &getInfo, 0, &bufferCountOutput, nullptr));
    std::vector<XrVector3f> vertexBuffer(bufferCountOutput);
    CHK_XR(xrGetSpatialBufferVector3fEXT(snapshot, &getInfo, bufferCountOutput, &bufferCountOutput, vertexBuffer.data()));

    // XrVertex3f buffer for entity entityIds[i] is now available in vertexBuffer vector.
  }
}

הנחיות לגבי תוספים

  • אם תוסף מגדיר XrSpatialComponentTypeEXT חדש שמספק נתונים נוספים על ישות מרחבית,

  • תוספים יכולים להגדיר מבנים שמרחיבים את XrSpatialDiscoverySnapshotCreateInfoEXT כדי לספק מסננים נוספים לזיהוי. המסננים ליצירת תמונת המצב לא צריכים להשפיע על ההגדרה של ההקשר המרחבי, אלא לשמש כדי לספק רמזים לזמן הריצה לגבי הישויות והנתונים שצריך לכלול בתמונת המצב, כפי שהם נמדדים על ידי ההגדרה הנוכחית של ההקשר המרחבי (ולכן ההגדרה הנוכחית של השירותים הבסיסיים).

  • אם תוסף מגדיר XrSpatialCapabilityEXT חדש,

  • אם תוסף מגדיר XrSpatialCapabilityFeatureEXT חדש, הוא חייב גם להגדיר מבנה תצורה תואם שאפשר לשרשר למצביע הבא של XrSpatialCapabilityConfigurationBaseHeaderEXT , שהאפליקציה יכולה להשתמש בו כדי להפעיל את התכונה בזמן יצירת XrSpatialContextEXT .

  • תוסף שמגדיר XrSpatialCapabilityEXT חדש צריך לפעול לפי התבנית הזו של המפרט:

    • סקירה כללית
    • תמיכה בסביבת זמן ריצה
    • הגדרות אישיות
    • רכיבים מובטחים
    • קוד לדוגמה

  • תוסף שמגדיר XrSpatialComponentTypeEXT חדש צריך לפעול לפי התבנית הזו למפרט –

    • נתוני רכיבים
    • מבנה רשימת הרכיבים לשאילתת נתונים
    • הגדרות אישיות

  • כשכותבים API שמספק לאפליקציה XrSpatialBufferIdEXT, חובה לצרף אליו XrSpatialBufferTypeEXT כדי ליידע את האפליקציה מהו סוג הנתונים של המאגר, והאפליקציה יכולה להשתמש בפונקציה xrGetSpatialBuffer* מתאימה כדי לאחזר את התוכן בפועל של המאגר.

הנחיות לעיצוב ולהרחבה של תוויות סמנטיות

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

  • אם תוסף מגדיר תוויות סמנטיות ל-XrSpatialCapabilityEXT כלשהו, הוא צריך לעשות זאת על ידי הגדרת XrSpatialComponentTypeEXT חדש וגם ספירה חדשה עם קבוצת תוויות ("קבוצת תוויות סמנטיות") שתהיה הנתונים של הרכיב הזה.
  • בספירה שמייצגת קבוצת תוויות סמנטיות חייב להיות ערך שמציין שהישות לא מסווגת לאף אחת מהתוויות בקבוצה הזו. השם של הערך הזה חייב לכלול את המילה "UNCATEGORIZED", למשל XR_SPATIAL_PLANE_SEMANTIC_LABEL_UNCATEGORIZED_EXT. הערך הזה מציין לאפליקציות שסביבת זמן הריצה מזהה את הישות הזו, אבל יש קבוצות אחרות של תוויות סמנטיות שבהן הישות הזו מסווגת.
  • ספירה של XrSpatialComponentTypeEXT החדש שהוגדר ב-xrEnumerateSpatialCapabilityComponentTypesEXT מציינת שזמן הריצה תומך בקבוצת התוויות הסמנטיות (ולכן בתוויות שהוגדרו בקבוצה) שתואמת לסוג הרכיב הזה.
  • אפליקציות מבטאות את הרצון שלהן לגלות ישויות שיש להן תוויות ששייכות לקבוצת התוויות הסמנטיות הזו על ידי הכללת ה-XrSpatialComponentTypeEXT המתאים במערך XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents של מבנה ההגדרות של היכולת שסוג הרכיב מופיע בה.
  • יכול להיות שלישות מרחבית אחת יש כמה רכיבים, וכל אחד מהם מספק לה תווית מקבוצת התוויות הסמנטיות שלו. נניח שיש לנו קבוצות של תוויות סמנטיות היפותטיות – XrSpatialObjectSemanticLabel , שיכולות להיות להן ערכים כמו כיסא, ספה, שולחן וכו', XrSpatialSofaBrand, שיכול להכיל ערכים כמו איקאה, Wayfair וכו', ו-XrSpatialIkeaSofa, שיכול להכיל שמות ספציפיים של דגמי ספות של איקאה. בתרחיש הזה, אותה ישות של ספה כוללת את כל 3 הרכיבים (תוויות מכל 3 קבוצות התוויות הסמנטיות), וכל אחד מהם מספק רמת פירוט שונה של מידע על הישות.
  • אם תוסף מגדיר XrSpatialComponentTypeEXT חדש שמספק קבוצת תוויות סמנטיות חדשה שמכילה כמה תוויות בנוסף לתווית UNCATEGORIZED, התוסף צריך להגדיר XrSpatialCapabilityFeatureEXT שמאפשר לאפליקציות להפעיל רק קבוצת משנה של התוויות שמוגדרות בקבוצת התוויות הסמנטיות שתואמת לסוג הרכיב הזה. קבוצת המשנה הזו, שמופיעה בשרשרת הבאה של הגדרת היכולות, משמשת כרמז לסביבות זמן הריצה כדי לבצע אופטימיזציה של צינורות עיבוד הנתונים למעקב, ולעקוב רק אחרי קבוצת המשנה שסופקה. בהמשך מוצגת דוגמה למבנה של תכונה כזו.
  • תוספים לא יכולים להוסיף תוויות למערך קיים של תוויות סמנטיות. במקום זאת, הם חייבים להגדיר ספירה חדשה שמכילה ספירות מקבילות עם סמנטיקה זהה ועם ערכים שווים לאלה מהקבוצה השנייה, בנוסף לספירות החדשות שנוספו. המפרט של קבוצת התוויות הסמנטיות החדשה חייב גם להגדיר את המיפוי בין קבוצת התוויות הישנה לחדשה. לדוגמה:
דוגמה להגדרה של תכונה מרחבית לקבוצת משנה של תוויות סמנטיות
// New example semantic label set.
typedef enum XrSpatialExampleSemanticLabelEXT {
  // ... label values
} XrSpatialExampleSemanticLabelEXT;

/*
typedef enum XrSpatialCapabilityFeatureEXT {
  // .. existing values

  // new spatial feature value
  XR_SPATIAL_CAPABILITY_FEATURE_EXAMPLE_SEMANTIC_LABEL_SUBSET_EXT

  // .. existing values
} XrSpatialCapabilityFeatureEXT;
*/

// New spatial feaure configuration structure
typedef struct XrSpatialFeatureExampleSemanticLabelSubsetEXT {
    XrStructureType                             type;
    const void* XR_MAY_ALIAS                    next;
    uint32_t                                    semanticLabelCount;
    const XrSpatialExampleSemanticLabelEXT*     semanticLabels;
} XrSpatialFeatureExampleSemanticLabelSubsetEXT;
דוגמה לתוסף תווית סמנטית מרחבית
typedef enum XrSpatialExamplePlaneSemanticLabelExtensionEXT {
    XR_SPATIAL_EXAMPLE_PLANE_SEMANTIC_LABEL_EXTENSION_UNCATEGORIZED_EXT = 1,
    XR_SPATIAL_EXAMPLE_PLANE_SEMANTIC_LABEL_EXTENSION_FLOOR_EXT = 2,
    XR_SPATIAL_EXAMPLE_PLANE_SEMANTIC_LABEL_EXTENSION_WALL_EXT = 3,
    XR_SPATIAL_EXAMPLE_PLANE_SEMANTIC_LABEL_EXTENSION_CEILING_EXT = 4,
    XR_SPATIAL_EXAMPLE_PLANE_SEMANTIC_LABEL_EXTENSION_TABLE_EXT = 5,
    XR_SPATIAL_EXAMPLE_PLANE_SEMANTIC_LABEL_EXTENSION_DOOR_EXT = 6,
    XR_SPATIAL_EXAMPLE_PLANE_SEMANTIC_LABEL_EXTENSION_WINDOW_EXT = 7,
    XR_SPATIAL_EXAMPLE_PLANE_SEMANTIC_LABEL_EXTENSION_MAX_ENUM_EXT = 0x7FFFFFFF
} XrSpatialExamplePlaneSemanticLabelExtensionEXT;

נניח שבדוגמה שלמעלה, תוסף מגדיר את הספירה XrSpatialExamplePlaneSemanticLabelExtensionEXT כדי להרחיב את XrSpatialPlaneSemanticLabelEXT הקיים עם ערכים שמייצגים דלתות וחלונות. המפרט של הערך החדש חייב לכלול טקסט בפורמט הבא:

For all non-UNCATEGORIZED label enumerants in elink:XrSpatialPlaneSemanticLabelEXT,
the runtime must: return that enumerant if and only if it returns the corresponding
label enumerant from elink:XrSpatialExamplePlaneSemanticLabelExtensionEXT with the same value
i.e.
the ename:XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT value for that entity must:
correspond with the ename:XR_SPATIAL_COMPONENT_TYPE_EXAMPLE_PLANE_SEMANTIC_LABEL_EXTENSION_EXT values
according to the following table -

[width="100%",options="header"]
|====
| XrSpatialExamplePlaneSemanticLabelExtensionEXT                | XrSpatialPlaneSemanticLabelEXT
| XR_SPATIAL_EXAMPLE_PLANE_SEMANTIC_LABEL_EXTENSION_FLOOR_EXT   | XR_SPATIAL_PLANE_SEMANTIC_LABEL_FLOOR_EXT
| XR_SPATIAL_EXAMPLE_PLANE_SEMANTIC_LABEL_EXTENSION_WALL_EXT    | XR_SPATIAL_PLANE_SEMANTIC_LABEL_WALL_EXT
| XR_SPATIAL_EXAMPLE_PLANE_SEMANTIC_LABEL_EXTENSION_CEILING_EXT | XR_SPATIAL_PLANE_SEMANTIC_LABEL_CEILING_EXT
| XR_SPATIAL_EXAMPLE_PLANE_SEMANTIC_LABEL_EXTENSION_TABLE_EXT   | XR_SPATIAL_PLANE_SEMANTIC_LABEL_TABLE_EXT
| XR_SPATIAL_EXAMPLE_PLANE_SEMANTIC_LABEL_EXTENSION_DOOR_EXT    | XR_SPATIAL_PLANE_SEMANTIC_LABEL_UNCATEGORIZED_EXT
| XR_SPATIAL_EXAMPLE_PLANE_SEMANTIC_LABEL_EXTENSION_WINDOW_EXT  | XR_SPATIAL_PLANE_SEMANTIC_LABEL_UNCATEGORIZED_EXT
|====

פקודות מאקרו חדשות

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

  • XrSpatialBufferIdEXT
  • XrSpatialEntityIdEXT

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

פקודות חדשות

מבנים חדשים

ערכי Enums חדשים

קבועי Enum חדשים

  • XR_EXT_SPATIAL_ENTITY_EXTENSION_NAME
  • XR_EXT_spatial_entity_SPEC_VERSION

  • הרחבה של XrObjectType :

    • XR_OBJECT_TYPE_SPATIAL_CONTEXT_EXT
    • XR_OBJECT_TYPE_SPATIAL_ENTITY_EXT
    • XR_OBJECT_TYPE_SPATIAL_SNAPSHOT_EXT

  • הרחבת XrResult :

    • XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT
    • XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT
    • XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT
    • XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT
    • XR_ERROR_SPATIAL_COMPONENT_UNSUPPORTED_FOR_CAPABILITY_EXT
    • XR_ERROR_SPATIAL_ENTITY_ID_INVALID_EXT

  • הרחבה של XrStructureType :

    • XR_TYPE_CREATE_SPATIAL_CONTEXT_COMPLETION_EXT
    • XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_EXT
    • XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_INFO_EXT
    • XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT
    • XR_TYPE_SPATIAL_BUFFER_GET_INFO_EXT
    • XR_TYPE_SPATIAL_CAPABILITY_COMPONENT_TYPES_EXT
    • XR_TYPE_SPATIAL_COMPONENT_BOUNDED_2D_LIST_EXT
    • XR_TYPE_SPATIAL_COMPONENT_BOUNDED_3D_LIST_EXT
    • XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_CONDITION_EXT
    • XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_RESULT_EXT
    • XR_TYPE_SPATIAL_COMPONENT_MESH_3D_LIST_EXT
    • XR_TYPE_SPATIAL_COMPONENT_PARENT_LIST_EXT
    • XR_TYPE_SPATIAL_CONTEXT_CREATE_INFO_EXT
    • XR_TYPE_SPATIAL_DISCOVERY_SNAPSHOT_CREATE_INFO_EXT
    • XR_TYPE_SPATIAL_ENTITY_FROM_ID_CREATE_INFO_EXT
    • XR_TYPE_SPATIAL_FILTER_TRACKING_STATE_EXT
    • XR_TYPE_SPATIAL_UPDATE_SNAPSHOT_CREATE_INFO_EXT

בעיות

  • האם ישות אחת תמיד נובעת מיכולת אחת בלבד?

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

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

  • גרסה 1, 12.04.2024 (Nihav Jain, Google)

    • תיאור התוסף הראשוני