StreamableRenderResourceState.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
StreamableRenderResourceState.h: Render resource state for streamable assets.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
 
struct FStreamableRenderResourceState
{
    // The maximum number of streaming LODs the streaming supports.
    static const uint32 MAX_LOD_COUNT = 16;
 
    FStreamableRenderResourceState() : Data(0) {}
 
    // Manually implement copy operations, because MSVC produces bad codegen for bitfields in unions
    // (as of the 14.35.32217 toolchain)
    inline FStreamableRenderResourceState(const FStreamableRenderResourceState& Other)
        : Data(Other.Data)
    {
    }
    inline void operator=(const FStreamableRenderResourceState& Other)
    {
        Data = Other.Data;
    }
 
    union
    {
        struct
        {
            /* Whether the resource LODs can be streamed or not. Even when false, the structure can contain valid information if IsValid(). */
            uint8 bSupportsStreaming : 1;
 
            uint8 bSupportsVirtualStreaming : 1;
 
            /* Whether the render resources have pending InitRHI(). Used in HasPendingInitOrStreaming() to avoid dereferencing the different resource pointers unless required. Once false, expected to stay false. */
            mutable uint8 bHasPendingInitHint : 1;
 
            /* Whether there is currently a visual LOD transition, following a streaming operation. Used to prevent accessing the render resource unless necessary. */
            mutable uint8 bHasPendingLODTransitionHint : 1;
 
            /* The number of always loaded LODs, which can not be streamed out. */
            uint8 NumNonStreamingLODs; 
            /* The number of LODs (streaming or not) that are guarantied to be installed, for example in PAKs. */
            uint8 NumNonOptionalLODs; // >= NumberOfNonStreamingLODs
            /* The maximum number of LODs the resource can possibly have. Might be less than the asset LOD count. */
            uint8 MaxNumLODs; // >= NumberOfNonOptionalLODs
 
            uint8 AssetLODBias;
            
            uint8 NumResidentLODs;
            uint8 NumRequestedLODs;
 
            uint8 LODBiasModifier;
        };
        uint64 Data;
    };
 
    inline int32 LODCountToAssetFirstLODIdx(int32 InLODCount) const
    {
        return AssetLODBias + MaxNumLODs - InLODCount;
    }
 
    inline int32 LODCountToFirstLODIdx(int32 InLODCount) const
    {
        return MaxNumLODs - InLODCount;
    }
 
    inline int32 ResidentFirstLODIdx() const
    {
        return LODCountToFirstLODIdx(NumResidentLODs);
    }
 
    inline int32 RequestedFirstLODIdx() const
    {
        return LODCountToFirstLODIdx(NumRequestedLODs);
    }
 
    inline bool IsValid() const { return Data != 0; }
 
    inline void Clear() { Data = 0; }
 
    inline bool IsValidForStreamingRequest() const
    {
        return bSupportsStreaming
            && NumNonStreamingLODs <= NumNonOptionalLODs && NumNonOptionalLODs <= MaxNumLODs && MaxNumLODs <= MAX_LOD_COUNT 
            && FMath::IsWithinInclusive(NumResidentLODs, NumNonStreamingLODs, MaxNumLODs)
            && FMath::IsWithinInclusive(NumRequestedLODs, NumNonStreamingLODs, MaxNumLODs)
            && NumResidentLODs != NumRequestedLODs;
    }
 
    inline bool StreamIn(int32 InLODCount)
    {
        // InLODCount can be higher than MaxNumLODs, as long as there are some LODs to yet stream in.
        if (bSupportsStreaming && InLODCount > NumResidentLODs && NumResidentLODs < MaxNumLODs && NumRequestedLODs == NumResidentLODs)
        {
            NumRequestedLODs = (uint8)FMath::Min<int32>(InLODCount, MaxNumLODs);
            bHasPendingLODTransitionHint = true;
            return true;
        }
        else
        {
            return false;
        }
    }
 
    inline bool StreamOut(int32 InLODCount)
    {
        // InLODCount can be lower than MaxNumLODs, as long as there are some LODs to yet stream in.
        if (bSupportsStreaming && InLODCount < NumResidentLODs && NumResidentLODs > NumNonStreamingLODs && NumRequestedLODs == NumResidentLODs)
        {
            NumRequestedLODs = (uint8)FMath::Max<int32>(InLODCount, NumNonStreamingLODs);
            bHasPendingLODTransitionHint = true;
            return true;
        }
        else
        {
            return false;
        }
    }
};