Android XR for OpenXR | Android Developers

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

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

XR_ANDROID_trackables_marker

Name String

XR_ANDROID_trackables_marker

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

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

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

708

बदलाव

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

मंज़ूरी नहीं मिली

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

XR_ANDROID_trackables

बंद होने की स्थिति

XR_EXT_spatial_marker_tracking एक्सटेंशन की मदद से बंद किया गया

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

2025-07-23

आईपी स्टेटस

बौद्धिक संपत्ति से जुड़े किसी दावे की जानकारी नहीं है.

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

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

खास जानकारी

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

यह एक्सटेंशन, जाने-माने मार्कर टाइप के साथ काम करता है. खास तौर पर, ArUco और April Tags के साथ. इससे रनटाइम को मार्कर के साइज़ का अनुमान लगाने की सुविधा मिलती है. हालांकि, यह ज़रूरी नहीं है.

अनुमतियां

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

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

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

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

typedef struct XrSystemMarkerTrackingPropertiesANDROID {
    XrStructureType    type;
    void*              next;
    XrBool32           supportsMarkerTracking;
    XrBool32           supportsMarkerSizeEstimation;
    uint16_t           maxMarkerCount;
} XrSystemMarkerTrackingPropertiesANDROID;

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

type, इस स्ट्रक्चर का XrStructureType है.
next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है. OpenXR के मुख्य वर्शन या इस एक्सटेंशन में, इस तरह के स्ट्रक्चर के बारे में नहीं बताया गया है. स्ट्रक्चर चेन के बारे में ज़्यादा जानकारी के लिए, एक्सटेंड किए जा रहे स्ट्रक्चर ( XrSystemProperties ) को देखें.
supportsMarkerTracking एक XrBool32 है. इससे पता चलता है कि मौजूदा सिस्टम में मार्कर ट्रैकिंग की सुविधा है या नहीं.
supportsMarkerSizeEstimation एक XrBool32 है. इससे पता चलता है कि मौजूदा सिस्टम, मार्कर के साइज़ का अनुमान देता है या नहीं.
maxMarkerCount, मार्कर की वह ज़्यादा से ज़्यादा संख्या है जिसे रनटाइम एक ही समय पर ट्रैक कर सकता है.

कोई ऐप्लिकेशन यह जांच कर सकता है कि सिस्टम, मार्कर ट्रैकिंग की सुविधा के साथ काम करता है या नहीं. इसके लिए, xrGetSystemProperties को कॉल करते समय, XrSystemProperties को XrSystemMarkerTrackingPropertiesANDROID स्ट्रक्चर के साथ जोड़ना होगा. मार्कर ट्रैकर बनाने के लिए, रनटाइम को XR_ERROR_FEATURE_UNSUPPORTED ज़रूर दिखाना चाहिए. ऐसा सिर्फ़ तब होना चाहिए, जब supportsMarkerTracking, XR_FALSE हो.

अगर कोई रनटाइम, मार्कर ट्रैकिंग के साथ काम करता है, तो maxMarkerCount की वैल्यू कम से कम 1 होनी चाहिए.

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

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

ट्रैकिंग मार्कर

यह एक्सटेंशन, XrTrackableTypeANDROID में XR_TRACKABLE_TYPE_MARKER_ANDROID जोड़ता है.

ऐप्लिकेशन, xrCreateTrackableTrackerANDROID को कॉल करके और XrTrackableTrackerCreateInfoANDROID :: trackableType में ट्रैक किए जा सकने वाले टाइप के तौर पर XR_TRACKABLE_TYPE_MARKER_ANDROID को तय करके, XrTrackableTrackerANDROID बनाता है. साथ ही, XrTrackableTrackerCreateInfoANDROID की अगली चेन में XrTrackableMarkerConfigurationANDROID को जोड़कर, मान्य कॉन्फ़िगरेशन सेट करता है.

अगर XrTrackableTrackerCreateInfoANDROID :: trackableType, XR_TRACKABLE_TYPE_MARKER_ANDROID है और XrSystemMarkerTrackingPropertiesANDROID :: supportsMarkerTracking, xrGetSystemProperties के ज़रिए XR_FALSE दिखाता है, तो रनटाइम को XR_ERROR_FEATURE_UNSUPPORTED दिखाना चाहिए.

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

