AnimTypes.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 "Misc/MemStack.h"
#include "Algo/Transform.h"
#include "Animation/AnimLinkableElement.h"
#include "Animation/AnimEnums.h"
#include "Misc/SecureHash.h"
#include "Kismet/BlueprintFunctionLibrary.h"
#include "UObject/UE5ReleaseStreamObjectVersion.h"
#include "AnimTypes.generated.h"
 
struct FMarkerPair;
struct FMarkerSyncAnimPosition;
struct FPassedMarker;
 
class FMemoryReader;
class FMemoryWriter;
class UMirrorDataTable;
 
// Disable debugging information for shipping and test builds.
#define ENABLE_ANIM_DEBUG (1 && !(UE_BUILD_SHIPPING || UE_BUILD_TEST))
 
#define DEFAULT_SAMPLERATE          30.f
#define MINIMUM_ANIMATION_LENGTH    (1/DEFAULT_SAMPLERATE)
 
// Enable this if you want to locally measure detailed anim perf.  Disabled by default as it is introduces a lot of additional profile markers and associated overhead.
#define ENABLE_VERBOSE_ANIM_PERF_TRACKING 0
 
#define MAX_ANIMATION_TRACKS 65535
 
namespace EAnimEventTriggerOffsets
{
    enum Type
    {
        OffsetBefore,
        OffsetAfter,
        NoOffset
    };
}
 
ENGINE_API float GetTriggerTimeOffsetForType(EAnimEventTriggerOffsets::Type OffsetType);
 
UENUM()
enum EBoneAxis : int
{
    BA_X UMETA(DisplayName = "X Axis"),
    BA_Y UMETA(DisplayName = "Y Axis"),
    BA_Z UMETA(DisplayName = "Z Axis"),
};
 
 
UENUM(BlueprintType)
enum EBoneControlSpace : int
{
    BCS_WorldSpace UMETA(DisplayName = "World Space"),
    BCS_ComponentSpace UMETA(DisplayName = "Component Space"),
    BCS_ParentBoneSpace UMETA(DisplayName = "Parent Bone Space"),
    BCS_BoneSpace UMETA(DisplayName = "Bone Space"),
    BCS_MAX,
};
 
UENUM()
enum EBoneRotationSource : int
{
    BRS_KeepComponentSpaceRotation UMETA(DisplayName = "No Change (Preserve Existing Component Space Rotation)"),
    BRS_KeepLocalSpaceRotation UMETA(DisplayName = "Maintain Local Rotation Relative to Parent"),
    BRS_CopyFromTarget UMETA(DisplayName = "Copy Target Rotation"),
};
 
UENUM()
namespace EMontageNotifyTickType
{
    enum Type : int
    {
        Queued,
        BranchingPoint,
    };
}
 
UENUM()
namespace ENotifyFilterType
{
    enum Type : int
    {
        NoFiltering,
 
        LOD,
    };
}
 
USTRUCT(BlueprintType)
struct FPerBoneBlendWeight
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    int32 SourceIndex;
 
    UPROPERTY()
    float BlendWeight;
 
    FPerBoneBlendWeight()
        : SourceIndex(0)
        , BlendWeight(0.0f)
    {
    }
};
 
USTRUCT(BlueprintType)
struct FPerBoneBlendWeights
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    TArray<FPerBoneBlendWeight> BoneBlendWeights;
 
 
    FPerBoneBlendWeights() {}
 
};
 
struct FGraphTraversalCounter
{
private:
    // Number of the last external frame where we updated the counter (total global frame count)
    uint64 LastSyncronizedFrame;
 
    // Number of counter increments since last reset
    int16 Counter;
 
    // Number of external frames that URO is currently scheduled to skip
    int16 SkipFrames;
 
public:
 
    FGraphTraversalCounter()
        : LastSyncronizedFrame(INDEX_NONE)
        , Counter(INDEX_NONE)
        , SkipFrames(0)
 
    {}
 
    int16 Get() const
    {
        return Counter;
    }
 
    bool HasEverBeenUpdated() const
    {
        return (Counter != INDEX_NONE) && (LastSyncronizedFrame != INDEX_NONE);
    }
 
    void Increment()
    {
        Counter++;
        LastSyncronizedFrame = GFrameCounter;
 
        // Avoid wrapping over back to INDEX_NONE, as this means 'never been traversed'
        if (Counter == INDEX_NONE)
        {
            Counter++;
        }
    }
 
    void SetMaxSkippedFrames(int16 InMaxSkippedFrames)
    {
        SkipFrames = InMaxSkippedFrames;
    }
 
    int16 GetMaxSkippedFrames() const
    {
        return SkipFrames;
    }
 
    void Reset()
    {
        Counter = INDEX_NONE;
        LastSyncronizedFrame = INDEX_NONE;
        SkipFrames = 0;
    }
 
    void SynchronizeWith(const FGraphTraversalCounter& InMasterCounter)
    {
        Counter = InMasterCounter.Counter;
        LastSyncronizedFrame = InMasterCounter.LastSyncronizedFrame;
        SkipFrames = InMasterCounter.SkipFrames;
    }
 
    bool IsSynchronized_Counter(const FGraphTraversalCounter& InOtherCounter) const
    {
        return HasEverBeenUpdated() && Counter == InOtherCounter.Counter;
    }
 
    bool IsSynchronized_Frame(const FGraphTraversalCounter& InOtherCounter) const
    {
        return HasEverBeenUpdated() && LastSyncronizedFrame == InOtherCounter.LastSyncronizedFrame;
    }
 
    bool IsSynchronized_All(const FGraphTraversalCounter& InOtherCounter) const
    {
        return HasEverBeenUpdated() && Counter == InOtherCounter.Counter && LastSyncronizedFrame == InOtherCounter.LastSyncronizedFrame;
    }
 
    bool WasSynchronizedCounter(const FGraphTraversalCounter& InOtherCounter) const
    {
        // Test if we're currently in sync with our master counter
        if(IsSynchronized_Counter(InOtherCounter))
        {
            return true;
        }
 
        // If not, test if the Master Counter is a frame ahead of us
        FGraphTraversalCounter TestCounter(*this);
        TestCounter.Increment();
 
        return TestCounter.IsSynchronized_Counter(InOtherCounter);
    }
 
    bool WasSynchronizedLastFrame(const FGraphTraversalCounter& InOtherCounter) const
    {
        // Test if we're currently in sync with our master counter
        if(IsSynchronized_Frame(InOtherCounter))
        {
            return true;
        }
 
        // If we aren't synced then check if we were synced last frame
        return LastSyncronizedFrame >= (GFrameCounter - SkipFrames) - 1;
    }
};
 
USTRUCT(BlueprintType)
struct FAnimNotifyEvent : public FAnimLinkableElement
{
    GENERATED_USTRUCT_BODY()
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    float DisplayTime_DEPRECATED;
#endif
 
    UPROPERTY()
    float TriggerTimeOffset;
 
    UPROPERTY()
    float EndTriggerTimeOffset;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=AnimNotifyEvent)
    float TriggerWeightThreshold;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=AnimNotifyEvent)
    FName NotifyName;
 
    UPROPERTY(EditAnywhere, Instanced, BlueprintReadWrite, Category=AnimNotifyEvent)
    TObjectPtr<class UAnimNotify>  Notify;
 
    UPROPERTY(EditAnywhere, Instanced, BlueprintReadWrite, Category=AnimNotifyEvent)
    TObjectPtr<class UAnimNotifyState>  NotifyStateClass;
 
    UPROPERTY()
    float Duration;
 
    UPROPERTY()
    FAnimLinkableElement EndLink;
 
    UPROPERTY()
    bool bConvertedFromBranchingPoint;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=AnimNotifyEvent)
    TEnumAsByte<EMontageNotifyTickType::Type> MontageTickType;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = AnimNotifyTriggerSettings, meta = (ClampMin = "0.0", ClampMax = "1.0"))
    float NotifyTriggerChance;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = AnimNotifyTriggerSettings)
    TEnumAsByte<ENotifyFilterType::Type> NotifyFilterType;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = AnimNotifyTriggerSettings, meta = (ClampMin = "0"))
    int32 NotifyFilterLOD;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = AnimNotifyTriggerSettings)
    bool bCanBeFilteredViaRequest;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = AnimNotifyTriggerSettings)
    bool bTriggerOnDedicatedServer;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = AnimNotifyTriggerSettings)
    bool bTriggerOnFollower;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FColor NotifyColor;
 
    UPROPERTY(meta = (ExcludeFromHash))
    FGuid Guid;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY()
    int32 TrackIndex;
 
