Guide de développement de la compatibilité des formats de données LCC et LCC2

Le format de données LCC2 offre une meilleure compression des données et de meilleurs mécanismes de LOD. Le format LCC d'origine sera progressivement remplacé par LCC2, et le LCC SDK d'origine (v1.x) cessera progressivement d'être maintenu. Étant donné que les anciens et nouveaux formats de données diffèrent grandement, le nouveau LCC SDK (v2.x) n'est pas rétrocompatible avec le format LCC. La compatibilité des données peut être obtenue des deux manières suivantes :

Utiliser le convertisseur officiel (LccConverter) exe/dll pour convertir le format de données LCC en LCC2, puis l'utiliser dans le SDK ;
Implémenter la compatibilité des formats de données LCC et LCC2 au niveau de la couche applicative.

Ce guide décrit principalement le flux et les étapes de la mise en œuvre de la compatibilité des formats de données au niveau de la couche applicative, c'est-à-dire importer deux versions du SDK dans le même projet Unity en même temps et sélectionner automatiquement la version correspondante pour le rendu et le traitement en fonction du format de données.

Étape 1 : Version de Unity et paramètres du projet

La version de Unity et les paramètres du projet sont les mêmes que lors de l'utilisation indépendante du SDK ; aucune configuration supplémentaire n'est requise. Voir Guide de démarrage rapide PC et Guide d'optimisation des paramètres de projet.

Étape 2 : Importer les deux versions de SDK

Importez SDK v1.4.8 et versions ultérieures (v1.4.32 recommandé) et SDK v2.0.1 et versions ultérieures via Unity UPM. Après l'importation, la version v1.x sera affichée comme Legacy. Les deux versions de SDK peuvent coexister sans s'affecter mutuellement.

Remarque :
Le SDK v1.4.32 peut être téléchargé depuis GitHub : https://github.com/xgrids/LCC-Unity-SDK/releases
L'espace de noms du SDK v1.4.32 est LCCCore_Legacy et son composant manager est LCCManager_Legacy ; l'espace de noms de v2.x est LCCCore et son composant manager est LCCManager.

Étape 3 : Configurer la scène

Créez un objet vide dans la scène nommé LCCController, et attachez-y à la fois les composants LCCManager_Legacy et LCCManager.

Attacher les composants LCCManager_Legacy et LCCManager à l'objet LCCController

Attacher à la fois les composants LCCManager_Legacy et LCCManager à l'objet LCCController

Remarque :
Les réglages de Transform du GameObject LCCController (Rotation.x = -90, Scale.x = -1) l'alignent avec le système de coordonnées des données LCC. Pour plus de détails sur l'alignement du système de coordonnées, voir « Système de coordonnées des données LCC » dans Introduction au SDK Unity.

Étape 4 : Écrire le script MultiSDKController

Créez un nouveau script C# nommé MultiSDKController.cs avec le code suivant :

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

public class MultiSDKController : MonoBehaviour
{
    public LCCManager_Legacy m_managerLegacy;          // pour LCC SDK v1.4.8 et versions antérieures
    public LCCManager m_manager;                       // pour LCC SDK v2.0.0 et versions ultérieures
    public string m_FilePath;                          // chemin du fichier LCC
    private LCCCore_Legacy.Renderer m_rendererLegacy;  // pour LCC SDK v1.4.8 et versions antérieures
    private LCCCore.Renderer m_renderer;               // pour LCC SDK v2.0.0 et versions ultérieures
    private DataType m_dataType;                       // type de données, utilisé pour déterminer quel SDK utiliser

    void Start()
    {
        string extension = Path.GetExtension(m_FilePath);
        if (extension == ".lcc")
        {
            m_manager.Enable = false; // désactiver le 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; // désactiver le manager v1.4.8 et antérieur
            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("données chargées !!!");
    }

    // Exemple d'appel de méthode : déterminer quel renderer du SDK utiliser par type de données
    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 }
}

Remarque :
Le nom du fichier de script doit correspondre au nom de la classe (MultiSDKController.cs correspond à class MultiSDKController), sinon il ne peut pas être attaché à un GameObject.
Les deux versions ont des espaces de noms différents (LCCCore et LCCCore_Legacy). Lorsque vous utilisez des types portant le même nom tels que Renderer, PlatformType et RenderMode, vous devez les préfixer avec l'espace de noms pour les distinguer.
L'exemple détermine le format de données par l'extension de fichier (.lcc / .lcc2) et sélectionne la version de SDK correspondante.

