SplineComponent.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 "Components/PrimitiveComponent.h"
#include "Math/InterpCurve.h"
#include "BoxTypes.h"
 
PRAGMA_DISABLE_EXPERIMENTAL_WARNINGS
#include "Curves/Spline.h"
PRAGMA_ENABLE_EXPERIMENTAL_WARNINGS
 
#include "SplineComponent.generated.h"
 
PRAGMA_DISABLE_EXPERIMENTAL_WARNINGS
 
class FPrimitiveSceneProxy;
class FPrimitiveDrawInterface;
class FSceneView;
 
UENUM(BlueprintType)
namespace ESplinePointType
{
    enum Type : int
    {
        Linear,
        Curve,
        Constant,
        CurveClamped,
        CurveCustomTangent
    };
}
 
UENUM()
namespace ESplineCoordinateSpace
{
    enum Type : int
    {
        Local,
        World
    };
}
 
UENUM()
enum class ELastAuthority : uint8
{
    Unset,
    Spline,
    SplineCurves
};
 
UCLASS(Abstract, MinimalAPI)
class USplineMetadata : public UObject
{
    GENERATED_UCLASS_BODY()
 
public:
    virtual void InsertPoint(int32 Index, float t, bool bClosedLoop) PURE_VIRTUAL(USplineMetadata::InsertPoint, );
    virtual void UpdatePoint(int32 Index, float t, bool bClosedLoop) PURE_VIRTUAL(USplineMetadata::UpdatePoint, );
    virtual void AddPoint(float InputKey) PURE_VIRTUAL(USplineMetadata::AddPoint, );
    virtual void RemovePoint(int32 Index) PURE_VIRTUAL(USplineMetadata::RemovePoint, );
    virtual void DuplicatePoint(int32 Index) PURE_VIRTUAL(USplineMetadata::DuplicatePoint, );
    virtual void CopyPoint(const USplineMetadata* FromSplineMetadata, int32 FromIndex, int32 ToIndex) PURE_VIRTUAL(USplineMetadata::CopyPoint, );
    virtual void Reset(int32 NumPoints) PURE_VIRTUAL(USplineMetadata::Reset, );
    virtual void Fixup(int32 NumPoints, USplineComponent* SplineComp) PURE_VIRTUAL(USplineMetadata::Fixup, );
};
 
USTRUCT()
struct FSplineCurves
{
    GENERATED_BODY()
 
    static FSplineCurves FromSplineInterface(const FSpline& InProxy)
    {
        FSplineCurves NewCurve;
        NewCurve.Position = InProxy.GetSplinePointsPosition();
        NewCurve.Rotation = InProxy.GetSplinePointsRotation();
        NewCurve.Scale = InProxy.GetSplinePointsScale();
        NewCurve.UpdateSpline(NewCurve.Position.bIsLooped, false);
        return NewCurve;
    }
    
    UPROPERTY()
    FInterpCurveVector Position;
 
    UPROPERTY()
    FInterpCurveQuat Rotation;
 
    UPROPERTY()
    FInterpCurveVector Scale;
 
    UPROPERTY()
    FInterpCurveFloat ReparamTable;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TObjectPtr<USplineMetadata> Metadata_DEPRECATED = nullptr;
#endif
 
    UPROPERTY(transient)
    uint32 Version = 0xffffffff;
 
    bool operator==(const FSplineCurves& Other) const
    {
        return Position == Other.Position && Rotation == Other.Rotation && Scale == Other.Scale;
    }
 
    bool operator!=(const FSplineCurves& Other) const
    {
        return !(*this == Other);
    }
 
    ENGINE_API void UpdateSpline(bool bClosedLoop = false, bool bStationaryEndpoints = false, int32 ReparamStepsPerSegment = 10, bool bLoopPositionOverride = false, float LoopPosition = 0.0f, const FVector& Scale3D = FVector(1.0f));
 
    ENGINE_API float GetSegmentLength(const int32 Index, const float Param, bool bClosedLoop = false, const FVector& Scale3D = FVector(1.0f)) const;
 
    ENGINE_API float GetSplineLength() const;
};
 
struct FSplinePositionLinearApproximation
{
    FSplinePositionLinearApproximation(const FVector& InPosition, float InSplineParam)
        : Position(InPosition)
        , SplineParam(InSplineParam)
    {}
 
    static ENGINE_API void Build(const FSplineCurves& InCurves, TArray<FSplinePositionLinearApproximation>& OutPoints, float InDensity = 0.5f);
 
    FVector Position;
 
    float SplineParam;
};
 
