ULCCComponentBase: Basisklasse der 3DGS-Components

Basisklasse jeder LCC-Component, die Rendering, Farbe, Leistung, Kollision und GIS-Fähigkeiten trägt. ULCCComponent (LCC1) und ULCC2Component (LCC2) erben von ihr.

#include "LCCComponentBase.h"

Die Instanz über den Actor holen:

ULCCComponentBase* Component = LCCActor->GetLCCComponent();

Diese Seite ist ein Schnittstellenverzeichnis und beschreibt Signatur, Parameter und Aufrufhinweise jeder Methode. Wie ein Parameter abzustimmen ist und welche Folgen er für Bild und Leistung hat, steht im zugehörigen Themendokument:

Unterschiede zwischen den beiden Pipelines

Manche Eigenschaften und Methoden sind an der Basisklasse deklariert, aber nur eine Pipeline setzt sie tatsächlich um. Vor dem Schreiben von Code bestätigen, welche Pipeline die Zieldaten durchlaufen.

Eigenschaften

Bei Eigenschaften mit BlueprintSetter gehen das Ziehen des Werts im Details-Panel und der Aufruf des Setters im Code denselben Weg. Eigenschaften mit Interp lassen sich in Sequencer mit Keyframes versehen.

Ladepfad

Rendering-Eigenschaften

Leistungs-Eigenschaften

Das Feld Performance hat den Typ FRenderInfo. Jeder Wert bringt ein Kontrollkästchen zur Aktivierung mit, und solange das Kästchen aus ist, wird der eingebaute Standardwert genutzt. Zur Feldliste siehe Structs, zu empfohlenen Werten siehe Leistungsparameter.

Eigenschaften der Farbanpassung

Die vier Komponenten entsprechen in dieser Reihenfolge R, G, B und dem Gesamtwert. Zur Beschreibung der Wirkung der Farbanpassung siehe Bildeinstellungen.

Zu beachten: Diese Bereiche sind nur die Schieberegler-Bereiche des Panels (UIMin / UIMax) und es gibt keinen Clamp. Werte außerhalb des Bereichs, die im Code an einen Setter übergeben werden, werden nicht beschnitten, und das Ergebnis liegt beim Aufrufer. SplatScale und GlobalAlpha sind dagegen wirklich geklemmt.

Eigenschaften der Punktwolken-Einfärbung

Kollisions-Eigenschaften

Details siehe Kollision.

Kamera-Eigenschaften

Die folgenden drei Punkte wirken nur in der LCC1-Pipeline, und das Details-Panel einer LCC2-Komponente blendet die letzten zwei aus.

GIS-Eigenschaften

Zu den Einrichtungsschritten zusammen mit Cesium siehe Integration von Drittanbieter- und Engine-Plugins.

Eigenschaften für Clipping und Schnittebenen

Beide Arrays sind BlueprintReadOnly. Die Elemente nicht direkt ändern, sondern mit AddClippingVolume und den zugehörigen Methoden pflegen.

Animations-Eigenschaften

Die Animation hat zwei Stufen: Die erste Stufe wartet FirstStageDelay ab und skaliert von 0 auf AnimationMinScale, die zweite Stufe wartet SecondStageDelay ab und skaliert von AnimationMinScale auf SplatScale.

Zur Wirkung jedes Parameters und zum Abstimmen siehe Ladeanimation.

Laden und Zustand

Load

UFUNCTION(BlueprintCallable, Category = "XGrids")
bool Load(FString LCCPath);

Lädt Daten. Das ist es, was ALCCActorBase::Load letztlich aufruft.

Rückgabewert bool: true, sobald die Prüfung des Pfads besteht und der Ladevorgang startet. Die Übergabe eines leeren Pfads führt ein Entladen durch und gibt ebenfalls true zurück.

Hinweise zur Verwendung:

• true bedeutet nur, dass der Vorgang gestartet ist, nicht dass die Daten bereit sind. Die aktuelle Version erfordert ein Abfragen mit CheckIfLoaded; ein Callback für den Abschluss des Ladens wird in einer späteren Version bereitgestellt.
• Stimmt der übergebene Pfad mit dem aktuell geladenen Pfad überein, kehrt der Aufruf unmittelbar zurück und es wird nichts erneut geladen.
• Ein erfolgreiches Laden schreibt den Pfad in DefaultLoadPath.

ULCCComponentBase* Component = LCCActor->GetLCCComponent();
if (Component && Component->Load(TEXT("D:/Data/Tower/Tower.lcc")))
{
    UE_LOG(LogTemp, Log, TEXT("Load started"));
}

UnLoad

UFUNCTION(BlueprintCallable, Category = "XGrids")
virtual void UnLoad();

Entlädt die Daten, gibt Node-Caches, GPU-Buffer und Kollisionskörper frei und leert DefaultLoadPath.

Zwei Punkte sind zu beachten:

• Weil DefaultLoadPath geleert wird, lädt ein Refresh() unmittelbar nach UnLoad() nichts.
• Die Metadaten werden nicht geleert. Nach dem Entladen geben GetMetaInfo() und GetSplatNumber() weiterhin die Daten des vorherigen Ladens zurück, sie taugen also nicht zur Prüfung, ob die Daten entladen sind; dafür CheckIfLoaded nutzen.

Refresh

UFUNCTION(BlueprintCallable, Category = "XGrids")
void Refresh();

Lädt die aktuellen Daten erneut. Die Umsetzung ist UnLoad() plus Load(DefaultLoadPath), die Kosten entsprechen also einem vollständigen erneuten Laden.

Damit erneut von der Festplatte lesen, nachdem die Datendateien auf der Festplatte ersetzt wurden. Um das Rendering für ein einzelnes Bild zu aktualisieren, ForceUpdate nutzen.

ForceUpdate

UFUNCTION(BlueprintCallable, Category = "XGrids")
void ForceUpdate();

Markiert das nächste Bild, um eine Aktualisierung der Szene zu erzwingen, zu sehr geringen Kosten.

Das Plugin überspringt Node-Aktualisierungen, solange sich weder die Kamera noch die Rendering-Parameter ändern. Wurde von außen etwas geändert, das die Sichtbarkeit betrifft, und das Bild folgte nicht, damit ein Bild anstoßen. Nicht in jedem Bild aufrufen, das hebt die Sprung-Optimierung auf.

CheckIfLoaded

UFUNCTION(BlueprintPure, Category = "XGrids")
virtual bool CheckIfLoaded() const;

Ob Metadaten und Indexstruktur aufgebaut sind. BlueprintPure, also ein reiner Node ohne Ausführungspins in Blueprint.

Genaue Bedeutung: LCC1 prüft, ob der Node-Manager erzeugt ist, LCC2 prüft, ob der Baum erzeugt ist. true bedeutet, dass das Parsen der Metadaten abgeschlossen ist und die Metadaten gelesen sowie Parameter sicher konfiguriert werden können, aber die Splat-Daten strömen weiterhin je Ansicht nach und das Bild füllt sich weiter auf.

Anders gesagt bedeutet es nicht „das Bild ist vollständig“. Für Fälle, die auf ein stabiles Bild warten müssen, gibt diese Funktion keine Antwort.

if (Component->CheckIfLoaded())
{
    // safe to read metadata and configure parameters
}

Blueprint als Text, Abfrage alle 0,2 Sekunden:

[Event BeginPlay]
        │
        ▼
[Set Timer by Event]
        Time = 0.2
        Looping = true
        Event ──▶ [Custom Event: CheckLoaded]

[Custom Event: CheckLoaded]
        │
        ▼
[Get LCC Component] ──▶ [Check If Loaded]
                              │ Return Value ──┐
                              ▼                │
                        [Branch] ◀─────────────┘
                              │ True
                              ▼
                        [Clear and Invalidate Timer by Handle]
                              │
                              ▼
                        (Konfiguration nach Abschluss des Ladens)

GetSplatNumber

UFUNCTION(BlueprintCallable, Category = "XGrids")
int GetSplatNumber() const;

Gibt die Gesamtzahl der Splats der Daten zurück, entnommen dem Feld TotalSplats der Metadaten.

Hinweise zur Verwendung:

• Das ist die innere Gesamtzahl der Daten. Sie ändert sich nicht mit der Kamerabewegung und ist nicht die im aktuellen Bild tatsächlich gerenderte Menge.
• Gibt vor dem ersten Laden 0 zurück. Da UnLoad() die Metadaten aber nicht leert, gibt sie nach dem Entladen weiterhin den vorherigen Wert zurück.
• Um die Render-Last des aktuellen Bildes zu erfahren, das Statistik-Panel mit Stats() am Actor öffnen und die Live-Daten lesen.

if (Component->CheckIfLoaded())
{
    UE_LOG(LogTemp, Log, TEXT("Total splats in dataset: %d"),
        Component->GetSplatNumber());
}

HaveValidSplatData

UFUNCTION(BlueprintCallable, Category = "XGrids")
virtual bool HaveValidSplatData();

Ob gültige Splat-Daten zum Rendern verfügbar sind. Gibt false zurück, wenn das Laden fehlgeschlagen ist oder die Daten leer sind.

HaveValidCollisionData

UFUNCTION(BlueprintCallable, Category = "XGrids")
bool HaveValidCollisionData();

Ob die Daten eine Kollisionsdatei mitbringen.

Zu beachten: Es wird nur die neuere collision.lci geprüft, nicht die alte collision.bin und keine Punktwolken-Kollision als .ply. Das Laden der Kollision selbst unterstützt alle drei Formate, ein Datensatz mit nur collision.bin kann diese Funktion also false zurückgeben lassen, während SetLCCCollisionEnable(true) dennoch erfolgreich lädt.

Um alle drei Formate zuverlässig zu prüfen, ULCCUtilLibrary::DetermineCollisionType nutzen (das Verzeichnis übergeben, das die Daten enthält).

if (Component->HaveValidCollisionData())
{
    Component->SetLCCCollisionEnable(true);
}

CanRender

UFUNCTION(BlueprintCallable, Category = "XGrids")
virtual bool CanRender() const;

Ob die Bedingungen für das Rendering derzeit erfüllt sind. Die Kriterien sind der Sichtbarkeitszustand der Component plus die Frage, ob die Datenstruktur der Unterklasse aufgebaut ist (LCC1 prüft den Node-Manager, LCC2 prüft den Baum). Die Gültigkeit der Metadaten ist nicht beteiligt.

CanSetShcoef

