Przewodnik deweloperski dla OpenXR

OpenXR to otwarty, bezpłatny standard interfejsu XR (VR/AR/MR) zdefiniowany i utrzymywany przez Khronos Group. Jego głównym celem jest umożliwienie deweloperom „napisz raz, uruchom wszędzie", co rozwiązuje problem fragmentacji różnych urządzeń, z których każde ma własny zestaw API. LCC Unity SDK obsługuje teraz standard OpenXR, dzięki czemu może renderować dane 3DGS na urządzeniach zgodnych z OpenXR bez SDK dostarczanego przez konkretnego dostawcę urządzeń VR.

Wymagania dotyczące wersji

Wersje oprogramowania i wtyczek używane w tym przewodniku są następujące. Zaleca się tworzenie z użyciem tych samych wersji; inne, nieprzetestowane wersje mogą mieć problemy ze zgodnością:

Oprogramowanie / Wtyczka	Wersja
Unity	v6000.0.69f1
LCC Unity SDK	v2.3.0 i nowsze

Uwaga:
OpenXR to standard, a różni dostawcy urządzeń VR mogą obsługiwać wszystkie jego funkcje lub tylko część z nich, więc przed użyciem musisz sprawdzić stan wsparcia konkretnego urządzenia.
Standard OpenXR definiuje wspólne specyfikacje techniczne, ale funkcje specyficzne dla urządzenia nadal wymagają SDK dostawcy lub rozszerzenia OpenXR dostawcy, takich jak ATW (Asynchronous Time Warp), PTW (Late Stage Reprojection) i inne technologie poprawiające płynność międzyklatkową.
Ten przewodnik głównie demonstruje tworzenie dla OpenXR na rzeczywistych urządzeniach VR; LCC Unity SDK nie obsługuje tworzenia aplikacji desktopowych OpenXR (z wyjątkiem PCVR).

Przepływ pracy deweloperskiej

Krok 1: Utwórz projekt URP

Wybierz typ Uniwersalny 3D (potok renderowania URP) w szablonie projektu, jak pokazano poniżej:

Utwórz projekt Uniwersalny 3D

Krok 2: Przełącz platformę

Po utworzeniu projektu wybierz Plik → Profile kompilacji z menu Unity, aby otworzyć okno kompilacji, i przełącz platformę na Android, jak pokazano poniżej:

Przełącz platformę na Android w Profilach kompilacji

Krok 3: Zaimportuj Unity OpenXR

Otwórz okno UPM przez menu Unity Okno → Menedżer pakietów, wybierz Unity Registry na liście po lewej stronie, wpisz OpenXR w polu wyszukiwania, wybierz OpenXR Plugin z wyników wyszukiwania i zainstaluj go, jak pokazano poniżej:

Zainstaluj wtyczkę OpenXR Plugin z Unity Registry

Krok 4: Zaimportuj XR Interaction Toolkit

Wybierz Unity Registry na liście po lewej stronie, wpisz XR w polu wyszukiwania, wybierz XR Interaction Toolkit z wyników wyszukiwania i zainstaluj go, jak pokazano poniżej:

Zainstaluj XR Interaction Toolkit z Unity Registry

Krok 5: Zaimportuj LCC Unity SDK

Otwórz okno UPM przez menu Unity Okno → Menedżer pakietów, kliknij ＋ po lewej stronie, wybierz Zainstaluj pakiet z dysku z menu rozwijanego, znajdź LCC Unity SDK i wybierz plik package.json, aby go zaimportować, jak pokazano poniżej:

Zaimportuj LCC Unity SDK przez Zainstaluj pakiet z dysku

Krok 6: Skonfiguruj środowisko Unity

Skonfiguruj XR Plug-in Management (platforma Android)

Wybierz Plik → Ustawienia projektu z paska menu Unity, po lewej stronie wybierz Zarządzanie wtyczkami XR, zaznacz OpenXR na karcie platformy Android i zaznacz Zainicjuj XR przy uruchomieniu, jak pokazano poniżej:

Zaznacz OpenXR i Zainicjuj XR przy uruchomieniu na platformie Android

Skonfiguruj XR Plug-in Management (platforma Pulpit)

