XR_ANDROID_spatial_annotation_tracking

String de nome

XR_ANDROID_spatial_annotation_tracking

Tipo de extensão

Extensão de instância

Número de ramal registrado

795

Revisão

1

Status de ratificação

Não ratificado

Dependências de extensão e versão

XR_EXT_spatial_entity
e
XR_EXT_spatial_image_tracking

Data da última modificação

2026-01-12

Status do IP

Nenhuma reivindicação de PI conhecida.

Colaboradores

Levana Chen, Google
Christopher Feil, Google
Martin Sundermeyer, Google
David Joseph Tan, Google
Jared Finder, Google
Nihav Jain, Google

Visão geral

Essa extensão oferece o recurso de rastreamento de anotações para a extensão XR_EXT_spatial_entity, que rastreia várias anotações na cena. Ele permite que os aplicativos coloquem sobreposições em objetos físicos ou virtuais definidos por referências de ambiente de execução.

Essa extensão fornece um tipo de anotação básico "Quad", que é um polígono com exatamente quatro lados, ou seja, um quadrilátero convexo, que representa uma caixa delimitadora 2D generalizada em uma referência de ambiente de execução. Uma anotação de quadrilátero rastreado é representada como uma entidade espacial com os seguintes componentes:

  • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

Os aplicativos podem usar a extensão de rastreamento de anotações espaciais nos seguintes padrões:

  • Primeiro, um aplicativo cria um identificador de XrSpatialReferenceCacheANDROID, que começa a gravar referências de ambiente de execução da origem fornecida.
  • Em seguida, o aplicativo captura uma referência de ambiente de execução de XrSpatialReferenceImageEXT e define uma anotação desejada dentro da referência durante o período do cache de referência.
  • Em seguida, o aplicativo cria um identificador XrSpatialContextEXT com base no XrSpatialReferenceImageEXT fornecido por XrSpatialCapabilityConfigurationAnnotationTrackingANDROID .
  • O aplicativo pode destruir o identificador XrSpatialReferenceCacheANDROID para interromper a gravação de referências de ambiente de execução e reduzir o uso da memória ou aguardar o evento XR_TYPE_EVENT_DATA_SPATIAL_ANNOTATION_TRACKING_ANDROID para confirmar o resultado da inicialização.
  • Em seguida, o aplicativo extrai o evento XR_TYPE_EVENT_DATA_SPATIAL_ANNOTATION_TRACKING_ANDROID para confirmar o resultado da inicialização da anotação.
  • Se a inicialização for bem-sucedida, o aplicativo poderá extrair o evento XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT para rastrear a anotação.
  • Se a inicialização falhar, o aplicativo poderá usar o código do erro retornado no evento para determinar o motivo da falha e destruir o identificador XrSpatialContextEXT atual para iniciar uma nova anotação.
  • Independentemente do resultado da inicialização, o aplicativo pode liberar o buffer de imagem para reduzir o uso da memória depois de receber o evento.
  • O aplicativo descobre e consulta anotações de acordo com os padrões de acesso da entidade espacial.
  • O aplicativo pode criar um identificador XrSpatialContextEXT adicional para rastrear anotações em uma nova referência durante o período de um XrSpatialReferenceCacheANDROID válido.
  • O aplicativo pode destruir identificadores XrSpatialContextEXT para reduzir o conjunto de anotações detectáveis e rastreáveis dinamicamente no momento da execução.

Suporte ao ambiente de execução

Um ambiente de execução precisa anunciar que oferece suporte ao recurso de rastreamento de anotações usando xrEnumerateSpatialCapabilitiesEXT e listando o seguinte recurso:

  • XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID

Quando o ambiente de execução é compatível com o recurso de rastreamento de anotações:

A função xrEnumerateSpatialAnnotationReferenceSourcesANDROID é definida como:

XrResult xrEnumerateSpatialAnnotationReferenceSourcesANDROID(
    XrInstance                                  instance,
    XrSystemId                                  systemId,
    XrSpatialCapabilityEXT                      capability,
    uint32_t                                    sourceCapacityInput,
    uint32_t*                                   sourceCountOutput,
    XrSpatialAnnotationReferenceSourceANDROID*  sources);

Descrições dos parâmetros

  • instance é um identificador para uma XrInstance .
  • systemId é o XrSystemId cujas fontes de referência serão enumeradas.
  • capability é o XrSpatialCapabilityEXT para o qual as fontes de referência serão enumeradas.
  • sourceCapacityInput é a capacidade da matriz sources ou 0 para indicar uma solicitação de recuperação da capacidade necessária.
  • sourceCountOutput é o número de fontes ou a capacidade necessária caso sourceCapacityInput seja insuficiente.
  • sources é uma matriz de XrSpatialAnnotationReferenceSourceANDROID . Pode ser NULL se sourceCapacityInput for 0.
  • Consulte a seção Parâmetros de tamanho do buffer para uma descrição detalhada de como recuperar o tamanho de sources necessário.

O aplicativo pode enumerar a lista de origens de referência compatíveis com um determinado XrSystemId usando xrEnumerateSpatialAnnotationReferenceSourcesANDROID .

O ambiente de execução não pode enumerar as fontes de referência cuja extensão não está ativada para instance .

Uso válido (implícito)

Códigos de retorno

Sucesso

  • XR_SUCCESS

Falha

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SIZE_INSUFFICIENT
  • XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT
  • XR_ERROR_SYSTEM_INVALID
  • XR_ERROR_VALIDATION_FAILURE

