Android XR for OpenXR | Android Developers

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

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

XR_EXT_spatial_container_self_rendering

Name String

XR_EXT_spatial_container_self_rendering

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

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

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

814

बदलाव

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

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

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

XR_EXT_spatial_container

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

2026-08-06

आईपी स्टेटस

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

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

लैकलन फ़ोर्ड, Google
ऐंड्रियास लोव सेल्विक, Meta Platforms
ऐडम गाउसेटिस, Meta Platforms
ब्योर्न स्वेनसन, LÖVR
कैस एवरेट, Meta Platforms
क्रिश्चियन क्रूस, Meta Platforms
डेनी रॉनग्रेन, Varjo Technologies
फ़्रेडिया हुया-कुआडियो, Godot Engine
जेकब बोर्नक्रांट्ज़, NVIDIA
जेरेड फ़ाइंडर, Google
जॉनाथन राइट, Meta Platforms
जियान झांग, ByteDance
कर्टिस एवली, Qualcomm
मॉरीशियो नारवेज़, Meta Platforms
निक क्लिंगनस्मिथ, Qualcomm
निकिता लुत्सेन्को, Meta Platforms
प्रवीण बाबू जे डी, ByteDance
रायली पावलिक, Collabora
सलार खान, Google
शुआइ लियू, ByteDance
वॉल्टर लू, Meta Platforms
यिन ली, Microsoft

खास जानकारी

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

इस एक्सटेंशन को XR_EXT_spatial_container के साथ इस्तेमाल करने पर, OpenXR 1.x के कोर कंपोज़िशन लेयर रेंडरिंग की क्षमताओं का सुपरसेट मिलता है. OpenXR 1.x रनटाइम, जो ग्राफ़िकल रेंडरिंग और इस एक्सटेंशन के साथ काम करते हैं, उन्हें XrSystemSpatialContainerPropertiesEXT :: supportsImmersive को 'सही' पर सेट करना चाहिए. इससे यह पता चलता है कि वे इमर्सिव स्पेशल कंटेनर के साथ काम करते हैं.

स्पेशल कंटेनर रेंडरिंग लाइफ़साइकल

स्पेशल कंटेनर के लिए सेल्फ़ रेंडरिंग का इस्तेमाल करने के लिए, कोई ऐप्लिकेशन xrCreateSpatialContainerEXT को कॉल करते समय, XrSpatialContainerCreateInfoEXT :: graphicsPresentation को XR_SPATIAL_CONTAINER_GRAPHICS_PRESENTATION_SELF_RENDERING_EXT पर सेट करता है. इसके बाद, वह ऐप्लिकेशन xrBeginSpatialContainerRenderingEXT और xrEndSpatialContainerRenderingEXT फ़ंक्शन को कॉल करके, यह मैनेज कर सकता है कि कोई स्पेशल कंटेनर रेंडर हो रहा है या नहीं. ये फ़ंक्शन, xrBeginSession और xrEndSession की जगह ले लेते हैं. ये हर फ़्रेम के लिए होने वाले ऑपरेशन नहीं हैं, जैसे कि xrBeginFrame और xrEndFrame .

हर फ़्रेम के लिए, ऐप्लिकेशन को इन चरणों से गुज़रना पड़ता है:

xrWaitFrame और xrBeginFrame को कॉल करें. इन फ़ंक्शन में कंटेनर के हिसाब से कोई स्ट्रक्चर नहीं होता. साथ ही, ये मुख्य स्पेसिफ़िकेशन के हिसाब से काम करते हैं.
xrLocateSpatialContainerViewsEXT की मदद से, रेंडर किए जा रहे सभी स्पेशल कंटेनर के लिए, व्यू पोज़, प्रोजेक्शन पैरामीटर, और रेंडरिंग के सुझाव पाएं. हर स्पेशल कंटेनर के लिए, रनटाइम यह रिपोर्ट करता है कि उसकी कंपोज़िशन लेयर रेंडर की जानी चाहिए या नहीं. साथ ही, XrSpatialContainerViewStateEXT को भरकर, लेयर को रेंडर करने का सुझाया गया तरीका भी बताता है.
पिक्सल को सामान्य रूप से कंपोज़िशन लेयर में रेंडर करें. इन कार्रवाइयों में कंटेनर के हिसाब से कोई स्ट्रक्चर नहीं होता.
xrEndFrame को कॉल करके और XrSpatialContainerLayerFrameEndInfoEXT को चेन करके, रेंडर हो रहे सभी स्पेशल कंटेनर के लिए कंपोज़िशन लेयर सबमिट करें.

XrSpatialContainerEXT हैंडल को खत्म करने पर, वह रेंडर सेट से अपने-आप हट जाता है. कोई ऐप्लिकेशन किसी स्पेशल कंटेनर को नष्ट कर सकता है. भले ही, उसने xrBeginSpatialContainerRenderingEXT को कॉल किया हो, लेकिन xrEndSpatialContainerRenderingEXT को कॉल न किया हो. रनटाइम को इस तरह काम करना चाहिए कि अगर xrDestroySpatialContainerEXT को लागू करने के दौरान, xrEndSpatialContainerRenderingEXT को पहले ही कॉल करने की ज़रूरत पड़े, तो उसे इंप्लिसिट तरीके से कॉल किया जाए. ऐसा तब होगा, जब xrDestroySpatialContainerEXT को लागू करने की प्रोसेस पूरी हो जाए.

जब किसी ऐप्लिकेशन को ऐक्टिव रेंडर सेट में मौजूद कंटेनर के लिए, XrEventDataSpatialContainerClosedEXT इवेंट मिलता है, तो उस ऐप्लिकेशन को xrEndSpatialContainerRenderingEXT को कॉल करना चाहिए. साथ ही, XrSpatialContainerEXT हैंडल को खत्म करना चाहिए.

xrBeginSpatialContainerRenderingEXT फ़ंक्शन, स्पेशल कंटेनर को हर सेशन के ऐक्टिव रेंडर सेट में जोड़ता है. इससे ऐप्लिकेशन, स्पेशल कंटेनर के लिए कंपोज़िशन लेयर को xrEndFrame में सबमिट कर पाता है.

XrResult xrBeginSpatialContainerRenderingEXT(
    XrSession                                   session,
    const XrSpatialContainerBeginInfoEXT*       beginInfo);

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

session, XrSession है.
beginInfo, XrSpatialContainerBeginInfoEXT स्ट्रक्चर का पॉइंटर है.

ऐप्लिकेशन आम तौर पर, XrEventDataSpatialContainerVisibleChangedEXT :: visible को 'सही है' पर सेट करके, विज़िबल-चेंज्ड इवेंट के जवाब में इसे कॉल करते हैं.

अगर xrCreateSpatialContainerEXT को कॉल करते समय, XR_SPATIAL_CONTAINER_GRAPHICS_PRESENTATION_SELF_RENDERING_EXT का इस्तेमाल करके स्पेशल कंटेनर नहीं बनाया गया था, तो रनटाइम को XR_ERROR_SPATIAL_CONTAINER_GRAPHICS_PRESENTATION_MISSING_EXT दिखाना चाहिए .

अगर स्पेशल कंटेनर पहले से ही ऐक्टिव रेंडर सेट में मौजूद है, तो रनटाइम को XR_ERROR_SPATIAL_CONTAINER_IS_RENDERING_EXT दिखाना चाहिए .

