XR_ANDROID_spatial_annotation_tracking

Name String

XR_ANDROID_spatial_annotation_tracking

Type d'extension

Extension d'instance

Numéro d'extension enregistré

795

Révision

1

État de la ratification

Non ratifié

Dépendances d'extension et de version

XR_EXT_spatial_entity
et
XR_EXT_spatial_image_tracking

Date de dernière modification

2026-01-12

État de l'adresse IP

Aucune réclamation de propriété intellectuelle connue.

Participants

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

Présentation

Cette extension fournit la fonctionnalité de suivi des annotations pour l'extension XR_EXT_spatial_entity afin de suivre différentes annotations dans la scène. Elle permet aux applications de placer des superpositions sur des objets physiques ou virtuels définis par des références d'exécution.

Cette extension fournit un type d'annotation de base "Quad", qui est un polygone comportant exactement quatre côtés (c'est-à-dire un quadrilatère convexe) représentant un cadre de délimitation 2D généralisé dans une référence d'exécution. Une annotation de quadrilatère suivi est représentée sous la forme d'une entité spatiale avec (ou "qui possède") les composants suivants :

  • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

Les applications peuvent généralement utiliser l'extension de suivi des annotations spatiales selon les modèles suivants :

  • Une application crée d'abord un handle de XrSpatialReferenceCacheANDROID, qui commence à enregistrer les références d'exécution à partir de la source donnée.
  • L'application capture ensuite une référence d'exécution de XrSpatialReferenceImageEXT et définit une annotation souhaitée dans la référence pendant la durée de vie du cache de référence.
  • L'application crée ensuite un handle XrSpatialContextEXT basé sur l'XrSpatialReferenceImageEXT fourni par XrSpatialCapabilityConfigurationAnnotationTrackingANDROID .
  • L'application peut détruire le handle XrSpatialReferenceCacheANDROID pour arrêter l'enregistrement des références d'exécution afin de réduire l'utilisation de la mémoire, ou attendre l'événement XR_TYPE_EVENT_DATA_SPATIAL_ANNOTATION_TRACKING_ANDROID pour confirmer le résultat de l'initialisation.
  • L'application extrait ensuite l'événement XR_TYPE_EVENT_DATA_SPATIAL_ANNOTATION_TRACKING_ANDROID pour confirmer le résultat de l'initialisation de l'annotation.
  • Si l'initialisation réussit, l'application peut ensuite extraire l'événement XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT pour suivre l'annotation.
  • Si l'initialisation échoue, l'application peut utiliser le code d'erreur renvoyé dans l'événement pour déterminer la raison de l'échec et détruire le handle XrSpatialContextEXT existant pour démarrer une nouvelle annotation.
  • Quel que soit le résultat de l'initialisation, l'application peut libérer la mémoire tampon d'image pour réduire l'utilisation de la mémoire après avoir reçu l'événement.
  • L'application découvre et interroge les annotations en fonction des modèles d'accès aux entités spatiales.
  • L'application peut créer un handle XrSpatialContextEXT supplémentaire pour suivre les annotations dans une nouvelle référence pendant la durée d'un XrSpatialReferenceCacheANDROID valide.
  • L'application peut détruire les poignées XrSpatialContextEXT pour réduire l'ensemble d'annotations détectables et traçables de manière dynamique au moment de l'exécution.

Compatibilité des environnements d'exécution

Un environnement d'exécution doit annoncer sa compatibilité avec la fonctionnalité de suivi des annotations à l'aide de xrEnumerateSpatialCapabilitiesEXT en listant la fonctionnalité suivante :

  • XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID

Lorsque l'environnement d'exécution est compatible avec la fonctionnalité de suivi des annotations :

La fonction xrEnumerateSpatialAnnotationReferenceSourcesANDROID est définie comme suit :

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

Description des paramètres

  • instance est un handle vers un XrInstance .
  • systemId est l'XrSystemId dont les sources de référence seront énumérées.
  • capability est l'XrSpatialCapabilityEXT pour lequel les sources de référence seront énumérées.
  • sourceCapacityInput est la capacité du tableau sources, ou 0 pour indiquer une requête de récupération de la capacité requise.
  • sourceCountOutput est le nombre de sources ou la capacité requise si sourceCapacityInput est insuffisant.
  • sources est un tableau de XrSpatialAnnotationReferenceSourceANDROID . Il peut être NULL si sourceCapacityInput est égal à 0.
  • Consultez la section Paramètres de taille de la mémoire tampon pour obtenir une description détaillée de la récupération de la taille sources requise.

