ColorVec.h

Go to the documentation of this file.

// NAP  12/20/2004  \Noel120\Include\ColorVec.h

#ifndef __COLORVEC_H
#define __COLORVEC_H

#ifndef __FASTFTOL_H
#include "FastFTOL.h"
#endif
#ifndef __VECTOR_H
#include "Vector.h"
#endif
#ifndef __DATATYPE_H
#include "DataType.h"
#endif
#ifndef __OS9ROS_H
#include "Macros.h"
#endif

#include <math.h>

class HalfColorBuf;
class ColorBuf;
//******************************************************************************
//** ColorVector
//******************************************************************************
class ColorVector {
public:
   float m_red;
   float m_green;
   float m_blue;

   ColorVector( void ) { }
   ColorVector( float red, float green, float blue ) { m_red = red; m_green = green; m_blue = blue; }
   ColorVector( const float scalar ) { m_red = m_green = m_blue = scalar; }
   ColorVector( COLORREF c ) { m_red=GetRValue(c); m_green=GetGValue(c); m_blue=GetBValue(c); }
   ColorVector( const ColorVector &other ) { *this = other; }
   ColorVector( const HalfColorBuf &other );

   ColorVector & operator = ( float scalar) { m_red = m_green = m_blue = scalar; return *this; }
   ColorVector & operator = ( const ColorVector &other) { m_red = other.m_red; m_green = other.m_green; m_blue = other.m_blue; return *this; }

   ColorVector & operator += ( const ColorVector &other ) { m_red += other.m_red; m_green += other.m_green; m_blue += other.m_blue; return *this; }
   ColorVector & operator -= ( const ColorVector &other ) { m_red -= other.m_red; m_green -= other.m_green; m_blue -= other.m_blue; return *this; }
   ColorVector & operator *= ( const ColorVector &other ) { m_red *= other.m_red; m_green *= other.m_green; m_blue *= other.m_blue; return *this; }
   ColorVector & operator *= ( float scale )              { m_red *= scale; m_green *= scale; m_blue *= scale; return *this; }
   ColorVector & operator /= ( const ColorVector &other ) { m_red /= other.m_red; m_green /= other.m_green; m_blue /= other.m_blue; return *this; }
   ColorVector & operator /= ( float scale )              { return (*this *= (1/scale)); }

   float Red() const   { return m_red;   }
   float Green() const { return m_green; }
   float Blue() const { return m_blue;  }   
   
   void SetRed(float red)     { m_red = red;   }
   void SetGreen(float green) { m_green = green; }
   void SetBlue(float blue)   { m_blue = blue;  }   
   
   void Set( float red, float green, float blue ) { m_red = red; m_green = green; m_blue = blue; }
   void Set( float init ) { m_red = m_green = m_blue = init; }

   int operator == ( const ColorVector &a )       const { return (m_red == a.m_red) && (m_green == a.m_green) && (m_blue == a.m_blue); }
   int operator != ( const ColorVector &a )       const { return !(*this == a); }   

   ColorVector operator + ( const ColorVector &a ) const { return ColorVector(*this) += a; }
   ColorVector operator - ( const ColorVector &a ) const { return ColorVector(*this) -= a; }
   ColorVector operator * ( const ColorVector &a ) const { return ColorVector(*this) *= a; }
   ColorVector operator * ( float s )              const { return ColorVector(*this) *= s; }
   ColorVector operator / ( float s )              const { return ColorVector(*this) /= s; }
   ColorVector operator / ( const ColorVector &a ) const { return ColorVector(*this) /= a; }
   float operator[]( int i ) const { return (&m_red)[i]; }

   COLORREF GetCOLORREF() const { return RGB(fast_round(m_red), fast_round(m_green), fast_round(m_blue)); }
   float GetLuminance() const { return 0.3f*m_red + 0.59f*m_green + 0.11f*m_blue; }

   friend ColorVector operator * ( const float s, const ColorVector &a )  { return a * s; }
   
   void Min(float min) { if (m_red<min) m_red=min; if (m_green<min) m_green=min; if (m_blue<min) m_blue=min; }
   void Max(float max) { if (m_red>max) m_red=max; if (m_green>max) m_green=max; if (m_blue>max) m_blue=max; }
   void MinMax(float min, float max) { if (m_red>max) m_red=max; else if (m_red<min) m_red=min; 
                                       if (m_green>max) m_green=max; else if (m_green<min) m_green=min;
                                       if (m_blue>max) m_blue=max; else if (m_blue<min) m_blue=min; }
};