अगर xrBeginSpatialContainerRenderingEXT को ऐसे समय पर कॉल किया जाता है जब ऐप्लिकेशन xrWaitFrame को कॉल नहीं कर सकता (यानी कि xrBeginFrame और xrEndFrame विंडो के अंदर), तो रनटाइम को XR_ERROR_CALL_ORDER_INVALID दिखाना चाहिए.

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

xrBeginSpatialContainerRenderingEXT को कॉल करने से पहले, XR_EXT_spatial_container_self_rendering एक्सटेंशन को चालू करना ज़रूरी है
session एक मान्य XrSession हैंडल होना चाहिए
beginInfo को किसी मान्य XrSpatialContainerBeginInfoEXT स्ट्रक्चर का पॉइंटर होना ज़रूरी है

Thread की सुरक्षा

किसी अन्य xrBeginSpatialContainerRenderingEXT , xrEndSpatialContainerRenderingEXT या xrEndFrame कॉल से session पैरामीटर को ऐक्सेस करने के लिए, बाहरी तौर पर सिंक्रनाइज़ करना ज़रूरी है

रिटर्न कोड

सफलता

XR_SUCCESS
XR_SESSION_LOSS_PENDING

Failure

XR_ERROR_CALL_ORDER_INVALID
XR_ERROR_FUNCTION_UNSUPPORTED
XR_ERROR_HANDLE_INVALID
XR_ERROR_INSTANCE_LOST
XR_ERROR_RUNTIME_FAILURE
XR_ERROR_SESSION_LOST
XR_ERROR_SPATIAL_CONTAINER_GRAPHICS_PRESENTATION_MISSING_EXT
XR_ERROR_SPATIAL_CONTAINER_IS_RENDERING_EXT
XR_ERROR_VALIDATION_FAILURE
XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED

XrSpatialContainerBeginInfoEXT स्ट्रक्चर का इस्तेमाल, किसी स्पेशल कंटेनर की रेंडरिंग शुरू करने के लिए पैरामीटर तय करने के लिए किया जाता है.

typedef struct XrSpatialContainerBeginInfoEXT {
    XrStructureType            type;
    const void*                next;
    XrSpatialContainerEXT      spatialContainer;
    XrViewConfigurationType    primaryViewConfigurationType;
} XrSpatialContainerBeginInfoEXT;

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

type, इस स्ट्रक्चर का XrStructureType है.
next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
spatialContainer, रेंडरिंग शुरू करने के लिए XrSpatialContainerEXT है.
primaryViewConfigurationType, प्राइमरी XrViewConfigurationType है. इसका इस्तेमाल, स्पेशल कंटेनर के लिए किया जाता है.

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

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

XrSpatialContainerBeginInfoEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_container_self_rendering एक्सटेंशन चालू करना ज़रूरी है
type की वैल्यू XR_TYPE_SPATIAL_CONTAINER_BEGIN_INFO_EXT होनी चाहिए
next NULL या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
spatialContainer एक मान्य XrSpatialContainerEXT हैंडल होना चाहिए
primaryViewConfigurationType की वैल्यू, XrViewConfigurationType की मान्य वैल्यू होनी चाहिए

xrEndSpatialContainerRenderingEXT फ़ंक्शन, स्पेशल कंटेनर को ऐक्टिव रेंडर सेट से हटा देता है.

XrResult xrEndSpatialContainerRenderingEXT(
    XrSession                                   session,
    const XrSpatialContainerEndInfoEXT*         endInfo);

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

session, XrSession है.
endInfo, XrSpatialContainerEndInfoEXT स्ट्रक्चर का पॉइंटर है.

ऐप्लिकेशन आम तौर पर, XrEventDataSpatialContainerVisibleChangedEXT :: visible को false पर सेट करके, विज़िबल-चेंज्ड इवेंट के जवाब में इसे कॉल करते हैं.

अगर स्पेशल कंटेनर, ऐक्टिव रेंडर सेट में नहीं है, तो रनटाइम को XR_ERROR_SPATIAL_CONTAINER_NOT_RENDERING_EXT दिखाना चाहिए .

अगर xrEndSpatialContainerRenderingEXT को ऐसे समय पर कॉल किया जाता है जब ऐप्लिकेशन xrWaitFrame को कॉल नहीं कर सकता (यानी कि xrBeginFrame और xrEndFrame कॉल के बीच की अवधि के दौरान), तो रनटाइम को XR_ERROR_CALL_ORDER_INVALID दिखाना चाहिए .

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

xrEndSpatialContainerRenderingEXT को कॉल करने से पहले, XR_EXT_spatial_container_self_rendering एक्सटेंशन को चालू करना ज़रूरी है
session एक मान्य XrSession हैंडल होना चाहिए
endInfo को किसी मान्य XrSpatialContainerEndInfoEXT स्ट्रक्चर का पॉइंटर होना चाहिए

Thread की सुरक्षा

किसी अन्य xrBeginSpatialContainerRenderingEXT , xrEndSpatialContainerRenderingEXT या xrEndFrame कॉल से session पैरामीटर को ऐक्सेस करने के लिए, बाहरी तौर पर सिंक्रनाइज़ करना ज़रूरी है

रिटर्न कोड

सफलता

XR_SUCCESS
XR_SESSION_LOSS_PENDING

Failure

XR_ERROR_CALL_ORDER_INVALID
XR_ERROR_FUNCTION_UNSUPPORTED
XR_ERROR_HANDLE_INVALID
XR_ERROR_INSTANCE_LOST
XR_ERROR_RUNTIME_FAILURE
XR_ERROR_SESSION_LOST
XR_ERROR_SPATIAL_CONTAINER_NOT_RENDERING_EXT
XR_ERROR_VALIDATION_FAILURE

XrSpatialContainerEndInfoEXT स्ट्रक्चर का इस्तेमाल, स्पेशल कंटेनर की रेंडरिंग खत्म करने के लिए पैरामीटर तय करने के लिए किया जाता है.

typedef struct XrSpatialContainerEndInfoEXT {
    XrStructureType          type;
    const void*              next;
    XrSpatialContainerEXT    spatialContainer;
} XrSpatialContainerEndInfoEXT;

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

type, इस स्ट्रक्चर का XrStructureType है.
next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
spatialContainer, XrSpatialContainerEXT है, ताकि रेंडरिंग को खत्म किया जा सके.

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

XrSpatialContainerEndInfoEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_container_self_rendering एक्सटेंशन चालू करना ज़रूरी है
type की वैल्यू XR_TYPE_SPATIAL_CONTAINER_END_INFO_EXT होनी चाहिए
next NULL या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
spatialContainer एक मान्य XrSpatialContainerEXT हैंडल होना चाहिए

xrLocateSpatialContainerViewsEXT की मदद से व्यू का पता लगाना

xrLocateSpatialContainerViewsEXT फ़ंक्शन, स्पेशल कंटेनर के सेट के लिए व्यू का पता लगाता है.

XrResult xrLocateSpatialContainerViewsEXT(
    XrSession                                   session,
    const XrSpatialContainerViewsLocateInfoEXT* locateInfo,
    uint32_t                                    viewStateCount,
    XrSpatialContainerViewStateEXT*             viewStates,
    uint32_t                                    viewCount,
    XrView*                                     views);

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

session, XrSession है.
locateInfo, XrSpatialContainerViewsLocateInfoEXT स्ट्रक्चर का पॉइंटर है.
viewStateCount, viewStates कलेक्शन की संख्या है.
viewStates, XrSpatialContainerViewStateEXT स्ट्रक्चर के कलेक्शन का पॉइंटर है. इसे रनटाइम के दौरान भरा जाता है.
viewCount, views कलेक्शन की संख्या है.
views, XrView स्ट्रक्चर के कलेक्शन का पॉइंटर है.

