XR_ANDROID_spatial_discovery_raycast

Name String

XR_ANDROID_spatial_discovery_raycast

Tipo de extensión

Extensión de instancia

Número de extensión registrado

787

Revisión

1

Estado de ratificación

No ratificado

Dependencias de extensiones y versiones

XR_EXT_spatial_entity

Fecha de la última modificación

12/8/2025

Estado de la IP

No hay reclamos de IP conocidos.

Colaboradores

Brian Chen, Google
Levana Chen, Google
Kyle Chen, Google
Nihav Jain, Google
Spencer Quin, Google
Natalie Fleury, Meta
Yuichi Taguchi, Meta
Jimmy Alamparambil, ByteDance
Zhipeng Liu, ByteDance

Descripción general

Esta extensión se basa en XR_EXT_spatial_entity y proporciona la funcionalidad de raycast para las capacidades espaciales existentes, como XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT , para descubrir entidades espaciales.

Esta extensión también presenta una nueva función espacial para el trazado de rayos en el búfer de profundidad.

Permisos

Son los permisos obligatorios según las funciones que use la aplicación para Android. Si se usa XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID, la aplicación debe tener el permiso android.permission.SCENE_UNDERSTANDING_FINE. Si se usa XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT, la aplicación debe tener el permiso android.permission.SCENE_UNDERSTANDING_COARSE. El permiso android.permission.SCENE_UNDERSTANDING_FINE también implica el permiso android.permission.SCENE_UNDERSTANDING_COARSE. Si la aplicación usa ambas capacidades, no es necesario que solicite ambos permisos por separado.

Tanto android.permission.SCENE_UNDERSTANDING_COARSE como android.permission.SCENE_UNDERSTANDING_FINE se consideran permisos peligrosos.

(nivel de protección: peligroso)

Asistencia del entorno de ejecución

Si el entorno de ejecución admite el descubrimiento de entidades espaciales a través de la proyección de rayos, debe indicarlo enumerando XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID en xrEnumerateSpatialCapabilityComponentTypesEXT para las capacidades que admiten el descubrimiento por proyección de rayos.

Si el entorno de ejecución admite el trazado de rayos en el búfer de profundidad, debe enumerar XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID en xrEnumerateSpatialCapabilitiesEXT .

Descubre entidades espaciales con el trazado de rayos

La estructura XrSpatialRaycastInfoANDROID se define de la siguiente manera:

typedef struct XrSpatialRaycastInfoANDROID {
    XrStructureType    type;
    const void*        next;
    XrSpace            space;
    XrTime             time;
    XrVector3f         origin;
    XrVector3f         direction;
    float              maxDistance;
} XrSpatialRaycastInfoANDROID;

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.
  • space es el XrSpace en el que se ubicará la pose de XrSpatialRaycastResultDataANDROID.
  • time es un XrTime en el que se define la pose de XrSpatialRaycastResultDataANDROID.
  • origin es un XrVector3f que describe el origen del rayo.
  • direction es un XrVector3f que describe la dirección del rayo.
  • maxDistance es la distancia en metros que la aplicación puede especificar de forma opcional para limitar el descubrimiento de entidades que se encuentran dentro de la distancia especificada desde el origin , a lo largo de direction .

Una aplicación puede incluir XrSpatialRaycastInfoANDROID en la cadena XrSpatialDiscoverySnapshotCreateInfoEXT :: next para descubrir entidades espaciales que se cruzan con el rayo definido en este struct.

Si una aplicación usa XrSpatialRaycastInfoANDROID con un XrSpatialContextEXT que se configuró sin habilitar XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID para ninguna capacidad, el entorno de ejecución debe devolver XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT desde xrCreateSpatialDiscoverySnapshotAsyncEXT o xrCreateSpatialRaycastSnapshotANDROID .

El entorno de ejecución debe incluir los datos de componentes y los IDs solo de las entidades espaciales de XrSpatialSnapshotEXT que provienen de capacidades que admiten el componente XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID.

Si una aplicación establece maxDistance en un valor positivo, el entorno de ejecución no debe incluir ninguna entidad espacial de impacto en la instantánea que esté a más de maxDistance de panme:origin a lo largo de direction . Si maxDistance se establece en 0 o en un valor negativo, el entorno de ejecución debe considerar el rayo como ilimitado.

Uso válido (implícito)

Componente de resultado de Raycast

La estructura XrSpatialRaycastResultDataANDROID se define de la siguiente manera:

