MassArchetypeData.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "MassEntityHandle.h"
#include "MassArchetypeTypes.h"
#include "MassArchetypeGroup.h"
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "MassEntityManager.h"
#endif // UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "HAL/LowLevelMemTracker.h"
 
struct FMassEntityQuery;
struct FMassExecutionContext;
class FOutputDevice;
struct FMassArchetypeEntityCollection;
struct FMassFragmentRequirementDescription;
struct FMassFragmentRequirements;
 
namespace UE::Mass
{
    uint32 SanitizeChunkMemorySize(const uint32 InChunkMemorySize, const bool bLogMismatch = true);
}
 
// This is one chunk within an archetype
struct FMassArchetypeChunk
{
private:
    uint8* RawMemory = nullptr;
    SIZE_T AllocSize = 0;
    int32 NumInstances = 0;
    int32 SerialModificationNumber = 0;
    TArray<FInstancedStruct> ChunkFragmentData;
    FMassArchetypeSharedFragmentValues SharedFragmentValues;
 
public:
    explicit FMassArchetypeChunk(const SIZE_T InAllocSize, TConstArrayView<FInstancedStruct> InChunkFragmentTemplates, FMassArchetypeSharedFragmentValues InSharedFragmentValues)
        : AllocSize(InAllocSize)
        , ChunkFragmentData(InChunkFragmentTemplates)
        , SharedFragmentValues(InSharedFragmentValues)
    {
        
        LLM_SCOPE_BYNAME(TEXT("Mass/ArchetypeChunk"));
        RawMemory = (uint8*)FMemory::Malloc(AllocSize);
    }
 
    ~FMassArchetypeChunk()
    {
        // Only release memory if it was not done already.
        if (RawMemory != nullptr)
        {
            FMemory::Free(RawMemory);
            RawMemory = nullptr;
        }
    }
 
    // Returns the Entity array element at the specified index
    FMassEntityHandle& GetEntityArrayElementRef(int32 ChunkBase, int32 IndexWithinChunk)
    {
        uint8* RawMemoryChunkBase = RawMemory + ChunkBase;
        checkSlow(ChunkBase + IndexWithinChunk * sizeof(FMassEntityHandle) < AllocSize
            && (reinterpret_cast<SIZE_T>(RawMemoryChunkBase) % alignof(FMassEntityHandle)) == 0);
        return reinterpret_cast<FMassEntityHandle*>(RawMemoryChunkBase)[IndexWithinChunk];
    }
 
    const FMassEntityHandle* GetEntityArray(int32 ChunkBase) const
    {
        uint8* RawMemoryChunkBase = RawMemory + ChunkBase;
        checkSlow(ChunkBase < AllocSize
            && (reinterpret_cast<SIZE_T>(RawMemoryChunkBase) % alignof(FMassEntityHandle)) == 0);
        return reinterpret_cast<const FMassEntityHandle*>(RawMemoryChunkBase);
    }
 
    uint8* GetRawMemory() const
    {
        return RawMemory;
    }
 
    int32 GetNumInstances() const
    {
        return NumInstances;
    }
 
    void AddMultipleInstances(uint32 Count)
    {
        NumInstances += Count;
        SerialModificationNumber++;
    }
 
    void RemoveMultipleInstances(uint32 Count)
    {
        NumInstances -= Count;
        check(NumInstances >= 0);
        SerialModificationNumber++;
 
        // Because we only remove trailing chunks to avoid messing up the absolute indices in the entities map,
        // We are freeing the memory here to save memory
        if (NumInstances == 0)
        {
            FMemory::Free(RawMemory);
            RawMemory = nullptr;
        }
    }
 
    void AddInstance()
    {
        AddMultipleInstances(1);
    }
 
    void RemoveInstance()
    {
        RemoveMultipleInstances(1);
    }
 
    int32 GetSerialModificationNumber() const
    {
        return SerialModificationNumber;
    }
 
    FStructView GetMutableChunkFragmentViewChecked(const int32 Index) { return FStructView(ChunkFragmentData[Index]); }
 
    FInstancedStruct* FindMutableChunkFragment(const UScriptStruct* Type)
    {
        return ChunkFragmentData.FindByPredicate([Type](const FInstancedStruct& Element)
            {
                return Element.GetScriptStruct()->IsChildOf(Type);
            });
    }
 
