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

Cikk
01/17/2024

Megjegyzés

A Mixed Reality Academy oktatóanyagait a HoloLens (1. generációs) és Mixed Reality modern headsetek szem előtt tartásával tervezték. Ezért fontosnak tartjuk, hogy ezeket az oktatóanyagokat helyben hagyjuk azoknak a fejlesztőknek, akik továbbra is útmutatást keresnek az ilyen eszközök fejlesztéséhez. Ezek az oktatóanyagok nem frissülnek az HoloLens 2 legújabb eszközkészleteivel vagy interakcióival. A támogatott eszközökön továbbra is működni fognak. A jövőben egy új oktatóanyag-sorozat jelenik meg, amely bemutatja, hogyan fejleszthet HoloLens 2. Ezt az értesítést a közzétételükkor az oktatóanyagokra mutató hivatkozással frissítjük.

final product -start

Ebben a tanfolyamban megtanulhatja, hogyan hozhat létre és használhat Azure Functions és tárolhat adatokat egy Azure Storage-erőforrással egy vegyes valóságú alkalmazásban.

Azure Functions egy Microsoft-szolgáltatás, amely lehetővé teszi a fejlesztők számára, hogy kis kódrészleteket (functions) futtasson az Azure-ban. Így a helyi alkalmazás helyett a felhőbe delegálhatja a munkát, ami számos előnnyel járhat. Azure Functions számos fejlesztési nyelvet támogat, például a C#, az F#, a Node.js, a Java és a PHP nyelvet. További információt a Azure Functions cikkben talál.

Az Azure Storage egy Microsoft-felhőszolgáltatás, amely lehetővé teszi a fejlesztők számára az adatok tárolását azzal a biztosítással, hogy magas rendelkezésre állású, biztonságos, tartós, méretezhető és redundáns lesz. Ez azt jelenti, hogy a Microsoft minden karbantartást és kritikus problémát kezelni fog. További információért tekintse meg az Azure Storage cikket.

Miután elvégezte ezt a tanfolyamot, egy vegyes valósági modern headset-alkalmazással fog rendelkezni, amely a következőket fogja tudni elvégezni:

Engedélyezze a felhasználónak, hogy egy jelenet körül nézzen.
Aktiválja az objektumok ívását, amikor a felhasználó egy 3D-s "gombra" néz.
Az ívott objektumokat egy Azure-függvény választja ki.
Az egyes objektumok ívása során az alkalmazás egy Azure Storage-fájlban tárolja az objektumtípust.
A második betöltéskor a rendszer lekéri az Azure File-adatokat , és az alkalmazás előző példányából származó ívási műveletek visszajátszására szolgál.

Az alkalmazásban ön múlik, hogyan fogja integrálni az eredményeket a tervével. Ez a tanfolyam arra szolgál, hogy megtanítsa, hogyan integrálhat egy Azure-szolgáltatást a Unity-projekttel. Az Ön feladata, hogy felhasználja a tanfolyamból szerzett tudást a vegyes valóság alkalmazás továbbfejlesztéséhez.

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 Windows Mixed Reality magával ragadó (VR) headsetekre összpontosít, a tanfolyamban tanultakat alkalmazhatja a Microsoft HoloLens. Ahogy követi a tanfolyamot, jegyzeteket fog látni a HoloLens támogatásához esetleg szükséges módosításokról.

Előfeltételek

Megjegyzés

Ez az oktatóanyag olyan fejlesztőknek készült, akik alapszintű tapasztalattal rendelkeznek a Unityben és a C#-ben. Felhívjuk a figyelmét arra is, hogy a jelen dokumentumban szereplő előfeltételek és írásos utasítások az íráskor (2018. május) tesztelt és ellenőrzött adatokat jelölik. Szabadon használhatja a legújabb szoftvert, ahogy az az eszközök telepítéséről szóló cikkben szerepel, bár nem szabad feltételezni, hogy a tanfolyam információi tökéletesen megfelelnek az újabb szoftverekben található információknak, mint az alább felsoroltak.

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

