UAssetManager Class Reference

#include <AssetManager.h>

Inheritance diagram for UAssetManager:

Classes
struct	FPendingChunkInstall

Public Member Functions
ENGINE_API	UAssetManager ()
virtual ENGINE_API int32	ScanPathsForPrimaryAssets (FPrimaryAssetType PrimaryAssetType, const TArray< FString > &Paths, UClass *BaseClass, bool bHasBlueprintClasses, bool bIsEditorOnly=false, bool bForceSynchronousScan=true)
virtual ENGINE_API 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 ()
virtual ENGINE_API void	RemoveScanPathsForPrimaryAssets (FPrimaryAssetType PrimaryAssetType, const TArray< FString > &Paths, UClass *BaseClass, bool bHasBlueprintClasses, bool bIsEditorOnly=false)
virtual ENGINE_API void	RemovePrimaryAssetType (FPrimaryAssetType PrimaryAssetType)
virtual ENGINE_API bool	AddDynamicAsset (const FPrimaryAssetId &PrimaryAssetId, const FSoftObjectPath &AssetPath, const FAssetBundleData &BundleData)
virtual ENGINE_API void	RecursivelyExpandBundleData (FAssetBundleData &BundleData) const
virtual ENGINE_API bool	HasInitialScanCompleted () const
ENGINE_API FDelegateHandle	Register_OnAddedAssetSearchRoot (FOnAddedAssetSearchRoot::FDelegate &&Delegate)
ENGINE_API void	Unregister_OnAddedAssetSearchRoot (FDelegateHandle DelegateHandle)
virtual ENGINE_API bool	ExpandVirtualPaths (TArray< FString > &InOutPaths) const
virtual ENGINE_API void	AddAssetSearchRoot (const FString &NewRootPath)
ENGINE_API const TArray< FString > &	GetAssetSearchRoots (bool bIncludeDefaultRoots=true) const
virtual ENGINE_API bool	GetPrimaryAssetData (const FPrimaryAssetId &PrimaryAssetId, FAssetData &AssetData) const
virtual ENGINE_API bool	GetPrimaryAssetDataList (FPrimaryAssetType PrimaryAssetType, TArray< FAssetData > &AssetDataList) const
virtual ENGINE_API UObject *	GetPrimaryAssetObject (const FPrimaryAssetId &PrimaryAssetId) const
template<class AssetType >
AssetType *	GetPrimaryAssetObject (const FPrimaryAssetId &PrimaryAssetId) const
template<class AssetType >
TSubclassOf< AssetType >	GetPrimaryAssetObjectClass (const FPrimaryAssetId &PrimaryAssetId) const
virtual ENGINE_API bool	GetPrimaryAssetObjectList (FPrimaryAssetType PrimaryAssetType, TArray< UObject * > &ObjectList) const
virtual ENGINE_API FSoftObjectPath	GetPrimaryAssetPath (const FPrimaryAssetId &PrimaryAssetId) const
virtual ENGINE_API bool	GetPrimaryAssetPathList (FPrimaryAssetType PrimaryAssetType, TArray< FSoftObjectPath > &AssetPathList) const
virtual ENGINE_API FPrimaryAssetId	GetPrimaryAssetIdForObject (UObject *Object) const
virtual ENGINE_API FPrimaryAssetId	GetPrimaryAssetIdForPath (const FSoftObjectPath &ObjectPath) const
virtual ENGINE_API FPrimaryAssetId	GetPrimaryAssetIdForPackage (FName PackagePath) const
virtual ENGINE_API FPrimaryAssetId	GetPrimaryAssetIdForData (const FAssetData &AssetData) const
virtual ENGINE_API bool	GetPrimaryAssetIdList (FPrimaryAssetType PrimaryAssetType, TArray< FPrimaryAssetId > &PrimaryAssetIdList, EAssetManagerFilter Filter=EAssetManagerFilter::Default) const
virtual ENGINE_API bool	GetPrimaryAssetTypeInfo (FPrimaryAssetType PrimaryAssetType, FPrimaryAssetTypeInfo &AssetTypeInfo) const
virtual ENGINE_API void	GetPrimaryAssetTypeInfoList (TArray< FPrimaryAssetTypeInfo > &AssetTypeInfoList) const
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())
virtual ENGINE_API 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())
virtual ENGINE_API 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())
virtual ENGINE_API TSharedPtr< FStreamableHandle >	LoadPrimaryAssetsWithType (FPrimaryAssetType PrimaryAssetType, const TArray< FName > &LoadBundles, FAssetManagerLoadParams &&LoadParams, UE::FSourceLocation Location=UE::FSourceLocation::Current())
virtual ENGINE_API int32	UnloadPrimaryAssets (const TArray< FPrimaryAssetId > &AssetsToUnload)
virtual ENGINE_API int32	UnloadPrimaryAsset (const FPrimaryAssetId &AssetToUnload)
virtual ENGINE_API 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())
virtual ENGINE_API 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())
virtual ENGINE_API 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())
virtual ENGINE_API TSharedPtr< FStreamableHandle >	PreloadPrimaryAssets (const TArray< FPrimaryAssetId > &AssetsToLoad, const TArray< FName > &LoadBundles, bool bLoadRecursive, FAssetManagerLoadParams &&LoadParams, UE::FSourceLocation Location=UE::FSourceLocation::Current())
virtual ENGINE_API 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())
virtual ENGINE_API 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())
virtual ENGINE_API FAssetBundleEntry	GetAssetBundleEntry (const FPrimaryAssetId &BundleScope, FName BundleName) const
virtual ENGINE_API bool	GetAssetBundleEntries (const FPrimaryAssetId &BundleScope, TArray< FAssetBundleEntry > &OutEntries) const
virtual ENGINE_API bool	FindMissingChunkList (const TArray< FSoftObjectPath > &AssetList, TArray< int32 > &OutMissingChunkList, TArray< int32 > &OutErrorChunkList) const
virtual ENGINE_API void	AcquireResourcesForAssetList (const TArray< FSoftObjectPath > &AssetList, FAssetManagerAcquireResourceDelegateEx CompleteDelegate, EChunkPriority::Type Priority=EChunkPriority::Immediate)
virtual ENGINE_API void	AcquireResourcesForAssetList (const TArray< FSoftObjectPath > &AssetList, FAssetManagerAcquireResourceDelegate CompleteDelegate, EChunkPriority::Type Priority=EChunkPriority::Immediate)
virtual ENGINE_API void	AcquireResourcesForPrimaryAssetList (const TArray< FPrimaryAssetId > &PrimaryAssetList, FAssetManagerAcquireResourceDelegate CompleteDelegate, EChunkPriority::Type Priority=EChunkPriority::Immediate)
virtual ENGINE_API bool	GetResourceAcquireProgress (int32 &OutAcquiredCount, int32 &OutRequestedCount) const
virtual ENGINE_API void	SetPrimaryAssetTypeRules (FPrimaryAssetType PrimaryAssetType, const FPrimaryAssetRules &Rules)
virtual ENGINE_API void	SetPrimaryAssetRules (FPrimaryAssetId PrimaryAssetId, const FPrimaryAssetRules &Rules)
virtual ENGINE_API void	SetPrimaryAssetRulesExplicitly (FPrimaryAssetId PrimaryAssetId, const FPrimaryAssetRulesExplicitOverride &ExplicitRules)
virtual ENGINE_API FPrimaryAssetRules	GetPrimaryAssetRules (FPrimaryAssetId PrimaryAssetId) const
virtual ENGINE_API bool	GetManagedPackageList (FPrimaryAssetId PrimaryAssetId, TArray< FName > &AssetPackageList) const
virtual ENGINE_API bool	GetPackageCookRuleManagers (FName PackageName, bool bRecurseToParents, TMap< FPrimaryAssetId, UE::AssetRegistry::EDependencyProperty > &Managers) const
virtual ENGINE_API bool	GetPackageManagers (FName PackageName, bool bRecurseToParents, TMap< FPrimaryAssetId, UE::AssetRegistry::EDependencyProperty > &Managers) const
virtual ENGINE_API bool	GetPackageManagers (FName PackageName, bool bRecurseToParents, TSet< FPrimaryAssetId > &ManagerSet) const
virtual ENGINE_API FPrimaryAssetId	ExtractPrimaryAssetIdFromData (const FAssetData &AssetData, FPrimaryAssetType SuggestedType=FPrimaryAssetType()) const
virtual ENGINE_API bool	GetAssetDataForPath (const FSoftObjectPath &ObjectPath, FAssetData &AssetData) const
virtual ENGINE_API bool	IsAssetDataBlueprintOfClassSet (const FAssetData &AssetData, const TSet< FTopLevelAssetPath > &ClassNameSet) const
virtual ENGINE_API FSoftObjectPath	GetAssetPathForData (const FAssetData &AssetData) const
virtual ENGINE_API FPrimaryAssetId	GetRedirectedPrimaryAssetId (const FPrimaryAssetId &OldId) const
virtual ENGINE_API void	GetPreviousPrimaryAssetIds (const FPrimaryAssetId &NewId, TArray< FPrimaryAssetId > &OutOldIds) const
virtual ENGINE_API FPrimaryAssetId	DeterminePrimaryAssetIdForObject (const UObject *Object) const
virtual ENGINE_API FSoftObjectPath	GetRedirectedAssetPath (const FSoftObjectPath &OldPath) const
virtual ENGINE_API void	ExtractSoftObjectPaths (const UStruct *Struct, const void *StructValue, TArray< FSoftObjectPath > &FoundAssetReferences, const TArray< FName > &PropertiesToSkip=TArray< FName >()) const
virtual ENGINE_API int32	SearchAssetRegistryPaths (TArray< FAssetData > &OutAssetDataList, const FAssetManagerSearchRules &Rules) const
virtual ENGINE_API bool	DoesAssetMatchSearchRules (const FAssetData &AssetData, const FAssetManagerSearchRules &Rules) const
virtual ENGINE_API bool	ShouldScanPrimaryAssetType (FPrimaryAssetTypeInfo &TypeInfo) const
virtual ENGINE_API bool	RegisterSpecificPrimaryAsset (const FPrimaryAssetId &PrimaryAssetId, const FAssetData &NewAssetData)
virtual ENGINE_API void	ScanPathsSynchronous (const TArray< FString > &PathsToScan) const
virtual ENGINE_API bool	OnAssetRegistryAvailableAfterInitialization (FName InName, FAssetRegistryState &OutNewState)
virtual ENGINE_API void	StartInitialLoading ()
virtual ENGINE_API void	FinishInitialLoading ()
ENGINE_API IAssetRegistry &	GetAssetRegistry () const
ENGINE_API const UAssetManagerSettings &	GetSettings () const
ENGINE_API FTimerManager *	GetTimerManager () const
virtual ENGINE_API void	BeginDestroy () override
virtual ENGINE_API void	PostInitProperties () override
virtual ENGINE_API void	GetCachedPrimaryAssetEncryptionKeyGuid (FPrimaryAssetId InPrimaryAssetId, FGuid &OutGuid)
virtual ENGINE_API void	LoadRedirectorMaps ()
virtual ENGINE_API void	RefreshPrimaryAssetDirectory (bool bForceRefresh=false)
virtual ENGINE_API void	InvalidatePrimaryAssetDirectory ()
virtual ENGINE_API void	WarnAboutInvalidPrimaryAsset (const FPrimaryAssetId &PrimaryAssetId, const FString &Message) const
virtual ENGINE_API bool	WriteCustomReport (FString FileName, TArray< FString > &FileLines) const
virtual ENGINE_API void	ApplyCustomPrimaryAssetRulesOverride (const FPrimaryAssetRulesCustomOverride &CustomOverride)
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)
Public Member Functions inherited from UObject
COREUOBJECT_API	UObject ()
COREUOBJECT_API	UObject (const FObjectInitializer &ObjectInitializer)
COREUOBJECT_API	UObject (EStaticConstructor, EObjectFlags InFlags)
COREUOBJECT_API	UObject (FVTableHelper &Helper)
COREUOBJECT_API UObject *	CreateDefaultSubobject (FName SubobjectFName, UClass *ReturnType, UClass *ClassToCreateByDefault, bool bIsRequired, bool bIsTransient)
template<class TReturnType >
TReturnType *	CreateEditorOnlyDefaultSubobject (FName SubobjectName, bool bTransient=false)
template<class TReturnType >
TReturnType *	CreateDefaultSubobject (FName SubobjectName, bool bTransient=false)
template<class TReturnType , class TClassToConstructByDefault >
TReturnType *	CreateDefaultSubobject (FName SubobjectName, bool bTransient=false)
template<class TReturnType >
TReturnType *	CreateOptionalDefaultSubobject (FName SubobjectName, bool bTransient=false)
template<class TReturnType , class TClassToConstructByDefault >
TReturnType *	CreateOptionalDefaultSubobject (FName SubobjectName, bool bTransient=false)
COREUOBJECT_API void	GetDefaultSubobjects (TArray< UObject * > &OutDefaultSubobjects)
COREUOBJECT_API UObject *	GetDefaultSubobjectByName (FName ToFind)
virtual COREUOBJECT_API void	PostReinitProperties ()
virtual void	PostCDOContruct ()
virtual COREUOBJECT_API void	PreSaveRoot (FObjectPreSaveRootContext ObjectSaveContext)
virtual COREUOBJECT_API void	PostSaveRoot (FObjectPostSaveRootContext ObjectSaveContext)
virtual COREUOBJECT_API void	PreSave (FObjectPreSaveContext SaveContext)
virtual COREUOBJECT_API void	CollectSaveOverrides (FObjectCollectSaveOverridesContext SaveContext)
UE_FORCEINLINE_HINT bool	Modify (bool bAlwaysMarkDirty=true)
UE_FORCEINLINE_HINT bool	IsCapturingAsRootObjectForTransaction () const
virtual bool	ResolveSubobject (const TCHAR *SubObjectPath, UObject *&OutObject, bool bLoadIfExists)
virtual bool	IsReadyForAsyncPostLoad () const
virtual COREUOBJECT_API void	PostLoad ()
virtual COREUOBJECT_API void	PostLoadSubobjects (FObjectInstancingGraph *OuterInstanceGraph)
virtual bool	IsReadyForFinishDestroy ()
virtual COREUOBJECT_API void	FinishDestroy ()
virtual COREUOBJECT_API void	Serialize (FArchive &Ar)
virtual COREUOBJECT_API void	Serialize (FStructuredArchive::FRecord Record)
virtual void	ShutdownAfterError ()
virtual void	PostInterpChange (FProperty *PropertyThatChanged)
virtual COREUOBJECT_API void	PostRename (UObject *OldOuter, const FName OldName)
virtual void	PreDuplicate (FObjectDuplicationParameters &DupParams)
virtual void	PostDuplicate (bool bDuplicateForPIE)
virtual void	PostDuplicate (EDuplicateMode::Type DuplicateMode)
virtual COREUOBJECT_API bool	NeedsLoadForClient () const
virtual COREUOBJECT_API bool	NeedsLoadForServer () const
virtual COREUOBJECT_API bool	NeedsLoadForTargetPlatform (const class ITargetPlatform *TargetPlatform) const
virtual bool	NeedsLoadForEditorGame () const
virtual bool	IsEditorOnly () const
virtual bool	HasNonEditorOnlyReferences () const
virtual bool	IsPostLoadThreadSafe () const
virtual COREUOBJECT_API bool	IsDestructionThreadSafe () const
virtual COREUOBJECT_API void	GetPreloadDependencies (TArray< UObject * > &OutDeps)
virtual void	GetPrestreamPackages (TArray< UObject * > &OutPrestream)
virtual void	ExportCustomProperties (FOutputDevice &Out, uint32 Indent)
virtual void	ImportCustomProperties (const TCHAR *SourceText, FFeedbackContext *Warn)
virtual void	PostEditImport ()
virtual void	PostReloadConfig (class FProperty *PropertyThatWasLoaded)
virtual COREUOBJECT_API bool	Rename (const TCHAR *NewName=nullptr, UObject *NewOuter=nullptr, ERenameFlags Flags=REN_None)
virtual FString	GetDesc ()
COREUOBJECT_API UScriptStruct *	GetSparseClassDataStruct () const
virtual bool	GetNativePropertyValues (TMap< FString, FString > &out_PropertyValues, uint32 ExportFlags=0) const
virtual COREUOBJECT_API void	GetResourceSizeEx (FResourceSizeEx &CumulativeResourceSize)
SIZE_T	GetResourceSizeBytes (EResourceSizeMode::Type Mode)
virtual FName	GetExporterName (void)
COREUOBJECT_API void	CallAddReferencedObjects (FReferenceCollector &Collector)
virtual FRestoreForUObjectOverwrite *	GetRestoreForUObjectOverwrite ()
virtual bool	AreNativePropertiesIdenticalTo (UObject *Other) const
virtual COREUOBJECT_API void	GetAssetRegistryTags (FAssetRegistryTagsContext Context) const
virtual COREUOBJECT_API void	GetAssetRegistryTags (TArray< FAssetRegistryTag > &OutTags) const
COREUOBJECT_API void	GetAssetRegistryTags (FAssetData &Out) const
COREUOBJECT_API void	GetAssetRegistryTags (FAssetRegistryTagsContext Context, FAssetData &Out) const
virtual COREUOBJECT_API bool	IsAsset () const
virtual COREUOBJECT_API FPrimaryAssetId	GetPrimaryAssetId () const
virtual COREUOBJECT_API bool	IsLocalizedResource () const
virtual COREUOBJECT_API bool	IsSafeForRootSet () const
virtual COREUOBJECT_API void	TagSubobjects (EObjectFlags NewFlags)
virtual COREUOBJECT_API void	GetLifetimeReplicatedProps (TArray< class FLifetimeProperty > &OutLifetimeProps) const
virtual COREUOBJECT_API void	GetReplicatedCustomConditionState (FCustomPropertyConditionState &OutActiveState) const
virtual COREUOBJECT_API void	RegisterReplicationFragments (UE::Net::FFragmentRegistrationContext &Context, UE::Net::EFragmentRegistrationFlags RegistrationFlags)
virtual COREUOBJECT_API bool	IsNameStableForNetworking () const
virtual COREUOBJECT_API bool	IsFullNameStableForNetworking () const
virtual COREUOBJECT_API bool	IsSupportedForNetworking () const
virtual void	GetSubobjectsWithStableNamesForNetworking (TArray< UObject * > &ObjList)
virtual COREUOBJECT_API void	PreNetReceive ()
virtual COREUOBJECT_API void	PostNetReceive ()
virtual void	PostRepNotifies ()
virtual COREUOBJECT_API void	PreDestroyFromReplication ()
COREUOBJECT_API bool	IsSelected () const
COREUOBJECT_API void	SerializeScriptProperties (FArchive &Ar) const
COREUOBJECT_API void	SerializeScriptProperties (FStructuredArchive::FSlot Slot) const
COREUOBJECT_API void	ReinitializeProperties (UObject *SourceObject=NULL, struct FObjectInstancingGraph *InstanceGraph=NULL)
COREUOBJECT_API FString	GetDetailedInfo () const
COREUOBJECT_API bool	ConditionalBeginDestroy ()
COREUOBJECT_API bool	ConditionalFinishDestroy ()
COREUOBJECT_API void	ConditionalPostLoad ()
COREUOBJECT_API void	ConditionalPreload ()
COREUOBJECT_API void	ConditionalPostLoadSubobjects (struct FObjectInstancingGraph *OuterInstanceGraph=NULL)
bool	IsBasedOnArchetype (const UObject *const SomeObject) const
COREUOBJECT_API UFunction *	FindFunction (FName InName) const
COREUOBJECT_API UFunction *	FindFunctionChecked (FName InName) const
virtual COREUOBJECT_API void	BuildSubobjectMapping (UObject *OtherObject, TMap< UObject *, UObject * > &ObjectMapping) const
COREUOBJECT_API void	CollectDefaultSubobjects (TArray< UObject * > &OutDefaultSubobjects, bool bIncludeNestedSubobjects=false) const
COREUOBJECT_API bool	CheckDefaultSubobjects (bool bForceCheck=false) const
COREUOBJECT_API void	SaveConfig (uint64 RequiredPropertyFlags=CPF_Config, const TCHAR *Filename=nullptr, FConfigCacheIni *Config=GConfig, bool bAllowCopyToDefaultObject=true)
COREUOBJECT_API void	SaveConfig (const FSaveConfigContext &Context)
COREUOBJECT_API void	UpdateDefaultConfigFile (const FString &SpecificFileLocation="")
COREUOBJECT_API bool	TryUpdateDefaultConfigFile (const FString &SpecificFileLocation="", bool bWarnIfFail=true)
COREUOBJECT_API void	UpdateGlobalUserConfigFile ()
COREUOBJECT_API void	UpdateProjectUserConfigFile ()
COREUOBJECT_API void	UpdateSinglePropertyInConfigFile (const FProperty *InProperty, const FString &InConfigIniName)
COREUOBJECT_API FString	GetDefaultConfigFilename () const
COREUOBJECT_API FString	GetGlobalUserConfigFilename () const
COREUOBJECT_API FString	GetProjectUserConfigFilename () const
virtual const TCHAR *	GetConfigOverridePlatform () const
virtual void	OverrideConfigSection (FString &SectionName)
virtual void	OverridePerObjectConfigSection (FString &SectionName)
COREUOBJECT_API void	LoadConfig (UClass *ConfigClass=nullptr, const TCHAR *Filename=nullptr, uint32 PropagationFlags=UE::LCPF_None, class FProperty *PropertyToLoad=nullptr, TArray< UE::ConfigAccessTracking::FConfigAccessData > *OutAccessedKeys=nullptr)
COREUOBJECT_API void	ReloadConfig (UClass *ConfigClass=NULL, const TCHAR *Filename=NULL, uint32 PropagationFlags=UE::LCPF_None, class FProperty *PropertyToLoad=NULL)
COREUOBJECT_API void	ParseParms (const TCHAR *Parms)
COREUOBJECT_API void	OutputReferencers (FOutputDevice &Ar, FReferencerInformationList *Referencers=NULL)
COREUOBJECT_API void	RetrieveReferencers (TArray< FReferencerInformation > *OutInternalReferencers, TArray< FReferencerInformation > *OutExternalReferencers)
COREUOBJECT_API void	SetLinker (FLinkerLoad *LinkerLoad, int32 LinkerIndex, bool bShouldDetachExisting=true, bool bSilenceLogs=false)
COREUOBJECT_API UObject *	GetArchetype () const
COREUOBJECT_API void	GetArchetypeInstances (TArray< UObject * > &Instances)
COREUOBJECT_API void	InstanceSubobjectTemplates (struct FObjectInstancingGraph *InstanceGraph=NULL)
template<class T >
bool	Implements () const
virtual COREUOBJECT_API void	ProcessEvent (UFunction *Function, void *Parms)
virtual int32	GetFunctionCallspace (UFunction *Function, FFrame *Stack)
virtual bool	CallRemoteFunction (UFunction *Function, void *Parms, struct FOutParmRec *OutParms, FFrame *Stack)
COREUOBJECT_API bool	CallFunctionByNameWithArguments (const TCHAR *Cmd, FOutputDevice &Ar, UObject *Executor, bool bForceCallWithNonExec=false)
COREUOBJECT_API void	CallFunction (FFrame &Stack, RESULT_DECL, UFunction *Function)
	DECLARE_FUNCTION (ProcessInternal)
