HoloLens (1. generace) a Azure 305: Funkce a úložiště

Článek
07/04/2024

Poznámka:

Kurzy Mixed Reality Academy byly navrženy s HoloLensem (1. generace) a imerzivními náhlavními soupravami hybridní reality. Proto máme pocit, že je důležité nechat tyto kurzy zavedené pro vývojáře, kteří stále hledají pokyny při vývoji těchto zařízení. Tyto kurzy nebudou aktualizovány nejnovějšími sadami nástrojů ani interakcemi používanými pro HoloLens 2. Budou zachovány, aby pokračovaly v práci na podporovaných zařízeních. Bude k dispozici nová série kurzů, které budou publikovány v budoucnu, které předvádějí, jak vyvíjet pro HoloLens 2. Toto oznámení se při publikování aktualizuje odkazem na tyto kurzy.

konečný produkt -start

V tomto kurzu se dozvíte, jak vytvářet a používat Azure Functions a ukládat data s prostředkem služby Azure Storage v rámci aplikace hybridní reality.

Azure Functions je služba Microsoftu, která vývojářům umožňuje spouštět v Azure malé části kódu "functions". To poskytuje způsob, jak delegovat práci do cloudu místo místní aplikace, což může mít mnoho výhod. Azure Functions podporuje několik vývojových jazyků, včetně jazyků C#, F#, Node.js, Java a PHP. Další informace najdete v článku o službě Azure Functions.

Azure Storage je cloudová služba Microsoftu, která vývojářům umožňuje ukládat data s pojištěním, že bude vysoce dostupná, zabezpečená, odolná, škálovatelná a redundantní. To znamená, že Microsoft bude za vás zpracovávat veškerou údržbu a kritické problémy. Další informace najdete v článku o službě Azure Storage.

Po dokončení tohoto kurzu budete mít aplikaci pro imerzivní náhlavní soupravu hybridní reality, která bude schopná provést následující akce:

Umožňuje uživateli upřet pohled na scénu.
Aktivujte vytváření objektů, když uživatel upřel pohled na 3D tlačítko.
Vytvářené objekty budou zvoleny funkcí Azure Functions.
Při vytvoření každého objektu aplikace uloží typ objektu do souboru Azure umístěného ve službě Azure Storage.
Při druhém načtení se načtou data azure File a použijí se k přehrání akcí vytváření z předchozí instance aplikace.

V aplikaci je na vás, jak integrovat výsledky s návrhem. Tento kurz je navržený tak, aby vás naučil, jak integrovat službu Azure s projektem Unity. Vaším úkolem je využít znalosti získané z tohoto kurzu k vylepšení aplikace hybridní reality.

Podpora zařízení

Kurz	HoloLens	Imerzivní náhlavní soupravy
MR a Azure 305: Funkce a úložiště	✔️	✔️

Poznámka:

I když se tento kurz primárně zaměřuje na imerzivní náhlavní soupravy Windows Mixed Reality (VR), můžete také použít to, co se v tomto kurzu naučíte, na Microsoft HoloLens. Při sledování kurzu uvidíte poznámky o všech změnách, které možná budete potřebovat k podpoře HoloLensu.

Požadavky

Poznámka:

Tento kurz je určený pro vývojáře, kteří mají základní zkušenosti s Unity a C#. Mějte také na paměti, že požadavky a písemné pokyny v tomto dokumentu představují to, co bylo otestováno a ověřeno v době psaní (květen 2018). Můžete používat nejnovější software, jak je uvedeno v článku o instalaci nástrojů , i když by se nemělo předpokládat, že informace v tomto kurzu budou dokonale odpovídat tomu, co najdete v novějším softwaru, než je uvedeno níže.

Pro tento kurz doporučujeme následující hardware a software:

Vývojový počítač kompatibilní s Windows Mixed Reality pro vývoj imerzivních náhlavních souprav (VR)
Windows 10 Fall Creators Update (nebo novější) s povoleným režimem vývojáře
Nejnovější sada Windows 10 SDK
Unity 2017.4
Visual Studio 2017
Imerzivní náhlavní souprava Windows Mixed Reality (VR) nebo Microsoft HoloLens s povoleným režimem vývojáře
Předplatné účtu Azure pro vytváření prostředků Azure
Přístup k internetu pro nastavení Azure a načítání dat

Než začnete

Abyste se vyhnuli problémům při sestavování tohoto projektu, důrazně doporučujeme vytvořit projekt uvedený v tomto kurzu v kořenové nebo téměř kořenové složce (dlouhé cesty ke složkám můžou způsobovat problémy v době sestavení).

Kapitola 1 – Azure Portal

Pokud chcete použít službu Azure Storage, budete muset vytvořit a nakonfigurovat účet úložiště na webu Azure Portal.

Přihlaste se k webu Azure Portal.

Poznámka:

Pokud ještě nemáte účet Azure, budete ho muset vytvořit. Pokud tento kurz sledujete v situaci v učebně nebo testovacím prostředí, požádejte svého instruktora nebo některého z proktorů, aby vám pomohli nastavit nový účet.
Po přihlášení klikněte v levém horním rohu na Nový a vyhledejte účet úložiště a klikněte na Enter.

Poznámka:

Slovo Nový mohlo být nahrazeno vytvořením prostředku na novějších portálech.
Na nové stránce se zobrazí popis služby účtu Azure Storage. V levém dolním rohu této výzvy vyberte tlačítko Vytvořit a vytvořte přidružení k této službě.
Po kliknutí na Vytvořit:
1. Vložte název svého účtu, mějte na paměti, že toto pole přijímá jenom číslice a malá písmena.
2. Jako model nasazení vyberte Resource Manager.
3. Jako druh účtu vyberte Úložiště (pro obecné účely v1).
4. Určete umístění vaší skupiny prostředků (pokud vytváříte novou skupinu prostředků). Umístění by ideálně bylo v oblasti, ve které by aplikace běžela. Některé prostředky Azure jsou dostupné jenom v určitých oblastech.
5. Pro replikaci vyberte geograficky redundantní úložiště jen pro čtení (RA-GRS).
6. Výkon – vyberte Standard.
7. Zabezpečený přenos ponechte jako zakázaný.
8. Vyberte nějaké předplatné.
9. Zvolte skupinu prostředků nebo vytvořte novou. Skupina prostředků poskytuje způsob, jak monitorovat, řídit přístup, zřizovat a spravovat fakturaci pro kolekci prostředků Azure. Doporučujeme zachovat všechny služby Azure přidružené k jednomu projektu (například k těmto testovacím prostředím) v rámci společné skupiny prostředků).
  
  Pokud si chcete přečíst další informace o skupinách prostředků Azure, navštivte prosím článek o skupině prostředků.
10. Budete také muset potvrdit, že jste porozuměli podmínkám a ujednáním použitým pro tuto službu.
11. Vyberte Vytvořit.
Jakmile kliknete na Vytvořit, budete muset počkat, až se služba vytvoří, může to chvíli trvat.
Po vytvoření instance služby se na portálu zobrazí oznámení.
Kliknutím na oznámení můžete prozkoumat novou instanci služby.
Kliknutím na tlačítko Přejít k prostředku v oznámení můžete prozkoumat novou instanci služby. Budete přesměrováni na novou instanci služby účtu úložiště.
Kliknutím na Přístupové klíče zobrazíte koncové body pro tuto cloudovou službu. K pozdějšímu použití použijte Poznámkový blok nebo podobný klíč. Poznamenejte si také hodnotu připojovacího řetězce , protože se použije ve třídě AzureServices , kterou vytvoříte později.

Kapitola 2 – Nastavení funkce Azure Functions

Teď napíšete funkci Azure Functions ve službě Azure.

Pomocí funkce Azure Functions můžete dělat téměř cokoli, co byste udělali s klasickou funkcí v kódu. Rozdíl je v tom, že k této funkci může přistupovat libovolná aplikace, která má přihlašovací údaje pro přístup k vašemu účtu Azure.

Vytvoření funkce Azure Functions:

Na webu Azure Portal klikněte v levém horním rohu na Nový a vyhledejte aplikaci Funkcí a klikněte na Enter.

