MovieSceneSequenceTransform.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/ContainersFwd.h"
#include "Containers/Array.h"
#include "MovieSceneFwd.h"
#include "Misc/AssertionMacros.h"
#include "Misc/FrameNumber.h"
#include "Misc/FrameTime.h"
#include "MovieSceneTimeTransform.h"
#include "MovieSceneTimeWarping.h"
#include "Variants/MovieSceneTimeWarpVariant.h"
 
#include "MovieSceneSequenceTransform.generated.h"
 
template<typename> class TRange;
 
struct FMovieSceneTransformBreadcrumbs;
struct FMovieSceneNestedSequenceTransform;
struct FMovieSceneInverseNestedSequenceTransform;
 
namespace UE::MovieScene
{
    struct FInverseTransformTimeParams;
    struct FTransformTimeParams;
 
    enum class ETimeWarpChannelDomain : uint8;
}
 
 
/*~
 * This file contains the structures necessary for representing transformations of time between various different
 *      'spaces' within the Sequencer/MovieScene codebase. Typically these spaces denote root and sub-sequences,
 *      or sub-sub-suquences. 'Lossy' transformations (ie, transformations that are mathematically non-linear)
 *      are supported and typically referred to as 'warping' or 'non-linear' transforms. Such transforms are always
 *      stored as a stack of nested FMovieSceneNestedSequenceTransform structures and cannot be combined mathematically
 *      like FMovieSceneTimeTransform can.
 *
 * When dealing with time transformations, it is common to use the following nomenclature interchangably:
 *      - Outer, Untransformed, Unwarped space; and,
 *      - Inner, Transformed, Warped space.
 * 
 * Inverse transformations are also supported, but via a different, more restrictive API. Where outer->inner transforms
 *      must always map an outer time to an inner time, inverse transformations can fail. This is clearly the case when 
 *      attempting to inverse-transform a time of 20 from a loop that only spans [0, 10). The requested time is not present
 *      in the set of times that can result from the outer->inner transform, and so the operation fails.
 *      Similarly, inverse transformations may have zero or more real solutions. Consider the previous example, but with a
 *      time of 5; the operation has an infinite number of solutions (one for each loop, or every t where t%5==0).
 *
 *                         ________ << FMovieSceneInverseSequenceTransform << ___________
 *                        /                                                              \
 * ----------------------                                                                -----------------------
 * | Untransformed space |                                                                |  Transformed space  |
 * -----------------------                                                                -----------------------
 *                        \_____________ >> FMovieSceneSequenceTransform >> _____________/
 */
 
 
UENUM()
enum class EMovieSceneBreadcrumbMode : uint8
{
    Sparse,
    Dense
};
 
USTRUCT()
struct FMovieSceneTransformBreadcrumbs
{
    GENERATED_BODY()
 
    
    FMovieSceneTransformBreadcrumbs(EMovieSceneBreadcrumbMode InMode = EMovieSceneBreadcrumbMode::Sparse)
        : Mode(InMode)
    {}
 
 
    FFrameTime operator[](int32 Index) const
    {
        return Breadcrumbs[Index];
    }
 
 
    int32 Num() const
    {
        return Breadcrumbs.Num();
    }
 
 
    bool IsValidIndex(int32 Index) const
    {
        return Breadcrumbs.IsValidIndex(Index);
    }
 
 
    bool IsSparse() const
    {
        return Mode == EMovieSceneBreadcrumbMode::Sparse;
    }
 
 
    EMovieSceneBreadcrumbMode GetMode() const
    {
        return Mode;
    }
 
 
    void Reset()
    {
        Breadcrumbs.Reset();
    }
 
 
    void AddBreadcrumb(const FFrameTime& Breadcrumb)
    {
        Breadcrumbs.Add(Breadcrumb);
    }
 
 
    FFrameTime PopBreadcrumb()
    {
        return Breadcrumbs.Pop();
    }
 
 
    void CombineWithOuterBreadcrumbs(const FMovieSceneTransformBreadcrumbs& OuterBreadcrumbs)
    {
        // Append the outer breadcrumbs to the head of this list
        Breadcrumbs.Insert(OuterBreadcrumbs.Breadcrumbs, 0);
    }
 
 
    FMovieSceneTransformBreadcrumbs OverwriteWith(FFrameTime InTime) const
    {
        FMovieSceneTransformBreadcrumbs Result;
        Result.Breadcrumbs.SetNum(Breadcrumbs.Num());
        for (FFrameTime& X : Result.Breadcrumbs)
        {
            X = InTime;
        }
        return Result;
    }
 
public:
 
