Crea un gioco AR con AR Foundation di Unity

1. Panoramica

ARCore è il framework di Google per la creazione di esperienze di realtà aumentata sugli smartphone. Puoi utilizzare AR Foundation di Unity per creare applicazioni AR multipiattaforma.

Cosa creerai

In questo codelab, creerai un gioco semplice utilizzando AR Foundation. Lo scopo del gioco è raccogliere pacchi utilizzando un'auto che controlli con il tuo dispositivo portatile.

Tuttavia, questo non accadrà in un mondo completamente virtuale. Mescolerai atomi fisici e bit digitali per creare un nuovo tipo di esperienza per i giocatori, creando un gioco che comprenda l'ambiente circostante.

Al termine di questo codelab, il tuo gioco sarà in grado di:

  • Rileva gli aerei nel mondo reale e disegna un campo di gioco sopra.
  • Proietta raggi dalla visuale della videocamera e rileva le intersezioni con i piani.
  • Reagisce alle condizioni di illuminazione del mondo reale per dare al gioco un realismo extra.

Obiettivi didattici

  • Come configurare un progetto che utilizza AR Foundation di Unity.
  • Come utilizzare ARPlaneManager per abbonarsi a nuovi piani.
  • Come utilizzare Raycast per trovare intersezioni con la geometria virtuale
  • Come utilizzare ARLightEstimationData per illuminare la scena.

Che cosa ti serve

2. Configurazione dell'ambiente di sviluppo

In questo passaggio, preparerai l'ambiente per lo sviluppo con AR Foundation di Unity.

Assicurarsi che il dispositivo sia compatibile con la realtà aumentata

Le esperienze AR sui dispositivi Android sono gestite da ARCore, disponibile sui dispositivi supportati da ARCore. Assicurati che il dispositivo di sviluppo sia compatibile con la AR. In alternativa, puoi utilizzare un'istanza dell'emulatore Android compatibile con la AR configurata correttamente.

Configurare il debug USB sul dispositivo

Per eseguire le app di debug, devi attivare le Opzioni sviluppatore sul tuo dispositivo. Se non l'hai ancora fatto, consulta la documentazione di Android su come attivare le opzioni sviluppatore e il debug USB.

Installare Unity (2020.3 LTS)

Sulla workstation, installa Unity 2020 LTS. In questo codelab vengono mostrati screenshot della UI di Unity nella versione 2020.3 (LTS). Potrebbero funzionare anche altre versioni di Unity, ma potrebbero essere necessari passaggi aggiuntivi. Potrebbe avere un aspetto diverso rispetto agli screenshot mostrati qui.

Crea un nuovo progetto

Crea un nuovo progetto utilizzando il modello Universal Render Pipeline. Assegna un nome descrittivo e una posizione appropriata, quindi premi CREA.

Installa i framework richiesti

AR Foundation di Unity è disponibile in Unity Package Manager.

  1. Per aprirlo, fai clic su Finestra > Package Manager.

  1. In questa finestra, installa i pacchetti che utilizzerai in questo codelab. Visualizza le ultime versioni di questi framework espandendo la voce utilizzando l'icona ►. Installa le versioni più recenti di ciascuno di questi framework:
    • AR Foundation
    • Plug-in ARCore XR

Al termine, Package Manager dovrebbe avere un aspetto simile a questo:

Installa il pacchetto iniziale

Per questo codelab, abbiamo fornito un pacchetto iniziale contenente prefabbricati e script che velocizzeranno alcune parti del codelab, in modo che tu possa concentrarti su come utilizzare AR Foundation.

  2. Installa il pacchetto iniziale aprendo Assets > Import Package > Custom Package… (Risorse > Importa pacchetto > Pacchetto personalizzato…) e aprendo starter-package.unitypackage.
  3. Nella finestra popup, assicurati che tutto sia selezionato.
  4. Fai clic su Importa.

Modificare le impostazioni di build

Poiché l'applicazione verrà eseguita su Android, modifica la piattaforma di build in Android:

  1. Apri File > Build Settings (Impostazioni build).
  2. Nel riquadro Piattaforma, seleziona Android.
  3. (Facoltativo) Attiva Build di sviluppo e Debug script per conservare le informazioni di debug durante l'esecuzione dell'app.
  4. Fai clic su Cambia piattaforma.

Modificare le impostazioni del progetto

