RenderResource.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    RenderResource.h: Render resource definitions.
=============================================================================*/
 
#pragma once
 
#include "RHIFwd.h"
#include "RHIShaderPlatform.h"
#include "RHIFeatureLevel.h"
#include "RenderTimer.h"
#include "CoreGlobals.h"
 
class FRenderCommandPipe;
class FRDGPooledBuffer;
class FResourceArrayInterface;
 
enum class ERenderResourceState : uint8
{
    Default,
    BatchReleased,
    Deleted,
};
 
enum class ERayTracingMode : uint8
{
    Disabled,   
    Enabled,
    Dynamic
};
 
class FRenderResource
{
public:
 
    enum class EInitPhase : uint8
    {
        Pre,
        Default,
        MAX
    };
 
    static RENDERCORE_API void ReleaseRHIForAllResources();
 
    static RENDERCORE_API void InitPreRHIResources();
 
    static RENDERCORE_API void ChangeFeatureLevel(ERHIFeatureLevel::Type NewFeatureLevel);
 
    static RENDERCORE_API FName SetScopeName(FName Name);
 
 
    RENDERCORE_API FRenderResource();
 
    RENDERCORE_API FRenderResource(ERHIFeatureLevel::Type InFeatureLevel);
 
    RENDERCORE_API FRenderResource(const FRenderResource&);
    RENDERCORE_API FRenderResource(FRenderResource&&);
    RENDERCORE_API FRenderResource& operator=(const FRenderResource& Other);
    RENDERCORE_API FRenderResource& operator=(FRenderResource&& Other);
 
    RENDERCORE_API virtual ~FRenderResource();
 
    virtual void InitRHI(FRHICommandListBase& RHICmdList) {}
 
    virtual void ReleaseRHI() {}
 
    RENDERCORE_API virtual void InitResource(FRHICommandListBase& RHICmdList);
 
    RENDERCORE_API virtual void ReleaseResource();
 
    RENDERCORE_API void UpdateRHI(FRHICommandListBase& RHICmdList);
 
    virtual FString GetFriendlyName() const { return TEXT("undefined"); }
 
    // Accessors.
    inline bool IsInitialized() const { return ListIndex != INDEX_NONE; }
 
    int32 GetListIndex() const { return ListIndex; }
    EInitPhase GetInitPhase() const { return InitPhase; }
 
    void SetOwnerName(FName InOwnerName)
    {
#if RHI_ENABLE_RESOURCE_INFO
        OwnerName = InOwnerName;
#endif
    }
 
    FName GetOwnerName() const
    {
#if RHI_ENABLE_RESOURCE_INFO
        return OwnerName;
#else
        return NAME_None;
#endif
    }
 
    void SetResourceName(FName InResourceName)
    {
#if RHI_ENABLE_RESOURCE_INFO
        ResourceName = InResourceName;
#endif
    }
 
    FName GetResourceName() const
    {
#if RHI_ENABLE_RESOURCE_INFO
        return ResourceName;
#else
        return NAME_None;
#endif
    }
 
protected:
    // This is used during mobile editor preview refactor, this will eventually be replaced with a parameter to InitRHI() etc..
    void SetFeatureLevel(const FStaticFeatureLevel InFeatureLevel) { FeatureLevel = (ERHIFeatureLevel::Type)InFeatureLevel; }
    const FStaticFeatureLevel GetFeatureLevel() const { return FeatureLevel == ERHIFeatureLevel::Num ? FStaticFeatureLevel(GMaxRHIFeatureLevel) : FeatureLevel; }
    inline bool HasValidFeatureLevel() const { return FeatureLevel < ERHIFeatureLevel::Num; }
 