    TArray<FFrameTime>::RangedForConstIteratorType begin () const { return Breadcrumbs.begin(); }
    TArray<FFrameTime>::RangedForConstIteratorType end   () const { return Breadcrumbs.end();   }
 
    MOVIESCENE_API operator TArrayView<const FFrameTime>() const;
 
private:
 
    UPROPERTY()
    TArray<FFrameTime> Breadcrumbs;
 
    UPROPERTY()
    EMovieSceneBreadcrumbMode Mode;
};
 
 
USTRUCT()
struct FMovieSceneWarpCounter : public FMovieSceneTransformBreadcrumbs
{
    GENERATED_BODY()
 
public:
 
    MOVIESCENE_API FMovieSceneWarpCounter();
 
    MOVIESCENE_API FMovieSceneWarpCounter(const FMovieSceneWarpCounter&);
    MOVIESCENE_API FMovieSceneWarpCounter& operator=(const FMovieSceneWarpCounter&);
 
    MOVIESCENE_API FMovieSceneWarpCounter(FMovieSceneWarpCounter&&);
    MOVIESCENE_API FMovieSceneWarpCounter& operator=(FMovieSceneWarpCounter&&);
 
    MOVIESCENE_API ~FMovieSceneWarpCounter();
 
    UE_DEPRECATED(5.5, "This function is no longer used. Please update your code to use time-based breadcrumbs instead.")
    void AddWarpingLevel(uint32 WarpCount)
    {
    }
 
    UE_DEPRECATED(5.5, "This function is no longer used. Please update your code to use time-based breadcrumbs instead.")
    void AddNonWarpingLevel()
    {
    }
 
    UE_DEPRECATED(5.5, "This function is no longer used. Please update your code to use time-based breadcrumbs instead.")
    int32 NumWarpCounts() const
    {
        return 0;
    }
 
    UE_DEPRECATED(5.5, "This function is no longer used. Please update your code to use time-based breadcrumbs instead.")
    uint32 LastWarpCount() const
    {
        return (uint32)(-1);
    }
 
    UE_DEPRECATED(5.5, "Warp counts are no longer supported.")
    TArray<uint32> WarpCounts;
};
 
 
USTRUCT()
struct FMovieSceneInverseNestedSequenceTransform
{
    GENERATED_BODY()
 
    
    FMovieSceneInverseNestedSequenceTransform()
    {}
 
 
    FMovieSceneInverseNestedSequenceTransform(const FMovieSceneTimeTransform& InLinearTransform)
        : TimeScale(InLinearTransform.TimeScale), Offset(InLinearTransform.Offset)
    {}
 
 
 
    FMovieSceneInverseNestedSequenceTransform(const FFrameTime& InOffset, double InTimeScale)
        : TimeScale(InTimeScale), Offset(InOffset)
    {}
 
 
public:
 
 
    bool IsLinear() const
    {
        return TimeScale.GetType() == EMovieSceneTimeWarpType::FixedPlayRate;
    }
 
 
    bool NeedsBreadcrumb() const
    {
        return !IsLinear();
    }
 
 
    MOVIESCENE_API FMovieSceneTimeTransform AsLinear() const;
 
 
    MOVIESCENE_API FMovieSceneNestedSequenceTransform Inverse() const;
 
 
    MOVIESCENE_API TOptional<FFrameTime> TryTransformTime(FFrameTime Time, FFrameTime Breadcrumb) const;
 
 
    MOVIESCENE_API TOptional<FFrameTime> TryTransformTime(FFrameTime Time, FFrameTime Breadcrumb, const UE::MovieScene::FInverseTransformTimeParams& Params) const;
 
 
    MOVIESCENE_API bool TransformTimeWithinRange(FFrameTime Time, const TFunctionRef<bool(FFrameTime)>& Visitor, FFrameTime UntransformedRangeStart, FFrameTime UntransformedRangeEnd) const;
 
private:
 
