icematrix3x3.h

来自「opcode是功能强大」· C头文件 代码 · 共 497 行 · 第 1/2 页

									m[0][1] = a.m[0][0] * b.m[1][0] + a.m[0][1] * b.m[1][1] + a.m[0][2] * b.m[1][2];
									m[0][2] = a.m[0][0] * b.m[2][0] + a.m[0][1] * b.m[2][1] + a.m[0][2] * b.m[2][2];
									m[1][0] = a.m[1][0] * b.m[0][0] + a.m[1][1] * b.m[0][1] + a.m[1][2] * b.m[0][2];
									m[1][1] = a.m[1][0] * b.m[1][0] + a.m[1][1] * b.m[1][1] + a.m[1][2] * b.m[1][2];
									m[1][2] = a.m[1][0] * b.m[2][0] + a.m[1][1] * b.m[2][1] + a.m[1][2] * b.m[2][2];
									m[2][0] = a.m[2][0] * b.m[0][0] + a.m[2][1] * b.m[0][1] + a.m[2][2] * b.m[0][2];
									m[2][1] = a.m[2][0] * b.m[1][0] + a.m[2][1] * b.m[1][1] + a.m[2][2] * b.m[1][2];
									m[2][2] = a.m[2][0] * b.m[2][0] + a.m[2][1] * b.m[2][1] + a.m[2][2] * b.m[2][2];
								}

		//! Makes a rotation matrix mapping vector "from" to vector "to".
				Matrix3x3&		FromTo(const Point& from, const Point& to);

		//! Set a rotation matrix around the X axis.
		//!		 1		0		0
		//!	RX = 0		cx		sx
		//!		 0		-sx		cx
				void			RotX(float angle);
		//! Set a rotation matrix around the Y axis.
		//!		 cy		0		-sy
		//!	RY = 0		1		0
		//!		 sy		0		cy
				void			RotY(float angle);
		//! Set a rotation matrix around the Z axis.
		//!		 cz		sz		0
		//!	RZ = -sz	cz		0
		//!		 0		0		1
				void			RotZ(float angle);
		//!			cy		sx.sy		-sy.cx
		//!	RY.RX	0		cx			sx
		//!			sy		-sx.cy		cx.cy
				void			RotYX(float y, float x);

		//! Make a rotation matrix about an arbitrary axis
				Matrix3x3&		Rot(float angle, const Point& axis);

		//! Transpose the matrix.
				void			Transpose()
								{
									IR(m[1][0]) ^= IR(m[0][1]);	IR(m[0][1]) ^= IR(m[1][0]);	IR(m[1][0]) ^= IR(m[0][1]);
									IR(m[2][0]) ^= IR(m[0][2]);	IR(m[0][2]) ^= IR(m[2][0]);	IR(m[2][0]) ^= IR(m[0][2]);
									IR(m[2][1]) ^= IR(m[1][2]);	IR(m[1][2]) ^= IR(m[2][1]);	IR(m[2][1]) ^= IR(m[1][2]);
								}

		//! this = Transpose(a)
				void			Transpose(const Matrix3x3& a)
								{
									m[0][0] = a.m[0][0];	m[0][1] = a.m[1][0];	m[0][2] = a.m[2][0];
									m[1][0] = a.m[0][1];	m[1][1] = a.m[1][1];	m[1][2] = a.m[2][1];
									m[2][0] = a.m[0][2];	m[2][1] = a.m[1][2];	m[2][2] = a.m[2][2];
								}

		//! Compute the determinant of the matrix. We use the rule of Sarrus.
				float			Determinant()					const
								{
									return (m[0][0]*m[1][1]*m[2][2] + m[0][1]*m[1][2]*m[2][0] + m[0][2]*m[1][0]*m[2][1])
										-  (m[2][0]*m[1][1]*m[0][2] + m[2][1]*m[1][2]*m[0][0] + m[2][2]*m[1][0]*m[0][1]);
								}
/*
		//! Compute a cofactor. Used for matrix inversion.
				float			CoFactor(ubyte row, ubyte column)	const
				{
					static sdword gIndex[3+2] = { 0, 1, 2, 0, 1 };
					return	(m[gIndex[row+1]][gIndex[column+1]]*m[gIndex[row+2]][gIndex[column+2]] - m[gIndex[row+2]][gIndex[column+1]]*m[gIndex[row+1]][gIndex[column+2]]);
				}
*/
		//! Invert the matrix. Determinant must be different from zero, else matrix can't be inverted.
				Matrix3x3&		Invert()
								{
									float Det = Determinant();	// Must be !=0
									float OneOverDet = 1.0f / Det;

									Matrix3x3 Temp;
									Temp.m[0][0] = +(m[1][1] * m[2][2] - m[2][1] * m[1][2]) * OneOverDet;
									Temp.m[1][0] = -(m[1][0] * m[2][2] - m[2][0] * m[1][2]) * OneOverDet;
									Temp.m[2][0] = +(m[1][0] * m[2][1] - m[2][0] * m[1][1]) * OneOverDet;
									Temp.m[0][1] = -(m[0][1] * m[2][2] - m[2][1] * m[0][2]) * OneOverDet;
									Temp.m[1][1] = +(m[0][0] * m[2][2] - m[2][0] * m[0][2]) * OneOverDet;
									Temp.m[2][1] = -(m[0][0] * m[2][1] - m[2][0] * m[0][1]) * OneOverDet;
									Temp.m[0][2] = +(m[0][1] * m[1][2] - m[1][1] * m[0][2]) * OneOverDet;
									Temp.m[1][2] = -(m[0][0] * m[1][2] - m[1][0] * m[0][2]) * OneOverDet;
									Temp.m[2][2] = +(m[0][0] * m[1][1] - m[1][0] * m[0][1]) * OneOverDet;

									*this = Temp;

									return	*this;
								}

				Matrix3x3&		Normalize();

		//! this = exp(a)
				Matrix3x3&		Exp(const Matrix3x3& a);

