Estensione OpenXR XR_ANDROID_scene_meshing

Stringa del nome XR_ANDROID_scene_meshing

Tipo di estensione Estensione dell'istanza

Numero di interno registrato 464

Revisione 3

Dipendenze da estensioni e versioni OpenXR 1.0

Data ultima modifica 2025-05-15

Stato della proprietà intellettuale Nessuna rivendicazione della proprietà intellettuale nota.

Collaboratori Spencer Quin, Google Jared Finder, Google Antonio Fontan, Google Cairn Overturf, Google Nihav Jain, Google Salar Khan, Google Sebastian Klose, Google Jürgen Sturm, Google Vinny DaSilva, Google Ricardo Campbell, Google

Panoramica

Questa estensione ha lo scopo di fornire dati mesh per le mesh che rappresentano approssimativamente gli oggetti fisici nel tuo ambiente. Può essere utilizzato per visualizzare la scena in un'applicazione immersiva e permettere agli oggetti virtuali di interagire con gli oggetti fisici, ad esempio le collisioni.

Nota: i dati della mesh della scena vengono generati dal runtime e condivisi con l'applicazione utilizzando XrSceneMeshingTrackerANDROID e XrSceneMeshSnapshotANDROID. Le applicazioni possono accedere ai valori nelle informazioni sulle submesh della scena tramite XrSceneSubmeshStateANDROID restituito da xrGetAllSubmeshStatesANDROID. Le applicazioni possono accedere ai valori nei dati delle submesh della scena tramite XrSceneSubmeshDataANDROID restituito da xrGetSubmeshDataANDROID.

I dati di mesh della scena possono essere informazioni personali sensibili e sono strettamente collegati alla privacy e all'integrità personali. È consigliabile che le applicazioni che archiviano o trasferiscono dati di mesh della scena chiedano sempre all'utente un'accettazione attiva e specifica.

Autorizzazioni

Le applicazioni Android devono avere l'autorizzazione android.permission.SCENE_UNDERSTANDING_FINE elencata nel manifest. L'autorizzazione android.permission.SCENE_UNDERSTANDING_FINE è considerata un'autorizzazione sensibile in quanto consente al runtime di studiare l'ambiente utente.

L'applicazione deve richiedere l'autorizzazione in fase di runtime per utilizzare queste funzioni:

• xrCreateSceneMeshingTrackerANDROID
• xrDestroySceneMeshingTrackerANDROID
• xrCreateSceneMeshSnapshotANDROID
• xrDestroySceneMeshSnapshotANDROID
• xrGetAllSubmeshStatesANDROID
• xrGetSubmeshDataANDROID

(livello di protezione: pericoloso)

Ispezionare la funzionalità del sistema

Un'applicazione può verificare se il sistema è in grado di eseguire la mesh della scena concatenando una struttura XrSystemSceneMeshingPropertiesANDROID alla XrSystemProperties quando chiama xrGetSystemProperties.

XrSystemSceneMeshingPropertiesANDROID

typedef struct XrSystemSceneMeshingPropertiesANDROID {
    XrStructureType    type;
    void*              next;
    XrBool32           supportsSceneMeshing;
} XrSystemSceneMeshingPropertiesANDROID;

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.
• supportsSceneMeshing è un XrBool32, che indica se il sistema supporta la creazione di mesh della scena.

Se supportsSceneMeshing è XR_FALSE, il sistema non supporta la creazione di mesh della scena. L'applicazione deve evitare di utilizzare la funzionalità di mesh della scena quando supportsSceneMeshing è XR_FALSE, poiché le chiamate a xrCreateSceneMeshingTrackerANDROID non andranno a buon fine.

Se supportsSceneMeshing è XR_TRUE, il sistema supporta la creazione di mesh della scena.

Utilizzo valido (implicito)

• L'estensione XR_ANDROID_scene_meshing deve essere attivata prima di utilizzare XrSystemSceneMeshingPropertiesANDROID
• type deve essere XR_TYPE_SYSTEM_SCENE_MESHING_PROPERTIES_ANDROID
• next deve essere NULL o un puntatore valido alla struttura successiva in una catena di strutture

XrSceneMeshSemanticLabelSetANDROID

L'enumerazione XrSceneMeshSemanticLabelSetANDROID descrive gli insiemi di etichette semantiche per la mesh della scena. Ogni valore di questa enumerazione rappresenta un'altra enumerazione che contiene le etichette semantiche. Ad esempio, il valore XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT_ANDROID rappresenta il set XrSceneMeshSemanticLabelANDROID.

