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

Článek
07/12/2023

Poznámka

Kurzy Mixed Reality Academy byly navrženy s ohledem na HoloLens (1. generace) a Mixed Reality Asistivní náhlavní soupravy. Proto se domníváme, že je důležité ponechat tyto kurzy pro vývojáře, kteří stále hledají pokyny při vývoji pro tato zařízení. Tyto kurzy nebudou aktualizovány nejnovějšími sadami nástrojů nebo interakcemi používanými pro HoloLens 2. Budou zachovány, aby mohly pokračovat v práci na podporovaných zařízeních. V budoucnu bude k dispozici nová série kurzů, které předvedou vývoj pro HoloLens 2. Toto oznámení bude aktualizováno odkazem na tyto kurzy, jakmile budou zveřejněny.

final product -start

V tomto kurzu se naučíte vytvářet a používat Azure Functions a ukládat data pomocí prostředku Azure Storage v aplikaci 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, nikoli místní aplikaci, 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 Azure Functions.

Azure Storage je cloudová služba Microsoftu, která vývojářům umožňuje ukládat data s pojištěním, že budou vysoce dostupná, zabezpečená, odolná, škálovatelná a redundantní. To znamená, že Microsoft za vás vyřeší 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 imerzivní aplikaci pro imerzivní náhlavní soupravu pro hybridní realitu, která bude umět následující:

Umožněte uživateli upřený pohled na scénu.
Aktivace vytváření objektů, když se uživatel podívá na 3D tlačítko.
Vytvářené objekty zvolí funkce Azure Functions.
Při vytvoření každého objektu uloží aplikace typ objektu do souboru Azure, který se nachází 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.

Ve vaší aplikaci je na vás, jak integrujete výsledky s vaším návrhem. Tento kurz je navržený tak, aby vás naučil integrovat službu Azure s projektem Unity. Je vaším úkolem využít znalosti, které z tohoto kurzu získáte, k vylepšení aplikace pro hybridní realitu.

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 zaměřuje primárně na Windows Mixed Reality imerzivní náhlavní soupravy (VR), můžete také využít to, co se v tomto kurzu naučíte, k Microsoft HoloLens. V průběhu kurzu uvidíte poznámky ke všem změnám, které budete muset použít pro podporu 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 testováno a ověřeno v době psaní tohoto dokumentu (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 vývojářským režimem
Nejnovější Windows 10 SDK
Unity 2017.4
Visual Studio 2017
Windows Mixed Reality imerzivní náhlavní souprava nebo Microsoft HoloLens s povoleným režimem Vývojář
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

Aby nedocházelo k 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ůsobit problémy při sestavování).

Kapitola 1 – Azure Portal

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

Přihlaste se k webu Azure Portal.

Poznámka

Pokud ještě nemáte účet Azure, budete si ho muset vytvořit. Pokud tento kurz sledujete v situaci ve třídě nebo testovacím prostředí, požádejte o pomoc s nastavením nového účtu svého instruktora nebo některého z specialistů.
Po přihlášení klikněte v levém horním rohu na Nový , vyhledejte Účet úložiště a klikněte na Enter.

Poznámka

Na novějších portálech mohlo být slovo Nový nahrazeno slovem Vytvořit prostředek.
Na nové stránce najdete 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 účtu. Mějte na paměti, že do tohoto pole se dají použít jenom čísla a malá písmena.
2. V části Model nasazení vyberte Resource Manager.
3. V části Druh účtu vyberte Úložiště (obecné účely v1).
4. Určete umístění vaší skupiny prostředků (pokud vytváříte novou skupinu prostředků). Umístění by v ideálním případě bylo v oblasti, ve které by se aplikace spustila. Některé prostředky Azure jsou dostupné jenom v určitých oblastech.
5. V části Replikace vyberte Úložiště jen pro čtení a geograficky redundantní úložiště (RA-GRS).
6. Výkon – vyberte Standard.
7. Vyžadovat zabezpečený přenos ponechte na zakázaném.
8. Vyberte 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 kolekce prostředků Azure. Doporučujeme ponechat všechny služby Azure přidružené k jednomu projektu (např. tato testovací prostředí) ve společné skupině prostředků.
  
  Pokud si chcete přečíst další informace o skupinách prostředků Azure, přečtěte si článek o skupinách prostředků.
