Guida allo sviluppo OpenXR

OpenXR è uno standard di interfaccia XR (VR/AR/MR) aperto e libero da royalty definito e mantenuto dal Khronos Group. Il suo obiettivo principale è consentire agli sviluppatori di "scrivere una volta, eseguire ovunque", risolvendo il problema della frammentazione dovuto al fatto che dispositivi diversi hanno ciascuno il proprio set di API. L'LCC Unity SDK ora supporta lo standard OpenXR, quindi può eseguire il rendering dei dati 3DGS su dispositivi compatibili con OpenXR senza un SDK fornito da un produttore di dispositivi VR specifico.

Requisiti di versione

Di seguito sono indicate le versioni di software e plugin utilizzate in questa guida. Si consiglia di sviluppare con le stesse versioni; altre versioni non testate potrebbero presentare problemi di compatibilità:

Nota:

1. OpenXR è uno standard, e vari produttori di dispositivi VR possono supportare tutte le sue funzionalità o solo una parte, quindi è necessario verificare lo stato di supporto del dispositivo specifico prima di usarlo.
2. Lo standard OpenXR definisce specifiche tecniche comuni, ma le funzionalità specifiche del dispositivo richiedono comunque il supporto dell'SDK del produttore o dell'OpenXR Extension del produttore, come ATW (Asynchronous Time Warp), PTW (Late Stage Reprojection) e altre tecnologie che migliorano la fluidità tra i fotogrammi.
3. Questa guida mostra principalmente lo sviluppo OpenXR su dispositivi VR reali; l'LCC Unity SDK non supporta lo sviluppo di applicazioni desktop OpenXR (ad eccezione del PCVR).

Flusso di lavoro di sviluppo

Passaggio 1: Creare un progetto URP

Seleziona il tipo Universal 3D (pipeline di rendering URP) nel modello di progetto, come mostrato di seguito:

Crea un progetto Universal 3D

Passaggio 2: Cambiare la piattaforma

Dopo aver creato il progetto, seleziona File → Build Profiles dal menu di Unity per aprire la finestra di build e passa la piattaforma ad Android, come mostrato di seguito:

Passa la piattaforma ad Android in Build Profiles

Passaggio 3: Importare Unity OpenXR

Apri la finestra UPM tramite il menu di Unity Finestra → Gestione pacchetti, seleziona Unity Registry nell'elenco a sinistra, inserisci OpenXR nella casella di ricerca, seleziona OpenXR Plugin dai risultati della ricerca e installalo, come mostrato di seguito:

Installa l'OpenXR Plugin da Unity Registry

Passaggio 4: Importare XR Interaction Toolkit

Seleziona Unity Registry nell'elenco a sinistra, inserisci XR nella casella di ricerca, seleziona XR Interaction Toolkit dai risultati della ricerca e installalo, come mostrato di seguito:

Installa XR Interaction Toolkit da Unity Registry

Passaggio 5: Importare l'LCC Unity SDK

Apri la finestra UPM tramite il menu di Unity Finestra → Gestione pacchetti, fai clic su ＋ a sinistra, seleziona Installa pacchetto da disco dal menu a discesa, individua l'LCC Unity SDK e seleziona il file package.json da importare, come mostrato di seguito:

Importa l'LCC Unity SDK tramite Installa pacchetto da disco

Passaggio 6: Configurare l'ambiente Unity

Configurare XR Plug-in Management (piattaforma Android)

Seleziona File → Project Settings dalla barra dei menu di Unity, seleziona XR Plug-in Management a sinistra, spunta OpenXR nella scheda della piattaforma Android e spunta Initialize XR on Startup, come mostrato di seguito:

Spunta OpenXR e Initialize XR on Startup sulla piattaforma Android

Configurare XR Plug-in Management (piattaforma Desktop)

Poiché l'LCC Unity SDK non supporta lo sviluppo OpenXR desktop, non spuntare OpenXR né Initialize XR on Startup sulla piattaforma Desktop, come mostrato di seguito:

Non spuntare OpenXR o Initialize XR on Startup sulla piattaforma Desktop