virtual bool	ProcessConsoleExec (const TCHAR *Cmd, FOutputDevice &Ar, UObject *Executor)
COREUOBJECT_API void	SkipFunction (FFrame &Stack, RESULT_DECL, UFunction *Function)
virtual UClass *	RegenerateClass (UClass *ClassToRegenerate, UObject *PreviousCDO)
COREUOBJECT_API bool	IsInBlueprint () const
COREUOBJECT_API void	DestroyNonNativeProperties ()
virtual void	MarkAsEditorOnlySubobject ()
COREUOBJECT_API void	AbortInsideMemberFunction () const
	DECLARE_FUNCTION (execUndefined)
	DECLARE_FUNCTION (execLocalVariable)
	DECLARE_FUNCTION (execInstanceVariable)
	DECLARE_FUNCTION (execDefaultVariable)
	DECLARE_FUNCTION (execLocalOutVariable)
	DECLARE_FUNCTION (execInterfaceVariable)
	DECLARE_FUNCTION (execClassSparseDataVariable)
	DECLARE_FUNCTION (execInterfaceContext)
	DECLARE_FUNCTION (execArrayElement)
	DECLARE_FUNCTION (execBoolVariable)
	DECLARE_FUNCTION (execClassDefaultVariable)
	DECLARE_FUNCTION (execEndFunctionParms)
	DECLARE_FUNCTION (execNothing)
	DECLARE_FUNCTION (execNothingInt32)
	DECLARE_FUNCTION (execNothingOp4a)
	DECLARE_FUNCTION (execBreakpoint)
	DECLARE_FUNCTION (execTracepoint)
	DECLARE_FUNCTION (execWireTracepoint)
	DECLARE_FUNCTION (execInstrumentation)
	DECLARE_FUNCTION (execEndOfScript)
	DECLARE_FUNCTION (execReturnNothing)
	DECLARE_FUNCTION (execEmptyParmValue)
	DECLARE_FUNCTION (execJump)
	DECLARE_FUNCTION (execJumpIfNot)
	DECLARE_FUNCTION (execAssert)
	DECLARE_FUNCTION (execPushExecutionFlow)
	DECLARE_FUNCTION (execPopExecutionFlow)
	DECLARE_FUNCTION (execComputedJump)
	DECLARE_FUNCTION (execPopExecutionFlowIfNot)
	DECLARE_FUNCTION (execLet)
	DECLARE_FUNCTION (execLetObj)
	DECLARE_FUNCTION (execLetWeakObjPtr)
	DECLARE_FUNCTION (execLetBool)
	DECLARE_FUNCTION (execLetDelegate)
	DECLARE_FUNCTION (execLetMulticastDelegate)
	DECLARE_FUNCTION (execAddMulticastDelegate)
	DECLARE_FUNCTION (execClearMulticastDelegate)
	DECLARE_FUNCTION (execEatReturnValue)
	DECLARE_FUNCTION (execRemoveMulticastDelegate)
	DECLARE_FUNCTION (execSelf)
	DECLARE_FUNCTION (execContext)
	DECLARE_FUNCTION (execContext_FailSilent)
	DECLARE_FUNCTION (execStructMemberContext)
	DECLARE_FUNCTION (execVirtualFunction)
	DECLARE_FUNCTION (execFinalFunction)
	DECLARE_FUNCTION (execLocalVirtualFunction)
	DECLARE_FUNCTION (execLocalFinalFunction)
	DECLARE_FUNCTION (execStructCmpEq)
	DECLARE_FUNCTION (execStructCmpNe)
	DECLARE_FUNCTION (execStructMember)
	DECLARE_FUNCTION (execEqualEqual_DelegateDelegate)
	DECLARE_FUNCTION (execNotEqual_DelegateDelegate)
	DECLARE_FUNCTION (execEqualEqual_DelegateFunction)
	DECLARE_FUNCTION (execNotEqual_DelegateFunction)
	DECLARE_FUNCTION (execIntConst)
	DECLARE_FUNCTION (execInt64Const)
	DECLARE_FUNCTION (execUInt64Const)
	DECLARE_FUNCTION (execSkipOffsetConst)
	DECLARE_FUNCTION (execFloatConst)
	DECLARE_FUNCTION (execDoubleConst)
	DECLARE_FUNCTION (execStringConst)
	DECLARE_FUNCTION (execUnicodeStringConst)
	DECLARE_FUNCTION (execTextConst)
	DECLARE_FUNCTION (execPropertyConst)
	DECLARE_FUNCTION (execObjectConst)
	DECLARE_FUNCTION (execSoftObjectConst)
	DECLARE_FUNCTION (execFieldPathConst)
	DECLARE_FUNCTION (execInstanceDelegate)
	DECLARE_FUNCTION (execNameConst)
	DECLARE_FUNCTION (execByteConst)
	DECLARE_FUNCTION (execIntZero)
	DECLARE_FUNCTION (execIntOne)
	DECLARE_FUNCTION (execTrue)
	DECLARE_FUNCTION (execFalse)
	DECLARE_FUNCTION (execNoObject)
	DECLARE_FUNCTION (execNullInterface)
	DECLARE_FUNCTION (execIntConstByte)
	DECLARE_FUNCTION (execRotationConst)
	DECLARE_FUNCTION (execVectorConst)
	DECLARE_FUNCTION (execVector3fConst)
	DECLARE_FUNCTION (execTransformConst)
	DECLARE_FUNCTION (execStructConst)
	DECLARE_FUNCTION (execSetArray)
	DECLARE_FUNCTION (execSetSet)
	DECLARE_FUNCTION (execSetMap)
	DECLARE_FUNCTION (execArrayConst)
	DECLARE_FUNCTION (execSetConst)
	DECLARE_FUNCTION (execMapConst)
	DECLARE_FUNCTION (execBitFieldConst)
	DECLARE_FUNCTION (execNew)
	DECLARE_FUNCTION (execClassContext)
	DECLARE_FUNCTION (execNativeParm)
	DECLARE_FUNCTION (execCast)
	DECLARE_FUNCTION (execDynamicCast)
	DECLARE_FUNCTION (execMetaCast)
	DECLARE_FUNCTION (execInterfaceCast)
	DECLARE_FUNCTION (execDoubleToFloatCast)
	DECLARE_FUNCTION (execFloatToDoubleCast)
	DECLARE_FUNCTION (execObjectToBool)
	DECLARE_FUNCTION (execInterfaceToBool)
	DECLARE_FUNCTION (execObjectToInterface)
	DECLARE_FUNCTION (execInterfaceToInterface)
	DECLARE_FUNCTION (execInterfaceToObject)
	DECLARE_FUNCTION (execGetDynArrayElement)
	DECLARE_FUNCTION (execSetDynArrayElement)
	DECLARE_FUNCTION (execGetDynArrayLength)
	DECLARE_FUNCTION (execSetDynArrayLength)
	DECLARE_FUNCTION (execDynArrayInsert)
	DECLARE_FUNCTION (execDynArrayRemove)
	DECLARE_FUNCTION (execDynArrayFind)
	DECLARE_FUNCTION (execDynArrayFindStruct)
	DECLARE_FUNCTION (execDynArrayAdd)
	DECLARE_FUNCTION (execDynArrayAddItem)
	DECLARE_FUNCTION (execDynArrayInsertItem)
	DECLARE_FUNCTION (execDynArrayRemoveItem)
	DECLARE_FUNCTION (execDynArraySort)
	DECLARE_FUNCTION (execBindDelegate)
	DECLARE_FUNCTION (execCallMulticastDelegate)
	DECLARE_FUNCTION (execLetValueOnPersistentFrame)
	DECLARE_FUNCTION (execCallMathFunction)
	DECLARE_FUNCTION (execSwitchValue)
	DECLARE_FUNCTION (execArrayGetByRef)
	DECLARE_FUNCTION (execAutoRtfmTransact)
	DECLARE_FUNCTION (execAutoRtfmStopTransact)
	DECLARE_FUNCTION (execAutoRtfmAbortIfNot)
