ContentStreaming.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    ContentStreaming.h: Definitions of classes used for content streaming.
=============================================================================*/
 
#pragma once
 
#include "Async/TaskGraphInterfaces.h"
#include "CoreMinimal.h"
#include "RenderedTextureStats.h"
#include "Serialization/BulkData.h"
#include "UObject/ObjectKey.h"
#include "UObject/WeakObjectPtr.h"
 
class AActor;
class FSoundSource;
class UPrimitiveComponent;
class FCanvas;
class FViewport;
class FSoundWaveData;
class FSoundWaveProxy;
class ICompressedAudioInfo;
class UTexture2D;
struct FRenderAssetStreamingManager;
struct FWaveInstance;
class UAnimStreamable;
enum class EStreamableRenderAssetType : uint8;
struct FCompressedAnimSequence;
class UStreamableSparseVolumeTexture;
 
using FSoundWaveProxyPtr = TSharedPtr<FSoundWaveProxy, ESPMode::ThreadSafe>;
 
/*-----------------------------------------------------------------------------
    Stats.
-----------------------------------------------------------------------------*/
 
// Forward declarations
class UPrimitiveComponent;
class AActor;
class UTexture2D;
class UStaticMesh;
class USkeletalMesh;
class UStreamableRenderAsset;
class FRenderAssetUpdate;
class FSoundSource;
class FAudioStreamCacheMemoryHandle;
struct FWaveInstance;
struct FRenderAssetStreamingManager;
 
namespace Nanite
{
    class FCoarseMeshStreamingManager;
}
 
void FlushResourceStreaming();
 
/*-----------------------------------------------------------------------------
    Base streaming classes.
-----------------------------------------------------------------------------*/
 
enum ERemoveStreamingViews
{
    RemoveStreamingViews_Normal,
    RemoveStreamingViews_All
};
 
struct FStreamingViewInfo
{
    FStreamingViewInfo( const FVector& InViewOrigin, float InScreenSize, float InFOVScreenSize, float InBoostFactor, bool bInOverrideLocation, float InDuration, TWeakObjectPtr<AActor> InActorToBoost, TWeakObjectPtr<UWorld> InWorld)
    :   ViewOrigin( InViewOrigin )
    ,   ScreenSize( InScreenSize )
    ,   FOVScreenSize( InFOVScreenSize )
    ,   BoostFactor( InBoostFactor )
    ,   Duration( InDuration )
    ,   bOverrideLocation( bInOverrideLocation )
    ,   ActorToBoost( InActorToBoost )
    ,   World( InWorld )
    {
    }
    FVector ViewOrigin;
    float   ScreenSize;
    float   FOVScreenSize;
    float   BoostFactor;
    float   Duration;
    bool    bOverrideLocation;
    TWeakObjectPtr<AActor> ActorToBoost;
    TWeakObjectPtr<UWorld> World;
};
 
class FAudioChunkHandle
{
public:
    ENGINE_API FAudioChunkHandle();
    ENGINE_API FAudioChunkHandle(const FAudioChunkHandle& Other);
    ENGINE_API FAudioChunkHandle(FAudioChunkHandle&& Other);
 
    ENGINE_API FAudioChunkHandle& operator=(const FAudioChunkHandle& Other);
    ENGINE_API FAudioChunkHandle& operator=(FAudioChunkHandle&& Other);
 
    ENGINE_API ~FAudioChunkHandle();
 
    // gets a pointer to the compressed chunk.
    ENGINE_API const uint8* GetData() const;
 
    // Returns the num bytes pointed to by GetData().
    ENGINE_API uint32 Num() const;
 
    // Checks whether this points to a valid compressed chunk.
    ENGINE_API bool IsValid() const;
 
#if WITH_EDITOR
    // If the soundwave has been recompressed, the compressed audio retained by this handle will not be up to date, and this will return true. 
    ENGINE_API bool IsStale() const;
#endif
 
private:
    // This constructor should only be called by an implementation of IAudioStreamingManager.
    ENGINE_API FAudioChunkHandle(const uint8* InData, uint32 NumBytes, const FSoundWaveProxyPtr&  InSoundWave, const FName& SoundWaveName, uint32 InChunkIndex, uint64 InCacheLookupID);
 
    const uint8*  CachedData;
    int32 CachedDataNumBytes;
 
