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

Artikel
07/04/2024

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 in Zukunft veröffentlicht werden, die zeigen, wie sie für HoloLens 2 entwickelt werden. Dieser Hinweis wird mit einem Link zu diesen Lernprogrammen aktualisiert, wenn sie veröffentlicht werden.

Endprodukt - Start

In diesem Kurs erfahren Sie, wie Sie Azure-Funktionen erstellen und verwenden und Daten mit einer Azure Storage-Ressource in einer Mixed Reality-Anwendung speichern.

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 an 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 Artikel "Azure Functions".

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

Nach Abschluss dieses Kurses haben Sie eine immersive Mixed Reality-Headset-Anwendung, die folgende Aktionen ausführen kann:

Ermöglichen Sie dem Benutzer, eine Szene herumzublicken.
Auslösen des Spawnings von Objekten, wenn der Benutzer auf eine 3D-Schaltfläche blickt.
Die spawnierten Objekte werden von einer Azure-Funktion ausgewählt.
Wenn jedes Objekt spawniert wird, speichert die Anwendung den Objekttyp in einer Azure-Datei, die sich in Azure Storage befindet.
Beim zweiten Laden werden die Azure-Dateidaten abgerufen und zum Wiedergeben der Spawningaktionen aus der vorherigen Instanz der Anwendung verwendet.

In Ihrer Anwendung liegt es an Ihnen, wie Sie die Ergebnisse in Ihr Design integrieren. Dieser Kurs wurde entwickelt, um Ihnen zu vermitteln, wie Sie einen Azure-Dienst in Ihr Unity-Projekt integrieren. Es ist Ihre Aufgabe, das Wissen zu nutzen, das Sie aus diesem Kurs gewinnen, um Ihre Mixed Reality-Anwendung zu verbessern.

Unterstützung für Geräte

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

Hinweis

Während sich dieser Kurs in erster Linie auf immersive Windows Mixed Reality-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 zur Unterstützung von HoloLens verwenden müssen.

Voraussetzungen

Hinweis

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

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

Ein Entwicklungs-PC, kompatibel mit Windows Mixed Reality für die Entwicklung von immersiven (VR)-Headsets
Windows 10 Fall Creators Update (oder höher) mit aktivierter Entwicklermodus
Das neueste Windows 10 SDK
Unity 2017.4
Visual Studio 2017
Ein immersives Windows Mixed Reality-Headset (VR) oder Microsoft HoloLens mit aktiviertem Entwicklermodus
Ein Abonnement für ein Azure-Konto zum Erstellen von Azure-Ressourcen
Internetzugriff für Azure-Setup und Datenabruf

Vor der Installation

Um Probleme beim Erstellen dieses Projekts zu vermeiden, wird dringend empfohlen, das in diesem Lernprogramm erwähnte Projekt in einem Stamm- oder Near-Root-Ordner zu erstellen (lange Ordnerpfade können zu Buildzeit zu Problemen führen).

Kapitel 1 – Das Azure-Portal

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

Melden Sie sich beim Azure-Portalan.

Hinweis

Wenn Sie noch nicht über ein Azure-Konto verfügen, müssen Sie ein Konto erstellen. Wenn Sie diesem Lernprogramm in einer Unterrichts- oder Laborsituation folgen, bitten Sie Ihren Kursleiter oder einen der Betreuer, Hilfe beim Einrichten Ihres neuen Kontos zu erhalten.
Nachdem Sie angemeldet sind, klicken Sie in der oberen linken Ecke auf "Neu ", suchen Sie nach "Speicherkonto", und klicken Sie auf " EINGABETASTE".

Hinweis

