StreamableManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Containers/ArrayView.h"
#include "IO/IoStoreOnDemand.h"
#include "Math/NumericLimits.h"
#include "Misc/PackageAccessTracking.h"
#include "Misc/SourceLocation.h"
#include "Misc/SourceLocationUtils.h"
#include "Templates/Casts.h"
#include "Templates/Function.h"
#include "UObject/Class.h"
#include "UObject/GCObject.h"
#include "UObject/ObjectMacros.h"
#include "UObject/SoftObjectPtr.h"
#include "Experimental/StreamableManagerError.h"
 
enum class EStreamableProgressType : uint8
{
    Load,
    DownloadRelative,
    DownloadAbsolute,
};
 
 
using FStreamableDelegate = TDelegate<void()>;
using FStreamableDelegateWithHandle = TDelegate<void(TSharedPtr<struct FStreamableHandle>)>;
using FStreamableUpdateDelegate = TDelegate<void(TSharedRef<struct FStreamableHandle>)>;
 
using FStreamableDownloadPriority = int16;
 
namespace UE::StreamableManager::Private
{
    // Default priority for all async loads
    static constexpr TAsyncLoadPriority DefaultAsyncLoadPriority    = 0;
    // Priority to try and load immediately
    static constexpr TAsyncLoadPriority AsyncLoadHighPriority       = 100;
 
    static constexpr FStreamableDownloadPriority DownloadVeryLowPriority    = -200;
    static constexpr FStreamableDownloadPriority DownloadLowPriority        = -100;
    static constexpr FStreamableDownloadPriority DownloadDefaultPriority    = 0;
    static constexpr FStreamableDownloadPriority DownloadHighPriority       = 100;
    static constexpr FStreamableDownloadPriority DownloadVeryHighPriority   = 200;
 
    inline FStreamableDelegateWithHandle WrapDelegate(const FStreamableDelegate& InDelegate)
    {
        if (InDelegate.IsBound())
        {
            return FStreamableDelegateWithHandle::CreateLambda(
                [InDelegate](TSharedPtr<FStreamableHandle>)
                {
                    // Delegates may get tick delayed so may not be safe to call if bound to a GC'd object
                    InDelegate.ExecuteIfBound();
                });
        }
 
        return FStreamableDelegateWithHandle();
    }
 
    inline FStreamableDelegateWithHandle WrapDelegate(FStreamableDelegate&& InDelegate)
    {
        if (InDelegate.IsBound())
        {
            return FStreamableDelegateWithHandle::CreateLambda(
                [InDelegate = MoveTemp(InDelegate)](TSharedPtr<FStreamableHandle>)
                {
                    // Delegates may get tick delayed so may not be safe to call if bound to a GC'd object
                    InDelegate.ExecuteIfBound();
                });
        }
 
        return FStreamableDelegateWithHandle();
    }
 
    template<class> inline constexpr bool always_false_v = false;
 
    struct FDownloadContext;
}
 
struct FStreamableDownloadCachePin
{
    ENGINE_API FStreamableDownloadCachePin();
    ENGINE_API ~FStreamableDownloadCachePin();
 
    template<typename DebugNameType = UE::FSourceLocation>
    static FStreamableDownloadCachePin Create(DebugNameType&& DebugNameOrLocation)
    {
        FStreamableDownloadCachePin Result;
        if constexpr (std::is_same_v<std::decay_t<DebugNameType>, UE::FSourceLocation>)
        {
            Result.ContentHandle = UE::IoStore::FOnDemandContentHandle::Create(
                UE::SourceLocation::FileAndLine(DebugNameOrLocation).ToString());
        }
        else
        {
            Result.ContentHandle = UE::IoStore::FOnDemandContentHandle::Create(
                Forward<DebugNameType>(DebugNameOrLocation));
        }
 
        return Result;
    }
 
    ENGINE_API FString GetDebugName() const;
 
    ENGINE_API void Release();
    ENGINE_API bool IsValid() const;
    operator bool() const { return IsValid(); }
    ENGINE_API bool operator==(FStreamableDownloadCachePin& Other) const;
private:
    UE::IoStore::FOnDemandContentHandle ContentHandle;
    friend struct UE::StreamableManager::Private::FDownloadContext;
};
 
#if WITH_EDITOR
enum class ECookLoadType : uint8;
#endif
 
typedef uint8 TStreamableHandleContextDataTypeID;
 