A modern (VR) headsetek fejlesztéséhez Windows Mixed Reality kompatibilis fejlesztőszámítógép
Windows 10 Fall Creators Update (vagy újabb) a fejlesztői mód engedélyezésével
A legújabb Windows 10 SDK
Unity 2017.4
Visual Studio 2017
Windows Mixed Reality modern (VR) headset vagy Microsoft HoloLens, amelyen engedélyezve van a Fejlesztői mód
Azure-fiók előfizetése Azure-erőforrások létrehozásához
Internet-hozzáférés az Azure beállításához és az adatok lekéréséhez

Előkészületek

A projekt létrehozásával kapcsolatos problémák elkerülése érdekében javasoljuk, hogy az oktatóanyagban említett projektet gyökérszintű vagy gyökérszintű mappában hozza létre (a hosszú mappaelérési utak problémákat okozhatnak buildeléskor).

1. fejezet – Az Azure Portal

Az Azure Storage szolgáltatás használatához létre kell hoznia és konfigurálnia kell egy tárfiókot a Azure Portal.

Jelentkezzen be az Azure Portalra.

Megjegyzés

Ha még nem rendelkezik Azure-fiókkal, létre kell hoznia egyet. Ha tantermi vagy laborhelyzetben követi ezt az oktatóanyagot, kérjen segítséget az oktatótól vagy az egyik szakembertől az új fiók beállításához.
Miután bejelentkezett, kattintson a bal felső sarokban az Új elemre, keresse meg a Tárfiók elemet, majd kattintson az Enter gombra.

Megjegyzés

