XR_ANDROID_depth_texture

Ciąg znaków nazwy

XR_ANDROID_depth_texture

Typ rozszerzenia

Rozszerzenie instancji

Zarejestrowany numer wewnętrzny

703

Wersja

1

Stan ratyfikacji

Nie ratyfikowano

Zależności rozszerzeń i wersji

OpenXR 1.0

Data ostatniej modyfikacji

2024-09-11

Stan adresu IP

Brak znanych roszczeń dotyczących własności intelektualnej.

Twórcy

Sushant Kulkarni, Google
Cairn Overturf, Google
Spencer Quin, Google
Levana Chen, Google

Omówienie

To rozszerzenie umożliwia aplikacji żądanie map głębi otoczenia w rzeczywistym świecie wokół zestawu słuchawkowego i sprawdzanie obsługiwanych rozdzielczości głębi podczas tworzenia.

To rozszerzenie ma na celu udostępnianie surowych i wygładzonych danych o głębi na potrzeby okluzji, testów trafień i innych konkretnych zadań, które wykorzystują dokładną geometrię sceny, np. wykrywanie podrobionych twarzy.

Uwaga

Mapy głębi są generowane przez środowisko wykonawcze i udostępniane aplikacji za pomocą funkcji XrDepthSwapchainANDROID . Środowisko wykonawcze nie może zmieniać rozdzielczości obrazu głębi zwracanych przez funkcję xrEnumerateDepthResolutionsANDROID przez cały okres działania aplikacji.

Uprawnienia

To rozszerzenie udostępnia teksturę głębi o niższej rozdzielczości, aby ograniczyć ryzyko związane z informacjami umożliwiającymi identyfikację. Aplikacje na Androida muszą mieć w pliku manifestu uprawnienia android.permission.SCENE_UNDERSTANDING_FINE, ponieważ to rozszerzenie udostępnia geometrię otoczenia. Uprawnienie android.permission.SCENE_UNDERSTANDING_FINE jest uznawane za niebezpieczne. Aby korzystać z tych funkcji, aplikacja musi prosić o uprawnienia w czasie działania:

(poziom ochrony: niebezpieczny)

Sprawdzanie możliwości systemu

Struktura XrSystemDepthTrackingPropertiesANDROID jest zdefiniowana w ten sposób:

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

Opisy członków

  • type to XrStructureType tej struktury.
  • next to NULL lub wskaźnik do następnej struktury w łańcuchu struktur. W podstawowej specyfikacji OpenXR ani w tym rozszerzeniu nie zdefiniowano takich struktur.
  • supportsDepthTracking to XrBool32 wskazujący, czy bieżący system obsługuje śledzenie głębi.

Aplikacja może sprawdzić, czy system obsługuje śledzenie głębi, rozszerzając strukturę XrSystemProperties o strukturę XrSystemDepthTrackingPropertiesANDROID podczas wywoływania funkcji xrGetSystemProperties .

Jeśli środowisko wykonawcze zwraca wartość XR_FALSE dla supportsDepthTracking , musi zwrócić wartość XR_ERROR_FEATURE_UNSUPPORTED z funkcji xrCreateDepthSwapchainANDROID .

Prawidłowe użycie (domyślne)

Rozwiązania dotyczące głębokości zapytań

Funkcja xrEnumerateDepthResolutionsANDROID jest zdefiniowana w ten sposób:

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

Opisy parametrów

  • session to XrSession, która zawiera listę obsługiwanych rozdzielczości głębi.
  • resolutionCapacityInput to pojemność resolutions lub 0 , aby pobrać wymaganą pojemność.
  • resolutionCountOutput to wskaźnik liczby zapisanych bajtów uint64_t resolutions lub wskaźnik wymaganej pojemności w przypadku, gdy resolutionCapacityInput jest niewystarczająca.
  • resolutions to wskaźnik tablicy XrDepthCameraResolutionANDROID, ale może mieć wartość NULL, jeśli resolutionCapacityInput ma wartość 0 .
  • Szczegółowy opis pobierania wymaganego rozmiaru resolutions znajdziesz w sekcji Parametry rozmiaru bufora.

