matrix.h

environment_mapped_bump_mapping using opengl

inline float CMatrix4::Det4()
{
	const float M3344 = m33 * m44 - m43 * m34;
	const float M2344 = m23 * m44 - m43 * m24;
	const float M2334 = m23 * m34 - m33 * m24;
	const float M1344 = m13 * m44 - m43 * m14;
	const float M1334 = m13 * m34 - m33 * m14;
	const float M1324 = m13 * m24 - m23 * m14;	
	return	m11 * (m22 * M3344 - m32 * M2344 + m42 * M2334) -
			m21 * (m12 * M3344 - m32 * M1344 + m42 * M1334) +
			m31 * (m12 * M2344 - m22 * M1344 + m42 * M1324) -
			m41 * (m12 * M2334 - m22 * M1334 + m32 * M1324);
}

inline void CMatrix4::RotX( const float angle )
{
	const float c = (float) cos( PI180*angle );
	const float s = (float) sin( PI180*angle );
	CMatrix4 m(*this);

	m.m12 =  c*m12 + s*m13;	m.m13 = -s*m12 + c*m13;		// 1  0  0  0
	m.m22 =  c*m22 + s*m23;	m.m23 = -s*m22 + c*m23;		// 0  c -s  0
	m.m32 =  c*m32 + s*m33;	m.m33 = -s*m32 + c*m33;		// 0  s  c  0
	m.m42 =  c*m42 + s*m43;	m.m43 = -s*m42 + c*m43;		// 0  0  0  1
	*this = m;
}

inline void CMatrix4::RotY( const float angle )
{
	const float c = (float) cos( PI180*angle );
	const float s = (float) sin( PI180*angle );
	CMatrix4 m(*this);

	m.m11 = c*m11 - s*m13;	m.m13 = s*m11 + c*m13;	// c  0  s  0
	m.m21 = c*m21 - s*m23;	m.m23 = s*m21 + c*m23;	// 0  1  0  0
	m.m31 = c*m31 - s*m33;	m.m33 = s*m31 + c*m33;	//-s  0  c  0
	m.m41 = c*m41 - s*m43;	m.m43 = s*m41 + c*m43;	// 0  0  0  1
	*this = m;
}

inline void CMatrix4::RotZ( const float angle )
{
	const float c = (float) cos( PI180*angle );
	const float s = (float) sin( PI180*angle );
	CMatrix4 m(*this);
	m.m11 = c*m11 + s*m12;	m.m12 = -s*m11 + c*m12;	// c -s  0  0
	m.m21 = c*m21 + s*m22;	m.m22 = -s*m21 + c*m22;	// s  c  0  0
	m.m31 = c*m31 + s*m32;	m.m32 = -s*m31 + c*m32;	// 0  0  1  0
	m.m41 = c*m41 + s*m42;	m.m42 = -s*m41 + c*m42;	// 0  0  0  1
	*this = m;
}

inline void CMatrix4::Scale( const float x, const float y, const float z )
{
	m11 *= x;	m12 *= y;	m13 *= z;	// x 0 0 0
	m21 *= x;	m22 *= y;	m23 *= z;	// 0 y 0 0
	m31 *= x;	m32 *= y;	m33 *= z;	// 0 0 z 0
	m41 *= x;	m42 *= y;	m43 *= z;	// 0 0 0 1
}
inline void CMatrix4::Scale( const CVector &V )
{
	m11 *= V.x;	m12 *= V.y;	m13 *= V.z;	// x 0 0 0
	m21 *= V.x;	m22 *= V.y;	m23 *= V.z;	// 0 y 0 0
	m31 *= V.x;	m32 *= V.y;	m33 *= V.z;	// 0 0 z 0
	m41 *= V.x;	m42 *= V.y;	m43 *= V.z;	// 0 0 0 1
}

inline void CMatrix4::Translate( const float x, const float y, const float z )
{
	m14 += m11*x + m12*y + m13*z;	// 1 0 0 x
	m24 += m21*x + m22*y + m23*z;	// 0 1 0 y
	m34 += m31*x + m32*y + m33*z;	// 0 0 1 z
	m44 += m41*x + m42*y + m43*z;	// 0 0 0 1
}
inline void CMatrix4::Translate( const CVector &V )
{
	m14 += m11*V.x + m12*V.y + m13*V.z;	// 1 0 0 V.x
	m24 += m21*V.x + m22*V.y + m23*V.z;	// 0 1 0 V.y
	m34 += m31*V.x + m32*V.y + m33*V.z;	// 0 0 1 V.z
	m44 += m41*V.x + m42*V.y + m43*V.z;	// 0 0 0 1
}

inline void CMatrix4::glGetMatrix(){glGetFloatv( GL_MODELVIEW_MATRIX, m);}
inline void CMatrix4::glSetMatrix() const {glLoadMatrixf( m);}
inline void CMatrix4::glMultMatrix() const {glMultMatrixf( m);}

