HoloLens (1. Generation) und Azure 305: Funktionen und Speicher


Hinweis

Die Tutorials der Mixed Reality Academy wurden im Hinblick auf HoloLens (1. Gen.) und immersive Mixed Reality-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. Sie werden gewartet, um weiterhin auf den unterstützten Geräten zu funktionieren. Es wird eine neue Reihe von Lernprogrammen geben, die zukünftig veröffentlicht werden, die zeigen, wie sie für HoloLens 2 entwickelt werden. Diese Benachrichtigung wird mit einem Link zu diesen Lernprogrammen aktualisiert, wenn sie veröffentlicht werden.


Endprodukt -Start

In diesem Kurs erfahren Sie, wie Sie Azure Functions Erstellen und Speichern von Daten mit einer Azure Storage-Ressource in einer Mixed Reality-Anwendung erstellen und verwenden.

Azure Functions ist ein Microsoft-Dienst, mit dem Entwickler kleine Codeteile, "Funktionen" in Azure ausführen können. Dies bietet eine Möglichkeit, Arbeit an die Cloud zu delegieren, anstatt ihre lokale Anwendung, die viele Vorteile haben kann. Azure Functions unterstützt mehrere Entwicklungssprachen, einschließlich C#, F#, Node.js, Java und PHP. Weitere Informationen finden Sie im Azure Functions Artikel.

Azure Storage ist ein Microsoft-Clouddienst, mit dem Entwickler Daten speichern können, mit der Versicherung, dass es hoch verfügbar, sicher, langlebig, skalierbare und redundant ist. Dies bedeutet, dass Microsoft alle Wartungs- und kritischen Probleme für Sie verarbeitet. Weitere Informationen finden Sie im Azure Storage-Artikel.

Nachdem Sie diesen Kurs abgeschlossen haben, verfügen Sie über eine immersive Mixed Reality-Headset-Anwendung, die folgende Aktionen ausführen kann:

  1. Erlauben Sie dem Benutzer, sich um eine Szene zu blicken.
  2. Lösen Sie den Spawning von Objekten aus, wenn der Benutzer auf eine 3D-Schaltfläche blickt.
  3. Die Spawned-Objekte werden von einer Azure-Funktion ausgewählt.
  4. Da jedes Objekt spawned wird, speichert die Anwendung den Objekttyp in einer Azure-Datei, die sich in Azure Storage befindet.
  5. Beim Laden eines zweiten Mal werden die Azure-Dateidaten abgerufen und verwendet, um die Spawningaktionen aus der vorherigen Instanz der Anwendung wiederzugeben.

In Ihrer Anwendung liegt es ihnen bei der Integration der Ergebnisse in Ihr Design. Dieser Kurs soll Ihnen vermitteln, wie Sie einen Azure-Dienst in Ihr Unity-Projekt integrieren. Es ist Ihre Aufgabe, das Wissen zu nutzen, das Sie von diesem Kurs erhalten, um Ihre Mixed Reality-Anwendung zu verbessern.

Geräteunterstützung

Kurs HoloLens Immersive Headsets
MR und Azure 305: Funktionen und Speicher ✔️ ✔️

Hinweis

Während sich dieser Kurs hauptsächlich auf Windows Mixed Reality immersiven Headsets (VR) konzentriert, können Sie auch das, was Sie in diesem Kurs lernen, auf Microsoft HoloLens anwenden. Während Sie den Kurs befolgen, werden Notizen zu allen Änderungen angezeigt, die Sie möglicherweise zum Unterstützen von HoloLens verwenden müssen.

Voraussetzungen

Hinweis

Dieses Lernprogramm wurde für Entwickler entwickelt, die grundlegende Erfahrungen mit Unity und C# haben. Bitte beachten Sie auch, dass die Voraussetzungen und schriftlichen Anweisungen in diesem Dokument darstellen, was zum Zeitpunkt des Schreibens getestet und überprüft wurde (Mai 2018). Sie sind kostenlos, die neueste Software zu verwenden, wie im Artikel zur Installation der Tools aufgeführt, aber es sollte nicht angenommen werden, dass die Informationen in diesem Kurs perfekt mit dem übereinstimmen, was Sie in neuerer Software finden werden als die unten aufgeführten.

Wir empfehlen die folgende Hardware und Software für diesen Kurs:

Vorbereitung

Um probleme beim Erstellen dieses Projekts zu vermeiden, wird dringend empfohlen, dass Sie das in diesem Lernprogramm erwähnte Projekt in einem Stamm- oder Nahstammordner erstellen (lange Ordnerpfade können probleme beim Buildzeit verursachen).

Kapitel 1 – Das Azure-Portal

Um den Azure Storage Service zu verwenden, müssen Sie ein Speicherkonto im Azure-Portal erstellen und konfigurieren.

  1. Melden Sie sich beim Azure-Portal an.

    Hinweis

    Wenn Sie noch kein Azure-Konto haben, müssen Sie ein Konto erstellen. Wenn Sie diesem Lernprogramm in einer Unterrichts- oder Laborsituation folgen, bitten Sie Ihren Kursleiter oder einen der Proktoren, hilfe beim Einrichten Ihres neuen Kontos.

  2. Sobald Sie angemeldet sind, klicken Sie in der oberen linken Ecke auf "Neu ", und suchen Sie nach Speicherkonto, und klicken Sie auf 'EINGABETASTE'.

    Azure Storage Search

    Hinweis

    Das Wort "Neu " wurde möglicherweise durch "Ressource erstellen" in neueren Portalen ersetzt.

  3. Die neue Seite enthält eine Beschreibung des Azure Storage-Kontodiensts . Wählen Sie unten links neben dieser Eingabeaufforderung die Schaltfläche "Erstellen" aus, um eine Zuordnung mit diesem Dienst zu erstellen.

    Dienst erstellen

  4. Nachdem Sie auf "Erstellen" geklickt haben:

    1. Fügen Sie einen Namen für Ihr Konto ein, beachten Sie, dass dieses Feld nur Zahlen akzeptiert, und Kleinbuchstaben.

    2. Wählen Sie für das Bereitstellungsmodellden Ressourcen-Manager aus.

    3. Wählen Sie für "Kontotyp" die Option "Speicher" (allgemeiner Zweck v1) aus.

    4. Bestimmen Sie den Speicherort für Ihre Ressourcengruppe (wenn Sie eine neue Ressourcengruppe erstellen). Der Standort wäre idealerweise in der Region, in der die Anwendung ausgeführt wird. Einige Azure-Ressourcen sind nur in bestimmten Regionen verfügbar.

    5. Wählen Sie für replikationsbasierten Read-access-geo-redundant storage (RA-GRS) aus.

    6. Wählen Sie für Leistung die Option Standard aus.

    7. Lassen Sie die sichere Übertragung als deaktiviert erforderlich.

    8. Wählen Sie ein Abonnementaus.

    9. Wählen Sie eine Ressourcengruppe aus, oder erstellen Sie eine neue. Eine Ressourcengruppe bietet eine Möglichkeit, die Abrechnung für eine Sammlung von Azure-Ressourcen zu überwachen, zu steuern, den Zugriff zu steuern, bereitzustellen und zu verwalten. Es wird empfohlen, alle Azure-Dienste, die einem einzelnen Projekt zugeordnet sind (z. B. diese Labs), unter einer gemeinsamen Ressourcengruppe zu halten.

      Wenn Sie mehr über Azure-Ressourcengruppen lesen möchten, besuchen Sie bitte den Artikel zur Ressourcengruppe.

    10. Sie müssen auch bestätigen, dass Sie die auf diesen Dienst angewendeten Geschäftsbedingungen verstanden haben.

    11. Klicken Sie auf Erstellen.

      Eingabedienstinformationen

  5. Nachdem Sie auf "Erstellen" geklickt haben, müssen Sie warten, bis der Dienst erstellt wird. Dies kann eine Minute dauern.

  6. Eine Benachrichtigung wird im Portal angezeigt, sobald die Dienstinstanz erstellt wurde.

    Neue Benachrichtigung im Azure-Portal

  7. Klicken Sie auf die Benachrichtigungen, um Ihre neue Dienstinstanz zu erkunden.

    Zur Ressource wechseln

  8. Klicken Sie in der Benachrichtigung auf die Schaltfläche " Zur Ressource wechseln ", um Ihre neue Dienstinstanz zu erkunden. Sie werden zu Ihrer neuen Speicherkontodienstinstanz weitergeleitet.

    Zugriffstasten

  9. Klicken Sie auf Zugriffstasten, um die Endpunkte für diesen Clouddienst anzuzeigen. Verwenden Sie Editor oder ähnliches, um eine Ihrer Tasten später zu kopieren. Beachten Sie außerdem den Verbindungszeichenfolgenwert , da er in der AzureServices-Klasse verwendet wird, die Sie später erstellen.

    Verbindungszeichenfolge kopieren