L'application peut énumérer la liste des sources de référence compatibles avec un XrSystemId donné à l'aide de xrEnumerateSpatialAnnotationReferenceSourcesANDROID .

L'environnement d'exécution ne doit pas énumérer les sources de référence dont l'extension n'est pas activée pour instance .

Utilisation valide (implicite)

Codes renvoyés

Opération réussie

  • XR_SUCCESS

Échec

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

L'énumération XrSpatialAnnotationReferenceSourceANDROID décrit la source de la référence qui fournit les métadonnées d'une annotation.

Les énumérations ont les significations suivantes :

Description de l'enum

XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_CAMERA_ANDROID

L'image de référence est une image non recadrée provenant d'une API d'appareil photo Android, par exemple une image provenant d'un ImageReader associé à un CameraDevice Camera2 ou un ImageProxy provenant d'un ImageAnalysis associé à CameraX. Il s'agit généralement de l'une des caméras RVB orientées vers l'avant.

XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_MEDIA_PROJECTION_ANDROID

L'image de référence est une image non recadrée générée par l'API Android MediaProjection, par exemple une image provenant d'un ImageReader associé à un écran virtuel MediaProjection. Il peut inclure du contenu virtuel et réel.

La structure XrSystemSpatialAnnotationPropertiesANDROID est définie comme suit :

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

Descriptions des membres

  • type est le XrStructureType de cette structure.
  • next est NULL ou un pointeur vers la structure suivante dans une chaîne de structures.
  • referenceCacheTimespan indique la durée en secondes d'un handle XrSpatialReferenceCacheANDROID valide.
  • maxReferencePixelWidth indique la largeur maximale du bord des images de référence en pixels.
  • maxReferencePixelHeight indique la hauteur maximale du bord des images de référence en pixels.
  • maxReferenceCount indique le nombre maximal d'images de référence à allouer en même temps.
  • maxAnnotationCount indique le nombre maximal d'annotations à suivre en même temps.

Lorsque l'environnement d'exécution est compatible avec la fonctionnalité de suivi des annotations, une application peut inspecter les propriétés système pertinentes en associant une structure XrSystemSpatialAnnotationPropertiesANDROID à XrSystemProperties lors de l'appel de xrGetSystemProperties .

Si XrSpatialReferenceImageEXT :: width de XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference dépasse maxReferencePixelWidth , l'environnement d'exécution doit renvoyer XR_ERROR_VALIDATION_FAILURE lors de l'appel de xrCreateSpatialContextAsyncEXT .

Si XrSpatialReferenceImageEXT :: height de XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference dépasse maxReferencePixelHeight , l'environnement d'exécution doit renvoyer XR_ERROR_VALIDATION_FAILURE lors de l'appel de xrCreateSpatialContextAsyncEXT .

Si XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: time est en dehors de la période de XrSpatialReferenceCacheANDROID :: cache , l'environnement d'exécution doit renvoyer XR_ERROR_TIME_INVALID lors de l'appel de xrCreateSpatialContextAsyncEXT . L'application peut recréer le handle XrSpatialContextEXT avec une nouvelle référence pendant la durée de vie de XrSpatialReferenceCacheANDROID .

Si le nombre d'images de référence allouées dépasse maxReferenceCount , l'environnement d'exécution doit renvoyer XR_ERROR_LIMIT_REACHED et indiquer l'échec de l'initialisation via XrEventDataSpatialAnnotationTrackingANDROID :: initializationResult . L'application peut détruire le handle XrSpatialContextEXT et réessayer une fois l'initialisation en attente terminée.

Si le nombre d'annotations actives dépasse maxAnnotationCount , l'environnement d'exécution doit renvoyer XR_ERROR_VALIDATION_FAILURE lors de l'appel de xrCreateSpatialContextAsyncEXT .

Utilisation valide (implicite)

Cache de référence d'exécution

XR_DEFINE_HANDLE(XrSpatialReferenceCacheANDROID)

Le handle XrSpatialReferenceCacheANDROID représente un cache de références d'exécution enregistrées à partir d'une source donnée.

La fonction xrCreateSpatialReferenceCacheAsyncANDROID est définie comme suit :

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

Description des paramètres

  • session est une XrSession dans laquelle le cache de référence sera actif.
  • createInfo est un pointeur vers un XrSpatialReferenceCacheCreateInfoANDROID utilisé pour spécifier les paramètres du cache de référence.
  • future est un pointeur vers le handle de sortie d'un XrFutureEXT .