typedef struct XrTrackableMarkerConfigurationANDROID {
    XrStructureType                            type;
    void*                                      next;
    XrTrackableMarkerTrackingModeANDROID       trackingMode;
    uint32_t                                   databaseCount;
    const XrTrackableMarkerDatabaseANDROID*    databases;
} XrTrackableMarkerConfigurationANDROID;

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

type, इस स्ट्रक्चर का XrStructureType है.
next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
trackingMode, XrTrackableMarkerTrackingModeANDROID है. इससे ट्रैकिंग के लिए पसंदीदा मोड का पता चलता है.
databaseCount एक uint32_t है, जो databases कलेक्शन में मौजूद एलिमेंट की संख्या बताता है.
databases, XrTrackableMarkerDatabaseANDROID के कलेक्शन का पॉइंटर है. इनमें से हर एक में, ट्रैक करने के लिए दी गई डिक्शनरी से चुने गए मार्कर शामिल होते हैं.

ऐप्लिकेशन को मान्य कॉन्फ़िगरेशन सेट करना ज़रूरी है. इसके लिए, XrTrackableTrackerCreateInfoANDROID :: trackableType को XR_TRACKABLE_TYPE_MARKER_ANDROID पर सेट करके, xrCreateTrackableTrackerANDROID को कॉल करते समय, XrTrackableTrackerCreateInfoANDROID :: next चेन में XrTrackableMarkerConfigurationANDROID जोड़ें. अगर ट्रैकर टाइप ऊपर बताए गए तरीके से सेट किया गया है, लेकिन कॉन्फ़िगरेशन स्ट्रक्चर मौजूद नहीं है या मान्य नहीं है, तो रनटाइम को XR_ERROR_VALIDATION_FAILURE नतीजे के तौर पर ज़रूर दिखाना चाहिए.

अगर कोई रनटाइम, मार्कर के साइज़ का अनुमान लगाने की सुविधा के साथ काम करता है, तो ऐप्लिकेशन XrTrackableMarkerDatabaseEntryANDROID :: edgeSize को 0 पर सेट कर सकता है. इसके लिए, उसे XrTrackableMarkerDatabaseANDROID :: entries में जाकर, साइज़ के अनुमान के इस्तेमाल के बारे में बताना होगा. ऐसा न होने पर, ऐप्लिकेशन को XrTrackableMarkerDatabaseEntryANDROID :: edgeSize को पॉज़िटिव वैल्यू पर सेट करना चाहिए या रनटाइम को XR_ERROR_VALIDATION_FAILURE दिखाना चाहिए .

रनटाइम को xrGetAllTrackablesANDROID से मिले आउटपुट को फ़िल्टर करना चाहिए, ताकि वह trackingMode और XrTrackableMarkerDatabaseEntryANDROID :: edgeSize से मैच हो सके.

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

XrTrackableMarkerConfigurationANDROID का इस्तेमाल करने से पहले, XR_ANDROID_trackables_marker एक्सटेंशन चालू करना ज़रूरी है
type की वैल्यू XR_TYPE_TRACKABLE_MARKER_CONFIGURATION_ANDROID होनी चाहिए
next NULL या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
trackingMode की वैल्यू, XrTrackableMarkerTrackingModeANDROID की मान्य वैल्यू होनी चाहिए
databases को databaseCount मान्य XrTrackableMarkerDatabaseANDROID स्ट्रक्चर के कलेक्शन का पॉइंटर होना चाहिए
databaseCount पैरामीटर की वैल्यू, 0 से ज़्यादा होनी चाहिए

XrTrackableMarkerTrackingModeANDROID enum, मार्कर के लिए इस्तेमाल किए जा सकने वाले ट्रैकिंग मोड के बारे में बताता है.

typedef enum XrTrackableMarkerTrackingModeANDROID {
    XR_TRACKABLE_MARKER_TRACKING_MODE_DYNAMIC_ANDROID = 0,
    XR_TRACKABLE_MARKER_TRACKING_MODE_STATIC_ANDROID = 1,
    XR_TRACKABLE_MARKER_TRACKING_MODE_MAX_ENUM_ANDROID = 0x7FFFFFFF
} XrTrackableMarkerTrackingModeANDROID;

Enumerant Descriptions

