MovieScenePlayback.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "CoreMinimal.h"
#include "Evaluation/MovieSceneSequenceTransform.h"
#include "Evaluation/MovieSceneTimeTransform.h"
#include "Evaluation/MovieSceneTimeWarping.h"
#include "HAL/Platform.h"
#include "HAL/PlatformCrt.h"
#include "Math/NumericLimits.h"
#include "Math/Range.h"
#include "Math/RangeBound.h"
#include "Misc/AssertionMacros.h"
#include "Misc/FrameNumber.h"
#include "Misc/FrameRate.h"
#include "Misc/FrameTime.h"
#include "Misc/Optional.h"
#include "MovieSceneFwd.h"
#include "MovieSceneTimeHelpers.h"
 
 
enum class EPlayDirection
{
    Forwards, Backwards
};
 
 
struct FMovieSceneEvaluationRange
{
    MOVIESCENE_API FMovieSceneEvaluationRange(FFrameTime InTime, FFrameRate InFrameRate);
 
    MOVIESCENE_API FMovieSceneEvaluationRange(TRange<FFrameTime> InRange, FFrameRate InFrameRate, EPlayDirection InDirection);
 
    MOVIESCENE_API FMovieSceneEvaluationRange(FFrameTime InCurrentTime, FFrameTime InPreviousTime, FFrameRate InFrameRate, bool bInclusivePreviousTime = false, EPlayDirection PreferredDirection = EPlayDirection::Forwards);
 
    static MOVIESCENE_API TRange<FFrameNumber> TimeRangeToNumberRange(const TRange<FFrameTime>& InFrameTimeRange);
 
    static MOVIESCENE_API TRange<FFrameTime> NumberRangeToTimeRange(const TRange<FFrameNumber>& InFrameTimeRange);
 
    inline TRange<FFrameTime> GetRange() const
    {
        return EvaluationRange;
    }
 
    inline TRange<FFrameNumber> GetFrameNumberRange() const
    {
        return TimeRangeToNumberRange(EvaluationRange);
    }
 
    MOVIESCENE_API TRange<FFrameNumber> GetTraversedFrameNumberRange() const;
 
    inline EPlayDirection GetDirection() const 
    {
        return Direction;
    }
 
    inline FFrameTime GetTime() const
    {
        if (TimeOverride != TNumericLimits<int32>::Lowest())
        {
            return TimeOverride;
        }
 
        return Direction == EPlayDirection::Forwards ? EvaluationRange.GetUpperBoundValue() : EvaluationRange.GetLowerBoundValue();
    }
 
    inline FFrameNumber GetEvaluationFieldTime() const
    {
        TRange<FFrameNumber> Range = GetFrameNumberRange();
 
        if (Direction == EPlayDirection::Forwards)
        {
            return UE::MovieScene::DiscreteExclusiveUpper(Range)-1;
        }
        else
        {
            return UE::MovieScene::DiscreteInclusiveLower(Range);
        }
    }
 
    inline FFrameTime GetDelta() const
    {
        return EvaluationRange.Size<FFrameTime>();
    }
 
    inline FFrameTime GetPreviousTime() const
    {
        return Direction == EPlayDirection::Forwards ? EvaluationRange.GetLowerBoundValue() : EvaluationRange.GetUpperBoundValue();
    }
 
    inline FFrameTime GetOffsetTime(FFrameTime InOffset) const
    {
        FFrameTime Now = GetTime();
        return Direction == EPlayDirection::Forwards ? Now + InOffset : Now - InOffset;
    }
 
    inline void OverrideTime(FFrameNumber InTimeOverride)
    {
        TimeOverride = InTimeOverride;
    }
 
    inline FFrameRate GetFrameRate() const
    {
        return CurrentFrameRate;
    }
 
    MOVIESCENE_API void ResetRange(const TRange<FFrameTime>& NewRange);
 
protected:
 
    TRange<FFrameTime> EvaluationRange;
 
    FFrameRate CurrentFrameRate;
 
    EPlayDirection Direction;
 
    FFrameNumber TimeOverride;
};
 
struct FMovieSceneContext : FMovieSceneEvaluationRange
{
    FMovieSceneContext()
        : FMovieSceneEvaluationRange(TRange<FFrameTime>::Empty(), FFrameRate(60, 1), EPlayDirection::Forwards)
        , Status(EMovieScenePlayerStatus::Stopped)
        , PrePostRollStartEndTime(TNumericLimits<int32>::Lowest())
        , HierarchicalBias(0)
        , bHasJumped(false)
        , bHasLooped(false)
        , bSilent(false)
        , bSectionPreRoll(false)
        , bSectionPostRoll(false)
        , bHasPreRollEndTime(false)
        , bHasPostRollStartTime(false)
    {}
 
