XR_ANDROID_scene_meshing OpenXR एक्सटेंशन

Name String XR_ANDROID_scene_meshing

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

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

बदलाव 3

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

पिछली बार बदलाव किए जाने की तारीख 2025-05-15

आईपी की स्थिति आईपी के किसी भी दावे की जानकारी नहीं है.

योगदान देने वाले लोग स्पेंसर क्विन, Google जेरेड फ़ाइंडर, Google एंटोनियो फ़ॉन्टैन, Google केर्न ओवरटर्फ़, Google निहाव जैन, Google सलार ख़ान, Google सेबेस्टियन क्लोज़, Google जर्गन स्टर्म, Google विन्नी डिसिल्वा, Google रिकार्डो कैंपबेल, Google

खास जानकारी

इस एक्सटेंशन का मकसद, उन मेश के लिए मेश डेटा उपलब्ध कराना है जो आपके एनवायरमेंट में मौजूद फ़िज़िकल ऑब्जेक्ट को दिखाते हैं. इसका इस्तेमाल, इमर्सिव ऐप्लिकेशन में अपने सीन को विज़ुअलाइज़ करने के लिए किया जा सकता है. साथ ही, इसकी मदद से वर्चुअल ऑब्जेक्ट को फ़िज़िकल ऑब्जेक्ट के साथ इंटरैक्ट करने की अनुमति दी जा सकती है. जैसे, टकराव.

ध्यान दें: सीन मेश का डेटा, रनटाइम के ज़रिए जनरेट किया जाता है. इसे XrSceneMeshingTrackerANDROID और XrSceneMeshSnapshotANDROID का इस्तेमाल करके ऐप्लिकेशन के साथ शेयर किया जाता है. ऐप्लिकेशन, सीन सबमेश की जानकारी में मौजूद वैल्यू को ऐक्सेस कर सकते हैं. इसके लिए, उन्हें xrGetAllSubmeshStatesANDROID से मिले XrSceneSubmeshStateANDROID का इस्तेमाल करना होगा. ऐप्लिकेशन, सीन सबमेश डेटा में मौजूद वैल्यू को ऐक्सेस कर सकते हैं. इसके लिए, उन्हें xrGetSubmeshDataANDROID से मिले XrSceneSubmeshDataANDROID का इस्तेमाल करना होगा.

सीन मेशिंग का डेटा, संवेदनशील निजी जानकारी हो सकती है. यह निजी निजता और अखंडता से काफ़ी हद तक जुड़ा होता है. हमारा सुझाव है कि सीन मेशिंग डेटा को सेव या ट्रांसफ़र करने वाले ऐप्लिकेशन, उपयोगकर्ता से हमेशा इस काम के लिए अनुमति लें.

अनुमतियां

Android ऐप्लिकेशन के मेनिफ़ेस्ट में, android.permission.SCENE_UNDERSTANDING_FINE अनुमति का होना ज़रूरी है. android.permission.SCENE_UNDERSTANDING_FINE अनुमति को संवेदनशील अनुमति माना जाता है, क्योंकि इससे रनटाइम को उपयोगकर्ता के एनवायरमेंट के बारे में जानकारी मिलती है.

इन फ़ंक्शन का इस्तेमाल करने के लिए, ऐप्लिकेशन को रनटाइम के दौरान अनुमति का अनुरोध ज़रूर करना चाहिए:

• xrCreateSceneMeshingTrackerANDROID
• xrDestroySceneMeshingTrackerANDROID
• xrCreateSceneMeshSnapshotANDROID
• xrDestroySceneMeshSnapshotANDROID
• xrGetAllSubmeshStatesANDROID
• xrGetSubmeshDataANDROID

(सुरक्षा का लेवल: खतरनाक)

सिस्टम की क्षमता की जांच करना

कोई ऐप्लिकेशन यह जांच कर सकता है कि सिस्टम, सीन मेशिंग की सुविधा के साथ काम कर सकता है या नहीं. इसके लिए, xrGetSystemProperties को कॉल करते समय, XrSystemSceneMeshingPropertiesANDROID स्ट्रक्चर को XrSystemProperties से जोड़ना होगा.

XrSystemSceneMeshingPropertiesANDROID

typedef struct XrSystemSceneMeshingPropertiesANDROID {
    XrStructureType    type;
    void*              next;
    XrBool32           supportsSceneMeshing;
} XrSystemSceneMeshingPropertiesANDROID;

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

• type इस स्ट्रक्चर का XrStructureType है.
• next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है. इस तरह के स्ट्रक्चर, OpenXR के मुख्य स्पेसिफ़िकेशन या इस एक्सटेंशन में तय नहीं किए गए हैं.
• supportsSceneMeshing एक XrBool32 है. इससे पता चलता है कि सिस्टम, सीन मेशिंग की सुविधा के साथ काम करता है या नहीं.

अगर supportsSceneMeshing XR_FALSE है, तो सिस्टम सीन मेशिंग की सुविधा के साथ काम नहीं करता. जब supportsSceneMeshing XR_FALSE हो, तब ऐप्लिकेशन को सीन मेशिंग की सुविधा का इस्तेमाल करने से बचना चाहिए. ऐसा इसलिए, क्योंकि xrCreateSceneMeshingTrackerANDROID को कॉल करने पर गड़बड़ी होगी.

अगर supportsSceneMeshing XR_TRUE है, तो सिस्टम सीन मेशिंग की सुविधा के साथ काम करता है.

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

