3 dimensional floating point matrix More...

Collaboration diagram for Burger::Matrix3D_t:

Public Member Functions
void	Zero (void)
	Clear out a 3D matrix.

void	Identity (void)
	Initialize a 3D matrix so that it is inert.

void	Set (const Matrix3D_t *pInput)
	Copy the matrix.

void	Set (const FixedMatrix3D_t *pInput)
	Convert a fixed point matrix into a floating point matrix.

void	Set (const Matrix4D_t *pInput)
	Copy a Matrix4D_t to a Matrix3D_t.

void	SetYaw (float fYaw)
	Initialize a rotation matrix with radians for yaw (Y)

void	SetPitch (float fPitch)
	Initialize a rotation matrix with radians for pitch (X)

void	SetRoll (float fRoll)
	Initialize a rotation matrix with radians for roll (Z)

void	SetYXZ (float fYaw, float fPitch, float fRoll)
	Initialize a rotation matrix in the order of Y, X and Z.

void	SetYZX (float fYaw, float fPitch, float fRoll)
	Initialize a rotation matrix in the order of Y, Z and X.

void	SetXYZ (float fYaw, float fPitch, float fRoll)
	Initialize a rotation matrix in the order of X, Y and Z.

void	SetXZY (float fYaw, float fPitch, float fRoll)
	Initialize a rotation matrix in the order of X, Z and Y.

void	SetZYX (float fYaw, float fPitch, float fRoll)
	Initialize a rotation matrix in the order of Z, Y and X.

void	SetZXY (float fYaw, float fPitch, float fRoll)
	Initialize a rotation matrix in the order of Z, X and Y.

void	SetTranslate (float fX, float fY)
	Create a 2D Translation matrix.

void	SetFromQuaternion (const Vector4D_t *pInput)
	Convert a quaternion to a 3x3 matrix.

void	TransposeSetYaw (float fYaw)
	Initialize a rotation matrix with radians for yaw (Y)

void	TransposeSetPitch (float fPitch)
	Initialize a rotation matrix with radians for pitch (X)

void	TransposeSetRoll (float fRoll)
	Initialize a rotation matrix with radians for roll (Z)

void	TransposeSetYXZ (float fYaw, float fPitch, float fRoll)
	Initialize a transposed rotation matrix in the order of Y, X and Z.

void	TransposeSetYZX (float fYaw, float fPitch, float fRoll)
	Initialize a transposed rotation matrix in the order of Y, Z and X.

void	TransposeSetXYZ (float fYaw, float fPitch, float fRoll)
	Initialize a transposed rotation matrix in the order of X, Y and Z.

void	TransposeSetXZY (float fYaw, float fPitch, float fRoll)
	Initialize a transposed rotation matrix in the order of X, Z and Y.

void	TransposeSetZYX (float fYaw, float fPitch, float fRoll)
	Initialize a transposed rotation matrix in the order of Z, Y and X.

void	TransposeSetZXY (float fYaw, float fPitch, float fRoll)
	Initialize a transposed rotation matrix in the order of Z, X and Y.

void	TransposeSetFromQuaternion (const Vector4D_t *pInput)
	Convert a quaternion to a transposed 3x3 matrix.

void	SetScale (float fX, float fY, float fZ) noexcept
	Create a 3D scale matrix.

void	Transpose (void)
	Perform a matrix transposition.

void	Transpose (const Matrix3D_t *pInput)
	Perform a matrix transposition.

void	GetXRow (Vector3D_t *pOutput) const
	Return the X row from a matrix.

void	GetYRow (Vector3D_t *pOutput) const
	Return the Y row from a matrix.

void	GetZRow (Vector3D_t *pOutput) const
	Return the Z row from a matrix.

void	GetXColumn (Vector3D_t *pOutput) const
	Return the X column from a matrix.

void	GetYColumn (Vector3D_t *pOutput) const
	Return the Y column from a matrix.

void	GetZColumn (Vector3D_t *pOutput) const
	Return the Z column from a matrix.

void	SetXRow (const Vector3D_t *pInput)
	Set the X row of a matrix.

void	SetXRow (float fX, float fY, float fZ)
	Set the X row of a matrix.

void	SetYRow (const Vector3D_t *pInput)
	Set the Y row of a matrix.

void	SetYRow (float fX, float fY, float fZ)
	Set the Y row of a matrix.

void	SetZRow (const Vector3D_t *pInput)
	Set the Z row of a matrix.

void	SetZRow (float fX, float fY, float fZ)
	Set the Z row of a matrix.

void	SetXColumn (const Vector3D_t *pInput)
	Set the X column of a matrix.

void	SetXColumn (float fX, float fY, float fZ)
	Set the X column of a matrix.

void	SetYColumn (const Vector3D_t *pInput)
	Set the Y column of a matrix.

void	SetYColumn (float fX, float fY, float fZ)
	Set the Y column of a matrix.

void	SetZColumn (const Vector3D_t *pInput)
	Set the Z column of a matrix.

void	SetZColumn (float fX, float fY, float fZ)
	Set the Z column of a matrix.

void	Multiply (const Matrix3D_t *pInput)
	Perform a matrix multiply against this matrix.

void	Multiply (const Matrix3D_t pInput1, const Matrix3D_t pInput2) noexcept
	Perform a matrix multiply.

void	Multiply (float fScale)
	Multiply all entries by a scalar.

void	Multiply (const Matrix3D_t *pInput, float fScale)
	Initialize with a matrix multiplied by a scalar.

void	Multiply (float fScaleX, float fScaleY, float fScaleZ)
	Multiply by an X,Y and Z scale.

void	Multiply (const Matrix3D_t *pInput, float fScaleX, float fScaleY, float fScaleZ) noexcept
	Multiply by an X,Y and Z scale into a copy.

void	TransposeMultiply (float fScaleX, float fScaleY, float fScaleZ)
	Multiply by an X,Y and Z scale.

void	TransposeMultiply (const Matrix3D_t *pInput, float fScaleX, float fScaleY, float fScaleZ) noexcept
	Multiply by an X,Y and Z scale into a copy.

void	Transform (Vector3D_t *pInput) const
	Multiply a vector by a matrix.

void	Transform (Vector3D_t pOutput, const Vector3D_t pInput) const
	Multiply a vector by a matrix.

void	TransformAdd (Vector3D_t pInput, const Vector3D_t pTranslate) const
	Transform a vector and then add a point.

void	TransformAdd (Vector3D_t pOutput, const Vector3D_t pInput, const Vector3D_t *pTranslate) const
	Transform a vector and then add a point.

void	TransposeTransform (Vector3D_t *pInput) const
	Multiply a vector by a transposed matrix.

void	TransposeTransform (Vector3D_t pOutput, const Vector3D_t pInput) const
	Multiply a vector by a transposed matrix.

void	TransposeTransformAdd (Vector3D_t pInput, const Vector3D_t pTranslate) const
	Transform a vector and then add a point.

void	TransposeTransformAdd (Vector3D_t pOutput, const Vector3D_t pInput, const Vector3D_t *pTranslate) const
	Transform a vector and then add a point.

uint_t	AffineInverse (const Matrix3D_t *pInput)
	Perform an affine inverse.

void	Yaw (float fYaw)
	Rotate a matrix in the Y axis (Yaw)

void	Pitch (float fPitch)
	Rotate a matrix in the X axis (Pitch)

void	Roll (float fRoll)
	Rotate a matrix in the Z axis (Roll)

	operator const float * () const
	Convert to a const float pointer.

