AnimationRuntime.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    AnimationRuntime.h: Skeletal mesh animation utilities
    Should only contain functions needed for runtime animation, no tools.
=============================================================================*/ 
 
#pragma once
 
#include "CoreMinimal.h"
#include "Misc/EnumClassFlags.h"
#include "BoneIndices.h"
#include "Animation/AnimTypes.h"
#include "Animation/AnimationAsset.h"
#include "Animation/AnimCurveTypes.h"
#include "Animation/AnimSequenceBase.h"
#include "Animation/SkeletonRemapping.h"
#include "BonePose.h"
#include "Containers/ArrayView.h"
 
class UBlendSpace;
class USkeletalMeshComponent;
class UMirrorDataTable;
class UMorphTarget;
struct FA2CSPose;
struct FA2Pose;
struct FInputBlendPose;
struct FAnimationPoseData;
using FMorphTargetWeightMap = TMap<const UMorphTarget*, int32>;
 
namespace UE { namespace Anim { struct FStackAttributeContainer; }}
 
typedef TArray<FTransform> FTransformArrayA2;
 
// Templated Transform Blend Functionality
 
namespace ETransformBlendMode
{
    enum Type
    {
        Overwrite,
        Accumulate
    };
}
 
template<int32>
ENGINE_API void BlendTransform(const FTransform& Source, FTransform& Dest, const float BlendWeight);
 
template<>
inline void BlendTransform<ETransformBlendMode::Overwrite>(const FTransform& Source, FTransform& Dest, const float BlendWeight)
{
    const ScalarRegister VBlendWeight(BlendWeight);
    Dest = Source * VBlendWeight;
}
 
template<>
inline void BlendTransform<ETransformBlendMode::Accumulate>(const FTransform& Source, FTransform& Dest, const float BlendWeight)
{
    const ScalarRegister VBlendWeight(BlendWeight);
    Dest.AccumulateWithShortestRotation(Source, VBlendWeight);
}
 
ENGINE_API void BlendCurves(const TArrayView<const FBlendedCurve> SourceCurves, const TArrayView<const float> SourceWeights, FBlendedCurve& OutCurve);
void ENGINE_API BlendCurves(const TArrayView<const FBlendedCurve* const> SourceCurves, const TArrayView<const float> SourceWeights, FBlendedCurve& OutCurve);
ENGINE_API void BlendCurves(const TArrayView<const FBlendedCurve* const> SourceCurves, const TArrayView<const float> SourceWeights, FBlendedCurve& OutCurve, ECurveBlendOption::Type BlendOption);
 
 
 
class IInterpolationIndexProvider
{
public:
    ~IInterpolationIndexProvider() = default;
    
    struct FPerBoneInterpolationData
    {
        virtual ~FPerBoneInterpolationData() {}
    };
 
    // There may be times when the implementation can pre-calculate data needed for GetPerBoneInterpolationIndex, as the
    // latter is often called multiple times whilst iterating over a skeleton.
    virtual TSharedPtr<FPerBoneInterpolationData> GetPerBoneInterpolationData(const USkeleton* Skeleton) const { return nullptr; }
 
    UE_DEPRECATED(5.0, "Please use the overload that takes a FCompactPoseBoneIndex")
    ENGINE_API virtual int32 GetPerBoneInterpolationIndex(
        int32 BoneIndex, const FBoneContainer& RequiredBones, const FPerBoneInterpolationData* Data) const;
 
    // Implementation should return the index into the PerBoneBlendData array that would be required when looking
    // up/blending BoneIndex. This call will be passed the results of GetPerBoneInterpolationData, so the two functions
    // should be matched.
    virtual int32 GetPerBoneInterpolationIndex(const FCompactPoseBoneIndex& InCompactPoseBoneIndex, const FBoneContainer& RequiredBones, const FPerBoneInterpolationData* Data) const = 0;
 
    // Implementation should return the index into the PerBoneBlendData array that would be required when looking
    // up/blending BoneIndex. This call will be passed the results of GetPerBoneInterpolationData, so the two functions
    // should be matched.
    virtual int32 GetPerBoneInterpolationIndex(const FSkeletonPoseBoneIndex InSkeletonBoneIndex, const USkeleton* TargetSkeleton, const IInterpolationIndexProvider::FPerBoneInterpolationData* Data) const = 0;
};
 