typedef struct XrSpatialRaycastResultDataANDROID {
    XrPosef    hitPose;
    float      distanceSquared;
} XrSpatialRaycastResultDataANDROID;

Descripciones de los miembros

  • hitPose es un XrPosef que define el punto en el que el rayo se cruza con la entidad espacial.
  • distanceSquared es el cuadrado de la distancia desde el origen del rayo hasta el punto de intersección.

El componente XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID solo estará presente en un XrSpatialSnapshotEXT creado a partir de xrCreateSpatialDiscoverySnapshotAsyncEXT, en el que se incluye XrSpatialRaycastInfoANDROID en la cadena XrSpatialDiscoverySnapshotCreateInfoEXT :: next o en un XrSpatialSnapshotEXT creado a partir de xrCreateSpatialRaycastSnapshotANDROID .

El entorno de ejecución no debe incluir este componente en ningún XrSpatialSnapshotEXT que se cree con xrCreateSpatialUpdateSnapshotEXT .

El entorno de ejecución debe devolver XR_ERROR_VALIDATION_FAILURE de xrCreateSpatialUpdateSnapshotEXT si la aplicación incluye XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID en XrSpatialUpdateSnapshotCreateInfoEXT :: componentTypes .

Si XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID está habilitado solo para ciertas capacidades, el entorno de ejecución debe incluir solo las entidades espaciales que proporcionan esas capacidades en la instantánea. Por ejemplo, si un objeto y un plano se alinean en la misma dirección y XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID está habilitado solo para XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT , solo se descubrirá el plano.

El hitPose del XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID se ubicará en XrCreateSpatialDiscoverySnapshotCompletionInfoEXT :: baseSpace en XrCreateSpatialDiscoverySnapshotCompletionInfoEXT :: time . El eje Z positivo es la normal de la superficie de impacto, y el eje Y negativo apunta aproximadamente hacia el origen del rayo.

Uso válido (implícito)

Estructura de la lista de componentes para consultar datos

La estructura XrSpatialComponentRaycastResultListANDROID se define de la siguiente manera:

typedef struct XrSpatialComponentRaycastResultListANDROID {
    XrStructureType                       type;
    void*                                 next;
    uint32_t                              raycastResultCount;
    XrSpatialRaycastResultDataANDROID*    raycastResults;
} XrSpatialComponentRaycastResultListANDROID;

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.
  • raycastResultCount es un uint32_t que describe el recuento de elementos en el array raycastResults.
  • raycastResults es un array de XrSpatialRaycastResultDataANDROID .

Para consultar el componente de resultado de raycast de las entidades espaciales en un XrSpatialSnapshotEXT , incluye XR_TYPE_SPATIAL_COMPONENT_RAYCAST_RESULT_LIST_ANDROID en XrSpatialComponentDataQueryConditionEXT :: componentTypes y agrega XrSpatialComponentRaycastResultListANDROID a la cadena XrSpatialComponentDataQueryResultEXT :: next.

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

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

Los raycastResults que se devuelven no están ordenados. Una aplicación puede usar XrSpatialRaycastResultDataANDROID :: distanceSquared para ordenar los resultados por distancia.

Uso válido (implícito)

Configuración

Si XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID se enumera en XrSpatialCapabilityComponentTypesEXT :: componentTypes para alguna capacidad, la aplicación puede habilitarla incluyendo el valor de enumeración en la lista XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents. Este componente no requiere ninguna configuración especial para incluirse en la siguiente cadena de XrSpatialCapabilityConfigurationBaseHeaderEXT .

El entorno de ejecución debe devolver XR_ERROR_VALIDATION_FAILURE de xrCreateSpatialUpdateSnapshotEXT si la aplicación incluye XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID en XrSpatialUpdateSnapshotCreateInfoEXT :: componentTypes . Este componente es específico de las instantáneas de descubrimiento.

Capacidad espacial de Raycast de profundidad

Configuración

La estructura XrSpatialCapabilityConfigurationDepthRaycastANDROID se define de la siguiente manera:

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

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_DEPTH_RAYCAST_ANDROID .
  • enabledComponentCount es un uint32_t que describe el recuento de elementos en el array enabledComponents. Debe ser mayor que 0.
  • enabledComponents es un puntero a un array de XrSpatialComponentTypeEXT .

Las aplicaciones pueden habilitar la capacidad espacial XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID incluyendo un puntero a una estructura XrSpatialCapabilityConfigurationDepthRaycastANDROID en XrSpatialContextCreateInfoEXT :: capabilityConfigs .

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