Public Attributes
Vector3D_t	x
	32 bit floating point X row for the 3D Matrix

Vector3D_t	y
	32 bit floating point Y row for the 3D Matrix

Vector3D_t	z
	32 bit floating point Z row for the 3D Matrix

Detailed Description

3 dimensional floating point matrix

This 36 byte matrix contains x,y and z 32 bit floating point rows and columns. A set of common functions for simple 3 dimensional math are part of the structure.

It is expected to be 4 byte aligned and use scalar math. The members are hard coded to be "x", "y" and "z" for maximum compatibility

Note: Since this is a structure, there is no constructor or destructor, so assume the data is uninitialized when creating this data type.

See also: Burger::Vector3D_t, Burger::Matrix4D_t or Burger::FixedMatrix3D_t

Member Function Documentation

◆ AffineInverse()

uint_t BURGER_API Burger::Matrix3D_t::AffineInverse ( const Matrix3D_t * pInput )

Perform an affine inverse.

Given an input matrix, perform an affine inverse and store it in this instance.

Note: Due to buffer use, do NOT perform this operation on the matrix itself!

Parameters

pInput Pointer to a matrix to obtain an inverse from

Returns: TRUE if the inverse was successful, FALSE if failure

◆ GetXColumn()

void BURGER_API Burger::Matrix3D_t::GetXColumn ( Vector3D_t * pOutput ) const

Return the X column from a matrix.

Copy the x column of a matrix into a user supplied Vector3D_t buffer.

x	xx
y	yx
z	zx

Parameters

pOutput Pointer to an uninitialized Vector3D_t structure to receive the data

◆ GetXRow()

void BURGER_API Burger::Matrix3D_t::GetXRow ( Vector3D_t * pOutput ) const

Return the X row from a matrix.

Copy the x row of a matrix into a user supplied Vector3D_t buffer.

x	xx
y	xy
z	xz

Parameters

pOutput Pointer to an uninitialized Vector3D_t structure to receive the data

◆ GetYColumn()

void BURGER_API Burger::Matrix3D_t::GetYColumn ( Vector3D_t * pOutput ) const

Return the Y column from a matrix.

Copy the y column of a matrix into a user supplied Vector3D_t buffer.

x	xy
y	yy
z	zy

Parameters

pOutput Pointer to an uninitialized Vector3D_t structure to receive the data

◆ GetYRow()

void BURGER_API Burger::Matrix3D_t::GetYRow ( Vector3D_t * pOutput ) const

Return the Y row from a matrix.

Copy the y row of a matrix into a user supplied Vector3D_t buffer.

x	yx
y	yy
z	yz

Parameters

pOutput Pointer to an uninitialized Vector3D_t structure to receive the data

◆ GetZColumn()

void BURGER_API Burger::Matrix3D_t::GetZColumn ( Vector3D_t * pOutput ) const

Return the Z column from a matrix.

Copy the z column of a matrix into a user supplied Vector3D_t buffer.

x	xz
y	yz
z	zz

Parameters

pOutput Pointer to an uninitialized Vector3D_t structure to receive the data

◆ GetZRow()

void BURGER_API Burger::Matrix3D_t::GetZRow ( Vector3D_t * pOutput ) const

Return the Z row from a matrix.

Copy the z row of a matrix into a user supplied Vector3D_t buffer.

x	zx
y	zy
z	zz

Parameters

pOutput Pointer to an uninitialized Vector3D_t structure to receive the data

◆ Identity()

void BURGER_API Burger::Matrix3D_t::Identity ( void )

Initialize a 3D matrix so that it is inert.

Sets the x.x, y.y and z.z components to 1.0f, all others to 0.0f

	x	y	z
x	1	0	0
y	0	1	0
z	0	0	1

See also: Zero(void)

◆ Multiply() [1/6]

void BURGER_API Burger::Matrix3D_t::Multiply ( const Matrix3D_t * pInput )

Perform a matrix multiply against this matrix.

Multiply this matrix against another one

Use this formula to create the final matrix, this matrix is matrix #1 and the input matrix is matrix #2

	x	y	z
x	(xx1xx2)+(yx1xy2)+(zx1*xz2)	(xy1xx2)+(yy1xy2)+(zy1*xz2)	(xz1xx2)+(yz1xy2)+(zz1*xz2)
y	(xx1yx2)+(yx1yy2)+(zx1*yz2)	(xy1yx2)+(yy1yy2)+(zy1*yz2)	(xz1yx2)+(yz1yy2)+(zz1*yz2)
z	(xx1zx2)+(yx1zy2)+(zx1*zz2)	(xy1zx2)+(yy1zy2)+(zy1*zz2)	(xz1zx2)+(yz1zy2)+(zz1*zz2)

Parameters

pInput Matrix to multiply against

See also: Multiply(const Matrix3D_t *,const Matrix3D_t *)

◆ Multiply() [2/6]

void BURGER_API Burger::Matrix3D_t::Multiply	(	const Matrix3D_t *	pInput,
		float	fScale )

Initialize with a matrix multiplied by a scalar.

Multiply all values of the matrix by a scalar constant and store the result in this matrix

Use this formula to create the final matrix

	x	y	z
x	(pInput->x.x*fScale)	(pInput->x.y*fScale)	(pInput->x.z*fScale)
y	(pInput->y.x*fScale)	(pInput->y.y*fScale)	(pInput->y.z*fScale)
z	(pInput->z.x*fScale)	(pInput->z.y*fScale)	(pInput->z.z*fScale)

Parameters

pInput	Pointer to Matrix to multiply
fScale	Scalar to multiply all entries by

See also: Multiply(float)

◆ Multiply() [3/6]

void BURGER_API Burger::Matrix3D_t::Multiply	(	const Matrix3D_t *	pInput,
		float	fScaleX,
		float	fScaleY,
		float	fScaleZ )

noexcept

Multiply by an X,Y and Z scale into a copy.

Using only the x.x, y.y, and z.z components of a simulated matrix, perform a matrix multiply quickly that would yield a multiplication vs a scale matrix and store the result in this Matrix3D_t

Use this formula to create the final matrix

	x	y	z
x	(pInput->x.x*fScaleX)	(pInput->x.y*fScaleX)	(pInput->x.z*fScaleX)
y	(pInput->y.x*fScaleY)	(pInput->y.y*fScaleY)	(pInput->y.z*fScaleY)
z	(pInput->z.x*fScaleZ)	(pInput->z.y*fScaleZ)	(pInput->z.z*fScaleZ)

Parameters

pInput	Pointer to a valid Matrix3D_t to apply the scale to
fScaleX	X scale value
fScaleY	Y scale value
fScaleZ	Z scale value

See also: Multiply(float,float,float), TransposeMultiply(const Matrix3D_t*,float,float,float) or SetScale(float,float,float)

◆ Multiply() [4/6]

void BURGER_API Burger::Matrix3D_t::Multiply	(	const Matrix3D_t *	pInput1,
		const Matrix3D_t *	pInput2 )

noexcept

Perform a matrix multiply.

Multiply two matrices together and store the result in this matrix.

Use this formula to create the final matrix

	x	y	z
x	(xx1xx2)+(yx1xy2)+(zx1*xz2)	(xy1xx2)+(yy1xy2)+(zy1*xz2)	(xz1xx2)+(yz1xy2)+(zz1*xz2)
y	(xx1yx2)+(yx1yy2)+(zx1*yz2)	(xy1yx2)+(yy1yy2)+(zy1*yz2)	(xz1yx2)+(yz1yy2)+(zz1*yz2)
z	(xx1zx2)+(yx1zy2)+(zx1*zz2)	(xy1zx2)+(yy1zy2)+(zy1*zz2)	(xz1zx2)+(yz1zy2)+(zz1*zz2)

