SplineMeshComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Misc/Guid.h"
#include "Interfaces/Interface_CollisionDataProvider.h"
#include "Components/StaticMeshComponent.h"
#include "SplineMeshShaderParams.h"
 
#include "SplineMeshComponent.generated.h"
 
class FPrimitiveSceneProxy;
class ULightComponent;
struct FNavigableGeometryExport;
class UBodySetup;
struct FMeshDescription;
 
// Helper for packing spline mesh shader parameters into a float4 buffer
ENGINE_API void PackSplineMeshParams(const FSplineMeshShaderParams& Params, const TArrayView<FVector4f>& Output);
 
UENUM(BlueprintType)
namespace ESplineMeshAxis
{
    enum Type : int
    {
        X,
        Y,
        Z,
    };
}
 
namespace UE::SplineMesh
{
    ENGINE_API float RealToFloatChecked(const double Value);
}
 
USTRUCT()
struct FSplineMeshParams
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, Category=SplineMesh)
    FVector StartPos;
 
    UPROPERTY(EditAnywhere, Category=SplineMesh)
    FVector StartTangent;
 
    UPROPERTY(EditAnywhere, Category=SplineMesh, AdvancedDisplay)
    FVector2D StartScale;
 
    UPROPERTY(EditAnywhere, Category=SplineMesh, AdvancedDisplay)
    float StartRoll;
 
    UPROPERTY(EditAnywhere, Category=SplineMesh, AdvancedDisplay, meta=(DisplayAfter="EndTangent"))
    float EndRoll;
 
    UPROPERTY(EditAnywhere, Category=SplineMesh, AdvancedDisplay)
    FVector2D StartOffset;
 
    UPROPERTY(EditAnywhere, Category=SplineMesh)
    FVector EndPos;
 
    UPROPERTY(EditAnywhere, Category=SplineMesh, AdvancedDisplay)
    FVector2D EndScale;
 
    UPROPERTY(EditAnywhere, Category = SplineMesh)
    FVector EndTangent;
 
    UPROPERTY(EditAnywhere, Category=SplineMesh, AdvancedDisplay)
    FVector2D EndOffset;
 
    UPROPERTY(EditAnywhere, Category=SplineMesh, AdvancedDisplay, meta=(ClampMin=1.0))
    float NaniteClusterBoundsScale;
 
 
    FSplineMeshParams()
        : StartPos(ForceInit)
        , StartTangent(ForceInit)
        , StartScale(ForceInit)
        , StartRoll(0)
        , EndRoll(0)
        , StartOffset(ForceInit)
        , EndPos(ForceInit)
        , EndScale(ForceInit)
        , EndTangent(ForceInit)
        , EndOffset(ForceInit)
        , NaniteClusterBoundsScale(1.0f)
    {
    }
 
};
 
UCLASS(ClassGroup=Rendering, hidecategories=(Physics), meta=(BlueprintSpawnableComponent), MinimalAPI)
class USplineMeshComponent : public UStaticMeshComponent, public IInterface_CollisionDataProvider
{
    GENERATED_UCLASS_BODY()
 
    
    UPROPERTY(EditAnywhere, Category=SplineMesh, meta=(ShowOnlyInnerProperties))
    FSplineMeshParams SplineParams;
 
    UPROPERTY(EditAnywhere, Category=SplineMesh)
    FVector SplineUpDir;
 
    UPROPERTY(EditAnywhere, Category = SplineMesh, AdvancedDisplay)
    float SplineBoundaryMin;
 
    // Used to automatically trigger rebuild of collision data
    UPROPERTY()
    FGuid CachedMeshBodySetupGuid;
 
    UPROPERTY()
    float VirtualTextureMainPassMaxDrawDistance = 0.f;
 
    // Navigation bounds can differ from primitive bounds since NavCollision can hold more geometry
    FBox CachedNavigationBounds;
 
    // Physics data.
    UPROPERTY()
    TObjectPtr<UBodySetup> BodySetup;
 
    UPROPERTY(EditAnywhere, Category = SplineMesh, AdvancedDisplay)
    float SplineBoundaryMax;
 
    UPROPERTY(EditAnywhere, Category=SplineMesh)
    TEnumAsByte<ESplineMeshAxis::Type> ForwardAxis;
 
    UPROPERTY(EditDefaultsOnly, Category = Spline)
    uint8 bAllowSplineEditingPerInstance:1;
 
    UPROPERTY(EditAnywhere, Category=SplineMesh, AdvancedDisplay)
    uint8 bSmoothInterpRollScale:1;
 
    // Indicates that the mesh needs updating
    UPROPERTY(transient)
    uint8 bMeshDirty : 1;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(transient)
    uint8 bSelected:1;
#endif
 
private:
    UPROPERTY(EditAnywhere, Getter, Setter, Category = Collision)
    uint8 bNeverNeedsCookedCollisionData:1;
 
public:
    ENGINE_API void InitVertexFactory(int32 InLODIndex, FColorVertexBuffer* InOverrideColorVertexBuffer);
 
    //Begin UObject Interface
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
#if WITH_EDITOR
    ENGINE_API bool IsRelevantForSplinePartitioning() const;
    ENGINE_API virtual bool IsEditorOnly() const override;
    ENGINE_API virtual bool Modify(bool bAlwaysMarkDirty = true) override;
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif
    //End UObject Interface
 
    //~ Begin UActorComponent Interface.
    ENGINE_API virtual TStructOnScope<FActorComponentInstanceData> GetComponentInstanceData() const override;
    //~ End UActorComponent Interface.
 
    ENGINE_API void ApplyComponentInstanceData(struct FSplineMeshInstanceData* ComponentInstanceData);
 
    //Begin USceneComponent Interface
    ENGINE_API virtual FBoxSphereBounds CalcBounds(const FTransform& LocalToWorld) const override;
    ENGINE_API virtual FTransform GetSocketTransform(FName InSocketName, ERelativeTransformSpace TransformSpace = RTS_World) const override;
    ENGINE_API virtual void UpdateBounds() override;
    //End USceneComponent Interface
 
    //Begin UPrimitiveComponent Interface
protected:
    ENGINE_API virtual void OnCreatePhysicsState() override;
 
    float ComputeRatioAlongSpline(float DistanceAlong) const;
 
    void ComputeVisualMeshSplineTRange(float& MinT, float& MaxT) const;
 
    FBox ComputeDistortedBounds(const FTransform& InLocalToWorld, const FBoxSphereBounds& InMeshBounds, const FBoxSphereBounds* InBoundsToDistort = nullptr) const;
 
public:
    ENGINE_API virtual class UBodySetup* GetBodySetup() override;
    ENGINE_API class UBodySetup* GetBodySetup() const;
#if WITH_EDITOR
    virtual bool ShouldRenderSelected() const override
    {
        return Super::ShouldRenderSelected() || bSelected;
    }
#endif
    ENGINE_API virtual bool DoCustomNavigableGeometryExport(FNavigableGeometryExport& GeomExport) const override;
    virtual float GetVirtualTextureMainPassMaxDrawDistance() const override { return VirtualTextureMainPassMaxDrawDistance; }
    //End UPrimitiveComponent Interface
 
    //Begin UStaticMeshComponent Interface
public:
    ENGINE_API virtual class FStaticMeshStaticLightingMesh* AllocateStaticLightingMesh(int32 LODIndex, const TArray<ULightComponent*>& InRelevantLights) override;
protected:
    ENGINE_API virtual FPrimitiveSceneProxy* CreateStaticMeshSceneProxy(::Nanite::FMaterialAudit& NaniteMaterials, bool bCreateNanite) override;
    //End UStaticMeshComponent Interface
 
    //~ Begin Interface_CollisionDataProvider Interface
public:
    ENGINE_API virtual bool GetPhysicsTriMeshData(struct FTriMeshCollisionData* CollisionData, bool InUseAllTriData) override;
    ENGINE_API virtual bool ContainsPhysicsTriMeshData(bool InUseAllTriData) const override;
    virtual bool WantsNegXTriMesh() override { return false; }
    ENGINE_API virtual void GetMeshId(FString& OutMeshId) override;
    ENGINE_API void GetMeshId(FString& OutMeshId) const;
    ENGINE_API virtual bool GetTriMeshSizeEstimates(struct FTriMeshCollisionDataEstimates& OutTriMeshEstimates, bool bInUseAllTriData) const override;
    //~ End Interface_CollisionDataProvider Interface
 
    //~ Begin INavRelevantInterface
    ENGINE_API virtual FBox GetNavigationBounds() const override;
    //~ End  INavRelevantInterface
 
    ENGINE_API FSplineMeshShaderParams CalculateShaderParams() const;
 
    ENGINE_API void UpdateRenderStateAndCollision();
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API void UpdateMesh();
 
    ENGINE_API void UpdateMesh_Concurrent();
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API FVector GetStartPosition() const;
 
    UFUNCTION(BlueprintCallable, Category=SplineMesh)
    ENGINE_API void SetStartPosition(FVector StartPos, bool bUpdateMesh = true);
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API FVector GetStartTangent() const;
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API void SetStartTangent(FVector StartTangent, bool bUpdateMesh = true);
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API FVector GetEndPosition() const;
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API void SetEndPosition(FVector EndPos, bool bUpdateMesh = true);
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API FVector GetEndTangent() const;
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API void SetEndTangent(FVector EndTangent, bool bUpdateMesh = true);
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API void SetStartAndEnd(FVector StartPos, FVector StartTangent, FVector EndPos, FVector EndTangent, bool bUpdateMesh = true);
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API FVector2D GetStartScale() const;
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API void SetStartScale(FVector2D StartScale = FVector2D(1,1), bool bUpdateMesh = true);
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API float GetStartRoll() const;
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh, meta = (DisplayName = "Set Start Roll Radians"))
    ENGINE_API void SetStartRoll(float StartRoll, bool bUpdateMesh = true);
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API void SetStartRollDegrees(float StartRollDegrees, bool bUpdateMesh = true);
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API FVector2D GetStartOffset() const;
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API void SetStartOffset(FVector2D StartOffset, bool bUpdateMesh = true);
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API FVector2D GetEndScale() const;
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API void SetEndScale(FVector2D EndScale = FVector2D(1,1), bool bUpdateMesh = true);
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API float GetEndRoll() const;
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh, meta = (DisplayName = "Set End Roll Radians"))
    ENGINE_API void SetEndRoll(float EndRoll, bool bUpdateMesh = true);
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API void SetEndRollDegrees(float EndRollDegrees, bool bUpdateMesh = true);
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API FVector2D GetEndOffset() const;
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API void SetEndOffset(FVector2D EndOffset, bool bUpdateMesh = true);
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API ESplineMeshAxis::Type GetForwardAxis() const;
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API void SetForwardAxis(ESplineMeshAxis::Type InForwardAxis, bool bUpdateMesh = true);
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API FVector GetSplineUpDir() const;
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API void SetSplineUpDir(const FVector& InSplineUpDir, bool bUpdateMesh = true);
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API float GetBoundaryMin() const;
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API void SetBoundaryMin(float InBoundaryMin, bool bUpdateMesh = true);
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API float GetBoundaryMax() const;
 
    UFUNCTION(BlueprintCallable, Category = SplineMesh)
    ENGINE_API void SetBoundaryMax(float InBoundaryMax, bool bUpdateMesh = true);
 
    ENGINE_API void SetbNeverNeedsCookedCollisionData(bool bInValue); 
 
    bool GetbNeverNeedsCookedCollisionData() const { return bNeverNeedsCookedCollisionData; }
 
    // Destroys the body setup, used to clear collision if the mesh goes missing
    ENGINE_API void DestroyBodySetup();
    // Builds collision for the spline mesh (if collision is enabled)
    ENGINE_API void RecreateCollision();
 
    ENGINE_API FTransform CalcSliceTransform(const float DistanceAlong) const;
 
    ENGINE_API FTransform CalcSliceTransformAtSplineOffset(const float Alpha, const float MinT=0.f, const float MaxT=1.0f) const;
 
    ENGINE_API void PropagateSplineDeformationToMesh(FMeshDescription& InOutMeshDescription) const;
 
    inline static const double& GetAxisValueRef(const FVector3d& InVector, ESplineMeshAxis::Type InAxis);
    inline static double& GetAxisValueRef(FVector3d& InVector, ESplineMeshAxis::Type InAxis);
 
    inline static const float& GetAxisValueRef(const FVector3f& InVector, ESplineMeshAxis::Type InAxis);
    inline static float& GetAxisValueRef(FVector3f& InVector, ESplineMeshAxis::Type InAxis);
 
    inline static FVector GetAxisMask(ESplineMeshAxis::Type InAxis);
    ENGINE_API static bool ShouldRenderNaniteSplineMeshes();
 
    ENGINE_API virtual float GetTextureStreamingTransformScale() const override;
 
    ENGINE_API virtual void CollectPSOPrecacheData(const FPSOPrecacheParams& BasePrecachePSOParams, FMaterialInterfacePSOPrecacheParamsList& OutParams) override;
 