    void Recycle(TConstArrayView<FInstancedStruct> InChunkFragmentsTemplate, const FMassArchetypeSharedFragmentValues& InSharedFragmentValues)
    {
        checkf(NumInstances == 0, TEXT("Recycling a chunk that is not empty."));
        SerialModificationNumber++;
        ChunkFragmentData = InChunkFragmentsTemplate;
        SharedFragmentValues = InSharedFragmentValues;
        
        // If this chunk previously had entity and it does not anymore, we might have to reallocate the memory as it was freed to save memory
        if (RawMemory == nullptr)
        {
            RawMemory = (uint8*)FMemory::Malloc(AllocSize);
        }
    }
 
    bool IsValidSubChunk(const int32 StartIndex, const int32 Length) const
    {
        return StartIndex >= 0 && StartIndex < NumInstances && (StartIndex + Length) <= NumInstances;
    }
 
#if WITH_MASSENTITY_DEBUG
    int32 DebugGetChunkFragmentCount() const { return ChunkFragmentData.Num(); }
#endif // WITH_MASSENTITY_DEBUG
 
    FMassArchetypeSharedFragmentValues& GetMutableSharedFragmentValues() { return SharedFragmentValues; }
    const FMassArchetypeSharedFragmentValues& GetSharedFragmentValues() const { return SharedFragmentValues; }
};
 
// Information for a single fragment type in an archetype
struct FMassArchetypeFragmentConfig
{
    const UScriptStruct* FragmentType = nullptr;
    int32 ArrayOffsetWithinChunk = 0;
 
    void* GetFragmentData(uint8* ChunkBase, int32 IndexWithinChunk) const
    {
        return ChunkBase + ArrayOffsetWithinChunk + (IndexWithinChunk * FragmentType->GetStructureSize());
    }
};
 
// An archetype is defined by a collection of unique fragment types (no duplicates).
// Order doesn't matter, there will only ever be one FMassArchetypeData per unique set of fragment types per entity manager subsystem
struct FMassArchetypeData
{
private:
    // One-stop-shop variable describing the archetype's fragment and tag composition 
    FMassArchetypeCompositionDescriptor CompositionDescriptor;
 
    // Pre-created default chunk fragment templates
    TArray<FInstancedStruct> ChunkFragmentsTemplate;
 
    TArray<FMassArchetypeFragmentConfig, TInlineAllocator<16>> FragmentConfigs;
    
    TArray<FMassArchetypeChunk> Chunks;
 
    // Entity ID to index within archetype
    //@TODO: Could be folded into FEntityData in the entity manager at the expense of a bit
    // of loss of encapsulation and extra complexity during archetype changes
    TMap<int32, int32> EntityMap;
    
    TMap<const UScriptStruct*, int32> FragmentIndexMap;
 
    UE::Mass::FArchetypeGroups Groups;
 
    int32 NumEntitiesPerChunk;
    uint32 TotalBytesPerEntity = 0;
    int32 EntityListOffsetWithinChunk;
 
    uint32 CreatedArchetypeDataVersion = 0;
 
    uint32 EntityOrderVersion = 0;
 
    const uint32 ChunkMemorySize = 0;
 
#if WITH_MASSENTITY_DEBUG
    TArray<FName> DebugNames;
 
    FColor DebugColor;
#endif // WITH_MASSENTITY_DEBUG
    
    friend FMassEntityQuery;
    friend FMassArchetypeEntityCollection;
    friend FMassDebugger;
 
public:
    explicit FMassArchetypeData(const FMassArchetypeCreationParams& CreationParams = FMassArchetypeCreationParams());
 
    TConstArrayView<FMassArchetypeFragmentConfig> GetFragmentConfigs() const { return FragmentConfigs; }
    const FMassFragmentBitSet& GetFragmentBitSet() const { return CompositionDescriptor.GetFragments(); }
    const FMassTagBitSet& GetTagBitSet() const { return CompositionDescriptor.GetTags(); }
    const FMassChunkFragmentBitSet& GetChunkFragmentBitSet() const { return CompositionDescriptor.GetChunkFragments(); }
    const FMassSharedFragmentBitSet& GetSharedFragmentBitSet() const { return CompositionDescriptor.GetSharedFragments(); }
    const FMassConstSharedFragmentBitSet& GetConstSharedFragmentBitSet() const { return CompositionDescriptor.GetConstSharedFragments(); }
 
