MassExecutionContext.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
 
#include "MassEntityHandle.h"
#include "MassEntityTypes.h"
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "MassExternalSubsystemTraits.h"
#endif // UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "MassEntityQuery.h"
#include "MassArchetypeTypes.h"
#include "MassSubsystemAccess.h"
#include "MassProcessor.h"
 
 
#define CHECK_IF_VALID(View, Type) \
    checkf(View \
        , TEXT("Requested fragment type not bound, type %s. Make sure it has been listed as required."), *GetNameSafe(Type))
 
#define CHECK_IF_READWRITE(View) \
    checkf(View == nullptr || View->Requirement.AccessMode == EMassFragmentAccess::ReadWrite \
        , TEXT("Requested fragment type not bound for writing, type %s. Make sure it has been listed as required in ReadWrite mode.") \
        , View ? *GetNameSafe(View->Requirement.StructType) : TEXT("[Not found]"))
 
struct FMassEntityQuery;
 
struct FMassExecutionContext
{
private:
 
    template< typename ViewType >
    struct TFragmentView 
    {
        FMassFragmentRequirementDescription Requirement;
        ViewType FragmentView;
 
        TFragmentView() {}
        explicit TFragmentView(const FMassFragmentRequirementDescription& InRequirement) : Requirement(InRequirement) {}
 
        bool operator==(const UScriptStruct* FragmentType) const { return Requirement.StructType == FragmentType; }
    };
    using FFragmentView = TFragmentView<TArrayView<FMassFragment>>;
    TArray<FFragmentView, TInlineAllocator<8>> FragmentViews;
 
    using FChunkFragmentView = TFragmentView<FStructView>;
    TArray<FChunkFragmentView, TInlineAllocator<4>> ChunkFragmentViews;
 
    using FConstSharedFragmentView = TFragmentView<FConstStructView>;
    TArray<FConstSharedFragmentView, TInlineAllocator<4>> ConstSharedFragmentViews;
 
    using FSharedFragmentView = TFragmentView<FStructView>;
    TArray<FSharedFragmentView, TInlineAllocator<4>> SharedFragmentViews;
 
    FMassSubsystemAccess SubsystemAccess;
    
    // mz@todo make this shared ptr thread-safe and never auto-flush in MT environment. 
    TSharedPtr<FMassCommandBuffer> DeferredCommandBuffer;
    TArrayView<FMassEntityHandle> EntityListView;
    
    FMassArchetypeEntityCollection EntityCollection;
    
    FInstancedStruct AuxData;
    float DeltaTimeSeconds = 0.0f;
    int32 ChunkSerialModificationNumber = -1;
    FMassArchetypeCompositionDescriptor CurrentArchetypeCompositionDescriptor;
#if WITH_MASSENTITY_DEBUG
    FColor DebugColor;
#endif // WITH_MASSENTITY_DEBUG
 
    TSharedRef<FMassEntityManager> EntityManager;
 
    struct FQueryTransientRuntime
    {
        TNotNull<FMassEntityQuery*> Query;
        FMassExternalSubsystemBitSet ConstSubsystemsBitSet;
        FMassExternalSubsystemBitSet MutableSubsystemsBitSet;
#if WITH_MASSENTITY_DEBUG
        static constexpr uint32 MaxFragmentBreakpointCount = 8;
        TStaticArray<const UScriptStruct*, MaxFragmentBreakpointCount> FragmentTypesToBreakOn;
 
        bool bCheckProcessorBreaks = false;
        int32 BreakFragmentsCount = 0;
#endif // WITH_MASSENTITY_DEBUG
 
        uint32 IteratorSerialNumber = 0;
 
        static FQueryTransientRuntime& GetDummyInstance();
    };
 
    TArray<FQueryTransientRuntime, TInlineAllocator<2>> QueriesStack;
 
    uint32 IteratorSerialNumberGenerator = 0;
 
#if WITH_MASSENTITY_DEBUG
    FString DebugExecutionDescription;
 
