XR_ANDROID_depth_texture

Cadena de nombre

XR_ANDROID_depth_texture

Tipo de extensión

Extensión de la instancia

Número de extensión registrado

703

Revisión

1

Estado de ratificación

No se ratificó

Dependencias de extensiones y versiones

OpenXR 1.0

Fecha de la última modificación

2024-09-11

Estado de la IP

No hay reclamos conocidos por IP.

Colaboradores

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

Descripción general

Esta extensión permite que la aplicación solicite mapas de profundidad del entorno del mundo real alrededor del visor y consulte las resoluciones de profundidad admitidas en el momento de la creación.

Esta extensión tiene como objetivo exponer la profundidad sin procesar y suavizada para la oclusión, las pruebas de impacto y otras tareas específicas que aprovechan la geometría precisa de la escena, por ejemplo, la detección de rostros falsificados.

Nota

El tiempo de ejecución genera los mapas de profundidad y los comparte con la aplicación a través de XrDepthSwapchainANDROID . El tiempo de ejecución no debe cambiar las resoluciones de la imagen de profundidad que se devuelven a través de xrEnumerateDepthResolutionsANDROID durante el ciclo de vida de la aplicación.

Permisos

Esta extensión expone una textura de profundidad con una reducción de la muestra para mitigar las preocupaciones relacionadas con la información de identificación personal (PII). Las aplicaciones para Android deben tener el permiso android.permission.SCENE_UNDERSTANDING_FINE incluido en su manifiesto, ya que esta extensión expone la geometría del entorno. El permiso android.permission.SCENE_UNDERSTANDING_FINE se considera un permiso peligroso. La aplicación debe solicitar el permiso durante el tiempo de ejecución para usar estas funciones:

(nivel de protección: peligroso)

Inspecciona la capacidad del sistema

La estructura XrSystemDepthTrackingPropertiesANDROID se define de la siguiente manera:

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

Descripciones de los miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructuras. No se definen tales estructuras en OpenXR principal ni en esta extensión.
  • supportsDepthTracking es un XrBool32 que indica si el sistema actual admite el seguimiento de profundidad.

Una aplicación puede inspeccionar si el sistema es capaz de realizar el seguimiento de profundidad extendiendo XrSystemProperties con la estructura XrSystemDepthTrackingPropertiesANDROID cuando llama a xrGetSystemProperties .

Si y solo si un tiempo de ejecución devuelve XR_FALSE para supportsDepthTracking , el tiempo de ejecución debe devolver XR_ERROR_FEATURE_UNSUPPORTED de xrCreateDepthSwapchainANDROID .

Uso válido (implícito)

Resoluciones de profundidad de la búsqueda

La función xrEnumerateDepthResolutionsANDROID se define de la siguiente manera:

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

Descripciones de los parámetros

  • session es el XrSession que enumera las resoluciones de profundidad admitidas.
  • resolutionCapacityInput es la capacidad del resolutions o 0 para recuperar la capacidad requerida.
  • resolutionCountOutput es un puntero al recuento de uint64_t resolutions escritos o un puntero a la capacidad requerida en el caso de que resolutionCapacityInput sea insuficiente.
  • resolutions es un puntero a un array de XrDepthCameraResolutionANDROID , pero puede ser NULL si resolutionCapacityInput es 0 .
  • Consulta la sección Parámetros de tamaño del búfer para obtener una descripción detallada de cómo recuperar el tamaño de resolutions requerido.

xrEnumerateDepthResolutionsANDROID enumera las resoluciones de profundidad admitidas por la sesión actual. Las resoluciones de profundidad deben estar ordenadas de mayor a menor preferencia de tiempo de ejecución. La aplicación debe usar la preferencia más alta que admita para obtener un rendimiento y una calidad óptimos.

Los tiempos de ejecución deben siempre devolver contenido de búfer idéntico desde esta enumeración durante el ciclo de vida de la sesión.

Uso válido (implícito)

  • La extensión XR_ANDROID_depth_texture debe habilitarse antes de llamar a xrEnumerateDepthResolutionsANDROID.
  • session debe ser un identificador de XrSession válido
  • resolutionCountOutput debe ser un puntero a un valor uint32_t.
  • Si resolutionCapacityInput no es 0 , resolutions debe ser un puntero a un array de valores XrDepthCameraResolutionANDROID de resolutionCapacityInput.

