AnimInstanceProxy.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 "Engine/EngineTypes.h"
#include "Animation/AnimTypes.h"
#include "Animation/AnimationAsset.h"
#include "Animation/AnimBlueprint.h"
#include "Animation/AnimClassInterface.h"
#include "Animation/AnimSync.h"
#include "Animation/AnimInertializationRequest.h"
 
#include "AnimInstanceProxy.generated.h"
 
struct FComponentSpacePoseContext;
class UAnimInstance;
class UAnimNotify;
class UAnimNotifyState;
class UBlendProfile;
class UBlendSpace;
class FTokenizedMessage;
namespace EMessageSeverity { enum Type : int; }
struct FAnimationEvaluationContext;
struct FAnimationPoseData;
struct FAnimBlueprintDebugData_NodeVisit;
struct FAnimBlueprintDebugData_AttributeRecord;
struct FAnimGroupInstance;
struct FAnimNodePoseWatch;
struct FAnimNode_AssetPlayerBase;
struct FAnimNode_AssetPlayerRelevancyBase;
struct FAnimNode_Base;
struct FAnimNode_LinkedInputPose;
struct FAnimNode_SaveCachedPose;
struct FAnimNode_StateMachine;
struct FAnimTickRecord;
struct FBakedAnimationStateMachine;
struct FCompactPose;
struct FMontageActiveSlotTracker;
struct FMontageEvaluationState;
struct FNativeStateBinding;
struct FNativeTransitionBinding;
struct FNodeDebugData;
struct FPoseContext;
struct FPoseSnapshot;
enum class ETransitionRequestQueueMode : uint8;
enum class ETransitionRequestOverwriteMode : uint8;
 
namespace UE::Anim
{
    class FAnimSyncGroupScope;
    class FActiveStateMachineScope;
    struct FAnimSyncParams;
    // DEPRECATED use FInertializationRequest instead
    using FSlotInertializationRequest = TPair<float, const UBlendProfile*>;
}
 
template<class PoseType> struct FCSPose;
 
// Disable debugging information for shipping and test builds.
#define ENABLE_ANIM_DRAW_DEBUG (1 && !(UE_BUILD_SHIPPING || UE_BUILD_TEST))
 
// Disable node logging for shipping and test builds
#define ENABLE_ANIM_LOGGING (1 && !NO_LOGGING && !(UE_BUILD_SHIPPING || UE_BUILD_TEST))
 
extern const FName NAME_AnimBlueprintLog;
extern const FName NAME_Evaluate;
extern const FName NAME_Update;
extern const FName NAME_AnimGraph;
 
DECLARE_DELEGATE_RetVal(bool, FCanTakeTransition);
DECLARE_DELEGATE_ThreeParams(FOnGraphStateChanged, const struct FAnimNode_StateMachine&, int32, int32);
 
UENUM()
namespace EDrawDebugItemType
{
    enum Type : int
    {
        DirectionalArrow,
        Sphere,
        Line,
        OnScreenMessage,
        CoordinateSystem,
        Point,
        Circle,
        Cone,
        InWorldMessage,
        Capsule,
    };
}
 
struct FQueuedDrawDebugItem 
{
    struct FVectorEntry
    {
        FVectorEntry(const FVector& InVector)
            : Value(InVector)
        {}
 
        FVector Value;
    };
 
    TEnumAsByte<EDrawDebugItemType::Type> ItemType = EDrawDebugItemType::DirectionalArrow;
 
    union
    {
        FVector StartLoc;
        struct
        {
            float Length;
            float AngleWidth;
            float AngleHeight;
        };
    };
    
    union
    {
        FVectorEntry EndLoc;
        FVectorEntry Direction;
    };
 
    FVector Center = FVector(0.f);
    FRotator Rotation = FRotator(0.f);
    float Radius = 0.f;
    float Size = 0.f;
    int32 Segments = 0;
    FColor Color = FColor(0);
    bool bPersistentLines = false;
    float LifeTime = 0.f;
    float Thickness = 0.f;
    FString Message;
    FVector2D TextScale = FVector2D(0.f);
    TEnumAsByte<ESceneDepthPriorityGroup> DepthPriority = SDPG_World;
    FQueuedDrawDebugItem() 
        : StartLoc(FVector(0.f))
        , EndLoc(FVector(0.f))
    {};
};
 
USTRUCT(meta = (DisplayName = "Native Variables"))
struct FAnimInstanceProxy
{
    GENERATED_USTRUCT_BODY()
 
public:
    using FSyncGroupMap = TMap<FName, FAnimGroupInstance>;
 
    ENGINE_API FAnimInstanceProxy();
    ENGINE_API FAnimInstanceProxy(UAnimInstance* Instance);
 
    ENGINE_API FAnimInstanceProxy(const FAnimInstanceProxy&);
    ENGINE_API FAnimInstanceProxy& operator=(FAnimInstanceProxy&&);
    ENGINE_API FAnimInstanceProxy& operator=(const FAnimInstanceProxy&);
    ENGINE_API virtual ~FAnimInstanceProxy();
 
    // Get the IAnimClassInterface associated with this context, if there is one.
    // Note: This can return NULL, so check the result.
    IAnimClassInterface* GetAnimClassInterface() const
    {
        return AnimClassInterface;
    }
 
    float GetDeltaSeconds() const
    {
        return CurrentDeltaSeconds;
    }
 
    float GetTimeDilation() const
    {
        return CurrentTimeDilation;
    }
 
#if WITH_EDITORONLY_DATA
    bool IsBeingDebugged() const
    {
        return bIsBeingDebugged;
    }
 
    ENGINE_API void RecordNodeVisit(int32 TargetNodeIndex, int32 SourceNodeIndex, float BlendWeight);
 
    ENGINE_API void RecordNodeAttribute(const FAnimInstanceProxy& InSourceProxy, int32 InTargetNodeIndex, int32 InSourceNodeIndex, FName InAttribute);
 
    void RecordNodeSync(int32 InSourceNodeIndex, FName InSyncGroup)
    {
        NodeSyncsThisFrame.FindOrAdd(InSourceNodeIndex, InSyncGroup);
    }
 