• XrSystemSceneMeshingPropertiesANDROID का इस्तेमाल करने से पहले, XR_ANDROID_scene_meshing एक्सटेंशन को चालू करना ज़रूरी है
• type ज़रूरी है कि XR_TYPE_SYSTEM_SCENE_MESHING_PROPERTIES_ANDROID हो
• next ज़रूरी है कि वह NULL हो या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर हो

XrSceneMeshSemanticLabelSetANDROID

XrSceneMeshSemanticLabelSetANDROID इन्यूमरेशन, सीन मेशिंग के लिए सिमैंटिक लेबल सेट के बारे में बताता है. इस enum में मौजूद हर वैल्यू, एक ऐसे दूसरे enum को दिखाती है जिसमें सिमैंटिक लेबल होते हैं. उदाहरण के लिए, XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT_ANDROID वैल्यू, सेट XrSceneMeshSemanticLabelANDROID को दिखाती है.

typedef enum XrSceneMeshSemanticLabelSetANDROID {
    XR_SCENE_MESH_SEMANTIC_LABEL_SET_NONE_ANDROID = 0,
    XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT_ANDROID = 1,
    XR_SCENE_MESH_SEMANTIC_LABEL_SET_MAX_ENUM_ANDROID = 0x7FFFFFFF
} XrSceneMeshSemanticLabelSetANDROID;

xrEnumerateSupportedSemanticLabelSetsANDROID

ऐप्लिकेशन, xrEnumerateSupportedSemanticLabelSetsANDROID फ़ंक्शन का इस्तेमाल करके, सिस्टम के साथ काम करने वाले सिमैंटिक लेबल सेट पा सकता है.

XrResult xrEnumerateSupportedSemanticLabelSetsANDROID(
    XrInstance                                  instance,
    XrSystemId                                  systemId,
    uint32_t                                    supportedSemanticLabelSetsInputCapacity,
    uint32_t*                                   supportedSemanticLabelSetsOutputCount,
    XrSceneMeshSemanticLabelSetANDROID*         supportedSemanticLabelSets);

पैरामीटर की जानकारी

• instance, ऐप्लिकेशन से बनाया गया XrInstance है.
• systemId, XrSystemId है. इसे xrGetSystem से फिर से आज़माया गया है.
• supportedSemanticLabelSetsInputCapacity, supportedSemanticLabelSets की लंबाई है.
• supportedSemanticLabelSetsOutputCount, supportedSemanticLabelSets में मौजूद उन एलिमेंट की संख्या है जिन्हें रनटाइम ने ऐरे की शुरुआत से बदलना शुरू किया है.
• supportedSemanticLabelSets, XrSceneMeshSemanticLabelSetANDROID का एक कलेक्शन है. इसमें, रनटाइम के ज़रिए इस्तेमाल किए जा सकने वाले सिमैंटिक लेबल सेट लिखे जाते हैं.

उम्मीद है कि हर सिस्टम कम से कम XR_SCENE_MESH_SEMANTIC_LABEL_SET_NONE_ANDROID का इस्तेमाल करेगा, क्योंकि यह enum वैल्यू, कोई भी सिमैंटिक लेबल सेट नहीं दिखाती है. साथ ही, इसका इस्तेमाल तब किया जा सकता है, जब ऐप्लिकेशन को वर्टेक्स सिमैंटिक की ज़रूरत न हो.

सीन मेसिंग ट्रैकर हैंडल बनाना

XrSceneMeshingTrackerANDROID

XR_DEFINE_HANDLE(XrSceneMeshingTrackerANDROID)

XrSceneMeshingTrackerANDROID हैंडल, सीन मेशिंग के लिए सीन मेशिंग ट्रैकर को दिखाता है. साथ ही, इससे जुड़े संसाधनों को मैनेज करता है.

इस हैंडल का इस्तेमाल करके, इस एक्सटेंशन में xrCreateSceneMeshSnapshotANDROID का इस्तेमाल करके सीन मेश स्नैपशॉट बनाया जा सकता है.

xrCreateSceneMeshingTrackerANDROID

कोई ऐप्लिकेशन, xrCreateSceneMeshingTrackerANDROID फ़ंक्शन का इस्तेमाल करके, XrSceneMeshingTrackerANDROID हैंडल बना सकता है.

XrResult xrCreateSceneMeshingTrackerANDROID(
    XrSession                                   session,
    const XrSceneMeshingTrackerCreateInfoANDROID* createInfo,
    XrSceneMeshingTrackerANDROID*               tracker);

पैरामीटर की जानकारी

• session एक XrSession है, जिसमें सीन मेशिंग ट्रैकर चालू होगा.
• createInfo, XrSceneMeshingTrackerCreateInfoANDROID स्ट्रक्चर का पॉइंटर है. इसका इस्तेमाल, बनाए जाने वाले सीन मेशिंग ट्रैकर के बारे में बताने के लिए किया जाता है.
• tracker, XrSceneMeshingTrackerANDROID का हैंडल है.

अगर सिस्टम, सीन मेशिंग की सुविधा के साथ काम नहीं करता है, तो xrCreateSceneMeshingTrackerANDROID XR_ERROR_FEATURE_UNSUPPORTED दिखाएगा. ऐप्लिकेशन, XrSystemSceneMeshingPropertiesANDROID स्ट्रक्चर के साथ xrGetSystemProperties को कॉल करके, सिस्टम के साथ काम करने की सुविधा की जांच कर सकता है.

सिस्टम के साथ काम करने वाले सिर्फ़ सिमैंटिक लेबल सेट का इस्तेमाल, सीन मेशिंग ट्रैकर बनाते समय किया जा सकता है. इसके लिए, XrSceneMeshingTrackerCreateInfoANDROID::semanticLabelSet का इस्तेमाल करें. xrEnumerateSupportedSemanticLabelSetsANDROID फ़ंक्शन का इस्तेमाल करके, सेमैंटिक लेबल सेट की सूची पाई जा सकती है.

