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 को कॉल करते समय, XrSystemProperties में XrSystemSceneMeshingPropertiesANDROID स्ट्रक्चर को जोड़कर, यह देख सकता है कि सिस्टम सीन मेशिंग की सुविधा के साथ काम करता है या नहीं .

अगर कोई रनटाइम, 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 इन्यूमरेशन, सीन मेशिंग के लिए सिमैंटिक लेबल सेट के बारे में बताता है. इस इनम की हर वैल्यू, ऐसे दूसरे इनम को दिखाती है जिसमें सिमैंटिक लेबल शामिल होते हैं. उदाहरण के लिए, 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;

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

Enum की जानकारी

XR_SCENE_MESH_SEMANTIC_LABEL_SET_NONE_ANDROID

इस सिमैंटिक लेबल सेट से पता चलता है कि कोई सिमैंटिक लेबल मौजूद नहीं है.

XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT_ANDROID

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

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

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

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

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

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

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

मान्य इस्तेमाल (इंप्लिसिट)

• 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 वापस मिल जाना चाहिए . इस मामले में, xrGetSystemProperties फ़ंक्शन को कॉल किए जाने पर, रनटाइम को XrSystemSceneMeshingPropertiesANDROID :: supportsSceneMeshing के लिए XR_FALSE वैल्यू ज़रूर दिखानी चाहिए, ताकि ऐप्लिकेशन, सीन मेशिंग ट्रैकर न बना पाए.

सीन मेशिंग ट्रैकर बनाते समय, ऐप्लिकेशन को सिर्फ़ उन सिमैंटिक लेबल सेट का इस्तेमाल करना चाहिए जिन्हें सिस्टम, 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 का मान्य हैंडल होना चाहिए

थ्रेड सेफ़्टी

• 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 फ़ंक्शन का इस्तेमाल कर सकता है. यह फ़ंक्शन, XrSceneMeshSnapshotCreationResultANDROID स्ट्रक्चर में रैप किए गए XrSceneMeshTrackingStateANDROID के साथ-साथ XrSceneMeshSnapshotANDROID हैंडल दिखाता है. टेक्निकल तौर पर, हैंडल, सीन मेश डेटा का स्नैपशॉट होता है. यह स्नैपशॉट, हैंडल बनाने के समय लिया जाता है. इस हैंडल का इस्तेमाल, सीन मेश की जानकारी और डेटा के बारे में क्वेरी करने के लिए किया जा सकता है. इसके लिए, 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 इन्यूमरेशन, सिमैंटिक लेबल का डिफ़ॉल्ट सेट है. इसका इस्तेमाल, मेश वर्टेक्स को लेबल करने के लिए किया जा सकता है. इससे यह पता चलता है कि मेश वर्टेक्स, किस फ़िज़िकल एनवायरमेंट की सतह पर है. इस एनम सेट को 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 की जानकारी

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 का मान्य हैंडल होना चाहिए

थ्रेड सेफ़्टी

• 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

नए एनम

• 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 (सैलर खान)

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