AR Foundation deve essere configurato per inizializzare i sistemi XR all'avvio.

  1. Apri Modifica > Impostazioni progetto… e fai clic sulla sezione Gestione plug-in XR.
  2. Nella scheda Android, attiva ARCore.

  1. Nel riquadro a sinistra, fai clic sulla sezione Player.
  2. Nella scheda Android, in Other Settings, rimuovi Vulkan da Graphics API.

  1. Le app AR Required che utilizzano ARCore richiedono un livello API minimo di 24. Scorri verso il basso e trova Livello API minimo. Imposta il livello API minimo su 24.

Aggiungere gli elementi della scena richiesti

Il modello Universal Render Pipeline include alcuni oggetti di gioco che non utilizzerai in questo tutorial.

  1. Elimina tutti gli oggetti di gioco in SampleScene.

  1. Aggiungi oggetti AR Foundation. Fai clic con il tasto destro del mouse nel riquadro Gerarchia. Utilizza questo menu per aggiungere:
  • XR > AR Session: questo oggetto controlla il ciclo di vita di un'esperienza AR.
  • XR > AR Session Origin: questo oggetto trasforma le coordinate AR in coordinate del mondo Unity.
  • Luce > Luce direzionale: fornisce una sorgente luminosa per illuminare gli oggetti di gioco.

La gerarchia dovrebbe essere simile alla seguente:

  1. Espandi l'origine della sessione AR che hai creato nella gerarchia e seleziona l'oggetto Fotocamera AR. Nell'inspector, cambia il tag in MainCamera.

Configurare il rendering

La pipeline di rendering universale di Unity richiede una modifica per essere compatibile con AR Foundation.

  1. Nel riquadro Progetto, vai a Risorse > Impostazioni per trovare la risorsa ForwardRenderer.

  1. Seleziona ForwardRenderer.
  2. Nel riquadro Inspector, utilizza Add Renderer Feature per aggiungere una AR Background Renderer Feature. Questo componente eseguirà il rendering del feed della videocamera nella scena.

Verifica la configurazione

  1. Assicurati che il dispositivo sia collegato alla corrente e che il debug ADB sia attivo.
  2. Fai clic su File > Build And Run... (File > Compila ed esegui…) L'applicazione verrà caricata sul dispositivo e avviata al termine dell'installazione.
  3. Dovresti vedere il feed della videocamera sullo schermo del dispositivo.

Nel passaggio successivo inizierai ad aggiungere funzionalità alla tua app.

3. Rilevare gli aerei nel mondo reale

Ora che è stata configurata una scena di base, puoi iniziare a sviluppare il gioco. In questo passaggio, rileverai i piani e li disegnerai nella scena.

Aggiungere un componente ARPlaneManager

Un ARPlaneManager rileva ARPlane e crea, aggiorna e rimuove gli oggetti di gioco quando la comprensione dell'ambiente da parte del dispositivo cambia.

  1. Utilizzando il riquadro Gerarchia, crea un GameObject vuoto.
  2. Rinominalo in Driving Surface Manager. Questo componente mostrerà gli aerei finché uno non viene selezionato dal giocatore.
  3. Seleziona il nuovo oggetto di gioco. Nel riquadro Inspector, fai clic su Add Component (Aggiungi componente) per aggiungere un AR Plane Manager (Gestore piani AR).

  1. Configura ARPlaneManager impostando il campo Plane Prefab:
    1. Fai clic sul pulsante accanto a None per visualizzare la finestra Seleziona GameObject.
    2. Seleziona la scheda Asset e cerca Driving Surface Plane.

Questo prefab del pacchetto iniziale fornisce una texture del pavimento granulosa che verrà utilizzata come decorazione dell'aereo.

  1. Modifica Detection Mode in Horizontal. In questo modo, ARPlaneManager fornisce solo piani orizzontali, ideali per la guida.

Aggiungere un componente ARRaycastManager

Un ARRaycastManager espone la funzionalità di raycast. Nel passaggio successivo, utilizzeremo questo oggetto per fornire i controlli all'utente.

  1. Assicurati che l'oggetto denominato Driving Surface Manager sia selezionato nel riquadro Gerarchia.
  2. Nell'inspector, fai clic su Aggiungi componente per aggiungere un componente ARRaycastManager all'oggetto di gioco.

Non è necessaria alcuna ulteriore configurazione per questo componente.

Aggiungere un componente DrivingSurfaceManager

Un DrivingSurfaceManager è uno script helper del pacchetto iniziale che consente di selezionare un ARPlane. Una volta selezionato un ARPlane, tutti gli altri piani verranno nascosti e i nuovi piani verranno disattivati.

  1. Assicurati che l'oggetto denominato Driving Surface Manager sia selezionato nel riquadro Gerarchia.
  2. Nell'inspector, fai clic su Add Component (Aggiungi componente) per aggiungere un componente DrivingSurfaceManager al tuo oggetto di gioco.

