ULCCComponent: Component del pipeline LCC

Component específico del pipeline LCC1, que hereda ULCCComponentBase. Además de las capacidades de la clase base, añade pruebas de rayos basadas en las posiciones de los splats y el corte de costuras.

#include "LCCComponent.h"

Obtener la instancia:

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

Propiedades

MetaInfo (de tipo FLCCMetaInfo) es un miembro protegido, no accesible desde fuera en el lado de C++ y solo visible para Blueprint (solo lectura en el panel Details). En C++ usar GetMetaInfo() de la clase base para leer los campos básicos.

LCCPerformance

También con la forma de una casilla más un valor, usando el valor predeterminado de la configuración del proyecto mientras la casilla está desmarcada.

ULCCComponent* Comp = Cast<ULCCComponent>(LCCActor->GetLCCComponent());
if (Comp)
{
    // ordenar con menos frecuencia para ahorrar rendimiento
    Comp->LCCPerformance.bCanSetSortFactor = true;
    Comp->LCCPerformance.SortFactor = 2.0f;

    // los giros de cabeza son rápidos en VR, añadir nodos de precarga
    Comp->LCCPerformance.bEnableExtraPreNodes = true;
    Comp->LCCPerformance.bAddExtraPreNodes = true;
}

Métodos

GetUseSeamCut

bool GetUseSeamCut() const;

Si el shader tiene el corte de costuras activado. Devuelve true cuando se cumple cualquiera de las dos condiciones: la versión del archivo LCC es 5.0 o superior, o bEnableSeamCutting se activó manualmente. Solo C++.

Varios viewports

Las interfaces de varios viewports (SetPlayerLoadMode, SetPlayerRenderMode, SetSceneCaptureLoadMode, SetSceneCaptureRenderMode, ModifyPlayerTransform, CancelModifyPlayerTransform) se declaran en la clase base ULCCComponentBase y las admiten tanto el pipeline LCC1 como el LCC2.

Para los casos de uso y los pasos, consultar Buenas prácticas - Renderizado independiente por cámara.

Prueba de rayos

⚠️ Este grupo de interfaces no está suficientemente probado y puede no funcionar como se espera. En producción, usar en su lugar el enfoque de «activar la colisión más las pruebas de rayos del motor»: cargar primero los datos de colisión con SetLCCCollisionEnable y probar después con interfaces del motor como LineTraceByChannel. Consultar Colisión para más detalles.

LCC1 proporciona cuatro funciones de prueba de rayos dirigidas a las posiciones de los splats. El objetivo de la prueba son los propios datos de nube de puntos y no se requiere ningún archivo de colisión.

Las cuatro funciones se dividen en dos grupos que difieren en dos dimensiones:

Parámetros de depuración comunes a las cuatro:

Nota: estas cuatro funciones son protected en el lado de C++ y se pueden llamar como nodos directamente en el lado de Blueprint. En C++ usarlas dentro de una subclase de ULCCComponent, o pasar a las pruebas de rayos que proporciona el motor.

Recomendación

Preferir los cuerpos de colisión más las pruebas de rayos del motor. A partir de la v0.6.0, una vez que los datos incluyen un archivo de colisión y la colisión está activada, LineTraceByChannel devuelve un FHitResult completo (normal, material, componente impactado y más), funciona sin fricción con los sistemas de física, IA y navegación del motor, y esa vía está exhaustivamente validada.

Las interfaces dedicadas de aquí solo merecen consideración en los casos siguientes, y requieren pruebas exhaustivas propias:

• Los datos no tienen archivo de colisión y no es posible pasar a datos con colisión.
• Se requiere la información de nodo del punto de impacto (FLCCSplat::NodeVector da X, Y y Level).

LineTraceSingle

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

Prueba de rayo simple, que devuelve el punto de impacto más cercano. El radio de la prueba está fijado en 10 cm.

Devuelve bool: true cuando hay impacto.

// dentro de una subclase de 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 como texto, selección con un clic del ratón:

[Input Action: Pick]
        │ Pressed
        ▼
[Get Player Camera Manager] ──▶ [Get Camera Location]  → Start
                            └─▶ [Get Actor Forward Vector]
                                        │
                                        ▼
                                [Multiply] (× 10000)
                                        │
                                        ▼
                                [Add] (Start + paso anterior) → 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]  ← conectado a Out Hit
        Location → usado para colocar un marcador

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;

Prueba de rayo simple con un radio de prueba configurable.

Notas de uso:

• Una nube de puntos es discreta, y un radio demasiado pequeño atraviesa fácilmente los huecos entre puntos, así que no se impacta en nada aunque se apunte directamente a un objeto. En ese caso conviene aumentar el radio.
• Un radio mayor impacta con más facilidad pero reduce la precisión, y el punto devuelto puede desviarse de la posición realmente pretendida.
• Empezar en 20~50 cm para datos dispersos; 5~10 cm es suficiente para datos densos.

FLCCSplat Hit;
// radio grande para una nube de puntos dispersa, lo que aumenta la tasa de impacto
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;

Prueba de rayo múltiple, que devuelve todos los puntos de impacto a lo largo del recorrido. El radio de la prueba está fijado en 10 cm.

Notas de uso:

• Usarla para pruebas penetrantes, por ejemplo para medir cuántas capas de estructura atraviesa una línea, o para análisis de secciones.
• El número de puntos de impacto puede ser grande, así que conviene evitar llamarla en cada fotograma.

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;

Prueba de rayo múltiple con un radio de prueba configurable. Los parámetros significan lo mismo que arriba.

Un radio mayor aumenta notablemente el número de puntos de impacto, lo que se ajusta a necesidades estadísticas como estimar la densidad de puntos dentro de un rango cilíndrico.

FLCCSplat

USTRUCT(BlueprintType)
struct FLCCSplat
{
    FVector Location;         // coordenadas de mundo del punto de impacto
    FLCCVector NodeVector;    // nodo al que pertenece el punto de impacto
};

Los campos X, Y y Level de FLCCVector sitúan el nodo dentro del octree. Level refleja el nivel de detalle cargado actualmente en ese lugar, lo que indica si los datos que se están viendo son finos o gruesos.

Para los campos completos, consultar Structs.

Véase también

• ULCCComponentBase: interfaces comunes de renderizado y rendimiento
• ULCC2Component: el componente correspondiente del pipeline LCC2
• Structs: campos de FLCCSplat, FLCCVector y FLCCRenderInfo