AnimSequenceBase.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 "Animation/AnimTypes.h"
#include "Animation/AnimationAsset.h"
#include "Animation/AnimCurveTypes.h"
#include "Animation/AnimNotifyQueue.h"
#include "Animation/AnimData/AnimDataModelNotifyCollector.h"
#include "Animation/AnimData/IAnimationDataController.h"
 
#include "AnimSequenceBase.generated.h"
 
UENUM()
enum ETypeAdvanceAnim : int
{
    ETAA_Default,
    ETAA_Finished,
    ETAA_Looped
};
 
struct FAnimationPoseData;
struct FAnimDataModelNotifPayload;
class UAnimDataModel;
class IAnimationDataModel;
enum class EAnimDataModelNotifyType : uint8;
 
UCLASS(abstract, BlueprintType, MinimalAPI)
class UAnimSequenceBase : public UAnimationAsset
{
    GENERATED_UCLASS_BODY()
 
public:
    UPROPERTY()
    TArray<struct FAnimNotifyEvent> Notifies;
 
protected:
    UE_DEPRECATED(5.0, "Public access to SequenceLength is deprecated, use GetPlayLength or UAnimDataController::SetPlayLength instead")
    UPROPERTY(Category=Length, AssetRegistrySearchable, VisibleAnywhere, BlueprintReadOnly)
    float SequenceLength;
 
    UE_DEPRECATED(5.0, "Public access to RawCurveData is deprecated, see UAnimDataModel for source data or use GetCurveData for runtime instead")
    UPROPERTY()
    struct FRawCurveTracks RawCurveData;
    
public:
    UPROPERTY(EditAnywhere, Category=Animation)
    float RateScale;
    
    UPROPERTY(EditAnywhere, Category=Animation)
    bool bLoop;
#if WITH_EDITORONLY_DATA
    // if you change Notifies array, this will need to be rebuilt
    UPROPERTY()
    TArray<FAnimNotifyTrack> AnimNotifyTracks;
#endif // WITH_EDITORONLY_DATA
 
    //~ Begin UObject Interface
    ENGINE_API virtual void PostLoad() override;
    ENGINE_API virtual bool IsPostLoadThreadSafe() const override;
    ENGINE_API virtual void PostDuplicate(EDuplicateMode::Type DuplicateMode) override;
#if WITH_EDITORONLY_DATA
    static ENGINE_API void DeclareConstructClasses(TArray<FTopLevelAssetPath>& OutConstructClasses, const UClass* SpecificSubclass);
#endif
    ENGINE_API virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
    //~ End UObject Interface
 
    ENGINE_API virtual float GetPlayLength() const override;
 
    ENGINE_API void SortNotifies(); 
 
    ENGINE_API bool RemoveNotifies(const TArray<FName>& NotifiesToRemove);
    
    ENGINE_API void RemoveNotifies();
 
#if WITH_EDITOR
    ENGINE_API void RenameNotifies(FName InOldName, FName InNewName);
#endif
    
    ENGINE_API void GetAnimNotifies(const float& StartTime, const float& DeltaTime, FAnimNotifyContext& NotifyContext) const;
 
    ENGINE_API virtual void GetAnimNotifiesFromDeltaPositions(const float& PreviousPosition, const float & CurrentPosition, FAnimNotifyContext& NotifyContext) const;
 
    UE_DEPRECATED(5.6, "Please use EvaluateCurveData with FAnimExtractContext")
    virtual void EvaluateCurveData(FBlendedCurve& OutCurve, float CurrentTime, bool bForceUseRawData = false) const { const FAnimExtractContext Context(static_cast<double>(CurrentTime)); EvaluateCurveData(OutCurve, Context, bForceUseRawData); }
    ENGINE_API virtual void EvaluateCurveData(FBlendedCurve& OutCurve, const FAnimExtractContext& AnimExtractContext, bool bForceUseRawData = false) const;
    
    UE_DEPRECATED(5.6, "Please use EvaluateCurveData with FAnimExtractContext")
    virtual float EvaluateCurveData(FName CurveName, float CurrentTime, bool bForceUseRawData = false) const { const FAnimExtractContext Context(static_cast<double>(CurrentTime)); return EvaluateCurveData(CurveName, Context, bForceUseRawData); }
    ENGINE_API virtual float EvaluateCurveData(FName CurveName, const FAnimExtractContext& AnimExtractContext, bool bForceUseRawData = false) const;
    
    ENGINE_API virtual const FRawCurveTracks& GetCurveData() const;
        
    ENGINE_API virtual bool HasCurveData(FName CurveName, bool bForceUseRawData = false) const;
 
    ENGINE_API virtual int32 GetNumberOfSampledKeys() const;
 
    ENGINE_API virtual FFrameRate GetSamplingFrameRate() const;
 
    ENGINE_API virtual float GetTimeAtFrame(const int32 Frame) const;
 
#if WITH_EDITOR
    ENGINE_API virtual int32 GetFrameAtTime(const float Time) const;
 
