#include <CUVec4.h>

Public Member Functions
	Vec4 ()

	Vec4 (float x, float y, float z, float w)

	Vec4 (const float *array)

	Vec4 (const Vec4 p1, const Vec4 p2)

Vec4 &	operator= (const float *array)

Vec4 &	set (float x, float y, float z, float w)

Vec4 &	set (const float *array)

Vec4 &	set (const Vec4 v)

Vec4 &	set (const Vec4 p1, const Vec4 p2)

Vec4 &	setZero ()

Vec4 &	clamp (const Vec4 min, const Vec4 max)

Vec4	getClamp (const Vec4 min, const Vec4 max) const

Vec4 &	add (const Vec4 v)

Vec4 &	add (float x, float y, float z, float w)

Vec4 &	subtract (const Vec4 v)

Vec4 &	subtract (float x, float y, float z, float w)

Vec4 &	scale (float s)

Vec4 &	scale (float sx, float sy, float sz, float sw)

Vec4 &	scale (const Vec4 v)

Vec4 &	divide (float s)

Vec4 &	divide (float sx, float sy, float sz, float sw)

Vec4 &	divide (const Vec4 v)

Vec4 &	negate ()

Vec4 &	reciprocate ()

Vec4	getNegation () const

Vec4	getReciprocal () const

Vec4 &	map (std::function< float(float)> func)

Vec4	getMap (std::function< float(float)> func) const

Vec4 &	operator+= (const Vec4 v)

Vec4 &	operator-= (const Vec4 v)

Vec4 &	operator*= (float s)

Vec4 &	operator*= (const Vec4 v)

Vec4 &	operator/= (float s)

Vec4 &	operator/= (const Vec4 v)

const Vec4	operator+ (const Vec4 v) const

const Vec4	operator- (const Vec4 v) const

const Vec4	operator- () const

const Vec4	operator* (float s) const

const Vec4	operator* (const Vec4 v) const

const Vec4	operator/ (float s) const

const Vec4	operator/ (const Vec4 v) const

bool	operator< (const Vec4 v) const

bool	operator<= (const Vec4 v) const

bool	operator> (const Vec4 v) const

bool	operator>= (const Vec4 v) const

bool	operator== (const Vec4 v) const

bool	operator!= (const Vec4 v) const

bool	under (const Vec4 v) const

bool	over (const Vec4 v) const

bool	equals (const Vec4 v, float epsilon=CU_MATH_EPSILON) const

bool	isZero () const

bool	isNearZero (float epsilon=CU_MATH_EPSILON) const

bool	isOne () const

bool	isInvertible () const

bool	isUnit (float epsilon=CU_MATH_EPSILON) const

bool	isHomogenous () const

float	getAngle (const Vec4 other) const

float	distance (const Vec4 v) const

float	distanceSquared (const Vec4 v) const

float	length () const

float	lengthSquared () const

float	dot (const Vec4 v) const

Vec4	cross (const Vec4 v)

Vec4 &	normalize ()

Vec4	getNormalization () const

Vec4	getMidpoint (const Vec4 other) const

Vec4 &	project (const Vec4 other)

Vec4	getProjection (const Vec4 other) const

Vec4 &	homogenize ()

Vec4	getHomogenized ()

Vec4 &	lerp (const Vec4 other, float alpha)

Vec4	getLerp (const Vec4 other, float alpha)

void	smooth (const Vec4 target, float elapsed, float response)

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

	operator std::string () const

	operator Color4 () const

	Vec4 (Color4 color)

Vec4 &	operator= (Color4 color)

	operator Color4f () const

	Vec4 (const Color4f color)

Vec4 &	operator= (const Color4f color)

	operator Vec2 () const

	Vec4 (const Vec2 v)

	Vec4 (const Vec2 v, float z, float w)

Vec4 &	operator= (const Vec2 size)

	operator Vec3 () const

	Vec4 (const Vec3 v)

	Vec4 (const Vec3 v, float w)

Vec4 &	operator= (const Vec3 v)

Vec4 &	set (const Vec3 v, float w)

Static Public Member Functions
static Vec4 *	clamp (const Vec4 v, const Vec4 min, const Vec4 max, Vec4 *dst)

static float	angle (const Vec4 v1, const Vec4 v2)

static Vec4 *	add (const Vec4 v1, const Vec4 v2, Vec4 *dst)

static Vec4 *	subtract (const Vec4 v1, const Vec4 v2, Vec4 *dst)

static Vec4 *	scale (const Vec4 v, float s, Vec4 *dst)

static Vec4 *	scale (const Vec4 v1, const Vec4 v2, Vec4 *dst)

static Vec4 *	divide (const Vec4 v, float s, Vec4 *dst)

static Vec4 *	divide (const Vec4 v1, const Vec4 v2, Vec4 *dst)