Das Wort "Neu" wurde möglicherweise durch "Ressource erstellen" in neueren Portalen ersetzt.
Die neue Seite enthält eine Beschreibung des Azure Storage-Kontodiensts . Wählen Sie unten links in dieser Eingabeaufforderung die Schaltfläche "Erstellen " aus, um eine Zuordnung zu diesem Dienst zu erstellen.
Nachdem Sie auf "Erstellen" geklickt haben:
1. Fügen Sie einen Namen für Ihr Konto ein, beachten Sie, dass in diesem Feld nur Zahlen und Kleinbuchstaben akzeptiert werden.
2. Wählen Sie für das Bereitstellungsmodell den 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 würde. Einige Azure-Ressourcen sind nur in bestimmten Regionen verfügbar.
5. Wählen Sie für die Replikation "Read-access-geo-redundant storage (RA-GRS)" aus.
6. Wählen Sie für Leistung die Option Standard aus.
7. Verlassen Sie die sichere Übertragung, die als deaktiviert erforderlich ist.
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 (z. B. diesen Laboren) zugeordnet sind, unter einer gemeinsamen Ressourcengruppe zu halten.
  
  Wenn Sie mehr über Azure-Ressourcengruppen erfahren möchten, besuchen Sie bitte den Artikel zur Ressourcengruppe.
10. Sie müssen auch bestätigen, dass Sie die auf diesen Dienst angewendeten Allgemeinen Geschäftsbedingungen verstanden haben.
11. Klicken Sie auf Erstellen.
Nachdem Sie auf "Erstellen" geklickt haben, müssen Sie warten, bis der Dienst erstellt wurde. Dies kann eine Minute dauern.
Sobald die Dienstinstanz erstellt wurde, wird im Portal eine Benachrichtigung angezeigt.
Klicken Sie auf die Benachrichtigungen, um Ihre neue Dienstinstanz zu erkunden.
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.
Klicken Sie auf Zugriffstasten, um die Endpunkte für diesen Clouddienst anzuzeigen. Verwenden Sie Editor oder ähnliches, um eine Ihrer Tasten zur späteren Verwendung zu kopieren. Beachten Sie außerdem den Wert der Verbindungszeichenfolge , da er in der AzureServices-Klasse verwendet wird, die Sie später erstellen werden.

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:

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

Hinweis

Das Wort "Neu" wurde möglicherweise durch "Ressource erstellen" in neueren Portalen ersetzt.
Die neue Seite enthält eine Beschreibung des Azure Function App-Diensts . Wählen Sie unten links in dieser Eingabeaufforderung die Schaltfläche "Erstellen " aus, um eine Zuordnung zu diesem Dienst zu erstellen.
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 (z. B. diesen Laboren) zugeordnet sind, unter einer gemeinsamen Ressourcengruppe zu halten.
  
  Wenn Sie mehr über Azure-Ressourcengruppen erfahren möchten, besuchen Sie bitte den Artikel zur Ressourcengruppe.
4. Wählen Sie für diese Übung Windows als das ausgewählte 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 würde. Einige Azure-Ressourcen sind nur in bestimmten Regionen verfügbar. Um eine optimale Leistung zu erzielen, wählen Sie dieselbe Region 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.
Klicken Sie auf die Schaltfläche Erstellen .
Nachdem Sie auf "Erstellen" geklickt haben, müssen Sie warten, bis der Dienst erstellt wurde. Dies kann eine Minute dauern.
Sobald die Dienstinstanz erstellt wurde, wird im Portal eine Benachrichtigung angezeigt.
Klicken Sie auf die Benachrichtigungen, um Ihre neue Dienstinstanz zu erkunden.
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.
Zeigen Sie im Dashboard der Funktions-App mit dem Mauszeiger auf Funktionen, die sich im Bereich auf der linken Seite befinden, und klicken Sie dann auf das Pluszeichen +(Plus).
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 abschließend auf die Schaltfläche "Diese Funktion erstellen".
Sie sollten jedoch zur Codeseite (run.csx) weitergeleitet werden, wenn nicht, klicken Sie auf die neu erstellte Funktion in der Liste "Funktionen" im Bereich auf der linken Seite.

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, sie können sie oben einfü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;}
    }

Wählen Sie Speichern.
Das Ergebnis sollte wie das bild unten aussehen.
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 werden.

Kapitel 3 – Einrichten des Unity-Projekts

Im Folgenden sehen Sie eine typische Einrichtung für die Entwicklung mit Mixed Reality und ist daher 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 Motion Controller. Wenn Sie Unterstützung beim Einrichten des immersiven Headsets benötigen, besuchen Sie bitte den Mixed Reality-Einrichtungsartikel.