L'application peut créer un handle XrSpatialReferenceCacheANDROID en appelant xrCreateSpatialReferenceCacheAsyncANDROID . L'environnement d'exécution peut prendre un certain temps pour initialiser les services de suivi. L'application peut ensuite appeler xrCreateSpatialReferenceCacheCompleteANDROID de manière répétée pour vérifier l'achèvement de cette opération asynchrone.

L'environnement d'exécution doit renvoyer XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT si XrSpatialReferenceCacheCreateInfoANDROID :: capability n'est pas listé par xrEnumerateSpatialCapabilitiesEXT .

L'environnement d'exécution doit renvoyer XR_ERROR_FEATURE_UNSUPPORTED si XrSpatialReferenceCacheCreateInfoANDROID :: source n'est pas listé par xrEnumerateSpatialAnnotationReferenceSourcesANDROID pour la fonctionnalité donnée.

L'application ne peut créer qu'un seul handle par source pour une capacité donnée. Sinon, l'environnement d'exécution doit renvoyer XR_ERROR_LIMIT_REACHED .

L'application peut ensuite capturer des références d'exécution pendant la durée de l'identifiant XrSpatialReferenceCacheANDROID pour configurer un nouvel identifiant XrSpatialContextEXT.

Utilisation valide (implicite)

Codes renvoyés

Opération réussie

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Échec

  • 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 structure XrSpatialReferenceCacheCreateInfoANDROID est définie comme suit :

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

Descriptions des membres

  • type est le XrStructureType de cette structure.
  • next est NULL ou un pointeur vers la structure suivante dans une chaîne de structures. Aucune structure de ce type n'est définie dans OpenXR de base ou dans cette extension.
  • capability est un XrSpatialCapabilityEXT décrivant la capacité pour laquelle le cache de référence est créé.
  • source est un XrSpatialAnnotationReferenceSourceANDROID décrivant la source du cache de référence.

La structure XrSpatialReferenceCacheCreateInfoANDROID décrit les informations permettant de créer un handle XrSpatialReferenceCacheANDROID.

Utilisation valide (implicite)

La fonction xrCreateSpatialReferenceCacheCompleteANDROID est définie comme suit :

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

Description des paramètres

L'application peut appeler xrCreateSpatialReferenceCacheCompleteANDROID pour attendre la fin de l'opération asynchrone lancée par xrCreateSpatialReferenceCacheAsyncANDROID .

L'environnement d'exécution doit renvoyer XR_ERROR_FUTURE_PENDING_EXT si future n'est pas à l'état prêt. L'environnement d'exécution doit renvoyer XR_ERROR_FUTURE_INVALID_EXT si future a déjà été terminé ou annulé.

Utilisation valide (implicite)

Codes renvoyés

Opération réussie

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Échec

  • 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 structure XrCreateSpatialReferenceCacheCompletionANDROID est définie comme suit :

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

Descriptions des membres

  • type est le XrStructureType de cette structure.
  • next est NULL ou un pointeur vers la structure suivante dans une chaîne de structures. Aucune structure de ce type n'est définie dans OpenXR de base ou dans cette extension.
  • futureResult est le XrResult de l'opération de création du cache de référence.
  • referenceCache est le handle XrSpatialReferenceCacheANDROID si l'opération réussit.

Codes de retour futurs

Valeurs de futureResult :

Opération réussie

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Échec

  • 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 est un code de réussite, l'environnement d'exécution doit renvoyer un handle referenceCache valide. Si referenceCache est valide, il ne le reste que pendant la durée de vie de xrCreateSpatialReferenceCacheAsyncANDROID :: session ou jusqu'à ce que l'application détruise le handle avec xrDestroySpatialReferenceCacheANDROID, selon la première occurrence.

Lorsque referenceCache est valide, il enregistre les caches dans XrSystemSpatialAnnotationPropertiesANDROID :: referenceCacheTimespan .

Utilisation valide (implicite)

La fonction xrDestroySpatialReferenceCacheANDROID est définie comme suit :

XrResult xrDestroySpatialReferenceCacheANDROID(
    XrSpatialReferenceCacheANDROID              cacheHandle);

Description des paramètres

L'application peut appeler la fonction xrDestroySpatialReferenceCacheANDROID pour libérer le handle cacheHandle et les ressources sous-jacentes une fois la création du contexte spatial terminée.

Utilisation valide (implicite)

Thread safety

  • L'accès à cacheHandle et à tous les handles enfants doit être synchronisé en externe.

Codes renvoyés

Opération réussie

  • XR_SUCCESS

Échec

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_RUNTIME_FAILURE

Configuration

La structure XrSpatialCapabilityConfigurationAnnotationTrackingANDROID est définie comme suit :

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