    const FMassArchetypeCompositionDescriptor& GetCompositionDescriptor() const { return CompositionDescriptor; }
    FORCEINLINE const FMassArchetypeSharedFragmentValues& GetSharedFragmentValues(int32 EntityIndex) const
    { 
        const int32 AbsoluteIndex = EntityMap.FindChecked(EntityIndex);
        const int32 ChunkIndex = AbsoluteIndex / NumEntitiesPerChunk;
 
        return Chunks[ChunkIndex].GetSharedFragmentValues();
    }
    FORCEINLINE const FMassArchetypeSharedFragmentValues& GetSharedFragmentValues(FMassEntityHandle Entity) const
    {
        return GetSharedFragmentValues(Entity.Index);
    }
 
    const UE::Mass::FArchetypeGroups& GetGroups() const;
    bool IsInGroup(const UE::Mass::FArchetypeGroupHandle GroupHandle) const;
    bool IsInGroupOfType(const UE::Mass::FArchetypeGroupType GroupType) const;
 
    void ForEachFragmentType(TFunction< void(const UScriptStruct* /*FragmentType*/)> Function) const;
    bool HasFragmentType(const UScriptStruct* FragmentType) const;
    bool HasTagType(const UScriptStruct* FragmentType) const { check(FragmentType); return CompositionDescriptor.GetTags().Contains(*FragmentType); }
 
    bool IsEquivalent(const FMassArchetypeCompositionDescriptor& OtherCompositionDescriptor, const UE::Mass::FArchetypeGroups& OtherGroups) const;
 
    void Initialize(const FMassEntityManager& EntityManager, const FMassArchetypeCompositionDescriptor& InCompositionDescriptor, const uint32 ArchetypeDataVersion);
 
    void InitializeWithSimilar(const FMassEntityManager& EntityManager, const FMassArchetypeData& BaseArchetype
        , FMassArchetypeCompositionDescriptor&& NewComposition, const UE::Mass::FArchetypeGroups& InGroups, const uint32 ArchetypeDataVersion);
 
    void AddEntity(FMassEntityHandle Entity, const FMassArchetypeSharedFragmentValues& InSharedFragmentValues);
    void RemoveEntity(FMassEntityHandle Entity);
 
    bool HasFragmentDataForEntity(const UScriptStruct* FragmentType, int32 EntityIndex) const;
    void* GetFragmentDataForEntityChecked(const UScriptStruct* FragmentType, int32 EntityIndex) const;
    void* GetFragmentDataForEntity(const UScriptStruct* FragmentType, int32 EntityIndex) const;
 
    FORCEINLINE const int32* GetInternalIndexForEntity(const int32 EntityIndex) const { return EntityMap.Find(EntityIndex); }
    FORCEINLINE int32 GetInternalIndexForEntityChecked(const int32 EntityIndex) const { return EntityMap.FindChecked(EntityIndex); }
    int32 GetNumEntitiesPerChunk() const { return NumEntitiesPerChunk; }
    SIZE_T GetBytesPerEntity() const { return TotalBytesPerEntity; }
 
    int32 GetNumEntities() const { return EntityMap.Num(); }
 
    SIZE_T GetChunkAllocSize() const { return ChunkMemorySize; }
 
    int32 GetChunkCount() const { return Chunks.Num(); }
    int32 GetNonEmptyChunkCount() const;
 
    FORCEINLINE static int32 CalculateRangeLength(FMassArchetypeEntityCollection::FArchetypeEntityRange EntityRange, const FMassArchetypeChunk& Chunk)
    {
        return EntityRange.Length > 0
            ? EntityRange.Length
            : (Chunk.GetNumInstances() - EntityRange.SubchunkStart);    
    }
 
    int32 CalculateRangeLength(FMassArchetypeEntityCollection::FArchetypeEntityRange EntityRange) const
    {
        check(Chunks.IsValidIndex(EntityRange.ChunkIndex));
        const FMassArchetypeChunk& Chunk = Chunks[EntityRange.ChunkIndex];
        return CalculateRangeLength(EntityRange, Chunk);
    }
 
    uint32 GetCreatedArchetypeDataVersion() const;
    uint32 GetEntityOrderVersion() const;
 
    void ExecuteFunction(FMassExecutionContext& RunContext, const FMassExecuteFunction& Function, const FMassQueryRequirementIndicesMapping& RequirementMapping
        , FMassArchetypeEntityCollection::FConstEntityRangeArrayView EntityRangeContainer, const FMassChunkConditionFunction& ChunkCondition);
    void ExecuteFunction(FMassExecutionContext& RunContext, const FMassExecuteFunction& Function, const FMassQueryRequirementIndicesMapping& RequirementMapping
        , const FMassChunkConditionFunction& ChunkCondition, UE::Mass::FExecutionLimiter* ExecutionLimiter = nullptr);
 
