AssetRegistry.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "AssetRegistryImpl.h"
#include "Containers/Ticker.h"
#include "UObject/Object.h"
 
#include "AssetRegistry.generated.h"
 
namespace UE::AssetRegistry::Premade { struct FAsyncConsumer; }
 
PRAGMA_DISABLE_DEPRECATION_WARNINGS
 
UCLASS(transient)
class UAssetRegistryImpl : public UObject, public IAssetRegistry
{
    GENERATED_BODY()
public:
    UAssetRegistryImpl(const FObjectInitializer& ObjectInitializer);
    UAssetRegistryImpl(FVTableHelper& Helper);
    virtual ~UAssetRegistryImpl();
    virtual void FinishDestroy() override;
 
    static UAssetRegistryImpl& Get();
 
    // IAssetRegistry implementation
    virtual bool HasAssets(const FName PackagePath, const bool bRecursive = false) const override;
    virtual bool GetAssetsByPackageName(FName PackageName, TArray<FAssetData>& OutAssetData, bool bIncludeOnlyOnDiskAssets = false, bool bSkipARFilteredAssets=true) const override;
    virtual bool GetAssetsByPath(FName PackagePath, TArray<FAssetData>& OutAssetData, bool bRecursive = false, bool bIncludeOnlyOnDiskAssets = false) const override;
    virtual bool GetAssetsByPaths(TArray<FName> PackagePath, TArray<FAssetData>& OutAssetData, bool bRecursive = false, bool bIncludeOnlyOnDiskAssets = false) const override;
    virtual bool GetAssetsByClass(FTopLevelAssetPath ClassPathName, TArray<FAssetData>& OutAssetData, bool bSearchSubClasses = false) const override;
    virtual bool GetAssetsByTags(const TArray<FName>& AssetTags, TArray<FAssetData>& OutAssetData) const override;
    virtual bool GetAssetsByTagValues(const TMultiMap<FName, FString>& AssetTagsAndValues, TArray<FAssetData>& OutAssetData) const override;
    virtual bool GetAssets(const FARFilter& Filter, TArray<FAssetData>& OutAssetData, bool bSkipARFilteredAssets = true) const override;
    virtual bool GetAssets(const FARCompiledFilter& Filter, TArray<FAssetData>& OutAssetData, bool bSkipARFilteredAssets = true) const override;
    virtual bool GetInMemoryAssets(const FARFilter& Filter, TArray<FAssetData>& OutAssetData, bool bSkipARFilteredAssets=true) const override;
    virtual bool GetInMemoryAssets(const FARCompiledFilter& Filter, TArray<FAssetData>& OutAssetData, bool bSkipARFilteredAssets=true) const override;
    virtual bool EnumerateAssets(const FARFilter& Filter, TFunctionRef<bool(const FAssetData&)> Callback,
        UE::AssetRegistry::EEnumerateAssetsFlags InEnumerateFlags = UE::AssetRegistry::EEnumerateAssetsFlags::None) const override;
    virtual bool EnumerateAssets(const FARCompiledFilter& Filter, TFunctionRef<bool(const FAssetData&)> Callback,
        UE::AssetRegistry::EEnumerateAssetsFlags InEnumerateFlags = UE::AssetRegistry::EEnumerateAssetsFlags::None) const override;
    UE_DEPRECATED(5.1, "Asset path FNames have been deprecated, use FSoftObjectPath instead.")
    virtual FAssetData GetAssetByObjectPath( const FName ObjectPath, bool bIncludeOnlyOnDiskAssets = false ) const override;
    virtual FAssetData GetAssetByObjectPath(const FSoftObjectPath& ObjectPath, bool bIncludeOnlyOnDiskAssets = false, bool bSkipARFilteredAssets = true) const override;
    virtual UE::AssetRegistry::EExists TryGetAssetByObjectPath(const FSoftObjectPath& ObjectPath, FAssetData& OutAssetData) const override;
    virtual UE::AssetRegistry::EExists TryGetAssetPackageData(const FName PackageName, FAssetPackageData& OutAssetPackageData) const override;
    virtual UE::AssetRegistry::EExists TryGetAssetPackageData(const FName PackageName, FAssetPackageData& OutAssetPackageData, FName& OutCorrectCasePackageName) const override;
    virtual bool GetAllAssets(TArray<FAssetData>& OutAssetData, bool bIncludeOnlyOnDiskAssets = false) const override;
    virtual bool EnumerateAllAssets(TFunctionRef<bool(const FAssetData&)> Callback,
        UE::AssetRegistry::EEnumerateAssetsFlags InEnumerateFlags = UE::AssetRegistry::EEnumerateAssetsFlags::None) const override;
    virtual void GetPackagesByName(FStringView PackageName, TArray<FName>& OutPackageNames) const override;
    virtual FName GetFirstPackageByName(FStringView PackageName) const override;
    virtual bool GetDependencies(const FAssetIdentifier& AssetIdentifier, TArray<FAssetIdentifier>& OutDependencies, UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All, const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const override;
    virtual bool GetDependencies(const FAssetIdentifier& AssetIdentifier, TArray<FAssetDependency>& OutDependencies, UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All, const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const override;
    virtual bool GetDependencies(FName PackageName, TArray<FName>& OutDependencies, UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::Package, const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const override; //-V1101
    virtual bool ContainsDependency(FName PackageName, FName QueryDependencyName, UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::Package, const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const override;
    virtual bool GetReferencers(const FAssetIdentifier& AssetIdentifier, TArray<FAssetIdentifier>& OutReferencers, UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All, const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const override;
    virtual bool GetReferencers(const FAssetIdentifier& AssetIdentifier, TArray<FAssetDependency>& OutReferencers, UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::All, const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const override;
    virtual bool GetReferencers(FName PackageName, TArray<FName>& OutReferencers, UE::AssetRegistry::EDependencyCategory Category = UE::AssetRegistry::EDependencyCategory::Package, const UE::AssetRegistry::FDependencyQuery& Flags = UE::AssetRegistry::FDependencyQuery()) const override; //-V1101
    virtual TOptional<FAssetPackageData> GetAssetPackageDataCopy(FName PackageName) const override;
    virtual TArray<TOptional<FAssetPackageData>> GetAssetPackageDatasCopy(TArrayView<FName> PackageNames) const override;
    virtual void EnumerateAllPackages(TFunctionRef<void(FName PackageName, const FAssetPackageData& PackageData)> Callback, UE::AssetRegistry::EEnumeratePackagesFlags InEnumerateFlags) const override;
    virtual bool DoesPackageExistOnDisk(FName PackageName, FString* OutCorrectCasePackageName = nullptr, FString* OutExtension = nullptr) const override;
    virtual FSoftObjectPath GetRedirectedObjectPath(const FSoftObjectPath& ObjectPath) override;
    virtual bool GetAncestorClassNames(FTopLevelAssetPath ClassName, TArray<FTopLevelAssetPath>& OutAncestorClassNames) const override;
    virtual void GetDerivedClassNames(const TArray<FTopLevelAssetPath>& ClassNames, const TSet<FTopLevelAssetPath>& ExcludedClassNames, TSet<FTopLevelAssetPath>& OutDerivedClassNames) const override; 
    virtual void GetAllCachedPaths(TArray<FString>& OutPathList) const override;
    virtual void EnumerateAllCachedPaths(TFunctionRef<bool(FString)> Callback) const override;
    virtual void EnumerateAllCachedPaths(TFunctionRef<bool(FName)> Callback) const override;
    virtual void GetSubPaths(const FString& InBasePath, TArray<FString>& OutPathList, bool bInRecurse) const override;
    virtual void GetSubPaths(const FName& InBasePath, TArray<FName>& OutPathList, bool bInRecurse) const override;
    virtual void EnumerateSubPaths(const FString& InBasePath, TFunctionRef<bool(FString)> Callback, bool bInRecurse) const override;
    virtual void EnumerateSubPaths(const FName InBasePath, TFunctionRef<bool(FName)> Callback, bool bInRecurse) const override;
    virtual void RunAssetsThroughFilter (TArray<FAssetData>& AssetDataList, const FARFilter& Filter) const override;
    virtual void UseFilterToExcludeAssets(TArray<FAssetData>& AssetDataList, const FARFilter& Filter) const override;
    virtual void UseFilterToExcludeAssets(TArray<FAssetData>& AssetDataList, const FARCompiledFilter& CompiledFilter) const override;
    virtual bool IsAssetIncludedByFilter(const FAssetData& AssetData, const FARCompiledFilter& Filter) const override;
    virtual bool IsAssetExcludedByFilter(const FAssetData& AssetData, const FARCompiledFilter& Filter) const override;
    virtual void CompileFilter(const FARFilter& InFilter, FARCompiledFilter& OutCompiledFilter) const override;
    virtual void SetTemporaryCachingMode(bool bEnable) override;
    virtual void SetTemporaryCachingModeInvalidated() override;
    virtual bool GetTemporaryCachingMode() const override;
    virtual EAssetAvailability::Type GetAssetAvailability(const FAssetData& AssetData) const override;  
    virtual float GetAssetAvailabilityProgress(const FAssetData& AssetData, EAssetAvailabilityProgressReportingType::Type ReportType) const override;
    virtual bool GetAssetAvailabilityProgressTypeSupported(EAssetAvailabilityProgressReportingType::Type ReportType) const override;
    virtual void PrioritizeAssetInstall(const FAssetData& AssetData) const override;
    virtual bool HasVerseFiles(FName PackagePath, bool bRecursive = false) const override;
    virtual bool GetVerseFilesByPath(FName PackagePath, TArray<FName>& OutFilePaths, bool bRecursive = false) const override;
    virtual bool AddPath(const FString& PathToAdd) override;
    virtual bool RemovePath(const FString& PathToRemove) override;
    virtual bool PathExists(const FString& PathToTest) const override;
    virtual bool PathExists(const FName PathToTest) const override;
    virtual void SearchAllAssets(bool bSynchronousSearch) override;
    virtual bool IsSearchAllAssets() const override;
    virtual bool IsSearchAsync() const override;
    virtual void WaitForCompletion() override;
    virtual void WaitForPremadeAssetRegistry() override;
    virtual void ClearGathererCache() override;
    virtual void WaitForPackage(const FString& PackageName) override;
    virtual void ScanSynchronous(const TArray<FString>& InPaths, const TArray<FString>& InFilePaths, UE::AssetRegistry::EScanFlags InScanFlags = UE::AssetRegistry::EScanFlags::None) override;
    virtual void ScanPathsSynchronous(const TArray<FString>& InPaths, bool bForceRescan = false, bool bIgnoreDenyListScanFilters = false) override;
    virtual void ScanFilesSynchronous(const TArray<FString>& InFilePaths, bool bForceRescan = false) override;
    virtual void PrioritizeSearchPath(const FString& PathToPrioritize) override;
    virtual void ScanModifiedAssetFiles(const TArray<FString>& InFilePaths) override;
    virtual void ScanModifiedAssetFiles(const TArray<FString>& InFilePaths, UE::AssetRegistry::EScanFlags ScanFlags) override;
    virtual void Serialize(FArchive& Ar) override;
    virtual void AppendState(const FAssetRegistryState& InState, UE::AssetRegistry::EAppendMode AppendMode = UE::AssetRegistry::EAppendMode::Append) override;
    virtual SIZE_T GetAllocatedSize(bool bLogDetailed = false) const override;
    virtual void LoadPackageRegistryData(FArchive& Ar, FLoadPackageRegistryData& InOutData) const override;
    virtual void LoadPackageRegistryData(const FString& PackageFilename, FLoadPackageRegistryData& InOutData) const override;
    virtual void InitializeTemporaryAssetRegistryState(FAssetRegistryState& OutState, const FAssetRegistrySerializationOptions& Options,
        bool bRefreshExisting = false, const TSet<FName>& RequiredPackages = TSet<FName>(),
        const TSet<FName>& RemovePackages = TSet<FName>()) const override;
#if ASSET_REGISTRY_STATE_DUMPING_ENABLED
    virtual void DumpState(const TArray<FString>& Arguments, TArray<FString>& OutPages, int32 LinesPerPage = 1) const override;
#endif
    virtual TSet<FName> GetCachedEmptyPackagesCopy() const override;
    virtual bool ContainsTag(FName TagName) const override;
    virtual void InitializeSerializationOptions(FAssetRegistrySerializationOptions& Options, const ITargetPlatform* TargetPlatform = nullptr, UE::AssetRegistry::ESerializationTarget Target = UE::AssetRegistry::ESerializationTarget::ForGame) const override;
 
    DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FFilesBlockedEvent, FFilesBlockedEvent);
    virtual FFilesBlockedEvent& OnFilesBlocked() override;
 
    DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FPathsEvent, FPathsEvent);
    virtual FPathsEvent& OnPathsAdded() override;
    virtual FPathsEvent& OnPathsRemoved() override;
    
    DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FPathAddedEvent, FPathAddedEvent);
    virtual FPathAddedEvent& OnPathAdded() override;
 
    DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FPathRemovedEvent, FPathRemovedEvent);
    virtual FPathRemovedEvent& OnPathRemoved() override;
 
    DECLARE_DERIVED_EVENT(UAssetRegistryImpl, IAssetRegistry::FScanStartedEvent, FScanStartedEvent);
    virtual FScanStartedEvent& OnScanStarted() override;
 
    DECLARE_DERIVED_EVENT(UAssetRegistryImpl, IAssetRegistry::FScanEndedEvent, FScanEndedEvent);
    virtual FScanEndedEvent& OnScanEnded() override;
 
    DECLARE_DERIVED_EVENT(UAssetRegistryImpl, IAssetRegistry::FKnownGathersCompleteEvent, FKnownGathersCompleteEvent);
    virtual FKnownGathersCompleteEvent& OnKnownGathersComplete() override;
 
    virtual void AssetCreated(UObject* NewAsset) override;
    virtual void AssetDeleted(UObject* DeletedAsset) override;
    virtual void AssetRenamed(const UObject* RenamedAsset, const FString& OldObjectPath) override;
    virtual void AssetsSaved(TArray<FAssetData>&& SavedAssets) override;
    virtual void AssetUpdateTags(UObject* Object, EAssetRegistryTagsCaller Caller) override;
    virtual void AssetTagsFinalized(const UObject& FinalizedAsset) override;
 
    virtual bool VerseCreated(const FString& FilePath) override;
    virtual bool VerseDeleted(const FString& FilePath) override;
 
    virtual void PackageDeleted(UPackage* DeletedPackage) override;
 
    virtual IAssetRegistry::FAssetCollisionEvent& OnAssetCollision_Private() override;
 
    DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FAssetAddedEvent, FAssetAddedEvent);
    virtual FAssetAddedEvent& OnAssetAdded() override;
 
    DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FAssetRemovedEvent, FAssetRemovedEvent);
    virtual FAssetRemovedEvent& OnAssetRemoved() override;
    
    DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FAssetRenamedEvent, FAssetRenamedEvent);
    virtual FAssetRenamedEvent& OnAssetRenamed() override;
 
    DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FAssetUpdatedEvent, FAssetUpdatedEvent );
    virtual FAssetUpdatedEvent& OnAssetUpdated() override;
    virtual FAssetUpdatedEvent& OnAssetUpdatedOnDisk() override;
 
    // Batch events
    DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FAssetsEvent, FAssetsEvent);
    virtual FAssetsEvent& OnAssetsAdded() override;
    virtual FAssetsEvent& OnAssetsRemoved() override;
    virtual FAssetsEvent& OnAssetsUpdated() override;
    virtual FAssetsEvent& OnAssetsUpdatedOnDisk() override;
    
    DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FInMemoryAssetCreatedEvent, FInMemoryAssetCreatedEvent );
    virtual FInMemoryAssetCreatedEvent& OnInMemoryAssetCreated() override;
 
    DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FInMemoryAssetDeletedEvent, FInMemoryAssetDeletedEvent );
    virtual FInMemoryAssetDeletedEvent& OnInMemoryAssetDeleted() override;
 
    DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FVerseAddedEvent, FVerseAddedEvent);
    virtual FVerseAddedEvent& OnVerseAdded() override;
 
    DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FVerseRemovedEvent, FVerseRemovedEvent);
    virtual FVerseRemovedEvent& OnVerseRemoved() override;
 
    DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FFilesLoadedEvent, FFilesLoadedEvent );
    virtual FFilesLoadedEvent& OnFilesLoaded() override;
 
    DECLARE_DERIVED_EVENT( UAssetRegistryImpl, IAssetRegistry::FFileLoadProgressUpdatedEvent, FFileLoadProgressUpdatedEvent );
    virtual FFileLoadProgressUpdatedEvent& OnFileLoadProgressUpdated() override;
 
    virtual bool IsLoadingAssets() const override;
    virtual bool IsGathering() const override;
    virtual bool HasSerializedDiscoveryCache() const override;
    virtual bool ShouldUpdateDiskCacheAfterLoad() const override
    {
#if WITH_EDITORONLY_DATA
        return bUpdateDiskCacheAfterLoad;
#else
        return false;
#endif
    }
 
    virtual void Tick (float DeltaTime) override;
 
    virtual void ReadLockEnumerateAllTagToAssetDatas(TFunctionRef<bool(FName TagName, IAssetRegistry::FEnumerateAssetDatasFunc EnumerateAssets)> Callback) const override;
 
    virtual bool IsPathBeautificationNeeded(const FString& InAssetPath) const override;
 
    UE::AssetRegistry::Impl::EGatherStatus TickOnBackgroundThread();
 
    DECLARE_DERIVED_EVENT(UAssetRegistryImpl, IAssetRegistry::FEnumerateAssetsEvent, FEnumerateAssetsEvent)
    virtual FEnumerateAssetsEvent& OnEnumerateAssetsEvent() override;
 
