Guide de développement OpenXR

OpenXR est un standard d'interface XR (VR/AR/MR) ouvert et libre de redevance, défini et maintenu par le groupe Khronos. Son objectif principal est de permettre aux développeurs d'« écrire une fois, exécuter partout », résolvant ainsi le problème de fragmentation où chaque appareil possède son propre ensemble d'API. Le LCC Unity SDK prend désormais en charge le standard OpenXR, ce qui lui permet de rendre des données 3DGS sur des appareils compatibles OpenXR sans SDK fourni par un fabricant d'appareil VR spécifique.

Exigences de version

Les versions de logiciels et de plugins utilisées dans ce guide sont les suivantes. Il est recommandé de développer avec les mêmes versions ; d'autres versions non testées peuvent présenter des problèmes de compatibilité :

Logiciel / Plugin	Version
Unity	v6000.0.69f1
LCC Unity SDK	v2.3.0 et versions ultérieures

Remarque :
OpenXR est un standard, et les différents fabricants d'appareils VR peuvent prendre en charge toutes ses fonctionnalités ou seulement une partie d'entre elles ; vous devez donc vérifier l'état de prise en charge de l'appareil spécifique avant de l'utiliser.
Le standard OpenXR définit des spécifications techniques communes, mais les fonctionnalités spécifiques à un appareil nécessitent toujours le SDK du fabricant ou une extension OpenXR du fabricant, telles que ATW (Asynchronous Time Warp), PTW (Late Stage Reprojection) et d'autres technologies qui améliorent la fluidité entre les images.
Ce guide démontre principalement le développement OpenXR sur de vrais appareils VR ; le LCC Unity SDK ne prend pas en charge le développement d'applications de bureau OpenXR (à l'exception du PCVR).

Flux de travail de développement

Étape 1 : Créer un projet URP

Sélectionnez le type Universal 3D (pipeline de rendu URP) dans le modèle de projet, comme illustré ci-dessous :

Créer un projet Universal 3D

Étape 2 : Basculer de plateforme

Une fois le projet créé, sélectionnez Fichier → Build Profiles dans le menu Unity pour ouvrir la fenêtre de compilation, et basculez la plateforme vers Android, comme illustré ci-dessous :

Basculer la plateforme vers Android dans Build Profiles

Étape 3 : Importer Unity OpenXR

Ouvrez la fenêtre UPM via le menu Unity Fenêtre → Package Manager, sélectionnez Unity Registry dans la liste de gauche, saisissez OpenXR dans la zone de recherche, sélectionnez OpenXR Plugin dans les résultats et installez-le, comme illustré ci-dessous :

Installer l'OpenXR Plugin depuis Unity Registry

Étape 4 : Importer XR Interaction Toolkit

Sélectionnez Unity Registry dans la liste de gauche, saisissez XR dans la zone de recherche, sélectionnez XR Interaction Toolkit dans les résultats et installez-le, comme illustré ci-dessous :

Installer XR Interaction Toolkit depuis Unity Registry

Étape 5 : Importer le LCC Unity SDK

Ouvrez la fenêtre UPM via le menu Unity Fenêtre → Package Manager, cliquez sur ＋ à gauche, sélectionnez Install package from disk dans le menu déroulant, localisez le LCC Unity SDK, puis sélectionnez le fichier package.json pour l'importer, comme illustré ci-dessous :

Importer le LCC Unity SDK via Install package from disk

Étape 6 : Configurer l'environnement Unity

Configurer XR Plug-in Management (plateforme Android)

Sélectionnez Fichier → Paramètres du projet dans la barre de menus Unity, sélectionnez XR Plug-in Management à gauche, cochez OpenXR sous l'onglet de la plateforme Android, et cochez Initialize XR on Startup, comme illustré ci-dessous :

Cocher OpenXR et Initialize XR on Startup sur la plateforme Android

Configurer XR Plug-in Management (plateforme Desktop)

