HoloLens (1. generációs) és az Azure 305: Függvények és tárolás


Megjegyzés

A Mixed Reality Academy oktatóanyagai HoloLens (1. generációs) és Mixed Reality Modern headsetekkel készültek. Ezért fontos, hogy ezeket az oktatóanyagokat a helyére helyezzük azoknak a fejlesztőknek, akik továbbra is útmutatást keresnek az eszközök fejlesztéséhez. Ezek az oktatóanyagok nem frissülnek a 2. HoloLens használt legújabb eszközkészletekkel vagy interakciókkal. A rendszer fenntartja őket, hogy továbbra is a támogatott eszközökön dolgoznak. A jövőben egy új oktatóanyag-sorozat lesz közzétéve, amely bemutatja, hogyan fejleszthet a 2. HoloLens való fejlesztéshez. Ez az értesítés frissülni fog az oktatóanyagokra mutató hivatkozással, amikor közzétenjük őket.


final product -start

Ebben a kurzusban megtudhatja, hogyan hozhat létre és használhat Azure Functions adatokat egy Azure Storage-erőforrással egy vegyes valóságon belüli alkalmazásban.

Azure Functions egy Microsoft-szolgáltatás, amely lehetővé teszi a fejlesztők számára, hogy kis kódokat (függvényeket) futtassanak az Azure-ban. Így a helyi alkalmazás helyett a felhőbe delegálhatja a munkát, ami számos előnyt biztosít. Azure Functions nyelvet támogat, például a C#, az F#, a Node.js, a Java és a PHP nyelvet. További információért látogasson el a Azure Functions cikkre.

Az Azure Storage egy Microsoft felhőszolgáltatás, amely lehetővé teszi a fejlesztők számára az adatok tárolására, azzal a biztosítva, hogy magas rendelkezésre állás, biztonságos, tartós, skálázható és redundáns lesz. Ez azt jelenti, hogy a Microsoft minden karbantartást és kritikus problémát kezelni fog Önért. További információért látogasson el az Azure Storage cikkre.

A kurzus befejezése után egy modern, vegyes valóságú headset-alkalmazással fog fog tudni tenni a következőket:

  1. Lehetővé teszi, hogy a felhasználó egy jelenet körültekintsen.
  2. Aktiválja az objektumokból való indítást, amikor a felhasználó egy 3D-s "gombot" néz.
  3. Az elindított objektumokat egy Azure-függvény fogja kiválasztani.
  4. Az egyes objektumok létrehozása során az alkalmazás egy Azure-fájlbantárolja az objektumtípust, amely az Azure Storage.
  5. A második betöltéskor a rendszer beolvassa az Azure File-adatokat, és az alkalmazás előző példányából származó forrásműveleteket használja vissza.

Az alkalmazásban Öntől kell tudni, hogyan fogja integrálni az eredményeket a tervbe. Ennek a kurzusnak az a célja, hogy megtanítsa, hogyan integrálhat egy Azure-szolgáltatást a Unity-Project. Az Ön feladata, hogy az ebben a kurzusban megszerezhető ismereteket használja fel a vegyes valóságon áteső alkalmazás továbbadása érdekében.

Eszköztámogatás

Tanfolyam HoloLens Modern headsetek
MR és Azure 305: Függvények és tárolás ✔️ ✔️

Megjegyzés

Bár ez a kurzus elsősorban a Windows Mixed Reality (VR)-headsetekkel foglalkozik, a kurzusban tanultak használhatja a Microsoft HoloLens. A tanfolyam során megjegyzéseket fog látni az esetleges változásokról, amelyekre szükség lehet a HoloLens.

Előfeltételek

Megjegyzés

Ez az oktatóanyag olyan fejlesztők számára készült, akik alapszintű tapasztalattal rendelkeznek a Unity és a C# használatában. Vegye figyelembe azt is, hogy a dokumentum előfeltételei és írásos utasításai a cikk írásakor tesztelt és ellenőrzött adatokat (2018. május) írják le. Használhatja a legújabb szoftvereket az eszközök telepítésével kapcsolatos cikkben felsoroltak szerint, de nem szabad feltételezni, hogy a kurzusban szereplő információk tökéletesen megegyeznek az újabb szoftverekben található információkkal, mint az alább felsoroltak.

Ehhez a kurzushoz a következő hardvereket és szoftvereket javasoljuk:

Előkészületek

A projekt létrehozásakor felmerülő problémák elkerülése érdekében határozottan javasoljuk, hogy az oktatóanyagban említett projektet egy gyökér- vagy gyökérmappában hozza létre (a hosszú mappák elérési útjai problémákat okozhatnak a létrehozáskor).

1. fejezet – Az Azure Portal

