Implementations of matrix, vector, and quaternion operations. More...

Data Structures
struct	C3D_FVec
	Float vector. More...

struct	C3D_Mtx
	Row-major 4x4 matrix. More...

Macros
#define	M_TAU (6.28318530717958647692528676655900576)

#define	M_PI (M_TAU/2)

#define	C3D_Angle(_angle) ((_angle)*M_TAU)
	Convert an angle from revolutions to radians.

#define	C3D_AngleFromDegrees(_angle) ((_angle)*M_TAU/360.0f)
	Convert an angle from degrees to radians.

#define	C3D_AspectRatioTop (400.0f / 240.0f)
	Aspect ratio for 3DS top screen.

#define	C3D_AspectRatioBot (320.0f / 240.0f)
	Aspect ratio for 3DS bottom screen.

Typedefs
typedef C3D_FVec	C3D_FQuat
	Float quaternion. See C3D_FVec.

Vector Math
static C3D_FVec	FVec4_New (float x, float y, float z, float w)
	Create a new FVec4.

static C3D_FVec	FVec4_Add (C3D_FVec lhs, C3D_FVec rhs)
	Add two FVec4s.

static C3D_FVec	FVec4_Subtract (C3D_FVec lhs, C3D_FVec rhs)
	Subtract two FVec4s.

static C3D_FVec	FVec4_Negate (C3D_FVec v)
	Negate a FVec4.

static C3D_FVec	FVec4_Scale (C3D_FVec v, float s)
	Scale a FVec4.

static C3D_FVec	FVec4_PerspDivide (C3D_FVec v)
	Perspective divide.

static float	FVec4_Dot (C3D_FVec lhs, C3D_FVec rhs)
	Dot product of two FVec4s.

static float	FVec4_Magnitude (C3D_FVec v)
	Magnitude of a FVec4.

static C3D_FVec	FVec4_Normalize (C3D_FVec v)
	Normalize a FVec4.

static C3D_FVec	FVec3_New (float x, float y, float z)
	Create a new FVec3.

static float	FVec3_Dot (C3D_FVec lhs, C3D_FVec rhs)
	Dot product of two FVec3s.

static float	FVec3_Magnitude (C3D_FVec v)
	Magnitude of a FVec3.

static C3D_FVec	FVec3_Normalize (C3D_FVec v)
	Normalize a FVec3.

static C3D_FVec	FVec3_Add (C3D_FVec lhs, C3D_FVec rhs)
	Add two FVec3s.

static C3D_FVec	FVec3_Subtract (C3D_FVec lhs, C3D_FVec rhs)
	Subtract two FVec3s.

static float	FVec3_Distance (C3D_FVec lhs, C3D_FVec rhs)
	Distance between two 3D points.

static C3D_FVec	FVec3_Scale (C3D_FVec v, float s)
	Scale a FVec3.

static C3D_FVec	FVec3_Negate (C3D_FVec v)
	Negate a FVec3.

static C3D_FVec	FVec3_Cross (C3D_FVec lhs, C3D_FVec rhs)
	Cross product of two FVec3s.

Matrix Math
Note All matrices are 4x4 unless otherwise noted.
static void	Mtx_Zeros (C3D_Mtx *out)
	Zero matrix.

static void	Mtx_Copy (C3D_Mtx out, const C3D_Mtx in)
	Copy a matrix.

static void	Mtx_Diagonal (C3D_Mtx *out, float x, float y, float z, float w)
	Creates a matrix with the diagonal using the given parameters.

static void	Mtx_Identity (C3D_Mtx *out)
	Identity matrix.

void	Mtx_Transpose (C3D_Mtx *out)
	Transposes the matrix. Row => Column, and vice versa.

static void	Mtx_Add (C3D_Mtx out, const C3D_Mtx lhs, const C3D_Mtx *rhs)
	Matrix addition.

static void	Mtx_Subtract (C3D_Mtx out, const C3D_Mtx lhs, const C3D_Mtx *rhs)
	Matrix subtraction.

void	Mtx_Multiply (C3D_Mtx out, const C3D_Mtx a, const C3D_Mtx *b)
	Multiply two matrices.

float	Mtx_Inverse (C3D_Mtx *out)
	Inverse a matrix.

C3D_FVec	Mtx_MultiplyFVec3 (const C3D_Mtx *mtx, C3D_FVec v)
	Multiply 3x3 matrix by a FVec3.

C3D_FVec	Mtx_MultiplyFVec4 (const C3D_Mtx *mtx, C3D_FVec v)
	Multiply 4x4 matrix by a FVec4.

static C3D_FVec	Mtx_MultiplyFVecH (const C3D_Mtx *mtx, C3D_FVec v)
	Multiply 4x3 matrix by a FVec3.