Poznámka:

Slovo Nový mohlo být nahrazeno vytvořením prostředku na novějších portálech.
Na nové stránce se zobrazí popis služby Azure Function App Service. V levém dolním rohu této výzvy vyberte tlačítko Vytvořit a vytvořte přidružení k této službě.
Po kliknutí na Vytvořit:
1. Zadejte název aplikace. Tady se dají použít jenom písmena a číslice (jsou povolená velká nebo malá písmena).
2. Vyberte upřednostňované předplatné.
3. Zvolte skupinu prostředků nebo vytvořte novou. Skupina prostředků poskytuje způsob, jak monitorovat, řídit přístup, zřizovat a spravovat fakturaci pro kolekci prostředků Azure. Doporučujeme zachovat všechny služby Azure přidružené k jednomu projektu (například k těmto testovacím prostředím) v rámci společné skupiny prostředků).
  
  Pokud si chcete přečíst další informace o skupinách prostředků Azure, navštivte prosím článek o skupině prostředků.
4. V tomto cvičení vyberte jako zvolený operační systém Windows.
5. Vyberte Plán Consumption pro plán hostování.
6. Určete umístění vaší skupiny prostředků (pokud vytváříte novou skupinu prostředků). Umístění by ideálně bylo v oblasti, ve které by aplikace běžela. Některé prostředky Azure jsou dostupné jenom v určitých oblastech. Pokud chcete dosáhnout optimálního výkonu, vyberte stejnou oblast jako účet úložiště.
7. V části Úložiště vyberte Použít existující a potom v rozevírací nabídce vyhledejte dříve vytvořené úložiště.
8. Pro účely tohoto cvičení nechte Application Insights vypnuté.
Klikněte na tlačítko Vytvořit.
Jakmile kliknete na Vytvořit, budete muset počkat, až se služba vytvoří, může to chvíli trvat.
Po vytvoření instance služby se na portálu zobrazí oznámení.
Kliknutím na oznámení můžete prozkoumat novou instanci služby.
Kliknutím na tlačítko Přejít k prostředku v oznámení můžete prozkoumat novou instanci služby. Přejdete do nové instance služby Function App Service.
Na řídicím panelu aplikace funkcí najeďte myší na functions, najděte na panelu vlevo a potom klikněte na symbol + (plus).
Na další stránce se ujistěte, že je vybraná možnost Webhook + API , a pro výběr jazyka vyberte CSharp, protože se jedná o jazyk používaný pro tento kurz. Nakonec klikněte na tlačítko Vytvořit tuto funkci .
Měli byste být přesměrováni na znakovou stránku (run.csx), pokud ne, klikněte na nově vytvořenou funkci v seznamu Funkcí v panelu vlevo.

Zkopírujte do své funkce následující kód. Tato funkce jednoduše vrátí náhodné celé číslo mezi 0 a 2 při zavolání. Nedělejte si starosti s existujícím kódem a vložte ho do horní části.

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

Zvolte Uložit.
Výsledek by měl vypadat jako na následujícím obrázku.
Klikněte na Získat adresu URL funkce a poznamenejte si zobrazený koncový bod . Budete ho muset vložit do třídy AzureServices , kterou vytvoříte později v tomto kurzu.

Kapitola 3 – Nastavení projektu Unity

Následuje typická sada pro vývoj s hybridní realitou a jako taková je vhodná šablona pro jiné projekty.

Nastavte a otestujte imerzivní náhlavní soupravu hybridní reality.

Poznámka:

Pro tento kurz nebudete vyžadovat ovladače pohybu. Pokud potřebujete podporu pro nastavení imerzivní náhlavní soupravy, navštivte článek o nastavení hybridní reality.

