Image.hpp

#ifndef RAYLIB_CPP_INCLUDE_IMAGE_HPP_
#define RAYLIB_CPP_INCLUDE_IMAGE_HPP_
 
#include <span>
#include <string>
#include <string_view>
 
#include "./Color.hpp"
#include "./RaylibException.hpp"
#include "./raylib-cpp-utils.hpp"
#include "./raylib.hpp"
 
namespace raylib {
class Image : public ::Image {
public:
    Image(
        void* data = nullptr,
        int width = 0,
        int height = 0,
        int mipmaps = 1,
        int format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8)
        : ::Image{data, width, height, mipmaps, format} {
        // Nothing.
    }
 
    Image(const ::Image& image) : ::Image(image) { }
 
    Image(const std::string_view fileName) {
        Load(fileName);
    }
 
    Image(const std::string_view fileName, int width, int height, int format, int headerSize = 0) {
        Load(fileName, width, height, format, headerSize);
    }
 
    Image(const std::string_view fileName, int* frames) {
        Load(fileName, frames);
    }
 
    Image(const std::string_view fileName, std::span<int> frames) {
        Load(fileName, frames.data());
    }
 
    Image(const std::string_view fileType, const unsigned char* fileData, int dataSize) {
        Load(fileType, fileData, dataSize);
    }
 
    Image(const ::Texture2D& texture) { Load(texture); }
 
    Image(int width, int height, ::Color color = {255, 255, 255, 255}) { set(::GenImageColor(width, height, color)); }
 
    Image(const std::string_view text, int fontSize, ::Color color = {255, 255, 255, 255}) {
        set(::ImageText(text.data(), fontSize, color));
    }
 
    Image(const ::Font& font, const std::string_view text, float fontSize, float spacing,
            ::Color tint = {255, 255, 255, 255}) {
        set(::ImageTextEx(font, text.data(), fontSize, spacing, tint));
    }
 
    Image(const Image& other) { set(other.Copy()); }
 
    Image(Image&& other) noexcept {
        set(other);
 
        other.data = nullptr;
        other.width = 0;
        other.height = 0;
        other.mipmaps = 0;
        other.format = 0;
    }
 
    static ::Image Text(const std::string_view text, int fontSize,
            ::Color color = {255, 255, 255, 255}) {
        return ::ImageText(text.data(), fontSize, color);
    }
 
    static ::Image Text(const ::Font& font, const std::string_view text, float fontSize, float spacing,
            ::Color tint = {255, 255, 255, 255}) {
        return ::ImageTextEx(font, text.data(), fontSize, spacing, tint);
    }
 
    static ::Image LoadFromScreen() { return ::LoadImageFromScreen(); }
 
    static ::Image Color(int width, int height, ::Color color = {255, 255, 255, 255}) {
        return ::GenImageColor(width, height, color);
    }
 
    static ::Image GradientLinear(int width, int height, int direction, ::Color start, ::Color end) {
        return ::GenImageGradientLinear(width, height, direction, start, end);
    }
 
    static ::Image GradientRadial(int width, int height, float density, ::Color inner, ::Color outer) {
        return ::GenImageGradientRadial(width, height, density, inner, outer);
    }
 
    static ::Image Checked(
        int width,
        int height,
        int checksX,
        int checksY,
        ::Color col1 = {255, 255, 255, 255},
        ::Color col2 = {0, 0, 0, 255}) {
        return ::GenImageChecked(width, height, checksX, checksY, col1, col2);
    }
 
    static ::Image WhiteNoise(int width, int height, float factor) {
        return ::GenImageWhiteNoise(width, height, factor);
    }
 
    static ::Image Cellular(int width, int height, int tileSize) { return ::GenImageCellular(width, height, tileSize); }
 
    static ::Image GetClipboard() { return ::GetClipboardImage(); }
 
    ~Image() { Unload(); }
 
    Image& operator=(const ::Image& image) {
        set(image);
        return *this;
    }
 
    Image& operator=(const Image& other) {
        if (this == &other) {
            return *this;
        }
 
        Unload();
        set(other.Copy());
 
        return *this;
    }
 
    Image& operator=(Image&& other) noexcept {
        if (this == &other) {
            return *this;
        }
 
        Unload();
        set(other);
 
        other.data = nullptr;
        other.width = 0;
        other.height = 0;
        other.mipmaps = 0;
        other.format = 0;
 
        return *this;
    }
 
