color class

#ifndef Color_h__
#define Color_h__

class Color
{
public:
float r, g, b;

Color (float fR = 0.0f, float fG = 0.0f, float fB = 0.0f);

Color& operator= (float fScalar);
bool operator== (const Color& c) const;
bool operator!= (const Color& c) const { return !(*this == c); }

Color operator+ (const Color& c) const;
Color operator- (const Color& c) const;
Color operator* (float fScalar) const;
Color operator* (const Color& c) const;
Color operator/ (float fScalar) const;
Color operator/ (const Color& c) const;
Color operator- () const;
friend Color operator* (float fScalar, const Color& c);

Color& operator+= (const Color& c);
Color& operator-= (const Color& c);
Color& operator*= (float fScalar);
Color& operator*= (const Color& c);
Color& operator/= (float fScalar);
Color& operator/= (const Color& c);

static const Color WHITE; // (1,1,1)
static const Color BLACK; // (0,0,0)
};

class ColorA
{
public:
float r, g, b, a;

ColorA (float fR = 0.0f, float fG = 0.0f,
float fB = 0.0f, float fA = 0.0f);
ColorA (unsigned int iR , unsigned int iG,
unsigned int iB , unsigned int iA );

//unsigned int operator()(const GpColorA& c);
ColorA& operator= (float fScalar);
ColorA& operator= (const ColorA& c);
ColorA& operator= (const ColorA* c);
bool operator== (const ColorA& c) const;
bool operator!= (const ColorA& c) const { return !(*this == c); }

ColorA operator+ (const ColorA& c) const;
ColorA operator- (const ColorA& c) const;
ColorA operator* (float fScalar) const;
ColorA operator* (const ColorA& c) const;
ColorA operator/ (float fScalar) const;
ColorA operator/ (const ColorA& c) const;
ColorA operator- () const;
friend ColorA operator* (float fScalar, const ColorA& c);

ColorA& operator+= (const ColorA& c);
ColorA& operator-= (const ColorA& c);
ColorA& operator*= (float fScalar);
ColorA& operator*= (const ColorA& c);
ColorA& operator/= (float fScalar);
ColorA& operator/= (const ColorA& c);

static const ColorA WHITE;  // (1,1,1,1)
static const ColorA BLACK;  // (0,0,0,1)
static unsigned int GetD3DColor(const ColorA& kColor);


} ;


#include "Color.inl"

#endif // Color_h__






//---------------------------------------------------------------------------
inline Color::Color(float fR, float fG, float fB)
{
r = fR;
g = fG;
b = fB;
}



//---------------------------------------------------------------------------
inline Color& Color::operator= (float fScalar)
{
r = fScalar;
g = fScalar;
b = fScalar;
return *this;
}
//---------------------------------------------------------------------------
inline bool Color::operator== (const Color& c) const
{
return (r == c.r && g == c.g && b == c.b);
}
//---------------------------------------------------------------------------
inline Color Color::operator+ (const Color& c) const
{
Color result = *this;
result.r += c.r;
result.g += c.g;
result.b += c.b;
return result;
}
//---------------------------------------------------------------------------
inline Color Color::operator- (const Color& c) const
{
Color result = *this;
result.r -= c.r;
result.g -= c.g;
result.b -= c.b;
return result;
}
//---------------------------------------------------------------------------
inline Color Color::operator* (float fScalar) const
{
Color result = *this;
result.r *= fScalar;
result.g *= fScalar;
result.b *= fScalar;
return result;
}
//---------------------------------------------------------------------------
inline Color Color::operator* (const Color &c) const
{
Color result = *this;
result.r *= c.r;
result.g *= c.g;
result.b *= c.b;
return result;
}
//---------------------------------------------------------------------------
inline Color Color::operator/ (float fScalar) const
{
Color result = *this;
result.r /= fScalar;
result.g /= fScalar;
result.b /= fScalar;
return result;
}
//---------------------------------------------------------------------------
inline Color Color::operator/ (const Color &c) const
{
Color result = *this;
result.r /= c.r;
result.g /= c.g;
result.b /= c.b;
return result;
}
//---------------------------------------------------------------------------
inline Color Color::operator- () const
{
return Color(-r,-g,-b);
}
//---------------------------------------------------------------------------
inline Color operator* (float fScalar, const Color& c)
{
return c*fScalar;
}
//---------------------------------------------------------------------------
inline Color& Color::operator+= (const Color& c)
{
r += c.r;
g += c.g;
b += c.b;
return *this;
}
//---------------------------------------------------------------------------
inline Color& Color::operator-= (const Color& c)
{
r -= c.r;
g -= c.g;
b -= c.b;
return *this;
}
//---------------------------------------------------------------------------
inline Color& Color::operator*= (float fScalar)
{
r *= fScalar;
g *= fScalar;
b *= fScalar;
return *this;
}
//---------------------------------------------------------------------------
inline Color& Color::operator*= (const Color &c)
{
r *= c.r;
g *= c.g;
b *= c.b;
return *this;
}
//---------------------------------------------------------------------------
inline Color& Color::operator/= (float fScalar)
{
r /= fScalar;
g /= fScalar;
b /= fScalar;
return *this;
}
//---------------------------------------------------------------------------
inline Color& Color::operator/= (const Color &c)
{
r /= c.r;
g /= c.g;
b /= c.b;
return *this;
}

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
inline ColorA::ColorA(float fR, float fG, float fB, float fA)
{
r = fR;
g = fG;
b = fB;
a = fA;
}

