XR_EXT_spatial_object_tracking

Name String

XR_EXT_spatial_object_tracking

Tipo de extensión

Extensión de instancia

Número de extensión registrado

745

Revisión

1

Estado de ratificación

No ratificado

Dependencias de extensiones y versiones

XR_EXT_spatial_entity

Estado de la IP

No hay reclamos de IP conocidos.

Colaboradores

Nihav Jain, Google
Natalie Fleury, Meta
Yuichi Taguchi, Meta
Ron Bessems, Meta
Yin Li, Microsoft
Jimmy Alamparambil, ByteDance
Zhipeng Liu, ByteDance
Jun Yan, ByteDance
Andy Biar, Unity Technologies
Rebecca Nordhauser, Unity Technologies

Descripción general

Esta extensión se basa en XR_EXT_spatial_entity y define una capacidad espacial para hacer un seguimiento de un conjunto de objetos predefinidos sin requerir un conjunto de datos de entrada de la aplicación.

Asistencia del entorno de ejecución

Si el entorno de ejecución admite el seguimiento de objetos, debe indicarlo enumerando XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_EXT en xrEnumerateSpatialCapabilitiesEXT .

Configuración

La estructura XrSpatialCapabilityConfigurationObjectTrackingEXT se define de la siguiente manera:

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

Descripciones de los miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructuras.
  • capability es un XrSpatialCapabilityEXT y debe ser XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_EXT .
  • enabledComponentCount es un uint32_t que describe el recuento de elementos en el array enabledComponents.
  • enabledComponents es un puntero a un array de XrSpatialComponentTypeEXT .

Las aplicaciones pueden habilitar la capacidad espacial XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_EXT agregando un puntero a la estructura XrSpatialCapabilityConfigurationObjectTrackingEXT en XrSpatialContextCreateInfoEXT :: capabilityConfigs .

El entorno de ejecución debe devolver XR_ERROR_VALIDATION_FAILURE si capability no es XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_EXT .

Uso válido (implícito)

Componentes garantizados

Un entorno de ejecución que admita XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_EXT debe admitir los siguientes componentes espaciales como componentes garantizados de las entidades descubiertas por esta función y debe enumerarlos en xrEnumerateSpatialCapabilityComponentTypesEXT :

  • XR_SPATIAL_COMPONENT_TYPE_BOUNDED_3D_EXT
  • Al menos un tipo de componente que proporcione un conjunto de etiquetas semánticas para los objetos de los que se hace un seguimiento. Una función de seguimiento de objetos no tiene sentido sin un componente de etiqueta semántica. Si bien esta extensión define XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_EXT y XR_SPATIAL_COMPONENT_TYPE_KEYBOARD_SEMANTIC_LABEL_EXT como posibles componentes de etiquetas semánticas para que los entornos de ejecución los admitan, otras extensiones pueden definir nuevos tipos de componentes para proporcionar diferentes clases de etiquetas semánticas que describan un objeto con seguimiento. Consulta [ext_spatial_semantic_labels_guidelines] para obtener detalles sobre los conjuntos de etiquetas semánticas y el diseño de los tipos de componentes. Los entornos de ejecución pueden no admitir XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_EXT ni XR_SPATIAL_COMPONENT_TYPE_KEYBOARD_SEMANTIC_LABEL_EXT para la capacidad de seguimiento de objetos, pero deben admitir al menos un tipo de componente que proporcione una etiqueta semántica.

Componente 3D delimitado

El componente 3D limitado proporciona el centro y las extensiones del objeto representado por la entidad en la que se encuentra. Consulta Bounded 3D para obtener más detalles.

Componentes opcionales

Un entorno de ejecución que admita XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_EXT puede admitir componentes espaciales además de los que se indican en la sección Componentes garantizados. La aplicación puede usar xrEnumerateSpatialCapabilityComponentTypesEXT para obtener la lista completa de componentes que admite un entorno de ejecución y, luego, puede configurar los que le interesan cuando crea el contexto espacial.

Etiqueta semántica del objeto

Datos de componentes