USTRUCT(BlueprintType)
struct FSplinePoint
{
    GENERATED_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SplinePoint)
    float InputKey;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SplinePoint)
    FVector Position;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SplinePoint)
    FVector ArriveTangent;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SplinePoint)
    FVector LeaveTangent;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SplinePoint)
    FRotator Rotation;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SplinePoint)
    FVector Scale;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SplinePoint)
    TEnumAsByte<ESplinePointType::Type> Type;
 
    FSplinePoint()
        : InputKey(0.0f), Position(0.0f), ArriveTangent(0.0f), LeaveTangent(0.0f), Rotation(0.0f), Scale(1.0f), Type(ESplinePointType::Curve)
    {}
 
    FSplinePoint(float InInputKey, const FVector& InPosition)
        : InputKey(InInputKey), Position(InPosition), ArriveTangent(0.0f), LeaveTangent(0.0f), Rotation(0.0f), Scale(1.0f), Type(ESplinePointType::Curve)
    {}
 
    FSplinePoint(float InInputKey, const FVector& InPosition, ESplinePointType::Type InType, const FRotator& InRotation = FRotator(0.0f), const FVector& InScale = FVector(1.0f))
        : InputKey(InInputKey), Position(InPosition), ArriveTangent(0.0f), LeaveTangent(0.0f), Rotation(InRotation), Scale(InScale), Type(InType)
    {}
 
    FSplinePoint(float InInputKey,
                 const FVector& InPosition,
                 const FVector& InArriveTangent,
                 const FVector& InLeaveTangent,
                 const FRotator& InRotation = FRotator(0.0f),
                 const FVector& InScale = FVector(1.0f),
                 ESplinePointType::Type InType = ESplinePointType::CurveCustomTangent)
        : InputKey(InInputKey), Position(InPosition), ArriveTangent(InArriveTangent), LeaveTangent(InLeaveTangent), Rotation(InRotation), Scale(InScale), Type(InType)
    {}
};
 
UCLASS(ClassGroup=Utility, ShowCategories = (Mobility), HideCategories = (Physics, Collision, Lighting, Rendering, Mobile), meta=(BlueprintSpawnableComponent), MinimalAPI)
class USplineComponent : public UPrimitiveComponent
{
    GENERATED_UCLASS_BODY()
 
protected:
 
    UPROPERTY(EditAnywhere, Category=Points)
    FSpline Spline;
    
public:
 
    UFUNCTION(CallInEditor, Category="Spline")
    void PopulateFromLegacy();
 
    ENGINE_API static FName GetSplinePropertyName();
 
    ENGINE_API static TSet<FName> GetSplinePropertyNames();
    
    UPROPERTY(EditAnywhere, Replicated, Category=Points)
    FSplineCurves SplineCurves;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FInterpCurveVector SplineInfo_DEPRECATED;
 
    UPROPERTY()
    FInterpCurveQuat SplineRotInfo_DEPRECATED;
 
    UPROPERTY()
    FInterpCurveVector SplineScaleInfo_DEPRECATED;
 
    UPROPERTY()
    FInterpCurveFloat SplineReparamTable_DEPRECATED;
 
    UPROPERTY()
    bool bAllowSplineEditingPerInstance_DEPRECATED;
#endif
 
    UPROPERTY(EditAnywhere, Replicated, AdvancedDisplay, Category = Spline, meta=(ClampMin=4, UIMin=4, ClampMax=100, UIMax=100))
    int32 ReparamStepsPerSegment;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Spline)
    float Duration;
 
    UPROPERTY(EditAnywhere, Replicated, BlueprintReadWrite, AdvancedDisplay, Category = Spline, meta=(EditCondition="!bClosedLoop"))
    bool bStationaryEndpoints;
 
    UPROPERTY(EditAnywhere, Replicated, Category = Spline, meta=(DisplayName="Override Construction Script"))
    bool bSplineHasBeenEdited;
 
    UPROPERTY()
    bool bModifiedByConstructionScript;
 
    UPROPERTY(EditAnywhere, Replicated, BlueprintReadWrite, Category = Spline)
    bool bInputSplinePointsToConstructionScript;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Spline)
    bool bDrawDebug;
 
private:
    UPROPERTY(EditAnywhere, Replicated, Category = Spline)
    bool bClosedLoop;
 
    UPROPERTY(EditAnywhere, Replicated, Category = Spline, meta=(InlineEditConditionToggle=true))
    bool bLoopPositionOverride;
 
    UPROPERTY(EditAnywhere, Replicated, Category = Spline, meta=(EditCondition="bLoopPositionOverride"))
    float LoopPosition;
 
private:
    
    UPROPERTY(Transient)
    TSoftObjectPtr<UMaterialInterface> LineMaterial = nullptr;
 
    UPROPERTY(Transient)
    TSoftObjectPtr<UMaterialInterface> PointMaterial = nullptr;
 
    UPROPERTY(Transient)
    TObjectPtr<UMaterialInterface> LineMaterialLifetimePtr = nullptr;
 
    UPROPERTY(Transient)
    TObjectPtr<UMaterialInterface> PointMaterialLifetimePtr = nullptr;
 
    int32 LineMaterialLoadID = INDEX_NONE;
    int32 PointMaterialLoadID = INDEX_NONE;
    
public:
    UPROPERTY(EditAnywhere, Replicated, BlueprintReadWrite, Category = Spline, meta=(Spatial))
    FVector DefaultUpVector;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, Category = Editor, meta = (DisplayName="Editor Spline Unselected Color"))
    FLinearColor EditorUnselectedSplineSegmentColor;
 
    UPROPERTY(EditAnywhere, Category = Editor, meta = (DisplayName="Editor Spline Selected Color"))
    FLinearColor EditorSelectedSplineSegmentColor;
 
    UPROPERTY(EditAnywhere, Category = Editor, meta = (DisplayName="Editor Spline Tangent Color"))
    FLinearColor EditorTangentColor;
 
    UPROPERTY(EditAnywhere, Category = Editor)
    bool bAllowDiscontinuousSpline;
 
    UPROPERTY(EditAnywhere, Category = Editor)
    bool bAdjustTangentsOnSnap;
 
    UPROPERTY(EditAnywhere, Category = Editor, meta=(InlineEditConditionToggle=true))
    bool bShouldVisualizeScale;
 
    UPROPERTY(EditAnywhere, Category = Editor, meta=(EditCondition="bShouldVisualizeScale"))
    float ScaleVisualizationWidth;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(DeselectedInEditorDelegate, TObjectPtr<USplineComponent>)
    DeselectedInEditorDelegate OnDeselectedInEditor;
