Color.h

Go to the documentation of this file.

#pragma once
 
#include <string.h>
#include <vector>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <stdint.h>
#include <stdexcept>
 
#include "../Types.h"
 
namespace Gorgon { namespace Graphics {
 
    enum class ColorMode {
        Invalid = 0,
 
        Automatic = 0,
 
        RGB = 1,
 
        BGR = 16,
 
        Grayscale = 4,
 
        Alpha = 8,
 
        RGBA = RGB | Alpha,
 
        BGRA = BGR | Alpha,
 
        Grayscale_Alpha = Grayscale | Alpha
    };
 
    inline unsigned long GetChannelsPerPixel(ColorMode mode) {
        switch(mode) {
        case ColorMode::Grayscale:
        case ColorMode::Alpha:
            return 1;
        case ColorMode::Grayscale_Alpha:
            return 2;
        case ColorMode::BGR:
        case ColorMode::RGB:
            return 3;
        case ColorMode::RGBA:
        case ColorMode::BGRA:
            return 4;
        default:
#ifndef NDEBUG
            throw std::runtime_error("Unknown mode");
#endif
            return 0;
        }
    }
 
    inline bool HasAlpha(ColorMode mode) {
        return ((int)mode & (int)ColorMode::Alpha) != 0;
    }
 
    inline int GetAlphaIndex(ColorMode mode) {
        switch(mode) {
            case ColorMode::Alpha:
                return 0;
            case ColorMode::Grayscale_Alpha:
                return 1;
            case ColorMode::RGBA:
            case ColorMode::BGRA:
                return 3;
            default:
                return -1;
        }
    }
 
    class RGBA {
    public:
        typedef Byte ChannelType;
        
        // cppcheck-suppress uninitMemberVar
        RGBA() {}
 
        RGBA(const RGBA &) = default;
 
        RGBA(const RGBA &other, Byte newalpha) : R(other.R), G(other.G), B(other.B), A(newalpha) {}
 
        RGBA(const RGBA &other, int newalpha) : R(other.R), G(other.G), B(other.B), A(Byte(newalpha)) {}
 
        RGBA(const RGBA &other, double newalpha) : R(other.R), G(other.G), B(other.B), A(Byte(255*newalpha)) {}
 
        RGBA(const RGBA &other, float newalpha) : R(other.R), G(other.G), B(other.B), A(Byte(255*newalpha)) {}
        
        RGBA(const RGBA &first, const RGBA &second, float alpha = 1.0f) : RGBA(first) {
            Blend(second, alpha);
        }
        
        RGBA(const RGBA &first, const RGBA &second, double alpha) : RGBA(first) {
            Blend(second, (float)alpha);
        }
        
        RGBA(const RGBA &first, const RGBA &second, int alpha) : RGBA(first, second, alpha/255.f) { }
 
        RGBA(Byte r, Byte g, Byte b, Byte a=255) : R(r), G(g), B(b), A(a) {}
 
        explicit RGBA(Byte lum, Byte a=255) : RGBA(lum, lum, lum, a) {}
 
        explicit RGBA(int lum, int a) : RGBA(Byte(lum), Byte(lum), Byte(lum), Byte(a)) {}
 
        // cppcheck-suppress noExplicitConstructor
        constexpr RGBA(int color) : R((color>>0)&0xff), G((color>>8)&0xff), B((color>>16)&0xff), A((color>>24)&0xff) {
            static_assert(sizeof(int)>=4, "This conversion requires size of int to be at least 4 bytes");
        }
 
        // cppcheck-suppress noExplicitConstructor
        constexpr RGBA(uint32_t color) : R((color>>0)&0xff), G((color>>8)&0xff), B((color>>16)&0xff), A((color>>24)&0xff) {
            static_assert(sizeof(int)>=4, "This conversion requires size of int to be at least 4 bytes");
        }
 
        explicit RGBA(float lum) : A(255) {
            if(lum<0) lum=0;
            if(lum>1) lum=1;
 
            R=G=B=Byte(lum*255);
        }
 
        explicit RGBA(double lum) : A(255) {
            if(lum<0) lum=0;
            if(lum>1) lum=1;
 
            R=G=B=Byte(lum*255);
        }
 
        operator int() const {
            static_assert(sizeof(int)>=4, "This conversion requires size of int to be at least 4 bytes");
 
            int ret;
            memcpy(&ret, this, 4);
 
            return ret;
        }
 
        operator uint32_t() const {
            uint32_t ret;
            memcpy(&ret, this, 4);
 
            return ret;
        }
 
        RGBA &operator =(const RGBA &) = default;
 
        RGBA &operator =(const int &color) {
            static_assert(sizeof(int)>=4, "This conversion requires size of int to be at least 4 bytes");
 
            memcpy(this, &color, 4);
            
            return *this;
        }
 
        RGBA &operator =(const uint32_t &color) {
            memcpy(this, &color, 4);
            
            return *this;
        }
 
        RGBA &operator =(float lum) {
            if(lum<0) lum=0;
            if(lum>1) lum=1;
 
            R=G=B=Byte(lum*255);
            A=255;
            
            return *this;
        }
 
        bool operator==(const RGBA &other) const {
            return (int)(*this) == (uint32_t)other;
        }
 
        bool operator!=(const RGBA &other) const {
            return (uint32_t)(*this) != (uint32_t)other;
        }
 
        Byte Luminance() const {
            return (R>>3) + (R>>4) + (R>>5) + (G>>1) + (G>>3) + (G>>4) + (G>>5) + (B>>4) + (B>>5);
        }
 
