3escolour.h

//
// author Kazys Stepanas
//
// Copyright (c) Kazys Stepanas 2014
//
#ifndef _3ESCOLOUR_H_
#define _3ESCOLOUR_H_

#include "3es-core.h"

#include <cstdint>

namespace tes
{
  class _3es_coreAPI Colour
  {
  public:
    enum Channels
    {
#if TES_IS_BIG_ENDIAN
      R = 0,
      G = 1,
      B = 2,
      A = 3
#else  // TES_IS_BIG_ENDIAN
      A = 0,  
      B = 1,  
      G = 2,  
      R = 3   
#endif // TES_IS_BIG_ENDIAN
    };
    union
    {
      uint32_t c; 

      struct
      {
#if TES_IS_BIG_ENDIAN
        uint8_t r;
        uint8_t g;
        uint8_t b;
        uint8_t a;
#else  // TES_IS_BIG_ENDIAN
        uint8_t a;  
        uint8_t b;  
        uint8_t g;  
        uint8_t r;  
#endif // TES_IS_BIG_ENDIAN
      };
      uint8_t rgba[4];  
    };

    Colour(uint32_t c = 0xffffffffu);

    Colour(const Colour &other);

    Colour(const Colour &other, uint8_t a);
    Colour(const Colour &other, int a);
    Colour(const Colour &other, float a);

    explicit Colour(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255u);

    Colour(int r, int g, int b, int a = 255);

    Colour(float r, float g, float b, float a = 1.0f);

    float rf() const;
    float gf() const;
    float bf() const;
    float af() const;

    void setRf(float f);
    void setGf(float f);
    void setBf(float f);
    void setAf(float f);

    void setf(float f, int index);
    float getf(int index) const;

    Colour adjust(float factor) const;

    inline Colour lighten() const { return adjust(1.5f); }

    inline Colour darken() const { return adjust(0.5f); }

    static void rgbToHsv(float &h, float &s, float &v, const float r, const float g, const float b);

    static void hsvToRgb(float &r, float &g, float &b, const float h, const float s, const float v);
    static void hsvToRgb(uint8_t &r, uint8_t &g, uint8_t &b,
                         const float h, const float s, const float v);

    Colour &operator=(const Colour &other);

    //inline operator uint32_t() const { return c; }

    bool operator==(const Colour &other) const;
    bool operator!=(const Colour &other) const;

    enum Predefined
    {
      // Greys and blacks.
      Gainsboro,
      LightGrey,
      Silver,
      DarkGrey,
      Grey,
      DimGrey,
      LightSlateGrey,
      SlateGrey,
      DarkSlateGrey,
      Black,

      // Whites
      White,
      Snow,
      Honeydew,
      MintCream,
      Azure,
      AliceBlue,
      GhostWhite,
      WhiteSmoke,
      Seashell,
      Beige,
      OldLace,
      FloralWhite,
      Ivory,
      AntiqueWhite,
      Linen,
      LavenderBlush,
      MistyRose,

      // Pinks
      Pink,
      LightPink,
      HotPink,
      DeepPink,
      PaleVioletRed,
      MediumVioletRed,

      // Reds
      LightSalmon,
      Salmon,
      DarkSalmon,
      LightCoral,
      IndianRed,
      Crimson,
      FireBrick,
      DarkRed,
      Red,

      // Oranges
      OrangeRed,
      Tomato,
      Coral,
      DarkOrange,
      Orange,

      // Yellows
      Yellow,
      LightYellow,
      LemonChiffon,
      LightGoldenrodYellow,
      PapayaWhip,
      Moccasin,
      PeachPuff,
      PaleGoldenrod,
      Khaki,
      DarkKhaki,
      Gold,

      // Browns
      Cornsilk,
      BlanchedAlmond,
      Bisque,
      NavajoWhite,
      Wheat,
      BurlyWood,
      Tan,
      RosyBrown,
      SandyBrown,
      Goldenrod,
      DarkGoldenrod,
      Peru,
      Chocolate,
      SaddleBrown,
      Sienna,
      Brown,
      Maroon,