    friend FMovieSceneNestedSequenceTransform;
 
    UPROPERTY()
    FMovieSceneTimeWarpVariant TimeScale;
 
    UPROPERTY()
    FFrameTime Offset;
};
 
 
 
USTRUCT()
struct FMovieSceneNestedSequenceTransform
{
    GENERATED_BODY()
 
 
    
    MOVIESCENE_API FMovieSceneNestedSequenceTransform();
 
    MOVIESCENE_API FMovieSceneNestedSequenceTransform(const FMovieSceneNestedSequenceTransform&);
    MOVIESCENE_API FMovieSceneNestedSequenceTransform& operator=(const FMovieSceneNestedSequenceTransform&);
 
    MOVIESCENE_API FMovieSceneNestedSequenceTransform(FMovieSceneNestedSequenceTransform&&);
    MOVIESCENE_API FMovieSceneNestedSequenceTransform& operator=(FMovieSceneNestedSequenceTransform&&);
 
    MOVIESCENE_API ~FMovieSceneNestedSequenceTransform();
 
    FMovieSceneNestedSequenceTransform(FMovieSceneTimeWarpVariant&& InVariant)
        : TimeScale(MoveTemp(InVariant))
    {
        TimeScale.MakeWeakUnsafe();
    }
 
 
    FMovieSceneNestedSequenceTransform(const FMovieSceneTimeTransform& InLinearTransform)
        : TimeScale(InLinearTransform.TimeScale), Offset(InLinearTransform.Offset)
    {}
 
 
    FMovieSceneNestedSequenceTransform(FFrameTime InOffset, double InTimeScale)
        : TimeScale(InTimeScale), Offset(InOffset)
    {}
 
 
    FMovieSceneNestedSequenceTransform(FFrameTime InOffset, FMovieSceneTimeWarpVariant&& InTimeScale)
        : TimeScale(MoveTemp(InTimeScale)), Offset(InOffset)
    {
        TimeScale.MakeWeakUnsafe();
    }
 
 
public:
 
 
    bool IsLinear() const
    {
        return TimeScale.GetType() == EMovieSceneTimeWarpType::FixedPlayRate;
    }
 
 
    FMovieSceneTimeTransform AsLinear() const
    {
        return FMovieSceneTimeTransform(Offset, TimeScale.AsFixedPlayRateFloat());
    }
 
 
    bool NeedsBreadcrumb() const
    {
        return !IsLinear();
    }
 
 
    bool IsIdentity() const
    {
        return Offset == 0 && TimeScale.GetType() == EMovieSceneTimeWarpType::FixedPlayRate && TimeScale.AsFixedPlayRate() == 1.0;
    }
 
 
    MOVIESCENE_API FFrameTime TransformTime(FFrameTime Time) const;
 
 
    MOVIESCENE_API FFrameTime TransformTime(FFrameTime Time, const UE::MovieScene::FTransformTimeParams& Params) const;
 
 
    MOVIESCENE_API FMovieSceneInverseNestedSequenceTransform Inverse() const;
 
 
    MOVIESCENE_API TRange<FFrameTime> ComputeTraversedHull(const TRange<FFrameTime>& Range) const;
 
 
    MOVIESCENE_API bool SupportsBoundaries() const;
 
 
    MOVIESCENE_API TOptional<UE::MovieScene::ETimeWarpChannelDomain> GetWarpDomain() const;
 
 
    MOVIESCENE_API bool ExtractBoundariesWithinRange(const TRange<FFrameTime>& UntransformedRange, const TFunctionRef<bool(FFrameTime)>& Visitor) const;
 
 
    MOVIESCENE_API void ToString(TStringBuilderBase<TCHAR>& OutBuilder) const;
 
 
    friend bool operator==(const FMovieSceneNestedSequenceTransform& A, const FMovieSceneNestedSequenceTransform& B)
    {
        return A.TimeScale == B.TimeScale && A.Offset == B.Offset;
    }
 
 
    friend bool operator!=(const FMovieSceneNestedSequenceTransform& A, const FMovieSceneNestedSequenceTransform& B)
    {
        return A.TimeScale != B.TimeScale || A.Offset != B.Offset;
    }
 
