Color.hpp

Go to the documentation of this file.

#ifndef GL_COLOR_HPP
#define GL_COLOR_HPP

#include <cmath>
#include <unordered_map>
#include <string>
#include <functional>
#include <sstream>
#include <iomanip>

#define GL_FORCE_INTO_RANGE(VAR, LOWER, UPPER) \
  VAR < LOWER ? LOWER : (VAR > UPPER ? UPPER : VAR)

namespace gl
{

class Color
{
public:
  using color_val_t = unsigned char; 
  Color() : r_(0), g_(0), b_(0), a_(100) {}
  Color(const int r, const int g,
        const int b, const int a = 100) : r_(static_cast<color_val_t>(GL_FORCE_INTO_RANGE(r, 0, 255))),
                                          g_(static_cast<color_val_t>(GL_FORCE_INTO_RANGE(g, 0, 255))),
                                          b_(static_cast<color_val_t>(GL_FORCE_INTO_RANGE(b, 0, 255))),
                                          a_(static_cast<color_val_t>(GL_FORCE_INTO_RANGE(a, 0, 100))) {}
  Color(const double r, const double g,
        const double b, const double a = 1.0) : r_(static_cast<color_val_t>(GL_FORCE_INTO_RANGE(r, 0., 1.) * 255)),
                                                g_(static_cast<color_val_t>(GL_FORCE_INTO_RANGE(g, 0., 1.) * 255)),
                                                b_(static_cast<color_val_t>(GL_FORCE_INTO_RANGE(b, 0., 1.) * 255)),
                                                a_(static_cast<color_val_t>(GL_FORCE_INTO_RANGE(a, 0., 1.) * 100)) {}
  explicit Color(const unsigned int hex, const unsigned int a=0x64) : 
    a_(a),
    r_((hex >> 16) & 0xFF),
    g_((hex >> 8) & 0xFF),
    b_((hex) & 0xFF)
  {}
  Color(const char *name, color_val_t a = 100) : a_(a)
  {
    const std::unordered_map<std::string, std::function<void()>> map{
        {"black",   [&]() { hex(0x000000); }},
        {"gray",    [&]() { hex(0x808080); }},
        {"silver",  [&]() { hex(0xC0C0C0); }},
        {"white",   [&]() { hex(0xFFFFFF); }},
        {"orange",  [&]() { hex(0xED9121); }},
        {"maroon",  [&]() { hex(0x800000); }},
        {"red",     [&]() { hex(0xFF0000); }},
        {"olive",   [&]() { hex(0x808000); }},
        {"yellow",  [&]() { hex(0xFFFF00); }},
        {"green",   [&]() { hex(0x008000); }},
        {"lime",    [&]() { hex(0x00FF00); }},
        {"teal",    [&]() { hex(0x008080); }},
        {"aqua",    [&]() { hex(0x00FFFF); }},
        {"navy",    [&]() { hex(0x000080); }},
        {"blue",    [&]() { hex(0x0000FF); }},
        {"purple",  [&]() { hex(0x800080); }},
        {"fuchsia", [&]() { hex(0xFF00FF); }},
    };
    auto it = map.find(name);
    if (it != map.end())
    {
      it->second();
    }
    else
    {
      hex(0xFFFFFF);
    }
  }
  Color(const Color &) = default;                
  Color(Color &&) noexcept = default;            
  Color &operator=(const Color &) = default;     
  Color &operator=(Color &&) noexcept = default; 
  ~Color() = default;                            

  bool operator== (const Color& rhs) const
  {
    return r_ == rhs.r_ 
        && g_ == rhs.g_
        && b_ == rhs.b_
        && a_ == rhs.a_;
  }
  bool operator!= (const Color& rhs) const
  {
    return !operator==(rhs);
  }
  inline std::string RGBA() const
  {
    std::stringstream ss;
    ss << std::setfill('0') << std::setw(8) << std::hex << (hex() | 0);
    return ss.str();
  }
  inline std::string RGB() const
  {
    std::stringstream ss;
    int val = (hex() >> 8) & 0xffffff;
    ss << std::setfill('0') << std::setw(6) << std::hex << (val | 0);
    return ss.str();
  }
  inline int hex() const
  {
    return (r_ << 24) | (g_ << 16) | (b_ << 8) | a_;
  }
  inline color_val_t r() const { return r_; }
  inline color_val_t g() const { return g_; }
  inline color_val_t b() const { return b_; }
  inline color_val_t a() const { return a_; }

  inline void hex(const int hex)
  {
    r_ = (hex >> 16) & 0xFF;
    g_ = (hex >> 8) & 0xFF;
    b_ = (hex) & 0xFF;
  }
  inline void hex(const int hex, const unsigned int a)
  {
    r_ = (hex >> 16) & 0xFF;
    g_ = (hex >> 8) & 0xFF;
    b_ = (hex) & 0xFF;
    a_ = GL_FORCE_INTO_RANGE(a, 0, 100);
  }
  inline void r(color_val_t r) { r_ = r; }
  inline void g(color_val_t g) { g_ = g; }
  inline void b(color_val_t b) { b_ = b; }
  inline void a(color_val_t a) { a_ = a; }

private:
  color_val_t r_, 
              g_, 
              b_, 
              a_; 
};

} // namespace gl

#undef GL_FORCE_INTO_RANGE

#endif // GL_COLOR_HPP