AnimInstance.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/AnimTypes.h"
#include "Animation/AnimationAsset.h"
#include "Animation/AnimNotifyQueue.h"
#include "Animation/AnimSubsystemInstance.h"
#include "Animation/AnimSync.h"
#include "Animation/AnimNotifies/AnimNotify.h"
#include "Animation/AnimInertializationRequest.h"
#include "AnimInstance.generated.h"
 
// Post Compile Validation requires WITH_EDITOR
#define ANIMINST_PostCompileValidation WITH_EDITOR
 
struct FDisplayDebugManager;
class FDebugDisplayInfo;
class IAnimClassInterface;
class UAnimInstance;
class UCanvas;
class USkeletalMeshComponent;
class USkeleton;
struct FAlphaBlend;
struct FAlphaBlendArgs;
struct FAnimInstanceProxy;
struct FAnimMontageInstance;
struct FAnimationEvaluationContext;
struct FAnimNode_AssetPlayerBase;
struct FAnimNode_AssetPlayerRelevancyBase;
struct FAnimNode_StateMachine;
struct FAnimNode_LinkedInputPose;
struct FBakedAnimationStateMachine;
struct FCompactPose;
struct FCurveEvaluationOption;
class FCompilerResultsLog;
struct FBlendedHeapCurve;
struct FBoneContainer;
struct FSmartNameMapping;
struct FAnimNode_LinkedAnimLayer;
struct FNodeDebugData;
enum class ETransitionRequestQueueMode : uint8;
enum class ETransitionRequestOverwriteMode : uint8;
class UAnimMontage;
 
typedef TArray<FTransform> FTransformArrayA2;
 
namespace UE::Anim
{
    struct FHeapAttributeContainer;
    // DEPRECATED use FInertializationRequest instead
    using FSlotInertializationRequest = TPair<float, const UBlendProfile*>;
    struct FCurveFilterSettings;
}   // namespace UE::Anim
 
struct FParallelEvaluationData
{
    FBlendedHeapCurve& OutCurve;
    FCompactPose& OutPose;
    UE::Anim::FHeapAttributeContainer& OutAttributes;
};
 
UENUM()
enum class EMontagePlayReturnType : uint8
{
    //Return value is the length of the montage (in seconds)
    MontageLength,
    //Return value is the play duration of the montage (length / play rate, in seconds)
    Duration,
};
 
DECLARE_DELEGATE_OneParam(FOnMontageStarted, UAnimMontage*)
DECLARE_DELEGATE_TwoParams(FOnMontageEnded, UAnimMontage*, bool /*bInterrupted*/)
DECLARE_DELEGATE_TwoParams(FOnMontageBlendingOutStarted, UAnimMontage*, bool /*bInterrupted*/)
DECLARE_DELEGATE_OneParam(FOnMontageBlendedInEnded, UAnimMontage*)
DECLARE_DELEGATE_ThreeParams(FOnMontageSectionChanged, UAnimMontage*, FName /*SectionName*/ , bool /*bLooped*/)
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnMontageStartedMCDelegate, UAnimMontage*, Montage);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnMontageEndedMCDelegate, UAnimMontage*, Montage, bool, bInterrupted);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnAllMontageInstancesEndedMCDelegate);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnMontageBlendingOutStartedMCDelegate, UAnimMontage*, Montage, bool, bInterrupted);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnMontageBlendedInEndedMCDelegate, UAnimMontage*, Montage);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FOnMontageSectionChangedMCDelegate, UAnimMontage*, Montage, FName, SectionName, bool, bLooped);
 
DECLARE_DELEGATE_RetVal(bool, FCanTakeTransition);
 
DECLARE_DELEGATE_ThreeParams(FOnGraphStateChanged, const struct FAnimNode_StateMachine& /*Machine*/, int32 /*PrevStateIndex*/, int32 /*NextStateIndex*/);
 
DECLARE_DELEGATE_OneParam(FOnAddCustomAnimationCurves, UAnimInstance*)
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FPlayMontageAnimNotifyDelegate, FName, NotifyName, const FBranchingPointNotifyPayload&, BranchingPointPayload);
 
 
USTRUCT()
struct FA2Pose
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    TArray<FTransform> Bones;
 
    FA2Pose() {}
};
 
USTRUCT()
struct FA2CSPose : public FA2Pose
{
    GENERATED_USTRUCT_BODY()
 
private:
    const struct FBoneContainer* BoneContainer;
 
    UPROPERTY()
    TArray<uint8> ComponentSpaceFlags;
 
public:
    FA2CSPose()
        : BoneContainer(NULL)
    {
    }
 
    ENGINE_API void AllocateLocalPoses(const FBoneContainer& InBoneContainer, const FA2Pose & LocalPose);
 
    ENGINE_API void AllocateLocalPoses(const FBoneContainer& InBoneContainer, const FTransformArrayA2 & LocalBones);
 
    ENGINE_API bool IsValid() const;
 
    ENGINE_API int32 GetParentBoneIndex(const int32 BoneIndex) const;
 
    ENGINE_API FTransform GetLocalSpaceTransform(int32 BoneIndex);
 
    ENGINE_API FTransform GetComponentSpaceTransform(int32 BoneIndex);
 
    ENGINE_API void ConvertToLocalPoses(FA2Pose & LocalPoses) const;
 
private:
    ENGINE_API void CalculateComponentSpaceTransform(int32 Index);
    ENGINE_API void SetComponentSpaceTransform(int32 Index, const FTransform& NewTransform);
 
    ENGINE_API void ConvertBoneToLocalSpace(int32 BoneIndex);
 
 
    ENGINE_API void SetLocalSpaceTransform(int32 Index, const FTransform& NewTransform);
 
    // This is not really best way to protect SetComponentSpaceTransform, but we'd like to make sure that isn't called by anywhere else.
    friend class FAnimationRuntime;
};
 
struct FQueuedMontageBlendingOutEvent
{
    TObjectPtr<class UAnimMontage> Montage;
    bool bInterrupted;
    FOnMontageBlendingOutStarted Delegate;
 
    FQueuedMontageBlendingOutEvent()
        : bInterrupted(false)
    {}
 
    FQueuedMontageBlendingOutEvent(class UAnimMontage* InMontage, bool InbInterrupted, FOnMontageBlendingOutStarted InDelegate)
        : Montage(InMontage)
        , bInterrupted(InbInterrupted)
        , Delegate(InDelegate)
    {}
};
 
struct FQueuedMontageBlendedInEvent
{
    TObjectPtr<class UAnimMontage> Montage;
    FOnMontageBlendedInEnded Delegate;
 
    FQueuedMontageBlendedInEvent(class UAnimMontage* InMontage, FOnMontageBlendedInEnded InDelegate)
        : Montage(InMontage)
        , Delegate(InDelegate)
    {}
};
 
struct FQueuedMontageEndedEvent
{
    TObjectPtr<class UAnimMontage> Montage;
    int32 MontageInstanceID;
    bool bInterrupted;
    FOnMontageEnded Delegate;
 
    FQueuedMontageEndedEvent()
        : MontageInstanceID(INDEX_NONE)
        , bInterrupted(false)
    {}
 
    FQueuedMontageEndedEvent(class UAnimMontage* InMontage, int32 InInstanceID, bool InbInterrupted, FOnMontageEnded InDelegate)
        : Montage(InMontage)
        , MontageInstanceID(InInstanceID)
        , bInterrupted(InbInterrupted)
        , Delegate(InDelegate)
    {}
};
 
struct FQueuedMontageSectionChangedEvent
{
    TObjectPtr<class UAnimMontage> Montage;
    int32 MontageInstanceID;
    FName SectionName;
    bool bLooped;
    FOnMontageSectionChanged Delegate;
 
    FQueuedMontageSectionChangedEvent()
        : Montage(nullptr)
        , MontageInstanceID(INDEX_NONE)
        , SectionName(NAME_None)
        , bLooped(false)
    {}
 
    FQueuedMontageSectionChangedEvent(class UAnimMontage* InMontage, int32 InInstanceID, FName SectionName, bool InbLooped, FOnMontageSectionChanged InDelegate)
        : Montage(InMontage)
        , MontageInstanceID(InInstanceID)
        , SectionName(SectionName)
        , bLooped(InbLooped)
        , Delegate(InDelegate)
    {}
};
 
struct FNativeTransitionBinding
{
    FName MachineName;
 
    FName PreviousStateName;
 
    FName NextStateName;
 
    FCanTakeTransition NativeTransitionDelegate;
 
#if WITH_EDITORONLY_DATA
    FName TransitionName;
#endif
 
    FNativeTransitionBinding(const FName& InMachineName, const FName& InPreviousStateName, const FName& InNextStateName, const FCanTakeTransition& InNativeTransitionDelegate, const FName& InTransitionName = NAME_None)
        : MachineName(InMachineName)
        , PreviousStateName(InPreviousStateName)
        , NextStateName(InNextStateName)
        , NativeTransitionDelegate(InNativeTransitionDelegate)
#if WITH_EDITORONLY_DATA
        , TransitionName(InTransitionName)
#endif
    {
    }
};
 
struct FNativeStateBinding
{
    FName MachineName;
 
    FName StateName;
 
