#include <CUColor4.h>

Public Member Functions
	Color4 ()

	Color4 (GLubyte r, GLubyte g, GLubyte b, GLubyte a=255)

	Color4 (GLuint color)

	Color4 (const float *array)

	Color4 (const std::string color)

Color4 &	operator= (GLuint color)

Color4 &	operator= (const float *array)

Color4 &	operator= (const std::string name)

Color4 &	set (GLubyte r, GLubyte g, GLubyte b, GLubyte a=255)

Color4 &	set (const float *array)

Color4 &	set (GLuint color)

Color4 &	set (const Color4 c)

Color4 &	set (const std::string name)

Color4 &	setHSV (float h, float s, float v, GLubyte a=255)

Color4 &	setHSL (float h, float s, float l, GLubyte a=255)

Color4 &	clamp (Color4 min, Color4 max)

Color4	getClamp (Color4 min, Color4 max) const

Color4 &	add (Color4 c, bool alpha=false)

Color4 &	add (GLubyte r, GLubyte g, GLubyte b, GLubyte a=0)

Color4 &	subtract (Color4 c, bool alpha=false)

Color4 &	subtract (GLubyte r, GLubyte g, GLubyte b, GLubyte a=0)

Color4 &	scale (float s, bool alpha=false)

Color4 &	scale (float sr, float sg, float sb, float sa=1)

Color4 &	scale (Color4 c, bool alpha=false)

Color4 &	map (std::function< GLubyte(GLubyte)> func, bool alpha=false)

Color4	getMap (std::function< GLubyte(GLubyte)> func, bool alpha=false) const

Color4 &	complement (bool alpha=false)

Color4	getComplement (bool alpha=false) const

Color4 &	lerp (const Color4f other, float alpha)

Color4 &	blend (Color4 other)

Color4 &	blendPre (Color4 other)

Color4 &	premultiply ()

Color4 &	unpremultiply ()

Color4	getLerp (Color4 other, float alpha) const

Color4	getBlend (Color4 other) const

Color4	getBlendPre (Color4 other) const

Color4	getPremultiplied () const

Color4	getUnpremultiplied () const

Color4 &	operator+= (Color4 c)

Color4 &	operator-= (Color4 c)

Color4 &	operator*= (float s)

Color4 &	operator*= (Color4 c)

const Color4	operator+ (Color4 c) const

const Color4	operator- (Color4 c) const

const Color4	operator* (float s) const

const Color4	operator* (Color4 c) const

bool	operator< (Color4 c) const

bool	operator<= (Color4 c) const

bool	operator> (Color4 c) const

bool	operator>= (Color4 c) const

bool	operator== (Color4 c) const

bool	operator!= (Color4 c) const

bool	darkerThan (Color4 c) const

bool	lighterThan (Color4 c) const

std::string	toString (bool verbose=false) const

	operator std::string () const

	operator Vec4 () const

	Color4 (const Vec4 vector)

Color4 &	operator= (const Vec4 vector)

	operator Vec3 () const

	Color4 (const Vec3 vector)

Color4 &	operator= (const Vec3 vector)

	operator Color4f () const

	Color4 (const Color4f color)

Color4 &	operator= (const Color4f color)

float *	get (float *array) const

GLuint	getRGBA () const

GLuint	getPacked () const

Static Public Member Functions
static Color4 *	lerp (Color4 c1, Color4 c2, float alpha, Color4 *dst)

static Color4 *	blend (Color4 c1, Color4 c2, Color4 *dst)

static Color4 *	blendPre (Color4 c1, Color4 c2, Color4 *dst)

Public Attributes
union {
struct {
GLubyte r

GLubyte g

GLubyte b

GLubyte a

}

Uint32 rgba

};

Static Public Attributes
static const Color4	CLEAR

static const Color4	WHITE

static const Color4	BLACK

static const Color4	YELLOW

static const Color4	BLUE

static const Color4	GREEN

static const Color4	RED

static const Color4	MAGENTA

static const Color4	CYAN

static const Color4	ORANGE

static const Color4	GRAY

static const Color4	CORNFLOWER

static const Color4	PAPYRUS

Detailed Description

This class is a RGBA color composed of 4 unsigned bytes.

This is the preferred (non-transparent) color class for storage. It is slightly slower on calculations, because it often has to shift to 0..1 for all its values. It is also slower to cast to Vec3.

Constructor & Destructor Documentation

◆ Color4() [1/8]