UFUNCTION(BlueprintCallable, Category = "XGrids")
bool CanSetShcoef() const;

Ob die Daten Koeffizienten der Kugelflächenfunktionen mitbringen. Die Umsetzung entspricht der Prüfung, dass der Dateityp EFileType::Quality ist.

Vor dem Aufruf von SetUseShcoef prüfen und damit entscheiden, ob der Schalter für die Kugelflächenfunktionen in einer UI ausgegraut wird.

GetMetaInfo

UFUNCTION(BlueprintPure, Category = "XGrids")
virtual FMetaInfoBase GetMetaInfo() const;

Gibt die Metadaten der Daten zurück, einschließlich Name, Version, Koordinatensystem, Gesamtzahl der Levels, Gesamtzahl der Splats und mehr. Zu den Feldern siehe Structs.

Nach Abschluss des Ladens lesen; solange die Daten nicht bereit sind, sind die Felder Nullwerte. Der Rückgabewert ist ein Schnitt der Basisklasse, für die vollständigen LCC1-/LCC2-Felder daher die eigenen Methoden der Unterklassen nutzen.

if (Component->CheckIfLoaded())
{
    const FMetaInfoBase Meta = Component->GetMetaInfo();
    UE_LOG(LogTemp, Log, TEXT("Name=%s Levels=%d RTK=%s"),
        *Meta.Name, Meta.TotalLevel, Meta.IsRTK() ? TEXT("yes") : TEXT("no"));
}

GetLocalVisibleBounds

UFUNCTION(BlueprintPure, Category = "XGrids")
virtual FBox GetLocalVisibleBounds() const;

Gibt die sichtbare Bounding Box des Modells im lokalen Raum der Component zurück. Gibt eine ungültige Box (FBox(ForceInit)) zurück, wenn die Daten nicht verfügbar sind, daher vor der Verwendung IsValid prüfen.

Für den Weltraum sie mit GetComponentTransform() transformieren. Ein gängiger Zweck ist das automatische Platzieren der Kamera, damit die gesamte Szene ins Bild passt.

const FBox LocalBounds = Component->GetLocalVisibleBounds();
if (LocalBounds.IsValid)
{
    const FBox WorldBounds =
        LocalBounds.TransformBy(Component->GetComponentTransform());

    const FVector Center = WorldBounds.GetCenter();
    const float Radius = WorldBounds.GetExtent().Size();
    // use Center and Radius to compute the viewing position
}

GetLccVersion

virtual ELCCVersion GetLccVersion() const;

Gibt die Version der Daten zurück, ELCCVersion::LCC oder ELCCVersion::LCC2. Nur C++.

Rendering

Zur Bildwirkung und zu den Abwägungen jedes Parameters siehe Rendering und Bildeinstellungen; dieser Abschnitt behandelt nur die Schnittstellen.

SetRenderMode / GetRenderMode

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetRenderMode(ERenderMode InRenderMode);

UFUNCTION(BlueprintPure, Category = "XGrids")
ERenderMode GetRenderMode() const;

Wechselt zwischen 3DGS (ERenderMode::Splatting) und Punktwolke (ERenderMode::PointCloud).

Im Punktwolken-Modus haben die 3DGS-eigenen Punkte keine Wirkung, und die Deckkraft kommt stattdessen von GlobalAlpha_PointCloud.

Zugehöriger Panel-Parameter: Render Mode.

Component->SetRenderMode(ERenderMode::PointCloud);

Blueprint als Text:

[Input Action: ToggleView]
        │ Pressed
        ▼
[Get LCC Component]
        Target = LCCActor
        │ Return Value ──┐
        ▼                │
[Set Render Mode] ◀──────┘
        Target = (Return Value)
        In Render Mode = Point Cloud

ToggleRenderMode

UFUNCTION(BlueprintCallable, Category = "XGrids")
void ToggleRenderMode();

Wechselt zwischen 3DGS und Punktwolke hin und her, ohne den aktuellen Zustand zu prüfen.

SetLoadMode / GetLoadMode

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetLoadMode(ELoadMode Mode);

UFUNCTION(BlueprintPure, Category = "XGrids")
ELoadMode GetLoadMode() const;

Steuert, ob die Hauptdaten, die Umgebungsdaten oder beide gerendert werden. Zu den Werten siehe ELoadMode, zur Beschreibung im Panel siehe Load Mode.

ELoadMode::None entspricht einem vorübergehenden Ausblenden, während die bereits geladenen Daten im Arbeitsspeicher bleiben, die Wiederherstellung ist daher schneller als mit UnLoad.

Component->SetLoadMode(ELoadMode::OnlyMain);

SetLightMode / GetLightMode

UFUNCTION(BlueprintCallable, Category = "XGrids")
virtual void SetLightMode(ELightMode InLightMode);

UFUNCTION(BlueprintPure, Category = "XGrids")
ELightMode GetLightMode() const;

Steuert, ob die Daten an der Szenenbeleuchtung teilnehmen, ELightMode::Unlit oder ELightMode::Lit.

Die beiden Pipelines setzen es unterschiedlich um:

• LCC1 macht es durch Wechsel zwischen Lit- und Unlit-Material.
• LCC2 wechselt kein Material; die Beleuchtung wird im Shader behandelt. LCC2 benötigt daher zusätzlich ein konfiguriertes NormalMode, um ein sinnvolles Shading zu erhalten, siehe ULCC2Component und Normalen und Beleuchtung.