Ponieważ LCC Unity SDK nie obsługuje tworzenia dla OpenXR na komputerach stacjonarnych, nie zaznaczaj OpenXR ani Zainicjuj XR przy uruchomieniu na platformie Pulpit, jak pokazano poniżej:

Nie zaznaczaj OpenXR ani Zainicjuj XR przy uruchomieniu na platformie Pulpit

Uwaga: w przypadku PCVR na komputerze stacjonarnym zapoznaj się z Strumieniowanie PCVR.

Skonfiguruj tryb renderowania OpenXR i konfigurację interakcji

Wybierz pozycję OpenXR w sekcji Zarządzanie wtyczkami XR i ustaw Tryb renderowania platformy Android na Single Pass Instanced lub Multi-View. Ponieważ OpenXR wymaga ustawienia Profili interakcji, zwykle wybierz Profil kontrolera Oculus Touch lub profil o podobnych parametrach wydajności urządzenia, jak pokazano poniżej:

Ustaw Tryb renderowania OpenXR i Profile interakcji

Walidacja projektu

Wybierz pozycję Walidacja projektu w sekcji Zarządzanie wtyczkami XR i kliknij Napraw wszystko, aby dokończyć niezbędne ustawienia (możesz też na razie pozostawić bez obsługi i utworzyć ręcznie później), jak pokazano poniżej:

Kliknij Napraw wszystko w Walidacji projektu

Skonfiguruj Odtwarzacz (platforma Pulpit)

Po lewej stronie Ustawień projektu wybierz Odtwarzacz, przełącz na platformę Pulpit, rozwiń sekcję Inne ustawienia, odznacz Automatyczny API grafiki, ustaw API graficzne na Direct3D12, Vulkan, Direct3D11 i usuń pozostałe API graficzne; ustaw Przestrzeń kolorów na Gamma, jak pokazano poniżej:

Ustaw API graficzne i przestrzeń kolorów Gamma na platformie Pulpit

Uwaga: niektóre urządzenia VR nie obsługują przestrzeni kolorów Gamma; w takim przypadku możesz wybrać tylko przestrzeń kolorów Linear, a sceny LCC renderowane w przestrzeni kolorów Linear będą wyglądać na nieco wyblakłe.

Skonfiguruj Odtwarzacz (platforma Android)

Po lewej stronie Ustawień projektu wybierz Odtwarzacz, przełącz na platformę Android, rozwiń sekcję Inne ustawienia, odznacz Automatyczny API grafiki, ustaw API graficzne na Vulkan i usuń pozostałe API graficzne; ustaw Przestrzeń kolorów na Gamma, jak pokazano poniżej:

Ustaw API graficzne na Vulkan i przestrzeń kolorów Gamma na platformie Android

Ustaw backend skryptowy i wejście platformy Android

Przewiń kartę Inne ustawienia platformy Android w dół i ustaw Minimalny poziom API = Android 12L (poziom API 32) lub wyższy, Backend skryptowy = IL2CPP, Architektury docelowe = ARM64, Aktywna obsługa wejścia = Pakiet Input System (nowy) lub Obie, jak pokazano poniżej:

Ustaw Minimalny poziom API, Backend skryptowy, Architektury docelowe i Aktywną obsługę wejścia

Sprawdź Grafikę i Jakość

Po lewej stronie Ustawień projektu wybierz Grafika i sprawdź Render Asset odpowiadający Domyślnemu potokowi renderowania używanemu przez platformę Mobile, w tym przykładzie Mobile_RPAsset, jak pokazano poniżej:

Sprawdź Render Asset Domyślnego potoku renderowania na platformie Mobile

Po lewej stronie Ustawień projektu wybierz Jakość, sprawdź Render Asset odpowiadający Domyślnemu potokowi renderowania używanemu przez platformę Mobile (w tym przykładzie Mobile_RPAsset), ustaw Stały współczynnik DPI skalowania rozdzielczości = 0.7, Liczba VSync = Bez synchronizacji, jak pokazano poniżej:

Ustaw współczynnik DPI i VSync w Jakości

Skonfiguruj Render Asset