typedef enum XrSpatialObjectSemanticLabelEXT {
    XR_SPATIAL_OBJECT_SEMANTIC_LABEL_UNCATEGORIZED_EXT = 1,
    XR_SPATIAL_OBJECT_SEMANTIC_LABEL_SOFA_EXT = 2,
    XR_SPATIAL_OBJECT_SEMANTIC_LABEL_BED_EXT = 3,
    XR_SPATIAL_OBJECT_SEMANTIC_LABEL_CHAIR_EXT = 4,
    XR_SPATIAL_OBJECT_SEMANTIC_LABEL_TABLE_EXT = 5,
    XR_SPATIAL_OBJECT_SEMANTIC_LABEL_LAMP_EXT = 6,
    XR_SPATIAL_OBJECT_SEMANTIC_LABEL_PLANT_EXT = 7,
    XR_SPATIAL_OBJECT_SEMANTIC_LABEL_DISPLAY_SCREEN_EXT = 8,
    XR_SPATIAL_OBJECT_SEMANTIC_LABEL_WALL_ART_EXT = 9,
    XR_SPATIAL_OBJECT_SEMANTIC_LABEL_CABINET_EXT = 10,
    XR_SPATIAL_OBJECT_SEMANTIC_LABEL_MAX_ENUM_EXT = 0x7FFFFFFF
} XrSpatialObjectSemanticLabelEXT;

La enumeración XrSpatialObjectSemanticLabelEXT describe un conjunto de etiquetas semánticas para objetos.

En el caso de las entidades con la etiqueta XR_SPATIAL_OBJECT_SEMANTIC_LABEL_DISPLAY_SCREEN_EXT, el eje +Z del componente Bounded 3D debe coincidir aproximadamente con la normal de la superficie de la pantalla.

En el caso de las entidades con la etiqueta XR_SPATIAL_OBJECT_SEMANTIC_LABEL_WALL_ART_EXT, el eje +Z del componente Bounded 3D debe coincidir con la normal de la superficie de la pared en la que se descubre la obra de arte.

Para las entidades con la etiqueta XR_SPATIAL_OBJECT_SEMANTIC_LABEL_TABLE_EXT, el eje +Z del componente Bounded 3D debe coincidir con la normal de la superficie de la mesa.

Para todas las demás etiquetas de XrSpatialObjectSemanticLabelEXT , la aplicación no debe hacer suposiciones sobre cómo el XrBoxf :: center :: orientation que proporciona el componente Bounded 3D en la entidad se alinea con los atributos físicos de ese objeto.

Los valores de enumeración tienen los siguientes significados:

Descripción de enum

XR_SPATIAL_OBJECT_SEMANTIC_LABEL_UNCATEGORIZED_EXT

El entorno de ejecución no pudo clasificar esta entidad.

XR_SPATIAL_OBJECT_SEMANTIC_LABEL_SOFA_EXT

La entidad es un sofá.

XR_SPATIAL_OBJECT_SEMANTIC_LABEL_BED_EXT

La entidad es una cama.

XR_SPATIAL_OBJECT_SEMANTIC_LABEL_CHAIR_EXT

La entidad es una silla.

XR_SPATIAL_OBJECT_SEMANTIC_LABEL_TABLE_EXT

La entidad es una tabla.

XR_SPATIAL_OBJECT_SEMANTIC_LABEL_LAMP_EXT

La entidad es una lámpara.

XR_SPATIAL_OBJECT_SEMANTIC_LABEL_PLANT_EXT

La entidad es una planta.

XR_SPATIAL_OBJECT_SEMANTIC_LABEL_DISPLAY_SCREEN_EXT

La entidad es una pantalla, como un monitor o una TV.

XR_SPATIAL_OBJECT_SEMANTIC_LABEL_WALL_ART_EXT

La entidad es un mural.

XR_SPATIAL_OBJECT_SEMANTIC_LABEL_CABINET_EXT

La entidad es un gabinete.

Estructura de lista de componentes para consultar datos

La estructura XrSpatialComponentObjectSemanticLabelListEXT se define de la siguiente manera:

typedef struct XrSpatialComponentObjectSemanticLabelListEXT {
    XrStructureType                     type;
    void*                               next;
    uint32_t                            semanticLabelCount;
    XrSpatialObjectSemanticLabelEXT*    semanticLabels;
} XrSpatialComponentObjectSemanticLabelListEXT;

Descripciones de los miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructuras. No se definen tales estructuras en OpenXR principal ni en esta extensión.
  • semanticLabelCount es un uint32_t que describe el recuento de elementos en el array semanticLabels.
  • semanticLabels es un array de XrSpatialObjectSemanticLabelEXT .

