XR_ANDROID_depth_texture

Name String

XR_ANDROID_depth_texture

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

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

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

703

बदलाव

1

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

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

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

OpenXR 1.0

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

2024-09-11

आईपी स्टेटस

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

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

सुशांत कुलकर्णी, Google
कैरन ओवरटर्फ़, Google
स्पेंसर क्विन, Google
लेवाना चेन, Google

खास जानकारी

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

इस एक्सटेंशन का मकसद, ऑक्लूज़न, हिट टेस्ट, और अन्य खास टास्क के लिए रॉ और स्मूद डेप्थ का पता लगाना है. ये टास्क, सीन की सटीक ज्यामिति का इस्तेमाल करते हैं. उदाहरण के लिए, नकली चेहरे का पता लगाना.

नोट

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

अनुमतियां

यह एक्सटेंशन, डाउनसैंपल की गई डेप्थ टेक्सचर को दिखाता है, ताकि व्यक्तिगत पहचान से जुड़ी जानकारी (पीआईआई) के बारे में चिंताओं को कम किया जा सके. Android ऐप्लिकेशन के मेनिफ़ेस्ट में, android.permission.SCENE_UNDERSTANDING_FINE अनुमति का होना ज़रूरी है. ऐसा इसलिए, क्योंकि यह एक्सटेंशन एनवायरमेंट की ज्यामिति को दिखाता है. android.permission.SCENE_UNDERSTANDING_FINE अनुमति को खतरनाक अनुमति माना जाता है. इन फ़ंक्शन का इस्तेमाल करने के लिए, ऐप्लिकेशन को रनटाइम के दौरान अनुमति का अनुरोध ज़रूर करना चाहिए:

• xrCreateDepthSwapchainANDROID

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

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

XrSystemDepthTrackingPropertiesANDROID स्ट्रक्चर को इस तरह से परिभाषित किया गया है:

typedef struct XrSystemDepthTrackingPropertiesANDROID {
    XrStructureType    type;
    void*              next;
    XrBool32           supportsDepthTracking;
} XrSystemDepthTrackingPropertiesANDROID;

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

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

कोई ऐप्लिकेशन, xrGetSystemProperties को कॉल करते समय, XrSystemDepthTrackingPropertiesANDROID स्ट्रक्चर के साथ XrSystemProperties को बढ़ाकर यह देख सकता है कि सिस्टम में डेप्थ ट्रैकिंग की सुविधा है या नहीं .

अगर कोई रनटाइम, supportsDepthTracking के लिए XR_FALSE दिखाता है, तो रनटाइम को xrCreateDepthSwapchainANDROID से XR_ERROR_FEATURE_UNSUPPORTED दिखाना ज़रूरी है .

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

• XrSystemDepthTrackingPropertiesANDROID का इस्तेमाल करने से पहले, XR_ANDROID_depth_texture एक्सटेंशन को चालू करना ज़रूरी है
• type ज़रूरी तौर पर XR_TYPE_SYSTEM_DEPTH_TRACKING_PROPERTIES_ANDROID होना चाहिए
• next, NULL या स्ट्रक्चर चेन में मौजूद अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए

क्वेरी डेप्थ से जुड़ी समस्याओं को हल करना

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

XrResult xrEnumerateDepthResolutionsANDROID(
    XrSession                                   session,
    uint32_t                                    resolutionCapacityInput,
    uint32_t*                                   resolutionCountOutput,
    XrDepthCameraResolutionANDROID*             resolutions);

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

• session वह XrSession है जो डेप्थ के लिए काम करने वाले रिज़ॉल्यूशन की गिनती करता है.
• resolutionCapacityInput, resolutions की क्षमता है. अगर आपको ज़रूरी क्षमता वापस लानी है, तो इसे 0 पर सेट करें.
• resolutionCountOutput, uint64_t resolutions की संख्या का पॉइंटर है. अगर resolutionCapacityInput की क्षमता कम है, तो यह ज़रूरी क्षमता का पॉइंटर है.
• resolutions, XrDepthCameraResolutionANDROID के ऐरे का पॉइंटर है. हालांकि, अगर resolutionCapacityInput, 0 है, तो can NULL हो सकता है.
• ज़रूरी resolutions का साइज़ वापस पाने के बारे में ज़्यादा जानकारी के लिए, बफ़र साइज़ के पैरामीटर सेक्शन देखें.

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

सत्र की अवधि के दौरान, रनटाइम को इस इन्यूमरेशन से हमेशा एक जैसा बफ़र कॉन्टेंट दिखाना ज़रूरी है.

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

• xrEnumerateDepthResolutionsANDROID को कॉल करने से पहले, XR_ANDROID_depth_texture एक्सटेंशन को चालू करना ज़रूरी है
• session, XrSession का एक मान्य हैंडल होना चाहिए
• resolutionCountOutput, uint32_t वैल्यू का पॉइंटर होना चाहिए
• If resolutionCapacityInput is not 0 , resolutions must be a pointer to an array of resolutionCapacityInput XrDepthCameraResolutionANDROID values