Note: This function is optimized to reduce variable usage by storing into the output without buffering. Do not use the output matrix as an input matrix.

Parameters

pInput1	Matrix to multiply from
pInput2	Matrix to multiply against

See also: Multiply(const Matrix3D_t *)

◆ Multiply() [5/6]

void BURGER_API Burger::Matrix3D_t::Multiply ( float fScale )

Multiply all entries by a scalar.

Multiply all values in the matrix by a scalar constant

Use this formula to create the final matrix

	x	y	z
x	(x.x*fScale)	(x.y*fScale)	(x.z*fScale)
y	(y.x*fScale)	(y.y*fScale)	(y.z*fScale)
z	(z.x*fScale)	(z.y*fScale)	(z.z*fScale)

Parameters

fScale Scalar to multiply all entries by

See also: Multiply(const Matrix3D_t *,float)

◆ Multiply() [6/6]

void BURGER_API Burger::Matrix3D_t::Multiply	(	float	fScaleX,
		float	fScaleY,
		float	fScaleZ )

Multiply by an X,Y and Z scale.

Using only the x.x, y.y, and z.z components of a simulated matrix, perform a matrix multiply quickly that would yield a multiplication vs a scale matrix

Use this formula to create the final matrix

	x	y	z
x	(x.x*fScaleX)	(x.y*fScaleX)	(x.z*fScaleX)
y	(y.x*fScaleY)	(y.y*fScaleY)	(y.z*fScaleY)
z	(z.x*fScaleZ)	(z.y*fScaleZ)	(z.z*fScaleZ)

Parameters

fScaleX	X scale value
fScaleY	Y scale value
fScaleZ	Z scale value

See also: Multiply(const Matrix3D_t *,float,float,float), TransposeMultiply(float,float,float) or SetScale(float,float,float)

◆ operator const float *()

Burger::Matrix3D_t::operator const float * ( ) const

inline

Convert to a const float pointer.

This convenience operator converts the Matrix3D_t into a float pointer to pass to other APIs that treat this as an array of 32 bit floats.

Returns: The pointer to the object typecast as a (const float *)

◆ Pitch()

void BURGER_API Burger::Matrix3D_t::Pitch ( float fPitch )

Rotate a matrix in the X axis (Pitch)

Given a X angle in radians, rotate the matrix accordingly

fCos = get_cosine(fPitch); fSin = get_sine(fPitch);

	x	y	z
x	x.x	x.y	x.z
y	(z.xfSin)+(y.xfCos)	(z.yfSin)+(y.yfCos)	(z.zfSin)+(y.zfCos)
z	(z.xfCos)-(y.xfSin)	(z.yfCos)-(y.yfSin)	(z.zfCos)-(y.zfSin)

Parameters

fPitch Angle in radians to pitch the matrix

See also: Yaw(float) or Roll(float)

◆ Roll()

void BURGER_API Burger::Matrix3D_t::Roll ( float fRoll )

Rotate a matrix in the Z axis (Roll)

Given a Z angle in radians, rotate the matrix accordingly

fCos = get_cosine(fRoll); fSin = get_sine(fRoll);

	x	y	z
x	(y.xfSin)+(x.xfCos)	(y.yfSin)+(x.yfCos)	(y.zfSin)+(x.zfCos)
y	(y.xfCos)-(x.xfSin)	(y.yfCos)-(x.yfSin)	(y.zfCos)-(x.zfSin)
z	z.x	z.y	z.z

Parameters

fRoll Angle in radians to roll the matrix

See also: Yaw(float) or Pitch(float)

◆ Set() [1/3]

void BURGER_API Burger::Matrix3D_t::Set ( const FixedMatrix3D_t * pInput )

Convert a fixed point matrix into a floating point matrix.

Using fixed_to_float(float *,Fixed32), convert all of the entries from a 3x3 16.16 fixed point matrix into a floating point matrix

Parameters

pInput Pointer to a valid FixedMatrix3D_t for conversion

See also: fixed_to_float(float *,Fixed32)

◆ Set() [2/3]

void BURGER_API Burger::Matrix3D_t::Set ( const Matrix3D_t * pInput )

Copy the matrix.

Copy a matrix into this one

Parameters

pInput Pointer to a valid Matrix3D_t for copying

See also: Identity() or Zero()

◆ Set() [3/3]

void BURGER_API Burger::Matrix3D_t::Set ( const Matrix4D_t * pInput )

Copy a Matrix4D_t to a Matrix3D_t.

Copy a 4x4 matrix into this one by truncating all of the w components

	x	y	z
x	pInput->x.x	pInput->x.y	pInput->x.z
y	pInput->y.x	pInput->y.y	pInput->y.z
z	pInput->z.x	pInput->z.y	pInput->z.z

Parameters

pInput Pointer to a valid Matrix4D_t for copying

See also: Set(const Matrix3D_t *) or Matrix4D_t::Set(const Matrix3D_t *)

◆ SetFromQuaternion()

void BURGER_API Burger::Matrix3D_t::SetFromQuaternion ( const Vector4D_t * pInput )

Convert a quaternion to a 3x3 matrix.

Here's the resulting matrix of math used using terms from the input quaternion

	x	y	z
x	1-(2yy+2zz)	2xy+2wz	2xz-2wy
y	2xy-2wz	1-(2xx+2zz)	2yz+2wx
z	2xz+2wy	2yz-2wx	1-(2xx+2yy)

Parameters

pInput Pointer to a normalized quaternion

See also: Matrix4D_t::SetFromQuaternion(const Vector4D_t *pInput) or TransposeSetFromQuaternion(const Vector4D_t *pInput)

◆ SetPitch()

void BURGER_API Burger::Matrix3D_t::SetPitch ( float fPitch )

Initialize a rotation matrix with radians for pitch (X)

float sx = get_sine(fPitch);

float cx = get_cosine(fPitch);

Burger::get_cosine

float get_cosine(float fInput) noexcept

Return the cosine from radians.

Definition brsinecosine.cpp:1203

Burger::get_sine

float get_sine(float fInput) noexcept

Return the sine from radians.

Definition brsinecosine.cpp:969

Burger::conditional

Select a type based if the conditional is true or false.

Definition burger.h:3178

	x	y	z
x	1	0	0
y	0	cx	-sx
z	0	sx	cx

Parameters

fPitch Pitch of the X in radians

See also: TransposeSetPitch(float), Set(float,float,float), SetYaw(float) and SetRoll(float)

◆ SetRoll()

void BURGER_API Burger::Matrix3D_t::SetRoll ( float fRoll )

Initialize a rotation matrix with radians for roll (Z)

float sz = get_sine(fRoll);

float cz = get_cosine(fRoll);

	x	y	z
x	cz	-sz	0
y	sz	cz	0
z	0	0	1

Parameters

fRoll Roll of the Z in radians

See also: TransposeSetRoll(float), Set(float,float,float), SetYaw(float) and SetPitch(float)

◆ SetScale()

void BURGER_API Burger::Matrix3D_t::SetScale	(	float	fX,
		float	fY,
		float	fZ )

noexcept

Create a 3D scale matrix.

Sets the x.x, y.y and z.z components to the input values and all others are set to 0.0f

	x	y	z
x	fX	0	0
y	0	fY	0
z	0	0	fZ

Parameters

fX	new x.x component
fY	new y.y component
fZ	new z.z component