    /*~ Begin StructOpsTypeTraits */
    void PostSerialize(const FArchive& Ar);
    /*~ End StructOpsTypeTraits */
 
private:
 
    UPROPERTY()
    FMovieSceneTimeWarpVariant TimeScale;
 
    UPROPERTY()
    FFrameTime Offset;
 
public:
 
    /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Begin API deprecation ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
    UE_DEPRECATED(5.5, "Please update your code to use a FMovieSceneTimeWarpVariant")
    FMovieSceneNestedSequenceTransform(const FMovieSceneTimeWarping& InWarping)
    {
    }
 
    UE_DEPRECATED(5.5, "Please update your code to use a FMovieSceneTimeWarpVariant")
    FMovieSceneNestedSequenceTransform(FMovieSceneTimeTransform InLinearTransform, const FMovieSceneTimeWarping& InWarping)
        : TimeScale(InLinearTransform.TimeScale), Offset(InLinearTransform.Offset)
    {
    }
 
    UE_DEPRECATED(5.5, "Please update your code to check for IsLinear()")
    bool IsLooping() const
    {
        return TimeScale.GetType() == EMovieSceneTimeWarpType::Loop;
    }
 
    UE_DEPRECATED(5.5, "Please use Inverse()")
    FMovieSceneNestedSequenceTransform InverseLinearOnly() const
    {
        return IsLinear() ? AsLinear().Inverse() : FMovieSceneNestedSequenceTransform();
    }
 
    UE_DEPRECATED(5.5, "Please use Inverse()")
    FMovieSceneNestedSequenceTransform InverseFromWarp(uint32 WarpCount) const
    {
        return IsLinear() ? AsLinear().Inverse() : FMovieSceneNestedSequenceTransform();
    }
 
    UE_DEPRECATED(5.5, "Warping is now implemented as a variant within TimeScale")
    FMovieSceneTimeWarping Warping;
    /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  End API deprecation  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
};
template<>
struct TStructOpsTypeTraits<FMovieSceneNestedSequenceTransform> : public TStructOpsTypeTraitsBase2<FMovieSceneNestedSequenceTransform>
{
    enum
    {
        WithPostSerialize = true,
    };
};
 
 
 
 
USTRUCT()
struct FMovieSceneSequenceTransform
{
    GENERATED_BODY()
 
 
    
    FMovieSceneSequenceTransform()
    {}
 
    explicit FMovieSceneSequenceTransform(FFrameTime InOffset, float InTimeScale = 1.f)
        : LinearTransform(InOffset, InTimeScale)
    {}
 
 
    explicit FMovieSceneSequenceTransform(FMovieSceneTimeTransform InLinearTransform)
        : LinearTransform(InLinearTransform)
    {}
 
 
    explicit FMovieSceneSequenceTransform(FMovieSceneNestedSequenceTransform&& InNestedTransform)
    {
        if (InNestedTransform.IsLinear())
        {
            LinearTransform = InNestedTransform.AsLinear();
        }
        else
        {
            NestedTransforms.Emplace(InNestedTransform);
        }
    }
 
 
    friend bool operator==(const FMovieSceneSequenceTransform& A, const FMovieSceneSequenceTransform& B)
    {
        return A.LinearTransform == B.LinearTransform && A.NestedTransforms == B.NestedTransforms;
    }
 
 
    friend bool operator!=(const FMovieSceneSequenceTransform& A, const FMovieSceneSequenceTransform& B)
    {
        return A.LinearTransform != B.LinearTransform || A.NestedTransforms != B.NestedTransforms;
    }
 
 
    bool NeedsBreadcrumbs() const
    {
        return !IsLinear();
    }
 
 
    bool IsLinear() const
    {
        return NestedTransforms.Num() == 0;
    }
 
 
    FMovieSceneTimeTransform AsLinear() const
    {
        return LinearTransform;
    }
 
 
    MOVIESCENE_API bool IsIdentity() const;
 
 
    MOVIESCENE_API FFrameTime TransformTime(FFrameTime Time) const;
 
 
    MOVIESCENE_API FFrameTime TransformTime(FFrameTime InTime, const UE::MovieScene::FTransformTimeParams& Params) const;
 
 
    MOVIESCENE_API TRange<FFrameTime> ComputeTraversedHull(const TRange<FFrameTime>& Range) const;
 
 
    MOVIESCENE_API TRange<FFrameTime> ComputeTraversedHull(const TRange<FFrameNumber>& Range) const;
 
 
    MOVIESCENE_API TOptional<UE::MovieScene::ETimeWarpChannelDomain> FindFirstWarpDomain() const;
 
 
public:
 
 
    MOVIESCENE_API void Add(FMovieSceneTimeTransform InTransform);
 
 
 
