XR_ANDROID_spatial_annotation_tracking

Name String

XR_ANDROID_spatial_annotation_tracking

Tipo de extensión

Extensión de instancia

Número de extensión registrado

795

Revisión

1

Estado de ratificación

No ratificado

Dependencias de extensiones y versiones

XR_EXT_spatial_entity
y
XR_EXT_spatial_image_tracking

Fecha de la última modificación

2026-01-12

Estado de la IP

No hay reclamos de IP conocidos.

Colaboradores

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

Descripción general

Esta extensión proporciona la capacidad de seguimiento de anotaciones para la extensión XR_EXT_spatial_entity para realizar un seguimiento de varias anotaciones en la escena. Permite que las aplicaciones coloquen superposiciones en objetos físicos o virtuales definidos por referencias de tiempo de ejecución.

Esta extensión proporciona un tipo de anotación básico "Quad", que es un polígono que tiene exactamente 4 lados, es decir, un cuadrilátero convexo, que representa un cuadro delimitador 2D generalizado dentro de una referencia de tiempo de ejecución. Una anotación de cuadrilátero con seguimiento se representa como una entidad espacial con los siguientes componentes:

  • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

Por lo general, las aplicaciones pueden usar la extensión de seguimiento de anotaciones espaciales en los siguientes patrones:

  • Primero, una aplicación crea un controlador de XrSpatialReferenceCacheANDROID que comienza a grabar referencias del entorno de ejecución desde la fuente determinada.
  • Luego, la aplicación captura una referencia de tiempo de ejecución de XrSpatialReferenceImageEXT y define una anotación deseada dentro de la referencia durante el período de la caché de referencia.
  • Luego, la aplicación crea un controlador XrSpatialContextEXT basado en el XrSpatialReferenceImageEXT que proporciona XrSpatialCapabilityConfigurationAnnotationTrackingANDROID .
  • La aplicación puede destruir el controlador XrSpatialReferenceCacheANDROID para detener la grabación de referencias del entorno de ejecución y reducir el uso de memoria, o esperar el evento XR_TYPE_EVENT_DATA_SPATIAL_ANNOTATION_TRACKING_ANDROID para confirmar el resultado de la inicialización.
  • Luego, la aplicación extrae el evento XR_TYPE_EVENT_DATA_SPATIAL_ANNOTATION_TRACKING_ANDROID para confirmar el resultado de la inicialización de la anotación.
  • Si la inicialización se realiza correctamente, la aplicación puede extraer el evento XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT para hacer un seguimiento de la anotación.
  • Si la inicialización falla, la aplicación puede usar el código de error que se muestra en el evento para determinar el motivo de la falla y destruir el controlador XrSpatialContextEXT existente para iniciar una nueva anotación.
  • Independientemente del resultado de la inicialización, la aplicación puede liberar el búfer de imágenes para reducir el uso de memoria después de recibir el evento.
  • La aplicación descubre y consulta anotaciones según los patrones de acceso de la entidad espacial.
  • La aplicación puede crear un controlador XrSpatialContextEXT adicional para hacer un seguimiento de las anotaciones dentro de una referencia nueva durante el período de un XrSpatialReferenceCacheANDROID válido.
  • La aplicación puede destruir los controladores XrSpatialContextEXT para reducir el conjunto de anotaciones detectables y rastreables de forma dinámica durante el tiempo de ejecución.

Asistencia del entorno de ejecución

Un entorno de ejecución debe anunciar su compatibilidad con la capacidad de seguimiento de anotaciones usando xrEnumerateSpatialCapabilitiesEXT y enumerando la siguiente capacidad:

  • XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID

Cuando el entorno de ejecución admite la capacidad de seguimiento de anotaciones, ocurre lo siguiente:

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

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

Descripciones de los parámetros

  • instance es un controlador de un XrInstance .
  • systemId es el XrSystemId cuyas fuentes de referencia se enumerarán.
  • capability es el XrSpatialCapabilityEXT para el que se enumerarán las fuentes de referencia.
  • sourceCapacityInput es la capacidad del array sources, o 0 para indicar una solicitud de recuperación de la capacidad requerida.
  • sourceCountOutput es la cantidad de fuentes o la capacidad requerida en caso de que sourceCapacityInput sea insuficiente.
  • sources es un array de XrSpatialAnnotationReferenceSourceANDROID . Puede ser NULL si sourceCapacityInput es 0.
  • Consulta la sección Parámetros de tamaño del búfer para obtener una descripción detallada de cómo recuperar el tamaño de sources requerido.