Étant donné que le LCC Unity SDK ne prend pas en charge le développement OpenXR de bureau, ne cochez pas OpenXR ni Initialize XR on Startup sous la plateforme Desktop, comme illustré ci-dessous :

Ne pas cocher OpenXR ni Initialize XR on Startup sur la plateforme Desktop

Remarque : pour le PCVR de bureau, reportez-vous à Streaming PCVR.

Configurer le mode de rendu OpenXR et la configuration d'interaction

Sélectionnez l'élément OpenXR sous XR Plug-in Management, et définissez le Render Mode de la plateforme Android sur Single Pass Instanced ou Multi-View. Étant donné qu'OpenXR nécessite de définir des Interaction Profiles, sélectionnez généralement Oculus Touch Controller Profile ou un profil aux caractéristiques de performance similaires, comme illustré ci-dessous :

Définir le Render Mode OpenXR et les Interaction Profiles

Project Validation

Sélectionnez l'élément Project Validation sous XR Plug-in Management, et cliquez sur Fix All pour compléter les paramètres nécessaires (vous pouvez aussi le laisser non traité pour l'instant et le créer manuellement plus tard), comme illustré ci-dessous :

Cliquer sur Fix All dans Project Validation

Configurer Player (plateforme Desktop)

Sélectionnez Player à gauche de Paramètres du projet, basculez vers la plateforme Desktop, déployez la section Other Settings, décochez Auto Graphics API, définissez Graphics APIs sur Direct3D12, Vulkan, Direct3D11, et supprimez les autres API graphiques ; définissez Color Space sur Gamma, comme illustré ci-dessous :

Définir les API graphiques et l'espace colorimétrique Gamma sur la plateforme Desktop

Remarque : certains appareils VR ne prennent pas en charge l'espace colorimétrique Gamma ; dans ce cas, vous ne pouvez choisir que l'espace colorimétrique Linear, et les scènes LCC rendues dans l'espace colorimétrique Linear paraîtront légèrement délavées.

Configurer Player (plateforme Android)

Sélectionnez Player à gauche de Paramètres du projet, basculez vers la plateforme Android, déployez la section Other Settings, décochez Auto Graphics API, définissez Graphics APIs sur Vulkan, et supprimez les autres API graphiques ; définissez Color Space sur Gamma, comme illustré ci-dessous :

Définir l'API graphique sur Vulkan et l'espace colorimétrique Gamma sur la plateforme Android

Définir le backend de script et la saisie de la plateforme Android

Faites défiler l'onglet Other Settings de la plateforme Android vers le bas, et définissez Minimum API Level = Android 12L (API Level 32) ou supérieur, Scripting Backend = IL2CPP, Target Architectures = ARM64, Active Input Handling = Input System Package (New) ou Both, comme illustré ci-dessous :

Définir Minimum API Level, Scripting Backend, Target Architectures et Active Input Handling

Vérifier Graphismes et Qualité

Sélectionnez Graphismes à gauche de Paramètres du projet, et vérifiez le Render Asset correspondant au Default Render Pipeline utilisé par la plateforme Mobile, Mobile_RPAsset dans cet exemple, comme illustré ci-dessous :

Vérifier le Render Asset du Default Render Pipeline sur la plateforme Mobile

Sélectionnez Qualité à gauche de Paramètres du projet, vérifiez le Render Asset correspondant au Default Render Pipeline utilisé par la plateforme Mobile (Mobile_RPAsset dans cet exemple), définissez Resolution Scaling Fixed DPI Factor = 0.7, VSync Count = Don't Sync, comme illustré ci-dessous :

Définir le DPI Factor et VSync dans Qualité

Configurer le Render Asset

Trouvez le Render Asset correspondant au Default Render Pipeline utilisé par la plateforme Mobile (Mobile_RPAsset dans cet exemple), sélectionnez l'Asset, et dans la fenêtre de propriétés (Inspecteur) : décochez Depth Texture, Opaque Texture, HDR ; définissez Anti Aliasing (MSAA) = Disabled, Render Scale = 0.7, Upscaling Filter = Automatic, comme illustré ci-dessous :