static Vec4 *	reciprocate (const Vec4 v, Vec4 *dst)

static Vec4 *	negate (const Vec4 v, Vec4 *dst)

static float	dot (const Vec4 v1, const Vec4 v2)

static Vec4 *	cross (const Vec4 v1, const Vec4 v2, Vec4 *dst)

static Vec4 *	normalize (const Vec4 v, Vec4 *dst)

static Vec4 *	homogenize (const Vec4 v, Vec4 *dst)

static Vec4 *	midpoint (const Vec4 v1, const Vec4 v2, Vec4 *dst)

static Vec4 *	project (const Vec4 v1, const Vec4 v2, Vec4 *dst)

static Vec4 *	lerp (const Vec4 v1, const Vec4 v2, float alpha, Vec4 *dst)

Public Attributes
float	x

float	y

float	z

float	w

Static Public Attributes
static const Vec4	ZERO

static const Vec4	ONE

static const Vec4	UNIT_X

static const Vec4	UNIT_Y

static const Vec4	UNIT_Z

static const Vec4	UNIT_W

static const Vec4	HOMOG_ORIGIN

static const Vec4	HOMOG_X

static const Vec4	HOMOG_Y

static const Vec4	HOMOG_Z

Detailed Description

This class defines a 3-element floating point vector.

This class may be used to represent either a normal, a direction or a point interchangeably without casting. In addition, instances of this class may be freely cast to Color4 and vectors of other sizes.

This class is in standard layout with fields of uniform type. This means that it is safe to reinterpret_cast objects to float arrays.

Constructor & Destructor Documentation

◆ Vec4() [1/10]

cugl::Vec4::Vec4 ( )

inline

Constructs a new vector initialized to all zeros.

◆ Vec4() [2/10]

cugl::Vec4::Vec4	(	float	x,
		float	y,
		float	z,
		float	w
	)

inline

Constructs a new vector initialized to the specified values.

Parameters

x	The x coordinate.
y	The y coordinate.
z	The z coordinate.
w	The w coordinate.

◆ Vec4() [3/10]

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

inline

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

The elements of the arra are in the order x, y, z, and w.

Parameters

array An array containing the elements of the vector.

◆ Vec4() [4/10]

cugl::Vec4::Vec4	(	const Vec4	p1,
		const Vec4	p2
	)

inline

Constructs a vector that describes the direction between the specified points.

Parameters

p1	The first point.
p2	The second point.

◆ Vec4() [5/10]

cugl::Vec4::Vec4 ( Color4 color )

explicit

Creates a vector from the given color.

The attributes are read in the order r,g,b,a. Values are all divided uniformly by 255.0.

Parameters

color The color to convert

◆ Vec4() [6/10]

cugl::Vec4::Vec4 ( const Color4f color )

explicit

Creates a vector from the given color.

The attributes are read in the order r,g,b,a.

Parameters

color The color to convert

◆ Vec4() [7/10]

cugl::Vec4::Vec4 ( const Vec2 v )

explicit

Creates a homogenous vector from the given 2d one.

The z-value is set to 0. However, the w-value is set to 1, to support homogenous coordinates.

Parameters

v	The vector to convert

◆ Vec4() [8/10]

cugl::Vec4::Vec4	(	const Vec2	v,
		float	z,
		float	w
	)

Creates a 4d vector from the given 2d one

The z-coordinate and w-coordinate are set to given values.

Parameters

v	The vector to convert
z	The z-coordinate
w	The w-coordinate

◆ Vec4() [9/10]

cugl::Vec4::Vec4 ( const Vec3 v )

explicit

Creates a homogenous vector from the given 3d one.

The w-value is set to 1. That is because the standard usage of Vec4 objects is homogenous coords.

Parameters

v	The vector to convert

◆ Vec4() [10/10]

cugl::Vec4::Vec4	(	const Vec3	v,
		float	w
	)

Creates a 4d vector from the given 3d one

The w-value is set to given value.

Parameters

v	The vector to convert
w	The w-coordinate

Member Function Documentation

◆ add() [1/3]

Vec4 & cugl::Vec4::add ( const Vec4 v )

inline

Adds the given vector to this one in place.

Parameters

v	The vector to add

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

◆ add() [2/3]

static Vec4 * cugl::Vec4::add	(	const Vec4	v1,
		const Vec4	v2,
		Vec4 *	dst
	)

static

Adds the specified vectors and stores the result in dst.

Parameters

v1	The first vector.
v2	The second vector.
dst	A vector to store the result in

Returns: A reference to dst for chaining

◆ add() [3/3]

Vec4 & cugl::Vec4::add	(	float	x,
		float	y,
		float	z,
		float	w
	)

inline

Adds the given values to this vector.

Parameters

x	The x coordinate to add.
y	The y coordinate to add.
z	The z coordinate to add.
w	The w coordinate to add.

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

