Android XR for OpenXR | Android Developers

מפגש של מפתחי Android חוזר עם מסלול ייעודי ל-Android XR. אתם מוזמנים לנסות את התכונות החדשות ולשלוח לנו משוב.

‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

XR_ANDROID_light_estimation_cubemap

מחרוזת שם

XR_ANDROID_light_estimation_cubemap

סוג התוסף

תוסף למכונה

מספר השלוחה הרשום

722

גרסה

סטטוס האישור

לא אושר

תלויות של תוספים וגרסאות

XR_ANDROID_light_estimation

תאריך השינוי האחרון

2025-08-06

סטטוס IP

אין תלונות ידועות על הפרת קניין רוחני.

שותפים ביצירת התוכן

Salar Khan, Google
Scott Chung, Google
Jared Finder, Google
Spencer Quin, Google
Levana Chen, Google
Nihav Jain, Google
Jürgen Sturm, Google

סקירה כללית

התוסף הזה מבוסס על התוסף הבסיסי של XR_ANDROID_light_estimation. היא מוסיפה תמיכה בקבלת הערכות תאורה של מפת קוביות, שמספקות הערכות מפורטות יותר לגבי התאורה בסביבה הפיזית.

הערה

המנגנון לקבלת נתוני הערכת התאורה זהה לזה של התוסף הבסיסי, אבל צריך לשרשר את XrCubemapLightEstimatorCreateInfoANDROID אל XrLightEstimatorCreateInfoANDROID כשיוצרים את נקודת האחיזה של מעריך התאורה.

בדיקת יכולות המערכת

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

תיאורי חברים

‫type הוא ה-XrStructureType של המבנה הזה.
‫next הוא NULL או מצביע למבנה הבא בשרשרת מבנים. מבנים כאלה לא מוגדרים ב-OpenXR או בתוסף הזה.
‫supportsCubemapLightEstimation הוא XrBool32 , שמציין אם המערכת הנוכחית תומכת בהערכת תאורה של מפת קוביה.

אפליקציה יכולה לבדוק אם המערכת מסוגלת לתמוך בהערכת תאורה של מפת קוביה על ידי הרחבה של XrSystemProperties עם מבנה XrSystemCubemapLightEstimationPropertiesANDROID כשקוראים ל-xrGetSystemProperties .

אם זמן הריצה מחזיר את הערך XR_FALSE עבור supportsCubemapLightEstimation ו-XrCubemapLightEstimatorCreateInfoANDROID משורשר ל-XrLightEstimatorCreateInfoANDROID , זמן הריצה חייב להחזיר את הערך XR_ERROR_FEATURE_UNSUPPORTED מ-xrCreateLightEstimatorANDROID .

שימוש תקין (משתמע)

חובה להפעיל את התוסף XR_ANDROID_light_estimation_cubemap לפני שמשתמשים ב-XrSystemCubemapLightEstimationPropertiesANDROID
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 שמאוכלס על ידי סביבת זמן הריצה ברזולוציות הנתמכות של מפת הקוביה.

רזולוציית Cubemap מציינת את הרוחב והגובה של כל פאה של ה-Cubemap בפיקסלים. ניב של 2 קריאות האפליקציה יכולה לבחור להשתמש באחת מהרזולוציות הנתמכות ב-XrCubemapLightEstimatorCreateInfoANDROID :: cubemapResolution כשיוצרים את נקודת האחיזה של אומדן התאורה. האפליקציה חייבת להקצות את כמות הזיכרון המתאימה לאיברים של מאגר התמונות הזמני של XrCubemapLightingDataANDROID, בהתאם לרזולוציה ולפורמט הצבע שנבחרו.

שימוש תקין (משתמע)

חובה להפעיל את התוסף XR_ANDROID_light_estimation_cubemap לפני שקוראים לפונקציה xrEnumerateCubemapLightingResolutionsANDROID
‫ instance חייב להיות כינוי תקין של XrInstance
resolutionCountOutput חייב להיות מצביע לערך uint32_t
אם resolutionCapacityInput הוא לא 0, אז resolutions חייב להיות מצביע למערך של ערכי uint32_t מסוג resolutionCapacityInput

