Criar um jogo de RA usando a AR Foundation do Unity

1. Visão geral

O ARCore é o framework do Google para criar experiências de realidade aumentada em smartphones. Você pode usar o AR Foundation do Unity para criar aplicativos de RA multiplataforma.

O que você vai criar

Neste codelab, você vai criar um jogo simples usando o AR Foundation. O objetivo do jogo é coletar pacotes usando um carro controlado por um dispositivo portátil.

No entanto, isso não vai acontecer em um mundo totalmente virtual. Você vai misturar átomos físicos e bits digitais para criar um novo tipo de experiência de jogador, criando um jogo que entenda o ambiente ao redor do jogador.

Ao final deste codelab, seu jogo poderá:

• Detectar planos do mundo real e desenhar um campo de jogo sobre eles.
• Projeta raios da visão da câmera e detecta interseções com planos.
• Reaja a condições de iluminação do mundo real para dar mais realismo ao jogo.

O que você vai aprender

• Como configurar um projeto que usa o AR Foundation do Unity.
• Como usar o ARPlaneManager para assinar novos planos.
• Como usar Raycast para encontrar interseções com geometria virtual
• Como usar o ARLightEstimationData para iluminar a cena.

O que é necessário

• Um dispositivo compatível com o ARCore, conectado por um cabo USB à sua máquina de desenvolvimento.
• Google Play Services para RA 1.23 ou mais recente.
• Uma instalação do Unity Hub ou do Unity 2020 LTS.

2. Configurar o ambiente de desenvolvimento

Nesta etapa, você vai preparar o ambiente para o desenvolvimento com a AR Foundation do Unity.

Verificar se o dispositivo é compatível com RA

As experiências de RA em dispositivos Android são impulsionadas pelo ARCore, que está disponível em dispositivos compatíveis com o ARCore. Verifique se o dispositivo de desenvolvimento é compatível com AR. Também é possível usar uma instância do emulador do Android compatível com AR configurada corretamente.

Configurar a depuração USB no dispositivo

Você precisará ativar as Opções do desenvolvedor no dispositivo para executar apps de depuração. Se você ainda não fez isso, consulte a documentação do Android sobre Ativar as opções do desenvolvedor e a depuração USB.

Instalar o Unity (2020.3 LTS)

Na sua estação de trabalho, instale o Unity 2020 LTS. Neste codelab, mostramos capturas de tela da interface do Unity na versão 2020.3 (LTS). Outras versões do Unity podem funcionar, mas talvez exijam etapas adicionais. A aparência pode ser diferente das capturas de tela mostradas aqui.

Criar um novo projeto

Crie um projeto usando o modelo Universal Render Pipeline. Dê um nome descritivo e um local adequado e pressione CRIAR.

Instalar os frameworks necessários

A AR Foundation do Unity pode ser encontrada no Unity Package Manager.

1. Para abrir, clique em Window > Package Manager.

2. Nesta janela, instale os pacotes que você vai usar neste codelab. Para conferir as versões mais recentes desses frameworks, expanda a entrada usando o ícone ►. Instale as versões mais recentes de cada um destes frameworks:
   • AR Foundation
   • Plug-in XR do ARCore

Quando você terminar, o Package Manager vai ficar assim:

Instalar o pacote inicial

Para este codelab, fornecemos um pacote inicial que contém prefabs e scripts que vão acelerar algumas partes do codelab para que você possa se concentrar em como usar o AR Foundation.

1. Baixe o pacote inicial
2. Instale o pacote inicial abrindo Assets > Import Package > Custom Package... e starter-package.unitypackage.
3. Na janela pop-up, verifique se tudo está selecionado.
4. Clique em Importar.

Mudar as configurações da versão

Como o aplicativo será executado no Android, mude a plataforma de build para Android:

1. Abra Arquivo > Configurações do build.
2. No painel Plataforma, selecione Android.
3. Se quiser, ative Build de desenvolvimento e Depuração de script para reter informações de depuração enquanto o app é executado.
4. Clique em Alternar plataforma.

Mudar as configurações do projeto

A AR Foundation precisa ser configurada para inicializar sistemas de RV na inicialização.

1. Abra Edit > Project Settings... e clique na seção XR Plug-in Management.
2. Na guia Android, ative o ARCore.

3. No painel à esquerda, clique na seção Player.
4. Na guia Android, em Outras configurações, remova Vulkan de APIs de gráficos.

5. Os apps que exigem RA e usam o ARCore precisam de um nível mínimo da API de 24. Role a tela para baixo e encontre Nível mínimo da API. Defina o nível mínimo da API como 24.

Adicionar os elementos de cena necessários

