TimelineComponent.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/ActorComponent.h"
#include "TimelineComponent.generated.h"
 
class UCurveFloat;
class UCurveLinearColor;
class UCurveVector;
 
DECLARE_DYNAMIC_DELEGATE( FOnTimelineEvent );
DECLARE_DYNAMIC_DELEGATE_OneParam( FOnTimelineFloat, float, Output );
DECLARE_DYNAMIC_DELEGATE_OneParam( FOnTimelineVector, FVector, Output );
DECLARE_DYNAMIC_DELEGATE_OneParam( FOnTimelineLinearColor, FLinearColor, Output );
 
DECLARE_DELEGATE( FOnTimelineEventStatic );
DECLARE_DELEGATE_OneParam( FOnTimelineFloatStatic, float );
DECLARE_DELEGATE_OneParam( FOnTimelineVectorStatic, FVector );
DECLARE_DELEGATE_OneParam( FOnTimelineLinearColorStatic, FLinearColor );
 
UENUM()
enum ETimelineLengthMode : int
{
    TL_TimelineLength,
    TL_LastKeyFrame
};
 
UENUM(BlueprintType)
namespace ETimelineDirection
{
    enum Type : int
    {
        Forward,
        Backward,
    };
}
 
USTRUCT()
struct FTimelineEventEntry
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    float Time;
 
    UPROPERTY()
    FOnTimelineEvent EventFunc;
 
 
    FTimelineEventEntry()
        : Time(0)
    {
    }
 
};
 
USTRUCT()
struct FTimelineVectorTrack
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    TObjectPtr<class UCurveVector> VectorCurve;
 
    UPROPERTY()
    FOnTimelineVector InterpFunc;
 
    UPROPERTY()
    FName TrackName;
 
    UPROPERTY()
    FName VectorPropertyName;
 
    FStructProperty* VectorProperty;
 
    FOnTimelineVectorStatic InterpFuncStatic;
 
    FTimelineVectorTrack()
        : VectorCurve(NULL)
        , VectorPropertyName(NAME_None)
        , VectorProperty(NULL)
    {
    }
 
};
 
USTRUCT()
struct FTimelineFloatTrack
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    TObjectPtr<class UCurveFloat> FloatCurve;
 
    UPROPERTY()
    FOnTimelineFloat InterpFunc;
 
    UPROPERTY()
    FName TrackName;
 
    UPROPERTY()
    FName FloatPropertyName;
 
    FFloatProperty* FloatProperty;
 
    FOnTimelineFloatStatic InterpFuncStatic;
 
    FTimelineFloatTrack()
        : FloatCurve(NULL)
        , FloatPropertyName(NAME_None)
        , FloatProperty(NULL)
    {
    }
 
};
 
 
USTRUCT()
struct FTimelineLinearColorTrack
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    TObjectPtr<class UCurveLinearColor> LinearColorCurve;
 
    UPROPERTY()
    FOnTimelineLinearColor InterpFunc;
 
    UPROPERTY()
    FName TrackName;
 
    UPROPERTY()
    FName LinearColorPropertyName;
 
    FStructProperty* LinearColorProperty;
 
    FOnTimelineLinearColorStatic InterpFuncStatic;
 
    FTimelineLinearColorTrack()
        : LinearColorCurve(NULL)
        , LinearColorPropertyName(NAME_None)
        , LinearColorProperty(NULL)
    {
    }
 
};
 
USTRUCT()
struct FTimeline
{
    GENERATED_BODY()
    
private:
    UPROPERTY(NotReplicated)
    TEnumAsByte<ETimelineLengthMode> LengthMode;
 
    UPROPERTY()
    uint8 bLooping:1;
 
    UPROPERTY()
    uint8 bReversePlayback:1;
    
    UE_DEPRECATED(5.5, "Use PlayingStateTracker instead")
    UPROPERTY(Meta = (DeprecatedProperty, DeprecationMessage = "This property is no longer supported. Use PlayingStateTracker instead"))
    uint8 bPlaying_DEPRECATED:1;
    
    UPROPERTY()
    uint8 PlayingStateTracker;
 
    UPROPERTY(NotReplicated)
    float Length;
 
    UPROPERTY()
    float PlayRate;
 
    UPROPERTY()
    float Position;
 