    FName CorrespondingWaveName;
    FGuid CorrespondingWaveGuid;
 
    // The index of this chunk in the sound wave's full set of chunks of compressed audio.
    int32 ChunkIndex;
 
#if WITH_EDITOR
    TWeakPtr<FSoundWaveData, ESPMode::ThreadSafe> CorrespondingWave;
    uint32 ChunkRevision;
#endif
 
    friend struct IAudioStreamingManager;
    friend struct FCachedAudioStreamingManager;
};
 
struct IStreamingManager
{
    IStreamingManager()
        : NumWantingResources(0)
        , NumWantingResourcesCounter(0)
    {
    }
 
    virtual ~IStreamingManager()
    {}
 
    ENGINE_API static struct FStreamingManagerCollection& Get();
 
    ENGINE_API static struct FStreamingManagerCollection* Get_Concurrent();
 
    ENGINE_API static void Shutdown();
 
    ENGINE_API static bool HasShutdown();
 
    ENGINE_API virtual void Tick(float DeltaTime, bool bProcessEverything = false);
 
    virtual void UpdateResourceStreaming(float DeltaTime, bool bProcessEverything = false) = 0;
 
    ENGINE_API virtual int32 StreamAllResources(float TimeLimit = 0.0f);
    
    virtual int32 BlockTillAllRequestsFinished(float TimeLimit = 0.0f, bool bLogResults = false) = 0;
 
    virtual void CancelForcedResources() = 0;
 
    virtual void NotifyLevelChange() = 0;
 
    void RemoveStreamingViews(ERemoveStreamingViews RemovalType);
 
    ENGINE_API void AddViewInformation(const FVector& ViewOrigin, float ScreenSize, float FOVScreenSize, float BoostFactor = 1.0f, bool bOverrideLocation = false, float Duration = 0.0f, TWeakObjectPtr<AActor> InActorToBoost = NULL, TWeakObjectPtr<UWorld> InWorld = NULL);
 
    ENGINE_API void AddViewLocation(const FVector& Location, float BoostFactor = 1.0f, bool bOverrideLocation = false, float Duration = 0.0f);
 
    virtual void SetDisregardWorldResourcesForFrames(int32 NumFrames) = 0;
 
    virtual bool Exec(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar)
    {
        return false;
    }
 
    virtual void AddLevel(class ULevel* Level) = 0;
 
    virtual void RemoveLevel(class ULevel* Level) = 0;
 
    virtual void NotifyLevelOffset(class ULevel* Level, const FVector& Offset) = 0;
 
    virtual void NotifyActorDestroyed(AActor* Actor)
    {
    }
 
    virtual void NotifyPrimitiveDetached(const UPrimitiveComponent* Primitive)
    {
    }
 
    virtual void NotifyPrimitiveUpdated(const UPrimitiveComponent* Primitive)
    {
    }
 
    virtual void NotifyPrimitiveUpdated_Concurrent(const UPrimitiveComponent* Primitive)
    {
    }
 
    int32 GetNumViews() const
    {
        return CurrentViewInfos.Num();
    }
 
    const FStreamingViewInfo& GetViewInformation(int32 ViewIndex) const
    {
        return CurrentViewInfos[ViewIndex];
    }
 
    virtual int32 GetNumWantingResources() const
    {
        return NumWantingResources;
    }
 
    virtual int32 GetNumWantingResourcesID() const
    {
        return NumWantingResourcesCounter;
    }
 
    virtual void PropagateLightingScenarioChange()
    {
    }
 
#if WITH_EDITOR
    virtual void OnAudioStreamingParamsChanged() {};
#endif
 
protected:
 
    void SetupViewInfos( float DeltaTime );
 
    static void AddViewInfoToArray( TArray<FStreamingViewInfo> &ViewInfos, const FVector& ViewOrigin, float ScreenSize, float FOVScreenSize, float BoostFactor, bool bOverrideLocation, float Duration, TWeakObjectPtr<AActor> InActorToBoost, TWeakObjectPtr<UWorld> InWorld);
 
    static void RemoveViewInfoFromArray( TArray<FStreamingViewInfo> &ViewInfos, const FVector& ViewOrigin );
 