यह फ़ंक्शन xrLocateViews की जगह लेता है. इससे कोई ऐप्लिकेशन, एक साथ कई स्पेशल कंटेनर के लिए व्यू की क्वेरी कर सकता है.

सभी स्पेशल कंटेनर के व्यू, एक ही views कलेक्शन में दिखाए जाते हैं. व्यू को XrSpatialContainerViewsLocateInfoEXT :: viewLocateInfos कलेक्शन में, स्पेशल कंटेनर के इंडेक्स के आधार पर क्रम में लगाया जाता है. इसके बाद, उस कंटेनर के व्यू इंडेक्स के आधार पर क्रम में लगाया जाता है.

उदाहरण के लिए, अगर कोई ऐप्लिकेशन XrSpatialContainerViewsLocateInfoEXT :: viewLocateInfos में तीन स्पेशल कंटेनर उपलब्ध कराता है, तो:

इंडेक्स 0: XR_VIEW_CONFIGURATION_TYPE_PRIMARY_MONO (1 व्यू)
इंडेक्स 1: XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO (दो व्यू)
इंडेक्स 2: XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO_WITH_FOVEATED_INSET (4 व्यू)

इसके बाद, रनटाइम को views कलेक्शन में सात व्यू भरने होंगे:

views [0], कंटेनर 0 का व्यू है.
views [1], कंटेनर 1 के लिए बाईं आंख का व्यू है.
views [2], कंटेनर 1 के लिए दाईं आंख का व्यू है.
views [3], कंटेनर 2 के लिए बाईं आंख का व्यू है.
views [4], कंटेनर 2 के लिए दाईं आंख का व्यू है.
views [5] कंटेनर 2 के लिए, बाईं आंख का इनसेट व्यू है.
views [6], कंटेनर 2 के लिए दाईं आंख का इनसेट व्यू है.

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

रनटाइम, व्यू कॉन्फ़िगरेशन को ऑप्टिमाइज़ करने के लिए, उसे कम व्यू वाले टाइप में बदल सकता है. उदाहरण के लिए, कोई कंटेनर बहुत दूर और छोटा है, जिससे स्टीरियो व्यू नहीं दिखता. अगर रनटाइम, व्यू कॉन्फ़िगरेशन को कम करता है, तो रनटाइम को उस कंटेनर के लिए व्यू की ओरिजनल संख्या अब भी दिखानी चाहिए. साथ ही, कम किए गए व्यू के डुप्लीकेट के साथ अतिरिक्त व्यू भरने चाहिए. उदाहरण के लिए, अगर XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO को XR_VIEW_CONFIGURATION_TYPE_PRIMARY_MONO में बदल दिया जाता है, तो इंडेक्स 0 और इंडेक्स 1, दोनों में एक ही मोनो व्यू होगा. इसलिए, views कलेक्शन में दिखाए गए व्यू की कुल संख्या इस बात पर निर्भर नहीं करती कि रनटाइम ने किसी व्यू कॉन्फ़िगरेशन को खत्म करने का फ़ैसला लिया है या नहीं.

रनटाइम को हर XrView :: fov को इस तरह से अडैप्ट करना चाहिए कि फ़्रस्टम जितना हो सके उतना छोटा हो. हालांकि, इसमें संबंधित स्पेशल कंटेनर की पूरी सीमाएं शामिल होनी चाहिए. रनटाइम, नॉन-सिमेट्रिकल एफ़ओवी दिखा सकते हैं. उदाहरण के लिए, अगर कोई स्पेशल कंटेनर, उपयोगकर्ता के व्यू के हिसाब से तिरछे ऐंगल पर है या किसी अन्य ऑब्जेक्ट की वजह से आंशिक रूप से छिपा हुआ है. रनटाइम, स्पेशल कंटेनर के लिए टारगेट रेंडरिंग सरफ़ेस को अपनी पसंद के मुताबिक पोज़िशन कर सकते हैं. मल्टी-ऐप्लिकेशन रेंडरिंग की वजह से, रनटाइम शायद ऐसी XrView वैल्यू दिखाए जो पिक्सल रेंडरिंग के लिए सही न हों. ऐसा इसलिए होता है, क्योंकि इसमें स्पेशल कंटेनर, उपयोगकर्ता से अलग होते हैं. उदाहरण के लिए, अगर स्पेशल कंटेनर स्क्रीन पर नहीं दिखता है, तो XrView :: fov को सेट करने के लिए कोई मान्य वैल्यू नहीं होती. ऐसे मामलों में, रनटाइम को XrSpatialContainerViewStateEXT :: shouldSubmitLayers को false पर सेट करना होगा.

रनटाइम, viewStates कलेक्शन में हर स्पेशल कंटेनर के रेंडरिंग स्टेटस की अतिरिक्त जानकारी दिखाता है. अगर viewStateCount, XrSpatialContainerViewsLocateInfoEXT :: viewLocateInfoCount के बराबर नहीं है, तो रनटाइम को XR_ERROR_VALIDATION_FAILURE दिखाना चाहिए .

रनटाइम के किसी स्पेशल कंटेनर के लिए, XrEventDataSpatialContainerClosedEXT इवेंट को सूची में शामिल करने के बाद, यह फ़ंक्शन संबंधित स्पेशल कंटेनर के लिए, XrSpatialContainerViewStateEXT :: shouldSubmitLayers में XR_FALSE और XrSpatialContainerViewStateEXT :: viewStateFlags में 0 ज़रूर दिखाना चाहिए.

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

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

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

xrLocateSpatialContainerViewsEXT को कॉल करने से पहले, XR_EXT_spatial_container_self_rendering एक्सटेंशन को चालू करना ज़रूरी है
session एक मान्य XrSession हैंडल होना चाहिए
locateInfo को किसी मान्य XrSpatialContainerViewsLocateInfoEXT स्ट्रक्चर का पॉइंटर होना चाहिए
viewStates, viewStateCount XrSpatialContainerViewStateEXT स्ट्रक्चर के कलेक्शन का पॉइंटर होना चाहिए
views को viewCount XrView स्ट्रक्चर के कलेक्शन का पॉइंटर होना ज़रूरी है
viewStateCount पैरामीटर की वैल्यू, 0 से ज़्यादा होनी चाहिए
viewCount पैरामीटर की वैल्यू, 0 से ज़्यादा होनी चाहिए

रिटर्न कोड

सफलता

XR_SUCCESS
XR_SESSION_LOSS_PENDING

Failure

XR_ERROR_FUNCTION_UNSUPPORTED
XR_ERROR_HANDLE_INVALID
XR_ERROR_INSTANCE_LOST
XR_ERROR_RUNTIME_FAILURE
XR_ERROR_SESSION_LOST
XR_ERROR_SPATIAL_CONTAINER_NOT_RENDERING_EXT
XR_ERROR_TIME_INVALID
XR_ERROR_VALIDATION_FAILURE
XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED

XrSpatialContainerViewsLocateInfoEXT स्ट्रक्चर में, स्पेशल कंटेनर के कलेक्शन में व्यू ढूंढने के लिए पैरामीटर शामिल होते हैं.

typedef struct XrSpatialContainerViewsLocateInfoEXT {
    XrStructureType                               type;
    const void*                                   next;
    XrTime                                        displayTime;
    uint32_t                                      viewLocateInfoCount;
    const XrSpatialContainerViewLocateInfoEXT*    viewLocateInfos;
} XrSpatialContainerViewsLocateInfoEXT;

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

