Rozszerzenie OpenXR XR_ANDROID_trackables

Ciąg znaków nazwy

XR_ANDROID_trackables

Typ rozszerzenia

Rozszerzenie instancji

Zarejestrowany numer wewnętrzny

456

Wersja

1

Zależności rozszerzeń i wersji

OpenXR 1.0

Data ostatniej modyfikacji

2024-09-30

Stan adresu IP

Brak znanych roszczeń dotyczących praw autorskich do treści objętych ochroną prawną.

Twórcy

Spencer Quin, Google

Nihav Jain, Google

John Pursey, Google

Jared Finder, Google

Levana Chen, Google

Kenny Vercaemer, Google

Omówienie

To rozszerzenie umożliwia aplikacji dostęp do urządzeń śledzenia z fizycznego otoczenia oraz tworzenie kotwic dołączonych do urządzenia śledzenia.

To rozszerzenie definiuje obiekty śledzenia samolotów. Inne rozszerzenia mogą dodawać dodatkowe typy danych. Na przykład XR_ANDROID_trackables_object dodaje obiekty śledzenia, a XR_ANDROID_depth_texture dodaje bufor głębi, który umożliwia raycasting do dowolnych punktów w środowisku.

Element śledzenia to coś, co jest śledzone w środowisku fizycznym (patrz XrTrackableTypeANDROID):

  • płaszczyzna (np. ściana, podłoga, sufit, stół);
  • obiekt (np. klawiatura, mysz, laptop);

Tworzenie śledzonego lokalizatora

XrTrackableTrackerANDROID to uchwyt, który reprezentuje zasoby wymagane do wykrywania i aktualizowania elementów śledzenia danego typu XrTrackableTypeANDROID w środowisku.

XR_DEFINE_HANDLE(XrTrackableTrackerANDROID)

Funkcja xrCreateTrackableTrackerANDROID jest zdefiniowana w ten sposób: 

XrResult xrCreateTrackableTrackerANDROID(
    XrSession                                   session,
    const XrTrackableTrackerCreateInfoANDROID*  createInfo,
    XrTrackableTrackerANDROID*                  trackableTracker);

Opisy parametrów

Aplikacja może użyć funkcji xrCreateTrackableTrackerANDROID, aby utworzyć śledzony lokalizator.

  • Jeśli system nie obsługuje śledzenia obiektów danego typu, zwracana jest wartość XR_ERROR_FEATURE_UNSUPPORTED.
  • XR_ERROR_PERMISSION_INSUFFICIENT zostanie zwrócony, jeśli aplikacja wywołująca nie ma przyznanych wymaganych uprawnień.

Aplikacja może używać zwróconego uchwytu śledzenia w kolejnych wywołaniach interfejsu API. Musisz ostatecznie uwolnić uchwyt XrTrackableTrackerANDROID za pomocą funkcji xrDestroyTrackableTrackerANDROID.

Prawidłowe użycie (domyślne)

Kody zwrotne

Gotowe

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Błąd

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

Struktura XrTrackableTrackerCreateInfoANDROID jest zdefiniowana w ten sposób: 

typedef struct XrTrackableTrackerCreateInfoANDROID {
    XrStructureType           type;
    void*                     next;
    XrTrackableTypeANDROID    trackableType;
} XrTrackableTrackerCreateInfoANDROID;

Opisy członków

  • type to XrStructureType tej struktury.
  • next to NULL lub wskaźnik do następnej struktury w łańcuchu struktury. Nie ma żadnych takich struktur zdefiniowanych w podstawowej wersji OpenXR ani w tym rozszerzeniu.
  • trackableType to XrTrackableTypeANDROID, który będzie śledzony przez lokalizator.

Struktura XrTrackableTrackerCreateInfoANDROID udostępnia opcje tworzenia dla XrTrackableTrackerANDROID, gdy zostanie przekazana do funkcji xrCreateTrackableTrackerANDROID.

Rozszerzenia mogą definiować struktury, które można dołączyć do next, aby umożliwić dodatkową konfigurację śledzenia.

Prawidłowe użycie (domyślne)

Wyliczenie XrTrackableTypeANDROID jest zdefiniowane w ten sposób: 

