gempyre_bitmap.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <algorithm>
#include <cstring> // memcpy (windows)
#include <gempyre_types.h>
#include <array>
 
#ifdef WINDOWS_EXPORT
    #ifndef GEMPYRE_EX
        #define GGEMPYRE_EX __declspec( dllexport )
    //#else
    //    #define GEMPYRE_EX
    #endif
#endif
 
#define gempyre_graphics_assert(b, x) ((b) || GempyreUtils::do_fatal(x, nullptr, __FILE__, __LINE__));
 
 
namespace  Gempyre {
    class CanvasElement;
 
    namespace  Color {
        using type = Gempyre::dataT;
 
        [[nodiscard]]
        static constexpr inline type rgba_clamped(type r, type g, type b, type a = 0xFF) {
            const type FF = 0xFF;
            return std::min(FF, r) | (std::min(FF, g) << 8) | (std::min(FF, b) << 16) | (std::min(FF, a) << 24);
        }
 
        [[nodiscard]] 
        static constexpr inline type rgba(type r, type g, type b, type a = 0xFF) {
            return r | (g << 8) | (b << 16) | (a << 24);
        }
 
        [[nodiscard]] 
        static constexpr inline type rgb(type r, type g, type b) {
            return r | (g << 8) | (b << 16) | (static_cast<type>(0xFF) << 24);
        }
 
        [[nodiscard]]
        static constexpr inline type r(type pixel) {
            return pixel & static_cast<type>(0xFF);
        }
        [[nodiscard]] 
        static constexpr inline type g(type pixel) {
            return (pixel & static_cast<type>(0xFF00)) >> 8;
        }
 
        [[nodiscard]] 
        static constexpr inline type b(type pixel) {
            return (pixel & static_cast<type>(0xFF0000)) >> 16;
        }
 
        [[nodiscard]] 
        static constexpr inline type alpha(type pixel) {
            return (pixel & 0xFF000000) >> 24;
        }
 
        [[nodiscard]] 
        static inline std::string rgba(type pixel) {
            constexpr auto c = "0123456789ABCDEF";
            std::string v("#RRGGBBAA");
            v[1] =  c[r(pixel) >> 4];
            v[2] =  c[r(pixel) & 0xF];
            v[3] =  c[g(pixel) >> 4];
            v[4] =  c[g(pixel) & 0xF];
            v[5] =  c[b(pixel) >> 4];
            v[6] =  c[b(pixel) & 0xF];
            v[7] =  c[alpha(pixel) >> 4];
            v[8] =  c[alpha(pixel) & 0xF];
            return v;
        }
 
        [[nodiscard]] 
        static inline std::string rgb(type pixel) {
            constexpr auto c = "0123456789ABCDEF";
            std::string v("#RRGGBB");
            v[1] =  c[r(pixel) >> 4];
            v[2] =  c[r(pixel) & 0xF];
            v[3] =  c[g(pixel) >> 4];
            v[4] =  c[g(pixel) & 0xF];
            v[5] =  c[b(pixel) >> 4];
            v[6] =  c[b(pixel) & 0xF];
        return v;
        }
 
        [[nodiscard]] 
        static inline std::string to_string(type r, type g, type b, type a = 0xFF) {
            return a == 0xFF ? Gempyre::Color::rgb(Gempyre::Color::rgb(r, g, b)) : Gempyre::Color::rgba(Gempyre::Color::rgba(r, g, b, a));
        }
 
        [[nodiscard]] 
        static inline std::string to_string(Gempyre::Color::type color) {
            return Gempyre::Color::to_string(
                Gempyre::Color::r(color),
                Gempyre::Color::g(color),
                Gempyre::Color::b(color),
                Gempyre::Color::alpha(color));
        }
 
        static constexpr Color::type Black      = Color::rgba(0, 0, 0, 0xFF);
        static constexpr Color::type White      = Color::rgba(0xFF, 0xFF, 0xFF, 0xFF);
        static constexpr Color::type Red        = Color::rgba(0xFF, 0, 0, 0xFF);
        static constexpr Color::type Green      = Color::rgba(0, 0xFF, 0, 0xFF);
        static constexpr Color::type Blue       = Color::rgba(0, 0, 0xFF, 0xFF);
        static constexpr Color::type Cyan       = Color::rgba(0, 0xFF, 0xFF, 0xFF);
        static constexpr Color::type Magenta    = Color::rgba(0xFF, 0, 0xFF, 0xFF);
        static constexpr Color::type Yellow     = Color::rgba(0xFF, 0xFF, 0, 0xFF);
        static constexpr Color::type Aqua       = Cyan;
        static constexpr Color::type Fuchsia    = Magenta;
        static constexpr Color::type Lime       = Green;
        static constexpr Color::type Transparent = Color::rgba(0, 0, 0, 0);
    }
 
 
    class GEMPYRE_EX Bitmap {
    public:
        Bitmap(int width, int height);
 
        Bitmap(int width, int height, Gempyre::Color::type color);
        
        Bitmap();
        
        Bitmap(Bitmap&& other) = default;
        
        Bitmap(const Bitmap& other) = default;
        
        ~Bitmap();
 
        Bitmap(const std::vector<uint8_t>& image_data);
 
        std::vector<uint8_t> png_image() const;
 
        Bitmap& operator=(const Bitmap& other) = default;
        
        Bitmap& operator=(Bitmap&& other) = default;
 
        void create(int width, int height);
 
        Bitmap clone() const;
 
        static constexpr Color::type pix(Color::type r, Color::type g, Color::type b, Color::type a = 0xFF) {return Color::rgba(r, g, b, a);}
        
        void set_pixel(int x, int y, Color::type color);
 
        void set_alpha(int x, int y, Color::type alpha);
 
        Color::type pixel(int x, int y) const;
 
        [[nodiscard]] int width() const;
 
        [[nodiscard]] int height() const;
 
        void swap(Bitmap& other);
 
        void draw_rect(const Gempyre::Rect& rect, Color::type color);
 
        void merge(int x, int y, const Bitmap& other);
 
        void merge(const Bitmap& other) {merge(0, 0, other);}
 
        void tile(int x, int y, const Bitmap& other);
 
        void tile(int x, int y, const Bitmap& other, int width, int height);
 
        void tile(int x, int y, const Bitmap& other, int other_x, int other_y, int width, int height);
 
        Bitmap clip(const Gempyre::Rect& rect) const;
 
        bool empty() const;
 
        const uint8_t* const_data() const;
 
        template<class T, std::enable_if_t<std::is_same_v<typename T::value_type, Color::type>, int> = 0>
        bool set_data(const T& bytes, size_t offset = 0) {
            if(bytes.size() + offset > size())
                return false;
            std::memcpy(inner_data() + offset * sizeof(Color::type), bytes.data(), sizeof(Color::type) * bytes.size());
            return true;
        }
 
    protected:
        void copy_from(const Bitmap& other);
        Color::type* inner_data();
        std::size_t size() const;
    private:
        friend class Gempyre::CanvasElement;
        Gempyre::CanvasDataPtr m_canvas{};
    };
 
}