      // Greens
      DarkOliveGreen,
      Olive,
      OliveDrab,
      YellowGreen,
      LimeGreen,
      Lime,
      LawnGreen,
      Chartreuse,
      GreenYellow,
      SpringGreen,
      MediumSpringGreen,
      LightGreen,
      PaleGreen,
      DarkSeaGreen,
      MediumSeaGreen,
      SeaGreen,
      ForestGreen,
      Green,
      DarkGreen,

      // Cyans
      MediumAquamarine,
      Aqua,
      Cyan,
      LightCyan,
      PaleTurquoise,
      Aquamarine,
      Turquoise,
      MediumTurquoise,
      DarkTurquoise,
      LightSeaGreen,
      CadetBlue,
      DarkCyan,
      Teal,

      // Blues
      LightSteelBlue,
      PowderBlue,
      LightBlue,
      SkyBlue,
      LightSkyBlue,
      DeepSkyBlue,
      DodgerBlue,
      CornflowerBlue,
      SteelBlue,
      RoyalBlue,
      Blue,
      MediumBlue,
      DarkBlue,
      Navy,
      MidnightBlue,

      // Purples
      Lavender,
      Thistle,
      Plum,
      Violet,
      Orchid,
      Fuchsia,
      Magenta,
      MediumOrchid,
      MediumPurple,
      BlueViolet,
      DarkViolet,
      DarkOrchid,
      DarkMagenta,
      Purple,
      Indigo,
      DarkSlateBlue,
      SlateBlue,
      MediumSlateBlue,

      PredefinedCount
    };

    enum ColourCycle
    {
      StandardCycle,
      DeuteranomalyCycle,
      ProtanomalyCycle,
      TritanomalyCycle,
      GreyCycle,
      CycleCount
    };

    static const Colour Colours[PredefinedCount];

    static const int *ColourCycles[CycleCount];

    static const int CycleCounts[CycleCount];

    static const Colour &cycle(unsigned number, ColourCycle cycle = StandardCycle);
  };


  inline Colour::Colour(uint32_t c)
    : c(c)
  {
  }


  inline Colour::Colour(const Colour &other)
    : c(other.c)
  {
  }


  inline Colour::Colour(const Colour &other, uint8_t a)
    : c(other.c)
  {
    this->a = a;
  }


  inline Colour::Colour(const Colour &other, int a)
    : c(other.c)
  {
    this->a = a;
  }


  inline Colour::Colour(const Colour &other, float a)
    : c(other.c)
  {
    setAf(a);
  }


  inline Colour::Colour(uint8_t r, uint8_t g, uint8_t b, uint8_t a)
    : r(r), g(g), b(b), a(a)
  {
  }


  inline Colour::Colour(int r, int g, int b, int a)
    : r(uint8_t(r))
    , g(uint8_t(g))
    , b(uint8_t(b))
    , a(uint8_t(a))
  {
  }


  inline Colour::Colour(float r, float g, float b, float a)
  {
    setRf(r);
    setGf(g);
    setBf(b);
    setAf(a);
  }

  inline float Colour::rf() const
  {
    return getf(0);
  }


  inline float Colour::gf() const
  {
    return getf(1);
  }


  inline float Colour::bf() const
  {
    return getf(2);
  }


  inline float Colour::af() const
  {
    return getf(3);
  }


  inline void Colour::setRf(float f)
  {
    setf(f, 0);
  }


  inline void Colour::setGf(float f)
  {
    setf(f, 1);
  }


  inline void Colour::setBf(float f)
  {
    setf(f, 2);
  }


  inline void Colour::setAf(float f)
  {
    setf(f, 3);
  }


  inline void Colour::setf(float f, int index)
  {
    rgba[index] = uint8_t(f * 255.0f);
  }


  inline float Colour::getf(int index) const
  {
    return rgba[index] / 255.0f;
  }


  inline Colour &Colour::operator=(const Colour &other)
  {
    c = other.c;
    return *this;
  }


  inline bool Colour::operator==(const Colour &other) const
  {
    return c == other.c;
  }


  inline bool Colour::operator!=(const Colour &other) const
  {
    return c != other.c;
  }
}

#endif // _3ESCOLOUR_H_