source: GTP/trunk/Lib/Illum/GPUObscurancesGT/include/COLOR.h @ 930

//////////////////////////////////////////////////////////////////////////////////////////
//      COLOR.h
//      Class declaration for an RGBA color
//      You may use this code however you wish, but if you do, please credit me and
//      provide a link to my website in a readme file or similar
//      Downloaded from: www.paulsprojects.net
//      Created:        20th July 2002
//      Modified:       7th November 2002       -       Some speed improvements
//                                                                      -       Removed clamping after adds etc. Do it yourself!
//                                                                              To enable use with floating point color buffers
//                                                                      -       Corrected lerp (reversed f and 1-f)
//                              13th December 2002      -       Added default parameter to alpha of Set()
//                                                                      -       Added red, green, blue constant COLORs
//////////////////////////////////////////////////////////////////////////////////////////      

#ifndef COLOR_H
#define COLOR_H

class COLOR
{
public:
        //constructors
        COLOR()
        {       r=g=b=a=0.0f;   }

        COLOR(float newR, float newG, float newB, float newA=0.0f)
        {       r=newR; g=newG; b=newB; a=newA; }

        COLOR(const float * rhs)
        {       r=*rhs; g=*(rhs+1);     b=*(rhs+2); a=*(rhs+3); }

        COLOR(const COLOR & rhs)
        {       r=rhs.r;        g=rhs.g;        b=rhs.b;        a=rhs.a;}

        ~COLOR() {}     //empty

        void Set(float newR, float newG, float newB, float newA=0.0f)
        {       r=newR; g=newG; b=newB; a=newA; }
        
        //accessors kept for compatability
        void SetR(float newR) {r = newR;}
        void SetG(float newG) {g = newG;}
        void SetB(float newB) {b = newB;}
        void SetA(float newA) {a = newA;}
        
        float GetR() const {return r;}  //public accessor functions
        float GetG() const {return g;}  //inline, const
        float GetB() const {return b;}
        float GetA() const {return a;}

        void ClampTo01(void);                   //clamp all components to [0,1]

        void SetBlack(void) {r=g=b=a=1.0f;}
        void SetWhite(void) {r=g=b=a=0.0f;}
        void SetGrey(float shade) {r=g=b=a=shade;}

        //linear interpolate
        COLOR lerp(const COLOR & c2, float factor)
        {       return (*this)*(1.0f-factor) + c2*factor;       }

        //binary operators
        COLOR operator+(const COLOR & rhs) const
        {       return COLOR(r+rhs.r, g+rhs.g, b+rhs.b, a+rhs.a);       }

        COLOR operator-(const COLOR & rhs) const
        {       return COLOR(r-rhs.r, g-rhs.g, b-rhs.b, a-rhs.a);       }

        COLOR operator*(const COLOR & rhs) const
        {       return COLOR(r*rhs.r, g*rhs.g, b*rhs.b, a*rhs.a);       }

        COLOR operator/(const COLOR & rhs) const
        {       return COLOR(r/rhs.r, g/rhs.g, b/rhs.b, a/rhs.a);       }

        COLOR operator*(const float rhs) const
        {       return COLOR(r*rhs, g*rhs, b*rhs, a*rhs);       }

        COLOR operator/(const float rhs) const
        {       return COLOR(r/rhs, g/rhs, b/rhs, a/rhs);       }

        //multiply by a float, eg 3*c
        friend COLOR operator*(float scaleFactor, const COLOR & rhs);

        bool operator==(const COLOR & rhs) const;
        bool operator!=(const COLOR & rhs) const
        {       return !((*this)==rhs); }

        //self-add etc
        COLOR operator+=(const COLOR & rhs)
        {       (*this)=(*this)+rhs;    return (*this); }

        COLOR operator-=(const COLOR & rhs)
        {       (*this)=(*this)-rhs;    return (*this); }

        COLOR operator*=(const COLOR & rhs)
        {       (*this)=(*this)*rhs;    return (*this); }

        COLOR operator/=(const COLOR & rhs)
        {       (*this)=(*this)/rhs;    return (*this); }

        COLOR operator*=(const float rhs)
        {       (*this)=(*this)*rhs;    return (*this); }

        COLOR operator/=(const float rhs)
        {       (*this)=(*this)/rhs;    return (*this); }

        //unary operators
        COLOR operator-(void) const {return COLOR(-r,-g, -b, -a);}
        COLOR operator+(void) const {return (*this);}

        //cast to pointer to float for glColor4fv etc
        operator float* () const {return (float*) this;}
        operator const float* () const {return (const float*) this;}

        //member variables
        float r;
        float g;
        float b;
        float a;
};

const COLOR white(1.0f, 1.0f, 1.0f, 1.0f);
const COLOR black(0.0f, 0.0f, 0.0f, 0.0f);

const COLOR red(1.0f, 0.0f, 0.0f, 1.0f);
const COLOR green(0.0f, 1.0f, 0.0f, 1.0f);
const COLOR blue(0.0f, 0.0f, 1.0f, 1.0f);

const COLOR cyan(0.0f, 1.0f, 1.0f, 1.0f);
const COLOR magenta(1.0f, 0.0f, 1.0f, 1.0f);
const COLOR yellow(1.0f, 1.0f, 0.0f, 1.0f);

#endif  //COLOR_H