cugl::Color4::Color4 ( )

inline

Constructs a new clear color (all zeros).

◆ Color4() [2/8]

cugl::Color4::Color4	(	GLubyte	r,
		GLubyte	g,
		GLubyte	b,
		GLubyte	a = `255`
	)

inline

Constructs a new color initialized to the specified values.

Parameters

r	The red color.
g	The green color.
b	The blue color.
a	The alpha value (optional).

◆ Color4() [3/8]

cugl::Color4::Color4 ( GLuint color )

inline

Creates a new color from an integer interpreted as an RGBA value.

This representation assigned is native to the platform, but the integer parameter is interpreted in network order, which matches the way web colors are specified. In this order, red will always be the highest order byte and alpha will always be the lowest order byte. Hence
0x00ff00ff represents green or the color (0, 1, 0, 1).

Parameters

color The integer to interpret as an RGBA value.

◆ Color4() [4/8]

cugl::Color4::Color4 ( const float * array )

Constructs a new color from the values in the specified array.

The color values must all be in the range 0..1. They are multiplied by 255.0 and rounded up.

Parameters

array An array containing the color values in the order r, g, b, a.

◆ Color4() [5/8]

cugl::Color4::Color4 ( const std::string color )

Creates a new color from an string represenation

A string representation may either be an explicit name or a (modified) HTML code. The supported color names are the classic TCL/TK colors, which are listed here:

https://www.tcl.tk/man/tcl8.6/TkCmd/colors.htm

An HTML code is a string that starts with #, followed by the characters 0-9, A-F. This is the hex representation of the color, as specified here:

https://htmlcolorcodes.com