रिटर्न कोड

सफल

• 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

XrDepthCameraResolutionANDROID enum, XrDepthSwapchainANDROID बनाते समय, डेप्थ के लिए उपलब्ध रिज़ॉल्यूशन के बारे में बताता है .

typedef enum XrDepthCameraResolutionANDROID {
    XR_DEPTH_CAMERA_RESOLUTION_80x80_ANDROID = 0,
    XR_DEPTH_CAMERA_RESOLUTION_160x160_ANDROID = 1,
    XR_DEPTH_CAMERA_RESOLUTION_320x320_ANDROID = 2,
    XR_DEPTH_CAMERA_RESOLUTION_MAX_ENUM_ANDROID = 0x7FFFFFFF
} XrDepthCameraResolutionANDROID;

गिनती की गई वैल्यू की जानकारी

• XR_DEPTH_CAMERA_RESOLUTION_80x80_ANDROID — डेप्थ और कॉन्फ़िडेंस इमेज का रिज़ॉल्यूशन 80x80 होता है.
• XR_DEPTH_CAMERA_RESOLUTION_160x160_ANDROID — डेप्थ और कॉन्फ़िडेंस इमेज का रिज़ॉल्यूशन 160x160 होता है.
• XR_DEPTH_CAMERA_RESOLUTION_320x320_ANDROID — डेप्थ और कॉन्फ़िडेंस इमेज का रिज़ॉल्यूशन 320x320 होता है.

डेप्थ स्वैपचेन बनाना

XR_DEFINE_HANDLE(XrDepthSwapchainANDROID)

XrDepthSwapchainANDROID, डेप्थ स्वैपचेन हैंडल होता है.

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

XrResult xrCreateDepthSwapchainANDROID(
    XrSession                                   session,
    const XrDepthSwapchainCreateInfoANDROID*    createInfo,
    XrDepthSwapchainANDROID*                    swapchain);

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

• session, XrSession है, जो डेप्थ स्वैपचेन बनाता है.
• createInfo, XrDepthSwapchainCreateInfoANDROID स्ट्रक्चर का पॉइंटर है. इसमें स्वैपचेन बनाने के लिए इस्तेमाल किए जाने वाले पैरामीटर होते हैं.
• swapchain एक हैंडल का पॉइंटर है, जिसमें बनाया गया XrDepthSwapchainANDROID वापस आ जाता है.

ऐप्लिकेशन, xrCreateDepthSwapchainANDROID फ़ंक्शन का इस्तेमाल करके, डेप्थ स्वैपचेन बना सकता है. यह डेप्थ स्वैपचेन, डेप्थ और कॉन्फ़िडेंस इमेज, दोनों को मैनेज करता है.

• अगर सिस्टम में डेप्थ ट्रैकिंग की सुविधा काम नहीं करती है, तो रनटाइम को XR_ERROR_FEATURE_UNSUPPORTED वैल्यू ज़रूर दिखानी चाहिए.
• अगर कॉल करने वाले ऐप्लिकेशन को ज़रूरी अनुमतियां नहीं दी गई हैं, तो रनटाइम को XR_ERROR_PERMISSION_INSUFFICIENT वैल्यू ज़रूर दिखानी चाहिए.
• अगर XrDepthSwapchainCreateInfoANDROID में तय किया गया डेप्थ रिज़ॉल्यूशन काम नहीं करता है, तो रनटाइम को XR_ERROR_VALIDATION_FAILURE वैल्यू ज़रूर दिखानी चाहिए.
• रनटाइम को डेप्थ कॉन्फ़िडेंस इमेज तभी बनानी चाहिए, जब स्वैपचेन बनाते समय createInfo के लिए, इससे जुड़े बिट सेट किए गए हों.

इसके बाद, लौटाए गए डेप्थ स्वैपचेन हैंडल का इस्तेमाल एपीआई कॉल में किया जा सकता है. XrDepthSwapchainANDROID हैंडल को xrDestroyDepthSwapchainANDROID फ़ंक्शन के ज़रिए ज़रूर फ़्री किया जाना चाहिए.

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

• xrCreateDepthSwapchainANDROID को कॉल करने से पहले, XR_ANDROID_depth_texture एक्सटेंशन को चालू करना ज़रूरी है
• session, XrSession का एक मान्य हैंडल होना चाहिए
• createInfo XrDepthSwapchainCreateInfoANDROID स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
• swapchain, XrDepthSwapchainANDROID हैंडल का पॉइंटर होना चाहिए

रिटर्न कोड

सफल

• 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_PERMISSION_INSUFFICIENT
• XR_ERROR_RUNTIME_FAILURE
• XR_ERROR_SESSION_LOST

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

typedef struct XrDepthSwapchainCreateInfoANDROID {
    XrStructureType                       type;
    const void*                           next;
    XrDepthCameraResolutionANDROID        resolution;
    XrDepthSwapchainCreateFlagsANDROID    createFlags;
} XrDepthSwapchainCreateInfoANDROID;

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

