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


Wichtig

Die Mixed Reality Academy-Tutorials wurden im Hinblick auf HoloLens (1. Generation), Unity 2017 und Mixed Reality Immersive Headsets entworfen. 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.


In diesem Tutorial werden Sie durch ein vollständiges, in Unity integriertes Projekt führt, das wichtige Windows Mixed Reality Features auf HoloLens veranschaulicht, einschließlich Anverfolgen, Gesten, Spracheingabe, räumlichem Sound und räumlicher Zuordnung.

Das Tutorial dauert ungefähr eine Stunde.

Geräteunterstützung

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

Vorbereitung

Voraussetzungen

Projektdateien

  • Laden Sie die dateien herunter, die für das Projekt erforderlich sind. 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 dieses Release.
    • Wenn Sie weiterhin Unity 5.4-Unterstützung benötigen, verwenden Sie dieses Release.
  • Aufheben der Archivierung der Dateien auf Ihrem Desktop oder an einem anderen leicht zu erreichenden Speicherort. Behalten Sie den Ordnernamen Origami bei.

Hinweis

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

Kapitel 1: "Holo"-Welt

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 location 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, indem Sie FileSave / Scene As verwenden.
  • Nennen Sie die neue Szene Origami , und klicken Sie auf die Schaltfläche Speichern .