class FAnimationRuntime
{
public:
    static ENGINE_API void NormalizeRotations(const FBoneContainer& RequiredBones, /*inout*/ FTransformArrayA2& Atoms);
    static ENGINE_API void NormalizeRotations(FTransformArrayA2& Atoms);
 
    static ENGINE_API void InitializeTransform(const FBoneContainer& RequiredBones, /*inout*/ FTransformArrayA2& Atoms);
#if DO_GUARD_SLOW
    static ENGINE_API bool ContainsNaN(TArray<FBoneIndexType>& RequiredBoneIndices, FA2Pose& Pose);
#endif
 
    UE_DEPRECATED(4.26, "Use BlendPosesTogether with other signature")
    static ENGINE_API void BlendPosesTogether(
        TArrayView<const FCompactPose> SourcePoses,
        TArrayView<const FBlendedCurve> SourceCurves,
        TArrayView<const float> SourceWeights,
        /*out*/ FCompactPose& ResultPose, 
        /*out*/ FBlendedCurve& ResultCurve);
 
    static ENGINE_API void BlendPosesTogether(
        TArrayView<const FCompactPose> SourcePoses,
        TArrayView<const FBlendedCurve> SourceCurves,
        TArrayView<const UE::Anim::FStackAttributeContainer> SourceAttributes,
        TArrayView<const float> SourceWeights,
        FAnimationPoseData& OutAnimationPoseData);
 
    UE_DEPRECATED(4.26, "Use BlendPosesTogether with other signature")
    static ENGINE_API void BlendPosesTogether(
        TArrayView<const FCompactPose> SourcePoses,
        TArrayView<const FBlendedCurve> SourceCurves,
        TArrayView<const float> SourceWeights,
        TArrayView<const int32> SourceWeightsIndices,
        /*out*/ FCompactPose& ResultPose,
        /*out*/ FBlendedCurve& ResultCurve);
 
    static ENGINE_API void BlendPosesTogether(
        TArrayView<const FCompactPose> SourcePoses,
        TArrayView<const FBlendedCurve> SourceCurves,
        TArrayView<const UE::Anim::FStackAttributeContainer> SourceAttributes,
        TArrayView<const float> SourceWeights,
        TArrayView<const int32> SourceWeightsIndices,
        /*out*/ FAnimationPoseData& OutPoseData
        );
 
    UE_DEPRECATED(4.26, "Use BlendPosesTogetherIndirect with other signature")
    static ENGINE_API void BlendPosesTogetherIndirect(
        TArrayView<const FCompactPose* const> SourcePoses,
        TArrayView<const FBlendedCurve* const> SourceCurves,
        TArrayView<const float> SourceWeights,
        /*out*/ FCompactPose& ResultPose,
        /*out*/ FBlendedCurve& ResultCurve);
 
    static ENGINE_API void BlendPosesTogetherIndirect(
        TArrayView<const FCompactPose* const> SourcePoses,
        TArrayView<const FBlendedCurve* const> SourceCurves,
        TArrayView<const UE::Anim::FStackAttributeContainer* const> SourceAttributes,
        TArrayView<const float> SourceWeights,
        FAnimationPoseData& OutPoseData);
 
    UE_DEPRECATED(4.26, "Use BlendTwoPosesTogether with other signature")
    static ENGINE_API void BlendTwoPosesTogether(
        const FCompactPose& SourcePose1,
        const FCompactPose& SourcePose2,
        const FBlendedCurve& SourceCurve1,
        const FBlendedCurve& SourceCurve2,
        const float WeightOfPose1,
        /*out*/ FCompactPose& ResultPose,
        /*out*/ FBlendedCurve& ResultCurve);
               
    static ENGINE_API void BlendTwoPosesTogether(
        const FAnimationPoseData& SourcePoseOneData,
        const FAnimationPoseData& SourcePoseTwoData,
        const float WeightOfPoseOne,
        /*out*/ FAnimationPoseData& OutAnimationPoseData);
 
    UE_DEPRECATED(4.26, "Use BlendTwoPosesTogether with other signature")
    static ENGINE_API void BlendTwoPosesTogetherPerBone(
        const FCompactPose& SourcePose1,
        const FCompactPose& SourcePose2,
        const FBlendedCurve& SourceCurve1,
        const FBlendedCurve& SourceCurve2,
        const TArray<float>& WeightsOfSource2,
        /*out*/ FCompactPose& ResultPose,
        /*out*/ FBlendedCurve& ResultCurve);
        
