HoloLens (första generationen) Indata 212: Röst

Viktigt

Självstudierna Mixed Reality Academy har utformats med HoloLens (första generationen), Unity 2017 och Mixed Reality integrerande headset i åtanke. Därför anser vi att det är viktigt att låta de här självstudierna vara kvar för utvecklare som fortfarande letar efter vägledning för att utveckla för dessa enheter. De här självstudierna uppdateras inte med de senaste verktygsuppsättningarna eller interaktionerna som används för HoloLens 2 och kanske inte är kompatibla med nyare versioner av Unity. De underhålls för att fortsätta arbeta på de enheter som stöds. En ny serie självstudier har publicerats för HoloLens 2.

Röstinmatning ger oss ett annat sätt att interagera med våra hologram. Röstkommandon fungerar på ett mycket naturligt och enkelt sätt. Utforma dina röstkommandon så att de är:

• Naturliga
• Lätt att komma ihåg
• Lämplig kontext
• Tillräckligt skild från andra alternativ inom samma kontext

I MR Basics 101 använde vi KeywordRecognizer för att skapa två enkla röstkommandon. I MR Input 212 går vi djupare och lär oss att:

• Utforma röstkommandon som är optimerade för HoloLens-talmotorn.
• Gör användaren medveten om vilka röstkommandon som är tillgängliga.
• Bekräfta att vi har hört användarens röstkommando.
• Förstå vad användaren säger med hjälp av en diktamensigenkänning.
• Använd en grammatikigenkänning för att lyssna efter kommandon baserat på en SRGS-fil eller en fil med grammatikspecifikation för taligenkänning.

I den här kursen går vi tillbaka till Model Explorer, som vi skapade i MR Input 210 och MR Input 211.

Viktigt

Videorna som är inbäddade i vart och ett av kapitlen nedan spelades in med hjälp av en äldre version av Unity och Mixed Reality Toolkit. Även om de stegvisa instruktionerna är korrekta och aktuella kan du se skript och visuella objekt i motsvarande videor som är inaktuella. Videorna förblir inkluderade för eftervärlden och eftersom de begrepp som beskrivs fortfarande gäller.

Stöd för enheter

Kurs	HoloLens	Integrerande headset
MR-indata 212: Röst	✔️	✔️

Innan du börjar

Förutsättningar

• En Windows 10 dator som konfigurerats med rätt verktyg installerade.
• Vissa grundläggande C#-programmeringskunskaper.
• Du borde ha slutfört MR Basics 101.
• Du bör ha slutfört MR Input 210.
• Du bör ha slutfört MR Input 211.
• En HoloLens-enhet som konfigurerats för utveckling.

Projektfiler

• Ladda ned de filer som krävs av projektet. Kräver Unity 2017.2 eller senare.
• Avarkivera filerna på skrivbordet eller på en annan plats som är enkel att nå.

Anteckning

Om du vill titta igenom källkoden innan du laddar ned den är den tillgänglig på GitHub.

Errata och anteckningar

• "Aktivera Just My Code" måste inaktiveras (avmarkerat) i Visual Studio under Verktyg-Alternativ-Felsökning>> för att nå brytpunkter i koden.

Unity-installation

Instruktioner

1. Starta Unity.
2. Välj Öppna.
3. Gå till mappen HolographicAcademy-Holograms-212-Voice som du tidigare avarkiverade.
4. Leta upp och välj mappen Starta/modellutforskaren .
5. Klicka på knappen Välj mapp .
6. I projektpanelen expanderar du mappen Scener .
7. Dubbelklicka på ModelExplorer-scenen för att läsa in den i Unity.

Byggnad

1. I Unity väljer du Inställningar för filbygge>.
2. Om Scenes/ModelExplorer inte visas i Scener i build klickar du på Lägg till öppna scener för att lägga till scenen.
3. Om du utvecklar specifikt för HoloLens anger du Målenhet till HoloLens. Annars lämnar du den på Valfri enhet.
4. Se till att versionstypen är inställd på D3D och att SDK är inställt på Senaste installerat (som ska vara SDK 16299 eller senare).
5. Klicka på Skapa.
6. Skapa en ny mapp med namnet "App".
7. Klicka på mappen App .
8. Tryck på Välj mapp så börjar Unity skapa projektet för Visual Studio.

När Unity är klart visas ett Utforskaren fönster.

1. Öppna mappen App .
2. Öppna Lösningen ModelExplorer Visual Studio.

