GameplayTagsManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "AssetRegistry/AssetData.h"
#include "CoreMinimal.h"
#include "Stats/Stats.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "UObject/ScriptMacros.h"
#include "GameplayTagContainer.h"
#include "Engine/DataTable.h"
#include "Templates/UniquePtr.h"
#include "Misc/ScopeLock.h"
#include "Misc/TransactionallySafeCriticalSection.h"
#if WITH_EDITOR
#include "Hash/Blake3.h"
#endif
 
#include "GameplayTagsManager.generated.h"
 
class UGameplayTagsList;
struct FStreamableHandle;
class FNativeGameplayTag;
 
#if WITH_EDITOR
namespace UE::Cook { class FCookDependency; }
namespace UE::Cook { class ICookInfo; }
#endif
 
USTRUCT()
struct FGameplayTagTableRow : public FTableRowBase
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=GameplayTag)
    FName Tag;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=GameplayTag)
    FString DevComment;
 
    FGameplayTagTableRow() {}
    FGameplayTagTableRow(FName InTag, const FString& InDevComment = TEXT("")) : Tag(InTag), DevComment(InDevComment) {}
    GAMEPLAYTAGS_API FGameplayTagTableRow(FGameplayTagTableRow const& Other);
 
    GAMEPLAYTAGS_API FGameplayTagTableRow& operator=(FGameplayTagTableRow const& Other);
    GAMEPLAYTAGS_API bool operator==(FGameplayTagTableRow const& Other) const;
    GAMEPLAYTAGS_API bool operator!=(FGameplayTagTableRow const& Other) const;
    GAMEPLAYTAGS_API bool operator<(FGameplayTagTableRow const& Other) const;
};
 
USTRUCT()
struct FRestrictedGameplayTagTableRow : public FGameplayTagTableRow
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = GameplayTag)
    bool bAllowNonRestrictedChildren;
 
    FRestrictedGameplayTagTableRow() : bAllowNonRestrictedChildren(false) {}
    FRestrictedGameplayTagTableRow(FName InTag, const FString& InDevComment = TEXT(""), bool InAllowNonRestrictedChildren = false) : FGameplayTagTableRow(InTag, InDevComment), bAllowNonRestrictedChildren(InAllowNonRestrictedChildren) {}
    GAMEPLAYTAGS_API FRestrictedGameplayTagTableRow(FRestrictedGameplayTagTableRow const& Other);
 
    GAMEPLAYTAGS_API FRestrictedGameplayTagTableRow& operator=(FRestrictedGameplayTagTableRow const& Other);
    GAMEPLAYTAGS_API bool operator==(FRestrictedGameplayTagTableRow const& Other) const;
    GAMEPLAYTAGS_API bool operator!=(FRestrictedGameplayTagTableRow const& Other) const;
};
 
UENUM()
enum class EGameplayTagSourceType : uint8
{
    Native,             // Was added from C++ code
    DefaultTagList,     // The default tag list in DefaultGameplayTags.ini
    TagList,            // Another tag list from an ini in tags/*.ini
    RestrictedTagList,  // Restricted tags from an ini
    DataTable,          // From a DataTable
    Invalid,            // Not a real source
};
 
UENUM()
enum class EGameplayTagSelectionType : uint8
{
    None,
    NonRestrictedOnly,
    RestrictedOnly,
    All
};
 
USTRUCT()
struct FGameplayTagSource
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    FName SourceName;
 
    UPROPERTY()
    EGameplayTagSourceType SourceType;
 
    UPROPERTY()
    TObjectPtr<class UGameplayTagsList> SourceTagList;
 
    UPROPERTY()
    TObjectPtr<class URestrictedGameplayTagsList> SourceRestrictedTagList;
 
    FGameplayTagSource() 
        : SourceName(NAME_None), SourceType(EGameplayTagSourceType::Invalid), SourceTagList(nullptr), SourceRestrictedTagList(nullptr)
    {
    }
 
    FGameplayTagSource(FName InSourceName, EGameplayTagSourceType InSourceType, UGameplayTagsList* InSourceTagList = nullptr, URestrictedGameplayTagsList* InSourceRestrictedTagList = nullptr) 
        : SourceName(InSourceName), SourceType(InSourceType), SourceTagList(InSourceTagList), SourceRestrictedTagList(InSourceRestrictedTagList)
    {
    }
 
    GAMEPLAYTAGS_API FString GetConfigFileName() const;
 
    static GAMEPLAYTAGS_API FName GetNativeName();
 
    static GAMEPLAYTAGS_API FName GetDefaultName();
 