enum { TStreamableHandleContextDataTypeIDInvalid = TNumericLimits<TStreamableHandleContextDataTypeID>::Max() };
 
struct TStreamableHandleContextDataTypeIDStorage
{
private:
    TStreamableHandleContextDataTypeID Value = TStreamableHandleContextDataTypeIDInvalid;
    template <typename SubClassType> friend struct TStreamableHandleContextData;
};
 
struct FStreamableHandleContextDataBase : public TSharedFromThis<FStreamableHandleContextDataBase, ESPMode::ThreadSafe>
{
    TStreamableHandleContextDataTypeID GetInstanceTypeId() const
    {
        return InstanceTypeId;
    }
    template <typename SubClassType> bool IsType() const
    {
        return GetInstanceTypeId() == SubClassType::GetClassTypeId();
    }
 
protected:
    FStreamableHandleContextDataBase(TStreamableHandleContextDataTypeID TypeId)
        : InstanceTypeId(TypeId)
    {}
 
    ENGINE_API static TStreamableHandleContextDataTypeID AllocateClassTypeId();
 
private:
    TStreamableHandleContextDataTypeID InstanceTypeId;
};
 
template <typename SubClassType>
struct TStreamableHandleContextData : public FStreamableHandleContextDataBase
{
    TStreamableHandleContextData()
        : FStreamableHandleContextDataBase(GetClassTypeId())
    {}
 
    static TStreamableHandleContextDataTypeID GetClassTypeId()
    {
        // Subclasses of TStreamableHandleContextData must implement 
        //     MODULE_API static TStreamableHandleContextDataTypeIDStorage&
        //     TypeIdCrossModuleStorage() { static TStreamableHandleContextDataTypeIDStorage Id; return Id; }
        // With MODULE_API being e.g. ENGINE_API.
        // MODULE_API is required for classes used across modules, to ensure that all modules see the same value.
        TStreamableHandleContextDataTypeIDStorage& ClassTypeId = SubClassType::TypeIdCrossModuleStorage();
        if (ClassTypeId.Value == TStreamableHandleContextDataTypeIDInvalid)
        {
            ClassTypeId.Value = AllocateClassTypeId();
        }
        return ClassTypeId.Value;
    }
};
 
struct FStreamableHandle : public TSharedFromThis<FStreamableHandle>
{
    bool HasLoadCompleted() const
    {
        return bLoadCompleted;
    }
 
    bool WasCanceled() const
    {
        return bCanceled;
    }
 
    bool IsLoadingInProgress() const
    {
        return !bLoadCompleted && !bCanceled;
    }
 
    bool IsActive() const
    {
        return !bCanceled && !bReleased;
    }
 
    bool IsStalled() const
    {
        return bStalled;
    }
 
    bool IsCombinedHandle() const
    {
        return bIsCombinedHandle;
    }
 
    bool HasError() const
    {
        return Error.IsSet();
    }
 
    const TOptional<UE::UnifiedError::FError>& GetError() const
    {
        return Error;
    }
 
    FStreamableDownloadCachePin GetDownloadCachePin() const
    {
        return DownloadCachePin;
    }
 
    TArray<FStreamableDownloadCachePin> GetDownloadCachePins() const;
 
    ENGINE_API bool HasLoadCompletedOrStalled() const;
 
    ENGINE_API void SetDebugNameIfEmptyOrDefault(const FString& NewName);
 
    const FString& GetDebugName() const
    {
        return DebugName;
    }
 
#if UE_WITH_PACKAGE_ACCESS_TRACKING
    FName GetReferencerPackage() const
    {
        return ReferencerPackage;
    }
    FName GetRefencerPackageOp() const
    {
        return ReferencerPackageOp;
    }
#endif
#if WITH_EDITOR
    ECookLoadType GetCookLoadType() const
    {
        return CookLoadType;
    }
#endif
 
    TAsyncLoadPriority GetPriority() const
    {
        return Priority;
    }
 
    ENGINE_API TOptional<FStreamableDownloadPriority> GetDownloadPriority() const;
 
    ENGINE_API bool SetDownloadPriority(FStreamableDownloadPriority Priority);
 
    ENGINE_API void ReleaseHandle();
 
    ENGINE_API void CancelHandle();
 
    ENGINE_API void StartStalledHandle();
 
    ENGINE_API bool HasCompleteDelegate() const;
 
    ENGINE_API bool HasCancelDelegate() const;
 