Om du distribuerar till HoloLens:

1. Använd det översta verktygsfältet i Visual Studio och ändra målet från Felsökning till Släpp och från ARM till x86.
2. Klicka på listrutepilen bredvid knappen Lokal dator och välj Fjärrdator.
3. Ange din HoloLens-enhets-IP-adress och ange Autentiseringsläge till Universellt (okrypterat protokoll). Klicka på Välj. Om du inte känner till enhetens IP-adress tittar du i Inställningar > Nätverk & Avancerade Internetalternativ>.
4. I den översta menyraden klickar du på Felsöka –> Starta utan felsökning eller tryck på Ctrl + F5. Om det här är första gången du distribuerar till enheten måste du koppla den till Visual Studio.
5. När appen har distribuerats stänger du Fitbox med en select-gest.

Om du distribuerar till ett uppslukande headset:

1. Använd det översta verktygsfältet i Visual Studio och ändra målet från Felsökning till Släpp och från ARM till x64.
2. Kontrollera att distributionsmålet är inställt på Lokal dator.
3. I den översta menyraden klickar du på Felsöka –> Starta utan felsökning eller tryck på Ctrl + F5.
4. När appen har distribuerats stänger du Fitbox genom att trycka på utlösaren på en rörelsestyrenhet.

Anteckning

Du kanske ser några röda fel på panelen Visual Studio-fel. Det är säkert att ignorera dem. Växla till panelen Utdata för att visa faktiska byggframsteg. Fel i utdatapanelen kräver att du gör en korrigering (oftast orsakas de av ett misstag i ett skript).

Kapitel 1 – Medvetenhet

Mål

• Lär dig hur du använder röstkommandodesignen Dos and Don'ts .
• Använd KeywordRecognizer för att lägga till blickbaserade röstkommandon.
• Gör användarna medvetna om röstkommandon med hjälp av feedback från markören.

Röstkommandodesign

I det här kapitlet får du lära dig hur du utformar röstkommandon. När du skapar röstkommandon:

DO

• Skapa koncisa kommandon. Du vill inte använda "Spela upp den valda videon" eftersom det kommandot inte är koncist och enkelt skulle glömmas bort av användaren. I stället bör du använda: "Spela upp video", eftersom det är koncist och har flera stavelser.
• Använd ett enkelt ordförråd. Försök alltid att använda vanliga ord och fraser som är enkla för användaren att identifiera och komma ihåg. Om ditt program till exempel hade ett anteckningsobjekt som kunde visas eller döljas från vyn skulle du inte använda kommandot "Visa plakat", eftersom "plakat" är en term som sällan används. I stället använder du kommandot " Visa anteckning" för att visa anteckningen i ditt program.
• Var konsekvent. Röstkommandon ska hållas konsekventa i hela programmet. Anta att du har två scener i ditt program och att båda scenerna innehåller en knapp för att stänga programmet. Om den första scenen använde kommandot "Avsluta" för att utlösa knappen, men den andra scenen använde kommandot "Stäng app", kommer användaren att bli mycket förvirrad. Om samma funktion kvarstår i flera scener bör samma röstkommando användas för att utlösa den.

GÖR INTE

• Använd enkla stavningsbara kommandon. Om du till exempel skapar ett röstkommando för att spela upp en video bör du undvika att använda det enkla kommandot "Play", eftersom det bara är en enda stavelser och enkelt kan missas av systemet. I stället bör du använda: "Spela upp video", eftersom det är koncist och har flera stavelser.
• Använd systemkommandon. Kommandot "Välj" är reserverat av systemet för att utlösa en Tap-händelse för det aktuella fokuserade objektet. Använd inte kommandot "Välj" igen i ett nyckelord eller en fras, eftersom det kanske inte fungerar som förväntat. Om röstkommandot för att välja en kub i programmet till exempel var "Välj kub", men användaren tittade på en sfär när de yttrade kommandot, skulle sfären väljas i stället. På samma sätt är appfältkommandon röstaktiverade. Använd inte följande talkommandon i CoreWindow-vyn:
  1. Gå tillbaka
  2. Rullningsverktyg
  3. Zoomverktyg
  4. Dra verktyg
  5. Justera
  6. Ta bort
• Använd liknande ljud. Försök att undvika att använda röstkommandon som rimmar. Om du hade ett shoppingprogram som hade stöd för "Show Store" och "Show More" som röstkommandon, skulle du vilja inaktivera ett av kommandona medan det andra användes. Du kan till exempel använda knappen "Visa butik" för att öppna arkivet och sedan inaktivera kommandot när arkivet visades så att kommandot "Visa mer" kan användas för surfning.

