Verrouillage mondial et ancres spatiales dans Unity

Pour commencer à utiliser World Locking Tools, téléchargez l’outil de fonctionnalité Mixed Reality. Pour en savoir plus sur les principes de base, consultez la page de documentation principale de World Locking Tools pour obtenir des liens vers Vue d’ensemble, Démarrage rapide et d’autres rubriques utiles.

Configuration automatisée

Lorsque votre projet est prêt, exécutez l’utilitaire de configuration de scène à partir de Mixed Reality > World Locking Tools :

Visualiseurs

Au cours du développement précoce, l’ajout de visualiseurs peut être utile pour s’assurer que WLT est configuré et fonctionne correctement. Ils peuvent être supprimés pour les performances de production, ou si, pour une raison quelconque, ne sont plus nécessaires, à l’aide de l’utilitaire Supprimer les visualiseurs. Pour plus d’informations sur les visualiseurs, consultez la documentation outils.

Le plug-in OpenXR Mixed Reality fournit des fonctionnalités d’ancrage de base via une implémentation d’ARFoundation ARAnchorManager d’Unity. Pour découvrir les principes de base sur ARAnchors dans ARFoundation, consultez le manuel ARFoundation pour AR Anchor Manager.

Espace de noms :UnityEngine.XR.WSA
Type :WorldAnchor

Une technique clé consiste à créer une ancre spatiale pour verrouiller un cluster d’hologrammes précisément en place dans le monde physique, quelle que soit la distance parcourue par l’utilisateur, puis à retrouver ces hologrammes dans les sessions ultérieures.

Dans les versions antérieures d’Unity, vous créez une ancre spatiale en ajoutant le composant WorldAnchor Unity à un GameObject.

Ajouter une ancre mondiale

Pour ajouter une ancre mondiale, appelez AddComponent<WorldAnchor>() sur l’objet de jeu avec la transformation que vous souhaitez ancrer dans le monde réel.

WorldAnchor anchor = gameObject.AddComponent<WorldAnchor>();

Cet objet de jeu est maintenant ancré à son emplacement actuel dans le monde physique. Vous pouvez voir ses coordonnées de monde Unity s’ajuster légèrement au fil du temps pour garantir l’alignement physique. Consultez Charger une ancre mondiale pour trouver à nouveau cet emplacement ancré dans une session d’application future.

Supprimer une ancre mondiale

Si vous ne souhaitez plus que le GameObject verrouille à un emplacement du monde physique et que vous n’avez pas l’intention de le déplacer dans ce cadre, appelez Destroy le composant World Anchor.

Destroy(gameObject.GetComponent<WorldAnchor>());

Si vous souhaitez déplacer ce frame, appelez DestroyImmediate à la GameObject place.

DestroyImmediate(gameObject.GetComponent<WorldAnchor>());

Déplacer un GameObject ancré dans le monde

Vous ne pouvez pas déplacer tant GameObject qu’une ancre mondiale est dessus. Si vous devez déplacer ce GameObject cadre, vous devez :

1. DestroyImmediate composant World Anchor.
2. Déplacez le GameObject.
3. Ajoutez un nouveau composant World Anchor à .GameObject

DestroyImmediate(gameObject.GetComponent<WorldAnchor>());
gameObject.transform.position = new Vector3(0, 0, 2);
WorldAnchor anchor = gameObject.AddComponent<WorldAnchor>();

Gérer les modifications de locatabilité

Une ancre mondiale peut ne pas être locatable dans le monde physique à un moment donné. Unity ne met alors pas à jour la transformation de l’objet ancré. Cette situation peut également se produire pendant l’exécution d’une application. Si vous ne gérez pas la modification de la locatabilité, l’objet n’apparaît pas à l’emplacement physique correct dans le monde.

Pour être informé des modifications de locatabilité :

1. Abonnez-vous à l’événement OnTrackingChanged . L’événement OnTrackingChanged est appelé chaque fois que l’ancre spatiale sous-jacente change entre un état locatable ou non locatable.

   anchor.OnTrackingChanged += Anchor_OnTrackingChanged;
   