void FromQuat(const Quat &q);
void FromQuatL2(const Quat &q, float l2);

		// Arithmetic operators
		//! Operator for Matrix3x3 Plus = Matrix3x3 + Matrix3x3;
		inline_	Matrix3x3		operator+(const Matrix3x3& mat)	const
								{
									return Matrix3x3(
									m[0][0] + mat.m[0][0],	m[0][1] + mat.m[0][1],	m[0][2] + mat.m[0][2],
									m[1][0] + mat.m[1][0],	m[1][1] + mat.m[1][1],	m[1][2] + mat.m[1][2],
									m[2][0] + mat.m[2][0],	m[2][1] + mat.m[2][1],	m[2][2] + mat.m[2][2]);
								}

		//! Operator for Matrix3x3 Minus = Matrix3x3 - Matrix3x3;
		inline_	Matrix3x3		operator-(const Matrix3x3& mat)	const
								{
									return Matrix3x3(
									m[0][0] - mat.m[0][0],	m[0][1] - mat.m[0][1],	m[0][2] - mat.m[0][2],
									m[1][0] - mat.m[1][0],	m[1][1] - mat.m[1][1],	m[1][2] - mat.m[1][2],
									m[2][0] - mat.m[2][0],	m[2][1] - mat.m[2][1],	m[2][2] - mat.m[2][2]);
								}

		//! Operator for Matrix3x3 Mul = Matrix3x3 * Matrix3x3;
		inline_	Matrix3x3		operator*(const Matrix3x3& mat)	const
								{
									return Matrix3x3(
									m[0][0]*mat.m[0][0] + m[0][1]*mat.m[1][0] + m[0][2]*mat.m[2][0],
									m[0][0]*mat.m[0][1] + m[0][1]*mat.m[1][1] + m[0][2]*mat.m[2][1],
									m[0][0]*mat.m[0][2] + m[0][1]*mat.m[1][2] + m[0][2]*mat.m[2][2],

									m[1][0]*mat.m[0][0] + m[1][1]*mat.m[1][0] + m[1][2]*mat.m[2][0],
									m[1][0]*mat.m[0][1] + m[1][1]*mat.m[1][1] + m[1][2]*mat.m[2][1],
									m[1][0]*mat.m[0][2] + m[1][1]*mat.m[1][2] + m[1][2]*mat.m[2][2],

									m[2][0]*mat.m[0][0] + m[2][1]*mat.m[1][0] + m[2][2]*mat.m[2][0],
									m[2][0]*mat.m[0][1] + m[2][1]*mat.m[1][1] + m[2][2]*mat.m[2][1],
									m[2][0]*mat.m[0][2] + m[2][1]*mat.m[1][2] + m[2][2]*mat.m[2][2]);
								}

		//! Operator for Point Mul = Matrix3x3 * Point;
		inline_	Point			operator*(const Point& v)		const		{ return Point(GetRow(0)|v, GetRow(1)|v, GetRow(2)|v); }

		//! Operator for Matrix3x3 Mul = Matrix3x3 * float;
		inline_	Matrix3x3		operator*(float s)				const
								{
									return Matrix3x3(
									m[0][0]*s,	m[0][1]*s,	m[0][2]*s,
									m[1][0]*s,	m[1][1]*s,	m[1][2]*s,
									m[2][0]*s,	m[2][1]*s,	m[2][2]*s);
								}

		//! Operator for Matrix3x3 Mul = float * Matrix3x3;
		inline_	friend Matrix3x3 operator*(float s, const Matrix3x3& mat)
								{
									return Matrix3x3(
									s*mat.m[0][0],	s*mat.m[0][1],	s*mat.m[0][2],
									s*mat.m[1][0],	s*mat.m[1][1],	s*mat.m[1][2],
									s*mat.m[2][0],	s*mat.m[2][1],	s*mat.m[2][2]);
								}

		//! Operator for Matrix3x3 Div = Matrix3x3 / float;
		inline_	Matrix3x3		operator/(float s)				const
								{
									if (s)	s = 1.0f / s;
									return Matrix3x3(
									m[0][0]*s,	m[0][1]*s,	m[0][2]*s,
									m[1][0]*s,	m[1][1]*s,	m[1][2]*s,
									m[2][0]*s,	m[2][1]*s,	m[2][2]*s);
								}

		//! Operator for Matrix3x3 Div = float / Matrix3x3;
		inline_	friend Matrix3x3 operator/(float s, const Matrix3x3& mat)
								{
									return Matrix3x3(
									s/mat.m[0][0],	s/mat.m[0][1],	s/mat.m[0][2],
									s/mat.m[1][0],	s/mat.m[1][1],	s/mat.m[1][2],
									s/mat.m[2][0],	s/mat.m[2][1],	s/mat.m[2][2]);
								}

		//! Operator for Matrix3x3 += Matrix3x3
		inline_	Matrix3x3&		operator+=(const Matrix3x3& mat)
								{
									m[0][0] += mat.m[0][0];		m[0][1] += mat.m[0][1];		m[0][2] += mat.m[0][2];
									m[1][0] += mat.m[1][0];		m[1][1] += mat.m[1][1];		m[1][2] += mat.m[1][2];
									m[2][0] += mat.m[2][0];		m[2][1] += mat.m[2][1];		m[2][2] += mat.m[2][2];
									return	*this;
								}

		//! Operator for Matrix3x3 -= Matrix3x3
		inline_	Matrix3x3&		operator-=(const Matrix3x3& mat)
								{
									m[0][0] -= mat.m[0][0];		m[0][1] -= mat.m[0][1];		m[0][2] -= mat.m[0][2];
									m[1][0] -= mat.m[1][0];		m[1][1] -= mat.m[1][1];		m[1][2] -= mat.m[1][2];
									m[2][0] -= mat.m[2][0];		m[2][1] -= mat.m[2][1];		m[2][2] -= mat.m[2][2];
									return	*this;
								}

		//! Operator for Matrix3x3 *= Matrix3x3
		inline_	Matrix3x3&		operator*=(const Matrix3x3& mat)
								{
									Point TempRow;

									GetRow(0, TempRow);
									m[0][0] = TempRow.x*mat.m[0][0] + TempRow.y*mat.m[1][0] + TempRow.z*mat.m[2][0];
									m[0][1] = TempRow.x*mat.m[0][1] + TempRow.y*mat.m[1][1] + TempRow.z*mat.m[2][1];
									m[0][2] = TempRow.x*mat.m[0][2] + TempRow.y*mat.m[1][2] + TempRow.z*mat.m[2][2];

									GetRow(1, TempRow);
									m[1][0] = TempRow.x*mat.m[0][0] + TempRow.y*mat.m[1][0] + TempRow.z*mat.m[2][0];
									m[1][1] = TempRow.x*mat.m[0][1] + TempRow.y*mat.m[1][1] + TempRow.z*mat.m[2][1];
									m[1][2] = TempRow.x*mat.m[0][2] + TempRow.y*mat.m[1][2] + TempRow.z*mat.m[2][2];

									GetRow(2, TempRow);
									m[2][0] = TempRow.x*mat.m[0][0] + TempRow.y*mat.m[1][0] + TempRow.z*mat.m[2][0];
									m[2][1] = TempRow.x*mat.m[0][1] + TempRow.y*mat.m[1][1] + TempRow.z*mat.m[2][1];
									m[2][2] = TempRow.x*mat.m[0][2] + TempRow.y*mat.m[1][2] + TempRow.z*mat.m[2][2];
									return	*this;
								}

		//! Operator for Matrix3x3 *= float
		inline_	Matrix3x3&		operator*=(float s)
								{
									m[0][0] *= s;	m[0][1] *= s;	m[0][2] *= s;
									m[1][0] *= s;	m[1][1] *= s;	m[1][2] *= s;
									m[2][0] *= s;	m[2][1] *= s;	m[2][2] *= s;
									return	*this;
								}

		//! Operator for Matrix3x3 /= float
		inline_	Matrix3x3&		operator/=(float s)
								{
									if (s)	s = 1.0f / s;
									m[0][0] *= s;	m[0][1] *= s;	m[0][2] *= s;
									m[1][0] *= s;	m[1][1] *= s;	m[1][2] *= s;
									m[2][0] *= s;	m[2][1] *= s;	m[2][2] *= s;
									return	*this;
								}

		// Cast operators
		//! Cast a Matrix3x3 to a Matrix4x4.
								operator Matrix4x4()	const;
		//! Cast a Matrix3x3 to a Quat.
								operator Quat()			const;

		inline_	const Point&	operator[](int row)		const	{ return *(const Point*)&m[row][0];	}
		inline_	Point&			operator[](int row)				{ return *(Point*)&m[row][0];		}

		public:

				float			m[3][3];
	};

#endif // __ICEMATRIX3X3_H__