    FMovieSceneContext(FMovieSceneEvaluationRange InRange)
        : FMovieSceneEvaluationRange(InRange)
        , Status(EMovieScenePlayerStatus::Stopped)
        , PrePostRollStartEndTime(TNumericLimits<int32>::Lowest())
        , HierarchicalBias(0)
        , bHasJumped(false)
        , bHasLooped(false)
        , bSilent(false)
        , bSectionPreRoll(false)
        , bSectionPostRoll(false)
        , bHasPreRollEndTime(false)
        , bHasPostRollStartTime(false)
    {}
 
    FMovieSceneContext(FMovieSceneEvaluationRange InRange, EMovieScenePlayerStatus::Type InStatus)
        : FMovieSceneEvaluationRange(InRange)
        , Status(InStatus)
        , PrePostRollStartEndTime(TNumericLimits<int32>::Lowest())
        , HierarchicalBias(0)
        , bHasJumped(false)
        , bHasLooped(false)
        , bSilent(false)
        , bSectionPreRoll(false)
        , bSectionPostRoll(false)
        , bHasPreRollEndTime(false)
        , bHasPostRollStartTime(false)
    {}
 
    inline EMovieScenePlayerStatus::Type GetStatus() const
    {
        return Status;
    }
 
    inline bool HasJumped() const
    {
        return bHasJumped;
    }
 
    inline bool HasLooped() const
    {
        return bHasLooped;
    }
 
    inline bool IsSilent() const
    {
        return bSilent;
    }
 
    inline const FMovieSceneSequenceTransform& GetRootToSequenceTransform() const
    {
        return RootToSequenceTransform;
    }
 
    inline const FMovieSceneWarpCounter& GetRootToSequenceWarpCounter() const
    {
        return RootToSequenceWarpCounter;
    }
 
    UE_DEPRECATED(5.4, "Please use GetSequenceToRootSequenceTransform instead.")
    MOVIESCENE_API FMovieSceneTimeTransform GetSequenceToRootTransform() const;
 
    MOVIESCENE_API FMovieSceneInverseSequenceTransform GetSequenceToRootSequenceTransform() const;
 
    inline void ApplySectionPrePostRoll(bool bInLeadingRegion, bool bInTrailingRegion)
    {
        if (Direction == EPlayDirection::Forwards)
        {
            bSectionPreRoll = bInLeadingRegion;
            bSectionPostRoll = bInTrailingRegion;
        }
        else
        {
            bSectionPreRoll = bInTrailingRegion;
            bSectionPostRoll = bInLeadingRegion;
        }
    }
 
public:
 
    FMovieSceneContext& SetHasJumped(bool bInHasJumped)
    {
        bHasJumped = bInHasJumped;
        return *this;
    }
 
    FMovieSceneContext& SetHasLooped(bool bInHasLooped)
    {
        bHasLooped = bInHasLooped;
        return *this;
    }
 
    FMovieSceneContext& SetIsSilent(bool bInIsSilent)
    {
        bSilent = bInIsSilent;
        return *this;
    }
 
    FMovieSceneContext Clamp(TRange<FFrameTime> NewRange) const
    {
        FMovieSceneContext NewContext = *this;
        NewContext.EvaluationRange = TRange<FFrameTime>::Intersection(NewRange, NewContext.EvaluationRange);
        return NewContext;
    }
 
    MOVIESCENE_API FMovieSceneContext Transform(const FMovieSceneSequenceTransform& InTransform, FFrameRate NewFrameRate) const;
 
    void SetHierarchicalBias(int32 InHierarchicalBias)
    {
        HierarchicalBias = InHierarchicalBias;
    }
 
    int32 GetHierarchicalBias() const
    {
        return HierarchicalBias;
    }
 
public:
 
    bool IsPreRoll() const
    {
        return bHasPreRollEndTime || bSectionPreRoll;
    }
 
    bool IsPostRoll() const
    {
        return bHasPostRollStartTime || bSectionPostRoll;
    }
 
    bool HasPreRollEndTime() const
    {
        return bHasPreRollEndTime;
    }
 
