AnimMontage.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 "UObject/Object.h"
#include "Animation/AnimLinkableElement.h"
#include "Animation/AnimTypes.h"
#include "Animation/AnimationAsset.h"
#include "AlphaBlend.h"
#include "Animation/AnimCompositeBase.h"
#include "Animation/TimeStretchCurve.h"
#include "AnimMontage.generated.h"
 
class UAnimInstance;
class UAnimMontage;
class UAnimNotifyState;
class UAnimSequence;
class UBlendProfile;
class USkeletalMeshComponent;
 
enum class EBlendProfileMode : uint8;
 
 
USTRUCT()
struct FCompositeSection : public FAnimLinkableElement
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, Category=Section)
    FName SectionName;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    float StartTime_DEPRECATED;
#endif
 
    UPROPERTY(VisibleAnywhere, Category=Section)
    FName NextSectionName;
 
    UPROPERTY(Category=Section, Instanced, EditAnywhere)
    TArray<TObjectPtr<class UAnimMetaData>> MetaData;
 
public:
    FCompositeSection()
        : FAnimLinkableElement()
        , SectionName(NAME_None)
#if WITH_EDITORONLY_DATA
        , StartTime_DEPRECATED(0.0f)
#endif
        , NextSectionName(NAME_None)
    {
    }
 
    const TArray<class UAnimMetaData*>& GetMetaData() const { return MetaData; }
};
 
USTRUCT()
struct FSlotAnimationTrack
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(EditAnywhere, Category=Slot)
    FName SlotName;
 
    UPROPERTY(EditAnywhere, Category=Slot)
    FAnimTrack AnimTrack;
 
    ENGINE_API FSlotAnimationTrack();
};
 
USTRUCT()
struct FBranchingPoint : public FAnimLinkableElement
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(EditAnywhere, Category=BranchingPoint)
    FName EventName;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    float DisplayTime_DEPRECATED = 0.f;
#endif
 
    UPROPERTY()
    float TriggerTimeOffset = 0.f;
 
    float GetTriggerTime() const { return GetTime() + TriggerTimeOffset; }
};
 
UENUM()
namespace EAnimNotifyEventType
{
    enum Type : int
    {
        Begin,
        End,
    };
}
 
UENUM()
enum class EMontageBlendMode : uint8
{
    //Uses standard weight based blend
    Standard,
    //Uses inertialization. Requires an inertialization node somewhere in the graph after any slot node used by this montage.
    Inertialization,
};
 
USTRUCT()
struct FBranchingPointMarker
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    int32 NotifyIndex;
    
    UPROPERTY()
    float TriggerTime;
 
    UPROPERTY()
    TEnumAsByte<EAnimNotifyEventType::Type> NotifyEventType;
 
    FBranchingPointMarker()
        : NotifyIndex(INDEX_NONE)
        , TriggerTime(0.f)
        , NotifyEventType(EAnimNotifyEventType::Begin)
    {
    }
 
    FBranchingPointMarker(int32 InNotifyIndex, float InTriggerTime, EAnimNotifyEventType::Type InNotifyEventType)
        : NotifyIndex(InNotifyIndex)
        , TriggerTime(InTriggerTime)
        , NotifyEventType(InNotifyEventType)
    {
    }
};
 
UENUM()
enum class EMontageSubStepResult : uint8
{
    Moved,
    NotMoved,
    InvalidSection,
    InvalidMontage,
};
 
DECLARE_DELEGATE_TwoParams( FOnMontageEnded, class UAnimMontage*, bool /*bInterrupted*/) 
 
DECLARE_DELEGATE_TwoParams( FOnMontageBlendingOutStarted, class UAnimMontage*, bool /*bInterrupted*/) 
 
DECLARE_DELEGATE_OneParam(FOnMontageBlendedInEnded, class UAnimMontage*)
 
DECLARE_DELEGATE_ThreeParams( FOnMontageSectionChanged, class UAnimMontage*, FName /*SectionName*/ , bool /*bInterrupted*/)
 
