#pragma once



#define _USE_MATH_DEFINES  // Enable non-standard math defines (MSVC)
#include <math.h>





template <typename T>
// tolua_begin
class Matrix4
{

	TOLUA_TEMPLATE_BIND((T, float, double))

	// tolua_end

public:

	T cell[16];

	// tolua_begin

	inline Matrix4(void)
	{
		Identity();
	}

	inline Matrix4(const Matrix4 & a_Rhs)
	{
		*this = a_Rhs;
	}

	// tolua_end

	inline Matrix4 & operator = (const Matrix4 & a_Rhs)
	{
		for (unsigned int i = 0; i < 16; ++i)
		{
			cell[i] = a_Rhs.cell[i];
		}
		return *this;
	}

	// tolua_begin

	inline T & operator [] (int a_N)
	{
		ASSERT(a_N < 16);
		return cell[a_N];
	}

	inline void Identity()
	{
		cell[1]  = cell[2]  = cell[3]  = cell[4]  = 0;
		cell[6]  = cell[7]  = cell[8]  = cell[9]  = 0;
		cell[11] = cell[12] = cell[13] = cell[14] = 0;

		cell[0] = cell[5] = cell[10] = cell[15] = 1;
	}

	inline void Init(const Vector3<T> & a_Pos, T a_RX, T a_RY, T a_RZ)
	{
		Matrix4<T> t;
		t.RotateX(a_RZ);
		RotateY(a_RY);
		Concatenate(t);
		t.RotateZ(a_RX);
		Concatenate(t);
		Translate(a_Pos);
	}

	inline void RotateX(T a_RX)
	{
		T sx = static_cast<T>(sin(a_RX * M_PI / 180));
		T cx = static_cast<T>(cos(a_RX * M_PI / 180));

		Identity();

		cell[5] = cx;  cell[6]  = sx;
		cell[9] = -sx; cell[10] = cx;
	}

	inline void RotateY(T a_RY)
	{
		T sy = static_cast<T>(sin(a_RY * M_PI / 180));
		T cy = static_cast<T>(cos(a_RY * M_PI / 180));

		Identity();

		cell[0] = cy; cell[2] = -sy;
		cell[8] = sy; cell[10] = cy;
	}

	inline void RotateZ(T a_RZ)
	{
		T sz = static_cast<T>(sin(a_RZ * M_PI / 180));
		T cz = static_cast<T>(cos(a_RZ * M_PI / 180));

		Identity();

		cell[0] = cz;  cell[1] = sz;
		cell[4] = -sz; cell[5] = cz;
	}

	inline void Translate(const Vector3<T> & a_Pos)
	{
		cell[3]  += a_Pos.x;
		cell[7]  += a_Pos.y;
		cell[11] += a_Pos.z;
	}

	inline void SetTranslation(const Vector3<T> & a_Pos)
	{
		cell[3]  = a_Pos.x;
		cell[7]  = a_Pos.y;
		cell[11] = a_Pos.z;
	}

	inline void Concatenate(const Matrix4 & m2)
	{
		Matrix4 res;

		for (unsigned int c = 0; c < 4; ++c)
		{
			for (unsigned int r = 0; r < 4; ++r)
			{
				res.cell[r * 4 + c] = (
					cell[r * 4 + 0] * m2.cell[c + 0] +
					cell[r * 4 + 1] * m2.cell[c + 4] +
					cell[r * 4 + 2] * m2.cell[c + 8] +
					cell[r * 4 + 3] * m2.cell[c + 12]
				);
			}
		}

		*this = res;
	}

	inline Vector3<T> Transform(const Vector3<T> & v) const
	{
		T x  = cell[0] * v.x + cell[1] * v.y + cell[2]  * v.z + cell[3];
		T y  = cell[4] * v.x + cell[5] * v.y + cell[6]  * v.z + cell[7];
		T z  = cell[8] * v.x + cell[9] * v.y + cell[10] * v.z + cell[11];

		return Vector3<T>(x, y, z);
	}

	inline void Invert(void)
	{
		Matrix4 t;

		T tx = -cell[3];
		T ty = -cell[7];
		T tz = -cell[11];

		for (unsigned int h = 0; h < 3; ++h)
		{
			for (unsigned int v = 0; v < 3; ++v)
			{
				t.cell[h + v * 4] = cell[v + h * 4];
			}
		}

		for (unsigned int i = 0; i < 11; ++i)
		{
			cell[i] = t.cell[i];
		}

		cell[3]  = tx * cell[0] + ty * cell[1] + tz * cell[2];
		cell[7]  = tx * cell[4] + ty * cell[5] + tz * cell[6];
		cell[11] = tx * cell[8] + ty * cell[9] + tz * cell[10];
	}

	inline Vector3<T> GetXColumn(void) const
	{
		return Vector3<T>(cell[0], cell[1], cell[2]);
	}

	inline Vector3<T> GetYColumn(void) const
	{
		return Vector3<T>(cell[4], cell[5], cell[6]);
	}

	inline Vector3<T> GetZColumn(void) const
	{
		return Vector3<T>(cell[8], cell[9], cell[10]);
	}

	inline void SetXColumn(const Vector3<T> & a_X)
	{
		cell[0] = a_X.x;
		cell[1] = a_X.y;
		cell[2] = a_X.z;
	}

	inline void SetYColumn(const Vector3<T> & a_Y)
	{
		cell[4] = a_Y.x;
		cell[5] = a_Y.y;
		cell[6] = a_Y.z;
	}

	inline void SetZColumn(const Vector3<T> & a_Z)
	{
		cell[8]  = a_Z.x;
		cell[9]  = a_Z.y;
		cell[10] = a_Z.z;
	}
};
// tolua_end




// tolua_begin
typedef Matrix4<double> Matrix4d;
typedef Matrix4<float>  Matrix4f;
// tolua_end