void	Mtx_FromQuat (C3D_Mtx *m, C3D_FQuat q)
	Get 4x4 matrix equivalent to Quaternion.

3D Transformation Matrix Math
Note bRightSide is used to determine which side to perform the transformation. With an input matrix A and a transformation matrix B, bRightSide being true yields AB, while being false yield BA.
void	Mtx_Translate (C3D_Mtx *mtx, float x, float y, float z, bool bRightSide)
	3D translation

void	Mtx_Scale (C3D_Mtx *mtx, float x, float y, float z)
	3D Scale

void	Mtx_Rotate (C3D_Mtx *mtx, C3D_FVec axis, float angle, bool bRightSide)
	3D Rotation

void	Mtx_RotateX (C3D_Mtx *mtx, float angle, bool bRightSide)
	3D Rotation about the X axis

void	Mtx_RotateY (C3D_Mtx *mtx, float angle, bool bRightSide)
	3D Rotation about the Y axis

void	Mtx_RotateZ (C3D_Mtx *mtx, float angle, bool bRightSide)
	3D Rotation about the Z axis

3D Projection Matrix Math
void	Mtx_Ortho (C3D_Mtx *mtx, float left, float right, float bottom, float top, float near, float far, bool isLeftHanded)
	Orthogonal projection.

void	Mtx_Persp (C3D_Mtx *mtx, float fovy, float aspect, float near, float far, bool isLeftHanded)
	Perspective projection.

void	Mtx_PerspStereo (C3D_Mtx *mtx, float fovy, float aspect, float near, float far, float iod, float screen, bool isLeftHanded)
	Stereo perspective projection.

void	Mtx_OrthoTilt (C3D_Mtx *mtx, float left, float right, float bottom, float top, float near, float far, bool isLeftHanded)
	Orthogonal projection, tilted to account for the 3DS screen rotation.

void	Mtx_PerspTilt (C3D_Mtx *mtx, float fovy, float aspect, float near, float far, bool isLeftHanded)
	Perspective projection, tilted to account for the 3DS screen rotation.

void	Mtx_PerspStereoTilt (C3D_Mtx *mtx, float fovy, float aspect, float near, float far, float iod, float screen, bool isLeftHanded)
	Stereo perspective projection, tilted to account for the 3DS screen rotation.

void	Mtx_LookAt (C3D_Mtx *out, C3D_FVec cameraPosition, C3D_FVec cameraTarget, C3D_FVec cameraUpVector, bool isLeftHanded)
	Look-At matrix, based on DirectX implementation.

Quaternion Math
C3D_FQuat	Quat_Multiply (C3D_FQuat lhs, C3D_FQuat rhs)
	Multiply two Quaternions.

C3D_FQuat	Quat_Pow (C3D_FQuat q, float p)
	Raise Quaternion to a power.

C3D_FVec	Quat_CrossFVec3 (C3D_FQuat q, C3D_FVec v)
	Cross product of Quaternion and FVec3.

C3D_FQuat	Quat_Rotate (C3D_FQuat q, C3D_FVec axis, float r, bool bRightSide)
	3D Rotation

C3D_FQuat	Quat_RotateX (C3D_FQuat q, float r, bool bRightSide)
	3D Rotation about the X axis

C3D_FQuat	Quat_RotateY (C3D_FQuat q, float r, bool bRightSide)
	3D Rotation about the Y axis

C3D_FQuat	Quat_RotateZ (C3D_FQuat q, float r, bool bRightSide)
	3D Rotation about the Z axis

C3D_FQuat	Quat_FromMtx (const C3D_Mtx *m)
	Get Quaternion equivalent to 4x4 matrix.

static C3D_FQuat	Quat_Identity (void)
	Identity Quaternion.

static C3D_FQuat	Quat_Conjugate (C3D_FQuat q)
	Quaternion conjugate.

static C3D_FQuat	Quat_Inverse (C3D_FQuat q)
	Quaternion inverse.

static C3D_FVec	FVec3_CrossQuat (C3D_FVec v, C3D_FQuat q)
	Cross product of FVec3 and Quaternion.

C3D_FQuat	Quat_FromPitchYawRoll (float pitch, float yaw, float roll, bool bRightSide)
	Converting Pitch, Yaw, and Roll to Quaternion equivalent.

C3D_FQuat	Quat_LookAt (C3D_FVec source, C3D_FVec target, C3D_FVec forwardVector, C3D_FVec upVector)
	Quaternion Look-At.

C3D_FQuat	Quat_FromAxisAngle (C3D_FVec axis, float angle)
	Quaternion, created from a given axis and angle in radians.

#define	Quat_New(i, j, k, r) FVec4_New(i,j,k,r)
	Create a new Quaternion.

