Actor SOG / SPZ / PLY: caricamento di 3DGS a file singolo

Gli Actor ASogActor, ASpzActor e APlyActor corrispondono rispettivamente ai formati .sog, .spz e .ply e caricano un singolo file 3DGS senza una struttura di directory LCC. Tutti e tre ereditano da ALCCActorBase.

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

Tutti e tre riutilizzano internamente l'intera pipeline di rendering LCC2 costruendo un FLCC2MetaInfo virtuale. In altre parole, le funzionalità LCC2 sono disponibili allo stesso modo per questi tre formati, incluso il controllo delle bande di armoniche sferiche, le modalità delle normali per l'illuminazione, il taglio e il sezionamento e la regolazione del colore. Per lo stesso motivo si ereditano anche i limiti della pipeline LCC2, per esempio l'assenza di effetto delle interfacce per più viewport.

Formati supportati

Per l'ambito di supporto di ogni formato vedere Introduzione - Formati supportati.

Confronto con i formati a directory LCC

Come scegliere: usare questi tre formati quando i dati sono piccoli, quando serve verificare rapidamente il risultato o quando serve la distribuzione a file singolo. Le scene grandi si affidano al LOD per controllare le prestazioni e richiedono il formato a directory LCC / LCC2.

Metodi

Le interfacce pubbliche di tutti e tre gli Actor sono ereditate da ALCCActorBase; solo i metodi seguenti sono sovrascritti.

SelectFile

// ASogActor
virtual void SelectFile() override;   // la finestra di dialogo elenca solo .sog

// ASpzActor
virtual void SelectFile() override;   // la finestra di dialogo elenca solo .spz

// APlyActor
virtual void SelectFile() override;   // la finestra di dialogo elenca solo .ply

Apre la finestra di dialogo dei file, ciascuno filtrando la propria estensione. Compare come pulsante Load nel pannello Details.

Solo nell'editor; a runtime in una build pacchettizzata usare Load.

Load (sovrascritto solo da APlyActor)

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

Carica un file .ply. Un percorso la cui estensione non è .ply viene rifiutato subito e non viene tentata alcuna analisi.

ASogActor e ASpzActor non sovrascrivono Load e usano l'implementazione della classe base.

Esempi

Caricare un singolo file .sog

#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"));

    // internamente è un ULCC2Component, quindi tutte le funzionalità LCC2 sono disponibili
    ULCC2Component* Comp = Cast<ULCC2Component>(SogActor->GetLCCComponent());
    if (Comp)
    {
        Comp->SetSHBands(2);
        Comp->SetSplatScale(0.9f);
    }
}

Scegliere l'Actor automaticamente in base all'estensione

Ogni formato ha il proprio Actor dedicato e un progetto reale di norma deve smistare in base all'estensione.

Non affidarsi a DetermineFileFormat per questo: riconosce solo .lcc, .splats, .las e .ply, e restituisce None per .lcc2, .sog e .spz. Verificare direttamente l'estensione è più affidabile:

#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 non ha un nodo che accetta direttamente l'estensione, quindi usare una verifica sulla stringa:

[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

(il ramo False continua a verificare ".spz", ".ply", ".lcc2", ".lcc" con Ends With)

Note

• Questi tre formati non hanno Level di LOD. Il caricamento costruisce un albero a un solo livello e un solo nodo (numero totale di Level pari a 1, nodo radice senza figli), quindi i parametri di LOD come StartLevel, EndLevel e LevelFactor vengono comunque letti ma non hanno Level tra cui scegliere e non producono alcun effetto. Le prestazioni si controllano principalmente con MaxSplatNum e SplatScale.
• Questi tre formati non contengono dati di collisione; per le alternative vedere Collisioni - Alternative per i formati a file singolo.
• Un file grande viene caricato interamente in una volta e l'uso della memoria video resta costante e non cambia con la vista. Per il limite di caricamento e come viene calcolato, vedere Rendering - Limiti di caricamento dei formati a file singolo.
• Passano per la pipeline di rendering LCC2, quindi le interfacce per più viewport della classe base non si applicano.
• Tutti e tre impostano bUseMipFilter sul Component a false alla costruzione (il valore predefinito della classe base è true) e impostano la rotazione dell'Actor a (0, 0, 90).
• .ply ha diversi sottoformati e il plugin supporta la variante che contiene le proprietà 3DGS. Il caricamento di un normale .ply con una mesh geometrica fallisce.

Vedere anche

• ALCCActorBase: tutte le interfacce ereditate
• ULCC2Component: il component usato internamente da questi tre Actor
• ULCCUtilLibrary: rilevamento del formato e validazione dei percorsi