HalfColorBuf.h

Go to the documentation of this file.

// Dan  7/26/2004  \DanLP115\Include\HalfColorBuf.h

#define __HALFCOLORBUF_H

#include "3rdParty/OpenEXR/half.h"

class ColorBuf;
class ColorVector;
class ColorVectorAlpha;
class HalfColorBuf 
{
public:
   half  m_red, m_green, m_blue;
   HalfColorBuf() { m_red = m_green = m_blue = 0; }

//Copy Constructors
   HalfColorBuf( const HalfColorBuf &other );
   HalfColorBuf( const ColorVector &colorvector );

   HalfColorBuf &operator = ( const HalfColorBuf &other );
   
   void operator += ( const HalfColorBuf &other );
   void operator -= ( const HalfColorBuf &other );
   void operator *= ( float factor );
   void operator /= ( float factor );

   HalfColorBuf operator + ( const HalfColorBuf &other );

   half operator [] ( int i ) const  { return (&m_red)[i]; }
   half &operator [] (int i) { return (&m_red)[i]; }

   int operator == ( const HalfColorBuf &other ) const;
   int operator != ( const HalfColorBuf &other ) const  { return !(*this == other); }   

   half Red()   const { return m_red; }
   half Green() const { return m_green; }
   half Blue()  const { return m_blue; }
   
   void Set( half value ) { m_red = m_green = m_blue = value; }
   void Set( half red, half green, half blue) { m_red = red; m_green = green; m_blue = blue; }
   void SetRed  ( half red   ) { m_red   = red;   }
   void SetGreen( half green ) { m_green = green; }
   void SetBlue ( half blue  ) { m_blue  = blue;  }
   
   void Max(float max) { 
      SetRed( MIN(pmax, Red()));
      SetGreen( MIN(pmax, Green()));
      SetBlue( MIN(pmax, Blue()));
   }
   float GetLuminance() const { return 0.3f*m_red + 0.59f*m_green + 0.11f*m_blue; }
};

inline HalfColorBuf::HalfColorBuf( const HalfColorBuf &other )
{
   (*this) = other;
}

inline HalfColorBuf &HalfColorBuf::operator = ( const HalfColorBuf &other )
{
   m_red   = other.Red();
   m_green = other.Green();
   m_blue  = other.Blue();
   return *this;
}

inline void HalfColorBuf::operator += ( const HalfColorBuf &other )
{
   m_red   += other.Red();
   m_green += other.Green();
   m_blue  += other.Blue();
}

inline void HalfColorBuf::operator -= ( const HalfColorBuf &other )
{
   m_red   -= other.Red();
   m_green -= other.Green();
   m_blue  -= other.Blue();
}

inline void HalfColorBuf::operator *= ( float factor )
{
   m_red  *= factor;
   m_green *= factor;
   m_blue  *= factor;
}

inline void HalfColorBuf::operator /= ( float factor )
{
   m_red   /= factor;
   m_green /= factor;
   m_blue  /= factor;
}

inline HalfColorBuf HalfColorBuf::operator + ( const HalfColorBuf &other )
{
   m_red += other.Red();
   m_green += other.Green();
   m_blue += other.Blue();
   return HalfColorBuf(*this);
}

inline int HalfColorBuf::operator == ( const HalfColorBuf &other ) const
{
   if (m_red == other.m_red &&
    m_green == other.m_green &&
    m_blue == other.m_blue)
      return TRUE;
   return FALSE;
}

//**********************************************************
//**********************************************************
//**********************************************************
//**********************************************************
class HalfColorBufAlpha 
{
public:
   HalfColorBuf m_color;
   half m_alpha;
     HalfColorBufAlpha() { m_alpha = 1; }
//Copy Constructors
   HalfColorBufAlpha( const HalfColorBufAlpha &other ) { (*this) = other;}
   HalfColorBufAlpha( const HalfColorBuf &other ) : m_color(other) { m_alpha = 1; }
   HalfColorBufAlpha( const ColorBuf &colorbuf );

   HalfColorBufAlpha &operator = ( const HalfColorBufAlpha &other );
   
   void operator += ( const HalfColorBufAlpha &other );
   void operator -= ( const HalfColorBufAlpha &other );
   void operator *= ( float factor);
   void operator /= ( float factor);

   HalfColorBufAlpha operator + ( const HalfColorBufAlpha &other );

   int operator == ( const HalfColorBufAlpha &other ) const;
   int operator != ( const HalfColorBufAlpha &other ) const  { return !(*this == other); }   

   half operator [] ( int i ) const  { return ((half *) &m_color)[i]; }
   half &operator [] (int i) { return ((half *) &m_color)[i]; }

   HalfColorBuf Color() const { return m_color; }

   half Red()   const { return m_color.Red(); }
   half Green() const { return m_color.Green(); }
   half Blue()  const { return m_color.Blue(); }
   half Alpha() const { return m_alpha; }

   void SetRed(half red) { m_color.SetRed(red);} 
   void SetGreen(half green) { m_color.SetGreen(green);} 
   void SetBlue(half blue) { m_color.SetBlue(blue);} 

   void SetColor ( HalfColorBuf &color ) { m_color = color;   }
   void SetAlpha ( half alpha ) { m_alpha = alpha;   }

   void Set( half red, half green, half blue, half alpha) { m_color.Set(red, green, blue); m_alpha = alpha; }
   
   void Max(float max) { 
      m_color.Max(max);
      SetAlpha( MIN( pmax, Alpha()));
   }
};

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

inline void HalfColorBufAlpha::operator += ( const HalfColorBufAlpha &other )
{
   m_color += other.Color();
   m_alpha += other.Alpha();
}

inline void HalfColorBufAlpha::operator -= ( const HalfColorBufAlpha &other )
{
   m_color -= other.Color();
   m_alpha -= other.Alpha();
}

inline void HalfColorBufAlpha::operator *= ( float factor )
{
   m_color *= factor;
   m_alpha *= factor;
}

inline void HalfColorBufAlpha::operator /= ( float factor )
{
   m_color /= factor;
   m_alpha /= factor;
}

inline HalfColorBufAlpha HalfColorBufAlpha::operator + ( const HalfColorBufAlpha &other )
{
   m_color += other.Color();
   m_alpha += other.Alpha();
   return HalfColorBufAlpha(*this);
}

inline int HalfColorBufAlpha::operator == ( const HalfColorBufAlpha &other ) const
{
   if (m_color == other.Color() && m_alpha == other.Alpha())
      return TRUE;
   return FALSE;
}

---