    UAnimBlueprint* GetAnimBlueprint() const
    {
        UClass* ActualAnimClass = IAnimClassInterface::GetActualAnimClass(AnimClassInterface);
        return ActualAnimClass ? Cast<UAnimBlueprint>(ActualAnimClass->ClassGeneratedBy) : nullptr;
    }
 
    // Record pose for node of ID LinkID if it is currently being watched
    UE_DEPRECATED(5.6, "Please use RegisterWatchedPose that takes a pose context")
    ENGINE_API void RegisterWatchedPose(const FCompactPose& Pose, const FBlendedCurve& InCurve, int32 LinkID);
    UE_DEPRECATED(5.6, "Please use RegisterWatchedPose that takes a pose context")
    ENGINE_API void RegisterWatchedPose(const FCSPose<FCompactPose>& Pose, const FBlendedCurve& InCurve, int32 LinkID);
 
    // Record pose for node of ID LinkID if it is currently being watched
    ENGINE_API void RegisterWatchedPose(const FPoseContext& Pose, int32 LinkID);
    ENGINE_API void RegisterWatchedPose(const FComponentSpacePoseContext& Pose, int32 LinkID);
#endif
 
    UE_DEPRECATED(5.0, "Function renamed to FlipBufferWriteIndex as this no longer deals with sync groups.")
    void TickSyncGroupWriteIndex()
    { 
        FlipBufferWriteIndex();
    }
 
    // flip buffer read/write indices
    void FlipBufferWriteIndex()
    { 
        BufferWriteIndex = GetBufferReadIndex();
    }
 
    UE_DEPRECATED(5.0, "Sync groups are no longer stored in arrays, please use GetSyncGroupMapRead.")
    const TArray<FAnimGroupInstance>& GetSyncGroupRead() const
    {
        static const TArray<FAnimGroupInstance> Dummy;
        return Dummy; 
    }
 
    const FSyncGroupMap& GetSyncGroupMapRead() const
    { 
        return Sync.GetSyncGroupMapRead(); 
    }
 
    const TArray<FAnimTickRecord>& GetUngroupedActivePlayersRead() 
    { 
        return Sync.GetUngroupedActivePlayersRead(); 
    }
 
    UE_DEPRECATED(5.0, "Do not call directly. Instead sync and asset player ticking is controlled via UE::Anim::FSync and UE::Anim::FSyncScope.")
    ENGINE_API void TickAssetPlayerInstances(float DeltaSeconds);
 
    UE_DEPRECATED(5.0, "Do not call directly. Instead sync and asset player ticking is controlled via UE::Anim::FSync and UE::Anim::FSyncScope.")
    ENGINE_API void TickAssetPlayerInstances();
 
    ENGINE_API void AddAnimNotifyFromGeneratedClass(int32 NotifyIndex);
 
    ENGINE_API void TriggerAnimNotifies(USkeletalMeshComponent* SkelMeshComp, float DeltaSeconds);
 
    UE_DEPRECATED(5.2, "Skeleton compatibility is now an editor-only concern, this function is no longer used.")
    bool IsSkeletonCompatible(USkeleton const* InSkeleton) const
    {
        return Skeleton != nullptr && InSkeleton != nullptr;
    }
 
    bool ShouldExtractRootMotion() const 
    { 
        return bShouldExtractRootMotion;
    }
    
    ENGINE_API void SavePoseSnapshot(USkeletalMeshComponent* InSkeletalMeshComponent, FName SnapshotName);
 
    ENGINE_API FPoseSnapshot& AddPoseSnapshot(FName SnapshotName);
 
    ENGINE_API void RemovePoseSnapshot(FName SnapshotName);
 
    ENGINE_API const FPoseSnapshot* GetPoseSnapshot(FName SnapshotName) const;
 
    const FGraphTraversalCounter& GetInitializationCounter() const { return InitializationCounter; }
    const FGraphTraversalCounter& GetCachedBonesCounter() const  { return CachedBonesCounter; }
    const FGraphTraversalCounter& GetUpdateCounter() const  { return UpdateCounter; }
    const FGraphTraversalCounter& GetEvaluationCounter() const { return EvaluationCounter; }
    const FGraphTraversalCounter& GetSlotNodeInitializationCounter() const { return SlotNodeInitializationCounter; }
    
    void ResetUpdateCounter() { UpdateCounter.Reset(); }
 
    FRootMotionMovementParams& GetExtractedRootMotion() { return ExtractedRootMotion; }
 
    UObject* GetAnimInstanceObject() { return AnimInstanceObject; }
    const UObject* GetAnimInstanceObject() const { return AnimInstanceObject; }
 
    ENGINE_API FAnimNode_Base* GetMutableNodeFromIndexUntyped(int32 NodeIdx, UScriptStruct* RequiredStructType);
 
    ENGINE_API const FAnimNode_Base* GetNodeFromIndexUntyped(int32 NodeIdx, UScriptStruct* RequiredStructType) const;
 
    ENGINE_API FAnimNode_Base* GetCheckedMutableNodeFromIndexUntyped(int32 NodeIdx, UScriptStruct* RequiredStructType);
 
    ENGINE_API const FAnimNode_Base* GetCheckedNodeFromIndexUntyped(int32 NodeIdx, UScriptStruct* RequiredStructType) const;
 
    template<class NodeType>
    const NodeType* GetCheckedNodeFromIndex(int32 NodeIdx) const
    {
        return (NodeType*)GetCheckedNodeFromIndexUntyped(NodeIdx, NodeType::StaticStruct());
    }
 
    template<class NodeType>
    NodeType* GetCheckedMutableNodeFromIndex(int32 NodeIdx) const
    {
        return (NodeType*)GetCheckedMutableNodeFromIndexUntyped(NodeIdx, NodeType::StaticStruct());
    }
 
    template<class NodeType>
    const NodeType* GetNodeFromIndex(int32 NodeIdx) const
    {
        return (NodeType*)GetNodeFromIndexUntyped(NodeIdx, NodeType::StaticStruct());
    }
 
