MovieSceneExecutionTokens.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 "CoreMinimal.h"
#include "Evaluation/Blending/BlendableToken.h"
#include "Evaluation/Blending/MovieSceneBlendingAccumulator.h"
#include "Evaluation/Blending/MovieSceneBlendingActuatorID.h"
#include "Evaluation/MovieSceneEvaluationKey.h"
#include "Evaluation/MovieSceneEvaluationOperand.h"
#include "Evaluation/MovieSceneEvaluationScope.h"
#include "Evaluation/MovieScenePlayback.h"
#include "Evaluation/PersistentEvaluationData.h"
#include "HAL/Platform.h"
#include "Misc/AssertionMacros.h"
#include "Misc/FrameRate.h"
#include "Misc/FrameTime.h"
#include "Misc/InlineValue.h"
#include "MovieSceneExecutionToken.h"
#include "MovieSceneFwd.h"
#include "Templates/EnableIf.h"
#include "Templates/PointerIsConvertibleFromTo.h"
#include "Templates/RemoveReference.h"
#include "Templates/UnrealTemplate.h"
 
class IMovieScenePlayer;
 
 
struct FMovieSceneExecutionTokens
{
    FMovieSceneExecutionTokens()
        : Context(FMovieSceneEvaluationRange(FFrameTime(0), FFrameRate()), EMovieScenePlayerStatus::Stopped)
    {
    }
 
    FMovieSceneExecutionTokens(const FMovieSceneExecutionTokens&) = delete;
    FMovieSceneExecutionTokens& operator=(const FMovieSceneExecutionTokens&) = delete;
 
    FMovieSceneExecutionTokens(FMovieSceneExecutionTokens&&) = default;
    FMovieSceneExecutionTokens& operator=(FMovieSceneExecutionTokens&&) = default;
 
    template<typename T>
    inline typename TEnableIf<TPointerIsConvertibleFromTo<typename TRemoveReference<T>::Type, const IMovieSceneExecutionToken>::Value>::Type Add(T&& InToken)
    {
        check(Scope.Key.IsValid() && Operand.IsValid());
        OrderedTokens.Add(FEntry(Operand, Scope, Context, Forward<T>(InToken)));
    }
 
    template<typename T>
    inline typename TEnableIf<TPointerIsConvertibleFromTo<typename TRemoveReference<T>::Type, const IMovieSceneSharedExecutionToken>::Value>::Type AddShared(FMovieSceneSharedDataId ID, T&& InToken)
    {
        checkf(!SharedTokens.Contains(ID), TEXT("Already added a shared token of this type"));
        SharedTokens.Add(ID, MoveTemp(InToken));
    }
 
    IMovieSceneSharedExecutionToken* FindShared(FMovieSceneSharedDataId ID)
    {
        auto* Existing = SharedTokens.Find(ID);
        return Existing ? Existing->GetPtr() : nullptr;
    }
 
public:
 
    FMovieSceneBlendingAccumulator& GetBlendingAccumulator()
    {
        return BlendingAccumulator;
    }
 
    const FMovieSceneBlendingAccumulator& GetBlendingAccumulator() const
    {
        return BlendingAccumulator;
    }
 
    template<typename ActuatorDataType>
    void BlendToken(FMovieSceneBlendingActuatorID InActuatorTypeID, TBlendableToken<ActuatorDataType>&& InToken)
    {
        BlendingAccumulator.BlendToken(Operand, InActuatorTypeID, Scope, Context, MoveTemp(InToken));
    }
 
    MOVIESCENE_API void Apply(const FMovieSceneContext& RootContext, IMovieScenePlayer& Player);
 
public:
 
    inline void SetOperand(const FMovieSceneEvaluationOperand& InOperand)
    {
        Operand = InOperand;
    }
 
    inline void SetCurrentScope(const FMovieSceneEvaluationScope& InScope)
    {
        Scope = InScope;
    }
 
    inline void SetContext(const FMovieSceneContext& InContext)
    {
        Context = InContext;
    }
 
    inline FMovieSceneEvaluationScope GetCurrentScope() const
    {
        return Scope;
    }
 
private:
 
    struct FEntry
    {
        FEntry(const FMovieSceneEvaluationOperand& InOperand, const FMovieSceneEvaluationScope& InScope, const FMovieSceneContext& InContext, TInlineValue<IMovieSceneExecutionToken, 64>&& InToken)
            : Operand(InOperand)
            , Scope(InScope)
            , Context(InContext)
            , Token(MoveTemp(InToken))
        {
        }
 
        FEntry(FEntry&&) = default;
        FEntry& operator=(FEntry&&) = default;
 
        FMovieSceneEvaluationOperand Operand;
        FMovieSceneEvaluationScope Scope;
        FMovieSceneContext Context;
        TInlineValue<IMovieSceneExecutionToken, 64> Token;
    };
 
    TArray<FEntry> OrderedTokens;
 
    TMap<FMovieSceneSharedDataId, TInlineValue<IMovieSceneSharedExecutionToken, 32>> SharedTokens;
 
    FMovieSceneBlendingAccumulator BlendingAccumulator;
 
    FMovieSceneEvaluationOperand Operand;
    FMovieSceneEvaluationScope Scope;
    FMovieSceneContext Context;
};