Étape 5 : Attacher le script et définir les propriétés

Attachez également le script MultiSDKController.cs à l'objet LCCController de la scène.
Dans la fenêtre Inspecteur, faites glisser les composants LCCManager et LCCManager_Legacy sur les propriétés de script correspondantes.
Renseignez le chemin du fichier LCC / LCC2 dans la propriété File Path du script.

Attacher le script MultiSDKController et définir ses propriétés dans l'Inspecteur

Maintenant, lorsque vous exécutez le code, la version de SDK correspondante est automatiquement utilisée pour le rendu en fonction du format de données LCC, ce qui permet d'obtenir la compatibilité des formats de données.

Étapes clés

Les étapes clés pour mettre en œuvre la compatibilité des formats de données LCC et LCC2 au niveau de la couche applicative :

Importez à la fois les versions de SDK v1.x (Legacy) et v2.x via UPM ; les deux peuvent coexister.
Attachez à la fois les composants managers LCCManager_Legacy et LCCManager au même objet.
Sélectionnez le manager de la version correspondante pour créer un renderer et charger les données en fonction du format de données (extension de fichier .lcc / .lcc2).
Après avoir déterminé quelle version utiliser, désactivez le manager de l'autre version (Manager.Enable = false).
Lors du changement de données ou de la destruction, déchargez les données actuellement rendues via Renderer.Dispose().

Remarques sur la compatibilité des formats de données

Le rendu simultané de LCC et LCC2 n'est pas pris en charge. Par conséquent, lors du changement de données, vous devez d'abord décharger les données actuellement rendues (appelez Renderer.Dispose()), sinon cela peut provoquer des fuites de mémoire et de mémoire vidéo.
Désactivez le Manager inutilisé. Après avoir déterminé quelle version de SDK utiliser, il est préférable de désactiver l'objet Manager de l'autre version de SDK (Manager.Enable = false), sinon cela peut provoquer un surcoût de performance inefficace.
Les interfaces API sont cohérentes, mais vous devez appeler le bon Renderer. Les interfaces API des deux versions de SDK sont exactement les mêmes (dans v2.x, de nombreuses API ont été déplacées vers la classe Manager ; voir le manuel API), mais vous devez vous assurer d'appeler le Renderer de la bonne version (m_rendererLegacy ou m_renderer). De plus, v2.0.0 et versions ultérieures ne prennent plus en charge l'enregistrement du réglage des couleurs et de la découpe des données, et certaines autres API sont également dépréciées ; veuillez consulter la documentation développeur de la version correspondante.

API associées

Cette solution implique principalement les API manager et renderer des deux versions de SDK. Ce qui suit utilise v2.x (LCCCore) comme exemple ; v1.x (LCCCore_Legacy) a la même interface avec seulement un espace de noms différent.

LCCManager.Enable

// Propriété
public bool Enable { get; set; }

L'interrupteur d'activation du manager. Le définir sur false désactive le manager de cette version de SDK, évitant un surcoût de performance inefficace dû au fonctionnement simultané avec l'autre version.

Exemple d'utilisation :

// Lors de l'utilisation de données LCC2, désactiver le manager Legacy
m_managerLegacy.Enable = false;

Remarques :

Après avoir déterminé quelle version utiliser, il est recommandé de désactiver le manager de l'autre version.

GetRender

// Valeur de retour : Renderer → instance de rendu, null en cas d'échec
public Renderer GetRender(Transform _transform)

Crée une instance de rendu et la lie au Transform spécifié.

Paramètre	Type	Description
`_transform`	`Transform`	Le Transform auquel l'instance de rendu est attachée

Exemple d'utilisation :

m_renderer = m_manager.GetRender(this.transform);

Remarques :

Doit être créé via le manager de la version correspondante pour garantir que le renderer correspond au format de données.

Renderer.Dispose

// Valeur de retour : void
public void Dispose()

Détruit l'instance de rendu et libère toutes les ressources GPU et la mémoire. L'instance ne peut plus être utilisée après la destruction.

Exemple d'utilisation :

m_renderer?.Dispose();

Remarques :

Avant de changer de données, vous devez d'abord décharger les données actuelles, sinon cela peut provoquer des fuites de mémoire et de mémoire vidéo.
Après l'appel, il notifie automatiquement le Manager de supprimer la référence.
Il est recommandé de l'appeler lorsque l'objet est détruit (OnDestroy).