IAnimationDataController.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "UObject/Interface.h"
#include "CurveIdentifier.h"
#include "Misc/FrameRate.h"
#include "AttributeIdentifier.h"
#include "IAnimationDataModel.h"
#include "Logging/LogVerbosity.h"
#include "Algo/Transform.h"
#include "Animation/AnimCurveTypes.h"
 
#if WITH_EDITOR
#include "ChangeTransactor.h"
#endif // WITH_EDITOR
 
#include "IAnimationDataController.generated.h"
 
#define LOCTEXT_NAMESPACE "IAnimationDataController"
 
class FText;
class UAssetUserData;
class IAnimationDataModel;
 
struct FCurveAttributes;
struct FAnimationCurveIdentifier;
struct FAnimationAttributeIdentifier;
 
namespace UE {
namespace Anim {
    class FOpenBracketAction;
    class FCloseBracketAction;
}}
 
UINTERFACE(BlueprintType, meta=(CannotImplementInterfaceInBlueprint), MinimalAPI)
class UAnimationDataController : public UInterface
{
    GENERATED_BODY()
};
 
class IAnimationDataController
{
public:
    GENERATED_BODY()
 
#if WITH_EDITOR
    struct FScopedBracket
    {
        FScopedBracket(IAnimationDataController* InController, const FText& InDescription, bool bInShouldTransact=true)
            : Controller(*InController), bShouldTransact(bInShouldTransact)
        {
            Controller.OpenBracket(InDescription, bShouldTransact);
        }
 
        FScopedBracket(IAnimationDataController& InController, const FText& InDescription, bool bInShouldTransact=true)
            : Controller(InController), bShouldTransact(bInShouldTransact)
        {
            Controller.OpenBracket(InDescription, bShouldTransact);
        }
        
        FScopedBracket(const TScriptInterface<IAnimationDataController>& InController, const FText& InDescription, bool bInShouldTransact=true)
            : Controller(*InController), bShouldTransact(bInShouldTransact)
        {
            Controller.OpenBracket(InDescription, bShouldTransact);
        }
        
        ~FScopedBracket()
        {
            Controller.CloseBracket(bShouldTransact);
        }
    private:
        IAnimationDataController& Controller;
        bool bShouldTransact;
    };
#endif // WITH_EDITOR
 
    UFUNCTION(BlueprintCallable, Category = AnimationData)
    virtual void SetModel(TScriptInterface<IAnimationDataModel> InModel) = 0;
 
    UFUNCTION(BlueprintCallable, Category = AnimationData)
    virtual TScriptInterface<IAnimationDataModel> GetModelInterface() const = 0;
 
    virtual const IAnimationDataModel* const GetModel() const = 0;
 
    UFUNCTION(BlueprintCallable, Category = AnimationData)
    virtual void OpenBracket(const FText& InTitle, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = AnimationData)
    virtual void CloseBracket(bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = AnimationData)
    virtual void SetNumberOfFrames(FFrameNumber NewLengthInFrames, bool bShouldTransact = true) = 0;
 
    UE_DEPRECATED(5.1, "SetPlayLength with length in seconds in deprecated use SetNumberOfFrames using FFrameNumber instead")
    UFUNCTION(BlueprintCallable, Category = AnimationData, meta=(DeprecatedFunction, DeprecationMessage="SetPlayLength is deprecated use SetNumberOfFrames instead."))
    virtual void SetPlayLength(float Length, bool bShouldTransact = true) = 0;
 
    /*** Sets the total play-able length in seconds. Broadcasts a EAnimDataModelNotifyType::SequenceLengthChanged notify if successful.
    * T0 and T1 are expected to represent the window of time that was either added or removed. E.g. for insertion T0 indicates the time
    * at which additional time starts and T1 were it ends. For removal T0 indicates the time at which time should be started to remove, and T1 indicates the end. Giving a total of T1 - T0 added or removed length.
    * The number of frames and keys for the provided length is recalculated according to the current value of UAnimDataModel::FrameRate.
    * @param    NewLengthInFrames   Total new play-able number of frames value (according to frame rate), has to be positive and non-zero
    * @param    T0                  Point between 0 and NewLengthInFrames at which the change in length starts
    * @param    T1                  Point between 0 and NewLengthInFrames at which the change in length ends
    * @param    bShouldTransact     Whether or not any undo-redo changes should be generated
    */
    UFUNCTION(BlueprintCallable, Category = AnimationData)
    virtual void ResizeNumberOfFrames(FFrameNumber NewLengthInFrames, FFrameNumber T0, FFrameNumber T1, bool bShouldTransact = true) = 0;
 
