MassTypeManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "UObject/Class.h"
#include "UObject/ObjectKey.h"
#include "Misc/NotNull.h"
#include "Misc/TVariant.h"
#include "Templates/SharedPointer.h"
#include "MassEntityConcepts.h"
#include "Subsystems/Subsystem.h"
#include "MassEntityRelations.h"
#include "MassExternalSubsystemTraits.h"
 
#define UE_API MASSENTITY_API
 
 
struct FMassEntityManager;
 
namespace UE::Mass
{
    using namespace Relations;
    struct FRelationData;
 
    struct FTypeHandle
    {
        FTypeHandle() = default;
        FTypeHandle(const FTypeHandle&) = default;
 
        bool operator==(const FTypeHandle&) const = default;
 
        bool IsValid() const;
 
        const UClass* GetClass() const
        {
            return Cast<const UClass>(TypeKey.ResolveObjectPtr());
        }
 
        const UScriptStruct* GetScriptStruct() const
        {
            return Cast<UScriptStruct>(TypeKey.ResolveObjectPtr());
        }
 
        friend inline uint32 GetTypeHash(const FTypeHandle& InHandle)
        {
            return GetTypeHash(InHandle.TypeKey);
        }
 
        FName GetFName() const
        {
            const UStruct* RepresentedType = TypeKey.ResolveObjectPtr();
            return GetFNameSafe(RepresentedType);
        }
 
        FString ToString() const
        {
            const UStruct* RepresentedType = TypeKey.ResolveObjectPtr();
            return GetNameSafe(RepresentedType);
        }
 
    private:
        friend struct FTypeManager;
        UE_API explicit FTypeHandle(TObjectKey<const UStruct> InTypeKey);
 
        TObjectKey<const UStruct> TypeKey;
    };
 
    struct FEmptyTypeTraits
    {
    };
 
    struct FSubsystemTypeTraits
    {
        FSubsystemTypeTraits() = default;
 
        template <typename T>
        static FSubsystemTypeTraits Make()
        {
            FSubsystemTypeTraits Traits;
            Traits.bGameThreadOnly = TMassExternalSubsystemTraits<T>::GameThreadOnly;
            Traits.bThreadSafeWrite = TMassExternalSubsystemTraits<T>::ThreadSafeWrite;
            return MoveTemp(Traits);
        }
 
        bool bGameThreadOnly = true;
        bool bThreadSafeWrite = false;
    };
 
    struct FSharedFragmentTypeTraits
    {
        FSharedFragmentTypeTraits() = default;
 
        template<CSharedFragment T>
        static FSharedFragmentTypeTraits Make()
        {
            FSharedFragmentTypeTraits Traits;
            Traits.bGameThreadOnly = TMassSharedFragmentTraits<T>::GameThreadOnly;
            return MoveTemp(Traits);
        }
 
        bool bGameThreadOnly = true;
    };
 
    struct FTypeInfo
    {
        using FTypeTraits = TVariant<FEmptyTypeTraits
            , FSubsystemTypeTraits
            , FSharedFragmentTypeTraits
            , FRelationTypeTraits>;
 
        FName TypeName;
        FTypeTraits Traits;
 
        const FSubsystemTypeTraits* GetAsSystemTraits() const;
 
        const FSharedFragmentTypeTraits* GetAsSharedFragmentTraits() const;
 
        const FRelationTypeTraits* GetAsRelationTraits() const;
 
        const FRelationTypeTraits& GetAsRelationTraitsChecked() const;
    };
 
    struct FTypeManager : TSharedFromThis<FTypeManager>
    {
        DECLARE_MULTICAST_DELEGATE_OneParam(FOnRegisterBuiltInTypes, FTypeManager& /*Instance*/);
 
        UE_API explicit FTypeManager(FMassEntityManager& InEntityManager);
 
        void RegisterBuiltInTypes();
 
        bool IsEmpty() const;
 
        UE_API FTypeHandle RegisterType(TNotNull<const UStruct*> InType, FSubsystemTypeTraits&&);
        UE_API FTypeHandle RegisterType(TNotNull<const UStruct*> InType, FSharedFragmentTypeTraits&&);
        UE_API FTypeHandle RegisterType(FRelationTypeTraits&&);
 
        template<CSharedFragment T>
        FTypeHandle RegisterType();
 
        template<typename T> requires TIsDerivedFrom<typename TRemoveReference<T>::Type, USubsystem>::Value
        FTypeHandle RegisterType();
 
        const FTypeInfo* GetTypeInfo(FTypeHandle TypeHandle) const;
 
        const FTypeInfo* GetTypeInfo(TObjectKey<const UStruct> TypeKey) const;
 