        float AccurateLuminance() const {
            return  (0.2126f/255)*R + (0.7151f/255)*G + (0.0722f/255)*B;
        }
 
        std::string HTMLColor() const {
            std::stringstream str;
 
            str<<"#"<<std::fixed<<std::setfill('0')<<std::setw(2)<<R<<std::setw(2)<<G<<std::setw(2)<<B;
 
            return str.str();
        }
 
        void Blend(const RGBA &color) {
            Blend(color, 1.0f);
        }
 
        void Blend(const RGBA &color, float alpha) {
            if (color.A * alpha == 255) {
                A = 255;
                R = color.R;
                G = color.G;
                B = color.B;
            }
            else {
                float a = color.A*alpha / 255;
                float alpham1 = (1 - a);
 
                alpham1 *= A / 255.f;
                    
                float aa = a + A/255.f * (1 - a);
 
                if(aa > 0) {
                    R = Byte((R*alpham1 + color.R*a)/aa);
                    G = Byte((G*alpham1 + color.G*a)/aa);
                    B = Byte((B*alpham1 + color.B*a)/aa);
                }
                A = Byte(aa*255);
            }
        }
        
        RGBA BlendWith(const RGBA &color) const {
            auto n = *this;
            n.Blend(color);
            return n;
        }
        
        RGBA BlendWith(const RGBA &color, float alpha) const {
            auto n = *this;
            n.Blend(color, alpha);
            return n;
        }
 
        operator std::string() const {
            std::stringstream str;
            str<<std::fixed<<std::setw(8)<<std::setfill('0')<<std::hex<<((const uint32_t)(*this));
 
            return str.str();
        }
 
 
 
        Byte R;
 
        Byte G;
 
        Byte B;
 
        Byte A;
 
        // Maximum value for this color type, activate after c++14 support
        // static const Byte Max = 255;
    };
 
    inline std::ostream &operator <<(std::ostream &stream, const RGBA &color) {
        stream<<(std::string)color;
 
        return stream;
    }
 
    inline std::istream &operator>>(std::istream &in, RGBA &color) {
        while(isspace(in.peek())) in.ignore();
 
        if(in.peek()=='#') {
            color.A=255;
            in.ignore(1);
 
            auto flags=in.flags();
            in>>std::hex>>color.R>>color.G>>color.B;
            in.flags(flags);
        }
        else {
            if(in.peek()=='0') {
                in.ignore();
                if(in.peek()=='x') {
                    in.ignore();
                }
                else {
                    in.clear();
                }
            }
 
            auto flags=in.flags();
            in>>std::hex>>(*(unsigned int*)&color);
            in.flags(flags);
        }
        return in;
    }
    
    inline RGBA Blend(RGBA first, const RGBA &second) {
        first.Blend(second);
        
        return first;
    }
    
    inline RGBA Blend(RGBA first, const RGBA &second, float alpha) {
        first.Blend(second, alpha);
        
        return first;
    }
 
    class RGBAf {
    public:
        typedef float ChannelType;
 
 
        RGBAf() { }
 
        RGBAf(float r, float g, float b, float a=1.f) : R(r), G(g), B(b), A(a) { }
 
        // cppcheck-suppress noExplicitConstructor
        RGBAf(float lum, float a=1.0f) : RGBAf(lum, lum, lum, a) { }
 
        explicit RGBAf(double lum, float a=1.0f) : RGBAf((float)lum, (float)lum, (float)lum, a) { }
 
        // cppcheck-suppress noExplicitConstructor
        RGBAf(const RGBA &color) : R(color.R/255.f), G(color.G/255.f), B(color.B/255.f), A(color.A/255.f) { }
 
        RGBAf(const RGBA &color, float alpha) : R(color.R/255.f), G(color.G/255.f), B(color.B/255.f), A(color.A/255.f * alpha) { }
 
        RGBAf(const RGBA &color, double alpha) : R(color.R/255.f), G(color.G/255.f), B(color.B/255.f), A(float(color.A/255. * alpha)) { }
 
        // cppcheck-suppress noExplicitConstructor
        RGBAf(unsigned color) : RGBAf(RGBA(color)) { }
 
        RGBAf(int) = delete;
 
        RGBAf(bool) = delete;
 
        RGBAf &operator = (const RGBAf &) = default;
 
        RGBAf &operator =(const RGBA &color) {
            R = color.R/255.f;
            G = color.G/255.f;
            B = color.B/255.f;
            A = color.A/255.f;
            
            return *this;
        }
 
        RGBAf &operator =(const int &color) {
            return (*this = RGBA(color));
        }
 
        RGBAf &operator =(float lum) {
            R = lum;
            G = lum;
            B = lum;
            A = 1;
 
            return *this;
        }
 
        RGBAf &operator =(double lum) {
            R = (float)lum;
            G = (float)lum;
            B = (float)lum;
            A = 1;
 
            return *this;
        }
 
        explicit operator RGBA() const {
            return{Byte(R*255), Byte(G*255), Byte(B*255), Byte(A*255)};
        }
 
        explicit operator int() const {
            return int(this->operator RGBA());
        }
 
        operator std::string() const {
            std::stringstream ss;
 
            ss<<"("<<R<<", "<<G<<", "<<B<<", "<<A<<")";
 
            return ss.str();
        }
        
        RGBAf operator *(const RGBAf &other) const {
            return {R * other.R, G * other.G, B * other.B, A * other.A};
        }
        
        RGBAf &operator *=(const RGBAf &other) {
            R *= other.R;
            G *= other.G;
            B *= other.B;
            A *= other.A;
            
            return *this;
        }
 
