bullet3

///////////////////////////////////////////////////////////////////////////////
// Matrice.h
// =========
// NxN Matrix Math classes
//
// The elements of the matrix are stored as column major order.
// | 0 2 |    | 0 3 6 |    |  0  4  8 12 |
// | 1 3 |    | 1 4 7 |    |  1  5  9 13 |
//            | 2 5 8 |    |  2  6 10 14 |
//                         |  3  7 11 15 |
//
//  AUTHOR: Song Ho Ahn (song.ahn@gmail.com)
// CREATED: 2005-06-24
// UPDATED: 2013-09-30
//
// Copyright (C) 2005 Song Ho Ahn
///////////////////////////////////////////////////////////////////////////////

#ifndef MATH_MATRICES_H
#define MATH_MATRICES_H

#include <iostream>
#include <iomanip>
#include "Vectors.h"

///////////////////////////////////////////////////////////////////////////
// 2x2 matrix
///////////////////////////////////////////////////////////////////////////
class Matrix2
{
public:
	// constructors
	Matrix2();  // init with identity
	Matrix2(const float src[4]);
	Matrix2(float m0, float m1, float m2, float m3);

	void set(const float src[4]);
	void set(float m0, float m1, float m2, float m3);
	void setRow(int index, const float row[2]);
	void setRow(int index, const Vector2& v);
	void setColumn(int index, const float col[2]);
	void setColumn(int index, const Vector2& v);

	const float* get() const;
	float getDeterminant();

	Matrix2& identity();
	Matrix2& transpose();  // transpose itself and return reference
	Matrix2& invert();

	// operators
	Matrix2 operator+(const Matrix2& rhs) const;  // add rhs
	Matrix2 operator-(const Matrix2& rhs) const;  // subtract rhs
	Matrix2& operator+=(const Matrix2& rhs);      // add rhs and update this object
	Matrix2& operator-=(const Matrix2& rhs);      // subtract rhs and update this object
	Vector2 operator*(const Vector2& rhs) const;  // multiplication: v' = M * v
	Matrix2 operator*(const Matrix2& rhs) const;  // multiplication: M3 = M1 * M2
	Matrix2& operator*=(const Matrix2& rhs);      // multiplication: M1' = M1 * M2
	bool operator==(const Matrix2& rhs) const;    // exact compare, no epsilon
	bool operator!=(const Matrix2& rhs) const;    // exact compare, no epsilon
	float operator[](int index) const;            // subscript operator v[0], v[1]
	float& operator[](int index);                 // subscript operator v[0], v[1]

	friend Matrix2 operator-(const Matrix2& m);                      // unary operator (-)
	friend Matrix2 operator*(float scalar, const Matrix2& m);        // pre-multiplication
	friend Vector2 operator*(const Vector2& vec, const Matrix2& m);  // pre-multiplication
	friend std::ostream& operator<<(std::ostream& os, const Matrix2& m);

protected:
private:
	float m[4];
};

///////////////////////////////////////////////////////////////////////////
// 3x3 matrix
///////////////////////////////////////////////////////////////////////////
class Matrix3
{
public:
	// constructors
	Matrix3();  // init with identity
	Matrix3(const float src[9]);
	Matrix3(float m0, float m1, float m2,   // 1st column
			float m3, float m4, float m5,   // 2nd column
			float m6, float m7, float m8);  // 3rd column

	void set(const float src[9]);
	void set(float m0, float m1, float m2,   // 1st column
			 float m3, float m4, float m5,   // 2nd column
			 float m6, float m7, float m8);  // 3rd column
	void setRow(int index, const float row[3]);
	void setRow(int index, const Vector3& v);
	void setColumn(int index, const float col[3]);
	void setColumn(int index, const Vector3& v);

	const float* get() const;
	float getDeterminant();

	Matrix3& identity();
	Matrix3& transpose();  // transpose itself and return reference
	Matrix3& invert();

	// operators
	Matrix3 operator+(const Matrix3& rhs) const;  // add rhs
	Matrix3 operator-(const Matrix3& rhs) const;  // subtract rhs
	Matrix3& operator+=(const Matrix3& rhs);      // add rhs and update this object
	Matrix3& operator-=(const Matrix3& rhs);      // subtract rhs and update this object
	Vector3 operator*(const Vector3& rhs) const;  // multiplication: v' = M * v
	Matrix3 operator*(const Matrix3& rhs) const;  // multiplication: M3 = M1 * M2
	Matrix3& operator*=(const Matrix3& rhs);      // multiplication: M1' = M1 * M2
	bool operator==(const Matrix3& rhs) const;    // exact compare, no epsilon
	bool operator!=(const Matrix3& rhs) const;    // exact compare, no epsilon
	float operator[](int index) const;            // subscript operator v[0], v[1]
	float& operator[](int index);                 // subscript operator v[0], v[1]