El ID de las entidades descubiertas a través de esta función siempre es XR_NULL_SPATIAL_ENTITY_ID_EXT . Esto también significa que la aplicación no puede crear un controlador XrSpatialEntityEXT para estas entidades y, por lo tanto, no se pueden incluir en XrSpatialUpdateSnapshotCreateInfoEXT :: entities para crear una instantánea de actualización.

Uso válido (implícito)

Componentes garantizados

Un entorno de ejecución que admita XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID 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_RAYCAST_RESULT_ANDROID

Raycast síncrono

La función xrCreateSpatialRaycastSnapshotANDROID se define de la siguiente manera:

XrResult xrCreateSpatialRaycastSnapshotANDROID(
    XrSpatialContextEXT                         spatialContext,
    const XrSpatialRaycastSnapshotCreateInfoANDROID* createInfo,
    XrSpatialSnapshotEXT*                       snapshot);

Descripciones de los parámetros

Si bien xrCreateSpatialDiscoverySnapshotAsyncEXT es suficiente para la mayoría de los casos de uso, se considera lento para las aplicaciones que requieren resultados de raycast instantáneos. xrCreateSpatialRaycastSnapshotANDROID inicia un raycast síncrono para crear una instantánea, lo que permite que las aplicaciones comiencen a consultar los resultados de raycast de inmediato.

El entorno de ejecución debe devolver XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT si alguno de los XrSpatialComponentTypeEXT en XrSpatialRaycastSnapshotCreateInfoANDROID :: componentTypes no está habilitado para las capacidades espaciales que se pasan a XrSpatialContextCreateInfoEXT :: capabilityConfigs cuando se crea spatialContext .

Si la aplicación no proporciona una lista de tipos de componentes espaciales en XrSpatialRaycastSnapshotCreateInfoANDROID :: componentTypes , el entorno de ejecución debe incluir todas las entidades espaciales en la instantánea que tengan el conjunto de componentes que se enumeran en XrSpatialCapabilityConfigurationBaseHeaderEXT ::enabledComponents para las capacidades compatibles con la proyección de rayos configuradas para spatialContext . El entorno de ejecución debe incluir los datos de todos los componentes habilitados de las capacidades compatibles con el trazado de rayos configuradas para spatialContext .

Uso válido (implícito)

Códigos de retorno

Listo

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Falla

  • 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_COMPONENT_NOT_ENABLED_EXT
  • XR_ERROR_TIME_INVALID
  • XR_ERROR_VALIDATION_FAILURE

La estructura XrSpatialRaycastSnapshotCreateInfoANDROID se define de la siguiente manera:

typedef struct XrSpatialRaycastSnapshotCreateInfoANDROID {
    XrStructureType                       type;
    const void*                           next;
    uint32_t                              componentTypeCount;
    const XrSpatialComponentTypeEXT*      componentTypes;
    const XrSpatialRaycastInfoANDROID*    raycastInfo;
} XrSpatialRaycastSnapshotCreateInfoANDROID;

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.
  • componentTypeCount es un uint32_t que describe el recuento de elementos en el array componentTypes.
  • componentTypes es un array de XrSpatialComponentTypeEXT .
  • raycastInfo es la estructura XrSpatialRaycastInfoANDROID que describe la información de un rayo.

Uso válido (implícito)

Ejemplo de código

Configura la capacidad de seguimiento de planos y de Raycast de profundidad

En el siguiente código de ejemplo, se muestra cómo crear un contexto espacial con capacidades que admiten la funcionalidad de raycast. En este ejemplo, se usan XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID y XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT.

// Check runtime supported capabilities
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_DEPTH_RAYCAST_ANDROID) == capabilities.end()) {
  return;
}

if (std::find(capabilities.begin(), capabilities.end(), XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT) == capabilities.end()) {
  return;
}

// Create capability config for depth raycasting
std::vector<XrSpatialComponentTypeEXT> depthRaycastComponents {
  XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID
};

// Create capability config for depth raycasting
XrSpatialCapabilityConfigurationDepthRaycastANDROID depthRaycastConfig {
  .type = XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_DEPTH_RAYCAST_ANDROID,
  .next = nullptr,
  .capability = XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID,
  .enabledComponentCount = (uint32_t)depthRaycastComponents.size(),
  .enabledComponents = depthRaycastComponents.data(),
};