Otevřete Unity a klikněte na Nový.
Teď budete muset zadat název projektu Unity. Vložit MR_Azure_Functions Ujistěte se, že je typ projektu nastavený na 3D. Nastavte umístění na místo, které je pro vás vhodné (nezapomeňte, že blíže ke kořenovým adresářům je lepší). Potom klikněte na Vytvořit projekt.
Při otevření Unity stojí za to zkontrolovat, jestli je výchozí editor skriptů nastavený na Visual Studio. Přejděte na Upravit>předvolby a pak v novém okně přejděte na Externí nástroje. Změňte editor externích skriptů na Visual Studio 2017. Zavřete okno Předvolby.
Dále přejděte do Nastavení sestavení souborů>a přepněte platformu na Univerzální platforma Windows kliknutím na tlačítko Přepnout platformu.
Přejděte do nastavení sestavení souborů>a ujistěte se, že:
1. Cílové zařízení je nastavené na libovolné zařízení.
  
  Pro Microsoft HoloLens nastavte cílové zařízení na HoloLens.
2. Typ sestavení je nastavený na D3D.
3. Sada SDK je nastavená na nejnovější nainstalovanou verzi.
4. Verze sady Visual Studio je nastavená na nejnovější nainstalovanou verzi.
5. Sestavení a spuštění je nastavené na místní počítač.
6. Uložte scénu a přidejte ji do sestavení.
  1. Uděláte to tak, že vyberete Přidat otevřené scény. Zobrazí se okno pro uložení.
  2. Vytvořte novou složku pro tuto a jakoukoli budoucí scénu a pak vyberte tlačítko Nová složka a vytvořte novou složku, pojmenujte ji Scény.
  3. Otevřete nově vytvořenou složku Scény a pak v názvu souboru: textové pole, zadejte FunctionsScene a stiskněte Uložit.
Zbývající nastavení v nastavení sestavení by teď měla zůstat ve výchozím nastavení.
V okně Nastavení sestavení klikněte na tlačítko Nastavení přehrávače, otevře se související panel v prostoru, kde se nachází inspektor.
Na tomto panelu je potřeba ověřit několik nastavení:
1. Na kartě Další nastavení:
  1. Skriptovací verze modulu runtime by měla být experimentální (ekvivalent .NET 4.6), která aktivuje nutnost restartování editoru.
  2. Back-end skriptování by měl být .NET.
  3. Úroveň kompatibility rozhraní API by měla být .NET 4.6
2. Na kartě Nastavení publikování v části Možnosti zaškrtněte:
  - InternetClient
3. Dále na panelu v nastavení XR (najdete pod nastavením publikování) zaškrtněte možnost Podpora virtuální reality a ujistěte se, že je přidaná sada SDK pro Windows Mixed Reality .
Zpět v projektech Unity Nastavení sestavení v jazyce C# se už nezobrazuje šedě. Zaškrtněte políčko vedle tohoto příkazu.
Zavřete okno Nastavení sestavení.
Uložte scénu a projekt (FILE SAVE SCENE / FILE>>SAVE PROJECT).

Kapitola 4 - Nastavení hlavní kamery

Důležité

Pokud chcete přeskočit komponenty Nastavení Unity v tomto kurzu a pokračovat přímo do kódu, můžete si stáhnout tento balíček .unitypackage a importovat ho do projektu jako vlastní balíček. Bude obsahovat také knihovny DLL z další kapitoly. Po importu pokračujte z kapitoly 7.

Na panelu hierarchie najdete objekt s názvem Hlavní kamera, tento objekt představuje váš "hlavní" pohled, jakmile budete "uvnitř" aplikace.
Na řídicím panelu Unity před vámi vyberte hlavní objekt GameObject fotoaparátu. Všimněte si, že panel inspektoru (obvykle se nachází vpravo, v řídicím panelu) zobrazí různé komponenty objektu GameObject s transformací v horní části, následovanou kamerou a některými dalšími komponentami. Budete muset resetovat transformaci hlavní kamery, aby byla správně umístěna.
Uděláte to tak, že vyberete ikonu ozubeného kola vedle komponenty Transformace fotoaparátu a vyberete Obnovit.
Potom aktualizujte komponentu Transform tak, aby vypadala takto:

Transformace – pozice

X	Y	Z
0	1	0

Transformace – otočení

X	Y	Z
0	0	0

Transformace – škálování

X	Y	Z
1	1	1

nastavení transformace fotoaparátu

Kapitola 5 – Nastavení scény Unity