void	ExecuteUbergraph (int32 EntryPoint)
virtual void	ValidateGeneratedRepEnums (const TArray< struct FRepRecord > &ClassReps) const
virtual uint64	GetNetPushIdDynamic () const
Public Member Functions inherited from UObjectBaseUtility
	UObjectBaseUtility ()
	UObjectBaseUtility (EObjectFlags InFlags)
void	SetFlags (EObjectFlags NewFlags)
void	ClearFlags (EObjectFlags FlagsToClear)
bool	HasAnyFlags (EObjectFlags FlagsToCheck) const
bool	HasAllFlags (EObjectFlags FlagsToCheck) const
UE_FORCEINLINE_HINT EObjectFlags	GetMaskedFlags (EObjectFlags Mask=RF_AllFlags) const
UE_FORCEINLINE_HINT void	Mark (EObjectMark Marks) const
UE_FORCEINLINE_HINT void	UnMark (EObjectMark Marks) const
UE_FORCEINLINE_HINT bool	HasAnyMarks (EObjectMark Marks) const
UE_FORCEINLINE_HINT bool	HasAllMarks (EObjectMark Marks) const
UE_FORCEINLINE_HINT EObjectMark	GetAllMarks () const
void	MarkAsGarbage ()
void	ClearGarbage ()
UE_FORCEINLINE_HINT void	AddToRoot ()
UE_FORCEINLINE_HINT void	RemoveFromRoot ()
UE_FORCEINLINE_HINT bool	IsRooted () const
UE_FORCEINLINE_HINT int32	GetRefCount () const
bool	ThisThreadAtomicallyClearedRFUnreachable ()
UE_FORCEINLINE_HINT bool	IsUnreachable () const
UE_FORCEINLINE_HINT bool	IsNative () const
void	SetInternalFlags (EInternalObjectFlags FlagsToSet) const
UE_FORCEINLINE_HINT EInternalObjectFlags	GetInternalFlags () const
UE_FORCEINLINE_HINT bool	HasAnyInternalFlags (EInternalObjectFlags FlagsToCheck) const
void	ClearInternalFlags (EInternalObjectFlags FlagsToClear) const
bool	AtomicallyClearInternalFlags (EInternalObjectFlags FlagsToClear) const
COREUOBJECT_API FString	GetFullName (const UObject *StopOuter=NULL, EObjectFullNameFlags Flags=EObjectFullNameFlags::None) const
COREUOBJECT_API void	GetFullName (const UObject *StopOuter, FString &ResultString, EObjectFullNameFlags Flags=EObjectFullNameFlags::None) const
COREUOBJECT_API void	GetFullName (FStringBuilderBase &ResultString, const UObject *StopOuter=NULL, EObjectFullNameFlags Flags=EObjectFullNameFlags::None) const
COREUOBJECT_API FString	GetPathName (const UObject *StopOuter=NULL) const
COREUOBJECT_API void	GetPathName (const UObject *StopOuter, FString &ResultString) const
COREUOBJECT_API void	GetPathName (const UObject *StopOuter, FStringBuilderBase &ResultString) const
virtual bool	CanBeClusterRoot () const
virtual COREUOBJECT_API bool	CanBeInCluster () const
virtual COREUOBJECT_API void	CreateCluster ()
virtual void	OnClusterMarkedAsPendingKill ()
COREUOBJECT_API void	AddToCluster (UObjectBaseUtility *ClusterRootOrObjectFromCluster, bool bAddAsMutableObject=false)
COREUOBJECT_API FString	GetFullGroupName (bool bStartWithOuter) const
UE_FORCEINLINE_HINT FString	GetName () const
UE_FORCEINLINE_HINT void	GetName (FString &ResultString) const
UE_FORCEINLINE_HINT void	AppendName (FString &ResultString) const
COREUOBJECT_API bool	IsPackageExternal () const
COREUOBJECT_API void	DetachExternalPackage ()
COREUOBJECT_API void	ReattachExternalPackage ()
COREUOBJECT_API UObject *	GetOutermostObject () const
COREUOBJECT_API UPackage *	GetPackage () const
UE_INTERNAL virtual COREUOBJECT_API UE::Core::FVersePath	GetVersePath () const
COREUOBJECT_API UPackage *	GetOutermost () const
COREUOBJECT_API bool	MarkPackageDirty () const
COREUOBJECT_API bool	IsTemplate (EObjectFlags TemplateTypes=RF_ArchetypeObject|RF_ClassDefaultObject) const
COREUOBJECT_API UObject *	GetTypedOuter (UClass *Target) const
template<typename T >
T *	GetTypedOuter () const
template<typename InterfaceClassType >
InterfaceClassType *	GetImplementingOuter () const
COREUOBJECT_API UObjectBaseUtility *	GetImplementingOuterObject (const UClass *InInterfaceClass) const
COREUOBJECT_API bool	IsIn (const UObject *SomeOuter) const
COREUOBJECT_API bool	IsIn (const UPackage *SomePackage) const
COREUOBJECT_API bool	IsInOuter (const UObject *SomeOuter) const
COREUOBJECT_API bool	IsInPackage (const UPackage *SomePackage) const
COREUOBJECT_API bool	IsInA (const UClass *SomeBaseClass) const
COREUOBJECT_API bool	RootPackageHasAnyFlags (uint32 CheckFlagMask) const
template<typename OtherClassType >
bool	IsA (OtherClassType SomeBase) const
template<class T >
bool	IsA () const
COREUOBJECT_API const UClass *	FindNearestCommonBaseClass (const UClass *TestClass) const
COREUOBJECT_API void *	GetInterfaceAddress (UClass *InterfaceClass)
COREUOBJECT_API void *	GetNativeInterfaceAddress (UClass *InterfaceClass)
const void *	GetNativeInterfaceAddress (UClass *InterfaceClass) const
COREUOBJECT_API bool	IsTemplateForSubobjects (EObjectFlags TemplateTypes=RF_ClassDefaultObject|RF_DefaultSubObject|RF_InheritableComponentTemplate) const
COREUOBJECT_API bool	IsDefaultSubobject () const
COREUOBJECT_API class FLinkerLoad *	GetLinker () const
COREUOBJECT_API int32	GetLinkerIndex () const
COREUOBJECT_API FPackageFileVersion	GetLinkerUEVersion () const
int32	GetLinkerUE4Version () const
COREUOBJECT_API int32	GetLinkerLicenseeUEVersion () const
int32	GetLinkerLicenseeUE4Version () const
COREUOBJECT_API int32	GetLinkerCustomVersion (FGuid CustomVersionKey) const
UE_FORCEINLINE_HINT bool	operator< (const UObjectBaseUtility &Other) const
TStatId	GetStatID (bool bForDeferredUse=false) const
Public Member Functions inherited from UObjectBase
COREUOBJECT_API	UObjectBase (UClass *InClass, EObjectFlags InFlags, EInternalObjectFlags InInternalFlags, UObject *InOuter, FName InName, int32 InInternalIndex=-1, int32 InSerialNumber=0, FRemoteObjectId InRemoteId=FRemoteObjectId())
virtual COREUOBJECT_API	~UObjectBase ()
COREUOBJECT_API bool	IsValidLowLevel () const
COREUOBJECT_API bool	IsValidLowLevelFast (bool bRecursive=true) const
FORCEINLINE uint32	GetUniqueID () const
FORCEINLINE UClass *	GetClass () const
FORCEINLINE UObject *	GetOuter () const
FORCEINLINE FName	GetFName () const
virtual COREUOBJECT_API FName	GetFNameForStatID () const
COREUOBJECT_API UPackage *	GetExternalPackage () const
COREUOBJECT_API void	SetExternalPackage (UPackage *InPackage)
COREUOBJECT_API UPackage *	GetExternalPackageInternal () const
COREUOBJECT_API void	MarkAsReachable () const
COREUOBJECT_API void	AddRef () const
COREUOBJECT_API void	ReleaseRef () const
FORCEINLINE EObjectFlags	GetFlags () const
FORCENOINLINE void	AtomicallySetFlags (EObjectFlags FlagsToAdd)
FORCENOINLINE void	AtomicallyClearFlags (EObjectFlags FlagsToClear)

