MassEntityTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "StructUtils/StructTypeBitSet.h"
#include "MassProcessingTypes.h"
#include "StructUtils/StructArrayView.h"
#include "Subsystems/Subsystem.h"
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "MassExternalSubsystemTraits.h"
#endif // UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "StructUtils/SharedStruct.h"
#include "MassEntityElementTypes.h"
#include "MassEntityConcepts.h"
#include "MassTestableEnsures.h"
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "MassExternalSubsystemTraits.h"
#include "MassEntityHandle.h"
#endif // UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "MassEntityTypes.generated.h"
 
 
MASSENTITY_API DECLARE_LOG_CATEGORY_EXTERN(LogMass, Warning, All);
 
DECLARE_STATS_GROUP(TEXT("Mass"), STATGROUP_Mass, STATCAT_Advanced);
DECLARE_CYCLE_STAT_EXTERN(TEXT("Mass Total Frame Time"), STAT_Mass_Total, STATGROUP_Mass, MASSENTITY_API);
 
DECLARE_STRUCTTYPEBITSET_EXPORTED(MASSENTITY_API, FMassFragmentBitSet, FMassFragment);
DECLARE_STRUCTTYPEBITSET_EXPORTED(MASSENTITY_API, FMassTagBitSet, FMassTag);
DECLARE_STRUCTTYPEBITSET_EXPORTED(MASSENTITY_API, FMassChunkFragmentBitSet, FMassChunkFragment);
DECLARE_STRUCTTYPEBITSET_EXPORTED(MASSENTITY_API, FMassSharedFragmentBitSet, FMassSharedFragment);
DECLARE_STRUCTTYPEBITSET_EXPORTED(MASSENTITY_API, FMassConstSharedFragmentBitSet, FMassConstSharedFragment);
DECLARE_CLASSTYPEBITSET_EXPORTED(MASSENTITY_API, FMassExternalSubsystemBitSet, USubsystem);
 
struct FMassArchetypeData;
struct FMassEntityQuery;
 
namespace UE::Mass
{
    template<typename T>
    static constexpr bool TAlwaysFalse = false;
 
    struct FExecutionLimiter
    {
        friend struct ::FMassArchetypeData;
        friend struct ::FMassEntityQuery;
 
        explicit FExecutionLimiter(int32 InEntityLimit)
            : EntityLimit(InEntityLimit)
            , ChunkIndex(INDEX_NONE)
            , ArchetypeIndex(INDEX_NONE)
            , MaxChunkIndex(INDEX_NONE)
            , EntityCountRemaining(0)
        {
        }
        
        int32 EntityLimit;
 
    private:
        int32 ChunkIndex;
        int32 ArchetypeIndex;
        int32 MaxChunkIndex;
        int32 EntityCountRemaining;
    };
}
 
PRAGMA_DISABLE_DEPRECATION_WARNINGS
struct FMassArchetypeCompositionDescriptor
{
    FMassArchetypeCompositionDescriptor() = default;
    FMassArchetypeCompositionDescriptor(const FMassFragmentBitSet& InFragments,
        const FMassTagBitSet& InTags,
        const FMassChunkFragmentBitSet& InChunkFragments,
        const FMassSharedFragmentBitSet& InSharedFragments,
        const FMassConstSharedFragmentBitSet& InConstSharedFragments)
        : Fragments(InFragments)
        , Tags(InTags)
        , ChunkFragments(InChunkFragments)
        , SharedFragments(InSharedFragments)
        , ConstSharedFragments(InConstSharedFragments)
    {}
 
    FMassArchetypeCompositionDescriptor(TConstArrayView<const UScriptStruct*> InFragments,
        const FMassTagBitSet& InTags,
        const FMassChunkFragmentBitSet& InChunkFragments,
        const FMassSharedFragmentBitSet& InSharedFragments,
        const FMassConstSharedFragmentBitSet& InConstSharedFragments)
        : FMassArchetypeCompositionDescriptor(FMassFragmentBitSet(InFragments), InTags, InChunkFragments, InSharedFragments, InConstSharedFragments)
    {}
 
    FMassArchetypeCompositionDescriptor(TConstArrayView<FInstancedStruct> InFragmentInstances,
        const FMassTagBitSet& InTags,
        const FMassChunkFragmentBitSet& InChunkFragments,
        const FMassSharedFragmentBitSet& InSharedFragments,
        const FMassConstSharedFragmentBitSet& InConstSharedFragments)
        : FMassArchetypeCompositionDescriptor(FMassFragmentBitSet(InFragmentInstances), InTags, InChunkFragments, InSharedFragments, InConstSharedFragments)
    {}
 
