Rgb.hpp

Go to the documentation of this file.

// Copyright 2024-2026 Jan Niklas Hasse <jhasse@bixense.com>
// For conditions of distribution and use, see copyright notice in LICENSE.txt
#pragma once
 
#include <cstddef>
#include <cstdint>
#include <iosfwd>
 
#if __has_include(<format>) && (!defined(_LIBCPP_VERSION) || _LIBCPP_VERSION >= 170000)
#include <format>
#endif
 
namespace jngl {
 
class Color;
 
class Rgb {
public:
    constexpr Rgb(float red, float green, float blue) : red(red), green(green), blue(blue) {
    }
 
    constexpr static Rgb u8(uint8_t red, uint8_t green, uint8_t blue) {
        return Rgb{ static_cast<float>(red) / 255.f, static_cast<float>(green) / 255.f,
                    static_cast<float>(blue) / 255.f };
    }
 
    Rgb(Color); // NOLINT
 
    constexpr float getRed() const {
        return red;
    }
    void setRed(float);
 
    constexpr float getGreen() const {
        return green;
    }
    void setGreen(float);
 
    constexpr float getBlue() const {
        return blue;
    }
    void setBlue(float);
 
    uint8_t getRed_u8() const;
 
    uint8_t getGreen_u8() const;
 
    uint8_t getBlue_u8() const;
 
    explicit operator Color() const;
 
private:
    float red;
    float green;
    float blue;
};
 
Rgb mix(Rgb a, Rgb b, float t);
 
[[deprecated("Use mix instead")]]
inline Rgb interpolate(Rgb a, Rgb b, float t) {
    return mix(a, b, t);
}
 
Rgb getBackgroundColor();
 
bool operator==(Rgb a, Rgb b);
 
std::ostream& operator<<(std::ostream& os, Rgb color);
 
} // namespace jngl
 
#if __has_include(<format>) && (!defined(_LIBCPP_VERSION) || _LIBCPP_VERSION >= 170000)
template <> struct std::formatter<jngl::Rgb> {
    constexpr static auto parse(std::format_parse_context& ctx) {
        return ctx.begin();
    }
    auto format(const jngl::Rgb& c, auto& ctx) const {
        return std::format_to(ctx.out(), "jngl::Rgb{{ {}, {}, {} }}", c.getRed(), c.getGreen(),
                              c.getBlue());
    }
};
#endif
 
jngl::Rgb operator""_rgb(unsigned long long);
 
namespace jngl::internal {
// These are intentionally declared but not defined. When reached in a consteval context,
// the compiler error will include the function name as the diagnostic message.
void invalid_hex_character_in_color_literal();
void invalid_rgb_color_literal_expected_format_hash_rrggbb();
 
consteval uint8_t hexVal(char c) {
    if (c >= '0' && c <= '9') {
        return static_cast<uint8_t>(c - '0');
    }
    if (c >= 'a' && c <= 'f') {
        return static_cast<uint8_t>(c - 'a' + 10);
    }
    if (c >= 'A' && c <= 'F') {
        return static_cast<uint8_t>(c - 'A' + 10);
    }
    invalid_hex_character_in_color_literal();
    return 0;
}
consteval uint8_t hexByte(const char* s) {
    return static_cast<uint8_t>(hexVal(s[0]) * 16 + hexVal(s[1]));
}
} // namespace jngl::internal
 
consteval jngl::Rgb operator""_rgb(const char* hex, size_t length) {
    using jngl::internal::hexByte;
    if (length == 7 && hex[0] == '#') {
        return jngl::Rgb::u8(hexByte(hex + 1), hexByte(hex + 3), hexByte(hex + 5));
    }
    jngl::internal::invalid_rgb_color_literal_expected_format_hash_rrggbb();
    return jngl::Rgb{ 0, 0, 0 };
}