UAssetManager

A singleton [UObject](API\Runtime\CoreUObject\UObject\UObject) that is responsible for loading and unloading PrimaryAssets, and maintaining game-specific asset references Games should override this class and change the class reference

API > API/Runtime > API/Runtime/Engine > API/Runtime/Engine/Engine

Inheritance Hierarchy

References

   
Module Engine
Header /Engine/Source/Runtime/Engine/Classes/Engine/AssetManager.h
Include #include "Engine/AssetManager.h"

Syntax

UCLASS (MinimalAPI)  
class UAssetManager : public UObject

Remarks

A singleton UObject that is responsible for loading and unloading PrimaryAssets, and maintaining game-specific asset references Games should override this class and change the class reference

Variables

  Type Name Description
Protected variable TArray< FString > AddedAssetSearchRoots List of dynamic asset search roots added past startup
Protected variable TArray< FString > AllAssetSearchRoots All asset search roots including startup ones
Protected variable TArray< FString > AlreadyScannedDirectories List of directories that have already been synchronously scanned
Protected variable TMap< FSoftObjectPath, FPrimaryAssetId > AssetPathMap Map from object path to Primary Asset Id
Protected variable TMap< FSoftObjectPath, FSoftObjectPath > AssetPathRedirects  
Protected variable TMap< FPrimaryAssetId, FPrimaryAssetRulesExplicitOverride > AssetRuleOverrides Overridden asset management data for specific types
Protected variable UProperty bool bHasCompletedInitialScan True if we have passed the initial asset registry/type scan
Protected variable UProperty bool bIncludeOnlyOnDiskAssets True if only on-disk assets should be searched by the asset registry
Protected variable UProperty bool bIsGlobalAsyncScanEnvironment True if we are running a build that is already scanning assets globally so we can perhaps avoid scanning paths synchronously
Protected variable UProperty bool bIsLoadingFromPakFiles True if we are loading from pak files
Protected variable UProperty bool bIsManagementDatabaseCurrent True if the asset management database is up to date
Protected variable UProperty bool bIsPrimaryAssetDirectoryCurrent True if asset data is current, if false it will need to rescan before PIE
Protected variable bool bObjectReferenceListDirty  
Protected variable UProperty bool bOnlyCookProductionAssets If true, DevelopmentCook assets will error when they are cooked
Protected variable UProperty bool bShouldAcquireMissingChunksOnLoad True if the chunk install interface should be queries before loading assets
Protected variable UProperty bool bShouldGuessTypeAndName True if PrimaryAssetType/Name will be implied for loading assets that don't have it saved on disk.
Protected variable UProperty bool bShouldUseSynchronousLoad True if we should always use synchronous loads, this speeds up cooking
Protected variable bool bTargetPlatformsAllowDevelopmentObjects Suppresses bOnlyCookProductionAssets based on the AllowsDevelopmentObjects() property of the TargetPlatforms being cooked.
Protected variable UProperty bool bUpdateManagementDatabaseAfterScan True if the asset management database should be updated after scan completes
Protected variable TMap< FPrimaryAssetId, TSharedPtr< FAssetBundleData, ESPMode::ThreadSafe > > CachedAssetBundles Cached map of asset bundles, global and per primary asset
Protected variable TMap< int32, FAssetManagerChunkInfo > CachedChunkMap Cached map of chunk ids to lists of assets in that chunk
Protected variable FDelegateHandle ChunkInstallDelegateHandle Delegate bound to chunk install
Protected variable TMap< FPrimaryAssetId, TArray< FPrimaryAssetId > > ManagementParentMap Map from PrimaryAssetId to list of PrimaryAssetIds that are the parent of this one, for determining chunking/cooking
Protected variable UProperty int32 NumberOfSpawnedNotifications Number of notifications seen in this update
Protected variable UProperty int32 NumBulkScanRequests >0 if we are currently in bulk scanning mode
Protected variable UProperty TArray< TObjectPtr< UObject > > ObjectReferenceList List of UObjects that are being kept from being GCd, derived from the asset type map.
Protected variable FOnAddedAssetSearchRoot OnAddedAssetSearchRootDelegate Delegate called when a new asset search root is registered
Protected variable TArray< FPendingChunkInstall > PendingChunkInstalls List of chunk installs that are being waited for
Protected variable TMap< FPrimaryAssetId, FGuid > PrimaryAssetEncryptionKeyCache Cache of encryption keys used by each primary asset
Protected variable TMap< FString, FString > PrimaryAssetIdRedirects  
Protected variable TMap< FPrimaryAssetId, TArray< FName > > PrimaryAssetStateBeforePIE Copy of the asset state before PIE was entered, return to that when PIE completes
Protected variable TMap< FName, FName > PrimaryAssetTypeRedirects Redirector maps loaded out of AssetMigrations.ini
Protected variable FStreamableManager StreamableManager The streamable manager used for all primary asset loading
Protected variable TSet< FPrimaryAssetId > WarningInvalidAssets List of assets we have warned about being missing