Erfasste Daten haben die Beleuchtung vor Ort bereits eingebacken, das Umschalten auf Lit überstrahlt daher leicht. LCC2 kann die ursprüngliche Helligkeit mit LightingScale senken.

Dieser Setter hat im Punktwolken-Modus keine Wirkung: Die Zuweisung wird intern übersprungen und eine Warnung ausgegeben. Um den Lichtmodus zu ändern, zuerst zurück auf 3DGS wechseln.

Zugehöriger Panel-Parameter: Light Mode.

ToggleLightMode

UFUNCTION(BlueprintCallable, Category = "XGrids")
void ToggleLightMode();

Wechselt zwischen Unlit und Lit.

SetUseShcoef / GetUseShcoef

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetUseShcoef(bool InUseShcoef);

UFUNCTION(BlueprintPure, Category = "XGrids")
bool GetUseShcoef() const;

Schaltet die Kugelflächenfunktionen um. Kugelflächenfunktionen liefern blickwinkelabhängige Farbvariation; sind sie aus, ist die Farbe fest.

Hinweise zur Verwendung:

• Es erfordert, dass die Daten Kugelflächenfunktionen mitbringen, geprüft mit CanSetShcoef. Portable-Daten haben keine Kugelflächenfunktionen zur Verfügung und dieser Punkt ist im Panel nicht editierbar.
• Dieser Setter wird im Punktwolken-Modus stillschweigend ignoriert. Intern erfordert er, dass die Daten vom Typ Quality sind und der aktuelle Modus nicht Punktwolke ist; scheitert eine der beiden Bedingungen, wird die Zuweisung übersprungen.
• LCC2 kann die Anzahl der Bänder senken statt sie vollständig abzuschalten, siehe SetSHBands.
• Zur Beschreibung im Panel siehe Kugelflächenfunktionen (SH).

if (Component->CanSetShcoef())
{
    Component->SetUseShcoef(false);
}

ToggleShcoef

UFUNCTION(BlueprintCallable, Category = "XGrids")
void ToggleShcoef();

Schaltet die Kugelflächenfunktionen um, nützlich zum Vergleichen der Wirkung.

SetSplatScale / GetSplatScale

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetSplatScale(float InSplatScale);

UFUNCTION(BlueprintPure, Category = "XGrids")
float GetSplatScale() const;

Größe des Splat-Quads, von 0.001 bis 1.0, Standard 1.0.

Hinweise zur Verwendung:

• Der Standardwert 1.0 ist die Obergrenze, er lässt sich also nur senken.
• Ein Senken reduziert Overdraw und hebt die Bildrate, um den Preis möglicher Löcher im Bild, sobald die Quads kleiner werden.
• Wirkt nur im 3DGS-Modus.
• Zur Beschreibung im Panel siehe SplatScale.

// trade overdraw for frame rate, weighing the holes case by case
Component->SetSplatScale(0.8f);

SetGlobalAlpha / GetGlobalAlpha

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetGlobalAlpha(float InGlobalAlpha);

UFUNCTION(BlueprintPure, Category = "XGrids")
float GetGlobalAlpha() const;

Gesamte 3DGS-Deckkraft, von 0 bis 1. Als Interp markiert, lässt sie sich daher in Sequencer für Überblendungen mit Keyframes versehen.

Für den Punktwolken-Modus SetGlobalAlpha_PointCloud nutzen; die beiden Werte sind unabhängig. Zur Beschreibung im Panel siehe Global Alpha.

// fade out frame by frame
const float Next = FMath::FInterpTo(
    Component->GetGlobalAlpha(), 0.0f, DeltaTime, 2.0f);
Component->SetGlobalAlpha(Next);

Blueprint als Text, Ausblenden mit einer Timeline:

[Timeline: FadeOut]
        Length = 2.0
        Float Track "Alpha" = 1.0 → 0.0
        │ Update
        ▼
[Set Global Alpha]
        Target = (LCC Component)
        In Global Alpha = (Alpha-Ausgang der Timeline)

SetGlobalAlpha_PointCloud / GetGlobalAlpha_PointCloud

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetGlobalAlpha_PointCloud(float InGlobalAlpha);

UFUNCTION(BlueprintPure, Category = "XGrids")
float GetGlobalAlpha_PointCloud() const;

Gesamte Deckkraft im Punktwolken-Modus, von 0 bis 1, Standard 0.2.

SetUseMipFilter / GetUseMipFilter

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetUseMipFilter(bool InUseMipFilter);

UFUNCTION(BlueprintPure, Category = "XGrids")
bool GetUseMipFilter() const;

Schaltet die Filterung gegen Flackern um, standardmäßig aktiviert. Aktiviert nutzt sie einen Tiefpassfilter mit Kompensation der Deckkraft und ist in unterschiedlichen Maßstäben stabiler; deaktiviert ist das Bild schärfer, kann aber Aliasing und Flackern zeigen. Nur im 3DGS-Modus wirksam.

Zur Beschreibung im Panel siehe Mip Filter.

EnableReceiveShadows / DisableReceiveShadows

UFUNCTION(BlueprintCallable, Category = "XGrids")
void EnableReceiveShadows();

