XR_ANDROID_light_estimation_cubemap

Name String

XR_ANDROID_light_estimation_cubemap

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

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

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

722

बदलाव

1

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

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

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

XR_ANDROID_light_estimation

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

2025-08-06

आईपी स्टेटस

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

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

सैलार ख़ान, Google
स्कॉट चुंग, Google
जेरेड फ़ाइंडर, Google
स्पेंसर क्विन, Google
लेवाना चेन, Google
निहाव जैन, Google
जर्गन स्टर्म, Google

खास जानकारी

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

नोट

लाइट का अनुमान लगाने वाले डेटा को पाने का तरीका, बुनियादी एक्सटेंशन की तरह ही होता है. हालांकि, लाइट का अनुमान लगाने वाले हैंडल को बनाते समय, XrCubemapLightEstimatorCreateInfoANDROID को XrLightEstimatorCreateInfoANDROID से जोड़ना होता है.

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

typedef struct XrSystemCubemapLightEstimationPropertiesANDROID {
    XrStructureType    type;
    void*              next;
    XrBool32           supportsCubemapLightEstimation;
} XrSystemCubemapLightEstimationPropertiesANDROID;

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

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

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

अगर रनटाइम, supportsCubemapLightEstimation के लिए XR_FALSE दिखाता है और XrCubemapLightEstimatorCreateInfoANDROID को XrLightEstimatorCreateInfoANDROID से लिंक किया गया है, तो रनटाइम को xrCreateLightEstimatorANDROID से XR_ERROR_FEATURE_UNSUPPORTED दिखाना ज़रूरी है .

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

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

साथ काम करने वाले क्यूबमैप रिज़ॉल्यूशन पाना

XrResult xrEnumerateCubemapLightingResolutionsANDROID(
    XrInstance                                  instance,
    XrSystemId                                  systemId,
    uint32_t                                    resolutionCapacityInput,
    uint32_t*                                   resolutionCountOutput,
    uint32_t*                                   resolutions);

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

• instance पहले से बनाया गया XrInstance है.
• systemId वह XrSystemId है जिसे xrGetSystem ने पहले फ़ेच किया था. इसके लिए, काम करने वाले क्यूबमैप रिज़ॉल्यूशन पाने हैं.
• resolutionCapacityInput एक uint32_t है. इससे पता चलता है कि resolutions कलेक्शन में ज़्यादा से ज़्यादा कितने एलिमेंट स्टोर किए जा सकते हैं.
• resolutionCountOutput, uint32_t का पॉइंटर है. इसे रनटाइम सेट करता है. इससे पता चलता है कि रनटाइम ने resolutions ऐरे में कितने एलिमेंट लिखे हैं.
• resolutions, uint32_t का एक ऐरे है. इसे रनटाइम के दौरान, काम करने वाले क्यूबमैप रिज़ॉल्यूशन के साथ पॉप्युलेट किया जाता है.

क्यूबमैप रिज़ॉल्यूशन से, क्यूबमैप के हर फ़ेस की चौड़ाई और ऊंचाई का पता चलता है. यह जानकारी पिक्सल में होती है. दो कॉल वाला मुहावरा इसके बाद, ऐप्लिकेशन XrCubemapLightEstimatorCreateInfoANDROID :: cubemapResolution में दिए गए, काम करने वाले किसी एक रिज़ॉल्यूशन का इस्तेमाल कर सकता है. ऐसा लाइट एस्टिमेटर हैंडल बनाते समय किया जाता है. ऐप्लिकेशन को चुने गए रिज़ॉल्यूशन और कलर फ़ॉर्मैट के आधार पर, XrCubemapLightingDataANDROID के इमेज बफ़र सदस्यों के लिए सही मेमोरी ज़रूर असाइन करनी चाहिए.

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

• xrEnumerateCubemapLightingResolutionsANDROID को कॉल करने से पहले, XR_ANDROID_light_estimation_cubemap एक्सटेंशन को चालू करना ज़रूरी है
• instance, XrInstance का मान्य हैंडल होना चाहिए
• resolutionCountOutput, uint32_t वैल्यू का पॉइंटर होना चाहिए
• अगर resolutionCapacityInput 0 नहीं है, तो resolutions, resolutionCapacityInput uint32_t वैल्यू की एक सरणी का पॉइंटर होना चाहिए