    UPROPERTY(NotReplicated)
    TArray<struct FTimelineEventEntry> Events;
 
    UPROPERTY(NotReplicated)
    TArray<struct FTimelineVectorTrack> InterpVectors;
 
    UPROPERTY(NotReplicated)
    TArray<struct FTimelineFloatTrack> InterpFloats;
 
    UPROPERTY(NotReplicated)
    TArray<struct FTimelineLinearColorTrack> InterpLinearColors;
 
    UPROPERTY(NotReplicated)
    FOnTimelineEvent TimelinePostUpdateFunc;
 
    UPROPERTY(NotReplicated)
    FOnTimelineEvent TimelineFinishedFunc;
 
    UPROPERTY(NotReplicated)
    TWeakObjectPtr<UObject> PropertySetObject;
 
    UPROPERTY(NotReplicated)
    FName DirectionPropertyName;
 
    FOnTimelineEventStatic TimelineFinishFuncStatic;
 
    FProperty* DirectionProperty;
 
public:
    
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    
    FTimeline()
    : LengthMode( TL_LastKeyFrame )
    , bLooping( false )
    , bReversePlayback( false )
    , bPlaying_DEPRECATED ( false )
    , PlayingStateTracker( 2 )
    , Length( 5.f )
    , PlayRate( 1.f )
    , Position( 0.0f )  
    , PropertySetObject(nullptr)
    , DirectionProperty(nullptr)
    {
    }
 
    // Note: We need to explicitly disable warnings on these constructors/operators for clang to be happy with deprecated variables
    ~FTimeline() = default;
    FTimeline(const FTimeline&) = default;
    FTimeline(FTimeline&&) = default;
    FTimeline& operator=(const FTimeline&) = default;
    FTimeline& operator=(FTimeline&&) = default;
    
PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    ENGINE_API static UEnum* GetTimelineDirectionEnum();
 
    ENGINE_API void Play();
 
    ENGINE_API void PlayFromStart();
 
    ENGINE_API void Reverse();
 
    ENGINE_API void ReverseFromEnd();
 
    ENGINE_API void Stop();
 
    ENGINE_API bool IsPlaying() const;
 
    ENGINE_API bool IsReversing() const;
 
    ENGINE_API void SetPlaybackPosition(float NewPosition, bool bFireEvents, bool bFireUpdate = true);
 
    ENGINE_API float GetPlaybackPosition() const;
 
    ENGINE_API void SetLooping(bool bNewLooping);
 
    ENGINE_API bool IsLooping() const;
 
    ENGINE_API void SetPlayRate(float NewRate);
 
    ENGINE_API float GetPlayRate() const;
 
    ENGINE_API void SetNewTime(float NewTime);
 
    ENGINE_API float GetTimelineLength() const;
 
    ENGINE_API float GetScaledTimelineLength() const;
 
    ENGINE_API void SetTimelineLengthMode(ETimelineLengthMode NewMode);
 
    ENGINE_API void SetTimelineLength(float NewLength);
 
    ENGINE_API void SetFloatCurve(UCurveFloat* NewFloatCurve, FName FloatTrackName);
 
    ENGINE_API void SetVectorCurve(UCurveVector* NewVectorCurve, FName VectorTrackName);
 
    ENGINE_API void SetLinearColorCurve(UCurveLinearColor* NewLinearColorCurve, FName LinearColorTrackName);
 
    ENGINE_API void SetPropertySetObject(UObject* NewPropertySetObject);
 
    ENGINE_API void SetTimelinePostUpdateFunc(FOnTimelineEvent NewTimelinePostUpdateFunc);
 
    ENGINE_API void SetTimelineFinishedFunc(FOnTimelineEvent NewTimelineFinishedFunc);
 
    ENGINE_API void SetTimelineFinishedFunc(FOnTimelineEventStatic NewTimelineFinishedFunc);
 
    ENGINE_API void AddEvent(float Time, FOnTimelineEvent EventFunc);
 
    ENGINE_API void AddInterpVector(UCurveVector* VectorCurve, FOnTimelineVector InterpFunc, FName PropertyName = NAME_None, FName TrackName = NAME_None);
 
    ENGINE_API void AddInterpVector(UCurveVector* VectorCurve, FOnTimelineVectorStatic InterpFunc);
 
    ENGINE_API void AddInterpFloat(UCurveFloat* FloatCurve, FOnTimelineFloat InterpFunc, FName PropertyName = NAME_None, FName TrackName = NAME_None);
 
    ENGINE_API void AddInterpFloat(UCurveFloat* FloatCurve, FOnTimelineFloatStatic InterpFunc );
 
    ENGINE_API void AddInterpLinearColor(UCurveLinearColor* LinearColorCurve, FOnTimelineLinearColor InterpFunc, FName PropertyName = NAME_None, FName TrackName = NAME_None);
 
    ENGINE_API void AddInterpLinearColor(UCurveLinearColor* LinearColorCurve, FOnTimelineLinearColorStatic InterpFunc);
 
 
    ENGINE_API void TickTimeline(float DeltaTime);
 
    ENGINE_API void SetDirectionPropertyName(FName InDirectionPropertyName);
 
    void GetAllCurves(TSet<class UCurveBase*>& InOutCurves) const;
 
    ENGINE_API bool Serialize(FArchive& Ar);
    ENGINE_API void PostSerialize(const FArchive& Ar);
    
private:
    float GetLastKeyframeTime() const;
 
    void ChangeMarkPlayingState(const bool bIsPlaying);
};
 
// Need to customize serialization to safely update the old bPlaying flag to the newer play state tracer
template<> struct TStructOpsTypeTraits<FTimeline> : public TStructOpsTypeTraitsBase2<FTimeline>
{
    enum
    {
        WithSerializer = true,
        WithPostSerialize = true,
    };
};
 
UCLASS(MinimalAPI)
class UTimelineComponent : public UActorComponent
{
    GENERATED_UCLASS_BODY()
 
private:
    
    UPROPERTY(ReplicatedUsing=OnRep_Timeline)
    FTimeline   TheTimeline;
    
    UPROPERTY()
    uint32 bIgnoreTimeDilation : 1;
 
public:
 
    UFUNCTION(BlueprintCallable, Category="Components|Timeline")
    ENGINE_API void Play();
 
    UFUNCTION(BlueprintCallable, Category="Components|Timeline")
    ENGINE_API void PlayFromStart();
 
    UFUNCTION(BlueprintCallable, Category="Components|Timeline")
    ENGINE_API void Reverse();
 
    UFUNCTION(BlueprintCallable, Category="Components|Timeline")
    ENGINE_API void ReverseFromEnd();
 
    UFUNCTION(BlueprintCallable, Category="Components|Timeline")
    ENGINE_API void Stop();
 
    UFUNCTION(BlueprintCallable, Category="Components|Timeline")
    ENGINE_API bool IsPlaying() const;
 
    UFUNCTION(BlueprintCallable, Category="Components|Timeline")
    ENGINE_API bool IsReversing() const;
 
    UFUNCTION(BlueprintCallable, Category="Components|Timeline", meta=(AdvancedDisplay="bFireUpdate"))
    ENGINE_API void SetPlaybackPosition(float NewPosition, bool bFireEvents, bool bFireUpdate = true);
 
    UFUNCTION(BlueprintCallable, Category="Components|Timeline")
    ENGINE_API float GetPlaybackPosition() const;
 
    UFUNCTION(BlueprintCallable, Category="Components|Timeline")
    ENGINE_API void SetLooping(bool bNewLooping);
 
    UFUNCTION(BlueprintCallable, Category="Components|Timeline")
    ENGINE_API bool IsLooping() const;
 
    UFUNCTION(BlueprintCallable, Category="Components|Timeline")
    ENGINE_API void SetPlayRate(float NewRate);
 
    UFUNCTION(BlueprintCallable, Category="Components|Timeline")
    ENGINE_API float GetPlayRate() const;
 
    UFUNCTION(BlueprintCallable, Category="Components|Timeline")
    ENGINE_API void SetNewTime(float NewTime);
 
    UFUNCTION(BlueprintCallable, Category="Components|Timeline")
    ENGINE_API float GetTimelineLength() const;
 
    UFUNCTION(BlueprintCallable, Category="Components|Timeline")
    ENGINE_API float GetScaledTimelineLength() const;
 
    UFUNCTION(BlueprintCallable, Category="Components|Timeline")
    ENGINE_API void SetTimelineLength(float NewLength);
 
