G3D::Matrix4 Class Reference

#include <Matrix4.h>

Public Member Functions
	Matrix4 (const Any &any)
Any	toAny () const
	Matrix4 (float r1c1, float r1c2, float r1c3, float r1c4, float r2c1, float r2c2, float r2c3, float r2c4, float r3c1, float r3c2, float r3c3, float r3c4, float r4c1, float r4c2, float r4c3, float r4c4)
	Matrix4 (const float *init)
	Matrix4 (const class Matrix3 &upper3x3, const class Vector3 &lastCol=Vector3::zero())
	Matrix4 (const class CoordinateFrame &c)
	Matrix4 (const double *init)
	Matrix4 ()
class CoordinateFrame	approxCoordinateFrame () const
void	getPerspectiveProjectionParameters (double &left, double &right, double &bottom, double &top, double &nearval, double &farval, float updirection=-1.0f) const
float *	operator[] (int r)
const float *	operator[] (int r) const
	operator float * ()
	operator const float * () const
Matrix4	operator* (const Matrix4 &other) const
Matrix4	operator+ (const Matrix4 &other) const
class Matrix3	upper3x3 () const
class Matrix2	upper2x2 () const
class Vector3	homoMul (const class Vector3 &v, float w) const
void	setRow (int r, const class Vector4 &v)
void	setColumn (int c, const Vector4 &v)
const Vector4 &	row (int r) const
Vector4	column (int c) const
Matrix4	operator* (const float s) const
Vector4	operator* (const Vector4 &vector) const
Matrix4	transpose () const
bool	operator!= (const Matrix4 &other) const
bool	operator== (const Matrix4 &other) const
float	determinant () const
Matrix4	inverse () const
Matrix4	adjoint () const
Matrix4	cofactor () const
void	serialize (class BinaryOutput &b) const
void	deserialize (class BinaryInput &b)
std::string	toString () const

Static Public Member Functions
static Matrix4	diagonal (float e00, float e11, float e22, float e33)
static const Matrix4 &	identity ()
static const Matrix4 &	zero ()
static Matrix4	orthogonalProjection (float left, float right, float bottom, float top, float nearval, float farval, float upDirection=-1.0f)
static Matrix4	orthogonalProjection (const class Rect2D &rect, float nearval, float farval, float upDirection=-1.0f)
static Matrix4	perspectiveProjection (double left, double right, double bottom, double top, double nearval, double farval, float upDirection=-1.0f)
static Matrix4	scale (const Vector3 &v)
static Matrix4	scale (float x, float y, float z)
static Matrix4	scale (float s)
static Matrix4	translation (const Vector3 &v)
static Matrix4	translation (float x, float y, float z)
static Matrix4	yawDegrees (float deg)
static Matrix4	pitchDegrees (float deg)
static Matrix4	rollDegrees (float deg)

Private Member Functions
float	subDeterminant (int excludeRow, int excludeCol) const
bool	operator< (const Matrix4 &) const
bool	operator> (const Matrix4 &) const
bool	operator<= (const Matrix4 &) const
bool	operator>= (const Matrix4 &) const

Private Attributes
float	elt [4][4]

Detailed Description

A 4x4 matrix. Do not subclass. Data is initialized to 0 when default constructed.

See also

G3D::CoordinateFrame, G3D::Matrix3, G3D::Quat

Constructor & Destructor Documentation

G3D::Matrix4::Matrix4 ( const Any &  any )

explicit

Must be in one of the following forms:

• Matrix4(#, #, # .... #)
• Matrix4::scale(#)
• Matrix4::scale(#, #, #)
• Matrix4::translation(#, #, #)
• Matrix4::identity()
• Matrix4::rollDegrees(#)
• Matrix4::pitchDegrees(#)
• Matrix4::yawDegrees(#)

 {
 any.verifyNameBeginsWith("Matrix4", "CFrame", "CoordinateFrame");
 any.verifyType(Any::ARRAY);

 const std::string& name = any.name();
 if (name == "Matrix4") {
 any.verifySize(16);

 for (int r = 0; r < 4; ++r) {
 for (int c = 0; c < 4; ++c) {
 elt[r][c] = any[r * 4 + c];
 }
 }
 } else if (name == "Matrix4::scale") {
 if (any.size() == 1) {
 *this = scale(any[0].floatValue());
 } else if (any.size() == 3) {
 *this = scale(any[0], any[1], any[2]);
 } else {
 any.verify(false, "Matrix4::scale() takes either 1 or 3 arguments");
 }
 } else if (name == "Matrix4::rollDegrees") {
 any.verifySize(1);
 *this = rollDegrees(any[0].floatValue());
 } else if (name == "Matrix4::yawDegrees") {
 any.verifySize(1);
 *this = yawDegrees(any[0].floatValue());
 } else if (name == "Matrix4::pitchDegrees") {
 any.verifySize(1);
 *this = pitchDegrees(any[0].floatValue());
 } else if (name == "Matrix4::translation") {
 if (any.size() == 3) {
 *this = translation(any[0], any[1], any[2]);
 } else {
 any.verify(false, "Matrix4::translation() requires 3 arguments");
 } 
 } else if (name == "Matrix4::diagonal") {
 any.verifySize(4);
 *this = diagonal(any[0], any[1], any[2], any[3]);
 } else if (name == "Matrix4::identity") {
 *this = identity();
 } else if (beginsWith(name, "CFrame") || beginsWith(name, "CoordinateFrame")) {
 *this = CFrame(any);
 } else {
 any.verify(false, "Expected Matrix4 constructor");
 }
}

Here is the call graph for this function:

G3D::Matrix4::Matrix4	(	float	r1c1,
		float	r1c2,
		float	r1c3,
		float	r1c4,
		float	r2c1,
		float	r2c2,
		float	r2c3,
		float	r2c4,
		float	r3c1,
		float	r3c2,
		float	r3c3,
		float	r3c4,
		float	r4c1,
		float	r4c2,
		float	r4c3,
		float	r4c4
	)

 {
 elt[0][0] = r1c1; elt[0][1] = r1c2; elt[0][2] = r1c3; elt[0][3] = r1c4;
 elt[1][0] = r2c1; elt[1][1] = r2c2; elt[1][2] = r2c3; elt[1][3] = r2c4;
 elt[2][0] = r3c1; elt[2][1] = r3c2; elt[2][2] = r3c3; elt[2][3] = r3c4;
 elt[3][0] = r4c1; elt[3][1] = r4c2; elt[3][2] = r4c3; elt[3][3] = r4c4;
}

G3D::Matrix4::Matrix4

(

const float *

init

)

init should be row major.

 {
 for (int r = 0; r < 4; ++r) {
 for (int c = 0; c < 4; ++c) {
 elt[r][c] = init[r * 4 + c];
 }
 }
}

G3D::Matrix4::Matrix4	(	const class Matrix3 &	upper3x3,
		const class Vector3 &	lastCol = Vector3::zero()
	)

a is the upper left 3x3 submatrix and b is the upper right 3x1 submatrix. The last row of the created matrix is (0,0,0,1).

G3D::Matrix4::Matrix4

(

const class CoordinateFrame &

c

)

 {
 for (int r = 0; r < 3; ++r) {
 for (int c = 0; c < 3; ++c) {
 elt[r][c] = cframe.rotation[r][c];
 }
 elt[r][3] = cframe.translation[r];
 }
 elt[3][0] = 0.0f;
 elt[3][1] = 0.0f;
 elt[3][2] = 0.0f;
 elt[3][3] = 1.0f;
}

G3D::Matrix4::Matrix4

(

const double *

init

)

 {
 for (int r = 0; r < 4; ++r) {
 for (int c = 0; c < 4; ++c) {
 elt[r][c] = (float)init[r * 4 + c];
 }
 }
}

G3D::Matrix4::Matrix4

(

)

Matrix4::zero()

 {
 for (int r = 0; r < 4; ++r) {
 for (int c = 0; c < 4; ++c) {
 elt[r][c] = 0;
 }
 }
}

Here is the caller graph for this function:

Member Function Documentation

Matrix4 G3D::Matrix4::adjoint

(

)

const

Transpose of the cofactor matrix (used in computing the inverse). Note: This is in fact only one type of adjoint. More generally, an adjoint of a matrix is any mapping of a matrix which possesses certain properties. This returns the so-called adjugate or classical adjoint.

 {
 return cofactor().transpose();
}

Here is the call graph for this function:

Here is the caller graph for this function:

CoordinateFrame G3D::Matrix4::approxCoordinateFrame

(

)

const

Produces an RT transformation that nearly matches this Matrix4. Because a Matrix4 may not be precisely a rotation and translation, this may introduce error.

 {
 CoordinateFrame cframe;

 for (int r = 0; r < 3; ++r) {
 for (int c = 0; c < 3; ++c) {
 cframe.rotation[r][c] = elt[r][c];
 }
 cframe.translation[r] = elt[r][3];
 }

 // Ensure that the rotation matrix is orthonormal
 cframe.rotation.orthonormalize();

 return cframe;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Matrix4 G3D::Matrix4::cofactor

(

)

const

 {
 Matrix4 out;

 // We'll use i to incrementally compute -1 ^ (r+c)
 int i = 1;

 for (int r = 0; r < 4; ++r) {
 for (int c = 0; c < 4; ++c) {
 // Compute the determinant of the 3x3 submatrix
 float det = subDeterminant(r, c);
 out.elt[r][c] = i * det;
 i = -i;
 }
 i = -i;
 }

 return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Vector4 G3D::Matrix4::column

(

int

c

)

const

 {
 Vector4 v;
 for (int r = 0; r < 4; ++r) {
 v[r] = elt[r][c];
 }
 return v;
}

Here is the caller graph for this function:

void G3D::Matrix4::deserialize

(

class BinaryInput &

b

)

 {
 for (int r = 0; r < 4; ++r) {
 for (int c = 0; c < 4; ++c) {
 elt[r][c] = b.readFloat32();
 }
 }
}

Here is the call graph for this function:

float G3D::Matrix4::determinant

(

)

const

 {
 // Determinant is the dot product of the first row and the first row
 // of cofactors (i.e. the first col of the adjoint matrix)
 return cofactor().row(0).dot(row(0));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static Matrix4 G3D::Matrix4::diagonal ( float  e00, float  e11, float  e22, float  e33  )

inlinestatic

 {
 return Matrix4(e00, 0, 0, 0,
 0, e11, 0, 0,
 0, 0, e22, 0,
 0, 0, 0, e33);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::Matrix4::getPerspectiveProjectionParameters	(	double &	left,
		double &	right,
		double &	bottom,
		double &	top,
		double &	nearval,
		double &	farval,
		float	updirection = -1.0f
	)		const

If this is a perspective projection matrix created by Matrix4::perspectiveProjection, extract its parameters.

Uses double precision because the operations involved in projection involve divisions that can significantly impact precision.

 {

 debugAssertM(abs(upDirection) == 1.0f, "upDirection must be -1 or +1");

 double x = elt[0][0];
 double y = elt[1][1] * upDirection;
 double a = elt[0][2];
 double b = elt[1][2] * upDirection;
 double c = elt[2][2];
 double d = elt[2][3];

 // Verify that this really is a projection matrix
 debugAssertM(elt[3][2] == -1, "Not a projection matrix");
 debugAssertM(elt[0][1] == 0, "Not a projection matrix");
 debugAssertM(elt[0][3] == 0, "Not a projection matrix");
 debugAssertM(elt[1][3] == 0, "Not a projection matrix");
 debugAssertM(elt[3][3] == 0, "Not a projection matrix");
 debugAssertM(elt[1][0] == 0, "Not a projection matrix");
 debugAssertM(elt[2][0] == 0, "Not a projection matrix");
 debugAssertM(elt[2][1] == 0, "Not a projection matrix");
 debugAssertM(elt[3][0] == 0, "Not a projection matrix");
 debugAssertM(elt[3][1] == 0, "Not a projection matrix");

 if (c == -1) {
 farval = finf();
 nearval = -d / 2.0;
 } else {
 nearval = d * ((c - 1.0) / (c + 1.0) - 1.0) / (-2.0 * (c - 1.0) / (c + 1.0));
 farval = nearval * ((c - 1.0) / (c + 1.0));
 }


 left = (a - 1.0) * nearval / x;
 right = 2.0 * nearval / x + left;

 bottom = (b - 1.0) * nearval / y;
 top = 2.0 * nearval / y + bottom;
}

Here is the call graph for this function:

Vector3 G3D::Matrix4::homoMul	(	const class Vector3 &	v,
		float	w
	)		const

Homogeneous multiplication. Let k = M * [v w]^T. result = k.xyz() / k.w

 {
 Vector4 r = (*this) * Vector4(v, w);
 return r.xyz() * (1.0f / r.w);
}

Here is the call graph for this function:

const Matrix4 & G3D::Matrix4::identity ( )

static

 {
 static Matrix4 m(
 1, 0, 0, 0,
 0, 1, 0, 0,
 0, 0, 1, 0,
 0, 0, 0, 1);
 return m;
}

Here is the caller graph for this function:

Matrix4 G3D::Matrix4::inverse

(

)

const

 {
 // Inverse = adjoint / determinant

 Matrix4 A = adjoint();

 // Determinant is the dot product of the first row and the first row
 // of cofactors (i.e. the first col of the adjoint matrix)
 float det = A.column(0).dot(row(0));

 return A * (1.0f / det);
}

Here is the call graph for this function:

Here is the caller graph for this function:

G3D::Matrix4::operator const float * ( ) const

inline

 {
 return (const float*)&elt[0][0];
 }

G3D::Matrix4::operator float * ( )

inline

Returns a row-major pointer.

 {
 return (float*)&elt[0][0];
 }

bool G3D::Matrix4::operator!=

(

const Matrix4 &

other

)

const

 {
 return ! (*this == other);
}

Matrix4 G3D::Matrix4::operator*

(

const Matrix4 &

other

)

const

 {
 Matrix4 result;
 for (int r = 0; r < 4; ++r) {
 for (int c = 0; c < 4; ++c) {
 for (int i = 0; i < 4; ++i) {
 result.elt[r][c] += elt[r][i] * other.elt[i][c];
 }
 }
 }

 return result;
}

Matrix4 G3D::Matrix4::operator*

(

const float

s

)

const

 {
 Matrix4 result;
 for (int r = 0; r < 4; ++r) {
 for (int c = 0; c < 4; ++c) {
 result.elt[r][c] = elt[r][c] * s;
 }
 }

 return result;
}

Vector4 G3D::Matrix4::operator*

(

const Vector4 &

vector

)

const

 {
 Vector4 result(0,0,0,0);
 for (int r = 0; r < 4; ++r) {
 for (int c = 0; c < 4; ++c) {
 result[r] += elt[r][c] * vector[c];
 }
 }

 return result;
}

Matrix4 G3D::Matrix4::operator+ ( const Matrix4 &  other ) const

inline

 {
 Matrix4 result;
 for (int r = 0; r < 4; ++r) {
 for (int c = 0; c < 4; ++c) {
 result.elt[r][c] = elt[r][c] + other.elt[r][c];
 }
 }
 return result;
 }

bool G3D::Matrix4::operator< ( const Matrix4 &  ) const

private

bool G3D::Matrix4::operator<= ( const Matrix4 &  ) const

private

bool G3D::Matrix4::operator==

(

const Matrix4 &

other

)

const

 {

 // If the bit patterns are identical, they must be
 // the same matrix. If not, they *might* still have
 // equal elements due to floating point weirdness.
 if (memcmp(this, &other, sizeof(Matrix4)) == 0) {
 return true;
 } 

 for (int r = 0; r < 4; ++r) {
 for (int c = 0; c < 4; ++c) {
 if (elt[r][c] != other.elt[r][c]) {
 return false;
 }
 }
 }

 return true;
}

bool G3D::Matrix4::operator> ( const Matrix4 &  ) const

private

bool G3D::Matrix4::operator>= ( const Matrix4 &  ) const

private

float* G3D::Matrix4::operator[] ( int  r )

inline

 {
 debugAssert(r >= 0);
 debugAssert(r < 4);
 return (float*)&elt[r];
 }

const float* G3D::Matrix4::operator[] ( int  r ) const

inline

 {
 debugAssert(r >= 0);
 debugAssert(r < 4);
 return (const float*)&elt[r];
 } 

Matrix4 G3D::Matrix4::orthogonalProjection ( float  left, float  right, float  bottom, float  top, float  nearval, float  farval, float  upDirection = -1.0f  )

static

Constructs an orthogonal projection matrix from the given parameters. Near and far are the NEGATIVE of the near and far plane Z values (to follow OpenGL conventions).

Parameters

upDirection

Use -1.0 for 2D Y increasing downwards (the G3D 8.x default convention), 1.0 for 2D Y increasing upwards (the G3D 7.x default and OpenGL convention)

 {

 // Adapted from Mesa. Note that Microsoft (http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glfunc03_8qnj.asp) 
 // and Linux (http://www.xfree86.org/current/glOrtho.3.html) have different matrices shown in their documentation.

 float x, y, z;
 float tx, ty, tz;

 x = 2.0f / (right-left);
 y = 2.0f / (top-bottom);
 z = -2.0f / (farval-nearval);
 tx = -(right+left) / (right-left);
 ty = -(top+bottom) / (top-bottom);
 tz = -(farval+nearval) / (farval-nearval);

 y *= upDirection;
 ty *= upDirection;

 return 
 Matrix4( x , 0.0f, 0.0f, tx,
 0.0f, y , 0.0f, ty,
 0.0f, 0.0f, z , tz,
 0.0f, 0.0f, 0.0f, 1.0f);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Matrix4 G3D::Matrix4::orthogonalProjection ( const class Rect2D &  rect, float  nearval, float  farval, float  upDirection = -1.0f  )

static

Parameters

upDirection

Use -1.0 for 2D Y increasing downwards (the G3D 8.x default convention), 1.0 for 2D Y increasing upwards (the G3D 7.x default and OpenGL convention)

 {
 return Matrix4::orthogonalProjection(rect.x0(), rect.x1(), rect.y1(), rect.y0(), nearval, farval, upDirection);
}

Here is the call graph for this function:

Matrix4 G3D::Matrix4::perspectiveProjection ( double  left, double  right, double  bottom, double  top, double  nearval, double  farval, float  upDirection = -1.0f  )

static

Parameters

upDirection

Use -1.0 for 2D Y increasing downwards (the G3D 8.x default convention), 1.0 for 2D Y increasing upwards (the G3D 7.x default and OpenGL convention) Uses double precision because the operations involved in projection involve divisions that can significantly impact precision.

 {

 double x, y, a, b, c, d;

 x = (2.0*nearval) / (right-left);
 y = (2.0*nearval) / (top-bottom);
 a = (right+left) / (right-left);
 b = (top+bottom) / (top-bottom);

 if (farval >= inf()) {
 // Infinite view frustum
 c = -1.0;
 d = -2.0 * nearval;
 } else {
 c = -(farval+nearval) / (farval-nearval);
 d = -(2.0*farval*nearval) / (farval-nearval);
 }

 debugAssertM(abs(upDirection) == 1.0, "upDirection must be -1 or +1");
 y *= upDirection;
 b *= upDirection;

 return Matrix4(
 (float)x, 0, (float)a, 0,
 0, (float)y, (float)b, 0,
 0, 0, (float)c, (float)d,
 0, 0, -1, 0);
}

Here is the call graph for this function:

static Matrix4 G3D::Matrix4::pitchDegrees ( float  deg )

inlinestatic

 {
 return Matrix4(Matrix3::fromAxisAngle(Vector3::unitX(), toRadians(deg)));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static Matrix4 G3D::Matrix4::rollDegrees ( float  deg )

inlinestatic

 {
 return Matrix4(Matrix3::fromAxisAngle(Vector3::unitZ(), toRadians(deg)));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const Vector4 & G3D::Matrix4::row

(

int

r

)

const

 {
 return reinterpret_cast<const Vector4*>(elt[r])[0];
}

Here is the caller graph for this function:

static Matrix4 G3D::Matrix4::scale ( const Vector3 &  v )

inlinestatic

3D scale matrix

 {
 return Matrix4(v.x, 0, 0, 0,
 0, v.y, 0, 0,
 0, 0, v.z, 0,
 0, 0, 0, 1);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static Matrix4 G3D::Matrix4::scale ( float  x, float  y, float  z  )

inlinestatic

3D scale matrix

 {
 return scale(Vector3(x, y, z));
 }

Here is the call graph for this function:

static Matrix4 G3D::Matrix4::scale ( float  s )

inlinestatic

3D scale matrix

 {
 return scale(s,s,s);
 }

Here is the call graph for this function:

void G3D::Matrix4::serialize

(

class BinaryOutput &

b

)

const

Serializes row-major

 {
 for (int r = 0; r < 4; ++r) {
 for (int c = 0; c < 4; ++c) {
 b.writeFloat32(elt[r][c]);
 }
 }
}

Here is the call graph for this function:

void G3D::Matrix4::setColumn	(	int	c,
		const Vector4 &	v
	)

 {
 for (int r = 0; r < 4; ++r) {
 elt[r][c] = v[r];
 }
}

Here is the caller graph for this function:

void G3D::Matrix4::setRow	(	int	r,
		const class Vector4 &	v
	)

 {
 for (int c = 0; c < 4; ++c) {
 elt[r][c] = v[c];
 }
}

float G3D::Matrix4::subDeterminant ( int  excludeRow, int  excludeCol  ) const

private

Computes the determinant of the 3x3 matrix that lacks excludeRow and excludeCol.

 {
 // Compute non-excluded row and column indices
 int row[3];
 int col[3];

 for (int i = 0; i < 3; ++i) {
 row[i] = i;
 col[i] = i;

 if (i >= excludeRow) {
 ++row[i];
 }
 if (i >= excludeCol) {
 ++col[i];
 }
 }

 // Compute the first row of cofactors 
 float cofactor00 = 
 elt[row[1]][col[1]] * elt[row[2]][col[2]] -
 elt[row[1]][col[2]] * elt[row[2]][col[1]];

 float cofactor10 = 
 elt[row[1]][col[2]] * elt[row[2]][col[0]] -
 elt[row[1]][col[0]] * elt[row[2]][col[2]];

 float cofactor20 = 
 elt[row[1]][col[0]] * elt[row[2]][col[1]] -
 elt[row[1]][col[1]] * elt[row[2]][col[0]];

 // Product of the first row and the cofactors along the first row
 return
 elt[row[0]][col[0]] * cofactor00 +
 elt[row[0]][col[1]] * cofactor10 +
 elt[row[0]][col[2]] * cofactor20;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Any G3D::Matrix4::toAny

(

)

const

 {
 Any any(Any::ARRAY, "Matrix4");
 any.resize(16);
 for (int r = 0; r < 4; ++r) {
 for (int c = 0; c < 4; ++c) {
 any[r * 4 + c] = elt[r][c];
 }
 }

 return any;
}

Here is the call graph for this function:

std::string G3D::Matrix4::toString

(

)

const

 {
 return G3D::format("[%g, %g, %g, %g; %g, %g, %g, %g; %g, %g, %g, %g; %g, %g, %g, %g]", 
 elt[0][0], elt[0][1], elt[0][2], elt[0][3],
 elt[1][0], elt[1][1], elt[1][2], elt[1][3],
 elt[2][0], elt[2][1], elt[2][2], elt[2][3],
 elt[3][0], elt[3][1], elt[3][2], elt[3][3]);
}

Here is the call graph for this function:

static Matrix4 G3D::Matrix4::translation ( const Vector3 &  v )

inlinestatic

3D translation matrix

 {
 return Matrix4(Matrix3::identity(), v);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static Matrix4 G3D::Matrix4::translation ( float  x, float  y, float  z  )

inlinestatic

 {
 return Matrix4(Matrix3::identity(), Vector3(x, y, z));
 }

Here is the call graph for this function:

Matrix4 G3D::Matrix4::transpose

(

)

const

 {
 Matrix4 result;
 for (int r = 0; r < 4; ++r) {
 for (int c = 0; c < 4; ++c) {
 result.elt[c][r] = elt[r][c];
 }
 }

 return result;
}

Here is the caller graph for this function:

Matrix2 G3D::Matrix4::upper2x2

(

)

const

 {
 return Matrix2(elt[0][0], elt[0][1],
 elt[1][0], elt[1][1]);
}

Matrix3 G3D::Matrix4::upper3x3

(

)

const

 {
 return Matrix3(elt[0][0], elt[0][1], elt[0][2],
 elt[1][0], elt[1][1], elt[1][2],
 elt[2][0], elt[2][1], elt[2][2]);
}

static Matrix4 G3D::Matrix4::yawDegrees ( float  deg )

inlinestatic

Create a rotation matrix that rotates deg degrees around the Y axis

 {
 return Matrix4(Matrix3::fromAxisAngle(Vector3::unitY(), toRadians(deg)));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const Matrix4 & G3D::Matrix4::zero ( )

static

 {
 static Matrix4 m(
 0, 0, 0, 0,
 0, 0, 0, 0,
 0, 0, 0, 0,
 0, 0, 0, 0);
 return m;
}

Member Data Documentation

float G3D::Matrix4::elt[4][4]

private

---

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

• dep/g3dlite/include/G3D/Matrix4.h
• dep/g3dlite/source/Matrix4.cpp