ULCCComponentBase: classe base dei Component 3DGS

Classe base di ogni Component LCC, che porta con sé le funzionalità di rendering, colore, prestazioni, collisioni e GIS. ULCCComponent (LCC1) e ULCC2Component (LCC2) ereditano da essa.

#include "LCCComponentBase.h"

Ottenere l'istanza attraverso l'Actor:

ULCCComponentBase* Component = LCCActor->GetLCCComponent();

Questa pagina è un indice delle interfacce che descrive firma, parametri e note sulle chiamate di ogni metodo. Per capire come regolare un parametro e quali siano le conseguenze visive e prestazionali, vedere il documento tematico corrispondente:

Differenze tra le due pipeline

Alcune proprietà e metodi sono dichiarati nella classe base ma solo una pipeline li implementa realmente. Verificare per quale pipeline passano i dati di destinazione prima di scrivere codice.

Proprietà

Per le proprietà con BlueprintSetter, trascinare il valore nel pannello Details e chiamare il Setter da codice passano per lo stesso percorso. Le proprietà con Interp possono essere animate con keyframe in Sequencer.

Percorso di caricamento

Proprietà di rendering

Proprietà di prestazione

Il campo Performance è di tipo FRenderInfo. Ogni valore è accompagnato da una casella di abilitazione, e mentre la casella è disattivata viene usato il valore predefinito interno. Per l'elenco dei campi vedere Struct, e per i valori consigliati vedere Parametri di prestazione.

Proprietà di regolazione del colore

Le quattro componenti corrispondono, in quest'ordine, a R, G, B e al valore complessivo. Per una descrizione degli effetti della regolazione del colore vedere Impostazioni visive.

Notare che questi intervalli sono soltanto gli intervalli degli slider del pannello (UIMin / UIMax) e non c'è alcun Clamp. I valori fuori intervallo passati a un Setter da codice non vengono troncati, e il risultato è responsabilità del chiamante. SplatScale e GlobalAlpha, al contrario, sono realmente limitati.

Proprietà di colorazione della nuvola di punti

Proprietà di collisione

Per i dettagli vedere Collisioni.

Proprietà della camera

Le tre voci seguenti hanno effetto solo sulla pipeline LCC1, e il pannello Details di un component LCC2 nasconde le ultime due.

Proprietà GIS

Per i passi di configurazione usati insieme a Cesium, vedere Integrazione con plugin di terze parti e del motore.

Proprietà di clipping e sezione

Entrambi gli array sono BlueprintReadOnly. Non modificare direttamente gli elementi; gestirli con AddClippingVolume e i metodi correlati.

Proprietà dell'animazione

L'animazione ha due fasi: la prima fase attende FirstStageDelay e scala da 0 a AnimationMinScale, la seconda fase attende SecondStageDelay e scala da AnimationMinScale a SplatScale.

Per l'effetto di ogni parametro e come regolarlo, vedere Animazione di caricamento.

Caricamento e stato

Load

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

Carica i dati. È ciò che ALCCActorBase::Load chiama in ultima istanza.

Restituisce bool: true quando la validazione del percorso passa e il processo di caricamento parte. Passare un percorso vuoto esegue uno scaricamento e restituisce anch'esso true.

Note d'uso:

• true significa soltanto che il processo è partito, non che i dati siano pronti. La versione corrente richiede di interrogare periodicamente con CheckIfLoaded; una callback di completamento del caricamento verrà fornita in una versione successiva.
• Quando il percorso passato coincide con il percorso attualmente caricato, la chiamata ritorna immediatamente e nulla viene caricato di nuovo.
• Un caricamento riuscito scrive il percorso 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();

Scarica i dati, rilascia le cache dei nodi, i buffer GPU e i corpi di collisione, e azzera DefaultLoadPath.

Due cose da tenere presenti:

• Poiché DefaultLoadPath viene azzerato, chiamare Refresh() subito dopo UnLoad() non carica nulla.
• I metadati non vengono azzerati. Dopo lo scaricamento, GetMetaInfo() e GetSplatNumber() restituiscono ancora i dati del caricamento precedente, quindi non usarli per verificare se i dati siano stati scaricati; usare CheckIfLoaded.

Refresh

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

Ricarica i dati correnti. L'implementazione è UnLoad() più Load(DefaultLoadPath), quindi il costo corrisponde a un ricaricamento completo.

Usarlo per rileggere da disco dopo che i file di dati su disco sono stati sostituiti. Per aggiornare il rendering per un singolo fotogramma, usare ForceUpdate.

ForceUpdate

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

Contrassegna il fotogramma successivo per forzare un aggiornamento della scena una volta, a costo molto basso.

Il plugin salta l'aggiornamento dei nodi mentre né la camera né i parametri di rendering cambiano. Quando qualcosa che influisce sulla visibilità è stato modificato dall'esterno e l'immagine non ha seguito, usarlo per spingere un fotogramma. Non chiamarlo a ogni fotogramma, cosa che annulla l'ottimizzazione di salto.

CheckIfLoaded

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

Se i metadati e la struttura di indice sono stabiliti. È BlueprintPure, quindi in Blueprint è un nodo puro senza pin di esecuzione.

Significato esatto: LCC1 verifica se il gestore dei nodi sia creato, LCC2 verifica se l'albero sia creato. true significa che l'analisi dei metadati è completa e i metadati possono essere letti e i parametri configurati in sicurezza, ma i dati degli splat sono ancora in streaming per vista e l'immagine continua a completarsi.

In altre parole, non significa «l'immagine è completa». Per i casi che richiedono di attendere che l'immagine sia stabile, questa funzione non dà risposta.

if (Component->CheckIfLoaded())
{
    // ora è sicuro leggere i metadati e configurare i parametri
}

Blueprint come testo, con interrogazione ogni 0.2 secondi:

[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]
                              │
                              ▼
                        (configurazione dopo il completamento del caricamento)

GetSplatNumber

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

Restituisce il numero totale di splat dei dati, preso dal campo TotalSplats dei metadati.

Note d'uso:

• È il totale intrinseco dei dati. Non cambia al muoversi della camera e non è la quantità effettivamente renderizzata nel fotogramma corrente.
• Restituisce 0 prima del primo caricamento. Ma poiché UnLoad() non azzera i metadati, dopo lo scaricamento restituisce ancora il valore precedente.
• Per conoscere il carico di rendering del fotogramma corrente, aprire il pannello delle statistiche con Stats() sull'Actor e leggere i dati in tempo reale.

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

HaveValidSplatData

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

Se siano disponibili dati di splat validi per il rendering. Restituisce false quando il caricamento è fallito o i dati sono vuoti.

HaveValidCollisionData

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

Se i dati contengano un file di collisione.

Notare che verifica solo il più recente collision.lci, non il vecchio collision.bin, e nemmeno la collisione da nuvola di punti .ply. Il caricamento della collisione supporta di per sé tutti e tre i formati, quindi un insieme di dati che contiene solo collision.bin può far restituire false a questa funzione mentre SetLCCCollisionEnable(true) carica comunque con successo.

Per verificare accuratamente tutti e tre i formati, usare ULCCUtilLibrary::DetermineCollisionType (passando la directory che contiene i dati).

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

CanRender

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

