Arbitrary quaternion (not necessarily unit). More...

Public Member Functions
	Quat ()
	Initializes to a zero degree rotation, (0,0,0,1) More...

	Quat (const class Any &a)
	Expects "Quat(x,y,z,w)" or a Matrix3 constructor. More...

	Quat (const Matrix3 &rot)

	Quat (float _x, float _y, float _z, float _w)

	Quat (const Vector3 &v, float _w=0)
	Defaults to a pure vector quaternion. More...

float	angleBetween (const Quat &other) const
	Returns the angle in radians between this and other, assuming both are unit quaternions. More...

float	average () const

Quat	conj () const
	Negates the imaginary part. More...

void	deserialize (class BinaryInput &b)

float	dot (const Quat &other) const

Quat	exp () const
	exp q = [sin(A) * v, cos(A)] where q = [Av, 0]. More...

bool	fuzzyEq (const Quat &q)
	Note: two quats can represent the Quat::sameRotation and not be equal. More...

const Vector3 &	imag () const
	Returns the imaginary part (x, y, z) More...

Vector3 &	imag ()

Quat	inverse () const
	Note that q^-1 = q.conj() for a unit quaternion. More...

bool	isNaN () const
	True if any element is NaN. More...

bool	isUnit (float tolerance=1e-5) const
	Is the magnitude nearly 1.0? More...

Quat	log () const

float	magnitude () const

Quat	movedTowards (const Quat &other, float maxAngle) const
	Rotates towards other by at most maxAngle. More...

void	moveTowards (const Quat &other, float maxAngle)
	Rotates towards other by at most maxAngle. More...

Quat	nlerp (const Quat &other, float alpha) const
	Normalized linear interpolation of quaternion components. More...

float	norm () const
	The linear algebra 2-norm, sqrt(q dot q). More...

Quat	operator* (float s) const

Quat	operator* (const Quat &other) const
	Quaternion multiplication (composition of rotations). More...

Quat &	operator*= (float s)

Quat	operator+ (const Quat &q) const

Quat &	operator+= (const Quat &q)

Quat	operator- () const

Quat	operator- (const Quat &other) const

Quat &	operator-= (const Quat &q)

Quat	operator/ (float s) const

Quat	operator/ (const Quat &other) const

Quat &	operator/= (float s)

bool	operator== (const Quat &q) const
	True if the components are exactly equal. More...

const float &	operator[] (int i) const

float &	operator[] (int i)

Quat	pow (float x) const
	Raise this quaternion to a power. More...

const float &	real () const
	The real part of the quaternion. More...

float &	real ()

bool	sameRotation (const Quat &q)
	True if these quaternions represent the same rotation (note that every rotation is represented by two values; q and -q). More...

void	serialize (class BinaryOutput &b) const

Quat	slerp (const Quat &other, float alpha, float threshold=0.05f) const
	Spherical linear interpolation: linear interpolation along the shortest (3D) great-circle route between two quaternions. More...

float	sum () const

Any	toAny () const

