Public API Reference

csutil/cscolor.h

Go to the documentation of this file.

/*
    Copyright (C) 1998-2001 by Jorrit Tyberghein

    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.
*/

#ifndef __CS_CSCOLOR_H__
#define __CS_CSCOLOR_H__

#include "csextern.h"

class csColor
{
public:
  float red;
  float green;
  float blue;
public:
  csColor () { }
  csColor (float r, float g, float b)
  { red = r; green = g; blue = b; }
  csColor (const csColor& c)
  { red = c.red; green = c.green; blue = c.blue; }
  void Set (float r, float g, float b)
  { red = r; green = g; blue = b; }
  void Set (const csColor& c)
  { red = c.red; green = c.green; blue = c.blue; }
  void Clamp (float r, float g, float b)
  {
    if (red > r) red = r;
    if (green > g) green = g;
    if (blue > b) blue = b;
  }
  void ClampDown ()
  {
    if (red < 0) red = 0;
    if (green < 0) green = 0;
    if (blue < 0) blue = 0;
  }
  csColor& operator= (const csColor& c)
  { red = c.red; green = c.green; blue = c.blue; return *this; }
  csColor& operator*= (float f)
  { red *= f; green *= f; blue *= f; return *this; }
  csColor& operator+= (const csColor& c)
  { red += c.red; green += c.green; blue += c.blue; return *this; }
  csColor& operator-= (const csColor& c)
  { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
  csColor& operator*= (const csColor& c)
  { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
  csColor operator * (const float f)
  {
    csColor ret;
    ret.red = red*f;
    ret.green = green*f;
    ret.blue = blue*f;
    return ret;
  }
  bool operator== (const csColor& c) const
  { return red == c.red && green == c.green && blue == c.blue; }
  bool operator!= (const csColor& c) const
  { return red != c.red || green != c.green || blue != c.blue; }
  void Add (float r, float g, float b)
  { red += r; green += g; blue += b; }
  void Subtract (float r, float g, float b)
  { red -= r; green -= g; blue -= b; }
};

inline csColor operator/ (const csColor& v, float f)
{ f = 1.0f/f; return csColor(v.red*f, v.green*f, v.blue*f); }
inline csColor operator* (const csColor& v1, const csColor& v2)
{
  return csColor (v1.red * v2.red,
                  v1.green * v2.green,
                  v1.blue * v2.blue);
}


inline csColor operator* (const csColor& s, float f)
{ csColor c (s); c *= f; return c; }

inline csColor operator* (float f, const csColor& s)
{ csColor c (s); c *= f; return c; }

inline csColor operator+ (const csColor& s1, const csColor& s2)
{ csColor c (s1); c += s2; return c; }
inline csColor operator- (const csColor& s1, const csColor& s2)
{ csColor c (s1); c -= s2; return c; }

class csColor4 : public csColor
{
public:
  float alpha;

  csColor4 () { }
  csColor4 (float r, float g, float b, float a = 1.0f) : csColor (r, g, b)
  { alpha = a; }
  csColor4 (const csColor& c) : csColor (c), alpha (1.0f) { }
  void Set (const csColor& c)
  {
    red = c.red;
    green = c.green;
    blue = c.blue;
    alpha = 1.0f;
  }
  void Set (const csColor4& c)
  {
    red = c.red;
    green = c.green;
    blue = c.blue;
    alpha = c.alpha;
  }
  void Set (float r, float g, float b)
  {
    red = r;
    green = g;
    blue = b;
    alpha = 1.0f;
  }
  void Set (float r, float g, float b, float a)
  {
    red = r;
    green = g;
    blue = b;
    alpha = a;
  }
  csColor4& operator= (const csColor4& c)
  {
    red = c.red;
    green = c.green;
    blue = c.blue;
    alpha = c.alpha;
    return *this;
  }
  csColor4& operator= (const csColor& c)
  { red = c.red; green = c.green; blue = c.blue; alpha = 1.0f; return *this; }
  csColor4& operator*= (float f)
  { red *= f; green *= f; blue *= f; alpha *= f; return *this; }
  csColor4& operator+= (const csColor4& c)
  {
    red += c.red;
    green += c.green;
    blue += c.blue;
    alpha += c.alpha;
    return *this;
  }
  csColor4& operator+= (const csColor& c)
  { red += c.red; green += c.green; blue += c.blue; return *this; }
  csColor4& operator-= (const csColor4& c)
  {
    red -= c.red;
    green -= c.green;
    blue -= c.blue;
    alpha -= c.alpha;
    return *this;
  }
  csColor& operator-= (const csColor& c)
  { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
  bool operator== (const csColor4& c) const
  {
    return red == c.red &&
           green == c.green &&
           blue == c.blue &&
           alpha == c.alpha;
  }
  bool operator!= (const csColor4& c) const
  {
    return red != c.red ||
           green != c.green ||
           blue != c.blue ||
           alpha != c.alpha;
  }
};


inline csColor4 operator/ (const csColor4& v, float f)
{ f = 1.0f/f; return csColor4(v.red*f, v.green*f, v.blue*f); }
inline csColor4 operator* (const csColor4& v1, const csColor4& v2)
{
  return csColor4 (v1.red * v2.red,
    v1.green * v2.green,
    v1.blue * v2.blue);
}


inline csColor4 operator* (const csColor4& s, float f)
{ csColor4 c (s); c *= f; return c; }

inline csColor4 operator* (float f, const csColor4& s)
{ csColor4 c (s); c *= f; return c; }

inline csColor4 operator+ (const csColor4& s1, const csColor4& s2)
{ csColor4 c (s1); c += s2; return c; }
inline csColor4 operator- (const csColor4& s1, const csColor4& s2)
{ csColor4 c (s1); c -= s2; return c; }

#endif // __CS_CSCOLOR_H__

---