रिटर्न कोड

सफल

• 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_SYSTEM_INVALID
• XR_ERROR_VALIDATION_FAILURE

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

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

typedef enum XrCubemapLightingColorFormatANDROID {
    XR_CUBEMAP_LIGHTING_COLOR_FORMAT_R32G32B32_SFLOAT_ANDROID = 1,
    XR_CUBEMAP_LIGHTING_COLOR_FORMAT_R32G32B32A32_SFLOAT_ANDROID = 2,
    XR_CUBEMAP_LIGHTING_COLOR_FORMAT_R16G16B16A16_SFLOAT_ANDROID = 3,
    XR_CUBEMAP_LIGHTING_COLOR_FORMAT_MAX_ENUM_ANDROID = 0x7FFFFFFF
} XrCubemapLightingColorFormatANDROID;

इन एनम का मतलब यह है:

Enum की जानकारी

XR_CUBEMAP_LIGHTING_COLOR_FORMAT_R32G32B32_SFLOAT_ANDROID

यह तीन चैनलों वाला कलर फ़ॉर्मैट है. इसमें हर चैनल, 32-बिट फ़्लोटिंग पॉइंट वैल्यू होता है.

XR_CUBEMAP_LIGHTING_COLOR_FORMAT_R32G32B32A32_SFLOAT_ANDROID

यह चार चैनलों वाला कलर फ़ॉर्मैट है. इसमें हर चैनल, 32-बिट फ़्लोटिंग पॉइंट वैल्यू होता है.

XR_CUBEMAP_LIGHTING_COLOR_FORMAT_R16G16B16A16_SFLOAT_ANDROID

यह चार चैनलों वाला कलर फ़ॉर्मैट है. इसमें हर चैनल, 16-बिट फ़्लोटिंग पॉइंट वैल्यू होता है.

XrResult xrEnumerateCubemapLightingColorFormatsANDROID(
    XrInstance                                  instance,
    XrSystemId                                  systemId,
    uint32_t                                    colorFormatCapacityInput,
    uint32_t*                                   colorFormatCountOutput,
    XrCubemapLightingColorFormatANDROID*        colorFormats);

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

• instance पहले से बनाया गया XrInstance है.
• systemId वह XrSystemId है जिसे xrGetSystem ने पहले फ़ेच किया था. इसके लिए, काम करने वाले क्यूबमैप रिज़ॉल्यूशन पाने हैं.
• colorFormatCapacityInput एक uint32_t है. इससे पता चलता है कि colorFormats कलेक्शन में ज़्यादा से ज़्यादा कितने एलिमेंट स्टोर किए जा सकते हैं.
• colorFormatCountOutput, uint32_t का पॉइंटर है. इसे रनटाइम सेट करता है. इससे पता चलता है कि रनटाइम ने colorFormats ऐरे में कितने एलिमेंट लिखे हैं.
• colorFormats, XrCubemapLightingColorFormatANDROID का एक ऐरे है. इसे रनटाइम के दौरान, काम करने वाले क्यूबमैप कलर फ़ॉर्मैट से भरा जाता है.

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

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

• xrEnumerateCubemapLightingColorFormatsANDROID को कॉल करने से पहले, XR_ANDROID_light_estimation_cubemap एक्सटेंशन को चालू करना ज़रूरी है
• instance, XrInstance का मान्य हैंडल होना चाहिए
• colorFormatCountOutput, uint32_t वैल्यू का पॉइंटर होना चाहिए
• अगर colorFormatCapacityInput, 0 नहीं है, तो colorFormats, colorFormatCapacityInput XrCubemapLightingColorFormatANDROID वैल्यू के ऐरे का पॉइंटर होना चाहिए

रिटर्न कोड

सफल

• 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_SYSTEM_INVALID
• XR_ERROR_VALIDATION_FAILURE

क्यूबमैप लाइट का अनुमान लगाने वाले हैंडल को बनाना

typedef struct XrCubemapLightEstimatorCreateInfoANDROID {
    XrStructureType                        type;
    const void*                            next;
    uint32_t                               cubemapResolution;
    XrCubemapLightingColorFormatANDROID    colorFormat;
    XrBool32                               reproject;
} XrCubemapLightEstimatorCreateInfoANDROID;

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