	friend Matrix3 operator-(const Matrix3& m);                      // unary operator (-)
	friend Matrix3 operator*(float scalar, const Matrix3& m);        // pre-multiplication
	friend Vector3 operator*(const Vector3& vec, const Matrix3& m);  // pre-multiplication
	friend std::ostream& operator<<(std::ostream& os, const Matrix3& m);

protected:
private:
	float m[9];
};

///////////////////////////////////////////////////////////////////////////
// 4x4 matrix
///////////////////////////////////////////////////////////////////////////
class Matrix4
{
public:
	// constructors
	Matrix4();  // init with identity
	Matrix4(const float src[16]);
	Matrix4(float m00, float m01, float m02, float m03,   // 1st column
			float m04, float m05, float m06, float m07,   // 2nd column
			float m08, float m09, float m10, float m11,   // 3rd column
			float m12, float m13, float m14, float m15);  // 4th column

	void set(const float src[16]);
	void set(float m00, float m01, float m02, float m03,   // 1st column
			 float m04, float m05, float m06, float m07,   // 2nd column
			 float m08, float m09, float m10, float m11,   // 3rd column
			 float m12, float m13, float m14, float m15);  // 4th column
	void setRow(int index, const float row[4]);
	void setRow(int index, const Vector4& v);
	void setRow(int index, const Vector3& v);
	void setColumn(int index, const float col[4]);
	void setColumn(int index, const Vector4& v);
	void setColumn(int index, const Vector3& v);

	const float* get() const;
	const float* getTranspose();  // return transposed matrix
	float getDeterminant();

	Matrix4& identity();
	Matrix4& transpose();         // transpose itself and return reference
	Matrix4& invert();            // check best inverse method before inverse
	Matrix4& invertEuclidean();   // inverse of Euclidean transform matrix
	Matrix4& invertAffine();      // inverse of affine transform matrix
	Matrix4& invertProjective();  // inverse of projective matrix using partitioning
	Matrix4& invertGeneral();     // inverse of generic matrix

	// transform matrix
	Matrix4& translate(float x, float y, float z);      // translation by (x,y,z)
	Matrix4& translate(const Vector3& v);               //
	Matrix4& rotate(float angle, const Vector3& axis);  // rotate angle(degree) along the given axix
	Matrix4& rotate(float angle, float x, float y, float z);
	Matrix4& rotateX(float angle);                 // rotate on X-axis with degree
	Matrix4& rotateY(float angle);                 // rotate on Y-axis with degree
	Matrix4& rotateZ(float angle);                 // rotate on Z-axis with degree
	Matrix4& scale(float scale);                   // uniform scale
	Matrix4& scale(float sx, float sy, float sz);  // scale by (sx, sy, sz) on each axis

	// operators
	Matrix4 operator+(const Matrix4& rhs) const;  // add rhs
	Matrix4 operator-(const Matrix4& rhs) const;  // subtract rhs
	Matrix4& operator+=(const Matrix4& rhs);      // add rhs and update this object
	Matrix4& operator-=(const Matrix4& rhs);      // subtract rhs and update this object
	Vector4 operator*(const Vector4& rhs) const;  // multiplication: v' = M * v
	Vector3 operator*(const Vector3& rhs) const;  // multiplication: v' = M * v
	Matrix4 operator*(const Matrix4& rhs) const;  // multiplication: M3 = M1 * M2
	Matrix4& operator*=(const Matrix4& rhs);      // multiplication: M1' = M1 * M2
	bool operator==(const Matrix4& rhs) const;    // exact compare, no epsilon
	bool operator!=(const Matrix4& rhs) const;    // exact compare, no epsilon
	float operator[](int index) const;            // subscript operator v[0], v[1]
	float& operator[](int index);                 // subscript operator v[0], v[1]