10. Budete také muset potvrdit, že rozumíte podmínkám a ujednáním, které se na tuto službu vztahují.
11. Vyberte Vytvořit.
Po kliknutí na Vytvořit budete muset počkat na vytvoření služby, což může chvíli trvat.
Po vytvoření instance služby se na portálu zobrazí oznámení.
Klikněte na oznámení a prozkoumejte novou instanci služby.
V oznámení klikněte na tlačítko Přejít k prostředku a prozkoumejte 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 zobrazte koncové body pro tuto cloudovou službu. Pomocí Poznámkového bloku nebo podobného zkopírujte jeden ze svých klíčů pro pozdější použití. Všimněte si také hodnoty Připojovací řetězec , protože se použije ve třídě AzureServices , kterou vytvoříte později.

Kapitola 2 – Nastavení funkce Azure Functions

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

Funkci Azure Functions můžete použít k provádění téměř čehokoli, co byste dělali s klasickou funkcí v kódu. Rozdíl je v tom, že k této funkci má přístup jakákoli 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ý , vyhledejte Function App a klikněte na Enter.

Poznámka

Na novějších portálech mohlo být slovo Nový nahrazeno slovem Vytvořit prostředek.
Na nové stránce najdete popis služby Azure Function App . 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. V tomto případě je možné použít pouze 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 kolekce prostředků Azure. Doporučujeme ponechat všechny služby Azure přidružené k jednomu projektu (např. tato testovací prostředí) ve společné skupině prostředků.
  
  Pokud si chcete přečíst další informace o skupinách prostředků Azure, přečtěte si článek o skupinách prostředků.
4. Pro účely tohoto cvičení vyberte windows jako zvolený operační systém.
5. Jako plán hostování vyberte Plán Consumption.
6. Určete umístění vaší skupiny prostředků (pokud vytváříte novou skupinu prostředků). Umístění by v ideálním případě bylo v oblasti, ve které by se aplikace spustila. Některé prostředky Azure jsou dostupné jenom v určitých oblastech. Pro optimální výkon vyberte stejnou oblast jako účet úložiště.
7. V části Úložiště vyberte Použít existující a pak v rozevírací nabídce vyhledejte dříve vytvořené úložiště.
8. Pro toto cvičení nechte Application Insights vypnuté.
Klikněte na tlačítko Vytvořit.
Po kliknutí na Vytvořit budete muset počkat na vytvoření služby, což může chvíli trvat.
Po vytvoření instance služby se na portálu zobrazí oznámení.
Klikněte na oznámení a prozkoumejte novou instanci služby.
V oznámení klikněte na tlačítko Přejít k prostředku a prozkoumejte novou instanci služby. Budete přesměrováni do nové instance služby Function App .
Na řídicím panelu aplikace funkcí najeďte myší na Funkce, které najdete na panelu vlevo, a klikněte na symbol + (plus).
Na další stránce se ujistěte, že je vybraná možnost Webhook + API , a v části Zvolit jazyk vyberte CSharp, protože se bude používat v tomto kurzu. Nakonec klikněte na tlačítko Vytvořit tuto funkci .
Měli byste přejít na znakovou stránku (run.csx), pokud ne, klikněte na nově vytvořenou funkci v seznamu Funkce na panelu vlevo.

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

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

Vyberte 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

Toto je typické nastavení pro vývoj s Mixed Reality a jako takové je vhodná šablona pro jiné projekty.

Nastavte a otestujte imerzivní náhlavní soupravu pro hybridní realitu.

