XR_ANDROID_depth_texture

String de nome

XR_ANDROID_depth_texture

Tipo de extensão

Extensão de instância

Número de ramal registrado

703

Revisão

1

Status de ratificação

Não ratificado

Dependências de extensão e versão

OpenXR 1.0

Data da última modificação

2024-09-11

Status do IP

Nenhuma reivindicação de PI conhecida.

Colaboradores

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

Visão geral

Essa extensão permite que o aplicativo solicite mapas de profundidade do ambiente real ao redor do headset e consulte as resoluções de profundidade compatíveis no momento da criação.

Essa extensão serve para expor a profundidade bruta e suave para oclusão, testes de hit e outras tarefas específicas que usam geometria de cena precisa, por exemplo, detecção de rostos falsos.

Observação

Os mapas de profundidade são gerados pelo ambiente de execução e compartilhados com o aplicativo usando XrDepthSwapchainANDROID . O ambiente de execução não pode mudar as resoluções de imagem de profundidade retornadas por xrEnumerateDepthResolutionsANDROID durante o ciclo de vida do aplicativo.

Permissões

Essa extensão expõe uma textura de profundidade reduzida para mitigar as preocupações com informações de identificação pessoal (PII). Os apps Android precisam ter a permissão android.permission.SCENE_UNDERSTANDING_FINE listada no manifesto, já que essa extensão expõe a geometria do ambiente. A permissão android.permission.SCENE_UNDERSTANDING_FINE é considerada perigosa. O aplicativo precisa solicitar a permissão no momento da execução para usar estas funções:

(nível de proteção: perigoso)

Inspecionar a capacidade do sistema

A estrutura XrSystemDepthTrackingPropertiesANDROID é definida como:

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

Descrições dos membros

  • type é o XrStructureType dessa estrutura.
  • next é NULL ou um ponteiro para a próxima estrutura em uma cadeia de estruturas. Nenhuma estrutura desse tipo é definida no OpenXR principal ou nesta extensão.
  • supportsDepthTracking é um XrBool32 que indica se o sistema atual é compatível com o rastreamento de profundidade.

Um aplicativo pode inspecionar se o sistema é capaz de rastrear a profundidade estendendo as XrSystemProperties com a estrutura XrSystemDepthTrackingPropertiesANDROID ao chamar xrGetSystemProperties .

Se, e somente se, um ambiente de execução retornar XR_FALSE para supportsDepthTracking, ele precisará retornar XR_ERROR_FEATURE_UNSUPPORTED de xrCreateDepthSwapchainANDROID .

Uso válido (implícito)

Resoluções de profundidade de consulta

A função xrEnumerateDepthResolutionsANDROID é definida como:

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

Descrições dos parâmetros

  • session é a XrSession que enumera as resoluções de profundidade compatíveis.
  • resolutionCapacityInput é a capacidade do resolutions ou 0 para recuperar a capacidade necessária.
  • resolutionCountOutput é um ponteiro para a contagem de uint64_t resolutions gravados ou um ponteiro para a capacidade necessária caso resolutionCapacityInput seja insuficiente.
  • resolutions é um ponteiro para uma matriz de XrDepthCameraResolutionANDROID , mas pode ser NULL se resolutionCapacityInput for 0 .
  • Consulte a seção Parâmetros de tamanho do buffer para uma descrição detalhada de como recuperar o tamanho de resolutions necessário.

xrEnumerateDepthResolutionsANDROID enumera as resoluções de profundidade compatíveis com a sessão atual. As resoluções de profundidade precisam estar em ordem de preferência de execução, da mais alta para a mais baixa. O aplicativo precisa usar a preferência mais alta que ele aceita para garantir o melhor desempenho e qualidade.

Os ambientes de execução precisam sempre retornar conteúdos de buffer idênticos dessa enumeração durante a sessão.

Uso válido (implícito)

  • A extensão XR_ANDROID_depth_texture precisa ser ativada antes de chamar xrEnumerateDepthResolutionsANDROID.
  • session precisa ser um identificador XrSession válido
  • resolutionCountOutput precisa ser um ponteiro para um valor uint32_t
  • Se resolutionCapacityInput não for 0 , resolutions precisa ser um ponteiro para uma matriz de valores resolutionCapacityInput XrDepthCameraResolutionANDROID.

Códigos de retorno

Sucesso

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Falha

  • 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

O tipo enumerado XrDepthCameraResolutionANDROID descreve as resoluções de profundidade compatíveis ao criar um 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;

Descrições de enumerantes

  • XR_DEPTH_CAMERA_RESOLUTION_80x80_ANDROID: a resolução das imagens de profundidade e confiança é de 80 x 80.
  • XR_DEPTH_CAMERA_RESOLUTION_160x160_ANDROID: a resolução das imagens de profundidade e confiança é de 160 x 160.
  • XR_DEPTH_CAMERA_RESOLUTION_320x320_ANDROID: a resolução das imagens de profundidade e confiança é de 320 x 320.

Criar uma swapchain de profundidade

XR_DEFINE_HANDLE(XrDepthSwapchainANDROID)

Um XrDepthSwapchainANDROID é um identificador de swapchain de profundidade.

A função xrCreateDepthSwapchainANDROID é definida como:

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

Descrições dos parâmetros

O aplicativo pode usar a função xrCreateDepthSwapchainANDROID para criar uma swapchain de profundidade que gerencia as imagens de profundidade e de confiança.

  • O ambiente de execução precisa retornar XR_ERROR_FEATURE_UNSUPPORTED se o sistema não for compatível com o rastreamento de profundidade.
  • O ambiente de execução precisa retornar XR_ERROR_PERMISSION_INSUFFICIENT se as permissões necessárias não tiverem sido concedidas ao app de ligação.
  • O ambiente de execução precisa retornar XR_ERROR_VALIDATION_FAILURE se a resolução de profundidade especificada em XrDepthSwapchainCreateInfoANDROID não for compatível.
  • O ambiente de execução precisa criar imagens de confiança de profundidade apenas quando os bits correspondentes estiverem definidos para o createInfo na criação da swapchain.

O identificador da swapchain de profundidade retornado pode ser usado em chamadas de API. O identificador XrDepthSwapchainANDROID precisa ser liberado pela função xrDestroyDepthSwapchainANDROID.

Uso válido (implícito)

Códigos de retorno

Sucesso

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Falha

  • 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

A estrutura XrDepthSwapchainCreateInfoANDROID é definida como:

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

Descrições dos membros

A estrutura XrDepthSwapchainCreateInfoANDROID oferece opções de criação para o XrDepthSwapchainANDROID quando transmitida para xrCreateDepthSwapchainANDROID .

Uso válido (implícito)

O XrDepthSwapchainCreateFlagsANDROID especifica as opções de criação para XrDepthSwapchainANDROID .

typedef XrFlags64 XrDepthSwapchainCreateFlagsANDROID;

Os bits válidos para XrDepthSwapchainCreateFlagsANDROID são definidos por XrDepthSwapchainCreateFlagBitsANDROID , que é especificado como:

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

Descrições de flags

  • XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_DEPTH_IMAGE_BIT_ANDROID: indica que a swapchain vai fornecer imagens de profundidade suaves.
  • XR_DEPTH_SWAPCHAIN_CREATE_SMOOTH_CONFIDENCE_IMAGE_BIT_ANDROID: indica que a swapchain vai fornecer imagens de confiança de profundidade suaves.
  • XR_DEPTH_SWAPCHAIN_CREATE_RAW_DEPTH_IMAGE_BIT_ANDROID: indica que a swapchain vai fornecer imagens de profundidade bruta.
  • XR_DEPTH_SWAPCHAIN_CREATE_RAW_CONFIDENCE_IMAGE_BIT_ANDROID: indica que a swapchain vai fornecer imagens de confiança de profundidade bruta.

A função xrDestroyDepthSwapchainANDROID é definida como:

XrResult xrDestroyDepthSwapchainANDROID(
    XrDepthSwapchainANDROID                     swapchain);

Descrições dos parâmetros

A função xrDestroyDepthSwapchainANDROID destrói a swapchain de profundidade. Depois dessa chamada, o ambiente de execução pode liberar toda a memória e os recursos relacionados.

Uso válido (implícito)

Concorrência segura

  • O acesso a swapchain e a qualquer identificador filho precisa ser sincronizado externamente.

Códigos de retorno