अगर ऐप्लिकेशन, काम न करने वाले semanticLabelSet का अनुरोध करता है, तो xrCreateSceneMeshingTrackerANDROID, XR_ERROR_FEATURE_UNSUPPORTED दिखाएगा.

xrCreateSceneMeshingTrackerANDROID हैंडल के पास, सीन मेशिंग के लिए सभी संसाधन होते हैं. सीन मेशिंग का इस्तेमाल करने के बाद, ऐप्लिकेशन को xrDestroySceneMeshingTrackerANDROID फ़ंक्शन के ज़रिए हैंडल को मिटाना ज़रूरी है.

XrSceneMeshingTrackerCreateInfoANDROID

XrSceneMeshingTrackerCreateInfoANDROID स्ट्रक्चर, XrSceneMeshingTrackerANDROID हैंडल बनाने के लिए ज़रूरी जानकारी के बारे में बताता है.

typedef struct XrSceneMeshingTrackerCreateInfoANDROID {
    XrStructureType                       type;
    const void*                           next;
    XrSceneMeshSemanticLabelSetANDROID    semanticLabelSet;
    XrBool32                              enableNormals;
} XrSceneMeshingTrackerCreateInfoANDROID;

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

• type इस स्ट्रक्चर का XrStructureType है.
• next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है. इस तरह के स्ट्रक्चर, OpenXR के मुख्य स्पेसिफ़िकेशन या इस एक्सटेंशन में तय नहीं किए गए हैं.
• semanticLabelSet, XrSceneMeshSemanticLabelSetANDROID है. इसका इस्तेमाल, सीन मेसिंग के लिए इस्तेमाल किए जाने वाले सिमेंटिक लेबल सेट के बारे में बताने के लिए किया जाता है. अगर इसे XR_SCENE_MESH_SEMANTIC_LABEL_SET_NONE_ANDROID पर सेट किया जाता है, तो रनटाइम, XrSceneSubmeshDataANDROID::vertexSemantics बफ़र फ़ील्ड को अनदेखा कर देगा.
• enableNormals एक XrBool32 है. इसका इस्तेमाल यह तय करने के लिए किया जाता है कि सीन मेश डेटा पाने के दौरान, सीन मेश बफ़र में मेश वर्टेक्स के लिए वर्टेक्स नॉर्मल शामिल करने हैं या नहीं.

xrDestroySceneMeshingTrackerANDROID

xrDestroySceneMeshingTrackerANDROID फ़ंक्शन, सीन मेशिंग की प्रोसेस पूरी होने के बाद tracker और उससे जुड़े संसाधनों को रिलीज़ करता है.

XrResult xrDestroySceneMeshingTrackerANDROID(
    XrSceneMeshingTrackerANDROID          tracker);

पैरामीटर की जानकारी

• tracker, XrSceneMeshingTrackerANDROID है. इसे पहले xrCreateSceneMeshingTrackerANDROID ने बनाया था.

सीन मेश स्नैपशॉट हैंडल बनाना

XrSceneMeshSnapshotANDROID

XR_DEFINE_HANDLE(XrSceneMeshSnapshotANDROID)

XrSceneMeshSnapshotANDROID हैंडल, सीन मेश स्नैपशॉट को दिखाता है. इसे xrCreateSceneMeshSnapshotANDROID का इस्तेमाल करके बनाया जाता है. यह फ़ंक्शन कॉल के समय, सीन मेश डेटा का स्नैपशॉट लेता है.

इस हैंडल का इस्तेमाल करके, सबमेश की जानकारी और डेटा को वापस पाया जा सकता है. इसके लिए, xrGetAllSubmeshStatesANDROID और xrGetSubmeshDataANDROID का इस्तेमाल करें.

XrSceneMeshSnapshotCreateInfoANDROID

XrSceneMeshSnapshotCreateInfoANDROID स्ट्रक्चर, XrSceneMeshSnapshotANDROID हैंडल बनाने के लिए ज़रूरी जानकारी के बारे में बताता है

typedef struct XrSceneMeshSnapshotCreateInfoANDROID {
    XrStructureType    type;
    const void*        next;
    XrSpace            baseSpace;
    XrTime             time;
    XrBoxf             boundingBox;
} XrSceneMeshSnapshotCreateInfoANDROID;

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

• type इस स्ट्रक्चर का XrStructureType है.
• next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है. इस तरह के स्ट्रक्चर, OpenXR के मुख्य स्पेसिफ़िकेशन या इस एक्सटेंशन में तय नहीं किए गए हैं.
• baseSpace एक XrSpace है. इसका इस्तेमाल रेफ़रंस स्पेस के बारे में बताने के लिए किया जाता है. रेफ़रंस स्पेस में, सीन सबमेश की पोज़ की जानकारी दिखाई जानी चाहिए.
• time, XrTime है. यह उस समय के बारे में बताता है जब सीन मेश को प्रोसेस या दिखाया जाएगा.
• boundingBox एक XrBoxf है. यह उस बाउंडिंग बॉक्स के बारे में बताता है जिसमें सीन मेश को हासिल करना है.

XrSceneMeshTrackingStateANDROID

XrSceneMeshTrackingStateANDROID इन्यूमरेशन, सीन मेशिंग ट्रैकर के लिए ट्रैकिंग की स्थिति के बारे में बताता है. इस enum में मौजूद हर वैल्यू, सीन मेशिंग ट्रैकर की स्थिति के बारे में बताती है. यह enum, XrSceneMeshSnapshotCreationResultANDROID स्ट्रक्चर में रैप किया गया है. यह xrCreateSceneMeshSnapshotANDROID से मिलता है.

