SkeletalMeshComponent.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 "Engine/EngineBaseTypes.h"
#include "Components/SceneComponent.h"
#include "EngineDefines.h"
#include "CollisionQueryParams.h"
#include "Interfaces/Interface_CollisionDataProvider.h"
#include "Animation/AnimationAsset.h"
#include "Animation/AnimCurveTypes.h"
#include "Components/SkinnedMeshComponent.h"
#include "ClothSimData.h"
#include "SingleAnimationPlayData.h"
#include "Animation/PoseSnapshot.h"
#include "ClothingSystemRuntimeTypes.h"
#include "Animation/AttributesRuntime.h"
#include "Chaos/Serialization/SerializedDataBuffer.h"
#if WITH_ENGINE
#include "Engine/PoseWatchRenderData.h"
#endif
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_7
#include "ClothingSimulationInterface.h"
#include "ClothingSimulationFactory.h"
#endif
 
#include "SkeletalMeshComponent.generated.h"
 
 
class Error;
class FPrimitiveDrawInterface;
class FCanvas;
class FSceneView;
class UAnimInstance;
class UPhysicalMaterial;
class USkeletalMesh;
class USkeletalMeshComponent;
struct FClothCollisionData;
struct FClothCollisionSource;
struct FClothingSimulationInstance;
struct FConstraintInstance;
struct FConstraintProfileProperties;
struct FNavigableGeometryExport;
struct FCompactPose;
 
namespace UE::UAF
{
    class FDataRegistry;    // Temporary
}
 
enum class EClothingTeleportMode : uint8;
 
#ifndef WITH_CLOTH_COLLISION_DETECTION
#define WITH_CLOTH_COLLISION_DETECTION 1
#endif
 
DECLARE_MULTICAST_DELEGATE(FOnSkelMeshPhysicsCreatedMultiCast);
typedef FOnSkelMeshPhysicsCreatedMultiCast::FDelegate FOnSkelMeshPhysicsCreated;
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnAnimInitialized);
 
DECLARE_MULTICAST_DELEGATE(FOnSkelMeshTeleportedMultiCast);
typedef FOnSkelMeshTeleportedMultiCast::FDelegate FOnSkelMeshTeleported;
 
class UE_DEPRECATED(5.5, "use FOnBoneTransformsFinalizedMultiCast instead (see SkinnedMeshComponent.h).") FOnBoneTransformsFinalized;
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnBoneTransformsFinalized);  // Deprecated, use FOnBoneTransformsFinalizedMultiCast instead
 
DECLARE_TS_MULTICAST_DELEGATE_ThreeParams(FOnLODRequiredBonesUpdateMulticast, USkeletalMeshComponent*, int32, const TArray<FBoneIndexType>&);
typedef FOnLODRequiredBonesUpdateMulticast::FDelegate FOnLODRequiredBonesUpdate;
 
UENUM()
enum class ECustomBoneAttributeLookup : uint8
{
    BoneOnly,
    ImmediateParent,
    ParentHierarchy
};
 
struct FAnimationEvaluationContext
{
    // The anim instance we are evaluating
    UAnimInstance* AnimInstance;
 
    // The post process instance we are evaluating
    UAnimInstance* PostProcessAnimInstance;
 
    // The SkeletalMesh we are evaluating for
    USkeletalMesh* SkeletalMesh;
 
    // Evaluation data, swapped in from the component when we are running parallel eval
    TArray<FTransform> ComponentSpaceTransforms;
    TArray<FTransform> BoneSpaceTransforms;
    TArray<FTransform> CachedComponentSpaceTransforms;
    TArray<FTransform> CachedBoneSpaceTransforms;
    FVector RootBoneTranslation;
 
    // Are we performing interpolation this tick
    bool bDoInterpolation;
 
    // Are we evaluating this tick
    bool bDoEvaluation;
 
    // Are we storing data in cache bones this tick
    bool bDuplicateToCacheBones;
 
    // duplicate the cache curves
    bool bDuplicateToCacheCurve;
 
    // duplicate the cached attributes
    bool bDuplicateToCachedAttributes;
 
    // Force reference pose
    bool bForceRefPose;
 
    // Curve data, swapped in from the component when we are running parallel eval
    FBlendedHeapCurve   Curve;
    FBlendedHeapCurve   CachedCurve;
 
    // attribute data, swapped in from the component when we are running parallel eval
    UE::Anim::FMeshAttributeContainer CustomAttributes;
    UE::Anim::FMeshAttributeContainer CachedCustomAttributes;
 
    FAnimationEvaluationContext()
    {
        Clear();
    }
 
    void Copy(const FAnimationEvaluationContext& Other)
    {
        AnimInstance = Other.AnimInstance;
        PostProcessAnimInstance = Other.PostProcessAnimInstance;
        SkeletalMesh = Other.SkeletalMesh;
        ComponentSpaceTransforms.Reset();
        ComponentSpaceTransforms.Append(Other.ComponentSpaceTransforms);
        BoneSpaceTransforms.Reset();
        BoneSpaceTransforms.Append(Other.BoneSpaceTransforms);
        CachedComponentSpaceTransforms.Reset();
        CachedComponentSpaceTransforms.Append(Other.CachedComponentSpaceTransforms);
        CachedBoneSpaceTransforms.Reset();
        CachedBoneSpaceTransforms.Append(Other.CachedBoneSpaceTransforms);
        RootBoneTranslation = Other.RootBoneTranslation;
        Curve.CopyFrom(Other.Curve);
        CachedCurve.CopyFrom(Other.CachedCurve);
        bDoInterpolation = Other.bDoInterpolation;
        bDoEvaluation = Other.bDoEvaluation;
        bDuplicateToCacheBones = Other.bDuplicateToCacheBones;
        bDuplicateToCacheCurve = Other.bDuplicateToCacheCurve;
        bDuplicateToCachedAttributes = Other.bDuplicateToCachedAttributes;
        bForceRefPose = Other.bForceRefPose;
 
        CustomAttributes.CopyFrom(Other.CustomAttributes);
        CachedCustomAttributes.CopyFrom(Other.CachedCustomAttributes);
    }
 
    void Clear()
    {
        AnimInstance = nullptr;
        PostProcessAnimInstance = nullptr;
        SkeletalMesh = nullptr;
    }
 
};
 
UENUM()
namespace EKinematicBonesUpdateToPhysics
{
    enum Type : int
    {
        SkipSimulatingBones,
        SkipAllBones
    };
}
 
UENUM()
namespace EAnimationMode
{
    enum Type : int
    {
        AnimationBlueprint UMETA(DisplayName="Use Animation Blueprint"), 
        AnimationSingleNode UMETA(DisplayName="Use Animation Asset"), 
        // This is custom type, engine leaves AnimInstance as it is
        AnimationCustomMode UMETA(DisplayName = "Use Custom Mode"),
    };
}
 
UENUM()
namespace EPhysicsTransformUpdateMode
{
    enum Type : int
    {
        SimulationUpatesComponentTransform UMETA(DisplayName="Simulation Updates Component Transform"), 
        ComponentTransformIsKinematic
    };
}
 
enum class EAllowKinematicDeferral
{
    AllowDeferral,
    DisallowDeferral
};
 
USTRUCT()
struct FSkeletalMeshComponentEndPhysicsTickFunction : public FTickFunction
{
    GENERATED_USTRUCT_BODY()
 
     USkeletalMeshComponent*    Target;
 
    virtual void ExecuteTick(float DeltaTime, enum ELevelTick TickType, ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent) override;
    virtual FString DiagnosticMessage() override;
    virtual FName DiagnosticContext(bool bDetailed) override;
};
 
template<>
struct TStructOpsTypeTraits<FSkeletalMeshComponentEndPhysicsTickFunction> : public TStructOpsTypeTraitsBase2<FSkeletalMeshComponentEndPhysicsTickFunction>
{
    enum
    {
        WithCopy = false
    };
};
 
 
USTRUCT()
struct FSkeletalMeshComponentClothTickFunction : public FTickFunction
{
    GENERATED_USTRUCT_BODY()
 
    USkeletalMeshComponent* Target;
 
    virtual void ExecuteTick(float DeltaTime, enum ELevelTick TickType, ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent) override;
    virtual FString DiagnosticMessage() override;
    virtual FName DiagnosticContext(bool bDetailed) override;
};
 
template<>
struct TStructOpsTypeTraits<FSkeletalMeshComponentClothTickFunction> : public TStructOpsTypeTraitsBase2<FSkeletalMeshComponentClothTickFunction>
{
    enum
    {
        WithCopy = false
    };
};
 
 
struct FClosestPointOnPhysicsAsset
{
    FVector ClosestWorldPosition;
 
    FVector Normal;
 
    FName BoneName;
 
    float Distance;
 
    FClosestPointOnPhysicsAsset()
        : ClosestWorldPosition(FVector::ZeroVector)
        , Normal(FVector::ZeroVector)
        , BoneName(NAME_None)
        , Distance(-1.f)
    {
    }
};
 
namespace Chaos
{
    struct FSerializedDataBuffer;
}
 
UCLASS(Blueprintable, ClassGroup=(Rendering, Common), hidecategories=(Object, "Mesh|SkeletalAsset"), config=Engine, editinlinenew, meta=(BlueprintSpawnableComponent), MinimalAPI)
class USkeletalMeshComponent : public USkinnedMeshComponent, public IInterface_CollisionDataProvider
{
    GENERATED_UCLASS_BODY()
 
    friend class FSkinnedMeshComponentRecreateRenderStateContext;
    friend class FParallelAnimationCompletionTask;
    friend class USkeletalMesh; 
    friend class UAnimInstance;
    friend struct FAnimNode_LinkedAnimGraph;
    friend struct FAnimNode_LinkedAnimLayer;
    friend struct FLinkedInstancesAdapter;
    friend struct FLinkedAnimLayerClassData;
    friend struct FRigUnit_AnimNextWriteSkeletalMeshComponentPose;
    friend struct FRigUnit_AnimNextRemapPose;
    
#if WITH_EDITORONLY_DATA 
private:
    UE_DEPRECATED(5.1, "This property isn't deprecated, but getter and setter must be used at all times to preserve correct operations.")
    UPROPERTY(EditAnywhere, Transient, Setter = SetSkeletalMeshAsset, BlueprintSetter = SetSkeletalMeshAsset, Getter = GetSkeletalMeshAsset, BlueprintGetter = GetSkeletalMeshAsset, Category = Mesh)
    TObjectPtr<USkeletalMesh> SkeletalMeshAsset;
#endif
 
public:
    UFUNCTION(BlueprintCallable, Category = "Components|SkeletalMesh")
    void SetSkeletalMeshAsset(USkeletalMesh* NewMesh) { SetSkeletalMesh(NewMesh, false); }
 
    UFUNCTION(BlueprintPure, Category = "Components|SkeletalMesh")
    ENGINE_API USkeletalMesh* GetSkeletalMeshAsset() const;
 
    void RefreshSkeletalMeshAsset();
 
    ENGINE_API TSharedPtr<struct FBoneContainer> GetSharedRequiredBones();
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TObjectPtr<class UAnimBlueprint> AnimationBlueprint_DEPRECATED;
 
    UE_DEPRECATED(4.11, "This property is deprecated. Please use AnimClass instead")
    UPROPERTY(BlueprintReadOnly, Category = Animation, meta = (DeprecationMessage = "This property is deprecated. Please use AnimClass instead"))
    TObjectPtr<class UAnimBlueprintGeneratedClass> AnimBlueprintGeneratedClass;
#endif
 
    /* The AnimBlueprint class to use. Use 'SetAnimInstanceClass' to change at runtime. */
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Setter = SetAnimInstanceClass_Internal, Category = Animation, meta=(EditCondition = bEnableAnimation))
    class TSubclassOf<UAnimInstance> AnimClass;
 
    UPROPERTY(transient, NonTransactional)
    TObjectPtr<UAnimInstance> AnimScriptInstance;
 
#if WITH_EDITORONLY_DATA
    UE_DEPRECATED(4.24, "Direct access to this property is deprecated and the array is no longer used. Storage is now in LinkedInstances. Please use GetLinkedAnimInstances() instead.")
    UPROPERTY(transient)
    TArray<TObjectPtr<UAnimInstance>> SubInstances;
#endif
 
    UPROPERTY(transient)
    TSubclassOf<UAnimInstance> OverridePostProcessAnimBP;
 
    ENGINE_API TSubclassOf<UAnimInstance> GetPostProcessAnimBPClassToBeUsed() const;
 
    UPROPERTY(transient)
    TObjectPtr<UAnimInstance> PostProcessAnimInstance;
 
