ULCCComponent : Component de la pipeline LCC

Component propre à la pipeline LCC1, qui hérite de ULCCComponentBase. Outre les capacités de la classe de base, il fournit en plus un test de rayon fondé sur la position des splats et la découpe des jointures.

#include "LCCComponent.h"

Obtenir l'instance :

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

Propriétés

MetaInfo (de type FLCCMetaInfo) est un membre protected, inaccessible de l'extérieur côté C++ et visible uniquement depuis Blueprint (lecture seule dans le panneau Details). En C++, utiliser GetMetaInfo() de la classe de base pour obtenir les champs de base.

LCCPerformance

Là aussi sous la forme d'un interrupteur associé à une valeur ; lorsque l'interrupteur est désactivé, la valeur par défaut des réglages du projet est utilisée.

ULCCComponent* Comp = Cast<ULCCComponent>(LCCActor->GetLCCComponent());
if (Comp)
{
    // Lower the sorting frequency to save performance
    Comp->LCCPerformance.bCanSetSortFactor = true;
    Comp->LCCPerformance.SortFactor = 2.0f;

    // Head turns fast in VR, add extra preload nodes
    Comp->LCCPerformance.bEnableExtraPreNodes = true;
    Comp->LCCPerformance.bAddExtraPreNodes = true;
}

Méthodes

GetUseSeamCut

bool GetUseSeamCut() const;

Indique si le shader active la découpe des jointures. Renvoie true si l'une des conditions est remplie : la version du fichier LCC est supérieure ou égale à 5.0, ou bEnableSeamCutting a été activé manuellement. Disponible en C++ uniquement.

Viewports multiples

Les interfaces liées aux viewports multiples sont déclarées sur la classe de base ULCCComponentBase, mais ne sont effectives que sur la pipeline LCC1. Les méthodes SetPlayerLoadMode, SetPlayerRenderMode, SetSceneCaptureLoadMode, SetSceneCaptureRenderMode, ModifyPlayerTransform et CancelModifyPlayerTransform n'ont de sens que si elles sont appelées sur un ULCCComponent.

La raison est que la stratégie de rendu par viewport et l'ordonnancement des nœuds sont consommés par le chemin de rendu de LCC1, LCC2 n'y étant pas encore raccordé. Les appeler sur un ULCC2Component (y compris ALCC2Actor et .sog / .spz / .ply) ne provoque pas d'erreur, mais ne donne pas le résultat attendu.

Pour un rendu différencié du type viewport principal en haute qualité et mini-carte en basse qualité, ou pour un préchargement avant téléportation, seules les données LCC1 conviennent aujourd'hui.

Raycast

⚠️ Ce groupe d'interfaces n'a pas été suffisamment testé et peut ne pas fonctionner comme prévu. En production, adopter plutôt la solution « activer la collision + test de rayon du moteur » : charger d'abord les données de collision avec SetLCCCollisionEnable, puis effectuer le test avec les interfaces du moteur comme LineTraceByChannel. Voir Collision pour le détail.

LCC1 fournit quatre fonctions de test de rayon visant la position des splats ; la cible du test est la donnée de nuage de points elle-même, aucun fichier de collision n'est nécessaire.

Les quatre fonctions se répartissent en deux groupes, selon deux dimensions :

Paramètres de débogage communs aux quatre :

Note : ces quatre fonctions sont protected côté C++, alors que côté Blueprint elles s'appellent directement comme des nodes. En C++, il faut les utiliser dans une sous-classe de ULCCComponent, ou passer au test de rayon du moteur.

Recommandation de choix

Privilégier les corps de collision et le test de rayon du moteur. Depuis la v0.6.0, lorsque les données comportent un fichier de collision et que la collision est activée, LineTraceByChannel fournit un FHitResult complet (normale, matériau, Component touché, etc.) et s'intègre sans heurt à la physique, à l'IA et à la navigation du moteur ; ce chemin est de plus pleinement validé.

Les interfaces dédiées présentées ici ne méritent d'être envisagées que dans les cas suivants, et avec des tests approfondis de votre côté :

• Les données n'ont pas de fichier de collision et il n'est pas possible de passer à des données qui en comportent.
• Il faut obtenir les informations du nœud auquel appartient le point d'impact (FLCCSplat::NodeVector donne X, Y et 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 de rayon unique, qui renvoie le point d'impact le plus proche. Le rayon de test est fixé à 10 centimètres.

Renvoie un bool : true en cas d'impact.

// Inside a subclass of 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 sous forme de texte, sélection au clic de souris :

[Input Action: Pick]
        │ Pressed
        ▼
[Get Player Camera Manager] ──▶ [Get Camera Location]  → Start
                            └─▶ [Get Actor Forward Vector]
                                        │
                                        ▼
                                [Multiply] (× 10000)
                                        │
                                        ▼
                                [Add] (Start + previous step) → 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]  ← connected to Out Hit
        Location → used to place a marker

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 de rayon unique, avec un rayon de test spécifiable.

Points d'utilisation :

• Le nuage de points est discret : si le rayon est trop petit, le test passe facilement entre les points et ne détecte rien alors que l'objet est bien visé. Augmenter alors le rayon.
• Plus le rayon est grand, plus l'impact est probable, mais la précision baisse et le point renvoyé peut s'écarter de l'endroit réellement visé.
• Partir de 20~50 centimètres pour des données éparses ; 5~10 centimètres suffisent pour des données denses.

FLCCSplat Hit;
// Use a large radius on sparse point clouds to improve the hit rate
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 de rayon multiple, qui renvoie tous les points d'impact le long du trajet. Rayon de test fixé à 10 centimètres.

Points d'utilisation :

• Utile pour un test traversant, par exemple pour mesurer combien de couches de structure une ligne traverse, ou pour une analyse en coupe.
• Le nombre de points d'impact peut être très élevé ; éviter de l'appeler à chaque image.

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 de rayon multiple, avec un rayon de test spécifiable. Les paramètres ont le même sens que ci-dessus.

Avec un rayon important, le nombre de points d'impact augmente nettement, ce qui convient aux besoins statistiques (par exemple estimer la densité de points dans un cylindre donné).

FLCCSplat

USTRUCT(BlueprintType)
struct FLCCSplat
{
    FVector Location;         // world coordinates of the hit point
    FLCCVector NodeVector;    // node the hit point belongs to
};

Les trois champs X, Y et Level de FLCCVector localisent le nœud dans l'octree. Level reflète le niveau de détail chargé à cet endroit et permet de savoir « si ce que je vois est une donnée fine ou grossière ».

Les champs complets figurent dans Structs.

Voir aussi

• ULCCComponentBase : interfaces générales de rendu et de performance
• ULCC2Component : le Component correspondant de la pipeline LCC2
• Structs : description des champs de FLCCSplat, FLCCVector, FLCCRenderInfo