DynamicRHI.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
DynamicRHI.h: Dynamically bound Render Hardware Interface definitions.
=============================================================================*/
 
#pragma once
 
#include "CoreTypes.h"
#include "RHIBufferInitializer.h"
#include "RHIContext.h"
#include "RHIFeatureLevel.h"
#include "RHIShaderLibrary.h"
#include "RHITextureInitializer.h"
#include "MultiGPU.h"
#include "Serialization/MemoryLayout.h"
#include "Containers/ArrayView.h"
#include "Misc/EnumClassFlags.h"
#include "Async/TaskGraphInterfaces.h"
 
class FBlendStateInitializerRHI;
class FGraphicsPipelineStateInitializer;
class FLastRenderTimeContainer;
class FReadSurfaceDataFlags;
class FRHICommandList;
class FRHICommandListBase;
class FRHIComputeFence;
class FRayTracingPipelineState;
class IRHITransientResourceAllocator;
struct FDepthStencilStateInitializerRHI;
struct FDisplayInformation;
struct FRasterizerStateInitializerRHI;
struct FRHIBufferCreateDesc;
struct FRHIResourceCollectionMember;
struct FRHIResourceCreateInfo;
struct FRHIResourceInfo;
struct FRHIUniformBufferLayout;
struct FSamplerStateInitializerRHI;
struct FTextureMemoryStats;
struct FRHIGPUMask;
struct FUpdateTexture3DData;
struct FResourceArrayUploadInterface;
 
typedef TArray<FScreenResolutionRHI> FScreenResolutionArray;
using FDisplayInformationArray = TArray<FDisplayInformation>;
 
struct FRHIFlipDetails
{
    uint64 PresentIndex;
    double FlipTimeInSeconds;
    double VBlankTimeInSeconds;
    uint64 VBlankTimeInCycles;
 
    FRHIFlipDetails()
        : PresentIndex(0)
        , FlipTimeInSeconds(0)
        , VBlankTimeInSeconds(0)
        , VBlankTimeInCycles(0)
    {}
 
    FRHIFlipDetails(uint64 InPresentIndex, double InFlipTimeInSeconds, double InVBlankTimeInSeconds, uint64 InVBlankTimeInCycles)
        : PresentIndex(InPresentIndex)
        , FlipTimeInSeconds(InFlipTimeInSeconds)
        , VBlankTimeInSeconds(InVBlankTimeInSeconds)
        , VBlankTimeInCycles(InVBlankTimeInCycles)
    {}
};
 
//UE_DEPRECATED(5.3, "Use the CreateShaderResourceView function that takes an FRHIBufferSRVCreateDesc.")
struct FShaderResourceViewInitializer : public FRHIViewDesc::FBufferSRV::FInitializer
{
    FRHIBuffer* Buffer;
 
    RHI_API FShaderResourceViewInitializer(FRHIBuffer* InBuffer, EPixelFormat InFormat, uint32 InStartOffsetBytes, uint32 InNumElements);
    RHI_API FShaderResourceViewInitializer(FRHIBuffer* InBuffer, EPixelFormat InFormat);
    RHI_API FShaderResourceViewInitializer(FRHIBuffer* InBuffer, uint32 InStartOffsetBytes, uint32 InNumElements);
    RHI_API FShaderResourceViewInitializer(FRHIBuffer* InBuffer, FRHIRayTracingScene* InRayTracingScene, uint32 InStartOffsetBytes);
    RHI_API FShaderResourceViewInitializer(FRHIBuffer* InBuffer);
};
 
 
/*
* FRawBufferShaderResourceViewInitializer can be used to explicitly create a raw view for any buffer,
* even if it was not created with EBufferUsageFlags::ByteAddressBuffer flag.
* Can only be used if GRHIGlobals.SupportsRawViewsForAnyBuffer is set.
*/
//UE_DEPRECATED(5.3, "Use the CreateShaderResourceView function that takes an FRHIBufferSRVCreateDesc, and call SetRawAccess(true).")
struct FRawBufferShaderResourceViewInitializer : public FShaderResourceViewInitializer
{
    FRawBufferShaderResourceViewInitializer(FRHIBuffer* InBuffer)
        : FShaderResourceViewInitializer(InBuffer)
    {
        SetType(FRHIViewDesc::EBufferType::Raw);
    }
};
 
class FDynamicRHI;
 
class FDefaultRHIRenderQueryPool final : public FRHIRenderQueryPool
{
public:
    FDefaultRHIRenderQueryPool(ERenderQueryType InQueryType)
        : QueryType(InQueryType)
    {}
 
    RHI_API virtual ~FDefaultRHIRenderQueryPool();
 
private:
    RHI_API virtual FRHIPooledRenderQuery AllocateQuery() override;
    RHI_API virtual void ReleaseQuery(TRefCountPtr<FRHIRenderQuery>&& Query) override;
 
    const ERenderQueryType QueryType;
    uint32 AllocatedQueries = 0;
    TArray<TRefCountPtr<FRHIRenderQuery>> Queries;
    UE::FMutex QueriesMutex;
};
 
struct FRHICalcTextureSizeResult
{
    // The total size of the texture, in bytes.
    uint64 Size;
 
    // The required address alignment for the texture.
    uint32 Align;
};
 
struct FRHILockedTextureDesc
{
    FRHITexture* Texture = nullptr;
    uint32       FaceIndex = 0;
    uint32       ArrayIndex = 0;
    uint32       MipIndex = 0;
 
    bool operator==(const FRHILockedTextureDesc& Other) const
    {
        return Texture    == Other.Texture
            && FaceIndex  == Other.FaceIndex
            && ArrayIndex == Other.ArrayIndex
            && MipIndex   == Other.MipIndex;
    }
    bool operator!=(const FRHILockedTextureDesc& Other) const
    {
        return !(*this == Other);
    }
};
 
struct FRHILockTextureArgs : public FRHILockedTextureDesc
{
    static inline FRHILockTextureArgs Lock2D(FRHITexture* InTexture, uint32 InMipIndex, EResourceLockMode InLockMode, bool bInLockWithinMiptail, bool bFlushRHIThread = true)
    {
        FRHILockTextureArgs Result;
 
        Result.Texture = InTexture;
        Result.LockMode = InLockMode;
        Result.MipIndex = InMipIndex;
        Result.bLockWithinMiptail = bInLockWithinMiptail;
        Result.bNeedsDefaultRHIFlush = bFlushRHIThread;
 
        return Result;
    }
    static inline FRHILockTextureArgs Lock2DArray(FRHITexture* InTexture, uint32 InArrayIndex, uint32 InMipIndex, EResourceLockMode InLockMode, bool bInLockWithinMiptail)
    {
        FRHILockTextureArgs Result;
 
        Result.Texture = InTexture;
        Result.LockMode = InLockMode;
        Result.ArrayIndex = InArrayIndex;
        Result.MipIndex = InMipIndex;
        Result.bLockWithinMiptail = bInLockWithinMiptail;
 
        return Result;
    }
    static inline FRHILockTextureArgs LockCubeFace(FRHITexture* InTexture, uint32 InFaceIndex, uint32 InArrayIndex, uint32 InMipIndex, EResourceLockMode InLockMode, bool bInLockWithinMiptail)
    {
        FRHILockTextureArgs Result;
 
        Result.Texture = InTexture;
        Result.LockMode = InLockMode;
        Result.FaceIndex = InFaceIndex;
        Result.ArrayIndex = InArrayIndex;
        Result.MipIndex = InMipIndex;
        Result.bLockWithinMiptail = bInLockWithinMiptail;
 
        return Result;
    }
 
