Bagikan melalui

HoloLens (generasi ke-1) dan Azure 312: Integrasi bot

  • Artikel

Catatan

Tutorial Mixed Reality Academy dirancang dengan HoloLens (generasi ke-1) dan Mixed Reality Immersive Headsets dalam pikiran. Dengan demikian, kami merasa penting untuk meninggalkan tutorial ini di tempat bagi pengembang yang masih mencari panduan dalam mengembangkan untuk perangkat tersebut. Tutorial ini tidak akan diperbarui dengan toolset atau interaksi terbaru yang digunakan untuk HoloLens 2. Mereka akan dipertahankan untuk terus bekerja pada perangkat yang didukung. Akan ada serangkaian tutorial baru yang akan diposting di masa depan yang akan menunjukkan cara mengembangkan untuk HoloLens 2. Pemberitahuan ini akan diperbarui dengan tautan ke tutorial tersebut ketika diposting.

Dalam kursus ini, Anda akan mempelajari cara membuat dan menyebarkan bot menggunakan Microsoft Bot Framework V4 dan berkomunikasi dengannya melalui aplikasi Windows Mixed Reality.

Cuplikan layar yang memperlihatkan komunikasi melalui aplikasi Windows Mixed Reality.

Microsoft Bot Framework V4 adalah sekumpulan API yang dirancang untuk menyediakan alat kepada pengembang untuk membangun aplikasi bot yang dapat diperluas dan dapat diskalakan. Untuk informasi selengkapnya, kunjungi halaman Microsoft Bot Framework atau Repositori Git V4.

Setelah menyelesaikan kursus ini, Anda akan membangun aplikasi Windows Mixed Reality, yang akan dapat melakukan hal berikut:

  1. Gunakan Ketuk Gerakan untuk memulai bot yang mendengarkan suara pengguna.
  2. Ketika pengguna telah mengatakan sesuatu, bot akan mencoba memberikan respons.
  3. Tampilkan balasan bot sebagai teks, diposisikan di dekat bot, di Adegan Unity.

Dalam aplikasi Anda, terserah Anda tentang bagaimana Anda akan mengintegrasikan hasilnya dengan desain Anda. Kursus ini dirancang untuk mengajari Anda cara mengintegrasikan Layanan Azure dengan proyek Unity Anda. Ini adalah tugas Anda untuk menggunakan pengetahuan yang Anda peroleh dari kursus ini untuk meningkatkan aplikasi realitas campuran Anda.

Dukungan perangkat

Kursus HoloLens Headset imersif
MR dan Azure 312: Integrasi bot ✔️ ✔️

Catatan

Meskipun kursus ini terutama berfokus pada HoloLens, Anda juga dapat menerapkan apa yang Anda pelajari dalam kursus ini ke headset imersif (VR) Windows Mixed Reality. Karena headset imersif (VR) tidak memiliki kamera yang dapat diakses, Anda akan memerlukan kamera eksternal yang terhubung ke PC Anda. Saat mengikuti kursus, Anda akan melihat catatan tentang perubahan apa pun yang mungkin perlu Anda gunakan untuk mendukung headset imersif (VR).

Prasyarat

Catatan

Tutorial ini dirancang untuk pengembang yang memiliki pengalaman dasar dengan Unity dan C#. Perlu diketahui juga bahwa prasyarat dan instruksi tertulis dalam dokumen ini mewakili apa yang telah diuji dan diverifikasi pada saat penulisan (Juli 2018). Anda bebas menggunakan perangkat lunak terbaru, seperti yang tercantum dalam artikel instal alat , meskipun tidak boleh diasumsikan bahwa informasi dalam kursus ini akan sangat cocok dengan apa yang akan Anda temukan di perangkat lunak yang lebih baru daripada apa yang tercantum di bawah ini.

Kami merekomendasikan perangkat keras dan perangkat lunak berikut untuk kursus ini:

Sebelum memulai

  1. Untuk menghindari masalah saat membangun proyek ini, sangat disarankan agar Anda membuat proyek yang disebutkan dalam tutorial ini di folder root atau near-root (jalur folder panjang dapat menyebabkan masalah pada build-time).
  2. Siapkan dan uji HoloLens Anda. Jika Anda memerlukan dukungan untuk menyiapkan HoloLens Anda, pastikan untuk mengunjungi artikel penyiapan HoloLens.
  3. Sebaiknya lakukan Kalibrasi dan Penyetelan Sensor saat mulai mengembangkan aplikasi HoloLens baru (terkadang dapat membantu melakukan tugas tersebut untuk setiap pengguna).

Untuk bantuan tentang Kalibrasi, silakan ikuti tautan ini ke artikel Kalibrasi HoloLens.

Untuk bantuan tentang Penyetelan Sensor, silakan ikuti tautan ini ke artikel Penyetelan Sensor HoloLens.