private:
    mutable FName CachedNotifyEventName;
 
    mutable FName CachedNotifyEventBaseName;
 
public:
    FAnimNotifyEvent()
        : FAnimLinkableElement()
#if WITH_EDITORONLY_DATA
        , DisplayTime_DEPRECATED(0)
#endif
        , TriggerTimeOffset(0)
        , EndTriggerTimeOffset(0)
        , TriggerWeightThreshold(ZERO_ANIMWEIGHT_THRESH)
        , Notify(nullptr)
        , NotifyStateClass(nullptr)
        , Duration(0)
        , bConvertedFromBranchingPoint(false)
        , MontageTickType(EMontageNotifyTickType::Queued)
        , NotifyTriggerChance(1.f)
        , NotifyFilterType(ENotifyFilterType::NoFiltering)
        , NotifyFilterLOD(0)
        , bCanBeFilteredViaRequest(true)
        , bTriggerOnDedicatedServer(true)
        , bTriggerOnFollower(false)
#if WITH_EDITORONLY_DATA
        , NotifyColor(FColor::Black)
#endif // WITH_EDITORONLY_DATA
        , TrackIndex(0)
        , CachedNotifyEventName(NAME_None)
        , CachedNotifyEventBaseName(NAME_None)
    {
    }
 
    virtual ~FAnimNotifyEvent()
    {
    }
 
#if WITH_EDITORONLY_DATA
    ENGINE_API bool Serialize(FArchive& Ar);
    ENGINE_API void PostSerialize(const FArchive& Ar);
#endif
 
    ENGINE_API void RefreshTriggerOffset(EAnimEventTriggerOffsets::Type PredictedOffsetType);
 
    ENGINE_API void RefreshEndTriggerOffset(EAnimEventTriggerOffsets::Type PredictedOffsetType);
 
    ENGINE_API float GetTriggerTime() const;
 
    ENGINE_API float GetEndTriggerTime() const;
 
    ENGINE_API float GetDuration() const;
 
    ENGINE_API void SetDuration(float NewDuration);
 
    ENGINE_API bool IsBranchingPoint() const;
 
    bool IsBlueprintNotify() const
    {
        return Notify != nullptr || NotifyStateClass != nullptr;
    }
 
    bool operator ==(const FAnimNotifyEvent& Other) const
    {
        return(
            (Notify && Notify == Other.Notify) || 
            (NotifyStateClass && NotifyStateClass == Other.NotifyStateClass) ||
            (!IsBlueprintNotify() && NotifyName == Other.NotifyName)
            );
    }
 
    ENGINE_API bool operator <(const FAnimNotifyEvent& Other) const;
 
    ENGINE_API virtual void SetTime(float NewTime, EAnimLinkMethod::Type ReferenceFrame = EAnimLinkMethod::Absolute) override;
 
    ENGINE_API FName GetNotifyEventName() const;
    
    ENGINE_API FName GetNotifyEventName(const UMirrorDataTable* MirrorDataTable) const;
};
 