UFUNCTION(BlueprintCallable, Category = "XGrids")
void DisableReceiveShadows();

Schaltet das Empfangen von Schatten um, eine experimentelle Funktion.

Hinweise zur Verwendung:

• Nur in der LCC1-Pipeline unterstützt; das Details-Panel einer LCC2-Komponente blendet die Eigenschaft aus.
• Nur im 3DGS-Modus wirksam, mit deutlichen Auswirkungen auf die Leistung.
• Intern durch Wechsel auf ein eigenes Material umgesetzt, die Materialeinrichtung läuft daher erneut.
• Zur Beschreibung im Panel siehe Empfangen von Schatten.

Leistung

Diese Gruppe von Settern teilt ein Verhalten: Ein Aufruf setzt automatisch das zugehörige Kontrollkästchen auf true. Die Getter geben den wirksamen Wert zurück, und solange das Kästchen aus ist, geben sie den eingebauten Standardwert zurück statt des vorher eingegebenen Werts.

GetPreloadDistance ist die einzige Ausnahme: Es gibt den rohen Feldwert zurück, nicht den wirksamen Wert.

Zu empfohlenen Werten siehe Leistungsparameter und Leitfaden zur Leistung.

SetMaxDistance / GetMaxDistance

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetMaxDistance(const int32 InDistance);

UFUNCTION(BlueprintPure, Category = "XGrids")
int32 GetMaxDistance() const;

Maximale Render-Distanz in Metern, eingebauter Standardwert 300. Nodes jenseits dieser Distanz werden nicht gerendert.

Zugehöriger Panel-Parameter: Max Distance.

Component->SetMaxDistance(80);

SetMaxSplatNum / GetMaxSplatNum

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetMaxSplatNum(const int32 InSplatNum);

UFUNCTION(BlueprintPure, Category = "XGrids")
int32 GetMaxSplatNum() const;

Maximale Anzahl der Splats pro Bild, in Einheiten von Zehntausend, Obergrenze 10000. Die Übergabe von 1500 bedeutet 15 Millionen.

Werte über dem, was die GPU in einem einzelnen Bild verarbeiten kann, werden automatisch begrenzt. Zugehöriger Panel-Parameter: Max Splat Num.

Component->SetMaxSplatNum(1500);   // 15 million

SetLevelFactor / GetLevelFactor

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetLevelFactor(const float InLevelFactor);

UFUNCTION(BlueprintPure, Category = "XGrids")
float GetLevelFactor() const;

Skalierungsfaktor des LOD, von 0.01 bis 20, Standard 1. Ein größerer Wert bedeutet weniger Details und bessere Leistung.

Der Mechanismus unterscheidet sich je Pipeline:

• LCC1: skaliert RangeForLevel aus den Projekteinstellungen und ändert damit die Zuordnung von Distanz und Level.
• LCC2: wirkt als Skalierungsfaktor des Screen-Space-Fehlers bei der Auswahl der Nodes.

Die Bildwirkung desselben Werts lässt sich daher zwischen den beiden Pipelines nicht direkt vergleichen; jede einzeln vermessen.

Zugehöriger Panel-Parameter: Level Factor.

Component->SetLevelFactor(1.5f);

SetStartLevel / GetStartLevel

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetStartLevel(const int32 InStartLevel);

UFUNCTION(BlueprintPure, Category = "XGrids")
int32 GetStartLevel() const;

Start-Level, von 0 bis 20, Standard 0. Level 0 hat die höchsten Details; ein Erhöhen überspringt die feinsten Levels und senkt den Verbrauch an Videospeicher sowie die geladene Menge deutlich.

Zugehöriger Panel-Parameter: Start Level.

SetEndLevel / GetEndLevel

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetEndLevel(const int32 InEndLevel);

UFUNCTION(BlueprintPure, Category = "XGrids")
int32 GetEndLevel() const;

End-Level, von 0 bis 20, Standard 20. Es begrenzt das gröbste Level und braucht normalerweise keine Änderung.

Zugehöriger Panel-Parameter: End Level.

SetMaxCollisionDistance / GetMaxCollisionDistance

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetMaxCollisionDistance(const int32 InMaxCollisionDistance);

UFUNCTION(BlueprintPure, Category = "XGrids")
int32 GetMaxCollisionDistance() const;

Maximale Ladedistanz der Kollision in Metern, eingebauter Standardwert 300.

Bei Strahlentests über große Entfernungen muss dieser Wert den Testbereich abdecken, sonst wird nichts getroffen.

Zugehöriger Panel-Parameter: Max Load Collision Distance.

SetPreloadDistance / GetPreloadDistance

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetPreloadDistance(const int32 InPreloadDistance);

UFUNCTION(BlueprintPure, Category = "XGrids")
int32 GetPreloadDistance() const;

Preload-Distanz in Metern.

Hinweis: In der aktuellen Version liegt die wirksame Logik fest bei MaxDistance + 35, der über den Setter gesetzte Wert nimmt nicht an der Berechnung teil, und der Punkt wird im Panel nicht angezeigt. Die Schnittstelle bleibt aus Kompatibilitätsgründen erhalten und braucht im normalen Gebrauch keine Aufrufe.

Farbanpassung

