/*
Copyright (C) 2010 Matthew Baranowski, Sander van Rossen & Raven software.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#if !defined(MATRIX4_INC)
#define MATRIX4_INC

#include "vect3.h"
#include <math.h>
#include <memory.h>

#pragma warning( disable : 4244) 
#pragma optimize( "p", on )	// improve floating-point consistancy (makes release do bone-pooling as good as debug)
extern const float Pi;
extern const float Half_Pi;


#define MATFLAG_IDENTITY (1)
class Matrix4
{
	float m[4][4];
	int flags;
public:
	Matrix4() {flags=0;}
	Matrix4(const Matrix4 &o);
	float* operator[](int i) {return m[i];flags=0;}
	const float* operator[](int i) const {return m[i];}
	void SetElem(int r,int c,float v) {m[r][c]=v;flags=0;}
	const float &Elem(int r,int c) const {return m[r][c];}
	void SetFromMem(const float *mem) {memcpy(m,mem,sizeof(float)*16);CalcFlags();}
	void GetFromMem(float *mem) const {memcpy(mem,m,sizeof(float)*16);}
	void Identity();
	void Zero();
	bool IsRotationIdentity(void) const;
	bool IsRotationIdentityMoreTolerance(void) const;
	int CalcFlags();
	int GetFlags() const {return flags;}
	bool IntegrityCheck() const;
	void Translate(const float tx,const float ty,const float tz);
	void Translate(const Vect3 &t);
	void Rotate(int axis,const float theta);
	void Rotate(const float rx,const float ry,const float rz);
	void Rotate(const Vect3 v);
	void Scale(const float sx,const float sy,const float sz);
	void Scale(const float sx);
	void Concat(const Matrix4 &m1,const Matrix4 &m2);
	void Interp(const Matrix4 &m1,float s1,const Matrix4 &m2,float s2);
	void Interp(const Matrix4 &m1,const Matrix4 &m2,float s1);
	void XFormPoint(Vect3 &dest,const Vect3 &src) const;
	float HXFormPoint(Vect3 &dest,const Vect3 &src) const;
	void HXFormPointND(float *dest,const float *src) const;
	void XFormVect(Vect3 &dest,const Vect3 &src) const;
	void XFormVectTranspose(Vect3 &dest,const Vect3 &src) const;
	void SetRow(int i,const Vect3 &t);
	void SetColumn(int i,const Vect3 &t);
	void SetRow(int i);
	void SetColumn(int i);
	void SetFromDouble(double *d);
	void MultiplyColumn(int i,float f);
	float GetColumnLen(int i);
	void Inverse(const Matrix4 &old);
	void OrthoNormalInverse(const Matrix4 &old);
	void FindFromPoints(const Vect3 base1[4],const Vect3 base2[4]);
	void MakeEquiscalar();
	float Det();
	float MaxAbsElement();
	void GetRow(int r,Vect3 &v) const {v.x()=m[r][0];v.y()=m[r][1];v.z()=m[r][2];}
	void GetColumn(int r,Vect3 &v) const {v.x()=m[0][r];v.y()=m[1][r];v.z()=m[2][r];}
	void Transpose();
	bool operator== (const Matrix4& t) const;
	void From3x4(const float mat[3][4]);
	void To3x4(float mat[3][4]) const;
	void ClampPrecision(float fNumDecimals);
};


int GetTextureSystem(
  const Vect3 &p0,const Vect3 &uv0, //vertex 0
  const Vect3 &p1,const Vect3 &uv1, //vertex 1
  const Vect3 &p2,const Vect3 &uv2, //vertex 2
  const Vect3 &n, // normal vector for triangle
  Vect3 &M, // returned gradient wrt u
  Vect3 &N, // returned gradient wrt v
  Vect3 &P); // returned location in world space where u=v=0


#endif