ULCCComponentBase: clase base de los Components 3DGS

Clase base de todos los Components LCC, que aporta las capacidades de renderizado, color, rendimiento, colisión y GIS. ULCCComponent (LCC1) y ULCC2Component (LCC2) heredan de ella.

#include "LCCComponentBase.h"

Obtener la instancia mediante el Actor:

ULCCComponentBase* Component = LCCActor->GetLCCComponent();

Esta página es un listado de interfaces que describe la firma, los parámetros y las notas de llamada de cada método. Para saber cómo ajustar un parámetro y cuáles son sus consecuencias visuales y de rendimiento, consultar el documento del tema correspondiente:

Diferencias entre los dos pipelines

Algunas propiedades y métodos se declaran en la clase base, pero solo uno de los pipelines los implementa realmente. Confirmar por qué pipeline pasan los datos de destino antes de escribir código.

Propiedades

En las propiedades con BlueprintSetter, arrastrar el valor en el panel Details y llamar al Setter desde código siguen el mismo camino. Las propiedades con Interp se pueden animar con keyframes en Sequencer.

Ruta de carga

Propiedades de renderizado

Propiedades de rendimiento

El campo Performance es de tipo FRenderInfo. Cada valor viene con una casilla de activación, y se usa el valor predeterminado interno mientras la casilla está desmarcada. Para el listado de campos, consultar Structs, y para los valores recomendados, consultar Parámetros de rendimiento.

Propiedades de ajuste de color

Los cuatro componentes corresponden a R, G, B y al conjunto, en ese orden. Para una descripción de los efectos del ajuste de color, consultar Ajustes visuales.

Hay que tener en cuenta que esos rangos son solo los rangos del deslizador del panel (UIMin / UIMax) y no existe ningún Clamp. Los valores fuera del rango que se pasan a un Setter desde código no se truncan, y el resultado es responsabilidad de quien llama. SplatScale y GlobalAlpha, en cambio, sí están realmente limitados.

Propiedades de coloreado de la nube de puntos

Propiedades de colisión

Consultar Colisión para más detalles.

Propiedades de cámara

Los tres elementos siguientes solo surten efecto en el pipeline LCC1, y el panel Details de un componente LCC2 oculta los dos últimos.

Propiedades GIS

Para los pasos de configuración usados junto con Cesium, consultar Integración con plugins de terceros y del motor.

Propiedades de recorte y sección

Ambos arrays son BlueprintReadOnly. No modificar los elementos directamente; mantenerlos con AddClippingVolume y los métodos relacionados.

Propiedades de animación

La animación tiene dos etapas: la primera espera FirstStageDelay y escala de 0 a AnimationMinScale, y la segunda espera SecondStageDelay y escala de AnimationMinScale a SplatScale.

Para el efecto de cada parámetro y cómo ajustarlo, consultar Animación de carga.

Carga y estado

Load

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

Carga los datos. Es lo que acaba llamando ALCCActorBase::Load.

Devuelve bool: true cuando la validación de la ruta pasa y el proceso de carga comienza. Pasar una ruta vacía realiza una descarga y también devuelve true.

Notas de uso:

• true solo significa que el proceso comenzó, no que los datos estén listos. La versión actual requiere consultarlo periódicamente con CheckIfLoaded; una versión posterior proporcionará una llamada de retorno de finalización de la carga.
• Cuando la ruta que se pasa coincide con la ruta cargada actualmente, la llamada retorna de inmediato y no se carga nada de nuevo.
• Una carga correcta escribe la ruta en 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();

Descarga los datos, libera las cachés de nodos, los buffers de GPU y los cuerpos de colisión, y borra DefaultLoadPath.

Dos cosas que hay que tener presentes:

• Como DefaultLoadPath se borra, llamar a Refresh() justo después de UnLoad() no carga nada.
• Los metadatos no se borran. Después de descargar, GetMetaInfo() y GetSplatNumber() siguen devolviendo los datos de la carga anterior, así que no se deben usar para comprobar si los datos están descargados; usar CheckIfLoaded.

Refresh

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

Recarga los datos actuales. La implementación es UnLoad() más Load(DefaultLoadPath), así que el coste equivale a una recarga completa.

Usarlo para volver a leer del disco después de haber sustituido los archivos de datos en el disco. Para actualizar el renderizado durante un solo fotograma, usar ForceUpdate.

ForceUpdate

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