Códigos de retorno

Listo

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Falla

  • 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

La enumeración XrDepthCameraResolutionANDROID describe las resoluciones de profundidad admitidas cuando se crea un 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;

Descripciones de los enumerantes

  • XR_DEPTH_CAMERA_RESOLUTION_80x80_ANDROID: La resolución de las imágenes de profundidad y confianza es de 80 × 80.
  • XR_DEPTH_CAMERA_RESOLUTION_160x160_ANDROID: La resolución de las imágenes de profundidad y confianza es de 160 x 160.
  • XR_DEPTH_CAMERA_RESOLUTION_320x320_ANDROID: La resolución de las imágenes de profundidad y confianza es de 320 x 320.

Crea una cadena de intercambio de profundidad

XR_DEFINE_HANDLE(XrDepthSwapchainANDROID)

Un XrDepthSwapchainANDROID es un identificador de cadena de intercambio de profundidad.

La función xrCreateDepthSwapchainANDROID se define de la siguiente manera:

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

Descripciones de los parámetros

  • session es el XrSession que crea la cadena de intercambio de profundidad.
  • createInfo es un puntero a una estructura XrDepthSwapchainCreateInfoANDROID que contiene parámetros que se usarán para crear la cadena de intercambio.
  • swapchain es un puntero a un identificador en el que se devuelve el XrDepthSwapchainANDROID creado.

La aplicación puede usar la función xrCreateDepthSwapchainANDROID para crear una cadena de intercambio de profundidad que administre las imágenes de profundidad y confianza.

  • El tiempo de ejecución debe devolver XR_ERROR_FEATURE_UNSUPPORTED si el sistema no admite el seguimiento de profundidad.
  • El tiempo de ejecución debe devolver XR_ERROR_PERMISSION_INSUFFICIENT si no se otorgaron los permisos necesarios a la app de llamada.
  • El tiempo de ejecución debe devolver XR_ERROR_VALIDATION_FAILURE si no se admite la resolución de profundidad especificada en XrDepthSwapchainCreateInfoANDROID.
  • El tiempo de ejecución solo debe crear imágenes de confianza de profundidad cuando los bits correspondientes estén configurados para el createInfo en la creación de la cadena de intercambio.

El identificador de cadena de intercambio de profundidad que se devuelve puede usarse posteriormente en llamadas a la API. El controlador XrDepthSwapchainANDROID debe liberarse eventualmente a través de la función xrDestroyDepthSwapchainANDROID.

Uso válido (implícito)

Códigos de retorno

Listo

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Falla

  • 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

La estructura XrDepthSwapchainCreateInfoANDROID se define de la siguiente manera:

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

Descripciones de los miembros

La estructura XrDepthSwapchainCreateInfoANDROID proporciona opciones de creación para XrDepthSwapchainANDROID cuando se pasa a xrCreateDepthSwapchainANDROID .

Uso válido (implícito)

XrDepthSwapchainCreateFlagsANDROID especifica las opciones de creación para XrDepthSwapchainANDROID .

typedef XrFlags64 XrDepthSwapchainCreateFlagsANDROID;

Los bits válidos para XrDepthSwapchainCreateFlagsANDROID se definen con XrDepthSwapchainCreateFlagBitsANDROID , que se especifica de la siguiente manera:

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

Descripciones de las marcas

  • XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_DEPTH_IMAGE_BIT_ANDROID: Indica que la cadena de intercambio proporcionará imágenes de profundidad fluidas.
  • XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_CONFIDENCE_IMAGE_BIT_ANDROID: Indica que la cadena de intercambio proporcionará imágenes de confianza de profundidad fluidas.
  • XR_DEPTH_SWAPCHAIN_CREATE_RAW_DEPTH_IMAGE_BIT_ANDROID: Indica que la cadena de intercambio proporcionará imágenes de profundidad sin procesar.
  • XR_DEPTH_SWAPCHAIN_CREATE_RAW_CONFIDENCE_IMAGE_BIT_ANDROID: Indica que la cadena de intercambio proporcionará imágenes de confianza de profundidad sin procesar.

La función xrDestroyDepthSwapchainANDROID se define de la siguiente manera:

XrResult xrDestroyDepthSwapchainANDROID(
    XrDepthSwapchainANDROID                     swapchain);