	friend Matrix4 operator-(const Matrix4& m);                      // unary operator (-)
	friend Matrix4 operator*(float scalar, const Matrix4& m);        // pre-multiplication
	friend Vector3 operator*(const Vector3& vec, const Matrix4& m);  // pre-multiplication
	friend Vector4 operator*(const Vector4& vec, const Matrix4& m);  // pre-multiplication
	friend std::ostream& operator<<(std::ostream& os, const Matrix4& m);

protected:
private:
	float getCofactor(float m0, float m1, float m2,
					  float m3, float m4, float m5,
					  float m6, float m7, float m8);

	float m[16];
	float tm[16];  // transpose m
};

///////////////////////////////////////////////////////////////////////////
// inline functions for Matrix2
///////////////////////////////////////////////////////////////////////////
inline Matrix2::Matrix2()
{
	// initially identity matrix
	identity();
}

inline Matrix2::Matrix2(const float src[4])
{
	set(src);
}

inline Matrix2::Matrix2(float m0, float m1, float m2, float m3)
{
	set(m0, m1, m2, m3);
}

inline void Matrix2::set(const float src[4])
{
	m[0] = src[0];
	m[1] = src[1];
	m[2] = src[2];
	m[3] = src[3];
}

inline void Matrix2::set(float m0, float m1, float m2, float m3)
{
	m[0] = m0;
	m[1] = m1;
	m[2] = m2;
	m[3] = m3;
}

inline void Matrix2::setRow(int index, const float row[2])
{
	m[index] = row[0];
	m[index + 2] = row[1];
}

inline void Matrix2::setRow(int index, const Vector2& v)
{
	m[index] = v.x;
	m[index + 2] = v.y;
}

inline void Matrix2::setColumn(int index, const float col[2])
{
	m[index * 2] = col[0];
	m[index * 2 + 1] = col[1];
}

inline void Matrix2::setColumn(int index, const Vector2& v)
{
	m[index * 2] = v.x;
	m[index * 2 + 1] = v.y;
}

inline const float* Matrix2::get() const
{
	return m;
}

inline Matrix2& Matrix2::identity()
{
	m[0] = m[3] = 1.0f;
	m[1] = m[2] = 0.0f;
	return *this;
}

inline Matrix2 Matrix2::operator+(const Matrix2& rhs) const
{
	return Matrix2(m[0] + rhs[0], m[1] + rhs[1], m[2] + rhs[2], m[3] + rhs[3]);
}

inline Matrix2 Matrix2::operator-(const Matrix2& rhs) const
{
	return Matrix2(m[0] - rhs[0], m[1] - rhs[1], m[2] - rhs[2], m[3] - rhs[3]);
}

inline Matrix2& Matrix2::operator+=(const Matrix2& rhs)
{
	m[0] += rhs[0];
	m[1] += rhs[1];
	m[2] += rhs[2];
	m[3] += rhs[3];
	return *this;
}

inline Matrix2& Matrix2::operator-=(const Matrix2& rhs)
{
	m[0] -= rhs[0];
	m[1] -= rhs[1];
	m[2] -= rhs[2];
	m[3] -= rhs[3];
	return *this;
}

inline Vector2 Matrix2::operator*(const Vector2& rhs) const
{
	return Vector2(m[0] * rhs.x + m[2] * rhs.y, m[1] * rhs.x + m[3] * rhs.y);
}

inline Matrix2 Matrix2::operator*(const Matrix2& rhs) const
{
	return Matrix2(m[0] * rhs[0] + m[2] * rhs[1], m[1] * rhs[0] + m[3] * rhs[1],
				   m[0] * rhs[2] + m[2] * rhs[3], m[1] * rhs[2] + m[3] * rhs[3]);
}

inline Matrix2& Matrix2::operator*=(const Matrix2& rhs)
{
	*this = *this * rhs;
	return *this;
}

inline bool Matrix2::operator==(const Matrix2& rhs) const
{
	return (m[0] == rhs[0]) && (m[1] == rhs[1]) && (m[2] == rhs[2]) && (m[3] == rhs[3]);
}

inline bool Matrix2::operator!=(const Matrix2& rhs) const
{
	return (m[0] != rhs[0]) || (m[1] != rhs[1]) || (m[2] != rhs[2]) || (m[3] != rhs[3]);
}

inline float Matrix2::operator[](int index) const
{
	return m[index];
}

inline float& Matrix2::operator[](int index)
{
	return m[index];
}

