MovieSceneChannelTraits.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/ArrayView.h"
#include "Misc/FrameNumber.h"
#include "Misc/FrameTime.h"
#include "Misc/FrameRate.h"
#include "Misc/Optional.h"
#include "MovieSceneChannelEditorData.h"
#include "MovieSceneSection.h"
 
 
enum class EMovieSceneKeyInterpolation : uint8;
 
struct FKeyDataOptimizationParams
{
    float Tolerance = KINDA_SMALL_NUMBER;
 
    bool bAutoSetInterpolation = false;
 
    TRange<FFrameNumber> Range = TRange<FFrameNumber>::All();
 
    FFrameRate DisplayRate;
};
 
template<typename ChannelType>
struct TMovieSceneChannelTraitsBase
{
    enum { SupportsDefaults = true };
 
#if WITH_EDITOR
 
    typedef void ExtendedEditorDataType;
 
#endif
};
 
template<typename ValueType>
struct FMovieSceneChannelTraitsTransform
{
    ValueType Offset = {};
    ValueType Scale = {};
    ValueType Pivot = {};
};
 
template<typename ChannelType>
struct TMovieSceneChannelTraits : TMovieSceneChannelTraitsBase<ChannelType>
{
};
 
template<typename ChannelType>
using TGetMovieSceneChannelTraits = TMovieSceneChannelTraits<typename std::remove_cv_t<ChannelType>>;
 
namespace UE
{
namespace MovieScene
{
    template<typename ChannelType, typename ValueType>
    bool EvaluateChannel(const ChannelType* InChannel, FFrameTime InTime, ValueType& OutValue)
    {
        return InChannel->Evaluate(InTime, OutValue);
    }
 
    template<typename ChannelType, typename ValueType>
    bool EvaluateChannel(const UMovieSceneSection* InSection, const ChannelType* InChannel, FFrameTime InTime, ValueType& OutValue)
    {
        return EvaluateChannel(InChannel, InTime, OutValue);
    }
 
    template<typename ChannelType, typename ValueType>
    bool AssignValue(ChannelType* InChannel, FKeyHandle InKeyHandle, ValueType&& InValue)
    {
        auto ChannelData = InChannel->GetData();
        int32 ValueIndex = ChannelData.GetIndex(InKeyHandle);
 
        if (ValueIndex != INDEX_NONE)
        {
            ChannelData.GetValues()[ValueIndex] = Forward<ValueType>(InValue);
            return true;
        }
 
        // The key handle doesn't belong to this channel if it can't be found in the channel data, so report failure.
        return false;
    }
 
    template<typename ChannelType, typename ValueType>
    bool GetKeyValue(ChannelType* InChannel, FKeyHandle InKeyHandle, ValueType& OutValue)
    {
        auto ChannelData = InChannel->GetData();
        int32 ValueIndex = ChannelData.GetIndex(InKeyHandle);
        
        if (ValueIndex != INDEX_NONE)
        {
            OutValue = ChannelData.GetValues()[ValueIndex];
            return true;
        }
 
        // The key handle doesn't belong to this channel if it can't be found in the channel data, so report failure.
        return false;
    }
 
    template<typename ChannelType>
    EMovieSceneKeyInterpolation GetInterpolationMode(ChannelType* InChannel, const FFrameNumber& InTime, EMovieSceneKeyInterpolation DefaultInterpolationMode)
    {
        return DefaultInterpolationMode;
    }
 
    template<typename ChannelType, typename ValueType>
    FKeyHandle AddKeyToChannel(ChannelType* InChannel, FFrameNumber InTime, ValueType&& Value, EMovieSceneKeyInterpolation Interpolation)
    {
        auto ChannelInterface = InChannel->GetData();
        int32 ExistingIndex = ChannelInterface.FindKey(InTime);
 
        FKeyHandle Handle = FKeyHandle::Invalid();
 
        if (ExistingIndex != INDEX_NONE)
        {
            Handle = ChannelInterface.GetHandle(ExistingIndex);
            AssignValue(InChannel, Handle, Forward<ValueType>(Value));
        }
        else
        {
            ExistingIndex = ChannelInterface.AddKey(InTime, Forward<ValueType>(Value));
            Handle = ChannelInterface.GetHandle(ExistingIndex);
        }
 
        return Handle;
    }
 