typedef enum XrSceneMeshSemanticLabelSetANDROID {
    XR_SCENE_MESH_SEMANTIC_LABEL_SET_NONE_ANDROID = 0,
    XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT_ANDROID = 1,
    XR_SCENE_MESH_SEMANTIC_LABEL_SET_MAX_ENUM_ANDROID = 0x7FFFFFFF
} XrSceneMeshSemanticLabelSetANDROID;

xrEnumerateSupportedSemanticLabelSetsANDROID

L'applicazione può ottenere set di etichette semantiche supportati dal sistema utilizzando la funzione xrEnumerateSupportedSemanticLabelSetsANDROID.

XrResult xrEnumerateSupportedSemanticLabelSetsANDROID(
    XrInstance                                  instance,
    XrSystemId                                  systemId,
    uint32_t                                    supportedSemanticLabelSetsInputCapacity,
    uint32_t*                                   supportedSemanticLabelSetsOutputCount,
    XrSceneMeshSemanticLabelSetANDROID*         supportedSemanticLabelSets);

Descrizioni dei parametri

• instance è un XrInstance creato dall'applicazione.
• systemId è un XrSystemId riprovato da xrGetSystem.
• supportedSemanticLabelSetsInputCapacity è la lunghezza di supportedSemanticLabelSets.
• supportedSemanticLabelSetsOutputCount è il numero di elementi in supportedSemanticLabelSets modificati dal runtime a partire dall'inizio dell'array.
• supportedSemanticLabelSets è un array di XrSceneMeshSemanticLabelSetANDROID in cui il runtime scrive gli insiemi di etichette semantiche supportati.

È previsto che ogni sistema supporti almeno XR_SCENE_MESH_SEMANTIC_LABEL_SET_NONE_ANDROID perché questo valore enum non rappresenta alcun insieme di etichette semantiche e può essere utilizzato nel caso in cui l'applicazione non necessiti della semantica dei vertici.

Crea un handle del tracker di mesh della scena

XrSceneMeshingTrackerANDROID

XR_DEFINE_HANDLE(XrSceneMeshingTrackerANDROID)

L'handle XrSceneMeshingTrackerANDROID rappresenta un tracker di mesh della scena per la mesh della scena e la gestione delle risorse correlate.

Questo handle può essere utilizzato per creare uno snapshot della mesh della scena utilizzando xrCreateSceneMeshSnapshotANDROID in questa estensione.

xrCreateSceneMeshingTrackerANDROID

Un'applicazione può creare un handle XrSceneMeshingTrackerANDROID utilizzando la funzione xrCreateSceneMeshingTrackerANDROID.

XrResult xrCreateSceneMeshingTrackerANDROID(
    XrSession                                   session,
    const XrSceneMeshingTrackerCreateInfoANDROID* createInfo,
    XrSceneMeshingTrackerANDROID*               tracker);

Descrizioni dei parametri

• session è una XrSession in cui il tracker di mesh della scena sarà attivo.
• createInfo è un puntatore a una struttura XrSceneMeshingTrackerCreateInfoANDROID utilizzata per descrivere il tracker di mesh della scena da creare.
• tracker è l'handle XrSceneMeshingTrackerANDROID restituito.

Se il sistema non supporta la mesh della scena, xrCreateSceneMeshingTrackerANDROID restituirà XR_ERROR_FEATURE_UNSUPPORTED. L'applicazione può verificare il supporto del sistema chiamando xrGetSystemProperties con la struttura XrSystemSceneMeshingPropertiesANDROID.

Solo i set di etichette semantiche supportati dal sistema possono essere utilizzati in XrSceneMeshingTrackerCreateInfoANDROID::semanticLabelSet durante la creazione di un tracker di mesh della scena. La funzione xrEnumerateSupportedSemanticLabelSetsANDROID può essere utilizzata per ottenere l'elenco dei set di etichette semantiche supportati.

Se l'applicazione richiede un semanticLabelSet non supportato, xrCreateSceneMeshingTrackerANDROID restituirà XR_ERROR_FEATURE_UNSUPPORTED.

L'handle xrCreateSceneMeshingTrackerANDROID possiede tutte le risorse per la mesh della scena. Al termine dell'esperienza di mesh della scena, l'applicazione deve eliminare l'handle tramite la funzione xrDestroySceneMeshingTrackerANDROID.

XrSceneMeshingTrackerCreateInfoANDROID