    FMassArchetypeCompositionDescriptor(FMassFragmentBitSet&& InFragments,
        FMassTagBitSet&& InTags,
        FMassChunkFragmentBitSet&& InChunkFragments,
        FMassSharedFragmentBitSet&& InSharedFragments,
        FMassConstSharedFragmentBitSet&& InConstSharedFragments)
        : Fragments(MoveTemp(InFragments))
        , Tags(MoveTemp(InTags))
        , ChunkFragments(MoveTemp(InChunkFragments))
        , SharedFragments(MoveTemp(InSharedFragments))
        , ConstSharedFragments(MoveTemp(InConstSharedFragments))
    {}
 
    FMassArchetypeCompositionDescriptor(FMassFragmentBitSet&& InFragments)
        : Fragments(MoveTemp(InFragments))
    {}
 
    FMassArchetypeCompositionDescriptor(FMassTagBitSet&& InTags)
        : Tags(MoveTemp(InTags))
    {}
 
    void Reset()
    {
        Fragments.Reset();
        Tags.Reset();
        ChunkFragments.Reset();
        SharedFragments.Reset();
        ConstSharedFragments.Reset();
    }
 
    bool IsEquivalent(const FMassArchetypeCompositionDescriptor& OtherDescriptor) const
    {
        return Fragments.IsEquivalent(OtherDescriptor.Fragments)
            && Tags.IsEquivalent(OtherDescriptor.Tags)
            && ChunkFragments.IsEquivalent(OtherDescriptor.ChunkFragments)
            && SharedFragments.IsEquivalent(OtherDescriptor.SharedFragments)
            && ConstSharedFragments.IsEquivalent(OtherDescriptor.ConstSharedFragments);
    }
 
    bool IsIdentical(const FMassArchetypeCompositionDescriptor& OtherDescriptor) const
    {
        return Fragments == OtherDescriptor.Fragments
            && Tags == OtherDescriptor.Tags
            && ChunkFragments == OtherDescriptor.ChunkFragments
            && SharedFragments == OtherDescriptor.SharedFragments
            && ConstSharedFragments == OtherDescriptor.ConstSharedFragments;
    }
 
    bool IsEmpty() const 
    { 
        return Fragments.IsEmpty()
            && Tags.IsEmpty()
            && ChunkFragments.IsEmpty()
            && SharedFragments.IsEmpty()
            && ConstSharedFragments.IsEmpty();
    }
 
    bool HasAll(const FMassArchetypeCompositionDescriptor& OtherDescriptor) const
    {
        return Fragments.HasAll(OtherDescriptor.Fragments)
            && Tags.HasAll(OtherDescriptor.Tags)
            && ChunkFragments.HasAll(OtherDescriptor.ChunkFragments)
            && SharedFragments.HasAll(OtherDescriptor.SharedFragments)
            && ConstSharedFragments.HasAll(OtherDescriptor.ConstSharedFragments);
    }
 
    void Append(const FMassArchetypeCompositionDescriptor& OtherDescriptor)
    {
        Fragments += OtherDescriptor.Fragments;
        Tags += OtherDescriptor.Tags;
        ChunkFragments += OtherDescriptor.ChunkFragments;
        SharedFragments += OtherDescriptor.SharedFragments;
        ConstSharedFragments += OtherDescriptor.ConstSharedFragments;
    }
 
    void Remove(const FMassArchetypeCompositionDescriptor& OtherDescriptor)
    {
        Fragments -= OtherDescriptor.Fragments;
        Tags -= OtherDescriptor.Tags;
        ChunkFragments -= OtherDescriptor.ChunkFragments;
        SharedFragments -= OtherDescriptor.SharedFragments;
        ConstSharedFragments -= OtherDescriptor.ConstSharedFragments;
    }
 
    FMassArchetypeCompositionDescriptor CalculateDifference(const FMassArchetypeCompositionDescriptor& OtherDescriptor) const
    {
        FMassArchetypeCompositionDescriptor Diff;
 
        Diff.Fragments = Fragments - OtherDescriptor.Fragments;
        Diff.Tags = Tags - OtherDescriptor.Tags;
        Diff.ChunkFragments = ChunkFragments - OtherDescriptor.ChunkFragments;
        Diff.SharedFragments = SharedFragments - OtherDescriptor.SharedFragments;
        Diff.ConstSharedFragments = ConstSharedFragments - OtherDescriptor.ConstSharedFragments;
 
        return Diff;
    }
 
