#ifndef __MATRIX4X4__
#define __MATRIX4X4__
#include "Math.h"

namespace LifeMath
{
#undef INLINE
#ifdef _WIN32
#ifdef _MSC_VER
#define INLINE __forceinline
#define ALIGN_MATRIX __declspec(align(16))
#endif
#else
#define ALIGN_MATRIX
#ifdef __GNUC__
#define INLINE __attribute__((always_inline))
#endif
#endif
#ifndef INLINE
#define INLINE inline
#endif

	typedef ALIGN_MATRIX struct Matrix4x4
	{
	public:
		float M11;
		float M12;
		float M13;
		float M14;
		float M21;
		float M22;
		float M23;
		float M24;
		float M31;
		float M32;
		float M33;
		float M34;
		float M41;
		float M42;
		float M43;
		float M44;

		void setup(
			float _m11, float _m12, float _m13, float _m14,
			float _m21, float _m22, float _m23, float _m24,
			float _m31, float _m32, float _m33, float _m34,
			float _m41, float _m42, float _m43, float _m44)
		{
			M11 = _m11;
			M12 = _m12;
			M13 = _m13;
			M14 = _m14;

			M21 = _m21;
			M22 = _m22;
			M23 = _m23;
			M24 = _m24;

			M31 = _m31;
			M32 = _m32;
			M33 = _m33;
			M34 = _m34;

			M41 = _m41;
			M42 = _m42;
			M43 = _m43;
			M44 = _m44;
		}

		INLINE Matrix4x4 operator *(const Matrix4x4& matrix2)  const
		{
			Matrix4x4 matrix;
			matrix.M11 = (((this->M11 * matrix2.M11) + (this->M12 * matrix2.M21)) + (this->M13 * matrix2.M31)) + (this->M14 * matrix2.M41);
			matrix.M12 = (((this->M11 * matrix2.M12) + (this->M12 * matrix2.M22)) + (this->M13 * matrix2.M32)) + (this->M14 * matrix2.M42);
			matrix.M13 = (((this->M11 * matrix2.M13) + (this->M12 * matrix2.M23)) + (this->M13 * matrix2.M33)) + (this->M14 * matrix2.M43);
			matrix.M14 = (((this->M11 * matrix2.M14) + (this->M12 * matrix2.M24)) + (this->M13 * matrix2.M34)) + (this->M14 * matrix2.M44);
			matrix.M21 = (((this->M21 * matrix2.M11) + (this->M22 * matrix2.M21)) + (this->M23 * matrix2.M31)) + (this->M24 * matrix2.M41);
			matrix.M22 = (((this->M21 * matrix2.M12) + (this->M22 * matrix2.M22)) + (this->M23 * matrix2.M32)) + (this->M24 * matrix2.M42);
			matrix.M23 = (((this->M21 * matrix2.M13) + (this->M22 * matrix2.M23)) + (this->M23 * matrix2.M33)) + (this->M24 * matrix2.M43);
			matrix.M24 = (((this->M21 * matrix2.M14) + (this->M22 * matrix2.M24)) + (this->M23 * matrix2.M34)) + (this->M24 * matrix2.M44);
			matrix.M31 = (((this->M31 * matrix2.M11) + (this->M32 * matrix2.M21)) + (this->M33 * matrix2.M31)) + (this->M34 * matrix2.M41);
			matrix.M32 = (((this->M31 * matrix2.M12) + (this->M32 * matrix2.M22)) + (this->M33 * matrix2.M32)) + (this->M34 * matrix2.M42);
			matrix.M33 = (((this->M31 * matrix2.M13) + (this->M32 * matrix2.M23)) + (this->M33 * matrix2.M33)) + (this->M34 * matrix2.M43);
			matrix.M34 = (((this->M31 * matrix2.M14) + (this->M32 * matrix2.M24)) + (this->M33 * matrix2.M34)) + (this->M34 * matrix2.M44);
			matrix.M41 = (((this->M41 * matrix2.M11) + (this->M42 * matrix2.M21)) + (this->M43 * matrix2.M31)) + (this->M44 * matrix2.M41);
			matrix.M42 = (((this->M41 * matrix2.M12) + (this->M42 * matrix2.M22)) + (this->M43 * matrix2.M32)) + (this->M44 * matrix2.M42);
			matrix.M43 = (((this->M41 * matrix2.M13) + (this->M42 * matrix2.M23)) + (this->M43 * matrix2.M33)) + (this->M44 * matrix2.M43);
			matrix.M44 = (((this->M41 * matrix2.M14) + (this->M42 * matrix2.M24)) + (this->M43 * matrix2.M34)) + (this->M44 * matrix2.M44);
			return matrix;
		}

		/*  public MatrixBasis Basis
		{
		get
		{
		MatrixBasis basis = new MatrixBasis();
		basis.M11 = this.M11;
		basis.M12 = this.M12;
		basis.M13 = this.M13;

		basis.M21 = this.M21;
		basis.M22 = this.M22;
		basis.M23 = this.M23;

		basis.M31 = this.M31;
		basis.M32 = this.M32;
		basis.M33 = this.M33;
		return basis;
		}
		set
		{
		this.M11 = value.M11;
		this.M12 = value.M12;
		this.M13 = value.M13;

		this.M21 = value.M21;
		this.M22 = value.M22;
		this.M23 = value.M23;

		this.M31 = value.M31;
		this.M32 = value.M32;
		this.M33 = value.M33;
		}
		}*/

		/*

		#region Decomposition
		public Vec3f Up
		{
		get
		{
		Vec3f vector;
		vector.X = this.M21;
		vector.Y = this.M22;
		vector.Z = this.M23;
		return vector;
		}
		set
		{
		this.M21 = value.X;
		this.M22 = value.Y;
		this.M23 = value.Z;
		}
		}

		public Vec3f Down
		{
		get
		{
		Vec3f vector;
		vector.X = -this.M21;
		vector.Y = -this.M22;
		vector.Z = -this.M23;
		return vector;
		}
		set
		{
		this.M21 = -value.X;
		this.M22 = -value.Y;
		this.M23 = -value.Z;
		}
		}

		public Vec3f Right
		{
		get
		{
		Vec3f vector;
		vector.X = this.M11;
		vector.Y = this.M12;
		vector.Z = this.M13;
		return vector;
		}
		set
		{
		this.M11 = value.X;
		this.M12 = value.Y;
		this.M13 = value.Z;
		}
		}

		public Vec3f Left
		{
		get
		{
		Vec3f vector;
		vector.X = -this.M11;
		vector.Y = -this.M12;
		vector.Z = -this.M13;
		return vector;
		}
		set
		{
		this.M11 = -value.X;
		this.M12 = -value.Y;
		this.M13 = -value.Z;
		}
		}

		public Vec3f Forward
		{
		get
		{
		Vec3f vector;
		vector.X = -this.M31;
		vector.Y = -this.M32;
		vector.Z = -this.M33;
		return vector;
		}
		set
		{
		this.M31 = -value.X;
		this.M32 = -value.Y;
		this.M33 = -value.Z;
		}
		}

		public Vec3f Backward
		{
		get
		{
		Vec3f vector;
		vector.X = this.M31;
		vector.Y = this.M32;
		vector.Z = this.M33;
		return vector;
		}
		set
		{
		this.M31 = value.X;
		this.M32 = value.Y;
		this.M33 = value.Z;
		}
		}

		public Vec3f Position
		{
		get
		{
		Vec3f vector;
		vector.X = this.M41;
		vector.Y = this.M42;
		vector.Z = this.M43;
		return vector;
		}
		set
		{
		this.M41 = value.X;
		this.M42 = value.Y;
		this.M43 = value.Z;
		}
		}

		public void Decompose(out Vec3f scale, out CQuaternion rotation, out Vec3f translation)
		{
		MatrixBasis b = this.Basis;

		scale = b.Scaling;

		translation.X = this.M41;
		translation.Y = this.M42;
		translation.Z = this.M43;

		b.Scaling = new Vec3f(1, 1, 1);

		rotation = CQuaternion.RotationBasis(b);
		}

		#endregion*/
	} Matrix4x4, *PMatrix4x4, **LPMatrix4x4;
    typedef Matrix4x4 float4x4;
}
#endif