VirtualTextureUploadCache.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "PixelFormat.h"
#include "RendererInterface.h"
#include "RenderResource.h"
 
class FRDGTexture;
class FRHITexture;
class FRHIBuffer;
struct FVTProduceTargetLayer;
 
struct FVTUploadTileHandle
{
    explicit FVTUploadTileHandle(uint32 InIndex = ~0u) 
        : Index(InIndex) 
    {}
 
    inline bool IsValid() const { return Index != ~0u; }
 
    uint32 Index;
};
 
struct FVTUploadTileBuffer
{
    void* Memory = nullptr;
    uint32 MemorySize = 0u;
    uint32 Stride = 0u;
};
 
struct FVTUploadTileBufferExt
{
    FRHIBuffer* RHIBuffer;
    void* BufferMemory = nullptr;
    uint32 BufferOffset = 0u;
    uint32 Stride = 0u;
};
 
enum class EVTUploadType
{
    StagingTexture,
    StagingCopy,
    PersistentBuffer
};
 
class FVTUploadTileAllocator
{
public:
    uint32 Allocate(FRHICommandListBase& RHICmdList, EVTUploadType InUploadType, EPixelFormat InFormat, uint32 InTileSize);
    void Free(FRHICommandListBase& RHICmdList, uint32 InHandle);
 
    FVTUploadTileBuffer GetBufferFromHandle(uint32 InHandle) const;
    FVTUploadTileBufferExt GetBufferFromHandleExt(uint32 InHandle) const;
    
    uint64 TotalAllocatedBytes() const { return NumAllocatedBytes; }
 
private:
    UE::FMutex Mutex;
 
    union FHandle
    {
        uint32 PackedValue = 0u;
        struct
        {
            uint32 FormatIndex : 5;
            uint32 StagingBufferIndex : 14;
            uint32 TileIndex : 13;
        };
 
        static const uint32 MaxFormats = 1 << 5;
        static const uint32 MaxStagingBuffers = 1 << 14;
        static const uint32 MaxTiles = 1 << 13;
    };
 
    struct FStagingBuffer
    {
        ~FStagingBuffer();
 
        void Init(FRHICommandListBase& RHICmdList, EVTUploadType InUploadType, uint32 InBufferStrideBytes, uint32 InTileSizeBytes);
        void Release(FRHICommandListBase* RHICmdList);
 
        TRefCountPtr<FRHIBuffer> RHIBuffer;
 
        void* Memory = nullptr;
        uint32 TileSize = 0u;
        uint32 TileSizeAligned = 0u;
        uint32 NumTiles = 0u;
        TArray<uint16> TileFreeList;
    };
 
    struct FSharedFormatBuffers
    {
        TArray<FStagingBuffer> StagingBuffers;
    };
 
    struct FSharedFormatDesc
    {
        uint32 BlockBytes = 0u;
        uint32 Stride = 0u;
        uint32 MemorySize = 0u;
    };
 
    TArray<FSharedFormatDesc> FormatDescs;
    TArray<FSharedFormatBuffers> FormatBuffers;
    uint64 NumAllocatedBytes = 0;
};
 
class FVirtualTextureUploadCache : public IVirtualTextureFinalizer, public FRenderResource
{
public:
    FVirtualTextureUploadCache();
 
    //~ Begin FRenderResource Interface.
    virtual void ReleaseRHI() override;
    //~ End FRenderResource Interface.
 
    FVTUploadTileHandle PrepareTileForUpload(FRHICommandListBase& RHICmdList, FVTUploadTileBuffer& OutBuffer, EPixelFormat InFormat, uint32 InTileSize);
    void SubmitTile(FRHICommandListBase& RHICmdList, const FVTUploadTileHandle& InHandle, const FVTProduceTargetLayer& Target, int InSkipBorderSize);
    void CancelTile(FRHICommandListBase& RHICmdList, const FVTUploadTileHandle& InHandle);
 
    //~ Begin IVirtualTextureFinalizer Interface.
    virtual void Finalize(FRDGBuilder& GraphBuilder) override;
    //~ End IVirtualTextureFinalizer Interface.
 
    void UpdateFreeList(FRHICommandListBase& RHICmdList, bool bForceFreeAll = false);
 
    uint32 IsInMemoryBudget() const;
 
private:
    int32 GetOrCreatePoolIndex(EPixelFormat InFormat, uint32 InTileSize);
 
    void FinalizeWithLegacyCopyTexture(FRDGBuilder& GraphBuilder);
    void FinalizeWithUpdateTexture(FRDGBuilder& GraphBuilder);
 
    struct FTileEntry
    {
        uint32 PoolIndex = 0;
        uint32 TileHandle = 0;
        IPooledRenderTarget* PooledRenderTarget = nullptr;
        FRDGTexture* Texture = nullptr;
        int32 SubmitDestX = 0;
        int32 SubmitDestY = 0;
        int32 SubmitSkipBorderSize = 0;
        uint32 FrameSubmitted = 0;
    };
 
    struct FStagingTexture
    {
        TRefCountPtr<FRHITexture> RHITexture;
        uint32 WidthInTiles = 0u;
        uint32 BatchCapacity = 0u;
        bool bIsCPUWritable;
    };
 
    struct FPoolEntry
    {
        EPixelFormat Format = PF_Unknown;
        uint32 TileSize = 0u;
 
        static const uint32 NUM_STAGING_TEXTURES = 3u;
        FStagingTexture StagingTexture[NUM_STAGING_TEXTURES];
        uint32 BatchTextureIndex = 0u;
 
        TArray<FTileEntry> PendingSubmit;
    };
 
    EVTUploadType UploadType;
    TArray<FPoolEntry> Pools;
    FVTUploadTileAllocator TileAllocator;
    TSparseArray<FTileEntry> PendingUpload;
    TSparseArray<FTileEntry> PendingRelease;
};