La aplicación puede enumerar la lista de fuentes de referencia que admite un XrSystemId determinado con xrEnumerateSpatialAnnotationReferenceSourcesANDROID .

El entorno de ejecución no debe enumerar las fuentes de referencia cuya extensión no esté habilitada para instance .

Uso válido (implícito)

Códigos de retorno

Listo

  • XR_SUCCESS

Falla

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

La enumeración XrSpatialAnnotationReferenceSourceANDROID describe la fuente de la referencia que proporciona los metadatos de una anotación.

Las enumeraciones tienen los siguientes significados:

Descripción de enum

XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_CAMERA_ANDROID

La imagen de referencia es una imagen sin recortar que se obtiene de una API de cámara de Android, p.ej., una imagen de un ImageReader asociado con un CameraDevice de Camera2 o un ImageProxy de un ImageAnalysis asociado con CameraX. Por lo general, se trata de una de las cámaras RGB que miran hacia adelante.

XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_MEDIA_PROJECTION_ANDROID

La imagen de referencia es una imagen sin recortar que se obtiene de la API de MediaProjection de Android, p.ej., una imagen de un ImageReader asociado con una pantalla virtual de MediaProjection. Puede incluir contenido virtual y real.

La estructura XrSystemSpatialAnnotationPropertiesANDROID se define de la siguiente manera:

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

Descripciones de los miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructuras.
  • referenceCacheTimespan indica el intervalo de tiempo en segundos de un controlador XrSpatialReferenceCacheANDROID válido.
  • maxReferencePixelWidth indica el ancho máximo del borde de las imágenes de referencia en píxeles.
  • maxReferencePixelHeight indica la altura máxima del borde de las imágenes de referencia en píxeles.
  • maxReferenceCount indica la cantidad máxima de imágenes de referencia que se asignarán al mismo tiempo.
  • maxAnnotationCount indica la cantidad máxima de anotaciones de las que se puede hacer un seguimiento al mismo tiempo.

Cuando el entorno de ejecución admite la capacidad de seguimiento de anotaciones, una aplicación puede inspeccionar las propiedades relevantes del sistema encadenando una estructura XrSystemSpatialAnnotationPropertiesANDROID a XrSystemProperties cuando se llama a xrGetSystemProperties .

Si XrSpatialReferenceImageEXT :: width de XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference supera maxReferencePixelWidth , el entorno de ejecución debe devolver XR_ERROR_VALIDATION_FAILURE cuando se llama a xrCreateSpatialContextAsyncEXT .

Si XrSpatialReferenceImageEXT :: height de XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference supera maxReferencePixelHeight , el entorno de ejecución debe devolver XR_ERROR_VALIDATION_FAILURE cuando se llama a xrCreateSpatialContextAsyncEXT .

Si XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: time está fuera del intervalo de tiempo de XrSpatialReferenceCacheANDROID :: cache , el entorno de ejecución debe devolver XR_ERROR_TIME_INVALID cuando se llama a xrCreateSpatialContextAsyncEXT . La aplicación puede volver a crear el controlador XrSpatialContextEXT con una referencia nueva durante el intervalo de tiempo de XrSpatialReferenceCacheANDROID .

Si la cantidad de imágenes de referencia asignadas supera maxReferenceCount, el entorno de ejecución debe devolver XR_ERROR_LIMIT_REACHED y, además, indicar el error de inicialización a través de XrEventDataSpatialAnnotationTrackingANDROID :: initializationResult . La aplicación puede destruir el controlador XrSpatialContextEXT y volver a intentarlo después de que se complete la inicialización pendiente.

Si la cantidad de anotaciones activas supera maxAnnotationCount , el entorno de ejecución debe devolver XR_ERROR_VALIDATION_FAILURE cuando se llama a xrCreateSpatialContextAsyncEXT .

Uso válido (implícito)

Caché de referencia del entorno de ejecución

XR_DEFINE_HANDLE(XrSpatialReferenceCacheANDROID)

El controlador XrSpatialReferenceCacheANDROID representa una caché de referencias de tiempo de ejecución registradas desde una fuente determinada.

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

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

Descripciones de los parámetros

  • session es una XrSession en la que estará activa la caché de referencia.
  • createInfo es un puntero a un XrSpatialReferenceCacheCreateInfoANDROID que se usa para especificar los parámetros de la caché de referencia.
  • future es un puntero al controlador de salida de un XrFutureEXT .

