XR_ANDROID_spatial_annotation_tracking

Ciąg znaków nazwy

XR_ANDROID_spatial_annotation_tracking

Typ rozszerzenia

Rozszerzenie instancji

Zarejestrowany numer wewnętrzny

795

Wersja

1

Stan ratyfikacji

Nie ratyfikowano

Zależności rozszerzeń i wersji

XR_EXT_spatial_entity
oraz
XR_EXT_spatial_image_tracking

Data ostatniej modyfikacji

2026-01-12

Stan adresu IP

Brak znanych roszczeń dotyczących własności intelektualnej.

Twórcy

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

Omówienie

To rozszerzenie zapewnia możliwość śledzenia adnotacji w rozszerzeniu XR_EXT_spatial_entity, aby śledzić różne adnotacje w scenie. Umożliwia aplikacjom nakładanie warstw na obiekty fizyczne lub wirtualne zdefiniowane przez odwołania w czasie działania.

To rozszerzenie udostępnia podstawowy typ adnotacji „Quad”, czyli wielokąt o dokładnie 4 bokach, tj. wypukły czworokąt, reprezentujący uogólnioną 2-wymiarową ramkę ograniczającą w odniesieniu do środowiska wykonawczego. Śledzona adnotacja w postaci czworokąta jest reprezentowana jako jednostka przestrzenna, która ma te komponenty:

  • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

Aplikacje mogą zwykle używać rozszerzenia śledzenia adnotacji przestrzennych w tych wzorcach:

  • Aplikacja najpierw tworzy uchwyt XrSpatialReferenceCacheANDROID, który zaczyna rejestrować odwołania do środowiska wykonawczego z danego źródła.
  • Aplikacja przechwytuje następnie odwołanie w czasie działania do XrSpatialReferenceImageEXT i określa w nim żądaną adnotację w okresie istnienia pamięci podręcznej odwołania.
  • Aplikacja tworzy następnie uchwyt XrSpatialContextEXT na podstawie elementu XrSpatialReferenceImageEXT podanego przez XrSpatialCapabilityConfigurationAnnotationTrackingANDROID .
  • Aplikacja może zniszczyć uchwyt XrSpatialReferenceCacheANDROID, aby zatrzymać rejestrowanie odwołań w czasie działania i zmniejszyć wykorzystanie pamięci, lub poczekać na zdarzenie XR_TYPE_EVENT_DATA_SPATIAL_ANNOTATION_TRACKING_ANDROID, aby potwierdzić wynik inicjowania.
  • Aplikacja pobiera następnie zdarzenie XR_TYPE_EVENT_DATA_SPATIAL_ANNOTATION_TRACKING_ANDROID, aby potwierdzić wynik inicjowania adnotacji.
  • Jeśli inicjowanie się powiedzie, aplikacja może pobrać zdarzenie XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT, aby śledzić adnotację.
  • Jeśli inicjowanie się nie powiedzie, aplikacja może użyć kodu błędu zwróconego w wydarzeniu, aby określić przyczynę niepowodzenia, i zniszczyć istniejący uchwyt XrSpatialContextEXT, aby rozpocząć nową adnotację.
  • Niezależnie od wyniku inicjowania aplikacja może zwolnić bufor obrazu, aby zmniejszyć wykorzystanie pamięci po otrzymaniu zdarzenia.
  • Aplikacja wykrywa i wykonuje zapytania dotyczące adnotacji zgodnie ze wzorcami dostępu do obiektów przestrzennych.
  • Aplikacja może utworzyć dodatkowy uchwyt XrSpatialContextEXT, aby śledzić adnotacje w nowym odniesieniu w okresie ważności XrSpatialReferenceCacheANDROID .
  • Aplikacja może niszczyć uchwyty XrSpatialContextEXT, aby dynamicznie zmniejszać w czasie działania aplikacji zestaw wykrywanych i śledzonych adnotacji.

Obsługa środowiska wykonawczego

Środowisko wykonawcze musi reklamować obsługę funkcji śledzenia adnotacji za pomocą funkcji xrEnumerateSpatialCapabilitiesEXT, wymieniając te możliwości:

  • XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID

Gdy środowisko wykonawcze obsługuje funkcję śledzenia adnotacji:

Funkcja xrEnumerateSpatialAnnotationReferenceSourcesANDROID jest zdefiniowana w ten sposób:

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