    FOnGraphStateChanged NativeStateDelegate;
 
#if WITH_EDITORONLY_DATA
    FName BindingName;
#endif
 
    FNativeStateBinding(const FName& InMachineName, const FName& InStateName, const FOnGraphStateChanged& InNativeStateDelegate, const FName& InBindingName = NAME_None)
        : MachineName(InMachineName)
        , StateName(InStateName)
        , NativeStateDelegate(InNativeStateDelegate)
#if WITH_EDITORONLY_DATA
        , BindingName(InBindingName)
#endif
    {
    }
};
 
struct FMontageActiveSlotTracker
{
    float MontageLocalWeight;
 
    float NodeGlobalWeight;
 
    //Is the montage slot part of the active graph this tick
    bool  bIsRelevantThisTick;
 
    //Was the montage slot part of the active graph last tick
    bool  bWasRelevantOnPreviousTick;
 
    FMontageActiveSlotTracker()
        : MontageLocalWeight(0.f)
        , NodeGlobalWeight(0.f)
        , bIsRelevantThisTick(false)
        , bWasRelevantOnPreviousTick(false) 
    {}
};
 
UCLASS(transient, Blueprintable, hideCategories=AnimInstance, BlueprintType, Within=SkeletalMeshComponent, MinimalAPI)
class UAnimInstance : public UObject
{
    GENERATED_UCLASS_BODY()
 
    typedef FAnimInstanceProxy ProxyType;
 
    ENGINE_API ~UAnimInstance();
 
    UPROPERTY(transient)
    TObjectPtr<USkeleton> CurrentSkeleton;
 
    // Sets where this blueprint pulls Root Motion from
    UPROPERTY(Category = RootMotion, EditDefaultsOnly)
    TEnumAsByte<ERootMotionMode::Type> RootMotionMode;
 
    UPROPERTY(meta=(BlueprintCompilerGeneratedDefaults))
    uint8 bUseMultiThreadedAnimationUpdate : 1;
 
    UPROPERTY(meta = (BlueprintCompilerGeneratedDefaults))
    uint8 bUsingCopyPoseFromMesh : 1;
 
    uint8 bNeedsUpdate : 1;
 
    uint8 bCreatedByLinkedAnimGraph : 1;
 
    UPROPERTY(EditDefaultsOnly, Category = Notifies)
    uint8 bReceiveNotifiesFromLinkedInstances : 1;
 
    UPROPERTY(EditDefaultsOnly, Category = Notifies)
    uint8 bPropagateNotifiesToLinkedInstances : 1;
 
    UPROPERTY(EditDefaultsOnly, Category = "Montage")
    uint8 bUseMainInstanceMontageEvaluationData: 1;
 
private:
    // Should UpdateAnimation be called
    uint8 bUpdateAnimationEnabled;
 
    UPROPERTY(Transient)
    uint8 bQueueMontageEvents : 1;
 
    uint8 bUninitialized : 1;
    
#if DO_CHECK
    uint8 bInitializing : 1;
 
    bool bPostUpdatingAnimation;
 
    bool bUpdatingAnimation;
#endif
 
public:
 
    // @todo document
    ENGINE_API void MakeMontageTickRecord(FAnimTickRecord& TickRecord, class UAnimMontage* Montage, float MoveDelta, float Weight, TArray<FPassedMarker>& MarkersPassedThisTick, FMarkerTickRecord& MarkerTickRecord);
 
    ENGINE_API float GetSlotNodeGlobalWeight(const FName& SlotNodeName) const;
 
    // Should Extract Root Motion or not. Return true if we do. 
    bool ShouldExtractRootMotion() const { return RootMotionMode == ERootMotionMode::RootMotionFromEverything || RootMotionMode == ERootMotionMode::IgnoreRootMotion; }
 
    ENGINE_API float GetSlotMontageGlobalWeight(const FName& SlotNodeName) const;
 
    ENGINE_API float GetSlotMontageLocalWeight(const FName& SlotNodeName) const;
 
    ENGINE_API float CalcSlotMontageLocalWeight(const FName& SlotNodeName) const;
 
    // kismet event functions
 
    UFUNCTION(BlueprintCallable, Category = "Animation") 
    ENGINE_API virtual APawn* TryGetPawnOwner() const;
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Pose")
    ENGINE_API virtual void SavePoseSnapshot(FName SnapshotName);
 
    ENGINE_API FPoseSnapshot& AddPoseSnapshot(FName SnapshotName);
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Pose")
    ENGINE_API void RemovePoseSnapshot(FName SnapshotName);
 
    ENGINE_API const FPoseSnapshot* GetPoseSnapshot(FName SnapshotName) const;
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Pose")
    ENGINE_API virtual void SnapshotPose(UPARAM(ref) FPoseSnapshot& Snapshot);
    
    ENGINE_API const TMap<FName, FAnimGroupInstance>& GetSyncGroupMapRead() const;
 
    ENGINE_API const TArray<FAnimTickRecord>& GetUngroupedActivePlayersRead();
 
    ENGINE_API const TMap<FName, float>& GetAnimationCurves(EAnimCurveType InCurveType) const;
 
    ENGINE_API void GatherDebugData(FNodeDebugData& DebugData);
 
    // Can this animation instance run Update or Evaluation work in parallel
    virtual bool CanRunParallelWork() const { return true; }
 
    // Are we being evaluated on a worker thread
    ENGINE_API bool IsRunningParallelEvaluation() const;
 
    // Can does this anim instance need an update (parallel or not)?
    ENGINE_API bool NeedsUpdate() const;
 
    // Get whether we have initialized our animation instance or not. This will return false if UninitializeAnimation() has been called.
    ENGINE_API bool IsInitialized() const;
    
    UFUNCTION(BlueprintPure, Category = "Animation|Notifies")
    bool GetReceiveNotifiesFromLinkedInstances() const { return bReceiveNotifiesFromLinkedInstances; }
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Notifies")
    void SetReceiveNotifiesFromLinkedInstances(bool bSet) { bReceiveNotifiesFromLinkedInstances = bSet; }
 
    UFUNCTION(BlueprintPure, Category = "Animation|Notifies")
    bool GetPropagateNotifiesToLinkedInstances() const { return bPropagateNotifiesToLinkedInstances; }
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Notifies")
    void SetPropagateNotifiesToLinkedInstances(bool bSet) { bPropagateNotifiesToLinkedInstances = bSet; }
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Linked Anim Graphs|Montage")
    bool IsUsingMainInstanceMontageEvaluationData() const { return bUseMainInstanceMontageEvaluationData; }
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Linked Anim Graphs|Montage")
    void SetUseMainInstanceMontageEvaluationData(bool bSet) { bUseMainInstanceMontageEvaluationData = bSet; }
 
private:
    // Does this anim instance need immediate update (rather than parallel)?
    ENGINE_API bool NeedsImmediateUpdate(float DeltaSeconds, bool bNeedsValidRootMotion) const;
 
public:
    UFUNCTION(BlueprintCallable, Category = "Animation")
    ENGINE_API AActor* GetOwningActor() const;
    
    // Returns the skeletal mesh component that has created this AnimInstance
    UFUNCTION(BlueprintCallable, Category = "Animation")
    ENGINE_API USkeletalMeshComponent* GetOwningComponent() const;
 
    UFUNCTION(BlueprintCallable, Category = "Animation", meta = (DisplayName="Get Main Anim Instance", BlueprintThreadSafe))
    ENGINE_API UAnimInstance* Blueprint_GetMainAnimInstance() const;
 
public:
 
    UFUNCTION(BlueprintImplementableEvent)
    ENGINE_API void BlueprintInitializeAnimation();
 
    UFUNCTION(BlueprintImplementableEvent)
    ENGINE_API void BlueprintUpdateAnimation(float DeltaTimeX);
 
    UFUNCTION(BlueprintImplementableEvent)
    ENGINE_API void BlueprintPostEvaluateAnimation();
 
    UFUNCTION(BlueprintImplementableEvent)
    ENGINE_API void BlueprintBeginPlay();
 
    UFUNCTION(BlueprintImplementableEvent)
    ENGINE_API void BlueprintLinkedAnimationLayersInitialized();
 
    UFUNCTION(BlueprintImplementableEvent, meta=(BlueprintThreadSafe))
    ENGINE_API void BlueprintThreadSafeUpdateAnimation(float DeltaTime);
 
    ENGINE_API bool CanTransitionSignature() const;
    
    /*********************************************************************************************
    * SlotAnimation
    ********************************************************************************************* */
public:
 