    void Load(const std::string_view fileName) {
        set(::LoadImage(fileName.data()));
        if (!IsValid()) {
            throw RaylibException("Failed to load Image from file: " + std::string(fileName));
        }
    }
 
    void Load(const std::string_view fileName, int width, int height, int format, int headerSize) {
        set(::LoadImageRaw(fileName.data(), width, height, format, headerSize));
        if (!IsValid()) {
            throw RaylibException("Failed to load Image from file: " + std::string(fileName));
        }
    }
 
    void Load(const std::string_view fileName, int* frames) {
        set(::LoadImageAnim(fileName.data(), frames));
        if (!IsValid()) {
            throw RaylibException("Failed to load Image from file: " + std::string(fileName));
        }
    }
 
    void Load(const std::string_view fileName, std::span<int> frames) {
        set(::LoadImageAnim(fileName.data(), frames.data()));
        if (!IsValid()) {
            throw RaylibException("Failed to load Image from file: " + std::string(fileName));
        }
    }
 
    void Load(
            const std::string_view fileType,
            const unsigned char *fileData,
            int dataSize) {
        set(::LoadImageFromMemory(fileType.data(), fileData, dataSize));
        if (!IsValid()) {
            throw RaylibException("Failed to load Image data with file type: " + std::string(fileType));
        }
    }
 
    void Load(
            const std::string_view fileType,
            const std::span<unsigned char> fileData) {
        set(::LoadImageFromMemory(fileType.data(), fileData.data(), static_cast<int>(fileData.size())));
        if (!IsValid()) {
            throw RaylibException("Failed to load Image data with file type: " + std::string(fileType));
        }
    }
 
    void Load(const ::Texture2D& texture) {
        set(::LoadImageFromTexture(texture));
        if (!IsValid()) {
            throw RaylibException("Failed to load Image from texture.");
        }
    }
 
    void Unload() {
        if (data != nullptr) {
            ::UnloadImage(*this);
            data = nullptr;
        }
    }
 
    void Export(const std::string_view fileName) const {
        if (!::ExportImage(*this, fileName.data())) {
            throw RaylibException(TextFormat("Failed to export Image to file: %s", fileName.data()));
        }
    }
 
    unsigned char* ExportToMemory(const char* fileType, int* fileSize) {
        return ::ExportImageToMemory(*this, fileType, fileSize);
    }
 
    unsigned char* ExportToMemory(const std::string_view fileType, std::span<int> fileSize) {
        return ::ExportImageToMemory(*this, fileType.data(), fileSize.data());
    }
 
    void ExportAsCode(const std::string_view fileName) const {
        if (!::ExportImageAsCode(*this, fileName.data())) {
            throw RaylibException(TextFormat("Failed to export Image code to file: %s", fileName.data()));
        }
    }
 
    GETTER(void*, Data, data)
    GETTER(int, Width, width)
    GETTER(int, Height, height)
    GETTER(int, Mipmaps, mipmaps)
    GETTER(int, Format, format)
 
    void SetWidth(int width, int offsetX = 0, int offsetY = 0, ::Color fill = {255, 255, 255, 255}) {
        ResizeCanvas(width, height, offsetX, offsetY, fill);
    }
 
    void SetHeight(int height, int offsetX = 0, int offsetY = 0, ::Color fill = {255, 255, 255, 255}) {
        ResizeCanvas(width, height, offsetX, offsetY, fill);
    }
 
    [[nodiscard]] ::Vector2 GetSize() const { return {static_cast<float>(width), static_cast<float>(height)}; }
 
    [[nodiscard]] ::Image Copy() const { return ::ImageCopy(*this); }
 
    [[nodiscard]] ::Image FromImage(::Rectangle rec) const { return ::ImageFromImage(*this, rec); }
 
    Image& Format(int newFormat) {
        ::ImageFormat(this, newFormat);
        return *this;
    }
 
    Image& ToPOT(::Color fillColor) {
        ::ImageToPOT(this, fillColor);
        return *this;
    }
 
    Image& Crop(::Rectangle crop) {
        ::ImageCrop(this, crop);
        return *this;
    }
 
    Image& AlphaCrop(float threshold) {
        ::ImageAlphaCrop(this, threshold);
        return *this;
    }
 
    Image& AlphaClear(::Color color, float threshold) {
        ::ImageAlphaClear(this, color, threshold);
        return *this;
    }
 
    Image& AlphaMask(const ::Image& alphaMask) {
        ::ImageAlphaMask(this, alphaMask);
        return *this;
    }
 