    ENGINE_API bool HasUpdateDelegate() const;
 
    ENGINE_API bool BindCompleteDelegate(FStreamableDelegateWithHandle NewDelegate);
    ENGINE_API bool BindCompleteDelegate(FStreamableDelegate NewDelegate);
 
    ENGINE_API bool BindCancelDelegate(FStreamableDelegateWithHandle NewDelegate);
    ENGINE_API bool BindCancelDelegate(FStreamableDelegate NewDelegate);
 
    ENGINE_API bool BindUpdateDelegate(FStreamableUpdateDelegate NewDelegate);
 
    ENGINE_API EAsyncPackageState::Type WaitUntilComplete(float Timeout = 0.0f, bool bStartStalledHandles = true);
 
    ENGINE_API void GetRequestedAssets(TArray<FSoftObjectPath>& AssetList, bool bIncludeChildren = true) const;
 
    ENGINE_API void GetLoadedAssets(TArray<UObject *>& LoadedAssets) const;
 
    template<class T>
    void GetLoadedAssets(TArray<T*>& LoadedAssets) const
    {
        ForEachLoadedAsset([&LoadedAssets](UObject* LoadedAsset)
        {
            LoadedAssets.Add(Cast<T>(LoadedAsset));
        });
    }
 
    ENGINE_API UObject* GetLoadedAsset() const;
 
    template<class T>
    T* GetLoadedAsset() const
    {
        UObject* LoadedAsset = GetLoadedAsset();
        return Cast<T>(LoadedAsset);
    }
 
    ENGINE_API void GetLoadedCount(int32& LoadedCount, int32& RequestedCount) const;
 
    template <typename CallableT>
    void ForEachLoadedAsset(CallableT Callable) const;
 
    ENGINE_API float GetProgress(EStreamableProgressType Type = EStreamableProgressType::Load) const;
 
    float GetLoadProgress() const { return GetProgress(EStreamableProgressType::Load); }
 
    float GetRelativeDownloadProgress() const { return GetProgress(EStreamableProgressType::DownloadRelative); }
 
    float GetAbsoluteDownloadProgress() const { return GetProgress(EStreamableProgressType::DownloadAbsolute); }
 
    ENGINE_API struct FStreamableManager* GetOwningManager() const;
 
    static ENGINE_API void ExecuteDelegate(const FStreamableDelegateWithHandle& Delegate, TSharedPtr<FStreamableHandle> AssociatedHandle = nullptr, const FStreamableDelegateWithHandle& CancelDelegate = FStreamableDelegateWithHandle());
    static ENGINE_API void ExecuteDelegate(FStreamableDelegateWithHandle&& Delegate, TSharedPtr<FStreamableHandle> AssociatedHandle = nullptr, FStreamableDelegateWithHandle&& CancelDelegate = FStreamableDelegateWithHandle());
 
    static ENGINE_API void ExecuteDelegate(const FStreamableDelegate& Delegate, TSharedPtr<FStreamableHandle> AssociatedHandle = nullptr, const FStreamableDelegate& CancelDelegate = FStreamableDelegate());
    static ENGINE_API void ExecuteDelegate(FStreamableDelegate&& Delegate, TSharedPtr<FStreamableHandle> AssociatedHandle = nullptr, FStreamableDelegate&& CancelDelegate = FStreamableDelegate());
 
    ENGINE_API TSharedPtr<FStreamableHandle> FindMatchingHandle(TFunction<bool(const FStreamableHandle&)> Predicate) const;
 
    ENGINE_API TSharedPtr<FStreamableHandle> CreateCombinedHandle(const TConstArrayView<TSharedPtr<FStreamableHandle>>& OtherHandles);
 
    ENGINE_API TSharedPtr<FStreamableHandle> GetOutermostHandle();
 
    template <typename T>
    T& FindOrAddContextData()
    {
        TSharedPtr<T> FoundInternally = FindFirstContextDataOfType<T>();
        if (FoundInternally.IsValid())
        {
            return *FoundInternally.Get();
        }
 
        TSharedPtr<T> FreshlyAdded = MakeShared<T>();
        AddContextData(FreshlyAdded);
 
        return *FreshlyAdded.Get();
    }
 
    template <typename T>
    void AddContextData(const TSharedPtr<T>& NewData)
    {
        AdditionalContextData.Add(NewData);
    }
 