    // @todo document
    ENGINE_API void InitializeNotifyTrack();
 
    ENGINE_API void ClampNotifiesAtEndOfSequence();
 
    ENGINE_API virtual EAnimEventTriggerOffsets::Type CalculateOffsetForNotify(float NotifyDisplayTime) const;
 
    ENGINE_API virtual void GetAssetRegistryTags(FAssetRegistryTagsContext Context) const override;
    UE_DEPRECATED(5.4, "Implement the version that takes FAssetRegistryTagsContext instead.")
    ENGINE_API virtual void GetAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const override;
 
    // Get a pointer to the data for a given Anim Notify
    ENGINE_API uint8* FindNotifyPropertyData(int32 NotifyIndex, FArrayProperty*& ArrayProperty);
 
    // Get a pointer to the data for a given array property item
    ENGINE_API uint8* FindArrayProperty(const TCHAR* PropName, FArrayProperty*& ArrayProperty, int32 ArrayIndex);
 
protected:
    ENGINE_API virtual void RefreshParentAssetData() override;
#endif  //WITH_EDITORONLY_DATA
public: 
    // update cache data (notify tracks, sync markers)
    ENGINE_API virtual void RefreshCacheData();
 
    //~ Begin UAnimationAsset Interface
    ENGINE_API virtual void TickAssetPlayer(FAnimTickRecord& Instance, struct FAnimNotifyQueue& NotifyQueue, FAnimAssetTickContext& Context) const override;
    //~ End UAnimationAsset Interface
    
    ENGINE_API void TickByMarkerAsFollower(FMarkerTickRecord &Instance, FMarkerTickContext &MarkerContext, float& CurrentTime, float& OutPreviousTime, const float MoveDelta, const bool bLooping, const UMirrorDataTable* MirrorTable = nullptr) const;
    ENGINE_API void TickByMarkerAsLeader(FMarkerTickRecord& Instance, FMarkerTickContext& MarkerContext, float& CurrentTime, float& OutPreviousTime, const float MoveDelta, const bool bLooping, const UMirrorDataTable* MirrorTable = nullptr) const;
 
    virtual void GetAnimationPose(FAnimationPoseData& OutPoseData, const FAnimExtractContext& ExtractionContext) const
        PURE_VIRTUAL(UAnimSequenceBase::GetAnimationPose, );
    
    ENGINE_API virtual void HandleAssetPlayerTickedInternal(FAnimAssetTickContext &Context, const float PreviousTime, const float MoveDelta, const FAnimTickRecord &Instance, struct FAnimNotifyQueue& NotifyQueue) const;
 
    virtual bool HasRootMotion() const { return false; }
 
    UE_DEPRECATED(5.6, "Please use ExtractRootMotion with FAnimExtractContext")
    virtual FTransform ExtractRootMotion(float StartTime, float DeltaTime, bool bAllowLooping) const { const FAnimExtractContext Context(static_cast<double>(StartTime), true, FDeltaTimeRecord(DeltaTime), bAllowLooping); return ExtractRootMotion(Context); }
 
    // Extract Root Motion transform from the animation
    virtual FTransform ExtractRootMotion(const FAnimExtractContext& ExtractionContext) const { return {}; }
 
    UE_DEPRECATED(5.6, "Please use ExtractRootMotionFromRange with FAnimExtractContext")
    virtual FTransform ExtractRootMotionFromRange(float StartTrackPosition, float EndTrackPosition) const { const FAnimExtractContext Context; return ExtractRootMotionFromRange(StartTrackPosition, EndTrackPosition, Context); }
 
    // Extract Root Motion transform from a contiguous position range (no looping)
    virtual FTransform ExtractRootMotionFromRange(double StartTime, double EndTime, const FAnimExtractContext& ExtractionContext) const { return {}; }
 
    UE_DEPRECATED(5.6, "Please use ExtractRootTrackTransform with FAnimExtractContext")
    virtual FTransform ExtractRootTrackTransform(float Time, const FBoneContainer* RequiredBones) const { const FAnimExtractContext Context(static_cast<double>(Time)); return ExtractRootTrackTransform(Context, RequiredBones); }
 
    // Extract the transform from the root track for the given animation position
    virtual FTransform ExtractRootTrackTransform(const FAnimExtractContext& ExtractionContext, const FBoneContainer* RequiredBones) const { return {}; }
 
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
 
    virtual void AdvanceMarkerPhaseAsLeader(bool bLooping, float MoveDelta, const TArray<FName>& ValidMarkerNames, float& CurrentTime, FMarkerPair& PrevMarker, FMarkerPair& NextMarker, TArray<FPassedMarker>& MarkersPassed, const UMirrorDataTable* MirrorTable) const { check(false); /*Should never call this (either missing override or calling on unsupported asset */ }
 
    virtual void AdvanceMarkerPhaseAsFollower(const FMarkerTickContext& Context, float DeltaRemaining, bool bLooping, float& CurrentTime, FMarkerPair& PreviousMarker, FMarkerPair& NextMarker, const UMirrorDataTable* MirrorTable) const { check(false); /*Should never call this (either missing override or calling on unsupported asset */ }
    