• type इस स्ट्रक्चर का XrStructureType है.
• next, NULL होता है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर होता है. इस तरह के स्ट्रक्चर, OpenXR के मुख्य स्पेसिफ़िकेशन या इस एक्सटेंशन में तय नहीं किए गए हैं.
• resolution, XrDepthCameraResolutionANDROID है. इसकी मदद से, डेप्थ और कॉन्फ़िडेंस टेक्सचर बनाए जाते हैं.
• createFlags, XrDepthSwapchainCreateFlagsANDROID में से एक या उससे ज़्यादा फ़्लैग है .

XrDepthSwapchainCreateInfoANDROID स्ट्रक्चर, xrCreateDepthSwapchainANDROID को पास किए जाने पर, XrDepthSwapchainANDROID के लिए क्रिएशन के विकल्प उपलब्ध कराता है .

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

• XrDepthSwapchainCreateInfoANDROID का इस्तेमाल करने से पहले, XR_ANDROID_depth_texture एक्सटेंशन को चालू करना ज़रूरी है
• type ज़रूरी तौर पर XR_TYPE_DEPTH_SWAPCHAIN_CREATE_INFO_ANDROID होना चाहिए
• next, NULL या स्ट्रक्चर चेन में मौजूद अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
• resolution, XrDepthCameraResolutionANDROID की मान्य वैल्यू होनी चाहिए
• createFlags, XrDepthSwapchainCreateFlagBitsANDROID वैल्यू का मान्य कॉम्बिनेशन होना चाहिए
• createFlags must not be 0

XrDepthSwapchainCreateFlagsANDROID, XrDepthSwapchainANDROID के लिए, बनाने के विकल्प तय करता है .

typedef XrFlags64 XrDepthSwapchainCreateFlagsANDROID;

XrDepthSwapchainCreateFlagsANDROID के लिए मान्य बिट , XrDepthSwapchainCreateFlagBitsANDROID से तय किए जाते हैं. इन्हें इस तरह से तय किया जाता है:

// Flag bits for XrDepthSwapchainCreateFlagsANDROID
static const XrDepthSwapchainCreateFlagsANDROID XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_DEPTH_IMAGE_BIT_ANDROID = 0x00000001;
static const XrDepthSwapchainCreateFlagsANDROID XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_CONFIDENCE_IMAGE_BIT_ANDROID = 0x00000002;
static const XrDepthSwapchainCreateFlagsANDROID XR_DEPTH_SWAPCHAIN_CREATE_RAW_DEPTH_IMAGE_BIT_ANDROID = 0x00000004;
static const XrDepthSwapchainCreateFlagsANDROID XR_DEPTH_SWAPCHAIN_CREATE_RAW_CONFIDENCE_IMAGE_BIT_ANDROID = 0x00000008;

फ़्लैग की जानकारी

• XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_DEPTH_IMAGE_BIT_ANDROID — इससे पता चलता है कि स्वैपचेन, डेप्थ इमेज को स्मूद तरीके से दिखाएगा.
• XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_CONFIDENCE_IMAGE_BIT_ANDROID — इससे पता चलता है कि स्वैपचेन, डेप्थ कॉन्फ़िडेंस की स्मूद इमेज उपलब्ध कराएगा.
• XR_DEPTH_SWAPCHAIN_CREATE_RAW_DEPTH_IMAGE_BIT_ANDROID — इससे पता चलता है कि स्वैपचेन, रॉ डेप्थ इमेज उपलब्ध कराएगा.
• XR_DEPTH_SWAPCHAIN_CREATE_RAW_CONFIDENCE_IMAGE_BIT_ANDROID — इससे पता चलता है कि स्वैपचेन, डेप्थ कॉन्फ़िडेंस की रॉ इमेज उपलब्ध कराएगा.

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

XrResult xrDestroyDepthSwapchainANDROID(
    XrDepthSwapchainANDROID                     swapchain);

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

• swapchain एक XrDepthSwapchainANDROID हैंडल है, जिसे पहले xrCreateDepthSwapchainANDROID ने बनाया था .

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

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

• xrDestroyDepthSwapchainANDROID को कॉल करने से पहले, XR_ANDROID_depth_texture एक्सटेंशन को चालू करना ज़रूरी है
• swapchain, XrDepthSwapchainANDROID का मान्य हैंडल होना चाहिए

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

• swapchain और बच्चों के सभी हैंडल को बाहरी तौर पर सिंक किया जाना चाहिए

रिटर्न कोड

सफल

• XR_SUCCESS

Failure

• XR_ERROR_FUNCTION_UNSUPPORTED
• XR_ERROR_HANDLE_INVALID

डेप्थ टेक्सचर ऐक्सेस करना

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