public:
    UFUNCTION(BlueprintCallable, Category = "Components|SkeletalMesh")
    ENGINE_API void SetOverridePostProcessAnimBP(TSubclassOf<UAnimInstance> InPostProcessAnimBlueprint, bool ReinitAnimInstances = true);
 
    UFUNCTION(BlueprintCallable, Category="Components|SkeletalMesh")
    ENGINE_API void ToggleDisablePostProcessBlueprint();
 
    UFUNCTION(BlueprintGetter)
    ENGINE_API bool GetDisablePostProcessBlueprint() const;
 
    UFUNCTION(BlueprintSetter)
    ENGINE_API void SetDisablePostProcessBlueprint(bool bInDisablePostProcess);
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Animation, meta=(ShowOnlyInnerProperties, EditCondition = bEnableAnimation))
    struct FSingleAnimationPlayData AnimationData;
 
    // this is explicit copy because this buffer is reused during evaluation
    // we want to have reference and emptied during evaluation
    ENGINE_API TArray<FTransform> GetBoneSpaceTransforms();
 
    ENGINE_API TArrayView<const FTransform> GetBoneSpaceTransformsView();
 
    UE_DEPRECATED(4.23, "Direct access to this property is deprecated, please use GetBoneSpaceTransforms instead. We will move to private in the future.")
    TArray<FTransform> BoneSpaceTransforms;
 
public:
    UPROPERTY(transient)
    FVector RootBoneTranslation;
 
    UPROPERTY()
    FVector LineCheckBoundsScale;
 
    UE_DEPRECATED(5.6, "Direct access to this property is deprecated, please use GetAnimCurves or GetCurveValue instead. We will move to private in the future.")
    FBlendedHeapCurve AnimCurves;
 
    ENGINE_API const TArray<FTransform>& GetCachedComponentSpaceTransforms() const;
 
private:
    UPROPERTY(transient)
    TArray<TObjectPtr<UAnimInstance>> LinkedInstances;
 
    TSharedPtr<struct FBoneContainer> SharedRequiredBones;
 
    // Update Rate
 
    UPROPERTY(Transient)
    TArray<FTransform> CachedBoneSpaceTransforms;
 
    UPROPERTY(Transient)
    TArray<FTransform> CachedComponentSpaceTransforms;
 
    FBlendedHeapCurve CachedCurve;
 
    UE::Anim::FMeshAttributeContainer CachedAttributes;
    UE::Anim::FMeshAttributeContainer CustomAttributes;
public:
    UFUNCTION(BlueprintCallable, Category=CustomAttributes)
    ENGINE_API bool GetFloatAttribute_Ref(const FName& BoneName, const FName& AttributeName, UPARAM(ref) float& OutValue, ECustomBoneAttributeLookup LookupType = ECustomBoneAttributeLookup::BoneOnly);
 
    UFUNCTION(BlueprintCallable, Category = CustomAttributes)
    ENGINE_API bool GetTransformAttribute_Ref(const FName& BoneName, const FName& AttributeName, UPARAM(ref) FTransform& OutValue, ECustomBoneAttributeLookup LookupType = ECustomBoneAttributeLookup::BoneOnly);
 
    UFUNCTION(BlueprintCallable, Category = CustomAttributes)
    ENGINE_API bool GetIntegerAttribute_Ref(const FName& BoneName, const FName& AttributeName, UPARAM(ref) int32& OutValue, ECustomBoneAttributeLookup LookupType = ECustomBoneAttributeLookup::BoneOnly);
 
    UFUNCTION(BlueprintCallable, Category = CustomAttributes)
    ENGINE_API bool GetStringAttribute_Ref(const FName& BoneName, const FName& AttributeName, UPARAM(ref) FString& OutValue, ECustomBoneAttributeLookup LookupType = ECustomBoneAttributeLookup::BoneOnly);
 
    UFUNCTION(BlueprintCallable, Category = CustomAttributes)
    ENGINE_API bool GetFloatAttribute(const FName& BoneName, const FName& AttributeName, float DefaultValue, float& OutValue, ECustomBoneAttributeLookup LookupType = ECustomBoneAttributeLookup::BoneOnly);
    
    UFUNCTION(BlueprintCallable, Category = CustomAttributes)
    ENGINE_API bool GetTransformAttribute(const FName& BoneName, const FName& AttributeName, FTransform DefaultValue, FTransform& OutValue, ECustomBoneAttributeLookup LookupType = ECustomBoneAttributeLookup::BoneOnly);
 
    UFUNCTION(BlueprintCallable, Category = CustomAttributes)
    ENGINE_API bool GetIntegerAttribute(const FName& BoneName, const FName& AttributeName, int32 DefaultValue, int32& OutValue, ECustomBoneAttributeLookup LookupType = ECustomBoneAttributeLookup::BoneOnly);
 
    UFUNCTION(BlueprintCallable, Category = CustomAttributes)
    ENGINE_API bool GetStringAttribute(const FName& BoneName, const FName& AttributeName, FString DefaultValue, FString& OutValue, ECustomBoneAttributeLookup LookupType = ECustomBoneAttributeLookup::BoneOnly);
 
    UFUNCTION(BlueprintCallable, Category = Curve) 
    ENGINE_API bool GetCurveValue(FName CurveName, float DefaultValue, float& Value) const;
 
    ENGINE_API const FBlendedHeapCurve& GetAnimCurves() const;
 
protected:
    template<typename DataType, typename CustomAttributeType>
    bool FindAttributeChecked(const FName& BoneName, const FName& AttributeName, DataType DefaultValue, DataType& OutValue, ECustomBoneAttributeLookup LookupType); 
 
public:
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category=Animation, meta=(EditCondition = bEnableAnimation, ClampMin = 0.f))
    float GlobalAnimRateScale;
    
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category=SkeletalMesh)
    TEnumAsByte<EKinematicBonesUpdateToPhysics::Type> KinematicBonesUpdateType;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Physics)
    TEnumAsByte<EPhysicsTransformUpdateMode::Type> PhysicsTransformUpdateMode;
 
    UPROPERTY(Interp, Transient, BlueprintReadOnly, VisibleAnywhere,  Category=Clothing) // This property is explicitly hidden from the details panel inside FSkeletalMeshComponentDetails::UpdatePhysicsCategory
    EClothingTeleportMode ClothTeleportMode;
 
protected:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Animation, meta=(EditCondition = bEnableAnimation))
    TEnumAsByte<EAnimationMode::Type>   AnimationMode;
public:
    // helper function to get the member name and verify it exists, without making it public
    static ENGINE_API const FName& GetAnimationModePropertyNameChecked();
 
    // helper function to get the member name and verify it exists, without making it public
#if WITH_EDITORONLY_DATA
    static ENGINE_API FName GetSkeletalMeshAssetPropertyNameChecked();
#endif // WITH_EDITORONLY_DATA
 
private:
    ETeleportType PendingTeleportType;
 
    UPROPERTY(EditAnywhere, BlueprintGetter=GetDisablePostProcessBlueprint, BlueprintSetter=SetDisablePostProcessBlueprint, Category = Animation, meta=(EditCondition = bEnableAnimation))
    uint8 bDisablePostProcessBlueprint:1;
 
public:
    uint8 bSimulationUpdatesChildTransforms:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Physics)
    uint8 bUpdateOverlapsOnAnimationFinalize:1;
 
    uint8 bLocalSpaceKinematics:1;
 
    UPROPERTY(transient)
    uint8 bHasValidBodies:1;
 
 
    UPROPERTY(transient)
    uint8 bBlendPhysics:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category = SkeletalMesh)
    uint8 bEnablePhysicsOnDedicatedServer:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category = SkeletalMesh)
    uint8 bUpdateMeshWhenKinematic:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category=SkeletalMesh)
    uint8 bUpdateJointsFromAnimation:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Clothing)
    uint8 bAllowClothActors:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Clothing)
    uint8 bDisableClothSimulation:1;
 
    int32 DeferredKinematicUpdateIndex;
 
private:
    UPROPERTY(EditAnywhere, Category = Physics)
    uint8 bDisableRigidBodyAnimNode:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = SkeletalMesh)
    uint8 bAllowAnimCurveEvaluation : 1;
 
#if WITH_EDITORONLY_DATA
    UE_DEPRECATED(4.18, "This property is deprecated. Please use bAllowAnimCurveEvaluatiuon instead. Note that the meaning is reversed.")   
    UPROPERTY()
    uint8 bDisableAnimCurves_DEPRECATED : 1;
#endif
 
    uint8 bBindClothToLeaderComponent:1;
 
    uint8 bPendingClothTransformUpdate:1;
 
    uint8 bPendingClothCollisionUpdate:1;
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Clothing)
    uint8 bCollideWithEnvironment:1;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Clothing)
    uint8 bCollideWithAttachedChildren:1;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Clothing)
    uint8 bForceCollisionUpdate : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Clothing, Meta = (UIMin = 0.f, UIMax = 1.f, ClampMin = 0.f, ClampMax = 1.f))
    float ClothVelocityScale = 1.f;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Clothing)
    uint8 bResetAfterTeleport:1;
 
    uint8 bPrevDisableClothSimulation : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = SkeletalMesh)
    uint8 bDeferKinematicBoneUpdate : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category=SkeletalMesh)
    uint8 bNoSkeletonUpdate:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category=Animation, meta=(EditCondition = bEnableAnimation))
    uint8 bPauseAnims:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Animation)
    uint8 bEnableAnimation : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Animation, meta=(EditCondition = bEnableAnimation))
    uint8 bUseRefPoseOnInitAnim:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=SkeletalMesh)
    uint8 bEnablePerPolyCollision:1;
 
    UPROPERTY()
    uint8 bForceRefpose:1;
    
    UPROPERTY(Transient)
    uint8 bOnlyAllowAutonomousTickPose : 1;
 
    UPROPERTY(Transient)
    uint8 bIsAutonomousTickPose : 1;
 
    UPROPERTY()
    uint8 bOldForceRefPose:1;
 
    UPROPERTY()
    uint8 bShowPrePhysBones:1;
 
    UPROPERTY(transient)
    uint8 bRequiredBonesUpToDate:1;
 
    UPROPERTY(transient)
    uint8 bAnimTreeInitialised:1;
 
    UPROPERTY()
    uint8 bEnableLineCheckWithBounds:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = LeaderPoseComponent)
    uint8 bPropagateCurvesToFollowers : 1;
 
#if WITH_EDITORONLY_DATA
    UE_DEPRECATED(5.1, "This property is deprecated. Please use bPropagateCurvesToFollowers instead")
    uint8 bPropagateCurvesToSlaves : 1;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category = Optimization)
    uint8 bSkipKinematicUpdateWhenInterpolating:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category = Optimization)
    uint8 bSkipBoundsUpdateWhenInterpolating:1;
 
protected:
 
    uint8 bClothingSimulationSuspended:1;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(AdvancedDisplay, EditInstanceOnly, transient, Category = SkeletalMesh)
    uint8 bUpdateAnimationInEditor : 1;
    UPROPERTY(AdvancedDisplay, EditInstanceOnly, transient, Category = SkeletalMesh)
    uint8 bUpdateClothInEditor : 1;
 
    UPROPERTY(AdvancedDisplay,EditAnywhere, Category = SkeletalMesh, meta = (InlineEditConditionToggle))
    uint8 bOverrideDefaultAnimatingRig : 1;
 
#endif
 
    uint8 bNotifySyncComponentToRBPhysics : 1;
 
private:
 
    UPROPERTY(Transient)
    uint8 bNeedsQueuedAnimEventsDispatched:1;
 
    uint8 bPostEvaluatingAnimation:1;
 
public:
    FPhysicsAggregateHandle Aggregate;
 
public:
 
    UPROPERTY(transient)
    uint16 CachedAnimCurveUidVersion;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Interp, Category = Clothing)
    float ClothBlendWeight;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Clothing)
    bool bWaitForParallelClothTask;
 
private:
 
    UPROPERTY(transient)
    bool bFilteredAnimCurvesIsAllowList = false;
 
    UPROPERTY(transient)
    uint16 CachedMeshCurveMetaDataVersion;
    
    UPROPERTY(transient)
    TArray<FName> FilteredAnimCurves;
 
public:
 
    UPROPERTY(transient)
    TObjectPtr<class UBodySetup>  BodySetup;
 
    ENGINE_API void CreateBodySetup();
 
#if UE_ENABLE_DEBUG_DRAWING
    ENGINE_API virtual void SendRenderDebugPhysics(FPrimitiveSceneProxy* OverrideSceneProxy = nullptr) override;
