HoloLens (1ª geração) e Azure 305: Funções e armazenamento


Observação

Os tutoriais do Mixed Reality Academy foram projetados com o HoloLens (1ª geração) e os headsets imersivos de realidade misturada em mente. Dessa forma, achamos que é importante continuar disponibilizando esses tutoriais para os desenvolvedores que ainda buscam obter diretrizes para o desenvolvimento visando esses dispositivos. Esses tutoriais não serão atualizados com os conjuntos de ferramentas mais recentes nem com as interações usadas para o HoloLens 2. Eles serão mantidos para continuar funcionando nos dispositivos compatíveis. Haverá uma nova série de tutoriais que serão postados no futuro que demonstrarão como desenvolver para o HoloLens 2. Este aviso será atualizado com um link para esses tutoriais quando eles forem postados.


final product -start

Neste curso, você aprenderá a criar e usar Azure Functions e armazenar dados com um recurso de Armazenamento do Azure, dentro de um aplicativo de realidade misturada.

Azure Functions é um serviço da Microsoft, que permite que os desenvolvedores executem pequenas partes de código, "funções", no Azure. Isso fornece uma maneira de delegar o trabalho para a nuvem, em vez de seu aplicativo local, que pode ter muitos benefícios. Azure Functions dá suporte a várias linguagens de desenvolvimento, incluindo C#, F#, Node.js, Java e PHP. Para obter mais informações, visite o artigo Azure Functions.

O Armazenamento do Azure é um serviço de nuvem da Microsoft, que permite que os desenvolvedores armazenem dados, com o seguro de que eles estarão altamente disponíveis, seguros, duráveis, escalonáveis e redundantes. Isso significa que a Microsoft lidará com todos os problemas críticos e de manutenção para você. Para obter mais informações, visite o artigo do Armazenamento do Azure.

Após concluir este curso, você terá um aplicativo de headset imersivo de realidade misturada que poderá fazer o seguinte:

  1. Permitir que o usuário olhe em torno de uma cena.
  2. Dispare a geração de objetos quando o usuário olhar para um "botão" 3D.
  3. Os objetos gerados serão escolhidos por uma Função do Azure.
  4. À medida que cada objeto é gerado, o aplicativo armazenará o tipo de objeto em um Arquivo do Azure, localizado no Armazenamento do Azure.
  5. Ao carregar uma segunda vez, os dados do Arquivo do Azure serão recuperados e usados para reproduzir as ações de desova da instância anterior do aplicativo.

Em seu aplicativo, cabe a você integrar os resultados ao seu design. Este curso foi projetado para ensinar como integrar um Serviço do Azure ao seu Projeto do Unity. É seu trabalho usar o conhecimento obtido com este curso para aprimorar seu aplicativo de realidade misturada.

Suporte a dispositivos

Curso HoloLens Headsets imersivos
MR e Azure 305: funções e armazenamento ✔️ ✔️

Observação

Embora este curso se concentre principalmente em Windows Mixed Reality headsets imersivos (VR), você também pode aplicar o que aprender neste curso para Microsoft HoloLens. Ao acompanhar o curso, você verá anotações sobre as alterações que talvez precise empregar para dar suporte ao HoloLens.

Pré-requisitos

Observação

Este tutorial foi projetado para desenvolvedores que têm experiência básica com Unity e C#. Lembre-se também de que os pré-requisitos e as instruções escritas neste documento representam o que foi testado e verificado no momento da gravação (maio de 2018). Você é livre para usar o software mais recente, conforme listado no artigo instalar as ferramentas , embora não se supõe que as informações neste curso correspondam perfeitamente ao que você encontrará no software mais recente do que o listado abaixo.

Recomendamos o seguinte hardware e software para este curso:

Antes de começar

Para evitar problemas ao criar esse projeto, é altamente sugerido que você crie o projeto mencionado neste tutorial em uma pasta raiz ou quase raiz (caminhos de pastas longas podem causar problemas no tempo de build).

Capítulo 1 – Portal do Azure

Para usar o Serviço de Armazenamento do Azure, você precisará criar e configurar uma Conta de Armazenamento no portal do Azure.

  1. Faça logon no Portal do Azure.

    Observação

    Se você ainda não tiver uma conta do Azure, precisará criar uma. Se você estiver seguindo este tutorial em uma situação de sala de aula ou laboratório, peça ajuda ao instrutor ou a um dos supervisores para configurar sua nova conta.

  2. Depois de fazer logon, clique em Novo no canto superior esquerdo, pesquise a conta de Armazenamento e clique em Enter.

    pesquisa de armazenamento do azure

    Observação

    A palavra Novo pode ter sido substituída por Criar um recurso, em portais mais recentes.

  3. A nova página fornecerá uma descrição do serviço de conta de Armazenamento do Azure . Na parte inferior esquerda deste prompt, selecione o botão Criar , para criar uma associação com esse serviço.

    criar serviço

  4. Depois de clicar em Criar:

    1. Insira um nome para sua conta, lembre-se de que esse campo aceita apenas números e letras minúsculas.

    2. Para o modelo de implantação, selecione Gerenciador de Recursos.

    3. Para tipo de conta, selecione Armazenamento (uso geral v1).

    4. Determine a localização do grupo de recursos (se você estiver criando um novo Grupo de Recursos). O local seria idealmente na região em que o aplicativo seria executado. Alguns ativos do Azure só estão disponíveis em determinadas regiões.

    5. Para Replicação , selecione RA-GRS (armazenamento com redundância geográfica de acesso de leitura).

    6. Para Desempenho, selecione Standard.

    7. Deixe a transferência segura necessária como Desabilitada.

    8. Selecione uma Assinatura.

    9. Escolha um Grupo de Recursos ou crie um novo. Um grupo de recursos fornece uma maneira de monitorar, controlar o acesso, provisionar e gerenciar a cobrança de uma coleção de ativos do Azure. É recomendável manter todos os serviços do Azure associados a um único projeto (por exemplo, como esses laboratórios) em um grupo de recursos comum).

      Se você quiser ler mais sobre os Grupos de Recursos do Azure, visite o artigo do grupo de recursos.

    10. Você também precisará confirmar se entendeu os Termos e Condições aplicados a este Serviço.

    11. Selecione Criar.

      informações do serviço de entrada

  5. Depois de clicar em Criar, você precisará aguardar a criação do serviço, isso pode levar um minuto.

  6. Uma notificação será exibida no portal depois que a instância de Serviço for criada.

    nova notificação no portal do Azure

  7. Clique nas notificações para explorar sua nova instância de Serviço.

    ir para o recurso

  8. Clique no botão Ir para recurso na notificação para explorar sua nova instância de Serviço. Você será levado para sua nova instância de serviço de conta de armazenamento .

    chaves de acesso

  9. Clique em Chaves de Acesso para revelar os pontos de extremidade para este serviço de nuvem. Use o Bloco de Notas ou semelhante para copiar uma de suas chaves para uso posterior. Além disso, observe o valor da cadeia de conexão , pois ela será usada na classe AzureServices , que você criará posteriormente.

    copiar cadeia de conexão

Capítulo 2 – Configurando uma função do Azure

Agora você escreverá uma Função do Azure no Serviço do Azure.

Você pode usar uma Função do Azure para fazer quase tudo o que faria com uma função clássica em seu código, a diferença é que essa função pode ser acessada por qualquer aplicativo que tenha credenciais para acessar sua Conta do Azure.

Para criar uma Função do Azure:

  1. No Portal do Azure, clique em Novo no canto superior esquerdo, pesquise o Aplicativo de Funções e clique em Enter.

    criar aplicativo de funções

    Observação

    A palavra Novo pode ter sido substituída por Criar um recurso, em portais mais recentes.

  2. A nova página fornecerá uma descrição do serviço aplicativo de funções do Azure . Na parte inferior esquerda deste prompt, selecione o botão Criar , para criar uma associação com esse serviço.

    informações do aplicativo de funções

  3. Depois de clicar em Criar:

    1. Forneça um nome de aplicativo. Somente letras e números podem ser usados aqui (maiúsculas ou minúsculas são permitidas).

    2. Selecione sua assinatura preferencial.

    3. Escolha um Grupo de Recursos ou crie um novo. Um grupo de recursos fornece uma maneira de monitorar, controlar o acesso, provisionar e gerenciar a cobrança de uma coleção de ativos do Azure. É recomendável manter todos os serviços do Azure associados a um único projeto (por exemplo, como esses laboratórios) em um grupo de recursos comum).

      Se você quiser ler mais sobre os Grupos de Recursos do Azure, visite o artigo do grupo de recursos.

    4. Para este exercício, selecione o Windows como o sistema operacional escolhido.

    5. Selecione o Plano de Consumo para o Plano de Hospedagem.

    6. Determine a localização do grupo de recursos (se você estiver criando um novo Grupo de Recursos). O local seria idealmente na região em que o aplicativo seria executado. Alguns ativos do Azure só estão disponíveis em determinadas regiões. Para obter um desempenho ideal, selecione a mesma região que a conta de armazenamento.

    7. Para Armazenamento, selecione Usar existente e, em seguida, usando o menu suspenso, localize o armazenamento criado anteriormente.

    8. Deixe o Application Insights desativado para este exercício.

      detalhes do aplicativo de funções de entrada

  4. Selecione o botão Criar.

  5. Depois de clicar em Criar, você precisará aguardar a criação do serviço, isso pode levar um minuto.

  6. Uma notificação será exibida no portal depois que a instância de Serviço for criada.

    nova notificação do portal do Azure

  7. Clique nas notificações para explorar sua nova instância de Serviço.

    ir para o aplicativo de funções de recurso

  8. Clique no botão Ir para recurso na notificação para explorar sua nova instância de Serviço. Você será levado para sua nova instância do serviço aplicativo de funções .

  9. No painel do Aplicativo de Funções , passe o mouse sobre o Functions, encontrado no painel à esquerda e clique no símbolo + (mais ).

    criar nova função

  10. Na próxima página, verifique se o Webhook + API está selecionado e, para Escolher um idioma, selecione CSharp, pois esse será o idioma usado para este tutorial. Por fim, clique no botão Criar essa função .

    selecionar csharp de gancho da Web

  11. Você deve ser levado para a página de código (run.csx), se não for o caso, clique na função recém-criada na lista Funções dentro do painel à esquerda.

    abrir nova função

  12. Copie o código a seguir em sua função. Essa função simplesmente retornará um inteiro aleatório entre 0 e 2 quando chamado. Não se preocupe com o código existente, fique à vontade para colar por cima dele.

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

  14. O resultado deve se parecer com a imagem abaixo.

  15. Clique em Obter URL da função e anote o ponto de extremidade exibido. Você precisará inseri-lo na classe AzureServices que será criada posteriormente neste curso.

    Obter ponto de extremidade de função

    Inserir ponto de extremidade de função