Bab 1 – Buat aplikasi Bot

Langkah pertama adalah membuat bot Anda sebagai aplikasi Web ASP.Net Core lokal. Setelah selesai dan mengujinya, Anda akan menerbitkannya ke Portal Microsoft Azure.

  1. Buka Visual Studio. Buat proyek baru, pilih Aplikasi Web ASP NET Core sebagai jenis proyek (Anda akan menemukannya di bawah subbagian .NET Core) dan sebut saja MyBot. Klik OK.

  2. Di Jendela yang akan muncul pilih Kosong. Pastikan juga target diatur ke ASP NET Core 2.0 dan Autentikasi diatur ke Tanpa Autentikasi. Klik OK.

    Cuplikan layar yang memperlihatkan jendela Aplikasi Web New A S P dot N E T Core.

  3. Solusinya sekarang akan terbuka. Klik kanan pada Solution Mybot di Penjelajah Solusi dan klik Kelola Paket NuGet untuk Solusi.

    Cuplikan layar yang memperlihatkan solusi yang dibuka dengan 'MyBot' dan 'Kelola Paket NuGet untuk Solusi' disorot.

  4. Di tab Telusuri , cari Microsoft.Bot.Builder.Integration.AspNet.Core (pastikan Anda telah memeriksa Sertakan pra-rilis ). Pilih paket versi 4.0.1-preview, dan centang kotak proyek. Kemudian klik Instal. Anda sekarang telah menginstal pustaka yang diperlukan untuk Bot Framework v4. Tutup halaman NuGet.

    Cuplikan layar yang memperlihatkan manajer Solusi Nu-Get.

  5. Klik kanan proyek Anda, MyBot, di Penjelajah Solusi dan klik Tambahkan | Kelas.

    Cuplikan layar yang memperlihatkan proses untuk menambahkan kelas baru ke MyBot.

  6. Beri nama kelas MyBot dan klik Tambahkan.

    Cuplikan layar yang memperlihatkan pembuatan kelas baru 'MyBot'.

  7. Ulangi poin sebelumnya, untuk membuat kelas lain bernama ConversationContext.

  8. Klik kanan wwwroot di Penjelajah Solusi dan klik Tambahkan | Item Baru. Pilih Halaman HTML (Anda akan menemukannya di bawah Web sub-bagian). Beri nama file default.html. Klik Tambahkan.

    Cuplikan layar yang memperlihatkan pembuatan halaman H T M L baru dari dalam jendela Penjelajah Solusi.

  9. Daftar kelas/objek dalam Penjelajah Solusi akan terlihat seperti gambar di bawah ini.

    Cuplikan layar jendela Penjelajah Solusi dengan daftar kelas.

  10. Klik dua kali pada kelas ConversationContext . Kelas ini bertanggung jawab untuk menahan variabel yang digunakan oleh bot untuk mempertahankan konteks percakapan. Nilai konteks percakapan ini dipertahankan dalam instans kelas ini, karena instans kelas MyBot apa pun akan di-refresh setiap kali aktivitas diterima. Tambahkan kode berikut ke kelas :

    namespace MyBot
{
    public static class ConversationContext
    {
        internal static string userName;

        internal static string userMsg;
    }
}

  11. Klik dua kali pada kelas MyBot . Kelas ini akan menghosting handler yang dipanggil oleh aktivitas masuk apa pun dari pelanggan. Di kelas ini Anda akan menambahkan kode yang digunakan untuk membangun percakapan antara bot dan pelanggan. Seperti disebutkan sebelumnya, instans kelas ini diinisialisasi setiap kali aktivitas diterima. Tambahkan kode berikut ke kelas ini:

    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?");
            }

        }
    }
}

  12. Klik dua kali pada kelas Startup . Kelas ini akan menginisialisasi bot. Tambahkan kode berikut ke kelas :

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

  13. Buka file kelas Program dan verifikasi kode di dalamnya sama dengan yang berikut ini:

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

  14. Ingatlah untuk menyimpan perubahan Anda, untuk melakukannya, buka Simpan Semua File>, dari toolbar di bagian atas Visual Studio.

Bab 2 - Membuat Azure Bot Service