// Enumerate runtime supported components for plane tracking capability
XrSpatialCapabilityComponentTypesEXT capabilityComponentTypes {
  XR_TYPE_SPATIAL_CAPABILITY_COMPONENT_TYPES_EXT
};

bool isRaycastSupportedViaPlaneTracking;
std::vector<XrSpatialComponentTypeEXT> planeTrackingComponents {
  XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT,
  XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT,
};

CHK_XR(xrEnumerateSpatialCapabilityComponentTypesEXT(instance, systemId,
       XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT, &capabilityComponentTypes));

planeTrackingComponents.resize(capabilityComponentTypes.componentTypeCountOutput);
capabilityComponentTypes.componentTypeCapacityInput = (uint32_t)planeTrackingComponents.size();
capabilityComponentTypes.componentTypes = planeTrackingComponents.data();

CHK_XR(xrEnumerateSpatialCapabilityComponentTypesEXT(instance, systemId,
       XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT, &capabilityComponentTypes));

// Check if raycast is supported by plane tracking
isRaycastSupportedViaPlaneTracking = std::find(planeTrackingComponents.begin(),
planeTrackingComponents.end(), XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID)
!= planeTrackingComponents.end();

// Create capability config for plane tracking
XrSpatialCapabilityConfigurationPlaneTrackingEXT planeTrackingConfig {
  .type = XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_PLANE_TRACKING_EXT,
  .next = nullptr,
  .capability = XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT,
  .enabledComponentCount = (uint32_t)planeTrackingComponents.size(),
  .enabledComponents = planeTrackingComponents.data(),
};

// Create spatial context
// Types of raycast is determined by configs included in XrSpatialContextCreateInfoEXT
// For this example, both plane raycast & depth raycast are performed
std::vector<const XrSpatialCapabilityConfigurationBaseHeaderEXT*> capabilityConfigs;
capabilityConfigs.push_back(reinterpret_cast<const XrSpatialCapabilityConfigurationBaseHeaderEXT*>(&depthRaycastConfig));
if(isRaycastSupportedViaPlaneTracking) capabilityConfigs.push_back(reinterpret_cast<const XrSpatialCapabilityConfigurationBaseHeaderEXT*>(&planeTrackingConfig));

XrSpatialContextCreateInfoEXT contextCreateInfo {
  .type = XR_TYPE_SPATIAL_CONTEXT_CREATE_INFO_EXT,
  .next = nullptr,
  .capabilityConfigCount = (uint32_t)capabilityConfigs.size(),
  .capabilityConfigs = capabilityConfigs.data(),
};

CHK_XR(xrCreateSpatialContextAsyncEXT(session, &contextCreateInfo, &future))

// Completes creating spatial context
XrCreateSpatialContextCompletionEXT contextCompletion{
XR_TYPE_CREATE_SPATIAL_CONTEXT_COMPLETION_EXT};

CHK_XR(xrCreateSpatialContextCompleteEXT(session, future, &contextCompletion))

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_DEPTH_RAYCAST_ANDROID y XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT, y consultar sus datos de componentes.

// Fill in the raycast info.
XrSpatialRaycastInfoANDROID raycastInfo {
  .type        = XR_TYPE_SPATIAL_RAYCAST_INFO_ANDROID,
  .next        = nullptr,
  .space       = viewSpace,
  .time        = updateTime,
  .origin      = {0.0f, 0.0f, 0.0f},
  .direction   = {0.0f, 0.0f,-1.0f},
  .maxDistance = 0.0f  // ray is unbounded
};

// Next pointing to the raycast info.
XrSpatialDiscoverySnapshotCreateInfoEXT discoverySnapshotCreateInfo {
  .type = XR_TYPE_SPATIAL_DISCOVERY_SNAPSHOT_CREATE_INFO_EXT,
  .next = &raycastInfo
};

// Create snapshot
CHK_XR(xrCreateSpatialDiscoverySnapshotAsyncEXT (
spatialContext, &discoverySnapshotCreateInfo, &future));

waitUntilReady(future);

// Complete async operation.
XrCreateSpatialDiscoverySnapshotCompletionInfoEXT
  createSnapshotCompletionInfo {
    .type      = XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_INFO_EXT,
    .baseSpace = viewSpace,
    .time      = updateTime,
    .future    = future,
  };

XrCreateSpatialDiscoverySnapshotCompletionEXT completion {
  XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_EXT};

CHK_XR(xrCreateSpatialDiscoverySnapshotCompleteEXT(
           spatialContext, &createSnapshotCompletionInfo,
           &completion));

