AssetRegistryInterface.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ContainersFwd.h"
#include "Containers/Set.h"
#include "CoreTypes.h"
#include "Misc/EnumClassFlags.h"
#include "Modules/ModuleInterface.h"
#include "Modules/ModuleManager.h"
#include "Templates/Function.h"
#include "UObject/NameTypes.h"
#include "UObject/TopLevelAssetPath.h"
 
class FLinkerSave;
class FStructuredArchiveRecord;
class ITargetPlatform;
class UObject;
class UPackage;
struct FArchiveCookContext;
struct FARFilter;
struct FAssetData;
 
namespace EAssetRegistryDependencyType
{
    enum UE_DEPRECATED(5.3, "No longer used") Type
    {
        // Dependencies which don't need to be loaded for the object to be used (i.e. soft object paths)
        Soft = 0x01,
 
        // Dependencies which are required for correct usage of the source asset, and must be loaded at the same time
        Hard = 0x02,
 
        // References to specific SearchableNames inside a package
        SearchableName = 0x04,
 
        // Indirect management references, these are set through recursion for Primary Assets that manage packages or other primary assets
        SoftManage = 0x08,
 
        // Reference that says one object directly manages another object, set when Primary Assets manage things explicitly
        HardManage = 0x10,
 
        // Note: Also update FAssetRegistryDependencyOptions when adding more flags
    };
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS;
    UE_DEPRECATED(5.3, "No longer used")
    inline static const Type None = (Type)(0);
    UE_DEPRECATED(5.3, "No longer used")
    inline static const Type All = (Type)(Soft | Hard | SearchableName | SoftManage | HardManage);
    UE_DEPRECATED(5.3, "No longer used")
    inline static const Type Packages = (Type)(Soft | Hard);
    UE_DEPRECATED(5.3, "No longer used")
    inline static const Type Manage = (Type)(SoftManage | HardManage);
    PRAGMA_ENABLE_DEPRECATION_WARNINGS;
}
 
class IAssetRegistry;
class UAssetRegistryImpl;
 
namespace UE::AssetRegistry
{
 
    // 
    enum class EDependencyCategory : uint8
    {
        // This enum is serialized by value into the runtime AssetRegistry and the AssetDataGatherer.
        // If any values change or are removed, bump FAssetRegistryVersion and add backwards compatibility in FAssetRegistryState::Serialize.
 
        Package = 0x01,         // The target asset of any package dependency is expected to be loadable whenever the source asset is available; see EDependencyProperty for different requirements of the loadability.
        Manage = 0x02,          // The target asset of any manage dependency is managed (e.g. given a disk layout location) either directly or indirectly by the source asset. Used by UAssetManager.
        SearchableName = 0x04,  // Targets of SearchableName dependencies are FNames Keys inside of an Asset. The Source Asset of the dependency has a value for that Key. Used to search for Assets with a given Key,Value for the custom Key.
 
        None = 0x0,
        All = Package | Manage | SearchableName,
    };
    ENUM_CLASS_FLAGS(EDependencyCategory);
 
    enum class EDependencyProperty : uint8
    {
        None = 0,
        // This enum is serialized by value into the runtime AssetRegistry and the AssetDataGatherer.
        // If any values change or are removed, bump FAssetRegistryVersion and add backwards compatibility in FAssetRegistryState::Serialize.
 
        // Package Dependencies
        Hard = 1 << 0,
        Game = 1 << 1,
        Build = 1 << 2,
        PackageMask = Hard | Game | Build,
 
        // SearchableName Dependencies (None Yet)
        SearchableNameMask = None,
 
        // ManageDependencies
        Direct = 1 << 3,
        CookRule = 1 << 4,
        ManageMask = Direct | CookRule,
 
 
        AllMask = PackageMask | SearchableNameMask | ManageMask,
    };
    ENUM_CLASS_FLAGS(EDependencyProperty);
 
    enum class EDependencyQuery : uint32
    {
        NoRequirements = 0,
 
        // Package Dependencies Only
        Hard = 1 << 0,
        NotHard = 1 << 1,
        Soft = NotHard,
 