Znajdź Render Asset odpowiadający Domyślnemu potokowi renderowania używanemu przez platformę Mobile (w tym przykładzie Mobile_RPAsset), wybierz zasób, a następnie w oknie właściwości (Inspektor): odznacz Teksturę głębi, Teksturę nieprzezroczystą, HDR; ustaw Wygładzanie krawędzi (MSAA) = Wyłączone, Skala renderowania = 0.7, Filtr skalowania = Automatyczny, jak pokazano poniżej:

Wyłącz Teksturę głębi/nieprzezroczystą, HDR, MSAA i ustaw Skalę renderowania w Render Asset

Wyłącz Teksturę głębi/nieprzezroczystą, HDR, MSAA i ustaw Skalę renderowania = 0.7 w Render Asset

Znajdź pasujący Renderer dla tego Render Asset, w tym przykładzie Mobile_Renderer (Universal Renderer Data), i ustaw jego odpowiednie właściwości w oknie właściwości (Inspektor), jak pokazano poniżej:

Skonfiguruj właściwości Mobile_Renderer (Universal Renderer Data)

Krok 7: Utwórz scenę

Utwórz zupełnie nową scenę w Unity, usuń Kamerę główną i Światło kierunkowe, kliknij prawym przyciskiem myszy w pustym obszarze okna hierarchii (Hierarchia) i wybierz XR → XR Origin (VR) z menu podręcznego, aby utworzyć niezbędne obiekty XR.

Krok 8: Skonfiguruj scenę

Wybierz GameObject XR Origin (VR) w oknie hierarchii (Hierarchia) i w komponencie XR Origin w oknie właściwości (Inspektor) ustaw Tryb początku śledzenia na Podłoga; pozostałe odpowiednie właściwości jak pokazano poniżej:

Ustaw Tryb początku śledzenia XR Origin na Podłoga

Wybierz GameObject Kamera główna pod XR Origin (VR) w oknie hierarchii (Hierarchia) i ustaw właściwości komponentu Kamera w oknie właściwości (Inspektor): Płaszczyzny przycinania Blisko = 0.3, Daleko = 5000; Wygładzanie krawędzi = Bez wygładzania krawędzi; Tekstura nieprzezroczysta = Wyłączone, Tekstura głębi = Wyłączone; Typ tła = Jednolity kolor, Tło = czarny; HDR = Wyłączone, MSAA = Wyłączone; pozostałe właściwości jak pokazano poniżej:

Ustaw właściwości komponentu Kamera Kamery głównej pod XR Origin (VR)

Krok 9: Napisz kod, aby załadować scenę

Kliknij prawym przyciskiem myszy Utwórz pusty w oknie hierarchii (Hierarchia), aby utworzyć pusty obiekt, nazwij go LCCManager, znormalizuj jego Transform i dołącz skrypt LCCManager przez Dodaj komponent, jak pokazano poniżej:

Utwórz pusty obiekt LCCManager i dołącz skrypt LCCManager

Kliknij prawym przyciskiem myszy Utwórz pusty w oknie hierarchii (Hierarchia), aby utworzyć kolejny pusty obiekt, nazwij go LCCRenderer i ustaw jego Transform Rotation.x = -90, Scale.x = -1, jak pokazano poniżej:

Utwórz pusty obiekt LCCRenderer i ustaw Transform do wyrównania układu współrzędnych

Utwórz pusty obiekt LCCRenderer i ustaw Rotation.x = -90 oraz Scale.x = -1, aby wyrównać układy współrzędnych

Rotation.x = -90 i Scale.x = -1 to transformacja wyrównująca z układu współrzędnych danych LCC (prawoskrętny z osią Z w górę) do układu współrzędnych Unity (lewoskrętny z osią Y w górę); zobacz „Układ współrzędnych danych LCC" w Wprowadzenie do Unity SDK.

W tym momencie struktura GameObject w oknie hierarchii (Hierarchia) wygląda jak pokazano poniżej:

Struktura okna Hierarchia

Napisz skrypt C# o nazwie LCCRenderer.cs z następującym kodem:

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

    private void onLoaded()
    {
        m_manager.SetStartLod(2);
        m_renderer.SetEnvironment(false);
        Debug.Log("Dane załadowane");
    }
}

Dołącz skrypt do GameObject LCCRenderer w oknie hierarchii (Hierarchia), następnie przeciągnij GameObject LCCManager na właściwość Manager skryptu w oknie właściwości (Inspektor), a na koniec wpisz ścieżkę pliku LCC.