inline Matrix2 operator-(const Matrix2& rhs)
{
	return Matrix2(-rhs[0], -rhs[1], -rhs[2], -rhs[3]);
}

inline Matrix2 operator*(float s, const Matrix2& rhs)
{
	return Matrix2(s * rhs[0], s * rhs[1], s * rhs[2], s * rhs[3]);
}

inline Vector2 operator*(const Vector2& v, const Matrix2& rhs)
{
	return Vector2(v.x * rhs[0] + v.y * rhs[1], v.x * rhs[2] + v.y * rhs[3]);
}

inline std::ostream& operator<<(std::ostream& os, const Matrix2& m)
{
	os << std::fixed << std::setprecision(5);
	os << "[" << std::setw(10) << m[0] << " " << std::setw(10) << m[2] << "]\n"
	   << "[" << std::setw(10) << m[1] << " " << std::setw(10) << m[3] << "]\n";
	os << std::resetiosflags(std::ios_base::fixed | std::ios_base::floatfield);
	return os;
}
// END OF MATRIX2 INLINE //////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
// inline functions for Matrix3
///////////////////////////////////////////////////////////////////////////
inline Matrix3::Matrix3()
{
	// initially identity matrix
	identity();
}

inline Matrix3::Matrix3(const float src[9])
{
	set(src);
}

inline Matrix3::Matrix3(float m0, float m1, float m2,
						float m3, float m4, float m5,
						float m6, float m7, float m8)
{
	set(m0, m1, m2, m3, m4, m5, m6, m7, m8);
}

inline void Matrix3::set(const float src[9])
{
	m[0] = src[0];
	m[1] = src[1];
	m[2] = src[2];
	m[3] = src[3];
	m[4] = src[4];
	m[5] = src[5];
	m[6] = src[6];
	m[7] = src[7];
	m[8] = src[8];
}

inline void Matrix3::set(float m0, float m1, float m2,
						 float m3, float m4, float m5,
						 float m6, float m7, float m8)
{
	m[0] = m0;
	m[1] = m1;
	m[2] = m2;
	m[3] = m3;
	m[4] = m4;
	m[5] = m5;
	m[6] = m6;
	m[7] = m7;
	m[8] = m8;
}

inline void Matrix3::setRow(int index, const float row[3])
{
	m[index] = row[0];
	m[index + 3] = row[1];
	m[index + 6] = row[2];
}

inline void Matrix3::setRow(int index, const Vector3& v)
{
	m[index] = v.x;
	m[index + 3] = v.y;
	m[index + 6] = v.z;
}

inline void Matrix3::setColumn(int index, const float col[3])
{
	m[index * 3] = col[0];
	m[index * 3 + 1] = col[1];
	m[index * 3 + 2] = col[2];
}

inline void Matrix3::setColumn(int index, const Vector3& v)
{
	m[index * 3] = v.x;
	m[index * 3 + 1] = v.y;
	m[index * 3 + 2] = v.z;
}

inline const float* Matrix3::get() const
{
	return m;
}

inline Matrix3& Matrix3::identity()
{
	m[0] = m[4] = m[8] = 1.0f;
	m[1] = m[2] = m[3] = m[5] = m[6] = m[7] = 0.0f;
	return *this;
}

inline Matrix3 Matrix3::operator+(const Matrix3& rhs) const
{
	return Matrix3(m[0] + rhs[0], m[1] + rhs[1], m[2] + rhs[2],
				   m[3] + rhs[3], m[4] + rhs[4], m[5] + rhs[5],
				   m[6] + rhs[6], m[7] + rhs[7], m[8] + rhs[8]);
}

inline Matrix3 Matrix3::operator-(const Matrix3& rhs) const
{
	return Matrix3(m[0] - rhs[0], m[1] - rhs[1], m[2] - rhs[2],
				   m[3] - rhs[3], m[4] - rhs[4], m[5] - rhs[5],
				   m[6] - rhs[6], m[7] - rhs[7], m[8] - rhs[8]);
}

inline Matrix3& Matrix3::operator+=(const Matrix3& rhs)
{
	m[0] += rhs[0];
	m[1] += rhs[1];
	m[2] += rhs[2];
	m[3] += rhs[3];
	m[4] += rhs[4];
	m[5] += rhs[5];
	m[6] += rhs[6];
	m[7] += rhs[7];
	m[8] += rhs[8];
	return *this;
}