    bool HasPostRollStartTime() const
    {
        return bHasPostRollStartTime;
    }
 
    FFrameNumber GetPreRollEndFrame() const
    {
        checkf(bHasPreRollEndTime, TEXT("It's invalid to call GetPreRollEndFrame() without first checking HasPreRollEndTime()"));
        return PrePostRollStartEndTime;
    }
 
    FFrameNumber GetPostRollStartFrame() const
    {
        checkf(bHasPostRollStartTime, TEXT("It's invalid to call GetPostRollStartFrame() without first checking HasPostRollStartTime()"));
        return PrePostRollStartEndTime;
    }
 
    void ReportOuterSectionRanges(TRange<FFrameNumber> InLeadingRange, TRange<FFrameNumber> InTrailingRange)
    {
        const FFrameNumber Now = GetTime().FrameNumber;
        if (InLeadingRange.Contains(Now) && InLeadingRange.HasUpperBound())
        {
            PrePostRollStartEndTime = InLeadingRange.GetUpperBoundValue();
 
            bHasPreRollEndTime = Direction == EPlayDirection::Forwards;
            bHasPostRollStartTime = !bHasPreRollEndTime;
        }
        else if (InTrailingRange.Contains(Now) && InTrailingRange.HasLowerBound())
        {
            PrePostRollStartEndTime = InTrailingRange.GetLowerBoundValue();
 
            bHasPreRollEndTime = Direction == EPlayDirection::Backwards;
            bHasPostRollStartTime = !bHasPreRollEndTime;
        }
        else
        {
            bHasPreRollEndTime = bHasPostRollStartTime = false;
            PrePostRollStartEndTime = FFrameNumber(TNumericLimits<int32>::Lowest());
        }
    }
 
protected:
 
    FMovieSceneSequenceTransform RootToSequenceTransform;
 
    FMovieSceneWarpCounter RootToSequenceWarpCounter;
 
    EMovieScenePlayerStatus::Type Status;
 
    FFrameNumber PrePostRollStartEndTime;
 
    int32 HierarchicalBias;
 
protected:
 
    bool bHasJumped : 1;
 
    bool bHasLooped : 1;
 
    bool bSilent : 1;
 
    bool bSectionPreRoll : 1;
 
    bool bSectionPostRoll : 1;
 
    bool bHasPreRollEndTime : 1;
 
    bool bHasPostRollStartTime : 1;
};
 
struct FMovieScenePlaybackPosition
{
    FMovieScenePlaybackPosition()
        : InputRate(0,0), OutputRate(0,0), EvaluationType(EMovieSceneEvaluationType::WithSubFrames)
    {}
 
    inline EMovieSceneEvaluationType GetEvaluationType() const
    {
        return EvaluationType;
    }
 
    inline FFrameRate GetInputRate() const
    {
        return InputRate;
    }
 
    inline FFrameRate GetOutputRate() const
    {
        return OutputRate;
    }
 
public:
 
    MOVIESCENE_API void SetTimeBase(FFrameRate InInputRate, FFrameRate InOutputRate, EMovieSceneEvaluationType InputEvaluationType);
 
    MOVIESCENE_API void Reset(FFrameTime StartPos);
 
    FFrameTime GetCurrentPosition() const { return CurrentPosition; }
 
    TOptional<FFrameTime> GetLastPlayEvalPostition() const { return PreviousPlayEvalPosition; }
 
public:
 
    MOVIESCENE_API FMovieSceneEvaluationRange JumpTo(FFrameTime NewPosition, EPlayDirection PreferredDirection = EPlayDirection::Forwards);
 
    MOVIESCENE_API FMovieSceneEvaluationRange PlayTo(FFrameTime NewPosition, EPlayDirection PreferredDirection = EPlayDirection::Forwards);
 
    MOVIESCENE_API TOptional<FMovieSceneEvaluationRange> GetLastRange() const;
 
    MOVIESCENE_API FMovieSceneEvaluationRange GetCurrentPositionAsRange() const;
 
private:
 
    MOVIESCENE_API void CheckInvariants() const;
 
private:
 
    FFrameRate InputRate;
 
    FFrameRate OutputRate;
 
    EMovieSceneEvaluationType EvaluationType;
 
    FFrameTime CurrentPosition;
 
    TOptional<FFrameTime> PreviousPlayEvalPosition;
 
    TOptional<FMovieSceneEvaluationRange> LastRange;
};