inline ColorVector GetSpectrumColorVector(float x)
{
   float theta = (1.66f * (float)V_PI) * x;
   return ColorVector((2.0f+(float)cos(theta))/3.0f, (1.0f+(float)cos(theta-(2.0f*V_PI/3.0f)))/2.0f, (2.0f+(float)cos(theta-(4.0f*V_PI/3.0f)))/3.0f);
}

//*****************************************************************************
//** ColorVectorAlpha
//*****************************************************************************
class HalfColorBufAlpha;
class ColorVectorAlpha 
{
public:
   ColorVector m_color;
   float m_alpha;

   ColorVectorAlpha( void ) { }
   ColorVectorAlpha( float red, float green, float blue, float alpha ) : m_color(red, green, blue) {m_alpha = alpha; }
   ColorVectorAlpha( float scalar ) : m_color(scalar) { m_alpha = scalar; }
   ColorVectorAlpha( COLORREF c ) : m_color(c) { m_alpha = 1.0f; }
   ColorVectorAlpha( const ColorVectorAlpha &other ) { *this = other; }
   ColorVectorAlpha( const HalfColorBufAlpha &other );
   ColorVectorAlpha( const ColorBuf &other );

   ColorVectorAlpha & operator = ( const ColorVectorAlpha &other) { m_color = other.Color(); m_alpha = other.Alpha(); return *this; }

   ColorVectorAlpha & operator += ( const ColorVectorAlpha &other ) { m_color += other.Color(); m_alpha += other.m_alpha; return *this; }
   ColorVectorAlpha & operator -= ( const ColorVectorAlpha &other ) { m_color -= other.Color(); m_alpha -= other.m_alpha; return *this; }
   ColorVectorAlpha & operator *= ( const ColorVectorAlpha &other ) { m_color *= other.Color(); m_alpha *= other.m_alpha; return *this; }
   ColorVectorAlpha & operator *= ( float scale ) { m_color *= scale; m_alpha *= scale; return *this; }
   ColorVectorAlpha & operator /= ( const ColorVectorAlpha &other ) { m_color /= other.Color(); m_alpha /= other.m_alpha; return *this; }
   ColorVectorAlpha & operator /= ( float scale ) { return (*this *= (1/scale)); }

   ColorVector Color() const { return m_color; }
   float Red() const { return m_color.Red();  }   
   float Green() const { return m_color.Green();  }   
   float Blue() const { return m_color.Blue();  }   
   float Alpha() const { return m_alpha;  }   
   void SetRed(float red) { m_color.SetRed(red); }
   void SetGreen(float green) { m_color.SetGreen(green); }
   void SetBlue(float blue) { m_color.SetBlue(blue); }
   void SetAlpha(float alpha) { m_alpha = alpha; }

   void Set( float red, float green, float blue, float alpha )  { m_color.Set(red, green, blue); m_alpha = alpha; }
   void Set( float init ) { m_color.Set(init); m_alpha = init; }

   int operator == ( const ColorVectorAlpha &a )       const { return (m_color == a.Color()) && (m_alpha == a.Alpha()); }
   int operator != ( const ColorVectorAlpha &a )       const { return !(*this == a); }   

   ColorVectorAlpha operator + ( const ColorVectorAlpha &a ) const { return ColorVectorAlpha(*this) += a; }
   ColorVectorAlpha operator - ( const ColorVectorAlpha &a ) const { return ColorVectorAlpha(*this) -= a; }
   ColorVectorAlpha operator * ( const ColorVectorAlpha &a ) const { return ColorVectorAlpha(*this) *= a; }
   ColorVectorAlpha operator * ( float s )              const { return ColorVectorAlpha(*this) *= s; }
   ColorVectorAlpha operator / ( float s )              const { return ColorVectorAlpha(*this) /= s; }
   ColorVectorAlpha operator / ( const ColorVectorAlpha &a ) const { return ColorVectorAlpha(*this) /= a; }
   float operator[]( int i ) const { return (&m_color.m_red)[i]; }

   friend ColorVectorAlpha operator * ( const float s, const ColorVectorAlpha &a )  { return a * s; }
};

//*****************************************************************************
//** Colors
//*****************************************************************************
class ColorVectors {
public:
   ColorVector m_ambient, m_diffuse, m_specular, m_reflection, m_shadow;
};

#endif

---