Para consultar el componente de etiqueta semántica de objeto de las entidades espaciales en un XrSpatialSnapshotEXT , incluye XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_EXT en XrSpatialComponentDataQueryConditionEXT :: componentTypes y agrega XrSpatialComponentObjectSemanticLabelListEXT a la cadena XrSpatialComponentDataQueryResultEXT :: next.

El entorno de ejecución debe devolver XR_ERROR_VALIDATION_FAILURE de xrQuerySpatialComponentDataEXT si XrSpatialComponentObjectSemanticLabelListEXT está en la cadena XrSpatialComponentDataQueryResultEXT :: next, pero XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_EXT no se incluye en XrSpatialComponentDataQueryConditionEXT :: componentTypes .

El entorno de ejecución debe devolver XR_ERROR_SIZE_INSUFFICIENT de xrQuerySpatialComponentDataEXT si semanticLabelCount es menor que XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput .

Uso válido (implícito)

Configuración

Si XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_EXT se enumera en XrSpatialCapabilityComponentTypesEXT :: componentTypes para alguna capacidad, una aplicación puede habilitarla incluyendo el enumerante en la lista XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents de la estructura derivada XrSpatialCapabilityConfigurationBaseHeaderEXT de la capacidad que admite este componente.

Este componente no requiere ninguna configuración especial para incluirse en la cadena XrSpatialCapabilityConfigurationBaseHeaderEXT :: next, pero ofrece una configuración opcional para que la proporcionen las aplicaciones.

La estructura XrSpatialFeatureObjectSemanticLabelSubsetEXT se define de la siguiente manera:

typedef struct XrSpatialFeatureObjectSemanticLabelSubsetEXT {
    XrStructureType                           type;
    const void*                               next;
    uint32_t                                  semanticLabelCount;
    const XrSpatialObjectSemanticLabelEXT*    semanticLabels;
} XrSpatialFeatureObjectSemanticLabelSubsetEXT;

Descripciones de los miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructuras.
  • semanticLabelCount es un uint32_t que describe el recuento de elementos en el array semanticLabels.
  • semanticLabels es un array de XrSpatialObjectSemanticLabelEXT .

Si el entorno de ejecución enumera XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_EXT de xrEnumerateSpatialCapabilityComponentTypesEXT para una capacidad determinada, también debe enumerar XR_SPATIAL_CAPABILITY_FEATURE_OBJECT_SEMANTIC_LABEL_SUBSET_EXT de xrEnumerateSpatialCapabilityFeaturesEXT para la misma capacidad. Si una aplicación habilita XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_EXT cuando configura esa capability, puede encadenar XrSpatialFeatureObjectSemanticLabelSubsetEXT a la estructura de configuración correspondiente de esa capability para proporcionarle al entorno de ejecución un subconjunto de etiquetas definidas en XrSpatialObjectSemanticLabelEXT . El entorno de ejecución puede usar este subconjunto de etiquetas para optimizar sus canalizaciones de seguimiento.

El entorno de ejecución debe devolver XR_ERROR_VALIDATION_FAILURE de xrCreateSpatialContextAsyncEXT si semanticLabels contiene alguna etiqueta que no esté definida en XrSpatialObjectSemanticLabelEXT o si semanticLabels contiene XR_SPATIAL_OBJECT_SEMANTIC_LABEL_UNCATEGORIZED_EXT .

El entorno de ejecución debe devolver XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT de xrCreateSpatialContextAsyncEXT si la aplicación proporciona una lista válida de etiquetas en semanticLabels, pero XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_EXT no se incluye en el array enabledComponents de XrSpatialCapabilityConfigurationBaseHeaderEXT :: de la estructura de configuración a la que está encadenado XrSpatialFeatureObjectSemanticLabelSubsetEXT.

Si la aplicación configura una capacidad con un XrSpatialFeatureObjectSemanticLabelSubsetEXT válido, el entorno de ejecución no debe incluir entidades que tengan etiquetas semánticas que no aparezcan en semanticLabels en ninguna instantánea de descubrimiento creada para el contexto espacial configurado.

Uso válido (implícito)

Etiqueta semántica del teclado

Datos de componentes

typedef enum XrSpatialKeyboardSemanticLabelEXT {
    XR_SPATIAL_KEYBOARD_SEMANTIC_LABEL_UNCATEGORIZED_EXT = 1,
    XR_SPATIAL_KEYBOARD_SEMANTIC_LABEL_KEYBOARD_EXT = 2,
    XR_SPATIAL_KEYBOARD_SEMANTIC_LABEL_MAX_ENUM_EXT = 0x7FFFFFFF
} XrSpatialKeyboardSemanticLabelEXT;