2. Gérez l’événement.

   private void Anchor_OnTrackingChanged(WorldAnchor self, bool located)
   {
       // This simply activates/deactivates this object and all children when tracking changes
       self.gameObject.SetActiveRecursively(located);
   }
   

Si les ancres sont localisées immédiatement, la isLocated propriété de l’ancre est définie sur true lorsque AddComponent<WorldAnchor>() retourne. Par conséquent, l’événement OnTrackingChanged n’est pas déclenché. Un modèle plus propre consiste à appeler le OnTrackingChanged gestionnaire avec l’état initial IsLocated après l’attachement d’une ancre.

Anchor_OnTrackingChanged(anchor, anchor.isLocated);

Par défaut, World Locking Tools restaure le système de coordonnées d’Unity par rapport au monde physique entre les sessions sur les appareils qui prennent en charge la persistance des ancres spatiales locales. Pour qu’un hologramme apparaisse au même endroit dans le monde physique après avoir quitté et réexécuté l’application, il suffit à l’application de restaurer la même pose pour l’hologramme.

Si l’application a besoin d’un contrôle plus précis, vous pouvez désactiver l’enregistrement automatique et le chargement automatique dans l’inspecteur, et gérer la persistance à partir d’un script. Pour plus d’informations, consultez Conserver les systèmes de coordonnées spatiales.

World Locking Tools prend en charge la persistance des ancres locales uniquement sur les appareils HoloLens.

Une API appelée permet de XRAnchorStore conserver les ancres entre les sessions. est XRAnchorStore une représentation des ancres enregistrées sur un appareil. Vous pouvez conserver les ancres à partir de ARAnchors dans la scène Unity, charger des ancres à partir du stockage dans un nouveau ARAnchors, ou supprimer des ancres du stockage.

Espaces de noms

Pour Unity 2020 et OpenXR :

using Microsoft.MixedReality.ARSubsystems.XRAnchorStore

ou Unity 2019/2020 + Plug-in Windows XR :

using UnityEngine.XR.WindowsMR.XRAnchorStore

Méthodes publiques

{
    // A list of all persisted anchors, which can be loaded.
    public IReadOnlyList<string> PersistedAnchorNames { get; }

    // Clear all persisted anchors
    public void Clear();

    // Load a single persisted anchor by name. The ARAnchorManager will create this new anchor and report it in
    // the ARAnchorManager.anchorsChanged event. The TrackableId returned here is the same TrackableId the
    // ARAnchor will have when it is instantiated.
    public TrackableId LoadAnchor(string name);

    // Attempts to persist an existing ARAnchor with the given TrackableId to the local store. Returns true if
    // the storage is successful, false otherwise.
    public bool TryPersistAnchor(TrackableId id, string name);

    // Removes a single persisted anchor from the anchor store. This will not affect any ARAnchors in the Unity
    // scene, only the anchors in storage.
    public void UnpersistAnchor(string name);
}

Obtenir une référence de magasin d’ancres

Pour charger le XRAnchorStore avec Unity 2020 et OpenXR, utilisez la méthode d’extension sur XRAnchorSubsystem, le sous-système d’un ARAnchorManager :

public static Task<XRAnchorStore> LoadAnchorStoreAsync(this XRAnchorSubsystem anchorSubsystem)

Pour charger le XRAnchorStore avec Unity 2019/2020 et le plug-in Windows XR, utilisez la méthode d’extension sur XRReferencePointSubsystem (Unity 2019) ou XRAnchorSubsystem (Unity 2020), le sous-système d’un ARReferencePointManager/ARAnchorManager :

// Unity 2019 + Windows XR Plugin
public static Task<XRAnchorStore> TryGetAnchorStoreAsync(this XRReferencePointSubsystem anchorSubsystem);

// Unity 2020 + Windows XR Plugin
public static Task<XRAnchorStore> TryGetAnchorStoreAsync(this XRAnchorSubsystem anchorSubsystem);

Charger un magasin d’ancres

Pour charger un magasin d’ancres dans Unity 2020 et OpenXR, accédez-y à partir d’un sous-système ARAnchorManager comme suit :

ARAnchorManager arAnchorManager = GetComponent<ARAnchorManager>();
XRAnchorStore anchorStore = await arAnchorManager.subsystem.LoadAnchorStoreAsync();

