VirtualTextureBuiltData.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
#include "CoreMinimal.h"
#include "PixelFormat.h"
#include "Serialization/BulkData.h"
#include "Serialization/DerivedData.h"
#include "Engine/Texture.h"
#include "HAL/ThreadSafeBool.h"
 
// This header contains the all the structs and classes pertaining to the
// virtual texture on-disc file format.
 
#define VIRTUALTEXTURE_DATA_MAXLAYERS 8u
 
#define VIRTUALTEXTURE_DATA_MAXMIPS 16u
 
enum class EVirtualTextureCodec : uint8
{
    Black,          //Special case codec, always outputs black pixels 0,0,0,0
    OpaqueBlack,    //Special case codec, always outputs opaque black pixels 0,0,0,255
    White,          //Special case codec, always outputs white pixels 255,255,255,255
    Flat,           //Special case codec, always outputs 128,125,255,255 (flat normal map)
    RawGPU,         //Uncompressed data in an GPU-ready format (e.g R8G8B8A8, BC7, ASTC, ...)
    ZippedGPU_DEPRECATED,       //Same as RawGPU but with the data zipped
    Crunch_DEPRECATED,          //Use the Crunch library to compress data
    Max,            // Add new codecs before this entry
};
 
struct FVirtualTextureChunkHeader
{
    uint32 Unused; // Chunk header is currently not used, but keeping in place for future expansion
};
 
struct FVirtualTextureDataChunk
{
    UE::FDerivedData DerivedData;
    FByteBulkData BulkData;
    FSHAHash BulkDataHash;
    uint32 SizeInBytes;
    uint32 CodecPayloadSize;
    uint32 CodecPayloadOffset[VIRTUALTEXTURE_DATA_MAXLAYERS];
    EVirtualTextureCodec CodecType[VIRTUALTEXTURE_DATA_MAXLAYERS];
 
    inline FVirtualTextureDataChunk()
        : SizeInBytes(0u)
        , CodecPayloadSize(0u)
    {
        FMemory::Memzero(CodecPayloadOffset);
        FMemory::Memzero(CodecType);
    }
 
    inline uint32 GetMemoryFootprint() const
    {
        // Don't include editor-only data
        static constexpr uint32 MemoryFootprint = uint32(sizeof(BulkData) + sizeof(SizeInBytes) + sizeof(CodecPayloadOffset) + sizeof(CodecPayloadSize) + sizeof(CodecType));
        return MemoryFootprint;
    }
 
#if WITH_EDITORONLY_DATA
    FString DerivedDataKey;
 
    // Cached short key for VT DDC cache (not serialized)
    FString ShortDerivedDataKey;
    bool ShortenKey(const FString& CacheKey, FString& Result);
    FThreadSafeBool bFileAvailableInVTDDCDache;
    bool bCorruptDataLoadedFromDDC = false;
    int64 StoreInDerivedDataCache(FStringView InKey, FStringView InName, bool bReplaceExisting);
#endif // WITH_EDITORONLY_DATA
};
 
 
struct FVirtualTextureTileOffsetData
{
#if WITH_EDITOR
    /* Call at start of building the data before any calls to AddTile(). The entire area is initialized as empty. */
    void Init(uint32 InWidth, uint32 InHeight);
    /* Call to mark a tile as non-empty. */
    void AddTile(uint32 InAddress);
    /* Call after all calls to AddTile() to build the final blocks and offsets. */
    void Finalize();
#endif // WITH_EDITOR
 
    uint32 GetTileOffset(uint32 InAddress) const;
 
    friend FArchive& operator<<(FArchive& Ar, FVirtualTextureTileOffsetData& TileOffsetData)
    {
        Ar << TileOffsetData.Width;
        Ar << TileOffsetData.Height;
        Ar << TileOffsetData.MaxAddress;
        Ar << TileOffsetData.Addresses;
        Ar << TileOffsetData.Offsets;
        return Ar;
    }
 
    uint32 Width = 0;
    uint32 Height = 0;
    uint32 MaxAddress = 0;
    TArray<uint32> Addresses;
    TArray<uint32> Offsets;
    
#if WITH_EDITOR
    TBitArray<> TileStates;
#endif
};
 
 
struct FVirtualTextureBuiltData
{
    uint32 NumLayers;
    uint32 NumMips;
    uint32 Width; // Width of the texture in pixels. Note the physical width may be larger due to tiling
    uint32 Height; // Height of the texture in pixels. Note the physical height may be larger due to tiling
    uint32 WidthInBlocks; // Number of UDIM blocks that make up the texture, used to compute UV scaling factor
    uint32 HeightInBlocks;
    uint32 TileSize;  // Tile size excluding borders
    uint32 TileBorderSize; // A BorderSize pixel border will be added around all tiles
 
    TEnumAsByte<EPixelFormat> LayerTypes[VIRTUALTEXTURE_DATA_MAXLAYERS];
 
    FLinearColor LayerFallbackColors[VIRTUALTEXTURE_DATA_MAXLAYERS];
 
    TArray<FVirtualTextureDataChunk> Chunks;
 
    TArray<uint32> TileDataOffsetPerLayer;
 
    TArray<uint32> ChunkIndexPerMip;
 
    TArray<uint32> BaseOffsetPerMip;
 
    TArray<FVirtualTextureTileOffsetData> TileOffsetData;
 
    TArray<uint32> TileIndexPerChunk;
 
    TArray<uint32> TileIndexPerMip;
 
    TArray<uint32> TileOffsetInChunk;
 
    FVirtualTextureBuiltData()
        : NumLayers(0u)
        , NumMips(0u)
        , Width(0u)
        , Height(0u)
        , WidthInBlocks(0u)
        , HeightInBlocks(0u)
        , TileSize(0u)
        , TileBorderSize(0u)
    {
        FMemory::Memzero(LayerTypes);
        FMemory::Memzero(LayerFallbackColors);
    }
 
    inline bool IsInitialized() const { return TileSize != 0u; }
    inline uint32 GetNumMips() const { return NumMips; }
    inline uint32 GetNumLayers() const { return NumLayers; }
    inline uint32 GetPhysicalTileSize() const { return TileSize + TileBorderSize * 2u; }
    inline uint32 GetWidthInTiles() const { return FMath::DivideAndRoundUp(Width, TileSize); }
    inline uint32 GetHeightInTiles() const { return FMath::DivideAndRoundUp(Height, TileSize); }
 
    uint32 GetMemoryFootprint() const;
    uint32 GetTileMemoryFootprint() const;
    uint64 GetDiskMemoryFootprint() const;
    uint32 GetNumTileHeaders() const;
    
    void Serialize(FArchive& Ar, UObject* Owner, int32 FirstMipToSerialize);
 
    bool IsValidAddress(uint32 vLevel, uint32 vAddress);
 
    int32 GetChunkIndex(uint8 vLevel) const;
 
    uint32 GetTileOffset(uint32 vLevel, uint32 vAddress, uint32 LayerIndex) const;
 
    bool ValidateData(FStringView const& InDDCDebugContext, bool bValidateCompression) const;
 
private:
    bool IsLegacyData() const;
    uint32 GetTileIndex_Legacy(uint8 vLevel, uint32 vAddress) const;
    uint32 GetTileOffset_Legacy(uint32 ChunkIndex, uint32 TileIndex) const;
};