XR_ANDROID_spatial_discovery_raycast

Name String

XR_ANDROID_spatial_discovery_raycast

Tipo di estensione

Estensione dell'istanza

Numero di interno registrato

787

Revisione

1

Stato della ratifica

Non ratificato

Dipendenze di estensioni e versioni

XR_EXT_spatial_entity

Data ultima modifica

2025-08-12

Stato IP

Nessuna rivendicazione di PI nota.

Collaboratori

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

Panoramica

Questa estensione si basa su XR_EXT_spatial_entity e fornisce funzionalità di raycast per le funzionalità spaziali esistenti, come XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT , per rilevare entità spaziali.

Questa estensione introduce anche una nuova funzionalità spaziale per il raycasting rispetto al buffer di profondità.

Autorizzazioni

Autorizzazioni richieste in base alle funzionalità utilizzate dall'app per Android. Se viene utilizzato XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID, l'applicazione deve disporre dell'autorizzazione android.permission.SCENE_UNDERSTANDING_FINE. Se viene utilizzato XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT, l'applicazione deve avere l'autorizzazione android.permission.SCENE_UNDERSTANDING_COARSE. L'autorizzazione android.permission.SCENE_UNDERSTANDING_FINE implica anche l'autorizzazione android.permission.SCENE_UNDERSTANDING_COARSE. Se l'applicazione utilizza entrambe le funzionalità, non è necessario richiedere entrambe le autorizzazioni separatamente.

Sia android.permission.SCENE_UNDERSTANDING_COARSE sia android.permission.SCENE_UNDERSTANDING_FINE sono considerate autorizzazioni pericolose.

(livello di protezione: pericoloso)

Supporto di runtime

Se il runtime supporta il rilevamento di entità spaziali tramite raycasting, deve indicarlo enumerando XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID in xrEnumerateSpatialCapabilityComponentTypesEXT per le funzionalità che supportano il rilevamento tramite raycast.

Se il runtime supporta il raycasting rispetto al buffer di profondità, deve enumerare XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID in xrEnumerateSpatialCapabilitiesEXT .

Scopri le entità spaziali tramite raycasting

La struttura XrSpatialRaycastInfoANDROID è definita come:

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

Descrizioni dei membri

  • type è l'XrStructureType di questa struttura.
  • next è NULL o un puntatore alla struttura successiva in una catena di strutture.
  • space è l'XrSpace in cui si troverà la posa di XrSpatialRaycastResultDataANDROID.
  • time è un XrTime in cui è definita la posa di XrSpatialRaycastResultDataANDROID.
  • origin è un XrVector3f che descrive l'origine del raggio.
  • direction è un XrVector3f che descrive la direzione del raggio.
  • maxDistance è la distanza in metri che l'applicazione può facoltativamente specificare per limitare il rilevamento delle entità che si trovano entro la distanza specificata da origin , lungo direction .

Un'applicazione può includere XrSpatialRaycastInfoANDROID nella catena XrSpatialDiscoverySnapshotCreateInfoEXT :: next per rilevare le entità spaziali che si intersecano con il raggio definito in questa struttura.

Se un'applicazione utilizza XrSpatialRaycastInfoANDROID con un XrSpatialContextEXT configurato senza attivare XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID per nessuna funzionalità, il runtime deve restituire XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT da xrCreateSpatialDiscoverySnapshotAsyncEXT o xrCreateSpatialRaycastSnapshotANDROID .

Il runtime deve includere i dati e gli ID dei componenti solo delle entità spaziali in XrSpatialSnapshotEXT che provengono da funzionalità che supportano il componente XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID.

Se un'applicazione imposta maxDistance su un valore positivo, il runtime non deve includere nello snapshot entità spaziali colpite che si trovano a una distanza superiore a maxDistance da panme:origin lungo direction . Se maxDistance è impostato su 0 o su un valore negativo, il runtime deve considerare il raggio come illimitato.

Utilizzo valido (implicito)

Componente del risultato del raycast

La struttura XrSpatialRaycastResultDataANDROID è definita come:

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

Descrizioni dei membri

  • hitPose è un XrPosef che definisce il punto in cui il raggio interseca l'entità spaziale.
  • distanceSquared è il quadrato della distanza dall'origine del raggio al punto di intersezione.