Előfordulhat, hogy az Új szót az Erőforrás létrehozása kifejezésre cserélték az újabb portálokon.
Az új oldalon megjelenik az Azure Storage-fiók szolgáltatás leírása. A parancssor bal alsó sarkában válassza a Létrehozás gombot a szolgáltatással való társítás létrehozásához.
Miután a Létrehozás gombra kattintott:
1. Adjon nevet a fióknak, ne feledje, hogy ez a mező csak számokat és kisbetűket fogad el.
2. Az Üzembehelyezési modell beállításnál válassza a Resource Manager lehetőséget.
3. A Fiók típusa beállításnál válassza a Tárolás (á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 lenne, 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ásvédett 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. Hagyja letiltva a Biztonságos átvitel szükséges beállítást.
8. Válasszon ki egy előfizetést.
9. Válasszon egy erőforráscsoportot , vagy hozzon létre egy újat. Az erőforráscsoportokkal monitorozhat, szabályozhat hozzáférést, kiépíteni és kezelni tudja az Azure-objektumok gyűjteményének számlázását. Javasoljuk, hogy az egyetlen projekthez társított összes Azure-szolgáltatást (például ezeket a tesztkörnyezeteket) egy közös erőforráscsoport alatt tartsa.
  
  Ha többet szeretne megtudni az Azure-erőforráscsoportokról, látogasson el az erőforráscsoportról szóló cikkre.
10. Azt is meg kell erősítenie, hogy megértette a szolgáltatásra vonatkozó feltételeket.
11. Válassza a Létrehozás lehetőséget.
Miután a Létrehozás gombra kattintott, meg kell várnia a szolgáltatás létrehozását, ez eltarthat egy percig.
A szolgáltatáspéldány létrehozása után megjelenik egy értesítés a portálon.
Kattintson az értesítésekre az új szolgáltatáspéldány megismeréséhez.
Az értesítésben kattintson az Erőforrás megnyitása gombra az új szolgáltatáspéldány megismeréséhez. Ekkor megnyílik az új Storage-fiók szolgáltatáspéldánya.
Kattintson a Hozzáférési kulcsok elemre a felhőszolgáltatás végpontjainak megjelenítéséhez. Használja a Jegyzettömb vagy hasonló lehetőséget az egyik kulcs későbbi használatra történő másolásához. Jegyezze fel a Kapcsolati sztring értékét is, mivel az az AzureServices osztályban lesz használva, amelyet később fog létrehozni.

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

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

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

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

Az Azure Portalon kattintson a bal felső sarokban az Új elemre, keresse meg a függvényalkalmazást, majd kattintson az Enter gombra.

Megjegyzés

Előfordulhat, hogy az Új szót lecserélték az Erőforrás létrehozása elemre az újabb portálokon.
Az új oldal az Azure Function App service leírását adja meg. A parancssor bal alsó sarkában válassza a Létrehozás gombot a szolgáltatáshoz való társítás létrehozásához.
Miután a Létrehozás gombra kattintott:
1. Adjon meg egy alkalmazásnevet. Itt csak betűk és számok használhatók (kis- és nagybetűk is megengedettek).
2. Válassza ki az előnyben részesített előfizetést.
3. Válasszon egy erőforráscsoportot , vagy hozzon létre egy újat. Az erőforráscsoportok lehetővé teszi az Azure-eszközök gyűjteményéhez tartozó számlázás monitorozását, vezérlését, kiépítését és kezelését. Javasoljuk, hogy az egyetlen projekthez (például a tesztkörnyezetekhez) társított összes Azure-szolgáltatást egy közös erőforráscsoportban tartsa.
  
  Ha többet szeretne megtudni az Azure-erőforráscsoportokról, tekintse meg az erőforráscsoportról szóló cikket.
4. Ebben a gyakorlatban válassza a Windows lehetőséget a választott operációs rendszerként.
5. Válassza a Használati csomag lehetőséget az üzemeltetési csomaghoz.
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 lenne, 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 Tárolás területen válassza a Meglévő használata lehetőséget, majd a legördülő menüben keresse meg a korábban létrehozott tárolót.
8. Hagyja ki az Application Insightst ebben a gyakorlatban.
Kattintson a Létrehozás gombra.
Miután a Létrehozás gombra kattintott, meg kell várnia a szolgáltatás létrehozását, ez eltarthat egy percig.
A szolgáltatáspéldány létrehozása után megjelenik egy értesítés a portálon.
Kattintson az értesítésekre az új szolgáltatáspéldány megismeréséhez.
Az értesítésben kattintson az Erőforrás megnyitása gombra az új szolgáltatáspéldány megismeréséhez. A rendszer az új Function App Service-példányra kerül.
A Függvényalkalmazás irányítópultján vigye az egérmutatót a Függvények fölé, amely a bal oldali panelen található, majd kattintson a + (plusz) szimbólumra.
A következő lapon győződjön meg arról, hogy a Webhook + API van kiválasztva, és a Nyelv kiválasztása beállításnál válassza a CSharp lehetőséget, mivel ez lesz az oktatóanyaghoz használt nyelv. Végül kattintson a Függvény létrehozása gombra.
A kódlapra (run.csx) kell vinnie, ha nem, kattintson az újonnan létrehozott függvényre a bal oldali panel Függvények listájában.

Másolja a következő kódot a függvénybe. Ez a függvény egyszerűen egy véletlenszerű egész számot ad vissza 0 és 2 között, amikor meghívja őket. Ne aggódjon a meglévő kód miatt, nyugodtan illessze be a felső részét.

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

Kattintson a Mentés gombra.
Az eredménynek az alábbi képhez hasonlóan kell kinéznie.
Kattintson a Függvény URL-címének lekérése elemre, és jegyezze fel a megjelenített végpontot . Ezt be kell szúrnia az AzureServices osztályba, amelyet a tanfolyam későbbi részében fog létrehozni.

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

Az alábbiak egy tipikusan a Mixed Reality használatával történő fejlesztésre szolgálnak, és mint ilyen, jó sablon más projektekhez.

Állítsa be és tesztelje a vegyes valóság magával ragadó fejhallgatóját.

Megjegyzés

Ehhez a kurzushoz nem lesz szükség mozgásvezérlőkre. Ha segítségre van szüksége a modern headset beállításához, látogasson el a vegyes valóság beállításáról szóló cikkre.

Nyissa meg a Unityt, és kattintson az Új gombra.
Most meg kell adnia a Unity-projekt nevét. MR_Azure_Functions beszúrása. Győződjön meg arról, hogy a projekt típusa 3D. Állítsa a Hely értékét az Ön számára megfelelő helyre (ne feledje, a gyökérkönyvtárakhoz való közelebb jobb). Ezután kattintson a Projekt létrehozása elemre.
Ha a Unity nyitva van, érdemes ellenőrizni, hogy az alapértelmezett szkriptszerkesztőVisual Studióra van-e állítva. Lépjen aBeállításokszerkesztése> elemre, majd az új ablakból lépjen a Külső eszközök elemre. Módosítsa a Külső szkriptszerkesztőtVisual Studio 2017-re. Zárja be a Beállítások ablakot.
Ezután lépjen a Fájlkészítési>beállítások területre, és váltson a platformra Univerzális Windows-platform, kattintson a Platformváltás gombra.
Lépjen a Fájl>buildelési beállításai területre , és győződjön meg arról, hogy:
1. A céleszközbármely eszközre van állítva.
  
  Microsoft HoloLens esetén állítsa a Céleszköz beállítást HoloLens értékre.
2. A build típusaD3D értékre van állítva
3. Az SDK a Legújabb telepített értékre van állítva
4. A Visual Studio verziója a Legújabb telepítve értékre van állítva
5. A buildelés és a futtatáshelyi gépre van állítva
6. Mentse a jelenetet, és adja hozzá a buildhez.
  1. Ehhez válassza a Nyitott jelenetek hozzáadása lehetőséget. Ekkor megjelenik egy mentési ablak.
  2. Hozzon létre egy új mappát ehhez, és minden jövőbeni jelenethez, majd az Új mappa gombra kattintva hozzon létre egy új mappát, és adja neki a Jelenetek nevet.
  3. Nyissa meg az újonnan létrehozott Jelenetek mappát, majd a Fájlnév: szöveg mezőbe írja be a FunctionsScene kifejezést, majd nyomja le a Mentés gombot.
A buildbeállításokban lévő többi beállításnak egyelőre alapértelmezettnek kell lennie.
A Build Settings (Összeállítási beállítások ) ablakban kattintson a Lejátszó beállításai gombra, ezzel megnyitja a kapcsolódó panelt abban a térben, ahol az Inspector található.
Ebben a panelen ellenőrizni kell néhány beállítást:
1. Az Egyéb beállítások lapon:
  1. A szkriptelési futtatókörnyezet verziójánakkísérletinek (.NET 4.6-os egyenértékűnek) kell lennie, ami elindítja a szerkesztő újraindításának szükségességét.
  2. A szkriptelési háttérrendszernek.NET-nek kell lennie
  3. Az API-kompatibilitási szintnek.NET 4.6-osnak kell lennie
2. A Közzétételi beállítások lapon, a Képességek területen ellenőrizze a következőt:
  - InternetClient
3. A panelen lejjebb, az XR-beállítások területen (amely a Közzétételi beállítások alatt található) jelölje be a Virtual Reality Támogatott jelölőnégyzetet, és győződjön meg arról, hogy a Windows Mixed Reality SDK hozzá van adva.
A buildbeállításokban a Unity C#-projektek már nem szürkén jelennek meg; jelölje be a mellette lévő jelölőnégyzetet.
Zárja be a Létrehozási beállítások ablakot.
Mentse a jelenetet és a projektet (FILE>SAVE SCENE /FILE>SAVE PROJECT).

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

Fontos

Ha ki szeretné hagyni a kurzus Unity Set up összetevőit, és közvetlenül a kódba szeretne lépni, töltse le ezt a .unitypackage csomagot, és importálja a projektbe egyéni csomagként. Ez a következő fejezetben szereplő DLL-eket is tartalmazza. Az importálás után folytassa a 7. fejezetből.

A Hierarchia panelen egy Fő kamera nevű objektumot talál, amely az alkalmazás "belső" nézetét jelöli.
Az Előtted lévő Unity irányítópulton válassza a Fő kamera gameObject lehetőséget. Megfigyelheti, hogy az Inspector panel (általában jobb oldalon, az irányítópulton) az adott GameObject különböző összetevőit jeleníti meg, felül az Átalakítás , majd a Kamera és néhány más összetevő. Alaphelyzetbe kell állítania a fő kamera átalakítását, hogy megfelelően legyen elhelyezve.
Ehhez válassza a Fogaskerék ikont a Kamera átalakítás összetevője mellett, majd válassza az Alaphelyzetbe állítás lehetőséget.
Ezután frissítse az Átalakítás összetevőt a következőképpen:

Átalakítás – Pozíció

X	Y	Z
0	1	0

Átalakítás – Forgatás

X	Y	Z
0	0	0

Átalakítás – Skálázás

X	Y	Z
1	1	1

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

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

Kattintson a jobb gombbal a Hierarchia panel üres területére a 3D objektum területen, és adjon hozzá egy síkot.
Ha a Sík objektum van kiválasztva, 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 – Skálázás

X	Y	Z
10	1	10

síkpozíció és skálázás beállítása

a sík jelenetnézete

Kattintson a jobb gombbal a Hierarchia panel üres területén, a 3D objektum területen 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 az alábbi paramétereket az Átalakítási pozícióhoz az Inspector panelen:
  
  X Y Z
  
  0 3 5
3. Kattintson a Címke legördülő gombra, majd a Címke hozzáadása elemre a Címkék & Rétegek panel megnyitásához.
4. Válassza a + (plusz) gombot, majd az Új címke neve mezőbe írja be a GazeButton kifejezést, és nyomja le a Mentés gombot.
5. Kattintson a GazeButton objektumra a Hierarchia panelen, majd az Inspector panelen rendelje hozzá az újonnan létrehozott GazeButton címkét .
Kattintson a jobb gombbal a GazeButton objektumra a Hierarchia panelen, és adjon hozzá egy üres GameObject objektumot (amely gyermekobjektumként lesz hozzáadva).
Jelölje ki az új objektumot, és nevezze át ShapeSpawnPoint néven.
1. Módosítsa az alábbi paramétereket az Átalakítási pozícióhoz az Inspector panelen:
  
  X Y Z
  
  0 -1 0
Ezután létrehoz egy 3D Text objektumot, amely visszajelzést küld az Azure-szolgáltatás állapotáról.

Kattintson a jobb gombbal a Hierarchia panel gazeButton elemére , és adjon hozzá egy 3D objektum>3D szövegobjektumotgyermekként.
Nevezze át a 3D Text objektumot AzureStatusText névre.
Módosítsa az AzureStatusText objektum átalakító pozícióját az alábbiak szerint:

X Y Z

0 0 -0,6
Módosítsa az AzureStatusText objektum átalakítási skálázását az alábbiak szerint: | X | Y | Z | | :---: | :---: | :---: | | 0,1 | 0,1 | 0,1 |

Megjegyzés

Ne aggódjon, ha úgy tűnik, hogy középen kívül van, mivel ez a text mesh összetevő frissítésekor lesz javítva.
Módosítsa a Text Mesh összetevőt úgy, hogy megfeleljen az alábbinak:

Tipp

A kiválasztott szín itt Hexa szín: 000000FF, bár nyugodtan válassza ki a saját, csak győződjön meg róla, hogy olvasható.
A hierarchiapanel struktúrájának a következőképpen kell kinéznie:
A jelenetnek most a következőképpen kell kinéznie:

X	Y	Z
0	3	5

X	Y	Z
0	-1	0

X	Y	Z
0	0	-0,6

6. fejezet – Az Azure Storage importálása a Unityhez

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

Jelenleg egy ismert probléma van a Unityben, amely megköveteli a beépülő modulok importálás utáni újrakonfigurálását. Ezekre a lépésekre (ebben a szakaszban a 4–7. lépésre) már nincs szükség a hiba megoldása után.

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" csomagot a GitHubról. Ezután tegye a következőket:

Adja hozzá a .unitypackage fájlt a Unityhez az AssetsImport PackageCustom Package (Eszközök >importálása egyéni csomag>) menüvel.
A megjelenő Unity-csomag importálása mezőben mindent kiválaszthat a Plugin>Storage területen. Törölje a jelölést minden másból, mivel ehhez a kurzushoz nincs szükség.
Kattintson az Importálás gombra az elemek projekthez való hozzáadásához.
Nyissa meg a Storage mappát a Beépülő modulok területen, a Project nézetben, és csak a következő beépülő modulokat válassza:
- Microsoft.Data.Edm
- Microsoft.Data.OData
- Microsoft.WindowsAzure.Storage
- Newtonsoft.Json
- System.Spatial
Ha az adott beépülő modulok vannak kiválasztva, törölje a jeleta Bármely platform jelölőnégyzetből, és törölje aWSAPlayer jelölését, majd kattintson az Alkalmaz gombra.

Megjegyzés

Ezeket a beépülő modulokat úgy jelöljük meg, hogy csak a Unity-szerkesztőben használhatók legyenek. Ennek az az oka, hogy ugyanazoknak a beépülő moduloknak különböző verziói vannak a WSA mappában, amelyeket a projekt Unityből való exportálása után fognak használni.
A Storage beépülő modul mappájában válassza a csak a következőt:
- Microsoft.Data.Services.Client
Jelölje be a Folyamat mellőzése jelölőnégyzetet a Platformbeállítások területen, és kattintson az Alkalmaz gombra.

Megjegyzés

Ezt a beépülő modult "Ne dolgozza fel" megjelöléssel jelöljük meg, mert a Unity szerelvényjavítója nehezen dolgozza fel ezt a beépülő modult. A beépülő modul akkor is működik, ha nem dolgozzák fel.

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

Az első létrehozandó osztály az AzureServices osztály.

Az AzureServices osztály feladata:

Azure-fiók hitelesítő adatainak tárolása.
Hívja meg a Azure-alkalmazás függvényt.
Az adatfájl feltöltése és letöltése az Azure Cloud Storage-ban.

Az osztály létrehozása:

Kattintson a jobb gombbal az Eszköz mappára, amely a Projekt panel Mappa létrehozása> elemében található. Nevezze el a szkriptek mappát.
Kattintson duplán az imént létrehozott mappára a megnyitásához.
Kattintson a jobb gombbal a mappába, és hozza létre> aC# szkriptet. Hívja meg az AzureServices szkriptet.
Kattintson duplán az új AzureServices osztályra a Visual Studióval való megnyitásához.

Adja hozzá a következő névtereket az AzureServices tetejére:

    using System;
    using System.Threading.Tasks;
    using UnityEngine;
    using Microsoft.WindowsAzure.Storage;
    using Microsoft.WindowsAzure.Storage.File;
    using System.IO;
    using System.Net;

Adja hozzá a következő Inspector-mezőket az AzureServices osztályon belül:

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

Ezután adja hozzá a következő tagváltozókat az AzureServices osztályban:

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

Győződjön meg arról, hogy a végpontot és kapcsolati karakterlánc értékeket az Azure Portalon található Azure Storage-beli értékekre cseréli.

Az Awake() és a Start() metódusok kódját most már hozzá kell adni. Ezek a metódusok a osztály inicializálásakor lesznek meghívva:

    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.

Törölje az Update() metódust, mivel ez az osztály nem fogja használni.
Mentse a módosításokat a Visual Studióban, majd térjen vissza a Unitybe.
Kattintson és húzza az AzureServices osztályt a Szkriptek mappából a Hierarchia panel Fő kamerája objektumába.
Válassza ki a Fő kamerát, majd a GazeButton objektum alól húzza ki az AzureStatusText gyermekobjektumot, és helyezze az AzureStatusText referencia célmezőbe az Inspector mezőben az AzureServices-szkriptre mutató hivatkozás megadásához.

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

A következő létrehozandó szkript a ShapeFactory osztály. Ennek az osztálynak az a feladata, hogy igény szerint hozzon létre egy új alakzatot, és megőrizze az alakzatelőzmény-listában létrehozott alakzatok előzményeit. Minden alkalommal, amikor létrehoz egy alakzatot, az Alakzatelőzmények lista frissül az AzureService osztályban, majd az Azure Storage-ban lesz tárolva. Amikor az alkalmazás elindul, ha egy tárolt fájl található az Azure Storage-ban, a rendszer lekéri és visszajátssza az Alakzatelőzmények listát a 3D Text objektummal, amely megadja, hogy a létrehozott alakzat tárolóból származik-e, vagy új.

Az osztály létrehozása:

Nyissa meg a korábban létrehozott Szkriptek mappát.
Kattintson a jobb gombbal a mappába, és hozza létre> aC# szkriptet. Hívja meg a ShapeFactory szkriptet.
Kattintson duplán az új ShapeFactory szkriptre a Visual Studióval való megnyitásához.
Győződjön meg arról, hogy a ShapeFactory osztály a következő névtereket tartalmazza:
```
    using System.Collections.Generic;
    using UnityEngine;
```

Adja hozzá az alább látható változókat a ShapeFactory osztályhoz, és cserélje le a Start() és az Awake() függvényt az alábbira:

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

A CreateShape() metódus a megadott egész szám paraméter alapján hozza létre a primitív alakzatokat. A logikai paraméter használatával megadhatja, hogy az aktuálisan létrehozott alakzat tárolóból vagy újból származik-e. 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);
        }
    }