    template <typename T>
    TSharedPtr<T> FindFirstContextDataOfType() const
    {
        for (const TSharedPtr<FStreamableHandleContextDataBase>& InternalPtr : AdditionalContextData)
        {
            if (InternalPtr.IsValid() && InternalPtr->IsType<T>())
            {
                return StaticCastSharedPtr<T>(InternalPtr);
            }
        }
        
        return nullptr;
    }
 
    template <typename T>
    TArray<TSharedPtr<T>> GetContextDataOfType() const
    {
        TArray<TSharedPtr<T>> OfType;
 
        for (const TSharedPtr<FStreamableHandleContextDataBase>& InternalPtr : AdditionalContextData)
        {
            if (InternalPtr.IsValid() && InternalPtr->IsType<T>())
            {
                OfType.Add(StaticCastSharedPtr<T>(InternalPtr));
            }
        }
 
        return OfType;
    }
 
private:
    struct FPrivateToken { explicit FPrivateToken() = default; };
    FStreamableHandle() = delete;
public:
    explicit FStreamableHandle(FPrivateToken, UE::FSourceLocation&& InLocation);
 
    ENGINE_API ~FStreamableHandle();
 
    FStreamableHandle(const FStreamableHandle&) = delete;
    FStreamableHandle& operator=(const FStreamableHandle&) = delete;
 
    static ENGINE_API const FString HandleDebugName_Preloading;
    static ENGINE_API const FString HandleDebugName_AssetList;
    static ENGINE_API const FString HandleDebugName_CombinedHandle;
    static ENGINE_API const FString HandleDebugName_Error;
 
private:
    friend struct FStreamableManager;
    friend struct FStreamable;
    friend struct UE::StreamableManager::Private::FDownloadContext;
 
    bool IsHandleNameEmptyOrDefault() const;
 
    void CompleteLoad();
 
    void AsyncLoadCallbackWrapper(const FName& PackageName, UPackage* LevelPackage, EAsyncLoadingResult::Type Result, FSoftObjectPath TargetName);
 
    void NotifyParentsOfCompletion();
 
    void NotifyParentsOfCancellation();
 
    void UpdateCombinedHandle();
 
    void CallUpdateDelegate();
 
    void UnbindDelegates();
 
    void SetError(const UE::UnifiedError::FError& Error);
    void SetErrorOnParents(const UE::UnifiedError::FError& Error);
 
    FStreamableDelegateWithHandle CompleteDelegate;
 
    FStreamableDelegateWithHandle CancelDelegate;
 
    FStreamableUpdateDelegate UpdateDelegate;
 
    FString DebugName;
 
    UE::FSourceLocation Location;
 
    TOptional<UE::UnifiedError::FError> Error;
 
    FStreamableDownloadCachePin DownloadCachePin;
 
    TUniquePtr<UE::StreamableManager::Private::FDownloadContext> DownloadContext;
 
    TAsyncLoadPriority Priority;
 
    int32 StreamablesLoading;
 
    int32 CompletedChildCount = 0;
 
    int32 CanceledChildCount = 0;
 
    TArray<FSoftObjectPath> RequestedAssets;
 
    TArray<TSharedPtr<FStreamableHandle> > ChildHandles;
 
    TArray<TWeakPtr<FStreamableHandle> > ParentHandles;
 
#if UE_WITH_PACKAGE_ACCESS_TRACKING
    FName ReferencerPackage;
    FName ReferencerPackageOp;
#endif
 
    struct FStreamableManager* OwningManager;
 
    TArray<TSharedPtr<FStreamableHandleContextDataBase>> AdditionalContextData;
 
#if WITH_EDITOR
    ECookLoadType CookLoadType;
#endif
 
    bool bLoadStarted;
 
    bool bLoadCompleted;
 
    bool bReleased;
 
    bool bCanceled;
 
    bool bStalled;
 
    bool bReleaseWhenLoaded;
 
    bool bIsCombinedHandle;
};
 
enum class EStreamableManagerCombinedHandleOptions : uint8 
{
    None = 0,
    MergeDebugNames = 0x01,
    RedirectParents = 0x02,
    SkipNulls = 0x04,
};
 
ENUM_CLASS_FLAGS(EStreamableManagerCombinedHandleOptions);
 
struct FStreamableDownloadParams
{
    FStreamableDownloadCachePin CachePin;
    FStreamableDownloadPriority Priority = UE::StreamableManager::Private::DownloadDefaultPriority;
    bool bInstallSoftReferences = false;
    bool bDownloadOnly = false;
};
 
