StreamingManagerTexture.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
TextureStreamingManager.h: Definitions of classes used for texture streaming.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "ContentStreaming.h"
#include "AbandonedRenderAssetUpdateManager.h"
#include "Streaming/TextureStreamingHelpers.h"
#include "Streaming/StreamingTexture.h"
#include "Streaming/LevelTextureManager.h"
#include "Streaming/TextureInstanceTask.h"
 
class AActor;
class FRenderAssetStreamingMipCalcTask;
class IPakFile;
class UPrimitiveComponent;
 
template<typename TTask> class FAsyncTask;
 
/*-----------------------------------------------------------------------------
    Texture or mesh streaming.
-----------------------------------------------------------------------------*/
 
struct FRenderAssetStreamingManager final : public IRenderAssetStreamingManager
{
    FRenderAssetStreamingManager();
 
    virtual ~FRenderAssetStreamingManager();
 
    void OnPreGarbageCollect();
 
    virtual void UpdateResourceStreaming( float DeltaTime, bool bProcessEverything=false ) override;
 
    virtual void UpdateIndividualRenderAsset( UStreamableRenderAsset* RenderAsset ) override;
 
    virtual bool FastForceFullyResident(UStreamableRenderAsset* RenderAsset) override;
 
    virtual int32 BlockTillAllRequestsFinished( float TimeLimit = 0.0f, bool bLogResults = false ) override;
 
    virtual void CancelForcedResources() override;
 
    virtual void NotifyLevelChange() override;
 
    virtual void SetDisregardWorldResourcesForFrames( int32 NumFrames ) override;
 
    virtual bool StreamOutRenderAssetData( int64 RequiredMemorySize ) override;
 
    virtual int64 GetMemoryOverBudget() const override { return MemoryOverBudget; }
 
    virtual int64 GetPoolSize() const override;
 
    virtual int64 GetRequiredPoolSize() const override { return DisplayedStats.RequiredPool; }
 
    virtual int64 GetMaxEverRequired() const override { return MaxEverRequired; }
 
    virtual float GetCachedMips() const override { return DisplayedStats.CachedMips; }
 
    virtual void ResetMaxEverRequired() override { MaxEverRequired = 0; }
 
    virtual bool Exec( UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar ) override;
 
#if !UE_BUILD_SHIPPING
    bool HandleDumpTextureStreamingStatsCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleListStreamingRenderAssetsCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleResetMaxEverRequiredRenderAssetMemoryCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleLightmapStreamingFactorCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    bool HandleCancelRenderAssetStreamingCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    bool HandleShadowmapStreamingFactorCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    bool HandleNumStreamedMipsCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    bool HandleTrackRenderAssetCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    bool HandleListTrackedRenderAssetsCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    bool HandleDebugTrackedRenderAssetsCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    bool HandleUntrackRenderAssetCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    bool HandleStreamOutCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    bool HandlePauseRenderAssetStreamingCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    bool HandleStreamingManagerMemoryCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
    bool HandleLODGroupsCommand( const TCHAR* Cmd, FOutputDevice& Ar );
    bool HandleInvestigateRenderAssetCommand( const TCHAR* Cmd, FOutputDevice& Ar, UWorld* InWorld );
#endif // !UE_BUILD_SHIPPING
 
    virtual void AddStreamingRenderAsset( UStreamableRenderAsset* RenderAsset ) override;
 
    virtual void RemoveStreamingRenderAsset( UStreamableRenderAsset* RenderAsset ) override;
 
