Android XR for OpenXR | Android Developers

Android XR SDK का चौथा डेवलपर प्रीव्यू वर्शन उपलब्ध है. हमें आपकी राय का इंतज़ार है! इसे आज़माएं और हमसे संपर्क करने के लिए, हमारे सहायता पेज पर जाएं.

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

XR_ANDROID_trackables_marker

नाम वाली स्ट्रिंग

XR_ANDROID_trackables_marker

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

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

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

708

संशोधन

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

पुष्टि नहीं की गई

एक्सटेंशन और वर्शन की ज़रूरी शर्तें

XR_ANDROID_trackables

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

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

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

2025-07-23

आईपी की स्थिति

आईपी से जुड़े किसी दावे की जानकारी नहीं है.

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

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

खास जानकारी

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

यह एक्सटेंशन, 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 स्ट्रक्चर के साथ बढ़ाकर, कोई ऐप्लिकेशन यह देख सकता है कि सिस्टम में मार्कर ट्रैकिंग की सुविधा है या नहीं. अगर supportsMarkerTracking की वैल्यू XR_FALSE है, तो मार्कर ट्रैकर बनाने के लिए रनटाइम को XR_ERROR_FEATURE_UNSUPPORTED ज़रूर दिखाना होगा. इसके अलावा, किसी और स्थिति में यह गड़बड़ी नहीं दिखनी चाहिए.

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

मान्य इस्तेमाल (सीधे तौर पर न दिखाना)

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

मार्कर ट्रैक करना

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

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

अगर XrTrackableTrackerCreateInfoANDROID :: trackableType की वैल्यू XR_TRACKABLE_TYPE_MARKER_ANDROID है और xrGetSystemProperties के ज़रिए, XrSystemMarkerTrackingPropertiesANDROID :: supportsMarkerTracking की वैल्यू 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 के कलेक्शन का पॉइंटर है. इनमें से हर एक में, ट्रैक करने के लिए दिए गए डिक्शनरी से मनचाहे मार्कर शामिल होते हैं.

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

अगर रनटाइम में मार्कर के साइज़ का अनुमान लगाने की सुविधा है, तो ऐप्लिकेशन सेट करके, साइज़ का अनुमान लगाने की सुविधा के इस्तेमाल के बारे में बता सकता है: XrTrackableMarkerDatabaseEntryANDROID :: को में XrTrackableMarkerDatabaseANDROID :: .edgeSize0entries अगर ऐसा नहीं किया जाता है, तो ऐप्लिकेशन को ज़रूर 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 की जानकारी

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

गड़बड़ी

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

समस्याएं

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

संशोधन 1, 23 जुलाई, 2025 (लेवाना चेन)
- एक्सटेंशन की शुरुआती जानकारी.