    MASSENTITY_API static uint32 CalculateHash(const FMassFragmentBitSet& InFragments, const FMassTagBitSet& InTags
        , const FMassChunkFragmentBitSet& InChunkFragments, const FMassSharedFragmentBitSet& InSharedFragmentBitSet
        , const FMassConstSharedFragmentBitSet& InConstSharedFragmentBitSet);
 
    uint32 CalculateHash() const 
    {
        return CalculateHash(Fragments, Tags, ChunkFragments, SharedFragments, ConstSharedFragments);
    }
 
    MASSENTITY_API int32 CountStoredTypes() const;
 
    MASSENTITY_API void DebugOutputDescription(FOutputDevice& Ar) const;
 
    template<typename T>
    auto& GetContainer() const;
 
    template<typename T>
    auto& GetContainer();
 
    template<typename T>
    bool Contains() const;
 
    template<typename T>
    void Add();
 
    const FMassFragmentBitSet& GetFragments() const;
    const FMassTagBitSet& GetTags() const;
    const FMassChunkFragmentBitSet& GetChunkFragments() const;
    const FMassSharedFragmentBitSet& GetSharedFragments() const;
    const FMassConstSharedFragmentBitSet& GetConstSharedFragments() const;
 
    FMassFragmentBitSet& GetFragments();
    FMassTagBitSet& GetTags();
    FMassChunkFragmentBitSet& GetChunkFragments();
    FMassSharedFragmentBitSet& GetSharedFragments();
    FMassConstSharedFragmentBitSet& GetConstSharedFragments();
 
    void SetFragments(const FMassFragmentBitSet& InBitSet);
    void SetTags(const FMassTagBitSet& InBitSet);
    void SetChunkFragments(const FMassChunkFragmentBitSet& InBitSet);
    void SetSharedFragments(const FMassSharedFragmentBitSet& InBitSet);
    void SetConstSharedFragments(const FMassConstSharedFragmentBitSet& InBitSet);
 
    UE_DEPRECATED(5.7, "Direct access to FMassArchetypeCompositionDescriptor's bitsets is deprecated. Use any of the newly added getters instead.")
    FMassFragmentBitSet Fragments;
 
    UE_DEPRECATED(5.7, "Direct access to FMassArchetypeCompositionDescriptor's bitsets is deprecated. Use any of the newly added getters instead.")
    FMassTagBitSet Tags;
 
    UE_DEPRECATED(5.7, "Direct access to FMassArchetypeCompositionDescriptor's bitsets is deprecated. Use any of the newly added getters instead.")
    FMassChunkFragmentBitSet ChunkFragments;
 
    UE_DEPRECATED(5.7, "Direct access to FMassArchetypeCompositionDescriptor's bitsets is deprecated. Use any of the newly added getters instead.")
    FMassSharedFragmentBitSet SharedFragments;
 
    UE_DEPRECATED(5.7, "Direct access to FMassArchetypeCompositionDescriptor's bitsets is deprecated. Use any of the newly added getters instead.")
    FMassConstSharedFragmentBitSet ConstSharedFragments;
 
    UE_DEPRECATED(5.5, "This FMassArchetypeCompositionDescriptor constructor is deprecated. Please explicitly provide FConstSharedFragmentBitSet.")
    FMassArchetypeCompositionDescriptor(const FMassFragmentBitSet& InFragments, const FMassTagBitSet& InTags, const FMassChunkFragmentBitSet& InChunkFragments, const FMassSharedFragmentBitSet& InSharedFragments)
        : FMassArchetypeCompositionDescriptor(InFragments, InTags, InChunkFragments, InSharedFragments, FMassConstSharedFragmentBitSet())
    {}
 
    UE_DEPRECATED(5.5, "This FMassArchetypeCompositionDescriptor constructor is deprecated. Please explicitly provide FConstSharedFragmentBitSet.")
    FMassArchetypeCompositionDescriptor(TConstArrayView<const UScriptStruct*> InFragments, const FMassTagBitSet& InTags, const FMassChunkFragmentBitSet& InChunkFragments, const FMassSharedFragmentBitSet& InSharedFragments)
        : FMassArchetypeCompositionDescriptor(FMassFragmentBitSet(InFragments), InTags, InChunkFragments, InSharedFragments, FMassConstSharedFragmentBitSet())
    {}
 