    void ExecutionFunctionForChunk(FMassExecutionContext& RunContext, const FMassExecuteFunction& Function, const FMassQueryRequirementIndicesMapping& RequirementMapping
        , const FMassArchetypeEntityCollection::FArchetypeEntityRange& EntityRange, const FMassChunkConditionFunction& ChunkCondition = FMassChunkConditionFunction());
 
    int32 CompactEntities(const double TimeAllowed);
 
    void MoveEntityToAnotherArchetype(const FMassEntityHandle Entity, FMassArchetypeData& NewArchetype, const FMassArchetypeSharedFragmentValues* SharedFragmentValuesOverride = nullptr);
 
    void SetFragmentsData(const FMassEntityHandle Entity, TArrayView<const FInstancedStruct> FragmentSources);
 
    void SetFragmentData(FMassArchetypeEntityCollection::FConstEntityRangeArrayView EntityRangeContainer, const FInstancedStruct& FragmentSource);
 
    void GetRequirementsFragmentMapping(TConstArrayView<FMassFragmentRequirementDescription> Requirements, FMassFragmentIndicesMapping& OutFragmentIndices) const;
 
    void GetRequirementsChunkFragmentMapping(TConstArrayView<FMassFragmentRequirementDescription> ChunkRequirements, FMassFragmentIndicesMapping& OutFragmentIndices) const;
 
    void GetRequirementsConstSharedFragmentMapping(TConstArrayView<FMassFragmentRequirementDescription> Requirements, FMassFragmentIndicesMapping& OutFragmentIndices) const;
 
    void GetRequirementsSharedFragmentMapping(TConstArrayView<FMassFragmentRequirementDescription> Requirements, FMassFragmentIndicesMapping& OutFragmentIndices) const;
 
    SIZE_T GetAllocatedSize() const;
 
    void ExportEntityHandles(const TConstArrayView<FMassArchetypeEntityCollection::FArchetypeEntityRange> Ranges, TArray<FMassEntityHandle>& InOutHandles) const;
 
    void ExportEntityHandles(TArray<FMassEntityHandle>& InOutHandles) const;
 
    // Converts the list of fragments into a user-readable debug string
    FString DebugGetDescription() const;
 
    void CopyDebugNamesFrom(const FMassArchetypeData& Other)
    { 
#if WITH_MASSENTITY_DEBUG
        DebugNames = Other.DebugNames; 
#endif // WITH_MASSENTITY_DEBUG
    }
 
#if WITH_MASSENTITY_DEBUG
    void DebugGetEntityMemoryNumbers(SIZE_T& OutActiveChunksMemorySize, SIZE_T& OutActiveEntitiesMemorySize) const;
 
    void AddUniqueDebugName(const FName& Name) { DebugNames.AddUnique(Name); }
    
    const TConstArrayView<FName> GetDebugNames() const { return DebugNames; }
    
    FString GetCombinedDebugNamesAsString() const;
 
    void DebugPrintArchetype(FOutputDevice& Ar);
 
    void DebugPrintEntity(FMassEntityHandle Entity, FOutputDevice& Ar, const TCHAR* InPrefix = TEXT("")) const;
#endif // WITH_MASSENTITY_DEBUG
 
    void SetDebugColor(const FColor InDebugColor);
 
    void REMOVEME_GetArrayViewForFragmentInChunk(int32 ChunkIndex, const UScriptStruct* FragmentType, void*& OutChunkBase, int32& OutNumEntities);
 
    // low level api
    FORCEINLINE const int32* GetFragmentIndex(const UScriptStruct* FragmentType) const { return FragmentIndexMap.Find(FragmentType); }
    FORCEINLINE int32 GetFragmentIndexChecked(const UScriptStruct* FragmentType) const { return FragmentIndexMap.FindChecked(FragmentType); }
 
    FORCEINLINE void* GetFragmentData(const int32 FragmentIndex, const FMassRawEntityInChunkData RawEntityInChunkHandle) const
    {
        return FragmentConfigs[FragmentIndex].GetFragmentData(RawEntityInChunkHandle.ChunkRawMemory, RawEntityInChunkHandle.IndexWithinChunk);
    }
 
    FORCEINLINE bool IsValidHandle(const FMassEntityInChunkDataHandle Handle) const
    {
        return Handle.IsSet() && Chunks.IsValidIndex(Handle.ChunkIndex) && Chunks[Handle.ChunkIndex].GetSerialModificationNumber() == Handle.ChunkSerialNumber;
    }
 
