G3D::Color3 Class Reference

#include <Color3.h>

Public Member Functions
	Color3 ()
	Initializes to all zero. More...
bool	nonZero () const
	Color3 (const Any &any)
Color3 &	operator= (const Any &a)
Any	toAny () const
	Color3 (class BinaryInput &bi)
	Color3 (float r, float g, float b)
	Color3 (float v)
	Initializes all channels to v. More...
	Color3 (const class Vector3 &v)
	Color3 (const float value[3])
const Color3 &	rgb () const
	Color3 (const Color3 &other)
	Color3 (const class Color3unorm8 &other)
bool	isZero () const
bool	isOne () const
bool	isFinite () const
void	serialize (class BinaryOutput &bo) const
void	deserialize (class BinaryInput &bi)
const float &	operator[] (int i) const
float &	operator[] (int i)
Color3 &	operator= (const Color3 &rkVector)
bool	operator== (const Color3 &rkVector) const
bool	operator!= (const Color3 &rkVector) const
size_t	hashCode () const
Color3	operator+ (const Color3 &rkVector) const
Color3	operator- (const Color3 &rkVector) const
Color3	operator* (float s) const
Color3	operator/ (const Color3 &rkVector) const
Color3	operator* (const Color3 &rkVector) const
Color3	operator/ (float fScalar) const
Color3	operator- () const
Color3 &	operator+= (const Color3 &rkVector)
Color3 &	operator-= (const Color3 &rkVector)
Color3 &	operator*= (const Color3 &rkVector)
Color3 &	operator*= (float fScalar)
Color3 &	operator/= (float fScalar)
bool	fuzzyEq (const Color3 &other) const
bool	fuzzyNe (const Color3 &other) const
float	length () const
Color3	direction () const
float	squaredLength () const
float	dot (const Color3 &rkVector) const
float	unitize (float fTolerance=1e-06f)
Color3	cross (const Color3 &rkVector) const
Color3	unitCross (const Color3 &rkVector) const
Color3	pow (const Color3 &other) const
Color3	pow (float other) const
Color3	max (const Color3 &other) const
Color3	min (const Color3 &other) const
float	min () const
float	max () const
Color3	lerp (const Color3 &other, float a) const
float	sum () const
float	average () const
std::string	toString () const
Color3	bgr () const

Static Public Member Functions
static Color3	fromARGB (uint32)
static Color3	fromASRGB (uint32)
static const Color3 &	wheelRandom ()
static Color3	ansiMap (uint32 i)
static Color3	pastelMap (uint32 i)
static Color3	fromHSV (const Vector3 &_hsv)
static Vector3	toHSV (const Color3 &_rgb)
static Color3	jetColorMap (const float &val)
static Color3	rainbowColorMap (float hue)
static Color3	random ()
static const Color3 &	red ()
static const Color3 &	green ()
static const Color3 &	blue ()
static const Color3 &	purple ()
static const Color3 &	cyan ()
static const Color3 &	yellow ()
static const Color3 &	brown ()
static const Color3 &	orange ()
static const Color3 &	black ()
static const Color3 &	gray ()
static const Color3 &	white ()
static const Color3 &	zero ()
static const Color3 &	one ()

Public Attributes
float	r
float	g
float	b

Private Member Functions
bool	operator< (const Color3 &) const
bool	operator> (const Color3 &) const
bool	operator<= (const Color3 &) const
bool	operator>= (const Color3 &) const

Detailed Description

Do not subclass– this implementation makes assumptions about the memory layout.

Constructor & Destructor Documentation

G3D::Color3::Color3 ( )

inline

Initializes to all zero.

: r(0), g(0), b(0) {}

Here is the caller graph for this function:

G3D::Color3::Color3 ( const Any &  any )

explicit

Parameters

