Ontwikkelgids voor OpenXR

OpenXR is een open, royaltyvrije XR-interface (VR/AR/MR) die is gedefinieerd en wordt onderhouden door de Khronos Group. Het kernstreven is om ontwikkelaars in staat te stellen "één keer schrijven, overal draaien", waarmee het fragmentatieprobleem wordt opgelost dat verschillende apparaten elk hun eigen set API's hebben. De LCC Unity SDK ondersteunt nu de OpenXR-standaard, zodat deze 3DGS-gegevens kan renderen op OpenXR-compatibele apparaten zonder een SDK van een specifieke VR-apparaatleverancier.

Versievereisten

De software- en plug-inversies die in deze gids worden gebruikt, zijn als volgt. Het wordt aanbevolen om met dezelfde versies te ontwikkelen; andere, niet-geteste versies kunnen compatibiliteitsproblemen hebben:

Opmerking:

1. OpenXR is een standaard en diverse VR-apparaatleveranciers kunnen alle functies of slechts een deel ervan ondersteunen, dus je moet de ondersteuningsstatus van het specifieke apparaat controleren voordat je het gebruikt.
2. De OpenXR-standaard definieert gemeenschappelijke technische specificaties, maar apparaatspecifieke functies vereisen nog steeds ondersteuning van een leverancier-SDK of een leverancier-OpenXR-extensie, zoals ATW (Asynchronous Time Warp), PTW (Late Stage Reprojection) en andere technologieën die de vloeiendheid tussen frames verbeteren.
3. Deze gids demonstreert voornamelijk OpenXR-ontwikkeling op echte VR-apparaten; de LCC Unity SDK ondersteunt geen OpenXR-desktopapplicatieontwikkeling (behalve PCVR).

Ontwikkelworkflow

Stap 1: Een URP-project aanmaken

Selecteer het type Universal 3D (URP-renderpipeline) in de projectsjabloon, zoals hieronder wordt weergegeven:

Een Universal 3D-project aanmaken

Stap 2: Het platform wijzigen

Selecteer nadat het project is aangemaakt Bestand → Build Profiles in het Unity-menu om het buildvenster te openen en wijzig het platform naar Android, zoals hieronder wordt weergegeven:

Wijzig het platform naar Android in Build Profiles

Stap 3: Unity OpenXR importeren

Open het UPM-venster via het Unity-menu Venster → Package Manager, selecteer Unity Registry in de linker lijst, voer OpenXR in het zoekvak in, selecteer OpenXR Plugin in de zoekresultaten en installeer deze, zoals hieronder wordt weergegeven:

Installeer de OpenXR Plugin vanuit Unity Registry

Stap 4: XR Interaction Toolkit importeren

Selecteer Unity Registry in de linker lijst, voer XR in het zoekvak in, selecteer XR Interaction Toolkit in de zoekresultaten en installeer deze, zoals hieronder wordt weergegeven:

Installeer de XR Interaction Toolkit vanuit Unity Registry

Stap 5: De LCC Unity SDK importeren

Open het UPM-venster via het Unity-menu Venster → Package Manager, klik links op ＋, selecteer Pakket vanaf schijf installeren in de vervolgkeuzelijst, zoek de LCC Unity SDK en selecteer het package.json-bestand om deze te importeren, zoals hieronder wordt weergegeven:

Importeer de LCC Unity SDK via Pakket vanaf schijf installeren

Stap 6: De Unity-omgeving instellen

XR Plug-in Management configureren (Android-platform)

Selecteer Bestand → Projectinstellingen in de Unity-menubalk, selecteer links XR Plug-in Management, vink OpenXR aan onder het tabblad van het Android-platform en vink Initialize XR on Startup aan, zoals hieronder wordt weergegeven:

Vink OpenXR en Initialize XR on Startup aan op het Android-platform

XR Plug-in Management configureren (Desktop-platform)