Sekarang setelah Anda membuat kode untuk bot, Anda harus menerbitkannya ke instans Web App Bot Service, di Portal Microsoft Azure. Bab ini akan menunjukkan kepada Anda cara membuat dan mengonfigurasi Bot Service di Azure lalu menerbitkan kode Anda ke dalamnya.

  1. Pertama, masuk ke Portal Microsoft Azure (https://portal.azure.com).

    1. Jika Anda belum memiliki akun Azure, Anda harus membuatnya. Jika Anda mengikuti tutorial ini dalam situasi ruang kelas atau lab, mintalah instruktur atau salah satu proktor untuk membantu menyiapkan akun baru Anda.

  2. Setelah Anda masuk, klik Buat sumber daya di sudut kiri atas, dan cari bot Aplikasi Web, dan klik Enter.

    Cuplikan layar dasbor Microsoft Azure dengan 'Buat sumber daya' disorot di kiri atas.

  3. Halaman baru akan memberikan deskripsi Layanan Bot Aplikasi Web. Di kiri bawah halaman ini, pilih tombol Buat , untuk membuat asosiasi dengan Layanan ini.

    Cuplikan layar halaman Bot Aplikasi Web dan tombol 'Buat' di kiri bawah.

  4. Setelah Anda mengklik Buat:

    1. Sisipkan Nama yang Anda inginkan untuk instans Layanan ini.

    2. Pilih Langganan.

    3. Pilih Grup Sumber Daya atau buat yang baru. Grup sumber daya menyediakan cara untuk memantau, mengontrol akses, menyediakan, dan mengelola penagihan untuk kumpulan aset Azure. Disarankan untuk menyimpan semua Layanan Azure yang terkait dengan satu proyek (misalnya seperti kursus ini) di bawah grup sumber daya umum).

      Jika Anda ingin membaca selengkapnya tentang Grup Sumber Daya Azure, silakan ikuti tautan ini

    4. Tentukan Lokasi untuk grup sumber daya Anda (jika Anda membuat Grup Sumber Daya baru). Lokasi idealnya akan berada di wilayah tempat aplikasi akan berjalan. Beberapa aset Azure hanya tersedia di wilayah tertentu.

    5. Pilih Tingkat Harga yang sesuai untuk Anda, jika ini pertama kalinya membuat Layanan Bot Aplikasi Web, tingkat gratis (bernama F0) harus tersedia untuk Anda

    6. Nama aplikasi hanya dapat dibiarkan sama dengan nama Bot.

    7. Biarkan templat Bot sebagai Dasar (C#).

    8. Paket layanan aplikasi/Lokasi seharusnya telah diisi secara otomatis untuk akun Anda.

    9. Atur Azure Storage yang ingin Anda gunakan untuk menghosting Bot Anda. Jika Anda belum memilikinya, Anda dapat membuatnya di sini.

    10. Anda juga perlu mengonfirmasi bahwa Anda telah memahami Syarat dan Ketentuan yang diterapkan pada Layanan ini.

    11. Klik Buat.

      Cuplikan layar yang memperlihatkan bidang yang diperlukan untuk membuat Layanan baru.

  5. Setelah mengklik Buat, Anda harus menunggu Layanan dibuat, ini mungkin memakan waktu satu menit.

  6. Pemberitahuan akan muncul di Portal setelah instans Layanan dibuat.

    Cuplikan layar yang memperlihatkan ikon pemberitahuan disorot setelah instans Layanan dibuat.

  7. Klik pemberitahuan untuk menjelajahi instans Layanan baru Anda.

    Cuplikan layar yang menunjukkan penyebaran berhasil dan tombol 'Buka sumber daya'.

  8. Klik tombol Buka sumber daya di pemberitahuan untuk menjelajahi instans Layanan baru Anda. Anda akan dibawa ke instans Azure Service baru Anda.

    Cuplikan layar jendela Sumber Daya setelah mengklik tombol 'Buka sumber daya' di jendela sebelumnya.

  9. Pada titik ini Anda perlu menyiapkan fitur yang disebut Direct Line untuk memungkinkan aplikasi klien Anda berkomunikasi dengan Bot Service ini. Klik Saluran, lalu di bagian Tambahkan saluran unggulan, klik Konfigurasikan saluran Direct Line.

    Cuplikan layar yang memperlihatkan saluran Konfigurasi Direct Line disorot di MyHoloLensBot.

  10. Di halaman ini Anda akan menemukan kunci Rahasia yang akan memungkinkan aplikasi klien Anda untuk mengautentikasi dengan bot. Klik tombol Tampilkan dan ambil salinan salah satu Kunci yang ditampilkan, karena Anda akan membutuhkannya nanti dalam proyek Anda.

    Cuplikan layar kunci rahasia yang disorot di saluran MyHoloLensBot Konfigurasi Direct Line.

Bab 3 – Menerbitkan Bot ke Azure Web App Bot Service

Sekarang setelah Layanan Anda siap, Anda perlu menerbitkan kode Bot, yang Anda buat sebelumnya, ke Web App Bot Service yang baru dibuat.

Catatan

Anda harus menerbitkan Bot Anda ke Layanan Azure setiap kali Anda membuat perubahan pada solusi / kode Bot.

  1. Kembali ke Solusi Visual Studio yang Anda buat sebelumnya.

  2. Klik kanan pada proyek MyBot Anda, di Penjelajah Solusi, lalu klik Terbitkan.

    Cuplikan layar yang memperlihatkan menu drop-down proyek 'MyBot' setelah klik kanan.

  3. Pada halaman Pilih target penerbitan, klik App Service, lalu Pilih Yang Sudah Ada, terakhir klik Buat Profil (Anda mungkin perlu mengklik panah dropdown di samping tombol Terbitkan , jika ini tidak terlihat).

    Cuplikan layar yang memperlihatkan halaman Pilih target penerbitan dengan 'App Service', 'Pilih Yang Sudah Ada', dan 'Buat Profil' disorot.

  4. Jika Anda belum masuk ke Akun Microsoft, Anda harus melakukannya di sini.

  5. Pada halaman Terbitkan, Anda harus mengatur Langganan yang sama dengan yang Anda gunakan untuk pembuatan Web App Bot Service. Kemudian atur Tampilan sebagai Grup Sumber Daya dan, di struktur folder drop-down, pilih Grup Sumber Daya yang telah Anda buat sebelumnya. Klik OK.

    Cuplikan layar yang memperlihatkan jendela App Service dengan Langganan yang sama yang digunakan untuk pembuatan Layanan Bot Aplikasi Web dipilih.

  6. Sekarang klik tombol Terbitkan , dan tunggu hingga Bot diterbitkan (mungkin perlu beberapa menit).

    Cuplikan layar yang memperlihatkan jendela Terbitkan dengan tombol Terbitkan.

Bab 4 – Menyiapkan proyek Unity

Berikut ini adalah pengaturan khas untuk mengembangkan dengan realitas campuran, dan dengan demikian, adalah templat yang baik untuk proyek lain.

  1. Buka Unity dan klik Baru.

    Cuplikan layar yang memperlihatkan jendela Proyek Unity dengan ikon proyek 'Baru' disorot di kanan atas.

  2. Anda sekarang perlu memberikan nama proyek Unity. Sisipkan Bot HoloLens. Pastikan templat proyek diatur ke 3D. Atur Lokasi ke tempat yang sesuai untuk Anda (ingat, lebih dekat ke direktori akar lebih baik). Lalu, klik Buat proyek.

    Cuplikan layar yang memperlihatkan bidang nama Proyek Unity baru disorot.

  3. Dengan Unity terbuka, ada baiknya memeriksa Editor Skrip default diatur ke Visual Studio. Buka Edit > Preferensi lalu dari jendela baru, navigasikan ke Alat Eksternal. Ubah Editor Skrip Eksternal ke Visual Studio 2017. Tutup jendela Preferensi .

    Cuplikan layar yang memperlihatkan jendela Preferensi Unity dengan pengaturan yang diperlukan.

  4. Selanjutnya, buka Pengaturan Build File > dan pilih Platform Windows Universal, lalu klik tombol Beralih Platform untuk menerapkan pilihan Anda.

    Cuplikan layar yang memperlihatkan jendela Pengaturan Build dengan tombol 'Beralih Platform' disorot.

  5. Saat masih dalam Pengaturan Penyusunan File > dan pastikan bahwa:

    1. Perangkat Target diatur ke HoloLens

      Untuk headset imersif, atur Perangkat Target ke Perangkat Apa Pun.

    2. Jenis Build diatur ke D3D

    3. SDK diatur ke Terbaru diinstal

    4. Versi Visual Studio diatur ke Terbaru diinstal

    5. Build and Run diatur ke Komputer Lokal

    6. Simpan adegan dan tambahkan ke build.

      1. Lakukan ini dengan memilih Tambahkan Adegan Terbuka. Jendela penyimpanan akan muncul.

        Cuplikan layar yang memperlihatkan jendela Pengaturan Build dengan tombol 'Tambahkan Adegan Terbuka' disorot.

      2. Buat folder baru untuk ini, dan adegan di masa mendatang, lalu pilih tombol Folder baru, untuk membuat folder baru, beri nama Adegan.

        Cuplikan layar yang memperlihatkan pembuatan folder 'Adegan' baru.

      3. Buka folder Adegan yang baru dibuat, lalu di bidang Nama file: teks, ketik BotScene, lalu klik Simpan.

        Cuplikan layar folder Adegan dan file yang baru dibuat disimpan.

    7. Pengaturan yang tersisa, di Pengaturan Build, harus dibiarkan sebagai default untuk saat ini.

  6. Di jendela Pengaturan Build, klik tombol Pengaturan Pemutar, ini akan membuka panel terkait di ruang tempat Pemeriksa berada.

    Cuplikan layar yang memperlihatkan jendela Pengaturan Build di tab Pemeriksa.

  7. Di panel ini, beberapa pengaturan perlu diverifikasi:

    1. Di tab Pengaturan Lainnya:

      1. Versi Runtime Pembuatan Skrip harus Eksperimental (Setara NET 4.6); mengubah ini akan memerlukan mulai ulang Editor.

      2. Scripting Backend harus .NET

      3. Tingkat Kompatibilitas API harus .NET 4.6

        Cuplikan layar yang memperlihatkan tab Pengaturan Lain dengan pengaturan yang diperlukan.

    2. Dalam tab Pengaturan Penerbitan, di bawah Kemampuan, periksa:

      • InternetClient

      • Mikrofon

        Cuplikan layar yang memperlihatkan 'InternetClient' dan 'Mikrofon' diaktifkan di tab Pengaturan Penerbitan.

    3. Selanjutnya di bawah panel, di Pengaturan XR (ditemukan di bawah Pengaturan Penerbitan), centang Realitas Virtual yang Didukung, pastikan Windows Mixed Reality SDK ditambahkan.

      Cuplikan layar yang memperlihatkan Virtual Reality Didukung diaktifkan dan Windows Mixed Reality S D K ditambahkan.

  8. Kembali ke Pengaturan Build Proyek Unity C# tidak lagi berwarna abu-abu; centang kotak di samping ini.

  9. Tutup jendela Pengaturan Build.

  10. Simpan adegan dan proyek Anda (FILE > SAVE SCENE / FILE > SAVE PROJECT).

Bab 5 – Penyiapan kamera

Penting

Jika Anda ingin melewati komponen Unity Siapkan kursus ini, dan lanjutkan langsung ke dalam kode, jangan ragu untuk mengunduh Paket Azure-MR-312-Package.unitypackage ini, impor ke proyek Anda sebagai Paket Kustom, lalu lanjutkan dari Bab 7.

  1. Di panel Hierarki, pilih Kamera Utama.

  2. Setelah dipilih, Anda akan dapat melihat semua komponen Kamera Utama di panel Inspektur.

    1. Objek Kamera harus diberi nama Kamera Utama (perhatikan ejaan)
    2. Tag Kamera Utama harus diatur ke MainCamera (perhatikan ejaan)
    3. Pastikan Posisi Transformasi diatur ke 0, 0, 0
    4. Atur Hapus Bendera ke Warna Solid.
    5. Atur Warna Latar Belakang komponen Kamera ke Hitam, Alpha 0 (Kode Hex: #00000000)

    Cuplikan layar yang memperlihatkan semua komponen Kamera Utama di panel Inspektur.

Bab 6 – Impor pustaka Newtonsoft

Untuk membantu Anda mendeserialisasi dan menserialisasi objek yang diterima dan dikirim ke Bot Service, Anda perlu mengunduh pustaka Newtonsoft . Anda akan menemukan versi yang kompatibel yang sudah diatur dengan struktur folder Unity yang benar di sini.

Untuk mengimpor pustaka Newtonsoft ke dalam proyek Anda, gunakan Paket Unity yang disertakan dengan kursus ini.

  1. Tambahkan .unitypackage ke Unity dengan menggunakan opsi menu Paket Kustom Paket>Impor Aset.>

    Cuplikan layar yang memperlihatkan menu drop-down Aset dengan 'Impor Paket' lalu 'Paket Kustom' dipilih.

  2. Dalam kotak Impor Paket Unity yang muncul, pastikan semuanya di bawah (dan termasuk) Plugin dipilih.

    Cuplikan layar kotak popup Impor Paket Unity dengan 'Plugin' dipilih.

  3. Klik tombol Impor untuk menambahkan item ke proyek Anda.

  4. Buka folder Newtonsoft di bawah Plugin dalam tampilan proyek dan pilih plugin Newtonsoft.

    Cuplikan layar yang memperlihatkan folder Newtonsoft dalam tampilan proyek.

  5. Dengan plugin Newtonsoft dipilih, pastikan platform apa pun tidak dicentang, lalu pastikan bahwa WSAPlayer juga tidak dicentang, lalu klik Terapkan. Ini hanya untuk mengonfirmasi bahwa file dikonfigurasi dengan benar.

    Cuplikan layar yang memperlihatkan pilihan yang benar untuk plugin Newtonsoft.

    Catatan

    Menandai plugin ini mengonfigurasinya untuk hanya digunakan di Editor Unity. Ada set yang berbeda di folder WSA yang akan digunakan setelah proyek diekspor dari Unity.

  6. Selanjutnya, Anda perlu membuka folder WSA , di dalam folder Newtonsoft . Anda akan melihat salinan file yang sama yang baru saja Anda konfigurasikan. Pilih file, lalu di pemeriksa, pastikan bahwa

    • Platform apa pun tidak dicentang
    • hanya WSAPlayer yang diperiksa
    • Proses dont diperiksa

    Cuplikan layar yang memperlihatkan pilihan yang benar untuk plugin Newtonsoft di folder WSA.

Bab 7 - Buat BotTag

  1. Buat objek Tag baru yang disebut BotTag. Pilih Kamera Utama di adegan. Klik menu drop-down Tag di panel Pemeriksa. Klik Tambahkan Tag.

    Cuplikan layar menu drop-down Tag Kamera Utama di panel Pemeriksa dengan 'Tambahkan Tag' disorot.

  2. Klik simbol + . Beri nama Tag baru sebagai BotTag, Simpan.

    Cuplikan layar panel Pemeriksa dengan nama BotTag baru, simbol plus, dan tombol Simpan.

Peringatan

Jangan terapkan BotTag ke Kamera Utama. Jika Anda tidak sengaja melakukan ini, pastikan untuk mengubah tag Kamera Utama kembali ke MainCamera.

Bab 8 - Buat kelas BotObjects

Skrip pertama yang perlu Anda buat adalah kelas BotObjects , yang merupakan kelas kosong yang dibuat sehingga serangkaian objek kelas lain dapat disimpan dalam skrip yang sama dan diakses oleh skrip lain di adegan.

Pembuatan kelas ini murni pilihan arsitektur, objek-objek ini dapat dihosting dalam skrip Bot yang akan Anda buat nanti dalam kursus ini.

Untuk membuat kelas ini:

  1. Klik kanan di panel Proyek, lalu Buat > Folder. Beri nama folder Skrip.

    Membuat folder skrip.

  2. Klik dua kali pada folder Skrip untuk membukanya. Kemudian di dalam folder tersebut, klik kanan, dan pilih Buat > Skrip C#. Beri nama skrip BotObjects.

  3. Klik dua kali pada skrip BotObjects baru untuk membukanya dengan Visual Studio.

  4. Hapus konten skrip dan ganti dengan kode berikut:

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

  5. Pastikan untuk menyimpan perubahan Anda di Visual Studio sebelum kembali ke Unity.

Bab 9 - Buat kelas GazeInput

Kelas berikutnya yang akan Anda buat adalah kelas GazeInput . Kelas ini bertanggung jawab untuk:

  • Membuat kursor yang akan mewakili tatapan pemain.
  • Mendeteksi objek yang terkena tatapan pemutar, dan memegang referensi ke objek yang terdeteksi.

Untuk membuat kelas ini:

  1. Buka folder Skrip yang Anda buat sebelumnya.

  2. Klik kanan di dalam folder, Buat > Skrip C#. Panggil skrip GazeInput.

  3. Klik dua kali pada skrip GazeInput baru untuk membukanya dengan Visual Studio.

  4. Sisipkan baris berikut tepat di atas nama kelas:

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

  5. Kemudian tambahkan variabel berikut di dalam kelas GazeInput, di atas metode Start():

        [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;

  6. Kode untuk metode Start() harus ditambahkan. Ini akan dipanggil ketika kelas menginisialisasi:

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

  7. Terapkan metode yang akan membuat instans dan mengatur kursor tatapan:

        /// <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;
    }

  8. Terapkan metode yang akan mengatur Raycast dari Kamera Utama dan akan melacak objek yang berfokus saat ini.

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

  9. Pastikan untuk menyimpan perubahan Anda di Visual Studio sebelum kembali ke Unity.

Bab 10 – Buat kelas Bot

Skrip yang akan Anda buat sekarang disebut Bot. Ini adalah kelas inti aplikasi Anda, ia menyimpan:

  • Kredensial Bot Aplikasi Web Anda
  • Metode yang mengumpulkan perintah suara pengguna
  • Metode yang diperlukan untuk memulai percakapan dengan Bot Aplikasi Web Anda
  • Metode yang diperlukan untuk mengirim pesan ke Bot Aplikasi Web Anda

Untuk mengirim pesan ke Bot Service, koroutine SendMessageToBot() akan membangun aktivitas, yang merupakan objek yang dikenali oleh Bot Framework sebagai data yang dikirim oleh pengguna.

Untuk membuat kelas ini:

  1. Klik dua kali pada folder Skrip , untuk membukanya.

  2. Klik kanan di dalam folder Skrip , klik Buat > Skrip C#. Beri nama Bot skrip.

  3. Klik dua kali pada skrip baru untuk membukanya dengan Visual Studio.

  4. Perbarui namespace agar sama dengan yang berikut ini, di bagian atas kelas Bot :

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

  5. Di dalam kelas Bot tambahkan variabel berikut:

        /// <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;

    Catatan

    Pastikan Anda memasukkan Kunci Rahasia Bot ke dalam variabel botSecret . Anda akan mencatat Kunci Rahasia Bot Anda di awal kursus ini, di Bab 2, langkah 10.

  6. Kode untuk Awake() dan Start() sekarang perlu ditambahkan.

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

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

  7. Tambahkan dua handler yang dipanggil oleh pustaka ucapan saat pengambilan suara dimulai dan berakhir. DictationRecognizer akan secara otomatis berhenti menangkap suara pengguna saat pengguna berhenti berbicara.

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

  8. Handler berikut mengumpulkan hasil input suara pengguna dan memanggil koroutine yang bertanggung jawab untuk mengirim pesan ke Web App Bot Service.

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

  9. Koroutine berikut dipanggil untuk memulai percakapan dengan Bot. Anda akan melihat bahwa setelah panggilan percakapan selesai, panggilan akan memanggil SendMessageToCoroutine() dengan meneruskan serangkaian parameter yang akan mengatur aktivitas yang akan dikirim ke Bot Service sebagai pesan kosong. Ini dilakukan untuk meminta Bot Service memulai dialog.

        /// <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"));
    }

  10. Koroutine berikut dipanggil untuk membangun aktivitas yang akan dikirim ke Bot Service.

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

  11. Koroutine berikut dipanggil untuk meminta respons setelah mengirim aktivitas ke Bot Service.

        /// <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;
        }
    }

  12. Metode terakhir yang akan ditambahkan ke kelas ini, diperlukan untuk menampilkan pesan dalam adegan:

        /// <summary>
    /// Set the UI Response Text of the bot
    /// </summary>
    internal void SetBotResponseText(string responseString)
    {        
        SceneOrganiser.Instance.botResponseText.text =  responseString;
    }

    Catatan

    Anda mungkin melihat kesalahan dalam Konsol Editor Unity, tentang hilangnya kelas SceneOrganiser . Abaikan pesan ini, karena Anda akan membuat kelas ini nanti dalam tutorial.

  13. Pastikan untuk menyimpan perubahan Anda di Visual Studio sebelum kembali ke Unity.

