MassEntityManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "UObject/GCObject.h"
#include "Containers/StaticArray.h"
#include "MassEntityTypes.h"
#include "MassProcessingTypes.h"
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_7
#include "MassEntityQuery.h"
#endif
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_5
#include "StructUtils/InstancedStruct.h"
#include "StructUtils/StructUtilsTypes.h"
#endif
#include "MassObserverManager.h"
#include "Containers/MpscQueue.h"
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_7
#include "MassRequirementAccessDetector.h"
#endif // UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_7
#include "Templates/FunctionFwd.h"
#include "MassEntityManagerStorage.h"
#include "MassArchetypeGroup.h"
#include "MassRelationManager.h"
#include "MassEntityRelations.h"
 
#if WITH_MASSENTITY_DEBUG
#include "Misc/EnumClassFlags.h"
#include "MassRequirementAccessDetector.h"
#else
struct FMassRequirementAccessDetector;
#endif
 
#define UE_API MASSENTITY_API
 
struct FInstancedStruct;
struct FMassEntityQuery;
struct FMassExecutionContext;
struct FMassArchetypeData;
struct FMassCommandBuffer;
struct FMassArchetypeEntityCollection;
class FOutputDevice;
struct FMassDebugger;
struct FMassFragmentRequirements;
enum class EMassFragmentAccess : uint8;
enum class EForkProcessRole : uint8;
namespace UE::Mass
{
    struct FEntityBuilder;
    struct FTypeManager;
    struct FTypeHandle;
    namespace Private
    {
        struct FEntityStorageInitializer;
    }
    namespace ObserverManager
    {
        struct FObserverLock;
        struct FCreationContext;
    }
}
 
// use REQUESTED_MASS_CONCURRENT_RESERVE=0 in your project's Build.cs file to disable concurrent storage
// NOTE that it will always be enabled in WITH_EDITOR since editor code requires it. 
// @see WITH_MASS_CONCURRENT_RESERVE
#ifndef REQUESTED_MASS_CONCURRENT_RESERVE
#define REQUESTED_MASS_CONCURRENT_RESERVE 1
#endif
 
#define WITH_MASS_CONCURRENT_RESERVE (REQUESTED_MASS_CONCURRENT_RESERVE || WITH_EDITOR)
 
namespace UE::Mass
{
#if WITH_MASS_CONCURRENT_RESERVE
    using FStorageType = IEntityStorageInterface;
#else
    using FStorageType = FSingleThreadedEntityStorage;
#endif //WITH_MASS_CONCURRENT_RESERVE
}
 
struct FMassEntityManager : public TSharedFromThis<FMassEntityManager>, public FGCObject
{
    friend FMassEntityQuery;
    friend FMassDebugger;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnNewArchetypeDelegate, const FMassArchetypeHandle&);
 
private:
    // Index 0 is reserved so we can treat that index as an invalid entity handle
    constexpr static int32 NumReservedEntities = 1;
    