    FORCEINLINE void* GetFragmentData(const int32 FragmentIndex, const FMassEntityInChunkDataHandle EntityInChunkHandle) const
    {
        checkf(IsValidHandle(EntityInChunkHandle), TEXT("Input FMassRawEntityInChunkData is out of date."));
        return FragmentConfigs[FragmentIndex].GetFragmentData(EntityInChunkHandle.ChunkRawMemory, EntityInChunkHandle.IndexWithinChunk);
    }
 
    FORCEINLINE FMassRawEntityInChunkData MakeRawEntityHandle(int32 EntityIndex) const
    {
        const int32 AbsoluteIndex = EntityMap.FindChecked(EntityIndex);
        const int32 ChunkIndex = AbsoluteIndex / NumEntitiesPerChunk;
    
        return FMassRawEntityInChunkData(Chunks[ChunkIndex].GetRawMemory(), AbsoluteIndex % NumEntitiesPerChunk);
    }
 
    FORCEINLINE FMassRawEntityInChunkData MakeRawEntityHandle(const FMassEntityHandle Entity) const
    {
        return MakeRawEntityHandle(Entity.Index); 
    }
 
    FORCEINLINE FMassEntityInChunkDataHandle MakeEntityHandle(int32 EntityIndex) const
    {
        const int32 AbsoluteIndex = EntityMap.FindChecked(EntityIndex);
        const int32 ChunkIndex = AbsoluteIndex / NumEntitiesPerChunk;
        const FMassArchetypeChunk& Chunk = Chunks[ChunkIndex];
 
        return FMassEntityInChunkDataHandle(Chunk.GetRawMemory(), AbsoluteIndex % NumEntitiesPerChunk
            , ChunkIndex, Chunk.GetSerialModificationNumber());
    }
 
    FORCEINLINE FMassEntityInChunkDataHandle MakeEntityHandle(const FMassEntityHandle Entity) const
    {
        return MakeEntityHandle(Entity.Index); 
    }
 
    bool IsInitialized() const { return TotalBytesPerEntity > 0 && FragmentConfigs.IsEmpty() == false; }
 
    // batched api
    void BatchDestroyEntityChunks(FMassArchetypeEntityCollection::FConstEntityRangeArrayView EntityRangeContainer, TArray<FMassEntityHandle>& OutEntitiesRemoved);
    void BatchAddEntities(TConstArrayView<FMassEntityHandle> Entities, const FMassArchetypeSharedFragmentValues& SharedFragmentValues
        , TArray<FMassArchetypeEntityCollection::FArchetypeEntityRange>& OutNewRanges);
    void BatchMoveEntitiesToAnotherArchetype(const FMassArchetypeEntityCollection& EntityCollection, FMassArchetypeData& NewArchetype
        , TArray<FMassEntityHandle>& OutEntitiesBeingMoved, TArray<FMassArchetypeEntityCollection::FArchetypeEntityRange>* OutNewChunks = nullptr
        , const FMassArchetypeSharedFragmentValues* SharedFragmentValuesToAdd = nullptr
        , const FMassSharedFragmentBitSet* SharedFragmentToRemoveBitSet = nullptr
        , const FMassConstSharedFragmentBitSet* ConstSharedFragmentToRemoveBitSet = nullptr);
    void BatchSetFragmentValues(TConstArrayView<FMassArchetypeEntityCollection::FArchetypeEntityRange> EntityCollection, const FMassGenericPayloadViewSlice& Payload);
 
protected:
    FMassArchetypeEntityCollection::FArchetypeEntityRange PrepareNextEntitiesSpanInternal(TConstArrayView<FMassEntityHandle> Entities, const FMassArchetypeSharedFragmentValues& InSharedFragmentValues, const int32 StartingChunk = 0);
    void BatchRemoveEntitiesInternal(const int32 ChunkIndex, const int32 StartIndexWithinChunk, const int32 NumberToRemove);
 
    struct FTransientChunkLocation
    {
        uint8* RawChunkMemory;
        int32 IndexWithinChunk;
    };
    void MoveFragmentsToAnotherArchetypeInternal(FMassArchetypeData& TargetArchetype, FTransientChunkLocation Target, const FTransientChunkLocation Source, const int32 ElementsNum);
    void MoveFragmentsToNewLocationInternal(FTransientChunkLocation Target, const FTransientChunkLocation Source, const int32 NumberToMove);
    void ConfigureFragments(const FMassEntityManager& EntityManager);
 