Descriptions des membres

  • type est le XrStructureType de cette structure.
  • next est NULL ou un pointeur vers la structure suivante dans une chaîne de structures.
  • capability est un XrSpatialCapabilityEXT et doit être XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID .
  • enabledComponentCount est un uint32_t décrivant le nombre d'éléments dans le tableau enabledComponents.
  • enabledComponents est un pointeur vers un tableau de XrSpatialComponentTypeEXT .
  • cache est un XrSpatialReferenceCacheANDROID précédemment créé pour enregistrer les références d'exécution de la configuration reference.
  • time est l'XrTime auquel l'reference est capturé.
  • reference est un XrSpatialReferenceImageEXT avec des annotations associées à son pointeur suivant.

Les applications peuvent activer la fonctionnalité spatiale XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID en ajoutant un pointeur vers la structure XrSpatialCapabilityConfigurationAnnotationTrackingANDROID dans XrSpatialContextCreateInfoEXT :: capabilityConfigs .

L'environnement d'exécution doit renvoyer XR_ERROR_VALIDATION_FAILURE si capability n'est pas XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID .

L'environnement d'exécution doit renvoyer XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT si reference ne contient aucune annotation.

L'environnement d'exécution doit renvoyer XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT si le composant d'annotation est listé dans enabledComponents, mais qu'aucune annotation correspondante n'est associée à reference .

L'environnement d'exécution doit renvoyer XR_ERROR_VALIDATION_FAILURE si cache n'appartient pas à la même XrSession transmise à xrCreateSpatialContextAsyncEXT .

L'environnement d'exécution doit renvoyer XR_ERROR_TIME_INVALID si time est en dehors de la période de cache .

Utilisation valide (implicite)

Événements de suivi des annotations

La structure XrEventDataSpatialAnnotationTrackingANDROID est définie comme suit :

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

Descriptions des membres

  • type est le XrStructureType de cette structure.
  • next est NULL ou un pointeur vers la structure suivante dans une chaîne de structures.
  • spatialContext est l'élément XrSpatialContextEXT pour lequel le suivi des annotations a été activé.
  • annotationIndex correspond à l'index du tableau d'annotations associé à XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference .
  • initializationResult indique le résultat de l'initialisation de l'annotation. Si ce n'est pas XR_SUCCESS , l'application peut détruire et recréer le handle XrSpatialContextEXT pour réinitialiser l'annotation, ou continuer à utiliser spatialContext pour suivre d'autres annotations.

Utilisation valide (implicite)

L'environnement d'exécution doit renseigner XrEventDataSpatialAnnotationTrackingANDROID pour chaque annotation afin d'indiquer la fin de son initialisation. Quel que soit le résultat de l'initialisation, l'application peut libérer le tampon d'image pour réduire l'utilisation de la mémoire après avoir reçu l'événement.

L'environnement d'exécution doit renseigner initializationResult avec XR_SUCCESS si l'annotation est initialisée correctement. L'application peut ensuite extraire l'événement XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT pour suivre l'annotation.

Sinon, l'environnement d'exécution doit renseigner initializationResult avec un code d'erreur approprié pour indiquer la raison de l'échec. L'application peut détruire le handle XrSpatialContextEXT pour démarrer une nouvelle annotation ou continuer à utiliser spatialContext pour suivre d'autres annotations.

Annotation quadrilatérale

Un environnement d'exécution doit annoncer sa compatibilité avec les annotations quadrilatérales à l'aide de xrEnumerateSpatialCapabilityComponentTypesEXT en listant le type de composant suivant :

  • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

Référence Quad

La structure XrSpatialAnnotationQuadReferenceANDROID est définie comme suit :

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

Descriptions des membres

  • type est le XrStructureType de cette structure.
  • next est NULL ou un pointeur vers la structure suivante dans une chaîne de structures.
  • quadCount est un uint32_t décrivant le nombre d'éléments dans le tableau quads.
  • quads est le pointeur vers un tableau de XrSpatialAnnotationQuadANDROID .

Lorsque l'environnement d'exécution est compatible avec les annotations quad, une application peut configurer des annotations en associant une structure XrSpatialAnnotationQuadReferenceANDROID à XrSpatialReferenceImageEXT :: next et définir la référence dans XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference lors de la création du handle XrSpatialContextEXT.

L'environnement d'exécution doit renvoyer XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT à partir de xrCreateSpatialContextAsyncEXT si quadCount est égal à 0.

Utilisation valide (implicite)

La structure XrSpatialAnnotationQuadANDROID est définie comme suit :

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