XrResult xrEnumerateDepthSwapchainImagesANDROID(
    XrDepthSwapchainANDROID                     depthSwapchain,
    uint32_t                                    depthImageCapacityInput,
    uint32_t*                                   depthImageCountOutput,
    XrDepthSwapchainImageANDROID*               depthImages);

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

• depthSwapchain, इमेज पाने के लिए XrDepthSwapchainANDROID है.
• depthImageCapacityInput, depthImages ऐरे की क्षमता है. अगर आपको ज़रूरी क्षमता वापस पाने का अनुरोध करना है, तो इसे 0 पर सेट करें.
• depthImageCountOutput, depthImages की संख्या का पॉइंटर है. अगर depthImageCapacityInput की क्षमता कम है, तो यह ज़रूरी क्षमता का पॉइंटर है.
• depthImages, XrDepthSwapchainImageANDROID स्ट्रक्चर के ऐरे का पॉइंटर है. अगर depthImageCapacityInput की वैल्यू 0 है, तो इसकी वैल्यू NULL हो सकती है.
• ज़रूरी depthImages का साइज़ वापस पाने के बारे में ज़्यादा जानकारी के लिए, बफ़र साइज़ के पैरामीटर सेक्शन देखें.

xrEnumerateDepthSwapchainImagesANDROID, XrDepthSwapchainImageANDROID स्ट्रक्चर की एक ऐरे भरता है. संसाधन, XrDepthSwapchainANDROID के पूरे लाइफ़टाइम के लिए एक जैसे और मान्य होने चाहिए . यह फ़ंक्शन, xrEnumerateSwapchainImages की तरह काम करता है .

स्वैपचेन के लाइफ़टाइम के लिए, रनटाइम को इस इन्यूमरेशन से हमेशा एक जैसे बफ़र कॉन्टेंट दिखाने चाहिए.

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

• xrEnumerateDepthSwapchainImagesANDROID को कॉल करने से पहले, XR_ANDROID_depth_texture एक्सटेंशन को चालू करना ज़रूरी है
• depthSwapchain, XrDepthSwapchainANDROID का मान्य हैंडल होना चाहिए
• depthImageCountOutput, uint32_t वैल्यू का पॉइंटर होना चाहिए
• अगर depthImageCapacityInput 0 नहीं है , तो depthImages को depthImageCapacityInput XrDepthSwapchainImageANDROID स्ट्रक्चर के ऐरे का पॉइंटर होना चाहिए

रिटर्न कोड

सफल

• 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

XrDepthSwapchainImageANDROID स्ट्रक्चर को इस तरह परिभाषित किया गया है:

typedef struct XrDepthSwapchainImageANDROID {
    XrStructureType    type;
    void*              next;
    const float*       rawDepthImage;
    const uint8_t*     rawDepthConfidenceImage;
    const float*       smoothDepthImage;
    const uint8_t*     smoothDepthConfidenceImage;
} XrDepthSwapchainImageANDROID;

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

• type इस स्ट्रक्चर का XrStructureType है.
• next, NULL होता है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर होता है. इस तरह के स्ट्रक्चर, OpenXR के मुख्य स्पेसिफ़िकेशन या इस एक्सटेंशन में तय नहीं किए गए हैं.
• rawDepthImage, NULL है. यह रनटाइम के हिसाब से, बाएं और दाएं, दोनों व्यू के लिए तय की गई रॉ डेप्थ इमेज का पॉइंटर होता है. वैल्यू, मीटर में दी गई हैं. खास वैल्यू: 0.0 से रॉ डेप्थ में अमान्य या खाली डेप्थ पिक्सल का पता चलता है, Inf से ऐसे डेप्थ का पता चलता है जो काफ़ी दूर है,
• rawDepthConfidenceImage, रनटाइम के हिसाब से बांटे गए बाएं और दाएं, दोनों व्यू के लिए NULL या रॉ डेप्थ कॉन्फ़िडेंस इमेज का पॉइंटर है.
• smoothDepthImage, NULL है. यह रनटाइम के हिसाब से, बाईं और दाईं ओर के व्यू के लिए, डेप्थ इमेज को बेहतर बनाने वाला पॉइंटर होता है. वैल्यू, मीटर में दी गई हैं. खास वैल्यू: 0.0 का मतलब है कि स्मूथ डेप्थ में अमान्य या खाली डेप्थ पिक्सल है. Inf का मतलब है कि डेप्थ की जानकारी है, लेकिन वह बहुत दूर है.
• smoothDepthConfidenceImage, रनटाइम के हिसाब से बांटे गए बाएं और दाएं, दोनों व्यू के लिए NULL या डेप्थ कॉन्फ़िडेंस इमेज का पॉइंटर है.

इमेज बफ़र पॉइंटर सिर्फ़ स्वैपचेन के लाइफ़टाइम के दौरान मान्य होंगे. स्वैपचेन के बंद होने के बाद, पॉइंटर को डैंगलिंग माना जाएगा.

