MassEntityRelations.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/StaticArray.h"
#include "MassEntityElementTypes.h"
#include "MassEntityHandle.h"
#include "MassArchetypeGroup.h"
#include "MassEntityMacros.h"
#include "MassEntityRelations.generated.h"
 
#define UE_API MASSENTITY_API
 
struct FMassEntityManager;
class UMassObserverProcessor;
namespace UE::Mass
{
    struct FRelationManager;
}
 
namespace UE::Mass::Relations
{
    enum class ERemovalPolicy : uint8
    {
        CleanUp,
        Destroy,
        Splice,
        Custom,
 
        MAX,
        Default = CleanUp,
    };
 
    enum class EExternalMappingRequired : uint8
    {
        No,
        Yes,
        Default = Yes, 
    };
 
    enum class ERelationRole : uint8
    {
        Subject,
        Object,
        MAX
    };
 
    inline FString LexToString(const ERelationRole Value)
    {
        return Value == ERelationRole::MAX
            ? TEXT("INVALID")
            : (Value == ERelationRole::Subject
                ? TEXT("Subject")
                : TEXT("Object"));
    }
 
    struct FRoleTraits
    {
        const UScriptStruct* Element = nullptr;
 
        ERemovalPolicy DestructionPolicy = ERemovalPolicy::Default;
 
        bool bExclusive = true;
 
        EExternalMappingRequired RequiresExternalMapping = EExternalMappingRequired::Default;
 
        bool operator==(const FRoleTraits& Other) const
        {
            return Element == Other.Element
                && DestructionPolicy == Other.DestructionPolicy
                && bExclusive == Other.bExclusive
                && RequiresExternalMapping == Other.RequiresExternalMapping;
        }
    };
 
    struct FRelationTypeTraits
    {
        UE_API FRelationTypeTraits(TNotNull<const UScriptStruct*> InRelationTagType);
        UE_API FRelationTypeTraits(const FRelationTypeTraits& Other, TNotNull<const UScriptStruct*> NewRelationTagType);
        FRelationTypeTraits(const FRelationTypeTraits& Other) = default;
 
        TNotNull<const UScriptStruct*> GetRelationTagType() const
        {
            return RelationTagType;
        }
 
        FName GetFName() const
        {
            return RelationName;
        }
 
        FName RelationName;
 
        bool IsValid() const;
 
    private:
        TNotNull<const UScriptStruct*> RelationTagType;
 
    public:
        TNotNull<const UScriptStruct*> RelationFragmentType;
 
        bool bCreateRelationEntitiesInHierarchy = false;
 
        TStaticArray<FRoleTraits, static_cast<uint8>(ERelationRole::MAX)> RoleTraits;
 
        bool bHierarchical = false;
 
        FArchetypeGroupType RegisteredGroupType;
 
        TFunction<bool(FMassEntityManager&)> RegisterObserversDelegate;
 
        TWeakObjectPtr<UClass> RelationEntityCreationObserverClass;
        TWeakObjectPtr<UClass> RelationEntityDestructionObserverClass;
        TWeakObjectPtr<UClass> SubjectEntityDestructionObserverClass;
        TWeakObjectPtr<UClass> ObjectEntityDestructionObserverClass;
 
        void SetDebugInFix(FString&& InFix);
#if WITH_MASSENTITY_DEBUG
        UE_API FString DebugDescribeRelation(FMassEntityHandle A, FMassEntityHandle B) const;
    private:
        FString DebugInFix;
#endif // WITH_MASSENTITY_DEBUG
    };
}
 
//-----------------------------------------------------------------------------
// Relation types
//-----------------------------------------------------------------------------
USTRUCT()
struct FMassRelation : public FMassTag
{
    GENERATED_BODY()
};
 
//-----------------------------------------------------------------------------
// Relation data
//-----------------------------------------------------------------------------
USTRUCT()
struct FMassRelationFragment : public FMassFragment
{
    GENERATED_BODY()
 
    
    FMassEntityHandle Subject;
 
    FMassEntityHandle Object;
 
    FMassEntityHandle GetRole(const int32 Index) const
    {
        return Index == 0 ? Subject : Object;
    }
 