        Game = 1 << 2,
        NotGame = 1 << 3,
        EditorOnly = NotGame,
 
        Build = 1 << 4,
        NotBuild = 1 << 5,
 
        Propagation = 1 << 6,
 
        // Manage Dependencies Only
        Direct = 1 << 8,
        NotDirect = 1 << 9,
        Indirect = NotDirect,
 
        CookRule = 1 << 10,
        NotCookRule = 1 << 11,
        ChunkOnly = NotCookRule,
 
        // Masks used for manipulating EDependencyQuerys
        PackageMask = Hard | NotHard | Game | NotGame | Build | NotBuild,
        SearchableNameMask = 0x0000, // None yet
        ManageMask = Direct | NotDirect | CookRule | NotCookRule,
    };
    ENUM_CLASS_FLAGS(EDependencyQuery);
 
    enum class ESerializationTarget : uint8
    {
        ForGame,
        ForDevelopment
    };
 
    enum class EExists
    {
        DoesNotExist,   // Does not exist on disk
        Exists,         // Exists on disk
        Unknown,        // Not known. AssetRegistry might still be indexing
    };
 
    enum class EEnumerateAssetsFlags : uint32
    {
        None = 0,
        OnlyOnDiskAssets = (1 << 0),
        AllowUnmountedPaths = (1 << 1),
        AllowUnfilteredArAssets = (1 << 2),
        AllowAll = AllowUnmountedPaths | AllowUnfilteredArAssets,
        Parallel = (1 << 3),
    };
    ENUM_CLASS_FLAGS(EEnumerateAssetsFlags);
    
    enum class EEnumeratePackagesFlags : uint32
    {
        None = 0,                           // No flags
        Parallel = (1 << 0),                // Iterate with a ParallelFor
    };
    ENUM_CLASS_FLAGS(EEnumeratePackagesFlags);
 
    struct FDependencyQuery
    {
        UE::AssetRegistry::EDependencyProperty Required;
        UE::AssetRegistry::EDependencyProperty Excluded;
 
        TArray<UE::AssetRegistry::EDependencyProperty, TInlineAllocator<1>> RequiredUnions;
 
        FDependencyQuery()
        {
            Required = UE::AssetRegistry::EDependencyProperty::None;
            Excluded = UE::AssetRegistry::EDependencyProperty::None;
        }
 
        inline FDependencyQuery(EDependencyQuery QueryFlags)
        {
            if (!EnumHasAnyFlags(QueryFlags, EDependencyQuery::Propagation))
            {
                Required = (!!(QueryFlags & EDependencyQuery::Game) ? UE::AssetRegistry::EDependencyProperty::Game : UE::AssetRegistry::EDependencyProperty::None)
                    | (!!(QueryFlags & EDependencyQuery::Build) ? UE::AssetRegistry::EDependencyProperty::Build : UE::AssetRegistry::EDependencyProperty::None);
            }
            else
            {
                Required = UE::AssetRegistry::EDependencyProperty::None;
                EnumRemoveFlags(QueryFlags, EDependencyQuery::Game | EDependencyQuery::NotGame | EDependencyQuery::Build | EDependencyQuery::NotBuild);
                RequiredUnions.Add(UE::AssetRegistry::EDependencyProperty::Game | UE::AssetRegistry::EDependencyProperty::Build);
            }
            Required |= (!!(QueryFlags & EDependencyQuery::Hard) ? UE::AssetRegistry::EDependencyProperty::Hard : UE::AssetRegistry::EDependencyProperty::None)
                | (!!(QueryFlags & EDependencyQuery::Direct) ? UE::AssetRegistry::EDependencyProperty::Direct : UE::AssetRegistry::EDependencyProperty::None)
                | (!!(QueryFlags & EDependencyQuery::CookRule) ? UE::AssetRegistry::EDependencyProperty::CookRule : UE::AssetRegistry::EDependencyProperty::None);
 
            Excluded = (!!(QueryFlags & EDependencyQuery::NotHard) ? UE::AssetRegistry::EDependencyProperty::Hard : UE::AssetRegistry::EDependencyProperty::None)
                | (!!(QueryFlags & EDependencyQuery::NotGame) ? UE::AssetRegistry::EDependencyProperty::Game : UE::AssetRegistry::EDependencyProperty::None)
                | (!!(QueryFlags & EDependencyQuery::NotBuild) ? UE::AssetRegistry::EDependencyProperty::Build : UE::AssetRegistry::EDependencyProperty::None)
                | (!!(QueryFlags & EDependencyQuery::NotDirect) ? UE::AssetRegistry::EDependencyProperty::Direct : UE::AssetRegistry::EDependencyProperty::None)
                | (!!(QueryFlags & EDependencyQuery::NotCookRule) ? UE::AssetRegistry::EDependencyProperty::CookRule : UE::AssetRegistry::EDependencyProperty::None);
        }
    };
 
