matrix.h

environment_mapped_bump_mapping using opengl

#ifndef _MATRIX4_H
#define _MATRIX4_H

/* matica vyzera takto:
  (  m11  m12  m13  m14  )      (  m[ 0]  m[ 4]  m[ 8]  m[12]  )      ( e[0][0] e[1][0] e[2][0] e[3][0] )
  (  m21  m22  m23  m24  ) ---- (  m[ 1]  m[ 5]  m[ 9]  m[13]  ) ---- ( e[0][1] e[1][1] e[2][1] e[3][1] )
  (  m31  m32  m33  m34  ) ---- (  m[ 2]  m[ 6]  m[10]  m[14]  ) ---- ( e[0][2] e[1][2] e[2][2] e[3][2] )
  (  m41  m42  m43  m44  )      (  m[ 3]  m[ 7]  m[11]  m[15]  )      ( e[0][3] e[1][3] e[2][3] e[3][3] )
  v OpenGL sa matice ukladaju nie po riadkoch, ale po stlcoch, t.j. 11,21,31,41,12,22,32,42,...
  mij, i je riadok, j je stlpec  mij == m[ (j-1)*4+i-1 ] == e[j][i]
  CVector sa pouziva ako stlpcovy vektor t.j. CVector = CMatrix4*CVector
*/

#include "Vector.h"
//#include <math.h>

#ifndef PI180
#define PI180	0.0174532925199432957692369076848861f	// pi / 180
#endif

class CMatrix4 
{
public:
	union 
	{
		float m[16];
		float e[4][4];
		struct 
		{
			float m11; float m21; float m31; float m41;
			float m12; float m22; float m32; float m42;
			float m13; float m23; float m33; float m43;
			float m14; float m24; float m34; float m44;
		};
	};

	inline CMatrix4();					// konstruktor, vytvori jednotkovu maticu
	inline CMatrix4( const CMatrix4 &a);	// kopirovaci konstruktor
	// zadanie je po riadkoch, v opacnom porati ako su v OpenGL (tam su po stlpcoch)
	inline CMatrix4( const float Am11, const float Am12, const float Am13, const float Am14,
					 const float Am21, const float Am22, const float Am23, const float Am24,
					 const float Am31, const float Am32, const float Am33, const float Am34,
					 const float Am41, const float Am42, const float Am43, const float Am44);

	inline CMatrix4 operator+() const;		// pozitive
	inline CMatrix4 operator-() const;		// negative

	inline CMatrix4 operator!() const;		// Inverse
	inline CMatrix4 operator~() const;		// Transpose

	inline void operator+= ( const CMatrix4 &a );
	inline void operator-= ( const CMatrix4 &a );
	inline void operator*= ( const CMatrix4 &b );		// sprava
	inline void operator/= ( const CMatrix4 &a );
	inline void operator*= ( const float f );	// vynasobi, kazdy prvok matice s f
	inline void operator/= ( const float f );

	inline friend CMatrix4 operator+ ( const CMatrix4 &a, const CMatrix4 &b );
	inline friend CMatrix4 operator- ( const CMatrix4 &a, const CMatrix4 &b );
	inline friend CMatrix4 operator* ( const CMatrix4 &a, const CMatrix4 &b );
	inline friend CMatrix4 operator/ ( const CMatrix4 &a, const CMatrix4 &b );

	inline friend CMatrix4 operator* ( const CMatrix4 &a, const float f );
	inline friend CMatrix4 operator* ( const float f, const CMatrix4 &a );
	inline friend CMatrix4 operator/ ( const CMatrix4 &a, const float f );
	inline friend CMatrix4 operator/ ( const float f, const CMatrix4 &a );

	inline friend CVector operator*( const CMatrix4 &m, const CVector &v );

	inline float Det2();
	inline float Det3();
	inline float Det4();

	inline void Identity();	
	inline void RotX( const float angle );
	inline void RotY( const float angle );
	inline void RotZ( const float angle );
	inline void Scale( const float x, const float y, const float z );
	inline void Scale( const CVector &V );
	inline void Translate( const float x, const float y, const float z );
	inline void Translate( const CVector &V );
	
	inline void glGetMatrix();
	inline void glSetMatrix() const;
	inline void glMultMatrix() const;

	inline void MakeMatrix( const CVector vr, const CVector vu, const CVector ve );
	inline void Rotate( const CVector &p, const CVector &vec, const float angle);

//	inline void Invert();		// ??
//	void GetEulerAngles( float &xT, float &yT, float &zT );
//	void BuildMirrorPlane( const UPlane plane );
};