Mielőtt visszatér a Unitybe, mentse a módosításokat a Visual Studióban.
A Unity-szerkesztőben kattintson és húzza a ShapeFactory osztályt a Szkriptek mappából a Hierarchia panelFő kamerája objektumába.
Ha a Fő kamera van kiválasztva, láthatja, hogy a ShapeFactory szkript összetevő hiányzik a Spawn Point-referenciából . A probléma megoldásához húzza a ShapeSpawnPoint objektumot a Hierarchia panelről a Ívási pont hivatkozási célhelyére.

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

Az utolsó létrehozandó szkript a Gaze osztály.

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

Az osztály létrehozása:

Nyissa meg a korábban létrehozott Szkriptek mappát.
Kattintson a jobb gombbal a Projekt panel C#-szkriptlétrehozása> elemére. Hívja meg a gaze szkriptet.
Kattintson duplán az új Gaze szkriptre a Visual Studióval való megnyitásához.
Győződjön meg arról, hogy a szkript tetején a következő névtér található:
```
    using UnityEngine;
```

Ezután adja hozzá a következő változókat a Gaze osztályban:

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

Az Awake() és a Start() metódus kódját most már hozzá kell adni.

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

Adja hozzá a következő kódot, amely kezdetben létrehoz egy kurzorobjektumot az Update() metódussal együtt, amely a Raycast metódust futtatja, valamint azt, hogy a GazeEnabled logikai értéke hol van váltógombbal:

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