Az Azure Storage szolgáltatáshozlétre kell hoznia és konfigurálnia kell egy Storage-fiókot a Azure Portal.

  1. Jelentkezzen be az Azure Portalra.

    Megjegyzés

    Ha még nem rendelkezik Azure-fiókkal, létre kell hoznia egyet. Ha osztályterem- vagy laborhelyzetben követi ezt az oktatóanyagot, kérje meg az oktatóját vagy valamelyik vezetőt, hogy segítsen az új fiók beállításában.

  2. Miután bejelentkezett, kattintson az Új elemre a bal felső sarokban, keressen rá a Storage,majd kattintson az Enter gombra.

    azure storage search

    Megjegyzés

    Előfordulhat, hogy az Új szó helyett a Create a resource(Erőforrás létrehozása) szó lett az újabb portálon.

  3. Az új oldal az Azure-fiókszolgáltatás Storage leírását tartalmazza. A parancssor bal alsó részén válassza a Létrehozás gombot a szolgáltatáshoz való társítás létrehozásához.

    szolgáltatás létrehozása

  4. Miután a Létrehozás gombra kattintott:

    1. Szúrjon be egy Nevet a fiókhoz, vegye figyelembe, hogy ez a mező csak számokat és kisbetűket fogad el.

    2. Az Üzembe helyezési modell beállításhozválassza a Resource Manager lehetőséget.

    3. A Fiók fajtája mezőbenválassza a Storage (általános célú v1)lehetőséget.

    4. Határozza meg az erőforráscsoport helyét (ha új erőforráscsoportot hoz létre). A hely ideális esetben abban a régióban található, ahol az alkalmazás futna. Egyes Azure-eszközök csak bizonyos régiókban érhetők el.

    5. A Replikáció beállításnál válassza az Írási hozzáférés georedundáns tárolás (RA-GRS) lehetőséget.

    6. A Teljesítmény mezőben válassza a Standard lehetőséget.

    7. A Biztonságos átvitelre van szükség adatokat hagyjaLetiltva.

    8. Válasszon ki egy előfizetést.

    9. Válasszon ki egy erőforráscsoportot, vagy hozzon létre egy újat. Az erőforráscsoportokkal monitorzhatja, szabályozhatja a hozzáférést, kiépítheti és kezelheti az Azure-beli eszközök gyűjteményének számlázását. Javasoljuk, hogy egyetlen projekthez (például ezekhez a tesztkörnyezetekhez) társított összes Azure-szolgáltatást egy közös erőforráscsoportban tartsa.

      Ha többet szeretne tudni az Azure-erőforráscsoportokról, tekintse meg az erőforráscsoportokkal kapcsolatos cikket.

    10. Azt is meg kell erősítenie, hogy megértette a szolgáltatásra alkalmazott használati feltételeket.

    11. Válassza a Létrehozás lehetőséget.

      bemeneti szolgáltatás adatai

  5. Miután a Létrehozás gombra kattintott,meg kell várnia a szolgáltatás létrejöttét, ez egy percet is igénybe vehet.

  6. A szolgáltatáspéldány létrehozása után egy értesítés jelenik meg a portálon.

    új értesítés az Azure Portalon

  7. Kattintson az értesítésekre az új szolgáltatáspéldány felfedezéséhez.

    ugrás az erőforrásra

  8. Az értesítésben kattintson az Erőforrás ugrás gombra az új szolgáltatáspéldány felfedezéséhez. Meg fog lennie az új Storage-szolgáltatáspéldánya.

    hozzáférési kulcsok

  9. Kattintson a Hozzáférési kulcsok elemrea felhőszolgáltatás végpontjainak felfedése érdekében. A Jegyzettömb vagy hasonló használatával másolhatja az egyik kulcsot későbbi használatra. Figyelje meg a Kapcsolati sztring értékét is, mert az az AzureServices osztályban lesz használva, amelyet később fog létrehozni.

    kapcsolati sztring másolása

2. fejezet – Azure-függvény beállítása

Most egy Azure-függvényt fog írniaz Azure-szolgáltatásban.

Az Azure-függvényekkel szinte bármit tehet, amit a klasszikus függvényekkel tenne a kódban. A különbség az, hogy ezt a függvényt bármely olyan alkalmazás elérheti, amely rendelkezik az Azure-fiók eléréséhez szükséges hitelesítő adatokkal.

Azure-függvény létrehozása:

  1. Az Azure Portal bal felső sarkábankattintson az Új elemre, keressen rá a függvényalkalmazáskifejezésre, majd kattintson az Enter gombra.

    függvényalkalmazás létrehozása

    Megjegyzés

    Előfordulhat, hogy az Új szó helyére az Erőforráslétrehozása szó került az újabb portálok használatával.

  2. Az új oldal az Azure-függvényalkalmazás szolgáltatás leírását tartalmazza. A parancssor bal alsó részén válassza a Létrehozás gombot a szolgáltatással való társítás létrehozásához.

    függvényalkalmazás adatai

  3. Miután a Létrehozás gombra kattintott:

    1. Adjon meg egy alkalmazásnevet. Itt csak betűk és számok használhatók (a kis- és nagybetűk használata is engedélyezett).

    2. Válassza ki a kívánt előfizetést.

    3. Válasszon ki egy erőforráscsoportot, vagy hozzon létre egy újat. Az erőforráscsoport lehetővé teszi az Azure-eszközök gyűjteményének figyelése, hozzáférésének szabályozása, kiépítése és kezelése a számlázást. Javasoljuk, hogy az összes Azure-szolgáltatást egyetlen projektben (például ezekben a tesztkörnyezetekben) egy közös erőforráscsoportban tartsa.

      Ha többet szeretne tudni az Azure-erőforráscsoportokról, tekintse meg az erőforráscsoportokkal kapcsolatos cikket.

    4. Ebben a gyakorlatban válassza a Windows operációs rendszerként.

    5. Az Üzemeltetési csomag mezőben válassza a Használat alapján csomag lehetőséget.

    6. Határozza meg az erőforráscsoport helyét (ha új erőforráscsoportot hoz létre). A hely ideális esetben abban a régióban található, ahol az alkalmazás futna. Egyes Azure-eszközök csak bizonyos régiókban érhetők el. Az optimális teljesítmény érdekében válassza ki ugyanazt a régiót, mint a tárfiók.

    7. A Storageválassza a Meglévő használatalehetőséget, majd a legördülő menüben keresse meg a korábban létrehozott tárolót.

    8. Ebben a gyakorlatban hagyja Elemzések Application (Alkalmazás) kikapcsolva.

      bemeneti függvényalkalmazás részletei

  4. Kattintson a Létrehozás gombra.

  5. Miután a Létrehozás gombra kattintott,meg kell várnia a szolgáltatás létrejöttét, ez egy percet is igénybe vehet.

  6. A szolgáltatáspéldány létrehozása után egy értesítés jelenik meg a portálon.

    új Azure Portal-értesítés

  7. Kattintson az értesítésekre az új szolgáltatáspéldány felfedezéséhez.

    ugrás az erőforrás-függvényalkalmazásra

  8. Az értesítésben kattintson az Erőforrás ugrás gombra az új szolgáltatáspéldány felfedezéséhez. Meg fog lennie az új Function App Service-példányban.

  9. A Függvényalkalmazás irányítópulton vigye az egérmutatót a bal oldali panelen található Függvények fölé, majd kattintson a + (plusz) szimbólumra.

    új függvény létrehozása

  10. A következő lapon győződjön meg arról, hogy a Webhook + API van kiválasztva, és a Nyelv kiválasztása mezőben válassza a CSharplehetőséget, mivel ez lesz az oktatóanyagban használt nyelv. Végül kattintson a Függvény létrehozása gombra.

    csharp web hook kiválasztása

  11. Meg kell jelenni a kódlapon (run.csx), ha nem, kattintson a bal oldali panel Függvények listájában az újonnan létrehozott függvényre.

    új függvény megnyitása

  12. Másolja az alábbi kódot a függvénybe. Ez a függvény egyszerűen egy 0 és 2 közötti véletlenszerű egész számot ad vissza a hívatáskor. Ne aggódjon a meglévő kód miatt, nyugodtan beillesztheti a fájl tetejére.

        using System.Net;
        using System.Threading.Tasks;
    
        public static int Run(CustomObject req, TraceWriter log)
        {
            Random rnd = new Random();
            int randomInt = rnd.Next(0, 3);
            return randomInt;
        }
    
        public class CustomObject
        {
            public String name {get; set;}
        }
    
  13. Kattintson a Mentés gombra.

  14. Az eredménynek az alábbi képhez hasonlónak kell lennie.

  15. Kattintson a Függvény URL-címének le szolgáltatása lehetőségre, és jegyezze fel a megjelenített végpontot. Ezt be kell illesztenie az AzureServices osztályba, amit a tanfolyam későbbi szakasza során létre fog hozni.

    Függvényvégpont lekért száma

    Függvényvégpont beszúrása