    template<class NodeType>
    NodeType* GetMutableNodeFromIndex(int32 NodeIdx) const
    {
        return (NodeType*)GetNodeFromIndexUntyped(NodeIdx, NodeType::StaticStruct());
    }
 
    const FBoneContainer& GetRequiredBones() const 
    { 
        return *RequiredBones; 
    }
 
    FBoneContainer& GetRequiredBones() 
    { 
        return *RequiredBones;
    }
 
    int32 GetLODLevel() const
    {
        return LODLevel;
    }
 
    UE_DEPRECATED(5.0, "Please use GetComponentTransform")
    const FTransform& GetSkelMeshCompLocalToWorld() const
    {
        return ComponentTransform;
    }
 
    UE_DEPRECATED(5.0, "Please use GetActorTransform")
    const FTransform& GetSkelMeshCompOwnerTransform() const
    {
        return ActorTransform;
    }
 
    USkeleton* GetSkeleton() 
    { 
        // Skeleton is only available during update/eval. If you're calling this function outside of it, it will return null. 
        // adding ensure here so that we can catch them earlier
        ensureAlways(Skeleton);
        return Skeleton; 
    }
 
    USkeletalMeshComponent* GetSkelMeshComponent() const
    { 
        // Skeletal mesh component is only available during update/eval. If you're calling this function outside of it, it will return null. 
        // adding ensure here so that we can catch them earlier
        ensureAlways(SkeletalMeshComponent);
        return SkeletalMeshComponent; 
    }
 
    FAnimInstanceProxy* GetMainInstanceProxy() const
    { 
        // Main instance proxy is only available during update/eval. If you're calling this function outside of it, it will return null. 
        return MainInstanceProxy;
    }
 
    UE_DEPRECATED(4.26, "Please use the overload that takes a group FName")
    ENGINE_API FAnimTickRecord& CreateUninitializedTickRecord(int32 GroupIndex, FAnimGroupInstance*& OutSyncGroupPtr);
 
    UE_DEPRECATED(4.26, "Please use the overload that takes a group FName")
    ENGINE_API FAnimTickRecord& CreateUninitializedTickRecordInScope(int32 GroupIndex, EAnimSyncGroupScope Scope, FAnimGroupInstance*& OutSyncGroupPtr);
 
    UE_DEPRECATED(5.0, "Please use FAnimSyncGroupScope")
    ENGINE_API FAnimTickRecord& CreateUninitializedTickRecord(FAnimGroupInstance*& OutSyncGroupPtr, FName GroupName);
 
    UE_DEPRECATED(5.0, "Please use FAnimSyncGroupScope")
    ENGINE_API FAnimTickRecord& CreateUninitializedTickRecordInScope(FAnimGroupInstance*& OutSyncGroupPtr, FName GroupName, EAnimSyncGroupScope Scope);
 
    UE_DEPRECATED(5.0, "Please use the FAnimTickRecord constructor that takes a UAnimSequenceBase")
    ENGINE_API void MakeSequenceTickRecord(FAnimTickRecord& TickRecord, UAnimSequenceBase* Sequence, bool bLooping, float PlayRate, float FinalBlendWeight, float& CurrentTime, FMarkerTickRecord& MarkerTickRecord) const;
 
    UE_DEPRECATED(5.0, "Please use the FAnimTickRecord constructor that takes a UBlendSpace")
    ENGINE_API void MakeBlendSpaceTickRecord(FAnimTickRecord& TickRecord, UBlendSpace* BlendSpace, const FVector& BlendInput, TArray<FBlendSampleData>& BlendSampleDataCache, FBlendFilter& BlendFilter, bool bLooping, float PlayRate, float FinalBlendWeight, float& CurrentTime, FMarkerTickRecord& MarkerTickRecord) const;
 
    UE_DEPRECATED(5.0, "Please use the FAnimTickRecord constructor that takes a UPoseAsset")
    ENGINE_API void MakePoseAssetTickRecord(FAnimTickRecord& TickRecord, class UPoseAsset* PoseAsset, float FinalBlendWeight) const;
 
    // Adds a tick record in the list for the correct group or the ungrouped array.
    void AddTickRecord(const FAnimTickRecord& InTickRecord, const UE::Anim::FAnimSyncParams& InSyncParams = UE::Anim::FAnimSyncParams())
    {
        Sync.AddTickRecord(InTickRecord, InSyncParams);
    }
 
    ENGINE_API void GetSlotWeight(const FName& SlotNodeName, float& out_SlotNodeWeight, float& out_SourceWeight, float& out_TotalNodeWeight) const;
 
    UE_DEPRECATED(4.26, "Use SlotEvaluatePose with other signature")
    ENGINE_API void SlotEvaluatePose(const FName& SlotNodeName, const FCompactPose& SourcePose, const FBlendedCurve& SourceCurve, float InSourceWeight, FCompactPose& BlendedPose, FBlendedCurve& BlendedCurve, float InBlendWeight, float InTotalNodeWeight);
 
    ENGINE_API void SlotEvaluatePose(const FName& SlotNodeName, const FAnimationPoseData& SourceAnimationPoseData, float InSourceWeight, FAnimationPoseData& OutBlendedAnimationPoseData, float InBlendWeight, float InTotalNodeWeight);
    
    // Allow slot nodes to store off their weight during ticking
    ENGINE_API void UpdateSlotNodeWeight(const FName& SlotNodeName, float InLocalMontageWeight, float InNodeGlobalWeight);
 
    UE_DEPRECATED(5.5, "Please use GetSlotInertializationRequestData instead.")
    ENGINE_API bool GetSlotInertializationRequest(const FName& SlotName, UE::Anim::FSlotInertializationRequest& OutRequest);
 
    ENGINE_API bool GetSlotInertializationRequestData(const FName& SlotName, FInertializationRequest& OutRequest);
 
    ENGINE_API void RegisterSlotNodeWithAnimInstance(const FName& SlotNodeName);
 
    bool HasRootNode() const
    { 
        return RootNode != nullptr; 
    }
 
    FAnimNode_Base* GetRootNode() 
    { 
        return RootNode;
    }
 