Ezután adja hozzá az UpdateRaycast() metódust, amely egy Raycastot vetíti ki, é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();
                }
            }
        }
    }

Végül adja hozzá a ResetFocusedObject() metódust, amely a GazeButton objektum aktuális színét váltja ki, 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;
            }
        }
    }

Mentse a módosításokat a Visual Studióban, mielőtt visszatér a Unitybe.
Kattintson és húzza a Tekintet osztályt a Szkriptek mappából a Hierarchia panelFő kamerája objektumába.

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

A többi szkripttel most már befejezhető az AzureServices osztály. Ezt a következő módon érheti el:

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

Ez a metódus egy korábban tárolt, alakzatlistát tartalmazó fájl meglétét is ellenőrzi.

Ha a fájl megtalálható, letiltja a felhasználói tekintetet, és az alakzatok mintázatának megfelelően aktiválja az Alakzatok létrehozását az Azure Storage-fájlban tárolt módon. A felhasználó láthatja ezt, mivel a Text Mesh az alakzatok eredetétől függően "Storage" vagy "New" (Új) megjelenítést biztosít.

Ha nem található fájl, engedélyezi a Tekintetet, így a felhasználó alakzatokat hozhat létre, amikor a gazeButton objektumot nézem a jelenetben.

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

A következő kódrészlet a Start() metódusból származik; ahol a rendszer meghívja a CreateCloudIdentityAsync() metódust. Nyugodtan másolja át az aktuális Start() metódust az alábbi módon:

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