Capítulo 3 – Configurando o projeto do Unity

A seguir está uma configuração típica para desenvolvimento com Realidade Misturada e, como tal, é um bom modelo para outros projetos.

Configure e teste seu headset imersivo de realidade misturada.

Observação

Você não exigirá controladores de movimento para este curso. Se você precisar de suporte para configurar o headset imersivo, visite o artigo de configuração de realidade misturada.

  1. Abra o Unity e clique em Novo.

    Criar um novo projeto do Unity

  2. Agora você precisará fornecer um nome do Projeto do Unity. Insira MR_Azure_Functions. Verifique se o tipo de projeto está definido como 3D. Defina o Local como um lugar apropriado para você (lembre-se de que mais perto dos diretórios raiz é melhor). Em seguida, clique em Criar projeto.

    Dê um nome ao novo projeto do Unity

  3. Com o Unity aberto, vale a pena verificar se o Editor de Script padrão está definido como Visual Studio. Vá para Editar>Preferências e, em seguida, na nova janela, navegue até Ferramentas Externas. Altere o Editor de Script Externo para o Visual Studio 2017. Feche a janela Preferências .

    definir o Visual Studio como editor de script

  4. Em seguida, vá paraConfigurações de Build de Arquivo> e alterne a plataforma para Plataforma Universal do Windows, clicando no botão Alternar Plataforma.

    mudar de plataforma para uwp

  5. Vá paraconfigurações de build de arquivo> e verifique se:

    1. O dispositivo de destino está definido como Qualquer Dispositivo.

      Para Microsoft HoloLens, defina o dispositivo de destino como HoloLens.

    2. O tipo de build está definido como D3D

    3. O SDK está definido como o mais recente instalado

    4. A versão do Visual Studio está definida como mais recente instalada

    5. Compilar e Executar é definido como Computador Local

    6. Salve a cena e adicione-a ao build.

      1. Faça isso selecionando Adicionar Cenas Abertas. Uma janela de salvamento será exibida.

        adicionar cenas abertas

      2. Crie uma nova pasta para essa cena e, em qualquer futuro, selecione o botão Nova pasta , para criar uma nova pasta, nomeie-a cenas.

        criar pasta de cenas

      3. Abra a pasta Cenas recém-criada e, em seguida, no nome do arquivo: campo de texto, digite FunctionsScene e pressione Salvar.

        Salvar cena de funções

  6. As configurações restantes, em Configurações de Build, devem ser deixadas como padrão por enquanto.

    Deixar configurações de build padrão

  7. Na janela Configurações de Build , clique no botão Configurações do Player , isso abrirá o painel relacionado no espaço onde o Inspetor está localizado.

    configurações do player no inspetor

  8. Neste painel, algumas configurações precisam ser verificadas:

    1. Na guia Outras Configurações :

      1. A versão de runtime de script deve ser experimental (equivalente ao .NET 4.6), o que disparará a necessidade de reiniciar o Editor.
      2. O back-end de script deve ser .NET
      3. O nível de compatibilidade da API deve ser .NET 4.6
    2. Na guia Configurações de Publicação , em Recursos, verifique:

      • InternetClient

        definir recursos

    3. Mais abaixo no painel, em Configurações XR (encontradas abaixo das Configurações de Publicação), marque a Realidade Virtual com suporte, verifique se o SDK do Windows Mixed Reality foi adicionado.

      definir configurações de XR

  9. Os projetos do Unity C# de configurações de build não estão mais esmaecidos; marque a caixa de seleção ao lado disso.

    projetos do tick c#

  10. Feche a janela Configurações de Build.

  11. Salve a cena e o projeto (FILE>SAVE SCENE/FILE>SAVE PROJECT).

Capítulo 4 – Configurar a Câmera Principal

Importante

Se você quiser ignorar os componentes de Configuração do Unity deste curso e continuar diretamente no código, fique à vontade para baixar este .unitypackage e importá-lo para seu projeto como um Pacote Personalizado. Isso também conterá as DLLs do próximo Capítulo. Após a importação, prossiga do Capítulo 7.

  1. No Painel hierarquia, você encontrará um objeto chamado Câmera Principal, esse objeto representa o ponto de exibição "cabeça" quando você estiver "dentro" do aplicativo.

  2. Com o Painel do Unity à sua frente, selecione o GameObject da Câmera Principal. Você observará que o Painel inspetor (geralmente encontrado à direita, dentro do Painel) mostrará os vários componentes desse GameObject, com o Transform na parte superior, seguido pela Câmera e alguns outros componentes. Você precisará redefinir a Transformação da Câmera Principal para que ela seja posicionada corretamente.

  3. Para fazer isso, selecione o ícone Engrenagem ao lado do componente Transformação da Câmera e selecione Redefinir.

    redefinir transformação

  4. Em seguida, atualize o componente Transformar para se parecer com:

Transformação – Posição

X S Z
0 1 0

Transformar – Rotação

X S Z
0 0 0

Transformar – Dimensionar

X S Z
1 1 1

definir transformação da câmera

Capítulo 5 – Configurando a cena do Unity

  1. Clique com o botão direito do mouse em uma área vazia do Painel de Hierarquia, em Objeto 3D, adicione um Plano.

    criar novo plano

  2. Com o objeto Plane selecionado, altere os seguintes parâmetros no Painel inspetor:

Transformação – Posição

X S Z
0 0 4

Transformar – Dimensionar

X S Z
10 1 10

definir a posição e a escala do plano

exibição de cena do plano

  1. Clique com o botão direito do mouse em uma área vazia do Painel de Hierarquia, em Objeto 3D, adicione um Cubo.

    1. Renomeie o Cubo para GazeButton (com o Cubo selecionado, pressione 'F2').

    2. Altere os seguintes parâmetros para Transformar Posição no Painel inspetor:

      X S Z
      0 3 5

      definir transformação do botão de foco

      modo de exibição de cena do botão de foco

    3. Clique no botão suspenso Marca e clique em Adicionar Marca para abrir o Painel De Camadas & de Marcas.

      adicionar nova marca

      selecionar mais

    4. Selecione o botão + (mais) e, no campo Novo Nome da Marca , insira GazeButton e pressione Salvar.

      nome da nova marca

    5. Clique no objeto GazeButton no Painel hierarquia e, no Painel inspetor, atribua a marca GazeButton recém-criada.

      botão atribuir o botão de foco a nova marca

  2. Clique com o botão direito do mouse no objeto GazeButton , no Painel hierarquia, e adicione um GameObject vazio (que será adicionado como um objeto filho ).

  3. Selecione o novo objeto e renomeie-o como ShapeSpawnPoint.

    1. Altere os seguintes parâmetros para Transformar Posição no Painel inspetor:

      X S Z
      0 -1 0

      atualizar a transformação do ponto de desova de forma

      exibição da cena do ponto de desova da forma

  4. Em seguida, você criará um objeto 3D Text para fornecer comentários sobre o status do serviço do Azure.

    Clique com o botão direito do mouse no GazeButton no Painel de Hierarquia novamente e adicione um objeto 3D Object>3D Text como um filho.

    criar novo objeto de texto 3D

  5. Renomeie o objeto 3D Text para AzureStatusText.

  6. Altere a Posição de Transformação do objeto AzureStatusText da seguinte maneira:

    X S Z
    0 0 -0,6
  7. Altere a Escala de Transformação do objeto AzureStatusText da seguinte maneira: | X | Y | Z | | :---: | :---: | :---: | | 0.1 | 0.1 | 0.1 |

    Observação

    Não se preocupe se ele parecer estar fora do centro, pois isso será corrigido quando o componente da Malha de Texto abaixo for atualizado.

  8. Altere o componente Malha de Texto para corresponder ao seguinte:

    definir componente de malha de texto

    Dica

    A cor selecionada aqui é a cor Hex: 0000000FF, embora fique à vontade para escolher a sua, apenas verifique se ela é legível.

  9. Sua estrutura do Painel de Hierarquia agora deve ter esta aparência:

    Malha de texto na hierarquia

  10. Sua cena agora deve ter esta aparência:

    Malha de texto no modo de exibição de cena

Capítulo 6 – Importar o Armazenamento do Azure para Unity

Você usará o Armazenamento do Azure para Unity (que aproveita o SDK do .Net para Azure). Você pode ler mais sobre isso no artigo do Armazenamento do Azure para Unity.

Atualmente, há um problema conhecido no Unity que exige que os plug-ins sejam reconfigurados após a importação. Essas etapas (4 a 7 nesta seção) não serão mais necessárias depois que o bug for resolvido.

Para importar o SDK para seu próprio projeto, verifique se você baixou o '.unitypackage' mais recente do GitHub. Em seguida, faça o seguinte:

  1. Adicione o arquivo .unitypackage ao Unity usando a opção de menuPacote Personalizado deImportação> de Ativos>.

  2. Na caixa Importar Pacote do Unity que aparece, você pode selecionar tudo em Armazenamento de Plug-in>. Desmarque todo o resto, pois não é necessário para este curso.

    importar para pacote

  3. Clique no botão Importar para adicionar os itens ao projeto.

  4. Vá para a pasta Armazenamento em Plug-ins, no modo projeto, e selecione apenas os seguintes plug-ins:

    • Microsoft.Data.Edm

    • Microsoft.Data.OData

    • Microsoft.WindowsAzure.Storage

    • Newtonsoft.Json

    • System.Spatial

      desmarcar qualquer plataforma

  5. Com esses plug-ins específicos selecionados, desmarqueQualquer Plataforma e desmarque oWSAPlayer e clique em Aplicar.

    aplicar dlls de plataforma

    Observação

    Estamos marcando esses plug-ins específicos para serem usados apenas no Editor do Unity. Isso ocorre porque há versões diferentes dos mesmos plug-ins na pasta WSA que serão usadas depois que o projeto for exportado do Unity.

  6. Na pasta Plug-in de Armazenamento , selecione apenas:

    • Microsoft.Data.Services.Client

      set don't process for dlls

  7. Marque a caixa Não Processar em Configurações da Plataforma e clique em Aplicar.

    aplicar nenhum processamento

    Observação

    Estamos marcando esse plug-in "Não processar" porque o patcher de assembly do Unity tem dificuldade em processar esse plug-in. O plug-in ainda funcionará mesmo que não seja processado.

