MovieSceneEntitySystemLinker.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "MovieSceneEntityIDs.h"
#include "MovieSceneSequenceID.h"
#include "Engine/World.h"
#include "Evaluation/MovieScenePlayback.h"
#include "EntitySystem/MovieSceneEntityManager.h"
#include "EntitySystem/MovieSceneInstanceRegistry.h"
#include "Tickable.h"
#include "UObject/ObjectKey.h"
#include "Async/TaskGraphInterfaces.h"
#include "EntitySystem/MovieSceneEntitySystemTypes.h"
#include "EntitySystem/MovieSceneEntitySystemGraphs.h"
#include "EntitySystem/MovieSceneSequenceInstance.h"
#include "EntitySystem/MovieSceneEntitySystemLinkerExtension.h"
#include "Evaluation/PreAnimatedState/MovieScenePreAnimatedStateExtension.h"
 
#include "MovieSceneEntitySystemLinker.generated.h"
 
class FMovieSceneEntitySystemRunner;
class UMovieSceneEntitySystem;
class UMovieSceneCompiledDataManager;
 
namespace UE
{
namespace MovieScene
{
 
    struct FComponentRegistry;
    enum class ERunnerFlushState;
    enum class EEntitySystemCategory : uint32;
 
    enum class EAutoLinkRelevantSystems : uint8
    {
        Enabled,
        Disable,
    };
 
    enum class EEntitySystemLinkerRole : uint32
    {
        Unknown = 0,
        LevelSequences = 1,
        CameraAnimations,
        UMG,
        Standalone,
        Interrogation,
        Custom
    };
 
    MOVIESCENE_API EEntitySystemLinkerRole RegisterCustomEntitySystemLinkerRole();
 
    struct FSystemFilter
    {
        MOVIESCENE_API FSystemFilter();
 
        template<typename SystemClass>
        bool CheckSystem() const
        {
            return CheckSystem(SystemClass::StaticClass());
        }
 
        MOVIESCENE_API bool CheckSystem(TSubclassOf<UMovieSceneEntitySystem> InClass) const;
        MOVIESCENE_API bool CheckSystem(const UMovieSceneEntitySystem* InSystem) const;
 
        MOVIESCENE_API void SetAllowedCategories(EEntitySystemCategory InCategory);
        MOVIESCENE_API void AllowCategory(EEntitySystemCategory InCategory);
        MOVIESCENE_API void SetDisallowedCategories(EEntitySystemCategory InCategory);
        MOVIESCENE_API void DisallowCategory(EEntitySystemCategory InCategory);
 
        MOVIESCENE_API void AllowSystem(TSubclassOf<UMovieSceneEntitySystem> InClass);
        MOVIESCENE_API void DisallowSystem(TSubclassOf<UMovieSceneEntitySystem> InClass);
 
    private:
        UE::MovieScene::EEntitySystemCategory CategoriesAllowed;
        UE::MovieScene::EEntitySystemCategory CategoriesDisallowed;
        TBitArray<> SystemsAllowed;
        TBitArray<> SystemsDisallowed;
    };
 
}
}
 
DECLARE_MULTICAST_DELEGATE_OneParam(FMovieSceneEntitySystemLinkerEvent, UMovieSceneEntitySystemLinker*);
DECLARE_MULTICAST_DELEGATE_TwoParams(FMovieSceneEntitySystemLinkerAROEvent, UMovieSceneEntitySystemLinker*, FReferenceCollector&);
DECLARE_MULTICAST_DELEGATE_TwoParams(FMovieSceneEntitySystemLinkerWorldEvent, UMovieSceneEntitySystemLinker*, UWorld*);
DECLARE_MULTICAST_DELEGATE_OneParam(FMovieSceneEntitySystemLinkerPostSpawnEvent, UMovieSceneEntitySystemLinker*);
 
