ULCCComponent: Component della pipeline LCC

Component specifico della pipeline LCC1, che eredita da ULCCComponentBase. Oltre alle funzionalità della classe base aggiunge i test dei raggi basati sulle posizioni degli splat, più il taglio delle giunzioni.

#include "LCCComponent.h"

Ottenere l'istanza:

ULCCComponent* Comp = Cast<ULCCComponent>(LCCActor->GetLCCComponent());

Proprietà

MetaInfo (di tipo FLCCMetaInfo) è un membro protected, non accessibile dall'esterno sul lato C++ e visibile solo a Blueprint (in sola lettura nel pannello Details). In C++ usare GetMetaInfo() della classe base per leggere i campi di base.

LCCPerformance

Anche qui nella forma di una casella più un valore, con il valore predefinito delle impostazioni del progetto usato mentre la casella non è spuntata.

ULCCComponent* Comp = Cast<ULCCComponent>(LCCActor->GetLCCComponent());
if (Comp)
{
    // ordinare meno spesso per risparmiare prestazioni
    Comp->LCCPerformance.bCanSetSortFactor = true;
    Comp->LCCPerformance.SortFactor = 2.0f;

    // in VR le rotazioni della testa sono rapide, aggiungere nodi di precaricamento
    Comp->LCCPerformance.bEnableExtraPreNodes = true;
    Comp->LCCPerformance.bAddExtraPreNodes = true;
}

Metodi

GetUseSeamCut

bool GetUseSeamCut() const;

Se lo shader ha il taglio delle giunzioni abilitato. Restituisce true quando vale una delle due condizioni: la versione del file LCC è 5.0 o superiore, oppure bEnableSeamCutting è stato abilitato manualmente. Solo C++.

Più viewport

Le interfacce per più viewport sono dichiarate nella classe base ULCCComponentBase ma hanno effetto solo sulla pipeline LCC1. SetPlayerLoadMode, SetPlayerRenderMode, SetSceneCaptureLoadMode, SetSceneCaptureRenderMode, ModifyPlayerTransform e CancelModifyPlayerTransform hanno senso solo se chiamati su un ULCCComponent.

Il motivo è che la strategia di rendering per vista e la pianificazione dei nodi vengono consumate dal percorso di rendering LCC1, e LCC2 non è ancora collegato. Chiamarle su ULCC2Component (incluso ALCC2Actor e .sog / .spz / .ply) non genera errori ma non produce il risultato previsto.

Il rendering differenziato, per esempio alta qualità nel viewport principale e bassa qualità in una minimappa, oppure il precaricamento prima di un teletrasporto, richiede attualmente dati LCC1.

Test dei raggi

⚠️ Questo gruppo di interfacce non è sufficientemente testato e può non funzionare come previsto. In produzione usare invece l'approccio «abilitare le collisioni più i test dei raggi del motore»: caricare prima i dati di collisione con SetLCCCollisionEnable, poi eseguire il test con le interfacce del motore come LineTraceByChannel. Per i dettagli vedere Collisioni.

LCC1 fornisce quattro funzioni di test dei raggi che agiscono sulle posizioni degli splat. Il bersaglio del test sono i dati della nuvola di punti stessi e non è richiesto alcun file di collisione.

Le quattro funzioni si dividono in due gruppi, distinti su due dimensioni:

Parametri di debug condivisi da tutte e quattro:

Nota: queste quattro funzioni sono protected sul lato C++ e possono essere chiamate direttamente come nodi sul lato Blueprint. In C++ usarle all'interno di una sottoclasse di ULCCComponent, oppure passare ai test dei raggi forniti dal motore.

Raccomandazione

Preferire i corpi di collisione più i test dei raggi del motore. Dalla v0.6.0 in poi, quando i dati contengono un file di collisione e le collisioni sono abilitate, LineTraceByChannel restituisce un FHitResult completo (normale, materiale, component colpito e altro), funziona senza attriti con i sistemi di fisica, IA e navigazione del motore, e quel percorso è validato a fondo.

Le interfacce dedicate qui descritte vale la pena considerarle solo nei casi seguenti, e richiedono test approfonditi in autonomia:

• I dati non hanno un file di collisione e non è possibile passare a dati con collisioni.
• Servono le informazioni sul nodo del punto colpito (FLCCSplat::NodeVector fornisce X, Y e Level).

LineTraceSingle

UFUNCTION(BlueprintCallable, Category = "XGrids|Raycast")
bool LineTraceSingle(const FVector& Start, const FVector& End, FLCCSplat& OutHit,
                     bool bDrawDebugLine, float Duration, float Thickness) const;

Test del raggio a colpo singolo, che restituisce il punto colpito più vicino. Il raggio del test è fisso a 10 cm.

Restituisce bool: true in caso di colpo.

