Rozszerzenie OpenXR XR_ANDROID_depth_texture

Ciąg znaków nazwy

XR_ANDROID_depth_texture

Typ rozszerzenia

Rozszerzenie instancji

Zarejestrowany numer wewnętrzny

703

Wersja

1

Zależności rozszerzeń i wersji

OpenXR 1.0

Data ostatniej modyfikacji

2024-09-11

Stan adresu IP

Brak znanych roszczeń dotyczących praw autorskich do treści objętych ochroną prawną.

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 środowiska rzeczywistego wokół gogli oraz zapytanie o obsługiwane rozdzielczości głębi podczas tworzenia.

To rozszerzenie ma na celu udostępnienie surowych i gładkich głębi dla zasłonięcia, testów uderzeń i innych konkretnych zadań, które wykorzystują dokładną geometrię sceny, na przykład wykrywanie fałszywych twarzy.

Sprawdzanie możliwości systemu

Struktura XrSystemDepthTrackingPropertiesANDROID jest zdefiniowana w ten sposób:

typedef struct XrSystemDepthTrackingPropertiesANDROID {
    XrStructureType    type;
    const 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 struktury. Nie ma żadnych takich struktur zdefiniowanych w podstawowej wersji OpenXR ani w tym rozszerzeniu.
  • supportsDepthTracking to XrBool32 wskazujący, czy obecny 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.

Prawidłowe użycie (domyślne)

Rozwiązania problemów z 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óry wymienia obsługiwane rozdzielczości głębi.
  • resolutionCapacityInput to pojemność resolutions, a 0 to wymagana pojemność.
  • resolutionCountOutput to wskaźnik do liczby zapisanych elementów uint64_t resolutions lub wskaźnik do wymaganej pojemności w przypadku, gdy resolutionCapacityInput jest niewystarczająca.
  • resolutions to wskaźnik do tablicy XrDepthCameraResolutionANDROID, ale może być NULL, jeśli resolutionCapacityInput = 0.
  • Szczegółowe informacje o pobieraniu wymaganego rozmiaru resolutions znajdziesz w sekcji Parametry rozmiaru bufora.

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 w czasie wykonywania. Aplikacja powinna używać najwyższego obsługiwanego przez nią ustawienia, aby zapewnić optymalną wydajność i jakość.

Prawidłowe użycie (domyślne)

Kody zwrotne

Gotowe

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Błąd

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_VALIDATION_FAILURE
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_SIZE_INSUFFICIENT

Enumeracja 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
    } XrDepthCameraResolutionANDROID;

Opisy wyliczanych

  • XR_DEPTH_CAMERA_RESOLUTION_80x80_ANDROID – rozdzielczość obrazów głębi i pewności siebie to 80 x 80.
  • XR_DEPTH_CAMERA_RESOLUTION_160x160_ANDROID – rozdzielczość obrazów głębi i zaufania wynosi 160 × 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 głębokości swapchain.

Funkcja xrCreateDepthSwapchainANDROID jest zdefiniowana w ten sposób: 

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

Opisy parametrów

Aplikacja może użyć funkcji xrCreateDepthSwapchainANDROID do utworzenia wymiany głębi, która zarządza obrazami głębi i pewności.

Zwrócony identyfikator zasobnika swapchain może być później używany w wywołaniach interfejsu API. Musi zostać ostatecznie zwolniony uchwyt XrDepthSwapchainANDROID za pomocą funkcji xrDestroyDepthSwapchainANDROID.

Prawidłowe użycie (domyślne)

Kody zwrotne

Gotowe

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Błąd

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_OUT_OF_MEMORY
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_LIMIT_REACHED

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 udostępnia opcje tworzenia dla XrDepthSwapchainANDROID, gdy zostanie przekazana do funkcji xrCreateDepthSwapchainANDROID.

Prawidłowe użycie (domyślne)

Ustawienie XrDepthSwapchainCreateFlagsANDROID określa opcje tworzenia dla 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;

Funkcja xrDestroyDepthSwapchainANDROID jest zdefiniowana w ten sposób: 

XrResult xrDestroyDepthSwapchainANDROID(
    XrDepthSwapchainANDROID                     swapchain);

Opisy parametrów

Funkcja xrDestroyDepthSwapchainANDROID niszczy sekwencję zamiany głębi.

Prawidłowe użycie (domyślne)

Bezpieczeństwo wątków

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

Kody zwrotne

Gotowe

  • 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, a 0 oznacza prośbę o pobranie wymaganej przepustowoś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 = 0.
  • Szczegółowe informacje o pobieraniu wymaganego rozmiaru depthImages znajdziesz w sekcji Parametry rozmiaru bufora.

xrEnumerateDepthSwapchainImagesANDROID wypełnia tablicę struktur XrDepthSwapchainImageANDROID. Zasoby będą stałe i ważne przez cały okres istnienia XrDepthSwapchainANDROID. Ta funkcja działa podobnie do funkcji xrEnumerateSwapchainImages.

Prawidłowe użycie (domyślne)

Kody zwrotne

Gotowe

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Błąd

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_VALIDATION_FAILURE
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_SIZE_INSUFFICIENT

