MovieSceneAccumulatedBlendState.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Evaluation/Blending/BlendableToken.h"
#include "Evaluation/Blending/BlendableTokenStack.h"
#include "Evaluation/Blending/MovieSceneBlendingActuatorID.h"
#include "Evaluation/MovieSceneAnimTypeID.h"
#include "Evaluation/MovieSceneEvaluationScope.h"
#include "HAL/Platform.h"
#include "Misc/AssertionMacros.h"
#include "Misc/InlineValue.h"
#include "MovieSceneFwd.h"
#include "Templates/TypeHash.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/ObjectKey.h"
 
class IMovieScenePlayer;
class UObject;
struct FMovieSceneEvaluationOperand;
 
typedef TInlineValue<IBlendableTokenStack, 64> FActuatorTokenStackPtr;
 
struct FMovieSceneBlendingKey
{
    UObject* ObjectPtr;
 
    FMovieSceneBlendingActuatorID ActuatorType;
 
    friend uint32 GetTypeHash(const FMovieSceneBlendingKey& InKey)
    {
        return GetTypeHash(InKey.ObjectPtr) ^ GetTypeHash(InKey.ActuatorType);
    }
 
    friend bool operator==(const FMovieSceneBlendingKey& A, const FMovieSceneBlendingKey& B)
    {
        return A.ObjectPtr == B.ObjectPtr && A.ActuatorType == B.ActuatorType;
    }
};
 
struct FMovieSceneAccumulatedBlendState
{
public:
    FMovieSceneAccumulatedBlendState() = default;
 
    FMovieSceneAccumulatedBlendState(const FMovieSceneAccumulatedBlendState&) = delete;
    FMovieSceneAccumulatedBlendState& operator=(const FMovieSceneAccumulatedBlendState&) = delete;
 
    FMovieSceneAccumulatedBlendState(FMovieSceneAccumulatedBlendState&&) = default;
    FMovieSceneAccumulatedBlendState& operator=(FMovieSceneAccumulatedBlendState&&) = default;
 
    template<typename DataType>
    void Add(FMovieSceneBlendingActuatorID InActuatorType, TBlendableToken<DataType>&& InToken)
    {
        TokensToBlend.Emplace(TTokenEntry<DataType>(InActuatorType, MoveTemp(InToken)));
    }
 
    MOVIESCENE_API void Consolidate(TMap<FMovieSceneBlendingKey, FActuatorTokenStackPtr>& InOutBlendState, FMovieSceneEvaluationOperand InOperand, IMovieScenePlayer& Player);
 
    MOVIESCENE_API void Consolidate(TMap<FMovieSceneBlendingKey, FActuatorTokenStackPtr>& InOutBlendState);
 
    void Reset()
    {
        TokensToBlend.Reset();
    }
 
private:
 
    struct FTokenEntry
    {
        virtual ~FTokenEntry() {}
 
        virtual void Consolidate(FActuatorTokenStackPtr& OutStack) = 0;
 
        FMovieSceneBlendingActuatorID GetActuatorID() const
        {
            return ActuatorTypeID;
        }
 
        FMovieSceneAnimTypeID GetDataTypeID() const
        {
            return DataTypeID;
        }
 
    protected:
 
        FTokenEntry(FMovieSceneBlendingActuatorID InActuatorTypeID, FMovieSceneAnimTypeID InDataTypeID)
            : ActuatorTypeID(InActuatorTypeID), DataTypeID(InDataTypeID)
        {}
        FMovieSceneBlendingActuatorID ActuatorTypeID;
        FMovieSceneAnimTypeID DataTypeID;
    };
 
    template<typename DataType>
    struct TTokenEntry : FTokenEntry
    {
        TTokenEntry(FMovieSceneBlendingActuatorID InActuatorTypeID, TBlendableToken<DataType>&& InToken)
            : FTokenEntry(InActuatorTypeID, GetBlendingDataType<DataType>())
            , Token(MoveTemp(InToken))
        {}
 
        virtual void Consolidate(FActuatorTokenStackPtr& OutStack) override final
        {
            // Attempt to find an existing stack for this actuator
            if (!OutStack.IsValid())
            {
                OutStack = TBlendableTokenStack<DataType>();
            }
 
            // Ensure that the stack is operating on the same data type.
            // If this ensure fires, something has added a token with an actuator ID where that actuator doesn't operate the data type that was addded
            // For example:
            //      // MyActuator knows how to apply a float
            //      struct FMyActuator : TMovieSceneBlendingActuator<float>
            //      {...};
            //
            //      Accumulator.DefineActuator(FMyActuator::GetActuatorTypeID(), TUniquePtr<IMovieSceneBlendingActuator>(new FMyActuator));
            //      // OK - constructing a float token for a float actuator
            //      ExecutionTokens.BlendToken(FMyActuator::GetActuatorTypeID(), TBlendableToken<float>(1.f, ...));
            //      // OK - constructing a float token out of another type for a float actuator
            //      ExecutionTokens.BlendToken(FMyActuator::GetActuatorTypeID(), TBlendableToken<float>(FCompoundType(), ...));
            //      // Assert - data type mismatch - cannot associate a TBlendableToken<int32> with an actuator ID that operates on a float
            //      ExecutionTokens.BlendToken(FMyActuator::GetActuatorTypeID(), TBlendableToken<int32>(1.f, ...));
 
            if (ensureMsgf(OutStack->DataTypeID == DataTypeID, TEXT("Data type mismatch between actuators of the same ID")))
            {
                // static_cast should be safe now that we've verified the data type matches
                TBlendableTokenStack<DataType>& TypedStack = static_cast<TBlendableTokenStack<DataType>&>(OutStack.GetValue());
 
                // Add a pointer to this token to the stack to blend
                TypedStack.AddToken(&Token);
            }
        }
 
        TBlendableToken<DataType> Token;
    };
 
    TArray<TInlineValue<FTokenEntry, 128>> TokensToBlend;
};