Aby ułatwić debugowanie w Edytorze Unity i bezpośrednią kompilację na urządzenie z Androidem, kod używa makr kompilacji do rozróżnienia środowiska uruchomieniowego: w Edytorze Unity bezpośrednio używa adresu określonego przez m_FilePath; na urządzeniu z Androidem używa źródła danych na urządzeniu. Sposób umieszczania danych na urządzeniu:

Uruchom zbudowaną aplikację na urządzeniu VR raz.
Po zainstalowaniu aplikacji wejdź do jej katalogu danych (zwykle Pamięć urządzenia → Android → data → BundleID aplikacji → Files; konkretny katalog znajdziesz w ścieżce instalacji aplikacji Android) i utwórz folder LccData w podkatalogu Files.
Skopiuj wszystkie źródła danych LCC do folderu LccData.

Uwaga: w praktyce zaleca się umieszczenie źródła danych aplikacji na serwerze, zamiast pakowania go bezpośrednio do aplikacji.

Praktyki optymalizacji

Postępowanie zgodnie z powyższymi krokami pozwala normalnie renderować dane LCC na urządzeniu VR, ale istnieją dwa główne problemy:

Wyświetlanie okna aplikacji 2D

Aplikacje tworzone zgodnie ze standardem OpenXR bez SDK dostawcy urządzenia niekoniecznie są rozpoznawane jako aplikacje 3D na urządzeniach VR; zwykle system urządzenia VR traktuje je jako aplikacje 2D, więc wyświetlane jest okno aplikacji 2D. Istnieją dwa podejścia do rozwiązania tego problemu:

Wprowadź SDK dostawcy urządzenia lub rozszerzenie OpenXR dostawcy urządzenia; oprogramowanie dostawcy urządzenia obsłuży wtedy powiązane problemy.
Dostosuj AndroidManifest.xml.

Konkretne kroki dostosowywania manifestu: po lewej stronie Ustawień projektu wybierz Odtwarzacz, przełącz na platformę Android, rozwiń sekcję Ustawienia publikowania, zaznacz Własny manifest główny, co wygeneruje własny plik manifestu, jak pokazano poniżej:

Zaznacz Własny manifest główny, aby wygenerować własny plik manifestu

Znajdź plik AndroidManifest.xml i dodaj znacznik VR, aby urządzenie VR rozpoznało go jako wciągającą aplikację 3D, a uruchomiona aplikacja będzie wyświetlana jako przestrzeń 3D. Przykład:

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

        <!--Używane, gdy wpis aplikacji jest ustawiony na GameActivity; w przeciwnym razie usuń ten blok 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>

Zacinanie, gdy liczba klatek renderowania jest poniżej 90 FPS

Sam standard OpenXR nie definiuje interpolacji klatek, wygładzania ani powiązanych treści; gdy liczba klatek nie może osiągnąć 90 FPS, przy obracaniu głowy lub poruszaniu się odczuwalne będzie wyraźne zacinanie. Aby zapewnić lepsze wrażenia, zwłaszcza poprawić płynność przy ograniczonej wydajności sprzętowej, dostawcy urządzeń zwykle oferują techniki takie jak tweening, interpolacja klatek i wygładzanie, np. ATW (Asynchronous Time Warp), PTW (Late Stage Reprojection) itp.

Jeśli urządzenie obsługuje OpenXR, dostawcy urządzeń zwykle udostępniają rozszerzenie OpenXR lub SDK bezpośrednio obsługujące OpenXR; w takim przypadku najlepiej wprowadzić SDK dostawcy urządzenia dla płynniejszych wrażeń.

Powiązane materiały

Ustawienia projektu i optymalizację wydajności znajdziesz w rozdziałach Przewodnik optymalizacji ustawień projektu i Przewodnik parametrów wydajności renderowania.
Możliwość renderowania 3DGS na ekranie urządzenia VR wynosi około 700 000 prymitywów gaussowskich; podczas renderowania dużych scen zaleca się ustawienie StartLOD na 2 i wyłączenie wyświetlania danych środowiskowych; duże sceny będą płynniejsze przy strumieniowaniu PC.