        const FRelationTypeTraits& GetRelationTypeChecked(const FTypeHandle TypeHandle) const;
        const FRelationTypeTraits& GetRelationTypeChecked(const TNotNull<const UScriptStruct*> RelationOrElementType) const;
        UE_API FTypeHandle GetRelationTypeHandle(const TNotNull<const UScriptStruct*> RelationOrElementType) const;
        UE_API bool IsValidRelationType(const TNotNull<const UScriptStruct*> RelationOrElementType) const;
 
        using FTypeInfoConstIterator = TMap<FTypeHandle, FTypeInfo>::TConstIterator;
 
        using FSubsystemTypeConstIterator = TSet<FTypeHandle>::TConstIterator;
 
        FTypeInfoConstIterator MakeIterator() const;
        FSubsystemTypeConstIterator MakeSubsystemIterator() const;
 
        FMassEntityManager& GetEntityManager();
 
        static FTypeHandle MakeTypeHandle(TNotNull<const UStruct*> InTypeKey);
 
        UE_API static FOnRegisterBuiltInTypes OnRegisterBuiltInTypes;
 
    private:
        UE_API FTypeHandle RegisterTypeInternal(TNotNull<const UStruct*> InType, FTypeInfo&&);
 
        FMassEntityManager& OuterEntityManager; 
 
        TMap<FTypeHandle, FTypeInfo> TypeDataMap;
 
        TSet<FTypeHandle> SubsystemTypes;
 
        bool bBuiltInTypesRegistered = false;
    };
 
    //----------------------------------------------------------------------------
    // INLINES
    //----------------------------------------------------------------------------
    inline bool FTypeHandle::IsValid() const
    {
        // using this strange contraption since TObjectKey doesn't supply a way to check
        // whether it's set, while comparison and construction is trivial.
        // Note: we don't care to what the key's been set, we don't expect types to go away
        return TypeKey != TObjectKey<const UStruct>();
    }
 
    inline const FSubsystemTypeTraits* FTypeInfo::GetAsSystemTraits() const
    {
        return Traits.TryGet<FSubsystemTypeTraits>();
    }
 
    inline const FSharedFragmentTypeTraits* FTypeInfo::GetAsSharedFragmentTraits() const
    {
        return Traits.TryGet<FSharedFragmentTypeTraits>();
    }
 
    inline const FRelationTypeTraits* FTypeInfo::GetAsRelationTraits() const
    {
        return Traits.TryGet<FRelationTypeTraits>();
    }
 
    inline const FRelationTypeTraits& FTypeInfo::GetAsRelationTraitsChecked() const
    {
        return Traits.Get<FRelationTypeTraits>();
    }
 
    inline bool FTypeManager::IsEmpty() const
    {
        return TypeDataMap.IsEmpty();
    }
 
    inline FTypeManager::FTypeInfoConstIterator FTypeManager::MakeIterator() const
    {
        return FTypeManager::FTypeInfoConstIterator(TypeDataMap);
    }
 
    inline FTypeManager::FSubsystemTypeConstIterator FTypeManager::MakeSubsystemIterator() const
    {
        return FTypeManager::FSubsystemTypeConstIterator(SubsystemTypes);
    }
 
    template<CSharedFragment T>
    FTypeHandle FTypeManager::RegisterType()
    {
        return RegisterType(T::StaticStruct(), FSharedFragmentTypeTraits::Make<T>());
    }
 
    template<typename T>
    requires TIsDerivedFrom<typename TRemoveReference<T>::Type, USubsystem>::Value
    FTypeHandle FTypeManager::RegisterType()
    {
        return RegisterType(T::StaticClass(), FSubsystemTypeTraits::Make<T>());
    }
 
    inline const FTypeInfo* FTypeManager::GetTypeInfo(FTypeHandle TypeHandle) const
    {
        return TypeDataMap.Find(TypeHandle);
    }
 
    inline const FTypeInfo* FTypeManager::GetTypeInfo(TObjectKey<const UStruct> TypeKey) const
    {
        return TypeDataMap.Find(FTypeHandle(TypeKey));
    }
 
    inline const FRelationTypeTraits& FTypeManager::GetRelationTypeChecked(const FTypeHandle RelationHandle) const
    {
        const FTypeInfo* RelationInfo = GetTypeInfo(RelationHandle);
        check(RelationInfo);
        return RelationInfo->GetAsRelationTraitsChecked();
    }
 
    inline const FRelationTypeTraits& FTypeManager::GetRelationTypeChecked(const TNotNull<const UScriptStruct*> RelationOrElementType) const
    {
        return GetRelationTypeChecked(GetRelationTypeHandle(RelationOrElementType));
    }
 
    inline FMassEntityManager& FTypeManager::GetEntityManager()
    {
        return OuterEntityManager;
    }
 
    inline FTypeHandle FTypeManager::MakeTypeHandle(TNotNull<const UStruct*> InTypeKey)
    {
        return FTypeHandle(InTypeKey);
    }
}
 
#undef UE_API