XR_EXT_spatial_image_tracking

Name String

XR_EXT_spatial_image_tracking

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

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

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

783

बदलाव

1

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

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

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

XR_EXT_spatial_entity

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

डेनियल गटनबर्ग, Qualcomm
निहाव जैन, Google
जैरेड फ़ाइंडर, Google
ज़ीपेंग लियू, ByteDance

खास जानकारी

यह एक्सटेंशन, XR_EXT_spatial_entity एक्सटेंशन के लिए इमेज ट्रैकिंग की सुविधा देता है. इससे ऐप्लिकेशन, इनपुट के तौर पर दी गई रेफ़रंस इमेज के सेट के हिसाब से, खास समतल इमेज का पता लगा सकते हैं और उन्हें ट्रैक कर सकते हैं.

ट्रैक की गई इमेज को स्पेसियल इकाई के तौर पर दिखाया जाता है. इसमें ये कॉम्पोनेंट होते हैं:

• XR_SPATIAL_COMPONENT_TYPE_IMAGE_2D_EXT
• XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT

ऐप्लिकेशन आम तौर पर, स्पेशल इमेज ट्रैकिंग एक्सटेंशन का इस्तेमाल इस पैटर्न में करते हैं:

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

रनटाइम से जुड़ी सहायता

रनटाइम को xrEnumerateSpatialCapabilitiesEXT का इस्तेमाल करके, इमेज ट्रैकिंग की सुविधा के लिए अपने सपोर्ट का विज्ञापन ज़रूर करना चाहिए. इसके लिए, उसे इस सुविधा को लिस्ट करना होगा:

• XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT

कॉन्फ़िगरेशन

प्लेनर इमेज की पहचान और ट्रैकिंग की सुविधा चालू करने के लिए, ऐप्लिकेशन can XrSpatialCapabilityConfigurationImageTrackingEXT स्ट्रक्चर को XrSpatialContextCreateInfoEXT :: capabilityConfigs में पास कर सकता है. ऐसा xrCreateSpatialContextAsyncEXT फ़ंक्शन को कॉल करते समय और हर XrSpatialCapabilityConfigurationImageTrackingEXT :: imageTrackingDatabases में< XrSpatialImageTrackingDatabaseEXT स्ट्रक्चर के कलेक्शन को पास करते समय किया जा सकता है.

इनपुट इमेज सेट बनाना

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

XR_DEFINE_HANDLE(XrSpatialImageTrackingDatabaseEXT)

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

स्पेशल इमेज ट्रैकिंग डेटाबेस बनाना

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

XrResult xrCreateSpatialImageTrackingDatabaseAsyncEXT(
    XrSession                                   session,
    const XrSpatialImageTrackingDatabaseCreateInfoEXT* createInfo,
    XrFutureEXT*                                future);

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

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

कोई ऐप्लिकेशन, xrCreateSpatialImageTrackingDatabaseAsyncEXT फ़ंक्शन का इस्तेमाल करके, XrSpatialImageTrackingDatabaseEXT हैंडल बना सकता है. साथ ही, createInfo का इस्तेमाल करके, इमेज ट्रैकिंग डेटाबेस की इनपुट रेफ़रंस इमेज के सेट कॉन्फ़िगर कर सकता है.

अगर इनपुट के तौर पर दी गई किसी भी रेफ़रंस इमेज का XrSpatialReferenceImageEXT :: format, xrEnumerateSpatialReferenceImageFormatsEXT से नहीं मिलता है, तो रनटाइम को XR_ERROR_SPATIAL_IMAGE_FORMAT_UNSUPPORTED_EXT ज़रूर दिखाना चाहिए.

अगर XrSpatialReferenceImageEXT :: planes के इनपुट के तौर पर इस्तेमाल की गई किसी भी रेफ़रंस इमेज के कलेक्शन का आकलन, XrSpatialReferenceImageEXT के रेफ़रंस इमेज के मेटाडेटा के मुताबिक नहीं किया जा सकता, तो रनटाइम को XR_ERROR_SPATIAL_IMAGE_INVALID_EXT दिखाना चाहिए.

अगर इनपुट के तौर पर दी गई किसी भी रेफ़रंस इमेज का XrSpatialReferenceImageEXT :: planes कलेक्शन, उतने प्लेन उपलब्ध नहीं कराता जितने XrSpatialReferenceImageEXT :: format में कलर चैनल हैं, तो रनटाइम को XR_ERROR_SPATIAL_IMAGE_INVALID_EXT दिखाना चाहिए.

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

यह फ़ंक्शन, एसिंक्रोनस ऑपरेशन शुरू करता है और उससे जुड़ा XrFutureEXT बनाता है. इसका इस्तेमाल, xrPollFutureEXT और उससे जुड़े फ़ंक्शन के साथ किया जा सकता है. इस फ़ंक्शन की रिटर्न वैल्यू से सिर्फ़ यह पता चलता है कि एसिंक्रोनस ऑपरेशन को शेड्यूल करने के लिए, पैरामीटर स्वीकार किए जा सकते हैं या नहीं. इसके लिए, xrCreateSpatialImageTrackingDatabaseCompleteEXT फ़ंक्शन का इस्तेमाल किया जाता है. इसका इस्तेमाल तब किया जा सकता है, जब इस फ़ंक्शन से मिलने वाला फ़्यूचर READY स्टेटस में हो. साथ ही, इस फ़ंक्शन से मिलने वाले आउटपुट, XrCreateSpatialImageTrackingDatabaseCompletionEXT स्ट्रक्चर में मौजूद हों.

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

• xrCreateSpatialImageTrackingDatabaseAsyncEXT को कॉल करने से पहले, XR_EXT_spatial_image_tracking एक्सटेंशन को चालू करना ज़रूरी है
• session एक मान्य XrSession हैंडल होना चाहिए
• createInfo को किसी मान्य XrSpatialImageTrackingDatabaseCreateInfoEXT स्ट्रक्चर का पॉइंटर होना चाहिए
• future को XrFutureEXT वैल्यू का पॉइंटर होना चाहिए

रिटर्न कोड

सफलता

• 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_PERMISSION_INSUFFICIENT
• XR_ERROR_RUNTIME_FAILURE
• XR_ERROR_SESSION_LOST
• XR_ERROR_SPATIAL_IMAGE_FORMAT_UNSUPPORTED_EXT
• XR_ERROR_SPATIAL_IMAGE_INVALID_EXT
• XR_ERROR_SPATIAL_IMAGE_SIZE_MISSING_EXT
• XR_ERROR_VALIDATION_FAILURE

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

typedef struct XrSpatialImageTrackingDatabaseCreateInfoEXT {
    XrStructureType                      type;
    const void*                          next;
    uint32_t                             spatialReferenceImageCount;
    const XrSpatialReferenceImageEXT*    spatialReferenceImages;
} XrSpatialImageTrackingDatabaseCreateInfoEXT;

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

• type, इस स्ट्रक्चर का XrStructureType है.
• next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
• spatialReferenceImageCount, spatialReferenceImages कलेक्शन में मौजूद एलिमेंट की संख्या है.
• spatialReferenceImages, XrSpatialReferenceImageEXT का एक कलेक्शन है.

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

हर XrSpatialImageTrackingDatabaseEXT को XrSpatialImageTrackingDatabaseCreateInfoEXT :: spatialReferenceImages कलेक्शन में, कम से कम एक XrSpatialReferenceImageEXT के साथ बनाया जाना चाहिए.

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

• XrSpatialImageTrackingDatabaseCreateInfoEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_image_tracking एक्सटेंशन चालू करना ज़रूरी है
• type की वैल्यू XR_TYPE_SPATIAL_IMAGE_TRACKING_DATABASE_CREATE_INFO_EXT होनी चाहिए
• next को NULL या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए. यह भी देखें: XrSpatialImageSizeEXT , XrSpatialImageStaticOptimizationEXT
• spatialReferenceImages को spatialReferenceImageCount मान्य XrSpatialReferenceImageEXT स्ट्रक्चर के कलेक्शन का पॉइंटर होना चाहिए
• spatialReferenceImageCount पैरामीटर की वैल्यू, 0 से ज़्यादा होनी चाहिए

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