    // js@todo make this more generic
    TWeakObjectPtr<UMassProcessor> DebugProcessor;
#endif // WITH_MASSENTITY_DEBUG
    
    bool bFlushDeferredCommands = true;
 
    TArrayView<FFragmentView> GetMutableRequirements() { return FragmentViews; }
    TArrayView<FChunkFragmentView> GetMutableChunkRequirements() { return ChunkFragmentViews; }
    TArrayView<FConstSharedFragmentView> GetMutableConstSharedRequirements() { return ConstSharedFragmentViews; }
    TArrayView<FSharedFragmentView> GetMutableSharedRequirements() { return SharedFragmentViews; }
 
    void GetSubsystemRequirementBits(FMassExternalSubsystemBitSet& OutConstSubsystemsBitSet, FMassExternalSubsystemBitSet& OutMutableSubsystemsBitSet)
    {
        SubsystemAccess.GetSubsystemRequirementBits(OutConstSubsystemsBitSet, OutMutableSubsystemsBitSet);
    }
 
    void SetSubsystemRequirementBits(const FMassExternalSubsystemBitSet& InConstSubsystemsBitSet, const FMassExternalSubsystemBitSet& InMutableSubsystemsBitSet)
    {
        SubsystemAccess.SetSubsystemRequirementBits(InConstSubsystemsBitSet, InMutableSubsystemsBitSet);
    }
 
    EMassExecutionContextType ExecutionType = EMassExecutionContextType::Local;
 
    friend FMassArchetypeData;
 
    FMassExecutionContext& operator=(const FMassExecutionContext& Other) = default;
 
public:
    MASSENTITY_API explicit FMassExecutionContext(FMassEntityManager& InEntityManager, const float InDeltaTimeSeconds = 0.f, const bool bInFlushDeferredCommands = true);
    FMassExecutionContext(FMassExecutionContext&& Other) = default;
    MASSENTITY_API FMassExecutionContext(const FMassExecutionContext& Other);
    MASSENTITY_API FMassExecutionContext(const FMassExecutionContext& Other, FMassEntityQuery& Query, const TSharedPtr<FMassCommandBuffer>& InCommandBuffer = {});
    MASSENTITY_API ~FMassExecutionContext();
 
    MASSENTITY_API static FMassExecutionContext& GetDummyInstance();
 
    FMassEntityManager& GetEntityManagerChecked() const;
    const TSharedRef<FMassEntityManager>& GetSharedEntityManager();
 
#if WITH_MASSENTITY_DEBUG
    const FString& DebugGetExecutionDesc() const { return DebugExecutionDescription; }
    void DebugSetExecutionDesc(const FString& Description) { DebugExecutionDescription = Description; }
    void DebugSetExecutionDesc(FString&& Description) { DebugExecutionDescription = MoveTemp(Description); }
 
    UMassProcessor* DebugGetProcessor() const { return DebugProcessor.Get(); }
    void DebugSetProcessor(UMassProcessor* Processor) { DebugProcessor = Processor; }
#endif
 
    void PushQuery(FMassEntityQuery& InQuery);
    void PopQuery(const FMassEntityQuery& InQuery);
    const FMassEntityQuery& GetCurrentQuery() const;
    bool IsCurrentQuery(const FMassEntityQuery& Query) const;
    void ApplyFragmentRequirements(const FMassEntityQuery& RequestingQuery);
    void ClearFragmentViews(const FMassEntityQuery& RequestingQuery);
 
    struct FEntityIterator
    {
        inline int32 operator*() const
        {
            return EntityIndex;
        }
 
        inline bool operator!=(const int& Other) const
        {
            return EntityIndex != Other;
        }
 
        inline operator int32() const
        {
            return EntityIndex;
        }
 
        inline operator bool() const
        {
            return SerialNumber && EntityIndex < NumEntities;
        }
 
        inline bool operator<(const int32 Other) const
        {
            return SerialNumber && EntityIndex != INDEX_NONE && EntityIndex < Other;
        }
 
