Android XR for OpenXR | Android Developers

Android Dev Summit फिर से शुरू हो गया है. इसमें Android XR के लिए खास तौर पर बनाया गया ट्रैक शामिल है. इन सुविधाओं को आज़माएं और हमें अपने सुझाव/राय दें या शिकायत करें!

Google आपकी पसंदीदा भाषा में कॉन्टेंट का अनुवाद करने के लिए, एआई टेक्नोलॉजी का इस्तेमाल करता है. एआई से मिले अनुवादों में गलतियां हो सकती हैं.

XR_EXT_spatial_plane_tracking

Name String

XR_EXT_spatial_plane_tracking

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

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

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

742

बदलाव

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

मंज़ूरी दी गई

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

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 के कलेक्शन का पॉइंटर है.

ऐप्लिकेशन, XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT स्पेशल सुविधा को चालू कर सकते हैं. इसके लिए, उन्हें XrSpatialContextCreateInfoEXT :: capabilityConfigs में XrSpatialCapabilityConfigurationPlaneTrackingEXT स्ट्रक्चर का पॉइंटर शामिल करना होगा.

अगर capability, XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT नहीं है, तो रनटाइम को XR_ERROR_VALIDATION_FAILURE दिखाना ज़रूरी है.

सही इस्तेमाल (इंप्लिसिट)

XrSpatialCapabilityConfigurationPlaneTrackingEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_plane_tracking एक्सटेंशन चालू करना ज़रूरी है
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

Bounded 2D Component

बाउंडेड 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 से बनाए गए स्ट्रक्चर की होती है.

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

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

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

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

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

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

XrSpatialBufferEXT :: bufferType के लिए vertexBuffer ज़रूरी है कि 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 चेन में है, लेकिन XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT, XrSpatialComponentDataQueryConditionEXT :: componentTypes में शामिल नहीं है, तो रनटाइम को 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 से बनाए गए स्ट्रक्चर की होती है.

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

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

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 से बनाए गए स्ट्रक्चर की होती है.

कोड का उदाहरण

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

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

// 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 को एक्सटेंड करना :

नए 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)
- एक्सटेंशन का शुरुआती ब्यौरा