XR_EXT_spatial_plane_tracking

नाम स्ट्रिंग

XR_EXT_spatial_plane_tracking

एक्सटेंशन का टाइप

इंस्टेंस एक्सटेंशन

रजिस्टर किए गए एक्सटेंशन का नंबर

742

संशोधन

1

पुष्टि की स्थिति

पुष्टि की गई

एक्सटेंशन और वर्शन की डिपेंडेंसी

XR_EXT_spatial_entity

योगदान देने वाले

निहाव जैन, Google
नताली फ़्लूरी, Meta
युइची तागुची, Meta
रॉन बेसेम्स, Meta
यिन ली, Microsoft
जिम्मी अलमपरामबिल, ByteDance
ज़िपेंग लियू, ByteDance
जून यान, ByteDance

खास जानकारी

यह एक्सटेंशन, XR_EXT_spatial_entity पर आधारित है. साथ ही, यह स्पेशल एंटिटी फ़्रेमवर्क के लिए, प्लेन ट्रैकिंग की स्पेशल सुविधा तय करता है.

रनटाइम की सुविधा

अगर रनटाइम में प्लेन ट्रैकिंग की सुविधा उपलब्ध है, तो xrEnumerateSpatialCapabilitiesEXT में XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT को शामिल करके, यह जानकारी ज़रूर दी जानी चाहिए .

कॉन्फ़िगरेशन

XrSpatialCapabilityConfigurationPlaneTrackingEXT स्ट्रक्चर को इस तरह तय किया गया है:

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

सदस्यों की जानकारी

• type, इस स्ट्रक्चर का XrStructureType है.
• next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
• capability एक XrSpatialCapabilityEXT है और यह XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT ज़रूर होना चाहिए .
• enabledComponentCount, एक uint32_t है. इससे enabledComponents अरे में मौजूद एलिमेंट की संख्या के बारे में पता चलता है.
• enabledComponents , XrSpatialComponentTypeEXT के अरे का पॉइंटर है .

ऐप्लिकेशन, XrSpatialContextCreateInfoEXT :: capabilityConfigs में, XrSpatialCapabilityConfigurationPlaneTrackingEXT स्ट्रक्चर का पॉइंटर शामिल करके, XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT स्पेशल केपबिलिटी को चालू कर सकते हैं .

अगर capability, XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT नहीं है, तो रनटाइम को XR_ERROR_VALIDATION_FAILURE लौटाना होगा .

मान्य इस्तेमाल (सीधे तौर पर न दिखाना)

• XR_EXT_spatial_plane_tracking एक्सटेंशन चालू होना चाहिए, इससे पहले कि XrSpatialCapabilityConfigurationPlaneTrackingEXT का इस्तेमाल किया जा सके
• , type ज़रूर होना चाहिए XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_PLANE_TRACKING_EXT
• next NULL होना चाहिए या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
• capability XrSpatialCapabilityEXT की मान्य वैल्यू ज़रूर होनी चाहिए
• enabledComponents ज़रूर enabledComponentCount मान्य XrSpatialComponentTypeEXT वैल्यू के अरे का पॉइंटर होना चाहिए
• enabledComponentCount पैरामीटर, 0 से बड़ा ज़रूर होना चाहिए

गारंटी वाले कॉम्पोनेंट

ऐसे रनटाइम में XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT की सुविधा ज़रूर होनी चाहिए. साथ ही, इस सुविधा से खोजी गई सभी एंटिटी के लिए, ये स्पेशल कॉम्पोनेंट गारंटी वाले कॉम्पोनेंट के तौर पर ज़रूर उपलब्ध होने चाहिए. इसके अलावा, xrEnumerateSpatialCapabilityComponentTypesEXT में इन्हें ज़रूर शामिल किया जाना चाहिए :

• XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT
• XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT

बाउंडेड 2D कॉम्पोनेंट

बाउंडेड 2D कॉम्पोनेंट, उस प्लेन का सेंटर और एक्सटेंट उपलब्ध कराता है जिस पर एंटिटी मौजूद है. ज़्यादा जानकारी के लिए, बाउंडेड 2D देखें.

