XR_ANDROID_spatial_annotation_tracking

Name String

XR_ANDROID_spatial_annotation_tracking

Erweiterungstyp

Instanzerweiterung

Registrierte Durchwahlnummer

795

Revision

1

Ratifikationsstatus

Nicht ratifiziert

Abhängigkeiten von Erweiterungen und Versionen

XR_EXT_spatial_entity
und
XR_EXT_spatial_image_tracking

Datum der letzten Änderung

2026-01-12

IP-Status

Es sind keine Ansprüche wegen geistigen Eigentums bekannt.

Mitwirkende

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

Übersicht

Diese Erweiterung bietet die Möglichkeit, Anmerkungen für die Erweiterung XR_EXT_spatial_entity zu verfolgen, um verschiedene Anmerkungen in der Szene zu verfolgen. So können Anwendungen Overlays auf physische oder virtuelle Objekte legen, die durch Laufzeitreferenzen definiert werden.

Diese Erweiterung bietet den einfachen Annotationstyp „Quad“, ein Polygon mit genau vier Seiten, d.h. ein konvexes Viereck, das einen verallgemeinerten 2D-Begrenzungsrahmen innerhalb einer Laufzeitreferenz darstellt. Eine Annotation für ein verfolgtes Viereck wird als räumliche Einheit mit den folgenden Komponenten dargestellt:

  • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

Anwendungen können die Erweiterung für das Tracking räumlicher Anmerkungen in der Regel in den folgenden Mustern verwenden:

  • Eine Anwendung erstellt zuerst ein Handle von XrSpatialReferenceCacheANDROID, das mit der Aufzeichnung von Laufzeitreferenzen aus der angegebenen Quelle beginnt.
  • Die Anwendung erfasst dann eine Laufzeitreferenz von XrSpatialReferenceImageEXT und definiert eine gewünschte Anmerkung innerhalb der Referenz während der Zeitspanne des Referenz-Cache.
  • Die Anwendung erstellt dann ein XrSpatialContextEXT-Handle basierend auf dem XrSpatialReferenceImageEXT, das von XrSpatialCapabilityConfigurationAnnotationTrackingANDROID bereitgestellt wird .
  • Die Anwendung kann das Handle XrSpatialReferenceCacheANDROID löschen, um die Aufzeichnung von Laufzeitreferenzen zu beenden und so die Arbeitsspeichernutzung zu reduzieren. Alternativ kann sie auf das XR_TYPE_EVENT_DATA_SPATIAL_ANNOTATION_TRACKING_ANDROID-Ereignis warten, um das Initialisierungsergebnis zu bestätigen.
  • Die Anwendung ruft dann das XR_TYPE_EVENT_DATA_SPATIAL_ANNOTATION_TRACKING_ANDROID-Ereignis ab, um das Initialisierungsergebnis der Anmerkung zu bestätigen.
  • Wenn die Initialisierung erfolgreich ist, kann die Anwendung das XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT-Ereignis abrufen, um die Annotation zu erfassen.
  • Wenn die Initialisierung fehlschlägt, kann die Anwendung den im Ereignis zurückgegebenen Fehlercode verwenden, um den Grund für den Fehler zu ermitteln, und das vorhandene XrSpatialContextEXT-Handle zerstören, um eine neue Anmerkung zu starten.
  • Unabhängig vom Initialisierungsergebnis kann die Anwendung den Bildpuffer freigeben, um die Arbeitsspeichernutzung zu verringern, nachdem das Ereignis empfangen wurde.
  • Die Anwendung ermittelt und fragt Anmerkungen gemäß den Zugriffsmustern für räumliche Einheiten ab.
  • Die Anwendung kann ein zusätzliches XrSpatialContextEXT-Handle erstellen, um Anmerkungen innerhalb einer neuen Referenz während der Zeitspanne eines gültigen XrSpatialReferenceCacheANDROID zu verfolgen .
  • Die Anwendung kann XrSpatialContextEXT-Handles löschen, um die Menge der erkennbaren und verfolgbaren Anmerkungen dynamisch zur Laufzeit zu reduzieren.

Laufzeitunterstützung

Eine Laufzeit muss ihre Unterstützung für die Annotations-Tracking-Funktion über xrEnumerateSpatialCapabilitiesEXT bekannt geben, indem sie die folgende Funktion auflistet:

  • XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID

Wenn die Laufzeit die Funktion zum Erfassen von Anmerkungen unterstützt:

Die Funktion xrEnumerateSpatialAnnotationReferenceSourcesANDROID ist so definiert:

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

Parameterbeschreibungen

  • instance ist ein Handle für eine XrInstance .
  • systemId ist die XrSystemId, deren Referenzquellen aufgelistet werden.
  • capability ist die XrSpatialCapabilityEXT, für die die Referenzquellen aufgelistet werden.
  • sourceCapacityInput ist die Kapazität des sources-Arrays oder 0, um eine Anfrage zum Abrufen der erforderlichen Kapazität anzugeben.
  • sourceCountOutput ist die Anzahl der Quellen oder die erforderliche Kapazität, falls sourceCapacityInput nicht ausreicht.
  • sources ist ein Array von XrSpatialAnnotationReferenceSourceANDROID . Kann NULL sein, wenn sourceCapacityInput = 0.
  • Eine detaillierte Beschreibung zum Abrufen der erforderlichen sources-Größe finden Sie im Abschnitt Puffergrößenparameter.

Die Anwendung kann die Liste der Referenzquellen aufzählen, die von einem bestimmten XrSystemId unterstützt werden, indem sie xrEnumerateSpatialAnnotationReferenceSourcesANDROID verwendet .

Die Laufzeit darf die Referenzquellen, deren Erweiterung nicht für instance aktiviert ist, nicht aufzählen .

Gültige Nutzung (implizit)

Rückgabecodes

Erfolg

  • XR_SUCCESS

Fehler

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

Die Enumeration XrSpatialAnnotationReferenceSourceANDROID beschreibt die Quelle der Referenz, die die Metadaten für eine Annotation bereitstellt.

Die Enums haben die folgenden Bedeutungen:

Enum-Beschreibung

XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_CAMERA_ANDROID

Das Referenzbild ist ein unbeschnittenes Bild, das von einer Android-Kamera-API ausgegeben wird, z.B. ein Bild von einem ImageReader, der mit einem Camera2-CameraDevice verknüpft ist, oder ein ImageProxy von einer ImageAnalysis, die mit CameraX verknüpft ist. In der Regel ist das eine der nach vorn gerichteten RGB-Kameras.

XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_MEDIA_PROJECTION_ANDROID

Das Referenzbild ist ein unbeschnittenes Bild, das von der Android MediaProjection API ausgegeben wird, z.B. ein Bild von einem ImageReader, der einem virtuellen MediaProjection-Display zugeordnet ist. Sie kann sowohl virtuelle als auch reale Inhalte umfassen.

Die Struktur XrSystemSpatialAnnotationPropertiesANDROID ist so definiert:

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

Mitgliederbeschreibungen

  • type ist der XrStructureType dieser Struktur.
  • next ist NULL oder ein Zeiger auf die nächste Struktur in einer Strukturkette.
  • referenceCacheTimespan gibt den Zeitraum in Sekunden für ein gültiges XrSpatialReferenceCacheANDROID-Handle an.
  • maxReferencePixelWidth gibt die maximale Breite des Rands von Referenzbildern in Pixeln an.
  • maxReferencePixelHeight gibt die maximale Höhe des Rands von Referenzbildern in Pixeln an.
  • maxReferenceCount gibt die maximale Anzahl von Referenzbildern an, die gleichzeitig zugewiesen werden können.
  • maxAnnotationCount gibt die maximale Anzahl von gleichzeitig zu verfolgenden Anmerkungen an.

Wenn die Laufzeit die Funktion zur Annotation-Erfassung unterstützt, kann eine Anwendung relevante Systemeigenschaften prüfen, indem sie beim Aufrufen von xrGetSystemProperties eine XrSystemSpatialAnnotationPropertiesANDROID-Struktur an die XrSystemProperties-Struktur anhängt .

Wenn XrSpatialReferenceImageEXT :: width aus XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference größer als maxReferencePixelWidth ist, muss die Laufzeit XR_ERROR_VALIDATION_FAILURE zurückgeben, wenn xrCreateSpatialContextAsyncEXT aufgerufen wird .

Wenn XrSpatialReferenceImageEXT :: height aus XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference den Wert maxReferencePixelHeight überschreitet, muss die Laufzeit XR_ERROR_VALIDATION_FAILURE zurückgeben, wenn xrCreateSpatialContextAsyncEXT aufgerufen wird .

