SplineMeshedComponent.h

Go to the documentation of this file.

/*
 * Copyright (c) 2026 Grzegorz Krug.
 * All Rights Reserved.
 */
#pragma once
 
 
#include "CoreMinimal.h"
#include "Engine/StaticMesh.h"
 
#include "Components/SplineComponent.h"
#include "Components/SplineMeshComponent.h"
 
 
/* FOverlapResult include */
#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION == 4
#include "Engine/EngineTypes.h"
#include "Engine/OverlapResult.h"
#elif ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION < 4
#include "Engine/EngineTypes.h"
#else
#include "Engine/OverlapResult.h"
#endif
 
 
#include "SplineMeshedComponent.generated.h"
 


UENUM(
    BlueprintType,
    Category="YasiuSpline",
    meta = ( DisplayName = "Roll Method", ToolTip = "Different methods to solve rotation along spline" )
)
enum class ESplineRotateMode : uint8 {
    ConstantAbsolute,

    ConstantRelative,

    Default,

    DefaultFixed,

    SmoothRoll,
 
    //SmoothRollSnaped,
};
 

UENUM(
    BlueprintType,
    Category="YasiuSpline",
    meta = ( DisplayName = "Mesh Stretching Method", ToolTip = "Method fits meshes along spline" )
)
enum class ESplineMeshStretching : uint8 {
    NoStretching,

    StretchOnlyLast,

    MinimalStretchOnAll,

    ItemPerSegment,

    PipeStretching,
};
 
 
// UENUM(BlueprintType, meta = ( DisplayName = "SplineType", ToolTip = "What type of spline is it." ))
// enum class ESplineRoadType : uint8 {
//  /// Allow junctions and extension with same type.
//  AllowFullExtension,
//
//  /// Connect other road, but don't add points.
//  JunctionsOnly,
//
//  /// Spline can be extended with new points, but no Junctions
//  PointExtensionOnly,
//
//  /// This spline can only have 2 points.
//  TwoPointsOnly
// };

USTRUCT(BlueprintType, Category="YasiuSpline")
struct FSplineSinusParams {
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="YasiuSpline")
    float PeriodDistance = 800;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="YasiuSpline")
    float Amplitude = 300;
};
 

USTRUCT(BlueprintType, Category="YasiuSpline")
struct FSplineHelixParams {
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="YasiuSpline")
    float PeriodDistance = 800;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="YasiuSpline")
    float Amplitude = 400;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="YasiuSpline")
    bool AlternateDirection = false;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="YasiuSpline")
    int Resolution = 8;
};
 

USTRUCT(BlueprintType, Category="YasiuSpline")
struct FSplineMeshed_PointTangent {
    GENERATED_BODY()
 
    
    UPROPERTY(BlueprintReadWrite, Category="YasiuSpline")
    float tangent = 0;

    UPROPERTY(BlueprintReadWrite, Category="YasiuSpline")
    float rotation = 0;
};
 

USTRUCT(BlueprintType, Category="YasiuSpline")
struct FSplineMeshed_PointData {
    GENERATED_BODY()
 
    UPROPERTY(BlueprintReadWrite, Category="YasiuSpline")
    FVector3f location = FVector3f();
 
    UPROPERTY(BlueprintReadWrite, Category="YasiuSpline")
    FSplineMeshed_PointTangent Tangent;
};
 

USTRUCT(BlueprintType, Category="YasiuSpline")
struct FVectorRange {
    GENERATED_BODY()
 
    FVectorRange() {}

    FVectorRange( float value )
        : Min(FVector(value, value, value)), Max(FVector(value, value, value)) {};

    FVectorRange( float valMin, float valMax )
        : Min(FVector(valMin, valMin, valMin)), Max(FVector(valMax, valMax, valMax)) {};

    FVectorRange( float amplitudeA, float amplitudeB, float amplitudeC )
        : Min(FVector(-amplitudeA, -amplitudeB, -amplitudeC)), Max(FVector(amplitudeA, amplitudeB, amplitudeC)) {};

    bool operator!=( const double& Number ) const
    {
        if ( Min.X != Number || Min.Y != Number || Min.Z != Number ) {
            return true;
        }
        if ( Max.X != Number || Max.Y != Number || Max.Z != Number ) {
            return true;
        }
        return false;
    }
 