Static Public Member Functions
static ENGINE_API bool	IsValid ()
static ENGINE_API bool	IsInitialized ()
static ENGINE_API UAssetManager &	Get ()
static ENGINE_API UAssetManager *	GetIfValid ()
static ENGINE_API UAssetManager *	GetIfInitialized ()
static FStreamableManager &	GetStreamableManager ()
static ENGINE_API FName	GetEncryptionKeyAssetTagName ()
static ENGINE_API FPrimaryAssetId	CreatePrimaryAssetIdFromChunkId (int32 ChunkId)
static ENGINE_API int32	ExtractChunkIdFromPrimaryAssetId (const FPrimaryAssetId &PrimaryAssetId)
static ENGINE_API void	CallOrRegister_OnCompletedInitialScan (FSimpleMulticastDelegate::FDelegate &&Delegate)
static ENGINE_API void	CallOrRegister_OnAssetManagerCreated (FSimpleMulticastDelegate::FDelegate &&Delegate)
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)
Static Public Member Functions inherited from UObject
static COREUOBJECT_API void	UpdateClassesExcludedFromDedicatedServer (const TArray< FString > &InClassNames, const TArray< FString > &InModulesNames)
static COREUOBJECT_API void	UpdateClassesExcludedFromDedicatedClient (const TArray< FString > &InClassNames, const TArray< FString > &InModulesNames)
static COREUOBJECT_API bool	CanCreateInCurrentContext (UObject *Template)
static COREUOBJECT_API void	AddReferencedObjects (UObject *InThis, FReferenceCollector &Collector)
static COREUOBJECT_API const FName &	SourceFileTagName ()
static COREUOBJECT_API UObject *	GetArchetypeFromRequiredInfo (const UClass *Class, const UObject *Outer, FName Name, EObjectFlags ObjectFlags)
Static Public Member Functions inherited from UObjectBaseUtility
static bool	IsGarbageEliminationEnabled ()
static bool	IsPendingKillEnabled ()
static void	SetGarbageEliminationEnabled (bool bEnabled)
static COREUOBJECT_API void	ReloadObjectsFromModifiedConfigSections (const class FConfigModificationTracker *ChangeTracker)
Static Public Member Functions inherited from UObjectBase
static COREUOBJECT_API FString	RemoveClassPrefix (const TCHAR *ClassName)
static void	PrefetchClass (UObject *Object)
static void	PrefetchOuter (UObject *Object)

Static Public Attributes
static ENGINE_API const FPrimaryAssetType	MapType = FName(TEXT("Map"))
static ENGINE_API const FPrimaryAssetType	PrimaryAssetLabelType = FName(TEXT("PrimaryAssetLabel"))
static ENGINE_API const FPrimaryAssetType	PackageChunkType = FName(TEXT("PackageChunk"))
static ENGINE_API const FPrimaryAssetType	SuppressionType = FName(TEXT("__Suppressed__"))
static ENGINE_API const FString	AssetSearchRootsVirtualPath = TEXT("$AssetSearchRoots")
static ENGINE_API const FString	DynamicSearchRootsVirtualPath = TEXT("$DynamicSearchRoots")

Protected Member Functions
virtual ENGINE_API void	StartBulkScanning ()
virtual ENGINE_API void	StopBulkScanning ()
bool	IsBulkScanning () const
ENGINE_API bool	GetPackageManagersInternal (FName PackageName, bool bUseCookRuleReferences, bool bRecurseToParents, TMap< FPrimaryAssetId, UE::AssetRegistry::EDependencyProperty > &Managers) const
virtual ENGINE_API void	GetAssetDataForPathInternal (IAssetRegistry &AssetRegistry, const FString &AssetPath, OUT FAssetData &OutAssetData) const
virtual ENGINE_API 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
virtual ENGINE_API void	OnObjectReferenceListInvalidated ()
ENGINE_API void	CallPreGarbageCollect ()
virtual ENGINE_API void	PreGarbageCollect ()
virtual void	OnAssetStateChangeCompleted (FPrimaryAssetId PrimaryAssetId, TSharedPtr< FStreamableHandle > BoundHandle, FStreamableDelegate WrappedDelegate)
virtual void	NotifyOnAssetStateChangeCompleted (const FPrimaryAssetId &PrimaryAssetId)
ENGINE_API void	OnAssetStateChangeCompleted (TSharedPtr< FStreamableHandle > BoundHandle, FPrimaryAssetId PrimaryAssetId)
virtual ENGINE_API void	ScanPrimaryAssetTypesFromConfig ()
virtual ENGINE_API void	ScanPrimaryAssetRulesFromConfig ()
virtual ENGINE_API bool	DoesPrimaryAssetMatchCustomOverride (FPrimaryAssetId PrimaryAssetId, const FPrimaryAssetRulesCustomOverride &CustomOverride) const
virtual ENGINE_API void	PostInitialAssetScan ()
virtual ENGINE_API bool	IsPathExcludedFromScan (const FString &Path) const
ENGINE_API bool	IsScanningFromInitialConfig () const
virtual ENGINE_API bool	ShouldIncludeInAssetSearch (const FAssetData &AssetData, const FAssetManagerSearchRules &SearchRules) const
virtual ENGINE_API void	AcquireChunkList (const TArray< int32 > &ChunkList, FAssetManagerAcquireResourceDelegate CompleteDelegate, EChunkPriority::Type Priority, TSharedPtr< FStreamableHandle > StalledHandle)
virtual ENGINE_API void	OnChunkDownloaded (uint32 ChunkId, bool bSuccess)
virtual TSharedPtr< FStreamableHandle >	LoadAssetListInternal (TArray< FSoftObjectPath > &&AssetList, FStreamableDelegateWithHandle &&DelegateToCall, TAsyncLoadPriority Priority, FString &&DebugName)
Protected Member Functions inherited from UObject
virtual FString	GetDetailedInfoInternal () const
COREUOBJECT_API bool	CanCheckDefaultSubObjects (bool bForceCheck, bool &bResult) const
virtual COREUOBJECT_API bool	CheckDefaultSubobjectsInternal () const
Protected Member Functions inherited from UObjectBase
	UObjectBase ()
COREUOBJECT_API	UObjectBase (EObjectFlags InFlags)
COREUOBJECT_API void	LowLevelRename (FName NewName, UObject *NewOuter=NULL)
virtual void	RegisterDependencies ()
COREUOBJECT_API void	Register (class UClass *(*StaticClassFn)(), const TCHAR *PackageName, const TCHAR *Name)
COREUOBJECT_API void	Register (const TCHAR *PackageName, const TCHAR *Name)
virtual COREUOBJECT_API void	DeferredRegister (UClass *UClassStaticClass, const TCHAR *PackageName, const TCHAR *Name)
FORCEINLINE void	SetFlagsTo (EObjectFlags NewFlags)

Protected Attributes
friend	FAssetManagerEditorModule
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
TSet< FPrimaryAssetId >	WarningInvalidAssets
TArray< FString >	AlreadyScannedDirectories
TArray< FString >	AllAssetSearchRoots
TArray< FString >	AddedAssetSearchRoots
FStreamableManager	StreamableManager
TArray< FPendingChunkInstall >	PendingChunkInstalls
TMap< FPrimaryAssetId, FGuid >	PrimaryAssetEncryptionKeyCache
TArray< TObjectPtr< UObject > >	ObjectReferenceList
bool	bIsGlobalAsyncScanEnvironment
bool	bShouldGuessTypeAndName
bool	bShouldUseSynchronousLoad
bool	bIsLoadingFromPakFiles
bool	bShouldAcquireMissingChunksOnLoad
bool	bOnlyCookProductionAssets
bool	bTargetPlatformsAllowDevelopmentObjects
bool	bObjectReferenceListDirty = true
int32	NumBulkScanRequests
bool	bIsPrimaryAssetDirectoryCurrent
bool	bIsManagementDatabaseCurrent
bool	bUpdateManagementDatabaseAfterScan
bool	bIncludeOnlyOnDiskAssets
bool	bHasCompletedInitialScan
int32	NumberOfSpawnedNotifications
TMap< FName, FName >	PrimaryAssetTypeRedirects
TMap< FString, FString >	PrimaryAssetIdRedirects
TMap< FSoftObjectPath, FSoftObjectPath >	AssetPathRedirects
FOnAddedAssetSearchRoot	OnAddedAssetSearchRootDelegate
FDelegateHandle	ChunkInstallDelegateHandle

Static Protected Attributes
static ENGINE_API FSimpleMulticastDelegate	OnCompletedInitialScanDelegate
static ENGINE_API FSimpleMulticastDelegate	OnAssetManagerCreatedDelegate

Additional Inherited Members
Public Types inherited from UObject
enum class	ENetFields_Private { NETFIELD_REP_START = 0 , NETFIELD_REP_END = -1 }
typedef UObject	WithinClass

Detailed Description

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

Constructor & Destructor Documentation

UAssetManager()

UAssetManager::UAssetManager

(

)

Constructor

Member Function Documentation

AcquireChunkList()

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

protectedvirtual

Call to start acquiring a list of chunks

AcquireResourcesForAssetList() [1/2]

void UAssetManager::AcquireResourcesForAssetList ( const TArray< FSoftObjectPath > &  AssetList, FAssetManagerAcquireResourceDelegate  CompleteDelegate, EChunkPriority::Type  Priority = EChunkPriority::Immediate  )

virtual

AcquireResourcesForAssetList() [2/2]

void UAssetManager::AcquireResourcesForAssetList ( const TArray< FSoftObjectPath > &  AssetList, FAssetManagerAcquireResourceDelegateEx  CompleteDelegate, EChunkPriority::Type  Priority = EChunkPriority::Immediate  )

virtual

Acquires a set of chunks using the platform chunk layer, then calls the passed in callback

Parameters

AssetList	Asset Paths to get resources for
CompleteDelegate	Delegate called when chunks have been acquired or failed. If any chunks fail the entire operation is considered a failure
Priority	Priority to use when acquiring chunks

AcquireResourcesForPrimaryAssetList()

void UAssetManager::AcquireResourcesForPrimaryAssetList ( const TArray< FPrimaryAssetId > &  PrimaryAssetList, FAssetManagerAcquireResourceDelegate  CompleteDelegate, EChunkPriority::Type  Priority = EChunkPriority::Immediate  )

virtual

Acquires a set of chunks using the platform chunk layer, then calls the passed in callback. This will download all bundles of a primary asset

Parameters

PrimaryAssetList	Primary assets to get chunks for
CompleteDelegate	Delegate called when chunks have been acquired or failed. If any chunks fail the entire operation is considered a failure
Priority	Priority to use when acquiring chunks

AddAssetSearchRoot()

void UAssetManager::AddAssetSearchRoot ( const FString &  NewRootPath )

virtual

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

AddDynamicAsset()

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

virtual

Adds or updates a Dynamic asset, which is a runtime-specified asset that has no on disk representation, so has no FAssetData. But it can have bundle state and a path.

Parameters

FPrimaryAssetId	Type/Name of the asset. The type info will be created if it doesn't already exist
AssetPath	Path to the object representing this asset, this is optional for dynamic assets
BundleData	List of Name->asset paths that represent the possible bundle states for this asset

Returns

True if added

ApplyCustomPrimaryAssetRulesOverride()

void UAssetManager::ApplyCustomPrimaryAssetRulesOverride ( const FPrimaryAssetRulesCustomOverride &  CustomOverride )

virtual

Apply a single custom primary asset rule, calls function below

BeginDestroy()

void UAssetManager::BeginDestroy ( )

overridevirtual

Called before destroying the object. This is called immediately upon deciding to destroy the object, to allow the object to begin an asynchronous cleanup process.

Reimplemented from UObject.

CallOrRegister_OnAssetManagerCreated()

void UAssetManager::CallOrRegister_OnAssetManagerCreated ( FSimpleMulticastDelegate::FDelegate &&  Delegate )

static

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

CallOrRegister_OnCompletedInitialScan()

void UAssetManager::CallOrRegister_OnCompletedInitialScan ( FSimpleMulticastDelegate::FDelegate &&  Delegate )

static

Register a delegate to call when all types are scanned at startup, if this has already happened call immediately

CallPreGarbageCollect()

void UAssetManager::CallPreGarbageCollect ( )

protected

ChangeBundleStateForMatchingPrimaryAssets() [1/2]

TSharedPtr< FStreamableHandle > UAssetManager::ChangeBundleStateForMatchingPrimaryAssets ( const TArray< FName > &  NewBundles, const TArray< FName > &  OldBundles, FAssetManagerLoadParams &&  LoadParams, UE::FSourceLocation  Location = UE::FSourceLocation::Current()  )

virtual

Changes the bundle state of all loaded primary assets. Only assets matching OldBundles will be modified You can wait on the returned streamable request or poll as needed. If there is no work to do, returned handle will be null and delegate will get called.

Parameters

