MovieSceneSharedPlaybackState.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Compilation/MovieSceneCompiledDataID.h"
#include "CoreTypes.h"
#include "EntitySystem/MovieSceneSequenceInstanceHandle.h"
#include "Evaluation/MovieSceneEvaluationOperand.h"
#include "Evaluation/MovieScenePlaybackCapabilities.h"
#include "Evaluation/MovieScenePreAnimatedState.h"
#include "MovieSceneSequenceID.h"
 
#define UE_API MOVIESCENE_API
 
class UMovieSceneSequence;
class FMovieSceneEntitySystemRunner;
class UMovieSceneCompiledDataManager;
class UMovieSceneEntitySystemLinker;
struct FMovieSceneObjectCache;
struct FMovieSceneSequenceHierarchy;
 
namespace UE::MovieScene
{
 
struct FSharedPlaybackStateCreateParams
{
    UObject* PlaybackContext = nullptr;
 
    FRootInstanceHandle RootInstanceHandle;
 
    TObjectPtr<UMovieSceneEntitySystemLinker> Linker;
 
    UMovieSceneCompiledDataManager* CompiledDataManager = nullptr;
};
 
struct FSharedPlaybackState : TSharedFromThis<FSharedPlaybackState>
{
public:
 
    UE_API FSharedPlaybackState(UMovieSceneEntitySystemLinker* InLinker = nullptr);
    UE_API FSharedPlaybackState(
            UMovieSceneSequence& InRootSequence,
            const FSharedPlaybackStateCreateParams& CreateParams);
 
    UE_API ~FSharedPlaybackState();
 
public:
    
    UObject* GetPlaybackContext() const { return WeakPlaybackContext.Get(); }
 
    UMovieSceneSequence* GetRootSequence() const { return WeakRootSequence.Get(); }
 
    UMovieSceneEntitySystemLinker* GetLinker() const { return WeakLinker.Get(); }
 
    TObjectPtr<UMovieSceneCompiledDataManager> GetCompiledDataManager() const { return CompiledDataManager; }
 
    const FRootInstanceHandle& GetRootInstanceHandle() const { return RootInstanceHandle; }
 
    const FMovieSceneCompiledDataID&  GetRootCompiledDataID() const { return RootCompiledDataID; }
 
    const FMovieSceneInstancePreAnimatedState& GetPreAnimatedState() const { return PreAnimatedState; }
 
    FMovieSceneInstancePreAnimatedState& GetPreAnimatedState() { return PreAnimatedState; }
 
public:
 
    // General utility methods
 
    UE_API TSharedPtr<FMovieSceneEntitySystemRunner> GetRunner() const;
 
    UE_API const FMovieSceneSequenceHierarchy* GetHierarchy() const;
    UE_API UMovieSceneSequence* GetSequence(FMovieSceneSequenceIDRef SequenceID) const;
 
    UE_API TArrayView<TWeakObjectPtr<>> FindBoundObjects(const FGuid& ObjectBindingID, FMovieSceneSequenceIDRef SequenceID) const;
 
    UE_API void ClearObjectCaches();
 
public:
 
    FPlaybackCapabilities& GetCapabilities()
    {
#if !UE_BUILD_SHIPPING
        ensureMsgf(IsInGameThread(), 
                TEXT("Playback capabilities aren't meant to be thread-safe. Do not modify or access their container outside of the game thread."));
#endif
        return Capabilities;
    }
 
    const FPlaybackCapabilities& GetCapabilities() const
    {
#if !UE_BUILD_SHIPPING
        ensureMsgf(IsInGameThread(), 
                TEXT("Playback capabilities aren't meant to be thread-safe. Do not modify or access their container outside of the game thread."));
#endif
        return Capabilities;
    }
 
    template<typename T>
    bool HasCapability() const
    {
#if !UE_BUILD_SHIPPING
        ensureMsgf(IsInGameThread(), 
                TEXT("Playback capabilities aren't meant to be thread-safe. Do not modify or access their container outside of the game thread."));
#endif
        return Capabilities.HasCapability<T>();
    }
 
    template<typename T>
    T* FindCapability() const
    {
#if !UE_BUILD_SHIPPING
        ensureMsgf(IsInGameThread(), 
                TEXT("Playback capabilities aren't meant to be thread-safe. Do not modify or access their container outside of the game thread."));
#endif
        return Capabilities.FindCapability<T>();
    }
 
    template<typename T, typename ...ArgTypes>
    T& AddCapability(ArgTypes&&... InArgs)
    {
#if !UE_BUILD_SHIPPING
        ensureMsgf(IsInGameThread(), 
                TEXT("Playback capabilities aren't meant to be thread-safe. Do not modify or access their container outside of the game thread."));
#endif
        T& Cap = Capabilities.AddCapability<T>(Forward<ArgTypes>(InArgs)...);
        MaybeInitialize(Cap);
        return Cap;
    }
 