Funkcja xrEnumerateDepthResolutionsANDROID wylicza rozdzielczości głębi obsługiwane przez bieżącą sesję. Rozdzielczości głębi powinny być uporządkowane od najwyższej do najniższej preferencji czasu działania. Aplikacja powinna używać najwyższych ustawień, które obsługuje, aby zapewnić optymalną wydajność i jakość.

Środowiska wykonawcze muszą zawsze zwracać identyczną zawartość bufora z tego wyliczenia przez cały czas trwania sesji.

Prawidłowe użycie (domyślne)

  •  Rozszerzenie XR_ANDROID_depth_texture musi być włączone przed wywołaniem funkcji xrEnumerateDepthResolutionsANDROID.
  • session musi być prawidłowym uchwytem XrSession
  • resolutionCountOutput musi być wskaźnikiem wartości uint32_t
  •  Jeśli resolutionCapacityInput nie jest równe 0 , resolutions musi być wskaźnikiem do tablicy wartości resolutionCapacityInput XrDepthCameraResolutionANDROID.

Kody zwrotne

Sukces

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Błąd

  • 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

Wyliczenie XrDepthCameraResolutionANDROID opisuje obsługiwane rozdzielczości głębi podczas tworzenia 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;

Opisy elementów wyliczenia

  • XR_DEPTH_CAMERA_RESOLUTION_80x80_ANDROID – rozdzielczość obrazów głębi i pewności wynosi 80 x 80.
  • XR_DEPTH_CAMERA_RESOLUTION_160x160_ANDROID – rozdzielczość obrazów głębi i pewności wynosi 160 x 160.
  • XR_DEPTH_CAMERA_RESOLUTION_320x320_ANDROID – Rozdzielczość obrazów głębi i pewności wynosi 320 x 320.

Tworzenie łańcucha wymiany głębi

XR_DEFINE_HANDLE(XrDepthSwapchainANDROID)

XrDepthSwapchainANDROID to uchwyt łańcucha wymiany głębi.

Funkcja xrCreateDepthSwapchainANDROID jest zdefiniowana w ten sposób:

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

Opisy parametrów

Aplikacja może używać funkcji xrCreateDepthSwapchainANDROID do tworzenia łańcucha wymiany głębi, który zarządza obrazami głębi i pewności.

  • Środowisko wykonawcze musi zwracać wartość XR_ERROR_FEATURE_UNSUPPORTED, jeśli system nie obsługuje śledzenia głębi.
  • Środowisko wykonawcze musi zwrócić wartość XR_ERROR_PERMISSION_INSUFFICIENT, jeśli wymagane uprawnienia nie zostały przyznane aplikacji wywołującej.
  • Środowisko wykonawcze musi zwrócić wartość XR_ERROR_VALIDATION_FAILURE, jeśli rozdzielczość głębi określona w strukturze XrDepthSwapchainCreateInfoANDROID jest nieobsługiwana.
  • Środowisko wykonawcze powinno tworzyć obrazy z pewnością głębi tylko wtedy, gdy odpowiednie bity są ustawione dla createInfo podczas tworzenia łańcucha wymiany.

Zwrócony uchwyt łańcucha wymiany buforów głębi może być później używany w wywołaniach interfejsu API. Uchwyt XrDepthSwapchainANDROID musi zostać ostatecznie zwolniony za pomocą funkcji xrDestroyDepthSwapchainANDROID.

Prawidłowe użycie (domyślne)

Kody zwrotne

Sukces

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Błąd

  • 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

Struktura XrDepthSwapchainCreateInfoANDROID jest zdefiniowana w ten sposób:

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

Opisy członków

Struktura XrDepthSwapchainCreateInfoANDROID zawiera opcje tworzenia XrDepthSwapchainANDROID, gdy jest przekazywana do funkcji xrCreateDepthSwapchainANDROID .

Prawidłowe użycie (domyślne)

Flaga XrDepthSwapchainCreateFlagsANDROID określa opcje tworzenia XrDepthSwapchainANDROID .

typedef XrFlags64 XrDepthSwapchainCreateFlagsANDROID;

Prawidłowe bity dla XrDepthSwapchainCreateFlagsANDROID są zdefiniowane przez XrDepthSwapchainCreateFlagBitsANDROID , który jest określony jako:

// 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;

Opisy flag

  • XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_DEPTH_IMAGE_BIT_ANDROID – oznacza, że łańcuch wymiany będzie dostarczać płynne obrazy głębi.
  • XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_CONFIDENCE_IMAGE_BIT_ANDROID – wskazuje, że łańcuch wymiany będzie dostarczać płynne obrazy z poziomem ufności głębi.
  • XR_DEPTH_SWAPCHAIN_CREATE_RAW_DEPTH_IMAGE_BIT_ANDROID – oznacza, że łańcuch wymiany będzie dostarczać surowe obrazy głębi.
  • XR_DEPTH_SWAPCHAIN_CREATE_RAW_CONFIDENCE_IMAGE_BIT_ANDROID – wskazuje, że łańcuch buforów będzie dostarczać obrazy z surowymi danymi o pewności głębi.

Funkcja xrDestroyDepthSwapchainANDROID jest zdefiniowana w ten sposób:

XrResult xrDestroyDepthSwapchainANDROID(
    XrDepthSwapchainANDROID                     swapchain);

Opisy parametrów

Funkcja xrDestroyDepthSwapchainANDROID niszczy łańcuch wymiany głębi. Po tym wywołaniu środowisko wykonawcze może zwolnić całą powiązaną pamięć i zasoby.

Prawidłowe użycie (domyślne)

Bezpieczeństwo wątków

  • Dostęp do swapchain i wszystkich uchwytów podrzędnych musi być synchronizowany zewnętrznie.

Kody zwrotne

Sukces

  • XR_SUCCESS

Błąd

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID

Dostęp do tekstur głębi

Funkcja xrEnumerateDepthSwapchainImagesANDROID jest zdefiniowana w ten sposób:

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

Opisy parametrów

  • depthSwapchain to XrDepthSwapchainANDROID, z którego mają być pobierane obrazy.
  • depthImageCapacityInput to pojemność tablicy depthImages lub 0, aby wskazać żądanie pobrania wymaganej pojemności.
  • depthImageCountOutput to wskaźnik liczby zapisanych elementów depthImages lub wskaźnik wymaganej pojemności w przypadku, gdy depthImageCapacityInput jest niewystarczająca.
  • depthImages to wskaźnik do tablicy struktur XrDepthSwapchainImageANDROID. Może to być NULL, jeśli depthImageCapacityInput wynosi 0.
  • Szczegółowy opis pobierania wymaganego rozmiaru depthImages znajdziesz w sekcji Parametry rozmiaru bufora.

Funkcja xrEnumerateDepthSwapchainImagesANDROID wypełnia tablicę struktur XrDepthSwapchainImageANDROID. Zasoby muszą być stałe i ważne przez cały okres istnienia XrDepthSwapchainANDROID . Ta funkcja działa analogicznie do funkcji xrEnumerateSwapchainImages .

Czas działania musi zawsze zwracać identyczne zawartości bufora z tego wyliczenia przez cały okres istnienia łańcucha wymiany.

Prawidłowe użycie (domyślne)

Kody zwrotne

Sukces

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Błąd

  • 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

Struktura XrDepthSwapchainImageANDROID jest zdefiniowana w ten sposób:

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

Opisy członków

  • type to XrStructureType tej struktury.
  • next to NULL lub wskaźnik do następnej struktury w łańcuchu struktur. W podstawowej specyfikacji OpenXR ani w tym rozszerzeniu nie zdefiniowano takich struktur.
  • rawDepthImage to NULL lub wskaźnik do surowych obrazów głębi dla widoku z lewej i prawej strony przydzielony przez środowisko wykonawcze. Wartości są podawane w metrach. Wartości specjalne: 0.0 oznacza nieprawidłowy lub pusty piksel głębi w surowych danych o głębi, Inf oznacza znaną głębię, która jest w zasadzie nieskończenie daleko,
  • rawDepthConfidenceImage to NULL lub wskaźnik do obrazów ufności surowej głębi dla widoków z lewej i prawej strony przydzielonych przez środowisko wykonawcze.
  • smoothDepthImage to NULL lub wskaźnik do wygładzania obrazów głębi dla widoków z lewej i prawej strony przydzielonych przez środowisko wykonawcze. Wartości są podawane w metrach. Wartości specjalne: 0.0 oznacza nieprawidłowy lub pusty piksel głębi w wygładzonej głębi, Inf oznacza znaną głębię, która jest w zasadzie nieskończenie daleko.
  • smoothDepthConfidenceImage to NULL lub wskaźnik do wygładzonych obrazów ufności głębi dla widoków z lewej i prawej strony przydzielonych przez środowisko wykonawcze.