Bab 11 – Buat kelas Interaksi

Kelas yang akan Anda buat sekarang disebut Interaksi. Kelas ini digunakan untuk mendeteksi Input Ketuk HoloLens dari pengguna.

Jika pengguna mengetuk saat melihat objek Bot di adegan, dan Bot siap mendengarkan input suara, objek Bot akan berubah warna menjadi merah dan mulai mendengarkan input suara.

Kelas ini mewarisi dari kelas GazeInput , dan juga dapat mereferensikan metode Start() dan variabel dari kelas tersebut, ditandai dengan penggunaan basis.

Untuk membuat kelas ini:

  1. Klik dua kali pada folder Skrip , untuk membukanya.

  2. Klik kanan di dalam folder Skrip , klik Buat > Skrip C#. Beri nama skrip Interaksi.

  3. Klik dua kali pada skrip baru untuk membukanya dengan Visual Studio.

  4. Perbarui namespace layanan dan pewarisan kelas agar sama dengan yang berikut ini, di bagian atas kelas Interaksi :

    using UnityEngine.XR.WSA.Input;

public class Interactions : GazeInput
{

  5. Di dalam kelas Interaksi tambahkan variabel berikut:

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

  6. Kemudian tambahkan metode Start() :

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

  7. Tambahkan handler yang akan dipicu saat pengguna melakukan gerakan ketukan di depan kamera HoloLens

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