    ENGINE_API void GatherDebugData(FNodeDebugData& DebugData);
 
    ENGINE_API void GatherDebugData_WithRoot(FNodeDebugData& DebugData, FAnimNode_Base* InRootNode, FName InLayerName);
 
#if ENABLE_ANIM_DRAW_DEBUG
    mutable TArray<FQueuedDrawDebugItem> QueuedDrawDebugItems;
 
    ENGINE_API void AnimDrawDebugOnScreenMessage(const FString& DebugMessage, const FColor& Color, const FVector2D& TextScale = FVector2D::UnitVector, ESceneDepthPriorityGroup DepthPriority = SDPG_World);
    ENGINE_API void AnimDrawDebugInWorldMessage(const FString& DebugMessage, const FVector& TextLocation, const FColor& Color, float TextScale);
    ENGINE_API void AnimDrawDebugLine(const FVector& StartLoc, const FVector& EndLoc, const FColor& Color, bool bPersistentLines = false, float LifeTime = -1.f, float Thickness = 0.f, ESceneDepthPriorityGroup DepthPriority = SDPG_World);
    ENGINE_API void AnimDrawDebugDirectionalArrow(const FVector& LineStart, const FVector& LineEnd, float ArrowSize, const FColor& Color, bool bPersistentLines = false, float LifeTime = -1.f, float Thickness = 0.f, ESceneDepthPriorityGroup DepthPriority = SDPG_World);
    ENGINE_API void AnimDrawDebugSphere(const FVector& Center, float Radius, int32 Segments, const FColor& Color, bool bPersistentLines = false, float LifeTime = -1.f, float Thickness = 0.f, ESceneDepthPriorityGroup DepthPriority = SDPG_World);
    ENGINE_API void AnimDrawDebugCoordinateSystem(FVector const& AxisLoc, FRotator const& AxisRot, float Scale = 1.f, bool bPersistentLines = false, float LifeTime = -1.f, float Thickness = 0.f, ESceneDepthPriorityGroup DepthPriority = SDPG_World);
    ENGINE_API void AnimDrawDebugPlane(const FTransform& BaseTransform, float Radii, const FColor& Color, bool bPersistentLines = false, float LifeTime = -1.f, float Thickness = 0.f, ESceneDepthPriorityGroup DepthPriority = SDPG_World);
    ENGINE_API void AnimDrawDebugPoint(const FVector& Loc, float Size, const FColor& Color, bool bPersistentLines = false, float LifeTime = -1.f, ESceneDepthPriorityGroup DepthPriority = SDPG_World);
    ENGINE_API void AnimDrawDebugCircle(const FVector& Center, float Radius, int32 Segments, const FColor& Color, const FVector& UpVector = FVector::UpVector, bool bPersistentLines = false, float LifeTime = -1.f, ESceneDepthPriorityGroup DepthPriority = SDPG_World, float Thickness = 0.f);
    ENGINE_API void AnimDrawDebugCone(const FVector& Center, float Radius, const FVector& Direction, float AngleWidth, float AngleHeight, int32 Segments, const FColor& Color, bool bPersistentLines = false, float LifeTime = -1.f, ESceneDepthPriorityGroup DepthPriority = SDPG_World, float Thickness = 0.f);
    ENGINE_API void AnimDrawDebugCapsule(const FVector& Center, float HalfHeight, float Radius, const FRotator& Rotation, const FColor& Color, bool bPersistentLines = false, float LifeTime = -1.f, float Thickness = 0.f, ESceneDepthPriorityGroup DepthPriority = SDPG_World);
#else
    void AnimDrawDebugOnScreenMessage(const FString& DebugMessage, const FColor& Color, const FVector2D& TextScale = FVector2D::UnitVector, ESceneDepthPriorityGroup DepthPriority = SDPG_World) {}
    void AnimDrawDebugInWorldMessage(const FString& DebugMessage, const FVector& TextLocation, const FColor& Color, float TextScale) {}
    void AnimDrawDebugLine(const FVector& StartLoc, const FVector& EndLoc, const FColor& Color, bool bPersistentLines = false, float LifeTime = -1.f, float Thickness = 0.f, ESceneDepthPriorityGroup DepthPriority = SDPG_World) {}
    void AnimDrawDebugDirectionalArrow(const FVector& LineStart, const FVector& LineEnd, float ArrowSize, const FColor& Color, bool bPersistentLines = false, float LifeTime = -1.f, float Thickness = 0.f, ESceneDepthPriorityGroup DepthPriority = SDPG_World) {}
    void AnimDrawDebugSphere(const FVector& Center, float Radius, int32 Segments, const FColor& Color, bool bPersistentLines = false, float LifeTime = -1.f, float Thickness = 0.f, ESceneDepthPriorityGroup DepthPriority = SDPG_World) {}
    void AnimDrawDebugCoordinateSystem(FVector const& AxisLoc, FRotator const& AxisRot, float Scale = 1.f, bool bPersistentLines = false, float LifeTime = -1.f, float Thickness = 0.f, ESceneDepthPriorityGroup DepthPriority = SDPG_World) {}
    void AnimDrawDebugPlane(const FTransform& BaseTransform, float Radii, const FColor& Color, bool bPersistentLines = false, float LifeTime = -1.f, float Thickness = 0.f, ESceneDepthPriorityGroup DepthPriority = SDPG_World) {}
    void AnimDrawDebugPoint(const FVector& Loc, float Size, const FColor& Color, bool bPersistentLines = false, float LifeTime = -1.f, ESceneDepthPriorityGroup DepthPriority = SDPG_World) {}
    void AnimDrawDebugCircle(const FVector& Center, float Radius, int32 Segments, const FColor& Color, const FVector& UpVector = FVector::UpVector, bool bPersistentLines = false, float LifeTime=-1.f, ESceneDepthPriorityGroup DepthPriority = SDPG_World, float Thickness = 0.f) {}
    void AnimDrawDebugCone(const FVector& Center, float Radius, const FVector& Direction, float AngleWidth, float AngleHeight, int32 Segments, const FColor& Color, bool bPersistentLines = false, float LifeTime = -1.f, ESceneDepthPriorityGroup DepthPriority = SDPG_World, float Thickness = 0.f) {}
    void AnimDrawDebugCapsule(const FVector& Center, float HalfHeight, float Radius, const FRotator& Rotation, const FColor& Color, bool bPersistentLines = false, float LifeTime = -1.f, float Thickness = 0.f, ESceneDepthPriorityGroup DepthPriority = SDPG_World) {}
#endif // ENABLE_ANIM_DRAW_DEBUG
 
#if ENABLE_ANIM_LOGGING
    const FString& GetActorName() const 
    {
        return ActorName; 
    }
#endif
 