struct FMontageSubStepper
{
private:
    const struct FAnimMontageInstance* MontageInstance;
    const class UAnimMontage* Montage;
 
    float TimeRemaining;
    float Cached_CombinedPlayRate;
    float PlayRate;
    float DeltaMove;
    bool bPlayingForward;
 
    int32 CurrentSectionIndex;
    float CurrentSectionStartTime;
    float CurrentSectionLength;
    bool bReachedEndOfSection;
    bool bHasValidTimeStretchCurveData;
 
    int32 TimeStretchMarkerIndex;
 
    mutable TArray<float> SectionStartPositions_Target;
    mutable TArray<float> SectionEndPositions_Target;
 
    float Cached_P_Target;
    float Cached_P_Original;
 
    FTimeStretchCurveInstance TimeStretchCurveInstance;
 
public:
    FMontageSubStepper()
        : MontageInstance(nullptr)
        , Montage(nullptr)
        , TimeRemaining(0.f)
        , Cached_CombinedPlayRate(0.f)
        , PlayRate(0.f)
        , DeltaMove(0.f)
        , bPlayingForward(true)
        , CurrentSectionIndex(INDEX_NONE)
        , CurrentSectionStartTime(0.f)
        , CurrentSectionLength(0.f)
        , bReachedEndOfSection(false)
        , bHasValidTimeStretchCurveData(false)
        , TimeStretchMarkerIndex(INDEX_NONE)
        , Cached_P_Target(FLT_MAX)
        , Cached_P_Original(FLT_MAX)
    {}
 
    void Initialize(const struct FAnimMontageInstance& InAnimInstance);
 
    void AddEvaluationTime(float InDeltaTime) { TimeRemaining += InDeltaTime; }
    bool HasTimeRemaining() const { return (TimeRemaining > UE_SMALL_NUMBER); }
    float GetRemainingTime() const { return TimeRemaining; }
    EMontageSubStepResult Advance(float& InOut_P_Original, const FBranchingPointMarker** OutBranchingPointMarkerPtr);
    bool HasReachedEndOfSection() const { return bReachedEndOfSection; }
    float GetRemainingPlayTimeToSectionEnd(const float In_P_Original);
 
    bool GetbPlayingForward() const { return bPlayingForward; }
    float GetDeltaMove() const { return DeltaMove; }
    int32 GetCurrentSectionIndex() const { return CurrentSectionIndex; }
 
    void ClearCachedData() { Cached_CombinedPlayRate = FLT_MAX; }
 
private:
    void ConditionallyUpdateTimeStretchCurveCachedData();
 
    float FindMontagePosition_Target(float In_P_Original);
 
    float FindMontagePosition_Original(float In_P_Target);
 
    float GetCurrSectionEndPosition_Target() const;
 
    float GetCurrSectionStartPosition_Target() const;
};
 
USTRUCT(BlueprintType)
struct FMontageBlendSettings
{
    GENERATED_BODY()
 
    ENGINE_API FMontageBlendSettings();
    ENGINE_API FMontageBlendSettings(float BlendTime);
    ENGINE_API FMontageBlendSettings(const FAlphaBlendArgs& BlendArgs);
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Blend", meta = (DisplayAfter = "Blend"))
    TObjectPtr<UBlendProfile> BlendProfile;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Blend", meta = (DisplayAfter = "BlendMode"))
    FAlphaBlendArgs Blend;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Blend")
    EMontageBlendMode BlendMode;
};
 
USTRUCT()
struct FAnimMontageInstance
{
    GENERATED_USTRUCT_BODY()
 
    friend struct FMontageSubStepper;
 
    // Montage reference
    UPROPERTY()
    TObjectPtr<class UAnimMontage> Montage;
 
    // delegates
    FOnMontageEnded OnMontageEnded;
    FOnMontageBlendingOutStarted OnMontageBlendingOutStarted;
    FOnMontageBlendedInEnded OnMontageBlendedInEnded;
    FOnMontageSectionChanged OnMontageSectionChanged;
    
    UPROPERTY()
    bool bPlaying;
 