    UE_DEPRECATED(5.1, "ResizePlayLength with length in seconds in deprecated use ResizeNumberOfFrames using FFrameNumber instead")
    UFUNCTION(BlueprintCallable, Category = AnimationData, meta=(DeprecatedFunction, DeprecationMessage="ResizePlayLength is deprecated use ResizeNumberOfFrames instead."))
    virtual void ResizePlayLength(float NewLength, float T0, float T1, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = AnimationData)
    virtual void ResizeInFrames(FFrameNumber NewLengthInFrames, FFrameNumber T0, FFrameNumber T1, bool bShouldTransact = true) = 0;
 
    UE_DEPRECATED(5.1, "Resize with length in seconds in deprecated use ResizeInFrames using FFrameNumber instead")
    UFUNCTION(BlueprintCallable, Category = AnimationData, meta=(DeprecatedFunction, DeprecationMessage="Resize is deprecated use ResizeInFrames instead."))
    virtual void Resize(float Length, float T0, float T1, bool bShouldTransact = true) = 0;
    
    UFUNCTION(BlueprintCallable, Category = AnimationData)
    virtual void SetFrameRate(FFrameRate FrameRate, bool bShouldTransact = true) = 0;
 
    UE_DEPRECATED(5.2, "AddBoneTrack returning index is deprecated use AddBoneCurve returning bool instead.")
    UFUNCTION(BlueprintCallable, Category = AnimationData,  meta=(DeprecatedFunction, DeprecationMessage="AddBoneTrack returning index is deprecated use AddBoneCurve returning bool instead."))
    virtual int32 AddBoneTrack(FName BoneName, bool bShouldTransact = true) { AddBoneCurve(BoneName, bShouldTransact); return INDEX_NONE; }
 
    UFUNCTION(BlueprintCallable, Category = AnimationData)
    virtual bool AddBoneCurve(FName BoneName, bool bShouldTransact = true) = 0;
 
    UE_DEPRECATED(5.1, "InsertBoneTrack has been deprecated, use AddBoneTrack instead")
    UFUNCTION(BlueprintCallable, Category = AnimationData, meta=(DeprecatedFunction, DeprecationMessage="InsertBoneTrack is deprecated use AddBoneTrack instead."))
    virtual int32 InsertBoneTrack(FName BoneName, int32 DesiredIndex, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = AnimationData)
    virtual bool RemoveBoneTrack(FName BoneName, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = AnimationData)
    virtual void RemoveAllBoneTracks(bool bShouldTransact = true) = 0;
 
    virtual bool SetBoneTrackKeys(FName BoneName, const TArray<FVector3f>& PositionalKeys, const TArray<FQuat4f>& RotationalKeys, const TArray<FVector3f>& ScalingKeys, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = AnimationData)
    virtual bool SetBoneTrackKeys(FName BoneName, const TArray<FVector>& PositionalKeys, const TArray<FQuat>& RotationalKeys, const TArray<FVector>& ScalingKeys, bool bShouldTransact = true) = 0;
 
    virtual bool UpdateBoneTrackKeys(FName BoneName, const FInt32Range& KeyRangeToSet, const TArray<FVector3f>& PositionalKeys, const TArray<FQuat4f>& RotationalKeys, const TArray<FVector3f>& ScalingKeys, bool bShouldTransact = true) = 0;
 
    virtual bool UpdateBoneTrackKeys(FName BoneName, const FInt32Range& KeyRangeToSet, const TArray<FVector>& PositionalKeys, const TArray<FQuat>& RotationalKeys, const TArray<FVector>& ScalingKeys, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = CurveData)
    virtual bool AddCurve(const FAnimationCurveIdentifier& CurveId, int32 CurveFlags = 0x00000004, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = CurveData)
    virtual bool DuplicateCurve(const FAnimationCurveIdentifier& CopyCurveId, const FAnimationCurveIdentifier& NewCurveId, bool bShouldTransact = true) = 0;
    
 
    UFUNCTION(BlueprintCallable, Category = CurveData)
    virtual bool RemoveCurve(const FAnimationCurveIdentifier& CurveId, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = CurveData)
    virtual void RemoveAllCurvesOfType(ERawCurveTrackTypes SupportedCurveType, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = CurveData)
    virtual bool SetCurveFlag(const FAnimationCurveIdentifier& CurveId, EAnimAssetCurveFlags Flag, bool bState = true, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = CurveData)
    virtual bool SetCurveFlags(const FAnimationCurveIdentifier& CurveId, int32 Flags, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = CurveData)
    virtual bool SetTransformCurveKeys(const FAnimationCurveIdentifier& CurveId, const TArray<FTransform>& TransformValues, const TArray<float>& TimeKeys, bool bShouldTransact = true) = 0;
        
    UFUNCTION(BlueprintCallable, Category = CurveData)
    virtual bool SetTransformCurveKey(const FAnimationCurveIdentifier& CurveId, float Time, const FTransform& Value, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = CurveData)
    virtual bool RemoveTransformCurveKey(const FAnimationCurveIdentifier& CurveId, float Time, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = CurveData)
    virtual bool RenameCurve(const FAnimationCurveIdentifier& CurveToRenameId, const FAnimationCurveIdentifier& NewCurveId, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = CurveData)
    virtual bool SetCurveColor(const FAnimationCurveIdentifier& CurveId, FLinearColor Color, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = CurveData)
    virtual bool SetCurveComment(const FAnimationCurveIdentifier& CurveId, const FString& Comment, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = CurveData)
    virtual bool ScaleCurve(const FAnimationCurveIdentifier& CurveId, float Origin, float Factor, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = CurveData)
    virtual bool SetCurveKey(const FAnimationCurveIdentifier& CurveId, const FRichCurveKey& Key, bool bShouldTransact = true) = 0;
    
    UFUNCTION(BlueprintCallable, Category = CurveData)
    virtual bool RemoveCurveKey(const FAnimationCurveIdentifier& CurveId, float Time, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = CurveData)
    virtual bool SetCurveKeys(const FAnimationCurveIdentifier& CurveId, const TArray<FRichCurveKey>& CurveKeys, bool bShouldTransact = true) = 0;
 
    virtual bool SetCurveAttributes(const FAnimationCurveIdentifier& CurveId, const FCurveAttributes& Attributes, bool bShouldTransact = true) = 0;
 
    UE_DEPRECATED(5.3, "This function is no longer used.")
    UFUNCTION(BlueprintCallable, Category = CurveData, meta=(DeprecatedFunction, DeprecationMessage="This function is no longer used."))
    virtual void UpdateCurveNamesFromSkeleton(const USkeleton* Skeleton, ERawCurveTrackTypes SupportedCurveType, bool bShouldTransact = true) {}
 
    UE_DEPRECATED(5.3, "This function is no longer used.")
    UFUNCTION(BlueprintCallable, Category = CurveData, meta=(DeprecatedFunction, DeprecationMessage="This function is no longer used."))
    virtual void FindOrAddCurveNamesOnSkeleton(USkeleton* Skeleton, ERawCurveTrackTypes SupportedCurveType, bool bShouldTransact = true) {}
 
    virtual bool RemoveBoneTracksMissingFromSkeleton(const USkeleton* Skeleton, bool bShouldTransact = true) = 0;
 
    virtual void UpdateAttributesFromSkeleton(const USkeleton* Skeleton, bool bShouldTransact = true) = 0;
 
    virtual void NotifyPopulated() = 0; 
 
    virtual void ResetModel(bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = AttributeData)
    virtual bool AddAttribute(const FAnimationAttributeIdentifier& AttributeIdentifier, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = AttributeData)
    virtual bool RemoveAttribute(const FAnimationAttributeIdentifier& AttributeIdentifier, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = AttributeData)
    virtual int32 RemoveAllAttributesForBone(const FName& BoneName, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = AttributeData)
    virtual int32 RemoveAllAttributes(bool bShouldTransact = true) = 0; 
 
    template<typename AttributeType>
    bool SetTypedAttributeKey(const FAnimationAttributeIdentifier& AttributeIdentifier, float Time, const AttributeType& KeyValue, bool bShouldTransact = true)
    {
        return SetAttributeKey(AttributeIdentifier, Time, static_cast<const void*>(&KeyValue), AttributeType::StaticStruct(), bShouldTransact);
    }
 
    virtual bool SetAttributeKey(const FAnimationAttributeIdentifier& AttributeIdentifier, float Time, const void* KeyValue, const UScriptStruct* TypeStruct, bool bShouldTransact = true) = 0;
    
    virtual bool SetAttributeKeys(const FAnimationAttributeIdentifier& AttributeIdentifier, TArrayView<const float> Times, TArrayView<const void*> KeyValues, const UScriptStruct* TypeStruct, bool bShouldTransact = true) = 0;
 