    FString GetAnimInstanceName() const
    { 
        return AnimInstanceObject->GetFullName();
    }
 
    // Get the root motion mode assigned to this anim instance proxy
    ERootMotionMode::Type GetRootMotionMode() const
    {
        return RootMotionMode;
    }
 
    ENGINE_API const FAnimNode_StateMachine* GetStateMachineInstanceFromName(FName MachineName) const;
 
    ENGINE_API const FAnimNode_StateMachine* GetStateMachineInstance(int32 NodeIndex) const;
 
    static ENGINE_API const FBakedAnimationStateMachine* GetMachineDescription(IAnimClassInterface* AnimBlueprintClass, const FAnimNode_StateMachine* MachineInstance);
 
    ENGINE_API int32 GetInstanceAssetPlayerIndex(FName MachineName, FName StateName, FName InstanceName = NAME_None) const;
 
    ENGINE_API float GetRecordedMachineWeight(const int32 InMachineClassIndex) const;
    ENGINE_API void RecordMachineWeight(const int32 InMachineClassIndex, const float InMachineWeight);
 
    ENGINE_API float GetRecordedStateWeight(const int32 InMachineClassIndex, const int32 InStateIndex) const;
    ENGINE_API void RecordStateWeight(const int32 InMachineClassIndex, const int32 InStateIndex, const float InStateWeight, const float InElapsedTime);
 
    ENGINE_API bool IsSlotNodeRelevantForNotifies(const FName& SlotNodeName) const;
    ENGINE_API void ResetDynamics(ETeleportType InTeleportType);
 
    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 bool IsSyncGroupValid(FName InSyncGroupName) const;
 
    UE_DEPRECATED(4.20, "Please use ResetDynamics with a ETeleportType argument")
    ENGINE_API void ResetDynamics();
 
    const FTransform& GetComponentRelativeTransform() const { return ComponentRelativeTransform; }
 
    const FTransform& GetComponentTransform() const { return ComponentTransform; }
 
    const FTransform& GetActorTransform() const { return ActorTransform; }
 
    // Trace montage debug data for the specified slot
    ENGINE_API void TraceMontageEvaluationData(const FAnimationUpdateContext& InContext, const FName& InSlotName);
 
    ENGINE_API FAnimBlueprintDebugData* GetAnimBlueprintDebugData() const;
 
    ENGINE_API void AddAnimNotifies(const TArray<FAnimNotifyEventReference>& NewNotifies, const float InstanceWeight);
 
    ENGINE_API void SetInterpolationOverride(TOptional<EAnimInterpolationType> InterpolationType);
 
    ENGINE_API TOptional<EAnimInterpolationType> GetInterpolationOverride() const;
 
    friend class UAnimInstance;
    friend class UAnimSingleNodeInstance;
    friend class USkeletalMeshComponent;
    friend struct FAnimNode_LinkedAnimGraph;
    friend struct FAnimNode_LinkedAnimLayer;
    friend struct FAnimationBaseContext;
    friend struct FAnimTrace;
    friend struct UE::Anim::FAnimSync;
    friend class UE::Anim::FAnimSyncGroupScope;
    friend class UE::Anim::FActiveStateMachineScope;
    friend struct FAnimNode_ControlRigInputPose;
    friend struct FSequencerMixedAnimInstanceProxy;
    
protected:
    ENGINE_API virtual void Initialize(UAnimInstance* InAnimInstance);
 
    ENGINE_API virtual void Uninitialize(UAnimInstance* InAnimInstance);
 
    ENGINE_API void UpdateActiveAnimNotifiesSinceLastTick(const FAnimNotifyQueue& AnimInstanceQueue);
    
    ENGINE_API virtual void PreUpdate(UAnimInstance* InAnimInstance, float DeltaSeconds);
 
    ENGINE_API void OnPreUpdateLODChanged(const int32 PreviousLODIndex, const int32 NewLODIndex);
 
    virtual void Update(float DeltaSeconds) {}
 
    ENGINE_API virtual void UpdateAnimationNode(const FAnimationUpdateContext& InContext);
 
    ENGINE_API virtual void UpdateAnimationNode_WithRoot(const FAnimationUpdateContext& InContext, FAnimNode_Base* InRootNode, FName InLayerName);
 
    ENGINE_API virtual void PreEvaluateAnimation(UAnimInstance* InAnimInstance);
 
    virtual FAnimNode_Base* GetCustomRootNode()
    {
        return nullptr;
    }
 
    virtual void GetCustomNodes(TArray<FAnimNode_Base*>& OutNodes)
    {
    }
    
    ENGINE_API virtual void CacheBones();
 
    ENGINE_API virtual void CacheBones_WithRoot(FAnimNode_Base* InRootNode);
 
    virtual bool Evaluate(FPoseContext& Output) { return false; }
 
    virtual bool Evaluate_WithRoot(FPoseContext& Output, FAnimNode_Base* InRootNode) { return Evaluate(Output); }
 
    ENGINE_API virtual void PostUpdate(UAnimInstance* InAnimInstance) const;
 
    ENGINE_API virtual void PostEvaluate(UAnimInstance* InAnimInstance);
 
    ENGINE_API virtual void InitializeObjects(UAnimInstance* InAnimInstance);
 
    ENGINE_API virtual void ClearObjects();
 
    ENGINE_API void UpdateAnimation();
 
    ENGINE_API void UpdateAnimation_WithRoot(const FAnimationUpdateContext& InContext, FAnimNode_Base* InRootNode, FName InLayerName);
 
