15.2.2 Modification du fichier PAppSdlOpenGl3.cpp

Précédent
Modification du fichier PAppSdlOpenGl3.h		Parent
Adapter la classe PAppSdlOpenGl3		SommaireSuivant
Résumé des modifications des fichiers PAppSdlOpenGl3.h et PAppSdlOpenGl3.cpp

L'avantage d'utiliser les macro est que l'on a pas à réécrire un fichier en entier, et donc, que l'on garde une certaine cohérence dans le projet.

Modifions le destructeur : 

1
2
3
4
5
6
7
 
PAppSdlOpenGl3::~PAppSdlOpenGl3(){
#ifdef USE_NEW_MATRICE_C
	freePMat4fGl3(p_matModelview);
	freePMat4fGl3(p_matProjection);
#endif
	SDL_Quit();
}

Modifions la fonction executer 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
int PAppSdlOpenGl3::executer(){
	if(!p_isOpenGlSdlInit) return 1;
	p_isRun = true;
	while(p_isRun){
		p_start_time = SDL_GetTicks();
		this->clearKeyStatesNoRepeat();
		while(SDL_PollEvent(&p_evenements)){
			this->updateWithEvent(&p_evenements);
			this->getEvent(&p_evenements);
		}
		// Nettoyage de l'écran
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		//on suppose que tout à bien fonctionne comme prévus et que le temps de calcul était égale à this->timeForOneFrame (en même temps on s’arrange pour que se soit le cas)
		this->update(p_timeForOneFrame*DTFACTOR);   //on gère les événements
		
		// Ré-initialisation de la matrice et placement de la caméra
#ifdef USE_NEW_MATRICE_C
		loadIdentityPMat4fGl3(p_matModelview);
#else
		p_matModelview.loadIdentity();
#endif
		p_cameraGL.see(p_matModelview);
		
		this->draw3d();               //on affiche tout
		
		SDL_GL_SwapWindow(p_fenetre);   //on fait le double buffering
		p_ellapsed_time = SDL_GetTicks() - p_start_time;
		if(p_ellapsed_time < p_timeForOneFrame){SDL_Delay(p_timeForOneFrame - p_ellapsed_time);}
	}
	return 0;
}

Les fonctions sendMatProjectionToShader et sendMatModelViewToShader : 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
void PAppSdlOpenGl3::sendMatProjectionToShader(GLint idMatProjection){
#ifdef USE_NEW_MATRICE_C
	glUniformMatrix4fv(idMatProjection, 1, GL_TRUE, p_matProjection->mat);
#else
	glUniformMatrix4fv(idMatProjection, 1, GL_TRUE, p_matProjection.getValue());
#endif
}

void PAppSdlOpenGl3::sendMatModelViewToShader(GLint idMatModelView){
#ifdef USE_NEW_MATRICE_C
	glUniformMatrix4fv(idMatModelView, 1, GL_TRUE, p_matModelview->mat);
#else
	glUniformMatrix4fv(idMatModelView, 1, GL_TRUE, p_matModelview.getValue());
#endif
}

Les fonctions pushMatModelView et popMatModelView : 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
void PAppSdlOpenGl3::pushMatModelView(){
#ifdef USE_NEW_MATRICE_C
	pushPMat4fGl3(p_matModelview);
#else
	p_matModelview.push();
#endif
}

void PAppSdlOpenGl3::popMatModelView(){
#ifdef USE_NEW_MATRICE_C
	popPMat4fGl3(p_matModelview);
#else
	p_matModelview.pop();
#endif
}

Les fonctions pour manipuler les matrices : 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
void PAppSdlOpenGl3::loadIdentityMV(){
#ifdef USE_NEW_MATRICE_C
	loadIdentityPMat4fGl3(p_matModelview);
#else
	p_matModelview.loadIdentity();
#endif
}

void PAppSdlOpenGl3::translateMV(float x, float y, float z){
#ifdef USE_NEW_MATRICE_C
	translatePMat4fGl3(p_matModelview, x, y, z);
#else
	p_matModelview.translated(x, y, z);
#endif
}

void PAppSdlOpenGl3::scaleMV(float x, float y, float z){
#ifdef USE_NEW_MATRICE_C
	scalePMat4fGl3(p_matModelview, x, y, z);
#else
	p_matModelview.scale(x, y, z);
#endif
}