    bool operator==( const double& Number ) const
    {
        if ( (Min.X == Number && Min.Y == Number && Min.Z == Number) && (Max.X == Number && Max.Y == Number && Max.Z ==
            Number) ) {
            return true;
        }
        return false;
    }

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    FVector Min{-1, -1, -1};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    FVector Max{1, 1, 1};
};
 

USTRUCT(BlueprintType, Category="YasiuSpline")
struct FSplineRandomness {
    GENERATED_BODY()
 
    
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    int seed{5};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    FVectorRange Translation{0};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    FVectorRange Rotation{0};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    FVectorRange Scale{1};
};
 

USTRUCT(BlueprintType, Category="YasiuSpline")
struct FSplineMeshedCollision {
    GENERATED_BODY()
 
    
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="Collision")
    TEnumAsByte<ECollisionEnabled::Type> CollisionEnabled = ECollisionEnabled::Type::QueryAndPhysics;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="Collision")
    TEnumAsByte<ECollisionChannel> CollisionType = ECC_WorldDynamic;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="Collision")
    TEnumAsByte<ECollisionResponse> CollisionResponse = ECR_Overlap;
};
 

USTRUCT(BlueprintType, Category="YasiuSpline", meta=(DisplayName="Mesh spawn parameters"))
struct FSplineMeshedSpawnParams {
    GENERATED_BODY()
 
    FSplineMeshedSpawnParams() {};

    FSplineMeshedSpawnParams(
        const float& spacing,
        const bool& deformMesh,
        const ESplineMeshAxis::Type& forwardAxis,
        const ESplineRotateMode& RotateMethod
    )
        : RotationMethod(RotateMethod), ForwardAxis(forwardAxis), MeshSpacing(spacing), DeformMesh(deformMesh) {} ;
 
    FSplineMeshedSpawnParams(
        const FTransform& MeshTransf,
        const float& MeshSpacing,
        const bool& DeformMesh,
        ESplineMeshStretching FitMethod,
        ESplineRotateMode RotateMethod,
        ESplineMeshAxis::Type ForwardAxis
    )
        : StretchMethod(FitMethod), RotationMethod(RotateMethod), ForwardAxis(ForwardAxis), MeshSpacing(MeshSpacing),
          DeformMesh(DeformMesh), MeshTransform(MeshTransf) {};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="Shape")
    ESplineMeshStretching StretchMethod = ESplineMeshStretching::NoStretching;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="Orientation")
    ESplineRotateMode RotationMethod = ESplineRotateMode::DefaultFixed;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    TEnumAsByte<ESplineMeshAxis::Type> ForwardAxis = ESplineMeshAxis::X;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="Spacing")
    float MeshSpacing = 50;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="Spacing")
    bool AddMeshSizeToSpacing = true;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="Shape")
    bool DeformMesh = true;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="Shape")
    bool FixInvalidTangents = true;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="Shape")
    bool FixSharpDeformations = false;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="Orientation")
    FVector UpVector{0, 0, 1};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="Shape")
    FTransform MeshTransform{};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="Randomness")
    FSplineRandomness MeshRandomness{};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="Collision")
    FSplineMeshedCollision CollisionPreset{};
};
 

USTRUCT(BlueprintType, Category="YasiuSpline")
struct FSplineSmoothParams {
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Spline")
    int pointIndex = 0;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Spline")
    float smoothness = 1;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Spline")
    float rotationZ = 0;
};
 

USTRUCT(BlueprintType, Category="YasiuSpline")
struct FSplineDebugParams {
    GENERATED_BODY()
 
    static FSplineDebugParams Off()
    {
        auto params = FSplineDebugParams();
        params.ShowDebug = false;
        return params;
    }
 
    static FSplineDebugParams On()
    {
        auto params = FSplineDebugParams();
        params.ShowDebug = true;
        return params;
    }

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest")
    bool ShowDebug = false;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest")
    float DisplayTime = 3;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest")
    bool ShowEveryOverlap = true;

    float DebugSphereRadius = 1;

    FVector DebugBoxSize{1, 1, 1};
};
 

