XR_EXT_spatial_plane_tracking

Name String

XR_EXT_spatial_plane_tracking

Extension Type

Instance extension

Registered Extension Number

742

Revision

1

Ratification Status

Ratified

Extension and Version Dependencies

XR_EXT_spatial_entity

Contributors

Nihav Jain, Google
Natalie Fleury, Meta
Yuichi Taguchi, Meta
Ron Bessems, Meta
Yin Li, Microsoft
Jimmy Alamparambil, ByteDance
Zhipeng Liu, ByteDance
Jun Yan, ByteDance

Przegląd

To rozszerzenie bazuje na XR_EXT_spatial_entity i definiuje możliwość śledzenia płaszczyzny w ramach struktury elementów przestrzennych.

Obsługa środowiska wykonawczego

Jeśli środowisko wykonawcze obsługuje śledzenie płaszczyzny, musi wskazać to, wyliczając XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT w xrEnumerateSpatialCapabilitiesEXT .

Konfiguracja

Struktura XrSpatialCapabilityConfigurationPlaneTrackingEXT jest zdefiniowana w ten sposób:

typedef struct XrSpatialCapabilityConfigurationPlaneTrackingEXT {
    XrStructureType                     type;
    const void*                         next;
    XrSpatialCapabilityEXT              capability;
    uint32_t                            enabledComponentCount;
    const XrSpatialComponentTypeEXT*    enabledComponents;
} XrSpatialCapabilityConfigurationPlaneTrackingEXT;

Opisy elementó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_PLANE_TRACKING_EXT .
• enabledComponentCount to uint32_t opisująca liczbę elementów w tablicy enabledComponents.
• enabledComponents to wskaźnik do tablicy XrSpatialComponentTypeEXT .

Aplikacje mogą włączyć możliwość przestrzenną XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT, dodając wskaźnik do struktury XrSpatialCapabilityConfigurationPlaneTrackingEXT w XrSpatialContextCreateInfoEXT :: capabilityConfigs .

Środowisko wykonawcze musi zwrócić XR_ERROR_VALIDATION_FAILURE, jeśli capability nie ma wartości XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT .

Prawidłowe użycie (pośrednie)

• Przed użyciem XrSpatialCapabilityConfigurationPlaneTrackingEXT musi być włączone rozszerzenie XR_EXT_spatial_plane_tracking.
• type musi mieć wartość XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_PLANE_TRACKING_EXT
• next musi mieć wartość NULL lub prawidłowy wskaźnik do następnej struktury w łańcuchu struktur.
• capability musi być prawidłową wartością XrSpatialCapabilityEXT.
• enabledComponents musi być wskaźnikiem do tablicy enabledComponentCount prawidłowych wartości XrSpatialComponentTypeEXT.
• Parametr enabledComponentCount musi być większy niż 0.

Gwarantowane komponenty

Środowisko wykonawcze, które obsługuje XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT musi udostępniać te komponenty przestrzenne jako gwarantowane komponenty wszystkich elementów wykrytych przez tę możliwość i musi je wyliczać w xrEnumerateSpatialCapabilityComponentTypesEXT :

• XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT
• XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT

Komponent ograniczony do 2D

Komponent ograniczony do 2D udostępnia środek i zakres płaszczyzny reprezentowanej przez element, na którym się znajduje. Więcej informacji znajdziesz w sekcji Ograniczone do 2D.

Komponent wyrównania płaszczyzny

Dane komponentu

typedef enum XrSpatialPlaneAlignmentEXT {
    XR_SPATIAL_PLANE_ALIGNMENT_HORIZONTAL_UPWARD_EXT = 0,
    XR_SPATIAL_PLANE_ALIGNMENT_HORIZONTAL_DOWNWARD_EXT = 1,
    XR_SPATIAL_PLANE_ALIGNMENT_VERTICAL_EXT = 2,
    XR_SPATIAL_PLANE_ALIGNMENT_ARBITRARY_EXT = 3,
    XR_SPATIAL_PLANE_ALIGNMENT_MAX_ENUM_EXT = 0x7FFFFFFF
} XrSpatialPlaneAlignmentEXT;

Wyliczenie XrSpatialPlaneAlignmentEXT opisuje wyrównanie płaszczyzny powiązanej z elementem przestrzennym z komponentem XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT.

Wartości wyliczenia mają te znaczenia:

Opis wyliczenia

