Creare ancore con ARCore per Jetpack XR

Dispositivi XR applicabili

Queste indicazioni ti aiutano a creare esperienze per questi tipi di dispositivi XR.

Scopri di più sui tipi di dispositivi XR →

Scopri di più sui tipi di dispositivi XR →

Un ancoraggio descrive una posizione e un orientamento fissi nel mondo reale. Il collegamento di un oggetto a un ancoraggio consente di visualizzare gli oggetti in modo realistico nel mondo reale.

Accedere a una sessione

Crea ancoraggi tramite una ARCore per Jetpack XR Session. Se stai migliorando l'UI spaziale utilizzando Jetpack Compose per XR, accedi a una sessione da Jetpack Compose per XR. Se stai lavorando con entità spazializzate dalla libreria Jetpack SceneCore, accedi a una sessione da Jetpack XR Runtime.

Configurare la sessione

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

val newConfig = session.config.copy(
    anchorPersistence = AnchorPersistenceMode.LOCAL,
)
when (val result = session.configure(newConfig)) {
    is SessionConfigureSuccess -> TODO(/* Success! */)
    else ->
        TODO(/* The session could not be configured. See SessionConfigureResult for possible causes. */)
}
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 Anchorable esistente o meno. Un Anchorable è un Trackable a cui è possibile collegare gli ancoraggi.

Creare un ancoraggio relativo a un Anchorable

Quando viene creato un ancoraggio relativo a un Anchorable, ad esempio un Plane, l'ancoraggio segue l'Anchorable collegato quando si sposta nello spazio.

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

Creare un ancoraggio senza un Anchorable

Per creare un ancoraggio non collegato a un Anchorable:

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

Collegare 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 di essere utilizzato. Un Trackable con un TrackableState di Tracking ha la relativa Pose aggiornata attivamente dal sistema. Un Trackable in stato Paused potrebbe diventare Tracking in futuro, mentre uno in stato Stopped non diventerà mai Tracking.

Rendere persistente un ancoraggio tra le sessioni

Un ancoraggio non persistente scompare dopo la distruzione di una sessione. Se rendi persistente un ancoraggio, la tua app ricorda la posizione dell'ancoraggio nei dati privati dell'app. Questo ancoraggio può essere recuperato in una sessione successiva ed è ancorato nella stessa posizione nel mondo.

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

val uuid = anchor.persist()
AnchorPersistence.kt

La tua app può recuperare l'ancoraggio utilizzando il 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 ancoraggio, chiama unpersist(). In questo modo, l'ancoraggio viene rimosso dall'archiviazione dell'app e l'UUID specificato non può essere recuperato 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 ancora presenti nell'archiviazione dell'app:

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