प्लेन अलाइनमेंट कॉम्पोनेंट

कॉम्पोनेंट का डेटा

typedef enum XrSpatialPlaneAlignmentEXT {
    XR_SPATIAL_PLANE_ALIGNMENT_HORIZONTAL_UPWARD_EXT = 0,
    XR_SPATIAL_PLANE_ALIGNMENT_HORIZONTAL_DOWNWARD_EXT = 1,
    XR_SPATIAL_PLANE_ALIGNMENT_VERTICAL_EXT = 2,
    XR_SPATIAL_PLANE_ALIGNMENT_ARBITRARY_EXT = 3,
    XR_SPATIAL_PLANE_ALIGNMENT_MAX_ENUM_EXT = 0x7FFFFFFF
} XrSpatialPlaneAlignmentEXT;

XrSpatialPlaneAlignmentEXT एन्यूमरेशन, स्पेशल एंटिटी से जुड़े प्लेन के अलाइनमेंट के बारे में बताता है जिसमें एक XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT कॉम्पोनेंट होता है.

एन्यूमरेशन की वैल्यू का मतलब यहां दिया गया है:

Enum की जानकारी

XR_SPATIAL_PLANE_ALIGNMENT_HORIZONTAL_UPWARD_EXT

एंटिटी हॉरिज़ॉन्टल है और ऊपर की ओर है (जैसे, फ़्लोर).

XR_SPATIAL_PLANE_ALIGNMENT_HORIZONTAL_DOWNWARD_EXT

एंटिटी हॉरिज़ॉन्टल है और नीचे की ओर है (जैसे, सीलिंग).

XR_SPATIAL_PLANE_ALIGNMENT_VERTICAL_EXT

एंटिटी वर्टिकल है (जैसे, दीवार).

XR_SPATIAL_PLANE_ALIGNMENT_ARBITRARY_EXT

एंटिटी का ओरिएंटेशन आर्बिट्ररी है. यह न तो वर्टिकल है और न ही हॉरिज़ॉन्टल.

डेटा क्वेरी करने के लिए कॉम्पोनेंट की सूची का स्ट्रक्चर

XrSpatialComponentPlaneAlignmentListEXT स्ट्रक्चर को इस तरह तय किया गया है:

typedef struct XrSpatialComponentPlaneAlignmentListEXT {
    XrStructureType                type;
    void*                          next;
    uint32_t                       planeAlignmentCount;
    XrSpatialPlaneAlignmentEXT*    planeAlignments;
} XrSpatialComponentPlaneAlignmentListEXT;

सदस्यों की जानकारी

• type, इस स्ट्रक्चर का XrStructureType है.
• next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
• planeAlignmentCount, एक uint32_t है. इससे planeAlignments अरे में मौजूद एलिमेंट की संख्या के बारे में पता चलता है.
• planeAlignments XrSpatialPlaneAlignmentEXT का अरे है .

XrSpatialSnapshotEXT में मौजूद स्पेशल एंटिटी के प्लेन अलाइनमेंट कॉम्पोनेंट की क्वेरी करने के लिए, XrSpatialComponentDataQueryConditionEXT :: componentTypes में XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT शामिल करें. साथ ही, XrSpatialComponentDataQueryResultEXT :: next चेन में XrSpatialComponentPlaneAlignmentListEXT जोड़ें.

अगर XrSpatialComponentPlaneAlignmentListEXT, XrSpatialComponentDataQueryResultEXT :: next चेन में है, लेकिन XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT XrSpatialComponentDataQueryConditionEXT :: componentTypes में शामिल नहीं है, तो रनटाइम को xrQuerySpatialComponentDataEXT से XR_ERROR_VALIDATION_FAILURE लौटाना होगा .

अगर planeAlignmentCount, XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput से कम है, तो रनटाइम को xrQuerySpatialComponentDataEXT से XR_ERROR_SIZE_INSUFFICIENT लौटाना होगा .

मान्य इस्तेमाल (सीधे तौर पर न दिखाना)

• XrSpatialComponentPlaneAlignmentListEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_plane_tracking एक्सटेंशन चालू होना चाहिए
• , type ज़रूर होना चाहिए XR_TYPE_SPATIAL_COMPONENT_PLANE_ALIGNMENT_LIST_EXT
• next होना चाहिए NULL या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
• planeAlignments ज़रूर planeAlignmentCount XrSpatialPlaneAlignmentEXT वैल्यू के अरे का पॉइंटर होना चाहिए
• planeAlignmentCount पैरामीटर, 0 से बड़ा ज़रूर होना चाहिए

कॉन्फ़िगरेशन

अगर किसी सुविधा के लिए, XrSpatialCapabilityComponentTypesEXT :: componentTypes में XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT शामिल है, तो कोई ऐप्लिकेशन इसे चालू कर सकता है. इसके लिए, उसे XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents की सूची में, XrSpatialCapabilityConfigurationBaseHeaderEXT से मिले उस स्ट्रक्चर का एन्यूमरेंट शामिल करना होगा जिसमें यह कॉम्पोनेंट काम करता है.

XrSpatialCapabilityConfigurationBaseHeaderEXT :: next चेन में शामिल करने के लिए, इस कॉम्पोनेंट को किसी खास कॉन्फ़िगरेशन की ज़रूरत नहीं होती.

वैकल्पिक कॉम्पोनेंट

ऐसा हो सकता है कि XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT की सुविधा वाले रनटाइम में, गारंटी वाले कॉम्पोनेंट सेक्शन में शामिल कॉम्पोनेंट के अलावा, अन्य स्पेशल कॉम्पोनेंट भी उपलब्ध हों. कोई ऐप्लिकेशन, xrEnumerateSpatialCapabilityComponentTypesEXT का इस्तेमाल करके, उन कॉम्पोनेंट की पूरी सूची हासिल करता है जो किसी रनटाइम में उपलब्ध हैं. इसके बाद, स्पेशल कॉन्टेक्स्ट बनाते समय, उन कॉम्पोनेंट को कॉन्फ़िगर करता है जिनमें उसकी दिलचस्पी होती है.

मेश 2D कॉम्पोनेंट

कॉम्पोनेंट का डेटा

XR_SPATIAL_COMPONENT_TYPE_MESH_2D_EXT अपने डेटा के लिए, XrSpatialMeshDataEXT स्ट्रक्चर का इस्तेमाल करता है.

डेटा क्वेरी करने के लिए कॉम्पोनेंट की सूची का स्ट्रक्चर

XrSpatialComponentMesh2DListEXT स्ट्रक्चर को इस तरह तय किया गया है:

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

सदस्यों की जानकारी

• type, इस स्ट्रक्चर का XrStructureType है.
• next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
• meshCount, एक uint32_t है. इससे meshes अरे में मौजूद एलिमेंट की संख्या के बारे में पता चलता है.
• meshes , XrSpatialMeshDataEXT का अरे है .

XrSpatialSnapshotEXT में मौजूद स्पेशल एंटिटी के मेश 2D कॉम्पोनेंट की क्वेरी करने के लिए, XrSpatialComponentDataQueryConditionEXT :: componentTypes में XR_SPATIAL_COMPONENT_TYPE_MESH_2D_EXT शामिल करें. साथ ही, XrSpatialComponentDataQueryResultEXT :: next चेन में XrSpatialComponentMesh2DListEXT जोड़ें.

अगर XrSpatialComponentMesh2DListEXT, XrSpatialComponentDataQueryResultEXT :: next चेन में है, लेकिन XR_SPATIAL_COMPONENT_TYPE_MESH_2D_EXT XrSpatialComponentDataQueryConditionEXT :: componentTypes में शामिल नहीं है, तो रनटाइम को xrQuerySpatialComponentDataEXT से XR_ERROR_VALIDATION_FAILURE लौटाना होगा .

अगर meshCount, XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput से कम है, तो रनटाइम को xrQuerySpatialComponentDataEXT से XR_ERROR_SIZE_INSUFFICIENT लौटाना होगा .