Capítulo 7 – Criar a classe AzureServices

A primeira classe que você vai criar é a classe AzureServices .

A classe AzureServices será responsável por:

  • Armazenando credenciais da Conta do Azure.

  • Chamando sua função Azure App.

  • O upload e o download do arquivo de dados no Armazenamento de Nuvem do Azure.

Para criar esta Classe:

  1. Clique com o botão direito do mouse na Pasta de Ativos , localizada no Painel de Projeto, Criar>Pasta. Nomeie a pasta Scripts.

    criar nova pasta

    pasta de chamada – scripts

  2. Clique duas vezes na pasta que acabou de criar para abri-la.

  3. Clique com o botão direito do mouse dentro da pasta, Criar>Script C#. Chame o script AzureServices.

  4. Clique duas vezes na nova classe AzureServices para abri-la com o Visual Studio.

  5. Adicione os seguintes namespaces à parte superior do AzureServices:

        using System;
        using System.Threading.Tasks;
        using UnityEngine;
        using Microsoft.WindowsAzure.Storage;
        using Microsoft.WindowsAzure.Storage.File;
        using System.IO;
        using System.Net;
    
  6. Adicione os seguintes Campos de Inspetor dentro da classe AzureServices :

        /// <summary>
        /// Provides Singleton-like behavior to this class.
        /// </summary>
        public static AzureServices instance;
    
        /// <summary>
        /// Reference Target for AzureStatusText Text Mesh object
        /// </summary>
        public TextMesh azureStatusText;
    
  7. Em seguida, adicione as seguintes variáveis de membro dentro da classe AzureServices :

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

    Importante

    Substitua os valores de cadeia de caracteres de conexão e ponto de extremidade pelos valores do armazenamento do Azure, encontrados no Portal do Azure

  8. O código para métodos Awake() e Start() agora precisa ser adicionado. Esses métodos serão chamados quando a classe inicializar:

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

    Importante

    Preencheremos o código de CallAzureFunctionForNextShape() em um capítulo futuro.

  9. Exclua o método Update(), pois essa classe não o usará.

  10. Salve suas alterações no Visual Studio e retorne ao Unity.

  11. Clique e arraste a classe AzureServices da pasta Scripts para o objeto Câmera Principal no Painel de Hierarquia.

  12. Selecione a Câmera Principal e, em seguida, pegue o objeto filho AzureStatusText abaixo do objeto GazeButton e coloque-o dentro do campo de destino de referência do AzureStatusText , no Inspetor, para fornecer a referência ao script AzureServices .

    atribuir o destino de referência de texto de status do azure

Capítulo 8 – Criar a classe ShapeFactory

O próximo script a ser criado é a classe ShapeFactory . A função dessa classe é criar uma nova forma, quando solicitada, e manter um histórico das formas criadas em uma Lista de Histórico de Formas. Sempre que uma forma é criada, a lista de Histórico de Formas é atualizada na classe AzureService e armazenada no Armazenamento do Azure. Quando o aplicativo é iniciado, se um arquivo armazenado for encontrado no Armazenamento do Azure, a lista histórico de formas será recuperada e reproduzida, com o objeto Texto 3D fornecendo se a forma gerada é do armazenamento ou nova.

