IMovieSceneTaskScheduler.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Stats/Stats.h"
#include "Misc/TVariant.h"
#include "EntitySystem/RelativePtr.h"
#include "EntitySystem/MovieSceneEntitySystemTypes.h"
#include "EntitySystem/EntityAllocationIterator.h"
 
namespace UE::MovieScene
{
 
using FPreLockedDataPtr = TRelativePtr<void, uint32>;
 
struct FTaskID
{
    int32 Index;
 
    explicit FTaskID()
        : Index(INDEX_NONE)
    {}
 
    explicit FTaskID(int32 InIndex)
        : Index(InIndex)
    {}
 
    static FTaskID None()
    {
        return FTaskID(INDEX_NONE);
    }
 
    explicit operator bool() const
    {
        return Index != INDEX_NONE;
    }
};
 
struct FTaskParams
{
    explicit FTaskParams(const TStatId& InStatId)
        :
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
        DebugName(nullptr),
#endif
        StatId(InStatId)
    {
        bForceGameThread = false;
        bSerialTasks = false;
        bForcePropagateDownstream = false;
        bForceConsumeUpstream = false;
        bForcePrePostTask = false;
    }
 
    explicit FTaskParams(const TCHAR* InDebugName, const TStatId& InStatId = TStatId())
        : 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
        DebugName(InDebugName), 
#endif
        StatId(InStatId)
    {
        bForceGameThread = false;
        bSerialTasks = false;
        bForcePropagateDownstream = false;
        bForceConsumeUpstream = false;
        bForcePrePostTask = false;
    }
 
    FTaskParams& Stat(const TStatId& InStatId)
    {
        StatId = InStatId;
        return *this;
    }
 
    FTaskParams& ForceGameThread()
    {
        bForceGameThread = true;
        return *this;
    }
 
    FTaskParams& ForcePrePostTask()
    {
        bForcePrePostTask = true;
        return *this;
    }
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    const TCHAR* DebugName;
#endif
    TStatId StatId;
    uint8 bForceGameThread : 1;
    uint8 bSerialTasks : 1;
    uint8 bForcePrePostTask : 1;
    uint8 bForcePropagateDownstream : 1;
    uint8 bForceConsumeUpstream : 1;
};
 
 
struct ITaskContext
{
    virtual ~ITaskContext() {}
};
 
template<typename TaskType>
struct TAnonTaskWrapper : ITaskContext
{
    TaskType Task;
 
    template<typename ...ArgTypes>
    explicit TAnonTaskWrapper(ArgTypes&&... InArgs)
        : Task{ Forward<ArgTypes>(InArgs)... }
    {}
 
    static void Execute(const ITaskContext* Context, FEntityAllocationWriteContext WriteContext)
    {
        static_cast<const TAnonTaskWrapper<TaskType>*>(Context)->Task.Run(WriteContext);
    }
};
 
template<typename ClassType>
struct TMemberFunctionTaskWrapper : ITaskContext
{
    using MemberFunctionPtr = void (ClassType::*)();
 
    ClassType* ClassPtr;
    MemberFunctionPtr FunctionPtr;
 
    explicit TMemberFunctionTaskWrapper(ClassType* InClassPtr, MemberFunctionPtr InFunctionPtr)
        : ClassPtr(InClassPtr)
        , FunctionPtr(InFunctionPtr)
    {}
 
    static void Execute(const ITaskContext* Context, FEntityAllocationWriteContext WriteContext)
    {
        const TMemberFunctionTaskWrapper<ClassType>* This = static_cast<const TMemberFunctionTaskWrapper<ClassType>*>(Context);
        (This->ClassPtr->*This->FunctionPtr)();
    }
};
 
 
using UnboundTaskFunctionPtr             = void (*)(const ITaskContext* TaskContext, FEntityAllocationWriteContext WriteContext);
using AllocationFunctionPtr              = void (*)(const FEntityAllocation* Allocation, const ITaskContext* TaskContext, FEntityAllocationWriteContext WriteContext);
using AllocationItemFunctionPtr          = void (*)(FEntityAllocationIteratorItem Item, const ITaskContext* TaskContext, FEntityAllocationWriteContext WriteContext);
using PreLockedAllocationItemFunctionPtr = void (*)(FEntityAllocationIteratorItem Item, TArrayView<const FPreLockedDataPtr> PreLockedData, const ITaskContext* TaskContext, FEntityAllocationWriteContext WriteContext);
 
using TaskFunctionPtr = TVariant<UnboundTaskFunctionPtr, AllocationFunctionPtr, AllocationItemFunctionPtr, PreLockedAllocationItemFunctionPtr>;
 
class IEntitySystemScheduler
{
public:
 
    template<typename TaskType, typename ...TaskArgTypes>
    FTaskID AddTask(const FTaskParams& InParams, TaskArgTypes&&... Args)
    {
        TaskFunctionPtr Function(TInPlaceType<UnboundTaskFunctionPtr>(), TAnonTaskWrapper<TaskType>::Execute);
        return AddTask(InParams, MakeShared<TAnonTaskWrapper<TaskType>>(Forward<TaskArgTypes>(Args)...), Function);
    }
 
    template<typename TaskType>
    FTaskID AddMemberFunctionTask(const FTaskParams& InParams, TaskType* Instance, typename TMemberFunctionTaskWrapper<TaskType>::MemberFunctionPtr FunctionPtr)
    {
        TaskFunctionPtr Function(TInPlaceType<UnboundTaskFunctionPtr>(), TMemberFunctionTaskWrapper<TaskType>::Execute);
        return AddTask(InParams, MakeShared<TMemberFunctionTaskWrapper<TaskType>>(Instance, FunctionPtr), Function);
    }
 
    MOVIESCENE_API FTaskID AddNullTask();
 
    MOVIESCENE_API FTaskID AddTask(const FTaskParams& InParams, TSharedPtr<ITaskContext> InTaskContext, TaskFunctionPtr InTaskFunction);
 
    MOVIESCENE_API FTaskID CreateForkedAllocationTask(const FTaskParams& InParams, TSharedPtr<ITaskContext> InTaskContext, TaskFunctionPtr InTaskFunction, TFunctionRef<void(FEntityAllocationIteratorItem,TArray<FPreLockedDataPtr>&)> InPreLockFunc, const FEntityComponentFilter& Filter, const FComponentMask& ReadDeps, const FComponentMask& WriteDeps);
 
    MOVIESCENE_API void AddPrerequisite(FTaskID Prerequisite, FTaskID Subsequent);
 
    MOVIESCENE_API void AddChildBack(FTaskID Parent, FTaskID Child);
 
    MOVIESCENE_API void AddChildFront(FTaskID Parent, FTaskID Child);
 
private:
    friend class FEntitySystemScheduler;
    IEntitySystemScheduler() = default;
};
 
 
} // namespace UE::MovieScene