#endif
 
    //~ Begin UObject Interface
    ENGINE_API virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    ENGINE_API virtual void PostLoad() override;
    ENGINE_API virtual void OnRegister() override;
    ENGINE_API virtual bool GetIgnoreBoundsForEditorFocus() const override;
#if WITH_EDITOR
    ENGINE_API virtual void PostEditChangeChainProperty(FPropertyChangedChainEvent& PropertyChangedEvent) override;
    ENGINE_API virtual void PostTransacted(const FTransactionObjectEvent& TransactionEvent) override;
#endif
    //~ End UObject Interface
 
    //~ Begin UActorComponent Interface.
    ENGINE_API virtual TStructOnScope<FActorComponentInstanceData> GetComponentInstanceData() const override;
    //~ End UActorComponent Interface.
 
#if UE_ENABLE_DEBUG_DRAWING
    //~ Begin UPrimitiveComponent Interface.
    ENGINE_API virtual void GetUsedMaterials(TArray<UMaterialInterface*>& OutMaterials, bool bGetDebugMaterials = false) const override;
    ENGINE_API virtual FPrimitiveSceneProxy* CreateSceneProxy() override;
#endif
    
#if WITH_EDITOR
    ENGINE_API virtual void PushSelectionToProxy() override;
#endif
    //~ End UPrimitiveComponent Interface.
 
    //~ Begin USceneComponent Interface
    ENGINE_API virtual FBoxSphereBounds CalcBounds(const FTransform& LocalToWorld) const override;
    //~ End USceneComponent Interface
#if UE_ENABLE_DEBUG_DRAWING
    static ENGINE_API void Draw(FPrimitiveDrawInterface* PDI, const FSceneView* View, const FInterpCurveVector& SplineInfo, const FMatrix& LocalToWorld, const FLinearColor& LineColor, uint8 DepthPriorityGroup);
