Guía de desarrollo con OpenXR

OpenXR es un estándar de interfaz XR (VR/AR/MR) abierto y libre de regalías definido y mantenido por el Khronos Group. Su objetivo principal es permitir a los desarrolladores «escribir una vez, ejecutar en cualquier lugar», resolviendo el problema de fragmentación de que cada dispositivo tenga su propio conjunto de API. El LCC Unity SDK ahora admite el estándar OpenXR, por lo que puede renderizar datos 3DGS en dispositivos compatibles con OpenXR sin necesidad de un SDK proporcionado por un fabricante de dispositivos VR específico.

Requisitos de versión

Las versiones de software y plugin utilizadas en esta guía son las siguientes. Se recomienda desarrollar con las mismas versiones; otras versiones no probadas pueden tener problemas de compatibilidad:

Software / Plugin	Versión
Unity	v6000.0.69f1
LCC Unity SDK	v2.3.0 y superior

Nota:
OpenXR es un estándar, y varios fabricantes de dispositivos VR pueden admitir todas sus funciones o solo parte de ellas, por lo que debes comprobar el estado de compatibilidad del dispositivo específico antes de usarlo.
El estándar OpenXR define especificaciones técnicas comunes, pero las funciones específicas del dispositivo aún requieren el SDK del fabricante o una OpenXR Extension del fabricante, como ATW (Asynchronous Time Warp), PTW (Late Stage Reprojection) y otras tecnologías que mejoran la fluidez entre fotogramas.
Esta guía demuestra principalmente el desarrollo OpenXR en dispositivos VR reales; el LCC Unity SDK no admite el desarrollo de aplicaciones de escritorio OpenXR (excepto PCVR).

Flujo de trabajo de desarrollo

Paso 1: Crear un proyecto URP

Selecciona el tipo Universal 3D (pipeline de renderizado URP) en la plantilla de proyecto, como se muestra a continuación:

Crear un proyecto Universal 3D

Paso 2: Cambiar la plataforma

Una vez creado el proyecto, selecciona Archivo → Build Profiles en el menú de Unity para abrir la ventana de compilación y cambia la plataforma a Android, como se muestra a continuación:

Cambiar la plataforma a Android en Build Profiles

Paso 3: Importar Unity OpenXR

Abre la ventana UPM mediante el menú de Unity Ventana → Administrador de paquetes, selecciona Unity Registry en la lista izquierda, escribe OpenXR en el cuadro de búsqueda, selecciona OpenXR Plugin de los resultados de búsqueda e instálalo, como se muestra a continuación:

Instalar el OpenXR Plugin desde Unity Registry

Paso 4: Importar XR Interaction Toolkit

Selecciona Unity Registry en la lista izquierda, escribe XR en el cuadro de búsqueda, selecciona XR Interaction Toolkit de los resultados de búsqueda e instálalo, como se muestra a continuación:

Instalar XR Interaction Toolkit desde Unity Registry

Paso 5: Importar el LCC Unity SDK

Abre la ventana UPM mediante el menú de Unity Ventana → Administrador de paquetes, haz clic en ＋ a la izquierda, selecciona Instalar paquete desde disco en el menú desplegable, localiza el LCC Unity SDK y selecciona el archivo package.json para importarlo, como se muestra a continuación:

Importar el LCC Unity SDK mediante Instalar paquete desde disco

Paso 6: Configurar el entorno de Unity

Configurar XR Plug-in Management (plataforma Android)

Selecciona Archivo → Ajustes del proyecto en la barra de menús de Unity, selecciona XR Plug-in Management a la izquierda, marca OpenXR bajo la pestaña de plataforma Android y marca Initialize XR on Startup, como se muestra a continuación:

Marcar OpenXR e Initialize XR on Startup en la plataforma Android

Configurar XR Plug-in Management (plataforma Desktop)

Dado que el LCC Unity SDK no admite el desarrollo OpenXR de escritorio, no marques OpenXR ni Initialize XR on Startup bajo la plataforma Desktop, como se muestra a continuación:

No marcar OpenXR ni Initialize XR on Startup en la plataforma Desktop

Nota: Para PCVR de escritorio, consulta Streaming PCVR.

Configurar el modo de renderizado y la configuración de interacción de OpenXR

Selecciona el elemento OpenXR bajo XR Plug-in Management y establece el Render Mode de la plataforma Android como Single Pass Instanced o Multi-View. Dado que OpenXR requiere establecer Interaction Profiles, normalmente selecciona Oculus Touch Controller Profile o un perfil con características de rendimiento de dispositivo similares, como se muestra a continuación:

Establecer el Render Mode y los Interaction Profiles de OpenXR

Project Validation

Selecciona el elemento Project Validation bajo XR Plug-in Management y haz clic en Fix All para completar los ajustes necesarios (también puedes dejarlo sin gestionar por ahora y crearlo manualmente más tarde), como se muestra a continuación:

Hacer clic en Fix All en Project Validation