#define	Quat_Negate(q) FVec4_Negate(q)
	Negate a Quaternion.

#define	Quat_Add(lhs, rhs) FVec4_Add(lhs,rhs)
	Add two Quaternions.

#define	Quat_Subtract(lhs, rhs) FVec4_Subtract(lhs,rhs)
	Subtract two Quaternions.

#define	Quat_Scale(q, s) FVec4_Scale(q,s)
	Scale a Quaternion.

#define	Quat_Normalize(q) FVec4_Normalize(q)
	Normalize a Quaternion.

#define	Quat_Dot(lhs, rhs) FVec4_Dot(lhs,rhs)
	Dot product of two Quaternions.

Detailed Description

Implementations of matrix, vector, and quaternion operations.

Macro Definition Documentation

◆ C3D_Angle

#define C3D_Angle ( _angle ) ((_angle)*M_TAU)

Convert an angle from revolutions to radians.

Parameters

[in] _angle Proportion of a full revolution

Returns: Angle in radians

◆ C3D_AngleFromDegrees

#define C3D_AngleFromDegrees ( _angle ) ((_angle)*M_TAU/360.0f)

Convert an angle from degrees to radians.

Parameters

[in] _angle Angle in degrees

Returns: Angle in radians

◆ M_TAU

#define M_TAU (6.28318530717958647692528676655900576)

The one true circumference-to-radius ratio. See http://tauday.com/tau-manifesto

◆ Quat_Add

#define Quat_Add	(	lhs,
		rhs
	)	FVec4_Add(lhs,rhs)

Add two Quaternions.

Parameters

[in]	lhs	Augend
[in]	rhs	Addend

Returns: lhs+rhs (sum)

◆ Quat_Dot

#define Quat_Dot	(	lhs,
		rhs
	)	FVec4_Dot(lhs,rhs)

Dot product of two Quaternions.

Parameters

[in]	lhs	Left-side Quaternion
[in]	rhs	Right-side Quaternion

Returns: lhs∙rhs

◆ Quat_Negate

#define Quat_Negate ( q ) FVec4_Negate(q)

Negate a Quaternion.

Note: This is equivalent to Quat_Scale(v, -1)

Parameters

[in] q Quaternion to negate

Returns: -q

◆ Quat_New

#define Quat_New	(	i,
		j,
		k,
		r
	)	FVec4_New(i,j,k,r)

Create a new Quaternion.

Parameters

[in]	i	I-component
[in]	j	J-component
[in]	k	K-component
[in]	r	Real component

Returns: New Quaternion

◆ Quat_Normalize

#define Quat_Normalize ( q ) FVec4_Normalize(q)

Normalize a Quaternion.

Parameters

[in] q Quaternion to normalize

Returns: q/‖q‖

◆ Quat_Scale

#define Quat_Scale	(	q,
		s
	)	FVec4_Scale(q,s)

Scale a Quaternion.

Parameters

[in]	q	Quaternion to scale
[in]	s	Scale factor

Returns: q*s

◆ Quat_Subtract

#define Quat_Subtract	(	lhs,
		rhs
	)	FVec4_Subtract(lhs,rhs)

Subtract two Quaternions.

Parameters

[in]	lhs	Minuend
[in]	rhs	Subtrahend

Returns: lhs-rhs (difference)

Function Documentation

◆ FVec3_Add()

static C3D_FVec FVec3_Add	(	C3D_FVec	lhs,
		C3D_FVec	rhs
	)

inlinestatic

Add two FVec3s.

Parameters

[in]	lhs	Augend
[in]	rhs	Addend

Returns: lhs+rhs (sum)

◆ FVec3_Cross()

static C3D_FVec FVec3_Cross	(	C3D_FVec	lhs,
		C3D_FVec	rhs
	)

inlinestatic

Cross product of two FVec3s.

Note: This returns a pseudo-vector which is perpendicular to the plane spanned by the two input vectors.

Parameters

[in]	lhs	Left-side FVec3
[in]	rhs	Right-side FVec3

Returns: lhs×rhs

◆ FVec3_CrossQuat()

static C3D_FVec FVec3_CrossQuat	(	C3D_FVec	v,
		C3D_FQuat	q
	)

inlinestatic

Cross product of FVec3 and Quaternion.

Parameters

[in]	v	Base FVec3
[in]	q	Quaternion to cross

Returns: v×q

◆ FVec3_Distance()

static float FVec3_Distance	(	C3D_FVec	lhs,
		C3D_FVec	rhs
	)

inlinestatic

Distance between two 3D points.

Parameters

[in]	lhs	Relative origin
[in]	rhs	Relative point of interest

Returns: ‖lhs-rhs‖

