XR_ANDROID_depth_texture

מחרוזת שם

XR_ANDROID_depth_texture

סוג התוסף

הרחבת המכונה

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

703

Revision

1

סטטוס האישור

לא אושר

תלות בתוסף ובגרסה

OpenXR 1.0

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

2024-09-11

סטטוס כתובת ה-IP

לא ידוע על תלונות על הפרת זכויות יוצרים שקשורות לכתובות IP.

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

סושאנט קולקרני (Sushant Kulkarni), Google
קיירן אוברטרף (Cairn Overturf), Google
ספנסר קווין (Spencer Quin), Google
לבנה צ'ן (Levana Chen), Google

סקירה כללית

התוסף הזה מאפשר לאפליקציה לבקש מפות עומק של הסביבה בעולם האמיתי סביב האוזניות, ולשאול על רזולוציות העומק הנתמכות בזמן היצירה.

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

הערה

מפות העומק נוצרות על ידי זמן הריצה ומשותפות עם האפליקציה באמצעות XrDepthSwapchainANDROID . במהלך זמן הריצה, אסור לשנות את הרזולוציות של תמונות העומק שמוחזרות באמצעות xrEnumerateDepthResolutionsANDROID לאורך משך החיים של האפליקציה.

הרשאות

התוסף הזה חושף טקסטורת עומק שעברה דגימה חוזרת כדי לצמצם את החששות לגבי פרטים אישיים מזהים (PII). באפליקציות ל-Android חייבת להופיע ההרשאה android.permission.SCENE_UNDERSTANDING_FINE במניפסט, כי התוסף הזה חושף את הגיאומטריה של הסביבה. ההרשאה android.permission.SCENE_UNDERSTANDING_FINE נחשבת להרשאה מסוכנת. האפליקציה חייבת לבקש את ההרשאה בזמן הריצה כדי להשתמש בפונקציות האלה:

(רמת ההגנה: מסוכן)

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

המבנה XrSystemDepthTrackingPropertiesANDROID מוגדר כך:

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

תיאורי חברים

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

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

אם ורק אם זמן ריצה מחזיר XR_FALSE עבור supportsDepthTracking , זמן הריצה חייב להחזיר XR_ERROR_FEATURE_UNSUPPORTED מהפונקציה xrCreateDepthSwapchainANDROID .

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

פתרונות לעומק השאילתה

הפונקציה 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 , אבל יכול להיות NULL אם resolutionCapacityInput הוא 0 .
  • בקטע פרמטרים של גודל המאגר מפורט תיאור של אחזור הגודל הנדרש של resolutions.

‫xrEnumerateDepthResolutionsANDROID מפרט את רזולוציות העומק שנתמכות בסשן הנוכחי. רזולוציות העומק צריכות להיות מסודרות מההעדפה הגבוהה ביותר להכי פחות מועדפת בזמן הריצה. האפליקציה צריכה להשתמש בהעדפה הכי גבוהה שהיא תומכת בה כדי להשיג ביצועים ואיכות אופטימליים.

סביבות זמן הריצה חייבות להחזיר תמיד תוכן זהה של מאגרים מהספירה הזו למשך חיי הסשן.

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

  • ‫ התוסף XR_ANDROID_depth_texture חייב להיות מופעל לפני הקריאה ל-xrEnumerateDepthResolutionsANDROID
  • ‫ session חייב להיות מאחז XrSession תקין
  • ‫ resolutionCountOutput חייב להיות מצביע לערך uint32_t
  • ‫ אם resolutionCapacityInput לא שווה ל-0 , ‏ resolutions חייב להיות מצביע למערך של resolutionCapacityInput ערכים מסוג XrDepthCameraResolutionANDROID

קודי החזרה

הצלחה

  • 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

ה-enum‏ XrDepthCameraResolutionANDROID מתאר את רזולוציות העומק הנתמכות כשיוצרים 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;

תיאורים של ערכי enum

  • ‫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);

תיאורים של פרמטרים