typedef enum XrSceneMeshTrackingStateANDROID {
    XR_SCENE_MESH_TRACKING_STATE_INITIALIZING_ANDROID = 0,
    XR_SCENE_MESH_TRACKING_STATE_TRACKING_ANDROID = 1,
    XR_SCENE_MESH_TRACKING_STATE_WAITING_ANDROID = 2,
    XR_SCENE_MESH_TRACKING_STATE_ERROR_ANDROID = 3,
    XR_SCENE_MESH_TRACKING_STATE_MAX_ENUM_ANDROID = 0x7FFFFFFF
} XrSceneMeshTrackingStateANDROID;

XrSceneMeshSnapshotCreationResultANDROID

XrSceneMeshSnapshotCreationResultANDROID स्ट्रक्चर, सीन मेश स्नैपशॉट बनाने के नतीजे को सेव करता है. यह नतीजा, xrCreateSceneMeshSnapshotANDROID से मिलता है. नतीजे में, स्नैपशॉट हैंडल और स्नैपशॉट बनाने के समय सीन मेशिंग ट्रैकर की ट्रैकिंग की स्थिति शामिल होती है.

typedef struct XrSceneMeshSnapshotCreationResultANDROID {
    XrStructureType                  type;
    void*                            next;
    XrSceneMeshSnapshotANDROID       snapshot;
    XrSceneMeshTrackingStateANDROID    trackingState;
} XrSceneMeshSnapshotCreationResultANDROID;

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

• type इस स्ट्रक्चर का XrStructureType है.
• next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है. इस तरह के स्ट्रक्चर, OpenXR के मुख्य स्पेसिफ़िकेशन या इस एक्सटेंशन में तय नहीं किए गए हैं.
• snapshot, रनटाइम के ज़रिए बनाया गया XrSceneMeshSnapshotANDROID हैंडल है.
• trackingState एक XrSceneMeshTrackingStateANDROID है. यह स्नैपशॉट बनाते समय, सीन मेशिंग ट्रैकर की स्थिति के बारे में बताता है.

xrCreateSceneMeshSnapshotANDROID

ऐप्लिकेशन, सीन मेशिंग ट्रैकर से सीन मेश स्नैपशॉट बनाने के लिए, xrCreateSceneMeshSnapshotANDROID फ़ंक्शन का इस्तेमाल कर सकता है. यह फ़ंक्शन, XrSceneMeshSnapshotANDROID हैंडल के साथ-साथ, XrSceneMeshTrackingStateANDROID को XrSceneMeshSnapshotCreationResultANDROID स्ट्रक्चर में रैप करके दिखाता है. टेक्निकल तौर पर, हैंडल, सीन मेश डेटा का स्नैपशॉट होता है. यह स्नैपशॉट, हैंडल बनाने के समय लिया जाता है. इस हैंडल का इस्तेमाल, सीन मेश की जानकारी और डेटा को क्वेरी करने के लिए किया जा सकता है. इसके लिए, xrGetAllSubmeshStatesANDROID और xrGetSubmeshDataANDROID का इस्तेमाल करें.

XrResult xrCreateSceneMeshSnapshotANDROID(
    XrSceneMeshingTrackerANDROID                tracker,
    const XrSceneMeshSnapshotCreateInfoANDROID* createInfo,
    XrSceneMeshSnapshotCreationResultANDROID*   outSnapshotCreationResult);

पैरामीटर की जानकारी

• tracker, XrSceneMeshingTrackerANDROID हैंडल है. इसे पहले xrCreateSceneMeshingTrackerANDROID की मदद से बनाया गया था.
• createInfo, XrSceneMeshSnapshotCreateInfoANDROID स्ट्रक्चर का पॉइंटर है. इसमें सीन मेश स्नैपशॉट बनाने के लिए ज़रूरी जानकारी होती है.
• outSnapshotCreationResult, XrSceneMeshSnapshotCreationResultANDROID ऑब्जेक्ट का पॉइंटर है. इसे रनटाइम के दौरान, स्नैपशॉट बनाने के नतीजे के साथ पॉप्युलेट किया जाता है.

सीन मेश के स्नैपशॉट से सीन मेश का डेटा पाना

XrSceneSubmeshStateANDROID

XrSceneSubmeshStateANDROID, सबमेश के बारे में बताता है. इसमें सबमेश के बारे में बुनियादी जानकारी होती है. जैसे, आईडी, पोज़, बाउंड, और आखिरी बार अपडेट किए जाने का समय.

typedef struct XrSceneSubmeshStateANDROID {
    XrStructureType    type;
    void*              next;
    XrUuid             submeshId;
    XrTime             lastUpdatedTime;
    XrPosef            submeshPoseInBaseSpace;
    XrExtent3Df        bounds;
} XrSceneSubmeshStateANDROID;

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

• type इस स्ट्रक्चर का XrStructureType है.
• next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है. इस तरह के स्ट्रक्चर, OpenXR के मुख्य स्पेसिफ़िकेशन या इस एक्सटेंशन में तय नहीं किए गए हैं.
• submeshId एक XrUuid है, जो सबमेश की पहचान करता है.
• lastUpdatedTime एक XrTime है. यह उस समय को दिखाता है जब सबमेश को पिछली बार अपडेट किया गया था.
• submeshPoseInBaseSpace एक XrPosef है. यह उस बेस स्पेस में सबमेश की पोज़िशन दिखाता है जिसका इस्तेमाल सीन मेश स्नैपशॉट बनाने के लिए किया गया था. यह सबमेश बाउंडिंग बॉक्स के बीच का पोज़ भी है.
• bounds एक XrExtent3Df है. यह सबमेश को शामिल करने वाले बाउंडिंग बॉक्स के डाइमेंशन के बारे में बताता है. यह बाउंड, उस बेस स्पेस में है जिसका इस्तेमाल सीन मेश हैंडल बनाने के लिए किया गया था.