  8. Pastikan untuk menyimpan perubahan Anda di Visual Studio sebelum kembali ke Unity.

Bab 12 – Buat kelas SceneOrganiser

Kelas terakhir yang diperlukan di Lab ini disebut SceneOrganiser. Kelas ini akan mengatur adegan secara terprogram, dengan menambahkan komponen dan skrip ke Kamera Utama, dan membuat objek yang sesuai di adegan.

Untuk membuat kelas ini:

  1. Klik dua kali pada folder Skrip , untuk membukanya.

  2. Klik kanan di dalam folder Skrip , klik Buat > Skrip C#. Beri nama skrip SceneOrganiser.

  3. Klik dua kali pada skrip baru untuk membukanya dengan Visual Studio.

  4. Di dalam kelas SceneOrganiser tambahkan variabel berikut:

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

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

  5. Kemudian tambahkan metode Awake() dan Start():

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

  6. Tambahkan metode berikut, yang bertanggung jawab untuk membuat objek Bot di adegan dan menyiapkan parameter dan komponen:

        /// <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";
    }

  7. Tambahkan metode berikut, yang bertanggung jawab untuk membuat objek UI di adegan, mewakili respons dari Bot:

        /// <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;
    }

  8. Pastikan untuk menyimpan perubahan Anda di Visual Studio sebelum kembali ke Unity.

  9. Di Editor Unity, seret skrip SceneOrganiser dari folder Skrip ke Kamera Utama. Komponen Scene Organiser sekarang akan muncul pada objek Kamera Utama, seperti yang ditunjukkan pada gambar di bawah ini.

    Cuplikan layar yang memperlihatkan skrip Scene Organiser ditambahkan ke objek Kamera Utama di Editor Unity.

