AsyncTextureStreaming.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
AsyncTextureStreaming.h: Definitions of classes used for texture streaming async task.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "Stats/Stats.h"
#include "ContentStreaming.h"
#include "Async/AsyncWork.h"
#include "Streaming/StreamingTexture.h"
#include "Streaming/TextureInstanceView.h"
 
class FLevelRenderAssetManager;
class FDynamicRenderAssetInstanceManager;
struct FRenderAssetStreamingManager;
 
class FAsyncRenderAssetStreamingData
{
public:
 
    void Init(
        TArray<FStreamingViewInfo> InViewInfos,
        float InWorldTime,
        TArray<FLevelRenderAssetManager*>& LevelStaticInstanceManagers,
        FDynamicRenderAssetInstanceManager& DynamicComponentManager);
 
    void Init(
        TArray<FStreamingViewInfo> InViewInfos,
        float InLastUpdateTime);
 
    void ComputeViewInfoExtras(const FRenderAssetStreamingSettings& Settings);
 
    void UpdateBoundSizes_Async(const FRenderAssetStreamingSettings& Settings);
 
    void UpdatePerfectWantedMips_Async(FStreamingRenderAsset& StreamingRenderAsset, const FRenderAssetStreamingSettings& Settings, bool bOutputToLog = false) const;
 
    uint32 GetAllocatedSize() const { return ViewInfos.GetAllocatedSize() + StaticInstancesViews.GetAllocatedSize(); }
 
    FORCEINLINE const FRenderAssetInstanceAsyncView& GetDynamicInstancesView() const { return DynamicInstancesView; }
    FORCEINLINE const TArray<FRenderAssetInstanceAsyncView>& GetStaticInstancesViews() const { return StaticInstancesViews; }
    FORCEINLINE const TArray<FStreamingViewInfo>& GetViewInfos() const { return ViewInfos; }
 
    FORCEINLINE bool HasAnyView() const { return ViewInfos.Num() > 0; }
 
    // Release the view. Decrementing the refcounts. 
    // This must be done on the gamethread as the refcount are not threadsafe.
    void ReleaseViews()
    {
        DynamicInstancesView = FRenderAssetInstanceAsyncView();
        StaticInstancesViews.Reset();
    }
 
    void OnTaskDone_Async() 
    { 
        DynamicInstancesView.OnTaskDone();
        for (FRenderAssetInstanceAsyncView& StaticView : StaticInstancesViews)
        {
            StaticView.OnTaskDone();
        }
    }
 
 
private:
    TArray<FStreamingViewInfo> ViewInfos;
    
    FStreamingViewInfoExtraArray ViewInfoExtras;
 
    FRenderAssetInstanceAsyncView DynamicInstancesView;
 
    TArray<FRenderAssetInstanceAsyncView> StaticInstancesViews;
 
    float LastUpdateTime;
 
    float MaxScreenSizeOverAllViews;
 
    TArray<int32> StaticInstancesViewIndices;
 
    TArray<int32> CulledStaticInstancesViewIndices;
 
    TArray<int32> StaticInstancesViewLevelIndices;
};
 
struct FCompareRenderAssetByRetentionPriority // Bigger retention priority first.
{
    FCompareRenderAssetByRetentionPriority(const TArray<FStreamingRenderAsset>& InStreamingRenderAssets) : StreamingRenderAssets(InStreamingRenderAssets) {}
    const TArray<FStreamingRenderAsset>& StreamingRenderAssets;
 
    FORCEINLINE bool operator()( int32 IndexA, int32 IndexB ) const
    {
        const int32 PrioA = StreamingRenderAssets[IndexA].RetentionPriority;
        const int32 PrioB = StreamingRenderAssets[IndexB].RetentionPriority;
        if (PrioA > PrioB)  return true;
        if (PrioA == PrioB)
        {
            const float SSA = StreamingRenderAssets[IndexA].NormalizedScreenSize;
            const float SSB = StreamingRenderAssets[IndexB].NormalizedScreenSize;
            if (SSA > SSB) return true;
            if (SSA == SSB) return IndexA > IndexB;  // Sorting by index so that it gets deterministic.
        }
        return false;
    }
};
 