• type इस स्ट्रक्चर का XrStructureType है.
• next, NULL होता है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर होता है.
• cubemapResolution एक uint32_t है. इससे यह पता चलता है कि क्यूबमैप लाइटिंग के लिए किस रिज़ॉल्यूशन का इस्तेमाल करना है.
• colorFormat एक XrCubemapLightingColorFormatANDROID है. यह इस्तेमाल किए जाने वाले क्यूबमैप लाइटिंग डेटा के कलर फ़ॉर्मैट के बारे में बताता है.
• reproject एक XrBool32 है. इससे पता चलता है कि क्यूबमैप लाइटिंग को ऐप्लिकेशन के बेस स्पेस में फिर से प्रोजेक्ट किया जाना चाहिए या नहीं.

XrCubemapLightEstimatorCreateInfoANDROID स्ट्रक्चर में, XrLightEstimatorANDROID हैंडल बनाने के लिए ज़रूरी जानकारी होती है. इस हैंडल की मदद से, क्यूबमैप लाइटिंग का अनुमान लगाया जा सकता है. XrCubemapLightEstimatorCreateInfoANDROID :: cubemapResolution सदस्य को, xrEnumerateCubemapLightingResolutionsANDROID से मिले रिज़ॉल्यूशन में से किसी एक पर सेट किया जाना चाहिए . XrCubemapLightEstimatorCreateInfoANDROID :: colorFormat सदस्य को xrEnumerateCubemapLightingColorFormatsANDROID से मिले रंग के फ़ॉर्मैट में से किसी एक पर सेट किया जाना ज़रूरी है . अगर ऐप्लिकेशन, रिज़ॉल्यूशन को ऐसे रिज़ॉल्यूशन पर सेट नहीं करता है जो काम करता है या कलर फ़ॉर्मैट को ऐसे कलर फ़ॉर्मैट पर सेट नहीं करता है जो काम करता है, तो रनटाइम को xrCreateLightEstimatorANDROID से XR_ERROR_FEATURE_UNSUPPORTED ज़रूर दिखाना चाहिए .

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

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

क्यूबमैप लाइट के अनुमान

typedef struct XrCubemapLightingDataANDROID {
    XrStructureType                type;
    void*                          next;
    XrLightEstimateStateANDROID    state;
    uint32_t                       imageBufferSize;
    uint8_t*                       imageBufferRight;
    uint8_t*                       imageBufferLeft;
    uint8_t*                       imageBufferTop;
    uint8_t*                       imageBufferBottom;
    uint8_t*                       imageBufferFront;
    uint8_t*                       imageBufferBack;
    XrQuaternionf                  rotation;
    XrTime                         centerExposureTime;
} XrCubemapLightingDataANDROID;

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

• type इस स्ट्रक्चर का XrStructureType है.
• next, NULL होता है या स्ट्रक्चर चेन में अगले स्ट्रक्चर का पॉइंटर होता है. मान्य स्ट्रक्चर XrAmbientLightANDROID , XrSphericalHarmonicsANDROID , XrDirectionalLightANDROID हैं .
• state, XrLightEstimateStateANDROID है. यह रोशनी के अनुमान की स्थिति को दिखाता है.
• imageBufferSize एक uint32_t है, जो क्यूबमैप में हर फ़ेस इमेज बफ़र का बाइट साइज़ दिखाता है.
• imageBufferRight एक uint8_t बफ़र है, जिसमें क्यूबमैप के दाईं ओर के चेहरे की इमेज होती है.
• imageBufferLeft, uint8_t बफ़र है. इसमें क्यूबमैप के बाईं ओर के फ़ेस की इमेज होती है.
• imageBufferTop एक uint8_t बफ़र है, जिसमें क्यूबमैप के सबसे ऊपर वाले हिस्से की इमेज होती है.
• imageBufferBottom एक uint8_t बफ़र है, जिसमें क्यूबमैप के बॉटम फ़ेस की इमेज होती है.
• imageBufferFront एक uint8_t बफ़र है, जिसमें क्यूबमैप के सामने वाले हिस्से की इमेज होती है.
• imageBufferBack एक uint8_t बफ़र है, जिसमें क्यूबमैप के पीछे के हिस्से की इमेज होती है.
• rotation एक XrQuaternionf है. इससे क्यूबमैप के रोटेशन के बारे में पता चलता है.
• centerExposureTime एक XrTime है. इससे पता चलता है कि क्यूबमैप को कब कैप्चर किया गया था.