ou avec Unity 2019/2020 et le plug-in Windows XR :

// Unity 2019
ARReferencePointManager arReferencePointManager = GetComponent<ARReferencePointManager>();
XRAnchorStore anchorStore = await arReferencePointManager.subsystem.TryGetAnchorStoreAsync();

// Unity 2020
ARAnchorManager arAnchorManager = GetComponent<ARAnchorManager>();
XRAnchorStore anchorStore = await arAnchorManager.subsystem.TryGetAnchorStoreAsync();

Pour voir un exemple complet d’ancres persistantes/non persistantes, case activée le GameObject Anchors -> Anchors Sample et AnchorsSample.cs script dans la [Mixed Reality OpenXR Plugin Sample Scene]((https://github.com/microsoft/OpenXR-Unity-MixedReality-Samples) :

Pour la persistance des hologrammes dans les versions antérieures d’Unity ou les projets WSA, utilisez WorldAnchor.

Namespace :UnityEngine.XR.WSA.Persistence
Class :WorldAnchorStore

WorldAnchorStore crée des expériences holographiques où les hologrammes restent dans des positions spécifiques du monde réel sur les instances de l’application. Les utilisateurs peuvent épingler des hologrammes individuels où ils le souhaitent et les trouver plus tard au même endroit sur les sessions d’application.

le WorldAnchorStore vous permet de conserver l’emplacement des ancres mondiales entre les sessions. Pour conserver les hologrammes entre les sessions, effectuez une trace distincte des GameObjects hologrammes qui utilisent une ancre mondiale particulière. Vous pouvez créer une GameObject racine avec une ancre mondiale et ancrer des hologrammes enfants à l’aide d’un décalage de position locale.

Pour charger les hologrammes des sessions précédentes :

1. Obtenez le WorldAnchorStore.
2. Chargez les données de l’application world anchor, ce qui vous donne l’ID de l’ancre mondiale.
3. Chargez l’ancre mondiale par son ID.

Pour enregistrer des hologrammes pour les sessions futures :

1. Obtenez le WorldAnchorStore.
2. Enregistrez une ancre mondiale en spécifiant un ID.
3. Enregistrez les données d’application liées à l’ancre mondiale avec l’ID.

Obtenir le WorldAnchorStore

Conservez une référence à , WorldAnchorStoreafin de savoir quand il est prêt à effectuer une opération. Étant donné que cet appel est asynchrone, dès que l’application démarre, vous pouvez appeler :

WorldAnchorStore.GetAsync(StoreLoaded);

StoreLoaded est le gestionnaire à la fin du WorldAnchorStore chargement :

private void StoreLoaded(WorldAnchorStore store)
{
       this.store = store;
}

Vous disposez maintenant d’une référence à , WorldAnchorStoreque vous pouvez utiliser pour enregistrer et charger des ancres de monde spécifiques.

Enregistrer une ancre mondiale

Pour enregistrer une ancre mondiale, nommez-la et passez-la dans le WorldAnchorStore que vous avez obtenu auparavant. Si vous essayez d’enregistrer deux ancres dans la même chaîne, store.Save retourne false. Supprimez l’enregistrement précédent avant d’en enregistrer un nouveau.

private void SaveGame()
{
       // Save data about holograms that this world anchor positions
       if (!this.savedRoot) // Only save the root once
       {
              this.savedRoot = this.store.Save("rootGameObject", anchor);
              Assert(this.savedRoot);
       }
}

Charger une ancre mondiale

Pour charger une ancre mondiale :

private void LoadGame()
{
       // Saved data about holograms that this world anchor positions:
       this.savedRoot = this.store.Load("rootGameObject", rootGameObject);
       if (!this.savedRoot)
       {
              // Game root not saved. Re-place objects or start over.
       }
}

Vous pouvez également utiliser store.Delete() pour supprimer une ancre que vous avez enregistrée précédemment et store.Clear() pour supprimer toutes les données précédemment enregistrées.

Énumérer les ancres existantes

Pour répertorier les ancres stockées, appelez GetAllIds.

string[] ids = this.store.GetAllIds();
for (int index = 0; index < ids.Length; index++)
{
        Debug.Log(ids[index]);
}