typedef enum XrSpatialAnnotationReferenceSourceANDROID {
    XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_CAMERA_ANDROID = 0,
    XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_MEDIA_PROJECTION_ANDROID = 1,
    XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_MAX_ENUM_ANDROID = 0x7FFFFFFF
} XrSpatialAnnotationReferenceSourceANDROID;

A enumeração XrSpatialAnnotationReferenceSourceANDROID descreve a origem da referência que fornece os metadados de uma anotação.

Os tipos enumerados têm os seguintes significados:

Descrição do tipo enumerado

XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_CAMERA_ANDROID

A imagem de referência é uma imagem não cortada de uma API de câmera do Android, por exemplo, uma imagem de um ImageReader associado a um CameraDevice da Camera2 ou um ImageProxy de uma ImageAnalysis associada ao CameraX. Normalmente, é uma das câmeras RGB voltadas para frente.

XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_MEDIA_PROJECTION_ANDROID

A imagem de referência é uma saída de imagem não cortada da API MediaProjection do Android, por exemplo, uma imagem de um ImageReader associado a uma tela virtual do MediaProjection. Ele pode incluir conteúdo virtual e real.

A estrutura XrSystemSpatialAnnotationPropertiesANDROID é definida como:

typedef struct XrSystemSpatialAnnotationPropertiesANDROID {
    XrStructureType    type;
    void*              next;
    uint32_t           referenceCacheTimespan;
    uint32_t           maxReferencePixelWidth;
    uint32_t           maxReferencePixelHeight;
    uint32_t           maxReferenceCount;
    uint32_t           maxAnnotationCount;
} XrSystemSpatialAnnotationPropertiesANDROID;

Descrições dos membros

  • type é o XrStructureType dessa estrutura.
  • next é NULL ou um ponteiro para a próxima estrutura em uma cadeia de estruturas.
  • referenceCacheTimespan indica o período em segundos de um identificador XrSpatialReferenceCacheANDROID válido.
  • maxReferencePixelWidth indica a largura máxima da borda das imagens de referência em pixels.
  • maxReferencePixelHeight indica a altura máxima da borda das imagens de referência em pixels.
  • maxReferenceCount indica o número máximo de imagens de referência a serem alocadas ao mesmo tempo.
  • maxAnnotationCount indica o número máximo de anotações a serem rastreadas ao mesmo tempo.

Quando o ambiente de execução oferece suporte ao recurso de rastreamento de anotações, um aplicativo pode inspecionar as propriedades relevantes do sistema encadeando uma estrutura XrSystemSpatialAnnotationPropertiesANDROID ao XrSystemProperties ao chamar xrGetSystemProperties .

Se XrSpatialReferenceImageEXT :: width de XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference exceder maxReferencePixelWidth , o ambiente de execução precisará retornar XR_ERROR_VALIDATION_FAILURE ao chamar xrCreateSpatialContextAsyncEXT .

Se XrSpatialReferenceImageEXT :: height de XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference exceder maxReferencePixelHeight , o ambiente de execução precisará retornar XR_ERROR_VALIDATION_FAILURE ao chamar xrCreateSpatialContextAsyncEXT .

Se XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: time estiver fora do período de XrSpatialReferenceCacheANDROID :: cache , o ambiente de execução precisa retornar XR_ERROR_TIME_INVALID ao chamar xrCreateSpatialContextAsyncEXT . O aplicativo pode recriar o identificador XrSpatialContextEXT com uma nova referência durante o período do XrSpatialReferenceCacheANDROID .

Se o número de imagens de referência alocadas exceder maxReferenceCount , o ambiente de execução precisará retornar XR_ERROR_LIMIT_REACHED e indicar a falha de inicialização usando XrEventDataSpatialAnnotationTrackingANDROID :: initializationResult . O aplicativo pode destruir o identificador XrSpatialContextEXT e tentar novamente após a conclusão da inicialização pendente.

Se o número de anotações ativas exceder maxAnnotationCount , o ambiente de execução precisará retornar XR_ERROR_VALIDATION_FAILURE ao chamar xrCreateSpatialContextAsyncEXT .

Uso válido (implícito)

Cache de referência do ambiente de execução

XR_DEFINE_HANDLE(XrSpatialReferenceCacheANDROID)

O identificador XrSpatialReferenceCacheANDROID representa um cache de referências de ambiente de execução gravadas de uma determinada origem.

A função xrCreateSpatialReferenceCacheAsyncANDROID é definida como:

XrResult xrCreateSpatialReferenceCacheAsyncANDROID(
    XrSession                                   session,
    const XrSpatialReferenceCacheCreateInfoANDROID* createInfo,
    XrFutureEXT*                                future);

Descrições dos parâmetros

  • session é uma XrSession em que o cache de referência estará ativo.
  • createInfo é um ponteiro para um XrSpatialReferenceCacheCreateInfoANDROID usado para especificar os parâmetros de cache de referência.
  • future é um ponteiro para o identificador de saída de um XrFutureEXT .

O aplicativo pode criar um identificador XrSpatialReferenceCacheANDROID chamando xrCreateSpatialReferenceCacheAsyncANDROID . O ambiente de execução pode levar algum tempo para inicializar os serviços de rastreamento. O aplicativo pode chamar xrCreateSpatialReferenceCacheCompleteANDROID repetidamente para verificar a conclusão dessa operação assíncrona.

O ambiente de execução precisa retornar XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT se XrSpatialReferenceCacheCreateInfoANDROID :: capability não estiver listado por xrEnumerateSpatialCapabilitiesEXT .