XrResult xrCreateSpatialImageTrackingDatabaseCompleteEXT(
    XrSession                                   session,
    XrFutureEXT                                 future,
    XrCreateSpatialImageTrackingDatabaseCompletionEXT* completion);

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

• session, XrSession है, जिसे पहले xrCreateSpatialContextAsyncEXT :: session को पास किया गया था.
• future, xrCreateSpatialContextAsyncEXT से मिला XrFutureEXT है.
• completion, XrCreateSpatialImageTrackingDatabaseCompletionEXT का पॉइंटर है.

xrCreateSpatialImageTrackingDatabaseCompleteEXT, xrCreateSpatialImageTrackingDatabaseAsyncEXT से शुरू किए गए एसिंक्रोनस ऑपरेशन को पूरा करता है.

रनटाइम को किसी भी XrSpatialReferenceImagePlaneEXT :: buffer पॉइंटर को ऐक्सेस नहीं करना चाहिए. ये पॉइंटर, XrSpatialImageTrackingDatabaseCreateInfoEXT :: spatialReferenceImages इनपुट कलेक्शन ने इस xrCreateSpatialImageTrackingDatabaseAsyncEXT कॉल के पूरा होने के बाद उपलब्ध कराए थे. हो सकता है कि ऐप्लिकेशन, XrSpatialReferenceImagePlaneEXT :: buffer डेटा को खाली कर दे. ऐसा xrCreateSpatialImageTrackingDatabaseAsyncEXT के पूरा होने के बाद किया जा सकता है, ताकि मेमोरी फ़ुटप्रिंट को कम किया जा सके.

अगर future तैयार नहीं है, तो रनटाइम को XR_ERROR_FUTURE_PENDING_EXT दिखाना चाहिए. अगर future पहले ही पूरा हो चुका है या रद्द कर दिया गया है, तो रनटाइम को XR_ERROR_FUTURE_INVALID_EXT दिखाना चाहिए.

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

• xrCreateSpatialImageTrackingDatabaseCompleteEXT को कॉल करने से पहले, XR_EXT_spatial_image_tracking एक्सटेंशन को चालू करना ज़रूरी है
• session एक मान्य XrSession हैंडल होना चाहिए
• completion को XrCreateSpatialImageTrackingDatabaseCompletionEXT स्ट्रक्चर का पॉइंटर होना चाहिए

रिटर्न कोड

सफलता

• XR_SUCCESS
• XR_SESSION_LOSS_PENDING

Failure

• XR_ERROR_FUNCTION_UNSUPPORTED
• XR_ERROR_FUTURE_INVALID_EXT
• XR_ERROR_FUTURE_PENDING_EXT
• 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

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

typedef struct XrCreateSpatialImageTrackingDatabaseCompletionEXT {
    XrStructureType                      type;
    void*                                next;
    XrResult                             futureResult;
    XrSpatialImageTrackingDatabaseEXT    database;
} XrCreateSpatialImageTrackingDatabaseCompletionEXT;

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

• type, इस स्ट्रक्चर का XrStructureType है.
• next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
• futureResult, स्पेशल इमेज ट्रैकिंग डेटाबेस बनाने की प्रोसेस का XrResult है.
• database एक XrSpatialImageTrackingDatabaseEXT है. इसे xrCreateSpatialImageTrackingDatabaseAsyncEXT :: createInfo में मौजूद डेटा और कॉन्फ़िगरेशन का इस्तेमाल करके बनाया गया है.

आने वाले समय में मिलने वाले रिटर्न कोड

futureResult वैल्यू:

सफलता

• XR_SUCCESS
• XR_SESSION_LOSS_PENDING

Failure

• XR_ERROR_RUNTIME_FAILURE
• XR_ERROR_INSTANCE_LOST
• XR_ERROR_SESSION_LOST
• XR_ERROR_OUT_OF_MEMORY
• XR_ERROR_LIMIT_REACHED
• XR_ERROR_SPATIAL_IMAGE_FORMAT_UNSUPPORTED_EXT
• XR_ERROR_SPATIAL_IMAGE_INVALID_EXT

अगर futureResult एक सक्सेस कोड है, तो database एक मान्य हैंडल होना चाहिए. अगर database मान्य है, तो यह सिर्फ़ xrCreateSpatialImageTrackingDatabaseAsyncEXT :: session के लाइफ़साइकल के दौरान या तब तक मान्य रहता है, जब तक ऐप्लिकेशन xrDestroySpatialImageTrackingDatabaseEXT के साथ database को खत्म नहीं कर देता. इनमें से जो भी पहले हो.

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

• XrCreateSpatialImageTrackingDatabaseCompletionEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_image_tracking एक्सटेंशन चालू करना ज़रूरी है
• type की वैल्यू XR_TYPE_CREATE_SPATIAL_IMAGE_TRACKING_DATABASE_COMPLETION_EXT होनी चाहिए
• next NULL या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
• futureResult must be a valid XrResult value
• database एक मान्य XrSpatialImageTrackingDatabaseEXT हैंडल होना चाहिए

स्पेशल इमेज ट्रैकिंग डेटाबेस को मिटाना

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

XrResult xrDestroySpatialImageTrackingDatabaseEXT(
    XrSpatialImageTrackingDatabaseEXT           database);

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

• database एक XrSpatialImageTrackingDatabaseEXT है, जिसे पहले xrCreateSpatialImageTrackingDatabaseAsyncEXT ने बनाया था.

स्पेशल इमेज को खोजने और अपडेट करने के टास्क पूरे होने के बाद, ऐप्लिकेशन xrDestroySpatialImageTrackingDatabaseEXT फ़ंक्शन को कॉल कर सकता है. इससे database हैंडल और उससे जुड़े संसाधनों को रिलीज़ किया जा सकता है.

ऐप्लिकेशन, xrDestroySpatialContextEXT को कॉल करने से पहले, xrDestroySpatialImageTrackingDatabaseEXT फ़ंक्शन को कॉल कर सकता है. रनटाइम को अब इस नष्ट किए गए XrSpatialImageTrackingDatabaseEXT से मैनेज की गई इमेज की जानकारी नहीं देनी चाहिए. रनटाइम को अन्य डेटाबेस से मैनेज की जाने वाली इमेज की जानकारी देना जारी रखना चाहिए.

रनटाइम को यह पक्का करना चाहिए कि xrCreateSpatialDiscoverySnapshotCompleteEXT से मिले डिस्कवरी स्नैपशॉट में, नष्ट किए गए या अमान्य XrSpatialImageTrackingDatabaseEXT हैंडल से जुड़ी इमेज शामिल न हों. भले ही, ऐप्लिकेशन के xrCreateSpatialDiscoverySnapshotAsyncEXT को कॉल करने के बाद हैंडल को नष्ट कर दिया गया हो. स्पेशल स्नैपशॉट में मौजूद डेटा में बदलाव नहीं किया जा सकता. इसलिए, ऐप्लिकेशन को database को खत्म करने से पहले, बनाए गए सभी XrSpatialSnapshotEXT हैंडल को खत्म कर देना चाहिए. ऐसा न करने पर, xrQuerySpatialComponentDataEXT का इस्तेमाल करते समय, ऐप्लिकेशन को अमान्य XrSpatialImageTrackingDatabaseEXT हैंडल मिल सकते हैं.

ऐप्लिकेशन, xrDestroySpatialContextEXT फ़ंक्शन को कॉल कर सकता है, ताकि XrSpatialContextEXT हैंडल को रिलीज़ किया जा सके. ऐसा, उन XrSpatialImageTrackingDatabaseEXT हैंडल को खत्म करने से पहले किया जा सकता है जिनकी मदद से XrSpatialContextEXT को बनाया गया था. XrSpatialContextEXT के खत्म होने पर, रनटाइम को इन XrSpatialImageTrackingDatabaseEXT हैंडल को अपने-आप खत्म नहीं करना चाहिए.

