Nozioni di base di HoloLens (prima generazione): completare il progetto con il dispositivo

Questa esercitazione illustra un progetto completo, integrato in Unity, che illustra le principali funzionalità di Windows Mixed Reality in HoloLens, tra cui sguardo fisso, movimenti, input vocale, audio spaziale e mapping spaziale.

Il completamento dell'esercitazione richiederà circa 1 ora.

Supporto di dispositivi

Prima di iniziare

Prerequisiti

• Un PC Windows 10 configurato con gli strumenti corretti installati.
• Un dispositivo HoloLens configurato per lo sviluppo.

File di progetto

• Scaricare i file richiesti dal progetto. Richiede Unity 2017.2 o versione successiva.
  • Se è ancora necessario il supporto di Unity 5.6, usare questa versione.
  • Se è ancora necessario il supporto di Unity 5.5, usare questa versione.
  • Se è ancora necessario il supporto di Unity 5.4, usare questa versione.
• Annullare l'archiviazione dei file nel desktop o in un altro percorso facile da raggiungere. Mantenere il nome della cartella come Origami.

Capitolo 1 - Mondo "Holo"

In questo capitolo verrà configurato il primo progetto Unity e verrà illustrato il processo di compilazione e distribuzione.

Obiettivi

• Configurare Unity per lo sviluppo olografico.
• Creare un ologramma.
• Vedi un ologramma creato.

Istruzioni

• Riavviare Unity.
• Selezionare Open (Apri).
• Immettere il percorso come cartella Origami non archiviata in precedenza.
• Selezionare Origami e fare clic su Seleziona cartella.
• Poiché il progetto Origami non contiene una scena, salvare la scena predefinita vuota in un nuovo file usando: Salva / scena file con nome.
• Assegnare alla nuova scena il nome Origami e premere il pulsante Salva .

Configurare la fotocamera virtuale principale

• Nel Pannello di gerarchia, selezionare Fotocamera principale.
• In Inspector imposta la posizione di trasformazione su 0.0.0.
• Trovare la proprietà Clear Flags e modificare l'elenco a discesa da Skybox a Tinta unita.
• Fare clic sul campo Sfondo per aprire un editor dei colori.
• Impostare R, G, B e A su 0.

Configurare la scena

• Nel pannello Gerarchia fare clic su Crea e crea vuoto.
• Fare clic con il pulsante destro del mouse sul nuovo GameObject e scegliere Rinomina. Rinominare GameObject in OrigamiCollection.
• Dalla cartella Holograms nel pannello del progetto (espandere Asset e selezionare Holograms o fare doppio clic sulla cartella Holograms nel pannello del progetto):
  • Trascinare Stage nella gerarchia per essere un elemento figlio di OrigamiCollection.
  • Trascinare Sphere1 nella gerarchia come elemento figlio di OrigamiCollection.
  • Trascinare Sphere2 nella gerarchia come figlio di OrigamiCollection.
• Fare clic con il pulsante destro del mouse sull'oggetto Directional Light nel pannello Gerarchia e scegliere Elimina.
• Dalla cartella Holograms trascinare Lights nella radice del Pannello gerarchia.
• Nella gerarchia selezionare OrigamiCollection.
• In Inspector (Controllo) impostare la posizione di trasformazione su 0, -0.5, 2.0.
• Premere il pulsante Riproduci in Unity per visualizzare in anteprima gli ologrammi.
• Gli oggetti Origami verranno visualizzati nella finestra di anteprima.
• Premere Riproduci una seconda volta per arrestare la modalità di anteprima.

Esportare il progetto da Unity a Visual Studio

• In Unity selezionare Impostazioni compilazione file>.

• Selezionare piattaforma UWP (Universal Windows Platform) nell'elenco Piattaforma e fare clic su Cambia piattaforma.

• Impostare SDK su Universale 10 e Tipo di compilazione su D3D.

• Selezionare Progetti C# unity.

• Fare clic su Aggiungi scene aperte per aggiungere la scena.

• Fare clic su Compila.

• Nella finestra esplora file visualizzata creare una nuova cartella denominata "App".

• Fare clic sulla cartella dell'app.

• Premere Seleziona cartella.

• Al termine di Unity, verrà visualizzata una finestra di Esplora file.

• Aprire la cartella App .

• Aprire (doppio clic) Origami.sln.