    EResourceLockMode LockMode = RLM_Num;
    bool              bLockWithinMiptail = false;
    bool              bNeedsDefaultRHIFlush = false;
 
protected:
    // Default constructor restricted to use in static functions
    FRHILockTextureArgs() = default;
};
 
struct FRHILockTextureResult
{
    void*  Data      = nullptr;
    uint64 ByteCount = 0;
    uint32 Stride    = 0;
};
 
class FDynamicRHI
{
public:
    using FRHICalcTextureSizeResult = ::FRHICalcTextureSizeResult;
 
    RHI_API virtual ~FDynamicRHI();
 
    virtual void Init() = 0;
 
    virtual void PostInit() {}
 
    virtual void Shutdown() = 0;
 
    virtual const TCHAR* GetName() = 0;
 
    virtual ERHIInterfaceType GetInterfaceType() const { return ERHIInterfaceType::Hidden; }
    virtual FDynamicRHI* GetNonValidationRHI() { return this; }
 
    void InitPixelFormatInfo(const TArray<uint32>& PixelFormatBlockBytesIn)
    {
        PixelFormatBlockBytes = PixelFormatBlockBytesIn;
    }
 
 
    RHI_API virtual void RHIEndFrame_RenderThread(FRHICommandListImmediate& RHICmdList);
 
    struct FRHIEndFrameArgs
    {
        // Increments once per call to RHIEndFrame
        uint32 FrameNumber;
 
    #if WITH_RHI_BREADCRUMBS
        const TRHIPipelineArray<FRHIBreadcrumbNode*>& GPUBreadcrumbs;
    #endif
    #if STATS
        TOptional<int64> StatsFrame;
    #endif
    };
    virtual void RHIEndFrame(const FRHIEndFrameArgs& Args) = 0;
 
    // FlushType: Thread safe
    virtual FSamplerStateRHIRef RHICreateSamplerState(const FSamplerStateInitializerRHI& Initializer) = 0;
 
    // FlushType: Thread safe
    virtual FRasterizerStateRHIRef RHICreateRasterizerState(const FRasterizerStateInitializerRHI& Initializer) = 0;
 
    // FlushType: Thread safe
    virtual FDepthStencilStateRHIRef RHICreateDepthStencilState(const FDepthStencilStateInitializerRHI& Initializer) = 0;
 
    // FlushType: Thread safe
    virtual FBlendStateRHIRef RHICreateBlendState(const FBlendStateInitializerRHI& Initializer) = 0;
 
    // FlushType: Wait RHI Thread
    virtual FVertexDeclarationRHIRef RHICreateVertexDeclaration(const FVertexDeclarationElementList& Elements) = 0;
 
    // FlushType: Wait RHI Thread
    virtual FPixelShaderRHIRef RHICreatePixelShader(TArrayView<const uint8> Code, const FSHAHash& Hash) = 0;
 
    // FlushType: Wait RHI Thread
    virtual FVertexShaderRHIRef RHICreateVertexShader(TArrayView<const uint8> Code, const FSHAHash& Hash) = 0;
 
    // FlushType: Wait RHI Thread
    virtual FGeometryShaderRHIRef RHICreateGeometryShader(TArrayView<const uint8> Code, const FSHAHash& Hash) = 0;
 
    // FlushType: Wait RHI Thread
    virtual FMeshShaderRHIRef RHICreateMeshShader(TArrayView<const uint8> Code, const FSHAHash& Hash)
    {
        return FMeshShaderRHIRef();
    }
 
    // FlushType: Wait RHI Thread
    virtual FAmplificationShaderRHIRef RHICreateAmplificationShader(TArrayView<const uint8> Code, const FSHAHash& Hash)
    {
        return FAmplificationShaderRHIRef();
    }
 
    // Some RHIs can have pending messages/logs for error tracking, or debug modes
    virtual void FlushPendingLogs() {}
 
    // FlushType: Wait RHI Thread
    virtual FComputeShaderRHIRef RHICreateComputeShader(TArrayView<const uint8> Code, const FSHAHash& Hash) = 0;
 
    // FlushType: Wait RHI Thread
    virtual FWorkGraphShaderRHIRef RHICreateWorkGraphShader(TArrayView<const uint8> Code, const FSHAHash& Hash, EShaderFrequency ShaderFrequency)
    {
        return FWorkGraphShaderRHIRef();
    }
 
     // FlushType: Must be Thread-Safe.
    virtual FRHIShaderLibraryRef RHICreateShaderLibrary(EShaderPlatform Platform, FString const& FilePath, FString const& Name)
    {
        return nullptr;
    }
 
    virtual FGPUFenceRHIRef RHICreateGPUFence(const FName &Name) = 0;
 
    //
    // Called by the thread recording an RHI command list (via RHICmdList.WriteGPUFence()).
    // Allows the platform RHI to perform operations on the GPU fence at the top-of-pipe.
    // Default implementation just enqueues an RHI command to call IRHIComputeContext::WriteGPUFence().
    //
    RHI_API virtual void RHIWriteGPUFence_TopOfPipe(FRHICommandListBase& RHICmdList, FRHIGPUFence* FenceRHI);
 
    virtual void RHICreateTransition(FRHITransition* Transition, const FRHITransitionCreateInfo& CreateInfo)
    {
    }
 
    virtual void RHIReleaseTransition(FRHITransition* Transition)
    {
    }
 
    virtual IRHITransientResourceAllocator* RHICreateTransientResourceAllocator() { return nullptr; }
 
    // FlushType: Thread safe.  
    virtual FStagingBufferRHIRef RHICreateStagingBuffer()
    {
        return new FGenericRHIStagingBuffer();
    }
 
    RHI_API virtual void* RHILockStagingBuffer(FRHIStagingBuffer* StagingBuffer, FRHIGPUFence* Fence, uint32 Offset, uint32 SizeRHI);
 
    RHI_API virtual void RHIUnlockStagingBuffer(FRHIStagingBuffer* StagingBuffer);
 
    RHI_API virtual void* LockStagingBuffer_RenderThread(class FRHICommandListImmediate& RHICmdList, FRHIStagingBuffer* StagingBuffer, FRHIGPUFence* Fence, uint32 Offset, uint32 SizeRHI);
 
    RHI_API virtual void UnlockStagingBuffer_RenderThread(class FRHICommandListImmediate& RHICmdList, FRHIStagingBuffer* StagingBuffer);
 
    // FlushType: Thread safe, but varies depending on the RHI
    virtual FBoundShaderStateRHIRef RHICreateBoundShaderState(FRHIVertexDeclaration* VertexDeclaration, FRHIVertexShader* VertexShader, FRHIPixelShader* PixelShader, FRHIGeometryShader* GeometryShader) = 0;
 
#if PLATFORM_SUPPORTS_MESH_SHADERS && PLATFORM_USE_FALLBACK_PSO
    // FlushType: Thread safe, but varies depending on the RHI
    virtual FBoundShaderStateRHIRef RHICreateBoundShaderState(FRHIAmplificationShader* AmplificationShader, FRHIMeshShader* MeshShader, FRHIPixelShader* PixelShader) = 0;
#endif
 
    // FlushType: Thread safe
    virtual FGraphicsPipelineStateRHIRef RHICreateGraphicsPipelineState(const FGraphicsPipelineStateInitializer& Initializer) = 0;
 
    // FlushType: Thread safe
    virtual FComputePipelineStateRHIRef RHICreateComputePipelineState(const FComputePipelineStateInitializer& Initializer) = 0;
 
    virtual FWorkGraphPipelineStateRHIRef RHICreateWorkGraphPipelineState(const FWorkGraphPipelineStateInitializer& Initializer)
    {
        checkNoEntry();
        return nullptr;
    }
 
