MovieSceneTimeTransform.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 "Misc/FrameTime.h"
#include "MovieSceneTimeTransform.generated.h"
 
USTRUCT()
struct FMovieSceneTimeTransform
{
    GENERATED_BODY()
 
    
    FMovieSceneTimeTransform()
        : TimeScale(1.f)
        , Offset(0)
    {}
 
    explicit FMovieSceneTimeTransform(FFrameTime InOffset, float InTimeScale = 1.f)
        : TimeScale(InTimeScale)
        , Offset(InOffset)
    {
        checkf(!FMath::IsNearlyZero(TimeScale), TEXT("It is invalid to create a linear transformation with a zero timescale. This case should be handled externally by FMovieSceneTimeWarpVariant and FLAG_Zero."))
    }
 
    friend bool operator==(const FMovieSceneTimeTransform& A, const FMovieSceneTimeTransform& B)
    {
        return A.TimeScale == B.TimeScale && A.Offset == B.Offset;
    }
 
    friend bool operator!=(const FMovieSceneTimeTransform& A, const FMovieSceneTimeTransform& B)
    {
        return A.TimeScale != B.TimeScale || A.Offset != B.Offset;
    }
 
    bool IsIdentity() const
    {
        return Offset.FrameNumber.Value == 0 && FMath::IsNearlyZero(Offset.GetSubFrame()) && FMath::IsNearlyEqual(TimeScale, 1.f);
    }
 
    FMovieSceneTimeTransform Inverse() const
    {
        const FFrameTime NewOffset = FMath::IsNearlyZero(TimeScale) ? -Offset : -Offset / TimeScale;
        return FMovieSceneTimeTransform(NewOffset, FMath::IsNearlyZero(TimeScale) ? std::numeric_limits<float>::infinity() : 1.f / TimeScale);
    }
 
    UPROPERTY()
    float TimeScale;
 
    UPROPERTY()
    FFrameTime Offset;
};
 
inline FFrameTime operator*(FFrameTime InTime, const FMovieSceneTimeTransform& RHS)
{
    // Avoid floating point conversion when in the same time-space
    if (RHS.TimeScale == 1.f)
    {
        return InTime + RHS.Offset;
    }
    else if (!FMath::IsFinite(RHS.TimeScale))
    {
        // Special case infinite timescale (inverse of a zero-timescale) and just return the RHS.Offset
        return RHS.Offset;
    }
 
    return InTime * RHS.TimeScale + RHS.Offset;
}
 
inline FFrameTime& operator*=(FFrameTime& InTime, const FMovieSceneTimeTransform& RHS)
{
    InTime = InTime * RHS;
    return InTime;
}
 
template<typename T>
TRange<T> operator*(const TRange<T>& LHS, const FMovieSceneTimeTransform& RHS)
{
    TRange<T> Result = LHS;
 
    if (!Result.GetLowerBound().IsOpen())
    {
        Result.SetLowerBoundValue(Result.GetLowerBoundValue() * RHS);
    }
    if (!Result.GetUpperBound().IsOpen())
    {
        Result.SetUpperBoundValue(Result.GetUpperBoundValue() * RHS);
    }
 
    return Result;
}
 
inline TRange<FFrameNumber> operator*(const TRange<FFrameNumber>& LHS, const FMovieSceneTimeTransform& RHS)
{
    TRange<FFrameNumber> Result = LHS;
 
    if (!Result.GetLowerBound().IsOpen())
    {
        Result.SetLowerBoundValue((Result.GetLowerBoundValue() * RHS).FloorToFrame());
    }
    if (!Result.GetUpperBound().IsOpen())
    {
        Result.SetUpperBoundValue((Result.GetUpperBoundValue() * RHS).FloorToFrame());
    }
 
    return Result;
}
 
template<typename T>
TRange<T>& operator*=(TRange<T>& LHS, const FMovieSceneTimeTransform& RHS)
{
    LHS = LHS * RHS;
    return LHS;
}
 
inline FMovieSceneTimeTransform operator*(const FMovieSceneTimeTransform& LHS, const FMovieSceneTimeTransform& RHS)
{
    // The matrix multiplication occurs as follows:
    //
    // | TimeScaleA , OffsetA   |   .   | TimeScaleB, OffsetB   |
    // | 0          , 1         |       | 0         , 1         |
    //
    const FFrameTime ScaledOffsetRHS = (LHS.TimeScale == 1.f || !FMath::IsFinite(LHS.TimeScale)) ? RHS.Offset : RHS.Offset * LHS.TimeScale;
    return FMovieSceneTimeTransform(
        LHS.Offset + ScaledOffsetRHS,       // New Offset
        RHS.TimeScale * LHS.TimeScale       // New TimeScale
        );
}
 
inline FString LexToString(const FMovieSceneTimeTransform& InTransform)
{
    if (InTransform.TimeScale == 1.f)
    {
        if (InTransform.Offset.GetSubFrame() == 0.f)
        {
            return *FString::Printf(TEXT("[ %+i ]"), InTransform.Offset.FrameNumber.Value);
        }
        else
        {
            return *FString::Printf(TEXT("[ %+i+%.3f ]"), 
                    InTransform.Offset.FrameNumber.Value, InTransform.Offset.GetSubFrame());
        }
    }
    else
    {
        if (InTransform.Offset.GetSubFrame() == 0.f)
        {
            return *FString::Printf(TEXT("[ %+i x%.3f ]"), 
                    InTransform.Offset.FrameNumber.Value, InTransform.TimeScale);
        }
        else
        {
            return *FString::Printf(TEXT("[ %+i+%.3f x%.3f ]"), 
                    InTransform.Offset.FrameNumber.Value, InTransform.Offset.GetSubFrame(), InTransform.TimeScale);
        }
    }
}