#if WITH_EDITORONLY_DATA
template<> struct TStructOpsTypeTraits<FAnimNotifyEvent> : public TStructOpsTypeTraitsBase2<FAnimNotifyEvent>
{
    enum 
    { 
        WithSerializer = true,
        WithPostSerialize = true
    };
};
#endif
 
// Used by UAnimSequenceBase::SortNotifies() to sort its Notifies array
inline bool FAnimNotifyEvent::operator<(const FAnimNotifyEvent& Other) const
{
    float ATime = GetTriggerTime();
    float BTime = Other.GetTriggerTime();
 
    // When we've got the same time sort on the track index. Explicitly
    // using SMALL_NUMBER here incase the underlying default changes as
    // notifies can have an offset of KINDA_SMALL_NUMBER to be consider
    // distinct
    if (FMath::IsNearlyEqual(ATime, BTime, UE_SMALL_NUMBER))
    {
        return TrackIndex < Other.TrackIndex;
    }
    else
    {
        return ATime < BTime;
    }
}
 
USTRUCT(BlueprintType)
struct FAnimSyncMarker
{
    GENERATED_BODY()
 
    FAnimSyncMarker()
        : MarkerName(NAME_None)
        , Time(0.0f)
#if WITH_EDITORONLY_DATA
        , TrackIndex(0)
#endif
    {}
 
    // The name of this marker
    UPROPERTY(BlueprintReadOnly, Category=Animation)
    FName MarkerName;
 
    // Time in seconds of this marker
    UPROPERTY(BlueprintReadOnly, Category = Animation)
    float Time;
 
#if WITH_EDITORONLY_DATA
    // The editor track this marker sits on
    UPROPERTY()
    int32 TrackIndex;
 
    UPROPERTY()
    FGuid Guid;
#endif
    
#if WITH_EDITORONLY_DATA
    ENGINE_API bool Serialize(FArchive& Ar);
#endif
 
    bool operator <(const FAnimSyncMarker& Other) const { return Time < Other.Time; }
 
    bool operator ==(const FAnimSyncMarker& Other) const
    {
        return MarkerName == Other.MarkerName &&
#if WITH_EDITORONLY_DATA
            TrackIndex == Other.TrackIndex &&
            Guid == Other.Guid &&
#endif
            Time == Other.Time;
    }
};
 
#if WITH_EDITORONLY_DATA
template<> struct TStructOpsTypeTraits<FAnimSyncMarker> : public TStructOpsTypeTraitsBase2<FAnimSyncMarker>
{
    enum 
    { 
        WithSerializer = true
    };
    static constexpr EPropertyObjectReferenceType WithSerializerObjectReferences = EPropertyObjectReferenceType::None;
};
#endif
 
USTRUCT()
struct FAnimNotifyTrack
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    FName TrackName;
 
    UPROPERTY()
    FLinearColor TrackColor;
 
    TArray<FAnimNotifyEvent*> Notifies;
    
    TArray<FAnimSyncMarker*> SyncMarkers;
 
    FAnimNotifyTrack()
        : TrackName(TEXT(""))
        , TrackColor(FLinearColor::White)
    {
    }
 
    FAnimNotifyTrack(FName InTrackName, FLinearColor InTrackColor)
        : TrackName(InTrackName)
        , TrackColor(InTrackColor)
    {
    }
};
 
UENUM()
enum EAdditiveAnimationType : int
{
    AAT_None  UMETA(DisplayName="No additive"),
    /* Create Additive from LocalSpace Base. */
    AAT_LocalSpaceBase UMETA(DisplayName="Local Space"),
    /* Create Additive from MeshSpace Rotation Only, Translation still will be LocalSpace. */
    AAT_RotationOffsetMeshSpace UMETA(DisplayName="Mesh Space"),
    AAT_MAX,
};
 
UENUM()
namespace ECurveBlendOption
{
    enum Type : int
    {
        /* Last pose that contains valid curve value override it. */
        Override, // redirect from MaxWeight old legacy behavior
        DoNotOverride, 
        NormalizeByWeight,
        BlendByWeight, 
        UseBasePose,
        UseMaxValue,
        UseMinValue,
    };
}
 