#endif
 
public:
 
    int32 RagdollAggregateThreshold;
 
    UPROPERTY(Interp, BlueprintReadWrite, Category=Clothing, meta=(UIMin = 0.0, UIMax = 10.0, ClampMin = 0.0, ClampMax = 10000.0))
    float ClothMaxDistanceScale;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Interp, Category = Clothing, meta = (UIMin = 0.0, UIMax = 10.0, ClampMin = 0.0, ClampMax = 10000.0))
    float ClothGeometryScale = 1.f;
 
private:
    /*
     * Max LOD level that post-process AnimBPs are evaluated. Overrides the setting of the same name on the skeletal mesh.
     * For example if you have the threshold set to 2, it will evaluate until including LOD 2 (based on 0 index). In case the LOD level gets set to 3, it will stop evaluating the post-process AnimBP.
     * Setting it to -1 will always evaluate it and disable LODing overrides for this component.
     */
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category=Animation, meta= (DisplayName = "Post-Process AnimBP LOD Threshold", AllowPrivateAccess = "true"))
    int32 PostProcessAnimBPLODThreshold = INDEX_NONE;
 
public:
    UPROPERTY(BlueprintAssignable)
    FConstraintBrokenSignature OnConstraintBroken;
 
    UPROPERTY(BlueprintAssignable)
    FPlasticDeformationEventSignature OnPlasticDeformation;
 
    UE_DEPRECATED(5.7, "This property will be removed since the ClothingSimulationFactory is no longer set per component.")
    UPROPERTY()
    TSubclassOf<class UClothingSimulationFactory> ClothingSimulationFactory;
 
    struct FPendingRadialForces
    {
        enum EType
        {
            AddImpulse,
            AddForce
        };
 
        FVector Origin;
        float Radius;
        float Strength;
        ERadialImpulseFalloff Falloff;
        bool bIgnoreMass;
        EType Type;
        int32 FrameNum;
 
        FPendingRadialForces(FVector InOrigin, float InRadius, float InStrength, ERadialImpulseFalloff InFalloff, bool InIgnoreMass, EType InType)
            : Origin(InOrigin)
            , Radius(InRadius)
            , Strength(InStrength)
            , Falloff(InFalloff)
            , bIgnoreMass(InIgnoreMass)
            , Type(InType)
            , FrameNum(GFrameNumber)
        {
        }
    };
 
    const TArray<FPendingRadialForces>& GetPendingRadialForces() const
    {
        return PendingRadialForces;
    }
    TArray<FPendingRadialForces> PendingRadialForces;
 
    UE_DEPRECATED(4.23, "This function is deprecated. Please use SetAnimInstanceClass instead. ")
    ENGINE_API virtual void K2_SetAnimInstanceClass(class UClass* NewClass);
 
    UE_DEPRECATED(5.5, "This function is deprecated. Please use 'SetAnimInstanceClass' instead. ")
    ENGINE_API virtual void SetAnimClass(class UClass* NewClass);
 
    UFUNCTION(BlueprintInternalUseOnly)
    ENGINE_API class UClass*  GetAnimClass();
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkeletalMesh", meta = (Keywords = "AnimBlueprint", DisplayName = "Set Anim Instance Class"))
    ENGINE_API virtual void SetAnimInstanceClass(class UClass* NewClass);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkeletalMesh", meta = (Keywords = "Animation"))
    ENGINE_API void SetEnableAnimation(bool bNewEnableAnimation);
 
    UFUNCTION(BlueprintCallable, Category="Components|SkeletalMesh", meta=(Keywords = "AnimBlueprint", UnsafeDuringActorConstruction = "true"))
    ENGINE_API class UAnimInstance * GetAnimInstance() const;
    
private:
    /* Setter function for anim instance class */
    void SetAnimInstanceClass_Internal(const TSubclassOf<UAnimInstance>& InAnimClass);
 
public:
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkeletalMesh", meta = (Keywords = "AnimBlueprint", UnsafeDuringActorConstruction = "true"))
    ENGINE_API UAnimInstance* GetPostProcessInstance() const;
 
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    const TArray<UAnimInstance*>& GetLinkedAnimInstances() const { return LinkedInstances; }
PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    ENGINE_API void AllowQueuedAnimEventsNextDispatch();
    
private:
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    TArray<TObjectPtr<UAnimInstance>>& GetLinkedAnimInstances() { return LinkedInstances; }
ENGINE_API PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    void ResetLinkedAnimInstances();
 
    void ResetToRefPose();
 
public:
    UE_DEPRECATED(4.23, "This function is deprecated. Please use GetLinkedAnimGraphInstanceByTag")
    UAnimInstance* GetSubInstanceByName(FName InTag) const { return GetLinkedAnimGraphInstanceByTag(InTag); }
 
    UE_DEPRECATED(4.24, "This function is deprecated. Please use GetLinkedAnimGraphInstanceByTag")
    UAnimInstance* GetSubInstanceByTag(FName InTag) const { return GetLinkedAnimGraphInstanceByTag(InTag); }
 
    UFUNCTION(BlueprintPure, Category = "Components|SkeletalMesh|Animation Blueprint Linking", meta = (Keywords = "AnimBlueprint", UnsafeDuringActorConstruction = "true"))
    ENGINE_API UAnimInstance* GetLinkedAnimGraphInstanceByTag(FName InTag) const;
 
    UE_DEPRECATED(4.24, "Function renamed, please use GetLinkedAnimGraphInstancesByTag")
    void GetSubInstancesByTag(FName InTag, TArray<UAnimInstance*>& OutSubInstances) const
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        GetLinkedAnimGraphInstancesByTag(InTag, OutSubInstances);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UE_DEPRECATED(5.0, "Tags are unique so this funciton is no longer supported. Please use GetLinkedAnimGraphInstanceByTag instead")
    UFUNCTION(BlueprintPure, Category = "Components|SkeletalMesh|Animation Blueprint Linking", meta = (Keywords = "AnimBlueprint", 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 = "Components|SkeletalMesh|Animation Blueprint Linking", meta = (Keywords = "AnimBlueprint", UnsafeDuringActorConstruction = "true"))
    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 = "Components|SkeletalMesh|Animation Blueprint Linking", meta = (Keywords = "AnimBlueprint", UnsafeDuringActorConstruction = "true"))
    ENGINE_API void LinkAnimClassLayers(TSubclassOf<UAnimInstance> InClass);
 
    UE_DEPRECATED(4.24, "Function renamed, please use UnlinkAnimClassLayers")
    void ClearLayerOverlay(TSubclassOf<UAnimInstance> InClass) { UnlinkAnimClassLayers(InClass); }
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkeletalMesh|Animation Blueprint Linking", meta = (Keywords = "AnimBlueprint", UnsafeDuringActorConstruction = "true"))
    ENGINE_API void UnlinkAnimClassLayers(TSubclassOf<UAnimInstance> InClass);
 
    UE_DEPRECATED(4.24, "Function renamed, please use GetLinkedLayerInstanceByGroup")
    UAnimInstance* GetLayerSubInstanceByGroup(FName InGroup) const { return GetLinkedAnimLayerInstanceByGroup(InGroup); }
 
    UFUNCTION(BlueprintPure, Category = "Components|SkeletalMesh|Animation Blueprint Linking", meta = (Keywords = "AnimBlueprint", UnsafeDuringActorConstruction = "true"))
    ENGINE_API UAnimInstance* GetLinkedAnimLayerInstanceByGroup(FName InGroup) const;
 
    UE_DEPRECATED(4.24, "Function renamed, please use GetLinkedAnimLayerInstanceByClass")
    UAnimInstance* GetLayerSubInstanceByClass(TSubclassOf<UAnimInstance> InClass) const { return GetLinkedAnimLayerInstanceByClass(InClass);  }
 
    UFUNCTION(BlueprintPure, Category = "Components|SkeletalMesh|Animation Blueprint Linking", meta = (Keywords = "AnimBlueprint", UnsafeDuringActorConstruction = "true"))
    ENGINE_API UAnimInstance* GetLinkedAnimLayerInstanceByClass(TSubclassOf<UAnimInstance> InClass) const;
 
    ENGINE_API void ForEachAnimInstance(TFunctionRef<void(UAnimInstance*)> InFunction);
 
    UFUNCTION(BlueprintPure, Category = "Components|SkeletalMesh", meta = (Keywords = "AnimBlueprint"))
    ENGINE_API bool HasValidAnimationInstance() const;
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkeletalMesh", meta = (Keywords = "Dynamics,Physics", UnsafeDuringActorConstruction = "true"))
    ENGINE_API void ResetAnimInstanceDynamics(ETeleportType InTeleportType = ETeleportType::ResetPhysics);
 
    UFUNCTION(BlueprintCallable, Category = "Components|Animation", meta = (Keywords = "Animation"))
    ENGINE_API void SetAnimationMode(EAnimationMode::Type InAnimationMode, bool bForceInitAnimScriptInstance = true);
    
    UFUNCTION(BlueprintPure, Category = "Components|Animation", meta = (Keywords = "Animation"))
    ENGINE_API EAnimationMode::Type GetAnimationMode() const;
 
    /* Animation play functions
     *
     * These changes status of animation instance, which is transient data, which means it won't serialize with this component
     * Because of that reason, it is not safe to be used during construction script
     * Please use OverrideAnimationData for construction script. That will override AnimationData to be serialized 
     */
    UFUNCTION(BlueprintCallable, Category = "Components|Animation", meta = (Keywords = "Animation", UnsafeDuringActorConstruction = "true"))
    ENGINE_API void PlayAnimation(class UAnimationAsset* NewAnimToPlay, bool bLooping);
 
    /* Animation play functions
    *
    * These changes status of animation instance, which is transient data, which means it won't serialize with this component
    * Because of that reason, it is not safe to be used during construction script
    * Please use OverrideAnimationData for construction script. That will override AnimationData to be serialized
    */
    UFUNCTION(BlueprintCallable, Category = "Components|Animation", meta = (Keywords = "Animation", UnsafeDuringActorConstruction = "true"))
    ENGINE_API void SetAnimation(class UAnimationAsset* NewAnimToPlay);
 
    /* Animation play functions
    *
    * These changes status of animation instance, which is transient data, which means it won't serialize with this component
    * Because of that reason, it is not safe to be used during construction script
    * Please use OverrideAnimationData for construction script. That will override AnimationData to be serialized
    */
    UFUNCTION(BlueprintCallable, Category = "Components|Animation", meta = (Keywords = "Animation", UnsafeDuringActorConstruction = "true"))
    ENGINE_API void Play(bool bLooping);
 
    /* Animation play functions
    *
    * These changes status of animation instance, which is transient data, which means it won't serialize with this component
    * Because of that reason, it is not safe to be used during construction script
    * Please use OverrideAnimationData for construction script. That will override AnimationData to be serialized
    */
    UFUNCTION(BlueprintCallable, Category = "Components|Animation", meta = (Keywords = "Animation", UnsafeDuringActorConstruction = "true"))
    ENGINE_API void Stop();
 
    /* Animation play functions
    *
    * These changes status of animation instance, which is transient data, which means it won't serialize with this component
    * Because of that reason, it is not safe to be used during construction script
    * Please use OverrideAnimationData for construction script. That will override AnimationData to be serialized
    */
    UFUNCTION(BlueprintCallable, Category = "Components|Animation", meta = (Keywords = "Animation", UnsafeDuringActorConstruction = "true"))
    ENGINE_API bool IsPlaying() const;
 
    /* Animation play functions
    *
    * These changes status of animation instance, which is transient data, which means it won't serialize with this component
    * Because of that reason, it is not safe to be used during construction script
    * Please use OverrideAnimationData for construction script. That will override AnimationData to be serialized
    */
    UFUNCTION(BlueprintCallable, Category = "Components|Animation", meta = (Keywords = "Animation", UnsafeDuringActorConstruction = "true"))
    ENGINE_API void SetPosition(float InPos, bool bFireNotifies = true);
 
    /* Animation play functions
    *
    * These changes status of animation instance, which is transient data, which means it won't serialize with this component
    * Because of that reason, it is not safe to be used during construction script
    * Please use OverrideAnimationData for construction script. That will override AnimationData to be serialized
    */
    UFUNCTION(BlueprintCallable, Category = "Components|Animation", meta = (Keywords = "Animation", UnsafeDuringActorConstruction = "true"))
    ENGINE_API float GetPosition() const;
 
    /* Animation play functions
    *
    * These changes status of animation instance, which is transient data, which means it won't serialize with this component
    * Because of that reason, it is not safe to be used during construction script
    * Please use OverrideAnimationData for construction script. That will override AnimationData to be serialized
    */
    UFUNCTION(BlueprintCallable, Category = "Components|Animation", meta = (Keywords = "Animation", UnsafeDuringActorConstruction = "true"))
    ENGINE_API void SetPlayRate(float Rate);
 
    /* Animation play functions
    *
    * These changes status of animation instance, which is transient data, which means it won't serialize with this component
    * Because of that reason, it is not safe to be used during construction script
    * Please use OverrideAnimationData for construction script. That will override AnimationData to be serialized
    */
    UFUNCTION(BlueprintCallable, Category = "Components|Animation", meta = (Keywords = "Animation", UnsafeDuringActorConstruction = "true"))
    ENGINE_API float GetPlayRate() const;
 
    UFUNCTION(BlueprintCallable, Category = "Components|Animation", meta = (Keywords = "Animation"))
    ENGINE_API void OverrideAnimationData(UAnimationAsset* InAnimToPlay, bool bIsLooping = true, bool bIsPlaying = true, float Position = 0.f, float PlayRate = 1.f);
 
    UFUNCTION(BlueprintCallable, Category="Components|SkeletalMesh", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API void SetMorphTarget(FName MorphTargetName, float Value, bool bRemoveZeroWeight=true);
 
    UFUNCTION(BlueprintCallable, Category="Components|SkeletalMesh")
    ENGINE_API void ClearMorphTargets();
 
    UFUNCTION(BlueprintCallable, Category="Components|SkeletalMesh")
    ENGINE_API float GetMorphTarget(FName MorphTargetName) const;
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkeletalMesh")
    ENGINE_API void SnapshotPose(UPARAM(ref) FPoseSnapshot& Snapshot);
 
    UFUNCTION(BlueprintCallable, Category="Components|SkeletalMesh")
    ENGINE_API void SetAllowClothActors(bool bInAllow);
 
    UFUNCTION(BlueprintCallable, Category="Components|SkeletalMesh")
    bool GetAllowClothActors() const { return bAllowClothActors; }
 
    UFUNCTION(BlueprintCallable, Category="Clothing")
    ENGINE_API float GetClothMaxDistanceScale() const;
    UFUNCTION(BlueprintCallable, Category="Clothing")
    ENGINE_API void SetClothMaxDistanceScale(float Scale);
 
    UFUNCTION(BlueprintCallable, Category="Clothing")
    ENGINE_API void ForceClothNextUpdateTeleport();
    UFUNCTION(BlueprintCallable, Category="Clothing")
    ENGINE_API void ForceClothNextUpdateTeleportAndReset();
 
    UFUNCTION(BlueprintCallable, Category="Clothing", meta=(UnsafeDuringActorConstruction))
    ENGINE_API void SuspendClothingSimulation();
 
    UFUNCTION(BlueprintCallable, Category = "Clothing", meta=(UnsafeDuringActorConstruction))
    ENGINE_API void ResumeClothingSimulation();
 
    UFUNCTION(BlueprintCallable, Category = "Clothing")
    ENGINE_API bool IsClothingSimulationSuspended() const;
 
    UFUNCTION(BlueprintCallable, Category="Clothing")
    ENGINE_API void ResetClothTeleportMode();
 
    UFUNCTION(BlueprintCallable, Category = "Clothing", meta = (UnsafeDuringActorConstruction = "true"))
    ENGINE_API void BindClothToLeaderPoseComponent();
 
    UE_DEPRECATED(5.1, "This method has been deprecated. Please use BindClothToLeaderPoseComponent instead.")
    void BindClothToMasterPoseComponent() { BindClothToLeaderPoseComponent(); }
 
    UFUNCTION(BlueprintCallable, Category="Clothing", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API void UnbindClothFromLeaderPoseComponent(bool bRestoreSimulationSpace = true);
 
    UE_DEPRECATED(5.1, "This method has been deprecated. Please use UnbindClothFromLeaderPoseComponent instead.")
    void UnbindClothFromMasterPoseComponent(bool bRestoreSimulationSpace = true) { UnbindClothFromLeaderPoseComponent(bRestoreSimulationSpace); }
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkeletalMesh")
    ENGINE_API void SetAllowRigidBodyAnimNode(bool bInAllow, bool bReinitAnim = true);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkeletalMesh")
    bool GetAllowRigidBodyAnimNode() const { return !bDisableRigidBodyAnimNode; }
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkeletalMesh", meta = (DevelopmentOnly, UnsafeDuringActorConstruction = "true"))
    ENGINE_API void SetUpdateAnimationInEditor(const bool NewUpdateState);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkeletalMesh", meta = (DevelopmentOnly, UnsafeDuringActorConstruction = "true"))
    ENGINE_API void SetUpdateClothInEditor(const bool NewUpdateState);
 
#if WITH_EDITOR
    bool GetUpdateAnimationInEditor() const 
    {       
        return bUpdateAnimationInEditor;    
    }
 
    bool GetUpdateClothInEditor() const
    {
        return bUpdateClothInEditor;
    }
#endif 
 
    UE_DEPRECATED(4.18, "This function is deprecated. Please use SetAllowAnimCurveEvaluation instead. Note that the meaning is reversed.")
    UFUNCTION(BlueprintCallable, Category = "Components|SkeletalMesh")
    ENGINE_API void SetDisableAnimCurves(bool bInDisableAnimCurves);
 
    UE_DEPRECATED(4.18, "This function is deprecated. Please use GetAllowedAnimCurveEvaluate instead. Note that the meaning is reversed.")
    UFUNCTION(BlueprintCallable, Category = "Components|SkeletalMesh")
    bool GetDisableAnimCurves() const { return !bAllowAnimCurveEvaluation; }
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkeletalMesh")
    ENGINE_API void SetAllowAnimCurveEvaluation(bool bInAllow);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkeletalMesh")
    bool GetAllowedAnimCurveEvaluate() const { return bAllowAnimCurveEvaluation; }
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkeletalMesh")
    ENGINE_API void AllowAnimCurveEvaluation(FName NameOfCurve, bool bAllow);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkeletalMesh")
    ENGINE_API void ResetAllowedAnimCurveEvaluation();
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkeletalMesh")
    ENGINE_API void SetAllowedAnimCurvesEvaluation(const TArray<FName>& List, bool bAllow);
 
    UE_DEPRECATED(5.3, "Please use GetCurveFilterSettings")
    const TArray<FName>& GetDisallowedAnimCurvesEvaluation() const { return FilteredAnimCurves; }
 
    ENGINE_API UE::Anim::FCurveFilterSettings GetCurveFilterSettings(int32 InLODOverride = INDEX_NONE) const;
    
    ENGINE_API virtual void SkelMeshCompOnParticleSystemFinished( class UParticleSystemComponent* PSC );
 
    ENGINE_API class UAnimSingleNodeInstance * GetSingleNodeInstance() const;
    ENGINE_API bool InitializeAnimScriptInstance(bool bForceReinit = true, bool bInDeferRootNodeInitialization = false);
 
    ENGINE_API virtual bool IsWindEnabled() const;
 
#if WITH_EDITOR
    virtual void ReportAnimNotifyError(const FText& Error, UObject* InSourceNotify){}
    
    virtual void ClearAnimNotifyErrors(UObject* InSourceNotify){}
#endif
 
public:
    struct 
    {
        int32 BodyIndex;
        FTransform TransformToRoot;
    } RootBodyData;
 
    ENGINE_API void SetRootBodyIndex(int32 InBodyIndex);
    ENGINE_API void ResetRootBodyIndex();
 
    TArray<FBoneIndexType> RequiredBones;
 
    TArray<FBoneIndexType> FillComponentSpaceTransformsRequiredBones;
 
    TArray<struct FBodyInstance*> Bodies;
 
    TArray<struct FConstraintInstance*> Constraints;
 
    FSkeletalMeshComponentClothTickFunction ClothTickFunction;
 
    UFUNCTION(BlueprintGetter, Category=Clothing)
    ENGINE_API float GetTeleportRotationThreshold() const;
 
    UFUNCTION(BlueprintSetter, Category=Clothing)
    ENGINE_API void SetTeleportRotationThreshold(float Threshold);
 
    UFUNCTION(BlueprintGetter, Category=Clothing)
    ENGINE_API float GetTeleportDistanceThreshold() const;
 
    UFUNCTION(BlueprintSetter, Category=Clothing)
    ENGINE_API void SetTeleportDistanceThreshold(float Threshold);
 
private:
    UPROPERTY(EditAnywhere, BlueprintGetter=GetTeleportDistanceThreshold, BlueprintSetter=SetTeleportDistanceThreshold, Category=Clothing)
    float TeleportDistanceThreshold;
 
    UPROPERTY(EditAnywhere, BlueprintGetter=GetTeleportRotationThreshold, BlueprintSetter=SetTeleportRotationThreshold, Category=Clothing)
    float TeleportRotationThreshold;
 
    float ClothTeleportCosineThresholdInRad;
    float ClothTeleportDistThresholdSquared;
 
public:
 
    ENGINE_API bool PoseTickedThisFrame() const;
 
    bool IsClothBoundToLeaderComponent() const { return bBindClothToLeaderComponent; }
    
    UE_DEPRECATED(5.1, "This method has been deprecated. Please, use IsClothBoundToLeaderComponent instead.")
    bool IsClothBoundToMasterComponent() const { return IsClothBoundToLeaderComponent(); }
 
    UE_DEPRECATED(5.7, "Use GetClothingSimulationInstances instead.")
    ENGINE_API const class IClothingSimulation* GetClothingSimulation() const;
 
    UE_DEPRECATED(5.7, "Use GetClothingSimulationInstances instead.")
    ENGINE_API class IClothingSimulation* GetClothingSimulation();
 
    UE_DEPRECATED(5.7, "Use GetClothingSimulationInstances instead.")
    ENGINE_API const class IClothingSimulationContext* GetClothingSimulationContext() const;
    
    ENGINE_API class IClothingSimulationContext* GetClothingSimulationContext();
    
    const TArray<FClothingSimulationInstance>& GetClothingSimulationInstances() const
    {
        return ClothingSimulationInstances;
    }
 
    TArray<FClothingSimulationInstance>& GetClothingSimulationInstances()
    {
        return ClothingSimulationInstances;
    }
 
    UFUNCTION(BlueprintCallable, Category = Clothing)
    ENGINE_API UClothingSimulationInteractor* GetClothingSimulationInteractor(const FName ClothingAssetName = NAME_None) const;
 
    ENGINE_API void CompleteParallelClothSimulation();
 
    ENGINE_API const TMap<int32, FClothSimulData>& GetCurrentClothingData_GameThread() const;
 
    ENGINE_API const TMap<int32, FClothSimulData>& GetCurrentClothingData_AnyThread() const;
 
    ENGINE_API void WaitForExistingParallelClothSimulation_GameThread();
 
private:
 
    friend FSkeletalMeshComponentClothTickFunction;
    friend class FParallelClothCompletionTask;
 
    friend class UDebugSkelMeshComponent;
 
    ENGINE_API void UpdateClothSimulationContext(float InDeltaTime);
 
    FMatrix PrevRootBoneMatrix;
 
    FVector3f PrevRootRigidBodyScale;
 
    UPROPERTY(Transient)
    TArray<FClothingSimulationInstance> ClothingSimulationInstances;
 
    TArray<FClothCollisionSource> ClothCollisionSources;
 
    FGraphEventRef ParallelClothTask;
 
    ENGINE_API bool ShouldWaitForClothInTickFunction() const;
 
    ENGINE_API void HandleExistingParallelClothSimulation();
 
    ENGINE_API void WritebackClothingSimulationData();
 
protected:
 
    TMap<int32, FClothSimulData> CurrentSimulationData;
 
private:
 
    ENGINE_API void OnConstraintBrokenWrapper(int32 ConstraintIndex);
 
    ENGINE_API void OnPlasticDeformationWrapper(int32 ConstraintIndex);
 
    UPROPERTY(Transient)
    TMap<FName, float>  MorphTargetCurves;
 
public:
    const TMap<FName, float>& GetMorphTargetCurves() const { return MorphTargetCurves;  }
    // 
    // Animation
    //
    ENGINE_API virtual void InitAnim(bool bForceReinit);
 
    // Broadcast when the components anim instance is initialized
    UPROPERTY(BlueprintAssignable, Category = Animation)
    FOnAnimInitialized OnAnimInitialized;
 
    ENGINE_API bool ShouldOnlyTickMontages(const float DeltaTime) const;
 
    ENGINE_API bool ShouldOnlyTickMontagesAndRefreshBones(const float DeltaTime) const;
 
    ENGINE_API bool ShouldTickAnimation() const;
 
    ENGINE_API void TickAnimation(float DeltaTime, bool bNeedsValidRootMotion);
 
    ENGINE_API void TickAnimInstances(float DeltaTime, bool bNeedsValidRootMotion);
 
    ENGINE_API void TickClothing(float DeltaTime, FTickFunction& ThisTickFunction);
 
    ENGINE_API virtual void GetUpdateClothSimulationData_AnyThread(TMap<int32, FClothSimulData>& OutClothSimulData, FMatrix& OutLocalToWorld, float& OutClothBlendWeight) const override;
 
    UE_DEPRECATED(5.7, "Use ReleaseAllClothingResources instead.")
    ENGINE_API void RemoveAllClothingActors();
 
    ENGINE_API void ReleaseAllClothingResources();
 
    ENGINE_API void DebugDrawClothing(FPrimitiveDrawInterface* PDI);
 
    ENGINE_API void DebugDrawClothingTexts(FCanvas* Canvas, const FSceneView* SceneView);
 
#if WITH_EDITOR
    ENGINE_API void UpdatePoseWatches();
    TArray<FAnimNodePoseWatch> PoseWatches;
#endif
 
    ENGINE_API virtual void SetNotifyRigidBodyCollision(bool bNewNotifyRigidBodyCollision) override;
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API virtual void SetBodyNotifyRigidBodyCollision(bool bNewNotifyRigidBodyCollision, FName BoneName = NAME_None);
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API virtual void SetNotifyRigidBodyCollisionBelow(bool bNewNotifyRigidBodyCollision, FName BoneName = NAME_None, bool bIncludeSelf = true);
 
    ENGINE_API void RecalcRequiredBones(int32 LODIndex);
 
    ENGINE_API void ComputeRequiredBones(TArray<FBoneIndexType>& OutRequiredBones, TArray<FBoneIndexType>& OutFillComponentSpaceTransformsRequiredBones, int32 LODIndex, bool bIgnorePhysicsAsset) const;
 
    // Get the required virtual bones from the SkeletalMesh Reference Skeleton
    static ENGINE_API void GetRequiredVirtualBones(const USkeletalMesh* SkeletalMesh, TArray<FBoneIndexType>& OutRequiredBones);
 
    // Removes the bones expicitly hidden or hiden by parent
    static ENGINE_API void ExcludeHiddenBones(const USkeletalMeshComponent* SkeletalMeshComponent, const USkeletalMesh* SkeletalMesh, TArray<FBoneIndexType>& OutRequiredBones);
 
    // Get the bones used for mirroring in the skeletal mesh asset (if any)
    UE_DEPRECATED(5.3, "This method has been deprecated. Please use UMirrorDataTable for mirroring support.")
    static ENGINE_API void GetMirroringRequiredBones(const USkeletalMesh* SkeletalMesh, TArray<FBoneIndexType>& OutRequiredBones);
 
    // Get the bones required for shadow shapes
    static ENGINE_API void GetShadowShapeRequiredBones(const USkeletalMeshComponent* SkeletalMeshComponent, TArray<FBoneIndexType>& OutRequiredBones);
 
    ENGINE_API void RecalcRequiredCurves();
 
public:
    //~ Begin UObject Interface.
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    ENGINE_API virtual void PostLoad() override;
    ENGINE_API virtual void PostInitProperties() override;
#if UE_WITH_REMOTE_OBJECT_HANDLE
    ENGINE_API virtual void PostMigrate(const struct FUObjectMigrationContext& MigrationContext) override;
#endif
#if WITH_EDITOR
    DECLARE_MULTICAST_DELEGATE(FOnSkeletalMeshPropertyChangedMulticaster)
    FOnSkeletalMeshPropertyChangedMulticaster OnSkeletalMeshPropertyChanged;
    typedef FOnSkeletalMeshPropertyChangedMulticaster::FDelegate FOnSkeletalMeshPropertyChanged;
 
    ENGINE_API FDelegateHandle RegisterOnSkeletalMeshPropertyChanged(const FOnSkeletalMeshPropertyChanged& Delegate);
    ENGINE_API void UnregisterOnSkeletalMeshPropertyChanged(FDelegateHandle Handle);
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnSkeletalMeshUnregisterd, const USkeletalMeshComponent*)
    FOnSkeletalMeshUnregisterd OnSkeletalMeshUnregistered;
    typedef FOnSkeletalMeshUnregisterd::FDelegate FOnSkeletalMeshUnregisteredDelegate;
 
    ENGINE_API FDelegateHandle RegisterOnSkeletalMeshUnregistered(const FOnSkeletalMeshUnregisteredDelegate& Delegate);
    ENGINE_API void UnregisterOnSkeletalMeshUnregistered(FDelegateHandle Handle);
 
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
 
    ENGINE_API void ValidateAnimation();
 
    ENGINE_API virtual void LoadedFromAnotherClass(const FName& OldClassName) override;
    ENGINE_API virtual void UpdateCollisionProfile() override;
#endif // WITH_EDITOR
    ENGINE_API virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
    //~ End UObject Interface.
 
    //~ Begin UActorComponent Interface.
    ENGINE_API virtual bool HasValidPhysicsState() const override;
 
protected:
    ENGINE_API virtual void OnRegister() override;
    ENGINE_API virtual void OnUnregister() override;
    ENGINE_API virtual bool ShouldCreatePhysicsState() const override;
    ENGINE_API virtual void OnCreatePhysicsState() override;
    ENGINE_API virtual void OnDestroyPhysicsState() override;
    ENGINE_API virtual void SendRenderDynamicData_Concurrent() override;
    ENGINE_API virtual void RegisterComponentTickFunctions(bool bRegister) override;
public:
    ENGINE_API virtual void InitializeComponent() override;
    ENGINE_API virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction) override;
    ENGINE_API virtual void BeginPlay() override;
    ENGINE_API virtual void SetComponentTickEnabled(bool bEnabled) override;
    ENGINE_API virtual void OnComponentDestroyed(bool bDestroyingHierarchy) override;
 