    ENGINE_API void EvaluateAnimation(FPoseContext& Output);
 
    ENGINE_API void EvaluateAnimation_WithRoot(FPoseContext& Output, FAnimNode_Base* InRootNode);
 
    ENGINE_API void EvaluateAnimationNode(FPoseContext& Output);
 
    ENGINE_API void EvaluateAnimationNode_WithRoot(FPoseContext& Output, FAnimNode_Base* InRootNode);
 
    // @todo document
    ENGINE_API void SequenceAdvanceImmediate(UAnimSequenceBase* Sequence, bool bLooping, float PlayRate, float DeltaSeconds, /*inout*/ float& CurrentTime, FMarkerTickRecord& MarkerTickRecord);
 
    // @todo document
    ENGINE_API void BlendSpaceAdvanceImmediate(UBlendSpace* BlendSpace, const FVector& BlendInput, TArray<FBlendSampleData> & BlendSampleDataCache, FBlendFilter & BlendFilter, bool bLooping, float PlayRate, float DeltaSeconds, /*inout*/ float& CurrentTime, FMarkerTickRecord& MarkerTickRecord);
 
    UE_DEPRECATED(5.0, "Function renamed to GetBufferReadIndex as this no longer deals with sync groups.")
    int32 GetSyncGroupReadIndex() const 
    { 
        return GetBufferReadIndex(); 
    }
 
    UE_DEPRECATED(5.0, "Function renamed to GetBufferWriteIndex as this no longer deals with sync groups.")
    int32 GetSyncGroupWriteIndex() const 
    { 
        return GetBufferWriteIndex(); 
    }
 
    // Gets the buffer we should be reading from
    int32 GetBufferReadIndex() const 
    { 
        return 1 - BufferWriteIndex; 
    }
 
    // Gets the sync group we should be writing to
    int32 GetBufferWriteIndex() const 
    { 
        return BufferWriteIndex; 
    }
 
    ENGINE_API int32 GetSyncGroupIndexFromName(FName SyncGroupName) const;
 
    ENGINE_API bool GetTimeToClosestMarker(FName SyncGroup, FName MarkerName, float& OutMarkerTime) const;
 
    ENGINE_API bool HasMarkerBeenHitThisFrame(FName SyncGroup, FName MarkerName) const;
 
    ENGINE_API bool IsSyncGroupBetweenMarkers(FName InSyncGroupName, FName PreviousMarker, FName NextMarker, bool bRespectMarkerOrder = true) const;
 
    ENGINE_API FMarkerSyncAnimPosition GetSyncGroupPosition(FName InSyncGroupName) const;
 
    // Set the mirror data table to sync animations
    void SetSyncMirror(const UMirrorDataTable* MirrorDataTable)
    {
        Sync.SetMirror(MirrorDataTable);
    }
    
    // slot node run-time functions
    ENGINE_API void ReinitializeSlotNodes();
 
    // if it doesn't tick, it will keep old weight, so we'll have to clear it in the beginning of tick
    ENGINE_API void ClearSlotNodeWeights();
 
    ENGINE_API float GetSlotNodeGlobalWeight(const FName& SlotNodeName) const;
 
    ENGINE_API float GetSlotMontageGlobalWeight(const FName& SlotNodeName) const;
 
    ENGINE_API float GetSlotMontageLocalWeight(const FName& SlotNodeName) const;
 
    ENGINE_API float CalcSlotMontageLocalWeight(const FName& SlotNodeName) const;
 
    ENGINE_API void RecalcRequiredBones(USkeletalMeshComponent* Component, UObject* Asset);
 
    ENGINE_API void RecalcRequiredCurves(const UE::Anim::FCurveFilterSettings& CurveFilterSettings);
 
    UE_DEPRECATED(5.3, "Please use RecalcRequiredCurves that takes a FCurveEvaluationOption.")
    ENGINE_API void RecalcRequiredCurves(const FCurveEvaluationOption& CurveEvalOption);
    
    UE_DEPRECATED(5.3, "This function is no longer used.")
    void UpdateCurvesToComponents(USkeletalMeshComponent* Component) {}
 
    ENGINE_API const FMontageEvaluationState* GetActiveMontageEvaluationState() const;
 
    UE_DEPRECATED(5.5, "Please use GetSlotGroupInertializationRequestDataMap instead.")
    ENGINE_API TMap<FName, UE::Anim::FSlotInertializationRequest>& GetSlotGroupInertializationRequestMap();
    
    ENGINE_API TMap<FName, FInertializationRequest>& GetSlotGroupInertializationRequestDataMap();
 
    ENGINE_API TArray<FMontageEvaluationState>& GetMontageEvaluationData();
 
    ENGINE_API const TArray<FMontageEvaluationState>& GetMontageEvaluationData() 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;
 
    template<class NodeType>
    NodeType* GetNodeFromProperty(FProperty* Property)
    {
        return (NodeType*)Property->ContainerPtrToValuePtr<NodeType>(AnimInstanceObject);
    }
 
    ENGINE_API float GetInstanceAssetPlayerLength(int32 AssetPlayerIndex) const;
 
    ENGINE_API float GetInstanceAssetPlayerTime(int32 AssetPlayerIndex) const;
 
    ENGINE_API float GetInstanceAssetPlayerTimeFraction(int32 AssetPlayerIndex) const;
 
    ENGINE_API float GetInstanceAssetPlayerTimeFromEnd(int32 AssetPlayerIndex) const;
 
    ENGINE_API float GetInstanceAssetPlayerTimeFromEndFraction(int32 AssetPlayerIndex) const;
 
    ENGINE_API float GetInstanceMachineWeight(int32 MachineIndex) const;
 
    ENGINE_API float GetInstanceStateWeight(int32 MachineIndex, int32 StateIndex) const;
 
    ENGINE_API float GetInstanceCurrentStateElapsedTime(int32 MachineIndex) const;
 
    ENGINE_API float GetInstanceTransitionCrossfadeDuration(int32 MachineIndex, int32 TransitionIndex) const;
 