typedef enum XrTrackableTypeANDROID {
    XR_TRACKABLE_TYPE_NOT_VALID_ANDROID = 0,
    XR_TRACKABLE_TYPE_PLANE_ANDROID = 1,
    XR_TRACKABLE_TYPE_DEPTH_ANDROID = 1000463000,
    XR_TRACKABLE_TYPE_OBJECT_ANDROID = 1000466000
} XrTrackableTypeANDROID;

Funkcja xrDestroyTrackableTrackerANDROID jest zdefiniowana w ten sposób: 

XrResult xrDestroyTrackableTrackerANDROID(
    XrTrackableTrackerANDROID                   trackableTracker);

Opisy parametrów

Funkcja xrDestroyTrackableTrackerANDROID niszczy lokalizator śledzenia.

Jeśli nie ma innego prawidłowego obiektu XrTrackableTrackerANDROID utworzonego z tym samym XrTrackableTypeANDROID, system może wyłączyć usługi śledzenia wymagane dla tego typu obiektu, aby zaoszczędzić zasoby systemowe.

Prawidłowe użycie (domyślne)

Bezpieczeństwo wątków

  • Dostęp do trackableTracker i wszystkich jego uchwytów podrzędnych musi być zsynchronizowany zewnętrznie.

Kody zwrotne

Gotowe

  • XR_SUCCESS

Błąd

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_HANDLE_INVALID

Wyświetlanie wszystkich gadżetów

Atom XrTrackableANDROID jest zdefiniowany w ten sposób:

XR_DEFINE_ATOM(XrTrackableANDROID)

XrTrackableANDROID służy do reprezentowania pojedynczego obiektu do śledzenia i jest prawidłowy tylko w cyklu życia powiązanego z nim obiektu XrTrackableTrackerANDROID.

Funkcja xrGetAllTrackablesANDROID jest zdefiniowana w ten sposób: 

XrResult xrGetAllTrackablesANDROID(
    XrTrackableTrackerANDROID                   trackableTracker,
    uint32_t                                    trackableCapacityInput,
    uint32_t*                                   trackableCountOutput,
    XrTrackableANDROID*                         trackables);

Opisy parametrów

  • trackableTracker to XrTrackableTrackerANDROID, którego dotyczy zapytanie.

  • trackableCapacityInput to pojemność tablicy trackables, a 0 oznacza prośbę o pobranie wymaganej przepustowości.

  • trackableCountOutput to wskaźnik liczby zapisanych elementów trackables lub wskaźnik wymaganej pojemności w przypadku, gdy trackables jest niewystarczająca.

  • trackables to wskaźnik do tablicy XrTrackableANDROID. Może ona wynosić NULL, jeśli trackableCapacityInput = 0.

  • Szczegółowe informacje o pobieraniu wymaganego rozmiaru trackables znajdziesz w sekcji Parametry rozmiaru bufora.

xrGetAllTrackablesANDROID wypełnia tablicę XrTrackableANDROID, która reprezentuje obiekty śledzenia znalezione w środowisku. Wartość XrTrackableTypeANDROID zwracanego obiektu trackables musi być zgodna z wartością XrTrackableTypeANDROID obiektu trackableTracker.

Uzyskaj samolot do śledzenia

Funkcja xrGetTrackablePlaneANDROID jest zdefiniowana w ten sposób:

XrResult xrGetTrackablePlaneANDROID(
    XrTrackableTrackerANDROID                   trackableTracker,
    const XrTrackableGetInfoANDROID*            getInfo,
    XrTrackablePlaneANDROID*                    planeOutput);

Opisy parametrów

Funkcja xrGetTrackablePlaneANDROID zwraca szczegóły dotyczące śledzenia, takie jak geometria, orientacja i stan śledzenia.

Informacje o samolocie są rozwiązywane i odnoszą się do przestrzeni bazowej w momencie wywołania funkcji xrGetTrackablePlaneANDROID za pomocą funkcji XrTrackableGetInfoANDROID::time, XrTrackableGetInfoANDROID::baseSpace.

Prawidłowe użycie (domyślne)

Kody zwrotne

Gotowe

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Błąd

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_VALIDATION_FAILURE
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_LIMIT_REACHED
  • XR_ERROR_TIME_INVALID

Struktura XrTrackableGetInfoANDROID jest zdefiniowana w ten sposób: 