    // FlushType: Thread safe, but varies depending on the RHI
    virtual FUniformBufferRHIRef RHICreateUniformBuffer(const void* Contents, const FRHIUniformBufferLayout* Layout, EUniformBufferUsage Usage, EUniformBufferValidation Validation) = 0;
 
    virtual void RHIUpdateUniformBuffer(FRHICommandListBase& RHICmdList, FRHIUniformBuffer* UniformBufferRHI, const void* Contents) = 0;
 
    virtual void RHIReplaceResources(FRHICommandListBase& RHICmdList, TArray<FRHIResourceReplaceInfo>&& ReplaceInfos) = 0;
 
    [[nodiscard]] virtual FRHIBufferInitializer RHICreateBufferInitializer(FRHICommandListBase& RHICmdList, const FRHIBufferCreateDesc& CreateDesc) = 0;
 
    RHI_API virtual void* RHILockBuffer(FRHICommandListBase& RHICmdList, FRHIBuffer* Buffer, uint32 Offset, uint32 Size, EResourceLockMode LockMode);
    RHI_API virtual void* RHILockBufferMGPU(FRHICommandListBase& RHICmdList, FRHIBuffer* Buffer, uint32 GPUIndex, uint32 Offset, uint32 Size, EResourceLockMode LockMode);
 
    // FlushType: Flush RHI Thread
    RHI_API virtual void RHIUnlockBuffer(FRHICommandListBase& RHICmdList, FRHIBuffer* Buffer);
    RHI_API virtual void RHIUnlockBufferMGPU(FRHICommandListBase& RHICmdList, FRHIBuffer* Buffer, uint32 GPUIndex);
 
    RHI_API virtual void RHIUpdateTextureReference(FRHICommandListBase& RHICmdList, FRHITextureReference* TextureRef, FRHITexture* NewTexture);
 
#if ENABLE_LOW_LEVEL_MEM_TRACKER || UE_MEMORY_TRACE_ENABLED
    virtual void RHIUpdateAllocationTags(FRHICommandListBase& RHICmdList, FRHIBuffer* Buffer) = 0;
#endif
 
    // FlushType: Thread safe
    virtual FRHICalcTextureSizeResult RHICalcTexturePlatformSize(FRHITextureDesc const& Desc, uint32 FirstMipIndex) = 0;
 
    // FlushType: Thread safe
    RHI_API virtual uint64 RHIGetMinimumAlignmentForBufferBackedSRV(EPixelFormat Format);
 
    // FlushType: Thread safe
    virtual void RHIGetTextureMemoryStats(FTextureMemoryStats& OutStats) = 0;
 
    // FlushType: Flush Immediate
    virtual bool RHIGetTextureMemoryVisualizeData(FColor* TextureData, int32 SizeX, int32 SizeY, int32 Pitch, int32 PixelSize) = 0;
 
    // Create a texture initializer, used for creating a RHITexture with data.
    [[nodiscard]]
    virtual FRHITextureInitializer RHICreateTextureInitializer(FRHICommandListBase& RHICmdList, const FRHITextureCreateDesc& CreateDesc) = 0;
 
    // FlushType: Thread safe
    virtual FTextureRHIRef RHIAsyncCreateTexture2D(uint32 SizeX, uint32 SizeY, uint8 Format, uint32 NumMips, ETextureCreateFlags Flags, ERHIAccess InResourceState, void** InitialMipData, uint32 NumInitialMips, const TCHAR* DebugName, FGraphEventRef& OutCompletionEvent) = 0;
 
        
 
    RHI_API virtual FTextureReferenceRHIRef RHICreateTextureReference(FRHICommandListBase& RHICmdList, FRHITexture* InReferencedTexture);
 
    // SRV / UAV creation functions
    virtual FShaderResourceViewRHIRef  RHICreateShaderResourceView (class FRHICommandListBase& RHICmdList, FRHIViewableResource* Resource, FRHIViewDesc const& ViewDesc) = 0;
    virtual FUnorderedAccessViewRHIRef RHICreateUnorderedAccessView(class FRHICommandListBase& RHICmdList, FRHIViewableResource* Resource, FRHIViewDesc const& ViewDesc) = 0;
 
    virtual FRHIResourceCollectionRef RHICreateResourceCollection(FRHICommandListBase& RHICmdList, TConstArrayView<FRHIResourceCollectionMember> InMembers)
    {
        return FRHIResourceCollectionRef{};
    }
 
    virtual void RHIUpdateResourceCollection(FRHICommandListBase& RHICmdList, FRHIResourceCollection* InResourceCollection, uint32 InStartIndex, TConstArrayView<FRHIResourceCollectionMember> InMemberUpdates)
    {
    }
 
    // FlushType: Thread safe
    virtual uint32 RHIComputeMemorySize(FRHITexture* TextureRHI) = 0;
 
    // FlushType: Flush RHI Thread
    // NP: Note that no RHI currently implements this as an async call, we should simplify the API.
    virtual FTextureRHIRef RHIAsyncReallocateTexture2D(FRHITexture* Texture2D, int32 NewMipCount, int32 NewSizeX, int32 NewSizeY, FThreadSafeCounter* RequestStatus) = 0;
 
    virtual FRHILockTextureResult RHILockTexture  (FRHICommandListImmediate& RHICmdList, const FRHILockTextureArgs& Arguments) = 0;
    virtual void                  RHIUnlockTexture(FRHICommandListImmediate& RHICmdList, const FRHILockTextureArgs& Arguments) = 0;
 
    virtual void RHIUpdateTexture2D(FRHICommandListBase& RHICmdList, FRHITexture* Texture, uint32 MipIndex, const struct FUpdateTextureRegion2D& UpdateRegion, uint32 SourcePitch, const uint8* SourceData) = 0;
 
    virtual void RHIUpdateFromBufferTexture2D(FRHICommandListBase& RHICmdList, FRHITexture* Texture, uint32 MipIndex, const struct FUpdateTextureRegion2D& UpdateRegion, uint32 SourcePitch, FRHIBuffer* Buffer, uint32 BufferOffset)
    {
        checkNoEntry();
    }
 
    virtual void RHIUpdateTexture3D(FRHICommandListBase& RHICmdList, FRHITexture* Texture, uint32 MipIndex, const struct FUpdateTextureRegion3D& UpdateRegion, uint32 SourceRowPitch, uint32 SourceDepthPitch, const uint8* SourceData) = 0;
 
    RHI_API virtual void RHIBindDebugLabelName(FRHICommandListBase& RHICmdList,FRHITexture* Texture, const TCHAR* Name);
    RHI_API virtual void RHIBindDebugLabelName(FRHICommandListBase& RHICmdList, FRHIBuffer* Buffer, const TCHAR* Name);
    RHI_API virtual void RHIBindDebugLabelName(FRHICommandListBase& RHICmdList, FRHIUnorderedAccessView* UnorderedAccessViewRHI, const TCHAR* Name);
 
    // FlushType: Flush Immediate (seems wrong)
    virtual void RHIReadSurfaceData(FRHITexture* Texture, FIntRect Rect, TArray<FColor>& OutData, FReadSurfaceDataFlags InFlags) = 0;
 
    // Default fallback; will not work for non-8-bit surfaces and it's extremely slow.
    RHI_API virtual void RHIReadSurfaceData(FRHITexture* Texture, FIntRect Rect, TArray<FLinearColor>& OutData, FReadSurfaceDataFlags InFlags);
 
#if PLATFORM_IOS
    virtual void RHIReadSurfaceDataDirect(FRHITexture* Texture, FIntRect Rect, TArray<FColor>& OutData) {}
#endif // PLATFORM_IOS
 
    // FlushType: Flush Immediate (seems wrong)
    virtual void RHIMapStagingSurface(FRHITexture* Texture, FRHIGPUFence* Fence, void*& OutData, int32& OutWidth, int32& OutHeight, uint32 GPUIndex = 0) = 0;
 
