HoloLens (1. Generation) und Azure 312: Botintegration

Artikel
07/12/2023

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

In diesem Kurs erfahren Sie, wie Sie einen Bot mit dem Microsoft Bot Framework V4 erstellen und bereitstellen und mit diesem über eine Windows Mixed Reality-Anwendung kommunizieren.

Screenshot: Kommunikation über eine Windows Mixed Reality Anwendung

Die Microsoft Bot Framework V4 ist eine Reihe von APIs, die Entwicklern die Tools zum Erstellen einer erweiterbaren und skalierbaren Botanwendung bereitstellen. Weitere Informationen finden Sie auf der Seite Microsoft Bot Framework oder im Git-Repository V4.

Nach Abschluss dieses Kurses haben Sie eine Windows Mixed Reality-Anwendung erstellt, die folgendes ausführen kann:

Verwenden Sie eine Tippen-Geste , um den Bot zu starten, der auf die Stimme der Benutzer lauscht.
Wenn der Benutzer etwas gesagt hat, versucht der Bot, eine Antwort bereitzustellen.
Zeigen Sie die Bots antworten als Text in der Nähe des Bots in der Unity-Szene an.

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

Geräteunterstützung

Kurs	HoloLens	Immersive Headsets
MR und Azure 312: Bot-Integration	✔️	✔️

Hinweis

Während sich dieser Kurs hauptsächlich auf HoloLens konzentriert, können Sie das, was Sie in diesem Kurs lernen, auch auf Windows Mixed Reality immersiven (VR)-Headsets anwenden. Da immersive Headsets (VR) keine zugänglichen Kameras haben, benötigen Sie eine externe Kamera, die an Ihren PC angeschlossen ist. Während Sie den Kurs befolgen, werden Ihnen Notizen zu allen Änderungen angezeigt, die Sie möglicherweise anwenden müssen, um immersive Headsets (VR) zu unterstützen.

Voraussetzungen

Hinweis

Dieses Tutorial richtet sich an Entwickler, die über grundlegende Erfahrungen mit Unity und C# verfügen. Bitte beachten Sie auch, dass die Voraussetzungen und schriftlichen Anweisungen in diesem Dokument das darstellen, was zum Zeitpunkt des Schreibens (Juli 2018) getestet und überprüft wurde. Sie können die neueste Software verwenden, wie im Artikel Installieren der Tools aufgeführt, obwohl nicht davon ausgegangen werden sollte, dass die Informationen in diesem Kurs perfekt dem entsprechen, was Sie in neuerer Software finden, als die unten aufgeführten.

Wir empfehlen die folgende Hard- 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 aktiviertem Entwicklermodus
Das neueste Windows 10 SDK
Unity 2017.4
Visual Studio 2017
Ein Windows Mixed Reality immersives Headset (VR) oder Microsoft HoloLens mit aktiviertem Entwicklermodus
Internetzugriff für Azure und für den Azure-Bot-Abruf. Weitere Informationen finden Sie unter diesem Link.

Vorbereitung

Um Probleme beim Erstellen dieses Projekts zu vermeiden, wird dringend empfohlen, das in diesem Tutorial erwähnte Projekt in einem Stamm- oder Fast-Root-Ordner zu erstellen (lange Ordnerpfade können zur Buildzeit Zu Problemen führen).
Richten Sie Ihre HoloLens ein und testen Sie sie. Wenn Sie Unterstützung beim Einrichten Ihrer HoloLens benötigen, lesen Sie den Artikel HoloLens-Setup.
Es ist eine gute Idee, Kalibrierung und Sensoroptimierung durchzuführen, wenn Sie mit der Entwicklung einer neuen HoloLens-App beginnen (manchmal kann dies helfen, diese Aufgaben für jeden Benutzer auszuführen).

Hilfe zur Kalibrierung finden Sie unter diesem Link zum Artikel HoloLens-Kalibrierung.

Hilfe zur Sensoroptimierung finden Sie unter diesem Link zum Artikel HoloLens Sensoroptimierung.

Kapitel 1: Erstellen der Botanwendung

Der erste Schritt besteht darin, Ihren Bot als lokale ASP.Net Core-Webanwendung zu erstellen. Nachdem Sie es abgeschlossen und getestet haben, veröffentlichen Sie es im Azure-Portal.

Öffnen Sie Visual Studio. Erstellen Sie ein neues Projekt, wählen Sie ASP NET Core-Webanwendung als Projekttyp aus (Sie finden es unter dem Unterabschnitt .NET Core), und nennen Sie es MyBot. Klicken Sie auf OK.
Wählen Sie im daraufhin angezeigten Fenster die Option Leer aus. Stellen Sie außerdem sicher, dass das Ziel auf ASP NET Core 2.0 und die Authentifizierung auf Keine Authentifizierung festgelegt ist. Klicken Sie auf OK.
Die Lösung wird nun geöffnet. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Projektmappe Mybot, und klicken Sie auf NuGet-Pakete für Projektmappe verwalten.
Suchen Sie auf der Registerkarte Durchsuchen nach Microsoft.Bot.Builder.Integration.AspNet.Core (stellen Sie sicher, dass Sie vorab einschließen aktiviert haben). Wählen Sie die Paketversion 4.0.1-preview aus, und aktivieren Sie die Projektfelder. Klicken Sie dann auf Installieren. Sie haben jetzt die Bibliotheken installiert, die für Bot Framework v4 benötigt werden. Schließen Sie die NuGet-Seite.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr Projekt, MyBot, und klicken Sie auf Klasse hinzufügen|.
Nennen Sie die Klasse MyBot , und klicken Sie auf Hinzufügen.
Wiederholen Sie den vorherigen Punkt, um eine weitere Klasse mit dem Namen ConversationContext zu erstellen.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf wwwroot, und klicken Sie aufNeues Elementhinzufügen|. Wählen Sie HTML-Seite aus (Sie finden sie im Unterabschnitt Web). Nennen Sie die Datei default.html. Klicken Sie auf Hinzufügen.
Die Liste der Klassen/Objekte in der Projektmappen-Explorer sollte wie die folgende Abbildung aussehen.
Doppelklicken Sie auf die ConversationContext-Klasse . Diese Klasse ist für das Halten der Variablen verantwortlich, die vom Bot verwendet werden, um den Kontext der Unterhaltung beizubehalten. Diese Unterhaltungskontextwerte werden in einer instance dieser Klasse beibehalten, da jedes instance der MyBot-Klasse bei jedem Empfang einer Aktivität aktualisiert wird. Fügen Sie der Klasse den folgenden Code hinzu:
```
namespace MyBot
{
    public static class ConversationContext
    {
        internal static string userName;

        internal static string userMsg;
    }
}
```