    UE_DEPRECATED(5.5, "This FMassArchetypeCompositionDescriptor constructor is deprecated. Please explicitly provide FConstSharedFragmentBitSet.")
    FMassArchetypeCompositionDescriptor(TConstArrayView<FInstancedStruct> InFragmentInstances, const FMassTagBitSet& InTags, const FMassChunkFragmentBitSet& InChunkFragments, const FMassSharedFragmentBitSet& InSharedFragments)
        : FMassArchetypeCompositionDescriptor(FMassFragmentBitSet(InFragmentInstances), InTags, InChunkFragments, InSharedFragments, FMassConstSharedFragmentBitSet())
    {}
 
    UE_DEPRECATED(5.5, "This FMassArchetypeCompositionDescriptor constructor is deprecated. Please explicitly provide FConstSharedFragmentBitSet.")
    FMassArchetypeCompositionDescriptor(FMassFragmentBitSet&& InFragments, FMassTagBitSet&& InTags, FMassChunkFragmentBitSet&& InChunkFragments, FMassSharedFragmentBitSet&& InSharedFragments)
    {
        ensureMsgf(false, TEXT("This constructor is defunct. Please update your implementation based on deprecation warning."));
    }
};
PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
struct FMassArchetypeSharedFragmentValues
{
    FMassArchetypeSharedFragmentValues() = default;
    FMassArchetypeSharedFragmentValues(const FMassArchetypeSharedFragmentValues& OtherFragmentValues) = default;
    FMassArchetypeSharedFragmentValues(FMassArchetypeSharedFragmentValues&& OtherFragmentValues) = default;
    FMassArchetypeSharedFragmentValues& operator=(const FMassArchetypeSharedFragmentValues& OtherFragmentValues) = default;
    FMassArchetypeSharedFragmentValues& operator=(FMassArchetypeSharedFragmentValues&& OtherFragmentValues) = default;
 
    inline bool HasExactFragmentTypesMatch(const FMassSharedFragmentBitSet& InSharedFragmentBitSet, const FMassConstSharedFragmentBitSet& InConstSharedFragmentBitSet) const
    {
        return HasExactSharedFragmentTypesMatch(InSharedFragmentBitSet)
            && HasExactConstSharedFragmentTypesMatch(InConstSharedFragmentBitSet);
    }
 
    inline bool HasExactSharedFragmentTypesMatch(const FMassSharedFragmentBitSet& InSharedFragmentBitSet) const
    {
        return SharedFragmentBitSet.IsEquivalent(InSharedFragmentBitSet);
    }
 
    inline bool HasAllRequiredSharedFragmentTypes(const FMassSharedFragmentBitSet& InSharedFragmentBitSet) const
    {
        return SharedFragmentBitSet.HasAll(InSharedFragmentBitSet);
    }
 
    inline bool HasExactConstSharedFragmentTypesMatch(const FMassConstSharedFragmentBitSet& InConstSharedFragmentBitSet) const
    {
        return ConstSharedFragmentBitSet.IsEquivalent(InConstSharedFragmentBitSet);
    }
 
    inline bool HasAllRequiredConstSharedFragmentTypes(const FMassConstSharedFragmentBitSet& InConstSharedFragmentBitSet) const
    {
        return ConstSharedFragmentBitSet.HasAll(InConstSharedFragmentBitSet);
    }
 
    bool DoesMatchComposition(const FMassArchetypeCompositionDescriptor& InDescriptor) const 
    {
        return HasExactSharedFragmentTypesMatch(InDescriptor.GetSharedFragments())
            && HasExactConstSharedFragmentTypesMatch(InDescriptor.GetConstSharedFragments());
    }
 
    inline bool IsEquivalent(const FMassArchetypeSharedFragmentValues& OtherSharedFragmentValues) const
    {
        return GetTypeHash(*this) == GetTypeHash(OtherSharedFragmentValues);
    }
 
    MASSENTITY_API bool HasSameValues(const FMassArchetypeSharedFragmentValues& Other) const;
 
    inline bool ContainsType(const UScriptStruct* FragmentType) const
    {
        if (UE::Mass::IsA<FMassSharedFragment>(FragmentType))
        {
            return SharedFragmentBitSet.Contains(*FragmentType);
        }
 
        if (UE::Mass::IsA<FMassConstSharedFragment>(FragmentType))
        {
            return ConstSharedFragmentBitSet.Contains(*FragmentType);
        }
 
        return false;
    }
 
    template<typename T>
    inline bool ContainsType() const
    {
        if constexpr (UE::Mass::CConstSharedFragment<T>)
        {
            return ConstSharedFragmentBitSet.Contains(*T::StaticStruct());
        }
        else if constexpr (UE::Mass::CSharedFragment<T>)
        {
            return SharedFragmentBitSet.Contains(*T::StaticStruct());
        }
        else
        {
            return false;
        }
    }
 