USTRUCT(BlueprintType, Blueprintable, Category="YasiuSpline")
struct FSplineDetectionTestParams {
    GENERATED_BODY()
 
    
    FCollisionQueryParams GetQueryParams() const;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest")
    TSoftObjectPtr<UStaticMesh> TestMesh{};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest")
    FTransform MeshTransform{};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest")
    TArray<TEnumAsByte<ECollisionChannel>> ObjectTypes{ECollisionChannel::ECC_WorldStatic};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest")
    float StepDistance = 50;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest")
    ESplineRotateMode RotationMethod{};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest")
    bool CenterMesh{true};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest")
    bool SelfIgnore{true};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest")
    FVector UpVector{0, 0, 1};
 
    // UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest")
    // TEnumAsByte<ECollisionResponse> TestResponse{ECR_Overlap};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest")
    bool StopAtFirstCollision = true;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest")
    bool UseSphere = false;

    // UPROPERTY(BlueprintReadWrite, Category="CollisionTest")
    UPROPERTY(BlueprintReadOnly, Category="FunctionInternal")
    FVector ShapeSize{1, 1, 1};
 
    // /// False means testing Overlap and Block response, while true will ignore overlap
    // UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest")
    // bool TestOnlyBlocking = false;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest")
    bool FirstOverlapWithingSplineLimits = true;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest")
    bool LastOverlapWithingSplineLimits = true;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest|QueryParams")
    bool TraceComplex{false};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest|QueryParams")
    bool FindInitialOverlaps{false};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest|QueryParams")
    bool IgnoreBlocks{false};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest|QueryParams")
    bool IgnoreTouches{false};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest|QueryParams")
    bool SkipNarrowPhase{false};
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest|QueryParams")
    TArray<AActor*> IgnoredActors;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="CollisionTest|Debug")
    FSplineDebugParams DebugParams{};

    UPROPERTY(BlueprintReadOnly, Category="YasiuSpline")
    FVector LocationOffset{};
};
 

USTRUCT(BlueprintType, Category="YasiuSpline")
struct FSplineMeshedOverlapResult {
    GENERATED_BODY()
 
    FSplineMeshedOverlapResult() {}
 
    FSplineMeshedOverlapResult( AActor* act )
    {
        Actor = act;
    }
 
    FSplineMeshedOverlapResult( const FOverlapResult& result )
    {
        Actor = result.GetActor();
        IsBlocking = result.bBlockingHit;
        Component = result.GetComponent();
    }

    UPROPERTY(BlueprintReadWrite, Category="YasiuSpline")
    AActor* Actor{nullptr};

    UPROPERTY(BlueprintReadWrite, Category="YasiuSpline")
    UPrimitiveComponent* Component{nullptr};

    UPROPERTY(BlueprintReadWrite, Category="YasiuSpline")
    bool IsBlocking{false};
};
 

USTRUCT(Blueprintable, BlueprintType, Category="YasiuSpline")
struct FYasiuSplineMeshParams {
    GENERATED_BODY()
 
    
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    FVector StartPos{};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    FVector EndPos{};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    FVector StartTangent{};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    FVector EndTangent{};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    FVector2D StartScale{1, 1};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    FVector2D EndScale{1, 1};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    float StartRoll{0};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    float EndRoll{0};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    FVector2D StartOffset{0};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    FVector2D EndOffset{0};
 
    /* Additional variables */

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    FTransform RelativeTransform = {};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    FVector UpVector{0, 0, 1};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    float SplineDistanceStart{};

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    float SplineDistanceEnd{};
};
 

UCLASS(BlueprintType, Blueprintable, Category="YasiuSpline", meta = ( BlueprintSpawnableComponent ))
class YASIUSPLINEMESHED_API USplineMeshedComponent : public USplineComponent {
    GENERATED_BODY()
 
public:
    USplineMeshedComponent( const FObjectInitializer& Initializer )
        : Super(Initializer)
    {
        auto col = FLinearColor(0.01, 0.1, 0.35);
        SetUnselectedSplineSegmentColor(col);
    };
 
 
    virtual void BeginPlay() override;
 
    virtual void DestroyComponent( bool bPromoteChildren = false ) override;
 
    virtual void OnComponentDestroyed( bool bDestroyingHierarchy ) override;
 
    virtual void EndPlay( const EEndPlayReason::Type reason ) override;
 
    virtual void UninitializeComponent() override;
 
#if WITH_EDITOR
    virtual void PostEditChangeProperty( struct FPropertyChangedEvent& PropertyChangedEvent ) override;
 
    /* Override for spline point move */
    virtual void PostEditComponentMove( bool bFinished ) override;
 