La aplicación puede crear un controlador XrSpatialReferenceCacheANDROID llamando a xrCreateSpatialReferenceCacheAsyncANDROID . El entorno de ejecución puede tardar un poco en inicializar los servicios de seguimiento. Luego, la aplicación puede llamar a xrCreateSpatialReferenceCacheCompleteANDROID de forma repetida para verificar que se complete esta operación asíncrona.

El entorno de ejecución debe devolver XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT si XrSpatialReferenceCacheCreateInfoANDROID :: capability no aparece en xrEnumerateSpatialCapabilitiesEXT .

El entorno de ejecución debe devolver XR_ERROR_FEATURE_UNSUPPORTED si XrSpatialReferenceCacheCreateInfoANDROID :: source no aparece en la lista de xrEnumerateSpatialAnnotationReferenceSourcesANDROID para la función determinada.

La aplicación puede crear solo un controlador por fuente para una capacidad determinada. De lo contrario, el entorno de ejecución debe devolver XR_ERROR_LIMIT_REACHED .

Luego, la aplicación puede capturar referencias de tiempo de ejecución durante el intervalo del controlador XrSpatialReferenceCacheANDROID para configurar un nuevo controlador XrSpatialContextEXT.

Uso válido (implícito)

Códigos de retorno

Listo

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Falla

  • XR_ERROR_FEATURE_UNSUPPORTED
  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_LIMIT_REACHED
  • XR_ERROR_OUT_OF_MEMORY
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT
  • XR_ERROR_VALIDATION_FAILURE

La estructura XrSpatialReferenceCacheCreateInfoANDROID se define de la siguiente manera:

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

Descripciones de los miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructuras. No se definen tales estructuras en OpenXR principal ni en esta extensión.
  • capability es un XrSpatialCapabilityEXT que describe para qué capacidad se crea la caché de referencia.
  • source es un XrSpatialAnnotationReferenceSourceANDROID que describe la fuente de la caché de referencia.

La estructura XrSpatialReferenceCacheCreateInfoANDROID describe la información para crear un controlador XrSpatialReferenceCacheANDROID.

Uso válido (implícito)

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

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

Descripciones de los parámetros

La aplicación puede llamar a xrCreateSpatialReferenceCacheCompleteANDROID para esperar a que se complete la operación asíncrona que inició xrCreateSpatialReferenceCacheAsyncANDROID .

El entorno de ejecución debe mostrar XR_ERROR_FUTURE_PENDING_EXT si future no está en estado listo. El entorno de ejecución debe devolver XR_ERROR_FUTURE_INVALID_EXT si future ya se completó o canceló.

Uso válido (implícito)

Códigos de retorno

Listo

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Falla

  • XR_ERROR_FEATURE_UNSUPPORTED
  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_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

La estructura XrCreateSpatialReferenceCacheCompletionANDROID se define de la siguiente manera:

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

Descripciones de los miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructuras. No se definen tales estructuras en OpenXR principal ni en esta extensión.
  • futureResult es el XrResult de la operación de creación de la caché de referencia.
  • referenceCache es el controlador XrSpatialReferenceCacheANDROID si la operación se realiza correctamente.

Códigos de devolución futuros

Valores de futureResult:

Listo

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Falla

  • 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

Si futureResult es un código de éxito, el entorno de ejecución debe devolver un controlador referenceCache válido. Si referenceCache es válido, solo lo será durante el ciclo de vida de xrCreateSpatialReferenceCacheAsyncANDROID :: session o hasta que la aplicación destruya el controlador con xrDestroySpatialReferenceCacheANDROID, lo que ocurra primero.

Cuando referenceCache es válido, registra las cachés en XrSystemSpatialAnnotationPropertiesANDROID :: referenceCacheTimespan .

Uso válido (implícito)

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

XrResult xrDestroySpatialReferenceCacheANDROID(
    XrSpatialReferenceCacheANDROID              cacheHandle);

Descripciones de los parámetros

La aplicación puede llamar a la función xrDestroySpatialReferenceCacheANDROID para liberar el controlador cacheHandle y los recursos subyacentes cuando termine de crear el contexto espacial.

Uso válido (implícito)

Seguridad de subprocesos

  • El acceso a cacheHandle y a cualquier controlador secundario debe sincronizarse de forma externa.

Códigos de retorno