Opisy parametrów

  • instance to uchwyt do XrInstance .
  • systemId to XrSystemId, którego źródła odniesienia zostaną wymienione.
  • capability to XrSpatialCapabilityEXT, dla którego zostaną wyliczone źródła odniesienia.
  • sourceCapacityInput to pojemność tablicy sources lub 0, aby wskazać żądanie pobrania wymaganej pojemności.
  • sourceCountOutput to liczba źródeł lub wymagana pojemność w przypadku, gdy sourceCapacityInput jest niewystarczająca.
  • sources to tablica elementów XrSpatialAnnotationReferenceSourceANDROID . Może to być NULL, jeśli sourceCapacityInput wynosi 0.
  • Szczegółowy opis pobierania wymaganego rozmiaru sources znajdziesz w sekcji Parametry rozmiaru bufora.

Aplikacja może wyliczyć listę źródeł odniesienia obsługiwanych przez dany XrSystemId za pomocą funkcji xrEnumerateSpatialAnnotationReferenceSourcesANDROID .

Środowisko wykonawcze nie może wyliczać źródeł odniesienia, których rozszerzenie nie jest włączone w przypadku instance .

Prawidłowe użycie (domyślne)

Kody zwrotne

Sukces

  • XR_SUCCESS

Błąd

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

Wyliczenie XrSpatialAnnotationReferenceSourceANDROID opisuje źródło odniesienia, które dostarcza metadane adnotacji.

Wartości wyliczeniowe mają następujące znaczenia:

Opis typu wyliczeniowego

XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_CAMERA_ANDROID

Obraz referencyjny to nieprzycięty obraz wyjściowy z interfejsu API aparatu na Androidzie, np. obraz z ImageReadera powiązanego z CameraDevice w Camera2 lub ImageProxy z ImageAnalysis powiązanego z CameraX. Zwykle jest to jeden z aparatów RGB skierowany do przodu.

XR_SPATIAL_ANNOTATION_REFERENCE_SOURCE_MEDIA_PROJECTION_ANDROID

Obraz referencyjny to nieprzycięty obraz wyjściowy z interfejsu Android MediaProjection API, np. obraz z interfejsu ImageReader powiązanego z wirtualnym wyświetlaczem MediaProjection. Może zawierać treści wirtualne i rzeczywiste.

Struktura XrSystemSpatialAnnotationPropertiesANDROID jest zdefiniowana w ten sposób:

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

Opisy członków

  • type to XrStructureType tej struktury.
  • next to NULL lub wskaźnik do następnej struktury w łańcuchu struktur.
  • referenceCacheTimespan oznacza okres ważności w sekundach prawidłowego uchwytu XrSpatialReferenceCacheANDROID.
  • maxReferencePixelWidth oznacza maksymalną szerokość krawędzi obrazów referencyjnych w pikselach.
  • maxReferencePixelHeight oznacza maksymalną wysokość krawędzi obrazów referencyjnych w pikselach.
  • maxReferenceCount oznacza maksymalną liczbę obrazów referencyjnych, które mają być przydzielane w tym samym czasie.
  • maxAnnotationCount oznacza maksymalną liczbę adnotacji, które mają być śledzone w tym samym czasie.

Gdy środowisko wykonawcze obsługuje funkcję śledzenia adnotacji, aplikacja może sprawdzić odpowiednie właściwości systemu, łącząc strukturę XrSystemSpatialAnnotationPropertiesANDROID ze strukturą XrSystemProperties podczas wywoływania funkcji xrGetSystemProperties .

Jeśli XrSpatialReferenceImageEXT :: width z XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference przekracza maxReferencePixelWidth , środowisko wykonawcze musi zwrócić XR_ERROR_VALIDATION_FAILURE podczas wywoływania funkcji xrCreateSpatialContextAsyncEXT .

Jeśli XrSpatialReferenceImageEXT :: height z XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference przekracza maxReferencePixelHeight , środowisko wykonawcze musi zwrócić XR_ERROR_VALIDATION_FAILURE podczas wywoływania funkcji xrCreateSpatialContextAsyncEXT .

