CColor.h

Go to the documentation of this file.

//==============================================================================
/*
    Software License Agreement (BSD License)
    Copyright (c) 2003-2016, CHAI3D.
    (www.chai3d.org)

    All rights reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:

    * Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above
    copyright notice, this list of conditions and the following
    disclaimer in the documentation and/or other materials provided
    with the distribution.

    * Neither the name of CHAI3D nor the names of its contributors may
    be used to endorse or promote products derived from this software
    without specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    POSSIBILITY OF SUCH DAMAGE. 

    \author    <http://www.chai3d.org>
    \author    Francois Conti
    \version   3.2.0 $Rev: 2148 $
*/
//==============================================================================

//------------------------------------------------------------------------------
#ifndef CColorH
#define CColorH
//------------------------------------------------------------------------------
#include "math/CMaths.h"
//------------------------------------------------------------------------------
#ifdef C_USE_OPENGL
#include "graphics/COpenGLHeaders.h"
#endif
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
namespace chai3d {
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
struct cColorb;
struct cColorf;
//------------------------------------------------------------------------------

//==============================================================================
//==============================================================================


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------


//==============================================================================
//==============================================================================
inline GLubyte cColorFtoB(GLfloat a_value) 
{
    return( (GLubyte)(255.0f * cClamp(a_value, 0.0f, 1.0f)) );
}


//==============================================================================
//==============================================================================
inline GLfloat cColorBtoF(GLubyte a_value) 
{
    return((1.0f / 255.0f) * (GLfloat)a_value);
}


//==============================================================================
//==============================================================================
struct cColorf
{
    //--------------------------------------------------------------------------
    // CONSTRUCTOR & DESTRUCTOR:
    //--------------------------------------------------------------------------

public:

    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    cColorf()
    {
        m_color[0] = 1.0f;
        m_color[1] = 1.0f;
        m_color[2] = 1.0f;
        m_color[3] = 1.0f;

        m_flag_color = false;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    cColorf(const GLfloat a_red,
            const GLfloat a_green,
            const GLfloat a_blue,
            const GLfloat a_alpha = 1.0f)
    {
        m_color[0] = cClamp( a_red,   0.0f, 1.0f);
        m_color[1] = cClamp( a_green, 0.0f, 1.0f);
        m_color[2] = cClamp( a_blue,  0.0f, 1.0f);
        m_color[3] = cClamp( a_alpha, 0.0f, 1.0f);

        m_flag_color = true;
    };


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    ~cColorf() {};


    //--------------------------------------------------------------------------
    // PUBLIC METHODS:
    //--------------------------------------------------------------------------

public:

    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void setModificationFlags(const bool a_value) { m_flag_color = a_value; }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void copyTo(cColorf& a_color)
    {
        if (m_flag_color)
        {
            a_color.set(m_color[0], m_color[1], m_color[2], m_color[3]);
        }
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void set(const GLfloat a_red, 
                    const GLfloat a_green, 
                    const GLfloat a_blue,
                    const GLfloat a_alpha)
    {
        m_color[0] = cClamp( a_red,   0.0f, 1.0f);
        m_color[1] = cClamp( a_green, 0.0f, 1.0f);
        m_color[2] = cClamp( a_blue,  0.0f, 1.0f);
        m_color[3] = cClamp( a_alpha, 0.0f, 1.0f);
        m_flag_color = true;
    };


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void set(const GLfloat a_red, 
                    const GLfloat a_green, 
                    const GLfloat a_blue)
    {
        m_color[0] = cClamp( a_red,   0.0f, 1.0f);
        m_color[1] = cClamp( a_green, 0.0f, 1.0f);
        m_color[2] = cClamp( a_blue,  0.0f, 1.0f);
        m_flag_color = true;
    };


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void setb(const GLubyte a_red, 
                     const GLubyte a_green, 
                     const GLubyte a_blue,
                     const GLubyte a_alpha)
    {
        m_color[0] = cColorBtoF(a_red);
        m_color[1] = cColorBtoF(a_green);
        m_color[2] = cColorBtoF(a_blue);
        m_color[3] = cColorBtoF(a_alpha);
        m_flag_color = true;
    };


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void setb(const GLubyte a_red, 
                     const GLubyte a_green, 
                     const GLubyte a_blue)
    {
        m_color[0] = cColorBtoF(a_red);
        m_color[1] = cColorBtoF(a_green);
        m_color[2] = cColorBtoF(a_blue);
        m_flag_color = true;
    };


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void mul(const GLfloat a_scale)
    {
        m_color[0] = cClamp( a_scale * m_color[0], 0.0f, 1.0f);
        m_color[1] = cClamp( a_scale * m_color[1], 0.0f, 1.0f);
        m_color[2] = cClamp( a_scale * m_color[2], 0.0f, 1.0f);
        m_flag_color = true;
    };


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void setMem3(const GLfloat* a_colorRGB)
    {
        m_color[0] = a_colorRGB[0];
        m_color[1] = a_colorRGB[1];
        m_color[2] = a_colorRGB[2];
        m_color[3] = 1.0;
        m_flag_color = true;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void setMem4(const GLfloat* a_colorRGBA)
    {
        m_color[0] = a_colorRGBA[0];
        m_color[1] = a_colorRGBA[1];
        m_color[2] = a_colorRGBA[2];
        m_color[3] = a_colorRGBA[3];
        m_flag_color = true;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void setR(const GLfloat a_red)
    {
        m_color[0] = cClamp( a_red, 0.0f, 1.0f);
        m_flag_color = true;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline GLfloat getR() const
    {
        return(m_color[0]);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void setG(const GLfloat a_green)
    {
        m_color[1] = cClamp( a_green, 0.0f, 1.0f);
        m_flag_color = true;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline GLfloat getG() const
    {
        return(m_color[1]);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void setB(const GLfloat a_blue)
    {
        m_color[2] = cClamp( a_blue, 0.0f, 1.0f);
        m_flag_color = true;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline GLfloat getB() const
    {
        return(m_color[2]);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void setA(const GLfloat a_alpha)
    {
        m_color[3] = cClamp( a_alpha, 0.0f, 1.0f);
        m_flag_color = true;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline GLfloat getA() const
    {
        return(m_color[3]);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void setLuminance(const GLfloat a_luminance)
    {
        set(a_luminance, a_luminance, a_luminance);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline GLfloat getLuminance() const
    {
        return (0.33333f * (m_color[0] + m_color[1] + m_color[2]));
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void render() const
    {
        #ifdef C_USE_OPENGL
        glColor4fv(&m_color[0]);
        #endif
    };


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline const GLfloat* getData() const
    {
        #ifdef C_USE_OPENGL
        return (&m_color[0]);
        #endif
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    cColorb getColorb() const;


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline GLfloat operator[](const unsigned int n) const
    {
        if (n<4) 
            return (m_color[n]);
        else 
            return (0.0f);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline GLfloat& operator[](const unsigned int n)
    {
        if (n<4) 
            return m_color[n];
        else 
            return m_color[0];
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline bool operator==(const cColorf& a_color)
    {
        if (m_color[0] != a_color[0]) { return (false); }
        if (m_color[1] != a_color[1]) { return (false); }
        if (m_color[2] != a_color[2]) { return (false); }
        return (true);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline bool operator!=(const cColorf& a_color)
    {
        if (m_color[0] != a_color[0]) { return (true); }
        if (m_color[1] != a_color[1]) { return (true); }
        if (m_color[2] != a_color[2]) { return (true); }
        return (false);
    }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - RED COLORS:
    //--------------------------------------------------------------------------

public:

    inline void setRedIndian()              { setb(0xCD, 0x5C, 0x5C); } 

    inline void setRedLightCoral()          { setb(0xF0, 0x80, 0x80); }

    inline void setRedSalmon()              { setb(0xFA, 0x80, 0x72); }

    inline void setRedDarkSalmon()          { setb(0xE9, 0x96, 0x7A); }

    inline void setRedLightSalmon()         { setb(0xFF, 0xA0, 0x7A); }

    inline void setRedCrimson()             { setb(0xDC, 0x14, 0x3C); }

    inline void setRed()                    { setb(0xFF, 0x00, 0x00); }

    inline void setRedFireBrick()           { setb(0xB2, 0x22, 0x22); }

    inline void setRedDark()                { setb(0x8B, 0x00, 0x00); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - PINK COLORS:
    //--------------------------------------------------------------------------

public:

    inline void setPink()                   { setb(0xFF, 0xC0, 0xCB); }

    inline void setPinkLight()              { setb(0xFF, 0xB6, 0xC); }

    inline void setPinkHot()                { setb(0xFF, 0x69, 0xB4); }

    inline void setPinkDeep()               { setb(0xFF, 0x14, 0x93); }

    inline void setPinkMediumVioletRed()    { setb(0xC7, 0x15, 0x85); }

    inline void setPinkPaleVioletRed()      { setb(0xDB, 0x70, 0x93); }

   
    //--------------------------------------------------------------------------
    // PUBLIC METHODS - ORANGE COLORS:
    //--------------------------------------------------------------------------

public:

    inline void setOrangeLightSalmon()      { setb(0xFF, 0xA0, 0x7A); }

    inline void setOrangeCoral()            { setb(0xFF, 0x7F, 0x50); }

    inline void setOrangeTomato()           { setb(0xFF, 0x63, 0x47); }

    inline void setOrangeRed()              { setb(0xFF, 0x45, 0x00); }

    inline void setOrangeDark()             { setb(0xFF, 0x8C, 0x00); }

    inline void setOrange()                 { setb(0xFF, 0xA5, 0x00); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - YELLOW COLORS:
    //--------------------------------------------------------------------------

public:

    inline void setYellowGold()             { setb(0xFF, 0xD7, 0x00); }

    inline void setYellow()                 { setb(0xFF, 0xFF, 0x00); }

    inline void setYellowLight()            { setb(0xFF, 0xFF, 0xE0); }

    inline void setYellowLemonChiffon()     { setb(0xFF, 0xFA, 0xCD); }

    inline void setYellowLightGoldenrod()   { setb(0xFA, 0xFA, 0xD); }

    inline void setYellowPapayaWhip()       { setb(0xFF, 0xEF, 0xD5); }

    inline void setYellowMoccasin()         { setb(0xFF, 0xE4, 0xB5); }

    inline void setYellowPeachPuff()        { setb(0xFF, 0xDA, 0xB9); }

    inline void setYellowPaleGoldenrod()    { setb(0xEE, 0xE8, 0xAA); }

    inline void setYellowKhaki()            { setb(0xF0, 0xE6, 0x8C); }

    inline void setYellowDarkKhaki()        { setb(0xBD, 0xB7, 0x6B); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - PURPLE COLORS:
    //--------------------------------------------------------------------------

public:

    inline void setPurpleLavender()         { setb(0xE6, 0xE6, 0xFA); }

    inline void setPurpleThistle()          { setb(0xD8, 0xBF, 0xD8); }

    inline void setPurplePlum()             { setb(0xDD, 0xA0, 0xDD); }

    inline void setPurpleViolet()           { setb(0xEE, 0x82, 0xEE); }

    inline void setPurpleOrchid()           { setb(0xDA, 0x70, 0xD6); }

    inline void setPurpleFuchsia()          { setb(0xFF, 0x00, 0xFF); }

    inline void setPurpleMagenta()          { setb(0xFF, 0x00, 0xFF); }

    inline void setPurpleMediumOrchid()     { setb(0xBA, 0x55, 0xD3); }

    inline void setPurpleMedium()           { setb(0x93, 0x70, 0xDB); }

    inline void setPurpleAmethyst()         { setb(0x99, 0x66, 0xCC); }

    inline void setPurpleBlueViolet()       { setb(0x8A, 0x2B, 0xE2); }

    inline void setPurpleDarkViolet()       { setb(0x94, 0x00, 0xD3); }

    inline void setPurpleDarkOrchid()       { setb(0x99, 0x32, 0xCC); }

    inline void setPurpleDarkMagenta()      { setb(0x8B, 0x00, 0x8B); }

    inline void setPurple()                 { setb(0x80, 0x00, 0x80); }

    inline void setPurpleIndigo()           { setb(0x4B, 0x00, 0x82); }

    inline void setPurpleSlateBlue()        { setb(0x6A, 0x5A, 0xCD); }

    inline void setPurpleDarkSlateBlue()    { setb(0x48, 0x3D, 0x8B); }

    inline void setPurpleMediumSlateBlue()  { setb(0x7B, 0x68, 0xEE); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - GREEN COLORS:
    //--------------------------------------------------------------------------

public:

    inline void setGreenYellow()            { setb(0xAD, 0xFF, 0x2F); }

    inline void setGreenChartreuse()        { setb(0x7F, 0xFF, 0x00); }

    inline void setGreenLawn()              { setb(0x7C, 0xFC, 0x00); }

    inline void setGreenLime()              { setb(0x00, 0xFF, 0x00); }

    inline void setGreenLimeGreen()         { setb(0x32, 0xCD, 0x32); }

    inline void setGreenPale()              { setb(0x98, 0xFB, 0x98); }

    inline void setGreenLight()             { setb(0x90, 0xEE, 0x90); }

    inline void setGreenMediumSpring()      { setb(0x00, 0xFA, 0x9A); }

    inline void setGreenSpring()            { setb(0x00, 0xFF, 0x7F); }

    inline void setGreenMediumSea()         { setb(0x3C, 0xB3, 0x71); }

    inline void setGreenSea()               { setb(0x2E, 0x8B, 0x57); }

    inline void setGreenForest()            { setb(0x22, 0x8B, 0x22); }

    inline void setGreen()                  { setb(0x00, 0x80, 0x00); }

    inline void setGreenDark()              { setb(0x00, 0x64, 0x00); }

    inline void setGreenYellowGreen()       { setb(0x9A, 0xCD, 0x32); }

    inline void setGreenOliveDrab()         { setb(0x6B, 0x8E, 0x23); }

    inline void setGreenOlive()             { setb(0x80, 0x80, 0x00); }

    inline void setGreenDarkOlive()         { setb(0x55, 0x6B, 0x2F); }

    inline void setGreenMediumAquamarine()  { setb(0x66, 0xCD, 0xAA); }

    inline void setGreenDarkSea()           { setb(0x8F, 0xBC, 0x8F); }

    inline void setGreenLightSea()          { setb(0x20, 0xB2, 0xAA); }

    inline void setGreenDarkCyan()          { setb(0x00, 0x8B, 0x8B); }

    inline void setGreenTeal()              { setb(0x00, 0x80, 0x80); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - BLUE COLORS:
    //--------------------------------------------------------------------------

public:

    inline void setBlueAqua()               { setb(0x00, 0xFF, 0xFF); }

    inline void setBlueCyan()               { setb(0x00, 0xFF, 0xFF); }

    inline void setBlueLightCyan()          { setb(0xE0, 0xFF, 0xFF); }

    inline void setBluePaleTurquoise()      { setb(0xAF, 0xEE, 0xEE); }

    inline void setBlueAquamarine()         { setb(0x7F, 0xFF, 0xD4); }

    inline void setBlueTurquoise()          { setb(0x40, 0xE0, 0xD0); }

    inline void setBlueMediumTurquoise()    { setb(0x48, 0xD1, 0xCC); }

    inline void setBlueDarkTurquoise()      { setb(0x00, 0xCE, 0xD1); }

    inline void setBlueCadet()              { setb(0x5F, 0x9E, 0xA0); }

    inline void setBlueSteel()              { setb(0x46, 0x82, 0xB4); }

    inline void setBlueLightSteel()         { setb(0xB0, 0xC4, 0xDE); }

    inline void setBluePowder()             { setb(0xB0, 0xE0, 0xE6); }

    inline void setBlueLight()              { setb(0xAD, 0xD8, 0xE6); }

    inline void setBlueSky()                { setb(0x87, 0xCE, 0xEB); }

    inline void setBlueLightSky()           { setb(0x87, 0xCE, 0xFA); }

    inline void setBlueDeepSky()            { setb(0x00, 0xBF, 0xFF); }

    inline void setBlueDodger()             { setb(0x1E, 0x90, 0xFF); }

    inline void setBlueCornflower()         { setb(0x64, 0x95, 0xED); }

    inline void setBlueMediumSlate()        { setb(0x7B, 0x68, 0xEE); }

    inline void setBlueRoyal()              { setb(0x41, 0x69, 0xE1); }

    inline void setBlue()                   { setb(0x00, 0x00, 0xFF); }

    inline void setBlueMedium()             { setb(0x00, 0x00, 0xCD); }

    inline void setBlueDark()               { setb(0x00, 0x00, 0x8B); }

    inline void setBlueNavy()               { setb(0x00, 0x00, 0x80); }

    inline void setBlueMidnight()           { setb(0x19, 0x19, 0x70); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - BROWN COLORS:
    //--------------------------------------------------------------------------

public:

    inline void setBrownCornsilk()          { setb(0xFF, 0xF8, 0xDC); }

    inline void setBrownBlanchedAlmond()    { setb(0xFF, 0xEB, 0xCD); }

    inline void setBrownBisque()            { setb(0xFF, 0xE4, 0xC4); }

    inline void setBrownNavajoWhite()       { setb(0xFF, 0xDE, 0xAD); }

    inline void setBrownWheat()             { setb(0xF5, 0xDE, 0xB3); }

    inline void setBrownBurlyWood()         { setb(0xDE, 0xB8, 0x87); }

    inline void setBrownTan()               { setb(0xD2, 0xB4, 0x8C); }

    inline void setBrownRosy()              { setb(0xBC, 0x8F, 0x8F); }

    inline void setBrownSandy()             { setb(0xF4, 0xA4, 0x60); }

    inline void setBrownGoldenrod()         { setb(0xDA, 0xA5, 0x20); }

    inline void setBrownDarkGoldenrod()     { setb(0xB8, 0x86, 0x0B); }

    inline void setBrownPeru()              { setb(0xCD, 0x85, 0x3F); }

    inline void setBrownChocolate()         { setb(0xD2, 0x69, 0x1E); }

    inline void setBrownSaddle()            { setb(0x8B, 0x45, 0x13); }

    inline void setBrownSienna()            { setb(0xA0, 0x52, 0x2D); }

    inline void setBrown()                  { setb(0xA5, 0x2A, 0x2A); }

    inline void setBrownMaroon()            { setb(0x80, 0x00, 0x00); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - WHITE COLORS:
    //--------------------------------------------------------------------------

public:

    inline void setWhite()                  { setb(0xFF, 0xFF, 0xFF); }

    inline void setWhiteSnow()              { setb(0xFF, 0xFA, 0xFA); }

    inline void setWhiteHoneydew()          { setb(0xF0, 0xFF, 0xF0); }

    inline void setWhiteMintCream()         { setb(0xF5, 0xFF, 0xFA); }

    inline void setWhiteAzure()             { setb(0xF0, 0xFF, 0xFF); }

    inline void setWhiteAliceBlue()         { setb(0xF0, 0xF8, 0xFF); }

    inline void setWhiteGhost()             { setb(0xF8, 0xF8, 0xFF); }

    inline void setWhiteSmoke()             { setb(0xF5, 0xF5, 0xF5); }

    inline void setWhiteSeashell()          { setb(0xFF, 0xF5, 0xEE); }

    inline void setWhiteBeige()             { setb(0xF5, 0xF5, 0xDC); }

    inline void setWhiteOldLace()           { setb(0xFD, 0xF5, 0xE6); }

    inline void setWhiteFloral()            { setb(0xFF, 0xFA, 0xF0); }

    inline void setWhiteIvory()             { setb(0xFF, 0xFF, 0xF0); }

    inline void setWhiteAntique()           { setb(0xFA, 0xEB, 0xD7); }

    inline void setWhiteLinen()             { setb(0xFA, 0xF0, 0xE6); }

    inline void setWhiteLavenderBlush()     { setb(0xFF, 0xF0, 0xF5); }

    inline void setWhiteMistyRose()         { setb(0xFF, 0xE4, 0xE1); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - GRAY COLORS:
    //--------------------------------------------------------------------------

public:

    inline void setGrayGainsboro()          { setb(0xDC, 0xDC, 0xDC); }

    inline void setGrayLight()              { setb(0xD3, 0xD3, 0xD3); }

    inline void setGraySilver()             { setb(0xC0, 0xC0, 0xC0); }

    inline void setGrayDark()               { setb(0xA9, 0xA9, 0xA9); }

    inline void setGray()                   { setb(0x80, 0x80, 0x80); }

    inline void setGrayDim()                { setb(0x69, 0x69, 0x69); }

    inline void setGrayLightSlate()         { setb(0x77, 0x88, 0x99); }

    inline void setGraySlate()              { setb(0x70, 0x80, 0x90); }

    inline void setGrayDarkSlate()          { setb(0x2F, 0x4F, 0x4F); }

    inline void setBlack()                  { setb(0x00, 0x00, 0x00); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - CUSTOM GRAY COLOR:
    //--------------------------------------------------------------------------

public:

    // This method sets a custom gray level.
    inline void setGrayLevel(const GLfloat a_level) { set(a_level, a_level, a_level); }


    //--------------------------------------------------------------------------
    // PUBLIC MEMBERS:
    //--------------------------------------------------------------------------

public:

    GLfloat m_color[4];

    bool m_flag_color;
};


//==============================================================================
//==============================================================================
struct cColorb
{
    //--------------------------------------------------------------------------
    // CONSTRUCTOR & DESTRUCTOR:
    //--------------------------------------------------------------------------

public:

    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    cColorb()
    {
        // initialize color components R,G,B,A
        m_color[0] = 0xff;
        m_color[1] = 0xff;
        m_color[2] = 0xff;
        m_color[3] = 0xff;
        m_flag_color = false;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    cColorb(const GLubyte a_red, 
            const GLubyte a_green, 
            const GLubyte a_blue,
            const GLubyte a_alpha = 0xff)
    {
        m_color[0] = a_red;
        m_color[1] = a_green;
        m_color[2] = a_blue;
        m_color[3] = a_alpha;
        m_flag_color = true;
    };


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    ~cColorb() {};


    //--------------------------------------------------------------------------
    // PUBLIC METHODS:
    //--------------------------------------------------------------------------
public:


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void setModificationFlags(const bool a_value) { m_flag_color = a_value; }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void copyTo(cColorb& a_color)
    {
        if (m_flag_color)
        {
            a_color.set(m_color[0], m_color[1], m_color[2], m_color[3]);
        }
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void set(const GLubyte a_red, const GLubyte a_green, const GLubyte a_blue,
                    const GLubyte a_alpha = 0xff)
    {
        m_color[0] = a_red;
        m_color[1] = a_green;
        m_color[2] = a_blue;
        m_color[3] = a_alpha;
        m_flag_color = true;
    };


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void setf(const GLfloat a_red, const GLfloat a_green, const GLfloat a_blue,
                     const GLfloat a_alpha = 1.0f)
    {
        m_color[0] = cColorFtoB(a_red);
        m_color[1] = cColorFtoB(a_green);
        m_color[2] = cColorFtoB(a_blue);
        m_color[3] = cColorFtoB(a_alpha);
        m_flag_color = true;
    };


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void setMem3(const GLubyte* a_colorRGB)
    {
        m_color[0] = a_colorRGB[0];
        m_color[1] = a_colorRGB[1];
        m_color[2] = a_colorRGB[2];
        m_color[3] = 0xff;
        m_flag_color = true;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void setMem4(const GLubyte* a_colorRGBA)
    {
        m_color[0] = a_colorRGBA[0];
        m_color[1] = a_colorRGBA[1];
        m_color[2] = a_colorRGBA[2];
        m_color[3] = a_colorRGBA[3];
        m_flag_color = true;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void setR(const GLubyte a_red)
    {
        m_color[0] = a_red;
        m_flag_color = true;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline GLubyte getR() const
    {
        return(m_color[0]);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void setG(const GLubyte a_green)
    {
        m_color[1] = a_green;
        m_flag_color = true;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline GLubyte getG() const
    {
        return(m_color[1]);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void setB(const GLubyte a_blue)
    {
        m_color[2] = a_blue;
        m_flag_color = true;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline GLubyte getB() const
    {
        return(m_color[2]);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void setA(const GLubyte a_alpha)
    {
        m_color[3] = a_alpha;
        m_flag_color = true;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline GLubyte getA() const
    {
        return(m_color[3]);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void setLuminance(const GLubyte a_luminance)
    {
        set(a_luminance, a_luminance, a_luminance);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline GLubyte getLuminance() const
    {
        return ((GLubyte)(0.33333 * ((float)m_color[0] + (float)m_color[1] + (float)m_color[2])));
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline void render() const
    {
        #ifdef C_USE_OPENGL 
        glColor4bv((const signed char*)(&m_color[0]));
        #endif
    };


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline const GLubyte* getData() const
    {
        return (&m_color[0]);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    cColorf getColorf() const;


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline GLubyte operator[](const unsigned int n) const
    {
        if (n<4) 
            return (m_color[n]);
        else 
            return (0x00);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline GLubyte& operator[](const unsigned int n)
    {
        if (n<4)
            return m_color[n];
        else 
            return m_color[0];
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline bool operator==(const cColorb& a_color)
    {
        if (m_color[0] != a_color[0]) { return (false); }
        if (m_color[1] != a_color[1]) { return (false); }
        if (m_color[2] != a_color[2]) { return (false); }
        return (true);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    inline bool operator!=(const cColorb& a_color)
    {
        if (m_color[0] != a_color[0]) { return (true); }
        if (m_color[1] != a_color[1]) { return (true); }
        if (m_color[2] != a_color[2]) { return (true); }
        return (false);
    }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - RED COLORS:
    //--------------------------------------------------------------------------

public:

    inline void setRedIndian()              { set(0xCD, 0x5C, 0x5C); } 

    inline void setRedLightCoral()          { set(0xF0, 0x80, 0x80); }

    inline void setRedSalmon()              { set(0xFA, 0x80, 0x72); }

    inline void setRedDarkSalmon()          { set(0xE9, 0x96, 0x7A); }

    inline void setRedLightSalmon()         { set(0xFF, 0xA0, 0x7A); }

    inline void setRedCrimson()             { set(0xDC, 0x14, 0x3C); }

    inline void setRed()                    { set(0xFF, 0x00, 0x00); }

    inline void setRedFireBrick()           { set(0xB2, 0x22, 0x22); }

    inline void setRedDark()                { set(0x8B, 0x00, 0x00); }

    
    //--------------------------------------------------------------------------
    // PUBLIC METHODS - PINK COLORS:
    //--------------------------------------------------------------------------

public:

    inline void setPink()                   { set(0xFF, 0xC0, 0xCB); }

    inline void setPinkLight()              { set(0xFF, 0xB6, 0xC); }

    inline void setPinkHot()                { set(0xFF, 0x69, 0xB4); }

    inline void setPinkDeep()               { set(0xFF, 0x14, 0x93); }

    inline void setPinkMediumVioletRed()    { set(0xC7, 0x15, 0x85); }

    inline void setPinkPaleVioletRed()      { set(0xDB, 0x70, 0x93); }

   
    //--------------------------------------------------------------------------
    // PUBLIC METHODS - ORANGE COLORS:
    //--------------------------------------------------------------------------

public:

    inline void setOrangeLightSalmon()      { set(0xFF, 0xA0, 0x7A); }

    inline void setOrangeCoral()            { set(0xFF, 0x7F, 0x50); }

    inline void setOrangeTomato()           { set(0xFF, 0x63, 0x47); }

    inline void setOrangeRed()              { set(0xFF, 0x45, 0x00); }

    inline void setOrangeDark()             { set(0xFF, 0x8C, 0x00); }

    inline void setOrange()                 { set(0xFF, 0xA5, 0x00); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - YELLOW COLORS:
    //--------------------------------------------------------------------------

public:

    inline void setYellowGold()             { set(0xFF, 0xD7, 0x00); }

    inline void setYellow()                 { set(0xFF, 0xFF, 0x00); }

    inline void setYellowLight()            { set(0xFF, 0xFF, 0xE0); }

    inline void setYellowLemonChiffon()     { set(0xFF, 0xFA, 0xCD); }

    inline void setYellowLightGoldenrod()   { set(0xFA, 0xFA, 0xD); }

    inline void setYellowPapayaWhip()       { set(0xFF, 0xEF, 0xD5); }

    inline void setYellowMoccasin()         { set(0xFF, 0xE4, 0xB5); }

    inline void setYellowPeachPuff()        { set(0xFF, 0xDA, 0xB9); }

    inline void setYellowPaleGoldenrod()    { set(0xEE, 0xE8, 0xAA); }

    inline void setYellowKhaki()            { set(0xF0, 0xE6, 0x8C); }

    inline void setYellowDarkKhaki()        { set(0xBD, 0xB7, 0x6B); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - PURPLE COLORS:
    //--------------------------------------------------------------------------

public:

    inline void setPurpleLavender()         { set(0xE6, 0xE6, 0xFA); }

    inline void setPurpleThistle()          { set(0xD8, 0xBF, 0xD8); }

    inline void setPurplePlum()             { set(0xDD, 0xA0, 0xDD); }

    inline void setPurpleViolet()           { set(0xEE, 0x82, 0xEE); }

    inline void setPurpleOrchid()           { set(0xDA, 0x70, 0xD6); }

    inline void setPurpleFuchsia()          { set(0xFF, 0x00, 0xFF); }

    inline void setPurpleMagenta()          { set(0xFF, 0x00, 0xFF); }

    inline void setPurpleMediumOrchid()     { set(0xBA, 0x55, 0xD3); }

    inline void setPurpleMedium()           { set(0x93, 0x70, 0xDB); }

    inline void setPurpleAmethyst()         { set(0x99, 0x66, 0xCC); }

    inline void setPurpleBlueViolet()       { set(0x8A, 0x2B, 0xE2); }

    inline void setPurpleDarkViolet()       { set(0x94, 0x00, 0xD3); }

    inline void setPurpleDarkOrchid()       { set(0x99, 0x32, 0xCC); }

    inline void setPurpleDarkMagenta()      { set(0x8B, 0x00, 0x8B); }

    inline void setPurple()                 { set(0x80, 0x00, 0x80); }

    inline void setPurpleIndigo()           { set(0x4B, 0x00, 0x82); }

    inline void setPurpleSlateBlue()        { set(0x6A, 0x5A, 0xCD); }

    inline void setPurpleDarkSlateBlue()    { set(0x48, 0x3D, 0x8B); }

    inline void setPurpleMediumSlateBlue()  { set(0x7B, 0x68, 0xEE); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - GREEN COLORS:
    //--------------------------------------------------------------------------

public:

    inline void setGreenYellow()            { set(0xAD, 0xFF, 0x2F); }

    inline void setGreenChartreuse()        { set(0x7F, 0xFF, 0x00); }

    inline void setGreenLawn()              { set(0x7C, 0xFC, 0x00); }

    inline void setGreenLime()              { set(0x00, 0xFF, 0x00); }

    inline void setGreenLimeGreen()         { set(0x32, 0xCD, 0x32); }

    inline void setGreenPale()              { set(0x98, 0xFB, 0x98); }

    inline void setGreenLight()             { set(0x90, 0xEE, 0x90); }

    inline void setGreenMediumSpring()      { set(0x00, 0xFA, 0x9A); }

    inline void setGreenSpring()            { set(0x00, 0xFF, 0x7F); }

    inline void setGreenMediumSea()         { set(0x3C, 0xB3, 0x71); }

    inline void setGreenSea()               { set(0x2E, 0x8B, 0x57); }

    inline void setGreenForest()            { set(0x22, 0x8B, 0x22); }

    inline void setGreen()                  { set(0x00, 0x80, 0x00); }

    inline void setGreenDark()              { set(0x00, 0x64, 0x00); }

    inline void setGreenYellowGreen()       { set(0x9A, 0xCD, 0x32); }

    inline void setGreenOliveDrab()         { set(0x6B, 0x8E, 0x23); }

    inline void setGreenOlive()             { set(0x80, 0x80, 0x00); }

    inline void setGreenDarkOlive()         { set(0x55, 0x6B, 0x2F); }

    inline void setGreenMediumAquamarine()  { set(0x66, 0xCD, 0xAA); }

    inline void setGreenDarkSea()           { set(0x8F, 0xBC, 0x8F); }

    inline void setGreenLightSea()          { set(0x20, 0xB2, 0xAA); }

    inline void setGreenDarkCyan()          { set(0x00, 0x8B, 0x8B); }

    inline void setGreenTeal()              { set(0x00, 0x80, 0x80); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - BLUE COLORS
    //--------------------------------------------------------------------------

public:

    inline void setBlueAqua()               { set(0x00, 0xFF, 0xFF); }

    inline void setBlueCyan()               { set(0x00, 0xFF, 0xFF); }

    inline void setBlueLightCyan()          { set(0xE0, 0xFF, 0xFF); }

    inline void setBluePaleTurquoise()      { set(0xAF, 0xEE, 0xEE); }

    inline void setBlueAquamarine()         { set(0x7F, 0xFF, 0xD4); }

    inline void setBlueTurquoise()          { set(0x40, 0xE0, 0xD0); }

    inline void setBlueMediumTurquoise()    { set(0x48, 0xD1, 0xCC); }

    inline void setBlueDarkTurquoise()      { set(0x00, 0xCE, 0xD1); }

    inline void setBlueCadet()              { set(0x5F, 0x9E, 0xA0); }

    inline void setBlueSteel()              { set(0x46, 0x82, 0xB4); }

    inline void setBlueLightSteel()         { set(0xB0, 0xC4, 0xDE); }

    inline void setBluePowder()             { set(0xB0, 0xE0, 0xE6); }

    inline void setBlueLight()              { set(0xAD, 0xD8, 0xE6); }

    inline void setBlueSky()                { set(0x87, 0xCE, 0xEB); }

    inline void setBlueLightSky()           { set(0x87, 0xCE, 0xFA); }

    inline void setBlueDeepSky()            { set(0x00, 0xBF, 0xFF); }

    inline void setBlueDodger()             { set(0x1E, 0x90, 0xFF); }

    inline void setBlueCornflower()         { set(0x64, 0x95, 0xED); }

    inline void setBlueMediumSlate()        { set(0x7B, 0x68, 0xEE); }

    inline void setBlueRoyal()              { set(0x41, 0x69, 0xE1); }

    inline void setBlue()                   { set(0x00, 0x00, 0xFF); }

    inline void setBlueMedium()             { set(0x00, 0x00, 0xCD); }

    inline void setBlueDark()               { set(0x00, 0x00, 0x8B); }

    inline void setBlueNavy()               { set(0x00, 0x00, 0x80); }

    inline void setBlueMidnight()           { set(0x19, 0x19, 0x70); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - BROWN COLORS:
    //--------------------------------------------------------------------------

public:

    inline void setBrownCornsilk()          { set(0xFF, 0xF8, 0xDC); }

    inline void setBrownBlanchedAlmond()    { set(0xFF, 0xEB, 0xCD); }

    inline void setBrownBisque()            { set(0xFF, 0xE4, 0xC4); }

    inline void setBrownNavajoWhite()       { set(0xFF, 0xDE, 0xAD); }

    inline void setBrownWheat()             { set(0xF5, 0xDE, 0xB3); }

    inline void setBrownBurlyWood()         { set(0xDE, 0xB8, 0x87); }

    inline void setBrownTan()               { set(0xD2, 0xB4, 0x8C); }

    inline void setBrownRosy()              { set(0xBC, 0x8F, 0x8F); }

    inline void setBrownSandy()             { set(0xF4, 0xA4, 0x60); }

    inline void setBrownGoldenrod()         { set(0xDA, 0xA5, 0x20); }

    inline void setBrownDarkGoldenrod()     { set(0xB8, 0x86, 0x0B); }

    inline void setBrownPeru()              { set(0xCD, 0x85, 0x3F); }

    inline void setBrownChocolate()         { set(0xD2, 0x69, 0x1E); }

    inline void setBrownSaddle()            { set(0x8B, 0x45, 0x13); }

    inline void setBrownSienna()            { set(0xA0, 0x52, 0x2D); }

    inline void setBrown()                  { set(0xA5, 0x2A, 0x2A); }

    inline void setBrownMaroon()            { set(0x80, 0x00, 0x00); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - WHITE COLORS:
    //--------------------------------------------------------------------------

public:

    inline void setWhite()                  { set(0xFF, 0xFF, 0xFF); }

    inline void setWhiteSnow()              { set(0xFF, 0xFA, 0xFA); }

    inline void setWhiteHoneydew()          { set(0xF0, 0xFF, 0xF0); }

    inline void setWhiteMintCream()         { set(0xF5, 0xFF, 0xFA); }

    inline void setWhiteAzure()             { set(0xF0, 0xFF, 0xFF); }

    inline void setWhiteAliceBlue()         { set(0xF0, 0xF8, 0xFF); }

    inline void setWhiteGhost()             { set(0xF8, 0xF8, 0xFF); }

    inline void setWhiteSmoke()             { set(0xF5, 0xF5, 0xF5); }

    inline void setWhiteSeashell()          { set(0xFF, 0xF5, 0xEE); }

    inline void setWhiteBeige()             { set(0xF5, 0xF5, 0xDC); }

    inline void setWhiteOldLace()           { set(0xFD, 0xF5, 0xE6); }

    inline void setWhiteFloral()            { set(0xFF, 0xFA, 0xF0); }

    inline void setWhiteIvory()             { set(0xFF, 0xFF, 0xF0); }

    inline void setWhiteAntique()           { set(0xFA, 0xEB, 0xD7); }

    inline void setWhiteLinen()             { set(0xFA, 0xF0, 0xE6); }

    inline void setWhiteLavenderBlush()     { set(0xFF, 0xF0, 0xF5); }

    inline void setWhiteMistyRose()         { set(0xFF, 0xE4, 0xE1); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - GRAY COLORS:
    //--------------------------------------------------------------------------

public:

    inline void setGrayGainsboro()          { set(0xDC, 0xDC, 0xDC); }

    inline void setGrayLight()              { set(0xD3, 0xD3, 0xD3); }

    inline void setGraySilver()             { set(0xC0, 0xC0, 0xC0); }

    inline void setGrayDark()               { set(0xA9, 0xA9, 0xA9); }

    inline void setGray()                   { set(0x80, 0x80, 0x80); }

    inline void setGrayDim()                { set(0x69, 0x69, 0x69); }

    inline void setGrayLightSlate()         { set(0x77, 0x88, 0x99); }

    inline void setGraySlate()              { set(0x70, 0x80, 0x90); }

    inline void setGrayDarkSlate()          { set(0x2F, 0x4F, 0x4F); }

    inline void setBlack()                  { set(0x00, 0x00, 0x00); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - CUSTOM GRAY COLOR
    //--------------------------------------------------------------------------

public:

    // This method set a custom gray level.
    inline void setGrayLevel(const GLubyte a_level) { set(a_level, a_level, a_level); }

  
    //--------------------------------------------------------------------------
    // PUBLIC MEMBERS:
    //--------------------------------------------------------------------------

public:

    GLubyte m_color[4];

    bool m_flag_color;
};

//------------------------------------------------------------------------------
} // namespace chai3d
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
#endif
//------------------------------------------------------------------------------