struct FCompareRenderAssetByLoadOrderPriority // Bigger load order priority first.
{
    FCompareRenderAssetByLoadOrderPriority(const TArray<FStreamingRenderAsset>& InStreamingRenderAssets) : StreamingRenderAssets(InStreamingRenderAssets) {}
    const TArray<FStreamingRenderAsset>& StreamingRenderAssets;
 
    FORCEINLINE bool operator()( int32 IndexA, int32 IndexB ) const
    {
        const int32 PrioA = StreamingRenderAssets[IndexA].LoadOrderPriority;
        const int32 PrioB = StreamingRenderAssets[IndexB].LoadOrderPriority;
        if ( PrioA > PrioB )  return true;
        if ( PrioA == PrioB ) return IndexA > IndexB;  // Sorting by index so that it gets deterministic.
        return false;
    }
};
 
// this could implement a better abandon, but give how it is used, it does that anyway via the abort mechanism
class FRenderAssetStreamingMipCalcTask : public FNonAbandonableTask
{
public:
 
    FRenderAssetStreamingMipCalcTask( FRenderAssetStreamingManager* InStreamingManager )
    :   StreamingManager( *InStreamingManager )
    ,   bAbort( false )
    {
        Reset(0, 0, 0, 0, 0);
        MemoryBudget = 0;
        MeshMemoryBudget = 0;
        PerfectWantedMipsBudgetResetThresold = 0;
    }
 
    void Reset(int64 InTotalGraphicsMemory, int64 InAllocatedMemory, int64 InPoolSize, int64 InTempMemoryBudget, int64 InMemoryMargin)
    {
        TotalGraphicsMemory = InTotalGraphicsMemory;
        AllocatedMemory = InAllocatedMemory;
        PoolSize = InPoolSize;
        TempMemoryBudget = InTempMemoryBudget;
        MemoryMargin = InMemoryMargin;
 
        bAbort = false;
    }
 
    void Abort() { bAbort = true; }
 
    bool IsAborted() const { return bAbort; }
 
    const TArray<int32>& GetLoadRequests() const { return LoadRequests; }
    const TArray<int32>& GetCancelationRequests() const { return CancelationRequests; }
    const TArray<int32>& GetPendingUpdateDirties() const { return PendingUpdateDirties; }
 
    FAsyncRenderAssetStreamingData StreamingData;
    
    void DoWork();
 
    bool HasAnyView() const { return StreamingData.HasAnyView(); }
 
    void ReleaseAsyncViews()
    {
        StreamingData.ReleaseViews();
    }
 
protected:
 
    bool AllowPerRenderAssetMipBiasChanges() const;
 
private:
 
    friend class FAsyncTask<FRenderAssetStreamingMipCalcTask>;
 
    void ApplyPakStateChanges_Async();
 
    void TryDropMaxResolutions(TArray<int32>& PrioritizedRenderAssets, int64& MemoryBudgeted, const int64 InMemoryBudget);
 
    void TryDropMips(TArray<int32>& PrioritizedRenderAssets, int64& MemoryBudgeted, const int64 InMemoryBudget);
 
    void TryKeepMips(TArray<int32>& PrioritizedRenderAssets, int64& MemoryBudgeted, const int64 InMemoryBudget);
 
    void UpdateBudgetedMips_Async();
    
    void UpdateBudgetedVirtualTextureMips_Async();
 
    void UpdateLoadAndCancelationRequests_Async();
 
    void UpdatePendingStreamingStatus_Async();
 
    void UpdateStats_Async();
 
    void UpdateCSVOnlyStats_Async();
 
    FORCEINLINE TStatId GetStatId() const
    {
        RETURN_QUICK_DECLARE_CYCLE_STAT(FRenderAssetStreamingMipCalcTask, STATGROUP_ThreadPoolAsyncTasks);
    }
 
    FRenderAssetStreamingManager& StreamingManager;
 
    TArray<int32>   LoadRequests;
    TArray<int32>   CancelationRequests;
 
    TArray<int32>   PendingUpdateDirties;
 
    volatile bool               bAbort;
 
    int64 TotalGraphicsMemory;
 
    int64 AllocatedMemory; 
 
    int64 PoolSize;
 
    int64 TempMemoryBudget;
 
    int64 MemoryMargin;
 
    int64 MemoryBudget;
 
    int64 MeshMemoryBudget;
 
    int64 PerfectWantedMipsBudgetResetThresold;
};