Omdat de LCC Unity SDK geen desktop-OpenXR-ontwikkeling ondersteunt, mag je OpenXR of Initialize XR on Startup onder het Desktop-platform niet aanvinken, zoals hieronder wordt weergegeven:

Vink OpenXR of Initialize XR on Startup op het Desktop-platform niet aan

Opmerking: Raadpleeg voor desktop-PCVR PCVR-streaming.

De OpenXR-rendermodus en interactieconfiguratie configureren

Selecteer het item OpenXR onder XR Plug-in Management en stel de Render Mode van het Android-platform in op Single Pass Instanced of Multi-View. Omdat OpenXR vereist dat je Interaction Profiles instelt, selecteer je doorgaans Oculus Touch Controller Profile of een profiel met vergelijkbare apparaatprestatiekenmerken, zoals hieronder wordt weergegeven:

Stel de OpenXR Render Mode en Interaction Profiles in

Project Validation

Selecteer het item Project Validation onder XR Plug-in Management en klik op Fix All om de benodigde instellingen te voltooien (je kunt het ook voorlopig onbehandeld laten en later handmatig aanmaken), zoals hieronder wordt weergegeven:

Klik op Fix All in Project Validation

Player configureren (Desktop-platform)

Selecteer links in Projectinstellingen Player, schakel naar het Desktop-platform, vouw de sectie Overige instellingen uit, schakel Auto Graphics API uit, stel Graphics APIs in op Direct3D12, Vulkan, Direct3D11 en verwijder de overige grafische API's; stel Color Space in op Gamma, zoals hieronder wordt weergegeven:

Stel de grafische API's en de Gamma-kleurruimte in op het Desktop-platform

Opmerking: Sommige VR-apparaten ondersteunen de Gamma-kleurruimte niet; in dat geval kun je alleen de Linear-kleurruimte kiezen en LCC-scènes die in de Linear-kleurruimte worden gerenderd, zien er enigszins flets uit.

Player configureren (Android-platform)

Selecteer links in Projectinstellingen Player, schakel naar het Android-platform, vouw de sectie Overige instellingen uit, schakel Auto Graphics API uit, stel Graphics APIs in op Vulkan en verwijder de overige grafische API's; stel Color Space in op Gamma, zoals hieronder wordt weergegeven:

Stel de grafische API in op Vulkan en de Gamma-kleurruimte in op het Android-platform

De scriptingbackend en invoer van het Android-platform instellen

Scroll omlaag in het tabblad Overige instellingen van het Android-platform en stel Minimum API Level = Android 12L (API Level 32) of hoger, Scripting Backend = IL2CPP, Target Architectures = ARM64, Active Input Handling = Input System Package (New) of Both in, zoals hieronder wordt weergegeven:

Stel Minimum API Level, Scripting Backend, Target Architectures en Active Input Handling in

Grafisch en Kwaliteit controleren

Selecteer links in Projectinstellingen Grafisch en controleer de Render Asset die overeenkomt met de Default Render Pipeline die door het Mobile-platform wordt gebruikt; in dit voorbeeld Mobile_RPAsset, zoals hieronder wordt weergegeven:

Controleer de Render Asset van de Default Render Pipeline op het Mobile-platform

Selecteer links in Projectinstellingen Kwaliteit, controleer de Render Asset die overeenkomt met de Default Render Pipeline die door het Mobile-platform wordt gebruikt (in dit voorbeeld Mobile_RPAsset), stel Resolution Scaling Fixed DPI Factor = 0.7, VSync Count = Don't Sync in, zoals hieronder wordt weergegeven:

Stel de DPI Factor en VSync in bij Kwaliteit

De Render Asset configureren

Zoek de Render Asset die overeenkomt met de Default Render Pipeline die door het Mobile-platform wordt gebruikt (in dit voorbeeld Mobile_RPAsset), selecteer het Asset en schakel in het eigenschappenvenster (Inspector) Depth Texture, Opaque Texture en HDR uit; stel Anti Aliasing (MSAA) = Disabled, Render Scale = 0.7, Upscaling Filter = Automatic in, zoals hieronder wordt weergegeven:

Schakel Depth/Opaque Texture, HDR en MSAA uit en stel Render Scale = 0.7 in de Render Asset in

Zoek de bijbehorende Renderer voor deze Render Asset; in dit voorbeeld Mobile_Renderer (Universal Renderer Data), en stel de relevante eigenschappen in het eigenschappenvenster (Inspector) in, zoals hieronder wordt weergegeven:

Configureer de eigenschappen van Mobile_Renderer (Universal Renderer Data)

Stap 7: De scène aanmaken

Maak een gloednieuwe scène aan in Unity, verwijder Main Camera en Directional Light, klik met de rechtermuisknop in een leeg gebied van het hiërarchievenster (Hierarchy) en selecteer XR → XR Origin (VR) in het pop-upmenu om de benodigde XR-objecten aan te maken.

Stap 8: De scène configureren

Selecteer het XR Origin (VR)-GameObject in het hiërarchievenster (Hierarchy) en stel in de XR Origin-component van het eigenschappenvenster (Inspector) Tracking Origin Mode in op Floor; de overige relevante eigenschappen zijn zoals hieronder wordt weergegeven:

Stel Tracking Origin Mode van de XR Origin in op Floor

Selecteer het Main Camera-GameObject onder XR Origin (VR) in het hiërarchievenster (Hierarchy) en stel de eigenschappen van de Camera-component in het eigenschappenvenster (Inspector) in: Clipping Planes Near = 0.3, Far = 5000; Anti-aliasing = No Anti-aliasing; Opaque Texture = Off, Depth Texture = Off; Background Type = Solid Color, Background = zwart; HDR = Off, MSAA = Off; de overige eigenschappen zijn zoals hieronder wordt weergegeven:

Stel de eigenschappen van de Camera-component van de Main Camera onder XR Origin (VR) in

Stap 9: Code schrijven om de scène te laden

Klik met de rechtermuisknop op Create Empty in het hiërarchievenster (Hierarchy) om een leeg object aan te maken, geef het de naam LCCManager, normaliseer de Transform en voeg het LCCManager-script toe via Component toevoegen, zoals hieronder wordt weergegeven:

Maak een leeg LCCManager-object aan en voeg het LCCManager-script toe

Klik met de rechtermuisknop op Create Empty in het hiërarchievenster (Hierarchy) om nog een leeg object aan te maken, geef het de naam LCCRenderer en stel de Transform in op Rotation.x = -90, Scale.x = -1, zoals hieronder wordt weergegeven:

Maak een leeg LCCRenderer-object aan en stel Rotation.x = -90 en Scale.x = -1 in om de coördinatensystemen uit te lijnen

Rotation.x = -90 en Scale.x = -1 vormen de uitlijningstransformatie van het LCC-gegevenscoördinatensysteem (rechtshandig, Z-as omhoog) naar het Unity-coördinatensysteem (linkshandig, Y-as omhoog); zie "Coördinatensysteem van LCC-gegevens" in LCC Unity SDK Introductie.

Op dit punt is de GameObject-structuur in het hiërarchievenster (Hierarchy) zoals hieronder wordt weergegeven:

De structuur van het Hierarchy-venster

Schrijf een C#-script met de naam LCCRenderer.cs met de volgende code:

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

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

Voeg het script toe aan het LCCRenderer-GameObject in het hiërarchievenster (Hierarchy), sleep vervolgens het LCCManager-GameObject naar de eigenschap Manager van het script in het eigenschappenvenster (Inspector) en vul ten slotte het LCC-bestandspad in.