typedef struct XrTrackableGetInfoANDROID {
    XrStructureType       type;
    void*                 next;
    XrTrackableANDROID    trackable;
    XrSpace               baseSpace;
    XrTime                time;
} XrTrackableGetInfoANDROID;

Opisy członków

  • type to XrStructureType tej struktury.
  • next to NULL lub wskaźnik do następnej struktury w łańcuchu struktury. Nie ma żadnych takich struktur zdefiniowanych w podstawowej wersji OpenXR ani w tym rozszerzeniu.
  • trackable to XrTrackableANDROID samolot, którego dotyczy zapytanie.
  • baseSpace pozycja samolotu będzie określana względem tego XrSpace w miejscu time.
  • time to XrTime, dla którego mają być obliczane współrzędne względem baseSpace.

Struktura XrTrackableGetInfoANDROID udostępnia opcje zapytań, gdy zostanie przekazana do funkcji xrGetTrackablePlaneANDROID. Wartość trackable musi odpowiadać wartości trackableTracker użytej w xrGetTrackablePlaneANDROID.

XR_ERROR_MISMATCHING_TRACKABLE_TYPE_ANDROID zostanie zwrócony, jeśli trackable nie jest typem XR_TRACKABLE_TYPE_PLANE_ANDROID.

Prawidłowe użycie (domyślne)

Struktura XrTrackablePlaneANDROID jest zdefiniowana w ten sposób: 

typedef struct XrTrackablePlaneANDROID {
    XrStructureType           type;
    void*                     next;
    XrTrackingStateANDROID    trackingState;
    XrPosef                   centerPose;
    XrExtent2Df               extents;
    XrPlaneTypeANDROID        planeType;
    XrPlaneLabelANDROID       planeLabel;
    XrTrackableANDROID        subsumedByPlane;
    XrTime                    lastUpdatedTime;
    uint32_t                  vertexCapacityInput;
    uint32_t*                 vertexCountOutput;
    XrVector2f*               vertices;
} XrTrackablePlaneANDROID;

Opisy członków

  • type to XrStructureType tej struktury.
  • next to NULL lub wskaźnik do następnej struktury w łańcuchu struktury. Nie ma żadnych takich struktur zdefiniowanych w podstawowej wersji OpenXR ani w tym rozszerzeniu.
  • trackingState to XrTrackingStateANDROID samolotu.
  • centerPose to XrPosef określający położenie i orientację płaszczyzny w układzie odniesienia odpowiadającego XrTrackableGetInfoANDROID::baseSpace. Orientacja tożsamościowa reprezentuje oś X+ równoległą do normalnej płaszczyzny.
  • extents to wymiar XrExtent2Df samolotu.
  • planeType to XrPlaneTypeANDROID, który środowisko wykonawcze określiło dla tego samolotu.
  • planeLabel to XrPlaneLabelANDROID, który został określony przez środowisko uruchomieniowe dla tego samolotu.
  • subsumedByPlane to XrTrackableANDROID płaszczyzny, która zawiera tę płaszczyznę (XR_NULL_TRACKABLE_ANDROID, jeśli nie ma takiej płaszczyzny).
  • lastUpdatedTime to data XrTime ostatniej aktualizacji planu.
  • vertexCapacityInput to pojemność tablicy vertices, a 0 oznacza prośbę o pobranie wymaganej przepustowości.
  • vertexCountOutput to wskaźnik liczby zapisanych wartości vertices lub wskaźnik wymaganej pojemności w przypadku, gdy vertices jest niewystarczająca.
  • vertices to wskaźnik do tablicy XrVector2f. Może ona wynosić NULL, jeśli vertexCapacityInput = 0. Wierzchołki są w kolejności przeciwnej do ruchu wskazówek zegara. Wielokąt może być wklęsły, ale nie może się przecinać sam ze sobą.
  • Szczegółowe informacje o pobieraniu wymaganego rozmiaru vertices znajdziesz w sekcji Parametry rozmiaru bufora.

Prawidłowe użycie (domyślne)

Typ enumeracji XrTrackingStateANDROID określa stan śledzenia XrTrackableANDROID. 

typedef enum XrTrackingStateANDROID {
    XR_TRACKING_STATE_PAUSED_ANDROID = 0,
    XR_TRACKING_STATE_STOPPED_ANDROID = 1,
    XR_TRACKING_STATE_TRACKING_ANDROID = 2
} XrTrackingStateANDROID;