NewBundles	New bundle state for the assets that are changed
OldBundles	Old bundle state, it will remove these bundles and replace with NewBundles
LoadParams	Contains callbacks and async load priority
Location	[optional] Is not intended for direct use, the parameter catches call site source location and passes it down to the streaming manager. See FStreamingManager.

Returns

Streamable Handle that can be used to poll or wait. You do not need to keep this handle to stop the assets from being unloaded

ChangeBundleStateForMatchingPrimaryAssets() [2/2]

TSharedPtr< FStreamableHandle > UAssetManager::ChangeBundleStateForMatchingPrimaryAssets ( const TArray< FName > &  NewBundles, const TArray< FName > &  OldBundles, FStreamableDelegate  DelegateToCall = FStreamableDelegate(), TAsyncLoadPriority  Priority = FStreamableManager::DefaultAsyncLoadPriority, UE::FSourceLocation  Location = UE::FSourceLocation::Current()  )

inlinevirtual

Changes the bundle state of all loaded primary assets. Only assets matching OldBundles will be modified You can wait on the returned streamable request or poll as needed. If there is no work to do, returned handle will be null and delegate will get called. Prefer the overloads with Param structs for new code.

Parameters

NewBundles	New bundle state for the assets that are changed
OldBundles	Old bundle state, it will remove these bundles and replace with NewBundles
DelegateToCall	[optional] Delegate that will be called on completion
Priority	[optional] Async loading priority for this request
Location	[optional] Is not intended for direct use, the parameter catches call site source location and passes it down to the streaming manager. See FStreamingManager.

Returns

Streamable Handle that can be used to poll or wait. You do not need to keep this handle to stop the assets from being unloaded

ChangeBundleStateForPrimaryAssets() [1/2]

TSharedPtr< FStreamableHandle > UAssetManager::ChangeBundleStateForPrimaryAssets ( const TArray< FPrimaryAssetId > &  AssetsToChange, const TArray< FName > &  AddBundles, const TArray< FName > &  RemoveBundles, bool  bRemoveAllBundles, FAssetManagerLoadParams &&  LoadParams, UE::FSourceLocation  Location = UE::FSourceLocation::Current()  )

virtual

Changes the bundle state of a set of loaded primary assets. You can wait on the returned streamable request or poll as needed. If there is no work to do, returned handle will be null and delegate will get called.

Parameters

AssetsToChange	List of primary assets to change state of
AddBundles	List of bundles to add
RemoveBundles	Explicit list of bundles to remove
RemoveAllBundles	If true, remove all existing bundles even if not in remove list
LoadParams	Contains callbacks and async load priority
Location	[optional] Is not intended for direct use, the parameter catches call site source location and passes it down to the streaming manager. See FStreamingManager.

Returns

Streamable Handle that can be used to poll or wait. You do not need to keep this handle to stop the assets from being unloaded

ChangeBundleStateForPrimaryAssets() [2/2]

TSharedPtr< FStreamableHandle > UAssetManager::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()  )

inlinevirtual

Changes the bundle state of a set of loaded primary assets. You can wait on the returned streamable request or poll as needed. If there is no work to do, returned handle will be null and delegate will get called. Prefer the overloads with Param structs for new code.

Parameters

AssetsToChange	List of primary assets to change state of
AddBundles	List of bundles to add
RemoveBundles	Explicit list of bundles to remove
RemoveAllBundles	[optional] If true, remove all existing bundles even if not in remove list
DelegateToCall	[optional] Delegate that will be called on completion
Priority	[optional] Async loading priority for this request
Location	[optional] Is not intended for direct use, the parameter catches call site source location and passes it down to the streaming manager. See FStreamingManager.

Returns

Streamable Handle that can be used to poll or wait. You do not need to keep this handle to stop the assets from being unloaded

CreatePrimaryAssetIdFromChunkId()

FPrimaryAssetId UAssetManager::CreatePrimaryAssetIdFromChunkId ( int32  ChunkId )

static

Creates a PrimaryAssetId from a chunk id

DeterminePrimaryAssetIdForObject()

FPrimaryAssetId UAssetManager::DeterminePrimaryAssetIdForObject ( const UObject *  Object ) const

virtual

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. Games can override the behavior here or call it from other places

DoesAssetMatchSearchRules()

bool UAssetManager::DoesAssetMatchSearchRules ( const FAssetData &  AssetData, const FAssetManagerSearchRules &  Rules  ) const

virtual

Helper function to check if a single asset passes restrictions in SearchRules, this can be used when an asset is manually registered

DoesPrimaryAssetMatchCustomOverride()

bool UAssetManager::DoesPrimaryAssetMatchCustomOverride ( FPrimaryAssetId  PrimaryAssetId, const FPrimaryAssetRulesCustomOverride &  CustomOverride  ) const

protectedvirtual

Sees if a specific primary asset passes the custom override filter, subclass this to handle FilterString

DownloadAssetList() [1/2]

TSharedPtr< FStreamableHandle > UAssetManager::DownloadAssetList ( const TArray< FSoftObjectPath > &  AssetList, FAssetManagerLoadParams &&  LoadParams, FString &&  DebugName = FString(TEXT("DownloadAssetList")), UE::FSourceLocation &&  Location = UE::FSourceLocation::Current()  )

inline

Download non primary assets with the primary streamable manager. Does not load assets after downloading. This will not auto release the handle, release it if needed.

Parameters

AssetList	List of non primary assets to load
LoadParams	Contains callbacks and async load priority
DebugName	[optional] Name of this handle, either FString or anything that can construct FString, will be reported in debug tools, will report Source Location if DebugName is not specified explicitly
Location	[optional] Is not intended for direct use, the parameter catches call site source location and passes it down to the streaming manager. See FStreamingManager.

Returns

Streamable Handle that must be stored to keep the preloaded assets from being freed

DownloadAssetList() [2/2]

TSharedPtr< FStreamableHandle > UAssetManager::DownloadAssetList	(	TArray< FSoftObjectPath > &&	AssetList,
		FAssetManagerLoadParams &&	LoadParams,
		FString &&	DebugName = FString(TEXT("DownloadAssetList")),
		UE::FSourceLocation &&	Location = UE::FSourceLocation::Current()
	)

rvalue reference overload for Asset List

DumpAssetRegistryInfo()

void UAssetManager::DumpAssetRegistryInfo ( )

static

Dumps information about the Asset Registry to log

DumpAssetTypeSummary()

void UAssetManager::DumpAssetTypeSummary ( )

static

Dumps out summary of managed types to log

DumpBundlesForAsset()

void UAssetManager::DumpBundlesForAsset ( const TArray< FString > &  Args )

static

Shows a list of all bundles for the specified primary asset by primary asset id (i.e. Map:Entry)

DumpLoadedAssetState()

void UAssetManager::DumpLoadedAssetState ( )

static

Dumps out list of loaded asset bundles to log

DumpReferencersForPackage()

void UAssetManager::DumpReferencersForPackage ( const TArray< FString > &  PackageNames )

static

Dumps out list of primary asset -> managed assets to log

ExpandVirtualPaths()

bool UAssetManager::ExpandVirtualPaths ( TArray< FString > &  InOutPaths ) const

virtual

Expands a list of paths that potentially use virtual paths into real directory and package paths. Returns true if any changes were made

ExtractChunkIdFromPrimaryAssetId()

int32 UAssetManager::ExtractChunkIdFromPrimaryAssetId ( const FPrimaryAssetId &  PrimaryAssetId )

static

Extracts a chunk id from a primary asset id, returns INDEX_NONE if it is not PackageChunkType

ExtractPrimaryAssetIdFromData()

FPrimaryAssetId UAssetManager::ExtractPrimaryAssetIdFromData ( const FAssetData &  AssetData, FPrimaryAssetType  SuggestedType = FPrimaryAssetType()  ) const

virtual

Parses AssetData to extract the primary type/name from it. This works even if it isn't in the directory

ExtractSoftObjectPaths()

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

virtual

Extracts all FSoftObjectPaths from a Class/Struct

FindMissingChunkList()

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

virtual

Returns the list of Chunks that are not currently mounted, and are required to load the referenced assets. Returns true if any chunks are missing

Parameters

AssetList	Asset Paths to check chunks for
OutMissingChunkList	Chunks that are known about but not yet installed
OutErrorChunkList	Chunks that do not exist at all and are not installable

FinishInitialLoading()

void UAssetManager::FinishInitialLoading ( )

virtual

Finishes initial loading, gets called from end of Engine::Init()

Get()

UAssetManager & UAssetManager::Get ( )

static

Returns the current AssetManager object

GetAllReferencersForPackage()

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

static

Finds all the referencers for a set of packages. Recursively will get all the referencers up to the max depth

GetAssetBundleEntries()

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

virtual

Appends all AssetBundleInfos inside a given scope

GetAssetBundleEntry()

FAssetBundleEntry UAssetManager::GetAssetBundleEntry ( const FPrimaryAssetId &  BundleScope, FName  BundleName  ) const

virtual

Returns a single AssetBundleInfo, matching Scope and Name

GetAssetDataForPath()

bool UAssetManager::GetAssetDataForPath ( const FSoftObjectPath &  ObjectPath, FAssetData &  AssetData  ) const

virtual

Gets the FAssetData at a specific path, handles redirectors and blueprint classes correctly. Returns true if it found a valid data

GetAssetDataForPathInternal()

void UAssetManager::GetAssetDataForPathInternal ( IAssetRegistry &  AssetRegistry, const FString &  AssetPath, OUT FAssetData &  OutAssetData  ) const

protectedvirtual

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

GetAssetPathForData()

FSoftObjectPath UAssetManager::GetAssetPathForData ( const FAssetData &  AssetData ) const

virtual

Turns an FAssetData into FSoftObjectPath, handles adding _C as necessary

GetAssetRegistry()

IAssetRegistry & UAssetManager::GetAssetRegistry

(

)

const

Accessor for asset registry

GetAssetSearchRoots()

const TArray< FString > & UAssetManager::GetAssetSearchRoots

(

bool

bIncludeDefaultRoots = true

)

const

Returns all the game asset roots, includes /Game by default and any dynamic ones

GetCachedPrimaryAssetEncryptionKeyGuid()

void UAssetManager::GetCachedPrimaryAssetEncryptionKeyGuid ( FPrimaryAssetId  InPrimaryAssetId, FGuid &  OutGuid  )

virtual

Get the encryption key guid attached to this primary asset. Can be invalid if the asset is not encrypted

GetContentRootPathFromPackageName()

bool UAssetManager::GetContentRootPathFromPackageName ( const FString &  PackageName, FString &  OutContentRootPath  )

static

Returns the root path for the package name or path (i.e. /Game/MyPackage would return /Game/ ). This works even if the root is not yet mounted

GetEncryptionKeyAssetTagName()

FName UAssetManager::GetEncryptionKeyAssetTagName ( )

static

Get the asset registry tag name for encryption key data

GetIfInitialized()

UAssetManager * UAssetManager::GetIfInitialized ( )

static

Returns the current global singleton AssetManager if it has been constructed, null otherwise

GetIfValid()

UAssetManager * UAssetManager::GetIfValid ( )

static

GetManagedPackageList()

bool UAssetManager::GetManagedPackageList ( FPrimaryAssetId  PrimaryAssetId, TArray< FName > &  AssetPackageList  ) const

virtual

Returns list of asset packages managed by primary asset

GetNameData() [1/2]

FPrimaryAssetData * UAssetManager::GetNameData ( const FPrimaryAssetId &  PrimaryAssetId, bool  bCheckRedirector = true  )

protected

Returns the NameData for a specific type/name pair

GetNameData() [2/2]

const FPrimaryAssetData * UAssetManager::GetNameData ( const FPrimaryAssetId &  PrimaryAssetId, bool  bCheckRedirector = true  ) const

protected

GetNormalizedPackagePath()

FString UAssetManager::GetNormalizedPackagePath ( const FString &  InPath, bool  bIncludeFinalSlash  )

static

GetPackageCookRuleManagers()

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

virtual

Returns PrimaryAssetIds that manage whether a package is included in the cook, with property describing the reference (direct or indirect).

GetPackageManagers() [1/2]

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

virtual

Returns PrimaryAssetIds that manage a package in any way, either chunk assignment or inclusion in the cook. Chunk assignments are a superset of inclusion in the cook assignments, so this is a supserset of GetPackageCookRuleManagers. Includes property describing the reference (direct or indirect, and cookrule or not).

GetPackageManagers() [2/2]

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

virtual

Returns just the keys of the TMap returned from GetPackageManagers that takes a TMap&.

GetPackageManagersInternal()

bool UAssetManager::GetPackageManagersInternal ( FName  PackageName, bool  bUseCookRuleReferences, bool  bRecurseToParents, TMap< FPrimaryAssetId, UE::AssetRegistry::EDependencyProperty > &  Managers  ) const

protected

GetPakChunkIdToStringMapping() [1/2]

virtual void UAssetManager::GetPakChunkIdToStringMapping ( const FString &  PlatformName, TMap< int32, FString > &  ChunkIdStringOverride  )

inlinevirtual

GetPakChunkIdToStringMapping() [2/2]

virtual void UAssetManager::GetPakChunkIdToStringMapping ( TMap< int32, FString > &  ChunkIdStringOverride )