xrGetAllSubmeshStatesANDROID

ऐप्लिकेशन, सीन मेश में मौजूद सभी सबमेश की स्थिति पाने के लिए, xrGetAllSubmeshStatesANDROID फ़ंक्शन का इस्तेमाल कर सकता है. इसमें बुनियादी जानकारी होती है, ताकि ऐप्लिकेशन उन सबमेश को चुन सके जिनके लिए उसे डेटा चाहिए. इस फ़ंक्शन का इस्तेमाल, दो कॉल वाले इडियम में किया जा सकता है.

XrResult xrGetAllSubmeshStatesANDROID(
    XrSceneMeshSnapshotANDROID            snapshot,
    uint32_t                              submeshStateCapacityInput,
    uint32_t*                             submeshStateCountOutput,
    XrSceneSubmeshStateANDROID*           submeshStates);

पैरामीटर की जानकारी

• snapshot, XrSceneMeshSnapshotANDROID हैंडल है. इसे पहले xrCreateSceneMeshSnapshotANDROID की मदद से बनाया गया था.
• submeshStateCapacityInput, submeshStates की लंबाई है.
• submeshStateCountOutput, submeshStates में मौजूद उन एलिमेंट की संख्या है जिन्हें रनटाइम के दौरान बदला गया है. ये बदलाव, ऐरे की शुरुआत से किए जाते हैं.
• submeshStates, XrSceneSubmeshStateANDROID स्ट्रक्चर की एक ऐसी ऐरे है जिसमें रनटाइम, सीन मेश में मौजूद सभी सबमेश की स्थिति को आउटपुट करेगा.

XrSceneSubmeshDataANDROID

XrSceneSubmeshDataANDROID में, सबमेश का ट्रायंगल डेटा और सबमेश आईडी होता है. इस स्ट्रक्चर का इस्तेमाल xrGetSubmeshDataANDROID में किया जाता है, ताकि सबमेश का डेटा मिल सके. ऐप्लिकेशन को इस स्ट्रक्ट का सबमेश आईडी और बफ़र पॉइंटर को असाइन किए गए बफ़र पर सेट करना ज़रूरी है, ताकि सबमेश के लिए मिले डेटा को असाइन किए गए बफ़र में भरा जा सके. ऐप्लिकेशन, xrGetSubmeshDataANDROID को दो कॉल वाले इडियम के तौर पर इस्तेमाल कर सकता है. पहले कॉल में, ऐप्लिकेशन को सबमेश आईडी सेट करना होगा और सबमेश डेटा के लिए ज़रूरी बफ़र के साइज़ पाने होंगे. इसके बाद, ऐप्लिकेशन बफ़र असाइन कर सकता है और दूसरे कॉल में डेटा पा सकता है.

typedef struct XrSceneSubmeshDataANDROID {
    XrStructureType    type;
    const void*        next;
    XrUuid             submeshId;
    uint32_t           vertexCapacityInput;
    uint32_t           vertexCountOutput;
    XrVector3f*        vertexPositions;
    XrVector3f*        vertexNormals;
    uint8_t*           vertexSemantics;
    uint32_t           indexCapacityInput;
    uint32_t           indexCountOutput;
    uint32_t*          indices;
} XrSceneSubmeshDataANDROID;

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

• type इस स्ट्रक्चर का XrStructureType है.
• next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है. इस तरह के स्ट्रक्चर, OpenXR के मुख्य स्पेसिफ़िकेशन या इस एक्सटेंशन में तय नहीं किए गए हैं.
• submeshId एक XrUuid है, जो सबमेश की पहचान करता है.
• vertexCapacityInput, vertexPositions, vertexNormals, और vertexSemantics की लंबाई है.
• vertexCountOutput, vertexPositions, vertexNormals, और vertexSemantics में मौजूद उन एलिमेंट की संख्या है जिन्हें रनटाइम ने ऐरे की शुरुआत से बदला है.
• vertexPositions, XrVector3f का एक कलेक्शन है. रनटाइम, सबमेश की वर्टेक्स पोज़िशन को इस कलेक्शन में आउटपुट करेगा.
• vertexNormals, XrVector3f का एक कलेक्शन है. रनटाइम, सबमेश के वर्टेक्स नॉर्मल को इस कलेक्शन में आउटपुट करेगा. अगर ऐप्लिकेशन ने सामान्य सेटिंग बंद करके ट्रैकर बनाया है, तो इस फ़ील्ड को NULL छोड़ा जा सकता है.
• vertexSemantics, uint8_t का एक ऐसा कलेक्शन है जिसमें रनटाइम, सबमेश के वर्टेक्स सिमैंटिक को आउटपुट करेगा. अगर ऐप्लिकेशन ने XR_SCENE_MESH_SEMANTIC_LABEL_SET_NONE_ANDROID सिमैंटिक लेबल सेट करके ट्रैकर बनाया है, तो इस फ़ील्ड को NULL छोड़ा जा सकता है. हालांकि, ऐसा किया जा सकता है.
• indexCapacityInput, indices की लंबाई है.
• indexCountOutput, indices में मौजूद उन एलिमेंट की संख्या है जिन्हें रनटाइम ने ऐरे की शुरुआत से बदलना शुरू कर दिया है.
• indices, uint32_t का एक कलेक्शन है. रनटाइम, सबमेश के इंडेक्स को इस कलेक्शन में आउटपुट करेगा.