    // virtual void OnUnregister() override;
 
    // virtual void OnCreatePhysicsState() override;
 
    // virtual void OnDestroyPhysicsState() override;
 
    virtual void PreEditUndo() override;
 
    virtual void PostEditUndo() override;
 
#endif
 
public:
    UFUNCTION(BlueprintCallable, BlueprintNativeEvent, Category="YasiuSpline")
    void PlaceMeshesAlongSpline( UStaticMesh* Mesh, const FSplineMeshedSpawnParams SpawnParameters );

    virtual void PlaceMeshesAlongSpline_Implementation( UStaticMesh* Mesh, const FSplineMeshedSpawnParams SpawnParameters );

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    static void ApplyParamsToMesh( const FYasiuSplineMeshParams& params, USplineMeshComponent* Mesh );

    UFUNCTION(BlueprintCallable, Category="YasiuSpline", BlueprintPure=false)
    void GetMeshPositonsArray(
        TArray<FYasiuSplineMeshParams>& OutArray,
        const UStaticMesh* Mesh,
        const FSplineMeshedSpawnParams& paramsIn
    ) const;

    UFUNCTION(BlueprintNativeEvent, Category="YasiuSpline")
    void OnMeshSpawn(
        const FVector& ForwardVec,
        const FVector& UpVect,
        const int SegmentID,
        const float DistanceA,
        const float DistanceB,
        // const double splineKey,
        USplineMeshComponent* RefMesh
    );

    virtual void OnMeshSpawn_Implementation(
        const FVector& ForwardVec,
        // asd
        const FVector& UpVect,
        const int SegmentID,
        const float DistanceA,
        const float DistanceB,
        USplineMeshComponent* RefMesh
    );
 

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    int Num() const { return MeshesArray.Num(); }
 
/* Functions Modifiers */

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    void ChangeMesh( TSoftObjectPtr<UStaticMesh> Mesh );

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    void GetMeshes( TArray<class USplineMeshComponent*>& OutArray ) const;

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    virtual void SetMaterialsByIndex( const TArray<UMaterialInterface*>& materials );

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    virtual void CopySplinePoints( const USplineMeshedComponent* copyFrom );

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    virtual void CopySplineAndMeshes( const USplineMeshedComponent* copyFrom );

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    static void CopyMeshMaterials( const UMeshComponent* copyFrom, UMeshComponent* copyTo );

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="YasiuSpline", SkipSerialization)
    FSplineSinusParams SinusToolParams{};

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="YasiuSpline", SkipSerialization)
    FSplineHelixParams HelixToolParams{};

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="YasiuSpline", SkipSerialization)
    FSplineSmoothParams TangentToolParams{};

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    void MakeHelix( const FSplineHelixParams& HelixParams );

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    void MakeSinus( const FSplineSinusParams& SinusParams );

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    ASplineMeshActor* SpawnMeshStaticClone( const USplineMeshComponent* Mesh );

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    TArray<ASplineMeshActor*> CloneSplineToStaticActors();
 
#if WITH_EDITOR
    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    void ChangeToSinus();

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    void ChangeToHelix();

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    void Decimate();

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    void FixMeshes();

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    void ClearMeshes();
#endif

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    void SetSmoothnessAtPoint( int keyIndex, float smoothness = 1.f, float ZRotationDeg = 0.f );

    UFUNCTION(BlueprintCallable, Category="SplineTools")
    void SetSmoothnessAtAllPoints( float smoothness = 1.f, float ZRotationDeg = 0.f );

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    void OffsetAllPoints( const FVector& RelativeOffset );

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    void Sharp() { SetSmoothnessAtAllPoints(0, 0); }

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    void Soft() { SetSmoothnessAtAllPoints(0.5, 0); }

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    void Smooth();

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    void ExtraCurvy() { SetSmoothnessAtAllPoints(2, 0); }

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    void CustomTangents()
    {
        SetSmoothnessAtPoint(TangentToolParams.pointIndex, TangentToolParams.smoothness, TangentToolParams.rotationZ);
    }

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    void CustomTangentsAllPoints() { SetSmoothnessAtAllPoints(TangentToolParams.smoothness, TangentToolParams.rotationZ); }
 

    UFUNCTION(BlueprintCallable, Category="YasiuSpline", BlueprintPure=false)
    bool DetectObjectsAlongSpline(
        TArray<FSplineMeshedOverlapResult>& DetectResults,
        FSplineDetectionTestParams DetectionParams
        // FSplineDebugParams debugParams
    ) const;
 