Se le condizioni per il rendering siano attualmente soddisfatte. I criteri sono lo stato di visibilità del component più il fatto che la struttura dati della sottoclasse sia stabilita (LCC1 verifica il gestore dei nodi, LCC2 verifica l'albero). La validità dei metadati non è coinvolta.

CanSetShcoef

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

Se i dati contengano coefficienti di armoniche sferiche. L'implementazione equivale a verificare che il tipo di file sia EFileType::Quality.

Verificarlo prima di chiamare SetUseShcoef, e usarlo per decidere se l'interruttore delle armoniche sferiche debba essere disattivato in un'interfaccia.

GetMetaInfo

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

Restituisce i metadati dei dati, inclusi nome, versione, sistema di coordinate, numero totale di Level, numero totale di splat e altro. Per i campi vedere Struct.

Leggerlo dopo il completamento del caricamento; i campi sono a valori nulli mentre i dati non sono pronti. Il valore di ritorno è una porzione della classe base, quindi per i campi LCC1/LCC2 completi usare i metodi dedicati delle sottoclassi.

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;

Restituisce il bounding box visibile del modello nello spazio locale del component. Restituisce un box non valido (FBox(ForceInit)) quando i dati non sono disponibili, quindi verificare IsValid prima dell'uso.

Per lo spazio mondo, trasformarlo con GetComponentTransform(). Un uso comune è posizionare automaticamente la camera in modo che l'intera scena entri nell'inquadratura.

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();
    // usare Center e Radius per calcolare la posizione di osservazione
}

GetLccVersion

virtual ELCCVersion GetLccVersion() const;

Restituisce la versione dei dati, ELCCVersion::LCC o ELCCVersion::LCC2. Solo C++.

Rendering

Per l'effetto visivo e i compromessi di ogni parametro, vedere Rendering e Impostazioni visive; questa sezione tratta solo le interfacce.

SetRenderMode / GetRenderMode

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

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

Alterna tra 3DGS (ERenderMode::Splatting) e nuvola di punti (ERenderMode::PointCloud).

In modalità nuvola di punti le voci specifiche del 3DGS non hanno effetto, e l'opacità proviene invece da GlobalAlpha_PointCloud.

Parametro corrispondente nel pannello: Render Mode.

Component->SetRenderMode(ERenderMode::PointCloud);

Blueprint come testo:

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

Alterna avanti e indietro tra 3DGS e nuvola di punti senza verificare lo stato corrente.

SetLoadMode / GetLoadMode

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

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

Controlla se vengano renderizzati i dati principali, i dati dell'ambiente o entrambi. Per i valori vedere ELoadMode, e per la descrizione del pannello vedere Load Mode.

ELoadMode::None equivale a un nascondimento temporaneo mentre i dati già caricati restano in memoria, quindi il ripristino è più rapido che con UnLoad.

Component->SetLoadMode(ELoadMode::OnlyMain);

SetLightMode / GetLightMode

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

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

Controlla se i dati partecipino all'illuminazione della scena, ELightMode::Unlit o ELightMode::Lit.

Le due pipeline lo implementano in modo diverso:

• LCC1 lo fa alternando i materiali Lit e Unlit.
• LCC2 non alterna i materiali; l'illuminazione è gestita dentro lo shader. LCC2 richiede quindi anche NormalMode configurato per ottenere una resa ragionevole, vedere ULCC2Component e Normali e illuminazione.

I dati acquisiti hanno già l'illuminazione del luogo incorporata, quindi passare a Lit sovraespone facilmente. LCC2 può ridurre la luminosità originale con LightingScale.

Questo Setter non ha effetto in modalità nuvola di punti: l'assegnazione viene saltata internamente e viene stampato un avviso. Per cambiare la modalità di illuminazione, tornare prima al 3DGS.

Parametro corrispondente nel pannello: Light Mode.

ToggleLightMode

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

Alterna tra Unlit e Lit.

SetUseShcoef / GetUseShcoef

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

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

Attiva e disattiva le armoniche sferiche. Le armoniche sferiche forniscono variazioni di colore in base alla vista; con esse disattivate il colore è fisso.

Note d'uso:

• Richiede che i dati contengano armoniche sferiche, verificato con CanSetShcoef. I dati Portable non hanno armoniche sferiche disponibili e questa voce non è modificabile nel pannello.
• Questo Setter viene ignorato senza avvisi in modalità nuvola di punti. Internamente richiede che i dati siano di tipo Quality e che la modalità corrente non sia la nuvola di punti; l'assegnazione viene saltata quando una delle due condizioni non è soddisfatta.
• LCC2 può ridurre il numero di bande invece di disattivarle completamente, vedere SetSHBands.
• Per la descrizione del pannello vedere Armoniche sferiche (SH).

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

