MovieSceneEntitySystemRunner.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "MovieSceneEntityIDs.h"
#include "MovieSceneSequenceID.h"
#include "Evaluation/MovieScenePlayback.h"
#include "Async/TaskGraphInterfaces.h"
#include "Containers/Array.h"
#include "Delegates/Delegate.h"
#include "EntitySystem/MovieSceneEntitySystemTypes.h"
#include "EntitySystem/MovieSceneSequenceInstance.h"
#include "EntitySystem/MovieSceneSequenceInstanceHandle.h"
#include "Evaluation/MovieScenePlayback.h"
#include "HAL/Platform.h"
#include "MovieSceneEntityIDs.h"
#include "MovieSceneSequenceID.h"
#include "UObject/WeakObjectPtrTemplates.h"
 
class UMovieSceneEntitySystemLinker;
 
namespace UE::MovieScene
{
 
class FEntityManager;
struct FInstanceRegistry;
 
enum class ERunnerFlushState
{
    None                 = 0,           // Signifies no evaluation is currently underway
    Start                = 1 << 0,      // Sets up initial evaluation flags for external players and listeners
    ConditionalRecompile = 1 << 1,      // Conditional recompile of dirtied sequences.
    Import               = 1 << 2,      // Update sequence instances and import entities into the entity manager
    ReimportAfterCompile = 1 << 3,      // Re-update sequence instances after a recompile occurred on a partially evaluated sequence. Not normally run.
    Spawn                = 1 << 4,      // Perform the Spawn phase in the Entity System Graph
    Instantiation        = 1 << 5,      // Perform the Instantiation phase in the Entity System Graph
    Evaluation           = 1 << 6,      // Perform the Evaluation phase in the Entity System Graph
    Finalization         = 1 << 7,      // Perform the Finalization phase in the Entity System Graph and trigger any external events
    EventTriggers        = 1 << 8,      // (re-entrant) Triggers any bound event triggers - skipped by Finalization if the delegate is not bound
    PostEvaluation       = 1 << 9,      // (re-entrant) Call post evaluation callbacks on sequence instances
    End                  = 1 << 10,     // Counterpart for Start - resets external players and listeners
};
ENUM_CLASS_FLAGS(ERunnerFlushState)
 
 
enum class ERunnerUpdateFlags
{
    None           = 0,         // No special behavior - just update the instance along with everything else when the runner is next flushed
    Flush          = 1<<0,      // Indicate that the runner should be completely flushed next update, ignoring any budgets
    Finish         = 1<<1,      // Finish the sequence instance and restore state (if enabled) after this update
    Destroy        = 1<<2,      // Destroy the sequence instance once this request has been fulfilled
 
    FinalDissectionMask = Finish|Destroy, // A mask that includes flags that should only ever be included on final (or non-)dissected updates, not intermediate updates
};
ENUM_CLASS_FLAGS(ERunnerUpdateFlags)
 
 
enum class ERunnerFlushResult
{
    ContinueAllowBudget,
    ContinueNoBudgeting,
    Break,
};
 
} // namespace UE::MovieScene
 
DECLARE_MULTICAST_DELEGATE(FMovieSceneEntitySystemEventTriggers);
 
class FMovieSceneEntitySystemRunner : public TSharedFromThis<FMovieSceneEntitySystemRunner>
{
public:
 
    using FEntityManager = UE::MovieScene::FEntityManager;
    using FInstanceHandle = UE::MovieScene::FInstanceHandle;
    using FInstanceRegistry = UE::MovieScene::FInstanceRegistry;
 
public:
 
    MOVIESCENE_API ~FMovieSceneEntitySystemRunner();
 
