Entwicklungsanleitung zur Kompatibilität der Datenformate LCC und LCC2

Das Datenformat LCC2 bietet bessere Datenkomprimierung und LOD-Mechanismen. Das ursprüngliche LCC-Format wird schrittweise durch LCC2 ersetzt, und das ursprüngliche LCC SDK (v1.x) wird nach und nach nicht mehr gepflegt. Da sich das alte und das neue Datenformat stark unterscheiden, ist das neue LCC SDK (v2.x) nicht abwärtskompatibel mit dem LCC-Format. Die Datenkompatibilität kann auf die folgenden beiden Arten erreicht werden:

1. Verwenden Sie den offiziellen Konverter (LccConverter) als exe/dll, um das LCC-Datenformat in LCC2 zu konvertieren und es dann im SDK zu verwenden;
2. Implementieren Sie die Kompatibilität der Datenformate LCC und LCC2 auf Anwendungsebene.

Diese Anleitung beschreibt hauptsächlich den Ablauf und die Schritte der Implementierung der Datenformat-Kompatibilität auf Anwendungsebene, also das gleichzeitige Importieren zweier SDK-Versionen in dasselbe Unity-Projekt und das automatische Auswählen der entsprechenden Version für Rendering und Verarbeitung anhand des Datenformats.

Schritt 1: Unity-Version und Projekteinstellungen

Die Unity-Version und die Projekteinstellungen sind identisch mit der eigenständigen Verwendung des SDK; es ist keine zusätzliche Konfiguration erforderlich. Siehe PC-Schnellstartanleitung und Leitfaden zur Optimierung der Projekteinstellungen.

Schritt 2: Die beiden SDK-Versionen importieren

Importieren Sie SDK v1.4.8 und neuer (empfohlen wird v1.4.32) und SDK v2.0.1 und neuer über Unity UPM. Nach dem Import wird die Version v1.x als Legacy angezeigt. Die beiden SDK-Versionen können koexistieren, ohne sich gegenseitig zu beeinflussen.

Hinweis:

• SDK v1.4.32 kann von GitHub heruntergeladen werden: https://github.com/xgrids/LCC-Unity-SDK/releases
• Der Namespace von SDK v1.4.32 lautet LCCCore_Legacy, und seine Manager-Komponente ist LCCManager_Legacy; der Namespace von v2.x lautet LCCCore, und seine Manager-Komponente ist LCCManager.

Schritt 3: Die Szene konfigurieren

Erstellen Sie ein leeres Objekt in der Szene namens LCCController und hängen Sie sowohl die Komponente LCCManager_Legacy als auch die Komponente LCCManager daran an.

Sowohl die Komponente LCCManager_Legacy als auch die Komponente LCCManager an das Objekt LCCController anhängen

Hinweis:

Die Transform-Einstellungen des GameObject LCCController (Rotation.x = -90, Scale.x = -1) richten es am LCC-Daten-Koordinatensystem aus. Details zur Ausrichtung am Koordinatensystem finden Sie unter „LCC-Daten-Koordinatensystem“ in Einführung in das Unity SDK.

Schritt 4: Das MultiSDKController-Skript schreiben

Erstellen Sie ein neues C#-Skript namens MultiSDKController.cs mit folgendem Code:

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

public class MultiSDKController : MonoBehaviour
{
    public LCCManager_Legacy m_managerLegacy;          // für LCC SDK v1.4.8 und älter
    public LCCManager m_manager;                       // für LCC SDK v2.0.0 und neuer
    public string m_FilePath;                          // LCC-Dateipfad
    private LCCCore_Legacy.Renderer m_rendererLegacy;  // für LCC SDK v1.4.8 und älter
    private LCCCore.Renderer m_renderer;               // für LCC SDK v2.0.0 und neuer
    private DataType m_dataType;                       // Datentyp, dient zur Bestimmung, welches SDK zu verwenden ist

    void Start()
    {
        string extension = Path.GetExtension(m_FilePath);
        if (extension == ".lcc")
        {
            m_manager.Enable = false; // Manager ab v2.0.0 deaktivieren
            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; // Manager ab v1.4.8 und älter deaktivieren
            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("Daten geladen !!!");
    }

    // Methodenaufruf-Beispiel: Anhand des Datentyps bestimmen, welcher SDK-Renderer bedient werden soll
    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 }
}

Hinweis:

• Der Skriptdateiname muss mit dem Klassennamen übereinstimmen (MultiSDKController.cs entspricht class MultiSDKController), andernfalls kann es nicht an ein GameObject angehängt werden.
• Die beiden Versionen besitzen unterschiedliche Namespaces (LCCCore und LCCCore_Legacy). Bei der Verwendung gleichnamiger Typen wie Renderer, PlatformType und RenderMode müssen Sie sie mit dem Namespace präfixieren, um sie zu unterscheiden.
• Das Beispiel bestimmt das Datenformat anhand der Dateiendung (.lcc / .lcc2) und wählt die entsprechende SDK-Version aus.

Schritt 5: Das Skript anhängen und Eigenschaften festlegen