        inline FEntityIterator& operator++()
        {
            ++EntityIndex;
#if WITH_MASSENTITY_DEBUG
            if (UNLIKELY(QueryRuntime.bCheckProcessorBreaks || QueryRuntime.BreakFragmentsCount != 0) 
                && EntityIndex < NumEntities)
            {
                TestBreakpoints();
            }
#endif //WITH_MASSENTITY_DEBUG
            return *this;
        }
 
        inline void operator++(int)
        {
            ++(*this);
        }
 
        FEntityIterator&& begin()
        {
            return MoveTemp(*this);
        }
 
        FEntityIterator end() const
        {
            FEntityIterator End;
            End.EntityIndex = NumEntities;
            return End;
        }
 
        MASSENTITY_API FEntityIterator();
        FEntityIterator(FEntityIterator&&) = default;
 
        FEntityIterator& operator=(const FEntityIterator&) = delete;
        FEntityIterator& operator=(FEntityIterator&&) = delete;
        FEntityIterator(const FEntityIterator&) = delete;
 
    private:
        friend FMassExecutionContext;
        FEntityIterator(FMassExecutionContext& InExecutionContext);
        FEntityIterator(FMassExecutionContext& InExecutionContext, FQueryTransientRuntime& InQueryRuntime);
 
#if WITH_MASSENTITY_DEBUG
        MASSENTITY_API void TestBreakpoints();
#endif 
 
        const FMassExecutionContext& ExecutionContext;
        const FQueryTransientRuntime& QueryRuntime;
        int32 EntityIndex = INDEX_NONE;
        const int32 NumEntities = INDEX_NONE;
        const uint32 SerialNumber = 0;
    };
 
    MASSENTITY_API FEntityIterator CreateEntityIterator();
 
    void SetFlushDeferredCommands(const bool bNewFlushDeferredCommands);
    void SetDeferredCommandBuffer(const TSharedPtr<FMassCommandBuffer>& InDeferredCommandBuffer);
    MASSENTITY_API void SetEntityCollection(const FMassArchetypeEntityCollection& InEntityCollection);
    MASSENTITY_API void SetEntityCollection(FMassArchetypeEntityCollection&& InEntityCollection);
    void ClearEntityCollection();
    void SetAuxData(const FInstancedStruct& InAuxData);
 
    void SetExecutionType(EMassExecutionContextType InExecutionType);
    EMassExecutionContextType GetExecutionType() const;
 
    float GetDeltaTimeSeconds() const;
 
    MASSENTITY_API UWorld* GetWorld();
 
    TSharedPtr<FMassCommandBuffer> GetSharedDeferredCommandBuffer() const { return DeferredCommandBuffer; }
    FMassCommandBuffer& Defer() const { checkSlow(DeferredCommandBuffer.IsValid()); return *DeferredCommandBuffer.Get(); }
 
    TConstArrayView<FMassEntityHandle> GetEntities() const { return EntityListView; }
    int32 GetNumEntities() const { return EntityListView.Num(); }
 
    FMassEntityHandle GetEntity(const int32 Index) const
    {
        return EntityListView[Index];
    }
 
    void ForEachEntityInChunk(const FMassEntityExecuteFunction& EntityExecuteFunction)
    {
        for (FEntityIterator EntityIterator = CreateEntityIterator(); EntityIterator; ++EntityIterator)
        {
            EntityExecuteFunction(*this, EntityIterator);
        }
    }
 
    bool DoesArchetypeHaveFragment(const UScriptStruct& FragmentType) const
    {
        return CurrentArchetypeCompositionDescriptor.GetFragments().Contains(FragmentType);
    }
 
    template<typename T>
    bool DoesArchetypeHaveFragment() const
    {
        static_assert(UE::Mass::CFragment<T>, MASS_INVALID_FRAGMENT_MSG);
        return CurrentArchetypeCompositionDescriptor.GetFragments().Contains<T>();
    }
 