    MOVIESCENE_API int32 GetQueuedUpdateCount() const;
    MOVIESCENE_API bool HasQueuedUpdates() const;
    MOVIESCENE_API bool HasQueuedUpdates(FInstanceHandle Instance) const;
    MOVIESCENE_API void QueueUpdate(const FMovieSceneContext& Context, FInstanceHandle Instance, UE::MovieScene::ERunnerUpdateFlags UpdateFlags = UE::MovieScene::ERunnerUpdateFlags::None);
    MOVIESCENE_API void QueueUpdate(const FMovieSceneContext& Context, FInstanceHandle Instance, FSimpleDelegate&& InOnFlushedDelegate, UE::MovieScene::ERunnerUpdateFlags UpdateFlags = UE::MovieScene::ERunnerUpdateFlags::None);
 
    MOVIESCENE_API bool QueueFinalUpdate(FInstanceHandle Instance);
    MOVIESCENE_API bool QueueFinalUpdate(FInstanceHandle Instance, FSimpleDelegate&& InOnLastFlushDelegate);
    MOVIESCENE_API bool QueueFinalUpdateAndDestroy(FInstanceHandle Instance);
    MOVIESCENE_API bool QueueFinalUpdateAndDestroy(FInstanceHandle Instance, FSimpleDelegate&& InOnLastFlushDelegate);
 
    MOVIESCENE_API void AbandonAndDestroyInstance(FInstanceHandle Instance);
    MOVIESCENE_API void AbandonAndDestroyInstance(FInstanceHandle Instance, FSimpleDelegate&& InOnLastFlushDelegate);
 
    MOVIESCENE_API void Flush(double BudgetMs = 0.f, UE::MovieScene::ERunnerFlushState TargetState = UE::MovieScene::ERunnerFlushState::None);
 
    MOVIESCENE_API void FlushOutstanding(double BudgetMs = 0.f, UE::MovieScene::ERunnerFlushState TargetState = UE::MovieScene::ERunnerFlushState::None);
 
    MOVIESCENE_API void ResetFlushState();
 
    MOVIESCENE_API void DiscardQueuedUpdates(FInstanceHandle Instance);
 
    UE::MovieScene::ESystemPhase GetCurrentPhase() const
    {
        return CurrentPhase;
    }
 
    MOVIESCENE_API bool IsCurrentlyEvaluating() const;
 
    MOVIESCENE_API bool IsUpdatingSequence() const;
 
    MOVIESCENE_API bool FlushSingleEvaluationPhase();
 
public:
 
    UMovieSceneEntitySystemLinker* GetLinker() const { return WeakLinker.Get(); }
    bool IsValid() const { return WeakLinker.IsValid(); }
 
    MOVIESCENE_API FEntityManager* GetEntityManager() const;
    MOVIESCENE_API FInstanceRegistry* GetInstanceRegistry() const;
 
public:
 
    UE_DEPRECATED(5.5, "Runners are now owned by linkers, and always attached")
    void AttachToLinker(UMovieSceneEntitySystemLinker* InLinker) {}
    UE_DEPRECATED(5.5, "Runners are now owned by linkers, and always attached")
    bool IsAttachedToLinker() const { return IsValid(); }
    UE_DEPRECATED(5.5, "Runners are now owned by linkers, and always attached")
    void DetachFromLinker() {}
 
public:
    
    // Internal API
 
    void MarkForUpdate(FInstanceHandle InInstanceHandle, UE::MovieScene::ERunnerUpdateFlags UpdateFlags);
    MOVIESCENE_API FMovieSceneEntitySystemEventTriggers& GetQueuedEventTriggers();
 
    FMovieSceneEntitySystemRunner();
    FMovieSceneEntitySystemRunner(UMovieSceneEntitySystemLinker* InLinker);
 
private:
 
    MOVIESCENE_API bool QueueFinalUpdateImpl(FInstanceHandle Instance, FSimpleDelegate&& InOnLastFlushDelegate, bool bDestroyInstance);
 
    MOVIESCENE_API UE::MovieScene::ERunnerFlushResult FlushNext(UMovieSceneEntitySystemLinker* Linker);
 