    // FlushType: Flush Immediate (seems wrong)
    virtual void RHIUnmapStagingSurface(FRHITexture* Texture, uint32 GPUIndex = 0) = 0;
 
    // FlushType: Flush Immediate (seems wrong)
    virtual void RHIReadSurfaceFloatData(FRHITexture* Texture, FIntRect Rect, TArray<FFloat16Color>& OutData, ECubeFace CubeFace, int32 ArrayIndex, int32 MipIndex) = 0;
 
    // FlushType: Flush Immediate (seems wrong)
    RHI_API virtual void RHIReadSurfaceFloatData(FRHITexture* Texture, FIntRect Rect, TArray<FFloat16Color>& OutData, FReadSurfaceDataFlags InFlags);
 
    // FlushType: Flush Immediate (seems wrong)
    virtual void RHIRead3DSurfaceFloatData(FRHITexture* Texture, FIntRect Rect, FIntPoint ZMinMax, TArray<FFloat16Color>& OutData) = 0;
 
    // FlushType: Flush Immediate (seems wrong)
    RHI_API virtual void RHIRead3DSurfaceFloatData(FRHITexture* Texture, FIntRect Rect, FIntPoint ZMinMax, TArray<FFloat16Color>& OutData, FReadSurfaceDataFlags InFlags);
 
    // FlushType: Wait RHI Thread
    virtual FRenderQueryRHIRef RHICreateRenderQuery(ERenderQueryType QueryType) = 0;
 
    virtual void RHIBeginRenderQueryBatch_TopOfPipe(FRHICommandListBase& RHICmdList, ERenderQueryType QueryType) {}
    virtual void RHIEndRenderQueryBatch_TopOfPipe  (FRHICommandListBase& RHICmdList, ERenderQueryType QueryType) {}
 
    RHI_API virtual void RHIBeginRenderQuery_TopOfPipe(FRHICommandListBase& RHICmdList, FRHIRenderQuery* RenderQuery);
    RHI_API virtual void RHIEndRenderQuery_TopOfPipe  (FRHICommandListBase& RHICmdList, FRHIRenderQuery* RenderQuery);
 
    // CAUTION: Even though this is marked as threadsafe, it is only valid to call from the render thread. It is need not be threadsafe on platforms that do not support or aren't using an RHIThread
    // FlushType: Thread safe, but varies by RHI
    virtual bool RHIGetRenderQueryResult(FRHIRenderQuery* RenderQuery, uint64& OutResult, bool bWait, uint32 GPUIndex = INDEX_NONE) = 0;
 
    // FlushType: Thread safe
    virtual uint32 RHIGetViewportNextPresentGPUIndex(FRHIViewport* Viewport)
    {
        return 0; // By default, viewport need to be rendered on GPU0.
    }
 
    // With RHI thread, this is the current backbuffer from the perspective of the render thread.
    // FlushType: Thread safe
    virtual FTextureRHIRef RHIGetViewportBackBuffer(FRHIViewport* Viewport) = 0;
 
    virtual FUnorderedAccessViewRHIRef RHIGetViewportBackBufferUAV(FRHIViewport* ViewportRHI)
    {
        return FUnorderedAccessViewRHIRef();
    }
 
    virtual uint32 RHIGetHTilePlatformConfig(uint32 DepthWidth, uint32 DepthHeight) const
    {
        return 0;
    }
 
    virtual uint32 RHIGetHTilePlatformConfig(const FRHITextureDesc& DepthDesc) const
    {
        return 0;
    }
 
    virtual void RHIAliasTextureResources(FTextureRHIRef& DestTexture, FTextureRHIRef& SrcTexture)
    {
        checkNoEntry();
    }
 
    virtual FTextureRHIRef RHICreateAliasedTexture(FTextureRHIRef& SourceTexture)
    {
        checkNoEntry();
        return nullptr;
    }
 
    virtual void RHIGetDisplaysInformation(FDisplayInformationArray& OutDisplayInformation)
    {
    }
    
    // Compute the hash of the state components of the PSO initializer for PSO Precaching (only hash data relevant for the RHI specific PSO)
    RHI_API virtual uint64 RHIComputeStatePrecachePSOHash(const FGraphicsPipelineStateInitializer& Initializer);
 
    // Compute the hash of the PSO initializer for PSO Precaching (only hash data relevant for the RHI specific PSO)
    RHI_API virtual uint64 RHIComputePrecachePSOHash(const FGraphicsPipelineStateInitializer& Initializer);
 
    // Check if PSO Initializers are the same used during PSO Precaching (only compare data relevant for the RHI specific PSO)
    RHI_API virtual bool RHIMatchPrecachePSOInitializers(const FGraphicsPipelineStateInitializer& LHS, const FGraphicsPipelineStateInitializer& RHS);
 
    // Only relevant with an RHI thread, this advances the backbuffer for the purpose of GetViewportBackBuffer
    // FlushType: Thread safe
    virtual void RHIAdvanceFrameForGetViewportBackBuffer(FRHIViewport* Viewport, bool bPresent) = 0;
 
    //
    // Acquires or releases ownership of the platform-specific rendering context for the calling thread.
    // Only required by OpenGL RHI.
    //
    virtual void RHIAcquireThreadOwnership() {}
    virtual void RHIReleaseThreadOwnership() {}
 
    // Flush driver resources. Typically called when switching contexts/threads
    // FlushType: Flush RHI Thread
    virtual void RHIFlushResources() = 0;
 
    //  must be called from the main thread.
    // FlushType: Thread safe
    virtual FViewportRHIRef RHICreateViewport(void* WindowHandle, uint32 SizeX, uint32 SizeY, bool bIsFullscreen, EPixelFormat PreferredPixelFormat) = 0;
 
    //  must be called from the main thread.
    // FlushType: Thread safe
    virtual void RHIResizeViewport(FRHIViewport* Viewport, uint32 SizeX, uint32 SizeY, bool bIsFullscreen) = 0;
 
    virtual void RHIResizeViewport(FRHIViewport* Viewport, uint32 SizeX, uint32 SizeY, bool bIsFullscreen, EPixelFormat PreferredPixelFormat)
    {
        // Default implementation for RHIs that cannot change formats on the fly
        RHIResizeViewport(Viewport, SizeX, SizeY, bIsFullscreen);
    }
 
    // Return preferred pixel format if given format is unsupported.
    virtual EPixelFormat RHIPreferredPixelFormatHint(EPixelFormat PreferredPixelFormat)
    {
        return PreferredPixelFormat;
    }
 
    // Tests the viewport to see if its HDR status has changed. This is usually tested after a window has been moved
    RHI_API virtual void RHICheckViewportHDRStatus(FRHIViewport* Viewport);
 
    virtual void RHIHandleDisplayChange() {}
 
    //  must be called from the main thread.
    // FlushType: Thread safe
    virtual void RHITick(float DeltaTime) = 0;
 
    // Blocks the CPU until the GPU catches up and goes idle.
    // FlushType: Flush Immediate (seems wrong)
    virtual void RHIBlockUntilGPUIdle() = 0;
 
    // Tells the RHI we're about to suspend it
    virtual void RHIBeginSuspendRendering() {};
 
    // Operations to suspend title rendering and yield control to the system
    // FlushType: Thread safe
    virtual void RHISuspendRendering() {};
 
    // FlushType: Thread safe
    virtual void RHIResumeRendering() {};
 
    // FlushType: Flush Immediate
    virtual bool RHIIsRenderingSuspended() { return false; };
 
    // FlushType: Thread safe
    virtual bool RHIGetAvailableResolutions(FScreenResolutionArray& Resolutions, bool bIgnoreRefreshRate) = 0;
 