XrSpatialContextEXT और XrSpatialImageTrackingDatabaseEXT के लाइफ़टाइम को अलग-अलग मैनेज करने से, ऐप्लिकेशन पहले से बनाए गए XrSpatialImageTrackingDatabaseEXT हैंडल को फिर से इस्तेमाल कर सकते हैं. इसके लिए, उन्हें बनाने की प्रोसेस को फिर से दोहराने की ज़रूरत नहीं पड़ती.

उदाहरण के लिए, किसी XrSpatialContextEXT को खत्म करके, उसी XrSpatialImageTrackingDatabaseEXT के साथ दूसरा XrSpatialContextEXT बनाने से, इमेज ट्रैकिंग को रोका और फिर से शुरू किया जा सकता है. इसके लिए, फिर से शुरू करने की कोई दूसरी प्रोसेस करने की ज़रूरत नहीं पड़ती.

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

• xrDestroySpatialImageTrackingDatabaseEXT को कॉल करने से पहले, XR_EXT_spatial_image_tracking एक्सटेंशन चालू करना ज़रूरी है
• database एक मान्य XrSpatialImageTrackingDatabaseEXT हैंडल होना चाहिए

Thread की सुरक्षा

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

रिटर्न कोड

सफलता

• XR_SUCCESS

Failure

• XR_ERROR_FUNCTION_UNSUPPORTED
• XR_ERROR_HANDLE_INVALID
• XR_ERROR_RUNTIME_FAILURE

इनपुट इमेज फ़ॉर्मैट के लिए सहायता

ऐप्लिकेशन को xrEnumerateSpatialReferenceImageFormatsEXT को कॉल करना चाहिए, ताकि इनपुट के तौर पर इस्तेमाल की जा सकने वाली रेफ़रंस इमेज के इमेज फ़ॉर्मैट की सूची मिल सके.

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

XrResult xrEnumerateSpatialReferenceImageFormatsEXT(
    XrInstance                                  instance,
    XrSystemId                                  systemId,
    XrSpatialCapabilityEXT                      capability,
    uint32_t                                    formatCapacityInput,
    uint32_t*                                   formatCountOutput,
    XrSpatialReferenceImageFormatEXT*           formats);

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

• instance, XrInstance का हैंडल है.
• systemId वह XrSystemId है जिसके इनपुट रेफ़रंस इमेज फ़ॉर्मैट की गिनती की जाएगी.
• capability, XrSpatialCapabilityEXT है. इसके लिए, इनपुट के तौर पर इस्तेमाल की जाने वाली रेफ़रंस इमेज के फ़ॉर्मैट की गिनती की जाएगी.
• formatCapacityInput, formats कलेक्शन की क्षमता है. इसके अलावा, ज़रूरी क्षमता को वापस पाने के अनुरोध को दिखाने के लिए, 0 का इस्तेमाल किया जाता है.
• formatCountOutput, फ़ॉर्मैट की संख्या है या formatCapacityInput के कम होने पर ज़रूरी क्षमता है.
• formats, XrSpatialReferenceImageFormatEXT का एक कलेक्शन है. अगर formatCapacityInput की वैल्यू 0 है, तो यह NULL हो सकती है.
• ज़रूरी formats साइज़ को वापस पाने के बारे में ज़्यादा जानकारी के लिए, बफ़र साइज़ पैरामीटर सेक्शन देखें.

ऐप्लिकेशन, xrEnumerateSpatialReferenceImageFormatsEXT का इस्तेमाल करके, किसी XrSpatialCapabilityEXT के लिए, दिए गए XrSystemId के साथ काम करने वाले इनपुट रेफ़रंस इमेज फ़ॉर्मैट की सूची बना सकता है.

रनटाइम को उन एक्सटेंशन के फ़ॉर्मैट की गिनती नहीं करनी चाहिए जो instance के लिए चालू नहीं हैं.

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

• xrEnumerateSpatialReferenceImageFormatsEXT को कॉल करने से पहले, XR_EXT_spatial_image_tracking एक्सटेंशन चालू करना ज़रूरी है
• instance एक मान्य XrInstance हैंडल होना ज़रूरी है
• capability की वैल्यू, XrSpatialCapabilityEXT की मान्य वैल्यू होनी चाहिए
• formatCountOutput को uint32_t वैल्यू का पॉइंटर होना चाहिए
• अगर formatCapacityInput की वैल्यू 0 नहीं है, तो formats को formatCapacityInput XrSpatialReferenceImageFormatEXT वैल्यू के कलेक्शन का पॉइंटर होना चाहिए

रिटर्न कोड

सफलता

• 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_SPATIAL_CAPABILITY_UNSUPPORTED_EXT
• XR_ERROR_SYSTEM_INVALID
• XR_ERROR_VALIDATION_FAILURE

किसी भी एक्सटेंशन के साथ काम करने वाले सभी रेफ़रंस इमेज फ़ॉर्मैट की पूरी सूची देखने के लिए, XrSpatialReferenceImageFormatEXT देखें.

typedef enum XrSpatialReferenceImageFormatEXT {
    XR_SPATIAL_REFERENCE_IMAGE_FORMAT_RGBA_8888_EXT = 1,
    XR_SPATIAL_REFERENCE_IMAGE_FORMAT_RGB_888_EXT = 2,
    XR_SPATIAL_REFERENCE_IMAGE_FORMAT_YUV_420_888_EXT = 3,
    XR_SPATIAL_REFERENCE_IMAGE_FORMAT_MAX_ENUM_EXT = 0x7FFFFFFF
} XrSpatialReferenceImageFormatEXT;

XrSpatialReferenceImageFormatEXT एन्यूमरेशन, इनपुट रेफ़रंस इमेज के उन फ़ॉर्मैट की पहचान करता है जो रनटाइम के साथ काम कर सकते हैं.

कम से कम XR_SPATIAL_REFERENCE_IMAGE_FORMAT_RGBA_8888_EXT वैल्यू और XR_SPATIAL_REFERENCE_IMAGE_FORMAT_RGB_888_EXT वैल्यू ज़रूर इस्तेमाल की जानी चाहिए.

इन एन्यूमरेंट का यह मतलब है:

Enumerant Descriptions

• XR_SPATIAL_REFERENCE_IMAGE_FORMAT_RGBA_8888_EXT — एक आरजीबीए बफ़र. यह फ़ॉर्मैट, मेमोरी में पिक्सल डेटा के लेआउट की कोई गारंटी नहीं देता. पिक्सल को ऐक्सेस करने के लिए, उनसे जुड़े XrSpatialReferenceImagePlaneEXT स्ट्रक्चर से मिले मेटाडेटा का इस्तेमाल करना ज़रूरी है. हर पिक्सल कलर चैनल का साइज़ 8 बिट होता है. इस वजह से, हर पिक्सल का साइज़ 32 बिट होता है.
• XR_SPATIAL_REFERENCE_IMAGE_FORMAT_RGB_888_EXT — एक आरजीबी बफ़र. यह फ़ॉर्मैट, मेमोरी में पिक्सल डेटा के लेआउट की कोई गारंटी नहीं देता. पिक्सल को ऐक्सेस करने के लिए, उनसे जुड़े XrSpatialReferenceImagePlaneEXT स्ट्रक्चर से मिले मेटाडेटा का इस्तेमाल करना ज़रूरी है. हर पिक्सल कलर चैनल का साइज़ आठ बिट होता है. इस वजह से, हर पिक्सल का साइज़ 24 बिट होता है.
• XR_SPATIAL_REFERENCE_IMAGE_FORMAT_YUV_420_888_EXT — एक YUV बफ़र, जो 4:2:0 पैटर्न क्रोमा सब-सैंपल किया गया है. यह फ़ॉर्मैट, मेमोरी में पिक्सल डेटा के लेआउट की कोई गारंटी नहीं देता. पिक्सल को ऐक्सेस करने के लिए, उनसे जुड़े XrSpatialReferenceImagePlaneEXT स्ट्रक्चर से मिले मेटाडेटा का इस्तेमाल करना ज़रूरी है. डिकोड किए गए हर आरजीबी पिक्सल कलर चैनल का साइज़ आठ बिट होता है. इससे हर पिक्सल का साइज़ 24 बिट हो जाता है.