See also: Identity(void) and Multiply(float,float,float)

◆ SetTranslate()

void BURGER_API Burger::Matrix3D_t::SetTranslate	(	float	fX,
		float	fY )

Create a 2D Translation matrix.

Create an identity matrix and set the z.x and z.y terms to the input to create a translation matrix for 2d points

	x	y	z
x	1	0	0
y	0	1	0
z	fX	fY	1

Parameters

fX	New z.x term
fY	New z.y term

◆ SetXColumn() [1/2]

void Burger::Matrix3D_t::SetXColumn ( const Vector3D_t * pInput )

inline

Set the X column of a matrix.

Overwrite the X column of the matrix with the input vector

	x	y	z
x	pInput->x	x.y	x.z
y	pInput->y	y.y	y.z
z	pInput->z	z.y	z.z

Parameters

pInput Pointer to a Vector3D_t structure that has the new X column

See also: SetXColumn(float,float,float)

◆ SetXColumn() [2/2]

void Burger::Matrix3D_t::SetXColumn	(	float	fX,
		float	fY,
		float	fZ )

inline

Set the X column of a matrix.

Overwrite the X column of the matrix with the input values

	x	y	z
x	fX	x.y	x.z
y	fY	y.y	y.z
z	fZ	z.y	z.z

Parameters

fX	New x.x value
fY	New y.x value
fZ	New z.x value

See also: SetXColumn(const Vector3D_t *)

◆ SetXRow() [1/2]

void Burger::Matrix3D_t::SetXRow ( const Vector3D_t * pInput )

inline

Set the X row of a matrix.

Overwrite the X row of the matrix with the input vector

	x	y	z
x	pInput->x	pInput->y	pInput->z
y	y.x	y.y	y.z
z	z.x	z.y	z.z

Parameters

pInput Pointer to a Vector3D_t structure that has the new X row

See also: SetXRow(float,float,float)

◆ SetXRow() [2/2]

void Burger::Matrix3D_t::SetXRow	(	float	fX,
		float	fY,
		float	fZ )

inline

Set the X row of a matrix.

Overwrite the X row of the matrix with the input values

	x	y	z
x	fX	fY	fZ
y	y.x	y.y	y.z
z	z.x	z.y	z.z

Parameters

fX	New x.x value
fY	New x.y value
fZ	New x.z value

See also: SetXRow(const Vector3D_t *)

◆ SetXYZ()

void BURGER_API Burger::Matrix3D_t::SetXYZ	(	float	fYaw,
		float	fPitch,
		float	fRoll )

Initialize a rotation matrix in the order of X, Y and Z.

Initialize a rotation matrix with radians for Yaw (Y), Pitch (X), and Roll (Z) in the order of X, Y and then Z.

float sx = get_sine(fPitch);
float sy = get_sine(fYaw);
float sz = get_sine(fRoll);
float cx = get_cosine(fPitch);
float cy = get_cosine(fYaw);
float cz = get_cosine(fRoll);

	x	y	z
x	cy*cz	(-sysxcz)+(cx*-sz)	(-sycxcz)+(-sx*-sz)
y	cy*sz	(cxcz)+(-sysx*sz)	(-sxcx)+(cysx*-sz)
z	sy	cy*sx	cy*cx

Parameters

fYaw	Yaw of the Y in radians
fPitch	Pitch of the X in radians
fRoll	Roll of the Z in radians

See also: TransposeSetXYZ(float,float,float), SetYaw(float), SetPitch(float), and SetRoll(float)

◆ SetXZY()

void BURGER_API Burger::Matrix3D_t::SetXZY	(	float	fYaw,
		float	fPitch,
		float	fRoll )

Initialize a rotation matrix in the order of X, Z and Y.

Initialize a rotation matrix with radians for Yaw (Y), Pitch (X), and Roll (Z) in the order of X, Z and then Y.

float sx = get_sine(fPitch);
float sy = get_sine(fYaw);
float sz = get_sine(fRoll);
float cx = get_cosine(fPitch);
float cy = get_cosine(fYaw);
float cz = get_cosine(fRoll);

	x	y	z
x	cy*cz	(cx-szcy)+(-sy*sx)	(-sx-szcy)+(-sy*cx)
y	sz	cx*cz	-sx*cz
z	sy*cz	(sxcy)+(sycx*-sz)	(cxcy)+(sy-sx*-sz)

Parameters

fYaw	Yaw of the Y in radians
fPitch	Pitch of the X in radians
fRoll	Roll of the Z in radians

See also: TransposeSetXZY(float,float,float), SetYaw(float), SetPitch(float), and SetRoll(float)

◆ SetYaw()

void BURGER_API Burger::Matrix3D_t::SetYaw ( float fYaw )

Initialize a rotation matrix with radians for yaw (Y)

float sy = get_sine(fYaw);

float cy = get_cosine(fYaw);

	x	y	z
x	cy	0	-sy
y	0	1	0
z	sy	0	cy

Parameters

fYaw	Yaw of the Y in radians

See also: TransposeSetYaw(float), Set(float,float,float), SetPitch(float) and SetRoll(float)

◆ SetYColumn() [1/2]

void Burger::Matrix3D_t::SetYColumn ( const Vector3D_t * pInput )

inline

Set the Y column of a matrix.

Overwrite the Y column of the matrix with the input vector

	x	y	z
x	x.x	pInput->x	x.z
y	y.x	pInput->y	y.z
z	z.x	pInput->z	z.z

Parameters

pInput Pointer to a Vector3D_t structure that has the new Y column

See also: SetYColumn(float,float,float)

◆ SetYColumn() [2/2]

void Burger::Matrix3D_t::SetYColumn	(	float	fX,
		float	fY,
		float	fZ )

inline

Set the Y column of a matrix.

Overwrite the Y column of the matrix with the input values

	x	y	z
x	x.x	fX	x.z
y	y.x	fY	y.z
z	z.x	fZ	z.z

Parameters

fX	New x.y value
fY	New y.y value
fZ	New z.y value

See also: SetYColumn(const Vector3D_t *)

◆ SetYRow() [1/2]

void Burger::Matrix3D_t::SetYRow ( const Vector3D_t * pInput )

inline

Set the Y row of a matrix.

Overwrite the Y row of the matrix with the input vector

	x	y	z
x	x.x	x.y	x.z
y	pInput->x	pInput->y	pInput->z
z	z.x	z.y	z.z

Parameters

pInput Pointer to a Vector3D_t structure that has the new Y row

See also: SetYRow(float,float,float)

◆ SetYRow() [2/2]

void Burger::Matrix3D_t::SetYRow	(	float	fX,
		float	fY,
		float	fZ )

inline

Set the Y row of a matrix.

Overwrite the Y row of the matrix with the input values

	x	y	z
x	x.x	x.y	x.z
y	fX	fY	fZ
z	z.x	z.y	z.z

Parameters

fX	New y.x value
fY	New y.y value
fZ	New y.z value

See also: SetYRow(const Vector3D_t *)

◆ SetYXZ()

void BURGER_API Burger::Matrix3D_t::SetYXZ	(	float	fYaw,
		float	fPitch,
		float	fRoll )

Initialize a rotation matrix in the order of Y, X and Z.

Initialize a rotation matrix with radians for Yaw (Y), Pitch (X), and Roll (Z) in the order of Y, X and then Z.

float sx = get_sine(fPitch);
float sy = get_sine(fYaw);
float sz = get_sine(fRoll);
float cx = get_cosine(fPitch);
float cy = get_cosine(fYaw);
float cz = get_cosine(fRoll);

	x	y	z