void	toAxisAngleRotation (Vector3 &axis, double &angle) const
	Returns the axis and angle of rotation represented by this quaternion (i.e. More...

void	toAxisAngleRotation (Vector3 &axis, float &angle) const

Matrix3	toRotationMatrix () const

void	toRotationMatrix (Matrix3 &rot) const

Quat	toUnit () const
	Returns a unit quaterion obtained by dividing through by the magnitude. More...

void	unitize ()
	Make unit length in place. More...

Vector2	ww () const

Vector3	www () const

Vector4	wwww () const

Vector4	wwwx () const

Vector4	wwwy () const

Vector4	wwwz () const

Vector3	wwx () const

Vector4	wwxw () const

Vector4	wwxx () const

Vector4	wwxy () const

Vector4	wwxz () const

Vector3	wwy () const

Vector4	wwyw () const

Vector4	wwyx () const

Vector4	wwyy () const

Vector4	wwyz () const

Vector3	wwz () const

Vector4	wwzw () const

Vector4	wwzx () const

Vector4	wwzy () const

Vector4	wwzz () const

Vector2	wx () const

Vector3	wxw () const

Vector4	wxww () const

Vector4	wxwx () const

Vector4	wxwy () const

Vector4	wxwz () const

Vector3	wxx () const

Vector4	wxxw () const

Vector4	wxxx () const

Vector4	wxxy () const

Vector4	wxxz () const

Vector3	wxy () const

Vector4	wxyw () const

Vector4	wxyx () const

Vector4	wxyy () const

Vector4	wxyz () const

Vector3	wxz () const

Vector4	wxzw () const

Vector4	wxzx () const

Vector4	wxzy () const

Vector4	wxzz () const

Vector2	wy () const

Vector3	wyw () const

Vector4	wyww () const

Vector4	wywx () const

Vector4	wywy () const

Vector4	wywz () const

Vector3	wyx () const

Vector4	wyxw () const

Vector4	wyxx () const

Vector4	wyxy () const

Vector4	wyxz () const

Vector3	wyy () const

Vector4	wyyw () const

Vector4	wyyx () const

Vector4	wyyy () const

Vector4	wyyz () const

Vector3	wyz () const

Vector4	wyzw () const

Vector4	wyzx () const

Vector4	wyzy () const

Vector4	wyzz () const

Vector2	wz () const

Vector3	wzw () const

Vector4	wzww () const

Vector4	wzwx () const

Vector4	wzwy () const

Vector4	wzwz () const

Vector3	wzx () const

Vector4	wzxw () const

Vector4	wzxx () const

Vector4	wzxy () const

Vector4	wzxz () const

Vector3	wzy () const

Vector4	wzyw () const

Vector4	wzyx () const

Vector4	wzyy () const

Vector4	wzyz () const

Vector3	wzz () const

Vector4	wzzw () const

Vector4	wzzx () const

Vector4	wzzy () const

Vector4	wzzz () const

Vector2	xw () const

Vector3	xww () const

Vector4	xwww () const

Vector4	xwwx () const

Vector4	xwwy () const

Vector4	xwwz () const

Vector3	xwx () const

Vector4	xwxw () const

Vector4	xwxx () const

Vector4	xwxy () const

Vector4	xwxz () const

Vector3	xwy () const

Vector4	xwyw () const

Vector4	xwyx () const

Vector4	xwyy () const

Vector4	xwyz () const

Vector3	xwz () const

Vector4	xwzw () const

Vector4	xwzx () const

Vector4	xwzy () const

Vector4	xwzz () const

Vector2	xx () const

Vector3	xxw () const

Vector4	xxww () const

Vector4	xxwx () const

Vector4	xxwy () const

Vector4	xxwz () const

Vector3	xxx () const

Vector4	xxxw () const

Vector4	xxxx () const

Vector4	xxxy () const

Vector4	xxxz () const

Vector3	xxy () const

Vector4	xxyw () const

Vector4	xxyx () const

Vector4	xxyy () const

Vector4	xxyz () const

Vector3	xxz () const

Vector4	xxzw () const

Vector4	xxzx () const

Vector4	xxzy () const

Vector4	xxzz () const

Vector2	xy () const

Vector3	xyw () const

Vector4	xyww () const

Vector4	xywx () const

Vector4	xywy () const

Vector4	xywz () const

Vector3	xyx () const

Vector4	xyxw () const

Vector4	xyxx () const

Vector4	xyxy () const

Vector4	xyxz () const

Vector3	xyy () const

Vector4	xyyw () const

Vector4	xyyx () const

Vector4	xyyy () const

Vector4	xyyz () const

Vector3	xyz () const

Vector4	xyzw () const

Vector4	xyzx () const

Vector4	xyzy () const

Vector4	xyzz () const

Vector2	xz () const

Vector3	xzw () const

Vector4	xzww () const

Vector4	xzwx () const

Vector4	xzwy () const

Vector4	xzwz () const

Vector3	xzx () const

Vector4	xzxw () const

Vector4	xzxx () const

Vector4	xzxy () const

Vector4	xzxz () const

Vector3	xzy () const

Vector4	xzyw () const

Vector4	xzyx () const

Vector4	xzyy () const

Vector4	xzyz () const

Vector3	xzz () const

Vector4	xzzw () const

Vector4	xzzx () const

Vector4	xzzy () const

Vector4	xzzz () const

Vector2	yw () const

Vector3	yww () const

Vector4	ywww () const

Vector4	ywwx () const

Vector4	ywwy () const

Vector4	ywwz () const

Vector3	ywx () const

Vector4	ywxw () const

Vector4	ywxx () const

Vector4	ywxy () const

Vector4	ywxz () const

Vector3	ywy () const

Vector4	ywyw () const

Vector4	ywyx () const

Vector4	ywyy () const

Vector4	ywyz () const

Vector3	ywz () const

Vector4	ywzw () const

Vector4	ywzx () const

Vector4	ywzy () const

Vector4	ywzz () const

Vector2	yx () const

Vector3	yxw () const

Vector4	yxww () const

Vector4	yxwx () const

Vector4	yxwy () const

Vector4	yxwz () const

Vector3	yxx () const

Vector4	yxxw () const

Vector4	yxxx () const

Vector4	yxxy () const

Vector4	yxxz () const

Vector3	yxy () const

Vector4	yxyw () const

Vector4	yxyx () const

Vector4	yxyy () const

Vector4	yxyz () const

Vector3	yxz () const

Vector4	yxzw () const

Vector4	yxzx () const

Vector4	yxzy () const

Vector4	yxzz () const

Vector2	yy () const

Vector3	yyw () const

Vector4	yyww () const

Vector4	yywx () const

Vector4	yywy () const

Vector4	yywz () const

Vector3	yyx () const

Vector4	yyxw () const

Vector4	yyxx () const

Vector4	yyxy () const

Vector4	yyxz () const

Vector3	yyy () const

Vector4	yyyw () const

Vector4	yyyx () const

Vector4	yyyy () const

Vector4	yyyz () const

Vector3	yyz () const

Vector4	yyzw () const

Vector4	yyzx () const

Vector4	yyzy () const

Vector4	yyzz () const

Vector2	yz () const

Vector3	yzw () const

Vector4	yzww () const

Vector4	yzwx () const

Vector4	yzwy () const

Vector4	yzwz () const

Vector3	yzx () const

Vector4	yzxw () const

Vector4	yzxx () const

Vector4	yzxy () const

Vector4	yzxz () const

Vector3	yzy () const

Vector4	yzyw () const

Vector4	yzyx () const

Vector4	yzyy () const

Vector4	yzyz () const

Vector3	yzz () const

Vector4	yzzw () const

Vector4	yzzx () const

Vector4	yzzy () const

Vector4	yzzz () const

Vector2	zw () const

Vector3	zww () const

Vector4	zwww () const

Vector4	zwwx () const

Vector4	zwwy () const

Vector4	zwwz () const

Vector3	zwx () const

Vector4	zwxw () const

Vector4	zwxx () const

Vector4	zwxy () const

Vector4	zwxz () const

Vector3	zwy () const

Vector4	zwyw () const

Vector4	zwyx () const

Vector4	zwyy () const

Vector4	zwyz () const

Vector3	zwz () const

Vector4	zwzw () const

Vector4	zwzx () const

Vector4	zwzy () const

Vector4	zwzz () const

Vector2	zx () const

Vector3	zxw () const

Vector4	zxww () const

Vector4	zxwx () const

Vector4	zxwy () const

Vector4	zxwz () const

Vector3	zxx () const

Vector4	zxxw () const

Vector4	zxxx () const

Vector4	zxxy () const

Vector4	zxxz () const

Vector3	zxy () const

Vector4	zxyw () const

Vector4	zxyx () const

Vector4	zxyy () const

Vector4	zxyz () const

Vector3	zxz () const

Vector4	zxzw () const

Vector4	zxzx () const

Vector4	zxzy () const

Vector4	zxzz () const

Vector2	zy () const

Vector3	zyw () const

Vector4	zyww () const

Vector4	zywx () const

Vector4	zywy () const

Vector4	zywz () const

Vector3	zyx () const

Vector4	zyxw () const

Vector4	zyxx () const

Vector4	zyxy () const

Vector4	zyxz () const

Vector3	zyy () const

Vector4	zyyw () const

Vector4	zyyx () const

Vector4	zyyy () const

Vector4	zyyz () const

Vector3	zyz () const

Vector4	zyzw () const

Vector4	zyzx () const

Vector4	zyzy () const

Vector4	zyzz () const

Vector2	zz () const

Vector3	zzw () const

Vector4	zzww () const

Vector4	zzwx () const

Vector4	zzwy () const

Vector4	zzwz () const

Vector3	zzx () const

Vector4	zzxw () const

Vector4	zzxx () const

Vector4	zzxy () const

Vector4	zzxz () const

Vector3	zzy () const

Vector4	zzyw () const

Vector4	zzyx () const

Vector4	zzyy () const

Vector4	zzyz () const

Vector3	zzz () const

Vector4	zzzw () const

Vector4	zzzx () const

Vector4	zzzy () const

Vector4	zzzz () const

Static Public Member Functions
static Quat	fromAxisAngleRotation (const Vector3 &axis, float angle)
	q = [sin(angle/2)*axis, cos(angle/2)] More...

static Quat	unitRandom ()
	Generate uniform random unit quaternion (i.e. More...

Public Attributes
float	w

float	x
	q = [sin(angle / 2) * axis, cos(angle / 2)] More...

float	y

float	z

Friends
Quat	operator* (float s, const Quat &q)

Detailed Description

Arbitrary quaternion (not necessarily unit).

Unit quaternions (aka versors) are used in computer graphics to represent rotation about an axis. Any 3x3 rotation matrix can be stored as a quaternion.

A quaternion represents the sum of a real scalar and an imaginary vector: ix + jy + kz + w. A unit quaternion representing a rotation by A about axis v has the form [sin(A/2)*v, cos(A/2)]. For a unit quaternion, q.conj() == q.inverse() is a rotation by -A about v. -q is the same rotation as q (negate both the axis and angle).
A non-unit quaterion q represents the same rotation as q.unitize() (Dam98 pg 28).

Although quaternion-vector operations (eg. Quat + Vector3) are well defined, they are not supported by this class because they typically are bugs when they appear in code.

Do not subclass.

BETA API – subject to change

Referenced Code: Erik B. Dam, Martin Koch, Martin Lillholm, Quaternions, Interpolation and Animation. Technical Report DIKU-TR-98/5, Department of Computer Science, University of Copenhagen, Denmark. 1998.

Constructor & Destructor Documentation

◆ Quat() [1/5]

G3D::Quat::Quat ( )

inline

Initializes to a zero degree rotation, (0,0,0,1)

Referenced by conj(), exp(), log(), operator*(), operator+(), operator-(), and operator/().

◆ Quat() [2/5]

G3D::Quat::Quat ( const class Any & a )

Expects "Quat(x,y,z,w)" or a Matrix3 constructor.

◆ Quat() [3/5]

G3D::Quat::Quat ( const Matrix3 & rot )

◆ Quat() [4/5]

G3D::Quat::Quat	(	float	_x,
		float	_y,
		float	_z,
		float	_w
	)

inline

◆ Quat() [5/5]

G3D::Quat::Quat	(	const Vector3 &	v,
		float	_w = `0`
	)

inline

Defaults to a pure vector quaternion.

Member Function Documentation

◆ angleBetween()

float G3D::Quat::angleBetween ( const Quat & other ) const

Returns the angle in radians between this and other, assuming both are unit quaternions.

Returns: On the range [0, pif()]

◆ average()

float G3D::Quat::average ( ) const

inline

◆ conj()

Quat G3D::Quat::conj ( ) const

inline

Negates the imaginary part.

Referenced by inverse().

◆ deserialize()

void G3D::Quat::deserialize ( class BinaryInput & b )

◆ dot()

float G3D::Quat::dot ( const Quat & other ) const

inline

Referenced by inverse(), isUnit(), magnitude(), and unitize().

◆ exp()

Quat G3D::Quat::exp ( ) const

inline

exp q = [sin(A) * v, cos(A)] where q = [Av, 0].

Only defined for pure-vector quaternions

Referenced by G3D::exp(), and pow().

◆ fromAxisAngleRotation()

static Quat G3D::Quat::fromAxisAngleRotation	(	const Vector3 &	axis,
		float	angle
	)

static

q = [sin(angle/2)*axis, cos(angle/2)]

◆ fuzzyEq()

bool G3D::Quat::fuzzyEq ( const Quat & q )

inline

Note: two quats can represent the Quat::sameRotation and not be equal.

Referenced by sameRotation().

◆ imag() [1/2]

const Vector3& G3D::Quat::imag ( ) const

inline

Returns the imaginary part (x, y, z)

◆ imag() [2/2]

Vector3& G3D::Quat::imag ( )

inline

◆ inverse()

Quat G3D::Quat::inverse ( ) const

inline

Note that q^-1 = q.conj() for a unit quaternion.

Referenced Code: Dam99 page 13

Referenced by operator/().

◆ isNaN()

bool G3D::Quat::isNaN ( ) const

inline

True if any element is NaN.

◆ isUnit()

bool G3D::Quat::isUnit ( float tolerance = 1e-5 ) const

inline

Is the magnitude nearly 1.0?

◆ log()

Quat G3D::Quat::log ( ) const

inline

Referenced by G3D::log(), and pow().

◆ magnitude()

float G3D::Quat::magnitude ( ) const

inline

Referenced by norm().

◆ movedTowards()

Quat G3D::Quat::movedTowards	(	const Quat &	other,
		float	maxAngle
	)		const

inline

Rotates towards other by at most maxAngle.

Referenced by moveTowards().

◆ moveTowards()

void G3D::Quat::moveTowards	(	const Quat &	other,
		float	maxAngle
	)

inline

Rotates towards other by at most maxAngle.

◆ nlerp()

Quat G3D::Quat::nlerp	(	const Quat &	other,
		float	alpha
	)		const

Normalized linear interpolation of quaternion components.

◆ norm()

float G3D::Quat::norm ( ) const

inline

The linear algebra 2-norm, sqrt(q dot q).

This matches the value used in Dam's 1998 tech report but differs from the n(q) value used in Eberly's 1999 paper, which is the square of the norm.

◆ operator*() [1/2]

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

inline

◆ operator*() [2/2]

Quat G3D::Quat::operator* ( const Quat & other ) const

Quaternion multiplication (composition of rotations).

Note that this does not commute.

◆ operator*=()

Quat& G3D::Quat::operator*= ( float s )

inline

◆ operator+()

Quat G3D::Quat::operator+ ( const Quat & q ) const

inline

◆ operator+=()

Quat& G3D::Quat::operator+= ( const Quat & q )

inline

◆ operator-() [1/2]

Quat G3D::Quat::operator- ( ) const

inline

◆ operator-() [2/2]

Quat G3D::Quat::operator- ( const Quat & other ) const

inline

◆ operator-=()

Quat& G3D::Quat::operator-= ( const Quat & q )

inline

◆ operator/() [1/2]

Quat G3D::Quat::operator/ ( float s ) const

inline

◆ operator/() [2/2]

Quat G3D::Quat::operator/ ( const Quat & other ) const

inline

◆ operator/=()

Quat& G3D::Quat::operator/= ( float s )

inline

◆ operator==()

bool G3D::Quat::operator== ( const Quat & q ) const

inline

True if the components are exactly equal.

Note that two quaternations may be unequal but map to the same rotation.

◆ operator[]() [1/2]

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

inline

◆ operator[]() [2/2]

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

inline

◆ pow()

Quat G3D::Quat::pow ( float x ) const

inline

Raise this quaternion to a power.

For a rotation, this is the effect of rotating x times as much as the original quaterion.

Note that q.pow(a).pow(b) == q.pow(a + b)

Referenced Code: Dam98 pg 21

Referenced by pow().

◆ real() [1/2]

const float& G3D::Quat::real ( ) const

inline

The real part of the quaternion.

◆ real() [2/2]

float& G3D::Quat::real ( )

inline

◆ sameRotation()

bool G3D::Quat::sameRotation ( const Quat & q )

inline

True if these quaternions represent the same rotation (note that every rotation is represented by two values; q and -q).

◆ serialize()

void G3D::Quat::serialize ( class BinaryOutput & b ) const

◆ slerp()

Quat G3D::Quat::slerp	(	const Quat &	other,
		float	alpha,
		float	threshold = `0.05f`
	)		const

inline

Spherical linear interpolation: linear interpolation along the shortest (3D) great-circle route between two quaternions.

Assumes that both arguments are unit quaternions.

Note: Correct rotations are expected between 0 and PI in the right order.

Referenced Code: Based on Game Physics – David Eberly pg 538-540

Parameters

threshold Critical angle between between rotations (in radians) at which the algorithm switches to normalized lerp, which is more numerically stable in those situations. 0.0 will always slerp.

◆ sum()

float G3D::Quat::sum ( ) const

inline

Referenced by average().

◆ toAny()

Any G3D::Quat::toAny ( ) const

◆ toAxisAngleRotation() [1/2]

void G3D::Quat::toAxisAngleRotation	(	Vector3 &	axis,
		double &	angle
	)		const

Returns the axis and angle of rotation represented by this quaternion (i.e.

q = [sin(angle/2)*axis, cos(angle/2)])

Referenced by toAxisAngleRotation().

◆ toAxisAngleRotation() [2/2]

void G3D::Quat::toAxisAngleRotation	(	Vector3 &	axis,
		float &	angle
	)		const

inline

◆ toRotationMatrix() [1/2]

Matrix3 G3D::Quat::toRotationMatrix ( ) const

◆ toRotationMatrix() [2/2]

void G3D::Quat::toRotationMatrix ( Matrix3 & rot ) const

◆ toUnit()

Quat G3D::Quat::toUnit ( ) const

inline

Returns a unit quaterion obtained by dividing through by the magnitude.

◆ unitize()

void G3D::Quat::unitize ( )

inline

Make unit length in place.

◆ unitRandom()

static Quat G3D::Quat::unitRandom ( )

static

Generate uniform random unit quaternion (i.e.

random "direction")

Referenced Code: From "Uniform Random Rotations", Ken Shoemake, Graphics Gems III.

◆ ww()

Vector2 G3D::Quat::ww ( ) const

◆ www()

Vector3 G3D::Quat::www ( ) const

◆ wwww()

Vector4 G3D::Quat::wwww ( ) const

◆ wwwx()

Vector4 G3D::Quat::wwwx ( ) const

◆ wwwy()

Vector4 G3D::Quat::wwwy ( ) const

◆ wwwz()

Vector4 G3D::Quat::wwwz ( ) const

◆ wwx()

Vector3 G3D::Quat::wwx ( ) const

◆ wwxw()

Vector4 G3D::Quat::wwxw ( ) const

◆ wwxx()

Vector4 G3D::Quat::wwxx ( ) const

◆ wwxy()

Vector4 G3D::Quat::wwxy ( ) const

◆ wwxz()

Vector4 G3D::Quat::wwxz ( ) const

◆ wwy()

Vector3 G3D::Quat::wwy ( ) const

◆ wwyw()

Vector4 G3D::Quat::wwyw ( ) const

◆ wwyx()

Vector4 G3D::Quat::wwyx ( ) const

◆ wwyy()

Vector4 G3D::Quat::wwyy ( ) const

◆ wwyz()

Vector4 G3D::Quat::wwyz ( ) const

◆ wwz()

Vector3 G3D::Quat::wwz ( ) const

◆ wwzw()

Vector4 G3D::Quat::wwzw ( ) const

◆ wwzx()

Vector4 G3D::Quat::wwzx ( ) const

◆ wwzy()

Vector4 G3D::Quat::wwzy ( ) const

◆ wwzz()

Vector4 G3D::Quat::wwzz ( ) const

◆ wx()

Vector2 G3D::Quat::wx ( ) const

◆ wxw()

Vector3 G3D::Quat::wxw ( ) const

◆ wxww()

Vector4 G3D::Quat::wxww ( ) const

◆ wxwx()

Vector4 G3D::Quat::wxwx ( ) const

◆ wxwy()

Vector4 G3D::Quat::wxwy ( ) const

◆ wxwz()

Vector4 G3D::Quat::wxwz ( ) const

◆ wxx()

Vector3 G3D::Quat::wxx ( ) const

◆ wxxw()

Vector4 G3D::Quat::wxxw ( ) const

◆ wxxx()

Vector4 G3D::Quat::wxxx ( ) const

◆ wxxy()

Vector4 G3D::Quat::wxxy ( ) const

◆ wxxz()

Vector4 G3D::Quat::wxxz ( ) const

◆ wxy()

Vector3 G3D::Quat::wxy ( ) const

◆ wxyw()

Vector4 G3D::Quat::wxyw ( ) const

◆ wxyx()

Vector4 G3D::Quat::wxyx ( ) const

◆ wxyy()

Vector4 G3D::Quat::wxyy ( ) const

◆ wxyz()

Vector4 G3D::Quat::wxyz ( ) const

◆ wxz()

Vector3 G3D::Quat::wxz ( ) const

◆ wxzw()

Vector4 G3D::Quat::wxzw ( ) const

◆ wxzx()

Vector4 G3D::Quat::wxzx ( ) const

◆ wxzy()

Vector4 G3D::Quat::wxzy ( ) const

◆ wxzz()

Vector4 G3D::Quat::wxzz ( ) const

◆ wy()

Vector2 G3D::Quat::wy ( ) const

◆ wyw()

Vector3 G3D::Quat::wyw ( ) const

◆ wyww()

Vector4 G3D::Quat::wyww ( ) const

◆ wywx()

Vector4 G3D::Quat::wywx ( ) const

◆ wywy()

Vector4 G3D::Quat::wywy ( ) const

◆ wywz()

Vector4 G3D::Quat::wywz ( ) const

◆ wyx()

Vector3 G3D::Quat::wyx ( ) const

◆ wyxw()

Vector4 G3D::Quat::wyxw ( ) const

◆ wyxx()

Vector4 G3D::Quat::wyxx ( ) const

◆ wyxy()

Vector4 G3D::Quat::wyxy ( ) const

◆ wyxz()

Vector4 G3D::Quat::wyxz ( ) const

◆ wyy()

Vector3 G3D::Quat::wyy ( ) const

◆ wyyw()

Vector4 G3D::Quat::wyyw ( ) const

◆ wyyx()

Vector4 G3D::Quat::wyyx ( ) const

◆ wyyy()

Vector4 G3D::Quat::wyyy ( ) const

◆ wyyz()

Vector4 G3D::Quat::wyyz ( ) const

◆ wyz()

Vector3 G3D::Quat::wyz ( ) const

◆ wyzw()

Vector4 G3D::Quat::wyzw ( ) const

◆ wyzx()

Vector4 G3D::Quat::wyzx ( ) const

◆ wyzy()

Vector4 G3D::Quat::wyzy ( ) const

◆ wyzz()

Vector4 G3D::Quat::wyzz ( ) const

◆ wz()

Vector2 G3D::Quat::wz ( ) const

◆ wzw()

Vector3 G3D::Quat::wzw ( ) const

◆ wzww()

Vector4 G3D::Quat::wzww ( ) const

◆ wzwx()

Vector4 G3D::Quat::wzwx ( ) const

◆ wzwy()

Vector4 G3D::Quat::wzwy ( ) const

◆ wzwz()

Vector4 G3D::Quat::wzwz ( ) const

◆ wzx()

Vector3 G3D::Quat::wzx ( ) const

◆ wzxw()

Vector4 G3D::Quat::wzxw ( ) const

◆ wzxx()

Vector4 G3D::Quat::wzxx ( ) const

◆ wzxy()

Vector4 G3D::Quat::wzxy ( ) const

◆ wzxz()

Vector4 G3D::Quat::wzxz ( ) const

◆ wzy()

Vector3 G3D::Quat::wzy ( ) const

◆ wzyw()

Vector4 G3D::Quat::wzyw ( ) const

◆ wzyx()

Vector4 G3D::Quat::wzyx ( ) const

◆ wzyy()

Vector4 G3D::Quat::wzyy ( ) const

◆ wzyz()

Vector4 G3D::Quat::wzyz ( ) const

◆ wzz()

Vector3 G3D::Quat::wzz ( ) const

◆ wzzw()

Vector4 G3D::Quat::wzzw ( ) const

◆ wzzx()

Vector4 G3D::Quat::wzzx ( ) const

◆ wzzy()

Vector4 G3D::Quat::wzzy ( ) const

◆ wzzz()

Vector4 G3D::Quat::wzzz ( ) const

◆ xw()

Vector2 G3D::Quat::xw ( ) const

◆ xww()

Vector3 G3D::Quat::xww ( ) const

◆ xwww()

Vector4 G3D::Quat::xwww ( ) const

◆ xwwx()

Vector4 G3D::Quat::xwwx ( ) const

◆ xwwy()

Vector4 G3D::Quat::xwwy ( ) const

◆ xwwz()

Vector4 G3D::Quat::xwwz ( ) const

◆ xwx()

Vector3 G3D::Quat::xwx ( ) const

◆ xwxw()

Vector4 G3D::Quat::xwxw ( ) const

◆ xwxx()

Vector4 G3D::Quat::xwxx ( ) const

◆ xwxy()

Vector4 G3D::Quat::xwxy ( ) const

◆ xwxz()

Vector4 G3D::Quat::xwxz ( ) const

◆ xwy()

Vector3 G3D::Quat::xwy ( ) const

◆ xwyw()

Vector4 G3D::Quat::xwyw ( ) const

◆ xwyx()

Vector4 G3D::Quat::xwyx ( ) const

◆ xwyy()

Vector4 G3D::Quat::xwyy ( ) const

◆ xwyz()

Vector4 G3D::Quat::xwyz ( ) const

◆ xwz()

Vector3 G3D::Quat::xwz ( ) const

◆ xwzw()

Vector4 G3D::Quat::xwzw ( ) const

◆ xwzx()

Vector4 G3D::Quat::xwzx ( ) const

◆ xwzy()

Vector4 G3D::Quat::xwzy ( ) const

◆ xwzz()

Vector4 G3D::Quat::xwzz ( ) const

◆ xx()

Vector2 G3D::Quat::xx ( ) const

◆ xxw()

Vector3 G3D::Quat::xxw ( ) const

◆ xxww()

Vector4 G3D::Quat::xxww ( ) const

◆ xxwx()

Vector4 G3D::Quat::xxwx ( ) const

◆ xxwy()

Vector4 G3D::Quat::xxwy ( ) const

◆ xxwz()

Vector4 G3D::Quat::xxwz ( ) const

◆ xxx()

Vector3 G3D::Quat::xxx ( ) const

◆ xxxw()

Vector4 G3D::Quat::xxxw ( ) const

◆ xxxx()

Vector4 G3D::Quat::xxxx ( ) const

◆ xxxy()

Vector4 G3D::Quat::xxxy ( ) const

◆ xxxz()

Vector4 G3D::Quat::xxxz ( ) const

◆ xxy()

Vector3 G3D::Quat::xxy ( ) const

◆ xxyw()

Vector4 G3D::Quat::xxyw ( ) const

◆ xxyx()

Vector4 G3D::Quat::xxyx ( ) const

◆ xxyy()

Vector4 G3D::Quat::xxyy ( ) const

◆ xxyz()

Vector4 G3D::Quat::xxyz ( ) const

◆ xxz()

Vector3 G3D::Quat::xxz ( ) const

◆ xxzw()

Vector4 G3D::Quat::xxzw ( ) const

◆ xxzx()

Vector4 G3D::Quat::xxzx ( ) const

◆ xxzy()

Vector4 G3D::Quat::xxzy ( ) const

◆ xxzz()

Vector4 G3D::Quat::xxzz ( ) const

◆ xy()

Vector2 G3D::Quat::xy ( ) const

◆ xyw()

Vector3 G3D::Quat::xyw ( ) const

◆ xyww()

Vector4 G3D::Quat::xyww ( ) const

◆ xywx()

Vector4 G3D::Quat::xywx ( ) const

◆ xywy()

Vector4 G3D::Quat::xywy ( ) const

◆ xywz()

Vector4 G3D::Quat::xywz ( ) const

◆ xyx()

Vector3 G3D::Quat::xyx ( ) const

◆ xyxw()

Vector4 G3D::Quat::xyxw ( ) const

◆ xyxx()

Vector4 G3D::Quat::xyxx ( ) const

◆ xyxy()

Vector4 G3D::Quat::xyxy ( ) const

◆ xyxz()

Vector4 G3D::Quat::xyxz ( ) const

◆ xyy()

Vector3 G3D::Quat::xyy ( ) const

◆ xyyw()

Vector4 G3D::Quat::xyyw ( ) const

◆ xyyx()

Vector4 G3D::Quat::xyyx ( ) const

◆ xyyy()

Vector4 G3D::Quat::xyyy ( ) const

◆ xyyz()

Vector4 G3D::Quat::xyyz ( ) const

◆ xyz()

Vector3 G3D::Quat::xyz ( ) const

◆ xyzw()

Vector4 G3D::Quat::xyzw ( ) const

◆ xyzx()

Vector4 G3D::Quat::xyzx ( ) const

◆ xyzy()

Vector4 G3D::Quat::xyzy ( ) const

◆ xyzz()

Vector4 G3D::Quat::xyzz ( ) const

◆ xz()

Vector2 G3D::Quat::xz ( ) const

◆ xzw()

Vector3 G3D::Quat::xzw ( ) const

◆ xzww()

Vector4 G3D::Quat::xzww ( ) const

◆ xzwx()

Vector4 G3D::Quat::xzwx ( ) const

◆ xzwy()

Vector4 G3D::Quat::xzwy ( ) const

◆ xzwz()

Vector4 G3D::Quat::xzwz ( ) const

◆ xzx()

Vector3 G3D::Quat::xzx ( ) const

◆ xzxw()

Vector4 G3D::Quat::xzxw ( ) const

◆ xzxx()

Vector4 G3D::Quat::xzxx ( ) const

◆ xzxy()

Vector4 G3D::Quat::xzxy ( ) const

◆ xzxz()

Vector4 G3D::Quat::xzxz ( ) const

◆ xzy()

Vector3 G3D::Quat::xzy ( ) const

◆ xzyw()

Vector4 G3D::Quat::xzyw ( ) const

◆ xzyx()

Vector4 G3D::Quat::xzyx ( ) const

◆ xzyy()

Vector4 G3D::Quat::xzyy ( ) const

◆ xzyz()

Vector4 G3D::Quat::xzyz ( ) const

◆ xzz()

Vector3 G3D::Quat::xzz ( ) const

◆ xzzw()

Vector4 G3D::Quat::xzzw ( ) const

◆ xzzx()

Vector4 G3D::Quat::xzzx ( ) const

◆ xzzy()

Vector4 G3D::Quat::xzzy ( ) const

◆ xzzz()

Vector4 G3D::Quat::xzzz ( ) const

◆ yw()

Vector2 G3D::Quat::yw ( ) const

◆ yww()

Vector3 G3D::Quat::yww ( ) const

◆ ywww()

Vector4 G3D::Quat::ywww ( ) const

◆ ywwx()

Vector4 G3D::Quat::ywwx ( ) const

◆ ywwy()

Vector4 G3D::Quat::ywwy ( ) const

◆ ywwz()

Vector4 G3D::Quat::ywwz ( ) const

◆ ywx()

Vector3 G3D::Quat::ywx ( ) const

◆ ywxw()

Vector4 G3D::Quat::ywxw ( ) const

◆ ywxx()

Vector4 G3D::Quat::ywxx ( ) const

◆ ywxy()

Vector4 G3D::Quat::ywxy ( ) const

◆ ywxz()

Vector4 G3D::Quat::ywxz ( ) const

◆ ywy()

Vector3 G3D::Quat::ywy ( ) const

◆ ywyw()

Vector4 G3D::Quat::ywyw ( ) const

◆ ywyx()

Vector4 G3D::Quat::ywyx ( ) const

◆ ywyy()

Vector4 G3D::Quat::ywyy ( ) const

◆ ywyz()

Vector4 G3D::Quat::ywyz ( ) const

◆ ywz()

Vector3 G3D::Quat::ywz ( ) const

◆ ywzw()

Vector4 G3D::Quat::ywzw ( ) const

◆ ywzx()

Vector4 G3D::Quat::ywzx ( ) const

◆ ywzy()

Vector4 G3D::Quat::ywzy ( ) const

◆ ywzz()

Vector4 G3D::Quat::ywzz ( ) const

◆ yx()

Vector2 G3D::Quat::yx ( ) const

◆ yxw()

Vector3 G3D::Quat::yxw ( ) const

◆ yxww()

Vector4 G3D::Quat::yxww ( ) const

◆ yxwx()

Vector4 G3D::Quat::yxwx ( ) const

◆ yxwy()

Vector4 G3D::Quat::yxwy ( ) const

◆ yxwz()

Vector4 G3D::Quat::yxwz ( ) const

◆ yxx()

Vector3 G3D::Quat::yxx ( ) const

◆ yxxw()

Vector4 G3D::Quat::yxxw ( ) const

◆ yxxx()

Vector4 G3D::Quat::yxxx ( ) const

◆ yxxy()

Vector4 G3D::Quat::yxxy ( ) const

◆ yxxz()

Vector4 G3D::Quat::yxxz ( ) const

◆ yxy()

Vector3 G3D::Quat::yxy ( ) const

◆ yxyw()

Vector4 G3D::Quat::yxyw ( ) const

◆ yxyx()

Vector4 G3D::Quat::yxyx ( ) const

◆ yxyy()

Vector4 G3D::Quat::yxyy ( ) const

◆ yxyz()

Vector4 G3D::Quat::yxyz ( ) const

◆ yxz()

Vector3 G3D::Quat::yxz ( ) const

◆ yxzw()

Vector4 G3D::Quat::yxzw ( ) const

◆ yxzx()

Vector4 G3D::Quat::yxzx ( ) const

◆ yxzy()

Vector4 G3D::Quat::yxzy ( ) const

◆ yxzz()

Vector4 G3D::Quat::yxzz ( ) const

◆ yy()

Vector2 G3D::Quat::yy ( ) const

◆ yyw()

Vector3 G3D::Quat::yyw ( ) const

◆ yyww()

Vector4 G3D::Quat::yyww ( ) const

◆ yywx()

Vector4 G3D::Quat::yywx ( ) const

◆ yywy()

Vector4 G3D::Quat::yywy ( ) const

◆ yywz()

Vector4 G3D::Quat::yywz ( ) const

◆ yyx()

Vector3 G3D::Quat::yyx ( ) const

◆ yyxw()

Vector4 G3D::Quat::yyxw ( ) const

◆ yyxx()

Vector4 G3D::Quat::yyxx ( ) const

◆ yyxy()

Vector4 G3D::Quat::yyxy ( ) const

◆ yyxz()

Vector4 G3D::Quat::yyxz ( ) const

◆ yyy()

Vector3 G3D::Quat::yyy ( ) const

◆ yyyw()

Vector4 G3D::Quat::yyyw ( ) const

◆ yyyx()

Vector4 G3D::Quat::yyyx ( ) const

◆ yyyy()

Vector4 G3D::Quat::yyyy ( ) const

◆ yyyz()

Vector4 G3D::Quat::yyyz ( ) const

◆ yyz()

Vector3 G3D::Quat::yyz ( ) const

◆ yyzw()

Vector4 G3D::Quat::yyzw ( ) const

◆ yyzx()

Vector4 G3D::Quat::yyzx ( ) const

◆ yyzy()

Vector4 G3D::Quat::yyzy ( ) const

◆ yyzz()

Vector4 G3D::Quat::yyzz ( ) const

◆ yz()

Vector2 G3D::Quat::yz ( ) const

◆ yzw()

Vector3 G3D::Quat::yzw ( ) const

◆ yzww()

Vector4 G3D::Quat::yzww ( ) const

◆ yzwx()

Vector4 G3D::Quat::yzwx ( ) const

◆ yzwy()

Vector4 G3D::Quat::yzwy ( ) const

◆ yzwz()

Vector4 G3D::Quat::yzwz ( ) const

◆ yzx()

Vector3 G3D::Quat::yzx ( ) const

◆ yzxw()

Vector4 G3D::Quat::yzxw ( ) const

◆ yzxx()

Vector4 G3D::Quat::yzxx ( ) const

◆ yzxy()

Vector4 G3D::Quat::yzxy ( ) const

◆ yzxz()

Vector4 G3D::Quat::yzxz ( ) const

◆ yzy()

Vector3 G3D::Quat::yzy ( ) const

◆ yzyw()

Vector4 G3D::Quat::yzyw ( ) const

◆ yzyx()

Vector4 G3D::Quat::yzyx ( ) const

◆ yzyy()

Vector4 G3D::Quat::yzyy ( ) const

◆ yzyz()

Vector4 G3D::Quat::yzyz ( ) const

◆ yzz()

Vector3 G3D::Quat::yzz ( ) const

◆ yzzw()

Vector4 G3D::Quat::yzzw ( ) const

◆ yzzx()

Vector4 G3D::Quat::yzzx ( ) const

◆ yzzy()

Vector4 G3D::Quat::yzzy ( ) const

◆ yzzz()

Vector4 G3D::Quat::yzzz ( ) const

◆ zw()

Vector2 G3D::Quat::zw ( ) const

◆ zww()

Vector3 G3D::Quat::zww ( ) const

◆ zwww()

Vector4 G3D::Quat::zwww ( ) const

◆ zwwx()

Vector4 G3D::Quat::zwwx ( ) const

◆ zwwy()

Vector4 G3D::Quat::zwwy ( ) const

◆ zwwz()

Vector4 G3D::Quat::zwwz ( ) const

◆ zwx()

Vector3 G3D::Quat::zwx ( ) const

◆ zwxw()

Vector4 G3D::Quat::zwxw ( ) const

◆ zwxx()

Vector4 G3D::Quat::zwxx ( ) const

◆ zwxy()

Vector4 G3D::Quat::zwxy ( ) const

◆ zwxz()

Vector4 G3D::Quat::zwxz ( ) const

◆ zwy()

Vector3 G3D::Quat::zwy ( ) const

◆ zwyw()

Vector4 G3D::Quat::zwyw ( ) const

◆ zwyx()

Vector4 G3D::Quat::zwyx ( ) const

◆ zwyy()

Vector4 G3D::Quat::zwyy ( ) const

◆ zwyz()

Vector4 G3D::Quat::zwyz ( ) const

◆ zwz()

Vector3 G3D::Quat::zwz ( ) const

◆ zwzw()

Vector4 G3D::Quat::zwzw ( ) const

◆ zwzx()

Vector4 G3D::Quat::zwzx ( ) const

◆ zwzy()

Vector4 G3D::Quat::zwzy ( ) const

◆ zwzz()

Vector4 G3D::Quat::zwzz ( ) const

◆ zx()

Vector2 G3D::Quat::zx ( ) const

◆ zxw()

Vector3 G3D::Quat::zxw ( ) const

◆ zxww()

Vector4 G3D::Quat::zxww ( ) const

◆ zxwx()

Vector4 G3D::Quat::zxwx ( ) const

◆ zxwy()

Vector4 G3D::Quat::zxwy ( ) const

◆ zxwz()

Vector4 G3D::Quat::zxwz ( ) const

◆ zxx()

Vector3 G3D::Quat::zxx ( ) const

◆ zxxw()

Vector4 G3D::Quat::zxxw ( ) const

◆ zxxx()

Vector4 G3D::Quat::zxxx ( ) const

◆ zxxy()

Vector4 G3D::Quat::zxxy ( ) const

◆ zxxz()

Vector4 G3D::Quat::zxxz ( ) const

◆ zxy()

Vector3 G3D::Quat::zxy ( ) const

◆ zxyw()

Vector4 G3D::Quat::zxyw ( ) const

◆ zxyx()

Vector4 G3D::Quat::zxyx ( ) const

◆ zxyy()

Vector4 G3D::Quat::zxyy ( ) const

◆ zxyz()

Vector4 G3D::Quat::zxyz ( ) const

◆ zxz()

Vector3 G3D::Quat::zxz ( ) const

◆ zxzw()

Vector4 G3D::Quat::zxzw ( ) const

◆ zxzx()

Vector4 G3D::Quat::zxzx ( ) const

◆ zxzy()

Vector4 G3D::Quat::zxzy ( ) const

◆ zxzz()

Vector4 G3D::Quat::zxzz ( ) const

◆ zy()

Vector2 G3D::Quat::zy ( ) const

◆ zyw()

Vector3 G3D::Quat::zyw ( ) const

◆ zyww()

Vector4 G3D::Quat::zyww ( ) const

◆ zywx()

Vector4 G3D::Quat::zywx ( ) const

◆ zywy()

Vector4 G3D::Quat::zywy ( ) const

◆ zywz()

Vector4 G3D::Quat::zywz ( ) const

◆ zyx()

Vector3 G3D::Quat::zyx ( ) const

◆ zyxw()

Vector4 G3D::Quat::zyxw ( ) const

◆ zyxx()

Vector4 G3D::Quat::zyxx ( ) const

◆ zyxy()

Vector4 G3D::Quat::zyxy ( ) const

◆ zyxz()

Vector4 G3D::Quat::zyxz ( ) const

◆ zyy()

Vector3 G3D::Quat::zyy ( ) const

◆ zyyw()

Vector4 G3D::Quat::zyyw ( ) const

◆ zyyx()

Vector4 G3D::Quat::zyyx ( ) const

◆ zyyy()

Vector4 G3D::Quat::zyyy ( ) const

◆ zyyz()

Vector4 G3D::Quat::zyyz ( ) const

◆ zyz()

Vector3 G3D::Quat::zyz ( ) const

◆ zyzw()

Vector4 G3D::Quat::zyzw ( ) const

◆ zyzx()

Vector4 G3D::Quat::zyzx ( ) const

◆ zyzy()

Vector4 G3D::Quat::zyzy ( ) const

◆ zyzz()

Vector4 G3D::Quat::zyzz ( ) const

◆ zz()

Vector2 G3D::Quat::zz ( ) const

◆ zzw()

Vector3 G3D::Quat::zzw ( ) const

◆ zzww()

Vector4 G3D::Quat::zzww ( ) const

◆ zzwx()

Vector4 G3D::Quat::zzwx ( ) const

◆ zzwy()

Vector4 G3D::Quat::zzwy ( ) const

◆ zzwz()

Vector4 G3D::Quat::zzwz ( ) const

◆ zzx()

Vector3 G3D::Quat::zzx ( ) const

◆ zzxw()

Vector4 G3D::Quat::zzxw ( ) const

◆ zzxx()

Vector4 G3D::Quat::zzxx ( ) const

◆ zzxy()

Vector4 G3D::Quat::zzxy ( ) const

◆ zzxz()

Vector4 G3D::Quat::zzxz ( ) const

◆ zzy()

Vector3 G3D::Quat::zzy ( ) const

◆ zzyw()

Vector4 G3D::Quat::zzyw ( ) const

◆ zzyx()

Vector4 G3D::Quat::zzyx ( ) const

◆ zzyy()

Vector4 G3D::Quat::zzyy ( ) const

◆ zzyz()

Vector4 G3D::Quat::zzyz ( ) const

◆ zzz()

Vector3 G3D::Quat::zzz ( ) const

◆ zzzw()

Vector4 G3D::Quat::zzzw ( ) const

◆ zzzx()

Vector4 G3D::Quat::zzzx ( ) const

◆ zzzy()

Vector4 G3D::Quat::zzzy ( ) const

◆ zzzz()

Vector4 G3D::Quat::zzzz ( ) const

Friends And Related Function Documentation

◆ operator*

Quat operator*	(	float	s,
		const Quat &	q
	)

friend

Referenced Code: Based on Watt & Watt, page 360

Member Data Documentation

◆ w

float G3D::Quat::w

Referenced by conj(), dot(), exp(), fuzzyEq(), isNaN(), log(), operator*(), operator*=(), operator+(), operator+=(), operator-(), operator-=(), operator/(), operator/=(), operator==(), real(), and sum().

◆ x

float G3D::Quat::x

q = [sin(angle / 2) * axis, cos(angle / 2)]

In Watt & Watt's notation, s = w, v = (x, y, z) In the Real-Time Rendering notation, u = (x, y, z), w = w

Referenced by conj(), dot(), exp(), fuzzyEq(), isNaN(), log(), operator*(), operator*=(), operator+(), operator+=(), operator-(), operator-=(), operator/(), operator/=(), operator==(), pow(), sum(), and toUnit().

◆ y

float G3D::Quat::y

Referenced by conj(), dot(), exp(), fuzzyEq(), isNaN(), log(), operator*(), operator*=(), operator+(), operator+=(), operator-(), operator-=(), operator/(), operator/=(), operator==(), and sum().

◆ z

float G3D::Quat::z

Referenced by conj(), dot(), exp(), fuzzyEq(), isNaN(), log(), operator*(), operator*=(), operator+(), operator+=(), operator-(), operator-=(), operator/(), operator/=(), operator==(), and sum().

Public Member Functions

Static Public Member Functions

Public Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ Quat() [1/5]

◆ Quat() [2/5]

◆ Quat() [3/5]

◆ Quat() [4/5]

◆ Quat() [5/5]

Member Function Documentation

◆ angleBetween()

◆ average()

◆ conj()

◆ deserialize()

◆ dot()

◆ exp()

◆ fromAxisAngleRotation()

◆ fuzzyEq()

◆ imag() [1/2]

◆ imag() [2/2]

◆ inverse()

◆ isNaN()

◆ isUnit()

◆ log()

◆ magnitude()

◆ movedTowards()

◆ moveTowards()

◆ nlerp()

◆ norm()

◆ operator*() [1/2]

◆ operator*() [2/2]

◆ operator*=()

◆ operator+()

◆ operator+=()

◆ operator-() [1/2]

◆ operator-() [2/2]

◆ operator-=()

◆ operator/() [1/2]

◆ operator/() [2/2]

◆ operator/=()

◆ operator==()

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ pow()

◆ real() [1/2]

◆ real() [2/2]

◆ sameRotation()

◆ serialize()

◆ slerp()

◆ sum()

◆ toAny()

◆ toAxisAngleRotation() [1/2]

◆ toAxisAngleRotation() [2/2]

◆ toRotationMatrix() [1/2]

◆ toRotationMatrix() [2/2]

◆ toUnit()

◆ unitize()

◆ unitRandom()

◆ ww()

◆ www()

◆ wwww()

◆ wwwx()

◆ wwwy()

◆ wwwz()

◆ wwx()

◆ wwxw()

◆ wwxx()

◆ wwxy()

◆ wwxz()

◆ wwy()

◆ wwyw()

◆ wwyx()

◆ wwyy()

◆ wwyz()

◆ wwz()

◆ wwzw()

◆ wwzx()

◆ wwzy()