    virtual void GetMarkerIndicesForTime(float CurrentTime, bool bLooping, const TArray<FName>& ValidMarkerNames, FMarkerPair& OutPrevMarker, FMarkerPair& OutNextMarker) const { check(false); /*Should never call this (either missing override or calling on unsupported asset */ }
 
    virtual FMarkerSyncAnimPosition GetMarkerSyncPositionFromMarkerIndicies(int32 PrevMarker, int32 NextMarker, float CurrentTime, const UMirrorDataTable* MirrorTable) const { check(false); return FMarkerSyncAnimPosition(); /*Should never call this (either missing override or calling on unsupported asset */ }
 
    virtual void GetMarkerIndicesForPosition(const FMarkerSyncAnimPosition& SyncPosition, bool bLooping, FMarkerPair& OutPrevMarker, FMarkerPair& OutNextMarker, float& CurrentTime, const UMirrorDataTable* MirrorTable ) const { check(false); /*Should never call this (either missing override or calling on unsupported asset */ }
    
    virtual float GetFirstMatchingPosFromMarkerSyncPos(const FMarkerSyncAnimPosition& InMarkerSyncGroupPosition) const { return 0.f; }
    virtual float GetNextMatchingPosFromMarkerSyncPos(const FMarkerSyncAnimPosition& InMarkerSyncGroupPosition, const float& StartingPosition) const { return 0.f; }
    virtual float GetPrevMatchingPosFromMarkerSyncPos(const FMarkerSyncAnimPosition& InMarkerSyncGroupPosition, const float& StartingPosition) const { return 0.f; }
 
    // default implementation, no additive
    virtual EAdditiveAnimationType GetAdditiveAnimType() const { return AAT_None; }
    virtual bool CanBeUsedInComposition() const { return true;  }
 
    // to support anim sequence base to montage
    virtual void EnableRootMotionSettingFromMontage(bool bInEnableRootMotion, const ERootMotionRootLock::Type InRootMotionRootLock) {};
    virtual bool GetEnableRootMotionSettingFromMontage() const { return false; }
 
#if WITH_EDITOR
private:
    DECLARE_MULTICAST_DELEGATE( FOnNotifyChangedMulticaster );
    FOnNotifyChangedMulticaster OnNotifyChanged;
 
public:
    typedef FOnNotifyChangedMulticaster::FDelegate FOnNotifyChanged;
 
    ENGINE_API void RegisterOnNotifyChanged(const FOnNotifyChanged& Delegate);
    ENGINE_API void UnregisterOnNotifyChanged(FDelegateUserObject Unregister);
    virtual bool IsValidToPlay() const { return true; }
    // ideally this would be animsequcnebase, but we might have some issue with that. For now, just allow AnimSequence
    virtual class UAnimSequence* GetAdditiveBasePose() const { return nullptr; }
#endif
 
    // return true if anim notify is available 
    ENGINE_API virtual bool IsNotifyAvailable() const;
 
#if WITH_EDITOR
    ENGINE_API void OnEndLoadPackage(const FEndLoadPackageContext& Context);
    ENGINE_API virtual void OnAnimModelLoaded();
public:
    ENGINE_API IAnimationDataModel* GetDataModel() const;
 
    ENGINE_API TScriptInterface<IAnimationDataModel> GetDataModelInterface() const;
 
    ENGINE_API IAnimationDataController& GetController();
protected:
    ENGINE_API virtual void PopulateModel();
    ENGINE_API virtual void PopulateWithExistingModel(TScriptInterface<IAnimationDataModel> ExistingDataModel);
 
    ENGINE_API virtual void OnModelModified(const EAnimDataModelNotifyType& NotifyType, IAnimationDataModel* Model, const FAnimDataModelNotifPayload& Payload);
 
    ENGINE_API void ValidateModel() const;
    
    ENGINE_API void BindToModelModificationEvent();
 
    ENGINE_API void CopyDataModel(const TScriptInterface<IAnimationDataModel>& ModelToDuplicate);
private:
    ENGINE_API void CreateModel();
 
public:
    ENGINE_API bool ShouldDataModelBeValid() const;
    bool IsDataModelValid() const
    {
        if(ShouldDataModelBeValid())
        {
            return DataModelInterface != nullptr;
        }
 
        return false;
    }   
#endif // WITH_EDITOR
 
#if WITH_EDITORONLY_DATA
protected:
    UE_DEPRECATED(5.1, "DataModel has been converted to DataModelInterface")
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Animation Model")
    TObjectPtr<UAnimDataModel> DataModel;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Animation Model")
    TScriptInterface<IAnimationDataModel> DataModelInterface;
 
    bool bPopulatingDataModel;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Transient, DuplicateTransient, Category = "Animation Model")
    TScriptInterface<IAnimationDataController> Controller;
    
    UE::Anim::FAnimDataModelNotifyCollector NotifyCollector;
#endif // WITH_EDITORONLY_DATA
 
};