    // FlushType: Thread safe
    virtual void RHIGetSupportedResolution(uint32& Width, uint32& Height) = 0;
 
    // FlushType: Wait RHI Thread
    RHI_API virtual void RHIVirtualTextureSetFirstMipInMemory(class FRHICommandListImmediate& RHICmdList, FRHITexture* Texture, uint32 FirstMip);
 
    // FlushType: Wait RHI Thread
    RHI_API virtual void RHIVirtualTextureSetFirstMipVisible(class FRHICommandListImmediate& RHICmdList, FRHITexture* Texture, uint32 FirstMip);
 
    // FlushType: Flush RHI Thread
    virtual void* RHIGetNativeDevice() = 0;
 
    // FlushType: Flush RHI Thread
    virtual void* RHIGetNativePhysicalDevice() 
    {
        // Currently only exists on Vulkan, so no need to force every backend to implement this.
        return nullptr;
    }
 
    // FlushType: Flush RHI Thread
    virtual void* RHIGetNativeGraphicsQueue() 
    {
        return nullptr;
    }
 
    // FlushType: Flush RHI Thread
    virtual void* RHIGetNativeComputeQueue() 
    {
        return nullptr;
    }
 
    // FlushType: Flush RHI Thread
    virtual void* RHIGetNativeInstance() = 0;
 
    // FlushType: Not Thread Safe!
    virtual void* RHIGetNativeCommandBuffer() 
    {
        return nullptr;
    }
 
 
    // FlushType: Thread safe
    virtual IRHICommandContext* RHIGetDefaultContext() = 0;
 
    //
    // Retrieves a new command context to begin the recording of a new platform command list.
    // The returned context is specific to the given pipeline. It can later be converted to an IRHIPlatformCommandList
    // by calling RHIFinalizeContext(), and then submitted to the GPU by calling RHISubmitCommandLists().
    //
    // Called by parallel worker threads, and the render thread. Platform implementations must be thread safe.
    //
    virtual IRHIComputeContext* RHIGetCommandContext(ERHIPipeline Pipeline, FRHIGPUMask GPUMask) = 0;
    
    //
    // Retrieves a new command context to begin the recording of a new platform command list.
    // The returned context is only for graphics pipelines and is used in conjunction with SubCommandList
    // The returned context is expected to be in a state to execute draw commands immediately, i.e. renderpasses must be created and state set.
    //
    // Called by parallel worker threads, and the render thread. Platform implementations must be thread safe.
    //
    virtual IRHIComputeContext* RHIGetParallelCommandContext(FRHIParallelRenderPassInfo const& ParallelRenderPass, FRHIGPUMask GPUMask)
    {
        IRHICommandContext* Context = static_cast<IRHICommandContext*>(RHIGetCommandContext(ERHIPipeline::Graphics, GPUMask));
        Context->RHIBeginRenderPass(ParallelRenderPass, ParallelRenderPass.PassName);
        
        return Context;
    }
    
    virtual IRHIUploadContext* RHIGetUploadContext()
    {
        return nullptr;
    };
    
    //
    // Finalizes (i.e. closes) the specified command context, returning the completed platform command list object.
    // The returned command list can later be submitted to the GPU by calling RHISubmitCommandLists().
    //
    // The context may be destroyed or recycled, so should not be used again. Call RHIGetCommandContext() to get a new context.
    //
    // Called by parallel worker threads, and the RHI thread. Platform implementations must be thread safe.
    //
    struct FRHIFinalizeContextArgs
    {
        TArray<IRHIComputeContext*> Contexts;
        IRHIUploadContext* UploadContext;
    };
    
    //
    // Close the current translate chain or ignore if we are not finalizing
    //
    #if ENABLE_RHI_VALIDATION
    virtual
    #endif
    void RHICloseTranslateChain(FRHIFinalizeContextArgs&& Args, TRHIPipelineArray<IRHIPlatformCommandList*>& Output, bool bShouldFinalize)
    {
        if(bShouldFinalize)
        {
            RHIFinalizeContext(MoveTemp(Args), Output);
        }
    }
 
    virtual void RHIFinalizeContext(FRHIFinalizeContextArgs&& Args, TRHIPipelineArray<IRHIPlatformCommandList*>& Output) = 0;
    
    virtual IRHIPlatformCommandList* RHIFinalizeParallelContext(IRHIComputeContext* Context)
    {
        FRHIFinalizeContextArgs Args;
        static_cast<IRHICommandContext*>(Context)->RHIEndRenderPass();
        
        Args.Contexts.Add(Context);
        
        TRHIPipelineArray<IRHIPlatformCommandList*> Output {nullptr, nullptr};
        RHIFinalizeContext(MoveTemp(Args), Output);
        
        return Output[ERHIPipeline::Graphics];
    }
 
    //
    // Submits a batch of previously recorded/finalized command lists to the GPU. 
    // Command lists are well-ordered in the array view. Platform implementations must submit in this order for correct rendering.
    //
    // Called by the RHI thread. 
    //
    struct FRHISubmitCommandListsArgs
    {
        TArray<IRHIPlatformCommandList*> CommandLists;
        IRHIUploadContext* UploadContext;
    };
    virtual void RHISubmitCommandLists(FRHISubmitCommandListsArgs&& Args) = 0;
 
    //
    // Platform RHIs should implement this function to process their internal GPU resource/memory delete queues.
    // Called only from RHI command list management code. Do not call directly.
    //
    virtual void RHIProcessDeleteQueue() {}
 
    RHI_API virtual FTextureRHIRef AsyncReallocateTexture2D_RenderThread(class FRHICommandListImmediate& RHICmdList, FRHITexture* Texture2D, int32 NewMipCount, int32 NewSizeX, int32 NewSizeY, FThreadSafeCounter* RequestStatus);
 
    RHI_API virtual FUpdateTexture3DData RHIBeginUpdateTexture3D(FRHICommandListBase& RHICmdList, FRHITexture* Texture, uint32 MipIndex, const struct FUpdateTextureRegion3D& UpdateRegion);
    RHI_API virtual void RHIEndUpdateTexture3D(FRHICommandListBase& RHICmdList, FUpdateTexture3DData& UpdateData);
 
    RHI_API virtual void RHIEndMultiUpdateTexture3D(FRHICommandListBase& RHICmdList, TArray<FUpdateTexture3DData>& UpdateDataArray);
 
    RHI_API virtual FRHIShaderLibraryRef RHICreateShaderLibrary_RenderThread(class FRHICommandListImmediate& RHICmdList, EShaderPlatform Platform, FString FilePath, FString Name);
 
    RHI_API virtual void RHIMapStagingSurface_RenderThread(class FRHICommandListImmediate& RHICmdList, FRHITexture* Texture, uint32 GPUIndex, FRHIGPUFence* Fence, void*& OutData, int32& OutWidth, int32& OutHeight);
    RHI_API virtual void RHIUnmapStagingSurface_RenderThread(class FRHICommandListImmediate& RHICmdList, FRHITexture* Texture, uint32 GPUIndex);
    RHI_API virtual void RHIReadSurfaceFloatData_RenderThread(class FRHICommandListImmediate& RHICmdList, FRHITexture* Texture, FIntRect Rect, TArray<FFloat16Color>& OutData, ECubeFace CubeFace, int32 ArrayIndex, int32 MipIndex);
    RHI_API virtual void RHIReadSurfaceFloatData_RenderThread(class FRHICommandListImmediate& RHICmdList, FRHITexture* Texture, FIntRect Rect, TArray<FFloat16Color>& OutData, FReadSurfaceDataFlags Flags);
 