◆ FVec3_Dot()

static float FVec3_Dot	(	C3D_FVec	lhs,
		C3D_FVec	rhs
	)

inlinestatic

Dot product of two FVec3s.

Parameters

[in]	lhs	Left-side FVec3
[in]	rhs	Right-side FVec3

Returns: lhs∙rhs

◆ FVec3_Magnitude()

static float FVec3_Magnitude ( C3D_FVec v )

inlinestatic

Magnitude of a FVec3.

Parameters

[in] v Vector

Returns: ‖v‖

◆ FVec3_Negate()

static C3D_FVec FVec3_Negate ( C3D_FVec v )

inlinestatic

Negate a FVec3.

Note: This is equivalent to FVec3_Scale(v, -1)

Parameters

[in] v Vector to negate

Returns: -v

◆ FVec3_New()

static C3D_FVec FVec3_New	(	float	x,
		float	y,
		float	z
	)

inlinestatic

Create a new FVec3.

Parameters

[in]	x	X-component
[in]	y	Y-component
[in]	z	Z-component

Returns: New FVec3

◆ FVec3_Normalize()

static C3D_FVec FVec3_Normalize ( C3D_FVec v )

inlinestatic

Normalize a FVec3.

Parameters

[in] v FVec3 to normalize

Returns: v/‖v‖

◆ FVec3_Scale()

static C3D_FVec FVec3_Scale	(	C3D_FVec	v,
		float	s
	)

inlinestatic

Scale a FVec3.

Parameters

[in]	v	Vector to scale
[in]	s	Scale factor

Returns: v*s

◆ FVec3_Subtract()

static C3D_FVec FVec3_Subtract	(	C3D_FVec	lhs,
		C3D_FVec	rhs
	)

inlinestatic

Subtract two FVec3s.

Parameters

[in]	lhs	Minuend
[in]	rhs	Subtrahend

Returns: lhs-rhs (difference)

◆ FVec4_Add()

static C3D_FVec FVec4_Add	(	C3D_FVec	lhs,
		C3D_FVec	rhs
	)

inlinestatic

Add two FVec4s.

Parameters

[in]	lhs	Augend
[in]	rhs	Addend

Returns: lhs+rhs (sum)

◆ FVec4_Dot()

static float FVec4_Dot	(	C3D_FVec	lhs,
		C3D_FVec	rhs
	)

inlinestatic

Dot product of two FVec4s.

Parameters

[in]	lhs	Left-side FVec4
[in]	rhs	Right-side FVec4

Returns: lhs∙rhs

◆ FVec4_Magnitude()

static float FVec4_Magnitude ( C3D_FVec v )

inlinestatic

Magnitude of a FVec4.

Parameters

[in] v Vector

Returns: ‖v‖

◆ FVec4_Negate()

static C3D_FVec FVec4_Negate ( C3D_FVec v )

inlinestatic

Negate a FVec4.

Note: This is equivalent to FVec4_Scale(v, -1)

Parameters

[in] v Vector to negate

Returns: -v

◆ FVec4_New()

static C3D_FVec FVec4_New	(	float	x,
		float	y,
		float	z,
		float	w
	)

inlinestatic

Create a new FVec4.

Parameters

[in]	x	X-component
[in]	y	Y-component
[in]	z	Z-component
[in]	w	W-component

Returns: New FVec4

◆ FVec4_Normalize()

static C3D_FVec FVec4_Normalize ( C3D_FVec v )

inlinestatic

Normalize a FVec4.

Parameters

[in] v FVec4 to normalize

Returns: v/‖v‖

◆ FVec4_PerspDivide()

static C3D_FVec FVec4_PerspDivide ( C3D_FVec v )

inlinestatic

Perspective divide.

Parameters

[in] v Vector to divide

Returns: v/v.w

◆ FVec4_Scale()

static C3D_FVec FVec4_Scale	(	C3D_FVec	v,
		float	s
	)

inlinestatic

Scale a FVec4.

Parameters

[in]	v	Vector to scale
[in]	s	Scale factor

Returns: v*s

◆ FVec4_Subtract()

static C3D_FVec FVec4_Subtract	(	C3D_FVec	lhs,
		C3D_FVec	rhs
	)

inlinestatic

Subtract two FVec4s.

Parameters

[in]	lhs	Minuend
[in]	rhs	Subtrahend

Returns: lhs-rhs (difference)

◆ Mtx_Add()

static void Mtx_Add	(	C3D_Mtx *	out,
		const C3D_Mtx *	lhs,
		const C3D_Mtx *	rhs
	)

inlinestatic

Matrix addition.

Parameters

[out]	out	Output matrix.
[in]	lhs	Left matrix.
[in]	rhs	Right matrix.

