ULCCComponent: Component der LCC-Pipeline

Component, die der LCC1-Pipeline eigen ist und von ULCCComponentBase erbt. Über die Fähigkeiten der Basisklasse hinaus ergänzt sie Strahlentests anhand der Splat-Positionen sowie die Nahtentfernung.

#include "LCCComponent.h"

Die Instanz holen:

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

Eigenschaften

MetaInfo (vom Typ FLCCMetaInfo) ist ein protected Member, auf der C++-Seite von außen nicht erreichbar und nur für Blueprint sichtbar (im Details-Panel nur lesbar). In C++ mit GetMetaInfo() der Basisklasse die grundlegenden Felder lesen.

LCCPerformance

Ebenfalls in der Form Kontrollkästchen plus Wert; solange das Kästchen aus ist, wird der Standardwert aus den Projekteinstellungen genutzt.

ULCCComponent* Comp = Cast<ULCCComponent>(LCCActor->GetLCCComponent());
if (Comp)
{
    // seltener sortieren, um Leistung zu sparen
    Comp->LCCPerformance.bCanSetSortFactor = true;
    Comp->LCCPerformance.SortFactor = 2.0f;

    // Kopfdrehungen sind in VR schnell, Preload-Nodes ergänzen
    Comp->LCCPerformance.bEnableExtraPreNodes = true;
    Comp->LCCPerformance.bAddExtraPreNodes = true;
}

Methoden

GetUseSeamCut

bool GetUseSeamCut() const;

Ob der Shader die Nahtentfernung aktiviert hat. Gibt true zurück, wenn eine der beiden Bedingungen gilt: die LCC-Dateiversion ist 5.0 oder höher, oder bEnableSeamCutting wurde manuell aktiviert. Nur C++.

Mehrere Viewports

Die Schnittstellen für mehrere Viewports sind an der Basisklasse ULCCComponentBase deklariert, wirken aber nur in der LCC1-Pipeline. SetPlayerLoadMode, SetPlayerRenderMode, SetSceneCaptureLoadMode, SetSceneCaptureRenderMode, ModifyPlayerTransform und CancelModifyPlayerTransform sind nur sinnvoll, wenn sie an einer ULCCComponent aufgerufen werden.

Der Grund ist, dass die Rendering-Strategie je Ansicht und die Node-Planung vom LCC1-Rendering-Pfad genutzt werden und LCC2 dafür noch nicht angebunden ist. Ein Aufruf an ULCC2Component (einschließlich ALCC2Actor und .sog / .spz / .ply) löst keinen Fehler aus, liefert aber nicht das erwartete Ergebnis.

Unterschiedliches Rendering wie hohe Qualität im Hauptviewport und niedrige Qualität in einer Minimap oder das Vorladen vor einem Teleport erfordert derzeit LCC1-Daten.

Strahlentest

⚠️ Diese Gruppe von Schnittstellen ist nicht ausreichend getestet und arbeitet möglicherweise nicht wie erwartet. In der Produktion stattdessen den Weg „Kollision aktivieren plus Strahlentest der Engine“ nutzen: zuerst die Kollisionsdaten mit SetLCCCollisionEnable laden, dann mit Engine-Schnittstellen wie LineTraceByChannel testen. Näheres unter Kollision.

LCC1 bietet vier Funktionen für Strahlentests, die auf die Splat-Positionen zielen. Testziel sind die Punktwolkendaten selbst, eine Kollisionsdatei ist nicht erforderlich.

Die vier Funktionen bilden zwei Gruppen und unterscheiden sich in zwei Dimensionen:

Debug-Parameter, die alle vier gemeinsam haben:

Hinweis: Diese vier Funktionen sind auf der C++-Seite protected und lassen sich auf der Blueprint-Seite unmittelbar als Nodes aufrufen. In C++ sie innerhalb einer Unterklasse von ULCCComponent nutzen oder auf die von der Engine bereitgestellten Strahlentests wechseln.

Empfehlung

Kollisionskörper plus Strahlentests der Engine bevorzugen. Ab v0.6.0 gibt LineTraceByChannel, sobald die Daten eine Kollisionsdatei mitbringen und Kollision aktiviert ist, ein vollständiges FHitResult zurück (Normale, Material, getroffene Component und mehr), arbeitet reibungslos mit den Systemen für Physik, KI und Navigation der Engine zusammen, und dieser Weg ist gründlich validiert.

Die eigenen Schnittstellen hier sind nur in den folgenden Fällen eine Überlegung wert und erfordern eigene, gründliche Tests:

• Die Daten haben keine Kollisionsdatei und ein Wechsel auf Daten mit Kollision ist nicht möglich.
• Die Node-Information des Trefferpunkts wird gebraucht (FLCCSplat::NodeVector liefert X, Y und Level).

LineTraceSingle

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

Einzelner Strahlentest, gibt den nächstgelegenen Trefferpunkt zurück. Der Testradius liegt fest bei 10 cm.

Rückgabewert bool: true bei einem Treffer.

// innerhalb einer Unterklasse von 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 als Text, Auswahl mit einem Mausklick:

[Input Action: Pick]
        │ Pressed
        ▼
[Get Player Camera Manager] ──▶ [Get Camera Location]  → Start
                            └─▶ [Get Actor Forward Vector]
                                        │
                                        ▼
                                [Multiply] (× 10000)
                                        │
                                        ▼
                                [Add] (Start + vorheriger Schritt) → 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]  ← verbunden mit Out Hit
        Location → zum Platzieren einer Markierung genutzt

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;

Einzelner Strahlentest mit konfigurierbarem Testradius.

Hinweise zur Verwendung:

• Eine Punktwolke ist diskret, und ein zu kleiner Radius geht leicht durch die Lücken zwischen den Punkten hindurch, sodass nichts getroffen wird, obwohl direkt auf ein Objekt gezeigt wird. In diesem Fall den Radius erhöhen.
• Ein größerer Radius trifft leichter, senkt aber die Genauigkeit, und der zurückgegebene Punkt kann von der tatsächlich gemeinten Position abweichen.
• Bei dünn besetzten Daten mit 20~50 cm beginnen; bei dichten Daten genügen 5~10 cm.

FLCCSplat Hit;
// großer Radius für eine dünn besetzte Punktwolke, erhöht die Trefferquote
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;

Strahlentest mit mehreren Treffern, gibt jeden Trefferpunkt entlang des Wegs zurück. Der Testradius liegt fest bei 10 cm.

Hinweise zur Verwendung:

• Damit durchdringende Tests machen, zum Beispiel messen, durch wie viele Schichten von Struktur eine Linie läuft, oder eine Querschnittsanalyse durchführen.
• Die Anzahl der Trefferpunkte kann groß sein, einen Aufruf in jedem Bild daher vermeiden.

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;

Strahlentest mit mehreren Treffern und konfigurierbarem Testradius. Die Parameter bedeuten dasselbe wie oben.

Ein größerer Radius erhöht die Anzahl der Trefferpunkte merklich, was zu statistischen Zwecken passt, etwa dem Schätzen der Punktdichte innerhalb eines zylindrischen Bereichs.

FLCCSplat

USTRUCT(BlueprintType)
struct FLCCSplat
{
    FVector Location;         // Weltkoordinaten des Trefferpunkts
    FLCCVector NodeVector;    // Node, zu dem der Trefferpunkt gehört
};

Die Felder X, Y und Level von FLCCVector verorten den Node im Octree. Level spiegelt das an dieser Stelle aktuell geladene Detaillevel und sagt damit, ob die betrachteten Daten fein oder grob sind.

Die vollständigen Felder unter Structs.

Siehe auch

• ULCCComponentBase: gemeinsame Schnittstellen für Rendering und Leistung
• ULCC2Component: die zugehörige Component der LCC2-Pipeline
• Structs: Felder von FLCCSplat, FLCCVector und FLCCRenderInfo