StreamingTexture.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
StreamingTexture.h: Definitions of classes used for texture streaming.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "Engine/StreamableRenderAsset.h"
#include "Engine/TextureDefines.h"
#include "StaticMeshResources.h"
 
struct FRenderAssetStreamingManager;
struct FRenderAssetStreamingSettings;
 
/*-----------------------------------------------------------------------------
    FStreamingRenderAsset, the streaming system's version of UStreamableRenderAsset.
-----------------------------------------------------------------------------*/
 
struct FStreamingRenderAsset
{
    enum EOptionalMipsState : uint8
    {
        OMS_NotCached,
        OMS_NoOptionalMips,
        OMS_HasOptionalMips,
        OMS_Num
    };
 
    FStreamingRenderAsset(
        UStreamableRenderAsset* InRenderAsset,
        TSharedPtr<int32, ESPMode::ThreadSafe>& InSimpleStreamableAssetManagerIndex,
        const int32* NumStreamedMips,
        int32 NumLODGroups,
        const FRenderAssetStreamingSettings& Settings);
 
    void UpdateStaticData(const FRenderAssetStreamingSettings& Settings);
 
    void UpdateDynamicData(const int32* NumStreamedMips, int32 NumLODGroups, const FRenderAssetStreamingSettings& Settings, bool bWaitForMipFading, TArray<UStreamableRenderAsset*>* DeferredTickCBAssets = nullptr);
 
    FStreamableRenderResourceState UpdateStreamingStatus(bool bWaitForMipFading, TArray<UStreamableRenderAsset*>* DeferredTickCBAssets = nullptr);
 
    int32 GetSize( int32 InMipCount ) const
    {
        check(InMipCount > 0);
        check((uint32)InMipCount <= (IsTexture() ? UE_ARRAY_COUNT(CumulativeLODSizes) : UE_ARRAY_COUNT(CumulativeLODSizes_Mesh)));
        return CumulativeLODSizes[InMipCount - 1];
    }
 
    static const TCHAR* GetStreamingAssetTypeStr(EStreamableRenderAssetType InAssetType)
    {
        switch (InAssetType)
        {
        case EStreamableRenderAssetType::Texture:
            return TEXT("Texture");
        case EStreamableRenderAssetType::StaticMesh:
            return TEXT("StaticMesh");
        case EStreamableRenderAssetType::SkeletalMesh:
            return TEXT("SkeletalMesh");
        default:
            return TEXT("Unkown");
        }
    }
 
    static float GetDefaultExtraBoost(bool bUseNewMetrics)
    {
        // When accurate distance computation, we need to relax the distance otherwise it gets too conservative. (ex 513 goes to 1024)
        return bUseNewMetrics ? .71f : 1.f;
    }
 
    static float GetExtraBoost(TextureGroup LODGroup, const FRenderAssetStreamingSettings& Settings);
 
    int32 GetWantedMipsFromSize(float Size, float InvMaxScreenSizeOverAllViews) const;
 
    void SetPerfectWantedMips_Async(
        float MaxSize,
        float MaxSize_VisibleOnly,
        float MaxScreenSizeOverAllViews,
        int32 MaxNumForcedLODs,
        bool InLooksLowRes,
        const FRenderAssetStreamingSettings& Settings);
 
    int64 UpdateRetentionPriority_Async(bool bPrioritizeMesh);
 
    int64 DropMaxResolution_Async(int32 NumDroppedMips);
 
    int64 DropOneMip_Async();
 
    int64 KeepOneMip_Async();
 
    int64 GetDropMaxResMemDelta(int32 NumDroppedMips) const;
 
    int64 GetDropOneMipMemDelta() const;
 
    float GetMaxAllowedSize(float MaxScreenSizeOverAllViews) const
    {
        return IsTexture() ? (float)(0x1 << (MaxAllowedMips - 1)) : MaxScreenSizeOverAllViews;
    }
 
    float GetNormalizedScreenSize(int32 NumMips) const
    {
        check(IsMesh());
        check(NumMips > 0 && (uint32)NumMips <= UE_ARRAY_COUNT(LODScreenSizes));
        return LODScreenSizes[NumMips - 1];
    }
 
    float GetLODScreenSize(int32 NumMips, float MaxScreenSizeOverAllViews) const
    {
        return IsTexture() ?
            static_cast<float>(1 << (NumMips - 1)) :
            GetNormalizedScreenSize(NumMips) * MaxScreenSizeOverAllViews;
    }
 
    bool UpdateLoadOrderPriority_Async(const FRenderAssetStreamingSettings& Settings);
 
    void UpdateOptionalMipsState_Async();
    
    void CancelStreamingRequest();
    void StreamWantedMips(FRenderAssetStreamingManager& Manager);
 
    // Cache meta data (e.g. WantedMips) for StreamWantedMipsUsingCachedData to use later on
    void CacheStreamingMetaData();
 
    // Stream using the meta data produced by last run of FRenderAssetStreamingMipCalcTask.
    // This allows streaming to happen in parallel with the async update task
    void StreamWantedMipsUsingCachedData(FRenderAssetStreamingManager& Manager);
 