    bool DoesArchetypeHaveTag(const UScriptStruct& TagType) const
    {
        return CurrentArchetypeCompositionDescriptor.GetTags().Contains(TagType);
    }
 
    template<typename T>
    bool DoesArchetypeHaveTag() const
    {
        static_assert(UE::Mass::CTag<T>, "Given struct is not of a valid tag type.");
        return CurrentArchetypeCompositionDescriptor.GetTags().Contains<T>();
    }
 
#if WITH_MASSENTITY_DEBUG
    FColor DebugGetArchetypeColor() const
    {
        return DebugColor;
    }
#endif // WITH_MASSENTITY_DEBUG
 
    void SetCurrentChunkSerialModificationNumber(const int32 SerialModificationNumber) { ChunkSerialModificationNumber = SerialModificationNumber; }
    int32 GetChunkSerialModificationNumber() const { return ChunkSerialModificationNumber; }
 
    template<typename T>
    T* GetMutableChunkFragmentPtr()
    {
        static_assert(UE::Mass::CChunkFragment<T>, "Given struct doesn't represent a valid chunk fragment type. Make sure to inherit from FMassChunkFragment or one of its child-types.");
 
        const UScriptStruct* Type = T::StaticStruct();
        FChunkFragmentView* FoundChunkFragmentData = ChunkFragmentViews.FindByPredicate([Type](const FChunkFragmentView& Element) { return Element.Requirement.StructType == Type; } );
        CHECK_IF_READWRITE(FoundChunkFragmentData);
        return FoundChunkFragmentData ? FoundChunkFragmentData->FragmentView.GetPtr<T>() : static_cast<T*>(nullptr);
    }
    
    template<typename T>
    T& GetMutableChunkFragment()
    {
        T* ChunkFragment = GetMutableChunkFragmentPtr<T>();
        CHECK_IF_VALID(ChunkFragment, T::StaticStruct());
        return *ChunkFragment;
    }
 
    template<typename T>
    const T* GetChunkFragmentPtr() const
    {
        static_assert(UE::Mass::CChunkFragment<T>, "Given struct doesn't represent a valid chunk fragment type. Make sure to inherit from FMassChunkFragment or one of its child-types.");
 
        const UScriptStruct* Type = T::StaticStruct();
        const FChunkFragmentView* FoundChunkFragmentData = ChunkFragmentViews.FindByPredicate([Type](const FChunkFragmentView& Element) { return Element.Requirement.StructType == Type; } );
        return FoundChunkFragmentData ? FoundChunkFragmentData->FragmentView.GetPtr<T>() : static_cast<const T*>(nullptr);
    }
    
    template<typename T>
    const T& GetChunkFragment() const
    {
        const T* ChunkFragment = GetChunkFragmentPtr<T>();
        CHECK_IF_VALID(ChunkFragment, T::StaticStruct());
        return *ChunkFragment;
    }
 
    const void* GetConstSharedFragmentPtr(const UScriptStruct& SharedFragmentType) const
    {
        const FConstSharedFragmentView* FoundSharedFragmentData = ConstSharedFragmentViews.FindByPredicate([&SharedFragmentType](const FConstSharedFragmentView& Element) { return Element.Requirement.StructType == &SharedFragmentType; });
        return FoundSharedFragmentData ? FoundSharedFragmentData->FragmentView.GetMemory() : nullptr;
    }
    
    template<typename T>
    const T* GetConstSharedFragmentPtr() const
    {
        static_assert(UE::Mass::CConstSharedFragment<T>, "Given struct doesn't represent a valid const shared fragment type. Make sure to inherit from FMassConstSharedFragment or one of its child-types.");
 
        const FConstSharedFragmentView* FoundSharedFragmentData = ConstSharedFragmentViews.FindByPredicate([](const FConstSharedFragmentView& Element) { return Element.Requirement.StructType == T::StaticStruct(); });
        return FoundSharedFragmentData ? FoundSharedFragmentData->FragmentView.GetPtr<const T>() : static_cast<const T*>(nullptr);
    }
 