स्पेशल इमेज ट्रैकिंग की सेटिंग

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

स्टैटिक इमेज ऑप्टिमाइज़ेशन

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

typedef struct XrSpatialImageStaticOptimizationEXT {
    XrStructureType    type;
    const void*        next;
    XrBool32           optimizeForStaticImage;
} XrSpatialImageStaticOptimizationEXT;

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

• type, इस स्ट्रक्चर का XrStructureType है.
• next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
• optimizeForStaticImage एक XrBool32 है, जिससे पता चलता है कि इमेज मूव करती हैं या नहीं. XR_TRUE वैल्यू का मतलब है कि इमेज मूव नहीं होती हैं.

अगर XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT क्षमता के लिए, xrEnumerateSpatialCapabilityFeaturesEXT ने XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_STATIC_IMAGES_EXT को शामिल किया है, तो ऐप्लिकेशन XrSpatialImageStaticOptimizationEXT को XrSpatialImageTrackingDatabaseCreateInfoEXT :: next चेन या XrSpatialReferenceImageEXT :: next से चेन कर सकता है.

अगर ऐप्लिकेशन, XrSpatialImageStaticOptimizationEXT को XrSpatialImageTrackingDatabaseCreateInfoEXT स्ट्रक्चर से जोड़ता है, तो रनटाइम को यह मान लेना चाहिए कि उस XrSpatialImageTrackingDatabaseEXT की सभी इमेज स्टैटिक हैं. ऐसा तब होगा, जब optimizeForStaticImage को XR_TRUE पर सेट किया गया हो. इसी तरह, रनटाइम को यह मान लेना चाहिए कि अगर optimizeForStaticImage को XR_FALSE पर सेट किया गया है, तो उस XrSpatialImageTrackingDatabaseEXT की सभी इमेज स्टैटिक नहीं हैं.

अगर ऐप्लिकेशन, XrSpatialImageStaticOptimizationEXT को XrSpatialReferenceImageEXT स्ट्रक्चर से जोड़ता है, तो रनटाइम को यह मान लेना चाहिए कि अगर optimizeForStaticImage को XR_TRUE पर सेट किया गया है, तो यह रेफ़रंस इमेज स्टैटिक है. इसी तरह, अगर optimizeForStaticImage को XR_FALSE पर सेट किया गया है, तो रनटाइम को यह ज़रूर मानना चाहिए कि यह रेफ़रंस इमेज स्टैटिक नहीं है. XrSpatialImageStaticOptimizationEXT स्ट्रक्चर को XrSpatialReferenceImageEXT स्ट्रक्चर से चेन करने को, XrSpatialImageTrackingDatabaseCreateInfoEXT स्ट्रक्चर से चेन करने के मुकाबले ज़्यादा प्राथमिकता दी जाती है.

अगर XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_STATIC_IMAGES_EXT को XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT क्षमता के लिए xrEnumerateSpatialCapabilityFeaturesEXT से नहीं गिना जाता है और ऐप्लिकेशन, लागू होने वाली किसी भी अगली चेन में XrSpatialImageStaticOptimizationEXT स्ट्रक्चर को चेन करता है, तो रनटाइम को xrCreateSpatialImageTrackingDatabaseAsyncEXT से XR_ERROR_VALIDATION_FAILURE को ज़रूर दिखाना चाहिए.

इससे रनटाइम को ज़्यादा सटीक पोज़ और साइज़ जनरेट करने में मदद मिल सकती है.

इससे शायद रनटाइम को बिजली की खपत कम करने में मदद मिले.

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

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

रेफ़रंस के लिए इमेज की चौड़ाई

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

typedef struct XrSpatialImageSizeEXT {
    XrStructureType    type;
    const void*        next;
    float              physicalWidth;
} XrSpatialImageSizeEXT;

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

• type, इस स्ट्रक्चर का XrStructureType है.
• next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
• physicalWidth एक float वैल्यू है, जो मीटर में सेट की जाने वाली चौड़ाई को दिखाती है.

अगर XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT क्षमता के लिए, xrEnumerateSpatialCapabilityFeaturesEXT ने XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_FIXED_SIZE_IMAGES_EXT को शामिल किया है, तो ऐप्लिकेशन XrSpatialImageSizeEXT को XrSpatialImageTrackingDatabaseCreateInfoEXT :: next या XrSpatialReferenceImageEXT :: next से जोड़ सकता है.

अगर ऐप्लिकेशन, XrSpatialImageSizeEXT को XrSpatialImageTrackingDatabaseCreateInfoEXT स्ट्रक्चर से जोड़ता है, तो रनटाइम को यह मानना होगा कि उस XrSpatialImageTrackingDatabaseEXT की सभी इमेज की चौड़ाई physicalWidth मीटर है. साथ ही, उनकी ऊंचाई, आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) के हिसाब से है. यह जानकारी, XrSpatialReferenceImageEXT :: width और XrSpatialReferenceImageEXT :: height के ज़रिए दी जाती है.

अगर ऐप्लिकेशन, XrSpatialImageSizeEXT को XrSpatialReferenceImageEXT स्ट्रक्चर से जोड़ता है, तो रनटाइम को यह ज़रूर मानना चाहिए कि इस रेफ़रंस इमेज की चौड़ाई physicalWidth मीटर है. साथ ही, इसकी ऊंचाई, आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) के हिसाब से है. यह जानकारी, XrSpatialReferenceImageEXT :: width और XrSpatialReferenceImageEXT :: height के ज़रिए दी गई है. XrSpatialImageSizeEXT स्ट्रक्चर को XrSpatialReferenceImageEXT स्ट्रक्चर से जोड़ने को, XrSpatialImageTrackingDatabaseCreateInfoEXT स्ट्रक्चर से जोड़ने के मुकाबले ज़्यादा प्राथमिकता दी जाती है.

इससे रनटाइम को ज़्यादा सटीक पोज़ और साइज़ दिखाने में मदद मिल सकती है.

रनटाइम में XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_FIXED_SIZE_IMAGES_EXT या XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_AUTOMATIC_SIZE_IMAGES_EXT या दोनों को शामिल करना ज़रूरी है.

अगर XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_AUTOMATIC_SIZE_IMAGES_EXT को xrEnumerateSpatialCapabilityFeaturesEXT से गिना जाता है, तो रनटाइम को उन इमेज के लिए अपने-आप इमेज के साइज़ उपलब्ध कराने चाहिए जिनके लिए ऐप्लिकेशन ने लागू होने वाली किसी भी अगली चेन के हिस्से के तौर पर कोई XrSpatialImageSizeEXT स्ट्रक्चर उपलब्ध नहीं कराया है.

रनटाइम के दौरान, इमेज के साइज़ अपने-आप और सटीक तरीके से जनरेट करने के लिए, डिवाइस में कुछ सुविधाएं और ज़रूरी शर्तें हो सकती हैं; जैसे, स्टीरियो कैमरे, कैमरे के बाहरी और अंदरूनी पैरामीटर को सटीक तरीके से कैलिब्रेट करना.

अगर XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_AUTOMATIC_SIZE_IMAGES_EXT को xrEnumerateSpatialCapabilityFeaturesEXT से नहीं गिना जाता है, तो ऐप्लिकेशन को XrSpatialImageSizeEXT स्ट्रक्चर को लागू होने वाली अगली चेन में लिंक करना होगा, ताकि सभी इमेज के लिए साफ़ तौर पर साइज़ दिया जा सके. ऐसा न होने पर, रनटाइम को xrCreateSpatialImageTrackingDatabaseAsyncEXT से XR_ERROR_SPATIAL_IMAGE_SIZE_MISSING_EXT को वापस करना होगा.

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

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

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