◆ angle()

static float cugl::Vec4::angle	(	const Vec4	v1,
		const Vec4	v2
	)

static

Returns the angle (in radians) between the specified vectors.

This computes the angle between the vectors in 4d space. It does not treat the vectors as homogenous coordinates. To get the angle between two homogenous vectors, cast them to Vec3 and use Vec3::angle.

The angle returned is unsigned, as there is no clear sense of direction. If either vector is zero, this method returns zero.

Parameters

v1	The first vector.
v2	The second vector.

Returns: The angle between the two vectors (in radians).

◆ clamp() [1/2]

Vec4 & cugl::Vec4::clamp	(	const Vec4	min,
		const Vec4	max
	)

Clamps this vector within the given range.

Parameters

min	The minimum value.
max	The maximum value.

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

◆ clamp() [2/2]

static Vec4 * cugl::Vec4::clamp	(	const Vec4	v,
		const Vec4	min,
		const Vec4	max,
		Vec4 *	dst
	)

static

Clamps the specified vector within the given range and returns it in dst.

Parameters

v	The vector to clamp.
min	The minimum value.
max	The maximum value.
dst	A vector to store the result in.

Returns: A reference to dst for chaining

◆ cross() [1/2]

Vec4 cugl::Vec4::cross ( const Vec4 v )

inline

Return the cross product of this vector and the specified vector.

This method assumes that this vector and v are homogenous vectors (w=1). It returns a projection vector (w=0).

Parameters

v	The vector to cross.

Returns: The cross product.

◆ cross() [2/2]

static Vec4 * cugl::Vec4::cross	(	const Vec4	v1,
		const Vec4	v2,
		Vec4 *	dst
	)

static

Returns the cross product between the specified vectors.

The vectors are treated as 3-dimensional vectors, with the w-attribute ignored.

Parameters

v1	The first vector.
v2	The second vector.
dst	The destination vector.

Returns: The cross product between the vectors.

◆ distance()

float cugl::Vec4::distance ( const Vec4 v ) const

inline

Returns the distance between this vector and v.

Parameters

v	The other vector.

Returns: The distance between this vector and v.

{

See also: distanceSquared}

◆ distanceSquared()

float cugl::Vec4::distanceSquared ( const Vec4 v ) const

Returns the squared distance between this vector and v.

This method is faster than distance because it does not need to compute a square root. Hence it is best to us this method when it is not necessary to get the exact distance between two vectors (e.g. when simply comparing the distance between different vectors).

Parameters

v	The other vector.

Returns: The squared distance between this vector and v.

{

See also: distance}

◆ divide() [1/5]

Vec4 & cugl::Vec4::divide ( const Vec4 v )

Divides this vector in place by the given vector.

This method is provided to support non-uniform scaling.

Parameters

v	The vector to divide by

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

◆ divide() [2/5]

static Vec4 * cugl::Vec4::divide	(	const Vec4	v,
		float	s,
		Vec4 *	dst
	)

static

Divides the specified vector and stores the result in dst.

The division is uniform by the constant s.

Parameters

v	The vector to divide.
s	The uniform division factor.
dst	The destination vector.

Returns: A reference to dst for chaining

◆ divide() [3/5]

static Vec4 * cugl::Vec4::divide	(	const Vec4	v1,
		const Vec4	v2,
		Vec4 *	dst
	)

static

Divides the specified vector and stores the result in dst.

The division is nonuniform by the attributes in v2.

Parameters

v1	The vector to divide.
v2	The nonuniform division factor.
dst	The destination vector.

Returns: A reference to dst for chaining

◆ divide() [4/5]

Vec4 & cugl::Vec4::divide ( float s )

Divides this vector in place by the given factor.

Parameters

s	The scalar to divide by

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

◆ divide() [5/5]

Vec4 & cugl::Vec4::divide	(	float	sx,
		float	sy,
		float	sz,
		float	sw
	)

Divides this vector nonuniformly by the given factors.

Parameters

sx	The scalar to divide the x-axis
sy	The scalar to divide the y-axis
sz	The scalar to divide the z-axis
sw	The scalar to divide the w-axis

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

◆ dot() [1/2]

float cugl::Vec4::dot ( const Vec4 v ) const

inline

Returns the dot product of this vector and the specified vector.

Parameters

v	The vector to compute the dot product with.

Returns: The dot product.

◆ dot() [2/2]

static float cugl::Vec4::dot	(	const Vec4	v1,
		const Vec4	v2
	)

static

Returns the dot product between the specified vectors.

Parameters

v1	The first vector.
v2	The second vector.

Returns: The dot product between the vectors.

◆ equals()

bool cugl::Vec4::equals	(	const Vec4	v,
		float	epsilon = `CU_MATH_EPSILON`
	)		const

Returns true if the vectors are within tolerance of each other.