public:
    struct FScopedProcessing
    {
        explicit FScopedProcessing(std::atomic<int32>& InProcessingScopeCount) : ScopedProcessingCount(InProcessingScopeCount)
        {
            ++ScopedProcessingCount;
        }
        ~FScopedProcessing()
        {
            --ScopedProcessingCount;
        }
    private:
        std::atomic<int32>& ScopedProcessingCount;
    };
    using FStructInitializationCallback = TFunctionRef<void(void* Fragment, const UScriptStruct& FragmentType)>;
 
    const UE_API static FMassEntityHandle InvalidEntity;
 
    UE_API explicit FMassEntityManager(UObject* InOwner = nullptr);
    FMassEntityManager(const FMassEntityManager& Other) = delete;
    UE_API virtual ~FMassEntityManager();
 
    // FGCObject interface
    UE_API virtual void AddReferencedObjects(FReferenceCollector& Collector) override;
    virtual FString GetReferencerName() const override
    {
        return TEXT("FMassEntityManager");
    }
    // End of FGCObject interface
    UE_API void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize);
 
    // Default to use single threaded implementation
    UE_API void Initialize();
    UE_API void Initialize(const FMassEntityManagerStorageInitParams& InitializationParams);
    UE_API void PostInitialize();
    UE_API void Deinitialize();
 
    UE_API FMassArchetypeHandle CreateArchetype(TConstArrayView<const UScriptStruct*> FragmentsAndTagsList, const FMassArchetypeCreationParams& CreationParams = FMassArchetypeCreationParams());
 
    UE_API FMassArchetypeHandle CreateArchetype(FMassArchetypeHandle SourceArchetype, TConstArrayView<const UScriptStruct*> FragmentsAndTagsList);
    
    UE_API FMassArchetypeHandle CreateArchetype(FMassArchetypeHandle SourceArchetype, TConstArrayView<const UScriptStruct*> FragmentsAndTagsList, 
        const FMassArchetypeCreationParams& CreationParams);
 
    UE_API FMassArchetypeHandle CreateArchetype(const FMassArchetypeCompositionDescriptor& Composition, const FMassArchetypeCreationParams& CreationParams = FMassArchetypeCreationParams());
 
    UE_API FMassArchetypeHandle CreateArchetype(const TSharedPtr<FMassArchetypeData>& SourceArchetype, const FMassFragmentBitSet& InFragments);
    
    UE_API FMassArchetypeHandle CreateArchetype(const TSharedPtr<FMassArchetypeData>& SourceArchetype, const FMassFragmentBitSet& InFragments, 
        const FMassArchetypeCreationParams& CreationParams);
 
    UE_API FMassArchetypeHandle GetOrCreateSuitableArchetype(const FMassArchetypeHandle& ArchetypeHandle
        , const FMassSharedFragmentBitSet& SharedFragmentBitSet
        , const FMassConstSharedFragmentBitSet& ConstSharedFragmentBitSet
        , const FMassArchetypeCreationParams& CreationParams = FMassArchetypeCreationParams());
 
    UE_API FMassArchetypeHandle GetArchetypeForEntity(FMassEntityHandle EntityHandle) const;
    UE_API FMassArchetypeHandle GetArchetypeForEntityUnsafe(FMassEntityHandle EntityHandle) const;
 
    UE_API void GetMatchingArchetypes(const FMassFragmentRequirements& Requirements, TArray<FMassArchetypeHandle>& OutValidArchetypes) const;
 
    static UE_API void ForEachArchetypeFragmentType(const FMassArchetypeHandle& ArchetypeHandle, TFunction< void(const UScriptStruct* /*FragmentType*/)> Function);
 
    UE_API void DoEntityCompaction(const double TimeAllowed);
 
    UE_API FMassEntityHandle CreateEntity(const FMassArchetypeHandle& ArchetypeHandle, const FMassArchetypeSharedFragmentValues& SharedFragmentValues = {});
 
    UE_API FMassEntityHandle CreateEntity(TConstArrayView<FInstancedStruct> FragmentInstanceList, const FMassArchetypeSharedFragmentValues& SharedFragmentValues = {}, const FMassArchetypeCreationParams& CreationParams = FMassArchetypeCreationParams());
 
    using FEntityCreationContext = UE::Mass::ObserverManager::FCreationContext;
 
    UE_API TSharedRef<FEntityCreationContext> GetOrMakeCreationContext();
 
    TSharedRef<UE::Mass::ObserverManager::FObserverLock> GetOrMakeObserversLock();
 
    UE_API TSharedRef<FEntityCreationContext> BatchCreateReservedEntities(const FMassArchetypeHandle& ArchetypeHandle,
        const FMassArchetypeSharedFragmentValues& SharedFragmentValues, TConstArrayView<FMassEntityHandle> ReservedEntities);
    inline TSharedRef<FEntityCreationContext> BatchCreateReservedEntities(const FMassArchetypeHandle& ArchetypeHandle,
        TConstArrayView<FMassEntityHandle> OutEntities)
    {
        return BatchCreateReservedEntities(ArchetypeHandle, FMassArchetypeSharedFragmentValues(), OutEntities);
    }
    UE_API TSharedRef<FEntityCreationContext> BatchCreateEntities(const FMassArchetypeHandle& ArchetypeHandle, const FMassArchetypeSharedFragmentValues& SharedFragmentValues, const int32 Count, TArray<FMassEntityHandle>& InOutEntities);
    inline TSharedRef<FEntityCreationContext> BatchCreateEntities(const FMassArchetypeHandle& ArchetypeHandle, const int32 Count, TArray<FMassEntityHandle>& InOutEntities)
    {
        return BatchCreateEntities(ArchetypeHandle, FMassArchetypeSharedFragmentValues(), Count, InOutEntities);
    }
 
    UE_API void DestroyEntity(FMassEntityHandle EntityHandle);
 
    UE_API FMassEntityHandle ReserveEntity();
 
    UE_API void BuildEntity(FMassEntityHandle EntityHandle, const FMassArchetypeHandle& ArchetypeHandle, const FMassArchetypeSharedFragmentValues& SharedFragmentValues = {});
 
    UE_API void BuildEntity(FMassEntityHandle EntityHandle, TConstArrayView<FInstancedStruct> FragmentInstanceList, const FMassArchetypeSharedFragmentValues& SharedFragmentValues = {});
 
    /*
     * Releases a previously reserved entity handle that was not yet built, otherwise call DestroyEntity
     * @param EntityHandle to release */
    UE_API void ReleaseReservedEntity(FMassEntityHandle EntityHandle);
 
    UE_API void BatchDestroyEntities(TConstArrayView<FMassEntityHandle> InEntities);
 
    UE_API void BatchDestroyEntityChunks(const FMassArchetypeEntityCollection& Collection);
    UE_API void BatchDestroyEntityChunks(TConstArrayView<FMassArchetypeEntityCollection> Collections);
 
    UE_API void BatchGroupEntities(const UE::Mass::FArchetypeGroupHandle GroupHandle, TConstArrayView<FMassArchetypeEntityCollection> Collections);
 
    UE_API void BatchGroupEntities(const UE::Mass::FArchetypeGroupHandle GroupHandle, TConstArrayView<FMassEntityHandle> InEntities);
 
    UE_API UE::Mass::FArchetypeGroupType FindOrAddArchetypeGroupType(const FName GroupName);
 
    UE_API const UE::Mass::FArchetypeGroups& GetGroupsForArchetype(const FMassArchetypeHandle& ArchetypeHandle) const;
 
    UE_API void AddFragmentToEntity(FMassEntityHandle EntityHandle, const UScriptStruct* FragmentType);
    UE_API void AddFragmentToEntity(FMassEntityHandle EntityHandle, const UScriptStruct* FragmentType, const FStructInitializationCallback& Initializer);
 
    UE_API void AddFragmentListToEntity(FMassEntityHandle EntityHandle, TConstArrayView<const UScriptStruct*> FragmentList);
 
    UE_API void AddFragmentInstanceListToEntity(FMassEntityHandle EntityHandle, TConstArrayView<FInstancedStruct> FragmentInstanceList);
    UE_API void RemoveFragmentFromEntity(FMassEntityHandle EntityHandle, const UScriptStruct* FragmentType);
    UE_API void RemoveFragmentListFromEntity(FMassEntityHandle EntityHandle, TConstArrayView<const UScriptStruct*> FragmentList);
 
    UE_API void AddTagToEntity(FMassEntityHandle EntityHandle, const UScriptStruct* TagType);
    UE_API void RemoveTagFromEntity(FMassEntityHandle EntityHandle, const UScriptStruct* TagType);
    UE_API void SwapTagsForEntity(FMassEntityHandle EntityHandle, const UScriptStruct* FromFragmentType, const UScriptStruct* ToFragmentType);
 
    void AddElementToEntities(TConstArrayView<FMassEntityHandle> Entities, TNotNull<const UScriptStruct*> ElementType);
 
    void AddElementToEntity(FMassEntityHandle Entity, TNotNull<const UScriptStruct*> ElementType);
 
    /*
     * Removes ElementType from the entities, treating it accordingly based on which element type it represents (i.e. Fragment or Tag).
     * The function will assert on unhandled types.
     */
    void RemoveElementFromEntities(TConstArrayView<FMassEntityHandle> Entities, TNotNull<const UScriptStruct*> ElementType);
 
    /*
     * Removes ElementType from the entity, treating it accordingly based on which element type it represents (i.e. Fragment or Tag).
     * The function will assert on unhandled types.
     */
    void RemoveElementFromEntity(FMassEntityHandle Entity, TNotNull<const UScriptStruct*> ElementType);
 
    bool DoesEntityHaveElement(FMassEntityHandle Entity, TNotNull<const UScriptStruct*> ElementType) const;
 
    UE_API bool AddConstSharedFragmentToEntity(const FMassEntityHandle EntityHandle, const FConstSharedStruct& InConstSharedFragment);
 
    UE_API bool RemoveConstSharedFragmentFromEntity(const FMassEntityHandle EntityHandle, const UScriptStruct& ConstSharedFragmentType);
 
    UE_API bool AddSharedFragmentToEntity(const FMassEntityHandle EntityHandle, const FSharedStruct& InSharedFragment);
 
    UE_API bool RemoveSharedFragmentFromEntity(const FMassEntityHandle EntityHandle, const UScriptStruct& SharedFragmentType);
 
    UE_API void RemoveEntityFromGroupType(FMassEntityHandle EntityHandle, UE::Mass::FArchetypeGroupType GroupType);
 
    UE_API UE::Mass::FArchetypeGroupHandle GetGroupForEntity(FMassEntityHandle EntityHandle, UE::Mass::FArchetypeGroupType GroupType) const;
 
    UE_API TConstArrayView<FMassEntityHandle> BatchReserveEntities(const int32 Count, TArray<FMassEntityHandle>& InOutEntities);
    
    UE_API int32 BatchReserveEntities(TArrayView<FMassEntityHandle> InOutEntities);
 
    UE_API TSharedRef<FEntityCreationContext> BatchBuildEntities(const FMassArchetypeEntityCollectionWithPayload& EncodedEntitiesWithPayload, const FMassFragmentBitSet& FragmentsAffected
        , const FMassArchetypeSharedFragmentValues& SharedFragmentValues = {}, const FMassArchetypeCreationParams& CreationParams = FMassArchetypeCreationParams());
    UE_API TSharedRef<FEntityCreationContext> BatchBuildEntities(const FMassArchetypeEntityCollectionWithPayload& EncodedEntitiesWithPayload, const FMassArchetypeCompositionDescriptor& Composition
        , const FMassArchetypeSharedFragmentValues& SharedFragmentValues = {}, const FMassArchetypeCreationParams& CreationParams = FMassArchetypeCreationParams());
    UE_API void BatchChangeTagsForEntities(TConstArrayView<FMassArchetypeEntityCollection> EntityCollections, const FMassTagBitSet& TagsToAdd, const FMassTagBitSet& TagsToRemove);
    UE_API void BatchChangeFragmentCompositionForEntities(TConstArrayView<FMassArchetypeEntityCollection> EntityCollections, const FMassFragmentBitSet& FragmentsToAdd, const FMassFragmentBitSet& FragmentsToRemove);
    UE_API void BatchAddFragmentInstancesForEntities(TConstArrayView<FMassArchetypeEntityCollectionWithPayload> EntityCollections, const FMassFragmentBitSet& FragmentsAffected);
    UE_API void BatchAddSharedFragmentsForEntities(TConstArrayView<FMassArchetypeEntityCollection> EntityCollections, const FMassArchetypeSharedFragmentValues& AddedFragmentValues);
 
    UE_API void AddCompositionToEntity_GetDelta(FMassEntityHandle EntityHandle, FMassArchetypeCompositionDescriptor& InOutDescriptor, const FMassArchetypeSharedFragmentValues* AddedSharedFragmentValues = nullptr);
    UE_API void RemoveCompositionFromEntity(FMassEntityHandle EntityHandle, const FMassArchetypeCompositionDescriptor& InDescriptor);
 
    UE_API const FMassArchetypeCompositionDescriptor& GetArchetypeComposition(const FMassArchetypeHandle& ArchetypeHandle) const;
 
    UE_API void MoveEntityToAnotherArchetype(FMassEntityHandle EntityHandle, FMassArchetypeHandle NewArchetypeHandle, const FMassArchetypeSharedFragmentValues* SharedFragmentValuesOverride = nullptr);
 
    UE_API void SetEntityFragmentValues(FMassEntityHandle EntityHandle, TArrayView<const FInstancedStruct> FragmentInstanceList);
 
    UE_API void BatchSetEntityFragmentValues(const FMassArchetypeEntityCollection& SparseEntities, TArrayView<const FInstancedStruct> FragmentInstanceList);
 
    UE_API void BatchSetEntityFragmentValues(TConstArrayView<FMassArchetypeEntityCollection> EntityCollections, TArrayView<const FInstancedStruct> FragmentInstanceList);
 
    UE_API bool IsEntityActive(FMassEntityHandle EntityHandle) const;
 
    UE_API bool IsEntityValid(FMassEntityHandle EntityHandle) const;
 
    UE_API bool IsEntityBuilt(FMassEntityHandle EntityHandle) const;
 
    UE_API bool IsEntityReserved(FMassEntityHandle EntityHandle) const;
 
    inline void CheckIfEntityIsValid(FMassEntityHandle EntityHandle) const
    {
        checkf(IsEntityValid(EntityHandle), TEXT("Invalid entity (ID: %d, SN:%d, %s)"), EntityHandle.Index, EntityHandle.SerialNumber,
               (EntityHandle.Index == 0) ? TEXT("was never initialized") : TEXT("already destroyed"));
    }
 
    inline void CheckIfEntityIsActive(FMassEntityHandle EntityHandle) const
    {
        checkf(IsEntityBuilt(EntityHandle), TEXT("Entity not yet created(ID: %d, SN:%d)"), EntityHandle.Index, EntityHandle.SerialNumber);
    }
 
    UE_API FMassEntityHandle CreateEntityIndexHandle(const int32 EntityIndex) const;
 
    template<typename FragmentType>
    FragmentType& GetFragmentDataChecked(FMassEntityHandle EntityHandle) const
    {
        static_assert(UE::Mass::CFragment<FragmentType>, MASS_INVALID_FRAGMENT_MSG);
        return *((FragmentType*)InternalGetFragmentDataChecked(EntityHandle, FragmentType::StaticStruct()));
    }
 
    template<typename FragmentType>
    FragmentType* GetFragmentDataPtr(FMassEntityHandle EntityHandle) const
    {
        static_assert(UE::Mass::CFragment<FragmentType>, MASS_INVALID_FRAGMENT_MSG);
        return (FragmentType*)InternalGetFragmentDataPtr(EntityHandle, FragmentType::StaticStruct());
    }
 
    FStructView GetFragmentDataStruct(FMassEntityHandle EntityHandle, const UScriptStruct* FragmentType) const
    {
        checkf(UE::Mass::IsA<FMassFragment>(FragmentType)
            , TEXT("GetFragmentDataStruct called with an invalid fragment type '%s'"), *GetPathNameSafe(FragmentType));
        return FStructView(FragmentType, static_cast<uint8*>(InternalGetFragmentDataPtr(EntityHandle, FragmentType)));
    }
 
    template<typename ConstSharedFragmentType>
    ConstSharedFragmentType* GetConstSharedFragmentDataPtr(FMassEntityHandle EntityHandle) const
    {
        static_assert(UE::Mass::CConstSharedFragment<ConstSharedFragmentType>, "Given struct doesn't represent a valid const shared fragment type. Make sure to inherit from FMassConstSharedFragment or one of its child-types.");
        const FConstSharedStruct* ConstSharedStruct = InternalGetConstSharedFragmentPtr(EntityHandle, ConstSharedFragmentType::StaticStruct());
        return (ConstSharedFragmentType*)(ConstSharedStruct ? ConstSharedStruct->GetMemory() : nullptr);
    }
 
    template<typename ConstSharedFragmentType>
    ConstSharedFragmentType& GetConstSharedFragmentDataChecked(FMassEntityHandle EntityHandle) const
    {
        ConstSharedFragmentType* TypePtr = GetConstSharedFragmentDataPtr<ConstSharedFragmentType>(EntityHandle);
        check(TypePtr);
        return *TypePtr;
    }
 
    FConstStructView GetConstSharedFragmentDataStruct(FMassEntityHandle EntityHandle, const UScriptStruct* ConstSharedFragmentType) const
    {
        checkf(UE::Mass::IsA<FMassConstSharedFragment>(ConstSharedFragmentType)
            , TEXT("GetConstSharedFragmentDataStruct called with an invalid fragment type '%s'"), *GetPathNameSafe(ConstSharedFragmentType));
        const FConstSharedStruct* ConstSharedStruct = InternalGetConstSharedFragmentPtr(EntityHandle, ConstSharedFragmentType);
        return ConstSharedStruct
            ? FConstStructView(*ConstSharedStruct)
            : FConstStructView();
    }
 
    template<typename SharedFragmentType>
    TConstArrayView<FSharedStruct> GetSharedFragmentsOfType()
    {
        static_assert(UE::Mass::CSharedFragment<SharedFragmentType>
            , "Given struct doesn't represent a valid shared fragment type. Make sure to inherit from FMassSharedFragment or one of its child-types.");
 
        TArray<FSharedStruct>* InstancesOfType = SharedFragmentsContainer.Find(SharedFragmentType::StaticStruct());
        return InstancesOfType ? *InstancesOfType : TConstArrayView<FSharedStruct>();
    }
 
    template<typename SharedFragmentType>
    SharedFragmentType* GetSharedFragmentDataPtr(FMassEntityHandle EntityHandle) const
    {
        static_assert(UE::Mass::CSharedFragment<SharedFragmentType>
            , "Given struct doesn't represent a valid shared fragment type. Make sure to inherit from FMassSharedFragment or one of its child-types.");
        const FSharedStruct* FragmentPtr = InternalGetSharedFragmentPtr(EntityHandle, SharedFragmentType::StaticStruct());
        return (SharedFragmentType*)(FragmentPtr ? FragmentPtr->GetMemory() : nullptr);
    }
 
    template<typename SharedFragmentType>
    SharedFragmentType& GetSharedFragmentDataChecked(FMassEntityHandle EntityHandle) const
    {
        SharedFragmentType* TypePtr = GetSharedFragmentDataPtr<SharedFragmentType>(EntityHandle);
        check(TypePtr);
        return *TypePtr;
    }
 
    FConstStructView GetSharedFragmentDataStruct(FMassEntityHandle EntityHandle, const UScriptStruct* SharedFragmentType) const
    {
        checkf(UE::Mass::IsA<FMassSharedFragment>(SharedFragmentType)
            , TEXT("GetSharedFragmentDataStruct called with an invalid fragment type '%s'"), *GetPathNameSafe(SharedFragmentType));
        const FSharedStruct* FragmentPtr = InternalGetSharedFragmentPtr(EntityHandle, SharedFragmentType);
        return FragmentPtr
            ? FConstStructView(*FragmentPtr)
            : FConstStructView();
    }
 
    template<typename T>
    FConstStructView GetElementDataStruct(FMassEntityHandle EntityHandle, TNotNull<const UScriptStruct*> FragmentType) const
    {
        if constexpr (std::is_same_v<T, FMassFragment>)
        {
            return GetFragmentDataStruct(EntityHandle, FragmentType);
        }
        else if constexpr (std::is_same_v<T, FMassSharedFragment>)
        {
            return GetSharedFragmentDataStruct(EntityHandle, FragmentType);
        }
        else if constexpr (std::is_same_v<T, FMassConstSharedFragment>)
        {
            return GetConstSharedFragmentDataStruct(EntityHandle, FragmentType);
        }
        else
        {
            static_assert(UE::Mass::TAlwaysFalse<T>, "Unsupported element type passed to GetElementDataStruct");
            return {};
        }
    }
 
    uint32 GetArchetypeDataVersion() const { return ArchetypeDataVersion; }
 
    UE_API FMassExecutionContext CreateExecutionContext(const float DeltaSeconds);
 
    FScopedProcessing NewProcessingScope() { return FScopedProcessing(ProcessingScopeCount); }
 
    bool IsProcessing() const { return ProcessingScopeCount > 0; }
 
    FMassCommandBuffer& Defer() const { return *DeferredCommandBuffers[OpenedCommandBufferIndex].Get(); }
    UE_API void FlushCommands(const TSharedPtr<FMassCommandBuffer>& InCommandBuffer);
 
    UE_API void FlushCommands();
 
    UE_API void AppendCommands(const TSharedPtr<FMassCommandBuffer>& InOutCommandBuffer);
 
    template<typename T>
    UE_DEPRECATED(5.5, "This method will no longer be exposed. Use GetOrCreateConstSharedFragment instead.")
    const FConstSharedStruct& GetOrCreateConstSharedFragmentByHash(const uint32 Hash, const T& Fragment)
    {
        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.");
        return ConstSharedFragmentsContainer.FindOrAdd(Hash, T::StaticStruct(), reinterpret_cast<const uint8*>(&Fragment));
    }
 