Configurar Player (plataforma Desktop)

Selecciona Player a la izquierda de Ajustes del proyecto, cambia a la plataforma Desktop, expande la sección Other Settings, desmarca Auto Graphics API, establece Graphics APIs como Direct3D12, Vulkan, Direct3D11 y elimina las demás API gráficas; establece Color Space como Gamma, como se muestra a continuación:

Establecer las API gráficas y el espacio de color Gamma en la plataforma Desktop

Nota: Algunos dispositivos VR no admiten el espacio de color Gamma; en ese caso solo puedes elegir el espacio de color Linear, y las escenas LCC renderizadas en el espacio de color Linear se verán ligeramente descoloridas.

Configurar Player (plataforma Android)

Selecciona Player a la izquierda de Ajustes del proyecto, cambia a la plataforma Android, expande la sección Other Settings, desmarca Auto Graphics API, establece Graphics APIs como Vulkan y elimina las demás API gráficas; establece Color Space como Gamma, como se muestra a continuación:

Establecer la API gráfica Vulkan y el espacio de color Gamma en la plataforma Android

Establecer el backend de scripting y la entrada de la plataforma Android

Desplázate hacia abajo en la pestaña Other Settings de la plataforma Android y establece Minimum API Level = Android 12L (API Level 32) o superior, Scripting Backend = IL2CPP, Target Architectures = ARM64, Active Input Handling = Input System Package (New) o Both, como se muestra a continuación:

Establecer Minimum API Level, Scripting Backend, Target Architectures y Active Input Handling

Comprobar Gráficos y Calidad

Selecciona Gráficos a la izquierda de Ajustes del proyecto y comprueba el Render Asset correspondiente al Default Render Pipeline utilizado por la plataforma Mobile, Mobile_RPAsset en este ejemplo, como se muestra a continuación:

Comprobar el Render Asset del Default Render Pipeline en la plataforma Mobile

Selecciona Calidad a la izquierda de Ajustes del proyecto, comprueba el Render Asset correspondiente al Default Render Pipeline utilizado por la plataforma Mobile (Mobile_RPAsset en este ejemplo), establece Resolution Scaling Fixed DPI Factor = 0.7, VSync Count = Don't Sync, como se muestra a continuación:

Establecer el DPI Factor y VSync en Calidad

Configurar el Render Asset

Encuentra el Render Asset correspondiente al Default Render Pipeline utilizado por la plataforma Mobile (Mobile_RPAsset en este ejemplo), selecciona el Asset y, en la ventana de propiedades (Inspector): desmarca Depth Texture, Opaque Texture, HDR; establece Anti Aliasing (MSAA) = Disabled, Render Scale = 0.7, Upscaling Filter = Automatic, como se muestra a continuación:

Desactivar Depth/Opaque Texture, HDR, MSAA y establecer la Render Scale en el Render Asset

Desactivar Depth/Opaque Texture, HDR, MSAA y establecer Render Scale = 0.7 en el Render Asset

Encuentra el Renderer correspondiente de este Render Asset, Mobile_Renderer (Universal Renderer Data) en este ejemplo, y establece sus propiedades relevantes en la ventana de propiedades (Inspector), como se muestra a continuación:

Configurar las propiedades de Mobile_Renderer (Universal Renderer Data)

Paso 7: Crear la escena

Crea una escena completamente nueva en Unity, elimina Main Camera y Directional Light, haz clic con el botón derecho en un área vacía de la ventana de jerarquía (Jerarquía) y selecciona XR → XR Origin (VR) en el menú emergente para crear los objetos XR necesarios.

Paso 8: Configurar la escena

Selecciona el GameObject XR Origin (VR) en la ventana de jerarquía (Jerarquía) y, en el componente XR Origin de la ventana de propiedades (Inspector), establece Tracking Origin Mode como Floor; el resto de propiedades relevantes son como se muestra a continuación:

Establecer Tracking Origin Mode del XR Origin como Floor

Selecciona el GameObject Main Camera bajo XR Origin (VR) en la ventana de jerarquía (Jerarquía) y establece las propiedades del componente Camera en la ventana de propiedades (Inspector): Clipping Planes Near = 0.3, Far = 5000; Anti-aliasing = No Anti-aliasing; Opaque Texture = Off, Depth Texture = Off; Background Type = Solid Color, Background = negro; HDR = Off, MSAA = Off; el resto de propiedades son como se muestra a continuación:

Establecer las propiedades del componente Camera de Main Camera bajo XR Origin (VR)

Paso 9: Escribir código para cargar la escena

Haz clic con el botón derecho en Create Empty en la ventana de jerarquía (Jerarquía) para crear un objeto vacío, nómbralo LCCManager, normaliza su Transform y adjunta el script LCCManager mediante Agregar componente, como se muestra a continuación:

Crear un objeto vacío LCCManager y adjuntar el script LCCManager