    // Helper for submitting a resource array to RHI and freeing eligible CPU memory
    template<typename T>
    FBufferRHIRef CreateRHIBuffer(FRHICommandListBase& RHICmdList, T& InOutResourceObject, uint32 ResourceCount, EBufferUsageFlags InBufferUsageFlags, const TCHAR* InDebugName)
    {
        FBufferRHIRef Buffer;
 
        FResourceArrayInterface* RESTRICT ResourceArray = InOutResourceObject ? InOutResourceObject->GetResourceArray() : nullptr;
        if (ResourceCount != 0)
        {
            Buffer = CreateRHIBufferInternal(RHICmdList, InDebugName, GetOwnerName(), ResourceCount, InBufferUsageFlags, ResourceArray, InOutResourceObject == nullptr);
        }
 
        // If the buffer creation emptied the resource array, delete the containing structure as well
        if (ShouldFreeResourceObject(InOutResourceObject, ResourceArray))
        {
            delete InOutResourceObject;
            InOutResourceObject = nullptr;
        }
 
        return Buffer;
    }
 
    static RENDERCORE_API FRHICommandListBase& GetImmediateCommandList();
 
    void SetInitPhase(EInitPhase InInitPhase)
    {
        check(InInitPhase != EInitPhase::MAX);
        check(!IsInitialized());
        InitPhase = InInitPhase;
    }
 
private:
    static RENDERCORE_API bool ShouldFreeResourceObject(void* ResourceObject, FResourceArrayInterface* ResourceArray);
    static RENDERCORE_API FBufferRHIRef CreateRHIBufferInternal(
        FRHICommandListBase& RHICmdList,
        const TCHAR* InDebugName,
        const FName& InOwnerName,
        uint32 ResourceCount,
        EBufferUsageFlags InBufferUsageFlags,
        FResourceArrayInterface* ResourceArray,
        bool bWithoutNativeResource
    );
 
#if RHI_ENABLE_RESOURCE_INFO
    FName OwnerName;
    FName ResourceName;
#endif
 
    int32 ListIndex;
    TEnumAsByte<ERHIFeatureLevel::Type> FeatureLevel;
    EInitPhase InitPhase = EInitPhase::Default;
 
public:
    ERenderResourceState ResourceState = ERenderResourceState::Default;
};
 
extern RENDERCORE_API void BeginInitResource(FRenderResource* Resource, FRenderCommandPipe* RenderCommandPipe = nullptr);
 
inline void BeginInitResource(FName OwnerName, FRenderResource* Resource, FRenderCommandPipe* RenderCommandPipe = nullptr)
{
#if RHI_ENABLE_RESOURCE_INFO
    Resource->SetOwnerName(OwnerName);
#endif
 
    BeginInitResource(Resource, RenderCommandPipe);
}
 
extern RENDERCORE_API void BeginUpdateResourceRHI(FRenderResource* Resource, FRenderCommandPipe* RenderCommandPipe = nullptr);
 
extern RENDERCORE_API void BeginReleaseResource(FRenderResource* Resource, FRenderCommandPipe* RenderCommandPipe = nullptr);
 
extern RENDERCORE_API void StartBatchedRelease();
 
extern RENDERCORE_API void EndBatchedRelease();
 
extern RENDERCORE_API void ReleaseResourceAndFlush(FRenderResource* Resource);
 
enum EMipFadeSettings
{
    MipFade_Normal = 0,
    MipFade_Slow,
 
    MipFade_NumSettings,
};
 
struct FMipFadeSettings
{
    FMipFadeSettings( float InFadeInSpeed, float InFadeOutSpeed )
        :   FadeInSpeed( InFadeInSpeed )
        ,   FadeOutSpeed( InFadeOutSpeed )
    {
    }
 
    float FadeInSpeed;
 
    float FadeOutSpeed;
};
 
extern RENDERCORE_API float GEnableMipLevelFading;
 
extern RENDERCORE_API FMipFadeSettings GMipFadeSettings[MipFade_NumSettings];
 
struct FMipBiasFade
{
    FMipBiasFade()
    :   TotalMipCount(0.0f)
    ,   MipCountDelta(0.0f)
    ,   StartTime(0.0f)
    ,   MipCountFadingRate(0.0f)
    ,   BiasOffset(0.0f)
    {
    }
 
    float   TotalMipCount;
 
    float   MipCountDelta;
 
    float   StartTime;
 
    float   MipCountFadingRate;
 