    static ENGINE_API void BlendTwoPosesTogetherPerBone(
        const FAnimationPoseData& SourcePoseOneData,
        const FAnimationPoseData& SourcePoseTwoData,
        const TArray<float>& WeightsOfSource2,
        /*out*/ FAnimationPoseData& OutAnimationPoseData);
 
    static ENGINE_API void BlendTwoPosesTogetherPerBone(
        const FCompactPose& SourcePoseOneData,
        const FCompactPose& SourcePoseTwoData,
        const TArray<float>& WeightsOfSource2,
        /*out*/ FCompactPose& OutAnimationPoseData);
        
    UE_DEPRECATED(4.26, "Use BlendPosesTogetherPerBone with other signature")
    static ENGINE_API void BlendPosesTogetherPerBone(
        TArrayView<const FCompactPose> SourcePoses,
        TArrayView<const FBlendedCurve> SourceCurves,
        const IInterpolationIndexProvider* InterpolationIndexProvider,
        TArrayView<const FBlendSampleData> BlendSampleDataCache,
        /*out*/ FCompactPose& ResultPose,
        /*out*/ FBlendedCurve& ResultCurve);
 
    static ENGINE_API void BlendPosesTogetherPerBone(
        TArrayView<const FCompactPose> SourcePoses,
        TArrayView<const FBlendedCurve> SourceCurves,
        TArrayView<const UE::Anim::FStackAttributeContainer> SourceAttributes,
        const IInterpolationIndexProvider* InterpolationIndexProvider,
        TArrayView<const FBlendSampleData> BlendSampleDataCache,
        /*out*/ FAnimationPoseData& OutAnimationPoseData);
 
    static ENGINE_API void BlendPosesTogetherPerBoneRemapped(
        TArrayView<const FCompactPose> SourcePoses, 
        TArrayView<const FBlendedCurve> SourceCurves, 
        TArrayView<const UE::Anim::FStackAttributeContainer> SourceAttributes, 
        const IInterpolationIndexProvider* InterpolationIndexProvider,
        TArrayView<const FBlendSampleData> BlendSampleDataCache,
        TArrayView<const int32> BlendSampleDataCacheIndices, 
        const FSkeletonRemapping& SkeletonRemapping,
        /*out*/ FAnimationPoseData& OutAnimationPoseData);
 
 
    UE_DEPRECATED(4.26, "Use BlendPosesTogetherPerBone with other signature")
    static ENGINE_API void BlendPosesTogetherPerBone(
        TArrayView<const FCompactPose> SourcePoses,
        TArrayView<const FBlendedCurve> SourceCurves,
        const IInterpolationIndexProvider* InterpolationIndexProvider,
        TArrayView<const FBlendSampleData> BlendSampleDataCache,
        TArrayView<const int32> BlendSampleDataCacheIndices,
        /*out*/ FCompactPose& ResultPose,
        /*out*/ FBlendedCurve& ResultCurve);
 
    static ENGINE_API void BlendPosesTogetherPerBone(
        TArrayView<const FCompactPose> SourcePoses,
        TArrayView<const FBlendedCurve> SourceCurves,
        TArrayView<const UE::Anim::FStackAttributeContainer> SourceAttributes,
        const IInterpolationIndexProvider* InterpolationIndexProvider,
        TArrayView<const FBlendSampleData> BlendSampleDataCache,
        TArrayView<const int32> BlendSampleDataCacheIndices,
        /*out*/ FAnimationPoseData& OutAnimationPoseData);
 
    UE_DEPRECATED(4.26, "Use BlendPosesTogetherPerBone with other signature")
    static ENGINE_API void BlendPosesTogetherPerBoneInMeshSpace(
        TArrayView<FCompactPose>           SourcePoses,
        TArrayView<const FBlendedCurve>    SourceCurves,
        const UBlendSpace*                 BlendSpace,
        TArrayView<const FBlendSampleData> BlendSampleDataCache,
        FCompactPose&                      OutResultPose,
        FBlendedCurve&                     OutResultCurve);
 
    static ENGINE_API void BlendPosesTogetherPerBoneInMeshSpace(
        TArrayView<FCompactPose>                             SourcePoses,
        TArrayView<const FBlendedCurve>                      SourceCurves,
        TArrayView<const UE::Anim::FStackAttributeContainer> SourceAttributes,  
        const UBlendSpace*                                   BlendSpace,
        TArrayView<const FBlendSampleData>                   BlendSampleDataCache,
        FAnimationPoseData&                                  OutAnimationPoseData);
 