typedef struct XrSpatialCapabilityConfigurationImageTrackingEXT {
    XrStructureType                             type;
    const void*                                 next;
    XrSpatialCapabilityEXT                      capability;
    uint32_t                                    enabledComponentCount;
    const XrSpatialComponentTypeEXT*            enabledComponents;
    uint32_t                                    imageTrackingDatabaseCount;
    const XrSpatialImageTrackingDatabaseEXT*    imageTrackingDatabases;
} XrSpatialCapabilityConfigurationImageTrackingEXT;

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

• type, इस स्ट्रक्चर का XrStructureType है.
• next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
• capability, XrSpatialCapabilityEXT है और यह XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT होना चाहिए .
• enabledComponentCount एक uint32_t है, जो enabledComponents में मौजूद एलिमेंट की संख्या बताता है.
• enabledComponents, XrSpatialComponentTypeEXT का एक कलेक्शन है. इससे पता चलता है कि इस सुविधा के लिए किन कॉम्पोनेंट को चालू करना है.
• imageTrackingDatabaseCount एक unint32_t है, जो imageTrackingDatabases में मौजूद एलिमेंट की संख्या बताता है.
• imageTrackingDatabases, XrSpatialImageTrackingDatabaseEXT हैंडल का एक कलेक्शन है. इससे इमेज ट्रैकिंग डेटाबेस के बारे में पता चलता है, ताकि स्पेशल कॉन्टेक्स्ट को चालू किया जा सके.

अगर इमेज ट्रैकिंग की सुविधा काम करती है, तो रनटाइम को इमेज ट्रैकिंग की सुविधा चालू करनी होगी. ऐसा तब करना होगा, जब xrCreateSpatialContextAsyncEXT को कॉल करते समय, XrSpatialContextCreateInfoEXT :: capabilityConfigs में XrSpatialCapabilityConfigurationImageTrackingEXT स्ट्रक्चर पास किया गया हो.

XrSpatialCapabilityConfigurationImageTrackingEXT स्ट्रक्चर की मदद से, ऐप्लिकेशन imageTrackingDatabases में XrSpatialImageTrackingDatabaseEXT हैंडल से दिखाई गई रेफ़रंस इमेज का पता लगा सकता है.

अगर xrEnumerateSpatialCapabilitiesEXT ने XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT को एन्यूमेरेटर नहीं किया है, तो रनटाइम को XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT दिखाना चाहिए.

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

• XrSpatialCapabilityConfigurationImageTrackingEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_image_tracking एक्सटेंशन चालू करना ज़रूरी है
• type की वैल्यू XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_IMAGE_TRACKING_EXT होनी चाहिए
• next NULL या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
• capability की वैल्यू, XrSpatialCapabilityEXT की मान्य वैल्यू होनी चाहिए
• enabledComponents को enabledComponentCount मान्य XrSpatialComponentTypeEXT वैल्यू के कलेक्शन का पॉइंटर होना चाहिए
• imageTrackingDatabases ज़रूरी है कि यह imageTrackingDatabaseCount मान्य XrSpatialImageTrackingDatabaseEXT हैंडल के कलेक्शन का पॉइंटर हो
• enabledComponentCount पैरामीटर की वैल्यू, 0 से ज़्यादा होनी चाहिए
• imageTrackingDatabaseCount पैरामीटर की वैल्यू, 0 से ज़्यादा होनी चाहिए

स्पेशियल रेफ़रंस इमेज

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

typedef struct XrSpatialReferenceImagePlaneEXT {
    uint32_t    bufferSize;
    uint8_t*    buffer;
    uint32_t    rowStride;
    uint32_t    pixelStride;
} XrSpatialReferenceImagePlaneEXT;

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

• bufferSize, buffer कलेक्शन का साइज़ है.
• buffer, uint8_t डेटा का एक ऐरे है, जो प्लेन डेटा को दिखाता है.
• rowStride, पिक्सल डेटा की लगातार दो पंक्तियों की शुरुआती पोज़िशन के बीच की बाइट दूरी है.
• pixelStride, लगातार दो पिक्सल के बीच की बाइट दूरी है.

रनटाइम को buffer को ज़रूर ऐक्सेस करना चाहिए. यह ऐक्सेस, rowStride और pixelStride पैरामीटर से मिले पैटर्न के मुताबिक होना चाहिए.

ऐप्लिकेशन को rowStride और pixelStride को इस तरह सेट करना चाहिए कि रनटाइम के दौरान, इस XrSpatialReferenceImagePlaneEXT के सिर्फ़ काम के पिक्सल निकाले जाएं.

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

• XrSpatialReferenceImagePlaneEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_image_tracking एक्सटेंशन चालू करना ज़रूरी है
• buffer को bufferSize uint8_t वैल्यू के कलेक्शन का पॉइंटर होना चाहिए
• bufferSize पैरामीटर की वैल्यू, 0 से ज़्यादा होनी चाहिए

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

typedef struct XrSpatialReferenceImageEXT {
    XrStructureType                           type;
    const void*                               next;
    uint32_t                                  width;
    uint32_t                                  height;
    XrSpatialReferenceImageFormatEXT          format;
    uint32_t                                  planeCount;
    const XrSpatialReferenceImagePlaneEXT*    planes;
} XrSpatialReferenceImageEXT;

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

• type, इस स्ट्रक्चर का XrStructureType है.
• next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
• width, रेफ़रंस के लिए इस्तेमाल की गई इमेज की चौड़ाई है. यह चौड़ाई पिक्सल में है.
• height, रेफ़रंस इमेज की पिक्सल ऊंचाई है.
• format एक XrSpatialReferenceImageFormatEXT है, जो इमेज का फ़ॉर्मैट दिखाता है.
• planeCount, planes कलेक्शन में मौजूद एलिमेंट की संख्या है.
• planes, XrSpatialReferenceImagePlaneEXT स्ट्रक्चर का कलेक्शन है. यह इमेज डेटा के प्लेन दिखाता है.

ऐप्लिकेशन, एक या उससे ज़्यादा XrSpatialReferenceImageEXT स्ट्रक्चर बना सकता है. हर स्ट्रक्चर, इनपुट के तौर पर इस्तेमाल की जाने वाली एक रेफ़रंस इमेज को दिखाता है. इसे XrSpatialImageTrackingDatabaseEXT हैंडल बनाते समय, XrSpatialImageTrackingDatabaseCreateInfoEXT :: spatialReferenceImages के ज़रिए xrCreateSpatialImageTrackingDatabaseAsyncEXT फ़ंक्शन में पास किया जाता है.

XrSpatialReferenceImagePlaneEXT :: buffer डेटा को ऐप्लिकेशन से, बाएं से दाएं और ऊपर से नीचे के पिक्सल क्रम में उपलब्ध कराया जाना चाहिए.

ऐप्लिकेशन को XrSpatialReferenceImageEXT :: format के हर कलर चैनल के लिए, XrSpatialReferenceImageEXT :: planes कलेक्शन में XrSpatialReferenceImagePlaneEXT स्ट्रक्चर उपलब्ध कराना ज़रूरी है.

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

• XrSpatialReferenceImageEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_image_tracking एक्सटेंशन चालू करना ज़रूरी है
• type की वैल्यू XR_TYPE_SPATIAL_REFERENCE_IMAGE_EXT होनी चाहिए
• next को NULL या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए. यह भी देखें: XrSpatialAnnotationQuadReferenceANDROID , XrSpatialImageSizeEXT , XrSpatialImageStaticOptimizationEXT
• format must be a valid XrSpatialReferenceImageFormatEXT value
• planes को planeCount मान्य XrSpatialReferenceImagePlaneEXT स्ट्रक्चर के कलेक्शन का पॉइंटर होना चाहिए
• planeCount पैरामीटर की वैल्यू, 0 से ज़्यादा होनी चाहिए

गारंटी वाले कॉम्पोनेंट

XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT के साथ काम करने वाले रनटाइम को, इन सुविधाओं से खोजी गई सभी इकाइयों के गारंटी वाले कॉम्पोनेंट के तौर पर, ये स्पेशल कॉम्पोनेंट ज़रूर उपलब्ध कराने चाहिए. साथ ही, उन्हें xrEnumerateSpatialCapabilityComponentTypesEXT में शामिल करना चाहिए:

• XR_SPATIAL_COMPONENT_TYPE_IMAGE_2D_EXT
• XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT

इमेज 2D कॉम्पोनेंट

डेटा के बारे में क्वेरी करने के लिए कॉम्पोनेंट लिस्ट स्ट्रक्चर

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

typedef struct XrSpatialComponentImage2DListEXT {
    XrStructureType             type;
    const void*                 next;
    uint32_t                    imageCount;
    XrSpatialImage2DDataEXT*    images;
} XrSpatialComponentImage2DListEXT;

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

• type, इस स्ट्रक्चर का XrStructureType है.
• next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
• imageCount, images कलेक्शन में मौजूद एलिमेंट की संख्या है.
• images, XrSpatialImage2DDataEXT का एक कलेक्शन है.

अगर XrSpatialComponentImage2DListEXT, XrSpatialComponentDataQueryResultEXT :: next चेन में है, तो रनटाइम को xrQuerySpatialComponentDataEXT से XR_ERROR_VALIDATION_FAILURE दिखाना चाहिए. हालांकि, XR_SPATIAL_COMPONENT_TYPE_IMAGE_2D_EXT को XrSpatialComponentDataQueryConditionEXT :: componentTypes में शामिल नहीं किया गया है.

अगर imageCount, XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput से कम है, तो रनटाइम को xrQuerySpatialComponentDataEXT से XR_ERROR_SIZE_INSUFFICIENT को ज़रूर दिखाना चाहिए.

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

• XrSpatialComponentImage2DListEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_image_tracking एक्सटेंशन चालू करना ज़रूरी है
• type की वैल्यू XR_TYPE_SPATIAL_COMPONENT_IMAGE_2D_LIST_EXT होनी चाहिए
• next NULL या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
• images must be a pointer to an array of imageCount XrSpatialImage2DDataEXT structures
• imageCount पैरामीटर की वैल्यू, 0 से ज़्यादा होनी चाहिए

कॉम्पोनेंट डेटा

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

typedef struct XrSpatialImage2DDataEXT {
    XrSpatialImageTrackingDatabaseEXT    imageTrackingDatabase;
    uint32_t                             referenceImageIndex;
} XrSpatialImage2DDataEXT;

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

• imageTrackingDatabase, XrSpatialImageTrackingDatabaseEXT है, जिसने इमेज का पता लगाया या उसे ट्रैक किया.
• referenceImageIndex वह इंडेक्स है जो XrSpatialImageTrackingDatabaseCreateInfoEXT :: spatialReferenceImages में मैप होता है. यह इनपुट रेफ़रंस इमेज का कलेक्शन है, जिसका इस्तेमाल करके imageTrackingDatabase को बनाया गया था.

ऐप्लिकेशन imageTrackingDatabase का इस्तेमाल कर सकता है, ताकि यह पता लगाया जा सके कि पहले बनाए गए किस XrSpatialImageTrackingDatabaseEXT में इस XrSpatialImage2DDataEXT स्ट्रक्चर की रेफ़रंस इमेज शामिल है. उस XrSpatialImageTrackingDatabaseEXT के लिए, ऐप्लिकेशन referenceImageIndex का इस्तेमाल कर सकता है, ताकि इस XrSpatialImage2DDataEXT स्ट्रक्चर के XrSpatialReferenceImageEXT की पहचान की जा सके. इसके लिए, इसे XrSpatialImageTrackingDatabaseCreateInfoEXT :: spatialReferenceImages कलेक्शन के इनपुट ऑर्डर से मैच करना होगा.

सभी चालू डेटाबेस के सेट से तय किए गए रेफ़रंस इमेज के सेट में, डुप्लीकेट इमेज शामिल नहीं होनी चाहिए. डुप्लीकेट इमेज शामिल करने से, खोज या ट्रैकिंग के व्यवहार पर बुरा असर पड़ सकता है. जैसे, अलग-अलग या कई इंडेक्स दिखना.

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

• XrSpatialImage2DDataEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_image_tracking एक्सटेंशन चालू करना ज़रूरी है
• imageTrackingDatabase एक मान्य XrSpatialImageTrackingDatabaseEXT हैंडल होना चाहिए

कॉन्फ़िगरेशन

अगर किसी सुविधा के लिए, XrSpatialCapabilityComponentTypesEXT :: componentTypes में XR_SPATIAL_COMPONENT_TYPE_IMAGE_2D_EXT को शामिल किया गया है, तो ऐप्लिकेशन उसे चालू कर सकता है. इसके लिए, उसे XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents सूची में enum वैल्यू को शामिल करना होगा. इस कॉम्पोनेंट को XrSpatialCapabilityConfigurationBaseHeaderEXT की अगली चेन में शामिल करने के लिए, किसी खास कॉन्फ़िगरेशन की ज़रूरत नहीं होती.

Bounded 2D Component

बाउंडेड 2D कॉम्पोनेंट, उस स्पेसियल इमेज का सेंटर और एक्सटेंट दिखाता है जिसे वह इकाई दिखाती है जिस पर वह मौजूद है. बाउंडेड 2D कॉम्पोनेंट के बारे में ज़्यादा जानने के लिए, बाउंडेड 2D देखें.

कोड का उदाहरण

स्पेशल इमेज और क्वेरी कॉम्पोनेंट डेटा के बारे में जानें

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

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

uint32_t capabilityCountOutput = 0;
CHK_XR(xrEnumerateSpatialCapabilitiesEXT(instance, systemId, 0, &capabilityCountOutput, nullptr));
std::vector<XrSpatialCapabilityEXT> capabilities(capabilityCountOutput);
CHK_XR(xrEnumerateSpatialCapabilitiesEXT(instance, systemId, capabilities.size(), &capabilityCountOutput, capabilities.data()));

if (std::find(capabilities.begin(), capabilities.end(), XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT) == capabilities.end()) {
  // Image tracking not supported
}

XrSpatialCapabilityComponentTypesEXT imageTrackingComponents{XR_TYPE_SPATIAL_CAPABILITY_COMPONENT_TYPES_EXT};
CHK_XR(xrEnumerateSpatialCapabilityComponentTypesEXT(instance, systemId, XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT, &imageTrackingComponents));
std::vector<XrSpatialComponentTypeEXT> imageTrackingCapabilityComponents(imageTrackingComponents.componentTypeCountOutput);
imageTrackingComponents.componentTypes = imageTrackingCapabilityComponents.data();
CHK_XR(xrEnumerateSpatialCapabilityComponentTypesEXT(instance, systemId, XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT, &imageTrackingComponents));

if (std::find(imageTrackingCapabilityComponents.begin(), imageTrackingCapabilityComponents.end(), XR_SPATIAL_COMPONENT_TYPE_IMAGE_2D_EXT) == imageTrackingCapabilityComponents.end()) {
  // The image2d component is not supported
}

uint32_t capabilityFeatureCountOutput = 0;
CHK_XR(xrEnumerateSpatialCapabilityFeaturesEXT(instance, systemId, XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT, 0, &capabilityFeatureCountOutput, nullptr));
std::vector<XrSpatialCapabilityFeatureEXT> capabilityFeatures(capabilityFeatureCountOutput);
CHK_XR(xrEnumerateSpatialCapabilityFeaturesEXT(instance, systemId, XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT, capabilityFeatures.size(), &capabilityFeatureCountOutput, capabilityFeatures.data()));

// Helper function to query optional feature support
const auto supportsFeature = [&capabilityFeatures](XrSpatialCapabilityFeatureEXT feature) {
  return std::find(capabilityFeatures.begin(), capabilityFeatures.end(), feature) != capabilityFeatures.end();
};

// supported state for optional features
const bool supportsAutomaticScaleEstimation = supportsFeature(XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_AUTOMATIC_SIZE_IMAGES_EXT);
const bool supportsStaticImages = supportsFeature(XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_STATIC_IMAGES_EXT);
const bool supportsFixedSizeImages = supportsFeature(XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_FIXED_SIZE_IMAGES_EXT);