        RGBA Convert() const { 
            return{
                Byte(R<0.f ? 0 : (R>1.f ? 255 : R*255)), 
                Byte(G<0.f ? 0 : (G>1.f ? 255 : G*255)),
                Byte(B<0.f ? 0 : (B>1.f ? 255 : B*255)),
                Byte(A<0.f ? 0 : (A>1.f ? 255 : A*255))
            };
        }
 
        float Luminance() const {
            return  0.2126f*R + 0.7151f*G + 0.0722f*B;
        }
 
        bool operator ==(const RGBAf &other) const {
            return R==other.R && G==other.G && B==other.B && A==other.A;
        }
 
        bool operator !=(const RGBAf &other) const {
            return R!=other.R || G!=other.G || B!=other.B || A!=other.A;
        }
 
        void Blend(const RGBAf &color) {
            if(color.A==1.f) {
                A=1.f;
                R=color.R;
                G=color.G;
                B=color.B;
            }
            else {
                float alpham1=1.f-color.A;
 
                R=R*alpham1*A + color.R*color.A;
                G=G*alpham1*A + color.G*color.A;
                B=B*alpham1*A + color.B*color.A;
                A = color.A + A * alpham1;
                
                R /= A;
                G /= A;
                B /= A;
            }
        }
 
        void Blend(const RGBAf &color, float factor) {
            if(color.A==1.f) {
                A=1.f;
                R=color.R;
                G=color.G;
                B=color.B;
            }
            else {
                float a = color.A*factor;
                float alpham1=1.f-a;
 
                R=R*alpham1 * A + color.R * a;
                G=G*alpham1 * A + color.G * a;
                B=B*alpham1 * A + color.B * a;
                A = color.A + A * alpham1;
                
                R /= A;
                G /= A;
                B /= A;
            }
        }
 
        void Slide(const RGBAf &color, float factor) {
            auto ma = 1 - factor;
 
            R = ma * R + factor * color.R;
            G = ma * G + factor * color.G;
            B = ma * B + factor * color.B;
            A = ma * A + factor * color.A;
        }
        
        void Slide(const RGBAf &color, float factor_color, float factor_alpha) {
            auto mc = 1 - factor_color;
            auto ma = 1 - factor_alpha;
 
            R = mc * R + factor_color * color.R;
            G = mc * G + factor_color * color.G;
            B = mc * B + factor_color * color.B;
            A = ma * A + factor_alpha * color.A;
        }
 
        void Slide(const RGBAf &color, const RGBAf &factor) {
            R = (1 - factor.R) * R + factor.R * color.R;
            G = (1 - factor.G) * G + factor.G * color.G;
            B = (1 - factor.B) * B + factor.B * color.B;
            A = (1 - factor.A) * A + factor.A * color.A;
        }
 
        union {
            struct {
                float R;
 
                float G;
 
                float B;
 
                float A;
            };
 
            float Vector[4];
        };
 
        // Maximum value for this color type, activate after c++14 support
        // static const float Max = 1.0f;
    };
 
    inline std::ostream &operator <<(std::ostream &stream, const RGBAf &color) {
        stream<<(std::string)color;
 
        return stream;
    }
 