protected:
    virtual void SetManageReferences(const TMultiMap<FAssetIdentifier, FAssetIdentifier>& ManagerMap,
        bool bClearExisting, UE::AssetRegistry::EDependencyCategory RecurseType,
        TSet<FDependsNode*>& ExistingManagedNode, ShouldSetManagerPredicate ShouldSetManager = nullptr) override;
    virtual void SetManageReferences(UE::AssetRegistry::FSetManageReferencesContext& Context) override;
    virtual bool SetPrimaryAssetIdForObjectPath(const FSoftObjectPath& ObjectPath, FPrimaryAssetId PrimaryAssetId) override;
 
private:
    void OnPreExit();
#if WITH_EDITOR
    void OnFEngineLoopInitCompleteSearchAllAssets();
    void OnAssetDependencyGathererRegistered();
#endif
    void InitializeEvents(UE::AssetRegistry::Impl::FInitializeContext& Context);
    void Broadcast(UE::AssetRegistry::Impl::FEventContext& EventContext, bool bAllowFileLoadedEvent = false);
    bool CanBroadcastEvents() const;
 
    bool OnResolveRedirect(const FString& InPackageName, FString& OutPackageName);
 
#if WITH_EDITOR
    void OnDirectoryChanged(const TArray<struct FFileChangeData>& Files);
 
    void OnAssetLoaded(UObject* AssetLoaded);