    // Buffer Lock/Unlock
    virtual void* LockBuffer_BottomOfPipe(class FRHICommandListBase& RHICmdList, FRHIBuffer* Buffer, uint32 Offset, uint32 SizeRHI, EResourceLockMode LockMode)
    {
        // Either this function or RHILockBuffer must be implemented by the platform RHI.
        checkNoEntry();
        return nullptr;
    }
 
    virtual void UnlockBuffer_BottomOfPipe(class FRHICommandListBase& RHICmdList, FRHIBuffer* Buffer)
    {
        // Either this function or RHIUnlockBuffer must be implemented by the platform RHI.
        checkNoEntry();
    }
 
    //Utilities
    static RHI_API void EnableIdealGPUCaptureOptions(bool bEnable);
 
    virtual FRHIFlipDetails RHIWaitForFlip(double TimeoutInSeconds) { return FRHIFlipDetails(); }
    virtual void RHISignalFlipEvent() { }
 
 
    virtual uint16 RHIGetPlatformTextureMaxSampleCount() { return 8; };
 
    virtual FRayTracingAccelerationStructureSize RHICalcRayTracingSceneSize(const FRayTracingSceneInitializer& Initializer)
    {
        checkNoEntry();
        return {};
    }
 
    virtual FRayTracingAccelerationStructureSize RHICalcRayTracingGeometrySize(const FRayTracingGeometryInitializer& Initializer)
    {
        checkNoEntry();
        return {};
    }
 
    virtual FRayTracingClusterOperationSize RHICalcRayTracingClusterOperationSize(const FRayTracingClusterOperationInitializer& Initializer)
    {
        checkNoEntry();
        return {};
    }
 
    virtual FRayTracingAccelerationStructureOfflineMetadata RHIGetRayTracingGeometryOfflineMetadata(const FRayTracingGeometryOfflineDataHeader& OfflineDataHeader)
    {
        checkNoEntry();
        return {};
    }
 
    virtual FRayTracingGeometryRHIRef RHICreateRayTracingGeometry(FRHICommandListBase& RHICmdList, const FRayTracingGeometryInitializer& Initializer)
    {
        checkNoEntry();
        return nullptr;
    }
    
    virtual FRayTracingSceneRHIRef RHICreateRayTracingScene(FRayTracingSceneInitializer Initializer)
    {
        checkNoEntry();
        return nullptr;
    }
 
    virtual FRayTracingShaderRHIRef RHICreateRayTracingShader(TArrayView<const uint8> Code, const FSHAHash& Hash, EShaderFrequency ShaderFrequency)
    {
        checkNoEntry();
        return nullptr;
    }
 
    virtual FRayTracingPipelineStateRHIRef RHICreateRayTracingPipelineState(const FRayTracingPipelineStateInitializer& Initializer)
    {
        checkNoEntry();
        return nullptr;
    }
 
    virtual FShaderBindingTableRHIRef RHICreateShaderBindingTable(FRHICommandListBase& RHICmdList, const FRayTracingShaderBindingTableInitializer& Initializer)
    {
        checkNoEntry();
        return nullptr;
    }
 
#if !UE_BUILD_SHIPPING
    virtual void RHISerializeAccelerationStructure(FRHICommandListImmediate& RHICmdList, FRHIRayTracingScene* Scene, const TCHAR* Path)
    {
        checkNoEntry();
    }
#endif
 
    virtual FShaderBundleRHIRef RHICreateShaderBundle(const FShaderBundleCreateInfo& CreateInfo)
    {
        checkNoEntry();
        return nullptr;
    }
 
protected:
    TArray<uint32> PixelFormatBlockBytes;
    friend class FValidationRHI;
};
 
extern RHI_API FDynamicRHI* GDynamicRHI;
 
// Dynamic RHI for RHIs that do not support real Graphics/Compute Pipelines.
class FDynamicRHIPSOFallback : public FDynamicRHI
{
public:
    virtual FGraphicsPipelineStateRHIRef RHICreateGraphicsPipelineState(const FGraphicsPipelineStateInitializer& Initializer) override
    {
        return new FRHIGraphicsPipelineStateFallBack(Initializer);
    }
 
    virtual FComputePipelineStateRHIRef RHICreateComputePipelineState(const FComputePipelineStateInitializer& Initializer) override
    {
        return new FRHIComputePipelineStateFallback(Initializer.ComputeShader);
    }
};
 
inline ERHIInterfaceType RHIGetInterfaceType()
{
    return GDynamicRHI->GetInterfaceType();
}
 
template<typename TRHI>
inline TRHI* CastDynamicRHI(FDynamicRHI* InDynamicRHI)
{
    return static_cast<TRHI*>(InDynamicRHI->GetNonValidationRHI());
}
 
template<typename TRHI>
inline TRHI* GetDynamicRHI()
{
    return CastDynamicRHI<TRHI>(GDynamicRHI);
}
 
inline FPixelShaderRHIRef RHICreatePixelShader(TArrayView<const uint8> Code, const FSHAHash& Hash)
{
    LLM_SCOPE(ELLMTag::Shaders);
    return GDynamicRHI->RHICreatePixelShader(Code, Hash);
}
 
inline FVertexShaderRHIRef RHICreateVertexShader(TArrayView<const uint8> Code, const FSHAHash& Hash)
{
    LLM_SCOPE(ELLMTag::Shaders);
    return GDynamicRHI->RHICreateVertexShader(Code, Hash);
}
 
inline FMeshShaderRHIRef RHICreateMeshShader(TArrayView<const uint8> Code, const FSHAHash& Hash)
{
    LLM_SCOPE(ELLMTag::Shaders);
    return GDynamicRHI->RHICreateMeshShader(Code, Hash);
}
 
inline FAmplificationShaderRHIRef RHICreateAmplificationShader(TArrayView<const uint8> Code, const FSHAHash& Hash)
{
    LLM_SCOPE(ELLMTag::Shaders);
    return GDynamicRHI->RHICreateAmplificationShader(Code, Hash);
}
 
inline FGeometryShaderRHIRef RHICreateGeometryShader(TArrayView<const uint8> Code, const FSHAHash& Hash)
{
    LLM_SCOPE(ELLMTag::Shaders);
    return GDynamicRHI->RHICreateGeometryShader(Code, Hash);
}
 
inline FComputeShaderRHIRef RHICreateComputeShader(TArrayView<const uint8> Code, const FSHAHash& Hash)
{
    LLM_SCOPE(ELLMTag::Shaders);
    return GDynamicRHI->RHICreateComputeShader(Code, Hash);
}
 
inline FWorkGraphShaderRHIRef RHICreateWorkGraphShader(TArrayView<const uint8> Code, const FSHAHash& Hash, EShaderFrequency ShaderFrequency)
{
    LLM_SCOPE(ELLMTag::Shaders);
    return GDynamicRHI->RHICreateWorkGraphShader(Code, Hash, ShaderFrequency);
}
 
inline FGPUFenceRHIRef RHICreateGPUFence(const FName& Name)
{
    return GDynamicRHI->RHICreateGPUFence(Name);
}
 
inline FStagingBufferRHIRef RHICreateStagingBuffer()
{
    return GDynamicRHI->RHICreateStagingBuffer();
}
 
inline FSamplerStateRHIRef RHICreateSamplerState(const FSamplerStateInitializerRHI& Initializer)
{
    LLM_SCOPE_BYNAME(TEXT("RHIMisc/CreateSamplerState"));
    return GDynamicRHI->RHICreateSamplerState(Initializer);
}
 
inline FRasterizerStateRHIRef RHICreateRasterizerState(const FRasterizerStateInitializerRHI& Initializer)
{
    LLM_SCOPE_BYNAME(TEXT("RHIMisc/CreateRasterizerState"));
    return GDynamicRHI->RHICreateRasterizerState(Initializer);
}
 
