MassEntityCollection.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "MassEntityHandle.h"
#include "MassArchetypeTypes.h"
 
namespace UE::Mass
{
    struct FEntityCollection
    {
        FEntityCollection() = default;
 
        MASSENTITY_API explicit FEntityCollection(FMassArchetypeEntityCollection&& InEntityCollection);
        MASSENTITY_API explicit FEntityCollection(const FMassArchetypeEntityCollection& InEntityCollection);
        MASSENTITY_API explicit FEntityCollection(const TConstArrayView<FMassEntityHandle> InEntityHandles);
        MASSENTITY_API FEntityCollection(const TConstArrayView<FMassEntityHandle> InEntityHandles, FMassArchetypeEntityCollection&& InEntityCollection);
 
        //-----------------------------------------------------------------------------
        // mutating API
        //-----------------------------------------------------------------------------
        MASSENTITY_API void AppendHandles(TConstArrayView<FMassEntityHandle> Handles);
 
        MASSENTITY_API void AppendHandles(TConstArrayView<FMassEntityHandle> Handles, FMassArchetypeEntityCollection&& InEntityCollection);
 
        MASSENTITY_API void AppendHandles(TArray<FMassEntityHandle>&& Handles);
 
        MASSENTITY_API void AddHandle(FMassEntityHandle Handle);
 
        template<typename T> requires std::is_same_v<typename TDecay<T>::Type, FMassArchetypeEntityCollection>
        void AppendCollection(T&& InEntityCollection)
        {
            if (UNLIKELY(InEntityCollection.IsEmpty()))
            {
                return;
            }
 
            const bool bWasEmpty = EntityHandles.IsEmpty();
            if (InEntityCollection.ExportEntityHandles(EntityHandles))
            {
                ConditionallyStoreCollection(bWasEmpty, Forward<T>(InEntityCollection));
            }
        }
 
        MASSENTITY_API bool UpdateAndRemoveDuplicates(const FMassEntityManager& EntityManager, bool bForceOperation = false);
 
        //-----------------------------------------------------------------------------
        // state-querying API
        //-----------------------------------------------------------------------------
        void MarkDirty()
        {
            CachedCollections.Reset();
        }
 
        bool IsEmpty() const
        {
            ensureMsgf(!(EntityHandles.Num() == 0 && CachedCollections.Num() != 0), TEXT("Stored entity array is empty while there are stored collections. This is unexpected."));
            return EntityHandles.IsEmpty();
        }
 
        MASSENTITY_API bool IsUpToDate() const;
 
        //-----------------------------------------------------------------------------
        // data reading API
        //-----------------------------------------------------------------------------
        TConstArrayView<FMassEntityHandle> GetEntityHandlesView() const
        {
            return EntityHandles;
        }
 
        TConstArrayView<FMassArchetypeEntityCollection> GetCachedPerArchetypeCollections() const
        {
            return CachedCollections;
        }
 
        TConstArrayView<FMassArchetypeEntityCollection> GetUpToDatePerArchetypeCollections(const FMassEntityManager& EntityManager) const
        {
            ConditionallyUpdate(EntityManager);
            return CachedCollections;
        }
 
        TArray<FMassArchetypeEntityCollection> ConsumeArchetypeCollections(const FMassEntityManager& EntityManager) &&
        {
            ConditionallyUpdate(EntityManager);
            return MoveTemp(CachedCollections);
        }
 
    private:
        template<typename T> requires std::is_same_v<typename TDecay<T>::Type, FMassArchetypeEntityCollection>
        void ConditionallyStoreCollection(const bool bWasEmpty, T&& InEntityCollection)
        {
            // if there was no previous data, or the data was "complete", meaning we had collections for stored handles
            // Note: this condition only works as expected if we make sure that adding handles without associated collections
            // resets the CachedCollections array
            // @todo add unit tests to ensure this behavior
            if (bWasEmpty || !CachedCollections.IsEmpty())
            {
                if (!CachedCollections.IsEmpty() && CachedCollections.Last().IsSameArchetype(InEntityCollection))
                {
                    // merge with the last collection since it's the same archetype.
                    CachedCollections.Last().Append(Forward<T>(InEntityCollection));
                }
                else
                {
                    CachedCollections.Emplace(Forward<T>(InEntityCollection));
                }
            }
            else
            {
                CachedCollections.Reset();
            }
        }
 
        MASSENTITY_API void ConditionallyUpdate(const FMassEntityManager& EntityManager) const;
 
        TArray<FMassEntityHandle> EntityHandles;
 
        mutable TArray<FMassArchetypeEntityCollection> CachedCollections;
 
        FMassArchetypeEntityCollection::EDuplicatesHandling CollectionCreationDuplicatesHandling = FMassArchetypeEntityCollection::NoDuplicates;
    };
}