Bab 13 – Sebelum membangun

Untuk melakukan pengujian menyeluruh aplikasi Anda, Anda harus membongkarnya ke HoloLens Anda. Sebelum melakukannya, pastikan bahwa:

  • Semua pengaturan yang disebutkan dalam Bab 4 diatur dengan benar.
  • Skrip SceneOrganiser dilampirkan ke objek Kamera Utama.
  • Di kelas Bot, pastikan Anda telah memasukkan Kunci Rahasia Bot Anda ke dalam variabel botSecret.

Bab 14 - Membangun dan Memihak ke HoloLens

Semua yang diperlukan untuk bagian Unity dari proyek ini sekarang telah selesai, jadi sekarang saatnya untuk membangunnya dari Unity.

  1. Navigasi ke Pengaturan Build, Pengaturan Build File>....

  2. Dari jendela Pengaturan Build, klik Bangun.

    Membangun aplikasi dari Unity

  3. Jika belum, centang Proyek Unity C#.

  4. Klik Bangun. Unity akan meluncurkan jendela File Explorer , tempat Anda perlu membuat lalu memilih folder untuk membangun aplikasi. Buat folder tersebut sekarang, dan beri nama Aplikasi. Kemudian dengan folder Aplikasi dipilih, klik Pilih Folder.

  5. Unity akan mulai membangun proyek Anda ke folder Aplikasi .

  6. Setelah Unity selesai membangun (mungkin perlu waktu), Unity akan membuka jendela File Explorer di lokasi build Anda (periksa bilah tugas Anda, karena mungkin tidak selalu muncul di atas jendela Anda, tetapi akan memberi tahu Anda tentang penambahan jendela baru).