האפליקציה יכולה להשתמש בפונקציה xrCreateDepthSwapchainANDROID כדי ליצור שרשרת החלפה של עומק שמנהלת גם תמונות של עומק וגם תמונות של רמת הביטחון.

  • סביבת זמן הריצה חייבת להחזיר את הערך XR_ERROR_FEATURE_UNSUPPORTED אם המערכת לא תומכת במעקב אחר עומק.
  • סביבת זמן הריצה חייבת להחזיר XR_ERROR_PERMISSION_INSUFFICIENT אם ההרשאות הנדרשות לא ניתנו לאפליקציה שמבצעת את הקריאה.
  • סביבת זמן הריצה חייבת להחזיר את הערך XR_ERROR_VALIDATION_FAILURE אם רזולוציית העומק שצוינה ב-XrDepthSwapchainCreateInfoANDROID לא נתמכת.
  • זמן הריצה צריך ליצור תמונות של רמת מהימנות העומק רק כשהביטים התואמים מוגדרים ל-createInfo בזמן יצירת swapchain.

אפשר להשתמש בהמשך ב-handle של שרשרת ההחלפה של העומק שמוחזר בקריאות ל-API. חובה לשחרר את ה-handle של XrDepthSwapchainANDROID בסופו של דבר באמצעות הפונקציה xrDestroyDepthSwapchainANDROID.

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

קודי החזרה

הצלחה

  • 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 מספק אפשרויות ליצירת XrDepthSwapchainANDROID כשמעבירים אותו אל xrCreateDepthSwapchainANDROID.

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

הפרמטר 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);

תיאורים של פרמטרים

הפונקציה xrDestroyDepthSwapchainANDROID משמידה את שרשרת ההחלפה של עומק. אחרי הקריאה הזו, יכול להיות שסביבת זמן הריצה תפנה את כל הזיכרון והמשאבים שקשורים אליה.

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

Thread Safety

  • הגישה אל 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. הערך יכול להיות NULL אם depthImageCapacityInput הוא 0.
  • בקטע פרמטרים של גודל המאגר מפורט תיאור של אחזור הגודל הנדרש של depthImages.

הפונקציה xrEnumerateDepthSwapchainImagesANDROID ממלאת מערך של מבני XrDepthSwapchainImageANDROID. המשאבים חייבים להיות קבועים ותקפים למשך כל משך החיים של XrDepthSwapchainANDROID . הפונקציה הזו פועלת באופן דומה ל-xrEnumerateSwapchainImages .

סביבת זמן הריצה חייבת להחזיר תמיד תוכן זהה של מאגרים מהספירה הזו למשך משך החיים של שרשרת ההחלפה.

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

  • ‫ התוסף XR_ANDROID_depth_texture חייב להיות מופעל לפני הקריאה ל-xrEnumerateDepthSwapchainImagesANDROID
  • ‫ 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 או המצביע לתמונות של רמת מהימנות העומק המוחלקות עבור התצוגות השמאלית והימנית שהוקצו על ידי זמן הריצה.

הפוינטרים של מאגר התמונות יהיו תקפים רק במהלך משך החיים של ה-swapchain. אחרי שה-swapchain נהרס, המצביעים ייחשבו כ-dangling.

‫XrDepthSwapchainImageANDROID מייצג את תמונות העומק מ-XrDepthSwapchainANDROID שניתן לקרוא , שהוקצו כפי שמתואר ב-XrDepthSwapchainCreateInfoANDROID :: resolution וב-XrDepthSwapchainCreateInfoANDROID :: createFlags במהלך הקריאה ל-xrCreateDepthSwapchainANDROID . לכל תמונת עומק:

  • ערכי התמונות מסודרים בזיכרון לפי סדר השורות, ללא ריווח בין השורות.
  • הערך הראשון הוא הפינה השמאלית העליונה והערך האחרון הוא הפינה הימנית התחתונה.
  • הגודל של הזיכרון שאליו מצביע המצביע נקבע לפי הערך של xrEnumerateDepthSwapchainImagesANDROID ומוגדר על ידי XrDepthSwapchainCreateInfoANDROID :: resolution במהלך הקריאה ל-xrCreateDepthSwapchainANDROID . לדוגמה, אם XrDepthSwapchainCreateInfoANDROID :: resolution הוא XR_DEPTH_CAMERA_RESOLUTION_160x160_ANDROID , לתמונות העומק יהיה גודל של 2*160*160*sizeof(float) .
  • הערך של rawDepthImage חייב להיות NULL אם XrDepthSwapchainCreateInfoANDROID :: createFlags לא כלל את XR_DEPTH_SWAPCHAIN_CREATE_RAW_DEPTH_IMAGE_BIT_ANDROID .
  • הערך של rawDepthConfidenceImage חייב להיות NULL אם XrDepthSwapchainCreateInfoANDROID :: createFlags לא כלל את XR_DEPTH_SWAPCHAIN_CREATE_RAW_CONFIDENCE_IMAGE_BIT_ANDROID .
  • הערך של smoothDepthImage חייב להיות 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 .

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