Nota: Per il PCVR desktop, consulta Streaming PCVR.

Configurare la modalità di rendering e la configurazione dell'interazione OpenXR

Seleziona la voce OpenXR in XR Plug-in Management e imposta la Render Mode della piattaforma Android su Single Pass Instanced o Multi-View. Poiché OpenXR richiede l'impostazione degli Interaction Profiles, di solito seleziona Oculus Touch Controller Profile o un profilo con caratteristiche prestazionali del dispositivo simili, come mostrato di seguito:

Imposta la Render Mode e gli Interaction Profiles OpenXR

Project Validation

Seleziona la voce Project Validation in XR Plug-in Management e fai clic su Fix All per completare le impostazioni necessarie (puoi anche lasciarle non gestite per ora e crearle manualmente in seguito), come mostrato di seguito:

Fai clic su Fix All in Project Validation

Configurare Player (piattaforma Desktop)

Seleziona Player a sinistra di Project Settings, passa alla piattaforma Desktop, espandi la sezione Other Settings, deseleziona Auto Graphics API, imposta Graphics APIs su Direct3D12, Vulkan, Direct3D11 e rimuovi le altre API grafiche; imposta Color Space su Gamma, come mostrato di seguito:

Imposta le API grafiche e lo spazio colore Gamma sulla piattaforma Desktop

Nota: Alcuni dispositivi VR non supportano lo spazio colore Gamma; in tal caso puoi scegliere solo lo spazio colore Linear, e le scene LCC renderizzate nello spazio colore Linear appariranno leggermente slavate.

Configurare Player (piattaforma Android)

Seleziona Player a sinistra di Project Settings, passa alla piattaforma Android, espandi la sezione Other Settings, deseleziona Auto Graphics API, imposta Graphics APIs su Vulkan e rimuovi le altre API grafiche; imposta Color Space su Gamma, come mostrato di seguito:

Imposta l'API grafica su Vulkan e lo spazio colore Gamma sulla piattaforma Android

Impostare lo scripting backend e l'input della piattaforma Android

Scorri verso il basso nella scheda Other Settings della piattaforma Android e imposta Minimum API Level = Android 12L (API Level 32) o superiore, Scripting Backend = IL2CPP, Target Architectures = ARM64, Active Input Handling = Input System Package (New) o Both, come mostrato di seguito:

Imposta Minimum API Level, Scripting Backend, Target Architectures e Active Input Handling

Controllare Graphics e Quality

Seleziona Graphics a sinistra di Project Settings e controlla il Render Asset corrispondente alla Default Render Pipeline usata dalla piattaforma Mobile, Mobile_RPAsset in questo esempio, come mostrato di seguito:

Controlla il Render Asset della Default Render Pipeline sulla piattaforma Mobile

Seleziona Quality a sinistra di Project Settings, controlla il Render Asset corrispondente alla Default Render Pipeline usata dalla piattaforma Mobile (Mobile_RPAsset in questo esempio), imposta Resolution Scaling Fixed DPI Factor = 0.7, VSync Count = Don't Sync, come mostrato di seguito:

Imposta DPI Factor e VSync in Quality

Configurare il Render Asset

Trova il Render Asset corrispondente alla Default Render Pipeline usata dalla piattaforma Mobile (Mobile_RPAsset in questo esempio), seleziona l'Asset e, nella finestra delle proprietà (Inspector): deseleziona Depth Texture, Opaque Texture, HDR; imposta Anti Aliasing (MSAA) = Disabled, Render Scale = 0.7, Upscaling Filter = Automatic, come mostrato di seguito:

Disattiva Depth/Opaque Texture, HDR, MSAA e imposta Render Scale = 0.7 nel Render Asset

Trova il Renderer corrispondente a questo Render Asset, Mobile_Renderer (Universal Renderer Data) in questo esempio, e impostane le relative proprietà nella finestra delle proprietà (Inspector), come mostrato di seguito:

Configura le proprietà di Mobile_Renderer (Universal Renderer Data)

Passaggio 7: Creare la scena

