8.3.3 Écrire sdlopengl_app.h

Précédent
Un petit plus avant de commencer		Parent
Rédaction d'une classe SdlOpenglApp (pour qu'elle face toutes les initialisations toute seule)		SommaireSuivant
Écrire sdlopengl_app.cpp

Donc, rédigeons sdlopengl_app.h : 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
#ifndef SDLOPENGL_APP_H
#define SDLOPENGL_APP_H

#include <time.h>

#include <SDL.h>
#include <SDL_image.h>

#include <GL/gl.h>
#include <GL/glu.h>

#include <string>

#include "vecteur.h"
#include "sdlglutils.h"
#include "camera.h"

#include <map>

Ensuite, nous gardons notre système de map pour les touches : 

1
2
 
typedef std::map<SDLKey,bool> KeyStates;
typedef std::map<std::string,SDLKey> KeyConf;

Les fonctions publiques

Déclaration de la classe, constructeur et destructeur : 

1
2
3
4
 
class SDLOpenGl_app{
	public:
		SDLOpenGl_app(double width = 640, double height = 480, double near = 1, double far = 1000, double angle = 70, const std::string & titre = "SDL_Application", const std::string & icon = "");
		virtual ~SDLOpenGl_app();

La fonction principale : 

1
 
void executer();

La fonction qui renvoie la taille de la fenêtre : 

1
 
Vecteur getFenetre();

Les fonctions qui initialiseront la caméra de l'application : 

1
2
 
void setCamera(const Camera & cam);
		void setCamera(const Vecteur & pos, double theta = 0, double phi = 0, double rouli = M_PI/2);

Si on a besoin de faire bouger la caméra : 

1
 
void moveCamera(const Vecteur & dv);

On s'occupe du changement de rotation et de l'initialisation de la rotation de la Camera : 

1
2
 
void rotationCamera(double dteta, double dPhi, double dRouli);
		void setRotationCamera(double theta, double phi, double rouli);

Si on a besoin de changer la perspective : 

1
2
 
void setPerspective( double angle, double width, double height, double near, double far);
		void setPerspective( double angle, double aspect, double near, double far);

Répétition des touches (pour ne pas être obligé de connaître la fonction de SDL) : 

1
 
void keyRepeat(int delay, int interval);

Les seteurs habituels : 

1
2
3
4
5
 
void setSize(int width, int height);
		void setIcon(SDL_Surface* icon);
		void setIcon(const std::string & nom_icon);
		void setTitre(const std::string & titre);
		void setAll(double width = 640, double height = 480, double near = 1, double far = 1000, double angle = 70, const std::string & titre = "SDL_Application", const std::string & icon = "");

si on veut définir une position maximale dans l'espace : 

1
 
void setPosMax(const Vecteur & posMax);

Les fonctions protégées

Les fonctions virtuelles : 

1
2
3
 
virtual void draw() =0;
		virtual void update(float dt) =0;
		virtual void getSDL_Event(SDL_Event & event);

Oui, si on veut récupérer un SDL_Event, (on aurait pu le faire dans l'autre classe).

La gestion des touches : 

1
2
 
void addKeyEvent(const std::string & action, SDLKey key, bool initValue);
		bool keyEventMade(const std::string & action);

Fonction d'arrêt de la classe : 

1
 
void stop();

La Camera de l'application : 

1
 
Camera camera;

On met la Camera de l'application protected comme ça on aura pas besoin de fonction pour y accéder depuis la classe fille.

Les fonctions privées

Fonction qui récupère les évènements : 

1
 
void getEvent(SDL_Event* event);

L'initialisation : 

1
 
void initSDLOpenGl(double width, double height, double near, double far, double angle, const std::string & titre, const std::string & icon);

Et maintenant toutes les variables : 

1
2
3
4
5
6
7
8
9
10
11
 
Uint32 p_timeForOneFrame;
		Uint32 p_ellapsed_time; //intervalle de temps entre le temps courrant et la dernière mesure de temps de l'application
		Uint32 p_start_time;   //instant ou l'application a été déclenchée
		KeyStates p_keystates; //tableau de bool pour les entrées clavier
		KeyConf p_keyconf;    //association actions touches
		bool p_isRun;  //exécution
		Vecteur p_fenetre;  //taille de la fenêtre
		Vecteur p_posMax; //position maximale d'un objet dans l'application
};

#endif

Vous avez sûrement remarqué, il n'y a pas de constructeur de copie ni d'opérateur =, bien sur vous pouvez les rajouter mais si vous vous rappelez pourquoi il ne faut pas copier cette classe c'est mieux.

Encore un résumé : 

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
#ifndef SDLOPENGL_APP_H
#define SDLOPENGL_APP_H

#include <time.h>
#include <SDL.h>
#include <SDL_image.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <string>
#include "vecteur.h"
#include "sdlglutils.h"
#include "camera.h"

#include <map>
typedef std::map< SDLKey,bool> KeyStates;   //tableau de bool pour les événements clavier
typedef std::map<std::string,SDLKey> KeyConf; //tableau d'action pour savoir ce que l'utilisateur veut faire

/**
	@brief Classe qui a pour but de créer une application SDL avec un affichage OpenGl sans avoir besoin de se trimbaler toute l'initialisation à chaque fois
*/

class SDLOpenGl_app{
	public:
		//constructeur de l'application on est obliger de mettre des double pour width et height
		SDLOpenGl_app(double width = 640, double height = 480, double near = 1, double far = 1000, double angle = 70, const std::string & titre = "SDL_Application", const std::string & icon = "");
		//destructeur
		virtual ~SDLOpenGl_app();
		//exécute l'application
		void executer();
		//renvoi la taille de la fenêtre
		Vecteur getFenetre();
		//initialise la caméra
		void setCamera(const Camera & cam);
		void setCamera(const Vecteur & pos, double theta = 0, double phi = 0, double rouli = M_PI/2);
		//bouge la caméra de dv
		void moveCamera(const Vecteur & dv);
		//change l’angle de visée de la caméra de dteta(horizontal) et dPhi(vertical) radian
		void rotationCamera(double dteta, double dPhi, double dRouli);
		//initialise un angle de visée de la caméra
		void setRotationCamera(double theta, double phi, double rouli);
		//initialise la perspective
		void setPerspective( double angle, double width, double height, double near, double far);
		//initialise la perspective
		void setPerspective( double angle, double aspect, double near, double far);
		//active la répétition des touches
		void keyRepeat(int delay, int interval);//répétition des touches
		//change la taille de la fenêtre
		void setSize(int width, int height);
		//change l’icône de l'application
		void setIcon(SDL_Surface* icon);
		//change l’icône de l'application
		void setIcon(const std::string & nom_icon);
		//change le titre de l'application
		void setTitre(const std::string & titre);
		//set tout les paramétrés de l'application
		void setAll(double width = 640, double height = 480, double near = 1, double far = 1000, double angle = 70, const std::string & titre = "SDL_Application", const std::string & icon = "");
		void setPosMax(const Vecteur & posMax);
		void setFPS(unsigned int fps);
	protected:
		//fonctions virtuelles à compléter
		//fonction d'affichage
		///fonction virtuelle d'affichage
		virtual void draw() =0;
		//fonction de mise a jour des variables
		///fonction virtuelle de calcul
		/** @param dt : intervalle de temps (très petit) utile pour effectuer des calculs de vitesses ou l'accélération
		*/
		virtual void update(float dt) =0;
		virtual void getSDL_Event(SDL_Event & event);
		//rajoute un événement clavier
		void addKeyEvent(const std::string & action, SDLKey key, bool initValue);
		//événement du clavier retourne true si action est réalisée
		bool keyEventMade(const std::string & action);
		//arrête l'application
		void stop();
		///@a Camera de l'application
		Camera camera; //Caméra de l'application
		