private:
    template<typename T>
    const FSharedStruct& GetOrCreateSharedFragmentByHash(const uint32 Hash, const T& Fragment)
    {
        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.");
        return SharedFragmentsContainer.FindOrAdd(Hash, T::StaticStruct(), reinterpret_cast<const uint8*>(&Fragment));
    }
 
    const FConstSharedStruct& GetOrCreateConstSharedFragmentByHash(const uint32 Hash, const UScriptStruct* InScriptStruct, const uint8* InStructMemory)
    {
        return ConstSharedFragmentsContainer.FindOrAdd(Hash, InScriptStruct, InStructMemory);
    }
 
    const FSharedStruct& GetOrCreateSharedFragmentByHash(const uint32 Hash, const UScriptStruct* InScriptStruct, const uint8* InStructMemory)
    {
        return SharedFragmentsContainer.FindOrAdd(Hash, InScriptStruct, InStructMemory);
    }
 
    template<typename T, typename... TArgs>
    const FConstSharedStruct& GetOrCreateConstSharedFragmentByHash(const uint32 Hash, TArgs&&... InArgs)
    {
        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.");
        return ConstSharedFragmentsContainer.FindOrAdd<T>(Hash, Forward<TArgs>(InArgs)...);
    }
 
public:
 
#if WITH_EDITOR || WITH_MASSENTITY_DEBUG
    template<typename CallableT>
    void ForEachArchetype(int32 BeginRange, int32 EndRange, const CallableT& Callable) const
    {
        if (EndRange > AllArchetypes.Num())
        {
            EndRange = AllArchetypes.Num();
        }
        for (int32 Cursor = BeginRange; Cursor < EndRange; ++Cursor)
        {
            FMassArchetypeHandle Handle(AllArchetypes[Cursor]);
            Callable(*this, Handle);
        }
    }