    UFUNCTION(BlueprintCallable, Category="Animation|Montage")
    ENGINE_API UAnimMontage* PlaySlotAnimationAsDynamicMontage(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|Montage")
    ENGINE_API UAnimMontage* PlaySlotAnimationAsDynamicMontage_WithBlendArgs(UAnimSequenceBase* Asset, FName SlotNodeName, const FAlphaBlendArgs& BlendIn, const FAlphaBlendArgs& BlendOut, float InPlayRate = 1.f, int32 LoopCount = 1, float BlendOutTriggerTime = -1.f, float InTimeToStartMontageAt = 0.f);
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Montage")
    ENGINE_API UAnimMontage* PlaySlotAnimationAsDynamicMontage_WithBlendSettings(UAnimSequenceBase* Asset, FName SlotNodeName, const FMontageBlendSettings& BlendInSettings, const FMontageBlendSettings& BlendOutSettings, float InPlayRate = 1.f, int32 LoopCount = 1, float BlendOutTriggerTime = -1.f, float InTimeToStartMontageAt = 0.f);
 
    UFUNCTION(BlueprintCallable, Category="Animation|Montage")
    ENGINE_API void StopSlotAnimation(float InBlendOutTime = 0.25f, FName SlotNodeName = NAME_None);
 
    UFUNCTION(BlueprintPure, Category="Animation|Montage")
    ENGINE_API bool IsPlayingSlotAnimation(const UAnimSequenceBase* Asset, FName SlotNodeName) const;
 
    ENGINE_API bool IsPlayingSlotAnimation(const UAnimSequenceBase* Asset, FName SlotNodeName, UAnimMontage*& OutMontage) const;
 
    UFUNCTION(BlueprintPure, Category="Animation|Montage", meta=(BlueprintThreadSafe))
    ENGINE_API bool IsSlotActive(FName SlotNodeName) const;
    
    UFUNCTION(BlueprintPure, Category="Animation|Montage", meta=(BlueprintThreadSafe, DisplayName="GetSlotLocalWeight"))
    ENGINE_API float Blueprint_GetSlotMontageLocalWeight(FName SlotNodeName) const;
    
    /*********************************************************************************************
     * AnimMontage
     ********************************************************************************************* */
public:
    UFUNCTION(BlueprintCallable, Category = "Animation|Montage")
    ENGINE_API float Montage_Play(UAnimMontage* MontageToPlay, float InPlayRate = 1.f, EMontagePlayReturnType ReturnValueType = EMontagePlayReturnType::MontageLength, float InTimeToStartMontageAt=0.f, bool bStopAllMontages = true);
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Montage")
    ENGINE_API float Montage_PlayWithBlendIn(UAnimMontage* MontageToPlay, const FAlphaBlendArgs& BlendIn, float InPlayRate = 1.f, EMontagePlayReturnType ReturnValueType = EMontagePlayReturnType::MontageLength, float InTimeToStartMontageAt=0.f, bool bStopAllMontages = true);
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Montage")
    ENGINE_API float Montage_PlayWithBlendSettings(UAnimMontage* MontageToPlay, const FMontageBlendSettings& BlendInSettings, float InPlayRate = 1.f, EMontagePlayReturnType ReturnValueType = EMontagePlayReturnType::MontageLength, float InTimeToStartMontageAt=0.f, bool bStopAllMontages = true);
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Montage")
    ENGINE_API void Montage_Stop(float InBlendOutTime, const UAnimMontage* Montage = NULL);
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Montage")
    ENGINE_API void Montage_StopWithBlendOut(const FAlphaBlendArgs& BlendOut, const UAnimMontage* Montage = nullptr);
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Montage")
    ENGINE_API void Montage_StopWithBlendSettings(const FMontageBlendSettings& BlendOutSettings, const UAnimMontage* Montage = nullptr);
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Montage")
    ENGINE_API void Montage_StopGroupByName(float InBlendOutTime, FName GroupName);
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Montage")
    ENGINE_API void Montage_Pause(const UAnimMontage* Montage = NULL);
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Montage")
    ENGINE_API void Montage_Resume(const UAnimMontage* Montage);
 
    UFUNCTION(BlueprintCallable, Category="Animation|Montage")
    ENGINE_API void Montage_JumpToSection(FName SectionName, const UAnimMontage* Montage = NULL);
 
    UFUNCTION(BlueprintCallable, Category="Animation|Montage")
    ENGINE_API void Montage_JumpToSectionsEnd(FName SectionName, const UAnimMontage* Montage = NULL);
 
    UFUNCTION(BlueprintCallable, Category="Animation|Montage")
    ENGINE_API void Montage_SetNextSection(FName SectionNameToChange, FName NextSection, const UAnimMontage* Montage = NULL);
 
    UFUNCTION(BlueprintCallable, Category="Animation|Montage")
    ENGINE_API void Montage_SetPlayRate(const UAnimMontage* Montage, float NewPlayRate = 1.f);
 
    UFUNCTION(BlueprintPure, Category="Animation|Montage")
    ENGINE_API bool Montage_IsActive(const UAnimMontage* Montage) const;
 
    UFUNCTION(BlueprintPure, Category="Animation|Montage")
    ENGINE_API bool Montage_IsPlaying(const UAnimMontage* Montage) const;
 
    UFUNCTION(BlueprintPure, Category="Animation|Montage")
    ENGINE_API FName Montage_GetCurrentSection(const UAnimMontage* Montage = NULL) const;
 
    UFUNCTION(BlueprintPure, Category = "Animation|Montage")
    ENGINE_API float Montage_GetPosition(const UAnimMontage* Montage) const;
    
    UFUNCTION(BlueprintCallable, Category = "Animation|Montage")
    ENGINE_API void Montage_SetPosition(const UAnimMontage* Montage, float NewPosition);
    
    UFUNCTION(BlueprintPure, Category = "Animation|Montage")
    ENGINE_API bool Montage_GetIsStopped(const UAnimMontage* Montage) const;
 
    UFUNCTION(BlueprintPure, Category = "Animation|Montage")
    ENGINE_API float Montage_GetBlendTime(const UAnimMontage* Montage) const;
 
    UFUNCTION(BlueprintPure, Category = "Animation|Montage")
    ENGINE_API float Montage_GetPlayRate(const UAnimMontage* Montage) const;
 
    UFUNCTION(BlueprintPure, Category = "Animation|Montage")
    ENGINE_API float Montage_GetEffectivePlayRate(const UAnimMontage* Montage) const;
 
    UFUNCTION(BlueprintPure, Category = "Animation|Montage")
    ENGINE_API bool DynamicMontage_IsPlayingFrom(const UAnimSequenceBase* Animation) const;
 
    /*********************************************************************************************
    * AnimMontage sync. See notes in AnimMontage.h
    ********************************************************************************************* */
 
    UFUNCTION(BlueprintCallable, Category = "Montage")
    ENGINE_API void MontageSync_Follow(const UAnimMontage* MontageFollower, const UAnimInstance* OtherAnimInstance, const UAnimMontage* MontageLeader);
 
    UFUNCTION(BlueprintCallable, Category = "Montage")
    ENGINE_API void MontageSync_StopFollowing(const UAnimMontage* MontageFollower);
 
    UFUNCTION(BlueprintPure, Category = "Animation|Montage")
    ENGINE_API bool IsAnyMontagePlaying() const;
 
    UFUNCTION(BlueprintPure, Category = "Animation|Montage")
    ENGINE_API UAnimMontage* GetCurrentActiveMontage() const;
 
    UPROPERTY(BlueprintAssignable)
    FOnMontageBlendingOutStartedMCDelegate OnMontageBlendingOut;
 
    UPROPERTY(BlueprintAssignable)
    FOnMontageBlendedInEndedMCDelegate OnMontageBlendedIn;
    
    UPROPERTY(BlueprintAssignable)
    FOnMontageStartedMCDelegate OnMontageStarted;
 
    UPROPERTY(BlueprintAssignable)
    FOnMontageEndedMCDelegate OnMontageEnded;
 
    UPROPERTY(BlueprintAssignable)
    FOnAllMontageInstancesEndedMCDelegate OnAllMontageInstancesEnded;
 
    UPROPERTY(BlueprintAssignable)
    FOnMontageSectionChangedMCDelegate OnMontageSectionChanged;
    
    /*********************************************************************************************
    * AnimMontage native C++ interface
    ********************************************************************************************* */
public: 
    ENGINE_API void Montage_SetEndDelegate(FOnMontageEnded & InOnMontageEnded, UAnimMontage* Montage = NULL);
 
    ENGINE_API FOnMontageEnded* Montage_GetEndedDelegate(UAnimMontage* Montage = nullptr);
    
    ENGINE_API void Montage_SetBlendingOutDelegate(FOnMontageBlendingOutStarted& InOnMontageBlendingOut, UAnimMontage* Montage = NULL);
 
    ENGINE_API void Montage_SetBlendedInDelegate(FOnMontageBlendedInEnded& InOnMontageBlendingIn, UAnimMontage* Montage = nullptr);
    
    ENGINE_API FOnMontageBlendingOutStarted* Montage_GetBlendingOutDelegate(UAnimMontage* Montage = NULL);
 
    ENGINE_API void Montage_SetSectionChangedDelegate(FOnMontageSectionChanged& InOnMontageSectionChanged, UAnimMontage* Montage = NULL);
    
    ENGINE_API FOnMontageSectionChanged* Montage_GetSectionChangedDelegate(UAnimMontage* Montage = NULL);
    
    ENGINE_API int32 Montage_GetNextSectionID(const UAnimMontage* Montage, int32 const & CurrentSectionID) const;
 
    ENGINE_API FAnimMontageInstance* GetActiveMontageInstance() const;
 
    ENGINE_API FAnimMontageInstance* GetActiveInstanceForMontage(const UAnimMontage* Montage) const;
 
    ENGINE_API FAnimMontageInstance* GetInstanceForMontage(const UAnimMontage* Montage) const;
 
    ENGINE_API FAnimMontageInstance* GetMontageInstanceForID(int32 MontageInstanceID);
 
    ENGINE_API void StopAllMontages(float BlendOut);
 
    TArray<struct FAnimMontageInstance*> MontageInstances;
 
    ENGINE_API virtual void OnMontageInstanceStopped(FAnimMontageInstance & StoppedMontageInstance);
    ENGINE_API void ClearMontageInstanceReferences(FAnimMontageInstance& InMontageInstance);
 
    UE_DEPRECATED(4.24, "Function renamed, please use GetLinkedInputPoseNode")
    FAnimNode_LinkedInputPose* GetSubInputNode(FName InSubInput = NAME_None, FName InGraph = NAME_None) { return GetLinkedInputPoseNode(InSubInput, InGraph); }
 
    ENGINE_API FAnimNode_LinkedInputPose* GetLinkedInputPoseNode(FName InSubInput = NAME_None, FName InGraph = NAME_None);
 
    UE_DEPRECATED(4.24, "Function renamed, please use GetLinkedAnimGraphInstanceByTag")
    UAnimInstance* GetSubInstanceByTag(FName InTag) const { return GetLinkedAnimGraphInstanceByTag(InTag); }
 
    UFUNCTION(BlueprintPure, Category = "Animation|Linked Anim Graphs")
    ENGINE_API UAnimInstance* GetLinkedAnimGraphInstanceByTag(FName InTag) const;
 
    UE_DEPRECATED(4.24, "Function renamed, please use GetLinkedAnimGraphInstancesByTag")
    ENGINE_API void GetSubInstancesByTag(FName InTag, TArray<UAnimInstance*>& OutSubInstances) const;
 
    UE_DEPRECATED(5.0, "Tags are unique so this function is no longer supported. Please use GetLinkedAnimGraphInstanceByTag instead")
    UFUNCTION(BlueprintPure, Category = "Animation|Linked Anim Graphs", meta=(DeprecatedFunction, DeprecationMessage="Tags are unique so this function is no longer supported. Please use GetLinkedAnimGraphInstanceByTag instead"))
    ENGINE_API void GetLinkedAnimGraphInstancesByTag(FName InTag, TArray<UAnimInstance*>& OutLinkedInstances) const;
 
    UE_DEPRECATED(4.24, "Function renamed, please use LinkAnimGraphByTag")
    void SetSubInstanceClassByTag(FName InTag, TSubclassOf<UAnimInstance> InClass) { LinkAnimGraphByTag(InTag, InClass); }
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Linked Anim Graphs")
    ENGINE_API void LinkAnimGraphByTag(FName InTag, TSubclassOf<UAnimInstance> InClass);
 
    UE_DEPRECATED(4.24, "Function renamed, please use LinkAnimClassLayers")
    void SetLayerOverlay(TSubclassOf<UAnimInstance> InClass) { LinkAnimClassLayers(InClass); }
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Linked Anim Graphs")
    ENGINE_API virtual void LinkAnimClassLayers(TSubclassOf<UAnimInstance> InClass);
 
    UE_DEPRECATED(4.24, "Function renamed, please use UnlinkAnimClassLayers")
    void ClearLayerOverlay(TSubclassOf<UAnimInstance> InClass) { UnlinkAnimClassLayers(InClass); }
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Linked Anim Graphs")
    ENGINE_API virtual void UnlinkAnimClassLayers(TSubclassOf<UAnimInstance> InClass);
 
    UE_DEPRECATED(4.24, "Function renamed, please use GetLinkedAnimLayerInstanceByGroup")
    UAnimInstance* GetLayerSubInstanceByGroup(FName InGroup) const { return GetLinkedAnimLayerInstanceByGroup(InGroup); }
 
    UFUNCTION(BlueprintPure, Category = "Animation|Linked Anim Graphs")
    ENGINE_API UAnimInstance* GetLinkedAnimLayerInstanceByGroup(FName InGroup) const;
 
    UFUNCTION(BlueprintPure, Category = "Animation|Linked Anim Graphs")
    ENGINE_API void GetLinkedAnimLayerInstancesByGroup(FName InGroup, TArray<UAnimInstance*>& OutLinkedInstances) const;
 
    UFUNCTION(BlueprintPure, Category = "Animation|Linked Anim Graphs")
    ENGINE_API UAnimInstance* GetLinkedAnimLayerInstanceByGroupAndClass(FName InGroup, TSubclassOf<UAnimInstance> InClass) const;
 
    UE_DEPRECATED(4.24, "Function renamed, please use GetLinkedAnimLayerInstanceByClass")
    UAnimInstance* GetLayerSubInstanceByClass(TSubclassOf<UAnimInstance> InClass) const { return GetLinkedAnimLayerInstanceByClass(InClass); }
 
    UFUNCTION(BlueprintPure, Category = "Animation|Linked Anim Graphs")
    ENGINE_API UAnimInstance* GetLinkedAnimLayerInstanceByClass(TSubclassOf<UAnimInstance> InClass, bool bCheckForChildClass = false) const;
 
    ENGINE_API void InitializeGroupedLayers(bool bInDeferSubGraphInitialization);
 
    ENGINE_API void AddExternalNotifyHandler(UObject* ExternalHandlerObject, FName NotifyEventName);
    ENGINE_API void RemoveExternalNotifyHandler(UObject* ExternalHandlerObject, FName NotifyEventName);
 
    // Find a subsystem's instance-resident data. If no subsystem of the type exists this will return nullptr.
    // @param   InSubsystemType The subsystem's type
    ENGINE_API FAnimSubsystemInstance* FindSubsystem(UScriptStruct* InSubsystemType);
 
    // Get a subsystem's instance-resident data. If no subsystem of the type exists this will return nullptr.
    template<typename SubsystemType>
    SubsystemType* FindSubsystem()
    {
        FAnimSubsystemInstance* Subsystem = FindSubsystem(SubsystemType::StaticStruct());
        return static_cast<SubsystemType*>(Subsystem);
    }
    
    // Get a subsystem's instance-resident data. If no subsystem of the type exists this will assert.
    template<typename SubsystemType>
    SubsystemType& GetSubsystem()
    {
        FAnimSubsystemInstance* Subsystem = FindSubsystem(SubsystemType::StaticStruct());
        check(Subsystem);
        return static_cast<SubsystemType&>(*Subsystem);
    }
 
private:
    ENGINE_API void PerformLinkedLayerOverlayOperation(TSubclassOf<UAnimInstance> InClass, TFunctionRef<UClass*(UClass*, FAnimNode_LinkedAnimLayer*)> InClassSelectorFunction, bool bInDeferSubGraphInitialization = false);
 
protected:
    TMap<class UAnimMontage*, struct FAnimMontageInstance*> ActiveMontagesMap;
    
 
    UE_DEPRECATED(5.5, "This property is deprecated. Please use SlotGroupInertializationRequestDataMap instead")
    TMap<FName, UE::Anim::FSlotInertializationRequest> SlotGroupInertializationRequestMap;
 
    UPROPERTY(Transient)
    TMap<FName, FInertializationRequest> SlotGroupInertializationRequestDataMap;
 
    /* StopAllMontagesByGroupName needs a BlendMode and BlendProfile to function properly if using non-default ones in your montages. If you want default BlendMode/BlendProfiles, you need to update the calling code to do so. */
    UE_DEPRECATED(5.0, "Use StopAllMontagesByGroupName with other signature.")
    ENGINE_API void StopAllMontagesByGroupName(FName InGroupName, const FAlphaBlend& BlendOut);
 
    ENGINE_API void StopAllMontagesByGroupName(FName InGroupName, const FMontageBlendSettings& BlendOutSettings);
 
    ENGINE_API virtual void Montage_UpdateWeight(float DeltaSeconds);
    ENGINE_API virtual void Montage_Advance(float DeltaSeconds);
 
    ENGINE_API void Montage_StopInternal(TFunctionRef<FMontageBlendSettings(const FAnimMontageInstance*)> AlphaBlendSelectorFunction, const UAnimMontage* Montage = nullptr);
    ENGINE_API virtual float Montage_PlayInternal(UAnimMontage* MontageToPlay, const FMontageBlendSettings& BlendInSettings, float InPlayRate = 1.f, EMontagePlayReturnType ReturnValueType = EMontagePlayReturnType::MontageLength, float InTimeToStartMontageAt = 0.f, bool bStopAllMontages = true);
 
public:
 
    ENGINE_API void ConditionalFlushCompletedMontages();
 
    ENGINE_API void RequestMontageInertialization(const UAnimMontage* Montage, float Duration, const UBlendProfile* BlendProfile = nullptr);
 
    ENGINE_API void RequestMontageInertialization(const UAnimMontage* Montage, const FInertializationRequest& Request);
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Inertial Blending")
    ENGINE_API void RequestSlotGroupInertialization(FName InSlotGroupName, float Duration, const UBlendProfile* BlendProfile = nullptr);
 
    ENGINE_API void QueueMontageBlendingOutEvent(const FQueuedMontageBlendingOutEvent& MontageBlendingOutEvent);
 
    ENGINE_API void QueueMontageBlendedInEvent(const FQueuedMontageBlendedInEvent& MontageBlendedInEvent);
 
    ENGINE_API void QueueMontageEndedEvent(const FQueuedMontageEndedEvent& MontageEndedEvent);
 
    ENGINE_API void QueueMontageSectionChangedEvent(const FQueuedMontageSectionChangedEvent& MontageSectionChangedEvent);
    
private:
    ENGINE_API void TriggerQueuedMontageEvents();
 
    TArray<FQueuedMontageBlendingOutEvent> QueuedMontageBlendingOutEvents;
 
    TArray<FQueuedMontageBlendedInEvent> QueuedMontageBlendedInEvents;
 
    TArray<FQueuedMontageEndedEvent> QueuedMontageEndedEvents;
 
    TArray<FQueuedMontageSectionChangedEvent> QueuedMontageSectionChangedEvents;
    
    ENGINE_API void TriggerMontageBlendingOutEvent(const FQueuedMontageBlendingOutEvent& MontageBlendingOutEvent);
 
    ENGINE_API void TriggerMontageBlendedInEvent(const FQueuedMontageBlendedInEvent& MontageBlendedInEvent);
 
    ENGINE_API void TriggerMontageEndedEvent(const FQueuedMontageEndedEvent& MontageEndedEvent);
 
    ENGINE_API void TriggerMontageSectionChangedEvent(const FQueuedMontageSectionChangedEvent& MontageSectionChangedEvent);
    
public:
 
#if DO_CHECK
    bool IsPostUpdatingAnimation() const { return bPostUpdatingAnimation; }
 
    bool IsUpdatingAnimation() const { return bUpdatingAnimation; }
#endif
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Root Motion")
    ENGINE_API void SetRootMotionMode(TEnumAsByte<ERootMotionMode::Type> Value);
 
    UFUNCTION(BlueprintPure, Category="Animation|Asset Player", meta=(DisplayName="Length", BlueprintInternalUseOnly="true", AnimGetter="true", BlueprintThreadSafe))
    ENGINE_API float GetInstanceAssetPlayerLength(int32 AssetPlayerIndex);
 
    UFUNCTION(BlueprintPure, Category="Animation|Asset Player", meta = (DisplayName = "Current Time", BlueprintInternalUseOnly = "true", AnimGetter = "true", BlueprintThreadSafe))
    ENGINE_API float GetInstanceAssetPlayerTime(int32 AssetPlayerIndex);
 
    UFUNCTION(BlueprintPure, Category="Animation|Asset Player", meta=(DisplayName="Current Time (ratio)", BlueprintInternalUseOnly="true", AnimGetter="true", BlueprintThreadSafe))
    ENGINE_API float GetInstanceAssetPlayerTimeFraction(int32 AssetPlayerIndex);
 
    UFUNCTION(BlueprintPure, Category="Animation|Asset Player", meta=(DisplayName="Time Remaining", BlueprintInternalUseOnly="true", AnimGetter="true", BlueprintThreadSafe))
    ENGINE_API float GetInstanceAssetPlayerTimeFromEnd(int32 AssetPlayerIndex);
 
    UFUNCTION(BlueprintPure, Category="Animation|Asset Player", meta=(DisplayName="Time Remaining (ratio)", BlueprintInternalUseOnly="true", AnimGetter="true", BlueprintThreadSafe))
    ENGINE_API float GetInstanceAssetPlayerTimeFromEndFraction(int32 AssetPlayerIndex);
 
    UFUNCTION(BlueprintPure, Category = "Animation|State Machines", meta = (DisplayName = "Machine Weight", BlueprintInternalUseOnly = "true", AnimGetter = "true", BlueprintThreadSafe))
    ENGINE_API float GetInstanceMachineWeight(int32 MachineIndex);
 
    UFUNCTION(BlueprintPure, Category="Animation|State Machines", meta = (DisplayName="State Weight", BlueprintInternalUseOnly = "true", AnimGetter="true", BlueprintThreadSafe))
    ENGINE_API float GetInstanceStateWeight(int32 MachineIndex, int32 StateIndex);
 
    UFUNCTION(BlueprintPure, Category="Animation|State Machines", meta = (DisplayName="Current State Time", BlueprintInternalUseOnly = "true", AnimGetter="true", GetterContext="Transition", BlueprintThreadSafe))
    ENGINE_API float GetInstanceCurrentStateElapsedTime(int32 MachineIndex);
 
    UFUNCTION(BlueprintPure, Category="Animation|State Machines", meta = (DisplayName="Get Transition Crossfade Duration", BlueprintInternalUseOnly = "true", AnimGetter="true", BlueprintThreadSafe))
    ENGINE_API float GetInstanceTransitionCrossfadeDuration(int32 MachineIndex, int32 TransitionIndex);
 
    UFUNCTION(BlueprintPure, Category="Animation|State Machines", meta = (DisplayName="Get Transition Time Elapsed", BlueprintInternalUseOnly = "true", AnimGetter="true", GetterContext="CustomBlend", BlueprintThreadSafe))
    ENGINE_API float GetInstanceTransitionTimeElapsed(int32 MachineIndex, int32 TransitionIndex);
 
    UFUNCTION(BlueprintPure, Category="Animation|State Machines", meta = (DisplayName="Get Transition Time Elapsed (ratio)", BlueprintInternalUseOnly = "true", AnimGetter="true", GetterContext="CustomBlend", BlueprintThreadSafe))
    ENGINE_API float GetInstanceTransitionTimeElapsedFraction(int32 MachineIndex, int32 TransitionIndex);
 
    UFUNCTION(BlueprintPure, Category="Animation|State Machines", meta = (BlueprintInternalUseOnly = "true", AnimGetter="true", GetterContext="Transition", BlueprintThreadSafe))
    ENGINE_API float GetRelevantAnimTimeRemaining(int32 MachineIndex, int32 StateIndex);
 
    UFUNCTION(BlueprintPure, Category = "Animation|State Machines", meta = (BlueprintInternalUseOnly = "true", AnimGetter = "true", GetterContext = "Transition", BlueprintThreadSafe))
    ENGINE_API float GetRelevantAnimTimeRemainingFraction(int32 MachineIndex, int32 StateIndex);
 
    UFUNCTION(BlueprintPure, Category = "Animation|State Machines", meta = (BlueprintInternalUseOnly = "true", AnimGetter = "true", GetterContext = "Transition", BlueprintThreadSafe))
    ENGINE_API float GetRelevantAnimLength(int32 MachineIndex, int32 StateIndex);
 
    UFUNCTION(BlueprintPure, Category = "Animation|State Machines", meta = (BlueprintInternalUseOnly = "true", AnimGetter = "true", GetterContext = "Transition", BlueprintThreadSafe))
    ENGINE_API float GetRelevantAnimTime(int32 MachineIndex, int32 StateIndex);
 
    UFUNCTION(BlueprintPure, Category = "Animation|State Machines", meta = (BlueprintInternalUseOnly = "true", AnimGetter = "true", GetterContext = "Transition", BlueprintThreadSafe))
    ENGINE_API float GetRelevantAnimTimeFraction(int32 MachineIndex, int32 StateIndex);
 
    UFUNCTION(BlueprintPure, Category = "Animation|State Machines", meta = (BlueprintThreadSafe, Keywords = "Window,TransitionWindow,NotifyState,NotifyStateTransition"))
    ENGINE_API bool WasAnimNotifyStateActiveInAnyState(TSubclassOf<UAnimNotifyState> AnimNotifyStateType);
 
    UFUNCTION(BlueprintPure, Category = "Animation|State Machines", meta = (BlueprintInternalUseOnly = "true", AnimGetter = "true", GetterContext = "Transition", BlueprintThreadSafe, Keywords = "Window,TransitionWindow,NotifyState,NotifyStateTransition"))
    ENGINE_API bool WasAnimNotifyStateActiveInStateMachine(int32 MachineIndex, TSubclassOf<UAnimNotifyState> AnimNotifyStateType);
 
    UFUNCTION(BlueprintPure, Category = "Animation|State Machines", meta = (BlueprintInternalUseOnly = "true", AnimGetter = "true", GetterContext = "Transition", BlueprintThreadSafe, Keywords = "Window,TransitionWindow,NotifyState,NotifyStateTransition"))
    ENGINE_API bool WasAnimNotifyStateActiveInSourceState(int32 MachineIndex, int32 StateIndex, TSubclassOf<UAnimNotifyState> AnimNotifyStateType);
 
    UFUNCTION(BlueprintPure, Category = "Animation|State Machines", meta = (BlueprintInternalUseOnly = "true", AnimGetter = "true", GetterContext = "Transition", BlueprintThreadSafe, Keywords = "Window,TransitionWindow,NotifyState,NotifyStateTransition"))
    ENGINE_API bool WasAnimNotifyTriggeredInSourceState(int32 MachineIndex, int32 StateIndex,  TSubclassOf<UAnimNotify> AnimNotifyType);
 
    UFUNCTION(BlueprintPure, Category = "Animation|State Machines", meta = (BlueprintInternalUseOnly = "true", AnimGetter = "true", GetterContext = "Transition", BlueprintThreadSafe, Keywords = "Window,TransitionWindow,NotifyState,NotifyStateTransition"))
    ENGINE_API bool WasAnimNotifyNameTriggeredInSourceState(int32 MachineIndex, int32 StateIndex, FName NotifyName);
 
    UFUNCTION(BlueprintPure, Category = "Animation|State Machines", meta = (BlueprintInternalUseOnly = "true", AnimGetter = "true", GetterContext = "Transition", BlueprintThreadSafe, Keywords = "Window,TransitionWindow,NotifyState,NotifyStateTransition"))
    ENGINE_API bool WasAnimNotifyTriggeredInStateMachine(int32 MachineIndex, TSubclassOf<UAnimNotify> AnimNotifyType);
 
    UFUNCTION(BlueprintPure, Category = "Animation|State Machines", meta = (BlueprintInternalUseOnly = "true", AnimGetter = "true", GetterContext = "Transition", BlueprintThreadSafe, Keywords = "Window,TransitionWindow,NotifyState,NotifyStateTransition"))
    ENGINE_API bool WasAnimNotifyNameTriggeredInStateMachine(int32 MachineIndex, FName NotifyName);
    
    UFUNCTION(BlueprintPure, Category = "Animation|State Machines", meta = (BlueprintInternalUseOnly = "true", AnimGetter = "true", GetterContext = "Transition", BlueprintThreadSafe, Keywords = "Window,TransitionWindow,NotifyState,NotifyStateTransition"))
    ENGINE_API bool WasAnimNotifyTriggeredInAnyState(TSubclassOf<UAnimNotify> AnimNotifyType);
 
    UFUNCTION(BlueprintPure, Category = "Animation|State Machines", meta = (BlueprintInternalUseOnly = "true", AnimGetter = "true", GetterContext = "Transition", BlueprintThreadSafe, Keywords = "Window,TransitionWindow,NotifyState,NotifyStateTransition"))
    ENGINE_API bool WasAnimNotifyNameTriggeredInAnyState(FName NotifyName);
    
    ENGINE_API const FAnimNode_StateMachine* GetStateMachineInstanceFromName(FName MachineName) const;
 
    ENGINE_API const FBakedAnimationStateMachine* GetMachineDescription(IAnimClassInterface* AnimBlueprintClass, FAnimNode_StateMachine* MachineInstance);
 
    ENGINE_API void GetStateMachineIndexAndDescription(FName InMachineName, int32& OutMachineIndex, const FBakedAnimationStateMachine** OutMachineDescription);
 
    ENGINE_API int32 GetSyncGroupIndexFromName(FName SyncGroupName) const;
 
    ENGINE_API int32 GetStateMachineIndex(FName MachineName) const;
 
    ENGINE_API const FAnimNode_StateMachine* GetStateMachineInstance(int32 MachineIndex) const;
 
    ENGINE_API int32 GetInstanceAssetPlayerIndex(FName MachineName, FName StateName, FName InstanceName = NAME_None) const;
 
    ENGINE_API TArray<const FAnimNode_AssetPlayerBase*> GetInstanceAssetPlayers(const FName& GraphName) const;
 
    ENGINE_API TArray<FAnimNode_AssetPlayerBase*> GetMutableInstanceAssetPlayers(const FName& GraphName);
 
    ENGINE_API TArray<const FAnimNode_AssetPlayerRelevancyBase*> GetInstanceRelevantAssetPlayers(const FName& GraphName) const;
 
    ENGINE_API TArray<FAnimNode_AssetPlayerRelevancyBase*> GetMutableInstanceRelevantAssetPlayers(const FName& GraphName);
 
    ENGINE_API const FBakedAnimationStateMachine* GetStateMachineInstanceDesc(FName MachineName) const;
 
    UE_DEPRECATED(5.1, "Please use GetRelevantAssetPlayerInterfaceFromState")
    const FAnimNode_AssetPlayerBase* GetRelevantAssetPlayerFromState(int32 MachineIndex, int32 StateIndex) const
    {
        return nullptr;
    }
 
    ENGINE_API const FAnimNode_AssetPlayerRelevancyBase* GetRelevantAssetPlayerInterfaceFromState(int32 MachineIndex, int32 StateIndex) const;
 
 
public:
    
    UFUNCTION(BlueprintPure, Category="Animation|Skeleton", meta=(BlueprintThreadSafe))
    ENGINE_API const UBlendProfile* GetBlendProfileByName(FName InBlendProfileName) const;
    
    UFUNCTION(BlueprintPure, Category="Animation|Curves", meta=(BlueprintThreadSafe))
    ENGINE_API float GetCurveValue(FName CurveName) const;
 
    UFUNCTION(BlueprintPure, Category="Animation|Curves", meta=(BlueprintThreadSafe))
    ENGINE_API bool GetCurveValueWithDefault(FName CurveName, float DefaultValue, float& OutValue);
 
    UFUNCTION(BlueprintPure, Category = "Animation|Curves", meta=(BlueprintThreadSafe))
    ENGINE_API void GetActiveCurveNames(EAnimCurveType CurveType, TArray<FName>& OutNames) const;
 
    /* This returns all curve names. This is the same as calling GetActiveCurveNames with CurveType == AttributeCurve */
    UFUNCTION(BlueprintPure, Category = "Animation|Curves", meta=(BlueprintThreadSafe))
    ENGINE_API void GetAllCurveNames(TArray<FName>& OutNames) const;
 
    ENGINE_API bool GetCurveValue(FName CurveName, float& OutValue) const;
 
    ENGINE_API void OverrideCurveValue(FName CurveName, float Value);
 
    UFUNCTION(BlueprintPure, Category="Animation|State Machines", meta=(BlueprintInternalUseOnly = "true", AnimGetter = "true", BlueprintThreadSafe))
    ENGINE_API FName GetCurrentStateName(int32 MachineIndex);
 
    UFUNCTION(BlueprintCallable, Category="Animation|Morph Targets")
    ENGINE_API void SetMorphTarget(FName MorphTargetName, float Value);
 
    UFUNCTION(BlueprintCallable, Category="Animation|Morph Targets")
    ENGINE_API void ClearMorphTargets();
 
    UE_DEPRECATED(5.0, "Please use UKismetAnimationLibrary::CalculateDirection instead")
    UFUNCTION(BlueprintCallable, Category="Animation", meta=(BlueprintThreadSafe))
    ENGINE_API float CalculateDirection(const FVector& Velocity, const FRotator& BaseRotation) const;
 
    //--- AI communication start ---//
    UFUNCTION(BlueprintCallable, Category = "Animation", BlueprintAuthorityOnly, Meta=(DeprecatedFunction, DeprecationMessage="Use LockAIResourcesWithAnimation instead"))
    ENGINE_API void LockAIResources(bool bLockMovement, bool LockAILogic);
 
    UFUNCTION(BlueprintCallable, Category = "Animation", BlueprintAuthorityOnly, Meta=(DeprecatedFunction, DeprecationMessage="Use UnlockAIResourcesWithAnimation instead"))
    ENGINE_API void UnlockAIResources(bool bUnlockMovement, bool UnlockAILogic);
    //--- AI communication end ---//
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Synchronization", meta=(BlueprintThreadSafe))
    ENGINE_API bool GetTimeToClosestMarker(FName SyncGroup, FName MarkerName, float& OutMarkerTime) const;
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Synchronization", meta=(BlueprintThreadSafe))
    ENGINE_API bool HasMarkerBeenHitThisFrame(FName SyncGroup, FName MarkerName) const;
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Synchronization", meta=(BlueprintThreadSafe))
    ENGINE_API bool IsSyncGroupBetweenMarkers(FName InSyncGroupName, FName PreviousMarker, FName NextMarker, bool bRespectMarkerOrder = true) const;
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Synchronization", meta=(BlueprintThreadSafe))
    ENGINE_API FMarkerSyncAnimPosition GetSyncGroupPosition(FName InSyncGroupName) const;
 
    UFUNCTION(BlueprintCallable, Category="Animation", meta = (BlueprintThreadSafe, Keywords = "Event,Request,Transition"))
    ENGINE_API bool RequestTransitionEvent(const FName EventName, const double RequestTimeout, const ETransitionRequestQueueMode QueueMode, const ETransitionRequestOverwriteMode OverwriteMode);
 
    UFUNCTION(BlueprintCallable, Category = "Animation", meta = (BlueprintThreadSafe, Keywords = "Event,Request,Transition"))
    ENGINE_API void ClearTransitionEvents(const FName EventName);
 
    UFUNCTION(BlueprintCallable, Category = "Animation", meta = (BlueprintThreadSafe, Keywords = "Event,Request,Transition"))
    ENGINE_API void ClearAllTransitionEvents();
 
    UFUNCTION(BlueprintPure, Category = "Transitions", meta = (BlueprintInternalUseOnly = "true", AnimGetter = "true", GetterContext = "Transition", BlueprintThreadSafe, Keywords = "Event,Request,Transition"))
    ENGINE_API bool QueryTransitionEvent(int32 MachineIndex, int32 TransitionIndex, FName EventName);
 
    UFUNCTION(BlueprintPure, Category = "Transitions", meta = (BlueprintInternalUseOnly = "true", AnimGetter = "true", GetterContext = "Transition", BlueprintThreadSafe, Keywords = "Event,Request,Transition"))
    ENGINE_API bool QueryAndMarkTransitionEvent(int32 MachineIndex, int32 TransitionIndex, FName EventName);
 
public:
    //~ Begin UObject Interface
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    ENGINE_API virtual void BeginDestroy() override;
    ENGINE_API virtual void PostInitProperties() override;
    static ENGINE_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
    //~ End UObject Interface
 
#if WITH_EDITORONLY_DATA // ANIMINST_PostCompileValidation
    UPROPERTY()
    FSoftClassPath PostCompileValidationClassName;
 
    virtual bool PCV_ShouldWarnAboutNodesNotUsingFastPath() const { return false; }
    virtual bool PCV_ShouldNotifyAboutNodesNotUsingFastPath() const { return false; }
 
    // Called on the newly created CDO during anim blueprint compilation to allow subclasses a chance to replace animations (experimental)
    virtual void ApplyAnimOverridesToCDO(FCompilerResultsLog& MessageLog) {}
#endif // WITH_EDITORONLY_DATA
 
    virtual void OnUROSkipTickAnimation() {}
 
    UE_DEPRECATED(4.22, "This function is deprecated, please use OnUROPreInterpolation_AnyThread")
    virtual void OnUROPreInterpolation() {}
 
    virtual void OnUROPreInterpolation_AnyThread(FAnimationEvaluationContext& InOutContext) {}
 
    enum class EUpdateAnimationFlag : uint8
    {
        ForceParallelUpdate,
        Default
    };
 
    // Animation phase trigger
    // start with initialize
    // update happens in every tick. Can happen in parallel with others if conditions are right.
    // evaluate happens when condition is met - i.e. depending on your skeletalmeshcomponent update flag
    // post eval happens after evaluation is done
    // uninitialize happens when owner is unregistered
    // @param   bInDeferRootNodeInitialization  When set to true, defer init of the blend tree until the first Update() call
    ENGINE_API void InitializeAnimation(bool bInDeferRootNodeInitialization = false);
 
    virtual void PreUpdateLinkedInstances(float DeltaSeconds) {}
 
    ENGINE_API void UpdateAnimation(float DeltaSeconds, bool bNeedsValidRootMotion, EUpdateAnimationFlag UpdateFlag = EUpdateAnimationFlag::Default );
 
    ENGINE_API void ParallelUpdateAnimation();
 
    ENGINE_API void PostUpdateAnimation();
 
    ENGINE_API void PreEvaluateAnimation();
 
    ENGINE_API bool ParallelCanEvaluate(const USkeletalMesh* InSkeletalMesh) const;
 
    ENGINE_API void ParallelEvaluateAnimation(bool bForceRefPose, const USkeletalMesh* InSkeletalMesh, FParallelEvaluationData& OutAnimationPoseData);
 
    UE_DEPRECATED(4.26, "Please use ParallelEvaluateAnimation with different signature.")
    ENGINE_API void ParallelEvaluateAnimation(bool bForceRefPose, const USkeletalMesh* InSkeletalMesh, FBlendedHeapCurve& OutCurve, FCompactPose& OutPose);
 
    ENGINE_API void PostEvaluateAnimation();
    ENGINE_API void UninitializeAnimation();
 
    // the below functions are the native overrides for each phase
    // Native initialization override point
    ENGINE_API virtual void NativeInitializeAnimation();
    // Native update override point. It is usually a good idea to simply gather data in this step and 
    // for the bulk of the work to be done in NativeThreadSafeUpdateAnimation.
    ENGINE_API virtual void NativeUpdateAnimation(float DeltaSeconds);
    // Native thread safe update override point. Executed on a worker thread just prior to graph update 
    // for linked anim instances, only called when the hosting node(s) are relevant
    ENGINE_API virtual void NativeThreadSafeUpdateAnimation(float DeltaSeconds);
    // Native Post Evaluate override point
    ENGINE_API virtual void NativePostEvaluateAnimation();
    // Native Uninitialize override point
    ENGINE_API virtual void NativeUninitializeAnimation();
    // Native override point executed when all Linked Animation Layers are initialized
    ENGINE_API virtual void NativeLinkedAnimationLayersInitialized();
 
    // Enable / Disable animation update. This is provided as an optimization to disable linked instances that aren't relevant. Disabling an instance whose graph is still evaluated will assert and causes issues.
    void EnableUpdateAnimation(bool bEnable) { bUpdateAnimationEnabled = bEnable; }
    bool IsUpdateAnimationEnabled() const { return bUpdateAnimationEnabled != 0; }
 
    // Executed when begin play is called on the owning component
    ENGINE_API virtual void NativeBeginPlay();
 
    // Sets up a native transition delegate between states with PrevStateName and NextStateName, in the state machine with name MachineName.
    // Note that a transition already has to exist for this to succeed
    ENGINE_API void AddNativeTransitionBinding(const FName& MachineName, const FName& PrevStateName, const FName& NextStateName, const FCanTakeTransition& NativeTransitionDelegate, const FName& TransitionName = NAME_None);
 
    // Check for whether a native rule is bound to the specified transition
    ENGINE_API bool HasNativeTransitionBinding(const FName& MachineName, const FName& PrevStateName, const FName& NextStateName, FName& OutBindingName);
 
    // Sets up a native state entry delegate from state with StateName, in the state machine with name MachineName.
    ENGINE_API void AddNativeStateEntryBinding(const FName& MachineName, const FName& StateName, const FOnGraphStateChanged& NativeEnteredDelegate);
    
    // Check for whether a native entry delegate is bound to the specified state
    ENGINE_API bool HasNativeStateEntryBinding(const FName& MachineName, const FName& StateName, FName& OutBindingName);
 
    // Sets up a native state exit delegate from state with StateName, in the state machine with name MachineName.
    ENGINE_API void AddNativeStateExitBinding(const FName& MachineName, const FName& StateName, const FOnGraphStateChanged& NativeExitedDelegate);
 
    // Check for whether a native exit delegate is bound to the specified state
    ENGINE_API bool HasNativeStateExitBinding(const FName& MachineName, const FName& StateName, FName& OutBindingName);
 
    // Debug output for this anim instance. Info for SyncGroups, Graph, Montages, etc.
    ENGINE_API void DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos);
 