type, इस स्ट्रक्चर का XrStructureType है.
next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
displayTime वह XrTime है जिस पर व्यू को ढूंढना है.
viewLocateInfoCount, viewLocateInfos कलेक्शन में मौजूद एंट्री की संख्या है.
viewLocateInfos, XrSpatialContainerViewLocateInfoEXT स्ट्रक्चर के कलेक्शन का पॉइंटर है.

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

XrSpatialContainerViewsLocateInfoEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_container_self_rendering एक्सटेंशन चालू करना ज़रूरी है
type की वैल्यू XR_TYPE_SPATIAL_CONTAINER_VIEWS_LOCATE_INFO_EXT होनी चाहिए
next NULL या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
viewLocateInfos को मान्य viewLocateInfoCount XrSpatialContainerViewLocateInfoEXT स्ट्रक्चर के कलेक्शन का पॉइंटर होना ज़रूरी है
viewLocateInfoCount पैरामीटर की वैल्यू, 0 से ज़्यादा होनी चाहिए

XrSpatialContainerViewLocateInfoEXT स्ट्रक्चर में, किसी खास स्पेशल कंटेनर के लिए पैरामीटर होते हैं. इनकी मदद से, व्यू का पता लगाया जाता है.

typedef struct XrSpatialContainerViewLocateInfoEXT {
    XrStructureType            type;
    const void*                next;
    XrViewConfigurationType    viewConfigurationType;
    XrSpace                    space;
    XrSpatialContainerEXT      spatialContainer;
} XrSpatialContainerViewLocateInfoEXT;

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

type, इस स्ट्रक्चर का XrStructureType है.
next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
viewConfigurationType एक XrViewConfigurationType है, जिसका इस्तेमाल स्पेशल कंटेनर के लिए किया जाता है.
space वह XrSpace है जिसमें स्पेशल कंटेनर के व्यू मौजूद हैं.
spatialContainer, XrSpatialContainerEXT हैंडल है.

ऐप्लिकेशन, space में कोई भी मान्य XrSpace उपलब्ध करा सकता है. हालांकि, हमारा सुझाव है कि वह XrSpatialContainerViewLocateInfoEXT स्ट्रक्चर में बताए गए XrSpatialContainerEXT के लिए, स्पेशल कंटेनर स्पेस उपलब्ध कराए.

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

XrSpatialContainerViewLocateInfoEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_container_self_rendering एक्सटेंशन चालू करना ज़रूरी है
type की वैल्यू XR_TYPE_SPATIAL_CONTAINER_VIEW_LOCATE_INFO_EXT होनी चाहिए
next NULL या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
viewConfigurationType की वैल्यू, XrViewConfigurationType की मान्य वैल्यू होनी चाहिए
space XrSpace हैंडल मान्य होना चाहिए
spatialContainer एक मान्य XrSpatialContainerEXT हैंडल होना चाहिए
space और spatialContainer, दोनों को एक ही XrSession से बनाया, असाइन या वापस लाया गया होना चाहिए

XrSpatialContainerViewStateEXT स्ट्रक्चर को xrLocateSpatialContainerViewsEXT को कॉल करके भरा जाता है. इसमें हर स्पेशल कंटेनर के रेंडरिंग की जानकारी होती है.

typedef struct XrSpatialContainerViewStateEXT {
    XrStructureType            type;
    void*                      next;
    XrViewStateFlags           viewStateFlags;
    XrViewConfigurationType    viewConfigurationType;
    XrBool32                   shouldSubmitLayers;
    XrExtent2Di                recommendedImageExtent;
} XrSpatialContainerViewStateEXT;

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

type, इस स्ट्रक्चर का XrStructureType है.
next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
viewStateFlags, XrViewStateFlags का बिटमास्क है. इन फ़्लैग का मकसद, कोर XrViewState स्ट्रक्चर में मौजूद viewStateFlags जैसा ही होता है.
viewConfigurationType एक XrViewConfigurationType है. इससे पता चलता है कि रनटाइम, स्पेशल कंटेनर के लिए किस व्यू कॉन्फ़िगरेशन टाइप का इस्तेमाल कर रहा है. रनटाइम, अनुरोध किए गए व्यू की तुलना में कम व्यू वाले व्यू कॉन्फ़िगरेशन में बदल सकते हैं.
shouldSubmitLayers एक XrBool32 है, जिसे रनटाइम ने वापस भेजा है. अगर XR_FALSE , तो ऐप्लिकेशन को इस स्पेशल कंटेनर के लिए कंपोज़िशन सबमिट करने से बचना चाहिए. ऐसा इसलिए, क्योंकि फ़िलहाल यह दिख नहीं रहा है या ऐसी स्थिति में है जहां रेंडरिंग की ज़रूरत नहीं है.
recommendedImageExtent एक XrExtent2Di स्ट्रक्चर है, जो स्पैशल कंटेनर के लिए सुझाए गए रिज़ॉल्यूशन को दिखाता है.

OpenXR व्यू की मुख्य जगह की जानकारी की तरह ही, ऐप्लिकेशन को XrSpatialContainerViewStateEXT :: viewStateFlags की जांच ज़रूर करनी चाहिए. इससे यह पक्का किया जा सकता है कि रेंडरिंग के लिए व्यू डेटा का इस्तेमाल करने से पहले, पोज़िशन और ओरिएंटेशन मान्य हों और उन्हें ट्रैक किया गया हो.

ऐप्लिकेशन को shouldSubmitLayers और viewConfigurationType की जांच करनी चाहिए, ताकि रनटाइम के दौरान तय की गई सीमा से ज़्यादा रेंडरिंग न हो. shouldSubmitLayers के false होने पर, ऐप्लिकेशन रेंडर करने के अपने तरीके को इस तरह बदलता है:

ऐप्लिकेशन को XrView :: fov को नहीं पढ़ना चाहिए.
ऐप्लिकेशन में recommendedImageExtent नहीं पढ़ा जाना चाहिए .
ऐप्लिकेशन को स्वैपचेन में रेंडर करने और उससे जुड़े स्पेशल कंटेनर के लिए कंपोज़िशन लेयर सबमिट करने से बचना चाहिए.
ऐप्लिकेशन को XrSpatialContainerLayerEXT :: retainPreviousSubmission को true पर सेट करना चाहिए. अगर ऐप्लिकेशन फिर भी लेयर सबमिट करने का विकल्प चुनता है, तो रनटाइम यह तय करता है कि उसे लेयर के साथ क्या करना है. उदाहरण के लिए, रनटाइम उन्हें हटाने का विकल्प चुन सकता है.

recommendedImageExtent का इस्तेमाल खास तौर पर उन लेयर के लिए किया जाता है जिन्हें कंटेनर की पोज़िशन या उपयोगकर्ता के व्यू के आधार पर अपडेट किया जाएगा. स्पेशल कंटेनर की पोज़िशन या उपयोगकर्ता के व्यू (जैसे, सामान्य 3D कॉन्टेंट) पर निर्भर कॉन्टेंट वाली लेयर को अपडेट करते समय, ऐप्लिकेशन को डिफ़ॉल्ट रूप से सुझाए गए व्यू साइज़ के बजाय, इस छोटे व्यूपोर्ट पर रेंडर करना चाहिए. लेयर को ऐसे कॉन्टेंट के साथ अपडेट करते समय जो स्पेशल कंटेनर की पोज़िशन या उपयोगकर्ता के व्यू पर निर्भर नहीं करता (जैसे कि स्टैटिक क्वाड लेयर), ऐप्लिकेशन इन वैल्यू को सुरक्षित तरीके से अनदेखा कर सकता है. व्यू पर निर्भर लेयर के लिए, recommendedImageExtent रनटाइम से ऐप्लिकेशन को मिलने वाला सुझाव है. इसका मकसद, एलियासिंग को कम करना और रेंडरिंग की परफ़ॉर्मेंस को बेहतर बनाना है. अगर ऐप्लिकेशन चाहे, तो वह फ़ुल रिज़ॉल्यूशन में इमेज सबमिट कर सकता है.