inline CMatrix4::CMatrix4()		// konstruktor, vytvori jednotkovu maticu
{
	m11 = 1; m12 = 0; m13 = 0; m14 = 0;	// 1 0 0 0
	m21 = 0; m22 = 1; m23 = 0; m24 = 0;	// 0 1 0 0
	m31 = 0; m32 = 0; m33 = 1; m34 = 0;	// 0 0 1 0
	m41 = 0; m42 = 0; m43 = 0; m44 = 1;	// 0 0 0 1
}

inline CMatrix4::CMatrix4( const CMatrix4 &a)	// kopirovaci konstruktor
{
	for(int i=0; i<16; i++) m[i]=a.m[i];
}

// zadanie je po riadkoch, v opacnom porati ako su v OpenGL (tam su po stlpcoch)
inline CMatrix4::CMatrix4( const float Am11, const float Am12, const float Am13, const float Am14,
						   const float Am21, const float Am22, const float Am23, const float Am24,
						   const float Am31, const float Am32, const float Am33, const float Am34,
						   const float Am41, const float Am42, const float Am43, const float Am44)
{
	m11 = Am11; m12 = Am12; m13 = Am13; m14 = Am14;
	m21 = Am21; m22 = Am22; m23 = Am23; m24 = Am24;
	m31 = Am31; m32 = Am32; m33 = Am33; m34 = Am34;
	m41 = Am41; m42 = Am42; m43 = Am43; m44 = Am44;
}

inline void CMatrix4::Identity()
{
	m11 = 1; m12 = 0; m13 = 0; m14 = 0;	// 1 0 0 0
	m21 = 0; m22 = 1; m23 = 0; m24 = 0;	// 0 1 0 0
	m31 = 0; m32 = 0; m33 = 1; m34 = 0;	// 0 0 1 0
	m41 = 0; m42 = 0; m43 = 0; m44 = 1;	// 0 0 0 1
}

inline CMatrix4 CMatrix4::operator+() const
{	return *this;}

inline CMatrix4 CMatrix4::operator-() const
{
	return CMatrix4( -m11, -m12, -m13, -m14,
					 -m21, -m22, -m23, -m24,
					 -m31, -m32, -m33, -m34,
					 -m41, -m42, -m43, -m44 );
}

inline CMatrix4 CMatrix4::operator!() const		// Inverse ???
{
	CMatrix4 A;

	const float M3344 = m33 * m44 - m34 * m43;
	const float M3244 = m32 * m44 - m34 * m42;
	const float M3243 = m32 * m43 - m33 * m42;
	const float M2344 = m23 * m44 - m24 * m43;
	const float M2244 = m22 * m44 - m24 * m42;
	const float M2243 = m22 * m43 - m23 * m42;
	const float M2334 = m23 * m34 - m24 * m33;
	const float M2234 = m22 * m34 - m24 * m32;
	const float M2233 = m22 * m33 - m23 * m32;
	const float M3144 = m31 * m44 - m34 * m41;
	const float M3143 = m31 * m43 - m33 * m41;
	const float M2144 = m21 * m44 - m24 * m41;
	const float M2143 = m21 * m43 - m23 * m41;
	const float M2134 = m21 * m34 - m24 * m31;
	const float M2133 = m21 * m33 - m23 * m31;
	const float M3142 = m31 * m42 - m32 * m41;
	const float M2142 = m21 * m42 - m22 * m41;
	const float M2132 = m21 * m32 - m22 * m31;

	A.m11 =  m22 * M3344 - m23 * M3244 + m24 * M3243;
	A.m12 = -m12 * M3344 + m13 * M3244 - m14 * M3243;
	A.m13 =  m12 * M2344 - m13 * M2244 + m14 * M2243;
	A.m14 = -m12 * M2334 + m13 * M2234 - m14 * M2233;

	A.m21 = -m21 * M3344 + m23 * M3144 - m24 * M3143;
	A.m22 =  m11 * M3344 - m13 * M3144 + m14 * M3143;
	A.m23 = -m11 * M2344 + m13 * M2144 - m14 * M2143;
	A.m24 =  m11 * M2334 - m13 * M2134 + m14 * M2133;

	A.m31 =  m21 * M3244 - m22 * M3144 + m24 * M3142;
	A.m32 = -m11 * M3244 + m12 * M3144 - m14 * M3142;
	A.m33 =  m11 * M2244 - m12 * M2144 + m14 * M2142;
	A.m34 = -m11 * M2234 + m12 * M2134 - m14 * M2132;

	A.m41 = -m21 * M3243 + m22 * M3143 - m23 * M3142;
	A.m42 =  m11 * M3243 - m12 * M3143 + m13 * M3142;
	A.m43 = -m11 * M2243 + m12 * M2143 - m13 * M2142;
	A.m44 =  m11 * M2233 - m12 * M2133 + m13 * M2132;

	A /= m11 * A.m11 + m12 * A.m21 + m13 * A.m31 + m14 * A.m41;   // Determinant
	return A;
}