Sucesso

  • XR_SUCCESS

Falha

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_RUNTIME_FAILURE

Acessar texturas de profundidade

A função xrEnumerateDepthSwapchainImagesANDROID é definida como:

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

Descrições dos parâmetros

  • depthSwapchain é o XrDepthSwapchainANDROID de onde as imagens serão extraídas.
  • depthImageCapacityInput é a capacidade da matriz depthImages ou 0 para indicar uma solicitação de recuperação da capacidade necessária.
  • depthImageCountOutput é um ponteiro para a contagem de depthImages gravados ou um ponteiro para a capacidade necessária caso depthImageCapacityInput seja insuficiente.
  • depthImages é um ponteiro para uma matriz de estruturas XrDepthSwapchainImageANDROID. Pode ser NULL se depthImageCapacityInput for 0.
  • Consulte a seção Parâmetros de tamanho do buffer para uma descrição detalhada de como recuperar o tamanho de depthImages necessário.

xrEnumerateDepthSwapchainImagesANDROID preenche uma matriz de estruturas XrDepthSwapchainImageANDROID. Os recursos precisam ser constantes e válidos durante a vida útil do XrDepthSwapchainANDROID . Essa função se comporta de maneira análoga a xrEnumerateSwapchainImages .

O ambiente de execução precisa sempre retornar conteúdos de buffer idênticos dessa enumeração durante a vida útil da swapchain.

Uso válido (implícito)

Códigos de retorno

Sucesso

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Falha

  • 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

A estrutura XrDepthSwapchainImageANDROID é definida como:

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

Descrições dos membros

  • type é o XrStructureType dessa estrutura.
  • next é NULL ou um ponteiro para a próxima estrutura em uma cadeia de estruturas. Nenhuma estrutura desse tipo é definida no OpenXR principal ou nesta extensão.
  • rawDepthImage é NULL ou o ponteiro para imagens de profundidade bruta para as visualizações esquerda e direita alocadas pelo ambiente de execução. Os valores são dados em metros. Valores especiais: 0.0 indica um pixel de profundidade inválido ou vazio na profundidade bruta, Inf indica uma profundidade conhecida que está efetivamente infinitamente distante,
  • rawDepthConfidenceImage é NULL ou o ponteiro para imagens de confiança de profundidade bruta para as visualizações esquerda e direita alocadas pelo ambiente de execução.
  • smoothDepthImage é NULL ou o ponteiro para suavizar as imagens de profundidade para as visualizações esquerda e direita alocadas pelo ambiente de execução. Os valores são dados em metros. Valores especiais: 0.0 indica um pixel de profundidade inválido ou vazio na profundidade suave, Inf indica uma profundidade conhecida que está infinitamente distante.
  • smoothDepthConfidenceImage é NULL ou o ponteiro para imagens de confiança de profundidade suavizada para as visualizações esquerda e direita alocadas pelo ambiente de execução.

Os ponteiros do buffer de imagem só serão válidos durante a vida útil da swapchain. Depois que a swapchain for destruída, os ponteiros serão considerados pendentes.

XrDepthSwapchainImageANDROID representa as imagens de profundidade de um XrDepthSwapchainANDROID legível, alocado conforme descrito em XrDepthSwapchainCreateInfoANDROID :: resolution e XrDepthSwapchainCreateInfoANDROID :: createFlags ao chamar xrCreateDepthSwapchainANDROID . Para cada imagem de profundidade:

Uso válido (implícito)

A função xrAcquireDepthSwapchainImagesANDROID é definida como:

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

Descrições dos parâmetros

Os aplicativos podem usar a função xrAcquireDepthSwapchainImagesANDROID para adquirir o índice de imagem da swapchain mais recente disponível, ou seja, XrDepthAcquireResultANDROID :: acquiredIndex , na matriz XrDepthSwapchainImageANDROID enumerada por xrEnumerateDepthSwapchainImagesANDROID . O XrDepthAcquireResultANDROID retornado também contém outras informações, como o campo de visão e a pose, que são necessárias para interpretar os dados de profundidade. É seguro ler o slot adquirido na matriz de imagens até a próxima chamada para xrAcquireDepthSwapchainImagesANDROID .

