MassEntityBuilder.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "MassArchetypeTypes.h"
#include "MassEntityConcepts.h"
#include "MassEntityHandle.h"
#include "MassEntityTypes.h"
#include "MassEntityRelations.h"
#include "MassTypeManager.h"
 
#define UE_API MASSENTITY_API
 
struct FMassEntityManager;
 
namespace UE::Mass
{
    struct FTypeHandle;
    namespace Private
    {
        struct FEntityBuilderHelper;
    }
 
struct FEntityBuilder
{
    UE_API explicit FEntityBuilder(FMassEntityManager& InEntityManager);
 
    UE_API explicit FEntityBuilder(const TSharedRef<FMassEntityManager>& InEntityManager);
 
    UE_API FEntityBuilder(const FEntityBuilder& Other);
 
    UE_API FEntityBuilder& operator=(const FEntityBuilder& Other);
 
    UE_API FEntityBuilder& operator=(FEntityBuilder&& Other);
 
    UE_API ~FEntityBuilder();
 
    static UE_API FEntityBuilder Make(const TSharedRef<FMassEntityManager>& InEntityManager
        , const FMassArchetypeCompositionDescriptor& Composition
        , TConstArrayView<FInstancedStruct> InitialFragmentValues = {}
        , TConstArrayView<FConstSharedStruct> ConstSharedFragments = {}
        , TConstArrayView<FSharedStruct> SharedFragments = {});
 
    static UE_API FEntityBuilder Make(const TSharedRef<FMassEntityManager>& InEntityManager
        , const FMassArchetypeCompositionDescriptor& Composition
        , TArray<FInstancedStruct>&& InitialFragmentValues
        , TArray<FConstSharedStruct>&& ConstSharedFragments
        , TArray<FSharedStruct>&& SharedFragments);
 
    UE_API FMassEntityHandle Commit();
 
    UE_API FMassEntityHandle CommitAndReprepare();
 
    UE_API void Reprepare();
 
    UE_API void Reset(const bool bReleaseEntityHandleIfReserved = true);
 
    UE_API bool SetReservedEntityHandle(const FMassEntityHandle ReservedEntityHandle);
 
    UE_API bool AppendDataFromEntity(const FMassEntityHandle SourceEntityHandle);
 
    UE_API bool CopyDataFromEntity(const FMassEntityHandle SourceEntityHandle);
 
    template<typename T, typename... TArgs>
    T& Add_GetRef(TArgs&&... InArgs) requires (CElement<T> && !(CTag<T> || CChunkFragment<T>));
 
    template<typename T, typename... TArgs>
    T& GetOrCreate(TArgs&&... InArgs) requires (CElement<T> && !(CTag<T> || CChunkFragment<T>));
 
    template<CTag T>
    FEntityBuilder& Add();
 
    template<CChunkFragment T>
    FEntityBuilder& Add();
 
    template<typename T, typename... TArgs>
    FEntityBuilder& Add(TArgs&&... InArgs) requires (CElement<T> && !(CTag<T> || CChunkFragment<T>));
 
    UE_API FEntityBuilder& Add(const FInstancedStruct& ElementInstance);
    UE_API FEntityBuilder& Add(FInstancedStruct&& ElementInstance);
 
    UE_API FEntityBuilder& Add(TNotNull<const UScriptStruct*> ElementType);
 
    struct FPendingRelationParams
    {
        UE::Mass::FTypeHandle RelationTypeHandle;
        FMassEntityHandle OtherEntity;
        Relations::ERelationRole OtherEntityRole;
    };
 
    UE_API FEntityBuilder& AddRelation(UE::Mass::FTypeHandle RelationTypeHandle, FMassEntityHandle OtherEntity, Relations::ERelationRole InputEntityRole = Relations::ERelationRole::Object);
 
    template<UE::Mass::CRelation T>
    FEntityBuilder& AddRelation(FMassEntityHandle OtherEntity, Relations::ERelationRole InputEntityRole = Relations::ERelationRole::Object);
 
    UE_API void ForEachRelation(const TFunctionRef<bool(FPendingRelationParams&)>& Operator);
 
    template<typename T>
    T* Find() requires (CElement<T> && !(CTag<T> || CChunkFragment<T>));
 
