gKit2 light

- Main Page
- Related Pages
- Modules
- Classes
- Files

- File List
- File Members

tuto2GL.cpp
Go to the documentation of this file.
1
3
4 #include <fstream>
5 #include <sstream>
6 #include <string>
7
8 #include "glcore.h"
9
10 #include "window.h"
11
12
13 /* une application opengl est composee de plusieurs composants :
14 1. une fenetre pour voir ce que l'on dessine
15 2. un contexte openGL pour dessiner
16 3. 3 fonctions :
17 init( ) pour creer les objets que l'on veut dessiner,
18 draw( ) pour les afficher / dessiner
19 quit( ) pour detruire les objets openGL crees dans init( ), a la fermeture de l'application
20
21 ces 3 fonctions sont appelees dans le main.
22
23 draw( ) est un peu a part, elle est appellee par la fonction run( ) qui traite les evenements clavier, souris, clicks, etc,
24 ca permet de reagir a ces evenements et de modifier / deplacer / animer ce que l'on dessine.
25
26 le shader sera compile dans init( ), utilise dans draw( ) et detruit a la fin de l'application dans quit( ).
27 */
28
29 // identifiants des shaders
30 GLuint vertex_shader;
31 GLuint fragment_shader;
32 // identifiant du shader program
33 GLuint program;
34
35 // identifiant du vertex array object
36 GLuint vao;
37
38 // utilitaire : charger un fichier texte et renvoyer une chaine de caracteres.
39 std::string read( const char *filename )
40 {
41 std::stringbuf source;
42 std::ifstream in(filename);
43 // verifie que le fichier existe
44 if(in.good() == false)
45 printf("[error] loading program '%s'...\n", filename);
46 else
47 printf("loading program '%s'...\n", filename);
48
49 // lire le fichier, le caractere '\0' ne peut pas se trouver dans le source de shader
50 in.get(source, 0);
51 // renvoyer la chaine de caracteres
52 return source.str();
53 }
54
55
56 // creation des objets openGL
57 int init( )
58 {
59 // creer un objet openGL : vertex array object
60 glGenVertexArrays(1, &vao);
61
62 // charger le source du vertex shader
63 std::string vertex_source= read("tutos/tuto2GL_vertex.glsl");
64 // creer un objet openGL : vertex shader
65 vertex_shader= glCreateShader(GL_VERTEX_SHADER);
66
67 // preparer les chaines de caracteres pour compiler le shader
68 const char *vertex_strings[]= { vertex_source.c_str() };
69 glShaderSource(vertex_shader, 1, vertex_strings, NULL);
70 // compiler les sources
71 glCompileShader(vertex_shader);
72
73 // pareil pour le fragment shader
74 std::string fragment_source= read("tutos/tuto2GL_fragment.glsl");
75 fragment_shader= glCreateShader(GL_FRAGMENT_SHADER);
76 const char *fragment_strings[]= { fragment_source.c_str() };
77 glShaderSource(fragment_shader, 1, fragment_strings, NULL);
78 glCompileShader(fragment_shader);
79
80 // creer le program et linker les 2 shaders
81 program= glCreateProgram();
82 // inclure les 2 shaders dans le program
83 glAttachShader(program, vertex_shader);
84 glAttachShader(program, fragment_shader);
85 // linker les shaders
86 glLinkProgram(program);
87
88 // verifier que tout c'est bien passe, si les shaders ne se sont pas compiles correctement, le link du program va echouer.
89 GLint status;
90 glGetProgramiv(program, GL_LINK_STATUS, &status);
91 if(status == GL_FALSE)
92 printf("[error] linking pogram...\n");
93
94 // renvoyer 0 ras, pas d'erreur, sinon renvoyer -1
95 if(status == GL_TRUE)
96 return 0;
97 else
98 return -1;
99 }
100
101
102 // destruction des objets openGL
103 int quit( )
104 {
105 glDeleteShader(vertex_shader);
106 glDeleteShader(fragment_shader);
107 glDeleteProgram(program);
108 glDeleteVertexArrays(1, &vao);
109 return 0; // ras, pas d'erreur
110 }
111
112
113 // affichage
114 int draw( )
115 {
116 // effacer la fenetre : copier la couleur par defaut dans tous les pixels de la fenetre
117 glClearColor(0.2, 0.2, 0.2, 1); // definir la couleur par defaut
118 glClear(GL_COLOR_BUFFER_BIT); // "effacer"
119
120 // configurer le pipeline, selectionner le shader program a utiliser
121 glUseProgram(program);
122
123 // configurer le pipeline, selectionner le vertex array a utiliser
124 glBindVertexArray(vao);
125
126 // dessiner 1 triangle, indices gl_VertexID de 0 a 3
127 glDrawArrays(GL_TRIANGLES, 0, 3);
128
129 return 1; // on continue, renvoyer 0 pour sortir de l'application
130 }
131
132
133 int main( int argc, char **argv )
134 {
135 // etape 1 : creer la fenetre
136 Window window= create_window(1024, 640);
137 if(window == NULL)
138 return 1; // erreur lors de la creation de la fenetre ou de l'init de sdl2
139
140 // etape 2 : creer un contexte opengl pour pouvoir dessiner
141 Context context= create_context(window);
142 if(context == NULL)
143 return 1; // erreur lors de la creation du contexte opengl
144
145 // etape 3 : creation des objets
146 if(init() < 0)
147 {
148 printf("[error] init failed.\n");
149 return 1;
150 }
151
152 // etape 4 : affichage de l'application, tant que la fenetre n'est pas fermee. ou que draw() ne renvoie pas 0
153 run(window, draw);
154
155 // etape 5 : nettoyage
156 quit();
157 release_context(context);
158 release_window(window);
159 return 0;
160 }
create_context
Context create_context(Window window, const int major, const int minor)
cree et configure un contexte opengl
Definition: window.cpp:252
window.h
draw
void draw(Mesh &m, const Transform &model, const Transform &view, const Transform &projection, const GLuint texture)
applique une texture a la surface de l'objet. ne fonctionne que si les coordonnees de textures sont f...
Definition: draw.cpp:6
create_window
Window create_window(const int w, const int h)
creation d'une fenetre pour l'application.
Definition: window.cpp:186
printf
void printf(Text &text, const int px, const int py, const char *format,...)
affiche un texte a la position x, y. meme utilisation que printf().
Definition: text.cpp:140
release_context
void release_context(Context context)
detruit le contexte openGL.
Definition: window.cpp:306
release_window
void release_window(Window window)
destruction de la fenetre.
Definition: window.cpp:222
run
int run(Window window, int(*draw)(void))
fonction principale. gestion des evenements et appel de la fonction draw de l'application.