Marca el fotograma siguiente para forzar una actualización de la escena una vez, con un coste muy bajo.

El plugin omite las actualizaciones de nodos mientras no cambian ni la cámara ni los parámetros de renderizado. Cuando algo que afecta a la visibilidad se cambió desde fuera y la imagen no lo siguió, usar esto para forzar un fotograma. No llamarlo en cada fotograma, ya que anula la optimización de omisión.

CheckIfLoaded

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

Si los metadatos y la estructura de índice están establecidos. Es BlueprintPure, así que en Blueprint es un nodo puro sin pines de ejecución.

Significado exacto: LCC1 comprueba si el gestor de nodos se ha creado, LCC2 comprueba si el árbol se ha creado. true significa que el análisis de los metadatos está completo y que se pueden leer los metadatos y configurar los parámetros con seguridad, pero los datos de splats siguen transmitiéndose según la vista y la imagen se sigue completando.

En otras palabras, no significa «la imagen está completa». Para los casos que necesitan esperar hasta que la imagen esté estable, esta función no da ninguna respuesta.

if (Component->CheckIfLoaded())
{
    // es seguro leer los metadatos y configurar los parámetros
}

Blueprint como texto, consultando cada 0,2 segundos:

[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]
                              │
                              ▼
                        (configuración una vez terminada la carga)

GetSplatNumber

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

Devuelve el número total de splats de los datos, tomado del campo TotalSplats de los metadatos.

Notas de uso:

• Es el total inherente a los datos. No cambia a medida que la cámara se mueve y no es la cantidad realmente renderizada en el fotograma actual.
• Devuelve 0 antes de la primera carga. Pero, como UnLoad() no borra los metadatos, sigue devolviendo el valor anterior después de descargar.
• Para conocer la carga de renderizado del fotograma actual, abrir el panel de estadísticas con Stats() en el Actor y leer los datos en vivo.

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

HaveValidSplatData

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

Si hay datos de splats válidos disponibles para renderizar. Devuelve false cuando la carga ha fallado o los datos están vacíos.

HaveValidCollisionData

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

Si los datos incluyen un archivo de colisión.

Hay que tener en cuenta que solo comprueba el collision.lci más reciente, no el collision.bin heredado, ni la colisión de nube de puntos .ply. La propia carga de colisión admite los tres formatos, así que un conjunto de datos que solo incluya collision.bin puede hacer que esta función devuelva false mientras SetLCCCollisionEnable(true) carga correctamente.

Para comprobar los tres formatos con precisión, usar ULCCUtilLibrary::DetermineCollisionType (pasando el directorio que contiene los datos).

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

CanRender

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

Si se cumplen actualmente las condiciones para renderizar. Los criterios son el estado de visibilidad del componente más si la estructura de datos de la subclase está establecida (LCC1 comprueba el gestor de nodos, LCC2 comprueba el árbol). La validez de los metadatos no interviene.

CanSetShcoef

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

Si los datos incluyen coeficientes de armónicos esféricos. La implementación equivale a comprobar que el tipo de archivo es EFileType::Quality.

Comprobarlo antes de llamar a SetUseShcoef, y usarlo para decidir si el interruptor de armónicos esféricos aparece desactivado en una interfaz.

GetMetaInfo

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

Devuelve los metadatos de los datos, incluidos el nombre, la versión, el sistema de coordenadas, el número total de Levels, el número total de splats y más. Para los campos, consultar Structs.

Leerlos una vez terminada la carga; los campos tienen valores cero mientras los datos no están listos. El valor de retorno es un corte de la clase base, así que conviene usar los métodos dedicados de las subclases para los campos completos de LCC1/LCC2.

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;

Devuelve la caja delimitadora visible del modelo en el espacio local del componente. Devuelve una caja no válida (FBox(ForceInit)) cuando los datos no están disponibles, así que conviene comprobar IsValid antes de usarla.

Para el espacio de mundo, transformarla con GetComponentTransform(). Un uso habitual es colocar la cámara automáticamente para que toda la escena quepa en la vista.

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();
    // usar Center y Radius para calcular la posición de visualización
}

GetLccVersion

virtual ELCCVersion GetLccVersion() const;

Devuelve la versión de los datos, ELCCVersion::LCC o ELCCVersion::LCC2. Solo C++.

Renderizado

Para el efecto visual y los compromisos de cada parámetro, consultar Renderizado y Ajustes visuales; esta sección solo cubre las interfaces.