O ambiente de execução precisa retornar XR_ERROR_FEATURE_UNSUPPORTED se XrSpatialReferenceCacheCreateInfoANDROID :: source não estiver listado por xrEnumerateSpatialAnnotationReferenceSourcesANDROID para o recurso em questão.

O aplicativo só pode criar um identificador por fonte para uma determinada capacidade. Caso contrário, o ambiente de execução precisa retornar XR_ERROR_LIMIT_REACHED .

O aplicativo pode capturar referências de tempo de execução durante o período do identificador XrSpatialReferenceCacheANDROID para configurar um novo identificador XrSpatialContextEXT.

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_RUNTIME_FAILURE
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT
  • XR_ERROR_VALIDATION_FAILURE

A estrutura XrSpatialReferenceCacheCreateInfoANDROID é definida como:

typedef struct XrSpatialReferenceCacheCreateInfoANDROID {
    XrStructureType                              type;
    const void*                                  next;
    XrSpatialCapabilityEXT                       capability;
    XrSpatialAnnotationReferenceSourceANDROID    source;
} XrSpatialReferenceCacheCreateInfoANDROID;

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.
  • capability é um XrSpatialCapabilityEXT que descreve para qual recurso o cache de referência é criado.
  • source é um XrSpatialAnnotationReferenceSourceANDROID que descreve a origem do cache de referência.

A estrutura XrSpatialReferenceCacheCreateInfoANDROID descreve as informações para criar um identificador XrSpatialReferenceCacheANDROID.

Uso válido (implícito)

A função xrCreateSpatialReferenceCacheCompleteANDROID é definida como:

XrResult xrCreateSpatialReferenceCacheCompleteANDROID(
    XrSession                                   session,
    XrFutureEXT                                 future,
    XrCreateSpatialReferenceCacheCompletionANDROID* completion);

Descrições dos parâmetros

O aplicativo pode chamar xrCreateSpatialReferenceCacheCompleteANDROID para aguardar a conclusão da operação assíncrona iniciada por xrCreateSpatialReferenceCacheAsyncANDROID .

O ambiente de execução precisa retornar XR_ERROR_FUTURE_PENDING_EXT se future não estiver no estado pronto. O ambiente de execução precisa retornar XR_ERROR_FUTURE_INVALID_EXT se future já tiver sido concluído ou cancelado.

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_FUTURE_INVALID_EXT
  • XR_ERROR_FUTURE_PENDING_EXT
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_LIMIT_REACHED
  • XR_ERROR_OUT_OF_MEMORY
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_VALIDATION_FAILURE

A estrutura XrCreateSpatialReferenceCacheCompletionANDROID é definida como:

typedef struct XrCreateSpatialReferenceCacheCompletionANDROID {
    XrStructureType                   type;
    void*                             next;
    XrResult                          futureResult;
    XrSpatialReferenceCacheANDROID    referenceCache;
} XrCreateSpatialReferenceCacheCompletionANDROID;

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.
  • futureResult é o XrResult da operação de criação do cache de referência.
  • referenceCache é o identificador XrSpatialReferenceCacheANDROID se a operação for bem-sucedida.

Códigos de retorno futuros

Valores de futureResult:

Sucesso

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Falha

  • XR_ERROR_FEATURE_UNSUPPORTED
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_OUT_OF_MEMORY
  • XR_ERROR_LIMIT_REACHED

Se futureResult for um código de sucesso, o ambiente de execução precisa retornar um identificador referenceCache válido. Se referenceCache for válido, ele vai permanecer assim apenas durante o ciclo de vida de xrCreateSpatialReferenceCacheAsyncANDROID :: session ou até que o aplicativo destrua o identificador com xrDestroySpatialReferenceCacheANDROID, o que ocorrer primeiro.

Quando referenceCache é válido, ele registra caches em XrSystemSpatialAnnotationPropertiesANDROID :: referenceCacheTimespan .

Uso válido (implícito)

A função xrDestroySpatialReferenceCacheANDROID é definida como:

XrResult xrDestroySpatialReferenceCacheANDROID(
    XrSpatialReferenceCacheANDROID              cacheHandle);

Descrições dos parâmetros

O aplicativo pode chamar a função xrDestroySpatialReferenceCacheANDROID para liberar o identificador cacheHandle e os recursos relacionados quando terminar de criar o contexto espacial.

Uso válido (implícito)

Concorrência segura

  • O acesso a cacheHandle 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

Configuração

A estrutura XrSpatialCapabilityConfigurationAnnotationTrackingANDROID é definida como:

typedef struct XrSpatialCapabilityConfigurationAnnotationTrackingANDROID {
    XrStructureType                     type;
    const void*                         next;
    XrSpatialCapabilityEXT              capability;
    uint32_t                            enabledComponentCount;
    const XrSpatialComponentTypeEXT*    enabledComponents;
    XrSpatialReferenceCacheANDROID      cache;
    XrTime                              time;
    XrSpatialReferenceImageEXT          reference;
} XrSpatialCapabilityConfigurationAnnotationTrackingANDROID;

Descrições dos membros

  • type é o XrStructureType dessa estrutura.
  • next é NULL ou um ponteiro para a próxima estrutura em uma cadeia de estruturas.
  • capability é um XrSpatialCapabilityEXT e precisa ser XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID .
  • enabledComponentCount é um uint32_t que descreve a contagem de elementos na matriz enabledComponents.
  • enabledComponents é um ponteiro para uma matriz de XrSpatialComponentTypeEXT .
  • cache é um XrSpatialReferenceCacheANDROID criado anteriormente para registrar referências de ambiente de execução para a configuração reference.
  • time é o XrTime em que o reference é capturado.
  • reference é um XrSpatialReferenceImageEXT com anotações encadeadas ao próximo ponteiro.