recommendedImageExtent के XrExtent2Di :: width और XrExtent2Di :: height, हमेशा पॉज़िटिव इंटीजर होने चाहिए. साथ ही, ये स्पेशल कंटेनर के प्राइमरी व्यू कॉन्फ़िगरेशन के लिए, XrViewConfigurationView के XrViewConfigurationView :: recommendedImageRectWidth और XrViewConfigurationView :: recommendedImageRectHeight से कम या उनके बराबर होने चाहिए. किसी ऐप्लिकेशन को सिर्फ़ recommendedImageExtent में बदलाव होने की वजह से, स्वैपचेन को फिर से नहीं बनाना चाहिए. ऐसा इसलिए, क्योंकि यह ऐप्लिकेशन के लिए एक डाइनैमिक हिंट है. इससे यह तय होता है कि सबमिट की गई किसी भी फ़ुल रिज़ॉल्यूशन कंपोज़िशन लेयर के XrSwapchainSubImage में, XrSwapchainSubImage :: imageRect का इस्तेमाल किया जाए. साथ ही, हर फ़्रेम को बदला जा सकता है.

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

XrSpatialContainerViewStateEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_container_self_rendering एक्सटेंशन को चालू करना ज़रूरी है
type की वैल्यू XR_TYPE_SPATIAL_CONTAINER_VIEW_STATE_EXT होनी चाहिए
next NULL या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
viewStateFlags, XrViewStateFlagBits वैल्यू का मान्य कॉम्बिनेशन होना ज़रूरी है
viewStateFlags must not be 0
viewConfigurationType की वैल्यू, XrViewConfigurationType की मान्य वैल्यू होनी चाहिए

रेफ़रंस स्पेस देखना

व्यू रेफ़रंस स्पेस में कोई बदलाव नहीं हुआ है, क्योंकि यह OpenXR कोर में है. इसे रेंडरिंग के लिए नहीं बनाया गया है.

xrEndFrame के ज़रिए लेयर सबमिट करना

स्पेशल कंटेनर रेंडर करने के लिए, ऐप्लिकेशन को xrEndFrame को उनके संबंधित स्पेशल कंटेनर से जुड़ी लेयर की सूची देनी होगी. यह काम XrSpatialContainerLayerFrameEndInfoEXT स्ट्रक्चर की मदद से किया जाता है.

typedef struct XrSpatialContainerLayerFrameEndInfoEXT {
    XrStructureType                      type;
    const void*                          next;
    uint32_t                             containerLayerCount;
    const XrSpatialContainerLayerEXT*    containerLayers;
} XrSpatialContainerLayerFrameEndInfoEXT;

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

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

containerLayers कलेक्शन में, ऐक्टिव रेंडर सेट में मौजूद हर स्पेशल कंटेनर के लिए एक XrSpatialContainerLayerEXT होता है. ये कंटेनर, हर सेशन के हिसाब से xrBeginSpatialContainerRenderingEXT और xrEndSpatialContainerRenderingEXT मैनेज करते हैं. हर XrSpatialContainerLayerEXT में, दिए गए स्पेशल कंटेनर से जुड़े XrCompositionLayerBaseHeader पॉइंटर की सूची होती है. रनटाइम, कंपोज़िट कंटेनर को किसी भी क्रम में जोड़ सकते हैं. यह क्रम, containerLayers के क्रम से अलग हो सकता है. उदाहरण के लिए, रनटाइम, उपयोगकर्ता के हिसाब से गहराई के आधार पर कंटेनर को कंपोज़िट कर सकते हैं. साथ ही, स्पेशल कंटेनर को बैकग्राउंड लेयर के तौर पर इस्तेमाल कर सकते हैं या स्पेशल कंटेनर को 'पिन' कर सकते हैं, ताकि वह अपनी गहराई के बावजूद हमेशा सबसे ऊपर रहे. रनटाइम, बाउंडेड या इमर्सिव मोड में स्पेशल कंटेनर के लिए अलग-अलग रणनीतियों का इस्तेमाल करके, लेयर को कंपोज़िट कर सकते हैं. उदाहरण के लिए, रनटाइम हर बाउंडेड स्पेशल कंटेनर की कंपोज़िशन लेयर को एक स्टीरियो क्वाड लेयर में पहले से कंपोज़ कर सकते हैं. इसे कंपोज़िशन के दूसरे चरण में अन्य सभी कंटेनर के साथ जोड़ा जाता है.

XrFrameEndInfo :: displayTime और XrFrameEndInfo :: environmentBlendMode को XrSpatialContainerLayerFrameEndInfoEXT में दिए गए सभी स्पेशल कंटेनर पर लागू किया जाएगा.

जब इस स्ट्रक्चर को XrFrameEndInfo से जोड़कर xrEndFrame को पास किया जाता है, तो चालू रेंडर सेट के आधार पर गड़बड़ी के ये अतिरिक्त मामले जुड़ जाते हैं:

अगर किसी स्पेशल कंटेनर को containerLayers के एक से ज़्यादा एलिमेंट से रेफ़र किया जाता है, तो रनटाइम को XR_ERROR_SPATIAL_CONTAINER_DUPLICATE_EXT दिखाना चाहिए .
अगर ऐक्टिव रेंडर सेट में मौजूद किसी स्पेशल कंटेनर को containerLayers के किसी एलिमेंट से रेफ़रंस नहीं दिया गया है, तो रनटाइम को XR_ERROR_SPATIAL_CONTAINER_MISSING_EXT दिखाना चाहिए .
अगर containerLayers से रेफ़र किया गया कोई स्पेशल कंटेनर, चालू रेंडर सेट का सदस्य नहीं है, तो रनटाइम को XR_ERROR_SPATIAL_CONTAINER_NOT_RENDERING_EXT दिखाना चाहिए .

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

ऊपर बताई गई किसी भी गड़बड़ी के मामले में, रनटाइम को किसी भी स्पेशल कंटेनर के लिए कोई कॉन्टेंट रेंडर नहीं करना चाहिए.

अगर ऐक्टिव रेंडर सेट में कोई भी स्पेशल कंटेनर नहीं है, तो कोई ऐप्लिकेशन xrEndFrame को तब तक कॉल कर सकता है, जब तक वह कोई कंपोज़िशन लेयर सबमिट नहीं कर रहा है.

ध्यान दें कि अलग-अलग स्वैपचेन को मान्य स्ट्रक्चर में लेयर के ज़रिए, एक से ज़्यादा कंटेनर के लिए सबमिट किया जा सकता है. उदाहरण के लिए, एक ही स्वैपचेन के ज़रिए रेंडर की गई क्वाड लेयर को एक से ज़्यादा स्पेशल कंटेनर में सबमिट किया जा सकता है. इस मामले को अन्य रेंडरिंग के साथ एक जैसा हैंडल किया जाता है: रनटाइम को ऐसे सभी स्पेशल कंटेनर में क्वाड को रेंडर करना चाहिए.

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

XrSpatialContainerLayerFrameEndInfoEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_container_self_rendering एक्सटेंशन को चालू करना ज़रूरी है
type की वैल्यू XR_TYPE_SPATIAL_CONTAINER_LAYER_FRAME_END_INFO_EXT होनी चाहिए
next NULL या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
containerLayers को containerLayerCount मान्य XrSpatialContainerLayerEXT स्ट्रक्चर के कलेक्शन का पॉइंटर होना चाहिए
containerLayerCount पैरामीटर की वैल्यू, 0 से ज़्यादा होनी चाहिए

XrSpatialContainerLayerEXT स्ट्रक्चर, स्टैंडर्ड कंपोज़िशन लेयर को ग्रुप करता है और उन्हें किसी खास स्पेशल कंटेनर से जोड़ता है.

typedef struct XrSpatialContainerLayerEXT {
    XrStructureType                               type;
    const void*                                   next;
    XrSpatialContainerEXT                         spatialContainer;
    XrBool32                                      retainPreviousSubmission;
    uint32_t                                      layerCount;
    const XrCompositionLayerBaseHeader* const*    layers;
} XrSpatialContainerLayerEXT;

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

type, इस स्ट्रक्चर का XrStructureType है.
next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
spatialContainer, XrSpatialContainerEXT है, जो टारगेट कंटेनर की पहचान करता है.
retainPreviousSubmission एक XrBool32 है. अगर XR_TRUE , तो रनटाइम इस स्पेशल कंटेनर के लिए सबमिट किए गए आखिरी फ़्रेम को सेव रखेगा.
layerCount, layers कलेक्शन में कंपोज़िशन लेयर की संख्या है.
layers, XrCompositionLayerBaseHeader पॉइंटर के कलेक्शन का पॉइंटर है.

जब retainPreviousSubmission, XR_TRUE हो, तो रनटाइम को कंपोज़िशन लेयर और स्वैपचेन इमेज के कॉन्टेंट का फिर से इस्तेमाल करना चाहिए. यह कॉन्टेंट, सबसे हाल ही में किए गए xrEndFrame कॉल के दौरान लैच किया गया था, जहां retainPreviousSubmission, XR_FALSE था. रेंडर किए गए आउटपुट में, सेव की गई लेयर को इस्तेमाल करने वाले स्वैपचेन में किए गए कोई भी बदलाव नहीं दिखने चाहिए.

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

स्पेशल कंटेनर को "खाली करने" का मतलब है कि उसमें मौजूद सारा कॉन्टेंट हटा दिया गया है. इस वजह से, मौजूदा फ़्रेम में उस कंटेनर के लिए कुछ भी रेंडर नहीं किया जाता. रनटाइम को इसे कंटेनर के अंदर मौजूद हर पिक्सल के लिए, पारदर्शी ब्लैक (सभी बिट 0) सबमिट करने वाले ऐप्लिकेशन के बराबर मानना चाहिए. स्पेशल कंटेनर को "बरकरार रखने" का मतलब है कि रनटाइम, उस कंटेनर के लिए सबमिट किए गए लेयर के सबसे हाल के सेट को दिखाता रहेगा.

हर स्पेशल कंटेनर के लिए, ऐप्लिकेशन यह तय कर सकता है कि नई लेयर सबमिट करनी हैं, पिछली सबमिशन को बनाए रखना है या स्पेशल कंटेनर को खाली करना है:

नई लेयर सबमिट करने के लिए, ऐप्लिकेशन शून्य के अलावा कोई और layerCount और मान्य layers पॉइंटर उपलब्ध कराता है.
स्पेशल कंटेनर को खाली करने के लिए, उसकी एंट्री के लिए layerCount 0 होना चाहिए और retainPreviousSubmission XR_FALSE होना चाहिए .
सबमिट की गई आखिरी लेयर और स्वैपचेन इमेज को बनाए रखने के लिए, इसकी एंट्री के लिए layerCount 0 और retainPreviousSubmission XR_TRUE होना चाहिए.

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

अगर retainPreviousSubmission की वैल्यू XR_TRUE है और layerCount की वैल्यू 0 नहीं है, तो रनटाइम में XR_ERROR_VALIDATION_FAILURE ज़रूर दिखना चाहिए.

अगर XrSpatialContainerCompositionLayerViewConfigurationEXT, किसी स्पेशल कंटेनर के हिस्से XrCompositionLayerProjection से नहीं जुड़ा है, तो रनटाइम को XR_ERROR_VALIDATION_FAILURE दिखाना चाहिए . यह स्ट्रक्चर सिर्फ़ XrCompositionLayerProjection लेयर पर लागू होता है. अगर इसे अन्य लेयर टाइप (जैसे, क्वाड या सिलिंडर लेयर) के साथ जोड़ा गया है, तो रनटाइम को XR_ERROR_VALIDATION_FAILURE दिखाना चाहिए .

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

XrSpatialContainerLayerEXT का इस्तेमाल करने से पहले, XR_EXT_spatial_container_self_rendering एक्सटेंशन चालू करना ज़रूरी है
type की वैल्यू XR_TYPE_SPATIAL_CONTAINER_LAYER_EXT होनी चाहिए
next को NULL या स्ट्रक्चर चेन में अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए. यह भी देखें: XrSpatialContainerLayerVolumeClippingEXT
spatialContainer एक मान्य XrSpatialContainerEXT हैंडल होना चाहिए
अगर layerCount की वैल्यू 0 नहीं है, तो layers को layerCount मान्य XrCompositionLayerBaseHeader -आधारित स्ट्रक्चर के कलेक्शन का पॉइंटर होना चाहिए. यह भी देखें: XrCompositionLayerCubeKHR , XrCompositionLayerCylinderKHR , XrCompositionLayerEquirect2KHR , XrCompositionLayerEquirectKHR , XrCompositionLayerPassthroughANDROID , XrCompositionLayerPassthroughFB , XrCompositionLayerPassthroughHTC , XrCompositionLayerProjection , XrCompositionLayerQuad

प्रोजेक्शन लेयर के लिए व्यू कॉन्फ़िगरेशन तय करना

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

typedef struct XrSpatialContainerCompositionLayerViewConfigurationEXT {
    XrStructureType            type;
    const void*                next;
    XrViewConfigurationType    viewConfigurationType;
} XrSpatialContainerCompositionLayerViewConfigurationEXT;

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

type, इस स्ट्रक्चर का XrStructureType है.
next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
viewConfigurationType, XrViewConfigurationType है. इसका इस्तेमाल, XrCompositionLayerProjection को रेंडर करने के लिए किया गया था.

स्पेशल कंटेनर के लिए XrCompositionLayerProjection सबमिट करते समय, ऐप्लिकेशन को यह बताना ज़रूरी है कि लेयर को रेंडर करने के लिए, किस व्यू कॉन्फ़िगरेशन का इस्तेमाल किया गया था. ऐसा करना ज़रूरी है, क्योंकि ऐप्लिकेशन हर फ़्रेम को रेंडर करने के लिए, स्पेशल कंटेनर के प्राइमरी व्यू कॉन्फ़िगरेशन या रनटाइम के सुझाए गए डिकेड व्यू कॉन्फ़िगरेशन (अगर कोई हो) को चुन सकता है.

XrSpatialContainerCompositionLayerViewConfigurationEXT को चेन करने पर, ऐप्लिकेशन को यह पक्का करना चाहिए कि XrCompositionLayerProjection :: viewCount, चेन किए गए स्ट्रक्चर में बताए गए XrViewConfigurationType के लिए मान्य व्यू की संख्या हो. चेन किए गए स्ट्रक्चर में बताया गया viewConfigurationType, XrSpatialContainerBeginInfoEXT :: primaryViewConfigurationType होना ज़रूरी है. यह कंटेनर शुरू करते समय बताया गया था. इसके अलावा, यह रनटाइम के ज़रिए XrSpatialContainerViewStateEXT में दिखाया गया, डिके व्यू कॉन्फ़िगरेशन टाइप या एक्सटेंशन के ज़रिए चालू की गई अन्य वैल्यू होनी चाहिए.

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

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