Il componente XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID sarà presente solo in un XrSpatialSnapshotEXT creato da xrCreateSpatialDiscoverySnapshotAsyncEXT in cui XrSpatialRaycastInfoANDROID è incluso nella catena XrSpatialDiscoverySnapshotCreateInfoEXT :: next o in un XrSpatialSnapshotEXT creato da xrCreateSpatialRaycastSnapshotANDROID .

Il runtime non deve includere questo componente in nessun XrSpatialSnapshotEXT creato utilizzando xrCreateSpatialUpdateSnapshotEXT .

Il runtime deve restituire XR_ERROR_VALIDATION_FAILURE da xrCreateSpatialUpdateSnapshotEXT se l'applicazione include XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID in XrSpatialUpdateSnapshotCreateInfoEXT :: componentTypes .

Se XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID è abilitato solo per determinate funzionalità, il runtime deve includere nello snapshot solo le entità spaziali fornite da queste funzionalità. Ad esempio, se un oggetto e un aereo sono allineati nella stessa direzione e XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID è abilitato solo per XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT , verrà rilevato solo l'aereo.

Il hitPose del XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID si troverà in XrCreateSpatialDiscoverySnapshotCompletionInfoEXT :: baseSpace in XrCreateSpatialDiscoverySnapshotCompletionInfoEXT :: time . L'asse Z positivo è la normale della superficie di impatto, mentre l'asse Y negativo punta approssimativamente verso l'origine del raggio.

Utilizzo valido (implicito)

Struttura dell'elenco dei componenti per eseguire query sui dati

La struttura XrSpatialComponentRaycastResultListANDROID è definita come:

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

Descrizioni dei membri

  • type è l'XrStructureType di questa struttura.
  • next è NULL o un puntatore alla struttura successiva in una catena di strutture.
  • raycastResultCount è un uint32_t che descrive il conteggio degli elementi nell'array raycastResults.
  • raycastResults è un array di XrSpatialRaycastResultDataANDROID .

Per eseguire una query sul componente del risultato del raycast delle entità spaziali in un XrSpatialSnapshotEXT , includi XR_TYPE_SPATIAL_COMPONENT_RAYCAST_RESULT_LIST_ANDROID in XrSpatialComponentDataQueryConditionEXT :: componentTypes e aggiungi XrSpatialComponentRaycastResultListANDROID alla catena XrSpatialComponentDataQueryResultEXT :: next.

Il runtime deve restituire XR_ERROR_VALIDATION_FAILURE da xrQuerySpatialComponentDataEXT se XrSpatialComponentRaycastResultListANDROID si trova nella catena XrSpatialComponentDataQueryResultEXT :: next, ma XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID non è incluso in XrSpatialComponentDataQueryConditionEXT :: componentTypes .

Il runtime deve restituire XR_ERROR_SIZE_INSUFFICIENT da xrQuerySpatialComponentDataEXT se raycastResultCount è inferiore a XrSpatialComponentDataQueryResultEXT :: entityIdCountOutput .

I raycastResults restituiti non sono ordinati. Un'applicazione può utilizzare XrSpatialRaycastResultDataANDROID :: distanceSquared per ordinare i risultati in base alla distanza.

Utilizzo valido (implicito)

Configurazione

Se XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID è enumerato in XrSpatialCapabilityComponentTypesEXT :: componentTypes per una funzionalità, l'applicazione può attivarla includendo il valore dell'enum nell'elenco XrSpatialCapabilityConfigurationBaseHeaderEXT :: enabledComponents. Questo componente non richiede alcuna configurazione speciale per essere incluso nella catena successiva di XrSpatialCapabilityConfigurationBaseHeaderEXT .

Il runtime deve restituire XR_ERROR_VALIDATION_FAILURE da xrCreateSpatialUpdateSnapshotEXT se l'applicazione include XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID in XrSpatialUpdateSnapshotCreateInfoEXT :: componentTypes . Questo componente è specifico per gli snapshot di discovery.

Funzionalità spaziale di raycast di profondità

Configurazione

La struttura XrSpatialCapabilityConfigurationDepthRaycastANDROID è definita come:

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

Descrizioni dei membri

  • type è l'XrStructureType di questa struttura.
  • next è NULL o un puntatore alla struttura successiva in una catena di strutture.
  • capability è un XrSpatialCapabilityEXT e deve essere XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID .
  • enabledComponentCount è un uint32_t che descrive il conteggio degli elementi nell'array enabledComponents. Deve essere maggiore di 0.
  • enabledComponents è un puntatore a un array di XrSpatialComponentTypeEXT .