    // Blend Time multiplier to allow extending and narrowing blendtimes
    UPROPERTY(transient)
    float DefaultBlendTimeMultiplier;
 
    // transient value of time position and delta in the last frame known
    FDeltaTimeRecord DeltaTimeRecord;
 
    // marker tick record
    FMarkerTickRecord MarkerTickRecord;
 
    // markers that passed in this tick
    TArray<FPassedMarker> MarkersPassedThisTick;
 
    // Whether this in this tick's call to Advance we used marker based sync
    bool bDidUseMarkerSyncThisTick;
 
    // enable auto blend out. This is instance set up. You can override
    bool bEnableAutoBlendOut;
 
private:
    struct FMontageSubStepper MontageSubStepper;
 
    // list of next sections per section - index of array is section id
    UPROPERTY()
    TArray<int32> NextSections;
 
    // list of prev sections per section - index of array is section id
    UPROPERTY()
    TArray<int32> PrevSections;
 
    // reference to AnimInstance
    TWeakObjectPtr<UAnimInstance> AnimInstance;
 
    // Unique ID for this instance
    int32 InstanceID;
 
    UPROPERTY(Transient)
    TArray<FAnimNotifyEvent> ActiveStateBranchingPoints;
 
    UPROPERTY()
    float Position;
 
    UPROPERTY()
    float PlayRate;
 
    UPROPERTY(transient)
    FAlphaBlend Blend;
 
    // need to save if it's interrupted or not
    // this information is crucial for gameplay
    bool bInterrupted;
 
    // transient PreviousWeight - Weight of previous tick
    float PreviousWeight;
 
    // transient NotifyWeight   - Weight for spawned notifies, modified slightly to make sure
    //                          - we spawn all notifies
    float NotifyWeight;
 
    // The current start linear alpha value of the blend. This is not stored inside the FAlphaBlend struct.
    float BlendStartAlpha;
 
    // sync group name
    FName SyncGroupName;
 
    // Active blend profile.
    UBlendProfile* ActiveBlendProfile;
    EBlendProfileMode ActiveBlendProfileMode;
 
    TOptional<float> ForcedNextFromPosition;
    TOptional<float> ForcedNextToPosition;
 
    UPROPERTY(Transient)
    int32 DisableRootMotionCount;
 
public:
    ENGINE_API void MontageSync_Follow(struct FAnimMontageInstance* NewLeaderMontageInstance);
    ENGINE_API void MontageSync_StopLeading();
    ENGINE_API void MontageSync_StopFollowing();
    ENGINE_API void MontageSync_PreUpdate();
    ENGINE_API void MontageSync_PostUpdate();
 
    float GetWeight() const { return Blend.GetBlendedValue(); }
    float GetDesiredWeight() const { return Blend.GetDesiredValue(); }
    float GetBlendTime() const { return Blend.GetBlendTime(); }
    UE_DEPRECATED(4.26, "Please use GetSyncGroupName")
    int32 GetSyncGroupIndex() const { return INDEX_NONE;  }
    FName GetSyncGroupName() const { return SyncGroupName;  }
 
    void SetWeight(float InValue) { Blend.SetAlpha(InValue); }
    void SetDesiredWeight(float InValue) { Blend.SetDesiredValue(InValue); }
 
    const FAlphaBlend& GetBlend() const { return Blend; }
 
private:
    TArray<struct FAnimMontageInstance*> MontageSyncFollowers;
    struct FAnimMontageInstance* MontageSyncLeader;
    uint32 MontageSyncUpdateFrameCounter;
 
    ENGINE_API bool MontageSync_HasBeenUpdatedThisFrame() const;
    ENGINE_API uint32 MontageSync_GetFrameCounter() const;
    ENGINE_API void MontageSync_PerformSyncToLeader();
 
    ENGINE_API void InitializeBlend(const FAlphaBlend& InAlphaBlend);
 
    static ENGINE_API bool ValidateInstanceAfterNotifyState(const TWeakObjectPtr<UAnimInstance>& InAnimInstance, const UAnimNotifyState* InNotifyStateClass);
 
public:
    ENGINE_API FAnimMontageInstance();
 