struct FStreamableAsyncLoadParams
{
    TArray<FSoftObjectPath> TargetsToStream;
    FStreamableDelegateWithHandle OnComplete;
    FStreamableDelegateWithHandle OnCancel;
    FStreamableUpdateDelegate OnUpdate;
    TAsyncLoadPriority Priority = UE::StreamableManager::Private::DefaultAsyncLoadPriority;
    bool bManageActiveHandle = false;
    bool bStartStalled = false;
    TOptional<FStreamableDownloadParams> DownloadParams;
};
 
struct FStreamableManager : public FGCObject
{
    // Default priority for all async loads
    static inline constexpr TAsyncLoadPriority DefaultAsyncLoadPriority     = UE::StreamableManager::Private::DefaultAsyncLoadPriority;
    // Priority to try and load immediately
    static inline constexpr TAsyncLoadPriority AsyncLoadHighPriority        = UE::StreamableManager::Private::AsyncLoadHighPriority;
 
    static inline constexpr FStreamableDownloadPriority DownloadVeryLowPriority     = UE::StreamableManager::Private::DownloadVeryLowPriority;
    static inline constexpr FStreamableDownloadPriority DownloadLowPriority         = UE::StreamableManager::Private::DownloadLowPriority;
    static inline constexpr FStreamableDownloadPriority DownloadDefaultPriority     = UE::StreamableManager::Private::DownloadDefaultPriority;
    static inline constexpr FStreamableDownloadPriority DownloadHighPriority        = UE::StreamableManager::Private::DownloadHighPriority;
    static inline constexpr FStreamableDownloadPriority DownloadVeryHighPriority    = UE::StreamableManager::Private::DownloadVeryHighPriority;
 
    template< typename PathContainerType = TArray<FSoftObjectPath>, typename FuncType = FStreamableDelegateWithHandle, typename = std::enable_if_t<!std::is_same_v<std::decay_t<PathContainerType>, FStreamableAsyncLoadParams>, void> >
    TSharedPtr<FStreamableHandle> RequestAsyncLoad(
        PathContainerType&& TargetsToStream,
        FuncType&& DelegateToCall = FStreamableDelegateWithHandle(),
        TAsyncLoadPriority Priority = DefaultAsyncLoadPriority,
        bool bManageActiveHandle = false,
        bool bStartStalled = false,
        FString DebugName = FString(),
        UE::FSourceLocation Location = UE::FSourceLocation::Current());
 
    ENGINE_API TSharedPtr<FStreamableHandle> RequestAsyncLoad(
        FStreamableAsyncLoadParams&& Params,
        FString DebugName = FString(),
        UE::FSourceLocation Location = UE::FSourceLocation::Current());
 
    template< typename PathContainerType = TArray<FSoftObjectPath>>
    TSharedPtr<FStreamableHandle> RequestSyncLoad(
        PathContainerType&& TargetsToStream,
        bool bManageActiveHandle = false,
        FString DebugName = FString(),
        UE::FSourceLocation Location = UE::FSourceLocation::Current());
 
    ENGINE_API UObject* LoadSynchronous(
        const FSoftObjectPath& Target,
        bool bManageActiveHandle = false,
        TSharedPtr<FStreamableHandle>* RequestHandlePointer = nullptr,
        UE::FSourceLocation Location = UE::FSourceLocation::Current());
 
    template< typename T >
    T* LoadSynchronous(
        const FSoftObjectPath& Target,
        bool bManageActiveHandle = false,
        TSharedPtr<FStreamableHandle>* RequestHandlePointer = nullptr,
        UE::FSourceLocation Location = UE::FSourceLocation::Current())
    {
        return Cast<T>(LoadSynchronous(Target, bManageActiveHandle, RequestHandlePointer, MoveTemp(Location)) );
    }
 
    template< typename T >
    T* LoadSynchronous(
        const TSoftObjectPtr<T>& Target,
        bool bManageActiveHandle = false,
        TSharedPtr<FStreamableHandle>* RequestHandlePointer = nullptr,
        UE::FSourceLocation Location = UE::FSourceLocation::Current())
    {
        return Cast<T>(LoadSynchronous(Target.ToSoftObjectPath(), bManageActiveHandle, RequestHandlePointer, MoveTemp(Location)));
    }
 