`meshes` अरे में रनटाइम से भरे गए `XrSpatialMeshDataEXT` के लिए, `XrSpatialMeshDataEXT` :: `vertexBuffer` का `XrSpatialBufferEXT` :: `bufferType`, `XR_SPATIAL_BUFFER_TYPE_VECTOR2F_EXT` `ज़रूर` होना चाहिए. साथ ही, `XrSpatialMeshDataEXT` :: `indexBuffer` का `XrSpatialBufferEXT` :: `bufferType`, `XR_SPATIAL_BUFFER_TYPE_UINT16_EXT` `ज़रूर` होना चाहिए.

मान्य इस्तेमाल (सीधे तौर पर न दिखाना)

• XrSpatialComponentMesh2DListEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_plane_tracking एक्सटेंशन चालू होना चाहिए
• , type XR_TYPE_SPATIAL_COMPONENT_MESH_2D_LIST_EXT ज़रूर होना चाहिए
• next NULL होना चाहिए या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
• meshes ज़रूर meshCount XrSpatialMeshDataEXT स्ट्रक्चर के अरे का पॉइंटर होना चाहिए
• meshCount पैरामीटर, 0 से बड़ा ज़रूर होना चाहिए

कॉन्फ़िगरेशन

अगर किसी सुविधा के लिए, XrSpatialCapabilityComponentTypesEXT :: componentTypes में XR_SPATIAL_COMPONENT_TYPE_MESH_2D_EXT शामिल है, तो कोई ऐप्लिकेशन इसे चालू कर सकता है. इसके लिए, उसे XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents की सूची में, XrSpatialCapabilityConfigurationBaseHeaderEXT से मिले उस स्ट्रक्चर का एन्यूमरेंट शामिल करना होगा जिसमें यह कॉम्पोनेंट काम करता है.

XrSpatialCapabilityConfigurationBaseHeaderEXT :: next चेन में शामिल करने के लिए, इस कॉम्पोनेंट को किसी खास कॉन्फ़िगरेशन की ज़रूरत नहीं होती.

पॉलीगॉन 2D कॉम्पोनेंट

कॉम्पोनेंट का डेटा

XrSpatialPolygon2DDataEXT स्ट्रक्चर को इस तरह तय किया गया है:

typedef struct XrSpatialPolygon2DDataEXT {
    XrPosef               origin;
    XrSpatialBufferEXT    vertexBuffer;
} XrSpatialPolygon2DDataEXT;

सदस्यों की जानकारी

• origin एक XrPosef है. इससे पॉलीगॉन के ऑरिजिन के बारे में पता चलता है. पॉलीगॉन के सभी वर्टिकल, X-Y प्लेन में इस ऑरिजिन के हिसाब से होते हैं.
• vertexBuffer एक XrSpatialBufferEXT है. इससे XR_SPATIAL_BUFFER_TYPE_VECTOR2F_EXT टाइप के बफ़र का आईडी मिलता है. साथ ही, यह उस एंटिटी के वर्टेक्स बफ़र को दिखाता है जिस पर यह कॉम्पोनेंट मौजूद है. वर्टिकल, काउंटर-क्लॉकवाइज़ क्रम में लौटाए जाने चाहिए. इन वर्टिकल से दिखने वाला पॉलीगॉन, एक-दूसरे को नहीं काटना चाहिए. हालांकि, यह कॉनकेव हो सकता है.

vertexBuffer के लिए, XrSpatialBufferEXT :: bufferType, XR_SPATIAL_BUFFER_TYPE_VECTOR2F_EXT ज़रूर होना चाहिए .

मान्य इस्तेमाल (सीधे तौर पर न दिखाना)

• XrSpatialPolygon2DDataEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_plane_tracking एक्सटेंशन चालू होना चाहिए
• vertexBuffer ज़रूर XrSpatialBufferEXT का मान्य स्ट्रक्चर होना चाहिए

डेटा क्वेरी करने के लिए कॉम्पोनेंट की सूची का स्ट्रक्चर

XrSpatialComponentPolygon2DListEXT स्ट्रक्चर को इस तरह तय किया गया है:

typedef struct XrSpatialComponentPolygon2DListEXT {
    XrStructureType               type;
    void*                         next;
    uint32_t                      polygonCount;
    XrSpatialPolygon2DDataEXT*    polygons;
} XrSpatialComponentPolygon2DListEXT;

सदस्यों की जानकारी

• type, इस स्ट्रक्चर का XrStructureType है.
• next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
• polygonCount, एक uint32_t है. इससे polygons अरे में मौजूद एलिमेंट की संख्या के बारे में पता चलता है.
• polygons , XrSpatialPolygon2DDataEXT का अरे है .

XrSpatialSnapshotEXT में मौजूद स्पेशल एंटिटी के पॉलीगॉन 2D कॉम्पोनेंट की क्वेरी करने के लिए, XrSpatialComponentDataQueryConditionEXT :: componentTypes में XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT शामिल करें. साथ ही, XrSpatialComponentDataQueryResultEXT :: next चेन में XrSpatialComponentPolygon2DListEXT जोड़ें.

अगर XrSpatialComponentPolygon2DListEXT, XrSpatialComponentDataQueryResultEXT :: next चेन में है, लेकिन XrSpatialComponentDataQueryConditionEXT :: componentTypes में XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT शामिल नहीं है, तो रनटाइम को xrQuerySpatialComponentDataEXT से XR_ERROR_VALIDATION_FAILURE लौटाना होगा .

अगर polygonCount , XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput से कम है, तो रनटाइम को xrQuerySpatialComponentDataEXT से XR_ERROR_SIZE_INSUFFICIENT लौटाना होगा .

मान्य इस्तेमाल (सीधे तौर पर न दिखाना)

• XrSpatialComponentPolygon2DListEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_plane_tracking एक्सटेंशन चालू होना चाहिए
• , type ज़रूर होना चाहिए XR_TYPE_SPATIAL_COMPONENT_POLYGON_2D_LIST_EXT
• next होना चाहिए NULL या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
• polygons ज़रूर polygonCount XrSpatialPolygon2DDataEXT स्ट्रक्चर के अरे का पॉइंटर होना चाहिए
• polygonCount पैरामीटर, 0 से बड़ा ज़रूर होना चाहिए

कॉन्फ़िगरेशन

अगर किसी सुविधा के लिए, XrSpatialCapabilityComponentTypesEXT :: componentTypes में XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT शामिल है, तो कोई ऐप्लिकेशन इसे चालू कर सकता है. इसके लिए, उसे XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents की सूची में, XrSpatialCapabilityConfigurationBaseHeaderEXT से मिले उस स्ट्रक्चर का एन्यूमरेंट शामिल करना होगा जिसमें यह कॉम्पोनेंट काम करता है.

XrSpatialCapabilityConfigurationBaseHeaderEXT :: next चेन में शामिल करने के लिए, इस कॉम्पोनेंट को किसी खास कॉन्फ़िगरेशन की ज़रूरत नहीं होती.

प्लेन सिमैंटिक लेबल

कॉम्पोनेंट का डेटा

typedef enum XrSpatialPlaneSemanticLabelEXT {
    XR_SPATIAL_PLANE_SEMANTIC_LABEL_UNCATEGORIZED_EXT = 1,
    XR_SPATIAL_PLANE_SEMANTIC_LABEL_FLOOR_EXT = 2,
    XR_SPATIAL_PLANE_SEMANTIC_LABEL_WALL_EXT = 3,
    XR_SPATIAL_PLANE_SEMANTIC_LABEL_CEILING_EXT = 4,
    XR_SPATIAL_PLANE_SEMANTIC_LABEL_TABLE_EXT = 5,
    XR_SPATIAL_PLANE_SEMANTIC_LABEL_MAX_ENUM_EXT = 0x7FFFFFFF
} XrSpatialPlaneSemanticLabelEXT;

XrSpatialPlaneSemanticLabelEXT एन्यूमरेशन, प्लेन के लिए सिमैंटिक लेबल का सेट तय करता है.

Enum की जानकारी

XR_SPATIAL_PLANE_SEMANTIC_LABEL_UNCATEGORIZED_EXT