    template<typename AttributeType>
    bool SetTypedAttributeKeys(const FAnimationAttributeIdentifier& AttributeIdentifier, TArrayView<const float> Times, TArrayView<const AttributeType> KeyValues, bool bShouldTransact = true)
    {
        TArray<const void*> KeyValuePtrs;
        Algo::Transform(KeyValues, KeyValuePtrs, [](const AttributeType& Value)
        {
            return static_cast<const void*>(&Value);
        });
 
        return SetAttributeKeys(AttributeIdentifier, Times, MakeArrayView(KeyValuePtrs), AttributeType::StaticStruct(), bShouldTransact);
    }
 
    UFUNCTION(BlueprintCallable, Category = AttributeData)
    virtual bool RemoveAttributeKey(const FAnimationAttributeIdentifier& AttributeIdentifier, float Time, bool bShouldTransact = true) = 0;
 
    UFUNCTION(BlueprintCallable, Category = AttributeData)
    virtual bool DuplicateAttribute(const FAnimationAttributeIdentifier& AttributeIdentifier, const FAnimationAttributeIdentifier& NewAttributeIdentifier, bool bShouldTransact = true) = 0;
 
    virtual void UpdateWithSkeleton(USkeleton* TargetSkeleton, bool bShouldTransact = true) = 0;
 
    virtual void PopulateWithExistingModel(TScriptInterface<IAnimationDataModel> InModel) = 0;
 
    virtual void InitializeModel() = 0;
 
    FFrameNumber ConvertSecondsToFrameNumber(double Seconds) const
    {
        ValidateModel();
        
        const FFrameRate& ModelFrameRate = GetModel()->GetFrameRate();
        
        static const FNumberFormattingOptions DurationFormatOptions = FNumberFormattingOptions()
            .SetMinimumFractionalDigits(8)
            .SetMaximumFractionalDigits(8);
    
        const FFrameTime FrameTime = ModelFrameRate.AsFrameTime(Seconds);
        // Check for either small sub-frame value or near zero seconds representation (of sub-frame only)
        if (!FMath::IsNearlyZero(FrameTime.GetSubFrame(), UE_KINDA_SMALL_NUMBER) &&
            !FMath::IsNearlyZero(ModelFrameRate.AsSeconds(FFrameTime(0, FrameTime.GetSubFrame())), UE_DOUBLE_KINDA_SMALL_NUMBER))
        {
            ReportWarningf(LOCTEXT("SecondsToFrameNumberPrecisionWarning", "Insufficient precision while converting seconds to frames: {0} seconds {1} frames using {2} (sub-frame in seconds {3})"), FText::AsNumber(Seconds), FText::AsNumber(FrameTime.AsDecimal(), &DurationFormatOptions), ModelFrameRate.ToPrettyText(), FText::AsNumber(ModelFrameRate.AsSeconds(FFrameTime(0, FrameTime.GetSubFrame())), &DurationFormatOptions));
        }
 
        return FrameTime.GetFrame();
    }   
protected:
    virtual void NotifyBracketOpen() = 0;
    virtual void NotifyBracketClosed() = 0;
 
    template <typename FmtType, typename... Types>
    void ReportWarningf(const FmtType& Fmt, Types... Args) const
    {
        ReportWarning(FText::Format(Fmt, Args...));
    }
 
    template <typename FmtType, typename... Types>
    void ReportErrorf(const FmtType& Fmt, Types... Args) const
    {
        ReportError(FText::Format(Fmt, Args...));
    }
 
    void Report(ELogVerbosity::Type Verbosity, const FText& Message) const
    {
        ReportMessage(GetModelInterface().GetObject(), Message, Verbosity);
    }
 
    template <typename FmtType, typename... Types>
    void Reportf(ELogVerbosity::Type Verbosity, const FmtType& Fmt, Types... Args) const
    {
        ReportMessage(GetModelInterface().GetObject(), FText::Format(Fmt, Args...), Verbosity);
    }
 
    void ReportWarning(const FText& Message) const
    {
        ReportMessage(GetModelInterface().GetObject(), Message, ELogVerbosity::Warning);
    }
    
    void ReportError(const FText& Message) const
    {
        ReportMessage(GetModelInterface().GetObject(), Message, ELogVerbosity::Error);
    }
 
    static bool IsSupportedCurveType(ERawCurveTrackTypes CurveType)
    {
        const TArray<ERawCurveTrackTypes> SupportedTypes = { ERawCurveTrackTypes::RCT_Float, ERawCurveTrackTypes::RCT_Transform };
        return SupportedTypes.Contains(CurveType);
    }
 
    void ValidateModel() const
    {
        checkf(GetModel() != nullptr, TEXT("Invalid Model"));
    }
        