Os aplicativos podem ativar o recurso espacial XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID adicionando um ponteiro à estrutura XrSpatialCapabilityConfigurationAnnotationTrackingANDROID em XrSpatialContextCreateInfoEXT :: capabilityConfigs .

O ambiente de execução precisa retornar XR_ERROR_VALIDATION_FAILURE se capability não for XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID .

O ambiente de execução precisa retornar XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT se reference não tiver anotações.

O ambiente de execução precisa retornar XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT se o componente de anotação estiver listado em enabledComponents, mas nenhuma anotação correspondente estiver associada a reference .

O ambiente de execução precisa retornar XR_ERROR_VALIDATION_FAILURE se cache não pertencer à mesma XrSession que está sendo transmitida para xrCreateSpatialContextAsyncEXT .

O ambiente de execução precisa retornar XR_ERROR_TIME_INVALID se time estiver fora do período de cache .

Uso válido (implícito)

Eventos de rastreamento de anotações

A estrutura XrEventDataSpatialAnnotationTrackingANDROID é definida como:

typedef struct XrEventDataSpatialAnnotationTrackingANDROID {
    XrStructureType        type;
    const void*            next;
    XrSpatialContextEXT    spatialContext;
    uint32_t               annotationIndex;
    XrResult               initializationResult;
} XrEventDataSpatialAnnotationTrackingANDROID;

Descrições dos membros

  • type é o XrStructureType dessa estrutura.
  • next é NULL ou um ponteiro para a próxima estrutura em uma cadeia de estruturas.
  • spatialContext é o XrSpatialContextEXT que ativou o rastreamento de anotações.
  • annotationIndex é mapeado para o índice da matriz de anotações associada a XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference .
  • initializationResult indica o resultado da inicialização da anotação. Se não for XR_SUCCESS, o aplicativo pode destruir e recriar o identificador XrSpatialContextEXT para reinicializar a anotação ou continuar usando o spatialContext para rastrear outras anotações.

Uso válido (implícito)

O ambiente de execução precisa preencher o XrEventDataSpatialAnnotationTrackingANDROID para cada anotação para indicar a conclusão da inicialização. Independentemente do resultado da inicialização, o aplicativo pode liberar o buffer de imagem para reduzir o uso da memória após receber o evento.

O ambiente de execução precisa preencher initializationResult com XR_SUCCESS se a anotação for inicializada. O aplicativo pode extrair o evento XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT para rastrear a anotação.

Caso contrário, o ambiente de execução precisa preencher initializationResult com um código do erro apropriado para indicar o motivo da falha. O aplicativo pode destruir o identificador XrSpatialContextEXT para iniciar uma nova anotação ou continuar usando o spatialContext para rastrear outras anotações.

Anotação de quadrilátero

Um ambiente de execução precisa anunciar que oferece suporte a anotações quádruplas usando xrEnumerateSpatialCapabilityComponentTypesEXT, listando o seguinte tipo de componente:

  • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

Referência Quad

A estrutura XrSpatialAnnotationQuadReferenceANDROID é definida como:

typedef struct XrSpatialAnnotationQuadReferenceANDROID {
    XrStructureType                          type;
    const void*                              next;
    uint32_t                                 quadCount;
    const XrSpatialAnnotationQuadANDROID*    quads;
} XrSpatialAnnotationQuadReferenceANDROID;

Descrições dos membros

  • type é o XrStructureType dessa estrutura.
  • next é NULL ou um ponteiro para a próxima estrutura em uma cadeia de estruturas.
  • quadCount é um uint32_t que descreve a contagem de elementos na matriz quads.
  • quads é o ponteiro para uma matriz de XrSpatialAnnotationQuadANDROID .

Quando o ambiente de execução oferece suporte a anotações quádruplas, um aplicativo pode configurar anotações encadeando uma estrutura XrSpatialAnnotationQuadReferenceANDROID ao XrSpatialReferenceImageEXT :: next e definir a referência em XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference ao criar o identificador XrSpatialContextEXT.

O ambiente de execução precisa retornar XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT de xrCreateSpatialContextAsyncEXT se quadCount for 0.

Uso válido (implícito)

A estrutura XrSpatialAnnotationQuadANDROID é definida como:

typedef struct XrSpatialAnnotationQuadANDROID {
    XrSpatialAnnotationQuadAlignmentANDROID    alignment;
    XrVector2f                                 upperLeft;
    XrVector2f                                 upperRight;
    XrVector2f                                 lowerRight;
    XrVector2f                                 lowerLeft;
} XrSpatialAnnotationQuadANDROID;

Descrições dos membros

  • alignment é o XrSpatialAnnotationQuadAlignmentANDROID do quad.
  • upperLeft é um XrVector2f que descreve a coordenada do canto superior esquerdo do quad relacionado à origem.
  • upperRight é um XrVector2f que descreve a coordenada do canto superior direito do quadrilátero em relação à origem.
  • lowerRight é um XrVector2f que descreve a coordenada do canto inferior direito do quadrilátero em relação à origem.
  • lowerLeft é um XrVector2f que descreve a coordenada do canto inferior esquerdo do quadrilátero em relação à origem.

Um quad em um espaço 2D é um quadrilátero convexo em sentido horário. O valor de quatro cantos está relacionado à origem (0, 0) à qual o quadrilátero está associado.

Uso válido (implícito)

typedef enum XrSpatialAnnotationQuadAlignmentANDROID {
    XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_SCREEN_ANDROID = 0,
    XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_OBJECT_ANDROID = 1,
    XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_SURFACE_ANDROID = 2,
    XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_MAX_ENUM_ANDROID = 0x7FFFFFFF
} XrSpatialAnnotationQuadAlignmentANDROID;