Kapitel 2 – Einrichten einer Azure-Funktion

Sie schreiben nun eine Azure-Funktion im Azure-Dienst.

Sie können eine Azure-Funktion verwenden, um nahezu alles zu tun, was Sie mit einer klassischen Funktion in Ihrem Code tun würden. Der Unterschied ist, dass auf diese Funktion von jeder Anwendung zugegriffen werden kann, die über Anmeldeinformationen für den Zugriff auf Ihr Azure-Konto verfügt.

So erstellen Sie eine Azure-Funktion:

  1. Klicken Sie im Azure-Portal in der oberen linken Ecke auf "Neu ", und suchen Sie nach Funktions-App, und klicken Sie auf "Eingabetaste".

    Funktions-App erstellen

    Hinweis

    Das Wort "Neu " wurde möglicherweise durch "Ressource erstellen" in neueren Portalen ersetzt.

  2. Die neue Seite enthält eine Beschreibung des Azure Function App-Diensts . Wählen Sie unten links neben dieser Eingabeaufforderung die Schaltfläche "Erstellen" aus, um eine Zuordnung mit diesem Dienst zu erstellen.

    Funktions-App-Informationen

  3. Nachdem Sie auf "Erstellen" geklickt haben:

    1. Geben Sie einen App-Namen an. Hier können nur Buchstaben und Zahlen verwendet werden (Groß- oder Kleinschreibung ist zulässig).

    2. Wählen Sie Ihr bevorzugtes Abonnement aus.

    3. Wählen Sie eine Ressourcengruppe aus, oder erstellen Sie eine neue. Eine Ressourcengruppe bietet eine Möglichkeit, die Abrechnung für eine Sammlung von Azure-Ressourcen zu überwachen, zu steuern, den Zugriff zu steuern, bereitzustellen und zu verwalten. Es wird empfohlen, alle Azure-Dienste, die einem einzelnen Projekt zugeordnet sind (z. B. diese Labs), unter einer gemeinsamen Ressourcengruppe zu halten.

      Wenn Sie mehr über Azure-Ressourcengruppen lesen möchten, besuchen Sie bitte den Artikel zur Ressourcengruppe.

    4. Wählen Sie für diese Übung Windows als ausgewähltes Betriebssystem aus.

    5. Wählen Sie den Verbrauchsplan für den Hostingplan aus.

    6. Bestimmen Sie den Speicherort für Ihre Ressourcengruppe (wenn Sie eine neue Ressourcengruppe erstellen). Der Standort wäre idealerweise in der Region, in der die Anwendung ausgeführt wird. Einige Azure-Ressourcen sind nur in bestimmten Regionen verfügbar. Wählen Sie für optimale Leistung denselben Bereich wie das Speicherkonto aus.

    7. Wählen Sie für "Speicher" die Option "Vorhandenes Verwenden" aus, und suchen Sie dann mithilfe des Dropdownmenüs Ihren zuvor erstellten Speicher.

    8. Lassen Sie Application Insights für diese Übung deaktiviert.

      Details der Eingabefunktion

  4. Klicken Sie auf die Schaltfläche Erstellen .

  5. Nachdem Sie auf "Erstellen" geklickt haben, müssen Sie warten, bis der Dienst erstellt wird. Dies kann eine Minute dauern.

  6. Eine Benachrichtigung wird im Portal angezeigt, sobald die Dienstinstanz erstellt wurde.

    Neue Azure-Portalbenachrichtigung

  7. Klicken Sie auf die Benachrichtigungen, um Ihre neue Dienstinstanz zu erkunden.

    Zur Ressourcenfunktions-App wechseln

  8. Klicken Sie in der Benachrichtigung auf die Schaltfläche " Zur Ressource wechseln ", um Ihre neue Dienstinstanz zu erkunden. Sie werden zur neuen Funktions-App-Dienstinstanz weitergeleitet.

  9. Zeigen Sie im Funktions-App-Dashboard mit der Maus auf Funktionen, die sich im Bereich auf der linken Seite befinden, und klicken Sie dann auf das Symbol + (Plus).

    neue Funktion erstellen

  10. Stellen Sie auf der nächsten Seite sicher, dass Webhook + API ausgewählt ist, und wählen Sie für " Sprache auswählen"CSharp aus, da dies die für dieses Lernprogramm verwendete Sprache ist. Klicken Sie schließlich auf die Schaltfläche " Diese Funktion erstellen ".

    Web-Hook-Csharp auswählen

  11. Sie sollten zur Codeseite (run.csx) gelangen, falls nicht, klicken Sie jedoch auf die neu erstellte Funktion in der Liste "Funktionen" im Bereich links.

    neue Funktion öffnen

  12. Kopieren Sie den folgenden Code in Ihre Funktion. Diese Funktion gibt einfach eine zufällige ganze Zahl zwischen 0 und 2 zurück, wenn sie aufgerufen wird. Machen Sie sich keine Gedanken über den vorhandenen Code, fühlen Sie sich frei, über den Oberen des Codes einzufügen.

        using System.Net;
        using System.Threading.Tasks;
    
        public static int Run(CustomObject req, TraceWriter log)
        {
            Random rnd = new Random();
            int randomInt = rnd.Next(0, 3);
            return randomInt;
        }
    
        public class CustomObject
        {
            public String name {get; set;}
        }
    
  13. Wählen Sie Speichern aus.

  14. Das Ergebnis sollte wie das bild unten aussehen.

  15. Klicken Sie auf "Funktions-URL abrufen ", und notieren Sie sich den angezeigten Endpunkt . Sie müssen sie in die AzureServices-Klasse einfügen, die Sie später in diesem Kurs erstellen.

    Abrufen des Funktionsendpunkts

    Endpunkt der Funktion einfügen