    ENGINE_API FAnimMontageInstance(UAnimInstance * InAnimInstance);
 
    //~ Begin montage instance Interfaces
 
    // Blend in with the supplied play rate. Other blend settings will come from the Montage asset.
    ENGINE_API void Play(float InPlayRate = 1.f);
    // Blend in with the supplied blend settings
    ENGINE_API void Play(float InPlayRate, const FMontageBlendSettings& BlendInSettings);
 
    // Blend out with the supplied FAlphaBlend. Other blend settings will come from the Montage asset.
    ENGINE_API void Stop(const FAlphaBlend& InBlendOut, bool bInterrupt=true);
    // Blend out with the supplied blend settings
    ENGINE_API void Stop(const FMontageBlendSettings& InBlendOutSettings, bool bInterrupt=true);
 
    ENGINE_API void Pause();
    ENGINE_API void Initialize(class UAnimMontage * InMontage);
 
    ENGINE_API bool JumpToSectionName(FName const & SectionName, bool bEndOfSection = false);
    ENGINE_API bool SetNextSectionName(FName const & SectionName, FName const & NewNextSectionName);
    ENGINE_API bool SetNextSectionID(int32 const & SectionID, int32 const & NewNextSectionID);
 
    bool IsValid() const { return (Montage!=nullptr); }
    bool IsPlaying() const { return IsValid() && bPlaying; }
    void SetPlaying(bool bInPlaying) { bPlaying = bInPlaying; }
    bool IsStopped() const { return Blend.GetDesiredValue() == 0.f; }
 
    bool IsActive() const { return (IsValid() && !IsStopped()); }
 
    ENGINE_API void Terminate();
 
    ENGINE_API bool CanUseMarkerSync() const;
 
    int32 GetInstanceID() const { return InstanceID; }
    float GetPosition() const { return Position; };
    float GetPlayRate() const { return PlayRate; }
    float GetDeltaMoved() const { return DeltaTimeRecord.Delta; }
    float GetPreviousPosition() const { return DeltaTimeRecord.GetPrevious();  }
    float GetBlendStartAlpha() const { return BlendStartAlpha; }
    const FAnimMontageInstance* GetMontageSyncLeader() const { return MontageSyncLeader; } 
    const UBlendProfile* GetActiveBlendProfile() const { return ActiveBlendProfile; }
    const EBlendProfileMode GetActiveBlendProfileMode() const { return ActiveBlendProfileMode; }
 
    void SetPosition(float const & InPosition) { Position = InPosition; MarkerTickRecord.Reset(); }
    void SetPlayRate(float const & InPlayRate) { PlayRate = InPlayRate; }
 
    // Disable RootMotion
    void PushDisableRootMotion() { DisableRootMotionCount++; }
    void PopDisableRootMotion() { DisableRootMotionCount--; }
    bool IsRootMotionDisabled() const { return DisableRootMotionCount > 0; }
 
    void SetNextPositionWithEvents(float InPosition) { ForcedNextFromPosition.Reset();  ForcedNextToPosition = InPosition; }
    void SetNextPositionWithEvents(float InFromPosition, float InToPosition) { ForcedNextFromPosition = InFromPosition; ForcedNextToPosition = InToPosition; }
 
    ENGINE_API void UpdateWeight(float DeltaTime);
 
#if WITH_EDITOR 
    ENGINE_API void EditorOnly_PreAdvance();
#endif
 
    ENGINE_API bool SimulateAdvance(float DeltaTime, float& InOutPosition, struct FRootMotionMovementParams & OutRootMotionParams) const;
    ENGINE_API void Advance(float DeltaTime, struct FRootMotionMovementParams * OutRootMotionParams, bool bBlendRootMotion);
 
    ENGINE_API FName GetCurrentSection() const;
    ENGINE_API FName GetNextSection() const;
    ENGINE_API int32 GetNextSectionID(int32 const & CurrentSectionID) const;
    ENGINE_API FName GetSectionNameFromID(int32 const & SectionID) const;
 