    template<typename T>
    T& AddCapabilityRaw(T* InPointer)
    {
#if !UE_BUILD_SHIPPING
        ensureMsgf(IsInGameThread(), 
                TEXT("Playback capabilities aren't meant to be thread-safe. Do not modify or access their container outside of the game thread."));
#endif
        T& Cap = Capabilities.AddCapabilityRaw<T>(InPointer);
        MaybeInitialize(Cap);
        return Cap;
    }
 
    template<typename T>
    T& AddCapabilityShared(TSharedRef<T> InSharedRef)
    {
#if !UE_BUILD_SHIPPING
        ensureMsgf(IsInGameThread(), 
                TEXT("Playback capabilities aren't meant to be thread-safe. Do not modify or access their container outside of the game thread."));
#endif
        T& Cap = Capabilities.AddCapabilityShared<T>(InSharedRef);
        MaybeInitialize(Cap);
        return Cap;
    }
 
    template<typename T, typename ...ArgTypes>
    T& SetOrAddCapability(ArgTypes&&... InArgs)
    {
#if !UE_BUILD_SHIPPING
        ensureMsgf(IsInGameThread(), 
                TEXT("Playback capabilities aren't meant to be thread-safe. Do not modify or access their container outside of the game thread."));
#endif
        if (HasCapability<T>())
        {
            T& Cap = Capabilities.OverwriteCapability<T>(Forward<ArgTypes>(InArgs)...);
            MaybeInitialize(Cap);
            return Cap;
        }
        else
        {
            T& Cap = Capabilities.AddCapability<T>(Forward<ArgTypes>(InArgs)...);
            MaybeInitialize(Cap);
            return Cap;
        }
    }
 
    template<typename T, typename ...ArgTypes>
    T& SetOrAddCapabilityRaw(T* InPointer)
    {
#if !UE_BUILD_SHIPPING
        ensureMsgf(IsInGameThread(), 
                TEXT("Playback capabilities aren't meant to be thread-safe. Do not modify or access their container outside of the game thread."));
#endif
        if (HasCapability<T>())
        {
            T& Cap = Capabilities.OverwriteCapabilityRaw<T>(InPointer);
            MaybeInitialize(Cap);
            return Cap;
        }
        else
        {
            T& Cap = Capabilities.AddCapabilityRaw<T>(InPointer);
            MaybeInitialize(Cap);
            return Cap;
        }
    }
 
    template<typename T, typename ...ArgTypes>
    T& SetOrAddCapabilityShared(TSharedRef<T> InSharedRef)
    {
#if !UE_BUILD_SHIPPING
        ensureMsgf(IsInGameThread(), 
                TEXT("Playback capabilities aren't meant to be thread-safe. Do not modify or access their container outside of the game thread."));
#endif
        if (HasCapability<T>())
        {
            T& Cap = Capabilities.OverwriteCapabilityShared<T>(InSharedRef);
            MaybeInitialize(Cap);
            return Cap;
        }
        else
        {
            T& Cap = Capabilities.AddCapabilityShared<T>(InSharedRef);
            MaybeInitialize(Cap);
            return Cap;
        }
    }
 
public:
 
    UE_API void InvalidateCachedData();
 
#if !UE_BUILD_SHIPPING
    void SetDebugBreakOnDestroy() { bDebugBreakOnDestroy = true; }
#endif
 
private:
 
    template<typename T>
    void MaybeInitialize(T& Cap)
    {
        if constexpr (TPointerIsConvertibleFromTo<T, IPlaybackCapability>::Value)
        {
            IPlaybackCapability* InterfacePtr = static_cast<IPlaybackCapability*>(&Cap);
            InterfacePtr->Initialize(SharedThis(this));
        }
    }
 
private:
 
    TWeakObjectPtr<UMovieSceneSequence> WeakRootSequence;
 
    TWeakObjectPtr<UObject> WeakPlaybackContext;
 
    TWeakObjectPtr<UMovieSceneEntitySystemLinker> WeakLinker;
 
    TObjectPtr<UMovieSceneCompiledDataManager> CompiledDataManager;
 
    FRootInstanceHandle RootInstanceHandle;
 
    FMovieSceneCompiledDataID  RootCompiledDataID;
 
    FPlaybackCapabilities Capabilities;
 
    FMovieSceneInstancePreAnimatedState PreAnimatedState;
 
#if !UE_BUILD_SHIPPING
    bool bDebugBreakOnDestroy = false;
#endif
};
 
} // namespace UE::MovieScene
 
#undef UE_API