    struct FWritePackageDataArgs
    {
        // Required inputs, must be initialized and non-null
        FStructuredArchiveRecord* ParentRecord = nullptr;
        const UPackage* Package = nullptr;
        FLinkerSave* Linker = nullptr;
        const TSet<TObjectPtr<UObject>>* ImportsUsedInGame = nullptr;
        const TSet<FName>* SoftPackagesUsedInGame = nullptr;
        const TArray<FName>* PackageBuildDependencies = nullptr;
        bool bProceduralSave = false;
 
        // Optional inputs that may be null
        FArchiveCookContext* CookContext = nullptr;
 
        // Optional outputs that may be null
        TArray<FAssetData>* OutAssetDatas = nullptr;
    };
    enum class EExtraDependencyFlags : uint32
    {
        None                    = 0,
        Build                   = 0x1,
        PropagateManage         = 0x2,
    };
    ENUM_CLASS_FLAGS(EExtraDependencyFlags);
 
    COREUOBJECT_API void WritePackageData(FWritePackageDataArgs& Args);
    UE_DEPRECATED(5.5, "Use version that takes FWritePackageDataArgs");
    COREUOBJECT_API void WritePackageData(FStructuredArchiveRecord& ParentRecord, FArchiveCookContext* CookContext,
        const UPackage* Package, FLinkerSave* Linker, const TSet<TObjectPtr<UObject>>& ImportsUsedInGame,
        const TSet<FName>& SoftPackagesUsedInGame, TArray<FAssetData>* OutAssetDatas, bool bProceduralSave);
    UE_DEPRECATED(5.4, "Use version that takes FWritePackageDataArgs");
    COREUOBJECT_API void WritePackageData(FStructuredArchiveRecord& ParentRecord, bool bIsCooking, const UPackage* Package,
        FLinkerSave* Linker, const TSet<TObjectPtr<UObject>>& ImportsUsedInGame, const TSet<FName>& SoftPackagesUsedInGame,
        const ITargetPlatform* TargetPlatform, TArray<FAssetData>* OutAssetDatas);
 
    namespace Private
    {
        class IAssetRegistrySingleton
        {
        public:
            static IAssetRegistry* Get()
            {
                return Singleton;
            }
        private:
            static COREUOBJECT_API IAssetRegistry* Singleton;
            friend class ::UAssetRegistryImpl;
        };
    }
 
    class FFiltering
    {
    public:
        static COREUOBJECT_API bool ShouldSkipAsset(const FTopLevelAssetPath& AssetClass, uint32 PackageFlags);
 
        static COREUOBJECT_API bool ShouldSkipAsset(const UObject* InAsset);
 
        static COREUOBJECT_API void MarkDirty();
 
#if WITH_ENGINE && WITH_EDITOR
        static COREUOBJECT_API void SetSkipClasses(const TSet<FTopLevelAssetPath>& InSkipUncookedClasses, const TSet<FTopLevelAssetPath>& InSkipCookedClasses);
 