    enum class EBlendPosesPerBoneFilterFlags : uint32
    {
        None = 0,
        MeshSpaceRotation = (1 << 0),   
        MeshSpaceScale    = (1 << 1),   
        RootSpaceRotation = (1 << 2),   
    };
 
    static ENGINE_API void BlendPosesPerBoneFilter(
        FCompactPose& BasePose,
        const TConstArrayView<FCompactPose> BlendPoses,
        FBlendedCurve& BaseCurve,
        const TConstArrayView<FBlendedCurve> BlendedCurves,
        UE::Anim::FStackAttributeContainer& BaseAttributes,
        const TArrayView<UE::Anim::FStackAttributeContainer> BlendAttributes,
        FAnimationPoseData& OutAnimationPoseData,
        const TArrayView<FPerBoneBlendWeight> BoneBlendWeights,
        EBlendPosesPerBoneFilterFlags BlendFlags,
        enum ECurveBlendOption::Type CurveBlendOption);
 
    static ENGINE_API void UpdateDesiredBoneWeight(
        const TArrayView<FPerBoneBlendWeight> SrcBoneBlendWeights,
        TArrayView<FPerBoneBlendWeight> TargetBoneBlendWeights,
        const TArrayView<float> BlendWeights);
 
    static ENGINE_API void CreateMaskWeights(
            TArray<FPerBoneBlendWeight>& BoneBlendWeights,
            const TArray<FInputBlendPose>& BlendFilters, 
            const USkeleton* Skeleton);
 
    static ENGINE_API void CreateMaskWeights(
        TArray<FPerBoneBlendWeight>& BoneBlendWeights,
        const TArray<class UBlendProfile*>& BlendMasks,
        const USkeleton* Skeleton);
 
    static ENGINE_API void CombineWithAdditiveAnimations(
        int32 NumAdditivePoses,
        const FTransformArrayA2** SourceAdditivePoses,
        const float* SourceAdditiveWeights,
        const FBoneContainer& RequiredBones,
        /*inout*/ FTransformArrayA2& Atoms);
 
    static ENGINE_API FTransform GetComponentSpaceRefPose(const FCompactPoseBoneIndex& CompactPoseBoneIndex, const FBoneContainer& BoneContainer);
 
    static ENGINE_API void FillWithRefPose(TArray<FTransform>& OutAtoms, const FBoneContainer& RequiredBones);
 
    static ENGINE_API void ConvertPoseToMeshSpace(const TArray<FTransform>& LocalTransforms, TArray<FTransform>& MeshSpaceTransforms, const FBoneContainer& RequiredBones);
 
    static ENGINE_API void ConvertPoseToAdditive(FCompactPose& TargetPose, const FCompactPose& BasePose);
 
    static ENGINE_API void ConvertTransformToAdditive(FTransform& TargetTrasnform, const FTransform& BaseTransform);
 
    static ENGINE_API void ConvertPoseToMeshRotation(FCompactPose& LocalPose);
 
    static ENGINE_API void ConvertMeshRotationPoseToLocalSpace(FCompactPose& Pose);
 
    UE_DEPRECATED(4.26, "Use AccumulateAdditivePose with other signature")
    static ENGINE_API void AccumulateAdditivePose(FCompactPose& BasePose, const FCompactPose& AdditivePose, FBlendedCurve& BaseCurve, const FBlendedCurve& AdditiveCurve, float Weight, enum EAdditiveAnimationType AdditiveType);
    
    static ENGINE_API void AccumulateAdditivePose(FAnimationPoseData& BaseAnimationPoseData, const FAnimationPoseData& AdditiveAnimationPoseData, float Weight, enum EAdditiveAnimationType AdditiveType);
 
private:
    static ENGINE_API void AccumulateLocalSpaceAdditivePoseInternal(FCompactPose& BasePose, const FCompactPose& AdditivePose, float Weight);
 
    static ENGINE_API void AccumulateMeshSpaceRotationAdditiveToLocalPoseInternal(FCompactPose& BasePose, const FCompactPose& MeshSpaceRotationAdditive, float Weight);
 
    static ENGINE_API void AccumulateRootSpaceAdditivePoseInternal(FCompactPose& BasePose, const FCompactPose& RootSpaceAdditivePose, float Weight);
 
public:
 
    UE_DEPRECATED(4.26, "Use AccumulateAdditivePose with other signature")
    static ENGINE_API void AccumulateLocalSpaceAdditivePose(FCompactPose& BasePose, const FCompactPose& AdditivePose, FBlendedCurve& BaseCurve, const FBlendedCurve& AdditiveCurve, float Weight);
 