inline Matrix3& Matrix3::operator-=(const Matrix3& rhs)
{
	m[0] -= rhs[0];
	m[1] -= rhs[1];
	m[2] -= rhs[2];
	m[3] -= rhs[3];
	m[4] -= rhs[4];
	m[5] -= rhs[5];
	m[6] -= rhs[6];
	m[7] -= rhs[7];
	m[8] -= rhs[8];
	return *this;
}

inline Vector3 Matrix3::operator*(const Vector3& rhs) const
{
	return Vector3(m[0] * rhs.x + m[3] * rhs.y + m[6] * rhs.z,
				   m[1] * rhs.x + m[4] * rhs.y + m[7] * rhs.z,
				   m[2] * rhs.x + m[5] * rhs.y + m[8] * rhs.z);
}

inline Matrix3 Matrix3::operator*(const Matrix3& rhs) const
{
	return Matrix3(m[0] * rhs[0] + m[3] * rhs[1] + m[6] * rhs[2], m[1] * rhs[0] + m[4] * rhs[1] + m[7] * rhs[2], m[2] * rhs[0] + m[5] * rhs[1] + m[8] * rhs[2],
				   m[0] * rhs[3] + m[3] * rhs[4] + m[6] * rhs[5], m[1] * rhs[3] + m[4] * rhs[4] + m[7] * rhs[5], m[2] * rhs[3] + m[5] * rhs[4] + m[8] * rhs[5],
				   m[0] * rhs[6] + m[3] * rhs[7] + m[6] * rhs[8], m[1] * rhs[6] + m[4] * rhs[7] + m[7] * rhs[8], m[2] * rhs[6] + m[5] * rhs[7] + m[8] * rhs[8]);
}

inline Matrix3& Matrix3::operator*=(const Matrix3& rhs)
{
	*this = *this * rhs;
	return *this;
}

inline bool Matrix3::operator==(const Matrix3& rhs) const
{
	return (m[0] == rhs[0]) && (m[1] == rhs[1]) && (m[2] == rhs[2]) &&
		   (m[3] == rhs[3]) && (m[4] == rhs[4]) && (m[5] == rhs[5]) &&
		   (m[6] == rhs[6]) && (m[7] == rhs[7]) && (m[8] == rhs[8]);
}

inline bool Matrix3::operator!=(const Matrix3& rhs) const
{
	return (m[0] != rhs[0]) || (m[1] != rhs[1]) || (m[2] != rhs[2]) ||
		   (m[3] != rhs[3]) || (m[4] != rhs[4]) || (m[5] != rhs[5]) ||
		   (m[6] != rhs[6]) || (m[7] != rhs[7]) || (m[8] != rhs[8]);
}

inline float Matrix3::operator[](int index) const
{
	return m[index];
}

inline float& Matrix3::operator[](int index)
{
	return m[index];
}

inline Matrix3 operator-(const Matrix3& rhs)
{
	return Matrix3(-rhs[0], -rhs[1], -rhs[2], -rhs[3], -rhs[4], -rhs[5], -rhs[6], -rhs[7], -rhs[8]);
}

inline Matrix3 operator*(float s, const Matrix3& rhs)
{
	return Matrix3(s * rhs[0], s * rhs[1], s * rhs[2], s * rhs[3], s * rhs[4], s * rhs[5], s * rhs[6], s * rhs[7], s * rhs[8]);
}

inline Vector3 operator*(const Vector3& v, const Matrix3& m)
{
	return Vector3(v.x * m[0] + v.y * m[1] + v.z * m[2], v.x * m[3] + v.y * m[4] + v.z * m[5], v.x * m[6] + v.y * m[7] + v.z * m[8]);
}

inline std::ostream& operator<<(std::ostream& os, const Matrix3& m)
{
	os << std::fixed << std::setprecision(5);
	os << "[" << std::setw(10) << m[0] << " " << std::setw(10) << m[3] << " " << std::setw(10) << m[6] << "]\n"
	   << "[" << std::setw(10) << m[1] << " " << std::setw(10) << m[4] << " " << std::setw(10) << m[7] << "]\n"
	   << "[" << std::setw(10) << m[2] << " " << std::setw(10) << m[5] << " " << std::setw(10) << m[8] << "]\n";
	os << std::resetiosflags(std::ios_base::fixed | std::ios_base::floatfield);
	return os;
}
// END OF MATRIX3 INLINE //////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
// inline functions for Matrix4
///////////////////////////////////////////////////////////////////////////
inline Matrix4::Matrix4()
{
	// initially identity matrix
	identity();
}