    // reference has to be managed manually
    ENGINE_API void AddReferencedObjects( FReferenceCollector& Collector );
 
    ENGINE_API void HandleEvents(float PreviousTrackPos, float CurrentTrackPos, const FBranchingPointMarker* BranchingPointMarker);
 
private:
    ENGINE_API void OnMontagePositionChanged(FName const & ToSectionName);
    
    ENGINE_API bool UpdateActiveStateBranchingPoints(float CurrentTrackPosition);
 
    ENGINE_API void BranchingPointEventHandler(const FBranchingPointMarker* BranchingPointMarker);
    ENGINE_API void RefreshNextPrevSections();
 
    ENGINE_API float GetRemainingPlayTimeToSectionEnd(const FMontageSubStepper& MontageSubStepper) const;
 
public:
    static ENGINE_API UAnimMontage* SetSequencerMontagePosition(FName SlotName, USkeletalMeshComponent* SkeletalMeshComponent, int32& InOutInstanceId, UAnimSequenceBase* InAnimSequence, float InFromPosition, float InToPosition, float Weight, bool bLooping, bool bPlaying);
    static ENGINE_API UAnimMontage* PreviewSequencerMontagePosition(FName SlotName, USkeletalMeshComponent* SkeletalMeshComponent, int32& InOutInstanceId, UAnimSequenceBase* InAnimSequence, float InFromPosition, float InToPosition, float Weight, bool bLooping, bool bFireNotifies, bool bPlaying);
    static ENGINE_API UAnimMontage* SetSequencerMontagePosition(FName SlotName, UAnimInstance* AnimInstance, int32& InOutInstanceId, UAnimSequenceBase* InAnimSequence, float InFromPosition, float InToPosition, float Weight, bool bLooping, bool bPlaying);
    static ENGINE_API UAnimMontage* PreviewSequencerMontagePosition(FName SlotName, USkeletalMeshComponent* SkeletalMeshComponent, UAnimInstance* AnimInstance, int32& InOutInstanceId, UAnimSequenceBase* InAnimSequence, float InFromPosition, float InToPosition, float Weight, bool bLooping, bool bFireNotifies, bool bPlaying);
};
 
UCLASS(config=Engine, hidecategories=(UObject, Length), MinimalAPI, BlueprintType, meta= (LoadBehavior = "LazyOnDemand"))
class UAnimMontage : public UAnimCompositeBase
{
    GENERATED_UCLASS_BODY()
 
    friend struct FAnimMontageInstance;
    friend class UAnimMontageFactory;
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = BlendOption)
    EMontageBlendMode BlendModeIn;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = BlendOption)
    EMontageBlendMode BlendModeOut;
 
    UPROPERTY(EditAnywhere, Category=BlendOption)
    FAlphaBlend BlendIn;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    float BlendInTime_DEPRECATED;
#endif
 
    UPROPERTY(EditAnywhere, Category=BlendOption)
    FAlphaBlend BlendOut;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    float BlendOutTime_DEPRECATED;
#endif
 
    UPROPERTY(EditAnywhere, Category = BlendOption)
    float BlendOutTriggerTime;
 
    UFUNCTION(BlueprintPure, Category = "Montage")
    FAlphaBlendArgs GetBlendInArgs() const { return FAlphaBlendArgs(BlendIn); }
 
    UFUNCTION(BlueprintPure, Category = "Montage")
    FAlphaBlendArgs GetBlendOutArgs() const { return FAlphaBlendArgs(BlendOut); }
 
    UFUNCTION(BlueprintPure, Category = "Montage")
    float GetDefaultBlendInTime() const { return BlendIn.GetBlendTime(); }
 
    UFUNCTION(BlueprintCallable, Category = "Montage")
    float GetDefaultBlendOutTime() const { return BlendOut.GetBlendTime(); }
 
    UPROPERTY(EditAnywhere, Category = SyncGroup)
    FName SyncGroup;
 
    UPROPERTY(EditAnywhere, Category = SyncGroup)
    int32 SyncSlotIndex;
 
    UPROPERTY()
    struct FMarkerSyncData  MarkerData;
 
    // composite section. 
    UPROPERTY()
    TArray<FCompositeSection> CompositeSections;
    
    // slot data, each slot contains anim track
    UPROPERTY()
    TArray<struct FSlotAnimationTrack> SlotAnimTracks;
 
