color.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_UTILITY_COLOR_HPP__
#define NEFORCE_CORE_UTILITY_COLOR_HPP__

 
#include "NeForce/core/utility/hexadecimal.hpp"
#include "NeForce/core/utility/packages.hpp"
NEFORCE_BEGIN_NAMESPACE__


class color : public iobject<color>, public icommon<color> {
private:
    int r = 0;   
    int g = 0;   
    int b = 0;   
    int a = 255; 

    static constexpr int clamp(const int value) noexcept {
        if (value < 0) {
            return 0;
        }
        if (value > 255) {
            return 255;
        }
        return value;
    }

    static constexpr double clamp_double(const double value) noexcept {
        if (value < 0.0) {
            return 0.0;
        }
        if (value > 1.0) {
            return 1.0;
        }
        return value;
    }

    static constexpr int lerp_component(const int from, const int to, const double t) noexcept {
        const double result = from + (to - from) * clamp_double(t);
        return static_cast<int>(_NEFORCE round(result));
    }
 
    static constexpr int find_closest(const int value) noexcept {
        constexpr int levels[6] = {0, 95, 135, 175, 215, 255};
 
        int closest_idx = 0;
        int min_diff = 255 * 255;
        for (int i = 0; i < 6; ++i) {
            const int diff = value - levels[i];
            const int dist = diff * diff;
            if (dist < min_diff) {
                min_diff = dist;
                closest_idx = i;
            }
        }
        return closest_idx;
    };
 
public:
    constexpr color() noexcept = default;
 
    constexpr color(const color& other) noexcept = default;
    constexpr color& operator=(const color& other) noexcept = default;

    explicit constexpr color(const int gray) noexcept :
    r(clamp(gray)),
    g(clamp(gray)),
    b(clamp(gray)) {}

    constexpr color(const int gray, const int alpha) noexcept :
    r(clamp(gray)),
    g(clamp(gray)),
    b(clamp(gray)),
    a(clamp(alpha)) {}

    constexpr color(const int red, const int green, const int blue) noexcept :
    r(clamp(red)),
    g(clamp(green)),
    b(clamp(blue)) {}

    constexpr color(const int red, const int green, const int blue, const int alpha) noexcept :
    r(clamp(red)),
    g(clamp(green)),
    b(clamp(blue)),
    a(clamp(alpha)) {}

    NEFORCE_CONSTEXPR20 explicit color(const string_view str) { *this = parse(str); }

    NEFORCE_CONSTEXPR20 explicit color(const string& str) { *this = parse(str.view()); }

    NEFORCE_CONSTEXPR20 explicit color(const char* str) { *this = parse(string_view{str}); }

    constexpr color(color&& other) noexcept :
    r(other.r),
    g(other.g),
    b(other.b),
    a(other.a) {
        other.r = 0;
        other.g = 0;
        other.b = 0;
        other.a = 255;
    }

    constexpr color& operator=(color&& other) noexcept {
        if (_NEFORCE addressof(other) == this) {
            return *this;
        }
        r = other.r;
        g = other.g;
        b = other.b;
        a = other.a;
        other.r = 0;
        other.g = 0;
        other.b = 0;
        other.a = 255;
        return *this;
    }
 
    NEFORCE_CONSTEXPR20 ~color() = default;

    NEFORCE_NODISCARD constexpr int R() const noexcept { return r; }

    NEFORCE_NODISCARD constexpr int G() const noexcept { return g; }

    NEFORCE_NODISCARD constexpr int B() const noexcept { return b; }

    NEFORCE_NODISCARD constexpr int A() const noexcept { return a; }

    constexpr void setR(const int red) noexcept { r = clamp(red); }

    constexpr void setG(const int green) noexcept { g = clamp(green); }

    constexpr void setB(const int blue) noexcept { b = clamp(blue); }

    constexpr void setA(const int alpha) noexcept { a = clamp(alpha); }

    constexpr void set_color(const int red, const int green, const int blue) noexcept {
        r = clamp(red);
        g = clamp(green);
        b = clamp(blue);
    }

    constexpr void set_color(const int red, const int green, const int blue, const int alpha) noexcept {
        r = clamp(red);
        g = clamp(green);
        b = clamp(blue);
        a = clamp(alpha);
    }

    constexpr void set_gray(const int gray) noexcept { r = g = b = clamp(gray); }

    constexpr void set_gray(const int gray, const int alpha) noexcept {
        set_gray(gray);
        a = clamp(alpha);
    }

    NEFORCE_NODISCARD constexpr bool is_transparent() const noexcept { return a == 0; }

    NEFORCE_NODISCARD constexpr bool is_opaque() const noexcept { return a == 255; }

    NEFORCE_NODISCARD constexpr double opacity() const noexcept { return a / 255.0; }

    constexpr void set_opacity(double opacity) noexcept {
        opacity = _NEFORCE max(opacity, 0.0);
        opacity = _NEFORCE min(opacity, 1.0);
        a = static_cast<int>(_NEFORCE round(opacity * 255));
    }