struct FSlotNodeWeightInfo
{
    float SourceWeight;
 
    float SlotNodeWeight;
 
    float TotalNodeWeight;
 
    FSlotNodeWeightInfo()
        : SourceWeight(0.f)
        , SlotNodeWeight(0.f)
        , TotalNodeWeight(0.f)
    {}
 
    void Reset()
    {
        SourceWeight = 0.f;
        SlotNodeWeight = 0.f;
        TotalNodeWeight = 0.f;
    }
};
 
USTRUCT()
struct FMarkerSyncData
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    TArray<FAnimSyncMarker>     AuthoredSyncMarkers;
 
    TArray<FName>               UniqueMarkerNames;
 
    void GetMarkerIndicesForTime(float CurrentTime, bool bLooping, const TArray<FName>& ValidMarkerNames, FMarkerPair& OutPrevMarker, FMarkerPair& OutNextMarker, float SequenceLength) const;
    
    UE_DEPRECATED(5.0, "Use other GetMarkerSyncPositionFromMarkerIndicies signature")
    FMarkerSyncAnimPosition GetMarkerSyncPositionfromMarkerIndicies(int32 PrevMarker, int32 NextMarker, float CurrentTime, float SequenceLength) const;
    FMarkerSyncAnimPosition GetMarkerSyncPositionFromMarkerIndicies(int32 PrevMarker, int32 NextMarker, float CurrentTime, float SequenceLength, const UMirrorDataTable* MirrorTable = nullptr) const;
    void CollectUniqueNames();
    void CollectMarkersInRange(float PrevPosition, float NewPosition, TArray<FPassedMarker>& OutMarkersPassedThisTick, float TotalDeltaMove);
};
 
// Shortcut for the allocator used by animation nodes.
typedef TMemStackAllocator<> FAnimStackAllocator;
 
struct FAnimWeight
{
    static inline bool IsRelevant(float InWeight)
    {
        return (InWeight > ZERO_ANIMWEIGHT_THRESH);
    }
 
    static inline bool IsFullWeight(float InWeight)
    {
        return (InWeight >= (1.f - ZERO_ANIMWEIGHT_THRESH));
    }
 
    static inline float GetSmallestRelevantWeight()
    {
        return 2.f * ZERO_ANIMWEIGHT_THRESH;
    }
};
 
UENUM(BlueprintType)
enum class EAnimInterpolationType : uint8
{
    Linear      UMETA(DisplayName="Linear"),
 
    Step        UMETA(DisplayName="Step"),
};
 
 
/*
 *  Smart name UID type definition
 * 
 * This is used by FSmartNameMapping/FSmartName to identify by number
 * This defines default type and Max number for the type and used all over animation code to identify curve
 * including bone container containing valid UID list for curves
 */
 namespace SmartName
{
    // ID type, should be used to access SmartNames as fundamental type may change.
    typedef uint16 UID_Type;
    // Max UID used for overflow checking
    inline constexpr UID_Type MaxUID = MAX_uint16;
}
struct FAnimKeyHelper
{
    FAnimKeyHelper(float InLength, int32 InNumKeys)
        : Length(InLength)
        , NumKeys(InNumKeys)
    {}
 
    float TimePerKey() const
    {
        return (NumKeys > 1) ? Length / (float)(NumKeys - 1) : MINIMUM_ANIMATION_LENGTH;
    }
 
    // Returns the FPS for the given length and number of keys
    float KeysPerSecond() const
    {
        return NumKeys > 0 ? (float(NumKeys - 1) / Length) : 0.0f;
    }
 
    int32 LastKey() const
    {
        return (NumKeys > 1) ? NumKeys - 1 : 0;
    }
 
    float GetLength() const 
    {
        return Length;
    }
 
    int32 GetNumKeys() const 
    {
        return NumKeys;
    }
 
private:
    float Length;
    int32 NumKeys;
};
 