#endif
 
    void OnContentPathMounted(const FString& AssetPath, const FString& FileSystemPath);
 
    void OnContentPathDismounted(const FString& AssetPath, const FString& FileSystemPath);
 
    void OnPostEngineInit();
 
    void OnInitialPluginLoadingComplete();
 
    void ScanPathsSynchronousInternal(const TArray<FString>& InDirs, const TArray<FString>& InFiles,
        UE::AssetRegistry::EScanFlags InScanFlags);
 
#if WITH_EDITOR
    void ProcessLoadedAssetsToUpdateCache(UE::AssetRegistry::Impl::FEventContext& EventContext,
        UE::AssetRegistry::Impl::EGatherStatus Status, UE::AssetRegistry::Impl::FInterruptionContext& InOutInterruptionContext);
#endif
    void GetInheritanceContextWithRequiredLock(UE::AssetRegistry::FInterfaceRWScopeLock& InOutScopeLock,
        UE::AssetRegistry::Impl::FClassInheritanceContext& InheritanceContext,
        UE::AssetRegistry::Impl::FClassInheritanceBuffer& StackBuffer);
    void GetInheritanceContextWithRequiredLock(UE::AssetRegistry::FInterfaceWriteScopeLock& InOutScopeLock,
        UE::AssetRegistry::Impl::FClassInheritanceContext& InheritanceContext,
        UE::AssetRegistry::Impl::FClassInheritanceBuffer& StackBuffer);
 
 