inlinevirtual

Allows the asset manager to override the chunkID to be a string rather than integer value. Used at cook time and runtime to determine how to map chunkids to the potential string override. This does not update the internal asset registry number only the generated pak chunk file name. The AssetRegistryGenerator will request this mapping during Chunk Generation time. All strings must be be alpha numeric with no spaces.

When overriding it's recommended to setup PlatformChunk mapping via the InstallBundle rules. When a pak chunk does not have a parseable number the default platform chunk will be 0 unless InstallBundle rules override that.

Parameters

ChunkIdStringOverride

- Out parameter for the override information of a chunkID to string.

GetPakStringToChunkIdMapping()

void UAssetManager::GetPakStringToChunkIdMapping

(

TMap< FString, int32 > &

StringOverrideToChunkId

)

Helper to make it easy to get the ChunkId based on the string override for a pakchunk. see "GetPakChunkIdToStringMapping" for more information

Parameters

ChunkIdStringOverride

- Out parameter for getting the chunkID based on the string override.

GetPreviousPrimaryAssetIds()

void UAssetManager::GetPreviousPrimaryAssetIds ( const FPrimaryAssetId &  NewId, TArray< FPrimaryAssetId > &  OutOldIds  ) const

virtual

Reads redirector list and gets a list of the redirected previous names for a Primary Asset Id

GetPrimaryAssetBundleStateMap()

void UAssetManager::GetPrimaryAssetBundleStateMap	(	TMap< FPrimaryAssetId, TArray< FName > > &	BundleStateMap,
		bool	bForceCurrent = false
	)		const

Fills in a TMap with the pending/active loading state of every asset

GetPrimaryAssetData()

bool UAssetManager::GetPrimaryAssetData ( const FPrimaryAssetId &  PrimaryAssetId, FAssetData &  AssetData  ) const

virtual

Gets the FAssetData for a primary asset with the specified type/name, will only work for once that have been scanned for already. Returns true if it found a valid data

GetPrimaryAssetDataList()

bool UAssetManager::GetPrimaryAssetDataList ( FPrimaryAssetType  PrimaryAssetType, TArray< FAssetData > &  AssetDataList  ) const

virtual

Gets list of all FAssetData for a primary asset type, returns true if any were found

GetPrimaryAssetHandle()

TSharedPtr< FStreamableHandle > UAssetManager::GetPrimaryAssetHandle	(	const FPrimaryAssetId &	PrimaryAssetId,
		bool	bForceCurrent = false,
		TArray< FName > *	Bundles = nullptr
	)		const

Returns the loading handle associated with the primary asset, it can then be checked for progress or waited on

Parameters

PrimaryAssetId	Asset to get handle for
bForceCurrent	If true, returns the current handle. If false, will return pending if active, or current if not
Bundles	If not null, will fill in with a list of the requested bundle state

Returns

Streamable Handle that can be used to poll or wait

GetPrimaryAssetIdForData()

FPrimaryAssetId UAssetManager::GetPrimaryAssetIdForData ( const FAssetData &  AssetData ) const

virtual

Returns the primary asset Id for the given FAssetData, only works if in directory

GetPrimaryAssetIdForObject()

FPrimaryAssetId UAssetManager::GetPrimaryAssetIdForObject ( UObject *  Object ) const

virtual

Sees if the passed in object is a registered primary asset, if so return it. Returns invalid Identifier if not found

GetPrimaryAssetIdForPackage()

FPrimaryAssetId UAssetManager::GetPrimaryAssetIdForPackage ( FName  PackagePath ) const

virtual

Sees if the package has a primary asset, useful if only the package name is available

GetPrimaryAssetIdForPath()

FPrimaryAssetId UAssetManager::GetPrimaryAssetIdForPath ( const FSoftObjectPath &  ObjectPath ) const

virtual

Sees if the passed in object path is a registered primary asset, if so return it. Returns invalid Identifier if not found

GetPrimaryAssetIdList()

bool UAssetManager::GetPrimaryAssetIdList ( FPrimaryAssetType  PrimaryAssetType, TArray< FPrimaryAssetId > &  PrimaryAssetIdList, EAssetManagerFilter  Filter = EAssetManagerFilter::Default  ) const

virtual

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

GetPrimaryAssetLoadList()

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

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

Parameters

OutAssetLoadList	TArray that will have asset paths added to it
PrimaryAssetId	Asset that would be loaded
LoadBundles	List of bundles to load for those assets
bLoadRecursive	If true, this will call RecursivelyExpandBundleData and recurse into sub bundles of other primary assets loaded by a bundle reference
bEnsureUniqueness	Only unique items will be inserted in OutAssetLoadList

Returns

True if primary asset id was found

GetPrimaryAssetLoadSet()

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

Fills in a set of object paths with the assets that need to be loaded, for a given Primary Asset and bundle list. Prefer to use GetPrimaryAssetLoadList instead, because this overload creates additional allocation and is here just for backward compatibility.

Parameters

OutAssetLoadSet	Set that will have asset paths added to it
PrimaryAssetId	Asset that would be loaded
LoadBundles	List of bundles to load for those assets
bLoadRecursive	If true, this will call RecursivelyExpandBundleData and recurse into sub bundles of other primary assets loaded by a bundle reference

Returns

True if primary asset id was found

GetPrimaryAssetObject() [1/2]

UObject * UAssetManager::GetPrimaryAssetObject ( const FPrimaryAssetId &  PrimaryAssetId ) const

virtual

Gets the in-memory UObject for a primary asset id, returning nullptr if it's not in memory. Will return blueprint class for blueprint assets. This works even if the asset wasn't loaded explicitly

GetPrimaryAssetObject() [2/2]

template<class AssetType >

AssetType * UAssetManager::GetPrimaryAssetObject ( const FPrimaryAssetId &  PrimaryAssetId ) const

inline

Templated versions of above

GetPrimaryAssetObjectClass()

template<class AssetType >

TSubclassOf< AssetType > UAssetManager::GetPrimaryAssetObjectClass ( const FPrimaryAssetId &  PrimaryAssetId ) const

inline

GetPrimaryAssetObjectList()

bool UAssetManager::GetPrimaryAssetObjectList ( FPrimaryAssetType  PrimaryAssetType, TArray< UObject * > &  ObjectList  ) const

virtual

Gets list of all loaded objects for a primary asset type, returns true if any were found. Will return blueprint class for blueprint assets. This works even if the asset wasn't loaded explicitly

GetPrimaryAssetPath()

FSoftObjectPath UAssetManager::GetPrimaryAssetPath ( const FPrimaryAssetId &  PrimaryAssetId ) const

virtual

Gets the FSoftObjectPath for a primary asset type and name, returns invalid if not found

GetPrimaryAssetPathList()

bool UAssetManager::GetPrimaryAssetPathList ( FPrimaryAssetType  PrimaryAssetType, TArray< FSoftObjectPath > &  AssetPathList  ) const

virtual

Gets the list of all FSoftObjectPaths for a given type, returns true if any found

GetPrimaryAssetRules()

FPrimaryAssetRules UAssetManager::GetPrimaryAssetRules ( FPrimaryAssetId  PrimaryAssetId ) const

virtual

Gets the management rules for a specific asset, this will merge the type and individual values

GetPrimaryAssetsWithBundleState()

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

Returns a list of primary assets that are in the given bundle state. Only assets that are loaded or being loaded are valid

Parameters

PrimaryAssetList	Any valid assets are added to this list
ValidTypes	List of types that are allowed. If empty, all types allowed
RequiredBundles	Adds to list if the bundle state has all of these bundles. If empty will return all loaded
ExcludedBundles	Doesn't add if the bundle state has any of these bundles
bForceCurrent	If true, only use the current state. If false, use the current or pending

Returns

True if any found

GetPrimaryAssetTypeInfo()

bool UAssetManager::GetPrimaryAssetTypeInfo ( FPrimaryAssetType  PrimaryAssetType, FPrimaryAssetTypeInfo &  AssetTypeInfo  ) const

virtual

Gets metadata for a specific asset type, returns false if not found

GetPrimaryAssetTypeInfoList()

void UAssetManager::GetPrimaryAssetTypeInfoList ( TArray< FPrimaryAssetTypeInfo > &  AssetTypeInfoList ) const

virtual

Gets list of all primary asset types infos

GetRedirectedAssetPath()

FSoftObjectPath UAssetManager::GetRedirectedAssetPath ( const FSoftObjectPath &  OldPath ) const

virtual

Reads AssetManagerSettings for specifically redirected asset paths. This is useful if you need to convert older saved data

GetRedirectedPrimaryAssetId()

FPrimaryAssetId UAssetManager::GetRedirectedPrimaryAssetId ( const FPrimaryAssetId &  OldId ) const

virtual

Tries to redirect a Primary Asset Id, using list in AssetManagerSettings

GetResourceAcquireProgress()

bool UAssetManager::GetResourceAcquireProgress ( int32 &  OutAcquiredCount, int32 &  OutRequestedCount  ) const

virtual

Returns the chunk download/install progress. AcquiredCount is the number of chunks that were requested and have already been insatlled, Requested includes both installed and pending

GetSettings()

const UAssetManagerSettings & UAssetManager::GetSettings

(

)

const

Return settings object

GetStreamableManager()

static FStreamableManager & UAssetManager::GetStreamableManager ( )

inlinestatic

Accesses the StreamableManager used by this Asset Manager. Static for easy access

GetTimerManager()

FTimerManager * UAssetManager::GetTimerManager

(

)

const

Returns a timer manager that is safe to use for asset loading actions. This will either be the editor or game instance one, or null during very early startup

HasInitialScanCompleted()

bool UAssetManager::HasInitialScanCompleted ( ) const

virtual

Returns true if initial scan has completed, this can be pretty late in editor builds

InvalidatePrimaryAssetDirectory()

void UAssetManager::InvalidatePrimaryAssetDirectory ( )

virtual

Invalidate cached asset data so it knows to rescan when needed

IsAssetDataBlueprintOfClassSet()

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

virtual

Checks to see if the given asset data is a blueprint with a base class in the ClassNameSet. This checks the parent asset tag

IsBulkScanning()

bool UAssetManager::IsBulkScanning ( ) const

inlineprotected

IsInitialized()

bool UAssetManager::IsInitialized ( )

static

Returns true if the global singleton AssetManager has been constructed.

IsPathExcludedFromScan()

bool UAssetManager::IsPathExcludedFromScan ( const FString &  Path ) const

protectedvirtual

Returns true if path should be excluded from primary asset scans, called from ShouldIncludeInAssetSearch and in the editor

IsScanningFromInitialConfig()

bool UAssetManager::IsScanningFromInitialConfig ( ) const

protected

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

IsValid()

bool UAssetManager::IsValid ( )

static

LoadAssetList() [1/4]

TSharedPtr< FStreamableHandle > UAssetManager::LoadAssetList ( const TArray< FSoftObjectPath > &  AssetList, FAssetManagerLoadParams &&  LoadParams, FString &&  DebugName = FString(TEXT("LoadAssetList")), UE::FSourceLocation &&  Location = UE::FSourceLocation::Current()  )

inline

lvalue reference overload to load non primary assets with the primary streamable manager. This will not auto release the handle, release it if needed. Prefer using rvalue reference version as it will not create an extra copy of your input array.

Parameters

AssetList	List of non primary assets to load
LoadParams	Contains callbacks and async load priority
DebugName	[optional] Name of this handle, either FString or anything that can construct FString, will be reported in debug tools, will report Source Location if DebugName is not specified explicitly
Location	[optional] Is not intended for direct use, the parameter catches call site source location and passes it down to the streaming manager. See FStreamingManager.

Returns

Streamable Handle that must be stored to keep the preloaded assets from being freed

LoadAssetList() [2/4]

TSharedPtr< FStreamableHandle > UAssetManager::LoadAssetList ( const TArray< FSoftObjectPath > &  AssetList, FStreamableDelegate  DelegateToCall = FStreamableDelegate(), TAsyncLoadPriority  Priority = FStreamableManager::DefaultAsyncLoadPriority, FString &&  DebugName = FString(TEXT("LoadAssetList")), UE::FSourceLocation &&  Location = UE::FSourceLocation::Current()  )

inline

Load non primary assets with the primary streamable manager. This will not auto release the handle, release it if needed. Prefer the overloads with Param structs for new code.

Parameters

AssetList	List of non primary assets to load
DelegateToCall	[optional] Delegate that will be called on completion
Priority	[optional] Async loading priority for this request
DebugName	[optional] Name of this handle, either FString or anything that can construct FString, will be reported in debug tools, will report Source Location if DebugName is not specified explicitly
Location	[optional] Is not intended for direct use, the parameter catches call site source location and passes it down to the streaming manager. See FStreamingManager.

Returns

Streamable Handle that must be stored to keep the preloaded assets from being freed

LoadAssetList() [3/4]

TSharedPtr< FStreamableHandle > UAssetManager::LoadAssetList ( TArray< FSoftObjectPath > &&  AssetList, FAssetManagerLoadParams &&  LoadParams, FString &&  DebugName = FString(TEXT("LoadAssetList")), UE::FSourceLocation &&  Location = UE::FSourceLocation::Current()  )