    ENGINE_API float GetInstanceTransitionTimeElapsed(int32 MachineIndex, int32 TransitionIndex) const;
 
    ENGINE_API float GetInstanceTransitionTimeElapsedFraction(int32 MachineIndex, int32 TransitionIndex) const;
 
    ENGINE_API float GetRelevantAnimTimeRemaining(int32 MachineIndex, int32 StateIndex) const;
 
    ENGINE_API float GetRelevantAnimTimeRemainingFraction(int32 MachineIndex, int32 StateIndex) const;
 
    ENGINE_API float GetRelevantAnimLength(int32 MachineIndex, int32 StateIndex) const;
 
    ENGINE_API float GetRelevantAnimTime(int32 MachineIndex, int32 StateIndex) const;
 
    ENGINE_API float GetRelevantAnimTimeFraction(int32 MachineIndex, int32 StateIndex) const;
 
    ENGINE_API bool WasAnimNotifyStateActiveInAnyState(TSubclassOf<UAnimNotifyState> AnimNotifyStateType) const;
 
    ENGINE_API bool WasAnimNotifyStateActiveInStateMachine(int32 MachineIndex, TSubclassOf<UAnimNotifyState> AnimNotifyStateType) const;
 
    ENGINE_API bool WasAnimNotifyStateActiveInSourceState(int32 MachineIndex, int32 StateIndex, TSubclassOf<UAnimNotifyState> AnimNotifyStateType) const;
    
    ENGINE_API bool WasAnimNotifyTriggeredInSourceState(int32 MachineIndex, int32 StateIndex, TSubclassOf<UAnimNotify> AnimNotifyType) const;
 
    ENGINE_API bool WasAnimNotifyNameTriggeredInSourceState(int32 MachineIndex, int32 StateIndex, FName NotifyName) const;
 
    ENGINE_API bool WasAnimNotifyTriggeredInStateMachine(int32 MachineIndex, TSubclassOf<UAnimNotify> AnimNotifyType) const;
 
    ENGINE_API bool WasAnimNotifyTriggeredInAnyState(TSubclassOf<UAnimNotify> AnimNotifyType) const;
 
    ENGINE_API bool WasAnimNotifyNameTriggeredInAnyState(FName NotifyName) const;
    
    ENGINE_API bool WasAnimNotifyNameTriggeredInStateMachine(int32 MachineIndex, FName NotifyName);
 
    ENGINE_API bool RequestTransitionEvent(const FName& EventName, const double RequestTimeout, const ETransitionRequestQueueMode& QueueMode, const ETransitionRequestOverwriteMode& OverwriteMode);
    
    ENGINE_API void ClearTransitionEvents(const FName& EventName);
 
    ENGINE_API void ClearAllTransitionEvents();
 
    ENGINE_API bool QueryTransitionEvent(int32 NodeIndex, int32 TransitionIndex, const FName& EventName) const;
 
    ENGINE_API bool QueryAndMarkTransitionEvent(int32 NodeIndex, int32 TransitionIndex, const FName& EventName);
 
    // 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, const FName& BindingName = NAME_None);
    
    // 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, const FName& BindingName = NAME_None);
 
    // 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);
 
    ENGINE_API void BindNativeDelegates();
 
    ENGINE_API const FBakedAnimationStateMachine* GetStateMachineInstanceDesc(FName MachineName) const;
 
    ENGINE_API int32 GetStateMachineIndex(FName MachineName) const;
 
    ENGINE_API int32 GetStateMachineIndex(FAnimNode_StateMachine* StateMachine) const;
 
    ENGINE_API void GetStateMachineIndexAndDescription(FName InMachineName, int32& OutMachineIndex, const FBakedAnimationStateMachine** OutMachineDescription) const;
 
    ENGINE_API void InitializeRootNode(bool bInDeferRootNodeInitialization = false);
 
    ENGINE_API void InitializeRootNode_WithRoot(FAnimNode_Base* InRootNode);
 
    ENGINE_API virtual void AddReferencedObjects(UAnimInstance* InAnimInstance, FReferenceCollector& Collector);
 
    ENGINE_API void LogMessage(FName InLogType, EMessageSeverity::Type InSeverity, const FText& InMessage) const;
    ENGINE_API void LogMessage(FName InLogType, const TSharedRef<FTokenizedMessage>& InMessage) const;
 
    TMap<FName, float>& GetAnimationCurves(EAnimCurveType InCurveType) { return AnimationCurves[(uint8)InCurveType]; }
    const TMap<FName, float>& GetAnimationCurves(EAnimCurveType InCurveType) const { return AnimationCurves[(uint8)InCurveType]; }
 
    ENGINE_API void ResetAnimationCurves();
 
    ENGINE_API void UpdateCurvesToEvaluationContext(const FAnimationEvaluationContext& InContext);
 
    ENGINE_API void UpdateCurvesPostEvaluation(USkeletalMeshComponent* SkelMeshComp);
 
    ENGINE_API bool HasActiveCurves() const;
 
    
    UE_DEPRECATED(5.3, "Please use AddCurveValue that does not take a FSmartNameMapping.")
    void AddCurveValue(const FSmartNameMapping& Mapping, const FName& CurveName, float Value) { AddCurveValue(CurveName, Value); }
 
    ENGINE_API void AddCurveValue(const FName& CurveName, float Value, bool bMorphtarget = false, bool bMaterial = false);
    
    static ENGINE_API void InitializeInputProxy(FAnimInstanceProxy* InputProxy, UAnimInstance* InAnimInstance);
    static ENGINE_API void GatherInputProxyDebugData(FAnimInstanceProxy* InputProxy, FNodeDebugData& DebugData);
    static ENGINE_API void CacheBonesInputProxy(FAnimInstanceProxy* InputProxy);
    static ENGINE_API void UpdateInputProxy(FAnimInstanceProxy* InputProxy, const FAnimationUpdateContext& Context);
    static ENGINE_API void EvaluateInputProxy(FAnimInstanceProxy* InputProxy, FPoseContext& Output);
    static ENGINE_API void ResetCounterInputProxy(FAnimInstanceProxy* InputProxy);
 
