Créer des ancrages avec ARCore pour Jetpack XR

Une ancre décrit une position et une orientation fixes dans le monde réel. Attacher un objet à un ancrage permet de le placer de manière réaliste dans le monde réel.

Créer une session ARCore pour Jetpack XR

Créez des ancrages via une session ARCore pour Jetpack XR. Consultez la section Comprendre le cycle de vie d'une session pour obtenir un Session.

Configurer la session

La création et le chargement d'ancrages ne nécessitent pas de configurer la session. Toutefois, la persistance des ancres n'est pas activée par défaut sur les sessions XR. Pour persister et charger des ancres, configurez la session:

val newConfig = session.config.copy(
    anchorPersistence = Config.AnchorPersistenceMode.Enabled,
)
when (val result = session.configure(newConfig)) {
    is SessionConfigureConfigurationNotSupported ->
        TODO(/* Some combinations of configurations are not valid. Handle this failure case. */)
    is SessionConfigurePermissionsNotGranted ->
        TODO(/* The required permissions in result.permissions have not been granted. */)
    is SessionConfigureSuccess -> TODO(/* Success! */)
}
Anchors.kt

Ancrer le contenu à un emplacement fixe dans l'espace

Une ancre est créée à l'aide d'un Pose, qui peut être interprété par rapport à un Trackable existant ou non.

Créer une ancre par rapport à un élément Trackable

Lorsqu'une ancre est créée par rapport à un Trackable, tel qu'un Plane, l'ancre suit le Trackable associé lorsqu'il se déplace dans l'espace.

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

Créer une ancre sans traceur

Pour créer une ancre qui n'est pas associée à un Trackable:

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

Associer une entité à un ancrage

Pour afficher un modèle à cet emplacement, [créez un GltfModel][5] et définissez son parent sur un AnchorEntity.

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

Comprendre TrackingState

Chaque Trackable possède un TrackingState qui doit être vérifié avant d'être utilisé. Un Trackable dont la valeur TrackableState est Tracking voit son Pose mis à jour activement par le système. Un Trackable qui est Paused peut devenir Tracking à l'avenir, tandis qu'un Stopped ne deviendra jamais Tracking.

Persistance d'une ancre entre les sessions

Une ancre qui n'est pas persistante disparaît après la destruction d'une session. En persistant un ancrage, votre application mémorise la position de cet ancrage dans ses données d'application privées. Cette ancre peut être récupérée dans une session ultérieure et est ancrée au même endroit dans le monde.

Pour conserver une ancre, utilisez anchor.persist() comme indiqué ci-dessous:

val uuid = anchor.persist()
AnchorPersistence.kt

Votre application peut récupérer l'ancre à l'aide de UUID dans une future session:

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

Lorsque vous n'avez plus besoin d'une ancre, appelez unpersist(). Cette action supprime l'ancre du stockage de votre application et rend l'UUID donné introuvable pour les appels à Anchor.load().

Anchor.unpersist(session, uuid)
AnchorPersistence.kt

Votre application peut également demander la liste de tous les ancrages persistants qui sont toujours présents dans l'espace de stockage de votre application:

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