XR_ANDROID_spatial_annotation_tracking

Name String

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

Przegląd

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

To rozszerzenie udostępnia podstawowy typ adnotacji „Quad”, czyli wielokąt, który ma dokładnie 4 boki, tj. czworokąt wypukły, reprezentujący uogólnioną ramkę ograniczającą 2D w odniesieniu do środowiska wykonawczego. Śledzona adnotacja czworokątna jest reprezentowana jako element przestrzenny z tymi komponentami:

  • XR_SPATIAL_COMPONENT_TYPE_ANNOTATION_QUAD_ANDROID

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

  • Aplikacja najpierw tworzy uchwyt XrSpatialReferenceCacheANDROID, który rozpoczyna nagrywanie odniesień środowiska wykonawczego z danego źródła.
  • Następnie aplikacja przechwytuje odniesienie do środowiska wykonawczego XrSpatialReferenceImageEXT i definiuje żądaną adnotację w odniesieniu w okresie przechowywania odniesienia w pamięci podręcznej.
  • Następnie aplikacja tworzy uchwyt XrSpatialContextEXT na podstawie XrSpatialReferenceImageEXT podanego przez XrSpatialCapabilityConfigurationAnnotationTrackingANDROID .
  • Aplikacja może zniszczyć uchwyt XrSpatialReferenceCacheANDROID, aby zatrzymać nagrywanie odniesień środowiska wykonawczego i zmniejszyć wykorzystanie pamięci, lub poczekać na zdarzenie XR_TYPE_EVENT_DATA_SPATIAL_ANNOTATION_TRACKING_ANDROID, aby potwierdzić wynik inicjowania.
  • Następnie aplikacja pobiera 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 zdarzeniu, 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 adnotacje i wysyła do nich zapytania zgodnie ze wzorcami dostępu do elementó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ć zestaw wykrywalnych i śledzonych adnotacji w czasie działania.

Obsługa środowiska wykonawczego

Środowisko wykonawcze musi informować o obsłudze funkcji śledzenia adnotacji za pomocą xrEnumerateSpatialCapabilitiesEXT, podając tę funkcję:

  • 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 referencyjne zostaną wymienione.
  • capability to XrSpatialCapabilityEXT, dla którego zostaną wyliczone źródła referencyjne.
  • sourceCapacityInput to pojemność tablicy sources lub 0, co oznacza prośbę o pobranie wymaganej pojemności.
  • sourceCountOutput to liczba źródeł lub wymagana pojemność, jeśli sourceCapacityInput jest niewystarczająca.
  • sources to tablica XrSpatialAnnotationReferenceSourceANDROID . Może mieć wartość NULL, jeśli sourceCapacityInput wynosi 0.
  • Szczegółowy opis pobierania wymaganego rozmiaru sources znajdziesz w sekcji Parametry rozmiaru bufora.

Aplikacja może wyświetlić listę źródeł referencyjnych obsługiwanych przez dany element XrSystemId za pomocą funkcji xrEnumerateSpatialAnnotationReferenceSourcesANDROID .

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

Prawidłowe użycie (pośrednie)

Kody zwrotu

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.

Typy wyliczeniowe mają następujące znaczenie:

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 ImageReader powiązanego z CameraDevice w Camera2 lub ImageProxy z ImageAnalysis powiązanego z CameraX. Zwykle jest to jedna z kamer RGB skierowanych 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 ImageReader powiązanego z wyświetlaczem wirtualnym 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 wskazuje czas ważności uchwytu XrSpatialReferenceCacheANDROID w sekundach.
  • maxReferencePixelWidth wskazuje maksymalną szerokość krawędzi obrazów referencyjnych w pikselach.
  • maxReferencePixelHeight wskazuje maksymalną wysokość krawędzi obrazów referencyjnych w pikselach.
  • maxReferenceCount wskazuje maksymalną liczbę obrazów referencyjnych, które można przydzielić jednocześnie.
  • maxAnnotationCount wskazuje maksymalną liczbę adnotacji, które mogą być śledzone jednocześnie.

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

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

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

