IMovieScenePlayer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Misc/Guid.h"
#include "Containers/ArrayView.h"
#include "Misc/InlineValue.h"
 
#include "EntitySystem/MovieSceneSharedPlaybackState.h"
#include "Evaluation/IMovieScenePlaybackCapability.h"
#include "Evaluation/MovieSceneAnimTypeID.h"
#include "Evaluation/MovieSceneEvaluationOperand.h"
#include "Evaluation/MovieSceneEvaluationState.h"
#include "Evaluation/MovieScenePreAnimatedState.h"
#include "Evaluation/SequenceDirectorPlaybackCapability.h"
#include "MovieSceneSpawnRegister.h"
 
enum class EMovieSceneBuiltInEasing : uint8;
 
struct FMovieSceneContext;
class UMovieSceneSequence;
class FViewportClient;
class IMovieScenePlaybackClient;
class UMovieSceneEntitySystemLinker;
struct FMovieSceneRootEvaluationTemplateInstance;
class FMovieSceneSequenceInstance;
class IMovieScenePlayer;
class IMovieSceneSequencePlayerObserver;
struct EMovieSceneViewportParams;
 
namespace UE::MovieScene
{
    enum class ESequenceInstanceUpdateFlags : uint8;
    struct FSharedPlaybackState;
 
    struct FPlayerIndexPlaybackCapability
    {
        UE_DECLARE_MOVIESCENE_PLAYBACK_CAPABILITY_API(MOVIESCENE_API, FPlayerIndexPlaybackCapability)
 
        static MOVIESCENE_API IMovieScenePlayer* GetPlayer(TSharedRef<const FSharedPlaybackState> Owner);
        static MOVIESCENE_API uint16 GetPlayerIndex(TSharedRef<const FSharedPlaybackState> Owner);
 
        FPlayerIndexPlaybackCapability(uint16 InPlayerIndex)
            : PlayerIndex(InPlayerIndex)
        {}
 
        uint16 PlayerIndex = (uint16)-1;
    };
}
 
struct FMovieSceneCameraCutParams
{
    UObject* UnlockIfCameraObject = nullptr;
    bool bJumpCut = false;
 
    float BlendTime = -1.f;
    TOptional<EMovieSceneBuiltInEasing> BlendType;
 
    UObject* PreviousCameraObject = nullptr;
 
    float PreviewBlendFactor = -1.f;
 
    bool bLockPreviousCamera = false;
    
    bool bCanBlend = false;
};
 
using EMovieSceneCameraCutParams = FMovieSceneCameraCutParams; 
 