Jeśli XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: time wykracza poza zakres czasu XrSpatialReferenceCacheANDROID :: cache , środowisko wykonawcze musi zwrócić XR_ERROR_TIME_INVALID podczas wywoływania funkcji xrCreateSpatialContextAsyncEXT . Aplikacja może ponownie utworzyć uchwyt XrSpatialContextEXT z nowym odniesieniem w okresie istnienia XrSpatialReferenceCacheANDROID .

Jeśli liczba przydzielonych obrazów referencyjnych przekracza maxReferenceCount , środowisko wykonawcze musi zwrócić XR_ERROR_LIMIT_REACHED i wskazać niepowodzenie inicjowania za pomocą XrEventDataSpatialAnnotationTrackingANDROID :: initializationResult . Aplikacja może zniszczyć uchwyt XrSpatialContextEXT i spróbować ponownie po zakończeniu oczekującej inicjalizacji.

Jeśli liczba aktywnych adnotacji przekracza maxAnnotationCount , środowisko wykonawcze musi zwracać XR_ERROR_VALIDATION_FAILURE podczas wywoływania funkcji xrCreateSpatialContextAsyncEXT .

Prawidłowe użycie (domyślne)

Pamięć podręczna odwołań w środowisku wykonawczym

XR_DEFINE_HANDLE(XrSpatialReferenceCacheANDROID)

Uchwyt XrSpatialReferenceCacheANDROID reprezentuje pamięć podręczną odniesień do środowiska wykonawczego zarejestrowanych z danego źródła.

Funkcja xrCreateSpatialReferenceCacheAsyncANDROID jest zdefiniowana w ten sposób:

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

Opisy parametrów

  • session to XrSession, w której pamięć podręczna referencji będzie aktywna.
  • createInfo to wskaźnik struktury XrSpatialReferenceCacheCreateInfoANDROID, która służy do określania parametrów pamięci podręcznej odniesienia.
  • future to wskaźnik do uchwytu wyjściowego elementu XrFutureEXT .

Aplikacja może utworzyć uchwyt XrSpatialReferenceCacheANDROID, wywołując funkcję xrCreateSpatialReferenceCacheAsyncANDROID . Inicjowanie usług śledzenia może zająć trochę czasu. Aplikacja może następnie wielokrotnie wywoływać funkcję xrCreateSpatialReferenceCacheCompleteANDROID, aby sprawdzić, czy ta operacja asynchroniczna została zakończona.

Środowisko wykonawcze musi zwrócić XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT, jeśli XrSpatialReferenceCacheCreateInfoANDROID :: capability nie jest wymienione przez xrEnumerateSpatialCapabilitiesEXT .

Środowisko wykonawcze musi zwrócić XR_ERROR_FEATURE_UNSUPPORTED, jeśli XrSpatialReferenceCacheCreateInfoANDROID :: source nie jest wymienione przez xrEnumerateSpatialAnnotationReferenceSourcesANDROID dla danej funkcji.

Aplikacja może utworzyć tylko 1 uchwyt na źródło dla danej funkcji. W przeciwnym razie środowisko wykonawcze musi zwrócić wartość XR_ERROR_LIMIT_REACHED .

Aplikacja może następnie przechwytywać odniesienia w czasie działania uchwytu XrSpatialReferenceCacheANDROID, aby skonfigurować nowy uchwyt XrSpatialContextEXT.

Prawidłowe użycie (domyślne)

Kody zwrotne

Sukces

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Błąd

  • 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

Struktura XrSpatialReferenceCacheCreateInfoANDROID jest zdefiniowana w ten sposób:

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

Opisy członków

  • type to XrStructureType tej struktury.
  • next to NULL lub wskaźnik do następnej struktury w łańcuchu struktur. W podstawowej specyfikacji OpenXR ani w tym rozszerzeniu nie zdefiniowano takich struktur.
  • capability to XrSpatialCapabilityEXT opisujący, dla której funkcji tworzona jest pamięć podręczna odniesienia.
  • source to XrSpatialAnnotationReferenceSourceANDROID opisujący źródło pamięci podręcznej odniesienia.

Struktura XrSpatialReferenceCacheCreateInfoANDROID zawiera informacje potrzebne do utworzenia uchwytu XrSpatialReferenceCacheANDROID.

Prawidłowe użycie (domyślne)

Funkcja xrCreateSpatialReferenceCacheCompleteANDROID jest zdefiniowana w ten sposób:

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

Opisy parametrów