    virtual bool IsFullyStreamedIn(UStreamableRenderAsset* RenderAsset) 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(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;
 
    FStreamingRenderAsset* GetStreamingRenderAsset( const UStreamableRenderAsset* RenderAsset );
 
    virtual void PauseRenderAssetStreaming(bool bInShouldPause) override
    {
        bPauseRenderAssetStreaming = bInShouldPause;
    }
 
    virtual void GetObjectReferenceBounds(const UObject* RefObject, TArray<FBox>& AssetBoxes) override;
 
    virtual void GetAssetComponents(const UStreamableRenderAsset* RenderAsset, TArray<const UPrimitiveComponent*>& OutComps, TFunction<bool(const UPrimitiveComponent*)> ShouldChoose) override;
 
    void PropagateLightingScenarioChange() override;
 
    void AddRenderedTextureStats(TMap<FString, FRenderedTextureStats>& InOutRenderedTextureStats) override;
 
    void OnRenderAssetUpdateAbandoned(UStreamableRenderAsset* OwningRenderAsset, TRefCountPtr<class FRenderAssetUpdate>& RenderAssetUpdate) override;
 
    void SetRenderAssetsRemovedTimestamp(const FRemovedRenderAssetArray& RemovedRenderAssets);
 
    static bool IsParallelForAllowedDuringIncrementalUpdate(int32 NumElementsToProcess, int32& OutParallelForMinBatchSize);
 
private:
//BEGIN: Thread-safe functions and data
        friend class FRenderAssetStreamingMipCalcTask;
        friend class FUpdateStreamingRenderAssetsTask;
 
        void RemoveStaticReferences(const UPrimitiveComponent* Primitive);
 
        void UpdateStreamingRenderAssets(int32 StageIndex, int32 NumStages, bool bWaitForMipFading, bool bAsync = false);
 
        void TickFastResponseAssets();
 
        void ProcessRemovedRenderAssets();
        void ProcessAddedRenderAssets();
        void ConditionalUpdateStaticData();
        void ProcessLevelsToReferenceToStreamedTextures();
 
        void PrepareAsyncTask( bool bProcessEverything );
 
        void CheckUserSettings();
 
        void BoostTextures( AActor* Actor, float BoostFactor ) override;
 
        void SetOptionalBulkData( UTexture* Texture, bool bHasOptionalBulkData );
 
        void StreamRenderAssets( bool bProcessEverything );
 
        int32 GetNumStreamedMipsArray(EStreamableRenderAssetType AssetType, const int32*& OutArray)
        {
            switch (AssetType)
            {
            case EStreamableRenderAssetType::Texture:
                OutArray = NumStreamedMips_Texture;
                return TEXTUREGROUP_MAX;
            case EStreamableRenderAssetType::StaticMesh:
                OutArray = NumStreamedMips_StaticMesh.GetData();
                return NumStreamedMips_StaticMesh.Num();
            case EStreamableRenderAssetType::SkeletalMesh:
                OutArray = NumStreamedMips_SkeletalMesh.GetData();
                return NumStreamedMips_SkeletalMesh.Num();
            default:
                check(false);
                OutArray = nullptr;
                return -1;
            }
        }
 
        TArray<FStreamingRenderAsset> AsyncUnsafeStreamingRenderAssets;
 
        struct FPointerKeyFunc : BaseKeyFuncs<UStreamableRenderAsset*, const UStreamableRenderAsset*, false>
        {
            static KeyInitType  GetSetKey(ElementInitType& Element) { return Element; }
            static KeyInitType  GetSetKey(const TObjectPtr<UStreamableRenderAsset>& Element) { return Element.Get(); }          
            static bool         Matches(KeyInitType A, KeyInitType B) { return A == B; }
            static uint32       GetKeyHash(KeyInitType Key) { return GetTypeHash(Key); }
        };
 
        TSet<TObjectPtr<UStreamableRenderAsset>, FPointerKeyFunc> ReferencedRenderAssets;
 
        TSet<FString> OptionalBulkDataFiles;
 
        int32 CurrentUpdateStreamingRenderAssetIndex;
//END: Thread-safe functions and data
 
    void    SetLastUpdateTime();
    void    UpdateStats();
    void    UpdateCSVOnlyStats();
    void    LogViewLocationChange();
 
    void    IncrementalUpdate( float Percentage, bool bUpdateDynamicComponents);
 
    void    UpdatePendingStates(bool bUpdateDynamicComponents);
 
    void    SyncStates(bool bCompleteFullUpdateCycle);
 
    void ProcessPendingMipCopyRequests();
 
    void TickDeferredMipLevelChangeCallbacks();
 
    void ProcessPendingLevelManagers();
 
    int32 NumStreamedMips_Texture[TEXTUREGROUP_MAX];
    TArray<int32> NumStreamedMips_StaticMesh;
    TArray<int32> NumStreamedMips_SkeletalMesh;
 
    FRenderAssetStreamingSettings Settings;
 
    FAsyncTask<FRenderAssetStreamingMipCalcTask>*   AsyncWork;
 
    TRefCountPtr<RenderAssetInstanceTask::FDoWorkAsyncTask> RenderAssetInstanceAsyncWork;
 
    FDynamicRenderAssetInstanceManager DynamicComponentManager;
 
    TArray<UStreamableRenderAsset*> PendingStreamingRenderAssets;
 
    TArray<int32>   RemovedRenderAssetIndices;
 
    TArray<UStreamableRenderAsset*> DeferredTickCBAssets;
 
    TSet<UStreamableRenderAsset*> FastResponseRenderAssets;
 
    TSet<int32> VisibleFastResponseRenderAssetIndices;
 
    // Represent a pending request to stream in/out mips to/from GPU for a texture or mesh
    struct FPendingMipCopyRequest
    {
        const UStreamableRenderAsset* RenderAsset;
        // Used to find the corresponding FStreamingRenderAsset in the StreamingRenderAssets array
        int32 CachedIdx;
 
        FPendingMipCopyRequest() = default;
 
        FPendingMipCopyRequest(const UStreamableRenderAsset* InAsset, int32 InCachedIdx)
            : RenderAsset(InAsset)
            , CachedIdx(InCachedIdx)
        {}
    };
    TArray<FPendingMipCopyRequest> PendingMipCopyRequests;
 
    // The index of the next FPendingMipCopyRequest to process so the requests can be amortized accross multiple frames
    int32 CurrentPendingMipCopyRequestIdx;
 
    TArray<FLevelRenderAssetManager*> LevelRenderAssetManagers;
 
    // Used to prevent hazard when LevelRenderAssetManagers array is modified through recursion
    struct FScopedLevelRenderAssetManagersLock
    {
        FRenderAssetStreamingManager* StreamingManager;
        TArray<FLevelRenderAssetManager*> PendingAddLevelManagers;
        TArray<FLevelRenderAssetManager*> PendingRemoveLevelManagers;
 
        FScopedLevelRenderAssetManagersLock(FRenderAssetStreamingManager* InStreamingManager);
 
        ~FScopedLevelRenderAssetManagersLock();
    };
 
    friend struct FScopedLevelRenderAssetManagersLock;
 
    FScopedLevelRenderAssetManagersLock* LevelRenderAssetManagersLock;
 
    int32                   ProcessingStage;
 
    int32                   NumRenderAssetProcessingStages;
 
    bool                    bUseDynamicStreaming;
 
    float                   BoostPlayerTextures;
 
    int64                   MemoryMargin;
 
    int64                   EffectiveStreamingPoolSize;
 
    // Stats we need to keep across frames as we only iterate over a subset of textures.
 
    int64 MemoryOverBudget;
    int64 MaxEverRequired;
 
    bool bPauseRenderAssetStreaming;
 
    float LastWorldUpdateTime;
 
    float LastWorldUpdateTime_MipCalcTask;
 
    FRenderAssetStreamingStats DisplayedStats;
    FRenderAssetStreamingStats GatheredStats;
 
    TArray<int32> InflightRenderAssets;
 
    FCriticalSection MountedStateDirtyFilesCS;
    bool bRecacheAllFiles = false;
    typedef TSet<FIoFilenameHash> FIoFilenameHashSet;
    FIoFilenameHashSet MountedStateDirtyFiles;
 
    FDelegateHandle OnPakFileMounted2Handle;
    FDelegateHandle NewFileAddedDelegateHandle;
 
    ENGINE_API virtual void MarkMountedStateDirty(FIoFilenameHash FilenameHash) override;
 
    // A critical section use around code that could be called in parallel with NotifyPrimitiveUpdated() or NotifyPrimitiveUpdated_Concurrent().
    FCriticalSection CriticalSection;
 
    // An event used to prevent FUpdateStreamingRenderAssetsTask from overlapping with related work
    FGraphEventRef StreamingRenderAssetsSyncEvent;
    TArray<FStreamingRenderAsset>& GetStreamingRenderAssetsAsyncSafe();
 
    FAbandonedRenderAssetUpdateManager AbandonedRenderAssetUpdateManager;
 
    friend bool TrackRenderAssetEvent( FStreamingRenderAsset* StreamingRenderAsset, UStreamableRenderAsset* RenderAsset, bool bForceMipLevelsToBeResident, const FRenderAssetStreamingManager* Manager);
};
 
struct FRenderAssetStreamingManagerHelper
{
    static float GetWorldTime(UWorld* InWorld);
};