xrGetSubmeshDataANDROID

ऐप्लिकेशन, चुने गए सबमेश की सूची का डेटा पाने के लिए, xrGetSubmeshDataANDROID फ़ंक्शन का इस्तेमाल कर सकता है. इस फ़ंक्शन का इस्तेमाल, दो कॉल वाले इडियम में किया जा सकता है. पहले कॉल में, ऐप्लिकेशन को एक मान्य सबमेश आईडी सेट करना होगा. जैसे: इसे xrGetAllSubmeshStatesANDROID से उसी सीन मेश स्नैपशॉट के साथ वापस पाया जा सकता है. साथ ही, सबमेश डेटा के लिए ज़रूरी बफ़र के साइज़ पाने के लिए, चुने गए सबमेश की सूची में मौजूद हर एलिमेंट के लिए, क्षमता को शून्य पर सेट करना होगा. दूसरे कॉल में, ऐप्लिकेशन को चुने गए सबमेश की सूची में मौजूद हर एलिमेंट के लिए, बफ़र पॉइंटर को असाइन किए गए बफ़र पर सेट करना होगा. साथ ही, बफ़र की क्षमता को भी सेट करना होगा, ताकि सबमेश का डेटा मिल सके.

XrResult xrGetSubmeshDataANDROID(
    XrSceneMeshSnapshotANDROID            snapshot,
    uint32_t                              submeshDataCount,
    XrSceneSubmeshDataANDROID*            inoutSubmeshData);

पैरामीटर की जानकारी

• snapshot, XrSceneMeshSnapshotANDROID हैंडल है. इसे पहले xrCreateSceneMeshSnapshotANDROID की मदद से बनाया गया था.
• submeshDataCount, inoutSubmeshData की लंबाई है.
• inoutSubmeshData, XrSceneSubmeshDataANDROID का एक कलेक्शन है. इसमें हर एलिमेंट को, सबमेश आईडी के आधार पर रनटाइम के ज़रिए मेश डेटा से भरा जाएगा.

XrSceneMeshSemanticLabelANDROID

XrSceneMeshSemanticLabelANDROID इन्यूमरेशन, सिमैंटिक लेबल का डिफ़ॉल्ट सेट है. इसका इस्तेमाल, मेश वर्टेक्स को लेबल करने के लिए किया जा सकता है. इससे यह पता चलता है कि मेश वर्टेक्स, किस फ़िज़िकल एनवायरमेंट की सतह पर है. इस enum सेट को XrSceneMeshSemanticLabelSetANDROID में XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT_ANDROID वैल्यू के तौर पर दिखाया जाता है.

typedef enum XrSceneMeshSemanticLabelANDROID {
    XR_SCENE_MESH_SEMANTIC_LABEL_OTHER_ANDROID = 0,
    XR_SCENE_MESH_SEMANTIC_LABEL_FLOOR_ANDROID = 1,
    XR_SCENE_MESH_SEMANTIC_LABEL_CEILING_ANDROID = 2,
    XR_SCENE_MESH_SEMANTIC_LABEL_WALL_ANDROID = 3,
    XR_SCENE_MESH_SEMANTIC_LABEL_TABLE_ANDROID = 4,
    XR_SCENE_MESH_SEMANTIC_LABEL_MAX_ENUM_ANDROID = 0x7FFFFFFF
} XrSceneMeshSemanticLabelANDROID;

सीन मेश स्नैपशॉट को डिस्ट्रॉय करता है

xrDestroySceneMeshSnapshotANDROID

ऐप्लिकेशन, सीन मेश स्नैपशॉट को मिटाने के लिए, xrDestroySceneMeshSnapshotANDROID फ़ंक्शन का इस्तेमाल कर सकता है. हैंडल मिटाने के बाद, ऐप्लिकेशन इसका इस्तेमाल सबमेश की जानकारी या डेटा पाने के लिए नहीं कर सकता. ट्रैकर के बंद होने पर हैंडल अपने-आप बंद हो जाता है, क्योंकि ट्रैकर हैंडल, सीन मेश स्नैपशॉट हैंडल का पैरंट होता है.

XrResult xrDestroySceneMeshSnapshotANDROID(
    XrSceneMeshSnapshotANDROID            snapshot);

पैरामीटर की जानकारी

• snapshot, XrSceneMeshSnapshotANDROID हैंडल है. इसे पहले xrCreateSceneMeshSnapshotANDROID की मदद से बनाया गया था. यह फ़ंक्शन इसे डिस्ट्रॉय कर देगा.

सीन मेशिंग के लिए कोड का उदाहरण

यहां दिए गए उदाहरण कोड में, रेंडरिंग के लिए सीन मेश डेटा को ऐक्सेस करने का तरीका बताया गया है.

XrInstance instance;  // Created at app startup
XrSystemId systemId;  // Received from xrGetSystem() at app startup
XrSession session;    // Created at app startup
XrSpace appPlaySpace; // Created at app startup