Instruktioner

• I Unitys hierarkipanel använder du sökverktyget för att hitta objektet holoComm_screen_mesh .
• Dubbelklicka på objektet holoComm_screen_mesh för att visa det i scenen. Det här är astronautens watch, som svarar på våra röstkommandon.
• Leta reda på komponenten Speech Input Source (Script) på panelen Kontroll.
• Expandera avsnittet Nyckelord för att se röstkommandot som stöds: Öppna Communicator.
• Klicka på kugghjulet till höger och välj sedan Redigera skript.
• Utforska SpeechInputSource.cs för att förstå hur det använder KeywordRecognizer för att lägga till röstkommandon.

Skapa och distribuera

• I Unity använder du Inställningar för filskapning > för att återskapa programmet.
• Öppna mappen App .
• Öppna Lösningen ModelExplorer Visual Studio.

(Om du redan har skapat/distribuerat det här projektet i Visual Studio under konfigurationen kan du öppna den instansen av VS och klicka på Läs in alla igen när du uppmanas att göra det).

• I Visual Studio klickar du på Felsöka –> Starta utan felsökning eller tryck på Ctrl + F5.
• När programmet har distribuerats till HoloLens stänger du fit-rutan med hjälp av lufttryckningsgesten .
• Titta på astronautens watch.
• När watch har fokus kontrollerar du att markören ändras till en mikrofon. Detta ger feedback om att programmet lyssnar efter röstkommandon.
• Kontrollera att en knappbeskrivning visas på watch. Detta hjälper användarna att identifiera kommandot "Open Communicator" .
• När du tittar på watch, säg "Open Communicator" för att öppna kommunikationspanelen.

Kapitel 2 – Bekräftelse

Mål

• Spela in ett meddelande med mikrofonindata.
• Ge feedback till användaren om att programmet lyssnar på deras röst.

Anteckning

Mikrofonfunktionen måste deklareras för att en app ska kunna spela in från mikrofonen. Detta görs för dig redan i MR Input 212, men tänk på detta för dina egna projekt.

1. I Unity-redigeraren går du till spelarinställningarna genom att gå till "Redigera > projektinställningar > spelare"
2. Klicka på fliken "Universell Windows-plattform"
3. I avsnittet "Funktioner för publiceringsinställningar>" kontrollerar du mikrofonfunktionen

Instruktioner

• Kontrollera att det holoComm_screen_mesh objektet är markerat på panelen Hierarki i Unity.
• Leta reda på komponenten Astronaut Watch (Script) i panelen Inspector.
• Klicka på den lilla blå kuben som anges som värdet för egenskapen Communicator Prefab .
• I projektpanelen bör Communicator-prefab nu ha fokus.
• Klicka på prefab för Communicator i projektpanelen för att visa dess komponenter i Inspector.
• Titta på komponenten Microphone Manager (Script) så att vi kan spela in användarens röst.
• Observera att Communicator-objektet har en Speech Input Handler-komponent (skript) för att svara på kommandot Skicka meddelande .
• Titta på komponenten Communicator (Script) och dubbelklicka på skriptet för att öppna det i Visual Studio.

Communicator.cs ansvarar för att ange rätt knapptillstånd på kommunikationsenheten. Detta gör att våra användare kan spela in ett meddelande, spela upp det och skicka meddelandet till astronauten. Det kommer också att starta och stoppa en animerad vågform, för att bekräfta för användaren att deras röst hördes.

• Ta bort följande rader (81 och 82) från startmetoden i Communicator.cs. Då aktiveras knappen "Spela in" i kommunikatören.

// TODO: 2.a Delete the following two lines:
RecordButton.SetActive(false);
MessageUIRenderer.gameObject.SetActive(false);

Skapa och distribuera

• I Visual Studio återskapar du programmet och distribuerar det till enheten.
• Titta på astronautens watch och säg "Open Communicator" för att visa kommunikatören.
• Tryck på knappen Spela in (mikrofon) för att börja spela in ett verbalt meddelande för astronauten.
• Börja tala och kontrollera att våganimeringen spelas upp på kommunikatören, vilket ger feedback till användaren om att deras röst hörs.
• Tryck på knappen Stoppa (vänster fyrkant) och kontrollera att våganimeringen slutar att köras.
• Tryck på knappen Spela upp (höger triangel) för att spela upp det inspelade meddelandet och höra det på enheten.
• Tryck på knappen Stoppa (höger fyrkant) för att stoppa uppspelningen av det inspelade meddelandet.
• Säg "Skicka meddelande" för att stänga kommunikatören och ta emot ett "Mottaget meddelande"-svar från astronauten.