A enumeração XrSpatialAnnotationQuadAlignmentANDROID descreve o alinhamento da anotação de quad.

Os tipos enumerados têm os seguintes significados:

Descrição do tipo enumerado

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_SCREEN_ANDROID

O quadrilátero de anotação é paralelo ao plano da tela, enquanto a rotação no plano permanece bloqueada para a gravidade do mundo. A saída aparece como uma caixa delimitadora vertical comum.

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_OBJECT_ANDROID

O quadrilátero de anotação é fixado diretamente no objeto, correspondendo ao alinhamento definido na imagem de referência. A saída é um quadrilátero convexo, ajustando a forma para corresponder à perspectiva do objeto.

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_SURFACE_ANDROID

O quadrilátero de anotação é coplanar com a superfície do objeto subjacente, supondo que o alvo rastreado seja um objeto ou uma superfície plana. O resultado se alinha perfeitamente à geometria física do objeto, ajustando a perspectiva para ficar plano em relação à superfície específica.

Componentes Quad

A estrutura XrSpatialAnnotationQuadDataANDROID é definida como:

typedef struct XrSpatialAnnotationQuadDataANDROID {
    uint32_t                          annotationIndex;
    XrSpaceLocationData               origin;
    XrSpatialAnnotationQuadANDROID    quad;
} XrSpatialAnnotationQuadDataANDROID;

Descrições dos membros

Uso válido (implícito)

A estrutura XrSpatialComponentAnnotationQuadListANDROID é definida como:

typedef struct XrSpatialComponentAnnotationQuadListANDROID {
    XrStructureType                        type;
    void*                                  next;
    uint32_t                               quadCount;
    XrSpatialAnnotationQuadDataANDROID*    quads;
} XrSpatialComponentAnnotationQuadListANDROID;

Descrições dos membros

  • type é o XrStructureType dessa estrutura.
  • next é NULL ou um ponteiro para a próxima estrutura em uma cadeia de estruturas.
  • quadCount é um uint32_t que descreve a contagem de elementos na matriz quads.
  • quads é uma matriz de XrSpatialAnnotationQuadDataANDROID .

O aplicativo pode consultar o componente de anotação quádrupla das entidades espaciais em um XrSpatialSnapshotEXT adicionando XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID em XrSpatialComponentDataQueryConditionEXT :: componentTypes e adicionando XrSpatialComponentAnnotationQuadListANDROID à próxima cadeia de ponteiros de XrSpatialComponentDataQueryResultEXT .

O ambiente de execução precisa retornar XR_ERROR_VALIDATION_FAILURE de xrQuerySpatialComponentDataEXT se XrSpatialComponentAnnotationQuadListANDROID estiver na próxima cadeia de XrSpatialComponentDataQueryResultEXT :: next, mas XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID não estiver incluído em XrSpatialComponentDataQueryConditionEXT :: componentTypes .

O ambiente de execução precisa retornar XR_ERROR_SIZE_INSUFFICIENT de xrQuerySpatialComponentDataEXT se quadCount for menor que XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput .

Uso válido (implícito)

Código de exemplo

Verificar o suporte ao ambiente de execução

O exemplo de código a seguir demonstra como verificar se o ambiente de execução é compatível com o recurso de rastreamento de anotações.

XrInstance instance;  // previously initialized
XrSystemId systemId;  // previously initialized
XrSession session;    // previously initialized
XrSpace localSpace;   // previously initialized, e.g. from
                      // XR_REFERENCE_SPACE_TYPE_LOCAL

PFN_xrEnumerateSpatialCapabilitiesEXT xrEnumerateSpatialCapabilitiesEXT;
PFN_xrEnumerateSpatialAnnotationReferenceSourcesANDROID xrEnumerateSpatialAnnotationReferenceSourcesANDROID;
PFN_xrEnumerateSpatialReferenceImageFormatsEXT xrEnumerateSpatialReferenceImageFormatsEXT;
PFN_xrEnumerateSpatialCapabilityComponentTypesEXT xrEnumerateSpatialCapabilityComponentTypesEXT;

// Check spatial annotation tracking capability
uint32_t capabilityCount;
CHK_XR(xrEnumerateSpatialCapabilitiesEXT(instance, systemId, 0,
                                         &capabilityCount, nullptr));
std::vector<XrSpatialCapabilityEXT> capabilities(capabilityCount);
CHK_XR(xrEnumerateSpatialCapabilitiesEXT(instance, systemId, capabilityCount,
                                         &capabilityCount,
                                         capabilities.data()));
if (std::find(capabilities.begin(), capabilities.end(),
              XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID) ==
    capabilities.end()) {
  // System does not support spatial annotation tracking.
  return;
}

// Inspect system properties for annotation tracking variables
XrSystemSpatialAnnotationPropertiesANDROID annotationSystemProperties{
    XR_TYPE_SYSTEM_SPATIAL_ANNOTATION_PROPERTIES_ANDROID};
XrSystemProperties systemProperties{.type = XR_TYPE_SYSTEM_PROPERTIES,
                                    .next = &annotationSystemProperties,
                                    .systemId = systemId};
CHK_XR(xrGetSystemProperties(instance, systemId, &systemProperties));
if (annotationSystemProperties.maxAnnotationCount == 0) {
  // System does not support any active annotations.
  return;
}

// Enumerate supported reference sources
uint32_t sourceCountOutput = 0;
XrSpatialAnnotationReferenceSourceANDROID desiredSource =
    XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_CAMERA_ANDROID;