    void Add(const FConstSharedStruct& Fragment)
    {
        (void)Add_GetRef(Fragment);
    }
 
    MASSENTITY_API FConstSharedStruct Add_GetRef(const FConstSharedStruct& Fragment);
 
    UE_DEPRECATED(5.6, "Use Add or Add_GetRef instead depending on whether you need the return value.")
        FConstSharedStruct AddConstSharedFragment(const FConstSharedStruct& Fragment)
    {
        return Add_GetRef(Fragment);
    }
 
    void Add(const FSharedStruct& Fragment)
    {
        (void)Add_GetRef(Fragment);
    }
 
    MASSENTITY_API FSharedStruct Add_GetRef(const FSharedStruct& Fragment);
 
    UE_DEPRECATED(5.6, "Use Add or Add_GetRef instead depending on whether you need the return value.")
    FSharedStruct AddSharedFragment(const FSharedStruct& Fragment)
    {
        return Add_GetRef(Fragment);
    }
 
    MASSENTITY_API void ReplaceSharedFragments(TConstArrayView<FSharedStruct> Fragments);
 
    MASSENTITY_API int32 Append(const FMassArchetypeSharedFragmentValues& Other);
 
    MASSENTITY_API int32 Remove(const FMassSharedFragmentBitSet& SharedFragmentToRemoveBitSet);
 
    MASSENTITY_API int32 Remove(const FMassConstSharedFragmentBitSet& ConstSharedFragmentToRemoveBitSet);
 
    int32 Remove(const FMassArchetypeCompositionDescriptor& InDescriptor)
    {
        return Remove(InDescriptor.GetSharedFragments()) + Remove(InDescriptor.GetConstSharedFragments());
    }
 
    inline const TArray<FConstSharedStruct>& GetConstSharedFragments() const
    {
        return ConstSharedFragments;
    }
 
    inline TArray<FSharedStruct>& GetMutableSharedFragments()
    {
        return SharedFragments;
    }
    
    inline const TArray<FSharedStruct>& GetSharedFragments() const
    {
        return SharedFragments;
    }
    
    FConstSharedStruct GetConstSharedFragmentStruct(const UScriptStruct* StructType) const
    {
        const int32 FragmentIndex = ConstSharedFragments.IndexOfByPredicate(FStructTypeEqualOperator(StructType));
        return FragmentIndex != INDEX_NONE ? ConstSharedFragments[FragmentIndex] : FConstSharedStruct();
    }
        
    FSharedStruct GetSharedFragmentStruct(const UScriptStruct* StructType)
    {
        const int32 FragmentIndex = SharedFragments.IndexOfByPredicate(FStructTypeEqualOperator(StructType));
        return FragmentIndex != INDEX_NONE ? SharedFragments[FragmentIndex] : FSharedStruct();
    }
 
    FConstSharedStruct GetSharedFragmentStruct(const UScriptStruct* StructType) const
    {
        const int32 FragmentIndex = SharedFragments.IndexOfByPredicate(FStructTypeEqualOperator(StructType));
        return FragmentIndex != INDEX_NONE ? SharedFragments[FragmentIndex] : FSharedStruct();
    }
 
    const FMassSharedFragmentBitSet& GetSharedFragmentBitSet() const
    {
        return SharedFragmentBitSet;
    }
 
    const FMassConstSharedFragmentBitSet& GetConstSharedFragmentBitSet() const
    {
        return ConstSharedFragmentBitSet;
    }
 
    inline void DirtyHashCache()
    {
        HashCache = UINT32_MAX;
        // we consider a single shared fragment as being "sorted"
        bSorted = (SharedFragments.Num() + ConstSharedFragments.Num() <= 1) ;
    }
 
    inline void CacheHash() const
    {
        if (HashCache == UINT32_MAX)
        {
            HashCache = CalculateHash();
        }
    }
 
    friend inline uint32 GetTypeHash(const FMassArchetypeSharedFragmentValues& SharedFragmentValues)
    {
        SharedFragmentValues.CacheHash();
        return SharedFragmentValues.HashCache;
    }
 
    MASSENTITY_API uint32 CalculateHash() const;
    SIZE_T GetAllocatedSize() const;
 
    void Sort()
    {
        if(!bSorted)
        {
            ConstSharedFragments.Sort(FStructTypeSortOperator());
            SharedFragments.Sort(FStructTypeSortOperator());
            bSorted = true;
        }
    }
 
    bool IsSorted() const;
 