        static COREUOBJECT_API void InitializeShouldSkipAsset();
#endif
    };
 
#if WITH_ENGINE && WITH_EDITOR
namespace Utils
{
    COREUOBJECT_API bool ShouldSkipAsset(const FTopLevelAssetPath& AssetClass, uint32 PackageFlags,
        const TSet<FTopLevelAssetPath>& InSkipUncookedClasses, const TSet<FTopLevelAssetPath>& InSkipCookedClasses);
    COREUOBJECT_API bool ShouldSkipAsset(const UObject* InAsset,
        const TSet<FTopLevelAssetPath>& InSkipUncookedClasses, const TSet<FTopLevelAssetPath>& InSkipCookedClasses);
    COREUOBJECT_API void PopulateSkipClasses(TSet<FTopLevelAssetPath>& OutSkipUncookedClasses, TSet<FTopLevelAssetPath>& OutSkipCookedClasses);
}
#endif
 
    COREUOBJECT_API FName GetScriptPackageNameCoreUObject();
    COREUOBJECT_API FName GetScriptPackageNameEngine();
    COREUOBJECT_API FName GetScriptPackageNameBlueprintGraph();
    COREUOBJECT_API FName GetScriptPackageNameUnrealEd();
    COREUOBJECT_API FName GetClassNameObject();
    COREUOBJECT_API FName GetClassNameObjectRedirector();
    COREUOBJECT_API FName GetClassNameBlueprintCore();
    COREUOBJECT_API FName GetClassNameBlueprint();
    COREUOBJECT_API FName GetClassNameBlueprintGeneratedClass();
    COREUOBJECT_API FTopLevelAssetPath GetClassPathObject();
    COREUOBJECT_API FTopLevelAssetPath GetClassPathObjectRedirector();
    COREUOBJECT_API FTopLevelAssetPath GetClassPathBlueprintCore();
    COREUOBJECT_API FTopLevelAssetPath GetClassPathBlueprint();
    COREUOBJECT_API FTopLevelAssetPath GetClassPathBlueprintGeneratedClass();
 
}
 
// Enums used in public Engine headers
namespace EAssetSetManagerResult
{
    enum Type
    {
        DoNotSet,           // Do not set manager
        SetButDoNotRecurse, // Set but do not recurse
        SetAndRecurse       // Set and recurse into reference
    };
}
 
namespace EAssetSetManagerFlags
{
    enum Type
    {
        IsDirectSet = 1,                // This attempt is a direct set instead of a recursive set
        TargetHasExistingManager = 2,   // Target already has a manager from previous run
        TargetHasDirectManager = 4,     // Target has another direct manager that will be set in this run
    };
}
 
class IAssetRegistryInterface
{
public:
    static COREUOBJECT_API IAssetRegistryInterface* GetPtr();
 
    virtual void GetDependencies(FName InPackageName, TArray<FName>& OutDependencies, UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::Package, const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) = 0;
 
    virtual UE::AssetRegistry::EExists TryGetAssetByObjectPath(const FSoftObjectPath& ObjectPath, struct FAssetData& OutAssetData) const = 0;
 
    virtual UE::AssetRegistry::EExists TryGetAssetPackageData(FName PackageName, class FAssetPackageData& OutPackageData) const = 0;
 
    virtual UE::AssetRegistry::EExists TryGetAssetPackageData(FName PackageName, class FAssetPackageData& OutPackageData, FName& OutCorrectCasePackageName) const = 0;
 
    virtual bool EnumerateAssets(const FARFilter& Filter, TFunctionRef<bool(const FAssetData&)> Callback,
        UE::AssetRegistry::EEnumerateAssetsFlags InEnumerateFlags = UE::AssetRegistry::EEnumerateAssetsFlags::None) const = 0;
 
    virtual bool RegisterOnAssetsAddedDelegate(const TFunction<void(TConstArrayView<FAssetData>)>& Function, FDelegateHandle& OutHandle) = 0;
 
    virtual bool UnregisterOnAssetsAddedDelegate(const FDelegateHandle& Handle) = 0;
 
    virtual bool RegisterOnAssetsRemovedDelegate(const TFunction<void(TConstArrayView<FAssetData>)>& Function, FDelegateHandle& OutHandle) = 0;
 
    virtual bool UnregisterOnAssetsRemovedDelegate(const FDelegateHandle& Handle) = 0;
 
protected:
 
    static COREUOBJECT_API IAssetRegistryInterface* Default;
    friend class UAssetRegistryImpl;
};