AssetManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "AssetManagerTypes.h"
#include "Misc/AssetRegistryInterface.h"
#include "StreamableManager.h"
#include "AssetRegistry/AssetBundleData.h"
#include "AssetRegistry/AssetRegistryModule.h"
#include "GenericPlatform/GenericPlatformChunkInstall.h"
#include "ContentEncryptionConfig.h"
#include "Misc/SourceLocation.h"
#include "Misc/SourceLocationUtils.h"
 
#include "AssetManager.generated.h"
 
DECLARE_LOG_CATEGORY_EXTERN(LogAssetManager, Log, All);
 
class IAssetRegistry;
class ITargetPlatform;
class FAssetManagerEditorModule;
class FTimerManager;
class UAssetManagerSettings;
namespace UE::AssetRegistry { struct FShouldSetManagerContext; }
namespace UE::Cook { class ICookInfo; }
struct FCompiledAssetManagerSearchRules;
struct FPrimaryAssetTypeData;
struct FPrimaryAssetData;
struct FPrimaryAssetRulesCustomOverride;
 
DECLARE_DELEGATE_TwoParams(FAssetManagerAcquireResourceDelegateEx, bool /* bSuccess */, const TArray<int32>& /* MissingChunks */);
 
DECLARE_DELEGATE_OneParam(FAssetManagerAcquireResourceDelegate, bool /* bSuccess */);
 
DECLARE_MULTICAST_DELEGATE_OneParam(FOnAddedAssetSearchRoot, const FString&);
 
struct FAssetManagerDownloadParams
{
    FStreamableDownloadPriority Priority = UE::StreamableManager::Private::DownloadDefaultPriority;
    bool bInstallSoftReferences = false;
 
    bool operator==(const FAssetManagerDownloadParams& Right) const = default;
};
 
struct FAssetManagerLoadParams
{
    FStreamableDelegateWithHandle OnComplete;
    FStreamableDelegateWithHandle OnCancel;
    FStreamableUpdateDelegate OnUpdate;
    TAsyncLoadPriority Priority = UE::StreamableManager::Private::DefaultAsyncLoadPriority;
    TOptional<FAssetManagerDownloadParams> DownloadParams;
};
 
enum class EUpdateManagementDatabaseFlags : uint32
{
    None = 0,                           // No flags
    BuildChunkMap = (1 << 0),           // if the CachedChunkMap should be built or not.
    ForceRefresh = (1 << 1),            // When set the database will be forcibly refreshed.
};
ENUM_CLASS_FLAGS(EUpdateManagementDatabaseFlags);
 
UCLASS(MinimalAPI)
class UAssetManager : public UObject
{
    GENERATED_BODY()
 
public:
    ENGINE_API UAssetManager();
 
    UE_DEPRECATED(5.3, "AssetManager is now always constructed during UEngine::InitializeObjectReferences. Call IsInitialized instead if you need to check whether it has not yet been initialized.")
    static ENGINE_API bool IsValid();
    static ENGINE_API bool IsInitialized();
 
    static ENGINE_API UAssetManager& Get();
 
    UE_DEPRECATED(5.3, "AssetManager is now always constructed during UEngine::InitializeObjectReferences. Call GetIfInitialized instead if you need to check whether it has not yet been initialized.")
    static ENGINE_API UAssetManager* GetIfValid();
    static ENGINE_API UAssetManager* GetIfInitialized();
 
    static FStreamableManager& GetStreamableManager() { return Get().StreamableManager; }
 
    static ENGINE_API const FPrimaryAssetType MapType;
 
    static ENGINE_API const FPrimaryAssetType PrimaryAssetLabelType;
 
    static ENGINE_API const FPrimaryAssetType PackageChunkType;
 
    static ENGINE_API const FPrimaryAssetType SuppressionType;
 
    static ENGINE_API const FString AssetSearchRootsVirtualPath;
 
    static ENGINE_API const FString DynamicSearchRootsVirtualPath;
 
    static ENGINE_API FName GetEncryptionKeyAssetTagName();
 
    static ENGINE_API FPrimaryAssetId CreatePrimaryAssetIdFromChunkId(int32 ChunkId);
 
    static ENGINE_API int32 ExtractChunkIdFromPrimaryAssetId(const FPrimaryAssetId& PrimaryAssetId);
 
    // BUILDING ASSET DIRECTORY
 
    ENGINE_API virtual int32 ScanPathsForPrimaryAssets(FPrimaryAssetType PrimaryAssetType, const TArray<FString>& Paths, UClass* BaseClass, bool bHasBlueprintClasses, bool bIsEditorOnly = false, bool bForceSynchronousScan = true);
 
    ENGINE_API virtual int32 ScanPathForPrimaryAssets(FPrimaryAssetType PrimaryAssetType, const FString& Path, UClass* BaseClass, bool bHasBlueprintClasses, bool bIsEditorOnly = false, bool bForceSynchronousScan = true);
 
    ENGINE_API void PushBulkScanning();
    ENGINE_API void PopBulkScanning();
 
    ENGINE_API virtual void RemoveScanPathsForPrimaryAssets(FPrimaryAssetType PrimaryAssetType, const TArray<FString>& Paths, UClass* BaseClass, bool bHasBlueprintClasses, bool bIsEditorOnly = false);
 
    ENGINE_API virtual void RemovePrimaryAssetType(FPrimaryAssetType PrimaryAssetType);
 
protected:
    ENGINE_API virtual void StartBulkScanning();
    ENGINE_API virtual void StopBulkScanning();
    bool IsBulkScanning() const { return NumBulkScanRequests > 0 ; }
 
public:
    ENGINE_API virtual bool AddDynamicAsset(const FPrimaryAssetId& PrimaryAssetId, const FSoftObjectPath& AssetPath, const FAssetBundleData& BundleData);
 
    ENGINE_API virtual void RecursivelyExpandBundleData(FAssetBundleData& BundleData) const;
 
    static ENGINE_API void CallOrRegister_OnCompletedInitialScan(FSimpleMulticastDelegate::FDelegate&& Delegate);
 
    static ENGINE_API void CallOrRegister_OnAssetManagerCreated(FSimpleMulticastDelegate::FDelegate&& Delegate);
 