Klikněte pravým tlačítkem myši do prázdné oblasti panelu hierarchie v části 3D Objekt přidat rovinu.
Při vybraném objektu Rovina změňte na panelu inspektoru následující parametry:

Transformace – pozice

X	Y	Z
0	0	4

Transformace – škálování

X	Y	Z
10	1	10

nastavení polohy a měřítka roviny

zobrazení scény roviny

Klikněte pravým tlačítkem myši do prázdné oblasti panelu hierarchie v části 3D Objekt a přidejte datovou krychli.
1. Přejmenujte datovou krychli na GazeButton (s vybranou datovou krychlí stiskněte klávesu F2).
2. Změňte následující parametry pro pozici transformace na panelu inspektoru:
  
  X Y Z
  
  0 3 5
3. Klikněte na rozevírací tlačítko Značka a kliknutím na Přidat značku otevřete podokno Značky a vrstvy.
4. Vyberte tlačítko + (plus) a v poli Nový název značky zadejte GazeButton a stiskněte Uložit.
5. Klikněte na objekt GazeButton na panelu hierarchie a na panelu inspektoru přiřaďte nově vytvořenou značku GazeButton.
Klikněte pravým tlačítkem myši na objekt GazeButton v panelu hierarchie a přidejte prázdný objekt GameObject (který se přidá jako podřízený objekt).
Vyberte nový objekt a přejmenujte ho ShapeSpawnPoint.
1. Změňte následující parametry pro pozici transformace na panelu inspektoru:
  
  X Y Z
  
  0 -1 0
Dále vytvoříte objekt 3D Text , který poskytne zpětnou vazbu ke stavu služby Azure.

Klikněte pravým tlačítkem myši na GazeButton na panelu hierarchie znovu a přidejte 3D objekt>3D text jako podřízený objekt.
Přejmenujte objekt 3D Text na AzureStatusText.
Změňte pozici transformace objektu AzureStatusText následujícím způsobem:

X Y Z

0 0 -0.6
Změňte měřítko transformace objektu AzureStatusText následujícím způsobem: | X | Y | Z | |:---: | :---: | :---: | | 0,1 | 0,1 | 0,1 | 0,1 | 0,1 |

Poznámka:

Nedělejte si starosti, pokud se zdá, že je mimo střed, protože to bude opraveno při aktualizaci níže uvedené součásti Text Mesh.
Změňte komponentu Text Mesh tak, aby odpovídala následujícímu:

Tip

Vybraná barva je hexní barva: 000000FF, i když si můžete vybrat vlastní, jen se ujistěte, že je čitelná.
Struktura panelu hierarchie by teď měla vypadat takto:
Vaše scéna by teď měla vypadat takto:

X	Y	Z
0	3	5

X	Y	Z
0	-1	0

X	Y	Z
0	0	-0.6

Kapitola 6 – Import služby Azure Storage pro Unity

Budete používat Službu Azure Storage pro Unity (která sama využívá sadu .Net SDK pro Azure). Další informace najdete v článku o Službě Azure Storage for Unity.

V Unity je v současné době známý problém, který vyžaduje, aby se po importu překonfigurovaly moduly plug-in. Tyto kroky (4 až 7 v této části) se už po vyřešení chyby nevyžadují.

Pokud chcete sadu SDK importovat do vlastního projektu, ujistěte se, že jste si stáhli nejnovější balíček .unitypackage z GitHubu. Pak proveďte tyto akce:

Přidejte soubor .unitypackage do Unity pomocí možnosti nabídky Vlastní balíček>importu prostředků.>
V okně Importovat balíček Unity, které se zobrazí, můžete vybrat vše v části Úložiště modulů plug-in>. Zrušte zaškrtnutí všech ostatních polí, protože pro tento kurz není potřeba.
Kliknutím na tlačítko Importovat přidáte položky do projektu.
Přejděte do složky Úložiště v části Moduly plug-in v zobrazení Projektu a vyberte pouze následující moduly plug-in:
- Microsoft.Data.Edm
- Microsoft.Data.OData
- Microsoft.WindowsAzure.Storage
- Newtonsoft.Json
- System.Spatial
Pokud jsou vybrány tyto konkrétní moduly plug-in, zrušte zaškrtnutí políčka Libovolná platforma a zrušte zaškrtnutí políčka WSAPlayer a klepněte na tlačítko Použít.