Wenn XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: time außerhalb des Zeitraums von XrSpatialReferenceCacheANDROID :: cache liegt, muss die Laufzeit XR_ERROR_TIME_INVALID zurückgeben, wenn xrCreateSpatialContextAsyncEXT aufgerufen wird . Die Anwendung kann das Handle XrSpatialContextEXT mit einer neuen Referenz während der Zeitspanne von XrSpatialReferenceCacheANDROID neu erstellen .

Wenn die Anzahl der zugewiesenen Referenzbilder maxReferenceCount überschreitet , muss die Laufzeit XR_ERROR_LIMIT_REACHED zurückgeben und den Initialisierungsfehler über XrEventDataSpatialAnnotationTrackingANDROID :: initializationResult angeben . Die Anwendung kann das XrSpatialContextEXT-Handle zerstören und es nach Abschluss der ausstehenden Initialisierung noch einmal versuchen.

Wenn die Anzahl der aktiven Anmerkungen maxAnnotationCount überschreitet , muss die Laufzeit beim Aufrufen von xrCreateSpatialContextAsyncEXT den Wert XR_ERROR_VALIDATION_FAILURE zurückgeben .

Gültige Nutzung (implizit)

Laufzeitreferenz-Cache

XR_DEFINE_HANDLE(XrSpatialReferenceCacheANDROID)

Das Handle XrSpatialReferenceCacheANDROID stellt einen Cache von Laufzeitreferenzen dar, die aus einer bestimmten Quelle aufgezeichnet wurden.

Die Funktion xrCreateSpatialReferenceCacheAsyncANDROID ist so definiert:

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

Parameterbeschreibungen

  • session ist eine XrSession, in der der Referenzcache aktiv ist.
  • createInfo ist ein Zeiger auf ein XrSpatialReferenceCacheCreateInfoANDROID, mit dem die Parameter des Referenz-Cache angegeben werden.
  • future ist ein Zeiger auf das Ausgabeargument eines XrFutureEXT .

Die Anwendung kann ein XrSpatialReferenceCacheANDROID-Handle erstellen, indem sie xrCreateSpatialReferenceCacheAsyncANDROID aufruft . Es kann einige Zeit dauern, bis die Tracking-Dienste initialisiert sind. Die Anwendung kann dann wiederholt xrCreateSpatialReferenceCacheCompleteANDROID aufrufen, um den Abschluss dieses asynchronen Vorgangs zu prüfen.

Die Laufzeit muss XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT zurückgeben, wenn XrSpatialReferenceCacheCreateInfoANDROID :: capability nicht von xrEnumerateSpatialCapabilitiesEXT aufgeführt wird .

Die Laufzeit muss XR_ERROR_FEATURE_UNSUPPORTED zurückgeben, wenn XrSpatialReferenceCacheCreateInfoANDROID :: source nicht von xrEnumerateSpatialAnnotationReferenceSourcesANDROID für die angegebene Funktion aufgeführt wird.

Die Anwendung kann nur ein Handle pro Quelle für eine bestimmte Funktion erstellen. Andernfalls muss die Laufzeit XR_ERROR_LIMIT_REACHED zurückgeben .

Die Anwendung kann dann während des Zeitraums des XrSpatialReferenceCacheANDROID-Handles Laufzeitreferenzen erfassen, um ein neues XrSpatialContextEXT-Handle zu konfigurieren.

Gültige Nutzung (implizit)

Rückgabecodes

Erfolg

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Fehler

  • 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

Die Struktur XrSpatialReferenceCacheCreateInfoANDROID ist so definiert:

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

Mitgliederbeschreibungen

  • type ist der XrStructureType dieser Struktur.
  • next ist NULL oder ein Zeiger auf die nächste Struktur in einer Strukturkette. Solche Strukturen sind in OpenXR Core oder dieser Erweiterung nicht definiert.
  • capability ist ein XrSpatialCapabilityEXT, das beschreibt, für welche Funktion der Referenzcache erstellt wird.
  • source ist ein XrSpatialAnnotationReferenceSourceANDROID, das die Quelle des Referenz-Cache beschreibt.

Die Struktur XrSpatialReferenceCacheCreateInfoANDROID beschreibt die Informationen zum Erstellen eines XrSpatialReferenceCacheANDROID-Handles.

Gültige Nutzung (implizit)