Töltse ki a CallAzureFunctionForNextShape() metódus kódját. A korábban létrehozott Azure-függvényalkalmazással fog alakzatindexet kérni. Az új alakzat beérkezése 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 fejezze be 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();
    }

Adjon hozzá egy metódust egy sztring létrehozásához az alakzatelőzmények listájában tárolt egész számok összefűzésével és az Azure Storage-fájlba való mentésével.

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

Adjon hozzá egy metódust az Azure Storage-fájlban található fájlban tárolt szöveg lekéréséhez, és deszerializálja azt egy listába.

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

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

Mentse a módosításokat a Visual Studióban, mielőtt visszatér a Unitybe.

11. fejezet – Az UWP-megoldás létrehozása

A buildelési folyamat megkezdéséhez:

Lépjen a Fájl>buildelési beállításai elemre.
Kattintson a Build (Build) gombra. A Unity elindít egy Fájlkezelő ablakot, amelyben létre kell hoznia, majd ki kell választania egy mappát az alkalmazás létrehozásához. Hozza létre ezt a mappát most, és nevezze el appnak. Ezután, ha az Alkalmazás mappa ki van jelölve, nyomja le a Mappa kiválasztása gombot.
A Unity megkezdi a projekt összeállítását az Alkalmazás mappába.
Miután a Unity befejezte az építést (ez eltarthat egy ideig), megnyit egy Fájlkezelő ablakot a build helyén (ellenőrizze a tálcát, mivel előfordulhat, hogy nem mindig jelenik meg az ablakok felett, de értesítést küld az új ablak hozzáadásáról).

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