• Usando la barra degli strumenti superiore in Visual Studio, modificare la destinazione da Debug a Rilascio e da ARM a X86.

• Fare clic sulla freccia accanto al pulsante Dispositivo e selezionare Computer remoto da distribuire tramite Wi-Fi.

  • Impostare l'indirizzo sul nome o sull'indirizzo IP di HoloLens. Se non conosci l'indirizzo IP del dispositivo, cerca Impostazioni > Rete & Opzioni avanzate Internet > o chiedi a Cortana "Ehi Cortana, Qual è il mio indirizzo IP?"
  • Se HoloLens è collegato tramite USB, è invece possibile selezionare Dispositivo da distribuire tramite USB.
  • Lasciare la modalità di autenticazione impostata su Universale.
  • Fare clic su Seleziona

• Fare clic su Avvia debug > senza eseguire il debug o premere CTRL+F5. Se questa è la prima volta che si esegue la distribuzione nel dispositivo, sarà necessario associarla a Visual Studio.

• Il progetto Origami verrà ora compilato, distribuito in HoloLens e quindi eseguito.

• Mettiti su HoloLens e guardati intorno per vedere i tuoi nuovi ologrammi.

Capitolo 2 - Sguardo fisso

In questo capitolo verranno presentati i primi tre modi per interagire con gli ologrammi, ovvero lo sguardo fisso.

Obiettivi

• Visualizzare lo sguardo fisso usando un cursore bloccato dal mondo.

Istruzioni

• Indietro al progetto Unity e chiudere la finestra Impostazioni di compilazione se è ancora aperta.
• Selezionare la cartella Holograms nel pannello Progetto.
• Trascinare l'oggetto Cursor nel pannello Hierarchy (Gerarchia ) a livello radice.
• Fare doppio clic sull'oggetto Cursor per esaminarlo più da vicino.
• Fare clic con il pulsante destro del mouse sulla cartella Script nel pannello Progetto.
• Fare clic sul sotto menu Crea .
• Selezionare Script C#.
• Assegnare un nome allo script WorldCursor. Nota: il nome è distinzione tra maiuscole e minuscole. Non è necessario aggiungere l'estensione .cs.
• Selezionare l'oggetto Cursor nel pannello Gerarchia.
• Trascinare e rilasciare lo script WorldCursor nel pannello Controllo.
• Fare doppio clic sullo script WorldCursor per aprirlo in Visual Studio.
• Copiare e incollare questo codice in WorldCursor.cs e Salvare tutto.

using UnityEngine;

public class WorldCursor : MonoBehaviour
{
    private MeshRenderer meshRenderer;

    // Use this for initialization
    void Start()
    {
        // Grab the mesh renderer that's on the same object as this script.
        meshRenderer = this.gameObject.GetComponentInChildren<MeshRenderer>();
    }

    // Update is called once per frame
    void Update()
    {
        // Do a raycast into the world based on the user's
        // head position and orientation.
        var headPosition = Camera.main.transform.position;
        var gazeDirection = Camera.main.transform.forward;

        RaycastHit hitInfo;

        if (Physics.Raycast(headPosition, gazeDirection, out hitInfo))
        {
            // If the raycast hit a hologram...
            // Display the cursor mesh.
            meshRenderer.enabled = true;

            // Move the cursor to the point where the raycast hit.
            this.transform.position = hitInfo.point;

            // Rotate the cursor to hug the surface of the hologram.
            this.transform.rotation = Quaternion.FromToRotation(Vector3.up, hitInfo.normal);
        }
        else
        {
            // If the raycast did not hit a hologram, hide the cursor mesh.
            meshRenderer.enabled = false;
        }
    }
}

• Ricompilare l'app da Impostazioni di compilazione file>.
• Tornare alla soluzione di Visual Studio usata in precedenza per la distribuzione in HoloLens.
• Selezionare 'Ricarica tutto' quando richiesto.
• Fare clic su Debug -> Avvia senza eseguire il debug o premere CTRL + F5.
• Ora guardare intorno alla scena e notare come il cursore interagisce con la forma di oggetti.

Capitolo 3 - Movimenti

In questo capitolo si aggiungerà il supporto per i movimenti. Quando l'utente seleziona una sfera di carta, si farà cadere la sfera attivando la gravità usando il motore di fisica di Unity.

Obiettivi