Returns: lhs+rhs (sum)

◆ Mtx_Copy()

static void Mtx_Copy	(	C3D_Mtx *	out,
		const C3D_Mtx *	in
	)

inlinestatic

Copy a matrix.

Parameters

[out]	out	Output matrix
[in]	in	Input matrix

◆ Mtx_Diagonal()

static void Mtx_Diagonal	(	C3D_Mtx *	out,
		float	x,
		float	y,
		float	z,
		float	w
	)

inlinestatic

Creates a matrix with the diagonal using the given parameters.

Parameters

[out]	out	Output matrix.
[in]	x	The X component.
[in]	y	The Y component.
[in]	z	The Z component.
[in]	w	The W component.

◆ Mtx_FromQuat()

void Mtx_FromQuat	(	C3D_Mtx *	m,
		C3D_FQuat	q
	)

Get 4x4 matrix equivalent to Quaternion.

Parameters

[out]	m	Output matrix
[in]	q	Input Quaternion

◆ Mtx_Identity()

static void Mtx_Identity ( C3D_Mtx * out )

inlinestatic

Identity matrix.

Parameters

[out] out Matrix to fill

◆ Mtx_Inverse()

float Mtx_Inverse ( C3D_Mtx * out )

Inverse a matrix.

Parameters

[in,out] out Matrix to inverse

Return values

0.0f	Degenerate matrix (no inverse)

Returns: determinant

◆ Mtx_LookAt()

void Mtx_LookAt	(	C3D_Mtx *	out,
		C3D_FVec	cameraPosition,
		C3D_FVec	cameraTarget,
		C3D_FVec	cameraUpVector,
		bool	isLeftHanded
	)

Look-At matrix, based on DirectX implementation.

Note: See https://msdn.microsoft.com/en-us/library/windows/desktop/bb205342

Parameters

[out]	out	Output matrix.
[in]	cameraPosition	Position of the intended camera in 3D space.
[in]	cameraTarget	Position of the intended target the camera is supposed to face in 3D space.
[in]	cameraUpVector	The vector that points straight up depending on the camera's "Up" direction.
[in]	isLeftHanded	Whether to build a LH projection

◆ Mtx_Multiply()

void Mtx_Multiply	(	C3D_Mtx *	out,
		const C3D_Mtx *	a,
		const C3D_Mtx *	b
	)

Multiply two matrices.

Parameters

[out]	out	Output matrix
[in]	a	Multiplicand
[in]	b	Multiplier

◆ Mtx_MultiplyFVec3()

C3D_FVec Mtx_MultiplyFVec3	(	const C3D_Mtx *	mtx,
		C3D_FVec	v
	)

Multiply 3x3 matrix by a FVec3.

Parameters

[in]	mtx	Matrix
[in]	v	Vector

Returns: mtx*v (product)

◆ Mtx_MultiplyFVec4()

C3D_FVec Mtx_MultiplyFVec4	(	const C3D_Mtx *	mtx,
		C3D_FVec	v
	)

Multiply 4x4 matrix by a FVec4.

Parameters

[in]	mtx	Matrix
[in]	v	Vector

Returns: mtx*v (product)

◆ Mtx_MultiplyFVecH()

static C3D_FVec Mtx_MultiplyFVecH	(	const C3D_Mtx *	mtx,
		C3D_FVec	v
	)

inlinestatic

Multiply 4x3 matrix by a FVec3.

Parameters

[in]	mtx	Matrix
[in]	v	Vector

Returns: mtx*v (product)

◆ Mtx_Ortho()

void Mtx_Ortho	(	C3D_Mtx *	mtx,
		float	left,
		float	right,
		float	bottom,
		float	top,
		float	near,
		float	far,
		bool	isLeftHanded
	)

Orthogonal projection.

Parameters

[out]	mtx	Output matrix
[in]	left	Left clip plane (X=left)
[in]	right	Right clip plane (X=right)
[in]	bottom	Bottom clip plane (Y=bottom)
[in]	top	Top clip plane (Y=top)
[in]	near	Near clip plane (Z=near)
[in]	far	Far clip plane (Z=far)
[in]	isLeftHanded	Whether to build a LH projection

See also: Mtx_OrthoTilt

◆ Mtx_OrthoTilt()

void Mtx_OrthoTilt	(	C3D_Mtx *	mtx,
		float	left,
		float	right,
		float	bottom,
		float	top,
		float	near,
		float	far,
		bool	isLeftHanded
	)

Orthogonal projection, tilted to account for the 3DS screen rotation.

Parameters