inline CMatrix4 CMatrix4::operator~() const		// Transpose
{
	return CMatrix4(m11, m21, m31, m41,
					m12, m22, m32, m42,
					m13, m23, m33, m43,
					m14, m24, m34, m44 );
}

inline void CMatrix4::operator+= ( const CMatrix4 &a )
{
	for(int i=0; i < 16; i++) m[i] += a.m[i];
}

inline void CMatrix4::operator-= ( const CMatrix4 &a )
{
	for(int i=0; i < 16; i++) m[i] -= a.m[i];
}

inline void CMatrix4::operator*= ( const CMatrix4 &b )
{
	CMatrix4 a(*this);

	m11 = a.m11*b.m11 + a.m12*b.m21 + a.m13*b.m31 + a.m14*b.m41;
	m12 = a.m11*b.m12 + a.m12*b.m22 + a.m13*b.m32 + a.m14*b.m42;
	m13 = a.m11*b.m13 + a.m12*b.m23 + a.m13*b.m33 + a.m14*b.m43;
	m14 = a.m11*b.m14 + a.m12*b.m24 + a.m13*b.m34 + a.m14*b.m44;

	m21 = a.m21*b.m11 + a.m22*b.m21 + a.m23*b.m31 + a.m24*b.m41;
	m22 = a.m21*b.m12 + a.m22*b.m22 + a.m23*b.m32 + a.m24*b.m42;
	m23 = a.m21*b.m13 + a.m22*b.m23 + a.m23*b.m33 + a.m24*b.m43;
	m24 = a.m21*b.m14 + a.m22*b.m24 + a.m23*b.m34 + a.m24*b.m44;

	m31 = a.m31*b.m11 + a.m32*b.m21 + a.m33*b.m31 + a.m34*b.m41;
	m32 = a.m31*b.m12 + a.m32*b.m22 + a.m33*b.m32 + a.m34*b.m42;
	m33 = a.m31*b.m13 + a.m32*b.m23 + a.m33*b.m33 + a.m34*b.m43;
	m34 = a.m31*b.m14 + a.m32*b.m24 + a.m33*b.m34 + a.m34*b.m44;

	m41 = a.m41*b.m11 + a.m42*b.m21 + a.m43*b.m31 + a.m44*b.m41;
	m42 = a.m41*b.m12 + a.m42*b.m22 + a.m43*b.m32 + a.m44*b.m42;
	m43 = a.m41*b.m13 + a.m42*b.m23 + a.m43*b.m33 + a.m44*b.m43;
	m44 = a.m41*b.m14 + a.m42*b.m24 + a.m43*b.m34 + a.m44*b.m44;
}

inline void CMatrix4::operator/= ( const CMatrix4 &a )
{	*this *= !a;}

inline void CMatrix4::operator *= (float f)
{
	for(int i=0; i < 16; i++) m[i] *= f;
}

inline void CMatrix4::operator /= (float f)
{
	float d=1.0f/f;
	for(int i=0; i < 16; i++) m[i] *= d;
}

inline CMatrix4 operator+ ( const CMatrix4 &a, const CMatrix4 &b )
{
	return CMatrix4( a.m11 + b.m11, a.m12 + b.m12, a.m13 + b.m13, a.m14 + b.m14,
					 a.m21 + b.m21, a.m22 + b.m22, a.m23 + b.m23, a.m24 + b.m24,
					 a.m31 + b.m31, a.m32 + b.m32, a.m33 + b.m33, a.m34 + b.m34,
					 a.m41 + b.m41, a.m42 + b.m42, a.m43 + b.m43, a.m44 + b.m44 );
}

