XR_ANDROID_spatial_discovery_raycast

Cadena de nombre

XR_ANDROID_spatial_discovery_raycast

Tipo de extensión

Extensión de instancia

Número de extensión registrada

787

Revisión

1

Estado de ratificación

No ratificado

Dependencias de extensión y versión

XR_EXT_spatial_entity

Fecha de modificación más reciente

12/8/2025

Estado de IP

No se conocen reclamos de IP.

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 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 capacidad espacial para el raycasting en el búfer de profundidad.

Permisos

Permisos obligatorios según las capacidades que usa 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 necesita solicitar ambos permisos por separado.

android.permission.SCENE_UNDERSTANDING_COARSE y 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 del raycasting, debe indicarlo enumerando XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID en xrEnumerateSpatialCapabilityComponentTypesEXT para las capacidades que admiten el descubrimiento por raycast.

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

Descubre entidades espaciales mediante el raycasting

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 miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructura.
  • space es el XrSpace en el que se ubicará la postura de XrSpatialRaycastResultDataANDROID.
  • time es un XrTime en el que se define la postura 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 , junto con 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 mostrar XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT desde xrCreateSpatialDiscoverySnapshotAsyncEXT o xrCreateSpatialRaycastSnapshotANDROID .

El entorno de ejecución debe incluir los datos y los IDs de los componentes de solo esas entidades espaciales en 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 alcanzada en la instantánea que esté a más de maxDistance del 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 que el rayo no está delimitado.

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 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 XrSpatialRaycastInfoANDROID se incluye 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 mostrar XR_ERROR_VALIDATION_FAILURE desde 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 proporcionadas por 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 de 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 alcanzada, y el eje Y negativo apunta aproximadamente hacia el origen del rayo.

Uso válido (implícito)

Struct de 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 miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructura.
  • 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 mostrar XR_ERROR_VALIDATION_FAILURE desde 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 mostrar XR_ERROR_SIZE_INSUFFICIENT desde xrQuerySpatialComponentDataEXT si raycastResultCount es menor que XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput .

Los raycastResults que se muestran 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 enum 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 mostrar XR_ERROR_VALIDATION_FAILURE desde 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 miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructura.
  • 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 mostrar 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 capacidad 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 admite XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID , debe admitir los siguientes componentes espaciales como componentes garantizados de las entidades descubiertas por esta capacidad 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 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 raycasting 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 mostrar 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 raycast configuradas para spatialContext . El entorno de ejecución debe incluir los datos de todos los componentes habilitados de las capacidades compatibles con raycast 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 miembros

  • type es el XrStructureType de esta estructura.
  • next es NULL o un puntero a la siguiente estructura en una cadena de estructura. No se definen esas estructuras en el núcleo de OpenXR 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 raycast de profundidad y seguimiento de planos

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

Constantes de enum nuevas

  • XR_ANDROID_SPATIAL_DISCOVERY_RAYCAST_EXTENSION_NAME
  • XR_ANDROID_spatial_discovery_raycast_SPEC_VERSION

  • Extensión de XrSpatialCapabilityEXT :

    • XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID

  • Extensión de XrSpatialComponentTypeEXT :

    • XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID

  • Extensión de 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/7/2025 (Brian Chen)

    • Descripción inicial de la extensión