void PAppSdlOpenGl3::rotateMVRad(float angleRad, float x, float y, float z){
#ifdef USE_NEW_MATRICE_C
	rotatePMat4fGl3Rad(p_matModelview, angleRad, x, y, z);
#else
	p_matModelview.rotateRad(angleRad, x, y, z);
#endif
}

void PAppSdlOpenGl3::rotateMVDeg(float angleDeg, float x, float y, float z){
#ifdef USE_NEW_MATRICE_C
	rotatePMat4fGl3Rad(p_matModelview, angleDeg, x, y, z);
#else
	p_matModelview.rotateDeg(angleDeg, x, y, z);
#endif
}

Les fonctions setPerpectiveDeg et setPerpectiveRad : 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
void PAppSdlOpenGl3::setPerpectiveDeg(float angleDeg, float near, float far){
#ifdef USE_NEW_MATRICE_C
	perspectivePMat4fGl3Deg(p_matProjection, angleDeg, getRatio(), near, far);
#else
	p_matProjection.perspectiveDeg(angleDeg, getRatio(), near, far);
#endif
}

void PAppSdlOpenGl3::setPerpectiveRad(float angleRad, float near, float far){
#ifdef USE_NEW_MATRICE_C
	perspectivePMat4fGl3Rad(p_matProjection, angleRad, getRatio(), near, far);
#else
	p_matProjection.perspectiveRad(angleRad, getRatio(), near, far);
#endif
}

La fonction d'affichage pour le mode debug : 

1
2
3
4
5
6
7
8
9
10
11
12
13
 
void PAppSdlOpenGl3::printMatPMV(){
#ifdef USE_NEW_MATRICE_C
	cout << "Matrice ModelView :" << endl;
	printPtMat4f(p_matModelview->mat);
	cout << "Matrice de projection :" << endl;
	printPtMat4f(p_matProjection->mat);
#else
	cout << "Matrice ModelView :" << endl;
	cout << p_matModelview << endl;
	cout << "Matrice de projection :" << endl;
	cout << p_matProjection << endl;
#endif
}

La fonction d'initialisation : 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
void PAppSdlOpenGl3::initialisationPAppSdlOpenGl3(const std::string& titreFenetre, int largeurFenetre, int hauteurFenetre){
	p_titreFenetre = titreFenetre;
	p_largeurFenetre = largeurFenetre;
	p_hauteurFenetre = hauteurFenetre;
	if(SDL_Init(SDL_INIT_VIDEO) < 0){  // Initialisation de la SDL
		std::cout << "Erreur lors de l'initialisation de la SDL : " << SDL_GetError() << std::endl;
		p_isOpenGlSdlInit = false;
		return;
	}else{
		std::cout << "Mode vidéo de SDL initialisé." << std::endl; 
	}
		
	// Version d'OpenGL
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
		
	// Double Buffer
	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
		
	// Création de la fenêtre
	p_fenetre = SDL_CreateWindow(p_titreFenetre.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, p_largeurFenetre, p_hauteurFenetre, SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL);
	if(p_fenetre == NULL){
		std::cerr << "Impossible de créer la fenêtre : "  << SDL_GetError() << std::endl;
		p_isOpenGlSdlInit = false;
		dontRun();
		return;
	}else{
		std::cout << "Création de la fenêtre." << std::endl;
	}
	p_contexteOpenGL = SDL_GL_CreateContext(p_fenetre);
	
	//on dit qu'il faut faire un test de profondeur (pour l'affichage 3D)
	glEnable(GL_DEPTH_TEST);
	
	p_isOpenGlSdlInit = true;
#ifdef USE_NEW_MATRICE_C
	p_matModelview = createPMat4fGl3();
	p_matProjection = createPMat4fGl3();
	loadIdentityPMat4fGl3(p_matModelview);
	loadIdentityPMat4fGl3(p_matProjection);
#else
	p_matModelview.loadIdentity();
	p_matProjection.loadIdentity();
#endif
	setFPS(30.0);
	p_cameraGL.setWindowID(p_fenetre);
}

Et voilà, c'est fini pour les modifications de la classe PAppSdlOpenGl3.

Précédent
Modification du fichier PAppSdlOpenGl3.h		Parent
Adapter la classe PAppSdlOpenGl3		SommaireSuivant
Résumé des modifications des fichiers PAppSdlOpenGl3.h et PAppSdlOpenGl3.cpp