// all'interno di una sottoclasse di ULCCComponent
void UMyLCCComponent::PickFromCamera(const FVector& CamLocation, const FVector& CamForward)
{
    const FVector Start = CamLocation;
    const FVector End = Start + CamForward * 10000.f;

    FLCCSplat Hit;
    if (LineTraceSingle(Start, End, Hit, true, 2.0f, 2.0f))
    {
        UE_LOG(LogTemp, Log, TEXT("Hit at %s, node %s"),
            *Hit.Location.ToString(), *Hit.NodeVector.ToString());
    }
}

Blueprint come testo, selezione con un clic del mouse:

[Input Action: Pick]
        │ Pressed
        ▼
[Get Player Camera Manager] ──▶ [Get Camera Location]  → Start
                            └─▶ [Get Actor Forward Vector]
                                        │
                                        ▼
                                [Multiply] (× 10000)
                                        │
                                        ▼
                                [Add] (Start + passo precedente) → End
        │
        ▼
[Line Trace Single]
        Target = (LCC Component)
        Start = Start
        End = End
        Draw Debug Line = true
        Duration = 2.0
        Thickness = 2.0
        │ Return Value ──┐
        ▼                │
[Branch] ◀───────────────┘
        │ True
        ▼
[Break LCCSplat]  ← collegato a Out Hit
        Location → usato per posizionare un marcatore

LineTraceSingleWithRadius

UFUNCTION(BlueprintCallable, Category = "XGrids|Raycast")
bool LineTraceSingleWithRadius(const FVector& Start, const FVector& End, float Radius,
                               FLCCSplat& OutHit, bool bDrawDebugLine,
                               float Duration, float Thickness) const;

Test del raggio a colpo singolo con raggio del test configurabile.

Note d'uso:

• Una nuvola di punti è discreta e un raggio troppo piccolo passa facilmente tra gli spazi vuoti tra i punti, quindi non viene colpito nulla anche puntando direttamente a un oggetto. In quel caso aumentare il raggio.
• Un raggio più grande colpisce più facilmente ma abbassa la precisione, e il punto restituito può discostarsi dalla posizione realmente desiderata.
• Partire da 20~50 cm per i dati sparsi; 5~10 cm sono sufficienti per i dati densi.

FLCCSplat Hit;
// raggio ampio per una nuvola di punti sparsa, aumentando il tasso di colpi
if (LineTraceSingleWithRadius(Start, End, 30.0f, Hit, false, 0.f, 0.f))
{
    SpawnMarkerAt(Hit.Location);
}

LineTraceMulti

UFUNCTION(BlueprintCallable, Category = "XGrids|Raycast")
bool LineTraceMulti(const FVector& Start, const FVector& End,
                    bool bDrawDebugLine, float Duration, float Thickness,
                    TArray<FLCCSplat>& OutHits) const;

Test del raggio a colpi multipli, che restituisce ogni punto colpito lungo il percorso. Il raggio del test è fisso a 10 cm.

Note d'uso:

• Usarlo per i test penetranti, per esempio per misurare quanti strati di struttura una linea attraversa, oppure per l'analisi in sezione.
• Il numero di punti colpiti può essere elevato, quindi evitare di chiamarlo a ogni fotogramma.

TArray<FLCCSplat> Hits;
if (LineTraceMulti(Start, End, true, 3.0f, 1.0f, Hits))
{
    UE_LOG(LogTemp, Log, TEXT("Passed through %d splats"), Hits.Num());

    for (const FLCCSplat& Hit : Hits)
    {
        DrawDebugPoint(GetWorld(), Hit.Location, 8.f, FColor::Yellow, false, 3.f);
    }
}

LineTraceMultiWithRadius

UFUNCTION(BlueprintCallable, Category = "XGrids|Raycast")
bool LineTraceMultiWithRadius(const FVector& Start, const FVector& End, float Radius,
                              bool bDrawDebugLine, float Duration, float Thickness,
                              TArray<FLCCSplat>& OutHits) const;

Test del raggio a colpi multipli con raggio del test configurabile. I parametri hanno lo stesso significato di sopra.

Un raggio più grande aumenta notevolmente il numero di punti colpiti, cosa adatta a esigenze statistiche come la stima della densità dei punti all'interno di un'estensione cilindrica.

FLCCSplat

USTRUCT(BlueprintType)
struct FLCCSplat
{
    FVector Location;         // coordinate nel mondo del punto colpito
    FLCCVector NodeVector;    // nodo a cui appartiene il punto colpito
};

I campi X, Y e Level di FLCCVector individuano il nodo nell'octree. Level riflette il livello di dettaglio attualmente caricato in quel punto, cosa che indica se i dati osservati siano fini o grossolani.

Per i campi completi vedere Struct.

Vedere anche

• ULCCComponentBase: interfacce comuni di rendering e prestazioni
• ULCC2Component: il component corrispondente della pipeline LCC2
• Struct: campi di FLCCSplat, FLCCVector e FLCCRenderInfo