    struct FSecondaryLocation
    {
        FSecondaryLocation( const FVector& InLocation, float InBoostFactor, bool bInOverrideLocation, float InDuration )
        :   Location( InLocation )
        ,   BoostFactor( InBoostFactor )
        ,   Duration( InDuration )
        ,   bOverrideLocation( bInOverrideLocation )
        {
        }
        FVector     Location;
        float       BoostFactor;
        float       Duration;
        bool        bOverrideLocation;
    };
 
    ENGINE_API static TArray<FStreamingViewInfo> CurrentViewInfos;
 
    static TArray<FStreamingViewInfo> PendingViewInfos;
 
    static TArray<FStreamingViewInfo> LastingViewInfos;
 
    static TArray<FSecondaryLocation> SecondaryLocations;
 
    static bool bPendingRemoveViews;
 
    int32       NumWantingResources;
 
    int32       NumWantingResourcesCounter;
};
 
struct IRenderAssetStreamingManager : public IStreamingManager
{
    virtual void UpdateIndividualRenderAsset(UStreamableRenderAsset* RenderAsset) = 0;
 
    virtual bool FastForceFullyResident(UStreamableRenderAsset* RenderAsset) = 0;
 
    virtual void BoostTextures(AActor* Actor, float BoostFactor) = 0;
 
    virtual bool StreamOutRenderAssetData(int64 RequiredMemorySize) = 0;
 
    virtual void AddStreamingRenderAsset(UStreamableRenderAsset* RenderAsset) = 0;
 
    virtual void RemoveStreamingRenderAsset(UStreamableRenderAsset* RenderAsset) = 0;
 
    virtual bool IsFullyStreamedIn(UStreamableRenderAsset* RenderAsset) = 0;
 
    virtual int64 GetMemoryOverBudget() const = 0;
 
    virtual int64 GetPoolSize() const = 0;
 
    virtual int64 GetRequiredPoolSize() const = 0;
 
    virtual int64 GetMaxEverRequired() const = 0;
 
    virtual float GetCachedMips() const = 0;
 
    virtual void ResetMaxEverRequired() = 0;
 
    virtual void PauseRenderAssetStreaming(bool bInShouldPause) = 0;
 
    virtual void GetObjectReferenceBounds(const UObject* RefObject, TArray<FBox>& AssetBoxes) = 0;
 
    constexpr static auto ShouldChooseDefault = [](const UPrimitiveComponent*) { return true; };
 
    virtual void GetAssetComponents(
        const UStreamableRenderAsset* RenderAsset,
        TArray<const UPrimitiveComponent*>& OutComps,
        TFunction<bool(const UPrimitiveComponent*)> ShouldChoose = ShouldChooseDefault) = 0;
 
    //BEGIN: APIs for backward compatibility
    ENGINE_API void UpdateIndividualTexture(UTexture2D* Texture);
    ENGINE_API bool StreamOutTextureData(int64 RequiredMemorySize);
    ENGINE_API void AddStreamingTexture(UTexture2D* Texture);
    ENGINE_API void RemoveStreamingTexture(UTexture2D* Texture);
    ENGINE_API void PauseTextureStreaming(bool bInShouldPause);
    //END: APIs for backward compatibility
 
    virtual void MarkMountedStateDirty(FIoFilenameHash FilenameHash) = 0;
 
    virtual void AddRenderedTextureStats(TMap<FString, FRenderedTextureStats>& InOutRenderedTextureAssets) = 0;
 
    virtual void OnRenderAssetUpdateAbandoned(UStreamableRenderAsset* OwningRenderAsset, TRefCountPtr<FRenderAssetUpdate>& RenderAssetUpdate) = 0;
};
 
enum class EAudioChunkLoadResult : uint8
{
    Completed,
    AlreadyLoaded,
    Interrupted,
    ChunkOutOfBounds,
    CacheBlown
};
 
struct IAudioStreamingManager : public IStreamingManager
{
    virtual void AddForceInlineSoundWave(const FSoundWaveProxyPtr& SoundWave) { };
 
    virtual void RemoveForceInlineSoundWave(const FSoundWaveProxyPtr& SoundWave) { };
    
    constexpr static auto LoadCompletedDefault = [](EAudioChunkLoadResult) {};
    virtual bool RequestChunk(const FSoundWaveProxyPtr& SoundWave, uint32 ChunkIndex, TFunction<void(EAudioChunkLoadResult)> OnLoadCompleted = LoadCompletedDefault, ENamedThreads::Type ThreadToCallOnLoadCompletedOn = ENamedThreads::AnyThread, bool bForImmediatePlayback = false) = 0;
 