    namespace Color {
        constexpr RGBA Purple   = 0xff9c1e7e;
        constexpr RGBA Green    = 0xff1ab015;
        constexpr RGBA Blue = 0xffdf4303;
        constexpr RGBA Pink = 0xffc081ff;
        constexpr RGBA Brown    = 0xff003765;
        constexpr RGBA Red  = 0xff0000e5;
        constexpr RGBA LightBlue    = 0xfffcd095;
        constexpr RGBA Teal = 0xff869302;
        constexpr RGBA Orange   = 0xff0673f9;
        constexpr RGBA LightGreen   = 0xff7bf996;
        constexpr RGBA Magenta  = 0xff7800c2;
        constexpr RGBA Yellow   = 0xff14ffff;
        constexpr RGBA SkyBlue  = 0xfffdbb75;
        constexpr RGBA Grey = 0xff919592;
        constexpr RGBA LimeGreen    = 0xff05fe89;
        constexpr RGBA LightPurple  = 0xfff677bf;
        constexpr RGBA Violet   = 0xffea0e9a;
        constexpr RGBA DarkGreen    = 0xff003503;
        constexpr RGBA Turquoise    = 0xffacc206;
        constexpr RGBA Lavender = 0xffef9fc7;
        constexpr RGBA DarkBlue = 0xff5b0300;
        constexpr RGBA Tan  = 0xff6fb2d1;
        constexpr RGBA Cyan = 0xffffff00;
        constexpr RGBA Aqua = 0xffc9ea13;
        constexpr RGBA ForestGreen  = 0xff0c4706;
        constexpr RGBA Mauve    = 0xff8171ae;
        constexpr RGBA DarkPurple   = 0xff3e0635;
        constexpr RGBA BrightGreen  = 0xff07ff01;
        constexpr RGBA Maroon   = 0xff210065;
        constexpr RGBA Olive    = 0xff0e756e;
        constexpr RGBA Salmon   = 0xff6c79ff;
        constexpr RGBA Beige    = 0xffa6dae6;
        constexpr RGBA RoyalBlue    = 0xffaa0405;
        constexpr RGBA NavyBlue = 0xff461100;
        constexpr RGBA Lilac    = 0xfffda2ce;
        constexpr RGBA Black    = 0xff000000;
        constexpr RGBA HotPink  = 0xff8d02ff;
        constexpr RGBA LightBrown   = 0xff5081ad;
        constexpr RGBA PaleGreen    = 0xffb5fdc7;
        constexpr RGBA Peach    = 0xff7cb0ff;
        constexpr RGBA OliveGreen   = 0xff047a67;
        constexpr RGBA DarkPink = 0xff6b41cb;
        constexpr RGBA Periwinkle   = 0xfffe828e;
        constexpr RGBA SeaGreen = 0xffa1fc53;
        constexpr RGBA Lime = 0xff32ffaa;
        constexpr RGBA Indigo   = 0xff820238;
        constexpr RGBA Mustard  = 0xff01b3ce;
        constexpr RGBA LightPink    = 0xffdfd1ff;
        constexpr RGBA Rose = 0xff7562cf;
        constexpr RGBA BrightBlue   = 0xfffc6501;
        constexpr RGBA NeonGreen    = 0xff0cff0c;
        constexpr RGBA BurntOrange  = 0xff014ec0;
        constexpr RGBA Aquamarine   = 0xffb2d804;
        constexpr RGBA Navy = 0xff3e1501;
        constexpr RGBA GrassGreen   = 0xff0b9b3f;
        constexpr RGBA PaleBlue = 0xfffefed0;
        constexpr RGBA DarkRed  = 0xff000084;
        constexpr RGBA BrightPurple = 0xfffd03be;
        constexpr RGBA YellowGreen  = 0xff2dfbc0;
        constexpr RGBA BabyBlue = 0xfffecfa2;
        constexpr RGBA Gold = 0xff0cb4db;
        constexpr RGBA MintGreen    = 0xff9fff8f;
        constexpr RGBA Plum = 0xff410f58;
        constexpr RGBA RoyalPurple  = 0xff6e004b;
        constexpr RGBA BrickRed = 0xff02148f;
        constexpr RGBA DarkTeal = 0xff4e4d01;
        constexpr RGBA Burgundy = 0xff230061;
        constexpr RGBA Khaki    = 0xff62a6aa;
        constexpr RGBA BlueGreen    = 0xff6d7e13;
        constexpr RGBA SeafoamGreen = 0xffabf97a;
        constexpr RGBA PeaGreen = 0xff12ab8e;
        constexpr RGBA Taupe    = 0xff81a2b9;
        constexpr RGBA DarkBrown    = 0xff021c34;
        constexpr RGBA DeepPurple   = 0xff3f0136;
        constexpr RGBA Chartreuse   = 0xff0af8c1;
        constexpr RGBA BrightPink   = 0xffb101fe;
        constexpr RGBA LightOrange  = 0xff48aafd;
        constexpr RGBA Mint = 0xffb0fe9f;
        constexpr RGBA PastelGreen  = 0xff9dffb0;
        constexpr RGBA Sand = 0xff76cae2;
        constexpr RGBA DarkOrange   = 0xff0251c6;
        constexpr RGBA SpringGreen  = 0xff71f9a9;
        constexpr RGBA Puce = 0xff527ea5;
        constexpr RGBA Seafoam  = 0xffadf980;
        constexpr RGBA GreyBlue = 0xffa48b6b;
        constexpr RGBA ArmyGreen    = 0xff165d4b;
        constexpr RGBA DarkGrey = 0xff373736;
        constexpr RGBA DarkYellow   = 0xff0ab6d5;
        constexpr RGBA Goldenrod    = 0xff05c2fa;
        constexpr RGBA Slate    = 0xff726551;
        constexpr RGBA LightTeal    = 0xffc1e490;
        constexpr RGBA Rust = 0xff093ca8;
        constexpr RGBA DeepBlue = 0xff730204;
        constexpr RGBA PalePink = 0xffdccfff;
        constexpr RGBA Cerulean = 0xffd18504;
        constexpr RGBA LightRed = 0xff4c47ff;
        constexpr RGBA MustardYellow    = 0xff0abdd2;
        constexpr RGBA Ochre    = 0xff0590bf;
        constexpr RGBA PaleYellow   = 0xff84ffff;
        constexpr RGBA Crimson  = 0xff0f008c;
        constexpr RGBA Fuchsia  = 0xffd90ded;
        constexpr RGBA HunterGreen  = 0xff08400b;
        constexpr RGBA BlueGrey = 0xff8e7c60;
        constexpr RGBA SlateBlue    = 0xff997c5b;
        constexpr RGBA PalePurple   = 0xffd490b7;
        constexpr RGBA SeaBlue  = 0xff957404;
        constexpr RGBA PinkishPurple    = 0xffd748d6;
        constexpr RGBA LightGrey    = 0xffd6dcd8;
        constexpr RGBA LeafGreen    = 0xff04a95c;
        constexpr RGBA LightYellow  = 0xff7afeff;
        constexpr RGBA Eggplant = 0xff350838;
        constexpr RGBA SteelBlue    = 0xff9a7d5a;
        constexpr RGBA MossGreen    = 0xff388b65;
        constexpr RGBA White    = 0xffffffff;
        constexpr RGBA GreyGreen    = 0xff739b78;
        constexpr RGBA Sage = 0xff73ae87;
        constexpr RGBA Brick    = 0xff2336a0;
        constexpr RGBA BurntSienna  = 0xff0f4eb0;
        constexpr RGBA ReddishBrown = 0xff0a2b7f;
        constexpr RGBA Cream    = 0xffc2ffff;
        constexpr RGBA Coral    = 0xff505afc;
        constexpr RGBA OceanBlue    = 0xff9c7103;
        constexpr RGBA Greenish = 0xff68a340;
        constexpr RGBA DarkMagenta  = 0xff560096;
        constexpr RGBA RedOrange    = 0xff063cfd;
        constexpr RGBA BluishPurple = 0xffe73b70;
        constexpr RGBA MidnightBlue = 0xff350002;
        constexpr RGBA LightViolet  = 0xfffcb4d6;
        constexpr RGBA DustyRose    = 0xff7a73c0;
        constexpr RGBA GreenishYellow   = 0xff02fdcd;
        constexpr RGBA YellowishGreen   = 0xff16ddb0;
        constexpr RGBA PurplishBlue = 0xfff91e60;
        constexpr RGBA GreyishBlue  = 0xff9d815e;
        constexpr RGBA Grape    = 0xff61346c;
        constexpr RGBA LightOlive   = 0xff69bfac;
        constexpr RGBA CornflowerBlue   = 0xffd77051;
        constexpr RGBA PinkishRed   = 0xff450cf1;
        constexpr RGBA BrightRed    = 0xff0d00ff;
        constexpr RGBA Azure    = 0xfff39a06;
        constexpr RGBA BluePurple   = 0xffce2957;
        constexpr RGBA DarkTurquoise    = 0xff5a5c04;
        constexpr RGBA ElectricBlue = 0xffff5206;
        constexpr RGBA OffWhite = 0xffe4ffff;
        constexpr RGBA PowderBlue   = 0xfffcd1b1;
        constexpr RGBA Wine = 0xff3f0180;
        constexpr RGBA DullGreen    = 0xff62a674;
        constexpr RGBA AppleGreen   = 0xff26cd76;
        constexpr RGBA LightTurquoise   = 0xffccf47e;
        constexpr RGBA NeonPurple   = 0xfffe13bc;
        constexpr RGBA Cobalt   = 0xff8f481e;
        constexpr RGBA Pinkish  = 0xff7e6ad4;
        constexpr RGBA OliveDrab    = 0xff32766f;
        constexpr RGBA DarkCyan = 0xff8a880a;
        constexpr RGBA PurpleBlue   = 0xffe92d63;
        constexpr RGBA DarkViolet   = 0xff3f0134;
        constexpr RGBA DarkLavender = 0xff986785;
        constexpr RGBA ForrestGreen = 0xff064415;
        constexpr RGBA PaleOrange   = 0xff56a7ff;
        constexpr RGBA GreenishBlue = 0xff878b0b;
        constexpr RGBA DarkTan  = 0xff4a88af;
        constexpr RGBA GreenBlue    = 0xff8bb406;
        constexpr RGBA BluishGreen  = 0xff74a610;
        constexpr RGBA PastelBlue   = 0xfffebfa2;
        constexpr RGBA Moss = 0xff589976;
        constexpr RGBA Grass    = 0xff2dac5c;
        constexpr RGBA DeepPink = 0xff6201cb;
        constexpr RGBA BloodRed = 0xff020098;
        constexpr RGBA SageGreen    = 0xff78b388;
        constexpr RGBA AquaBlue = 0xffe9d802;
        constexpr RGBA Terracotta   = 0xff4166ca;
        constexpr RGBA PastelPurple = 0xffffa0ca;
        constexpr RGBA Sienna   = 0xff1e56a9;
        constexpr RGBA DarkOlive    = 0xff023e37;
        constexpr RGBA GreenYellow  = 0xff27ffc9;
        constexpr RGBA Scarlet  = 0xff1901be;
        constexpr RGBA GreyishGreen = 0xff7da682;
        constexpr RGBA Chocolate    = 0xff021c3d;
        constexpr RGBA BlueViolet   = 0xffe9065d;
        constexpr RGBA BabyPink = 0xffceb7ff;
        constexpr RGBA Charcoal = 0xff373834;
        constexpr RGBA PineGreen    = 0xff1e480a;
        constexpr RGBA Pumpkin  = 0xff0177e1;
        constexpr RGBA GreenishBrown    = 0xff126169;
        constexpr RGBA RedBrown = 0xff162e8b;
        constexpr RGBA BrownishGreen    = 0xff096e6a;
        constexpr RGBA Tangerine    = 0xff0894ff;
        constexpr RGBA SalmonPink   = 0xff7c7bfe;
        constexpr RGBA AquaGreen    = 0xff93e112;
        constexpr RGBA Raspberry    = 0xff4901b0;
        constexpr RGBA GreyishPurple    = 0xff917188;
        constexpr RGBA RosePink = 0xff9a87f7;
        constexpr RGBA NeonPink = 0xff9a01fe;
        constexpr RGBA CobaltBlue   = 0xffa70a03;
        constexpr RGBA OrangeBrown  = 0xff0064be;
        constexpr RGBA DeepRed  = 0xff00029a;
        constexpr RGBA OrangeRed    = 0xff1e41fd;
        constexpr RGBA DirtyYellow  = 0xff0ac5cd;
        constexpr RGBA Orchid   = 0xffc475c8;
        constexpr RGBA ReddishPink  = 0xff542cfe;
        constexpr RGBA ReddishPurple    = 0xff510991;
        constexpr RGBA YellowOrange = 0xff01b0fc;
        constexpr RGBA LightCyan    = 0xfffcffac;
        constexpr RGBA Sky  = 0xfffcca82;
        constexpr RGBA LightMagenta = 0xfff75ffa;
        constexpr RGBA PaleRed  = 0xff4d54d9;
        constexpr RGBA Emerald  = 0xff49a001;
        constexpr RGBA DarkBeige    = 0xff6293ac;
        constexpr RGBA Jade = 0xff74a71f;
        constexpr RGBA GreenishGrey = 0xff8dae96;
        constexpr RGBA DarkSalmon   = 0xff535ac8;
        constexpr RGBA PurplishPink = 0xffae5dce;
        constexpr RGBA DarkAqua = 0xff6b6905;
        constexpr RGBA BrownishOrange   = 0xff2377cb;
        constexpr RGBA LightOliveGreen  = 0xff5cbea4;
        constexpr RGBA LightAqua    = 0xffdbff8c;
        constexpr RGBA Clay = 0xff506ab6;
        constexpr RGBA BurntUmber   = 0xff0e45a0;
        constexpr RGBA DullBlue = 0xff9c7549;
        constexpr RGBA PaleBrown    = 0xff6e91b1;
        constexpr RGBA EmeraldGreen = 0xff1e8f02;
        constexpr RGBA Brownish = 0xff576d9c;
        constexpr RGBA Mud  = 0xff125c73;
        constexpr RGBA DarkRose = 0xff5d48b5;
        constexpr RGBA BrownishRed  = 0xff23369e;
        constexpr RGBA PinkPurple   = 0xffda4bdb;
        constexpr RGBA PinkyPurple  = 0xffbe4cc9;
        constexpr RGBA CamoGreen    = 0xff256552;
        constexpr RGBA FadedGreen   = 0xff74b27b;
        constexpr RGBA DustyPink    = 0xff948ad5;
        constexpr RGBA PurplePink   = 0xffd83fe0;
        constexpr RGBA DeepGreen    = 0xff0f5902;
        constexpr RGBA ReddishOrange    = 0xff1c48f8;
        constexpr RGBA Mahogany = 0xff00014a;
        constexpr RGBA Aubergine    = 0xff34073d;
        constexpr RGBA DullPink = 0xff9d86d5;
        constexpr RGBA Evergreen    = 0xff2a4705;
        constexpr RGBA DarkSkyBlue  = 0xffe48e44;
        constexpr RGBA IceBlue  = 0xfffeffd7;
        constexpr RGBA LightTan = 0xffaceefb;
        constexpr RGBA DirtyGreen   = 0xff2c7e66;
        constexpr RGBA NeonBlue = 0xffffd904;
        constexpr RGBA Denim    = 0xff8c633b;
        constexpr RGBA Eggshell = 0xffd4ffff;
        constexpr RGBA JungleGreen  = 0xff438204;
        constexpr RGBA DarkPeach    = 0xff5d7ede;
        constexpr RGBA Umber    = 0xff0064b2;
        constexpr RGBA BrightYellow = 0xff01fdff;
        constexpr RGBA DustyBlue    = 0xffad865a;
        constexpr RGBA ElectricGreen    = 0xff0dfc21;
        constexpr RGBA LighterGreen = 0xff63fd75;
        constexpr RGBA SlateGrey    = 0xff6d6559;
        constexpr RGBA TealGreen    = 0xff6fa325;
        constexpr RGBA MarineBlue   = 0xff6a3801;
        constexpr RGBA Avocado  = 0xff34b190;
        constexpr RGBA Forest   = 0xff09550b;
        constexpr RGBA PeaSoup  = 0xff019992;
        constexpr RGBA Lemon    = 0xff52fffd;
        constexpr RGBA MuddyGreen   = 0xff327465;
        constexpr RGBA Marigold = 0xff06c0fc;
        constexpr RGBA Ocean    = 0xff927b01;
        constexpr RGBA LightMauve   = 0xffa192c2;
        constexpr RGBA Bordeaux = 0xff2c007b;
        constexpr RGBA Pistachio    = 0xff8bfac0;
        constexpr RGBA LemonYellow  = 0xff38fffd;
        constexpr RGBA RedViolet    = 0xff68019e;
        constexpr RGBA DuskyPink    = 0xff8b7acc;
        constexpr RGBA Dirt = 0xff456e8a;
        constexpr RGBA Pine = 0xff345d2b;
        constexpr RGBA Vermillion   = 0xff0c32f4;
        constexpr RGBA Amber    = 0xff08b3fe;
        constexpr RGBA Silver   = 0xffc7c9c5;
        constexpr RGBA Coffee   = 0xff4c81a6;
        constexpr RGBA Sepia    = 0xff2b5e98;
        constexpr RGBA FadedRed = 0xff4e49d3;
        constexpr RGBA CanaryYellow = 0xff40feff;
        constexpr RGBA CherryRed    = 0xff2a02f7;
        constexpr RGBA Ocre = 0xff049cc6;
        constexpr RGBA Ivory    = 0xffcbffff;
        constexpr RGBA Copper   = 0xff2563b6;
        constexpr RGBA DarkLime = 0xff01b784;
        constexpr RGBA Strawberry   = 0xff4329fb;
        constexpr RGBA DarkNavy = 0xff350400;
        constexpr RGBA Cinnamon = 0xff064fac;
        constexpr RGBA CloudyBlue   = 0xffd9c2ac;
        