Constructors

  Type Name Description
Public function   Constructor

Functions

  Type Name Description
Protected function Virtual void

AcquireChunkList ( const TArray< int32 >& ChunkList,
FAssetManagerAcquireResourceDelegate CompleteDelegate,
EChunkPriority::Type Priority,
TSharedPtr< FStreamableHandle > StalledHandle
)

 Call to start acquiring a list of chunks
Public function Virtual void  
Public function Virtual void Acquires a set of chunks using the platform chunk layer, then calls the passed in callback
Public function Virtual void Acquires a set of chunks using the platform chunk layer, then calls the passed in callback.
Public function Virtual void

AddAssetSearchRoot ( const FString& NewRootPath
)

 Register a new asset search root of the form /AssetRoot, will notify other systems about change
Public function Virtual bool

AddDynamicAsset ( const FPrimaryAssetId& PrimaryAssetId,
const FSoftObjectPath& AssetPath,
const FAssetBundleData& BundleData
)

 Adds or updates a Dynamic asset, which is a runtime-specified asset that has no on disk representation, so has no FAssetData.
Public function Virtual void Apply a single custom primary asset rule, calls function below
Public function Virtual void Handles applying Asset Labels and should be overridden to do any game-specific labelling
Protected function Virtual Const TMap< int32, FAssetManagerChunkInfo >

BuildChunkMap ( const TSet< FName >& PackagesToUpdateChunksFor
)

 Used by UpdateManagementDatabase to build the CachedChunkMap. Should return a new cachedChunkMap.
Public function Const EPrimaryAssetCookRule Helper function for GetPackageCookRule.
Public function Static void

CallOrRegister_OnAssetManagerCreated ( FSimpleMulticastDelegate::FDelegate&& Delegate
)

 Register a delegate to call when the asset manager singleton is spawned, if this has already happened call immediately
Public function Static void

CallOrRegister_OnCompletedInitialScan ( FSimpleMulticastDelegate::FDelegate&& Delegate
)

 Register a delegate to call when all types are scanned at startup, if this has already happened call immediately
Protected function void  
Public function Virtual TSharedPtr< FStreamableHandle >

ChangeBundleStateForMatchingPrimaryAssets ( const TArray< FName >& NewBundles,
const TArray< FName >& OldBundles,
FStreamableDelegate DelegateToCall,
TAsyncLoadPriority Priority
)

 Changes the bundle state of all loaded primary assets.
Public function Virtual TSharedPtr< FStreamableHandle >

ChangeBundleStateForPrimaryAssets ( const TArray< FPrimaryAssetId >& AssetsToChange,
const TArray< FName >& AddBundles,
const TArray< FName >& RemoveBundles,
bool bRemoveAllBundles,
FStreamableDelegate DelegateToCall,
TAsyncLoadPriority Priority
)

 Changes the bundle state of a set of loaded primary assets.
Public function Static FPrimaryAssetId Creates a PrimaryAssetId from a chunk id
Public function Virtual Const FPrimaryAssetId If bShouldManagerDetermineTypeAndName is true in settings, this function is used to determine the primary asset id for any object that does not have it's own implementation.
Public function Virtual Const bool Helper function to check if a single asset passes restrictions in SearchRules, this can be used when an asset is manually registered
Protected function Virtual Const bool Sees if a specific primary asset passes the custom override filter, subclass this to handle FilterString
Public function Static void Dumps information about the Asset Registry to log
Public function Static void Dumps out summary of managed types to log
Public function Static void