uint32_t formatCountOutput = 0;
CHK_XR(xrEnumerateSpatialReferenceImageFormatsEXT(instance, systemId, XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT, 0, &formatCountOutput, nullptr));
std::vector<XrSpatialReferenceImageFormatEXT> formats(formatCountOutput);
CHK_XR(xrEnumerateSpatialReferenceImageFormatsEXT(instance, systemId, XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT, formats.size(), &formatCountOutput, formats.data()));

if (std::find(formats.begin(), formats.end(), XR_SPATIAL_REFERENCE_IMAGE_FORMAT_RGBA_8888_EXT) == formats.end()) {
  // The desired format is not supported
}

// Helper function to wait for XrFutureEXT completion
auto waitUntilReady = [&](XrFutureEXT future) {
  XrFuturePollInfoEXT pollInfo{XR_TYPE_FUTURE_POLL_INFO_EXT};
  XrFuturePollResultEXT pollResult{XR_TYPE_FUTURE_POLL_RESULT_EXT};
  pollInfo.future = future;
  do {
    // sleep(1);
    CHK_XR(xrPollFutureEXT(instance, &pollInfo, &pollResult));
  } while (pollResult.state != XR_FUTURE_STATE_READY_EXT);
};

// Data/metadata about reference images (identifiers, 3D models, trigger functions, etc.)
std::vector<std::string> referenceImageIdentifiers;

XrSpatialImageTrackingDatabaseEXT imageTrackingDatabase{};
{
  uint32_t imgSize; // preloaded interleaved RGBA buffer size
  uint8_t* img; // preloaded interleaved RGBA buffer data

  // interleaved RGBA buffer memory layout and buffer positions

  // first row of pixels
  // img[0] | img[1] | img[2] | img[3] | img[0]+pStride | img[1]+pStride | ...
  //  R0    |   G0   |   B0   |   A0   |       R1       |       G1       | ...

  // second row of pixels
  // img[0]+rStride | img[1]+rStride | img[2]+rStride | img[3]+rStride | img[0]+rStride+pStride | ...
  //      R640      |      G640      |      B640      |      A640      |          R641          | ...

  XrSpatialReferenceImagePlaneEXT spatialReferenceImagePlanes[4];

  for (int i = 0; i < 4; ++i) { // for each plane (0=R, 1=G, 2=B, 3=A)
    spatialReferenceImagePlanes[i].buffer = img + i; // set each plane buffer pointer to the first pixel of the plane
    spatialReferenceImagePlanes[i].bufferSize = imgSize - i; // adjust remeinaing buffer size according to offset applied
    spatialReferenceImagePlanes[i].rowStride = 640 * 4; // set byte offset to start of next row for this plane
    spatialReferenceImagePlanes[i].pixelStride = 4; // set byte offset to next pixel for this plane
  }

  XrSpatialReferenceImageEXT spatialReferenceImage{XR_TYPE_SPATIAL_REFERENCE_IMAGE_EXT};
  spatialReferenceImage.width = 640;
  spatialReferenceImage.height = 480;
  spatialReferenceImage.format = XR_SPATIAL_REFERENCE_IMAGE_FORMAT_RGBA_8888_EXT;
  spatialReferenceImage.planeCount = 4;
  spatialReferenceImage.planes = spatialReferenceImagePlanes;

  referenceImageIdentifiers.emplace_back("MyReferenceImage");

  // Helper function to append to the next chain
  XrBaseOutStructure* appendTo = reinterpret_cast<XrBaseOutStructure*>(&spatialReferenceImage);
  const auto appendToNextChain = [&appendTo](XrBaseOutStructure* toAppend) {
    appendTo->next = toAppend;
    appendTo = toAppend;
  };

  XrSpatialImageSizeEXT imageSize{XR_TYPE_SPATIAL_IMAGE_SIZE_EXT};
  imageSize.physicalWidth = 0.1f;

  if (!supportsAutomaticScaleEstimation) {
    if (supportsFixedSizeImages) {
      appendToNextChain(reinterpret_cast<XrBaseOutStructure*>(&imageSize));
    }
  }

  XrSpatialImageStaticOptimizationEXT imageStaticOptimization{XR_TYPE_SPATIAL_IMAGE_STATIC_OPTIMIZATION_EXT};
  imageStaticOptimization.optimizeForStaticImage = XR_TRUE;

  if (supportsStaticImages) {
    appendToNextChain(reinterpret_cast<XrBaseOutStructure*>(&imageStaticOptimization));
  }

  XrSpatialImageTrackingDatabaseCreateInfoEXT spatialImageTrackingDatabaseCreateInfo{XR_TYPE_SPATIAL_IMAGE_TRACKING_DATABASE_CREATE_INFO_EXT};
  spatialImageTrackingDatabaseCreateInfo.spatialReferenceImages = &spatialReferenceImage;
  spatialImageTrackingDatabaseCreateInfo.spatialReferenceImageCount = 1;

  XrFutureEXT createImageTrackingDatabaseFuture = XR_NULL_FUTURE_EXT;
  CHK_XR(xrCreateSpatialImageTrackingDatabaseAsyncEXT(session, &spatialImageTrackingDatabaseCreateInfo, &createImageTrackingDatabaseFuture));

  waitUntilReady(createImageTrackingDatabaseFuture);

  XrCreateSpatialImageTrackingDatabaseCompletionEXT imageTrackingCompletion{XR_TYPE_CREATE_SPATIAL_IMAGE_TRACKING_DATABASE_COMPLETION_EXT};
  CHK_XR(xrCreateSpatialImageTrackingDatabaseCompleteEXT(session, createImageTrackingDatabaseFuture, &imageTrackingCompletion));
  if (imageTrackingCompletion.futureResult != XR_SUCCESS) {
    // Error, image tracking database creation failed
  }

  imageTrackingDatabase = imageTrackingCompletion.database;
}

XrSpatialContextEXT spatialContext{};
{
  const std::array<XrSpatialComponentTypeEXT, 2> enabledComponents = {
    XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT,
    XR_SPATIAL_COMPONENT_TYPE_IMAGE_2D_EXT
  };

  // Configure the image tracking capability for the spatial context
  XrSpatialCapabilityConfigurationImageTrackingEXT imageTrackingCapabilityConfig{XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_IMAGE_TRACKING_EXT};
  imageTrackingCapabilityConfig.capability = XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT;
  imageTrackingCapabilityConfig.enabledComponentCount = enabledComponents.size();
  imageTrackingCapabilityConfig.enabledComponents = enabledComponents.data();
  imageTrackingCapabilityConfig.imageTrackingDatabaseCount = 1;
  imageTrackingCapabilityConfig.imageTrackingDatabases = &imageTrackingDatabase;

  std::vector<XrSpatialCapabilityConfigurationBaseHeaderEXT*> capabilityConfigs;
  capabilityConfigs.push_back(reinterpret_cast<XrSpatialCapabilityConfigurationBaseHeaderEXT*>(&imageTrackingCapabilityConfig));

  XrSpatialContextCreateInfoEXT spatialContextCreateInfo{XR_TYPE_SPATIAL_CONTEXT_CREATE_INFO_EXT};
  spatialContextCreateInfo.capabilityConfigCount = capabilityConfigs.size();
  spatialContextCreateInfo.capabilityConfigs = capabilityConfigs.data();

  XrFutureEXT createContextFuture = XR_NULL_FUTURE_EXT;
  CHK_XR(xrCreateSpatialContextAsyncEXT(session, &spatialContextCreateInfo, &createContextFuture));

  waitUntilReady(createContextFuture);

  XrCreateSpatialContextCompletionEXT completion{XR_TYPE_CREATE_SPATIAL_CONTEXT_COMPLETION_EXT};
  CHK_XR(xrCreateSpatialContextCompleteEXT(session, createContextFuture, &completion));
  if (completion.futureResult != XR_SUCCESS) {
    // Error, spatial context creation failed
  }

  spatialContext = completion.spatialContext;
}