    Image& AlphaPremultiply() {
        ::ImageAlphaPremultiply(this);
        return *this;
    }
 
    Image& Crop(int newWidth, int newHeight) { return Crop(0, 0, newWidth, newHeight); }
 
    Image& Crop(::Vector2 size) { return Crop(0, 0, static_cast<int>(size.x), static_cast<int>(size.y)); }
 
    Image& Crop(int offsetX, int offsetY, int newWidth, int newHeight) {
        ::Rectangle rect{
            static_cast<float>(offsetX),
            static_cast<float>(offsetY),
            static_cast<float>(newWidth),
            static_cast<float>(newHeight)};
        ::ImageCrop(this, rect);
        return *this;
    }
 
    Image& Resize(int newWidth, int newHeight) {
        ::ImageResize(this, newWidth, newHeight);
        return *this;
    }
 
    Image& ResizeNN(int newWidth, int newHeight) {
        ::ImageResizeNN(this, newWidth, newHeight);
        return *this;
    }
 
    Image&
    ResizeCanvas(int newWidth, int newHeight, int offsetX = 0, int offsetY = 0, ::Color color = {255, 255, 255, 255}) {
        ::ImageResizeCanvas(this, newWidth, newHeight, offsetX, offsetY, color);
        return *this;
    }
 
    Image& Mipmaps() {
        ::ImageMipmaps(this);
        return *this;
    }
 
    Image& Dither(int rBpp, int gBpp, int bBpp, int aBpp) {
        ::ImageDither(this, rBpp, gBpp, bBpp, aBpp);
        return *this;
    }
 
    Image& FlipVertical() {
        ::ImageFlipVertical(this);
        return *this;
    }
 
    Image& FlipHorizontal() {
        ::ImageFlipHorizontal(this);
        return *this;
    }
 
    Image& Rotate(Degree degrees) {
        ::ImageRotate(this, static_cast<int>(degrees));
        return *this;
    }
 
    Image& RotateCW() {
        ::ImageRotateCW(this);
        return *this;
    }
 
    Image& RotateCCW() {
        ::ImageRotateCCW(this);
        return *this;
    }
 
    Image& ColorTint(::Color color = {255, 255, 255, 255}) {
        ::ImageColorTint(this, color);
        return *this;
    }
 
    Image& ColorInvert() {
        ::ImageColorInvert(this);
        return *this;
    }
 
    Image& ColorGrayscale() {
        ::ImageColorGrayscale(this);
        return *this;
    }
 
    Image& ColorContrast(float contrast) {
        ::ImageColorContrast(this, contrast);
        return *this;
    }
 
    Image& ColorBrightness(int brightness) {
        ::ImageColorBrightness(this, brightness);
        return *this;
    }
 
    Image& ColorReplace(::Color color, ::Color replace) {
        ::ImageColorReplace(this, color, replace);
        return *this;
    }
 
    [[nodiscard]] Rectangle GetAlphaBorder(float threshold) const { return ::GetImageAlphaBorder(*this, threshold); }
 
    [[nodiscard]] raylib::Color GetColor(int x = 0, int y = 0) const { return ::GetImageColor(*this, x, y); }
 
    [[nodiscard]] raylib::Color GetColor(::Vector2 position) const {
        return ::GetImageColor(*this, static_cast<int>(position.x), static_cast<int>(position.y));
    }
 
    Image& ClearBackground(::Color color = {0, 0, 0, 255}) {
        ::ImageClearBackground(this, color);
        return *this;
    }
 
    void DrawPixel(int posX, int posY, ::Color color = {255, 255, 255, 255}) {
        ::ImageDrawPixel(this, posX, posY, color);
    }
 
    void DrawPixel(::Vector2 position, ::Color color = {255, 255, 255, 255}) {
        ::ImageDrawPixelV(this, position, color);
    }
 
    void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, ::Color color = {255, 255, 255, 255}) {
        ::ImageDrawLine(this, startPosX, startPosY, endPosX, endPosY, color);
    }
 
    void DrawLine(::Vector2 start, ::Vector2 end, ::Color color = {255, 255, 255, 255}) {
        ::ImageDrawLineV(this, start, end, color);
    }
 
    void DrawLine(::Vector2 start, ::Vector2 end, int thick, ::Color color = {255, 255, 255, 255}) {
        ImageDrawLineEx(this, start, end, thick, color);
    }
 
    void DrawCircle(int centerX, int centerY, int radius, ::Color color = {255, 255, 255, 255}) {
        ::ImageDrawCircle(this, centerX, centerY, radius, color);
    }
 