Die Eigenschaften der Farbanpassung sind alle FVector4, wobei die vier Komponenten in dieser Reihenfolge R, G, B und dem Gesamtwert entsprechen. Jeder Setter der Farbanpassung wirkt unmittelbar. Zur Beschreibung der Wirkung siehe Bildeinstellungen.

UFUNCTION(BlueprintCallable, Category = "XGrids|Color")
void SetSaturation(const FVector4 InSaturation);   // saturation, 0~2
void SetContrast(const FVector4 InContrast);       // contrast, 0~2
void SetGamma(const FVector4 InGamma);             // gamma, 0~2
void SetOffset(const FVector4 InOffset);           // additive offset, -1~1
void SetColorTint(const FLinearColor InColor);     // multiplicative tint

// matching Getters
FVector4 GetSaturation() const;
FVector4 GetContrast() const;
FVector4 GetGamma() const;
FVector4 GetOffset() const;
FLinearColor GetColorTint() const;

Offset ist additiv und hebt die dunklen Bereiche mitsamt allem anderen an; ColorTint ist multiplikativ und hält die dunklen Bereiche dunkel. Zur Wirkung jedes Punkts siehe Farbanpassung.

// lower saturation and brighten slightly
Component->SetSaturation(FVector4(0.6f, 0.6f, 0.6f, 0.6f));
Component->SetOffset(FVector4(0.05f, 0.05f, 0.05f, 0.f));

Höheneinfärbung der Punktwolke

UFUNCTION(BlueprintCallable, Category = "XGrids|PointCloud")
void SetElevationColorBottom(FLinearColor InElevationColorBottom);

UFUNCTION(BlueprintCallable, Category = "XGrids|PointCloud")
void SetElevationColorTop(FLinearColor InElevationColorTop);

UFUNCTION(BlueprintPure, Category = "XGrids|PointCloud")
FLinearColor GetElevationColorBottom() const;

UFUNCTION(BlueprintPure, Category = "XGrids|PointCloud")
FLinearColor GetElevationColorTop() const;

Untere und obere Farbe des Höhenverlaufs, standardmäßig Blau bis Rot.

Component->SetRenderMode(ERenderMode::PointCloud);
Component->SetElevationColorBottom(FLinearColor(0.0f, 0.2f, 1.0f, 1.0f));
Component->SetElevationColorTop(FLinearColor(1.0f, 0.1f, 0.0f, 1.0f));

Kollision

SetLCCCollisionEnable

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetLCCCollisionEnable(const bool InEnable);

Schaltet das Laden der Kollisionsdaten um.

Hinweise zur Verwendung:

• Es erfordert, dass die Daten eine Kollisionsdatei mitbringen, zuvor bestätigt mit HaveValidCollisionData.
• Die Kollision strömt nach Distanz nach, begrenzt durch Performance.CollisionLoadMaxDistance.
• Sobald aktiviert, arbeiten Engine-Funktionen wie LineTraceByChannel, Charakterbewegung und Physiksimulation unmittelbar.
• Die erste Aktivierung bringt einmalige Kosten für das Backen mit, die kurzes Ruckeln verursachen können. Sie möglichst während der Ladephase aktivieren.
• ShowCollision() am Actor zeigt das Drahtgitter der Kollision, um zu bestätigen, ob sie geladen wurde.

Zur vollständigen Beschreibung siehe Kollision.

if (Component->HaveValidCollisionData())
{
    Component->SetMaxCollisionDistance(50);
    Component->SetLCCCollisionEnable(true);
}

GIS

Die geografische Platzierung wird meist zusammen mit Cesium genutzt, um eine LCC-Szene an echten Erdkoordinaten zu platzieren. Zu den Einrichtungsschritten, den Plugin-Abhängigkeiten und den Vorbehalten siehe Integration von Drittanbieter- und Engine-Plugins.

SetGeoPlacement

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetGeoPlacement(bool InEnable);

Schaltet das Platzieren der Szene nach Breite und Länge um.

Sobald aktiviert, wird die Szene automatisch nach echten geografischen Koordinaten positioniert, die manuell gesetzte Actor-Position wird überschrieben, und die Feinabstimmung läuft über GeoLocationOffset. Mehrere LCC-Szenen mit aktivierter Option richten sich automatisch an ihren echten relativen Positionen aus.

Hinweise zur Verwendung:

• Intern läuft ein Refresh() (Entladen plus erneutes Laden), ein Aufruf wirkt daher zu jedem Zeitpunkt und ein manuelles Load() ist nicht erforderlich. Die Kosten entsprechen einem vollständigen erneuten Laden, die Option daher nicht häufig umschalten.
• Es erfordert, dass die Daten RTK-Informationen mitbringen. Mit GetMetaInfo().IsRTK() prüfen, nicht mit CanUseGeoPlace(): Letzteres erfordert, dass die geografische Platzierung schon aktiviert ist, und ist davor immer false.

if (Component->CheckIfLoaded() && Component->GetMetaInfo().IsRTK())
{
    Component->SetGeoPlacement(true);   // reloads automatically
}

CanUseGeoPlace

UFUNCTION(BlueprintCallable, Category = "XGrids")
bool CanUseGeoPlace() const;

Ob die geografische Platzierung derzeit in einem nutzbaren Zustand ist. Drei Bedingungen müssen gleichzeitig gelten: bEnableGeoPlace ist aktiviert, die Daten bringen RTK-Informationen mit, und das geografische Referenzsystem ist erzeugt.