    // Display debug info about AnimInstance. Can be overridden to add custom info from child classes.
    ENGINE_API virtual void DisplayDebugInstance(FDisplayDebugManager& DisplayDebugManager, float& Indent);
 
    UFUNCTION(BlueprintCallable, Category = "Animation|Dynamics")
    ENGINE_API void ResetDynamics(ETeleportType InTeleportType);
 
    UE_DEPRECATED(4.20, "Please use ResetDynamics with a ETeleportType argument")
    ENGINE_API void ResetDynamics();
 
    UFUNCTION(BlueprintPure, Category = "Animation")
    ENGINE_API virtual int32 GetLODLevel() const;
 
public:
    ENGINE_API const FGraphTraversalCounter& GetUpdateCounter() const; 
 
    ENGINE_API FBoneContainer& GetRequiredBones();
    ENGINE_API const FBoneContainer& GetRequiredBones() const;
    ENGINE_API const FBoneContainer& GetRequiredBonesOnAnyThread() const;
 
    ETeleportType PendingDynamicResetTeleportType;
 
    UPROPERTY(transient)
    FAnimNotifyQueue NotifyQueue;
 
    UPROPERTY(transient)
    TArray<FAnimNotifyEvent> ActiveAnimNotifyState;
 
    UPROPERTY(transient)
    TArray<FAnimNotifyEventReference> ActiveAnimNotifyEventReference;
    
private:
    ENGINE_API void ResetAnimationCurves();
 
public: 
    ENGINE_API void UpdateCurvesToEvaluationContext(const FAnimationEvaluationContext& InOutContext);
 