Az alkalmazás üzembe helyezése:

Lépjen az előző fejezetben létrehozott alkalmazásmappára. Megjelenik egy fájl az alkalmazás nevével, a ".sln" kiterjesztéssel, amelyre duplán kell kattintani, hogy megnyissa a Visual Studióban.
A Megoldásplatformon válassza az x86, Helyi gép lehetőséget.
A Megoldáskonfiguráció területen válassza a Hibakeresés lehetőséget.
A Microsoft HoloLens egyszerűbb lehet a Távoli gép beállítás, hogy ne legyen a számítógéphez kötve. Azonban a következőket is el kell végeznie:
- Ismerje meg a HoloLens IP-címét , amely a Beállítások>hálózat & Internet>Wi-Fi>speciális beállításai között található; az IPv4 a használni kívánt cím.
- Győződjön meg arról, hogy a fejlesztői módbe van kapcsolva; a Beállítások>frissítési & Fejlesztőknek című témakörben> található.
Nyissa meg a Build menüt, és kattintson a Megoldás üzembe helyezése elemre az alkalmazás gépre való feltöltéséhez.
Az alkalmazásnak most meg kell jelennie a telepített alkalmazások listájában, készen áll az indításra és tesztelésre!

A kész Azure Functions és a storage-alkalmazás