ToggleShcoef

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

Attiva e disattiva le armoniche sferiche, utile per confrontarne l'effetto.

SetSplatScale / GetSplatScale

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

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

Dimensione del quad dello splat, da 0.001 a 1.0, predefinito 1.0.

Note d'uso:

• Il valore predefinito di 1.0 è il limite superiore, quindi può solo essere ridotto.
• Ridurlo riduce l'overdraw e aumenta la frequenza dei fotogrammi, al prezzo di possibili buchi nell'immagine quando i quad diventano più piccoli.
• Ha effetto solo in modalità 3DGS.
• Per la descrizione del pannello vedere SplatScale.

// scambiare overdraw per frequenza dei fotogrammi, valutando i buchi caso per caso
Component->SetSplatScale(0.8f);

SetGlobalAlpha / GetGlobalAlpha

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

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

Opacità complessiva del 3DGS, da 0 a 1. È marcata Interp, quindi può essere animata con keyframe in Sequencer per le dissolvenze.

Per la modalità nuvola di punti usare SetGlobalAlpha_PointCloud; i due valori sono indipendenti. Per la descrizione del pannello vedere Global Alpha.

// dissolvenza in uscita fotogramma per fotogramma
const float Next = FMath::FInterpTo(
    Component->GetGlobalAlpha(), 0.0f, DeltaTime, 2.0f);
Component->SetGlobalAlpha(Next);

Blueprint come testo, dissolvenza in uscita con una Timeline:

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

SetGlobalAlpha_PointCloud / GetGlobalAlpha_PointCloud

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

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

Opacità complessiva in modalità nuvola di punti, da 0 a 1, predefinito 0.2.

SetUseMipFilter / GetUseMipFilter

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

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

Attiva e disattiva il filtro anti-sfarfallio, abilitato per impostazione predefinita. Quando è abilitato usa un filtro passa-basso con compensazione dell'opacità ed è più stabile a scale diverse; quando è disabilitato l'immagine è più nitida ma può presentare aliasing e sfarfallio. Ha effetto solo in modalità 3DGS.

Per la descrizione del pannello vedere Mip Filter.

EnableReceiveShadows / DisableReceiveShadows

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

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

Attiva e disattiva la ricezione delle ombre, una funzionalità sperimentale.

Note d'uso:

• Supportata solo sulla pipeline LCC1; il pannello Details di un component LCC2 nasconde la proprietà.
• Ha effetto solo in modalità 3DGS, con un impatto significativo sulle prestazioni.
• È implementata internamente passando a un materiale dedicato, quindi la configurazione dei materiali viene eseguita di nuovo.
• Per la descrizione del pannello vedere Ricezione delle ombre.

Prestazioni

Questo gruppo di Setter condivide un comportamento: chiamarne uno imposta automaticamente a true la casella di abilitazione corrispondente. I Getter restituiscono il valore effettivo, e mentre la casella è disattivata restituiscono il valore predefinito interno invece del valore inserito in precedenza.

GetPreloadDistance è l'unica eccezione: restituisce il valore grezzo del campo, non il valore effettivo.

Per i valori consigliati vedere Parametri di prestazione e Guida alle prestazioni.

SetMaxDistance / GetMaxDistance

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

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

Distanza massima di rendering in metri, valore predefinito interno 300. I nodi oltre quella distanza non vengono renderizzati.

Parametro corrispondente nel pannello: Max Distance.

Component->SetMaxDistance(80);

SetMaxSplatNum / GetMaxSplatNum

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

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

Numero massimo di splat per fotogramma, in unità di decine di migliaia, limite superiore 10000. Passare 1500 significa 15 milioni.

I valori oltre quanto la GPU può gestire in un singolo fotogramma vengono limitati automaticamente. Parametro corrispondente nel pannello: Max Splat Num.

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

SetLevelFactor / GetLevelFactor

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

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

Fattore di scala del LOD, da 0.01 a 20, predefinito 1. Un valore maggiore significa meno dettaglio e prestazioni migliori.

Il meccanismo differisce per pipeline:

• LCC1: scala RangeForLevel delle impostazioni del progetto, cambiando la mappatura tra distanza e Level.
• LCC2: agisce come fattore di scala dell'errore in spazio schermo durante la selezione dei nodi.

L'effetto visivo dello stesso valore non può quindi essere confrontato direttamente tra le due pipeline; misurarle separatamente.

Parametro corrispondente nel pannello: 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, da 0 a 20, predefinito 0. Il Level 0 ha il dettaglio più alto; aumentarlo salta i livelli più fini e riduce sensibilmente l'uso di memoria video e la quantità caricata.

Parametro corrispondente nel pannello: Start Level.

SetEndLevel / GetEndLevel

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

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

End Level, da 0 a 20, predefinito 20. Limita il Level più grossolano e normalmente non richiede modifiche.

Parametro corrispondente nel pannello: End Level.

SetMaxCollisionDistance / GetMaxCollisionDistance

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

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

Distanza massima di caricamento della collisione in metri, valore predefinito interno 300.

Per i test dei raggi a lunga distanza, questo valore deve coprire l'estensione del test, altrimenti non viene colpito nulla.

Parametro corrispondente nel pannello: Max Load Collision Distance.

SetPreloadDistance / GetPreloadDistance

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

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

Distanza di precaricamento in metri.

Nota: nella versione corrente la logica effettiva è fissata a MaxDistance + 35, il valore impostato attraverso il Setter non partecipa al calcolo, e la voce non è esposta nel pannello. L'interfaccia è mantenuta per compatibilità e non richiede chiamate nell'uso normale.

Regolazione del colore

Le proprietà di regolazione del colore sono tutte FVector4, con le quattro componenti che corrispondono, in quest'ordine, a R, G, B e al valore complessivo. Ogni Setter di regolazione del colore ha effetto immediato. Per una descrizione degli effetti vedere Impostazioni visive.

UFUNCTION(BlueprintCallable, Category = "XGrids|Color")
void SetSaturation(const FVector4 InSaturation);   // saturazione, 0~2
void SetContrast(const FVector4 InContrast);       // contrasto, 0~2
void SetGamma(const FVector4 InGamma);             // gamma, 0~2
void SetOffset(const FVector4 InOffset);           // offset additivo, -1~1
void SetColorTint(const FLinearColor InColor);     // tinta moltiplicativa

// Getter corrispondenti
FVector4 GetSaturation() const;
FVector4 GetContrast() const;
FVector4 GetGamma() const;
FVector4 GetOffset() const;
FLinearColor GetColorTint() const;

Offset è additivo e solleva le aree scure insieme a tutto il resto; ColorTint è moltiplicativo e mantiene scure le aree scure. Per l'effetto di ogni voce vedere Regolazione del colore.

// ridurre la saturazione e schiarire leggermente
Component->SetSaturation(FVector4(0.6f, 0.6f, 0.6f, 0.6f));
Component->SetOffset(FVector4(0.05f, 0.05f, 0.05f, 0.f));

Colorazione per quota della nuvola di punti

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;

Colore inferiore e superiore del gradiente per quota, dal blu al rosso per impostazione predefinita.

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

Collisione

SetLCCCollisionEnable

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

Attiva e disattiva il caricamento dei dati di collisione.

Note d'uso:

• Richiede che i dati contengano un file di collisione, confermato prima con HaveValidCollisionData.
• La collisione viene caricata in streaming per distanza, limitata da Performance.CollisionLoadMaxDistance.
• Una volta abilitata, le funzionalità del motore come LineTraceByChannel, il movimento dei personaggi e la simulazione fisica funzionano direttamente.
• La prima attivazione comporta un costo di baking una sola volta che può causare un breve scatto. Abilitarla durante la fase di caricamento quando possibile.
• ShowCollision() sull'Actor mostra il wireframe della collisione per confermare se sia stata caricata.

Per la descrizione completa vedere Collisioni.

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

GIS

Il posizionamento geografico viene usato di solito insieme a Cesium per collocare una scena LCC alle coordinate terrestri reali. Per i passi di configurazione, le dipendenze dai plugin e le avvertenze, vedere Integrazione con plugin di terze parti e del motore.

SetGeoPlacement

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

Attiva e disattiva il posizionamento della scena per latitudine e longitudine.

Una volta abilitato, la scena viene posizionata automaticamente in base alle coordinate geografiche reali, la posizione dell'Actor impostata manualmente viene sovrascritta, e la regolazione fine passa per GeoLocationOffset. Più scene LCC con questa opzione abilitata si allineano automaticamente alle loro posizioni relative reali.

Note d'uso:

• Internamente viene eseguito un Refresh() (scaricamento più ricaricamento), quindi una chiamata ha effetto in qualsiasi momento e non serve alcun Load() manuale. Il costo corrisponde a un ricaricamento completo, quindi non attivarlo e disattivarlo frequentemente.
• Richiede che i dati contengano informazioni RTK. Verificarlo con GetMetaInfo().IsRTK(), non con CanUseGeoPlace(): quest'ultimo richiede che il posizionamento geografico sia già abilitato ed è sempre false prima di quel momento.

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

CanUseGeoPlace

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

Se il posizionamento geografico sia attualmente in uno stato utilizzabile. Tre condizioni devono valere contemporaneamente: bEnableGeoPlace è abilitato, i dati contengono informazioni RTK, e il sistema di georeferenziazione è creato.

Non è un criterio per stabilire «se i dati supportino il posizionamento geografico». Poiché richiede che bEnableGeoPlace sia già true, una chiamata prima dell'abilitazione restituisce sempre false. Per verificare se i dati lo supportino prima dell'abilitazione, usare GetMetaInfo().IsRTK().

Il suo scopo effettivo è confermare, dopo l'abilitazione, che abbia realmente avuto effetto.

GetRTKBaseLocation

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

Restituisce la posizione della stazione base RTK convertita nello spazio del motore, che è l'origine geografica dei dati. È il punto di riferimento quando coordinate geografiche esterne devono essere convertite in coordinate del motore.

Nota: internamente usa direttamente il sistema di georeferenziazione per la conversione delle coordinate senza alcun controllo di nullità. Chiamarlo mentre il sistema di georeferenziazione non è creato provoca un crash. Confermare che CanUseGeoPlace sia true, oppure che GetGeoReferencingSystem restituisca un valore non nullo, prima della chiamata.

GetGeoReferencingSystem

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

Restituisce l'Actor del sistema di georeferenziazione presente nella scena, creato automaticamente dal plugin quando il posizionamento geografico è abilitato.

ALCCGeoReferencingSystem* GeoSystem = Component->GetGeoReferencingSystem();
if (GeoSystem)
{
    // da coordinate proiettate a coordinate del motore
    FVector EngineLocation;
    GeoSystem->ProjectedToEngine(ProjectedCoord, EngineLocation);

    // direzioni est / nord / alto in quel punto
    FVector East, North, Up;
    GeoSystem->GetENUVectorsAtEngineLocation(EngineLocation, East, North, Up);
}

Più viewport

Lo stesso insieme di dati può usare strategie di rendering diverse per camere diverse. Un uso tipico è il 3DGS di alta qualità nel viewport principale e una vista dall'alto a nuvola di punti renderizzata attraverso SceneCapture per una minimappa.