    template< typename T >
    TSubclassOf<T> LoadSynchronous(
        const TSoftClassPtr<T>& Target,
        bool bManageActiveHandle = false,
        TSharedPtr<FStreamableHandle>* RequestHandlePointer = nullptr,
        UE::FSourceLocation Location = UE::FSourceLocation::Current())
    {
        TSubclassOf<T> ReturnClass;
        ReturnClass = Cast<UClass>(LoadSynchronous(Target.ToSoftObjectPath(), bManageActiveHandle, RequestHandlePointer, MoveTemp(Location)));
        return ReturnClass;
    }
 
    ENGINE_API TSharedPtr<FStreamableHandle> CreateCombinedHandle(
        TConstArrayView<TSharedPtr<FStreamableHandle>> ChildHandles,
        FString DebugName = FStreamableHandle::HandleDebugName_CombinedHandle,
        EStreamableManagerCombinedHandleOptions Options = EStreamableManagerCombinedHandleOptions::None,
        FStreamableAsyncLoadParams&& Params = FStreamableAsyncLoadParams{},
        UE::FSourceLocation Location = UE::FSourceLocation::Current()
    );
 
    ENGINE_API TSharedPtr<FStreamableHandle> CreateErrorHandle(
        UE::UnifiedError::FError&& Error,
        FStreamableAsyncLoadParams&& Params,
        FString DebugName = FStreamableHandle::HandleDebugName_CombinedHandle,
        UE::FSourceLocation Location = UE::FSourceLocation::Current());
 
    ENGINE_API bool GetActiveHandles(const FSoftObjectPath& Target, TArray<TSharedRef<FStreamableHandle>>& HandleList, bool bOnlyManagedHandles = false) const;
 
    ENGINE_API bool AreAllAsyncLoadsComplete() const;
 
    ENGINE_API bool IsAsyncLoadComplete(const FSoftObjectPath& Target) const;
 
    ENGINE_API void Unload(const FSoftObjectPath& Target);
 
    ENGINE_API FSoftObjectPath ResolveRedirects(const FSoftObjectPath& Target) const;
 
    ENGINE_API const FString& GetManagerName() const;
 
    ENGINE_API void SetManagerName(FString InName);
 
    ENGINE_API virtual void AddReferencedObjects(FReferenceCollector& Collector) override;
    virtual FString GetReferencerName() const override { return ManagerName; }
    ENGINE_API virtual bool GetReferencerPropertyName(UObject* Object, FString& OutPropertyName) const override;
 
    ENGINE_API FStreamableManager();
    ENGINE_API ~FStreamableManager();
 
    FStreamableManager(const FStreamableManager&) = delete;
    FStreamableManager& operator=(const FStreamableManager&) = delete;
private:
    friend FStreamableHandle;
    friend UE::StreamableManager::Private::FDownloadContext;
 
    void RemoveReferencedAsset(const FSoftObjectPath& Target, TSharedRef<FStreamableHandle> Handle);
    void StartHandleRequests(TSharedRef<FStreamableHandle> Handle);
    TArray<int32> GetAsyncLoadRequestIds(TSharedRef<FStreamableHandle> Handle);
    void FindInMemory(FSoftObjectPath& InOutTarget, struct FStreamable* Existing, UPackage* Package = nullptr);
    FSoftObjectPath HandleLoadedRedirector(UObjectRedirector* LoadedRedirector, FSoftObjectPath RequestedPath, struct FStreamable* RequestedStreamable);
    struct FStreamable* FindStreamable(const FSoftObjectPath& Target) const;
    struct FStreamable* StreamInternal(const FSoftObjectPath& Target, TAsyncLoadPriority Priority, TSharedRef<FStreamableHandle> Handle);
    ENGINE_API UObject* GetStreamed(const FSoftObjectPath& Target) const;
    void CheckCompletedRequests(const FSoftObjectPath& Target, struct FStreamable* Existing);
 
    void OnPreGarbageCollect();
    void AsyncLoadCallback(FSoftObjectPath Request, UPackage* Package, const TOptional<UE::UnifiedError::FError> AsyncLoadError);
 
    ENGINE_API static bool ShouldStripDebugName();
    ENGINE_API TSharedPtr<FStreamableHandle> RequestSyncLoadInternal(TArray<FSoftObjectPath>&& TargetsToStream, bool bManageActiveHandle, FString&& DebugName, UE::FSourceLocation&& Location);
 
    typedef TMap<FSoftObjectPath, struct FStreamable*> TStreamableMap;
    TStreamableMap StreamableItems;
 
