IAnimationDataModel.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "AnimDataNotifications.h"
#include "Animation/AnimationPoseData.h"
#include "Animation/AttributeCurve.h"
#include "Features/IModularFeature.h"
 
class IAnimationDataController;
 
#include "IAnimationDataModel.generated.h"
 
namespace UE::Anim::DataModel
{
    struct FEvaluationContext
    {
        FEvaluationContext() = delete;
        FEvaluationContext(double InTime, FFrameRate InSampleRate, FName InRetargetSource, const TArray<FTransform>& InRetargetTransforms, EAnimInterpolationType InInterpolationType = EAnimInterpolationType::Linear)
            : SampleFrameRate(InSampleRate), SampleTime(InSampleRate.AsFrameTime(InTime)), RetargetSource(InRetargetSource), RetargetTransforms(InRetargetTransforms), InterpolationType(InInterpolationType)
        {       
        }
 
        FEvaluationContext(FFrameTime InTime, FFrameRate InSampleRate, FName InRetargetSource, const TArray<FTransform>& InRetargetTransforms, EAnimInterpolationType InInterpolationType = EAnimInterpolationType::Linear)
            : SampleFrameRate(InSampleRate), SampleTime(InTime), RetargetSource(InRetargetSource), RetargetTransforms(InRetargetTransforms), InterpolationType(InInterpolationType)
        {       
        }
 
        const FFrameRate SampleFrameRate;
        const FFrameTime SampleTime;
        const FName RetargetSource;
        const TArray<FTransform>& RetargetTransforms;
        const EAnimInterpolationType InterpolationType;
    };
 
    class IAnimationDataModels : public IModularFeature
    {
    public:
        virtual ~IAnimationDataModels() = default;
 
        static FName GetModularFeatureName()
        {
            static FName FeatureName = FName(TEXT("AnimationDataModels"));
            return FeatureName;
        }
 
        virtual UClass* GetModelClass(UAnimSequenceBase* OwningAnimationAsset) const = 0;
        
        static ENGINE_API UClass* FindClassForAnimationAsset(UAnimSequenceBase* AnimSequenceBase);
    };
}
 
USTRUCT(BlueprintType)
struct FBoneAnimationTrack
{
    GENERATED_BODY()
 
    
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Model")
    FRawAnimSequenceTrack InternalTrackData;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Model")
    int32 BoneTreeIndex = INDEX_NONE;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Model")
    FName Name;
};
 
USTRUCT(BlueprintType)
struct FAnimationCurveData
{
    GENERATED_BODY()
 
    
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Model")
    TArray<FFloatCurve> FloatCurves;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Model")
    TArray<FTransformCurve> TransformCurves;
};
 
USTRUCT(BlueprintType)
struct FAnimatedBoneAttribute
{
    GENERATED_BODY()
 
    
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Model")
    FAnimationAttributeIdentifier Identifier;   
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Model")
    FAttributeCurve Curve;
};
 
struct FTrackToSkeletonMap;
struct FAnimationCurveIdentifier;
 
UINTERFACE(BlueprintType, meta=(CannotImplementInterfaceInBlueprint), MinimalAPI)
class UAnimationDataModel : public UInterface
{
    GENERATED_BODY()
};
 
class IAnimationDataModel
{       
public:
    GENERATED_BODY()
 
#if WITH_EDITOR
    // RAII helper to allow repopulating data model without warnings during reimporting
    struct FReimportScope
    {
        FReimportScope(IAnimationDataModel* InModel) : bPopulationFlagRef(InModel->GetPopulationFlag())
        {
            bOriginalValue = bPopulationFlagRef;
            if (bOriginalValue)
            {
                bPopulationFlagRef = false;
            }
        }
 
        ~FReimportScope()
        {
            // Only reset back to true if that was the original state and currently is false            
            if (!bPopulationFlagRef && bOriginalValue)
            {
                bPopulationFlagRef = bOriginalValue;
            }
        }
    private:
        bool& bPopulationFlagRef;
        bool bOriginalValue;
    };
#endif // WITH_EDITOR
 
    UFUNCTION(BlueprintCallable, Category=AnimationDataModel)
    virtual double GetPlayLength() const = 0;
    
    UFUNCTION(BlueprintCallable, Category = AnimationDataModel)
    virtual int32 GetNumberOfFrames() const = 0;
 
    UFUNCTION(BlueprintCallable, Category = AnimationDataModel)
    virtual int32 GetNumberOfKeys() const = 0;
 
    UFUNCTION(BlueprintCallable, Category = AnimationDataModel)
    virtual FFrameRate GetFrameRate() const = 0;
 
    UE_DEPRECATED(5.2, "GetBoneAnimationTracks has been deprecated")
    UFUNCTION(BlueprintCallable, Category = AnimationDataModel)
    virtual const TArray<FBoneAnimationTrack>& GetBoneAnimationTracks() const = 0;
 