class IMovieScenePlayer 
    : public UE::MovieScene::IObjectBindingNotifyPlaybackCapability
{
public:
    MOVIESCENE_API IMovieScenePlayer();
 
    MOVIESCENE_API virtual ~IMovieScenePlayer();
 
    virtual FMovieSceneRootEvaluationTemplateInstance& GetEvaluationTemplate() = 0;
 
    virtual UMovieSceneEntitySystemLinker* ConstructEntitySystemLinker() { return nullptr; }
 
    virtual UObject* AsUObject() { return nullptr; }
 
    /*
     * Set the perspective viewport settings
     *
     * @param ViewportParamMap A map from the viewport client to its settings
     */
    UE_DEPRECATED(5.5, "Viewport settings management has moved to FViewportSettingsPlaybackCapability")
    virtual void SetViewportSettings(const TMap<FViewportClient*, EMovieSceneViewportParams>& ViewportParamsMap) {}
 
    /*
     * Get the current perspective viewport settings
     *
     * @param ViewportParamMap A map from the viewport client to its settings
     */
    UE_DEPRECATED(5.5, "Viewport settings management has moved to FViewportSettingsPlaybackCapability")
    virtual void GetViewportSettings(TMap<FViewportClient*, EMovieSceneViewportParams>& ViewportParamsMap) const {}
 
    virtual EMovieScenePlayerStatus::Type GetPlaybackStatus() const = 0;
 
    virtual void SetPlaybackStatus(EMovieScenePlayerStatus::Type InPlaybackStatus) = 0;
 
    UE_DEPRECATED(5.4, "Please either call IMovieScenePlayer::FindBoundObjects, FMovieSceneObjectBindingID::ResolveBoundObjects, or FMovieSceneEvaluationState::FindBoundObjects")
    MOVIESCENE_API virtual void ResolveBoundObjects(const FGuid& InBindingId, FMovieSceneSequenceID SequenceID, UMovieSceneSequence& Sequence, UObject* ResolutionContext, TArray<UObject*, TInlineAllocator<1>>& OutObjects) const;
 
    virtual IMovieScenePlaybackClient* GetPlaybackClient() { return nullptr; }
 
    const IMovieScenePlaybackClient* GetPlaybackClient() const { return const_cast<IMovieScenePlayer*>(this)->GetPlaybackClient(); }
 
    virtual FMovieSceneSpawnRegister& GetSpawnRegister() { return NullRegister; }
 
    /*
     * Called when an object is spawned by sequencer
     * 
     */
    virtual void OnObjectSpawned(UObject* InObject, const FMovieSceneEvaluationOperand& Operand) {}
 
    virtual void NotifyBindingUpdate(const FGuid& InGuid, FMovieSceneSequenceIDRef InSequenceID, TArrayView<TWeakObjectPtr<>> Objects) override { NotifyBindingsChanged(); }
 
    virtual void NotifyBindingsChanged() override {}
 
    FMovieSceneEvaluationOperand* GetBindingOverride(const FMovieSceneEvaluationOperand& InOperand);
 
    void AddBindingOverride(const FMovieSceneEvaluationOperand& InOperand, const FMovieSceneEvaluationOperand& InOverrideOperand);
 
    void RemoveBindingOverride(const FMovieSceneEvaluationOperand& InOperand);
 
    UE_DEPRECATED(5.4, "Director instances are now automanaged via FSequenceDirectorPlaybackCapability")
    void ResetDirectorInstances();
 
    UE_DEPRECATED(5.4, "Director instances are now automanaged via FSequenceDirectorPlaybackCapability")
    UObject* GetOrCreateDirectorInstance(TSharedRef<const UE::MovieScene::FSharedPlaybackState> SharedPlaybackState, FMovieSceneSequenceIDRef SequenceID);
 
    MOVIESCENE_API virtual void PopulateUpdateFlags(UE::MovieScene::ESequenceInstanceUpdateFlags& OutFlags);
 
    virtual UObject* GetPlaybackContext() const { return nullptr; }
 
    MOVIESCENE_API virtual TArray<UObject*> GetEventContexts() const;
 
    MOVIESCENE_API virtual bool IsDisablingEventTriggers(FFrameTime& DisabledUntilTime) const;
 
    virtual bool IsPreview() const { return false; }
 
    virtual bool HasDynamicWeighting() const { return false; }
 
    virtual void PreEvaluation(const FMovieSceneContext& Context) {}
 
    virtual void PostEvaluation(const FMovieSceneContext& Context) {}
 
    /*
    * Used to access the Observer in MovieSceneSequencePlayer
    */
    virtual TScriptInterface<IMovieSceneSequencePlayerObserver> GetObserver() { return nullptr; }
 
    /*
    * Attempts to create a binding for the given object in the given sequence.
    */
    MOVIESCENE_API virtual FGuid CreateBinding(UMovieSceneSequence* InSequence, UObject* InObject);
 
public:
 
    MOVIESCENE_API TArrayView<TWeakObjectPtr<>> FindBoundObjects(const FGuid& ObjectBindingID, FMovieSceneSequenceIDRef SequenceID);
 
    TArrayView<TWeakObjectPtr<>> FindBoundObjects(const FMovieSceneEvaluationOperand& Operand)
    {
        return FindBoundObjects(Operand.ObjectBindingID, Operand.SequenceID);
    }
 
    FGuid FindObjectId(UObject& InObject, FMovieSceneSequenceIDRef SequenceID)
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return State.FindObjectId(InObject, SequenceID, GetSharedPlaybackState());
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    FGuid FindCachedObjectId(UObject& InObject, FMovieSceneSequenceIDRef SequenceID)
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return State.FindCachedObjectId(InObject, SequenceID, GetSharedPlaybackState());
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    inline void SavePreAnimatedState(UObject& InObject, FMovieSceneAnimTypeID InTokenType, const IMovieScenePreAnimatedTokenProducer& InProducer)
    {
        PreAnimatedState.SavePreAnimatedState(InObject, InTokenType, InProducer);
    }
 
    inline void SavePreAnimatedState(FMovieSceneAnimTypeID InTokenType, const IMovieScenePreAnimatedGlobalTokenProducer& InProducer)
    {
        PreAnimatedState.SavePreAnimatedState(InTokenType, InProducer);
    }
 
    void RestorePreAnimatedState()
    {
        PreAnimatedState.RestorePreAnimatedState();
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        State.ClearObjectCaches(GetSharedPlaybackState());
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    void DiscardPreAnimatedState()
    {
        PreAnimatedState.DiscardPreAnimatedState();
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        State.ClearObjectCaches(GetSharedPlaybackState());
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    MOVIESCENE_API void InvalidateCachedData();
 
    MOVIESCENE_API static IMovieScenePlayer* Get(uint16 InUniqueIndex);
 
    MOVIESCENE_API static void Get(TArray<IMovieScenePlayer*>& OutPlayers, bool bOnlyUnstoppedPlayers);
 
    MOVIESCENE_API static void SetIsEvaluatingFlag(uint16 InUniqueIndex, bool bIsUpdating);
 
    MOVIESCENE_API bool IsEvaluating() const;
 
    MOVIESCENE_API TSharedPtr<UE::MovieScene::FSharedPlaybackState> FindSharedPlaybackState();
    MOVIESCENE_API TSharedPtr<const UE::MovieScene::FSharedPlaybackState> FindSharedPlaybackState() const;
    MOVIESCENE_API TSharedRef<UE::MovieScene::FSharedPlaybackState> GetSharedPlaybackState();
    MOVIESCENE_API TSharedRef<const UE::MovieScene::FSharedPlaybackState> GetSharedPlaybackState() const;
 
    uint16 GetUniqueIndex() const
    {
        return UniqueIndex;
    }
 
public:
 
    MOVIESCENE_API virtual void InitializeRootInstance(TSharedRef<UE::MovieScene::FSharedPlaybackState> NewSharedPlaybackState);
 
public:
 
    UE_DEPRECATED(5.4, "Camera cut management has moved to UMovieSceneCameraCutTrackInstance")
    virtual bool CanUpdateCameraCut() const { return true; }
 
    UE_DEPRECATED(5.4, "Camera cut management has moved to UMovieSceneCameraCutTrackInstance")
    virtual void UpdateCameraCut(UObject* CameraObject, UObject* UnlockIfCameraObject = nullptr, bool bJumpCut = false)
    {
        EMovieSceneCameraCutParams CameraCutParams;
        CameraCutParams.UnlockIfCameraObject = UnlockIfCameraObject;
        CameraCutParams.bJumpCut = bJumpCut;
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        UpdateCameraCut(CameraObject, CameraCutParams);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UE_DEPRECATED(5.4, "Camera cut management has moved to UMovieSceneCameraCutTrackInstance")
    virtual void UpdateCameraCut(UObject* CameraObject, const EMovieSceneCameraCutParams& CameraCutParams) {}
 
protected:
 
    friend struct FMovieSceneObjectCache;
    MOVIESCENE_API virtual void ResolveBoundObjects(UE::UniversalObjectLocator::FResolveParams& ResolveParams, const FGuid& InBindingId, FMovieSceneSequenceID SequenceID, UMovieSceneSequence& Sequence, TArray<UObject*, TInlineAllocator<1>>& OutObjects) const;
 
public:
 
    MOVIESCENE_API FMovieSceneEvaluationState* GetEvaluationState();
 
    MOVIESCENE_API UE::MovieScene::IStaticBindingOverridesPlaybackCapability* GetStaticBindingOverrides();
 
public:
 
    UE_DEPRECATED(5.6, "Please use GetEvaluationState().")
    FMovieSceneEvaluationState State;
 
    FMovieScenePreAnimatedState PreAnimatedState;
 
    UE_DEPRECATED(5.6, "Please use GetStaticBindingOverrides().")
    TMap<FMovieSceneEvaluationOperand, FMovieSceneEvaluationOperand>& BindingOverrides;
 
private:
 
    FNullMovieSceneSpawnRegister NullRegister;
 
    UE::MovieScene::FStaticBindingOverrides StaticBindingOverrides;
 
    uint16 UniqueIndex;
};