Wskaźniki bufora obrazu będą ważne tylko w trakcie istnienia łańcucha wymiany. Po zniszczeniu łańcucha wymiany wskaźniki będą uznawane za wiszące.

XrDepthSwapchainImageANDROID reprezentuje obrazy głębi z odczytywalnego XrDepthSwapchainANDROID , przydzielone zgodnie z opisem w XrDepthSwapchainCreateInfoANDROID :: resolution i XrDepthSwapchainCreateInfoANDROID :: createFlags podczas wywoływania xrCreateDepthSwapchainANDROID . W przypadku każdego obrazu głębi:

  • Wartości obrazu są ułożone w pamięci w kolejności wierszowej bez dopełnienia między wierszami.
  • Pierwsza wartość to lewy górny róg, a ostatnia – prawy dolny róg.
  • Rozmiar wskazywanej pamięci jest określany przez wartość xrEnumerateDepthSwapchainImagesANDROID i ustawiany przez XrDepthSwapchainCreateInfoANDROID :: resolution podczas wywoływania xrCreateDepthSwapchainANDROID . Jeśli na przykład XrDepthSwapchainCreateInfoANDROID :: resolution ma wartość XR_DEPTH_CAMERA_RESOLUTION_160x160_ANDROID, obrazy głębi będą miały rozmiar 2*160*160*sizeof(float) .
  • Wartość parametru rawDepthImage musi wynosić NULL, jeśli XrDepthSwapchainCreateInfoANDROID :: createFlags nie zawiera XR_DEPTH_SWAPCHAIN_CREATE_RAW_DEPTH_IMAGE_BIT_ANDROID .
  • Wartość parametru rawDepthConfidenceImage musi wynosić NULL, jeśli XrDepthSwapchainCreateInfoANDROID :: createFlags nie zawiera XR_DEPTH_SWAPCHAIN_CREATE_RAW_CONFIDENCE_IMAGE_BIT_ANDROID .
  • Wartość parametru smoothDepthImage musi wynosić NULL, jeśli XrDepthSwapchainCreateInfoANDROID :: createFlags nie zawiera XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_DEPTH_IMAGE_BIT_ANDROID .
  • Wartość parametru smoothDepthImage musi wynosić NULL, jeśli XrDepthSwapchainCreateInfoANDROID :: createFlags nie zawiera XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_CONFIDENCE_IMAGE_BIT_ANDROID .

Prawidłowe użycie (domyślne)

Funkcja xrAcquireDepthSwapchainImagesANDROID jest zdefiniowana w ten sposób:

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

Opisy parametrów

Aplikacje mogą używać funkcji xrAcquireDepthSwapchainImagesANDROID, aby uzyskać najnowszy dostępny indeks obrazu łańcucha wymiany, czyli XrDepthAcquireResultANDROID :: acquiredIndex, do tablicy XrDepthSwapchainImageANDROID wyliczanej przez xrEnumerateDepthSwapchainImagesANDROID. Zwracany obiekt XrDepthAcquireResultANDROID zawiera też inne informacje, takie jak pole widzenia i pozycja, które są niezbędne do interpretacji danych o głębi. Odczytywanie z uzyskanego miejsca w tablicy obrazów jest bezpieczne do momentu następnego wywołania funkcji xrAcquireDepthSwapchainImagesANDROID .