Non è necessaria alcuna ulteriore configurazione per questo componente.

Esegui l'app

  1. Fai clic su File > Build ed esegui… per testare le modifiche.
  2. Punta il dispositivo verso una superficie orizzontale del mondo reale e muovilo per migliorare la comprensione del mondo da parte di ARCore.

  1. Quando ARCore ha rilevato un piano, dovresti vedere una texture di sporco che copre le superfici del mondo reale. ARPlaneManager crea un'istanza di Plane Prefab per ogni piano rilevato. Il prefab Driving Surface Plane ha un componente ARPlaneMeshVisualizer che crea una mesh per un determinato ARPlane.

Nel passaggio successivo, utilizzerai un piano rilevato come campo di gioco.

4. Eseguire un test di riscontro sugli aerei rilevati

Nel passaggio precedente, hai programmato un'applicazione in grado di rilevare gli aerei. Questi piani si riflettono nella scena del gioco. Ora aggiungerai interattività a questi piani creando un reticolo di puntamento e un'auto che si muoverà sulla superficie del piano rilevato.

Creare un reticolo di puntamento

Lo schema di controllo di questa app prevede che il giocatore punti lo smartphone verso una superficie. Per fornire un feedback visivo chiaro per la posizione designata, utilizzerai un reticolo di puntamento.

Per "incollare" questo reticolo a un piano AR, utilizza un test di riscontro. Un test di hit è una tecnica che calcola le intersezioni quando viene lanciato un raggio in una determinata direzione. Utilizzerai un test di rilevamento per individuare un incrocio nella direzione del campo visivo della videocamera.

Aggiungere il reticolo

  1. Nel riquadro Progetto nella parte inferiore dello schermo, vai a Risorse > Pacchetto iniziale.
  2. Inserisci il prefab del reticolo nella scena trascinandolo nel riquadro Gerarchia del progetto.
  3. Seleziona il reticolo nella gerarchia.
  4. Nell'inspector, fai clic su Aggiungi componente. Aggiungi lo script ReticleBehaviour dal pacchetto iniziale. Questo script contiene del codice standard per controllare il reticolo.
  5. Lo script ReticleBehaviour dipende da Driving Surface Manager che hai creato in precedenza, quindi aggiungi la dipendenza facendo clic sul selettore Driving Surface Manager. Seleziona la scheda Scena e scegli Driving Surface Manager.

Modifica ReticleBehaviour

Lo script ReticleBehavior posizionerà il reticolo sul piano al centro del riquadro del dispositivo.

  1. Apri lo script ReticleBehaviour.cs facendo doppio clic sul campo Script.
  2. Determina il centro dello schermo utilizzando il ViewToScreenPoint della fotocamera. Modifica il metodo Update() per aggiungere quanto segue:
var screenCenter = Camera.main.ViewportToScreenPoint(new Vector3(0.5f, 0.5f));
  1. Utilizza questo punto per eseguire un raycast. Aggiungi quanto segue:
var hits = new List<ARRaycastHit>();
DrivingSurfaceManager.RaycastManager.Raycast(screenCenter, hits, TrackableType.PlaneWithinBounds);

La variabile hits conterrà ARRaycastHit che descrivono i punti sui trackable intersecati da ray.

  1. Determina il punto di interesse dell'incrocio eseguendo una query sull'elenco hits. Dai la priorità al piano bloccato contenuto in DrivingSurfaceManager e, se non esiste, utilizza il primo piano rilevato. Aggiungi quanto segue alla fine di 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);
}
  1. Se hit contiene un risultato, sposta la trasformazione di GameObject nella posizione del riscontro.
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);

Testa il reticolo

  1. Fai clic su File > Build ed esegui… per testare le modifiche.
  2. Quando punti il dispositivo verso un aereo, dovresti vedere il reticolo seguire i movimenti della fotocamera.

Crea un'auto

Il giocatore controllerà un'auto giocattolo che si dirigerà verso la posizione del mirino. Un modello e un comportamento per questa auto sono forniti nel pacchetto iniziale.

