#include "PMat4fGl3c.h"

///fonction qui créer une PMat4fGl3
/**	@return PMat4fGl3
*/
PMat4fGl3 * createPMat4fGl3(){
	PMat4fGl3 * mat = malloc(sizeof(PMat4fGl3));
	mat->savePrevMat = NULL;
	return mat;
}

///fonction qui désaloue une PMat4fGl3
/**	@param mat : PMat4fGl3 à désalouer
*/
void freePMat4fGl3(PMat4fGl3* mat){
	if(mat == NULL) return;
	depilerPMat4fGl3(mat);
	free(mat);
}

///fonction qui sauvegarde la matrice courante
/**	@param mat : PMat4fGl3 que l'on veut sauvegarder
*/
void pushPMat4fGl3(PMat4fGl3* mat){
	if(mat == NULL) return;
	PMat4fGl3* sauvegarde = malloc(sizeof(PMat4fGl3));
	// Si l'allocation réussit
	if(sauvegarde != NULL){
		// Copie des valeurs dans la nouvelle case
		memcpy(sauvegarde->mat, mat->mat, sizeof(PtMatrice4fc));
		// On pointe sur la sauvegarde précédente
		sauvegarde->savePrevMat = mat->savePrevMat;
		// Redéfinition du sommet de la pile
		mat->savePrevMat = sauvegarde;
	}
}

///fonction qui dégomme la sauvegarde précédente
/**	@param mat : PMat4fGl3 que l'on veut restaurer avec une sauvegarde
 * 	@return 1 si la fonction à réussie, 0 sinon
*/
int popPMat4fGl3(PMat4fGl3* mat){
	if(mat == NULL) return 0;
	PMat4fGl3 *matriceTmp = mat->savePrevMat;
	// Si la pile existe toujours
	if(matriceTmp != 0){
		// Copie des valeurs depuis la sauvegarde
		memcpy(mat->mat, matriceTmp->mat, sizeof(PtMatrice4fc));
		// Redéfinition du sommet de la pile
		mat->savePrevMat = matriceTmp->savePrevMat;
		matriceTmp->savePrevMat = NULL;
		free(matriceTmp);
		return 1;
	}else return 0;
}

///fonction qui dégomme toutes les sauvegardes de matrices précédentes
void depilerPMat4fGl3(PMat4fGl3* mat){
	if(mat == NULL) return;
	while(popPMat4fGl3(mat) != 0);
}

///fonction qui transforme la matrice en matrice identité
/**	@param mat : PMat4fGl3 à modifier
*/
void loadIdentityPMat4fGl3(PMat4fGl3* mat){
	if(mat == NULL) return;
	loadIdentityPtMat4f(mat->mat);
}

///fonction qui permet de faire une translation de la matrice (si on s'en sert de matrice modelView)
/**	@param mat : PMat4fGl3 à modifier
 * 	@param x : translation en x
 * 	@param y : translation en y
 * 	@param z : translation en z
*/
void translatePMat4fGl3(PMat4fGl3* mat, float x, float y, float z){
	if(mat == NULL) return;
	translatedPtMat4f(mat->mat, x, y, z);
}

///fonction qui permet de changer l'échelle de la matrice (si on s'en sert de matrice modelView)
/**	@param mat : PMat4fGl3 à modifier
 * 	@param x : échelle en x
 * 	@param y : échelle en y
 * 	@param z : échelle en z
*/
void scalePMat4fGl3(PMat4fGl3* mat, float x, float y, float z){
	if(mat == NULL) return;
	scalePtMat4f(mat->mat, x, y, z);
}

///fonction qui permet de changer l'échelle de la matrice (si on s'en sert de matrice modelView)
/**	@param mat : PMat4fGl3 à modifier
 * 	@param angleRad : angle de rotation (en radian)
 * 	@param x : composante x de l'axe de rotation
 * 	@param y : composante y de l'axe de rotation
 * 	@param z : composante z de l'axe de rotation
*/
void rotatePMat4fGl3Rad(PMat4fGl3* mat, float angleRad, float x, float y, float z){
	if(mat == NULL) return;
	rotatePtMat4fRad(mat->mat, angleRad, x, y, z);
}

///fonction qui permet de créer une matrice de rotation
/**	@param mat : PMat4fGl3 à modifier
 * 	@param angleDeg : angle de rotation (en degré)
 * 	@param x : composante x de l'axe de rotation
 * 	@param y : composante y de l'axe de rotation
 * 	@param z : composante z de l'axe de rotation
*/
void rotatePMat4fGl3Deg(PMat4fGl3* mat, float angleDeg, float x, float y, float z){
	if(mat == NULL) return;
	rotatePtMat4fDeg(mat->mat, angleDeg, x, y, z);
}

///fonction qui initialise la perspective de la matrice (qui sera la matrice de projection du monde OpenGl 3.1)
/**	@param mat : PMat4fGl3 à modifier
 * 	@param angleRad : angle de vue (en radian 70*M_PI/180.0)
 * 	@param ratio : ratio de l'écran
 * 	@param near : position la plus proche que l'on peut afficher
 * 	@param far : position la plus lointaine que l'on peut afficher
*/
void perspectivePMat4fGl3Rad(PMat4fGl3* mat, float angleRad, float ratio, float near, float far){
	if(mat == NULL) return;
	perspectivePtMat4fRad(mat->mat, angleRad, ratio, near, far);
}

///fonction qui initialise la perspective de la matrice (qui sera la matrice de projection du monde OpenGl 3.1)
/**	@param mat : PMat4fGl3 à modifier
 * 	@param angleDeg : angle de vue (en degré 70°)
 * 	@param ratio : ratio de l'écran
 * 	@param near : position la plus proche que l'on peut afficher
 * 	@param far : position la plus lointaine que l'on peut afficher
*/
void perspectivePMat4fGl3Deg(PMat4fGl3* mat, float angleDeg, float ratio, float near, float far){
	if(mat == NULL) return;
	perspectivePtMat4fDeg(mat->mat, angleDeg, ratio, near, far);
}

///fonction qui permet de dire où on veut regarder
/**	@param mat : PMat4fGl3 à modifier
 * 	@param eyeX : position en x de l'endroit d'où on regarde
 * 	@param eyeY : position en y de l'endroit d'où on regarde
 * 	@param eyeZ : position en z de l'endroit d'où on regarde
 * 	@param centerX : position en x de l'object que l'on regarde
 * 	@param centerY : position en y de l'object que l'on regarde
 * 	@param centerZ : position en z de l'object que l'on regarde
 * 	@param upX : composante x du vecteur vertical
 * 	@param upY : composante y du vecteur vertical
 * 	@param upZ : composante z du vecteur vertical
*/
void lookAtPMat4fGl3(PMat4fGl3* mat, float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ){
	if(mat == NULL) return;
	lookAtPtMat4f(mat->mat, eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ);
}