[out]	mtx	Output matrix
[in]	left	Left clip plane (X=left)
[in]	right	Right clip plane (X=right)
[in]	bottom	Bottom clip plane (Y=bottom)
[in]	top	Top clip plane (Y=top)
[in]	near	Near clip plane (Z=near)
[in]	far	Far clip plane (Z=far)
[in]	isLeftHanded	Whether to build a LH projection

See also: Mtx_Ortho

◆ Mtx_Persp()

void Mtx_Persp	(	C3D_Mtx *	mtx,
		float	fovy,
		float	aspect,
		float	near,
		float	far,
		bool	isLeftHanded
	)

Perspective projection.

Parameters

[out]	mtx	Output matrix
[in]	fovy	Vertical field of view in radians
[in]	aspect	Aspect ration of projection plane (width/height)
[in]	near	Near clip plane (Z=near)
[in]	far	Far clip plane (Z=far)
[in]	isLeftHanded	Whether to build a LH projection

See also: Mtx_PerspTilt; Mtx_PerspStereo; Mtx_PerspStereoTilt

◆ Mtx_PerspStereo()

void Mtx_PerspStereo	(	C3D_Mtx *	mtx,
		float	fovy,
		float	aspect,
		float	near,
		float	far,
		float	iod,
		float	screen,
		bool	isLeftHanded
	)

Stereo perspective projection.

Note: Typically you will use iod to mean the distance between the eyes. Plug in -iod for the left eye and iod for the right eye.; The focal length is defined by screen. If objects are further than this, they will appear to be inside the screen. If objects are closer than this, they will appear to pop out of the screen. Objects at this distance appear to be at the screen.

Parameters

[out]	mtx	Output matrix
[in]	fovy	Vertical field of view in radians
[in]	aspect	Aspect ration of projection plane (width/height)
[in]	near	Near clip plane (Z=near)
[in]	far	Far clip plane (Z=far)
[in]	iod	Interocular distance
[in]	screen	Focal length
[in]	isLeftHanded	Whether to build a LH projection

See also: Mtx_Persp; Mtx_PerspTilt; Mtx_PerspStereoTilt

◆ Mtx_PerspStereoTilt()

void Mtx_PerspStereoTilt	(	C3D_Mtx *	mtx,
		float	fovy,
		float	aspect,
		float	near,
		float	far,
		float	iod,
		float	screen,
		bool	isLeftHanded
	)

Stereo perspective projection, tilted to account for the 3DS screen rotation.

Note: See the notes for Mtx_PerspStereo

Parameters

[out]	mtx	Output matrix
[in]	fovy	Vertical field of view in radians
[in]	aspect	Aspect ration of projection plane (width/height)
[in]	near	Near clip plane (Z=near)
[in]	far	Far clip plane (Z=far)
[in]	iod	Interocular distance
[in]	screen	Focal length
[in]	isLeftHanded	Whether to build a LH projection

See also: Mtx_Persp; Mtx_PerspTilt; Mtx_PerspStereo

◆ Mtx_PerspTilt()

void Mtx_PerspTilt	(	C3D_Mtx *	mtx,
		float	fovy,
		float	aspect,
		float	near,
		float	far,
		bool	isLeftHanded
	)

Perspective projection, tilted to account for the 3DS screen rotation.

Parameters

[out]	mtx	Output matrix
[in]	fovy	Vertical field of view in radians
[in]	aspect	Aspect ration of projection plane (width/height)
[in]	near	Near clip plane (Z=near)
[in]	far	Far clip plane (Z=far)
[in]	isLeftHanded	Whether to build a LH projection

See also: Mtx_Persp; Mtx_PerspStereo; Mtx_PerspStereoTilt

◆ Mtx_Rotate()

void Mtx_Rotate	(	C3D_Mtx *	mtx,
		C3D_FVec	axis,
		float	angle,
		bool	bRightSide
	)

3D Rotation

Parameters

[in,out]	mtx	Matrix to rotate
[in]	axis	Axis about which to rotate
[in]	angle	Radians to rotate
[in]	bRightSide	Whether to transform from the right side

◆ Mtx_RotateX()

void Mtx_RotateX	(	C3D_Mtx *	mtx,
		float	angle,
		bool	bRightSide
	)

3D Rotation about the X axis

Parameters

[in,out]	mtx	Matrix to rotate
[in]	angle	Radians to rotate
[in]	bRightSide	Whether to transform from the right side

◆ Mtx_RotateY()

void Mtx_RotateY	(	C3D_Mtx *	mtx,
		float	angle,
		bool	bRightSide
	)

3D Rotation about the Y axis

Parameters

[in,out]	mtx	Matrix to rotate
[in]	angle	Radians to rotate
[in]	bRightSide	Whether to transform from the right side

◆ Mtx_RotateZ()

void Mtx_RotateZ	(	C3D_Mtx *	mtx,
		float	angle,
		bool	bRightSide
	)