Aggiungere un CarManager alla scena

  1. Nella gerarchia, crea un nuovo GameObject vuoto.
  2. Rinominalo in Car Spawner.
  3. Seleziona l'oggetto che hai creato. Nel riquadro Gerarchia, fai clic su Aggiungi componente per aggiungere il componente CarManager.
  4. Configura le dipendenze di CarManager facendo clic sul selettore per ogni campo:
    • Prefab auto: in Asset, seleziona Prefab auto.
    • Reticolo: in Scena, seleziona Reticolo prefab.
    • Driving Surface Manager: in Scena, seleziona Driving Surface Manager.

Questo comportamento di CarManager genera una macchinina sul piano su cui si trova il mirino. Se vuoi, dai un'occhiata allo script CarBehaviour per scoprire come è programmata l'auto.

Test drive

  1. Fai clic su File > Build And Run (Compila ed esegui) per testare le modifiche.
  2. Quando tocchi un aereo, dovresti vedere una piccola auto in quella posizione. Questa auto seguirà il reticolo.

Aggiungere l'elemento di gioco

Ora che il giocatore può controllare un'entità nella scena, dagli una destinazione da raggiungere.

  1. Crea un nuovo GameObject vuoto nella gerarchia.
  2. Rinominalo in Package Spawner.
  3. Seleziona l'oggetto che hai creato. Nel riquadro Gerarchia, fai clic su Aggiungi componente per aggiungere il componente PackageSpawner.
  4. Configura le dipendenze di PackageSpawner facendo clic sul selettore per ogni campo:
    • Package Prefab: in Asset, seleziona Package Prefab.
    • Driving Surface Manager: in Scena, seleziona Driving Surface Manager.

Questo comportamento di PackageSpawner genera un nuovo pacchetto in una posizione casuale su un ARPlane bloccato se non è già presente un pacchetto.

Testare il gioco

  1. Fai clic su File > Build And Run (Compila ed esegui) per testare le modifiche. 2. Dopo aver creato un'auto, dovrebbe comparire un pacchetto.
  2. Guida l'auto fino al pacco.
  3. Ne verrà visualizzato uno nuovo in una posizione casuale.

5. Configurare la stima dell'illuminazione

Ora che il gioco di base è stato completato, aggiungi un tocco di realismo alla tua scena AR. In questo passaggio, utilizzerai l'API Lighting Estimation di ARCore per rilevare l'illuminazione presente nel mondo reale in base ai frame della videocamera in entrata. Queste informazioni verranno utilizzate per adattare l'illuminazione della scena in modo che corrisponda a quella del mondo reale.

Attiva la stima dell'illuminazione

  1. In Gerarchia, espandi Origine sessione AR e seleziona l'oggetto Fotocamera AR.
  2. In Inspector, espandi lo script AR Camera Manager.
  3. Modifica il campo Stima illuminazione in Tutto.

Modificare la luce direzionale

  1. In Gerarchia, seleziona l'oggetto Luce direzionale.
  2. Aggiungi il componente LightEstimation. Questo componente del pacchetto iniziale fornisce un boilerplate per l'iscrizione alle modifiche dell'illuminazione.
  3. Nella funzione FrameReceived(), aggiungi:
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;
}

Testare le modifiche

  1. Fai clic su File > Build And Run (Compila ed esegui) per testare le modifiche.
  2. Quando osservi gli oggetti nella scena, potresti notare che sono colorati a seconda dell'illuminazione dell'ambiente.
  3. Se possibile, prova a modificare l'illuminazione. Ad esempio, prova a spegnere le luci della stanza in cui ti trovi. Dovresti notare che l'illuminazione degli oggetti si adatta al cambiamento dell'illuminazione nel mondo reale.

6. Conclusione

Complimenti! Hai raggiunto la fine di questo codelab su Unity AR Foundation.

Argomenti trattati

  • Come configurare un progetto di base utilizzando AR Foundation di Unity e la pipeline di rendering universale.
  • Come utilizzare ARPlaneManager per abbonarsi a nuovi piani.
  • Come utilizzare Raycast per trovare intersezioni con la geometria virtuale.
  • Come utilizzare ARLightEstimationData per illuminare la scena.

Passaggi successivi

Assegnazioni bonus

Se vuoi ampliare il gioco che hai creato qui, ecco alcune idee che potresti seguire:

  • Aggiungi un contatore di punteggio al tuo gioco modificando un TextMeshPro quando un PackageManager genera un nuovo pacchetto.
  • Controlla le informazioni sul rendimento durante l'esecuzione del gioco attivando la sovrapposizione delle prestazioni.
  • Utilizza Persistent Raycasts per posizionare prima i nuovi oggetti nella scena. Quando viene rilevato un piano in quell'area, l'oggetto si aggiorna per agganciarsi a quel piano.