Aplikacja może wywołać funkcję xrCreateSpatialReferenceCacheCompleteANDROID, aby poczekać na zakończenie operacji asynchronicznej rozpoczętej przez funkcję xrCreateSpatialReferenceCacheAsyncANDROID .

Środowisko wykonawcze musi zwracać wartość XR_ERROR_FUTURE_PENDING_EXT, jeśli future nie jest w stanie gotowości. Środowisko wykonawcze musi zwrócić wartość XR_ERROR_FUTURE_INVALID_EXT, jeśli future zostało już ukończone lub anulowane.

Prawidłowe użycie (domyślne)

Kody zwrotne

Sukces

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Błąd

  • 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

Struktura XrCreateSpatialReferenceCacheCompletionANDROID jest zdefiniowana w ten sposób:

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

Opisy członków

  • type to XrStructureType tej struktury.
  • next to NULL lub wskaźnik do następnej struktury w łańcuchu struktur. W podstawowej specyfikacji OpenXR ani w tym rozszerzeniu nie zdefiniowano takich struktur.
  • futureResult to XrResult operacji tworzenia pamięci podręcznej odniesienia.
  • Jeśli operacja się powiedzie, referenceCache będzie uchwytem XrSpatialReferenceCacheANDROID.

Kody zwrotu w przyszłości

Wartości futureResult:

Sukces

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Błąd

  • 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

Jeśli futureResult jest kodem powodzenia, środowisko wykonawcze musi zwrócić prawidłowy uchwyt referenceCache. Jeśli referenceCache jest prawidłowy, pozostaje taki tylko przez okres istnienia xrCreateSpatialReferenceCacheAsyncANDROID :: session lub do momentu, gdy aplikacja zniszczy uchwyt za pomocą funkcji xrDestroySpatialReferenceCacheANDROID, w zależności od tego, co nastąpi wcześniej.

Gdy referenceCache jest prawidłowe, zapisuje pamięci podręczne w XrSystemSpatialAnnotationPropertiesANDROID :: referenceCacheTimespan .

Prawidłowe użycie (domyślne)

Funkcja xrDestroySpatialReferenceCacheANDROID jest zdefiniowana w ten sposób:

XrResult xrDestroySpatialReferenceCacheANDROID(
    XrSpatialReferenceCacheANDROID              cacheHandle);

Opisy parametrów

Aplikacja może wywołać funkcję xrDestroySpatialReferenceCacheANDROID, aby zwolnić uchwyt cacheHandle i powiązane z nim zasoby po zakończeniu tworzenia kontekstu przestrzennego.

Prawidłowe użycie (domyślne)

Bezpieczeństwo wątków

  • Dostęp do cacheHandle i wszystkich uchwytów podrzędnych musi być synchronizowany zewnętrznie.

Kody zwrotne

Sukces

  • XR_SUCCESS

Błąd

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID

Konfiguracja

Struktura XrSpatialCapabilityConfigurationAnnotationTrackingANDROID jest zdefiniowana w ten sposób:

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

Opisy członków

  • type to XrStructureType tej struktury.
  • next to NULL lub wskaźnik do następnej struktury w łańcuchu struktur.
  • capability to XrSpatialCapabilityEXT i musi mieć wartość XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID .
  • enabledComponentCount to uint32_t opisujący liczbę elementów w tablicy enabledComponents.
  • enabledComponents to wskaźnik tablicy XrSpatialComponentTypeEXT .
  • cache to utworzony wcześniej obiekt XrSpatialReferenceCacheANDROID, który służy do rejestrowania odwołań w czasie działania w konfiguracji reference.
  • time to XrTime, w którym reference jest rejestrowany.
  • reference to XrSpatialReferenceImageEXT z adnotacjami połączonymi z jego następnym wskaźnikiem.

Aplikacje mogą włączyć XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID funkcję przestrzenną, dodając wskaźnik do struktury XrSpatialCapabilityConfigurationAnnotationTrackingANDROID w XrSpatialContextCreateInfoEXT :: capabilityConfigs .

Środowisko wykonawcze musi zwrócić wartość XR_ERROR_VALIDATION_FAILURE, jeśli capability nie jest równe XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID .

Środowisko wykonawcze musi zwracać wartość XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT, jeśli reference nie zawiera adnotacji.