#endif
 
    // Safe for caching spline data in the legacy format. Will auto convert data if necessary.
    ENGINE_API FSplineCurves GetSplineCurves() const;
    ENGINE_API FSpline GetSpline() const;
    ENGINE_API void SetSpline(const FSpline& InSpline);
    ENGINE_API void SetSpline(const FSplineCurves& InSplineCurves);
 
    UE_EXPERIMENTAL(5.7, "Spline change notifications are experimental while the API is under active development.")
    FSimpleMulticastDelegate& GetOnSplineChanged() { return OnSplineChanged; }
 
    UE_EXPERIMENTAL(5.7, "Spline update notifications are experimental while the API is under active development.")
    FSimpleMulticastDelegate& GetOnSplineUpdated() { return OnSplineUpdated; }
 
    UE_EXPERIMENTAL(5.7, "Spline display setting change notifications are experimental while the API is under active development.")
    FSimpleMulticastDelegate& GetOnSplineDisplayChanged() { return OnSplineDisplayChanged; }
    
    void SynchronizeSplines() { SetSpline(WarninglessSplineCurves()); }
 
    ENGINE_API int32 GetVersion() const;
    ENGINE_API const FInterpCurveVector& GetSplinePointsPosition() const;
    ENGINE_API const FInterpCurveQuat& GetSplinePointsRotation() const;
    ENGINE_API const FInterpCurveVector& GetSplinePointsScale() const;
 
    virtual USplineMetadata* GetSplinePointsMetadata() { return nullptr; }
    virtual const USplineMetadata* GetSplinePointsMetadata() const { return nullptr; }
 
    ENGINE_API virtual TArray<ESplinePointType::Type> GetEnabledSplinePointTypes() const;
 
    virtual bool AllowsSpinePointLocationEditing() const { return true; }
    virtual bool AllowsSplinePointRotationEditing() const { return true; }
    virtual bool AllowsSplinePointScaleEditing() const { return true; }
    virtual bool AllowsSplinePointArriveTangentEditing() const { return true; }
    virtual bool AllowsSplinePointLeaveTangentEditing() const { return true; }
 
    ENGINE_API void ApplyComponentInstanceData(struct FSplineInstanceData* ComponentInstanceData, const bool bPostUCS);
    ENGINE_API void ApplyComponentInstanceData(struct FSplineComponentInstanceData* ComponentInstanceData, const bool bPostUCS);
    
    ENGINE_API void ResetToDefault();
    ENGINE_API bool CanResetToDefault() const;
    ENGINE_API static FSpline GetDefaultSpline();
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API virtual void UpdateSpline();
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API virtual void SetOverrideConstructionScript(bool InOverride);
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector GetLocationAtSplineInputKey(float InKey, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector GetTangentAtSplineInputKey(float InKey, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector GetDirectionAtSplineInputKey(float InKey, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FRotator GetRotationAtSplineInputKey(float InKey, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    ENGINE_API FQuat GetQuaternionAtSplineInputKey(float InKey, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector GetUpVectorAtSplineInputKey(float InKey, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector GetRightVectorAtSplineInputKey(float InKey, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FTransform GetTransformAtSplineInputKey(float InKey, ESplineCoordinateSpace::Type CoordinateSpace, bool bUseScale = false) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API float GetRollAtSplineInputKey(float InKey, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector GetScaleAtSplineInputKey(float InKey) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API float GetDistanceAlongSplineAtSplineInputKey(float InKey) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API float GetDistanceAlongSplineAtLocation(const FVector& InLocation, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Editor)
    ENGINE_API void SetUnselectedSplineSegmentColor(const FLinearColor& SegmentColor);
 
    UFUNCTION(BlueprintCallable, Category = Editor)
    ENGINE_API void SetSelectedSplineSegmentColor(const FLinearColor& SegmentColor);
 
    UFUNCTION(BlueprintCallable, Category = Editor)
    ENGINE_API void SetTangentColor(const FLinearColor& TangentColor);
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API void SetDrawDebug(bool bShow);
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API void SetClosedLoop(bool bInClosedLoop, bool bUpdateSpline = true);
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API void SetClosedLoopAtPosition(bool bInClosedLoop, float Key, bool bUpdateSpline = true);
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API bool IsClosedLoop() const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API void ClearSplinePoints(bool bUpdateSpline = true);
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API void AddPoint(const FSplinePoint& Point, bool bUpdateSpline = true);
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API void AddPoints(const TArray<FSplinePoint>& Points, bool bUpdateSpline = true);
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API void AddSplinePoint(const FVector& Position, ESplineCoordinateSpace::Type CoordinateSpace, bool bUpdateSpline = true);
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API void AddSplinePointAtIndex(const FVector& Position, int32 Index, ESplineCoordinateSpace::Type CoordinateSpace, bool bUpdateSpline = true);
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API void RemoveSplinePoint(int32 Index, bool bUpdateSpline = true);
 
    UFUNCTION(BlueprintCallable, Category = Spline, meta = (DeprecatedFunction, DeprecationMessage = "Please use AddSplinePoint, specifying SplineCoordinateSpace::World"))
    void AddSplineWorldPoint(const FVector& Position);
 
    UFUNCTION(BlueprintCallable, Category = Spline, meta = (DeprecatedFunction, DeprecationMessage = "Please use AddSplinePoint, specifying SplineCoordinateSpace::Local"))
    void AddSplineLocalPoint(const FVector& Position);
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API void SetSplinePoints(const TArray<FVector>& Points, ESplineCoordinateSpace::Type CoordinateSpace, bool bUpdateSpline = true);
 
    UFUNCTION(BlueprintCallable, Category = Spline, meta = (DeprecatedFunction, DeprecationMessage = "Please use SetSplinePoints, specifying SplineCoordinateSpace::World"))
    void SetSplineWorldPoints(const TArray<FVector>& Points);
 
    UFUNCTION(BlueprintCallable, Category = Spline, meta = (DeprecatedFunction, DeprecationMessage = "Please use SetSplinePoints, specifying SplineCoordinateSpace::Local"))
    void SetSplineLocalPoints(const TArray<FVector>& Points);
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API void SetLocationAtSplinePoint(int32 PointIndex, const FVector& InLocation, ESplineCoordinateSpace::Type CoordinateSpace, bool bUpdateSpline = true);
 
    UFUNCTION(BlueprintCallable, Category = Spline, meta = (DeprecatedFunction, DeprecationMessage = "Please use SetLocationAtSplinePoint, specifying SplineCoordinateSpace::World"))
    void SetWorldLocationAtSplinePoint(int32 PointIndex, const FVector& InLocation);
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API void SetTangentAtSplinePoint(int32 PointIndex, const FVector& InTangent, ESplineCoordinateSpace::Type CoordinateSpace, bool bUpdateSpline = true);
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API void SetTangentsAtSplinePoint(int32 PointIndex, const FVector& InArriveTangent, const FVector& InLeaveTangent, ESplineCoordinateSpace::Type CoordinateSpace, bool bUpdateSpline = true);
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API void SetUpVectorAtSplinePoint(int32 PointIndex, const FVector& InUpVector, ESplineCoordinateSpace::Type CoordinateSpace, bool bUpdateSpline = true);
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API void SetRotationAtSplinePoint(int32 PointIndex, const FRotator& InRotation, ESplineCoordinateSpace::Type CoordinateSpace, bool bUpdateSpline = true);
    ENGINE_API void SetQuaternionAtSplinePoint(int32 PointIndex, const FQuat& InQuaternion, ESplineCoordinateSpace::Type CoordinateSpace, bool bUpdateSpline = true);
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API void SetScaleAtSplinePoint(int32 PointIndex, const FVector& InScaleVector, bool bUpdateSpline = true); 
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API ESplinePointType::Type GetSplinePointType(int32 PointIndex) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API void SetSplinePointType(int32 PointIndex, ESplinePointType::Type Type, bool bUpdateSpline = true);
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API int32 GetNumberOfSplinePoints() const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API int32 GetNumberOfSplineSegments() const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API float GetInputKeyValueAtSplinePoint(int32 PointIndex) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FSplinePoint GetSplinePointAt(int32 PointIndex, ESplineCoordinateSpace::Type CoordinateSpace) const;
        
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector GetLocationAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline, meta = (DeprecatedFunction, DeprecationMessage = "Please use GetLocationAtSplinePoint, specifying SplineCoordinateSpace::World"))
    FVector GetWorldLocationAtSplinePoint(int32 PointIndex) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector GetDirectionAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector GetTangentAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector GetArriveTangentAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector GetLeaveTangentAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    ENGINE_API FQuat GetQuaternionAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FRotator GetRotationAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector GetUpVectorAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector GetRightVectorAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API float GetRollAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector GetScaleAtSplinePoint(int32 PointIndex) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FTransform GetTransformAtSplinePoint(int32 PointIndex, ESplineCoordinateSpace::Type CoordinateSpace, bool bUseScale = false) const;
 
    UFUNCTION(BlueprintCallable, Category=Spline)
    ENGINE_API void GetLocationAndTangentAtSplinePoint(int32 PointIndex, FVector& Location, FVector& Tangent, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline, meta = (DeprecatedFunction, DeprecationMessage = "Please use GetLocationAndTangentAtSplinePoint, specifying SplineCoordinateSpace::Local"))
    void GetLocalLocationAndTangentAtSplinePoint(int32 PointIndex, FVector& LocalLocation, FVector& LocalTangent) const;
 
    UFUNCTION(BlueprintCallable, Category=Spline)
    ENGINE_API float GetDistanceAlongSplineAtSplinePoint(int32 PointIndex) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API float GetFloatPropertyAtSplinePoint(int32 Index, FName PropertyName) const;
    
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector GetVectorPropertyAtSplinePoint(int32 Index, FName PropertyName) const;
 
    UFUNCTION(BlueprintCallable, Category=Spline) 
    ENGINE_API float GetSplineLength() const;
 
    UFUNCTION(BlueprintCallable, Category=Spline)
    ENGINE_API void SetDefaultUpVector(const FVector& UpVector, ESplineCoordinateSpace::Type CoordinateSpace);
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector GetDefaultUpVector(ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API float GetInputKeyValueAtTime(float Time) const;
 
    UFUNCTION(BlueprintCallable, Category=Spline, meta = (DeprecatedFunction, DeprecationMessage = "Please use GetInputKeyValueAtDistanceAlongSpline to get input key at distance or GetTimeAtDistanceAlongSpline to get time value (normalized to duration) at distance (same logic as deprecated function)."))
    ENGINE_API float GetInputKeyAtDistanceAlongSpline(float Distance) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API float GetInputKeyValueAtDistanceAlongSpline(float Distance) const;
    
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API float GetTimeAtDistanceAlongSpline(float Distance) const;
 
    UFUNCTION(BlueprintCallable, Category=Spline)
    ENGINE_API FVector GetLocationAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline, meta = (DeprecatedFunction, DeprecationMessage = "Please use GetLocationAtDistanceAlongSpline, specifying SplineCoordinateSpace::World"))
    FVector GetWorldLocationAtDistanceAlongSpline(float Distance) const;
    
    UFUNCTION(BlueprintCallable, Category=Spline)
    ENGINE_API FVector GetDirectionAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline, meta = (DeprecatedFunction, DeprecationMessage = "Please use GetDirectionAtDistanceAlongSpline, specifying SplineCoordinateSpace::World"))
    FVector GetWorldDirectionAtDistanceAlongSpline(float Distance) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector GetTangentAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline, meta = (DeprecatedFunction, DeprecationMessage = "Please use GetTangentAtDistanceAlongSpline, specifying SplineCoordinateSpace::World"))
    FVector GetWorldTangentAtDistanceAlongSpline(float Distance) const;
 
    ENGINE_API FQuat GetQuaternionAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FRotator GetRotationAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline, meta = (DeprecatedFunction, DeprecationMessage = "Please use GetRotationAtDistanceAlongSpline, specifying SplineCoordinateSpace::World"))
    FRotator GetWorldRotationAtDistanceAlongSpline(float Distance) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector GetUpVectorAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector GetRightVectorAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API float GetRollAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector GetScaleAtDistanceAlongSpline(float Distance) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FTransform GetTransformAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace::Type CoordinateSpace, bool bUseScale = false) const;
 
    UFUNCTION(BlueprintCallable, Category=Spline)
    ENGINE_API FVector GetLocationAtTime(float Time, ESplineCoordinateSpace::Type CoordinateSpace, bool bUseConstantVelocity = false) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline, meta = (DeprecatedFunction, DeprecationMessage = "Please use GetLocationAtTime, specifying SplineCoordinateSpace::World"))
    FVector GetWorldLocationAtTime(float Time, bool bUseConstantVelocity = false) const;
 
    UFUNCTION(BlueprintCallable, Category=Spline)
    ENGINE_API FVector GetDirectionAtTime(float Time, ESplineCoordinateSpace::Type CoordinateSpace, bool bUseConstantVelocity = false) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline, meta = (DeprecatedFunction, DeprecationMessage = "Please use GetDirectionAtTime, specifying SplineCoordinateSpace::World"))
    FVector GetWorldDirectionAtTime(float Time, bool bUseConstantVelocity = false) const;
 
    UFUNCTION(BlueprintCallable, Category=Spline)
    ENGINE_API FVector GetTangentAtTime(float Time, ESplineCoordinateSpace::Type CoordinateSpace, bool bUseConstantVelocity = false) const;
 
    ENGINE_API FQuat GetQuaternionAtTime(float Time, ESplineCoordinateSpace::Type CoordinateSpace, bool bUseConstantVelocity = false) const;
 
    UFUNCTION(BlueprintCallable, Category=Spline)
    ENGINE_API FRotator GetRotationAtTime(float Time, ESplineCoordinateSpace::Type CoordinateSpace, bool bUseConstantVelocity = false) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline, meta = (DeprecatedFunction, DeprecationMessage = "Please use GetRotationAtTime, specifying SplineCoordinateSpace::World"))
    FRotator GetWorldRotationAtTime(float Time, bool bUseConstantVelocity = false) const;
 
    UFUNCTION(BlueprintCallable, Category=Spline)
    ENGINE_API FVector GetUpVectorAtTime(float Time, ESplineCoordinateSpace::Type CoordinateSpace, bool bUseConstantVelocity = false) const;
 
    UFUNCTION(BlueprintCallable, Category=Spline)
    ENGINE_API FVector GetRightVectorAtTime(float Time, ESplineCoordinateSpace::Type CoordinateSpace, bool bUseConstantVelocity = false) const;
 
    UFUNCTION(BlueprintCallable, Category=Spline)
    ENGINE_API FTransform GetTransformAtTime(float Time, ESplineCoordinateSpace::Type CoordinateSpace, bool bUseConstantVelocity = false, bool bUseScale = false) const;
 
    UFUNCTION(BlueprintCallable, Category=Spline)
    ENGINE_API float GetRollAtTime(float Time, ESplineCoordinateSpace::Type CoordinateSpace, bool bUseConstantVelocity = false) const;
 
    UFUNCTION(BlueprintCallable, Category=Spline)
    ENGINE_API FVector GetScaleAtTime(float Time, bool bUseConstantVelocity = false) const;
 
    UFUNCTION(BlueprintCallable, Category=Spline)
    ENGINE_API float FindInputKeyClosestToWorldLocation(const FVector& WorldLocation) const;
 
    UFUNCTION(BlueprintCallable, Category=Spline)
    ENGINE_API float FindInputKeyOnSegmentClosestToWorldLocation(const FVector& WorldLocation, int32 Index) const;
    
    UFUNCTION(BlueprintCallable, Category=Spline)
    ENGINE_API FVector FindLocationClosestToWorldLocation(const FVector& WorldLocation, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category=Spline)
    ENGINE_API FVector FindDirectionClosestToWorldLocation(const FVector& WorldLocation, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector FindTangentClosestToWorldLocation(const FVector& WorldLocation, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    ENGINE_API FQuat FindQuaternionClosestToWorldLocation(const FVector& WorldLocation, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FRotator FindRotationClosestToWorldLocation(const FVector& WorldLocation, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector FindUpVectorClosestToWorldLocation(const FVector& WorldLocation, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector FindRightVectorClosestToWorldLocation(const FVector& WorldLocation, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API float FindRollClosestToWorldLocation(const FVector& WorldLocation, ESplineCoordinateSpace::Type CoordinateSpace) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FVector FindScaleClosestToWorldLocation(const FVector& WorldLocation) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API FTransform FindTransformClosestToWorldLocation(const FVector& WorldLocation, ESplineCoordinateSpace::Type CoordinateSpace, bool bUseScale = false) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API bool DivideSplineIntoPolylineRecursive(float StartDistanceAlongSpline, float EndDistanceAlongSpline, ESplineCoordinateSpace::Type CoordinateSpace, const float MaxSquareDistanceFromSpline, TArray<FVector>& OutPoints) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API bool DivideSplineIntoPolylineRecursiveWithDistances(float StartDistanceAlongSpline, float EndDistanceAlongSpline, ESplineCoordinateSpace::Type CoordinateSpace, const float MaxSquareDistanceFromSpline, TArray<FVector>& OutPoints, TArray<double>& OutDistancesAlongSpline) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API bool ConvertSplineSegmentToPolyLine(int32 SplinePointStartIndex, ESplineCoordinateSpace::Type CoordinateSpace, const float MaxSquareDistanceFromSpline, TArray<FVector>& OutPoints) const;
 
    UFUNCTION(BlueprintCallable, Category = Spline)
    ENGINE_API bool ConvertSplineToPolyLine(ESplineCoordinateSpace::Type CoordinateSpace, const float MaxSquareDistanceFromSpline, TArray<FVector>& OutPoints) const;
 
    UFUNCTION(BlueprintPure = false, Category = Spline)
    ENGINE_API bool ConvertSplineToPolyLineWithDistances(ESplineCoordinateSpace::Type CoordinateSpace, const float MaxSquareDistanceFromSpline, TArray<FVector>& OutPoints, TArray<double>& OutDistancesAlongSpline) const;
 
    UFUNCTION(BlueprintPure = false, Category = Spline)
    ENGINE_API bool ConvertSplineToPolyline_InDistanceRange(ESplineCoordinateSpace::Type CoordinateSpace, const float MaxSquareDistanceFromSpline, float StartDistAlongSpline, float EndDistAlongSpline, TArray<FVector>& OutPoints, TArray<double>& OutDistancesAlongSpline, bool bAllowWrappingIfClosed = true) const;
 
    UFUNCTION(BlueprintPure = false, Category = Spline)
    ENGINE_API bool ConvertSplineToPolyline_InTimeRange(ESplineCoordinateSpace::Type CoordinateSpace, const float MaxSquareDistanceFromSpline, float StartTimeAlongSpline, float EndTimeAlongSpline, bool bUseConstantVelocity, TArray<FVector>& OutPoints, TArray<double>& OutDistancesAlongSpline, bool bAllowWrappingIfClosed = true) const;
 
    /* ---- Metadata API ---- */
    
    UFUNCTION(BlueprintCallable, Category = "Spline|Metadata")
    ENGINE_API bool SupportsAttributes() const;
 
    UFUNCTION(BlueprintCallable, Category = "Spline|Metadata")
    ENGINE_API bool RemovePropertyChannel(FName PropertyName);
    
    UFUNCTION(BlueprintCallable, Category = "Spline|Metadata")
    ENGINE_API int32 GetNumberOfPropertyValues(FName PropertyName) const;
        
    UFUNCTION(BlueprintCallable, Category = "Spline|Metadata")
    ENGINE_API TArray<FName> GetFloatPropertyChannels() const;
 
    UFUNCTION(BlueprintCallable, Category = "Spline|Metadata")
    ENGINE_API void CreateFloatPropertyChannel(FName PropertyName);
    
    UFUNCTION(BlueprintCallable, Category = "Spline|Metadata")
    ENGINE_API float GetFloatPropertyAtSplineInputKey(float InKey, FName PropertyName) const;
 
    UFUNCTION(BlueprintCallable, Category = "Spline|Metadata")
    ENGINE_API int32 SetFloatPropertyAtSplineInputKey(float InKey, float Value, FName PropertyName) const;
    
    UFUNCTION(BlueprintCallable, Category = "Spline|Metadata")
    ENGINE_API float GetFloatPropertyInputKeyAtIndex(int32 Index, FName PropertyName) const;
 
    UFUNCTION(BlueprintCallable, Category = "Spline|Metadata")
    ENGINE_API int32 SetFloatPropertyInputKeyAtIndex(int32 Index, float InKey, FName PropertyName);
 
    UFUNCTION(BlueprintCallable, Category = "Spline|Metadata")
    ENGINE_API float GetFloatPropertyAtIndex(int32 Index, FName PropertyName) const;
 
    UFUNCTION(BlueprintCallable, Category = "Spline|Metadata")
    ENGINE_API void SetFloatPropertyAtIndex(int32 Index, float Value, FName PropertyName);
 
    UFUNCTION(BlueprintCallable, Category = "Spline|Metadata")
    ENGINE_API void RemovePropertyAtIndex(int32 Index, FName PropertyName);
 
    // todo: deprecate
    FInterpCurveVector& GetSplinePointsPosition() { return WarninglessSplineCurves().Position; }
    FInterpCurveQuat& GetSplinePointsRotation() { return WarninglessSplineCurves().Rotation; }
    FInterpCurveVector& GetSplinePointsScale() { return WarninglessSplineCurves().Scale; }
 
protected:
 
    ENGINE_API float GetSegmentLength(const int32 Index, const float Param = 1.0f) const;
 
    FSimpleMulticastDelegate OnSplineChanged;
 
    FSimpleMulticastDelegate OnSplineUpdated;
 
    FSimpleMulticastDelegate OnSplineDisplayChanged;
    
private:
    
    UE::Geometry::FInterval1f GetInputKeyRange() const;
    
    int32 GetClampedIndex(int32 Index) const
    {
        // Treat Index == GetNumberOfSplinePoints() as Index == 0, then clamp to valid index range.
        return FMath::Clamp(bClosedLoop && Index == GetNumberOfSplinePoints() ? 0 : Index, 0, GetNumberOfSplinePoints() - 1);
    }
    
    static ENGINE_API const FInterpCurvePointVector DummyPointPosition;
    static ENGINE_API const FInterpCurvePointQuat DummyPointRotation;
    static ENGINE_API const FInterpCurvePointVector DummyPointScale;
 
    // Remove when appending _DEPRECATED to SplineCurves.
    FSplineCurves& WarninglessSplineCurves()
    {
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return SplineCurves;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    // Remove when appending _DEPRECATED to SplineCurves.
    const FSplineCurves& WarninglessSplineCurves() const
    {
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return SplineCurves;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UPROPERTY()
    ELastAuthority LastAuthority = ELastAuthority::Unset;
    
    bool Validate() const;
    
    ENGINE_API void SetDefaultSpline();
 
    ENGINE_API float GetSegmentParamFromLength(const int32 Index, const float Length, const float SegmentLength) const;
 
    // Internal helper function called by ConvertSplineSegmentToPolyLine -- assumes the input is within a half-segment, so testing the distance to midpoint will be an accurate guide to subdivision
    bool DivideSplineIntoPolylineRecursiveWithDistancesHelper(float StartDistanceAlongSpline, float EndDistanceAlongSpline, ESplineCoordinateSpace::Type CoordinateSpace, const float MaxSquareDistanceFromSpline, TArray<FVector>& OutPoints, TArray<double>& OutDistancesAlongSpline) const;
    // Internal helper function called by ConvertSplineSegmentToPolyLine -- assumes the input is within a half-segment, so testing the distance to midpoint will be an accurate guide to subdivision
    bool DivideSplineIntoPolylineRecursiveHelper(float StartDistanceAlongSpline, float EndDistanceAlongSpline, ESplineCoordinateSpace::Type CoordinateSpace, const float MaxSquareDistanceFromSpline, TArray<FVector>& OutPoints) const;
 
    // FSplineComponentVisualizer will access some private members when attempting to call NotifyPropertiesModified
    friend class FSplineComponentVisualizer;
};
 
USTRUCT()
struct FSplineInstanceData : public FSceneComponentInstanceData
{
    GENERATED_BODY()
public:
    FSplineInstanceData()
        : bSplineHasBeenEdited(false)
    {}
    explicit FSplineInstanceData(const USplineComponent* SourceComponent)
        : FSceneComponentInstanceData(SourceComponent)
        , bSplineHasBeenEdited(false)
    {}
    virtual ~FSplineInstanceData() = default;
 
    virtual bool ContainsData() const override
    {
        return Super::ContainsData() || bSplineHasBeenEdited;
    }
 
    virtual void ApplyToComponent(UActorComponent* Component, const ECacheApplyPhase CacheApplyPhase) override
    {
        Super::ApplyToComponent(Component, CacheApplyPhase);
        CastChecked<USplineComponent>(Component)->ApplyComponentInstanceData(this, (CacheApplyPhase == ECacheApplyPhase::PostUserConstructionScript));
    }
 
    UPROPERTY()
    bool bSplineHasBeenEdited;
 
    UPROPERTY()
    FSplineCurves SplineCurves;
 
    UPROPERTY()
    bool bClosedLoop = false;
 
    UPROPERTY()
    FSplineCurves SplineCurvesPreUCS;
};
 
USTRUCT()
struct FSplineComponentInstanceData : public FSceneComponentInstanceData
{
    GENERATED_BODY()
public:
    FSplineComponentInstanceData()
        : bSplineHasBeenEdited(false)
    {}
    explicit FSplineComponentInstanceData(const USplineComponent* SourceComponent)
        : FSceneComponentInstanceData(SourceComponent)
        , bSplineHasBeenEdited(false)
    {}
    explicit FSplineComponentInstanceData(const USplineComponent* SourceComponent, const FSpline& SourceSpline)
        : FSceneComponentInstanceData(SourceComponent)
        , bSplineHasBeenEdited(false)
        , Spline(SourceSpline)
    {}
    virtual ~FSplineComponentInstanceData() = default;
 
    virtual bool ContainsData() const override
    {
        return Super::ContainsData() || bSplineHasBeenEdited;
    }
 
    virtual void ApplyToComponent(UActorComponent* Component, const ECacheApplyPhase CacheApplyPhase) override
    {
        Super::ApplyToComponent(Component, CacheApplyPhase);
        CastChecked<USplineComponent>(Component)->ApplyComponentInstanceData(this, (CacheApplyPhase == ECacheApplyPhase::PostUserConstructionScript));
    }
 
    UPROPERTY()
    bool bSplineHasBeenEdited;
 
    UPROPERTY()
    FSpline Spline;
 
    UPROPERTY()
    bool bClosedLoop = false;
 
    UPROPERTY()
    FSpline SplinePreUCS;
};
 
ENGINE_API EInterpCurveMode ConvertSplinePointTypeToInterpCurveMode(ESplinePointType::Type SplinePointType);
ENGINE_API ESplinePointType::Type ConvertInterpCurveModeToSplinePointType(EInterpCurveMode InterpCurveMode);
 
// Deprecated method definitions
inline void USplineComponent::AddSplineWorldPoint(const FVector& Position) { AddSplinePoint(Position, ESplineCoordinateSpace::World); }
inline void USplineComponent::AddSplineLocalPoint(const FVector& Position) { AddSplinePoint(Position, ESplineCoordinateSpace::Local); }
inline void USplineComponent::SetSplineWorldPoints(const TArray<FVector>& Points) { SetSplinePoints(Points, ESplineCoordinateSpace::World); }
inline void USplineComponent::SetSplineLocalPoints(const TArray<FVector>& Points) { SetSplinePoints(Points, ESplineCoordinateSpace::Local); }
inline void USplineComponent::SetWorldLocationAtSplinePoint(int32 PointIndex, const FVector& InLocation) { SetLocationAtSplinePoint(PointIndex, InLocation, ESplineCoordinateSpace::World); }
inline FVector USplineComponent::GetWorldLocationAtSplinePoint(int32 PointIndex) const { return GetLocationAtSplinePoint(PointIndex, ESplineCoordinateSpace::World); }
inline void USplineComponent::GetLocalLocationAndTangentAtSplinePoint(int32 PointIndex, FVector& LocalLocation, FVector& LocalTangent) const { GetLocationAndTangentAtSplinePoint(PointIndex, LocalLocation, LocalTangent, ESplineCoordinateSpace::Local); }
inline FVector USplineComponent::GetWorldLocationAtDistanceAlongSpline(float Distance) const { return GetLocationAtDistanceAlongSpline(Distance, ESplineCoordinateSpace::World); }
inline FVector USplineComponent::GetWorldDirectionAtDistanceAlongSpline(float Distance) const { return GetDirectionAtDistanceAlongSpline(Distance, ESplineCoordinateSpace::World); }
inline FVector USplineComponent::GetWorldTangentAtDistanceAlongSpline(float Distance) const { return GetTangentAtDistanceAlongSpline(Distance, ESplineCoordinateSpace::World); }
inline FRotator USplineComponent::GetWorldRotationAtDistanceAlongSpline(float Distance) const { return GetRotationAtDistanceAlongSpline(Distance, ESplineCoordinateSpace::World); }
inline FVector USplineComponent::GetWorldLocationAtTime(float Time, bool bUseConstantVelocity) const { return GetLocationAtTime(Time, ESplineCoordinateSpace::World, bUseConstantVelocity); }
inline FVector USplineComponent::GetWorldDirectionAtTime(float Time, bool bUseConstantVelocity) const { return GetDirectionAtTime(Time, ESplineCoordinateSpace::World, bUseConstantVelocity); }
inline FRotator USplineComponent::GetWorldRotationAtTime(float Time, bool bUseConstantVelocity) const { return GetRotationAtTime(Time, ESplineCoordinateSpace::World, bUseConstantVelocity); }
 
PRAGMA_ENABLE_EXPERIMENTAL_WARNINGS