    ENGINE_API virtual bool HasInitialScanCompleted() const;
 
    ENGINE_API FDelegateHandle Register_OnAddedAssetSearchRoot(FOnAddedAssetSearchRoot::FDelegate&& Delegate);
 
    ENGINE_API void Unregister_OnAddedAssetSearchRoot(FDelegateHandle DelegateHandle);
 
    ENGINE_API virtual bool ExpandVirtualPaths(TArray<FString>& InOutPaths) const;
 
    ENGINE_API virtual void AddAssetSearchRoot(const FString& NewRootPath);
 
    ENGINE_API const TArray<FString>& GetAssetSearchRoots(bool bIncludeDefaultRoots = true) const;
 
 
    // ACCESSING ASSET DIRECTORY
 
    ENGINE_API virtual bool GetPrimaryAssetData(const FPrimaryAssetId& PrimaryAssetId, FAssetData& AssetData) const;
 
    ENGINE_API virtual bool GetPrimaryAssetDataList(FPrimaryAssetType PrimaryAssetType, TArray<FAssetData>& AssetDataList) const;
 
    ENGINE_API virtual UObject* GetPrimaryAssetObject(const FPrimaryAssetId& PrimaryAssetId) const;
 
    template<class AssetType> 
    inline AssetType* GetPrimaryAssetObject(const FPrimaryAssetId& PrimaryAssetId) const
    {
        UObject* ObjectReturn = GetPrimaryAssetObject(PrimaryAssetId);
        return Cast<AssetType>(ObjectReturn);
    }
 
    template<class AssetType>
    inline TSubclassOf<AssetType> GetPrimaryAssetObjectClass(const FPrimaryAssetId& PrimaryAssetId) const
    {
        TSubclassOf<AssetType> ReturnClass;
        ReturnClass = Cast<UClass>(GetPrimaryAssetObject(PrimaryAssetId));
        return ReturnClass;
    }
 
    ENGINE_API virtual bool GetPrimaryAssetObjectList(FPrimaryAssetType PrimaryAssetType, TArray<UObject*>& ObjectList) const;
 
    ENGINE_API virtual FSoftObjectPath GetPrimaryAssetPath(const FPrimaryAssetId& PrimaryAssetId) const;
 
    ENGINE_API virtual bool GetPrimaryAssetPathList(FPrimaryAssetType PrimaryAssetType, TArray<FSoftObjectPath>& AssetPathList) const;
 
    ENGINE_API virtual FPrimaryAssetId GetPrimaryAssetIdForObject(UObject* Object) const;
 
    ENGINE_API virtual FPrimaryAssetId GetPrimaryAssetIdForPath(const FSoftObjectPath& ObjectPath) const;
 
    ENGINE_API virtual FPrimaryAssetId GetPrimaryAssetIdForPackage(FName PackagePath) const;
 
    ENGINE_API virtual FPrimaryAssetId GetPrimaryAssetIdForData(const FAssetData& AssetData) const;
 
    ENGINE_API virtual bool GetPrimaryAssetIdList(FPrimaryAssetType PrimaryAssetType, TArray<FPrimaryAssetId>& PrimaryAssetIdList, EAssetManagerFilter Filter = EAssetManagerFilter::Default) const;
 
    ENGINE_API virtual bool GetPrimaryAssetTypeInfo(FPrimaryAssetType PrimaryAssetType, FPrimaryAssetTypeInfo& AssetTypeInfo) const;
 
    ENGINE_API virtual void GetPrimaryAssetTypeInfoList(TArray<FPrimaryAssetTypeInfo>& AssetTypeInfoList) const;
 
    // ASYNC LOADING PRIMARY ASSETS
 
    virtual TSharedPtr<FStreamableHandle> LoadPrimaryAssets(
        const TArray<FPrimaryAssetId>& AssetsToLoad,
        const TArray<FName>& LoadBundles = TArray<FName>(),
        FStreamableDelegate DelegateToCall = FStreamableDelegate(),
        TAsyncLoadPriority Priority = FStreamableManager::DefaultAsyncLoadPriority,
        UE::FSourceLocation Location = UE::FSourceLocation::Current());
    ENGINE_API virtual TSharedPtr<FStreamableHandle> LoadPrimaryAssets(
        const TArray<FPrimaryAssetId>& AssetsToLoad,
        const TArray<FName>& LoadBundles,
        FAssetManagerLoadParams&& LoadParams,
        UE::FSourceLocation Location = UE::FSourceLocation::Current());
 
    virtual TSharedPtr<FStreamableHandle> LoadPrimaryAsset(
        const FPrimaryAssetId& AssetToLoad,
        const TArray<FName>& LoadBundles = TArray<FName>(),
        FStreamableDelegate DelegateToCall = FStreamableDelegate(),
        TAsyncLoadPriority Priority = FStreamableManager::DefaultAsyncLoadPriority,
        UE::FSourceLocation Location = UE::FSourceLocation::Current());
    ENGINE_API virtual TSharedPtr<FStreamableHandle> LoadPrimaryAsset(
        const FPrimaryAssetId& AssetToLoad,
        const TArray<FName>& LoadBundles,
        FAssetManagerLoadParams&& LoadParams,
        UE::FSourceLocation Location = UE::FSourceLocation::Current());
 
    virtual TSharedPtr<FStreamableHandle> LoadPrimaryAssetsWithType(
        FPrimaryAssetType PrimaryAssetType,
        const TArray<FName>& LoadBundles = TArray<FName>(),
        FStreamableDelegate DelegateToCall = FStreamableDelegate(),
        TAsyncLoadPriority Priority = FStreamableManager::DefaultAsyncLoadPriority,
        UE::FSourceLocation Location = UE::FSourceLocation::Current());
    ENGINE_API virtual TSharedPtr<FStreamableHandle> LoadPrimaryAssetsWithType(
        FPrimaryAssetType PrimaryAssetType,
        const TArray<FName>& LoadBundles,
        FAssetManagerLoadParams&& LoadParams,
        UE::FSourceLocation Location = UE::FSourceLocation::Current());
 