#if WITH_EDITOR
    ENGINE_API virtual TStructOnScope<FActorComponentInstanceData> GetComponentInstanceData() const override;
#endif // WITH_EDITOR
 
    //Handle registering our end physics tick function
    ENGINE_API virtual void RegisterEndPhysicsTick(bool bRegister);
 
    ENGINE_API virtual bool RequiresPreEndOfFrameSync() const override;
    ENGINE_API virtual void OnPreEndOfFrameSync() override;
 
    //Handle registering our pre cloth tick function
    ENGINE_API void RegisterClothTick(bool bRegister);
 
    //~ End UActorComponent Interface.
 
    //~ Begin USceneComponent Interface.
    ENGINE_API virtual FBoxSphereBounds CalcBounds(const FTransform& LocalToWorld) const override;
    ENGINE_API virtual bool IsAnySimulatingPhysics() const override;
    ENGINE_API virtual void OnUpdateTransform(EUpdateTransformFlags UpdateTransformFlags, ETeleportType Teleport = ETeleportType::None) override;
    ENGINE_API virtual bool UpdateOverlapsImpl(const TOverlapArrayView* PendingOverlaps=NULL, bool bDoNotifies=true, const TOverlapArrayView* OverlapsAtEndLocation=NULL) override;
    //~ End USceneComponent Interface.
 
    //~ Begin UPrimitiveComponent Interface.
protected:
    ENGINE_API virtual bool ComponentOverlapMultiImpl(TArray<struct FOverlapResult>& OutOverlaps, const class UWorld* InWorld, const FVector& Pos, const FQuat& Rot, ECollisionChannel TestChannel, const struct FComponentQueryParams& Params, const struct FCollisionObjectQueryParams& ObjectQueryParams = FCollisionObjectQueryParams::DefaultObjectQueryParam) const override;
    
    ENGINE_API virtual bool ComponentOverlapComponentImpl(class UPrimitiveComponent* PrimComp, const FVector Pos, const FQuat& Quat, const FCollisionQueryParams& Params) override;
 
    ENGINE_API virtual bool MoveComponentImpl(const FVector& Delta, const FQuat& NewRotation, bool bSweep, FHitResult* OutHit = NULL, EMoveComponentFlags MoveFlags = MOVECOMP_NoFlags, ETeleportType Teleport = ETeleportType::None) override;
 
public:
 
    ENGINE_API virtual class UBodySetup* GetBodySetup() override;
    ENGINE_API virtual bool CanEditSimulatePhysics() override;
    ENGINE_API virtual bool IsSimulatingPhysics(FName BoneName = NAME_None) const override;
    ENGINE_API virtual FBodyInstance* GetBodyInstance(FName BoneName = NAME_None, bool bGetWelded = true, int32 Index = INDEX_NONE) const override;
    ENGINE_API virtual void UpdatePhysicsToRBChannels() override;
    ENGINE_API virtual void SetAllPhysicsAngularVelocityInRadians(FVector const& NewVel, bool bAddToCurrent = false) override;
    ENGINE_API virtual void SetAllPhysicsPosition(FVector NewPos) override;
    ENGINE_API virtual void SetAllPhysicsRotation(FRotator NewRot) override;
    ENGINE_API virtual void SetAllPhysicsRotation(const FQuat& NewRot) override;
    ENGINE_API virtual void WakeAllRigidBodies() override;
    ENGINE_API virtual void PutAllRigidBodiesToSleep() override;
    ENGINE_API virtual bool IsAnyRigidBodyAwake() override;
    ENGINE_API virtual void SetEnableGravity(bool bGravityEnabled);
    ENGINE_API virtual bool IsGravityEnabled() const override;
    ENGINE_API virtual void OnComponentCollisionSettingsChanged(bool bUpdateOverlaps=true) override;
    ENGINE_API virtual void SetPhysMaterialOverride(UPhysicalMaterial* NewPhysMaterial) override;
    ENGINE_API virtual bool GetSquaredDistanceToCollision(const FVector& Point, float& OutSquaredDistance, FVector& OutClosestPointOnCollision) const override;
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API void SetEnablePerPolyCollision(bool bInEnablePerPolyCollision);
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API void SetEnableBodyGravity(bool bEnableGravity, FName BoneName);
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API bool IsBodyGravityEnabled(FName BoneName);
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API void SetEnableGravityOnAllBodiesBelow(bool bEnableGravity, FName BoneName, bool bIncludeSelf=true);
 
    ENGINE_API bool GetClosestPointOnPhysicsAsset(const FVector& WorldPosition, FClosestPointOnPhysicsAsset& ClosestPointOnPhysicsAsset, bool bApproximate) const;
 
    UFUNCTION(BlueprintCallable, Category="Components|SkeletalMesh", meta=(DisplayName="Get Closest Point On Physics Asset", ScriptName="GetClosestPointOnPhysicsAsset", Keywords="closest point"))
    ENGINE_API bool K2_GetClosestPointOnPhysicsAsset(const FVector& WorldPosition, FVector& ClosestWorldPosition, FVector& Normal, FName& BoneName, float& Distance) const;
 
    ENGINE_API virtual bool LineTraceComponent( FHitResult& OutHit, const FVector Start, const FVector End, const FCollisionQueryParams& Params ) override;
    
     ENGINE_API virtual bool SweepComponent( FHitResult& OutHit, const FVector Start, const FVector End, const FQuat& ShapRotation, const FCollisionShape& CollisionShape, bool bTraceComplex=false) override;
    
    ENGINE_API virtual bool OverlapComponent(const FVector& Pos, const FQuat& Rot, const FCollisionShape& CollisionShape) const override;
    ENGINE_API virtual void SetSimulatePhysics(bool bEnabled) override;
    ENGINE_API virtual void AddRadialImpulse(FVector Origin, float Radius, float Strength, ERadialImpulseFalloff Falloff, bool bVelChange=false) override;
    ENGINE_API virtual void AddRadialForce(FVector Origin, float Radius, float Strength, ERadialImpulseFalloff Falloff, bool bAccelChange=false) override;
    ENGINE_API virtual void SetAllPhysicsLinearVelocity(FVector NewVel,bool bAddToCurrent = false) override;
    ENGINE_API virtual void SetAllMassScale(float InMassScale = 1.f) override;
    ENGINE_API virtual float GetMass() const override;
    ENGINE_API virtual void SetAllUseCCD(bool InUseCCD) override;
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API float GetBoneMass(FName BoneName = NAME_None, bool bScaleMass = true) const;
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API FVector GetSkeletalCenterOfMass() const;
 
 
    ENGINE_API virtual float CalculateMass(FName BoneName = NAME_None) override;
    ENGINE_API virtual bool DoCustomNavigableGeometryExport(FNavigableGeometryExport& GeomExport) const override;
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API virtual void AddForceToAllBodiesBelow(FVector Force, FName BoneName = NAME_None, bool bAccelChange = false, bool bIncludeSelf = true);
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API virtual void AddImpulseToAllBodiesBelow(FVector Impulse, FName BoneName = NAME_None, bool bVelChange = false, bool bIncludeSelf = true);
 
    ENGINE_API virtual bool IsShown(const FEngineShowFlags& ShowFlags) const override;