    template<typename ChannelType, typename ValueType>
    bool ValueExistsAtTime(const ChannelType* InChannel, FFrameNumber InTime, const ValueType& InValue)
    {
        ValueType ExistingValue{};
        return EvaluateChannel(InChannel, InTime, ExistingValue) && ExistingValue == InValue;
    }
 
    template<typename ChannelType, typename ValueType>
    typename TEnableIf<TGetMovieSceneChannelTraits<ChannelType>::SupportsDefaults>::Type SetChannelDefault(ChannelType* Channel, ValueType&& DefaultValue)
    {
        Channel->SetDefault(DefaultValue);
    }
    template<typename ChannelType, typename ValueType>
    typename TEnableIf<!TGetMovieSceneChannelTraits<ChannelType>::SupportsDefaults>::Type SetChannelDefault(ChannelType* Channel, ValueType&& DefaultValue)
    {}
 
    template<typename ChannelType>
    typename TEnableIf<TGetMovieSceneChannelTraits<ChannelType>::SupportsDefaults>::Type RemoveChannelDefault(ChannelType* Channel)
    {
        Channel->RemoveDefault();
    }
    template<typename ChannelType>
    typename TEnableIf<!TGetMovieSceneChannelTraits<ChannelType>::SupportsDefaults>::Type RemoveChannelDefault(ChannelType* Channel)
    {}
 
    template<typename ChannelType, typename ValueType>
    typename TEnableIf<TGetMovieSceneChannelTraits<ChannelType>::SupportsDefaults, bool>::Type GetChannelDefault(ChannelType* Channel, ValueType& OutDefaultValue)
    {
        if (Channel->GetDefault().IsSet())
        {
            OutDefaultValue = Channel->GetDefault().GetValue();
            return true;
        }
        return false;
    }
 
    template<typename ChannelType, typename ValueType>
    typename TEnableIf<!TGetMovieSceneChannelTraits<ChannelType>::SupportsDefaults, bool>::Type GetChannelDefault(ChannelType* Channel, ValueType& OutDefaultValue)
    {
        return false;
    }
 
    template<typename ChannelType>
    void Optimize(ChannelType* InChannel, const FKeyDataOptimizationParams& Params)
    {
        using namespace UE::MovieScene;
 
        auto ChannelInterface = InChannel->GetData();
        if (ChannelInterface.GetTimes().Num() > 1)
        {
            int32 StartIndex = 0;
            int32 EndIndex = 0;
 
            {
                TArrayView<const FFrameNumber> Times = ChannelInterface.GetTimes();
                StartIndex = Params.Range.GetLowerBound().IsClosed() ? Algo::LowerBound(Times, Params.Range.GetLowerBoundValue()) : 0;
                EndIndex   = Params.Range.GetUpperBound().IsClosed() ? Algo::UpperBound(Times, Params.Range.GetUpperBoundValue()) : Times.Num();
            }
 
            for (int32 Index = StartIndex; Index < EndIndex && Index < ChannelInterface.GetTimes().Num(); ++Index)
            {
                // Reget times and values as they may be reallocated
                FFrameNumber Time   = ChannelInterface.GetTimes()[Index];
                auto  OriginalValue = ChannelInterface.GetValues()[Index];
 
                // If the channel evaluates the same with this key removed, we can leave it out
                ChannelInterface.RemoveKey(Index);
                if (ValueExistsAtTime(InChannel, Time, OriginalValue))
                {
                    Index--;
                }
                else
                {
                    ChannelInterface.AddKey(Time, MoveTemp(OriginalValue));
                }
            }
        }
    }
 
    template<typename ValueType>
    void InvertValue(ValueType& InOutValue){}
 
    template<typename ValueType>
    void ReciprocalValue(ValueType& InOutValue) {}
 
    template<typename ValueType>
    void TransformValue(ValueType& InOutValue, const FMovieSceneChannelTraitsTransform<ValueType>& Transform) {}
 
} // namespace MovieScene
} // namespace UE