קודי החזרה

הצלחה

XR_SUCCESS

נכשל

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

קבלת פורמטים נתמכים של צבעי cubemap

הספירה XrCubemapLightingColorFormatANDROID מזהה את פורמט הצבע של תאורת cubemap שבו צריך להשתמש בזמן הריצה.

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;

אלה המשמעויות של ה-enums:

תיאור הטיפוס בן המנייה (enum)

XR_CUBEMAP_LIGHTING_COLOR_FORMAT_R32G32B32_SFLOAT_ANDROID

פורמט צבע עם 3 ערוצים, שבו כל ערוץ הוא ערך נקודה צפה (floating point) של 32 ביט.

XR_CUBEMAP_LIGHTING_COLOR_FORMAT_R32G32B32A32_SFLOAT_ANDROID

פורמט צבע עם 4 ערוצים, שבו כל ערוץ הוא ערך של נקודה צפה (floating point) של 32 ביט.

XR_CUBEMAP_LIGHTING_COLOR_FORMAT_R16G16B16A16_SFLOAT_ANDROID

פורמט צבע עם 4 ערוצים, שבו כל ערוץ הוא ערך של נקודה צפה (floating point) של 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 שמאוכלס על ידי סביבת זמן הריצה בפורמטים הנתמכים של צבעי cubemap.

ביטוי של 2 קריאות האפליקציה יכולה לבחור להשתמש באחד מהפורמטים הנתמכים של צבעים ב-XrCubemapLightEstimatorCreateInfoANDROID :: colorFormat כשיוצרים את נקודת האחיזה של מעריך התאורה. האפליקציה חייבת להקצות את כמות הזיכרון המתאימה לאיברים של מאגר התמונות הזמני של XrCubemapLightingDataANDROID, בהתאם לפורמט הצבע שנבחר.

שימוש תקין (משתמע)

צריך להפעיל את התוסף XR_ANDROID_light_estimation_cubemap לפני שקוראים לפונקציה xrEnumerateCubemapLightingColorFormatsANDROID
‫ instance חייב להיות כינוי תקין של XrInstance
colorFormatCountOutput חייב להיות מצביע לערך uint32_t
אם colorFormatCapacityInput הוא לא 0, הערך של colorFormats חייב להיות מצביע למערך של ערכי colorFormatCapacityInput XrCubemapLightingColorFormatANDROID

קודי החזרה

הצלחה

XR_SUCCESS

נכשל

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 שמציין את הרזולוציה של תאורת ה-cubemap שבה רוצים להשתמש.
‫colorFormat הוא XrCubemapLightingColorFormatANDROID שמציין את פורמט הצבע של נתוני התאורה של ה-cubemap שבהם צריך להשתמש.
‫reproject הוא XrBool32 שמציין אם צריך להקרין מחדש את התאורה של מפת הקוביה למרחב הבסיס של האפליקציה.

המבנה XrCubemapLightEstimatorCreateInfoANDROID מתאר את המידע ליצירת נקודת אחיזה (handle) מסוג XrLightEstimatorANDROID, כדי שתוכל לספק הערכות תאורה של מפת קוביות. צריך להגדיר את האיבר XrCubemapLightEstimatorCreateInfoANDROID :: cubemapResolution לאחת מהרזולוציות שמוחזרות על ידי xrEnumerateCubemapLightingResolutionsANDROID . צריך להגדיר את האיבר colorFormat של XrCubemapLightEstimatorCreateInfoANDROID :: לאחד מהפורמטים של הצבעים שמוחזרים על ידי xrEnumerateCubemapLightingColorFormatsANDROID . אם האפליקציה לא מגדירה את הרזולוציה לאחת מהרזולוציות הנתמכות או את פורמט הצבע לאחד מפורמטי הצבע הנתמכים, זמן הריצה חייב להחזיר את XR_ERROR_FEATURE_UNSUPPORTED מ-xrCreateLightEstimatorANDROID .

שימוש תקין (משתמע)