    static ENGINE_API void AccumulateLocalSpaceAdditivePose(FAnimationPoseData& BaseAnimationPoseData, const FAnimationPoseData& AdditiveAnimationPoseData, float Weight);
 
    UE_DEPRECATED(4.26, "Use AccumulateAdditivePose with other signature")
    static ENGINE_API void AccumulateMeshSpaceRotationAdditiveToLocalPose(FCompactPose& BasePose, const FCompactPose& MeshSpaceRotationAdditive, FBlendedCurve& BaseCurve, const FBlendedCurve& AdditiveCurve, float Weight);
 
    static ENGINE_API void AccumulateMeshSpaceRotationAdditiveToLocalPose(FAnimationPoseData& BaseAnimationPoseData, const FAnimationPoseData& MeshSpaceRotationAdditiveAnimationPoseData, float Weight);
 
    static ENGINE_API void AccumulateRootSpaceRotationAdditiveToLocalPose(FAnimationPoseData& BaseAnimationPoseData, const FAnimationPoseData& MeshSpaceRotationAdditiveAnimationPoseData, float Weight);
 
    static ENGINE_API void LerpPoses(FCompactPose& PoseA, const FCompactPose& PoseB, FBlendedCurve& CurveA, const FBlendedCurve& CurveB, float Alpha);
 
    static ENGINE_API void LerpPosesPerBone(FCompactPose& PoseA, const FCompactPose& PoseB, FBlendedCurve& CurveA, const FBlendedCurve& CurveB, float Alpha, const TArray<float>& PerBoneWeights);
 
    static ENGINE_API void LerpPosesWithBoneIndexList(FCompactPose& PoseA, const FCompactPose& PoseB, FBlendedCurve& CurveA, const FBlendedCurve& CurveB, float Alpha, const TArray<FCompactPoseBoneIndex>& BoneIndices);
 
    static ENGINE_API void LerpBoneTransforms(TArray<FTransform>& A, const TArray<FTransform>& B, float Alpha, const TArray<FBoneIndexType>& RequiredBonesArray);
 
    UE_DEPRECATED(4.26.0, "Please use BlendTransform() for weighted blending")
    static ENGINE_API void BlendTransformsByWeight(FTransform& OutTransform, const TArray<FTransform>& Transforms, const TArray<float>& Weights);
 
    static ENGINE_API void MirrorCurves(FBlendedCurve& Curves, const UMirrorDataTable& MirrorDataTable);
 
    static ENGINE_API FVector MirrorVector(const FVector& V, EAxis::Type MirrorAxis);
 
    static ENGINE_API FQuat MirrorQuat(const FQuat& Q, EAxis::Type MirrorAxis);
 
    static ENGINE_API void MirrorPose(FCompactPose& Pose, const UMirrorDataTable& MirrorDataTable);
 
    static ENGINE_API void MirrorPose(FCompactPose& Pose, EAxis::Type MirrorAxis, const TArray<FCompactPoseBoneIndex>& CompactPoseMirrorBones, const TCustomBoneIndexArray<FQuat, FCompactPoseBoneIndex>& ComponentSpaceRefRotations);
 
    static ENGINE_API ETypeAdvanceAnim AdvanceTime(const bool bAllowLooping, const float MoveDelta, float& InOutTime, const float EndTime);
 
    static ENGINE_API void TickBlendWeight(float DeltaTime, float DesiredWeight, float& Weight, float& BlendTime);
    static ENGINE_API void ApplyWeightToTransform(const FBoneContainer& RequiredBones, /*inout*/ FTransformArrayA2& Atoms, float Weight);
 
    static ENGINE_API void GetKeyIndicesFromTime(int32& OutKeyIndex1, int32& OutKeyIndex2, float& OutAlpha, const double Time, const int32 NumKeys, const double SequenceLength, double FramesPerSecond=-1.0);
    
    static ENGINE_API void GetKeyIndicesFromTime(int32& OutKeyIndex1, int32& OutKeyIndex2, float& OutAlpha, const double Time, const FFrameRate& FrameRate, const int32 NumberOfKeys);
 
    static ENGINE_API void EnsureParentsPresent(TArray<FBoneIndexType>& BoneIndices, const FReferenceSkeleton& RefSkeleton);
 