any	Must be in one of the following forms: Color3(#, #, #) Color3(#) Color3::fromARGB(#) Color3::fromASRGB(#) Color3{r = #, g = #, b = #) Color3::one() Color3::zero()

In the current implementation, G3D::Power3, G3D::Radiance3, and G3D::Irradiance3 are typedefs for Color3, so Color3 accepts "Power3" and "Radiance3" as a prefixes as well, e.g., Power3(1,0,0).

 {
 *this = Color3::zero();
 any.verifyNameBeginsWith("Color3", "Power3", "Radiance3", "Irradiance3", "Energy3", "Radiosity3", "Biradiance3");

 switch (any.type()) {
 case Any::TABLE:

 for (Any::AnyTable::Iterator it = any.table().begin(); it.isValid(); ++it) {
 const std::string& key = toLower(it->key);
 if (key == "r") {
 r = it->value;
 } else if (key == "g") {
 g = it->value;
 } else if (key == "b") {
 b = it->value;
 } else {
 any.verify(false, "Illegal key: " + it->key);
 }
 }
 break;

 case Any::ARRAY: // Intentionally falls through
 case Any::EMPTY_CONTAINER:
 { 
 const std::string& name = any.name();
 std::string factoryName;
 size_t i = name.find("::");
 if (i != std::string::npos && i > 1) {
 factoryName = name.substr(i + 2);
 }

 if (factoryName == "") {
 if (any.size() == 1) {
 r = g = b = any[0];
 } else {
 any.verifySize(3);
 r = any[0];
 g = any[1];
 b = any[2];
 }
 } else if (factoryName == "one") {
 any.verifySize(0);
 *this = one();
 } else if (factoryName == "zero") {
 any.verifySize(0);
 *this = zero();
 } else if (factoryName == "fromARGB") {
 *this = Color3::fromARGB((int)any[0].number());
 } else if (factoryName == "fromASRGB") {
 *this = Color3::fromASRGB((int)any[0].number());
 } else {
 any.verify(false, "Expected Color3 constructor");
 }
 }
 break;

 default:
 any.verify(false, "Bad Color3 constructor");
 }
}

Here is the call graph for this function:

G3D::Color3::Color3 ( class BinaryInput &  bi )

explicit

 {
 deserialize(bi);
}

Here is the call graph for this function:

G3D::Color3::Color3 ( float  r, float  g, float  b  )

inline

 {
 r = fX;
 g = fY;
 b = fZ;
}

G3D::Color3::Color3 ( float  v )

inlineexplicit

Initializes all channels to v.

: r(v), g(v), b(v) {}

G3D::Color3::Color3 ( const class Vector3 &  v )

explicit

G3D::Color3::Color3 ( const float  value[3] )

inlineexplicit

 {
 r = afCoordinate[0];
 g = afCoordinate[1];
 b = afCoordinate[2];
}

G3D::Color3::Color3 ( const Color3 &  other )

inline

Initialize from another color.

 {
 r = rkVector.r;
 g = rkVector.g;
 b = rkVector.b;
}

G3D::Color3::Color3

(

const class Color3unorm8 &

other

)

 : r(other.r), g(other.g), b(other.b) {
}

Member Function Documentation

Color3 G3D::Color3::ansiMap ( uint32  i )

static

Generate colors according to the ANSI color set, mod 16.

See also

pastelMap

 {
 static const Color3 map[] = 
 {Color3::black(), Color3::red() * 0.75f, Color3::green() * 0.75f, Color3::yellow() * 0.75f, 
 Color3::blue() * 0.75f, Color3::purple() * 0.75f, Color3::cyan() * 0.75f, Color3::white() * 0.75f,
 Color3::white() * 0.90f, Color3::red(), Color3::green(), Color3::yellow(), Color3::blue(), 
 Color3::purple(), Color3::cyan(), Color3::white()};

 return map[i & 15];
}

Here is the call graph for this function:

float G3D::Color3::average ( ) const

inline

 {
 return sum() / 3.0f;
 }

Here is the call graph for this function:

Color3 G3D::Color3::bgr ( ) const

inline

 {
 return Color3(b, g, r);
 }

Here is the call graph for this function:

const Color3 & G3D::Color3::black ( )

static

 {
 static Color3 c(0.0f, 0.0f, 0.0f);
 return c;
}

Here is the caller graph for this function:

const Color3 & G3D::Color3::blue ( )

static

 {
 static Color3 c(0.0f, 0.0f, 1.0f);
 return c;
}

Here is the caller graph for this function:

const Color3 & G3D::Color3::brown ( )

static

 {
 static Color3 c(0.5f, 0.5f, 0.0f);
 return c;
}

Here is the caller graph for this function:

Color3 G3D::Color3::cross ( const Color3 &  rkVector ) const

inline

 {
 return Color3(g*rkVector.b - b*rkVector.g, b*rkVector.r - r*rkVector.b,
 r*rkVector.g - g*rkVector.r);
}

Here is the call graph for this function:

const Color3 & G3D::Color3::cyan ( )

static

 {
 static Color3 c(0.0f, 0.7f, 1.0f);
 return c;
}

Here is the caller graph for this function:

void G3D::Color3::deserialize

(

class BinaryInput &

bi

)

 {
 r = bi.readFloat32();
 g = bi.readFloat32();
 b = bi.readFloat32();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Color3 G3D::Color3::direction ( ) const

inline

 {
 float lenSquared = r * r + g * g + b * b;

 if (lenSquared != 1.0f) {
 return *this / sqrtf(lenSquared);
 } else {
 return *this;
 }
}

Here is the caller graph for this function:

float G3D::Color3::dot ( const Color3 &  rkVector ) const

inline

 {
 return r*rkVector.r + g*rkVector.g + b*rkVector.b;
}

Color3 G3D::Color3::fromARGB ( uint32  x )

static

Initialize from an HTML-style color (e.g. 0xFF0000 == RED)

 {
 return Color3(Color3unorm8::fromARGB(x));
}

Here is the call graph for this function:

Here is the caller graph for this function:

Color3 G3D::Color3::fromASRGB ( uint32  x )

static

Initialize from an HTML-style color (e.g. 0xFF0000 == RED) by converting from sRGB to RGB.

 {
 return Color3(Color3unorm8::fromARGB(x)).pow(2.2f);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Color3 G3D::Color3::fromHSV ( const Vector3 &  _hsv )

static

Converts from HSV to RGB , note: toHSV(fromHSV(_hsv)) may not be _hsv, if it is at a grey point or black point. The components of _hsv should lie in the unit interval. [Alvy] Ray Smith SIGGRAPH 1978 "Color Gamut Transform Pairs"

 {
 debugAssertM((_hsv.x <= 1.0f && _hsv.x >= 0.0f)
 && (_hsv.y <= 1.0f && _hsv.y >= 0.0f) 
 && ( _hsv.z <= 1.0f && _hsv.z >= 0.0f), "H,S,V must be between [0,1]");
 const int i = iMin(5, G3D::iFloor(6.0 * _hsv.x));
 const float f = 6.0f * _hsv.x - i;
 const float m = _hsv.z * (1.0f - (_hsv.y));
 const float n = _hsv.z * (1.0f - (_hsv.y * f));
 const float k = _hsv.z * (1.0f - (_hsv.y * (1 - f)));
 switch(i) {
 case 0:
 return Color3(_hsv.z, k, m);
 
 case 1:
 return Color3(n, _hsv.z, m);
 
 case 2:
 return Color3(m, _hsv.z, k);
 
 case 3:
 return Color3(m, n, _hsv.z);
 
 case 4:
 return Color3(k, m, _hsv.z);
 
 case 5:
 return Color3(_hsv.z, m, n);
 
 default:
 debugAssertM(false, "fell through switch..");
 }
 return Color3::black();
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::Color3::fuzzyEq ( const Color3 &  other ) const

inline

 {
 return G3D::fuzzyEq((*this - other).squaredLength(), 0);
}

Here is the call graph for this function:

bool G3D::Color3::fuzzyNe ( const Color3 &  other ) const

inline

 {
 return G3D::fuzzyNe((*this - other).squaredLength(), 0);
}

Here is the call graph for this function:

const Color3 & G3D::Color3::gray ( )

static

 {
 static Color3 c(0.7f, 0.7f, 0.7f);
 return c;
}

const Color3 & G3D::Color3::green ( )

static

 {
 static Color3 c(0.0f, 1.0f, 0.0f);
 return c;
}

Here is the caller graph for this function:

size_t G3D::Color3::hashCode

(

)

const

 {
 unsigned int rhash = (*(int*)(void*)(&r));
 unsigned int ghash = (*(int*)(void*)(&g));
 unsigned int bhash = (*(int*)(void*)(&b));

 return rhash + (ghash * 37) + (bhash * 101);
}

Here is the caller graph for this function:

bool G3D::Color3::isFinite

(

)

const

 {
 return G3D::isFinite(r) && G3D::isFinite(g) && G3D::isFinite(b);
}

Here is the call graph for this function:

bool G3D::Color3::isOne ( ) const

inline

 {
 return (r == 1.0f) && (g == 1.0f) && (b == 1.0f);
 }

bool G3D::Color3::isZero ( ) const

inline

 {
 return (r == 0.0f) && (g == 0.0f) && (b == 0.0f);
 }

Color3 G3D::Color3::jetColorMap ( const float &  val )

static

Duplicates the matlab jet colormap maps [0,1] –> (r,g,b) where blue is close to 0 and red is close to 1.

 {
 debugAssertM(val <= 1.0f && val >= 0.0f , "value should be in [0,1]");

 //truncated triangles where sides have slope 4
 Color3 jet;

 jet.r = G3D::min(4.0f * val - 1.5f,-4.0f * val + 4.5f) ;
 jet.g = G3D::min(4.0f * val - 0.5f,-4.0f * val + 3.5f) ;
 jet.b = G3D::min(4.0f * val + 0.5f,-4.0f * val + 2.5f) ;


 jet.r = G3D::clamp(jet.r, 0.0f, 1.0f);
 jet.g = G3D::clamp(jet.g, 0.0f, 1.0f);
 jet.b = G3D::clamp(jet.b, 0.0f, 1.0f);

 return jet;
}

Here is the call graph for this function:

float G3D::Color3::length ( ) const

inline

 {
 return sqrtf(r*r + g*g + b*b);
}

Here is the caller graph for this function:

Color3 G3D::Color3::lerp ( const Color3 &  other, float  a  ) const

inline

 {
 return (*this) + (other - *this) * a; 

 }

Here is the caller graph for this function:

Color3 G3D::Color3::max ( const Color3 &  other ) const

inline

 {
 return Color3(G3D::max(r, other.r), G3D::max(g, other.g), G3D::max(b, other.b));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::Color3::max ( ) const

inline

Largest element

 {
 return G3D::max(G3D::max(r, g), b);
 }

Here is the call graph for this function:

Color3 G3D::Color3::min ( const Color3 &  other ) const

inline

 {
 return Color3(G3D::min(r, other.r), G3D::min(g, other.g), G3D::min(b, other.b));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::Color3::min ( ) const

inline

Smallest element

 {
 return G3D::min(G3D::min(r, g), b);
 }

Here is the call graph for this function:

bool G3D::Color3::nonZero ( ) const

inline

 {
 return (r != 0) || (g != 0) || (b != 0);
 }

const Color3 & G3D::Color3::one ( )

static

 {
 static Color3 c(1.0f, 1.0f, 1.0f);
 return c;
}

Here is the caller graph for this function:

bool G3D::Color3::operator!= ( const Color3 &  rkVector ) const

inline

 {
 return ( r != rkVector.r || g != rkVector.g || b != rkVector.b );
}

Color3 G3D::Color3::operator* ( float  s ) const

inline

 {
 return Color3(r * s, g * s, b * s);
 }

Here is the call graph for this function:

Color3 G3D::Color3::operator* ( const Color3 &  rkVector ) const

inline

 {
 return Color3(r * rkVector.r, g * rkVector.g, b * rkVector.b);
}

Here is the call graph for this function:

Color3 & G3D::Color3::operator*= ( const Color3 &  rkVector )

inline

 {
 r *= rkVector.r;
 g *= rkVector.g;
 b *= rkVector.b;
 return *this;
}

Color3 & G3D::Color3::operator*= ( float  fScalar )

inline

 {
 r *= fScalar;
 g *= fScalar;
 b *= fScalar;
 return *this;
}

Color3 G3D::Color3::operator+ ( const Color3 &  rkVector ) const

inline

 {
 return Color3(r + rkVector.r, g + rkVector.g, b + rkVector.b);
}

Here is the call graph for this function:

Color3 & G3D::Color3::operator+= ( const Color3 &  rkVector )

inline

 {
 r += rkVector.r;
 g += rkVector.g;
 b += rkVector.b;
 return *this;
}

Color3 G3D::Color3::operator- ( const Color3 &  rkVector ) const

inline

 {
 return Color3(r -rkVector.r, g - rkVector.g, b - rkVector.b);
}

Here is the call graph for this function:

Color3 G3D::Color3::operator- ( ) const

inline

 {
 return Color3( -r, -g, -b);
}

Here is the call graph for this function:

Color3 & G3D::Color3::operator-= ( const Color3 &  rkVector )

inline

 {
 r -= rkVector.r;
 g -= rkVector.g;
 b -= rkVector.b;
 return *this;
}

Color3 G3D::Color3::operator/ ( const Color3 &  rkVector ) const

inline

 {
 return Color3(r / rkVector.r, g / rkVector.g, b / rkVector.b);
 }

Here is the call graph for this function:

Color3 G3D::Color3::operator/ ( float  fScalar ) const

inline

 {
 return (*this) * (1.0f / fScalar);
 }

Color3 & G3D::Color3::operator/=

(

float

fScalar

)

 {
 if (fScalar != 0.0f) {
 float fInvScalar = 1.0f / fScalar;
 r *= fInvScalar;
 g *= fInvScalar;
 b *= fInvScalar;
 } else {
 r = (float)G3D::finf();
 g = (float)G3D::finf();
 b = (float)G3D::finf();
 }

 return *this;
}

Here is the call graph for this function:

bool G3D::Color3::operator< ( const Color3 &  ) const

private

bool G3D::Color3::operator<= ( const Color3 &  ) const

private

Color3 & G3D::Color3::operator=

(

const Any &

a

)

 {
 *this = Color3(a);
 return *this;
}

Here is the call graph for this function:

Color3 & G3D::Color3::operator= ( const Color3 &  rkVector )

inline

 {
 r = rkVector.r;
 g = rkVector.g;
 b = rkVector.b;
 return *this;
}

bool G3D::Color3::operator== ( const Color3 &  rkVector ) const

inline

 {
 return ( r == rkVector.r && g == rkVector.g && b == rkVector.b );
}

bool G3D::Color3::operator> ( const Color3 &  ) const

private

bool G3D::Color3::operator>= ( const Color3 &  ) const

private

const float & G3D::Color3::operator[] ( int  i ) const

inline

 {
 return ((float*)this)[i];
}

float & G3D::Color3::operator[] ( int  i )

inline

 {
 return ((float*)this)[i];
}

const Color3 & G3D::Color3::orange ( )

static

 {
 static Color3 c(1.0f, 0.5f, 0.0f);
 return c;
}

Here is the caller graph for this function:

Color3 G3D::Color3::pastelMap ( uint32  i )

static

Generate colors using a hash such that adjacent values are unlikely to have similar colors.

Useful for rendering with stable but arbitrary colors, e.g., when debugging a mesh algorithm.

See also

ansiMap

 {
 uint32 x = Crypto::crc32(&i, sizeof(uint32));
 // Create fairly bright, saturated colors
 Vector3 v(((x >> 22) & 1023) / 1023.0f,
 (((x >> 11) & 2047) / 2047.0f) * 0.5f + 0.25f, 
 ((x & 2047) / 2047.0f) * 0.75f + 0.25f);
 return Color3::fromHSV(v);
}

Here is the call graph for this function:

Color3 G3D::Color3::pow ( const Color3 &  other ) const

inline

 {
 return Color3(::pow(r, other.r), ::pow(g, other.g), ::pow(b, other.b));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Color3 G3D::Color3::pow ( float  other ) const

inline

 {
 return Color3(::pow(r, other), ::pow(g, other), ::pow(b, other));
 }

Here is the call graph for this function:

const Color3 & G3D::Color3::purple ( )

static

 {
 static Color3 c(0.7f, 0.0f, 1.0f);
 return c;
}

Here is the caller graph for this function:

Color3 G3D::Color3::rainbowColorMap ( float  hue )

static

Returns colors with maximum saturation and value

Parameters

hue

[0, 1]

 {
 return fromHSV(Vector3(hue, 1.0f, 1.0f));
}

Here is the call graph for this function:

Color3 G3D::Color3::random ( )

static

Random unit vector

 {
 return Color3(uniformRandom(), 
 uniformRandom(),
 uniformRandom()).direction();
}

Here is the call graph for this function:

const Color3 & G3D::Color3::red ( )

static

 {
 static Color3 c(1.0f, 0.0f, 0.0f);
 return c;
}

Here is the caller graph for this function:

const Color3& G3D::Color3::rgb ( ) const

inline

Returns this color

 {
 return *this;
 }

void G3D::Color3::serialize

(

class BinaryOutput &

bo

)

const

 {
 bo.writeFloat32(r);
 bo.writeFloat32(g);
 bo.writeFloat32(b);
}

Here is the call graph for this function:

float G3D::Color3::squaredLength ( ) const

inline

 {
 return r*r + g*g + b*b;
}

Here is the caller graph for this function:

float G3D::Color3::sum ( ) const

inline

 {
 return r + g + b;
 }

Here is the caller graph for this function:

Any G3D::Color3::toAny

(

)

const

Converts the Color3 to an Any.

 {
 Any a(Any::ARRAY, "Color3");
 a.append(r, g, b);
 return a;
}

Here is the call graph for this function:

Vector3 G3D::Color3::toHSV ( const Color3 &  _rgb )

static

 {
 debugAssertM((_rgb.r <= 1.0f && _rgb.r >= 0.0f) 
 && (_rgb.g <= 1.0f && _rgb.g >= 0.0f)
 && (_rgb.b <= 1.0f && _rgb.b >= 0.0f), "R,G,B must be between [0,1]");
 Vector3 hsv = Vector3::zero();
 hsv.z = G3D::max(G3D::max(_rgb.r, _rgb.g), _rgb.b);
 if (G3D::fuzzyEq(hsv.z, 0.0f)) {
 return hsv;
 }
 
 const float x = G3D::min(G3D::min(_rgb.r, _rgb.g), _rgb.b);
 hsv.y = (hsv.z - x) / hsv.z; 

 if (G3D::fuzzyEq(hsv.y, 0.0f)) {
 return hsv;
 }

 Vector3 rgbN;
 rgbN.x = (hsv.z - _rgb.r) / (hsv.z - x);
 rgbN.y = (hsv.z - _rgb.g) / (hsv.z - x);
 rgbN.z = (hsv.z - _rgb.b) / (hsv.z - x);

 if (_rgb.r == hsv.z) { // note from the max we know that it exactly equals one of the three.
 hsv.x = (_rgb.g == x)? 5.0f + rgbN.z : 1.0f - rgbN.y;
 } else if (_rgb.g == hsv.z) {
 hsv.x = (_rgb.b == x)? 1.0f + rgbN.x : 3.0f - rgbN.z;
 } else {
 hsv.x = (_rgb.r == x)? 3.0f + rgbN.y : 5.0f - rgbN.x;
 }
 
 hsv.x /= 6.0f;

 return hsv;
}

Here is the call graph for this function:

std::string G3D::Color3::toString

(

)

const

 {
 return G3D::format("(%g, %g, %g)", r, g, b);
}

Here is the call graph for this function:

Color3 G3D::Color3::unitCross ( const Color3 &  rkVector ) const

inline

 {
 Color3 kCross(g*rkVector.b - b*rkVector.g, b*rkVector.r - r*rkVector.b,
 r*rkVector.g - g*rkVector.r);
 return kCross.direction();
}

Here is the call graph for this function:

float G3D::Color3::unitize

(

float

fTolerance = 1e-06f

)

                                       {
    float fLength = length();

    if ( fLength > fTolerance ) {
        float fInvLength = 1.0f / fLength;
        r *= fInvLength;
        g *= fInvLength;
        b *= fInvLength;
    } else {
        fLength = 0.0f;
    }

    return fLength;
}

Here is the call graph for this function:

const Color3 & G3D::Color3::wheelRandom ( )

static

Returns one of the color wheel colors (e.g. RED, GREEN, CYAN). Does not include white, black, or gray.

                                  {
    static const Color3 colorArray[8] =
    {Color3::blue(),   Color3::red(),    Color3::green(),
     Color3::orange(), Color3::yellow(), 
     Color3::cyan(),   Color3::purple(), Color3::brown()};

    return colorArray[iRandom(0, 7)];
}

Here is the call graph for this function:

const Color3 & G3D::Color3::white ( )

static

                            {
    static Color3 c(1.0f, 1.0f, 1.0f);
    return c;
}

Here is the caller graph for this function:

const Color3 & G3D::Color3::yellow ( )

static

                             {
    static Color3 c(1.0f, 1.0f, 0.0f);
    return c;
}

Here is the caller graph for this function:

const Color3 & G3D::Color3::zero ( )

static

                           {
    static Color3 c(0.0f, 0.0f, 0.0f);
    return c;
}

Here is the caller graph for this function:

Member Data Documentation

float G3D::Color3::b

float G3D::Color3::g

float G3D::Color3::r

Channel value.

---

The documentation for this class was generated from the following files:

• dep/g3dlite/include/G3D/Color3.h
• dep/g3dlite/source/Color3.cpp