x	(cycz)+(sy-sx*-sz)	cx*-sz	(-sycz)+(cy-sx*-sz)
y	(sy-sxcz)+(cy*sz)	cx*cz	(cy-sxcz)+(-sy*sz)
z	sy*cx	sx	cy*cx

Parameters

fYaw	Yaw of the Y in radians
fPitch	Pitch of the X in radians
fRoll	Roll of the Z in radians

See also: TransposeSetYXZ(float,float,float), SetYaw(float), SetPitch(float), and SetRoll(float)

◆ SetYZX()

void BURGER_API Burger::Matrix3D_t::SetYZX	(	float	fYaw,
		float	fPitch,
		float	fRoll )

Initialize a rotation matrix in the order of Y, Z and X.

Initialize a rotation matrix with radians for Yaw (Y), Pitch (X), and Roll (Z) in the order of Y, Z and then X.

float sx = get_sine(fPitch);
float sy = get_sine(fYaw);
float sz = get_sine(fRoll);
float cx = get_cosine(fPitch);
float cy = get_cosine(fYaw);
float cz = get_cosine(fRoll);

	x	y	z
x	cy*cz	-sz	-sy*cz
y	(cyszcx)+(sy*-sx)	cx*cz	(-syszcx)+(cy*-sx)
z	(sycx)+(cysx*sz)	sx*cz	(cycx)+(-sysx*sz)

Parameters

fYaw	Yaw of the Y in radians
fPitch	Pitch of the X in radians
fRoll	Roll of the Z in radians

See also: TransposeSetYZX(float,float,float), SetYaw(float), SetPitch(float), and SetRoll(float)

◆ SetZColumn() [1/2]

void Burger::Matrix3D_t::SetZColumn ( const Vector3D_t * pInput )

inline

Set the Z column of a matrix.

Overwrite the Z column of the matrix with the input vector

	x	y	z
x	x.x	x.y	pInput->x
y	y.x	y.y	pInput->y
z	z.x	z.y	pInput->z

Parameters

pInput Pointer to a Vector3D_t structure that has the new Z column

See also: SetZColumn(float,float,float)

◆ SetZColumn() [2/2]

void Burger::Matrix3D_t::SetZColumn	(	float	fX,
		float	fY,
		float	fZ )

inline

Set the Z column of a matrix.

Overwrite the Z column of the matrix with the input values

	x	y	z
x	x.x	x.y	fX
y	y.x	y.y	fY
z	z.x	z.y	fZ

Parameters

fX	New x.z value
fY	New y.z value
fZ	New z.z value

See also: SetZColumn(const Vector3D_t *)

◆ SetZRow() [1/2]

void Burger::Matrix3D_t::SetZRow ( const Vector3D_t * pInput )

inline

Set the Z row of a matrix.

Overwrite the Z row of the matrix with the input vector

	x	y	z
x	x.x	x.y	x.z
y	y.x	y.y	y.z
z	pInput->x	pInput->y	pInput->z

Parameters

pInput Pointer to a Vector3D_t structure that has the new Z row

See also: SetZRow(float,float,float)

◆ SetZRow() [2/2]

void Burger::Matrix3D_t::SetZRow	(	float	fX,
		float	fY,
		float	fZ )

inline

Set the Z row of a matrix.

Overwrite the Z row of the matrix with the input values

	x	y	z
x	x.x	x.y	x.z
y	y.x	y.y	y.z
z	fX	fY	fZ

Parameters

fX	New z.x value
fY	New z.y value
fZ	New z.z value

See also: SetZRow(const Vector3D_t *)

◆ SetZXY()

void BURGER_API Burger::Matrix3D_t::SetZXY	(	float	fYaw,
		float	fPitch,
		float	fRoll )

Initialize a rotation matrix in the order of Z, X and Y.

Initialize a rotation matrix with radians for Yaw (Y), Pitch (X), and Roll (Z) in the order of Z, X and then Y.

float sx = get_sine(fPitch);
float sy = get_sine(fYaw);
float sz = get_sine(fRoll);
float cx = get_cosine(fPitch);
float cy = get_cosine(fYaw);
float cz = get_cosine(fRoll);

	x	y	z
x	(czcy)+(-sysx*sz)	(-szcy)+(-sysx*cz)	-sy*cx
y	cx*sz	cx*cz	-sx
z	(sxszcy)+(sy*cz)	(sxczcy)+(sy*-sz)	cy*cx

Parameters

fYaw	Yaw of the Y in radians
fPitch	Pitch of the X in radians
fRoll	Roll of the Z in radians

See also: TransposeSetZXY(float,float,float), SetYaw(float), SetPitch(float), and SetRoll(float)

◆ SetZYX()

void BURGER_API Burger::Matrix3D_t::SetZYX	(	float	fYaw,
		float	fPitch,
		float	fRoll )

Initialize a rotation matrix in the order of Z, Y and X.

Initialize a rotation matrix with radians for Yaw (Y), Pitch (X), and Roll (Z) in the order of Z, Y and then X.

float sx = get_sine(fPitch);
float sy = get_sine(fYaw);
float sz = get_sine(fRoll);
float cx = get_cosine(fPitch);
float cy = get_cosine(fYaw);
float cz = get_cosine(fRoll);

	x	y	z
x	cy*cz	cy*-sz	-sy
y	(szcx)+(sy-sx*cz)	(czcx)+(sy-sx*-sz)	cy*-sx
z	(syczcx)+(sx*sz)	(sy-szcx)+(sx*cz)	cy*cx

Parameters

fYaw	Yaw of the Y in radians
fPitch	Pitch of the X in radians
fRoll	Roll of the Z in radians

See also: TransposeSetZYX(float,float,float), SetYaw(float), SetPitch(float), and SetRoll(float)

◆ Transform() [1/2]

void BURGER_API Burger::Matrix3D_t::Transform ( Vector3D_t * pInput ) const

Multiply a vector by a matrix.

Transform the point by the matrix

x	(xxx)+(xyy)+(xz*z)
y	(yxx)+(yyy)+(yz*z)
z	(zxx)+(zyy)+(zz*z)

Parameters

pInput Pointer to a Vector3D_t to transform against this matrix

See also: Transform(Vector3D_t *,const Vector3D_t *) const or TransposeTransform(Vector3D_t *) const

◆ Transform() [2/2]

void BURGER_API Burger::Matrix3D_t::Transform	(	Vector3D_t *	pOutput,
		const Vector3D_t *	pInput ) const

Multiply a vector by a matrix.

Transform the point by the matrix and store the result in an uninitialized Vector3D_t

x	(xxx)+(xyy)+(xz*z)
y	(yxx)+(yyy)+(yz*z)
z	(zxx)+(zyy)+(zz*z)

Parameters

pInput	Pointer to a Vector3D_t to transform against this matrix
pOutput	Pointer to an uninitialized Vector3D_t to store the result

See also: Transform(Vector3D_t *) const or TransposeTransform(Vector3D_t *,const Vector3D_t *) const

◆ TransformAdd() [1/2]

void BURGER_API Burger::Matrix3D_t::TransformAdd	(	Vector3D_t *	pInput,
		const Vector3D_t *	pTranslate ) const

Transform a vector and then add a point.

Transform the point by the matrix and then add a translation vector

x	(xxx)+(xyy)+(xz*z)+tx
y	(yxx)+(yyy)+(yz*z)+ty
z	(zxx)+(zyy)+(zz*z)+tz

Parameters