XR_TRACKABLE_MARKER_TRACKING_MODE_DYNAMIC_ANDROID — डाइनैमिक मार्कर ट्रैक करना. इस मोड में सबसे सटीक नतीजे मिलते हैं. यह मूविंग और स्टैटिक मार्कर पर काम करता है. हालांकि, इसमें बिजली की खपत सबसे ज़्यादा होती है.
XR_TRACKABLE_MARKER_TRACKING_MODE_STATIC_ANDROID — स्टैटिक मार्कर ट्रैक करना. यह मोड मुख्य रूप से उन मार्कर के लिए काम का है जो स्टैटिक होते हैं. इससे डाइनैमिक मोड की तुलना में कम बैटरी खर्च होती है.

XrTrackableMarkerDatabaseANDROID स्ट्रक्चर, एक डिक्शनरी और उससे जुड़े मार्कर आईडी तय करता है, जिन्हें ट्रैक किया जाना है.

typedef struct XrTrackableMarkerDatabaseANDROID {
    XrTrackableMarkerDictionaryANDROID              dictionary;
    uint32_t                                        entryCount;
    const XrTrackableMarkerDatabaseEntryANDROID*    entries;
} XrTrackableMarkerDatabaseANDROID;

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

dictionary, XrTrackableMarkerDictionaryANDROID है, जिससे सभी entries जुड़े हैं.
entryCount एक uint32_t है, जो entries कलेक्शन में मौजूद एलिमेंट की संख्या बताता है. ऐप्लिकेशन, dictionary में सभी मार्कर ट्रैक करने के लिए, entryCount 0 सेट कर सकता है.
entries, XrTrackableMarkerDatabaseEntryANDROID के कलेक्शन का पॉइंटर है. इसमें से हर एक में, ट्रैक किए जाने वाले मार्कर का कॉन्फ़िगरेशन शामिल होता है.

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

XrTrackableMarkerDatabaseANDROID का इस्तेमाल करने से पहले, XR_ANDROID_trackables_marker एक्सटेंशन चालू करना ज़रूरी है
dictionary की वैल्यू, XrTrackableMarkerDictionaryANDROID की मान्य वैल्यू होनी चाहिए
अगर entryCount की वैल्यू 0 नहीं है, तो entries को entryCount XrTrackableMarkerDatabaseEntryANDROID स्ट्रक्चर के कलेक्शन का पॉइंटर होना चाहिए

XrTrackableMarkerDictionaryANDROID enum, इस्तेमाल की जा सकने वाली मार्कर डिक्शनरी के बारे में बताता है.

typedef enum XrTrackableMarkerDictionaryANDROID {
    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_50_ANDROID = 0,
    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_100_ANDROID = 1,
    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_250_ANDROID = 2,
    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_1000_ANDROID = 3,
    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_50_ANDROID = 4,
    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_100_ANDROID = 5,
    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_250_ANDROID = 6,
    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_1000_ANDROID = 7,
    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_50_ANDROID = 8,
    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_100_ANDROID = 9,
    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_250_ANDROID = 10,
    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_1000_ANDROID = 11,
    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_50_ANDROID = 12,
    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_100_ANDROID = 13,
    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_250_ANDROID = 14,
    XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_1000_ANDROID = 15,
    XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_16H5_ANDROID = 16,
    XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_25H9_ANDROID = 17,
    XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_36H10_ANDROID = 18,
    XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_36H11_ANDROID = 19,
    XR_TRACKABLE_MARKER_DICTIONARY_MAX_ENUM_ANDROID = 0x7FFFFFFF
} XrTrackableMarkerDictionaryANDROID;

XrTrackableMarkerDatabaseEntryANDROID स्ट्रक्चर, डिक्शनरी के एक मार्कर आईडी को कॉन्फ़िगर करता है.

typedef struct XrTrackableMarkerDatabaseEntryANDROID {
    int32_t    id;
    float      edgeSize;
} XrTrackableMarkerDatabaseEntryANDROID;

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

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

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

XrTrackableMarkerDatabaseEntryANDROID का इस्तेमाल करने से पहले, XR_ANDROID_trackables_marker एक्सटेंशन चालू करना ज़रूरी है

मार्कर पाएं

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

XrResult xrGetTrackableMarkerANDROID(
    XrTrackableTrackerANDROID                   tracker,
    const XrTrackableGetInfoANDROID*            getInfo,
    XrTrackableMarkerANDROID*                   markerOutput);

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