• Controllare gli ologrammi con il movimento Select.

Istruzioni

Si inizierà creando uno script, quindi è possibile rilevare il movimento Select.

• Nella cartella Script creare uno script denominato GazeGestureManager.
• Trascinare lo script GazeGestureManager nell'oggetto OrigamiCollection nella gerarchia.
• Aprire lo script GazeGestureManager in Visual Studio e aggiungere il codice seguente:

using UnityEngine;
using UnityEngine.XR.WSA.Input;

public class GazeGestureManager : MonoBehaviour
{
    public static GazeGestureManager Instance { get; private set; }

    // Represents the hologram that is currently being gazed at.
    public GameObject FocusedObject { get; private set; }

    GestureRecognizer recognizer;

    // Use this for initialization
    void Awake()
    {
        Instance = this;

        // Set up a GestureRecognizer to detect Select gestures.
        recognizer = new GestureRecognizer();
        recognizer.Tapped += (args) =>
        {
            // Send an OnSelect message to the focused object and its ancestors.
            if (FocusedObject != null)
            {
                FocusedObject.SendMessageUpwards("OnSelect", SendMessageOptions.DontRequireReceiver);
            }
        };
        recognizer.StartCapturingGestures();
    }

    // Update is called once per frame
    void Update()
    {
        // Figure out which hologram is focused this frame.
        GameObject oldFocusObject = FocusedObject;

        // Do a raycast into the world based on the user's
        // head position and orientation.
        var headPosition = Camera.main.transform.position;
        var gazeDirection = Camera.main.transform.forward;

        RaycastHit hitInfo;
        if (Physics.Raycast(headPosition, gazeDirection, out hitInfo))
        {
            // If the raycast hit a hologram, use that as the focused object.
            FocusedObject = hitInfo.collider.gameObject;
        }
        else
        {
            // If the raycast did not hit a hologram, clear the focused object.
            FocusedObject = null;
        }

        // If the focused object changed this frame,
        // start detecting fresh gestures again.
        if (FocusedObject != oldFocusObject)
        {
            recognizer.CancelGestures();
            recognizer.StartCapturingGestures();
        }
    }
}

• Creare un altro script nella cartella Script, questa volta denominata SphereCommands.
• Espandere l'oggetto OrigamiCollection nella visualizzazione Hierarchy.
• Trascinare lo script SphereCommands nell'oggetto Sphere1 nel pannello Hierarchy.
• Trascinare lo script SphereCommands nell'oggetto Sphere2 nel pannello Hierarchy.
• Aprire lo script in Visual Studio per la modifica e sostituire il codice predefinito con questo:

using UnityEngine;

public class SphereCommands : MonoBehaviour
{
    // Called by GazeGestureManager when the user performs a Select gesture
    void OnSelect()
    {
        // If the sphere has no Rigidbody component, add one to enable physics.
        if (!this.GetComponent<Rigidbody>())
        {
            var rigidbody = this.gameObject.AddComponent<Rigidbody>();
            rigidbody.collisionDetectionMode = CollisionDetectionMode.Continuous;
        }
    }
}

• Esportare, compilare e distribuire l'app in HoloLens.
• Guarda una delle sfere.
• Eseguire il movimento di selezione e watch l'eliminazione della sfera sulla superficie sottostante.

Capitolo 4 - Voce

In questo capitolo si aggiungerà il supporto per due comandi vocali: "Reimpostare il mondo" per restituire le sfere eliminate alla loro posizione originale e "Drop sphere" per rendere la sfera caduta.

Obiettivi

• Aggiungere comandi vocali che ascoltano sempre in background.
• Creare un ologramma che reagisce a un comando vocale.

Istruzioni

• Nella cartella Script creare uno script denominato SpeechManager.
• Trascinare lo script SpeechManager nell'oggetto OrigamiCollection nella gerarchia
• Aprire lo script SpeechManager in Visual Studio.
• Copiare e incollare questo codice in SpeechManager.cs e Salvare tutto:

using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.Windows.Speech;

public class SpeechManager : MonoBehaviour
{
    KeywordRecognizer keywordRecognizer = null;
    Dictionary<string, System.Action> keywords = new Dictionary<string, System.Action>();