#if WITH_EDITOR
    static GAMEPLAYTAGS_API FName GetFavoriteName();
 
    static GAMEPLAYTAGS_API void SetFavoriteName(FName TagSourceToFavorite);
 
    static GAMEPLAYTAGS_API FName GetTransientEditorName();
#endif
};
 
struct FGameplayTagSearchPathInfo
{
    TArray<FName> SourcesInPath;
 
    TArray<FString> TagIniList;
 
    bool bWasSearched = false;
 
    bool bWasAddedToTree = false;
 
    inline void Reset()
    {
        SourcesInPath.Reset();
        TagIniList.Reset();
        bWasSearched = false;
        bWasAddedToTree = false;
    }
 
    inline bool IsValid()
    {
        return bWasSearched && bWasAddedToTree;
    }
};
 
USTRUCT()
struct FGameplayTagNode
{
    GENERATED_USTRUCT_BODY()
    FGameplayTagNode(){};
 
    FGameplayTagNode(FName InTag, FName InFullTag, TSharedPtr<FGameplayTagNode> InParentNode, bool InIsExplicitTag, bool InIsRestrictedTag, bool InAllowNonRestrictedChildren);
 
    inline const FGameplayTagContainer& GetSingleTagContainer() const { return CompleteTagWithParents; }
 
    inline const FGameplayTag& GetCompleteTag() const { return CompleteTagWithParents.Num() > 0 ? CompleteTagWithParents.GameplayTags[0] : FGameplayTag::EmptyTag; }
    inline FName GetCompleteTagName() const { return GetCompleteTag().GetTagName(); }
    inline FString GetCompleteTagString() const { return GetCompleteTag().ToString(); }
 
    inline FName GetSimpleTagName() const { return Tag; }
 
    inline TArray< TSharedPtr<FGameplayTagNode> >& GetChildTagNodes() { return ChildTags; }
 
    inline const TArray< TSharedPtr<FGameplayTagNode> >& GetChildTagNodes() const { return ChildTags; }
 
    inline TSharedPtr<FGameplayTagNode> GetParentTagNode() const { return ParentNode; }
 
    inline FGameplayTagNetIndex GetNetIndex() const { check(NetIndex != INVALID_TAGNETINDEX); return NetIndex; }
 
    GAMEPLAYTAGS_API void ResetNode();
 
    inline bool IsExplicitTag() const {
#if WITH_EDITORONLY_DATA
        return bIsExplicitTag;
#else
        return true;
#endif
    }
 
    inline bool GetAllowNonRestrictedChildren() const { 
#if WITH_EDITORONLY_DATA
        return bAllowNonRestrictedChildren;  
#else
        return true;
#endif
    }
 
    inline bool IsRestrictedGameplayTag() const {
#if WITH_EDITORONLY_DATA
        return bIsRestrictedTag;
#else
        return true;
#endif
    }
 
#if WITH_EDITORONLY_DATA
    FName GetFirstSourceName() const { return SourceNames.Num() == 0 ? NAME_None : SourceNames[0]; }
    const TArray<FName>& GetAllSourceNames() const { return SourceNames; }
#endif
 
#if WITH_EDITORONLY_DATA
    FString GetDevComment() const { return DevComment; }
#endif
 
#if WITH_EDITOR
    GAMEPLAYTAGS_API void Hash(FBlake3& Hasher);
#endif
 
private:
    FName Tag;
 
    FGameplayTagContainer CompleteTagWithParents;
 
    TArray< TSharedPtr<FGameplayTagNode> > ChildTags;
 
    TSharedPtr<FGameplayTagNode> ParentNode;
    