auto discoverSpatialEntities = [&](XrSpatialContextEXT spatialContext, XrTime time) {
  // We want to look for entities that have the following components
  std::array<XrSpatialComponentTypeEXT, 2> snapshotComponents {XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT, XR_SPATIAL_COMPONENT_TYPE_IMAGE_2D_EXT};

  XrSpatialDiscoverySnapshotCreateInfoEXT snapshotCreateInfo{XR_TYPE_SPATIAL_DISCOVERY_SNAPSHOT_CREATE_INFO_EXT};
  snapshotCreateInfo.componentTypeCount = snapshotComponents.size();
  snapshotCreateInfo.componentTypes = snapshotComponents.data();
  XrFutureEXT discoveryFuture = XR_NULL_FUTURE_EXT;
  CHK_XR(xrCreateSpatialDiscoverySnapshotAsyncEXT(spatialContext, &snapshotCreateInfo, &discoveryFuture));

  waitUntilReady(discoveryFuture);

  XrCreateSpatialDiscoverySnapshotCompletionInfoEXT completionInfo{XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_INFO_EXT};
  completionInfo.baseSpace = localSpace;
  completionInfo.time = time;
  completionInfo.future = discoveryFuture;

  XrCreateSpatialDiscoverySnapshotCompletionEXT completion{XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_EXT};
  CHK_XR(xrCreateSpatialDiscoverySnapshotCompleteEXT(spatialContext, &completionInfo, &completion));
  if (completion.futureResult == XR_SUCCESS) {
    // Query for the bounded2d component data
    XrSpatialComponentTypeEXT componentsToQuery[] = {XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT, XR_SPATIAL_COMPONENT_TYPE_IMAGE_2D_EXT};
    XrSpatialComponentDataQueryConditionEXT queryCond{XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_CONDITION_EXT};
    queryCond.componentTypes = componentsToQuery;

    XrSpatialComponentDataQueryResultEXT queryResult{XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_RESULT_EXT};
    CHK_XR(xrQuerySpatialComponentDataEXT(completion.snapshot, &queryCond, &queryResult));

    std::vector<XrSpatialEntityIdEXT> entityIds(queryResult.entityIdCountOutput);
    std::vector<XrSpatialEntityTrackingStateEXT> entityStates(queryResult.entityStateCountOutput);
    queryResult.entityIdCapacityInput = entityIds.size();
    queryResult.entityIds = entityIds.data();
    queryResult.entityStateCapacityInput = entityStates.size();
    queryResult.entityStates = entityStates.data();

    std::vector<XrSpatialBounded2DDataEXT> bounded2d(queryResult.entityIdCountOutput);
    XrSpatialComponentBounded2DListEXT boundsList{XR_TYPE_SPATIAL_COMPONENT_BOUNDED_2D_LIST_EXT};
    boundsList.boundCount = bounded2d.size();
    boundsList.bounds = bounded2d.data();
    queryResult.next = &boundsList;

    std::vector<XrSpatialImage2DDataEXT> image2d(queryResult.entityIdCountOutput);
    XrSpatialComponentImage2DListEXT imagesList{XR_TYPE_SPATIAL_COMPONENT_IMAGE_2D_LIST_EXT};
    imagesList.imageCount = image2d.size();
    imagesList.images = image2d.data();
    queryResult.next = &imagesList;

    CHK_XR(xrQuerySpatialComponentDataEXT(completion.snapshot, &queryCond, &queryResult));

    for (int32_t i = 0; i < queryResult.entityIdCountOutput; ++i) {
      if (entityStates[i] == XR_SPATIAL_ENTITY_TRACKING_STATE_TRACKING_EXT) {
        const XrSpatialImage2DDataEXT& currentImage2d = image2d[i];
        const std::string& currentReferenceImageIdentifier = referenceImageIdentifiers[currentImage2d.referenceImageIndex];
        std::cout << currentReferenceImageIdentifier << std::endl; // Outputs the "MyReferenceImage" string the app defined previously; could be any other assocatied data or action.

        // Access bounded2d[i] for image bounds
      }
    }

    CHK_XR(xrDestroySpatialSnapshotEXT(completion.snapshot));
  }
};

while (1) {
  // For every frame in frame loop

  XrFrameState frameState;  // Previously returned from xrWaitFrame
  const XrTime time = frameState.predictedDisplayTime;

  // Poll for the XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT event
  XrEventDataBuffer event = {XR_TYPE_EVENT_DATA_BUFFER};
  XrResult result = xrPollEvent(instance, &event);
  if (result == XR_SUCCESS) {
      switch (event.type) {
          case XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT: {
              const XrEventDataSpatialDiscoveryRecommendedEXT& eventdata = *reinterpret_cast<XrEventDataSpatialDiscoveryRecommendedEXT*>(&event);
              // Discover spatial entities for the context that we received the "discovery
              // recommended" event for
              discoverSpatialEntities(eventdata.spatialContext, time);
              break;
          }
      }
  }

  // Finish frame loop
}

CHK_XR(xrDestroySpatialContextEXT(spatialContext));

// Unload spatial image tracking resources internally
CHK_XR(xrDestroySpatialImageTrackingDatabaseEXT(imageTrackingDatabase));

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

• XrSpatialImageTrackingDatabaseEXT

नए निर्देश

• xrCreateSpatialImageTrackingDatabaseAsyncEXT
• xrCreateSpatialImageTrackingDatabaseCompleteEXT
• xrDestroySpatialImageTrackingDatabaseEXT
• xrEnumerateSpatialReferenceImageFormatsEXT

नए स्ट्रक्चर

• XrCreateSpatialImageTrackingDatabaseCompletionEXT
• XrSpatialCapabilityConfigurationImageTrackingEXT
• XrSpatialImage2DDataEXT
• XrSpatialImageTrackingDatabaseCreateInfoEXT
• XrSpatialReferenceImageEXT
• XrSpatialReferenceImagePlaneEXT

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

  • XrSpatialComponentImage2DListEXT

• XrSpatialReferenceImageEXT , XrSpatialImageTrackingDatabaseCreateInfoEXT को एक्सटेंड करना :

  • XrSpatialImageSizeEXT
  • XrSpatialImageStaticOptimizationEXT

नए Enum

• XrSpatialReferenceImageFormatEXT

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

• XR_EXT_SPATIAL_IMAGE_TRACKING_EXTENSION_NAME
• XR_EXT_spatial_image_tracking_SPEC_VERSION

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

  • XR_OBJECT_TYPE_SPATIAL_IMAGE_TRACKING_DATABASE_EXT

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

  • XR_ERROR_SPATIAL_IMAGE_FORMAT_UNSUPPORTED_EXT
  • XR_ERROR_SPATIAL_IMAGE_INVALID_EXT
  • XR_ERROR_SPATIAL_IMAGE_SIZE_MISSING_EXT

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

  • XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT

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

  • XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_AUTOMATIC_SIZE_IMAGES_EXT
  • XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_FIXED_SIZE_IMAGES_EXT
  • XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_STATIC_IMAGES_EXT

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

  • XR_SPATIAL_COMPONENT_TYPE_IMAGE_2D_EXT

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

  • XR_TYPE_CREATE_SPATIAL_IMAGE_TRACKING_DATABASE_COMPLETION_EXT
  • XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_IMAGE_TRACKING_EXT
  • XR_TYPE_SPATIAL_COMPONENT_IMAGE_2D_LIST_EXT
  • XR_TYPE_SPATIAL_IMAGE_SIZE_EXT
  • XR_TYPE_SPATIAL_IMAGE_STATIC_OPTIMIZATION_EXT
  • XR_TYPE_SPATIAL_IMAGE_TRACKING_DATABASE_CREATE_INFO_EXT
  • XR_TYPE_SPATIAL_REFERENCE_IMAGE_EXT

समस्याएं

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

• रिविज़न 1, 22-04-2025 (डैनियल गटनबर्ग, Qualcomm)

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