AnimSequenceHelpers.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "UObject/WeakObjectPtrTemplates.h"
#include "AnimData/AnimDataNotifications.h"
#include "BoneContainer.h"
#include "Containers/Array.h"
#include "Delegates/IDelegateInstance.h"
 
class UAnimSequence;
class IAnimationDataModel;
class UAnimDataController;
class IAnimationDataController;
class FName;
struct FCompactPose;
struct FRawCurveTracks;
struct FRawAnimSequenceTrack;
struct FBoneAnimationTrack;
struct FRawAnimSequenceTrack;
struct FAnimationPoseData;
class IAnimationDataController;
struct FVirtualBoneCompactPoseData;
 
enum class EAnimInterpolationType : uint8;
 
namespace UE {
 
namespace Anim {
 
#if WITH_EDITOR
    UE_DEPRECATED(5.1, "Use BuildPoseFromModel with different signature instead")
    ENGINE_API void BuildPoseFromModel(const IAnimationDataModel* Model, FCompactPose& OutPose, const float Time, const EAnimInterpolationType& InterpolationType, const FName& RetargetSource, const TArray<FTransform>& RetargetTransforms);
 
    ENGINE_API void BuildPoseFromModel(const IAnimationDataModel* Model, FAnimationPoseData& OutPoseData, const double Time, const EAnimInterpolationType& InterpolationType, const FName& RetargetSource, const TArray<FTransform>& RetargetTransforms);
 
    ENGINE_API void EvaluateFloatCurvesFromModel(const IAnimationDataModel* Model, FBlendedCurve& OutCurves, double Time);
 
    ENGINE_API void EvaluateTransformCurvesFromModel(const IAnimationDataModel* Model, TMap<FName, FTransform>& OutCurves, double Time, float BlendWeight);
 
    UE_DEPRECATED(5.2, "GetBoneTransformFromModel with TrackIndex has been deprecated, use IAnimationDataModel::GetBoneTrackTransform instead")
    ENGINE_API void GetBoneTransformFromModel(const IAnimationDataModel* Model, FTransform& OutTransform, int32 TrackIndex, double Time, const EAnimInterpolationType& Interpolation);
    
    UE_DEPRECATED(5.2, "GetBoneTransformFromModel with TrackIndex has been deprecated, use IAnimationDataModel::GetBoneTrackTransform instead")
    ENGINE_API void GetBoneTransformFromModel(const IAnimationDataModel* Model, FTransform& OutTransform, int32 TrackIndex, int32 KeyIndex);
 
    ENGINE_API void CopyCurveDataToModel(const FRawCurveTracks& CurveData, const USkeleton* Skeleton, IAnimationDataController& Controller);
 
    ENGINE_API bool CopyNotifies(const UAnimSequenceBase* SourceAnimSeq, UAnimSequenceBase* DestAnimSeq, bool bShowDialogs = true, bool bDeleteExistingNotifies = false);
 
    namespace AnimationData
    {
        ENGINE_API bool AddLoopingInterpolation(UAnimSequence* InSequence);
 
        ENGINE_API bool Trim(UAnimSequence* InSequence, TRange<FFrameNumber> TrimRange);
 
        UE_DEPRECATED(5.6, "Trimming operation using time values has been deprecated use Trim with FFrameNumbers instead")
        ENGINE_API bool Trim(UAnimSequence* InSequence, float TrimStart, float TrimEnd, bool bInclusiveEnd=false);
                
        ENGINE_API void DuplicateKeys(UAnimSequence* InSequence, int32 StartKeyIndex, int32 NumDuplicates, int32 SourceKeyIndex = INDEX_NONE);
 
        ENGINE_API void RemoveKeys(UAnimSequence* InSequence, int32 StartKeyIndex, int32 NumKeysToRemove);
 
        ENGINE_API FName FindFirstChildTrackName(const UAnimSequence* InSequence, const USkeleton* Skeleton, const FName& BoneName);
 
        UE_DEPRECATED(5.2, "FindFirstChildTrackIndex has been deprecated, use FindFirstChildTrackName instead")
        static int32 FindFirstChildTrackIndex(const UAnimSequence* InSequence, const USkeleton* Skeleton, const FName& BoneName) { return INDEX_NONE; }
    }
#endif // WITH_EDITOR
 
    ENGINE_API void ExtractBoneTransform(const struct FRawAnimSequenceTrack& RawTrack, FTransform& OutTransform, int32 KeyIndex);
 
 
    ENGINE_API FTransform MirrorTransform(const FTransform& Transform, const UMirrorDataTable& MirrorDataTable);
 