    static constexpr color lerp(const color& from, const color& to, double t) noexcept {
        t = clamp_double(t);
        return {lerp_component(from.r, to.r, t), lerp_component(from.g, to.g, t), lerp_component(from.b, to.b, t),
                lerp_component(from.a, to.a, t)};
    }

    constexpr color operator+(const color& other) const noexcept {
        return {r + other.r, g + other.g, b + other.b, a + other.a};
    }

    constexpr color operator-(const color& other) const noexcept {
        return {r - other.r, g - other.g, b - other.b, a - other.a};
    }

    constexpr color operator*(const double scalar) const noexcept {
        return {static_cast<int>(_NEFORCE round(static_cast<double>(r) * scalar)),
                static_cast<int>(_NEFORCE round(static_cast<double>(g) * scalar)),
                static_cast<int>(_NEFORCE round(static_cast<double>(b) * scalar)),
                static_cast<int>(_NEFORCE round(static_cast<double>(a) * scalar))};
    }

    constexpr color operator*(const int scalar) const noexcept {
        return {r * scalar, g * scalar, b * scalar, a * scalar};
    }

    constexpr color& operator+=(const color& other) noexcept {
        r = clamp(r + other.r);
        g = clamp(g + other.g);
        b = clamp(b + other.b);
        a = clamp(a + other.a);
        return *this;
    }

    constexpr color& operator-=(const color& other) noexcept {
        r = clamp(r - other.r);
        g = clamp(g - other.g);
        b = clamp(b - other.b);
        a = clamp(a - other.a);
        return *this;
    }

    constexpr color& operator*=(const double scalar) noexcept {
        r = clamp(static_cast<int>(_NEFORCE round(r * scalar)));
        g = clamp(static_cast<int>(_NEFORCE round(g * scalar)));
        b = clamp(static_cast<int>(_NEFORCE round(b * scalar)));
        a = clamp(static_cast<int>(_NEFORCE round(a * scalar)));
        return *this;
    }

    NEFORCE_NODISCARD constexpr bool equal_to(const color& other) const noexcept {
        return r == other.r && g == other.g && b == other.b && a == other.a;
    }

    NEFORCE_NODISCARD constexpr bool less_than(const color& other) const noexcept {
        if (r != other.r) {
            return r < other.r;
        }
        if (g != other.g) {
            return g < other.g;
        }
        if (b != other.b) {
            return b < other.b;
        }
        return a < other.a;
    }

    NEFORCE_NODISCARD constexpr color blend(const color& background) const noexcept {
        if (a == 255) {
            return *this;
        }
        if (a == 0) {
            return background;
        }
 
        const decimal_t src_a = a / 255.0;
        const decimal_t dst_a = background.a / 255.0;
        const decimal_t inv_src_a = 1.0 - src_a;
 
        // Result_A = Src_A + Dst_A * (1 - Src_A)
        const decimal_t out_a = src_a + dst_a * inv_src_a;
 
        if (out_a <= 0.0) {
            return transparent();
        }
 
        // Result_RGB = (Src_RGB * Src_A + Dst_RGB * Dst_A * (1 - Src_A)) / Result_A
        const decimal_t inv_out_a = 1.0 / out_a;
        const int newR = static_cast<int>(_NEFORCE round((r * src_a + background.r * dst_a * inv_src_a) * inv_out_a));
        const int newG = static_cast<int>(_NEFORCE round((g * src_a + background.g * dst_a * inv_src_a) * inv_out_a));
        const int newB = static_cast<int>(_NEFORCE round((b * src_a + background.b * dst_a * inv_src_a) * inv_out_a));
        const int newA = static_cast<int>(_NEFORCE round(out_a * 255.0));
 
        return {newR, newG, newB, newA};
    }

    NEFORCE_NODISCARD constexpr double gray_value() const noexcept { return 0.299 * r + 0.587 * g + 0.114 * b; }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 string to_string() const {
        return _NEFORCE format("{:02X}{:02X}{:02X}{:02X}", r, g, b, a);
    }

    static NEFORCE_CONSTEXPR20 color parse(const string_view hex) {
        string_view clean_hex = hex;
        if (clean_hex[0] == '#') {
            clean_hex = clean_hex.tail(1);
        }
 
        if (clean_hex.length() == 6) {
            const int64_t r = hexadecimal::parse(clean_hex.substr(0, 2)).value();
            const int64_t g = hexadecimal::parse(clean_hex.substr(2, 2)).value();
            const int64_t b = hexadecimal::parse(clean_hex.substr(4, 2)).value();
            return {static_cast<int>(r), static_cast<int>(g), static_cast<int>(b)};
        } else if (clean_hex.length() == 8) {
            const int64_t r = hexadecimal::parse(clean_hex.substr(0, 2)).value();
            const int64_t g = hexadecimal::parse(clean_hex.substr(2, 2)).value();
            const int64_t b = hexadecimal::parse(clean_hex.substr(4, 2)).value();
            const int64_t a = hexadecimal::parse(clean_hex.substr(6, 2)).value();
            return {static_cast<int>(r), static_cast<int>(g), static_cast<int>(b), static_cast<int>(a)};
        } else {
            NEFORCE_THROW_EXCEPTION(value_exception("Invalid hex string"));
        }
        unreachable();
    }