    MOVIESCENE_API void Add(FMovieSceneNestedSequenceTransform InTransform);
 
 
    MOVIESCENE_API void Add(FFrameTime InOffset, FMovieSceneTimeWarpVariant&& InTimeWarp);
 
 
    MOVIESCENE_API void AddLoop(FFrameNumber Start, FFrameNumber End);
 
 
    MOVIESCENE_API void Append(const FMovieSceneSequenceTransform& Tail);
 
 
    MOVIESCENE_API FMovieSceneSequenceTransform operator*(const FMovieSceneSequenceTransform& RHS) const;
 
 
    MOVIESCENE_API FMovieSceneInverseSequenceTransform Inverse() const;
 
 
    MOVIESCENE_API bool ExtractBoundariesWithinRange(FFrameTime UntransformedStart, FFrameTime UntransformedEnd, const TFunctionRef<bool(FFrameTime)>& Visitor) const;
 
    /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Begin API deprecation ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
    UE_DEPRECATED(5.5, "This function is no longer supported. Please use !IsLinear()")
    bool IsLooping() const;
    UE_DEPRECATED(5.5, "Please upgrade your code to use TransformTime that takes breadcrumbs")
    MOVIESCENE_API void TransformTime(FFrameTime InTime, FFrameTime& OutTime, FMovieSceneWarpCounter& OutWarpCounter) const;
    UE_DEPRECATED(5.5, "Transforms no longer have a constant time scale.")
    MOVIESCENE_API float GetTimeScale() const;
    UE_DEPRECATED(5.5, "Please use ComputeTraversedHull or TransformTime")
    MOVIESCENE_API TRange<FFrameTime> TransformRangePure(const TRange<FFrameTime>& Range) const;
    UE_DEPRECATED(5.5, "Please use ComputeTraversedHull or TransformTime")
    MOVIESCENE_API TRange<FFrameTime> TransformRangeUnwarped(const TRange<FFrameTime>& Range) const;
    UE_DEPRECATED(5.5, "Please use ComputeTraversedHull or TransformTime")
    MOVIESCENE_API TRange<FFrameTime> TransformRangeConstrained(const TRange<FFrameTime>& Range) const;
    UE_DEPRECATED(5.5, "Please use ComputeTraversedHull or TransformTime")
    MOVIESCENE_API TRange<FFrameNumber> TransformRangePure(const TRange<FFrameNumber>& Range) const;
    UE_DEPRECATED(5.5, "Please use ComputeTraversedHull or TransformTime")
    MOVIESCENE_API TRange<FFrameNumber> TransformRangeUnwarped(const TRange<FFrameNumber>& Range) const;
    UE_DEPRECATED(5.5, "Please use ComputeTraversedHull or TransformTime")
    MOVIESCENE_API TRange<FFrameNumber> TransformRangeConstrained(const TRange<FFrameNumber>& Range) const;
    UE_DEPRECATED(5.5, "Please use Inverse()")
    MOVIESCENE_API FMovieSceneSequenceTransform InverseNoLooping() const;
    UE_DEPRECATED(5.4, "Please use InverseNoLooping instead.")
    MOVIESCENE_API FMovieSceneTimeTransform InverseLinearOnly() const;
    UE_DEPRECATED(5.4, "Please use InverseFromAllFirstLoops instead.")
    MOVIESCENE_API FMovieSceneTimeTransform InverseFromAllFirstWarps() const;
    UE_DEPRECATED(5.4, "Please use InverseFromLoop instead.")
    MOVIESCENE_API FMovieSceneTimeTransform InverseFromWarp(const FMovieSceneWarpCounter& WarpCounter) const;
    UE_DEPRECATED(5.4, "Please use InverseFromLoop instead.")
    MOVIESCENE_API FMovieSceneTimeTransform InverseFromWarp(const TArrayView<const uint32>& WarpCounts) const;
    UE_DEPRECATED(5.5, "Please use Inverse()")
    MOVIESCENE_API FMovieSceneSequenceTransform InverseFromAllFirstLoops() const;
    UE_DEPRECATED(5.5, "Please use Inverse()")
    MOVIESCENE_API FMovieSceneSequenceTransform InverseFromLoop(const FMovieSceneWarpCounter& LoopCounter) const;
    UE_DEPRECATED(5.5, "Please use Inverse()")
    FMovieSceneSequenceTransform InverseFromLoop(const TArrayView<const FFrameTime>& Breadcrumbs) const;
    UE_DEPRECATED(5.5, "Please use Inverse()")
    MOVIESCENE_API FMovieSceneSequenceTransform InverseFromLoop(const TArrayView<const uint32>& LoopCounts) const;
    /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  End API deprecation  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
    UPROPERTY()
    FMovieSceneTimeTransform LinearTransform;
 