#if WITH_EDITOR
    ENGINE_API virtual bool ComponentIsTouchingSelectionBox(const FBox& InSelBBox, const bool bConsiderOnlyBSP, const bool bMustEncompassEntireComponent) const override;
    ENGINE_API virtual bool ComponentIsTouchingSelectionFrustum(const FConvexVolume& InFrustum, const bool bConsiderOnlyBSP, const bool bMustEncompassEntireComponent) const override;
#endif
protected:
    ENGINE_API virtual FTransform GetComponentTransformFromBodyInstance(FBodyInstance* UseBI) override;
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    ENGINE_API virtual void MigratePhysicsState(FArchive& Ar) override;
    ENGINE_API virtual void ApplyMigratedPhysicsState(Chaos::FSerializedDataBufferPtr MigratedStateData = nullptr) override;
#endif
 
    //~ End UPrimitiveComponent Interface.
 
public:
    //~ Begin USkinnedMeshComponent Interface
    ENGINE_API virtual bool UpdateLODStatus() override;
    ENGINE_API virtual void SetPredictedLODLevel(int32 InPredictedLODLevel) override;
    ENGINE_API virtual void UpdateVisualizeLODString(FString& DebugString) override;
    ENGINE_API virtual void RefreshBoneTransforms( FActorComponentTickFunction* TickFunction = NULL ) override;
protected:
    ENGINE_API virtual void DispatchParallelTickPose( FActorComponentTickFunction* TickFunction ) override;
public:
    ENGINE_API virtual void TickPose(float DeltaTime, bool bNeedsValidRootMotion) override;
    ENGINE_API virtual void UpdateFollowerComponent() override;
    UE_DEPRECATED(5.1, "This method has been deprecated. Please use UpdateFollowerComponent instead.")
    virtual void UpdateSlaveComponent() override { UpdateFollowerComponent(); };
    ENGINE_API virtual bool ShouldUpdateTransform(bool bLODHasChanged) const override;
    ENGINE_API virtual bool ShouldTickPose() const override;
    ENGINE_API virtual bool AllocateTransformData() override;
    ENGINE_API virtual void DeallocateTransformData() override;
    ENGINE_API virtual void HideBone( int32 BoneIndex, EPhysBodyOp PhysBodyOption ) override;
    ENGINE_API virtual void UnHideBone( int32 BoneIndex ) override;
    ENGINE_API virtual void SetPhysicsAsset(class UPhysicsAsset* NewPhysicsAsset,bool bForceReInit = false) override;
    ENGINE_API virtual void SetSkeletalMesh(class USkeletalMesh* NewMesh, bool bReinitPose = true) override;  // SetSkeletalMesh may remain and become a UFUNCTION but lose its virtual after it is removed from the SkinnedMeshComponent API
 
    ENGINE_API virtual void SetSkinnedAssetAndUpdate(class USkinnedAsset* InSkinnedAsset, bool bReinitPose = true) override;
 
    static ENGINE_API FVector3f GetSkinnedVertexPosition(USkeletalMeshComponent* Component, int32 VertexIndex, const FSkeletalMeshLODRenderData& Model, const FSkinWeightVertexBuffer& SkinWeightBuffer);
    static ENGINE_API FVector3f GetSkinnedVertexPosition(USkeletalMeshComponent* Component, int32 VertexIndex, const FSkeletalMeshLODRenderData& Model, const FSkinWeightVertexBuffer& SkinWeightBuffer, TArray<FMatrix44f>& CachedRefToLocals);
    static ENGINE_API void ComputeSkinnedPositions(USkeletalMeshComponent* Component, TArray<FVector3f> & OutPositions, TArray<FMatrix44f>& CachedRefToLocals, const FSkeletalMeshLODRenderData& Model, const FSkinWeightVertexBuffer& SkinWeightBuffer);
 
    static ENGINE_API void GetSkinnedTangentBasis(USkeletalMeshComponent* Component, int32 VertexIndex, const FSkeletalMeshLODRenderData& Model, const FSkinWeightVertexBuffer& SkinWeightBuffer, TArray<FMatrix44f>& CachedRefToLocals, FVector3f& OutTangentX, FVector3f& OutTangentY, FVector3f& OutTangentZ);
    static ENGINE_API void ComputeSkinnedTangentBasis(USkeletalMeshComponent* Component, TArray<FVector3f>& OutTangenXYZ, TArray<FMatrix44f>& CachedRefToLocals, const FSkeletalMeshLODRenderData& Model, const FSkinWeightVertexBuffer& SkinWeightBuffer);
 
    UE_DEPRECATED(5.1, "This method has been deprecated. Please use SetSkeletalMesh(NewMesh, false) instead.")
    ENGINE_API void SetSkeletalMeshWithoutResettingAnimation(class USkeletalMesh* NewMesh);
 
    ENGINE_API virtual bool IsPlayingRootMotion() const override;
    ENGINE_API virtual bool IsPlayingNetworkedRootMotionMontage() const override;
    ENGINE_API virtual bool IsPlayingRootMotionFromEverything() const override;
    ENGINE_API virtual void FinalizeBoneTransform() override;
    ENGINE_API virtual void SetRefPoseOverride(const TArray<FTransform>& NewRefPoseTransforms) override;
    ENGINE_API virtual void ClearRefPoseOverride() override;
    //~ End USkinnedMeshComponent Interface
 
    // Conditions used to gate when post process events happen
    ENGINE_API bool ShouldEvaluatePostProcessAnimBP() const;
    ENGINE_API bool ShouldUpdatePostProcessInstance() const;
    ENGINE_API bool ShouldPostUpdatePostProcessInstance() const;
    ENGINE_API bool ShouldEvaluatePostProcessInstance() const;
 
    ENGINE_API void UpdateRBJointMotors();
 
#if WITH_EDITOR
    ENGINE_API void PerformAnimationEvaluation(const USkeletalMesh* InSkeletalMesh, UAnimInstance* InAnimInstance, TArray<FTransform>& OutSpaceBases, TArray<FTransform>& OutBoneSpaceTransforms, FVector& OutRootBoneTranslation, FBlendedHeapCurve& OutCurve, UE::Anim::FMeshAttributeContainer& OutAttributes);
 
    UE_DEPRECATED(4.26, "Please use PerformAnimationEvaluation with different signature")
    ENGINE_API void PerformAnimationEvaluation(const USkeletalMesh* InSkeletalMesh, UAnimInstance* InAnimInstance, TArray<FTransform>& OutSpaceBases, TArray<FTransform>& OutBoneSpaceTransforms, FVector& OutRootBoneTranslation, FBlendedHeapCurve& OutCurve);