La struttura XrSceneMeshingTrackerCreateInfoANDROID descrive le informazioni per creare un handle XrSceneMeshingTrackerANDROID.

typedef struct XrSceneMeshingTrackerCreateInfoANDROID {
    XrStructureType                       type;
    const void*                           next;
    XrSceneMeshSemanticLabelSetANDROID    semanticLabelSet;
    XrBool32                              enableNormals;
} XrSceneMeshingTrackerCreateInfoANDROID;

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.
• semanticLabelSet è un XrSceneMeshSemanticLabelSetANDROID utilizzato per specificare il set di etichette semantiche da utilizzare per la creazione della mesh della scena. Se questo valore è impostato su XR_SCENE_MESH_SEMANTIC_LABEL_SET_NONE_ANDROID, il runtime ignorerà il campo buffer XrSceneSubmeshDataANDROID::vertexSemantics.
• enableNormals è un XrBool32 utilizzato per specificare se includere le normali dei vertici per i vertici della mesh nel buffer della mesh della scena quando si recuperano i dati della mesh della scena.

xrDestroySceneMeshingTrackerANDROID

La funzione xrDestroySceneMeshingTrackerANDROID rilascia tracker e le risorse sottostanti al termine delle esperienze di mesh della scena.

XrResult xrDestroySceneMeshingTrackerANDROID(
    XrSceneMeshingTrackerANDROID          tracker);

Descrizioni dei parametri

• tracker è un XrSceneMeshingTrackerANDROID creato in precedenza da xrCreateSceneMeshingTrackerANDROID.

Crea un handle dello snapshot della mesh della scena

XrSceneMeshSnapshotANDROID

XR_DEFINE_HANDLE(XrSceneMeshSnapshotANDROID)

L'handle XrSceneMeshSnapshotANDROID rappresenta uno snapshot della mesh della scena. Viene creato utilizzando xrCreateSceneMeshSnapshotANDROID che essenzialmente acquisisce uno snapshot dei dati della mesh della scena al momento della chiamata di funzione.

Questo handle può essere utilizzato per recuperare informazioni e dati sulle submesh utilizzando xrGetAllSubmeshStatesANDROID e xrGetSubmeshDataANDROID.

XrSceneMeshSnapshotCreateInfoANDROID

La struttura XrSceneMeshSnapshotCreateInfoANDROID descrive le informazioni per creare un handle XrSceneMeshSnapshotANDROID

typedef struct XrSceneMeshSnapshotCreateInfoANDROID {
    XrStructureType    type;
    const void*        next;
    XrSpace            baseSpace;
    XrTime             time;
    XrBoxf             boundingBox;
} XrSceneMeshSnapshotCreateInfoANDROID;

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.
• baseSpace è uno spazio XrSpace utilizzato per descrivere lo spazio di riferimento in cui deve essere rappresentata la posa delle submesh della scena.
• time è l'XrTime che descrive il momento in cui la mesh della scena verrà elaborata o visualizzata.
• boundingBox è un XrBoxf che descrive il riquadro di delimitazione all'interno del quale acquisire la mesh della scena.

XrSceneMeshTrackingStateANDROID

L'enumerazione XrSceneMeshTrackingStateANDROID descrive lo stato di monitoraggio del tracker di mesh della scena. Ogni valore di questa enumerazione rappresenta uno stato del tracker di meshing della scena. Questo enum racchiuso nella struttura XrSceneMeshSnapshotCreationResultANDROID restituita da xrCreateSceneMeshSnapshotANDROID.

typedef enum XrSceneMeshTrackingStateANDROID {
    XR_SCENE_MESH_TRACKING_STATE_INITIALIZING_ANDROID = 0,
    XR_SCENE_MESH_TRACKING_STATE_TRACKING_ANDROID = 1,
    XR_SCENE_MESH_TRACKING_STATE_WAITING_ANDROID = 2,
    XR_SCENE_MESH_TRACKING_STATE_ERROR_ANDROID = 3,
    XR_SCENE_MESH_TRACKING_STATE_MAX_ENUM_ANDROID = 0x7FFFFFFF
} XrSceneMeshTrackingStateANDROID;

XrSceneMeshSnapshotCreationResultANDROID

La struttura XrSceneMeshSnapshotCreationResultANDROID memorizza il risultato della creazione di uno snapshot della mesh della scena restituito da xrCreateSceneMeshSnapshotANDROID. Il risultato include l'handle dello snapshot e lo stato di monitoraggio del tracker di mesh della scena al momento della creazione dello snapshot.