Gratulálunk, olyan vegyes valósági alkalmazást készített, amely a Azure Functions és az Azure Storage-szolgáltatásokat is kihasználja. Az alkalmazás képes lesz a tárolt adatokra rajzolni, és az adatok alapján műveletet nyújtani.

végső termék -end

Soron kívüli gyakorlatok

1. gyakorlat

Hozzon létre egy második ívási pontot és rekordot, amelyből létrehozták az objektumot. Az adatfájl betöltésekor játssza vissza az eredetileg létrehozott helyről származó alakzatokat.

2. gyakorlat

Hozzon létre egy módot az alkalmazás újraindítására ahelyett, hogy minden alkalommal újra meg kellene nyitnia. A jelenetek betöltése jó kiindulópont. Ezt követően hozzon létre egy módot a tárolt lista törlésére az Azure Storage-ban, hogy könnyen visszaállítható legyen az alkalmazásból.

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

Eszköztámogatás

Előfeltételek

Előkészületek

1. fejezet – Az Azure Portal

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

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

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

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

6. fejezet – Az Azure Storage importálása a Unityhez

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

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

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

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

11. fejezet – Az UWP-megoldás létrehozása

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

A kész Azure Functions és a storage-alkalmazás

Soron kívüli gyakorlatok

1. gyakorlat

2. gyakorlat

További források