    ENGINE_API FTransform ExtractRootMotionFromAnimationAsset(const UAnimationAsset* Animation, const UMirrorDataTable* MirrorDataTable, float StartTime, float DeltaTime, bool bAllowLooping);
 
    ENGINE_API FTransform ExtractRootMotionFromAnimationAsset(const UAnimationAsset* Animation, const UMirrorDataTable* MirrorDataTable, float StartPosition, float EndPosition);
 
    ENGINE_API FTransform ExtractRootTransformFromAnimationAsset(const UAnimationAsset* Animation, float Position);
 
    namespace Compression
    {
        UE_DEPRECATED(5.4, "CompressAnimationDataTracks has been deprecated use other signature with skeleton and bone mappings")
        ENGINE_API bool CompressAnimationDataTracks(TArray<FRawAnimSequenceTrack>& RawAnimationData, int32 NumberOfKeys, FName ErrorName, float MaxPosDiff = 0.0001f, float MaxAngleDiff = 0.0003f, float MaxScaleDiff = 0.0001f);
 
        ENGINE_API bool CompressAnimationDataTracks(const USkeleton* Skeleton, const TArray<FTrackToSkeletonMap>& TrackToSkeleton,TArray<FRawAnimSequenceTrack>& RawAnimationData, int32 NumberOfKeys, FName ErrorName, float MaxPosDiff = 0.0001f, float MaxAngleDiff = 0.0003f, float MaxScaleDiff = 0.0001f);
 
        UE_DEPRECATED(5.5, "CompressRawAnimSequenceTrack requires the MaxScaleDiff argument")
        ENGINE_API bool CompressRawAnimSequenceTrack(FRawAnimSequenceTrack& RawTrack, int32 NumberOfKeys, FName ErrorName, float MaxPosDiff, float MaxAngleDiff);
 
        ENGINE_API bool CompressRawAnimSequenceTrack(FRawAnimSequenceTrack& RawTrack, int32 NumberOfKeys, FName ErrorName, float MaxPosDiff, float MaxAngleDiff, float MaxScaleDiff);
 
        ENGINE_API void SanitizeRawAnimSequenceTrack(FRawAnimSequenceTrack& RawTrack);
 
#if WITH_EDITOR
        // RAII helper to temporarily block Animation compression requests for specified AnimationSequence
        struct FScopedCompressionGuard
        {
            FScopedCompressionGuard() = delete;
            ENGINE_API FScopedCompressionGuard(UAnimSequence* InAnimSequence);
            ENGINE_API ~FScopedCompressionGuard();
        protected:
            TObjectPtr<UAnimSequence> AnimSequence;
        };
#endif // WITH_EDITOR
    }
 
    namespace DataModel { struct FEvaluationContext; }
    namespace Retargeting
    {
        struct FRetargetTracking
        {
            const FCompactPoseBoneIndex PoseBoneIndex;
            const int32 SkeletonBoneIndex;
 
            FRetargetTracking(const FCompactPoseBoneIndex InPoseBoneIndex, const int32 InSkeletonBoneIndex) : PoseBoneIndex(InPoseBoneIndex), SkeletonBoneIndex(InSkeletonBoneIndex) {}
        };
 
        struct FRetargetingScope
        {
            ENGINE_API FRetargetingScope(const USkeleton* InSourceSkeleton, FCompactPose& ToRetargetPose, const DataModel::FEvaluationContext& InEvaluationContext);
            ENGINE_API ~FRetargetingScope();
            
            ENGINE_API void AddTrackedBone(FCompactPoseBoneIndex CompactBoneIndex, int32 SkeletonBoneIndex) const;
        private:
            const USkeleton* SourceSkeleton;
            FCompactPose& RetargetPose;
            const DataModel::FEvaluationContext& EvaluationContext;
            TArray<FRetargetTracking>& RetargetTracking;
            bool bShouldRetarget;
        };
        
        UE_DEPRECATED(5.1, "UE::Anim::Retargeting::RetargetPose has been deprecated as retargeting while evaluating pose data from a DataModel is now handled/performed implicitly")
        ENGINE_API void RetargetPose(FCompactPose& InOutPose, const FName& RetargetSource, const TArray<FTransform>& RetargetTransforms);
    }
 
    struct FBuildRawPoseScratchArea : public TThreadSingleton<FBuildRawPoseScratchArea>
    {
        TArray<Retargeting::FRetargetTracking> RetargetTracking;
        TArray<FVirtualBoneCompactPoseData> VirtualBoneCompactPoseData;
    };
 
} // namespace Anim 
 
} // namespace UE