    float   BiasOffset;
 
    RENDERCORE_API void SetNewMipCount( float ActualMipCount, float TargetMipCount, double LastRenderTime, EMipFadeSettings FadeSetting );
 
    inline float    CalcMipBias() const
    {
        float DeltaTime     = GRenderingRealtimeClock.GetCurrentTime() - StartTime;
        float TimeFactor    = FMath::Min<float>(DeltaTime * MipCountFadingRate, 1.0f);
        float MipBias       = BiasOffset - MipCountDelta*TimeFactor;
        return FMath::FloatSelect(GEnableMipLevelFading, MipBias, 0.0f);
    }
 
    inline bool IsFading( ) const
    {
        float DeltaTime = GRenderingRealtimeClock.GetCurrentTime() - StartTime;
        float TimeFactor = DeltaTime * MipCountFadingRate;
        return (FMath::Abs<float>(MipCountDelta) > UE_SMALL_NUMBER && TimeFactor < 1.0f);
    }
};
 
class FTexture : public FRenderResource
{
public:
 
    FTextureRHIRef      TextureRHI;
 
    FSamplerStateRHIRef SamplerStateRHI;
 
    FSamplerStateRHIRef DeferredPassSamplerStateRHI;
 
    mutable double      LastRenderTime = -FLT_MAX;
 
    FMipBiasFade        MipBiasFade;
 
    bool                bGreyScaleFormat = false;
 
    //UE_DEPRECATED(5.5,"bIgnoreGammaConversions should not be used")
    bool                bIgnoreGammaConversions = false;
 
    bool                bSRGB = false;
 
    RENDERCORE_API FTexture();
    RENDERCORE_API virtual ~FTexture();
    RENDERCORE_API FTexture(const FTexture&);
    RENDERCORE_API FTexture(FTexture&&);
    RENDERCORE_API FTexture& operator=(const FTexture& Other);
    RENDERCORE_API FTexture& operator=(FTexture&& Other);
 
    const FTextureRHIRef& GetTextureRHI() { return TextureRHI; }
 
    RENDERCORE_API virtual uint32 GetSizeX() const;
 
    RENDERCORE_API virtual uint32 GetSizeY() const;
 
    RENDERCORE_API virtual uint32 GetSizeZ() const;
 
    // FRenderResource interface.
    RENDERCORE_API virtual void ReleaseRHI() override;
    RENDERCORE_API virtual FString GetFriendlyName() const override;
 
protected:
    static RENDERCORE_API FRHISamplerState* GetOrCreateSamplerState(const FSamplerStateInitializerRHI& Initializer);
};
 
class FTextureWithSRV : public FTexture
{
public:
    RENDERCORE_API FTextureWithSRV();
    RENDERCORE_API virtual ~FTextureWithSRV();
 
    RENDERCORE_API virtual void ReleaseRHI() override;
 
    FShaderResourceViewRHIRef ShaderResourceViewRHI;
};
 
class FTextureReference : public FRenderResource
{
public:
    FTextureReferenceRHIRef TextureReferenceRHI;
 
private:
    bool bInitialized_GameThread;
 
public:
    RENDERCORE_API FTextureReference();
 
    // Destructor
    RENDERCORE_API virtual ~FTextureReference();
 
    RENDERCORE_API double GetLastRenderTime() const;
 
    RENDERCORE_API void InvalidateLastRenderTime();
 
    bool IsInitialized_GameThread() const { return bInitialized_GameThread; }
 
    RENDERCORE_API void BeginInit_GameThread();
 
    RENDERCORE_API void BeginRelease_GameThread();
 
    // FRenderResource interface.
    RENDERCORE_API virtual void InitRHI(FRHICommandListBase& RHICmdList);
    RENDERCORE_API virtual void ReleaseRHI();
    RENDERCORE_API virtual FString GetFriendlyName() const;
};
 
class FVertexBuffer : public FRenderResource
{
public:
    RENDERCORE_API FVertexBuffer();
    RENDERCORE_API FVertexBuffer(const FVertexBuffer&);
    RENDERCORE_API FVertexBuffer& operator=(const FVertexBuffer& Other);
    RENDERCORE_API virtual ~FVertexBuffer();
 