    virtual FTransform EvaluateBoneTrackTransform(FName TrackName, const FFrameTime& FrameTime, const EAnimInterpolationType& Interpolation) const = 0;
    virtual FTransform GetBoneTrackTransform(FName TrackName, const FFrameNumber& FrameNumber) const = 0;
    virtual void GetBoneTrackTransforms(FName TrackName, const TArray<FFrameNumber>& FrameNumbers, TArray<FTransform>& OutTransforms) const = 0;
    virtual void GetBoneTrackTransforms(FName TrackName, TArray<FTransform>& OutTransforms) const = 0;
    virtual void GetBoneTracksTransform(const TArray<FName>& TrackNames, const FFrameNumber& FrameNumber, TArray<FTransform>& OutTransforms) const = 0;
    
    UE_DEPRECATED(5.2, "GetBoneTrackByIndex has been deprecated")
    UFUNCTION(BlueprintCallable, Category = AnimationDataModel)
    virtual const FBoneAnimationTrack& GetBoneTrackByIndex(int32 TrackIndex) const = 0;
 
    UE_DEPRECATED(5.2, "GetBoneTrackByName has been deprecated")
    UFUNCTION(BlueprintCallable, Category = AnimationDataModel)
    virtual const FBoneAnimationTrack& GetBoneTrackByName(FName TrackName) const = 0;
 
    UE_DEPRECATED(5.2, "FindBoneTrackByName has been deprecated")
    virtual const FBoneAnimationTrack* FindBoneTrackByName(FName Name) const = 0;
 
    UE_DEPRECATED(5.2, "FindBoneTrackByIndex has been deprecated")
    virtual const FBoneAnimationTrack* FindBoneTrackByIndex(int32 BoneIndex) const = 0;
 
    UE_DEPRECATED(5.2, "FindBoneTrackByIndex has been deprecated")
    UFUNCTION(BlueprintCallable, Category = AnimationDataModel)
    virtual int32 GetBoneTrackIndex(const FBoneAnimationTrack& Track) const = 0;
 
    UE_DEPRECATED(5.2, "GetBoneTrackIndexByName has been deprecated")
    UFUNCTION(BlueprintCallable, Category = AnimationDataModel)
    virtual int32 GetBoneTrackIndexByName(FName TrackName) const = 0;
 
    UE_DEPRECATED(5.2, "IsValidBoneTrackIndex has been deprecated")
    UFUNCTION(BlueprintCallable, Category = AnimationDataModel)
    virtual bool IsValidBoneTrackIndex(int32 TrackIndex) const = 0;
 
    UFUNCTION(BlueprintCallable, Category = AnimationDataModel)
    virtual bool IsValidBoneTrackName(const FName& TrackName) const = 0;
 
    UFUNCTION(BlueprintCallable, Category = AnimationDataModel)
    virtual int32 GetNumBoneTracks() const = 0;
 
    UFUNCTION(BlueprintCallable, Category = AnimationDataModel)
    virtual void GetBoneTrackNames(TArray<FName>& OutNames) const = 0;
 
    virtual const FAnimationCurveData& GetCurveData() const = 0;
 
    UFUNCTION(BlueprintCallable, Category = AnimationDataModel)
    virtual int32 GetNumberOfTransformCurves() const = 0;
 
    UFUNCTION(BlueprintCallable, Category = AnimationDataModel)
    virtual int32 GetNumberOfFloatCurves() const = 0;
 
    virtual const TArray<struct FFloatCurve>& GetFloatCurves() const = 0;
 
    virtual const TArray<struct FTransformCurve>& GetTransformCurves() const = 0;
 
    virtual const FAnimCurveBase* FindCurve(const FAnimationCurveIdentifier& CurveIdentifier) const = 0;
 
    virtual const FFloatCurve* FindFloatCurve(const FAnimationCurveIdentifier& CurveIdentifier) const = 0;
 
    virtual const FTransformCurve* FindTransformCurve(const FAnimationCurveIdentifier& CurveIdentifier) const = 0;
 
    virtual const FRichCurve* FindRichCurve(const FAnimationCurveIdentifier& CurveIdentifier) const = 0;
 
    virtual const FAnimCurveBase& GetCurve(const FAnimationCurveIdentifier& CurveIdentifier) const = 0;
 
    virtual const FFloatCurve& GetFloatCurve(const FAnimationCurveIdentifier& CurveIdentifier) const = 0;
 
    virtual const FTransformCurve& GetTransformCurve(const FAnimationCurveIdentifier& CurveIdentifier) const = 0;
 
    virtual const FRichCurve& GetRichCurve(const FAnimationCurveIdentifier& CurveIdentifier) const = 0;
        
    virtual TArrayView<const FAnimatedBoneAttribute> GetAttributes() const = 0;
 
    virtual int32 GetNumberOfAttributes() const = 0;
 
    virtual int32 GetNumberOfAttributesForBoneIndex(const int32 BoneIndex) const = 0;
 
    virtual void GetAttributesForBone(const FName& BoneName, TArray<const FAnimatedBoneAttribute*>& OutBoneAttributes) const = 0;
 
    virtual const FAnimatedBoneAttribute& GetAttribute(const FAnimationAttributeIdentifier& AttributeIdentifier) const = 0;
 