    ENGINE_API virtual int32 UnloadPrimaryAssets(const TArray<FPrimaryAssetId>& AssetsToUnload);
 
    ENGINE_API virtual int32 UnloadPrimaryAsset(const FPrimaryAssetId& AssetToUnload);
 
    ENGINE_API virtual int32 UnloadPrimaryAssetsWithType(FPrimaryAssetType PrimaryAssetType);
 
    virtual TSharedPtr<FStreamableHandle> ChangeBundleStateForPrimaryAssets(
        const TArray<FPrimaryAssetId>& AssetsToChange,
        const TArray<FName>& AddBundles,
        const TArray<FName>& RemoveBundles,
        bool bRemoveAllBundles = false,
        FStreamableDelegate DelegateToCall = FStreamableDelegate(),
        TAsyncLoadPriority Priority = FStreamableManager::DefaultAsyncLoadPriority,
        UE::FSourceLocation Location = UE::FSourceLocation::Current());
    ENGINE_API virtual TSharedPtr<FStreamableHandle> ChangeBundleStateForPrimaryAssets(
        const TArray<FPrimaryAssetId>& AssetsToChange,
        const TArray<FName>& AddBundles,
        const TArray<FName>& RemoveBundles,
        bool bRemoveAllBundles,
        FAssetManagerLoadParams&& LoadParams,
        UE::FSourceLocation Location = UE::FSourceLocation::Current());
 
    virtual TSharedPtr<FStreamableHandle> ChangeBundleStateForMatchingPrimaryAssets(
        const TArray<FName>& NewBundles,
        const TArray<FName>& OldBundles,
        FStreamableDelegate DelegateToCall = FStreamableDelegate(),
        TAsyncLoadPriority Priority = FStreamableManager::DefaultAsyncLoadPriority,
        UE::FSourceLocation Location = UE::FSourceLocation::Current());
    ENGINE_API virtual TSharedPtr<FStreamableHandle> ChangeBundleStateForMatchingPrimaryAssets(
        const TArray<FName>& NewBundles,
        const TArray<FName>& OldBundles,
        FAssetManagerLoadParams&& LoadParams,
        UE::FSourceLocation Location = UE::FSourceLocation::Current());
 
    ENGINE_API TSharedPtr<FStreamableHandle> GetPrimaryAssetHandle(const FPrimaryAssetId& PrimaryAssetId, bool bForceCurrent = false, TArray<FName>* Bundles = nullptr) const ;
 
    ENGINE_API bool GetPrimaryAssetsWithBundleState(TArray<FPrimaryAssetId>& PrimaryAssetList, const TArray<FPrimaryAssetType>& ValidTypes, const TArray<FName>& RequiredBundles, const TArray<FName>& ExcludedBundles = TArray<FName>(), bool bForceCurrent = false) const;
 
    ENGINE_API void GetPrimaryAssetBundleStateMap(TMap<FPrimaryAssetId, TArray<FName>>& BundleStateMap, bool bForceCurrent = false) const;
 
    ENGINE_API bool GetPrimaryAssetLoadSet(TSet<FSoftObjectPath>& OutAssetLoadSet, const FPrimaryAssetId& PrimaryAssetId, const TArray<FName>& LoadBundles, bool bLoadRecursive) const;
 
    ENGINE_API bool GetPrimaryAssetLoadList(TArray<FSoftObjectPath>& OutAssetLoadList, const FPrimaryAssetId& PrimaryAssetId, const TArray<FName>& LoadBundles, bool bLoadRecursive, bool bEnsureUniqueness = true) const;
 
    virtual TSharedPtr<FStreamableHandle> PreloadPrimaryAssets(
        const TArray<FPrimaryAssetId>& AssetsToLoad,
        const TArray<FName>& LoadBundles,
        bool bLoadRecursive,
        FStreamableDelegate DelegateToCall = FStreamableDelegate(),
        TAsyncLoadPriority Priority = FStreamableManager::DefaultAsyncLoadPriority,
        UE::FSourceLocation Location = UE::FSourceLocation::Current());
    ENGINE_API virtual TSharedPtr<FStreamableHandle> PreloadPrimaryAssets(
        const TArray<FPrimaryAssetId>& AssetsToLoad,
        const TArray<FName>& LoadBundles,
        bool bLoadRecursive,
        FAssetManagerLoadParams&& LoadParams,
        UE::FSourceLocation Location = UE::FSourceLocation::Current());
 
    ENGINE_API virtual TSharedPtr<FStreamableHandle> PredownloadPrimaryAssets(
        const TArray<FPrimaryAssetId>& AssetsToLoad,
        const TArray<FName>& LoadBundles,
        bool bLoadRecursive,
        FAssetManagerLoadParams&& LoadParams,
        UE::FSourceLocation Location = UE::FSourceLocation::Current());
 
    TSharedPtr<FStreamableHandle> LoadAssetList(
        const TArray<FSoftObjectPath>& AssetList,
        FStreamableDelegate DelegateToCall = FStreamableDelegate(),
        TAsyncLoadPriority Priority = FStreamableManager::DefaultAsyncLoadPriority,
        FString&& DebugName = FString(TEXT("LoadAssetList")),
        UE::FSourceLocation&& Location = UE::FSourceLocation::Current());
    TSharedPtr<FStreamableHandle> LoadAssetList(
        TArray<FSoftObjectPath>&& AssetList,
        FStreamableDelegate DelegateToCall = FStreamableDelegate(),
        TAsyncLoadPriority Priority = FStreamableManager::DefaultAsyncLoadPriority,
        FString&& DebugName = FString(TEXT("LoadAssetList")),
        UE::FSourceLocation&& Location = UE::FSourceLocation::Current());
    TSharedPtr<FStreamableHandle> LoadAssetList(
        const TArray<FSoftObjectPath>& AssetList,
        FAssetManagerLoadParams&& LoadParams,
        FString&& DebugName = FString(TEXT("LoadAssetList")),
        UE::FSourceLocation&& Location = UE::FSourceLocation::Current());
 
    ENGINE_API virtual TSharedPtr<FStreamableHandle> LoadAssetList(
        TArray<FSoftObjectPath>&& AssetList,
        FAssetManagerLoadParams&& LoadParams,
        FString&& DebugName = FString(TEXT("LoadAssetList")),
        UE::FSourceLocation&& Location = UE::FSourceLocation::Current());
 
    TSharedPtr<FStreamableHandle> DownloadAssetList(
        const TArray<FSoftObjectPath>& AssetList,
        FAssetManagerLoadParams&& LoadParams,
        FString&& DebugName = FString(TEXT("DownloadAssetList")),
        UE::FSourceLocation&& Location = UE::FSourceLocation::Current());
    ENGINE_API TSharedPtr<FStreamableHandle> DownloadAssetList(
        TArray<FSoftObjectPath>&& AssetList,
        FAssetManagerLoadParams&& LoadParams,
        FString&& DebugName = FString(TEXT("DownloadAssetList")),
        UE::FSourceLocation&& Location = UE::FSourceLocation::Current());
 
    ENGINE_API virtual FAssetBundleEntry GetAssetBundleEntry(const FPrimaryAssetId& BundleScope, FName BundleName) const;
 
    ENGINE_API virtual bool GetAssetBundleEntries(const FPrimaryAssetId& BundleScope, TArray<FAssetBundleEntry>& OutEntries) const;
 
    ENGINE_API virtual bool FindMissingChunkList(const TArray<FSoftObjectPath>& AssetList, TArray<int32>& OutMissingChunkList, TArray<int32>& OutErrorChunkList) const;
 
    ENGINE_API virtual void AcquireResourcesForAssetList(const TArray<FSoftObjectPath>& AssetList, FAssetManagerAcquireResourceDelegateEx CompleteDelegate, EChunkPriority::Type Priority = EChunkPriority::Immediate);
    ENGINE_API virtual void AcquireResourcesForAssetList(const TArray<FSoftObjectPath>& AssetList, FAssetManagerAcquireResourceDelegate CompleteDelegate, EChunkPriority::Type Priority = EChunkPriority::Immediate);
 
    ENGINE_API virtual void AcquireResourcesForPrimaryAssetList(const TArray<FPrimaryAssetId>& PrimaryAssetList, FAssetManagerAcquireResourceDelegate CompleteDelegate, EChunkPriority::Type Priority = EChunkPriority::Immediate);
    
    ENGINE_API virtual bool GetResourceAcquireProgress(int32& OutAcquiredCount, int32& OutRequestedCount) const;
 
    // FUNCTIONS FOR MANAGEMENT/COOK RULES
 
    ENGINE_API virtual void SetPrimaryAssetTypeRules(FPrimaryAssetType PrimaryAssetType, const FPrimaryAssetRules& Rules);
 
    ENGINE_API virtual void SetPrimaryAssetRules(FPrimaryAssetId PrimaryAssetId, const FPrimaryAssetRules& Rules);
    ENGINE_API virtual void SetPrimaryAssetRulesExplicitly(FPrimaryAssetId PrimaryAssetId, const FPrimaryAssetRulesExplicitOverride& ExplicitRules);
 
    ENGINE_API virtual FPrimaryAssetRules GetPrimaryAssetRules(FPrimaryAssetId PrimaryAssetId) const;
 
    ENGINE_API virtual bool GetManagedPackageList(FPrimaryAssetId PrimaryAssetId, TArray<FName>& AssetPackageList) const;
 
    ENGINE_API virtual bool GetPackageCookRuleManagers(FName PackageName, bool bRecurseToParents,
        TMap<FPrimaryAssetId, UE::AssetRegistry::EDependencyProperty>& Managers) const;
 
    ENGINE_API virtual bool GetPackageManagers(FName PackageName, bool bRecurseToParents,
        TMap<FPrimaryAssetId, UE::AssetRegistry::EDependencyProperty>& Managers) const;
 
    ENGINE_API virtual bool GetPackageManagers(FName PackageName, bool bRecurseToParents, TSet<FPrimaryAssetId>& ManagerSet) const;
 
protected:
    ENGINE_API bool GetPackageManagersInternal(FName PackageName,
        bool bUseCookRuleReferences, bool bRecurseToParents,
        TMap<FPrimaryAssetId, UE::AssetRegistry::EDependencyProperty>& Managers) const;
public:
 
    // GENERAL ASSET UTILITY FUNCTIONS
 
    ENGINE_API virtual FPrimaryAssetId ExtractPrimaryAssetIdFromData(const FAssetData& AssetData, FPrimaryAssetType SuggestedType = FPrimaryAssetType()) const;
 
    ENGINE_API virtual bool GetAssetDataForPath(const FSoftObjectPath& ObjectPath, FAssetData& AssetData) const;
 
    ENGINE_API virtual bool IsAssetDataBlueprintOfClassSet(const FAssetData& AssetData, const TSet<FTopLevelAssetPath>& ClassNameSet) const;
 
    ENGINE_API virtual FSoftObjectPath GetAssetPathForData(const FAssetData& AssetData) const;
 
    ENGINE_API virtual FPrimaryAssetId GetRedirectedPrimaryAssetId(const FPrimaryAssetId& OldId) const;
 
    ENGINE_API virtual void GetPreviousPrimaryAssetIds(const FPrimaryAssetId& NewId, TArray<FPrimaryAssetId>& OutOldIds) const;
 
    ENGINE_API virtual FPrimaryAssetId DeterminePrimaryAssetIdForObject(const UObject* Object) const;
 
    ENGINE_API virtual FSoftObjectPath GetRedirectedAssetPath(const FSoftObjectPath& OldPath) const;
 
    ENGINE_API virtual void ExtractSoftObjectPaths(const UStruct* Struct, const void* StructValue, TArray<FSoftObjectPath>& FoundAssetReferences, const TArray<FName>& PropertiesToSkip = TArray<FName>()) const;
 
    ENGINE_API virtual int32 SearchAssetRegistryPaths(TArray<FAssetData>& OutAssetDataList, const FAssetManagerSearchRules& Rules) const;
 
    ENGINE_API virtual bool DoesAssetMatchSearchRules(const FAssetData& AssetData, const FAssetManagerSearchRules& Rules) const;
 