#if WITH_EDITORONLY_DATA
    // Remove this when VER_UE4_MONTAGE_BRANCHING_POINT_REMOVAL is removed.
    UPROPERTY()
    TArray<struct FBranchingPoint> BranchingPoints_DEPRECATED;
#endif
 
    UPROPERTY()
    bool bEnableRootMotionTranslation;
 
    UPROPERTY()
    bool bEnableRootMotionRotation;
 
    UPROPERTY(EditAnywhere, Category = BlendOption)
    bool bEnableAutoBlendOut;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = BlendOption, meta = (UseAsBlendProfile = true))
    TObjectPtr<UBlendProfile> BlendProfileIn;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = BlendOption, meta = (UseAsBlendProfile = true))
    TObjectPtr<UBlendProfile> BlendProfileOut;
 
    UPROPERTY()
    TEnumAsByte<ERootMotionRootLock::Type> RootMotionRootLock;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, Category = AdditiveSettings)
    TObjectPtr<UAnimSequence> PreviewBasePose;
#endif // WITH_EDITORONLY_DATA
 
    // Add new slot track to this montage
    ENGINE_API FSlotAnimationTrack& AddSlot(FName SlotName);
 
    ENGINE_API bool IsValidSlot(FName InSlotName) const;
 
    UFUNCTION(BlueprintPure, Category = "Montage")
    ENGINE_API bool IsDynamicMontage() const;
 
    UFUNCTION(BlueprintPure, Category = "Montage")
    ENGINE_API UAnimSequenceBase* GetFirstAnimReference() const;
 
public:
    //~ Begin UObject Interface
#if WITH_EDITORONLY_DATA
    virtual void Serialize(FArchive& Ar) override;
#endif // WITH_EDITORONLY_DATA
    virtual void PostLoad() override;
    virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
 
    virtual FFrameRate GetSamplingFrameRate() const override;
 
    // Gets the sequence length of the montage by calculating it from the lengths of the segments in the montage
    ENGINE_API float CalculateSequenceLength();
 
#if WITH_EDITOR
    virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif // WITH_EDITOR
    virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
    //~ End UObject Interface
 
    //~ Begin AnimSequenceBase Interface
    virtual bool IsValidAdditive() const override;
#if WITH_EDITOR
    virtual EAnimEventTriggerOffsets::Type CalculateOffsetForNotify(float NotifyDisplayTime) const override;
#endif // WITH_EDITOR
    virtual void GetMarkerIndicesForTime(float CurrentTime, bool bLooping, const TArray<FName>& ValidMarkerNames, FMarkerPair& OutPrevMarker, FMarkerPair& OutNextMarker) const override;
    UE_DEPRECATED(5.0, "Use other GetMarkerSyncPositionfromMarkerIndicies signature")
    virtual FMarkerSyncAnimPosition GetMarkerSyncPositionfromMarkerIndicies(int32 PrevMarker, int32 NextMarker, float CurrentTime) const { return UAnimMontage::GetMarkerSyncPositionFromMarkerIndicies(PrevMarker, NextMarker, CurrentTime, nullptr); }
    virtual FMarkerSyncAnimPosition GetMarkerSyncPositionFromMarkerIndicies(int32 PrevMarker, int32 NextMarker, float CurrentTime, const UMirrorDataTable* MirrorTable) const override;
    virtual void TickAssetPlayer(FAnimTickRecord& Instance, struct FAnimNotifyQueue& NotifyQueue, FAnimAssetTickContext& Context) const override;
    virtual TArray<FName>* GetUniqueMarkerNames() override { return &MarkerData.UniqueMarkerNames; }
    virtual void RefreshCacheData() override;
    virtual bool CanBeUsedInComposition() const { return false; }
    virtual void GetAnimationPose(FAnimationPoseData& OutPoseData, const FAnimExtractContext& ExtractionContext) const override { check(false); /* Should never be called, montages dont use this API */ }
    //~ End AnimSequenceBase Interface
 
