MovieSceneSequencePlayer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ScriptMacros.h"
#include "IMovieScenePlayer.h"
#include "MovieScene.h"
#include "Evaluation/MovieSceneEvaluationTemplateInstance.h"
#include "IMovieScenePlaybackClient.h"
#include "Misc/QualifiedFrameTime.h"
#include "MovieSceneTimeController.h"
#include "Evaluation/MovieScenePlayback.h"
#include "Evaluation/MovieScenePlayback.h"
#include "MovieSceneSequencePlaybackSettings.h"
#include "MovieSceneSequenceTickManagerClient.h"
#include "MovieSceneSequencePlaybackSettings.h"
#include "MovieSceneLatentActionManager.h"
#include "IMovieSceneSequencePlayerObserver.h"
#include "EntitySystem/MovieSceneEntityIDs.h"
 
#include "MovieSceneSequencePlayer.generated.h"
 
class UMovieSceneSequenceTickManager;
 
namespace UE::MovieScene
{
    class FSequenceWeights;
}
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnMovieSceneSequencePlayerEvent);
DECLARE_DELEGATE(FOnMovieSceneSequencePlayerNativeEvent);
 
UENUM(BlueprintType)
enum class EUpdatePositionMethod : uint8
{
    Play,
    Jump,
    Scrub,
};
 
 
USTRUCT()
struct FMovieSceneSequenceReplProperties
{
    GENERATED_BODY()
 
    FMovieSceneSequenceReplProperties()
        : LastKnownStatus(EMovieScenePlayerStatus::Stopped)
        , LastKnownNumLoops(0)
        , LastKnownSerialNumber(0)
    {}
 
    UPROPERTY()
    FFrameTime LastKnownPosition;
 
    UPROPERTY()
    TEnumAsByte<EMovieScenePlayerStatus::Type> LastKnownStatus;
 
    UPROPERTY()
    int32 LastKnownNumLoops;
 
    UPROPERTY()
    int32 LastKnownSerialNumber;
};
 
 
UENUM(BlueprintType)
enum class EMovieScenePositionType : uint8
{
    Frame,
    Time,
    MarkedFrame,
    Timecode
};
 
USTRUCT(BlueprintType)
struct FMovieSceneSequencePlaybackParams
{
    GENERATED_BODY()
 
    FMovieSceneSequencePlaybackParams()
        : Time(0.f)
        , PositionType(EMovieScenePositionType::Frame)
        , UpdateMethod(EUpdatePositionMethod::Play)
        , bHasJumped(false)
    {}
 
    FMovieSceneSequencePlaybackParams(FFrameTime InFrame, EUpdatePositionMethod InUpdateMethod)
        : Frame(InFrame)
        , Time(0.f)
        , PositionType(EMovieScenePositionType::Frame)
        , UpdateMethod(InUpdateMethod)
        , bHasJumped(false)
    {}
 
    FMovieSceneSequencePlaybackParams(float InTime, EUpdatePositionMethod InUpdateMethod)
        : Time(InTime)
        , PositionType(EMovieScenePositionType::Time)
        , UpdateMethod(InUpdateMethod)
        , bHasJumped(false)
    {}
 
    FMovieSceneSequencePlaybackParams(const FString& InMarkedFrame, EUpdatePositionMethod InUpdateMethod)
        : Time(0.f)
        , MarkedFrame(InMarkedFrame)
        , PositionType(EMovieScenePositionType::MarkedFrame)
        , UpdateMethod(InUpdateMethod)
        , bHasJumped(false)
    {}
 
    FMovieSceneSequencePlaybackParams(const FTimecode& InTimecode, EUpdatePositionMethod InUpdateMethod)
        : Time(0.f)
        , Timecode(InTimecode)
        , PositionType(EMovieScenePositionType::Timecode)
        , UpdateMethod(InUpdateMethod)
        , bHasJumped(false)
    {}
 
    // Get the playback position using the player's tick resolution and display rate    
    MOVIESCENE_API FFrameTime GetPlaybackPosition(UMovieSceneSequencePlayer* Player) const;
 