Öffnen Sie Unity, und klicken Sie auf "Neu".
Sie müssen nun 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 für Sie geeigneten Stelle fest (denken Sie daran, dass die Stammverzeichnisse besser sind). Klicken Sie dann auf "Projekt erstellen".
Wenn Unity geöffnet ist, lohnt es sich, den Standardmäßigen Skript-Editor auf Visual Studio festzulegen. Wechseln Sie zu "Einstellungen bearbeiten>", und navigieren Sie dann im neuen Fenster zu "Externe Tools". Ändern Sie den externen Skript-Editor in Visual Studio 2017. Schließen Sie das Fenster Einstellungen.
Wechseln Sie als Nächstes zu "Dateibuildeinstellungen>", und wechseln Sie zu Universelle Windows-Plattform, indem Sie auf die Schaltfläche "Plattform wechseln" klicken.
Wechseln Sie zu "Dateibuildeinstellungen>", und stellen Sie sicher, dass:
1. Das Zielgerät ist auf "Beliebiges Gerät" festgelegt.
  
  Legen Sie für Microsoft HoloLens das 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 Ausführung ist auf den lokalen Computer festgelegt.
6. Speichern Sie die Szene, und fügen Sie sie dem Build hinzu.
  1. Wählen Sie dazu "Offene Szenen hinzufügen" aus. Ein Speicherfenster wird angezeigt.
  2. Erstellen Sie einen neuen Ordner für diese Und jede zukünftige Szene, und wählen Sie dann die Schaltfläche "Neuer Ordner " aus, um einen neuen Ordner zu erstellen, nennen Sie ihn "Szenen".
  3. Öffnen Sie den neu erstellten Ordner "Szenen", und drücken Sie dann im Feld "Dateiname: Textfeld", "FunctionsScene" ein, und drücken Sie dann "Speichern".
Die übrigen Einstellungen in den Buildeinstellungen sollten jetzt als Standard beibehalten werden.
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.
In diesem Bereich müssen einige Einstellungen überprüft werden:
1. Auf der Registerkarte "Andere Einstellungen" folgendes:
  1. Skripting Runtime Version sollte Experimental (.NET 4.6 Equivalent) sein, wodurch ein Neustart des Editors ausgelöst wird.
  2. Scripting Back-End sollte .NET sein
  3. API-Kompatibilitätsstufe sollte .NET 4.6 sein
2. Aktivieren Sie auf der Registerkarte "Veröffentlichungseinstellungen " unter "Funktionen" Folgendes:
  - InternetClient
3. Klicken Sie weiter unten im Bereich unter "XR-Einstellungen" (unter "Veröffentlichungseinstellungen") auf "Virtual Reality Unterstützt", und stellen Sie sicher, dass das Windows Mixed Reality SDK hinzugefügt wird.
Zurück in Buildeinstellungen Unity C#-Projekte ist nicht mehr abgeblentet. Aktivieren Sie das Kontrollkästchen neben diesem.
Schließen Sie das Fenster Buildeinstellungen.
Speichern Sie Ihre Szene und Ihr Projekt (FILE>SAVE SCENE / FILE>SAVE PROJECT).

Kapitel 4 – Einrichten der Hauptkamera

Wichtig

Wenn Sie die Unity Set up-Komponenten dieses Kurses überspringen und direkt mit Code fortfahren möchten, können Sie dieses 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.

Im Hierarchiebereich finden Sie ein Objekt namens "Hauptkamera", dieses Objekt stellt ihren "Kopf"-Blickpunkt dar, sobald Sie sich in der Anwendung befinden.
Wählen Sie mit dem Unity-Dashboard vor Ihnen das Hauptkamera-GameObject aus. Sie werden feststellen, dass im Inspektorbereich (allgemein rechts im Dashboard) die verschiedenen Komponenten dieses GameObjects angezeigt werden, wobei "Transform" oben, gefolgt von "Kamera" und einigen anderen Komponenten angezeigt wird. Sie müssen die Transformation der Hauptkamera zurücksetzen, damit sie richtig positioniert ist.
Wählen Sie dazu das Zahnradsymbol neben der Transformationskomponente der Kamera aus, und wählen Sie "Zurücksetzen" aus.
Aktualisieren Sie dann die Transformationskomponente so, dass sie wie folgt aussieht:

Transformieren – Position

X	Y	Z
0	1	0

Transformation – Drehung

X	Y	Z
0	0	0

Transformation – Skalierung

X	Y	Z
1	1	1

Festlegen der Kameratransformation

Kapitel 5 – Einrichten der Unity-Szene

Klicken Sie mit der rechten Maustaste in einen leeren Bereich des Hierarchiebereichs unter 3D-Objekt, und fügen Sie eine Ebene hinzu.
Ändern Sie bei ausgewähltem Plane-Objekt die folgenden Parameter im Inspektorbereich:

Transformieren – Position

X	Y	Z
0	0	4

Transformation – Skalierung

X	Y	Z
10	1	10

Ebenenposition und Skalierung festlegen

Szenenansicht der Ebene

Klicken Sie mit der rechten Maustaste in einen leeren Bereich des Hierarchiebereichs unter 3D-Objekt, und fügen Sie einen Cube hinzu.
1. Benennen Sie den Cube in GazeButton um (mit ausgewähltem Cube drücken Sie F2).
2. Ändern Sie die folgenden Parameter für die Transformationsposition im Inspektorbereich:
  
  X Y Z
  
  0 3 5
3. Klicken Sie auf die Dropdownschaltfläche "Tag " und dann auf " Tag hinzufügen", um den Bereich "Kategorien & Ebenen" zu öffnen.
4. Wählen Sie die Schaltfläche +(Plus) aus, und geben Sie im Feld "Neuer Tagname" "GazeButton" ein, und drücken Sie "Speichern".
5. Klicken Sie im Hierarchiebereich auf das GazeButton-Objekt, und weisen Sie im Inspektorbereich das neu erstellte GazeButton-Tag zu.
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).
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 Y Z
  
  0 -1 0
Als Nächstes erstellen Sie ein 3D-Text-Objekt , um Feedback zum Status des Azure-Diensts zu geben.

Klicken Sie im Hierarchiebereich erneut mit der rechten Maustaste auf das GazeButton-Objekt, und fügen Sie ein 3D-Objekt>3D-Textobjekt als untergeordnetes Objekt hinzu.
Benennen Sie das 3D-Text-Objekt in AzureStatusText um.
Ändern Sie die AzureStatusText-Objekttransformationsposition wie folgt:

X Y Z

0 0 -0,6
Ändern Sie die AzureStatusText-Objekttransformationsskala wie folgt: | X | Y | Z | | :---: | :---: | :---: | | 0,1 | 0,1 | 0,1 | 0,1 |

Hinweis

Machen Sie sich keine Sorgen, wenn sie außerhalb des Zentrums zu sein scheint, da dies behoben wird, wenn die folgende TextGitterkomponente aktualisiert wird.
Ändern Sie die Textgitterkomponente so, dass sie mit der folgenden Übereinstimmung übereinstimmt:

Tipp

Die ausgewählte Farbe hier ist Hex-Farbe: 000000FF, obwohl Sie sich frei fühlen, eigene auszuwählen, stellen Sie sicher, dass sie lesbar ist.
Ihre Hierarchiepanelstruktur sollte nun wie folgt aussehen:
Ihre Szene sollte nun wie folgt aussehen:

X	Y	Z
0	3	5

X	Y	Z
0	-1	0

X	Y	Z
0	0	-0,6

Kapitel 6 – Importieren von Azure Storage für Unity

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

Es gibt derzeit ein bekanntes Problem in Unity, das erfordert, dass Plug-Ins nach dem Import neu konfiguriert werden. 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:

Fügen Sie die Unitypackage-Datei mithilfe der Menüoption "Benutzerdefiniertes>Paketimportpaket> importieren" zu Unity hinzu.
Im Popupfeld "Unity-Paket importieren" können Sie alles unter Plug-In-Speicher> auswählen. Deaktivieren Sie alles andere, da es für diesen Kurs nicht erforderlich ist.
Klicken Sie auf die Schaltfläche "Importieren ", um dem Projekt die Elemente hinzuzufügen.
Wechseln Sie in der Projektansicht zum Ordner "Speicher" unter "Plugins", und wählen Sie nur die folgenden Plug-Ins aus:
- Microsoft.Data.Edm
- Microsoft.Data.OData
- Microsoft.WindowsAzure.Storage
- Newtonsoft.Json
- System.Spatial
Wenn diese spezifischen Plug-Ins ausgewählt sind, deaktivieren Sie "Beliebige Plattform", und deaktivieren Sie "WSAPlayer" und klicken Sie dann auf "Übernehmen".

Hinweis

Wir markieren diese speziellen Plug-Ins, die nur im Unity-Editor verwendet werden sollen. Dies liegt daran, dass es verschiedene Versionen derselben Plug-Ins im WSA-Ordner gibt, die verwendet werden, nachdem das Projekt aus Unity exportiert wurde.
Wählen Sie im Ordner "Speicher-Plug-In " nur Folgendes aus:
- Microsoft.Data.Services.Client
Aktivieren Sie das Kontrollkästchen "Nicht verarbeiten " unter "Plattformeinstellungen ", und klicken Sie auf " Übernehmen".

Hinweis

Wir markieren dieses Plug-In "Nicht verarbeiten", da der Unity-Assemblypatcher Schwierigkeiten bei der Verarbeitung dieses Plug-Ins hat. 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 für Folgendes verantwortlich:

Speichern von Azure-Kontoanmeldeinformationen.
Aufrufen der Azure-App-Funktion.
Der Upload und Download der Datendatei in Ihrem Azure Cloud Storage.

So erstellen Sie diese Klasse:

Klicken Sie mit der rechten Maustaste in den Objektordner, der sich im Projektbereich befindet, "Ordner erstellen>". Benennen Sie den Ordner Skripts.
Doppelklicken Sie auf den soeben erstellten Ordner, um ihn zu öffnen.
Klicken Sie mit der rechten Maustaste in den Ordner, C#-Skript erstellen>. Rufen Sie das Skript AzureServices auf.
Doppelklicken Sie auf die neue AzureServices-Klasse , um sie mit Visual Studio zu öffnen.

Fügen Sie die folgenden Namespaces am Anfang der 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;

Fügen Sie die folgenden Inspector-Felder 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;

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 den Endpunkt und Verbindungszeichenfolge Werte durch die Werte aus Ihrem Azure-Speicher ersetzen, die im Azure-Portal zu finden sind.

Code für Die Methoden Awake() und Start() muss jetzt hinzugefügt werden. Diese Methoden werden aufgerufen, wenn die Klasse initialisiert wird:

    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.

Löschen Sie die Update()- Methode, da diese Klasse sie nicht verwendet.
Speichern Sie Ihre Änderungen in Visual Studio, und kehren Sie dann zu Unity zurück.
Klicken Und ziehen Sie die AzureServices-Klasse aus dem Ordner "Skripts" in das Hauptkameraobjekt im Hierarchiebereich.
Wählen Sie die Hauptkamera aus, und greifen Sie dann das untergeordnete AzureStatusText-Objekt unter dem GazeButton-Objekt ab, und platzieren Sie es im AzureStatusText-Referenzzielfeld im Inspektor, um den Verweis auf das AzureServices-Skript bereitzustellen.

Kapitel 8 – Erstellen der ShapeFactory-Klasse

Das nächste zu erstellende Skript ist die ShapeFactory-Klasse . Die Rolle dieser Klasse besteht darin, bei Bedarf ein neues Shape 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-Textobjekt angibt, ob das generierte Shape aus dem Speicher stammt oder neu.

So erstellen Sie diese Klasse:

Wechseln Sie zum Ordner "Skripts", den Sie zuvor erstellt haben.
Klicken Sie mit der rechten Maustaste in den Ordner, C#-Skript erstellen>. Rufen Sie das Skript ShapeFactory auf.
Doppelklicken Sie auf das neue ShapeFactory-Skript , um es mit Visual Studio zu öffnen.
Stellen Sie sicher, dass die ShapeFactory-Klasse die folgenden Namespaces enthält:
```
    using System.Collections.Generic;
    using UnityEngine;
```

Fügen Sie die unten gezeigten 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>();
    }

Die CreateShape()-Methode generiert die primitiven Formen basierend auf dem bereitgestellten ganzzahligen Parameter. Der boolesche Parameter wird verwendet, um anzugeben, ob das aktuell erstellte Shape aus dem Speicher oder neu stammt. Platzieren Sie den folgenden Code in der 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);
        }
    }

Achten Sie darauf, ihre Änderungen in Visual Studio zu speichern, bevor Sie zu Unity zurückkehren.
Klicken Sie zurück im Unity-Editor, und ziehen Sie die ShapeFactory-Klasse aus dem Ordner "Skripts " in das Hauptkameraobjekt im Hierarchiebereich.
Wenn die Hauptkamera ausgewählt ist, sehen Sie, dass die ShapeFactory-Skriptkomponente den Verweis "Spawn Point " fehlt. Um es zu beheben, ziehen Sie das ShapeSpawnPoint-Objekt aus dem Hierarchiebereich in das Referenzziel für Spawn-Punkte .

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:

Wechseln Sie zum Ordner "Skripts", den Sie zuvor erstellt haben.
Klicken Sie mit der rechten Maustaste in den Projektbereich, C#-Skript erstellen>. Rufen Sie das Skript Gaze auf.
Doppelklicken Sie auf das neue Gaze-Skript , um es mit Visual Studio zu öffnen.
Stellen Sie sicher, dass der folgende Namespace oben im Skript enthalten ist:
```
    using UnityEngine;
```

Fügen Sie dann die folgenden Variablen in 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.

Code für die Methoden Awake() und Start() muss 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();
    }

Fügen Sie den folgenden Code hinzu, der zu Beginn ein Cursorobjekt erstellt, zusammen mit der Update() -Methode, die die Raycast-Methode ausführt, zusammen mit dem Ort, an dem der Boolesche GazeEnabled umgeschaltet 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();
        }
    }

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

Fügen Sie schließlich die ResetFocusedObject() -Methode hinzu, die die aktuelle Farbe der GazeButton-Objekte umschaltet und 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;
            }
        }
    }

Speichern Sie Ihre Änderungen in Visual Studio, bevor Sie zu Unity zurückkehren.
Klicken Und ziehen Sie 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-Klasse abzuschließen. Dies wird erreicht durch:

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

Mit dieser Methode wird auch überprüft, ob eine zuvor gespeicherte Datei vorhanden ist, die die Shape-Liste enthält.

Wenn die Datei gefunden wird, wird die Benutzeranzeige deaktiviert und die Shape-Erstellung gemäß dem Muster der Shapes ausgelöst, wie in der Azure Storage-Datei gespeichert. Der Benutzer kann dies sehen, da das Textgitter abhängig vom Ursprung der Shapes die Anzeige "Speicher" oder "Neu" bereitstellt.

Wenn keine Datei gefunden wird, wird die Anzeige aktiviert, sodass der Benutzer Shapes beim Betrachten 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();
        }
    }

Der nächste Codeausschnitt stammt aus der Start() -Methode. Dabei wird ein Aufruf an die CreateCloudIdentityAsync() -Methode ausgeführt. Sie können ihre aktuelle Start() -Methode mit der folgenden Methode kopieren:

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

Füllen Sie den Code für die Methode CallAzureFunctionForNextShape(). Sie verwenden die zuvor erstellte Azure Function App , um einen Shape-Index anzufordern. Sobald das neue Shape empfangen wurde, sendet diese Methode das Shape an die ShapeFactory-Klasse , um das neue Shape 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();
    }

Fügen Sie eine Methode zum Erstellen einer Zeichenfolge hinzu, 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);
    }

Fügen Sie eine Methode hinzu, um den in der Datei gespeicherten Text in Ihrer Azure Storage-Datei abzurufen, und deserialisieren Sie ihn in einer Liste.