typedef struct XrSceneMeshSnapshotCreationResultANDROID {
    XrStructureType                  type;
    void*                            next;
    XrSceneMeshSnapshotANDROID       snapshot;
    XrSceneMeshTrackingStateANDROID    trackingState;
} XrSceneMeshSnapshotCreationResultANDROID;

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.
• snapshot è un handle XrSceneMeshSnapshotANDROID creato dal runtime.
• trackingState è un XrSceneMeshTrackingStateANDROID che descrive lo stato del tracker di meshing della scena al momento della creazione dello snapshot.

xrCreateSceneMeshSnapshotANDROID

L'applicazione può utilizzare la funzione xrCreateSceneMeshSnapshotANDROID per creare uno snapshot della mesh della scena dal tracker di meshing della scena. Questa funzione restituisce un handle XrSceneMeshSnapshotANDROID insieme a XrSceneMeshTrackingStateANDROID racchiuso in una struttura XrSceneMeshSnapshotCreationResultANDROID. L'handle è tecnicamente un'istantanea dei dati della mesh della scena al momento della creazione. Questo handle può essere utilizzato per eseguire query sulle informazioni e sui dati della mesh della scena utilizzando xrGetAllSubmeshStatesANDROID e xrGetSubmeshDataANDROID rispettivamente.

XrResult xrCreateSceneMeshSnapshotANDROID(
    XrSceneMeshingTrackerANDROID                tracker,
    const XrSceneMeshSnapshotCreateInfoANDROID* createInfo,
    XrSceneMeshSnapshotCreationResultANDROID*   outSnapshotCreationResult);

Descrizioni dei parametri

• tracker è un handle XrSceneMeshingTrackerANDROID creato in precedenza con xrCreateSceneMeshingTrackerANDROID.
• createInfo è un puntatore a una struttura XrSceneMeshSnapshotCreateInfoANDROID che contiene le informazioni necessarie per creare lo snapshot della mesh della scena.
• outSnapshotCreationResult è un puntatore a un oggetto XrSceneMeshSnapshotCreationResultANDROID che viene compilato dal runtime con il risultato della creazione dello snapshot.

Acquisizione dei dati della mesh della scena dallo snapshot della mesh della scena

XrSceneSubmeshStateANDROID