inline CMatrix4 operator- ( const CMatrix4 &a, const CMatrix4 &b )
{
	return CMatrix4( a.m11 - b.m11, a.m12 - b.m12, a.m13 - b.m13, a.m14 - b.m14,
					 a.m21 - b.m21, a.m22 - b.m22, a.m23 - b.m23, a.m24 - b.m24,
					 a.m31 - b.m31, a.m32 - b.m32, a.m33 - b.m33, a.m34 - b.m34,
					 a.m41 - b.m41, a.m42 - b.m42, a.m43 - b.m43, a.m44 - b.m44 );
}
inline CMatrix4 operator* ( const CMatrix4 &a, const CMatrix4 &b )
{
	CMatrix4 c;
	
	c.m11 = a.m11*b.m11 + a.m12*b.m21 + a.m13*b.m31 + a.m14*b.m41;
	c.m12 = a.m11*b.m12 + a.m12*b.m22 + a.m13*b.m32 + a.m14*b.m42;
	c.m13 = a.m11*b.m13 + a.m12*b.m23 + a.m13*b.m33 + a.m14*b.m43;
	c.m14 = a.m11*b.m14 + a.m12*b.m24 + a.m13*b.m34 + a.m14*b.m44;

	c.m21 = a.m21*b.m11 + a.m22*b.m21 + a.m23*b.m31 + a.m24*b.m41;
	c.m22 = a.m21*b.m12 + a.m22*b.m22 + a.m23*b.m32 + a.m24*b.m42;
	c.m23 = a.m21*b.m13 + a.m22*b.m23 + a.m23*b.m33 + a.m24*b.m43;
	c.m24 = a.m21*b.m14 + a.m22*b.m24 + a.m23*b.m34 + a.m24*b.m44;

	c.m31 = a.m31*b.m11 + a.m32*b.m21 + a.m33*b.m31 + a.m34*b.m41;
	c.m32 = a.m31*b.m12 + a.m32*b.m22 + a.m33*b.m32 + a.m34*b.m42;
	c.m33 = a.m31*b.m13 + a.m32*b.m23 + a.m33*b.m33 + a.m34*b.m43;
	c.m34 = a.m31*b.m14 + a.m32*b.m24 + a.m33*b.m34 + a.m34*b.m44;

	c.m41 = a.m41*b.m11 + a.m42*b.m21 + a.m43*b.m31 + a.m44*b.m41;
	c.m42 = a.m41*b.m12 + a.m42*b.m22 + a.m43*b.m32 + a.m44*b.m42;
	c.m43 = a.m41*b.m13 + a.m42*b.m23 + a.m43*b.m33 + a.m44*b.m43;
	c.m44 = a.m41*b.m14 + a.m42*b.m24 + a.m43*b.m34 + a.m44*b.m44;
	return c;
}

inline CMatrix4 operator/ ( const CMatrix4 &a, const CMatrix4 &b )
{
	return a * !b;
}

inline CMatrix4 operator* ( const CMatrix4 &a, const float f )
{
	return CMatrix4( a.m11*f, a.m12*f, a.m13*f, a.m14*f,
					 a.m21*f, a.m22*f, a.m23*f, a.m24*f,
					 a.m31*f, a.m32*f, a.m33*f, a.m34*f,
					 a.m41*f, a.m42*f, a.m43*f, a.m44*f );
}
inline CMatrix4 operator* ( const float f, const CMatrix4 &a )
{
	return CMatrix4( a.m11*f, a.m12*f, a.m13*f, a.m14*f,
					 a.m21*f, a.m22*f, a.m23*f, a.m24*f,
					 a.m31*f, a.m32*f, a.m33*f, a.m34*f,
					 a.m41*f, a.m42*f, a.m43*f, a.m44*f );
}
inline CMatrix4 operator/ ( const CMatrix4 &a, const float f )
{
	float f_ = 1.0f/f;
	return CMatrix4( a.m11*f_, a.m12*f_, a.m13*f_, a.m14*f_,
					 a.m21*f_, a.m22*f_, a.m23*f_, a.m24*f_,
					 a.m31*f_, a.m32*f_, a.m33*f_, a.m34*f_,
					 a.m41*f_, a.m42*f_, a.m43*f_, a.m44*f_ );
}
inline CMatrix4 operator/ ( const float f, const CMatrix4 &a )
{
	return f * !a;
}

inline CVector operator*( const CMatrix4 &m, const CVector &v )
{																// m11 m12 m13 m14   v.x
	return CVector( m.m11*v.x + m.m12*v.y + m.m13*v.z + m.m14,	// m21 m22 m23 m24 X v.y
					m.m21*v.x + m.m22*v.y + m.m23*v.z + m.m24,	// m31 m32 m33 m34   v.z
					m.m31*v.x + m.m32*v.y + m.m33*v.z + m.m34 );// m41 m42 m43 m44   1.0f
}

inline float CMatrix4::Det2() 
{
	return m11 * m22 - m12 * m21; 
}

inline float CMatrix4::Det3() 
{
	return	m11 * (m22 * m33 - m32 * m23) -
			m21 * (m12 * m33 - m32 * m13) +
			m31 * (m12 * m23 - m22 * m13);
}