    UPROPERTY()
    TArray<FMovieSceneNestedSequenceTransform> NestedTransforms;
};
 
 
 
USTRUCT()
struct FMovieSceneInverseSequenceTransform
{
    GENERATED_BODY()
 
 
    
    bool IsLinear() const
    {
        return NestedTransforms.Num() == 0;
    }
 
 
    FMovieSceneTimeTransform AsLinear() const
    {
        check(IsLinear());
        return LinearTransform;
    }
 
 
    MOVIESCENE_API TOptional<FFrameTime> TryTransformTime(FFrameTime Time, const FMovieSceneTransformBreadcrumbs& Breadcrumbs) const;
 
 
    MOVIESCENE_API TOptional<FFrameTime> TryTransformTime(FFrameTime Time, const FMovieSceneTransformBreadcrumbs& Breadcrumbs, const UE::MovieScene::FInverseTransformTimeParams& Params) const;
 
 
    MOVIESCENE_API TOptional<FFrameTime> TryTransformTime(FFrameTime Time) const;
 
 
    MOVIESCENE_API TOptional<FFrameTime> TryTransformTime(FFrameTime Time, const UE::MovieScene::FInverseTransformTimeParams& Params) const;
 
    MOVIESCENE_API bool TransformTimeWithinRange(FFrameTime Time, const TFunctionRef<bool(FFrameTime)>& Visitor, const FMovieSceneTransformBreadcrumbs& StartBreadcrumbs, const FMovieSceneTransformBreadcrumbs& EndBreadcrumbs) const;
 
 
    MOVIESCENE_API bool TransformFiniteRangeWithinRange(const TRange<FFrameTime>& Range, TFunctionRef<bool(TRange<FFrameTime>)> Visitor, const FMovieSceneTransformBreadcrumbs& StartBreadcrumbs, const FMovieSceneTransformBreadcrumbs& EndBreadcrumbs) const;
 
 
    UE_DEPRECATED(5.5, "This function is no longer supported. Please use FMovieSceneInverseSequenceTransform directly.")
    MOVIESCENE_API FMovieSceneTimeTransform AsLegacyLinearTimeTransform() const;
 
private:
 
 
    bool RecursiveTransformTimeWithinRange(int32 NestingIndex, FFrameTime Time, const TFunctionRef<bool(FFrameTime)>& FinalVisitor, TArrayView<const FFrameTime> StartBreadcrumbs, TArrayView<const FFrameTime> EndBreadcrumbs) const;
 
private:
 
    friend FMovieSceneSequenceTransform;
 
 
    UPROPERTY()
    FMovieSceneTimeTransform LinearTransform;
 
 
    UPROPERTY()
    TArray<FMovieSceneInverseNestedSequenceTransform> NestedTransforms;
};
 
MOVIESCENE_API FFrameTime operator*(FFrameTime InTime, const FMovieSceneSequenceTransform& RHS);
 
inline FFrameTime& operator*=(FFrameTime& InTime, const FMovieSceneSequenceTransform& RHS)
{
    InTime = InTime * RHS;
    return InTime;
}
 
FString LexToString(const FMovieSceneSequenceTransform& InTransform);
 
FString LexToString(const FMovieSceneWarpCounter& InCounter);