Poznámka:

Tyto konkrétní moduly plug-in označujeme, aby se používaly jenom v Unity Editoru. Důvodem je to, že ve složce WSA existují různé verze stejných modulů plug-in, které se po exportu projektu z Unity použijí.
Ve složce modulu plug-in Storage vyberte pouze:
- Microsoft.Data.Services.Client
Zaškrtněte políčko Nezpracovávejte v části Nastavení platformy a klikněte na Použít.

Poznámka:

Tento modul plug-in označujeme jako "Nezpracovávejte", protože patcher sestavení Unity má potíže se zpracováním tohoto modulu plug-in. Modul plug-in bude i nadále fungovat, i když se nezpracuje.

Kapitola 7 – Vytvoření třídy AzureServices

První třídou, kterou vytvoříte, je třída AzureServices .

Třída AzureServices bude zodpovědná za:

Ukládání přihlašovacích údajů účtu Azure
Volání funkce Aplikace Azure
Nahrání a stažení datového souboru ve službě Azure Cloud Storage

Vytvoření této třídy:

Klikněte pravým tlačítkem myši do složky Asset, která se nachází na panelu projektu, vytvořit>složku. Pojmenujte složky Skripty.
Poklikáním na právě vytvořenou složku otevřete.
Klikněte pravým tlačítkem do složky a vytvořte>skript jazyka C#. Zavolejte skript AzureServices.
Poklikáním otevřete novou třídu AzureServices pomocí sady Visual Studio.

Do horní části služby AzureServices přidejte následující obory názvů:

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

Do třídy AzureServices přidejte následující pole inspektoru:

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

Pak do třídy AzureServices přidejte následující členské proměnné:

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

Důležité

Ujistěte se, že nahradíte koncový bod a připojovací řetězec hodnoty hodnotami z úložiště Azure, které najdete na webu Azure Portal.

Teď je potřeba přidat kód pro metody Awake() a Start(). Tyto metody budou volány při inicializaci třídy:

    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()
    {

    }

Důležité

V budoucí kapitole vyplníme kód pro CallAzureFunctionForNextShape().

Odstraňte metodu Update(), protože tato třída ji nebude používat.
Uložte změny v sadě Visual Studio a vraťte se do Unity.
Klikněte a přetáhněte třídu AzureServices ze složky Scripts do objektu Hlavní kamera na panelu hierarchie.
Vyberte hlavní kameru a potom chyťte podřízený objekt AzureStatusText pod objekt GazeButton a umístěte ho do cílového pole odkazu AzureStatusText v inspektoru, abyste mohli poskytnout odkaz na skript AzureServices.

Kapitola 8 – Vytvoření třídy ShapeFactory

Dalším skriptem , který chcete vytvořit, je Třída ShapeFactory . Role této třídy spočívá v vytvoření nového obrazce při vyžádání a zachování historie obrazců vytvořených v seznamu historie obrazců. Při každém vytvoření obrazce se seznam Historie obrazců aktualizuje ve třídě AzureService a uloží se do služby Azure Storage. Když se aplikace spustí, pokud se ve službě Azure Storage nachází uložený soubor, načte se a přehraje se seznam Historie obrazců s objektem 3D Text , který poskytuje, jestli je vygenerovaný obrazec z úložiště nebo nový.

Vytvoření této třídy:

Přejděte do složky Scripts , kterou jste vytvořili dříve.
Klikněte pravým tlačítkem do složky a vytvořte>skript jazyka C#. Volání skriptu ShapeFactory
Poklikáním otevřete nový skript ShapeFactory v sadě Visual Studio.
Ujistěte se, že třída ShapeFactory obsahuje následující obory názvů:
```
    using System.Collections.Generic;
    using UnityEngine;
```

Přidejte proměnné uvedené níže do třídy ShapeFactory a nahraďte funkce Start() a Awake() následujícími funkcemi:

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

