SOG- / SPZ- / PLY-Actors: Laden einzelner 3DGS-Dateien

Die Actors ASogActor, ASpzActor und APlyActor entsprechen jeweils den Formaten .sog, .spz und .ply und laden eine einzelne 3DGS-Datei ohne LCC-Verzeichnisstruktur. Alle drei erben von ALCCActorBase.

#include "SogActor.h"
#include "SpzActor.h"
#include "PlyActor.h"

Alle drei nutzen intern die vollständige LCC2-Rendering-Pipeline erneut, indem sie ein virtuelles FLCC2MetaInfo aufbauen. Anders gesagt: Die LCC2-Fähigkeiten stehen diesen drei Formaten genauso zur Verfügung, darunter die Steuerung der Bänder der Kugelflächenfunktionen, die Modi der Beleuchtungsnormalen, Clipping und Schnittebenen sowie die Farbanpassung. Aus dem gleichen Grund werden auch die Einschränkungen der LCC2-Pipeline geerbt, etwa dass die Schnittstellen für mehrere Viewports keine Wirkung haben.

Unterstützte Formate

Zum Umfang der Unterstützung jedes Formats siehe Einführung - Unterstützte Formate.

Vergleich mit den LCC-Verzeichnisformaten

Zur Wahl: diese drei Formate nutzen, wenn die Daten klein sind, wenn das Ergebnis schnell geprüft werden soll oder wenn die Weitergabe als einzelne Datei gebraucht wird. Große Szenen stützen sich auf LOD, um die Leistung zu steuern, und erfordern das LCC- / LCC2-Verzeichnisformat.

Methoden

Die öffentlichen Schnittstellen aller drei Actors werden von ALCCActorBase geerbt; nur die untenstehenden Methoden werden überschrieben.

SelectFile

// ASogActor
virtual void SelectFile() override;   // der Dialog listet nur .sog

// ASpzActor
virtual void SelectFile() override;   // der Dialog listet nur .spz

// APlyActor
virtual void SelectFile() override;   // der Dialog listet nur .ply

Öffnet den Dateidialog, jeder filtert seine eigene Erweiterung. Wird im Details-Panel als Schaltfläche Load angezeigt.

Nur im Editor; in einer paketierten Laufzeit Load nutzen.

Load (nur von APlyActor überschrieben)

// APlyActor
virtual void Load(const FString& String) const override;

Lädt eine .ply-Datei. Ein Pfad, dessen Erweiterung nicht .ply ist, wird unmittelbar abgewiesen und es wird kein Parsen versucht.

ASogActor und ASpzActor überschreiben Load nicht und nutzen die Implementierung der Basisklasse.

Beispiele

Eine einzelne .sog-Datei laden

#include "SogActor.h"
#include "LCC2Component.h"

void AMyLoader::LoadSogFile()
{
    ASogActor* SogActor = GetWorld()->SpawnActor<ASogActor>(
        ASogActor::StaticClass(), FVector::ZeroVector, FRotator::ZeroRotator);
    if (!SogActor)
    {
        return;
    }

    SogActor->Load(TEXT("D:/Data/scene.sog"));

    // intern eine ULCC2Component, alle LCC2-Fähigkeiten stehen daher zur Verfügung
    ULCC2Component* Comp = Cast<ULCC2Component>(SogActor->GetLCCComponent());
    if (Comp)
    {
        Comp->SetSHBands(2);
        Comp->SetSplatScale(0.9f);
    }
}

Den Actor automatisch anhand der Erweiterung wählen

Jedes Format hat seinen eigenen Actor, und ein echtes Projekt muss meist anhand der Erweiterung verteilen.

Sich dafür nicht auf DetermineFileFormat stützen: Es erkennt nur .lcc, .splats, .las und .ply und gibt für .lcc2, .sog und .spz None zurück. Die Erweiterung direkt zu prüfen ist verlässlicher:

#include "Tools/LCCUtilLibrary.h"
#include "LCCActor.h"
#include "LCC2Actor.h"
#include "SogActor.h"
#include "SpzActor.h"
#include "PlyActor.h"

ALCCActorBase* AMyLoader::LoadAnyFormat(const FString& Path)
{
    if (!ULCCUtilLibrary::CheckPathValid(Path))
    {
        UE_LOG(LogTemp, Error, TEXT("Path does not exist: %s"), *Path);
        return nullptr;
    }

    const FString Ext = FPaths::GetExtension(Path).ToLower();

    UClass* ActorClass = nullptr;
    if (Ext == TEXT("lcc"))       ActorClass = ALCCActor::StaticClass();
    else if (Ext == TEXT("lcc2")) ActorClass = ALCC2Actor::StaticClass();
    else if (Ext == TEXT("sog"))  ActorClass = ASogActor::StaticClass();
    else if (Ext == TEXT("spz"))  ActorClass = ASpzActor::StaticClass();
    else if (Ext == TEXT("ply"))  ActorClass = APlyActor::StaticClass();

    if (!ActorClass)
    {
        UE_LOG(LogTemp, Error, TEXT("Unsupported format: %s"), *Path);
        return nullptr;
    }

    ALCCActorBase* Actor = GetWorld()->SpawnActor<ALCCActorBase>(
        ActorClass, FVector::ZeroVector, FRotator::ZeroRotator);
    if (Actor)
    {
        Actor->Load(Path);
    }
    return Actor;
}

Blueprint hat keinen Node, der die Erweiterung direkt annimmt, daher eine Zeichenkettenprüfung nutzen:

[Custom Event: LoadAnyFormat]
        Path (String)
        │
        ▼
[Check Path Valid]
        Path = Path
        │ Return Value ──┐
        ▼                │
[Branch] ◀───────────────┘
        │ True
        ▼
[Ends With]
        Source String = Path
        In Suffix = ".sog"
        Search Case = Ignore Case
        │ Return Value ──┐
        ▼                │
[Branch] ◀───────────────┘
        │ True
        ▼
[Spawn Actor from Class]
        Class = SogActor
        │ Return Value ──┐
        ▼                │
[Load] ◀─────────────────┘
        Target = (Return Value)
        String = Path

(der Zweig False prüft mit Ends With weiter ".spz", ".ply", ".lcc2", ".lcc")

Hinweise

• Diese drei Formate haben keine LOD-Levels. Das Laden baut einen Baum mit einem Level und einem Node auf (Gesamtanzahl der Levels 1, Wurzelknoten ohne Kinder), LOD-Parameter wie StartLevel, EndLevel und LevelFactor werden daher weiter gelesen, haben aber keine Levels zur Auswahl und keine Wirkung. Die Leistung wird vor allem über MaxSplatNum und SplatScale gesteuert.
• Diese drei Formate bringen keine Kollisionsdaten mit; zu Alternativen siehe Kollision - Alternativen für Einzeldateiformate.
• Eine große Datei wird in einem Durchgang vollständig geladen, und der Grafikspeicherbedarf bleibt konstant und ändert sich nicht mit der Ansicht. Zur Ladegrenze und ihrer Berechnung siehe Rendering - Ladegrenzen von Einzeldateiformaten.
• Sie laufen durch die LCC2-Rendering-Pipeline, die Schnittstellen für mehrere Viewports an der Basisklasse gelten daher nicht.
• Alle drei setzen bUseMipFilter an der Component beim Konstruieren auf false (der Standardwert der Basisklasse ist true) und setzen die Rotation des Actors auf (0, 0, 90).
• .ply hat mehrere Unterformate, und das Plugin unterstützt die Variante, die 3DGS-Eigenschaften mitbringt. Das Laden eines regulären Geometrie-Mesh im Format .ply schlägt fehl.

Siehe auch

• ALCCActorBase: alle geerbten Schnittstellen
• ULCC2Component: die Component, die diese drei Actors intern nutzen
• ULCCUtilLibrary: Formaterkennung und Pfadprüfung