    // FRenderResource interface.
    RENDERCORE_API virtual void ReleaseRHI() override;
    RENDERCORE_API virtual FString GetFriendlyName() const override;
 
    const FBufferRHIRef& GetRHI() const { return VertexBufferRHI; }
 
    RENDERCORE_API void SetRHI(const FBufferRHIRef& BufferRHI);
 
    FBufferRHIRef VertexBufferRHI;
};
 
class FVertexBufferWithSRV : public FVertexBuffer
{
public:
    RENDERCORE_API FVertexBufferWithSRV();
    RENDERCORE_API ~FVertexBufferWithSRV();
 
    RENDERCORE_API virtual void ReleaseRHI() override;
 
    FShaderResourceViewRHIRef ShaderResourceViewRHI;
 
    FUnorderedAccessViewRHIRef UnorderedAccessViewRHI;
};
 
class FIndexBuffer : public FRenderResource
{
public:
    RENDERCORE_API FIndexBuffer();
    RENDERCORE_API FIndexBuffer(const FIndexBuffer&);
    RENDERCORE_API FIndexBuffer& operator=(const FIndexBuffer& Other);
    RENDERCORE_API virtual ~FIndexBuffer();
 
    // FRenderResource interface.
    RENDERCORE_API virtual void ReleaseRHI() override;
    RENDERCORE_API virtual FString GetFriendlyName() const override;
 
    const FBufferRHIRef& GetRHI() const { return IndexBufferRHI; }
 
    RENDERCORE_API void SetRHI(const FBufferRHIRef& BufferRHI);
 
    FBufferRHIRef IndexBufferRHI;
};
 
class FBufferWithRDG : public FRenderResource
{
public:
    RENDERCORE_API FBufferWithRDG();
    RENDERCORE_API FBufferWithRDG(const FBufferWithRDG& Other);
    RENDERCORE_API FBufferWithRDG& operator=(const FBufferWithRDG& Other);
    RENDERCORE_API ~FBufferWithRDG() override;
 
    RENDERCORE_API void ReleaseRHI() override;
 
    TRefCountPtr<FRDGPooledBuffer> Buffer;
};
 
template<class ResourceType, FRenderResource::EInitPhase InInitPhase = FRenderResource::EInitPhase::Default>
class TGlobalResource : public ResourceType
{
public:
    TGlobalResource()
    {
        InitGlobalResource();
    }
 
    template<typename... Args>
    explicit TGlobalResource(Args... InArgs)
        : ResourceType(InArgs...)
    {
        InitGlobalResource();
    }
 
    virtual ~TGlobalResource()
    {
        ReleaseGlobalResource();
    }
 
private:
 
    void InitGlobalResource()
    {
        ResourceType::SetInitPhase(InInitPhase);
 
        if (IsInRenderingThread())
        {
            // If the resource is constructed in the rendering thread, directly initialize it.
            ((ResourceType*)this)->InitResource(FRenderResource::GetImmediateCommandList());
        }
        else
        {
            // If the resource is constructed outside of the rendering thread, enqueue a command to initialize it.
            BeginInitResource((ResourceType*)this);
        }
    }
 
    void ReleaseGlobalResource()
    {
        // This should be called in the rendering thread, or at shutdown when the rendering thread has exited.
        // However, it may also be called at shutdown after an error, when the rendering thread is still running.
        // To avoid a second error in that case we don't assert.
#if 0
        check(IsInRenderingThread());
#endif
 
        // Cleanup the resource.
        ((ResourceType*)this)->ReleaseResource();
    }
};
 
struct FRenderResourceNameScope
{
    FRenderResourceNameScope(FName Name)
    {
        PreviousName = FRenderResource::SetScopeName(Name);
    }
 
    ~FRenderResourceNameScope()
    {
        FRenderResource::SetScopeName(PreviousName);
    }
 
private:
    FName PreviousName;
};