    // Use this for initialization
    void Start()
    {
        keywords.Add("Reset world", () =>
        {
            // Call the OnReset method on every descendant object.
            this.BroadcastMessage("OnReset");
        });

        keywords.Add("Drop Sphere", () =>
        {
            var focusObject = GazeGestureManager.Instance.FocusedObject;
            if (focusObject != null)
            {
                // Call the OnDrop method on just the focused object.
                focusObject.SendMessage("OnDrop", SendMessageOptions.DontRequireReceiver);
            }
        });

        // Tell the KeywordRecognizer about our keywords.
        keywordRecognizer = new KeywordRecognizer(keywords.Keys.ToArray());

        // Register a callback for the KeywordRecognizer and start recognizing!
        keywordRecognizer.OnPhraseRecognized += KeywordRecognizer_OnPhraseRecognized;
        keywordRecognizer.Start();
    }

    private void KeywordRecognizer_OnPhraseRecognized(PhraseRecognizedEventArgs args)
    {
        System.Action keywordAction;
        if (keywords.TryGetValue(args.text, out keywordAction))
        {
            keywordAction.Invoke();
        }
    }
}

• Aprire lo script SphereCommands in Visual Studio.
• Aggiornare lo script da leggere come segue:

using UnityEngine;

public class SphereCommands : MonoBehaviour
{
    Vector3 originalPosition;

    // Use this for initialization
    void Start()
    {
        // Grab the original local position of the sphere when the app starts.
        originalPosition = this.transform.localPosition;
    }

    // Called by GazeGestureManager when the user performs a Select gesture
    void OnSelect()
    {
        // If the sphere has no Rigidbody component, add one to enable physics.
        if (!this.GetComponent<Rigidbody>())
        {
            var rigidbody = this.gameObject.AddComponent<Rigidbody>();
            rigidbody.collisionDetectionMode = CollisionDetectionMode.Continuous;
        }
    }

    // Called by SpeechManager when the user says the "Reset world" command
    void OnReset()
    {
        // If the sphere has a Rigidbody component, remove it to disable physics.
        var rigidbody = this.GetComponent<Rigidbody>();
        if (rigidbody != null)
        {
            rigidbody.isKinematic = true;
            Destroy(rigidbody);
        }

        // Put the sphere back into its original local position.
        this.transform.localPosition = originalPosition;
    }

    // Called by SpeechManager when the user says the "Drop sphere" command
    void OnDrop()
    {
        // Just do the same logic as a Select gesture.
        OnSelect();
    }
}

• Esportare, compilare e distribuire l'app in HoloLens.
• Guardare una delle sfere e dire "Drop Sphere".
• Dire "Reset World" per riportarli alle loro posizioni iniziali.

Capitolo 5 - Suono spaziale

In questo capitolo si aggiungerà musica all'app e quindi si attivano effetti audio su determinate azioni. Verrà usato il suono spaziale per dare suoni a una posizione specifica nello spazio 3D.

Obiettivi

• Senti gli ologrammi nel tuo mondo.

Istruzioni

• In Unity selezionare dal menu superiore Modifica > impostazioni > progetto Audio
• Nel pannello di controllo sul lato destro individuare l'impostazione Plug-in spazializzatore e selezionare MS HRTF Spatializer.
• Nella cartella Holograms nel pannello Project trascinare l'oggetto Ambience nell'oggetto OrigamiCollection nel pannello Gerarchia.
• Selezionare OrigamiCollection e trovare il componente Origine audio nel pannello Controllo. Modificare queste proprietà:
  • Controllare la proprietà Spatialize .
  • Controlla Play On Awake.
  • Modificare Blend spaziale in 3D trascinando il dispositivo di scorrimento fino a destra. Il valore deve cambiare da 0 a 1 quando si sposta il dispositivo di scorrimento.
  • Controllare la proprietà Loop .
  • Espandere Impostazioni audio 3D e immettere 0.1 per Livello Doppler.
  • Impostare Rolloff volume su Rolloff logaritmica.
  • Impostare Max Distance su 20.
• Nella cartella Script creare uno script denominato SphereSounds.
• Trascinare e rilasciare SphereSounds negli oggetti Sphere1 e Sphere2 nella gerarchia.
• Aprire SphereSounds in Visual Studio, aggiornare il codice seguente e Salvare tutto.

using UnityEngine;

public class SphereSounds : MonoBehaviour
{
    AudioSource impactAudioSource = null;
    AudioSource rollingAudioSource = null;

