MovieScenePiecewiseCurveUtils.inl

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "MovieSceneFwd.h"
#include "Channels/MovieSceneInterpolation.h"
#include "MovieSceneTransformTypes.h"
#include "Curves/RichCurve.h"
#include "Channels/MovieSceneChannel.h"
 
struct FFrameTime;
 
namespace UE::MovieScene::Interpolation
{
 
 
template<typename PiecewiseDataType>
UE::MovieScene::Interpolation::FInterpolationExtents ComputeExtentsWithinBounds(const PiecewiseDataType& PiecewiseData, FFrameTime StartTime, FFrameTime EndTime)
{
    using namespace UE::MovieScene;
 
    const int32        NumPieces         = PiecewiseData.NumPieces();
    const FFrameNumber FiniteSplineStart = PiecewiseData.GetFiniteStart();
    const FFrameNumber FiniteSplineEnd   = PiecewiseData.GetFiniteEnd();
 
    check(NumPieces > 0 &&
        StartTime >= FiniteSplineStart && StartTime <= FiniteSplineEnd &&
        EndTime   >= FiniteSplineStart && EndTime   <= FiniteSplineEnd
    );
 
    // Start at the first key that is less than or equal to the start time (upper bound finds first key >, then we subtract 1)
    const int32 StartIndex = PiecewiseData.GetIndexOfPieceByTime(StartTime);
 
    Interpolation::FInterpolationExtents Extents;
 
    for (int32 PieceIndex = StartIndex; PieceIndex >= 0 && PieceIndex < NumPieces; ++PieceIndex)
    {
        Interpolation::FCachedInterpolation Interp = PiecewiseData.GetPieceByIndex(PieceIndex);
 
        if (Interp.GetRange().Start > EndTime)
        {
            break;
        }
 
        FFrameTime EvalTime1 = Interp.GetRange().Clamp(StartTime);
        FFrameTime EvalTime2 = Interp.GetRange().Clamp(EndTime);
        Extents.Combine(Interp.ComputeExtents(EvalTime1, EvalTime2));
    }
 
    return Extents;
}
 
template<typename PiecewiseDataType>
UE::MovieScene::Interpolation::FInterpolationExtents ComputePiecewiseExtents(const PiecewiseDataType& PiecewiseData, FFrameTime StartTime, FFrameTime EndTime)
{
    using namespace UE::MovieScene;
    using namespace UE::MovieScene::Interpolation;
 
    if (!ensure(StartTime <= EndTime))
    {
        return FInterpolationExtents{ 0, 0, 0, 0 };
    }
    
    check(StartTime <= EndTime);
 
    const int32 NumPieces = PiecewiseData.NumPieces();
 
    if (NumPieces == 0)
    {
        FInterpolationExtents Extents;
        if (PiecewiseData.HasDefaultValue())
        {
            Extents.AddPoint(PiecewiseData.GetDefaultValue(), StartTime);
            Extents.AddPoint(PiecewiseData.GetDefaultValue(), EndTime);
        }
 
        return Extents;
    }
 
    FFrameNumber FiniteSplineStart = PiecewiseData.GetFiniteStart();
    FFrameNumber FiniteSplineEnd   = PiecewiseData.GetFiniteEnd();
 
    FInterpolationExtents FinalExtents;
 
    // Deal with linear pre-post extrapolation
    if (PiecewiseData.GetPreExtrapolation() == RCCE_Linear && StartTime.FrameNumber.Value < FiniteSplineStart)
    {
        const int32 FirstKeyTime = FiniteSplineStart.Value;
        const int32 Min          = StartTime.FrameNumber.Value;
        const int32 Max          = FMath::Min(FirstKeyTime, EndTime.FrameNumber.Value);
 
        const double MinPreExtrap = PiecewiseData.PreExtrapolate(Min);
        const double MaxPreExtrap = PiecewiseData.PreExtrapolate(Max);
 
        FinalExtents.AddPoint(MinPreExtrap, Min);
        FinalExtents.AddPoint(MaxPreExtrap, Max);
 
        if (EndTime.FrameNumber.Value <= FirstKeyTime)
        {
            return FinalExtents;
        }
 
        // Clamp to the valid range
        StartTime = FiniteSplineStart;
    }
 
    if (PiecewiseData.GetPostExtrapolation() == RCCE_Linear && EndTime.FrameNumber.Value > FiniteSplineEnd)
    {
        const int32 LastKeyTime  = FiniteSplineEnd.Value;
        const int32 Min          = FMath::Max(LastKeyTime, StartTime.FrameNumber.Value);
        const int32 Max          = EndTime.FrameNumber.Value;
 
        const double MinPostExtrap = PiecewiseData.PostExtrapolate(Min);
        const double MaxPostExtrap = PiecewiseData.PostExtrapolate(Max);
 
        FinalExtents.AddPoint(MinPostExtrap, Min);
        FinalExtents.AddPoint(MaxPostExtrap, Max);
 
        if (StartTime.FrameNumber.Value >= LastKeyTime)
        {
            return FinalExtents;
        }
 
        // Clamp to the valid range
        EndTime = FiniteSplineEnd;
    }
 
    FCycleParams StartCycled = CycleTime(FiniteSplineStart, FiniteSplineEnd, StartTime);
    FCycleParams EndCycled   = CycleTime(FiniteSplineStart, FiniteSplineEnd, EndTime);
 
    const double StartValue = PiecewiseData.GetStartingValue();
    const double EndValue   = PiecewiseData.GetEndingValue();
 
    // Deal with offset cycles and oscillation on the start frame
    if (StartTime < FFrameTime(FiniteSplineStart))
    {
        switch (PiecewiseData.GetPreExtrapolation())
        {
        case RCCE_Linear:          StartCycled.CycleCount = 0;                                               break;
        case RCCE_Cycle:           break;
        case RCCE_CycleWithOffset: StartCycled.ComputePreValueOffset(StartValue, EndValue);                  break;
        case RCCE_Oscillate:       StartCycled.Oscillate(FiniteSplineStart.Value, FiniteSplineEnd.Value);    break;
        case RCCE_Constant:        StartCycled.Time = FiniteSplineStart; StartCycled.CycleCount = 0;         break;
        case RCCE_None:            StartCycled.Time = FiniteSplineStart; StartCycled.CycleCount = 0;         break;
        }
    }
    else if (StartTime > FFrameTime(FiniteSplineEnd))
    {
        switch (PiecewiseData.GetPostExtrapolation())
        {
        case RCCE_Linear:          StartCycled.CycleCount = 0;                                               break;
        case RCCE_Cycle:           break;
        case RCCE_CycleWithOffset: StartCycled.ComputePostValueOffset(StartValue, EndValue);                 break;
        case RCCE_Oscillate:       StartCycled.Oscillate(FiniteSplineStart.Value, FiniteSplineEnd.Value);    break;
        case RCCE_Constant:        StartCycled.Time = FiniteSplineEnd; StartCycled.CycleCount = 0;           break;
        case RCCE_None:            StartCycled.Time = FiniteSplineEnd; StartCycled.CycleCount = 0;           break;
        }
    }
 
    // Deal with offset cycles and oscillation on the end frame
    if (EndTime < FFrameTime(FiniteSplineStart))
    {
        switch (PiecewiseData.GetPreExtrapolation())
        {
        case RCCE_Linear:          EndCycled.CycleCount = 0;                                                 break;
        case RCCE_Cycle:           break;
        case RCCE_CycleWithOffset: EndCycled.ComputePreValueOffset(StartValue, EndValue);                    break;
        case RCCE_Oscillate:       EndCycled.Oscillate(FiniteSplineStart.Value, FiniteSplineEnd.Value);      break;
        case RCCE_Constant:        EndCycled.Time = FiniteSplineStart; EndCycled.CycleCount = 0;             break;
        case RCCE_None:            EndCycled.Time = FiniteSplineStart; EndCycled.CycleCount = 0;             break;
        }
    }
    else if (EndTime > FFrameTime(FiniteSplineEnd))
    {
        switch (PiecewiseData.GetPostExtrapolation())
        {
        case RCCE_Linear:          EndCycled.CycleCount = 0;                                                 break;
        case RCCE_Cycle:           break;
        case RCCE_CycleWithOffset: EndCycled.ComputePostValueOffset(StartValue, EndValue);                   break;
        case RCCE_Oscillate:       EndCycled.Oscillate(FiniteSplineStart.Value, FiniteSplineEnd.Value);      break;
        case RCCE_Constant:        EndCycled.Time = FiniteSplineEnd; EndCycled.CycleCount = 0;               break;
        case RCCE_None:            EndCycled.Time = FiniteSplineEnd; EndCycled.CycleCount = 0;               break;
        }
    }
 
    if (StartCycled.CycleCount != EndCycled.CycleCount)
    {
        const double     OffsetPerCycle = (EndValue        - StartValue);
        const FFrameTime CycleDuration  = (FiniteSplineEnd - FiniteSplineStart);
 
        FInterpolationExtents StartCycleExtents = ComputeExtentsWithinBounds(
            PiecewiseData,
            StartCycled.bMirrorCurve ? FiniteSplineStart : StartCycled.Time,
            StartCycled.bMirrorCurve ? StartCycled.Time  : FiniteSplineEnd);
 
        StartCycleExtents.MinValue     += StartCycled.ValueOffset;
        StartCycleExtents.MaxValue     += StartCycled.ValueOffset;
        StartCycleExtents.MinValueTime += StartCycled.CycleCount * CycleDuration;
        StartCycleExtents.MaxValueTime += StartCycled.CycleCount * CycleDuration;
 
        FInterpolationExtents EndCycleExtents = ComputeExtentsWithinBounds(
            PiecewiseData,
            EndCycled.bMirrorCurve ? EndCycled.Time  : FiniteSplineStart,
            EndCycled.bMirrorCurve ? FiniteSplineEnd : EndCycled.Time);
 
        EndCycleExtents.MinValue     += EndCycled.ValueOffset;
        EndCycleExtents.MaxValue     += EndCycled.ValueOffset;
        EndCycleExtents.MinValueTime += EndCycled.CycleCount * CycleDuration;
        EndCycleExtents.MaxValueTime += EndCycled.CycleCount * CycleDuration;
 
        FinalExtents.Combine(StartCycleExtents);
        FinalExtents.Combine(EndCycleExtents);
 
        if (EndCycled.CycleCount - StartCycled.CycleCount > 1)
        {
            const bool bHasPreExtrapCycles  = PiecewiseData.GetPreExtrapolation()  == RCCE_CycleWithOffset && StartCycled.CycleCount < 0;
            const bool bHasPostExtrapCycles = PiecewiseData.GetPostExtrapolation() == RCCE_CycleWithOffset && EndCycled.CycleCount   > 0;
 
            const int32 NumFullPreExtrapCycles  = bHasPreExtrapCycles  ? -(StartCycled.CycleCount - FMath::Min(EndCycled.CycleCount,   0))-1 : 0;
            const int32 NumFullPostExtrapCycles = bHasPostExtrapCycles ?  (EndCycled.CycleCount   - FMath::Max(StartCycled.CycleCount, 0))-1 : 0;
 
            FInterpolationExtents FullExtents = ComputeExtentsWithinBounds(PiecewiseData, FiniteSplineStart, FiniteSplineEnd);
 
            if (NumFullPreExtrapCycles + NumFullPostExtrapCycles > 0)
            {
                FInterpolationExtents PreExtents;
                FInterpolationExtents PostExtents;
                PostExtents.AddPoint(
                    FullExtents.MaxValue     + OffsetPerCycle * NumFullPostExtrapCycles,
                    FullExtents.MaxValueTime + CycleDuration  * NumFullPostExtrapCycles);
                PostExtents.AddPoint(
                    FullExtents.MinValue     + OffsetPerCycle * NumFullPostExtrapCycles,
                    FullExtents.MinValueTime + CycleDuration  * NumFullPostExtrapCycles);
 
                PreExtents.AddPoint(
                    FullExtents.MaxValue     - OffsetPerCycle * NumFullPreExtrapCycles,
                    FullExtents.MaxValueTime - CycleDuration  * NumFullPreExtrapCycles);
                PreExtents.AddPoint(
                    FullExtents.MinValue     - OffsetPerCycle * NumFullPreExtrapCycles,
                    FullExtents.MinValueTime - CycleDuration  * NumFullPreExtrapCycles);
 
                FullExtents.Combine(PreExtents);
                FullExtents.Combine(PostExtents);
            }
 
            FinalExtents.Combine(FullExtents);
        }
    }
    else if (EndCycled.Time == StartCycled.Time)
    {
        double Value = 0.0;
 
        if (StartCycled.Time < FiniteSplineStart)
        {
            Value = PiecewiseData.PreExtrapolate(StartCycled.Time);
        }
        else if (StartCycled.Time >= FiniteSplineEnd)
        {
            Value = PiecewiseData.PostExtrapolate(StartCycled.Time);
        }
        else
        {
            PiecewiseData.GetPieceByTime(StartCycled.Time).Evaluate(StartCycled.Time, Value);
        }
 
        FInterpolationExtents Extents;
        Extents.AddPoint(Value, StartTime);
        return Extents;
    }
    else
    {
        // Within the same cycle is easy - just compute the extents between the two bounds, and offset by the oscillation amount
        FInterpolationExtents Extents = ComputeExtentsWithinBounds(
            PiecewiseData,
            StartCycled.bMirrorCurve ? EndCycled.Time   : StartCycled.Time,
            StartCycled.bMirrorCurve ? StartCycled.Time : EndCycled.Time);
 
        Extents.MinValue += StartCycled.ValueOffset;
        Extents.MaxValue += StartCycled.ValueOffset;
 
        FinalExtents.Combine(Extents);
    }
 
    return FinalExtents;
}
 
} // namespace UE::MovieScene::Interpolation