    void ResetSync()
    {
        Sync.ResetAll();
    }
 
#if ENABLE_ANIM_DRAW_DEBUG
    void FlushQueuedDebugDrawItems(AActor* InActor, UWorld* InWorld) const;
#endif
 
private:
 
    FName GetTargetLogNameForCurrentWorldType() const;
 
    ENGINE_API void ForEachStateMachine(const TFunctionRef<void(FAnimNode_StateMachine&)>& Functor);
 
    ENGINE_API void SlotEvaluatePoseWithBlendProfiles(const FName& SlotNodeName, const FAnimationPoseData& SourceAnimationPoseData, float InSourceWeight, FAnimationPoseData& OutBlendedAnimationPoseData, float InBlendWeight);
 
    ENGINE_API void InitializeCachedClassData();
    
    FTransform ComponentTransform;
 
    FTransform ComponentRelativeTransform;
 
    FTransform ActorTransform;
 
    mutable UObject* AnimInstanceObject;
 
    IAnimClassInterface* AnimClassInterface;
 
    USkeleton* Skeleton;
 
    USkeletalMeshComponent* SkeletalMeshComponent;
 
    FAnimInstanceProxy* MainInstanceProxy;
 
    float CurrentDeltaSeconds;
 
    float CurrentTimeDilation;
 
#if WITH_EDITORONLY_DATA
    TArray<FAnimBlueprintDebugData_NodeVisit> UpdatedNodesThisFrame;
 
    TMap<int32, TArray<FAnimBlueprintDebugData_AttributeRecord>> NodeInputAttributesThisFrame;
    TMap<int32, TArray<FAnimBlueprintDebugData_AttributeRecord>> NodeOutputAttributesThisFrame;
 
    TMap<int32, FName> NodeSyncsThisFrame;
#endif
 
#if ENABLE_ANIM_LOGGING
    FString ActorName;
#endif
 
    FAnimNode_Base* RootNode;
 
    FAnimNode_LinkedInputPose* DefaultLinkedInstanceInputNode;
 
    TMap<FName, TArray<FAnimNode_SaveCachedPose*>> SavedPoseQueueMap;
 
    UE::Anim::FAnimSync Sync;
 
    TArray<float> MachineWeightArrays[2];
 
    TArray<float> StateWeightArrays[2];
 
    TMap<int32, int32> StateMachineClassIndexToWeightOffset;
 
    // Current buffer index
    int32 BufferWriteIndex;
 
    FAnimNotifyQueue NotifyQueue;
 
    // Root motion mode duplicated from the anim instance
    ERootMotionMode::Type RootMotionMode;
 
    // Read/write buffers Tracker map for slot name->weights/relevancy
    TMap<FName, int32> SlotNameToTrackerIndex;
    TArray<FMontageActiveSlotTracker> SlotWeightTracker[2];
 
    TMap<FName, float> AnimationCurves[(uint8)EAnimCurveType::MaxAnimCurveType];
 
    TSet<FName> MaterialParametersToClear;
 
protected:
    // Animation Notifies that has been triggered since the last tick. These can be safely consumed at any point.
    TArray<FAnimNotifyEventReference> ActiveAnimNotifiesSinceLastTick;
    
    // Counters for synchronization
    FGraphTraversalCounter InitializationCounter;
    FGraphTraversalCounter CachedBonesCounter;
    FGraphTraversalCounter UpdateCounter;
    FGraphTraversalCounter EvaluationCounter;
    FGraphTraversalCounter SlotNodeInitializationCounter;
 
    // Sync counter
    uint64 FrameCounterForUpdate;
    uint64 FrameCounterForNodeUpdate;
 
    TOptional<EAnimInterpolationType> InterpolationOverride;
 
private:
    // Root motion extracted from animation since the last time ConsumeExtractedRootMotion was called
    FRootMotionMovementParams ExtractedRootMotion;
 
    TSharedPtr<FBoneContainer> RequiredBones;
 
    int32 LODLevel = 0;
 
    int32 CacheBonesRecursionCounter;
 
    int16 NumUroSkippedFrames_Update;
    int16 NumUroSkippedFrames_Eval;
 
private:
    TArray<FMontageEvaluationState> MontageEvaluationData;
 
    UE_DEPRECATED(5.5, "This property is deprecated. Please use SlotGroupInertializationRequestDataMap instead")
    TMap<FName, UE::Anim::FSlotInertializationRequest> SlotGroupInertializationRequestMap;
 
    // Inertialization request for each slot.
    UPROPERTY(Transient)
    TMap<FName, FInertializationRequest> SlotGroupInertializationRequestDataMap;
 
    TArray<FAnimNode_Base*> GameThreadPreUpdateNodes;
 
    TArray<FAnimNode_Base*> LODDisabledGameThreadPreUpdateNodes;
 
    TArray<FAnimNode_Base*> DynamicResetNodes;
    
    TArray<FNativeTransitionBinding> NativeTransitionBindings;
 
    TArray<FNativeStateBinding> NativeStateEntryBindings;
 
    TArray<FNativeStateBinding> NativeStateExitBindings;
 
    TArray<FPoseSnapshot> PoseSnapshots;
 
#if ENABLE_ANIM_LOGGING
    typedef TSharedRef<FTokenizedMessage> FLogMessageEntry;
    mutable TMap<FName, TArray<FLogMessageEntry>> LoggedMessagesMap;
 
    mutable TArray<FGuid> PreviouslyLoggedMessages;
#endif
 
    bool bUpdatingRoot;
 
protected:
    uint8 bBoneCachesInvalidated : 1;
 
private:
    // Diplicate of bool result of ShouldExtractRootMotion()
    uint8 bShouldExtractRootMotion : 1;
 
    uint8 bDeferRootNodeInitialization : 1;
 
#if WITH_EDITORONLY_DATA
    uint8 bIsBeingDebugged : 1;
 
    uint8 bIsGameWorld : 1;
#endif
 
    // Whether subsystems should be initialized
    uint8 bInitializeSubsystems : 1;
 
    uint8 bUseMainInstanceMontageEvaluationData : 1;
};
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "Animation/AnimTrace.h"
#endif