इस स्ट्रक्चर को XrLightEstimateANDROID से जोड़ा जा सकता है . अगर लाइट एस्टिमेटर हैंडल बनाने के लिए XrCubemapLightEstimatorCreateInfoANDROID का इस्तेमाल किया गया था, तो रनटाइम को xrGetLightEstimateANDROID में सिर्फ़ इस स्ट्रक्चर को पॉप्युलेट करना चाहिए. लाइट एस्टिमेटर हैंडल बनाते समय, ऐप्लिकेशन को इमेज बफ़र के लिए सही मात्रा में मेमोरी आवंटित करनी चाहिए. यह XrCubemapLightEstimatorCreateInfoANDROID :: cubemapResolution और XrCubemapLightEstimatorCreateInfoANDROID :: colorFormat में सेट की गई वैल्यू पर निर्भर करता है. ऐप्लिकेशन को, हर फ़ेस इमेज बफ़र की क्षमता को बाइट में सेट करने के लिए, XrCubemapLightingDataANDROID :: imageBufferSize को ज़रूर सेट करना चाहिए. अगर ऐप्लिकेशन, क्यूबमैप लाइट का अनुमान लगाने की सुविधा का इस्तेमाल नहीं कर रहा है या अगर XrCubemapLightingDataANDROID :: imageBufferSize, इमेज बफ़र को पॉप्युलेट करने के लिए रनटाइम के हिसाब से काफ़ी बड़ा नहीं है, तो रनटाइम को XrCubemapLightingDataANDROID :: state को XR_LIGHT_ESTIMATE_STATE_INVALID_ANDROID पर सेट करना ज़रूरी है .

अगर ऐप्लिकेशन ने लाइट एस्टिमेटर हैंडल बनाते समय, XrCubemapLightEstimatorCreateInfoANDROID :: reproject को XR_TRUE पर सेट किया है, तो रनटाइम को XrCubemapLightingDataANDROID :: rotation को आइडेंटिटी रोटेशन पर सेट करना होगा. साथ ही, यह पक्का करना होगा कि इंटरनल रोटेट किए गए क्यूबमैप को ऐप्लिकेशन के बेस स्पेस में आइडेंटिटी क्यूबमैप के फ़ेस पर फिर से प्रोजेक्ट किया गया हो.

लाइटिंग क्यूबमैप का लेआउट, OpenGL क्यूबमैप लेआउट जैसा ही होता है. इसे यहां दी गई इमेज में दिखाया गया है

इमेज 24. क्यूबमैप लेआउट.

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

• XrCubemapLightingDataANDROID का इस्तेमाल करने से पहले, XR_ANDROID_light_estimation_cubemap एक्सटेंशन को चालू करना ज़रूरी है
• type ज़रूरी तौर पर XR_TYPE_CUBEMAP_LIGHTING_DATA_ANDROID होना चाहिए
• next, NULL या स्ट्रक्चर चेन में मौजूद अगले स्ट्रक्चर का मान्य पॉइंटर होना चाहिए
• state, XrLightEstimateStateANDROID की मान्य वैल्यू होनी चाहिए
• imageBufferRight, imageBufferSize uint8_t वैल्यू की किसी कैटगरी का पॉइंटर होना चाहिए
• imageBufferLeft, imageBufferSize uint8_t वैल्यू की किसी कैटगरी का पॉइंटर होना चाहिए
• imageBufferTop, imageBufferSize uint8_t वैल्यू की किसी कैटगरी का पॉइंटर होना चाहिए
• imageBufferBottom, imageBufferSize uint8_t वैल्यू की किसी कैटगरी का पॉइंटर होना चाहिए
• imageBufferFront, imageBufferSize uint8_t वैल्यू की किसी कैटगरी का पॉइंटर होना चाहिए
• imageBufferBack, imageBufferSize uint8_t वैल्यू की किसी कैटगरी का पॉइंटर होना चाहिए
• imageBufferSize पैरामीटर की वैल्यू, 0 से ज़्यादा होनी चाहिए

रोशनी का अनुमान लगाने के लिए कोड का उदाहरण

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