    void ConfigureArchetypeCreation(const FMassArchetypeCreationParams& InCreationParams);
 
    [[nodiscard]] UE_API FMassEntityHandle GetEntityHandle() const;
 
    [[nodiscard]] UE_API FMassArchetypeHandle GetArchetypeHandle();
 
    bool IsValid() const;
 
    bool HasReservedEntityHandle() const;
 
    bool IsCommitted() const;
 
    TSharedRef<FMassEntityManager> GetEntityManager();
 
protected:
    friend Private::FEntityBuilderHelper;
 
    UE_API void CacheSharedFragmentValue();
    UE_API void CacheArchetypeHandle();
    UE_API void InvalidateCachedData();
 
    struct FStructInstanceFindingPredicate
    {
        template<typename TInstancedStruct>
        bool operator()(const TInstancedStruct& Instance) const
        {
            return Instance.GetScriptStruct() == SearchedType;
        }
        const UScriptStruct* SearchedType = nullptr;
    };
 
private:
    template<typename TInstancedStruct>
    FEntityBuilder& AddInternal(TInstancedStruct&& ElementInstance);
 
    template<typename T>
    bool HandleTypeInstance(const UScriptStruct* Type, TArray<FInstancedStruct>*& OutTargetContainer, bool& bOutAlreadyInComposition);
 
    TSharedRef<FMassEntityManager> EntityManager;
    mutable FMassEntityHandle EntityHandle;
 
    FMassArchetypeCompositionDescriptor Composition;
 
    FMassArchetypeSharedFragmentValues CachedSharedFragmentValues;
    FMassArchetypeHandle CachedArchetypeHandle;
 
    FMassArchetypeCreationParams ArchetypeCreationParams;
 
    template<CFragment T> 
    TArray<FInstancedStruct>& GetInstancedStructContainerInternal() 
    { 
        return Fragments; 
    }
 
    template<CSharedFragment T> 
    TArray<FInstancedStruct>& GetInstancedStructContainerInternal() 
    {
        // Resetting the cached shared values because this function is always called 
        // with the intent to modify the contents of SharedFragments, invalidating the
        // cached data anyway 
        CachedSharedFragmentValues.Reset();
        return SharedFragments; 
    }
 
    template<CConstSharedFragment T> 
    TArray<FInstancedStruct>& GetInstancedStructContainerInternal() 
    {
        CachedSharedFragmentValues.Reset();
        return ConstSharedFragments; 
    }
 
    template<typename T>
    auto& GetBitSetBuilder()
    {
        return Composition.GetContainer<T>();
    }
 
    void ConditionallyReleaseEntityHandle();
 
    void CacheEntityHandle() const;
 
    static void CreateEntityImpl(FMassEntityManager& EntityManager, FMassEntityHandle EntityHandle, const FMassArchetypeHandle& ArchetypeHandle
        , const FMassArchetypeSharedFragmentValues& SharedFragmentValues, TConstArrayView<FInstancedStruct> Fragments, TConstArrayView<FPendingRelationParams> RelationsParams);
 
    TArray<FInstancedStruct> Fragments;
    TArray<FInstancedStruct> SharedFragments;
    TArray<FInstancedStruct> ConstSharedFragments;
    TArray<FPendingRelationParams> RelationsParams;
 
    enum class EState : uint8
    {
        Empty,
        ReadyToCommit,
        Committed,
        Invalid,
    };
    EState State = EState::Empty;
};
 
struct FScopedEntityBuilder : FEntityBuilder
{
    UE_NONCOPYABLE(FScopedEntityBuilder);
 
    template<typename... TArgs>
    FScopedEntityBuilder(TArgs&&... InArgs)
        : FEntityBuilder(Forward<TArgs>(InArgs)...)
    {   
    }
 