    // Get the playback position using the sequence's tick resolution and display rate
    MOVIESCENE_API FFrameTime GetPlaybackPosition(UMovieSceneSequence* Sequence) const;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Cinematic", meta=(EditCondition="PositionType == EMovieScenePositionType::Frame"))
    FFrameTime Frame;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Cinematic", meta=(EditCondition="PositionType == EMovieScenePositionType::Time", unit=s))
    float Time;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Cinematic", meta=(EditCondition="PositionType == EMovieScenePositionType::MarkedFrame"))
    FString MarkedFrame;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Cinematic", meta=(EditCondition="PositionType == EMovieScenePositionType::Timecode"))
    FTimecode Timecode;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Cinematic")
    EMovieScenePositionType PositionType;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Cinematic")
    EUpdatePositionMethod UpdateMethod;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Cinematic")
    bool bHasJumped;
};
 
USTRUCT(BlueprintType)
struct FMovieSceneSequencePlayToParams
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Cinematic")
    bool bExclusive = true;
};
 
UCLASS(Abstract, BlueprintType, MinimalAPI)
class UMovieSceneSequencePlayer
    : public UObject
    , public IMovieScenePlayer
    , public IMovieSceneSequenceTickManagerClient
{
public:
    GENERATED_BODY()
 
    
    UPROPERTY(replicated)
    TScriptInterface<IMovieSceneSequencePlayerObserver> Observer;
 
    MOVIESCENE_API UMovieSceneSequencePlayer(const FObjectInitializer&);
    MOVIESCENE_API virtual ~UMovieSceneSequencePlayer();
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API void Play();
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API void PlayReverse();
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API void ChangePlaybackDirection();
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API void PlayLooping(int32 NumLoops = -1);
    
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API void Pause();
    
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API void Scrub();
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API void Stop();
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API void StopAtCurrentTime();
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player", meta = (ToolTip = "Go to end of the sequence and stop. Adheres to 'When Finished' section rules."))
    MOVIESCENE_API void GoToEndAndStop();
 
public:
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API FQualifiedFrameTime GetCurrentTime() const;
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API FQualifiedFrameTime GetDuration() const;
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API int32 GetFrameDuration() const;
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    FFrameRate GetFrameRate() const { return PlayPosition.GetInputRate(); }
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API void SetFrameRate(FFrameRate FrameRate);
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    FQualifiedFrameTime GetStartTime() const { return FQualifiedFrameTime(StartTime, PlayPosition.GetInputRate()); }
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    FQualifiedFrameTime GetEndTime() const { return FQualifiedFrameTime(StartTime + DurationFrames, PlayPosition.GetInputRate()); }
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API void SetWeight(double InWeight);
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API void RemoveWeight();
 
    MOVIESCENE_API void SetWeight(double InWeight, FMovieSceneSequenceID SequenceID);
 
    MOVIESCENE_API void RemoveWeight(FMovieSceneSequenceID SequenceID);
 
public:
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player", DisplayName="Set Play Range (Frames)")
    MOVIESCENE_API void SetFrameRange( int32 StartFrame, int32 Duration, float SubFrames = 0.f );
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player", DisplayName="Set Play Range (Seconds)")
    MOVIESCENE_API void SetTimeRange( float StartTime, float Duration );
 
public:
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API void PlayTo(FMovieSceneSequencePlaybackParams PlaybackParams, FMovieSceneSequencePlayToParams PlayToParams);
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API void SetPlaybackPosition(FMovieSceneSequencePlaybackParams PlaybackParams);
 
    UFUNCTION(BlueprintCallable, Category = "Game|Cinematic")
    MOVIESCENE_API void RestoreState();
 
    UFUNCTION(BlueprintCallable, Category = "Game|Cinematic")
    MOVIESCENE_API void SetCompletionModeOverride(EMovieSceneCompletionModeOverride CompletionModeOverride);
 
    UFUNCTION(BlueprintCallable, Category = "Game|Cinematic")
    MOVIESCENE_API EMovieSceneCompletionModeOverride GetCompletionModeOverride() const;
 
public:
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API bool IsPlaying() const;
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API bool IsPaused() const;
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API bool IsReversed() const;
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API float GetPlayRate() const;
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API void SetPlayRate(float PlayRate);
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API bool GetHideHud() const;
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API void SetHideHud(bool HideHud);
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    void SetDisableCameraCuts(bool bInDisableCameraCuts) { PlaybackSettings.bDisableCameraCuts = bInDisableCameraCuts; }
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    bool GetDisableCameraCuts() { return PlaybackSettings.bDisableCameraCuts; }
 
    DECLARE_EVENT_ThreeParams( UMovieSceneSequencePlayer, FOnMovieSceneSequencePlayerUpdated, const UMovieSceneSequencePlayer&, FFrameTime /*current time*/, FFrameTime /*previous time*/ );
    FOnMovieSceneSequencePlayerUpdated& OnSequenceUpdated() const { return OnMovieSceneSequencePlayerUpdate; }
 
    UPROPERTY(BlueprintAssignable, Category = "Sequencer|Player")
    FOnMovieSceneSequencePlayerEvent OnPlay;
 
    UPROPERTY(BlueprintAssignable, Category = "Sequencer|Player")
    FOnMovieSceneSequencePlayerEvent OnPlayReverse;
 
    UPROPERTY(BlueprintAssignable, Category = "Sequencer|Player")
    FOnMovieSceneSequencePlayerEvent OnStop;
 
    UPROPERTY(BlueprintAssignable, Category = "Sequencer|Player")
    FOnMovieSceneSequencePlayerEvent OnPause;
 
    UPROPERTY(BlueprintAssignable, Category = "Sequencer|Player")
    FOnMovieSceneSequencePlayerEvent OnFinished;
 
    FOnMovieSceneSequencePlayerNativeEvent OnNativeFinished;
 
public:
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API TArray<UObject*> GetBoundObjects(FMovieSceneObjectBindingID ObjectBinding);
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API TArray<FMovieSceneObjectBindingID> GetObjectBindings(UObject* InObject);
 
    /* Invalidates the given binding, forcing it to be refetched. This may be useful for some custom bindings that wish their resolution code to be called again.*/
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API void RequestInvalidateBinding(FMovieSceneObjectBindingID ObjectBinding);
 
public:
 
    MOVIESCENE_API void InitializeForTick(UObject* Context);
 
    MOVIESCENE_API void SetPlaybackSettings(const FMovieSceneSequencePlaybackSettings& InSettings);
 
    MOVIESCENE_API void Initialize(UMovieSceneSequence* InSequence);
 
    MOVIESCENE_API void Initialize(UMovieSceneSequence* InSequence, const FMovieSceneSequencePlaybackSettings& InSettings);
 
    MOVIESCENE_API void Update(const float DeltaSeconds);
 
    MOVIESCENE_API void UpdateAsync(const float DeltaSeconds);
 
    MOVIESCENE_API void TearDown();
 
    MOVIESCENE_API bool IsValid() const;
 
 
public:
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    UMovieSceneSequence* GetSequence() const { return Sequence; }
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    MOVIESCENE_API FString GetSequenceName(bool bAddClientInfo = false) const;
 
    UMovieSceneSequenceTickManager* GetTickManager() const { return TickManager; }
 
    MOVIESCENE_API void SetPlaybackClient(TScriptInterface<IMovieScenePlaybackClient> InPlaybackClient);
 
    MOVIESCENE_API TSharedPtr<FMovieSceneTimeController> GetTimeController() const;
 
    MOVIESCENE_API void SetTimeController(TSharedPtr<FMovieSceneTimeController> InTimeController);
    
 
    MOVIESCENE_API void SetTimeControllerDirectly(TSharedPtr<FMovieSceneTimeController> InTimeController);
 
    MOVIESCENE_API void SetIgnorePlaybackReplication(bool bState);
 
protected:
 
    MOVIESCENE_API void PlayInternal();
    MOVIESCENE_API void StopInternal(FFrameTime TimeToResetTo);
    MOVIESCENE_API void FinishPlaybackInternal(FFrameTime TimeToFinishAt);
 
    struct FMovieSceneUpdateArgs
    {
        bool bHasJumped = false;
        bool bHasLooped = false;
        bool bIsAsync = false;
    };
 
    MOVIESCENE_API void UpdateMovieSceneInstance(FMovieSceneEvaluationRange InRange, EMovieScenePlayerStatus::Type PlayerStatus, bool bHasJumped = false, bool bHasLooped = false);
    MOVIESCENE_API virtual void UpdateMovieSceneInstance(FMovieSceneEvaluationRange InRange, EMovieScenePlayerStatus::Type PlayerStatus, const FMovieSceneUpdateArgs& Args);
 
    MOVIESCENE_API void UpdateTimeCursorPosition(FFrameTime NewPosition, EUpdatePositionMethod Method, bool bHasJumpedOverride = false);
    MOVIESCENE_API bool ShouldStopOrLoop(FFrameTime NewPosition) const;
    MOVIESCENE_API TOptional<TRange<FFrameTime>> GetPauseRange(const FFrameTime& NewPosition) const;
    MOVIESCENE_API TOptional<FFrameTime> GetPauseTimeForNewPosition(const FFrameTime& NewPosition) const;
 
    MOVIESCENE_API UWorld* GetPlaybackWorld() const;
 
    MOVIESCENE_API FFrameTime GetLastValidTime() const;
 
    MOVIESCENE_API FFrameRate GetDisplayRate() const;
 
    MOVIESCENE_API bool NeedsQueueLatentAction() const;
    MOVIESCENE_API void QueueLatentAction(FMovieSceneSequenceLatentActionDelegate Delegate);
    MOVIESCENE_API void RunLatentActions();
 
public:
    //~ IMovieScenePlayer interface
    virtual FMovieSceneRootEvaluationTemplateInstance& GetEvaluationTemplate() override { return RootTemplateInstance; }
 
protected:
    //~ IMovieScenePlayer interface
    MOVIESCENE_API virtual UMovieSceneEntitySystemLinker* ConstructEntitySystemLinker() override;
    MOVIESCENE_API virtual EMovieScenePlayerStatus::Type GetPlaybackStatus() const override;
    MOVIESCENE_API virtual FMovieSceneSpawnRegister& GetSpawnRegister() override;
    virtual UObject* AsUObject() override { return this; }
 
    virtual void SetPlaybackStatus(EMovieScenePlayerStatus::Type InPlaybackStatus) override {}
    virtual void SetViewportSettings(const TMap<FViewportClient*, EMovieSceneViewportParams>& ViewportParamsMap) override {}
    virtual void GetViewportSettings(TMap<FViewportClient*, EMovieSceneViewportParams>& ViewportParamsMap) const override {}
 
    MOVIESCENE_API virtual void ResolveBoundObjects(UE::UniversalObjectLocator::FResolveParams& ResolveParams, const FGuid& InBindingId, FMovieSceneSequenceID SequenceID, UMovieSceneSequence& Sequence, TArray<UObject*, TInlineAllocator<1>>& OutObjects) const override;
    virtual IMovieScenePlaybackClient* GetPlaybackClient() override { return PlaybackClient ? &*PlaybackClient : nullptr; }
    MOVIESCENE_API virtual bool HasDynamicWeighting() const override;
    MOVIESCENE_API virtual void PreEvaluation(const FMovieSceneContext& Context) override;
    MOVIESCENE_API virtual void PostEvaluation(const FMovieSceneContext& Context) override;
 
    virtual TScriptInterface<IMovieSceneSequencePlayerObserver> GetObserver() override { return Observer; }
 
    /*~ Begin UObject interface */
    virtual bool IsSupportedForNetworking() const { return true; }
    MOVIESCENE_API virtual int32 GetFunctionCallspace(UFunction* Function, FFrame* Stack) override;
    MOVIESCENE_API virtual bool CallRemoteFunction(UFunction* Function, void* Parameters, FOutParmRec* OutParms, FFrame* Stack) override;
    MOVIESCENE_API virtual void PostNetReceive() override;
    MOVIESCENE_API virtual void BeginDestroy() override;
    MOVIESCENE_API virtual void RegisterReplicationFragments(UE::Net::FFragmentRegistrationContext& Context, UE::Net::EFragmentRegistrationFlags RegistrationFlags) override;
    /*~ End UObject interface */
 
    //~ Begin IMovieSceneSequenceTickManagerClient interface
    MOVIESCENE_API virtual void TickFromSequenceTickManager(float DeltaSeconds, FMovieSceneEntitySystemRunner* Runner) override;
    //~ End IMovieSceneSequenceTickManagerClient interface
 
protected:
 
    virtual bool CanPlay() const { return true; }
    virtual void OnStartedPlaying() {}
    virtual void OnLooped() {}
    virtual void OnPaused() {}
    virtual void OnStopped() {}
    
private:
    MOVIESCENE_API void StartTimeControllerAndBroadcastPlayState();
 
    MOVIESCENE_API void UpdateTimeCursorPosition_Internal(FFrameTime NewPosition, EUpdatePositionMethod Method, bool bHasJumpedOverride);
 
    MOVIESCENE_API void RunPreEvaluationCallbacks();
    MOVIESCENE_API void RunPostEvaluationCallbacks();
 
    void IncrementServerSerialNumber();
    void AdvanceClientSerialNumberTo(int32 NewSerialNumber);
    
private:
 
    UFUNCTION(netmulticast, reliable)
    MOVIESCENE_API void RPC_ExplicitServerUpdateEvent(EUpdatePositionMethod Method, FFrameTime RelevantTime, int32 NewSerialNumber);
 
    UFUNCTION(netmulticast, reliable)
    MOVIESCENE_API void RPC_OnStopEvent(FFrameTime StoppedTime, int32 NewSerialNumber);
 
    UFUNCTION(netmulticast, reliable)
    MOVIESCENE_API void RPC_OnFinishPlaybackEvent(FFrameTime StoppedTime, int32 NewSerialNumber);
 
    MOVIESCENE_API bool HasAuthority() const;
 
    MOVIESCENE_API void UpdateNetworkSyncProperties();
 
    MOVIESCENE_API FFrameTime UpdateServerTimeSamples();
 
    MOVIESCENE_API void UpdateNetworkSync();
 
    MOVIESCENE_API float GetPing() const;
 
protected:
 
    UPROPERTY()
    TEnumAsByte<EMovieScenePlayerStatus::Type> Status;
 
    UPROPERTY(replicated)
    uint32 bReversePlayback : 1;
 
    uint32 bPendingOnStartedPlaying : 1;
 
    enum class ETimeControllerState
    {
        ReadyToPlay,
        PreparingToPlay
    };
    ETimeControllerState TimeControllerState;
 
    uint32 bIsAsyncUpdate : 1;
 
    uint32 bSkipNextUpdate : 1;
 
    uint32 bUpdateNetSync : 1;
 
    uint32 bWarnZeroDuration : 1;
 
    UPROPERTY(transient)
    TObjectPtr<UMovieSceneSequence> Sequence;
 
    UPROPERTY(replicated)
    FFrameNumber StartTime;
 
    UPROPERTY(replicated)
    int32 DurationFrames;
 
    UPROPERTY(replicated)
    float DurationSubFrames;
 
    UPROPERTY(transient)
    int32 CurrentNumLoops;
 
    UPROPERTY(transient)
    int32 SerialNumber;
 
    UPROPERTY(replicated)
    FMovieSceneSequencePlaybackSettings PlaybackSettings;
 
    UPROPERTY(transient)
    FMovieSceneRootEvaluationTemplateInstance RootTemplateInstance;
 
    FMovieSceneEntitySystemRunner* CurrentRunner;
 
    FMovieScenePlaybackPosition PlayPosition;
 
    TSharedPtr<FMovieSceneSpawnRegister> SpawnRegister;
 
    TUniquePtr<UE::MovieScene::FSequenceWeights> SequenceWeights;
 
    struct FServerTimeSample
    {
        double ServerTime;
        double ReceivedTime;
    };
    TArray<FServerTimeSample> ServerTimeSamples;
 
    /*
    * On UpdateServerTimeSamples, the last recorded time dilation. Used to update the server time samples each update to ensure we can smooth server time even on changing time dilation.
    */
    float LastEffectiveTimeDilation = 1.0f;
 
    UPROPERTY(replicated)
    FMovieSceneSequenceReplProperties NetSyncProps;
 
    UPROPERTY(Transient)
    TScriptInterface<IMovieScenePlaybackClient> PlaybackClient;
 
    UPROPERTY(transient)
    TObjectPtr<UMovieSceneSequenceTickManager> TickManager;
 
    FMovieSceneLatentActionManager LatentActionManager;
 
    TSharedPtr<FMovieSceneTimeController> TimeController;
 
    TSharedPtr<FMovieSceneEntitySystemRunner> SynchronousRunner;
 
    bool bIgnorePlaybackReplication = false;
 
private:
 
    mutable FOnMovieSceneSequencePlayerUpdated OnMovieSceneSequencePlayerUpdate;
 
    TOptional<FMovieSceneSequenceTickInterval> RegisteredTickInterval;
 
    TOptional<double> OldMaxTickRate;
 
    bool bOverridingDynResFrameTimeBudget = false;
 
    TOptional<float> LastTickGameTimeSeconds;
 
    struct FPauseOnArgs
    {
        FFrameTime Time;
        bool bExclusive;
    };
 
    TOptional<FPauseOnArgs> PauseOnFrame;
 
    DECLARE_DELEGATE(FOnEvaluationCallback);
    TArray<FOnEvaluationCallback> PreEvaluationCallbacks;
    TArray<FOnEvaluationCallback> PostEvaluationCallbacks;
};