XrSession session;  // Created at app startup
XrInstance instance; // Created at app startup
XrSpace appSpace;   // Created previously.
XrSystemId systemId; // Retrieved previously by xrGetSystem
PFN_xrCreateLightEstimatorANDROID xrCreateLightEstimatorANDROID; // Created previously.
PFN_xrDestroyLightEstimatorANDROID xrDestroyLightEstimatorANDROID; // Created previously.
PFN_xrGetLightEstimateANDROID xrGetLightEstimateANDROID; // Created previously.
PFN_xrEnumerateCubemapLightingResolutionsANDROID xrEnumerateCubemapLightingResolutionsANDROID; // Created previously.
PFN_xrEnumerateCubemapLightingColorFormatsANDROID xrEnumerateCubemapLightingColorFormatsANDROID; // Created previously.

XrSystemCubemapLightEstimationPropertiesANDROID props = {
  .type = XR_TYPE_SYSTEM_CUBEMAP_LIGHT_ESTIMATION_PROPERTIES_ANDROID};
XrSystemProperties base = {.type = XR_TYPE_SYSTEM_PROPERTIES,
                           .next = &props};
CHK_XR(xrGetSystemProperties(instance, systemId, &base));
if (!props.supportsCubemapLightEstimation) {
   // Cubemap light estimation is not supported
}

uint32_t cubemapResolution = 0;
std::vector<uint32_t> supportedCubemapResolutions;
uint32_t resolutionCount;
CHK_XR(xrEnumerateCubemapLightingResolutionsANDROID(
  instance, systemId, 0, &resolutionCount, nullptr));
supportedCubemapResolutions.resize(resolutionCount);
if (resolutionCount == 0) {
  // No cubemap lighting supported
} else {
  CHK_XR(xrEnumerateCubemapLightingResolutionsANDROID(
    instance, systemId, 0, &resolutionCount, supportedCubemapResolutions.data()));
  cubemapResolution = supportedCubemapResolutions[0];
}

uint32_t pixelCount = cubemapResolution * cubemapResolution;

XrCubemapLightingColorFormatANDROID colorFormat;
std::vector<XrCubemapLightingColorFormatANDROID> supportedColorFormats;
uint32_t colorFormatCount;
CHK_XR(xrEnumerateCubemapLightingColorFormatsANDROID(
  instance, systemId, 0, &colorFormatCount, nullptr));
supportedColorFormats.resize(colorFormatCount);
if (colorFormatCount == 0) {
  // No supported color formats for cubemap lighting. Cannot use cubemap
  // light estimation.
} else {
  CHK_XR(xrEnumerateCubemapLightingColorFormatsANDROID(
    instance, systemId, 0, &colorFormatCount, supportedColorFormats.data()));
  colorFormat = supportedColorFormats[0];
}

uint32_t pixelSize = 0;
switch (colorFormat) {
  case XR_CUBEMAP_LIGHTING_COLOR_FORMAT_R32G32B32_SFLOAT_ANDROID:
    pixelSize = 3 * sizeof(float);
    break;
  case XR_CUBEMAP_LIGHTING_COLOR_FORMAT_R32G32B32A32_SFLOAT_ANDROID:
    pixelSize = 4 * sizeof(float);
    break;
  case XR_CUBEMAP_LIGHTING_COLOR_FORMAT_R16G16B16A16_SFLOAT_ANDROID:
    pixelSize = 4 * sizeof(uint16_t);
    break;
  default:
    // Should not happen since the color format was validated previously.
    break;
}

uint32_t perFaceImageBufferSize = pixelCount * pixelSize;

XrLightEstimatorANDROID estimator;
XrCubemapLightEstimatorCreateInfoANDROID cubemapCreateInfo = {
    .type = XR_TYPE_CUBEMAP_LIGHT_ESTIMATOR_CREATE_INFO_ANDROID,
    .cubemapResolution = cubemapResolution,
    .colorFormat = colorFormat,
    .reproject = XR_TRUE
};
XrLightEstimatorCreateInfoANDROID basicCreateInfo = {
    .type = XR_TYPE_LIGHT_ESTIMATOR_CREATE_INFO_ANDROID,
    .next = &cubemapCreateInfo};
CHK_XR(xrCreateLightEstimatorANDROID(session, &basicCreateInfo, &estimator));

std::vector<uint8_t> cubemapBuffer(perFaceImageBufferSize * 6); // 6 faces * perFaceImageBufferSize

// Every frame
XrTime updateTime;  // Time used for the current frame's simulation update.