XrDepthSwapchainImageANDROID, XrDepthSwapchainANDROID से डेप्थ इमेज दिखाता है. इन्हें XrDepthSwapchainCreateInfoANDROID :: resolution और XrDepthSwapchainCreateInfoANDROID :: createFlags में बताए गए तरीके से, xrCreateDepthSwapchainANDROID को कॉल करते समय असाइन किया जाता है. हर डेप्थ इमेज के लिए:

• इमेज की वैल्यू को मेमोरी में पंक्ति के हिसाब से क्रम में रखा जाता है. साथ ही, पंक्तियों के बीच कोई पैडिंग नहीं होती है.
• पहली वैल्यू, ऊपर बाईं ओर और आखिरी वैल्यू, नीचे दाईं ओर होती है.
• पॉइंट की गई मेमोरी का साइज़, xrEnumerateDepthSwapchainImagesANDROID की वैल्यू से तय होता है. साथ ही, xrCreateDepthSwapchainANDROID को कॉल करते समय, इसे XrDepthSwapchainCreateInfoANDROID :: resolution से सेट किया जाता है. उदाहरण के लिए, अगर XrDepthSwapchainCreateInfoANDROID :: resolution XR_DEPTH_CAMERA_RESOLUTION_160x160_ANDROID है , तो डेप्थ इमेज का साइज़ 2*160*160*sizeof(float) होगा .
• अगर XrDepthSwapchainCreateInfoANDROID :: createFlags में XR_DEPTH_SWAPCHAIN_CREATE_RAW_DEPTH_IMAGE_BIT_ANDROID शामिल नहीं है, तो rawDepthImage की वैल्यू NULL होनी चाहिए .
• अगर XrDepthSwapchainCreateInfoANDROID :: createFlags में XR_DEPTH_SWAPCHAIN_CREATE_RAW_CONFIDENCE_IMAGE_BIT_ANDROID शामिल नहीं है, तो rawDepthConfidenceImage की वैल्यू NULL होनी चाहिए .
• अगर XrDepthSwapchainCreateInfoANDROID :: createFlags में XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_DEPTH_IMAGE_BIT_ANDROID शामिल नहीं है, तो smoothDepthImage की वैल्यू NULL होनी चाहिए .
• अगर XrDepthSwapchainCreateInfoANDROID :: createFlags में XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_CONFIDENCE_IMAGE_BIT_ANDROID शामिल नहीं है, तो smoothDepthImage की वैल्यू NULL होनी चाहिए .

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

• XrDepthSwapchainImageANDROID का इस्तेमाल करने से पहले, XR_ANDROID_depth_texture एक्सटेंशन को चालू करना ज़रूरी है
• type ज़रूरी तौर पर XR_TYPE_DEPTH_SWAPCHAIN_IMAGE_ANDROID होना चाहिए
• next, NULL या स्ट्रक्चर चेन में मौजूद अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए

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

XrResult xrAcquireDepthSwapchainImagesANDROID(
    XrDepthSwapchainANDROID                     depthSwapchain,
    const XrDepthAcquireInfoANDROID*            acquireInfo,
    XrDepthAcquireResultANDROID*                acquireResult);

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

• depthSwapchain डेप्थ इमेज के लिए XrDepthSwapchainANDROID हैंडल है.
• acquireInfo एक XrDepthAcquireInfoANDROID है. इसमें डेप्थ इमेज पाने के तरीके के बारे में जानकारी होती है.
• acquireResult, XrDepthAcquireResultANDROID है. इसमें हासिल की गई डेप्थ इमेज के बारे में जानकारी होती है.

ऐप्लिकेशन, xrAcquireDepthSwapchainImagesANDROID फ़ंक्शन का इस्तेमाल करके, स्वैपचेन इमेज का सबसे नया उपलब्ध इंडेक्स, यानी कि XrDepthAcquireResultANDROID :: acquiredIndex , xrEnumerateDepthSwapchainImagesANDROID से गिने गए XrDepthSwapchainImageANDROID ऐरे में हासिल कर सकते हैं. XrDepthAcquireResultANDROID में, अन्य जानकारी भी शामिल होती है. जैसे, फ़ील्ड ऑफ़ व्यू और पोज़. ये जानकारी, डेप्थ डेटा को समझने के लिए ज़रूरी होती है. xrAcquireDepthSwapchainImagesANDROID को अगली बार कॉल किए जाने तक, इमेज ऐरे में हासिल किए गए स्लॉट से डेटा पढ़ा जा सकता है .

किसी सेशन में, xrBeginFrame और xrEndFrame के किसी भी जोड़े के बीच, xrAcquireDepthSwapchainImagesANDROID को एक से ज़्यादा बार कॉल नहीं किया जाना चाहिए.