Kapitel 3 – Einrichten des Unity-Projekts

Im Folgenden ist eine typische Einrichtung für die Entwicklung mit Mixed Reality und beispielsweise eine gute Vorlage für andere Projekte.

Richten Sie Ihr immersives Mixed Reality-Headset ein und testen Sie es.

Hinweis

Für diesen Kurs benötigen Sie keine Bewegungscontroller. Wenn Sie Unterstützung beim Einrichten des immersiven Headsets benötigen, besuchen Sie bitte den Mixed Reality-Einrichtungsartikel.

  1. Öffnen Sie Unity, und klicken Sie auf "Neu".

    Neues Unity-Projekt erstellen

  2. Sie müssen jetzt einen Unity-Projektnamen angeben. Fügen Sie MR_Azure_Functions ein. Stellen Sie sicher, dass der Projekttyp auf 3D festgelegt ist. Legen Sie den Speicherort an einer beliebigen Stelle fest, die für Sie geeignet ist (denken Sie daran, dass die Stammverzeichnisse besser sind). Klicken Sie dann auf "Projekt erstellen".

    Neues Unity-Projekt einen Namen geben

  3. Wenn Unity geöffnet ist, empfiehlt es sich, den Standardskript-Editor auf Visual Studio festzulegen. Wechseln Sie zu "Einstellungen bearbeiten">, und navigieren Sie dann im neuen Fenster zu "Externe Tools". Ändern des externen Skript-Editors in Visual Studio 2017. Schließen Sie das Fenster "Einstellungen" .

    Festlegen von Visual Studio als Skript-Editor

  4. Wechseln Sie als Nächstes zu "Dateibuildeinstellungen>", und wechseln Sie zu Universelle Windows-Plattform, indem Sie auf die Schaltfläche "Plattform wechseln" klicken.

    Plattform zu UWP wechseln

  5. Wechseln Sie zu DenDateibuildeinstellungen>, und stellen Sie sicher, dass:

    1. Zielgerät ist auf "Beliebiges Gerät" festgelegt.

      Legen Sie für Microsoft HoloLens Zielgerät auf HoloLens fest.

    2. Buildtyp ist auf D3D festgelegt

    3. SDK ist auf "Neueste Installation" festgelegt.

    4. Visual Studio-Version ist auf "Neueste Installation" festgelegt.

    5. Build und Run ist auf lokalen Computer festgelegt

    6. Speichern Sie die Szene, und fügen Sie sie dem Build hinzu.

      1. Wählen Sie dazu "Szenen hinzufügen" aus. Ein Speicherfenster wird angezeigt.

        Hinzufügen von offenen Szenen

      2. Erstellen Sie einen neuen Ordner für diesen Ordner und jede zukünftige Szene, und wählen Sie dann die Schaltfläche "Neuer Ordner " aus, um einen neuen Ordner zu erstellen, benennen Sie ihn "Szenen".

        Szenenordner erstellen

      3. Öffnen Sie Ihren neu erstellten Szenenordner , und drücken Sie dann im Dateinamen: Textfeld, geben Sie "FunctionsScene" ein, und drücken Sie dann "Speichern".

        Szenen zum Speichern von Funktionen

  6. Die verbleibenden Einstellungen in den Buildeinstellungen sollten jetzt als Standard beibehalten werden.

    Standardbuildeinstellungen verlassen

  7. Klicken Sie im Fenster " Buildeinstellungen " auf die Schaltfläche "Spielereinstellungen ". Dadurch wird der zugehörige Bereich im Bereich geöffnet, in dem sich der Inspektor befindet.

    Spielereinstellungen im Inspektor

  8. In diesem Bereich müssen einige Einstellungen überprüft werden:

    1. Auf der Registerkarte "Andere Einstellungen "

      1. Die Skriptlaufzeitversion sollte experimentelle (.NET 4.6-Entsprechung) sein, wodurch ein Neustart des Editors ausgelöst wird.
      2. Skript-Back-End sollte .NET sein
      3. API-Kompatibilitätsebene sollte .NET 4.6 sein
    2. Überprüfen Sie auf der Registerkarte " Veröffentlichungseinstellungen " unter "Funktionen":

      • InternetClient

        Festlegen von Funktionen

    3. Vergewissern Sie sich, dass das Windows Mixed Reality SDK hinzugefügt wird, weiter unten im Bereich in den XR-Einstellungen (unter "Veröffentlichungseinstellungen" gefunden).

      Festlegen von XR-Einstellungen

  9. Zurück in build settingsUnity C# Projects ist nicht mehr abgeblentet; aktivieren Sie das Kontrollkästchen neben dieser Option.

    Tick c#-Projekte

  10. Schließen Sie das Fenster „Build Settings“ (Buildeinstellungen).

  11. Speichern Sie Ihre Szene und Project (FILESAVE SCENE / FILE>>SAVE PROJECT).

Kapitel 4 – Einrichten der Hauptkamera

Wichtig

Wenn Sie die Unity Setup-Komponenten dieses Kurses überspringen möchten, und fahren Sie direkt in Code fort, können Sie diese .unitypackage herunterladen und in Ihr Projekt als benutzerdefiniertes Paket importieren. Dies enthält auch die DLLs aus dem nächsten Kapitel. Fahren Sie nach dem Import aus Kapitel 7 fort.

  1. Im Hierarchiebereich finden Sie ein Objekt namens Hauptkamera, dieses Objekt stellt Ihren "Kopf"-Ansichtspunkt dar, sobald Sie sich in Ihrer Anwendung befinden.

  2. Wählen Sie mit dem Unity-Dashboard vor Ihnen das Hauptkamera-GameObject aus. Sie werden feststellen, dass der Inspektorbereich (im Allgemeinen rechts im Dashboard gefunden) die verschiedenen Komponenten dieses GameObjects, mit Transformation oben, gefolgt von Kamera und einigen anderen Komponenten anzeigt. Sie müssen die Transformation der Hauptkamera zurücksetzen, sodass sie ordnungsgemäß positioniert ist.

  3. Wählen Sie dazu das Zahnradsymbol neben der Kameratransformationskomponente aus, und wählen Sie "Zurücksetzen" aus.

    Zurücksetzen der Transformation

  4. Aktualisieren Sie dann die Transformationskomponente , um wie folgt aussehen zu können:

Transformation – Position