Między każdą parą wywołań xrBeginFrame i xrEndFrame w sesji nie może być więcej niż jedno wywołanie funkcji xrAcquireDepthSwapchainImagesANDROID.

  • Środowisko wykonawcze może blokować, jeśli wcześniej uzyskane obrazy łańcucha wymiany są nadal używane przez środowisko wykonawcze.
  • Środowisko wykonawcze musi zwrócić XR_ERROR_CALL_ORDER_INVALID, jeśli funkcja xrAcquireDepthSwapchainImagesANDROID zostanie wywołana przed funkcją xrBeginFrame lub po funkcji xrEndFrame .
  • Środowisko wykonawcze musi zwracać XR_ERROR_LIMIT_REACHED, jeśli funkcja xrAcquireDepthSwapchainImagesANDROID jest wywoływana więcej niż raz na klatkę, czyli w trakcie sesji po wywołaniu funkcji xrBeginFrame, która nie ma powiązanej funkcji xrEndFrame.
  • Środowisko wykonawcze może zwrócić wartość XR_ERROR_DEPTH_NOT_AVAILABLE_ANDROID, jeśli dane o głębokości środowiska nie są jeszcze dostępne. W takim przypadku aplikacja powinna ponownie wywołać funkcję xrAcquireDepthSwapchainImagesANDROID w późniejszej klatce.

Prawidłowe użycie (domyślne)

Kody zwrotne

Sukces

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Błąd

  • 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

Struktura XrDepthAcquireInfoANDROID jest zdefiniowana w ten sposób:

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

Opisy członków

  • type to XrStructureType tej struktury.
  • next to NULL lub wskaźnik do następnej struktury w łańcuchu struktur. W podstawowej specyfikacji OpenXR ani w tym rozszerzeniu nie zdefiniowano takich struktur.
  • space to XrSpace określająca ramę odniesienia zwróconej pozycji w XrDepthAcquireResultANDROID :: views .
  • displayTime to XrTime określający czas użyty do obliczenia pozycji dla zwróconej pozycji w XrDepthAcquireResultANDROID :: views . Aplikacje powinny przekazywać przewidywany czas wyświetlania bieżącej ramki.

Prawidłowe użycie (domyślne)

Struktura XrDepthAcquireResultANDROID jest zdefiniowana w ten sposób:

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

Opisy członków

  • type to XrStructureType tej struktury.
  • next to NULL lub wskaźnik do następnej struktury w łańcuchu struktur. W podstawowej specyfikacji OpenXR ani w tym rozszerzeniu nie zdefiniowano takich struktur.
  • acquiredIndex to indeks uzyskanej tekstury w tablicy XrDepthSwapchainImageANDROID wyliczanej przez funkcję xrEnumerateDepthSwapchainImagesANDROID .
  • exposureTimestamp to XrTime określający czas, w którym została zarejestrowana mapa głębi.
  • views to tablica dwóch obiektów XrDepthViewANDROID , po jednym na każde oko. Indeks 0 to lewe oko, a indeks 1 to prawe oko.

Prawidłowe użycie (domyślne)

Struktura XrDepthViewANDROID jest zdefiniowana w ten sposób:

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

Opisy członków

  • type to XrStructureType tej struktury.
  • next to NULL lub wskaźnik do następnej struktury w łańcuchu struktur. W podstawowej specyfikacji OpenXR ani w tym rozszerzeniu nie zdefiniowano takich struktur.
  • fov to XrFovf określający pole widzenia użyte do wygenerowania tego widoku. Widok nigdy nie jest odwracany w poziomie ani w pionie.
  • pose to XrPosef określający pozę, z której wyrenderowano mapę głębi. Ramę odniesienia określa się w strukturze XrDepthAcquireInfoANDROID .

Prawidłowe użycie (domyślne)

Przykładowy kod śledzenia głębi

Poniższy przykładowy kod pokazuje, jak uzyskać obrazy głębi i użyć wartości głębi do mapowania współrzędnych obrazu głębi na przestrzeń sceny.

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

Nowe typy obiektów

Nowe polecenia

Nowe struktury

Nowe wartości w polu enum

Nowe maski bitowe

Nowe stałe wyliczeniowe

  • XR_ANDROID_DEPTH_TEXTURE_EXTENSION_NAME
  • XR_ANDROID_depth_texture_SPEC_VERSION

  • Rozszerzanie XrObjectType :

    • XR_OBJECT_TYPE_DEPTH_SWAPCHAIN_ANDROID

  • Rozszerzanie XrResult :

    • XR_ERROR_DEPTH_NOT_AVAILABLE_ANDROID

  • Rozszerzanie 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

Problemy

Historia zmian

  • Wersja 1, 9 września 2024 r. (Levana Chen)

    • Wstępny opis rozszerzenia