virtual

Load non primary assets with the primary streamable manager. This will not auto release the handle, release it if needed. This is a entry point for the set of overloads. Overide it to have your custom behavior.

Parameters

AssetList	List of non primary assets to load
LoadParams	Contains callbacks and async load priority
DebugName	[optional] Name of this handle, either FString or anything that can construct FString, will be reported in debug tools, will report Source Location if DebugName is not specified explicitly
Location	[optional] Is not intended for direct use, the parameter catches call site source location and passes it down to the streaming manager. See FStreamingManager.

Returns

Streamable Handle that must be stored to keep the preloaded assets from being freed

LoadAssetList() [4/4]

TSharedPtr< FStreamableHandle > UAssetManager::LoadAssetList ( TArray< FSoftObjectPath > &&  AssetList, FStreamableDelegate  DelegateToCall = FStreamableDelegate(), TAsyncLoadPriority  Priority = FStreamableManager::DefaultAsyncLoadPriority, FString &&  DebugName = FString(TEXT("LoadAssetList")), UE::FSourceLocation &&  Location = UE::FSourceLocation::Current()  )

inline

rvalue reference overload for Asset List

LoadAssetListInternal()

virtual TSharedPtr< FStreamableHandle > UAssetManager::LoadAssetListInternal ( TArray< FSoftObjectPath > &&  AssetList, FStreamableDelegateWithHandle &&  DelegateToCall, TAsyncLoadPriority  Priority, FString &&  DebugName  )

inlineprotectedvirtual

Called to load asset list

LoadPrimaryAsset() [1/2]

TSharedPtr< FStreamableHandle > UAssetManager::LoadPrimaryAsset ( const FPrimaryAssetId &  AssetToLoad, const TArray< FName > &  LoadBundles, FAssetManagerLoadParams &&  LoadParams, UE::FSourceLocation  Location = UE::FSourceLocation::Current()  )

virtual

Single asset wrapper, see LoadPrimaryAssets

LoadPrimaryAsset() [2/2]

TSharedPtr< FStreamableHandle > UAssetManager::LoadPrimaryAsset ( const FPrimaryAssetId &  AssetToLoad, const TArray< FName > &  LoadBundles = TArray<FName>(), FStreamableDelegate  DelegateToCall = FStreamableDelegate(), TAsyncLoadPriority  Priority = FStreamableManager::DefaultAsyncLoadPriority, UE::FSourceLocation  Location = UE::FSourceLocation::Current()  )

inlinevirtual

Single asset wrapper, see LoadPrimaryAssets

LoadPrimaryAssets() [1/2]

TSharedPtr< FStreamableHandle > UAssetManager::LoadPrimaryAssets ( const TArray< FPrimaryAssetId > &  AssetsToLoad, const TArray< FName > &  LoadBundles, FAssetManagerLoadParams &&  LoadParams, UE::FSourceLocation  Location = UE::FSourceLocation::Current()  )

virtual

Loads a list of Primary Assets. This will start an async load of those assets, calling callback on completion. These assets will stay in memory until explicitly unloaded. You can wait on the returned streamable request or poll as needed. If there is no work to do, returned handle will be null and complete delegate will get called.

Parameters

AssetsToLoad	List of primary assets to load
LoadBundles	List of bundles to load for those assets
LoadParams	Contains callbacks and async load priority
Location	[optional] Is not intended for direct use, the parameter catches call site source location and passes it down to the streaming manager. See FStreamingManager.

Returns

Streamable Handle that can be used to poll or wait. You do not need to keep this handle to stop the assets from being unloaded

LoadPrimaryAssets() [2/2]

TSharedPtr< FStreamableHandle > UAssetManager::LoadPrimaryAssets ( const TArray< FPrimaryAssetId > &  AssetsToLoad, const TArray< FName > &  LoadBundles = TArray<FName>(), FStreamableDelegate  DelegateToCall = FStreamableDelegate(), TAsyncLoadPriority  Priority = FStreamableManager::DefaultAsyncLoadPriority, UE::FSourceLocation  Location = UE::FSourceLocation::Current()  )

inlinevirtual

Loads a list of Primary Assets. This will start an async load of those assets, calling callback on completion. These assets will stay in memory until explicitly unloaded. You can wait on the returned streamable request or poll as needed. If there is no work to do, returned handle will be null and delegate will get called. Prefer the overloads with Param structs for new code.

Parameters

AssetsToLoad	List of primary assets to load
LoadBundles	List of bundles to load for those assets
DelegateToCall	Delegate that will be called on completion
Priority	Async loading priority for this request
Location	[optional] Is not intended for direct use, the parameter catches call site source location and passes it down to the streaming manager. See FStreamingManager.

Returns

Streamable Handle that can be used to poll or wait. You do not need to keep this handle to stop the assets from being unloaded

LoadPrimaryAssetsWithType() [1/2]

TSharedPtr< FStreamableHandle > UAssetManager::LoadPrimaryAssetsWithType ( FPrimaryAssetType  PrimaryAssetType, const TArray< FName > &  LoadBundles, FAssetManagerLoadParams &&  LoadParams, UE::FSourceLocation  Location = UE::FSourceLocation::Current()  )

virtual

Loads all assets of a given type, useful for cooking

LoadPrimaryAssetsWithType() [2/2]

TSharedPtr< FStreamableHandle > UAssetManager::LoadPrimaryAssetsWithType ( FPrimaryAssetType  PrimaryAssetType, const TArray< FName > &  LoadBundles = TArray<FName>(), FStreamableDelegate  DelegateToCall = FStreamableDelegate(), TAsyncLoadPriority  Priority = FStreamableManager::DefaultAsyncLoadPriority, UE::FSourceLocation  Location = UE::FSourceLocation::Current()  )

inlinevirtual

Loads all assets of a given type, useful for cooking

LoadRedirectorMaps()

void UAssetManager::LoadRedirectorMaps ( )

virtual

Loads the redirector maps

NormalizePackagePath()

void UAssetManager::NormalizePackagePath ( FString &  InOutPath, bool  bIncludeFinalSlash  )

static

Normalize a package path for use in asset manager, will remove duplicate // and add or remove a final slash as desired

NotifyOnAssetStateChangeCompleted()

virtual void UAssetManager::NotifyOnAssetStateChangeCompleted ( const FPrimaryAssetId &  PrimaryAssetId )

inlineprotectedvirtual

Called when an internal load handle finishes

OnAssetRegistryAvailableAfterInitialization()

bool UAssetManager::OnAssetRegistryAvailableAfterInitialization ( FName  InName, FAssetRegistryState &  OutNewState  )

virtual

Called when a new asset registry becomes available

Parameters

InName

Logical name for this asset registry. Must match the name returned by GetUniqueAssetRegistryName

Returns

TRUE if new data was loaded and added into the master asset registry

OnAssetStateChangeCompleted() [1/2]

virtual void UAssetManager::OnAssetStateChangeCompleted ( FPrimaryAssetId  PrimaryAssetId, TSharedPtr< FStreamableHandle >  BoundHandle, FStreamableDelegate  WrappedDelegate  )

inlineprotectedvirtual

Called when an internal load handle finishes, handles setting to pending state

OnAssetStateChangeCompleted() [2/2]

void UAssetManager::OnAssetStateChangeCompleted ( TSharedPtr< FStreamableHandle >  BoundHandle, FPrimaryAssetId  PrimaryAssetId  )

protected

Called when an internal load handle finishes, handles setting to pending state

OnChunkDownloaded()

void UAssetManager::OnChunkDownloaded ( uint32  ChunkId, bool  bSuccess  )

protectedvirtual

Called when a new chunk has been downloaded

OnObjectReferenceListInvalidated()

void UAssetManager::OnObjectReferenceListInvalidated ( )

protectedvirtual

PopBulkScanning()

void UAssetManager::PopBulkScanning

(

)

PostInitialAssetScan()

void UAssetManager::PostInitialAssetScan ( )

protectedvirtual

Called after scanning is complete, either from FinishInitialLoading or after the AssetRegistry finishes

PostInitProperties()

void UAssetManager::PostInitProperties ( )

overridevirtual

Called after the C++ constructor and after the properties have been initialized, including those loaded from config. This is called before any serialization or other setup has happened.

Reimplemented from UObject.

PredownloadPrimaryAssets()

TSharedPtr< FStreamableHandle > UAssetManager::PredownloadPrimaryAssets ( const TArray< FPrimaryAssetId > &  AssetsToLoad, const TArray< FName > &  LoadBundles, bool  bLoadRecursive, FAssetManagerLoadParams &&  LoadParams, UE::FSourceLocation  Location = UE::FSourceLocation::Current()  )

virtual

Downloads data for a set of assets in a specific bundle state, and returns a handle with a FStreamableDownloadCachePin. The FStreamableDownloadCachePin must be kept active to hold the data in the download cache. Does not load any assets.

Parameters

AssetsToLoad	List of primary assets to load
LoadBundles	List of bundles to load for those assets
bLoadRecursive	If true, this will call RecursivelyExpandBundleData and recurse into sub bundles of other primary assets loaded by a bundle reference
LoadParams	Contains callbacks and download params. Download params are required.
Location	[optional] Is not intended for direct use, the parameter catches call site source location and passes it down to the streaming manager. See FStreamingManager.

Returns

Streamable Handle

PreGarbageCollect()

void UAssetManager::PreGarbageCollect ( )

protectedvirtual

PreloadPrimaryAssets() [1/2]

TSharedPtr< FStreamableHandle > UAssetManager::PreloadPrimaryAssets ( const TArray< FPrimaryAssetId > &  AssetsToLoad, const TArray< FName > &  LoadBundles, bool  bLoadRecursive, FAssetManagerLoadParams &&  LoadParams, UE::FSourceLocation  Location = UE::FSourceLocation::Current()  )

virtual

Preloads data for a set of assets in a specific bundle state, and returns a handle you must keep active. These assets are not officially Loaded, so Unload/ChangeBundleState will not affect them and if you release the handle without otherwise loading the assets they will be freed.

Parameters

AssetsToLoad	List of primary assets to load
LoadBundles	List of bundles to load for those assets
bLoadRecursive	If true, this will call RecursivelyExpandBundleData and recurse into sub bundles of other primary assets loaded by a bundle reference
LoadParams	Contains callbacks and async load priority
Location	[optional] Is not intended for direct use, the parameter catches call site source location and passes it down to the streaming manager. See FStreamingManager.

Returns

Streamable Handle that must be stored to keep the preloaded assets from being freed

PreloadPrimaryAssets() [2/2]

TSharedPtr< FStreamableHandle > UAssetManager::PreloadPrimaryAssets ( const TArray< FPrimaryAssetId > &  AssetsToLoad, const TArray< FName > &  LoadBundles, bool  bLoadRecursive, FStreamableDelegate  DelegateToCall = FStreamableDelegate(), TAsyncLoadPriority  Priority = FStreamableManager::DefaultAsyncLoadPriority, UE::FSourceLocation  Location = UE::FSourceLocation::Current()  )

inlinevirtual

Preloads data for a set of assets in a specific bundle state, and returns a handle you must keep active. These assets are not officially Loaded, so Unload/ChangeBundleState will not affect them and if you release the handle without otherwise loading the assets they will be freed. Prefer the overloads with Param structs for new code.

Parameters

AssetsToLoad	List of primary assets to load
LoadBundles	List of bundles to load for those assets
bLoadRecursive	If true, this will call RecursivelyExpandBundleData and recurse into sub bundles of other primary assets loaded by a bundle reference
DelegateToCall	[optional] Delegate that will be called on completion
Priority	[optional] Async loading priority for this request
Location	[optional] Is not intended for direct use, the parameter catches call site source location and passes it down to the streaming manager. See FStreamingManager.

Returns

Streamable Handle that must be stored to keep the preloaded assets from being freed

PushBulkScanning()

void UAssetManager::PushBulkScanning

(

)

Call before many calls to ScanPaths to improve load performance. Match each call with PopBulkScanning().

RecursivelyExpandBundleData()

void UAssetManager::RecursivelyExpandBundleData ( FAssetBundleData &  BundleData ) const

virtual

This will expand out references in the passed in AssetBundleData that are pointing to other primary assets with bundles. This is useful to preload entire webs of assets

RefreshPrimaryAssetDirectory()

void UAssetManager::RefreshPrimaryAssetDirectory ( bool  bForceRefresh = false )

virtual

Refresh the entire set of asset data, can call from editor when things have changed dramatically. Will only refresh if force is true or it thinks something has changed

Register_OnAddedAssetSearchRoot()

FDelegateHandle UAssetManager::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

RegisterSpecificPrimaryAsset()

bool UAssetManager::RegisterSpecificPrimaryAsset ( const FPrimaryAssetId &  PrimaryAssetId, const FAssetData &  NewAssetData  )

virtual

Manually register a new or updated primary asset, returns true if it was successful

RemovePrimaryAssetType()

void UAssetManager::RemovePrimaryAssetType ( FPrimaryAssetType  PrimaryAssetType )

virtual

RemoveScanPathsForPrimaryAssets()