Sobald dieser Vorgang abgeschlossen ist, aktiviert die Methode den Blick erneut, damit 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!";
    }

Speichern Sie Ihre Änderungen in Visual Studio, bevor Sie zu Unity zurückkehren.

Kapitel 11 – Erstellen der UWP-Lösung

So beginnen Sie den Buildprozess:

Wechseln Sie zu "Dateibuildeinstellungen>".
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 nennen Sie ihn " App". Drücken Sie dann mit ausgewähltem App-Ordner "Ordner auswählen".
Unity beginnt mit dem Erstellen Ihres Projekts im App-Ordner .
Nachdem Unity das Erstellen abgeschlossen hat (es kann einige Zeit dauern), öffnet es ein Explorer Fenster an der Position Ihres Builds (überprüfen Sie Ihre Taskleiste, da sie möglicherweise nicht immer über Ihren Fenstern angezeigt wird, sondern Sie über dem Hinzufügen eines neuen Fensters informiert).

Kapitel 12 – Bereitstellen Ihrer Anwendung

So stellen Sie Ihre Anwendung bereit:

Navigieren Sie zum App-Ordner , der im letzten Kapitel erstellt wurde. Es wird eine Datei mit dem Namen Ihrer Apps mit der Erweiterung ".sln" angezeigt, auf die Sie doppelklicken sollten, um sie in Visual Studio zu öffnen.
Wählen Sie in der Lösungsplattform x86, lokaler Computer aus.
Wählen Sie in der Lösungskonfiguration "Debuggen" aus.
Für Microsoft HoloLens ist es möglicherweise einfacher, dies auf Remotecomputer festzulegen, sodass Sie nicht an Ihren Computer angebunden sind. Sie müssen jedoch auch die folgenden Schritte ausführen:
- Kennen Sie die IP-Adresse Ihrer HoloLens, die sich in den erweiterten Optionen für Netzwerkeinstellungen>und Internet>wi-Fi>befindet. IPv4 ist die Adresse, die Sie verwenden sollten.
- Stellen Sie sicher, dass der Entwicklermodus aktiviert ist; finden Sie in "Einstellungen>Update & Sicherheit>für Entwickler".
Wechseln Sie zum Menü "Erstellen ", und klicken Sie auf " Lösung bereitstellen", um die Anwendung auf Ihren Computer querzuladen.
Ihre App sollte jetzt in der Liste der installierten Apps angezeigt werden, bereit für den Start und test!

Ihre fertige Azure-Funktionen und -Speicheranwendung

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

Endprodukt -End

Zusatzübungen

Übung 1

Erstellen Sie einen zweiten Spawnpunkt und einen Datensatz, aus dem ein Objekt erstellt wurde. Wenn Sie die Datendatei laden, können Sie die Shapes wiedergeben, die aus dem ursprünglich erstellten 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 Ausgangspunkt. Erstellen Sie anschließend eine Möglichkeit, die gespeicherte Liste in Azure Storage zu löschen, damit sie ganz einfach von Ihrer App zurückgesetzt werden kann.

Freigeben über

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

Unterstützung für Geräte

Voraussetzungen

Vor der Installation

Kapitel 1 – Das Azure-Portal

Kapitel 2 – Einrichten einer Azure-Funktion

Kapitel 3 – Einrichten des Unity-Projekts

Kapitel 4 – Einrichten der Hauptkamera

Kapitel 5 – Einrichten der Unity-Szene

Kapitel 6 – Importieren von Azure Storage für Unity

Kapitel 7 – Erstellen der AzureServices-Klasse

Kapitel 8 – Erstellen der ShapeFactory-Klasse

Kapitel 9 – Erstellen der Gaze-Klasse

Kapitel 10 – Abschließen der AzureServices-Klasse

Kapitel 11 – Erstellen der UWP-Lösung

Kapitel 12 – Bereitstellen Ihrer Anwendung

Ihre fertige Azure-Funktionen und -Speicheranwendung

Zusatzübungen

Übung 1

Übung 2

Zusätzliche Ressourcen