La enumeración XrSpatialKeyboardSemanticLabelEXT describe una etiqueta semántica para un teclado.

Las extensiones y la orientación de XR_SPATIAL_KEYBOARD_SEMANTIC_LABEL_KEYBOARD_EXT representadas por el componente Bounded 3D en la misma entidad se muestran en la siguiente imagen (con xyz = rgb) que se origina en el centro del objeto.

ext spatial object tracking keyboard orientation

Figura 30. Orientación del teclado

Descripción de enum

XR_SPATIAL_KEYBOARD_SEMANTIC_LABEL_UNCATEGORIZED_EXT

El entorno de ejecución no pudo clasificar esta entidad.

XR_SPATIAL_KEYBOARD_SEMANTIC_LABEL_KEYBOARD_EXT

La entidad es un teclado.

Struct de lista de componentes para consultar datos

La estructura XrSpatialComponentKeyboardSemanticLabelListEXT se define de la siguiente manera:

typedef struct XrSpatialComponentKeyboardSemanticLabelListEXT {
    XrStructureType                       type;
    void*                                 next;
    uint32_t                              semanticLabelCount;
    XrSpatialKeyboardSemanticLabelEXT*    semanticLabels;
} XrSpatialComponentKeyboardSemanticLabelListEXT;

Descripciones de los miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructuras. No se definen tales estructuras en OpenXR principal ni en esta extensión.
  • semanticLabelCount es un uint32_t que describe el recuento de elementos en el array semanticLabels.
  • semanticLabels es un array de XrSpatialKeyboardSemanticLabelEXT .

Para consultar el componente de etiqueta semántica del teclado de las entidades espaciales en un XrSpatialSnapshotEXT , incluye XR_SPATIAL_COMPONENT_TYPE_KEYBOARD_SEMANTIC_LABEL_EXT en XrSpatialComponentDataQueryConditionEXT :: componentTypes y agrega XrSpatialComponentKeyboardSemanticLabelListEXT a la cadena XrSpatialComponentDataQueryResultEXT :: next.

El entorno de ejecución debe devolver XR_ERROR_VALIDATION_FAILURE de xrQuerySpatialComponentDataEXT si XrSpatialComponentKeyboardSemanticLabelListEXT está en la cadena XrSpatialComponentDataQueryResultEXT :: next, pero XR_SPATIAL_COMPONENT_TYPE_KEYBOARD_SEMANTIC_LABEL_EXT no se incluye en XrSpatialComponentDataQueryConditionEXT :: componentTypes .

El entorno de ejecución debe devolver XR_ERROR_SIZE_INSUFFICIENT de xrQuerySpatialComponentDataEXT si semanticLabelCount es menor que XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput .

Uso válido (implícito)

Configuración

Si XR_SPATIAL_COMPONENT_TYPE_KEYBOARD_SEMANTIC_LABEL_EXT se enumera en XrSpatialCapabilityComponentTypesEXT :: componentTypes para alguna capacidad, una aplicación puede habilitarla incluyendo el enumerante en la lista XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents de la estructura derivada XrSpatialCapabilityConfigurationBaseHeaderEXT de la capacidad que admite este componente.

Este componente no requiere ninguna configuración especial para incluirse en la cadena XrSpatialCapabilityConfigurationBaseHeaderEXT :: next.

Etiqueta semántica del mouse

Datos de componentes

typedef enum XrSpatialMouseSemanticLabelEXT {
    XR_SPATIAL_MOUSE_SEMANTIC_LABEL_UNCATEGORIZED_EXT = 1,
    XR_SPATIAL_MOUSE_SEMANTIC_LABEL_MOUSE_EXT = 2,
    XR_SPATIAL_MOUSE_SEMANTIC_LABEL_MAX_ENUM_EXT = 0x7FFFFFFF
} XrSpatialMouseSemanticLabelEXT;

La enumeración XrSpatialMouseSemanticLabelEXT describe una etiqueta semántica para un mouse.

Descripción de enum

XR_SPATIAL_MOUSE_SEMANTIC_LABEL_UNCATEGORIZED_EXT

El entorno de ejecución no pudo clasificar esta entidad.

XR_SPATIAL_MOUSE_SEMANTIC_LABEL_MOUSE_EXT

La entidad es un mouse.

Struct de lista de componentes para consultar datos

