HoloLens (1. Generation) Grundlagen 101: Projekt mit Gerät abschließen

Wichtig

Die Mixed Reality Academy-Tutorials wurden unter Berücksichtigung von HoloLens (1. Generation), Unity 2017 und Mixed Reality Immersive Headsets entwickelt. Daher halten wir es für wichtig, diese Tutorials für Entwickler verfügbar zu halten, die noch nach Anleitung beim Entwickeln für diese Geräte suchen. Diese Tutorials werden nicht mit den neuesten Toolsets oder Interaktionen aktualisiert, die für HoloLens 2 verwendet werden, und sind möglicherweise nicht mit neueren Versionen von Unity kompatibel. Sie werden gewartet, um weiterhin auf den unterstützten Geräten zu funktionieren. Es wurde eine neue Reihe von Tutorials für HoloLens 2 veröffentlicht.

Dieses Tutorial führt Sie durch ein vollständiges Projekt, das in Unity erstellt wurde und die wichtigsten Windows Mixed Reality Features von HoloLens veranschaulicht, einschließlich Blick, Gesten, Spracheingabe, Räumlicher Sound und räumlicher Zuordnung.

Das Tutorial dauert etwa eine Stunde.

Geräteunterstützung

Kurs	HoloLens	Immersive Headsets
MR-Grundlagen 101: Vollständiges Projekt mit Gerät	✔️

Vorbereitung

Voraussetzungen

• Ein Windows 10-PC, der mit den richtigen Tools konfiguriert ist.
• Ein HoloLens-Gerät , das für die Entwicklung konfiguriert ist.

Projektdateien

• Laden Sie die für das Projekt erforderlichen Dateien herunter. Erfordert Unity 2017.2 oder höher.
  • Wenn Sie weiterhin Unity 5.6-Unterstützung benötigen, verwenden Sie dieses Release.
  • Wenn Sie weiterhin Unity 5.5-Unterstützung benötigen, verwenden Sie bitte dieses Release.
  • Wenn Sie weiterhin Unity 5.4-Unterstützung benötigen, verwenden Sie diese Version.
• Heben Sie die Archivierung der Dateien auf Ihrem Desktop oder einem anderen leicht zu erreichenden Speicherort auf. Behalten Sie den Ordnernamen als Origami bei.

Hinweis

Wenn Sie den Quellcode vor dem Herunterladen durchsehen möchten, ist er auf GitHub verfügbar.

Kapitel 1 : Holowelt

In diesem Kapitel richten wir unser erstes Unity-Projekt ein und durchlaufen den Build- und Bereitstellungsprozess.

Ziele

• Richten Sie Unity für die holografische Entwicklung ein.
• Erstellen Sie ein Hologramm.
• Sehen Sie sich ein Hologramm an, das Sie erstellt haben.

Anweisungen

• Starten Sie Unity.
• Klicken Sie auf Öffnen.
• Geben Sie den Speicherort als Origami-Ordner ein, den Sie zuvor nicht archiviert haben.
• Wählen Sie Origami aus, und klicken Sie auf Ordner auswählen.
• Da das Origami-Projekt keine Szene enthält, speichern Sie die leere Standardszene in einer neuen Datei mit: Datei / speichern Szene unter.
• Nennen Sie die neue Szene Origami , und drücken Sie die Schaltfläche Speichern .

Einrichten der Standard virtuellen Kamera

• Wählen Sie im Hierarchiebereich die Option Hauptkamera aus.
• Legen Sie im Inspector die Transformationsposition auf 0,0,0 fest.
• Suchen Sie die Clear Flags-Eigenschaft , und ändern Sie die Dropdownliste von Skybox in Volltonfarbe.
• Klicken Sie auf das Feld Hintergrund, um eine Farbauswahl zu öffnen.
• Legen Sie R, G, B und A auf 0 fest.

Einrichten der Szene