Die Funktion xrCreateSpatialReferenceCacheCompleteANDROID ist so definiert:

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

Parameterbeschreibungen

Die Anwendung kann xrCreateSpatialReferenceCacheCompleteANDROID aufrufen, um auf den Abschluss des asynchronen Vorgangs zu warten, der von xrCreateSpatialReferenceCacheAsyncANDROID gestartet wurde .

Die Laufzeit muss XR_ERROR_FUTURE_PENDING_EXT zurückgeben, wenn future nicht bereit ist. Die Laufzeit muss XR_ERROR_FUTURE_INVALID_EXT zurückgeben, wenn future bereits abgeschlossen oder abgebrochen wurde.

Gültige Nutzung (implizit)

Rückgabecodes

Erfolg

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Fehler

  • 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

Die Struktur XrCreateSpatialReferenceCacheCompletionANDROID ist so definiert:

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

Mitgliederbeschreibungen

  • type ist der XrStructureType dieser Struktur.
  • next ist NULL oder ein Zeiger auf die nächste Struktur in einer Strukturkette. Solche Strukturen sind in OpenXR Core oder dieser Erweiterung nicht definiert.
  • futureResult ist das XrResult des Vorgangs zum Erstellen des Referenzcaches.
  • referenceCache ist das XrSpatialReferenceCacheANDROID-Handle, wenn der Vorgang erfolgreich ist.

Zukünftige Rückgabecodes

futureResult-Werte:

Erfolg

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Fehler

  • 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

Wenn futureResult ein Erfolgscode ist, muss die Laufzeit ein gültiges referenceCache-Handle zurückgeben. Wenn referenceCache gültig ist, bleibt es nur innerhalb der Lebensdauer von xrCreateSpatialReferenceCacheAsyncANDROID :: session oder bis die Anwendung das Handle mit xrDestroySpatialReferenceCacheANDROID zerstört, je nachdem, was zuerst eintritt.

Wenn referenceCache gültig ist, werden Caches in XrSystemSpatialAnnotationPropertiesANDROID :: referenceCacheTimespan aufgezeichnet .

Gültige Nutzung (implizit)

Die Funktion xrDestroySpatialReferenceCacheANDROID ist so definiert:

XrResult xrDestroySpatialReferenceCacheANDROID(
    XrSpatialReferenceCacheANDROID              cacheHandle);

Parameterbeschreibungen

Die Anwendung kann die Funktion xrDestroySpatialReferenceCacheANDROID aufrufen, um das cacheHandle-Handle und die zugrunde liegenden Ressourcen freizugeben, wenn die Erstellung des räumlichen Kontexts abgeschlossen ist.

Gültige Nutzung (implizit)

Threadsicherheit

  • Der Zugriff auf cacheHandle und alle untergeordneten Handles muss extern synchronisiert werden.

Rückgabecodes

Erfolg

  • XR_SUCCESS

Fehler

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID

Konfiguration

Die Struktur XrSpatialCapabilityConfigurationAnnotationTrackingANDROID ist so definiert:

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

Mitgliederbeschreibungen

  • type ist der XrStructureType dieser Struktur.
  • next ist NULL oder ein Zeiger auf die nächste Struktur in einer Strukturkette.
  • capability ist eine XrSpatialCapabilityEXT und muss XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID sein .
  • enabledComponentCount ist ein uint32_t, das die Anzahl der Elemente im enabledComponents-Array beschreibt.
  • enabledComponents ist ein Zeiger auf ein Array vom Typ XrSpatialComponentTypeEXT .
  • cache ist ein XrSpatialReferenceCacheANDROID, das zuvor erstellt wurde, um Laufzeitreferenzen für die reference-Konfiguration aufzuzeichnen.
  • time ist der XrTime, zu dem das reference erfasst wird.
  • reference ist ein XrSpatialReferenceImageEXT mit Annotationen, die an den Next-Pointer angehängt sind.

Anwendungen können die räumliche Funktion XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID aktivieren, indem sie einen Zeiger auf die Struktur XrSpatialCapabilityConfigurationAnnotationTrackingANDROID in XrSpatialContextCreateInfoEXT :: capabilityConfigs einfügen .

Die Laufzeit muss XR_ERROR_VALIDATION_FAILURE zurückgeben, wenn capability nicht XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID ist .