Doppelklicken Sie auf die MyBot-Klasse . Diese Klasse hostet die Handler, die von jeder eingehenden Aktivität des Kunden aufgerufen werden. In dieser Klasse fügen Sie den Code hinzu, der zum Erstellen der Konversation zwischen dem Bot und dem Kunden verwendet wird. Wie bereits erwähnt, wird jedes Mal ein instance dieser Klasse initialisiert, wenn eine Aktivität empfangen wird. Fügen Sie dieser Klasse den folgenden Code hinzu:

using Microsoft.Bot;
using Microsoft.Bot.Builder;
using Microsoft.Bot.Schema;
using System.Threading.Tasks;

namespace MyBot
{
    public class MyBot : IBot
    {       
        public async Task OnTurn(ITurnContext context)
        {
            ConversationContext.userMsg = context.Activity.Text;

            if (context.Activity.Type is ActivityTypes.Message)
            {
                if (string.IsNullOrEmpty(ConversationContext.userName))
                {
                    ConversationContext.userName = ConversationContext.userMsg;
                    await context.SendActivity($"Hello {ConversationContext.userName}. Looks like today it is going to rain. \nLuckily I have umbrellas and waterproof jackets to sell!");
                }
                else
                {
                    if (ConversationContext.userMsg.Contains("how much"))
                    {
                        if (ConversationContext.userMsg.Contains("umbrella")) await context.SendActivity($"Umbrellas are $13.");
                        else if (ConversationContext.userMsg.Contains("jacket")) await context.SendActivity($"Waterproof jackets are $30.");
                        else await context.SendActivity($"Umbrellas are $13. \nWaterproof jackets are $30.");
                    }
                    else if (ConversationContext.userMsg.Contains("color") || ConversationContext.userMsg.Contains("colour"))
                    {
                        await context.SendActivity($"Umbrellas are black. \nWaterproof jackets are yellow.");
                    }
                    else
                    {
                        await context.SendActivity($"Sorry {ConversationContext.userName}. I did not understand the question");
                    }
                }
            }
            else
            {

                ConversationContext.userMsg = string.Empty;
                ConversationContext.userName = string.Empty;
                await context.SendActivity($"Welcome! \nI am the Weather Shop Bot \nWhat is your name?");
            }

        }
    }
}

Doppelklicken Sie auf die Startklasse . Diese Klasse initialisiert den Bot. Fügen Sie der Klasse den folgenden Code hinzu:

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Bot.Builder.BotFramework;
using Microsoft.Bot.Builder.Integration.AspNet.Core;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

namespace MyBot
{
public class Startup
    {
        public IConfiguration Configuration { get; }

        public Startup(IHostingEnvironment env)
        {
            var builder = new ConfigurationBuilder()
                .SetBasePath(env.ContentRootPath)
                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
                .AddEnvironmentVariables();
            Configuration = builder.Build();
        }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddSingleton(_ => Configuration);
            services.AddBot<MyBot>(options =>
            {
                options.CredentialProvider = new ConfigurationCredentialProvider(Configuration);
            });
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseDefaultFiles();
            app.UseStaticFiles();
            app.UseBotFramework();
        }
    }
}

Öffnen Sie die Programmklassendatei , und vergewissern Sie sich, dass der Code darin mit dem folgenden identisch ist:

using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;

namespace MyBot
{
    public class Program
    {
        public static void Main(string[] args)
        {
            BuildWebHost(args).Run();
        }