• Klicken Sie im Hierarchiebereich auf Erstellen und Leer erstellen.
• Klicken Sie mit der rechten Maustaste auf das neue GameObject, und wählen Sie Umbenennen aus. Benennen Sie das GameObject in OrigamiCollection um.
• Erweitern Sie im Projektbereich im Ordner Hologramme (erweitern Sie Objekte, und wählen Sie Hologramme aus, oder doppelklicken Sie im Projektbereich auf den Ordner Hologramme):
  • Ziehen Sie Stage in die Hierarchie, um ein untergeordnetes Element von OrigamiCollection zu sein.
  • Ziehen Sie Sphere1 in die Hierarchie, um ein untergeordnetes Element von OrigamiCollection zu sein.
  • Ziehen Sie Sphere2 in die Hierarchie, um ein untergeordnetes Element von OrigamiCollection zu sein.
• Klicken Sie im Hierarchiebereich mit der rechten Maustaste auf das Objekt Directional Light, und wählen Sie Löschen aus.
• Ziehen Sie aus dem Ordner HologrammeLichter in den Stamm des Hierarchiebereichs.
• Wählen Sie in der Hierarchie die OrigamiCollection aus.
• Legen Sie im Inspector die Transformationsposition auf 0, -0.5, 2.0 fest.
• Drücken Sie die Schaltfläche Wiedergabe in Unity, um eine Vorschau Ihrer Hologramme anzuzeigen.
• Die Origami-Objekte sollten im Vorschaufenster angezeigt werden.
• Drücken Sie ein zweites Mal wiedergeben , um den Vorschaumodus zu beenden.

Exportieren des Projekts aus Unity nach Visual Studio

• Wählen Sie in Unity Dateibuildeinstellungen >aus.

• Wählen Sie in der Liste Plattform Universelle Windows-Plattform aus, und klicken Sie auf Plattform wechseln.

• Legen Sie sdk auf Universal 10 und Buildtyp auf D3D fest.

• Überprüfen Sie Unity C#-Projekte.

• Klicken Sie auf Offene Szenen hinzufügen , um die Szene hinzuzufügen.

• Klicken Sie auf Erstellen.

• Erstellen Sie im daraufhin angezeigten Datei-Explorer-Fenster einen neuen Ordner mit dem Namen "App".

• Klicken Sie mit einem Klick auf den App-Ordner.

• Drücken Sie Ordner auswählen.

• Wenn Unity fertig ist, wird ein Explorer Fenster angezeigt.

• Öffnen Sie den Ordner App .

• Öffnen (Doppelklicken) Origami.sln.

• Ändern Sie mithilfe der oberen Symbolleiste in Visual Studio das Ziel von Debuggen in Release und von ARM in X86.

• Klicken Sie auf den Pfeil neben der Schaltfläche Gerät, und wählen Sie Remotecomputer aus, um über WLAN bereitzustellen.

  • Legen Sie die Adresse auf den Namen oder die IP-Adresse Ihrer HoloLens fest. Wenn Sie Ihre Geräte-IP-Adresse nicht kennen, suchen Sie unter Einstellungen > Netzwerk & Internet > Erweiterte Optionen , oder fragen Sie Cortana : "Hey Cortana, Was ist meine IP-Adresse?".
  • Wenn holoLens über USB angeschlossen ist, können Sie stattdessen Gerät auswählen, das über USB bereitgestellt werden soll.
  • Lassen Sie den Authentifizierungsmodus auf Universell festgelegt.
  • Klicken Sie auf Auswählen.

• Klicken Sie auf Debuggen > starten ohne Debuggen , oder drücken Sie STRG+F5. Wenn dies die erste Bereitstellung auf Ihrem Gerät ist, müssen Sie es mit Visual Studio koppeln.

• Das Origami-Projekt wird jetzt erstellt, in Ihrer HoloLens bereitgestellt und dann ausgeführt.

• Legen Sie Ihre HoloLens an, und schauen Sie sich um, um Ihre neuen Hologramme zu sehen.

Kapitel 2 : Blick

In diesem Kapitel stellen wir ihnen die erste von drei Möglichkeiten der Interaktion mit Ihren Hologrammen vor : Blick.

Ziele

• Visualisieren Sie Ihren Blick mit einem weltgebundenen Cursor.

