XR_ANDROID_spatial_discovery_raycast

Stringa del nome

XR_ANDROID_spatial_discovery_raycast

Tipo di estensione

Estensione dell'istanza

Numero di estensione registrato

787

Revisione

1

Stato di ratifica

Non ratificato

Dipendenze di estensione e versione

XR_EXT_spatial_entity

Data ultima modifica

2025-08-12

Stato IP

Nessuna rivendicazione IP 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 scoprire le entità spaziali.

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

Autorizzazioni

Autorizzazioni richieste a seconda delle funzionalità utilizzate dall'app per Android. Se viene utilizzato XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID, l'applicazione deve avere l'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 le due autorizzazioni separatamente.

android.permission.SCENE_UNDERSTANDING_COARSE e android.permission.SCENE_UNDERSTANDING_FINE sono considerate autorizzazioni pericolose.

(livello di protezione: pericoloso)

Supporto di runtime

Se il runtime supporta l'individuazione delle entità spaziali tramite raycasting, deve indicarlo enumerando XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID in xrEnumerateSpatialCapabilityComponentTypesEXT per le funzionalità che supportano l'individuazione tramite raycast.

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

Individuare le entità spaziali tramite raycasting

La struttura XrSpatialRaycastInfoANDROID è definita come segue:

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ò specificare facoltativamente per limitare l'individuazione delle entità che si trovano entro la distanza specificata dall' origin , lungo direction .

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

Se un'applicazione utilizza XrSpatialRaycastInfoANDROID con un XrSpatialContextEXT configurato senza abilitare XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID per qualsiasi 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 provenienti 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 le entità spaziali colpite che si trovano a una distanza superiore a maxDistance dall'origine del raggio lungo direction . Se maxDistance è impostato su 0 o su un valore negativo, il runtime deve considerare il raggio illimitato.

Utilizzo valido (implicito)

Componente del risultato del raycast

La struttura XrSpatialRaycastResultDataANDROID è definita come segue:

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 next di XrSpatialDiscoverySnapshotCreateInfoEXT o in un XrSpatialSnapshotEXT creato da xrCreateSpatialRaycastSnapshotANDROID .

Il runtime non deve includere questo componente in alcun 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 piano si allineano nella stessa direzione e XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID è abilitato solo per XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT , verrà rilevato solo il piano.

Il hitPose di XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID si troverà in XrCreateSpatialDiscoverySnapshotCompletionInfoEXT :: baseSpace in XrCreateSpatialDiscoverySnapshotCompletionInfoEXT :: time . L'asse Z positivo è la normale della superficie colpita e 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 segue:

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 numero di elementi nell'array raycastResults.
  • raycastResults è un array di XrSpatialRaycastResultDataANDROID .

Per eseguire 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 determinata funzionalità, l'applicazione può abilitarlo includendo il valore 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 individuazione.

Funzionalità spaziale di raycast di profondità

Configurazione

La struttura XrSpatialCapabilityConfigurationDepthRaycastANDROID è definita come segue:

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 numero di elementi nell'array enabledComponents. Deve essere maggiore di 0.
  • enabledComponents è un puntatore a un array di XrSpatialComponentTypeEXT .

Le applicazioni possono abilitare 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à individuate 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à e, 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à individuate da questa funzionalità e deve enumerarli in xrEnumerateSpatialCapabilityComponentTypesEXT -

  • XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID

Raycast sincrono

La funzione xrCreateSpatialRaycastSnapshotANDROID è definita come segue:

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 immediati. xrCreateSpatialRaycastSnapshotANDROID avvia un raycasting sincrono per creare uno snapshot, 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 degli 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 il set di componenti enumerati in XrSpatialCapabilityConfigurationBaseHeaderEXT ::enabledComponents per le funzionalità supportate da raycast configurate per spatialContext . Il runtime deve includere i dati di tutti i componenti abilitati delle funzionalità supportate da raycast configurate per spatialContext .

Utilizzo valido (implicito)

Codici restituiti

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 segue:

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. Non sono definite strutture di questo tipo in OpenXR di base o in questa estensione.
  • componentTypeCount è un uint32_t che descrive il numero di 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

Configurare la funzionalità di raycast di profondità e di rilevamento del piano

Il seguente esempio di codice 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))

Individuare le entità spaziali ed eseguire query sui dati dei componenti

Il seguente esempio di codice mostra come individuare le 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 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);

Creare uno snapshot di raycast

Il seguente esempio di codice 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.