Não pode haver mais de uma chamada para xrAcquireDepthSwapchainImagesANDROID entre qualquer par de chamadas xrBeginFrame e xrEndFrame correspondentes em uma sessão.

  • O ambiente de execução pode bloquear se as imagens de swapchain adquiridas anteriormente ainda estiverem sendo usadas por ele.
  • O ambiente de execução precisa retornar XR_ERROR_CALL_ORDER_INVALID se xrAcquireDepthSwapchainImagesANDROID for chamado antes de xrBeginFrame ou depois de xrEndFrame .
  • O ambiente de execução precisa retornar XR_ERROR_LIMIT_REACHED se xrAcquireDepthSwapchainImagesANDROID for chamado mais de uma vez por frame, ou seja, em uma sessão em execução, após uma chamada para xrBeginFrame que não tenha um xrEndFrame associado.
  • O ambiente de execução pode retornar XR_ERROR_DEPTH_NOT_AVAILABLE_ANDROID se os dados de profundidade do ambiente ainda não estiverem disponíveis. Se isso acontecer, o aplicativo precisará chamar xrAcquireDepthSwapchainImagesANDROID novamente em um frame posterior.

Uso válido (implícito)

Códigos de retorno

Sucesso

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Falha

  • 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

A estrutura XrDepthAcquireInfoANDROID é definida como:

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

Descrições dos membros

  • type é o XrStructureType dessa estrutura.
  • next é NULL ou um ponteiro para a próxima estrutura em uma cadeia de estruturas. Nenhuma estrutura desse tipo é definida no OpenXR principal ou nesta extensão.
  • space é um XrSpace que define o frame de referência da pose retornada em XrDepthAcquireResultANDROID :: views .
  • displayTime é um XrTime que especifica o tempo usado para calcular a pose retornada em XrDepthAcquireResultANDROID :: views . Os aplicativos precisam transmitir o tempo de exibição previsto para o frame atual.

Uso válido (implícito)

A estrutura XrDepthAcquireResultANDROID é definida como:

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

Descrições dos membros

  • type é o XrStructureType dessa estrutura.
  • next é NULL ou um ponteiro para a próxima estrutura em uma cadeia de estruturas. Nenhuma estrutura desse tipo é definida no OpenXR principal ou nesta extensão.
  • acquiredIndex é o índice da textura adquirida na matriz XrDepthSwapchainImageANDROID enumerada por xrEnumerateDepthSwapchainImagesANDROID .
  • exposureTimestamp é o XrTime que especifica o horário em que o mapa de profundidade foi capturado.
  • views é uma matriz de dois XrDepthViewANDROID , um para cada olho, em que o índice 0 é o olho esquerdo e o índice 1 é o olho direito.

Uso válido (implícito)

A estrutura XrDepthViewANDROID é definida como:

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

Descrições dos membros

  • type é o XrStructureType dessa estrutura.
  • next é NULL ou um ponteiro para a próxima estrutura em uma cadeia de estruturas. Nenhuma estrutura desse tipo é definida no OpenXR principal ou nesta extensão.
  • fov é um XrFovf que especifica o campo de visão usado para gerar essa visualização. A visualização nunca é invertida horizontal ou verticalmente.
  • pose é um XrPosef que especifica a pose de onde o mapa de profundidade foi renderizado. O frame de referência é especificado em XrDepthAcquireInfoANDROID .

Uso válido (implícito)

Exemplo de código para rastreamento de profundidade

O exemplo de código a seguir demonstra como adquirir imagens de profundidade e usar valores de profundidade para mapear as coordenadas da imagem de profundidade para o espaço do palco.

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

Novos tipos de objeto

Novos comandos

Novas estruturas

Novos tipos enumerados

Novas máscaras de bits

Novas constantes de tipo enumerado

  • XR_ANDROID_DEPTH_TEXTURE_EXTENSION_NAME
  • XR_ANDROID_depth_texture_SPEC_VERSION

  • Estendendo XrObjectType :

    • XR_OBJECT_TYPE_DEPTH_SWAPCHAIN_ANDROID

  • Estendendo XrResult :

    • XR_ERROR_DEPTH_NOT_AVAILABLE_ANDROID

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

Histórico de versões

  • Revisão 1, 09/09/2024 (Levana Chen)

    • Descrição inicial da extensão