#endif
 
    ENGINE_API void PerformAnimationProcessing(const USkeletalMesh* InSkeletalMesh, UAnimInstance* InAnimInstance, bool bInDoEvaluation, bool bInForceRefPose, TArray<FTransform>& OutSpaceBases, TArray<FTransform>& OutBoneSpaceTransforms, FVector& OutRootBoneTranslation, FBlendedHeapCurve& OutCurve, UE::Anim::FMeshAttributeContainer& OutAttributes);
 
    UE_DEPRECATED(5.5, "Please use PerformAnimationEvaluation with different signature")
    ENGINE_API void PerformAnimationProcessing(const USkeletalMesh* InSkeletalMesh, UAnimInstance* InAnimInstance, bool bInDoEvaluation, TArray<FTransform>& OutSpaceBases, TArray<FTransform>& OutBoneSpaceTransforms, FVector& OutRootBoneTranslation, FBlendedHeapCurve& OutCurve, UE::Anim::FMeshAttributeContainer& OutAttributes);
 
    ENGINE_API void EvaluatePostProcessMeshInstance(TArray<FTransform>& OutBoneSpaceTransforms, FCompactPose& InOutPose, FBlendedHeapCurve& OutCurve, const USkeletalMesh* InSkeletalMesh, FVector& OutRootBoneTranslation, UE::Anim::FHeapAttributeContainer& OutAttributes, bool bInForceRefPose) const;
 
    UE_DEPRECATED(5.5, "Please use EvaluatePostProcessMeshInstance with different signature")
    ENGINE_API void EvaluatePostProcessMeshInstance(TArray<FTransform>& OutBoneSpaceTransforms, FCompactPose& InOutPose, FBlendedHeapCurve& OutCurve, const USkeletalMesh* InSkeletalMesh, FVector& OutRootBoneTranslation, UE::Anim::FHeapAttributeContainer& OutAttributes) const;
 
    ENGINE_API void PostAnimEvaluation(FAnimationEvaluationContext& EvaluationContext);
 
    ENGINE_API void InitCollisionRelationships();
 
    ENGINE_API void TermCollisionRelationships();
 
    UE_DEPRECATED(4.26, "This function is deprecated and should not be called directly. Please use the mechanism provided in USkeletalMeshComponent::EndPhysicsTickComponent")
    void BlendPhysicsBones( TArray<FBoneIndexType>& Bones )
    {
        PerformBlendPhysicsBones(Bones, AnimEvaluationContext.BoneSpaceTransforms, AnimEvaluationContext.BoneSpaceTransforms);
    }
 
 
    UE_DEPRECATED(4.26, "Public access to this function is deprecated. Please use the mechanism provided in USkeletalMeshComponent::EndPhysicsTickComponent")
    void BlendInPhysics(FTickFunction& ThisTickFunction) { BlendInPhysicsInternal(ThisTickFunction); }
 
    ENGINE_API void InitArticulated(FPhysScene* PhysScene);
 
    ENGINE_API void InstantiatePhysicsAsset(const UPhysicsAsset& PhysAsset, const FVector& Scale3D, TArray<FBodyInstance*>& OutBodies, TArray<FConstraintInstance*>& OutConstraints, FPhysScene* PhysScene = nullptr, USkeletalMeshComponent* OwningComponent = nullptr, int32 UseRootBodyIndex = INDEX_NONE, const FPhysicsAggregateHandle& UseAggregate = FPhysicsAggregateHandle()) const;
 
    ENGINE_API void InstantiatePhysicsAssetBodies(const UPhysicsAsset& PhysAsset, TArray<FBodyInstance*>& OutBodies, FPhysScene* PhysScene = nullptr, USkeletalMeshComponent* OwningComponent = nullptr, int32 UseRootBodyIndex = INDEX_NONE, const FPhysicsAggregateHandle& UseAggregate = FPhysicsAggregateHandle()) const;
 
    ENGINE_API void InstantiatePhysicsAssetBodiesRefPose(const UPhysicsAsset& PhysAsset, TArray<FBodyInstance*>& OutBodies, FPhysScene* PhysScene = nullptr, USkeletalMeshComponent* OwningComponent = nullptr, int32 UseRootBodyIndex = INDEX_NONE, const FPhysicsAggregateHandle& UseAggregate = FPhysicsAggregateHandle()) const;
 
    ENGINE_API void InstantiatePhysicsAssetRefPose(const UPhysicsAsset& PhysAsset, const FVector& Scale3D, TArray<FBodyInstance*>& OutBodies, TArray<FConstraintInstance*>& OutConstraints, FPhysScene* PhysScene = nullptr, USkeletalMeshComponent* OwningComponent = nullptr, int32 UseRootBodyIndex = INDEX_NONE, const FPhysicsAggregateHandle& UseAggregate = FPhysicsAggregateHandle(), bool bCreateBodiesInRefPose = false) const;
 
    ENGINE_API void TermArticulated();
 
    ENGINE_API int32 FindRootBodyIndex() const;
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API void TermBodiesBelow(FName ParentBoneName);
 
    ENGINE_API FConstraintInstance* FindConstraintInstance(FName ConName);
 
    ENGINE_API FConstraintInstance* GetConstraintInstanceByIndex(uint32 Index);
 
    ENGINE_API float GetTotalMassBelowBone(FName InBoneName);
 
    ENGINE_API virtual void SetCollisionObjectType(ECollisionChannel Channel) override;
 
    ENGINE_API void SetAllBodiesCollisionObjectType(ECollisionChannel NewChannel);
 
    ENGINE_API void SetAllBodiesNotifyRigidBodyCollision(bool bNewNotifyRigidBodyCollision);
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API void SetAllBodiesSimulatePhysics(bool bNewSimulate);
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API void SetPhysicsBlendWeight(float PhysicsBlendWeight);
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API void SetEnablePhysicsBlending(bool bNewBlendPhysics);
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API void SetAllBodiesBelowPhysicsDisabled(const FName& InBoneName, bool bDisabled, bool bIncludeSelf = true);
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API void SetAllBodiesBelowLinearVelocity(const FName& InBoneName, const FVector& LinearVelocity, bool bIncludeSelf = true);
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API FVector GetBoneLinearVelocity(const FName& InBoneName);
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API void SetAllBodiesBelowSimulatePhysics(const FName& InBoneName, bool bNewSimulate, bool bIncludeSelf = true );
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API void SetBodySimulatePhysics(const FName& InBoneName, bool bSimulate);
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API void ResetAllBodiesSimulatePhysics();
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API void SetAllBodiesPhysicsBlendWeight(float PhysicsBlendWeight, bool bSkipCustomPhysicsType = false );
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API void SetAllBodiesBelowPhysicsBlendWeight(const FName& InBoneName, float PhysicsBlendWeight, bool bSkipCustomPhysicsType = false, bool bIncludeSelf = true );
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API void AccumulateAllBodiesBelowPhysicsBlendWeight(const FName& InBoneName, float AddPhysicsBlendWeight, bool bSkipCustomPhysicsType = false );
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API void SetAllMotorsAngularPositionDrive(bool bEnableSwingDrive, bool bEnableTwistDrive, bool bSkipCustomPhysicsType = false);
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API void SetAllMotorsAngularVelocityDrive(bool bEnableSwingDrive, bool bEnableTwistDrive, bool bSkipCustomPhysicsType = false);
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API void SetAllMotorsAngularDriveParams(float InSpring, float InDamping, float InForceLimit, bool bSkipCustomPhysicsType = false);
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API void SetConstraintProfile(FName JointName, FName ProfileName, bool bDefaultIfNotFound = false);
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API void SetConstraintProfileForAll(FName ProfileName, bool bDefaultIfNotFound = false);
 
    ENGINE_API bool GetConstraintProfilePropertiesOrDefault(FConstraintProfileProperties& OutProperties, FName JointName, FName ProfileName);
 
    ENGINE_API void SetNamedMotorsAngularPositionDrive(bool bEnableSwingDrive, bool bEnableTwistDrive, const TArray<FName>& BoneNames, bool bSetOtherBodiesToComplement = false);
 
    ENGINE_API void SetNamedMotorsAngularVelocityDrive(bool bEnableSwingDrive, bool bEnableTwistDrive, const TArray<FName>& BoneNames, bool bSetOtherBodiesToComplement = false);
 
    ENGINE_API void GetWeldedBodies(TArray<FBodyInstance*> & OutWeldedBodies, TArray<FName> & OutChildrenLabels, bool bIncludingAutoWeld = false) override;
 
    ENGINE_API int32 ForEachBodyBelow(FName BoneName, bool bIncludeSelf, bool bSkipCustomType, TFunctionRef<void(FBodyInstance*)> Func);
 
    ENGINE_API void SetForceRefPose(bool bNewForceRefPose);
    
    ENGINE_API void UpdateHasValidBodies();
 
    ENGINE_API void UpdateBoneBodyMapping();
    
    ENGINE_API void InitSkelControls();
    
    ENGINE_API int32    FindConstraintIndex(FName ConstraintName);
    
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API FName    FindConstraintBoneName(int32 ConstraintIndex);
 
    ENGINE_API void UpdateKinematicBonesToAnim(const TArray<FTransform>& InComponentSpaceTransforms, ETeleportType Teleport, bool bNeedsSkinning, EAllowKinematicDeferral DeferralAllowed = EAllowKinematicDeferral::AllowDeferral);
 
    ENGINE_API void UpdateMeshForBrokenConstraints();
    
    ENGINE_API virtual void NotifySkelControlBeyondLimit(class USkelControlLookAt* LookAt);
 
    UFUNCTION(BlueprintCallable, Category = "Physics", meta = (Keywords = "Constraint"))
    ENGINE_API void BreakConstraint(FVector Impulse, FVector HitLocation, FName InBoneName);
 
    UFUNCTION(BlueprintCallable, Category = "Physics", meta = (Keywords = "Components|SkeletalMesh"))
    ENGINE_API FConstraintInstanceAccessor GetConstraintByName(FName ConstraintName, bool bIncludesTerminated);
 
    UFUNCTION(BlueprintCallable, Category = "Physics", meta = (Keywords = "Components|SkeletalMesh"))
    ENGINE_API void GetConstraints(bool bIncludesTerminated, TArray<FConstraintInstanceAccessor>& OutConstraints);
 
    UFUNCTION(BlueprintCallable, Category = "Physics", meta = (Keywords = "Components|SkeletalMesh"))
    ENGINE_API void GetConstraintsFromBody(FName BodyName, bool bParentConstraints, bool bChildConstraints, bool bIncludesTerminated, TArray<FConstraintInstanceAccessor>& OutConstraints);
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API void  SetAngularLimits(FName InBoneName,float Swing1LimitAngle, float TwistLimitAngle, float Swing2LimitAngle);
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API void GetCurrentJointAngles(FName InBoneName,float& Swing1Angle, float& TwistAngle, float& Swing2Angle) ;
 
 
    ENGINE_API FVector GetClosestCollidingRigidBodyLocation(const FVector& TestLocation) const;
    
    ENGINE_API void ApplyDeltaToAllPhysicsTransforms(const FVector& DeltaLocation, const FQuat& DeltaRotation);
 
    UFUNCTION(BlueprintCallable, Category = "Clothing")
    ENGINE_API void RecreateClothingActors();
 
    ENGINE_API void AddClothingBounds(FBoxSphereBounds& InOutBounds, const FTransform& LocalToWorld) const;
 
    ENGINE_API virtual void CheckClothTeleport();
 
    ENGINE_API void UpdateClothStateAndSimulate(float DeltaTime, FTickFunction& ThisTickFunction);
    
    ENGINE_API void UpdateClothTransform(ETeleportType TeleportType);
 
    void UpdateRigidBodyScaling(ETeleportType TeleportType);
 
    void UpdateClothTransform() { UpdateClothTransform(ETeleportType::None); }
 
    ENGINE_API void UpdateClothCollision();
 
    ENGINE_API bool GetClothSimulatedPosition_GameThread(const FGuid& AssetGuid, int32 VertexIndex, FVector& OutSimulPos) const;
 
    const TArray<FClothCollisionSource>& GetClothCollisionSources() const { return ClothCollisionSources; }
 
    UFUNCTION(BlueprintCallable, Category = "Clothing")
    ENGINE_API void AddClothCollisionSource(USkeletalMeshComponent* InSourceComponent, UPhysicsAsset* InSourcePhysicsAsset);
 
    UFUNCTION(BlueprintCallable, Category = "Clothing")
    ENGINE_API void RemoveClothCollisionSources(USkeletalMeshComponent* InSourceComponent);
 
    UE_DEPRECATED(5.5, "This function has been renamed RemoveClothCollisionSources")
    void RemoveClothCollisionSource(USkeletalMeshComponent* InSourceComponent)
    {
        RemoveClothCollisionSources(InSourceComponent);
    }
 
    UFUNCTION(BlueprintCallable, Category = "Clothing")
    ENGINE_API void RemoveClothCollisionSource(USkeletalMeshComponent* InSourceComponent, UPhysicsAsset* InSourcePhysicsAsset);
 
    UFUNCTION(BlueprintCallable, Category = "Clothing")
    ENGINE_API void ResetClothCollisionSources();
 
protected:
 
#if WITH_CLOTH_COLLISION_DETECTION
    ENGINE_API void CopyClothCollisionSources();
 
    ENGINE_API void ProcessClothCollisionWithEnvironment();
 
    ENGINE_API void CopyClothCollisionsToChildren();
 
    ENGINE_API void CopyChildrenClothCollisionsToParent();
 
    ENGINE_API void FindClothCollisions(FClothCollisionData& OutCollisions) const;
 
#endif
 
public:
    ENGINE_API bool IsAnimBlueprintInstanced() const;
    ENGINE_API void ClearAnimScriptInstance();
 
    ENGINE_API void ClearCachedAnimProperties();
 
protected:
    ENGINE_API bool NeedToSpawnAnimScriptInstance() const;
    ENGINE_API bool NeedToSpawnPostPhysicsInstance(bool bForceReinit) const;
 
    ENGINE_API virtual bool ShouldBlendPhysicsBones() const;
 
    UE_DEPRECATED(5.7, "Use ClothCollisionSource::ExtractCollisions() instead.")
    static ENGINE_API void ExtractCollisionsForCloth(USkeletalMeshComponent* SourceComponent, UPhysicsAsset* PhysicsAsset, USkeletalMeshComponent* DestClothComponent, FClothCollisionData& OutCollisions, FClothCollisionSource& ClothCollisionSource);
 
    virtual void OnSyncComponentToRBPhysics() { }
 
    FSkeletalMeshComponentEndPhysicsTickFunction EndPhysicsTickFunction;
 
private:
 
    virtual void OnClearAnimScriptInstance() {};
 
    friend struct FSkeletalMeshComponentEndPhysicsTickFunction;
 
    ENGINE_API void EndPhysicsTickComponent(FSkeletalMeshComponentEndPhysicsTickFunction& ThisTickFunction);
 
    ENGINE_API void EvaluateAnimation(const USkeletalMesh* InSkeletalMesh, UAnimInstance* InAnimInstance, bool bInForceRefPose, FVector& OutRootBoneTranslation, FBlendedHeapCurve& OutCurve, FCompactPose& OutPose, UE::Anim::FHeapAttributeContainer& OutAttributes) const;
 
    ENGINE_API void DispatchParallelEvaluationTasks(FActorComponentTickFunction* TickFunction);
 
    ENGINE_API void DoParallelEvaluationTasks_OnGameThread();
 
    ENGINE_API void SwapEvaluationContextBuffers();
 
    ENGINE_API void ParallelDuplicateAndInterpolate(FAnimationEvaluationContext& InAnimEvaluationContext);
 
    ENGINE_API bool DoAnyPhysicsBodiesHaveWeight() const;
 
    ENGINE_API virtual void RefreshMorphTargets() override;
 
    ENGINE_API void GetWindForCloth_GameThread(FVector& WindVector, float& WindAdaption) const;
 
    ENGINE_API void InstantiatePhysicsAsset_Internal(const UPhysicsAsset& PhysAsset, const FVector& Scale3D, TArray<FBodyInstance*>& OutBodies, TArray<FConstraintInstance*>& OutConstraints, TFunctionRef<FTransform(int32)> BoneTransformGetter, FPhysScene* PhysScene = nullptr, USkeletalMeshComponent* OwningComponent = nullptr, int32 UseRootBodyIndex = INDEX_NONE, const FPhysicsAggregateHandle& UseAggregate = FPhysicsAggregateHandle()) const;
    ENGINE_API void InstantiatePhysicsAssetBodies_Internal(const UPhysicsAsset& PhysAsset, TArray<FBodyInstance*>& OutBodies, TFunctionRef<FTransform(int32)> BoneTransformGetter, TMap<FName, FBodyInstance*>* OutNameToBodyMap = nullptr, FPhysScene* PhysScene = nullptr, USkeletalMeshComponent* OwningComponent = nullptr, int32 UseRootBodyIndex = INDEX_NONE, const FPhysicsAggregateHandle& UseAggregate = FPhysicsAggregateHandle()) const;
 
    // Reference to our current parallel animation evaluation task (if there is one)
    FGraphEventRef              ParallelAnimationEvaluationTask;
 
    // Reference to our current blend physics task (if there is one)
    FGraphEventRef              ParallelBlendPhysicsCompletionTask;
 
    //Data for parallel evaluation of animation
    FAnimationEvaluationContext AnimEvaluationContext;
 
public:
    // Parallel evaluation wrappers
    ENGINE_API void ParallelAnimationEvaluation();
    ENGINE_API virtual void CompleteParallelAnimationEvaluation(bool bDoPostAnimEvaluation);
 
 
    // Returns whether we are currently trying to run a parallel animation evaluation task
    bool IsRunningParallelEvaluation() const { return IsValidRef(ParallelAnimationEvaluationTask); }
 
    // Management function for if we want to do an evaluation but may already be running one
    // bBlockOnTask - if true and we are currently performing parallel eval we wait for it to finish
    // bPerformPostAnimEvaluation - if true and we are currently performing parallel eval we call PostAnimEvaluation too
    // return true if parallel task was running.
    ENGINE_API bool HandleExistingParallelEvaluationTask(bool bBlockOnTask, bool bPerformPostAnimEvaluation);
 
    friend class FSkeletalMeshComponentDetails;
 
    ENGINE_API void ApplyAnimationCurvesToComponent(const TMap<FName, float>* InMaterialParameterCurves, const TMap<FName, float>* InAnimationMorphCurves);
    
    // Returns whether we're able to run a simulation (ignoring the suspend flag)
    ENGINE_API bool CanSimulateClothing() const;
 