pInput	Pointer to a Vector3D_t to transform against this matrix
pTranslate	Pointer to a Vector3D_t to add against the translated input

See also: TransformAdd(Vector3D_t *,const Vector3D_t *,const Vector3D_t *) const or TransposeTransformAdd(Vector3D_t *,const Vector3D_t *) const

◆ TransformAdd() [2/2]

void BURGER_API Burger::Matrix3D_t::TransformAdd	(	Vector3D_t *	pOutput,
		const Vector3D_t *	pInput,
		const Vector3D_t *	pTranslate ) const

Transform a vector and then add a point.

Transform the point by the matrix and store the result in an uninitialized Vector3D_t

x	(xxx)+(xyy)+(xz*z)+tx
y	(yxx)+(yyy)+(yz*z)+ty
z	(zxx)+(zyy)+(zz*z)+tz

Parameters

pInput	Pointer to a Vector3D_t to transform against this matrix
pOutput	Pointer to an uninitialized Vector3D_t to store the result
pTranslate	Pointer to a Vector3D_t to add against the translated input

See also: TransformAdd(Vector3D_t *,const Vector3D_t *) const or TransposeTransformAdd(Vector3D_t *,const Vector3D_t *,const Vector3D_t *) const

◆ Transpose() [1/2]

void BURGER_API Burger::Matrix3D_t::Transpose ( const Matrix3D_t * pInput )

Perform a matrix transposition.

Swap the entries x.y and y.x, x.z and z.x, y,z and z.y to convert a right handed matrix to a left handed one and vice versa. The other three entries are copied. The destination matrix is assumed to be uninitialized.

	x	y	z
x	xx	yx	zx
y	xy	yy	zy
z	xz	yz	zz

Note: This function is optimized to write the new matrix in sequential order in the event this function is writing to write combined memory.

See also: Transpose(void)

◆ Transpose() [2/2]

void BURGER_API Burger::Matrix3D_t::Transpose ( void )

Perform a matrix transposition.

Swap the entries x.y and y.x, x.z and z.x, y,z and z.y to convert a right handed matrix to a left handed one and vice versa. The matrix is assumed to be already initialized.

	x	y	z
x	xx	yx	zx
y	xy	yy	zy
z	xz	yz	zz

See also: Transpose(const Matrix3D_t *)

◆ TransposeMultiply() [1/2]

void BURGER_API Burger::Matrix3D_t::TransposeMultiply	(	const Matrix3D_t *	pInput,
		float	fScaleX,
		float	fScaleY,
		float	fScaleZ )

noexcept

Multiply by an X,Y and Z scale into a copy.

Using only the x.x, y.y, and z.z components of a simulated matrix, perform a transposed matrix multiply quickly that would yield a multiplication vs a scale matrix and store the result in this Matrix3D_t

Use this formula to create the final matrix

	x	y	z
x	(pInput->x.x*fScaleX)	(pInput->x.y*fScaleY)	(pInput->x.z*fScaleZ)
y	(pInput->y.x*fScaleX)	(pInput->y.y*fScaleY)	(pInput->y.z*fScaleZ)
z	(pInput->z.x*fScaleX)	(pInput->z.y*fScaleY)	(pInput->z.z*fScaleZ)

Parameters

pInput	Pointer to a valid Matrix3D_t to apply the scale to
fScaleX	X scale value
fScaleY	Y scale value
fScaleZ	Z scale value

See also: TransposeMultiply(const Matrix3D_t *,float,float,float), Multiply(const Matrix3D_t *,float,float,float) or SetScale(float,float,float)

◆ TransposeMultiply() [2/2]

void BURGER_API Burger::Matrix3D_t::TransposeMultiply	(	float	fScaleX,
		float	fScaleY,
		float	fScaleZ )

Multiply by an X,Y and Z scale.

Using only the x.x, y.y, and z.z components of a simulated matrix, perform a transposed matrix multiply quickly that would yield a multiplication vs a scale matrix

Use this formula to create the final matrix

	x	y	z
x	(x.x*fScaleX)	(x.y*fScaleY)	(x.z*fScaleZ)
y	(y.x*fScaleX)	(y.y*fScaleY)	(y.z*fScaleZ)
z	(z.x*fScaleX)	(z.y*fScaleY)	(z.z*fScaleZ)

Parameters

fScaleX	X scale value
fScaleY	Y scale value
fScaleZ	Z scale value

See also: TransposeMultiply(const Matrix3D_t *,float,float,float), Multiply(float,float,float) or SetScale(float,float,float)

◆ TransposeSetFromQuaternion()

void BURGER_API Burger::Matrix3D_t::TransposeSetFromQuaternion ( const Vector4D_t * pInput )

Convert a quaternion to a transposed 3x3 matrix.

Here's the resulting matrix of math used using terms from the input quaternion

	x	y	z
x	1-(2yy+2zz)	2xy-2wz	2xz+2wy
y	2xy+2wz	1-(2xx+2zz)	2yz-2wx
z	2xz-2wy	2yz+2wx	1-(2xx+2yy)

Parameters

pInput Pointer to a normalized quaternion

See also: Matrix4D_t::TransposeSetFromQuaternion(const Vector4D_t *pInput) or SetFromQuaternion(const Vector4D_t *pInput)

◆ TransposeSetPitch()

void BURGER_API Burger::Matrix3D_t::TransposeSetPitch ( float fPitch )

Initialize a rotation matrix with radians for pitch (X)

float sx = get_sine(fPitch);

float cx = get_cosine(fPitch);

	x	y	z
x	1	0	0
y	0	cx	sx
z	0	-sx	cx

Parameters

fPitch Pitch of the X in radians

See also: SetPitch(float), TransposeSet(float,float,float), TransposeSetYaw(float) and TransposeSetRoll(float)

◆ TransposeSetRoll()

void BURGER_API Burger::Matrix3D_t::TransposeSetRoll ( float fRoll )

Initialize a rotation matrix with radians for roll (Z)

float sz = get_sine(fRoll);

float cz = get_cosine(fRoll);

	x	y	z
x	cz	sz	0
y	-sz	cz	0
z	0	0	1

Parameters

fRoll Roll of the Z in radians

See also: SetRoll(float), TransposeSet(float,float,float), TransposeSetYaw(float) and TransposeSetPitch(float)

◆ TransposeSetXYZ()

void BURGER_API Burger::Matrix3D_t::TransposeSetXYZ	(	float	fYaw,
		float	fPitch,
		float	fRoll )

Initialize a transposed rotation matrix in the order of X, Y and Z.

Initialize a transposed rotation matrix with radians for Yaw (Y), Pitch (X), and Roll (Z) in the order of X, Y and then Z.

float sx = get_sine(fPitch);
float sy = get_sine(fYaw);
float sz = get_sine(fRoll);
float cx = get_cosine(fPitch);
float cy = get_cosine(fYaw);
float cz = get_cosine(fRoll);

	x	y	z
x	cy*cz	(sy-sxcz)+(cx*sz)	(sycxcz)+(sx*sz)
y	cy*-sz	(cxcz)+(sy-sx*-sz)	(sxcz)+(sycx*-sz)
z	-sy	cy*-sx	cy*cx

Parameters

fYaw	Yaw of the Y in radians
fPitch	Pitch of the X in radians
fRoll	Roll of the Z in radians

See also: SetXYZ(float,float,float), TransposeSetYaw(float), TransposeSetPitch(float), and TransposeSetRoll(float)

◆ TransposeSetXZY()