    bool rolling = false;

    void Start()
    {
        // Add an AudioSource component and set up some defaults
        impactAudioSource = gameObject.AddComponent<AudioSource>();
        impactAudioSource.playOnAwake = false;
        impactAudioSource.spatialize = true;
        impactAudioSource.spatialBlend = 1.0f;
        impactAudioSource.dopplerLevel = 0.0f;
        impactAudioSource.rolloffMode = AudioRolloffMode.Logarithmic;
        impactAudioSource.maxDistance = 20f;

        rollingAudioSource = gameObject.AddComponent<AudioSource>();
        rollingAudioSource.playOnAwake = false;
        rollingAudioSource.spatialize = true;
        rollingAudioSource.spatialBlend = 1.0f;
        rollingAudioSource.dopplerLevel = 0.0f;
        rollingAudioSource.rolloffMode = AudioRolloffMode.Logarithmic;
        rollingAudioSource.maxDistance = 20f;
        rollingAudioSource.loop = true;

        // Load the Sphere sounds from the Resources folder
        impactAudioSource.clip = Resources.Load<AudioClip>("Impact");
        rollingAudioSource.clip = Resources.Load<AudioClip>("Rolling");
    }

    // Occurs when this object starts colliding with another object
    void OnCollisionEnter(Collision collision)
    {
        // Play an impact sound if the sphere impacts strongly enough.
        if (collision.relativeVelocity.magnitude >= 0.1f)
        {
            impactAudioSource.Play();
        }
    }

    // Occurs each frame that this object continues to collide with another object
    void OnCollisionStay(Collision collision)
    {
        Rigidbody rigid = gameObject.GetComponent<Rigidbody>();

        // Play a rolling sound if the sphere is rolling fast enough.
        if (!rolling && rigid.velocity.magnitude >= 0.01f)
        {
            rolling = true;
            rollingAudioSource.Play();
        }
        // Stop the rolling sound if rolling slows down.
        else if (rolling && rigid.velocity.magnitude < 0.01f)
        {
            rolling = false;
            rollingAudioSource.Stop();
        }
    }

    // Occurs when this object stops colliding with another object
    void OnCollisionExit(Collision collision)
    {
        // Stop the rolling sound if the object falls off and stops colliding.
        if (rolling)
        {
            rolling = false;
            impactAudioSource.Stop();
            rollingAudioSource.Stop();
        }
    }
}

• Salvare lo script e tornare a Unity.
• Esportare, compilare e distribuire l'app in HoloLens.
• Spostarsi più vicino e ulteriormente dalla fase e girare sul lato per sentire il cambiamento dei suoni.

Capitolo 6 - Mapping spaziale

Ora si userà il mapping spaziale per posizionare la tavola da gioco su un oggetto reale nel mondo reale.

Obiettivi

• Portare il mondo reale nel mondo virtuale.
• Posizionare gli ologrammi dove sono più importanti per voi.

Istruzioni

• In Unity fare clic sulla cartella Holograms nel pannello Progetto.
• Trascinare l'asset Mapping spaziale nella radice della gerarchia.
• Fare clic sull'oggetto Mapping spaziale nella gerarchia.
• Nel pannello Controllo modificare le proprietà seguenti:
  • Selezionare la casella Disegna reti visive .
  • Individuare Disegna materiale e fare clic sul cerchio a destra. Digitare "wireframe" nel campo di ricerca nella parte superiore. Fare clic sul risultato e quindi chiudere la finestra. Quando si esegue questa operazione, il valore per Draw Material deve essere impostato su Wireframe.
• Esportare, compilare e distribuire l'app in HoloLens.
• Quando l'app viene eseguita, una mesh wireframe sovrappone il mondo reale.
• Guarda come una sfera in rotolamento scenderà dal palco e sul pavimento!

A questo punto verrà illustrato come spostare OrigamiCollection in una nuova posizione:

• Nella cartella Script creare uno script denominato TapToPlaceParent.
• Nella gerarchia espandere OrigamiCollection e selezionare l'oggetto Stage .
• Trascinare lo script TapToPlaceParent nell'oggetto Stage.
• Aprire lo script TapToPlaceParent in Visual Studio e aggiornarlo come segue:

using UnityEngine;

public class TapToPlaceParent : MonoBehaviour
{
    bool placing = false;

