Creare ancore con ARCore per Jetpack XR

Un ancoraggio descrive una posizione e un orientamento fissi nel mondo reale. Se attacchi un oggetto a un ancoraggio, gli oggetti appaiono posizionati in modo realistico nel mondo reale.

Crea una sessione ARCore per Jetpack XR

Crea ancore tramite una sessione ARCore per Jetpack XR. Consulta la sezione Comprendere il ciclo di vita di una sessione per ottenere un Session.

Configurare la sessione

La creazione e il caricamento degli ancoraggi non richiedono la configurazione della sessione. Tuttavia, la persistenza degli ancoraggi non è abilitata per impostazione predefinita nelle sessioni XR. Per rendere persistenti e caricare gli ancoraggi dalla memoria locale, configura la sessione e imposta la modalità AnchorPersistenceMode.LOCAL:

val newConfig = session.config.copy(
    anchorPersistence = Config.AnchorPersistenceMode.LOCAL,
)
when (val result = session.configure(newConfig)) {
    is SessionConfigureConfigurationNotSupported ->
        TODO(/* Some combinations of configurations are not valid. Handle this failure case. */)
    is SessionConfigureSuccess -> TODO(/* Success! */)
    else ->
        TODO(/* A different unhandled exception was thrown. */)
}
Anchors.kt

Ancorare i contenuti a una posizione fissa nello spazio

Un ancoraggio viene creato utilizzando un Pose, che può essere interpretato in relazione a un Trackable esistente o meno.

Crea un ancoraggio relativo a un elemento monitorabile

Quando viene creato un ancoraggio rispetto a un Trackable, ad esempio un Plane, l'ancoraggio segue il Trackable allegato quando si sposta nello spazio.

when (val result = trackable.createAnchor(pose)) {
    is AnchorCreateSuccess -> { /* anchor stored in `result.anchor`. */ }
    else -> { /* handle failure */ }
}
Anchors.kt

Crea un ancoraggio senza un Trackable

Per creare un ancoraggio non collegato a un Trackable:

when (val result = Anchor.create(session, pose)) {
    is AnchorCreateSuccess -> { /* anchor stored in `result.anchor`. */ }
    else -> { /* handle failure */ }
}
Anchors.kt

Allegare un'entità a un ancoraggio

Per eseguire il rendering di un modello in questa posizione, crea un GltfModel e imposta il relativo elemento principale su un AnchorEntity.

AnchorEntity.create(session, anchor).apply {
    parent = session.scene.activitySpace
    addChild(entity)
}
Anchors.kt

Informazioni su TrackingState

Ogni Trackable ha un TrackingState che deve essere controllato prima dell'utilizzo. Un Trackable con un TrackableState di Tracking ha il Pose aggiornato attivamente dal sistema. Un Trackable Paused potrebbe diventare Tracking in futuro, mentre uno Stopped non diventerà mai Tracking.

Mantenere un ancoraggio durante le sessioni

Un ancoraggio non persistente scompare dopo la distruzione di una sessione. Se mantieni un ancoraggio, la tua app ne memorizza la posizione nei suoi dati privati. Questo ancoraggio può essere recuperato in una sessione successiva ed è ancorato nella stessa posizione del mondo.

Per rendere persistente un ancoraggio, utilizza Anchor.persist() come mostrato qui:

val uuid = anchor.persist()
AnchorPersistence.kt

La tua app può recuperare l'ancora utilizzando UUID in una sessione futura:

when (val result = Anchor.load(session, uuid)) {
    is AnchorCreateSuccess -> {
        // Loading was successful. The anchor is stored in result.anchor.
    }
    else -> {
        // handle failure
    }
}
AnchorPersistence.kt

Quando non hai più bisogno di un ancora, chiama il numero unpersist(). In questo modo l'ancora viene rimossa dallo spazio di archiviazione dell'app e l'UUID specificato non è più recuperabile per le chiamate a Anchor.load().

Anchor.unpersist(session, uuid)
AnchorPersistence.kt

La tua app può anche richiedere un elenco di tutti gli ancoraggi persistenti che sono ancora presenti nello spazio di archiviazione dell'app:

val uuids = Anchor.getPersistedAnchorUuids(session)
AnchorPersistence.kt