        public static IWebHost BuildWebHost(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseStartup<Startup>()
                .Build();
    }
}

Denken Sie daran, Ihre Änderungen zu speichern. Wechseln Sie dazu auf der Symbolleiste oben in Visual Studio zu Datei>speichern.

Kapitel 2: Erstellen des Azure-Bot Service

Nachdem Sie den Code für Ihren Bot erstellt haben, müssen Sie ihn im Azure-Portal in einer instance von Web App Bot Service veröffentlichen. In diesem Kapitel erfahren Sie, wie Sie die Bot Service in Azure erstellen und konfigurieren und dann Ihren Code darin veröffentlichen.

Melden Sie sich zunächst beim Azure-Portal (https://portal.azure.com) an.
1. Wenn Sie noch nicht über ein Azure-Konto verfügen, müssen Sie eines erstellen. Wenn Sie dieses Tutorial in einer Unterrichts- oder Laborsituation befolgen, bitten Sie Ihren Kursleiter oder einen der Experten um Hilfe beim Einrichten Ihres neuen Kontos.
Nachdem Sie angemeldet sind, klicken Sie in der oberen linken Ecke auf Ressource erstellen , suchen Sie nach Web-App-Bot, und klicken Sie auf DIE EINGABETASTE.
Die neue Seite enthält eine Beschreibung des Web App Bot Service. Wählen Sie unten links auf dieser Seite die Schaltfläche Erstellen aus, um eine Zuordnung zu diesem Dienst zu erstellen.
Nachdem Sie auf Erstellen geklickt haben:
1. Fügen Sie den gewünschten Namen für diesen Dienst instance ein.
2. Wählen Sie ein Abonnementaus.
3. Wählen Sie eine Ressourcengruppe aus, oder erstellen Sie eine neue. Eine Ressourcengruppe bietet eine Möglichkeit zum Überwachen, Steuern des Zugriffs, Bereitstellen und Verwalten der Abrechnung für eine Sammlung von Azure-Ressourcen. Es wird empfohlen, alle Azure-Dienste, die einem einzelnen Projekt (z. B. diesen Kursen) zugeordnet sind, unter einer gemeinsamen Ressourcengruppe zu speichern.
  
  Wenn Sie mehr über Azure-Ressourcengruppen erfahren möchten, folgen Sie diesem Link.
4. Ermitteln Sie den Speicherort für Ihre Ressourcengruppe (wenn Sie eine neue Ressourcengruppe erstellen). Der Speicherort befindet sich 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 den für Sie geeigneten Tarif aus. Wenn Sie zum ersten Mal einen Web App Bot Service erstellen, sollte ihnen ein kostenloser Tarif (mit dem Namen F0) zur Verfügung stehen.
6. Der App-Name kann einfach mit dem Botnamen identisch bleiben.
7. Belassen Sie die Bot-Vorlage als Basic (C#).
8. App Service-Plan/Standort sollte automatisch für Ihr Konto ausgefüllt worden sein.
9. Legen Sie den Azure Storage fest, den Sie zum Hosten Ihres Bots verwenden möchten. Wenn Sie noch keines haben, können Sie sie hier erstellen.
10. Sie müssen auch bestätigen, dass Sie die für diesen Dienst geltenden 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.
Eine Benachrichtigung wird im Portal angezeigt, sobald der Dienst instance erstellt wurde.
Klicken Sie auf die Benachrichtigung, um Ihre neue Dienst-instance zu erkunden.
Klicken Sie in der Benachrichtigung auf die Schaltfläche Zu Ressource wechseln, um Ihre neue Dienst-instance zu erkunden. Sie werden zu Ihrer neuen Azure-Dienst-instance weitergeleitet.
An diesem Punkt müssen Sie ein Feature namens Direct Line einrichten, damit Ihre Clientanwendung mit dieser Bot Service kommunizieren kann. Klicken Sie auf Kanäle, und klicken Sie dann im Abschnitt Ausgewählte Kanäle hinzufügen auf Direct Line Kanal konfigurieren.
Auf dieser Seite finden Sie die Geheimen Schlüssel , mit denen sich Ihre Client-App beim Bot authentifizieren kann. Klicken Sie auf die Schaltfläche Anzeigen , und nehmen Sie eine Kopie eines der angezeigten Schlüssel an, da Sie diese später in Ihrem Projekt benötigen.

Kapitel 3: Veröffentlichen des Bots in der Azure-Web-App-Bot Service

Nachdem Ihr Dienst nun bereit ist, müssen Sie Ihren zuvor erstellten Botcode in Ihrer neu erstellten Web-App-Bot Service veröffentlichen.

Hinweis

Sie müssen Ihren Bot jedes Mal im Azure-Dienst veröffentlichen, wenn Sie Änderungen an der Bot-Lösung bzw. dem Bot-Code vornehmen.

Zurück Zu Ihrer Visual Studio-Projektmappe, die Sie zuvor erstellt haben.
Klicken Sie mit der rechten Maustaste auf Ihr MyBot-Projekt in der Projektmappen-Explorer, und klicken Sie dann auf Veröffentlichen.
Klicken Sie auf der Seite Veröffentlichungsziel auswählen auf App Service und dann Auf Vorhandene auswählen, und klicken Sie schließlich auf Profil erstellen (Möglicherweise müssen Sie auf den Dropdownpfeil neben der Schaltfläche Veröffentlichen klicken, wenn dieser nicht sichtbar ist).
Wenn Sie noch nicht bei Ihrem Microsoft-Konto angemeldet sind, müssen Sie dies hier tun.
Auf der Seite Veröffentlichen müssen Sie dasselbe Abonnement festlegen, das Sie für die Erstellung von Web App Bot Service verwendet haben. Legen Sie dann die Ansicht als Ressourcengruppe fest, und wählen Sie in der Dropdownordnerstruktur die Ressourcengruppe aus, die Sie zuvor erstellt haben. Klicken Sie auf OK.
Klicken Sie nun auf die Schaltfläche Veröffentlichen , und warten Sie, bis der Bot veröffentlicht wurde (es kann einige Minuten dauern).

Kapitel 4: Einrichten des Unity-Projekts

Im Folgenden ist ein typischer Aufbau für die Entwicklung mit Mixed Reality dargestellt und daher eine gute Vorlage für andere Projekte.

Öffnen Sie Unity , und klicken Sie auf Neu.
Sie müssen nun einen Unity-Projektnamen angeben. Einfügen des HoloLens-Bots Stellen Sie sicher, dass die Projektvorlage auf 3D festgelegt ist. Legen Sie den Speicherort auf einen für Sie geeigneten Ort fest (denken Sie daran, dass näher an Stammverzeichnissen besser ist). Klicken Sie dann auf Projekt erstellen.
Wenn Unity geöffnet ist, lohnt es sich, zu überprüfen, ob der Standardskript-Editor auf Visual Studio festgelegt ist. Navigieren Sie zu Bearbeitungseinstellungen>, 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 wählen Sie Universelle Windows-Plattform aus, und klicken Sie dann auf die Schaltfläche Plattform wechseln, um Ihre Auswahl anzuwenden.
Während Sie sich noch in den Dateibuildeinstellungen > befinden , und stellen Sie sicher, dass:
1. Zielgerät ist auf HoloLens festgelegt.
  
  Legen Sie für die immersiven Headsets Zielgerät auf Beliebiges Gerät fest.
2. Buildtyp ist auf D3D festgelegt.
3. SDK ist auf Latest installed (Neueste Installation) festgelegt.
4. Visual Studio-Version ist auf Latest installed (Neueste Installation) festgelegt.
5. Build and Run ist auf Lokaler 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 Scenes , und geben Sie dann im Textfeld Dateiname: BotScene ein, und klicken Sie dann auf Speichern.
7. Die restlichen Einstellungen in Buildeinstellungen sollten vorerst als Standard beibehalten werden.
Klicken Sie im Fenster Buildeinstellungen auf die Schaltfläche Playereinstellungen . Dadurch wird der zugehörige Bereich in dem 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 :
  1. Die Skriptlaufzeitversion sollte experimentell (NET 4.6-Äquivalent) sein. Um dies zu ändern, ist ein Neustart des Editors erforderlich.
  2. Skript-Back-End sollte .NET sein
  3. API-Kompatibilitätsgrad sollte .NET 4.6 sein.
2. Aktivieren Sie auf der Registerkarte Veröffentlichungseinstellungen unter Funktionen Folgendes:
  - InternetClient
  - Mikrofon
3. Wählen Sie weiter unten im Bereich unter XR-Einstellungen (unter Veröffentlichungseinstellungen) das Kontrollkästchen Virtual Reality Unterstützt aus, und stellen Sie sicher, dass das Windows Mixed Reality SDK hinzugefügt wurde.
Zurück in den Buildeinstellungenunity C#- Projekte ist nicht mehr ausgegraut. aktivieren Sie das Kontrollkästchen neben diesem.
Schließen Sie das Fenster „Build Settings“ (Buildeinstellungen).
Speichern Sie Ihre Szene und Ihr Projekt (FILE > SAVE SCENE /FILE > SAVE PROJECT).

Kapitel 5 – Kameraeinrichtung

Wichtig

Wenn Sie die Unity-Einrichtungskomponente dieses Kurses überspringen und direkt mit dem Code fortfahren möchten, können Sie dieses Azure-MR-312-Package.unitypackage herunterladen, es als benutzerdefiniertes Paket in Ihr Projekt importieren und dann in Kapitel 7 fortfahren.

Wählen Sie im Bereich Hierarchie die Hauptkamera aus.
Nach auswahl können Sie alle Komponenten der Hauptkamera im Inspektorbereich sehen.
1. Das Camera-Objekt muss den Namen Hauptkamera haben (beachten Sie die Schreibweise).
2. Das Hauptkameratag muss auf MainCamera festgelegt werden (beachten Sie die Schreibweise).
3. Stellen Sie sicher, dass die Transformationsposition auf 0, 0, 0 festgelegt ist.
4. Legen Sie Clear Flags auf Volltonfarbe fest.
5. Festlegen der Hintergrundfarbe der Kamerakomponente auf Schwarz, Alpha 0 (Hexadezimalcode: #00000000)

Kapitel 6: Importieren der Newtonsoft-Bibliothek

Damit Sie empfangene und an die Bot Service e Objekte deserialisierens und serialisieren können, müssen Sie die Newtonsoft-Bibliothek herunterladen. Hier finden Sie eine kompatible Version, die bereits mit der richtigen Unity-Ordnerstruktur organisiert ist.

Um die Newtonsoft-Bibliothek in Ihr Projekt zu importieren, verwenden Sie das Unity-Paket, das in diesem Kurs enthalten ist.

Fügen Sie unitypackage zu Unity hinzu, indem Sie die Menüoption Assets>Import Package>Custom Package (Benutzerdefiniertes Paket importieren) verwenden.
Vergewissern Sie sich im eingeblendeten Feld Unity-Paket importieren , dass alles unter (und einschließlich) Plug-Ins ausgewählt ist.
Klicken Sie auf die Schaltfläche Importieren , um die Elemente zu Ihrem Projekt hinzuzufügen.
Wechseln Sie in der Projektansicht zum Ordner Newtonsoft unter Plugins , und wählen Sie das Newtonsoft-Plug-In aus.
Wenn das Newtonsoft-Plug-In ausgewählt ist, stellen Sie sicher, dass Beliebige Plattformdeaktiviert ist. Stellen Sie dann sicher, dass WSAPlayer ebenfalls deaktiviert ist, und klicken Sie dann auf Übernehmen. Dies dient lediglich dazu, zu bestätigen, dass die Dateien ordnungsgemäß konfiguriert sind.

Hinweis

Wenn Sie diese Plug-Ins markieren, werden sie so konfiguriert, dass sie nur im Unity-Editor verwendet werden. Es gibt eine andere Gruppe von ihnen im WSA-Ordner, die verwendet wird, nachdem das Projekt aus Unity exportiert wurde.
Als Nächstes müssen Sie den WSA-Ordner im Ordner Newtonsoft öffnen. Es wird eine Kopie derselben Datei angezeigt, die Sie gerade konfiguriert haben. Wählen Sie die Datei aus, und stellen Sie dann im Inspektor sicher, dass
- Jede Plattform ist deaktiviert.
- NurWSAPlayer ist aktiviert.
- Nicht-Prozessist aktiviert

Kapitel 7: Erstellen des BotTags

Erstellen Sie ein neues Tag-Objekt namens BotTag. Wählen Sie die Hauptkamera in der Szene aus. Klicken Sie im Inspektorbereich auf das Dropdownmenü Tag. Klicken Sie auf Tag hinzufügen.
Klicken Sie auf das + Symbol. Benennen Sie das neue Tag als BotTag, Speichern.

Warnung

Wenden Sie das BotTag nicht auf die Hauptkamera an. Wenn Sie dies versehentlich getan haben, stellen Sie sicher, dass Sie das Tag Hauptkamera wieder in MainCamera ändern.

Kapitel 8: Erstellen der BotObjects-Klasse

Das erste Skript, das Sie erstellen müssen, ist die BotObjects-Klasse . Dabei handelt es sich um eine leere Klasse, die erstellt wurde, sodass eine Reihe anderer Klassenobjekte innerhalb desselben Skripts gespeichert und von anderen Skripts in der Szene aufgerufen werden kann.

Die Erstellung dieser Klasse ist eine rein architektonische Wahl. Diese Objekte können stattdessen im Botskript gehostet werden, das Sie später in diesem Kurs erstellen.

So erstellen Sie diese Klasse:

Klicken Sie mit der rechten Maustaste im Projektbereich, und klicken Sie dann auf Ordner erstellen>. Nennen Sie den Ordner Skripts.
Doppelklicken Sie auf den Ordner Skripts , um ihn zu öffnen. Klicken Sie dann in diesem Ordner mit der rechten Maustaste, und wählen Sie C#-Skript erstellen >aus. Nennen Sie das Skript BotObjects.
Doppelklicken Sie auf das neue BotObjects-Skript , um es mit Visual Studio zu öffnen.

Löschen Sie den Inhalt des Skripts, und ersetzen Sie ihn durch den folgenden Code:

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class BotObjects : MonoBehaviour{}

/// <summary>
/// Object received when first opening a conversation
/// </summary>
[Serializable]
public class ConversationObject
{
    public string ConversationId;
    public string token;
    public string expires_in;
    public string streamUrl;
    public string referenceGrammarId;
}

/// <summary>
/// Object including all Activities
/// </summary>
[Serializable]
public class ActivitiesRootObject
{
    public List<Activity> activities { get; set; }
    public string watermark { get; set; }
}
[Serializable]
public class Conversation
{
    public string id { get; set; }
}
[Serializable]
public class From
{
    public string id { get; set; }
    public string name { get; set; }
}
[Serializable]
public class Activity
{
    public string type { get; set; }
    public string channelId { get; set; }
    public Conversation conversation { get; set; }
    public string id { get; set; }
    public From from { get; set; }
    public string text { get; set; }
    public string textFormat { get; set; }
    public DateTime timestamp { get; set; }
    public string serviceUrl { get; set; }
}

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

Kapitel 9: Erstellen der GazeInput-Klasse

Die nächste Klasse, die Sie erstellen werden, ist die GazeInput-Klasse . Diese Klasse ist für Folgendes zuständig:

Erstellen eines Cursors, der den Blick des Spielers darstellt.
Erkennen von Objekten, die vom Anblick des Spielers getroffen werden, und halten einen Verweis auf erkannte Objekte.

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 GazeInput auf.
Doppelklicken Sie auf das neue GazeInput-Skript , um es mit Visual Studio zu öffnen.

Fügen Sie die folgende Zeile rechts über dem Klassennamen ein:

/// <summary>
/// Class responsible for the User's gaze interactions
/// </summary>
[System.Serializable]
public class GazeInput : MonoBehaviour

Fügen Sie dann die folgenden Variablen in der GazeInput-Klasse oberhalb der Start() -Methode hinzu:

    [Tooltip("Used to compare whether an object is to be interacted with.")]
    internal string InteractibleTag = "BotTag";

    /// <summary>
    /// Length of the gaze
    /// </summary>
    internal float GazeMaxDistance = 300;

    /// <summary>
    /// Object currently gazed
    /// </summary>
    internal GameObject FocusedObject { get; private set; }

    internal GameObject _oldFocusedObject { get; private set; }

    internal RaycastHit HitInfo { get; private set; }

    /// <summary>
    /// Cursor object visible in the scene
    /// </summary>
    internal GameObject Cursor { get; private set; }

    internal bool Hit { get; private set; }

    internal Vector3 Position { get; private set; }

    internal Vector3 Normal { get; private set; }

    private Vector3 _gazeOrigin;

    private Vector3 _gazeDirection;

Code für die Start() -Methode sollte hinzugefügt werden. Dies wird aufgerufen, wenn die -Klasse initialisiert:

    /// <summary>
    /// Start method used upon initialization.
    /// </summary>
    internal virtual void Start()
    {
        FocusedObject = null;
        Cursor = CreateCursor();
    }

Implementieren Sie eine Methode, die den Blickcursor instanziieren und einrichten wird:

    /// <summary>
    /// Method to create a cursor object.
    /// </summary>
    internal GameObject CreateCursor()
    {
        GameObject newCursor = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        newCursor.SetActive(false);
        // Remove the collider, so it does not block Raycast.
        Destroy(newCursor.GetComponent<SphereCollider>());
        newCursor.transform.localScale = new Vector3(0.05f, 0.05f, 0.05f);
        Material mat = new Material(Shader.Find("Diffuse"));
        newCursor.GetComponent<MeshRenderer>().material = mat;
        mat.color = Color.HSVToRGB(0.0223f, 0.7922f, 1.000f);
        newCursor.SetActive(true);

        return newCursor;
    }

Implementieren Sie die Methoden, die den Raycast von der Hauptkamera aus einrichten und das aktuelle fokussierte Objekt nachverfolgen.

    /// <summary>
    /// Called every frame
    /// </summary>
    internal virtual void Update()
    {
        _gazeOrigin = Camera.main.transform.position;

        _gazeDirection = Camera.main.transform.forward;

        UpdateRaycast();
    }


    /// <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))
            {
                // Provide the OnGazeExited event.
                _oldFocusedObject.SendMessage("OnGazeExited", 
                    SendMessageOptions.DontRequireReceiver);
            }
        }
    }


    private void UpdateRaycast()
    {
        // Set the old focused gameobject.
        _oldFocusedObject = FocusedObject;
        RaycastHit hitInfo;

        // Initialize Raycasting.
        Hit = Physics.Raycast(_gazeOrigin,
            _gazeDirection,
            out hitInfo,
            GazeMaxDistance);
        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. If so, reset the focused object.
        if (FocusedObject != _oldFocusedObject)
        {
            ResetFocusedObject();
            if (FocusedObject != null)
            {
                if (FocusedObject.CompareTag(InteractibleTag))
                {
                    // Provide the OnGazeEntered event.
                    FocusedObject.SendMessage("OnGazeEntered",
                        SendMessageOptions.DontRequireReceiver);
                }
            }
        }
    }

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

Kapitel 10: Erstellen der Bot-Klasse

Das Skript, das Sie jetzt erstellen, heißt Bot. Dies ist die Kernklasse Ihrer Anwendung und speichert Folgendes:

Ihre Web App Bot-Anmeldeinformationen
Die Methode, die die Sprachbefehle des Benutzers erfasst.
Die Methode, die zum Initiieren von Unterhaltungen mit Ihrem Web App Bot erforderlich ist
Die Methode, die zum Senden von Nachrichten an Ihren Web App Bot erforderlich ist

Um Nachrichten an die Bot Service zu senden, erstellt die SendMessageToBot()-Coroutine eine Aktivität, bei der es sich um ein Objekt handelt, das vom Bot Framework als vom Benutzer gesendete Daten erkannt wird.

So erstellen Sie diese Klasse:

Doppelklicken Sie auf den Ordner Skripts , um ihn zu öffnen.
Klicken Sie mit der rechten Maustaste in den Ordner Skripts, und klicken Sie auf C#-Skript erstellen>. Nennen Sie das Skript Bot.
Doppelklicken Sie auf das neue Skript, um es mit Visual Studio zu öffnen.

Aktualisieren Sie die Namespaces, soweit sie oben in der Bot-Klasse wie folgt aussehen:

using Newtonsoft.Json;
using System.Collections;
using System.Text;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.Windows.Speech;

Fügen Sie in der Bot-Klasse die folgenden Variablen hinzu:

    /// <summary>
    /// Static instance of this class
    /// </summary>
    public static Bot Instance;

    /// <summary>
    /// Material of the sphere representing the Bot in the scene
    /// </summary>
    internal Material botMaterial;

    /// <summary>
    /// Speech recognizer class reference, which will convert speech to text.
    /// </summary>
    private DictationRecognizer dictationRecognizer;

    /// <summary>
    /// Use this variable to identify the Bot Id
    /// Can be any value
    /// </summary>
    private string botId = "MRBotId";

    /// <summary>
    /// Use this variable to identify the Bot Name
    /// Can be any value
    /// </summary>
    private string botName = "MRBotName";

    /// <summary>
    /// The Bot Secret key found on the Web App Bot Service on the Azure Portal
    /// </summary>
    private string botSecret = "-- Add your Secret Key here --"; 

    /// <summary>
    /// Bot Endpoint, v4 Framework uses v3 endpoint at this point in time
    /// </summary>
    private string botEndpoint = "https://directline.botframework.com/v3/directline";

    /// <summary>
    /// The conversation object reference
    /// </summary>
    private ConversationObject conversation;

    /// <summary>
    /// Bot states to regulate the application flow
    /// </summary>
    internal enum BotState {ReadyToListen, Listening, Processing}

    /// <summary>
    /// Flag for the Bot state
    /// </summary>
    internal BotState botState;

    /// <summary>
    /// Flag for the conversation status
    /// </summary>
    internal bool conversationStarted = false;

Hinweis

Stellen Sie sicher, dass Sie Ihren geheimen Bot-Schlüssel in die botSecret-Variable einfügen. Sie haben Ihren geheimen Bot-Schlüssel zu Beginn dieses Kurses in Kapitel 2, Schritt 10 notiert.

Code für Awake() und Start() muss jetzt hinzugefügt werden.

    /// <summary>
    /// Called on Initialization
    /// </summary>
    void Awake()
    {
        Instance = this;
    }

    /// <summary>
    /// Called immediately after Awake method
    /// </summary>
    void Start()
    {
        botState = BotState.ReadyToListen;
    }

Fügen Sie die beiden Handler hinzu, die von den Sprachbibliotheken aufgerufen werden, wenn die Spracherfassung beginnt und endet. DictationRecognizer beendet automatisch die Erfassung der Benutzerstimme, wenn der Benutzer nicht mehr spricht.

    /// <summary>
    /// Start microphone capture.
    /// </summary>
    public void StartCapturingAudio()
    {
        botState = BotState.Listening;
        botMaterial.color = Color.red;

        // Start dictation
        dictationRecognizer = new DictationRecognizer();
        dictationRecognizer.DictationResult += DictationRecognizer_DictationResult;
        dictationRecognizer.Start();
    }


    /// <summary>
    /// Stop microphone capture.
    /// </summary>
    public void StopCapturingAudio()
    {
        botState = BotState.Processing;
        dictationRecognizer.Stop();
    }

Der folgende Handler erfasst das Ergebnis der Spracheingabe des Benutzers und ruft die Coroutine auf, die für das Senden der Nachricht an die Web-App-Bot Service verantwortlich ist.

    /// <summary>
    /// This handler is called every time the Dictation detects a pause in the speech. 
    /// </summary>
    private void DictationRecognizer_DictationResult(string text, ConfidenceLevel confidence)
    {
        // Update UI with dictation captured
        Debug.Log($"User just said: {text}");      

        // Send dictation to Bot
        StartCoroutine(SendMessageToBot(text, botId, botName, "message"));
        StopCapturingAudio();
    }

Die folgende Coroutine wird aufgerufen, um eine Konversation mit dem Bot zu beginnen. Sie werden feststellen, dass nach Abschluss des Unterhaltungsaufrufs SendMessageToCoroutine() aufgerufen wird, indem eine Reihe von Parametern übergeben werden, die festlegen, dass die Aktivität als leere Nachricht an den Bot Service gesendet wird. Dies geschieht, um den Bot Service aufzufordern, den Dialog zu initiieren.

    /// <summary>
    /// Request a conversation with the Bot Service
    /// </summary>
    internal IEnumerator StartConversation()
    {
        string conversationEndpoint = string.Format("{0}/conversations", botEndpoint);

        WWWForm webForm = new WWWForm();

        using (UnityWebRequest unityWebRequest = UnityWebRequest.Post(conversationEndpoint, webForm))
        {
            unityWebRequest.SetRequestHeader("Authorization", "Bearer " + botSecret);
            unityWebRequest.downloadHandler = new DownloadHandlerBuffer();

            yield return unityWebRequest.SendWebRequest();
            string jsonResponse = unityWebRequest.downloadHandler.text;

            conversation = new ConversationObject();
            conversation = JsonConvert.DeserializeObject<ConversationObject>(jsonResponse);
            Debug.Log($"Start Conversation - Id: {conversation.ConversationId}");
            conversationStarted = true; 
        }

        // The following call is necessary to create and inject an activity of type //"conversationUpdate" to request a first "introduction" from the Bot Service.
        StartCoroutine(SendMessageToBot("", botId, botName, "conversationUpdate"));
    }

Die folgende Coroutine wird aufgerufen, um die Aktivität zu erstellen, die an die Bot Service gesendet werden soll.

    /// <summary>
    /// Send the user message to the Bot Service in form of activity
    /// and call for a response
    /// </summary>
    private IEnumerator SendMessageToBot(string message, string fromId, string fromName, string activityType)
    {
        Debug.Log($"SendMessageCoroutine: {conversation.ConversationId}, message: {message} from Id: {fromId} from name: {fromName}");

        // Create a new activity here
        Activity activity = new Activity();
        activity.from = new From();
        activity.conversation = new Conversation();
        activity.from.id = fromId;
        activity.from.name = fromName;
        activity.text = message;
        activity.type = activityType;
        activity.channelId = "DirectLineChannelId";
        activity.conversation.id = conversation.ConversationId;     

        // Serialize the activity
        string json = JsonConvert.SerializeObject(activity);

        string sendActivityEndpoint = string.Format("{0}/conversations/{1}/activities", botEndpoint, conversation.ConversationId);

        // Send the activity to the Bot
        using (UnityWebRequest www = new UnityWebRequest(sendActivityEndpoint, "POST"))
        {
            www.uploadHandler = new UploadHandlerRaw(Encoding.UTF8.GetBytes(json));

            www.downloadHandler = new DownloadHandlerBuffer();
            www.SetRequestHeader("Authorization", "Bearer " + botSecret);
            www.SetRequestHeader("Content-Type", "application/json");

            yield return www.SendWebRequest();

            // extrapolate the response Id used to keep track of the conversation
            string jsonResponse = www.downloadHandler.text;
            string cleanedJsonResponse = jsonResponse.Replace("\r\n", string.Empty);
            string responseConvId = cleanedJsonResponse.Substring(10, 30);

            // Request a response from the Bot Service
            StartCoroutine(GetResponseFromBot(activity));
        }
    }

Die folgende Coroutine wird aufgerufen, um nach dem Senden einer Aktivität an den Bot Service eine Antwort anzufordern.

    /// <summary>
    /// Request a response from the Bot by using a previously sent activity
    /// </summary>
    private IEnumerator GetResponseFromBot(Activity activity)
    {
        string getActivityEndpoint = string.Format("{0}/conversations/{1}/activities", botEndpoint, conversation.ConversationId);

        using (UnityWebRequest unityWebRequest1 = UnityWebRequest.Get(getActivityEndpoint))
        {
            unityWebRequest1.downloadHandler = new DownloadHandlerBuffer();
            unityWebRequest1.SetRequestHeader("Authorization", "Bearer " + botSecret);

            yield return unityWebRequest1.SendWebRequest();

            string jsonResponse = unityWebRequest1.downloadHandler.text;

            ActivitiesRootObject root = new ActivitiesRootObject();
            root = JsonConvert.DeserializeObject<ActivitiesRootObject>(jsonResponse);

            foreach (var act in root.activities)
            {
                Debug.Log($"Bot Response: {act.text}");
                SetBotResponseText(act.text);
            }

            botState = BotState.ReadyToListen;
            botMaterial.color = Color.blue;
        }
    }

Die letzte Methode, die dieser Klasse hinzugefügt werden soll, ist erforderlich, um die Meldung in der Szene anzuzeigen:
```
    /// <summary>
    /// Set the UI Response Text of the bot
    /// </summary>
    internal void SetBotResponseText(string responseString)
    {        
        SceneOrganiser.Instance.botResponseText.text =  responseString;
    }
```
Hinweis

Möglicherweise wird in der Unity-Editor-Konsole ein Fehler angezeigt, bei dem die SceneOrganiser-Klasse fehlt. Ignorieren Sie diese Meldung, da Sie diese Klasse später im Tutorial erstellen.
Speichern Sie ihre Änderungen in Visual Studio , bevor Sie zu Unity zurückkehren.

Kapitel 11: Erstellen der Interactions-Klasse

Die Klasse, die Sie jetzt erstellen, heißt Interaktionen. Diese Klasse wird verwendet, um die HoloLens Tap-Eingabe des Benutzers zu erkennen.

Wenn der Benutzer beim Betrachten des Bot-Objekts in der Szene tippt und der Bot bereit ist, spracheingaben zu lauschen, ändert sich die Farbe des Bot-Objekts in Rot und beginnt mit dem Lauschen auf Spracheingaben.

Diese Klasse erbt von der GazeInput-Klasse und kann daher auf die Start() -Methode und die Variablen aus dieser Klasse verweisen, die durch die Verwendung von base bezeichnet werden.

So erstellen Sie diese Klasse:

Doppelklicken Sie auf den Ordner Skripts , um ihn zu öffnen.
Klicken Sie mit der rechten Maustaste in den Ordner Skripts, und klicken Sie auf C#-Skript erstellen>. Nennen Sie das Skript Interaktionen.
Doppelklicken Sie auf das neue Skript, um es mit Visual Studio zu öffnen.
Aktualisieren Sie die Namespaces und die Klassenvererbung so, dass sie am Anfang der Interactions-Klasse mit den folgenden identisch sind:
```
using UnityEngine.XR.WSA.Input;

public class Interactions : GazeInput
{
```

Fügen Sie in der Interactions-Klasse die folgende Variable hinzu:

    /// <summary>
    /// Allows input recognition with the HoloLens
    /// </summary>
    private GestureRecognizer _gestureRecognizer;

Fügen Sie dann die Start()- Methode hinzu:

    /// <summary>
    /// Called on initialization, after Awake
    /// </summary>
    internal override void Start()
    {
        base.Start();

        //Register the application to recognize HoloLens user inputs
        _gestureRecognizer = new GestureRecognizer();
        _gestureRecognizer.SetRecognizableGestures(GestureSettings.Tap);
        _gestureRecognizer.Tapped += GestureRecognizer_Tapped;
        _gestureRecognizer.StartCapturingGestures();
    }

Fügen Sie den Handler hinzu, der ausgelöst wird, wenn der Benutzer die Tippbewegung vor der HoloLens-Kamera ausführt.

    /// <summary>
    /// Detects the User Tap Input
    /// </summary>
    private void GestureRecognizer_Tapped(TappedEventArgs obj)
    {
        // Ensure the bot is being gazed upon.
        if(base.FocusedObject != null)
        {
            // If the user is tapping on Bot and the Bot is ready to listen
            if (base.FocusedObject.name == "Bot" && Bot.Instance.botState == Bot.BotState.ReadyToListen)
            {
                // If a conversation has not started yet, request one
                if(Bot.Instance.conversationStarted)
                {
                    Bot.Instance.SetBotResponseText("Listening...");
                    Bot.Instance.StartCapturingAudio();
                }
                else
                {
                    Bot.Instance.SetBotResponseText("Requesting Conversation...");
                    StartCoroutine(Bot.Instance.StartConversation());
                }                                  
            }
        }
    }

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

Kapitel 12: Erstellen der SceneOrganiser-Klasse

Die letzte in diesem Lab erforderliche Klasse heißt SceneOrganiser. Mit dieser Klasse wird die Szene programmgesteuert eingerichtet, indem Komponenten und Skripts zur Hauptkamera hinzugefügt und die entsprechenden Objekte in der Szene erstellt werden.

So erstellen Sie diese Klasse:

Doppelklicken Sie auf den Ordner Skripts , um ihn zu öffnen.
Klicken Sie mit der rechten Maustaste in den Ordner Skripts, und klicken Sie auf C#-Skript erstellen>. Nennen Sie das Skript SceneOrganiser.
Doppelklicken Sie auf das neue Skript, um es mit Visual Studio zu öffnen.

Fügen Sie in der SceneOrganiser-Klasse die folgenden Variablen hinzu:

    /// <summary>
    /// Static instance of this class
    /// </summary>
    public static SceneOrganiser Instance;

    /// <summary>
    /// The 3D text representing the Bot response
    /// </summary>
    internal TextMesh botResponseText;

Fügen Sie dann die Methoden Awake() und Start() hinzu:

    /// <summary>
    /// Called on Initialization
    /// </summary>
    private void Awake()
    {
        Instance = this;
    }

    /// <summary>
    /// Called immediately after Awake method
    /// </summary>
    void Start ()
    {
        // Add the GazeInput class to this object
        gameObject.AddComponent<GazeInput>();

        // Add the Interactions class to this object
        gameObject.AddComponent<Interactions>();

        // Create the Bot in the scene
        CreateBotInScene();
    }

Fügen Sie die folgende Methode hinzu, die für das Erstellen des Bot-Objekts in der Szene und das Einrichten der Parameter und Komponenten verantwortlich ist:

    /// <summary>
    /// Create the Sign In button object in the scene
    /// and sets its properties
    /// </summary>
    private void CreateBotInScene()
    {
        GameObject botObjInScene = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        botObjInScene.name = "Bot";

        // Add the Bot class to the Bot GameObject
        botObjInScene.AddComponent<Bot>();

        // Create the Bot UI
        botResponseText = CreateBotResponseText();

        // Set properties of Bot GameObject
        Bot.Instance.botMaterial = new Material(Shader.Find("Diffuse"));
        botObjInScene.GetComponent<Renderer>().material = Bot.Instance.botMaterial;
        Bot.Instance.botMaterial.color = Color.blue;
        botObjInScene.transform.position = new Vector3(0f, 2f, 10f);
        botObjInScene.tag = "BotTag";
    }

Fügen Sie die folgende Methode hinzu, die für das Erstellen des UI-Objekts in der Szene verantwortlich ist und die Antworten des Bots darstellt:

    /// <summary>
    /// Spawns cursor for the Main Camera
    /// </summary>
    private TextMesh CreateBotResponseText()
    {
        // Create a sphere as new cursor
        GameObject textObject = new GameObject();
        textObject.transform.parent = Bot.Instance.transform;
        textObject.transform.localPosition = new Vector3(0,1,0);

        // Resize the new cursor
        textObject.transform.localScale = new Vector3(0.1f, 0.1f, 0.1f);

        // Creating the text of the Label
        TextMesh textMesh = textObject.AddComponent<TextMesh>();
        textMesh.anchor = TextAnchor.MiddleCenter;
        textMesh.alignment = TextAlignment.Center;
        textMesh.fontSize = 50;
        textMesh.text = "Hi there, tap on me and I will start listening.";

        return textMesh;
    }

Speichern Sie ihre Änderungen in Visual Studio , bevor Sie zu Unity zurückkehren.
Ziehen Sie im Unity-Editor das Skript SceneOrganiser aus dem Ordner Skripts in die Hauptkamera. Die Komponente Scene Organizer sollte nun im Hauptkameraobjekt angezeigt werden, wie in der folgenden Abbildung dargestellt.

Kapitel 13 – Vor dem Bau

Um einen gründlichen Test Ihrer Anwendung durchzuführen, müssen Sie sie auf Ihre HoloLens querladen. Stellen Sie zunächst Folgendes sicher:

Alle in Kapitel 4 erwähnten Einstellungen sind ordnungsgemäß festgelegt.
Das Skript SceneOrganiser ist an das Hauptkameraobjekt angefügt.
Stellen Sie in der Bot-Klasse sicher, dass Sie Ihren geheimen Bot-Schlüssel in die botSecret-Variable eingefügt haben.

Kapitel 14: Erstellen und Querladen in die HoloLens

Alles, was für den Unity-Abschnitt dieses Projekts benötigt wird, wurde nun abgeschlossen, daher ist es an der Zeit, es aus Unity zu erstellen.

Navigieren Sie zu Buildeinstellungen, Dateibuildeinstellungen > ....
Klicken Sie im Fenster Buildeinstellungen auf Erstellen.
Wenn noch nicht geschehen, markieren Sie Unity C#-Projekte.
Klicken Sie auf Erstellen. Unity startet ein Explorer Fenster, in dem Sie einen Ordner erstellen und dann auswählen müssen, in dem die App erstellt werden soll. Erstellen Sie diesen Ordner jetzt, und nennen Sie ihn App. Klicken Sie dann bei ausgewählter App-Ordner auf Ordner auswählen.
Unity beginnt mit dem Erstellen Ihres Projekts im Ordner App .
Sobald Unity den Bau abgeschlossen hat (es kann einige Zeit dauern), öffnet es ein Explorer Fenster an der Position Ihres Builds (überprüfen Sie Ihre Taskleiste, da es möglicherweise nicht immer über Ihren Fenstern angezeigt wird, aber Sie über das Hinzufügen eines neuen Fensters benachrichtigt).

Kapitel 15: Bereitstellen in HoloLens

So stellen Sie auf HoloLens bereit:

Sie benötigen die IP-Adresse Ihrer HoloLens (für Remote Deploy) und um sicherzustellen, dass sich Ihre HoloLens im Entwicklermodus befindet. Gehen Sie dazu folgendermaßen vor:
1. Öffnen Sie die Einstellungen, während Sie Ihre HoloLens tragen.
2. Wechseln Sie zu Netzwerk & Internet > Wi-Fi > Erweiterte Optionen.
3. Notieren Sie sich die IPv4-Adresse .
4. Navigieren Sie als Nächstes zurück zu Einstellungen und dann zu Aktualisieren & Sicherheit > für Entwickler.
5. Legen Sie den Entwicklermodus ein.
Navigieren Sie zu Ihrem neuen Unity-Build (dem Ordner App ), und öffnen Sie die Projektmappendatei mit Visual Studio.
Wählen Sie in der Projektmappenkonfigurationdebuggen aus.
Wählen Sie auf der Lösungsplattformdie Option x86, Remotecomputer aus.
Wechseln Sie zum Menü Erstellen , und klicken Sie auf Lösung bereitstellen, um die Anwendung in Ihre HoloLens querzuladen.
Ihre App sollte jetzt in der Liste der installierten Apps auf Ihrer HoloLens angezeigt werden, bereit für den Start!

Hinweis

Legen Sie für die Bereitstellung auf einem immersiven Headset die Lösungsplattform auf Lokaler Computer fest, und legen Sie die Konfiguration auf Debuggen fest, wobei x86 als Plattform verwendet wird. Stellen Sie dann auf dem lokalen Computer bereit, und wählen Sie im Menü Erstellen die Option Lösung bereitstellen aus.

Kapitel 16 : Verwenden der Anwendung auf der HoloLens

Nachdem Sie die Anwendung gestartet haben, sehen Sie den Bot als blaue Kugel vor Ihnen.
Verwenden Sie die Tippgeste , während Sie auf die Kugel blicken, um eine Unterhaltung zu initiieren.
Warten Sie, bis die Unterhaltung gestartet wird (auf der Benutzeroberfläche wird eine Meldung angezeigt, wenn dies geschieht). Nachdem Sie die einführende Nachricht vom Bot erhalten haben, tippen Sie erneut auf den Bot, damit er rot wird und beginnt, Ihre Stimme zu hören.
Sobald Sie das Gespräch beenden, sendet Ihre Anwendung Ihre Nachricht an den Bot, und Sie erhalten umgehend eine Antwort, die auf der Benutzeroberfläche angezeigt wird.
Wiederholen Sie den Vorgang, um weitere Nachrichten an Ihren Bot zu senden (Sie müssen jedes Mal tippen, wenn Sie eine Nachricht senden möchten).

In dieser Unterhaltung wird veranschaulicht, wie der Bot Informationen (Ihren Namen) beibehalten und gleichzeitig bekannte Informationen (z. B. die vorgehaltenen Elemente) bereitstellt.

Einige Fragen, die sie dem Bot stellen müssen:

what do you sell? 

how much are umbrellas?

how much are raincoats?

Ihre fertige Web App Bot(v4)-Anwendung

Herzlichen Glückwunsch! Sie haben eine Mixed Reality-App erstellt, die den Azure-Web-App-Bot Microsoft Bot Framework v4 nutzt.

Endprodukt

Zusatzübungen

Übung 1

Die Konversationsstruktur in diesem Lab ist sehr einfach. Verwenden Sie Microsoft LUIS, um Ihrem Bot Funktionen zum Verstehen natürlicher Sprache zu bieten.

Übung 2

Dieses Beispiel umfasst nicht das Beenden einer Unterhaltung und das Neustarten einer neuen Unterhaltung. Um das Bot-Feature abzuschließen, versuchen Sie, den Abschluss der Unterhaltung zu implementieren.

HoloLens (1. Generation) und Azure 312: Botintegration

Geräteunterstützung

Voraussetzungen

Vorbereitung

Kapitel 1: Erstellen der Botanwendung

Kapitel 2: Erstellen des Azure-Bot Service

Kapitel 3: Veröffentlichen des Bots in der Azure-Web-App-Bot Service

Kapitel 4: Einrichten des Unity-Projekts

Kapitel 5 – Kameraeinrichtung

Kapitel 6: Importieren der Newtonsoft-Bibliothek

Kapitel 7: Erstellen des BotTags

Kapitel 8: Erstellen der BotObjects-Klasse

Kapitel 9: Erstellen der GazeInput-Klasse

Kapitel 10: Erstellen der Bot-Klasse

Kapitel 11: Erstellen der Interactions-Klasse

Kapitel 12: Erstellen der SceneOrganiser-Klasse

Kapitel 13 – Vor dem Bau

Kapitel 14: Erstellen und Querladen in die HoloLens

Kapitel 15: Bereitstellen in HoloLens

Kapitel 16 : Verwenden der Anwendung auf der HoloLens

Einige Fragen, die sie dem Bot stellen müssen:

Ihre fertige Web App Bot(v4)-Anwendung

Zusatzübungen

Übung 1

Übung 2

Zusätzliche Ressourcen