    ENGINE_API virtual bool ShouldScanPrimaryAssetType(FPrimaryAssetTypeInfo& TypeInfo) const;
 
    ENGINE_API virtual bool RegisterSpecificPrimaryAsset(const FPrimaryAssetId& PrimaryAssetId, const FAssetData& NewAssetData);
 
    ENGINE_API virtual void ScanPathsSynchronous(const TArray<FString>& PathsToScan) const;
 
    ENGINE_API virtual bool OnAssetRegistryAvailableAfterInitialization(FName InName, FAssetRegistryState& OutNewState);
 
    static ENGINE_API bool GetContentRootPathFromPackageName(const FString& PackageName, FString& OutContentRootPath);
 
    static ENGINE_API void NormalizePackagePath(FString& InOutPath, bool bIncludeFinalSlash);
    static ENGINE_API FString GetNormalizedPackagePath(const FString& InPath, bool bIncludeFinalSlash);
 
    static ENGINE_API void DumpAssetTypeSummary();
 
    static ENGINE_API void DumpLoadedAssetState();
 
    static ENGINE_API void DumpBundlesForAsset(const TArray<FString>& Args);
 
    static ENGINE_API void DumpAssetRegistryInfo();
 
    static ENGINE_API void DumpReferencersForPackage(const TArray< FString >& PackageNames);
 
    static ENGINE_API void GetAllReferencersForPackage(TSet<FAssetData>& OutFoundAssets, const TArray<FName>& InPackageNames, int32 MaxDepth);
 
    ENGINE_API virtual void StartInitialLoading();
 
    ENGINE_API virtual void FinishInitialLoading();
 
    ENGINE_API IAssetRegistry& GetAssetRegistry() const;
 
    ENGINE_API const UAssetManagerSettings& GetSettings() const;
 
    ENGINE_API FTimerManager* GetTimerManager() const;
 
    // Overrides
    ENGINE_API virtual void BeginDestroy() override;
 
    ENGINE_API virtual void PostInitProperties() override;
 
    ENGINE_API virtual void GetCachedPrimaryAssetEncryptionKeyGuid(FPrimaryAssetId InPrimaryAssetId, FGuid& OutGuid);
 
    ENGINE_API virtual void LoadRedirectorMaps();
 
    ENGINE_API virtual void RefreshPrimaryAssetDirectory(bool bForceRefresh = false);
 
    ENGINE_API virtual void InvalidatePrimaryAssetDirectory();
 
    ENGINE_API virtual void WarnAboutInvalidPrimaryAsset(const FPrimaryAssetId& PrimaryAssetId, const FString& Message) const;
 
    ENGINE_API virtual bool WriteCustomReport(FString FileName, TArray<FString>& FileLines) const;
 
    ENGINE_API virtual void ApplyCustomPrimaryAssetRulesOverride(const FPrimaryAssetRulesCustomOverride& CustomOverride);
 
#if WITH_EDITOR
    // EDITOR ONLY FUNCTIONALITY
 
    ENGINE_API virtual void ModifyCook(TConstArrayView<const ITargetPlatform*> TargetPlatforms, TArray<FName>& PackagesToCook,
        TArray<FName>& PackagesToNeverCook);
 
    ENGINE_API virtual void ModifyDLCCook(const FString& DLCName, TConstArrayView<const ITargetPlatform*> TargetPlatforms,
        TArray<FName>& PackagesToCook, TArray<FName>& PackagesToNeverCook);
 
    virtual void ModifyDLCBasePackages(const ITargetPlatform* TargetPlatform, TArray<FName>& PlatformBasedPackages, TSet<FName>& PackagesToClearResults) const {};
 
    ENGINE_API virtual void ModifyCookReferences(FName PackageName, TArray<FName>& PackagesToCook);
 
    ENGINE_API virtual bool ShouldCookForPlatform(const UPackage* Package, const ITargetPlatform* TargetPlatform);
 
    ENGINE_API virtual EPrimaryAssetCookRule GetPackageCookRule(FName PackageName) const;
 
    ENGINE_API EPrimaryAssetCookRule CalculateCookRuleUnion(const TMap<FPrimaryAssetId, UE::AssetRegistry::EDependencyProperty>& Managers,
        TOptional<TPair<FPrimaryAssetId, FPrimaryAssetId>>* OutConflictIds) const;
 
    ENGINE_API virtual bool VerifyCanCookPackage(UE::Cook::ICookInfo* CookInfo, FName PackageName, bool bLogError = true) const;
 
    ENGINE_API virtual bool GetPackageChunkIds(FName PackageName, const ITargetPlatform* TargetPlatform, TArrayView<const int32> ExistingChunkList, TArray<int32>& OutChunkList, TArray<int32>* OutOverrideChunkList = nullptr) const;
 
    virtual FGuid GetChunkEncryptionKeyGuid(int32 InChunkId) const { return FGuid(); }
 
    virtual TSet<int32> GetEncryptedChunkIDsForPackage(FName InPackageName) const { return TSet<int32>(); }
 
    virtual FName GetUniqueAssetRegistryName(int32 InChunkIndex) const { return NAME_None; }
 
    virtual int32 GetContentEncryptionGroupChunkID(FName InGroupName) const { return INDEX_NONE; }
 
    ENGINE_API virtual bool GetPrimaryAssetSetChunkIds(const TSet<FPrimaryAssetId>& PrimaryAssetSet, const ITargetPlatform* TargetPlatform,
        TArrayView<const int32> ExistingChunkList, TArray<int32>& OutChunkList) const;
    ENGINE_API virtual bool GetPrimaryAssetSetChunkIds(TConstArrayView<FPrimaryAssetId> PrimaryAssets, const ITargetPlatform* TargetPlatform,
        TArrayView<const int32> ExistingChunkList, TArray<int32>& OutChunkList) const;
 
    ENGINE_API virtual void ReinitializeFromConfig();
 
    UE_DEPRECATED(5.6, "UpdateManagementDatabase as been updated to take InFlags instead.")
    ENGINE_API virtual void UpdateManagementDatabase(bool bForceRefresh);
    ENGINE_API virtual void UpdateManagementDatabase(EUpdateManagementDatabaseFlags InFlags = EUpdateManagementDatabaseFlags::BuildChunkMap);
 