Anweisungen

• Zurück zu Ihrem Unity-Projekt, und schließen Sie das Fenster Buildeinstellungen, wenn es noch geöffnet ist.
• Wählen Sie im Projektbereich den Ordner Hologramme aus.
• Ziehen Sie das Cursor-Objekt auf Stammebene in den Hierarchiebereich .
• Doppelklicken Sie auf das Cursor-Objekt , um es genauer zu betrachten.
• Klicken Sie im Projektbereich mit der rechten Maustaste auf den Ordner Skripts .
• Klicken Sie auf das Untermenü Erstellen .
• Wählen Sie C#-Skript aus.
• Nennen Sie das Skript WorldCursor. Hinweis: Bei dem Namen wird die Groß-/Kleinschreibung beachtet. Sie müssen die CS-Erweiterung nicht hinzufügen.
• Wählen Sie im Hierarchiebereich das Cursor-Objekt aus.
• Ziehen Sie das WorldCursor-Skript in den Inspektorbereich, und legen Sie es ab.
• Doppelklicken Sie auf das Skript WorldCursor , um es in Visual Studio zu öffnen.
• Kopieren Sie diesen Code, und fügen Sie ihn in WorldCursor.cs und Alle speichern ein.

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;
        }
    }
}

• Erstellen Sie die App über die Dateibuildeinstellungen >neu.
• Kehren Sie zur Visual Studio-Projektmappe zurück, die zuvor für die Bereitstellung in Ihrer HoloLens verwendet wurde.
• Wählen Sie "Alle erneut laden" aus, wenn Sie dazu aufgefordert werden.
• Klicken Sie auf Debuggen –> Starten ohne Debuggen , oder drücken Sie STRG+F5.
• Sehen Sie sich nun die Szene um, und stellen Sie fest, wie der Cursor mit der Form von Objekten interagiert.

Kapitel 3: Gesten

In diesem Kapitel wird unterstützung für Gesten hinzugefügt. Wenn der Benutzer eine Papierkugel auswählt, lassen wir die Kugel fallen, indem wir die Schwerkraft mithilfe der Physik-Engine von Unity einschalten.

Ziele

• Steuern Sie Ihre Hologramme mit der Geste Auswählen.

Anweisungen

Wir beginnen mit der Erstellung eines Skripts und können dann die Geste Auswählen erkennen.

• Erstellen Sie im Ordner Skripts ein Skript mit dem Namen GazeGestureManager.
• Ziehen Sie das GazeGestureManager-Skript auf das OrigamiCollection-Objekt in der Hierarchie.
• Öffnen Sie das Skript GazeGestureManager in Visual Studio, und fügen Sie den folgenden Code hinzu:

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();
        }
    }
}

• Erstellen Sie im Ordner Skripts ein weiteres Skript, diesmal mit dem Namen SphereCommands.
• Erweitern Sie das OrigamiCollection-Objekt in der Hierarchieansicht.
• Ziehen Sie das Skript SphereCommands im Hierarchiebereich auf das Sphere1-Objekt .
• Ziehen Sie das Skript SphereCommands auf das Sphere2-Objekt im Hierarchiebereich.
• Öffnen Sie das Skript in Visual Studio zur Bearbeitung, und ersetzen Sie den Standardcode durch folgendes:

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;
        }
    }
}

• Exportieren, Erstellen und Bereitstellen der App in HoloLens.
• Sehen Sie sich eine der Sphären an.
• Führen Sie die Auswahlgeste aus, und watch sie die Kugel auf die darunter stehende Oberfläche fallen.

Kapitel 4 : Stimme

In diesem Kapitel werden zwei Sprachbefehle unterstützt: "Welt zurücksetzen", um die abgelegten Kugeln an ihren ursprünglichen Standort zurückzugeben, und "Kugel ablegen", um die Kugel fallen zu lassen.

Ziele

• Fügen Sie Sprachbefehle hinzu, die immer im Hintergrund lauschen.
• Erstellen Sie ein Hologramm, das auf einen Sprachbefehl reagiert.

Anweisungen

