Guía de desarrollo de compatibilidad de formatos de datos LCC y LCC2

El formato de datos LCC2 proporciona una mejor compresión de datos y mejores mecanismos de LOD. El formato LCC original será reemplazado gradualmente por LCC2, y el LCC SDK original (v1.x) dejará de recibir mantenimiento gradualmente. Debido a que los formatos de datos antiguo y nuevo difieren mucho, el nuevo LCC SDK (v2.x) no es retrocompatible con el formato LCC. La compatibilidad de datos puede lograrse de las dos formas siguientes:

Usa el conversor oficial (LccConverter) exe/dll para convertir el formato de datos LCC a LCC2 y, a continuación, úsalo en el SDK;
Implementa la compatibilidad de formatos de datos LCC y LCC2 a nivel de aplicación.

Esta guía describe principalmente el flujo y los pasos de implementar la compatibilidad de formatos de datos a nivel de aplicación, es decir, importar dos versiones del SDK en el mismo proyecto de Unity al mismo tiempo y seleccionar automáticamente la versión correspondiente para renderizar y procesar según el formato de datos.

Paso 1: Versión de Unity y ajustes del proyecto

La versión de Unity y los ajustes del proyecto son los mismos que al usar el SDK de forma independiente; no se requiere configuración adicional. Consulta Guía de inicio rápido para PC y Guía de optimización de ajustes del proyecto.

Paso 2: Importar las dos versiones del SDK

Importa SDK v1.4.8 y posterior (se recomienda v1.4.32) y SDK v2.0.1 y posterior a través de Unity UPM. Después de importar, la versión v1.x se mostrará como Legacy. Las dos versiones del SDK pueden coexistir sin afectarse mutuamente.

Nota:
El SDK v1.4.32 puede descargarse desde GitHub: https://github.com/xgrids/LCC-Unity-SDK/releases
El namespace del SDK v1.4.32 es LCCCore_Legacy y su componente manager es LCCManager_Legacy; el namespace de v2.x es LCCCore y su componente manager es LCCManager.

Paso 3: Configurar la escena

Crea un objeto vacío en la escena llamado LCCController y adjunta tanto el componente LCCManager_Legacy como el componente LCCManager a él.

Adjuntar los componentes LCCManager_Legacy y LCCManager al objeto LCCController

Nota:
Los ajustes de Transform del GameObject LCCController (Rotation.x = -90, Scale.x = -1) lo alinean con el sistema de coordenadas de los datos LCC. Para más detalles sobre la alineación del sistema de coordenadas, consulta "Sistema de coordenadas de los datos LCC" en Introducción al SDK de Unity.

Paso 4: Escribir el script MultiSDKController

Crea un nuevo script C# llamado MultiSDKController.cs con el siguiente código:

using LCCCore;
using LCCCore_Legacy;
using System.IO;
using UnityEngine;

public class MultiSDKController : MonoBehaviour
{
    public LCCManager_Legacy m_managerLegacy;          // para LCC SDK v1.4.8 y anteriores
    public LCCManager m_manager;                       // para LCC SDK v2.0.0 y posteriores
    public string m_FilePath;                          // ruta del archivo LCC
    private LCCCore_Legacy.Renderer m_rendererLegacy;  // para LCC SDK v1.4.8 y anteriores
    private LCCCore.Renderer m_renderer;               // para LCC SDK v2.0.0 y posteriores
    private DataType m_dataType;                       // tipo de dato, usado para determinar qué SDK usar

    void Start()
    {
        string extension = Path.GetExtension(m_FilePath);
        if (extension == ".lcc")
        {
            m_manager.Enable = false; // desactiva el manager v2.0.0+
            m_dataType = DataType.LCC;
            m_rendererLegacy = m_managerLegacy.GetRender(this.transform);
            m_rendererLegacy.Load(m_FilePath, LCCCore_Legacy.PlatformType.PC, onLoadCallback);
        }
        else if (extension == ".lcc2")
        {
            m_managerLegacy.Enable = false; // desactiva el manager v1.4.8 y anteriores
            m_dataType = DataType.LCC2;
            m_renderer = m_manager.GetRender(this.transform);
            m_renderer.Load(m_FilePath, LCCCore.PlatformType.PC, onLoadCallback);
        }
    }

    private void onLoadCallback()
    {
        Debug.Log("datos cargados !!!");
    }

    // Ejemplo de llamada a método: determina qué renderer del SDK operar según el tipo de dato
    public void onRenderPointClick()
    {
        if (m_dataType == DataType.LCC)
            m_rendererLegacy.SwitchRenderMode(LCCCore_Legacy.RenderMode.PointCloud);
        else if (m_dataType == DataType.LCC2)
            m_renderer.SwitchRenderMode(LCCCore.RenderMode.PointCloud);
    }

    void OnDestroy()
    {
        if (m_dataType == DataType.LCC)
            m_rendererLegacy?.Dispose();
        else if (m_dataType == DataType.LCC2)
            m_renderer?.Dispose();
    }