    struct FRedirectedPath
    {
        FSoftObjectPath NewPath;
 
        TObjectPtr<UObjectRedirector> LoadedRedirector;
 
        FRedirectedPath() : LoadedRedirector(nullptr) {}
        FRedirectedPath(const FSoftObjectPath& InNewPath, UObjectRedirector* InLoadedRedirector) : NewPath(InNewPath),LoadedRedirector(InLoadedRedirector) {}
    };
    typedef TMap<FSoftObjectPath, FRedirectedPath> TStreamableRedirects;
    TStreamableRedirects StreamableRedirects;
 
    TArray<TSharedRef<FStreamableHandle>> ManagedActiveHandles;
 
    TArray<TSharedRef<FStreamableHandle>> PendingCombinedHandles;
 
    bool bForceSynchronousLoads;
 
    FString ManagerName;
};
 
template <typename CallableT>
void FStreamableHandle::ForEachLoadedAsset(CallableT Callable) const
{
    if (HasLoadCompleted())
    {
        for (const FSoftObjectPath& Ref : RequestedAssets)
        {
            // Try manager, should be faster and will handle redirects better
            if (IsActive())
            {
                Invoke(Callable, OwningManager->GetStreamed(Ref));
            }
            else
            {
                Invoke(Callable, Ref.ResolveObject());
            }
        }
 
        // Check child handles
        for (const TSharedPtr<FStreamableHandle>& ChildHandle : ChildHandles)
        {
            for (const FSoftObjectPath& Ref : ChildHandle->RequestedAssets)
            {
                // Try manager, should be faster and will handle redirects better
                if (IsActive())
                {
                    Invoke(Callable, OwningManager->GetStreamed(Ref));
                }
                else
                {
                    Invoke(Callable, Ref.ResolveObject());
                }
            }
        }
    }
}
 
template< typename PathContainerType, typename FuncType, typename >
TSharedPtr<FStreamableHandle> FStreamableManager::RequestAsyncLoad(
    PathContainerType&& TargetsToStream,
    FuncType&& Callback,
    TAsyncLoadPriority Priority,
    bool bManageActiveHandle,
    bool bStartStalled,
    FString DebugName,
    UE::FSourceLocation Location)
{
    FStreamableAsyncLoadParams Params;
    Params.TargetsToStream = TArray<FSoftObjectPath>{ Forward<PathContainerType>(TargetsToStream) };
 
    if constexpr (std::is_constructible_v<FStreamableDelegateWithHandle, FuncType>)
    {
        Params.OnComplete = FStreamableDelegateWithHandle(Forward<FuncType>(Callback));
    }
    else if constexpr (std::is_constructible_v<FStreamableDelegate, FuncType>)
    {
        Params.OnComplete = UE::StreamableManager::Private::WrapDelegate(
            FStreamableDelegate(Forward<FuncType>(Callback)));
    }
    else if constexpr (std::is_invocable_v<FuncType, TSharedPtr<FStreamableHandle>>)
    {
        Params.OnComplete = FStreamableDelegateWithHandle::CreateLambda(Forward<FuncType>(Callback));
    }
    else if constexpr (std::is_invocable_v<FuncType>)
    {
        Params.OnComplete = UE::StreamableManager::Private::WrapDelegate(
            FStreamableDelegate::CreateLambda(Forward<FuncType>(Callback)));
    }
    else
    {
        // Static assertions are evaluated even in non-instantiable static branches unless a dependent type is used. C++23 fixes this.
        static_assert(UE::StreamableManager::Private::always_false_v<FuncType>, "Cannot bind callback");
    }
 
    Params.Priority = Priority;
    Params.bManageActiveHandle = bManageActiveHandle;
    Params.bStartStalled = bStartStalled;
 
    return RequestAsyncLoad(
        MoveTemp(Params),
        MoveTemp(DebugName),
        MoveTemp(Location));
}
 
template< typename PathContainerType>
TSharedPtr<FStreamableHandle> FStreamableManager::RequestSyncLoad(
    PathContainerType&& TargetsToStream,
    bool bManageActiveHandle,
    FString DebugName,
    UE::FSourceLocation Location)
{
    return RequestSyncLoadInternal(
        TArray<FSoftObjectPath>{ Forward<PathContainerType>(TargetsToStream) },
        bManageActiveHandle,
        MoveTemp(DebugName),
        MoveTemp(Location));
}