Daniele Ferla

Da poco (13 ottobre 2020) messo in commercio il nuovo visore Oculus Quest 2 (by Facebook) e già possibile interfacciarlo a Unity attraverso gli ultimi aggiornamenti di Oculus Integration Toolkit. Vediamo quindi i passi per poter configurare un ambiente di sviluppo valido e ben ottimizzato per lo sviluppo di app e giochi per la realtà virtuale su Oculus Quest.

Installare Unity 2020 e Android Studio

• Scaricare e installare Unity Hub
• Accedere al menu Install e installare l’ultima versione di Unity disponibile (la 2020)
• Assicurarsi di aver selezionato tra i moduli aggiuntivi anche la voce Android Build Studio e le due sottostanti Android SDK e NDK Tools e OpenJDK

Configurare Unity e l’ambiente di sviluppo

• Tramite lo Unity Hub creare un nuovo progetto avendo cura di selezionare l’ultima versione di Unity installata
• Accedere poi al menu File -> Build Settings e cambiare la modalità di compilazione da PC, Mac Linux Standalone in Android avendo cura di cambiare anche la voce Texture Compression in ASTC
• Non avviare il processo di Build per ora
• Accedere al menu Edit -> Project Settings / Player e sotto la cartella Other Settings / Rendering Graphics APIs rimuovere Vulkan
• Alla voce Identification / Override Default Package Name spuntare la casella ed inserire un nome di Package valido, ad esempio com.desdinova.oculusquestdemo
• Accedere ora al menu Window -> Asset Store e ricercare l’asset gratuito Oculus Integration e aggiungelo al progetto importandolo (installarà nel vostro progetto tutti gli asset e gli script necessari per sviluppare un applicativo per Oculus, prendendosi diversi minuti, anche 15/20)
• Potrebbe venir chiesto di abilitare e aggironare alcuni aggiornamenti di plugin OVR, confermando verrà chiesto di riavviare Unity
• Per testare velocemente una scena già impostata accedere al pannello Project -> Oculus -> VR – Scenes e caricare una delel scene presenti di demo

Sbloccare la funzionalità Sviluppatore di Oculus Quest

• Scaricare e installare la app Oculus App sul proprio dispositivo smartphone
• Associare il proprio visore Oculus Quest 2 attraverso la funzionalità di associazione automatica
• Accedere ad Impostazioni -> Altre Impostazioni -> attivare la voce Modo Sviluppatore
• Se non avete un certificato accedere online a Developer Certificate e creare un proprio certificato valido (solo la prima volta)

Installare e configurare SideQuest

• Accedere al sito SideQuest e installare l’ultima versione disponibile per Windows
• Assicurarsi di aver acceso e messo fuori dallo standby il dispositivo Oculus Quest 2
• Collegare il dispositivo tramite USB al computer
• Il software SideQuest dovrebbe riconoscerlo in automatico (barra in alto a sinistra)
• Nel menu in alto a destra selezionare l’icona con una cartella e una freccia verso il basso dal nome “Installa APK file from folder on computer”
• A questo punto cercare la vostra build .apk e attendete che venga copiata sul dispositivo (noterete una barra verde sul fondo di Side Quest).

Testare il progetto su Oculus Quest 2

• Scollegare dalla USB il visore ed indossatelo
• Accedere allo store interno dell’Oculus Quest avendo cura di filtrare (casellina in alto a destra) per “Non riconosciute” (cioè tutte quelle app non ufficiali).
• Nell’elenco avviare l’applicazione (che riporterà il nome definito nei primi passaggi)

Sappiamo che in Unity è doveroso implementare ogni azione utilizzando Time.deltaTime (qui un approfondimento) in modo da renderle dipendenti dal tempo e non dal frame rate.

La funzione Mathf.Lerp viene usata per ottenere un valore comprensivo tra un valore iniziale e uno finale, dipendente da un valore arbitrario tra 0 e 1. Se il valore passato a Mathf.Lerp è 0 verrà ritornato il valore iniziale, se il valore è 1 verrà ritornato il valore finale. Tutti i valori intermedi tra 0 e 1 generano invece un risultato compreso tra l’iniziale e il finale, pesato tra i due valori.

Questa funzione quindi si rende utile quando serve realizzare una transizione tra due valori noti. Si provi a pensare la necessità di eseguire una dissolvenza (fade) di un colore passando da alpha = 255 a alpha = 0. La funzione sarebbe quindi Mathf.Lerp(255, 0, t) dove t è un valore compreso tra 0 e 1. Passando 0.5 si otterrà quindi, ad esempio, 125.

La funzione sottostante in pseudo-codice mostra come, dato il valore della durata della transizione (5.0f secondi) è possibile ottenere un valore alpha interpolato, dipendente dal tempo trascorso (ecco perchè Time.deltaTime).

        var t = 0f;
        var duration = 5.0f
        while (t < 1)
        {
            t += Time.deltaTime / duration;
            endColor.a = Mathf.Lerp(startColor.a, 0, t);
            this.FadePanel.GetComponent<RawImage>().color = endColor;
        }

Tutte le volte che dobbiamo quindi eseguire una transazione (cambiare un colore, generare una rotazione, spostare da un punto A ad uno B, il consiglio è sempre quello di utilizzare la funzione Mathf.Lerp (esiste quella specifica Mathf.LerpAngle per gli angoli che tiene conto della rotazione a 360°) facendo dipendere il valore t da Time.deltaTime in modo da rendere la transizione smooth ma anche regolata dal tempo.

Una delle prime complessità che ci si trova ad affrontare approcciandosi allo sviluppo di un videogame in Unity è la questione di rendere l’azione dipendente dal tempo o dai frame (Frame Dependant o Time Dependant). Tutto questo viene risolto analizzando questi due tipi di script che di fatto hanno un’unica differenza, cioè l’uso di Time.deltaTime nella funzione Update().

1. //1. Con time.deltaTime
2. transform.position = Vector3.Lerp(transform.position, target, smoothing * Time.deltaTime);
4. //2. Senza time.deltaTime
5. transform.position = Vector3.Lerp(transform.position, target, smoothing);

In sostanza, nel primo caso si sta dicendo che si vuole muovere il proprio oggetto con una velocità dipendente dal tempo (ad esempio metri al secondo). Questo garantisce che qualsiasi cosa accada durante (ad esempio un rallentamento dei frame dovuto a grafica eccessiva), l’azione da eseguire venga comunque compiuta rispetto al tempo a lei destinata.

Il seconda caso invece, senza Time.deltaTime, rende l’azione dipendente da frame e non dal tempo. Se dovessimo eseguire il codice su di una macchina lenta l’azione verrebbe eseguita più lentamente rispetto se eseguita su una macchina più veloce e performante. In alcuni casi il tutto potrebbe risultare “ingiocabile”.

E’ buona norma quindi utilizzare Time.deltaTime per ogni azione presente nel nostro applicativo al fine di renderla dipendente dal tempo e non dai frame. Ci sono alcune circostanze in cui può essere utile rendere l’applicativo dipendente dai frames ma sono più eccezioni che realtà.