SetRenderMode / GetRenderMode

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

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

Cambia entre 3DGS (ERenderMode::Splatting) y nube de puntos (ERenderMode::PointCloud).

En el modo de nube de puntos los elementos específicos del 3DGS no surten efecto, y la opacidad proviene de GlobalAlpha_PointCloud en su lugar.

Parámetro del panel correspondiente: Render Mode.

Component->SetRenderMode(ERenderMode::PointCloud);

Blueprint como texto:

[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();

Cambia de un lado a otro entre 3DGS y nube de puntos sin comprobar el estado actual.

SetLoadMode / GetLoadMode

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

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

Controla si se renderizan los datos principales, los datos de entorno o ambos. Para los valores, consultar ELoadMode, y para la descripción del panel, consultar Load Mode.

ELoadMode::None equivale a una ocultación temporal mientras los datos ya cargados permanecen en memoria, así que la recuperación es más rápida que con UnLoad.

Component->SetLoadMode(ELoadMode::OnlyMain);

SetLightMode / GetLightMode

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

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

Controla si los datos participan en la iluminación de la escena, ELightMode::Unlit o ELightMode::Lit.

Los dos pipelines lo implementan de forma distinta:

• LCC1 lo hace cambiando entre los materiales Lit y Unlit.
• LCC2 no cambia de material; la iluminación se trata dentro del shader. Por tanto, LCC2 necesita además configurar NormalMode para obtener un sombreado razonable, consultar ULCC2Component y Normales e iluminación.

Los datos capturados ya incorporan la iluminación del lugar, así que cambiar a Lit sobreexpone con facilidad. LCC2 puede reducir el brillo original con LightingScale.

Este Setter no surte efecto en el modo de nube de puntos: internamente se omite la asignación y se registra una advertencia. Para cambiar el modo de iluminación, volver primero al 3DGS.

Parámetro del panel correspondiente: Light Mode.

ToggleLightMode

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

Cambia entre Unlit y Lit.

SetUseShcoef / GetUseShcoef

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

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

Alterna los armónicos esféricos. Los armónicos esféricos aportan variación de color dependiente de la vista; con ellos desactivados el color es fijo.

Notas de uso:

• Requiere que los datos incluyan armónicos esféricos, lo que se comprueba con CanSetShcoef. Los datos Portable no tienen armónicos esféricos disponibles y este elemento no es editable en el panel.
• Este Setter se ignora sin avisar en el modo de nube de puntos. Internamente requiere que los datos sean del tipo Quality y que el modo actual no sea nube de puntos; la asignación se omite cuando falla cualquiera de las dos condiciones.
• LCC2 puede reducir el número de bandas en lugar de desactivarlos por completo, consultar SetSHBands.
• Para la descripción del panel, consultar Armónicos esféricos (SH).

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

ToggleShcoef

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

Alterna los armónicos esféricos, útil para comparar el efecto.

SetSplatScale / GetSplatScale

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

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

Tamaño del quad de cada splat, de 0.001 a 1.0, valor predeterminado 1.0.

Notas de uso:

• El valor predeterminado de 1.0 es el límite superior, así que solo se puede reducir.
• Reducirlo baja el sobredibujado y aumenta la tasa de fotogramas, a costa de posibles huecos en la imagen a medida que los quads se hacen más pequeños.
• Solo afecta al modo 3DGS.
• Para la descripción del panel, consultar SplatScale.

// cambiar sobredibujado por tasa de fotogramas, valorando los huecos caso por caso
Component->SetSplatScale(0.8f);

SetGlobalAlpha / GetGlobalAlpha

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

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

Opacidad general del 3DGS, de 0 a 1. Está marcada como Interp, así que se puede animar con keyframes en Sequencer para fundidos.

Para el modo de nube de puntos, usar SetGlobalAlpha_PointCloud; los dos valores son independientes. Para la descripción del panel, consultar Global Alpha.

// fundido de salida fotograma a fotograma
const float Next = FMath::FInterpTo(
    Component->GetGlobalAlpha(), 0.0f, DeltaTime, 2.0f);
Component->SetGlobalAlpha(Next);

Blueprint como texto, fundido de salida con un Timeline:

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

SetGlobalAlpha_PointCloud / GetGlobalAlpha_PointCloud

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

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

Opacidad general en el modo de nube de puntos, de 0 a 1, valor predeterminado 0.2.

SetUseMipFilter / GetUseMipFilter

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

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

Alterna el filtrado antiparpadeo, activado por defecto. Cuando está activado usa un filtro de paso bajo con compensación de opacidad y es más estable a distintas escalas; cuando está desactivado la imagen es más nítida pero puede presentar aliasing y parpadeo. Solo surte efecto en el modo 3DGS.

Para la descripción del panel, consultar Mip Filter.

EnableReceiveShadows / DisableReceiveShadows

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

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

Alterna la recepción de sombras, una función experimental.

Notas de uso:

• Solo compatible con el pipeline LCC1; el panel Details de un componente LCC2 oculta la propiedad.
• Solo surte efecto en el modo 3DGS, con un impacto notable en el rendimiento.
• Se implementa internamente cambiando a un material dedicado, así que la preparación del material se vuelve a ejecutar.
• Para la descripción del panel, consultar Recepción de sombras.

Rendimiento

Este grupo de Setters comparte un comportamiento: llamar a uno establece automáticamente la casilla de activación correspondiente en true. Los Getters devuelven el valor efectivo y, mientras la casilla está desmarcada, devuelven el valor predeterminado interno en lugar del valor introducido antes.

GetPreloadDistance es la única excepción: devuelve el valor bruto del campo, no el valor efectivo.

Para los valores recomendados, consultar Parámetros de rendimiento y Guía de rendimiento.

SetMaxDistance / GetMaxDistance

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

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

Distancia máxima de renderizado en metros, valor predeterminado interno 300. Los nodos más allá de esa distancia no se renderizan.

Parámetro del panel correspondiente: Max Distance.

Component->SetMaxDistance(80);

SetMaxSplatNum / GetMaxSplatNum

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

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

Número máximo de splats por fotograma, en unidades de diez mil, límite superior 10000. Pasar 1500 significa 15 millones.

Los valores que superan lo que la GPU puede manejar en un solo fotograma se recortan automáticamente. Parámetro del panel correspondiente: Max Splat Num.

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

SetLevelFactor / GetLevelFactor

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

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

Factor de escala del LOD, de 0.01 a 20, valor predeterminado 1. Un valor mayor implica menos detalle y mejor rendimiento.

El mecanismo difiere según el pipeline:

• LCC1: escala RangeForLevel de la configuración del proyecto, cambiando la correspondencia entre distancia y Level.
• LCC2: actúa como factor de escala del error en espacio de pantalla durante la selección de nodos.

Por tanto, el efecto visual de un mismo valor no se puede comparar directamente entre los dos pipelines; conviene medir cada uno.

Parámetro del panel correspondiente: 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, de 0 a 20, valor predeterminado 0. El Level 0 tiene la precisión más alta; aumentarlo omite los Levels más finos y reduce notablemente el uso de memoria de vídeo y la cantidad de carga.

Parámetro del panel correspondiente: Start Level.

SetEndLevel / GetEndLevel

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

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

End Level, de 0 a 20, valor predeterminado 20. Limita el Level más grueso y normalmente no requiere ningún cambio.

Parámetro del panel correspondiente: End Level.

SetMaxCollisionDistance / GetMaxCollisionDistance

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

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

Distancia máxima de carga de colisión en metros, valor predeterminado interno 300.

Para las pruebas de rayos de largo alcance, este valor tiene que cubrir el rango de la prueba; de lo contrario no se impacta en nada.

Parámetro del panel correspondiente: Max Load Collision Distance.

SetPreloadDistance / GetPreloadDistance

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

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

Distancia de precarga en metros.

Nota: en la versión actual la lógica efectiva está fijada en MaxDistance + 35, el valor establecido mediante el Setter no participa en el cálculo y el elemento no se expone en el panel. La interfaz se mantiene por compatibilidad y no requiere ninguna llamada en un uso normal.

Ajuste de color

Las propiedades de ajuste de color son todas FVector4, con los cuatro componentes correspondientes a R, G, B y al conjunto, en ese orden. Todos los Setters de ajuste de color surten efecto de inmediato. Para una descripción de los efectos, consultar Ajustes visuales.

UFUNCTION(BlueprintCallable, Category = "XGrids|Color")
void SetSaturation(const FVector4 InSaturation);   // saturación, 0~2
void SetContrast(const FVector4 InContrast);       // contraste, 0~2
void SetGamma(const FVector4 InGamma);             // gamma, 0~2
void SetOffset(const FVector4 InOffset);           // desplazamiento aditivo, -1~1
void SetColorTint(const FLinearColor InColor);     // tinte multiplicativo

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

Offset es aditivo y aclara las zonas oscuras junto con todo lo demás; ColorTint es multiplicativo y mantiene oscuras las zonas oscuras. Para el efecto de cada elemento, consultar Ajuste de color.

// bajar la saturación y aclarar ligeramente
Component->SetSaturation(FVector4(0.6f, 0.6f, 0.6f, 0.6f));
Component->SetOffset(FVector4(0.05f, 0.05f, 0.05f, 0.f));

Coloreado por elevación de la nube de puntos

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;

Colores inferior y superior del degradado de elevación, de azul a rojo por defecto.

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

Colisión

SetLCCCollisionEnable

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

Alterna la carga de los datos de colisión.

Notas de uso:

• Requiere que los datos incluyan un archivo de colisión, lo que conviene confirmar primero con HaveValidCollisionData.
• La colisión se transmite por distancia, limitada por Performance.CollisionLoadMaxDistance.
• Una vez activada, las funciones del motor como LineTraceByChannel, el movimiento de personajes y la simulación física funcionan directamente.
• La primera activación conlleva un coste de horneado puntual que puede provocar un tirón breve. Activarla durante la etapa de carga siempre que sea posible.
• ShowCollision() en el Actor muestra la estructura alámbrica de la colisión para confirmar si se cargó.

Para la descripción completa, consultar Colisión.

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

GIS

La colocación geográfica se usa normalmente junto con Cesium para situar una escena LCC en coordenadas terrestres reales. Para los pasos de configuración, las dependencias de plugins y las advertencias, consultar Integración con plugins de terceros y del motor.

SetGeoPlacement

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

Alterna la colocación de la escena por latitud y longitud.

Una vez activada, la escena se sitúa automáticamente por coordenadas geográficas reales, la ubicación del Actor establecida manualmente queda sustituida, y el ajuste fino se realiza mediante GeoLocationOffset. Varias escenas LCC con esta opción activada se alinean automáticamente en sus posiciones relativas reales.

Notas de uso:

• Internamente se ejecuta un Refresh() (descarga más recarga), así que una llamada surte efecto en cualquier momento y no se necesita ningún Load() manual. El coste equivale a una recarga completa, así que no conviene alternarlo con frecuencia.
• Requiere que los datos incluyan información RTK. Comprobarlo con GetMetaInfo().IsRTK(), no con CanUseGeoPlace(): el segundo requiere que la colocación geográfica ya esté activada y siempre es false antes de eso.

if (Component->CheckIfLoaded() && Component->GetMetaInfo().IsRTK())
{
    Component->SetGeoPlacement(true);   // recarga automáticamente
}

CanUseGeoPlace

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

Si la colocación geográfica está actualmente en un estado utilizable. Deben cumplirse tres condiciones a la vez: bEnableGeoPlace está activado, los datos incluyen información RTK y el sistema de referencia geográfica está creado.

No es un criterio de «si los datos admiten la colocación geográfica». Como requiere que bEnableGeoPlace ya sea true, una llamada antes de activarla siempre devuelve false. Para comprobar si los datos la admiten antes de activarla, usar GetMetaInfo().IsRTK().

Su finalidad real es confirmar, después de activarla, que realmente surtió efecto.

GetRTKBaseLocation

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

Devuelve la posición de la estación base RTK convertida al espacio del motor, que es el origen geográfico de los datos. Es el punto de referencia cuando hay que convertir coordenadas geográficas externas en coordenadas del motor.

Nota: internamente usa el sistema de referencia geográfica directamente para la conversión de coordenadas sin ninguna comprobación de nulidad. Llamarlo mientras el sistema de referencia geográfica no está creado provoca un cierre inesperado. Confirmar que CanUseGeoPlace es true, o que GetGeoReferencingSystem devuelve un valor no nulo, antes de llamarlo.

GetGeoReferencingSystem

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

Devuelve el Actor del sistema de referencia geográfica de la escena, creado automáticamente por el plugin al activar la colocación geográfica.

ALCCGeoReferencingSystem* GeoSystem = Component->GetGeoReferencingSystem();
if (GeoSystem)
{
    // coordenadas proyectadas a coordenadas del motor
    FVector EngineLocation;
    GeoSystem->ProjectedToEngine(ProjectedCoord, EngineLocation);

    // direcciones este/norte/arriba en ese punto
    FVector East, North, Up;
    GeoSystem->GetENUVectorsAtEngineLocation(EngineLocation, East, North, Up);
}

Varios viewports

Un mismo conjunto de datos puede usar estrategias de renderizado distintas para cámaras distintas. Un uso típico es 3DGS de alta calidad en el viewport principal y una vista superior de nube de puntos renderizada mediante SceneCapture para un minimapa.

Nota: este grupo de interfaces se aplica solo al pipeline LCC1. Llamarlas en el pipeline LCC2 (ALCC2Actor y .sog / .spz / .ply) no genera ningún error pero no produce el resultado esperado. Usar datos LCC1 cuando se necesite renderizado diferenciado en varios viewports o precarga antes de un teletransporte.

Toman punteros a objetos, no identificadores enteros.

Para el enfoque general con varias cámaras y varias salidas de pantalla (nDisplay, Aximmetry, Pixotope y otros), consultar Integración con plugins de terceros y del motor.

SetPlayerLoadMode

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

Establece un LoadMode independiente para el controlador de jugador indicado, efectivo en el fotograma siguiente.

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

SetPlayerRenderMode

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

Establece un RenderMode independiente para el controlador de jugador indicado, efectivo en el fotograma siguiente.

SetSceneCaptureLoadMode

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

Establece un LoadMode independiente para el SceneCapture indicado.

Hay que activar primero SceneCaptureComponent Support en la configuración del proyecto; de lo contrario el contenido LCC no se renderiza en SceneCapture.

SetSceneCaptureRenderMode

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

Establece un RenderMode independiente para el SceneCapture indicado.

// el minimapa usa nube de puntos y solo la parte principal, la opción más económica
Component->SetSceneCaptureRenderMode(MinimapCapture, ERenderMode::PointCloud);
Component->SetSceneCaptureLoadMode(MinimapCapture, ELoadMode::OnlyMain);

ModifyPlayerTransform

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

Sustituye la posición del jugador indicado en esta escena, y se usa para precargar los datos de un destino antes de teletransportarse.

El problema que resuelve: teletransportarse directamente a un lugar lejano deja los nodos del destino sin cargar, así que el jugador ve una parte principal en blanco que se va rellenando.

Secuencia correcta:

ModifyPlayerTransform(destino)
        ↓ esperar unos 0,2 segundos para que los nodos del destino empiecen a cargarse
teletransportar realmente al jugador
        ↓ esperar otros 0,2 segundos aproximadamente
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 como texto:

[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);

Cancela la sustitución de la posición y vuelve a usar la posición real del jugador.

Hay que llamarlo; de lo contrario la planificación de nodos de ese jugador se queda fijada en la posición sustituida y no se cargan nodos nuevos a medida que el jugador se mueve.

Recorte y sección

Para saber cómo usar el recorte y el seccionado, consultar Edición de escenas, junto con ALCCClippingVolume y ALCCSectionPlane.

AddClippingVolume

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

Añade un volumen de recorte.

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

Elimina un volumen de recorte. Para una desactivación temporal, cambiar bEnabled en el volumen de recorte es más ligero.

AddSectionPlane

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

Añade un plano de sección.

RemoveSectionPlane

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

Elimina un plano de sección.

Animación de carga

SetEnableAnimation / GetEnableAnimation

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

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

Alterna la animación y restablece el origen temporal de la animación al momento actual. Por tanto, no se limita a la etapa de carga: una llamada en cualquier momento reproduce la animación desde el principio.

Los parámetros de cada etapa se establecen directamente en las propiedades; no hay Setters específicos. Para que los parámetros se apliquen a toda la animación, establecerlos antes de llamar a esta función. Cambiar un parámetro durante la reproducción también surte efecto, como un ajuste en marcha.

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

Para la animación inversa (de desaparición), el orden de las llamadas, los valores de los parámetros y las notas prácticas, consultar Animación de carga.

Véase también

• ALCCActorBase: las interfaces del lado del Actor
• ULCCComponent: la prueba de rayos de nube de puntos exclusiva de LCC1
• ULCC2Component: los armónicos esféricos y los modos de normales exclusivos de LCC2
• Enumeraciones: valores de ERenderMode, ELoadMode, ELightMode y otros
• Structs: campos de FRenderInfo y FMetaInfoBase