color.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_COLOR_H
#define EGT_COLOR_H
 
#include <array>
#include <cmath>
#include <cstdint>
#include <egt/detail/math.h>
#include <egt/detail/meta.h>
#include <egt/detail/string.h>
#include <initializer_list>
#include <iosfwd>
#include <map>
#include <string>
#include <utility>
#include <vector>
 
namespace egt
{
inline namespace v1
{
 
class EGT_API Color
{
public:
 
    using RGBType = uint32_t;
    using RGBAType = uint32_t;
    using ComponentType = uint32_t;
 
    constexpr Color() = default;
 
    explicit constexpr Color(RGBAType c) noexcept
        : m_rgba
    {
 
        (c >> 24u) & 0xffu,
        (c >> 16u) & 0xffu,
        (c >> 8u) & 0xffu,
        c & 0xffu
    }
    {}
 
    constexpr Color(const Color& color, ComponentType alpha) noexcept
        : m_rgba
    {
        color.m_rgba[0],
                     color.m_rgba[1],
                     color.m_rgba[2],
                     alpha
    }
    {}
 
    constexpr explicit Color(ComponentType r, ComponentType g, ComponentType b, ComponentType a = 255) noexcept
        : m_rgba
    {
        r & 0xffu,
        g & 0xffu,
        b & 0xffu,
        a & 0xffu
    }
    {}
 
 
    EGT_NODISCARD constexpr float redf() const { return m_rgba[0] / 255.f; }
    EGT_NODISCARD constexpr float greenf() const { return m_rgba[1] / 255.f; }
    EGT_NODISCARD constexpr float bluef() const { return m_rgba[2] / 255.f; }
    EGT_NODISCARD constexpr float alphaf() const { return m_rgba[3] / 255.f; }
 
 
    constexpr void redf(float v) { m_rgba[0] = detail::clamp(v, 0.f, 1.f) * 255.f; }
    constexpr void greenf(float v) { m_rgba[1] = detail::clamp(v, 0.f, 1.f) * 255.f; }
    constexpr void bluef(float v) { m_rgba[2] = detail::clamp(v, 0.f, 1.f) * 255.f; }
    constexpr void alphaf(float v) { m_rgba[3] = detail::clamp(v, 0.f, 1.f) * 255.f; }
 
 
    EGT_NODISCARD constexpr ComponentType red() const { return assert(m_rgba[0] <= 255), m_rgba[0]; }
    EGT_NODISCARD constexpr ComponentType green() const { return assert(m_rgba[1] <= 255), m_rgba[1]; }
    EGT_NODISCARD constexpr ComponentType blue() const { return assert(m_rgba[2] <= 255), m_rgba[2]; }
    EGT_NODISCARD constexpr ComponentType alpha() const { return assert(m_rgba[3] <= 255), m_rgba[3]; }
 
 
    constexpr void red(ComponentType r) { m_rgba[0] = r & 0xffu; }
    constexpr void green(ComponentType g) { m_rgba[1] = g & 0xffu; }
    constexpr void blue(ComponentType b) { m_rgba[2] = b & 0xffu; }
    constexpr void alpha(ComponentType a) { m_rgba[3] = a & 0xffu; }
 
    EGT_NODISCARD constexpr uint16_t pixel16() const
    {
        const uint16_t b = (blue() >> 3u) & 0x1fu;
        const uint16_t g = ((green() >> 2u) & 0x3fu) << 5u;
        const uint16_t r = ((red() >> 3u) & 0x1fu) << 11u;
 
        return static_cast<uint16_t>(r | g | b);
    }
 
    EGT_NODISCARD static constexpr Color pixel16(uint16_t c)
    {
        const uint16_t b = (c) & 0x1fu;
        const uint16_t g = (c >> 5u) & 0x3fu;
        const uint16_t r = (c >> 11u) & 0x1fu;
 
        return Color(r, g, b, 0xffu);
    }
 
    EGT_NODISCARD constexpr RGBAType pixel24() const
    {
        return (red() << 16u) |
               (green() << 8u) |
               blue() |
               (0xff);
    }
 
    EGT_NODISCARD static constexpr Color pixel24(RGBAType c)
    {
        return Color((c >> 16u) & 0xffu,
                     (c >> 8u) & 0xffu,
                     c & 0xffu,
                     0xffu);
    }
 
    EGT_NODISCARD constexpr RGBAType pixel32() const
    {
        return (red() << 16u) |
               (green() << 8u) |
               blue() |
               (alpha() << 24u);
    }
 
    EGT_NODISCARD static constexpr Color pixel32(RGBAType c)
    {
        return Color((c >> 16u) & 0xffu,
                     (c >> 8u) & 0xffu,
                     c & 0xffu,
                     (c >> 24u) & 0xffu);
    }
 
    void get_hsvf(float& h, float& s, float& v, float* alpha = nullptr);
 
    void get_hslf(float& h, float& s, float& l, float* alpha = nullptr);
 
    void get_rgbaf(float& r, float& g, float& b, float* alpha = nullptr);
 
    EGT_NODISCARD static constexpr Color rgb(RGBType c, ComponentType alpha = 255) noexcept
    {
        return Color(c << 8u | alpha);
    }
 
    EGT_NODISCARD static constexpr Color rgbaf(float r, float g, float b, float a = 1.0)
    {
        Color result;
        result.redf(r);
        result.greenf(g);
        result.bluef(b);
        result.alphaf(a);
        return result;
    }
 
    EGT_NODISCARD static Color css(const std::string& hex)
    {
        return css(hex.c_str());
    }
 
    EGT_NODISCARD constexpr static Color css(const char* hex)
    {
        return Color((detail::hextoul(hex) << 8) | 0xff);
    }
 
    EGT_NODISCARD std::string hex() const;
 
    EGT_NODISCARD static Color hsvf(float h, float s, float v, float alpha = 1.0);
 
    EGT_NODISCARD static Color hslf(float h, float s, float l, float alpha = 1.0);
 
    EGT_NODISCARD constexpr Color shade(float factor) const
    {
        return Color(red() * (1.0f - factor),
                     green() * (1.0f - factor),
                     blue() * (1.0f - factor),
                     alpha());
    }
 
    EGT_NODISCARD constexpr Color tint(float factor) const
    {
        return Color(red() + ((255 - red()) * factor),
                     green() + ((255 - green()) * factor),
                     blue() + ((255 - blue()) * factor),
                     alpha());
    }
 
    EGT_NODISCARD Color hue(float h) const
    {
        auto u = std::cos(h * detail::pi<float>() / 180.0f);
        auto w = std::sin(h * detail::pi<float>() / 180.0f);
 
        Color ret;
        ret.red((0.299f + 0.701f * u + 0.168f * w) * red()
                + (0.587f - 0.587f * u + 0.330f * w) * green()
                + (0.114f - 0.114f * u - 0.497f * w) * blue());
        ret.green((0.299f - 0.299f * u - 0.328f * w) * red()
                  + (0.587f + 0.413f * u + 0.035f * w) * green()
                  + (0.114f - 0.114f * u + 0.292f * w) * blue());
        ret.blue((0.299f - 0.3f * u + 1.25f * w) * red()
                 + (0.587f - 0.588f * u - 1.05f * w) * green()
                 + (0.114f + 0.886f * u - 0.203f * w) * blue());
        return ret;
    }
 
    Color& operator=(RGBAType c)
    {
        m_rgba[0] = (c >> 24u) & 0xffu;
        m_rgba[1] = (c >> 16u) & 0xffu;
        m_rgba[2] = (c >> 8u) & 0xffu;
        m_rgba[3] = c & 0xffu;
 
        return *this;
    }
 
    template<class T>
    constexpr Color operator+(T scalar) const
    {
        return Color::rgbaf(redf() + scalar,
                            greenf() + scalar,
                            bluef() + scalar,
                            alphaf() + scalar);
    }
 
    template<class T>
    constexpr Color operator-(T scalar) const
    {
        return Color::rgbaf(redf() - scalar,
                            greenf() - scalar,
                            bluef() - scalar,
                            alphaf() - scalar);
    }
 
    template<class T>
    constexpr Color operator*(T scalar) const
    {
        return Color::rgbaf(redf() * scalar,
                            greenf() * scalar,
                            bluef() * scalar,
                            alphaf() * scalar);
    }
 
    template<class T>
    constexpr Color operator/(T scalar) const
    {
        return Color::rgbaf(redf() / scalar,
                            greenf() / scalar,
                            bluef() / scalar,
                            alphaf() / scalar);
    }
 
    constexpr Color operator+(const Color& rhs) const
    {
        return Color::rgbaf(redf() + rhs.redf(),
                            greenf() + rhs.greenf(),
                            bluef() + rhs.bluef(),
                            alphaf() + rhs.alphaf());
    }
 
    constexpr Color operator-(const Color& rhs) const
    {
        return Color::rgbaf(redf() - rhs.redf(),
                            greenf() - rhs.greenf(),
                            bluef() - rhs.bluef(),
                            alphaf() - rhs.alphaf());
    }
 
    Color operator*(const Color& rhs) const
    {
        return Color::rgbaf(redf() * rhs.redf(),
                            greenf() * rhs.greenf(),
                            bluef() * rhs.bluef(),
                            alphaf() * rhs.alphaf());
    }
 
    constexpr Color operator/(const Color& rhs) const
    {
        return Color::rgbaf(redf() / rhs.redf(),
                            greenf() / rhs.greenf(),
                            bluef() / rhs.bluef(),
                            alphaf() / rhs.alphaf());
    }
 
    static Color interp_hsv(const Color& a, const Color& b, float t);
 
    static Color interp_hsl(const Color& a, const Color& b, float t);
 
    static Color interp_rgba(const Color& a, const Color& b, float t);
 
protected:
 
    ComponentType m_rgba[4] {};
};
 
static_assert(detail::rule_of_5<Color>(), "must fulfill rule of 5");
 
constexpr bool operator==(const Color& lhs, const Color& rhs)
{
    return lhs.red() == rhs.red() &&
           lhs.green() == rhs.green() &&
           lhs.blue() == rhs.blue() &&
           lhs.alpha() == rhs.alpha();
}
 
constexpr bool operator!=(const Color& lhs, const Color& rhs)
{
    return !(lhs == rhs);
}
 
template<class T>
constexpr Color operator+(T scalar, const Color& rhs)
{
    return Color::rgbaf(rhs.redf() + scalar,
                        rhs.greenf() + scalar,
                        rhs.bluef() + scalar,
                        rhs.alphaf() + scalar);
}
 
template<class T>
constexpr Color operator-(T scalar, const Color& rhs)
{
    return Color::rgbaf(rhs.redf() - scalar,
                        rhs.greenf() - scalar,
                        rhs.bluef() - scalar,
                        rhs.alphaf() - scalar);
}
 
template<class T>
constexpr Color operator*(T scalar, const Color& rhs)
{
    return Color::rgbaf(rhs.redf() * scalar,
                        rhs.greenf() * scalar,
                        rhs.bluef() * scalar,
                        rhs.alphaf() * scalar);
}
 
template<class T>
constexpr Color operator/(T scalar, const Color& rhs)
{
    return Color::rgbaf(rhs.redf() / scalar,
                        rhs.greenf() / scalar,
                        rhs.bluef() / scalar,
                        rhs.alphaf() / scalar);
}
 
EGT_API std::ostream& operator<<(std::ostream& os, const Color& color);
 
namespace experimental
{
 
class EGT_API ColorMap
{
public:
 
    enum class Interpolation
    {
        rgba,
        hsv,
        hsl
    };
 
    using StepsArray = std::vector<Color>;
 
    explicit ColorMap(Interpolation interp) noexcept
        : m_interp(interp)
    {}
 
    explicit ColorMap(StepsArray steps, Interpolation interp = Interpolation::rgba)
        : m_steps(std::move(steps)),
          m_interp(interp)
    {}
 
    template<class T>
    explicit ColorMap(std::initializer_list<T> steps, Interpolation interp = Interpolation::rgba)
        : m_interp(interp)
    {
        m_steps.insert(m_steps.end(), steps.begin(), steps.end());
    }
 
    void step(const Color& color)
    {
        m_steps.emplace_back(color);
        for (auto& x : m_cache)
            x.clear();
    }
 
    void steps(const StepsArray& steps)
    {
        m_steps = steps;
        for (auto& x : m_cache)
            x.clear();
    }
 
    Color interp(float t) const;
 
    Color interp_cached(float t, size_t accuracy = 1000) const;
 
    const StepsArray& steps() const { return m_steps; }
 
    bool empty() const { return m_steps.empty(); }
 
    size_t count() const { return m_steps.size(); }
 
protected:
 
    StepsArray m_steps;
 
    mutable std::array<std::map<size_t, Color>, 3> m_cache{};
 
    Interpolation m_interp{Interpolation::rgba};
};
 
}
 
}
}
 
#endif