Środowisko wykonawcze musi zwrócić wartość XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT, jeśli komponent adnotacji jest wymieniony w enabledComponents, ale z reference nie są powiązane żadne adnotacje .

Środowisko wykonawcze musi zwrócić XR_ERROR_VALIDATION_FAILURE, jeśli cache nie należy do tej samej sesji XrSession przekazywanej do funkcji xrCreateSpatialContextAsyncEXT .

Środowisko wykonawcze musi zwrócić wartość XR_ERROR_TIME_INVALID, jeśli wartość time wykracza poza zakres czasu cache .

Prawidłowe użycie (domyślne)

Zdarzenia śledzenia adnotacji

Struktura XrEventDataSpatialAnnotationTrackingANDROID jest zdefiniowana w ten sposób:

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

Opisy członków

  • type to XrStructureType tej struktury.
  • next to NULL lub wskaźnik do następnej struktury w łańcuchu struktur.
  • spatialContext to XrSpatialContextEXT, w przypadku którego włączono śledzenie adnotacji.
  • annotationIndex mapuje na indeks z tablicy adnotacji powiązanej z XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference .
  • initializationResult oznacza wynik inicjowania adnotacji. Jeśli nie jest to XR_SUCCESS, aplikacja może zniszczyć i ponownie utworzyć uchwyt XrSpatialContextEXT, aby ponownie zainicjować adnotację, lub nadal używać spatialContext do śledzenia innych adnotacji.

Prawidłowe użycie (domyślne)

Środowisko wykonawcze musi wypełnić pole XrEventDataSpatialAnnotationTrackingANDROID dla każdej adnotacji, aby wskazać zakończenie jej inicjowania. Niezależnie od wyniku inicjowania aplikacja może zwolnić bufor obrazu, aby zmniejszyć wykorzystanie pamięci po otrzymaniu zdarzenia.

Środowisko wykonawcze musi wypełnić pole initializationResult wartością XR_SUCCESS, jeśli adnotacja została zainicjowana. Aplikacja może następnie pobrać zdarzenie XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT, aby śledzić adnotację.

W przeciwnym razie środowisko wykonawcze musi wypełnić pole initializationResult odpowiednim kodem błędu, aby wskazać przyczynę niepowodzenia. Aplikacja może zniszczyć uchwyt XrSpatialContextEXT, aby rozpocząć nową adnotację lub kontynuować śledzenie innych adnotacji za pomocą spatialContext.

Adnotacja w czterech punktach

Środowisko wykonawcze musi reklamować obsługę adnotacji kwadratowych za pomocą funkcji xrEnumerateSpatialCapabilityComponentTypesEXT, wymieniając ten typ komponentu:

  • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

Quad Reference

Struktura XrSpatialAnnotationQuadReferenceANDROID jest zdefiniowana w ten sposób:

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

Opisy członków

  • type to XrStructureType tej struktury.
  • next to NULL lub wskaźnik do następnej struktury w łańcuchu struktur.
  • quadCount to uint32_t opisujący liczbę elementów w tablicy quads.
  • quads to wskaźnik tablicy elementów XrSpatialAnnotationQuadANDROID .

Gdy środowisko wykonawcze obsługuje adnotacje czworokątne, aplikacja może skonfigurować adnotacje , łącząc strukturę XrSpatialAnnotationQuadReferenceANDROID ze strukturą XrSpatialReferenceImageEXT :: next i ustawiając odniesienie w strukturze XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference podczas tworzenia uchwytu XrSpatialContextEXT.

Środowisko wykonawcze musi zwracać XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT z funkcji xrCreateSpatialContextAsyncEXT, jeśli wartość quadCount wynosi 0.

Prawidłowe użycie (domyślne)

Struktura XrSpatialAnnotationQuadANDROID jest zdefiniowana w ten sposób:

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

Opisy członków

  • alignment to XrSpatialAnnotationQuadAlignmentANDROID czworokąta.
  • upperLeft to XrVector2f opisujący współrzędną lewego górnego rogu czworokąta względem punktu początkowego.
  • upperRight to XrVector2f opisujący współrzędne prawego górnego rogu czworokąta względem punktu początkowego.
  • lowerRight to XrVector2f opisujący współrzędne prawego dolnego rogu czworokąta względem punktu początkowego.
  • lowerLeft to XrVector2f opisujący współrzędne lewego dolnego rogu czworokąta względem punktu początkowego.