    bool IsEmpty() const;
 
    void Reset();
 
protected:
    mutable uint32 HashCache = UINT32_MAX;
    mutable bool bSorted = true; 
    
    FMassSharedFragmentBitSet SharedFragmentBitSet;
    FMassConstSharedFragmentBitSet ConstSharedFragmentBitSet;
    TArray<FConstSharedStruct> ConstSharedFragments;
    TArray<FSharedStruct> SharedFragments;
 
public:
    //-----------------------------------------------------------------------------
    // DEPRECATED
    //-----------------------------------------------------------------------------
    UE_DEPRECATED(5.5, "HasExactFragmentTypesMatch is deprecated. Use HasExactSharedFragmentTypesMatch or the two-parameter version of HasExactFragmentTypesMatch.")
    inline bool HasExactFragmentTypesMatch(const FMassSharedFragmentBitSet& InSharedFragmentBitSet) const
    {
        return HasExactSharedFragmentTypesMatch(InSharedFragmentBitSet);
    }
};
 
UENUM()
enum class EMassObservedOperation : uint8
{
    AddElement, // when an element (a fragment, tag...) is added to an existing entity
    RemoveElement,  // when an element (a fragment, tag...) is removed from an existing entity
    DestroyEntity,  // when an entity is destroyed, which is a special case of RemoveElement, because the entity gets all of its elements removed
    CreateEntity,   // when an entity is created, which is a special case of AddElement, because the entity gets all of its elements added
 
    // @todo another planned supported operation type
    // Touch,
    // -- new operations above this line -- //
 
    MAX,
 
    // the following values are deprecated. Use one of the values above 
    Add UMETA(Deprecated, DisplayName="DEPRECATED_Add"),
    Remove UMETA(Deprecated, DisplayName="DEPRECATED_Remove")
};
 
enum class EMassObservedOperationFlags : uint8
{
    None = 0,
    AddElement = 1 << static_cast<uint8>(EMassObservedOperation::AddElement),
    RemoveElement = 1 << static_cast<uint8>(EMassObservedOperation::RemoveElement),
    CreateEntity = 1 << static_cast<uint8>(EMassObservedOperation::CreateEntity),
    DestroyEntity = 1 << static_cast<uint8>(EMassObservedOperation::DestroyEntity),
    
    Add = AddElement | CreateEntity,
    Remove = RemoveElement | DestroyEntity,
    All = Add | Remove,
};
ENUM_CLASS_FLAGS(EMassObservedOperationFlags);
MASSENTITY_API FString LexToString(const EMassObservedOperationFlags Value);
 
enum class EMassExecutionContextType : uint8
{
    Local,
    Processor,
    MAX
};
 
struct FMassGenericPayloadView
{
    FMassGenericPayloadView() = default;
    FMassGenericPayloadView(TArray<FStructArrayView>&SourceData)
        : Content(SourceData)
    {}
    FMassGenericPayloadView(TArrayView<FStructArrayView> SourceData)
        : Content(SourceData)
    {}
 
    int32 Num() const { return Content.Num(); }
 
    void Reset()
    {
        Content = TArrayView<FStructArrayView>();
    }
 
    inline void Swap(const int32 A, const int32 B)
    {
        for (FStructArrayView& View : Content)
        {
            View.Swap(A, B);
        }
    }
 
    void SwapElementsToEnd(int32 StartIndex, int32 NumToMove);
 
    TArrayView<FStructArrayView> Content;
};
 
struct FMassGenericPayloadViewSlice
{
    FMassGenericPayloadViewSlice() = default;
    FMassGenericPayloadViewSlice(const FMassGenericPayloadView& InSource, const int32 InStartIndex, const int32 InCount)
        : Source(InSource), StartIndex(InStartIndex), Count(InCount)
    {
    }
 
    FStructArrayView operator[](const int32 Index) const
    {
        return Source.Content[Index].Slice(StartIndex, Count);
    }
 
    int32 Num() const 
    {
        return Source.Num();
    }
 
    bool IsEmpty() const
    {
        return !(Source.Num() > 0 && Count > 0);
    }
 
private:
    FMassGenericPayloadView Source;
    const int32 StartIndex = 0;
    const int32 Count = 0;
};
 
namespace UE::Mass
{
    template<typename T, typename... TOthers>
    struct TMultiTypeList : TMultiTypeList<TOthers...>
    {
        using Super = TMultiTypeList<TOthers...>;
        using FType = std::remove_const_t<typename TRemoveReference<T>::Type>;
        enum
        {
            Ordinal = Super::Ordinal + 1
        };
 