DumpBundlesForAsset ( const TArray< FString >& Args
)

 Shows a list of all bundles for the specified primary asset by primary asset id (i.e. Map:Entry)
Public function Static void Dumps out list of loaded asset bundles to log
Public function Static void

DumpReferencersForPackage ( const TArray< FString >& PackageNames
)

 Dumps out list of primary asset -> managed assets to log
Protected function Virtual void

EndPIE ( bool bStartSimulate
)

 Called after PIE ends, resets loading state
Public function Virtual Const bool

ExpandVirtualPaths ( TArray< FString >& InOutPaths
)

 Expands a list of paths that potentially use virtual paths into real directory and package paths.
Public function Static int32 Extracts a chunk id from a primary asset id, returns INDEX_NONE if it is not PackageChunkType
Public function Virtual Const FPrimaryAssetId

ExtractPrimaryAssetIdFromData ( const FAssetData& AssetData,
FPrimaryAssetType SuggestedType
)

 Parses AssetData to extract the primary type/name from it.
Public function Virtual Const void

ExtractSoftObjectPaths ( const UStruct* Struct,
const void* StructValue,
TArray< FSoftObjectPath >& FoundAssetReferences,
const TArray< FName >& PropertiesToSkip
)

 Extracts all FSoftObjectPaths from a Class/Struct
Public function Virtual Const bool

FindMissingChunkList ( const TArray< FSoftObjectPath >& AssetList,
TArray< int32 >& OutMissingChunkList,
TArray< int32 >& OutErrorChunkList
)

 Returns the list of Chunks that are not currently mounted, and are required to load the referenced assets.
Public function Virtual void Finishes initial loading, gets called from end of Engine::Init()
Protected function Virtual Const void

GatherPublicAssetsForPackage ( FName PackagePath,
TArray< FName >& PackagesToCook
)

 Scans the respective PackagePath for public assets to include in PackagesToCook
Public function Static UAssetManager &

Get ()

 Returns the current AssetManager object
Public function Static void

GetAllReferencersForPackage ( TSet< FAssetData >& OutFoundAssets,
const TArray< FName >& InPackageNames,
int32 MaxDepth
)

 Finds all the referencers for a set of packages.
Public function Virtual Const bool

GetAssetBundleEntries ( const FPrimaryAssetId& BundleScope,
TArray< FAssetBundleEntry >& OutEntries
)

 Appends all AssetBundleInfos inside a given scope
Public function Virtual Const FAssetBundleEntry

GetAssetBundleEntry ( const FPrimaryAssetId& BundleScope,
FName BundleName
)

 Returns a single AssetBundleInfo, matching Scope and Name
Public function Virtual Const bool

GetAssetDataForPath ( const FSoftObjectPath& ObjectPath,
FAssetData& AssetData
)

 Gets the FAssetData at a specific path, handles redirectors and blueprint classes correctly.
Protected function Virtual Const void

GetAssetDataForPathInternal ( IAssetRegistry& AssetRegistry,
const FString& AssetPath,
OUTFAssetData& OutAssetData
)

 Internal helper function that attempts to get asset data from the specified path; Accounts for possibility of blueprint classes ending in _C
Public function Virtual Const FSoftObjectPath

GetAssetPathForData ( const FAssetData& AssetData
)

 Turns an FAssetData into FSoftObjectPath, handles adding _C as necessary
Public function Const IAssetRegistry & Accessor for asset registry
Public function Const const TArray< FString > &

GetAssetSearchRoots ( bool bIncludeDefaultRoots
)

 Returns all the game asset roots, includes /Game by default and any dynamic ones
Public function Virtual void Get the encryption key guid attached to this primary asset.
Public function Virtual Const FGuid Retrieve the encryption key guid for a given chunk ID
Public function Const const TMap< int32, FAssetManagerChunkInfo > & Returns the chunk information map computed during UpdateManagementDatabase
Public function Virtual void

GetContentEncryptionConfig ( FContentEncryptionConfig& OutContentEncryptionConfig
)

 Gathers information about which assets the game wishes to encrypt into named groups
