BlendableToken.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Evaluation/Blending/MovieSceneBlendType.h"
#include "Misc/InlineValue.h"
#include "Evaluation/MovieScenePlayback.h"
#include "Evaluation/MovieSceneEvaluationScope.h"
 
 
template<typename DataType> struct TMovieSceneInitialValueStore;
 
namespace UE
{
namespace MovieScene
{
    template<typename InType, typename WorkingDataType, typename SourceDataType>
    void BlendValue(WorkingDataType& OutBlend, InType InValue, float Weight, EMovieSceneBlendType BlendType, TMovieSceneInitialValueStore<SourceDataType>& InitialValueStore)
    {
        BlendValue(OutBlend, InValue, Weight, BlendType, INDEX_NONE, InitialValueStore);
    }
    //new optional blending priority that supports blending priorities
    template<typename InType, typename WorkingDataType, typename SourceDataType>
    void BlendValue(WorkingDataType& OutBlend, InType InValue, float Weight, EMovieSceneBlendType BlendType, int32 BlendingOrder, TMovieSceneInitialValueStore<SourceDataType>& InitialValueStore)
    {
    
    }
} // namespace MovieScene
} // namespace UE
 
template<typename DataType> struct TBlendableTokenTraits { typedef DataType WorkingDataType; };
 
template<typename DataType>
struct TBlendableToken
{
    typedef typename TBlendableTokenTraits<DataType>::WorkingDataType WorkingDataType;
 
    TBlendableToken() = default;
 
    template<typename T>
    TBlendableToken(T&& InValue, EMovieSceneBlendType InBlendType, float InWeight = 1.f, int32 InBlendingOrder = INDEX_NONE)
        : Value(TData<typename TDecay<T>::Type>(Forward<T>(InValue)))
        , HierarchicalBias(0)
        , Weight(InWeight)
        , BlendType(InBlendType)
        , BlendingOrder(InBlendingOrder)
    {}
 
    template<typename T>
    TBlendableToken(T&& InValue, const FMovieSceneEvaluationScope& InCurrentScope, const FMovieSceneContext& InContext, EMovieSceneBlendType InBlendType, float InWeight = 1.f,
        int32 InBlendingOrder = INDEX_NONE)
        : Value(TData<typename TDecay<T>::Type>(Forward<T>(InValue)))
        , AnimatingScope(InCurrentScope)
        , HierarchicalBias(InContext.GetHierarchicalBias())
        , Weight(InWeight)
        , BlendType(InBlendType)
        , BlendingOrder(InBlendingOrder)
 
    {}
 
    TBlendableToken(const TBlendableToken&) = delete;
    TBlendableToken& operator=(const TBlendableToken&) = delete;
 
    TBlendableToken(TBlendableToken&&) = default;
    TBlendableToken& operator=(TBlendableToken&&) = default;
 
    void AddTo(WorkingDataType& CumulativeBlend, TMovieSceneInitialValueStore<DataType>& InitialValueStore) const
    {
        check(Value.IsValid());
        Value->AddTo(CumulativeBlend, Weight, BlendType, BlendingOrder, InitialValueStore);
    }
 
    bool operator<(const TBlendableToken& RHS) const
    {
        return BlendingOrder < RHS.BlendingOrder;
    }
private:
 
    struct IData
    {
        virtual ~IData() {}
        virtual void AddTo(WorkingDataType& CumulativeBlend, float Weight, EMovieSceneBlendType BlendType, int32 BlendingOrder, TMovieSceneInitialValueStore<DataType>& InitialValueStore) const = 0;
    };
 
    template<typename T>
    struct TData : IData
    {
        TData(T In) : Data(MoveTemp(In)) {}
 
        virtual void AddTo(WorkingDataType& CumulativeBlend, float InWeight, EMovieSceneBlendType InBlendType, int32 InBlendingOrder, TMovieSceneInitialValueStore<DataType>& InitialValueStore) const
        {
            // Use the default BlendValue function, or any other BlendValue function found through ADL on WorkingDataType
            using UE::MovieScene::BlendValue;
            if (InBlendingOrder == INDEX_NONE)
            {
                BlendValue(CumulativeBlend, Data, InWeight, InBlendType, InitialValueStore);
            }
            else
            {
                BlendValue(CumulativeBlend, Data, InWeight, InBlendType, InBlendingOrder, InitialValueStore);
            }
        }
 
        T Data;
    };
 
    TInlineValue<IData, sizeof(DataType)> Value;
 
public:
 
    FMovieSceneEvaluationScope AnimatingScope;
 
    int32 HierarchicalBias;
 
    float Weight;
 
    EMovieSceneBlendType BlendType;
 
    int32 BlendingOrder = INDEX_NONE;
 
};