Poznámka

Pro tento kurz nebudete potřebovat ovladače pohybu. Pokud potřebujete podporu pro nastavení imerzivní náhlavní soupravy, přečtěte si č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. Umístění nastavte na místo, které je pro vás vhodné (nezapomeňte, že lepší je blíž ke kořenovým adresářům). Potom klikněte na Vytvořit projekt.
Když je Unity otevřená, stojí za to zkontrolovat, jestli je výchozí Editor skriptů nastavený na Visual Studio. Přejděte na Upravit>předvolby a 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 .
Pak přejděte naNastavení sestavenísouboru> a kliknutím na tlačítko Přepnout platformu přepněte na Univerzální platforma Windows.
Přejděte naNastavení sestavenísouboru> 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 s názvem Scény.
  3. Otevřete nově vytvořenou složku Scény , do textového pole Název souboru: zadejte FunctionsScene a stiskněte Uložit.
Zbývající nastavení v nastavení sestavení by prozatím měla zůstat ve výchozím nastavení.
V okně Build Settings (Nastavení sestavení ) klikněte na tlačítko Player Settings (Nastavení přehrávače ). Tím se otevře související panel v prostoru, kde se inspektor nachází.
Na tomto panelu je potřeba ověřit několik nastavení:
1. Na kartě Další nastavení :
  1. Skriptovací modul runtime verze by měla být experimentální (ekvivalent .NET 4.6), což aktivuje potřebu restartování editoru.
  2. Skriptovací back-end 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 Schopnosti zaškrtněte:
  - InternetClient
3. Dále na panelu v Nastavení XR (najdete pod nastavením publikování) zaškrtněte políčko Virtuální realita podporováno a ujistěte se, že je přidaná sada SDK Windows Mixed Reality.
Zpět v nastavení sestaveníProjekty Unity C# už nejsou šedě; zaškrtněte políčko vedle tohoto políčka.
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 vynechat komponenty Unity Set up v tomto kurzu a pokračovat přímo do kódu, stáhněte si tento soubor .unitypackage a naimportujte ho do projektu jako vlastní balíček. Bude obsahovat také knihovny DLL z další kapitoly. Po importu pokračujte od kapitoly 7.

Na panelu hierarchie najdete objekt s názvem Hlavní kamera, který představuje váš "hlavní" pohled, jakmile jste "uvnitř" aplikace.
S řídicím panelem Unity před vámi vyberte GameObject hlavní kamery. Všimněte si, že na panelu inspektoru (obvykle napravo na řídicím panelu) se zobrazí různé komponenty tohoto 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ěná.
Uděláte to tak, že vyberete ikonu ozubeného kola vedle komponenty Transformace kamery a vyberete Resetovat.
Potom aktualizujte komponentu Transformovat 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

nastavit transformaci kamery

Kapitola 5 – Nastavení scény Unity

Klikněte pravým tlačítkem do prázdné oblasti panelu hierarchie a v části 3D objekt přidejte rovinu.
S vybraným objektem Plane 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

nastavit polohu a měřítko roviny

zobrazení scény roviny

Klikněte pravým tlačítkem do prázdné oblasti panelu hierarchie a v části 3D objekt 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 pozice transformace na panelu inspektoru:
  
  X Y Z
  
  0 3 5
3. Kliknutím na tlačítko rozevíracího seznamu Značka a kliknutím na Přidat značku otevřete podokno Značky & vrstvy.
4. Vyberte tlačítko + (plus), do pole Název nové značky zadejte GazeButton a stiskněte Uložit.
5. Klikněte na objekt GazeButton na panelu hierarchie a v panelu inspektoru přiřaďte nově vytvořenou značku GazeButton .
Klikněte pravým tlačítkem na objekt GazeButton na panelu hierarchie a přidejte prázdný objekt GameObject (který bude přidán jako podřízený objekt).
Vyberte nový objekt a přejmenujte ho na ShapeSpawnPoint.
1. Změňte následující parametry pozice transformace na panelu inspektoru:
  
  X Y Z
  
  0 -1 0