Haz clic con el botón derecho en Create Empty en la ventana de jerarquía (Jerarquía) para crear otro objeto vacío, nómbralo LCCRenderer y establece su Transform Rotation.x = -90, Scale.x = -1, como se muestra a continuación:

Crear un objeto vacío LCCRenderer y establecer el Transform para alinear el sistema de coordenadas

Crear un objeto vacío LCCRenderer y establecer Rotation.x = -90 y Scale.x = -1 para alinear los sistemas de coordenadas

Rotation.x = -90 y Scale.x = -1 son la transformación de alineación del sistema de coordenadas de los datos LCC (diestro con el eje Z hacia arriba) al sistema de coordenadas de Unity (zurdo con el eje Y hacia arriba); consulta "Sistema de coordenadas de los datos LCC" en Introducción al SDK de Unity.

En este punto, la estructura de GameObjects en la ventana de jerarquía (Jerarquía) es como se muestra a continuación:

La estructura de la ventana Jerarquía

Escribe un script C# llamado LCCRenderer.cs con el siguiente código:

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

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

Adjunta el script al GameObject LCCRenderer en la ventana de jerarquía (Jerarquía), arrastra el GameObject LCCManager a la propiedad Manager del script en la ventana de propiedades (Inspector) y, por último, rellena la ruta del archivo LCC.

Para facilitar la depuración en el Editor de Unity y la compilación directa en un dispositivo Android, el código usa macros de compilación para distinguir el entorno de ejecución: en el Editor de Unity, usa directamente la dirección especificada por m_FilePath; en un dispositivo Android, usa la fuente de datos en el dispositivo. La forma de colocar los datos en el dispositivo es:

Ejecuta la aplicación compilada una vez en el dispositivo VR.
Una vez instalada la aplicación, entra en su directorio de datos (generalmente almacenamiento del dispositivo → Android → data → BundleID de la app → Files; consulta la ruta de instalación de aplicaciones Android para el directorio específico) y crea una carpeta LccData bajo el subdirectorio Files.
Copia todas las fuentes de datos LCC en la carpeta LccData.

Nota: En la práctica, se recomienda colocar la fuente de datos de la aplicación en un servidor en lugar de empaquetarla directamente en la aplicación.

Prácticas de optimización

Seguir los pasos anteriores permite que los datos LCC se rendericen con normalidad en el dispositivo VR, pero hay dos problemas principales:

Visualización de la ventana de la aplicación 2D

Las aplicaciones desarrolladas según el estándar OpenXR sin un SDK de fabricante de dispositivos no se reconocen necesariamente como aplicaciones 3D en los dispositivos VR; normalmente el sistema del dispositivo VR las trata como aplicaciones 2D, por lo que se muestra una ventana de aplicación 2D. Hay dos enfoques para resolver este problema:

Introducir un SDK de fabricante de dispositivos o una OpenXR extension de fabricante; el software del fabricante se encargará entonces de los problemas relacionados.
Personalizar AndroidManifest.xml.

Los pasos específicos para personalizar el Manifest son: selecciona Player a la izquierda de Ajustes del proyecto, cambia a la plataforma Android, expande la sección Publishing Settings, marca Custom Main Manifest, lo que generará un archivo Manifest personalizado, como se muestra a continuación:

Marcar Custom Main Manifest para generar un archivo Manifest personalizado

Encuentra el archivo AndroidManifest.xml y añade el marcador VR para que el dispositivo VR lo reconozca como una aplicación inmersiva 3D, de modo que la aplicación lanzada se muestre como un espacio 3D. Ejemplo:

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

        <!--Se usa cuando Application Entry está configurado como GameActivity; de lo contrario, elimina este bloque de 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>

Tirones cuando la tasa de fotogramas de renderizado está por debajo de 90 FPS

El estándar OpenXR en sí no define la interpolación de fotogramas, el suavizado ni contenido relacionado; cuando la tasa de fotogramas no puede alcanzar 90 FPS, se percibirá un tirón notable al girar la cabeza o moverse. Para ofrecer una mejor experiencia, especialmente para mejorar la fluidez bajo un rendimiento de hardware limitado, los fabricantes de dispositivos suelen proporcionar técnicas como la interpolación, la interpolación de fotogramas y el suavizado, como ATW (Asynchronous Time Warp), PTW (Late Stage Reprojection), etc.

Si el dispositivo admite OpenXR, los fabricantes suelen proporcionar una OpenXR Extension o un SDK compatible directamente con OpenXR; en ese caso, es mejor introducir el SDK del fabricante para una experiencia más fluida.

Referencia relacionada

Para la configuración del proyecto y la optimización del rendimiento, consulta los capítulos Guía de optimización de ajustes del proyecto y Guía de parámetros de rendimiento de renderizado.
La capacidad de renderizado en pantalla del dispositivo VR para 3DGS es de aproximadamente 700 000 primitivas gaussianas; al renderizar escenas grandes, se recomienda establecer StartLOD en 2 y desactivar la visualización de los datos de entorno; las escenas grandes serán más fluidas con streaming desde PC.