Die Laufzeit muss XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT zurückgeben, wenn reference keine Anmerkungen enthält.

Die Laufzeit muss XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT zurückgeben, wenn die Annotationskomponente in enabledComponents aufgeführt ist, aber keine entsprechenden Annotationen mit reference verknüpft sind .

Die Laufzeit muss XR_ERROR_VALIDATION_FAILURE zurückgeben, wenn cache nicht derselben XrSession gehört, die an xrCreateSpatialContextAsyncEXT übergeben wird .

Die Laufzeit muss XR_ERROR_TIME_INVALID zurückgeben, wenn time außerhalb des Zeitraums von cache liegt .

Gültige Nutzung (implizit)

Tracking-Ereignisse für Anmerkungen

Die Struktur XrEventDataSpatialAnnotationTrackingANDROID ist so definiert:

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

Mitgliederbeschreibungen

  • type ist der XrStructureType dieser Struktur.
  • next ist NULL oder ein Zeiger auf die nächste Struktur in einer Strukturkette.
  • spatialContext ist der XrSpatialContextEXT, für den die Annotationserkennung aktiviert wurde.
  • annotationIndex entspricht dem Index aus dem Annotationsarray, das mit XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference verknüpft ist .
  • initializationResult gibt das Initialisierungsergebnis der Annotation an. Wenn es nicht XR_SUCCESS ist, kann die Anwendung das XrSpatialContextEXT-Handle zerstören und neu erstellen, um die Annotation neu zu initialisieren, oder spatialContext verwenden, um andere Annotationen zu verfolgen.

Gültige Nutzung (implizit)

Die Laufzeit muss für jede Anmerkung XrEventDataSpatialAnnotationTrackingANDROID ausfüllen, um den Abschluss der Initialisierung anzugeben. Unabhängig vom Initialisierungsergebnis kann die Anwendung den Bildpuffer freigeben, um die Arbeitsspeichernutzung zu reduzieren, nachdem sie das Ereignis empfangen hat.

Die Laufzeit muss initializationResult mit XR_SUCCESS füllen, wenn die Annotation erfolgreich initialisiert wurde. Die Anwendung kann dann das Ereignis XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT abrufen, um die Annotation zu verfolgen.

Andernfalls muss die Laufzeit initializationResult mit einem entsprechenden Fehlercode füllen, um den Grund für den Fehler anzugeben. Die Anwendung kann das XrSpatialContextEXT-Handle löschen, um eine neue Anmerkung zu starten oder weiterhin spatialContext zu verwenden, um andere Anmerkungen zu verfolgen.

Quad-Annotation

Eine Laufzeit muss ihre Unterstützung für Quad-Anmerkungen mit xrEnumerateSpatialCapabilityComponentTypesEXT bewerben, indem sie den folgenden Komponententyp auflistet:

  • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

Quad-Referenz

Die Struktur XrSpatialAnnotationQuadReferenceANDROID ist so definiert:

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

Mitgliederbeschreibungen

  • type ist der XrStructureType dieser Struktur.
  • next ist NULL oder ein Zeiger auf die nächste Struktur in einer Strukturkette.
  • quadCount ist ein uint32_t, das die Anzahl der Elemente im quads-Array beschreibt.
  • quads ist der Zeiger auf ein Array von XrSpatialAnnotationQuadANDROID .

Wenn die Laufzeit Quad-Anmerkungen unterstützt, kann eine Anwendung Anmerkungen konfigurieren, indem sie eine XrSpatialAnnotationQuadReferenceANDROID-Struktur an XrSpatialReferenceImageEXT :: next anhängt und die Referenz in XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference festlegt, wenn das XrSpatialContextEXT-Handle erstellt wird.

Die Laufzeit muss XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT von xrCreateSpatialContextAsyncEXT zurückgeben, wenn quadCount = 0 ist.

Gültige Nutzung (implizit)

Die Struktur XrSpatialAnnotationQuadANDROID ist so definiert:

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

Mitgliederbeschreibungen

  • alignment ist die XrSpatialAnnotationQuadAlignmentANDROID des Vierecks.
  • upperLeft ist ein XrVector2f, das die Koordinate der oberen linken Ecke des Vierecks in Bezug auf den Ursprung beschreibt.
  • upperRight ist ein XrVector2f, das die Koordinate der oberen rechten Ecke des Rechtecks in Bezug auf den Ursprung beschreibt.
  • lowerRight ist ein XrVector2f, das die Koordinate der unteren rechten Ecke des Quads in Bezug auf den Ursprung beschreibt.
  • lowerLeft ist ein XrVector2f, das die Koordinate der unteren linken Ecke des Quads in Bezug auf den Ursprung beschreibt.