XR_SPATIAL_PLANE_ALIGNMENT_HORIZONTAL_UPWARD_EXT

Element jest poziomy i skierowany do góry (np. podłoga).

XR_SPATIAL_PLANE_ALIGNMENT_HORIZONTAL_DOWNWARD_EXT

Element jest poziomy i skierowany w dół (np. sufit).

XR_SPATIAL_PLANE_ALIGNMENT_VERTICAL_EXT

Element jest pionowy (np. ściana).

XR_SPATIAL_PLANE_ALIGNMENT_ARBITRARY_EXT

Element ma dowolną orientację, która nie jest ani pionowa, ani pozioma.

Struktura listy komponentów do wysyłania zapytań o dane

Struktura XrSpatialComponentPlaneAlignmentListEXT jest zdefiniowana w ten sposób:

typedef struct XrSpatialComponentPlaneAlignmentListEXT {
    XrStructureType                type;
    void*                          next;
    uint32_t                       planeAlignmentCount;
    XrSpatialPlaneAlignmentEXT*    planeAlignments;
} XrSpatialComponentPlaneAlignmentListEXT;

Opisy elementów

• type to XrStructureType tej struktury.
• next to NULL lub wskaźnik do następnej struktury w łańcuchu struktur.
• planeAlignmentCount to uint32_t opisująca liczbę elementów w tablicy planeAlignments.
• planeAlignments to tablica XrSpatialPlaneAlignmentEXT .

Aby wysłać zapytanie o komponent wyrównania płaszczyzny elementów przestrzennych w XrSpatialSnapshotEXT , dodaj XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT do XrSpatialComponentDataQueryConditionEXT :: componentTypes i dodaj XrSpatialComponentPlaneAlignmentListEXT do łańcucha XrSpatialComponentDataQueryResultEXT :: next.

Środowisko wykonawcze musi zwrócić XR_ERROR_VALIDATION_FAILURE z xrQuerySpatialComponentDataEXT, jeśli XrSpatialComponentPlaneAlignmentListEXT znajduje się w łańcuchu XrSpatialComponentDataQueryResultEXT :: next, ale XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT nie jest uwzględniony w XrSpatialComponentDataQueryConditionEXT :: componentTypes .

Środowisko wykonawcze musi zwrócić XR_ERROR_SIZE_INSUFFICIENT z xrQuerySpatialComponentDataEXT, jeśli planeAlignmentCount jest mniejsza niż XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput .

Prawidłowe użycie (pośrednie)

• Przed użyciem XrSpatialComponentPlaneAlignmentListEXT musi być włączone rozszerzenie XR_EXT_spatial_plane_tracking.
• type musi mieć wartość XR_TYPE_SPATIAL_COMPONENT_PLANE_ALIGNMENT_LIST_EXT
• next musi mieć wartość NULL lub prawidłowy wskaźnik do następnej struktury w łańcuchu struktur.
• planeAlignments musi być wskaźnikiem do tablicy planeAlignmentCount XrSpatialPlaneAlignmentEXT wartości
• Parametr planeAlignmentCount musi być większy niż 0

Konfiguracja

Jeśli XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT jest wyliczony w XrSpatialCapabilityComponentTypesEXT :: componentTypes dla jakiejś możliwości, aplikacja może go włączyć, dodając wyliczenie do listy XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents struktury pochodnej XrSpatialCapabilityConfigurationBaseHeaderEXT możliwości, która obsługuje ten komponent.

Ten komponent nie wymaga żadnej specjalnej konfiguracji, aby można go było uwzględnić w łańcuchu XrSpatialCapabilityConfigurationBaseHeaderEXT :: next.

Komponenty opcjonalne

Środowisko wykonawcze, które obsługuje XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT może obsługiwać inne komponenty przestrzenne oprócz tych wymienionych w sekcji Gwarantowane komponenty. Aplikacja używa xrEnumerateSpatialCapabilityComponentTypesEXT, aby uzyskać pełną listę komponentów obsługiwanych przez środowisko wykonawcze, a następnie konfiguruje te, które ją interesują, podczas tworzenia kontekstu przestrzennego.

Komponent siatki 2D

Dane komponentu

XR_SPATIAL_COMPONENT_TYPE_MESH_2D_EXT używa struktury XrSpatialMeshDataEXT do przechowywania danych.

Struktura listy komponentów do wysyłania zapytań o dane

Struktura XrSpatialComponentMesh2DListEXT jest zdefiniowana w ten sposób:

typedef struct XrSpatialComponentMesh2DListEXT {
    XrStructureType          type;
    void*                    next;
    uint32_t                 meshCount;
    XrSpatialMeshDataEXT*    meshes;
} XrSpatialComponentMesh2DListEXT;

Opisy elementów

• type to XrStructureType tej struktury.
• next to NULL lub wskaźnik do następnej struktury w łańcuchu struktur.
• meshCount to uint32_t opisująca liczbę elementów w tablicy meshes.
• meshes to tablica XrSpatialMeshDataEXT .

Aby wysłać zapytanie o komponent siatki 2D elementów przestrzennych w XrSpatialSnapshotEXT , dodaj XR_SPATIAL_COMPONENT_TYPE_MESH_2D_EXT do XrSpatialComponentDataQueryConditionEXT :: componentTypes i dodaj XrSpatialComponentMesh2DListEXT do łańcucha XrSpatialComponentDataQueryResultEXT :: next.

Środowisko wykonawcze musi zwrócić XR_ERROR_VALIDATION_FAILURE z xrQuerySpatialComponentDataEXT, jeśli XrSpatialComponentMesh2DListEXT znajduje się w łańcuchu XrSpatialComponentDataQueryResultEXT :: next, ale XR_SPATIAL_COMPONENT_TYPE_MESH_2D_EXT nie jest uwzględniony w XrSpatialComponentDataQueryConditionEXT :: componentTypes .

Środowisko wykonawcze musi zwrócić XR_ERROR_SIZE_INSUFFICIENT z xrQuerySpatialComponentDataEXT, jeśli meshCount jest mniejsza niż XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput .

W przypadku XrSpatialMeshDataEXT wypełnionego przez środowisko wykonawcze w tablicy meshes XrSpatialBufferEXT :: bufferType dla XrSpatialMeshDataEXT :: vertexBuffer musi mieć wartość XR_SPATIAL_BUFFER_TYPE_VECTOR2F_EXT, a XrSpatialBufferEXT :: bufferType dla XrSpatialMeshDataEXT :: indexBuffer musi mieć wartość XR_SPATIAL_BUFFER_TYPE_UINT16_EXT .

Prawidłowe użycie (pośrednie)

• Przed użyciem XrSpatialComponentMesh2DListEXT musi być włączone rozszerzenie XR_EXT_spatial_plane_tracking.
• type musi mieć wartość XR_TYPE_SPATIAL_COMPONENT_MESH_2D_LIST_EXT
• next musi mieć wartość NULL lub prawidłowy wskaźnik do następnej struktury w łańcuchu struktur.
• meshes musi być wskaźnikiem do tablicy meshCount struktur XrSpatialMeshDataEXT.
• Parametr meshCount musi być większy niż 0

Konfiguracja

Jeśli XR_SPATIAL_COMPONENT_TYPE_MESH_2D_EXT jest wyliczony w XrSpatialCapabilityComponentTypesEXT :: componentTypes dla jakiejś możliwości, aplikacja może go włączyć, dodając wyliczenie do listy XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents struktury pochodnej XrSpatialCapabilityConfigurationBaseHeaderEXT możliwości, która obsługuje ten komponent.

Ten komponent nie wymaga żadnej specjalnej konfiguracji, aby można go było uwzględnić w łańcuchu XrSpatialCapabilityConfigurationBaseHeaderEXT :: next.

Komponent wielokąta 2D

Dane komponentu

Struktura XrSpatialPolygon2DDataEXT jest zdefiniowana w ten sposób:

typedef struct XrSpatialPolygon2DDataEXT {
    XrPosef               origin;
    XrSpatialBufferEXT    vertexBuffer;
} XrSpatialPolygon2DDataEXT;

Opisy elementów

• origin to XrPosef określający początek wielokąta. Wszystkie wierzchołki wielokąta są względne względem tego początku w płaszczyźnie X-Y.
• vertexBuffer to XrSpatialBufferEXT, który udostępnia identyfikator bufora typu XR_SPATIAL_BUFFER_TYPE_VECTOR2F_EXT i reprezentuje bufor wierzchołków elementu, na którym znajduje się ten komponent. Wierzchołki muszą być zwracane w kolejności przeciwnym do ruchu wskazówek zegara. Wielokąt reprezentowany przez te wierzchołki nie może się przecinać sam ze sobą i może być wklęsły.