La estructura XrSpatialComponentMouseSemanticLabelListEXT se define de la siguiente manera:

typedef struct XrSpatialComponentMouseSemanticLabelListEXT {
    XrStructureType                    type;
    void*                              next;
    uint32_t                           semanticLabelCount;
    XrSpatialMouseSemanticLabelEXT*    semanticLabels;
} XrSpatialComponentMouseSemanticLabelListEXT;

Descripciones de los miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructuras. No se definen tales estructuras en OpenXR principal ni en esta extensión.
  • semanticLabelCount es un uint32_t que describe el recuento de elementos en el array semanticLabels.
  • semanticLabels es un array de XrSpatialMouseSemanticLabelEXT .

Para consultar el componente de etiqueta semántica del mouse de las entidades espaciales en un XrSpatialSnapshotEXT , incluye XR_SPATIAL_COMPONENT_TYPE_MOUSE_SEMANTIC_LABEL_EXT en XrSpatialComponentDataQueryConditionEXT :: componentTypes y agrega XrSpatialComponentMouseSemanticLabelListEXT a la cadena XrSpatialComponentDataQueryResultEXT :: next.

El entorno de ejecución debe devolver XR_ERROR_VALIDATION_FAILURE de xrQuerySpatialComponentDataEXT si XrSpatialComponentMouseSemanticLabelListEXT está en la cadena XrSpatialComponentDataQueryResultEXT :: next, pero XR_SPATIAL_COMPONENT_TYPE_MOUSE_SEMANTIC_LABEL_EXT no se incluye en XrSpatialComponentDataQueryConditionEXT :: componentTypes .

El entorno de ejecución debe devolver XR_ERROR_SIZE_INSUFFICIENT de xrQuerySpatialComponentDataEXT si semanticLabelCount es menor que XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput .

Uso válido (implícito)

Configuración

Si XR_SPATIAL_COMPONENT_TYPE_MOUSE_SEMANTIC_LABEL_EXT se enumera en XrSpatialCapabilityComponentTypesEXT :: componentTypes para alguna capacidad, una aplicación puede habilitarla incluyendo el enumerante en la lista XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents de la estructura derivada XrSpatialCapabilityConfigurationBaseHeaderEXT de la capacidad que admite este componente.

Este componente no requiere ninguna configuración especial para incluirse en la cadena XrSpatialCapabilityConfigurationBaseHeaderEXT :: next.

Ejemplo de código

Configura la capacidad de seguimiento de objetos

En el siguiente código de ejemplo, se muestra cómo configurar la capacidad de seguimiento de objetos cuando se crea un contexto espacial.

// Check if object 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_OBJECT_TRACKING_EXT) == capabilities.end()) {
  return;
}

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

// Check if the object & keyboard semantic labels component is supported
const auto supportsComponent = [&objectCapabilityComponents](XrSpatialComponentTypeEXT component) {
  return std::find(objectCapabilityComponents.begin(), objectCapabilityComponents.end(), component) != objectCapabilityComponents.end();
};

const bool supportsObjectSemanticLabel = supportsComponent(XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_EXT);
const bool supportsKeyboardSemanticLabel = supportsComponent(XR_SPATIAL_COMPONENT_TYPE_KEYBOARD_SEMANTIC_LABEL_EXT);

// Enumerate supported features for object tracking capability
uint32_t featureCount;
CHK_XR(xrEnumerateSpatialCapabilityFeaturesEXT(instance, systemId, XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_EXT, 0, &featureCount, nullptr));
std::vector<XrSpatialCapabilityFeatureEXT> features(featureCount);
CHK_XR(xrEnumerateSpatialCapabilityFeaturesEXT(instance, systemId, XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_EXT, featureCount, &featureCount, features.data()));

const bool supportsObjectSemanticLabelSubsetFeature = std::find(features.begin(), features.end(), XR_SPATIAL_CAPABILITY_FEATURE_OBJECT_SEMANTIC_LABEL_SUBSET_EXT) != features.end();

// Create a spatial context
XrSpatialContextEXT spatialContext{};

// Enable the guaranteed components of the object tracking capability
std::vector<XrSpatialComponentTypeEXT> enabledComponents = {
  XR_SPATIAL_COMPONENT_TYPE_BOUNDED_3D_EXT,
};
// Optionally enable the supported semantic labels
if (supportsObjectSemanticLabel) {
  enabledComponents.push_back(XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_EXT);
}
if (supportsKeyboardSemanticLabel) {
  enabledComponents.push_back(XR_SPATIAL_COMPONENT_TYPE_KEYBOARD_SEMANTIC_LABEL_EXT);
}