#if WITH_EDITOR
    //~ Begin UAnimationAsset Interface
    virtual bool GetAllAnimationSequencesReferred(TArray<UAnimationAsset*>& AnimationAssets, bool bRecursive = true) override;
    virtual void ReplaceReferredAnimations(const TMap<UAnimationAsset*, UAnimationAsset*>& ReplacementMap) override;
    //~ End UAnimationAsset Interface
 
    ENGINE_API void UpdateLinkableElements();
 
    ENGINE_API void UpdateLinkableElements(int32 SlotIdx, int32 SegmentIdx);
#endif
    UFUNCTION(BlueprintPure, Category = "Montage")
    bool IsValidAdditiveSlot(const FName& SlotNodeName) const;
 
    ENGINE_API FCompositeSection& GetAnimCompositeSection(int32 SectionIndex);
    ENGINE_API const FCompositeSection& GetAnimCompositeSection(int32 SectionIndex) const;
 
    // @todo document
    ENGINE_API void GetSectionStartAndEndTime(int32 SectionIndex, float& OutStartTime, float& OutEndTime) const;
    
    // @todo document
    ENGINE_API float GetSectionLength(int32 SectionIndex) const;
    
    UFUNCTION(BlueprintPure, Category = "Montage")
    ENGINE_API int32 GetSectionIndex(FName InSectionName) const;
    
    UFUNCTION(BlueprintPure, Category = "Montage")
    ENGINE_API FName GetSectionName(int32 SectionIndex) const;
 
    UFUNCTION(BlueprintPure, Category = "Montage")
    int32 GetNumSections() const { return CompositeSections.Num(); }
 
    UFUNCTION(BlueprintCallable, Category = "Montage")
    ENGINE_API bool IsValidSectionName(FName InSectionName) const;
 
    // @todo document
    ENGINE_API bool IsValidSectionIndex(int32 SectionIndex) const;
 
    ENGINE_API int32 GetSectionIndexFromPosition(float Position) const;
    
    ENGINE_API const TArray<class UAnimMetaData*> GetSectionMetaData(FName SectionName, bool bIncludeSequence=true, FName SlotName = NAME_None);
 
    ENGINE_API int32 GetAnimCompositeSectionIndexFromPos(float CurrentTime, float& PosWithinCompositeSection) const;
 
    ENGINE_API float GetSectionTimeLeftFromPos(float Position);
 
    float CalculatePos(FCompositeSection &Section, float PosWithinCompositeSection) const;
    
    ENGINE_API const FAnimTrack* GetAnimationData(FName SlotName) const;
 
    virtual bool HasRootMotion() const override;
 
    ENGINE_API FTransform ExtractRootMotionFromTrackRange(float StartTrackPosition, float EndTrackPosition, const FAnimExtractContext& Context) const;
 
    UE_DEPRECATED(5.6, "Use ExtractRootMotionFromTrackRange with FAnimExtractContext")
    FTransform ExtractRootMotionFromTrackRange(float StartTrackPosition, float EndTrackPosition) const { const FAnimExtractContext Context; return ExtractRootMotionFromTrackRange(StartTrackPosition, EndTrackPosition, Context); }
 
    UFUNCTION(BlueprintPure, Category = "Montage")
    ENGINE_API FName GetGroupName() const;
 
    bool HasValidSlotSetup() const;
 
private:
    bool IsWithinPos(int32 FirstIndex, int32 SecondIndex, float CurrentTime) const;
 
    EAnimEventTriggerOffsets::Type CalculateOffsetFromSections(float Time) const;
 
 
public:
#if WITH_EDITOR
    ENGINE_API int32 AddAnimCompositeSection(FName InSectionName, float StartPos);
    
    ENGINE_API bool DeleteAnimCompositeSection(int32 SectionIndex);
 