    ~FScopedEntityBuilder()
    {
        Commit();
    }
};
 
//-----------------------------------------------------------------------------
// Inlines and specializations
//-----------------------------------------------------------------------------
template<CTag T>
FEntityBuilder& FEntityBuilder::Add()
{
    Composition.GetTags().Add<T>();
    State = EState::ReadyToCommit;
    CachedArchetypeHandle = FMassArchetypeHandle();
    return *this;
}
 
template<CChunkFragment T>
FEntityBuilder& FEntityBuilder::Add()
{
    Composition.GetChunkFragments().Add<T>();
    State = EState::ReadyToCommit;
    CachedArchetypeHandle = FMassArchetypeHandle();
    return *this;
}
 
template<typename T, typename... TArgs>
FEntityBuilder& FEntityBuilder::Add(TArgs&&... InArgs) requires (CElement<T> && !(CTag<T> || CChunkFragment<T>))
{
    Add_GetRef<T>(InArgs...);
    return *this;
}
 
template<typename T, typename... TArgs>
T& FEntityBuilder::Add_GetRef(TArgs&&... InArgs) requires (CElement<T> && !(CTag<T> || CChunkFragment<T>))
{
    using FElementType = UE::Mass::TElementType<T>;
 
    State = EState::ReadyToCommit;
 
    if (ensureMsgf(GetBitSetBuilder<FElementType>().template Contains<T>() == false, TEXT("Element of type %s has already been added"), *T::StaticStruct()->GetName()))
    {
        GetBitSetBuilder<FElementType>().template Add<T>();
        CachedArchetypeHandle = FMassArchetypeHandle();
 
        return GetInstancedStructContainerInternal<T>().Add_GetRef(FInstancedStruct::Make<T>(InArgs...)).template GetMutable<T>();
    }
 
    return GetInstancedStructContainerInternal<T>().FindByPredicate(FStructInstanceFindingPredicate{T::StaticStruct()})
        ->template GetMutable<T>();
}
 
template<typename T, typename... TArgs>
T& FEntityBuilder::GetOrCreate(TArgs&&... InArgs) requires (CElement<T> && !(CTag<T> || CChunkFragment<T>))
{
    using FElementType = UE::Mass::TElementType<T>;
 
    State = EState::ReadyToCommit;
 
    FInstancedStruct* ElementFound = nullptr;
    if (GetBitSetBuilder<FElementType>().template Contains<T>())
    {
        // replace
        ElementFound = GetInstancedStructContainerInternal<T>().FindByPredicate(FStructInstanceFindingPredicate{T::StaticStruct()});
 
        checkf(ElementFound, TEXT("We expect the element to be found since we already tested the Composition"));
        ElementFound->GetMutable<T>() = T(InArgs...);
    }
    else
    {
        GetBitSetBuilder<FElementType>().template Add<T>();
        CachedArchetypeHandle = FMassArchetypeHandle();
 
        ElementFound = &GetInstancedStructContainerInternal<T>().Add_GetRef(FInstancedStruct::Make<T>(InArgs...));
    }
 
    return ElementFound->GetMutable<T>();
}
 
template<typename T>
T* FEntityBuilder::Find() requires (CElement<T> && !(CTag<T> || CChunkFragment<T>))
{
    using FElementType = UE::Mass::TElementType<T>;
 
    if (GetBitSetBuilder<FElementType>().template Contains<T>())
    {
        FInstancedStruct* ElementFound = GetInstancedStructContainerInternal<T>().FindByPredicate(FStructInstanceFindingPredicate{T::StaticStruct()});
 
        checkf(ElementFound, TEXT("We expect the element to be found since we already tested the Composition"));
        return ElementFound->GetMutablePtr<T>();
    }
 
    return nullptr;
}
 
template<UE::Mass::CRelation T>
FEntityBuilder& FEntityBuilder::AddRelation(const FMassEntityHandle OtherEntity, const Relations::ERelationRole InputEntityRole)
{
    return AddRelation(FTypeManager::MakeTypeHandle(T::StaticStruct()), OtherEntity, InputEntityRole);
}
 
inline bool FEntityBuilder::IsValid() const
{
    return State != EState::Invalid;
}
 
inline bool FEntityBuilder::HasReservedEntityHandle() const
{
    return State != EState::Committed && EntityHandle.IsValid();
}
 
inline bool FEntityBuilder::IsCommitted() const
{
    return State == EState::Committed;
}
 
inline TSharedRef<FMassEntityManager> FEntityBuilder::GetEntityManager()
{
    return EntityManager;
}
 
inline void FEntityBuilder::ConfigureArchetypeCreation(const FMassArchetypeCreationParams& InCreationParams)
{
    ArchetypeCreationParams = InCreationParams;
}
 
} // namespace UE::Mass
 
#undef UE_API