    static ENGINE_API void ExcludeBonesWithNoParents(const TArray<int32>& BoneIndices, const FReferenceSkeleton& RefSkeleton, TArray<int32>& FilteredRequiredBones);
 
    static ENGINE_API void ConvertCSTransformToBoneSpace(const FTransform& ComponentTransform, FCSPose<FCompactPose>& MeshBases, FTransform& InOutCSBoneTM, FCompactPoseBoneIndex BoneIndex, EBoneControlSpace Space);
 
    static ENGINE_API void ConvertBoneSpaceTransformToCS(const FTransform& ComponentTransform, FCSPose<FCompactPose>& MeshBases, FTransform& InOutBoneSpaceTM, FCompactPoseBoneIndex BoneIndex, EBoneControlSpace Space);
 
    // FA2Pose/FA2CSPose Interfaces for template functions
    static ENGINE_API FTransform GetSpaceTransform(FA2Pose& Pose, int32 Index);
    static ENGINE_API FTransform GetSpaceTransform(FA2CSPose& Pose, int32 Index);
    static ENGINE_API void SetSpaceTransform(FA2Pose& Pose, int32 Index, FTransform& NewTransform);
    static ENGINE_API void SetSpaceTransform(FA2CSPose& Pose, int32 Index, FTransform& NewTransform);
    // space bases
    static ENGINE_API FTransform GetComponentSpaceTransformRefPose(const FReferenceSkeleton& RefSkeleton, int32 BoneIndex);
    static ENGINE_API FTransform GetComponentSpaceTransform(const FReferenceSkeleton& RefSkeleton, const TArrayView<const FTransform> &BoneSpaceTransforms, int32 BoneIndex);
    static ENGINE_API void FillUpComponentSpaceTransforms(const FReferenceSkeleton& RefSkeleton, const TArrayView<const FTransform> &BoneSpaceTransforms, TArray<FTransform> &ComponentSpaceTransforms);
    static ENGINE_API void MakeSkeletonRefPoseFromMesh(const USkeletalMesh* InMesh, const USkeleton* InSkeleton, TArray<FTransform>& OutBoneBuffer);
 
    static ENGINE_API EBoneTranslationRetargetingMode::Type GetBoneTranslationRetargetingMode(const bool bUseSourceRetargetModes, const int32 SourceSkeletonBoneIndex, const int32 TargetSkeletonBoneIndex, const USkeleton* SourceSkeleton, const USkeleton* TargetSkeleton, const bool bDisableRetargeting);
 
    static ENGINE_API const FTransform& GetComponentSpaceTransformWithCache(const FReferenceSkeleton& InRefSkeleton, const TArray<FTransform> &InBoneSpaceTransforms, int32 BoneIndex, TArray<FTransform>& CachedTransforms, TArray<bool>& CachedTransformReady);
 
#if WITH_EDITOR
    static ENGINE_API void FillUpComponentSpaceTransformsRefPose(const USkeleton* Skeleton, TArray<FTransform> &ComponentSpaceTransforms);
#endif
 
    /* Weight utility functions */
    static inline bool IsFullWeight(float Weight) { return FAnimWeight::IsFullWeight(Weight); }
    static inline bool HasWeight(float Weight) { return FAnimWeight::IsRelevant(Weight); }
    
    static ENGINE_API void AppendActiveMorphTargets(const USkeletalMesh* InSkeletalMesh, const TMap<FName, float>& InMorphCurveAnims, FMorphTargetWeightMap& InOutActiveMorphTargets, TArray<float>& InOutMorphTargetWeights);
 
    static ENGINE_API void RetargetBoneTransform(const USkeleton* SourceSkeleton, const FName& RetargetSource, FTransform& BoneTransform, const int32 SkeletonBoneIndex, const FCompactPoseBoneIndex& BoneIndex, const FBoneContainer& RequiredBones, const bool bIsBakedAdditive);
    static ENGINE_API void RetargetBoneTransform(const USkeleton* MySkeleton, const FName& SourceName, const TArray<FTransform>& RetargetTransforms, FTransform& BoneTransform, const int32 SkeletonBoneIndex, const FCompactPoseBoneIndex& BoneIndex, const FBoneContainer& RequiredBones, const bool bIsBakedAdditive);
    static ENGINE_API int32 GetStringDistance(const FString& First, const FString& Second);
};
 
ENUM_CLASS_FLAGS(FAnimationRuntime::EBlendPosesPerBoneFilterFlags);
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "Components/SkinnedMeshComponent.h"
#endif