protected:
 
    // Prep anim instances for evaluation
    ENGINE_API void DoInstancePreEvaluation();
 
    // Handle post evaluation on all anim instances
    ENGINE_API void DoInstancePostEvaluation();
 
    // Returns whether we need to run the Cloth Tick or not
    ENGINE_API virtual bool ShouldRunClothTick() const;
 
private:
    ENGINE_API virtual void AddFollowerPoseComponent(USkinnedMeshComponent* SkinnedMeshComponent) override;
    ENGINE_API virtual void RemoveFollowerPoseComponent(USkinnedMeshComponent* SkinnedMeshComponent) override;
 
    // Returns whether we need to run the Pre Cloth Tick or not
    ENGINE_API bool ShouldRunEndPhysicsTick() const;
 
    // Handles registering/unregistering the pre cloth tick as it is needed
    ENGINE_API void UpdateEndPhysicsTickRegisteredState();
 
    // Handles registering/unregistering the cloth tick as it is needed
    ENGINE_API void UpdateClothTickRegisteredState();
 
    // Handles registering/unregistering the 'during animation' tick as it is needed
    ENGINE_API void UpdateDuringAnimationTickRegisteredState();
 
    // Finalizes pose to OutBoneSpaceTransforms
    ENGINE_API void FinalizePoseEvaluationResult(const USkeletalMesh* InMesh, TArray<FTransform>& OutBoneSpaceTransforms, FVector& OutRootBoneTranslation, FCompactPose& InFinalPose) const;
 
    // Finalizes attributes (remapping from compact to mesh bone-indices)
    ENGINE_API void FinalizeAttributeEvaluationResults(const FBoneContainer& BoneContainer, const UE::Anim::FHeapAttributeContainer& FinalContainer, UE::Anim::FMeshAttributeContainer& OutContainer) const;
 
    friend class FParallelBlendPhysicsTask;
    
    ENGINE_API void BlendInPhysicsInternal(FTickFunction& ThisTickFunction);
 
    // Blends the simulation output with the component and bone space transforms coming from
    // animation (just calls PerformBlendPhysicsBones)
    void ParallelBlendPhysics() { PerformBlendPhysicsBones(RequiredBones, AnimEvaluationContext.ComponentSpaceTransforms, AnimEvaluationContext.BoneSpaceTransforms); }
 
    // Blends the simulation output with the component and bone space transforms coming from animation
    ENGINE_API void PerformBlendPhysicsBones(const TArray<FBoneIndexType>& InRequiredBones, TArray<FTransform>& InOutComponentSpaceTransforms, TArray<FTransform>& InOutBoneSpaceTransforms);
 
    friend class FParallelClothTask;
    // This is the parallel function that updates the cloth data and runs the simulation. This is safe to call from worker threads.
    //static void ParallelEvaluateCloth(float DeltaTime, const FClothingActor& ClothingActor, const FClothSimulationContext& ClothSimulationContext);
 
    friend class FParallelBlendPhysicsCompletionTask;
    ENGINE_API void CompleteParallelBlendPhysics();
    ENGINE_API void FinalizeAnimationUpdate();
 
    ENGINE_API void UpdateClothTransformImp();
 
    friend class FClothingSimulationContextCommon;
 
    friend class FTickClothingTask;
 
#if WITH_EDITORONLY_DATA
    // these are deprecated variables from removing SingleAnimSkeletalComponent
    // remove if this version goes away : VER_UE4_REMOVE_SINGLENODEINSTANCE
    // deprecated variable to be re-save
    UPROPERTY()
    TObjectPtr<class UAnimSequence> SequenceToPlay_DEPRECATED;
 
    // The default sequence to play on this skeletal mesh
    UPROPERTY()
    TObjectPtr<class UAnimationAsset> AnimToPlay_DEPRECATED;
 
    // Default setting for looping for SequenceToPlay. This is not current state of looping.
    UPROPERTY()
    uint32 bDefaultLooping_DEPRECATED:1;
 
    // Default setting for playing for SequenceToPlay. This is not current state of playing.
    UPROPERTY()
    uint32 bDefaultPlaying_DEPRECATED:1;
 
    // Default setting for position of SequenceToPlay to play. 
    UPROPERTY()
    float DefaultPosition_DEPRECATED;
 
    // Default setting for playrate of SequenceToPlay to play. 
    UPROPERTY()
    float DefaultPlayRate_DEPRECATED;
#endif
 
    /*
     * Update MorphTargetCurves from mesh - these are not animation curves, but SetMorphTarget and similar functions that can set to this mesh component
     */
    ENGINE_API void UpdateMorphTargetOverrideCurves();
 
    /*
     * Reset MorphTarget Curves - Reset all morphtarget curves
     */
    ENGINE_API void ResetMorphTargetCurves();
 
public:
    ENGINE_API FTransform ConvertLocalRootMotionToWorld(const FTransform& InTransform);
 
    ENGINE_API FRootMotionMovementParams ConsumeRootMotion();
 
#if WITH_EDITOR
    ENGINE_API void ApplyEditedComponentSpaceTransforms();
#endif
 
protected:
 
    ENGINE_API FRootMotionMovementParams ConsumeRootMotion_Internal(float InAlpha);
 
private:
 
#if WITH_EDITOR
    FBlendedHeapCurve   CurvesArray[2];
public: 
    const FBlendedHeapCurve& GetAnimationCurves() const { return CurvesArray[CurrentReadComponentTransforms]; }
 
    FBlendedHeapCurve& GetEditableAnimationCurves() { return CurvesArray[CurrentEditableComponentTransforms]; }
    const FBlendedHeapCurve& GetEditableAnimationCurves() const { return CurvesArray[CurrentEditableComponentTransforms]; }
#endif 
 
 
private:
    UE::Anim::FMeshAttributeContainer AttributesArray[2];
 
    UE::Anim::FMeshAttributeContainer& GetEditableCustomAttributes() { return AttributesArray[CurrentEditableComponentTransforms]; }
 
public:
    const UE::Anim::FMeshAttributeContainer& GetCustomAttributes() const { return AttributesArray[CurrentReadComponentTransforms]; }
public:
    virtual const bool CanHaveStaticMobility() const override { return false; }
 
public:
    ENGINE_API FDelegateHandle RegisterOnPhysicsCreatedDelegate(const FOnSkelMeshPhysicsCreated& Delegate);
    ENGINE_API void UnregisterOnPhysicsCreatedDelegate(const FDelegateHandle& DelegateHandle);
 
    ENGINE_API FDelegateHandle RegisterOnTeleportDelegate(const FOnSkelMeshTeleported& Delegate);
    ENGINE_API void UnregisterOnTeleportDelegate(const FDelegateHandle& DelegateHandle);
 
    ENGINE_API virtual FDelegateHandle RegisterOnBoneTransformsFinalizedDelegate(const FOnBoneTransformsFinalizedMultiCast::FDelegate& Delegate) override;
    ENGINE_API virtual void UnregisterOnBoneTransformsFinalizedDelegate(const FDelegateHandle& DelegateHandle) override;
 
    UE_DEPRECATED(5.6, "These should not be used as they rely on a global delegate, ANY change in LOD from ANY skeletal mesh component triggers the callback")
    ENGINE_API FDelegateHandle RegisterOnLODRequiredBonesUpdate(const FOnLODRequiredBonesUpdate& Delegate);
 
    UE_DEPRECATED(5.6, "These should not be used as they rely on a global delegate, ANY change in LOD from ANY skeletal mesh component triggers the callback")
    ENGINE_API void UnregisterOnLODRequiredBonesUpdate(const FDelegateHandle& DelegateHandle);
 
private:
    // NOTE: We anticipate that this will go away in the future, it is meant to be a temporary solution
    ENGINE_API FDelegateHandle RegisterOnLODRequiredBonesUpdate_Member(const FOnLODRequiredBonesUpdate& Delegate);
    ENGINE_API void UnregisterOnLODRequiredBonesUpdate_Member(const FDelegateHandle& DelegateHandle);
    friend class UE::UAF::FDataRegistry;
    
private:
 
#if WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, Category = AnimationRig, BlueprintGetter = GetDefaultAnimatingRigOverride, BlueprintSetter = SetDefaultAnimatingRigOverride, meta = (AllowedClasses = "/Script/ControlRigDeveloper.ControlRigBlueprint"), meta = (editcondition = "bOverrideDefaultAnimatingRig"))
    TSoftObjectPtr<UObject> DefaultAnimatingRigOverride;
 
#endif
 
#if WITH_EDITOR
public:
 
    UFUNCTION(BlueprintSetter)
    ENGINE_API void SetDefaultAnimatingRigOverride(TSoftObjectPtr<UObject> InAnimatingRig);
 
    UFUNCTION(BlueprintGetter)
    ENGINE_API TSoftObjectPtr<UObject> GetDefaultAnimatingRigOverride() const;
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkeletalMesh")
    ENGINE_API TSoftObjectPtr<UObject> GetDefaultAnimatingRig() const;
 
 
#endif
private:
 
    FOnSkelMeshPhysicsCreatedMultiCast OnSkelMeshPhysicsCreated;
 
    FOnSkelMeshTeleportedMultiCast OnSkelMeshPhysicsTeleported;
 
    FOnBoneTransformsFinalizedMultiCast OnBoneTransformsFinalizedMC;
 
    static ENGINE_API FOnLODRequiredBonesUpdateMulticast OnLODRequiredBonesUpdate_Static;
    FOnLODRequiredBonesUpdateMulticast OnLODRequiredBonesUpdate_Member;
 
    ENGINE_API void MarkRequiredCurveUpToDate();
    
    /* This will check if the required curves are up-to-date by checking version number with skeleton. 
     * Skeleton's curve list changes whenever newer is added or deleted. 
     * This still has to happen in editor as well as in game as 
     * There is no guarantee of Skeleton having all curves as we've seen over and over again. 
     * Cooking does not guarantee skeleton containing all names
     */
    ENGINE_API bool AreRequiredCurvesUpToDate() const;
 
 
private:
    // Can't rely on time value, because those may be affected by dilation and whether or not
    // the game is paused.
    // Also can't just rely on a flag as other components (like CharacterMovementComponent) may tick
    // the pose and we can't guarantee tick order.
    UPROPERTY(Transient)
    uint32 LastPoseTickFrame; 
 
public:
    ENGINE_API void ConditionallyDispatchQueuedAnimEvents();
 
    // Are we currently within PostAnimEvaluation
    bool IsPostEvaluatingAnimation() const { return bPostEvaluatingAnimation; }
 
    //~ Begin IPhysicsComponent Interface.
    ENGINE_API virtual Chaos::FPhysicsObject* GetPhysicsObjectById(Chaos::FPhysicsObjectId Id) const override;
    ENGINE_API virtual Chaos::FPhysicsObject* GetPhysicsObjectByName(const FName& Name) const override;
    ENGINE_API virtual TArray<Chaos::FPhysicsObject*> GetAllPhysicsObjects() const override;
    //~ End IPhysicsComponent Interface.
};
 
#if WITH_EDITOR
struct FPoseWatchDynamicData
{
public:
 
    FPoseWatchDynamicData(USkeletalMeshComponent* InComponent);
 
    TArray<FAnimNodePoseWatch> PoseWatches;
};
#endif
 
struct FLinkedInstancesAdapter
{
    static void AddLinkedInstance(USkeletalMeshComponent* InComponent, UAnimInstance* InAnimInstance)
    {
        if (InComponent && InAnimInstance)
        {
            InComponent->LinkedInstances.AddUnique(InAnimInstance);
        }
    }
 
    static void RemoveLinkedInstance(USkeletalMeshComponent* InComponent, UAnimInstance* InAnimInstance)
    {
        if (InComponent && InAnimInstance)
        {
            InComponent->LinkedInstances.Remove(InAnimInstance);
        }
    }
 
    static void ResetLinkedInstance(USkeletalMeshComponent* InComponent)
    {
        if (InComponent)
        {
            InComponent->LinkedInstances.Reset();
        }
    }
};