Bab 15 - Menyebarkan ke HoloLens

Untuk menyebarkan di HoloLens:

  1. Anda akan memerlukan Alamat IP HoloLens Anda (untuk Penyebaran Jarak Jauh), dan untuk memastikan HoloLens Anda berada dalam Mode Pengembang. Untuk melakukan ini:

    1. Sementara mengenakan HoloLens Anda, buka Pengaturan.
    2. Buka Opsi Tingkat Lanjut Wi-Fi Jaringan & > Internet >
    3. Perhatikan alamat IPv4.
    4. Selanjutnya, navigasikan kembali ke Pengaturan, lalu ke Pembaruan & Keamanan > Untuk Pengembang
    5. Atur Mode Pengembang Aktif.

  2. Navigasi ke build Unity baru Anda ( folder Aplikasi ) dan buka file solusi dengan Visual Studio.

  3. Di Konfigurasi Solusi pilih Debug.

  4. Di Platform Solusi, pilih x86, Komputer Jarak Jauh.

    Sebarkan solusi dari Visual Studio.

  5. Buka menu Build dan klik Sebarkan Solusi, untuk memuat samping aplikasi ke HoloLens Anda.

  6. Aplikasi Anda sekarang akan muncul dalam daftar aplikasi yang diinstal di HoloLens Anda, siap untuk diluncurkan!

    Catatan

    Untuk menyebarkan ke headset imersif, atur Platform Solusi ke Komputer Lokal, dan atur Konfigurasi ke Debug, dengan x86 sebagai Platform. Kemudian sebarkan ke komputer lokal, menggunakan menu Build, memilih Sebarkan Solusi.

