MovieSceneEntitySystem.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Async/TaskGraphInterfaces.h"
#include "EntitySystem/MovieSceneEntityIDs.h"
#include "EntitySystem/MovieSceneEntityManager.h"
#include "EntitySystem/MovieSceneEntitySystemTypes.h"
#include "EntitySystem/MovieSceneSequenceInstanceHandle.h"
#include "HAL/Platform.h"
#include "Misc/EnumClassFlags.h"
#include "Stats/Stats.h"
#include "Templates/SubclassOf.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ObjectPtr.h"
#include "UObject/UObjectGlobals.h"
 
#include "MovieSceneEntitySystem.generated.h"
 
class UMovieSceneEntitySystemLinker;
 
namespace UE
{
namespace MovieScene
{
 
    struct FSystemSubsequentTasks;
    struct FSystemTaskPrerequisites;
    class IEntitySystemScheduler;
 
    enum class EEntitySystemCategory : uint32
    {
        // No category
        None = 0,
        // Systems lacking any particular category
        Unspecified = 1u << 0,
        // Core systems, such as the time evaluation system
        Core = 1u << 1,
        // Systems that evaluate channel values
        ChannelEvaluators = 1u << 2,
        // Systems the blend values together
        BlenderSystems = 1u << 3,
        // Systems that set properties on objects
        PropertySystems = 1u << 4,
        // Start of custom categories
        Custom = 1u << 5,
 
        // Last entry, used as error condition
        Last = 1u << 31,
        // All categories
        All = ~0u
    };
    ENUM_CLASS_FLAGS(EEntitySystemCategory)
 
} // namespace MovieScene
} // namespace UE
 
 
UCLASS(MinimalAPI)
class UMovieSceneEntitySystem : public UObject
{
public:
    GENERATED_BODY()
 
 
    template<typename T>
    using TComponentTypeID = UE::MovieScene::TComponentTypeID<T>;
    using FComponentTypeID = UE::MovieScene::FComponentTypeID;
    using FComponentMask   = UE::MovieScene::FComponentMask;
 
    using FSystemTaskPrerequisites = UE::MovieScene::FSystemTaskPrerequisites;
    using FSystemSubsequentTasks   = UE::MovieScene::FSystemSubsequentTasks;
 
    MOVIESCENE_API UMovieSceneEntitySystem(const FObjectInitializer& ObjInit);
    MOVIESCENE_API ~UMovieSceneEntitySystem();
 
    static MOVIESCENE_API void DefineImplicitPrerequisite(TSubclassOf<UMovieSceneEntitySystem> UpstreamSystemType, TSubclassOf<UMovieSceneEntitySystem> DownstreamSystemType);
 
    static MOVIESCENE_API void DefineComponentProducer(TSubclassOf<UMovieSceneEntitySystem> ClassType, FComponentTypeID ComponentType);
 
    static MOVIESCENE_API void DefineComponentConsumer(TSubclassOf<UMovieSceneEntitySystem> ClassType, FComponentTypeID ComponentType);
 
    static MOVIESCENE_API void LinkRelevantSystems(UMovieSceneEntitySystemLinker* InLinker);
 
    static MOVIESCENE_API void LinkCategorySystems(UMovieSceneEntitySystemLinker* InLinker, UE::MovieScene::EEntitySystemCategory InCategory);
 
    static MOVIESCENE_API void LinkAllSystems(UMovieSceneEntitySystemLinker* InLinker);
 
    static MOVIESCENE_API UE::MovieScene::EEntitySystemCategory RegisterCustomSystemCategory();
 
    static MOVIESCENE_API void SortByFlowOrder(TArray<uint16>& InOutGlobalNodeIDs);
 
    static MOVIESCENE_API void GetSubsequentSystems(uint16 FromGlobalNodeID, TArray<uint16>& OutSubsequentGlobalNodeIDs);
 
    static MOVIESCENE_API void PrintFilteredFlowGraph(TArrayView<const TBitArray<>> GroupFilters, FStringBuilderBase& OutString);
 
    static MOVIESCENE_API void DebugPrintGlobalDependencyGraph(bool bUpdateCache = true);
 
public:
 
    UE::MovieScene::EEntitySystemCategory GetCategories() const
    {
        return SystemCategories;
    }
 
    UE::MovieScene::ESystemPhase GetPhase() const
    {
        return Phase;
    }
 
    UMovieSceneEntitySystemLinker* GetLinker() const
    {
        return Linker;
    }
 
    uint16 GetGraphID() const
    {
        return GraphID;
    }
    void SetGraphID(uint16 InGraphID)
    {
        GraphID = InGraphID;
    }
 
    uint16 GetGlobalDependencyGraphID() const
    {
        return GlobalDependencyGraphID;
    }
 
    MOVIESCENE_API void Unlink();
 
    MOVIESCENE_API void Abandon();
 
    MOVIESCENE_API void Link(UMovieSceneEntitySystemLinker* InLinker);
 
    MOVIESCENE_API void SchedulePersistentTasks(UE::MovieScene::IEntitySystemScheduler* Scheduler);
 
    MOVIESCENE_API void Run(FSystemTaskPrerequisites& InPrerequisites, FSystemSubsequentTasks& Subsequents);
 
    MOVIESCENE_API bool IsRelevant(UMovieSceneEntitySystemLinker* InLinker) const;
 
    MOVIESCENE_API void ConditionalLinkSystem(UMovieSceneEntitySystemLinker* InLinker) const;
 
    MOVIESCENE_API void TagGarbage();
 
    MOVIESCENE_API void CleanTaggedGarbage();
 
    MOVIESCENE_API void Enable();
 
    MOVIESCENE_API void Disable();
 
 
    MOVIESCENE_API static bool IsCustomSchedulingEnabled();
 
protected:
 
    MOVIESCENE_API virtual bool IsReadyForFinishDestroy() override;
    MOVIESCENE_API virtual void FinishDestroy() override;
 
private:
 
    virtual void OnLink() {}
 
    virtual void OnSchedulePersistentTasks(UE::MovieScene::IEntitySystemScheduler* TaskScheduler) { }
 
    virtual void OnRun(FSystemTaskPrerequisites& InPrerequisites, FSystemSubsequentTasks& Subsequents) { }
 
    virtual void OnUnlink() {}
 
    MOVIESCENE_API virtual bool IsRelevantImpl(UMovieSceneEntitySystemLinker* InLinker) const;
 
    MOVIESCENE_API virtual void ConditionalLinkSystemImpl(UMovieSceneEntitySystemLinker* InLinker) const;
 
    virtual void OnTagGarbage() {}
 
    virtual void OnCleanTaggedGarbage() {}
 
protected:
 
    UPROPERTY()
    TObjectPtr<UMovieSceneEntitySystemLinker> Linker;
 
protected:
 
    FComponentTypeID RelevantComponent;
 
    UE::MovieScene::ESystemPhase Phase;
 
    uint16 GraphID;
    uint16 GlobalDependencyGraphID;
 
    UE::MovieScene::EEntitySystemCategory SystemCategories;
 
    bool bSystemIsEnabled;
 
#if STATS || ENABLE_STATNAMEDEVENTS
    TStatId StatID;
#endif
};