रनटाइम, इस एंटिटी को कैटगरी में नहीं डाल पाया.

XR_SPATIAL_PLANE_SEMANTIC_LABEL_FLOOR_EXT

एंटिटी, फ़्लोर है.

XR_SPATIAL_PLANE_SEMANTIC_LABEL_WALL_EXT

एंटिटी, दीवार है.

XR_SPATIAL_PLANE_SEMANTIC_LABEL_CEILING_EXT

एंटिटी, सीलिंग है.

XR_SPATIAL_PLANE_SEMANTIC_LABEL_TABLE_EXT

एंटिटी, टेबल है.

डेटा क्वेरी करने के लिए कॉम्पोनेंट की सूची का स्ट्रक्चर

XrSpatialComponentPlaneSemanticLabelListEXT स्ट्रक्चर को इस तरह तय किया गया है:

typedef struct XrSpatialComponentPlaneSemanticLabelListEXT {
    XrStructureType                    type;
    void*                              next;
    uint32_t                           semanticLabelCount;
    XrSpatialPlaneSemanticLabelEXT*    semanticLabels;
} XrSpatialComponentPlaneSemanticLabelListEXT;

सदस्यों की जानकारी

• type, इस स्ट्रक्चर का XrStructureType है.
• next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
• semanticLabelCount, एक uint32_t है. इससे semanticLabels अरे में मौजूद एलिमेंट की संख्या के बारे में पता चलता है.
• semanticLabels XrSpatialPlaneSemanticLabelEXT का अरे है .

XrSpatialSnapshotEXT में मौजूद स्पेशल एंटिटी के प्लेन सिमैंटिक लेबल कॉम्पोनेंट की क्वेरी करने के लिए, XrSpatialComponentDataQueryConditionEXT :: componentTypes में XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT शामिल करें. साथ ही, XrSpatialComponentDataQueryResultEXT :: next चेन में XrSpatialComponentPlaneSemanticLabelListEXT जोड़ें.

अगर XrSpatialComponentPlaneSemanticLabelListEXT, XrSpatialComponentDataQueryResultEXT :: next की अगली चेन में है, लेकिन XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT XrSpatialComponentDataQueryConditionEXT :: componentTypes में शामिल नहीं है, तो रनटाइम को xrQuerySpatialComponentDataEXT से XR_ERROR_VALIDATION_FAILURE लौटाना होगा .

अगर semanticLabelCount, XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput से कम है, तो रनटाइम को xrQuerySpatialComponentDataEXT से XR_ERROR_SIZE_INSUFFICIENT लौटाना होगा .

मान्य इस्तेमाल (सीधे तौर पर न दिखाना)

• XrSpatialComponentPlaneSemanticLabelListEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_plane_tracking एक्सटेंशन चालू होना चाहिए
• , type ज़रूर होना चाहिए XR_TYPE_SPATIAL_COMPONENT_PLANE_SEMANTIC_LABEL_LIST_EXT
• next होना चाहिए NULL या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
• semanticLabels ज़रूर semanticLabelCount XrSpatialPlaneSemanticLabelEXT वैल्यू के अरे का पॉइंटर होना चाहिए
• semanticLabelCount पैरामीटर, 0 से बड़ा ज़रूर होना चाहिए

कॉन्फ़िगरेशन

अगर किसी सुविधा के लिए, XrSpatialCapabilityComponentTypesEXT :: componentTypes में XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT शामिल है, तो कोई ऐप्लिकेशन इसे चालू कर सकता है. इसके लिए, उसे XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents की सूची में, XrSpatialCapabilityConfigurationBaseHeaderEXT से मिले उस स्ट्रक्चर का एन्यूमरेंट शामिल करना होगा जिसमें यह कॉम्पोनेंट काम करता है.

XrSpatialCapabilityConfigurationBaseHeaderEXT :: next चेन में शामिल करने के लिए, इस कॉम्पोनेंट को किसी खास कॉन्फ़िगरेशन की ज़रूरत नहीं होती.

कोड का उदाहरण

प्लेन ट्रैकिंग की सुविधा कॉन्फ़िगर करना

