color.h

Go to the documentation of this file.

#ifndef KOUTIL_TERM_COLOR_H
#define KOUTIL_TERM_COLOR_H
 
#include <array>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <string_view>
#include <type_traits>
 
namespace koutil::term {
 
struct color_bg_t;
struct color_fg_t;
 
struct color_t {
public:
    using channel_t = std::uint8_t;
 
    enum class Tag : std::uint8_t {
        RGB,
        ID,
    };
 
    const channel_t red;
    const channel_t green;
    const channel_t blue;
    const Tag tag;
 
public:
    constexpr color_t()
        : red()
        , green()
        , blue()
        , tag(Tag::RGB) { }
 
    constexpr color_t(channel_t r, channel_t g, channel_t b)
        : red(r)
        , green(g)
        , blue(b)
        , tag(Tag::RGB) { }
 
    constexpr color_t(std::uint8_t id)
        : red(id)
        , green()
        , blue()
        , tag(Tag::ID) { }
 
    static constexpr color_t from_rgb(channel_t red, channel_t green, channel_t blue) { return { red, green, blue }; }
 
    static constexpr color_t from_id(channel_t id) { return { id }; }
 
    static constexpr color_t from_hsv(std::uint16_t h, float s, float v);
 
    static consteval color_t from_hex(std::string_view hex) {
        if (!hex.starts_with('#')) {
            assert(false);
        }
 
        if (hex.size() - 1 == 3) {
            return {
                static_cast<channel_t>(extract_value(hex[1]) | (extract_value(hex[1]) << 4)),
                static_cast<channel_t>(extract_value(hex[2]) | (extract_value(hex[2]) << 4)),
                static_cast<channel_t>(extract_value(hex[3]) | (extract_value(hex[3]) << 4)),
            };
        } else if (hex.size() - 1 == 6) {
            return {
                static_cast<channel_t>(extract_value(hex[2]) | (extract_value(hex[1]) << 4)),
                static_cast<channel_t>(extract_value(hex[4]) | (extract_value(hex[3]) << 4)),
                static_cast<channel_t>(extract_value(hex[6]) | (extract_value(hex[5]) << 4)),
            };
        } else {
            assert(false);
        }
    }
 
    [[nodiscard]] constexpr std::array<channel_t, 3> get_channels() const {
        assert(tag == Tag::RGB);
        return { red, green, blue };
    }
 
    [[nodiscard]] constexpr channel_t id() const { return red; }
 
    [[nodiscard]] constexpr color_bg_t as_bg() const;
 
    [[nodiscard]] constexpr color_fg_t as_fg() const;
 
    constexpr bool operator==(color_t other) const {
        return red == other.red && green == other.green && blue == other.blue && tag == other.tag;
    }
 
private:
    static consteval std::uint8_t extract_value(char val) {
        if ('a' <= val && val <= 'f') {
            return static_cast<std::uint8_t>(10 + val - 'a');
        } else if ('A' <= val && val <= 'F') {
            return static_cast<std::uint8_t>(10 + val - 'A');
        } else {
            return static_cast<std::uint8_t>(val - '0');
        }
    }
 
    static constexpr std::uint8_t convert_val(float val) {
        if (std::is_constant_evaluated()) {
            return static_cast<std::uint8_t>(val * 255.0F + 0.5F);
        } else {
            return static_cast<std::uint8_t>(std::round(val * 255.0F));
        }
    }
};
 
struct color_bg_t {
    constexpr color_bg_t(color_t c)
        : color(c) { }
 
    const color_t color;
};
 
struct color_fg_t {
    constexpr color_fg_t(color_t c)
        : color(c) { }
 
    const color_t color;
};
 
constexpr color_bg_t color_t::as_bg() const { return { *this }; }
 
constexpr color_fg_t color_t::as_fg() const { return { *this }; }
 
constexpr color_t color_t::from_hsv(std::uint16_t h, float s, float v) {
    constexpr std::uint16_t HUE_PART = 360 / 6;
    constexpr float HUE_PART_FLOAT   = 360.0F / 6.0F;
 
    if (s <= 0.0001F) {
        channel_t val = convert_val(v);
        return { val, val, val };
    }
 
    h %= 360;
 
    const auto region = h / HUE_PART;
    const auto rem    = static_cast<float>(h % HUE_PART) / HUE_PART_FLOAT;
 
    const float p = v * (1.0F - s);
    const float q = v * (1.0F - (s * rem));
    const auto t  = v * (1.0F - (s * (1.0F - rem)));
 
    float r = 0.F;
    float g = 0.F;
    float b = 0.F;
 
    switch (region) {
    case 0:
        r = v;
        g = t;
        b = p;
        break;
    case 1:
        r = q;
        g = v;
        b = p;
        break;
    case 2:
        r = p;
        g = v;
        b = t;
        break;
    case 3:
        r = p;
        g = q;
        b = v;
        break;
    case 4:
        r = t;
        g = p;
        b = v;
        break;
    case 5:
    default:
        r = v;
        g = p;
        b = q;
        break;
    }
 
    return { convert_val(r), convert_val(g), convert_val(b) };
}
 
}
 
#endif