Metoda CreateShape() generuje primitivní obrazce na základě zadaného celočíselného parametru. Logický parametr slouží k určení, jestli je aktuálně vytvořený obrazec z úložiště nebo nový. Do třídy ShapeFactory umístěte následující kód pod předchozí metody:

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

Než se vrátíte do Unity, nezapomeňte změny uložit v sadě Visual Studio.
Zpět v Unity Editoru klikněte a přetáhněte třídu ShapeFactory ze složky Scripts do objektu Hlavní kamera na panelu hierarchie.
Při vybrané hlavní kameře si všimnete, že komponentě skriptu ShapeFactory chybí odkaz na Spawn Point . Pokud ho chcete opravit, přetáhněte objekt ShapeSpawnPoint z panelu hierarchie do cíle odkazu na bod spawn.

Kapitola 9 – Vytvoření třídy Pohled

Posledním skriptem, který potřebujete vytvořit, je třída Gaze .

Tato třída je zodpovědná za vytvoření raycastu, který se promítne z hlavní kamery, aby zjistil, na který objekt se uživatel dívá. V tomto případě bude raycast muset identifikovat, zda uživatel dívá na objekt GazeButton ve scéně a aktivuje chování.

Vytvoření této třídy:

Přejděte do složky Scripts , kterou jste vytvořili dříve.
Klikněte pravým tlačítkem na panel projektu a vytvořte>skript jazyka C#. Zavolejte skript Pohled.
Poklikáním na nový skript Gaze ho otevřete v sadě Visual Studio.
Ujistěte se, že v horní části skriptu je uvedený následující obor názvů:
```
    using UnityEngine;
```

Pak do třídy Gaze přidejte následující proměnné:

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

Důležité

Některé z těchto proměnných budou možné upravovat v Editoru.

Kód pro metody Awake() a Start() je teď potřeba přidat.

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

Přidejte následující kód, který vytvoří objekt kurzoru na začátku spolu s Update(), která spustí Metodu Raycast spolu s umístěním, kde je přepínací logická hodnota GazeEnabled:

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

Dále přidejte metodu UpdateRaycast(), která promítne Raycast a zjistí cíl hitu.

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

Nakonec přidejte metodu ResetFocusedObject(), která přepíná aktuální barvu objekty GazeButton, což označuje, zda vytváří nový obrazec, nebo ne.

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

Před návratem do Unity uložte změny v sadě Visual Studio.
Klikněte a přetáhněte třídu Gaze ze složky Scripts do objektu Hlavní kamera na panelu hierarchie.

Kapitola 10 – Dokončení třídy AzureServices

S ostatními skripty je nyní možné dokončit třídu AzureServices . Toho dosáhnete takto:

Přidání nové metody s názvem CreateCloudIdentityAsync() pro nastavení ověřovacích proměnných potřebných pro komunikaci s Azure

Tato metoda také zkontroluje existenci dříve uloženého souboru obsahujícího seznam obrazců.

Pokud se soubor najde, zakáže uživatele Gaze a aktivuje vytvoření obrazce podle vzoru obrazců, jak je uloženo v souboru Azure Storage. Uživatel to uvidí, protože textová síť bude v závislosti na původu obrazců zobrazovat "Úložiště" nebo "Nový".

Pokud nebyl nalezen žádný soubor, umožní uživateli vytvořit obrazce při pohledu na objekt GazeButton ve scéně.

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

Další fragment kódu pochází z metody Start(), kde se volání provede metodou CreateCloudIdentityAsync(). Nebojte se kopírovat přes aktuální metodu Start() s následujícím kódem:

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

Vyplňte kód metody CallAzureFunctionForNextShape(). K vyžádání indexu obrazce použijete dříve vytvořenou aplikaci Funkcí Azure. Po přijetí nového obrazce odešle tato metoda obrazec do třídy ShapeFactory a vytvoří nový obrazec ve scéně. Pomocí následujícího kódu dokončete text CallAzureFunctionForNextShape().

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

Přidejte metodu pro vytvoření řetězce zřetězením celých čísel uložených v seznamu historie obrazců a jeho uložením do souboru Azure Storage.

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

