OpenXR-Entwicklungsanleitung

OpenXR ist ein offener, lizenzgebührenfreier XR-Schnittstellenstandard (VR/AR/MR), der von der Khronos Group definiert und gepflegt wird. Sein Kernziel besteht darin, Entwicklern „einmal schreiben, überall ausführen“ zu ermöglichen und so das Fragmentierungsproblem zu lösen, dass verschiedene Geräte jeweils über einen eigenen API-Satz verfügen. Das LCC Unity SDK unterstützt nun den OpenXR-Standard und kann daher 3DGS-Daten auf OpenXR-kompatiblen Geräten rendern, ohne dass ein SDK eines bestimmten VR-Geräteherstellers erforderlich ist.

Versionsanforderungen

Die in dieser Anleitung verwendeten Software- und Plugin-Versionen sind nachfolgend aufgeführt. Es wird empfohlen, mit denselben Versionen zu entwickeln; andere, nicht getestete Versionen können Kompatibilitätsprobleme aufweisen:

Software / Plugin	Version
Unity	v6000.0.69f1
LCC Unity SDK	v2.3.0 und neuer

Hinweis:
OpenXR ist ein Standard, und verschiedene VR-Gerätehersteller unterstützen möglicherweise alle seine Funktionen oder nur einen Teil davon; prüfen Sie daher vor der Verwendung den Unterstützungsstatus des jeweiligen Geräts.
Der OpenXR-Standard definiert gemeinsame technische Spezifikationen, aber gerätespezifische Funktionen erfordern weiterhin ein Hersteller-SDK oder eine Hersteller-OpenXR-Erweiterung, wie ATW (Asynchronous Time Warp), PTW (Late Stage Reprojection) und andere Technologien, die die Zwischenbild-Glätte verbessern.
Diese Anleitung demonstriert hauptsächlich die OpenXR-Entwicklung auf echten VR-Geräten; das LCC Unity SDK unterstützt keine OpenXR-Desktop-Anwendungsentwicklung (mit Ausnahme von PCVR).

Entwicklungsworkflow

Schritt 1: Ein URP-Projekt erstellen

Wählen Sie in der Projektvorlage den Typ Universal 3D (URP-Render-Pipeline), wie unten dargestellt:

Ein Universal-3D-Projekt erstellen

Schritt 2: Die Plattform wechseln

Wählen Sie nach der Projekterstellung im Unity-Menü Datei → Build-Profile, um das Build-Fenster zu öffnen, und wechseln Sie die Plattform auf Android, wie unten dargestellt:

Die Plattform in den Build-Profilen auf Android wechseln

Schritt 3: Unity OpenXR importieren

Öffnen Sie das UPM-Fenster über das Unity-Menü Fenster → Paket-Manager, wählen Sie in der linken Liste Unity-Registry, geben Sie OpenXR in das Suchfeld ein, wählen Sie aus den Suchergebnissen OpenXR Plugin und installieren Sie es, wie unten dargestellt:

Das OpenXR Plugin aus der Unity-Registry installieren

Schritt 4: XR Interaction Toolkit importieren

Wählen Sie in der linken Liste Unity-Registry, geben Sie XR in das Suchfeld ein, wählen Sie aus den Suchergebnissen XR Interaction Toolkit und installieren Sie es, wie unten dargestellt:

XR Interaction Toolkit aus der Unity-Registry installieren

Schritt 5: Das LCC Unity SDK importieren

Öffnen Sie das UPM-Fenster über das Unity-Menü Fenster → Paket-Manager, klicken Sie links auf ＋, wählen Sie im Dropdown-Menü Paket von Datenträger installieren, suchen Sie das LCC Unity SDK und wählen Sie die Datei package.json zum Import, wie unten dargestellt:

Das LCC Unity SDK über „Paket von Datenträger installieren“ importieren

Schritt 6: Die Unity-Umgebung einrichten

XR-Plug-in-Verwaltung konfigurieren (Android-Plattform)

Wählen Sie in der Unity-Menüleiste Datei → Projekteinstellungen, wählen Sie links XR-Plug-in-Verwaltung, aktivieren Sie im Tab der Plattform Android die Option OpenXR und aktivieren Sie XR beim Start initialisieren, wie unten dargestellt:

Auf der Android-Plattform OpenXR und „XR beim Start initialisieren“ aktivieren

XR-Plug-in-Verwaltung konfigurieren (Desktop-Plattform)