XrTrackingStateANDROID

Opis

XR_TRACKING_STATE_PAUSED_ANDROID

Wskazuje, że śledzenie ruchomego obiektu lub śledzenie za pomocą kotwicy jest wstrzymane, ale może zostać wznowione w przyszłości.

XR_TRACKING_STATE_STOPPED_ANDROID

Śledzenie tego obiektu zostało zatrzymane i nigdy nie zostanie wznowione.

XR_TRACKING_STATE_TRACKING_ANDROID

Obiekt jest śledzony, a jego pozycja jest aktualna.

Wyliczenie XrPlaneTypeANDROID to typ samolotu XrTrackableANDROID. 

typedef enum XrPlaneTypeANDROID {
    XR_PLANE_TYPE_HORIZONTAL_DOWNWARD_FACING_ANDROID = 0,
    XR_PLANE_TYPE_HORIZONTAL_UPWARD_FACING_ANDROID = 1,
    XR_PLANE_TYPE_VERTICAL_ANDROID = 2,
    XR_PLANE_TYPE_ARBITRARY_ANDROID = 3
} XrPlaneTypeANDROID;

Typ XrPlaneLabelANDROID to etykieta samolotu XrTrackableANDROID. 

typedef enum XrPlaneLabelANDROID {
    XR_PLANE_LABEL_UNKNOWN_ANDROID = 0,
    XR_PLANE_LABEL_WALL_ANDROID = 1,
    XR_PLANE_LABEL_FLOOR_ANDROID = 2,
    XR_PLANE_LABEL_CEILING_ANDROID = 3,
    XR_PLANE_LABEL_TABLE_ANDROID = 4
} XrPlaneLabelANDROID;

Tworzenie pokoju kotwicy

XrResult xrCreateAnchorSpaceANDROID(
    XrSession                                   session,
    const XrAnchorSpaceCreateInfoANDROID*       createInfo,
    XrSpace*                                    anchorOutput);

Opisy parametrów

  • session to XrSession, który tworzy przestrzeń kotwicy.
  • createInfo to wskaźnik do struktury XrAnchorSpaceCreateInfoANDROID zawierającej parametry służące do utworzenia przestrzeni kotwicy.
  • anchorOutput to wskaźnik do uchwytu, w którym zwracany jest utworzony XrSpace.

W dowolnym momencie można śledzić lub nie śledzić zarówno pozycji, jak i kierunku kotwicy. Oznacza to, że gdy aplikacja wywołuje metodę xrLocateSpace lub xrLocateSpaces, musi być ustawiona albo XR_SPACE_LOCATION_POSITION_TRACKED_BIT, albo XR_SPACE_LOCATION_ORIENTATION_TRACKED_BIT.anchorOutput

Aplikacja musi ostatecznie zwolnić zwrócone XrSpace za pomocą metody xrDestroySpace.

  • Jeśli system nie obsługuje kotwic, musi zostać zwrócona wartość XR_ERROR_FEATURE_UNSUPPORTED.
  • XR_ERROR_TRACKABLE_TYPE_NOT_SUPPORTED_ANDROID musi zostać zwrócony, jeśli określony załącznik kotwicy nie jest obsługiwany.

Prawidłowe użycie (domyślne)

Kody zwrotne

Gotowe

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Błąd

  • XR_ERROR_FUNCTION_UNSUPPORTED
  • XR_ERROR_TRACKABLE_TYPE_NOT_SUPPORTED_ANDROID
  • XR_ERROR_VALIDATION_FAILURE
  • XR_ERROR_RUNTIME_FAILURE
  • XR_ERROR_HANDLE_INVALID
  • XR_ERROR_INSTANCE_LOST
  • XR_ERROR_SESSION_LOST
  • XR_ERROR_LIMIT_REACHED
  • XR_ERROR_POSE_INVALID
  • XR_ERROR_TIME_INVALID
  • XR_ERROR_OUT_OF_MEMORY

Struktura XrAnchorSpaceCreateInfoANDROID jest zdefiniowana jako: 