X J Z
0 1 0

Transformation – Drehung

X J Z
0 0 0

Transformation – Skalierung

X J Z
1 1 1

Festlegen der Kameratransformation

Kapitel 5 – Einrichten der Unity-Szene

  1. Klicken Sie mit der rechten Maustaste in einen leeren Bereich des Hierarchiebereichs unter 3D-Objekt, fügen Sie eine Ebene hinzu.

    neue Ebene erstellen

  2. Ändern Sie mit dem ausgewählten Plane-Objekt die folgenden Parameter im Inspektorbereich:

Transformation – Position

X J Z
0 0 4

Transformation – Skalierung

X J Z
10 1 10

Festlegen der Ebene position und der Skalierung

Szenenansicht der Ebene

  1. Klicken Sie mit der rechten Maustaste in einen leeren Bereich des Hierarchiebereichs unter 3D-Objekt, fügen Sie einen Cube hinzu.

    1. Benennen Sie den Cube in GazeButton um (mit dem ausgewählten Cube drücken Sie 'F2').

    2. Ändern Sie die folgenden Parameter für die Transformationsposition im Inspektorbereich:

      X J Z
      0 3 5

      Schaltflächentransformation festlegen

      Ansicht

    3. Klicken Sie auf die Dropdownschaltfläche " Tag ", und klicken Sie auf "Tag hinzufügen ", um den Bereich " & Tags"-Ebenen zu öffnen.

      Neues Tag hinzufügen

      Plus auswählen

    4. Wählen Sie die Schaltfläche + (plus) aus, und geben Sie im Feld "Neuer Tagname " die Eingabetaste "GazeButton" ein, und drücken Sie "Speichern".

      name new tag

    5. Klicken Sie im Hierarchiebereich auf das GazeButton-Objekt, und weisen Sie im Inspektorbereich das neu erstellte GazeButton-Tag zu.

      Zuweisen der Blickschaltfläche des neuen Tags

  2. Klicken Sie mit der rechten Maustaste auf das GazeButton-Objekt , im Hierarchiebereich, und fügen Sie ein leeres GameObject hinzu (das als untergeordnetes Objekt hinzugefügt wird).

  3. Wählen Sie das neue Objekt aus, und benennen Sie es ShapeSpawnPoint um.

    1. Ändern Sie die folgenden Parameter für die Transformationsposition im Inspektorbereich:

      X J Z
      0 -1 0

      Aktualisieren der Form-Spawnpunkttransformation

      Ansicht des Shape-Spawnpunkts

  4. Als Nächstes erstellen Sie ein 3D-Text-Objekt , um Feedback zum Status des Azure-Diensts bereitzustellen.

    Klicken Sie mit der rechten Maustaste auf das GazeButton im Hierarchiebereich erneut, und fügen Sie als untergeordnetes Objekt ein 3D-Objekt>3D-Text hinzu.

    Erstellen eines neuen 3D-Textobjekts

  5. Benennen Sie das 3D-Text-Objekt in AzureStatusText um.

  6. Ändern Sie die Position des AzureStatusText-Objektstransformieren wie folgt:

    X J Z
    0 0 -0,6
  7. Ändern Sie die AzureStatusText-Objekttransformationsskala wie folgt: |X | Y | Z | | :---: | :---: | :---: | | 0.1 | 0.1 | 0.1 |

    Hinweis

    Machen Sie sich keine Sorgen, wenn sie nicht in der Mitte angezeigt wird, da dies behoben wird, wenn die unten aufgeführte TextGitterkomponente aktualisiert wird.

  8. Ändern Sie die TextGitterkomponente so, dass sie den folgenden Übereinstimmungen entspricht:

    Textgitterkomponente festlegen

    Tipp

    Die ausgewählte Farbe hier ist Hex-Farbe: 00000FF, obwohl Sie sich frei fühlen, ihre eigenen auszuwählen, stellen Sie sicher, dass sie lesbar ist.

  9. Ihre Hierarchiebereichsstruktur sollte nun wie folgt aussehen:

    Textgitter in der Hierarchie

  10. Ihre Szene sollte nun wie folgt aussehen:

    Textgitter in der Szenenansicht

Kapitel 6 – Importieren von Azure Storage für Unity

Sie verwenden Azure Storage for Unity (das selbst das .Net SDK für Azure nutzt). Weitere Informationen finden Sie im Azure Storage for Unity-Artikel.

Es gibt derzeit ein bekanntes Problem in Unity, das Plug-Ins nach dem Import neu konfiguriert werden muss. Diese Schritte (4 - 7 in diesem Abschnitt) sind nach der Behebung des Fehlers nicht mehr erforderlich.

Um das SDK in Ihr eigenes Projekt zu importieren, stellen Sie sicher, dass Sie das neueste '.unitypackage' von GitHub heruntergeladen haben. Gehen Sie nun wie folgt vor:

  1. Fügen Sie dieUnitypackage-Datei zu Unity hinzu, indem Sie die > Option "Benutzerdefiniertes Paket>importieren" verwenden.

  2. Im Feld "Unity-Paket importieren", das angezeigt wird, können Sie alles unter Plug-In-Speicher> auswählen. Deaktivieren Sie alles andere, da es für diesen Kurs nicht erforderlich ist.

    Importieren in Paket

  3. Klicken Sie auf die Schaltfläche "Importieren ", um dem Projekt die Elemente hinzuzufügen.

  4. Wechseln Sie zum Speicherordner unter Plugins in der Projektansicht, und wählen Sie nur die folgenden Plugins aus:

    • Microsoft.Data.Edm

    • Microsoft.Data.OData

    • Microsoft.WindowsAzure.Storage

    • Newtonsoft.Json

    • System.Spatial

      Deaktivieren der Option

  5. Wenn diese bestimmten Plugins ausgewählt sind, deaktivieren Sie "Alle Plattform", und deaktivieren Sie WSAPlayer, und klicken Sie dann auf "Übernehmen".

    Anwenden von Plattform-DLLs

    Hinweis

    Wir markieren diese speziellen Plugins, die nur im Unity-Editor verwendet werden sollen. Dies liegt daran, dass es verschiedene Versionen derselben Plugins im WSA-Ordner gibt, die nach dem Export des Projekts aus Unity verwendet werden.

  6. Wählen Sie im Ordner " Speicher-Plug-In" nur Folgendes aus:

    • Microsoft.Data.Services.Client

      set nicht verarbeiten für dlls

  7. Aktivieren Sie das Kontrollkästchen "Nicht verarbeiten" unter "Plattformeinstellungen ", und klicken Sie auf "Übernehmen".

    keine Verarbeitung anwenden

    Hinweis

    Wir markieren dieses Plug-In "Nicht verarbeiten", da der Unity-Assembly-Patcher schwierigkeiten hat, dieses Plug-In zu verarbeiten. Das Plug-In funktioniert weiterhin, obwohl es nicht verarbeitet wird.

Kapitel 7 – Erstellen der AzureServices-Klasse