    void DrawCircle(::Vector2 center, int radius, ::Color color = {255, 255, 255, 255}) {
        ::ImageDrawCircleV(this, center, radius, color);
    }
 
    void DrawRectangle(int posX, int posY, int width, int height, ::Color color = {255, 255, 255, 255}) {
        ::ImageDrawRectangle(this, posX, posY, width, height, color);
    }
 
    void DrawRectangle(Vector2 position, Vector2 size, ::Color color = {255, 255, 255, 255}) {
        ::ImageDrawRectangleV(this, position, size, color);
    }
 
    void DrawRectangle(::Rectangle rec, ::Color color = {255, 255, 255, 255}) {
        ::ImageDrawRectangleRec(this, rec, color);
    }
 
    void DrawRectangleLines(::Rectangle rec, int thick = 1, ::Color color = {255, 255, 255, 255}) {
        ::ImageDrawRectangleLines(this, rec, thick, color);
    }
 
    // TODO: Add ImageDrawTriangle()
 
    void Draw(const ::Image& src, ::Rectangle srcRec, ::Rectangle dstRec, ::Color tint = {255, 255, 255, 255}) {
        ::ImageDraw(this, src, srcRec, dstRec, tint);
    }
 
    void DrawText(const char* text, ::Vector2 position, int fontSize, ::Color color = {255, 255, 255, 255}) {
        ::ImageDrawText(this, text, static_cast<int>(position.x), static_cast<int>(position.y), fontSize, color);
    }
 
    void DrawText(const std::string_view text, ::Vector2 position, int fontSize,
            ::Color color = {255, 255, 255, 255}) {
        ::ImageDrawText(this,
            text.data(),
            static_cast<int>(position.x),
            static_cast<int>(position.y),
            fontSize,
            color);
    }
 
    void DrawText(const std::string_view text, int x, int y, int fontSize,
            ::Color color = {255, 255, 255, 255}) {
        ::ImageDrawText(this, text.data(), x, y, fontSize, color);
    }
 
    void DrawText(const char* text, int x, int y, int fontSize, ::Color color = {255, 255, 255, 255}) {
        ::ImageDrawText(this, text, x, y, fontSize, color);
    }
 
    void DrawText(const ::Font& font, const std::string_view text, ::Vector2 position,
            float fontSize, float spacing, ::Color tint = {255, 255, 255, 255}) {
        ::ImageDrawTextEx(this, font, text.data(), position, fontSize, spacing, tint);
    }
 
    void DrawText(
        const ::Font& font,
        const char* text,
        ::Vector2 position,
        float fontSize,
        float spacing,
        ::Color tint = {255, 255, 255, 255}) {
        ::ImageDrawTextEx(this, font, text, position, fontSize, spacing, tint);
    }
 
    [[nodiscard]] ::Color* LoadColors() const { return ::LoadImageColors(*this); }
 
    ::Color* LoadPalette(int maxPaletteSize, int* colorsCount) const {
        return ::LoadImagePalette(*this, maxPaletteSize, colorsCount);
    }
 
    void UnloadColors(::Color* colors) const { ::UnloadImageColors(colors); }
 
    void UnloadPalette(::Color* colors) const { ::UnloadImagePalette(colors); }
 
    [[nodiscard]] ::Texture2D LoadTexture() const { return ::LoadTextureFromImage(*this); }
 
    operator ::Texture2D() const { return LoadTexture(); }
 
    static int GetPixelDataSize(int width, int height, int format = PIXELFORMAT_UNCOMPRESSED_R32G32B32A32) {
        return ::GetPixelDataSize(width, height, format);
    }
 
    [[nodiscard]] int GetPixelDataSize() const { return ::GetPixelDataSize(width, height, format); }
 
    [[nodiscard]] bool IsValid() const { return ::IsImageValid(*this); }
 
    ::Image Channel(int selectedChannel) { return ::ImageFromChannel(*this, selectedChannel); }
 
    void KernelConvolution(const float* kernel, int kernelSize) {
        ::ImageKernelConvolution(this, kernel, kernelSize);
    }
protected:
    void set(const ::Image& image) {
        data = image.data;
        width = image.width;
        height = image.height;
        mipmaps = image.mipmaps;
        format = image.format;
    }
};
} // namespace raylib
 
using RImage = raylib::Image;
 
#endif // RAYLIB_CPP_INCLUDE_IMAGE_HPP_