    bool IsTexture() const
    {
        return RenderAssetType == EStreamableRenderAssetType::Texture;
    }
 
    bool IsVirtualTexture() const
    {
        return RenderAssetType == EStreamableRenderAssetType::Texture && bIsVirtualTexture;
    }
 
    bool IsMesh() const
    {
        // FRenderAssetStreamingManager only handles textures and meshes currently
        return RenderAssetType != EStreamableRenderAssetType::Texture;
    }
 
    bool IsMissingTooManyMips() const
    {
        return bMissingTooManyMips;
    }
 
    FORCEINLINE int32 GetPerfectWantedMips() const { return FMath::Max<int32>(VisibleWantedMips,  HiddenWantedMips); }
 
    // Whether this texture/mesh can be affected by Global Bias and Budget Bias per texture/mesh.
    // It controls if the texture/mesh resolution can be scarificed to fit into budget.
    FORCEINLINE bool IsMaxResolutionAffectedByGlobalBias() const 
    {
        // In editor, forced stream in should never have reduced mips as they can be edited.
        return (IsMesh() || LODGroup != TEXTUREGROUP_HierarchicalLOD)
            && !bIsTerrainTexture
            && !(bForceFullyLoadHeuristic && bIgnoreStreamingMipBias)
            && !(GIsEditor && bForceFullyLoadHeuristic); 
    }
 
    FORCEINLINE bool HasUpdatePending(bool bIsStreamingPaused, bool bHasViewPoint) const 
    {
        const bool bBudgetedMipsIsValid = bHasViewPoint || bForceFullyLoadHeuristic; // Force fully load don't need any viewpoint info.
        // If paused, nothing will update anytime soon.
        // If more mips will be streamed in eventually, wait.
        // Otherwise, if the distance based computation had no viewpoint, wait.
        return !bIsStreamingPaused && (BudgetedMips > ResidentMips || !bBudgetedMipsIsValid);
    }
 
    /***************************************************************
     * Member data categories:
     * (1) Members initialized when this is constructed => NEVER CHANGES
     * (2) Cached dynamic members that need constant update => UPDATES IN UpdateDynamicData()
     * (3) Helper data set by the streamer to handle special cases => CHANGES ANYTIME (gamethread)
     * (4) Data generated by the async task. CHANGES ANYTIME (taskthread)
     * (5) Data cached to allow streaming to run in parallel with meta data update
     ***************************************************************/
 
    UStreamableRenderAsset*     RenderAsset;
 
    TSharedPtr<int32, ESPMode::ThreadSafe> SimpleStreamableAssetManagerIndex;
    
    FIoFilenameHash OptionalFileHash = INVALID_IO_FILENAME_HASH;
    int32           LODGroup;
    float           BoostFactor;
    union
    {
        uint32 CumulativeLODSizes[FStreamableRenderResourceState::MAX_LOD_COUNT];
        struct
        {
            uint32 CumulativeLODSizes_Mesh[FStreamableRenderResourceState::MAX_LOD_COUNT / 2];
            // Normalized size of projected bounding sphere - [0, 1]
            float LODScreenSizes[FStreamableRenderResourceState::MAX_LOD_COUNT / 2];
        };
    };
    // Make sure static mesh LODs will fit in the above struct
    static_assert(FStreamableRenderResourceState::MAX_LOD_COUNT / 2 >= MAX_STATIC_MESH_LODS);
 
    float           LastRenderTime;
    double          InstanceRemovedTimestamp;
    float           DynamicBoostFactor;
 
    int32           RetentionPriority;
    float           NormalizedScreenSize;
    int32           LoadOrderPriority;  
    int32           BudgetMipBias;
    int32           NoRefLODBias;
    int8            WantedMips;
    int8            NumForcedMips;
    int8            ResidentMips;
    int8            RequestedMips;
    int8            MinAllowedMips;
    int8            MaxAllowedMips;
    int8            NumMissingMips;
    int8            VisibleWantedMips;
    int8            HiddenWantedMips;
    int8            BudgetedMips;
 
    int8 CachedWantedMips;
    int8 CachedVisibleWantedMips;
 
    EStreamableRenderAssetType RenderAssetType;
    EOptionalMipsState  OptionalMipsState;
 
    uint8           bIsVirtualTexture : 1;
    uint8           bLoadWithHigherPriority : 1;
    uint8           bIsTerrainTexture : 1;
 
    uint8           bForceFullyLoad : 1;
    uint8           bIgnoreStreamingMipBias : 1;
 
    uint8           bHasUpdatePending : 1;
 
    uint8           bForceFullyLoadHeuristic : 1;
    uint8           bUseUnkownRefHeuristic : 1;
    uint8           bLooksLowRes : 1;
    uint8           bMissingTooManyMips : 1;
 
    uint8           bCachedForceFullyLoadHeuristic : 1;
 
    TBitArray<>     LevelIndexUsage;
 
private:
    FORCEINLINE_DEBUGGABLE void StreamWantedMips_Internal(FRenderAssetStreamingManager& Manager, bool bUseCachedData);
 
    FORCEINLINE_DEBUGGABLE int32 ClampMaxResChange_Internal(int32 NumMipDropRequested) const;
};