Das ist kein Kriterium dafür, „ob die Daten geografische Platzierung unterstützen“. Weil es erfordert, dass bEnableGeoPlace schon true ist, gibt ein Aufruf vor dem Aktivieren immer false zurück. Um vor dem Aktivieren zu prüfen, ob die Daten es unterstützen, GetMetaInfo().IsRTK() nutzen.

Der tatsächliche Zweck ist die Bestätigung nach dem Aktivieren, dass es wirklich gewirkt hat.

GetRTKBaseLocation

UFUNCTION(BlueprintCallable, Category = "XGrids")
FVector GetRTKBaseLocation() const;

Gibt die in den Engine-Raum umgerechnete Position der RTK-Basisstation zurück, also den geografischen Ursprung der Daten. Sie ist der Bezugspunkt, wenn externe geografische Koordinaten in Engine-Koordinaten umzurechnen sind.

Hinweis: Intern wird für die Koordinatenumrechnung unmittelbar das geografische Referenzsystem genutzt, ohne Prüfung auf null. Ein Aufruf, während das geografische Referenzsystem nicht erzeugt ist, stürzt ab. Vor dem Aufruf bestätigen, dass CanUseGeoPlace true ist oder dass GetGeoReferencingSystem nicht null zurückgibt.

GetGeoReferencingSystem

UFUNCTION(BlueprintCallable, Category = "XGrids")
ALCCGeoReferencingSystem* GetGeoReferencingSystem() const;

Gibt den Actor des geografischen Referenzsystems in der Szene zurück, den das Plugin bei aktivierter geografischer Platzierung automatisch erzeugt.

ALCCGeoReferencingSystem* GeoSystem = Component->GetGeoReferencingSystem();
if (GeoSystem)
{
    // projected coordinates to engine coordinates
    FVector EngineLocation;
    GeoSystem->ProjectedToEngine(ProjectedCoord, EngineLocation);

    // east/north/up directions at that point
    FVector East, North, Up;
    GeoSystem->GetENUVectorsAtEngineLocation(EngineLocation, East, North, Up);
}

Multi-Viewport

Derselbe Datensatz kann für unterschiedliche Kameras unterschiedliche Rendering-Strategien nutzen. Ein typischer Zweck ist hochwertiges 3DGS im Hauptviewport und eine über SceneCapture gerenderte Punktwolken-Aufsicht für eine Minimap.

Hinweis: Diese Gruppe von Schnittstellen gilt nur für die LCC1-Pipeline. Ein Aufruf in der LCC2-Pipeline (ALCC2Actor und .sog / .spz / .ply) löst keinen Fehler aus, liefert aber nicht das erwartete Ergebnis. LCC1-Daten nutzen, wenn unterschiedliches Rendering in mehreren Viewports oder Vorladen vor einem Teleport gebraucht wird.

Sie nehmen Objektzeiger, nicht ganzzahlige IDs.

Zum grundsätzlichen Vorgehen bei mehreren Kameras und mehreren Bildschirmausgaben (nDisplay, Aximmetry, Pixotope und weitere) siehe Integration von Drittanbieter- und Engine-Plugins.

SetPlayerLoadMode

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetPlayerLoadMode(class APlayerController* PlayerController, ELoadMode InLoadMode);

Setzt einen eigenen LoadMode für den angegebenen Player Controller, wirksam im nächsten Bild.

APlayerController* PC2 = UGameplayStatics::GetPlayerController(GetWorld(), 1);
Component->SetPlayerLoadMode(PC2, ELoadMode::OnlyMain);

SetPlayerRenderMode

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetPlayerRenderMode(class APlayerController* PlayerController, ERenderMode InRenderMode);

Setzt einen eigenen RenderMode für den angegebenen Player Controller, wirksam im nächsten Bild.

SetSceneCaptureLoadMode

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetSceneCaptureLoadMode(class USceneCaptureComponent2D* InCapture2D, ELoadMode InLoadMode);

Setzt einen eigenen LoadMode für das angegebene SceneCapture.

Zuvor muss SceneCaptureComponent Support in den Projekteinstellungen aktiviert werden, sonst wird LCC-Inhalt in SceneCapture nicht gerendert.

SetSceneCaptureRenderMode

UFUNCTION(BlueprintCallable, Category = "XGrids")
void SetSceneCaptureRenderMode(class USceneCaptureComponent2D* InCapture2D, ERenderMode InRenderMode);

Setzt einen eigenen RenderMode für das angegebene SceneCapture.

// minimap uses point cloud and the main part only, the cheapest option
Component->SetSceneCaptureRenderMode(MinimapCapture, ERenderMode::PointCloud);
Component->SetSceneCaptureLoadMode(MinimapCapture, ELoadMode::OnlyMain);

ModifyPlayerTransform

UFUNCTION(BlueprintCallable, Category = "XGrids")
void ModifyPlayerTransform(class APlayerController* PlayerController, FTransform InTransform);

Überschreibt die Position des angegebenen Spielers in dieser Szene, genutzt zum Vorladen der Daten eines Ziels vor einem Teleport.

Das Problem, das es löst: Ein Teleport unmittelbar an einen fernen Ort lässt die Nodes des Ziels ungeladen, der Spieler sieht daher einen leeren Hauptteil, der sich allmählich auffüllt.