    ENGINE_API const TMap<int32, FAssetManagerChunkInfo>& GetChunkManagementMap() const;
 
    UE_INTERNAL ENGINE_API void UpdateCachedChunkMapAfterCook(const TSet<FName>& AllCookedPackages, const TSet<FName>& StartupPackages);
 
    ENGINE_API virtual void ApplyPrimaryAssetLabels();
 
    ENGINE_API virtual void RefreshAssetData(UObject* ChangedObject);
 
    ENGINE_API virtual void InitializeAssetBundlesFromMetadata(const UStruct* Struct, const void* StructValue, FAssetBundleData& AssetBundle, FName DebugName = NAME_None) const;
 
    virtual void InitializeAssetBundlesFromMetadata(const UObject* Object, FAssetBundleData& AssetBundle) const
    {
        InitializeAssetBundlesFromMetadata(Object->GetClass(), Object, AssetBundle, Object->GetFName());
    }
 
    virtual void PreSaveAssetRegistry(const ITargetPlatform* TargetPlatform, const TSet<FName>& InCookedPackages) {}
 
    virtual void PostSaveAssetRegistry() {}
 
    virtual void GetContentEncryptionConfig(FContentEncryptionConfig& OutContentEncryptionConfig) {}
 
    virtual bool HandleCookCommand(FStringView Token)
    {
        return false;
    }
#endif
 
    virtual void GetPakChunkIdToStringMapping(TMap<int32, FString>& ChunkIdStringOverride) {}
    virtual void GetPakChunkIdToStringMapping(const FString& PlatformName, TMap<int32, FString>& ChunkIdStringOverride) {}
 
    ENGINE_API void GetPakStringToChunkIdMapping(TMap<FString, int32>& StringOverrideToChunkId);
 
protected:
    friend FAssetManagerEditorModule;
 
    ENGINE_API virtual void GetAssetDataForPathInternal(IAssetRegistry& AssetRegistry, const FString& AssetPath, OUT FAssetData& OutAssetData) const;
 
    ENGINE_API virtual bool TryUpdateCachedAssetData(const FPrimaryAssetId& PrimaryAssetId, const FAssetData& NewAssetData, bool bAllowDuplicates);
 
    ENGINE_API FPrimaryAssetData* GetNameData(const FPrimaryAssetId& PrimaryAssetId, bool bCheckRedirector = true);
    ENGINE_API const FPrimaryAssetData* GetNameData(const FPrimaryAssetId& PrimaryAssetId, bool bCheckRedirector = true) const;
 
    ENGINE_API virtual void OnObjectReferenceListInvalidated();
 
    ENGINE_API void CallPreGarbageCollect();
    ENGINE_API virtual void PreGarbageCollect();
 
    UE_DEPRECATED(5.6, "Use NotifyOnAssetStateChangeCompleted instead")
    virtual void OnAssetStateChangeCompleted(FPrimaryAssetId PrimaryAssetId, TSharedPtr<FStreamableHandle> BoundHandle, FStreamableDelegate WrappedDelegate) { checkf(false, TEXT("Deprecated")); }
 
    virtual void NotifyOnAssetStateChangeCompleted(const FPrimaryAssetId& PrimaryAssetId) {}
 
    ENGINE_API void OnAssetStateChangeCompleted(TSharedPtr<FStreamableHandle> BoundHandle, FPrimaryAssetId PrimaryAssetId);
 
    ENGINE_API virtual void ScanPrimaryAssetTypesFromConfig();
 
    ENGINE_API virtual void ScanPrimaryAssetRulesFromConfig();
 
    ENGINE_API virtual bool DoesPrimaryAssetMatchCustomOverride(FPrimaryAssetId PrimaryAssetId, const FPrimaryAssetRulesCustomOverride& CustomOverride) const;
 
    ENGINE_API virtual void PostInitialAssetScan();
 
    ENGINE_API virtual bool IsPathExcludedFromScan(const FString& Path) const;
 
    ENGINE_API bool IsScanningFromInitialConfig() const;
 
    ENGINE_API virtual bool ShouldIncludeInAssetSearch(const FAssetData& AssetData, const FAssetManagerSearchRules& SearchRules) const;
 
    ENGINE_API virtual void AcquireChunkList(const TArray<int32>& ChunkList, FAssetManagerAcquireResourceDelegate CompleteDelegate, EChunkPriority::Type Priority, TSharedPtr<FStreamableHandle> StalledHandle);
 
    ENGINE_API virtual void OnChunkDownloaded(uint32 ChunkId, bool bSuccess);
 
    UE_DEPRECATED(5.6, "Function was renamed to LoadAssetList that accepts FAssetManagerLoadParams struct.")
    virtual TSharedPtr<FStreamableHandle> LoadAssetListInternal(TArray<FSoftObjectPath>&& AssetList, FStreamableDelegateWithHandle&& DelegateToCall, TAsyncLoadPriority Priority, FString&& DebugName)
    {
        checkf(false, TEXT("Deprecated"));
        return nullptr;
    }
 
#if WITH_EDITOR
    ENGINE_API virtual EAssetSetManagerResult::Type ShouldSetManager(UE::AssetRegistry::FShouldSetManagerContext& Context) const;
    UE_DEPRECATED(5.6, "Override the version that takes an FShouldSetManagerContext instead.")
    virtual EAssetSetManagerResult::Type ShouldSetManager(const FAssetIdentifier& Manager, const FAssetIdentifier& Source, const FAssetIdentifier& Target,
        UE::AssetRegistry::EDependencyCategory Category, UE::AssetRegistry::EDependencyProperty Properties, EAssetSetManagerFlags::Type Flags) const
    {
        return EAssetSetManagerResult::DoNotSet;
    }
 
    ENGINE_API virtual void OnAssetRegistryFilesLoaded();
 
    ENGINE_API virtual void OnInMemoryAssetCreated(UObject *Object);
 
    ENGINE_API virtual void OnInMemoryAssetDeleted(UObject *Object);
 
    ENGINE_API virtual void OnObjectPreSave(UObject* Object, FObjectPreSaveContext SaveContext);
 