Přidejte metodu pro načtení textu uloženého v souboru azure Storage a deserializaci do seznamu.

Po dokončení tohoto procesu metoda znovu povolí pohled, aby uživatel mohl do scény přidat další obrazce.

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

Před návratem do Unity uložte změny v sadě Visual Studio.

Kapitola 11 – Sestavení řešení UPW

Zahájení procesu sestavení:

Přejděte do nastavení sestavení souboru>.
Klikněte na Sestavit. Unity spustí okno Průzkumník souborů, ve kterém potřebujete vytvořit a pak vybrat složku pro sestavení aplikace. Vytvořte teď složku a pojmenujte ji App. Pak s vybranou složkou Aplikace stiskněte vybrat složku.
Unity začne sestavovat projekt do složky Aplikace .
Po dokončení sestavování Unity (může to nějakou dobu trvat), otevře se okno Průzkumník souborů na místě sestavení (zkontrolujte hlavní panel, protože se nemusí vždy zobrazovat nad okny, ale upozorní vás na přidání nového okna).

Kapitola 12 – Nasazení aplikace

Nasazení aplikace:

Přejděte do složky Aplikace , která byla vytvořena v poslední kapitole. Zobrazí se soubor s názvem aplikace s příponou ".sln", na kterou byste měli poklikáním, abyste ho otevřeli v sadě Visual Studio.
Na platformě řešení vyberte x86, místní počítač.
V konfiguraci řešení vyberte Ladit.
U Microsoft HoloLensu může být jednodušší nastavit tento počítač na vzdálený počítač, takže nejste připojení k počítači. I když budete muset udělat toto:
- Znát IP adresu vašeho HoloLensu, který najdete v rozšířených možnostech sítě Nastavení>a Internetu>Wi-Fi>. Protokol IPv4 je adresa, kterou byste měli použít.
- Ujistěte se, že je režim vývojáře zapnutý, najdete v části Aktualizace nastavení>a zabezpečení>pro vývojáře.
Přejděte do nabídky Sestavení a kliknutím na Nasadit řešení načtěte aplikaci do počítače bokem.
Vaše aplikace by se teď měla zobrazit v seznamu nainstalovaných aplikací připravených ke spuštění a otestování.

Dokončené funkce Azure Functions a aplikace úložiště

Blahopřejeme, vytvořili jste aplikaci hybridní reality, která využívá služby Azure Functions i Azure Storage. Aplikace bude moct nakreslit uložená data a poskytnout akci založenou na datech.

konečný produkt -end

Bonusová cvičení

Cvičení 1

Vytvořte druhý bod spawnu a záznam, ze kterého se vytvořil objekt. Při načítání datového souboru přehrajte obrazce vytvořené z umístění, které byly původně vytvořeny.

Cvičení 2

Vytvořte způsob, jak aplikaci restartovat, a nemusíte ji pokaždé znovu otevírat. Načítání scén je dobrým místem, kde začít. Potom vytvořte způsob, jak vymazat uložený seznam ve službě Azure Storage, aby se dala snadno resetovat z vaší aplikace.

Sdílet prostřednictvím

HoloLens (1. generace) a Azure 305: Funkce a úložiště

Podpora zařízení

Požadavky

Než začnete

Kapitola 1 – Azure Portal

Kapitola 2 – Nastavení funkce Azure Functions

Kapitola 3 – Nastavení projektu Unity

Kapitola 4 - Nastavení hlavní kamery

Kapitola 5 – Nastavení scény Unity

Kapitola 6 – Import služby Azure Storage pro Unity

Kapitola 7 – Vytvoření třídy AzureServices

Kapitola 8 – Vytvoření třídy ShapeFactory

Kapitola 9 – Vytvoření třídy Pohled

Kapitola 10 – Dokončení třídy AzureServices

Kapitola 11 – Sestavení řešení UPW

Kapitola 12 – Nasazení aplikace

Dokončené funkce Azure Functions a aplikace úložiště

Bonusová cvičení

Cvičení 1

Cvičení 2

Další materiály