void BURGER_API Burger::Matrix3D_t::TransposeSetXZY	(	float	fYaw,
		float	fPitch,
		float	fRoll )

Initialize a transposed rotation matrix in the order of X, Z and Y.

Initialize a transposed rotation matrix with radians for Yaw (Y), Pitch (X), and Roll (Z) in the order of X, Z and then Y.

float sx = get_sine(fPitch);
float sy = get_sine(fYaw);
float sz = get_sine(fRoll);
float cx = get_cosine(fPitch);
float cy = get_cosine(fYaw);
float cz = get_cosine(fRoll);

	x	y	z
x	cy*cz	(cxszcy)+(sy*-sx)	(sxszcy)+(sy*cx)
y	-sz	cx*cz	sx*cz
z	-sy*cz	(-sxcy)+(-sycx*sz)	(cxcy)+(-sysx*sz)

Parameters

fYaw	Yaw of the Y in radians
fPitch	Pitch of the X in radians
fRoll	Roll of the Z in radians

See also: SetXZY(float,float,float), TransposeSetYaw(float), TransposeSetPitch(float), and TransposeSetRoll(float)

◆ TransposeSetYaw()

void BURGER_API Burger::Matrix3D_t::TransposeSetYaw ( float fYaw )

Initialize a rotation matrix with radians for yaw (Y)

float sy = get_sine(fYaw);

float cy = get_cosine(fYaw);

	x	y	z
x	cy	0	sy
y	0	1	0
z	-sy	0	cy

Parameters

fYaw	Yaw of the Y in radians

See also: SetYaw(float), TransposeSet(float,float,float), TransposeSetPitch(float) and TransposeSetRoll(float)

◆ TransposeSetYXZ()

void BURGER_API Burger::Matrix3D_t::TransposeSetYXZ	(	float	fYaw,
		float	fPitch,
		float	fRoll )

Initialize a transposed rotation matrix in the order of Y, X and Z.

Initialize a transposed rotation matrix with radians for Yaw (Y), Pitch (X), and Roll (Z) in the order of Y, X and then Z.

float sx = get_sine(fPitch);
float sy = get_sine(fYaw);
float sz = get_sine(fRoll);
float cx = get_cosine(fPitch);
float cy = get_cosine(fYaw);
float cz = get_cosine(fRoll);

	x	y	z
x	(cycz)+(-sysx*sz)	cx*sz	(sycz)+(cysx*sz)
y	(-sysxcz)+(cy*-sz)	cx*cz	(cysxcz)+(sy*-sz)
z	-sy*cx	-sx	cy*cx

Parameters

fYaw	Yaw of the Y in radians
fPitch	Pitch of the X in radians
fRoll	Roll of the Z in radians

See also: SetYXZ(float,float,float), TransposeSetYaw(float), TransposeSetPitch(float), and TransposeSetRoll(float)

◆ TransposeSetYZX()

void BURGER_API Burger::Matrix3D_t::TransposeSetYZX	(	float	fYaw,
		float	fPitch,
		float	fRoll )

Initialize a transposed rotation matrix in the order of Y, Z and X.

Initialize a transposed rotation matrix with radians for Yaw (Y), Pitch (X), and Roll (Z) in the order of Y, Z and then X.

float sx = get_sine(fPitch);
float sy = get_sine(fYaw);
float sz = get_sine(fRoll);
float cx = get_cosine(fPitch);
float cy = get_cosine(fYaw);
float cz = get_cosine(fRoll);

	x	y	z
x	cy*cz	sz	sy*cz
y	(cy-szcx)+(-sy*sx)	cx*cz	(sy-szcx)+(cy*sx)
z	(-sycx)+(cy-sx*-sz)	-sx*cz	(cycx)+(sy-sx*-sz)

Parameters

fYaw	Yaw of the Y in radians
fPitch	Pitch of the X in radians
fRoll	Roll of the Z in radians

See also: SetYZX(float,float,float), TransposeSetYaw(float), TransposeSetPitch(float), and TransposeSetRoll(float)

◆ TransposeSetZXY()

void BURGER_API Burger::Matrix3D_t::TransposeSetZXY	(	float	fYaw,
		float	fPitch,
		float	fRoll )

Initialize a transposed rotation matrix in the order of Z, X and Y.

Initialize a transposed rotation matrix with radians for Yaw (Y), Pitch (X), and Roll (Z) in the order of Z, X and then Y.

float sx = get_sine(fPitch);
float sy = get_sine(fYaw);
float sz = get_sine(fRoll);
float cx = get_cosine(fPitch);
float cy = get_cosine(fYaw);
float cz = get_cosine(fRoll);

	x	y	z
x	(czcy)+(sy-sx*-sz)	(szcy)+(sy-sx*cz)	sy*cx
y	cx*-sz	cx*cz	sx
z	(-sx-szcy)+(-sy*cz)	(-sxczcy)+(-sy*sz)	cy*cx

Parameters

fYaw	Yaw of the Y in radians
fPitch	Pitch of the X in radians
fRoll	Roll of the Z in radians

See also: SetZXY(float,float,float), TransposeSetYaw(float), TransposeSetPitch(float), and TransposeSetRoll(float)

◆ TransposeSetZYX()

void BURGER_API Burger::Matrix3D_t::TransposeSetZYX	(	float	fYaw,
		float	fPitch,
		float	fRoll )

Initialize a transposed rotation matrix in the order of Z, Y and X.

Initialize a transposed rotation matrix with radians for Yaw (Y), Pitch (X), and Roll (Z) in the order of Z, Y and then X.

float sx = get_sine(fPitch);
float sy = get_sine(fYaw);
float sz = get_sine(fRoll);
float cx = get_cosine(fPitch);
float cy = get_cosine(fYaw);
float cz = get_cosine(fRoll);

	x	y	z
x	cy*cz	cy*sz	sy
y	(-szcx)+(-sysx*cz)	(czcx)+(-sysx*sz)	cy*sx
z	(-syczcx)+(-sx*-sz)	(-syszcx)+(-sx*cz)	cy*cx

Parameters

fYaw	Yaw of the Y in radians
fPitch	Pitch of the X in radians
fRoll	Roll of the Z in radians

See also: SetZYX(float,float,float), TransposeSetYaw(float), TransposeSetPitch(float), and TransposeSetRoll(float)

◆ TransposeTransform() [1/2]

void BURGER_API Burger::Matrix3D_t::TransposeTransform ( Vector3D_t * pInput ) const

Multiply a vector by a transposed matrix.

Transform the point by the transposed matrix

x	(xxx)+(yxy)+(zx*z)
y	(xyx)+(yyy)+(zy*z)
z	(xzx)+(yzy)+(zz*z)

Parameters

pInput Pointer to a Vector3D_t to transform against this transposed matrix

See also: TransposeTransform(Vector3D_t *,const Vector3D_t *) const or Transform(Vector3D_t *) const

◆ TransposeTransform() [2/2]

void BURGER_API Burger::Matrix3D_t::TransposeTransform	(	Vector3D_t *	pOutput,
		const Vector3D_t *	pInput ) const

Multiply a vector by a transposed matrix.

Transform the point by the transposed matrix and store the result in an uninitialized Vector3D_t

x	(xxx)+(yxy)+(zx*z)
y	(xyx)+(yyy)+(zy*z)
z	(xzx)+(yzy)+(zz*z)

Parameters

pInput	Pointer to a Vector3D_t to transform against this transposed matrix
pOutput	Pointer to an uninitialized Vector3D_t to store the result

See also: TransposeTransform(Vector3D_t *) const or Transform(Vector3D_t *,const Vector3D_t *) const