Nota: questo gruppo di interfacce si applica solo alla pipeline LCC1. Chiamarle sulla pipeline LCC2 (ALCC2Actor e .sog / .spz / .ply) non genera errori ma non produce il risultato previsto. Usare dati LCC1 quando serve il rendering differenziato per più viewport o il precaricamento prima di un teletrasporto.

Accettano puntatori a oggetti, non ID interi.

Per l'approccio complessivo a più camere e più uscite su schermo (nDisplay, Aximmetry, Pixotope e altri), vedere Integrazione con plugin di terze parti e del motore.

SetPlayerLoadMode

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

Imposta un LoadMode separato per il player controller indicato, effettivo dal fotogramma successivo.

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

SetPlayerRenderMode

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

Imposta un RenderMode separato per il player controller indicato, effettivo dal fotogramma successivo.

SetSceneCaptureLoadMode

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

Imposta un LoadMode separato per il SceneCapture indicato.

Va prima abilitato SceneCaptureComponent Support nelle impostazioni del progetto, altrimenti il contenuto LCC non viene renderizzato in SceneCapture.

SetSceneCaptureRenderMode

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

Imposta un RenderMode separato per il SceneCapture indicato.

// la minimappa usa la nuvola di punti e solo la parte principale, l'opzione più economica
Component->SetSceneCaptureRenderMode(MinimapCapture, ERenderMode::PointCloud);
Component->SetSceneCaptureLoadMode(MinimapCapture, ELoadMode::OnlyMain);

ModifyPlayerTransform

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

Sovrascrive la posizione del giocatore indicato in questa scena, usato per precaricare i dati di una destinazione prima di un teletrasporto.

Il problema che risolve: teletrasportarsi direttamente in un luogo distante lascia i nodi della destinazione non caricati, quindi il giocatore vede una parte principale vuota che si riempie gradualmente.

Sequenza corretta:

ModifyPlayerTransform(destinazione)
        ↓ attendere circa 0.2 secondi affinché i nodi della destinazione inizino a caricarsi
teletrasportare realmente il giocatore
        ↓ attendere altri 0.2 secondi circa
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 come testo:

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

Annulla la sovrascrittura della posizione e torna a usare la posizione reale del giocatore.

Va necessariamente chiamato, altrimenti la pianificazione dei nodi per quel giocatore resta bloccata alla posizione sovrascritta e nessun nuovo nodo viene caricato al muoversi del giocatore.

Clipping e sezione

Per l'uso del clipping e del sezionamento, vedere Modifica della scena, insieme a ALCCClippingVolume e ALCCSectionPlane.

AddClippingVolume

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

Aggiunge un volume di clipping.

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

Rimuove un volume di clipping. Per una disattivazione temporanea, modificare bEnabled sul volume di clipping è più leggero.

AddSectionPlane

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

Aggiunge un piano di sezione.

RemoveSectionPlane

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

Rimuove un piano di sezione.

Animazione di caricamento

SetEnableAnimation / GetEnableAnimation

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

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

Attiva e disattiva l'animazione e reimposta l'origine temporale dell'animazione all'istante corrente. Non è quindi limitato alla fase di caricamento: una chiamata in qualsiasi momento riproduce l'animazione dall'inizio.

I parametri di ogni fase si impostano direttamente sulle proprietà; non ci sono Setter separati. Per fare in modo che i parametri si applichino all'intera animazione, impostarli prima di chiamare questa funzione. Modificare un parametro durante la riproduzione ha comunque effetto, come regolazione a metà riproduzione.

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

Per l'animazione inversa (di scomparsa), l'ordine delle chiamate, i valori dei parametri e le note pratiche, vedere Animazione di caricamento.

Vedere anche

• ALCCActorBase: le interfacce lato Actor
• ULCCComponent: il test dei raggi sulla nuvola di punti, solo LCC1
• ULCC2Component: le armoniche sferiche e le modalità delle normali, solo LCC2
• Enum: valori di ERenderMode, ELoadMode, ELightMode e altri
• Struct: campi di FRenderInfo e FMetaInfoBase