Descripciones de los parámetros

La función xrDestroyDepthSwapchainANDROID destruye la cadena de intercambio de profundidad. Después de esta llamada, el tiempo de ejecución puede liberar toda la memoria y los recursos relacionados.

Uso válido (implícito)

Seguridad de subprocesos

  • El acceso a swapchain y a cualquier identificador secundario debe sincronizarse de forma externa.

Códigos de retorno

Listo

  • XR_SUCCESS

Falla

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID

Cómo acceder a texturas de profundidad

La función xrEnumerateDepthSwapchainImagesANDROID se define de la siguiente manera:

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

Descripciones de los parámetros

  • depthSwapchain es el XrDepthSwapchainANDROID del que se obtienen las imágenes.
  • depthImageCapacityInput es la capacidad del array depthImages o 0 para indicar una solicitud para recuperar la capacidad requerida.
  • depthImageCountOutput es un puntero al recuento de depthImages escritos o un puntero a la capacidad requerida en el caso de que depthImageCapacityInput sea insuficiente.
  • depthImages es un puntero a un array de estructuras XrDepthSwapchainImageANDROID. Puede ser NULL si depthImageCapacityInput es 0.
  • Consulta la sección Parámetros de tamaño del búfer para obtener una descripción detallada de cómo recuperar el tamaño de depthImages requerido.

xrEnumerateDepthSwapchainImagesANDROID completa un array de estructuras XrDepthSwapchainImageANDROID. Los recursos deben ser constantes y válidos durante la vida útil de XrDepthSwapchainANDROID . Esta función se comporta de manera análoga a xrEnumerateSwapchainImages .

El tiempo de ejecución debe siempre devolver contenido de búfer idéntico desde esta enumeración durante la vida útil de la cadena de intercambio.

Uso válido (implícito)

Códigos de retorno

Listo

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Falla

  • 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

La estructura XrDepthSwapchainImageANDROID se define de la siguiente manera:

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

Descripciones de los miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructuras. No se definen tales estructuras en OpenXR principal ni en esta extensión.
  • rawDepthImage es NULL o el puntero a las imágenes de profundidad sin procesar para las vistas izquierda y derecha asignadas por el tiempo de ejecución. Los valores tienen unidades de metros. Valores especiales: 0.0 indica un píxel de profundidad no válido o vacío en la profundidad sin procesar, Inf indica una profundidad conocida que es infinitamente lejana,
  • rawDepthConfidenceImage es NULL o el puntero a las imágenes de confianza de profundidad sin procesar para las vistas izquierda y derecha asignadas por el tiempo de ejecución.
  • smoothDepthImage es NULL o el puntero a las imágenes de profundidad suavizadas para las vistas izquierda y derecha asignadas por el tiempo de ejecución. Los valores tienen unidades de metros. Valores especiales: 0.0 indica un píxel de profundidad no válido o vacío en la profundidad suavizada, y Inf indica una profundidad conocida que es infinitamente lejana.
  • smoothDepthConfidenceImage es NULL o el puntero a las imágenes de confianza de profundidad suavizadas para las vistas izquierda y derecha asignadas por el tiempo de ejecución.

Los punteros del búfer de imágenes solo serán válidos durante la vida útil de la cadena de intercambio. Una vez que se destruye la cadena de intercambio, los punteros se considerarán colgantes.

XrDepthSwapchainImageANDROID representa las imágenes de profundidad de un XrDepthSwapchainANDROID legible , asignado como se describe en XrDepthSwapchainCreateInfoANDROID :: resolution y XrDepthSwapchainCreateInfoANDROID :: createFlags mientras se llama a xrCreateDepthSwapchainANDROID . Para cada imagen de profundidad, haz lo siguiente:

Uso válido (implícito)

La función xrAcquireDepthSwapchainImagesANDROID se define de la siguiente manera:

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

Descripciones de los parámetros

Las aplicaciones pueden usar la función xrAcquireDepthSwapchainImagesANDROID para adquirir el índice de imagen de la cadena de intercambio disponible más reciente, es decir, XrDepthAcquireResultANDROID :: acquiredIndex, en el array XrDepthSwapchainImageANDROID enumerado por xrEnumerateDepthSwapchainImagesANDROID. El objeto XrDepthAcquireResultANDROID que se devuelve también contiene otra información, como el campo visual y la postura, que son necesarios para interpretar los datos de profundidad. Es seguro leer desde la ranura adquirida en el array de imágenes hasta la próxima llamada a xrAcquireDepthSwapchainImagesANDROID .