Kapitel 3 – Förstå och diktamensigenkänning

Mål

• Använd dikteringsigenkänningen för att konvertera användarens tal till text.
• Visa dikteringsigenkänningens hypotetiska och slutliga resultat i kommunikatorn.

I det här kapitlet använder vi diktamensigenkänning för att skapa ett meddelande för astronauten. Tänk på följande när du använder dikteringsigenkänningen:

• Du måste vara ansluten till WiFi för att dikteringsigenkänningen ska fungera.
• Tidsgränser inträffar efter en angiven tidsperiod. Det finns två tidsgränser att vara medveten om:
  • Om identifieraren startar och inte hör något ljud under de första fem sekunderna överskrids tidsgränsen.
  • Om identifieraren har gett ett resultat men sedan hör tystnad i tjugo sekunder kommer tidsgränsen att nås.
• Endast en typ av identifierare (nyckelord eller diktering) kan köras i taget.

Anteckning

Mikrofonfunktionen måste deklareras för att en app ska kunna spela in från mikrofonen. Detta görs för dig redan i MR Input 212, men tänk på detta för dina egna projekt.

1. I Unity-redigeraren går du till spelarinställningarna genom att gå till "Redigera > projektinställningar > spelare"
2. Klicka på fliken "Universell Windows-plattform"
3. I avsnittet "Funktioner för publiceringsinställningar>" kontrollerar du mikrofonfunktionen

Instruktioner

Vi ska redigera MicrophoneManager.cs för att använda dikteringsigenkänningen. Det här ska vi lägga till:

1. När knappen Spela in trycks in startar vi diktamenRecognizer.
2. Visa hypotesen om vad diktamenRecognizer förstod.
3. Lås in resultatet av vad DictationRecognizer förstod.
4. Sök efter timeouter från DictationRecognizer.
5. När knappen Stoppa trycks in eller mikrofonsessionen överskrider tidsgränsen stoppar du dikteringenRecognizer.
6. Starta om KeywordRecognizer, som lyssnar efter kommandot Skicka meddelande .

Nu sätter vi igång. Slutför alla kodningsövningar för 3.a i MicrophoneManager.cs, eller kopiera och klistra in den färdiga koden som finns nedan:

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

using System.Collections;
using System.Text;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Windows.Speech;

namespace Academy
{
    public class MicrophoneManager : MonoBehaviour
    {
        [Tooltip("A text area for the recognizer to display the recognized strings.")]
        [SerializeField]
        private Text dictationDisplay;

        private DictationRecognizer dictationRecognizer;

        // Use this string to cache the text currently displayed in the text box.
        private StringBuilder textSoFar;

        // Using an empty string specifies the default microphone.
        private static string deviceName = string.Empty;
        private int samplingRate;
        private const int messageLength = 10;

        // Use this to reset the UI once the Microphone is done recording after it was started.
        private bool hasRecordingStarted;

        void Awake()
        {
            /* TODO: DEVELOPER CODING EXERCISE 3.a */

            // 3.a: Create a new DictationRecognizer and assign it to dictationRecognizer variable.
            dictationRecognizer = new DictationRecognizer();

            // 3.a: Register for dictationRecognizer.DictationHypothesis and implement DictationHypothesis below
            // This event is fired while the user is talking. As the recognizer listens, it provides text of what it's heard so far.
            dictationRecognizer.DictationHypothesis += DictationRecognizer_DictationHypothesis;

            // 3.a: Register for dictationRecognizer.DictationResult and implement DictationResult below
            // This event is fired after the user pauses, typically at the end of a sentence. The full recognized string is returned here.
            dictationRecognizer.DictationResult += DictationRecognizer_DictationResult;

            // 3.a: Register for dictationRecognizer.DictationComplete and implement DictationComplete below
            // This event is fired when the recognizer stops, whether from Stop() being called, a timeout occurring, or some other error.
            dictationRecognizer.DictationComplete += DictationRecognizer_DictationComplete;

            // 3.a: Register for dictationRecognizer.DictationError and implement DictationError below
            // This event is fired when an error occurs.
            dictationRecognizer.DictationError += DictationRecognizer_DictationError;

            // Query the maximum frequency of the default microphone. Use 'unused' to ignore the minimum frequency.
            int unused;
            Microphone.GetDeviceCaps(deviceName, out unused, out samplingRate);

            // Use this string to cache the text currently displayed in the text box.
            textSoFar = new StringBuilder();

            // Use this to reset the UI once the Microphone is done recording after it was started.
            hasRecordingStarted = false;
        }

