XR_ANDROID_scene_meshing

Name String

XR_ANDROID_scene_meshing

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

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

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

719

बदलाव

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

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

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

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

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

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

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

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

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

अगर रनटाइम, supportsSceneMeshing के लिए XR_TRUE दिखाता है, तो इसका मतलब है कि सिस्टम में सीन मेशिंग की सुविधा काम करती है.

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

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

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_DEFAULT2_ANDROID = 1000801000,
    XR_SCENE_MESH_SEMANTIC_LABEL_SET_MAX_ENUM_ANDROID = 0x7FFFFFFF
} XrSceneMeshSemanticLabelSetANDROID;

एनुमरेशन वैल्यू के ये मतलब होते हैं:

Enum की जानकारी

XR_SCENE_MESH_SEMANTIC_LABEL_SET_NONE_ANDROID

सिमैंटिक लेबल का यह सेट, सिमैंटिक लेबल की अनुपस्थिति को दिखाता है.

XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT_ANDROID

सिमैंटिक लेबल का यह सेट, XrSceneMeshSemanticLabelANDROID को दिखाता है.

XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT2_ANDROID

सिमैंटिक लेबल का यह सेट, XrSceneMeshSemanticLabel2ANDROID को दिखाता है. (XR_ANDROID_scene_meshing_semantic_label2 एक्सटेंशन ने जोड़ा है)

xrEnumerateSupportedSemanticLabelSetsANDROID फ़ंक्शन को इस तरह से तय किया गया है:

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

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

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

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

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

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

• xrEnumerateSupportedSemanticLabelSetsANDROID को कॉल करने से पहले, XR_ANDROID_scene_meshing एक्सटेंशन को चालू करना ज़रूरी है
• instance एक मान्य XrInstance हैंडल होना ज़रूरी है
• supportedSemanticLabelSetsOutputCount को uint32_t वैल्यू का पॉइंटर होना चाहिए
• अगर supportedSemanticLabelSetsInputCapacity की वैल्यू 0 नहीं है, तो supportedSemanticLabelSets को supportedSemanticLabelSetsInputCapacity XrSceneMeshSemanticLabelSetANDROID वैल्यू के कलेक्शन का पॉइंटर होना ज़रूरी है

रिटर्न कोड

सफलता

• XR_SUCCESS

Failure

• 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

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

XR_DEFINE_HANDLE(XrSceneMeshingTrackerANDROID)

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

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

xrCreateSceneMeshingTrackerANDROID फ़ंक्शन को इस तरह से तय किया गया है:

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

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

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

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

अगर सिस्टम में सीन मेशिंग की सुविधा काम नहीं करती है, तो रनटाइम को xrCreateSceneMeshingTrackerANDROID से XR_ERROR_FEATURE_UNSUPPORTED को ज़रूर रिटर्न करना चाहिए. इस मामले में, रनटाइम को XrSystemSceneMeshingPropertiesANDROID :: supportsSceneMeshing के लिए XR_FALSE ज़रूर दिखाना चाहिए. ऐसा तब होना चाहिए, जब xrGetSystemProperties फ़ंक्शन को कॉल किया जाए, ताकि ऐप्लिकेशन को सीन मेशिंग ट्रैकर बनाने से बचा जा सके.

सीन मेशिंग ट्रैकर बनाते समय, ऐप्लिकेशन को सिर्फ़ उन सिमैंटिक लेबल सेट का इस्तेमाल करना चाहिए जो सिस्टम में XrSceneMeshingTrackerCreateInfoANDROID :: semanticLabelSet के साथ काम करते हैं. अगर ऐप्लिकेशन, काम न करने वाले सीन मेश वर्टेक्स सिमैंटिक लेबल सेट का इस्तेमाल करता है, तो रनटाइम को xrCreateSceneMeshingTrackerANDROID से XR_ERROR_FEATURE_UNSUPPORTED ज़रूर दिखाना चाहिए.

ऐप्लिकेशन, xrEnumerateSupportedSemanticLabelSetsANDROID फ़ंक्शन की मदद से, सिमैंटिक लेबल सेट की सूची को गिन सकता है.

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

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

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

रिटर्न कोड

सफलता

• XR_SUCCESS
• XR_SESSION_LOSS_PENDING

Failure

• XR_ERROR_FEATURE_UNSUPPORTED
• 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_VALIDATION_FAILURE

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

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 है. इसका इस्तेमाल यह तय करने के लिए किया जाता है कि सीन मेश डेटा लेते समय, सीन मेश बफ़र में मेश वर्टिस के लिए वर्टेक्स नॉर्मल शामिल किए जाएं या नहीं.

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

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

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

xrDestroySceneMeshingTrackerANDROID फ़ंक्शन को इस तरह से तय किया गया है:

XrResult xrDestroySceneMeshingTrackerANDROID(
    XrSceneMeshingTrackerANDROID                tracker);

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

• tracker एक XrSceneMeshingTrackerANDROID है, जिसे पहले xrCreateSceneMeshingTrackerANDROID ने बनाया था.

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

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

• xrDestroySceneMeshingTrackerANDROID को कॉल करने से पहले, XR_ANDROID_scene_meshing एक्सटेंशन को चालू करना ज़रूरी है
• tracker एक मान्य XrSceneMeshingTrackerANDROID हैंडल होना चाहिए

Thread की सुरक्षा

• tracker और किसी भी चाइल्ड हैंडल का ऐक्सेस, बाहरी तौर पर सिंक किया जाना ज़रूरी है

रिटर्न कोड

सफलता

• XR_SUCCESS

Failure

• XR_ERROR_FUNCTION_UNSUPPORTED
• XR_ERROR_HANDLE_INVALID
• XR_ERROR_RUNTIME_FAILURE

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

XR_DEFINE_HANDLE(XrSceneMeshSnapshotANDROID)

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

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

xrCreateSceneMeshSnapshotANDROID फ़ंक्शन को इस तरह से तय किया गया है:

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

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

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

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

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

• xrCreateSceneMeshSnapshotANDROID को कॉल करने से पहले, XR_ANDROID_scene_meshing एक्सटेंशन को चालू करना ज़रूरी है
• tracker एक मान्य XrSceneMeshingTrackerANDROID हैंडल होना चाहिए
• createInfo को किसी मान्य XrSceneMeshSnapshotCreateInfoANDROID स्ट्रक्चर का पॉइंटर होना चाहिए
• outSnapshotCreationResult को XrSceneMeshSnapshotCreationResultANDROID स्ट्रक्चर का पॉइंटर होना चाहिए

रिटर्न कोड

सफलता

• XR_SUCCESS
• XR_SESSION_LOSS_PENDING

Failure

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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;

एनुमरेशन वैल्यू के ये मतलब होते हैं:

Enum की जानकारी

XR_SCENE_MESH_TRACKING_STATE_INITIALIZING_ANDROID

ट्रैकर अभी मेश डेटा देने के लिए तैयार नहीं है.

XR_SCENE_MESH_TRACKING_STATE_TRACKING_ANDROID

ट्रैकर, गतिविधि को ट्रैक कर रहा है.

XR_SCENE_MESH_TRACKING_STATE_WAITING_ANDROID

ट्रैकर, मेश के पिछले अपडेट के बाद से, इंटिग्रेट करने के लिए मान्य मेज़रमेंट का इंतज़ार कर रहा है.

XR_SCENE_MESH_TRACKING_STATE_ERROR_ANDROID

ट्रैकर को कई साइकल के लिए मान्य मेज़रमेंट नहीं मिले हैं और यह गड़बड़ी की स्थिति में है.

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

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

xrGetAllSubmeshStatesANDROID फ़ंक्शन को इस तरह से तय किया गया है:

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

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

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

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

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

• xrGetAllSubmeshStatesANDROID को कॉल करने से पहले, XR_ANDROID_scene_meshing एक्सटेंशन चालू करना ज़रूरी है
• snapshot एक मान्य XrSceneMeshSnapshotANDROID हैंडल होना चाहिए
• submeshStateCountOutput को uint32_t वैल्यू का पॉइंटर होना चाहिए
• अगर submeshStateCapacityInput की वैल्यू 0 नहीं है, तो submeshStates को submeshStateCapacityInput XrSceneSubmeshStateANDROID स्ट्रक्चर के कलेक्शन का पॉइंटर होना चाहिए

रिटर्न कोड

सफलता

• XR_SUCCESS
• XR_SESSION_LOSS_PENDING

Failure

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

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 है. यह सबमेश को घेरने वाले बाउंडिंग बॉक्स के डाइमेंशन के बारे में बताता है. यह बाउंड, उस बेस स्पेस में तय किया जाता है जिसका इस्तेमाल सीन मेश हैंडल बनाने के लिए किया गया था.

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

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

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

xrGetSubmeshDataANDROID फ़ंक्शन को इस तरह से तय किया गया है:

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

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

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

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

XrSceneSubmeshDataANDROID :: submeshId, inoutSubmeshData में मौजूद हर एलिमेंट के लिए यूनीक होना चाहिए. साथ ही, इसे उसी snapshot के लिए xrGetAllSubmeshStatesANDROID से वापस पाया जा सकता है. अगर सबमेश आईडी अमान्य है या inoutSubmeshData में मौजूद एक से ज़्यादा एलिमेंट का सबमेश आईडी एक ही है, तो रनटाइम को XR_ERROR_VALIDATION_FAILURE दिखाना चाहिए .