यहां दिए गए कोड के उदाहरण में, स्पेशल कॉन्टेक्स्ट बनाते समय, प्लेन ट्रैकिंग की सुविधा को कॉन्फ़िगर करने का तरीका बताया गया है.

// Check if plane tracking capability is supported
uint32_t capabilityCount;
CHK_XR(xrEnumerateSpatialCapabilitiesEXT(instance, systemId, 0, &capabilityCount, nullptr));
std::vector<XrSpatialCapabilityEXT> capabilities(capabilityCount);
CHK_XR(xrEnumerateSpatialCapabilitiesEXT(instance, systemId, capabilityCount, &capabilityCount, capabilities.data()));

if (std::find(capabilities.begin(), capabilities.end(), XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT) == capabilities.end()) {
  return;
}

// Enumerate supported components for plane tracking capability
XrSpatialCapabilityComponentTypesEXT planeComponents{XR_TYPE_SPATIAL_CAPABILITY_COMPONENT_TYPES_EXT};
CHK_XR(xrEnumerateSpatialCapabilityComponentTypesEXT(instance, systemId, XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT, &planeComponents));
std::vector<XrSpatialComponentTypeEXT> planeCapabilityComponents(planeComponents.componentTypeCountOutput);
planeComponents.componentTypeCapacityInput = planeCapabilityComponents.size();
planeComponents.componentTypes = planeCapabilityComponents.data();
CHK_XR(xrEnumerateSpatialCapabilityComponentTypesEXT(instance, systemId, XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT, &planeComponents));

// Check if polygon 2D and plane semantic labels optional components are supported
const auto supportsComponent = [&planeCapabilityComponents](XrSpatialComponentTypeEXT component) {
  return std::find(planeCapabilityComponents.begin(), planeCapabilityComponents.end(), component) != planeCapabilityComponents.end();
};

const bool supportsPolygon2DComponent = supportsComponent(XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT);
const bool supportsSemanticLabelComponent = supportsComponent(XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT);

// Create a spatial context
XrSpatialContextEXT spatialContext{};

// Enable the 2 guaranteed components of the plane tracking capability
std::vector<XrSpatialComponentTypeEXT> enabledComponents = {
  XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT,
  XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT,
};
// Optionally enable polygon2D if it is supported
if (supportsPolygon2DComponent) {
  enabledComponents.push_back(XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT);
}
// Optionally enable semantic labels if it is supported
if (supportsSemanticLabelComponent) {
  enabledComponents.push_back(XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT);
}

XrSpatialCapabilityConfigurationPlaneTrackingEXT planeConfig{XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_PLANE_TRACKING_EXT};
planeConfig.capability = XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT;
planeConfig.enabledComponentCount = enabledComponents.size();
planeConfig.enabledComponents = enabledComponents.data();

std::array<XrSpatialCapabilityConfigurationBaseHeaderEXT*, 1> capabilityConfigs = {
  reinterpret_cast<XrSpatialCapabilityConfigurationBaseHeaderEXT*>(&planeConfig),
};

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;

// ...
// Discover entities with the spatial context
// ...

CHK_XR(xrDestroySpatialContextEXT(spatialContext));

स्पेशल एंटिटी खोजना और कॉम्पोनेंट डेटा की क्वेरी करना

यहां दिए गए कोड के उदाहरण में, XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT के साथ कॉन्फ़िगर किए गए कॉन्टेक्स्ट के लिए, स्पेशल एंटिटी खोजने और उसके कॉम्पोनेंट डेटा की क्वेरी करने का तरीका बताया गया है.

XrFutureEXT future = XR_NULL_FUTURE_EXT;

// We want to look for entities that have the following components.
std::vector<XrSpatialComponentTypeEXT> snapshotComponents = {
  XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT,
  XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT,
};
if (supportsPolygon2DComponent) {
  snapshotComponents.push_back(XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT);
}
if (supportsSemanticLabelComponent) {
  snapshotComponents.push_back(XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT);
}