    public enum DataType { LCC, LCC2 }
}

Nota:
El nombre del archivo de script debe coincidir con el nombre de la clase (MultiSDKController.cs corresponde a class MultiSDKController), de lo contrario no puede adjuntarse a un GameObject.
Las dos versiones tienen namespaces diferentes (LCCCore y LCCCore_Legacy). Al usar tipos con el mismo nombre como Renderer, PlatformType y RenderMode, debes anteponer el namespace para distinguirlos.
El ejemplo determina el formato de datos por la extensión del archivo (.lcc / .lcc2) y selecciona la versión del SDK correspondiente.

Paso 5: Adjuntar el script y establecer propiedades

Adjunta también el script MultiSDKController.cs al objeto LCCController en la escena.
En la ventana Inspector, arrastra los componentes LCCManager y LCCManager_Legacy a las propiedades correspondientes del script.
Rellena la ruta del archivo LCC / LCC2 en la propiedad File Path del script.

Adjuntar el script MultiSDKController y establecer sus propiedades en el Inspector

Ahora, al ejecutar el código, se usa automáticamente la versión del SDK correspondiente para el renderizado según el formato de datos LCC, logrando la compatibilidad de formatos de datos.

Pasos clave

Los pasos clave para implementar la compatibilidad de formatos de datos LCC y LCC2 a nivel de aplicación:

Importa tanto la versión v1.x (Legacy) como la v2.x del SDK mediante UPM; las dos pueden coexistir.
Adjunta los componentes manager LCCManager_Legacy y LCCManager al mismo objeto.
Selecciona el manager de la versión correspondiente para crear un renderer y cargar datos según el formato de datos (extensión del archivo .lcc / .lcc2).
Después de determinar qué versión usar, desactiva el manager de la otra versión (Manager.Enable = false).
Al cambiar de datos o al destruir, descarga los datos renderizados actualmente mediante Renderer.Dispose().

Notas de la compatibilidad de formatos de datos

No se admite el renderizado simultáneo de LCC y LCC2. Por lo tanto, al cambiar de datos, debes descargar primero los datos renderizados actualmente (llama a Renderer.Dispose()), de lo contrario puede provocar fugas de memoria y memoria de vídeo.
Desactiva el Manager no utilizado. Después de determinar qué versión del SDK usar, es mejor desactivar el objeto Manager de la otra versión del SDK (Manager.Enable = false), de lo contrario puede provocar cierto coste de rendimiento ineficaz.
Las interfaces API son consistentes, pero debes llamar al Renderer correcto. Las interfaces API de las dos versiones del SDK son exactamente las mismas (en v2.x muchas API se han movido a la clase Manager; consulta el manual de API), pero debes asegurarte de llamar al Renderer de la versión correcta (m_rendererLegacy o m_renderer). Además, v2.0.0 y posteriores ya no admiten el guardado de datos de ajuste de color y recorte, y algunas otras API también están obsoletas; consulta la documentación para desarrolladores de la versión correspondiente.

API relacionadas

Esta solución implica principalmente las API de manager y renderer de las dos versiones del SDK. A continuación se usa v2.x (LCCCore) como ejemplo; v1.x (LCCCore_Legacy) tiene la misma interfaz con solo un namespace diferente.

LCCManager.Enable

// Propiedad
public bool Enable { get; set; }

El interruptor de activación del manager. Establecerlo como false desactiva el manager de esa versión del SDK, evitando el coste de rendimiento ineficaz de trabajar simultáneamente con la otra versión.

Ejemplo de uso:

// Al usar datos LCC2, desactiva el manager Legacy
m_managerLegacy.Enable = false;

Notas:

Después de determinar qué versión usar, se recomienda desactivar el manager de la otra versión.

GetRender

// Valor de retorno: Renderer → instancia de renderizado, null en caso de error
public Renderer GetRender(Transform _transform)

Crea una instancia de renderizado y la vincula al Transform especificado.

Parámetro	Tipo	Descripción
`_transform`	`Transform`	El Transform al que se adjunta la instancia de renderizado

Ejemplo de uso:

m_renderer = m_manager.GetRender(this.transform);

Notas:

Debe crearse a través del manager de la versión correspondiente para asegurar que el renderer coincide con el formato de datos.

Renderer.Dispose

// Valor de retorno: void
public void Dispose()

Destruye la instancia de renderizado y libera todos los recursos de GPU y la memoria. La instancia no puede volver a usarse después de la destrucción.

Ejemplo de uso:

m_renderer?.Dispose();

Notas:

Antes de cambiar de datos, debes descargar primero los datos actuales, de lo contrario puede provocar fugas de memoria y memoria de vídeo.
Después de llamarla, notifica automáticamente al Manager para eliminar la referencia.
Se recomienda llamarla cuando el objeto se destruye (OnDestroy).