XrSpatialBufferEXT :: bufferType dla vertexBuffer musi mieć wartość XR_SPATIAL_BUFFER_TYPE_VECTOR2F_EXT .

Prawidłowe użycie (pośrednie)

• Przed użyciem XrSpatialPolygon2DDataEXT musi być włączone rozszerzenie XR_EXT_spatial_plane_tracking.
• vertexBuffer musi być prawidłową strukturą XrSpatialBufferEXT.

Struktura listy komponentów do wysyłania zapytań o dane

Struktura XrSpatialComponentPolygon2DListEXT jest zdefiniowana w ten sposób:

typedef struct XrSpatialComponentPolygon2DListEXT {
    XrStructureType               type;
    void*                         next;
    uint32_t                      polygonCount;
    XrSpatialPolygon2DDataEXT*    polygons;
} XrSpatialComponentPolygon2DListEXT;

Opisy elementów

• type to XrStructureType tej struktury.
• next to NULL lub wskaźnik do następnej struktury w łańcuchu struktur.
• polygonCount to uint32_t opisująca liczbę elementów w tablicy polygons.
• polygons to tablica XrSpatialPolygon2DDataEXT .

Aby wysłać zapytanie o komponent wielokąta 2D elementów przestrzennych w XrSpatialSnapshotEXT , dodaj XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT do XrSpatialComponentDataQueryConditionEXT :: componentTypes i dodaj XrSpatialComponentPolygon2DListEXT do łańcucha XrSpatialComponentDataQueryResultEXT :: next.

Środowisko wykonawcze musi zwrócić XR_ERROR_VALIDATION_FAILURE z xrQuerySpatialComponentDataEXT, jeśli XrSpatialComponentPolygon2DListEXT znajduje się w łańcuchu XrSpatialComponentDataQueryResultEXT :: next, ale XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT nie jest uwzględniony w XrSpatialComponentDataQueryConditionEXT :: componentTypes .

Środowisko wykonawcze musi zwrócić XR_ERROR_SIZE_INSUFFICIENT z xrQuerySpatialComponentDataEXT, jeśli polygonCount jest mniejsza niż XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput .

Prawidłowe użycie (pośrednie)

• Przed użyciem XrSpatialComponentPolygon2DListEXT musi być włączone rozszerzenie XR_EXT_spatial_plane_tracking.
• type musi mieć wartość XR_TYPE_SPATIAL_COMPONENT_POLYGON_2D_LIST_EXT
• next musi mieć wartość NULL lub prawidłowy wskaźnik do następnej struktury w łańcuchu struktur.
• polygons musi być wskaźnikiem do tablicy polygonCount struktur XrSpatialPolygon2DDataEXT.
• Parametr polygonCount musi być większy niż 0.

Konfiguracja

Jeśli XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT jest wyliczony w XrSpatialCapabilityComponentTypesEXT :: componentTypes dla jakiejś możliwości, aplikacja może go włączyć, dodając wyliczenie do listy XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents struktury pochodnej XrSpatialCapabilityConfigurationBaseHeaderEXT możliwości, która obsługuje ten komponent.

Ten komponent nie wymaga żadnej specjalnej konfiguracji, aby można go było uwzględnić w łańcuchu XrSpatialCapabilityConfigurationBaseHeaderEXT :: next.

Etykieta semantyczna płaszczyzny

Dane komponentu

typedef enum XrSpatialPlaneSemanticLabelEXT {
    XR_SPATIAL_PLANE_SEMANTIC_LABEL_UNCATEGORIZED_EXT = 1,
    XR_SPATIAL_PLANE_SEMANTIC_LABEL_FLOOR_EXT = 2,
    XR_SPATIAL_PLANE_SEMANTIC_LABEL_WALL_EXT = 3,
    XR_SPATIAL_PLANE_SEMANTIC_LABEL_CEILING_EXT = 4,
    XR_SPATIAL_PLANE_SEMANTIC_LABEL_TABLE_EXT = 5,
    XR_SPATIAL_PLANE_SEMANTIC_LABEL_MAX_ENUM_EXT = 0x7FFFFFFF
} XrSpatialPlaneSemanticLabelEXT;

Wyliczenie XrSpatialPlaneSemanticLabelEXT opisuje zestaw etykiet semantycznych dla płaszczyzn.

Opis wyliczenia

XR_SPATIAL_PLANE_SEMANTIC_LABEL_UNCATEGORIZED_EXT