auto discoverSpatialEntities = [&](XrSpatialContextEXT spatialContext, XrTime time) {
  XrSpatialDiscoverySnapshotCreateInfoEXT snapshotCreateInfo{XR_TYPE_SPATIAL_DISCOVERY_SNAPSHOT_CREATE_INFO_EXT};
  snapshotCreateInfo.componentTypeCount = snapshotComponents.size();
  snapshotCreateInfo.componentTypes = snapshotComponents.data();
  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 semantic label component data
    XrSpatialComponentDataQueryConditionEXT queryCond{XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_CONDITION_EXT};
    queryCond.componentTypeCount = snapshotComponents.size();
    queryCond.componentTypes = snapshotComponents.data();

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

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

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

    std::vector<XrSpatialPolygon2DDataEXT> polygons;
    XrSpatialComponentPolygon2DListEXT polygonList{XR_TYPE_SPATIAL_COMPONENT_POLYGON_2D_LIST_EXT};
    if (supportsPolygon2DComponent) {
      polygons.resize(queryResult.entityIdCountOutput);
      polygonList.polygonCount = polygons.size();
      polygonList.polygons = polygons.data();
      polygonList.next = queryResult.next;
      queryResult.next = &polygonList;
    }

    std::vector<XrSpatialPlaneSemanticLabelEXT> semanticLabels;
    XrSpatialComponentPlaneSemanticLabelListEXT semanticLabelsList{XR_TYPE_SPATIAL_COMPONENT_PLANE_SEMANTIC_LABEL_LIST_EXT};
    if (supportsSemanticLabelComponent) {
      semanticLabels.resize(queryResult.entityIdCountOutput);
      semanticLabelsList.semanticLabelCount = semanticLabels.size();
      semanticLabelsList.semanticLabels = semanticLabels.data();
      semanticLabelsList.next = queryResult.next;
      queryResult.next = &semanticLabelsList;
    }

    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) {
        continue;
      }

      // 2D bounds for entity entityIds[i] is bounded2D[i].extents centered on bounded2D[i].center.

      if (supportsPolygon2DComponent) {
        // 2D polygon for entity entityIds[i] is the buffer represented by polygons[i].bufferId.
        // Application uses flink:xrGetSpatialBufferVector2fEXT to get the buffer data.
      }

      if (supportsSemanticLabelComponent) {
        // semantic label for entity entityIds[i] is semanticLabels[i].
      }
    }

    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
  // ...
}

नए स्ट्रक्चर

• XrSpatialCapabilityConfigurationPlaneTrackingEXT
• XrSpatialPolygon2DDataEXT

• XrSpatialComponentDataQueryResultEXT को बढ़ाना :

  • XrSpatialComponentMesh2DListEXT
  • XrSpatialComponentPlaneAlignmentListEXT
  • XrSpatialComponentPlaneSemanticLabelListEXT
  • XrSpatialComponentPolygon2DListEXT

नए Enums

• XrSpatialPlaneAlignmentEXT
• XrSpatialPlaneSemanticLabelEXT

नए Enum कॉन्सटेंट

• XR_EXT_SPATIAL_PLANE_TRACKING_EXTENSION_NAME
• XR_EXT_spatial_plane_tracking_SPEC_VERSION

• XrSpatialCapabilityEXT को बढ़ाना :

  • XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT

• XrSpatialComponentTypeEXT को बढ़ाना :

  • XR_SPATIAL_COMPONENT_TYPE_MESH_2D_EXT
  • XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT
  • XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT
  • XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT

• XrStructureType को बढ़ाना :

  • XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_PLANE_TRACKING_EXT
  • XR_TYPE_SPATIAL_COMPONENT_MESH_2D_LIST_EXT
  • XR_TYPE_SPATIAL_COMPONENT_PLANE_ALIGNMENT_LIST_EXT
  • XR_TYPE_SPATIAL_COMPONENT_PLANE_SEMANTIC_LABEL_LIST_EXT
  • XR_TYPE_SPATIAL_COMPONENT_POLYGON_2D_LIST_EXT

समस्याएं

वर्शन हिस्ट्री

• संशोधन 1, 02-07-2024 (निहाव जैन, Google)

  • एक्सटेंशन की शुरुआती जानकारी