XR_ANDROID_spatial_annotation_tracking

String de nome

XR_ANDROID_spatial_annotation_tracking

Tipo de extensão

Extensão de instância

Número da extensão registrada

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

Não há reivindicações de IP conhecidas.

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 a capacidade de rastreamento de anotações para a extensão XR_EXT_spatial_entity, permitindo rastrear 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 tempo de execução.

Essa extensão oferece um tipo de anotação básica "Quad", que é um polígono com exatamente quatro lados, ou seja, um quadrilátero convexo, representando uma caixa delimitadora 2D generalizada em uma referência de tempo de execução. Uma anotação de quadra rastreada é representada como uma entidade espacial com (ou "que tem") os seguintes componentes:

  • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

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

  • Primeiro, um aplicativo cria um identificador de XrSpatialReferenceCacheANDROID, que começa a gravar referências de tempo de execução da origem especificada.
  • Em seguida, o aplicativo captura uma referência de tempo 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 tempo 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 de erro retornado no evento para determinar o motivo da falha e destruir o identificador XrSpatialContextEXT atual para iniciar uma nova anotação.
  • Independente 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 aplicativo descobre e consulta anotações de acordo com os padrões de acesso a entidades espaciais.
  • 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 de forma dinâmica durante a execução.

Suporte ao ambiente de execução

Um ambiente de execução precisa anunciar o suporte ao recurso de rastreamento de anotações usando xrEnumerateSpatialCapabilitiesEXT ao listar a seguinte capability:

  • XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID

Quando o ambiente de execução é compatível com o recurso de acompanhamento 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 de 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 . Ele 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 sources necessário.

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

O tempo 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 da enumeração

XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_CAMERA_ANDROID

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

XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_MEDIA_PROJECTION_ANDROID

A imagem de referência é uma imagem sem corte gerada pela API Android MediaProjection, por exemplo, uma imagem de um ImageReader associado a uma tela virtual 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 de 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 tempo de execução deverá retornar XR_ERROR_VALIDATION_FAILURE ao chamar xrCreateSpatialContextAsyncEXT .

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

Se XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: time estiver fora do período de XrSpatialReferenceCacheANDROID :: cache , o tempo de execução deverá 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 deverá retornar XR_ERROR_LIMIT_REACHED e indicar a falha de inicialização via XrEventDataSpatialAnnotationTrackingANDROID :: initializationResult . O aplicativo pode destruir o identificador XrSpatialContextEXT e tentar de novo depois que a inicialização pendente for concluída.

Se o número de anotações ativas exceder maxAnnotationCount , o tempo de execução deverá 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 tempo 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 vai estar ativo.
  • createInfo é um ponteiro para um XrSpatialReferenceCacheCreateInfoANDROID usado para especificar os parâmetros de cache de referência.
  • future é um ponteiro para o handle 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 tempo de execução precisa retornar XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT se XrSpatialReferenceCacheCreateInfoANDROID :: capability não estiver listado por xrEnumerateSpatialCapabilitiesEXT .

O tempo de execução deve retornar XR_ERROR_FEATURE_UNSUPPORTED se XrSpatialReferenceCacheCreateInfoANDROID :: source não estiver listado por xrEnumerateSpatialAnnotationReferenceSourcesANDROID para o recurso especificado.

O aplicativo pode criar apenas um identificador por origem para uma determinada capacidade. Caso contrário, o tempo 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 de membros

  • type é o XrStructureType dessa estrutura.
  • next é NULL ou um ponteiro para a próxima estrutura em uma cadeia de estruturas. Nenhuma dessas estruturas é 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 tempo de execução precisa retornar XR_ERROR_FUTURE_PENDING_EXT se future não estiver no estado pronto. O tempo 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 da seguinte forma:

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

Descrições de membros

  • type é o XrStructureType dessa estrutura.
  • next é NULL ou um ponteiro para a próxima estrutura em uma cadeia de estruturas. Nenhuma dessas estruturas é definida no OpenXR principal ou nesta extensão.
  • futureResult é o XrResult da operação de criação de 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 tempo de execução deverá retornar um identificador referenceCache válido. Se referenceCache for válido, ele 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 grava 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 subjacentes quando a criação do contexto espacial for concluída.

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

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 de 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 tempo 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 tempo de execução deve retornar XR_ERROR_VALIDATION_FAILURE se capability não for XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID .

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

O tempo 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 tempo de execução deve retornar XR_ERROR_VALIDATION_FAILURE se cache não for de propriedade da mesma XrSession transmitida para xrCreateSpatialContextAsyncEXT .

O tempo de execução deve 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 da seguinte forma:

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

Descrições de membros

  • type é o XrStructureType dessa estrutura.
  • next é NULL ou um ponteiro para a próxima estrutura em uma cadeia de estruturas.
  • spatialContext é o XrSpatialContextEXT para o qual o rastreamento de anotações foi ativado.
  • annotationIndex mapeia 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 poderá 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 tempo de execução precisa preencher o XrEventDataSpatialAnnotationTrackingANDROID para cada anotação e indicar a conclusão da inicialização. Independente 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 tempo 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 tempo de execução precisa preencher initializationResult com um código de erro adequado 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 quadrante

Um ambiente de execução precisa anunciar a compatibilidade com anotações de quadrilátero usando xrEnumerateSpatialCapabilityComponentTypesEXT ao listar o seguinte tipo de componente:

  • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

Referência de quadriciclo

A estrutura XrSpatialAnnotationQuadReferenceANDROID é definida como:

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

Descrições de 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 tempo 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 tempo 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 da seguinte forma:

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

Descrições de membros

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

Um quadrilátero em um espaço 2D é um quadrilátero convexo com ordem horária. O valor dos quatro cantos está relacionado à origem (0, 0) em que 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_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 da enumeração

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 à gravidade do mundo. A saída aparece como uma caixa delimitadora regular e vertical.

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_OBJECT_ANDROID

O quadrilátero de anotação é ancorado diretamente ao 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.

Componentes de quatro vias

A estrutura XrSpatialAnnotationQuadDataANDROID é definida como:

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

Descrições de membros

Uso válido (implícito)

A estrutura XrSpatialComponentAnnotationQuadListANDROID é definida da seguinte forma:

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

Descrições de 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 de quadrilátero 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 tempo 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 tempo de execução precisa retornar XR_ERROR_SIZE_INSUFFICIENT de xrQuerySpatialComponentDataEXT se quadCount for menor que XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput .

Uso válido (implícito)

Exemplo de código

Verificar o suporte do ambiente de execução

O exemplo de código a seguir demonstra como verificar se o ambiente de execução oferece suporte ao 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 quadrante

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

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));
}

Descobrir 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 enumeração

  • XR_ANDROID_SPATIAL_ANNOTATION_TRACKING_EXTENSION_NAME
  • XR_ANDROID_spatial_annotation_tracking_SPEC_VERSION

  • Extensão de XrObjectType :

    • XR_OBJECT_TYPE_SPATIAL_REFERENCE_CACHE_ANDROID

  • Extensão de XrSpatialCapabilityEXT :

    • XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID

  • Extensão de XrSpatialComponentTypeEXT :

    • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

  • Extensão de 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.