inline FDepthStencilStateRHIRef RHICreateDepthStencilState(const FDepthStencilStateInitializerRHI& Initializer)
{
    LLM_SCOPE_BYNAME(TEXT("RHIMisc/CreateDepthStencilState"));
    return GDynamicRHI->RHICreateDepthStencilState(Initializer);
}
 
inline FBlendStateRHIRef RHICreateBlendState(const FBlendStateInitializerRHI& Initializer)
{
    LLM_SCOPE_BYNAME(TEXT("RHIMisc/CreateBlendState"));
    return GDynamicRHI->RHICreateBlendState(Initializer);
}
 
inline FBoundShaderStateRHIRef RHICreateBoundShaderState(FRHIVertexDeclaration* VertexDeclaration, FRHIVertexShader* VertexShader, FRHIPixelShader* PixelShader, FRHIGeometryShader* GeometryShader)
{
    LLM_SCOPE(ELLMTag::Shaders);
    return GDynamicRHI->RHICreateBoundShaderState(VertexDeclaration, VertexShader, PixelShader, GeometryShader);
}
 
#if PLATFORM_SUPPORTS_MESH_SHADERS && PLATFORM_USE_FALLBACK_PSO
inline FBoundShaderStateRHIRef RHICreateBoundShaderState(FRHIAmplificationShader* AmplificationShader, FRHIMeshShader* MeshShader, FRHIPixelShader* PixelShader)
{
    LLM_SCOPE(ELLMTag::Shaders);
    return GDynamicRHI->RHICreateBoundShaderState(AmplificationShader, MeshShader, PixelShader);
}
#endif
 
inline FGraphicsPipelineStateRHIRef RHICreateGraphicsPipelineState(const FGraphicsPipelineStateInitializer& Initializer)
{
    LLM_SCOPE(ELLMTag::Shaders);
    return GDynamicRHI->RHICreateGraphicsPipelineState(Initializer);
}
 
inline FVertexDeclarationRHIRef RHICreateVertexDeclaration(const FVertexDeclarationElementList& Elements)
{
    return GDynamicRHI->RHICreateVertexDeclaration(Elements);
}
 
UE_DEPRECATED(5.6, "Creating a compute pipeline state with a pointer to a FRHIComputeShader is deprecated, please pass a FComputePipelineStateInitializer instead.")
inline FComputePipelineStateRHIRef RHICreateComputePipelineState(FRHIComputeShader* ComputeShader)
{
    FComputePipelineStateInitializer Initializer = { ComputeShader, 0 };
    return GDynamicRHI->RHICreateComputePipelineState(Initializer);
}
 
inline FComputePipelineStateRHIRef RHICreateComputePipelineState(const FComputePipelineStateInitializer& Initializer)
{
    LLM_SCOPE(ELLMTag::Shaders);
    return GDynamicRHI->RHICreateComputePipelineState(Initializer);
}
 
inline TRefCountPtr<FRHIWorkGraphPipelineState> RHICreateWorkGraphPipelineState(const FWorkGraphPipelineStateInitializer& Initializer)
{
    LLM_SCOPE(ELLMTag::Shaders);
    return GDynamicRHI->RHICreateWorkGraphPipelineState(Initializer);
}
 
inline FRenderQueryRHIRef RHICreateRenderQuery(ERenderQueryType QueryType)
{
    return GDynamicRHI->RHICreateRenderQuery(QueryType);
}
 
inline TRefCountPtr<FRHIRayTracingPipelineState> RHICreateRayTracingPipelineState(const FRayTracingPipelineStateInitializer& Initializer)
{
    return GDynamicRHI->RHICreateRayTracingPipelineState(Initializer);
}
 
inline FUniformBufferLayoutRHIRef RHICreateUniformBufferLayout(const FRHIUniformBufferLayoutInitializer& Initializer)
{
    LLM_SCOPE_BYNAME(TEXT("RHIMisc/CreateUniformBufferLayout"));
    return new FRHIUniformBufferLayout(Initializer);
}
 
inline FUniformBufferRHIRef RHICreateUniformBuffer(const void* Contents, const FRHIUniformBufferLayout* Layout, EUniformBufferUsage Usage, EUniformBufferValidation Validation = EUniformBufferValidation::ValidateResources)
{
    LLM_SCOPE_BYNAME(TEXT("RHIMisc/CreateUniformBuffer"));
    return GDynamicRHI->RHICreateUniformBuffer(Contents, Layout, Usage, Validation);
}
 
inline FRHICalcTextureSizeResult RHICalcTexturePlatformSize(FRHITextureDesc const& Desc, uint32 FirstMipIndex = 0)
{
    if ( ! Desc.IsValid() )
    {
        // Invalid texture desc; return zero to indicate failure
        FRHICalcTextureSizeResult ZeroResult{};
        return ZeroResult;
    }
 
    return GDynamicRHI->RHICalcTexturePlatformSize(Desc, FirstMipIndex);
}
 
inline uint64 RHIGetMinimumAlignmentForBufferBackedSRV(EPixelFormat Format)
{
    return GDynamicRHI->RHIGetMinimumAlignmentForBufferBackedSRV(Format);
}
 
inline void RHIGetTextureMemoryStats(FTextureMemoryStats& OutStats)
{
    GDynamicRHI->RHIGetTextureMemoryStats(OutStats);
}
 
inline uint32 RHIComputeMemorySize(FRHITexture* TextureRHI)
{
    return GDynamicRHI->RHIComputeMemorySize(TextureRHI);
}
 
inline bool RHIGetRenderQueryResult(FRHIRenderQuery* RenderQuery, uint64& OutResult, bool bWait, uint32 GPUIndex = INDEX_NONE)
{
    return GDynamicRHI->RHIGetRenderQueryResult(RenderQuery, OutResult, bWait, GPUIndex);
}
 
inline uint32 RHIGetViewportNextPresentGPUIndex(FRHIViewport* Viewport)
{
    return GDynamicRHI->RHIGetViewportNextPresentGPUIndex(Viewport);
}
 
inline FTextureRHIRef RHIGetViewportBackBuffer(FRHIViewport* Viewport)
{
    return GDynamicRHI->RHIGetViewportBackBuffer(Viewport);
}
 
inline FUnorderedAccessViewRHIRef RHIGetViewportBackBufferUAV(FRHIViewport* Viewport)
{
    return GDynamicRHI->RHIGetViewportBackBufferUAV(Viewport);
}
 
UE_DEPRECATED(5.7, "RHIGetHTilePlatformConfig(uint32,uint32) has been deprecated. Please use RHIGetHTilePlatformConfig(const FRHITextureDesc&) instead.")
inline uint32 RHIGetHTilePlatformConfig(uint32 DepthWidth, uint32 DepthHeight)
{
    return GDynamicRHI->RHIGetHTilePlatformConfig(DepthWidth, DepthHeight);
}
 
inline uint32 RHIGetHTilePlatformConfig(const FRHITextureDesc& DepthDesc)
{
    return GDynamicRHI->RHIGetHTilePlatformConfig(DepthDesc);
}
 
UE_DEPRECATED(5.7, "RHIAdvanceFrameForGetViewportBackBuffer is deprecated. This happens automatically when RHIEndDrawingViewport is called. Remove calls to this function.")
inline void RHIAdvanceFrameForGetViewportBackBuffer(FRHIViewport* Viewport)
{
    return GDynamicRHI->RHIAdvanceFrameForGetViewportBackBuffer(Viewport, true);
}
 
RHI_API uint32 RHIGetGPUFrameCycles(uint32 GPUIndex = 0);
 