        void Update()
        {
            // 3.a: Add condition to check if dictationRecognizer.Status is Running
            if (hasRecordingStarted && !Microphone.IsRecording(deviceName) && dictationRecognizer.Status == SpeechSystemStatus.Running)
            {
                // Reset the flag now that we're cleaning up the UI.
                hasRecordingStarted = false;

                // This acts like pressing the Stop button and sends the message to the Communicator.
                // If the microphone stops as a result of timing out, make sure to manually stop the dictation recognizer.
                // Look at the StopRecording function.
                SendMessage("RecordStop");
            }
        }

        /// <summary>
        /// Turns on the dictation recognizer and begins recording audio from the default microphone.
        /// </summary>
        /// <returns>The audio clip recorded from the microphone.</returns>
        public AudioClip StartRecording()
        {
            // 3.a Shutdown the PhraseRecognitionSystem. This controls the KeywordRecognizers
            PhraseRecognitionSystem.Shutdown();

            // 3.a: Start dictationRecognizer
            dictationRecognizer.Start();

            // 3.a Uncomment this line
            dictationDisplay.text = "Dictation is starting. It may take time to display your text the first time, but begin speaking now...";

            // Set the flag that we've started recording.
            hasRecordingStarted = true;

            // Start recording from the microphone for 10 seconds.
            return Microphone.Start(deviceName, false, messageLength, samplingRate);
        }

        /// <summary>
        /// Ends the recording session.
        /// </summary>
        public void StopRecording()
        {
            // 3.a: Check if dictationRecognizer.Status is Running and stop it if so
            if (dictationRecognizer.Status == SpeechSystemStatus.Running)
            {
                dictationRecognizer.Stop();
            }

            Microphone.End(deviceName);
        }

        /// <summary>
        /// This event is fired while the user is talking. As the recognizer listens, it provides text of what it's heard so far.
        /// </summary>
        /// <param name="text">The currently hypothesized recognition.</param>
        private void DictationRecognizer_DictationHypothesis(string text)
        {
            // 3.a: Set DictationDisplay text to be textSoFar and new hypothesized text
            // We don't want to append to textSoFar yet, because the hypothesis may have changed on the next event
            dictationDisplay.text = textSoFar.ToString() + " " + text + "...";
        }

        /// <summary>
        /// This event is fired after the user pauses, typically at the end of a sentence. The full recognized string is returned here.
        /// </summary>
        /// <param name="text">The text that was heard by the recognizer.</param>
        /// <param name="confidence">A representation of how confident (rejected, low, medium, high) the recognizer is of this recognition.</param>
        private void DictationRecognizer_DictationResult(string text, ConfidenceLevel confidence)
        {
            // 3.a: Append textSoFar with latest text
            textSoFar.Append(text + ". ");

            // 3.a: Set DictationDisplay text to be textSoFar
            dictationDisplay.text = textSoFar.ToString();
        }

        /// <summary>
        /// This event is fired when the recognizer stops, whether from Stop() being called, a timeout occurring, or some other error.
        /// Typically, this will simply return "Complete". In this case, we check to see if the recognizer timed out.
        /// </summary>
        /// <param name="cause">An enumerated reason for the session completing.</param>
        private void DictationRecognizer_DictationComplete(DictationCompletionCause cause)
        {
            // If Timeout occurs, the user has been silent for too long.
            // With dictation, the default timeout after a recognition is 20 seconds.
            // The default timeout with initial silence is 5 seconds.
            if (cause == DictationCompletionCause.TimeoutExceeded)
            {
                Microphone.End(deviceName);

                dictationDisplay.text = "Dictation has timed out. Please press the record button again.";
                SendMessage("ResetAfterTimeout");
            }
        }

        /// <summary>
        /// This event is fired when an error occurs.
        /// </summary>
        /// <param name="error">The string representation of the error reason.</param>
        /// <param name="hresult">The int representation of the hresult.</param>
        private void DictationRecognizer_DictationError(string error, int hresult)
        {
            // 3.a: Set DictationDisplay text to be the error string
            dictationDisplay.text = error + "\nHRESULT: " + hresult;
        }