The tolerance bounds the traditional Euclidean difference between the two vectors (treated as points)

Parameters

v	The vector to compare against.
epsilon	The comparison tolerance.

Returns: true if the vectors are within tolerance of each other.

◆ getAngle()

float cugl::Vec4::getAngle ( const Vec4 other ) const

Returns the angle between this vector and other.

The angle is measured starting at this one. If either vector is zero, the result is undefined.

Parameters

other The vector to sweep towards.

Returns: the angle between this vector and other.

◆ getClamp()

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

inline

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

Note: this does not modify this vector.

Parameters

min	The minimum value.
max	The maximum value.

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

◆ getHomogenized()

Vec4 cugl::Vec4::getHomogenized ( )

inline

Returns a normalized homogenous copy of this vector.

If w is 0, the copy has a w value to 1. Otherwise, the copy has all of its attributes divided by w.

Note: this does not modify this vector.

Returns: a normalized homogenous copy of this vector.

◆ getLerp()

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

inline

Returns the linear interpolation of this vector with other.

If alpha is 0, the vector is unchanged. If alpha is 1, the vector is other. Otherwise it is a value on the line ab. This method supports alpha outside of the range 0..1.

Parameters

other	The other end of the line segment.
alpha	The interpolation value

Returns: The linear interpolation of this vector with other.

◆ getMap()

Vec4 cugl::Vec4::getMap ( std::function< float(float)> func ) const

inline

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

This method supports any function that has the signature float func(float); This includes many of the functions in math.h.

Parameters

func	The function to map on the coordinates.

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

◆ getMidpoint()

Vec4 cugl::Vec4::getMidpoint ( const Vec4 other ) const

inline

Returns the midpoint between this point and another.

Note: this does not modify this vector.

Parameters

other The other end of the line segment.

Returns: the midpoint between this point and another.

◆ getNegation()

Vec4 cugl::Vec4::getNegation ( ) const

inline

Returns a negated copy of this vector.

Note: This method does not modify the vector

Returns: a negated copy of this vector.

◆ getNormalization()

Vec4 cugl::Vec4::getNormalization ( ) const

inline

Returns a normalized copy of this vector.

This method creates a copy of this vector that is of unit length (i.e. the length of the vector after calling this method will be 1.0f). If the vector already has unit length or if the length of the vector is zero, this method does nothing. Note: this does not modify this vector.

Returns: A normalized copy of this vector.

◆ getProjection()

Vec4 cugl::Vec4::getProjection ( const Vec4 other ) const

inline

Returns the projection of this vector on to the other one.

Note: this does not modify this vector.

Parameters

other The vector to project on.

Returns: the projection of this vector on to the other one.

◆ getReciprocal()

Vec4 cugl::Vec4::getReciprocal ( ) const

inline

Returns a reciprocated copy of this vector.

The reciprocal is computed for each element invidiually. This method does not check that all elements are non-zero. If any element is zero, the result will be system-dependent.

Note: This method does not modify the vector

Returns: a reciprocated copy of this vector.

◆ homogenize() [1/2]

Vec4 & cugl::Vec4::homogenize ( )

inline

Normalizes the homogenous representation of this vector.

If w is 0, it sets the value to 1. Otherwise, it divides all attributes by w.

Returns: This vector, after homgenization.

◆ homogenize() [2/2]

static Vec4 * cugl::Vec4::homogenize	(	const Vec4	v,
		Vec4 *	dst
	)

static

Homogenizes the specified vector and stores the result in dst.

If w is 0, it sets the value to 1. Otherwise, it divides all attributes by w.

Parameters

v	The vector to homogenize.
dst	The destination vector.

Returns: A reference to dst for chaining

◆ isHomogenous()

bool cugl::Vec4::isHomogenous ( ) const

inline

Returns true if this vector is in homogenous coordinates (w=1).

Returns: true if this vector is in homogenous coordinates (w=1).

◆ isInvertible()

bool cugl::Vec4::isInvertible ( ) const

Returns true if this vector contains no zeroes.

Returns: true if this vector contains no zeroes, false otherwise.

◆ isNearZero()

bool cugl::Vec4::isNearZero ( float epsilon = CU_MATH_EPSILON ) const

inline

Returns true if this vector is with tolerance of the origin.

Parameters

epsilon The comparison tolerance

Returns: true if this vector is with tolerance of the origin.

◆ isOne()

bool cugl::Vec4::isOne ( ) const

Returns true if this vector contains all ones.

Returns: true if this vector contains all ones, false otherwise.

◆ isUnit()

bool cugl::Vec4::isUnit ( float epsilon = CU_MATH_EPSILON ) const

inline

Returns true if this vector is a unit vector.

Parameters

epsilon The comparison tolerance

Returns: true if this vector is a unit vector.

◆ isZero()

bool cugl::Vec4::isZero ( ) const

Returns true this vector contains all zeros.

Returns: true if this vector contains all zeros, false otherwise.

◆ length()

float cugl::Vec4::length ( ) const

inline

Returns the length of this vector.

Returns: The length of the vector.

{

See also: lengthSquared}

◆ lengthSquared()

float cugl::Vec4::lengthSquared ( ) const

inline

Returns the squared length of this vector.

This method is faster than length because it does not need to compute a square root. Hence it is best to us this method when it is not necessary to get the exact length of a vectors (e.g. when simply comparing the length to a threshold value).

Returns: The squared length of the vector.

{

See also: length}

◆ lerp() [1/2]

Vec4 & cugl::Vec4::lerp	(	const Vec4	other,
		float	alpha
	)

inline

Modifies this vector to be the linear interpolation with other.

If alpha is 0, the vector is unchanged. If alpha is 1, the vector is other. Otherwise it is a value on the line ab. This method supports alpha outside of the range 0..1.

Parameters

other	The other end of the line segment.
alpha	The interpolation value

Returns: This vector, after the interpolation.

◆ lerp() [2/2]

static Vec4 * cugl::Vec4::lerp	(	const Vec4	v1,
		const Vec4	v2,
		float	alpha,
		Vec4 *	dst
	)

static

Computes the linear interpolation of two vectors and stores it in dst.

If alpha is 0, the vector is a copy of v1. If alpha is 1, the vector is a copy of v2. Otherwise it is a value on the line v1v2. This method supports alpha outside of the range 0..1.

Parameters

v1	The first point.
v2	The second point.
alpha	The interpolation value.
dst	The destination vector.

Returns: The linear interpolation of this vector with other.

◆ map()

Vec4 & cugl::Vec4::map ( std::function< float(float)> func )

inline

Maps the given function to the vector coordinates in place.

This method supports any function that has the signature float func(float); This includes many of the functions in math.h.

Parameters

func	The function to map on the coordinates.

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

◆ midpoint()

static Vec4 * cugl::Vec4::midpoint	(	const Vec4	v1,
		const Vec4	v2,
		Vec4 *	dst
	)

static

Computes the midpoint between two points and stores it in dst.

Parameters

v1	The first point.
v2	The second point.
dst	The destination vector.

Returns: A reference to dst for chaining

◆ negate() [1/2]

Vec4 & cugl::Vec4::negate ( )

inline

Negates this vector in place.

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

◆ negate() [2/2]

static Vec4 * cugl::Vec4::negate	(	const Vec4	v,
		Vec4 *	dst
	)

static

Negates the specified vector and stores the result in dst.

Parameters

v	The vector to negate.
dst	The destination vector.

Returns: A reference to dst for chaining

◆ normalize() [1/2]

Vec4 & cugl::Vec4::normalize ( )

Normalizes this vector.

This method normalizes the vector so that it is of unit length (i.e. the length of the vector after calling this method will be 1.0f). If the vector already has unit length or if the length of the vector is zero, this method does nothing.

Returns: This vector, after the normalization occurs.

◆ normalize() [2/2]

static Vec4 * cugl::Vec4::normalize	(	const Vec4	v,
		Vec4 *	dst
	)

static

Normalizes the specified vector and stores the result in dst.

If the vector already has unit length or if the length of the vector is zero, this method copies v into dst.

Parameters

v	The vector to normalize.
dst	The destination vector.

Returns: A reference to dst for chaining

◆ operator Color4()

cugl::Vec4::operator Color4 ( ) const

Cast from Vec4 to a Color4.

◆ operator Color4f()

cugl::Vec4::operator Color4f ( ) const

Cast from Vec4 to a Color4f.

◆ operator std::string()

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

inline

Cast from Vec4 to a string.

◆ operator Vec2()

cugl::Vec4::operator Vec2 ( ) const

Casts from a homogenous vector to Vec4.

All coordinates are divided by the w-coordinate (assuming it is not zero) before this conversion. Afterwards, both z and w are dropped.

◆ operator Vec3()

cugl::Vec4::operator Vec3 ( ) const

Casts from Vec4 to Vec3.

The w-value is set to 1. That is because the standard usage of Vec4 objects is homogenous coords.

◆ operator!=()

bool cugl::Vec4::operator!= ( const Vec4 v ) const

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

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

Parameters

v	The vector to compare against.

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

◆ operator*() [1/2]

const Vec4 cugl::Vec4::operator* ( const Vec4 v ) const

inline

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

This method is provided to support non-uniform scaling. Note: this does not modify this vector.

Parameters

v	The vector to scale by.

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

◆ operator*() [2/2]

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

inline

Returns the scalar product of this vector with the given value.

Note: this does not modify this vector.

Parameters

s	The value to scale by.

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

◆ operator*=() [1/2]