No debe haber más de una llamada a xrAcquireDepthSwapchainImagesANDROID entre cualquier par de llamadas correspondientes a xrBeginFrame y xrEndFrame en una sesión.

  • El tiempo de ejecución puede bloquearse si el tiempo de ejecución sigue usando imágenes de cadena de intercambio adquiridas previamente.
  • El tiempo de ejecución debe devolver XR_ERROR_CALL_ORDER_INVALID si se llama a xrAcquireDepthSwapchainImagesANDROID antes de xrBeginFrame o después de xrEndFrame .
  • El tiempo de ejecución debe devolver XR_ERROR_LIMIT_REACHED si se llama a xrAcquireDepthSwapchainImagesANDROID más de una vez por fotograma, es decir, en una sesión en ejecución, después de una llamada a xrBeginFrame que no tuvo un xrEndFrame asociado.
  • El tiempo de ejecución puede devolver XR_ERROR_DEPTH_NOT_AVAILABLE_ANDROID si los datos de profundidad del entorno aún no están disponibles. Si esto sucede, la aplicación debe volver a llamar a xrAcquireDepthSwapchainImagesANDROID en un fotograma posterior.

Uso válido (implícito)

Códigos de retorno

Listo

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Falla

  • 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

La estructura XrDepthAcquireInfoANDROID se define de la siguiente manera:

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

Descripciones de los miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructuras. No se definen tales estructuras en OpenXR principal ni en esta extensión.
  • space es un XrSpace que define el marco de referencia de la postura devuelta en XrDepthAcquireResultANDROID :: views .
  • displayTime es un XrTime que especifica el tiempo que se usa para calcular la postura de la postura devuelta en XrDepthAcquireResultANDROID :: views . Las aplicaciones deben pasar su tiempo de visualización previsto para el fotograma actual.

Uso válido (implícito)

La estructura XrDepthAcquireResultANDROID se define de la siguiente manera:

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

Descripciones de los miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructuras. No se definen tales estructuras en OpenXR principal ni en esta extensión.
  • acquiredIndex es el índice de la textura adquirida en el array XrDepthSwapchainImageANDROID enumerado por xrEnumerateDepthSwapchainImagesANDROID .
  • exposureTimestamp es el XrTime que especifica la fecha y hora en que se capturó el mapa de profundidad.
  • views es un array de dos XrDepthViewANDROID , uno para cada ojo, en el que el índice 0 es el ojo izquierdo y el índice 1 es el ojo derecho.

Uso válido (implícito)

La estructura XrDepthViewANDROID se define de la siguiente manera:

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

Descripciones de los miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructuras. No se definen tales estructuras en OpenXR principal ni en esta extensión.
  • fov es un XrFovf que especifica el campo visual que se usó para generar esta vista. La vista nunca se invierte de forma horizontal ni vertical.
  • pose es un XrPosef que especifica la pose desde la que se renderizó el mapa de profundidad. El marco de referencia se especifica en XrDepthAcquireInfoANDROID .

Uso válido (implícito)

Ejemplo de código para el seguimiento de profundidad

En el siguiente ejemplo de código, se muestra cómo adquirir imágenes de profundidad y usar valores de profundidad para asignar coordenadas de imágenes de profundidad al espacio de la escena.

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

Nuevos tipos de objetos

Comandos nuevos

Nuevas estructuras

Nuevas enumeraciones

Nuevas máscaras de bits

Nuevas constantes de enumeración

  • XR_ANDROID_DEPTH_TEXTURE_EXTENSION_NAME
  • XR_ANDROID_depth_texture_SPEC_VERSION

  • Extensión de XrObjectType :

    • XR_OBJECT_TYPE_DEPTH_SWAPCHAIN_ANDROID

  • Extensión de XrResult :

    • XR_ERROR_DEPTH_NOT_AVAILABLE_ANDROID

  • Extensión de 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

Problemas

Historial de versiones

  • Revisión 1, 2024-09-09 (Levana Chen)

    • Descripción inicial de la extensión