G3D::Matrix4float64 Class Reference

#include <Matrix4.h>

Public Member Functions
	Matrix4float64 (const Matrix4 &m)
	Matrix4float64 ()
	Matrix4float64 (double r1c1, double r1c2, double r1c3, double r1c4, double r2c1, double r2c2, double r2c3, double r2c4, double r3c1, double r3c2, double r3c3, double r3c4, double r4c1, double r4c2, double r4c3, double r4c4)
bool	operator!= (const Matrix4float64 &other) const
bool	operator== (const Matrix4float64 &other) const
Vector4	operator* (const Vector4 &vector) const
double *	operator[] (int r)
const double *	operator[] (int r) const
	operator double * ()
	operator const double * () const

Static Public Member Functions
static const Matrix4float64 &	identity ()
static const Matrix4float64 &	zero ()
static Matrix4float64	perspectiveProjection (double left, double right, double bottom, double top, double nearval, double farval, float upDirection=-1.0f)

Private Attributes
double	elt [4][4]

Detailed Description

Double-precision 4x4 matrix

Constructor & Destructor Documentation

G3D::Matrix4float64::Matrix4float64 ( const Matrix4 &  m )

explicit

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

G3D::Matrix4float64::Matrix4float64

(

)

all zeros

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

Here is the caller graph for this function:

G3D::Matrix4float64::Matrix4float64	(	double	r1c1,
		double	r1c2,
		double	r1c3,
		double	r1c4,
		double	r2c1,
		double	r2c2,
		double	r2c3,
		double	r2c4,
		double	r3c1,
		double	r3c2,
		double	r3c3,
		double	r3c4,
		double	r4c1,
		double	r4c2,
		double	r4c3,
		double	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;
}

Member Function Documentation

const Matrix4float64 & G3D::Matrix4float64::identity ( )

static

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

G3D::Matrix4float64::operator const double * ( ) const

inline

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

G3D::Matrix4float64::operator double * ( )

inline

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

bool G3D::Matrix4float64::operator!=

(

const Matrix4float64 &

other

)

const

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

Vector4 G3D::Matrix4float64::operator*

(

const Vector4 &

vector

)

const

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

 return result;
}

bool G3D::Matrix4float64::operator==

(

const Matrix4float64 &

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(Matrix4float64)) == 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;
}

double* G3D::Matrix4float64::operator[] ( int  r )

inline

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

const double* G3D::Matrix4float64::operator[] ( int  r ) const

inline

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

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

static

 {
 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 Matrix4float64(
 (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:

const Matrix4float64 & G3D::Matrix4float64::zero ( )

static

 {
 static Matrix4float64 m;
 return m;
}

Member Data Documentation

double G3D::Matrix4float64::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