inline Matrix4::Matrix4(const float src[16])
{
	set(src);
}

inline Matrix4::Matrix4(float m00, float m01, float m02, float m03,
						float m04, float m05, float m06, float m07,
						float m08, float m09, float m10, float m11,
						float m12, float m13, float m14, float m15)
{
	set(m00, m01, m02, m03, m04, m05, m06, m07, m08, m09, m10, m11, m12, m13, m14, m15);
}

inline void Matrix4::set(const float src[16])
{
	m[0] = src[0];
	m[1] = src[1];
	m[2] = src[2];
	m[3] = src[3];
	m[4] = src[4];
	m[5] = src[5];
	m[6] = src[6];
	m[7] = src[7];
	m[8] = src[8];
	m[9] = src[9];
	m[10] = src[10];
	m[11] = src[11];
	m[12] = src[12];
	m[13] = src[13];
	m[14] = src[14];
	m[15] = src[15];
}

inline void Matrix4::set(float m00, float m01, float m02, float m03,
						 float m04, float m05, float m06, float m07,
						 float m08, float m09, float m10, float m11,
						 float m12, float m13, float m14, float m15)
{
	m[0] = m00;
	m[1] = m01;
	m[2] = m02;
	m[3] = m03;
	m[4] = m04;
	m[5] = m05;
	m[6] = m06;
	m[7] = m07;
	m[8] = m08;
	m[9] = m09;
	m[10] = m10;
	m[11] = m11;
	m[12] = m12;
	m[13] = m13;
	m[14] = m14;
	m[15] = m15;
}

inline void Matrix4::setRow(int index, const float row[4])
{
	m[index] = row[0];
	m[index + 4] = row[1];
	m[index + 8] = row[2];
	m[index + 12] = row[3];
}

inline void Matrix4::setRow(int index, const Vector4& v)
{
	m[index] = v.x;
	m[index + 4] = v.y;
	m[index + 8] = v.z;
	m[index + 12] = v.w;
}

inline void Matrix4::setRow(int index, const Vector3& v)
{
	m[index] = v.x;
	m[index + 4] = v.y;
	m[index + 8] = v.z;
}

inline void Matrix4::setColumn(int index, const float col[4])
{
	m[index * 4] = col[0];
	m[index * 4 + 1] = col[1];
	m[index * 4 + 2] = col[2];
	m[index * 4 + 3] = col[3];
}

inline void Matrix4::setColumn(int index, const Vector4& v)
{
	m[index * 4] = v.x;
	m[index * 4 + 1] = v.y;
	m[index * 4 + 2] = v.z;
	m[index * 4 + 3] = v.w;
}

inline void Matrix4::setColumn(int index, const Vector3& v)
{
	m[index * 4] = v.x;
	m[index * 4 + 1] = v.y;
	m[index * 4 + 2] = v.z;
}

inline const float* Matrix4::get() const
{
	return m;
}

inline const float* Matrix4::getTranspose()
{
	tm[0] = m[0];
	tm[1] = m[4];
	tm[2] = m[8];
	tm[3] = m[12];
	tm[4] = m[1];
	tm[5] = m[5];
	tm[6] = m[9];
	tm[7] = m[13];
	tm[8] = m[2];
	tm[9] = m[6];
	tm[10] = m[10];
	tm[11] = m[14];
	tm[12] = m[3];
	tm[13] = m[7];
	tm[14] = m[11];
	tm[15] = m[15];
	return tm;
}

inline Matrix4& Matrix4::identity()
{
	m[0] = m[5] = m[10] = m[15] = 1.0f;
	m[1] = m[2] = m[3] = m[4] = m[6] = m[7] = m[8] = m[9] = m[11] = m[12] = m[13] = m[14] = 0.0f;
	return *this;
}

inline Matrix4 Matrix4::operator+(const Matrix4& rhs) const
{
	return Matrix4(m[0] + rhs[0], m[1] + rhs[1], m[2] + rhs[2], m[3] + rhs[3],
				   m[4] + rhs[4], m[5] + rhs[5], m[6] + rhs[6], m[7] + rhs[7],
				   m[8] + rhs[8], m[9] + rhs[9], m[10] + rhs[10], m[11] + rhs[11],
				   m[12] + rhs[12], m[13] + rhs[13], m[14] + rhs[14], m[15] + rhs[15]);
}

inline Matrix4 Matrix4::operator-(const Matrix4& rhs) const
{
	return Matrix4(m[0] - rhs[0], m[1] - rhs[1], m[2] - rhs[2], m[3] - rhs[3],
				   m[4] - rhs[4], m[5] - rhs[5], m[6] - rhs[6], m[7] - rhs[7],
				   m[8] - rhs[8], m[9] - rhs[9], m[10] - rhs[10], m[11] - rhs[11],
				   m[12] - rhs[12], m[13] - rhs[13], m[14] - rhs[14], m[15] - rhs[15]);
}

inline Matrix4& Matrix4::operator+=(const Matrix4& rhs)
{
	m[0] += rhs[0];
	m[1] += rhs[1];
	m[2] += rhs[2];
	m[3] += rhs[3];
	m[4] += rhs[4];
	m[5] += rhs[5];
	m[6] += rhs[6];
	m[7] += rhs[7];
	m[8] += rhs[8];
	m[9] += rhs[9];
	m[10] += rhs[10];
	m[11] += rhs[11];
	m[12] += rhs[12];
	m[13] += rhs[13];
	m[14] += rhs[14];
	m[15] += rhs[15];
	return *this;
}

inline Matrix4& Matrix4::operator-=(const Matrix4& rhs)
{
	m[0] -= rhs[0];
	m[1] -= rhs[1];
	m[2] -= rhs[2];
	m[3] -= rhs[3];
	m[4] -= rhs[4];
	m[5] -= rhs[5];
	m[6] -= rhs[6];
	m[7] -= rhs[7];
	m[8] -= rhs[8];
	m[9] -= rhs[9];
	m[10] -= rhs[10];
	m[11] -= rhs[11];
	m[12] -= rhs[12];
	m[13] -= rhs[13];
	m[14] -= rhs[14];
	m[15] -= rhs[15];
	return *this;
}

inline Vector4 Matrix4::operator*(const Vector4& rhs) const
{
	return Vector4(m[0] * rhs.x + m[4] * rhs.y + m[8] * rhs.z + m[12] * rhs.w,
				   m[1] * rhs.x + m[5] * rhs.y + m[9] * rhs.z + m[13] * rhs.w,
				   m[2] * rhs.x + m[6] * rhs.y + m[10] * rhs.z + m[14] * rhs.w,
				   m[3] * rhs.x + m[7] * rhs.y + m[11] * rhs.z + m[15] * rhs.w);
}

inline Vector3 Matrix4::operator*(const Vector3& rhs) const
{
	return Vector3(m[0] * rhs.x + m[4] * rhs.y + m[8] * rhs.z,
				   m[1] * rhs.x + m[5] * rhs.y + m[9] * rhs.z,
				   m[2] * rhs.x + m[6] * rhs.y + m[10] * rhs.z);
}

inline Matrix4 Matrix4::operator*(const Matrix4& n) const
{
	return Matrix4(m[0] * n[0] + m[4] * n[1] + m[8] * n[2] + m[12] * n[3], m[1] * n[0] + m[5] * n[1] + m[9] * n[2] + m[13] * n[3], m[2] * n[0] + m[6] * n[1] + m[10] * n[2] + m[14] * n[3], m[3] * n[0] + m[7] * n[1] + m[11] * n[2] + m[15] * n[3],
				   m[0] * n[4] + m[4] * n[5] + m[8] * n[6] + m[12] * n[7], m[1] * n[4] + m[5] * n[5] + m[9] * n[6] + m[13] * n[7], m[2] * n[4] + m[6] * n[5] + m[10] * n[6] + m[14] * n[7], m[3] * n[4] + m[7] * n[5] + m[11] * n[6] + m[15] * n[7],
				   m[0] * n[8] + m[4] * n[9] + m[8] * n[10] + m[12] * n[11], m[1] * n[8] + m[5] * n[9] + m[9] * n[10] + m[13] * n[11], m[2] * n[8] + m[6] * n[9] + m[10] * n[10] + m[14] * n[11], m[3] * n[8] + m[7] * n[9] + m[11] * n[10] + m[15] * n[11],
				   m[0] * n[12] + m[4] * n[13] + m[8] * n[14] + m[12] * n[15], m[1] * n[12] + m[5] * n[13] + m[9] * n[14] + m[13] * n[15], m[2] * n[12] + m[6] * n[13] + m[10] * n[14] + m[14] * n[15], m[3] * n[12] + m[7] * n[13] + m[11] * n[14] + m[15] * n[15]);
}