3D Rotation about the Z axis

Parameters

[in,out]	mtx	Matrix to rotate
[in]	angle	Radians to rotate
[in]	bRightSide	Whether to transform from the right side

◆ Mtx_Scale()

void Mtx_Scale	(	C3D_Mtx *	mtx,
		float	x,
		float	y,
		float	z
	)

3D Scale

Parameters

[in,out]	mtx	Matrix to scale
[in]	x	X component to scale
[in]	y	Y component to scale
[in]	z	Z component to scale

◆ Mtx_Subtract()

static void Mtx_Subtract	(	C3D_Mtx *	out,
		const C3D_Mtx *	lhs,
		const C3D_Mtx *	rhs
	)

inlinestatic

Matrix subtraction.

Parameters

[out]	out	Output matrix.
[in]	lhs	Left matrix.
[in]	rhs	Right matrix.

Returns: lhs-rhs (difference)

◆ Mtx_Translate()

void Mtx_Translate	(	C3D_Mtx *	mtx,
		float	x,
		float	y,
		float	z,
		bool	bRightSide
	)

3D translation

Parameters

[in,out]	mtx	Matrix to translate
[in]	x	X component to translate
[in]	y	Y component to translate
[in]	z	Z component to translate
[in]	bRightSide	Whether to transform from the right side

◆ Mtx_Transpose()

void Mtx_Transpose ( C3D_Mtx * out )

Transposes the matrix. Row => Column, and vice versa.

Parameters

[in,out] out Output matrix.

◆ Mtx_Zeros()

static void Mtx_Zeros ( C3D_Mtx * out )

inlinestatic

Zero matrix.

Parameters

[out] out Matrix to zero

◆ Quat_Conjugate()

static C3D_FQuat Quat_Conjugate ( C3D_FQuat q )

inlinestatic

Quaternion conjugate.

Parameters

[in] q Quaternion of which to get conjugate

Returns: q*

◆ Quat_CrossFVec3()

C3D_FVec Quat_CrossFVec3	(	C3D_FQuat	q,
		C3D_FVec	v
	)

Cross product of Quaternion and FVec3.

Parameters

[in]	q	Base Quaternion
[in]	v	Vector to cross

Returns: q×v

◆ Quat_FromAxisAngle()

C3D_FQuat Quat_FromAxisAngle	(	C3D_FVec	axis,
		float	angle
	)

Quaternion, created from a given axis and angle in radians.

Parameters

[in]	axis	C3D_FVec The axis to rotate around at.
[in]	angle	float The angle to rotate. Unit: Radians

Returns: Quaternion rotation based on the axis and angle. Axis doesn't have to be orthogonal.

◆ Quat_FromMtx()

C3D_FQuat Quat_FromMtx ( const C3D_Mtx * m )

Get Quaternion equivalent to 4x4 matrix.

Note: If the matrix is orthogonal or special orthogonal, where determinant(matrix) = +1.0f, then the matrix can be converted.

Parameters

[in] m Input Matrix

Returns: Generated Quaternion

◆ Quat_FromPitchYawRoll()

C3D_FQuat Quat_FromPitchYawRoll	(	float	pitch,
		float	yaw,
		float	roll,
		bool	bRightSide
	)

Converting Pitch, Yaw, and Roll to Quaternion equivalent.

Parameters

[in]	pitch	The pitch angle in radians.
[in]	yaw	The yaw angle in radians.
[in]	roll	The roll angle in radians.
[in]	bRightSide	Whether to transform from the right side

Returns: C3D_FQuat The Quaternion equivalent with the pitch, yaw, and roll (in that order) orientations applied.

◆ Quat_Identity()

static C3D_FQuat Quat_Identity ( void )

inlinestatic

Identity Quaternion.

Returns: Identity Quaternion

◆ Quat_Inverse()

static C3D_FQuat Quat_Inverse ( C3D_FQuat q )

inlinestatic

Quaternion inverse.

Note: This is equivalent to Quat_Pow(v, -1)

Parameters

[in] q Quaternion of which to get inverse

Returns: q^-1

◆ Quat_LookAt()

C3D_FQuat Quat_LookAt	(	C3D_FVec	source,
		C3D_FVec	target,
		C3D_FVec	forwardVector,
		C3D_FVec	upVector
	)

Quaternion Look-At.

Parameters

[in]	source	C3D_FVec Starting position. Origin of rotation.
[in]	target	C3D_FVec Target position to orient towards.
[in]	forwardVector	C3D_FVec The Up vector.
[in]	upVector	C3D_FVec The Up vector.

Returns: Quaternion rotation.

◆ Quat_Multiply()

