Public API Reference

csgfx/rgbpixel.h

Go to the documentation of this file.

/*
    Copyright (C) 1998 by Jorrit Tyberghein
    Contributions made by Ivan Avramovic <[email protected]>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

//-----------------------------------------------------------------------------
// Implementation Note: Eric Sunshine <[email protected]>      1999/02/09
//
// Certain portions of the Crystal Space code have strict requirements about
// the sizes of the structures csRGBcolor and csRGBpixel.  In particular, some
// pieces of code make these assumptions:
//
//    sizeof(csRGBcolor) == 3  (byte:rgb)
//    sizeof(csRGBpixel) == 4  (byte:rgb + byte:alpha)
//
// Originally, csRGBpixel was implemented as a subclasse of csRGBcolor and
// added a byte-sized "alpha" variable.  Thus, the original implementation made
// the assumption that the compiler would not pad out the csRGBcolor structure.
//
// Unfortunately in some environments (such as the NextStep compiler on M68K
// hardware) the compiler does pad csRGBcolor thus breaking the original
// assumptions about structure sizes.  In such cases, csRGBcolor is padded out
// to 4 bytes instead of 3 and csRGBpixel is padded out to 6 bytes instead of
// 4.  This padding results in problems in code which makes assumptions about
// the sizes of each structure.  In practice, problems were observed in code
// which expected csRGBpixel to be 4 bytes.
//
// To work around this problem, csRGBpixel has been re-implemented so that it
// is no longer derived from csRGBcolor.  An unfortunate side-effect of this
// re-implementation is that code is no longer inherited, and is thus
// duplicated in each class.  However, except for this minor point, the size of
// each structure should now be more stable between various compilers.
//-----------------------------------------------------------------------------

#ifndef __CS_RGBPIXEL_H__
#define __CS_RGBPIXEL_H__

#include "csextern.h"
#include "csutil/comparator.h"


CS_STRUCT_ALIGN_4BYTE_BEGIN
struct csRGBcolor
{
  unsigned char red, green, blue;
  csRGBcolor () : red(0), green(0), blue(0) {}
  csRGBcolor (unsigned char r, unsigned char g, unsigned char b) :
    red(r), green(g), blue(b) {}
  void Set (unsigned char r, unsigned char g, unsigned char b)
  { red = r; green = g; blue = b; }
  bool operator == (const csRGBcolor& c) const
  { return (c.red == red) && (c.green == green) && (c.blue == blue); }
  bool operator != (const csRGBcolor& c) const
  { return !operator == (c); }
  csRGBcolor operator + (const csRGBcolor& c) const
  { return csRGBcolor (
    (unsigned char)(c.red + red),
    (unsigned char)(c.green + green),
    (unsigned char)(c.blue + blue)); }
  void UnsafeAdd (const csRGBcolor& c)
  {
    red   = (unsigned char)(red   + c.red  );
    green = (unsigned char)(green + c.green);
    blue  = (unsigned char)(blue  + c.blue );
  }
  void SafeAdd (const csRGBcolor& c)
  {
    int color = red + c.red;
    red   = (unsigned char)(color > 255 ? 255 : color);
    color = green + c.green;
    green = (unsigned char)(color > 255 ? 255 : color);
    color = blue + c.blue;
    blue  = (unsigned char)(color > 255 ? 255 : color);
  }
} CS_STRUCT_ALIGN_4BYTE_END;


template<>
class csComparator<csRGBcolor, csRGBcolor>
{
public:
  static int Compare (csRGBcolor const& r1, csRGBcolor const& r2)
  {
    if (r1.red != r2.red)
      return (int)r1.red - (int)r2.red;
    if (r1.green != r2.green)
      return (int)r1.green - (int)r2.green;
    if (r1.blue != r2.blue)
      return (int)r1.blue - (int)r2.blue;
    return 0;
  }
};

template<>
class csComparator<csRGBcolor*, csRGBcolor*> 
{
public:
  static int Compare (csRGBcolor* const& r1, csRGBcolor* const& r2)
  { return csComparator<csRGBcolor, csRGBcolor>::Compare (*r1, *r2); }
};

CS_STRUCT_ALIGN_4BYTE_BEGIN
struct csRGBpixel
{
  unsigned char red, green, blue, alpha;
  csRGBpixel () : red(0), green(0), blue(0), alpha(255) {}
  csRGBpixel (const csRGBpixel& p) :
    red (p.red), green (p.green), blue (p.blue), alpha (p.alpha) {}
  csRGBpixel (const csRGBcolor& c) :
    red (c.red), green (c.green), blue (c.blue), alpha (255) {}
  csRGBpixel (int r, int g, int b, int a = 255) :
    red ((unsigned char)r),
    green ((unsigned char)g),
    blue ((unsigned char)b),
    alpha ((unsigned char)a) {}
  bool operator == (const csRGBcolor& c) const
  { return (c.red == red) && (c.green == green) && (c.blue == blue); }
  bool operator == (const csRGBpixel& p) const
  { return (p.red == red) && (p.green == green) && (p.blue == blue); }
  bool operator != (const csRGBcolor& c) const
  { return !operator == (c); }
  bool operator != (const csRGBpixel& p) const
  { return !operator == (p); }
  operator csRGBcolor () const
  { return csRGBcolor (red, green, blue); }
  bool eq (const csRGBpixel& p) const
  { return operator==(p); }
  int Intensity () const
  { return (red + green + blue) / 3; }
  unsigned char Luminance () const
  {
    return (unsigned char)(((int)red*30 + (int)green*59 + (int)blue*11) / 100);
  }
  void Set (const int r, const int g, const int b, const int a = 255)
  {
    red = (unsigned char)r;
    green = (unsigned char)g;
    blue = (unsigned char)b;
    alpha = (unsigned char)a;
  }
  void Set (const csRGBpixel& p)
  { red = p.red; green = p.green; blue = p.blue; alpha = p.alpha; }
  void operator += (const csRGBcolor& c)
  {
      red   = (unsigned char)(red   + c.red  );
      green = (unsigned char)(green + c.green);
      blue  = (unsigned char)(blue  + c.blue );
  }
  void UnsafeAdd (const csRGBpixel& c)
  {
    red   = (unsigned char)(red   + c.red  );
    green = (unsigned char)(green + c.green);
    blue  = (unsigned char)(blue  + c.blue );
  }
  void SafeAdd (const csRGBpixel& c)
  {
    int color = red + c.red;
    red   = (unsigned char)(color > 255 ? 255 : color);
    color = green + c.green;
    green = (unsigned char)(color > 255 ? 255 : color);
    color = blue + c.blue;
    blue  = (unsigned char)(color > 255 ? 255 : color);
  }
} CS_STRUCT_ALIGN_4BYTE_END;



#define R_COEF          173
#define G_COEF          242
#define B_COEF          107


#define R_COEF_SQ       299
#define G_COEF_SQ       587
#define B_COEF_SQ       114

#endif // __CS_RGBPIXEL_H__

---