Actors SOG / SPZ / PLY: carga de 3DGS de archivo único

Los Actors ASogActor, ASpzActor y APlyActor corresponden respectivamente a los formatos .sog, .spz y .ply, y cargan un único archivo 3DGS sin estructura de directorios LCC. Los tres heredan de ALCCActorBase.

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

Los tres reutilizan internamente el pipeline de renderizado completo de LCC2 construyendo un FLCC2MetaInfo virtual. En otras palabras, las capacidades de LCC2 están igualmente disponibles para estos tres formatos, incluidos el control de las bandas de armónicos esféricos, los modos de normal para la iluminación, el recorte y el seccionado, y el ajuste de color. Por lo mismo, también se heredan las limitaciones del pipeline LCC2, como que las interfaces de varios viewports no tengan efecto.

Formatos compatibles

Para el alcance de compatibilidad de cada formato, consultar Introducción - Formatos compatibles.

Comparación con los formatos de directorio LCC

Cómo elegir: usar estos tres formatos cuando los datos son pequeños, cuando se quiere verificar el resultado rápidamente o cuando se necesita una distribución de archivo único. Las escenas grandes dependen del LOD para controlar el rendimiento y requieren el formato de directorio LCC / LCC2.

Métodos

Las interfaces públicas de los tres Actors se heredan de ALCCActorBase; solo se sobrescriben los métodos siguientes.

SelectFile

// ASogActor
virtual void SelectFile() override;   // el diálogo lista solo .sog

// ASpzActor
virtual void SelectFile() override;   // el diálogo lista solo .spz

// APlyActor
virtual void SelectFile() override;   // el diálogo lista solo .ply

Abre el diálogo de archivos, y cada uno filtra su propia extensión. Se muestra como un botón Load en el panel Details.

Solo en el editor; usar Load en un tiempo de ejecución empaquetado.

Load (sobrescrito solo por APlyActor)

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

Carga un archivo .ply. Una ruta cuya extensión no sea .ply se rechaza directamente y no se intenta analizarla.

ASogActor y ASpzActor no sobrescriben Load y usan la implementación de la clase base.

Ejemplos

Cargar un único archivo .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 es un ULCC2Component, así que todas las capacidades de LCC2 están disponibles
    ULCC2Component* Comp = Cast<ULCC2Component>(SogActor->GetLCCComponent());
    if (Comp)
    {
        Comp->SetSHBands(2);
        Comp->SetSplatScale(0.9f);
    }
}

Elegir el Actor automáticamente por la extensión

Cada formato tiene su propio Actor dedicado, y un proyecto real normalmente necesita despachar según la extensión.

No conviene basarse en DetermineFileFormat para esto: solo reconoce .lcc, .splats, .las y .ply, y devuelve None para .lcc2, .sog y .spz. Comprobar la extensión de forma directa es más fiable:

#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 no tiene ningún nodo que tome la extensión directamente, así que hay que usar una comprobación de cadena:

[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

(la rama False sigue comprobando ".spz", ".ply", ".lcc2", ".lcc" con Ends With)

Notas

• Estos tres formatos no tienen Levels de LOD. La carga construye un árbol de un solo Level y un solo nodo (recuento total de Levels 1, nodo raíz sin hijos), así que los parámetros de LOD como StartLevel, EndLevel y LevelFactor se siguen leyendo pero no tienen Levels entre los que elegir y no producen ningún efecto. El rendimiento se controla principalmente mediante MaxSplatNum y SplatScale.
• Estos tres formatos no incluyen datos de colisión; para las alternativas, consultar Colisión - Alternativas para los formatos de archivo único.
• Un archivo grande se carga por completo de una vez, y el uso de memoria de vídeo se mantiene constante y no cambia con la vista. Para el límite de carga y cómo se calcula, consultar Renderizado - Límites de carga de los formatos de archivo único.
• Pasan por el pipeline de renderizado de LCC2, así que las interfaces de varios viewports de la clase base no se aplican.
• Los tres establecen bUseMipFilter del Component en false al construirse (el valor predeterminado de la clase base es true) y establecen la rotación del Actor en (0, 0, 90).
• .ply tiene varios subformatos, y el plugin admite la variante que incluye propiedades 3DGS. Cargar un .ply de malla geométrica normal falla.

Véase también

• ALCCActorBase: todas las interfaces heredadas
• ULCC2Component: el component que estos tres Actors usan internamente
• ULCCUtilLibrary: detección de formato y validación de rutas