    NEFORCE_NODISCARD constexpr int to_ansi_256() const noexcept {
        if (r == 0 && g == 0 && b == 0) {
            return 16;
        }
        if (r == 255 && g == 255 && b == 255) {
            return 231;
        }
 
        if (r == g && g == b) {
            if (r < 8) {
                return 16;
            }
            if (r > 248) {
                return 231;
            }
            const int gray_index = (r - 8) / 10;
            return 232 + (gray_index > 23 ? 23 : gray_index);
        }
 
        const int r_idx = find_closest(r);
        const int g_idx = find_closest(g);
        const int b_idx = find_closest(b);
 
        // 16 + 36 * R + 6 * G + B
        return 16 + 36 * r_idx + 6 * g_idx + b_idx;
    }

    NEFORCE_NODISCARD constexpr int to_ansi_basic(const bool is_background = false) const noexcept {
        const int base = is_background ? 40 : 30;
 
        if (r > g && r > b) {
            if (g > 128 && b > 128) {
                return base + 7;
            }
            return base + 1;
        } else if (g > r && g > b) {
            if (r > 128 && b > 128) {
                return base + 7;
            }
            return base + 2;
        } else if (b > r && b > g) {
            if (r > 128 && g > 128) {
                return base + 7;
            }
            return base + 4;
        } else if (r == g && g == b) {
            if (r < 64) {
                return base + 0;
            }
            if (r < 192) {
                return base + 7;
            }
            return base + 7;
        } else if (r == g && r > b) {
            return base + 3;
        } else if (r == b && r > g) {
            return base + 5;
        } else if (g == b && g > r) {
            return base + 6;
        }
 
        return base + 7;
    }

    NEFORCE_NODISCARD constexpr integer32 to_ansi_foreground(const bool use_256_color = true) const noexcept {
        if (use_256_color) {
            return integer32{38 * 100 + 5 * 10 + to_ansi_256()};
        }
        return integer32{to_ansi_basic(false)};
    }

    NEFORCE_NODISCARD constexpr integer32 to_ansi_background(const bool use_256_color = true) const noexcept {
        if (use_256_color) {
            return integer32{48 * 100 + 5 * 10 + to_ansi_256()};
        }
        return integer32{to_ansi_basic(true)};
    }

    NEFORCE_NODISCARD constexpr color to_premultiplied() const noexcept {
        const decimal_t alpha = a / 255.0;
        return {static_cast<int>(_NEFORCE round(r * alpha)), static_cast<int>(_NEFORCE round(g * alpha)),
                static_cast<int>(_NEFORCE round(b * alpha)), a};
    }

    NEFORCE_NODISCARD constexpr color from_premultiplied() const noexcept {
        if (a == 0) {
            return transparent();
        }
        const decimal_t inv_alpha = 255.0 / a;
        return {static_cast<int>(_NEFORCE round(r * inv_alpha)), static_cast<int>(_NEFORCE round(g * inv_alpha)),
                static_cast<int>(_NEFORCE round(b * inv_alpha)), a};
    }

    NEFORCE_NODISCARD constexpr integer32 to_integer32(const bool use_256_color = true) const noexcept {
        if (use_256_color) {
            return integer32{to_ansi_256()};
        }
        return integer32{to_ansi_basic(false)};
    }

    NEFORCE_NODISCARD constexpr size_t to_hash() const noexcept {
        constexpr hash<int> hasher;
        return hasher(r) ^ hasher(g) ^ hasher(b) ^ hasher(a);
    }

    constexpr void swap(color& other) noexcept {
        color tmp = _NEFORCE move(other);
        other = _NEFORCE move(*this);
        *this = _NEFORCE move(tmp);
    }

    static constexpr color black() noexcept { return {0, 0, 0, 255}; }

    static constexpr color white() noexcept { return {255, 255, 255, 255}; }

    static constexpr color gray() noexcept { return {128, 128, 128, 255}; }

    static constexpr color red() noexcept { return {255, 0, 0, 255}; }

    static constexpr color green() noexcept { return {0, 255, 0, 255}; }

    static constexpr color blue() noexcept { return {0, 0, 255, 255}; }

    static constexpr color yellow() noexcept { return {255, 255, 0, 255}; }

    static constexpr color magenta() noexcept { return {255, 0, 255, 255}; }

    static constexpr color cyan() noexcept { return {0, 255, 255, 255}; }

    static constexpr color transparent() noexcept { return {0, 0, 0, 0}; }
};

constexpr color operator*(const double scalar, const color& color) noexcept { return color * scalar; }

constexpr color operator*(const int scalar, const color& color) noexcept { return color * scalar; }
 // Color
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_UTILITY_COLOR_HPP__