Vec4 & cugl::Vec4::operator*= ( const Vec4 v )

inline

Scales this vector nonuniformly by the given vector.

Parameters

v	The vector to scale by

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

◆ operator*=() [2/2]

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

inline

Scales this vector in place by the given factor.

Parameters

s	The value to scale by

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

◆ operator+()

const Vec4 cugl::Vec4::operator+ ( const Vec4 v ) const

inline

Returns the sum of this vector with the given vector.

Note: this does not modify this vector.

Parameters

v	The vector to add.

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

◆ operator+=()

Vec4 & cugl::Vec4::operator+= ( const Vec4 v )

inline

Adds the given vector to this one in place.

Parameters

v	The vector to add

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

◆ operator-() [1/2]

const Vec4 cugl::Vec4::operator- ( ) const

inline

Returns the negation of this vector.

Note: this does not modify this vector.

Returns: The negation of this vector.

◆ operator-() [2/2]

const Vec4 cugl::Vec4::operator- ( const Vec4 v ) const

inline

Returns the difference of this vector with the given vector.

Note: this does not modify this vector.

Parameters

v	The vector to subtract.

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

◆ operator-=()

Vec4 & cugl::Vec4::operator-= ( const Vec4 v )

inline

Subtracts the given vector from this one in place.

Parameters

v	The vector to subtract

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

◆ operator/() [1/2]

const Vec4 cugl::Vec4::operator/ ( const Vec4 v ) const

inline

Returns a copy of this vector divided by the given vector.

This method is provided to support non-uniform scaling. Note: this does not modify this vector.

Parameters

v	the vector to divide this vector with

Returns: A copy of this vector divided by the given vector

◆ operator/() [2/2]

const Vec4 cugl::Vec4::operator/ ( float s ) const

inline

Returns a copy of this vector divided by the given constant

Note: this does not modify this vector.

Parameters

s	the constant to divide this vector with

Returns: A copy of this vector divided by the given constant

◆ operator/=() [1/2]

Vec4 & cugl::Vec4::operator/= ( const Vec4 v )

inline

Divides this vector in place by the given vector.

This method is provided to support non-uniform scaling.

Parameters

v	The vector to divide by

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

◆ operator/=() [2/2]

Vec4 & cugl::Vec4::operator/= ( float s )

inline

Divides this vector in place by the given factor.

Parameters

s	The scalar to divide by

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

◆ operator<()

bool cugl::Vec4::operator< ( const Vec4 v ) const

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

This comparison uses the lexicographical order. To test if all components in this vector are less than those of v, use the method under().

Parameters

v	The vector to compare against.

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

◆ operator<=()

bool cugl::Vec4::operator<= ( const Vec4 v ) const

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

This comparison uses the lexicographical order. To test if all components in this vector are less than those of v, use the method under().

Parameters

v	The vector to compare against.

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

◆ operator=() [1/5]

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

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

The attributes are read in the order r,g,b,a. Values are all divided uniformly by 255.0.

Parameters

color The color to convert.

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

◆ operator=() [2/5]

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

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

The attributes are read in the order r,g,b,a.

Parameters

color The color to convert.

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

◆ operator=() [3/5]

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

inline

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

The elements of the array are in the order x, y, z, and w.

Parameters

array An array containing the elements of the vector.

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

◆ operator=() [4/5]

Vec4 & cugl::Vec4::operator= ( const Vec2 size )

Sets the coordinates of this vector to those of the given 2d vector.

The z-value is set to 0. However, the w-value is set to 1, to support homogenous coordinates.

Parameters

size	The vector to convert

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

◆ operator=() [5/5]

Vec4 & cugl::Vec4::operator= ( const Vec3 v )

Sets the coordinates of this vector to those of the given 3d vector.

The w-value is set to 1. That is because the standard usage of Vec4 objects is homogenous coords.

Parameters

v	The vector to convert

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

◆ operator==()

bool cugl::Vec4::operator== ( const Vec4 v ) const

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

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

Parameters

v	The vector to compare against.

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

◆ operator>()

bool cugl::Vec4::operator> ( const Vec4 v ) const

Determines if this vector is greater than the given vector.

This comparison uses the lexicographical order. To test if all components in this vector are greater than those of v, use the method over().

Parameters

v	The vector to compare against.

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

◆ operator>=()

bool cugl::Vec4::operator>= ( const Vec4 v ) const

Determines if this vector is greater than or equal the given vector.

This comparison uses the lexicographical order. To test if all components in this vector are greater than those of v, use the method over().

Parameters

v	The vector to compare against.

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

◆ over()

bool cugl::Vec4::over ( const Vec4 v ) const

Returns true if this vector dominates the given vector.

Domination means that all components of this vector are greater than or equal to the components of the given vector.

Parameters

v	The vector to compare against.

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

◆ project() [1/2]

Vec4 & cugl::Vec4::project ( const Vec4 other )