inline ColorA::ColorA( unsigned int iR , unsigned int iG, unsigned int iB , unsigned int iA )
{

double dDiv;
dDiv=(double)iR/255;
r=(iR>255 ? 1.0f:(float)dDiv);
dDiv=(double)iG/255;
g=(iG>255 ? 1.0f:(float)dDiv);
dDiv=(double)iB/255;
b=(iB>255 ? 1.0f:(float)dDiv);
dDiv=(double)iA/255;
a=(iA>255 ? 1.0f:(float)dDiv);
}

inline ColorA& ColorA::operator= (float fScalar)
{
r = fScalar;
g = fScalar;
b = fScalar;
a = fScalar;
return *this;
}

inline ColorA& ColorA::operator= (const ColorA& c)
{
r = c.r;
g = c.g;
b = c.b;
a = c.a;
return *this;
}

inline ColorA& ColorA::operator= (const ColorA* c)
{
r = c->r;
g = c->g;
b = c->b;
a = c->a;
return *this;
}

//---------------------------------------------------------------------------
inline bool ColorA::operator== (const ColorA& c) const
{
return (r == c.r && g == c.g && b == c.b && a == c.a);
}
//---------------------------------------------------------------------------
inline ColorA ColorA::operator+ (const ColorA& c) const
{
ColorA result = *this;
result.r += c.r;
result.g += c.g;
result.b += c.b;
result.a += c.a;
return result;
}
//---------------------------------------------------------------------------
inline ColorA ColorA::operator- (const ColorA& c) const
{
ColorA result = *this;
result.r -= c.r;
result.g -= c.g;
result.b -= c.b;
result.a -= c.a;
return result;
}
//---------------------------------------------------------------------------
inline ColorA ColorA::operator* (float fScalar) const
{
ColorA result = *this;
result.r *= fScalar;
result.g *= fScalar;
result.b *= fScalar;
result.a *= fScalar;
return result;
}
//---------------------------------------------------------------------------
inline ColorA ColorA::operator* (const ColorA &c) const
{
ColorA result = *this;
result.r *= c.r;
result.g *= c.g;
result.b *= c.b;
result.a *= c.a;
return result;
}
//---------------------------------------------------------------------------
inline ColorA ColorA::operator/ (float fScalar) const
{
ColorA result = *this;
result.r /= fScalar;
result.g /= fScalar;
result.b /= fScalar;
result.a /= fScalar;
return result;
}
//---------------------------------------------------------------------------
inline ColorA ColorA::operator/ (const ColorA &c) const
{
ColorA result = *this;
result.r /= c.r;
result.g /= c.g;
result.b /= c.b;
result.a /= c.a;
return result;
}
//---------------------------------------------------------------------------
inline ColorA ColorA::operator- () const
{
return ColorA(-r,-g,-b,-a);
}
//---------------------------------------------------------------------------
inline ColorA operator* (float fScalar, const ColorA& c)
{
return c*fScalar;
}
//---------------------------------------------------------------------------
inline ColorA& ColorA::operator+= (const ColorA& c)
{
r += c.r;
g += c.g;
b += c.b;
a += c.a;
return *this;
}
//---------------------------------------------------------------------------
inline ColorA& ColorA::operator-= (const ColorA& c)
{
r -= c.r;
g -= c.g;
b -= c.b;
a -= c.a;
return *this;
}
//---------------------------------------------------------------------------
inline ColorA& ColorA::operator*= (float fScalar)
{
r *= fScalar;
g *= fScalar;
b *= fScalar;
a *= fScalar;
return *this;
}
//---------------------------------------------------------------------------
inline ColorA& ColorA::operator*= (const ColorA &c)
{
r *= c.r;
g *= c.g;
b *= c.b;
a *= c.a;
return *this;
}
//---------------------------------------------------------------------------
inline ColorA& ColorA::operator/= (float fScalar)
{
r /= fScalar;
g /= fScalar;
b /= fScalar;
a /= fScalar;
return *this;
}
//---------------------------------------------------------------------------
inline ColorA& ColorA::operator/= (const ColorA &c)
{
r /= c.r;
g /= c.g;
b /= c.b;
a /= c.a;
return *this;
}


inline unsigned int ColorA::GetD3DColor(const ColorA& kColor)
{
unsigned char ucR = (unsigned char)(kColor.r * 255.0f);
unsigned char ucG = (unsigned char)(kColor.g * 255.0f);
unsigned char ucB = (unsigned char)(kColor.b * 255.0f);
unsigned char ucA = (unsigned char)(kColor.a * 255.0f);
return D3DCOLOR_ARGB(ucA, ucR, ucG, ucB);
}