Die erste Klasse, die Sie erstellen möchten, ist die AzureServices-Klasse .

Die AzureServices-Klasse ist verantwortlich für:

  • Speichern von Azure-Kontoanmeldeinformationen.

  • Rufen Sie Ihre Azure-App Funktion auf.

  • Der Upload und Download der Datendatei in Ihrem Azure Cloud Storage.

So erstellen Sie diese Klasse:

  1. Klicken Sie mit der rechten Maustaste im Ordner " Ressourcen " im Projektbereich, "Ordner erstellen>". Benennen Sie den Ordner Skripts.

    Neuen Ordner erstellen

    Anrufordner – Skripts

  2. Doppelklicken Sie auf den gerade erstellten Ordner, um ihn zu öffnen.

  3. Klicken Sie mit der rechten Maustaste in den Ordner, "C#-Skripterstellen>". Rufen Sie das Skript AzureServices auf.

  4. Doppelklicken Sie auf die neue AzureServices-Klasse , um sie mit Visual Studio zu öffnen.

  5. Fügen Sie den folgenden Namespaces oben im AzureServices hinzu:

        using System;
        using System.Threading.Tasks;
        using UnityEngine;
        using Microsoft.WindowsAzure.Storage;
        using Microsoft.WindowsAzure.Storage.File;
        using System.IO;
        using System.Net;
    
  6. Fügen Sie die folgenden Inspektorfelder in der AzureServices-Klasse hinzu:

        /// <summary>
        /// Provides Singleton-like behavior to this class.
        /// </summary>
        public static AzureServices instance;
    
        /// <summary>
        /// Reference Target for AzureStatusText Text Mesh object
        /// </summary>
        public TextMesh azureStatusText;
    
  7. Fügen Sie dann die folgenden Membervariablen in der AzureServices-Klasse hinzu:

        /// <summary>
        /// Holds the Azure Function endpoint - Insert your Azure Function
        /// Connection String here.
        /// </summary>
    
        private readonly string azureFunctionEndpoint = "--Insert here you AzureFunction Endpoint--";
    
        /// <summary>
        /// Holds the Storage Connection String - Insert your Azure Storage
        /// Connection String here.
        /// </summary>
        private readonly string storageConnectionString = "--Insert here you AzureStorage Connection String--";
    
        /// <summary>
        /// Name of the Cloud Share - Hosts directories.
        /// </summary>
        private const string fileShare = "fileshare";
    
        /// <summary>
        /// Name of a Directory within the Share
        /// </summary>
        private const string storageDirectory = "storagedirectory";
    
        /// <summary>
        /// The Cloud File
        /// </summary>
        private CloudFile shapeIndexCloudFile;
    
        /// <summary>
        /// The Linked Storage Account
        /// </summary>
        private CloudStorageAccount storageAccount;
    
        /// <summary>
        /// The Cloud Client
        /// </summary>
        private CloudFileClient fileClient;
    
        /// <summary>
        /// The Cloud Share - Hosts Directories
        /// </summary>
        private CloudFileShare share;
    
        /// <summary>
        /// The Directory in the share that will host the Cloud file
        /// </summary>
        private CloudFileDirectory dir;
    

    Wichtig

    Stellen Sie sicher, dass Sie die Endpunkt - und Verbindungszeichenfolgenwerte durch die Werte aus Ihrem Azure-Speicher ersetzen, die im Azure-Portal gefunden wurden.

  8. Code für Awake() und Start() -Methoden müssen jetzt hinzugefügt werden. Diese Methoden werden aufgerufen, wenn die Klasse initialisiert:

        private void Awake()
        {
            instance = this;
        }
    
        // Use this for initialization
        private void Start()
        {
            // Set the Status text to loading, whilst attempting connection to Azure.
            azureStatusText.text = "Loading...";
        }
    
        /// <summary>
        /// Call to the Azure Function App to request a Shape.
        /// </summary>
        public async void CallAzureFunctionForNextShape()
        {
    
        }
    

    Wichtig

    Wir werden den Code für CallAzureFunctionForNextShape() in einem zukünftigen Kapitel ausfüllen.

  9. Löschen Sie die Update()- Methode, da diese Klasse sie nicht verwendet.

  10. Speichern Sie Ihre Änderungen in Visual Studio, und kehren Sie dann zu Unity zurück.

  11. Klicken Sie auf die AzureServices-Klasse aus dem Ordner "Skripts" in das Hauptkameraobjekt im Hierarchiebereich.

  12. Wählen Sie die Hauptkamera aus, und ziehen Sie dann das untergeordnete AzureStatusText-Objekt unterhalb des GazeButton-Objekts, und platzieren Sie ihn im AzureStatusText-Referenzzielfeld im Inspektor, um den Verweis auf das AzureServices-Skript bereitzustellen.

    Azure-Statustextreferenzziel zuweisen

Kapitel 8 – Erstellen der ShapeFactory-Klasse

Das nächste Zu erstellende Skript ist die ShapeFactory-Klasse . Die Rolle dieser Klasse besteht darin, bei Bedarf eine neue Form zu erstellen und einen Verlauf der Shapes beizubehalten, die in einer Shape-Verlaufsliste erstellt wurden. Jedes Mal, wenn ein Shape erstellt wird, wird die Shape-Verlaufsliste in der AzureService-Klasse aktualisiert und dann in Ihrem Azure Storage gespeichert. Wenn die Anwendung gestartet wird, wenn eine gespeicherte Datei in Ihrem Azure Storage gefunden wird, wird die Shape-Verlaufsliste abgerufen und wiedergegeben, wobei das 3D-Text-Objekt bereitgestellt wird, das angibt, ob das generierte Shape aus dem Speicher oder neu stammt.