3. fejezet – A Unity-projekt beállítása

Az alábbiakban egy tipikus fejlesztést követünk Mixed Reality, és így jó sablon más projektekhez.

Állítsa be és tesztelje a vegyes valóságú modern headsetet.

Megjegyzés

Ehhez a kurzushoz nem lesz szükség mozgásvezérlőkre. Ha támogatásra van szüksége a modern headset beállításához, tekintse meg a vegyes valóság beállítását.

  1. Nyissa meg a Unityt, és kattintson a New (Új) elemre.

    Új Unity-projekt létrehozása

  2. Most meg kell adnia egy Unity-Project nevét. Szúrja MR_Azure_Functions következőt:. Győződjön meg arról, hogy a projekt típusa 3D. A Hely beállításnál adja meg az Önnek megfelelő helyet (ne feledje, hogy a gyökérkönyvtárakhoz közelebb is jobb). Ezután kattintson a Create project (Projekt létrehozása) elemre.

    Adjon nevet az új Unity-projektnek

  3. Ha a Unity meg van nyitva, érdemes ellenőrizni, hogy az alapértelmezett Script Editor értéke Visual Studio. Lépjen a Beállításokszerkesztése lapra, majd az új ablakban lépjen a Külső eszközök elemre. Módosítsa a Külső szkriptszerkesztőta 2017 Visual Studio re. Zárja be a Beállítások ablakot.

    visual studio beállítása szkriptszerkesztőként

  4. Ezután a Fájl build Gépház a platformot a Universal Windows Platform (Platformváltás) gombra kattintva váltsa át a Universal Windows Platform(Platformváltás) elemre.

    platformváltás uwp-re

  5. A Fájl buildelő Gépház győződjön meg a következőről:

    1. A Target Device (Céleszköz) beállítása Any Device (Bármely eszköz).

      A Microsoft HoloLens állítsa a Céleszközt akövetkezőre: HoloLens.

    2. A Build Type (Build típusa) beállítása D3D

    3. Az SDK a Legújabb telepítve beállításra van állítva

    4. Visual Studio Verziója a Legújabb telepítve beállításra van állítva

    5. A Build and Run (Összeállítás és futtatás) beállítása Local Machine (Helyi gép)

    6. Mentse a jelenet, és adja hozzá a buildhez.

      1. Ehhez válassza az Add Open Scenes (Nyitott jelenetek hozzáadása) gombra. Megjelenik egy Mentés ablak.

        nyitott jelenetek hozzáadása

      2. Hozzon létre egy új mappát ehhez és minden jövőbeli jelenethez, majd válassza az Új mappa gombot egy új mappa létrehozásához, és adja neki a Scenes nevet.

        create scenes mappa

      3. Nyissa meg az újonnan létrehozott Scenes mappát, majd a Fájlnév: szövegmezőbe írja be a FunctionsSceneszöveget, majd nyomja le a Mentés gombot.

        Függvények jelenetének mentése

  6. A Build Gépház többibeállítását az alapértelmezett értéken kell hagynunk.

    Hagyja meg az alapértelmezett buildbeállításokat

  7. A Build Gépház ablakban kattintson a Player Gépház gombra, ezzel megnyitja a kapcsolódó panelt abban a térben, ahol az Inspector található.

    a lejátszó beállításai az Inspectorban

  8. Ezen a panelen ellenőrizni kell néhány beállítást:

    1. Az Egyéb Gépház lapon:

      1. A parancsprogram-futtatás verziójánakkísérletinek kell lennie (.NET 4.6-os megfelelő), ami a szerkesztő újraindítását igényli.
      2. A szkriptek háttérrendszerének.NET-nek kell lennie
      3. Az API kompatibilitási szintjének.NET 4.6-nak kell lennie
    2. A Publishing Gépház lap Capabilities (Képességek) lapjánjelölje be a következőt:

      • InternetClient

        képességek beállítása

    3. A panelen lejjebb, az XR Gépház (a Publishing Gépházalatt található) jelölje be a Virtual Reality supported(Virtuális valóság támogatása) jelölőnégyzetet, és győződjön meg arról, hogy az Windows Mixed Reality SDK hozzá van adva.

      XR-beállítások megadása

  9. A Build GépházUnity C#-projektek már nem szürkülnek ki; jelölje be a mellette látható jelölőnégyzetet.

    c#-projektek órajele

  10. Zárja be a Build Gépház ablakot.

  11. Mentse a scene és Project (FILESAVE SCENE / FILESAVE PROJECT).

4. fejezet – A fő kamera beállítása

Fontos