    ENGINE_API void UpdateCurvesPostEvaluation();
 
    ENGINE_API void SwapCurveWithEvaluationContext(FAnimationEvaluationContext& InOutContext);
 
    ENGINE_API void UpdateCurves(const FBlendedHeapCurve& InCurves);
 
    ENGINE_API void CopyCurveValues(const UAnimInstance& InSourceInstance);
 
    ENGINE_API void RefreshCurves(USkeletalMeshComponent* Component);
 
    ENGINE_API bool HasMorphTargetCurves() const;
 
    ENGINE_API bool HasActiveCurves() const;
 
    UFUNCTION(BlueprintPure, Category="Animation", meta=(BlueprintThreadSafe))
    ENGINE_API float GetDeltaSeconds() const;
    
    ENGINE_API void AppendAnimationCurveList(EAnimCurveType Type, TMap<FName, float>& InOutCurveList) const;
 
 
    UE_DEPRECATED(4.19, "This function is deprecated. Use AppendAnimationCurveList instead.")
    ENGINE_API void GetAnimationCurveList(EAnimCurveType Type, TMap<FName, float>& InOutCurveList) const;
    ENGINE_API const TMap<FName, float>& GetAnimationCurveList(EAnimCurveType Type) const;
 
#if WITH_EDITORONLY_DATA
    // Maximum playback position ever reached (only used when debugging in Persona)
    double LifeTimer;
 