• Erstellen Sie im Ordner Skripts ein Skript mit dem Namen SpeechManager.
• Ziehen Sie das SpeechManager-Skript auf das OrigamiCollection-Objekt in der Hierarchie.
• Öffnen Sie das SpeechManager-Skript in Visual Studio.
• Kopieren Sie diesen Code, und fügen Sie ihn in SpeechManager.cs und Alle speichern ein:

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();
        }
    }
}

• Öffnen Sie das SphereCommands-Skript in Visual Studio.
• Aktualisieren Sie das Skript wie folgt:

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();
    }
}

• Exportieren, Erstellen und Bereitstellen der App in HoloLens.
• Sehen Sie sich eine der Sphären an, und sagen Sie "Drop Sphere".
• Sagen Sie "Reset World", um sie wieder zu ihren ursprünglichen Positionen zu bringen.

Kapitel 5 : Raumklang

In diesem Kapitel fügen wir der App Musik hinzu und lösen dann Soundeffekte für bestimmte Aktionen aus. Wir verwenden räumlichen Sound , um Sounds an einem bestimmten Ort im 3D-Raum zu geben.

Ziele

• Hören Sie Hologramme in Ihrer Welt.

Anweisungen

• Wählen Sie in Unity im oberen Menü Projekteinstellungen > audio bearbeiten > aus.
• Suchen Sie im Inspektorbereich auf der rechten Seite die Einstellung Spatializer-Plug-In , und wählen Sie MS HRTF Spatializer aus.
• Ziehen Sie aus dem Ordner Hologramme im Projektbereich das Objekt Ambient auf das OrigamiCollection-Objekt im Hierarchiebereich.
• Wählen Sie OrigamiCollection aus, und suchen Sie im Inspektorbereich nach der Komponente Audioquelle . Ändern Sie diese Eigenschaften:
  • Überprüfen Sie die Spatialize-Eigenschaft .
  • Überprüfen Sie die Option Play On Awake (Bei Wach wiedergeben).
  • Ändern Sie Spatial Blend in 3D , indem Sie den Schieberegler ganz nach rechts ziehen. Der Wert sollte sich von 0 in 1 ändern, wenn Sie den Schieberegler verschieben.
  • Überprüfen Sie die Loop-Eigenschaft .
  • Erweitern Sie 3D-Soundeinstellungen, und geben Sie 0.1 für Doppler Level ein.
  • Legen Sie volume rolloff auf Logarithmic Rolloff fest.
  • Legen Sie Max Distance auf 20 fest.
• Erstellen Sie im Ordner Skripts ein Skript mit dem Namen SphereSounds.
• Ziehen Sie SphereSounds in die Objekte Sphere1 und Sphere2 in der Hierarchie.
• Öffnen Sie SphereSounds in Visual Studio, aktualisieren Sie den folgenden Code, und speichern Sie alle.

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();
        }
    }
}

• Speichern Sie das Skript, und kehren Sie zu Unity zurück.
• Exportieren, Erstellen und Bereitstellen der App in HoloLens.
• Bewegen Sie sich näher und weiter von der Bühne, und drehen Sie sich von Seite zu Seite, um zu hören, dass sich die Sounds ändern.

Kapitel 6: Räumliche Zuordnung

Jetzt werden wir die räumliche Zuordnung verwenden, um das Spielbrett auf einem realen Objekt in der realen Welt zu platzieren.

Ziele

• Bringen Sie Ihre reale Welt in die virtuelle Welt.
• Platzieren Sie Ihre Hologramme dort, wo sie für Sie am wichtigsten sind.

Anweisungen

• Klicken Sie in Unity im Projektbereich auf den Ordner Hologramme .
• Ziehen Sie das Objekt Räumliche Zuordnung in den Stamm der Hierarchie.
• Klicken Sie in der Hierarchie auf das Objekt Räumliche Zuordnung .
• Ändern Sie im Bereich Inspektor die folgenden Eigenschaften:
  • Aktivieren Sie das Kontrollkästchen Visuelle Gitter zeichnen .
  • Suchen Sie Nach Zeichnungsmaterial , und klicken Sie auf den Kreis auf der rechten Seite. Geben Sie "wireframe" in das Suchfeld oben ein. Klicken Sie auf das Ergebnis, und schließen Sie dann das Fenster. Wenn Sie dies tun, sollte der Wert für Draw Material auf Wireframe festgelegt werden.