tracker, क्वेरी करने के लिए XrTrackableTrackerANDROID है.
getInfo, XrTrackableGetInfoANDROID है. इसमें ट्रैक किए जा सकने वाले मार्कर को पाने के लिए इस्तेमाल की जाने वाली जानकारी शामिल होती है.
markerOutput, XrTrackableMarkerANDROID स्ट्रक्चर का पॉइंटर है. इसमें ट्रैक किया जा सकने वाला मार्कर दिखाया जाता है.

अगर XrTrackableANDROID का ट्रैक किया जा सकने वाला टाइप XR_TRACKABLE_TYPE_MARKER_ANDROID नहीं है या XrTrackableTrackerANDROID का ट्रैक किया जा सकने वाला टाइप XR_TRACKABLE_TYPE_MARKER_ANDROID नहीं है, तो रनटाइम को XR_ERROR_MISMATCHING_TRACKABLE_TYPE_ANDROID दिखाना चाहिए.

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

xrGetTrackableMarkerANDROID को कॉल करने से पहले, XR_ANDROID_trackables_marker एक्सटेंशन को चालू करना ज़रूरी है
tracker एक मान्य XrTrackableTrackerANDROID हैंडल होना चाहिए
getInfo को मान्य XrTrackableGetInfoANDROID स्ट्रक्चर का पॉइंटर होना चाहिए
markerOutput को XrTrackableMarkerANDROID स्ट्रक्चर का पॉइंटर होना चाहिए

रिटर्न कोड

सफलता

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_MISMATCHING_TRACKABLE_TYPE_ANDROID
XR_ERROR_RUNTIME_FAILURE
XR_ERROR_SESSION_LOST
XR_ERROR_TIME_INVALID
XR_ERROR_VALIDATION_FAILURE

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

typedef struct XrTrackableMarkerANDROID {
    XrStructureType                       type;
    void*                                 next;
    XrTrackingStateANDROID                trackingState;
    XrTime                                lastUpdatedTime;
    XrTrackableMarkerDictionaryANDROID    dictionary;
    int32_t                               markerId;
    XrPosef                               centerPose;
    XrExtent2Df                           extents;
} XrTrackableMarkerANDROID;

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

type, इस स्ट्रक्चर का XrStructureType है.
next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है. OpenXR के मुख्य वर्शन या इस एक्सटेंशन में, इस तरह के स्ट्रक्चर के बारे में नहीं बताया गया है.
trackingState, मार्कर का XrTrackingStateANDROID है.
lastUpdatedTime, मार्कर के आखिरी अपडेट का XrTime है.
dictionary, मार्कर का XrTrackableMarkerDictionaryANDROID है.
markerId, डिक्शनरी में दिया गया मार्कर आईडी है.
centerPose, XrTrackableGetInfoANDROID :: baseSpace में मौजूद मार्कर का XrPosef है. मार्कर, XZ प्लेन में होता है. इसमें X, मार्कर के दाईं ओर और Z, उसके नीचे की ओर इशारा करता है. वहीं, Y, मार्कर से सामान्य रूप से बाहर की ओर इशारा करता है.
extents, मार्कर का XrExtent2Df डाइमेंशन है. बाउंडिंग बॉक्स की सीमा इन पॉइंट पर है: centerPose +/- ( extents / 2).

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

XrTrackableMarkerANDROID का इस्तेमाल करने से पहले, XR_ANDROID_trackables_marker एक्सटेंशन चालू करना ज़रूरी है
type की वैल्यू XR_TYPE_TRACKABLE_MARKER_ANDROID होनी चाहिए
next NULL या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
trackingState की वैल्यू, XrTrackingStateANDROID की मान्य वैल्यू होनी चाहिए
dictionary की वैल्यू, XrTrackableMarkerDictionaryANDROID की मान्य वैल्यू होनी चाहिए

ट्रैक किए जा सकने वाले मार्कर पाने के लिए कोड का उदाहरण

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

XrInstance instance; // previously initialized
XrSystemId systemId; // previously initialized
XrSession session;   // previously initialized

// The function pointers are previously initialized using xrGetInstanceProcAddr.
PFN_xrGetSystemProperties xrGetSystemProperties;                       // previously initialized
PFN_xrCreateTrackableTrackerANDROID xrCreateTrackableTrackerANDROID;   // previously initialized
PFN_xrGetAllTrackablesANDROID xrGetAllTrackablesANDROID;               // previously initialized
PFN_xrGetTrackableMarkerANDROID xrGetTrackableMarkerANDROID;           // previously initialized
PFN_xrDestroyTrackableTrackerANDROID xrDestroyTrackableTrackerANDROID; // previously initialized