UENUM()
namespace EAxisOption
{
    enum Type : int
    {
        X,
        Y,
        Z,
        X_Neg,
        Y_Neg,
        Z_Neg,
        Custom
    };
}
 
struct FAxisOption
{
    static FVector GetAxisVector(const TEnumAsByte<EAxisOption::Type> InAxis, const FVector& CustomAxis)
    {
        switch (InAxis)
        {
        case EAxisOption::X:
            return FVector::ForwardVector;
        case EAxisOption::X_Neg:
            return -FVector::ForwardVector;
        case EAxisOption::Y:
            return FVector::RightVector;
        case EAxisOption::Y_Neg:
            return -FVector::RightVector;
        case EAxisOption::Z:
            return FVector::UpVector;
        case EAxisOption::Z_Neg:
            return -FVector::UpVector;
        case EAxisOption::Custom:
            return CustomAxis;
        }
 
        return FVector::ForwardVector;
    }
 
    static FVector GetAxisVector(const TEnumAsByte<EAxisOption::Type> InAxis)
    {
        return GetAxisVector(InAxis, FVector::ForwardVector);
    }
};
 
// The transform component (attribute) to read from
UENUM()
namespace EComponentType
{
    enum Type : int
    {
        None = 0,
        TranslationX,
        TranslationY,
        TranslationZ,
        RotationX,
        RotationY,
        RotationZ,
        Scale UMETA(DisplayName = "Scale (largest component)"),
        ScaleX,
        ScaleY,
        ScaleZ
    };
}
 
// @note We have a plan to support skeletal hierarchy. When that happens, we'd like to keep skeleton indexing.
USTRUCT()
struct FTrackToSkeletonMap
{
    GENERATED_USTRUCT_BODY()
 
    // Index of Skeleton.BoneTree this Track belongs to.
    UPROPERTY()
    int32 BoneTreeIndex;
 
 
    FTrackToSkeletonMap()
        : BoneTreeIndex(0)
    {
    }
 
    FTrackToSkeletonMap(int32 InBoneTreeIndex)
        : BoneTreeIndex(InBoneTreeIndex)
    {
    }
 
    friend FArchive& operator<<(FArchive& Ar, FTrackToSkeletonMap &Item)
    {
        return Ar << Item.BoneTreeIndex;
    }
};
 
USTRUCT(BlueprintType)
struct FRawAnimSequenceTrack
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    TArray<FVector3f> PosKeys;
 
    UPROPERTY()
    TArray<FQuat4f> RotKeys;
 
    UPROPERTY()
    TArray<FVector3f> ScaleKeys;
 
    // Serializer.
    friend FArchive& operator<<(FArchive& Ar, FRawAnimSequenceTrack& T)
    {
        T.PosKeys.BulkSerialize(Ar);
        T.RotKeys.BulkSerialize(Ar);
 
        if (Ar.UEVer() >= VER_UE4_ANIM_SUPPORT_NONUNIFORM_SCALE_ANIMATION)
        {
            T.ScaleKeys.BulkSerialize(Ar);
        }
 
        return Ar;
    }
 
    bool ContainsNaN() const
    {
        bool bContainsNaN = false;
 
        auto CheckForNan = [&bContainsNaN](const auto& Keys) -> bool
        {
            if (!bContainsNaN)
            {
                for (const auto& Key : Keys)
                {
                    if (Key.ContainsNaN())
                        return true;
                }
 
                return false;
            }
        
            return true;
        };
 
        bContainsNaN = CheckForNan(PosKeys);
        bContainsNaN = CheckForNan(RotKeys);
        bContainsNaN = CheckForNan(ScaleKeys);
 
        return bContainsNaN;
    }
 
    bool Serialize(FArchive& Ar)
    {
        Ar.UsingCustomVersion(FUE5ReleaseStreamObjectVersion::GUID); 
 
        // Previously generated content was saved without bulk array serialization, so have to rely on UProperty serialization until resaved
        if (Ar.CustomVer(FUE5ReleaseStreamObjectVersion::GUID) < FUE5ReleaseStreamObjectVersion::RawAnimSequenceTrackSerializer)
        {
            return false;
        }
 
        Ar << *this;
 
        return true;
    }
 
    static const uint32 SingleKeySize = sizeof(FVector3f) + sizeof(FQuat4f) + sizeof(FVector3f);
};
 