Public function Virtual Const int32 For a given content encryption group name (as defined in the content encryption config that the project provides, return the relevant chunk ID
Public function Static bool

GetContentRootPathFromPackageName ( const FString& PackageName,
FString& OutContentRootPath
)

 Returns the root path for the package name or path (i.e. /Game/MyPackage would return /Game/ ).
Public function Virtual Const TSet< int32 > Get the encrypted chunk assignments for a give package.
Public function Static FName Get the asset registry tag name for encryption key data
Public function Static UAssetManager * Returns the current global singleton AssetManager if it has been constructed, null otherwise
Public function Static UAssetManager *  
Public function Virtual Const bool

GetManagedPackageList ( FPrimaryAssetId PrimaryAssetId,
TArray< FName >& AssetPackageList
)

 Returns list of asset packages managed by primary asset
Protected function FPrimaryAssetData *

GetNameData ( const FPrimaryAssetId& PrimaryAssetId,
bool bCheckRedirector
)

 Returns the NameData for a specific type/name pair
Protected function Const const FPrimaryAssetData *

GetNameData ( const FPrimaryAssetId& PrimaryAssetId,
bool bCheckRedirector
)

  
Public function Static FString

GetNormalizedPackagePath ( const FString& InPath,
bool bIncludeFinalSlash
)

  
Public function Virtual Const bool

GetPackageChunkIds ( FName PackageName,
const ITargetPlatform* TargetPlatform,
TArrayView< const int32 > ExistingChunkList,
TArray< int32 >& OutChunkList,
TArray< int32 >* OutOverrideChunkList
)

 For a given package and platform, return what Chunks it should be assigned to, games can override this as needed.
Public function Virtual Const EPrimaryAssetCookRule

GetPackageCookRule ( FName PackageName
)

 Returns cook rule for a package name using Management rules, games should override this to take into account their individual workflows
Public function Virtual Const bool

GetPackageManagers ( FName PackageName,
bool bRecurseToParents,
TMap< FPrimaryAssetId, UE::AssetRegistry::EDependencyProperty >& Managers
)

 Returns PrimaryAssetIds that manage a package, with property describing the reference (direct or indirect).
Public function Virtual Const bool

GetPackageManagers ( FName PackageName,
bool bRecurseToParents,
TSet< FPrimaryAssetId >& ManagerSet
)

 Returns list of PrimaryAssetIds that manage a package.
Public function Virtual Const void Reads redirector list and gets a list of the redirected previous names for a Primary Asset Id
Public function Const void

GetPrimaryAssetBundleStateMap ( TMap< FPrimaryAssetId, TArray< FName > >& BundleStateMap,
bool bForceCurrent
)

 Fills in a TMap with the pending/active loading state of every asset
Public function Virtual Const bool

GetPrimaryAssetData ( const FPrimaryAssetId& PrimaryAssetId,
FAssetData& AssetData
)

 Gets the FAssetData for a primary asset with the specified type/name, will only work for once that have been scanned for already.
Public function Virtual Const bool

GetPrimaryAssetDataList ( FPrimaryAssetType PrimaryAssetType,
TArray< FAssetData >& AssetDataList
)

 Gets list of all FAssetData for a primary asset type, returns true if any were found
Public function Const TSharedPtr< FStreamableHandle >

GetPrimaryAssetHandle ( const FPrimaryAssetId& PrimaryAssetId,
bool bForceCurrent,
TArray< FName >* Bundles
)

 Returns the loading handle associated with the primary asset, it can then be checked for progress or waited on
Public function Virtual Const FPrimaryAssetId

GetPrimaryAssetIdForData ( const FAssetData& AssetData
)

 Returns the primary asset Id for the given FAssetData, only works if in directory
Public function Virtual Const FPrimaryAssetId Sees if the passed in object is a registered primary asset, if so return it.
Public function Virtual Const FPrimaryAssetId Sees if the package has a primary asset, useful if only the package name is available
Public function Virtual Const FPrimaryAssetId Sees if the passed in object path is a registered primary asset, if so return it.
Public function Virtual Const FPrimaryAssetId  
Public function Virtual Const bool

GetPrimaryAssetIdList ( FPrimaryAssetType PrimaryAssetType,
TArray< FPrimaryAssetId >& PrimaryAssetIdList,
EAssetManagerFilter Filter
)

 Gets list of all FPrimaryAssetId for a primary asset type, returns true if any were found
Public function Const bool

GetPrimaryAssetLoadList ( TArray< FSoftObjectPath >& OutAssetLoadList,
const FPrimaryAssetId& PrimaryAssetId,
const TArray< FName >& LoadBundles,
bool bLoadRecursive,
bool bEnsureUniqueness
)

 Fills in a array of unique object paths with the assets that need to be loaded, for a given Primary Asset and bundle list
Public function Const bool

GetPrimaryAssetLoadSet ( TSet< FSoftObjectPath >& OutAssetLoadSet,
const FPrimaryAssetId& PrimaryAssetId,
const TArray< FName >& LoadBundles,
bool bLoadRecursive
)

 Fills in a set of object paths with the assets that need to be loaded, for a given Primary Asset and bundle list.
Public function Virtual Const UObject *

GetPrimaryAssetObject ( const FPrimaryAssetId& PrimaryAssetId
)

 Gets the in-memory UObject for a primary asset id, returning nullptr if it's not in memory.
Public function Const AssetType *

GetPrimaryAssetObject ( const FPrimaryAssetId& PrimaryAssetId
)

 Templated versions of above
Public function Const TSubclassOf< AssetType >

GetPrimaryAssetObjectClass ( const FPrimaryAssetId& PrimaryAssetId
)

  
Public function Virtual Const bool

GetPrimaryAssetObjectList ( FPrimaryAssetType PrimaryAssetType,
TArray< UObject* >& ObjectList
)

 Gets list of all loaded objects for a primary asset type, returns true if any were found.
Public function Virtual Const FSoftObjectPath

GetPrimaryAssetPath ( const FPrimaryAssetId& PrimaryAssetId
)

 Gets the FSoftObjectPath for a primary asset type and name, returns invalid if not found
Public function Virtual Const bool

GetPrimaryAssetPathList ( FPrimaryAssetType PrimaryAssetType,
TArray< FSoftObjectPath >& AssetPathList
)

 Gets the list of all FSoftObjectPaths for a given type, returns true if any found
Public function Virtual Const FPrimaryAssetRules Gets the management rules for a specific asset, this will merge the type and individual values
Public function Virtual Const bool

GetPrimaryAssetSetChunkIds ( const TSet< FPrimaryAssetId >& PrimaryAssetSet,
const ITargetPlatform* TargetPlatform,
TArrayView< const int32 > ExistingChunkList,
TArray< int32 >& OutChunkList
)

 Returns the list of chunks assigned to the list of primary assets, which is usually a manager list.
Public function Const bool

GetPrimaryAssetsWithBundleState ( TArray< FPrimaryAssetId >& PrimaryAssetList,
const TArray< FPrimaryAssetType >& ValidTypes,
const TArray< FName >& RequiredBundles,
const TArray< FName >& ExcludedBundles,
bool bForceCurrent
)

 Returns a list of primary assets that are in the given bundle state.
Public function Virtual Const bool

GetPrimaryAssetTypeInfo ( FPrimaryAssetType PrimaryAssetType,
FPrimaryAssetTypeInfo& AssetTypeInfo
)

 Gets metadata for a specific asset type, returns false if not found
Public function Virtual Const void Gets list of all primary asset types infos
Public function Virtual Const FName Reads AssetManagerSettings for specifically redirected asset paths.
Public function Virtual Const FSoftObjectPath  
Public function Virtual Const FPrimaryAssetId Tries to redirect a Primary Asset Id, using list in AssetManagerSettings
Public function Virtual Const bool

GetResourceAcquireProgress ( int32& OutAcquiredCount,
int32& OutRequestedCount
)

 Returns the chunk download/install progress.
Public function Const const UAssetManagerSettings & Return settings object
Public function Static FStreamableManager & Accesses the StreamableManager used by this Asset Manager. Static for easy access
Public function Const FTimerManager * Returns a timer manager that is safe to use for asset loading actions.
Public function Virtual Const FName Determine if we should separate the asset registry for this chunk out into its own file and return the unique name that identifies it
Public function Virtual bool Processes a command token as part of cooking.
Public function Virtual Const bool Returns true if initial scan has completed, this can be pretty late in editor builds
Public function Virtual Const void

InitializeAssetBundlesFromMetadata ( const UStruct* Struct,
const void* StructValue,
FAssetBundleData& AssetBundle,
FName DebugName
)

 Initializes asset bundle data from a passed in struct or class, this will read the AssetBundles metadata off the UProperties.
Public function Virtual Const void UObject wrapper
Public function Virtual void Invalidate cached asset data so it knows to rescan when needed
Public function Virtual Const bool

IsAssetDataBlueprintOfClassSet ( const FAssetData& AssetData,
const TSet< FTopLevelAssetPath >& ClassNameSet
)

 Checks to see if the given asset data is a blueprint with a base class in the ClassNameSet.
Protected function Const bool  
Public function Static bool Returns true if the global singleton AssetManager has been constructed.
Protected function Virtual Const bool Returns true if path should be excluded from primary asset scans, called from ShouldIncludeInAssetSearch and in the editor
Protected function Const bool Returns true if we're in the middle of handling the initial config, false if this is being called from something else like a plugin
Public function Static bool

IsValid ()

  
Public function TSharedPtr< FStreamableHandle >

LoadAssetList ( TArray< FSoftObjectPath >&& AssetList,
FStreamableDelegate DelegateToCall,
TAsyncLoadPriority Priority,
DebugNameType&& DebugNameOrLocation
)

 Rvalue reference overload for Asset List
Public function TSharedPtr< FStreamableHandle >

LoadAssetList ( const TArray< FSoftObjectPath >& AssetList,
FStreamableDelegate DelegateToCall,
TAsyncLoadPriority Priority,
DebugNameType&& DebugNameOrLocation
)

 Load non primary assets with the primary streamable manager.
Protected function Virtual TSharedPtr< FStreamableHandle >

LoadAssetListInternal ( TArray< FSoftObjectPath >&& AssetList,
FStreamableDelegate&& DelegateToCall,
TAsyncLoadPriority Priority,
FString&& DebugName
)

 Called to load asset list
Public function Virtual TSharedPtr< FStreamableHandle >

LoadPrimaryAsset ( const FPrimaryAssetId& AssetToLoad,
const TArray< FName >& LoadBundles,
FStreamableDelegate DelegateToCall,
TAsyncLoadPriority Priority
)

 Single asset wrapper
Public function Virtual TSharedPtr< FStreamableHandle >

LoadPrimaryAssets ( const TArray< FPrimaryAssetId >& AssetsToLoad,
const TArray< FName >& LoadBundles,
FStreamableDelegate DelegateToCall,
TAsyncLoadPriority Priority
)

 Loads a list of Primary Assets.
Public function Virtual TSharedPtr< FStreamableHandle >

LoadPrimaryAssetsWithType ( FPrimaryAssetType PrimaryAssetType,
const TArray< FName >& LoadBundles,
FStreamableDelegate DelegateToCall,
TAsyncLoadPriority Priority
)

 Loads all assets of a given type, useful for cooking
Public function Virtual void Loads the redirector maps
Public function Virtual void

ModifyCook ( TConstArrayView< const ITargetPlatform* > TargetPlatforms,
TArray< FName >& PackagesToCook,
TArray< FName >& PackagesToNeverCook
)

 Gets package names to add to the cook, and packages to never cook even if in startup set memory or referenced
Public function Virtual void

ModifyCookReferences ( FName PackageName,
TArray< FName >& PackagesToCook
)

 If the given package contains a primary asset, get the packages referenced by its AssetBundleEntries.
Public function Virtual Const void

ModifyDLCBasePackages ( const ITargetPlatform* TargetPlatform,
TArray< FName >& PlatformBasedPackages,
TSet< FName >& PackagesToClearResults
)

 Allows for game code to modify the base packages that have been read in from the DevelopmentAssetRegistry when performing a DLC cook.
Public function Virtual void

ModifyDLCCook ( const FString& DLCName,
TConstArrayView< const ITargetPlatform* > TargetPlatforms,
TArray< FName >& PackagesToCook,
TArray< FName >& PackagesToNeverCook
)

 Gets package names to add to a DLC cook
Public function Static void

NormalizePackagePath ( FString& InOutPath,
bool bIncludeFinalSlash
)

 Normalize a package path for use in asset manager, will remove duplicate // and add or remove a final slash as desired
Public function Virtual bool Called when a new asset registry becomes available
Protected function Virtual void Called when asset registry is done loading off disk, will finish any deferred loads
Protected function Virtual void

OnAssetRemoved ( const FAssetData& Data
)

 When an asset is removed
Protected function Virtual void

OnAssetRenamed ( const FAssetData& NewData,
const FString& OldPath
)

 When asset is renamed
Protected function Virtual void Called when an internal load handle finishes, handles setting to pending state
Protected function Virtual void

OnChunkDownloaded ( uint32 ChunkId,
bool bSuccess
)

 Called when a new chunk has been downloaded
Protected function Virtual void Handles updating manager when a new asset is created
Protected function Virtual void Handles updating manager if deleted object is relevant
Protected function Virtual void

OnObjectPreSave ( UObject* Object,
FObjectPreSaveContext SaveContext
)

 Called when object is saved
Protected function Virtual void  
Public function void  
Protected function Virtual void Called after scanning is complete, either from FinishInitialLoading or after the AssetRegistry finishes
Public function Virtual void Called immediately after saving the asset registry during cooking
Protected function Virtual void

PreBeginPIE ( bool bStartSimulate
)

 Called right before PIE starts, will refresh asset directory and can be overriden to preload assets
Protected function Virtual void  
Public function Virtual TSharedPtr< FStreamableHandle >

PreloadPrimaryAssets ( const TArray< FPrimaryAssetId >& AssetsToLoad,
const TArray< FName >& LoadBundles,
bool bLoadRecursive,
FStreamableDelegate DelegateToCall,
TAsyncLoadPriority Priority
)

 Preloads data for a set of assets in a specific bundle state, and returns a handle you must keep active.
Public function Virtual void

PreSaveAssetRegistry ( const ITargetPlatform* TargetPlatform,
const TSet< FName >& InCookedPackages
)

 Called immediately before saving the asset registry during cooking
Public function void Call before many calls to ScanPaths to improve load performance.
Protected function Virtual void Rebuilds the ObjectReferenceList, needed after global object state has changed
Public function Virtual Const void This will expand out references in the passed in AssetBundleData that are pointing to other primary assets with bundles.
Public function Virtual void

RefreshAssetData ( UObject* ChangedObject
)

 Refreshes cache of asset data for in memory object
Public function Virtual void

RefreshPrimaryAssetDirectory ( bool bForceRefresh
)

 Refresh the entire set of asset data, can call from editor when things have changed dramatically.
Public function FDelegateHandle

Register_OnAddedAssetSearchRoot ( FOnAddedAssetSearchRoot::FDelegate&& Delegate
)

 Call to register a callback executed when a new asset search root is added, can be used to scan for new assets
Public function Virtual bool

RegisterSpecificPrimaryAsset ( const FPrimaryAssetId& PrimaryAssetId,
const FAssetData& NewAssetData
)

 Manually register a new or updated primary asset, returns true if it was successful
Public function Virtual void Resets all asset manager data, called in the editor to reinitialize the config
Protected function Virtual void

RemovePrimaryAssetId ( const FPrimaryAssetId& PrimaryAssetId
)

 Try to remove an old asset identifier when it has been deleted/renamed
Public function Virtual void  
Public function Virtual void

RemoveScanPathsForPrimaryAssets ( FPrimaryAssetType PrimaryAssetType,
const TArray< FString >& Paths,
UClass* BaseClass,
bool bHasBlueprintClasses,
bool bIsEditorOnly
)

  
Public function Virtual int32

ScanPathForPrimaryAssets ( FPrimaryAssetType PrimaryAssetType,
const FString& Path,
UClass* BaseClass,
bool bHasBlueprintClasses,
bool bIsEditorOnly,
bool bForceSynchronousScan
)

 Single path wrapper
Public function Virtual int32

ScanPathsForPrimaryAssets ( FPrimaryAssetType PrimaryAssetType,
const TArray< FString >& Paths,
UClass* BaseClass,
bool bHasBlueprintClasses,
bool bIsEditorOnly,
bool bForceSynchronousScan
)

 Scans a list of paths and reads asset data for all primary assets of a specific type.
Public function Virtual Const void

ScanPathsSynchronous ( const TArray< FString >& PathsToScan
)

 Helper function which requests the asset registery scan a list of directories/assets
Protected function Virtual void Called to apply the primary asset rule overrides from config
Protected function Virtual void Scans all asset types specified in DefaultGame
Public function Virtual Const int32

SearchAssetRegistryPaths ( TArray< FAssetData >& OutAssetDataList,
const FAssetManagerSearchRules& Rules
)

 Helper function to search the asset registry for AssetData matching search rules
Public function Virtual void

SetPrimaryAssetRules ( FPrimaryAssetId PrimaryAssetId,
const FPrimaryAssetRules& Rules
)

 Changes the management rules for a specific asset, this overrides the type rules.
Public function Virtual void  
Public function Virtual void Changes the default management rules for a specified type
Public function Virtual bool

ShouldCookForPlatform ( const UPackage* Package,
const ITargetPlatform* TargetPlatform
)

 Returns whether or not a specific UPackage should be cooked for the provied TargetPlatform
Protected function Virtual Const bool

ShouldIncludeInAssetSearch ( const FAssetData& AssetData,
const FAssetManagerSearchRules& SearchRules
)

 Filter function that is called from SearchAssetRegistryPaths, returns true if asset data should be included in search results
Public function Virtual Const bool Returns true if the specified TypeInfo should be scanned. Can be overridden by the game
Protected function Virtual Const EAssetSetManagerResult::Type Function used during creating Management references to decide when to recurse and set references
Protected function Virtual void Should only be called from PushBulkScanning() and override
Public function Virtual void Starts initial load, gets called from InitializeObjectReferences
Protected function Virtual void Should only be called from PopBulkScanning() and override
Protected function Virtual bool

TryUpdateCachedAssetData ( const FPrimaryAssetId& PrimaryAssetId,
const FAssetData& NewAssetData,
bool bAllowDuplicates
)

 Updates the asset data cached on the name data; returns false if the asset is not a valid primary asset.
Public function Virtual int32

UnloadPrimaryAsset ( const FPrimaryAssetId& AssetToUnload
)

 Single asset wrapper
Public function Virtual int32

UnloadPrimaryAssets ( const TArray< FPrimaryAssetId >& AssetsToUnload
)

 Unloads a list of Primary Assets that were previously Loaded.
Public function Virtual int32 Loads all assets of a given type, useful for cooking
Public function void Unregister previously added callback
Public function Virtual void

UpdateManagementDatabase ( bool bForceRefresh
)

 Updates the asset management database if needed
Public function Virtual Const bool

VerifyCanCookPackage ( UE::Cook::ICookInfo* CookInfo,
FName PackageName,
bool bLogError
)

 Returns true if the specified asset package can be cooked, will error and return false if it is disallowed
Public function Virtual Const void

WarnAboutInvalidPrimaryAsset ( const FPrimaryAssetId& PrimaryAssetId,
const FString& Message
)

 Warn about this primary asset id being missing, but only if this is the first time this session
Public function Virtual Const bool

WriteCustomReport ( FString FileName,
TArray< FString >& FileLines
)

 Helper function to write out asset reports

Overridden from UObject

  Type Name Description
Public function Virtual void Called before destroying the object.
Public function Virtual void Called after the C++ constructor and after the properties have been initialized, including those loaded from config.

Classes

  Type Name Description
Protected struct FPendingChunkInstall Defines a set of chunk installs that are waiting  

Constants

Name Description
AssetSearchRootsVirtualPath Virtual path $AssetSearchRoots, replaced with all roots including defaults like /Game
DynamicSearchRootsVirtualPath Virtual path $DynamicSearchRoots, replaced with dynamically added asset roots
MapType Asset Type of UWorld assets
OnAssetManagerCreatedDelegate Delegate called when the asset manager singleton is created
OnCompletedInitialScanDelegate Delegate called when initial span finishes
PackageChunkType Type representing a packaging chunk, this is a virtual type that is never loaded off disk
PrimaryAssetLabelType Asset Type of Label used to tag other assets
SuppressionType Asset Type used in return values to indicate that a specific asset of a given PrimaryAssetType should be suppressed and not considered a PrimaryAsset.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page