submeshDataCount की वैल्यू, xrGetAllSubmeshStatesANDROID :: submeshStateCountOutput से मिली वैल्यू के बराबर या उससे कम होनी चाहिए. ऐसा न होने पर, रनटाइम को XR_ERROR_VALIDATION_FAILURE दिखाना चाहिए.

इसका इस्तेमाल, दो कॉल वाले इडियम में किया जा सकता है. इससे, चुने गए सभी सबमेश के लिए वर्टेक्स और इंडेक्स की संख्या के बारे में क्वेरी की जा सकती है.

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

• xrGetSubmeshDataANDROID को कॉल करने से पहले, XR_ANDROID_scene_meshing एक्सटेंशन को चालू करना ज़रूरी है
• snapshot एक मान्य XrSceneMeshSnapshotANDROID हैंडल होना चाहिए
• inoutSubmeshData को submeshDataCount XrSceneSubmeshDataANDROID स्ट्रक्चर के कलेक्शन का पॉइंटर होना चाहिए
• submeshDataCount पैरामीटर की वैल्यू, 0 से ज़्यादा होनी चाहिए

रिटर्न कोड

सफलता

• XR_SUCCESS
• XR_SESSION_LOSS_PENDING

Failure

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

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

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 की क्षमता है. इसके अलावा, ज़रूरी क्षमता पाने के लिए 0 डालें.
• vertexCountOutput, लिखे गए vertexPositions , vertexNormals , और vertexSemantics की संख्या का पॉइंटर है. इसके अलावा, vertexCapacityInput के कम होने पर, यह ज़रूरी क्षमता का पॉइंटर है.
• vertexPositions, XrVector3f का एक कलेक्शन है. रनटाइम, सबमेश के वर्टेक्स की पोज़िशन को इस कलेक्शन में आउटपुट करेगा.
• vertexNormals, XrVector3f का एक कलेक्शन है. रनटाइम, सबमेश के वर्टेक्स नॉर्मल को इसमें आउटपुट करेगा. अगर ऐप्लिकेशन ने सामान्य ट्रैकर बंद करके कोई ट्रैकर बनाया है, तो इस फ़ील्ड को NULL छोड़ा जा सकता है.
• vertexSemantics, uint8_t का एक कलेक्शन है. रनटाइम, सबमेश के वर्टेक्स सिमैंटिक को इसी कलेक्शन में आउटपुट करेगा. अगर ऐप्लिकेशन ने XR_SCENE_MESH_SEMANTIC_LABEL_SET_NONE_ANDROID सिमैंटिक लेबल सेट के साथ ट्रैकर बनाया है, तो इस फ़ील्ड को NULL छोड़ा जा सकता है.
• indexCapacityInput, indices की क्षमता है या ज़रूरी क्षमता को वापस पाने के लिए 0 है.
• indexCountOutput, लिखे गए indices की संख्या का पॉइंटर है या vertexCapacityInput के कम होने पर, ज़रूरी क्षमता का पॉइंटर है.
• indices, uint32_t का एक कलेक्शन है. रनटाइम, इसमें सबमेश के इंडेक्स को आउटपुट करेगा.
• ज़रूरी vertexPositions , vertexNormals , vertexSemantics , और indices साइज़ को वापस पाने के बारे में ज़्यादा जानकारी के लिए, बफ़र साइज़ पैरामीटर चैप्टर देखें.

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

• XrSceneSubmeshDataANDROID का इस्तेमाल करने से पहले, XR_ANDROID_scene_meshing एक्सटेंशन चालू करना ज़रूरी है
• type की वैल्यू XR_TYPE_SCENE_SUBMESH_DATA_ANDROID होनी चाहिए
• next NULL या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
• अगर vertexCapacityInput की वैल्यू 0 नहीं है, तो vertexPositions को vertexCapacityInput XrVector3f स्ट्रक्चर के कलेक्शन का पॉइंटर होना ज़रूरी है
• अगर vertexCapacityInput की वैल्यू 0 नहीं है, तो vertexNormals को vertexCapacityInput XrVector3f स्ट्रक्चर के कलेक्शन का पॉइंटर होना ज़रूरी है
• अगर vertexCapacityInput, 0 नहीं है, तो vertexSemantics को vertexCapacityInput uint8_t वैल्यू के कलेक्शन का पॉइंटर होना चाहिए
• अगर indexCapacityInput, 0 नहीं है, तो indices को indexCapacityInput uint32_t वैल्यू के कलेक्शन का पॉइंटर होना चाहिए

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;

इन enum का मतलब यह है:

Enum की जानकारी

XR_SCENE_MESH_SEMANTIC_LABEL_OTHER_ANDROID