Bab 16 – Menggunakan aplikasi di HoloLens

  • Setelah meluncurkan aplikasi, Anda akan melihat Bot sebagai bola biru di depan Anda.

  • Gunakan Tap Gesture saat Anda menatap bola untuk memulai percakapan.

  • Tunggu hingga percakapan dimulai (UI akan menampilkan pesan saat terjadi). Setelah Anda menerima pesan pengantar dari Bot, ketuk lagi pada Bot sehingga akan berubah menjadi merah dan mulai mendengarkan suara Anda.

  • Setelah berhenti berbicara, aplikasi Anda akan mengirim pesan Anda ke Bot dan Anda akan segera menerima respons yang akan ditampilkan di UI.

  • Ulangi proses untuk mengirim lebih banyak pesan ke Bot Anda (Anda harus mengetuk setiap kali Anda ingin membuat pesan).

Percakapan ini menunjukkan bagaimana Bot dapat menyimpan informasi (nama Anda), sementara juga memberikan informasi yang diketahui (seperti item yang diisi).

Beberapa pertanyaan untuk diajukan kepada Bot:

what do you sell? 

how much are umbrellas?

how much are raincoats?

Aplikasi Web App Bot (v4) Anda yang sudah selesai

Selamat, Anda membuat aplikasi realitas campuran yang memanfaatkan Azure Web App Bot, Microsoft Bot Framework v4.

Produk Akhir

Latihan bonus

Latihan 1

Struktur percakapan di Lab ini sangat mendasar. Gunakan Microsoft LUIS untuk memberikan kemampuan pemahaman bahasa alami bot Anda.

Latihan 2

Contoh ini tidak termasuk mengakhiri percakapan dan memulai ulang percakapan baru. Untuk membuat fitur Bot selesai, coba terapkan penutupan ke percakapan.