    virtual FAudioChunkHandle GetLoadedChunk(const FSoundWaveProxyPtr&  SoundWave, uint32 ChunkIndex,  bool bBlockForLoad = false, bool bForImmediatePlayback = false) const = 0;
 
    virtual uint64 TrimMemory(uint64 NumBytesToFree) = 0;
 
    virtual int32 RenderStatAudioStreaming(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation, const FRotator* ViewRotation) = 0;
 
    virtual FString GenerateMemoryReport() = 0;
 
    virtual void SetProfilingMode(bool bEnabled) = 0;
 
    virtual void HandleStarvation(const FSoundWaveProxyPtr& SoundWave, const uint32 ChunkIndex, const uint32 InBytesProduced, const uint32 InBytesExpected ) {}
 
protected:
    friend FAudioChunkHandle;
    friend FAudioStreamCacheMemoryHandle;
 
    static FAudioChunkHandle BuildChunkHandle(const uint8* InData, uint32 NumBytes, const FSoundWaveProxyPtr& InSoundWave, const FName& SoundWaveName, uint32 InChunkIndex, uint64 CacheLookupID);
 
    virtual void AddReferenceToChunk(const FAudioChunkHandle& InHandle) = 0;
 
    virtual void RemoveReferenceToChunk(const FAudioChunkHandle& InHandle) = 0;
 
    virtual void AddMemoryCountedFeature(const FAudioStreamCacheMemoryHandle& Feature) { };
 
    virtual void RemoveMemoryCountedFeature(const FAudioStreamCacheMemoryHandle& Feature) { };
 
// DEPRECATED VIRTUAL INTERFACE
private:
    static void LogWarning();
};
 
struct FDummyAudioStreamingManager final : public IAudioStreamingManager
{
    virtual void UpdateResourceStreaming(float DeltaTime, bool bProcessEverything = false) override {}
    virtual int32 BlockTillAllRequestsFinished(float TimeLimit = 0.0f, bool bLogResults = false) override { return 0; }
    virtual void CancelForcedResources() override {}
    virtual void NotifyLevelChange() override {}
    virtual void SetDisregardWorldResourcesForFrames(int32 NumFrames) {}
    virtual void AddLevel(class ULevel* Level) {}
    virtual void RemoveLevel(class ULevel* Level) {}
    virtual void NotifyLevelOffset(class ULevel* Level, const FVector& Offset) {}
 
    virtual void AddMemoryCountedFeature(const FAudioStreamCacheMemoryHandle& Feature) override {}
    virtual void RemoveMemoryCountedFeature(const FAudioStreamCacheMemoryHandle& Feature) override {}
    virtual bool RequestChunk(const FSoundWaveProxyPtr& SoundWave, uint32 ChunkIndex, TFunction<void(EAudioChunkLoadResult)> OnLoadCompleted = LoadCompletedDefault, ENamedThreads::Type ThreadToCallOnLoadCompletedOn = ENamedThreads::AnyThread, bool bForImmediatePlayback = false) override { return false; }
    virtual FAudioChunkHandle GetLoadedChunk(const FSoundWaveProxyPtr& SoundWave, uint32 ChunkIndex, bool bBlockForLoad = false, bool bForImmediatePlayback = false) const override { return FAudioChunkHandle(); }
    virtual uint64 TrimMemory(uint64 NumBytesToFree) override { return 0; }
    virtual int32 RenderStatAudioStreaming(UWorld* World, FViewport* Viewport, FCanvas* Canvas, int32 X, int32 Y, const FVector* ViewLocation, const FRotator* ViewRotation) override { return 0; }
    virtual FString GenerateMemoryReport() override { return TEXT(""); }
    virtual void SetProfilingMode(bool bEnabled) override {}
 
protected:
    virtual void AddReferenceToChunk(const FAudioChunkHandle& InHandle) override {}
    virtual void RemoveReferenceToChunk(const FAudioChunkHandle& InHandle) override {}
};
 
struct IAnimationStreamingManager : public IStreamingManager
{
    virtual void AddStreamingAnim(UAnimStreamable* Anim) = 0;
 
    virtual bool RemoveStreamingAnim(UAnimStreamable* Anim) = 0;
 