if(completion.futureResult != XR_SUCCESS) return;

// Query hit result components
std::array<XrSpatialComponentTypeEXT, 1> enabledComponents = {
  XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID
};

XrSpatialComponentDataQueryConditionEXT queryCond {
  .type = XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_CONDITION_EXT,
  .componentTypeCount = 1,
  .componentTypes     = enabledComponents.data(),
};

XrSpatialComponentDataQueryResultEXT queryResult {
  .type = XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_RESULT_EXT,
};

XrResult result = xrQuerySpatialComponentDataEXT(
           completion.snapshot, &queryCond, &queryResult);

// Check query result.
if(result != XR_SUCCESS) return;

// Query again for the hit result list.
std::vector<XrSpatialRaycastResultDataANDROID> raycastResults;
raycastResults.resize(queryResult.entityIdCountOutput);
XrSpatialComponentRaycastResultListANDROID raycastResultList {
  .type               = XR_TYPE_SPATIAL_COMPONENT_RAYCAST_RESULT_LIST_ANDROID,
  .raycastResultCount = (uint32_t)raycastResults.size(),
  .raycastResults     = raycastResults.data(),
};

queryResult.next = &raycastResultList;
result = xrQuerySpatialComponentDataEXT(completion.snapshot, &queryCond, &queryResult);

// Check query result again.
if(result != XR_SUCCESS) return;

std::vector<XrSpatialEntityEXT> hitEntities;
std::vector<XrPosef> depthHitPoses;
for(uint32_t i = 0; i < queryResult.entityIdCountOutput; ++i) {
    // access raycastResults[i] for id & pose
    XrSpatialEntityIdEXT   id   = queryResult.entityIds[i];
    XrPosef                pose = raycastResults[i].hitPose;

    if (id != XR_NULL_SPATIAL_ENTITY_ID_EXT) {
        // hit entities (e.g. planes)
    // get entity handle via entity id
    XrSpatialEntityFromIdCreateInfoEXT entityCreateInfo {
      .type = XR_TYPE_SPATIAL_ENTITY_FROM_ID_CREATE_INFO_EXT,
      .entityId = id,
    };

    XrSpatialEntityEXT entity = XR_NULL_HANDLE;
    xrCreateSpatialEntityFromIdEXT(spatialContext, &entityCreateInfo, &entity);

    hitEntities.push_back(entity);
  } else {
    // hit depth
    depthHitPoses.push_back(pose);
  }
}

// Cleanup
xrDestroySpatialSnapshotEXT(completion.snapshot);

Crea una instantánea de Raycast

En el siguiente código de ejemplo, se muestra cómo crear una instantánea de raycast síncrona.

// fill in create info
XrSpatialRaycastSnapshotCreateInfoANDROID createInfo {
  .type = XR_TYPE_SPATIAL_RAYCAST_SNAPSHOT_CREATE_INFO_ANDROID,
  .componentTypeCount = 0,   // include all hit spatial entities
  .componentTypes = nullptr,
  .raycastInfo = &raycastInfo
};

// create raycast snapshot
XrSpatialSnapshotEXT raycastSnapshot = XR_NULL_HANDLE;
CHK_XR(xrCreateSpatialRaycastSnapshotANDROID(
  spatialContext, &createInfo, &raycastSnapshot));

// ...
// query component data as previous example
// ...

// Cleanup
xrDestroySpatialSnapshotEXT(raycastSnapshot);

Comandos nuevos

Estructuras nuevas

Nuevas constantes de enum

  • XR_ANDROID_SPATIAL_DISCOVERY_RAYCAST_EXTENSION_NAME
  • XR_ANDROID_spatial_discovery_raycast_SPEC_VERSION

  • Extiende XrSpatialCapabilityEXT :

    • XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID

  • Extiende XrSpatialComponentTypeEXT :

    • XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID

  • Extiende XrStructureType :

    • XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_DEPTH_RAYCAST_ANDROID
    • XR_TYPE_SPATIAL_COMPONENT_RAYCAST_RESULT_LIST_ANDROID
    • XR_TYPE_SPATIAL_RAYCAST_INFO_ANDROID
    • XR_TYPE_SPATIAL_RAYCAST_SNAPSHOT_CREATE_INFO_ANDROID

Problemas

Historial de versiones

  • Revisión 1, 15 de julio de 2025 (Brian Chen)

    • Descripción inicial de la extensión.