        inline const std::vector<std::pair<std::string, RGBA>> &Names() {
            static std::vector<std::pair<std::string, RGBA>> names = {
                {"Purple", Purple},
                {"Green", Green},
                {"Blue", Blue},
                {"Pink", Pink},
                {"Brown", Brown},
                {"Red", Red},
                {"Light Blue", LightBlue},
                {"Teal", Teal},
                {"Orange", Orange},
                {"Light Green", LightGreen},
                {"Magenta", Magenta},
                {"Yellow", Yellow},
                {"Sky Blue", SkyBlue},
                {"Grey", Grey},
                {"Lime Green", LimeGreen},
                {"Light Purple", LightPurple},
                {"Violet", Violet},
                {"Dark Green", DarkGreen},
                {"Turquoise", Turquoise},
                {"Lavender", Lavender},
                {"Dark Blue", DarkBlue},
                {"Tan", Tan},
                {"Cyan", Cyan},
                {"Aqua", Aqua},
                {"Forest Green", ForestGreen},
                {"Mauve", Mauve},
                {"Dark Purple", DarkPurple},
                {"Bright Green", BrightGreen},
                {"Maroon", Maroon},
                {"Olive", Olive},
                {"Salmon", Salmon},
                {"Beige", Beige},
                {"Royal Blue", RoyalBlue},
                {"Navy Blue", NavyBlue},
                {"Lilac", Lilac},
                {"Black", Black},
                {"Hot Pink", HotPink},
                {"Light Brown", LightBrown},
                {"Pale Green", PaleGreen},
                {"Peach", Peach},
                {"Olive Green", OliveGreen},
                {"Dark Pink", DarkPink},
                {"Periwinkle", Periwinkle},
                {"Sea Green", SeaGreen},
                {"Lime", Lime},
                {"Indigo", Indigo},
                {"Mustard", Mustard},
                {"Light Pink", LightPink},
                {"Rose", Rose},
                {"Bright Blue", BrightBlue},
                {"Neon Green", NeonGreen},
                {"Burnt Orange", BurntOrange},
                {"Aquamarine", Aquamarine},
                {"Navy", Navy},
                {"Grass Green", GrassGreen},
                {"Pale Blue", PaleBlue},
                {"Dark Red", DarkRed},
                {"Bright Purple", BrightPurple},
                {"Yellow Green", YellowGreen},
                {"Baby Blue", BabyBlue},
                {"Gold", Gold},
                {"Mint Green", MintGreen},
                {"Plum", Plum},
                {"Royal Purple", RoyalPurple},
                {"Brick Red", BrickRed},
                {"Dark Teal", DarkTeal},
                {"Burgundy", Burgundy},
                {"Khaki", Khaki},
                {"Blue Green", BlueGreen},
                {"Seafoam Green", SeafoamGreen},
                {"Pea Green", PeaGreen},
                {"Taupe", Taupe},
                {"Dark Brown", DarkBrown},
                {"Deep Purple", DeepPurple},
                {"Chartreuse", Chartreuse},
                {"Bright Pink", BrightPink},
                {"Light Orange", LightOrange},
                {"Mint", Mint},
                {"Pastel Green", PastelGreen},
                {"Sand", Sand},
                {"Dark Orange", DarkOrange},
                {"Spring Green", SpringGreen},
                {"Puce", Puce},
                {"Seafoam", Seafoam},
                {"Grey Blue", GreyBlue},
                {"Army Green", ArmyGreen},
                {"Dark Grey", DarkGrey},
                {"Dark Yellow", DarkYellow},
                {"Goldenrod", Goldenrod},
                {"Slate", Slate},
                {"Light Teal", LightTeal},
                {"Rust", Rust},
                {"Deep Blue", DeepBlue},
                {"Pale Pink", PalePink},
                {"Cerulean", Cerulean},
                {"Light Red", LightRed},
                {"Mustard Yellow", MustardYellow},
                {"Ochre", Ochre},
                {"Pale Yellow", PaleYellow},
                {"Crimson", Crimson},
                {"Fuchsia", Fuchsia},
                {"Hunter Green", HunterGreen},
                {"Blue Grey", BlueGrey},
                {"Slate Blue", SlateBlue},
                {"Pale Purple", PalePurple},
                {"Sea Blue", SeaBlue},
                {"Pinkish Purple", PinkishPurple},
                {"Light Grey", LightGrey},
                {"Leaf Green", LeafGreen},
                {"Light Yellow", LightYellow},
                {"Eggplant", Eggplant},
                {"Steel Blue", SteelBlue},
                {"Moss Green", MossGreen},
                {"White", White},
                {"Grey Green", GreyGreen},
                {"Sage", Sage},
                {"Brick", Brick},
                {"Burnt Sienna", BurntSienna},
                {"Reddish Brown", ReddishBrown},
                {"Cream", Cream},
                {"Coral", Coral},
                {"Ocean Blue", OceanBlue},
                {"Greenish", Greenish},
                {"Dark Magenta", DarkMagenta},
                {"Red Orange", RedOrange},
                {"Bluish Purple", BluishPurple},
                {"Midnight Blue", MidnightBlue},
                {"Light Violet", LightViolet},
                {"Dusty Rose", DustyRose},
                {"Greenish Yellow", GreenishYellow},
                {"Yellowish Green", YellowishGreen},
                {"Purplish Blue", PurplishBlue},
                {"Greyish Blue", GreyishBlue},
                {"Grape", Grape},
                {"Light Olive", LightOlive},
                {"Cornflower Blue", CornflowerBlue},
                {"Pinkish Red", PinkishRed},
                {"Bright Red", BrightRed},
                {"Azure", Azure},
                {"Blue Purple", BluePurple},
                {"Dark Turquoise", DarkTurquoise},
                {"Electric Blue", ElectricBlue},
                {"Off White", OffWhite},
                {"Powder Blue", PowderBlue},
                {"Wine", Wine},
                {"Dull Green", DullGreen},
                {"Apple Green", AppleGreen},
                {"Light Turquoise", LightTurquoise},
                {"Neon Purple", NeonPurple},
                {"Cobalt", Cobalt},
                {"Pinkish", Pinkish},
                {"Olive Drab", OliveDrab},
                {"Dark Cyan", DarkCyan},
                {"Purple Blue", PurpleBlue},
                {"Dark Violet", DarkViolet},
                {"Dark Lavender", DarkLavender},
                {"Forrest Green", ForrestGreen},
                {"Pale Orange", PaleOrange},
                {"Greenish Blue", GreenishBlue},
                {"Dark Tan", DarkTan},
                {"Green Blue", GreenBlue},
                {"Bluish Green", BluishGreen},
                {"Pastel Blue", PastelBlue},
                {"Moss", Moss},
                {"Grass", Grass},
                {"Deep Pink", DeepPink},
                {"Blood Red", BloodRed},
                {"Sage Green", SageGreen},
                {"Aqua Blue", AquaBlue},
                {"Terracotta", Terracotta},
                {"Pastel Purple", PastelPurple},
                {"Sienna", Sienna},
                {"Dark Olive", DarkOlive},
                {"Green Yellow", GreenYellow},
                {"Scarlet", Scarlet},
                {"Greyish Green", GreyishGreen},
                {"Chocolate", Chocolate},
                {"Blue Violet", BlueViolet},
                {"Baby Pink", BabyPink},
                {"Charcoal", Charcoal},
                {"Pine Green", PineGreen},
                {"Pumpkin", Pumpkin},
                {"Greenish Brown", GreenishBrown},
                {"Red Brown", RedBrown},
                {"Brownish Green", BrownishGreen},
                {"Tangerine", Tangerine},
                {"Salmon Pink", SalmonPink},
                {"Aqua Green", AquaGreen},
                {"Raspberry", Raspberry},
                {"Greyish Purple", GreyishPurple},
                {"Rose Pink", RosePink},
                {"Neon Pink", NeonPink},
                {"Cobalt Blue", CobaltBlue},
                {"Orange Brown", OrangeBrown},
                {"Deep Red", DeepRed},
                {"Orange Red", OrangeRed},
                {"Dirty Yellow", DirtyYellow},
                {"Orchid", Orchid},
                {"Reddish Pink", ReddishPink},
                {"Reddish Purple", ReddishPurple},
                {"Yellow Orange", YellowOrange},
                {"Light Cyan", LightCyan},
                {"Sky", Sky},
                {"Light Magenta", LightMagenta},
                {"Pale Red", PaleRed},
                {"Emerald", Emerald},
                {"Dark Beige", DarkBeige},
                {"Jade", Jade},
                {"Greenish Grey", GreenishGrey},
                {"Dark Salmon", DarkSalmon},
                {"Purplish Pink", PurplishPink},
                {"Dark Aqua", DarkAqua},
                {"Brownish Orange", BrownishOrange},
                {"Light Olive Green", LightOliveGreen},
                {"Light Aqua", LightAqua},
                {"Clay", Clay},
                {"Burnt Umber", BurntUmber},
                {"Dull Blue", DullBlue},
                {"Pale Brown", PaleBrown},
                {"Emerald Green", EmeraldGreen},
                {"Brownish", Brownish},
                {"Mud", Mud},
                {"Dark Rose", DarkRose},
                {"Brownish Red", BrownishRed},
                {"Pink Purple", PinkPurple},
                {"Pinky Purple", PinkyPurple},
                {"Camo Green", CamoGreen},
                {"Faded Green", FadedGreen},
                {"Dusty Pink", DustyPink},
                {"Purple Pink", PurplePink},
                {"Deep Green", DeepGreen},
                {"Reddish Orange", ReddishOrange},
                {"Mahogany", Mahogany},
                {"Aubergine", Aubergine},
                {"Dull Pink", DullPink},
                {"Evergreen", Evergreen},
                {"Dark Sky Blue", DarkSkyBlue},
                {"Ice Blue", IceBlue},
                {"Light Tan", LightTan},
                {"Dirty Green", DirtyGreen},
                {"Neon Blue", NeonBlue},
                {"Denim", Denim},
                {"Eggshell", Eggshell},
                {"Jungle Green", JungleGreen},
                {"Dark Peach", DarkPeach},
                {"Umber", Umber},
                {"Bright Yellow", BrightYellow},
                {"Dusty Blue", DustyBlue},
                {"Electric Green", ElectricGreen},
                {"Lighter Green", LighterGreen},
                {"Slate Grey", SlateGrey},
                {"Teal Green", TealGreen},
                {"Marine Blue", MarineBlue},
                {"Avocado", Avocado},
                {"Forest", Forest},
                {"Pea Soup", PeaSoup},
                {"Lemon", Lemon},
                {"Muddy Green", MuddyGreen},
                {"Marigold", Marigold},
                {"Ocean", Ocean},
                {"Light Mauve", LightMauve},
                {"Bordeaux", Bordeaux},
                {"Pistachio", Pistachio},
                {"Lemon Yellow", LemonYellow},
                {"Red Violet", RedViolet},
                {"Dusky Pink", DuskyPink},
                {"Dirt", Dirt},
                {"Pine", Pine},
                {"Vermillion", Vermillion},
                {"Amber", Amber},
                {"Silver", Silver},
                {"Coffee", Coffee},
                {"Sepia", Sepia},
                {"Faded Red", FadedRed},
                {"Canary Yellow", CanaryYellow},
                {"Cherry Red", CherryRed},
                {"Ocre", Ocre},
                {"Ivory", Ivory},
                {"Copper", Copper},
                {"Dark Lime", DarkLime},
                {"Strawberry", Strawberry},
                {"Dark Navy", DarkNavy},
                {"Cinnamon", Cinnamon},
                {"Cloudy Blue", CloudyBlue},
            };
            
            return names;
        }
    }
} }