XrLightEstimateGetInfoANDROID info = {
    .type = XR_TYPE_LIGHT_ESTIMATE_GET_INFO_ANDROID,
    .space = appSpace,
    .time = updateTime,
};

XrCubemapLightingDataANDROID cubemap = {
    .type = XR_TYPE_CUBEMAP_LIGHTING_DATA_ANDROID,
    .next = nullptr,
    .imageBufferSize = perFaceImageBufferSize,
    .imageBufferRight = cubemapBuffer.data() + 0 * perFaceImageBufferSize,
    .imageBufferLeft = cubemapBuffer.data() + 1 * perFaceImageBufferSize,
    .imageBufferTop = cubemapBuffer.data() + 2 * perFaceImageBufferSize,
    .imageBufferBottom = cubemapBuffer.data() + 3 * perFaceImageBufferSize,
    .imageBufferFront = cubemapBuffer.data() + 4 * perFaceImageBufferSize,
    .imageBufferBack = cubemapBuffer.data() + 5 * perFaceImageBufferSize,
};

XrDirectionalLightANDROID directionalLight = {
    .type = XR_TYPE_DIRECTIONAL_LIGHT_ANDROID,
    .next = &cubemap,
};

XrSphericalHarmonicsANDROID totalSh = {
    .type = XR_TYPE_SPHERICAL_HARMONICS_ANDROID,
    .next = &directionalLight,
    .kind = XR_SPHERICAL_HARMONICS_KIND_TOTAL_ANDROID,
};

XrSphericalHarmonicsANDROID ambientSh = {
    .type = XR_TYPE_SPHERICAL_HARMONICS_ANDROID,
    .next = &totalSh,
    .kind = XR_SPHERICAL_HARMONICS_KIND_AMBIENT_ANDROID,
};

XrAmbientLightANDROID ambientLight = {
    .type = XR_TYPE_AMBIENT_LIGHT_ANDROID,
    .next = &ambientSh,
};

XrLightEstimateANDROID estimate = {
    .type = XR_TYPE_LIGHT_ESTIMATE_ANDROID,
    .next = &ambientLight,
};

XrResult result = xrGetLightEstimateANDROID(estimator, &info, &estimate);
if (result == XR_SUCCESS &&
    estimate.state == XR_LIGHT_ESTIMATE_STATE_VALID_ANDROID) {
  // use cubemap, directionalLight, totalSh, ambientSh, and
  // ambientLight if each struct has a valid state field

  if (cubemap.state == XR_LIGHT_ESTIMATE_STATE_VALID_ANDROID) {
    // use cubemap
    if (cubemapCreateInfo.reproject == XR_TRUE) {
      XrQuaternionf identityQuaternion = {0.0f, 0.0f, 0.0f, 1.0f};
      assert(memcmp(&cubemap.rotation, &identityQuaternion, sizeof(XrQuaternionf)) == 0);
    }
  }
}

// When you want to disable light estimation
CHK_XR(xrDestroyLightEstimatorANDROID(estimator));

नए निर्देश

• xrEnumerateCubemapLightingColorFormatsANDROID
• xrEnumerateCubemapLightingResolutionsANDROID

नई संरचनाएं

• XrLightEstimateANDROID को बढ़ाना :

  • XrCubemapLightingDataANDROID

• XrLightEstimatorCreateInfoANDROID को बढ़ाना :

  • XrCubemapLightEstimatorCreateInfoANDROID

• XrSystemProperties को बढ़ाना :

  • XrSystemCubemapLightEstimationPropertiesANDROID

नए एनम

• XrCubemapLightingColorFormatANDROID

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

• XR_ANDROID_LIGHT_ESTIMATION_CUBEMAP_EXTENSION_NAME
• XR_ANDROID_light_estimation_cubemap_SPEC_VERSION

• XrStructureType को बढ़ाना :

  • XR_TYPE_CUBEMAP_LIGHTING_DATA_ANDROID
  • XR_TYPE_CUBEMAP_LIGHT_ESTIMATOR_CREATE_INFO_ANDROID
  • XR_TYPE_SYSTEM_CUBEMAP_LIGHT_ESTIMATION_PROPERTIES_ANDROID

समस्याएं

वर्शन इतिहास

• पहला संशोधन, 05-12-2025 (सैलर खान)

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