Jeśli XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: time wykracza poza przedział czasu XrSpatialReferenceCacheANDROID :: cache , środowisko wykonawcze musi zwrócić XR_ERROR_TIME_INVALID podczas wywoływania xrCreateSpatialContextAsyncEXT . Aplikacja może odtworzyć uchwyt XrSpatialContextEXT z nowym odwołaniem w okresie ważności XrSpatialReferenceCacheANDROID .

Jeśli liczba przydzielonych obrazów referencyjnych przekracza maxReferenceCount , środowisko wykonawcze musi zwrócić XR_ERROR_LIMIT_REACHED i wskazać błąd 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 zwrócić XR_ERROR_VALIDATION_FAILURE podczas wywoływania xrCreateSpatialContextAsyncEXT .

Prawidłowe użycie (pośrednie)

Pamięć podręczna odwołań środowiska wykonawczego

XR_DEFINE_HANDLE(XrSpatialReferenceCacheANDROID)

Uchwyt XrSpatialReferenceCacheANDROID reprezentuje pamięć podręczną odniesień ś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 odniesień będzie aktywna.
  • createInfo to wskaźnik do XrSpatialReferenceCacheCreateInfoANDROID, który służy do określania parametrów pamięci podręcznej odniesienia.
  • future to wskaźnik do uchwytu wyjściowego XrFutureEXT .

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

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

Środowisko wykonawcze musi zwracać 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ć XR_ERROR_LIMIT_REACHED .

Aplikacja może wtedy przechwytywać odwołania do środowiska wykonawczego w czasie działania uchwytu XrSpatialReferenceCacheANDROID, aby skonfigurować nowy uchwyt XrSpatialContextEXT.

Prawidłowe użycie (pośrednie)

Kody zwrotu

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 podstawowym interfejsie OpenXR ani w tym rozszerzeniu nie zdefiniowano takich struktur.
  • capability to XrSpatialCapabilityEXT, który opisuje, dla jakiej funkcji jest tworzona referencyjna pamięć podręczna.
  • source to XrSpatialAnnotationReferenceSourceANDROID opisujący źródło pamięci podręcznej odniesień.

Struktura XrSpatialReferenceCacheCreateInfoANDROID opisuje informacje potrzebne do utworzenia uchwytu XrSpatialReferenceCacheANDROID.

Prawidłowe użycie (pośrednie)

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ć XR_ERROR_FUTURE_PENDING_EXT, jeśli future nie jest w stanie gotowości. Środowisko wykonawcze musi zwrócić XR_ERROR_FUTURE_INVALID_EXT, jeśli future zostało już ukończone lub anulowane.

Prawidłowe użycie (pośrednie)

Kody zwrotu

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 podstawowym interfejsie OpenXR ani w tym rozszerzeniu nie zdefiniowano takich struktur.
  • futureResult to XrResult operacji tworzenia pamięci podręcznej odniesienia.
  • referenceCache to uchwyt XrSpatialReferenceCacheANDROID, jeśli operacja się powiedzie.

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 sukcesu, środowisko wykonawcze musi zwrócić prawidłowy uchwyt referenceCache. Jeśli referenceCache jest prawidłowy, pozostaje taki tylko przez czas działania xrCreateSpatialReferenceCacheAsyncANDROID :: session lub do momentu, gdy aplikacja zniszczy uchwyt za pomocą xrDestroySpatialReferenceCacheANDROID, w zależności od tego, co nastąpi wcześniej.

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

Prawidłowe użycie (pośrednie)

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 zasoby po zakończeniu tworzenia kontekstu przestrzennego.

Prawidłowe użycie (pośrednie)

Bezpieczeństwo wątków

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

Kody zwrotu

Sukces

  • XR_SUCCESS