    FGameplayTagNetIndex NetIndex;
 
#if WITH_EDITORONLY_DATA
    TArray<FName> SourceNames;
 
    FString DevComment;
 
    uint8 bIsRestrictedTag : 1;
 
    uint8 bAllowNonRestrictedChildren : 1;
 
    uint8 bIsExplicitTag : 1;
 
    uint8 bDescendantHasConflict : 1;
 
    uint8 bNodeHasConflict : 1;
 
    uint8 bAncestorHasConflict : 1;
#endif 
 
    friend class UGameplayTagsManager;
    friend class SGameplayTagWidget;
    friend class SGameplayTagPicker;
};
 
UCLASS(config=Engine, MinimalAPI)
class UGameplayTagsManager : public UObject
{
    GENERATED_UCLASS_BODY()
 
    
    GAMEPLAYTAGS_API ~UGameplayTagsManager();
 
    inline static UGameplayTagsManager& Get()
    {
        if (SingletonManager == nullptr)
        {
            InitializeManager();
        }
 
        return *SingletonManager;
    }
 
    inline static UGameplayTagsManager* GetIfAllocated() { return SingletonManager; }
 
    GAMEPLAYTAGS_API void RequestGameplayTagContainer(const TArray<FString>& TagStrings, FGameplayTagContainer& OutTagsContainer, bool bErrorIfNotFound=true) const;
 
    GAMEPLAYTAGS_API FGameplayTag RequestGameplayTag(FName TagName, bool ErrorIfNotFound=true) const;
 
    GAMEPLAYTAGS_API bool IsValidGameplayTagString(const TCHAR* TagString, FText* OutError = nullptr, FString* OutFixedString = nullptr);
    GAMEPLAYTAGS_API bool IsValidGameplayTagString(const FString& TagString, FText* OutError = nullptr, FString* OutFixedString = nullptr);
    GAMEPLAYTAGS_API bool IsValidGameplayTagString(const FStringView& TagString, FText* OutError = nullptr, FStringBuilderBase* OutFixedString = nullptr);
 
    GAMEPLAYTAGS_API FGameplayTag FindGameplayTagFromPartialString_Slow(FString PartialString) const;
 
    GAMEPLAYTAGS_API FGameplayTag AddNativeGameplayTag(FName TagName, const FString& TagDevComment = TEXT("(Native)"));
 
private:
    // Only callable from FNativeGameplayTag, these functions do less error checking and can happen after initial tag loading is done
    GAMEPLAYTAGS_API void AddNativeGameplayTag(FNativeGameplayTag* TagSource);
    GAMEPLAYTAGS_API void RemoveNativeGameplayTag(const FNativeGameplayTag* TagSource);
 
public:
    GAMEPLAYTAGS_API void DoneAddingNativeTags();
 
    static GAMEPLAYTAGS_API FSimpleMulticastDelegate& OnLastChanceToAddNativeTags();
 
    GAMEPLAYTAGS_API FDelegateHandle CallOrRegister_OnDoneAddingNativeTagsDelegate(const FSimpleMulticastDelegate::FDelegate& Delegate) const;
 
    GAMEPLAYTAGS_API FGameplayTagContainer RequestGameplayTagParents(const FGameplayTag& GameplayTag) const;
 
    GAMEPLAYTAGS_API bool ExtractParentTags(const FGameplayTag& GameplayTag, TArray<FGameplayTag>& UniqueParentTags) const;
 
    GAMEPLAYTAGS_API FGameplayTagContainer RequestGameplayTagChildren(const FGameplayTag& GameplayTag) const;
 
    GAMEPLAYTAGS_API FGameplayTag RequestGameplayTagDirectParent(const FGameplayTag& GameplayTag) const;
 
    UE_DEPRECATED(5.4, "This function is not threadsafe, use FindTagNode or FGameplayTag::GetSingleTagContainer")
    inline const FGameplayTagContainer* GetSingleTagContainer(const FGameplayTag& GameplayTag) const
    {
        return GetSingleTagContainerPtr(GameplayTag);
    }
 
