Color.hpp

#ifndef RAYLIB_CPP_INCLUDE_COLOR_HPP_
#define RAYLIB_CPP_INCLUDE_COLOR_HPP_
 
#include <string>
#include <string_view>
 
#include "./raylib.hpp"
#include "./Vector4.hpp"
#include "./RadiansDegrees.hpp"
#include "./raylib-cpp-utils.hpp"
 
namespace raylib {
class Color : public ::Color {
 public:
    Color(const ::Color& color) : ::Color{color.r, color.g, color.b, color.a} {}
 
    Color(
            unsigned char red,
            unsigned char green,
            unsigned char blue,
            unsigned char alpha = 255) : ::Color{red, green, blue, alpha} {};
 
    Color() : ::Color{0, 0, 0, 255} {};
 
    Color(::Vector3 hsv) {
        set(::ColorFromHSV(hsv.x, hsv.y, hsv.z));
    }
 
    static ::Color FromHSV(float hue, float saturation, float value) {
        return ::ColorFromHSV(hue, saturation, value);
    }
 
    Color(unsigned int hexValue) {
        set(::GetColor(hexValue));
    }
 
    Color(void *srcPtr, int format) {
        set(::GetPixelColor(srcPtr, format));
    }
 
    int ToInt() const {
        return ::ColorToInt(*this);
    }
 
    operator int() const {
        return ::ColorToInt(*this);
    }
 
    std::string ToString() const {
        return TextFormat("Color(%d, %d, %d, %d)", r, g, b, a);
    }
 
    operator std::string() const {
        return ToString();
    }
 
    Color Fade(float alpha) const {
        return ::Fade(*this, alpha);
    }
 
    Vector4 Normalize() const {
        return ::ColorNormalize(*this);
    }
 
    Color(::Vector4 normalized) {
        set(::ColorFromNormalized(normalized));
    }
 
    Vector3 ToHSV() const {
        return ::ColorToHSV(*this);
    }
 
    GETTERSETTER(unsigned char, R, r)
    GETTERSETTER(unsigned char, G, g)
    GETTERSETTER(unsigned char, B, b)
    GETTERSETTER(unsigned char, A, a)
 
    Color& operator=(const ::Color& color) {
        set(color);
        return *this;
    }
 
    Color& ClearBackground() {
        ::ClearBackground(*this);
        return *this;
    }
 
    void DrawPixel(int x, int y) const {
        ::DrawPixel(x, y, *this);
    }
 
    void DrawPixel(::Vector2 pos) const {
        ::DrawPixelV(pos, *this);
    }
 
    void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY) const {
        ::DrawLine(startPosX, startPosY, endPosX, endPosY, *this);
    }
 
    void DrawLine(::Vector2 startPos, ::Vector2 endPos) const {
        ::DrawLineV(startPos, endPos, *this);
    }
 
    void DrawLine(::Vector2 startPos, ::Vector2 endPos, float thick) const {
        ::DrawLineEx(startPos, endPos, thick, *this);
    }
 
    void DrawLineBezier(::Vector2 startPos, ::Vector2 endPos, float thick = 1.0f) const {
        ::DrawLineBezier(startPos, endPos, thick, *this);
    }
 
    void DrawLineStrip(::Vector2 *points, int numPoints) const {
        ::DrawLineStrip(points, numPoints, *this);
    }
 
    void DrawText(const char* text, int posX = 0, int posY = 0, int fontSize = 10.0f) const {
        ::DrawText(text, posX, posY, fontSize, *this);
    }
 
    void DrawText(const std::string_view text, int posX = 0, int posY = 0, int fontSize = 10.0f) const {
        ::DrawText(text.data(), posX, posY, fontSize, *this);
    }
 
    void DrawText(const ::Font& font, const char* text, ::Vector2 position,
            float fontSize, float spacing) const {
        ::DrawTextEx(font, text, position, fontSize, spacing, *this);
    }
 
    void DrawText(const ::Font& font, const std::string_view text, ::Vector2 position,
            float fontSize, float spacing) const {
        ::DrawTextEx(font, text.data(), position, fontSize, spacing, *this);
    }
 
    void DrawText(
            const ::Font& font,
            const char* text,
            ::Vector2 position,
            ::Vector2 origin,
            Degree rotation,
            float fontSize,
            float spacing) const {
        ::DrawTextPro(font, text, position, origin, rotation, fontSize, spacing, *this);
    }
 
    void DrawText(
            const ::Font& font,
            const std::string_view text,
            ::Vector2 position,
            ::Vector2 origin,
            Degree rotation,
            float fontSize,
            float spacing) const {
        ::DrawTextPro(font, text.data(), position, origin, rotation, fontSize, spacing, *this);
    }
 
    void DrawRectangle(int posX, int posY, int width, int height) const {
        ::DrawRectangle(posX, posY, width, height, *this);
    }
 
    void DrawRectangle(::Vector2 position, ::Vector2 size) const {
        ::DrawRectangleV(position, size, *this);
    }
 
    void DrawRectangle(::Rectangle rec) const {
        ::DrawRectangleRec(rec, *this);
    }
 
    void DrawRectangle(::Rectangle rec, ::Vector2 origin, Degree rotation) const {
        ::DrawRectanglePro(rec, origin, rotation, *this);
    }
 
    void DrawRectangleLines(int posX, int posY, int width, int height) const {
        ::DrawRectangleLines(posX, posY, width, height, *this);
    }
 
    void DrawRectangleLines(::Rectangle rec, float lineThick) const {
        ::DrawRectangleLinesEx(rec, lineThick, *this);
    }
 
    Color Tint(::Color tint) {
        return ::ColorTint(*this, tint);
    }
 
    Color Brightness(float factor) {
        return ::ColorBrightness(*this, factor);
    }
 
    Color Contrast(float contrast) {
        return ::ColorContrast(*this, contrast);
    }
 
    Color Alpha(float alpha) const {
        return ::ColorAlpha(*this, alpha);
    }
 
    Color AlphaBlend(::Color dst, ::Color tint) const {
        return ::ColorAlphaBlend(dst, *this, tint);
    }
 
    static Color LightGray() { return LIGHTGRAY; }
    static Color Gray() { return GRAY; }
    static Color DarkGray() { return DARKGRAY; }
    static Color Yellow() { return YELLOW; }
    static Color Gold() { return GOLD; }
    static Color Orange() { return ORANGE; }
    static Color Pink() { return PINK; }
    static Color Red() { return RED; }
    static Color Maroon() { return MAROON; }
    static Color Green() { return GREEN; }
    static Color Lime() { return LIME; }
    static Color DarkGreen() { return DARKGREEN; }
    static Color SkyBlue() { return SKYBLUE; }
    static Color Blue() { return BLUE; }
    static Color DarkBlue() { return DARKBLUE; }
    static Color Purple() { return PURPLE; }
    static Color Violet() { return VIOLET; }
    static Color DarkPurple() { return DARKPURPLE; }
    static Color Beige() { return BEIGE; }
    static Color Brown() { return BROWN; }
    static Color DarkBrown() { return DARKBROWN; }
    static Color White() { return WHITE; }
    static Color Black() { return BLACK; }
    static Color Blank() { return BLANK; }
    static Color Magenta() { return MAGENTA; }
    static Color RayWhite() { return RAYWHITE; }
 
 protected:
    void set(const ::Color& color) {
        r = color.r;
        g = color.g;
        b = color.b;
        a = color.a;
    }
};
 
}  // namespace raylib
 
using RColor = raylib::Color;
 
#endif  // RAYLIB_CPP_INCLUDE_COLOR_HPP_