    // Current scrubbing playback position (only used when debugging in Persona)
    double CurrentLifeTimerScrubPosition;
#endif
 
public:
    FGraphTraversalCounter DebugDataCounter;
 
private:
 
    // Used to prevent indefinitely flushing montages on a single frame. 
    uint32 LastMontageFlushFrame = 0u;
    
    TMap<FName, FMontageActiveSlotTracker> SlotWeightTracker;
    TMap<FName, FSimpleMulticastDelegate> ExternalNotifyHandlers;
 
    ENGINE_API bool CheckOnInstanceAndMainInstance(TFunctionRef<bool (FAnimInstanceProxy* )> ProxyLambdaFunc);
 
public:
 
    // Gets the last frame any completed montages where flushed. Only important if a.Montage.FlushCompletedMontagesOnPlay is enabled.
    uint32 GetLastMontageFlushFrame() const;
 
    ENGINE_API void RecalcRequiredBones();
 
    ENGINE_API void RecalcRequiredCurves(const UE::Anim::FCurveFilterSettings& CurveFilterSettings);
    
    UE_DEPRECATED(5.3, "Please use RecalcRequiredCurves that takes a FCurveFilterSettings.")
    ENGINE_API void RecalcRequiredCurves(const FCurveEvaluationOption& CurveEvalOption);
 