XrTime updateTime; // Time used for the current frame's simulation update.
XrSpace appSpace;  // Space created for XR_REFERENCE_SPACE_TYPE_LOCAL.

// Inspect system capability
XrSystemMarkerTrackingPropertiesANDROID markerProperty {
  .type = XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_ANDROID,
  .next = nullptr,
};
XrSystemProperties systemProperties {
  .type = XR_TYPE_SYSTEM_PROPERTIES,
  .next = &markerProperty,
};
CHK_XR(xrGetSystemProperties(instance, systemId, &systemProperties));
if (!markerProperty.supportsMarkerTracking) {
    // Marker tracking is not supported.
    return;
}

// Create a trackable tracker for marker tracking.
// If the runtime does not support size estimation, configures marker edge size of 0.1m.
XrTrackableMarkerDatabaseEntryANDROID markerEntries {
  .id = 0,
  .edgeSize = markerProperty.supportsMarkerSizeEstimation ? 0.0f : 0.1f,
};
XrTrackableMarkerDatabaseANDROID markerDatabases {
  .dictionary = XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_50_ANDROID,
  .entryCount = 1,
  .entries = &markerEntries,
};
XrTrackableMarkerConfigurationANDROID configuration {
  .type = XR_TYPE_TRACKABLE_MARKER_CONFIGURATION_ANDROID,
  .next = nullptr,
  .trackingMode = XR_TRACKABLE_MARKER_TRACKING_MODE_DYNAMIC_ANDROID,
  .databaseCount = 1,
  .databases = &markerDatabases,
};
XrTrackableTrackerCreateInfoANDROID createInfo {
  .type = XR_TYPE_TRACKABLE_TRACKER_CREATE_INFO_ANDROID,
  .next = &configuration,
  .trackableType = XR_TRACKABLE_TYPE_MARKER_ANDROID,
};
XrTrackableTrackerANDROID markerTracker;
auto res = xrCreateTrackableTrackerANDROID(session, &createInfo, &markerTracker);
if (res == XR_ERROR_PERMISSION_INSUFFICIENT) {
    // Handle permission requests.
}
CHK_XR(res);

// Get markers.
std::vector<XrTrackableANDROID> trackables(markerProperty.maxMarkerCount);
std::vector<XrTrackableMarkerANDROID> markers(markerProperty.maxMarkerCount, {
  .type = XR_TYPE_TRACKABLE_MARKER_ANDROID,
  .next = nullptr,
});
uint32_t markerSize = 0;
CHK_XR(xrGetAllTrackablesANDROID(markerTracker, markerProperty.maxMarkerCount, &markerSize,
                                 trackables.data()));
for (int i = 0; i < markerSize; i++) {
    XrTrackableGetInfoANDROID getInfo {
      .type = XR_TYPE_TRACKABLE_GET_INFO_ANDROID,
      .next = nullptr,
      .trackable = trackables[i],
      .baseSpace = appSpace,
      .time = updateTime,
    };
    CHK_XR(xrGetTrackableMarkerANDROID(markerTracker, &getInfo, &markers[i]));
    // Handle markers.
}

// Release trackable tracker.
CHK_XR(xrDestroyTrackableTrackerANDROID(markerTracker));

नए निर्देश

xrGetTrackableMarkerANDROID

नए स्ट्रक्चर

XrTrackableMarkerANDROID
XrTrackableMarkerDatabaseANDROID
XrTrackableMarkerDatabaseEntryANDROID
XrSystemProperties को एक्सटेंड करना :
- XrSystemMarkerTrackingPropertiesANDROID
XrTrackableTrackerCreateInfoANDROID को एक्सटेंड करना :
- XrTrackableMarkerConfigurationANDROID

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

XR_ANDROID_TRACKABLES_MARKER_EXTENSION_NAME
XR_ANDROID_trackables_marker_SPEC_VERSION
XrStructureType को एक्सटेंड करना :
- XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_ANDROID
- XR_TYPE_TRACKABLE_MARKER_ANDROID
- XR_TYPE_TRACKABLE_MARKER_CONFIGURATION_ANDROID
XrTrackableTypeANDROID को एक्सटेंड करना :
- XR_TRACKABLE_TYPE_MARKER_ANDROID

समस्याएं

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

पहला बदलाव, 23-07-2025 (लेवाना चेन)
- एक्सटेंशन का शुरुआती ब्यौरा.