inline Matrix4& Matrix4::operator*=(const Matrix4& rhs)
{
	*this = *this * rhs;
	return *this;
}

inline bool Matrix4::operator==(const Matrix4& n) const
{
	return (m[0] == n[0]) && (m[1] == n[1]) && (m[2] == n[2]) && (m[3] == n[3]) &&
		   (m[4] == n[4]) && (m[5] == n[5]) && (m[6] == n[6]) && (m[7] == n[7]) &&
		   (m[8] == n[8]) && (m[9] == n[9]) && (m[10] == n[10]) && (m[11] == n[11]) &&
		   (m[12] == n[12]) && (m[13] == n[13]) && (m[14] == n[14]) && (m[15] == n[15]);
}

inline bool Matrix4::operator!=(const Matrix4& n) const
{
	return (m[0] != n[0]) || (m[1] != n[1]) || (m[2] != n[2]) || (m[3] != n[3]) ||
		   (m[4] != n[4]) || (m[5] != n[5]) || (m[6] != n[6]) || (m[7] != n[7]) ||
		   (m[8] != n[8]) || (m[9] != n[9]) || (m[10] != n[10]) || (m[11] != n[11]) ||
		   (m[12] != n[12]) || (m[13] != n[13]) || (m[14] != n[14]) || (m[15] != n[15]);
}

inline float Matrix4::operator[](int index) const
{
	return m[index];
}

inline float& Matrix4::operator[](int index)
{
	return m[index];
}

inline Matrix4 operator-(const Matrix4& rhs)
{
	return Matrix4(-rhs[0], -rhs[1], -rhs[2], -rhs[3], -rhs[4], -rhs[5], -rhs[6], -rhs[7], -rhs[8], -rhs[9], -rhs[10], -rhs[11], -rhs[12], -rhs[13], -rhs[14], -rhs[15]);
}

inline Matrix4 operator*(float s, const Matrix4& rhs)
{
	return Matrix4(s * rhs[0], s * rhs[1], s * rhs[2], s * rhs[3], s * rhs[4], s * rhs[5], s * rhs[6], s * rhs[7], s * rhs[8], s * rhs[9], s * rhs[10], s * rhs[11], s * rhs[12], s * rhs[13], s * rhs[14], s * rhs[15]);
}

inline Vector4 operator*(const Vector4& v, const Matrix4& m)
{
	return Vector4(v.x * m[0] + v.y * m[1] + v.z * m[2] + v.w * m[3], v.x * m[4] + v.y * m[5] + v.z * m[6] + v.w * m[7], v.x * m[8] + v.y * m[9] + v.z * m[10] + v.w * m[11], v.x * m[12] + v.y * m[13] + v.z * m[14] + v.w * m[15]);
}

inline Vector3 operator*(const Vector3& v, const Matrix4& m)
{
	return Vector3(v.x * m[0] + v.y * m[1] + v.z * m[2], v.x * m[4] + v.y * m[5] + v.z * m[6], v.x * m[8] + v.y * m[9] + v.z * m[10]);
}

inline std::ostream& operator<<(std::ostream& os, const Matrix4& m)
{
	os << std::fixed << std::setprecision(5);
	os << "[" << std::setw(10) << m[0] << " " << std::setw(10) << m[4] << " " << std::setw(10) << m[8] << " " << std::setw(10) << m[12] << "]\n"
	   << "[" << std::setw(10) << m[1] << " " << std::setw(10) << m[5] << " " << std::setw(10) << m[9] << " " << std::setw(10) << m[13] << "]\n"
	   << "[" << std::setw(10) << m[2] << " " << std::setw(10) << m[6] << " " << std::setw(10) << m[10] << " " << std::setw(10) << m[14] << "]\n"
	   << "[" << std::setw(10) << m[3] << " " << std::setw(10) << m[7] << " " << std::setw(10) << m[11] << " " << std::setw(10) << m[15] << "]\n";
	os << std::resetiosflags(std::ios_base::fixed | std::ios_base::floatfield);
	return os;
}
// END OF MATRIX4 INLINE //////////////////////////////////////////////////////
#endif