typedef struct XrAnchorSpaceCreateInfoANDROID {
    XrStructureType       type;
    void*                 next;
    XrSpace               space;
    XrTime                time;
    XrPosef               pose;
    XrTrackableANDROID    trackable;
} XrAnchorSpaceCreateInfoANDROID;

Opisy członków

  • type to XrStructureType tej struktury.
  • next to NULL lub wskaźnik do następnej struktury w łańcuchu struktury. Nie ma żadnych takich struktur zdefiniowanych w podstawowej wersji OpenXR ani w tym rozszerzeniu.
  • space to XrSpace, w którym zostanie utworzona kotwica.
  • time to XrTime utworzenia kotwicy.
  • pose to XrPosef zakotwiczonego elementu.
  • trackable to element XrTrackableANDROID, do którego zostanie dołączona kotwica. Możesz XR_NULL_TRACKABLE_ANDROID utworzyć kotwicę przestrzenną.

Prawidłowe użycie (domyślne)

Przykładowy kod służący do uzyskiwania wszystkich obiektów śledzonych

Poniższy przykładowy kod pokazuje, jak uzyskać wszystkie obiekty śledzenia danego typu.

XrSession session; // previously initialized

// The function pointers are previously initialized using xrGetInstanceProcAddr.
PFN_xrCreateTrackableTrackerANDROID xrCreateTrackableTrackerANDROID; // previously initialized
PFN_xrGetAllTrackablesANDROID xrGetAllTrackablesANDROID; // previously initialized
PFN_xrDestroyTrackableTrackerANDROID xrDestroyTrackableTrackerANDROID; // previously initialized

XrTrackableTrackerCreateInfoANDROID createInfo{XR_TYPE_TRACKABLE_TRACKER_CREATE_INFO_ANDROID};
createInfo.trackableType = XR_TRACKABLE_TYPE_PLANE_ANDROID;
XrTrackableTrackerANDROID planeTrackableTracker;
XrResult result = xrCreateTrackableTrackerANDROID(
  session,
  &createInfo,
  &planeTrackableTracker);
if (result != XR_SUCCESS) { /* Handle failures. */ }

uint32_t trackableCountOutput = 0;
std::vector<XrTrackableANDROID> allPlaneTrackables;

// Query the number of trackables available.
result = xrGetAllTrackablesANDROID(
  planeTrackableTracker,
  0,
  &trackableCountOutput,
  nullptr
);

if (result == XR_SUCCESS) {
  allPlaneTrackables.resize(trackableCountOutput, XR_NULL_HANDLE);

  // Fetch the actual trackable handles in the appropriately resized array.
  result = xrGetAllTrackablesANDROID(
    planeTrackableTracker,
    trackableCountOutput,
    &trackableCountOutput,
    allPlaneTrackables.data());

  if (result == XR_SUCCESS) {
    for (XrTrackableANDROID trackable : allPlaneTrackables) {
      // You now have all trackables of the specified type.
    }
  }
}

// Release trackable tracker.
result = xrDestroyTrackableTrackerANDROID(planeTrackableTracker);

Przykładowy kod umożliwiający uzyskanie płaszczyzny śledzenia

Poniższy przykładowy kod pokazuje, jak uzyskać śledzoną płaszczyznę z istniejącego obiektu XrTrackableANDROID, uzyskanego z wyniku dopasowania XR_ANDROID_raycast lub xrGetTrackablesANDROID.

XrTrackableTrackerANDROID planeTracker; // previously created

// The function pointers are previously initialized using xrGetInstanceProcAddr.
PFN_xrGetTrackablePlaneANDROID xrGetTrackablePlaneANDROID; // previously initialized

XrTime updateTime; // Time used for the current frame's simulation update.
XrSpace appSpace; // Space created for XR_REFERENCE_SPACE_TYPE_LOCAL.
XrTrackableANDROID planeTrackable; // Acquired from a hit result or getTrackables().

XrTrackableGetInfoANDROID planeGetInfo;
planeGetInfo.type = XR_TYPE_TRACKABLE_GET_INFO_ANDROID;
planeGetInfo.next = nullptr;
planeGetInfo.trackable = planeTrackable;
planeGetInfo.space = appSpace;
planeGetInfo.time = updateTime;

XrTrackablePlaneANDROID plane = { XR_TYPE_TRACKABLE_PLANE_ANDROID };
result = xrGetTrackablePlaneANDROID(
  planeTracker,
  &planeGetInfo,
  &plane
);