C3D_FQuat Quat_Multiply	(	C3D_FQuat	lhs,
		C3D_FQuat	rhs
	)

Multiply two Quaternions.

Parameters

[in]	lhs	Multiplicand
[in]	rhs	Multiplier

Returns: lhs*rhs

◆ Quat_Pow()

C3D_FQuat Quat_Pow	(	C3D_FQuat	q,
		float	p
	)

Raise Quaternion to a power.

Note: If p is 0, this returns the identity Quaternion. If p is 1, this returns q.

Parameters

[in]	q	Base Quaternion
[in]	p	Power

Returns: q^p

◆ Quat_Rotate()

C3D_FQuat Quat_Rotate	(	C3D_FQuat	q,
		C3D_FVec	axis,
		float	r,
		bool	bRightSide
	)

3D Rotation

Parameters

[in]	q	Quaternion to rotate
[in]	axis	Axis about which to rotate
[in]	r	Radians to rotate
[in]	bRightSide	Whether to transform from the right side

Returns: Rotated Quaternion

◆ Quat_RotateX()

C3D_FQuat Quat_RotateX	(	C3D_FQuat	q,
		float	r,
		bool	bRightSide
	)

3D Rotation about the X axis

Parameters

[in]	q	Quaternion to rotate
[in]	r	Radians to rotate
[in]	bRightSide	Whether to transform from the right side

Returns: Rotated Quaternion

◆ Quat_RotateY()

C3D_FQuat Quat_RotateY	(	C3D_FQuat	q,
		float	r,
		bool	bRightSide
	)

3D Rotation about the Y axis

Parameters

[in]	q	Quaternion to rotate
[in]	r	Radians to rotate
[in]	bRightSide	Whether to transform from the right side

Returns: Rotated Quaternion

◆ Quat_RotateZ()

C3D_FQuat Quat_RotateZ	(	C3D_FQuat	q,
		float	r,
		bool	bRightSide
	)

3D Rotation about the Z axis

Parameters

[in]	q	Quaternion to rotate
[in]	r	Radians to rotate
[in]	bRightSide	Whether to transform from the right side

Returns: Rotated Quaternion

Data Structures

Macros

Typedefs

Vector Math

Matrix Math

3D Transformation Matrix Math

3D Projection Matrix Math

Quaternion Math

Detailed Description

Macro Definition Documentation

◆ C3D_Angle

◆ C3D_AngleFromDegrees

◆ M_TAU

◆ Quat_Add

◆ Quat_Dot

◆ Quat_Negate

◆ Quat_New

◆ Quat_Normalize

◆ Quat_Scale

◆ Quat_Subtract

Function Documentation

◆ FVec3_Add()

◆ FVec3_Cross()

◆ FVec3_CrossQuat()

◆ FVec3_Distance()

◆ FVec3_Dot()

◆ FVec3_Magnitude()

◆ FVec3_Negate()

◆ FVec3_New()

◆ FVec3_Normalize()

◆ FVec3_Scale()

◆ FVec3_Subtract()

◆ FVec4_Add()

◆ FVec4_Dot()

◆ FVec4_Magnitude()

◆ FVec4_Negate()

◆ FVec4_New()

◆ FVec4_Normalize()

◆ FVec4_PerspDivide()

◆ FVec4_Scale()

◆ FVec4_Subtract()

◆ Mtx_Add()

◆ Mtx_Copy()

◆ Mtx_Diagonal()

◆ Mtx_FromQuat()

◆ Mtx_Identity()

◆ Mtx_Inverse()

◆ Mtx_LookAt()

◆ Mtx_Multiply()

◆ Mtx_MultiplyFVec3()

◆ Mtx_MultiplyFVec4()

◆ Mtx_MultiplyFVecH()

◆ Mtx_Ortho()

◆ Mtx_OrthoTilt()

◆ Mtx_Persp()

◆ Mtx_PerspStereo()

◆ Mtx_PerspStereoTilt()

◆ Mtx_PerspTilt()

◆ Mtx_Rotate()

◆ Mtx_RotateX()

◆ Mtx_RotateY()

◆ Mtx_RotateZ()

◆ Mtx_Scale()

◆ Mtx_Subtract()

◆ Mtx_Translate()

◆ Mtx_Transpose()

◆ Mtx_Zeros()

◆ Quat_Conjugate()

◆ Quat_CrossFVec3()

◆ Quat_FromAxisAngle()

◆ Quat_FromMtx()

◆ Quat_FromPitchYawRoll()

◆ Quat_Identity()

◆ Quat_Inverse()

◆ Quat_LookAt()

◆ Quat_Multiply()

◆ Quat_Pow()

◆ Quat_Rotate()

◆ Quat_RotateX()

◆ Quat_RotateY()