Listo

  • XR_SUCCESS

Falla

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_RUNTIME_FAILURE

Configuración

La estructura XrSpatialCapabilityConfigurationAnnotationTrackingANDROID se define de la siguiente manera:

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

Descripciones de los miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructuras.
  • capability es un XrSpatialCapabilityEXT y debe ser XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID .
  • enabledComponentCount es un uint32_t que describe el recuento de elementos en el array enabledComponents.
  • enabledComponents es un puntero a un array de XrSpatialComponentTypeEXT .
  • cache es un XrSpatialReferenceCacheANDROID creado anteriormente para registrar referencias de tiempo de ejecución para la configuración de reference.
  • time es el XrTime en el que se captura el reference.
  • reference es un XrSpatialReferenceImageEXT con anotaciones encadenadas a su siguiente puntero.

Las aplicaciones pueden habilitar la capacidad espacial XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID agregando un puntero a la estructura XrSpatialCapabilityConfigurationAnnotationTrackingANDROID en XrSpatialContextCreateInfoEXT :: capabilityConfigs .

El entorno de ejecución debe devolver XR_ERROR_VALIDATION_FAILURE si capability no es XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID .

El entorno de ejecución debe devolver XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT si reference no contiene anotaciones.

El entorno de ejecución debe devolver XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT si el componente de anotación aparece en enabledComponents, pero no hay anotaciones correspondientes asociadas con reference .

El entorno de ejecución debe devolver XR_ERROR_VALIDATION_FAILURE si cache no pertenece a la misma XrSession que se pasa a xrCreateSpatialContextAsyncEXT .

El entorno de ejecución debe devolver XR_ERROR_TIME_INVALID si time está fuera del intervalo de tiempo de cache .

Uso válido (implícito)

Eventos de seguimiento de anotaciones

La estructura XrEventDataSpatialAnnotationTrackingANDROID se define de la siguiente manera:

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

Descripciones de los miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructuras.
  • spatialContext es el XrSpatialContextEXT para el que se activó el seguimiento de anotaciones.
  • annotationIndex se asigna al índice del array de anotaciones asociado con XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference .
  • initializationResult indica el resultado de la inicialización de la anotación. Si no es XR_SUCCESS, la aplicación puede destruir y volver a crear el controlador XrSpatialContextEXT para reinicializar la anotación o seguir usando spatialContext para hacer un seguimiento de otras anotaciones.

Uso válido (implícito)

El entorno de ejecución debe propagar el XrEventDataSpatialAnnotationTrackingANDROID para cada anotación para indicar que se completó su inicialización. Independientemente del resultado de la inicialización, la aplicación puede liberar el búfer de imagen para reducir el uso de memoria después de recibir el evento.

El entorno de ejecución debe propagar initializationResult con XR_SUCCESS si la anotación se inicializa correctamente. Luego, la aplicación puede extraer el evento XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT para hacer un seguimiento de la anotación.

De lo contrario, el entorno de ejecución debe propagar initializationResult con un código de error adecuado para indicar el motivo de la falla. La aplicación puede destruir el controlador XrSpatialContextEXT para iniciar una anotación nueva o seguir usando el spatialContext para hacer un seguimiento de otras anotaciones.

Anotación cuádruple

Un entorno de ejecución debe anunciar su compatibilidad con las anotaciones de cuadriláteros con xrEnumerateSpatialCapabilityComponentTypesEXT enumerando el siguiente tipo de componente:

  • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

Referencia de Quad

La estructura XrSpatialAnnotationQuadReferenceANDROID se define de la siguiente manera:

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

Descripciones de los miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructuras.
  • quadCount es un uint32_t que describe el recuento de elementos en el array quads.
  • quads es el puntero a un array de XrSpatialAnnotationQuadANDROID .

Cuando el entorno de ejecución admite anotaciones cuadriláteras, una aplicación puede configurar anotaciones encadenando una estructura XrSpatialAnnotationQuadReferenceANDROID a XrSpatialReferenceImageEXT :: next y establecer la referencia en XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference cuando se crea el controlador XrSpatialContextEXT.

El entorno de ejecución debe devolver XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT de xrCreateSpatialContextAsyncEXT si quadCount es 0.

Uso válido (implícito)

La estructura XrSpatialAnnotationQuadANDROID se define de la siguiente manera:

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