• अगर रनटाइम पहले से हासिल की गई स्वैपचेन इमेज का इस्तेमाल कर रहा है, तो रनटाइम ब्लॉक कर सकता है.
• अगर xrBeginFrame से पहले या xrEndFrame के बाद xrAcquireDepthSwapchainImagesANDROID को कॉल किया जाता है, तो रनटाइम को XR_ERROR_CALL_ORDER_INVALID वैल्यू ज़रूर दिखानी चाहिए .
• अगर हर फ़्रेम में xrAcquireDepthSwapchainImagesANDROID को एक से ज़्यादा बार कॉल किया जाता है, तो रनटाइम को XR_ERROR_LIMIT_REACHED वापस भेजना ज़रूरी है. इसका मतलब है कि चालू सेशन में, xrBeginFrame को कॉल करने के बाद, xrEndFrame से जुड़ा कॉल नहीं किया गया है.
• अगर एनवायरमेंट डेप्थ डेटा अभी उपलब्ध नहीं है, तो रनटाइम शायद XR_ERROR_DEPTH_NOT_AVAILABLE_ANDROID वैल्यू दिखाता है. अगर ऐसा होता है, तो ऐप्लिकेशन को बाद के फ़्रेम में, xrAcquireDepthSwapchainImagesANDROID को फिर से कॉल करना चाहिए.

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

• xrAcquireDepthSwapchainImagesANDROID को कॉल करने से पहले, XR_ANDROID_depth_texture एक्सटेंशन को चालू करना ज़रूरी है
• depthSwapchain, XrDepthSwapchainANDROID का मान्य हैंडल होना चाहिए
• acquireInfo एक मान्य XrDepthAcquireInfoANDROID स्ट्रक्चर का पॉइंटर होना चाहिए
• acquireResult XrDepthAcquireResultANDROID स्ट्रक्चर का पॉइंटर होना चाहिए

रिटर्न कोड

सफल

• XR_SUCCESS
• XR_SESSION_LOSS_PENDING

Failure

• XR_ERROR_CALL_ORDER_INVALID
• XR_ERROR_DEPTH_NOT_AVAILABLE_ANDROID
• XR_ERROR_FUNCTION_UNSUPPORTED
• XR_ERROR_HANDLE_INVALID
• XR_ERROR_INSTANCE_LOST
• XR_ERROR_LIMIT_REACHED
• XR_ERROR_RUNTIME_FAILURE
• XR_ERROR_SESSION_LOST
• XR_ERROR_TIME_INVALID
• XR_ERROR_VALIDATION_FAILURE

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

typedef struct XrDepthAcquireInfoANDROID {
    XrStructureType    type;
    const void*        next;
    XrSpace            space;
    XrTime             displayTime;
} XrDepthAcquireInfoANDROID;

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

• type इस स्ट्रक्चर का XrStructureType है.
• next, NULL होता है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर होता है. इस तरह के स्ट्रक्चर, OpenXR के मुख्य स्पेसिफ़िकेशन या इस एक्सटेंशन में तय नहीं किए गए हैं.
• space एक XrSpace है. यह XrDepthAcquireResultANDROID :: views में, लौटाए गए पोज़ के रेफ़रंस फ़्रेम को तय करता है.
• displayTime एक XrTime है. यह XrDepthAcquireResultANDROID :: views में दिखाए गए पोज़ के लिए, पोज़ का हिसाब लगाने में लगने वाला समय बताता है. ऐप्लिकेशन को मौजूदा फ़्रेम के लिए, अनुमानित डिसप्ले टाइम को पूरा करना चाहिए.

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

• XrDepthAcquireInfoANDROID का इस्तेमाल करने से पहले, XR_ANDROID_depth_texture एक्सटेंशन को चालू करना ज़रूरी है
• type ज़रूरी तौर पर XR_TYPE_DEPTH_ACQUIRE_INFO_ANDROID होना चाहिए
• next, NULL या स्ट्रक्चर चेन में मौजूद अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
• space मान्य XrSpace हैंडल होना चाहिए

XrDepthAcquireResultANDROID स्ट्रक्चर को इस तरह से परिभाषित किया गया है:

typedef struct XrDepthAcquireResultANDROID {
    XrStructureType       type;
    const void*           next;
    uint32_t              acquiredIndex;
    XrTime                exposureTimestamp;
    XrDepthViewANDROID    views[2];
} XrDepthAcquireResultANDROID;

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

• type इस स्ट्रक्चर का XrStructureType है.
• next, NULL होता है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर होता है. इस तरह के स्ट्रक्चर, OpenXR के मुख्य स्पेसिफ़िकेशन या इस एक्सटेंशन में तय नहीं किए गए हैं.
• acquiredIndex, XrDepthSwapchainImageANDROID कलेक्शन में मौजूद उस टेक्सचर का इंडेक्स है जिसे xrEnumerateDepthSwapchainImagesANDROID फ़ंक्शन ने गिना है .
• exposureTimestamp, XrTime है. इससे पता चलता है कि डेप्थ मैप कब कैप्चर किया गया था.
• views दो XrDepthViewANDROID का एक ऐरे है. इसमें हर आंख के लिए एक व्यू होता है. इंडेक्स 0 बाईं आंख के लिए होता है और इंडेक्स 1 दाईं आंख के लिए होता है.

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