    inline TSharedPtr<FGameplayTagNode> FindTagNode(const FGameplayTag& GameplayTag) const
    {
        UE::TScopeLock Lock(GameplayTagMapCritical);
 
        const TSharedPtr<FGameplayTagNode>* Node = GameplayTagNodeMap.Find(GameplayTag);
 
        if (Node)
        {
            return *Node;
        }
#if WITH_EDITOR
        // Check redirector
        if (GIsEditor && GameplayTag.IsValid())
        {
            FGameplayTag RedirectedTag = GameplayTag;
 
            RedirectSingleGameplayTag(RedirectedTag, nullptr);
 
            Node = GameplayTagNodeMap.Find(RedirectedTag);
 
            if (Node)
            {
                return *Node;
            }
        }
#endif
        return nullptr;
    }
 
    inline TSharedPtr<FGameplayTagNode> FindTagNode(FName TagName) const
    {
        FGameplayTag PossibleTag(TagName);
        return FindTagNode(PossibleTag);
    }
 
    GAMEPLAYTAGS_API void LoadGameplayTagTables(bool bAllowAsyncLoad = false);
 
    GAMEPLAYTAGS_API void AddTagIniSearchPath(const FString& RootDir, const TSet<FString>* PluginConfigsCache = nullptr);
 
    GAMEPLAYTAGS_API bool RemoveTagIniSearchPath(const FString& RootDir);
 
    GAMEPLAYTAGS_API void GetTagSourceSearchPaths(TArray<FString>& OutPaths);
 
    GAMEPLAYTAGS_API int32 GetNumTagSourceSearchPaths();
 
    GAMEPLAYTAGS_API void ConstructGameplayTagTree();
 
    GAMEPLAYTAGS_API void DestroyGameplayTagTree();
 
    GAMEPLAYTAGS_API void SplitGameplayTagFName(const FGameplayTag& Tag, TArray<FName>& OutNames) const;
 
    GAMEPLAYTAGS_API void RequestAllGameplayTags(FGameplayTagContainer& TagContainer, bool OnlyIncludeDictionaryTags) const;
 
    GAMEPLAYTAGS_API bool ValidateTagCreation(FName TagName) const;
 
    GAMEPLAYTAGS_API const FGameplayTagSource* FindTagSource(FName TagSourceName) const;
 
    GAMEPLAYTAGS_API FGameplayTagSource* FindTagSource(FName TagSourceName);
 
    GAMEPLAYTAGS_API void FindTagSourcesWithType(EGameplayTagSourceType TagSourceType, TArray<const FGameplayTagSource*>& OutArray) const;
 
    GAMEPLAYTAGS_API void FindTagsWithSource(FStringView PackageNameOrPath, TArray<FGameplayTag>& OutTags) const;
 
    GAMEPLAYTAGS_API int32 GameplayTagsMatchDepth(const FGameplayTag& GameplayTagOne, const FGameplayTag& GameplayTagTwo) const;
 
    GAMEPLAYTAGS_API int32 GetNumberOfTagNodes(const FGameplayTag& GameplayTag) const;
 
    GAMEPLAYTAGS_API bool ShouldImportTagsFromINI() const;
 
    bool ShouldWarnOnInvalidTags() const
    {
        return bShouldWarnOnInvalidTags;
    }
 
    UE_DEPRECATED(5.5, "We should never clear invalid tags as we're not guaranteed the required plugin has loaded")
    bool ShouldClearInvalidTags() const
    {
        return false;
    }
 
    bool ShouldUseFastReplication() const
    {
        return bUseFastReplication;
    }
 
    bool ShouldUseDynamicReplication() const
    {
        return !bUseFastReplication && bUseDynamicReplication;
    }
 
    GAMEPLAYTAGS_API bool ShouldUnloadTags() const;
 
    GAMEPLAYTAGS_API void SetShouldUnloadTagsOverride(bool bShouldUnloadTags);
 
    GAMEPLAYTAGS_API void ClearShouldUnloadTagsOverride();
 
    GAMEPLAYTAGS_API void SetShouldDeferGameplayTagTreeRebuilds(bool bShouldDeferRebuilds);
 
    GAMEPLAYTAGS_API void ClearShouldDeferGameplayTagTreeRebuilds(bool bRebuildTree);
 