Descripciones de los miembros

  • alignment es el XrSpatialAnnotationQuadAlignmentANDROID del cuadrilátero.
  • upperLeft es un XrVector2f que describe la coordenada de la esquina superior izquierda del cuadrilátero relacionado con el origen.
  • upperRight es un XrVector2f que describe la coordenada de la esquina superior derecha del cuadrilátero relacionado con el origen.
  • lowerRight es un XrVector2f que describe la coordenada de la esquina inferior derecha del cuadrilátero relacionado con el origen.
  • lowerLeft es un XrVector2f que describe la coordenada de la esquina inferior izquierda del cuadrilátero relacionado con el origen.

Un cuadrilátero en un espacio 2D es un cuadrilátero convexo en el sentido de las manecillas del reloj. El valor de las 4 esquinas se relaciona con el origen (0, 0) con el que se asocia el cuadrilátero.

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;

La enumeración XrSpatialAnnotationQuadAlignmentANDROID describe la alineación de la anotación de cuadrilátero.

Las enumeraciones tienen los siguientes significados:

Descripción de enum

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_SCREEN_ANDROID

El cuadrilátero de anotación es paralelo al plano de la pantalla, mientras que su rotación en el plano permanece bloqueada según la gravedad del mundo. El resultado aparece como un cuadro delimitador vertical normal.

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_OBJECT_ANDROID

El cuadrilátero de anotación se fija directamente al objeto, lo que coincide con la alineación definida en la imagen de referencia. El resultado es un cuadrilátero convexo, que ajusta su forma para que coincida con la perspectiva del objeto.

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_SURFACE_ANDROID

El cuadrilátero de anotación es coplanar con la superficie del objeto subyacente, suponiendo que el objetivo seguido es un objeto o una superficie plana. El resultado se alinea sin problemas con la geometría física del objeto y ajusta su perspectiva para que quede plano contra esa superficie específica.

Componentes de Quad

La estructura XrSpatialAnnotationQuadDataANDROID se define de la siguiente manera:

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

Descripciones de los miembros

Uso válido (implícito)

La estructura XrSpatialComponentAnnotationQuadListANDROID se define de la siguiente manera:

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

Descripciones de los miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructuras.
  • quadCount es un uint32_t que describe el recuento de elementos en el array quads.
  • quads es un array de XrSpatialAnnotationQuadDataANDROID .

La aplicación puede consultar el componente de anotación de cuadrilátero de las entidades espaciales en un XrSpatialSnapshotEXT agregando XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID en XrSpatialComponentDataQueryConditionEXT :: componentTypes y agregando XrSpatialComponentAnnotationQuadListANDROID a la siguiente cadena de punteros de XrSpatialComponentDataQueryResultEXT .

El entorno de ejecución debe devolver XR_ERROR_VALIDATION_FAILURE de xrQuerySpatialComponentDataEXT si XrSpatialComponentAnnotationQuadListANDROID está en la siguiente cadena de XrSpatialComponentDataQueryResultEXT :: next, pero XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID no se incluye en XrSpatialComponentDataQueryConditionEXT :: componentTypes .

El entorno de ejecución debe devolver XR_ERROR_SIZE_INSUFFICIENT de xrQuerySpatialComponentDataEXT si quadCount es menor que XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput .

Uso válido (implícito)

Código de ejemplo

Verifica la compatibilidad con el entorno de ejecución

En el siguiente código de ejemplo, se muestra cómo verificar si el entorno de ejecución admite la capacidad de seguimiento de anotaciones.

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

Configura la anotación de cuadrilátero

En el siguiente código de ejemplo, se muestra cómo configurar la anotación de cuadrilá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));
}

Descubre las anotaciones activas

En el siguiente código de ejemplo, se muestra cómo descubrir y consultar anotaciones.

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

Nuevos tipos de objetos

Comandos nuevos

Estructuras nuevas

Enums nuevas

Nuevas constantes de enum

  • XR_ANDROID_SPATIAL_ANNOTATION_TRACKING_EXTENSION_NAME
  • XR_ANDROID_spatial_annotation_tracking_SPEC_VERSION

  • Extiende XrObjectType :

    • XR_OBJECT_TYPE_SPATIAL_REFERENCE_CACHE_ANDROID

  • Extiende XrSpatialCapabilityEXT :

    • XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID

  • Extiende XrSpatialComponentTypeEXT :

    • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

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

Historial de versiones

  • Revisión 1, 17 de septiembre de 2025 (Levana Chen)

    • Descripción inicial de la extensión.