Dále vytvoříte objekt 3D Text , který vám poskytne zpětnou vazbu ke stavu služby Azure.

Znovu klikněte pravým tlačítkem na tlačítko GazeButton na panelu hierarchie a přidejte objekt 3D Object>3D Text jako podřízený objekt.
Přejmenujte objekt 3D Text na AzureStatusText.
Změňte pozici transformaceobjektu AzureStatusText následujícím způsobem:

X Y Z

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

Poznámka

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

Tip

Vybraná barva je hexitová barva: 000000FF, i když si můžete vybrat vlastní, jen se ujistěte, že je čitelná.
Struktura hierarchických panelů 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 Azure Storage pro Unity (která sama využívá sadu .Net SDK pro Azure). Další informace najdete v článku Azure Storage pro Unity.

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

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

Přidejte soubor .unitypackage do Unity pomocí možnosti nabídkyVlastní 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 v tomto kurzu to není potřeba.
Kliknutím na tlačítko Importovat přidejte položky do projektu.
V zobrazení Projektu přejděte do složky Úložiště v části Moduly plug-in a vyberte pouze následující moduly plug-in:
- Microsoft.Data.Edm
- Microsoft.Data.OData
- Microsoft.WindowsAzure.Storage
- Newtonsoft.Json
- System.Spatial
Vyberte tyto konkrétní pluginy , zrušte zaškrtnutí jakákoliplatforma a zrušte zaškrtnutíWSAPlayer a pak klikněte na Použít.

Poznámka

Tyto konkrétní moduly plug-in označujeme tak, aby se používaly jenom v Unity Editoru. Je to proto, že ve složce WSA jsou různé verze stejných modulů plug-in, které se po exportu projektu z Unity použijí.
Ve složce modulu plug-in úložiště 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 fungovat, i když se nezpracuje.

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

První třída, 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 do složky Asset , která se nachází na panelu Projektu, Vytvořit>složku. Složku pojmenujte Scripts.
Poklikáním na právě vytvořenou složku otevřete.
Klikněte pravým tlačítkem do složky Vytvořit>skript jazyka C#. Zavolejte skript AzureServices.
Poklikáním na novou třídu AzureServices ji otevřete v sadě Visual Studio.

Na začátek 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é

Nezapomeňte nahradit hodnoty koncového bodu a připojovací řetězec 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ána 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é

Kód pro CallAzureFunctionForNextShape() vyplníme v budoucí kapitole.

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

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

Dalším skriptem, který chcete vytvořit, je třída ShapeFactory . Úlohou této třídy je vytvořit nový obrazec na vyžádání a uchovávat historii 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 pak se uloží do služby Azure Storage. Pokud se při spuštění aplikace ve službě Azure Storage najde uložený soubor, načte se a přehraje seznam Historie obrazců , přičemž objekt 3D Text určuje, jestli je vygenerovaný obrazec z úložiště, nebo z nového.

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 Vytvořit>skript jazyka C#. Zavolejte skript ShapeFactory.
Poklikáním na nový skript ShapeFactory ho otevřete 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 níže uvedené proměnné 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);
        }
    }

Před návratem do Unity nezapomeňte uložit změny v sadě Visual Studio.
Zpátky v Unity Editoru klikněte na třídu ShapeFactory a přetáhněte ji ze složky Scripts do objektu Hlavní kamera na panelu hierarchie.
Když máte vybranou hlavní kameru, všimnete si, že komponentě skriptu ShapeFactory chybí odkaz na bod tření . Pokud ho chcete opravit, přetáhněte objekt ShapeSpawnPoint z panelu hierarchie do cílového referenčního bodu vytvoření .

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

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

