texture_format.h

#pragma once
 
#include <algorithm>
#include <cstdint>
 
#include "core/reflect.h"
 
namespace Vkm::Engine {
 
// Every enum TextureParams holds is persisted by value in cooked textures: append only. A reorder
// silently re-reads cooked textures as another format; writeTexture in io/asset/asset_cook.cpp pins
// every enumerator.

enum class TextureInternalFormat : uint8_t {
    R8,
    RG8,
    RGB8,
    RGBA8,
    SRGB8,
    SRGBA8,
    RGBA16F,
    RGBA32F,
    BC4R,       
    BC5RG,      
    BC7RGBA,    
    BC7SRGBA    
};

enum class TexturePixelFormat : uint8_t {
    R,
    RG,
    RGB,
    RGBA
};

enum class TexturePixelType : uint8_t {
    UnsignedByte,
    Float,
    HalfFloat
};

enum class TextureWrapMode : uint8_t {
    Repeat,
    MirroredRepeat,
    ClampToEdge,
    ClampToBorder
};

enum class TextureFilterOverride : uint8_t {
    None,
    Nearest
};

struct TextureParams {
    uint32_t width  = 0;
    uint32_t height = 0;
 
    TextureInternalFormat internalFormat = TextureInternalFormat::RGBA8;
    TexturePixelFormat    format         = TexturePixelFormat::RGBA;
    TexturePixelType      type           = TexturePixelType::UnsignedByte;
 
    TextureWrapMode wrapS = TextureWrapMode::ClampToEdge;
    TextureWrapMode wrapT = TextureWrapMode::ClampToEdge;
 
    TextureFilterOverride filterOverride = TextureFilterOverride::None;
 
    bool generateMipmaps = true;

    uint32_t mipLevels = 1;
};

enum class TextureUsage : uint8_t {
    Color,   
    Data,    
    Normal,  
    Count
};

inline int decodeChannels(int fileChannels, TextureUsage usage) {
    if (usage == TextureUsage::Normal) return 2;
    if (fileChannels == 2 || (fileChannels == 1 && usage == TextureUsage::Color)) return 4;
    return fileChannels;
}

inline TextureInternalFormat inferInternalFormat(int channels, TextureUsage usage) {
    if (usage == TextureUsage::Color) {
        return (channels == 3) ? TextureInternalFormat::SRGB8 : TextureInternalFormat::SRGBA8;
    }
    if (usage == TextureUsage::Normal) return TextureInternalFormat::RG8;
    switch (channels) {
        case 1:  return TextureInternalFormat::R8;
        case 3:  return TextureInternalFormat::RGB8;
        default: return TextureInternalFormat::RGBA8;
    }
}

inline bool isSrgbFormat(TextureInternalFormat format) {
    return format == TextureInternalFormat::SRGB8 || format == TextureInternalFormat::SRGBA8
        || format == TextureInternalFormat::BC7SRGBA;
}

inline TextureUsage textureUsageOf(TextureInternalFormat format) {
    if (isSrgbFormat(format)) return TextureUsage::Color;
    if (format == TextureInternalFormat::RG8 || format == TextureInternalFormat::BC5RG) {
        return TextureUsage::Normal;
    }
    return TextureUsage::Data;
}

inline uint64_t blockBytes(TextureInternalFormat format) {
    switch (format) {
        case TextureInternalFormat::BC4R:     return 8;
        case TextureInternalFormat::BC5RG:
        case TextureInternalFormat::BC7RGBA:
        case TextureInternalFormat::BC7SRGBA: return 16;
        case TextureInternalFormat::R8:
        case TextureInternalFormat::RG8:
        case TextureInternalFormat::RGB8:
        case TextureInternalFormat::RGBA8:
        case TextureInternalFormat::SRGB8:
        case TextureInternalFormat::SRGBA8:
        case TextureInternalFormat::RGBA16F:
        case TextureInternalFormat::RGBA32F:  return 0;
    }
    return 0;
}

inline bool isCompressedFormat(TextureInternalFormat format) {
    return blockBytes(format) != 0;
}

inline uint32_t channelCount(TexturePixelFormat format) {
    switch (format) {
        case TexturePixelFormat::R:    return 1;
        case TexturePixelFormat::RG:   return 2;
        case TexturePixelFormat::RGB:  return 3;
        case TexturePixelFormat::RGBA: return 4;
    }
    return 4;
}

inline uint64_t bytesPerTexel(TexturePixelFormat format, TexturePixelType type) {
    const uint64_t channels = channelCount(format);
    uint64_t componentBytes = 1;
    switch (type) {
        case TexturePixelType::UnsignedByte: componentBytes = 1; break;
        case TexturePixelType::HalfFloat:    componentBytes = 2; break;
        case TexturePixelType::Float:        componentBytes = 4; break;
    }
    return channels * componentBytes;
}

inline uint32_t mipChainLength(uint32_t width, uint32_t height) {
    if (width == 0 || height == 0) return 0;
    uint32_t extent = std::max(width, height);
    uint32_t levels = 1;
    while (extent > 1) {
        extent >>= 1;
        ++levels;
    }
    return levels;
}

inline uint32_t mipExtent(uint32_t extent, uint32_t level) {
    return (level >= 32) ? 1u : std::max(extent >> level, 1u);
}

inline uint64_t textureUnitBytes(const TextureParams& params) {
    return isCompressedFormat(params.internalFormat)
        ? blockBytes(params.internalFormat)
        : bytesPerTexel(params.format, params.type);
}

inline uint64_t textureLevelUnits(const TextureParams& params, uint32_t level) {
    const uint64_t width  = mipExtent(params.width, level);
    const uint64_t height = mipExtent(params.height, level);
    if (!isCompressedFormat(params.internalFormat)) return width * height;
    return ((width + 3) / 4) * ((height + 3) / 4);
}

inline uint64_t textureLevelBytes(const TextureParams& params, uint32_t level) {
    return textureLevelUnits(params, level) * textureUnitBytes(params);
}

inline bool buildsMipsAtUpload(const TextureParams& params) {
    return params.generateMipmaps && params.mipLevels == 1 && !isCompressedFormat(params.internalFormat);
}

inline bool isMipmapped(const TextureParams& params) {
    return params.mipLevels > 1 || buildsMipsAtUpload(params);
}

inline TexturePixelFormat inferFormat(int channels) {
    switch (channels) {
        case 1:  return TexturePixelFormat::R;
        case 2:  return TexturePixelFormat::RG;
        case 3:  return TexturePixelFormat::RGB;
        case 4:
        default: return TexturePixelFormat::RGBA;
    }
}
 
} // namespace Vkm::Engine
 
VKM_ENUM_NAMES(::Vkm::Engine::TextureUsage, "Color", "Data", "Normal")