Ein Quad im 2D-Raum ist ein konvexes Viereck mit einer Reihenfolge im Uhrzeigersinn. Die Werte der vier Ecken beziehen sich auf den Ursprung (0, 0), dem das Viereck zugeordnet ist.

Gültige Nutzung (implizit)

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;

Die Enumeration XrSpatialAnnotationQuadAlignmentANDROID beschreibt die Ausrichtung der Quad-Annotation.

Die Enums haben die folgenden Bedeutungen:

Enum-Beschreibung

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_SCREEN_ANDROID

Das Anmerkungs-Quad ist parallel zur Bildschirmebene, während seine Rotation in der Ebene an die Schwerkraft der Welt gebunden bleibt. Die Ausgabe wird als normaler, aufrechter Begrenzungsrahmen angezeigt.

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_OBJECT_ANDROID

Das Annotations-Quad ist direkt am Objekt verankert und entspricht der Ausrichtung, die im Referenzbild definiert ist. Die Ausgabe ist ein konvexes Viereck, dessen Form an die Perspektive des Objekts angepasst wird.

Quad-Komponenten

Die Struktur XrSpatialAnnotationQuadDataANDROID ist so definiert:

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

Mitgliederbeschreibungen

Gültige Nutzung (implizit)

Die Struktur XrSpatialComponentAnnotationQuadListANDROID ist so definiert:

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

Mitgliederbeschreibungen

  • type ist der XrStructureType dieser Struktur.
  • next ist NULL oder ein Zeiger auf die nächste Struktur in einer Strukturkette.
  • quadCount ist ein uint32_t, das die Anzahl der Elemente im quads-Array beschreibt.
  • quads ist ein Array von XrSpatialAnnotationQuadDataANDROID .

Die Anwendung kann die Quad-Anmerkungskomponente der räumlichen Entitäten in einem XrSpatialSnapshotEXT abfragen, indem sie XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID in XrSpatialComponentDataQueryConditionEXT :: componentTypes hinzufügt und XrSpatialComponentAnnotationQuadListANDROID der Next-Zeiger-Kette von XrSpatialComponentDataQueryResultEXT hinzufügt .

Die Laufzeit muss XR_ERROR_VALIDATION_FAILURE von xrQuerySpatialComponentDataEXT zurückgeben, wenn XrSpatialComponentAnnotationQuadListANDROID in der nächsten Kette von XrSpatialComponentDataQueryResultEXT :: next enthalten ist, aber XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID nicht in XrSpatialComponentDataQueryConditionEXT :: componentTypes enthalten ist .

Die Laufzeit muss XR_ERROR_SIZE_INSUFFICIENT von xrQuerySpatialComponentDataEXT zurückgeben, wenn quadCount kleiner als XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput ist .

Gültige Nutzung (implizit)

Beispielcode

Laufzeitunterstützung prüfen

Der folgende Beispielcode zeigt, wie Sie prüfen können, ob die Laufzeit die Funktion zum Erfassen von Anmerkungen unterstützt.

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

Quad-Anmerkung konfigurieren

Das folgende Beispiel zeigt, wie Sie die Quad-Annotation konfigurieren.

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

Aktive Anmerkungen ansehen

Der folgende Beispielcode zeigt, wie Sie Anmerkungen ermitteln und abfragen.

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

Neue Objekttypen

Neue Befehle

Neue Strukturen

Neue Enums

Neue Enum-Konstanten

  • XR_ANDROID_SPATIAL_ANNOTATION_TRACKING_EXTENSION_NAME
  • XR_ANDROID_spatial_annotation_tracking_SPEC_VERSION

  • XrObjectType erweitern :

    • XR_OBJECT_TYPE_SPATIAL_REFERENCE_CACHE_ANDROID

  • Erweitern von XrSpatialCapabilityEXT :

    • XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID

  • Erweitern von XrSpatialComponentTypeEXT :

    • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

  • Erweitern von 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

Probleme

Versionsverlauf

  • Revision 1, 17.09.2025 (Levana Chen)

    • Erste Beschreibung der Erweiterung.