#if WITH_EDITOR
    void OnGetExtraObjectTags(FAssetRegistryTagsContext Context);
 
    bool IsDirAlreadyWatchedByRootWatchers(const FString& Directory) const;
#endif
 
    virtual void RequestPauseBackgroundProcessing();
    virtual void RequestResumeBackgroundProcessing();
    bool IsBackgroundProcessingPaused() const 
    { 
#if WITH_EDITOR 
        return GuardedData.IsBackgroundProcessingPaused(); 
#else
        return true;
#endif
    }
 
    void RequestTick();
    void ClearRequestTick();
 
private:
 
    UE::AssetRegistry::FAssetRegistryImpl GuardedData;
 
    mutable UE::AssetRegistry::Private::FRWLockWithPriority InterfaceLock;
 
    FCriticalSection GatheredDataProcessingLock;
 
#if WITH_EDITOR
    TMap<FString, FDelegateHandle> OnDirectoryChangedDelegateHandles;
    TArray<FString> DirectoryWatchRoots;
#endif
 
#if WITH_EDITORONLY_DATA
    bool bAddMetaDataTagsToOnGetExtraObjectTags = true;
 
    bool bUpdateDiskCacheAfterLoad = true;
#endif
 
    FFilesBlockedEvent FilesBlockedEvent;
 
    FPathsEvent PathsAddedEvent;
 
    FPathsEvent PathsRemovedEvent;
    
    FPathAddedEvent PathAddedEvent;
 
    FPathRemovedEvent PathRemovedEvent;
 
    FAssetAddedEvent AssetAddedEvent;
    
    FAssetRemovedEvent AssetRemovedEvent;
 
    FAssetRenamedEvent AssetRenamedEvent;
 
    FAssetUpdatedEvent AssetUpdatedEvent;
 
    FAssetUpdatedEvent AssetUpdatedOnDiskEvent;
 
    static constexpr SIZE_T NumBatchedEvents = static_cast<SIZE_T>(UE::AssetRegistry::Impl::FEventContext::EEvent::MAX);
    FAssetsEvent BatchedAssetEvents[NumBatchedEvents];
 
    FInMemoryAssetCreatedEvent InMemoryAssetCreatedEvent;
 
    FInMemoryAssetDeletedEvent InMemoryAssetDeletedEvent;
 
    FVerseAddedEvent VerseAddedEvent;
 
    FVerseRemovedEvent VerseRemovedEvent;
 
    FFilesLoadedEvent FileLoadedEvent;
 
    FFileLoadProgressUpdatedEvent FileLoadProgressUpdatedEvent;
 
    FScanStartedEvent ScanStartedEvent;
 
    FScanEndedEvent ScanEndedEvent;
 
    FKnownGathersCompleteEvent KnownGathersCompleteEvent;
 
    FEnumerateAssetsEvent EnumerateAssetsEvent;
 
    UE::AssetRegistry::Impl::FEventContext DeferredEvents;
    FTSTicker::FDelegateHandle TickRequestHandle;
    FCriticalSection DeferredEventsCriticalSection;
 
    friend class FAssetDataGatherer;
    friend class UE::AssetRegistry::FAssetRegistryImpl;
    friend struct UE::AssetRegistry::Premade::FAsyncConsumer;
};
PRAGMA_ENABLE_DEPRECATION_WARNINGS