// The function pointers are previously initialized using xrGetInstanceProcAddr.
PFN_xrCreateSceneMeshingTrackerANDROID xrCreateSceneMeshingTrackerANDROID;
PFN_xrDestroySceneMeshingTrackerANDROID xrDestroySceneMeshingTrackerANDROID;
PFN_xrEnumerateSupportedSemanticLabelSetsANDROID xrEnumerateSupportedSemanticLabelSetsANDROID;
PFN_xrCreateSceneMeshSnapshotANDROID xrCreateSceneMeshSnapshotANDROID;
PFN_xrDestroySceneMeshSnapshotANDROID xrDestroySceneMeshSnapshotANDROID;
PFN_xrGetAllSubmeshStatesANDROID xrGetAllSubmeshStatesANDROID;
PFN_xrGetSubmeshDataANDROID xrGetSubmeshDataANDROID;

// Inspect system capability
XrSystemSceneMeshingPropertiesANDROID sceneMeshingProps = {
  .type = XR_TYPE_SYSTEM_SCENE_MESHING_PROPERTIES_ANDROID,
};
XrSystemProperties sysProps = {
  .type = XR_TYPE_SYSTEM_PROPERTIES,
  .next = &sceneMeshingProps
};
CHK_XR(xrGetSystemProperties(instance, systemId, &sysProps));
if (!sceneMeshingProps.supportsSceneMeshing) {
    // scene meshing is not supported.
    return;
}

uint32_t supportedsemanticLabelSetsCount = 0;
xrEnumerateSupportedSemanticLabelSetsANDROID(
  instance, systemId, 0, &supportedsemanticLabelSetsCount, nullptr);
std::vector<XrSceneMeshSemanticLabelSetANDROID> supportedSemanticLabelSets(
  supportedsemanticLabelSetsCount);
xrEnumerateSupportedSemanticLabelSetsANDROID(
  instance, systemId, supportedsemanticLabelSetsCount,
  &supportedsemanticLabelSetsCount, supportedSemanticLabelSets.data());

XrSceneMeshSemanticLabelSetANDROID semanticLabelSet = XR_SCENE_MESH_SEMANTIC_LABEL_SET_NONE_ANDROID;
// Check if system supports XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT_ANDROID
if (std::find(supportedSemanticLabelSets.begin(), supportedSemanticLabelSets.end(),
              XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT_ANDROID) !=
    supportedSemanticLabelSets.end()) {
  semanticLabelSet = XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT_ANDROID;
}

XrSceneMeshingTrackerCreateInfoANDROID trackerCreateInfo = {
  .type = XR_TYPE_SCENE_MESHING_TRACKER_CREATE_INFO_ANDROID,
  .semanticLabelSet = semanticLabelSet,
  .enableNormals = XR_TRUE
};

XrSceneMeshingTrackerANDROID tracker = XR_NULL_HANDLE;
CHK_XR(xrCreateSceneMeshingTrackerANDROID(session, &trackerCreateInfo, &tracker));

XrSceneMeshSnapshotCreationResultANDROID snapshotResult = {
  .type = XR_TYPE_SCENE_MESH_SNAPSHOT_CREATION_RESULT_ANDROID,
  .snapshot = XR_NULL_HANDLE
};
XrSceneMeshSnapshotANDROID& snapshot = snapshotResult.snapshot;
XrSceneMeshSnapshotCreateInfoANDROID createInfo = {
  .type = XR_TYPE_SCENE_MESH_SNAPSHOT_CREATE_INFO_ANDROID
};