    // Called by GazeGestureManager when the user performs a Select gesture
    void OnSelect()
    {
        // On each Select gesture, toggle whether the user is in placing mode.
        placing = !placing;

        // If the user is in placing mode, display the spatial mapping mesh.
        if (placing)
        {
            SpatialMapping.Instance.DrawVisualMeshes = true;
        }
        // If the user is not in placing mode, hide the spatial mapping mesh.
        else
        {
            SpatialMapping.Instance.DrawVisualMeshes = false;
        }
    }

    // Update is called once per frame
    void Update()
    {
        // If the user is in placing mode,
        // update the placement to match the user's gaze.

        if (placing)
        {
            // Do a raycast into the world that will only hit the Spatial Mapping mesh.
            var headPosition = Camera.main.transform.position;
            var gazeDirection = Camera.main.transform.forward;

            RaycastHit hitInfo;
            if (Physics.Raycast(headPosition, gazeDirection, out hitInfo,
                30.0f, SpatialMapping.PhysicsRaycastMask))
            {
                // Move this object's parent object to
                // where the raycast hit the Spatial Mapping mesh.
                this.transform.parent.position = hitInfo.point;

                // Rotate this object's parent object to face the user.
                Quaternion toQuat = Camera.main.transform.localRotation;
                toQuat.x = 0;
                toQuat.z = 0;
                this.transform.parent.rotation = toQuat;
            }
        }
    }
}

• Esportare, compilare e distribuire l'app.
• Ora dovresti ora essere in grado di posizionare il gioco in una posizione specifica guardandolo, usando il movimento Select e quindi spostandosi in una nuova posizione e usando di nuovo il movimento Select.

Capitolo 7 - Divertimento olografico

Obiettivi

• Rivela l'ingresso a un mondo olografico.

Istruzioni

A questo punto verrà illustrato come scoprire l'olografico underworld:

• Dalla cartella Holograms nel pannello del progetto:
  • Trascinare Underworld nella gerarchia come elemento figlio di OrigamiCollection.
• Nella cartella Scripts creare uno script denominato HitTarget.
• Nella gerarchia espandere OrigamiCollection.
• Espandere l'oggetto Stage e selezionare l'oggetto Target (ventola blu).
• Trascinare lo script HitTarget nell'oggetto Target .
• Aprire lo script HitTarget in Visual Studio e aggiornarlo in modo che sia il seguente:

using UnityEngine;

public class HitTarget : MonoBehaviour
{
    // These public fields become settable properties in the Unity editor.
    public GameObject underworld;
    public GameObject objectToHide;

    // Occurs when this object starts colliding with another object
    void OnCollisionEnter(Collision collision)
    {
        // Hide the stage and show the underworld.
        objectToHide.SetActive(false);
        underworld.SetActive(true);

        // Disable Spatial Mapping to let the spheres enter the underworld.
        SpatialMapping.Instance.MappingEnabled = false;
    }
}

• In Unity selezionare l'oggetto Target .
• Due proprietà pubbliche sono ora visibili nel componente Hit Target e devono fare riferimento agli oggetti nella scena:
  • Trascinare Underworld dal pannello Hierarchy (Gerarchia ) alla proprietà Underworld (Underworld ) nel componente Hit Target (Destinazione di hit ).
  • Trascinare Stage dal pannello Hierarchy (Gerarchia ) all'oggetto per nascondere la proprietà nel componente Hit Target (Destinazione di hit ).
• Esportare, compilare e distribuire l'app.
• Posizionare la raccolta Origami sul pavimento e quindi usare il movimento Select per fare una goccia di sfera.
• Quando la sfera raggiunge il bersaglio (ventola blu), si verificherà un'esplosione. La raccolta verrà nascosta e apparirà un foro per l'mondo inferiore.

La fine

E questa è la fine di questa esercitazione!

Sono stati appresi i concetti seguenti:

• Come creare un'app olografica in Unity.
• Come usare lo sguardo fisso, il movimento, la voce, il suono e il mapping spaziale.
• Come compilare e distribuire un'app con Visual Studio.

A questo punto è possibile iniziare a creare un'esperienza olografica personalizzata.

Vedi anche

• Nozioni di base MR 101E: Progetto completo con emulatore
• Sguardo fisso
• Puntamento con la testa e commit
• Input vocale
• Audio spaziale
• Mapping spaziale