    FORCEINLINE void* GetFragmentData(const int32 FragmentIndex, uint8* ChunkRawMemory, const int32 IndexWithinChunk) const
    {
        return FragmentConfigs[FragmentIndex].GetFragmentData(ChunkRawMemory, IndexWithinChunk);
    }
 
    void BindEntityRequirements(FMassExecutionContext& RunContext, const FMassFragmentIndicesMapping& EntityFragmentsMapping, FMassArchetypeChunk& Chunk, const int32 SubchunkStart, const int32 SubchunkLength);
    void BindChunkFragmentRequirements(FMassExecutionContext& RunContext, const FMassFragmentIndicesMapping& ChunkFragmentsMapping, FMassArchetypeChunk& Chunk);
    void BindConstSharedFragmentRequirements(FMassExecutionContext& RunContext, const FMassArchetypeSharedFragmentValues& SharedFragmentValues, const FMassFragmentIndicesMapping& ChunkFragmentsMapping);
    void BindSharedFragmentRequirements(FMassExecutionContext& RunContext, FMassArchetypeSharedFragmentValues& SharedFragmentValues, const FMassFragmentIndicesMapping& ChunkFragmentsMapping);
 
    void SetSharedFragmentsData(const FMassEntityHandle Entity, TConstArrayView<FSharedStruct> SharedFragmentValueOverrides);
 
    FMassArchetypeChunk& GetOrAddChunk(const FMassArchetypeSharedFragmentValues& SharedFragmentValues, int32& OutAbsoluteIndex, int32& OutIndexWithinChunk);
    
private:
    int32 AddEntityInternal(FMassEntityHandle Entity, const FMassArchetypeSharedFragmentValues& InSharedFragmentValues);
    void RemoveEntityInternal(const int32 AbsoluteIndex);
};
 
 
struct FMassArchetypeHelper
{
    FORCEINLINE static FMassArchetypeData* ArchetypeDataFromHandle(const FMassArchetypeHandle& ArchetypeHandle) { return ArchetypeHandle.DataPtr.Get(); }
    FORCEINLINE static FMassArchetypeData& ArchetypeDataFromHandleChecked(const FMassArchetypeHandle& ArchetypeHandle)
    {
        check(ArchetypeHandle.IsValid());
        return *ArchetypeHandle.DataPtr.Get();
    }
    FORCEINLINE static FMassArchetypeHandle ArchetypeHandleFromData(const TSharedPtr<FMassArchetypeData>& Archetype)
    {
        return FMassArchetypeHandle(Archetype);
    }
 
#if WITH_MASSENTITY_DEBUG
    MASSENTITY_API static bool DoesArchetypeMatchRequirements(const FMassArchetypeData& Archetype, const FMassFragmentRequirements& Requirements
        , const bool bBailOutOnFirstFail = true, FOutputDevice* OutputDevice = nullptr);
#endif // WITH_MASSENTITY_DEBUG
 
    MASSENTITY_API static bool DoesArchetypeMatchRequirements(const FMassArchetypeData& Archetype, const FMassFragmentRequirements& Requirements);
    MASSENTITY_API static bool DoesArchetypeMatchRequirements(const FMassArchetypeCompositionDescriptor& ArchetypeComposition, const FMassFragmentRequirements& Requirements);
};
 
//-----------------------------------------------------------------------------
// INLINES
//-----------------------------------------------------------------------------
inline const UE::Mass::FArchetypeGroups& FMassArchetypeData::GetGroups() const
{
    return Groups;
}
 
inline bool FMassArchetypeData::IsInGroup(const UE::Mass::FArchetypeGroupHandle GroupHandle) const
{
    if (GroupHandle.IsValid())
    {
        UE::Mass::FArchetypeGroupID FoundGroupID = Groups.GetID(GroupHandle.GetGroupType());
        return FoundGroupID.IsValid() && FoundGroupID == GroupHandle.GetGroupID();
    }
    return false;
}
 
inline bool FMassArchetypeData::IsInGroupOfType(const UE::Mass::FArchetypeGroupType GroupType) const
{
    return Groups.ContainsType(GroupType);
}
 
inline uint32 FMassArchetypeData::GetCreatedArchetypeDataVersion() const
{
    return CreatedArchetypeDataVersion;
}
 
inline uint32 FMassArchetypeData::GetEntityOrderVersion() const
{
    return EntityOrderVersion;
}