    template<typename T>
    const T& GetConstSharedFragment() const
    {
        const T* SharedFragment = GetConstSharedFragmentPtr<const T>();
        CHECK_IF_VALID(SharedFragment, T::StaticStruct());
        return *SharedFragment;
    }
 
    template<typename T>
    T* GetMutableSharedFragmentPtr()
    {
        static_assert(UE::Mass::CSharedFragment<T>, "Given struct doesn't represent a valid shared fragment type. Make sure to inherit from FMassSharedFragment or one of its child-types.");
 
        FSharedFragmentView* FoundSharedFragmentData = SharedFragmentViews.FindByPredicate([](const FSharedFragmentView& Element) { return Element.Requirement.StructType == T::StaticStruct(); });
        CHECK_IF_READWRITE(FoundSharedFragmentData);
        return FoundSharedFragmentData ? FoundSharedFragmentData->FragmentView.GetPtr<T>() : static_cast<T*>(nullptr);
    }
 
    template<typename T>
    const T* GetSharedFragmentPtr() const
    {
        static_assert(UE::Mass::CSharedFragment<T>, "Given struct doesn't represent a valid shared fragment type. Make sure to inherit from FMassSharedFragment or one of its child-types.");
 
        const FSharedFragmentView* FoundSharedFragmentData = SharedFragmentViews.FindByPredicate([](const FSharedFragmentView& Element) { return Element.Requirement.StructType == T::StaticStruct(); });
        return FoundSharedFragmentData ? FoundSharedFragmentData->FragmentView.GetPtr<T>() : static_cast<const T*>(nullptr);
    }
 
    template<typename T>
    T& GetMutableSharedFragment()
    {
        T* SharedFragment = GetMutableSharedFragmentPtr<T>();
        CHECK_IF_VALID(SharedFragment, T::StaticStruct());
        return *SharedFragment;
    }
 
    template<typename T>
    const T& GetSharedFragment() const
    {
        const T* SharedFragment = GetSharedFragmentPtr<T>();
        CHECK_IF_VALID(SharedFragment, T::StaticStruct());
        return *SharedFragment;
    }
 
    /* Fragments related operations */
    template<typename TFragment>
    TArrayView<TFragment> GetMutableFragmentView()
    {
        const UScriptStruct* FragmentType = TFragment::StaticStruct();
        const FFragmentView* View = FragmentViews.FindByPredicate([FragmentType](const FFragmentView& Element) { return Element.Requirement.StructType == FragmentType; });
        CHECK_IF_VALID(View, FragmentType);
        CHECK_IF_READWRITE(View);
        return MakeArrayView<TFragment>((TFragment*)View->FragmentView.GetData(), View->FragmentView.Num());
    }
 
    template<typename TFragment>
    TConstArrayView<TFragment> GetFragmentView() const
    {
        const UScriptStruct* FragmentType = TFragment::StaticStruct();
        const FFragmentView* View = FragmentViews.FindByPredicate([FragmentType](const FFragmentView& Element) { return Element.Requirement.StructType == FragmentType; });
        CHECK_IF_VALID(View, TFragment::StaticStruct());
        return TConstArrayView<TFragment>((const TFragment*)View->FragmentView.GetData(), View->FragmentView.Num());
    }
 
    TConstArrayView<FMassFragment> GetFragmentView(const UScriptStruct* FragmentType) const
    {
        const FFragmentView* View = FragmentViews.FindByPredicate([FragmentType](const FFragmentView& Element) { return Element.Requirement.StructType == FragmentType; });
        CHECK_IF_VALID(View, FragmentType);
        return TConstArrayView<FMassFragment>((const FMassFragment*)View->FragmentView.GetData(), View->FragmentView.Num());;
    }
 