// app update loop
while (true) {
  // ...
  // For every frame in frame loop
  // ...

  XrFrameState frameState; // previously returned from xrWaitFrame
  const XrTime time = frameState.predictedDisplayTime;
  XrBoxf box; // populated with the bounding box of the camera frustum

  // ...

  createInfo.baseSpace = appPlaySpace;
  createInfo.time = time;
  createInfo.boundingBox = box;

  // Grab the scene mesh snapshot. This way the app can: know all of the submesh infos,
  // choose the appropriate submeshes for which to get data, allocate the necessary
  // buffer for those submeshes, and then get the data.
  CHK_XR(xrCreateSceneMeshSnapshotANDROID(tracker, &createInfo, &snapshotResult));

  // check the tracking state
  if (snapshotResult.trackingState == XR_SCENE_MESH_TRACKING_STATE_ERROR_ANDROID) {
    // unrecoverable error. Exit the app.
    if (snapshot != XR_NULL_HANDLE) {
      CHK_XR(xrDestroySceneMeshSnapshotANDROID(snapshot));
      snapshot = XR_NULL_HANDLE;
    }
    break;
  } else if (snapshotResult.trackingState != XR_SCENE_MESH_TRACKING_STATE_TRACKING_ANDROID) {
    // The tracker is not tracking. Try again later.
    if (snapshot != XR_NULL_HANDLE) {
      CHK_XR(xrDestroySceneMeshSnapshotANDROID(snapshot));
      snapshot = XR_NULL_HANDLE;
    }
    continue;
  }

  // 2-call idiom for getting submesh states
  std::vector<XrSceneSubmeshStateANDROID> states;
  uint32_t submeshCount = 0;
  CHK_XR(xrGetAllSubmeshStatesANDROID(snapshot, 0, &submeshCount, nullptr));
  states.resize(submeshCount);
  for (XrSceneSubmeshStateANDROID& state : states) {
    state = {.type = XR_TYPE_SCENE_SUBMESH_STATE_ANDROID};
  }
  CHK_XR(xrGetAllSubmeshStatesANDROID(snapshot, submeshCount, &submeshCount, states.data()));

  // To store the poses for the selected submeshes
  std::vector<XrPosef> submeshesPoses;
  submeshesPoses.reserve(submeshCount);

  std::vector<XrSceneSubmeshDataANDROID> submeshes;
  submeshes.reserve(submeshCount);
  // Iterate the states and determine which submeshes the app wants data for
  for (XrSceneSubmeshStateANDROID& state : states) {
    // Modify this bool as necessary by looking at states. Maybe state.lastUpdatedTime
    // is below a threshold or maybe the bounding box does not intersect with camera view
    // frustum (The submesh will be culled).
    bool needed;
    if (needed) {
      // Add the selected submesh to the submeshes list. Set the capacity
      // zero for now since the size of the buffer will be determined later.
      XrSceneSubmeshDataANDROID submesh = {
        .type = XR_TYPE_SCENE_SUBMESH_DATA_ANDROID,
        .submeshId = state.submeshId,
        .vertexCapacityInput = 0,
        .vertexCountOutput = 0,
        .vertexPositions = nullptr,
        .vertexNormals = nullptr,
        .vertexSemantics = nullptr,
        .indexCapacityInput = 0,
        .indexCountOutput = 0,
        .indices = nullptr,
      };
      submeshes.push_back(submesh);
      submeshesPoses.push_back(state.submeshPoseInBaseSpace);
    }
  }

  // Grab the data for the selected submeshes using the 2-call idiom.
  CHK_XR(xrGetSubmeshDataANDROID(snapshot, submeshes.size(), submeshes.data()));
  for (XrSceneSubmeshDataANDROID& submesh : submeshes) {
    submesh.vertexCapacityInput = submesh.vertexCountOutput;
    submesh.vertexCountOutput = 0;
    submesh.vertexPositions = new XrVector3f[submesh.vertexCountOutput];
    submesh.vertexNormals = new XrVector3f[submesh.vertexCountOutput];
    submesh.vertexSemantics = new uint8_t[submesh.vertexCountOutput];
    submesh.indexCapacityInput = submesh.indexCountOutput;
    submesh.indexCountOutput = 0;
    submesh.indices = new uint32_t[submesh.indexCountOutput];
  }
  CHK_XR(xrGetSubmeshDataANDROID(snapshot, submeshes.size(), submeshes.data()));

  // Destroy the scene mesh snapshot since we have finally grabbed the submeshes data. In
  // next iteration app can: create a new one to get latest mesh data
  CHK_XR(xrDestroySceneMeshSnapshotANDROID(snapshot));
  snapshot = XR_NULL_HANDLE;

  // Iterate the submeshes and get the vertex positions, vertex normals and
  // vertex semantics data for the selected submeshes
  for (uint32_t i = 0; i < submeshes.size(); i++) {
    XrSceneSubmeshDataANDROID& data = submeshes[i];
    XrVector3f* vertexPositions = data.vertexPositions;
    XrVector3f* vertexNormals = data.vertexNormals;
    XrSceneMeshSemanticLabelANDROID* vertexSemantics =
      reinterpret_cast<XrSceneMeshSemanticLabelANDROID*>(data.vertexSemantics);
    XrPosef pose = submeshesPoses[i];

    // *** Use the data as per needs ***

    // Release the allocated memory for the data buffers when done using
    delete [] data.vertexPositions;
    delete [] data.vertexNormals;
    delete [] data.vertexSemantics;
    delete [] data.indices;
  }

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

CHK_XR(xrDestroySceneMeshingTrackerANDROID(tracker));

नए ऑब्जेक्ट टाइप

• XrSceneMeshingTrackerANDROID
• XrSceneMeshSnapshotANDROID

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

XrObjectType इन्यूमरेशन को इन वैल्यू के साथ बढ़ाया गया है:

• XR_OBJECT_TYPE_SCENE_MESHING_TRACKER_ANDROID
• XR_OBJECT_TYPE_SCENE_MESH_SNAPSHOT_ANDROID

XrStructureType इन्यूमरेशन को इन वैल्यू के साथ बढ़ाया गया है:

• XR_TYPE_SYSTEM_SCENE_MESHING_PROPERTIES_ANDROID
• XR_TYPE_SCENE_MESHING_TRACKER_CREATE_INFO_ANDROID
• XR_TYPE_SCENE_MESH_SNAPSHOT_CREATE_INFO_ANDROID
• XR_TYPE_SCENE_MESH_SNAPSHOT_CREATION_RESULT_ANDROID
• XR_TYPE_SCENE_SUBMESH_STATE_ANDROID
• XR_TYPE_SCENE_SUBMESH_DATA_ANDROID

नए एनम

• XrSceneMeshSemanticLabelSetANDROID
• XrSceneMeshSemanticLabelANDROID
• XrSceneMeshTrackingStateANDROID

नए स्ट्रक्चर

• XrSystemSceneMeshingPropertiesANDROID
• XrSceneMeshingTrackerCreateInfoANDROID
• XrSceneMeshSnapshotCreateInfoANDROID
• XrSceneMeshSnapshotCreationResultANDROID
• XrSceneSubmeshStateANDROID
• XrSceneSubmeshDataANDROID

नए फ़ंक्शन

• xrCreateSceneMeshingTrackerANDROID
• xrDestroySceneMeshingTrackerANDROID
• xrEnumerateSupportedSemanticLabelSetsANDROID
• xrCreateSceneMeshSnapshotANDROID
• xrDestroySceneMeshSnapshotANDROID
• xrGetAllSubmeshStatesANDROID
• xrGetSubmeshDataANDROID

समस्याएं

वर्शन इतिहास

• तीसरा वर्शन, 15-05-2025 (सैलर ख़ान) ** एक्सटेंशन की शुरुआती जानकारी

---

OpenXR™ और OpenXR लोगो, The Khronos Group Inc. के ट्रेडमार्क हैं. इन्हें चीन, यूरोपियन यूनियन, जापान, और यूनाइटेड किंगडम में ट्रेडमार्क के तौर पर रजिस्टर किया गया है.