AnimCompositeBase.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/AnimSequenceBase.h"
#include "HAL/IConsoleManager.h"
#include "AnimCompositeBase.generated.h"
 
class UAnimCompositeBase;
class UAnimSequence;
struct FCompactPose;
 
#if WITH_EDITOR
namespace UE { namespace Anim
{
    extern TAutoConsoleVariable<bool> CVarOutputMontageFrameRateWarning;
}}
 
#endif // WITH_EDITOR
 
USTRUCT()
struct FRootMotionExtractionStep
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    TObjectPtr<UAnimSequence> AnimSequence;
 
    UPROPERTY()
    float StartPosition;
 
    UPROPERTY()
    float EndPosition;
 
    FRootMotionExtractionStep() 
        : AnimSequence(nullptr)
        , StartPosition(0.f)
        , EndPosition(0.f)
        {
        }
 
    FRootMotionExtractionStep(UAnimSequence * InAnimSequence, float InStartPosition, float InEndPosition) 
        : AnimSequence(InAnimSequence)
        , StartPosition(InStartPosition)
        , EndPosition(InEndPosition)
    {
    }
};
 
USTRUCT()
struct FAnimSegment
{
    GENERATED_USTRUCT_BODY()
 
    FAnimSegment(const FAnimSegment&) = default;
    FAnimSegment(FAnimSegment&&) = default;
    FAnimSegment& operator=(const FAnimSegment&) = default;
    FAnimSegment& operator=(FAnimSegment&&) = default;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, Category=AnimSegment, meta=(DisplayName = "Cached Animation Asset length"))
    float CachedPlayLength = 0.f;
#endif
 
#if WITH_EDITOR
    friend class UEditorAnimSegment;
    friend class UEditorAnimCompositeSegment;
    ENGINE_API void UpdateCachedPlayLength();
#endif // WITH_EDITOR
 
protected:
    UPROPERTY(EditAnywhere, Category=AnimSegment, meta=(DisplayName = "Animation Reference"))
    TObjectPtr<UAnimSequenceBase> AnimReference;
public:
 
    ENGINE_API void SetAnimReference(UAnimSequenceBase* InAnimReference, bool bInitialize = false);
    const TObjectPtr<UAnimSequenceBase>& GetAnimReference() const 
    {
        return AnimReference;
    }
 
#if WITH_EDITOR
    ENGINE_API bool IsPlayLengthOutOfDate() const;
#endif // WITH_EDITOR
    
    UPROPERTY(VisibleAnywhere, Category=AnimSegment, meta=(DisplayName = "Starting Position"))
    float StartPos;
 
    UPROPERTY(EditAnywhere, Category=AnimSegment, meta=(DisplayName = "Start Time"))
    float AnimStartTime;
 
    UPROPERTY(EditAnywhere, Category=AnimSegment, meta=(DisplayName = "End Time"))
    float AnimEndTime;
 
    UPROPERTY(EditAnywhere, Category=AnimSegment, meta=(DisplayName = "Play Rate"))
    float AnimPlayRate;
 
    UPROPERTY(EditAnywhere, Category=AnimSegment, meta=(DisplayName = "Loop Count"))
    int32 LoopingCount;
 
    FAnimSegment()
        : AnimReference(nullptr)
        , StartPos(0.f)
        , AnimStartTime(0.f)
        , AnimEndTime(0.f)
        , AnimPlayRate(1.f)
        , LoopingCount(1)
        , bValid(true)
    {
    }
 
    float GetValidPlayRate() const
    {
        float SeqPlayRate = AnimReference ? AnimReference->RateScale : 1.0f;
        float FinalPlayRate = SeqPlayRate * AnimPlayRate;
        return (FMath::IsNearlyZero(FinalPlayRate) ? 1.f : FinalPlayRate);
    }
 
    float GetLength() const
    {
        return (float(LoopingCount) * (AnimEndTime - AnimStartTime)) / FMath::Abs(GetValidPlayRate());
    }
 
    float GetEndPos() const
    {
        return StartPos + GetLength();
    }
 
    bool IsInRange(float CurPos) const
    {
        return ((CurPos >= StartPos) && (CurPos <= GetEndPos()));
    }
 
    /*
     * Return true if it's included within the input range
     */
    bool IsIncluded(float InStartPos, float InEndPos) const
    {
        float EndPos = StartPos + GetLength(); 
        // InStartPos is between Start and End, it is included
        if (StartPos <= InStartPos && EndPos > InStartPos)
        {
            return true;
        }
        // InEndPos is between Start and End, it is also included
        if (StartPos < InEndPos && EndPos >= InEndPos)
        {
            return true;
        }
        // if it is within Start and End, it is also included
        if (StartPos >= InStartPos && EndPos <= InEndPos)
        {
            return true;
        }
 
        return false;
    }
    ENGINE_API UAnimSequenceBase* GetAnimationData(float PositionInTrack, float& PositionInAnim) const;
 
    ENGINE_API float ConvertTrackPosToAnimPos(const float& TrackPosition) const;
    
    ENGINE_API void GetAnimNotifiesFromTrackPositions(const float& PreviousTrackPosition, const float& CurrentTrackPosition, FAnimNotifyContext& NotifyContext) const;
 
    void GetRootMotionExtractionStepsForTrackRange(TArray<FRootMotionExtractionStep> & RootMotionExtractionSteps, const float StartPosition, const float EndPosition) const;
 
    bool IsValid() const { return bValid;  }
 
    bool IsNotifyAvailable() const { return IsValid() && AnimReference && AnimReference->IsNotifyAvailable(); }