    FMassEntityHandle GetRole(const UE::Mass::Relations::ERelationRole Role) const
    {
        check(Role != UE::Mass::Relations::ERelationRole::MAX);
        return GetRole(static_cast<int32>(Role));
    }
};
 
USTRUCT()
struct FMassRelationMappingFragment : public FMassFragment
{
    GENERATED_BODY()
};
 
struct alignas(8) FMassRelationRoleInstanceHandle
{
    static constexpr int32 EntityIndexBits = 30;
    static constexpr int32 EntityIndexMask = (1 << 30) - 1;
    static constexpr int32 TypeMask = ~EntityIndexMask;
 
    FMassRelationRoleInstanceHandle() = default;
 
    static FMassRelationRoleInstanceHandle Create(UE::Mass::Relations::ERelationRole Role, const FMassEntityHandle RoleHandle, const FMassEntityHandle RelationEntityHandle)
    {
        check(Role != UE::Mass::Relations::ERelationRole::MAX);
 
        FMassRelationRoleInstanceHandle ReturnHandle;
        ReturnHandle.SetRoleEntityIndex(RoleHandle.Index);
        ReturnHandle.SetRelationEntityIndex(RelationEntityHandle.Index);
        ReturnHandle.SetRole(Role);
        check(ReturnHandle.GetRoleEntityIndex() == RoleHandle.Index)
        check(ReturnHandle.GetRelationEntityIndex() == RelationEntityHandle.Index)
 
        return ReturnHandle;
    }
 
    int32 GetRoleEntityIndex() const 
    {
        return (RoleEntity & EntityIndexMask);
    }
    MASSENTITY_API FMassEntityHandle GetRoleEntityHandle(const FMassEntityManager& EntityManager) const;
 
    int32 GetRelationEntityIndex() const 
    {
        return (RelationEntity & EntityIndexMask);
    }
    MASSENTITY_API FMassEntityHandle GetRelationEntityHandle(const FMassEntityManager& EntityManager) const;
 
    UE::Mass::Relations::ERelationRole GetRole() const
    {
        return static_cast<UE::Mass::Relations::ERelationRole>((RoleEntity & TypeMask) >> EntityIndexBits);
    }
 
    friend FString LexToString(const FMassRelationRoleInstanceHandle Handle)
    {
        return Handle.DebugGetDescription();
    }
 
    FString DebugGetDescription() const
    {
        return FString::Printf(TEXT("Relation %d role %s %d"), GetRelationEntityIndex(), *LexToString(GetRole()), GetRoleEntityIndex());
    }
 
    bool IsValid() const = delete;
 
    struct FMassRelationRoleInstanceHandleFinder
    {
        FMassRelationRoleInstanceHandleFinder(const FMassEntityHandle EntityHandle)
            : EntityIndex(EntityHandle.Index)
        {   
        }
 
        bool operator()(const FMassRelationRoleInstanceHandle& Element) const
        {
            return Element.GetRoleEntityIndex() == EntityIndex;
        }
 
        const int32 EntityIndex;
    };
 
    bool operator==(const FMassRelationRoleInstanceHandle& Other) const
    {
        return RelationEntity == Other.RelationEntity && RoleEntity == Other.RoleEntity;
    }
 
private:
    uint32 RelationEntity = 0;
    uint32 RoleEntity = 0;
 
    void SetRoleEntityIndex(const int32 InIndex)
    {
        RoleEntity = (InIndex & EntityIndexMask) | (RoleEntity & TypeMask);
    }
 
    void SetRelationEntityIndex(const int32 InIndex)
    {
        RelationEntity = (InIndex & EntityIndexMask) | (RelationEntity & TypeMask);
    }
 
    void SetRole(UE::Mass::Relations::ERelationRole InRole)
    {
        RoleEntity = (RoleEntity & EntityIndexMask) | (static_cast<int32>(InRole) << EntityIndexBits);
    }
};
 
namespace UE::Mass
{
    template<>
    inline bool IsA<FMassRelation>(const UStruct* Struct)
    {
        return Struct && Struct->IsChildOf(FMassRelation::StaticStruct());
    }
 
    template<typename T>
    concept CRelation = TIsDerivedFrom<typename TRemoveReference<T>::Type, FMassRelation>::Value;
};
 
#undef UE_API