if (result == XR_SUCCESS) {
  // Plane tracking state, center pose, extents, type now available in plane.
}

Przykładowy kod do tworzenia miejsca kotwicy

Poniższy przykładowy kod pokazuje, jak utworzyć przestrzeń kotwicy powiązaną z elementem śledzonym.

XrSession session; // Created at app startup.
XrTime updateTime; // Time used for the current frame's simulation update.
XrSpace appSpace; // Space created for XR_REFERENCE_SPACE_TYPE_LOCAL.
XrTrackableANDROID planeTrackable; // Acquired from a hit result or getTrackables().

// Create an anchor at (2, 2, 2) world-coordinates.
XrAnchorSpaceCreateInfoANDROID spatialAnchorCreateInfo;
spatialAnchorCreateInfo.type = XR_TYPE_ANCHOR_SPACE_CREATE_INFO_ANDROID;
spatialAnchorCreateInfo.next = nullptr;
spatialAnchorCreateInfo.space = appSpace;
spatialAnchorCreateInfo.time = updateTime;
spatialAnchorCreateInfo.pose = { { 0, 0, 0, 1 }, { 2, 2, 2 } };

XrSpace spatialAnchor = XR_NULL_HANDLE;
XrResult result = xrCreateAnchorSpaceANDROID(
  session,
  &spatialAnchorCreateInfo,
  &spatialAnchor
);

// Create an anchor attached to a trackable.
XrTrackablePlane plane = ...;
XrAnchorSpaceCreateInfoANDROID trackableAnchorCreateInfo;
trackableAnchorCreateInfo.type = XR_TYPE_ANCHOR_SPACE_CREATE_INFO_ANDROID;
trackableAnchorCreateInfo.next = nullptr;
trackableAnchorCreateInfo.space = appState;
trackableAnchorCreateInfo.pose = plane.centerPose;
trackableAnchorCreateInfo.trackable = planeTrackable;

XrSpace trackableAnchor = XR_NULL_HANDLE;
XrResult result = xrCreateAnchorSpaceANDROID(
  session,
  &trackableAnchorCreateInfo,
  &trackableAnchor
);
while (true) {
  // app update loop
  // ...

  // Get the current location of the anchor's space w.r.t the world.
  XrSpaceLocation anchorLocation = { XR_TYPE_SPACE_LOCATION };
  result = xrLocateSpace(trackableAnchor, appSpace, updateTime, &anchorLocation);

  if (anchor.trackingState == XR_TRACKING_STATE_TRACKING_ANDROID) {
    // Update anchor pose.
    doDrawingForAnchor(anchorLocation.pose);
  } else {
    // ...
  }
}

// Cleanup - destroy the space, detatch the anchor so its no longer tracked by the
// runtime and then release all resources held by it.
xrDestroySpace(spatialAnchor);
xrDestroySpace(trackableAnchor);

Nowe typy podstawy

Nowe typy obiektów

Nowe stałe typu wyliczeniowego

Wyliczenie XrStructureType zostało rozszerzone o:

  • XR_TYPE_TRACKABLE_GET_INFO_ANDROID
  • XR_TYPE_ANCHOR_SPACE_CREATE_INFO_ANDROID
  • XR_TYPE_TRACKABLE_PLANE_ANDROID
  • XR_TYPE_TRACKABLE_TRACKER_CREATE_INFO_ANDROID

Wyliczenie XrObjectType zostało rozszerzone o:

  • XR_OBJECT_TYPE_TRACKABLE_TRACKER_ANDROID

Wyliczenie XrResult zostało rozszerzone o:

  • XR_ERROR_MISMATCHING_TRACKABLE_TYPE_ANDROID
  • XR_ERROR_TRACKABLE_TYPE_NOT_SUPPORTED_ANDROID

Nowe wartości w polu enum

Nowe struktury

Nowe funkcje

Problemy

Historia wersji

  • Wersja 1, 2024-09-27 (Kenny Vercaemer)
    • Początkowy opis rozszerzenia.

OpenXR™ i logo OpenXR są znakami towarowymi należącymi do The Khronos Group Inc. i zarejestrowanymi jako znak towarowy w Chinach, Unii Europejskiej, Japonii i Wielkiej Brytanii.