private:
 
    bool bValid;
 
    friend struct FAnimTrack;
};
 
USTRUCT()
struct FAnimTrack
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(EditAnywhere, Category=AnimTrack, EditFixedSize)
    TArray<FAnimSegment>    AnimSegments;
 
    FAnimTrack() {}
    ENGINE_API float GetLength() const;
    ENGINE_API bool IsAdditive() const;
    bool IsRotationOffsetAdditive() const;
 
    ENGINE_API int32 GetTrackAdditiveType() const;
 
    bool HasRootMotion() const;
 
    ENGINE_API void GetRootMotionExtractionStepsForTrackRange(TArray<FRootMotionExtractionStep> & RootMotionExtractionSteps, const float StartTrackPosition, const float EndTrackPosition) const;
 
    void ValidateSegmentTimes();
 
    ENGINE_API bool IsValidToAdd(const UAnimSequenceBase* SequenceBase, FText* OutReason = nullptr) const;
 
    ENGINE_API int32 GetSegmentIndexAtTime(float InTime) const;
 
    ENGINE_API FAnimSegment* GetSegmentAtTime(float InTime);
    ENGINE_API const FAnimSegment* GetSegmentAtTime(float InTime) const;
 
    ENGINE_API void GetAnimationPose(FAnimationPoseData& OutAnimationPoseData, const FAnimExtractContext& ExtractionContext) const;
 
    void EnableRootMotionSettingFromMontage(bool bInEnableRootMotion, const ERootMotionRootLock::Type InRootMotionRootLock);
 
#if WITH_EDITOR
    bool GetAllAnimationSequencesReferred(TArray<UAnimationAsset*>& AnimationAssets, bool bRecursive) const;
    void ReplaceReferredAnimations(const TMap<UAnimationAsset*, UAnimationAsset*>& ReplacementMap);
 
    ENGINE_API void CollapseAnimSegments();
 
    ENGINE_API void SortAnimSegments();
 
    class UAnimSequence* GetAdditiveBasePose() const;
#endif
 
    // this is to prevent anybody adding recursive asset to anim composite
    // as a result of anim composite being a part of anim sequence base
    void InvalidateRecursiveAsset(class UAnimCompositeBase* CheckAsset);
 
    // this is recursive function that look thorough internal assets 
    // and clear the reference if recursive is found. 
    // We're going to remove the top reference if found
    bool ContainRecursive(const TArray<UAnimCompositeBase*>& CurrentAccumulatedList);
 
    ENGINE_API void GetAnimNotifiesFromTrackPositions(const float& PreviousTrackPosition, const float& CurrentTrackPosition, FAnimNotifyContext& NotifyContext) const;
 
    bool IsNotifyAvailable() const;
 
    ENGINE_API int32 GetTotalBytesUsed() const;
};
 
UCLASS(abstract, MinimalAPI)
class UAnimCompositeBase : public UAnimSequenceBase
{
    GENERATED_UCLASS_BODY()
 
    //~ Begin UObject Interface
    virtual void PostLoad() override;
    //~ End UObject Interface
    
    //~ Begin UAnimSequenceBase Interface
    virtual FFrameRate GetSamplingFrameRate() const override;
    //~ End UAnimSequenceBase Interface
 
    // Extracts root motion from the supplied FAnimTrack between the Start End range specified
    UE_DEPRECATED(5.6, "Use static ExtractRootMotionFromTrack with FAnimExtractionContext")
    void ExtractRootMotionFromTrack(const FAnimTrack &SlotAnimTrack, float StartTrackPosition, float EndTrackPosition, FRootMotionMovementParams &RootMotion) const { FAnimExtractContext Context; ExtractRootMotionFromTrack(SlotAnimTrack, StartTrackPosition, EndTrackPosition, Context, RootMotion); }
    
    ENGINE_API void ExtractRootMotionFromTrack(const FAnimTrack &SlotAnimTrack, float StartTrackPosition, float EndTrackPosition, const FAnimExtractContext& Context, FRootMotionMovementParams& RootMotion) const;
 
    // this is to prevent anybody adding recursive asset to anim composite
    // as a result of anim composite being a part of anim sequence base
    virtual void InvalidateRecursiveAsset() PURE_VIRTUAL(UAnimCompositeBase::InvalidateRecursiveAsset, );
 
    // this is recursive function that look thorough internal assets 
    // and clear the reference if recursive is found. 
    // We're going to remove the top reference if found
    virtual bool ContainRecursive(TArray<UAnimCompositeBase*>& CurrentAccumulatedList) PURE_VIRTUAL(UAnimCompositeBase::ContainRecursive, return false; );
 
    virtual void SetCompositeLength(float InLength) PURE_VIRTUAL(UAnimCompositeBase::SetCompositeLength, );
 
#if WITH_EDITOR
    virtual void PopulateWithExistingModel(TScriptInterface<IAnimationDataModel> ExistingDataModel) override;
 
    virtual void UpdateCommonTargetFrameRate() PURE_VIRTUAL(UAnimCompositeBase::UpdateCommonTargetFrameRate, ); 
#endif // WITH_EDITOR
    FFrameRate GetCommonTargetFrameRate() const { return CommonTargetFrameRate; }
protected:
    UPROPERTY(VisibleAnywhere, Category = AnimationComposite)
    FFrameRate CommonTargetFrameRate;
};