• XrDepthAcquireResultANDROID का इस्तेमाल करने से पहले, XR_ANDROID_depth_texture एक्सटेंशन को चालू करना ज़रूरी है
• type ज़रूरी तौर पर XR_TYPE_DEPTH_ACQUIRE_RESULT_ANDROID होना चाहिए
• next, NULL या स्ट्रक्चर चेन में मौजूद अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
• views का कोई भी एलिमेंट, XrDepthViewANDROID स्ट्रक्चर के हिसाब से मान्य होना चाहिए

XrDepthViewANDROID स्ट्रक्चर को इस तरह से परिभाषित किया गया है:

typedef struct XrDepthViewANDROID {
    XrStructureType    type;
    const void*        next;
    XrFovf             fov;
    XrPosef            pose;
} XrDepthViewANDROID;

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

• type इस स्ट्रक्चर का XrStructureType है.
• next, NULL होता है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर होता है. इस तरह के स्ट्रक्चर, OpenXR के मुख्य स्पेसिफ़िकेशन या इस एक्सटेंशन में तय नहीं किए गए हैं.
• fov एक XrFovf है. यह इस व्यू को जनरेट करने के लिए इस्तेमाल किए गए फ़ील्ड ऑफ़ व्यू के बारे में बताता है. व्यू को कभी भी हॉरिज़ॉन्टल या वर्टिकल तौर पर फ़्लिप नहीं किया जाता.
• pose एक XrPosef है. यह उस पोज़ के बारे में बताता है जिससे डेप्थ मैप रेंडर किया गया था. रेफ़रंस फ़्रेम, XrDepthAcquireInfoANDROID में तय किया जाता है .

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

• XrDepthViewANDROID का इस्तेमाल करने से पहले, XR_ANDROID_depth_texture एक्सटेंशन को चालू करना ज़रूरी है
• type ज़रूरी तौर पर XR_TYPE_DEPTH_VIEW_ANDROID होना चाहिए
• next, NULL या स्ट्रक्चर चेन में मौजूद अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए

डेप्थ ट्रैकिंग के लिए कोड का उदाहरण

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

XrInstance instance;  // previously initialized
XrSystemId systemId;  // previously initialized
XrSession session; // previously initialized
XrSpace stageSpace; // space created for XR_REFERENCE_SPACE_TYPE_STAGE.

// The function pointers are previously initialized using xrGetInstanceProcAddr.
PFN_xrCreateDepthSwapchainANDROID xrCreateDepthSwapchainANDROID; // previously initialized
PFN_xrDestroyDepthSwapchainANDROID xrDestroyDepthSwapchainANDROID; // previously initialized
PFN_xrEnumerateDepthSwapchainImagesANDROID xrEnumerateDepthSwapchainImagesANDROID; // previously initialized
PFN_xrEnumerateDepthResolutionsANDROID xrEnumerateDepthResolutionsANDROID; // previously initialized
PFN_xrAcquireDepthSwapchainImagesANDROID xrAcquireDepthSwapchainImagesANDROID; // previously initialized

float tanf(float);

// Inspect system capability
XrSystemProperties properties{XR_TYPE_SYSTEM_PROPERTIES};
XrSystemDepthTrackingPropertiesANDROID depthTrackingProperties{XR_TYPE_SYSTEM_DEPTH_TRACKING_PROPERTIES_ANDROID};
properties.next = &depthTrackingProperties;
CHK_XR(xrGetSystemProperties(instance, systemId, &properties));
if (!depthTrackingProperties.supportsDepthTracking) {
  // depth tracking is not supported.
  return;
}

// Query the supported depth resolution.
XrDepthCameraResolutionANDROID supportedDepthResolution;
uint32_t supportedResolutionCount = 0;
CHK_XR(xrEnumerateDepthResolutionsANDROID(
    session, 1, &supportedResolutionCount, &supportedDepthResolution));

// Define metadata to access the raw and smooth depth along with confidences.
XrDepthSwapchainCreateInfoANDROID swapchainCreateInfo = {
  .type = XR_TYPE_DEPTH_SWAPCHAIN_CREATE_INFO_ANDROID,
  .next = nullptr,
  // Use the resolution supported by the runtime.
  .resolution = supportedDepthResolution,
  .createFlags =
    XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_DEPTH_IMAGE_BIT_ANDROID |
    XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_CONFIDENCE_IMAGE_BIT_ANDROID |
    XR_DEPTH_SWAPCHAIN_CREATE_RAW_DEPTH_IMAGE_BIT_ANDROID |
    XR_DEPTH_SWAPCHAIN_CREATE_RAW_CONFIDENCE_IMAGE_BIT_ANDROID,
};

XrDepthSwapchainANDROID depthSwapchain;
CHK_XR(xrCreateDepthSwapchainANDROID(
    session, &swapchainCreateInfo, &depthSwapchain));