private:
    void SortAnimCompositeSectionByPos();
 
    virtual void RefreshParentAssetData() override;
    
    void PropagateChanges();
 
private:
    DECLARE_MULTICAST_DELEGATE(FOnMontageChangedMulticaster);
    FOnMontageChangedMulticaster OnMontageChanged;
 
public:
    typedef FOnMontageChangedMulticaster::FDelegate FOnMontageChanged;
 
    ENGINE_API void RegisterOnMontageChanged(const FOnMontageChanged& Delegate);
    ENGINE_API void UnregisterOnMontageChanged(FDelegateUserObject Unregister);
#endif  //WITH_EDITOR
 
private:
 
    void ConvertBranchingPointsToAnimNotifies();
    void RefreshBranchingPointMarkers();
    void AddBranchingPointMarker(FBranchingPointMarker Marker, TMap<float, FAnimNotifyEvent*>& TriggerTimes);
    
    UPROPERTY()
    TArray<FBranchingPointMarker> BranchingPointMarkers;
public:
 
    UPROPERTY()
    TArray<int32> BranchingPointStateNotifyIndices;
 
    const FBranchingPointMarker* FindFirstBranchingPointMarker(float StartTrackPos, float EndTrackPos) const;
    
    UE_DEPRECATED(4.19, "Use the GetAnimNotifiesFromTrackPositions that takes FAnimNotifyEventReferences instead")
    void FilterOutNotifyBranchingPoints(TArray<const FAnimNotifyEvent*>& InAnimNotifies);
 
    void FilterOutNotifyBranchingPoints(TArray<FAnimNotifyEventReference>& InAnimNotifies);
 
    bool CanUseMarkerSync() const { return MarkerData.AuthoredSyncMarkers.Num() > 0; }
 
    // update markers
    void CollectMarkers();
 
    //~Begin UAnimCompositeBase Interface
    virtual void InvalidateRecursiveAsset() override;
    virtual bool ContainRecursive(TArray<UAnimCompositeBase*>& CurrentAccumulatedList) override;
    virtual void SetCompositeLength(float InLength) override;
#if WITH_EDITOR
    virtual void PopulateWithExistingModel(TScriptInterface<IAnimationDataModel> ExistingDataModel) override;
#endif // WITH_EDITOR
    //~End UAnimCompositeBase Interface
 
    ENGINE_API static UAnimMontage* CreateSlotAnimationAsDynamicMontage(UAnimSequenceBase* Asset, FName SlotNodeName, float BlendInTime = 0.25f, float BlendOutTime = 0.25f, float InPlayRate = 1.f, int32 LoopCount = 1, float BlendOutTriggerTime = -1.f, float InTimeToStartMontageAt = 0.f);
 
    UFUNCTION(BlueprintCallable, Category = "Animation")
    static ENGINE_API UAnimMontage* CreateSlotAnimationAsDynamicMontage_WithBlendSettings(UAnimSequenceBase* Asset, FName SlotNodeName, const FMontageBlendSettings& BlendInSettings, const FMontageBlendSettings& BlendOutSettings, float InPlayRate = 1.f, int32 LoopCount = 1, float InBlendOutTriggerTime = -1.f);
 
    ENGINE_API static UAnimMontage* CreateSlotAnimationAsDynamicMontage_WithFractionalLoops(UAnimSequenceBase* Asset, FName SlotNodeName, float BlendInTime = 0.25f, float BlendOutTime = 0.25f, float LoopCount = 1.0f, float BlendOutTriggerTime = -1.f);
 
    //~Begin Time Stretch Curve
public:
 
    UPROPERTY(EditAnywhere, Category = TimeStretchCurve)
    FTimeStretchCurve TimeStretchCurve;
 
    UPROPERTY(EditAnywhere, Category = TimeStretchCurve)
    FName TimeStretchCurveName;
 
private:
#if WITH_EDITOR
    void BakeTimeStretchCurve();
    //~End Time Stretch Curve
    virtual void UpdateCommonTargetFrameRate() override;
#endif // WITH_EDITOR
};