    UFUNCTION(BlueprintCallable, Category="Components|Timeline")
    ENGINE_API void SetTimelineLengthMode(ETimelineLengthMode NewLengthMode);
 
    UFUNCTION(BlueprintCallable, Category = "Components|Timeline")
    ENGINE_API void SetIgnoreTimeDilation(bool bNewIgnoreTimeDilation);
 
    UFUNCTION(BlueprintCallable, Category = "Components|Timeline")
    ENGINE_API bool GetIgnoreTimeDilation() const;
 
    UFUNCTION(BlueprintCallable, Category = "Components|Timeline")
    ENGINE_API void SetFloatCurve(UCurveFloat* NewFloatCurve, FName FloatTrackName);
 
    UFUNCTION(BlueprintCallable, Category = "Components|Timeline")
    ENGINE_API void SetVectorCurve(UCurveVector* NewVectorCurve, FName VectorTrackName);
 
    UFUNCTION(BlueprintCallable, Category = "Components|Timeline")
    ENGINE_API void SetLinearColorCurve(UCurveLinearColor* NewLinearColorCurve, FName LinearColorTrackName);
 
    UFUNCTION()
    void OnRep_Timeline(FTimeline& OldTimeline);
 
    //~ Begin ActorComponent Interface.
    virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction) override;
    virtual void Activate(bool bReset=false) override;
    virtual void Deactivate() override;
    virtual bool IsReadyForOwnerToAutoDestroy() const override;
    //~ End ActorComponent Interface.
 
    //~ Begin UObject Interface. 
    virtual bool IsPostLoadThreadSafe() const override;
    //~ End UObject Interface
 
    ENGINE_API static UFunction* GetTimelineEventSignature();
    ENGINE_API static UFunction* GetTimelineFloatSignature();
    ENGINE_API static UFunction* GetTimelineVectorSignature();
    ENGINE_API static UFunction* GetTimelineLinearColorSignature();
 
    static ETimelineSigType GetTimelineSignatureForFunction(const UFunction* InFunc);
 
    UFUNCTION(BlueprintCallable, Category = "Components|Timeline")
    ENGINE_API void AddEvent(float Time, FOnTimelineEvent EventFunc);
    
    UFUNCTION(BlueprintCallable, Category = "Components|Timeline")
    ENGINE_API void AddInterpVector(UCurveVector* VectorCurve, FOnTimelineVector InterpFunc, FName PropertyName = NAME_None, FName TrackName = NAME_None);
    ENGINE_API void AddInterpVector(UCurveVector* VectorCurve, FOnTimelineVectorStatic InterpFunc);
    
    UFUNCTION(BlueprintCallable, Category = "Components|Timeline")
    ENGINE_API void AddInterpFloat(UCurveFloat* FloatCurve, FOnTimelineFloat InterpFunc, FName PropertyName = NAME_None, FName TrackName = NAME_None);
    ENGINE_API void AddInterpFloat(UCurveFloat* FloatCurve, FOnTimelineFloatStatic InterpFunc);
 
    UFUNCTION(BlueprintCallable, Category = "Components|Timeline")
    ENGINE_API void AddInterpLinearColor(UCurveLinearColor* LinearColorCurve, FOnTimelineLinearColor InterpFunc, FName PropertyName = NAME_None, FName TrackName = NAME_None);
    ENGINE_API void AddInterpLinearColor(UCurveLinearColor* LinearColorCurve, FOnTimelineLinearColorStatic InterpFunc);
 
    ENGINE_API void SetPropertySetObject(UObject* NewPropertySetObject);
 
    UFUNCTION(BlueprintCallable, Category = "Components|Timeline")
    ENGINE_API void SetTimelinePostUpdateFunc(FOnTimelineEvent NewTimelinePostUpdateFunc);
 
    UFUNCTION(BlueprintCallable, Category = "Components|Timeline")
    ENGINE_API void SetTimelineFinishedFunc(FOnTimelineEvent NewTimelineFinishedFunc);
    ENGINE_API void SetTimelineFinishedFunc(FOnTimelineEventStatic NewTimelineFinishedFunc);
 
    ENGINE_API void SetDirectionPropertyName(FName DirectionPropertyName);
 
    ENGINE_API void GetAllCurves(TSet<class UCurveBase*>& InOutCurves) const;
};