// vytvori maticu m pre ktoru plati (v pripade, ze m14, m24, m34 == 0):
// m*vr = CVector(1,0,0)
// m*vu = CVector(0,1,0)
// m*ve = CVector(0,0,1)
// m*CVector(1,0,0) = CVector(vr.x, vu.x, ve.x)
// m*CVector(0,1,0) = CVector(vr.y, vu.y, ve.y)
// m*CVector(0,0,1) = CVector(vr.z, vu.z, ve.z)
// matica otoci vektor vr na os x, vu na os y a ve na os z

// matica mT = ~m (transponovana matica) (v pripade ze m14, m24, m34 == 0) 
// nam otoci os x na vr, os y na vu a os z na ve
// mT*CVector(1,0,0) = vr
// mT*CVector(0,1,0) = vu
// mT*CVector(0,0,1) = ve

// vr - vector right - vektor smerujuci vpravo
// vu - vector up    - vektor smerujuci hore
// ve - vector eye   - vektor smerujuci k ociam
// vektory musia byt normalizovane !

inline void CMatrix4::MakeMatrix( const CVector vr, const CVector vu, const CVector ve)
{
	m11 = vr.x;		m12 = vr.y;		m13 = vr.z;
	m21 = vu.x;		m22 = vu.y;		m23 = vu.z;
	m31 = ve.x;		m32 = ve.y;		m33 = ve.z;
}

inline void CMatrix4::Rotate( const CVector &p, const CVector &vec, const float angle)
{
	CVector v(vec);		// 2 krat rychlejsi
	v.Normalise();
	CMatrix4 s,u,I;

	// u = vvT
	u.m11 = v.x*v.x;	u.m12 = v.x*v.y;	u.m13 = v.x*v.z;
	u.m21 = v.y*v.x;	u.m22 = v.y*v.y;	u.m23 = v.y*v.z;
	u.m31 = v.z*v.x;	u.m32 = v.z*v.y;	u.m33 = v.z*v.z;
	u.m44 = 0;

	v *= (float)sin( angle*PI180);

	I.m44 = 0;
	s.m11 =    0;	s.m12 = -v.z;	s.m13 =  v.y;
	s.m21 =  v.z;	s.m22 =    0;	s.m23 = -v.x;
	s.m31 = -v.y;	s.m32 =  v.x;	s.m33 =    0;
	s.m44 = 0;

	//	R = vvT + cos(uhol)*(I-vvT) + sin(uhol)*s
	*this = u + (float)cos(angle*PI180)*(I-u) + s;
	m44 = 1;

/*	CMatrix4 T,Rx,Ry,Rz,Ryi,Rxi,Ti;
	CVector v(vec);
	float a;

	T.Translate( -p );		// posunutie do bodu -p
	Ti.Translate( p );		// posunutie do bodu p

	v.Normalise();
	a = (float) sqrt( v.y*v.y + v.z*v.z);		// a - velkost vektora premietnutneho do yz

	if(a!=0)				// ak a==0 nema zmysel rotovat okolo x, pretoze v=(1,0,0)
	{
		// 1. rotacia v okolo x tak aby sa v dostal do roviny xz
		//  v\   | y   v sa ma dostat na z (xz), uhol pre rotaciu je uhol medzi v a z
		//    \  |     velkost v v tomto priemete je a
		//     \ |     sin = v.y/a
		//      \|     cos = v.z/a = [(0, v.y, v.z)dot(0, 0, v.z)]/[a*v.z]
		// z-----+                         (  1    0     0  )
		// rotacna matica pre rotaciu x :  (  0   cos  -sin )
		//                                 (  0   sin   cos )
		Rx.m22 = v.z/a; Rx.m23 =-v.y/a;
		Rx.m32 = v.y/a; Rx.m33 = v.z/a;

		Rxi.m22 = v.z/a; Rxi.m23 = v.y/a;
		Rxi.m32 =-v.y/a; Rxi.m33 = v.z/a;
	}
	// 2. rotacia v okolo osi y tak aby sa v stotoznil so z
	//        ^ y           vektor v je uz v rovine xz
	//        |             v budeme rotavat okolo osi y, tak aby sa stotoznil so z
	//        |             -----+----- x  vektor v rotujeme v smere pravotocivej skrutky okolo osi y
	//        +----- x     -x   /|         velkost vektora je v je 1 = (v.x^2+a^2)^0.5
	//       / \               / |         sin = -v.x
	//      /   \             /  |         cos = a
	//    z/     \v         v/   | z                           (  cos  0  sin )
	//                          rotacna matica pre rotaciu y : (   0   1   0  )
	//                                                         ( -sin  0  cos )
	Ry.m11 = a;    Ry.m13 = -v.x;
	Ry.m31 = v.x;  Ry.m33 = a;
	
	Ryi.m11 = a;    Ryi.m13 = v.x;
	Ryi.m31 = -v.x; Ryi.m33 = a;
	
	// 3. rotacia okolo z o uhol angle
	Rz.RotZ( angle);

	*this = Ti*Rxi*Ryi*Rz*Ry*Rx*T;*/
}