पिक्सल क्लिपिंग का व्यवहार

ऐप्लिकेशन को रनटाइम को यह जानकारी देनी चाहिए कि वे कंपोज़िशन लेयर सबमिट करते समय, XrSpatialContainerLayerVolumeClippingEXT को चेन करके, स्पेशल कंटेनर की सीमाओं के बाहर पिक्सल रेंडर करते हैं या नहीं.

typedef struct XrSpatialContainerLayerVolumeClippingEXT {
    XrStructureType                        type;
    const void*                            next;
    XrSpatialContainerVolumeClippingEXT    volumeClipping;
} XrSpatialContainerLayerVolumeClippingEXT;

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

type, इस स्ट्रक्चर का XrStructureType है.
next, NULL है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर है.
volumeClipping, XrSpatialContainerVolumeClippingEXT है, जिसे ऐप्लिकेशन ने लागू किया है.

इस स्ट्रक्चर से यह पता चलता है कि ऐप्लिकेशन, स्पेशल कंटेनर की सीमाओं के बाहर पिक्सल रेंडर करता है या नहीं. जब कोई स्पेशल कंटेनर इमर्सिव मोड में होता है, तो इस हिंट का कोई मतलब नहीं होता. ऐसा इसलिए, क्योंकि इसकी सीमाएं अनंत होती हैं.

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

रनटाइम को 2D पिक्सल की सीमाओं से बाहर की स्वैपचेन इमेज से पिक्सल को ज़रूर खारिज करना चाहिए. हालांकि, रनटाइम को उन पिक्सल को खारिज नहीं करना चाहिए जो 2D पिक्सल की सीमाओं के अंदर हैं, लेकिन 3D वॉल्यूम की सीमाओं से बाहर हैं. स्टीरियो इफ़ेक्ट का इस्तेमाल किया जा सकता है. इसमें कॉन्टेंट, कंटेनर के 3D वॉल्यूम की सीमाओं से आगे या सामने तक फैला हुआ दिखता है. ऐप्लिकेशन, बाउंडेड स्पेशल कंटेनर के 3D वॉल्यूम की सीमाओं के बाहर के पिक्सल को खारिज कर सकते हैं, ताकि डेप्थ पैराडॉक्स को कम किया जा सके. साथ ही, उन्हें इस आधार पर volumeClipping सेट करना चाहिए कि वे ऐसा कैसे करते हैं. डेप्थ पैराडॉक्स की वजह से, अक्सर आंखों पर ज़ोर पड़ता है और उपयोगकर्ता को परेशानी होती है.

रनटाइम, volumeClipping का इस्तेमाल कर सकते हैं, ताकि वे किसी खास स्पेशल कंटेनर को दिखाने के तरीके में बदलाव कर सकें. उदाहरण के लिए, XR_SPATIAL_CONTAINER_VOLUME_CLIPPING_STRICT_EXT पर सेट होने पर, रनटाइम 3D वॉल्यूम बाउंड के पीछे के हिस्से को रेंडर कर सकता है. इससे डेप्थ पैराडॉक्स की समस्या हो सकती है. ऐसा तब होता है, जब स्पेशल कंटेनर, कंटेनर के 3D वॉल्यूम बाउंड के पीछे पिक्सल ड्रॉ करता है.

आने वाले समय में, एक्सटेंशन की मदद से 3D वॉल्यूम बाउंड के आधार पर क्लिपिंग की जा सकती है. हालांकि, इसके लिए गहराई की जानकारी सबमिट करनी होगी.

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

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

नए स्ट्रक्चर

XrSpatialContainerBeginInfoEXT
XrSpatialContainerEndInfoEXT
XrSpatialContainerLayerEXT
XrSpatialContainerViewLocateInfoEXT
XrSpatialContainerViewStateEXT
XrSpatialContainerViewsLocateInfoEXT
XrCompositionLayerProjection को एक्सटेंड करना :
- XrSpatialContainerCompositionLayerViewConfigurationEXT
XrFrameEndInfo को एक्सटेंड करना :
- XrSpatialContainerLayerFrameEndInfoEXT
XrSpatialContainerLayerEXT को एक्सटेंड करना :
- XrSpatialContainerLayerVolumeClippingEXT

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

XR_EXT_SPATIAL_CONTAINER_SELF_RENDERING_EXTENSION_NAME
XR_EXT_spatial_container_self_rendering_SPEC_VERSION
XrResult को एक्सटेंड करना :
- XR_ERROR_SPATIAL_CONTAINER_DUPLICATE_EXT
- XR_ERROR_SPATIAL_CONTAINER_GRAPHICS_PRESENTATION_MISSING_EXT
- XR_ERROR_SPATIAL_CONTAINER_IS_RENDERING_EXT
- XR_ERROR_SPATIAL_CONTAINER_MISSING_EXT
- XR_ERROR_SPATIAL_CONTAINER_NOT_RENDERING_EXT
XrSpatialContainerGraphicsPresentationEXT को एक्सटेंड करना :
- XR_SPATIAL_CONTAINER_GRAPHICS_PRESENTATION_SELF_RENDERING_EXT
XrStructureType को एक्सटेंड करना :
- XR_TYPE_SPATIAL_CONTAINER_BEGIN_INFO_EXT
- XR_TYPE_SPATIAL_CONTAINER_COMPOSITION_LAYER_VIEW_CONFIGURATION_EXT
- XR_TYPE_SPATIAL_CONTAINER_END_INFO_EXT
- XR_TYPE_SPATIAL_CONTAINER_LAYER_EXT
- XR_TYPE_SPATIAL_CONTAINER_LAYER_FRAME_END_INFO_EXT
- XR_TYPE_SPATIAL_CONTAINER_LAYER_VOLUME_CLIPPING_EXT
- XR_TYPE_SPATIAL_CONTAINER_VIEWS_LOCATE_INFO_EXT
- XR_TYPE_SPATIAL_CONTAINER_VIEW_LOCATE_INFO_EXT
- XR_TYPE_SPATIAL_CONTAINER_VIEW_STATE_EXT

कोड नमूने

// Example: Complete lifecycle, view location, and frame submission for spatial containers
PFN_xrBeginSpatialContainerRenderingEXT xrBeginSpatialContainerRenderingEXT; // previously initialized
PFN_xrEndSpatialContainerRenderingEXT xrEndSpatialContainerRenderingEXT; // previously initialized
PFN_xrLocateSpatialContainerViewsEXT xrLocateSpatialContainerViewsEXT; // previously initialized

XrSession session; // previously initialized

// We want to update this container
XrSpatialContainerEXT containerA; // previously initialized with XR_SPATIAL_CONTAINER_GRAPHICS_PRESENTATION_SELF_RENDERING_EXT
XrSpace containerASpace; // previously initialized

// We want to retain this container
XrSpatialContainerEXT containerB; // previously initialized with XR_SPATIAL_CONTAINER_GRAPHICS_PRESENTATION_SELF_RENDERING_EXT
XrSpace containerBSpace; // previously initialized