CHK_XR(xrEnumerateSpatialAnnotationReferenceSourcesANDROID(
    instance, systemId, XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID,
    0, &sourceCountOutput, nullptr));
std::vector<XrSpatialAnnotationReferenceSourceANDROID> sources(sourceCountOutput);
CHK_XR(xrEnumerateSpatialAnnotationReferenceSourcesANDROID(
    instance, systemId, XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID,
    sourceCountOutput, &sourceCountOutput, sources.data()));
if (std::find(sources.begin(), sources.end(), desiredSource) == sources.end()) {
  // The desired source is not supported.
  return;
}

// Enumerate supported reference image formats, provided by XR_EXT_spatial_image_tracking.
uint32_t formatCountOutput = 0;
XrSpatialReferenceImageFormatEXT desiredFormat =
    XR_SPATIAL_REFERENCE_IMAGE_FORMAT_YUV_420_888_EXT; // Or XR_SPATIAL_REFERENCE_IMAGE_FORMAT_RGBA_8888_EXT for screenshot.
CHK_XR(xrEnumerateSpatialReferenceImageFormatsEXT(
    instance, systemId, XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID, 0,
    &formatCountOutput, nullptr));
std::vector<XrSpatialReferenceImageFormatEXT> formats(formatCountOutput);
CHK_XR(xrEnumerateSpatialReferenceImageFormatsEXT(
    instance, systemId, XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID,
    formats.size(), &formatCountOutput, formats.data()));
if (std::find(formats.begin(), formats.end(), desiredFormat) == formats.end()) {
  // The desired format is not supported
  return;
}

// Enumerate supported components for annotation tracking capability.
XrSpatialCapabilityComponentTypesEXT capabilityComponentTypes{
    XR_TYPE_SPATIAL_CAPABILITY_COMPONENT_TYPES_EXT};
CHK_XR(xrEnumerateSpatialCapabilityComponentTypesEXT(
    instance, systemId, XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID,
    &capabilityComponentTypes));
std::vector<XrSpatialComponentTypeEXT>
    annotationTypes(capabilityComponentTypes.componentTypeCountOutput);
capabilityComponentTypes.componentTypeCapacityInput = annotationTypes.size();
capabilityComponentTypes.componentTypes = annotationTypes.data();
CHK_XR(xrEnumerateSpatialCapabilityComponentTypesEXT(
    instance, systemId, XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID,
    &capabilityComponentTypes));

// Check supported annotation components.
XrSpatialComponentTypeEXT desiredComponent =
    XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID;
const auto supportedComponent = [&annotationTypes](
                                    XrSpatialComponentTypeEXT component) {
  return std::find(annotationTypes.begin(), annotationTypes.end(), component) !=
         annotationTypes.end();
};
if (!supportedComponent(desiredComponent)) {
  // The desired annotation is not supported.
  return;
}

Configurar anotação de quadrilátero

O exemplo de código a seguir demonstra como configurar a anotação quádrupla.

XrInstance instance;  // previously initialized
XrSystemId systemId;  // previously initialized
XrSession session;    // previously initialized
XrSpace localSpace;   // previously initialized, e.g. from
                      // XR_REFERENCE_SPACE_TYPE_LOCAL

PFN_xrCreateSpatialReferenceCacheAsyncANDROID xrCreateSpatialReferenceCacheAsyncANDROID;
PFN_xrCreateSpatialReferenceCacheCompleteANDROID xrCreateSpatialReferenceCacheCompleteANDROID;
PFN_xrDestroySpatialReferenceCacheANDROID xrDestroySpatialReferenceCacheANDROID;
PFN_xrCreateSpatialContextAsyncEXT xrCreateSpatialContextAsyncEXT;
PFN_xrCreateSpatialContextCompleteEXT xrCreateSpatialContextCompleteEXT;
void (*waitUntilReady)(XrFutureEXT);

XrSpatialReferenceImageFormatEXT desiredFormat;
XrSpatialAnnotationReferenceSourceANDROID desiredSource;
XrSpatialComponentTypeEXT desiredComponent;

// Create and start reference cache to prepare for capturing reference images.
XrSpatialReferenceCacheANDROID referenceCache;
XrSpatialReferenceCacheCreateInfoANDROID cacheCreateInfo{
  .type = XR_TYPE_SPATIAL_REFERENCE_CACHE_CREATE_INFO_ANDROID,
  .next = nullptr,
  .capability = XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID,
  .source = desiredSource,
};
XrFutureEXT cacheFuture = XR_NULL_FUTURE_EXT;
CHK_XR(xrCreateSpatialReferenceCacheAsyncANDROID(session, &cacheCreateInfo, &cacheFuture));

waitUntilReady(cacheFuture);

XrCreateSpatialReferenceCacheCompletionANDROID cacheCompletion{
    XR_TYPE_CREATE_SPATIAL_REFERENCE_CACHE_COMPLETION_ANDROID};
CHK_XR(xrCreateSpatialReferenceCacheCompleteANDROID(session, cacheFuture,
                                                     &cacheCompletion));
if (cacheCompletion.futureResult != XR_SUCCESS) {
  // Error, reference cache creation failed
  return;
}

referenceCache = cacheCompletion.referenceCache;

// Create the reference image with quad annotations