Om het debuggen in de Unity Editor en het rechtstreeks bouwen naar een Android-apparaat te vergemakkelijken, gebruikt de code compileermacro's om de runtime-omgeving te onderscheiden: gebruik in de Unity Editor rechtstreeks het adres dat door m_FilePath is opgegeven; gebruik op een Android-apparaat de gegevensbron op het apparaat. De manier om de gegevens op het apparaat te plaatsen is:

1. Voer de gebouwde app één keer uit op het VR-apparaat.
2. Ga nadat de app is geïnstalleerd naar de gegevensmap (doorgaans Apparaatopslag → Android → data → app BundleID → Files; raadpleeg het installatiepad van de Android-app voor de specifieke map) en maak een map LccData aan onder de submap Files.
3. Kopieer alle LCC-gegevensbronnen naar de map LccData.

Opmerking: In de praktijk wordt aanbevolen om de gegevensbron van de app op een server te plaatsen in plaats van deze rechtstreeks in de app in te pakken.

Optimalisatiepraktijken

Door de bovenstaande stappen te volgen, kunnen LCC-gegevens normaal renderen op het VR-apparaat, maar er zijn twee hoofdproblemen:

Weergave van een 2D-appvenster

Apps die volgens de OpenXR-standaard zijn ontwikkeld zonder een apparaatleverancier-SDK worden op VR-apparaten niet noodzakelijk herkend als 3D-apps; doorgaans behandelt het VR-apparaatsysteem ze als 2D-apps, waardoor er een 2D-appvenster wordt weergegeven. Er zijn twee manieren om dit probleem op te lossen:

• Introduceer een apparaatleverancier-SDK of een apparaatleverancier-OpenXR-extensie; de software van de apparaatleverancier handelt dan de gerelateerde problemen af.
• Pas AndroidManifest.xml aan.

De specifieke stappen voor het aanpassen van het Manifest zijn: selecteer links in Projectinstellingen Player, schakel naar het Android-platform, vouw de sectie Publishing Settings uit en vink Custom Main Manifest aan, waarmee een aangepast Manifest-bestand wordt gegenereerd, zoals hieronder wordt weergegeven:

Vink Custom Main Manifest aan om een aangepast Manifest-bestand te genereren

Zoek het AndroidManifest.xml-bestand en voeg de VR-marker toe zodat het VR-apparaat het herkent als een 3D-immersieve app en de gestarte app wordt weergegeven als een 3D-ruimte. Voorbeeld:

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

        <!--Wordt gebruikt wanneer Application Entry is ingesteld op GameActivity, verwijder anders dit activity-blok-->
        <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>

Haperen wanneer de renderingframerate lager is dan 90 FPS

De OpenXR-standaard zelf definieert geen frame-interpolatie, smoothing of gerelateerde inhoud; wanneer de framerate de 90 FPS niet kan halen, is er een merkbaar haperend gevoel bij het draaien van het hoofd of bij beweging. Om een betere ervaring te bieden, met name om de vloeiendheid bij beperkte hardwareprestaties te verbeteren, bieden apparaatleveranciers doorgaans technieken zoals tweening, frame-interpolatie en smoothing, zoals ATW (Asynchronous Time Warp), PTW (Late Stage Reprojection), enz.

Als het apparaat OpenXR ondersteunt, bieden apparaatleveranciers doorgaans een OpenXR-extensie of een SDK die OpenXR rechtstreeks ondersteunt; in dat geval kun je het beste de apparaatleverancier-SDK introduceren voor een vloeiendere ervaring.

Gerelateerde verwijzing

• Zie voor projectinstellingen en prestatieoptimalisatie de hoofdstukken Optimalisatiegids voor projectinstellingen en Gids voor instellingen van renderprestatieparameters.
• De on-screen renderingcapaciteit voor 3DGS van het VR-apparaat bedraagt ongeveer 700.000 Gaussiaanse primitieven; bij het renderen van grote scènes wordt aanbevolen om StartLOD in te stellen op 2 en de weergave van omgevingsgegevens uit te schakelen; grote scènes verlopen vloeiender met pc-streaming.