    uint32 GetNetworkGameplayTagNodeIndexHash() const { VerifyNetworkIndex(); return NetworkGameplayTagNodeIndexHash; }
 
    GAMEPLAYTAGS_API void GetRestrictedTagConfigFiles(TArray<FString>& RestrictedConfigFiles) const;
 
    GAMEPLAYTAGS_API void GetRestrictedTagSources(TArray<const FGameplayTagSource*>& Sources) const;
 
    GAMEPLAYTAGS_API void GetOwnersForTagSource(const FString& SourceName, TArray<FString>& OutOwners) const;
 
    GAMEPLAYTAGS_API void GameplayTagContainerLoaded(FGameplayTagContainer& Container, FProperty* SerializingProperty) const;
 
    GAMEPLAYTAGS_API void SingleGameplayTagLoaded(FGameplayTag& Tag, FProperty* SerializingProperty) const;
 
    GAMEPLAYTAGS_API void RedirectTagsForContainer(FGameplayTagContainer& Container, FProperty* SerializingProperty) const;
 
    GAMEPLAYTAGS_API void RedirectSingleGameplayTag(FGameplayTag& Tag, FProperty* SerializingProperty) const;
 
    GAMEPLAYTAGS_API bool ImportSingleGameplayTag(FGameplayTag& Tag, FName ImportedTagName, bool bImportFromSerialize = false) const;
 
    GAMEPLAYTAGS_API FName GetTagNameFromNetIndex(FGameplayTagNetIndex Index) const;
    GAMEPLAYTAGS_API FGameplayTagNetIndex GetNetIndexFromTag(const FGameplayTag &InTag) const;
 
    int32 GetNetIndexTrueBitNum() const { VerifyNetworkIndex(); return NetIndexTrueBitNum; }
 
    int32 GetNetIndexFirstBitSegment() const { VerifyNetworkIndex(); return NetIndexFirstBitSegment; }
 
    FGameplayTagNetIndex GetInvalidTagNetIndex() const { VerifyNetworkIndex(); return InvalidTagNetIndex; }
 
    const TArray<TSharedPtr<FGameplayTagNode>>& GetNetworkGameplayTagNodeIndex() const { VerifyNetworkIndex(); return NetworkGameplayTagNodeIndex; }
 
    DECLARE_TS_MULTICAST_DELEGATE_OneParam(FOnGameplayTagLoaded, const FGameplayTag& /*Tag*/)
    FOnGameplayTagLoaded OnGameplayTagLoadedDelegate;
 
    int32 NumBitsForContainerSize;
 
    GAMEPLAYTAGS_API void PushDeferOnGameplayTagTreeChangedBroadcast();
    GAMEPLAYTAGS_API void PopDeferOnGameplayTagTreeChangedBroadcast();
 
private:
    int32 NetIndexTrueBitNum;
 
    int32 NetIndexFirstBitSegment;
 
    FGameplayTagNetIndex InvalidTagNetIndex;
 
public:
 
#if WITH_EDITOR
    GAMEPLAYTAGS_API void GetFilteredGameplayRootTags(const FString& InFilterString, TArray< TSharedPtr<FGameplayTagNode> >& OutTagArray) const;
 
    GAMEPLAYTAGS_API FString GetCategoriesMetaFromPropertyHandle(TSharedPtr<class IPropertyHandle> PropertyHandle) const;
 
    static GAMEPLAYTAGS_API FString StaticGetCategoriesMetaFromPropertyHandle(TSharedPtr<class IPropertyHandle> PropertyHandle);
 
    template <typename TFieldType>
    static FString GetCategoriesMetaFromField(TFieldType* Field)
    {
        check(Field);
        if (Field->HasMetaData(NAME_Categories))
        {
            return Field->GetMetaData(NAME_Categories);
        }
        else if (Field->HasMetaData(NAME_GameplayTagFilter))
        {
            return Field->GetMetaData(NAME_GameplayTagFilter);
        }
        return FString();
    }
 
    static GAMEPLAYTAGS_API FString GetCategoriesMetaFromFunction(const UFunction* Func, FName ParamName = NAME_None);
 