◆ TransposeTransformAdd() [1/2]

void BURGER_API Burger::Matrix3D_t::TransposeTransformAdd	(	Vector3D_t *	pInput,
		const Vector3D_t *	pTranslate ) const

Transform a vector and then add a point.

Transform the point by the transposed matrix and then add a translation vector

x	(xxx)+(yxy)+(zx*z)+tx
y	(xyx)+(yyy)+(zy*z)+ty
z	(xzx)+(yzy)+(zz*z)+tz

Parameters

pInput	Pointer to a Vector3D_t to transform against this transposed matrix
pTranslate	Pointer to a Vector3D_t to add against the translated input

See also: TransposeTransformAdd(Vector3D_t *,const Vector3D_t *,const Vector3D_t *) const or TransformAdd(Vector3D_t *,const Vector3D_t *) const

◆ TransposeTransformAdd() [2/2]

void BURGER_API Burger::Matrix3D_t::TransposeTransformAdd	(	Vector3D_t *	pOutput,
		const Vector3D_t *	pInput,
		const Vector3D_t *	pTranslate ) const

Transform a vector and then add a point.

Transform the point by the transposed matrix and store the result in an uninitialized Vector3D_t

x	(xxx)+(yxy)+(zx*z)+tx
y	(xyx)+(yyy)+(zy*z)+ty
z	(xzx)+(yzy)+(zz*z)+tz

Parameters

pInput	Pointer to a Vector3D_t to transform against this transposed matrix
pOutput	Pointer to an uninitialized Vector3D_t to store the result
pTranslate	Pointer to a Vector3D_t to add against the translated input

See also: TransposeTransformAdd(Vector3D_t *,const Vector3D_t *) const or TransformAdd(Vector3D_t *,const Vector3D_t *,const Vector3D_t *) const

◆ Yaw()

void BURGER_API Burger::Matrix3D_t::Yaw ( float fYaw )

Rotate a matrix in the Y axis (Yaw)

Given a Y angle in radians, rotate the matrix accordingly

fCos = get_cosine(fYaw); fSin = get_sine(fYaw);

	x	y	z
x	(z.xfSin)+(x.xfCos)	(z.yfSin)+(x.yfCos)	(z.zfSin)+(x.zfCos)
y	y.x	y.y	y.z
z	(z.xfCos)-(x.xfSin)	(z.yfCos)-(x,yfSin)	(z.zfCos)-(x.zfSin)

Parameters

fYaw	Angle in radians to yaw the matrix

See also: Pitch(float) or Roll(float)

◆ Zero()

void BURGER_API Burger::Matrix3D_t::Zero ( void )

Clear out a 3D matrix.

Set all of the entries to zero

	x	y	z
x	0	0	0
y	0	0	0
z	0	0	0

See also: Identity(void)

Member Data Documentation

◆ x

Vector3D_t Burger::Matrix3D_t::x

32 bit floating point X row for the 3D Matrix

◆ y

Vector3D_t Burger::Matrix3D_t::y

32 bit floating point Y row for the 3D Matrix

◆ z

Vector3D_t Burger::Matrix3D_t::z

32 bit floating point Z row for the 3D Matrix

	x	y	z
x	(xx1xx2)+(yx1xy2)+(zx1*xz2)	(xy1xx2)+(yy1xy2)+(zy1*xz2)	(xz1xx2)+(yz1xy2)+(zz1*xz2)
y	(xx1yx2)+(yx1yy2)+(zx1*yz2)	(xy1yx2)+(yy1yy2)+(zy1*yz2)	(xz1yx2)+(yz1yy2)+(zz1*yz2)
z	(xx1zx2)+(yx1zy2)+(zx1*zz2)	(xy1zx2)+(yy1zy2)+(zy1*zz2)	(xz1zx2)+(yz1zy2)+(zz1*zz2)

	x	y	z
x	(xx1xx2)+(yx1xy2)+(zx1*xz2)	(xy1xx2)+(yy1xy2)+(zy1*xz2)	(xz1xx2)+(yz1xy2)+(zz1*xz2)
y	(xx1yx2)+(yx1yy2)+(zx1*yz2)	(xy1yx2)+(yy1yy2)+(zy1*yz2)	(xz1yx2)+(yz1yy2)+(zz1*yz2)
z	(xx1zx2)+(yx1zy2)+(zx1*zz2)	(xy1zx2)+(yy1zy2)+(zy1*zz2)	(xz1zx2)+(yz1zy2)+(zz1*zz2)

	x	y	z
x	x.x	x.y	x.z
y	(z.xfSin)+(y.xfCos)	(z.yfSin)+(y.yfCos)	(z.zfSin)+(y.zfCos)
z	(z.xfCos)-(y.xfSin)	(z.yfCos)-(y.yfSin)	(z.zfCos)-(y.zfSin)

	x	y	z
x	(y.xfSin)+(x.xfCos)	(y.yfSin)+(x.yfCos)	(y.zfSin)+(x.zfCos)
y	(y.xfCos)-(x.xfSin)	(y.yfCos)-(x.yfSin)	(y.zfCos)-(x.zfSin)
z	z.x	z.y	z.z

Public Member Functions

Public Attributes

Detailed Description

Member Function Documentation

◆ AffineInverse()

◆ GetXColumn()

◆ GetXRow()

◆ GetYColumn()

◆ GetYRow()

◆ GetZColumn()

◆ GetZRow()

◆ Identity()

◆ Multiply() [1/6]

◆ Multiply() [2/6]

◆ Multiply() [3/6]

◆ Multiply() [4/6]

◆ Multiply() [5/6]

◆ Multiply() [6/6]

◆ operator const float *()

◆ Pitch()

◆ Roll()

◆ Set() [1/3]

◆ Set() [2/3]

◆ Set() [3/3]

◆ SetFromQuaternion()

◆ SetPitch()

◆ SetRoll()

◆ SetScale()

◆ SetTranslate()

◆ SetXColumn() [1/2]

◆ SetXColumn() [2/2]

◆ SetXRow() [1/2]

◆ SetXRow() [2/2]

◆ SetXYZ()

◆ SetXZY()

◆ SetYaw()

◆ SetYColumn() [1/2]

◆ SetYColumn() [2/2]

◆ SetYRow() [1/2]

◆ SetYRow() [2/2]

◆ SetYXZ()

◆ SetYZX()

◆ SetZColumn() [1/2]

◆ SetZColumn() [2/2]

◆ SetZRow() [1/2]

◆ SetZRow() [2/2]

◆ SetZXY()

◆ SetZYX()

◆ Transform() [1/2]

◆ Transform() [2/2]

◆ TransformAdd() [1/2]

◆ TransformAdd() [2/2]

◆ Transpose() [1/2]

◆ Transpose() [2/2]

◆ TransposeMultiply() [1/2]

◆ TransposeMultiply() [2/2]

◆ TransposeSetFromQuaternion()

◆ TransposeSetPitch()

◆ TransposeSetRoll()

◆ TransposeSetXYZ()

◆ TransposeSetXZY()

◆ TransposeSetYaw()

◆ TransposeSetYXZ()

◆ TransposeSetYZX()

◆ TransposeSetZXY()

◆ TransposeSetZYX()

◆ TransposeTransform() [1/2]

◆ TransposeTransform() [2/2]

◆ TransposeTransformAdd() [1/2]

◆ TransposeTransformAdd() [2/2]

◆ Yaw()

◆ Zero()

Member Data Documentation

◆ x

◆ y

◆ z