Einrichten der virtuellen Hauptkamera

  • Wählen Sie im Hierarchiebereich die Option Hauptkamera aus.
  • Legen Sie im Inspektor die Transformationsposition auf 0,0,0 fest.
  • Suchen Sie die Eigenschaft Flags löschen , 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 GameObject in OrigamiCollection um.
  • Erweitern Sie im Project Bereich im Ordner Hologramme (erweitern Sie Assets, und wählen Sie Hologramme aus, oder doppelklicken Sie im Project Bereich 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 HologrammeLights in das Stammverzeichnis des Hierarchiebereichs.
  • Wählen Sie in der Hierarchie die OrigamiCollection aus.
  • Legen Sie im Inspector die Transformationsposition auf 0, -0,5, 2,0 fest.
  • Klicken Sie in Unity auf die Schaltfläche Wiedergeben , um eine Vorschau Ihrer Hologramme anzuzeigen.
  • Die Origami-Objekte sollten im Vorschaufenster angezeigt werden.
  • Drücken Sie ein zweites Mal auf Wiedergeben , um den Vorschaumodus zu beenden.

Exportieren des Projekts aus Unity in Visual Studio

  • Wählen Sie in Unity Dateibuild > Einstellungen aus.

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

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

  • Aktivieren Sie Unity C#-Projekte.

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

  • Klicken Sie auf Erstellen.

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

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

  • Klicken Sie auf Ordner auswählen.

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

  • Öffnen Sie den Ordner App .

  • Öffnen Sie Origami.sln (Doppelklick).

  • Ä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 die Bereitstellung über WLAN zu ermöglichen.

    • 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 in Einstellungen Network Internet Advanced Options (Erweiterte Optionen für Einstellungen > Netzwerkinternet &>), oder fragen Sie Cortana "Hey Cortana, What es my IP address?" (Hey Cortana, Was ist meine IP-Adresse?).
    • Wenn die HoloLens über USB angeschlossen ist, können Sie stattdessen Gerät auswählen, das über USB bereitgestellt werden soll.
    • Belassen Sie den Authentifizierungsmodus auf Universell.
    • 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 nun erstellt, auf Ihrem HoloLens bereitgestellt und dann ausgeführt.

  • Legen Sie Ihre HoloLens an, und sehen Sie sich ihre neuen Hologramme an.

Kapitel 2 : Anv anv

In diesem Kapitel stellen wir die erste von drei Möglichkeiten vor, mit Ihren Hologrammen zu interagieren – anvieren.

Ziele

  • Visualisieren Sie Das Anvieren mithilfe eines weltweit gesperrten Cursors.

Anweisungen

  • Zurück zu Ihrem Unity-Projekt, und schließen Sie das Fenster Build Einstellungen , wenn es noch geöffnet ist.
  • Wählen Sie im bereich Project den Ordner Hologramme aus.
  • Ziehen Sie das Cursor-Objekt in den Hierarchiebereich auf der Stammebene.
  • Doppelklicken Sie auf das Cursor-Objekt , um es genauer zu betrachten.
  • Klicken Sie im Bereich Project 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: Beim Namen wird die Kleinschreibung beachtet. Sie müssen die ERWEITERUNG .cs nicht hinzufügen.
  • Wählen Sie im Bereich Hierarchie das Cursorobjekt aus.
  • Drag and drop the WorldCursor script into the Inspector panel.
  • Doppelklicken Sie auf das WorldCursor-Skript, um es in der Visual Studio.
  • Kopieren Sie diesen Code, und fügen Sie ihn in WorldCursor.cs undSave All 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 auf der Einstellungen>.
  • Kehren Sie zur Visual Studio lösung zurück, die zuvor für die Bereitstellung in Ihrer HoloLens.
  • 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 an, und beachten Sie, wie der Cursor mit der Form von Objekten interagiert.

Kapitel 3: Gesten

In diesem Kapitel fügen wir Unterstützung für Gesten hinzu. Wenn der Benutzer eine Papierkugel auswählt, lassen wir die Kugel fallen, indem wir die Schwerkraft mithilfe der Physikalischen Engine von Unity einschalten.

Ziele

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

Anweisungen

Zunächst erstellen wir ein Skript und können dann die Geste Auswählen erkennen.

  • Erstellen Sie im Ordner Skripts ein Skript mit dem Namen GazeGestureManager.
  • Ziehen Sie das Skript GazeGestureManager auf das OrigamiCollection-Objekt in der Hierarchie.
  • Öffnen Sie das GazeGestureManager-Skript 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 mit dem Namen SphereCommands.
  • Erweitern Sie das OrigamiCollection-Objekt in der Hierarchieansicht.
  • Ziehen Sie das SphereCommands-Skript auf das Objekt Sphere1 im Hierarchiebereich.
  • Ziehen Sie das SphereCommands-Skript auf das Sphere2-Objekt im Hierarchiebereich.
  • Öffnen Sie das Skript in Visual Studio, 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 Kugeln an.
  • Führen Sie die Auswahlgeste aus, und beobachten Sie, wie die Kugel auf der unteren Oberfläche abflag.

Kapitel 4: Stimme

In diesem Kapitel fügen wir Unterstützung für zwei Sprachbefehle hinzu: "Reset world" (Welt zurücksetzen), um die verworfenen Kugeln an ihren ursprünglichen Speicherort zurückzusetzen, und "Drop sphere", 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 ein, undspeichern Sie alle:
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, um es zu lesen:
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 Kugeln an, und sagen Sie "Drop Sphere".
  • Sagen Sie "Reset World", um sie wieder an ihre 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 Raumklang , um Sounds eine bestimmte Position im 3D-Raum zu geben.

Ziele

  • Hören Sie Hologramme in Ihrer Welt.

Anweisungen

  • Wählen Sie in Unity im oberen Menü Bearbeiten >> Project Einstellungen Audio aus.
  • Suchen Sie im Inspektorbereich auf der rechten Seite nach der Einstellung Spatializer-Plug-In , und wählen Sie MS HRTF Spatializer aus.
  • Ziehen Sie Hologramme Ordner im Project Bereich auf das Objekt OrigamiCollection 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 Play On Awake.
    • Ä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 Sound Einstellungen, und geben Sie 0.1 für Doppler Level ein.
    • Legen Sie Volumerolloff auf Logarithmischer Rolloff fest.
    • Legen Sie Max Distance auf 20 fest.
  • Erstellen Sie im Ordner Skripts ein Skript mit dem Namen SphereSounds.
  • Drag and drop SphereSounds to the Sphere1 and Sphere2 objects in the Hierarchy.
  • Ö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 von der Stufe immer weiter, und drehen Sie sich nebeneinander, um zu hören, wie sich die Sounds ändern.

Kapitel 6: Räumliche Zuordnung

Nun verwenden wir die räumliche Zuordnung , 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 Hologramme auf Project Ordner .
  • Ziehen Sie das Objekt Spatial Mapping 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 Gitternetze zeichnen .
    • Suchen Sie Material zeichnen , und klicken Sie auf den Kreis auf der rechten Seite. Geben Sie oben im Suchfeld "wireframe" 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 Drahtmodellgittermodell Ihre reale Welt.
  • Sehen Sie sich an, wie eine rollierende Kugel von der Stufe 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 Skript TapToPlaceParent auf das Stage-Objekt.
  • Öffnen Sie das Skript TapToPlaceParent 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.
  • Nun sollten Sie das Spiel an einem bestimmten Ort platzieren können, indem Sie es an einer bestimmten Position platzieren, indem Sie die Geste Auswählen verwenden und dann an eine neue Position verschieben und die Geste Auswählen erneut verwenden.

Kapitel 7: Holografischer Spaß

Ziele

  • Verraten Sie den Eingang einer holografischen Unterwelt.

Anweisungen

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

  • Im ordner Hologramme im Project Panel:
    • Ziehen Sie Underworld 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 Komponente Trefferziel sichtbar und müssen auf Objekte in unserer Szene verweisen:
    • Ziehen Sie Underworld aus dem Hierarchiebereich in die Underworld-Eigenschaft der Komponente Ziel erreichen .
    • Ziehen Sie Stage aus dem Hierarchiebereich in die Eigenschaft Object to Hide (Objekt zum Ausblenden ) der Komponente "Ziel erreichen ".
  • Exportieren, Erstellen und Bereitstellen der App.
  • Platzieren Sie die Origami-Sammlung auf dem Boden, und verwenden Sie dann die Select-Geste, um einen Kugelablage zu erstellen.
  • Wenn die Kugel auf das Ziel trifft (blauer Lüfter), kommt es zu einer Explosion. Die Auflistung wird ausgeblendet, und eine Lücke zur Unterwelt wird angezeigt.

Das Ende

Und das ist das Ende dieses Tutorials!

Sie haben Folgendes gelernt:

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

Sie können nun mit dem Erstellen Ihrer eigenen holografischen Erfahrung beginnen!

Siehe auch