    bool CheckOuterClass(UClass* InClass) const
    {
        ValidateModel();
    
        if (const UObject* ModelOuter = GetModelInterface().GetObject()->GetOuter())
        {
            if (const UClass* OuterClass = ModelOuter->GetClass())
            {
                if (OuterClass == InClass || OuterClass->IsChildOf(InClass))
                {
                    return true;
                }
                else
                {
                    ReportErrorf(NSLOCTEXT("IAnimationDataController", "NoValidOuterClassError", "Incorrect outer object class found for Animation Data Model {0}, expected {1} actual {2}"), FText::FromString(GetModelInterface().GetObject()->GetName()), FText::FromString(InClass->GetName()), FText::FromString(OuterClass->GetName()));
                }
            }
        }
        else
        {
            ReportErrorf(NSLOCTEXT("IAnimationDataController", "NoValidOuterObjectFoundError", "No valid outer object found for Animation Data Model {0}"), FText::FromString(GetModelInterface().GetObject()->GetName()));
        }
 
        return false;
    }
    
    static FString GetCurveTypeValueName(ERawCurveTrackTypes InType)
    {
        FString ValueString;
        if (const UEnum* Enum = FindObject<UEnum>(nullptr, TEXT("/Script/Engine.ERawCurveTrackTypes")))
        {
            ValueString = Enum->GetNameStringByValue(static_cast<int64>(InType));
        }
 
        return ValueString;
    }
    
    static constexpr int32 DefaultCurveFlags = EAnimAssetCurveFlags::AACF_Editable;
 
#if WITH_EDITOR
    typedef TUniquePtr<UE::FScopedCompoundTransaction> FTransaction;
    FTransaction ConditionalTransaction(const FText& Description, bool bCondition)
    {
        if (UE::FChangeTransactor::CanTransactChanges() && bCondition)
        { 
            return MakeUnique<UE::FScopedCompoundTransaction>(ChangeTransactor, Description);
        }
 
        return nullptr;
    }
 
    typedef TUniquePtr<IAnimationDataController::FScopedBracket> FBracket; 
    FBracket ConditionalBracket(const FText& Description, bool bCondition)
    {   
        return MakeUnique<IAnimationDataController::FScopedBracket>(this, Description, UE::FChangeTransactor::CanTransactChanges() && bCondition);  
    }
 
    template<typename ActionClass, class... ActionArguments>
    void ConditionalAction(bool bCondition, ActionArguments&&... Arguments)
    {
        if (UE::FChangeTransactor::CanTransactChanges() && bCondition) \
        { 
            ChangeTransactor.AddTransactionChange<ActionClass>(Forward<ActionArguments>(Arguments)...); \
        }
    }
protected:
    UE::FChangeTransactor ChangeTransactor;
#endif // WITH_EDITOR
 
public:
    template <typename FmtType, typename... Types>
    static void ReportObjectWarningf(const UObject* ErrorObject, const FmtType& Fmt, Types... Args)
    {
        ReportMessage(ErrorObject, FText::Format(Fmt, Args...), ELogVerbosity::Warning);
    }
 
    template <typename FmtType, typename... Types>
    static void ReportObjectErrorf(const UObject* ErrorObject, const FmtType& Fmt, Types... Args)
    {
        ReportMessage(ErrorObject, FText::Format(Fmt, Args...), ELogVerbosity::Error);
    }
    
    template <typename FmtType, typename... Types>
    static void Reportf(ELogVerbosity::Type LogVerbosity, const UObject* ErrorObject, const FmtType& Fmt, Types... Args)
    {
        ReportMessage(ErrorObject, FText::Format(Fmt, Args...), ELogVerbosity::Error);
    }
 
    static ENGINE_API void ReportMessage(const UObject* ErrorObject, const FText& InMessage, ELogVerbosity::Type LogVerbosity); 
private:
    friend class FAnimDataControllerTestBase;
    friend UE::Anim::FOpenBracketAction;
    friend UE::Anim::FCloseBracketAction;
};
 
#define CONDITIONAL_TRANSACTION(Text) FTransaction Transaction = ConditionalTransaction(Test, bShouldTransact);
#define CONDITIONAL_BRACKET(Text) FBracket Bracket = ConditionalBracket(Text, bShouldTransact);
#define CONDITIONAL_ACTION(ActionClass, ...) ConditionalAction<ActionClass>(bShouldTransact, __VA_ARGS__);
 
#undef LOCTEXT_NAMESPACE // "IAnimationDataController"