fork download

#ifndef FURROVINERMATRIX4_H
#define FURROVINERMATRIX4_H
 
#include <Furrovine++/Core.h>
#include <Furrovine++/Quaternion.h>
 
namespace Furrovine {
 
	template <typename T> struct RMatrix4 {
	public:
 
		union {
 
			struct {
#ifdef FURROVINEMATRIX_ROWMAJOR
				T	m11, m12, m13, m14,
					m21, m22, m23, m24,
					m31, m32, m33, m34,
					m41, m42, m43, m44;
#else
				T	m11, m21, m31, m41,
					m12, m22, m32, m42,
					m13, m23, m33, m43,
					m14, m24, m34, m44;
#endif /* FURROVINEMATRIX_ROWMAJOR */
			};
 
			T m[16];
 
			struct {
				typename MatrixTraits<T>::TApi4 api;
			};
 
			RVector4<T> rows[4];
		};
 
		RMatrix4<T>& Set ( T x11 = T(1), T x21 = T(0), T x31 = T(0), T x41 = T(0),
			T x12 = T(0), T x22 = T(1), T x32 = T(0), T x42 = T(0),
			T x13 = T(0), T x23 = T(0), T x33 = T(1), T x43 = T(0),
			T x14 = T(0), T x24 = T(0), T x34 = T(0), T x44 = T(1) ) {
				m11 = x11;
				m12 = x12;
				m13 = x13;
				m14 = x14;
				m21 = x21;
				m22 = x22;
				m23 = x23;
				m24 = x24;
				m31 = x31;
				m32 = x32;
				m33 = x33;
				m34 = x34;
				m41 = x41;
				m42 = x42;
				m43 = x43;
				m44 = x44;
				return *this;
		}
 
		RMatrix4<T>& Set ( bool memorder,
			T x01, T x02, T x03, T x04,
			T x05, T x06, T x07, T x08,
			T x09, T x10, T x11, T x12,
			T x13, T x14, T x15, T x16 ) {
				m[0] = x01;
				m[1] = x02;
				m[2] = x03;
				m[3] = x04;
				m[4] = x05;
				m[5] = x06;
				m[6] = x07;
				m[7] = x08;
				m[8] = x09;
				m[9] = x10;
				m[10] = x11;
				m[11] = x12;
				m[12] = x13;
				m[13] = x14;
				m[14] = x15;
				m[15] = x16;
				return *this;
		}
 
		void Identify () {
			m12 = m13 = m14 = m21 = m23 = m24 = m31 = m32 = m34 = m41 = m42 = m43 = 0;
			m11 = m22 = m33 = m44 = (T)1;
		}
 
		RMatrix4<T> Clone () {
			RMatrix4<T> r;
			memcpy(m, r.m, sizeof(T) * 16);
			return r;
		}
 
		RMatrix4<T>& Clone (const RMatrix4<T>& obj) {
			memcpy(m, obj.m, sizeof(T) * 16);
			return *this;
		}
 
		RMatrix4<T>& Transpose () {
			Mem::Swap<T>(m12, m21);
			Mem::Swap<T>(m13, m31);
			Mem::Swap<T>(m14, m41);
 
			Mem::Swap<T>(m32, m23);
			Mem::Swap<T>(m34, m43);
 
			Mem::Swap<T>(m42, m24);
 
			return *this;
		}
 
		TVector3<T> Transform (const TVector3<T>& source) {
			return *this * source;
		}
 
		TVector4<T> Transform (const TVector4<T>& source) {
			return *this * source;
		}
 
		void Transform (const TVector3<T>& source, TVector3<T>& out) {
			T w = m[4 * 1 - 1] * source.x +
				m[4 * 2 - 1] * source.y +
				m[4 * 3 - 1] * source.z +
				m[4 * 4 - 1];
 
			out.x = m[1 * 1 - 1] * source.x +
				m[1 * 2 - 1] * source.y +
				m[1 * 3 - 1] * source.z +
				m[1 * 4 - 1];
			out.y = m[2 * 1 - 1] * source.x +
				m[2 * 2 - 1] * source.y +
				m[2 * 3 - 1] * source.z +
				m[2 * 4 - 1];
			out.z = m[3 * 1 - 1] * source.x +
				m[3 * 2 - 1] * source.y +
				m[3 * 3 - 1] * source.z +
				m[3 * 4 - 1];
 
			out /= w;
		}
 
		void Transform (const TVector4<T>& source, TVector4<T>& out) {
			out.x = m[1 * 1 - 1] * source.x +
				m[1 * 2 - 1] * source.y +
				m[1 * 3 - 1] * source.z +
				m[1 * 4 - 1] * source.w;
			out.y = m[2 * 1 - 1] * source.x +
				m[2 * 2 - 1] * source.y +
				m[2 * 3 - 1] * source.z +
				m[2 * 4 - 1] * source.w;
			out.z = m[3 * 1 - 1] * source.x +
				m[3 * 2 - 1] * source.y +
				m[3 * 3 - 1] * source.z +
				m[3 * 4 - 1] * source.w;
			out.w = m[4 * 1 - 1] * source.x +
				m[4 * 2 - 1] * source.y +
				m[4 * 3 - 1] * source.z +
				m[4 * 4 - 1] * source.w;
		}
 
		void Transform (const TVector4<T>& source, TVector3<T>& out) {
			T w = m[4 * 1 - 1] * source.x +
				m[4 * 2 - 1] * source.y +
				m[4 * 3 - 1] * source.z +
				m[4 * 4 - 1] * source.w;
 
			out.x = m[1 * 1 - 1] * source.x +
				m[1 * 2 - 1] * source.y +
				m[1 * 3 - 1] * source.z +
				m[1 * 4 - 1] * source.w;
			out.y = m[2 * 1 - 1] * source.x +
				m[2 * 2 - 1] * source.y +
				m[2 * 3 - 1] * source.z +
				m[2 * 4 - 1] * source.w;
			out.z = m[3 * 1 - 1] * source.x +
				m[3 * 2 - 1] * source.y +
				m[3 * 3 - 1] * source.z +
				m[3 * 4 - 1] * source.w;
 
			out /= w;
		}
 
		TVector3<T> Transform (const TVector3<T>& source) const {
			return *this * source;
		}
 
		TVector4<T> Transform (const TVector4<T>& source) const {
			return *this * source;
		}
 
		void Transform (const TVector3<T>& source, TVector3<T>& out) const {
			T w = m[4 * 1 - 1] * source.x +
				m[4 * 2 - 1] * source.y +
				m[4 * 3 - 1] * source.z +
				m[4 * 4 - 1];
 
			out.x = m[1 * 1 - 1] * source.x +
				m[1 * 2 - 1] * source.y +
				m[1 * 3 - 1] * source.z +
				m[1 * 4 - 1];
			out.y = m[2 * 1 - 1] * source.x +
				m[2 * 2 - 1] * source.y +
				m[2 * 3 - 1] * source.z +
				m[2 * 4 - 1];
			out.z = m[3 * 1 - 1] * source.x +
				m[3 * 2 - 1] * source.y +
				m[3 * 3 - 1] * source.z +
				m[3 * 4 - 1];
 
			out /= w;
		}
 
		void Transform (const TVector4<T>& source, TVector4<T>& out) const {
			out.x = m[1 * 1 - 1] * source.x +
				m[1 * 2 - 1] * source.y +
				m[1 * 3 - 1] * source.z +
				m[1 * 4 - 1] * source.w;
			out.y = m[2 * 1 - 1] * source.x +
				m[2 * 2 - 1] * source.y +
				m[2 * 3 - 1] * source.z +
				m[2 * 4 - 1] * source.w;
			out.z = m[3 * 1 - 1] * source.x +
				m[3 * 2 - 1] * source.y +
				m[3 * 3 - 1] * source.z +
				m[3 * 4 - 1] * source.w;
			out.w = m[4 * 1 - 1] * source.x +
				m[4 * 2 - 1] * source.y +
				m[4 * 3 - 1] * source.z +
				m[4 * 4 - 1] * source.w;
		}
 
		void Transform (const TVector4<T>& source, TVector3<T>& out) const {
			T w = m[4 * 1 - 1] * source.x +
				m[4 * 2 - 1] * source.y +
				m[4 * 3 - 1] * source.z +
				m[4 * 4 - 1] * source.w;
 
			out.x = m[1 * 1 - 1] * source.x +
				m[1 * 2 - 1] * source.y +
				m[1 * 3 - 1] * source.z +
				m[1 * 4 - 1] * source.w;
			out.y = m[2 * 1 - 1] * source.x +
				m[2 * 2 - 1] * source.y +
				m[2 * 3 - 1] * source.z +
				m[2 * 4 - 1] * source.w;
			out.z = m[3 * 1 - 1] * source.x +
				m[3 * 2 - 1] * source.y +
				m[3 * 3 - 1] * source.z +
				m[3 * 4 - 1] * source.w;
 
			out /= w;
		}
 
		T Determinant () {
			T a0 = m[0] * m[5] - m[1] * m[4];
			T a1 = m[0] * m[6] - m[2] * m[4];
			T a2 = m[0] * m[7] - m[3] * m[4];
			T a3 = m[1] * m[6] - m[2] * m[5];
			T a4 = m[1] * m[7] - m[3] * m[5];
			T a5 = m[2] * m[7] - m[3] * m[6];
			T b0 = m[8] * m[13] - m[9] * m[12];
			T b1 = m[8] * m[14] - m[10] * m[12];
			T b2 = m[8] * m[15] - m[11] * m[12];
			T b3 = m[9] * m[14] - m[10] * m[13];
			T b4 = m[9] * m[15] - m[11] * m[13];
			T b5 = m[10] * m[15] - m[11] * m[14];
 
			T det = a0*b5 - a1*b4 + a2*b3 + a3*b2 - a4*b1 + a5*b0;
 
			return det;
		}
 
		RMatrix4<T> Inverse () {
			T a0 = m[0] * m[5] - m[1] * m[4];
			T a1 = m[0] * m[6] - m[2] * m[4];
			T a2 = m[0] * m[7] - m[3] * m[4];
			T a3 = m[1] * m[6] - m[2] * m[5];
			T a4 = m[1] * m[7] - m[3] * m[5];
			T a5 = m[2] * m[7] - m[3] * m[6];
			T b0 = m[8] * m[13] - m[9] * m[12];
			T b1 = m[8] * m[14] - m[10] * m[12];
			T b2 = m[8] * m[15] - m[11] * m[12];
			T b3 = m[9] * m[14] - m[10] * m[13];
			T b4 = m[9] * m[15] - m[11] * m[13];
			T b5 = m[10] * m[15] - m[11] * m[14];
 
			T det = a0 * b5 - a1 * b4 + a2 * b3 + a3 * b2 - a4 * b1 + a5 * b0;
			RMatrix4<T> inverse;
			if (Mathema<T>::Abs(det) > T(0)) {
				inverse.m[0] = + m[5] * b5 - m[6] * b4 + m[7] * b3;
				inverse.m[4] = - m[4] * b5 + m[6] * b2 - m[7] * b1;
				inverse.m[8] = + m[4] * b4 - m[5] * b2 + m[7] * b0;
				inverse.m[12] = - m[4] * b3 + m[5] * b1 - m[6] * b0;
				inverse.m[1] = - m[1] * b5 + m[2] * b4 - m[3] * b3;
				inverse.m[5] = + m[0] * b5 - m[2] * b2 + m[3] * b1;
				inverse.m[9] = - m[0] * b4 + m[1] * b2 - m[3] * b0;
				inverse.m[13] = + m[0] * b3 - m[1] * b1 + m[2] * b0;
				inverse.m[2] = + m[13] * a5 - m[14] * a4 + m[15] * a3;
				inverse.m[6] = - m[12] * a5 + m[14] * a2 - m[15] * a1;
				inverse.m[10] = + m[12] * a4 - m[13] * a2 + m[15] * a0;
				inverse.m[14] = - m[12] * a3 + m[13] * a1 - m[14] * a0;
				inverse.m[3] = - m[9] * a5 + m[10] * a4 - m[11] * a3;
				inverse.m[7] = + m[8] * a5 - m[10] * a2 + m[11] * a1;
				inverse.m[11] = - m[8] * a4 + m[9] * a2 - m[11] * a0;
				inverse.m[15] = + m[8] * a3 - m[9] * a1 + m[10] * a0;
 
				T invDet = (T(1)) / det;
				inverse.m[0]  *= invDet;
				inverse.m[1]  *= invDet;
				inverse.m[2]  *= invDet;
				inverse.m[3]  *= invDet;
				inverse.m[4]  *= invDet;
				inverse.m[5]  *= invDet;
				inverse.m[6]  *= invDet;
				inverse.m[7]  *= invDet;
				inverse.m[8]  *= invDet;
				inverse.m[9]  *= invDet;
				inverse.m[10]  *= invDet;
				inverse.m[11]  *= invDet;
				inverse.m[12]  *= invDet;
				inverse.m[13]  *= invDet;
				inverse.m[14]  *= invDet;
				inverse.m[15]  *= invDet;
 
				return inverse;
			}
			inverse.Identify();
			return inverse;
		}
 
		bool Invert () {
			T a0 = m[0] * m[5] - m[1] * m[4];
			T a1 = m[0] * m[6] - m[2] * m[4];
			T a2 = m[0] * m[7] - m[3] * m[4];
			T a3 = m[1] * m[6] - m[2] * m[5];
			T a4 = m[1] * m[7] - m[3] * m[5];
			T a5 = m[2] * m[7] - m[3] * m[6];
			T b0 = m[8] * m[13] - m[9] * m[12];
			T b1 = m[8] * m[14] - m[10] * m[12];
			T b2 = m[8] * m[15] - m[11] * m[12];
			T b3 = m[9] * m[14] - m[10] * m[13];
			T b4 = m[9] * m[15] - m[11] * m[13];
			T b5 = m[10] * m[15] - m[11] * m[14];
 
			T det = a0 * b5 - a1 * b4 + a2 * b3 + a3 * b2 - a4 * b1 + a5 * b0;
			if (Mathema<T>::Abs(det) > T(0)) {
				RMatrix4<T> inverse;
				inverse.m[0] = + m[5] * b5 - m[6] * b4 + m[7] * b3;
				inverse.m[4] = - m[4] * b5 + m[6] * b2 - m[7] * b1;
				inverse.m[8] = + m[4] * b4 - m[5] * b2 + m[7] * b0;
				inverse.m[12] = - m[4] * b3 + m[5] * b1 - m[6] * b0;
				inverse.m[1] = - m[1] * b5 + m[2] * b4 - m[3] * b3;
				inverse.m[5] = + m[0] * b5 - m[2] * b2 + m[3] * b1;
				inverse.m[9] = - m[0] * b4 + m[1] * b2 - m[3] * b0;
				inverse.m[13] = + m[0] * b3 - m[1] * b1 + m[2] * b0;
				inverse.m[2] = + m[13] * a5 - m[14] * a4 + m[15] * a3;
				inverse.m[6] = - m[12] * a5 + m[14] * a2 - m[15] * a1;
				inverse.m[10] = + m[12] * a4 - m[13] * a2 + m[15] * a0;
				inverse.m[14] = - m[12] * a3 + m[13] * a1 - m[14] * a0;
				inverse.m[3] = - m[9] * a5 + m[10] * a4 - m[11] * a3;
				inverse.m[7] = + m[8] * a5 - m[10] * a2 + m[11] * a1;
				inverse.m[11] = - m[8] * a4 + m[9] * a2 - m[11] * a0;
				inverse.m[15] = + m[8] * a3 - m[9] * a1 + m[10] * a0;
 
				T invDet = (T(1)) / det;
				inverse.m[0]  *= invDet;
				inverse.m[1]  *= invDet;
				inverse.m[2]  *= invDet;
				inverse.m[3]  *= invDet;
				inverse.m[4]  *= invDet;
				inverse.m[5]  *= invDet;
				inverse.m[6]  *= invDet;
				inverse.m[7]  *= invDet;
				inverse.m[8]  *= invDet;
				inverse.m[9]  *= invDet;
				inverse.m[10]  *= invDet;
				inverse.m[11]  *= invDet;
				inverse.m[12]  *= invDet;
				inverse.m[13]  *= invDet;
				inverse.m[14]  *= invDet;
				inverse.m[15]  *= invDet;
 
				Clone(inverse);
 
				return true;
			}
 
			return false;
		}
 
		void Decompose (TVector3<T>& outscale, TQuaternion<T>& outrotate, TVector3<T>& outtranslation) {
			T mdiag = Mathema<T>::Sqrt(m[0] + m[5] + m[10] + m[15]);
			T mdiag2 = 2 * mdiag;
#ifdef FURROVINEMATRIX_ROWMAJOR
			outscale.x = Mathema<T>::Sqrt(m11 * m11 + m21 * m21 * m31 * m31);
			outscale.y = Mathema<T>::Sqrt(m12 * m12 + m22 * m22 * m32 * m32);
			outscale.z = Mathema<T>::Sqrt(m13 * m13 + m23 * m23 * m33 * m33);
			outtranslation.x = m14;
			outtranslation.y = m24;
			outtranslation.z = m34;
			outrotate.x = (m[6] - m[9]) / mdiag2;
			outrotate.y = (m[8] - m[2]) / mdiag2;
			outrotate.z = (m[1] - m[4]) / mdiag2;
			outrotate.w = mdiag / 2;
#else
			outtranslation.x = m[3];
			outtranslation.y = m[7];
			outtranslation.z = m[11];
			outscale.x = Mathema<T>::Sqrt(m[0] * m[0] + m[1] * m[1] + m[2] * m[2]);
			outscale.y = Mathema<T>::Sqrt(m[4] * m[4] + m[5] * m[5] + m[6] * m[6]);
			outscale.z = Mathema<T>::Sqrt(m[8] * m[8] + m[9] * m[9] + m[10] * m[10]);
			outrotate.x = (m[6] - m[9]) / mdiag2;
			outrotate.y = (m[8] - m[2]) / mdiag2;
			outrotate.z = (m[1] - m[4]) / mdiag2;
			outrotate.w = mdiag / 2;
#endif
		}
 
		void Decompose (TVector3<T>& outscale, TVector3<T>& outrotate, TVector3<T>& ouTranslate) {
#ifdef FURROVINEMATRIX_ROWMAJOR
			outscale.x = Mathema<T>::Sqrt(m11 * m11 + m21 * m21 * m31 * m31);
			outscale.y = Mathema<T>::Sqrt(m12 * m12 + m22 * m22 * m32 * m32);
			outscale.z = Mathema<T>::Sqrt(m13 * m13 + m23 * m23 * m33 * m33);
			ouTranslate.x = m14;
			ouTranslate.y = m24;
			ouTranslate.z = m34;
			outrotate.x = (m[6] - m[9]) / mdiag2;
			outrotate.y = (m[8] - m[2]) / mdiag2;
			outrotate.z = (m[1] - m[4]) / mdiag2;
			outrotate.w = mdiag / 2;
#else
			ouTranslate.x = m[3];
			ouTranslate.y = m[7];
			ouTranslate.z = m[11];
			outscale.x = Mathema<T>::Sqrt(m[0] * m[0] + m[1] * m[1] + m[2] * m[2]);
			outscale.y = Mathema<T>::Sqrt(m[4] * m[4] + m[5] * m[5] + m[6] * m[6]);
			outscale.z = Mathema<T>::Sqrt(m[8] * m[8] + m[9] * m[9] + m[10] * m[10]);
			outrotate.y = Mathema<T>::Asin(-m[8]);
			T theta = Mathema<T>::Cos(outrotate.y);
			outrotate.x = Mathema<T>::Asin(Mathema<T>::Mod(m[9] / theta, T(1)) );
			outrotate.z = Mathema<T>::Asin(Mathema<T>::Mod(m[4] / theta, T(1)) );
#endif
		}
 
		RMatrix4<T> operator+ (const RMatrix4<T>& right) const {
			RMatrix4<T> r = {
				m[0] + right.m[0],
				m[1] + right.m[1],
				m[2] + right.m[2],
				m[3] + right.m[3],
				m[4] + right.m[4],
				m[5] + right.m[5],
				m[6] + right.m[6],
				m[7] + right.m[7],
				m[8] + right.m[8],
				m[9] + right.m[9],
				m[10] + right.m[10],
				m[11] + right.m[11],
				m[12] + right.m[12],
				m[13] + right.m[13],
				m[14] + right.m[14],
				m[15] + right.m[15]
			};
			return r;
		}
 
		RMatrix4<T> operator- (const RMatrix4<T>& right) const {
			RMatrix4<T> r = {
				m[0] - right.m[0],
				m[1] - right.m[1],
				m[2] - right.m[2],
				m[3] - right.m[3],
				m[4] - right.m[4],
				m[5] - right.m[5],
				m[6] - right.m[6],
				m[7] - right.m[7],
				m[8] - right.m[8],
				m[9] - right.m[9],
				m[10] - right.m[10],
				m[11] - right.m[11],
				m[12] - right.m[12],
				m[13] - right.m[13],
				m[14] - right.m[14],
				m[15] - right.m[15]
			};
			return r;
		}
 
		RMatrix4<T> operator* (const T& right) const {
			RMatrix4<T> r = {
				m[0] * right,
				m[1] * right,
				m[2] * right,
				m[3] * right,
				m[4] * right,
				m[5] * right,
				m[6] * right,
				m[7] * right,
				m[8] * right,
				m[9] * right,
				m[10] * right,
				m[11] * right,
				m[12] * right,
				m[13] * right,
				m[14] * right,
				m[15] * right
			};
			return r;
		}
 
		RMatrix4<T> operator/ (const T& right) const {
			if (right == T(0)) {
				RMatrix4<T> z = { 0 };
				return z;
			}
			T invright = (T(1)) / right;
			RMatrix4<T> r = { 
				m[0] * invright,
				m[1] * invright,
				m[2] * invright,
				m[3] * invright,
				m[4] * invright,
				m[5] * invright,
				m[6] * invright,
				m[7] * invright,
				m[8] * invright,
				m[9] * invright,
				m[10] * invright,
				m[11] * invright,
				m[12] * invright,
				m[13] * invright,
				m[14] * invright,
				m[15] * invright };
 
			return r;
		}
 
		RMatrix4<T>& operator+= (const RMatrix4<T>& right) {
			m[0] += right.m[0];
			m[1] += right.m[1];
			m[2] += right.m[2];
			m[3] += right.m[3];
			m[4] += right.m[4];
			m[5] += right.m[5];
			m[6] += right.m[6];
			m[7] += right.m[7];
			m[8] += right.m[8];
			m[9] += right.m[9];
			m[10] += right.m[10];
			m[11] += right.m[11];
			m[12] += right.m[12];
			m[13] += right.m[13];
			m[14] += right.m[14];
			m[15] += right.m[15];
 
			return *this;
		}
 
		RMatrix4<T>& operator-= (const RMatrix4<T>& right) {
			m[0] -= right.m[0];
			m[1] -= right.m[1];
			m[2] -= right.m[2];
			m[3] -= right.m[3];
			m[4] -= right.m[4];
			m[5] -= right.m[5];
			m[6] -= right.m[6];
			m[7] -= right.m[7];
			m[8] -= right.m[8];
			m[9] -= right.m[9];
			m[10] -= right.m[10];
			m[11] -= right.m[11];
			m[12] -= right.m[12];
			m[13] -= right.m[13];
			m[14] -= right.m[14];
			m[15] -= right.m[15];
 
			return *this;
		}
 
		RMatrix4<T>& operator*= (const T& right) {
			m[0] *= right;
			m[1] *= right;
			m[2] *= right;
			m[3] *= right;
			m[4] *= right;
			m[5] *= right;
			m[6] *= right;
			m[7] *= right;
			m[8] *= right;
			m[9] *= right;
			m[10] *= right;
			m[11] *= right;
			m[12] *= right;
			m[13] *= right;
			m[14] *= right;
			m[15] *= right;
 
			return *this;
		}
 
		RMatrix4<T>& operator/= (const T& right) {
			if (right == T(0))
				return *this;
 
			T invright = (T(1)) / right;
			m[0] *= invright;
			m[1] *= invright;
			m[2] *= invright;
			m[3] *= invright;
			m[4] *= invright;
			m[5] *= invright;
			m[6] *= invright;
			m[7] *= invright;
			m[8] *= invright;
			m[9] *= invright;
			m[10] *= invright;
			m[11] *= invright;
			m[12] *= invright;
			m[13] *= invright;
			m[14] *= invright;
			m[15] *= invright;
 
			return *this;
		}
 
		TVector4<T> operator* ( const TVector4<T>& right ) {
			return TVector4<T>(
				m[1 * 1 - 1] * right.x +
				m[1 * 2 - 1] * right.y +
				m[1 * 3 - 1] * right.z +
				m[1 * 4 - 1] * right.w,
 
				m[2 * 1 - 1] * right.x +
				m[2 * 2 - 1] * right.y +
				m[2 * 3 - 1] * right.z +
				m[2 * 4 - 1] * right.w,
 
				m[3 * 1 - 1] * right.x +
				m[3 * 2 - 1] * right.y +
				m[3 * 3 - 1] * right.z +
				m[3 * 4 - 1] * right.w,
 
				m[4 * 1 - 1] * right.x +
				m[4 * 2 - 1] * right.y +
				m[4 * 3 - 1] * right.z +
				m[4 * 4 - 1] * right.w
				);
		}
 
		TVector3<T> operator* ( const TVector3<T>& right ) {
			return TVector3<T> (
				m[1 * 1 - 1] * right.x +
				m[1 * 2 - 1] * right.y +
				m[1 * 3 - 1] * right.z +
				m[1 * 4 - 1],
 
				m[2 * 1 - 1] * right.x +
				m[2 * 2 - 1] * right.y +
				m[2 * 3 - 1] * right.z +
				m[2 * 4 - 1],
 
				m[3 * 1 - 1] * right.x +
				m[3 * 2 - 1] * right.y +
				m[3 * 3 - 1] * right.z +
				m[3 * 4 - 1],
 
				m[4 * 1 - 1] * right.x +
				m[4 * 2 - 1] * right.y +
				m[4 * 3 - 1] * right.z +
				m[4 * 4 - 1]
			);
		}
 
		RMatrix4<T> operator* ( const RMatrix4<T>& right ) {
			RMatrix4<T> r = {
				(right.m[1 * 1 - 1] * m[1 * 1 - 1] + right.m[1 * 2 - 1] * m[2 * 1 - 1] + right.m[1 * 3 - 1] * m[3 * 1 - 1] + right.m[1 * 4 - 1] * m[4 * 1 - 1]),
				(right.m[1 * 1 - 1] * m[1 * 2 - 1] + right.m[1 * 2 - 1] * m[2 * 2 - 1] + right.m[1 * 3 - 1] * m[3 * 2 - 1] + right.m[1 * 4 - 1] * m[4 * 2 - 1]),
				(right.m[1 * 1 - 1] * m[1 * 3 - 1] + right.m[1 * 2 - 1] * m[2 * 3 - 1] + right.m[1 * 3 - 1] * m[3 * 3 - 1] + right.m[1 * 4 - 1] * m[4 * 3 - 1]),
				(right.m[1 * 1 - 1] * m[1 * 4 - 1] + right.m[1 * 2 - 1] * m[2 * 4 - 1] + right.m[1 * 3 - 1] * m[3 * 4 - 1] + right.m[1 * 4 - 1] * m[4 * 4 - 1]),
				(right.m[2 * 1 - 1] * m[1 * 1 - 1] + right.m[2 * 2 - 1] * m[2 * 1 - 1] + right.m[2 * 3 - 1] * m[3 * 1 - 1] + right.m[2 * 4 - 1] * m[4 * 1 - 1]),
				(right.m[2 * 1 - 1] * m[1 * 2 - 1] + right.m[2 * 2 - 1] * m[2 * 2 - 1] + right.m[2 * 3 - 1] * m[3 * 2 - 1] + right.m[2 * 4 - 1] * m[4 * 2 - 1]),
				(right.m[2 * 1 - 1] * m[1 * 3 - 1] + right.m[2 * 2 - 1] * m[2 * 3 - 1] + right.m[2 * 3 - 1] * m[3 * 3 - 1] + right.m[2 * 4 - 1] * m[4 * 3 - 1]),
				(right.m[2 * 1 - 1] * m[1 * 4 - 1] + right.m[2 * 2 - 1] * m[2 * 4 - 1] + right.m[2 * 3 - 1] * m[3 * 4 - 1] + right.m[2 * 4 - 1] * m[4 * 4 - 1]),
				(right.m[3 * 1 - 1] * m[1 * 1 - 1] + right.m[3 * 2 - 1] * m[2 * 1 - 1] + right.m[3 * 3 - 1] * m[3 * 1 - 1] + right.m[3 * 4 - 1] * m[4 * 1 - 1]),
				(right.m[3 * 1 - 1] * m[1 * 2 - 1] + right.m[3 * 2 - 1] * m[2 * 2 - 1] + right.m[3 * 3 - 1] * m[3 * 2 - 1] + right.m[3 * 4 - 1] * m[4 * 2 - 1]),
				(right.m[3 * 1 - 1] * m[1 * 3 - 1] + right.m[3 * 2 - 1] * m[2 * 3 - 1] + right.m[3 * 3 - 1] * m[3 * 3 - 1] + right.m[3 * 4 - 1] * m[4 * 3 - 1]),
				(right.m[3 * 1 - 1] * m[1 * 4 - 1] + right.m[3 * 2 - 1] * m[2 * 4 - 1] + right.m[3 * 3 - 1] * m[3 * 4 - 1] + right.m[3 * 4 - 1] * m[4 * 4 - 1]),
				(right.m[4 * 1 - 1] * m[1 * 1 - 1] + right.m[4 * 2 - 1] * m[2 * 1 - 1] + right.m[4 * 3 - 1] * m[3 * 1 - 1] + right.m[4 * 4 - 1] * m[4 * 1 - 1]),
				(right.m[4 * 1 - 1] * m[1 * 2 - 1] + right.m[4 * 2 - 1] * m[2 * 2 - 1] + right.m[4 * 3 - 1] * m[3 * 2 - 1] + right.m[4 * 4 - 1] * m[4 * 2 - 1]),
				(right.m[4 * 1 - 1] * m[1 * 3 - 1] + right.m[4 * 2 - 1] * m[2 * 3 - 1] + right.m[4 * 3 - 1] * m[3 * 3 - 1] + right.m[4 * 4 - 1] * m[4 * 3 - 1]),
				(right.m[4 * 1 - 1] * m[1 * 4 - 1] + right.m[4 * 2 - 1] * m[2 * 4 - 1] + right.m[4 * 3 - 1] * m[3 * 4 - 1] + right.m[4 * 4 - 1] * m[4 * 4 - 1])
			};
			return r;
		}
 
		RMatrix4<T>& operator*= ( const RMatrix4<T>& right ) {
			T out[16] = {
				right.m[1 * 1 - 1] * m[1 * 1 - 1] + right.m[1 * 2 - 1] * m[2 * 1 - 1] + right.m[1 * 3 - 1] * m[3 * 1 - 1] + right.m[1 * 4 - 1] * m[4 * 1 - 1],
				right.m[1 * 1 - 1] * m[1 * 2 - 1] + right.m[1 * 2 - 1] * m[2 * 2 - 1] + right.m[1 * 3 - 1] * m[3 * 2 - 1] + right.m[1 * 4 - 1] * m[4 * 2 - 1],
				right.m[1 * 1 - 1] * m[1 * 3 - 1] + right.m[1 * 2 - 1] * m[2 * 3 - 1] + right.m[1 * 3 - 1] * m[3 * 3 - 1] + right.m[1 * 4 - 1] * m[4 * 3 - 1],
				right.m[1 * 1 - 1] * m[1 * 4 - 1] + right.m[1 * 2 - 1] * m[2 * 4 - 1] + right.m[1 * 3 - 1] * m[3 * 4 - 1] + right.m[1 * 4 - 1] * m[4 * 4 - 1],
				right.m[2 * 1 - 1] * m[1 * 1 - 1] + right.m[2 * 2 - 1] * m[2 * 1 - 1] + right.m[2 * 3 - 1] * m[3 * 1 - 1] + right.m[2 * 4 - 1] * m[4 * 1 - 1],
				right.m[2 * 1 - 1] * m[1 * 2 - 1] + right.m[2 * 2 - 1] * m[2 * 2 - 1] + right.m[2 * 3 - 1] * m[3 * 2 - 1] + right.m[2 * 4 - 1] * m[4 * 2 - 1],
				right.m[2 * 1 - 1] * m[1 * 3 - 1] + right.m[2 * 2 - 1] * m[2 * 3 - 1] + right.m[2 * 3 - 1] * m[3 * 3 - 1] + right.m[2 * 4 - 1] * m[4 * 3 - 1],
				right.m[2 * 1 - 1] * m[1 * 4 - 1] + right.m[2 * 2 - 1] * m[2 * 4 - 1] + right.m[2 * 3 - 1] * m[3 * 4 - 1] + right.m[2 * 4 - 1] * m[4 * 4 - 1],
				right.m[3 * 1 - 1] * m[1 * 1 - 1] + right.m[3 * 2 - 1] * m[2 * 1 - 1] + right.m[3 * 3 - 1] * m[3 * 1 - 1] + right.m[3 * 4 - 1] * m[4 * 1 - 1],
				right.m[3 * 1 - 1] * m[1 * 2 - 1] + right.m[3 * 2 - 1] * m[2 * 2 - 1] + right.m[3 * 3 - 1] * m[3 * 2 - 1] + right.m[3 * 4 - 1] * m[4 * 2 - 1],
				right.m[3 * 1 - 1] * m[1 * 3 - 1] + right.m[3 * 2 - 1] * m[2 * 3 - 1] + right.m[3 * 3 - 1] * m[3 * 3 - 1] + right.m[3 * 4 - 1] * m[4 * 3 - 1],
				right.m[3 * 1 - 1] * m[1 * 4 - 1] + right.m[3 * 2 - 1] * m[2 * 4 - 1] + right.m[3 * 3 - 1] * m[3 * 4 - 1] + right.m[3 * 4 - 1] * m[4 * 4 - 1],
				right.m[4 * 1 - 1] * m[1 * 1 - 1] + right.m[4 * 2 - 1] * m[2 * 1 - 1] + right.m[4 * 3 - 1] * m[3 * 1 - 1] + right.m[4 * 4 - 1] * m[4 * 1 - 1],
				right.m[4 * 1 - 1] * m[1 * 2 - 1] + right.m[4 * 2 - 1] * m[2 * 2 - 1] + right.m[4 * 3 - 1] * m[3 * 2 - 1] + right.m[4 * 4 - 1] * m[4 * 2 - 1],
				right.m[4 * 1 - 1] * m[1 * 3 - 1] + right.m[4 * 2 - 1] * m[2 * 3 - 1] + right.m[4 * 3 - 1] * m[3 * 3 - 1] + right.m[4 * 4 - 1] * m[4 * 3 - 1],
				right.m[4 * 1 - 1] * m[1 * 4 - 1] + right.m[4 * 2 - 1] * m[2 * 4 - 1] + right.m[4 * 3 - 1] * m[3 * 4 - 1] + right.m[4 * 4 - 1] * m[4 * 4 - 1]
			};
 
			memcpy(m, out, sizeof(T) * 16);
 
			return *this;
		}
 
		bool operator== ( const RMatrix4<T>& right ) {
			return m[0] == right.m[0] &&
				m[1] == right.m[1] &&
				m[2] == right.m[2] &&
				m[3] == right.m[3] &&
				m[4] == right.m[4] &&
				m[5] == right.m[5] &&
				m[6] == right.m[6] &&
				m[7] == right.m[7] &&
				m[8] == right.m[8] &&
				m[9] == right.m[9] &&
				m[10] == right.m[10] &&
				m[11] == right.m[11] &&
				m[12] == right.m[12] &&
				m[13] == right.m[13] &&
				m[14] == right.m[14] &&
				m[15] == right.m[15];
		}
 
		bool operator!= ( const RMatrix4<T>& right ) {
			return !(*this == right);
		}
 
		bool operator== ( T* right ) {
			return m[0] == right[0] &&
				m[1] == right[1] &&
				m[2] == right[2] &&
				m[3] == right[3] &&
				m[4] == right[4] &&
				m[5] == right[5] &&
				m[6] == right[6] &&
				m[7] == right[7] &&
				m[8] == right[8] &&
				m[9] == right[9] &&
				m[10] == right[10] &&
				m[11] == right[11] &&
				m[12] == right[12] &&
				m[13] == right[13] &&
				m[14] == right[14] &&
				m[15] == right[15];
		}
 
		bool operator!= ( T* right ) {
			return !(*this == right);
		}
 
		bool Equals (const RMatrix4<T>& right) {
			return m[0] == right.m[0] &&
				m[1] == right.m[1] &&
				m[2] == right.m[2] &&
				m[3] == right.m[3] &&
				m[4] == right.m[4] &&
				m[5] == right.m[5] &&
				m[6] == right.m[6] &&
				m[7] == right.m[7] &&
				m[8] == right.m[8] &&
				m[9] == right.m[9] &&
				m[10] == right.m[10] &&
				m[11] == right.m[11] &&
				m[12] == right.m[12] &&
				m[13] == right.m[13] &&
				m[14] == right.m[14] &&
				m[15] == right.m[15];
		}
 
		TVector4<T> operator* ( const TVector4<T>& right ) const {
			return TVector4<T> (
				m11 * right.x +
				m12 * right.y +
				m13 * right.z +
				m14 * right.w,
 
				m21 * right.x +
				m22 * right.y +
				m23 * right.z +
				m24 * right.w,
 
				m31 * right.x +
				m32 * right.y +
				m33 * right.z +
				m34 * right.w,
 
				m41 * right.x +
				m42 * right.y +
				m43 * right.z +
				m44 * right.w
				);
		}
 
		TVector3<T> operator* ( const TVector3<T>& right ) const {
			return TVector3<T> (
				m11 * right.x +
				m12 * right.y +
				m13 * right.z +
				m14,
 
				m21 * right.x +
				m22 * right.y +
				m23 * right.z +
				m24,
 
				m31 * right.x +
				m32 * right.y +
				m33 * right.z +
				m34,
 
				m41 * right.x +
				m42 * right.y +
				m43 * right.z +
				m44
				);
		}
 
		RMatrix4<T> operator* ( const RMatrix4<T>& right ) const {
			RMatrix4<T> r = { m[0] * right.m[0] +
				m[1] * right.m[4] +
				m[2] * right.m[8] +
				m[3] * right.m[12],
 
				m[0] * right.m[1] +
				m[1] * right.m[5] +
				m[2] * right.m[9] +
				m[3] * right.m[13],
 
				m[0] * right.m[2] +
				m[1] * right.m[6] +
				m[2] * right.m[10] +
				m[3] * right.m[14],
 
				m[0] * right.m[3] +
				m[1] * right.m[7] +
				m[2] * right.m[11] +
				m[3] * right.m[15],
 
				m[4] * right.m[0] +
				m[5] * right.m[4] +
				m[6] * right.m[8] +
				m[7] * right.m[12],
 
				m[4] * right.m[1] +
				m[5] * right.m[5] +
				m[6] * right.m[9] +
				m[7] * right.m[13],
 
				m[4] * right.m[2] +
				m[5] * right.m[6] +
				m[6] * right.m[10] +
				m[7] * right.m[14],
 
				m[4] * right.m[3] +
				m[5] * right.m[7] +
				m[6] * right.m[11] +
				m[7] * right.m[15],
 
				m[8] * right.m[0] +
				m[9] * right.m[4] +
				m[10] * right.m[8] +
				m[11] * right.m[12],
 
				m[8] * right.m[1] +
				m[9] * right.m[5] +
				m[10] * right.m[9] +
				m[11] * right.m[13],
 
				m[8] * right.m[2] +
				m[9] * right.m[6] +
				m[10] * right.m[10] +
				m[11] * right.m[14],
 
				m[8] * right.m[3] +
				m[9] * right.m[7] +
				m[10] * right.m[11] +
				m[11] * right.m[15],
 
				m[12] * right.m[0] +
				m[13] * right.m[4] +
				m[14] * right.m[8] +
				m[15] * right.m[12],
 
				m[12] * right.m[1] +
				m[13] * right.m[5] +
				m[14] * right.m[9] +
				m[15] * right.m[13],
 
				m[12] * right.m[2] +
				m[13] * right.m[6] +
				m[14] * right.m[10] +
				m[15] * right.m[14],
 
				m[12] * right.m[3] +
				m[13] * right.m[7] +
				m[14] * right.m[11] +
				m[15] * right.m[15]
			};
			return r;
		}
 
		bool operator== ( const RMatrix4<T>& right ) const {
			return memcmp(m, right.m, sizeof(T) * 16) == 0;
		}
 
		bool operator!= ( const RMatrix4<T>& right ) const {
			return memcmp(m, right.m, sizeof(T) * 16) != 0;
		}
 
		bool operator== ( T* right ) const {
			return memcmp(m, right, sizeof(T) * 16) == 0;
		}
 
		bool operator!= ( T* right ) const {
			return memcmp(m, right, sizeof(T) * 16) != 0;
		}
 
		operator T* () const {
			return (T*)m;
		}
 
		T& operator[] (int index) {
			return m[index];
		}
 
		T& operator() (int column, int row) {
			return m[row * 4 + column];
		}
 
		static TVector3<T> Transform (const RMatrix4<T>& matrix, const TVector3<T>& source) {
			return matrix * source;
		}
 
		static TVector4<T> Transform (const RMatrix4<T>& matrix, const TVector4<T>& source) {
			return matrix * source;
		}
 
		static RMatrix4<T> Transpose (const RMatrix4<T>& matrix) {
			RMatrix4<T> r = {
				matrix.m[0],
				matrix.m[4],
				matrix.m[8],
				matrix.m[12],
				matrix.m[1],
				matrix.m[5],
				matrix.m[9],
				matrix.m[13],
				matrix.m[2],
				matrix.m[6],
				matrix.m[10],
				matrix.m[14],
				matrix.m[3],
				matrix.m[7],
				matrix.m[11],
				matrix.m[15]
			};
			return r;
		}
 
		static RMatrix4<T> Adjoint (const RMatrix4<T>& matrix) {
			T a0 = matrix.m[0] * matrix.m[5] - matrix.m[1] * matrix.m[4];
			T a1 = matrix.m[0] * matrix.m[6] - matrix.m[2] * matrix.m[4];
			T a2 = matrix.m[0] * matrix.m[7] - matrix.m[3] * matrix.m[4];
			T a3 = matrix.m[1] * matrix.m[6] - matrix.m[2] * matrix.m[5];
			T a4 = matrix.m[1] * matrix.m[7] - matrix.m[3] * matrix.m[5];
			T a5 = matrix.m[2] * matrix.m[7] - matrix.m[3] * matrix.m[6];
			T b0 = matrix.m[8] * matrix.m[13] - matrix.m[9] * matrix.m[12];
			T b1 = matrix.m[8] * matrix.m[14] - matrix.m[10] * matrix.m[12];
			T b2 = matrix.m[8] * matrix.m[15] - matrix.m[11] * matrix.m[12];
			T b3 = matrix.m[9] * matrix.m[14] - matrix.m[10] * matrix.m[13];
			T b4 = matrix.m[9] * matrix.m[15] - matrix.m[11] * matrix.m[13];
			T b5 = matrix.m[10] * matrix.m[15] - matrix.m[11] * matrix.m[14];
 
			RMatrix4<T> r = {
				+ matrix.m[5] * b5 - matrix.m[6] * b4 + matrix.m[7] * b3,
				- matrix.m[1] * b5 + matrix.m[2] * b4 - matrix.m[3] * b3,
				+ matrix.m[13] * a5 - matrix.m[14] * a4 + matrix.m[15] * a3,
				- matrix.m[9] * a5 + matrix.m[10] * a4 - matrix.m[11] * a3,
				- matrix.m[4] * b5 + matrix.m[6] * b2 - matrix.m[7] * b1,
				+ matrix.m[0] * b5 - matrix.m[2] * b2 + matrix.m[3] * b1,
				- matrix.m[12] * a5 + matrix.m[14] * a2 - matrix.m[15] * a1,
				+ matrix.m[8] * a5 - matrix.m[10] * a2 + matrix.m[11] * a1,
				+ matrix.m[4] * b4 - matrix.m[5] * b2 + matrix.m[7] * b0,
				- matrix.m[0] * b4 + matrix.m[1] * b2 - matrix.m[3] * b0,
				+ matrix.m[12] * a4 - matrix.m[13] * a2 + matrix.m[15] * a0,
				- matrix.m[8] * a4 + matrix.m[9] * a2 - matrix.m[11] * a0,
				- matrix.m[4] * b3 + matrix.m[5] * b1 - matrix.m[6] * b0,
				+ matrix.m[0] * b3 - matrix.m[1] * b1 + matrix.m[2] * b0,
				- matrix.m[12] * a3 + matrix.m[13] * a1 - matrix.m[14] * a0,
				+ matrix.m[8] * a3 - matrix.m[9] * a1 + matrix.m[10] * a0
			};
			return r;
		}
 
		static RMatrix4<T> Inverse (const RMatrix4<T>& matrix) {
			T a0 = matrix.m[0] * matrix.m[5] - matrix.m[1] * matrix.m[4];
			T a1 = matrix.m[0] * matrix.m[6] - matrix.m[2] * matrix.m[4];
			T a2 = matrix.m[0] * matrix.m[7] - matrix.m[3] * matrix.m[4];
			T a3 = matrix.m[1] * matrix.m[6] - matrix.m[2] * matrix.m[5];
			T a4 = matrix.m[1] * matrix.m[7] - matrix.m[3] * matrix.m[5];
			T a5 = matrix.m[2] * matrix.m[7] - matrix.m[3] * matrix.m[6];
			T b0 = matrix.m[8] * matrix.m[13] - matrix.m[9] * matrix.m[12];
			T b1 = matrix.m[8] * matrix.m[14] - matrix.m[10] * matrix.m[12];
			T b2 = matrix.m[8] * matrix.m[15] - matrix.m[11] * matrix.m[12];
			T b3 = matrix.m[9] * matrix.m[14] - matrix.m[10] * matrix.m[13];
			T b4 = matrix.m[9] * matrix.m[15] - matrix.m[11] * matrix.m[13];
			T b5 = matrix.m[10] * matrix.m[15] - matrix.m[11] * matrix.m[14];
 
			T det = a0 * b5 - a1 * b4 + a2 * b3 + a3 * b2 - a4 * b1 + a5 * b0;
			RMatrix4<T> inverse = { 0 };
			if (Mathema<T>::Abs(det) > T(0)) {
				inverse.m[0] = + matrix.m[5] * b5 - matrix.m[6] * b4 + matrix.m[7] * b3;
				inverse.m[4] = - matrix.m[4] * b5 + matrix.m[6] * b2 - matrix.m[7] * b1;
				inverse.m[8] = + matrix.m[4] * b4 - matrix.m[5] * b2 + matrix.m[7] * b0;
				inverse.m[12] = - matrix.m[4] * b3 + matrix.m[5] * b1 - matrix.m[6] * b0;
				inverse.m[1] = - matrix.m[1] * b5 + matrix.m[2] * b4 - matrix.m[3] * b3;
				inverse.m[5] = + matrix.m[0] * b5 - matrix.m[2] * b2 + matrix.m[3] * b1;
				inverse.m[9] = - matrix.m[0] * b4 + matrix.m[1] * b2 - matrix.m[3] * b0;
				inverse.m[13] = + matrix.m[0] * b3 - matrix.m[1] * b1 + matrix.m[2] * b0;
				inverse.m[2] = + matrix.m[13] * a5 - matrix.m[14] * a4 + matrix.m[15] * a3;
				inverse.m[6] = - matrix.m[12] * a5 + matrix.m[14] * a2 - matrix.m[15] * a1;
				inverse.m[10] = + matrix.m[12] * a4 - matrix.m[13] * a2 + matrix.m[15] * a0;
				inverse.m[14] = - matrix.m[12] * a3 + matrix.m[13] * a1 - matrix.m[14] * a0;
				inverse.m[3] = - matrix.m[9] * a5 + matrix.m[10] * a4 - matrix.m[11] * a3;
				inverse.m[7] = + matrix.m[8] * a5 - matrix.m[10] * a2 + matrix.m[11] * a1;
				inverse.m[11] = - matrix.m[8] * a4 + matrix.m[9] * a2 - matrix.m[11] * a0;
				inverse.m[15] = + matrix.m[8] * a3 - matrix.m[9] * a1 + matrix.m[10] * a0;
 
				T invDet = (T(1)) / det;
				inverse.m[0]  *= invDet;
				inverse.m[1]  *= invDet;
				inverse.m[2]  *= invDet;
				inverse.m[3]  *= invDet;
				inverse.m[4]  *= invDet;
				inverse.m[5]  *= invDet;
				inverse.m[6]  *= invDet;
				inverse.m[7]  *= invDet;
				inverse.m[8]  *= invDet;
				inverse.m[9]  *= invDet;
				inverse.m[10]  *= invDet;
				inverse.m[11]  *= invDet;
				inverse.m[12]  *= invDet;
				inverse.m[13]  *= invDet;
				inverse.m[14]  *= invDet;
				inverse.m[15]  *= invDet;
 
			}
 
			return inverse;
		}
 
		static bool Invert (const RMatrix4<T>& matrix, RMatrix4<T>& out) {
			T a0 = matrix.m[0] * matrix.m[5] - matrix.m[1] * matrix.m[4];
			T a1 = matrix.m[0] * matrix.m[6] - matrix.m[2] * matrix.m[4];
			T a2 = matrix.m[0] * matrix.m[7] - matrix.m[3] * matrix.m[4];
			T a3 = matrix.m[1] * matrix.m[6] - matrix.m[2] * matrix.m[5];
			T a4 = matrix.m[1] * matrix.m[7] - matrix.m[3] * matrix.m[5];
			T a5 = matrix.m[2] * matrix.m[7] - matrix.m[3] * matrix.m[6];
			T b0 = matrix.m[8] * matrix.m[13] - matrix.m[9] * matrix.m[12];
			T b1 = matrix.m[8] * matrix.m[14] - matrix.m[10] * matrix.m[12];
			T b2 = matrix.m[8] * matrix.m[15] - matrix.m[11] * matrix.m[12];
			T b3 = matrix.m[9] * matrix.m[14] - matrix.m[10] * matrix.m[13];
			T b4 = matrix.m[9] * matrix.m[15] - matrix.m[11] * matrix.m[13];
			T b5 = matrix.m[10] * matrix.m[15] - matrix.m[11] * matrix.m[14];
 
			T det = a0 * b5 - a1 * b4 + a2 * b3 + a3 * b2 - a4 * b1 + a5 * b0;
			if (Mathema<T>::Abs(det) > T(0)) {
				out.m[0] = + matrix.m[5] * b5 - matrix.m[6] * b4 + matrix.m[7] * b3;
				out.m[4] = - matrix.m[4] * b5 + matrix.m[6] * b2 - matrix.m[7] * b1;
				out.m[8] = + matrix.m[4] * b4 - matrix.m[5] * b2 + matrix.m[7] * b0;
				out.m[12] = - matrix.m[4] * b3 + matrix.m[5] * b1 - matrix.m[6] * b0;
				out.m[1] = - matrix.m[1] * b5 + matrix.m[2] * b4 - matrix.m[3] * b3;
				out.m[5] = + matrix.m[0] * b5 - matrix.m[2] * b2 + matrix.m[3] * b1;
				out.m[9] = - matrix.m[0] * b4 + matrix.m[1] * b2 - matrix.m[3] * b0;
				out.m[13] = + matrix.m[0] * b3 - matrix.m[1] * b1 + matrix.m[2] * b0;
				out.m[2] = + matrix.m[13] * a5 - matrix.m[14] * a4 + matrix.m[15] * a3;
				out.m[6] = - matrix.m[12] * a5 + matrix.m[14] * a2 - matrix.m[15] * a1;
				out.m[10] = + matrix.m[12] * a4 - matrix.m[13] * a2 + matrix.m[15] * a0;
				out.m[14] = - matrix.m[12] * a3 + matrix.m[13] * a1 - matrix.m[14] * a0;
				out.m[3] = - matrix.m[9] * a5 + matrix.m[10] * a4 - matrix.m[11] * a3;
				out.m[7] = + matrix.m[8] * a5 - matrix.m[10] * a2 + matrix.m[11] * a1;
				out.m[11] = - matrix.m[8] * a4 + matrix.m[9] * a2 - matrix.m[11] * a0;
				out.m[15] = + matrix.m[8] * a3 - matrix.m[9] * a1 + matrix.m[10] * a0;
 
				T invDet = (T(1)) / det;
				out.m[0]  *= invDet;
				out.m[1]  *= invDet;
				out.m[2]  *= invDet;
				out.m[3]  *= invDet;
				out.m[4]  *= invDet;
				out.m[5]  *= invDet;
				out.m[6]  *= invDet;
				out.m[7]  *= invDet;
				out.m[8]  *= invDet;
				out.m[9]  *= invDet;
				out.m[10]  *= invDet;
				out.m[11]  *= invDet;
				out.m[12]  *= invDet;
				out.m[13]  *= invDet;
				out.m[14]  *= invDet;
				out.m[15]  *= invDet;
 
				return true;
			}
 
			return false;
		}
 
		static RMatrix4<T> CreateTranslation (T dx, T dy, T dz) {
			RMatrix4<T> r = { T(1), T(0), T(0), T(0),
				T(0), T(1), T(0), T(0),
				T(0), T(0), T(1), T(0),
				dx, dy, dz, T(1)};
			return r;
		}
 
		static RMatrix4<T> CreateTranslation (const TVector3<T>& translation) {
			return CreateTranslation(translation.x, translation.y, translation.z);
		}
 
		static RMatrix4<T> CreateRotationX (T radians) {
			T cosa = Mathema<T>::Cos(radians);
			T sina = Mathema<T>::Sin(radians);
			RMatrix4<T> r = {
				T(1), T(0), T(0), T(0),
				T(0), cosa, -sina, T(0),
				T(0), sina, cosa, T(0),
				T(0), T(0), T(0), T(1)};
			return r;
		}
 
		static RMatrix4<T> CreateRotationY (T radians) {
			T cosa = Mathema<T>::Cos(radians);
			T sina = Mathema<T>::Sin(radians);
			RMatrix4<T> r = {
				cosa, T(0), sina, T(0),
				T(0), T(1), T(0), T(0),
				-sina, T(0), cosa, T(0),
				T(0), T(0), T(0), T(1) };
			return r;
		}
 
		static RMatrix4<T> CreateRotationZ (T radians) {
			T cosa = Mathema<T>::Cos(radians);
			T sina = Mathema<T>::Sin(radians);
			RMatrix4<T> r = {
				cosa, -sina, T(0), T(0),
				sina, cosa, T(0), T(0),
				T(0), T(0), T(1), T(0),
				T(0), T(0), T(0), T(1) };
			return r;
		}
 
		static RMatrix4<T> CreateRotation (T xradians, T yradians, T zradians) {
			T xcos = Mathema<T>::Cos(xradians);
			T xsin = Mathema<T>::Sin(xradians);
			T zcos = Mathema<T>::Cos(zradians);
			T zsin = Mathema<T>::Sin(zradians);
			T ycos = Mathema<T>::Cos(yradians);
			T ysin = Mathema<T>::Sin(yradians);
			RMatrix4<T> r = {
				ycos * zcos, -xcos * zsin + xsin * ysin * zcos, xsin * zsin + xcos * ysin * zcos, T(0),
				ycos * zsin, xcos * zcos + xsin * ysin * zsin, -xsin * zcos + xcos * ysin * zsin, T(0),
				ysin, xsin * ycos, xcos * ycos, T(0),
				T(0), T(0), T(0), T(1) };
			return r;
		}
 
		static RMatrix4<T> CreateRotation (const TVector3<T>& yawpitchroll) {
			return CreateRotation(yawpitchroll.x, yawpitchroll.y, yawpitchroll.z);
		}
 
		static RMatrix4<T> CreateRotationAxis (TVector3<T> axis, T radians) {
			axis.Normalize();
			T cosa = Mathema<T>::Cos(radians);
			T sina = Mathema<T>::Sin(radians);
			T affcosa = T(1) - cosa;
			RMatrix4<T> r = {
				(axis.x * axis.x) * affcosa + cosa, (axis.x * axis.y) * affcosa - (axis.z * sina), (axis.x * axis.z) * affcosa + (axis.y * sina), T(0),
				(axis.y * axis.x) * affcosa + (axis.z * sina), (axis.y * axis.y) * affcosa + cosa, (axis.y * axis.z) * affcosa - (axis.x * sina), T(0),
				(axis.z * axis.x) * affcosa - (axis.y * sina), (axis.z * axis.y) * affcosa + (axis.x * sina), (axis.z * axis.z) * affcosa + cosa, T(0),
				T(0), T(0), T(0), T(1) };
			return r;
		}
 
		static RMatrix4<T> CreateRotationQuaternion (const TQuaternion<T>& quaternion) {
			T w2 = castto(T, quaternion.w * quaternion.w);
			T x2 = castto(T, quaternion.x * quaternion.x);
			T y2 = castto(T, quaternion.y * quaternion.y);
			T z2 = castto(T, quaternion.z * quaternion.z);
			T dx = castto(T, 2 * quaternion.x);
			T dy = castto(T, 2 * quaternion.y);
			T dw = castto(T, 2 * quaternion.w);
			RMatrix4<T> r = {
				w2 + x2 - y2 - z2, dx * quaternion.y - dw * quaternion.z, dx * quaternion.z + dw * quaternion.y, T(0),
				dx * quaternion.y + dw * quaternion.z, w2 - x2 + y2 - z2, dy * quaternion.z + dw * quaternion.x, T(0),
				dx * quaternion.z - dw * quaternion.y, dy * quaternion.z - dw * quaternion.x, w2 - x2 - y2 + z2, T(0),
				T(0), T(0), T(0), T(1) };
			return r;
		}
 
		static RMatrix4<T> CreateScale (T sx, T sy, T sz) {
			RMatrix4<T> r = {
				sx, T(0), T(0), T(0),
				T(0), sy, T(0), T(0),
				T(0), T(0), sz, T(0),
				T(0), T(0), T(0), T(1) };
			return r;
		}
 
		static RMatrix4<T> CreateScale (T s) {
			return CreateScale(s, s, s);
		}
 
		static RMatrix4<T> CreateScale (const TVector3<T>& s) {
			return CreateScale(s.x, s.y, s.z);
		}
 
		static RMatrix4<T> CreateScale (T sx, T sy, T sz, const TVector3<T>& origin) {
			RMatrix4<T> r = {
				sx, T(0), T(0), origin.x * (T(1) - sx),
				T(0), sy, T(0), origin.y * (T(1) - sy),
				T(0), T(0), sz, origin.z * (T(1) - sz),
				T(0), T(0), T(0), T(1) };
			return r;
		}
 
		static RMatrix4<T> CreateScale (T s, const TVector3<T>& origin) {
			return CreateScale(s, s, s, origin);
		}
 
		static RMatrix4<T> CreateScale (const TVector3<T>& s, const TVector3<T>& origin) {
			return CreateScale(s.x, s.y, s.z, origin);
		}
 
		static RMatrix4<T> CreateReflectionX () {
			RMatrix4<T> r = {
				-T(1), T(0), T(0), T(0),
				T(0), T(1), T(0), T(0),
				T(0), T(0), T(1), T(0),
				T(0), T(0), T(0), T(1) };
			return r;
		}
 
		static RMatrix4<T> CreateReflectionY () {
			RMatrix4<T> r = {
				T(1), T(0), T(0), T(0),
				T(0), -T(1), T(0), T(0),
				T(0), T(0), T(1), T(0),
				T(0), T(0), T(0), T(1) };
			return r;
		}
 
		static RMatrix4<T> CreateReflectionZ () {
			RMatrix4<T> r = {
				T(1), T(0), T(0), T(0),
				T(0), T(1), T(0), T(0),
				T(0), T(0), -T(1), T(0),
				T(0), T(0), T(0), T(1) };
			return r;
		}
 
		static RMatrix4<T> CreateReflection (const TVector3<T>& normal, const TVector3<T>& origin) {
			T doubledotnormorigin = ((T)2) * (normal.Dot(origin));
			RMatrix4<T> r = {
				T(1) - ((T)2) * normal[0] * normal[0],
				-((T)2) * normal[0] * normal[1],
				-((T)2) * normal[0] * normal[2],
				doubledotnormorigin * normal[0],
				-((T)2) * normal[1] * normal[0],
				T(1) - ((T)2) * normal[1] * normal[1],
				-((T)2) * normal[1] * normal[2],
				doubledotnormorigin * normal[1],
				-((T)2) * normal[2] * normal[0],
				-((T)2) * normal[2] * normal[1],
				T(1) - ((T)2) * normal[2] * normal[2],
				doubledotnormorigin * normal[2],
				T(0),
				T(0),
				T(0),
				T(1)
			};
			return r;
		}
 
		static RMatrix4<T> CreateObliqueProjection (const TVector3<T>& normal, const TVector3<T>& origin, const TVector3<T>& direction) {
			T normaldotdir = normal.Dot(direction);
			T normaldotorigin = normal.Dot(origin);
 
#ifdef FURROVINECOORDINATESYSTEM_LEFTHANDED
			RMatrix4<T> r = {
				direction[0] * normal[0] - normaldotdir,
				direction[0] * normal[1],
				direction[0] * normal[2],
				-normaldotorigin * direction[0],
				direction[1] * normal[0],
				direction[1] * normal[1] - normaldotdir,
				direction[1] * normal[2],
				-normaldotorigin * direction[1],
				-direction[2] * normal[0],
				-direction[2] * normal[1],
				-direction[2] * normal[2] - normaldotdir,
				normaldotorigin * direction[2],
				T(0),
				T(0),
				T(0),
				-normaldotdir
			};
#else
			RMatrix4<T> r = {
				direction[0] * normal[0] - normaldotdir,
				direction[0] * normal[1],
				direction[0] * normal[2],
				-normaldotorigin * direction[0],
				direction[1] * normal[0],
				direction[1] * normal[1] - normaldotdir,
				direction[1] * normal[2],
				-normaldotorigin * direction[1],
				direction[2] * normal[0],
				direction[2] * normal[1],
				direction[2] * normal[2] - normaldotdir,
				-normaldotorigin * direction[2],
				T(0),
				T(0),
				T(0),
				-normaldotdir
			};
#endif
 
			return r;
		}
 
		static RMatrix4<T> CreateOrthographicProjectionOffCenter ( T left, T right,  T bottom,  T top ) {
			return CreateOrthographicProjectionOffCenter(left, right, bottom, top, (T)-1, (T)1 );
		}
 
		static RMatrix4<T> CreateOrthographicProjectionOffCenter ( T left, T right,  T bottom,  T top, T nearplane, T farplane ) {
#ifdef FURROVINECOORDINATESYSTEM_LEFTHANDED
			RMatrix4<T> r = {
				T(2) / (right - left), T(0), T(0), T(0),
				T(0), T(2) / (top - bottom), T(0), T(0),
				-T(0), -T(0), T(2) / (farplane - nearplane), -T(0),
				- (right + left) / (right - left), - (top + bottom) / (top - bottom), - (farplane + nearplane) / (farplane - nearplane), T(1)
			};
#else
			RMatrix4<T> r = {
				T(2) / (right - left), T(0), T(0), T(0),
				T(0), T(2) / (top - bottom), T(0), T(0),
				T(0), T(0), -T(2) / (farplane - nearplane), T(0),
				- (right + left) / (right - left), - (top + bottom) / (top - bottom), - (farplane + nearplane) / (farplane - nearplane), T(1)
			};
#endif
			return r;
		}
 
		static RMatrix4<T> CreateOrthographicProjection ( T left, T right,  T bottom,  T top ) {
#ifdef FURROVINECOORDINATESYSTEM_LEFTHANDED
			RMatrix4<T> r = {
				T(2) / (right - left), T(0), T(0), T(0),
				T(0), T(2) / (top - bottom), T(0), T(0),
				-T(0), -T(0), T(1), -T(0),
				- (right + left) / (right - left), - (top + bottom) / (top - bottom), T(0), T(1)
			};
#else
			RMatrix4<T> r = {
				T(2) / (right - left), T(0), T(0), T(0),
				T(0), T(2) / (top - bottom), T(0), T(0),
				T(0), T(0), -T(1), T(0),
				- (right + left) / (right - left), - (top + bottom) / (top - bottom), T(0), T(1)
			};
#endif
			return r;
		}
 
		static RMatrix4<T> CreatePerspectiveProjection ( T left, T right, T bottom, T top, T nearplane, T farplane ) {
#ifdef FURROVINECOORDINATESYSTEM_LEFTHANDED
			RMatrix4<T> = r {
				(T(2) * nearplane) / (right - left), T(0), (right + left) / (right - left), T(0),
					T(0), (T(2) * nearplane) / (top - bottom), (top + bottom) / (top - bottom), T(0),
					-T(0), -T(0), (farplane + nearplane) / (farplane - nearplane), (T(2) * farplane * nearplane) / (farplane - nearplane),
					T(0), T(0), -T(1), T(0)
			};
#else
			RMatrix4<T> r = {
				(T(2) * nearplane) / (right - left), T(0), (right + left) / (right - left), T(0),
				T(0), (T(2) * nearplane) / (top - bottom), (top + bottom) / (top - bottom), T(0),
				T(0), T(0), -(farplane + nearplane) / (farplane - nearplane), -(T(2) * farplane * nearplane) / (farplane - nearplane),
				T(0), T(0), -T(1), T(0)
			};
#endif
			return r;
		}
 
		static RMatrix4<T> CreatePerspectiveProjection ( T fovy, T aspect, T nearplane, T farplane) {
			T range = Mathema<T>::Tan(fovy / T(2)) * nearplane;
			T left = -range * aspect;
			T right = range * aspect;
			T bottom = -range;
			T top = range;
#ifdef FURROVINECOORDINATESYSTEM_LEFTHANDED
			RMatrix4<T> r = {
				(T(2) * nearplane) / (right - left), T(0), (right + left) / (right - left), T(0),
				T(0), (T(2) * nearplane) / (top - bottom), (top + bottom) / (top - bottom), T(0),
				-T(0), -T(0), (farplane + nearplane) / (farplane - nearplane), (T(2) * farplane * nearplane) / (farplane - nearplane),
				T(0), T(0), -T(1), T(0)
			};
#else
			RMatrix4<T> r = {
				(T(2) * nearplane) / (right - left), T(0), (right + left) / (right - left), T(0),
				T(0), (T(2) * nearplane) / (top - bottom), (top + bottom) / (top - bottom), T(0),
				T(0), T(0), -(farplane + nearplane) / (farplane - nearplane), -(T(2) * farplane * nearplane) / (farplane - nearplane),
				T(0), T(0), -T(1), T(0)
			};
#endif
			return r;
		}
 
		static RMatrix4<T> CreatePerspectiveFoV ( T fov, T width, T height, T nearplane, T farplane) {
			T rad = (T)Mathema<T>::Radians(fov);
			T h = Mathema<T>::Cos(T(0.5) * rad) / Mathema<T>::Sin(T(0.5) * rad);
			T w = h * height / width;
 
#ifdef FURROVINECOORDINATESYSTEM_LEFTHANDED
			RMatrix4<T> r = {
				w, T(0), T(0), T(0),
				T(0), h, T(0), T(0),
				-T(0), -T(0), (farplane + nearplane) / (farplane - nearplane), (T(2) * farplane * nearplane) / (farplane - nearplane),
				T(0), T(0), -T(1), T(0)
			};
#else
			RMatrix4<T> r = {
				w, T(0), T(0), T(0),
				T(0), h, T(0), T(0),
				T(0), T(0), -(farplane + nearplane) / (farplane - nearplane), -T(1),
				T(0), T(0), -(T(2) * farplane * nearplane) / (farplane - nearplane), T(0)
			};
#endif
			return r;
		}
 
		static RMatrix4<T> CreateInfinitePerspective (T fovy, T aspect, T nearplane) {
			T range = Mathema<T>::Tan(fovy / T(2)) * nearplane;
			T left = -range * aspect;
			T right = range * aspect;
			T bottom = -range;
			T top = range;
 
#ifdef FURROVINECOORDINATESYSTEM_LEFTHANDED
			RMatrix4<T> r = {
				(T(2) * nearplane) / (right - left), T(0), T(0), T(0),
				T(0), (T(2) * nearplane) / (top - bottom), T(0), T(0),
				-T(0), -T(0), T(1), T(1),
				T(0), T(0), -T(2) * nearplane, T(0)
			};
#else
			RMatrix4<T> r = {
				(T(2) * nearplane) / (right - left), T(0), T(0), T(0),
				T(0), (T(2) * nearplane) / (top - bottom), T(0), T(0),
				T(0), T(0), -T(1), -T(1),
				T(0), T(0), -T(2) * nearplane, T(0)
			};
#endif
			return r;
		}
 
		static RMatrix4<T> CreateInfinitePerspective2 (T fovy, T aspect, T nearplane) {
			T range = Mathema<T>::Tan((fovy / T(2))) * nearplane;
			T left = -range * aspect;
			T right = range * aspect;
			T bottom = -range;
			T top = range;
#ifdef FURROVINECOORDINATESYSTEM_LEFTHANDED
			RMatrix4<T> r = {
				(T(2) * nearplane) / (right - left), T(0), T(0), T(0),
				T(0), (T(2) * nearplane) / (top - bottom), T(0), T(0),
				-T(0), -T(0), T(0.0001) + T(1), T(1),
				T(0), T(0), (T(0.0001) - T(2)) * nearplane, T(0)
			};
#else
			RMatrix4<T> r = {
				(T(2) * nearplane) / (right - left), T(0), T(0), T(0),
				T(0), (T(2) * nearplane) / (top - bottom), T(0), T(0),
				T(0), T(0), T(0.0001) - T(1), -T(1),
				T(0), T(0), (T(0.0001) - T(2)) * nearplane, T(0)
			};
#endif
			return r;
		}
 
		static RMatrix4<T> CreateLookAt ( const TVector3<T>& eye, const TVector3<T>& center, const TVector3<T>& up) {
			TVector3<T> f = TVector3<T>::Normalize(center - eye);
			TVector3<T> u = TVector3<T>::Normalize(up);
			TVector3<T> s = TVector3<T>::Normalize(f.Cross(u));
			u = s.Cross(f);
 
#ifdef FURROVINECOORDINATESYSTEM_LEFTHANDED
			RMatrix4<T> r = {
				s.x, s.y, s.z, -s.Dot(eye),
				u.x, u.y, u.z, -u.Dot(eye),
				f.x, f.y, f.z, -f.Dot(eye),
				T(0), T(0), T(0), T(1)
			};
#else
			RMatrix4<T> r = {
				s.x, s.y, s.z, -s.Dot(eye),
				u.x, u.y, u.z, -u.Dot(eye),
				f.x, f.y, f.z, -f.Dot(eye),
				T(0), T(0), T(0), T(1)
			};
#endif
			return r;
		}
 
		static RMatrix4<T> CreateShearX (T dyradians, T dzradians) {
			dyradians = Mathema<T>::Tan(dyradians);
			dzradians = Mathema<T>::Tan(dzradians);
			RMatrix4<T> r = {
				T(1), dyradians, dzradians, T(0),
				T(0), T(1), T(0), T(0),
				T(0), T(0), T(1), T(0),
				T(0), T(0), T(0), T(1) };
			return r;
		}
 
		static RMatrix4<T> CreateShearX (T radians) {
			radians = Mathema<T>::Tan(radians);
			RMatrix4<T> r = {
				T(1), radians, radians, T(0),
				T(0), T(1), T(0), T(0),
				T(0), T(0), T(1), T(0),
				T(0), T(0), T(0), T(1) };
			return r;
		}
 
		static RMatrix4<T> CreateShearY (T radians) {
			radians = Mathema<T>::Tan(radians);
			RMatrix4<T> r = {
				T(1), T(0), T(0), T(0),
				radians, T(1), radians, T(0),
				T(0), T(0), T(1), T(0),
				T(0), T(0), T(0), T(1) };
			return r;
		}
 
		static RMatrix4<T> CreateShearY (T dxradians, T dzradians) {
			dxradians = Mathema<T>::Tan(dxradians);
			dzradians = Mathema<T>::Tan(dzradians);
			RMatrix4<T> r = {
				T(1), T(0), T(0), T(0),
				dxradians, T(1), dzradians, T(0),
				T(0), T(0), T(1), T(0),
				T(0), T(0), T(0), T(1) };
			return r;
		}
 
		static RMatrix4<T> CreateShearZ (T radians) {
			radians = Mathema<T>::Tan(radians);
			RMatrix4<T> r = {
				T(1), T(0), T(0), T(0),
				T(0), T(1), T(0), T(0),
				radians, radians, T(1), T(0),
				T(0), T(0), T(0), T(1) };
			return r;
		}
 
		static RMatrix4<T> CreateShearZ (T dxradians, T dyradians) {
			dxradians = Mathema<T>::Tan(dxradians);
			dyradians = Mathema<T>::Tan(dyradians);
			RMatrix4<T> r = {
				T(1), T(0), T(0), T(0),
				T(0), T(1), T(0), T(0),
				dxradians, dyradians, T(1), T(0),
				T(0), T(0), T(0), T(1) };
			return r;
		}
 
		static RMatrix4<T> CreateShear (T xradians = T(0), T yradians = T(0), T zradians = T(0)) {
			xradians = Mathema<T>::Tan(xradians);
			yradians = Mathema<T>::Tan(yradians);
			zradians = Mathema<T>::Tan(zradians);
			RMatrix4<T> r = {
				T(1), xradians, xradians, T(0),
				yradians, T(1), yradians, T(0),
				zradians, zradians, T(1), T(0),
				T(0), T(0), T(0), T(1) };
			return r;
		}
 
		static RMatrix4<T> CreateShear (const TVector3<T>& radians) {
			return CreateShear(radians.x, radians.y, radians.z);
		}
 
	};
 
}
 
#endif /* FURROVINERMATRIX4_H */