Środowisko wykonawcze nie mogło sklasyfikować tego elementu.

XR_SPATIAL_PLANE_SEMANTIC_LABEL_FLOOR_EXT

Element jest podłogą.

XR_SPATIAL_PLANE_SEMANTIC_LABEL_WALL_EXT

Element jest ścianą.

XR_SPATIAL_PLANE_SEMANTIC_LABEL_CEILING_EXT

Element jest sufitem.

XR_SPATIAL_PLANE_SEMANTIC_LABEL_TABLE_EXT

Element jest stołem.

Struktura listy komponentów do wysyłania zapytań o dane

Struktura XrSpatialComponentPlaneSemanticLabelListEXT jest zdefiniowana w ten sposób:

typedef struct XrSpatialComponentPlaneSemanticLabelListEXT {
    XrStructureType                    type;
    void*                              next;
    uint32_t                           semanticLabelCount;
    XrSpatialPlaneSemanticLabelEXT*    semanticLabels;
} XrSpatialComponentPlaneSemanticLabelListEXT;

Opisy elementów

• type to XrStructureType tej struktury.
• next to NULL lub wskaźnik do następnej struktury w łańcuchu struktur.
• semanticLabelCount to uint32_t opisująca liczbę elementów w tablicy semanticLabels.
• semanticLabels to tablica XrSpatialPlaneSemanticLabelEXT .

Aby wysłać zapytanie o komponent etykiety semantycznej płaszczyzny elementów przestrzennych w XrSpatialSnapshotEXT , dodaj XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT do XrSpatialComponentDataQueryConditionEXT :: componentTypes i dodaj XrSpatialComponentPlaneSemanticLabelListEXT do łańcucha XrComponentDataQueryResultEXT :: next.

Środowisko wykonawcze musi zwrócić XR_ERROR_VALIDATION_FAILURE z xrQuerySpatialComponentDataEXT, jeśli XrSpatialComponentPlaneSemanticLabelListEXT znajduje się w łańcuchu XrSpatialComponentDataQueryResultEXT :: next, ale XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT nie jest uwzględniony w XrSpatialComponentDataQueryConditionEXT :: componentTypes .

Środowisko wykonawcze musi zwrócić XR_ERROR_SIZE_INSUFFICIENT z xrQuerySpatialComponentDataEXT, jeśli semanticLabelCount jest mniejsza niż XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput .

Prawidłowe użycie (pośrednie)

• Przed użyciem XrSpatialComponentPlaneSemanticLabelListEXT musi być włączone rozszerzenie XR_EXT_spatial_plane_tracking.
• type musi mieć wartość XR_TYPE_SPATIAL_COMPONENT_PLANE_SEMANTIC_LABEL_LIST_EXT
• next musi mieć wartość NULL lub prawidłowy wskaźnik do następnej struktury w łańcuchu struktur.
• semanticLabels musi być wskaźnikiem do tablicy semanticLabelCount XrSpatialPlaneSemanticLabelEXT wartości
• Parametr semanticLabelCount musi być większy niż 0

Konfiguracja

Jeśli XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT jest wyliczony w XrSpatialCapabilityComponentTypesEXT :: componentTypes dla jakiejś możliwości, aplikacja może go włączyć, dodając wyliczenie do listy XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents struktury pochodnej XrSpatialCapabilityConfigurationBaseHeaderEXT możliwości, która obsługuje ten komponent.

Ten komponent nie wymaga żadnej specjalnej konfiguracji, aby można go było uwzględnić w łańcuchu XrSpatialCapabilityConfigurationBaseHeaderEXT :: next.

Przykładowy kod

Konfigurowanie możliwości śledzenia płaszczyzny

Poniższy przykładowy kod pokazuje, jak skonfigurować możliwość śledzenia płaszczyzny podczas tworzenia kontekstu przestrzennego.

// Check if plane tracking capability is supported
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_PLANE_TRACKING_EXT) == capabilities.end()) {
  return;
}

// Enumerate supported components for plane tracking capability
XrSpatialCapabilityComponentTypesEXT planeComponents{XR_TYPE_SPATIAL_CAPABILITY_COMPONENT_TYPES_EXT};
CHK_XR(xrEnumerateSpatialCapabilityComponentTypesEXT(instance, systemId, XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT, &planeComponents));
std::vector<XrSpatialComponentTypeEXT> planeCapabilityComponents(planeComponents.componentTypeCountOutput);
planeComponents.componentTypeCapacityInput = planeCapabilityComponents.size();
planeComponents.componentTypes = planeCapabilityComponents.data();
CHK_XR(xrEnumerateSpatialCapabilityComponentTypesEXT(instance, systemId, XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT, &planeComponents));