// Enumerate depth images.
uint32_t imageCountOutput = 0;
CHK_XR(xrEnumerateDepthSwapchainImagesANDROID(
    depthSwapchain, 0, &imageCountOutput, nullptr));
std::vector<XrDepthSwapchainImageANDROID> depthImages(imageCountOutput);
for (int i = 0; i < imageCountOutput; i++) {
  depthImages[i].type = XR_TYPE_DEPTH_SWAPCHAIN_IMAGE_ANDROID;
}
CHK_XR(xrEnumerateDepthSwapchainImagesANDROID(
  depthSwapchain, imageCountOutput, &imageCountOutput, depthImages.data()));

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

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

    XrDepthAcquireInfoANDROID acquireInfo = {
        .type = XR_TYPE_DEPTH_ACQUIRE_INFO_ANDROID,
        .space = stageSpace,
        .displayTime = time
    };
    XrDepthAcquireResultANDROID acquireResult = {
        .type = XR_TYPE_DEPTH_ACQUIRE_RESULT_ANDROID,
    };
    CHK_XR(xrAcquireDepthSwapchainImagesANDROID(
        depthSwapchain, &acquireInfo, &acquireResult));

    // Each value in a depth image corresponds to a point in the real world.
    // The sample code below shows how to find the stageSpace position of
    // the point corresponding to a particular value in the depth image.

    // For this sample code, assume we are using a right handed coordinate system
    // with +X to the right, +Y up and -Z forward.

    XrDepthSwapchainImageANDROID *image =
        &depthImages[acquireResult.acquiredIndex];

    // Assume supported resolution is XR_DEPTH_CAMERA_RESOLUTION_160x160_ANDROID.
    const int imageResolution = 160;
    int imageY = 80; // value in [0, imageResolution)
    int imageX = 80; // value in [0, imageResolution)

    // Get depth value from left eye.
    // A right depth value is obtained with the following expression:
    // depthR = image->rawDepthImage[imageResolution*imageResolution+i*imageResolution+j]
    float depthL = image->rawDepthImage[imageY*imageResolution + imageX];
    XrDepthViewANDROID viewL = acquireResult.views[0];

    float tanL = tanf(viewL.fov.angleLeft);
    float tanR = tanf(viewL.fov.angleRight);
    float tanU = tanf(viewL.fov.angleUp);
    float tanD = tanf(viewL.fov.angleDown);

    float s = (imageX + 0.5f) / (float)imageResolution;
    float t = (imageY + 0.5f) / (float)imageResolution;

    // Calculate the depth camera space position of the point
    // corresponding to this depth value.
    XrVector3f posInCameraSpace;
    posInCameraSpace.z = -depthL;
    posInCameraSpace.x = (tanL + (tanR - tanL)*s)*depthL;
    posInCameraSpace.y = (tanD + (tanU - tanD)*t)*depthL;

    XrPosef depthCameraPoseL = viewL.pose;
    // Transform posInCameraSpace by depthCameraPoseL

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

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

• XrDepthSwapchainANDROID

नए निर्देश

• xrAcquireDepthSwapchainImagesANDROID
• xrCreateDepthSwapchainANDROID
• xrDestroyDepthSwapchainANDROID
• xrEnumerateDepthResolutionsANDROID
• xrEnumerateDepthSwapchainImagesANDROID

नई संरचनाएं

• XrDepthAcquireInfoANDROID
• XrDepthAcquireResultANDROID
• XrDepthSwapchainCreateInfoANDROID
• XrDepthSwapchainImageANDROID
• XrDepthViewANDROID

• XrSystemProperties को बढ़ाना :

  • XrSystemDepthTrackingPropertiesANDROID

नए एनम

• XrDepthCameraResolutionANDROID
• XrDepthSwapchainCreateFlagBitsANDROID

नए बिटमास्क

• XrDepthSwapchainCreateFlagsANDROID

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

• XR_ANDROID_DEPTH_TEXTURE_EXTENSION_NAME
• XR_ANDROID_depth_texture_SPEC_VERSION

• XrObjectType को बढ़ाना :

  • XR_OBJECT_TYPE_DEPTH_SWAPCHAIN_ANDROID

• XrResult को बढ़ाना :

  • XR_ERROR_DEPTH_NOT_AVAILABLE_ANDROID

• XrStructureType को बढ़ाना :

  • XR_TYPE_DEPTH_ACQUIRE_INFO_ANDROID
  • XR_TYPE_DEPTH_ACQUIRE_RESULT_ANDROID
  • XR_TYPE_DEPTH_SWAPCHAIN_CREATE_INFO_ANDROID
  • XR_TYPE_DEPTH_SWAPCHAIN_IMAGE_ANDROID
  • XR_TYPE_DEPTH_VIEW_ANDROID
  • XR_TYPE_SYSTEM_DEPTH_TRACKING_PROPERTIES_ANDROID

समस्याएं

वर्शन इतिहास

• पहला संशोधन, 09-09-2024 (लेवाना चेन)

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