private:
    ENGINE_API void UpdateRenderStateAndCollision_Internal(bool bConcurrent);
};
 
USTRUCT()
struct FSplineMeshInstanceData : public FStaticMeshComponentInstanceData
{
    GENERATED_BODY()
public:
    FSplineMeshInstanceData() = default;
    explicit FSplineMeshInstanceData(const USplineMeshComponent* SourceComponent);
 
    virtual ~FSplineMeshInstanceData() override = default;
 
    virtual bool ContainsData() const override
    {
        return true;
    }
 
    virtual void ApplyToComponent(UActorComponent* Component, const ECacheApplyPhase CacheApplyPhase) override
    {
        Super::ApplyToComponent(Component, CacheApplyPhase);
        CastChecked<USplineMeshComponent>(Component)->ApplyComponentInstanceData(this);
    }
 
    UPROPERTY()
    FVector StartPos = FVector::ZeroVector;
 
    UPROPERTY()
    FVector EndPos = FVector::ZeroVector;
 
    UPROPERTY()
    FVector StartTangent = FVector::ZeroVector;
 
    UPROPERTY()
    FVector EndTangent = FVector::ZeroVector;
};
 
const double& USplineMeshComponent::GetAxisValueRef(const FVector3d& InVector, ESplineMeshAxis::Type InAxis)
{
    switch (InAxis)
    {
    case ESplineMeshAxis::X:
        return InVector.X;
    case ESplineMeshAxis::Y:
        return InVector.Y;
    case ESplineMeshAxis::Z:
        return InVector.Z;
    default:
        check(0);
        return InVector.Z;
    }
}
 
double& USplineMeshComponent::GetAxisValueRef(FVector3d& InVector, ESplineMeshAxis::Type InAxis)
{
    switch (InAxis)
    {
    case ESplineMeshAxis::X:
        return InVector.X;
    case ESplineMeshAxis::Y:
        return InVector.Y;
    case ESplineMeshAxis::Z:
        return InVector.Z;
    default:
        check(0);
        return InVector.Z;
    }
}
 
 
const float& USplineMeshComponent::GetAxisValueRef(const FVector3f& InVector, ESplineMeshAxis::Type InAxis)
{
    switch (InAxis)
    {
    case ESplineMeshAxis::X:
        return InVector.X;
    case ESplineMeshAxis::Y:
        return InVector.Y;
    case ESplineMeshAxis::Z:
        return InVector.Z;
    default:
        check(0);
        return InVector.Z;
    }
}
 
float& USplineMeshComponent::GetAxisValueRef(FVector3f& InVector, ESplineMeshAxis::Type InAxis)
{
    switch (InAxis)
    {
    case ESplineMeshAxis::X:
        return InVector.X;
    case ESplineMeshAxis::Y:
        return InVector.Y;
    case ESplineMeshAxis::Z:
        return InVector.Z;
    default:
        check(0);
        return InVector.Z;
    }
}
 
FVector USplineMeshComponent::GetAxisMask(ESplineMeshAxis::Type InAxis)
{
    switch (InAxis)
    {
    case ESplineMeshAxis::X:
        return FVector(0, 1, 1);
    case ESplineMeshAxis::Y:
        return FVector(1, 0, 1);
    case ESplineMeshAxis::Z:
        return FVector(1, 1, 0);
    default:
        check(0);
        return FVector::ZeroVector;
    }
}