// Check if polygon 2D and plane semantic labels optional components are supported
const auto supportsComponent = [&planeCapabilityComponents](XrSpatialComponentTypeEXT component) {
  return std::find(planeCapabilityComponents.begin(), planeCapabilityComponents.end(), component) != planeCapabilityComponents.end();
};

const bool supportsPolygon2DComponent = supportsComponent(XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT);
const bool supportsSemanticLabelComponent = supportsComponent(XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT);

// Create a spatial context
XrSpatialContextEXT spatialContext{};

// Enable the 2 guaranteed components of the plane tracking capability
std::vector<XrSpatialComponentTypeEXT> enabledComponents = {
  XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT,
  XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT,
};
// Optionally enable polygon2D if it is supported
if (supportsPolygon2DComponent) {
  enabledComponents.push_back(XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT);
}
// Optionally enable semantic labels if it is supported
if (supportsSemanticLabelComponent) {
  enabledComponents.push_back(XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT);
}

XrSpatialCapabilityConfigurationPlaneTrackingEXT planeConfig{XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_PLANE_TRACKING_EXT};
planeConfig.capability = XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT;
planeConfig.enabledComponentCount = enabledComponents.size();
planeConfig.enabledComponents = enabledComponents.data();

std::array<XrSpatialCapabilityConfigurationBaseHeaderEXT*, 1> capabilityConfigs = {
  reinterpret_cast<XrSpatialCapabilityConfigurationBaseHeaderEXT*>(&planeConfig),
};

XrSpatialContextCreateInfoEXT spatialContextCreateInfo{XR_TYPE_SPATIAL_CONTEXT_CREATE_INFO_EXT};
spatialContextCreateInfo.capabilityConfigCount = capabilityConfigs.size();
spatialContextCreateInfo.capabilityConfigs = capabilityConfigs.data();
XrFutureEXT createContextFuture;
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) {
  return;
}

spatialContext = completion.spatialContext;

// ...
// Discover entities with the spatial context
// ...

CHK_XR(xrDestroySpatialContextEXT(spatialContext));

Odkrywanie elementów przestrzennych i wysyłanie zapytań o dane komponentu

Poniższy przykładowy kod pokazuje, jak odkrywać elementy przestrzenne w kontekście skonfigurowanym za pomocą XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT i wysyłać zapytania o dane komponentu.

XrFutureEXT future = XR_NULL_FUTURE_EXT;

// We want to look for entities that have the following components.
std::vector<XrSpatialComponentTypeEXT> snapshotComponents = {
  XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT,
  XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT,
};
if (supportsPolygon2DComponent) {
  snapshotComponents.push_back(XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT);
}
if (supportsSemanticLabelComponent) {
  snapshotComponents.push_back(XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT);
}