    inline USkeletalMeshComponent* GetSkelMeshComponent() const
    {
        return GetSkelMeshComponentChecked();
    }
 
    ENGINE_API virtual UWorld* GetWorld() const override;
 
    ENGINE_API void TriggerAnimNotifies(float DeltaSeconds);
 
    ENGINE_API void TriggerSingleAnimNotify(const FAnimNotifyEvent* AnimNotifyEvent);
 
    ENGINE_API void TriggerSingleAnimNotify(FAnimNotifyEventReference& EventReference);
 
    ENGINE_API void EndNotifyStates();
 
    UE_DEPRECATED(5.3, "Please use AddCurveValue that takes a CurveName")
    void AddCurveValue(const SmartName::UID_Type Uid, float Value) {}
 
    UE_DEPRECATED(5.3, "Please use AddCurveValue that takes a CurveName")
    void AddCurveValue(const FSmartNameMapping& Mapping, const FName& CurveName, float Value) {}
 
    ENGINE_API void RecordMachineWeight(const int32 InMachineClassIndex, const float InMachineWeight);
    
    ENGINE_API void AddCurveValue(const FName& CurveName, float Value, bool bMorphtarget = false, bool bMaterial = false);
 
    ENGINE_API void RecordStateWeight(const int32 InMachineClassIndex, const int32 InStateIndex, const float InStateWeight, const float InElapsedTime);
 
protected:
#if WITH_EDITORONLY_DATA
    // Returns true if a snapshot is being played back and the remainder of Update should be skipped.
    ENGINE_API bool UpdateSnapshotAndSkipRemainingUpdate();
#endif
 