Czworokąt w przestrzeni 2D to wypukły czworokąt o wskazówkach zegara. Wartość 4 narożników jest powiązana z punktem początkowym (0, 0), z którym jest powiązany czworokąt.

Prawidłowe użycie (domyślne)

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;

Wyliczenie XrSpatialAnnotationQuadAlignmentANDROID opisuje wyrównanie adnotacji w kształcie czworokąta.

Wartości wyliczeniowe mają następujące znaczenia:

Opis typu wyliczeniowego

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_SCREEN_ANDROID

Czworokąt adnotacji jest równoległy do płaszczyzny ekranu, a jego obrót w płaszczyźnie pozostaje zablokowany względem grawitacji. Wynik jest wyświetlany jako zwykła, pionowa ramka ograniczająca.

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_OBJECT_ANDROID

Czworokąt adnotacji jest bezpośrednio powiązany z obiektem i zgodny z wyrównaniem zdefiniowanym na obrazie referencyjnym. Wynikiem jest czworokąt wypukły, którego kształt jest dostosowany do perspektywy obiektu.

Komponenty Quad

Struktura XrSpatialAnnotationQuadDataANDROID jest zdefiniowana w ten sposób:

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

Opisy członków

Prawidłowe użycie (domyślne)

Struktura XrSpatialComponentAnnotationQuadListANDROID jest zdefiniowana w ten sposób:

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

Opisy członków

  • type to XrStructureType tej struktury.
  • next to NULL lub wskaźnik do następnej struktury w łańcuchu struktur.
  • quadCount to uint32_t opisujący liczbę elementów w tablicy quads.
  • quads to tablica elementów XrSpatialAnnotationQuadDataANDROID .

Aplikacja może wysyłać zapytania do komponentu adnotacji czworokątnych jednostek przestrzennych w obiekcie XrSpatialSnapshotEXT, dodając XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID w obiekcie XrSpatialComponentDataQueryConditionEXT :: componentTypes i dodając XrSpatialComponentAnnotationQuadListANDROID do następnego łańcucha wskaźników obiektu XrSpatialComponentDataQueryResultEXT .

Środowisko wykonawcze musi zwracać XR_ERROR_VALIDATION_FAILURE z funkcji xrQuerySpatialComponentDataEXT, jeśli XrSpatialComponentAnnotationQuadListANDROID znajduje się w następnym łańcuchu XrSpatialComponentDataQueryResultEXT :: next, ale XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID nie jest uwzględniony w funkcji XrSpatialComponentDataQueryConditionEXT :: componentTypes .

Środowisko wykonawcze musi zwracać XR_ERROR_SIZE_INSUFFICIENT z funkcji xrQuerySpatialComponentDataEXT, jeśli wartość quadCount jest mniejsza niż XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput .

Prawidłowe użycie (domyślne)

Przykładowy kod

Sprawdzanie obsługi środowiska wykonawczego

Poniższy przykładowy kod pokazuje, jak sprawdzić, czy środowisko wykonawcze obsługuje śledzenie adnotacji.

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

Konfigurowanie adnotacji w postaci czworokąta

Poniższy przykładowy kod pokazuje, jak skonfigurować adnotację w postaci czworokąta.

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

Odkrywanie aktywnych adnotacji

Poniższy przykładowy kod pokazuje, jak wykrywać i wykonywać zapytania dotyczące adnotacji.

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

Nowe typy obiektów

Nowe polecenia

Nowe struktury

Nowe wartości w polu enum

Nowe stałe wyliczeniowe

  • XR_ANDROID_SPATIAL_ANNOTATION_TRACKING_EXTENSION_NAME
  • XR_ANDROID_spatial_annotation_tracking_SPEC_VERSION

  • Rozszerzanie XrObjectType :

    • XR_OBJECT_TYPE_SPATIAL_REFERENCE_CACHE_ANDROID

  • Rozszerzenie XrSpatialCapabilityEXT :

    • XR_SPATIAL_CAPABILITY_ANNOTATION_TRACKING_ANDROID

  • Rozszerzanie XrSpatialComponentTypeEXT :

    • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

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

Problemy

Historia wersji

  • Wersja 1, 17 września 2025 r. (Levana Chen)

    • Początkowy opis rozszerzenia.