	private:
		//récupère les événements
		void getEvent(SDL_Event* event);
		//initialisation de l'application
		void initSDLOpenGl(double width, double height, double near, double far, double angle, const std::string & titre, const std::string & icon);
		Uint32 p_timeForOneFrame;
		///intervalle de temps entre le temps courrant et la dernière mesure de temps de l'application
		Uint32 p_ellapsed_time; //intervalle de temps entre le temps courrant et la dernière mesure de temps de l'application
		///instant ou l'appilcation a été déclenchée
		Uint32 p_start_time;   //instant ou l'appilcation a été déclenchée
		///tableau de bool pour les entrées clavier
		KeyStates p_keystates; //tableau de bool pour les entrées clavier
		///association actions touches
		KeyConf p_keyconf;    //association actions touches
		///booléen qui dit si l'application est en train d'être exécute
		bool p_isRun;  //exécution
		///taille de la fenêtre
		Vecteur p_fenetre;  //taille de la fenêtre
		///position maximale d'un objet dans l'application
		Vecteur p_posMax; //position maximale d'un objet dans l'application
};

#endif // SDLOPENGL_APP_H

Ça fait déjà plusieurs fois que je vois ça, qu'est-ce que c'est que les commentaires bizarre genre "///" ou "/** ...*/", et "@param ..." ?

C'est une manière d'écrire les commentaires qui permet de générer de la documentation du son projet (je vous en parlerai dans le chapitre sur Doxygen, mais j'empiète un peu)

Précédent
Un petit plus avant de commencer		Parent
Rédaction d'une classe SdlOpenglApp (pour qu'elle face toutes les initialisations toute seule)		SommaireSuivant
Écrire sdlopengl_app.cpp