    GAMEPLAYTAGS_API void GetAllTagsFromSource(FName TagSource, TArray< TSharedPtr<FGameplayTagNode> >& OutTagArray) const;
 
    GAMEPLAYTAGS_API bool IsDictionaryTag(FName TagName) const;
 
    GAMEPLAYTAGS_API bool GetTagEditorData(FName TagName, FString& OutComment, FName &OutFirstTagSource, bool& bOutIsTagExplicit, bool &bOutIsRestrictedTag, bool &bOutAllowNonRestrictedChildren) const;
    
    GAMEPLAYTAGS_API bool GetTagEditorData(FName TagName, FString& OutComment, TArray<FName>& OutTagSources, bool& bOutIsTagExplicit, bool &bOutIsRestrictedTag, bool &bOutAllowNonRestrictedChildren) const;
 
    static GAMEPLAYTAGS_API FSimpleMulticastDelegate OnEditorRefreshGameplayTagTree;
 
    GAMEPLAYTAGS_API void EditorRefreshGameplayTagTree();
 
    GAMEPLAYTAGS_API void SuspendEditorRefreshGameplayTagTree(FGuid SuspendToken);
 
    GAMEPLAYTAGS_API void ResumeEditorRefreshGameplayTagTree(FGuid SuspendToken);
 
    GAMEPLAYTAGS_API FGameplayTagContainer RequestGameplayTagChildrenInDictionary(const FGameplayTag& GameplayTag) const;
#if WITH_EDITORONLY_DATA
    GAMEPLAYTAGS_API FGameplayTagContainer RequestGameplayTagDirectDescendantsInDictionary(const FGameplayTag& GameplayTag, EGameplayTagSelectionType SelectionType) const;
#endif // WITH_EDITORONLY_DATA
 
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnGameplayTagDoubleClickedEditor, FGameplayTag, FSimpleMulticastDelegate& /* OUT */)
    FOnGameplayTagDoubleClickedEditor OnGatherGameplayTagDoubleClickedEditor;
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnGetCategoriesMetaFromPropertyHandle, TSharedPtr<IPropertyHandle>, FString& /* OUT */)
    FOnGetCategoriesMetaFromPropertyHandle OnGetCategoriesMetaFromPropertyHandle;
 
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnFilterGameplayTagChildren, const FString&  , TSharedPtr<FGameplayTagNode>& /* TagNode */, bool& /* OUT OutShouldHide */)
    FOnFilterGameplayTagChildren OnFilterGameplayTagChildren;
 
    /*
    * This is a container to filter out gameplay tags when they are invalid or when they don't meet the filter string
    * If used from editor to filter out tags when picking them the FilterString is optional and the ReferencingPropertyHandle is required
    * If used to validate an asset / assets you can provide the TagSourceAssets. The FilterString and ReferencingPropertyHandle is optional
    */
    struct FFilterGameplayTagContext
    {
        const FString& FilterString;
        const TSharedPtr<FGameplayTagNode>& TagNode;
        const FGameplayTagSource* TagSource;
        const TSharedPtr<IPropertyHandle> ReferencingPropertyHandle;
        const TArray<FAssetData> TagSourceAssets;
 
        FFilterGameplayTagContext(const FString& InFilterString, const TSharedPtr<FGameplayTagNode>& InTagNode, const FGameplayTagSource* InTagSource, const TSharedPtr<IPropertyHandle>& InReferencingPropertyHandle)
            : FilterString(InFilterString), TagNode(InTagNode), TagSource(InTagSource), ReferencingPropertyHandle(InReferencingPropertyHandle)
        {}
 
        FFilterGameplayTagContext(const TSharedPtr<FGameplayTagNode>& InTagNode, const FGameplayTagSource* InTagSource, const TArray<FAssetData>& InTagSourceAssets, const FString& InFilterString = FString())
            : FilterString(InFilterString), TagNode(InTagNode), TagSource(InTagSource), TagSourceAssets(InTagSourceAssets)
        {}
    };
 
    /*
     * Allows dynamic hiding of gameplay tags in SGameplayTagWidget. Allows higher order structs to dynamically change which tags are visible based on its own data
     * Applies to all tags, and has more context than OnFilterGameplayTagChildren
     */
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnFilterGameplayTag, const FFilterGameplayTagContext& , bool& /* OUT OutShouldHide */)
    FOnFilterGameplayTag OnFilterGameplayTag;
    
    GAMEPLAYTAGS_API void NotifyGameplayTagDoubleClickedEditor(FString TagName);
    
    GAMEPLAYTAGS_API bool ShowGameplayTagAsHyperLinkEditor(FString TagName);
 
    GAMEPLAYTAGS_API UE::Cook::FCookDependency CreateCookDependency();
 
    void DumpSources(FOutputDevice& Out) const;