Ha ki szeretné hagyni a kurzus Unity-összetevők beállítását, és közvetlenül a kódba szeretne ugrani, töltse le ezt a .unitypackagecsomagot, és importálja a projektbe Custom Package-csomagként. Ez a következő fejezetből származó DLL-eket is tartalmazza. Importálás után folytassa a 7. fejezettel.

  1. A Hierarchia panelentalálható egy Main Camera (Main Camera)nevű objektum, amely az alkalmazáson belüli "head" (fej) nézőpontot jelöli.

  2. A Unity irányítópultja előtt válassza a Main Camera GameObject et. Figyelje meg, hogy az Inspector panel (amely általában a jobb oldalon található az Irányítópulton) az adott GameObjectkülönböző összetevőit mutatja, felül az Átalakítás, majd a Camera(Kamera) és néhány más összetevőt. Alaphelyzetbe kell állítania a Fő kamera átalakítását, hogy megfelelően legyen elhelyezve.

  3. Ehhez válassza a Kamera Átalakítás összetevője melletti Fogaskerék ikont, majd válassza a Alaphelyzetbe állítás lehetőséget.

    átalakítás alaphelyzetbe állítása

  4. Ezután frissítse az Átalakítás összetevőt a következőre:

    ÁTALAKÍTÁS – POZÍCIÓ
    X Y Z
    0 1 0
    ÁTALAKÍTÁS – ELFORGATÁS
    X Y Z
    0 0 0
    ÁTALAKÍTÁS – MÉRETEZÉS
    X Y Z
    1 1 1

    kamera-átalakítás beállítása

5. fejezet – A Unity-jelenet beállítása

  1. Kattintson a jobb gombbal a Hierarchiapanel egy üres területére, a 3D objektumalatt adjon hozzá egy Síkot.

    új sík létrehozása

  2. A Plane objektum kiválasztása után módosítsa a következő paramétereket az Inspector panelen:

    ÁTALAKÍTÁS – POZÍCIÓ
    X Y Z
    0 0 4
    ÁTALAKÍTÁS – MÉRETEZÉS
    X Y Z
    10 1 10

    sík pozíciójának és méretezésének beállítása

    a sík jelenetnézete

  3. Kattintson a jobb gombbal a Hierarchiapanel egy üres területére, a 3D Objektumalatt adjon hozzá egy kockát.

    1. Nevezze át a kockát GazeButton névre (ha a Kocka ki van jelölve, nyomja le az "F2" billentyűt).

    2. Módosítsa a következő paramétereket az Inspector panelen:

      ÁTALAKÍTÁS – POZÍCIÓ
      X Y Z
      0 3 5

      a tekintet gomb átalakításának beállítása

      tekintet gomb jelenetnézete

    3. Kattintson a Címke legördülő gombra, majd kattintson a Címke hozzáadása elemre a Címkék rétegei panel megnyitásához.

      új címke hozzáadása

      plusz kiválasztása

    4. Válassza a + (plusz) gombot, majd az Új címke neve mezőbe írja be a GazeButtonnevet, majd nyomja le a Save (Mentés) gombot.

      új címke elnevezése

    5. Kattintson a GazeButton objektumra a Hierarchiapanelen, majd az Inspector panelenrendelje hozzá az újonnan létrehozott GazeButton címkét.

      hozzárendeli a tekintet gombot az új címkéhez

  4. Kattintson a jobb gombbal a GazeButton objektumra a Hierarchiapanelen, és adjon hozzá egy Empty GameObject objektumot (amely gyermekobjektumként lesz hozzáadva).

  5. Jelölje ki az új objektumot, és nevezze át ShapeSpawnPoint névre.

    1. Módosítsa a következő paramétereket az Inspector panelen:

      ÁTALAKÍTÁS – POZÍCIÓ
      X Y Z
      0 -1 0

      alakzat- és pontalakzat-átalakítás frissítése

      shape spawn point scene view

  6. A következő lépés egy 3D Text objektum létrehozása, amely visszajelzést küld az Azure-szolgáltatás állapotáról.

    Kattintson ismét a Jobb gombbal a Hierarchia panel GazeButton gombjára, és adjon hozzá egy 3D Object3D Text objektumot gyermekként.

    új 3D szöveges objektum létrehozása

  7. Nevezze át a 3D Text objektumota következőre: AzureStatusText.

  8. Módosítsa az AzureStatusText objektum Átalakítás tulajdonságát a következőképpen:

    ÁTALAKÍTÁS – POZÍCIÓ
    X Y Z
    0 0 -0,6
    ÁTALAKÍTÁS – MÉRETEZÉS
    X Y Z
    0.1 0.1 0.1

    Megjegyzés

    Ne aggódjon, ha úgy tűnik, hogy a középponton túl van, mivel ez az alábbi Text Mesh-összetevő frissítése után ki lesz javítva.

  9. Módosítsa a Text Mesh összetevőt úgy, hogy megfeleljen az alábbiaknak:

    szövegháló összetevő beállítása

    Tipp

    A kiválasztott szín hexxiális szín: 000000FF, bár nyugodtan választhatja a sajátját, csak ellenőrizze, hogy olvasható-e.

  10. A Hierarchia panel struktúrájának most így kell kinéznie:

    Szövegháló a hierarchiában

  11. A jelenetnek most így kell kinéznie:

    Szövegháló jelenetnézetben

6. fejezet – Az Azure Storage for Unity importálása

Az Azure Storage Unityt fogja használni (amely maga az Azure-hoz készült .Net SDK-t használja). Erről bővebben az Azure Storage for Unity-cikkben olvashat.

A Unityben jelenleg van egy ismert probléma, amely miatt az importálás után újra kell konfigurálni a beépülő modulokat. Ezek a lépések (a szakasz 4–7. lépései) a hiba megoldása után már nem szükségesek.