XrSceneSubmeshStateANDROID descrive una submesh. Contiene le informazioni di base sulla submesh (ID, posa, limiti, ora dell'ultimo aggiornamento).

typedef struct XrSceneSubmeshStateANDROID {
    XrStructureType    type;
    void*              next;
    XrUuid             submeshId;
    XrTime             lastUpdatedTime;
    XrPosef            submeshPoseInBaseSpace;
    XrExtent3Df        bounds;
} XrSceneSubmeshStateANDROID;

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.
• submeshId è un XrUuid che identifica la submesh.
• lastUpdatedTime è un XrTime che rappresenta l'ora dell'ultimo aggiornamento della submesh.
• submeshPoseInBaseSpace è un XrPosef che rappresenta la posa del submesh nello spazio di base utilizzato per creare lo snapshot della mesh della scena. Questa è anche la posa del centro del riquadro di selezione della submesh.
• bounds è un XrExtent3Df che descrive le dimensioni del bounding box che racchiude la submesh. Questo limite si trova nello spazio di base utilizzato per creare l'handle della mesh della scena.

xrGetAllSubmeshStatesANDROID

L'applicazione può utilizzare la funzione xrGetAllSubmeshStatesANDROID per ottenere lo stato di tutte le submesh nella mesh della scena. Contiene informazioni di base per consentire all'applicazione di selezionare le mesh secondarie per le quali vuole i dati. Questa funzione può essere utilizzata in un idioma a due chiamate.

XrResult xrGetAllSubmeshStatesANDROID(
    XrSceneMeshSnapshotANDROID            snapshot,
    uint32_t                              submeshStateCapacityInput,
    uint32_t*                             submeshStateCountOutput,
    XrSceneSubmeshStateANDROID*           submeshStates);

Descrizioni dei parametri

• snapshot è un handle XrSceneMeshSnapshotANDROID creato in precedenza con xrCreateSceneMeshSnapshotANDROID.
• submeshStateCapacityInput è la lunghezza di submeshStates.
• submeshStateCountOutput è il numero di elementi in submeshStates modificati dal runtime a partire dall'inizio dell'array.
• submeshStates è un array di strutture XrSceneSubmeshStateANDROID a cui il runtime restituirà lo stato di tutte le submesh nella mesh della scena.

XrSceneSubmeshDataANDROID

XrSceneSubmeshDataANDROID contiene i dati dei triangoli per una submesh insieme all'ID submesh. Questa struttura viene utilizzata in xrGetSubmeshDataANDROID per ottenere i dati della submesh. L'applicazione deve impostare l'ID della submesh di questa struttura e i puntatori del buffer sui buffer allocati in modo che i dati restituiti per la submesh possano essere inseriti nei buffer allocati. L'applicazione può utilizzare xrGetSubmeshDataANDROID come idioma a due chiamate in cui la prima chiamata richiederà all'applicazione di impostare l'ID submesh e ottenere le dimensioni dei buffer necessari per i dati submesh, quindi l'applicazione può allocare i buffer e ottenere i dati nella seconda chiamata.

typedef struct XrSceneSubmeshDataANDROID {
    XrStructureType    type;
    const void*        next;
    XrUuid             submeshId;
    uint32_t           vertexCapacityInput;
    uint32_t           vertexCountOutput;
    XrVector3f*        vertexPositions;
    XrVector3f*        vertexNormals;
    uint8_t*           vertexSemantics;
    uint32_t           indexCapacityInput;
    uint32_t           indexCountOutput;
    uint32_t*          indices;
} XrSceneSubmeshDataANDROID;

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.
• submeshId è un XrUuid che identifica la submesh.
• vertexCapacityInput è la lunghezza di vertexPositions, vertexNormals e vertexSemantics.
• vertexCountOutput è il numero di elementi in vertexPositions, vertexNormals e vertexSemantics che sono stati modificati dal runtime a partire dall'inizio dell'array.
• vertexPositions è un array di XrVector3f in cui il runtime restituisce le posizioni dei vertici della submesh.
• vertexNormals è un array di XrVector3f in cui il runtime restituisce le normali dei vertici della submesh. Questo campo può essere lasciato NULL se l'applicazione ha creato un tracker con le normali disattivate.
• vertexSemantics è un array di uint8_t in cui il runtime restituisce la semantica dei vertici della submesh. Questo campo può essere lasciato NULL se l'applicazione ha creato un tracker con l'etichetta semantica XR_SCENE_MESH_SEMANTIC_LABEL_SET_NONE_ANDROID impostata.
• indexCapacityInput è la lunghezza di indices.
• indexCountOutput è il numero di elementi in indices che sono stati modificati dal runtime a partire dall'inizio dell'array.
• indices è un array di uint32_t a cui il runtime restituirà gli indici della submesh.

xrGetSubmeshDataANDROID

L'applicazione può utilizzare la funzione xrGetSubmeshDataANDROID per ottenere i dati per un elenco selezionato di submesh. Questa funzione può essere utilizzata in un idioma a due chiamate. Nella prima chiamata, l'applicazione deve impostare un ID submesh valido (ovvero recuperabile da xrGetAllSubmeshStatesANDROID con lo stesso snapshot della mesh della scena) e una capacità pari a zero per ogni elemento nell'elenco selezionato di submesh per ottenere le dimensioni dei buffer richiesti per i dati della submesh. Nella seconda chiamata, l'applicazione deve impostare i puntatori del buffer su un buffer allocato per ogni elemento nell'elenco selezionato di submesh insieme alla capacità dei buffer per ottenere i dati delle submesh.

XrResult xrGetSubmeshDataANDROID(
    XrSceneMeshSnapshotANDROID            snapshot,
    uint32_t                              submeshDataCount,
    XrSceneSubmeshDataANDROID*            inoutSubmeshData);

Descrizioni dei parametri

• snapshot è un handle XrSceneMeshSnapshotANDROID creato in precedenza con xrCreateSceneMeshSnapshotANDROID.
• submeshDataCount è la lunghezza di inoutSubmeshData.
• inoutSubmeshData è un array di XrSceneSubmeshDataANDROID in cui ogni elemento verrà compilato con i dati della mesh dal runtime in base all'ID della submesh.

XrSceneMeshSemanticLabelANDROID

L'enumerazione XrSceneMeshSemanticLabelANDROID è l'insieme predefinito di etichette semantiche che possono essere utilizzate per etichettare i vertici della mesh per descrivere su quale superficie dell'ambiente fisico si trova il vertice della mesh. Questo set di enum è rappresentato dal valore XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT_ANDROID in XrSceneMeshSemanticLabelSetANDROID.

typedef enum XrSceneMeshSemanticLabelANDROID {
    XR_SCENE_MESH_SEMANTIC_LABEL_OTHER_ANDROID = 0,
    XR_SCENE_MESH_SEMANTIC_LABEL_FLOOR_ANDROID = 1,
    XR_SCENE_MESH_SEMANTIC_LABEL_CEILING_ANDROID = 2,
    XR_SCENE_MESH_SEMANTIC_LABEL_WALL_ANDROID = 3,
    XR_SCENE_MESH_SEMANTIC_LABEL_TABLE_ANDROID = 4,
    XR_SCENE_MESH_SEMANTIC_LABEL_MAX_ENUM_ANDROID = 0x7FFFFFFF
} XrSceneMeshSemanticLabelANDROID;

Distruggere uno snapshot della mesh della scena

xrDestroySceneMeshSnapshotANDROID

L'applicazione può utilizzare la funzione xrDestroySceneMeshSnapshotANDROID per eliminare uno snapshot della mesh della scena. Una volta eliminato l'handle, l'applicazione non può più utilizzarlo per ottenere i dati o le informazioni sulla submesh. L'handle viene eliminato automaticamente quando viene eliminato il tracker perché l'handle del tracker è il genitore dell'handle dello snapshot della mesh della scena.

XrResult xrDestroySceneMeshSnapshotANDROID(
    XrSceneMeshSnapshotANDROID            snapshot);

Descrizioni dei parametri

• snapshot è un handle XrSceneMeshSnapshotANDROID creato in precedenza con xrCreateSceneMeshSnapshotANDROID che verrà eliminato da questa funzione.

Codice di esempio per la creazione di mesh della scena

Il seguente codice di esempio mostra come accedere ai dati della mesh della scena per il rendering.

XrInstance instance;  // Created at app startup
XrSystemId systemId;  // Received from xrGetSystem() at app startup
XrSession session;    // Created at app startup
XrSpace appPlaySpace; // Created at app startup

// The function pointers are previously initialized using xrGetInstanceProcAddr.
PFN_xrCreateSceneMeshingTrackerANDROID xrCreateSceneMeshingTrackerANDROID;
PFN_xrDestroySceneMeshingTrackerANDROID xrDestroySceneMeshingTrackerANDROID;
PFN_xrEnumerateSupportedSemanticLabelSetsANDROID xrEnumerateSupportedSemanticLabelSetsANDROID;
PFN_xrCreateSceneMeshSnapshotANDROID xrCreateSceneMeshSnapshotANDROID;
PFN_xrDestroySceneMeshSnapshotANDROID xrDestroySceneMeshSnapshotANDROID;
PFN_xrGetAllSubmeshStatesANDROID xrGetAllSubmeshStatesANDROID;
PFN_xrGetSubmeshDataANDROID xrGetSubmeshDataANDROID;

// Inspect system capability
XrSystemSceneMeshingPropertiesANDROID sceneMeshingProps = {
  .type = XR_TYPE_SYSTEM_SCENE_MESHING_PROPERTIES_ANDROID,
};
XrSystemProperties sysProps = {
  .type = XR_TYPE_SYSTEM_PROPERTIES,
  .next = &sceneMeshingProps
};
CHK_XR(xrGetSystemProperties(instance, systemId, &sysProps));
if (!sceneMeshingProps.supportsSceneMeshing) {
    // scene meshing is not supported.
    return;
}

uint32_t supportedsemanticLabelSetsCount = 0;
xrEnumerateSupportedSemanticLabelSetsANDROID(
  instance, systemId, 0, &supportedsemanticLabelSetsCount, nullptr);
std::vector<XrSceneMeshSemanticLabelSetANDROID> supportedSemanticLabelSets(
  supportedsemanticLabelSetsCount);
xrEnumerateSupportedSemanticLabelSetsANDROID(
  instance, systemId, supportedsemanticLabelSetsCount,
  &supportedsemanticLabelSetsCount, supportedSemanticLabelSets.data());

XrSceneMeshSemanticLabelSetANDROID semanticLabelSet = XR_SCENE_MESH_SEMANTIC_LABEL_SET_NONE_ANDROID;
// Check if system supports XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT_ANDROID
if (std::find(supportedSemanticLabelSets.begin(), supportedSemanticLabelSets.end(),
              XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT_ANDROID) !=
    supportedSemanticLabelSets.end()) {
  semanticLabelSet = XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT_ANDROID;
}

XrSceneMeshingTrackerCreateInfoANDROID trackerCreateInfo = {
  .type = XR_TYPE_SCENE_MESHING_TRACKER_CREATE_INFO_ANDROID,
  .semanticLabelSet = semanticLabelSet,
  .enableNormals = XR_TRUE
};

XrSceneMeshingTrackerANDROID tracker = XR_NULL_HANDLE;
CHK_XR(xrCreateSceneMeshingTrackerANDROID(session, &trackerCreateInfo, &tracker));

XrSceneMeshSnapshotCreationResultANDROID snapshotResult = {
  .type = XR_TYPE_SCENE_MESH_SNAPSHOT_CREATION_RESULT_ANDROID,
  .snapshot = XR_NULL_HANDLE
};
XrSceneMeshSnapshotANDROID& snapshot = snapshotResult.snapshot;
XrSceneMeshSnapshotCreateInfoANDROID createInfo = {
  .type = XR_TYPE_SCENE_MESH_SNAPSHOT_CREATE_INFO_ANDROID
};

// app update loop
while (true) {
  // ...
  // For every frame in frame loop
  // ...

  XrFrameState frameState; // previously returned from xrWaitFrame
  const XrTime time = frameState.predictedDisplayTime;
  XrBoxf box; // populated with the bounding box of the camera frustum

  // ...

  createInfo.baseSpace = appPlaySpace;
  createInfo.time = time;
  createInfo.boundingBox = box;

  // Grab the scene mesh snapshot. This way the app can: know all of the submesh infos,
  // choose the appropriate submeshes for which to get data, allocate the necessary
  // buffer for those submeshes, and then get the data.
  CHK_XR(xrCreateSceneMeshSnapshotANDROID(tracker, &createInfo, &snapshotResult));

  // check the tracking state
  if (snapshotResult.trackingState == XR_SCENE_MESH_TRACKING_STATE_ERROR_ANDROID) {
    // unrecoverable error. Exit the app.
    if (snapshot != XR_NULL_HANDLE) {
      CHK_XR(xrDestroySceneMeshSnapshotANDROID(snapshot));
      snapshot = XR_NULL_HANDLE;
    }
    break;
  } else if (snapshotResult.trackingState != XR_SCENE_MESH_TRACKING_STATE_TRACKING_ANDROID) {
    // The tracker is not tracking. Try again later.
    if (snapshot != XR_NULL_HANDLE) {
      CHK_XR(xrDestroySceneMeshSnapshotANDROID(snapshot));
      snapshot = XR_NULL_HANDLE;
    }
    continue;
  }

  // 2-call idiom for getting submesh states
  std::vector<XrSceneSubmeshStateANDROID> states;
  uint32_t submeshCount = 0;
  CHK_XR(xrGetAllSubmeshStatesANDROID(snapshot, 0, &submeshCount, nullptr));
  states.resize(submeshCount);
  for (XrSceneSubmeshStateANDROID& state : states) {
    state = {.type = XR_TYPE_SCENE_SUBMESH_STATE_ANDROID};
  }
  CHK_XR(xrGetAllSubmeshStatesANDROID(snapshot, submeshCount, &submeshCount, states.data()));

  // To store the poses for the selected submeshes
  std::vector<XrPosef> submeshesPoses;
  submeshesPoses.reserve(submeshCount);

  std::vector<XrSceneSubmeshDataANDROID> submeshes;
  submeshes.reserve(submeshCount);
  // Iterate the states and determine which submeshes the app wants data for
  for (XrSceneSubmeshStateANDROID& state : states) {
    // Modify this bool as necessary by looking at states. Maybe state.lastUpdatedTime
    // is below a threshold or maybe the bounding box does not intersect with camera view
    // frustum (The submesh will be culled).
    bool needed;
    if (needed) {
      // Add the selected submesh to the submeshes list. Set the capacity
      // zero for now since the size of the buffer will be determined later.
      XrSceneSubmeshDataANDROID submesh = {
        .type = XR_TYPE_SCENE_SUBMESH_DATA_ANDROID,
        .submeshId = state.submeshId,
        .vertexCapacityInput = 0,
        .vertexCountOutput = 0,
        .vertexPositions = nullptr,
        .vertexNormals = nullptr,
        .vertexSemantics = nullptr,
        .indexCapacityInput = 0,
        .indexCountOutput = 0,
        .indices = nullptr,
      };
      submeshes.push_back(submesh);
      submeshesPoses.push_back(state.submeshPoseInBaseSpace);
    }
  }

  // Grab the data for the selected submeshes using the 2-call idiom.
  CHK_XR(xrGetSubmeshDataANDROID(snapshot, submeshes.size(), submeshes.data()));
  for (XrSceneSubmeshDataANDROID& submesh : submeshes) {
    submesh.vertexCapacityInput = submesh.vertexCountOutput;
    submesh.vertexCountOutput = 0;
    submesh.vertexPositions = new XrVector3f[submesh.vertexCountOutput];
    submesh.vertexNormals = new XrVector3f[submesh.vertexCountOutput];
    submesh.vertexSemantics = new uint8_t[submesh.vertexCountOutput];
    submesh.indexCapacityInput = submesh.indexCountOutput;
    submesh.indexCountOutput = 0;
    submesh.indices = new uint32_t[submesh.indexCountOutput];
  }
  CHK_XR(xrGetSubmeshDataANDROID(snapshot, submeshes.size(), submeshes.data()));

  // Destroy the scene mesh snapshot since we have finally grabbed the submeshes data. In
  // next iteration app can: create a new one to get latest mesh data
  CHK_XR(xrDestroySceneMeshSnapshotANDROID(snapshot));
  snapshot = XR_NULL_HANDLE;

  // Iterate the submeshes and get the vertex positions, vertex normals and
  // vertex semantics data for the selected submeshes
  for (uint32_t i = 0; i < submeshes.size(); i++) {
    XrSceneSubmeshDataANDROID& data = submeshes[i];
    XrVector3f* vertexPositions = data.vertexPositions;
    XrVector3f* vertexNormals = data.vertexNormals;
    XrSceneMeshSemanticLabelANDROID* vertexSemantics =
      reinterpret_cast<XrSceneMeshSemanticLabelANDROID*>(data.vertexSemantics);
    XrPosef pose = submeshesPoses[i];

    // *** Use the data as per needs ***

    // Release the allocated memory for the data buffers when done using
    delete [] data.vertexPositions;
    delete [] data.vertexNormals;
    delete [] data.vertexSemantics;
    delete [] data.indices;
  }

  // ...
  // Finish frame loop
  // ...
}

CHK_XR(xrDestroySceneMeshingTrackerANDROID(tracker));

Nuovi tipi di oggetti

• XrSceneMeshingTrackerANDROID
• XrSceneMeshSnapshotANDROID

Nuove costanti enum

L'enumerazione XrObjectType è estesa con:

• XR_OBJECT_TYPE_SCENE_MESHING_TRACKER_ANDROID
• XR_OBJECT_TYPE_SCENE_MESH_SNAPSHOT_ANDROID

L'enumerazione XrStructureType è estesa con:

• XR_TYPE_SYSTEM_SCENE_MESHING_PROPERTIES_ANDROID
• XR_TYPE_SCENE_MESHING_TRACKER_CREATE_INFO_ANDROID
• XR_TYPE_SCENE_MESH_SNAPSHOT_CREATE_INFO_ANDROID
• XR_TYPE_SCENE_MESH_SNAPSHOT_CREATION_RESULT_ANDROID
• XR_TYPE_SCENE_SUBMESH_STATE_ANDROID
• XR_TYPE_SCENE_SUBMESH_DATA_ANDROID

Nuovi enum

• XrSceneMeshSemanticLabelSetANDROID
• XrSceneMeshSemanticLabelANDROID
• XrSceneMeshTrackingStateANDROID

Nuove strutture

• XrSystemSceneMeshingPropertiesANDROID
• XrSceneMeshingTrackerCreateInfoANDROID
• XrSceneMeshSnapshotCreateInfoANDROID
• XrSceneMeshSnapshotCreationResultANDROID
• XrSceneSubmeshStateANDROID
• XrSceneSubmeshDataANDROID

Nuove funzioni

• xrCreateSceneMeshingTrackerANDROID
• xrDestroySceneMeshingTrackerANDROID
• xrEnumerateSupportedSemanticLabelSetsANDROID
• xrCreateSceneMeshSnapshotANDROID
• xrDestroySceneMeshSnapshotANDROID
• xrGetAllSubmeshStatesANDROID
• xrGetSubmeshDataANDROID

Problemi

Cronologia delle versioni

• Revisione 3, 15/05/2025 (Salar Khan) ** Descrizione iniziale dell'estensione

---

OpenXR™ e il logo OpenXR sono marchi di proprietà di The Khronos Group Inc. e sono registrati come marchi in Cina, nell'Unione Europea, in Giappone e nel Regno Unito.