So erstellen Sie diese Klasse:

  1. Wechseln Sie zum Ordner "Skripts" , den Sie zuvor erstellt haben.

  2. Klicken Sie mit der rechten Maustaste in den Ordner, "C#-Skripterstellen>". Rufen Sie das Skript ShapeFactory auf.

  3. Doppelklicken Sie auf das neue ShapeFactory-Skript , um es mit Visual Studio zu öffnen.

  4. Stellen Sie sicher, dass die ShapeFactory-Klasse die folgenden Namespaces enthält:

        using System.Collections.Generic;
        using UnityEngine;
    
  5. Fügen Sie die folgenden Variablen zur ShapeFactory-Klasse hinzu, und ersetzen Sie die Funktionen "Start() und Awake() durch die folgenden Funktionen:

        /// <summary>
        /// Provide this class Singleton-like behaviour
        /// </summary>
        [HideInInspector]
        public static ShapeFactory instance;
    
        /// <summary>
        /// Provides an Inspector exposed reference to ShapeSpawnPoint
        /// </summary>
        [SerializeField]
        public Transform spawnPoint;
    
        /// <summary>
        /// Shape History Index
        /// </summary>
        [HideInInspector]
        public List<int> shapeHistoryList;
    
        /// <summary>
        /// Shapes Enum for selecting required shape
        /// </summary>
        private enum Shapes { Cube, Sphere, Cylinder }
    
        private void Awake()
        {
            instance = this;
        }
    
        private void Start()
        {
            shapeHistoryList = new List<int>();
        }
    
  6. Die CreateShape()- Methode generiert die Grundformen basierend auf dem angegebenen ganzzahligen Parameter. Der Boolesche Parameter wird verwendet, um anzugeben, ob sich die aktuell erstellte Form aus dem Speicher oder neu befindet. Platzieren Sie den folgenden Code in Ihrer ShapeFactory-Klasse unter den vorherigen Methoden:

        /// <summary>
        /// Use the Shape Enum to spawn a new Primitive object in the scene
        /// </summary>
        /// <param name="shape">Enumerator Number for Shape</param>
        /// <param name="storageShape">Provides whether this is new or old</param>
        internal void CreateShape(int shape, bool storageSpace)
        {
            Shapes primitive = (Shapes)shape;
            GameObject newObject = null;
            string shapeText = storageSpace == true ? "Storage: " : "New: ";
    
            AzureServices.instance.azureStatusText.text = string.Format("{0}{1}", shapeText, primitive.ToString());
    
            switch (primitive)
            {
                case Shapes.Cube:
                newObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
                break;
    
                case Shapes.Sphere:
                newObject = GameObject.CreatePrimitive(PrimitiveType.Sphere);
                break;
    
                case Shapes.Cylinder:
                newObject = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
                break;
            }
    
            if (newObject != null)
            {
                newObject.transform.position = spawnPoint.position;
    
                newObject.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
    
                newObject.AddComponent<Rigidbody>().useGravity = true;
    
                newObject.GetComponent<Renderer>().material.color = UnityEngine.Random.ColorHSV(0f, 1f, 1f, 1f, 0.5f, 1f);
            }
        }
    
  7. Achten Sie darauf, Ihre Änderungen in Visual Studio zu speichern, bevor Sie zu Unity zurückkehren.

  8. Klicken Sie im Unity-Editor auf die ShapeFactory-Klasse aus dem Skriptordner in das Hauptkameraobjekt im Hierarchiebereich.

  9. Mit der ausgewählten Hauptkamera werden Sie feststellen, dass die ShapeFactory-Skriptkomponente den Spawn Point-Verweis fehlt. Um es zu beheben, ziehen Sie das ShapeSpawnPoint-Objekt aus dem Hierarchiebereich auf das Referenzziel "Spawn Point ".

    Shape Factory-Referenzziel festlegen

Kapitel 9 – Erstellen der Gaze-Klasse

Das letzte Skript, das Sie erstellen müssen, ist die Gaze-Klasse .

Diese Klasse ist dafür verantwortlich, einen Raycast zu erstellen, der von der Hauptkamera projiziert wird, um zu erkennen, welches Objekt der Benutzer betrachtet. In diesem Fall muss der Raycast identifizieren, ob der Benutzer das GazeButton-Objekt in der Szene betrachtet und ein Verhalten auslöst.

So erstellen Sie diese Klasse:

  1. Wechseln Sie zum Ordner "Skripts" , den Sie zuvor erstellt haben.

  2. Klicken Sie im Projektbereich mit der rechten Maustaste auf dasSkript "C#erstellen>". Rufen Sie das Skript "Gaze" auf.

  3. Doppelklicken Sie auf das neue Blickskript, um es mit Visual Studio zu öffnen.

  4. Stellen Sie sicher, dass der folgende Namespace oben im Skript enthalten ist:

        using UnityEngine;
    
  5. Fügen Sie dann die folgenden Variablen innerhalb der Gaze-Klasse hinzu:

        /// <summary>
        /// Provides Singleton-like behavior to this class.
        /// </summary>
        public static Gaze instance;
    
        /// <summary>
        /// The Tag which the Gaze will use to interact with objects. Can also be set in editor.
        /// </summary>
        public string InteractibleTag = "GazeButton";
    
        /// <summary>
        /// The layer which will be detected by the Gaze ('~0' equals everything).
        /// </summary>
        public LayerMask LayerMask = ~0;
    
        /// <summary>
        /// The Max Distance the gaze should travel, if it has not hit anything.
        /// </summary>
        public float GazeMaxDistance = 300;
    
        /// <summary>
        /// The size of the cursor, which will be created.
        /// </summary>
        public Vector3 CursorSize = new Vector3(0.05f, 0.05f, 0.05f);
    
        /// <summary>
        /// The color of the cursor - can be set in editor.
        /// </summary>
        public Color CursorColour = Color.HSVToRGB(0.0223f, 0.7922f, 1.000f);
    
        /// <summary>
        /// Provides when the gaze is ready to start working (based upon whether
        /// Azure connects successfully).
        /// </summary>
        internal bool GazeEnabled = false;
    
        /// <summary>
        /// The currently focused object.
        /// </summary>
        internal GameObject FocusedObject { get; private set; }
    
        /// <summary>
        /// The object which was last focused on.
        /// </summary>
        internal GameObject _oldFocusedObject { get; private set; }
    
        /// <summary>
        /// The info taken from the last hit.
        /// </summary>
        internal RaycastHit HitInfo { get; private set; }
    
        /// <summary>
        /// The cursor object.
        /// </summary>
        internal GameObject Cursor { get; private set; }
    
        /// <summary>
        /// Provides whether the raycast has hit something.
        /// </summary>
        internal bool Hit { get; private set; }
    
        /// <summary>
        /// This will store the position which the ray last hit.
        /// </summary>
        internal Vector3 Position { get; private set; }
    
        /// <summary>
        /// This will store the normal, of the ray from its last hit.
        /// </summary>
        internal Vector3 Normal { get; private set; }
    
        /// <summary>
        /// The start point of the gaze ray cast.
        /// </summary>
        private Vector3 _gazeOrigin;
    
        /// <summary>
        /// The direction in which the gaze should be.
        /// </summary>
        private Vector3 _gazeDirection;
    

Wichtig