//  YUV 4:2:0 Planar:
// ----------------------
// |     Y      |Cb |Cr |
// ----------------------
XrSpatialReferenceImagePlaneEXT cameraImagePlanes[3];
// for each plane (0=Y, 1=U(cb), 2=V(Cr)) return by Image#getPlanes().
for (int i = 0; i < 3; ++i) {
  cameraImagePlanes[i].buffer; // read from Plane#getBuffer().
  cameraImagePlanes[i].bufferSize; // set each buffer size. Y = width * height (bytes); U = Y / 4 (bytes); V = Y / 4 (bytes).
  cameraImagePlanes[i].rowStride; // read from Plane#getRowStride().
  cameraImagePlanes[i].pixelStride; // read from Plane#getPixelStride().
}
XrSpatialReferenceImageEXT referenceImage{
      XR_TYPE_SPATIAL_REFERENCE_IMAGE_EXT};
referenceImage.width = 640;
referenceImage.height = 480;
referenceImage.format = desiredFormat;
referenceImage.planeCount = 3;
referenceImage.planes = cameraImagePlanes;

XrSpatialAnnotationQuadANDROID
    quad; // quad coordinates within the reference image.
quad.alignment = XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_OBJECT_ANDROID;
// Set unnormalized pixel coordinates of 4 corners.
quad.upperLeft = {0.0, 0.0};
quad.upperRight = {0.0, 100.0};
quad.lowerRight = {100.0, 100.0};
quad.lowerLeft = {0.0, 100.0};

XrSpatialAnnotationQuadReferenceANDROID quadReference{
    XR_TYPE_SPATIAL_ANNOTATION_QUAD_REFERENCE_ANDROID};
quadReference.quads = &quad;
quadReference.quadCount = 1;
referenceImage.next = &quadReference;

// Create the spatial context with annotation configuration.
XrSpatialContextEXT spatialContext{};
{
  const std::array<XrSpatialComponentTypeEXT, 1> enabledComponents = {
      desiredComponent,
  };

  // Configure annotation tracking
  XrSpatialCapabilityConfigurationAnnotationTrackingANDROID annotationConfig{
      XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ANNOTATION_TRACKING_ANDROID};
  annotationConfig.capability =
      XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID;
  annotationConfig.enabledComponentCount = enabledComponents.size();
  annotationConfig.enabledComponents = enabledComponents.data();
  annotationConfig.cache = referenceCache;
  annotationConfig.time; // The time when this reference image is captured.
  annotationConfig.reference = referenceImage;

  std::vector<XrSpatialCapabilityConfigurationBaseHeaderEXT *>
      capabilityConfigs;
  capabilityConfigs.push_back(
      reinterpret_cast<XrSpatialCapabilityConfigurationBaseHeaderEXT *>(
          &annotationConfig));

  XrSpatialContextCreateInfoEXT spatialContextCreateInfo{
      XR_TYPE_SPATIAL_CONTEXT_CREATE_INFO_EXT};
  spatialContextCreateInfo.capabilityConfigCount = capabilityConfigs.size();
  spatialContextCreateInfo.capabilityConfigs = capabilityConfigs.data();

  XrFutureEXT createContextFuture = XR_NULL_FUTURE_EXT;
  CHK_XR(xrCreateSpatialContextAsyncEXT(session, &spatialContextCreateInfo,
                                        &createContextFuture));

  waitUntilReady(createContextFuture);

  XrCreateSpatialContextCompletionEXT completion{
      XR_TYPE_CREATE_SPATIAL_CONTEXT_COMPLETION_EXT};
  CHK_XR(xrCreateSpatialContextCompleteEXT(session, createContextFuture,
                                           &completion));
  if (completion.futureResult != XR_SUCCESS) {
    // Error, spatial context creation failed
    return;
  }

  spatialContext = completion.spatialContext;
  CHK_XR(xrDestroySpatialReferenceCacheANDROID(referenceCache));
}

Descubra as anotações ativas

O exemplo de código a seguir demonstra como descobrir e consultar anotações.

XrInstance instance;  // previously initialized
XrSession session;    // previously initialized
XrSpace localSpace;   // previously initialized, e.g. from
                      // XR_REFERENCE_SPACE_TYPE_LOCAL
XrSpatialContextEXT spatialContext; // previously created

PFN_xrCreateSpatialDiscoverySnapshotAsyncEXT xrCreateSpatialDiscoverySnapshotAsyncEXT;
PFN_xrCreateSpatialDiscoverySnapshotCompleteEXT xrCreateSpatialDiscoverySnapshotCompleteEXT;
PFN_xrQuerySpatialComponentDataEXT xrQuerySpatialComponentDataEXT;
PFN_xrDestroySpatialSnapshotEXT xrDestroySpatialSnapshotEXT;
PFN_xrPollEvent xrPollEvent;
PFN_xrDestroySpatialContextEXT xrDestroySpatialContextEXT;
void (*waitUntilReady)(XrFutureEXT);

XrSpatialComponentTypeEXT desiredComponent; // e.g. XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