1. Hängen Sie das Skript MultiSDKController.cs ebenfalls an das Objekt LCCController in der Szene.
2. Ziehen Sie im Fenster Inspektor die Komponenten LCCManager und LCCManager_Legacy auf die entsprechenden Skript-Eigenschaften.
3. Tragen Sie den LCC- / LCC2-Dateipfad in die Eigenschaft File Path des Skripts ein.

Das MultiSDKController-Skript anhängen und dessen Eigenschaften im Inspektor festlegen

Wenn Sie den Code nun ausführen, wird anhand des LCC-Datenformats automatisch die entsprechende SDK-Version für das Rendering verwendet, wodurch die Datenformat-Kompatibilität erreicht wird.

Schlüsselschritte

Die Schlüsselschritte zur Implementierung der Kompatibilität der Datenformate LCC und LCC2 auf Anwendungsebene:

1. Importieren Sie sowohl die SDK-Version v1.x (Legacy) als auch v2.x über UPM; die beiden können koexistieren.
2. Hängen Sie sowohl die Manager-Komponente LCCManager_Legacy als auch LCCManager an dasselbe Objekt.
3. Wählen Sie den Manager der entsprechenden Version, um anhand des Datenformats (Dateiendung .lcc / .lcc2) einen Renderer zu erstellen und Daten zu laden.
4. Deaktivieren Sie nach der Bestimmung, welche Version zu verwenden ist, den Manager der anderen Version (Manager.Enable = false).
5. Entladen Sie beim Datenwechsel oder bei der Zerstörung die aktuell gerenderten Daten über Renderer.Dispose().

Hinweise zur Datenformat-Kompatibilität

• Das gleichzeitige Rendern von LCC und LCC2 wird nicht unterstützt. Daher müssen Sie beim Datenwechsel zuerst die aktuell gerenderten Daten entladen (Aufruf von Renderer.Dispose()), andernfalls kann es zu Arbeitsspeicher- und Grafikspeicher-Leaks kommen.

• Den ungenutzten Manager deaktivieren. Nach der Bestimmung, welche SDK-Version zu verwenden ist, deaktivieren Sie am besten das Manager-Objekt der anderen SDK-Version (Manager.Enable = false), andernfalls kann es zu einem gewissen ineffektiven Leistungs-Overhead kommen.

• Die API-Schnittstellen sind konsistent, aber Sie müssen den korrekten Renderer aufrufen. Die API-Schnittstellen der beiden SDK-Versionen sind exakt gleich (in v2.x wurden viele APIs in die Manager-Klasse verschoben; siehe das API-Handbuch), aber Sie müssen sicherstellen, dass Sie den Renderer der korrekten Version aufrufen (m_rendererLegacy oder m_renderer). Darüber hinaus unterstützen v2.0.0 und neuer das Speichern von Farbanpassung und Clipping-Daten nicht mehr, und einige weitere APIs sind ebenfalls veraltet; prüfen Sie bitte die Entwicklerdokumentation der entsprechenden Version.

Zugehörige APIs

Diese Lösung betrifft hauptsächlich die Manager- und Renderer-APIs der beiden SDK-Versionen. Im Folgenden wird v2.x (LCCCore) als Beispiel verwendet; v1.x (LCCCore_Legacy) besitzt dieselbe Schnittstelle mit lediglich einem anderen Namespace.

LCCManager.Enable

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

Der Aktivierungsschalter des Managers. Wird er auf false gesetzt, deaktiviert er den Manager dieser SDK-Version und vermeidet ineffektiven Leistungs-Overhead durch das gleichzeitige Arbeiten mit der anderen Version.

Verwendungsbeispiel:

// Bei Verwendung von LCC2-Daten den Legacy-Manager deaktivieren
m_managerLegacy.Enable = false;

Hinweise:

• Nach der Bestimmung, welche Version zu verwenden ist, wird empfohlen, den Manager der anderen Version zu deaktivieren.

GetRender

// Rückgabewert: Renderer → Render-Instanz, null bei Fehler
public Renderer GetRender(Transform _transform)

Erstellt eine Render-Instanz und bindet sie an die angegebene Transform.

Verwendungsbeispiel:

m_renderer = m_manager.GetRender(this.transform);

Hinweise:

• Muss über den Manager der entsprechenden Version erstellt werden, um sicherzustellen, dass der Renderer zum Datenformat passt.

Renderer.Dispose

// Rückgabewert: void
public void Dispose()

Zerstört die Render-Instanz und gibt alle GPU-Ressourcen und den Speicher frei. Die Instanz kann nach der Zerstörung nicht mehr verwendet werden.

Verwendungsbeispiel:

m_renderer?.Dispose();

Hinweise:

• Vor dem Datenwechsel müssen Sie zuerst die aktuellen Daten entladen, andernfalls kann es zu Arbeitsspeicher- und Grafikspeicher-Leaks kommen.
• Nach dem Aufruf benachrichtigt es automatisch den Manager, die Referenz zu entfernen.
• Es wird empfohlen, es bei Zerstörung des Objekts (OnDestroy) aufzurufen.