O modelo do Universal Render Pipeline vem com alguns objetos de jogo que não serão usados neste tutorial.

1. Exclua todos os objetos de jogo no SampleScene.

2. Adicione objetos do AR Foundation. Clique com o botão direito do mouse no painel Hierarquia. Use esse menu para adicionar:

• XR > Sessão de RA: esse objeto controla o ciclo de vida de uma experiência de RA.
• XR > Origem da sessão de RA: esse objeto transforma coordenadas de RA em coordenadas mundiais do Unity.
• Luz > Luz direcional: fornece uma fonte de luz para iluminar objetos do jogo.

A hierarquia deve ser assim:

3. Expanda a Origem da sessão de RA criada na hierarquia e selecione o objeto Câmera de RA. No inspetor, mude a tag para MainCamera.

Configurar a renderização

O Universal Render Pipeline do Unity precisa de uma mudança para ser compatível com o AR Foundation.

1. No painel Project, navegue até Assets > Settings para encontrar o recurso ForwardRenderer.

2. Selecione o ForwardRenderer.
3. No painel "Inspector", use Add Renderer Feature para adicionar um AR Background Renderer Feature. Esse componente vai renderizar a transmissão da câmera na sua cena.

Verifique a configuração

1. Verifique se o dispositivo está conectado e se a depuração ADB está ativada.
2. Clique em Arquivo > Build And Run... Isso vai fazer upload do aplicativo para o dispositivo e iniciá-lo quando estiver instalado.
3. Você deve ver a transmissão da câmera na tela do seu dispositivo.

Na próxima etapa, você vai começar a adicionar funcionalidades ao app.

3. Detectar superfícies planas no mundo real

Agora que uma cena básica foi configurada, você pode começar a desenvolver o jogo. Nesta etapa, você vai detectar planos e desenhá-los na cena.

Adicionar um componente ARPlaneManager

Um ARPlaneManager detecta ARPlanes e cria, atualiza e remove objetos de jogo quando a compreensão do ambiente pelo dispositivo muda.

1. Usando o painel "Hierarquia", crie um GameObject vazio.
2. Renomeie como Driving Surface Manager. Esse componente vai mostrar aviões até que um seja selecionado pelo jogador.
3. Selecione o novo objeto do jogo. No painel "Inspector", clique em Add Component para adicionar um AR Plane Manager.

4. Configure o ARPlaneManager definindo o campo Plane Prefab:
   1. Clique no botão ao lado de None para abrir a janela Selecionar GameObject.
   2. Selecione a guia Recursos e pesquise Plano da superfície de direção.

Esse prefab do pacote inicial fornece uma textura de piso áspera que será usada como decoração do plano.

5. Mude o Detection Mode para Horizontal. Isso configura o ARPlaneManager para fornecer apenas planos horizontais, ideais para dirigir.

Adicionar um componente ARRaycastManager

Um ARRaycastManager expõe a funcionalidade de raycast. Na próxima etapa, vamos usar esse objeto para fornecer os controles ao usuário.

1. Verifique se o objeto chamado Driving Surface Manager está selecionado no painel "Hierarchy".
2. No Inspector, clique em Add Component para adicionar um componente ARRaycastManager ao objeto do jogo.

Nenhuma outra configuração é necessária para esse componente.

Adicionar um componente DrivingSurfaceManager

Um DrivingSurfaceManager é um script auxiliar do pacote inicial que permite selecionar um ARPlane. Depois que um ARPlane é selecionado, todos os outros planos são ocultados, e os novos são desativados.

1. Verifique se o objeto chamado Driving Surface Manager está selecionado no painel "Hierarchy".
2. No Inspector, clique em Add Component para adicionar um componente DrivingSurfaceManager ao objeto do jogo.

Nenhuma outra configuração é necessária para esse componente.

Executar o app

1. Clique em File > Build And Run... para testar as mudanças.
2. Aponte o dispositivo para uma superfície horizontal do mundo real e mova-o para melhorar a compreensão do mundo pelo ARCore.

3. Quando o ARCore detectar um plano, uma textura de sujeira vai cobrir as superfícies do mundo real. O ARPlaneManager cria uma instância do Plane Prefab especificado para cada avião detectado. O prefab Driving Surface Plane tem um componente ARPlaneMeshVisualizer que cria uma malha para um determinado ARPlane.

Na próxima etapa, você vai usar um plano detectado como campo de jogo.

4. Realizar um teste de hit em planos detectados

Na etapa anterior, você programou um aplicativo que pode detectar planos. Esses planos são refletidos na cena do jogo. Agora, você vai adicionar interatividade a esses planos criando uma mira e um carro que vai dirigir na superfície do plano detectado.