UCLASS(MinimalAPI)
class UMovieSceneEntitySystemLinker
    : public UObject
{
public:
 
    template<typename T>
    using TComponentTypeID    = UE::MovieScene::TComponentTypeID<T>;
    using FEntityManager      = UE::MovieScene::FEntityManager;
    using FComponentTypeID    = UE::MovieScene::FComponentTypeID;
    using FInstanceHandle     = UE::MovieScene::FInstanceHandle;
    using FMovieSceneEntityID = UE::MovieScene::FMovieSceneEntityID;
    using FInstanceRegistry   = UE::MovieScene::FInstanceRegistry;
    using FComponentRegistry  = UE::MovieScene::FComponentRegistry;
 
    FEntityManager EntityManager;
 
    UPROPERTY()
    FMovieSceneEntitySystemGraph SystemGraph;
 
public:
 
    GENERATED_BODY()
 
    UE::MovieScene::FPreAnimatedStateExtension PreAnimatedState;
 
    MOVIESCENE_API UMovieSceneEntitySystemLinker(const FObjectInitializer& ObjInit);
 
    static MOVIESCENE_API FComponentRegistry* GetComponents();
 
    static MOVIESCENE_API UMovieSceneEntitySystemLinker* FindOrCreateLinker(UObject* PreferredOuter, UE::MovieScene::EEntitySystemLinkerRole LinkerRole, const TCHAR* Name = TEXT("DefaultMovieSceneEntitySystemLinker"));
    static MOVIESCENE_API UMovieSceneEntitySystemLinker* CreateLinker(UObject* PreferredOuter, UE::MovieScene::EEntitySystemLinkerRole LinkerRole);
 
    FInstanceRegistry* GetInstanceRegistry()
    {
        check(InstanceRegistry.IsValid());
        return InstanceRegistry.Get();
    }
 
    const FInstanceRegistry* GetInstanceRegistry() const
    {
        check(InstanceRegistry.IsValid());
        return InstanceRegistry.Get();
    }
 
    template<typename SystemType>
    SystemType* LinkSystem()
    {
        return CastChecked<SystemType>(LinkSystem(SystemType::StaticClass()));
    }
 
    template<typename SystemType>
    SystemType* LinkSystemIfAllowed()
    {
        return Cast<SystemType>(LinkSystemIfAllowed(SystemType::StaticClass()));
    }
 
    template<typename SystemType>
    SystemType* FindSystem() const
    {
        return CastChecked<SystemType>(FindSystem(SystemType::StaticClass()), ECastCheckedType::NullAllowed);
    }
 
    MOVIESCENE_API UMovieSceneEntitySystem* LinkSystem(TSubclassOf<UMovieSceneEntitySystem> InClassType);
    MOVIESCENE_API UMovieSceneEntitySystem* LinkSystemIfAllowed(TSubclassOf<UMovieSceneEntitySystem> InClassType);
 
    MOVIESCENE_API UMovieSceneEntitySystem* FindSystem(TSubclassOf<UMovieSceneEntitySystem> Class) const;
 
    static MOVIESCENE_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
 
    UE::MovieScene::FSystemFilter& GetSystemFilter()
    {
        return SystemFilter;
    }
 
    UE::MovieScene::EEntitySystemLinkerRole GetLinkerRole() const
    {
        return Role;
    }
 
    void SetLinkerRole(UE::MovieScene::EEntitySystemLinkerRole InRole)
    {
        Role = InRole;
    }
 
    MOVIESCENE_API void Reset();
 
    virtual UWorld* GetWorld() const override { return WeakWorld.IsValid() ? WeakWorld.Get() : Super::GetWorld(); }
 
    void SetWorld(UWorld* InWorld) { WeakWorld = InWorld; }
 
public:
 
    template<typename ExtensionType>
    static UE::MovieScene::TEntitySystemLinkerExtensionID<ExtensionType> RegisterExtension()
    {
        return UE::MovieScene::TEntitySystemLinkerExtensionID<ExtensionType>(RegisterExtension().ID);
    }
 
    template<typename ExtensionType>
    void AddExtension(UE::MovieScene::TEntitySystemLinkerExtensionID<ExtensionType> InID, ExtensionType* InExtension)
    {
        const int32 Index = InID.ID;
        if (!ExtensionsByID.IsValidIndex(Index))
        {
            ExtensionsByID.Insert(Index, InExtension);
        }
        else
        {
            check(ExtensionsByID[Index] == InExtension);
        }
    }
 
    template<typename ExtensionType>
    void AddExtension(ExtensionType* InExtension)
    {
        AddExtension(ExtensionType::GetExtensionID(), InExtension);
    }
 
    template<typename ExtensionType>
    ExtensionType* FindExtension(UE::MovieScene::TEntitySystemLinkerExtensionID<ExtensionType> InID) const
    {
        const int32 Index = InID.ID;
        if (ExtensionsByID.IsValidIndex(Index))
        {
            return static_cast<ExtensionType*>(ExtensionsByID[Index]);
        }
 
        return nullptr;
    }
 
 
    template<typename ExtensionType>
    ExtensionType* FindExtension() const
    {
        const int32 Index = ExtensionType::GetExtensionID().ID;
        if (ExtensionsByID.IsValidIndex(Index))
        {
            return static_cast<ExtensionType*>(ExtensionsByID[Index]);
        }
 
        return nullptr;
    }
 
 
    void RemoveExtension(UE::MovieScene::FEntitySystemLinkerExtensionID ExtensionID)
    {
        const int32 Index = ExtensionID.ID;
        if (ExtensionsByID.IsValidIndex(Index))
        {
            ExtensionsByID.RemoveAt(Index);
        }
    }
 
public:
 
    // Internal API
    
    MOVIESCENE_API void SystemLinked(UMovieSceneEntitySystem* InSystem);
    MOVIESCENE_API void SystemUnlinked(UMovieSceneEntitySystem* InSystem);
 
    MOVIESCENE_API bool HasLinkedSystem(const uint16 GlobalDependencyGraphID);
 
    MOVIESCENE_API void LinkRelevantSystems();
    MOVIESCENE_API void UnlinkIrrelevantSystems();
    MOVIESCENE_API void AutoLinkRelevantSystems();
    MOVIESCENE_API void AutoUnlinkIrrelevantSystems();
 
    MOVIESCENE_API bool HasStructureChangedSinceLastRun() const;
 
    MOVIESCENE_API void InvalidateObjectBinding(const FGuid& ObjectBindingID, FInstanceHandle InstanceHandle);
    MOVIESCENE_API void CleanupInvalidBoundObjects();
 
    MOVIESCENE_API bool StartEvaluation();
    MOVIESCENE_API TSharedRef<FMovieSceneEntitySystemRunner> GetRunner() const;
    MOVIESCENE_API void PostInstantation();
    MOVIESCENE_API void EndEvaluation();
 
    MOVIESCENE_API void ResetRunner();
 
    MOVIESCENE_API void DestroyInstanceImmediately(UE::MovieScene::FRootInstanceHandle Instance);
 
    UE_DEPRECATED(5.5, "Please use GetRunner()")
    FMovieSceneEntitySystemRunner* GetActiveRunner() const { return &GetRunner().Get(); }
 
private:
 
    MOVIESCENE_API UMovieSceneEntitySystem* LinkSystemImpl(TSubclassOf<UMovieSceneEntitySystem> InClassType);
 
    MOVIESCENE_API void HandlePreGarbageCollection();
    MOVIESCENE_API void HandlePostGarbageCollection();
 
    MOVIESCENE_API void TagInvalidBoundObjects();
    MOVIESCENE_API void CleanGarbage();
 
    MOVIESCENE_API void OnWorldCleanup(UWorld* InWorld, bool bSessionEnded, bool bCleanupResources);
    MOVIESCENE_API void OnObjectsReplaced(const TMap<UObject*, UObject*>& ReplacementMap);
 
    MOVIESCENE_API virtual void BeginDestroy() override;
 
    static MOVIESCENE_API UE::MovieScene::FEntitySystemLinkerExtensionID RegisterExtension();
 
private:
 
    TUniquePtr<FInstanceRegistry> InstanceRegistry;
 
    TSparseArray<UMovieSceneEntitySystem*> EntitySystemsByGlobalGraphID;
    TMap<TObjectPtr<UClass>, TObjectPtr<UMovieSceneEntitySystem>> EntitySystemsRecyclingPool;
 
    TSharedPtr<FMovieSceneEntitySystemRunner> Runner;
    TBitArray<> RunnerReentrancyFlags;
 
    TSparseArray<void*> ExtensionsByID;
 
    friend struct FMovieSceneEntitySystemEvaluationReentrancyWindow;
 
public:
 
    struct
    {
        FMovieSceneEntitySystemLinkerPostSpawnEvent PostSpawnEvent;
        FMovieSceneEntitySystemLinkerEvent          TagGarbage;
        FMovieSceneEntitySystemLinkerEvent          CleanTaggedGarbage;
        FMovieSceneEntitySystemLinkerAROEvent       AddReferencedObjects;
        FMovieSceneEntitySystemLinkerEvent          AbandonLinker;
    } Events;
 
private:
 
    uint64 LastSystemLinkVersion;
    uint64 LastSystemUnlinkVersion;
    uint64 LastInstantiationVersion;
 
    TWeakPtr<bool> GlobalStateCaptureToken;
    TWeakObjectPtr<UWorld> WeakWorld;
 
protected:
 
    UE::MovieScene::EEntitySystemLinkerRole Role;
    UE::MovieScene::EAutoLinkRelevantSystems AutoLinkMode;
    UE::MovieScene::FSystemFilter SystemFilter;
};