#endif
 
    //-----------------------------------------------------------------------------
    // Shared fragments
    //-----------------------------------------------------------------------------
    template<typename T, typename... TArgs>
    UE_DEPRECATED(5.5, "This method will no longer be exposed. Use GetOrCreateSharedFragment instead.")
    const FSharedStruct& GetOrCreateSharedFragmentByHash(const uint32 Hash, TArgs&&... InArgs)
    {
        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.");
        return SharedFragmentsContainer.FindOrAdd<T>(Hash, Forward<TArgs>(InArgs)...);
    }
 
    template<typename T>
    const FConstSharedStruct& GetOrCreateConstSharedFragment(const T& Fragment)
    {
        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 uint32 Hash = UE::StructUtils::GetStructInstanceCrc32(FConstStructView::Make(Fragment));
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return GetOrCreateConstSharedFragmentByHash(Hash, Fragment);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    template<typename T>
    const FSharedStruct& GetOrCreateSharedFragment(const T& Fragment)
    {
        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 uint32 Hash = UE::StructUtils::GetStructInstanceCrc32(FConstStructView::Make(Fragment));
        return GetOrCreateSharedFragmentByHash(Hash, Fragment);
    }
 
    template<typename T, typename... TArgs>
    const FConstSharedStruct& GetOrCreateConstSharedFragment(TArgs&&... InArgs)
    {
        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.");
        T Struct(Forward<TArgs>(InArgs)...);
        const uint32 Hash = UE::StructUtils::GetStructInstanceCrc32(FConstStructView::Make(Struct));
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return GetOrCreateConstSharedFragmentByHash(Hash, MoveTemp(Struct));
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    template<typename T, typename... TArgs>
    const FSharedStruct& GetOrCreateSharedFragment(TArgs&&... InArgs)
    {
        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.");
        T Struct(Forward<TArgs>(InArgs)...);
        const uint32 Hash = UE::StructUtils::GetStructInstanceCrc32(FConstStructView::Make(Struct));
        return GetOrCreateSharedFragmentByHash(Hash, MoveTemp(Struct));
    }
 
    const FConstSharedStruct& GetOrCreateConstSharedFragment(const UScriptStruct& InScriptStruct, const uint8* InStructMemory)
    {
        checkf(InScriptStruct.IsChildOf(TBaseStructure<FMassConstSharedFragment>::Get()),
            TEXT("Given struct doesn't represent a valid const shared fragment type. Make sure to inherit from FMassConstSharedFragment or one of its child-types."));
        const uint32 Hash = UE::StructUtils::GetStructInstanceCrc32(InScriptStruct, InStructMemory);
        return GetOrCreateConstSharedFragmentByHash(Hash, &InScriptStruct, InStructMemory);
    }
 
    const FSharedStruct& GetOrCreateSharedFragment(const UScriptStruct& InScriptStruct, const uint8* InStructMemory)
    {
        checkf(InScriptStruct.IsChildOf(TBaseStructure<FMassSharedFragment>::Get()),
            TEXT("Given struct doesn't represent a valid shared fragment type. Make sure to inherit from FMassSharedFragment or one of its child-types."));
        const uint32 Hash = UE::StructUtils::GetStructInstanceCrc32(InScriptStruct, InStructMemory);
        return GetOrCreateSharedFragmentByHash(Hash, &InScriptStruct, InStructMemory);
    }
 
    template<typename T, typename... TArgs>
    const FConstSharedStruct& GetOrCreateConstSharedFragment(const FConstStructView HashingHelperStruct, TArgs&&... InArgs)
    {
        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.");
        T Fragment(Forward<TArgs>(InArgs)...);
        const uint32 Hash = UE::StructUtils::GetStructInstanceCrc32(HashingHelperStruct);
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return GetOrCreateConstSharedFragmentByHash(Hash, MoveTemp(Fragment));
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    template<typename T, typename... TArgs>
    const FSharedStruct& GetOrCreateSharedFragment(const FConstStructView HashingHelperStruct, TArgs&&... InArgs)
    {
        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.");
        T Fragment(Forward<TArgs>(InArgs)...);
        const uint32 Hash = UE::StructUtils::GetStructInstanceCrc32(HashingHelperStruct);
        return GetOrCreateSharedFragmentByHash(Hash, MoveTemp(Fragment));
    }
 
    template<UE::Mass::CSharedFragment T>
    void ForEachSharedFragment(TFunctionRef< void(T& /*SharedFragment*/) > ExecuteFunction);
 
    template<UE::Mass::CSharedFragment T>
    void ForEachSharedFragmentConditional(TFunctionRef< bool(T& /*SharedFragment*/) > ConditionFunction, TFunctionRef< void(T& /*SharedFragment*/) > ExecuteFunction);
 
    template<UE::Mass::CConstSharedFragment T>
    void ForEachConstSharedFragment(TFunctionRef< void(const T& /*ConstSharedFragment*/) > ExecuteFunction);
 
    template<UE::Mass::CConstSharedFragment T>
    void ForEachConstSharedFragmentConditional(TFunctionRef< bool(const T& /*ConstSharedFragment*/) > ConditionFunction, TFunctionRef< void(const T& /*ConstSharedFragment*/) > ExecuteFunction);
 
    //-----------------------------------------------------------------------------
    // Relations
    //-----------------------------------------------------------------------------
    UE::Mass::FRelationManager& GetRelationManager();
 
    template<UE::Mass::CRelation T>
    bool BatchCreateRelations(TArrayView<FMassEntityHandle> Subjects, TArrayView<FMassEntityHandle> Objects);
    UE_API bool BatchCreateRelations(const UE::Mass::FTypeHandle RelationTypeHandle, TArrayView<FMassEntityHandle> Subjects, TArrayView<FMassEntityHandle> Objects);
 
    //-----------------------------------------------------------------------------
    // Type management
    //-----------------------------------------------------------------------------
    void OnNewTypeRegistered(UE::Mass::FTypeHandle RegisteredTypeHandle);
 
protected:
    void OnRelationTypeRegistered(UE::Mass::FTypeHandle RegisteredTypeHandle, const UE::Mass::FRelationTypeTraits& RelationTypeTraits);
 
public:
    //-----------------------------------------------------------------------------
    // Entity Builder
    //-----------------------------------------------------------------------------
    [[nodiscard]] UE_API UE::Mass::FEntityBuilder MakeEntityBuilder();
 
    //-----------------------------------------------------------------------------
    // Sub-Managers
    //-----------------------------------------------------------------------------
    const UE::Mass::FTypeManager& GetTypeManager() const;
    UE::Mass::FTypeManager& GetTypeManager();
 
    FMassObserverManager& GetObserverManager() { return ObserverManager; }
 
    FOnNewArchetypeDelegate& GetOnNewArchetypeEvent() { return OnNewArchetypeEvent; }
    UWorld* GetWorld() const { return Owner.IsValid() ? Owner->GetWorld() : nullptr; }
    UObject* GetOwner() const { return Owner.Get(); }
 
    bool IsDuringEntityCreation() const;
 
    UE_API void SetDebugName(const FString& NewDebugGame);
#if WITH_MASSENTITY_DEBUG
    UE_API void DebugPrintArchetypes(FOutputDevice& Ar, const bool bIncludeEmpty = true) const;
    UE_API void DebugGetArchetypesStringDetails(FOutputDevice& Ar, const bool bIncludeEmpty = true) const;
    UE_API void DebugGetArchetypeFragmentTypes(const FMassArchetypeHandle& Archetype, TArray<const UScriptStruct*>& InOutFragmentList) const;
    UE_API int32 DebugGetArchetypeEntitiesCount(const FMassArchetypeHandle& Archetype) const;
    UE_API int32 DebugGetArchetypeEntitiesCountPerChunk(const FMassArchetypeHandle& Archetype) const;
    UE_API int32 DebugGetEntityCount() const;
    UE_API int32 DebugGetArchetypesCount() const;
    UE_API void DebugRemoveAllEntities();
    UE_API void DebugForceArchetypeDataVersionBump();
    UE_API void DebugGetArchetypeStrings(const FMassArchetypeHandle& Archetype, TArray<FName>& OutFragmentNames, TArray<FName>& OutTagNames);
    UE_DEPRECATED(5.7, "Using CreateEntityIndexHandle instead.")
    UE_API FMassEntityHandle DebugGetEntityIndexHandle(const int32 EntityIndex) const;
    UE_API const FString& DebugGetName() const;
 
    enum class EDebugFeatures
    {
        None,
        TraceProcessors = 1 << 0, // Used to track information about processors such as their name.
        All = TraceProcessors
    };
 
    UE_API void DebugEnableDebugFeature(EDebugFeatures Features);
    UE_API void DebugDisableDebugFeature(EDebugFeatures Features);
    UE_API bool DebugHasAllDebugFeatures(EDebugFeatures Features) const;
 
    UE_API FMassRequirementAccessDetector& GetRequirementAccessDetector();
 
    // For use by the friend MassDebugger
    UE_API UE::Mass::FStorageType& DebugGetEntityStorageInterface();
    // For use by the friend MassDebugger
    UE_API const UE::Mass::FStorageType& DebugGetEntityStorageInterface() const;
 
    UE_API bool DebugHasCommandsToFlush() const;
#endif // WITH_MASSENTITY_DEBUG
 
protected:
    UE_API void OnPostFork(EForkProcessRole Role);
 
    UE_API void GetMatchingArchetypes(const FMassFragmentRequirements& Requirements, TArray<FMassArchetypeHandle>& OutValidArchetypes, const uint32 FromArchetypeDataVersion) const;
    
    UE_API FMassArchetypeHandle InternalCreateSimilarArchetype(const TSharedPtr<FMassArchetypeData>& SourceArchetype, const FMassTagBitSet& OverrideTags);
    UE_API FMassArchetypeHandle InternalCreateSimilarArchetype(const TSharedPtr<FMassArchetypeData>& SourceArchetype, const FMassFragmentBitSet& OverrideFragments);
    UE_API FMassArchetypeHandle InternalCreateSimilarArchetype(const TSharedPtr<FMassArchetypeData>& SourceArchetype, const UE::Mass::FArchetypeGroups& GroupsOverride);
    UE_API FMassArchetypeHandle InternalCreateSimilarArchetype(const FMassArchetypeData& SourceArchetypeRef, FMassArchetypeCompositionDescriptor&& NewComposition, const UE::Mass::FArchetypeGroups& GroupsOverride);
 
    UE_API void InternalAppendFragmentsAndTagsToArchetypeCompositionDescriptor(FMassArchetypeCompositionDescriptor& InOutComposition,
        TConstArrayView<const UScriptStruct*> FragmentsAndTagsList) const;
 
private:
    void InternalBuildEntity(FMassEntityHandle EntityHandle, const FMassArchetypeHandle& ArchetypeHandle, const FMassArchetypeSharedFragmentValues& SharedFragmentValues);
    void InternalReleaseEntity(FMassEntityHandle EntityHandle);
 
    FMassFragmentBitSet InternalAddFragmentListToEntityChecked(FMassEntityHandle EntityHandle, const FMassFragmentBitSet& InFragments);
 
    void InternalAddFragmentListToEntity(FMassEntityHandle EntityHandle, const FMassFragmentBitSet& InFragments);
    UE_API void* InternalGetFragmentDataChecked(FMassEntityHandle EntityHandle, const UScriptStruct* FragmentType) const;
    UE_API void* InternalGetFragmentDataPtr(FMassEntityHandle EntityHandle, const UScriptStruct* FragmentType) const;
    UE_API const FConstSharedStruct* InternalGetConstSharedFragmentPtr(FMassEntityHandle EntityHandle, const UScriptStruct* ConstSharedFragmentType) const;
    UE_API const FSharedStruct* InternalGetSharedFragmentPtr(FMassEntityHandle EntityHandle, const UScriptStruct* SharedFragmentType) const;
 
    TSharedRef<FEntityCreationContext> InternalBatchCreateReservedEntities(const FMassArchetypeHandle& ArchetypeHandle,
        const FMassArchetypeSharedFragmentValues& SharedFragmentValues, TConstArrayView<FMassEntityHandle> ReservedEntities);
 
    UE::Mass::FStorageType& GetEntityStorageInterface() const
    {
#if WITH_MASS_CONCURRENT_RESERVE
        using namespace UE::Mass;
        struct StorageSelector
        {
            UE::Mass::IEntityStorageInterface* operator()(FEmptyVariantState&) const
            {
                checkf(false, TEXT("Attempt to use EntityStorageInterface without initialization"));
                return nullptr;
            }
            UE::Mass::IEntityStorageInterface* operator()(FSingleThreadedEntityStorage& Storage) const
            {
                return &Storage;
            }
            UE::Mass::IEntityStorageInterface* operator()(FConcurrentEntityStorage& Storage) const
            {
                return &Storage;
            }
        };
 
        UE::Mass::IEntityStorageInterface* Interface = Visit(StorageSelector{}, EntityStorage);
 
        return *Interface;
#else   
        return EntityStorage.Get<UE::Mass::FSingleThreadedEntityStorage>();
#endif
    }
 
    bool DebugDoCollectionsOverlapCreationContext(TConstArrayView<FMassArchetypeEntityCollection> EntityCollections) const;
        
private:
 
    friend struct UE::Mass::Private::FEntityStorageInitializer;
    using FEntityStorageContainerType = TVariant<
        FEmptyVariantState,
        UE::Mass::FSingleThreadedEntityStorage,
        UE::Mass::FConcurrentEntityStorage>;
    mutable FEntityStorageContainerType EntityStorage;
#if WITH_MASSENTITY_DEBUG
    UE::Mass::FStorageType* DebugEntityStoragePtr = nullptr;
#endif // WITH_MASSENTITY_DEBUG
 
    std::atomic<int32> ProcessingScopeCount = 0;
 
    // the "version" number increased every time an archetype gets added
    uint32 ArchetypeDataVersion = 0;
 
    // Map of hash of sorted fragment list to archetypes with that hash
    TMap<uint32, TArray<TSharedPtr<FMassArchetypeData>>> FragmentHashToArchetypeMap;
 
    // Map to list of archetypes that contain the specified fragment type
    TMap<const UScriptStruct*, TArray<TSharedPtr<FMassArchetypeData>>> FragmentTypeToArchetypeMap;
 
    // Contains all archetypes ever created. The array always growing and a given archetypes remains at a given index 
    // throughout its lifetime, and the index is never reused for another archetype. 
    TArray<TSharedPtr<FMassArchetypeData>> AllArchetypes;
 
    template<typename TSharedStructType>
    struct TSharedFragmentsContainer
    {
        TArray<TSharedStructType>* Find(const UScriptStruct* Type)
        {
            return TypeToInstanceMap.Find(Type);
        }
 
        TSharedStructType& FindOrAdd(const uint32 Hash, const UScriptStruct* Type, const uint8* Data)
        {
            for (TMultiMap<uint32, int32>::TConstKeyIterator It = HashToInstanceIndexMap.CreateConstKeyIterator(Hash); It; ++It)
            {
                TSharedStructType& Instance = Instances[It.Value()];
 
                if (Instance.GetScriptStruct() == Type
                    && Type->CompareScriptStruct(Instance.GetMemory(), Data, PPF_None))
                {
                    return Instance;
                }
            }
 
            int32 Index = Add(TSharedStructType::Make(Type, Data));
            HashToInstanceIndexMap.Add(Hash, Index);
            return Instances[Index];
        }
 
        template<typename T, typename... TArgs>
        TSharedStructType& FindOrAdd(const uint32 Hash, TArgs&&... InArgs)
        {
            // Need to actually construct the struct to make proper comparison to possible existing instance
            TSharedStructType TempInstance = Make<T>(Forward<TArgs>(InArgs)...);
 
            for (TMultiMap<uint32, int32>::TConstKeyIterator It = HashToInstanceIndexMap.CreateConstKeyIterator(Hash); It; ++It)
            {
                TSharedStructType& Instance = Instances[It.Value()];
 
                if (Instance.GetScriptStruct() == T::StaticStruct()
                    && T::StaticStruct()->CompareScriptStruct(Instance.GetMemory(), TempInstance.GetMemory(), PPF_None))
                {
                    return Instance;
                }
            }
 
            int32 Index = Add(MoveTemp(TempInstance));
            HashToInstanceIndexMap.Add(Hash, Index);
            return Instances[Index];
        }
 
        TSharedStructType& operator[](const int32 Index)
        {
            return Instances[Index];
        }
 
        TArrayView<TSharedStructType> GetAllInstances()
        {
            return Instances;
        }
 
    private:
        int32 Add(TSharedStructType&& SharedStruct)
        {
            TArray<TSharedStructType>& InstancesOfType = TypeToInstanceMap.FindOrAdd(SharedStruct.GetScriptStruct(), {});
            const int32 Index = Instances.Add(Forward<TSharedStructType>(SharedStruct));
            // note that even though we're copying the input F[Const]SharedStruct instance it's perfectly fine since 
            // F[Const]SharedStruct does guarantee there's not going to be data duplication (via a member shared pointer to hosted data)
            InstancesOfType.Add(Instances[Index]);
            return Index;
        }
 
        TArray<TSharedStructType> Instances;
        // Hash/Index in array pair
        TMultiMap<uint32, int32> HashToInstanceIndexMap;
        // Maps specific struct type to a collection of FSharedStruct instances of that type
        TMap<const UScriptStruct*, TArray<TSharedStructType>> TypeToInstanceMap;
    };
 
    TSharedFragmentsContainer<FConstSharedStruct> ConstSharedFragmentsContainer;
    TSharedFragmentsContainer<FSharedStruct> SharedFragmentsContainer;
 
    FMassObserverManager ObserverManager;
 
    TSharedRef<UE::Mass::FTypeManager> TypeManager;
    UE::Mass::FRelationManager RelationManager;
 
    TMap<const FName, const int32> GroupNameToTypeIndex;
    // @todo we'll probably have some "GroupTypeInformation" here in the future
    TArray<const FName> GroupTypes;
 
#if WITH_MASSENTITY_DEBUG
    FMassRequirementAccessDetector RequirementAccessDetector;
    FString DebugName;
    EDebugFeatures EnabledDebugFeatures = EDebugFeatures::All;
#endif // WITH_MASSENTITY_DEBUG
 
    TWeakObjectPtr<UObject> Owner;
 
    FOnNewArchetypeDelegate OnNewArchetypeEvent;
 
    FDelegateHandle OnPostForkHandle;
 
    static constexpr int32 NumCommandBuffers = 2;
    TStaticArray<TSharedPtr<FMassCommandBuffer>, NumCommandBuffers> DeferredCommandBuffers;
    uint8 OpenedCommandBufferIndex = 0;
    std::atomic<bool> bCommandBufferFlushingInProgress = false;
    bool bFirstCommandFlush = true;
 
    enum class EInitializationState : uint8
    {
        Uninitialized,
        Initialized,
        Deinitialized
    };
 
    EInitializationState InitializationState = EInitializationState::Uninitialized;
 
    //-----------------------------------------------------------------------------
    // DEPRECATED
    //-----------------------------------------------------------------------------
protected:
    UE_DEPRECATED(5.6, "This flavor of InternalCreateSimilarArchetype is deprecated due to the introduction of archetype grouping. Use InternalCreateSimilarArchetype with a FArchetypeGroups parameter instead")
    UE_API FMassArchetypeHandle InternalCreateSimilarArchetype(const FMassArchetypeData& SourceArchetypeRef, FMassArchetypeCompositionDescriptor&& NewComposition);
public:
    UE_DEPRECATED(5.6, "SetEntityFragmentsValues is deprecated. Use SetEntityFragmentValues instead (note the slight change in name).")
    UE_API void SetEntityFragmentsValues(FMassEntityHandle EntityHandle, TArrayView<const FInstancedStruct> FragmentInstanceList);
 
    UE_DEPRECATED(5.6, "Static BatchSetEntityFragmentsValues is deprecated. Use EntityManager's member function BatchSetEntityFragmentValues (note the slight change in name).")
    static UE_API void BatchSetEntityFragmentsValues(const FMassArchetypeEntityCollection& SparseEntities, TArrayView<const FInstancedStruct> FragmentInstanceList);
 
    UE_DEPRECATED(5.6, "Static BatchSetEntityFragmentsValues is deprecated. Use EntityManager's member function BatchSetEntityFragmentValues (note the slight change in name).")
    static UE_API void BatchSetEntityFragmentsValues(TConstArrayView<FMassArchetypeEntityCollection> EntityCollections, TArrayView<const FInstancedStruct> FragmentInstanceList);
 
    template<UE::Mass::CConstSharedFragment T>
    UE_DEPRECATED(5.6, "Using ForEachSharedFragment for Const Shared Fragments has been deprecated. Use ForEachConstSharedFragment instead.")
    void ForEachSharedFragment(TFunctionRef< void(T& /*SharedFragment*/) > ExecuteFunction)
    {
    }
 
    template<UE::Mass::CConstSharedFragment T>
    UE_DEPRECATED(5.6, "Using ForEachSharedFragmentConditional for Const Shared Fragments has been deprecated. Use ForEachConstSharedFragmentConditional instead.")
    void ForEachSharedFragmentConditional(TFunctionRef< bool(T& /*SharedFragment*/) > ConditionFunction, TFunctionRef< void(T& /*SharedFragment*/) > ExecuteFunction)
    {
    }
};
 
//-----------------------------------------------------------------------------
// INLINE
//-----------------------------------------------------------------------------
 
#if WITH_MASSENTITY_DEBUG
ENUM_CLASS_FLAGS(FMassEntityManager::EDebugFeatures);
#endif
 
template<UE::Mass::CSharedFragment T>
void FMassEntityManager::ForEachSharedFragment(TFunctionRef< void(T& /*SharedFragment*/) > ExecuteFunction)
{
    if (TArray<FSharedStruct>* InstancesOfType = SharedFragmentsContainer.Find(T::StaticStruct()))
    {
        for (const FSharedStruct& SharedStruct : *InstancesOfType)
        {
            ExecuteFunction(SharedStruct.Get<T>());
        }
    }
}
 
template<UE::Mass::CSharedFragment T>
void FMassEntityManager::ForEachSharedFragmentConditional(TFunctionRef< bool(T& /*SharedFragment*/) > ConditionFunction, TFunctionRef< void(T& /*SharedFragment*/) > ExecuteFunction)
{
    if (TArray<FSharedStruct>* InstancesOfType = SharedFragmentsContainer.Find(T::StaticStruct()))
    {
        for (const FSharedStruct& SharedStruct : *InstancesOfType)
        {
            T& StructInstanceRef = SharedStruct.Get<T>();
            if (ConditionFunction(StructInstanceRef))
            {
                ExecuteFunction(StructInstanceRef);
            }
        }
    }
}
 
template<UE::Mass::CConstSharedFragment T>
void FMassEntityManager::ForEachConstSharedFragment(TFunctionRef< void(const T& /*ConstSharedFragment*/) > ExecuteFunction)
{
    if (TArray<FConstSharedStruct>* InstancesOfType = ConstSharedFragmentsContainer.Find(T::StaticStruct()))
    {
        for (const FConstSharedStruct& SharedStruct : *InstancesOfType)
        {
            ExecuteFunction(SharedStruct.Get<const T>());
        }
    }
}
 
template<UE::Mass::CConstSharedFragment T>
void FMassEntityManager::ForEachConstSharedFragmentConditional(TFunctionRef< bool(const T& /*ConstSharedFragment*/) > ConditionFunction, TFunctionRef< void(const T& /*ConstSharedFragment*/) > ExecuteFunction)
{
    if (TArray<FConstSharedStruct>* InstancesOfType = ConstSharedFragmentsContainer.Find(T::StaticStruct()))
    {
        for (const FConstSharedStruct& SharedStruct : *InstancesOfType)
        {
            const T& StructInstanceRef = SharedStruct.Get<const T>();
            if (ConditionFunction(StructInstanceRef))
            {
                ExecuteFunction(StructInstanceRef);
            }
        }
    }
}
 
inline const UE::Mass::FTypeManager& FMassEntityManager::GetTypeManager() const
{
    return *TypeManager;
}
 
inline UE::Mass::FTypeManager& FMassEntityManager::GetTypeManager()
{
    return *TypeManager;
}
 
inline bool FMassEntityManager::IsDuringEntityCreation() const
{
    return ObserverManager.GetCreationContext().IsValid();
}
 
inline TSharedRef<FMassObserverManager::FObserverLock> FMassEntityManager::GetOrMakeObserversLock()
{
    return ObserverManager.GetOrMakeObserverLock();
}
 
inline UE::Mass::FRelationManager& FMassEntityManager::GetRelationManager()
{
    return RelationManager;
}
 
template<UE::Mass::CRelation T>
bool FMassEntityManager::BatchCreateRelations(TArrayView<FMassEntityHandle> Subjects, TArrayView<FMassEntityHandle> Objects)
{
    return BatchCreateRelations(UE::Mass::FTypeManager::MakeTypeHandle(T::StaticStruct()), Subjects, Objects);
}
 
#undef UE_API