lrgb.hpp

 
#ifndef UFO_VISION_COLOR_LRGB_HPP
#define UFO_VISION_COLOR_LRGB_HPP
 
// UFO
#include <ufo/vision/color/flags.hpp>
 
// STL
#include <concepts>
#include <cstdint>
#include <format>
#include <ostream>
 
namespace ufo
{
template <class T = float, ColorFlags Flags = ColorFlags::None>
  requires(std::integral<T> || std::floating_point<T>)
struct Lrgb;
 
template <class T>
  requires(std::integral<T> || std::floating_point<T>)
struct Lrgb<T, ColorFlags::None> {
    T red;
 
    T green;
 
    T blue;
 
    [[nodiscard]] friend constexpr bool operator==(Lrgb const& a,
                                                   Lrgb const& b) noexcept = default;
};
 
template <class T>
  requires(std::integral<T> || std::floating_point<T>)
struct Lrgb<T, ColorFlags::Alpha> {
    T red;
 
    T green;
 
    T blue;
 
    T alpha;
 
    [[nodiscard]] friend constexpr bool operator==(Lrgb const& a,
                                                   Lrgb const& b) noexcept = default;
};
 
template <class T>
  requires(std::integral<T> || std::floating_point<T>)
struct Lrgb<T, ColorFlags::Weight> {
    T red;
 
    T green;
 
    T blue;
 
    float weight;
 
    [[nodiscard]] friend constexpr bool operator==(Lrgb const& a,
                                                   Lrgb const& b) noexcept = default;
};
 
template <class T>
  requires(std::integral<T> || std::floating_point<T>)
struct Lrgb<T, ColorFlags::Alpha | ColorFlags::Weight> {
    T red;
 
    T green;
 
    T blue;
 
    T alpha;
 
    float weight;
 
    [[nodiscard]] friend constexpr bool operator==(Lrgb const& a,
                                                   Lrgb const& b) noexcept = default;
};
 
template <class T, ColorFlags Flags>
[[nodiscard]] constexpr T red(Lrgb<T, Flags> color) noexcept
{
    if constexpr (weightset(Flags) && std::floating_point<T>) {
        return color.red / static_cast<T>(color.weight);
    } else {
        return color.red;
    }
}
 
template <class T, ColorFlags Flags>
[[nodiscard]] constexpr T green(Lrgb<T, Flags> color) noexcept
{
    if constexpr (weightset(Flags) && std::floating_point<T>) {
        return color.green / static_cast<T>(color.weight);
    } else {
        return color.green;
    }
}
 
template <class T, ColorFlags Flags>
[[nodiscard]] constexpr T blue(Lrgb<T, Flags> color) noexcept
{
    if constexpr (weightset(Flags) && std::floating_point<T>) {
        return color.blue / static_cast<T>(color.weight);
    } else {
        return color.blue;
    }
}
 
using SmallLrgb = Lrgb<std::uint8_t>;
 
using SmallLrgbA = Lrgb<std::uint8_t, ColorFlags::Alpha>;
 
using SmallLrgbW = Lrgb<std::uint8_t, ColorFlags::Weight>;
 
using SmallLrgbAW = Lrgb<std::uint8_t, ColorFlags::Alpha | ColorFlags::Weight>;
 
using FineLrgb = Lrgb<float>;
 
using FineLrgbA = Lrgb<float, ColorFlags::Alpha>;
 
using FineLrgbW = Lrgb<float, ColorFlags::Weight>;
 
using FineLrgbAW = Lrgb<float, ColorFlags::Alpha | ColorFlags::Weight>;
 
template <class T, ColorFlags Flags>
inline std::ostream& operator<<(std::ostream& out, Lrgb<T, Flags> const& c)
{
    out << "Red: " << +c.red << " Green: " << +c.green << " Blue: " << +c.blue;
    if constexpr (alphaset(Flags)) {
        out << " Alpha: " << +c.alpha;
    }
    if constexpr (weightset(Flags)) {
        out << " Weight: " << c.weight;
    }
    return out;
}
 
}  // namespace ufo
 
template <class T, ufo::ColorFlags Flags>
struct std::formatter<ufo::Lrgb<T, Flags>> {
    constexpr auto parse(std::format_parse_context& ctx) { return ctx.begin(); }
 
    auto format(ufo::Lrgb<T, Flags> const& c, std::format_context& ctx) const
    {
        auto out = std::format_to(ctx.out(), "Red: {} Green: {} Blue: {}", +c.red, +c.green,
                                  +c.blue);
        if constexpr (ufo::alphaset(Flags)) {
            out = std::format_to(out, " Alpha: {}", +c.alpha);
        }
        if constexpr (ufo::weightset(Flags)) {
            out = std::format_to(out, " Weight: {}", c.weight);
        }
        return out;
    }
};
 
#endif  // UFO_VISION_COLOR_LRGB_HPP