    MOVIESCENE_API UE::MovieScene::ERunnerFlushResult StartEvaluation(UMovieSceneEntitySystemLinker* Linker);
 
    MOVIESCENE_API UE::MovieScene::ERunnerFlushResult GameThread_ConditionalRecompile(UMovieSceneEntitySystemLinker* Linker);
    MOVIESCENE_API UE::MovieScene::ERunnerFlushResult GameThread_UpdateSequenceInstances(UMovieSceneEntitySystemLinker* Linker);
    MOVIESCENE_API UE::MovieScene::ERunnerFlushResult GameThread_ReimportSequenceInstances(UMovieSceneEntitySystemLinker* Linker);
    MOVIESCENE_API UE::MovieScene::ERunnerFlushResult GameThread_SpawnPhase(UMovieSceneEntitySystemLinker* Linker);
    MOVIESCENE_API UE::MovieScene::ERunnerFlushResult GameThread_InstantiationPhase(UMovieSceneEntitySystemLinker* Linker);
    MOVIESCENE_API UE::MovieScene::ERunnerFlushResult GameThread_PostInstantiation(UMovieSceneEntitySystemLinker* Linker);
    MOVIESCENE_API UE::MovieScene::ERunnerFlushResult GameThread_EvaluationPhase(UMovieSceneEntitySystemLinker* Linker);
    MOVIESCENE_API void GameThread_EvaluationFinalizationPhase(UMovieSceneEntitySystemLinker* Linker);
    MOVIESCENE_API void GameThread_EventTriggerPhase(UMovieSceneEntitySystemLinker* Linker);
    MOVIESCENE_API void GameThread_PostEvaluationPhase(UMovieSceneEntitySystemLinker* Linker);
 
    MOVIESCENE_API void EndEvaluation(UMovieSceneEntitySystemLinker* Linker);
 
    MOVIESCENE_API void EnterFlushState(UE::MovieScene::ERunnerFlushState EnteredFlushState);
 
    MOVIESCENE_API void SkipFlushState(UE::MovieScene::ERunnerFlushState FlushStateToSkip);
 
private:
 
    friend struct FMovieSceneEntitySystemEvaluationReentrancyWindow;
 
    struct FDissectedUpdate
    {
        FSimpleDelegate OnFlushed;
        FMovieSceneContext Context;
 
        FInstanceHandle InstanceHandle;
        int32 Order;
        UE::MovieScene::ERunnerUpdateFlags UpdateFlags = UE::MovieScene::ERunnerUpdateFlags::None;
    };
 
    TWeakObjectPtr<UMovieSceneEntitySystemLinker> WeakLinker;
 
    struct FQueuedUpdateParams
    {
        FInstanceHandle InstanceHandle;
        UE::MovieScene::ERunnerUpdateFlags UpdateFlags = UE::MovieScene::ERunnerUpdateFlags::None;
    };
    struct FUpdateParamsAndContext
    {
        FSimpleDelegate OnFlushed;
        FMovieSceneContext Context;
        FQueuedUpdateParams Params;
    };
    TArray<FUpdateParamsAndContext> UpdateQueue;
 
    TArray<FQueuedUpdateParams> CurrentInstances;
    TArray<FDissectedUpdate> DissectedUpdates;
    TArray<FSimpleDelegate> OnFlushedDelegates;
    FMovieSceneEntitySystemEventTriggers EventTriggers;
    UE::MovieScene::ESequenceInstanceUpdateFlags AccumulatedUpdateFlags;
 
    uint32 ReentrancyCount;
 
    ENamedThreads::Type GameThread;
 
    UE::MovieScene::ESystemPhase CurrentPhase;
 
    UE::MovieScene::ERunnerFlushState FlushState;
 
    UE::MovieScene::ERunnerFlushState CurrentFlushState;
 
    bool bCanQueueEventTriggers;
 
    bool bRequireFullFlush;
 
    bool bIsUpdatingSequence;
};