template<> struct TStructOpsTypeTraits<FRawAnimSequenceTrack> : public TStructOpsTypeTraitsBase2<FRawAnimSequenceTrack>
{
    enum { WithSerializer = true };
    static constexpr EPropertyObjectReferenceType WithSerializerObjectReferences = EPropertyObjectReferenceType::None;
};
 
UCLASS(MinimalAPI)
class URawAnimSequenceTrackExtensions : public UBlueprintFunctionLibrary
{
    GENERATED_BODY()
public:
 
    UFUNCTION(BlueprintPure, Category = Animation, meta=(ScriptMethod))
    static TArray<FVector> GetPositionalKeys(UPARAM(ref)const FRawAnimSequenceTrack& Track)
    {
        TArray<FVector> Keys;
        Algo::Transform(Track.PosKeys, Keys, [](FVector3f FloatKey)
        {
            return FVector(FloatKey);
        });
 
        return Keys;
    }
 
    UFUNCTION(BlueprintPure, Category = Animation, meta=(ScriptMethod))
    static TArray<FQuat> GetRotationalKeys(UPARAM(ref)const FRawAnimSequenceTrack& Track)
    {
        TArray<FQuat> Keys;
        Algo::Transform(Track.RotKeys, Keys, [](FQuat4f FloatKey)
        {
            return FQuat(FloatKey);
        });
 
        return Keys;
    }
 
    UFUNCTION(BlueprintPure, Category = Animation, meta=(ScriptMethod))
    static TArray<FVector> GetScaleKeys(UPARAM(ref)const FRawAnimSequenceTrack& Track)
    {
        TArray<FVector> Keys;
        Algo::Transform(Track.ScaleKeys, Keys, [](FVector3f FloatKey)
        {
            return FVector(FloatKey);
        });
 
        return Keys;
    }
};
 
 
class FBoneData
{
public:
    FQuat       Orientation;
 
    FVector3f   Position;
 
    FVector3f   Scale;
 
    FName       Name;
 
    TArray<int32> Children;
 
    TArray<int32>   BonesToRoot;
 
    TArray<int32>   EndEffectors;
 
    bool        bHasSocket;
 
    bool        bKeyEndEffector;
 
    int32 GetParent() const
    {
        return GetDepth() ? BonesToRoot[0] : -1;
    }
 
    int32 GetDepth() const
    {
        return BonesToRoot.Num();
    }
 
    bool IsEndEffector() const
    {
        return Children.Num() == 0;
    }
};
 
#if 0
template <typename ArrayType>
FGuid GetArrayGuid(const TArray<ArrayType>& Array)
{
    FSHA1 Sha;
    Sha.Update((uint8*)Array.GetData(), Array.Num() * Array.GetTypeSize());
 
    Sha.Final();
 
    uint32 Hash[5];
    Sha.GetHash((uint8*)Hash);
    FGuid Guid(Hash[0] ^ Hash[4], Hash[1], Hash[2], Hash[3]);
    return Guid;
}
 
template <typename ArrayType>
void DebugLogArray(const TArray<ArrayType>& Array)
{
    FPlatformMisc::LowLevelOutputDebugStringf(TEXT("Array: %i %s\n"), Array.Num(), *GetArrayGuid(Array).ToString());
    for (int32 i = 0; i < Array.Num(); ++i)
    {
        FPlatformMisc::LowLevelOutputDebugStringf(TEXT("\t%i %s\n"), i, *Array[i].ToString());
    }
}
 
template <>
void DebugLogArray(const TArray<FRawAnimSequenceTrack>& RawData);
#endif