        template<typename TBitSetType>
        constexpr static void PopulateBitSet(TBitSetType& OutBitSet)
        {
            Super::PopulateBitSet(OutBitSet);
            OutBitSet += TBitSetType::template GetTypeBitSet<FType>();
        }
    };
        
    template<typename T>
    struct TMultiTypeList<T>
    {
        using FType = std::remove_const_t<typename TRemoveReference<T>::Type>;
        enum
        {
            Ordinal = 0
        };
 
        template<typename TBitSetType>
        constexpr static void PopulateBitSet(TBitSetType& OutBitSet)
        {
            OutBitSet += TBitSetType::template GetTypeBitSet<FType>();
        }
    };
 
    template<typename T, typename... TOthers>
    struct TMultiArray : TMultiArray<TOthers...>
    {
        using FType = std::remove_const_t<typename TRemoveReference<T>::Type>;
        using Super = TMultiArray<TOthers...>;
 
        enum
        {
            Ordinal = Super::Ordinal + 1
        };
 
        SIZE_T GetAllocatedSize() const
        {
            return FragmentInstances.GetAllocatedSize() + Super::GetAllocatedSize();
        }
 
        int GetNumArrays() const { return Ordinal + 1; }
 
        void Add(const FType& Item, TOthers... Rest)
        {
            FragmentInstances.Add(Item);
            Super::Add(Rest...);
        }
 
        void GetAsGenericMultiArray(TArray<FStructArrayView>& A) /*const*/
        {
            Super::GetAsGenericMultiArray(A);
            A.Add(FStructArrayView(FragmentInstances));
        }
 
        void GetheredAffectedFragments(FMassFragmentBitSet& OutBitSet) const
        {
            Super::GetheredAffectedFragments(OutBitSet);
            OutBitSet += FMassFragmentBitSet::GetTypeBitSet<FType>();
        }
 
        void Reset()
        {
            Super::Reset();
            FragmentInstances.Reset();
        }
 
        TArray<FType> FragmentInstances;
    };
 
    template<typename T>
    struct TMultiArray<T>
    {
        using FType = std::remove_const_t<typename TRemoveReference<T>::Type>;
        enum { Ordinal = 0 };
 
        SIZE_T GetAllocatedSize() const
        {
            return FragmentInstances.GetAllocatedSize();
        }
 
        int GetNumArrays() const { return Ordinal + 1; }
 
        void Add(const FType& Item) { FragmentInstances.Add(Item); }
 
        void GetAsGenericMultiArray(TArray<FStructArrayView>& A) /*const*/
        {
            A.Add(FStructArrayView(FragmentInstances));
        }
 
        void GetheredAffectedFragments(FMassFragmentBitSet& OutBitSet) const
        {
            OutBitSet += FMassFragmentBitSet::GetTypeBitSet<FType>();
        }
 
        void Reset()
        {
            FragmentInstances.Reset();
        }
 
        TArray<FType> FragmentInstances;
    };
 
} // UE::Mass
 
 
struct FMassArchetypeCreationParams
{
    FMassArchetypeCreationParams() = default;
    explicit FMassArchetypeCreationParams(const struct FMassArchetypeData& Archetype);
 
    int32 ChunkMemorySize = 0;
 
    FName DebugName;
 
#if WITH_MASSENTITY_DEBUG
    FColor DebugColor{0};
#endif // WITH_MASSENTITY_DEBUG
};
 
//-----------------------------------------------------------------------------
// INLINES
//-----------------------------------------------------------------------------
PRAGMA_DISABLE_DEPRECATION_WARNINGS
template<typename T>
auto& FMassArchetypeCompositionDescriptor::GetContainer() const
{
    if constexpr (std::is_same_v<FMassFragment, T>)
    {
        return Fragments;
    }
    else if constexpr (std::is_same_v<FMassTag, T>)
    {
        return Tags;
    }
    else if constexpr (std::is_same_v<FMassChunkFragment, T>)
    {
        return ChunkFragments;
    }
    else if constexpr (std::is_same_v<FMassSharedFragment, T>)
    {
        return SharedFragments;
    }
    else if constexpr (std::is_same_v<FMassConstSharedFragment, T>)
    {
        return ConstSharedFragments;
    }
    else
    {
        static_assert(UE::Mass::TAlwaysFalse<T>, "Unknown element type passed to GetContainer.");
    }
}
 