#endif //WITH_EDITOR
 
    GAMEPLAYTAGS_API void PrintReplicationIndices();
    int32 GetNumGameplayTagNodes() const { return GameplayTagNodeMap.Num(); }
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    GAMEPLAYTAGS_API void PrintReplicationFrequencyReport();
    GAMEPLAYTAGS_API void NotifyTagReplicated(FGameplayTag Tag, bool WasInContainer);
 
    TMap<FGameplayTag, int32>   ReplicationCountMap;
    TMap<FGameplayTag, int32>   ReplicationCountMap_SingleTags;
    TMap<FGameplayTag, int32>   ReplicationCountMap_Containers;
#endif
 
private:
 
    static GAMEPLAYTAGS_API void InitializeManager();
 
    static GAMEPLAYTAGS_API FSimpleMulticastDelegate& OnDoneAddingNativeTagsDelegate();
 
    static GAMEPLAYTAGS_API UGameplayTagsManager* SingletonManager;
 
    friend class FGameplayTagTest;
    friend class FGameplayEffectsTest;
    friend class FGameplayTagsModule;
    friend class FGameplayTagsEditorModule;
    friend class UGameplayTagsSettings;
    friend class SAddNewGameplayTagSourceWidget;
    friend class FNativeGameplayTag;
 
    inline const FGameplayTagContainer* GetSingleTagContainerPtr(const FGameplayTag& GameplayTag) const
    {
        // Doing this with pointers to avoid a shared ptr reference count change
        const TSharedPtr<FGameplayTagNode>* Node = GameplayTagNodeMap.Find(GameplayTag);
 
        if (Node)
        {
            return &(*Node)->GetSingleTagContainer();
        }
#if WITH_EDITOR
        // Check redirector
        if (GIsEditor && GameplayTag.IsValid())
        {
            FGameplayTag RedirectedTag = GameplayTag;
 
            RedirectSingleGameplayTag(RedirectedTag, nullptr);
 
            Node = GameplayTagNodeMap.Find(RedirectedTag);
 
            if (Node)
            {
                return &(*Node)->GetSingleTagContainer();
            }
        }
#endif
        return nullptr;
    }
 
 
    GAMEPLAYTAGS_API int32 InsertTagIntoNodeArray(FName Tag, FName FullTag, TSharedPtr<FGameplayTagNode> ParentNode, TArray< TSharedPtr<FGameplayTagNode> >& NodeArray, FName SourceName, const FString& DevComment, bool bIsExplicitTag, bool bIsRestrictedTag, bool bAllowNonRestrictedChildren);
 
    GAMEPLAYTAGS_API void PopulateTreeFromDataTable(class UDataTable* Table);
 
    GAMEPLAYTAGS_API void AddTagTableRow(const FGameplayTagTableRow& TagRow, FName SourceName, bool bIsRestrictedTag = false);
 
    GAMEPLAYTAGS_API void AddChildrenTags(FGameplayTagContainer& TagContainer, TSharedPtr<FGameplayTagNode> GameplayTagNode, bool RecurseAll=true, bool OnlyIncludeDictionaryTags=false) const;
 
    GAMEPLAYTAGS_API void AddRestrictedGameplayTagSource(const FString& FileName);
 
    GAMEPLAYTAGS_API void AddTagsFromAdditionalLooseIniFiles(const TArray<FString>& IniFileList);
 
    GAMEPLAYTAGS_API void GetAllParentNodeNames(TSet<FName>& NamesList, TSharedPtr<FGameplayTagNode> GameplayTag) const;
 
    GAMEPLAYTAGS_API FGameplayTagSource* FindOrAddTagSource(FName TagSourceName, EGameplayTagSourceType SourceType, const FString& RootDirToUse = FString());
 
    GAMEPLAYTAGS_API void ConstructNetIndex();
 
    GAMEPLAYTAGS_API void MarkChildrenOfNodeConflict(TSharedPtr<FGameplayTagNode> CurNode);
 
    void VerifyNetworkIndex() const
    {
        if (!bUseFastReplication)
        {
            UE_LOG(LogGameplayTags, Warning, TEXT("%hs called when not using FastReplication (not rebuilding the fast replication cache)"), __func__);
        }
        else if (bNetworkIndexInvalidated)
        {
            const_cast<UGameplayTagsManager*>(this)->ConstructNetIndex();
        }
    }
 
    void InvalidateNetworkIndex() { bNetworkIndexInvalidated = true; }
 
    GAMEPLAYTAGS_API void BroadcastOnGameplayTagTreeChanged();
 
    GAMEPLAYTAGS_API void HandleGameplayTagTreeChanged(bool bRecreateTree);
 