// 1. Add to active render set when the app is ready to start submitting layers
XrSpatialContainerBeginInfoEXT beginInfoA {
  .type = XR_TYPE_SPATIAL_CONTAINER_BEGIN_INFO_EXT,
  .spatialContainer = containerA,
  .primaryViewConfigurationType = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO,
};
CHK_XR(xrBeginSpatialContainerRenderingEXT(session, &beginInfoA));

XrSpatialContainerBeginInfoEXT beginInfoB {
  .type = XR_TYPE_SPATIAL_CONTAINER_BEGIN_INFO_EXT,
  .spatialContainer = containerB,
  .primaryViewConfigurationType = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO,
};
CHK_XR(xrBeginSpatialContainerRenderingEXT(session, &beginInfoB));

// ... Frame Loop ...


XrTime displayTime; // returned from xrWaitFrame

const std::vector<XrSpatialContainerEXT> containers = {containerA, containerB};
const std::vector<XrSpace> containerSpaces = {containerASpace, containerBSpace};
uint32_t containerCount = static_cast<uint32_t>(containers.size());

// 2. Setup individual locate info for each container
std::vector<XrSpatialContainerViewLocateInfoEXT> containerLocateInfos(containerCount, {
  .type = XR_TYPE_SPATIAL_CONTAINER_VIEW_LOCATE_INFO_EXT,
});

for (uint32_t i = 0; i < containerCount; ++i) {
    containerLocateInfos[i].viewConfigurationType = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO;
    containerLocateInfos[i].space = containerSpaces[i]; // Recommended to use container's own space
    containerLocateInfos[i].spatialContainer = containers[i];
}

// Setup bulk locate info
XrSpatialContainerViewsLocateInfoEXT locateInfo {
  .type = XR_TYPE_SPATIAL_CONTAINER_VIEWS_LOCATE_INFO_EXT,
  .displayTime = displayTime,
  .viewLocateInfoCount = containerCount,
  .viewLocateInfos = containerLocateInfos.data(),
};

// Prepare states to be populated by the runtime
std::vector<XrSpatialContainerViewStateEXT> viewStates(containerCount, {
  .type = XR_TYPE_SPATIAL_CONTAINER_VIEW_STATE_EXT,
});

// Call the dedicated locate views function
// We know the required view count is 2 per container for STEREO
const uint32_t viewsPerConfig = 2;
uint32_t totalViewCount = containerCount * viewsPerConfig;
std::vector<XrView> views(totalViewCount, {.type = XR_TYPE_VIEW});

CHK_XR(xrLocateSpatialContainerViewsEXT(session, &locateInfo, containerCount, viewStates.data(), totalViewCount, views.data()));

// Process results
for (uint32_t i = 0; i < containerCount; ++i) {
    XrBool32 shouldSubmitLayers = viewStates[i].shouldSubmitLayers;
    XrExtent2Di recommendedImageExtent = viewStates[i].recommendedImageExtent;
    XrViewConfigurationType viewConfigurationType = viewStates[i].viewConfigurationType;
    bool isDecayedToMono = (viewConfigurationType == XR_VIEW_CONFIGURATION_TYPE_PRIMARY_MONO);
    if (shouldSubmitLayers) {
        // App is expected to also verify viewStates[i].viewStateFlags has valid orientation/position bits before rendering
        XrView& leftView = views[i * viewsPerConfig];
        XrView& rightView = views[i * viewsPerConfig + 1];
        // If isDecayedToMono is true, left and right will be identical.
    } else {
        // Skip layer submission but retain previous submission when calling
        // xrEndFrame.
    }
}

// 3. Setup projection layer for container A
XrCompositionLayerProjection projectionLayer = {.type = XR_TYPE_COMPOSITION_LAYER_PROJECTION};
// ... standard projection layer setup (space, viewCount, views, etc.) ...

// Specify which view configuration was used to render this specific layer
XrSpatialContainerCompositionLayerViewConfigurationEXT containerViewConfig {
  .type = XR_TYPE_SPATIAL_CONTAINER_COMPOSITION_LAYER_VIEW_CONFIGURATION_EXT,
  // Even if the runtime decayed to MONO, we indicate what we actually rendered
  .viewConfigurationType = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO,
};

// Chain it to the projection layer
projectionLayer.next = &containerViewConfig;
const XrCompositionLayerBaseHeader* layersA[1] = {reinterpret_cast<const XrCompositionLayerBaseHeader*>(&projectionLayer)};

// Note: In a real app, you are required to submit ALL active containers in the render set.

XrSpatialContainerLayerVolumeClippingEXT containerClippingA = {
  .type = XR_TYPE_SPATIAL_CONTAINER_LAYER_VOLUME_CLIPPING_EXT,
  // Set volumeClipping appropriately for the rendering done.
  .volumeClipping = XR_SPATIAL_CONTAINER_VOLUME_CLIPPING_STRICT_EXT,
};

// Setup container A (Update with new pixels)
XrSpatialContainerLayerEXT containerLayerA {
  .type = XR_TYPE_SPATIAL_CONTAINER_LAYER_EXT,
  .next = &containerClippingA,
  .spatialContainer = containerA,
  .retainPreviousSubmission = XR_FALSE,
  .layerCount = 1,
  .layers = layersA,
};

XrSpatialContainerLayerVolumeClippingEXT containerClippingB {
  .type = XR_TYPE_SPATIAL_CONTAINER_LAYER_VOLUME_CLIPPING_EXT,
  // Set volumeClipping appropriately for the rendering done.
  .volumeClipping = XR_SPATIAL_CONTAINER_VOLUME_CLIPPING_STRICT_EXT,
};

// Setup container B (Explicitly retain previous frame)
XrSpatialContainerLayerEXT containerLayerB {
  .type = XR_TYPE_SPATIAL_CONTAINER_LAYER_EXT,
  .next = &containerClippingB,
  .spatialContainer = containerB,
  .retainPreviousSubmission = XR_TRUE,
  .layerCount = 0, // Required to be 0 when retaining
  .layers = nullptr,
};

// Aggregate all container layers
XrSpatialContainerLayerEXT containerLayers[] = { containerLayerA, containerLayerB };

XrSpatialContainerLayerFrameEndInfoEXT spatialEndInfo {
  .type = XR_TYPE_SPATIAL_CONTAINER_LAYER_FRAME_END_INFO_EXT,
  .containerLayerCount = 2, // Must equal the number of active containers
  .containerLayers = containerLayers,
};

XrFrameEndInfo frameEndInfo {
  .type = XR_TYPE_FRAME_END_INFO,
  .next = &spatialEndInfo,
  .displayTime = displayTime,
  .environmentBlendMode = XR_ENVIRONMENT_BLEND_MODE_ALPHA_BLEND,
  .layerCount = 0, // MANDATORY: Must be 0 for self rendering extension
};

CHK_XR(xrEndFrame(session, &frameEndInfo));

// ... End Frame Loop ...

// 4. Remove from active render set when the container is destroyed or no longer needs rendering
XrSpatialContainerEndInfoEXT endInfoA {
  .type = XR_TYPE_SPATIAL_CONTAINER_END_INFO_EXT,
  .spatialContainer = containerA,
};
CHK_XR(xrEndSpatialContainerRenderingEXT(session, &endInfoA));

XrSpatialContainerEndInfoEXT endInfoB {
  .type = XR_TYPE_SPATIAL_CONTAINER_END_INFO_EXT,
  .spatialContainer = containerB,
};
CHK_XR(xrEndSpatialContainerRenderingEXT(session, &endInfoB));

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

पहला बदलाव, 06-08-2026 (लैकलन फ़ोर्ड)
- एक्सटेंशन का शुरुआती ब्यौरा