We support 3, 4, 6, and 8 character codes (not including the #). The standard code is 6 characters, but that does not specify the alpha value.
If you specify eight characters, the last two characters specify the byte values for alpha, following the same rules for red, green, blue.

Finally, the 3 and 4 character versions are the abbreviated 6 and 8 character versions, respectively. In these versions, the byte values are repeated. So #fa2 becomes #ffaa22 and #fad3 becomes #ffaadd33.

Parameters

color The integer to interpret as an RGBA value.

◆ Color4() [6/8]

cugl::Color4::Color4 ( const Vec4 vector )

explicit

Creates a color from the given vector.

The attributes are read in the order x,y,z,w. They are all multiplied by 255.0f and rounded up before assignment.

Parameters

vector The vector to convert

◆ Color4() [7/8]

cugl::Color4::Color4 ( const Vec3 vector )

explicit

Creates a color from the given vector.

The attributes are read in the order x,y,z. They are all multiplied by 255.0f and rounded up before assignment. The alpha value is 255.

Parameters

vector The vector to convert

◆ Color4() [8/8]

cugl::Color4::Color4 ( const Color4f color )

explicit

Creates a byte-based color from the given float-based color.

The attributes are read in the order r,g,b,a. They are all multiplied by 255.0f and rounded up before assignment.

Parameters

color The color to convert

Member Function Documentation

◆ add() [1/2]

Color4& cugl::Color4::add	(	Color4	c,
		bool	alpha = `false`
	)

inline

Adds the given color to this one in place.

This operation is functionally identical to additive blending. The addition is clamped so that this remains a valid color.

Parameters

c	The color to add
alpha	Whether to add the alpha values (optional)

Returns: A reference to this (modified) Color4 for chaining.

◆ add() [2/2]

Color4& cugl::Color4::add	(	GLubyte	r,
		GLubyte	g,
		GLubyte	b,
		GLubyte	a = `0`
	)

inline

Adds the given values to this color.

The addition is clamped so that this remains a valid color.

Parameters

r	The red color to add.
g	The green color to add.
b	The blue color to add.
a	The alpha value (optional).

Returns: A reference to this (modified) Color4 for chaining.

◆ blend() [1/2]

static Color4* cugl::Color4::blend	(	Color4	c1,
		Color4	c2,
		Color4 *	dst
	)

static

Blends the two colors c1 and c2, assuming they are not premultiplied.

The blending is the standard over operation with color c1 as the source and c2 as the destination. It assumes that the color values are not premultiplied.

Parameters

c1	The source color.
c2	The destination color.
dst	The color to store the result in

Returns: A reference to dst for chaining

◆ blend() [2/2]

Color4& cugl::Color4::blend ( Color4 other )

Blends this color with the other one, storing the new value in place.

The blending is the standard over operation with this color as the destination. It assumes that the color values are not premultiplied.

Parameters

other The color to interpolate with.

Returns: This color, after the blending.

◆ blendPre() [1/2]

static Color4* cugl::Color4::blendPre	(	Color4	c1,
		Color4	c2,
		Color4 *	dst
	)

static

Blends the two colors c1 and c2, assuming they are premultiplied.

The blending is the standard over operation with color c1 as the source and c2 as the destination. It assumes that the color values are premultiplied.

Parameters

c1	The source color.
c2	The destination color.
dst	The color to store the result in

Returns: A reference to dst for chaining

◆ blendPre() [2/2]

Color4& cugl::Color4::blendPre ( Color4 other )

Blends this color with the other one, storing the new value in place.

The blending is the standard over operation with this color as the destination. It assumes that this color is premultiplied.

Parameters

other The color to interpolate with.

Returns: This color, after the blending.

◆ clamp()

Color4& cugl::Color4::clamp	(	Color4	min,
		Color4	max
	)

Clamps this color within the given range.

Parameters

min	The minimum value.
max	The maximum value.

Returns: A reference to this (modified) Color4 for chaining.

◆ complement()

Color4& cugl::Color4::complement ( bool alpha = false )

inline

Complements this color.

The complement of the color is the (255-v) for each value v.

Parameters

alpha Whether to complement the alpha value (optional)

Returns: A reference to this (modified) Color4f for chaining.

◆ darkerThan()

bool cugl::Color4::darkerThan ( Color4 c ) const

inline

Returns true if this color is dominated by the given color.

Domination means that all components of the given color are greater than or equal to the components of this one. However, alpha is reversed for this computation, as a greater value means more opaque (and hence darker).

Parameters

c	The color to compare against.

Returns: True if this color is dominated by the given color.

◆ get()

float* cugl::Color4::get ( float * array ) const

Writes the color values into a float array.

The attributes are read into the array in the order r,g,b,a. All values are divided by 255.0f (so they are between 0 and 1) before assignment.

Parameters

array The array to store the color values.

Returns: A reference to the array for chaining.

◆ getBlend()

Color4 cugl::Color4::getBlend ( Color4 other ) const

Returns a blend of this color with the other one.

The blending is the standard over operation with this color as the destination. It assumes that the color values are not premultiplied.

Note: this does not modify this color.

Parameters

other The color to interpolate with.

Returns: The newly blended color

◆ getBlendPre()

Color4 cugl::Color4::getBlendPre ( Color4 other ) const

Returns a blend of this color with the other one.

The blending is the standard over operation with this color as the destination. It assumes that this color is premultiplied.

Note: this does not modify this color.

Parameters

other The color to interpolate with.

Returns: The newly blended color

◆ getClamp()

Color4 cugl::Color4::getClamp	(	Color4	min,
		Color4	max
	)		const

inline

Returns a copy of this color clamped within the given range.

Note: this does not modify this color.

Parameters

min	The minimum value.
max	The maximum value.

Returns: A copy of this color clamped within the given range.

◆ getComplement()

Color4 cugl::Color4::getComplement ( bool alpha = false ) const

inline

Returns the complement of this color.

The complement of the color is the (255-v) for each value v.

Parameters

alpha Whether to complement the alpha value (optional)

Note: this does not modify this color.

Returns: The complement of this color

◆ getLerp()

Color4 cugl::Color4::getLerp	(	Color4	other,
		float	alpha
	)		const

inline

Returns the linear interpolation of this color with other.

If alpha is 0, the color is unchanged. If alpha is 1, the color is other. Otherwise it is a value in between. If alpha is outside of the range 0 to 1, it is clamped to the nearest value.

This method just implements standard linear interpolation. It does not attempt to give any blending semantics to it.

Note: this does not modify this color.

Parameters

other	The color to interpolate with.
alpha	The interpolation value in 0..1

Returns: The linear interpolation of this color with other.

◆ getMap()

Color4 cugl::Color4::getMap	(	std::function< GLubyte(GLubyte)>	func,
		bool	alpha = `false`
	)		const

inline

Returns a copy of this color with func applied to each component.

This method supports any function that has the signature Glubyte func(Glubyte). If you wish to use float-oriented function, use Color4f instead.

Parameters

func	The function to map on the color values.
alpha	Whether to modify the alpha value (optional)

Returns: A copy of this color with func applied to each component.

◆ getPacked()

GLuint cugl::Color4::getPacked ( ) const

inline

Returns the packed integer representation of this color

This representation returned is native to the platform. In other words, it is guaranteed to be the same value as if you were to access the rgba attribute directly. That makes this value the correct one to send to OpenGL (which always uses client order).

However, this value is not necessarily the same value that you assigned the constructor, because of endianness issues. To get that value, you should call getRGBA instead.

Returns: the packed integer representation of this color

◆ getPremultiplied()

Color4 cugl::Color4::getPremultiplied ( ) const

inline

Returns the premultiplied version of this color, using its current alpha.

This class does not store whether the color is already premultiplied. Hence premultiplying an already premultiplied color will have a compounding effect.

Note: this does not modify this color.

Returns: The newly premultiplied color

◆ getRGBA()

GLuint cugl::Color4::getRGBA ( ) const

inline

Returns the canonical integer representation of this color

This method returns the color as an integer in network order, which matches the way web colors are specified. In this order, red will always be the highest order byte and alpha will always be the lowest order byte. Hence 0x00ff00ff represents green or the color (0, 1, 0, 1).

The value returned by this method is guaranteed to be the same value that you assigned the constructor, or via setter. However, it is not guaranteed to be a value recognizable by OpenGL. For that value you will need to call getPacked instead.

Returns: the canonical integer representation of this color

◆ getUnpremultiplied()

Color4 cugl::Color4::getUnpremultiplied ( ) const

inline

Returns the unpremultiplied version of this color, using its current alpha.

This class does not store whether the color is already premultiplied. Hence unpremultiplying an non-premultiplied color will have a compounding effect.

If the alpha value is 0, the copy is equal to the original color.

Note: this does not modify this color.

Returns: The newly premultiplied color

◆ lerp() [1/2]

static Color4* cugl::Color4::lerp	(	Color4	c1,
		Color4	c2,
		float	alpha,
		Color4 *	dst
	)

static

Interpolates the two colors c1 and c2, and stores the result in dst.

If alpha is 0, the result is c1. If alpha is 1, the color is c2. Otherwise it is a value in c1..c2. If alpha is outside of the range 0 to 1, it is clamped to the nearest value.

This method just implements standard linear interpolation. It does not attempt to give any blending semantics to it.

Parameters

c1	The first color.
c2	The second color.
alpha	The interpolation value in 0..1
dst	The color to store the result in

Returns: A reference to dst for chaining

◆ lerp() [2/2]

Color4& cugl::Color4::lerp	(	const Color4f	other,
		float	alpha
	)

Modifies this color to be the linear interpolation with other.

If alpha is 0, the color is unchanged. If alpha is 1, the color is other. Otherwise it is a value in between. If alpha is outside of the range 0 to 1, it is clamped to the nearest value.

This method just implements standard linear interpolation. It does not attempt to give any blending semantics to it.

Parameters

other	The color to interpolate with.
alpha	The interpolation value in 0..1

Returns: This color, after the interpolation.

◆ lighterThan()

bool cugl::Color4::lighterThan ( Color4 c ) const

inline

Returns true if this color dominates the given color.

Domination means that all components of this color are greater than or equal to the components of the given color. However, alpha is reversed for this computation, as a lesser value means more transparent (and hence lighter).

Parameters

c	The color to compare against.

Returns: True if this color is dominated by the given color.

◆ map()

Color4& cugl::Color4::map	(	std::function< GLubyte(GLubyte)>	func,
		bool	alpha = `false`
	)

inline

Maps the given function to the color values in place.

This method supports any function that has the signature Glubyte func(Glubyte). If you wish to use float-oriented function, use Color4f instead.

Parameters

func	The function to map on the color values.
alpha	Whether to modify the alpha value (optional)

Returns: A reference to this (modified) Color4f for chaining.

◆ operator Color4f()

cugl::Color4::operator Color4f ( ) const

Cast from Color4f to a float-based Color4.

◆ operator std::string()

cugl::Color4::operator std::string ( ) const

inline

Cast from Color4f to a string.

◆ operator Vec3()

cugl::Color4::operator Vec3 ( ) const

Cast from Color4f to a vector.

The attributes are all divided by 255.0. The alpha value is dropped.

◆ operator Vec4()

cugl::Color4::operator Vec4 ( ) const

Cast from Color4 to a vector.

The attributes are all divided by 255.0.

◆ operator!=()

bool cugl::Color4::operator!= ( Color4 c ) const

inline

Returns true if this color is not equal to the given color.

Comparison is exact, which may be unreliable given that the attributes are floats.

Parameters

c	The color to compare against.

Returns: True if this color is not equal to the given color.

◆ operator*() [1/2]

const Color4 cugl::Color4::operator* ( Color4 c ) const

inline

Returns the scalar product of this color with the given color.

This operation is functionally identical to multiplicative blending.

Note: this does not modify this color.

Parameters

c	The color to scale by.

Returns: The scalar product of this color with the given color.

◆ operator*() [2/2]

const Color4 cugl::Color4::operator* ( float s ) const

inline

Returns the scalar product of this color with the given color.

The scaling is clamped so that this remains a valid color.

This version of scaling always multiplies alpha values.

Note: this does not modify this color.

Parameters

s	The value to scale by.

Returns: The scalar product of this color with the given value.

◆ operator*=() [1/2]

Color4& cugl::Color4::operator*= ( Color4 c )

inline

Scales this color nonuniformly by the given color.

This operation is functionally identical to multiplicative blending.

Parameters

c	The color to scale by

Returns: A reference to this (modified) Color4 for chaining.

◆ operator*=() [2/2]

Color4& cugl::Color4::operator*= ( float s )

inline

Scales this color in place by the given factor.

The scaling is clamped so that this remains a valid color.

This version of scaling always multiplies alpha values.

Parameters

s	The value to scale by

Returns: A reference to this (modified) Color4 for chaining.

◆ operator+()

const Color4 cugl::Color4::operator+ ( Color4 c ) const

inline

Returns the sum of this color with the given color.

This operation is functionally identical to additive blending. The addition is clamped so that this remains a valid color.

This version of addition always adds alpha values.

Note: this does not modify this color.

Parameters

c	The color to add.

Returns: The sum of this color with the given color.

◆ operator+=()

Color4& cugl::Color4::operator+= ( Color4 c )

inline

Adds the given color to this one in place.

This operation is functionally identical to additive blending. The addition is clamped so that this remains a valid color.

This version of addition always adds alpha values.

Parameters

c	The color to add

Returns: A reference to this (modified) Color4 for chaining.

◆ operator-()

const Color4 cugl::Color4::operator- ( Color4 c ) const

inline

Returns the difference of this color with the given color.

This operation is functionally identical to subtractive blending. The subtraction is clamped so that this remains a valid color.

This version of subraction always subtracts alpha values.

Note: this does not modify this color.

Parameters

c	The color to subtract.

Returns: The difference of this color with the given color.

◆ operator-=()

Color4& cugl::Color4::operator-= ( Color4 c )

inline

Subtracts the given color from this one in place.

This operation is functionally identical to subtractive blending. The subtraction is clamped so that this remains a valid color.

This version of subraction always subtracts alpha values.

Parameters

c	The color to subtract

Returns: A reference to this (modified) Color4 for chaining.

◆ operator<()

bool cugl::Color4::operator< ( Color4 c ) const

Returns true if this color is less than the given color.

This comparison uses lexicographical order of rgba. To test if all components in this color are less than those of c, use the method darkerThan().

Parameters

c	The color to compare against.

Returns: True if this color is less than the given color.

◆ operator<=()

bool cugl::Color4::operator<= ( Color4 c ) const

inline

Returns true if this color is less than or equal the given color.

This comparison uses lexicographical order of rgba. To test if all components in this color are less than those of c, use the method darkerThan().

Parameters

c	The color to compare against.

Returns: True if this color is less than or equal the given color.

◆ operator=() [1/6]

Color4& cugl::Color4::operator= ( const Color4f color )

Sets the attributes of this color from the given float-based color.

The attributes are read in the order r,g,b,a. They are all multiplied by 255.0f and rounded up before assignment.

Parameters

color The color to convert.

Returns: A reference to this (modified) Color4f for chaining.

◆ operator=() [2/6]

Color4& cugl::Color4::operator= ( const float * array )

inline

Sets the elements of this color from the values in the specified array.

The color values must all be in the range 0..1. They are multiplied by 255.0 and rounded up

Parameters

array An array containing the color values in the order r, g, b, a

Returns: A reference to this (modified) Color4 for chaining.

◆ operator=() [3/6]

Color4& cugl::Color4::operator= ( const std::string name )

inline

Sets the elements of this color to match the string represenation

A string representation may either be an explicit name or a (modified) HTML code. The supported color names are the classic TCL/TK colors, which are listed here:

https://www.tcl.tk/man/tcl8.6/TkCmd/colors.htm

An HTML code is a string that starts with #, followed by the characters 0-9, A-F. This is the hex representation of the color, as specified here:

https://htmlcolorcodes.com

We support 3, 4, 6, and 8 character codes (not including the #). The standard code is 6 characters, but that does not specify the alpha value.
If you specify eight characters, the last two characters specify the byte values for alpha, following the same rules for red, green, blue.

Finally, the 3 and 4 character versions are the abbreviated 6 and 8 character versions, respectively. In these versions, the byte values are repeated. So #fa2 becomes #ffaa22 and #fad3 becomes #ffaadd33.

Parameters

name	The string name

Returns: A reference to this (modified) Color4f for chaining.

◆ operator=() [4/6]

Color4& cugl::Color4::operator= ( const Vec3 vector )

Sets the coordinates of this color to those of the given vector.

The attributes are read in the order x,y,z. They are all multiplied by 255.0f and rounded up before assignment. The alpha value is 255.

Parameters

vector The vector to convert

Returns: A reference to this (modified) Color4f for chaining.

◆ operator=() [5/6]

Color4& cugl::Color4::operator= ( const Vec4 vector )

Sets the coordinates of this color to those of the given vector.

The attributes are read in the order x,y,z,w. They are all multiplied by 255.0f and rounded up before assignment.

Parameters

vector The vector to convert

Returns: A reference to this (modified) Color4f for chaining.

◆ operator=() [6/6]

Color4& cugl::Color4::operator= ( GLuint color )

inline

Sets this color to the integer interpreted as an RGBA value.

This representation assigned is native to the platform, but the integer parameter is interpreted in network order, which matches the way web colors are specified. In this order, red will always be the highest order byte and alpha will always be the lowest order byte. Hence
0x00ff00ff represents green or the color (0, 1, 0, 1).

Parameters

color The integer to interpret as an RGBA value.

Returns: A reference to this (modified) Color4 for chaining.

◆ operator==()

bool cugl::Color4::operator== ( Color4 c ) const

inline

Returns true if this color is equal to the given color.

Parameters

c	The color to compare against.

Returns: True if this color is equal to the given color.

◆ operator>()

bool cugl::Color4::operator> ( Color4 c ) const

Returns true if this color is greater than the given color.

This comparison uses lexicographical order of rgba. To test if all components in this color are greater than those of c, use the method lighterThan().

Parameters

c	The color to compare against.

Returns: True if this color is greater than the given color.

◆ operator>=()

bool cugl::Color4::operator>= ( Color4 c ) const

inline

Returns true if this color is greater than or equal the given color.

This comparison uses lexicographical order of rgba. To test if all components in this color are greater than those of c, use the method lighterThan().

Parameters

c	The color to compare against.

Returns: True if this color is greater than or equal the given color.

◆ premultiply()

Color4& cugl::Color4::premultiply ( )

inline

Premultiplies this color with its current alpha.

This class does not store whether the color is already premultiplied. Hence premultiplying an already premultiplied color will have a compounding effect.

Returns: This color, after premultiplication.

◆ scale() [1/3]

Color4& cugl::Color4::scale	(	Color4	c,
		bool	alpha = `false`
	)

inline

Scales this color nonuniformly by the given color.

This operation is functionally identical to multiplicative blending.

Parameters

c	The color to scale by
alpha	Whether to scale the alpha value (optional)

Returns: A reference to this (modified) Color4 for chaining.

◆ scale() [2/3]

Color4& cugl::Color4::scale	(	float	s,
		bool	alpha = `false`
	)

inline

Scales this color in place by the given factor.

The scaling is clamped so that this remains a valid color.

Parameters

s	The scalar to multiply by
alpha	Whether to scale the alpha value (optional)

Returns: A reference to this (modified) Color4 for chaining.

◆ scale() [3/3]

Color4& cugl::Color4::scale	(	float	sr,
		float	sg,
		float	sb,
		float	sa = `1`
	)

inline

Scales this color nonuniformly by the given factors.

The scaling is clamped so that this remains a valid color.

Parameters

sr	The scalar to multiply the red value
sg	The scalar to multiply the green value
sb	The scalar to multiply the blue value
sa	The scalar to multiply the alpha value (optional)

Returns: A reference to this (modified) Color4 for chaining.

◆ set() [1/5]

Color4& cugl::Color4::set ( const Color4 c )

inline

Sets the values of this color to those in the specified color.

Parameters

c	The color to copy.

Returns: A reference to this (modified) Color4f for chaining.

◆ set() [2/5]

Color4& cugl::Color4::set ( const float * array )

Sets the elements of this color from the values in the specified array.

The color values must all be in the range 0..1. They are multiplied by 255.0 and rounded up

Parameters

array An array containing the color values in the order r, g, b, a

Returns: A reference to this (modified) Color4 for chaining.

◆ set() [3/5]

Color4& cugl::Color4::set ( const std::string name )

Sets the elements of this color to match the string represenation

A string representation may either be an explicit name or a (modified) HTML code. The supported color names are the classic TCL/TK colors, which are listed here:

https://www.tcl.tk/man/tcl8.6/TkCmd/colors.htm

An HTML code is a string that starts with #, followed by the characters 0-9, A-F. This is the hex representation of the color, as specified here:

https://htmlcolorcodes.com

We support 3, 4, 6, and 8 character codes (not including the #). The standard code is 6 characters, but that does not specify the alpha value.
If you specify eight characters, the last two characters specify the byte values for alpha, following the same rules for red, green, blue.

Finally, the 3 and 4 character versions are the abbreviated 6 and 8 character versions, respectively. In these versions, the byte values are repeated. So #fa2 becomes #ffaa22 and #fad3 becomes #ffaadd33.

Parameters

name	The string name

Returns: A reference to this (modified) Color4f for chaining.

◆ set() [4/5]

Color4& cugl::Color4::set	(	GLubyte	r,
		GLubyte	g,
		GLubyte	b,
		GLubyte	a = `255`
	)

inline

Sets the elements of this color to the specified values.

Parameters

r	The red color.
g	The green color.
b	The blue color.
a	The alpha value (optional).

Returns: A reference to this (modified) Color43 for chaining.

◆ set() [5/5]

Color4& cugl::Color4::set ( GLuint color )

Sets this color to the integer interpreted as an RGBA value.

This representation assigned is native to the platform, but the integer parameter is interpreted in network order, which matches the way web colors are specified. In this order, red will always be the highest order byte and alpha will always be the lowest order byte. Hence
0x00ff00ff represents green or the color (0, 1, 0, 1).

Parameters

color The integer to interpret as an RGBA value.

Returns: A reference to this (modified) Color4 for chaining.

◆ setHSL()

Color4& cugl::Color4::setHSL	(	float	h,
		float	s,
		float	l,
		GLubyte	a = `255`
	)

Sets this color to have the given hue-saturation-lightness

This method will apply the formula given on this page:

 https://en.wikipedia.org/wiki/HSL_and_HSV

Parameters

h	The hue (in radians)
s	The saturation (in range 0..1)
l	The lightness (in range 0..1)
a	The alpha component (in range 0..255)

Returns: A reference to this (modified) Color4f for chaining.

◆ setHSV()

Color4& cugl::Color4::setHSV	(	float	h,
		float	s,
		float	v,
		GLubyte	a = `255`
	)

Sets this color to have the given hue-saturation-value

This method will convert to hue-staturation-lightness and then apply the formula given on this page:

 https://en.wikipedia.org/wiki/HSL_and_HSV

Parameters

h	The hue (in radians)
s	The saturation (in range 0..1)
v	The brightness value (in range 0..1)
a	The alpha component (in range 0..255)

Returns: A reference to this (modified) Color4f for chaining.

◆ subtract() [1/2]

Color4& cugl::Color4::subtract	(	Color4	c,
		bool	alpha = `false`
	)

inline

Subtracts the given color from this one in place.

This operation is functionally identical to subtractive blending. The subtraction is clamped so that this remains a valid color.

Parameters

c	The color to subtract
alpha	Whether to subtract the alpha value (optional)

Returns: A reference to this (modified) Color4 for chaining.

◆ subtract() [2/2]

Color4& cugl::Color4::subtract	(	GLubyte	r,
		GLubyte	g,
		GLubyte	b,
		GLubyte	a = `0`
	)

inline

Subtracts the given values from this color.

The subtraction is clamped so that this remains a valid color.

Parameters

r	The red color to subtract.
g	The green color to subtract.
b	The blue color to subtract.
a	The alpha value (optional).

Returns: A reference to this (modified) Color4 for chaining.

◆ toString()

std::string cugl::Color4::toString ( bool verbose = false ) const

Returns a string representation of this vector for debuggging purposes.

If verbose is true, the string will include class information. This allows us to unambiguously identify the class.

Parameters

verbose Whether to include class information

Returns: a string representation of this vector for debuggging purposes.

◆ unpremultiply()

Color4& cugl::Color4::unpremultiply ( )

inline

Undoes premultiplication this color with its current alpha.

This class does not store whether the color is already premultiplied. Hence unpremultiplying an non-premultiplied color will have a compounding effect.

If the alpha value is 0, the color is unchanged.

Returns: This color, after undoing premultiplication.

Member Data Documentation

◆ a

GLubyte cugl::Color4::a

The alpha value

◆ b

GLubyte cugl::Color4::b

The blue value

◆ BLACK

const Color4 cugl::Color4::BLACK

static

The Black color (0,0,0,1)

◆ BLUE

const Color4 cugl::Color4::BLUE

static

The Blue color (0,0,1,1)

◆ CLEAR

const Color4 cugl::Color4::CLEAR

static

The Clear color (0,0,0,0)

◆ CORNFLOWER

const Color4 cugl::Color4::CORNFLOWER

static

The classic XNA color (0.392,0.584,0.93,1)

◆ CYAN

const Color4 cugl::Color4::CYAN

static

The Cyan color (0,1,1,1)

◆ g

GLubyte cugl::Color4::g

The green value

◆ GRAY

const Color4 cugl::Color4::GRAY

static

The Gray color (0.65,0.65,0.65,1)

◆ GREEN

const Color4 cugl::Color4::GREEN

static

The Green color (0,1,0,1)

◆ MAGENTA

const Color4 cugl::Color4::MAGENTA

static

The Magenta color (1,0,1,1)

◆ ORANGE

const Color4 cugl::Color4::ORANGE

static

The Orange color (1,0.5,0,1)

◆ PAPYRUS

const Color4 cugl::Color4::PAPYRUS

static

The Playing Fields color (0.933f,0.99f,0.65f,1.0f)

◆ r

GLubyte cugl::Color4::r

The red value

◆ RED

const Color4 cugl::Color4::RED

static

The Red color (1,0,0,1)

◆ rgba

Uint32 cugl::Color4::rgba

The color as a packed integer (WARNING: Endian specific)

◆ WHITE

const Color4 cugl::Color4::WHITE

static

The White color (1,1,1,1)

◆ YELLOW

const Color4 cugl::Color4::YELLOW

static

The Yellow color (1,1,0,1)

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

include/cugl/math/CUColor4.h

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Color4() [1/8]

◆ Color4() [2/8]

◆ Color4() [3/8]

◆ Color4() [4/8]

◆ Color4() [5/8]

◆ Color4() [6/8]

◆ Color4() [7/8]

◆ Color4() [8/8]

Member Function Documentation

◆ add() [1/2]

◆ add() [2/2]

◆ blend() [1/2]

◆ blend() [2/2]

◆ blendPre() [1/2]

◆ blendPre() [2/2]

◆ clamp()

◆ complement()

◆ darkerThan()

◆ get()

◆ getBlend()

◆ getBlendPre()

◆ getClamp()

◆ getComplement()

◆ getLerp()

◆ getMap()

◆ getPacked()

◆ getPremultiplied()

◆ getRGBA()

◆ getUnpremultiplied()

◆ lerp() [1/2]

◆ lerp() [2/2]

◆ lighterThan()

◆ map()

◆ operator Color4f()

◆ operator std::string()

◆ operator Vec3()

◆ operator Vec4()

◆ operator!=()

◆ operator*() [1/2]

◆ operator*() [2/2]

◆ operator*=() [1/2]

◆ operator*=() [2/2]

◆ operator+()

◆ operator+=()

◆ operator-()

◆ operator-=()

◆ operator<()

◆ operator<=()

◆ operator=() [1/6]

◆ operator=() [2/6]

◆ operator=() [3/6]

◆ operator=() [4/6]

◆ operator=() [5/6]

◆ operator=() [6/6]

◆ operator==()

◆ operator>()

◆ operator>=()

◆ premultiply()

◆ scale() [1/3]

◆ scale() [2/3]

◆ scale() [3/3]

◆ set() [1/5]

◆ set() [2/5]

◆ set() [3/5]

◆ set() [4/5]

◆ set() [5/5]

◆ setHSL()

◆ setHSV()

◆ subtract() [1/2]

◆ subtract() [2/2]

◆ toString()

◆ unpremultiply()

Member Data Documentation

◆ a