auto discoverAnnotations = [&](XrSpatialContextEXT spatialContext, XrTime time,
                               XrSpace baseSpace) {
  std::array<XrSpatialComponentTypeEXT, 1> snapshotComponents{desiredComponent};
  XrSpatialDiscoverySnapshotCreateInfoEXT snapshotCreateInfo{
      XR_TYPE_SPATIAL_DISCOVERY_SNAPSHOT_CREATE_INFO_EXT};
  snapshotCreateInfo.componentTypeCount = snapshotComponents.size();
  snapshotCreateInfo.componentTypes = snapshotComponents.data();
  XrFutureEXT discoveryFuture = XR_NULL_FUTURE_EXT;
  CHK_XR(xrCreateSpatialDiscoverySnapshotAsyncEXT(
      spatialContext, &snapshotCreateInfo, &discoveryFuture));

  waitUntilReady(discoveryFuture);

  XrCreateSpatialDiscoverySnapshotCompletionInfoEXT completionInfo{
      XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_INFO_EXT};
  completionInfo.baseSpace = baseSpace;
  completionInfo.time = time;
  completionInfo.future = discoveryFuture;

  XrCreateSpatialDiscoverySnapshotCompletionEXT completion{
      XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_EXT};
  CHK_XR(xrCreateSpatialDiscoverySnapshotCompleteEXT(
      spatialContext, &completionInfo, &completion));
  if (completion.futureResult == XR_SUCCESS) {
    // Query for desired annotation data, e.g. quad.
    XrSpatialComponentTypeEXT componentsToQuery[] = {
        XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID};
    XrSpatialComponentDataQueryConditionEXT queryCond{
        XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_CONDITION_EXT};
    queryCond.componentTypeCount = 1;
    queryCond.componentTypes = componentsToQuery;
    XrSpatialComponentDataQueryResultEXT queryResult{
        XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_RESULT_EXT};
    CHK_XR(xrQuerySpatialComponentDataEXT(completion.snapshot, &queryCond,
                                          &queryResult));

    std::vector<XrSpatialEntityIdEXT> entityIds(
        queryResult.entityIdCountOutput);
    std::vector<XrSpatialEntityTrackingStateEXT> entityStates(
        queryResult.entityStateCountOutput);
    queryResult.entityIdCapacityInput = entityIds.size();
    queryResult.entityIds = entityIds.data();
    queryResult.entityStateCapacityInput = entityStates.size();
    queryResult.entityStates = entityStates.data();

    std::vector<XrSpatialAnnotationQuadDataANDROID> quads(
        queryResult.entityIdCountOutput);
    XrSpatialComponentAnnotationQuadListANDROID quadList{
        XR_TYPE_SPATIAL_COMPONENT_ANNOTATION_QUAD_LIST_ANDROID};
    quadList.quadCount = quads.size();
    quadList.quads = quads.data();
    queryResult.next = &quadList;

    CHK_XR(xrQuerySpatialComponentDataEXT(completion.snapshot, &queryCond,
                                          &queryResult));

    for (int32_t i = 0; i < queryResult.entityIdCountOutput; ++i) {
      if (entityStates[i] == XR_SPATIAL_ENTITY_TRACKING_STATE_TRACKING_EXT) {
        const XrSpatialAnnotationQuadDataANDROID &currentQuad = quads[i];
        // Rendering quad in the view.
      }
    }

    CHK_XR(xrDestroySpatialSnapshotEXT(completion.snapshot));
  }
};

while (1) {
  // For every frame in frame loop

  XrSpace space;           // Application's play space.
  XrFrameState frameState; // Previously returned from xrWaitFrame
  const XrTime time = frameState.predictedDisplayTime;

  // Poll for the XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT event
  XrEventDataBuffer event = {XR_TYPE_EVENT_DATA_BUFFER};
  XrResult result = xrPollEvent(instance, &event);
  if (result == XR_SUCCESS) {
    switch (event.type) {
    case XR_TYPE_EVENT_DATA_SPATIAL_ANNOTATION_TRACKING_ANDROID: {
      const XrEventDataSpatialAnnotationTrackingANDROID &eventdata =
          *reinterpret_cast<XrEventDataSpatialAnnotationTrackingANDROID *>(
              &event);
      if (eventdata.initializationResult != XR_SUCCESS) {
        // handle initialization failure.
        // e.g. CHK_XR(xrDestroySpatialContextEXT(spatialContext));
      }
      break;
    }
    case XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT: {
      const XrEventDataSpatialDiscoveryRecommendedEXT &eventdata =
          *reinterpret_cast<XrEventDataSpatialDiscoveryRecommendedEXT *>(
              &event);
      // Discover spatial entities for the context that we received the
      // "discovery recommended" event for.
      //discoverSpatialEntities(eventdata.spatialContext, time, space);
      break;
    }
    }
  }

  // Finish frame loop
}

CHK_XR(xrDestroySpatialContextEXT(spatialContext));

Novos tipos de objeto

Novos comandos

Novas estruturas

Novos tipos enumerados

Novas constantes de tipo enumerado

  • XR_ANDROID_SPATIAL_ANNOTATION_TRACKING_EXTENSION_NAME
  • XR_ANDROID_spatial_annotation_tracking_SPEC_VERSION

  • Estendendo XrObjectType :

    • XR_OBJECT_TYPE_SPATIAL_REFERENCE_CACHE_ANDROID

  • Estendendo XrSpatialCapabilityEXT :

    • XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID

  • Estendendo XrSpatialComponentTypeEXT :

    • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

  • Estendendo XrStructureType :

    • XR_TYPE_CREATE_SPATIAL_REFERENCE_CACHE_COMPLETION_ANDROID
    • XR_TYPE_EVENT_DATA_SPATIAL_ANNOTATION_TRACKING_ANDROID
    • XR_TYPE_SPATIAL_ANNOTATION_QUAD_REFERENCE_ANDROID
    • XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ANNOTATION_TRACKING_ANDROID
    • XR_TYPE_SPATIAL_COMPONENT_ANNOTATION_QUAD_LIST_ANDROID
    • XR_TYPE_SPATIAL_REFERENCE_CACHE_CREATE_INFO_ANDROID
    • XR_TYPE_SYSTEM_SPATIAL_ANNOTATION_PROPERTIES_ANDROID

Problemas

Histórico de versões

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

    • Descrição inicial da extensão.