Az SDK saját projektbe való importálásához győződjön meg arról, hogy letöltötte a legújabb ".unitypackage"fájlt a GitHub. Ezután tegye a következőket:

  1. Adja hozzá a .unitypackage fájlt a Unityhez az AssetsImport PackageCustom Package menüelem használatával.

  2. A felugró Import Unity Package mezőben mindent kiválaszthat a Beépülőmodul alatt, Storage. Törölje a jelölést minden más jelölőnégyzetből, mert erre a kurzusra nincs szükség.

    importálás csomagba

  3. Kattintson az Importálás gombra az elemek projekthez való hozzáadásához.

  4. A Beépülő modulok Storagegombra a Project nézetben válassza ki a következő beépülő modulokat:

    • Microsoft.Data.Edm

    • Microsoft.Data.OData

    • Microsoft.WindowsAzure.Storage

    • Newtonsoft.Json

    • System.Spatial

      törölje a Bármely platform jelölőnégyzet jelölését

  5. Jelölje ki ezeket a beépülő modulokat, törölje a Bármely platform jelölőnégyzet jelölését, törölje a jelölést a WSAPlayer jelölőnégyzetből, majd kattintson az Apply (Alkalmaz) gombra.

    platform-dll-fájlok alkalmazása

    Megjegyzés

    Ezeket a beépülő modulokat úgy jelöljük meg, hogy csak a Unity-szerkesztőben használhatók. Ennek az az oka, hogy ugyanazoknak a beépülő moduloknak különböző verziói vannak a WSA mappában, amelyek a projekt Unityből való exportálása után lesznek használva.

  6. Az Storage beépülő modul mappájában csak a következőt válassza:

    • Microsoft.Data.Services.Client

      set don't process for dlls

  7. Jelölje be a Ne folyamat jelölőnégyzetet a Platform Gépház, majd kattintson az Apply (Alkalmaz) gombra.

    nincs feldolgozás

    Megjegyzés

    Ezt a beépülő modult azért jelöljük meg "Ne használja", mert a Unity szerelvény-javítója nehezen tudja feldolgozni a beépülő modult. A beépülő modul akkor is működni fog, ha nincs feldolgozva.

7. fejezet – Az AzureServices osztály létrehozása

Az első osztály, amit létre fog hozni, az AzureServices osztály.

Az AzureServices osztály feladata a következő:

  • Azure-fiók hitelesítő adatainak tárolása.

  • Az Azure App Function hívása.

  • Az adatfájl feltöltése és letöltése az Azure Cloud Storage.

Az osztály létrehozása:

  1. Kattintson a jobb gombbal az Asset mappára, amely a Project, Create Folder (Mappa létrehozása)panelen található. A mappának a Scripts nevet kell írnia.

    új mappa létrehozása

    hívási mappa – szkriptek

  2. Kattintson duplán az éppen létrehozott mappára a megnyitásához.

  3. Kattintson a jobb gombbal a Create C# Script (C#-szkript létrehozása) mappában. Hívja meg az AzureServices szkriptet.

  4. Kattintson duplán az új AzureServices osztályra a következővel való Visual Studio.

  5. Adja hozzá a következő névtereket az AzureServices tetejéhez:

        using System;
        using System.Threading.Tasks;
        using UnityEngine;
        using Microsoft.WindowsAzure.Storage;
        using Microsoft.WindowsAzure.Storage.File;
        using System.IO;
        using System.Net;
    
  6. Adja hozzá a következő Inspector-mezőket az AzureServices osztályhoz:

        /// <summary>
        /// Provides Singleton-like behavior to this class.
        /// </summary>
        public static AzureServices instance;
    
        /// <summary>
        /// Reference Target for AzureStatusText Text Mesh object
        /// </summary>
        public TextMesh azureStatusText;
    
  7. Ezután adja hozzá a következő tagváltozókat az AzureServices osztályhoz:

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

    Fontos

    Cserélje le a végpont és a kapcsolati sztring értékeit az Azure Portalon található Azure-tároló értékeire.

  8. Most hozzá kell adni a Kódot az Új() ésa Start() metódushoz. Ezeket a metódusokat a osztály inicializálja:

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

    Fontos

    A CallAzureFunctionForNextShape() kódját egy későbbi fejezetben fogjuk kitölteni.

  9. Törölje az Update() metódust, mivel ez az osztály nem fogja használni.

  10. Mentse a módosításokat a Visual Studio, majd térjen vissza a Unitybe.

  11. Kattintson az AzureServices osztályra, és húzza át a Scripts mappából a Main Camera (Main Camera) objektumra a Hierarchia panelen.

  12. Válassza ki a Main Camera (Main Camera) gombot, majd ragadja meg az AzureStatusText gyermekobjektumot a GazeButton objektum alatt, és helyezze el az Inspector (Vizsgáló) AzureStatusText referenciacélmezőjében az AzureServices-szkriptre való hivatkozás meghozása érdekében.

    azure-állapot szöveges referenciacél hozzárendelése

8. fejezet – A ShapeFactory osztály létrehozása

A következő létrehozni kívánt szkript a ShapeFactory osztály. Ennek az osztálynak az a szerepe, hogy kérés esetén új alakzatot hozzon létre, és megtartsa az alakzatelőzmények listájában létrehozott alakzatok előzményeit. Alakzat létrehozásakor minden alkalommal frissül az Alakzatelőzmények lista az AzureService osztályban, majd az Azure-beliStorage. Ha az alkalmazás elindul, és egy tárolt fájl található az Azure Storage-ben,a rendszer lekéri és visszajátszja az Alakzatelőzmények listát, és a 3D Text objektum biztosítja, hogy a létrehozott alakzat a tárolóból vagy új.

