Texture.hpp

Go to the documentation of this file.

#pragma once
#include <Core/Container.hpp>
#include <Math/Math.hpp>
#include <RHICore/Resource.hpp>
#include "Serialization.hpp"
#include "TextureDDS.hpp"
using namespace Foundation;
using namespace RHI;
using namespace Core;
using namespace Math;
 
struct FTextureHeader
{
    uint32_t magic{DDS_MAGIC};
    DDS_HEADER header{};
    DDS_HEADER_DXT10 header10{};
 
    [[nodiscard]] bool IsValid() const { return magic == DDS_MAGIC && GetSize() != 0; }
    [[nodiscard]] uint32_t GetWidth() const { return header.width; }
    [[nodiscard]] uint32_t GetHeight() const { return header.height; }
    [[nodiscard]] uint32_t GetDepth() const;
    [[nodiscard]] RHITextureDimension GetDimension() const;
    [[nodiscard]] RHITextureDimension GetViewDimension() const;
    [[nodiscard]] uint32_t GetNumLayers() const
    {
        if (header.caps2 & DDS_CUBEMAP)
            return 6;
        if (header10.arraySize)
            return header10.arraySize;
        return 1;
    }
    [[nodiscard]] uint32_t GetNumMips() const { return header.mipMapCount > 0 ? header.mipMapCount : 1; }
    [[nodiscard]] RHIResourceFormat GetFormat() const;
    [[nodiscard]] uint32_t GetBlockSize() const;
    [[nodiscard]] uint32_t GetBpp() const;
    [[nodiscard]] static uint64_t CalculateTextureImageSize(uint32_t width, uint32_t height, uint32_t depth,
                                                            uint32_t mipLevels, uint32_t blockSize,
                                                            uint32_t blockDim);
    [[nodiscard]] uint32_t GetSize() const;
    [[nodiscard]] size_t GetSubresourceSize(uint32_t layer, uint32_t mip) const;
    [[nodiscard]] RHIExtent3D GetMipExtent(uint32_t mipLevel) const;
    [[nodiscard]] RHITextureDesc GetDesc() const;
};
 
struct FSerializedTexture : FTextureHeader
{
    Vector<FBlobRef> subresources;
 
    explicit FSerializedTexture(Allocator* alloc = GLOBAL_ALLOC)
        : subresources(alloc)
    {
    }
 
    [[nodiscard]] uint32_t GetSubresourceCount() const { return GetNumLayers() * GetNumMips(); }
 
    [[nodiscard]] uint32_t GetSubresourceIndex(uint32_t layer, uint32_t mip) const
    {
        CHECK_MSG(layer < GetNumLayers(), "Texture layer {} out of range {}", layer, GetNumLayers());
        CHECK_MSG(mip < GetNumMips(), "Texture mip {} out of range {}", mip, GetNumMips());
        return layer * GetNumMips() + mip;
    }
 
    [[nodiscard]] FBlobRef const& GetSubresourceBlob(uint32_t layer, uint32_t mip) const
    {
        uint32_t const index = GetSubresourceIndex(layer, mip);
        CHECK_MSG(index < subresources.size(), "Texture subresource {} missing from serialized texture", index);
        return subresources[index];
    }
 
    [[nodiscard]] bool IsValid() const
    {
        return FTextureHeader::IsValid() && subresources.size() == GetSubresourceCount() && !subresources.empty();
    }
};
 
struct FTexture : FTextureHeader
{
    mutable Vector<unsigned char> bytes;
 
    FTexture(Allocator* alloc);
    void Initialize(RHIResourceFormat format, RHITextureDimension dimension, uint32_t width, uint32_t height = 1,
                    uint32_t depth = 1, uint32_t mipCount = 1, uint32_t layerCount = 1);
    [[nodiscard]] bool IsValid() const { return FTextureHeader::IsValid() && bytes.size() == GetSize(); }
    // Get raw subresource slice that can be uploaded to the GPU directly
    [[nodiscard]] Span<unsigned char> GetSubresource(uint32_t mipLevel = 0, uint32_t arrayLayer = 0) const;
 
    void GenerateMips();
    FTexture EncodeBC7(Allocator* alloc = GLOBAL_ALLOC) const;
 
    [[nodiscard]] FSerializedTexture ToSerializedTexture(Allocator* alloc = GLOBAL_ALLOC) const
    {
        FSerializedTexture texture(alloc);
        texture.magic = magic;
        texture.header = header;
        texture.header10 = header10;
        return texture;
    }
};
 
void LoadDDS(FTexture& texture, StringView path);
void LoadRGBA8(FTexture& texture, StringView path, bool gamma = true);
void LoadRGBA8(FTexture& texture, Span<const unsigned char> data, bool gamma = true);
void LoadHDR(FTexture& texture, StringView path);
void SaveHDR(const float* data, int width, int height, StringView path);
void SavePNG(const unsigned char* data, int width, int height, StringView path);
/* -- Serialization -- */
template <>
inline void FSerialize(FWriter& w, FSerializedTexture const& obj)
{
    FTextureHeader const& header = obj;
    FSerialize(w, header.magic);
    FSerialize(w, header.header);
    FSerialize(w, header.header10);
    FSerialize(w, obj.subresources);
}
 
template <>
inline void FDeserialize(FReader& r, FSerializedTexture& obj)
{
    FTextureHeader& header = obj;
    FDeserialize(r, header.magic);
    FDeserialize(r, header.header);
    FDeserialize(r, header.header10);
    FDeserialize(r, obj.subresources);
}
 
template <>
inline void FSerialize(FWriter& w, FTexture const& obj)
{
    FSerialize(w, obj.magic);
    FSerialize(w, obj.header);
    if (obj.header.ddspf.fourCC == DDSPF_DX10.fourCC)
        FSerialize(w, obj.header10);
    CHECK(w.write(obj.bytes.data(), obj.bytes.size()) == obj.bytes.size());
}
template <>
inline void FDeserialize(FReader& r, FTexture& obj)
{
    FDeserialize(r, obj.magic);
    CHECK(obj.magic == DDS_MAGIC);
    FDeserialize(r, obj.header);
    if (obj.header.ddspf.fourCC == DDSPF_DX10.fourCC)
        FDeserialize(r, obj.header10);
    obj.bytes.resize(obj.GetSize());
    CHECK(r.read(obj.bytes.data(), obj.bytes.size()) == obj.bytes.size());
}