    TArrayView<FMassFragment> GetMutableFragmentView(const UScriptStruct* FragmentType) 
    {
        const FFragmentView* View = FragmentViews.FindByPredicate([FragmentType](const FFragmentView& Element) { return Element.Requirement.StructType == FragmentType; });
        CHECK_IF_VALID(View, FragmentType);
        CHECK_IF_READWRITE(View);
        return View->FragmentView;
    }
 
    template<typename TFragmentBase>
    TConstArrayView<TFragmentBase> GetFragmentView(TNotNull<const UScriptStruct*> FragmentType) const
    {
        check(FragmentType->IsChildOf(TFragmentBase::StaticStruct()));
        TConstArrayView<FMassFragment> View = GetFragmentView(FragmentType);
        return TConstArrayView<TFragmentBase>(reinterpret_cast<const TFragmentBase*>(View.GetData()), View.Num());
    }
 
    template<typename TFragmentBase>
    TArrayView<TFragmentBase> GetMutableFragmentView(TNotNull<const UScriptStruct*> FragmentType)
    {
        check(FragmentType->IsChildOf(TFragmentBase::StaticStruct()));
        TArrayView<FMassFragment> View = GetMutableFragmentView(FragmentType);
        return TArrayView<TFragmentBase>(reinterpret_cast<TFragmentBase*>(View.GetData()), View.Num());;
    }
 
    template<typename T, typename = typename TEnableIf<TIsDerivedFrom<T, USubsystem>::IsDerived>::Type>
    T* GetMutableSubsystem()
    {
        return SubsystemAccess.GetMutableSubsystem<T>();
    }
 
    template<typename T, typename = typename TEnableIf<TIsDerivedFrom<T, USubsystem>::IsDerived>::Type>
    T& GetMutableSubsystemChecked()
    {
        return SubsystemAccess.GetMutableSubsystemChecked<T>();
    }
 
    template<typename T, typename = typename TEnableIf<TIsDerivedFrom<T, USubsystem>::IsDerived>::Type>
    const T* GetSubsystem()
    {
        return SubsystemAccess.GetSubsystem<T>();
    }
 
    template<typename T, typename = typename TEnableIf<TIsDerivedFrom<T, USubsystem>::IsDerived>::Type>
    const T& GetSubsystemChecked()
    {
        return SubsystemAccess.GetSubsystemChecked<T>();
    }
 
    template<typename T, typename = typename TEnableIf<TIsDerivedFrom<T, USubsystem>::IsDerived>::Type>
    T* GetMutableSubsystem(const TSubclassOf<USubsystem> SubsystemClass)
    {
        return SubsystemAccess.GetMutableSubsystem<T>(SubsystemClass);
    }
 
    template<typename T, typename = typename TEnableIf<TIsDerivedFrom<T, USubsystem>::IsDerived>::Type>
    T& GetMutableSubsystemChecked(const TSubclassOf<USubsystem> SubsystemClass)
    {
        return SubsystemAccess.GetMutableSubsystemChecked<T>(SubsystemClass);
    }
 
    template<typename T, typename = typename TEnableIf<TIsDerivedFrom<T, USubsystem>::IsDerived>::Type>
    const T* GetSubsystem(const TSubclassOf<USubsystem> SubsystemClass)
    {
        return SubsystemAccess.GetSubsystem<T>(SubsystemClass);
    }
 
    template<typename T, typename = typename TEnableIf<TIsDerivedFrom<T, USubsystem>::IsDerived>::Type>
    const T& GetSubsystemChecked(const TSubclassOf<USubsystem> SubsystemClass)
    {
        return SubsystemAccess.GetSubsystemChecked<T>(SubsystemClass);
    }
 
    const FMassArchetypeEntityCollection& GetEntityCollection() const { return EntityCollection; }
 
    const FInstancedStruct& GetAuxData() const { return AuxData; }
    FInstancedStruct& GetMutableAuxData() { return AuxData; }
    
    template<typename TFragment>
    bool ValidateAuxDataType() const
    {
        const UScriptStruct* FragmentType = GetAuxData().GetScriptStruct();
        return FragmentType != nullptr && FragmentType == TFragment::StaticStruct();
    }
 