    ENGINE_API virtual void OnAssetRenamed(const FAssetData& NewData, const FString& OldPath);
 
    ENGINE_API virtual void OnAssetRemoved(const FAssetData& Data);
 
    ENGINE_API virtual void RemovePrimaryAssetId(const FPrimaryAssetId& PrimaryAssetId);
 
    ENGINE_API virtual void GatherPublicAssetsForPackage(FName PackagePath, TArray<FName>& PackagesToCook) const;
 
    ENGINE_API virtual void GatherPublicAssetsForPackage(FName PackagePath, TSet<FSoftObjectPath>& AssetsToCook) const;
 
    ENGINE_API virtual void PreBeginPIE(bool bStartSimulate);
 
    ENGINE_API virtual void EndPIE(bool bStartSimulate);
 
    UE_DEPRECATED(5.6, "BuildChunkMap now takes 2 additional arguments")
    ENGINE_API virtual TMap<int32, FAssetManagerChunkInfo> BuildChunkMap(const TSet<FName>& PackagesToUpdateChunksFor) const;
 
    ENGINE_API virtual TMap<int32, FAssetManagerChunkInfo> BuildChunkMap(const TSet<FName>& PackagesToUpdateChunksFor, const TSet<FName>& StartupPackages, const TSet<FName>& PackageThatWereCooked) const;
 
    TMap<FPrimaryAssetId, TArray<FName>> PrimaryAssetStateBeforePIE;
 
    TMap<int32, FAssetManagerChunkInfo> CachedChunkMap;
#endif // WITH_EDITOR
 
    TMap<FSoftObjectPath, FPrimaryAssetId> AssetPathMap;
 
    TMap<FPrimaryAssetId, FPrimaryAssetRulesExplicitOverride> AssetRuleOverrides;
 
    TMap<FPrimaryAssetId, TArray<FPrimaryAssetId>> ManagementParentMap;
    TMap<FPrimaryAssetId, TArray<FPrimaryAssetId>> CookRuleManagementParentMap;
 
    TMap<FPrimaryAssetId, TSharedPtr<FAssetBundleData, ESPMode::ThreadSafe>> CachedAssetBundles;
 
    mutable TSet<FPrimaryAssetId> WarningInvalidAssets;
 
    mutable TArray<FString> AlreadyScannedDirectories;
 
    TArray<FString> AllAssetSearchRoots;
 
    TArray<FString> AddedAssetSearchRoots;
 
    FStreamableManager StreamableManager;
 
    struct FPendingChunkInstall
    {
        TArray<int32> RequestedChunks;
 
        TArray<int32> PendingChunks;
 
        TSharedPtr<FStreamableHandle> StalledStreamableHandle;
 
        FAssetManagerAcquireResourceDelegate ManualCallback;
    };
 
    TArray<FPendingChunkInstall> PendingChunkInstalls;
 
    TMap<FPrimaryAssetId, FGuid> PrimaryAssetEncryptionKeyCache;
 
    UPROPERTY()
    TArray<TObjectPtr<UObject>> ObjectReferenceList;
 
    UPROPERTY()
    bool bIsGlobalAsyncScanEnvironment;
 
    UPROPERTY()
    bool bShouldGuessTypeAndName;
 
    UPROPERTY()
    bool bShouldUseSynchronousLoad;
 
    UPROPERTY()
    bool bIsLoadingFromPakFiles;
 
    UPROPERTY()
    bool bShouldAcquireMissingChunksOnLoad;
 
    UPROPERTY()
    bool bOnlyCookProductionAssets;
 
    bool bTargetPlatformsAllowDevelopmentObjects;
 
    bool bObjectReferenceListDirty = true;
 
    UPROPERTY()
    int32 NumBulkScanRequests;
 
    UPROPERTY()
    bool bIsPrimaryAssetDirectoryCurrent;
 
    UPROPERTY()
    bool bIsManagementDatabaseCurrent;
 
    UPROPERTY()
    bool bUpdateManagementDatabaseAfterScan;
 
    UPROPERTY()
    bool bIncludeOnlyOnDiskAssets;
 
    UPROPERTY()
    bool bHasCompletedInitialScan;
 
    UPROPERTY()
    int32 NumberOfSpawnedNotifications;
 
    TMap<FName, FName> PrimaryAssetTypeRedirects;
    TMap<FString, FString> PrimaryAssetIdRedirects;
    TMap<FSoftObjectPath, FSoftObjectPath> AssetPathRedirects;
 
    static ENGINE_API FSimpleMulticastDelegate OnCompletedInitialScanDelegate;
 
    static ENGINE_API FSimpleMulticastDelegate OnAssetManagerCreatedDelegate;
 
    FOnAddedAssetSearchRoot OnAddedAssetSearchRootDelegate;
 
    FDelegateHandle ChunkInstallDelegateHandle;
 
private:
    bool bOldTemporaryCachingMode = false;
 
    bool bScanningFromInitialConfig = false;
 
    void InternalAddAssetScanPath(FPrimaryAssetTypeData& TypeData, const FString& AssetScanPath);
 
#if WITH_EDITOR
    ENGINE_API virtual void InitializeAssetBundlesFromMetadata_Recursive(const UStruct* Struct, const void* StructValue, FAssetBundleData& AssetBundle, FName DebugName, TSet<const void*>& AllVisitedStructValues) const;
#endif
 
    TMap<FName, TSharedRef<FPrimaryAssetTypeData>> AssetTypeMap;
 
#if WITH_EDITOR
    TMap<FName, TArray<FTopLevelAssetPath>> AssetBundlePathsForPackage;
#endif
 
    mutable IAssetRegistry* CachedAssetRegistry;
    mutable const UAssetManagerSettings* CachedSettings;
 
    friend FCompiledAssetManagerSearchRules;
};
 