इस सिमैंटिक लेबल से पता चलता है कि उससे जुड़ा मेश एलिमेंट, किसी अज्ञात ऑब्जेक्ट को दिखाता है.

XR_SCENE_MESH_SEMANTIC_LABEL_FLOOR_ANDROID

इस सिमैंटिक लेबल से पता चलता है कि उससे जुड़ा मेश एलिमेंट, फ़्लोर को दिखाता है.

XR_SCENE_MESH_SEMANTIC_LABEL_CEILING_ANDROID

इस सिमैंटिक लेबल से पता चलता है कि उससे जुड़ा मेश एलिमेंट, छत को दिखाता है.

XR_SCENE_MESH_SEMANTIC_LABEL_WALL_ANDROID

इस सिमैंटिक लेबल से पता चलता है कि उससे जुड़ा मेश एलिमेंट, दीवार को दिखाता है.

XR_SCENE_MESH_SEMANTIC_LABEL_TABLE_ANDROID

इस सिमैंटिक लेबल से पता चलता है कि उससे जुड़ा मेश एलिमेंट, टेबल को दिखाता है.

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

xrDestroySceneMeshSnapshotANDROID फ़ंक्शन को इस तरह से तय किया गया है:

XrResult xrDestroySceneMeshSnapshotANDROID(
    XrSceneMeshSnapshotANDROID                  snapshot);

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

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

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

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

• xrDestroySceneMeshSnapshotANDROID को कॉल करने से पहले, XR_ANDROID_scene_meshing एक्सटेंशन चालू होना ज़रूरी है
• snapshot एक मान्य XrSceneMeshSnapshotANDROID हैंडल होना चाहिए

Thread की सुरक्षा

• snapshot और किसी भी चाइल्ड हैंडल का ऐक्सेस, बाहरी तौर पर सिंक किया जाना ज़रूरी है

रिटर्न कोड

सफलता

• XR_SUCCESS

Failure

• XR_ERROR_FUNCTION_UNSUPPORTED
• XR_ERROR_HANDLE_INVALID
• XR_ERROR_RUNTIME_FAILURE

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

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

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
  uint32_t submeshCount = 0;
  CHK_XR(xrGetAllSubmeshStatesANDROID(snapshot, 0, &submeshCount, nullptr));
  std::vector<XrSceneSubmeshStateANDROID> states(submeshCount, {
    .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.vertexCapacityInput];
    submesh.vertexNormals = new XrVector3f[submesh.vertexCapacityInput];
    submesh.vertexSemantics = new uint8_t[submesh.vertexCapacityInput];
    submesh.indexCapacityInput = submesh.indexCountOutput;
    submesh.indexCountOutput = 0;
    submesh.indices = new uint32_t[submesh.indexCapacityInput];
  }
  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 =
      new XrSceneMeshSemanticLabelANDROID[data.vertexCountOutput];
    for (uint32_t j = 0; j < data.vertexCountOutput; j++) {
      vertexSemantics[j] =
        static_cast<XrSceneMeshSemanticLabelANDROID>(data.vertexSemantics[j]);
    }
    XrPosef pose = submeshesPoses[i];

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

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

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

CHK_XR(xrDestroySceneMeshingTrackerANDROID(tracker));

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

• XrSceneMeshSnapshotANDROID
• XrSceneMeshingTrackerANDROID

नए निर्देश

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

नए स्ट्रक्चर

• XrSceneMeshSnapshotCreateInfoANDROID
• XrSceneMeshSnapshotCreationResultANDROID
• XrSceneMeshingTrackerCreateInfoANDROID
• XrSceneSubmeshDataANDROID
• XrSceneSubmeshStateANDROID

• XrSystemProperties को एक्सटेंड करना :

  • XrSystemSceneMeshingPropertiesANDROID

नए Enum

• XrSceneMeshSemanticLabelANDROID
• XrSceneMeshSemanticLabelSetANDROID
• XrSceneMeshTrackingStateANDROID

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

• XR_ANDROID_SCENE_MESHING_EXTENSION_NAME
• XR_ANDROID_scene_meshing_SPEC_VERSION

• XrObjectType को एक्सटेंड करना :

  • XR_OBJECT_TYPE_SCENE_MESHING_TRACKER_ANDROID
  • XR_OBJECT_TYPE_SCENE_MESH_SNAPSHOT_ANDROID

• XrStructureType को एक्सटेंड करना :

  • 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_DATA_ANDROID
  • XR_TYPE_SCENE_SUBMESH_STATE_ANDROID
  • XR_TYPE_SYSTEM_SCENE_MESHING_PROPERTIES_ANDROID

समस्याएं

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

• तीसरा संशोधन, 15-05-2025 (सालार खान)

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