Désactiver Depth/Opaque Texture, HDR, MSAA et définir le Render Scale dans le Render Asset

Désactiver Depth/Opaque Texture, HDR, MSAA et définir Render Scale = 0.7 dans le Render Asset

Trouvez le Renderer correspondant à ce Render Asset, Mobile_Renderer (Universal Renderer Data) dans cet exemple, et définissez ses propriétés pertinentes dans la fenêtre de propriétés (Inspecteur), comme illustré ci-dessous :

Configurer les propriétés de Mobile_Renderer (Universal Renderer Data)

Étape 7 : Créer la scène

Créez une toute nouvelle scène dans Unity, supprimez la Caméra principale et la Lumière directionnelle, faites un clic droit dans une zone vide de la fenêtre de hiérarchie (Hiérarchie), et sélectionnez XR → XR Origin (VR) dans le menu contextuel pour créer les objets XR nécessaires.

Étape 8 : Configurer la scène

Sélectionnez le GameObject XR Origin (VR) dans la fenêtre de hiérarchie (Hiérarchie), et dans le composant XR Origin de la fenêtre de propriétés (Inspecteur), définissez Tracking Origin Mode sur Floor ; les autres propriétés pertinentes sont comme illustré ci-dessous :

Définir le Tracking Origin Mode de XR Origin sur Floor

Sélectionnez le GameObject Caméra principale sous XR Origin (VR) dans la fenêtre de hiérarchie (Hiérarchie), et définissez les propriétés du composant Camera dans la fenêtre de propriétés (Inspecteur) : Clipping Planes Near = 0.3, Far = 5000 ; Anti-aliasing = No Anti-aliasing ; Opaque Texture = Off, Depth Texture = Off ; Background Type = Solid Color, Background = noir ; HDR = Off, MSAA = Off ; les autres propriétés sont comme illustré ci-dessous :

Définir les propriétés du composant Camera de la Caméra principale sous XR Origin (VR)

Étape 9 : Écrire le code pour charger la scène

Faites un clic droit Créer vide dans la fenêtre de hiérarchie (Hiérarchie) pour créer un objet vide, nommez-le LCCManager, normalisez son Transform, et attachez le script LCCManager via Ajouter un composant, comme illustré ci-dessous :

Créer un objet vide LCCManager et attacher le script LCCManager

Faites un clic droit Créer vide dans la fenêtre de hiérarchie (Hiérarchie) pour créer un autre objet vide, nommez-le LCCRenderer, et définissez son Transform Rotation.x = -90, Scale.x = -1, comme illustré ci-dessous :

Créer un objet vide LCCRenderer et définir le Transform pour l'alignement du système de coordonnées

Créer un objet vide LCCRenderer, et définir Rotation.x = -90 et Scale.x = -1 pour aligner les systèmes de coordonnées

Rotation.x = -90 et Scale.x = -1 constituent la transformation d'alignement du système de coordonnées des données LCC (axe Z vers le haut, droitier) vers le système de coordonnées Unity (axe Y vers le haut, gaucher) ; voir « Système de coordonnées des données LCC » dans Introduction au SDK Unity.

À ce stade, la structure des GameObjects dans la fenêtre de hiérarchie (Hiérarchie) est comme illustré ci-dessous :

La structure de la fenêtre Hiérarchie

Écrivez un script C# nommé LCCRenderer.cs avec le code suivant :

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("progression :" + v);
    }

    private void onLoaded()
    {
        m_manager.SetStartLod(2);
        m_renderer.SetEnvironment(false);
        Debug.Log("Données chargées");
    }
}

Attachez le script au GameObject LCCRenderer dans la fenêtre de hiérarchie (Hiérarchie), puis faites glisser le GameObject LCCManager sur la propriété Manager du script dans la fenêtre de propriétés (Inspecteur), et enfin renseignez le chemin du fichier LCC.