הפונקציה xrAcquireDepthSwapchainImagesANDROID מוגדרת כך:

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

תיאורים של פרמטרים

אפליקציות יכולות להשתמש בפונקציה xrAcquireDepthSwapchainImagesANDROID כדי לקבל את האינדקס העדכני ביותר של תמונת swapchain, כלומר XrDepthAcquireResultANDROID :: acquiredIndex , למערך XrDepthSwapchainImageANDROID שמופיע ברשימה על ידי xrEnumerateDepthSwapchainImagesANDROID . התוצאה XrDepthAcquireResultANDROID שמוחזרת מכילה גם מידע נוסף, כמו שדה הראייה והמיקום, שנדרש כדי לפרש את נתוני העומק. אפשר לקרוא מהמשבצת שנרכשה במערך התמונות עד לקריאה הבאה אל xrAcquireDepthSwapchainImagesANDROID .

חייבת להיות קריאה אחת בלבד ל-xrAcquireDepthSwapchainImagesANDROID בין כל זוג של קריאות תואמות ל-xrBeginFrame ול-xrEndFrame בסשן.

  • יכול להיות שזמן הריצה ייחסם אם תמונות של שרשרת החלפה שנרכשו בעבר עדיין נמצאות בשימוש בזמן הריצה.
  • סביבת זמן הריצה חייבת להחזיר XR_ERROR_CALL_ORDER_INVALID אם הפונקציה xrAcquireDepthSwapchainImagesANDROID נקראת לפני xrBeginFrame או אחרי xrEndFrame .
  • סביבת זמן הריצה חייבת להחזיר XR_ERROR_LIMIT_REACHED אם הפונקציה xrAcquireDepthSwapchainImagesANDROID נקראת יותר מפעם אחת לכל פריים – כלומר, בסשן פעיל, אחרי קריאה לפונקציה xrBeginFrame שלא שויכה אליה הפונקציה xrEndFrame.
  • יכול להיות שסביבת זמן הריצה תחזיר את הערך XR_ERROR_DEPTH_NOT_AVAILABLE_ANDROID אם נתוני העומק של הסביבה עדיין לא זמינים. במקרה כזה, האפליקציה צריכה לקרוא שוב לפונקציה xrAcquireDepthSwapchainImagesANDROID בפריים מאוחר יותר.

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

קודי החזרה

הצלחה

  • 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 . יישומים צריכים להעביר את זמן התצוגה החזוי שלהם עבור המסגרת הנוכחית.

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

המבנה 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 הוא העין הימנית.

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

המבנה של XrDepthViewANDROID מוגדר כך:

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

תיאורי חברים

  • ‫type הוא XrStructureType של המבנה הזה.
  • ‫next הוא NULL או מצביע למבנה הבא בשרשרת מבנים. לא מוגדרים מבנים כאלה ב-OpenXR או בתוסף הזה.
  • ‫fov הוא XrFovf שמציין את שדה הראייה ששימש ליצירת התצוגה הזו. התצוגה אף פעם לא מתהפכת אופקית או אנכית.
  • ‫pose הוא XrPosef שמציין את התנוחה שממנה מפת העומק עברה רינדור. מסגרת ההפניה מוגדרת ב-XrDepthAcquireInfoANDROID .

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

קוד לדוגמה למעקב אחר עומק

בדוגמת הקוד הבאה אפשר לראות איך מקבלים תמונות עומק ומשתמשים בערכי העומק כדי למפות את הקואורדינטות של תמונת העומק למרחב הבמה.

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
    // ...
}

סוגי אובייקטים חדשים

פקודות חדשות

מבנים חדשים

New Enums

מסיכות סיביות חדשות

New Enum Constants

  • 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

בעיות

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

  • גרסה 1, 09.09.2024 (לבנה חן)

    • תיאור ראשוני של התוסף