inline

Modifies this vector to be its projection on to the other one.

Parameters

other The vector to project on.

Returns: This vector, after the projection.

◆ project() [2/2]

static Vec4 * cugl::Vec4::project	(	const Vec4	v1,
		const Vec4	v2,
		Vec4 *	dst
	)

static

Computes the projection of one vector on to another and stores it in dst.

Parameters

v1	The original vector.
v2	The vector to project on.
dst	The destination vector.

Returns: A reference to dst for chaining

◆ reciprocate() [1/2]

Vec4 & cugl::Vec4::reciprocate ( )

Reciprovates this vector in place.

The reciprocal is computed for each element invidiually. This method does not check that all elements are non-zero. If any element is zero, the result will be system-dependent.

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

◆ reciprocate() [2/2]

static Vec4 * cugl::Vec4::reciprocate	(	const Vec4	v,
		Vec4 *	dst
	)

static

Reciprocates the specified quaternion and stores the result in dst.

Reciprocation is applied to each element invidiually. This method does not check that all elements are non-zero. If any element is zero, the result will be system-dependent.

Parameters

v	The vector to reciprocate.
dst	The destination vector.

Returns: A reference to dst for chaining

◆ scale() [1/5]

Vec4 & cugl::Vec4::scale ( const Vec4 v )

inline

Scales this vector nonuniformly by the given vector.

Parameters

v	The vector to scale by

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

◆ scale() [2/5]

static Vec4 * cugl::Vec4::scale	(	const Vec4	v,
		float	s,
		Vec4 *	dst
	)

static

Scales the specified vector and stores the result in dst.

The scale is uniform by the constant s.

Parameters

v	The vector to scale.
s	The uniform scaling factor.
dst	The destination vector.

Returns: A reference to dst for chaining

◆ scale() [3/5]

static Vec4 * cugl::Vec4::scale	(	const Vec4	v1,
		const Vec4	v2,
		Vec4 *	dst
	)

static

Scales the specified vector and stores the result in dst.

The scale is nonuniform by the attributes in v2.

Parameters

v1	The vector to scale.
v2	The nonuniform scaling factor.
dst	The destination vector.

Returns: A reference to dst for chaining

◆ scale() [4/5]

Vec4 & cugl::Vec4::scale ( float s )

inline

Scales this vector in place by the given factor.

Parameters

s	The scalar to multiply by

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

◆ scale() [5/5]

Vec4 & cugl::Vec4::scale	(	float	sx,
		float	sy,
		float	sz,
		float	sw
	)

inline

Scales this vector nonuniformly by the given factors.

Parameters

sx	The scalar to multiply the x-axis
sy	The scalar to multiply the y-axis
sz	The scalar to multiply the z-axis
sw	The scalar to divide the w-axis

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

◆ set() [1/5]

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

inline

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

The elements of the arra are in the order x, y, z, and w.

Parameters

array An array containing the elements of the vector.

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

◆ set() [2/5]

Vec4 & cugl::Vec4::set	(	const Vec3	v,
		float	w
	)

Sets the coordinates of this vector to those of the given 3d vector.

The w-value is set to given value.

Parameters

v	The vector to convert
w	The w-coordinate

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

◆ set() [3/5]

Vec4 & cugl::Vec4::set	(	const Vec4	p1,
		const Vec4	p2
	)

inline

Sets this vector to the directional vector between the specified points.

Parameters

p1	The initial point of the vector.
p2	The terminal point of the vector.

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

◆ set() [4/5]

Vec4 & cugl::Vec4::set ( const Vec4 v )

inline

Sets the elements of this vector to those in the specified vector.

Parameters

v	The vector to copy.

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

◆ set() [5/5]

Vec4 & cugl::Vec4::set	(	float	x,
		float	y,
		float	z,
		float	w
	)

inline

Sets the elements of this vector to the specified values.

Parameters

x	The new x coordinate.
y	The new y coordinate.
z	The new z coordinate.
w	The new w coordinate.

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

◆ setZero()

Vec4 & cugl::Vec4::setZero ( )

inline

Sets the elements of this vector to zero.

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

◆ smooth()

void cugl::Vec4::smooth	(	const Vec4	target,
		float	elapsed,
		float	response
	)

Updates this vector towards the given target using a smoothing function.

The given response time determines the amount of smoothing (lag). A longer response time yields a smoother result and more lag. To force this vector to follow the target closely, provide a response time that is very small relative to the given elapsed time.

Parameters

target	The target value.
elapsed	The elapsed time between calls.
response	The response time (in the same units as elapsed).

◆ subtract() [1/3]

Vec4 & cugl::Vec4::subtract ( const Vec4 v )

inline

Subtracts the given vector from this one in place.

Parameters

v	The vector to subtract

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

◆ subtract() [2/3]