Az osztály létrehozása:

  1. Ugrás a korábban létrehozott Scripts mappára.

  2. Kattintson a jobb gombbal a Create C# Script (C#-szkript létrehozása) mappában. Hívja meg a ShapeFactory szkriptet.

  3. Kattintson duplán az új ShapeFactory szkriptre, hogy az a következővel Visual Studio.

  4. Győződjön meg arról, hogy a ShapeFactory osztály a következő névtereket tartalmazza:

        using System.Collections.Generic;
        using UnityEngine;
    
  5. Adja hozzá az alább látható változókat a ShapeFactory osztályhoz, és cserélje le a Start() és az Azúúdó() függvényt az alábbiakra:

        /// <summary>
        /// Provide this class Singleton-like behaviour
        /// </summary>
        [HideInInspector]
        public static ShapeFactory instance;
    
        /// <summary>
        /// Provides an Inspector exposed reference to ShapeSpawnPoint
        /// </summary>
        [SerializeField]
        public Transform spawnPoint;
    
        /// <summary>
        /// Shape History Index
        /// </summary>
        [HideInInspector]
        public List<int> shapeHistoryList;
    
        /// <summary>
        /// Shapes Enum for selecting required shape
        /// </summary>
        private enum Shapes { Cube, Sphere, Cylinder }
    
        private void Awake()
        {
            instance = this;
        }
    
        private void Start()
        {
            shapeHistoryList = new List<int>();
        }
    
  6. A CreateShape() metódus a megadott egész szám paraméter alapján hozza létre a primitív alakzatokat. A logikai paraméterrel adható meg, hogy az aktuálisan létrehozott alakzat tárolóból vagy újból van-e létrehozva. Helyezze a következő kódot a ShapeFactory osztályba az előző metódusok alá:

        /// <summary>
        /// Use the Shape Enum to spawn a new Primitive object in the scene
        /// </summary>
        /// <param name="shape">Enumerator Number for Shape</param>
        /// <param name="storageShape">Provides whether this is new or old</param>
        internal void CreateShape(int shape, bool storageSpace)
        {
            Shapes primitive = (Shapes)shape;
            GameObject newObject = null;
            string shapeText = storageSpace == true ? "Storage: " : "New: ";
    
            AzureServices.instance.azureStatusText.text = string.Format("{0}{1}", shapeText, primitive.ToString());
    
            switch (primitive)
            {
                case Shapes.Cube:
                newObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
                break;
    
                case Shapes.Sphere:
                newObject = GameObject.CreatePrimitive(PrimitiveType.Sphere);
                break;
    
                case Shapes.Cylinder:
                newObject = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
                break;
            }
    
            if (newObject != null)
            {
                newObject.transform.position = spawnPoint.position;
    
                newObject.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
    
                newObject.AddComponent<Rigidbody>().useGravity = true;
    
                newObject.GetComponent<Renderer>().material.color = UnityEngine.Random.ColorHSV(0f, 1f, 1f, 1f, 0.5f, 1f);
            }
        }
    
  7. Mielőtt visszatér a Unitybe, mindenképpen mentse a módosításokat Visual Studio a unitybe.

  8. A Unity-szerkesztőben kattintson és húzza a ShapeFactory osztályt a Scripts mappából a Hierarchy Panel Main Camera objektumába.

  9. Ha a Main Camera (Fő kamera) van kiválasztva, észreveheti, hogy a ShapeFactory szkript összetevőből hiányzik a Beállítási pont hivatkozás. A hiba kijavítása érdekében húzza a ShapeSpawnPoint objektumot a Hierarchy Panelről a Majdani pont referenciacélra.

    alakzat-előállító referenciacél beállítása

9. fejezet – A Tekintet osztály létrehozása

Az utolsó létrehozató szkript a Tekintet osztály.

Ez az osztály felelős egy Olyan Raycast létrehozásáért, amely előre lesz vetve a Main Camera-ból, és amely észleli, hogy a felhasználó melyik objektumot nézi. Ebben az esetben a Raycastnak azonosítania kell, hogy a felhasználó a gazeButton objektumot nézi-e a jelenetben, és aktiválni kell a viselkedést.

Az osztály létrehozása:

  1. Ugrás a korábban létrehozott Scripts mappára.

  2. Kattintson a jobb gombbal a Project panelena Create C# Script (C#-szkript létrehozása) elemre. Hívja meg a Tekintet szkriptet.

  3. Kattintson duplán az új Tekinteti szkriptre, hogy megnyitja Visual Studio.

  4. Győződjön meg arról, hogy a szkript tetején szerepel a következő névtér:

        using UnityEngine;
    
  5. Ezután adja hozzá a következő változókat a Tekintet osztályhoz:

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

Fontos

