MassCommandBuffer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "MassEntityTypes.h"
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "MassEntityManager.h"
#endif // UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "Misc/MTTransactionallySafeAccessDetector.h"
#include "Misc/TransactionallySafeCriticalSection.h"
#include "MassEntityUtils.h"
#include "MassDebuggerBreakpoints.h"
#include "MassCommands.h"
// required for UE::Mass::Deprecation
#include <type_traits>
#include "Concepts/ConvertibleTo.h"
 
struct FMassEntityManager;
 
//@TODO: Consider debug information in case there is an assert when replaying the command buffer
// (e.g., which system added the command, or even file/line number in development builds for the specific call via a macro)
 
#define COMMAND_PUSHING_CHECK() \
checkf(IsFlushing() == false, TEXT("Trying to push commands is not supported while the given buffer is being flushed")); \
checkf(OwnerThreadId == FPlatformTLS::GetCurrentThreadId(), TEXT("Commands can be pushed only in the same thread where the command buffer was created."))
 
// The following is a temporary construct to help users update their code after FMassBatchedCommand::Execute deprecation
// @todo remove by 5.9
namespace UE::Mass::Deprecation
{
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    template <typename TCommand>
    constexpr bool IsExecuteOverridden()
    {
        using TResolved = decltype(&TCommand::Execute);
        using TBase = decltype(&FMassBatchedCommand::Execute);
        return !std::is_same_v<TResolved, TBase>;
    }
 
    template <typename TCommand>
    requires std::is_base_of_v<FMassBatchedCommand, TCommand>
    struct TOverridesExecute : std::bool_constant<IsExecuteOverridden<TCommand>()>
    {
    };
PRAGMA_ENABLE_DEPRECATION_WARNINGS
}
 
#define ASSERT_EXECUTE_DEPRECATION(CommandType) \
        static_assert(!UE::Mass::Deprecation::TOverridesExecute<CommandType>::value, "Mass Commands: CONST Execute function is deprecated in 5.7 and will be removed by 5.9. Use Run instead.");
 
namespace UE::Mass::Debug
{
 
    template<typename TCommand, typename... Args>
    concept HasCheckBreakpoints =
        requires(Args&&... args) {
            { TCommand::CheckBreakpoints(Forward<Args>(args)...) }
            -> CConvertibleTo<bool>;
    };
 
    template<typename TCommand, typename... Args>
    concept HasCheckBreakpointsWithEntity =
        requires(const FMassEntityHandle Entity, Args&&... args) {
            { TCommand::CheckBreakpoints(Entity, Forward<Args>(args)...) }
            -> CConvertibleTo<bool>;
    };
 
    template<typename TCommand, typename... TArgs>
    void CallCheckBreakpoints(TArgs&&... InArgs)
    {
#if WITH_MASSENTITY_DEBUG
        if constexpr (HasCheckBreakpoints<TCommand, TArgs...>)
        {
            if (TCommand::CheckBreakpoints(Forward<TArgs>(InArgs)...))
            {
                UE::Mass::Debug::FBreakpoint::DebugBreak();
            }
        }
#endif //WITH_MASSENTITY_DEBUG
    }
 
    template<typename TCommand, typename... TArgs >
    void CallCheckBreakpointsByInstance(TArgs&&... InArgs)
    {
#if WITH_MASSENTITY_DEBUG
        if constexpr (HasCheckBreakpointsWithEntity<TCommand, TArgs...>)
        {
            if (TCommand::CheckBreakpointsByInstance(Forward<TArgs>(InArgs)...))
            {
                UE::Mass::Debug::FBreakpoint::DebugBreak();
            }
        }
#endif //WITH_MASSENTITY_DEBUG
    }
} // namespace UE::Mass::Debug
 
 
struct FMassCommandBuffer
{
    MASSENTITY_API FMassCommandBuffer();
    MASSENTITY_API ~FMassCommandBuffer();
 
    template< template<typename... TArgs> typename TCommand, typename... TArgs >
    void PushCommand(const FMassEntityHandle Entity, TArgs&&... InArgs)
    {
        COMMAND_PUSHING_CHECK();
        UE::Mass::Debug::CallCheckBreakpointsByInstance<TCommand<TArgs...>>(Entity, Forward<TArgs>(InArgs)...);
 
        LLM_SCOPE_BYNAME(TEXT("Mass/PushCommand"));
        TCommand<TArgs...>& Instance = CreateOrAddCommand<TCommand<TArgs...>>();
        Instance.Add(Entity, Forward<TArgs>(InArgs)...);
        ++ActiveCommandsCounter;
    }
 