protected:
    void UpdateWithParent( bool ForceUpdate = false );
 
private:
    bool DetectObjectsHelper(
        TArray<FSplineMeshedOverlapResult>& OutOverlaps,
        FVector& locationIn,
        FQuat& rotationIn,
        const FSplineDetectionTestParams& paramsIn
    ) const;
 
public:
    UFUNCTION(BlueprintNativeEvent, Category="YasiuSpline")
    void DetectionFunction(
        TArray<FSplineMeshedOverlapResult>& DetectedObjects,
        UWorld* World,
        const FVector& LocationIn,
        const FQuat& RotationIn,
        const FSplineDetectionTestParams& ParamsIn
    ) const;

    virtual void DetectionFunction_Implementation(
        TArray<FSplineMeshedOverlapResult>& DetectedObjects,
        UWorld* World,
        const FVector& LocationIn,
        const FQuat& RotationIn,
        const FSplineDetectionTestParams& ParamsIn
    ) const;

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    FVector GetSideOffset( const FVector& Fwd, const FVector& Up, float DistanceRight, float AngleDeg ) const;

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    FVector VectorFrom2Points(
        float distanceA,
        float distanceB,
        const TEnumAsByte<ESplineCoordinateSpace::Type>& CoordSpace = ESplineCoordinateSpace::World
    ) const;

    bool WasUpdated = true;

    UFUNCTION(BlueprintCallable, Category="YasiuSpline")
    FVector CalculateSplineUpVector(
        ESplineRotateMode Mode,
        const FVector& CurrentUp,
        const FVector& CurrentForward,
        const FVector& PrevUp,
        const FVector& UpParameter
    ) const;
 
protected:
    UPROPERTY(BlueprintReadOnly, Category="YasiuSpline")
    TArray<TObjectPtr<USplineMeshComponent>> MeshesArray;

    virtual void MeshArrayReserve( const int& amount );

    static FVector FindClosestUpVector( const FVector& previousUp, const FVector& currentForward );

    static FVector MatchVectors( const FVector& axis, FVector properOrientedVector, FVector splineVector );
};
 

USTRUCT(BlueprintType, Blueprintable, Category="YasiuSpline")
struct FSplineMeshed_ExtendedParams {
    GENERATED_BODY()
 
    
    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(Category="SplineExtended"))
    float PeriodDistance = 1000;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(Category="SplineExtended"))
    float Amplitude = 300;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(Category="SplineExtended"))
    float PhaseOffset = 0;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(Category="SplineExtended"))
    bool UseAlternate = false;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(Category="SplineExtended"))
    bool RotateToShape = false;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, meta=(Category="SplineExtended"))
    bool UniformSize = true;
};
 

UCLASS(BlueprintType, Blueprintable, Category="YasiuSpline", meta = ( BlueprintSpawnableComponent ))
class YASIUSPLINEMESHED_API USplineMeshedComponent_Extension : public USplineMeshedComponent {
    GENERATED_BODY()
 
public:
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="YasiuSpline")
    FSplineMeshed_ExtendedParams ExtendedSpline;
};
 

UCLASS(BlueprintType, Blueprintable, Category="YasiuSpline", meta = ( BlueprintSpawnableComponent ))
class USplineMeshedComponent_ExtendedToSinus : public USplineMeshedComponent_Extension {
    GENERATED_BODY()
 
public:
    virtual void OnMeshSpawn_Implementation(
        const FVector& forwardVec,
        const FVector& upVect,
        const int segmentID,
        const float distanceA,
        const float distanceB,
        USplineMeshComponent* refMesh
    ) override;
};
 

UCLASS(BlueprintType, Blueprintable, Category="YasiuSpline", meta = ( BlueprintSpawnableComponent ))
class USplineMeshedComponent_ExtendedToHelix : public USplineMeshedComponent_Extension {
    GENERATED_BODY()
 
public:
    virtual void OnMeshSpawn_Implementation(
        const FVector& forwardVec,
        const FVector& upVect,
        const int segmentID,
        const float distanceA,
        const float distanceB,
        USplineMeshComponent* refMesh
    ) override;
};