    ENGINE_API virtual bool HandleNotify(const FAnimNotifyEvent& AnimNotifyEvent);
 
    ENGINE_API USkeletalMeshComponent* GetSkelMeshComponentChecked() const;
 
    ENGINE_API USkeletalMeshComponent* GetSkelMeshComponentUnchecked() const;
 
    // Root Motion
public:
    ENGINE_API FAnimMontageInstance * GetRootMotionMontageInstance() const;
 
    ENGINE_API FRootMotionMovementParams ConsumeExtractedRootMotion(float Alpha);
 
    ENGINE_API void QueueRootMotionBlend(const FTransform& RootTransform, const FName& SlotName, float Weight);
 
private:
    struct FAnimMontageInstance* RootMotionMontageInstance;
 
    struct FQueuedRootMotionBlend
    {
        FQueuedRootMotionBlend(const FTransform& InTransform, const FName& InSlotName, float InWeight)
            : Transform(InTransform)
            , SlotName(InSlotName)
            , Weight(InWeight)
        {}
 
        FTransform Transform;
        FName SlotName;
        float Weight;
    };
 
    TArray<FQueuedRootMotionBlend> RootMotionBlendQueue;
 
    // Root motion read from proxy (where it is calculated) and stored here to avoid potential stalls by calling GetProxyOnGameThread
    FRootMotionMovementParams ExtractedRootMotion;
 
private:
    // update montage
    ENGINE_API void UpdateMontage(float DeltaSeconds);
    ENGINE_API void UpdateMontageSyncGroup();
 
protected:
    // Updates the montage data used for evaluation based on the current playing montages
    ENGINE_API void UpdateMontageEvaluationData();
 
    ENGINE_API virtual void PreUpdateAnimation(float DeltaSeconds);
 
    ENGINE_API void UpdateCurvesToComponents(USkeletalMeshComponent* Component);
 
    ENGINE_API virtual FAnimInstanceProxy* CreateAnimInstanceProxy();
 
    ENGINE_API virtual void DestroyAnimInstanceProxy(FAnimInstanceProxy* InProxy);
 
    template <typename T /*= FAnimInstanceProxy*/>  // @TODO: Cant default parameters to this function on Xbox One until we move off the VS2012 compiler
    inline static T* GetProxyOnGameThreadStatic(UAnimInstance* InAnimInstance)
    {
        if (InAnimInstance)
        {
            check(IsInGameThread());
            UObject* OuterObj = InAnimInstance->GetOuter();
            if (IsSkeletalMeshComponent(OuterObj))
            {
                HandleExistingParallelEvaluationTask(InAnimInstance->GetSkelMeshComponent());
            }
            if (InAnimInstance->AnimInstanceProxy == nullptr)
            {
                InAnimInstance->AnimInstanceProxy = InAnimInstance->CreateAnimInstanceProxy();
            }
            return static_cast<T*>(InAnimInstance->AnimInstanceProxy);
        }
 
        return nullptr;
    }
    template <typename T /*= FAnimInstanceProxy*/>  // @TODO: Cant default parameters to this function on Xbox One until we move off the VS2012 compiler
    inline T& GetProxyOnGameThread()
    {
        return *GetProxyOnGameThreadStatic<T>(this);
    }
 
    template <typename T/* = FAnimInstanceProxy*/>  // @TODO: Cant default parameters to this function on Xbox One until we move off the VS2012 compiler
    inline const T& GetProxyOnGameThread() const
    {
        check(IsInGameThread());
        if(IsSkeletalMeshComponent(GetOuter()))
        {
            HandleExistingParallelEvaluationTask(GetSkelMeshComponent());
        }
        if(AnimInstanceProxy == nullptr)
        {
            AnimInstanceProxy = const_cast<UAnimInstance*>(this)->CreateAnimInstanceProxy();
        }
        return *static_cast<const T*>(AnimInstanceProxy);
    }
 
    template <typename T/* = FAnimInstanceProxy*/>  // @TODO: Cant default parameters to this function on Xbox One until we move off the VS2012 compiler
    inline T& GetProxyOnAnyThread()
    {
        if(IsSkeletalMeshComponent(GetOuter()))
        {
            if(IsInGameThread())
            {
                HandleExistingParallelEvaluationTask(GetSkelMeshComponent());
            }
        }
        if(AnimInstanceProxy == nullptr)
        {
            AnimInstanceProxy = CreateAnimInstanceProxy();
        }
        return *static_cast<T*>(AnimInstanceProxy);
    }
 
    template <typename T/* = FAnimInstanceProxy*/>  // @TODO: Cant default parameters to this function on Xbox One until we move off the VS2012 compiler
    inline const T& GetProxyOnAnyThread() const
    {
        if(IsSkeletalMeshComponent(GetOuter()))
        {
            if(IsInGameThread())
            {
                HandleExistingParallelEvaluationTask(GetSkelMeshComponent());
            }
        }
        if(AnimInstanceProxy == nullptr)
        {
            AnimInstanceProxy = const_cast<UAnimInstance*>(this)->CreateAnimInstanceProxy();
        }
        return *static_cast<const T*>(AnimInstanceProxy);
    }
 
    friend struct FAnimNode_LinkedAnimGraph;
    friend struct FAnimNode_LinkedAnimLayer;
    friend struct FAnimInstanceProxy;
    
public:
    ENGINE_API virtual bool ShouldTriggerAnimNotifyState(const UAnimNotifyState* AnimNotifyState) const;
 
protected:
    static ENGINE_API bool IsSkeletalMeshComponent(const UObject* Object);
    static ENGINE_API void HandleExistingParallelEvaluationTask(USkeletalMeshComponent* Component);
 
    mutable FAnimInstanceProxy* AnimInstanceProxy;
 
public:
    FPlayMontageAnimNotifyDelegate OnPlayMontageNotifyBegin;
 
    FPlayMontageAnimNotifyDelegate OnPlayMontageNotifyEnd;
 
public:
    ENGINE_API void DispatchQueuedAnimEvents();
 
    ENGINE_API void ClearQueuedAnimEvents(bool bShouldUpdateActiveAnimNotifiesSinceLastTick);
    
#if WITH_EDITOR
    // Helper function to handle reinstancing in editor
    ENGINE_API virtual void HandleObjectsReinstanced(const TMap<UObject*, UObject*>& OldToNewInstanceMap);
 
    ENGINE_API bool IsBeingDebugged() const;
#endif
};