// We only want to track sofa and table.
std::vector<XrSpatialObjectSemanticLabelEXT> objectSemanticLabelSubset = {
  XR_SPATIAL_OBJECT_SEMANTIC_LABEL_SOFA_EXT,
  XR_SPATIAL_OBJECT_SEMANTIC_LABEL_TABLE_EXT
};
XrSpatialFeatureObjectSemanticLabelSubsetEXT subsetFeature{XR_TYPE_SPATIAL_FEATURE_OBJECT_SEMANTIC_LABEL_SUBSET_EXT};
subsetFeature.semanticLabelCount = objectSemanticLabelSubset.size();
subsetFeature.semanticLabels = objectSemanticLabelSubset.data();

XrSpatialCapabilityConfigurationObjectTrackingEXT objectTrackingConfig{XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_OBJECT_TRACKING_EXT};
objectTrackingConfig.capability = XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_EXT;
objectTrackingConfig.enabledComponentCount = enabledComponents.size();
objectTrackingConfig.enabledComponents = enabledComponents.data();
if (supportsObjectSemanticLabelSubsetFeature) {
  objectTrackingConfig.next = &subsetFeature;
}

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

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;

// ...
// Discovery entities with the spatial context
// ...

CHK_XR(xrDestroySpatialContextEXT(spatialContext));

Descubre entidades espaciales y consulta datos de componentes

En el siguiente código de ejemplo, se muestra cómo descubrir entidades espaciales para un contexto configurado con XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_EXT y consultar sus datos de componentes.

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_3D_EXT,
};
if (supportsKeyboardSemanticLabel) {
  snapshotComponents.push_back(XR_SPATIAL_COMPONENT_TYPE_KEYBOARD_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<XrBoxf> bounded3D(queryResult.entityIdCountOutput);
    XrSpatialComponentBounded3DListEXT bounded3DList{XR_TYPE_SPATIAL_COMPONENT_BOUNDED_3D_LIST_EXT};
    bounded3DList.boundCount = bounded3D.size();
    bounded3DList.bounds = bounded3D.data();
    queryResult.next = &bounded3DList;

    std::vector<XrSpatialKeyboardSemanticLabelEXT> semanticLabels;
    XrSpatialComponentKeyboardSemanticLabelListEXT semanticLabelsList{XR_TYPE_SPATIAL_COMPONENT_KEYBOARD_SEMANTIC_LABEL_LIST_EXT};
    if (supportsKeyboardSemanticLabel) {
      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;
      }

      // 3D bounds for entity entityIds[i] is bounded3D[i].extents centered on bounded3D[i].center.

      if (supportsKeyboardSemanticLabel) {
        // 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
  // ...
}

Estructuras nuevas

Enums nuevas

Nuevas constantes de enum

  • XR_EXT_SPATIAL_OBJECT_TRACKING_EXTENSION_NAME
  • XR_EXT_spatial_object_tracking_SPEC_VERSION

  • Extiende XrSpatialCapabilityEXT :

    • XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_EXT

  • Extensión de XrSpatialCapabilityFeatureEXT :

    • XR_SPATIAL_CAPABILITY_FEATURE_OBJECT_SEMANTIC_LABEL_SUBSET_EXT

  • Extiende XrSpatialComponentTypeEXT :

    • XR_SPATIAL_COMPONENT_TYPE_KEYBOARD_SEMANTIC_LABEL_EXT
    • XR_SPATIAL_COMPONENT_TYPE_MOUSE_SEMANTIC_LABEL_EXT
    • XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_EXT

  • Extiende XrStructureType :

    • XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_OBJECT_TRACKING_EXT
    • XR_TYPE_SPATIAL_COMPONENT_KEYBOARD_SEMANTIC_LABEL_LIST_EXT
    • XR_TYPE_SPATIAL_COMPONENT_MOUSE_SEMANTIC_LABEL_LIST_EXT
    • XR_TYPE_SPATIAL_COMPONENT_OBJECT_SEMANTIC_LABEL_LIST_EXT
    • XR_TYPE_SPATIAL_FEATURE_OBJECT_SEMANTIC_LABEL_SUBSET_EXT

Problemas

Historial de versiones

  • Revisión 1, 3 de junio de 2025 (Nihav Jain, Google)

    • Descripción inicial de la extensión