Richtige Reihenfolge:

ModifyPlayerTransform(Ziel)
        ↓ rund 0,2 Sekunden warten, damit die Nodes des Ziels zu laden beginnen
den Spieler tatsächlich teleportieren
        ↓ rund weitere 0,2 Sekunden warten
CancelModifyPlayerTransform

void AMyTeleporter::TeleportWithPreload(APlayerController* PC, const FTransform& Destination)
{
    Component->ModifyPlayerTransform(PC, Destination);

    FTimerHandle Handle;
    GetWorld()->GetTimerManager().SetTimer(Handle,
        [this, PC, Destination]()
        {
            PC->GetPawn()->SetActorTransform(Destination);

            FTimerHandle CancelHandle;
            GetWorld()->GetTimerManager().SetTimer(CancelHandle,
                [this, PC]()
                {
                    Component->CancelModifyPlayerTransform(PC);
                },
                0.2f, false);
        },
        0.2f, false);
}

Blueprint als Text:

[Custom Event: TeleportTo]
        Destination (Transform)
        │
        ▼
[Modify Player Transform]
        Target = (LCC Component)
        Player Controller = Get Player Controller
        In Transform = Destination
        │
        ▼
[Delay]  Duration = 0.2
        │
        ▼
[Set Actor Transform]
        Target = Get Player Pawn
        New Transform = Destination
        │
        ▼
[Delay]  Duration = 0.2
        │
        ▼
[Cancel Modify Player Transform]
        Target = (LCC Component)
        Player Controller = Get Player Controller

CancelModifyPlayerTransform

UFUNCTION(BlueprintCallable, Category = "XGrids")
void CancelModifyPlayerTransform(class APlayerController* PlayerController);

Hebt das Überschreiben der Position auf und kehrt zur Nutzung der laufenden Spielerposition zurück.

Der Aufruf ist erforderlich, sonst bleibt die Node-Planung für diesen Spieler an der überschriebenen Position stehen und mit der Bewegung des Spielers werden keine neuen Nodes geladen.

Clipping und Schnittebenen

Zur Nutzung von Clipping und Schnittebenen siehe Szenenbearbeitung, zusammen mit ALCCClippingVolume und ALCCSectionPlane.

AddClippingVolume

UFUNCTION(BlueprintCallable, Category = "XGrids")
void AddClippingVolume(ALCCClippingVolume* InClippingVolume);

Ergänzt ein Clipping-Volumen.

ALCCClippingVolume* Volume = GetWorld()->SpawnActor<ALCCClippingVolume>(
    ALCCClippingVolume::StaticClass(), Location, FRotator::ZeroRotator);

Volume->VolumeType = EClipVolumeType::Box;
Volume->Mode = EClipType::Inside;
Volume->bEnabled = true;

Component->AddClippingVolume(Volume);

RemoveClippingVolume

UFUNCTION(BlueprintCallable, Category = "XGrids")
void RemoveClippingVolume(ALCCClippingVolume* InClippingVolume);

Entfernt ein Clipping-Volumen. Für ein vorübergehendes Deaktivieren ist das Ändern von bEnabled am Clipping-Volumen leichter.

AddSectionPlane

UFUNCTION(BlueprintCallable, Category = "XGrids")
void AddSectionPlane(ALCCSectionPlane* InSectionPlane);

Ergänzt eine Schnittebene.

RemoveSectionPlane

UFUNCTION(BlueprintCallable, Category = "XGrids")
void RemoveSectionPlane(ALCCSectionPlane* InSectionPlane);

Entfernt eine Schnittebene.

Ladeanimation

SetEnableAnimation / GetEnableAnimation

UFUNCTION(BlueprintCallable, Category = "XGrids|Animation")
void SetEnableAnimation(bool bInEnableAnimation);

UFUNCTION(BlueprintPure, Category = "XGrids|Animation")
bool GetEnableAnimation() const;

Schaltet die Animation um und setzt den Zeitursprung der Animation auf den aktuellen Zeitpunkt zurück. Sie ist daher nicht auf die Ladephase beschränkt: Ein Aufruf zu einem beliebigen Zeitpunkt spielt die Animation von Anfang an erneut ab.

Die Parameter jeder Stufe werden unmittelbar an den Eigenschaften gesetzt; es gibt keine eigenen Setter. Damit die Parameter für die gesamte Animation gelten, sie vor dem Aufruf dieser Funktion setzen. Eine Änderung eines Parameters während der Wiedergabe wirkt ebenfalls, als Anpassung im Lauf.

Component->AnimationSpeed = 30.0f;
Component->SecondStageDelay = 1.0f;
Component->SetEnableAnimation(true);

Zur umgekehrten Animation (Verschwinden), zur Aufrufreihenfolge, zu den Parameterwerten und zu praktischen Hinweisen siehe Ladeanimation.

Siehe auch

• ALCCActorBase: die Schnittstellen auf der Actor-Seite
• ULCCComponent: der LCC1-eigene Strahlentest auf der Punktwolke
• ULCC2Component: die LCC2-eigenen Kugelflächenfunktionen und Normalen-Modi
• Enums: Werte von ERenderMode, ELoadMode, ELightMode und weiteren
• Structs: Felder von FRenderInfo und FMetaInfoBase