Da das LCC Unity SDK die OpenXR-Desktop-Entwicklung nicht unterstützt, aktivieren Sie unter der Plattform Desktop weder OpenXR noch XR beim Start initialisieren, wie unten dargestellt:

Auf der Desktop-Plattform OpenXR und „XR beim Start initialisieren“ nicht aktivieren

Hinweis: Für Desktop-PCVR siehe PCVR-Streaming.

OpenXR-Render-Modus und Interaktionskonfiguration konfigurieren

Wählen Sie unter XR-Plug-in-Verwaltung den Eintrag OpenXR und setzen Sie den Render-Modus der Plattform Android auf Single Pass Instanced oder Multi-View. Da OpenXR das Festlegen von Interaktionsprofilen erfordert, wählen Sie üblicherweise Oculus Touch Controller Profile oder ein Profil mit ähnlichen Geräteleistungsmerkmalen, wie unten dargestellt:

Den OpenXR-Render-Modus und die Interaktionsprofile festlegen

Projektvalidierung

Wählen Sie unter XR-Plug-in-Verwaltung den Eintrag Projektvalidierung und klicken Sie auf Alle korrigieren, um die erforderlichen Einstellungen abzuschließen (Sie können dies auch vorerst unbehandelt lassen und später manuell erstellen), wie unten dargestellt:

In der Projektvalidierung auf „Alle korrigieren“ klicken

Player konfigurieren (Desktop-Plattform)

Wählen Sie links in Projekteinstellungen den Eintrag Player, wechseln Sie zur Plattform Desktop, klappen Sie den Abschnitt Weitere Einstellungen auf, deaktivieren Sie Automatische Grafik-API, setzen Sie Grafik-APIs auf Direct3D12, Vulkan, Direct3D11 und entfernen Sie die übrigen Grafik-APIs; setzen Sie Farbraum auf Gamma, wie unten dargestellt:

Die Grafik-APIs und den Gamma-Farbraum auf der Desktop-Plattform festlegen

Hinweis: Einige VR-Geräte unterstützen den Gamma-Farbraum nicht; in diesem Fall können Sie nur den Linear-Farbraum wählen, und im Linear-Farbraum gerenderte LCC-Szenen erscheinen leicht ausgewaschen.

Player konfigurieren (Android-Plattform)

Wählen Sie links in Projekteinstellungen den Eintrag Player, wechseln Sie zur Plattform Android, klappen Sie den Abschnitt Weitere Einstellungen auf, deaktivieren Sie Automatische Grafik-API, setzen Sie Grafik-APIs auf Vulkan und entfernen Sie die übrigen Grafik-APIs; setzen Sie Farbraum auf Gamma, wie unten dargestellt:

Die Grafik-API auf Vulkan und den Gamma-Farbraum auf der Android-Plattform festlegen

Skripting-Backend und Eingabe der Android-Plattform festlegen

Scrollen Sie im Tab Weitere Einstellungen der Plattform Android weiter nach unten und setzen Sie Mindest-API-Level = Android 12L (API Level 32) oder neuer, Skripting-Backend = IL2CPP, Zielarchitektur = ARM64, Aktive Eingabeverarbeitung = Input System-Paket (Neu) oder Beides, wie unten dargestellt:

Mindest-API-Level, Skripting-Backend, Zielarchitektur und Aktive Eingabeverarbeitung festlegen

Grafik und Qualität prüfen

Wählen Sie links in Projekteinstellungen den Eintrag Grafik und prüfen Sie das von der Standard-Render-Pipeline der Plattform Mobil verwendete Render-Asset, in diesem Beispiel Mobile_RPAsset, wie unten dargestellt:

Das Render-Asset der Standard-Render-Pipeline auf der Mobil-Plattform prüfen

Wählen Sie links in Projekteinstellungen den Eintrag Qualität, prüfen Sie das von der Standard-Render-Pipeline der Plattform Mobil verwendete Render-Asset (in diesem Beispiel Mobile_RPAsset), setzen Sie Fester DPI-Faktor für Auflösungsskalierung = 0,7 und VSync-Anzahl = Nicht synchronisieren, wie unten dargestellt:

Den DPI-Faktor und VSync in den Qualitätseinstellungen festlegen

Das Render-Asset konfigurieren

Suchen Sie das von der Standard-Render-Pipeline der Plattform Mobil verwendete Render-Asset (in diesem Beispiel Mobile_RPAsset), wählen Sie das Asset aus und deaktivieren Sie im Eigenschaftenfenster (Inspektor): Tiefentextur, Opake Textur, HDR; setzen Sie Kantenglättung (MSAA) = Deaktiviert, Render-Skalierung = 0,7, Hochskalierungsfilter = Automatisch, wie unten dargestellt:

Tiefentextur/Opake Textur, HDR, MSAA deaktivieren und die Render-Skalierung im Render-Asset festlegen

Tiefentextur/Opake Textur, HDR, MSAA deaktivieren und Render-Skalierung = 0,7 im Render-Asset festlegen

Suchen Sie den zu diesem Render-Asset passenden Renderer, in diesem Beispiel Mobile_Renderer (Universal Renderer Data), und legen Sie dessen zugehörige Eigenschaften im Eigenschaftenfenster (Inspektor) fest, wie unten dargestellt:

Die Eigenschaften von Mobile_Renderer (Universal Renderer Data) konfigurieren

Schritt 7: Die Szene erstellen

Erstellen Sie eine brandneue Szene in Unity, löschen Sie die Hauptkamera und das Richtungslicht, klicken Sie mit der rechten Maustaste in einen leeren Bereich des Hierarchiefensters (Hierarchie) und wählen Sie im Popup-Menü XR → XR Origin (VR), um die erforderlichen XR-Objekte zu erstellen.

Schritt 8: Die Szene konfigurieren

Wählen Sie das GameObject XR Origin (VR) im Hierarchiefenster (Hierarchie) aus und setzen Sie in der Komponente XR Origin des Eigenschaftenfensters (Inspektor) den Tracking-Ursprungsmodus auf Boden; weitere zugehörige Eigenschaften sind wie unten dargestellt:

Den Tracking-Ursprungsmodus von XR Origin auf Boden setzen

Wählen Sie das GameObject Hauptkamera unter XR Origin (VR) im Hierarchiefenster (Hierarchie) aus und legen Sie die Eigenschaften der Komponente Camera im Eigenschaftenfenster (Inspektor) fest: Clipping-Ebenen Nah = 0,3, Fern = 5000; Kantenglättung = Keine Kantenglättung; Opake Textur = Aus, Tiefentextur = Aus; Hintergrundtyp = Einfarbig, Hintergrund = Schwarz; HDR = Aus, MSAA = Aus; weitere Eigenschaften sind wie unten dargestellt:

Die Eigenschaften der Camera-Komponente der Hauptkamera unter XR Origin (VR) festlegen

Schritt 9: Code zum Laden der Szene schreiben

Klicken Sie im Hierarchiefenster (Hierarchie) mit der rechten Maustaste auf Leeres GameObject erstellen, um ein leeres Objekt zu erstellen, benennen Sie es LCCManager, normalisieren Sie dessen Transform und hängen Sie das Skript LCCManager über Komponente hinzufügen an, wie unten dargestellt:

Ein leeres Objekt LCCManager erstellen und das Skript LCCManager anhängen

Klicken Sie im Hierarchiefenster (Hierarchie) mit der rechten Maustaste auf Leeres GameObject erstellen, um ein weiteres leeres Objekt zu erstellen, benennen Sie es LCCRenderer und setzen Sie dessen Transform Rotation.x = -90, Scale.x = -1, wie unten dargestellt:

Ein leeres Objekt LCCRenderer erstellen und die Transform für die Koordinatensystem-Ausrichtung festlegen

Ein leeres Objekt LCCRenderer erstellen und Rotation.x = -90 sowie Scale.x = -1 festlegen, um die Koordinatensysteme auszurichten

Rotation.x = -90 und Scale.x = -1 sind die Ausrichtungstransformation vom LCC-Daten-Koordinatensystem (Z-up, rechtshändig) zum Unity-Koordinatensystem (Y-up, linkshändig); siehe „LCC-Daten-Koordinatensystem“ in Einführung in das Unity SDK.

An diesem Punkt ist die GameObject-Struktur im Hierarchiefenster (Hierarchie) wie unten dargestellt:

Die Struktur des Hierarchiefensters

Schreiben Sie ein C#-Skript namens LCCRenderer.cs mit folgendem 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("Fortschritt:" + v);
    }

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

Hängen Sie das Skript im Hierarchiefenster (Hierarchie) an das GameObject LCCRenderer an, ziehen Sie anschließend im Eigenschaftenfenster (Inspektor) das GameObject LCCManager auf die Eigenschaft Manager des Skripts und tragen Sie abschließend den LCC-Dateipfad ein.