Criar um retículo de mira

O esquema de controle desse app envolve o jogador apontando o smartphone para uma superfície. Para dar um feedback visual claro do local designado, use um retículo de mira.

Para "fixar" essa mira em um plano de RA, use um teste de hit. Um teste de hit é uma técnica que calcula interseções ao emitir um raio em uma determinada direção. Você vai usar um teste de hit para detectar uma interseção na direção da visualização da câmera.

Adicionar o retículo

1. No painel Project, perto da parte de baixo da tela, acesse Assets > Starter Package.
2. Arraste o Reticle Prefab para o painel de hierarquia do projeto.
3. Selecione o retículo na hierarquia.
4. No inspetor, clique em Adicionar componente. Adicione o script ReticleBehaviour do pacote inicial. Esse script contém um pouco de boilerplate para controlar o retículo.
5. O script ReticleBehaviour depende do Driving Surface Manager criado anteriormente. Para adicionar a dependência, clique no seletor Driving Surface Manager. Selecione a guia Cena e escolha o Driving Surface Manager.

Edite o ReticleBehaviour

O script ReticleBehavior posiciona o retículo no plano que está no centro da janela de visualização do dispositivo.

1. Abra o script ReticleBehaviour.cs clicando duas vezes no campo Script.
2. Determine o centro da tela usando ViewToScreenPoint da câmera. Edite o método Update() para adicionar o seguinte:

var screenCenter = Camera.main.ViewportToScreenPoint(new Vector3(0.5f, 0.5f));

3. Use esse ponto para fazer um raycast. Adicione o seguinte:

var hits = new List<ARRaycastHit>();
DrivingSurfaceManager.RaycastManager.Raycast(screenCenter, hits, TrackableType.PlaneWithinBounds);

Se você encontrar um NullReferenceException ao usar Camera.main, verifique se o AR Camera da cena em Hierarchy > AR Session Origin está marcado como MainCamera.

A variável hits vai conter ARRaycastHits que descrevem pontos em rastreáveis que são interceptados por ray.

TrackableType.PlaneWithinBounds é um valor em TrackableType. Isso especifica quais tipos de Trackables podem ser detectados com essa transmissão de raio. Confira a documentação do Unity sobre TrackableType para mais informações.

4. Para determinar o ponto de interesse de interseção, consulte a lista hits. Priorize o plano bloqueado contido em DrivingSurfaceManager e, se ele não existir, use o primeiro plano atingido. Adicione o seguinte ao final de Update():

CurrentPlane = null;
ARRaycastHit? hit = null;
if (hits.Length > 0)
{
    // If you don't have a locked plane already...
    var lockedPlane = DrivingSurfaceManager.LockedPlane;
    hit = lockedPlane == null
        // ... use the first hit in `hits`.
        ? hits[0]
        // Otherwise use the locked plane, if it's there.
        : hits.SingleOrDefault(x => x.trackableId == lockedPlane.trackableId);
}

5. Se hit contiver um resultado, mova a transformação de GameObject para a posição do clique.

if (hit.HasValue)
{
    CurrentPlane = DrivingSurfaceManager.PlaneManager.GetPlane(hit.Value.trackableId);
    // Move this reticle to the location of the hit.
    transform.position = hit.Value.pose.position;
}
Child.SetActive(CurrentPlane != null);

Testar a retícula

1. Clique em File > Build And Run... para testar as mudanças.
2. Quando você apontar o dispositivo para um plano, o retículo vai acompanhar os movimentos da câmera.

Criar um carro

O jogador controla um carrinho de brinquedo que se move em direção ao local do retículo. Um modelo e um comportamento para esse carro são fornecidos no pacote inicial.

Adicionar um CarManager à cena

1. Na Hierarquia, crie um GameObject vazio.
2. Renomeie como Car Spawner.
3. Selecione o objeto que você criou. No painel Hierarchy, clique em Add Component para adicionar o componente CarManager.
4. Configure as dependências de CarManager clicando no seletor de cada campo:
   • Prefab do carro: em Recursos, selecione Prefab do carro.
   • Retículo: em Cena, selecione Prefab do retículo.
   • Gerenciador de superfície de direção: em Cena, selecione Gerenciador de superfície de direção.

Esse comportamento de CarManager gera um carrinho de brinquedo no plano em que o retículo está. Se quiser, confira o script CarBehaviour para saber como o carro é programado.

Test drive

1. Clique em File > Build And Run para testar as mudanças.
2. Ao tocar em um avião, um carro pequeno vai aparecer nesse local. O carro vai seguir o retículo.