‫ חובה להפעיל את התוסף XR_ANDROID_light_estimation_cubemap לפני שמשתמשים ב-XrCubemapLightEstimatorCreateInfoANDROID
type חייב להיות XR_TYPE_CUBEMAP_LIGHT_ESTIMATOR_CREATE_INFO_ANDROID
next חייב להיות NULL או מצביע תקין למבנה הבא בשרשרת מבנים
‫ colorFormat חייב להיות ערך XrCubemapLightingColorFormatANDROID תקין

הערכות תאורה של Cubemap

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 שמכיל את תמונת הפאה הימנית של ה-cubemap.
‫imageBufferLeft הוא מאגר נתונים זמני מסוג uint8_t שמכיל את תמונת הפאה השמאלית של מפת הקוביה.
‫imageBufferTop הוא מאגר נתונים זמני מסוג uint8_t שמכיל את התמונה של הפאה העליונה של מפת הקוביה.
‫imageBufferBottom הוא מאגר נתונים זמני מסוג uint8_t שמכיל את תמונת הפאה התחתונה של מפת הקוביה.
‫imageBufferFront הוא מאגר נתונים זמני מסוג uint8_t שמכיל את תמונת הפנים הקדמיות של מפת הקוביה.
‫imageBufferBack הוא מאגר נתונים זמני מסוג uint8_t שמכיל את תמונת הפאה האחורית של מפת הקוביה.
‫rotation הוא XrQuaternionf שמציין את הסיבוב של מפת הקוביה.
‫centerExposureTime הוא XrTime שמציין את הזמן שבו צולמה מפת הקוביה.

אפשר לשרשר את המבנה הזה ל-XrLightEstimateANDROID . זמן הריצה חייב לאכלס את המבנה הזה רק ב-xrGetLightEstimateANDROID אם נעשה שימוש ב-XrCubemapLightEstimatorCreateInfoANDROID כדי ליצור את נקודת האחיזה של מעריך התאורה. האפליקציה חייבת להקצות את כמות הזיכרון המתאימה למאגרי התמונות, בהתאם לערכים שמוגדרים ב-XrCubemapLightEstimatorCreateInfoANDROID :: cubemapResolution וב-XrCubemapLightEstimatorCreateInfoANDROID :: colorFormat כשיוצרים את נקודת האחיזה של אומדן התאורה. האפליקציה חייבת להגדיר את XrCubemapLightingDataANDROID :: imageBufferSize לקיבולת של כל מאגר נתונים זמני של תמונת פנים בבייטים. אם האפליקציה לא משתמשת בהערכת תאורה של cubemap או אם XrCubemapLightingDataANDROID :: imageBufferSize לא מספיק גדול כדי שזמן הריצה יאכלס את מאגרי התמונות, זמן הריצה חייב להגדיר את XrCubemapLightingDataANDROID :: state ל-XR_LIGHT_ESTIMATE_STATE_INVALID_ANDROID .

אם האפליקציה הגדירה את XrCubemapLightEstimatorCreateInfoANDROID :: reproject ל-XR_TRUE בזמן יצירת נקודת האחיזה של אומדן התאורה, זמן הריצה חייב להגדיר את XrCubemapLightingDataANDROID :: rotation לסיבוב הזהות ולוודא שה-cubemap הפנימי שעבר סיבוב מוקרן מחדש על הפנים של cubemap הזהות במרחב הבסיס של האפליקציה.

הפריסה של מפת הקוביות של התאורה זהה לפריסה של מפת הקוביות של OpenGL, כמו שמוצג בתמונה הבאה

פריסת מפת קוביות להערכת תאורה ב-XR ANDROID

איור 31. פריסת Cubemap.

שימוש תקין (משתמע)

‫ חובה להפעיל את התוסף XR_ANDROID_light_estimation_cubemap לפני שמשתמשים ב-XrCubemapLightingDataANDROID
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

ערכי Enums חדשים

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

בעיות

היסטוריית גרסאות

גרסה 1, 2025-12-05 (סאלאר חאן)
- תיאור התוסף הראשוני