Para criar essa classe:

  1. Vá para a pasta Scripts que você criou anteriormente.

  2. Clique com o botão direito do mouse dentro da pasta, Criar>Script C#. Chame o script ShapeFactory.

  3. Clique duas vezes no novo script ShapeFactory para abri-lo com o Visual Studio.

  4. Verifique se a classe ShapeFactory inclui os seguintes namespaces:

        using System.Collections.Generic;
        using UnityEngine;
    
  5. Adicione as variáveis mostradas abaixo à classe ShapeFactory e substitua as funções Start() e Awake() pelas seguintes:

        /// <summary>
        /// Provide this class Singleton-like behaviour
        /// </summary>
        [HideInInspector]
        public static ShapeFactory instance;
    
        /// <summary>
        /// Provides an Inspector exposed reference to ShapeSpawnPoint
        /// </summary>
        [SerializeField]
        public Transform spawnPoint;
    
        /// <summary>
        /// Shape History Index
        /// </summary>
        [HideInInspector]
        public List<int> shapeHistoryList;
    
        /// <summary>
        /// Shapes Enum for selecting required shape
        /// </summary>
        private enum Shapes { Cube, Sphere, Cylinder }
    
        private void Awake()
        {
            instance = this;
        }
    
        private void Start()
        {
            shapeHistoryList = new List<int>();
        }
    
  6. O método CreateShape() gera as formas primitivas, com base no parâmetro inteiro fornecido. O parâmetro booliano é usado para especificar se a forma atualmente criada é do armazenamento ou nova. Coloque o seguinte código em sua classe ShapeFactory , abaixo dos métodos anteriores:

        /// <summary>
        /// Use the Shape Enum to spawn a new Primitive object in the scene
        /// </summary>
        /// <param name="shape">Enumerator Number for Shape</param>
        /// <param name="storageShape">Provides whether this is new or old</param>
        internal void CreateShape(int shape, bool storageSpace)
        {
            Shapes primitive = (Shapes)shape;
            GameObject newObject = null;
            string shapeText = storageSpace == true ? "Storage: " : "New: ";
    
            AzureServices.instance.azureStatusText.text = string.Format("{0}{1}", shapeText, primitive.ToString());
    
            switch (primitive)
            {
                case Shapes.Cube:
                newObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
                break;
    
                case Shapes.Sphere:
                newObject = GameObject.CreatePrimitive(PrimitiveType.Sphere);
                break;
    
                case Shapes.Cylinder:
                newObject = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
                break;
            }
    
            if (newObject != null)
            {
                newObject.transform.position = spawnPoint.position;
    
                newObject.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
    
                newObject.AddComponent<Rigidbody>().useGravity = true;
    
                newObject.GetComponent<Renderer>().material.color = UnityEngine.Random.ColorHSV(0f, 1f, 1f, 1f, 0.5f, 1f);
            }
        }
    
  7. Salve suas alterações no Visual Studio antes de retornar ao Unity.

  8. De volta ao Editor do Unity, clique e arraste a classe ShapeFactory da pasta Scripts para o objeto Câmera Principal no Painel hierarquia.

  9. Com a Câmera Principal selecionada, você observará que o componente de script ShapeFactory não tem a referência de Ponto de Geração . Para corrigi-lo, arraste o objeto ShapeSpawnPoint do Painel de Hierarquia para o destino de referência do Ponto de Geração .

    definir meta de referência de fábrica de formas

Capítulo 9 – Criar a classe Gaze

O último script que você precisa criar é a classe Gaze .

Essa classe é responsável por criar um Raycast que será projetado para a frente a partir da Câmera Principal, para detectar qual objeto o usuário está examinando. Nesse caso, o Raycast precisará identificar se o usuário está examinando o objeto GazeButton na cena e disparar um comportamento.

Para criar esta Classe:

  1. Vá para a pasta Scripts que você criou anteriormente.

  2. Clique com o botão direito do mouse no Painel de Projeto, Criar>Script em C#. Chame o script De olhar.

  3. Clique duas vezes no novo script Gaze para abri-lo com o Visual Studio.

  4. Verifique se o namespace a seguir está incluído na parte superior do script:

        using UnityEngine;
    
  5. Em seguida, adicione as seguintes variáveis dentro da classe Gaze :

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

Importante