Einige dieser Variablen können im Editor bearbeitet werden.

  1. Code für die Methoden Awake() und Start() müssen jetzt hinzugefügt werden.

        /// <summary>
        /// The method used after initialization of the scene, though before Start().
        /// </summary>
        private void Awake()
        {
            // Set this class to behave similar to singleton
            instance = this;
        }
    
        /// <summary>
        /// Start method used upon initialization.
        /// </summary>
        private void Start()
        {
            FocusedObject = null;
            Cursor = CreateCursor();
        }
    
  2. Fügen Sie den folgenden Code hinzu, der ein Cursorobjekt zu Beginn erstellt, zusammen mit der Update() -Methode, die die Raycast-Methode ausführt, zusammen mit dem Ort, an dem das Boolesche GazeEnabled-Objekt verschoben wird:

        /// <summary>
        /// Method to create a cursor object.
        /// </summary>
        /// <returns></returns>
        private GameObject CreateCursor()
        {
            GameObject newCursor = GameObject.CreatePrimitive(PrimitiveType.Sphere);
            newCursor.SetActive(false);
    
            // Remove the collider, so it doesn't block raycast.
            Destroy(newCursor.GetComponent<SphereCollider>());
            newCursor.transform.localScale = CursorSize;
    
            newCursor.GetComponent<MeshRenderer>().material = new Material(Shader.Find("Diffuse"))
            {
                color = CursorColour
            };
    
            newCursor.name = "Cursor";
    
            newCursor.SetActive(true);
    
            return newCursor;
        }
    
        /// <summary>
        /// Called every frame
        /// </summary>
        private void Update()
        {
            if(GazeEnabled == true)
            {
                _gazeOrigin = Camera.main.transform.position;
    
                _gazeDirection = Camera.main.transform.forward;
    
                UpdateRaycast();
            }
        }
    
  3. Fügen Sie als Nächstes die UpdateRaycast()- Methode hinzu, die einen Raycast projiziert und das Trefferziel erkennt.

        private void UpdateRaycast()
        {
            // Set the old focused gameobject.
            _oldFocusedObject = FocusedObject;
    
            RaycastHit hitInfo;
    
            // Initialise Raycasting.
            Hit = Physics.Raycast(_gazeOrigin,
                _gazeDirection,
                out hitInfo,
                GazeMaxDistance, LayerMask);
    
            HitInfo = hitInfo;
    
            // Check whether raycast has hit.
            if (Hit == true)
            {
                Position = hitInfo.point;
    
                Normal = hitInfo.normal;
    
                // Check whether the hit has a collider.
                if (hitInfo.collider != null)
                {
                    // Set the focused object with what the user just looked at.
                    FocusedObject = hitInfo.collider.gameObject;
                }
                else
                {
                    // Object looked on is not valid, set focused gameobject to null.
                    FocusedObject = null;
                }
            }
            else
            {
                // No object looked upon, set focused gameobject to null.
                FocusedObject = null;
    
                // Provide default position for cursor.
                Position = _gazeOrigin + (_gazeDirection * GazeMaxDistance);
    
                // Provide a default normal.
                Normal = _gazeDirection;
            }
    
            // Lerp the cursor to the given position, which helps to stabilize the gaze.
            Cursor.transform.position = Vector3.Lerp(Cursor.transform.position, Position, 0.6f);
    
            // Check whether the previous focused object is this same 
            //    object. If so, reset the focused object.
            if (FocusedObject != _oldFocusedObject)
            {
                ResetFocusedObject();
    
                if (FocusedObject != null)
                {
                if (FocusedObject.CompareTag(InteractibleTag.ToString()))
                {
                        // Set the Focused object to green - success!
                        FocusedObject.GetComponent<Renderer>().material.color = Color.green;
    
                        // Start the Azure Function, to provide the next shape!
                        AzureServices.instance.CallAzureFunctionForNextShape();
                    }
                }
            }
        }
    
  4. Fügen Sie schließlich die ResetFocusedObject() -Methode hinzu, die die Aktuelle Farbe der GazeButton-Objekte umgibt, die angibt, ob sie eine neue Form erstellt oder nicht.

        /// <summary>
        /// Reset the old focused object, stop the gaze timer, and send data if it
        /// is greater than one.
        /// </summary>
        private void ResetFocusedObject()
        {
            // Ensure the old focused object is not null.
            if (_oldFocusedObject != null)
            {
                if (_oldFocusedObject.CompareTag(InteractibleTag.ToString()))
                {
                    // Set the old focused object to red - its original state.
                    _oldFocusedObject.GetComponent<Renderer>().material.color = Color.red;
                }
            }
        }
    
  5. Speichern Sie Ihre Änderungen in Visual Studio, bevor Sie zu Unity zurückkehren.

  6. Klicken Sie auf die Gaze-Klasse aus dem Ordner "Skripts" in das Hauptkameraobjekt im Hierarchiebereich.

Kapitel 10 – Abschließen der AzureServices-Klasse