Ezen változók némelyike szerkeszthető lesz a szerkesztőben.

  1. Most hozzá kell adni a kódot az Új() és Start() metódushoz.

        /// <summary>
        /// The method used after initialization of the scene, though before Start().
        /// </summary>
        private void Awake()
        {
            // Set this class to behave similar to singleton
            instance = this;
        }
    
        /// <summary>
        /// Start method used upon initialization.
        /// </summary>
        private void Start()
        {
            FocusedObject = null;
            Cursor = CreateCursor();
        }
    
  2. Adja hozzá a következő kódot, amely indításkor létrehoz egy kurzorobjektumot az Update() metódussal együtt, amely a Raycast metódust futtatja, valamint a GazeEnabled logikai kapcsolót:

        /// <summary>
        /// Method to create a cursor object.
        /// </summary>
        /// <returns></returns>
        private GameObject CreateCursor()
        {
            GameObject newCursor = GameObject.CreatePrimitive(PrimitiveType.Sphere);
            newCursor.SetActive(false);
    
            // Remove the collider, so it doesn't block raycast.
            Destroy(newCursor.GetComponent<SphereCollider>());
            newCursor.transform.localScale = CursorSize;
    
            newCursor.GetComponent<MeshRenderer>().material = new Material(Shader.Find("Diffuse"))
            {
                color = CursorColour
            };
    
            newCursor.name = "Cursor";
    
            newCursor.SetActive(true);
    
            return newCursor;
        }
    
        /// <summary>
        /// Called every frame
        /// </summary>
        private void Update()
        {
            if(GazeEnabled == true)
            {
                _gazeOrigin = Camera.main.transform.position;
    
                _gazeDirection = Camera.main.transform.forward;
    
                UpdateRaycast();
            }
        }
    
  3. Ezután adja hozzá az UpdateRaycast() metódust, amely egy Raycast-projektet fog kivetíteni, és észleli a találati célt.

        private void UpdateRaycast()
        {
            // Set the old focused gameobject.
            _oldFocusedObject = FocusedObject;
    
            RaycastHit hitInfo;
    
            // Initialise Raycasting.
            Hit = Physics.Raycast(_gazeOrigin,
                _gazeDirection,
                out hitInfo,
                GazeMaxDistance, LayerMask);
    
            HitInfo = hitInfo;
    
            // Check whether raycast has hit.
            if (Hit == true)
            {
                Position = hitInfo.point;
    
                Normal = hitInfo.normal;
    
                // Check whether the hit has a collider.
                if (hitInfo.collider != null)
                {
                    // Set the focused object with what the user just looked at.
                    FocusedObject = hitInfo.collider.gameObject;
                }
                else
                {
                    // Object looked on is not valid, set focused gameobject to null.
                    FocusedObject = null;
                }
            }
            else
            {
                // No object looked upon, set focused gameobject to null.
                FocusedObject = null;
    
                // Provide default position for cursor.
                Position = _gazeOrigin + (_gazeDirection * GazeMaxDistance);
    
                // Provide a default normal.
                Normal = _gazeDirection;
            }
    
            // Lerp the cursor to the given position, which helps to stabilize the gaze.
            Cursor.transform.position = Vector3.Lerp(Cursor.transform.position, Position, 0.6f);
    
            // Check whether the previous focused object is this same 
            //    object. If so, reset the focused object.
            if (FocusedObject != _oldFocusedObject)
            {
                ResetFocusedObject();
    
                if (FocusedObject != null)
                {
                if (FocusedObject.CompareTag(InteractibleTag.ToString()))
                {
                        // Set the Focused object to green - success!
                        FocusedObject.GetComponent<Renderer>().material.color = Color.green;
    
                        // Start the Azure Function, to provide the next shape!
                        AzureServices.instance.CallAzureFunctionForNextShape();
                    }
                }
            }
        }
    
  4. Végül adja hozzá a ResetFocusedObject() metódust, amely ki- és bekapcsolja a GazeButton-objektumok aktuális színét, jelezve, hogy új alakzatot hoz-e létre.

        /// <summary>
        /// Reset the old focused object, stop the gaze timer, and send data if it
        /// is greater than one.
        /// </summary>
        private void ResetFocusedObject()
        {
            // Ensure the old focused object is not null.
            if (_oldFocusedObject != null)
            {
                if (_oldFocusedObject.CompareTag(InteractibleTag.ToString()))
                {
                    // Set the old focused object to red - its original state.
                    _oldFocusedObject.GetComponent<Renderer>().material.color = Color.red;
                }
            }
        }
    
  5. Mentse a módosításokat a Visual Studio, mielőtt visszatér a Unitybe.

  6. Kattintson a Tekintet osztályra, és húzza át a Parancsfájlok mappából a Main Camera (Main Camera) objektumra a Hierarchia panelen.

10. fejezet – Az AzureServices osztály befejezése

A többi szkript üzembe helyezése után már befejezi azAzureServices osztályt. Ez a következőn keresztül érhető el:

  1. Új metódus hozzáadása CreateCloudIdentityAsync()névvel az Azure-ral való kommunikációhoz szükséges hitelesítési változók beállítására.

    Ez a metódus azt is ellenőrzi, hogy létezik-e az alakzatlistát tartalmazó, korábban tárolt fájl.

    Ha a fájlmegtalálható, akkor letiltja a felhasználó tekintetét, és az alakzatok mintázatának megfelelően elindítja az alakzat létrehozását az Azure-beli virtuális Storage alapján. A felhasználó ezt láthatja, mivel a Text Mesh a forrásalakzattól függően Storage "Storage" vagy "Új" megjelenítési adatokat jelenít meg.

    Ha nem található fájl,akkor engedélyezi a Tekintetet,amely lehetővé teszi, hogy a felhasználó alakzatokat hozzon létre a jelenetBen lévő GazeButton objektumra való tekintetkor.

        /// <summary>
        /// Create the references necessary to log into Azure
        /// </summary>
        private async void CreateCloudIdentityAsync()
        {
            // Retrieve storage account information from connection string
            storageAccount = CloudStorageAccount.Parse(storageConnectionString);
    
            // Create a file client for interacting with the file service.
            fileClient = storageAccount.CreateCloudFileClient();
    
            // Create a share for organizing files and directories within the storage account.
            share = fileClient.GetShareReference(fileShare);
    
            await share.CreateIfNotExistsAsync();
    
            // Get a reference to the root directory of the share.
            CloudFileDirectory root = share.GetRootDirectoryReference();
    
            // Create a directory under the root directory
            dir = root.GetDirectoryReference(storageDirectory);
    
            await dir.CreateIfNotExistsAsync();
    
            //Check if the there is a stored text file containing the list
            shapeIndexCloudFile = dir.GetFileReference("TextShapeFile");
    
            if (!await shapeIndexCloudFile.ExistsAsync())
            {
                // File not found, enable gaze for shapes creation
                Gaze.instance.GazeEnabled = true;
    
                azureStatusText.text = "No Shape\nFile!";
            }
            else
            {
                // The file has been found, disable gaze and get the list from the file
                Gaze.instance.GazeEnabled = false;
    
                azureStatusText.text = "Shape File\nFound!";
    
                await ReplicateListFromAzureAsync();
            }
        }
    
  2. A következő kódrészlet a Start() metódusból való; ahol a Rendszer hívást fog létrehozni a CreateCloudIdentityAsync() metódusra. Nyugodtan másolja át az aktuális Start() metódust az alábbiak szerint:

        private void Start()
        {
            // Disable TLS cert checks only while in Unity Editor (until Unity adds support for TLS)
    #if UNITY_EDITOR
            ServicePointManager.ServerCertificateValidationCallback = delegate { return true; };
    #endif
    
            // Set the Status text to loading, whilst attempting connection to Azure.
            azureStatusText.text = "Loading...";
    
            //Creating the references necessary to log into Azure and check if the Storage Directory is empty
            CreateCloudIdentityAsync();
        }
    
  3. Töltse ki a CallAzureFunctionForNextShape()metódus kódját. Alakzatindex igényléséhez a korábban létrehozott Azure-függvényalkalmazást fogja használni. Az új alakzat megkapása után ez a metódus elküldi az alakzatot a ShapeFactory osztálynak, hogy létrehozza az új alakzatot a jelenetben. Az alábbi kóddal töltse ki a CallAzureFunctionForNextShape() törzsét.

        /// <summary>
        /// Call to the Azure Function App to request a Shape.
        /// </summary>
        public async void CallAzureFunctionForNextShape()
        {
            int azureRandomInt = 0;
    
            // Call Azure function
            HttpWebRequest webRequest = WebRequest.CreateHttp(azureFunctionEndpoint);
    
            WebResponse response = await webRequest.GetResponseAsync();
    
            // Read response as string
            using (Stream stream = response.GetResponseStream())
            {
                StreamReader reader = new StreamReader(stream);
    
                String responseString = reader.ReadToEnd();
    
                //parse result as integer
                Int32.TryParse(responseString, out azureRandomInt);
            }
    
            //add random int from Azure to the ShapeIndexList
            ShapeFactory.instance.shapeHistoryList.Add(azureRandomInt);
    
            ShapeFactory.instance.CreateShape(azureRandomInt, false);
    
            //Save to Azure storage
            await UploadListToAzureAsync();
        }
    
  4. Adjon hozzá egy metódust egy sztring létrehozásához az alakzatelőzmények listájában tárolt egész számokkal, majd mentse azt az Azure Storage Fájlba.

        /// <summary>
        /// Upload the locally stored List to Azure
        /// </summary>
        private async Task UploadListToAzureAsync()
        {
            // Uploading a local file to the directory created above
            string listToString = string.Join(",", ShapeFactory.instance.shapeHistoryList.ToArray());
    
            await shapeIndexCloudFile.UploadTextAsync(listToString);
        }
    
  5. Adjon hozzá egy metódust, amely lekéri az Azure Storage File fájlban található fájlban tárolt szöveget, és deszerializálja egy listában.

  6. A folyamat befejezése után a metódus újra engedélyezi a tekintetet, hogy a felhasználó további alakzatokat adjon a jelenethez.

        ///<summary>
        /// Get the List stored in Azure and use the data retrieved to replicate 
        /// a Shape creation pattern
        ///</summary>
        private async Task ReplicateListFromAzureAsync()
        {
            string azureTextFileContent = await shapeIndexCloudFile.DownloadTextAsync();
    
            string[] shapes = azureTextFileContent.Split(new char[] { ',' });
    
            foreach (string shape in shapes)
            {
                int i;
    
                Int32.TryParse(shape.ToString(), out i);
    
                ShapeFactory.instance.shapeHistoryList.Add(i);
    
                ShapeFactory.instance.CreateShape(i, true);
    
                await Task.Delay(500);
            }
    
            Gaze.instance.GazeEnabled = true;
    
            azureStatusText.text = "Load Complete!";
        }
    
  7. Mentse a módosításokat a Visual Studio, mielőtt visszatér a Unitybe.