inline FViewportRHIRef RHICreateViewport(void* WindowHandle, uint32 SizeX, uint32 SizeY, bool bIsFullscreen, EPixelFormat PreferredPixelFormat)
{
    LLM_SCOPE(ELLMTag::RenderTargets);
    return GDynamicRHI->RHICreateViewport(WindowHandle, SizeX, SizeY, bIsFullscreen, PreferredPixelFormat);
}
 
inline void RHIResizeViewport(FRHIViewport* Viewport, uint32 SizeX, uint32 SizeY, bool bIsFullscreen, EPixelFormat PreferredPixelFormat)
{
    LLM_SCOPE(ELLMTag::RenderTargets);
    GDynamicRHI->RHIResizeViewport(Viewport, SizeX, SizeY, bIsFullscreen, PreferredPixelFormat);
}
 
// UE_DEPRECATED(5.5, "This method is no longer used.")
inline EColorSpaceAndEOTF RHIGetColorSpace(FRHIViewport* Viewport)
{
    return EColorSpaceAndEOTF::ERec709_sRGB;
}
 
inline void RHICheckViewportHDRStatus(FRHIViewport* Viewport)
{
    GDynamicRHI->RHICheckViewportHDRStatus(Viewport);
}
 
inline void RHIHandleDisplayChange()
{
    GDynamicRHI->RHIHandleDisplayChange();
}
 
inline void RHITick(float DeltaTime)
{
    LLM_SCOPE_BYNAME(TEXT("RHIMisc/RHITick"));
    GDynamicRHI->RHITick(DeltaTime);
}
 
inline void RHIBeginSuspendRendering()
{
    GDynamicRHI->RHIBeginSuspendRendering();
}
 
inline void RHISuspendRendering()
{
    GDynamicRHI->RHISuspendRendering();
}
 
inline void RHIResumeRendering()
{
    GDynamicRHI->RHIResumeRendering();
}
 
inline bool RHIGetAvailableResolutions(FScreenResolutionArray& Resolutions, bool bIgnoreRefreshRate)
{
    return GDynamicRHI->RHIGetAvailableResolutions(Resolutions, bIgnoreRefreshRate);
}
 
inline void RHIGetSupportedResolution(uint32& Width, uint32& Height)
{
    GDynamicRHI->RHIGetSupportedResolution(Width, Height);
}
 
inline class IRHICommandContext* RHIGetDefaultContext()
{
    return GDynamicRHI->RHIGetDefaultContext();
}
 
RHI_API FRenderQueryPoolRHIRef RHICreateRenderQueryPool(ERenderQueryType QueryType, uint32 NumQueries = UINT32_MAX);
 
RHI_API FRHITransition* RHICreateTransition(const FRHITransitionCreateInfo& CreateInfo);
 
inline void RHIReleaseTransition(FRHITransition* Transition)
{
    GDynamicRHI->RHIReleaseTransition(Transition);
}
 
inline IRHITransientResourceAllocator* RHICreateTransientResourceAllocator()
{
    return GDynamicRHI->RHICreateTransientResourceAllocator();
}
 
inline void RHIGetDisplaysInformation(FDisplayInformationArray& OutDisplayInformation)
{
    GDynamicRHI->RHIGetDisplaysInformation(OutDisplayInformation);
}
 
inline uint64 RHIComputeStatePrecachePSOHash(const FGraphicsPipelineStateInitializer& Initializer)
{
    return GDynamicRHI->RHIComputeStatePrecachePSOHash(Initializer);
}
 
inline uint64 RHIComputePrecachePSOHash(const FGraphicsPipelineStateInitializer& Initializer)
{
    return GDynamicRHI->RHIComputePrecachePSOHash(Initializer);
}
 
inline bool RHIMatchPrecachePSOInitializers(const FGraphicsPipelineStateInitializer& LHS, const FGraphicsPipelineStateInitializer& RHS)
{
    return GDynamicRHI->RHIMatchPrecachePSOInitializers(LHS, RHS);
}
 
inline FRayTracingAccelerationStructureSize RHICalcRayTracingSceneSize(const FRayTracingSceneInitializer& Initializer)
{
    return GDynamicRHI->RHICalcRayTracingSceneSize(Initializer);
}
 
inline FRayTracingSceneRHIRef RHICreateRayTracingScene(FRayTracingSceneInitializer Initializer)
{
    return GDynamicRHI->RHICreateRayTracingScene(MoveTemp(Initializer));
}
 
inline FRayTracingShaderRHIRef RHICreateRayTracingShader(TArrayView<const uint8> Code, const FSHAHash& Hash, EShaderFrequency ShaderFrequency)
{
    return GDynamicRHI->RHICreateRayTracingShader(Code, Hash, ShaderFrequency);
}
 
inline FShaderBundleRHIRef RHICreateShaderBundle(const FShaderBundleCreateInfo& CreateInfo)
{
    return GDynamicRHI->RHICreateShaderBundle(CreateInfo);
}
 
inline void appDefragmentTexturePool() {}
 
inline bool appIsPoolTexture(FRHITexture* TextureRHI) { return false; }
 
inline void appDumpTextureMemoryStats(const TCHAR* /*Message*/) {}
 
struct FRHIGPUUsageFractions
{
    // Fraction on how much much the GPU clocks has been scaled down by driver for energy savings.
    float ClockScaling = 1.0f;
 
    // Fraction of GPU resource dedicated for our own process at current clock scaling.
    float CurrentProcessMHz = 0.0f;
 
    // Fraction of GPU resource dedicated for other processes at current clock scaling.
    float ExternalProcessesMHz = 0.0f;
 
    // Amount of VRAM used by the process in bytes.
    uint64_t CurrentProcessMemoryUsage = 0;
 
    // Amount of VRAM used by other processes in bytes.
    uint64_t ExternalProcessMemoryUsage = 0;
 
    // Remaining fraction of GPU resource that is idle.
    inline float GetUnused()
    {
        return FMath::Clamp(1.0f - CurrentProcessMHz - ExternalProcessesMHz, 0.0f, 1.0f);
    }
};
 
typedef FRHIGPUUsageFractions (*RHIGetGPUUsageType)(uint32);
extern RHI_API RHIGetGPUUsageType RHIGetGPUUsage;
 
class IDynamicRHIModule : public IModuleInterface
{
public:
 
    virtual bool IsSupported() = 0;
 
    virtual bool IsSupported(ERHIFeatureLevel::Type RequestedFeatureLevel) { return IsSupported(); }
 
    virtual FDynamicRHI* CreateRHI(ERHIFeatureLevel::Type RequestedFeatureLevel = ERHIFeatureLevel::Num) = 0;
};
 
FDynamicRHI* PlatformCreateDynamicRHI();
 
// Name of the RHI module that will be created when PlatformCreateDynamicRHI is called
// NOTE: This function is very slow when called before RHIInit
extern RHI_API const TCHAR* GetSelectedDynamicRHIModuleName(bool bCleanup = true);
 
extern RHI_API bool GDynamicRHIFailedToInitializeAdvancedPlatform;
 
//
// Helper for acquiring and releasing thread ownership of the RHI within a scope.
// For private use by the RHI and render thread management code only.
//
struct FScopedRHIThreadOwnership
{
    bool const bCondition;
 
    FScopedRHIThreadOwnership(bool bCondition)
        : bCondition(bCondition)
    {
        if (bCondition)
        {
            SCOPED_NAMED_EVENT(RHIAcquireThreadOwnership, FColor::Red);
            GDynamicRHI->RHIAcquireThreadOwnership();
        }
    }
 
    ~FScopedRHIThreadOwnership()
    {
        if (bCondition)
        {
            SCOPED_NAMED_EVENT(RHIReleaseThreadOwnership, FColor::Red);
            GDynamicRHI->RHIReleaseThreadOwnership();
        }
    }
};