Mit den anderen Skripts ist es jetzt möglich, die AzureServices-Klasseabzuschließen. Dies wird durch folgendes erreicht:

  1. Hinzufügen einer neuen Methode namens CreateCloudIdentityAsync(), um die für die Kommunikation mit Azure erforderlichen Authentifizierungsvariablen einzurichten.

    Diese Methode überprüft auch die Existenz einer zuvor gespeicherten Datei, die die Shape-Liste enthält.

    Wenn die Datei gefunden wird, wird die Benutzeranzeige deaktiviert und die Shape-Erstellung entsprechend dem Muster von Shapes ausgelöst, wie in der Azure Storage-Datei gespeichert. Der Benutzer kann dies sehen, da das Textgitter "Speicher" oder "Neu" angezeigt wird, je nach Ursprung der Shapes.

    Wenn keine Datei gefunden wird, wird der Blick aktiviert, sodass der Benutzer Formen beim Anzeigen des GazeButton-Objekts in der Szene erstellen kann.

        /// <summary>
        /// Create the references necessary to log into Azure
        /// </summary>
        private async void CreateCloudIdentityAsync()
        {
            // Retrieve storage account information from connection string
            storageAccount = CloudStorageAccount.Parse(storageConnectionString);
    
            // Create a file client for interacting with the file service.
            fileClient = storageAccount.CreateCloudFileClient();
    
            // Create a share for organizing files and directories within the storage account.
            share = fileClient.GetShareReference(fileShare);
    
            await share.CreateIfNotExistsAsync();
    
            // Get a reference to the root directory of the share.
            CloudFileDirectory root = share.GetRootDirectoryReference();
    
            // Create a directory under the root directory
            dir = root.GetDirectoryReference(storageDirectory);
    
            await dir.CreateIfNotExistsAsync();
    
            //Check if the there is a stored text file containing the list
            shapeIndexCloudFile = dir.GetFileReference("TextShapeFile");
    
            if (!await shapeIndexCloudFile.ExistsAsync())
            {
                // File not found, enable gaze for shapes creation
                Gaze.instance.GazeEnabled = true;
    
                azureStatusText.text = "No Shape\nFile!";
            }
            else
            {
                // The file has been found, disable gaze and get the list from the file
                Gaze.instance.GazeEnabled = false;
    
                azureStatusText.text = "Shape File\nFound!";
    
                await ReplicateListFromAzureAsync();
            }
        }
    
  2. Der nächste Codeausschnitt befindet sich in der Start()- Methode; wobei ein Aufruf an die CreateCloudIdentityAsync() -Methode vorgenommen wird. Fühlen Sie sich frei, über Ihre aktuelle Start()- Methode zu kopieren, mit der folgenden:

        private void Start()
        {
            // Disable TLS cert checks only while in Unity Editor (until Unity adds support for TLS)
    #if UNITY_EDITOR
            ServicePointManager.ServerCertificateValidationCallback = delegate { return true; };
    #endif
    
            // Set the Status text to loading, whilst attempting connection to Azure.
            azureStatusText.text = "Loading...";
    
            //Creating the references necessary to log into Azure and check if the Storage Directory is empty
            CreateCloudIdentityAsync();
        }
    
  3. Füllen Sie den Code für die Methode CallAzureFunctionForNextShape(). Sie verwenden die zuvor erstellte Azure Function App , um einen Shape-Index anzufordern. Nachdem die neue Form empfangen wurde, sendet diese Methode die Form an die ShapeFactory-Klasse , um die neue Form in der Szene zu erstellen. Verwenden Sie den folgenden Code, um den Textkörper von CallAzureFunctionForNextShape()abzuschließen.

        /// <summary>
        /// Call to the Azure Function App to request a Shape.
        /// </summary>
        public async void CallAzureFunctionForNextShape()
        {
            int azureRandomInt = 0;
    
            // Call Azure function
            HttpWebRequest webRequest = WebRequest.CreateHttp(azureFunctionEndpoint);
    
            WebResponse response = await webRequest.GetResponseAsync();
    
            // Read response as string
            using (Stream stream = response.GetResponseStream())
            {
                StreamReader reader = new StreamReader(stream);
    
                String responseString = reader.ReadToEnd();
    
                //parse result as integer
                Int32.TryParse(responseString, out azureRandomInt);
            }
    
            //add random int from Azure to the ShapeIndexList
            ShapeFactory.instance.shapeHistoryList.Add(azureRandomInt);
    
            ShapeFactory.instance.CreateShape(azureRandomInt, false);
    
            //Save to Azure storage
            await UploadListToAzureAsync();
        }
    
  4. Fügen Sie eine Methode hinzu, um eine Zeichenfolge zu erstellen, indem Sie die in der Shape-Verlaufsliste gespeicherten Ganzzahlen verkettet und in Ihrer Azure Storage-Datei speichern.

        /// <summary>
        /// Upload the locally stored List to Azure
        /// </summary>
        private async Task UploadListToAzureAsync()
        {
            // Uploading a local file to the directory created above
            string listToString = string.Join(",", ShapeFactory.instance.shapeHistoryList.ToArray());
    
            await shapeIndexCloudFile.UploadTextAsync(listToString);
        }
    
  5. Fügen Sie eine Methode hinzu, um den in der Datei gespeicherten Text in Ihrer Azure Storage-Datei abzurufen und sie in eine Liste zu deserialisieren .

  6. Sobald dieser Prozess abgeschlossen ist, aktiviert die Methode den Blick erneut, sodass der Benutzer der Szene weitere Shapes hinzufügen kann.

        ///<summary>
        /// Get the List stored in Azure and use the data retrieved to replicate 
        /// a Shape creation pattern
        ///</summary>
        private async Task ReplicateListFromAzureAsync()
        {
            string azureTextFileContent = await shapeIndexCloudFile.DownloadTextAsync();
    
            string[] shapes = azureTextFileContent.Split(new char[] { ',' });
    
            foreach (string shape in shapes)
            {
                int i;
    
                Int32.TryParse(shape.ToString(), out i);
    
                ShapeFactory.instance.shapeHistoryList.Add(i);
    
                ShapeFactory.instance.CreateShape(i, true);
    
                await Task.Delay(500);
            }
    
            Gaze.instance.GazeEnabled = true;
    
            azureStatusText.text = "Load Complete!";
        }
    
  7. Speichern Sie Ihre Änderungen in Visual Studio, bevor Sie zu Unity zurückkehren.

Kapitel 11 – Erstellen der UWP-Lösung

So beginnen Sie den Buildvorgang:

  1. Wechseln Sie zuDateierstellungseinstellungen>.

    Erstellen der App

  2. Klicken Sie auf Erstellen. Unity startet ein Explorer Fenster, in dem Sie einen Ordner erstellen und dann einen Ordner auswählen müssen, in dem die App erstellt werden soll. Erstellen Sie diesen Ordner jetzt, und benennen Sie die App. Drücken Sie dann mit dem ausgewählten App-Ordner"Ordner auswählen".

  3. Unity beginnt mit dem Erstellen Ihres Projekts im App-Ordner .

  4. Nachdem Unity das Gebäude abgeschlossen hat (es kann einige Zeit dauern), wird ein Explorer Fenster an der Stelle Ihres Build geöffnet (überprüfen Sie Ihre Taskleiste, da sie möglicherweise nicht immer über Ihren Fenstern angezeigt wird, aber Sie über dem Hinzufügen eines neuen Fensters informieren).

Kapitel 12 – Bereitstellen Ihrer Anwendung

So stellen Sie Ihre Anwendung bereit:

  1. Navigieren Sie zum App-Ordner , der im letzten Kapitel erstellt wurde. Sie sehen eine Datei mit Dem Namen Ihrer Apps mit der Erweiterung ".sln", auf die Sie doppelklicken sollten, damit Sie sie in Visual Studio öffnen können.

  2. Wählen Sie in der Lösungsplattformx86, lokaler Computer aus.

  3. Wählen Sie im Projektmappenkonfigurations-Befehl"Debuggen" aus.

    Für die Microsoft HoloLens können Sie dies auf Remotecomputer einfacher festlegen, sodass Sie nicht an Ihren Computer angebindet sind. Sie müssen jedoch auch folgendes ausführen:

    • Kennen Sie die IP-Adresse> Ihrer HoloLens, die in den Einstellungen>&>Netzwerk-Wlan-ErweitertenOptionen gefunden werden können. Das IPv4 ist die Adresse, die Sie verwenden sollten.
    • Stellen Sie sicher, dass der Entwicklermodusaktiviert ist; In "Einstellungen>Update & Security>For Developer" gefunden.

    Bereitstellen einer Lösung

  4. Wechseln Sie zum Menü "Erstellen ", und klicken Sie auf " Lösung bereitstellen", um die Anwendung auf Ihren Computer querzuladen.

  5. Ihre App sollte jetzt in der Liste der installierten Apps angezeigt werden, die zum Starten und Testen bereit sind!

Ihre fertige Azure Functions und Speicheranwendung

Herzlichen Glückwunsch, Sie haben eine Mixed Reality-App erstellt, die sowohl die Azure Functions als auch Azure Storage-Dienste nutzt. Ihre App kann auf gespeicherte Daten zeichnen und eine Aktion basierend auf diesen Daten bereitstellen.

Endprodukt -End

Zusatzübungen

Übung 1

Erstellen Sie einen zweiten Spawnpunkt und Datensatz, aus dem ein Spawnpunkt eines Objekts erstellt wurde. Wenn Sie die Datendatei laden, wiedergeben Sie die Shapes, die aus dem ursprünglichen Speicherort abgerufen werden.

Übung 2

Erstellen Sie eine Möglichkeit, die App neu zu starten, anstatt sie jedes Mal erneut zu öffnen. Laden von Szenen ist ein guter Ort, um zu beginnen. Erstellen Sie danach eine Möglichkeit, die gespeicherte Liste in Azure Storage zu löschen, sodass sie einfach von Ihrer App zurückgesetzt werden kann.