Image.hpp

Go to the documentation of this file.

#ifndef DONUT_GRAPHICS_IMAGE_HPP
#define DONUT_GRAPHICS_IMAGE_HPP
 
#include <donut/Filesystem.hpp>
#include <donut/UniqueHandle.hpp>
 
#include <cassert>  // assert
#include <cstddef>  // std::size_t
#include <cstdint>  // std::uint32_t
#include <optional> // std::optional
 
namespace donut::graphics {
 
enum class PixelFormat : std::uint32_t {
    R = 0x1903,    
    RG = 0x8227,   
    RGB = 0x1907,  
    RGBA = 0x1908, 
};
 
enum class PixelComponentType : std::uint32_t {
    U8 = 0x1401,  
    F16 = 0x140B, 
    F32 = 0x1406, 
};
 
class ImageView {
public:
    constexpr ImageView() noexcept = default;
 
    constexpr ImageView(std::size_t width, std::size_t height, PixelFormat pixelFormat, PixelComponentType pixelComponentType, const void* pixels) noexcept
        : pixels(pixels)
        , width(width)
        , height(height)
        , pixelFormat(pixelFormat)
        , pixelComponentType(pixelComponentType) {
        assert(pixels || (width == 0 && height == 0 && pixelFormat == PixelFormat::R && pixelComponentType == PixelComponentType::U8));
    }
 
    explicit operator bool() const noexcept {
        return static_cast<bool>(pixels);
    }
 
    [[nodiscard]] constexpr std::size_t getWidth() const noexcept {
        return width;
    }
 
    [[nodiscard]] constexpr std::size_t getHeight() const noexcept {
        return height;
    }
 
    [[nodiscard]] constexpr PixelFormat getPixelFormat() const noexcept {
        return pixelFormat;
    }
 
    [[nodiscard]] constexpr PixelComponentType getPixelComponentType() const noexcept {
        return pixelComponentType;
    }
 
    [[nodiscard]] constexpr const void* getPixels() const noexcept {
        return pixels;
    }
 
    [[nodiscard]] constexpr std::size_t getChannelCount() const noexcept {
        if (pixels) {
            switch (pixelFormat) {
                case PixelFormat::R: return 1;
                case PixelFormat::RG: return 2;
                case PixelFormat::RGB: return 3;
                case PixelFormat::RGBA: return 4;
            }
        }
        return 0;
    }
 
    [[nodiscard]] constexpr std::size_t getPixelComponentSize() const noexcept {
        if (pixels) {
            switch (pixelComponentType) {
                case PixelComponentType::U8: return 1;
                case PixelComponentType::F16: return 2;
                case PixelComponentType::F32: return 4;
            }
        }
        return 0;
    }
 
    [[nodiscard]] constexpr std::size_t getPixelStride() const noexcept {
        return getChannelCount() * getPixelComponentSize();
    }
 
    [[nodiscard]] constexpr std::size_t getSizeInBytes() const noexcept {
        return getWidth() * getHeight() * getPixelStride();
    }
 
private:
    const void* pixels = nullptr;
    std::size_t width = 0;
    std::size_t height = 0;
    PixelFormat pixelFormat = PixelFormat::R;
    PixelComponentType pixelComponentType = PixelComponentType::U8;
};
 
struct ImageSavePNGOptions {
    int compressionLevel = 8;
 
    bool flipVertically = false;
};
 
struct ImageSaveBMPOptions {
    bool flipVertically = false;
};
 
struct ImageSaveTGAOptions {
    bool useRleCompression = true;
 
    bool flipVertically = false;
};
 
struct ImageSaveJPGOptions {
    int quality = 90;
 
    bool flipVertically = false;
};
 
struct ImageSaveHDROptions {
    bool flipVertically = false;
};
 
struct ImageSaveOptions {
    bool flipVertically = false;
};
 
struct ImageOptions {
    std::optional<PixelFormat> desiredFormat{};
 
    bool highDynamicRange = false;
 
    bool flipVertically = false;
};
 
class Image {
public:
    static void savePNG(const ImageView& image, Filesystem& filesystem, const char* filepath, const ImageSavePNGOptions& options = {});
 
    static void saveBMP(const ImageView& image, Filesystem& filesystem, const char* filepath, const ImageSaveBMPOptions& options = {});
 
    static void saveTGA(const ImageView& image, Filesystem& filesystem, const char* filepath, const ImageSaveTGAOptions& options = {});
 
    static void saveJPG(const ImageView& image, Filesystem& filesystem, const char* filepath, const ImageSaveJPGOptions& options = {});
 
    static void saveHDR(const ImageView& image, Filesystem& filesystem, const char* filepath, const ImageSaveHDROptions& options = {});
 
    static void save(const ImageView& image, Filesystem& filesystem, const char* filepath, const ImageSaveOptions& options = {});
 
    Image() noexcept = default;
 
    Image(std::size_t width, std::size_t height, PixelFormat pixelFormat, PixelComponentType pixelComponentType, const void* pixels);
 
    explicit Image(const ImageView& image);
 
    explicit Image(const Filesystem& filesystem, const char* filepath, const ImageOptions& options = {});
 
    explicit operator bool() const noexcept {
        return static_cast<bool>(pixels);
    }
 
    operator ImageView() const noexcept {
        return ImageView{getWidth(), getHeight(), getPixelFormat(), getPixelComponentType(), getPixels()};
    }
 
    void reset() noexcept {
        *this = Image{};
    }
 
    [[nodiscard]] std::size_t getWidth() const noexcept {
        return width;
    }
 
    [[nodiscard]] std::size_t getHeight() const noexcept {
        return height;
    }
 
    [[nodiscard]] PixelFormat getPixelFormat() const noexcept {
        return pixelFormat;
    }
 
    [[nodiscard]] PixelComponentType getPixelComponentType() const noexcept {
        return pixelComponentType;
    }
 
    [[nodiscard]] void* getPixels() noexcept {
        return pixels.get();
    }
 
    [[nodiscard]] const void* getPixels() const noexcept {
        return pixels.get();
    }
 
    [[nodiscard]] std::size_t getChannelCount() const noexcept {
        return ImageView{*this}.getChannelCount();
    }
 
    [[nodiscard]] std::size_t getPixelComponentSize() const noexcept {
        return ImageView{*this}.getPixelComponentSize();
    }
 
    [[nodiscard]] std::size_t getPixelStride() const noexcept {
        return ImageView{*this}.getPixelStride();
    }
 
    [[nodiscard]] std::size_t getSizeInBytes() const noexcept {
        return ImageView{*this}.getSizeInBytes();
    }
 
private:
    struct PixelsDeleter {
        void operator()(void* handle) const noexcept;
    };
 
    UniqueHandle<void*, PixelsDeleter> pixels{};
    std::size_t width = 0;
    std::size_t height = 0;
    PixelFormat pixelFormat = PixelFormat::R;
    PixelComponentType pixelComponentType = PixelComponentType::U8;
};
 
} // namespace donut::graphics
 
#endif