#if WITH_EDITOR
    void UpdateIncrementalCookHash(UE::Cook::ICookInfo& CookInfo);
#endif
 
    // Tag Sources
 
    TSet<FName> LegacyNativeTags;
 
    TMap<FString, FGameplayTagSearchPathInfo> RegisteredSearchPaths;
 
    TSharedPtr<FGameplayTagNode> GameplayRootTag;
 
    TMap<FGameplayTag, TSharedPtr<FGameplayTagNode>> GameplayTagNodeMap;
 
    TArray<FGameplayTag> CommonlyReplicatedTags;
 
    UPROPERTY()
    TMap<FName, FGameplayTagSource> TagSources;
 
    TSet<FName> RestrictedGameplayTagSourceNames;
 
    bool bIsConstructingGameplayTagTree = false;
 
    bool bUseFastReplication;
 
    bool bUseDynamicReplication;
 
    bool bShouldWarnOnInvalidTags;
 
    bool bShouldAllowUnloadingTags;
 
    TOptional<bool> ShouldAllowUnloadingTagsOverride;
 
    TOptional<bool> ShouldDeferGameplayTagTreeRebuilds;
 
    bool bDoneAddingNativeTags;
 
    int32 bDeferBroadcastOnGameplayTagTreeChanged = 0;
    bool bShouldBroadcastDeferredOnGameplayTagTreeChanged = false;
 
    bool bNeedsTreeRebuildOnDoneAddingGameplayTags = false;
 
    FString InvalidTagCharacters;
 
    // This critical section is to handle an issue where tag requests come from another thread when async loading from a background thread in FGameplayTagContainer::Serialize.
    // This class is not generically threadsafe, but this should be locked by any operation that could update something read by a background thread.
    mutable FTransactionallySafeCriticalSection GameplayTagMapCritical;
 
#if WITH_EDITOR
    // Transient editor-only tags to support quick-iteration PIE workflows
    TSet<FName> TransientEditorTags;
 
    TSet<FGuid> EditorRefreshGameplayTagTreeSuspendTokens;
    bool bEditorRefreshGameplayTagTreeRequestedDuringSuspend = false;
 
    FBlake3Hash IncrementalCookHash;
#endif //if WITH_EDITOR
 
    TArray<TSharedPtr<FGameplayTagNode>> NetworkGameplayTagNodeIndex;
 
    uint32 NetworkGameplayTagNodeIndexHash;
 
    bool bNetworkIndexInvalidated = true;
 
    UPROPERTY()
    TArray<TObjectPtr<UDataTable>> GameplayTagTables;
 
    GAMEPLAYTAGS_API const static FName NAME_Categories;
    GAMEPLAYTAGS_API const static FName NAME_GameplayTagFilter;
 
    friend class UGameplayTagsManagerIncrementalCookFunctions;
};