    template<typename TCommand, typename... TArgs>
    void PushCommand(TArgs&&... InArgs)
    {
        COMMAND_PUSHING_CHECK();
        UE::Mass::Debug::CallCheckBreakpointsByInstance<TCommand>(Forward<TArgs>(InArgs)...);
 
        LLM_SCOPE_BYNAME(TEXT("Mass/PushCommand"));
        TCommand& Instance = CreateOrAddCommand<TCommand>();
        Instance.Add(Forward<TArgs>(InArgs)...);
        ++ActiveCommandsCounter;
    }
 
    template< typename TCommand>
    void PushCommand(const FMassEntityHandle Entity)
    {
        COMMAND_PUSHING_CHECK();
        UE::Mass::Debug::CallCheckBreakpoints<TCommand>(Entity);
 
        LLM_SCOPE_BYNAME(TEXT("Mass/PushCommand"));
        CreateOrAddCommand<TCommand>().Add(Entity);
        ++ActiveCommandsCounter;
    }
 
    template< typename TCommand>
    void PushCommand(TConstArrayView<FMassEntityHandle> Entities)
    {
        COMMAND_PUSHING_CHECK();
        UE::Mass::Debug::CallCheckBreakpoints<TCommand>(Entities);
 
        LLM_SCOPE_BYNAME(TEXT("Mass/PushCommand"));
        CreateOrAddCommand<TCommand>().Add(Entities);
        ++ActiveCommandsCounter;
    }
 
    void PushUniqueCommand(TUniquePtr<FMassBatchedCommand>&& CommandInstance)
    {
        COMMAND_PUSHING_CHECK();
 
        LLM_SCOPE_BYNAME(TEXT("Mass/PushCommand"));
        UE::TScopeLock Lock(AppendingCommandsCS);
        UE_MT_SCOPED_WRITE_ACCESS(PendingBatchCommandsDetector);
        AppendedCommandInstances.Add(MoveTemp(CommandInstance));
 
        ++ActiveCommandsCounter;
    }
 
    template<typename T>
    void AddFragment(FMassEntityHandle Entity)
    {
        static_assert(UE::Mass::CFragment<T>, MASS_INVALID_FRAGMENT_MSG);
        PushCommand<FMassCommandAddFragmentsInternal<EMassCommandCheckTime::CompileTimeCheck, T>>(Entity);
    }
 
    template<typename T>
    void AddFragment_RuntimeCheck(FMassEntityHandle Entity)
    {
        checkf(UE::Mass::IsA<FMassFragment>(T::StaticStruct()), TEXT(MASS_INVALID_FRAGMENT_MSG_F), *T::StaticStruct()->GetName());
        PushCommand<FMassCommandAddFragmentsInternal<EMassCommandCheckTime::RuntimeCheck, T>>(Entity);
    }
 
    template<typename T>
    void RemoveFragment(FMassEntityHandle Entity)
    {
        static_assert(UE::Mass::CFragment<T>, MASS_INVALID_FRAGMENT_MSG);
        PushCommand<FMassCommandRemoveFragmentsInternal<EMassCommandCheckTime::CompileTimeCheck, T>>(Entity);
    }
 
    template<typename T>
    void RemoveFragment_RuntimeCheck(FMassEntityHandle Entity)
    {
        checkf(UE::Mass::IsA<FMassFragment>(T::StaticStruct()), TEXT(MASS_INVALID_FRAGMENT_MSG_F), *T::StaticStruct()->GetName());
        PushCommand<FMassCommandRemoveFragmentsInternal<EMassCommandCheckTime::RuntimeCheck, T>>(Entity);
    }
 
    template<typename T>
    void AddTag(FMassEntityHandle Entity)
    {
        static_assert(UE::Mass::CTag<T>, "Given struct type is not a valid tag type.");
        PushCommand<FMassCommandAddTagsInternal<EMassCommandCheckTime::CompileTimeCheck, T>>(Entity);
    }
 
    template<typename T>
    void AddTag(TConstArrayView<FMassEntityHandle> Entities)
    {
        static_assert(UE::Mass::CTag<T>, "Given struct type is not a valid tag type.");
        PushCommand<FMassCommandAddTagsInternal<EMassCommandCheckTime::CompileTimeCheck, T>>(Entities);
    }
 
    template<typename T>
    void AddTag_RuntimeCheck(FMassEntityHandle Entity)
    {
        checkf(UE::Mass::IsA<FMassTag>(T::StaticStruct()), TEXT("Given struct type is not a valid tag type."));
        PushCommand<FMassCommandAddTagsInternal<EMassCommandCheckTime::RuntimeCheck, T>>(Entity);
    }
 