    virtual SIZE_T GetMemorySizeForAnim(const UAnimStreamable* Anim) = 0;
 
    virtual const FCompressedAnimSequence* GetLoadedChunk(const UAnimStreamable* Anim, uint32 ChunkIndex, bool bRequestNextChunk) const = 0;
};
 
struct FStreamingManagerCollection : public IStreamingManager
{
    ENGINE_API FStreamingManagerCollection();
    ENGINE_API ~FStreamingManagerCollection();
 
    ENGINE_API virtual void Tick( float DeltaTime, bool bProcessEverything=false ) override;
 
    virtual void UpdateResourceStreaming( float DeltaTime, bool bProcessEverything=false ) override;
 
    virtual int32 StreamAllResources( float TimeLimit=0.0f ) override;
 
    virtual int32 BlockTillAllRequestsFinished( float TimeLimit = 0.0f, bool bLogResults = false ) override;
 
    virtual int32 GetNumWantingResources() const override;
 
    virtual int32 GetNumWantingResourcesID() const override;
 
    virtual void CancelForcedResources() override;
 
    virtual void NotifyLevelChange() override;
 
    ENGINE_API bool IsStreamingEnabled() const;
 
    ENGINE_API bool IsTextureStreamingEnabled() const;
 
    ENGINE_API bool IsRenderAssetStreamingEnabled(EStreamableRenderAssetType FilteredAssetType) const;
 
    ENGINE_API IRenderAssetStreamingManager& GetTextureStreamingManager() const;
 
    ENGINE_API IRenderAssetStreamingManager& GetRenderAssetStreamingManager() const;
 
    ENGINE_API IAudioStreamingManager& GetAudioStreamingManager() const;
 
    ENGINE_API IAnimationStreamingManager& GetAnimationStreamingManager() const;
 
    ENGINE_API struct FVirtualTextureChunkStreamingManager& GetVirtualTextureStreamingManager() const;
 
    ENGINE_API Nanite::FCoarseMeshStreamingManager* GetNaniteCoarseMeshStreamingManager() const;
 
    ENGINE_API void AddStreamingManager( IStreamingManager* StreamingManager );
 
    ENGINE_API void RemoveStreamingManager( IStreamingManager* StreamingManager );
 
    void SetNumIterationsForNextFrame( int32 NumIterations );
 
    virtual void SetDisregardWorldResourcesForFrames( int32 NumFrames ) override;
 
    void DisableResourceStreaming();
 
    void EnableResourceStreaming();
 
    virtual bool Exec( UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar ) override;
 
    virtual void AddLevel( class ULevel* Level ) override;
 
    virtual void RemoveLevel( class ULevel* Level ) override;
    
    /* Notifies manager that level primitives were shifted. */
    virtual void NotifyLevelOffset( class ULevel* Level, const FVector& Offset ) override;
 
    virtual void NotifyActorDestroyed( AActor* Actor ) override;
 
    virtual void NotifyPrimitiveDetached( const UPrimitiveComponent* Primitive ) override;
 
    virtual void NotifyPrimitiveUpdated( const UPrimitiveComponent* Primitive ) override;
 
    virtual void NotifyPrimitiveUpdated_Concurrent( const UPrimitiveComponent* Primitive ) override;
 
    void PropagateLightingScenarioChange() override;
 
#if WITH_EDITOR
    virtual void OnAudioStreamingParamsChanged() override;
#endif
 
protected:
 
    virtual void AddOrRemoveTextureStreamingManagerIfNeeded(bool bIsInit=false);
 
    TArray<IStreamingManager*> StreamingManagers;
    int32 NumIterations;
 
    int32 DisableResourceStreamingCount;
 
    float LoadMapTimeLimit;
 
    FRenderAssetStreamingManager* RenderAssetStreamingManager;
 
    IAudioStreamingManager* AudioStreamingManager;
 
    IAnimationStreamingManager* AnimationStreamingManager;
 
    FVirtualTextureChunkStreamingManager* VirtualTextureStreamingManager;
 
    Nanite::FCoarseMeshStreamingManager* NaniteCoarseMeshStreamingManager;
 
#if WITH_EDITOR
    // Locks out any audio streaming manager call when we are re-initializing the audio streaming manager.
    mutable FCriticalSection AudioStreamingManagerCriticalSection;
#endif
};