auto discoverSpatialEntities = [&](XrSpatialContextEXT spatialContext, XrTime time) {
  XrSpatialDiscoverySnapshotCreateInfoEXT snapshotCreateInfo{XR_TYPE_SPATIAL_DISCOVERY_SNAPSHOT_CREATE_INFO_EXT};
  snapshotCreateInfo.componentTypeCount = snapshotComponents.size();
  snapshotCreateInfo.componentTypes = snapshotComponents.data();
  CHK_XR(xrCreateSpatialDiscoverySnapshotAsyncEXT(spatialContext, &snapshotCreateInfo, &future));

  waitUntilReady(future);

  XrCreateSpatialDiscoverySnapshotCompletionInfoEXT completionInfo{XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_INFO_EXT};
  completionInfo.baseSpace = localSpace;
  completionInfo.time = time;
  completionInfo.future = future;

  XrCreateSpatialDiscoverySnapshotCompletionEXT completion{XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_EXT};
  CHK_XR(xrCreateSpatialDiscoverySnapshotCompleteEXT(spatialContext, &completionInfo, &completion));
  if (completion.futureResult == XR_SUCCESS) {

    // Query for the semantic label component data
    XrSpatialComponentDataQueryConditionEXT queryCond{XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_CONDITION_EXT};
    queryCond.componentTypeCount = snapshotComponents.size();
    queryCond.componentTypes = snapshotComponents.data();

    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.entityIdCountOutput);
    queryResult.entityIdCapacityInput = entityIds.size();
    queryResult.entityIds = entityIds.data();
    queryResult.entityStateCapacityInput = entityStates.size();
    queryResult.entityStates = entityStates.data();

    std::vector<XrSpatialBounded2DDataEXT> bounded2D(queryResult.entityIdCountOutput);
    XrSpatialComponentBounded2DListEXT bounded2DList{XR_TYPE_SPATIAL_COMPONENT_BOUNDED_2D_LIST_EXT};
    bounded2DList.boundCount = bounded2D.size();
    bounded2DList.bounds = bounded2D.data();
    queryResult.next = &bounded2DList;

    std::vector<XrSpatialPolygon2DDataEXT> polygons;
    XrSpatialComponentPolygon2DListEXT polygonList{XR_TYPE_SPATIAL_COMPONENT_POLYGON_2D_LIST_EXT};
    if (supportsPolygon2DComponent) {
      polygons.resize(queryResult.entityIdCountOutput);
      polygonList.polygonCount = polygons.size();
      polygonList.polygons = polygons.data();
      polygonList.next = queryResult.next;
      queryResult.next = &polygonList;
    }

    std::vector<XrSpatialPlaneSemanticLabelEXT> semanticLabels;
    XrSpatialComponentPlaneSemanticLabelListEXT semanticLabelsList{XR_TYPE_SPATIAL_COMPONENT_PLANE_SEMANTIC_LABEL_LIST_EXT};
    if (supportsSemanticLabelComponent) {
      semanticLabels.resize(queryResult.entityIdCountOutput);
      semanticLabelsList.semanticLabelCount = semanticLabels.size();
      semanticLabelsList.semanticLabels = semanticLabels.data();
      semanticLabelsList.next = queryResult.next;
      queryResult.next = &semanticLabelsList;
    }

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

      // 2D bounds for entity entityIds[i] is bounded2D[i].extents centered on bounded2D[i].center.

      if (supportsPolygon2DComponent) {
        // 2D polygon for entity entityIds[i] is the buffer represented by polygons[i].bufferId.
        // Application uses flink:xrGetSpatialBufferVector2fEXT to get the buffer data.
      }

      if (supportsSemanticLabelComponent) {
        // semantic label for entity entityIds[i] is semanticLabels[i].
      }
    }

    CHK_XR(xrDestroySpatialSnapshotEXT(completion.snapshot));
  }
};

while (1) {
  // ...
  // For every frame in frame loop
  // ...

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

  // ...
  // Finish frame loop
  // ...
}

Nowe struktury

• XrSpatialCapabilityConfigurationPlaneTrackingEXT
• XrSpatialPolygon2DDataEXT

• Rozszerzanie XrSpatialComponentDataQueryResultEXT :

  • XrSpatialComponentMesh2DListEXT
  • XrSpatialComponentPlaneAlignmentListEXT
  • XrSpatialComponentPlaneSemanticLabelListEXT
  • XrSpatialComponentPolygon2DListEXT

Nowe wyliczenia

• XrSpatialPlaneAlignmentEXT
• XrSpatialPlaneSemanticLabelEXT

Nowe stałe wyliczenia

• XR_EXT_SPATIAL_PLANE_TRACKING_EXTENSION_NAME
• XR_EXT_spatial_plane_tracking_SPEC_VERSION

• Rozszerzanie XrSpatialCapabilityEXT :

  • XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT

• Rozszerzanie XrSpatialComponentTypeEXT :

  • XR_SPATIAL_COMPONENT_TYPE_MESH_2D_EXT
  • XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT
  • XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT
  • XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT

• Rozszerzanie XrStructureType :

  • XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_PLANE_TRACKING_EXT
  • XR_TYPE_SPATIAL_COMPONENT_MESH_2D_LIST_EXT
  • XR_TYPE_SPATIAL_COMPONENT_PLANE_ALIGNMENT_LIST_EXT
  • XR_TYPE_SPATIAL_COMPONENT_PLANE_SEMANTIC_LABEL_LIST_EXT
  • XR_TYPE_SPATIAL_COMPONENT_POLYGON_2D_LIST_EXT

Problemy

Historia zmian

• Wersja 1, 2.07.2024 (Nihav Jain, Google)

  • Początkowy opis rozszerzenia