void UAssetManager::RemoveScanPathsForPrimaryAssets ( FPrimaryAssetType  PrimaryAssetType, const TArray< FString > &  Paths, UClass *  BaseClass, bool  bHasBlueprintClasses, bool  bIsEditorOnly = false  )

virtual

ScanPathForPrimaryAssets()

int32 UAssetManager::ScanPathForPrimaryAssets ( FPrimaryAssetType  PrimaryAssetType, const FString &  Path, UClass *  BaseClass, bool  bHasBlueprintClasses, bool  bIsEditorOnly = false, bool  bForceSynchronousScan = true  )

virtual

Single path wrapper

ScanPathsForPrimaryAssets()

int32 UAssetManager::ScanPathsForPrimaryAssets ( FPrimaryAssetType  PrimaryAssetType, const TArray< FString > &  Paths, UClass *  BaseClass, bool  bHasBlueprintClasses, bool  bIsEditorOnly = false, bool  bForceSynchronousScan = true  )

virtual

Scans a list of paths and reads asset data for all primary assets of a specific type. If done in the editor it will load the data off disk, in cooked games it will load out of the asset registry cache

Parameters

PrimaryAssetType	Type of asset to look for. If the scanned asset matches GetPrimaryAssetType with this it will be added to directory
Paths	List of file system paths to scan
BaseClass	Base class of all loaded assets, if the scanned asset isn't a child of this class it will be skipped
bHasBlueprintClasses	If true, the assets are blueprints that subclass BaseClass. If false they are base UObject assets
bIsEditorOnly	If true, assets will only be scanned in editor builds, and will not be stored into the asset registry
bForceSynchronousScan	If true will scan the disk synchronously, otherwise will wait for asset registry scan to complete

Returns

Number of primary assets found

ScanPathsSynchronous()

void UAssetManager::ScanPathsSynchronous ( const TArray< FString > &  PathsToScan ) const

virtual

Helper function which requests the asset registery scan a list of directories/assets

ScanPrimaryAssetRulesFromConfig()

void UAssetManager::ScanPrimaryAssetRulesFromConfig ( )

protectedvirtual

Called to apply the primary asset rule overrides from config

ScanPrimaryAssetTypesFromConfig()

void UAssetManager::ScanPrimaryAssetTypesFromConfig ( )

protectedvirtual

Scans all asset types specified in DefaultGame

SearchAssetRegistryPaths()

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

virtual

Helper function to search the asset registry for AssetData matching search rules

SetPrimaryAssetRules()

void UAssetManager::SetPrimaryAssetRules ( FPrimaryAssetId  PrimaryAssetId, const FPrimaryAssetRules &  Rules  )

virtual

Changes the management rules for a specific asset, this overrides the type rules. If passed in Rules is default, delete override

SetPrimaryAssetRulesExplicitly()

void UAssetManager::SetPrimaryAssetRulesExplicitly ( FPrimaryAssetId  PrimaryAssetId, const FPrimaryAssetRulesExplicitOverride &  ExplicitRules  )

virtual

SetPrimaryAssetTypeRules()

void UAssetManager::SetPrimaryAssetTypeRules ( FPrimaryAssetType  PrimaryAssetType, const FPrimaryAssetRules &  Rules  )

virtual

Changes the default management rules for a specified type

ShouldIncludeInAssetSearch()

bool UAssetManager::ShouldIncludeInAssetSearch ( const FAssetData &  AssetData, const FAssetManagerSearchRules &  SearchRules  ) const

protectedvirtual

Filter function that is called from SearchAssetRegistryPaths, returns true if asset data should be included in search results

ShouldScanPrimaryAssetType()

bool UAssetManager::ShouldScanPrimaryAssetType ( FPrimaryAssetTypeInfo &  TypeInfo ) const

virtual

Returns true if the specified TypeInfo should be scanned. Can be overridden by the game

StartBulkScanning()

void UAssetManager::StartBulkScanning ( )

protectedvirtual

Should only be called from PushBulkScanning() and override

StartInitialLoading()

void UAssetManager::StartInitialLoading ( )

virtual

Starts initial load, gets called from InitializeObjectReferences

StopBulkScanning()

void UAssetManager::StopBulkScanning ( )

protectedvirtual

Should only be called from PopBulkScanning() and override

TryUpdateCachedAssetData()

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

protectedvirtual

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

UnloadPrimaryAsset()

int32 UAssetManager::UnloadPrimaryAsset ( const FPrimaryAssetId &  AssetToUnload )

virtual

Single asset wrapper

UnloadPrimaryAssets()

int32 UAssetManager::UnloadPrimaryAssets ( const TArray< FPrimaryAssetId > &  AssetsToUnload )

virtual

Unloads a list of Primary Assets that were previously Loaded. If the only thing keeping these assets in memory was a prior Load call, they will be freed.

Parameters

AssetsToUnload

List of primary assets to load

Returns

Number of assets unloaded

UnloadPrimaryAssetsWithType()

int32 UAssetManager::UnloadPrimaryAssetsWithType ( FPrimaryAssetType  PrimaryAssetType )

virtual

Loads all assets of a given type, useful for cooking

Unregister_OnAddedAssetSearchRoot()

void UAssetManager::Unregister_OnAddedAssetSearchRoot

(

FDelegateHandle

DelegateHandle

)

Unregister previously added callback

WarnAboutInvalidPrimaryAsset()

void UAssetManager::WarnAboutInvalidPrimaryAsset ( const FPrimaryAssetId &  PrimaryAssetId, const FString &  Message  ) const

virtual

Warn about this primary asset id being missing, but only if this is the first time this session

WriteCustomReport()

bool UAssetManager::WriteCustomReport ( FString  FileName, TArray< FString > &  FileLines  ) const

virtual

Helper function to write out asset reports

Member Data Documentation

AddedAssetSearchRoots

TArray<FString> UAssetManager::AddedAssetSearchRoots

protected

List of dynamic asset search roots added past startup

AllAssetSearchRoots

TArray<FString> UAssetManager::AllAssetSearchRoots

protected

All asset search roots including startup ones

AlreadyScannedDirectories

TArray<FString> UAssetManager::AlreadyScannedDirectories

mutableprotected

List of directories that have already been synchronously scanned

AssetPathMap

TMap<FSoftObjectPath, FPrimaryAssetId> UAssetManager::AssetPathMap

protected

Map from object path to Primary Asset Id

AssetPathRedirects

TMap<FSoftObjectPath, FSoftObjectPath> UAssetManager::AssetPathRedirects

protected

AssetRuleOverrides

TMap<FPrimaryAssetId, FPrimaryAssetRulesExplicitOverride> UAssetManager::AssetRuleOverrides

protected

Overridden asset management data for specific types

AssetSearchRootsVirtualPath

const FString UAssetManager::AssetSearchRootsVirtualPath = TEXT("$AssetSearchRoots")

static

Virtual path $AssetSearchRoots, replaced with all roots including defaults like /Game

bHasCompletedInitialScan

bool UAssetManager::bHasCompletedInitialScan

protected

True if we have passed the initial asset registry/type scan

bIncludeOnlyOnDiskAssets

bool UAssetManager::bIncludeOnlyOnDiskAssets

protected

True if only on-disk assets should be searched by the asset registry

bIsGlobalAsyncScanEnvironment

bool UAssetManager::bIsGlobalAsyncScanEnvironment

protected

True if we are running a build that is already scanning assets globally so we can perhaps avoid scanning paths synchronously

bIsLoadingFromPakFiles

bool UAssetManager::bIsLoadingFromPakFiles

protected

True if we are loading from pak files

bIsManagementDatabaseCurrent

bool UAssetManager::bIsManagementDatabaseCurrent

protected

True if the asset management database is up to date

bIsPrimaryAssetDirectoryCurrent

bool UAssetManager::bIsPrimaryAssetDirectoryCurrent

protected

True if asset data is current, if false it will need to rescan before PIE

bObjectReferenceListDirty

bool UAssetManager::bObjectReferenceListDirty = true

protected

bOnlyCookProductionAssets

bool UAssetManager::bOnlyCookProductionAssets

protected

If true, DevelopmentCook assets will error when they are cooked

bShouldAcquireMissingChunksOnLoad

bool UAssetManager::bShouldAcquireMissingChunksOnLoad

protected

True if the chunk install interface should be queries before loading assets

bShouldGuessTypeAndName

bool UAssetManager::bShouldGuessTypeAndName

protected

True if PrimaryAssetType/Name will be implied for loading assets that don't have it saved on disk. Won't work for all projects

bShouldUseSynchronousLoad

bool UAssetManager::bShouldUseSynchronousLoad

protected

True if we should always use synchronous loads, this speeds up cooking

bTargetPlatformsAllowDevelopmentObjects

bool UAssetManager::bTargetPlatformsAllowDevelopmentObjects

protected

Suppresses bOnlyCookProductionAssets based on the AllowsDevelopmentObjects() property of the TargetPlatforms being cooked.

bUpdateManagementDatabaseAfterScan

bool UAssetManager::bUpdateManagementDatabaseAfterScan

protected

True if the asset management database should be updated after scan completes

CachedAssetBundles

TMap<FPrimaryAssetId, TSharedPtr<FAssetBundleData, ESPMode::ThreadSafe> > UAssetManager::CachedAssetBundles

protected

Cached map of asset bundles, global and per primary asset

ChunkInstallDelegateHandle

FDelegateHandle UAssetManager::ChunkInstallDelegateHandle

protected

Delegate bound to chunk install

CookRuleManagementParentMap

TMap<FPrimaryAssetId, TArray<FPrimaryAssetId> > UAssetManager::CookRuleManagementParentMap

protected

Map from PrimaryAssetId to list of PrimaryAssetIds that are the parent of this one, for determining what gets cooked

DynamicSearchRootsVirtualPath

const FString UAssetManager::DynamicSearchRootsVirtualPath = TEXT("$DynamicSearchRoots")

static

Virtual path $DynamicSearchRoots, replaced with dynamically added asset roots

FAssetManagerEditorModule

friend UAssetManager::FAssetManagerEditorModule

protected

ManagementParentMap

TMap<FPrimaryAssetId, TArray<FPrimaryAssetId> > UAssetManager::ManagementParentMap

protected

Map from PrimaryAssetId to list of PrimaryAssetIds that are the parent of this one, for determining chunking

MapType

const FPrimaryAssetType UAssetManager::MapType = FName(TEXT("Map"))

static

Asset Type of UWorld assets

NumberOfSpawnedNotifications

int32 UAssetManager::NumberOfSpawnedNotifications

protected

Number of notifications seen in this update

NumBulkScanRequests

int32 UAssetManager::NumBulkScanRequests

protected

>0 if we are currently in bulk scanning mode

ObjectReferenceList

TArray<TObjectPtr<UObject> > UAssetManager::ObjectReferenceList

protected

List of UObjects that are being kept from being GCd, derived from the asset type map. Arrays are currently more efficient than Sets

OnAddedAssetSearchRootDelegate

FOnAddedAssetSearchRoot UAssetManager::OnAddedAssetSearchRootDelegate

protected

Delegate called when a new asset search root is registered

OnAssetManagerCreatedDelegate

FSimpleMulticastDelegate UAssetManager::OnAssetManagerCreatedDelegate

staticprotected

Delegate called when the asset manager singleton is created

OnCompletedInitialScanDelegate

FSimpleMulticastDelegate UAssetManager::OnCompletedInitialScanDelegate

staticprotected

Delegate called when initial span finishes

PackageChunkType

const FPrimaryAssetType UAssetManager::PackageChunkType = FName(TEXT("PackageChunk"))

static

Type representing a packaging chunk, this is a virtual type that is never loaded off disk

PendingChunkInstalls

TArray<FPendingChunkInstall> UAssetManager::PendingChunkInstalls

protected

List of chunk installs that are being waited for

PrimaryAssetEncryptionKeyCache

TMap<FPrimaryAssetId, FGuid> UAssetManager::PrimaryAssetEncryptionKeyCache

protected

Cache of encryption keys used by each primary asset

PrimaryAssetIdRedirects

TMap<FString, FString> UAssetManager::PrimaryAssetIdRedirects

protected

PrimaryAssetLabelType

const FPrimaryAssetType UAssetManager::PrimaryAssetLabelType = FName(TEXT("PrimaryAssetLabel"))

static

Asset Type of Label used to tag other assets

PrimaryAssetTypeRedirects

TMap<FName, FName> UAssetManager::PrimaryAssetTypeRedirects

protected

Redirector maps loaded out of AssetMigrations.ini

StreamableManager

FStreamableManager UAssetManager::StreamableManager

protected

The streamable manager used for all primary asset loading

SuppressionType

const FPrimaryAssetType UAssetManager::SuppressionType = FName(TEXT("__Suppressed__"))

static

Asset Type used in return values to indicate that a specific asset of a given PrimaryAssetType should be suppressed and not considered a PrimaryAsset.

WarningInvalidAssets

TSet<FPrimaryAssetId> UAssetManager::WarningInvalidAssets

mutableprotected

List of assets we have warned about being missing

---

The documentation for this class was generated from the following files:

• Engine/Source/Runtime/Engine/Classes/Engine/AssetManager.h
• Engine/Source/Runtime/Engine/Private/AssetManager.cpp