    MASSENTITY_API void FlushDeferred();
 
    void ClearExecutionData();
    void SetCurrentArchetypeCompositionDescriptor(const FMassArchetypeCompositionDescriptor& Descriptor)
    {
        CurrentArchetypeCompositionDescriptor = Descriptor;
    }
 
#if WITH_MASSENTITY_DEBUG
    void DebugSetColor(FColor InColor)
    {
        DebugColor = InColor;
    }
#endif // WITH_MASSENTITY_DEBUG
 
    bool CacheSubsystemRequirements(const FMassSubsystemRequirements& SubsystemRequirements);
 
protected:
    void SetSubsystemRequirements(const FMassSubsystemRequirements& SubsystemRequirements)
    {
        SubsystemAccess.SetSubsystemRequirements(SubsystemRequirements);
    }
 
    void SetFragmentRequirements(const FMassFragmentRequirements& FragmentRequirements);
 
    void ClearFragmentViews()
    {
        for (FFragmentView& View : FragmentViews)
        {
            View.FragmentView = TArrayView<FMassFragment>();
        }
        for (FChunkFragmentView& View : ChunkFragmentViews)
        {
            View.FragmentView.Reset();
        }
        for (FConstSharedFragmentView& View : ConstSharedFragmentViews)
        {
            View.FragmentView.Reset();
        }
        for (FSharedFragmentView& View : SharedFragmentViews)
        {
            View.FragmentView.Reset();
        }
    }
};
 
//-----------------------------------------------------------------------------
// Inlines
//-----------------------------------------------------------------------------
inline FMassEntityManager& FMassExecutionContext::GetEntityManagerChecked() const
{
    return EntityManager.Get();
}
 
inline const TSharedRef<FMassEntityManager>& FMassExecutionContext::GetSharedEntityManager()
{
    return EntityManager;
}
 
inline void FMassExecutionContext::SetFlushDeferredCommands(const bool bNewFlushDeferredCommands)
{
    bFlushDeferredCommands = bNewFlushDeferredCommands;
}
 
inline void FMassExecutionContext::SetDeferredCommandBuffer(const TSharedPtr<FMassCommandBuffer>& InDeferredCommandBuffer)
{
    DeferredCommandBuffer = InDeferredCommandBuffer;
}
 
inline void FMassExecutionContext::ClearEntityCollection()
{
    EntityCollection.Reset();
}
 
inline void FMassExecutionContext::SetAuxData(const FInstancedStruct& InAuxData)
{
    AuxData = InAuxData;
}
 
inline float FMassExecutionContext::GetDeltaTimeSeconds() const
{
    return DeltaTimeSeconds;
}
 
inline void FMassExecutionContext::SetExecutionType(EMassExecutionContextType InExecutionType)
{
    check(InExecutionType != EMassExecutionContextType::MAX);
    ExecutionType = InExecutionType;
}
 
inline EMassExecutionContextType FMassExecutionContext::GetExecutionType() const
{
    return ExecutionType;
}
 
inline const FMassEntityQuery& FMassExecutionContext::GetCurrentQuery() const
{
    check(QueriesStack.Num());
    return *QueriesStack.Last().Query;
}
 
inline bool FMassExecutionContext::IsCurrentQuery(const FMassEntityQuery& Query) const
{
    return QueriesStack.Num() && QueriesStack.Last().Query == &Query;
}
 
inline void FMassExecutionContext::ApplyFragmentRequirements(const FMassEntityQuery& RequestingQuery)
{
    check(IsCurrentQuery(RequestingQuery));
    SetFragmentRequirements(RequestingQuery);
}
 
inline void FMassExecutionContext::ClearFragmentViews(const FMassEntityQuery& RequestingQuery)
{
    check(IsCurrentQuery(RequestingQuery));
    ClearFragmentViews();
}
 
#undef CHECK_IF_VALID
#undef CHECK_IF_READWRITE