template<typename T>
auto& FMassArchetypeCompositionDescriptor::GetContainer()
{
    if constexpr (std::is_same_v<FMassFragment, T>)
    {
        return Fragments;
    }
    else if constexpr (std::is_same_v<FMassTag, T>)
    {
        return Tags;
    }
    else if constexpr (std::is_same_v<FMassChunkFragment, T>)
    {
        return ChunkFragments;
    }
    else if constexpr (std::is_same_v<FMassSharedFragment, T>)
    {
        return SharedFragments;
    }
    else if constexpr (std::is_same_v<FMassConstSharedFragment, T>)
    {
        return ConstSharedFragments;
    }
    else
    {
        static_assert(UE::Mass::TAlwaysFalse<T>, "Unknown element type passed to GetContainer.");
    }
}
 
template<typename T>
bool FMassArchetypeCompositionDescriptor::Contains() const
{
    using FElementType = UE::Mass::TElementType<T>;
    return GetContainer<FElementType>().template Contains<T>();
}
 
template<typename T>
void FMassArchetypeCompositionDescriptor::Add()
{
    using FElementType = UE::Mass::TElementType<T>;
    GetContainer<FElementType>().template Add<T>();
}
 
inline const FMassFragmentBitSet& FMassArchetypeCompositionDescriptor::GetFragments() const 
{ 
    return Fragments; 
}
 
inline const FMassTagBitSet& FMassArchetypeCompositionDescriptor::GetTags() const 
{ 
    return Tags; 
}
 
inline const FMassChunkFragmentBitSet& FMassArchetypeCompositionDescriptor::GetChunkFragments() const 
{ 
    return ChunkFragments; 
}
 
inline const FMassSharedFragmentBitSet& FMassArchetypeCompositionDescriptor::GetSharedFragments() const 
{ 
    return SharedFragments; 
}
 
inline const FMassConstSharedFragmentBitSet& FMassArchetypeCompositionDescriptor::GetConstSharedFragments() const 
{ 
    return ConstSharedFragments; 
}
 
inline FMassFragmentBitSet& FMassArchetypeCompositionDescriptor::GetFragments() 
{ 
    return Fragments; 
}
 
inline FMassTagBitSet& FMassArchetypeCompositionDescriptor::GetTags() 
{ 
    return Tags; 
}
 
inline FMassChunkFragmentBitSet& FMassArchetypeCompositionDescriptor::GetChunkFragments() 
{ 
    return ChunkFragments; 
}
 
inline FMassSharedFragmentBitSet& FMassArchetypeCompositionDescriptor::GetSharedFragments() 
{ 
    return SharedFragments; 
}
 
inline FMassConstSharedFragmentBitSet& FMassArchetypeCompositionDescriptor::GetConstSharedFragments() 
{ 
    return ConstSharedFragments; 
}
 
inline void FMassArchetypeCompositionDescriptor::SetFragments(const FMassFragmentBitSet& InBitSet)
{ 
    Fragments = InBitSet; 
}
 
inline void FMassArchetypeCompositionDescriptor::SetTags(const FMassTagBitSet& InBitSet)
{ 
    Tags = InBitSet; 
}
 
inline void FMassArchetypeCompositionDescriptor::SetChunkFragments(const FMassChunkFragmentBitSet& InBitSet)
{ 
    ChunkFragments = InBitSet; 
}
 
inline void FMassArchetypeCompositionDescriptor::SetSharedFragments(const FMassSharedFragmentBitSet& InBitSet)
{ 
    SharedFragments = InBitSet; 
}
 
inline void FMassArchetypeCompositionDescriptor::SetConstSharedFragments(const FMassConstSharedFragmentBitSet& InBitSet)
{ 
    ConstSharedFragments = InBitSet; 
}
PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
inline SIZE_T FMassArchetypeSharedFragmentValues::GetAllocatedSize() const
{
    return SharedFragmentBitSet.GetAllocatedSize()
        + ConstSharedFragmentBitSet.GetAllocatedSize()
        + ConstSharedFragments.GetAllocatedSize()
        + SharedFragments.GetAllocatedSize();
}
 
inline bool FMassArchetypeSharedFragmentValues::IsSorted() const
{
    return bSorted;
}
 
inline bool FMassArchetypeSharedFragmentValues::IsEmpty() const
{
    return ConstSharedFragments.IsEmpty() && SharedFragments.IsEmpty();
}
 
inline void FMassArchetypeSharedFragmentValues::Reset()
{
    HashCache = UINT32_MAX;
    bSorted = false; 
    SharedFragmentBitSet.Reset();
    ConstSharedFragmentBitSet.Reset();
    ConstSharedFragments.Reset();
    SharedFragments.Reset();
}