    virtual const FAnimatedBoneAttribute* FindAttribute(const FAnimationAttributeIdentifier& AttributeIdentifier) const = 0;
        
    UFUNCTION(BlueprintCallable, Category = AnimationDataModel)
    virtual UAnimSequence* GetAnimationSequence() const = 0;
 
    virtual FAnimDataModelModifiedEvent& GetModifiedEvent() = 0;
 
    struct FGuidGenerationSettings
    {
        FGuidGenerationSettings() : bIncludeBoneData(1), bIncludeCurveData(1), bIncludeAttributeData(1), bIncludeTimingData(1) {}
 
        uint8 bIncludeBoneData : 1;
        uint8 bIncludeCurveData : 1;
        uint8 bIncludeAttributeData : 1;
        uint8 bIncludeTimingData : 1;
    };
 
    virtual FGuid GenerateGuid(const FGuidGenerationSettings& InSettings) const = 0;
 
    virtual FGuid GenerateGuid() const { return GenerateGuid(FGuidGenerationSettings()); }
 
#if WITH_EDITOR
    virtual FString GenerateDebugStateString() const
    {
        return FString::Printf(TEXT("DebugStateString not implemented. Guid == %s"), *GenerateGuid().ToString());
    }
#endif
 
    virtual TScriptInterface<IAnimationDataController> GetController() = 0;
 
#if WITH_EDITOR
    virtual void Evaluate(FAnimationPoseData& InOutPoseData, const UE::Anim::DataModel::FEvaluationContext& EvaluationContext) const = 0;
#endif // WITH_EDITOR
 
    virtual bool HasBeenPopulated() const = 0;
    virtual void IterateBoneKeys(const FName& BoneName, TFunction<bool(const FVector3f& Pos, const FQuat4f&, const FVector3f, const FFrameNumber&)> IterationFunction) const = 0;
 
    struct FEvaluationAndModificationLock
    {
        FEvaluationAndModificationLock(IAnimationDataModel& InModel) : Model(InModel) { InModel.LockEvaluationAndModification(); bLocked = true; }
        FEvaluationAndModificationLock(IAnimationDataModel& InModel, const TFunction<bool()>& SpinFunc) : Model(InModel)
        {
            while(SpinFunc())
            {
                bLocked = InModel.TryLockEvaluationAndModification();
                if (bLocked)
                {
                    break;
                }
            }
        }
        ~FEvaluationAndModificationLock()  { if(bLocked) {Model.UnlockEvaluationAndModification(); } }
    private:
        IAnimationDataModel& Model;
        bool bLocked = false;
    };
protected:
    virtual FAnimDataModelModifiedDynamicEvent& GetModifiedDynamicEvent() = 0;
    virtual void OnNotify(const EAnimDataModelNotifyType& NotifyType, const FAnimDataModelNotifPayload& Payload) = 0;
 
    virtual void LockEvaluationAndModification() const = 0;
    virtual bool TryLockEvaluationAndModification() const = 0;
    virtual void UnlockEvaluationAndModification() const = 0;
    virtual bool& GetPopulationFlag() = 0;
    
    struct FModelNotifier;
    virtual IAnimationDataModel::FModelNotifier& GetNotifier() = 0;
 
    struct FModelNotifier
    {
        virtual ~FModelNotifier() = default;    
        
        template<typename T>
        void Notify(EAnimDataModelNotifyType NotifyType, const T& PayloadData)
        {
            UScriptStruct* TypeScriptStruct = T::StaticStruct();
 
            const FAnimDataModelNotifPayload Payload((int8*)&PayloadData, TypeScriptStruct);
            DataModel->OnNotify(NotifyType, Payload);
            
            ModifiedEvent.Broadcast(NotifyType, DataModel.GetInterface(), Payload);
            
            if (ModifiedEventDynamic.IsBound())
            {
                ModifiedEventDynamic.Broadcast(NotifyType, DataModel, Payload);
            }
 
            // Only regenerate transient data when not in a bracket, or at the end of one
            {
                if (NotifyType == EAnimDataModelNotifyType::BracketOpened)
                {
                    ++BracketCounter;
                }
                if (NotifyType == EAnimDataModelNotifyType::BracketClosed)
                {
                    --BracketCounter;
                }
 
                check(BracketCounter >= 0);
            }
        }
 
        void Notify(EAnimDataModelNotifyType NotifyType)
        {
            const FEmptyPayload EmptyPayload;
            Notify<FEmptyPayload>(NotifyType, EmptyPayload);
        }
    
        FModelNotifier(TScriptInterface<IAnimationDataModel> ModelInterface) :
            DataModel(ModelInterface),              
            ModifiedEvent(ModelInterface->GetModifiedEvent()),
            ModifiedEventDynamic(ModelInterface->GetModifiedDynamicEvent())
        {                   
        }
 
        int32 GetBracketDepth() const
        {
            return BracketCounter;
        }
 
    protected:
        TScriptInterface<IAnimationDataModel> DataModel;
        FAnimDataModelModifiedEvent& ModifiedEvent; 
        FAnimDataModelModifiedDynamicEvent& ModifiedEventDynamic;
        int32 BracketCounter = 0;
    };
};