Algumas dessas variáveis poderão ser editadas no Editor.

  1. O código para os métodos Awake() e Start() agora precisa ser adicionado.

        /// <summary>
        /// The method used after initialization of the scene, though before Start().
        /// </summary>
        private void Awake()
        {
            // Set this class to behave similar to singleton
            instance = this;
        }
    
        /// <summary>
        /// Start method used upon initialization.
        /// </summary>
        private void Start()
        {
            FocusedObject = null;
            Cursor = CreateCursor();
        }
    
  2. Adicione o seguinte código, que criará um objeto de cursor no início, juntamente com o método Update(), que executará o método Raycast, além de ser onde o booliano GazeEnabled é alternado:

        /// <summary>
        /// Method to create a cursor object.
        /// </summary>
        /// <returns></returns>
        private GameObject CreateCursor()
        {
            GameObject newCursor = GameObject.CreatePrimitive(PrimitiveType.Sphere);
            newCursor.SetActive(false);
    
            // Remove the collider, so it doesn't block raycast.
            Destroy(newCursor.GetComponent<SphereCollider>());
            newCursor.transform.localScale = CursorSize;
    
            newCursor.GetComponent<MeshRenderer>().material = new Material(Shader.Find("Diffuse"))
            {
                color = CursorColour
            };
    
            newCursor.name = "Cursor";
    
            newCursor.SetActive(true);
    
            return newCursor;
        }
    
        /// <summary>
        /// Called every frame
        /// </summary>
        private void Update()
        {
            if(GazeEnabled == true)
            {
                _gazeOrigin = Camera.main.transform.position;
    
                _gazeDirection = Camera.main.transform.forward;
    
                UpdateRaycast();
            }
        }
    
  3. Em seguida, adicione o método UpdateRaycast(), que projetará um Raycast e detectará o destino atingido.

        private void UpdateRaycast()
        {
            // Set the old focused gameobject.
            _oldFocusedObject = FocusedObject;
    
            RaycastHit hitInfo;
    
            // Initialise Raycasting.
            Hit = Physics.Raycast(_gazeOrigin,
                _gazeDirection,
                out hitInfo,
                GazeMaxDistance, LayerMask);
    
            HitInfo = hitInfo;
    
            // Check whether raycast has hit.
            if (Hit == true)
            {
                Position = hitInfo.point;
    
                Normal = hitInfo.normal;
    
                // Check whether the hit has a collider.
                if (hitInfo.collider != null)
                {
                    // Set the focused object with what the user just looked at.
                    FocusedObject = hitInfo.collider.gameObject;
                }
                else
                {
                    // Object looked on is not valid, set focused gameobject to null.
                    FocusedObject = null;
                }
            }
            else
            {
                // No object looked upon, set focused gameobject to null.
                FocusedObject = null;
    
                // Provide default position for cursor.
                Position = _gazeOrigin + (_gazeDirection * GazeMaxDistance);
    
                // Provide a default normal.
                Normal = _gazeDirection;
            }
    
            // Lerp the cursor to the given position, which helps to stabilize the gaze.
            Cursor.transform.position = Vector3.Lerp(Cursor.transform.position, Position, 0.6f);
    
            // Check whether the previous focused object is this same 
            //    object. If so, reset the focused object.
            if (FocusedObject != _oldFocusedObject)
            {
                ResetFocusedObject();
    
                if (FocusedObject != null)
                {
                if (FocusedObject.CompareTag(InteractibleTag.ToString()))
                {
                        // Set the Focused object to green - success!
                        FocusedObject.GetComponent<Renderer>().material.color = Color.green;
    
                        // Start the Azure Function, to provide the next shape!
                        AzureServices.instance.CallAzureFunctionForNextShape();
                    }
                }
            }
        }
    
  4. Por fim, adicione o método ResetFocusedObject(), que alternará a cor atual dos objetos GazeButton, indicando se ele está criando uma nova forma ou não.

        /// <summary>
        /// Reset the old focused object, stop the gaze timer, and send data if it
        /// is greater than one.
        /// </summary>
        private void ResetFocusedObject()
        {
            // Ensure the old focused object is not null.
            if (_oldFocusedObject != null)
            {
                if (_oldFocusedObject.CompareTag(InteractibleTag.ToString()))
                {
                    // Set the old focused object to red - its original state.
                    _oldFocusedObject.GetComponent<Renderer>().material.color = Color.red;
                }
            }
        }
    
  5. Salve suas alterações no Visual Studio antes de retornar ao Unity.

  6. Clique e arraste a classe Gaze da pasta Scripts para o objeto Câmera Principal no Painel de Hierarquia.

Capítulo 10 – Concluindo a classe AzureServices

Com os outros scripts em vigor, agora é possível concluir a classe AzureServices . Isso será alcançado por meio de:

  1. Adicionando um novo método chamado CreateCloudIdentityAsync(), para configurar as variáveis de autenticação necessárias para se comunicar com o Azure.

    Esse método também verificará a existência de um arquivo armazenado anteriormente que contém a Lista de Formas.

    Se o arquivo for encontrado, ele desabilitará o Foco do usuário e disparará a criação de forma, de acordo com o padrão de formas, conforme armazenado no arquivo de Armazenamento do Azure. O usuário pode ver isso, pois a Malha de Texto fornecerá a exibição "Armazenamento" ou "Novo", dependendo da origem das formas.

    Se nenhum arquivo for encontrado, ele habilitará o Gaze, permitindo que o usuário crie formas ao examinar o objeto GazeButton na cena.

        /// <summary>
        /// Create the references necessary to log into Azure
        /// </summary>
        private async void CreateCloudIdentityAsync()
        {
            // Retrieve storage account information from connection string
            storageAccount = CloudStorageAccount.Parse(storageConnectionString);
    
            // Create a file client for interacting with the file service.
            fileClient = storageAccount.CreateCloudFileClient();
    
            // Create a share for organizing files and directories within the storage account.
            share = fileClient.GetShareReference(fileShare);
    
            await share.CreateIfNotExistsAsync();
    
            // Get a reference to the root directory of the share.
            CloudFileDirectory root = share.GetRootDirectoryReference();
    
            // Create a directory under the root directory
            dir = root.GetDirectoryReference(storageDirectory);
    
            await dir.CreateIfNotExistsAsync();
    
            //Check if the there is a stored text file containing the list
            shapeIndexCloudFile = dir.GetFileReference("TextShapeFile");
    
            if (!await shapeIndexCloudFile.ExistsAsync())
            {
                // File not found, enable gaze for shapes creation
                Gaze.instance.GazeEnabled = true;
    
                azureStatusText.text = "No Shape\nFile!";
            }
            else
            {
                // The file has been found, disable gaze and get the list from the file
                Gaze.instance.GazeEnabled = false;
    
                azureStatusText.text = "Shape File\nFound!";
    
                await ReplicateListFromAzureAsync();
            }
        }
    
  2. O próximo snippet de código é de dentro do método Start(; em que uma chamada será feita para o método CreateCloudIdentityAsync( ). Fique à vontade para copiar o método Start() atual, com o seguinte:

        private void Start()
        {
            // Disable TLS cert checks only while in Unity Editor (until Unity adds support for TLS)
    #if UNITY_EDITOR
            ServicePointManager.ServerCertificateValidationCallback = delegate { return true; };
    #endif
    
            // Set the Status text to loading, whilst attempting connection to Azure.
            azureStatusText.text = "Loading...";
    
            //Creating the references necessary to log into Azure and check if the Storage Directory is empty
            CreateCloudIdentityAsync();
        }
    
  3. Preencha o código do método CallAzureFunctionForNextShape(). Você usará o Aplicativo de Funções do Azure criado anteriormente para solicitar um índice de forma. Depois que a nova forma for recebida, esse método enviará a forma para a classe ShapeFactory para criar a nova forma na cena. Use o código abaixo para concluir o corpo de 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();
        }
    
  4. Adicione um método para criar uma cadeia de caracteres, concatenando os inteiros armazenados na lista de histórico de formas e salvando-o no Arquivo de Armazenamento do Azure.

        /// <summary>
        /// Upload the locally stored List to Azure
        /// </summary>
        private async Task UploadListToAzureAsync()
        {
            // Uploading a local file to the directory created above
            string listToString = string.Join(",", ShapeFactory.instance.shapeHistoryList.ToArray());
    
            await shapeIndexCloudFile.UploadTextAsync(listToString);
        }
    
  5. Adicione um método para recuperar o texto armazenado no arquivo localizado em seu Arquivo de Armazenamento do Azure e desserializá-lo em uma lista.

  6. Depois que esse processo é concluído, o método habilita novamente o olhar para que o usuário possa adicionar mais formas à cena.

        ///<summary>
        /// Get the List stored in Azure and use the data retrieved to replicate 
        /// a Shape creation pattern
        ///</summary>
        private async Task ReplicateListFromAzureAsync()
        {
            string azureTextFileContent = await shapeIndexCloudFile.DownloadTextAsync();
    
            string[] shapes = azureTextFileContent.Split(new char[] { ',' });
    
            foreach (string shape in shapes)
            {
                int i;
    
                Int32.TryParse(shape.ToString(), out i);
    
                ShapeFactory.instance.shapeHistoryList.Add(i);
    
                ShapeFactory.instance.CreateShape(i, true);
    
                await Task.Delay(500);
            }
    
            Gaze.instance.GazeEnabled = true;
    
            azureStatusText.text = "Load Complete!";
        }
    
  7. Salve suas alterações no Visual Studio antes de retornar ao Unity.

Capítulo 11 – Criar a solução UWP

Para iniciar o processo de build:

  1. Vá paraconfigurações de build de arquivo>.

    criar o aplicativo

  2. Clique em Compilar. O Unity iniciará uma janela Explorador de Arquivos, na qual você precisa criar e selecionar uma pasta para criar o aplicativo. Crie essa pasta agora e nomeie-a como Aplicativo. Em seguida, com a pasta Aplicativo selecionada, pressione Selecionar Pasta.

  3. O Unity começará a compilar seu projeto para a pasta Aplicativo .

  4. Depois que o Unity terminar de criar (pode levar algum tempo), ele abrirá uma janela Explorador de Arquivos no local do build (verifique sua barra de tarefas, pois ela pode nem sempre aparecer acima das janelas, mas notificará você sobre a adição de uma nova janela).

Capítulo 12 – Implantando seu aplicativo

Para implantar seu aplicativo:

  1. Navegue até a pasta Aplicativo que foi criada no último Capítulo. Você verá um arquivo com o nome de seus aplicativos, com a extensão '.sln', que você deve clicar duas vezes, para abri-lo no Visual Studio.

  2. Na Plataforma de Soluções, selecione x86, Computador Local.

  3. Na Configuração da Solução , selecione Depurar.

    Para o Microsoft HoloLens, talvez seja mais fácil defini-lo como Computador Remoto, para que você não esteja vinculado ao computador. No entanto, você também precisará fazer o seguinte:

    • Conheça o endereço IP do HoloLens, que pode ser encontrado nasOpções Avançadas deWi-Fi> daInternet de Configurações&>; o IPv4 é o endereço que você deve usar.>
    • Verifique se o modo de desenvolvedor está ativado; encontrado na Segurança > deAtualização &de Configurações>para desenvolvedores.

    implantar solução

  4. Vá para o menu Compilar e clique em Implantar solução para sideload do aplicativo em seu computador.

  5. Seu aplicativo agora deve aparecer na lista de aplicativos instalados, prontos para serem iniciados e testados!

Seu aplicativo de armazenamento e Azure Functions concluído

Parabéns, você criou um aplicativo de realidade misturada que aproveita os serviços de armazenamento do Azure Functions e do Azure. Seu aplicativo poderá desenhar dados armazenados e fornecer uma ação com base nesses dados.

final do produto -end

Exercícios de bônus

Exercício 1

Crie um segundo ponto de desova e registro do qual ponto de geração um objeto foi criado. Ao carregar o arquivo de dados, reproduza as formas que estão sendo geradas do local em que foram criadas originalmente.

Exercício 2

Crie uma maneira de reiniciar o aplicativo, em vez de precisar abri-lo novamente cada vez. Carregar Cenas é um bom local para começar. Depois de fazer isso, crie uma maneira de limpar a lista armazenada no Armazenamento do Azure, para que ela possa ser facilmente redefinida do seu aplicativo.