inline TSharedPtr<FStreamableHandle> UAssetManager::LoadPrimaryAssets(const TArray<FPrimaryAssetId>& AssetsToLoad, const TArray<FName>& LoadBundles, FStreamableDelegate DelegateToCall, TAsyncLoadPriority Priority, UE::FSourceLocation Location)
{
    FAssetManagerLoadParams LoadParams;
    LoadParams.OnComplete = UE::StreamableManager::Private::WrapDelegate(DelegateToCall);
    LoadParams.Priority = Priority;
 
    return LoadPrimaryAssets(AssetsToLoad, LoadBundles, MoveTemp(LoadParams), MoveTemp(Location));
}
 
inline TSharedPtr<FStreamableHandle> UAssetManager::LoadPrimaryAsset(const FPrimaryAssetId& AssetToLoad, const TArray<FName>& LoadBundles, FStreamableDelegate DelegateToCall, TAsyncLoadPriority Priority, UE::FSourceLocation Location)
{
    FAssetManagerLoadParams LoadParams;
    LoadParams.OnComplete = UE::StreamableManager::Private::WrapDelegate(DelegateToCall);
    LoadParams.Priority = Priority;
 
    return LoadPrimaryAsset(AssetToLoad, LoadBundles, MoveTemp(LoadParams), MoveTemp(Location));
}
 
inline TSharedPtr<FStreamableHandle> UAssetManager::LoadPrimaryAssetsWithType(FPrimaryAssetType PrimaryAssetType, const TArray<FName>& LoadBundles, FStreamableDelegate DelegateToCall, TAsyncLoadPriority Priority, UE::FSourceLocation Location)
{
    FAssetManagerLoadParams LoadParams;
    LoadParams.OnComplete = UE::StreamableManager::Private::WrapDelegate(DelegateToCall);
    LoadParams.Priority = Priority;
 
    return LoadPrimaryAssetsWithType(PrimaryAssetType, LoadBundles, MoveTemp(LoadParams), MoveTemp(Location));
}
 
inline TSharedPtr<FStreamableHandle> UAssetManager::ChangeBundleStateForPrimaryAssets(const TArray<FPrimaryAssetId>& AssetsToChange, const TArray<FName>& AddBundles, const TArray<FName>& RemoveBundles, bool bRemoveAllBundles, FStreamableDelegate DelegateToCall, TAsyncLoadPriority Priority, UE::FSourceLocation Location)
{
    FAssetManagerLoadParams LoadParams;
    LoadParams.OnComplete = UE::StreamableManager::Private::WrapDelegate(MoveTemp(DelegateToCall));
    LoadParams.Priority = Priority;
 
    return ChangeBundleStateForPrimaryAssets(AssetsToChange, AddBundles, RemoveBundles, bRemoveAllBundles, MoveTemp(LoadParams), MoveTemp(Location));
}
 
inline TSharedPtr<FStreamableHandle> UAssetManager::ChangeBundleStateForMatchingPrimaryAssets(const TArray<FName>& NewBundles, const TArray<FName>& OldBundles, FStreamableDelegate DelegateToCall, TAsyncLoadPriority Priority, UE::FSourceLocation Location)
{
    FAssetManagerLoadParams LoadParams;
    LoadParams.OnComplete = UE::StreamableManager::Private::WrapDelegate(DelegateToCall);
    LoadParams.Priority = Priority;
 
    return ChangeBundleStateForMatchingPrimaryAssets(NewBundles, OldBundles, MoveTemp(LoadParams), MoveTemp(Location));
}
 
inline TSharedPtr<FStreamableHandle> UAssetManager::PreloadPrimaryAssets(const TArray<FPrimaryAssetId>& AssetsToLoad, const TArray<FName>& LoadBundles, bool bLoadRecursive, FStreamableDelegate DelegateToCall, TAsyncLoadPriority Priority, UE::FSourceLocation Location)
{
    FAssetManagerLoadParams LoadParams;
    LoadParams.OnComplete = UE::StreamableManager::Private::WrapDelegate(MoveTemp(DelegateToCall));
    LoadParams.Priority = Priority;
 
    return PreloadPrimaryAssets(AssetsToLoad, LoadBundles, bLoadRecursive, MoveTemp(LoadParams), MoveTemp(Location));
}
 
inline TSharedPtr<FStreamableHandle> UAssetManager::LoadAssetList(
    const TArray<FSoftObjectPath>& AssetList,
    FStreamableDelegate DelegateToCall,
    TAsyncLoadPriority Priority,
    FString&& DebugName,
    UE::FSourceLocation&& Location)
{
    FAssetManagerLoadParams LoadParams;
    LoadParams.OnComplete = UE::StreamableManager::Private::WrapDelegate(MoveTemp(DelegateToCall));
    LoadParams.Priority = Priority;
 
    return LoadAssetList(CopyTemp(AssetList), MoveTemp(LoadParams), MoveTemp(DebugName), MoveTemp(Location));
}
 
inline TSharedPtr<FStreamableHandle> UAssetManager::LoadAssetList(
    TArray<FSoftObjectPath>&& AssetList,
    FStreamableDelegate DelegateToCall,
    TAsyncLoadPriority Priority,
    FString&& DebugName,
    UE::FSourceLocation&& Location)
{
    FAssetManagerLoadParams LoadParams;
    LoadParams.OnComplete = UE::StreamableManager::Private::WrapDelegate(MoveTemp(DelegateToCall));
    LoadParams.Priority = Priority;
 
    return LoadAssetList(MoveTemp(AssetList), MoveTemp(LoadParams), MoveTemp(DebugName), MoveTemp(Location));
}
 
inline TSharedPtr<FStreamableHandle> UAssetManager::LoadAssetList(
    const TArray<FSoftObjectPath>& AssetList,
    FAssetManagerLoadParams&& LoadParams,
    FString&& DebugName,
    UE::FSourceLocation&& Location)
{
    return LoadAssetList(CopyTemp(AssetList), MoveTemp(LoadParams), MoveTemp(DebugName), MoveTemp(Location));
}
 
inline TSharedPtr<FStreamableHandle> UAssetManager::DownloadAssetList(
    const TArray<FSoftObjectPath>& AssetList,
    FAssetManagerLoadParams&& LoadParams,
    FString&& DebugName,
    UE::FSourceLocation&& Location)
{
    return DownloadAssetList(CopyTemp(AssetList), MoveTemp(LoadParams), MoveTemp(DebugName), MoveTemp(Location));
}