11. fejezet – Az UWP-megoldás kiépítése

A buildfolyamat megkezdéséhez:

  1. Ugrás a Fájlbuildelő Gépház.

    az alkalmazás összeállítása

  2. Kattintson a Build (Build) gombra. A Unity elindít egy Fájlkezelő, amelyben létre kell hoznia, majd ki kell választania egy mappát, amelybe az alkalmazást felépíti. Hozza létre ezt a mappát, és nevezze el App néven. Ezután jelölje ki az Alkalmazás mappát, és kattintson a Mappa kiválasztása gombra.

  3. A Unity megkezdi a projekt az App mappában való építését.

  4. Ha a Unity befejezte az összeállítást (ez némi időt is vegyen el), megnyílik egy Fájlkezelő-ablak a build helyén (ellenőrizze a feladatsávot, mert előfordulhat, hogy nem mindig jelenik meg az ablakok fölött, de értesítést küld egy új ablakról).

12. fejezet – Az alkalmazás üzembe helyezése

Az alkalmazás üzembe helyezése:

  1. Lépjen az app mappára, amely az előző fejezetben jött létre. Egy fájlt fog látni az alkalmazás nevével és az ".sln" kiterjesztéssel, amelyre duplán kell kattintanunk, ezért a fájlban való megnyitásáhozVisual Studio.

  2. A Megoldásplatformonválassza az x86, helyi gép lehetőséget.

  3. A Megoldáskonfigurációban válassza a Hibakeresés lehetőséget.

    A Microsoft HoloLens könnyebben beállíthatja a Távoli gép beállítását, hogy ne legyen a számítógépéhezkötve. Azonban a következőket is el kell majd követnie:

    • Ismeri a hálózati HoloLens IP-címét, amely a GépházNetwork Internet Wi-Fi speciális beállításai között található; az IPv4-címet érdemes használnia.
    • Ellenőrizze, hogy a Fejlesztői mód be van-e va; A a GépházUpdate Security for developers (Frissítésbiztonság frissítésefejlesztők számára) 2.

    megoldás üzembe helyezése

  4. A Build (Build) menüben kattintson a Deploy Solution (Megoldás üzembe helyezése) elemre az alkalmazás saját gépre való telepítéséhez.

  5. Az alkalmazásnak most már meg kell jelenni a telepített alkalmazások listájában, készen áll az indulásra és a tesztelésre!

A kész Azure Functions és Storage application

Gratulálunk, felépített egy vegyes valóságon keresztüli alkalmazást, amely az Azure Functions és az Azure Storage is kihasználja. Az alkalmazás képes lesz a tárolt adatok alapján rajzolni, és az adatok alapján műveletet biztosítani.

végleges termék vége

Soron kívüli gyakorlatok

1. gyakorlat

Hozzon létre egy második pont-pont és egy rekordot, amelyből az objektum létrejött. Az adatfájl betöltésekor visszajátssa az eredetileg létrehozott helyről származó alakzatokat.

2. gyakorlat

Az alkalmazás újraindításának módja ahelyett, hogy minden alkalommal újra meg kell nyitnia. A Jelenetek betöltése jó kezdő pont. Ezt követően hozzon létre egy olyan módját, amely törli a tárolt listát az Azure Storage-ban,hogy könnyen visszaállítható legyen az alkalmazásból.