Um das Debuggen im Unity-Editor und das direkte Builden auf ein Android-Gerät zu erleichtern, verwendet der Code Kompilierungsmakros zur Unterscheidung der Laufzeitumgebung: Im Unity-Editor wird direkt die durch m_FilePath angegebene Adresse verwendet; auf einem Android-Gerät wird die On-Device-Datenquelle genutzt. Die On-Device-Daten werden wie folgt abgelegt:

Führen Sie die gebaute App einmal auf dem VR-Gerät aus.
Nachdem die App installiert ist, öffnen Sie deren Datenverzeichnis (im Allgemeinen Gerätespeicher → Android → data → App-BundleID → Files; das konkrete Verzeichnis entnehmen Sie dem Android-App-Installationspfad) und erstellen Sie unter dem Unterverzeichnis Files einen Ordner LccData.
Kopieren Sie alle LCC-Datenquellen in den Ordner LccData.

Hinweis: In der Praxis wird empfohlen, die Datenquelle der App auf einem Server abzulegen, anstatt sie direkt in die App zu verpacken.

Optimierungspraktiken

Das Befolgen der obigen Schritte ermöglicht das normale Rendern der LCC-Daten auf dem VR-Gerät, aber es gibt zwei Hauptprobleme:

2D-App-Fensterdarstellung

Apps, die ohne ein Gerätehersteller-SDK nach dem OpenXR-Standard entwickelt wurden, werden auf VR-Geräten nicht unbedingt als 3D-Apps erkannt; typischerweise behandelt das VR-Gerätesystem sie als 2D-Apps, sodass ein 2D-App-Fenster angezeigt wird. Es gibt zwei Ansätze, um dieses Problem zu lösen:

Ein Gerätehersteller-SDK oder eine Gerätehersteller-OpenXR-Erweiterung einführen; die Software des Geräteherstellers übernimmt dann die Behandlung der damit verbundenen Probleme.
AndroidManifest.xml anpassen.

Die konkreten Schritte zum Anpassen des Manifests sind: Wählen Sie links in Projekteinstellungen den Eintrag Player, wechseln Sie zur Plattform Android, klappen Sie den Abschnitt Veröffentlichungseinstellungen auf und aktivieren Sie Benutzerdefiniertes Hauptmanifest, wodurch eine benutzerdefinierte Manifestdatei generiert wird, wie unten dargestellt:

„Benutzerdefiniertes Hauptmanifest“ aktivieren, um eine benutzerdefinierte Manifestdatei zu generieren

Suchen Sie die Datei AndroidManifest.xml und fügen Sie den VR-Marker hinzu, damit das VR-Gerät sie als immersive 3D-App erkennt und die gestartete App als 3D-Raum angezeigt wird. Beispiel:

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

        <!--Wird verwendet, wenn Application Entry auf GameActivity gesetzt ist, andernfalls diesen Activity-Block entfernen-->
        <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>

Ruckeln bei einer Rendering-Bildrate unter 90 FPS

Der OpenXR-Standard selbst definiert keine Frame-Interpolation, Glättung oder verwandte Inhalte; wenn die Bildrate 90 FPS nicht erreichen kann, entsteht beim Drehen des Kopfes oder Bewegen ein spürbares Ruckelgefühl. Um eine bessere Erfahrung zu bieten, insbesondere um die Flüssigkeit bei begrenzter Hardwareleistung zu verbessern, stellen Gerätehersteller in der Regel Techniken wie Tweening, Frame-Interpolation und Glättung bereit, etwa ATW (Asynchronous Time Warp), PTW (Late Stage Reprojection) usw.

Wenn das Gerät OpenXR unterstützt, stellen Gerätehersteller in der Regel eine OpenXR-Erweiterung oder ein SDK bereit, das OpenXR direkt unterstützt; in diesem Fall ist es am besten, das Gerätehersteller-SDK für eine flüssigere Erfahrung einzuführen.

Weiterführende Referenz

Zur Projekteinrichtung und Leistungsoptimierung siehe die Kapitel Leitfaden zur Optimierung der Projekteinstellungen und Leitfaden zu den Rendering-Leistungsparametern.
Die On-Screen-Rendering-Fähigkeit des VR-Geräts für 3DGS beträgt etwa 700.000 Gauß-Primitive; beim Rendern großer Szenen wird empfohlen, StartLOD auf 2 zu setzen und die Anzeige der Umgebungsdaten zu deaktivieren; große Szenen laufen über PC-Streaming flüssiger.