Pour faciliter le débogage dans l'éditeur Unity et la compilation directe vers un appareil Android, le code utilise des macros de compilation pour distinguer l'environnement d'exécution : dans l'éditeur Unity, utilisez directement l'adresse spécifiée par m_FilePath ; sur un appareil Android, utilisez la source de données sur appareil. La façon de placer les données sur appareil est la suivante :

Exécutez l'application compilée sur l'appareil VR une fois.
Une fois l'application installée, entrez dans son répertoire de données (généralement Stockage de l'appareil → Android → data → app BundleID → Files ; reportez-vous au chemin d'installation de l'application Android pour le répertoire spécifique), et créez un dossier LccData sous le sous-répertoire Files.
Copiez toutes les sources de données LCC dans le dossier LccData.

Remarque : en pratique, il est recommandé de placer la source de données de l'application sur un serveur plutôt que de la packager directement dans l'application.

Pratiques d'optimisation

Suivre les étapes ci-dessus permet aux données LCC de s'afficher normalement sur l'appareil VR, mais il existe deux problèmes principaux :

Affichage de fenêtre d'application 2D

Les applications développées selon le standard OpenXR sans SDK de fabricant d'appareil ne sont pas nécessairement reconnues comme applications 3D sur les appareils VR ; généralement, le système de l'appareil VR les traite comme des applications 2D, et une fenêtre d'application 2D est donc affichée. Il existe deux approches pour résoudre ce problème :

Introduire un SDK de fabricant d'appareil ou une extension OpenXR de fabricant ; le logiciel du fabricant gérera alors les problèmes associés.
Personnaliser AndroidManifest.xml.

Les étapes spécifiques pour personnaliser le Manifest sont : sélectionnez Player à gauche de Paramètres du projet, basculez vers la plateforme Android, déployez la section Publishing Settings, cochez Custom Main Manifest, ce qui générera un fichier Manifest personnalisé, comme illustré ci-dessous :

Cocher Custom Main Manifest pour générer un fichier Manifest personnalisé

Trouvez le fichier AndroidManifest.xml et ajoutez le marqueur VR afin que l'appareil VR le reconnaisse comme une application immersive 3D, et l'application lancée sera affichée comme un espace 3D. Exemple :

<?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>

        <!--Utilisé lorsque Application Entry est défini sur GameActivity, sinon supprimez ce bloc d'activité-->
        <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>

Saccades lorsque la fréquence d'images de rendu est inférieure à 90 FPS

Le standard OpenXR lui-même ne définit pas l'interpolation d'images, le lissage ni le contenu associé ; lorsque la fréquence d'images ne peut pas atteindre 90 FPS, il y aura une sensation de saccade perceptible lors de la rotation de la tête ou des déplacements. Pour offrir une meilleure expérience, en particulier pour améliorer la fluidité sous des performances matérielles limitées, les fabricants d'appareils fournissent généralement des techniques telles que le tweening, l'interpolation d'images et le lissage, comme ATW (Asynchronous Time Warp), PTW (Late Stage Reprojection), etc.

Si l'appareil prend en charge OpenXR, les fabricants fournissent généralement une extension OpenXR ou un SDK qui prend directement en charge OpenXR ; dans ce cas, il est préférable d'introduire le SDK du fabricant pour une expérience plus fluide.

Référence associée

Pour les paramètres de projet et l'optimisation des performances, voir les chapitres Guide d'optimisation des paramètres de projet et Guide des paramètres de performance de rendu.
La capacité de rendu à l'écran de l'appareil VR pour le 3DGS est d'environ 700 000 primitives gaussiennes ; lors du rendu de grandes scènes, il est recommandé de définir StartLOD sur 2 et de désactiver l'affichage des données d'environnement ; les grandes scènes seront plus fluides avec le streaming PC.