XR_ANDROID_depth_texture

Name String

XR_ANDROID_depth_texture

Tipo de extensión

Extensión de instancia

Número de extensión registrado

703

Revisión

1

Estado de ratificación

No ratificado

Dependencias de extensiones y versiones

OpenXR 1.0

Fecha de la última modificación

2024-09-11

Estado de la IP

No hay reclamos de IP conocidos.

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 real alrededor del visor y consulte las resoluciones de profundidad admitidas en el momento de la creación.

Esta extensión está diseñada para exponer la profundidad sin procesar y suavizada para la oclusión, las pruebas de posicionamiento y otras tareas específicas que aprovechan la geometría precisa de la escena, por ejemplo, la detección de rostros falsificados.

Nota

El entorno de ejecución genera los mapas de profundidad y los comparte con la aplicación a través de XrDepthSwapchainANDROID . El entorno de ejecución no debe cambiar las resoluciones de las imágenes 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 reducción de muestreo para mitigar las inquietudes relacionadas con la información de identificación personal (IIP). Las aplicaciones para Android deben tener el permiso android.permission.SCENE_UNDERSTANDING_FINE en su manifiesto, ya que esta extensión expone la geometría del entorno. El permiso android.permission.SCENE_UNDERSTANDING_FINE se considera 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 un seguimiento de la profundidad extendiendo XrSystemProperties con la estructura XrSystemDepthTrackingPropertiesANDROID cuando se llama a xrGetSystemProperties .

Si un entorno de ejecución devuelve XR_FALSE para supportsDepthTracking , el entorno de ejecución debe devolver XR_ERROR_FEATURE_UNSUPPORTED de xrCreateDepthSwapchainANDROID .

Uso válido (implícito)

Resoluciones de profundidad de consulta

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 de 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 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 que admite la sesión actual. Las resoluciones de profundidad deben estar en orden de preferencia de tiempo de ejecución, de mayor a menor. La aplicación debe usar la preferencia más alta que admita para obtener un rendimiento y una calidad óptimos.

Los entornos de ejecución deben siempre devolver contenidos de búfer idénticos de 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 estar habilitada antes de llamar a xrEnumerateDepthResolutionsANDROID.
  • session debe ser un controlador 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 resolutionCapacityInput XrDepthCameraResolutionANDROID.

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 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 × 160.
  • XR_DEPTH_CAMERA_RESOLUTION_320x320_ANDROID: La resolución de las imágenes de profundidad y confianza es de 320 × 320.

Crea una cadena de intercambio de profundidad

XR_DEFINE_HANDLE(XrDepthSwapchainANDROID)

Un XrDepthSwapchainANDROID es un controlador 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 la 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 controlador 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 entorno de ejecución debe devolver XR_ERROR_FEATURE_UNSUPPORTED si el sistema no admite el seguimiento de profundidad.
  • El entorno de ejecución debe devolver XR_ERROR_PERMISSION_INSUFFICIENT si no se otorgaron los permisos necesarios a la app de llamadas.
  • El entorno de ejecución debe devolver XR_ERROR_VALIDATION_FAILURE si no se admite la resolución de profundidad especificada en XrDepthSwapchainCreateInfoANDROID.
  • El entorno de ejecución debería crear imágenes de confianza de profundidad solo cuando se configuren los bits correspondientes para createInfo en la creación de la cadena de intercambio.

El controlador de la cadena de intercambio de profundidad que se muestra puede usarse posteriormente en llamadas a la API. El controlador XrDepthSwapchainANDROID debe liberarse con el tiempo 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 entorno 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 controlador secundario debe sincronizarse de forma externa.

Códigos de retorno

Listo

  • XR_SUCCESS

Falla

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_RUNTIME_FAILURE

Cómo acceder a las 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 obtendrán las imágenes.
  • depthImageCapacityInput es la capacidad del array depthImages, o 0 para indicar una solicitud de recuperación de la capacidad requerida.
  • depthImageCountOutput es un puntero al recuento de depthImages escritos o un puntero a la capacidad requerida en 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 el ciclo de vida de XrDepthSwapchainANDROID . Esta función se comporta de manera análoga a xrEnumerateSwapchainImages .

El entorno de ejecución debe siempre devolver contenidos de búfer idénticos de esta enumeración durante el ciclo de vida 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 entorno de ejecución. Los valores se expresan en 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 está infinitamente lejos,
  • 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 entorno 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 entorno de ejecución. Los valores se expresan en metros. Valores especiales: 0.0 indica un píxel de profundidad no válido o vacío en la profundidad suavizada, Inf indica una profundidad conocida que está efectivamente infinitamente lejos.
  • smoothDepthConfidenceImage es NULL o el puntero a las imágenes de confianza de profundidad suavizada para las vistas izquierda y derecha asignadas por el entorno 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 destruya 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 cadena de intercambio más reciente disponible, es decir, XrDepthAcquireResultANDROID :: acquiredIndex, en el array XrDepthSwapchainImageANDROID enumerado por xrEnumerateDepthSwapchainImagesANDROID. El XrDepthAcquireResultANDROID que se devuelve también contiene otra información, como el campo visual y la pose, 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 entorno de ejecución puede bloquearse si el entorno de ejecución aún usa imágenes de la cadena de intercambio adquiridas anteriormente.
  • El entorno de ejecución debe devolver XR_ERROR_CALL_ORDER_INVALID si se llama a xrAcquireDepthSwapchainImagesANDROID antes de xrBeginFrame o después de xrEndFrame .
  • El entorno 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 haya tenido un xrEndFrame asociado.
  • El entorno de ejecución puede mostrar 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 debería 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 pose que se muestra en XrDepthAcquireResultANDROID :: views .
  • displayTime es un XrTime que especifica el tiempo que se usa para calcular la pose de la pose que se muestra en XrDepthAcquireResultANDROID :: views . Las aplicaciones deben pasar el 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 hora en la que se capturó el mapa de profundidad.
  • views es un array de dos XrDepthViewANDROID , uno para cada ojo, donde 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 usa para generar esta vista. La vista nunca se voltea horizontal ni verticalmente.
  • 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)

Código de ejemplo para el seguimiento de profundidad

En el siguiente código de ejemplo, 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

Estructuras nuevas

Enums nuevas

Máscaras de bits nuevas

Nuevas constantes de enum

  • XR_ANDROID_DEPTH_TEXTURE_EXTENSION_NAME
  • XR_ANDROID_depth_texture_SPEC_VERSION

  • Extiende XrObjectType :

    • XR_OBJECT_TYPE_DEPTH_SWAPCHAIN_ANDROID

  • Extiende XrResult :

    • XR_ERROR_DEPTH_NOT_AVAILABLE_ANDROID

  • Extiende 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, 9 de septiembre de 2024 (Levana Chen)

    • Descripción inicial de la extensión