Tato třída je zodpovědná za vytvoření raycastu , který bude promítaný dopředu z hlavní kamery, aby zjistil, na který objekt se uživatel dívá. V takovém případě raycast bude muset identifikovat, jestli se uživatel dívá na objekt GazeButton ve scéně, a aktivovat 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 Projekt a vytvořte>skript jazyka C#. Zavolejte skript Gaze.
Poklikáním na nový skript Gaze ho otevřete v sadě Visual Studio.
Ujistěte se, že je v horní části skriptu 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 bude možné upravovat v editoru.

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

    /// <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ý na začátku vytvoří objekt kurzoru, spolu s metodou Update(), která spustí metodu Raycast, spolu s tím, kde je přepnutá 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 detekuje cíl dosažení.

    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řepne GazeButton objektů aktuální barvu, která 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 na třídu Gaze a přetáhněte ji ze složky Scripts do objektu Hlavní kamera na panelu hierarchie.

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

Když jsou ostatní skripty na místě, je teď možné dokončit třídu AzureServices . Toho dosáhnete prostřednictvím:

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, uživatel gaze zakáže a aktivuje vytvoření obrazce podle vzoru obrazců uloženého v souboru Azure Storage. Uživatel to může vidět, protože textová síť zobrazí "Úložiště" nebo "Nový" v závislosti na původu obrazců.

Pokud se nenajde žádný soubor, povolí se objekt Gaze, který uživateli umožní vytvářet 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 je z metody Start(). kde se provede volání metody CreateCloudIdentityAsync(). Nebojte se zkopírovat 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 pro metodu CallAzureFunctionForNextShape(). K vyžádání indexu obrazce použijete dříve vytvořenou aplikaci Azure Function App . Po přijetí nového obrazce odešle tato metoda obrazec do třídy ShapeFactory , aby se vytvořil 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 jejich 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 umístěném v souboru služby 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í pro UPW

Postup zahájení procesu sestavení:

Přejděte naNastavení sestavenísouboru>.
Klikněte na Sestavit. Unity spustí Průzkumník souborů okno, ve kterém musíte vytvořit a vybrat složku, do které chcete aplikaci sestavit. Vytvořte teď složku a pojmenujte ji App. Pak s vybranou složkou Aplikace stiskněte Vybrat složku.
Unity začne váš projekt vytvářet do složky Aplikace .
Jakmile Unity dokončí sestavování (může to nějakou dobu trvat), otevře se okno Průzkumník souborů v umístění 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 vaší aplikace s příponou .sln, na který byste měli poklikáním otevřít v sadě Visual Studio.
Na platformě řešení vyberte x86 , Místní počítač.
V části Konfigurace řešení vyberte Ladit.
Pro Microsoft HoloLens může být jednodušší nastavit tuto možnost na Vzdálený počítač, abyste nebyli připojení k počítači. Budete ale muset provést také následující akce:
- Zjistěte IP adresu vašeho HoloLensu, kterou najdete v rozšířenýchmožnostech nastavení >sítě & internetu>wi-fi>. IPv4 je adresa, kterou byste měli použít.
- Ujistěte se , že vývojářský režim je zapnutý. najdete v části Nastavení>Aktualizace & 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 testování.

Dokončené 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. Vaše aplikace bude moct kreslit z uložených dat a na jejich základě poskytovat akci.

final product -end

Bonusová cvičení

Cvičení 1

Vytvořte druhý bod vytvoření a poznamenejte si, ze kterého bodu vytvoření byl objekt vytvořen. Když načtete datový soubor, přehrajte obrazce vytvořené z původního umístění.

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 seznam uložených ve službě Azure Storage, aby bylo možné ho snadno resetovat z vaší aplikace.

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 Gaze

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

Kapitola 11 – Sestavení řešení pro UPW

Kapitola 12 – Nasazení aplikace

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

Bonusová cvičení

Cvičení 1

Cvičení 2

Další materiály