• Exportieren, Erstellen und Bereitstellen der App in HoloLens.
• Wenn die App ausgeführt wird, überlagert ein Drahtmodellnetz Ihre reale Welt.
• Beobachten Sie, wie eine rollierende Kugel von der Bühne und auf den Boden fällt!

Nun zeigen wir Ihnen, wie Sie die OrigamiCollection an einen neuen Speicherort verschieben:

• Erstellen Sie im Ordner Skripts ein Skript mit dem Namen TapToPlaceParent.
• Erweitern Sie in der Hierarchie die OrigamiCollection , und wählen Sie das Stage-Objekt aus.
• Ziehen Sie das TapToPlaceParent-Skript auf das Stage-Objekt.
• Öffnen Sie das TapToPlaceParent-Skript in Visual Studio, und aktualisieren Sie es wie folgt:

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;
            }
        }
    }
}

• Exportieren, Erstellen und Bereitstellen der App.
• Jetzt sollten Sie in der Lage sein, das Spiel an einer bestimmten Stelle zu platzieren, indem Sie es betrachten, die Geste Auswählen verwenden und dann an eine neue Position wechseln und erneut die Geste Auswählen verwenden.

Kapitel 7 : Holografischer Spaß

Ziele

• Zeigen Sie den Eingang zu einer holografischen Unterwelt.

Anweisungen

Nun zeigen wir Ihnen, wie Sie die holografische Unterwelt aufdecken:

• Aus dem Ordner Hologramme im Projektbereich:
  • Ziehen Sie Unterwelt in die Hierarchie, um ein untergeordnetes Element von OrigamiCollection zu sein.
• Erstellen Sie im Ordner Skripts ein Skript mit dem Namen HitTarget.
• Erweitern Sie in der Hierarchie die OrigamiCollection.
• Erweitern Sie das Stage-Objekt , und wählen Sie das Zielobjekt (blauer Lüfter) aus.
• Ziehen Sie das HitTarget-Skript auf das Target-Objekt .
• Öffnen Sie das HitTarget-Skript in Visual Studio, und aktualisieren Sie es wie folgt:

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;
    }
}

• Wählen Sie in Unity das Zielobjekt aus.
• Zwei öffentliche Eigenschaften sind jetzt in der Hit Target-Komponente sichtbar und müssen auf Objekte in unserer Szene verweisen:
  • Ziehen Sie Underworld aus dem Hierarchiebereich in die Underworld-Eigenschaft der Komponente Trefferziel .
  • Ziehen Sie Stage aus dem Hierarchiebereich auf die Eigenschaft Objekt ausblenden für die Komponente Trefferziel .
• Exportieren, Erstellen und Bereitstellen der App.
• Platzieren Sie die Origami-Sammlung auf dem Boden, und verwenden Sie dann die Geste Auswählen, um eine Kugel zu löschen.
• Wenn die Kugel auf das Ziel trifft (blauer Lüfter), tritt eine Explosion auf. Die Sammlung wird ausgeblendet, und ein Loch in die Unterwelt wird angezeigt.

Das Ende

Und das ist das Ende dieses Tutorials!

Sie haben Folgendes gelernt:

• Erstellen einer holografischen App in Unity
• Verwenden von Blick, Geste, Stimme, Sound und räumlicher Zuordnung
• Erstellen und Bereitstellen einer App mit Visual Studio

Sie sind jetzt bereit, Mit der Erstellung Ihrer eigenen holografischen Erfahrung zu beginnen!

Weitere Informationen

• MR-Grundlagen 101E: Vollständiges Projekt mit Emulator
• Anvisieren
• Anvisieren mit dem Kopf und Ausführen
• Spracheingabe
• Raumklang
• Räumliche Abbildung