Błąd

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_RUNTIME_FAILURE

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 do tablicy XrSpatialComponentTypeEXT .
  • cache to obiekt XrSpatialReferenceCacheANDROID utworzony wcześniej w celu rejestrowania odniesień środowiska wykonawczego dla konfiguracji reference.
  • time to XrTime, w którym zarejestrowano reference.
  • reference to XrSpatialReferenceImageEXT z adnotacjami połączonymi z następnym wskaźnikiem.

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

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

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

Środowisko wykonawcze musi zwracać XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT, jeśli komponent adnotacji jest wymieniony w enabledComponents, ale nie ma powiązanych z nim adnotacji w reference .

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

Środowisko wykonawcze musi zwracać XR_ERROR_TIME_INVALID, jeśli time wykracza poza przedział czasu cache .

Prawidłowe użycie (pośrednie)

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, dla którego aktywowano śledzenie adnotacji.
  • annotationIndex mapuje indeks z tablicy adnotacji powiązanej z XrSpatialCapabilityConfigurationAnnotationTrackingANDROID :: reference .
  • initializationResult wskazuje 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 (pośrednie)

Środowisko wykonawcze musi wypełnić 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 pomyślnie 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 nadal używać spatialContext do śledzenia innych adnotacji.

Adnotacja czworokątna

Środowisko wykonawcze musi informować o obsłudze adnotacji czworokątnych za pomocą xrEnumerateSpatialCapabilityComponentTypesEXT, podają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 do tablicy XrSpatialAnnotationQuadANDROID .

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

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

Prawidłowe użycie (pośrednie)

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ędną prawego górnego rogu czworokąta względem punktu początkowego.
  • lowerRight to XrVector2f opisujący współrzędną prawego dolnego rogu czworokąta względem punktu początkowego.
  • lowerLeft to XrVector2f opisujący współrzędną lewego dolnego rogu czworokąta względem punktu początkowego.

Czworokąt w przestrzeni 2D to czworokąt wypukły z kolejnością zgodną z ruchem wskazówek zegara. Wartość 4 rogów jest powiązana z początkiem układu współrzędnych (0, 0), z którym jest powiązany czworokąt.

Prawidłowe użycie (pośrednie)

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;

Wyliczenie XrSpatialAnnotationQuadAlignmentANDROID opisuje wyrównanie adnotacji czworokątnej.

Typy wyliczeniowe mają następujące znaczenie:

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 świata. Wynik jest wyświetlany jako zwykła, pionowa ramka ograniczająca.

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_OBJECT_ANDROID

Czworokąt adnotacji jest zakotwiczony bezpośrednio do obiektu, zgodnie z wyrównaniem określonym na obrazie referencyjnym. Wynikiem jest czworokąt wypukły, którego kształt jest dostosowywany do perspektywy obiektu.

XR_SPATIAL_ANNOTATION_QUAD_ALIGNMENT_SURFACE_ANDROID

Czworokąt adnotacji jest współpłaszczyznowy z powierzchnią obiektu, przy założeniu, że śledzony cel jest obiektem lub powierzchnią płaską. Wynik jest płynnie dopasowywany do fizycznej geometrii obiektu, a jego perspektywa jest dostosowywana tak, aby przylegał do danej powierzchni.

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 (pośrednie)

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

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

Środowisko wykonawcze musi zwracać XR_ERROR_VALIDATION_FAILURE z 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 XrSpatialComponentDataQueryConditionEXT :: componentTypes .

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

Prawidłowe użycie (pośrednie)

Przykładowy kod

Sprawdzanie obsługi środowiska wykonawczego

Poniższy przykładowy kod pokazuje, jak sprawdzić, czy środowisko wykonawcze obsługuje funkcję śledzenia 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 czworokątnych

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

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ć adnotacje i wysyłać do nich zapytania.

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 domy

Nowe wartości w polu enum

Nowe stałe typu wyliczeniowego

  • 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

  • Rozszerzenie 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 zmian

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

    • Początkowy opis rozszerzenia.