    template<typename T>
    void RemoveTag(FMassEntityHandle Entity)
    {
        static_assert(UE::Mass::CTag<T>, "Given struct type is not a valid tag type.");
        PushCommand<FMassCommandRemoveTagsInternal<EMassCommandCheckTime::CompileTimeCheck, T>>(Entity);
    }
 
    template<typename T>
    void RemoveTag(TConstArrayView<FMassEntityHandle> Entities)
    {
        static_assert(UE::Mass::CTag<T>, "Given struct type is not a valid tag type.");
        PushCommand<FMassCommandRemoveTagsInternal<EMassCommandCheckTime::CompileTimeCheck, T>>(Entities);
    }
 
    template<typename T>
    void RemoveTag_RuntimeCheck(FMassEntityHandle Entity)
    {
        checkf(UE::Mass::IsA<FMassTag>(T::StaticStruct()), TEXT("Given struct type is not a valid tag type."));
        PushCommand<FMassCommandRemoveTagsInternal<EMassCommandCheckTime::RuntimeCheck, T>>(Entity);
    }
 
    template<typename TOld, typename TNew>
    void SwapTags(FMassEntityHandle Entity)
    {
        static_assert(UE::Mass::CTag<TOld>, "Given struct type is not a valid tag type.");
        static_assert(UE::Mass::CTag<TNew>, "Given struct type is not a valid tag type.");
        PushCommand<FMassCommandSwapTagsInternal<EMassCommandCheckTime::CompileTimeCheck, TOld, TNew>>(Entity);
    }
 
    template<typename TOld, typename TNew>
    void SwapTags_RuntimeCheck(FMassEntityHandle Entity)
    {
        checkf(UE::Mass::IsA<FMassTag>(TOld::StaticStruct()), TEXT("Given struct type is not a valid tag type."));
        checkf(UE::Mass::IsA<FMassTag>(TNew::StaticStruct()), TEXT("Given struct type is not a valid tag type."));
        PushCommand<FMassCommandSwapTagsInternal<EMassCommandCheckTime::RuntimeCheck, TOld, TNew>>(Entity);
    }
 
    void DestroyEntity(FMassEntityHandle Entity)
    {
        PushCommand<FMassCommandDestroyEntities>(Entity);
    }
 
    void DestroyEntities(TConstArrayView<FMassEntityHandle> InEntitiesToDestroy)
    {
        PushCommand<FMassCommandDestroyEntities>(InEntitiesToDestroy);
    }
 
    void DestroyEntities(TArray<FMassEntityHandle>&& InEntitiesToDestroy)
    {
        PushCommand<FMassCommandDestroyEntities>(MoveTemp(InEntitiesToDestroy));
    }
 
    MASSENTITY_API SIZE_T GetAllocatedSize() const;
 
    MASSENTITY_API void MoveAppend(FMassCommandBuffer& InOutOther);
 
    bool HasPendingCommands() const 
    {
        return ActiveCommandsCounter > 0;
    }
    bool IsFlushing() const { return bIsFlushing; }
 
    void CancelCommands()
    {
        CleanUp();
    }
 
    bool IsInOwnerThread() const
    {
        return OwnerThreadId == FPlatformTLS::GetCurrentThreadId();
    }
 
    void ForceUpdateCurrentThreadID();
 
private:
    friend FMassEntityManager;
 
    template<typename T>
    T& CreateOrAddCommand()
    {
        ASSERT_EXECUTE_DEPRECATION(T);
 
        static_assert(!UE::Mass::Command::TCommandTraits<T>::RequiresUniqueHandling, "This command type needs to be added via PushUniqueCommand");
        const int32 Index = FMassBatchedCommand::GetCommandIndex<T>();
 
        if (CommandInstances.IsValidIndex(Index) == false)
        {
            CommandInstances.AddZeroed(Index - CommandInstances.Num() + 1);
        }
        else if (CommandInstances[Index])
        {
            return (T&)(*CommandInstances[Index].Get());
        }
 
        CommandInstances[Index] = MakeUnique<T>();
        return (T&)(*CommandInstances[Index].Get());
    }
 
    bool Flush(FMassEntityManager& EntityManager);
    MASSENTITY_API void CleanUp();
 
    FTransactionallySafeCriticalSection AppendingCommandsCS;
 
    UE_MT_DECLARE_TS_RW_ACCESS_DETECTOR(PendingBatchCommandsDetector);
    TArray<TUniquePtr<FMassBatchedCommand>> CommandInstances;
    TArray<TUniquePtr<FMassBatchedCommand>> AppendedCommandInstances;
 
    int32 ActiveCommandsCounter = 0;
 
    bool bIsFlushing = false;
 
    uint32 OwnerThreadId;
};
 
#undef COMMAND_PUSHING_CHECK