Struktura XrDepthSwapchainImageANDROID jest zdefiniowana jako: 

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 struktury. Nie ma żadnych takich struktur zdefiniowanych w podstawowej wersji OpenXR ani w tym rozszerzeniu.
  • rawDepthImage to NULL lub wskaźnik do nieprzetworzonych obrazów głębi dla obu widoków (lewego i prawego). Wartości mają jednostki miary metryczne. Wartości specjalne: 0.0 wskazuje nieprawidłowy lub pusty piksel głębi w głębi surowej, Inf wskazuje znaną głębię, która jest w efekcie nieskończenie daleko,
  • rawDepthConfidenceImage to NULL lub wskaźnik do surowych obrazów głębi dla obu widoków (lewego i prawego).
  • smoothDepthImage to NULL lub wskaźnik do wygładzania obrazów głębi zarówno z lewej, jak i z prawej strony. Wartości mają jednostki miary metryczne. Wartości specjalne: 0.0 wskazuje nieprawidłowy lub pusty piksel głębi w płynnej głębi, Inf wskazuje znaną głębię, która jest w praktyce nieskończenie odległa.
  • smoothDepthConfidenceImage to NULL lub wskaźnik do wygładzania obrazów z głębią w przypadku lewego i prawego widoku.

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

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 do pobierania najnowszego dostępnego indeksu obrazu swapchain, np. XrDepthAcquireResultANDROID::acquiredIndex, do tablicy XrDepthSwapchainImageANDROID zliczanej przez funkcję xrEnumerateDepthSwapchainImagesANDROID. Zwrócony obiekt XrDepthAcquireResultANDROID zawiera też inne informacje, takie jak pole widzenia i postawa, które są niezbędne do interpretacji danych głębi. Dozwolone jest odczytywanie z zajętego slotu w tablicy obrazów do momentu następnego wywołania funkcji xrAcquireDepthSwapchainImagesANDROID.

Musi być co najwyżej jedno wywołanie funkcji xrAcquireDepthSwapchainImagesANDROID między każdą parą odpowiednich wywołań funkcji xrBeginFrame i xrEndFrame w sesji.

Prawidłowe użycie (domyślne)

Kody zwrotne

Gotowe

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Błąd

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_VALIDATION_FAILURE
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_DEPTH_NOT_AVAILABLE_ANDROID
  • XR_ERROR_CALL_ORDER_INVALID
  • XR_ERROR_LIMIT_REACHED
  • XR_ERROR_TIME_INVALID

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 struktury. Nie ma żadnych takich struktur zdefiniowanych w podstawowej wersji OpenXR ani w tym rozszerzeniu.
  • space to XrSpace określający układ odniesienia zwróconej pozycji w XrDepthAcquireResultANDROID::views.
  • displayTime to XrTime określający czas użyty do obliczenia powracanej pozycji w XrDepthAcquireResultANDROID::views. Aplikacje powinny przekazać 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 struktury. Nie ma żadnych takich struktur zdefiniowanych w podstawowej wersji OpenXR ani w tym rozszerzeniu.
  • acquiredIndex to indeks tekstury w tablicy XrDepthSwapchainImageANDROID zliczanej przez funkcję xrEnumerateDepthSwapchainImagesANDROID.
  • exposureTimestamp to XrTime określający czas, w którym została utworzona mapa głębi.
  • views to tablica dwóch XrDepthViewANDROID, po jednej dla każdego oka, gdzie indeks 0 to lewe oko, a indeks 1 to prawe oko.

Prawidłowe użycie (domyślne)

Struktura XrDepthViewANDROID jest zdefiniowana jako: 

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 struktury. Nie ma żadnych takich struktur zdefiniowanych w podstawowej wersji OpenXR ani w tym rozszerzeniu.
  • 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 została wyrenderowana mapa głębi. Ramka odniesienia jest określona w XrDepthAcquireInfoANDROID.

Prawidłowe użycie (domyślne)

Przykładowy kod śledzenia głębi

Poniższy przykładowy kod pokazuje, jak pobierać obrazy głębi.

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

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

  // Use the resolution supported by the runtime.
  .resolution = supportedDepthResolution,
};

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(xrAcquireDepthImagesANDROID(
        depthSwapchain, &acquireInfo, &acquireResult));

    // Each value in a depth image corresponds to a point in the real world.
    // The sample code in this section 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.acquireIndex];

    // Assume supported resolution is XR_DEPTH_CAMERA_RESOLUTION_160x160_ANDROID.
    const int imageResolution = 160;
    int imageY = // value in [0, imageResolution)
    int imageX = // value in [0, imageResolution)

    // Get depth value from left eye.
    // A right depth value would be 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 = (tanB + (tanU - tanB)*t)*depthL;

    XrPosef depthCameraPoseL = viewL.pose;
    // Transform posInCameraSpace by depthCameraPoseL

    // ...
    // Finish frame loop
    // ...
}

Nowe typy obiektów

Nowe stałe typu wyliczeniowego

Wyliczenie XrObjectType zostało rozszerzone o:

  • XR_OBJECT_TYPE_DEPTH_SWAPCHAIN_ANDROID

Wyliczenie XrResult zostało rozszerzone o:

  • XR_ERROR_DEPTH_NOT_AVAILABLE_ANDROID

Wyliczenie XrStructureType zostało rozszerzone o:

  • XR_TYPE_DEPTH_SWAPCHAIN_CREATE_INFO_ANDROID
  • XR_TYPE_DEPTH_VIEW_ANDROID
  • XR_TYPE_DEPTH_ACQUIRE_INFO_ANDROID
  • XR_TYPE_DEPTH_ACQUIRE_RESULT_ANDROID
  • XR_TYPE_SYSTEM_DEPTH_TRACKING_PROPERTIES_ANDROID
  • XR_TYPE_DEPTH_SWAPCHAIN_IMAGE_ANDROID

Nowe typy wyliczeniowe

Nowe struktury

Nowe funkcje

Problemy

Historia zmian

  • Wersja 1, 9 września 2024 r. (Levana Chen)
    • Początkowy opis rozszerzenia

OpenXR™ i logo OpenXR są znakami towarowymi należącymi do The Khronos Group Inc. i zarejestrowanymi jako znak towarowy w Chinach, Unii Europejskiej, Japonii i Wielkiej Brytanii.