Le applicazioni possono attivare la funzionalità spaziale XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID includendo un puntatore a una struttura XrSpatialCapabilityConfigurationDepthRaycastANDROID in XrSpatialContextCreateInfoEXT :: capabilityConfigs .

Il runtime deve restituire XR_ERROR_VALIDATION_FAILURE se capability non è XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID .

L'ID delle entità rilevate tramite questa funzionalità è sempre XR_NULL_SPATIAL_ENTITY_ID_EXT . Ciò significa anche che l'applicazione non può creare un handle XrSpatialEntityEXT per queste entità, pertanto non possono essere incluse in XrSpatialUpdateSnapshotCreateInfoEXT :: entities per creare uno snapshot di aggiornamento

Utilizzo valido (implicito)

Componenti garantiti

Un runtime che supporta XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID deve supportare i seguenti componenti spaziali come componenti garantiti delle entità rilevate da questa funzionalità e deve enumerarli in xrEnumerateSpatialCapabilityComponentTypesEXT:

  • XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID

Raycast sincrono

La funzione xrCreateSpatialRaycastSnapshotANDROID è definita come:

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

Descrizioni dei parametri

Sebbene xrCreateSpatialDiscoverySnapshotAsyncEXT sia sufficiente per la maggior parte dei casi d'uso, è considerato lento per le applicazioni che richiedono risultati di raycast istantanei. xrCreateSpatialRaycastSnapshotANDROID avvia un raycasting sincrono per creare uno snapshot, il che consente alle applicazioni di iniziare immediatamente a eseguire query sui risultati del raycast.

Il runtime deve restituire XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT se uno dei XrSpatialComponentTypeEXT in XrSpatialRaycastSnapshotCreateInfoANDROID :: componentTypes non è abilitato per le funzionalità spaziali passate a XrSpatialContextCreateInfoEXT :: capabilityConfigs durante la creazione di spatialContext .

Se l'applicazione non fornisce un elenco di tipi di componenti spaziali in XrSpatialRaycastSnapshotCreateInfoANDROID :: componentTypes , il runtime deve includere nello snapshot tutte le entità spaziali che hanno l'insieme di componenti enumerati in XrSpatialCapabilityConfigurationBaseHeaderEXT ::enabledComponents per le funzionalità supportate dal raycast configurate per spatialContext . Il runtime deve includere i dati per tutti i componenti abilitati delle funzionalità supportate dal raycast configurate per spatialContext .

Utilizzo valido (implicito)

Codici di risposta

Operazione riuscita

  • XR_SUCCESS
  • XR_SESSION_LOSS_PENDING

Errore

  • 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 struttura XrSpatialRaycastSnapshotCreateInfoANDROID è definita come:

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

Descrizioni dei membri

  • type è l'XrStructureType di questa struttura.
  • next è NULL o un puntatore alla struttura successiva in una catena di strutture. Nessuna struttura di questo tipo è definita in OpenXR di base o in questa estensione.
  • componentTypeCount è un uint32_t che descrive il conteggio degli elementi nell'array componentTypes.
  • componentTypes è un array di XrSpatialComponentTypeEXT .
  • raycastInfo è la struttura XrSpatialRaycastInfoANDROID che descrive le informazioni di un raggio.

Utilizzo valido (implicito)

Esempio di codice

Configura la funzionalità di raycast di profondità e tracciamento dei piani

Il seguente codice di esempio mostra come creare un contesto spaziale con funzionalità che supportano la funzionalità di raycast. Per questo esempio, vengono utilizzati XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID e 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))

Scopri le entità spaziali ed esegui query sui dati dei componenti

Il seguente codice di esempio mostra come rilevare entità spaziali per un contesto configurato con XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID e XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT ed eseguire query sui dati dei relativi componenti.

// 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 snapshot Raycast

Il seguente codice di esempio mostra come creare uno snapshot di raycast sincrono.

// 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);

Nuovi comandi

Nuove strutture

Nuove costanti enum

  • XR_ANDROID_SPATIAL_DISCOVERY_RAYCAST_EXTENSION_NAME
  • XR_ANDROID_spatial_discovery_raycast_SPEC_VERSION

  • Estensione di XrSpatialCapabilityEXT :

    • XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID

  • Estensione di XrSpatialComponentTypeEXT :

    • XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID

  • Estensione di 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

Problemi

Cronologia delle versioni

  • Revisione 1, 15/07/2025 (Brian Chen)

    • Descrizione iniziale dell'estensione.