Descriptions des membres

  • alignment est le XrSpatialAnnotationQuadAlignmentANDROID du quad.
  • upperLeft est un XrVector2f décrivant les coordonnées de l'angle supérieur gauche du quad par rapport à l'origine.
  • upperRight est un XrVector2f décrivant les coordonnées du coin supérieur droit du quad par rapport à l'origine.
  • lowerRight est un XrVector2f décrivant les coordonnées du coin inférieur droit du quad par rapport à l'origine.
  • lowerLeft est un XrVector2f décrivant les coordonnées du coin inférieur gauche du quad par rapport à l'origine.

Un quad dans un espace 2D est un quadrilatère convexe dans le sens des aiguilles d'une montre. La valeur des quatre angles est liée à l'origine (0, 0) à laquelle le quad est associé.

Utilisation valide (implicite)

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;

L'énumération XrSpatialAnnotationQuadAlignmentANDROID décrit l'alignement de l'annotation quad.

Les énumérations ont les significations suivantes :

Description de l'enum

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_SCREEN_ANDROID

Le quad d'annotation est parallèle au plan de l'écran, tandis que sa rotation dans le plan reste verrouillée sur la gravité du monde. Le résultat s'affiche sous la forme d'un cadre de délimitation standard et droit.

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_OBJECT_ANDROID

Le quad d'annotation est ancré directement à l'objet, en fonction de l'alignement défini dans l'image de référence. Le résultat est un quadrilatère convexe, dont la forme s'ajuste pour correspondre à la perspective de l'objet.

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_SURFACE_ANDROID

Le quad d'annotation est coplanaire avec la surface de l'objet sous-jacent, en supposant que la cible suivie est un objet ou une surface plane. Le résultat s'aligne parfaitement avec la géométrie physique de l'objet, en ajustant sa perspective pour qu'il repose à plat sur cette surface spécifique.

Composants Quad

La structure XrSpatialAnnotationQuadDataANDROID est définie comme suit :

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

Descriptions des membres

Utilisation valide (implicite)

La structure XrSpatialComponentAnnotationQuadListANDROID est définie comme suit :

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

Descriptions des membres

  • type est le XrStructureType de cette structure.
  • next est NULL ou un pointeur vers la structure suivante dans une chaîne de structures.
  • quadCount est un uint32_t décrivant le nombre d'éléments dans le tableau quads.
  • quads est un tableau de XrSpatialAnnotationQuadDataANDROID .

L'application peut interroger le composant d'annotation quad des entités spatiales dans un XrSpatialSnapshotEXT en ajoutant XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID dans XrSpatialComponentDataQueryConditionEXT :: componentTypes et en ajoutant XrSpatialComponentAnnotationQuadListANDROID à la chaîne de pointeurs suivante de XrSpatialComponentDataQueryResultEXT .

L'environnement d'exécution doit renvoyer XR_ERROR_VALIDATION_FAILURE à partir de xrQuerySpatialComponentDataEXT si XrSpatialComponentAnnotationQuadListANDROID se trouve dans la chaîne suivante de XrSpatialComponentDataQueryResultEXT :: next, mais que XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID n'est pas inclus dans XrSpatialComponentDataQueryConditionEXT :: componentTypes .

L'environnement d'exécution doit renvoyer XR_ERROR_SIZE_INSUFFICIENT à partir de xrQuerySpatialComponentDataEXT si quadCount est inférieur à XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput .

Utilisation valide (implicite)

Exemple de code

Vérifier la compatibilité de l'environnement d'exécution

L'exemple de code suivant montre comment vérifier si l'environnement d'exécution est compatible avec la fonctionnalité de suivi des annotations.

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

Configurer l'annotation quad

L'exemple de code suivant montre comment configurer l'annotation de quadrilatère.

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

Découvrir les annotations actives

L'exemple de code suivant montre comment découvrir et interroger des annotations.

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

Nouveaux types d'objets

Nouvelles commandes

Nouvelles structures

Nouvelles énumérations

Nouvelles constantes d'énumération

  • XR_ANDROID_SPATIAL_ANNOTATION_TRACKING_EXTENSION_NAME
  • XR_ANDROID_spatial_annotation_tracking_SPEC_VERSION

  • Extension de XrObjectType :

    • XR_OBJECT_TYPE_SPATIAL_REFERENCE_CACHE_ANDROID

  • Extension de XrSpatialCapabilityEXT :

    • XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID

  • Extension de XrSpatialComponentTypeEXT :

    • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

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

Problèmes

Historique des versions

  • Révision 1, 17/09/2025 (Levana Chen)

    • Description initiale de l'extension.