Crea una scena completamente nuova in Unity, elimina Camera principale e Luce direzionale, fai clic con il pulsante destro in un'area vuota della finestra Gerarchia e seleziona XR → XR Origin (VR) dal menu a comparsa per creare gli oggetti XR necessari.

Passaggio 8: Configurare la scena

Seleziona il GameObject XR Origin (VR) nella finestra Gerarchia e, nel componente XR Origin della finestra delle proprietà (Inspector), imposta Tracking Origin Mode su Floor; le altre proprietà rilevanti sono come mostrato di seguito:

Imposta Tracking Origin Mode di XR Origin su Floor

Seleziona il GameObject Camera principale sotto XR Origin (VR) nella finestra Gerarchia e imposta le proprietà del componente Camera nella finestra delle proprietà (Inspector): Clipping Planes Near = 0.3, Far = 5000; Anti-aliasing = No Anti-aliasing; Opaque Texture = Off, Depth Texture = Off; Background Type = Solid Color, Background = nero; HDR = Off, MSAA = Off; le altre proprietà sono come mostrato di seguito:

Imposta le proprietà del componente Camera della Camera principale sotto XR Origin (VR)

Passaggio 9: Scrivere il codice per caricare la scena

Fai clic con il pulsante destro su Crea vuoto nella finestra Gerarchia per creare un oggetto vuoto, denominalo LCCManager, normalizza il suo Transform e collega lo script LCCManager tramite Aggiungi componente, come mostrato di seguito:

Crea un oggetto vuoto LCCManager e collega lo script LCCManager

Fai clic con il pulsante destro su Crea vuoto nella finestra Gerarchia per creare un altro oggetto vuoto, denominalo LCCRenderer e imposta il suo Transform con Rotation.x = -90, Scale.x = -1, come mostrato di seguito:

Crea un oggetto vuoto LCCRenderer e imposta Rotation.x = -90 e Scale.x = -1 per allineare i sistemi di coordinate

Rotation.x = -90 e Scale.x = -1 sono la trasformazione di allineamento dal sistema di coordinate dei dati LCC (Z in alto, destrorso) al sistema di coordinate di Unity (Y in alto, sinistrorso); vedi "Sistema di coordinate dei dati LCC" in Introduzione all'Unity SDK.

A questo punto, la struttura dei GameObject nella finestra Gerarchia è come mostrato di seguito:

La struttura della finestra Gerarchia

Scrivi uno script C# denominato LCCRenderer.cs con il seguente codice:

using LCCCore;
using UnityEngine;
using UnityEngine.XR;

public class LCCRenderer : MonoBehaviour
{
    public LCCManager m_manager;
    public string m_FilePath;

    private LCCCore.Renderer m_renderer;

    void Start()
    {
#if UNITY_EDITOR
        m_manager.SetPlatformType(PlatformType.PC);
        m_renderer = m_manager.GetRender(this.gameObject.transform);
        m_renderer.Load(m_FilePath, onProgress, onLoaded);
#else
        m_manager.SetPlatformType(PlatformType.OpenXR);
        m_renderer = m_manager.GetRender(this.gameObject.transform);
        m_renderer.Load($"{Application.persistentDataPath}/LccData/meta.lcc2", onProgress, onLoaded);
#endif
    }

    private void onProgress(float v)
    {
        Debug.Log("avanzamento:" + v);
    }

    private void onLoaded()
    {
        m_manager.SetStartLod(2);
        m_renderer.SetEnvironment(false);
        Debug.Log("Dati caricati");
    }
}

Collega lo script al GameObject LCCRenderer nella finestra Gerarchia, quindi trascina il GameObject LCCManager sulla proprietà Manager dello script nella finestra delle proprietà (Inspector) e infine inserisci il percorso del file LCC.

Per facilitare il debug nell'Editor di Unity e la creazione diretta del pacchetto per un dispositivo Android, il codice usa macro di compilazione per distinguere l'ambiente di runtime: nell'Editor di Unity usa direttamente l'indirizzo specificato da m_FilePath; su un dispositivo Android usa l'origine dati sul dispositivo. Il modo per collocare i dati sul dispositivo è:

1. Esegui l'app compilata sul dispositivo VR una volta.
2. Dopo l'installazione dell'app, accedi alla sua directory dati (generalmente memoria del dispositivo → Android → data → BundleID dell'app → Files; consulta il percorso di installazione delle app Android per la directory specifica) e crea una cartella LccData nella sottodirectory Files.
3. Copia tutte le origini dati LCC nella cartella LccData.

Nota: In pratica, si consiglia di collocare l'origine dati dell'app su un server invece di pacchettizzarla direttamente nell'app.

Pratiche di ottimizzazione

Seguendo i passaggi precedenti i dati LCC vengono renderizzati normalmente sul dispositivo VR, ma ci sono due problemi principali:

Visualizzazione della finestra app 2D

Le app sviluppate secondo lo standard OpenXR senza un SDK del produttore del dispositivo non sono necessariamente riconosciute come app 3D sui dispositivi VR; in genere il sistema del dispositivo VR le tratta come app 2D, quindi viene visualizzata una finestra app 2D. Ci sono due approcci per risolvere questo problema:

• Introdurre un SDK del produttore del dispositivo o un'estensione OpenXR del produttore; il software del produttore del dispositivo gestirà quindi i problemi correlati.
• Personalizzare AndroidManifest.xml.

I passaggi specifici per personalizzare il Manifest sono: seleziona Player a sinistra di Project Settings, passa alla piattaforma Android, espandi la sezione Publishing Settings, spunta Custom Main Manifest, che genererà un file Manifest personalizzato, come mostrato di seguito:

Spunta Custom Main Manifest per generare un file Manifest personalizzato

Trova il file AndroidManifest.xml e aggiungi il marcatore VR affinché il dispositivo VR lo riconosca come app 3D immersiva, e l'app avviata verrà visualizzata come spazio 3D. Esempio:

<?xml version="1.0" encoding="utf-8"?>
<manifest
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">
    <application>

        <!--Usato quando Application Entry è impostato su GameActivity, altrimenti rimuovi questo blocco activity-->
        <activity android:name="com.unity3d.player.UnityPlayerGameActivity"
                  android:theme="@style/BaseUnityGameActivityTheme"
                  android:resizeableActivity="false">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
                <category android:name="org.khronos.openxr.intent.category.IMMERSIVE_HMD" />
            </intent-filter>
            <meta-data android:name="unityplayer.UnityActivity" android:value="true" />
            <meta-data android:name="android.app.lib_name" android:value="game" />
        </activity>
    </application>
</manifest>

Scatti quando il frame rate di rendering è inferiore a 90FPS

Lo standard OpenXR stesso non definisce l'interpolazione dei fotogrammi, lo smoothing o contenuti correlati; quando il frame rate non riesce a raggiungere 90FPS, si avvertirà un notevole senso di scatti durante la rotazione della testa o il movimento. Per offrire un'esperienza migliore, soprattutto per migliorare la fluidità con prestazioni hardware limitate, i produttori di dispositivi di solito forniscono tecniche come tweening, interpolazione dei fotogrammi e smoothing, come ATW (Asynchronous Time Warp), PTW (Late Stage Reprojection), ecc.

Se il dispositivo supporta OpenXR, i produttori di solito forniscono un'OpenXR Extension o un SDK che supporta direttamente OpenXR; in questo caso è meglio introdurre l'SDK del produttore del dispositivo per un'esperienza più fluida.

Riferimenti correlati

• Per le impostazioni di progetto e l'ottimizzazione delle prestazioni, consulta i capitoli Guida all'ottimizzazione delle impostazioni di progetto e Guida ai parametri di prestazione del rendering.
• La capacità di rendering su schermo del dispositivo VR per la 3DGS è di circa 700.000 primitive gaussiane; quando si renderizzano scene grandi, si consiglia di impostare StartLOD su 2 e di disabilitare la visualizzazione dei dati ambiente; le scene grandi saranno più fluide con lo streaming PC.