static Vec4 * cugl::Vec4::subtract	(	const Vec4	v1,
		const Vec4	v2,
		Vec4 *	dst
	)

static

Subtracts the specified vectors and stores the result in dst.

The resulting vector is computed as (v1 - v2).

Parameters

v1	The first vector.
v2	The second vector.
dst	The destination vector.

Returns: A reference to dst for chaining

◆ subtract() [3/3]

Vec4 & cugl::Vec4::subtract	(	float	x,
		float	y,
		float	z,
		float	w
	)

inline

Subtracts the given values from this vector.

Parameters

x	The x coordinate to subtract.
y	The y coordinate to subtract.
z	The z coordinate to subtract.
w	The w coordinate to subtract.

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

◆ toString()

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

Returns a string representation of this vector for debugging 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 debugging purposes.

◆ under()

bool cugl::Vec4::under ( const Vec4 v ) const

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

Domination means that all components of the given vector are greater than or equal to the components of this one.

Parameters

v	The vector to compare against.

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

Member Data Documentation

◆ HOMOG_ORIGIN

const Vec4 cugl::Vec4::HOMOG_ORIGIN

static

The homogenous origin Vec4(0,0,0,1)

◆ HOMOG_X

const Vec4 cugl::Vec4::HOMOG_X

static

The homogenous x-axis Vec4(1,0,0,1)

◆ HOMOG_Y

const Vec4 cugl::Vec4::HOMOG_Y

static

The homogenous y-axis Vec4(0,1,0,1)

◆ HOMOG_Z

const Vec4 cugl::Vec4::HOMOG_Z

static

The homogenous z-axis Vec4(0,0,1,1)

◆ ONE

const Vec4 cugl::Vec4::ONE

static

The ones vector Vec4(1,1,1,1)

◆ UNIT_W

const Vec4 cugl::Vec4::UNIT_W

static

The w-axis Vec4(0,0,0,1)

◆ UNIT_X

const Vec4 cugl::Vec4::UNIT_X

static

The x-axis Vec4(1,0,0,0)

◆ UNIT_Y

const Vec4 cugl::Vec4::UNIT_Y

static

The y-axis Vec4(0,1,0,0)

◆ UNIT_Z

const Vec4 cugl::Vec4::UNIT_Z

static

The z-axis Vec4(0,0,1,0)

◆ w

float cugl::Vec4::w

The w-coordinate.

◆ x

float cugl::Vec4::x

The x-coordinate.

◆ y

float cugl::Vec4::y

The y-coordinate.

◆ z

float cugl::Vec4::z

The z-coordinate.

◆ ZERO

const Vec4 cugl::Vec4::ZERO

static

The zero vector Vec4(0,0,0,0)

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

cugl/include/cugl/math/CUVec4.h

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Vec4() [1/10]

◆ Vec4() [2/10]

◆ Vec4() [3/10]

◆ Vec4() [4/10]

◆ Vec4() [5/10]

◆ Vec4() [6/10]

◆ Vec4() [7/10]

◆ Vec4() [8/10]

◆ Vec4() [9/10]

◆ Vec4() [10/10]

Member Function Documentation

◆ add() [1/3]

◆ add() [2/3]

◆ add() [3/3]

◆ angle()

◆ clamp() [1/2]

◆ clamp() [2/2]

◆ cross() [1/2]

◆ cross() [2/2]

◆ distance()

◆ distanceSquared()

◆ divide() [1/5]

◆ divide() [2/5]

◆ divide() [3/5]

◆ divide() [4/5]

◆ divide() [5/5]

◆ dot() [1/2]

◆ dot() [2/2]

◆ equals()

◆ getAngle()

◆ getClamp()

◆ getHomogenized()

◆ getLerp()

◆ getMap()

◆ getMidpoint()

◆ getNegation()

◆ getNormalization()

◆ getProjection()

◆ getReciprocal()

◆ homogenize() [1/2]

◆ homogenize() [2/2]

◆ isHomogenous()

◆ isInvertible()

◆ isNearZero()

◆ isOne()

◆ isUnit()

◆ isZero()

◆ length()

◆ lengthSquared()

◆ lerp() [1/2]

◆ lerp() [2/2]

◆ map()

◆ midpoint()

◆ negate() [1/2]

◆ negate() [2/2]

◆ normalize() [1/2]

◆ normalize() [2/2]

◆ operator Color4()

◆ operator Color4f()

◆ operator std::string()

◆ operator Vec2()

◆ operator Vec3()

◆ operator!=()

◆ operator*() [1/2]

◆ operator*() [2/2]

◆ operator*=() [1/2]

◆ operator*=() [2/2]

◆ operator+()

◆ operator+=()

◆ operator-() [1/2]

◆ operator-() [2/2]

◆ operator-=()

◆ operator/() [1/2]

◆ operator/() [2/2]