Quest 3-Entwicklungsanleitung

Der LCC-Entwicklungsworkflow für Quest 3 unterscheidet sich geringfügig vom offiziellen VR-Projekterstellungsworkflow von Meta: Die offiziellen Änderungen von Meta an der Unity-Konfiguration führen dazu, dass das LCC-Rendering mit dem in deren Entwicklungsdokumentation empfohlenen Workflow inkompatibel ist. Den offiziellen Workflow von Meta finden Sie unter Set up Unity for XR development. Aufbauend auf diesem Workflow erläutert diese Anleitung, wie das LCC Unity SDK zum Rendern von 3DGS-Szenen integriert wird.

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:

Hinweis:

1. Das Meta SDK unterstützt nur den Linear-Farbraum von URP, und in diesem Farbraum gerenderte LCC-Szenen erscheinen leicht ausgewaschen.
2. Unity-Version, Meta SDK-Version und LCC SDK-Version beeinflussen alle das Rendering und die Leistung; halten Sie daher jede Softwareversion mit dieser Anleitung konsistent.

Entwicklungsworkflow

Schritt 1: Ein URP-Projekt erstellen

Wählen Sie in der Projektvorlage Universal 3D, wie unten dargestellt:

Ein Universal-3D-Projekt (URP) 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: Meta XR All-in-One SDK importieren

Das Meta XR All-in-One SDK ist das XR-Entwicklungstoolkit von Meta; siehe Meta XR All-in-One SDK (UPM).

Fügen Sie dieses SDK vor der Verwendung im Unity Asset Store Ihren persönlichen Assets hinzu: https://assetstore.unity.com/packages/tools/integration/meta-xr-all-in-one-sdk-269657. Öffnen Sie anschließend UPM über Fenster → Paket-Manager, wählen Sie links Meine Assets, geben Sie Meta XR in das Suchfeld ein und installieren Sie Meta XR All-in-One SDK, wie unten dargestellt:

Meta XR All-in-One SDK aus „Meine Assets“ installieren

Schritt 6: 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

Starten Sie Unity nach Abschluss der obigen Schritte neu, bevor Sie mit den nachfolgenden Einstellungen fortfahren.

Schritt 7: Die Unity-Umgebung einrichten

XR-Plug-in-Verwaltung konfigurieren

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

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

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

Wählen Sie unter XR-Plug-in-Verwaltung den Eintrag OpenXR und setzen Sie den Render-Modus für beide Plattformen Desktop und Android auf Multi-pass, wie unten dargestellt:

Den OpenXR-Render-Modus auf Multi-pass setzen

Hinweis: Das Meta XR All-in-One SDK ändert den Wert des Render-Modus; stellen Sie vor dem Build sicher, dass dieser Wert Multi-pass lautet.

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 Vulkan, Direct3D12, Direct3D11 und entfernen Sie die übrigen Grafik-APIs; setzen Sie Farbraum auf Linear, wie unten dargestellt:

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

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 Linear (das Meta SDK unterstützt nur den Linear-Farbraum), wie unten dargestellt:

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

Firmenname und Produktname festlegen

Setzen Sie im Tab Player den Firmennamen und Produktnamen korrekt, wie unten dargestellt:

Firmenname und Produktname 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), 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). Nach einem Klick darauf wird das Asset im Projektfenster (Projekt) lokalisiert. Wählen Sie das Asset aus und deaktivieren Sie dann 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 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

Projektvalidierung

Wählen Sie links in Projekteinstellungen den Eintrag XR-Plug-in-Verwaltung und anschließend Projektvalidierung. Beheben Sie die rot markierten Validierungselemente – klicken Sie rechts neben jedem roten Eintrag auf die Schaltfläche Korrigieren, um ihn zu beheben; die gelben Warnhinweise können nach Bedarf behoben oder vorerst unbehandelt gelassen werden. Vor der Bearbeitung, wie unten dargestellt:

Projektvalidierung vor der Bearbeitung (rot markierte Elemente vorhanden)

Nach der Bearbeitung, wie unten dargestellt:

Projektvalidierung nach der Bearbeitung (rot markierte Elemente behoben)

Schritt 8: Die Szene erstellen

Dieses Beispiel beginnt mit einer brandneuen Szene (Szene). Löschen Sie nach dem Erstellen einer Unity-Szene das GameObject Hauptkamera im Hierarchiefenster (Hierarchie), klicken Sie dann mit der rechten Maustaste in einen leeren Bereich des Fensters und wählen Sie im Popup-Menü XR → XR Origin (VR), wie unten dargestellt:

XR Origin (VR) über das Kontextmenü erstellen

Schritt 9: 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, 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 Kameraeigenschaften im Eigenschaftenfenster (Inspektor) fest:

Weitere Eigenschaften sind wie unten dargestellt:

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

Schritt 10: 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 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 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.

Schreiben Sie ein C#-Skript namens LCCRenderer.cs mit folgendem Code:

using LCCCore;
using UnityEngine;

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.Quest);
        m_renderer = m_manager.GetRender(this.gameObject.transform);
        m_renderer.Load(m_FilePath, onProgress, onLoaded);
        //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; danach bauen und ausführen.

Das Skript LCCRenderer an das Objekt anhängen und Manager sowie Dateipfad binden

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 die PC-Plattform verwendet, auf einem Quest-Gerät die Quest-Plattform.

Für Quest-Geräte wird empfohlen, die Datenquelle auf einem Server abzulegen; während des Tests können Sie auch die Datenquelle direkt auf dem Gerät verwenden. Die konkreten Schritte sind:

1. Führen Sie die gebaute App einmal auf dem Quest-Gerät aus.
2. Nachdem die App installiert ist, öffnen Sie deren Datenverzeichnis (im Allgemeinen Quest-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.
3. Kopieren Sie alle LCC-Datenquellen in den Ordner LccData.

Hinweis:

1. In der Praxis wird empfohlen, die Datenquelle der Quest-App auf einem Server abzulegen, anstatt sie direkt in die App zu verpacken.
2. Die On-Screen-Rendering-Fähigkeit des Quest-3-Geräts für 3DGS beträgt etwa 700.000 Gauß-Primitive, also rund zwei Größenordnungen weniger als die PC-seitige Fähigkeit von etwa 25 Millionen. Es wird hauptsächlich für das Rendern und Anzeigen kleiner Szenen und einzelner Objekte empfohlen; große Szenen laufen über PC-Streaming flüssiger.
3. Beim Rendern großer LCC-Szenen wird empfohlen, StartLOD auf 2 zu setzen und die Anzeige der Umgebungsdaten zu deaktivieren (wie im Beispielcode gezeigt).

Weiterführende Referenz

• Zur Projekteinrichtung und Leistungsoptimierung siehe die Kapitel Leitfaden zur Optimierung der Projekteinstellungen und Leitfaden zu den Rendering-Leistungsparametern.
• Zu weiteren Meta-Entwicklungsworkflows siehe die offizielle Dokumentation: Meta-Entwicklerdokumentation.
• Setzen Sie während der Quest-Entwicklung den Render-Modus der Plattform Desktop in Projekteinstellungen → OpenXR auf Multi-pass; andernfalls können LCC-Szenen in Unity nicht normal gerendert werden (einschließlich Editor und Laufzeit).