/*
inline void CMatrix4::Invert()
{
    float a,b,c,d,e,f,g,h,i,j,k,l;
    float dW;

    a = m[ 0];	b = m[ 1];	c = m[ 2];
    d = m[ 4];	e = m[ 5];	f = m[ 6];
    g = m[ 8];	h = m[ 9];	i = m[10];
    j = m[12];	k = m[13];	l = m[14];

    dW = 1.0f / ( a*(e*i - f*h) - ( b*(d*i - f*g) + c*(e*g - d*h) ) );

    m[ 0]= (e*i - f*h) * dW;
    m[ 1]= (c*h - b*i) * dW;
    m[ 2]= (b*f - c*e) * dW;

    m[ 4]= (f*g - d*i) * dW;
    m[ 5]= (a*i - c*g) * dW;
    m[ 6]= (c*d - a*f) * dW;

    m[ 8]= (d*h - e*g) * dW;
    m[ 9]= (b*g - a*h) * dW;
    m[10]= (a*e - b*d) * dW;

    m[12]= ((e*(g*l - i*j) + f*(h*j - g*k) - d*(h*l - i*k)) * dW);
	m[13]= ((a*(h*l - i*k) + b*(i*j - g*l) + c*(g*k - h*j)) * dW);
	m[14]= ((b*(d*l - f*j) + c*(e*j - d*k) - a*(e*l - f*k)) * dW);
}
*/
/*
void CMatrix4::GetEulerAngles( float &xT, float &yT, float &zT )
{
	float angleX, angleY, angleZ;
	angleY = arctan2( m13, FastSqrt(m23*m23+m33*m33) );
	float cosangleY = cosf( angleY );

	if ( absf(cosangleY) > EPSILON ) {
		angleZ = arctan2(-m12/cosangleY, m11/cosangleY);
		angleX = arctan2(-m23/cosangleY, m33/cosangleY);
	} else {
		if ( absf(PIhalf-angleY) < EPSILON )	{
			angleX = arctan2(m21 , m22);
			angleY = PIhalf;
			angleZ = 0.0f;
		} else {
			angleX = arctan2(-m21, m22);
			angleY = -PIhalf;
			angleZ = 0.0f;
		}
	}
	// We set the result:
	float PIUNDER180 = 180.0f / PI;
	xT = (float) ( -angleX*PIUNDER180 );
	yT = (float) ( -angleY*PIUNDER180 );
	zT = (float) ( -angleZ*PIUNDER180 );
}

void CMatrix4::BuildMirrorPlane( const UPlane plane ) {
		const float fX = plane.normal.x;
		const float fY = plane.normal.y;
		const float fZ = plane.normal.z;
		const float fD = plane.dist;
		
		m11 = -(2.0f * fX * fX);
		m21 = -(2.0f * fX * fY);
		m31 = -(2.0f * fX * fZ);
		m41 = 0.0f;

		m12 = -(2.0f * fY * fX);
		m22 = -(2.0f * fY * fY);
		m32 = -(2.0f * fY * fZ);
		m42 = 0.0f;

		m13 = -(2.0f * fZ * fX);
		m23 = -(2.0f * fZ * fY);
		m33 = -(2.0f * fZ * fZ);
		m43 = 0.0f;

		m14 = -(2.0f * fD * fX);
		m24 = -(2.0f * fD * fY);
		m34 = -(2.0f * fD * fZ);
		m44 = 1.0f;
}
*/
/*
	void rotP(vector p, float x, float y, float z)
	{
		matrix trans;
	}

	void rotInv(float x, float y, float z)
	{
		float cx, cy, cz, sx, sy, sz;

		cx = (float)cos(x);
		sx = (float)sin(x);
		cy = (float)cos(y);
		sy = (float)sin(y);
		cz = (float)cos(z);
		sz = (float)sin(z);

		matrix mat;

		mat.m[0] = cy * cz;
		mat.m[4] = cy * sz;
		mat.m[8] = -sy;
		
		mat.m[1] = (sx * sy * cz) - (cx * sz);
		mat.m[5] = (sx * sy * sz) + (cx * cz);
		mat.m[9] = sx * cy;
		
		mat.m[2] = (cx * sy * cz) + (sx * sz);
		mat.m[6] = (cx * sy * sz) - (sx * cz);
		mat.m[10] = cx * cy;

		*this = mat * *this;
	}

	void rot(float x, float y, float z)
	{
		float cx, cy, cz, sx, sy, sz;

		cx = (float)cos(x);
		sx = (float)sin(x);
		cy = (float)cos(y);
		sy = (float)sin(y);
		cz = (float)cos(z);
		sz = (float)sin(z);

		matrix mat;

		mat.m[0] = cy * cz;
		mat.m[1] = cy * sz;
		mat.m[2] = -sy;
		
		mat.m[4] = (sx * sy * cz) - (cx * sz);
		mat.m[5] = (sx * sy * sz) + (cx * cz);
		mat.m[6] = sx * cy;
		
		mat.m[8] = (cx * sy * cz) + (sx * sz);
		mat.m[9] = (cx * sy * sz) - (sx * cz);
		mat.m[10] = cx * cy;

		*this = mat * *this;
	}
};
*/
#endif