Adicionar o elemento do jogo

Agora que o jogador pode controlar uma entidade na cena, dê a ele um destino para dirigir.

1. Crie um GameObject vazio na hierarquia.
2. Renomeie como Package Spawner.
3. Selecione o objeto que você criou. No painel Hierarquia, clique em Adicionar componente para adicionar o componente PackageSpawner.
4. Configure as dependências de PackageSpawner clicando no seletor de cada campo:
   • Prefab de pacote: em Assets, selecione Prefab de pacote.
   • Gerenciador de superfície de direção: em Cena, selecione Gerenciador de superfície de direção.

Esse comportamento de PackageSpawner gera um novo pacote em um local aleatório em um ARPlane bloqueado, se ainda não houver um pacote.

Testar o jogo

1. Clique em File > Build And Run para testar as mudanças. 2. Depois de criar um carro, um pacote vai aparecer.
2. Dirija até o pacote.
3. Um novo vai aparecer em um local aleatório.

5. Configurar a estimativa de iluminação

Agora que o jogo básico foi concluído, adicione um toque de realismo à sua cena de RA. Nesta etapa, você vai usar a API Lighting Estimation do ARCore para detectar a iluminação presente no mundo real com base nos frames da câmera recebidos. Essas informações serão usadas para adaptar a iluminação da cena e corresponder à iluminação do mundo real.

Ativar a estimativa de iluminação

1. Em Hierarquia, expanda a Origem da sessão de RA e selecione o objeto Câmera de RA.
2. No Inspector, expanda o script AR Camera Manager.
3. Mude o campo Estimativa de iluminação para Tudo.

Modificar a iluminação direcional

1. Em Hierarquia, selecione o objeto Luz direcional.
2. Adicione o componente LightEstimation a ele. Esse componente do pacote inicial fornece um pouco de boilerplate para se inscrever em mudanças de iluminação.
3. Na função FrameReceived(), adicione:

ARLightEstimationData lightEstimation = args.lightEstimation;

if (lightEstimation.averageBrightness.HasValue)
    Light.intensity = lightEstimation.averageBrightness.Value;

if (lightEstimation.averageColorTemperature.HasValue)
    Light.colorTemperature = lightEstimation.averageColorTemperature.Value;

if (lightEstimation.colorCorrection.HasValue)
    Light.color = lightEstimation.colorCorrection.Value;

if (lightEstimation.mainLightDirection.HasValue)
    Light.transform.rotation = Quaternion.LookRotation(lightEstimation.mainLightDirection.Value);

if (lightEstimation.mainLightColor.HasValue)
    Light.color = lightEstimation.mainLightColor.Value;

if (lightEstimation.mainLightIntensityLumens.HasValue)
    Light.intensity = lightEstimation.averageMainLightBrightness.Value;

if (lightEstimation.ambientSphericalHarmonics.HasValue)
{
    RenderSettings.ambientMode = AmbientMode.Skybox;
    RenderSettings.ambientProbe = lightEstimation.ambientSphericalHarmonics.Value;
}

Confira a documentação do AR Foundation em ARLightEstimationData para mais detalhes sobre cada parâmetro.

Testar suas alterações

1. Clique em File > Build And Run para testar as mudanças.
2. Ao olhar para os objetos na cena, você vai notar que eles são coloridos dependendo da iluminação do ambiente.
3. Se possível, mude a iluminação. Por exemplo, tente apagar as luzes do ambiente em que você está. A iluminação dos objetos precisa se adaptar à mudança na iluminação do mundo real.

6. Resumo

Parabéns! Você chegou ao fim deste codelab sobre o Unity AR Foundation.

Conteúdo abordado

• Como configurar um projeto básico usando a AR Foundation do Unity e o Universal Rendering Pipeline.
• Como usar o ARPlaneManager para assinar novos planos.
• Como usar Raycast para encontrar interseções com geometria virtual.
• Como usar o ARLightEstimationData para iluminar a cena.

Próximas etapas

• Confira os exemplos da AR Foundation do Unity (link em inglês).
• Consulte a documentação do AR Foundation.
• Confira a documentação do Google sobre as extensões do ARCore para a AR Foundation do Unity.

Atividades extras

Se quiser expandir o jogo que você criou aqui, confira algumas ideias:

• Adicione um contador de pontuação ao jogo modificando um TextMeshPro quando um PackageManager gera um novo pacote.
• Confira as informações de desempenho quando o jogo estiver em execução ativando a Sobreposição de desempenho.
• Use Raycasts persistentes para colocar novos objetos na cena primeiro. Quando uma superfície plana é detectada nessa área, o objeto é atualizado para se ajustar a ela.