        /// <summary>
        /// The dictation recognizer may not turn off immediately, so this call blocks on
        /// the recognizer reporting that it has actually stopped.
        /// </summary>
        public IEnumerator WaitForDictationToStop()
        {
            while (dictationRecognizer != null && dictationRecognizer.Status == SpeechSystemStatus.Running)
            {
                yield return null;
            }
        }
    }
}

Skapa och distribuera

• Återskapa i Visual Studio och distribuera till din enhet.
• Stäng fit boxen med en lufttryckningsgest.
• Titta på astronautens watch och säg "Öppna kommunikatör".
• Välj knappen Spela in (mikrofon) för att spela in meddelandet.
• Börja prata. Dikteringsigenkänningen tolkar ditt tal och visar den hypotetiska texten i kommunikatorn.
• Försök att säga "Skicka meddelande" när du spelar in ett meddelande. Observera att nyckelordsigenkänningen inte svarar eftersom dikteringsigenkänningen fortfarande är aktiv.
• Sluta tala i några sekunder. Se när dikteringsigenkänningen slutför sin hypotes och visar slutresultatet.
• Börja tala och pausa sedan i 20 sekunder. Detta gör att dikteringsigenkänningen överskrider tidsgränsen.
• Observera att nyckelordsigenkänning återaktiveras efter tidsgränsen ovan. Kommunikatören svarar nu på röstkommandon.
• Säg "Skicka meddelande" för att skicka meddelandet till astronauten.

Kapitel 4 – Grammatikigenkänning

Mål

• Använd grammatikigenkänningen för att identifiera användarens tal enligt en SRGS-fil eller en grammatikspecifikation för taligenkänning.

Anteckning

Mikrofonfunktionen måste deklareras för att en app ska kunna spela in från mikrofonen. Detta görs för dig redan i MR Input 212, men tänk på detta för dina egna projekt.

1. I Unity-redigeraren går du till spelarinställningarna genom att gå till "Redigera > projektinställningar > spelare"
2. Klicka på fliken "Universell Windows-plattform"
3. I avsnittet "Funktioner för publiceringsinställningar>" kontrollerar du mikrofonfunktionen

Instruktioner

1. I panelen Hierarki söker du efter Jetpack_Center och väljer den.
2. Leta efter Tagalong Action-skriptet i panelen Inspector .
3. Klicka på den lilla cirkeln till höger om fältet Objekt att tagga längs .
4. I fönstret som visas söker du efter SRGSToolbox och väljer den i listan.
5. Ta en titt på filenSRGSColor.xml i mappen StreamingAssets .
   1. SRGS-designspecifikationen finns på W3C-webbplatsen här.

I vår SRGS-fil har vi tre typer av regler:

• En regel som låter dig säga en färg från en lista med tolv färger.
• Tre regler som lyssnar efter en kombination av färgregeln och en av de tre formerna.
• Rotregeln, colorChooser, som lyssnar efter valfri kombination av de tre reglerna för "färg + form". Formerna kan sägas i valfri ordning och i vilken mängd som helst från bara en till alla tre. Det här är den enda regel som lyssnas efter, eftersom den anges som rotregeln överst i filen i den första <grammatiktaggen> .

Skapa och distribuera

• Återskapa programmet i Unity och skapa och distribuera sedan från Visual Studio för att uppleva appen på HoloLens.
• Stäng fit boxen med en lufttryckningsgest.
• Titta på astronautens jetpack och utför en lufttryckningsgest.
• Börja prata. Grammatikigenkänningen tolkar ditt tal och ändrar färgerna på formerna baserat på igenkänningen. Ett exempelkommando är "blå cirkel, gul fyrkant".
• Utför en annan lufttryckningsgest för att stänga verktygslådan.

Slutet

Grattis! Du har nu slutfört MR Input 212: Voice.

• Du känner till röstkommandona Dos och Don'ts.
• Du såg hur knappbeskrivningar användes för att göra användarna medvetna om röstkommandon.
• Du såg flera typer av feedback som användes för att bekräfta att användarens röst hördes.
• Du vet hur du växlar mellan nyckelordsigenkänning och dikteringsigenkänning och hur dessa två funktioner förstår och tolkar din röst.
• Du har lärt dig hur du använder en SRGS-fil och grammatikigenkänning för taligenkänning i ditt program.