matrix of 16 floats More...

Public Member Functions
	Matrix4 (float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
	matrix constructor taking 16 scalar floats
	Matrix4 (Vector4 x, Vector4 y, Vector4 z, Vector4 w)
	matrix constructor initializing the 4 matrix column vectors
	Matrix4 (Vector3 x, Vector3 y, Vector3 z, Vector3 w)
	matrix constructor initializing the 4 matrix column vectors
float	Determinant ()
	return the determinant of this matrix
Matrix4	Transpose ()
	get the transpose of the matrix
void	Transpose (out Matrix4 result)
	get the transpose of the matrix
Matrix4	Inverse ()
	inverse for a matrix
void	Inverse (out Matrix4 result)
	inverse for a matrix
Matrix4	InverseAffine ()
	inverse for an affine matrix
void	InverseAffine (out Matrix4 result)
	inverse for an affine matrix
Matrix4	InverseOrthonormal ()
	inverse for a orthonormal martix
void	InverseOrthonormal (out Matrix4 result)
	inverse for a orthonormal matrix
Matrix4	Orthonormalize ()
	orthonormalize a matrix
void	Orthonormalize (out Matrix4 result)
	orthonormalize a matrix
Vector4	Transform (Vector4 v)
	return this * v
void	Transform (ref Vector4 v, out Vector4 result)
	result = this * v
Vector3	TransformPoint (Vector3 v)
	return this * v (X,Y,Z,1)
void	TransformPoint (ref Vector3 v, out Vector3 result)
	result = this * v (X,Y,Z,1)
Vector2	TransformPoint (Vector2 v)
	return this * v (X,Y,0,1)
void	TransformPoint (ref Vector2 v, out Vector2 result)
	result = this * v (X,Y,0,1)
Vector3	TransformVector (Vector3 v)
	return this * v (X,Y,Z,0)
void	TransformVector (ref Vector3 v, out Vector3 result)
	result = this * v (X,Y,Z,0)
Vector2	TransformVector (Vector2 v)
	return this * v (X,Y,0,0)
void	TransformVector (ref Vector2 v, out Vector2 result)
	result = this * v (X,Y,0,0)
Vector4	TransformProjection (Vector4 v)
	return this * v ( divided by W )
void	TransformProjection (ref Vector4 v, out Vector4 result)
	result = this * v ( divided by W )
Vector3	TransformProjection (Vector3 v)
	return this * v ( divided by W )
void	TransformProjection (ref Vector3 v, out Vector3 result)
	result = this * v ( divided by W )
Vector2	TransformProjection (Vector2 v)
	return this * v ( divided by W )
void	TransformProjection (ref Vector2 v, out Vector2 result)
	result = this * v ( divided by W )
Matrix4	Add (Matrix4 m)
	return this + m
void	Add (ref Matrix4 m, out Matrix4 result)
	result = this + m
Matrix4	Subtract (Matrix4 m)
	return this - m
void	Subtract (ref Matrix4 m, out Matrix4 result)
	result = this - m
Matrix4	Multiply (Matrix4 m)
	return this * m
void	Multiply (ref Matrix4 m, out Matrix4 result)
	result = this * m
Matrix4	MultiplyAffine (Matrix4 m)
	return this * m ( for affine matrices )
void	MultiplyAffine (ref Matrix4 m, out Matrix4 result)
	result = this * m ( for affine matrices )
Matrix4	Multiply (float f)
	return this * f
void	Multiply (float f, out Matrix4 result)
	result = this * f
Matrix4	Divide (float f)
	return this / f
void	Divide (float f, out Matrix4 result)
	result = this / f
Matrix4	Negate ()
	return -this
void	Negate (out Matrix4 result)
	result = -this
bool	IsOrthonormal (float epsilon)
	test to determine if a matrix is orthonormal
bool	IsIdentity ()
	test if this is an identity matrix
bool	IsInfinity ()
	test if any elements of this are Infinity
bool	IsNaN ()
	test if any elements of this are NaN
bool	Equals (Matrix4 m, float epsilon)
	equality test with an epsilon
bool	Equals (Matrix4 m)
	equality test
override bool	Equals (Object o)
	equality test
override string	ToString ()
	convert matrix to string for printing
override int	GetHashCode ()
	gets the hash code for this vector
Static Public Member Functions
static Matrix4	Transformation (Vector3 translation, Quaternion rotation, Vector3 scale)
	gets translation matrix times rotation matrix times scale matrix
static void	Transformation (ref Vector3 translation, ref Quaternion rotation, ref Vector3 scale, out Matrix4 result)
	gets translation matrix times rotation matrix times scale matrix
static Matrix4	Transformation (Vector2 translation, float rotation, Vector2 scale)
	gets translation matrix times rotation matrix times scale matrix
static void	Transformation (ref Vector2 translation, float rotation, ref Vector2 scale, out Matrix4 result)
	gets translation matrix times rotation matrix times scale matrix
static Matrix4	Transformation (Vector3 translation, Vector3 scale)
	gets translation matrix times scale matrix
static void	Transformation (ref Vector3 translation, ref Vector3 scale, out Matrix4 result)
	gets translation matrix times scale matrix
static Matrix4	Transformation (Vector2 translation, Vector2 scale)
	gets translation matrix times scale matrix
static void	Transformation (ref Vector2 translation, ref Vector2 scale, out Matrix4 result)
	gets translation matrix times scale matrix
static Matrix4	Translation (float x, float y, float z)
	get a matrix for translating a point
static void	Translation (float x, float y, float z, out Matrix4 result)
	get a matrix for translating a point
static Matrix4	Translation (Vector3 translation)
	get a matrix for translating a point
static void	Translation (ref Vector3 translation, out Matrix4 result)
	get a matrix for translating a point
static Matrix4	Translation (Vector2 translation)
	get a matrix for translating a point
static void	Translation (ref Vector2 translation, out Matrix4 result)
	get a matrix for translating a point
static Matrix4	RotationAxis (Vector3 axis, float angle)
	gets the matrix for rotating about an axis
static void	RotationAxis (ref Vector3 axis, float angle, out Matrix4 result)
	gets the matrix for rotating about an axis
static Matrix4	RotationX (float angle)
	gets a matrix for rotating around the x axis
static void	RotationX (float angle, out Matrix4 result)
	gets a matrix for rotating around the x axis
static Matrix4	RotationY (float angle)
	gets a matrix for rotating around the y axis
static void	RotationY (float angle, out Matrix4 result)
	gets a matrix for rotating around the y axis
static Matrix4	RotationZ (float angle)
	gets a matrix for rotating around the z axis
static void	RotationZ (float angle, out Matrix4 result)
	gets a matrix for rotating around the z axis
static Matrix4	RotationZyx (float x, float y, float z)
	create a new matrix from three euler angles
static void	RotationZyx (float x, float y, float z, out Matrix4 result)
	create a new matrix from three euler angles
static Matrix4	RotationZyx (Vector3 angles)
	create a new matrix from three euler angles
static void	RotationZyx (ref Vector3 angles, out Matrix4 result)
	create a new matrix from three euler angles
static Matrix4	RotationYxz (float x, float y, float z)
	create a new matrix from three euler angles
static void	RotationYxz (float x, float y, float z, out Matrix4 result)
	create a new matrix from three euler angles
static Matrix4	RotationYxz (Vector3 angles)
	create a new matrix from three euler angles
static void	RotationYxz (ref Vector3 angles, out Matrix4 result)
	create a new matrix from three euler angles
static Matrix4	RotationXzy (float x, float y, float z)
	create a new matrix from three euler angles
static void	RotationXzy (float x, float y, float z, out Matrix4 result)
	create a new matrix from three euler angles
static Matrix4	RotationXzy (Vector3 angles)
	create a new matrix from three euler angles
static void	RotationXzy (ref Vector3 angles, out Matrix4 result)
	create a new matrix from three euler angles
static Matrix4	RotationXyz (float x, float y, float z)
	create a new matrix from three euler angles
static void	RotationXyz (float x, float y, float z, out Matrix4 result)
	create a new matrix from three euler angles
static Matrix4	RotationXyz (Vector3 angles)
	create a new matrix from three euler angles
static void	RotationXyz (ref Vector3 angles, out Matrix4 result)
	create a new matrix from three euler angles
static Matrix4	RotationYzx (float x, float y, float z)
	create a new matrix from three euler angles
static void	RotationYzx (float x, float y, float z, out Matrix4 result)
	create a new matrix from three euler angles
static Matrix4	RotationYzx (Vector3 angles)
	create a new matrix from three euler angles
static void	RotationYzx (ref Vector3 angles, out Matrix4 result)
	create a new matrix from three euler angles
static Matrix4	RotationZxy (float x, float y, float z)
	create a new matrix from three euler angles
static void	RotationZxy (float x, float y, float z, out Matrix4 result)
	create a new matrix from three euler angles
static Matrix4	RotationZxy (Vector3 angles)
	create a new matrix from three euler angles
static void	RotationZxy (ref Vector3 angles, out Matrix4 result)
	create a new matrix from three euler angles
static Matrix4	Scale (float x, float y, float z)
	get a matrix for scaling a point
static void	Scale (float x, float y, float z, out Matrix4 result)
	get a matrix for scaling a point
static Matrix4	Scale (Vector3 scale)
	get a matrix for scaling a point
static void	Scale (ref Vector3 scale, out Matrix4 result)
	get a matrix for scaling a point
static Matrix4	Scale (Vector2 scale)
	get a matrix for scaling a point
static void	Scale (ref Vector2 scale, out Matrix4 result)
	get a matrix for scaling a point
static Matrix4	Perspective (float fovy, float aspect, float n, float f)
	gets a perspective matrix
static void	Perspective (float fovy, float aspect, float n, float f, out Matrix4 result)
	gets a perspective matrix
static Matrix4	Frustum (float l, float r, float b, float t, float n, float f)
	gets a perspective matrix
static void	Frustum (float l, float r, float b, float t, float n, float f, out Matrix4 result)
	gets a perspective matrix
static Matrix4	Ortho (float l, float r, float b, float t, float n, float f)
	gets an orthographic matrix
static void	Ortho (float l, float r, float b, float t, float n, float f, out Matrix4 result)
	gets an orthographic matrix
static Matrix4	LookAt (Vector3 eye, Vector3 center, Vector3 up)
	gets the matrix for a viewing transformation
static void	LookAt (ref Vector3 eye, ref Vector3 center, ref Vector3 up, out Matrix4 result)
	gets the matrix for a viewing transformation
static float	Determinant (Matrix4 m)
	static function equivalent to Determinant()
static float	Determinant (ref Matrix4 m)
	static function equivalent to Determinant()
static Matrix4	Transpose (Matrix4 m)
	static function equivalent to Transpose()
static void	Transpose (ref Matrix4 m, out Matrix4 result)
	static function equivalent to Transpose(out Matrix4)
static Matrix4	Inverse (Matrix4 m)
	static function equivalent to Inverse()
static void	Inverse (ref Matrix4 m, out Matrix4 result)
	static function equivalent to Inverse(out Matrix4)
static Matrix4	InverseAffine (Matrix4 m)
	static function equivalent to InverseAffine()
static void	InverseAffine (ref Matrix4 m, out Matrix4 result)
	static function equivalent to InverseAffine(out Matrix4)
static Matrix4	InverseOrthonormal (Matrix4 m)
	static function equivalent to InverseOrthonormal()
static void	InverseOrthonormal (ref Matrix4 m, out Matrix4 result)
	static function equivalent to InverseOrthonormal(out Matrix4)
static Matrix4	Orthonormalize (Matrix4 m)
	static function equivalent to Orthonormalize()
static void	Orthonormalize (ref Matrix4 m, out Matrix4 result)
	static function equivalent to Orthonormalize(out Matrix4)
static Vector4	Transform (Matrix4 m, Vector4 v)
	static function equivalent to Transform(Vector4)
static void	Transform (ref Matrix4 m, ref Vector4 v, out Vector4 result)
	static function equivalent to Transform(ref Vector4, out Vector4)
static Vector3	TransformPoint (Matrix4 m, Vector3 v)
	static function equivalent to TransformPoint(Vector3)
static void	TransformPoint (ref Matrix4 m, ref Vector3 v, out Vector3 result)
	static function equivalent to TransformPoint(ref Vector3, out Vector3)
static Vector2	TransformPoint (Matrix4 m, Vector2 v)
	static function equivalent to TransformPoint(Vector2)
static void	TransformPoint (ref Matrix4 m, ref Vector2 v, out Vector2 result)
	static function equivalent to TransformPoint(ref Vector2, out Vector2)
static Vector3	TransformVector (Matrix4 m, Vector3 v)
	static function equivalent to TransformVector(Vector3)
static void	TransformVector (ref Matrix4 m, ref Vector3 v, out Vector3 result)
	static function equivalent to TransformVector(ref Vector3, out Vector3)
static Vector2	TransformVector (Matrix4 m, Vector2 v)
	static function equivalent to TransformVector(Vector2)
static void	TransformVector (ref Matrix4 m, ref Vector2 v, out Vector2 result)
	static function equivalent to TransformVector(ref Vector2, out Vector2)
static Vector4	TransformProjection (Matrix4 m, Vector4 v)
	static function equivalent to TransformProjection(Vector4)
static void	TransformProjection (ref Matrix4 m, ref Vector4 v, out Vector4 result)
	static function equivalent to TransformProjection(ref Vector4, out Vector4)
static Vector3	TransformProjection (Matrix4 m, Vector3 v)
	static function equivalent to TransformProjection(Vector3)
static void	TransformProjection (ref Matrix4 m, ref Vector3 v, out Vector3 result)
	static function equivalent to TransformProjection(ref Vector3, out Vector3)
static Vector2	TransformProjection (Matrix4 m, Vector2 v)
	static function equivalent to TransformProjection(Vector2)
static void	TransformProjection (ref Matrix4 m, ref Vector2 v, out Vector2 result)
	static function equivalent to TransformProjection(ref Vector2, out Vector2)
static Matrix4	Add (Matrix4 m1, Matrix4 m2)
	static function equivalent to Add(Matrix4)
static void	Add (ref Matrix4 m1, ref Matrix4 m2, out Matrix4 result)
	static function equivalent to Add(ref Matrix4, out Matrix4)
static Matrix4	Subtract (Matrix4 m1, Matrix4 m2)
	static function equivalent to Subtract(Matrix4)
static void	Subtract (ref Matrix4 m1, ref Matrix4 m2, out Matrix4 result)
	static function equivalent to Subtract(ref Matrix4, out Matrix4)
static Matrix4	Multiply (Matrix4 m1, Matrix4 m2)
	static function equivalent to Multiply(Matrix4)
static void	Multiply (ref Matrix4 m1, ref Matrix4 m2, out Matrix4 result)
	static function equivalent to Multiply(ref Matrix4, out Matrix4)
static Matrix4	MultiplyAffine (Matrix4 m1, Matrix4 m2)
	static function equivalent to MultiplyAffine(Matrix4)
static void	MultiplyAffine (ref Matrix4 m1, ref Matrix4 m2, out Matrix4 result)
	static function equivalent to MultiplyAffine(ref Matrix4, out Matrix4)
static Matrix4	Multiply (Matrix4 m, float f)
	static function equivalent to Multiply(float)
static void	Multiply (ref Matrix4 m, float f, out Matrix4 result)
	static function equivalent to Multiply(float, out Matrix4)
static Matrix4	Divide (Matrix4 m, float f)
	static function equivalent to Divide(float)
static void	Divide (ref Matrix4 m, float f, out Matrix4 result)
	static function equivalent to Divide(float, out Matrix4)
static Matrix4	Negate (Matrix4 m)
	static function equivalent to Negate()
static void	Negate (ref Matrix4 m, out Matrix4 result)
	static function equivalent to Negate(out Matrix4)
static bool	operator== (Matrix4 m1, Matrix4 m2)
	operator to test if two matrices are equal
static bool	operator!= (Matrix4 m1, Matrix4 m2)
	operator to test if two matrices are not equal
static Matrix4	operator+ (Matrix4 m1, Matrix4 m2)
	operator adding each element of matrix 1 to the corresponding element of matrix 2
static Matrix4	operator- (Matrix4 m1, Matrix4 m2)
	operator subtracting each element of matrix 2 from the corresponding element of matrix 1
static Matrix4	operator- (Matrix4 m)
	unary minus operator
static Matrix4	operator* (Matrix4 m1, Matrix4 m2)
	operator multiplying a matrix by a matrix
static Matrix4	operator* (Matrix4 m, float f)
	operator multiplying each matrix element by a scalar float value
static Matrix4	operator* (float f, Matrix4 m)
	operator multiplying each matrix element by a scalar float value
static Vector4	operator* (Matrix4 m, Vector4 v)
	operator multiplying a matrix by a vector
static Matrix4	operator/ (Matrix4 m, float f)
	operator dividing each matrix element by a scalar float value
Public Attributes
float	M11
	column 1, element 1
float	M12
	column 1, element 2
float	M13
	column 1, element 3
float	M14
	column 1, element 4
float	M21
	column 2, element 1
float	M22
	column 2, element 2
float	M23
	column 2, element 3
float	M24
	column 2, element 4
float	M31
	column 3, element 1
float	M32
	column 3, element 2
float	M33
	column 3, element 3
float	M34
	column 3, element 4
float	M41
	column 4, element 1
float	M42
	column 4, element 2
float	M43
	column 4, element 3
float	M44
	column 4, element 4
Static Public Attributes
static readonly Matrix4	Zero = new Matrix4(Vector4.Zero, Vector4.Zero, Vector4.Zero, Vector4.Zero)
	a matrix of all zeroes
static readonly Matrix4	Identity = new Matrix4(Vector4.UnitX, Vector4.UnitY, Vector4.UnitZ, Vector4.UnitW)
	identity matrix
Properties
Vector4	ColumnX `[get, set]`
	the first column in the matrix
Vector4	ColumnY `[get, set]`
	the second column in the matrix
Vector4	ColumnZ `[get, set]`
	the third column in the matrix
Vector4	ColumnW `[get, set]`
	the fourth column in the matrix
Vector4	RowX `[get, set]`
	the first row in the matrix
Vector4	RowY `[get, set]`
	the second row in the matrix
Vector4	RowZ `[get, set]`
	the third row in the matrix
Vector4	RowW `[get, set]`
	the fourth row in the matrix
Vector3	AxisX `[get, set]`
	XYZ components of ColumnX.
Vector3	AxisY `[get, set]`
	XYZ components of ColumnY.
Vector3	AxisZ `[get, set]`
	XYZ components of ColumnZ.
Vector3	AxisW `[get, set]`
	XYZ components of ColumnW.

Detailed Description

matrix of 16 floats

Constructor & Destructor Documentation

Matrix4	(	float	m11,
		float	m12,
		float	m13,
		float	m14,
		float	m21,
		float	m22,
		float	m23,
		float	m24,
		float	m31,
		float	m32,
		float	m33,
		float	m34,
		float	m41,
		float	m42,
		float	m43,
		float	m44
	)

matrix constructor taking 16 scalar floats

Parameters:

m11	value to initialize column 1 element 1 with
m12	value to initialize column 1 element 2 with
m13	value to initialize column 1 element 3 with
m14	value to initialize column 1 element 4 with
m21	value to initialize column 2 element 1 with
m22	value to initialize column 2 element 2 with
m23	value to initialize column 2 element 3 with
m24	value to initialize column 2 element 4 with
m31	value to initialize column 3 element 1 with
m32	value to initialize column 3 element 2 with
m33	value to initialize column 3 element 3 with
m34	value to initialize column 3 element 4 with
m41	value to initialize column 4 element 1 with
m42	value to initialize column 4 element 2 with
m43	value to initialize column 4 element 3 with
m44	value to initialize column 4 element 4 with

Matrix4	(	Vector4	x,
		Vector4	y,
		Vector4	z,
		Vector4	w
	)

matrix constructor initializing the 4 matrix column vectors

Parameters:

x	vector to initialize matrix column 1 with
y	vector to initialize matrix column 2 with
z	vector to initialize matrix column 3 with
w	vector to initialize matrix column 4 with

Matrix4	(	Vector3	x,
		Vector3	y,
		Vector3	z,
		Vector3	w
	)

matrix constructor initializing the 4 matrix column vectors

Parameters:

x	vector to initialize matrix column 1 with
y	vector to initialize matrix column 2 with
z	vector to initialize matrix column 3 with
w	vector to initialize matrix column 4 with

Member Function Documentation

Matrix4 Add ( Matrix4 m )

return this + m

Parameters:

m matrix

Returns:: this + m

static Matrix4 Add	(	Matrix4	m1,
		Matrix4	m2
	)		`[static]`

static function equivalent to Add(Matrix4)

Parameters:

m1	matrix 1
m2	matrix 2

Returns:: m1 + m2

static void Add	(	ref Matrix4	m1,
		ref Matrix4	m2,
		out Matrix4	result
	)		`[static]`

static function equivalent to Add(ref Matrix4, out Matrix4)

Parameters:

m1	matrix 1
m2	matrix 2
result	m1 + m2

void Add	(	ref Matrix4	m,
		out Matrix4	result
	)

result = this + m

Parameters:

m	matrix
result	this + m

static float Determinant ( Matrix4 m ) [static]

static function equivalent to Determinant()

Parameters:

m matrix

Returns:: the determinant of this matrix

float Determinant ( )

return the determinant of this matrix

Returns:: the determinant of this matrix

static float Determinant ( ref Matrix4 m ) [static]

static function equivalent to Determinant()

Parameters:

m matrix

Returns:: the determinant of this matrix

Matrix4 Divide ( float f )

return this / f

Parameters:

f scalar

Returns:: this / f

void Divide	(	float	f,
		out Matrix4	result
	)

result = this / f

Parameters:

f	scalar
result	this / f

static Matrix4 Divide	(	Matrix4	m,
		float	f
	)		`[static]`

static function equivalent to Divide(float)

Parameters:

m	matrix
f	scalar

Returns:: m / f

static void Divide	(	ref Matrix4	m,
		float	f,
		out Matrix4	result
	)		`[static]`

static function equivalent to Divide(float, out Matrix4)

Parameters:

m	matrix
f	scalar
result	m / f

bool Equals	(	Matrix4	m,
		float	epsilon
	)

equality test with an epsilon

Parameters:

m	the matrix to compare this to
epsilon	the epsilon to use in comparison

Returns:: true if for every element n, abs(this[n] - m[n]) <= epsilon, false otherwise

bool Equals ( Matrix4 m )

equality test

Parameters:

m	the matrix to compare this to

Returns:: true if this == m, false otherwise

override bool Equals ( Object o )

equality test

Parameters:

o	the object to compare this to

Returns:: true if this == o, false otherwise

static void Frustum	(	float	l,
		float	r,
		float	b,
		float	t,
		float	n,
		float	f,
		out Matrix4	result
	)		`[static]`

gets a perspective matrix

Parameters:

l	coordinates for the left vertical clip plane
r	coordinates for the right vertical clip plane
b	coordinates for the bottom horizontal clip plane
t	coordinates for the top horizontal clip plane
n	distance to the near clip plane
f	distance to the far clip plane
result	perspective matrix

static Matrix4 Frustum	(	float	l,
		float	r,
		float	b,
		float	t,
		float	n,
		float	f
	)		`[static]`

gets a perspective matrix

Parameters:

l	coordinates for the left vertical clip plane
r	coordinates for the right vertical clip plane
b	coordinates for the bottom horizontal clip plane
t	coordinates for the top horizontal clip plane
n	distance to the near clip plane
f	distance to the far clip plane

Returns:: perspective matrix

override int GetHashCode ( )

gets the hash code for this vector

Returns:: integer hash code

Matrix4 Inverse ( )

inverse for a matrix

Returns:: matrix inverse

void Inverse ( out Matrix4 result )

inverse for a matrix

Parameters:

result matrix inverse

static Matrix4 Inverse ( Matrix4 m ) [static]

static function equivalent to Inverse()

Parameters:

m matrix

Returns:: matrix inverse

static void Inverse	(	ref Matrix4	m,
		out Matrix4	result
	)		`[static]`

static function equivalent to Inverse(out Matrix4)

Parameters:

m	matrix
result	matrix inverse

Matrix4 InverseAffine ( )

inverse for an affine matrix

Returns:: matrix inverse

void InverseAffine ( out Matrix4 result )

inverse for an affine matrix

Parameters:

result matrix inverse

static Matrix4 InverseAffine ( Matrix4 m ) [static]

static function equivalent to InverseAffine()

Parameters:

m matrix

Returns:: matrix inverse

static void InverseAffine	(	ref Matrix4	m,
		out Matrix4	result
	)		`[static]`

static function equivalent to InverseAffine(out Matrix4)

Parameters:

m	matrix
result	matrix inverse

Matrix4 InverseOrthonormal ( )

inverse for a orthonormal martix

Returns:: matrix inverse

void InverseOrthonormal ( out Matrix4 result )

inverse for a orthonormal matrix

Parameters:

result matrix inverse

static Matrix4 InverseOrthonormal ( Matrix4 m ) [static]

static function equivalent to InverseOrthonormal()

Parameters:

m matrix

Returns:: matrix inverse

static void InverseOrthonormal	(	ref Matrix4	m,
		out Matrix4	result
	)		`[static]`

static function equivalent to InverseOrthonormal(out Matrix4)

Parameters:

m	matrix
result	matrix inverse

bool IsIdentity ( )

test if this is an identity matrix

Returns:: true if this is an identity matrix, false otherwise

bool IsInfinity ( )

test if any elements of this are Infinity

Returns:: true if any elements of this are Infinity, false otherwise

bool IsNaN ( )

test if any elements of this are NaN

Returns:: true if any elements of this are NaN, false otherwise

bool IsOrthonormal ( float epsilon )

test to determine if a matrix is orthonormal

Parameters:

epsilon epsilon for testing if vectors are unit vectors

Returns:: true if the matrix is orthonormal, false otherwise

static Matrix4 LookAt	(	Vector3	eye,
		Vector3	center,
		Vector3	up
	)		`[static]`

gets the matrix for a viewing transformation

Parameters:

eye	position of the eye point
center	position of the reference point
up	the up vector

Returns:: viewing transformation matrix

static void LookAt	(	ref Vector3	eye,
		ref Vector3	center,
		ref Vector3	up,
		out Matrix4	result
	)		`[static]`

gets the matrix for a viewing transformation

Parameters:

eye	position of the eye point
center	position of the reference point
up	the up vector
result	viewing transformation matrix

void Multiply	(	ref Matrix4	m,
		out Matrix4	result
	)

result = this * m

Parameters:

m	matrix
result	this * m

Matrix4 Multiply ( Matrix4 m )

return this * m

Parameters:

m matrix

Returns:: this * m

static Matrix4 Multiply	(	Matrix4	m1,
		Matrix4	m2
	)		`[static]`

static function equivalent to Multiply(Matrix4)

Parameters:

m1	matrix 1
m2	matrix 2

Returns:: m1 * m2

static void Multiply	(	ref Matrix4	m1,
		ref Matrix4	m2,
		out Matrix4	result
	)		`[static]`

static function equivalent to Multiply(ref Matrix4, out Matrix4)

Parameters:

m1	matrix 1
m2	matrix 2
result	m1 * m2

static Matrix4 Multiply	(	Matrix4	m,
		float	f
	)		`[static]`

static function equivalent to Multiply(float)

Parameters:

m	matrix
f	scalar

Returns:: m * f

void Multiply	(	float	f,
		out Matrix4	result
	)

result = this * f

Parameters:

f	scalar
result	this * f

static void Multiply	(	ref Matrix4	m,
		float	f,
		out Matrix4	result
	)		`[static]`

static function equivalent to Multiply(float, out Matrix4)

Parameters:

m	matrix
f	scalar
result	m * f

Matrix4 Multiply ( float f )

return this * f

Parameters:

f scalar

Returns:: this * f

Matrix4 MultiplyAffine ( Matrix4 m )

return this * m ( for affine matrices )

Parameters:

m matrix

Returns:: this * m

void MultiplyAffine	(	ref Matrix4	m,
		out Matrix4	result
	)

result = this * m ( for affine matrices )

Parameters:

m	matrix
result	this * m

static Matrix4 MultiplyAffine	(	Matrix4	m1,
		Matrix4	m2
	)		`[static]`

static function equivalent to MultiplyAffine(Matrix4)

Parameters:

m1	matrix 1
m2	matrix 2

Returns:: m1 * m2

static void MultiplyAffine	(	ref Matrix4	m1,
		ref Matrix4	m2,
		out Matrix4	result
	)		`[static]`

static function equivalent to MultiplyAffine(ref Matrix4, out Matrix4)

Parameters:

m1	matrix 1
m2	matrix 2
result	m1 * m2

static void Negate	(	ref Matrix4	m,
		out Matrix4	result
	)		`[static]`

static function equivalent to Negate(out Matrix4)

Parameters:

m	matrix
result	-m

void Negate ( out Matrix4 result )

result = -this

Parameters:

result -this

Matrix4 Negate ( )

return -this

Returns:: -this

static Matrix4 Negate ( Matrix4 m ) [static]

static function equivalent to Negate()

Parameters:

m matrix

Returns:: -m

static bool operator!=	(	Matrix4	m1,
		Matrix4	m2
	)		`[static]`

operator to test if two matrices are not equal

Parameters:

m1	matrix 1
m2	matrix 2

Returns:: true if not equal, false otherwise

static Matrix4 operator*	(	Matrix4	m1,
		Matrix4	m2
	)		`[static]`

operator multiplying a matrix by a matrix

Parameters:

m1	matrix 1
m2	matrix 2

static Matrix4 operator*	(	Matrix4	m,
		float	f
	)		`[static]`

operator multiplying each matrix element by a scalar float value

Parameters:

m	the matrix to multiply
f	the scalar float to multiply each matrix element by

static Matrix4 operator*	(	float	f,
		Matrix4	m
	)		`[static]`

operator multiplying each matrix element by a scalar float value

Parameters:

f	the scalar float to multiply each matrix element by
m	the matrix to multiply

static Vector4 operator*	(	Matrix4	m,
		Vector4	v
	)		`[static]`

operator multiplying a matrix by a vector

Parameters:

m	the matrix to multiply
v	the vector to multiply the matrix by

static Matrix4 operator+	(	Matrix4	m1,
		Matrix4	m2
	)		`[static]`

operator adding each element of matrix 1 to the corresponding element of matrix 2

Parameters:

m1	matrix 1
m2	matrix 2

static Matrix4 operator-	(	Matrix4	m1,
		Matrix4	m2
	)		`[static]`

operator subtracting each element of matrix 2 from the corresponding element of matrix 1

Parameters:

m1	matrix 1
m2	matrix 2

Returns:: matrix 1 - matrix 2

static Matrix4 operator- ( Matrix4 m ) [static]

unary minus operator

Parameters:

m	matrix to negate

Returns:: unary minus applied to each member of m

static Matrix4 operator/	(	Matrix4	m,
		float	f
	)		`[static]`

operator dividing each matrix element by a scalar float value

Parameters:

m	the matrix to divide
f	the scalar float to divide each element by

static bool operator==	(	Matrix4	m1,
		Matrix4	m2
	)		`[static]`

operator to test if two matrices are equal

Parameters:

m1	matrix 1
m2	matrix 2

Returns:: true is equal, false otherwise

static Matrix4 Ortho	(	float	l,
		float	r,
		float	b,
		float	t,
		float	n,
		float	f
	)		`[static]`

gets an orthographic matrix

Parameters:

l	coordinates for the left vertical clip plane
r	coordinates for the right vertical clip plane
b	coordinates for the bottom horizontal clip plane
t	coordinates for the top horizontal clip plane
n	distance to the near clip plane
f	distance to the far clip plane

Returns:: orthographic matrix

static void Ortho	(	float	l,
		float	r,
		float	b,
		float	t,
		float	n,
		float	f,
		out Matrix4	result
	)		`[static]`

gets an orthographic matrix

Parameters:

l	coordinates for the left vertical clip plane
r	coordinates for the right vertical clip plane
b	coordinates for the bottom horizontal clip plane
t	coordinates for the top horizontal clip plane
n	distance to the near clip plane
f	distance to the far clip plane
result	orthographic matrix

Matrix4 Orthonormalize ( )

orthonormalize a matrix

Returns:: orthonormalized matrix

void Orthonormalize ( out Matrix4 result )

orthonormalize a matrix

Parameters:

result orthonormalized matrix

static Matrix4 Orthonormalize ( Matrix4 m ) [static]

static function equivalent to Orthonormalize()

Parameters:

m matrix

Returns:: orthonormalized matrix

static void Orthonormalize	(	ref Matrix4	m,
		out Matrix4	result
	)		`[static]`

static function equivalent to Orthonormalize(out Matrix4)

Parameters:

m	matrix
result	orthonormalized matrix

static Matrix4 Perspective	(	float	fovy,
		float	aspect,
		float	n,
		float	f
	)		`[static]`

gets a perspective matrix

Parameters:

fovy	field of view angle in the y direction
aspect	aspect ratio
n	distance from the viewer to the near clip
f	distance from the viewer to the far clip

Returns:: perspective matrix

static void Perspective	(	float	fovy,
		float	aspect,
		float	n,
		float	f,
		out Matrix4	result
	)		`[static]`

gets a perspective matrix

Parameters:

fovy	field of view angle in the y direction
aspect	aspect ratio
n	distance from the viewer to the near clip
f	distance from the viewer to the far clip
result	perspective matrix

static Matrix4 RotationAxis	(	Vector3	axis,
		float	angle
	)		`[static]`

gets the matrix for rotating about an axis

Parameters:

axis	the axis to rotate around
angle	the angle to rotate

Returns:: rotation matrix

static void RotationAxis	(	ref Vector3	axis,
		float	angle,
		out Matrix4	result
	)		`[static]`

gets the matrix for rotating about an axis

Parameters:

axis	the axis to rotate around
angle	the angle to rotate
result	rotation matrix

static Matrix4 RotationX ( float angle ) [static]

gets a matrix for rotating around the x axis

Parameters:

angle the angle to rotate

Returns:: rotation matrix

static void RotationX	(	float	angle,
		out Matrix4	result
	)		`[static]`

gets a matrix for rotating around the x axis

Parameters:

angle	the angle to rotate
result	rotation matrix

static void RotationXyz	(	float	x,
		float	y,
		float	z,
		out Matrix4	result
	)		`[static]`

create a new matrix from three euler angles

Parameters:

x	x angle
y	y angle
z	z angle
result	a new matrix from the three euler angles

static Matrix4 RotationXyz	(	float	x,
		float	y,
		float	z
	)		`[static]`

create a new matrix from three euler angles

Parameters:

x	x angle
y	y angle
z	z angle

Returns:: a new matrix from the three euler angles

static Matrix4 RotationXyz ( Vector3 angles ) [static]

create a new matrix from three euler angles

Parameters:

angles the x, y, z euler angles used to create the matrix

Returns:: a new matrix from the three euler angles

static void RotationXyz	(	ref Vector3	angles,
		out Matrix4	result
	)		`[static]`

create a new matrix from three euler angles

Parameters:

angles	the x, y, z euler angles used to create the matrix
result	a new matrix from the three euler angles

static void RotationXzy	(	ref Vector3	angles,
		out Matrix4	result
	)		`[static]`

create a new matrix from three euler angles

Parameters:

angles	the x, z, y euler angles used to create the matrix
result	a new matrix from the three euler angles

static Matrix4 RotationXzy	(	float	x,
		float	y,
		float	z
	)		`[static]`

create a new matrix from three euler angles

Parameters:

x	x angle
y	y angle
z	z angle

Returns:: a new matrix from the three euler angles

static void RotationXzy	(	float	x,
		float	y,
		float	z,
		out Matrix4	result
	)		`[static]`

create a new matrix from three euler angles

Parameters:

x	x angle
y	y angle
z	z angle
result	a new matrix from the three euler angles

static Matrix4 RotationXzy ( Vector3 angles ) [static]

create a new matrix from three euler angles

Parameters:

angles the x, z, y euler angles used to create the matrix

Returns:: a new matrix from the three euler angles

static Matrix4 RotationY ( float angle ) [static]

gets a matrix for rotating around the y axis

Parameters:

angle the angle to rotate

Returns:: rotation matrix

static void RotationY	(	float	angle,
		out Matrix4	result
	)		`[static]`

gets a matrix for rotating around the y axis

Parameters:

angle	the angle to rotate
result	rotation matrix

static void RotationYxz	(	float	x,
		float	y,
		float	z,
		out Matrix4	result
	)		`[static]`

create a new matrix from three euler angles

Parameters:

x	x angle
y	y angle
z	z angle
result	a new matrix from the three euler angles

static void RotationYxz	(	ref Vector3	angles,
		out Matrix4	result
	)		`[static]`

create a new matrix from three euler angles

Parameters:

angles	the y, x, z euler angles used to create the matrix
result	a new matrix from the three euler angles

static Matrix4 RotationYxz ( Vector3 angles ) [static]

create a new matrix from three euler angles

Parameters:

angles the y, x, z euler angles used to create the matrix

Returns:: a new matrix from the three euler angles

static Matrix4 RotationYxz	(	float	x,
		float	y,
		float	z
	)		`[static]`

create a new matrix from three euler angles

Parameters:

x	x angle
y	y angle
z	z angle

Returns:: a new matrix from the three euler angles

static Matrix4 RotationYzx ( Vector3 angles ) [static]

create a new matrix from three euler angles

Parameters:

angles the y, z, x euler angles used to create the matrix

Returns:: a new matrix from the three euler angles

static Matrix4 RotationYzx	(	float	x,
		float	y,
		float	z
	)		`[static]`

create a new matrix from three euler angles

Parameters:

x	x angle
y	y angle
z	z angle

Returns:: a new matrix from the three euler angles

static void RotationYzx	(	float	x,
		float	y,
		float	z,
		out Matrix4	result
	)		`[static]`

create a new matrix from three euler angles

Parameters:

x	x angle
y	y angle
z	z angle
result	a new matrix from the three euler angles

static void RotationYzx	(	ref Vector3	angles,
		out Matrix4	result
	)		`[static]`

create a new matrix from three euler angles

Parameters:

angles	the y, z, x euler angles used to create the matrix
result	a new matrix from the three euler angles

static Matrix4 RotationZ ( float angle ) [static]

gets a matrix for rotating around the z axis

Parameters:

angle the angle to rotate

Returns:: rotation matrix

static void RotationZ	(	float	angle,
		out Matrix4	result
	)		`[static]`

gets a matrix for rotating around the z axis

Parameters:

angle	the angle to rotate
result	rotation matrix

static Matrix4 RotationZxy ( Vector3 angles ) [static]

create a new matrix from three euler angles

Parameters:

angles the z, x, y euler angles used to create the matrix

Returns:: a new matrix from the three euler angles

static Matrix4 RotationZxy	(	float	x,
		float	y,
		float	z
	)		`[static]`

create a new matrix from three euler angles

Parameters:

x	x angle
y	y angle
z	z angle

Returns:: a new matrix from the three euler angles

static void RotationZxy	(	float	x,
		float	y,
		float	z,
		out Matrix4	result
	)		`[static]`

create a new matrix from three euler angles

Parameters:

x	x angle
y	y angle
z	z angle
result	a new matrix from the three euler angles

static void RotationZxy	(	ref Vector3	angles,
		out Matrix4	result
	)		`[static]`

create a new matrix from three euler angles

Parameters:

angles	the z, x, y euler angles used to create the matrix
result	a new matrix from the three euler angles

static void RotationZyx	(	float	x,
		float	y,
		float	z,
		out Matrix4	result
	)		`[static]`

create a new matrix from three euler angles

Parameters:

x	x angle
y	y angle
z	z angle
result	a new matrix from the three euler angles

static Matrix4 RotationZyx	(	float	x,
		float	y,
		float	z
	)		`[static]`

create a new matrix from three euler angles

Parameters:

x	x angle
y	y angle
z	z angle

Returns:: a new matrix from the three euler angles

static void RotationZyx	(	ref Vector3	angles,
		out Matrix4	result
	)		`[static]`

create a new matrix from three euler angles

Parameters:

angles	the z, y, x euler angles used to create the matrix
result	a new matrix from the three euler angles

static Matrix4 RotationZyx ( Vector3 angles ) [static]

create a new matrix from three euler angles

Parameters:

angles the z, y, x euler angles used to create the matrix

Returns:: a new matrix from the three euler angles

static Matrix4 Scale ( Vector3 scale ) [static]

get a matrix for scaling a point

Parameters:

scale a vector containing the x, y, z scale values

Returns:: scaling matrix

static Matrix4 Scale	(	float	x,
		float	y,
		float	z
	)		`[static]`

get a matrix for scaling a point

Parameters:

x	x scale
y	y scale
z	z scale

Returns:: scaling matrix

static void Scale	(	float	x,
		float	y,
		float	z,
		out Matrix4	result
	)		`[static]`

get a matrix for scaling a point

Parameters:

x	x scale
y	y scale
z	z scale
result	scaling matrix

static Matrix4 Scale ( Vector2 scale ) [static]

get a matrix for scaling a point

Parameters:

scale a vector containing the x, y scale values

Returns:: scaling matrix

static void Scale	(	ref Vector3	scale,
		out Matrix4	result
	)		`[static]`

get a matrix for scaling a point

Parameters:

scale	a vector containing the x, y, z scale values
result	scaling matrix

static void Scale	(	ref Vector2	scale,
		out Matrix4	result
	)		`[static]`

get a matrix for scaling a point

Parameters:

scale	a vector containing the x, y scale values
result	scaling matrix

static void Subtract	(	ref Matrix4	m1,
		ref Matrix4	m2,
		out Matrix4	result
	)		`[static]`

static function equivalent to Subtract(ref Matrix4, out Matrix4)

Parameters:

m1	matrix 1
m2	matrix 2
result	m1 - m2

static Matrix4 Subtract	(	Matrix4	m1,
		Matrix4	m2
	)		`[static]`

static function equivalent to Subtract(Matrix4)

Parameters:

m1	matrix 1
m2	matrix 2

Returns:: m1 - m2

Matrix4 Subtract ( Matrix4 m )

return this - m

Parameters:

m matrix

Returns:: this - m

void Subtract	(	ref Matrix4	m,
		out Matrix4	result
	)

result = this - m

Parameters:

m	matrix
result	this - m

override string ToString ( )

convert matrix to string for printing

Returns:: matrix as string

Vector4 Transform ( Vector4 v )

return this * v

Parameters:

v vector

Returns:: this * v

void Transform	(	ref Vector4	v,
		out Vector4	result
	)

result = this * v

Parameters:

v	vector
result	this * v

static Vector4 Transform	(	Matrix4	m,
		Vector4	v
	)		`[static]`

static function equivalent to Transform(Vector4)

Parameters:

m	matrix
v	vector

Returns:: m * v

static void Transform	(	ref Matrix4	m,
		ref Vector4	v,
		out Vector4	result
	)		`[static]`

static function equivalent to Transform(ref Vector4, out Vector4)

Parameters:

m	matrix
v	vector
result	m * v

static Matrix4 Transformation	(	Vector3	translation,
		Quaternion	rotation,
		Vector3	scale
	)		`[static]`

gets translation matrix times rotation matrix times scale matrix

Parameters:

translation	x, y, z translation values
rotation	quaternion rotation values
scale	x, y, z scale values

Returns:: translation matrix times rotation matrix times scale matrix

static Matrix4 Transformation	(	Vector2	translation,
		Vector2	scale
	)		`[static]`

gets translation matrix times scale matrix

Parameters:

translation	x, y translation values
scale	x, y scale values

Returns:: translation matrix times scale matrix

static void Transformation	(	ref Vector2	translation,
		ref Vector2	scale,
		out Matrix4	result
	)		`[static]`

gets translation matrix times scale matrix

Parameters:

translation	x, y translation values
scale	x, y scale values
result	translation matrix times scale matrix

static Matrix4 Transformation	(	Vector3	translation,
		Vector3	scale
	)		`[static]`

gets translation matrix times scale matrix

Parameters:

translation	x, y, z translation values
scale	x, y, z scale values

Returns:: translation matrix times scale matrix

static void Transformation	(	ref Vector2	translation,
		float	rotation,
		ref Vector2	scale,
		out Matrix4	result
	)		`[static]`

gets translation matrix times rotation matrix times scale matrix

Parameters:

translation	x, y translation values
rotation	z rotation angle
scale	x, y scale values
result	translation matrix times rotation matrix times scale matrix

static void Transformation	(	ref Vector3	translation,
		ref Quaternion	rotation,
		ref Vector3	scale,
		out Matrix4	result
	)		`[static]`

gets translation matrix times rotation matrix times scale matrix

Parameters:

translation	x, y, z translation values
rotation	quaternion rotation values
scale	x, y, z scale values
result	translation matrix times rotation matrix times scale matrix

static void Transformation	(	ref Vector3	translation,
		ref Vector3	scale,
		out Matrix4	result
	)		`[static]`

gets translation matrix times scale matrix

Parameters:

translation	x, y, z translation values
scale	x, y, z scale values
result	translation matrix times scale matrix

static Matrix4 Transformation	(	Vector2	translation,
		float	rotation,
		Vector2	scale
	)		`[static]`

gets translation matrix times rotation matrix times scale matrix

Parameters:

translation	x, y translation values
rotation	z rotation angle
scale	x, y scale values

Returns:: translation matrix times rotation matrix times scale matrix

static void TransformPoint	(	ref Matrix4	m,
		ref Vector2	v,
		out Vector2	result
	)		`[static]`

static function equivalent to TransformPoint(ref Vector2, out Vector2)

Parameters:

m	matrix
v	vector
result	m * v (X,Y,0,1)

Vector3 TransformPoint ( Vector3 v )

return this * v (X,Y,Z,1)

Parameters:

v vector

Returns:: this * v (X,Y,Z,1)

void TransformPoint	(	ref Vector2	v,
		out Vector2	result
	)

result = this * v (X,Y,0,1)

Parameters:

v	vector
result	this * v (X,Y,0,1)

void TransformPoint	(	ref Vector3	v,
		out Vector3	result
	)

result = this * v (X,Y,Z,1)

Parameters:

v	vector
result	this * v (X,Y,Z,1)

static Vector2 TransformPoint	(	Matrix4	m,
		Vector2	v
	)		`[static]`

static function equivalent to TransformPoint(Vector2)

Parameters:

m	matrix
v	vector

Returns:: m * v (X,Y,0,1)

static Vector3 TransformPoint	(	Matrix4	m,
		Vector3	v
	)		`[static]`

static function equivalent to TransformPoint(Vector3)

Parameters:

m	matrix
v	vector

Returns:: m * v (X,Y,Z,1)

static void TransformPoint	(	ref Matrix4	m,
		ref Vector3	v,
		out Vector3	result
	)		`[static]`

static function equivalent to TransformPoint(ref Vector3, out Vector3)

Parameters:

m	matrix
v	vector
result	m * v (X,Y,Z,1)

Vector2 TransformPoint ( Vector2 v )

return this * v (X,Y,0,1)

Parameters:

v vector

Returns:: this * v (X,Y,0,1)

static void TransformProjection	(	ref Matrix4	m,
		ref Vector4	v,
		out Vector4	result
	)		`[static]`

static function equivalent to TransformProjection(ref Vector4, out Vector4)

Parameters:

m	matrix
v	vector
result	m * v ( divided by W )

void TransformProjection	(	ref Vector3	v,
		out Vector3	result
	)

result = this * v ( divided by W )

Parameters:

v	vector
result	this * v ( divided by W )

static Vector3 TransformProjection	(	Matrix4	m,
		Vector3	v
	)		`[static]`

static function equivalent to TransformProjection(Vector3)

Parameters:

m	matrix
v	vector

Returns:: m * v ( divided by W )

static Vector4 TransformProjection	(	Matrix4	m,
		Vector4	v
	)		`[static]`

static function equivalent to TransformProjection(Vector4)

Parameters:

m	matrix
v	vector

Returns:: m * v ( divided by W )

void TransformProjection	(	ref Vector4	v,
		out Vector4	result
	)

result = this * v ( divided by W )

Parameters:

v	vector
result	this * v ( divided by W )

Vector3 TransformProjection ( Vector3 v )

return this * v ( divided by W )

Parameters:

v vector

Returns:: this * v ( divided by W )

void TransformProjection	(	ref Vector2	v,
		out Vector2	result
	)

result = this * v ( divided by W )

Parameters:

v	vector
result	this * v ( divided by W )

Vector4 TransformProjection ( Vector4 v )

return this * v ( divided by W )

Parameters:

v vector

Returns:: this * v ( divided by W )

static void TransformProjection	(	ref Matrix4	m,
		ref Vector2	v,
		out Vector2	result
	)		`[static]`

static function equivalent to TransformProjection(ref Vector2, out Vector2)

Parameters:

m	matrix
v	vector
result	m * v ( divided by W )

static void TransformProjection	(	ref Matrix4	m,
		ref Vector3	v,
		out Vector3	result
	)		`[static]`

static function equivalent to TransformProjection(ref Vector3, out Vector3)

Parameters:

m	matrix
v	vector
result	m * v ( divided by W )

Vector2 TransformProjection ( Vector2 v )

return this * v ( divided by W )

Parameters:

v vector

Returns:: this * v ( divided by W )

static Vector2 TransformProjection	(	Matrix4	m,
		Vector2	v
	)		`[static]`

static function equivalent to TransformProjection(Vector2)

Parameters:

m	matrix
v	vector

Returns:: m * v ( divided by W )

Vector2 TransformVector ( Vector2 v )

return this * v (X,Y,0,0)

Parameters:

v vector

Returns:: this * v (X,Y,0,0)

static Vector2 TransformVector	(	Matrix4	m,
		Vector2	v
	)		`[static]`

static function equivalent to TransformVector(Vector2)

Parameters:

m	matrix
v	vector

Returns:: m * v (X,Y,0,0)

void TransformVector	(	ref Vector3	v,
		out Vector3	result
	)

result = this * v (X,Y,Z,0)

Parameters:

v	vector
result	this * v (X,Y,Z,0)

static void TransformVector	(	ref Matrix4	m,
		ref Vector3	v,
		out Vector3	result
	)		`[static]`

static function equivalent to TransformVector(ref Vector3, out Vector3)

Parameters:

m	matrix
v	vector
result	m * v (X,Y,Z,0)

static void TransformVector	(	ref Matrix4	m,
		ref Vector2	v,
		out Vector2	result
	)		`[static]`

static function equivalent to TransformVector(ref Vector2, out Vector2)

Parameters:

m	matrix
v	vector
result	m * v (X,Y,0,0)

static Vector3 TransformVector	(	Matrix4	m,
		Vector3	v
	)		`[static]`

static function equivalent to TransformVector(Vector3)

Parameters:

m	matrix
v	vector

Returns:: m * v (X,Y,Z,0)

void TransformVector	(	ref Vector2	v,
		out Vector2	result
	)

result = this * v (X,Y,0,0)

Parameters:

v	vector
result	this * v (X,Y,0,0)

Vector3 TransformVector ( Vector3 v )

return this * v (X,Y,Z,0)

Parameters:

v vector

Returns:: this * v (X,Y,Z,0)

static Matrix4 Translation ( Vector3 translation ) [static]

get a matrix for translating a point

Parameters:

translation a vector containing the x, y, z translation values

Returns:: translation matrix

static void Translation	(	float	x,
		float	y,
		float	z,
		out Matrix4	result
	)		`[static]`

get a matrix for translating a point

Parameters:

x	x translation
y	y translation
z	z translation
result	translation matrix

static Matrix4 Translation	(	float	x,
		float	y,
		float	z
	)		`[static]`

get a matrix for translating a point

Parameters:

x	x translation
y	y translation
z	z translation

Returns:: translation matrix

static void Translation	(	ref Vector2	translation,
		out Matrix4	result
	)		`[static]`

get a matrix for translating a point

Parameters:

translation	a vector containing the x, y translation values
result	translation matrix

static Matrix4 Translation ( Vector2 translation ) [static]

get a matrix for translating a point

Parameters:

translation a vector containing the x, y translation values

Returns:: translation matrix

static void Translation	(	ref Vector3	translation,
		out Matrix4	result
	)		`[static]`

get a matrix for translating a point

Parameters:

translation	a vector containing the x, y, z translation values
result	translation matrix

static void Transpose	(	ref Matrix4	m,
		out Matrix4	result
	)		`[static]`

static function equivalent to Transpose(out Matrix4)

Parameters:

m	matrix
result	matrix transpose

Matrix4 Transpose ( )

get the transpose of the matrix

Returns:: matrix transpose

static Matrix4 Transpose ( Matrix4 m ) [static]

static function equivalent to Transpose()

Parameters:

m matrix

Returns:: matrix transpose

void Transpose ( out Matrix4 result )

get the transpose of the matrix

Parameters:

result matrix transpose

Member Data Documentation

readonly Matrix4 Identity = new Matrix4(Vector4.UnitX, Vector4.UnitY, Vector4.UnitZ, Vector4.UnitW) [static]

identity matrix

float M11

column 1, element 1

float M12

column 1, element 2

float M13

column 1, element 3

float M14

column 1, element 4

float M21

column 2, element 1

float M22

column 2, element 2

float M23

column 2, element 3

float M24

column 2, element 4

float M31

column 3, element 1

float M32

column 3, element 2

float M33

column 3, element 3

float M34

column 3, element 4

float M41

column 4, element 1

float M42

column 4, element 2

float M43

column 4, element 3

float M44

column 4, element 4

readonly Matrix4 Zero = new Matrix4(Vector4.Zero, Vector4.Zero, Vector4.Zero, Vector4.Zero) [static]

a matrix of all zeroes

Property Documentation

Vector3 AxisW [get, set]

XYZ components of ColumnW.

Vector3 AxisX [get, set]

XYZ components of ColumnX.

Vector3 AxisY [get, set]

XYZ components of ColumnY.

Vector3 AxisZ [get, set]

XYZ components of ColumnZ.

Vector4 ColumnW [get, set]

the fourth column in the matrix

Vector4 ColumnX [get, set]

the first column in the matrix

Vector4 ColumnY [get, set]

the second column in the matrix

Vector4 ColumnZ [get, set]

the third column in the matrix

Vector4 RowW [get, set]

the fourth row in the matrix

Vector4 RowX [get, set]

the first row in the matrix

Vector4 RowY [get, set]

the second row in the matrix

Vector4 RowZ [get, set]

the third row in the matrix

Matrix4 Struct Reference

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Properties

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation