Discussion :

[Fredchkek]

Bonjour,

Débutant en glut, je souhaite réaliser une application console (C++) qui peut lancer une fenêtre graphique.
J'ai donc un "main" habituel :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

void main(int arg, char *argv[], char **argc)

et un "main" de glut :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

int mainGL(int arg, char **argc)

A partir de mon "main", je peux donc appeler "mainGL" en utilisant simplement :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

mainGL(arg, argc);

Question 1 : Même si cela fonctionne, j'aimerais savoir si cette méthode est usuelle ?

Question 2 : Comment mon "mainGL" peut-il rendre la main à mon "main" lorsque je ferme la fenêtre graphique ?

J'ai l'impression de faire fausse route alors merci pour votre aide !

[LittleWhite]

Bonjour,

Tout d'abord je conseille freeglut à GLUT, car c'est plus propre et plus maintenu.

Maintenant, pour votre histoire, oui il est possible de faire ( un sous main ) car un main est une fonction comme toute les autres.
Pour sortir du mainGL il faut juste faire un return

J'ai aussi vu que les paramètres de votre main sont un peu faux. Normalement c'est:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
int main(int argc, char** argv, char** arge)

Et arge est optionnel.

Après, oui cela fonctionne, mais c'est assez rare de voir ça ... mais cela est votre choix

[Fredchkek]

Bonjour,

Je ne comprends pas en quoi le mainGL est une fonction comme les autres.
Dans l'exemple de base qu'on trouve sur le net et qui permet de tourner un cube dans tous les sens, le mainGL (qui s'appelle en fait init) se termine par

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

glutMainLoop();

Ce qui signifie que tout ce que l'on met après ne sera pas atteint (donc pas de return possible).

Comment faire ?

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
 
#include <GL/glut.h>
 
 
/* 
 * Window properties 
 */
#define WINDOW_WIDTH    500
#define WINDOW_HEIGHT   500
#define WINDOW_X        100
#define WINDOW_Y        100
#define WINDOW_TITLE    "RGB-ColorCube"
 
/* 
 * Perspective properties 
 */
#define FOV_ANGLE       45
 
#define CENTER_X        0.0
#define CENTER_Y        0.0
#define CENTER_Z        0.0
 
#define VIEWER_X        0.0
#define VIEWER_Y        0.0
#define VIEWER_Z        -5
 
#define UP_X            1.0
#define UP_Y            0.0
#define UP_Z            0.0
 
#define CLIPPLANE_NEAR  1.0
#define CLIPPLANE_FAR   20.0
 
 
#define ROTATION_SPEED  2.0
 
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
 
GLfloat rot_x = 0.0, rot_y = 0.0;
GLfloat saved_x, saved_y;
 
/*
 * Material colors used for shading
 */
GLfloat red[4] = {.8, 0.0, 0.0, 1.0};
GLfloat white[4] = {.8, .8, .8, 1.0};
 
/*
 * Function prototypes
 */
void usage(void);
void draw_scene(void);
void draw_object(void);
void init(int argc, char **argv, void (*draw)(void));
void save_position(int button, int state, int x, int y);
struct point get_coords(double a, double b);
void vertex(double a, double b);
void rotate(int x, int y);
void set_color(int angle);
 
int main(int argc, char **argv) {
    /*
     * Init OpenGL and enter the event loop
     */
    init(argc, argv, draw_scene);
 
    return 0;
}
 
/*
 * Handle rotations and buffer swapping and call the function draw_object 
 * which does the actual drawing
 */
void draw_scene(void) {
    static GLfloat old_rot_matrix[16];
    static int initialized = 0;
    GLfloat new_rot_matrix[16];
 
    /* calculate new rotation matrix */
    glPushMatrix();
    glLoadIdentity();
    glRotatef(rot_x, 1.0, 0.0, 0.0);
    glRotatef(rot_y, 0.0, 1.0, 0.0);
    glGetFloatv(GL_MODELVIEW_MATRIX, new_rot_matrix);
    glPopMatrix();
 
    /* calculate total rotation */
    glPushMatrix();
    glLoadIdentity();
    glMultMatrixf(new_rot_matrix);
    if (initialized) {
      glMultMatrixf(old_rot_matrix);
    }
 
    glGetFloatv(GL_MODELVIEW_MATRIX, old_rot_matrix);
    initialized = 1;
    glPopMatrix();
 
    glPushMatrix();
    glMultMatrixf(old_rot_matrix); 
 
    draw_object();
 
    glPopMatrix();
    glFlush();
    glutSwapBuffers();
}
 
/*
 * Initialize the OpenGL machine
 */
void init(int argc, char **argv, void (*draw)(void)) {
    GLfloat light0_pos[] = {100.0, 100.0, 100.0, 1.0};
    GLfloat light0_color[] = {1.0, 1.0, 1.0, 1.0};
    GLfloat ambient_light[] = {0.8, 0.8, 0.8, 1.0};
 
    glutInit(&argc, argv);
 
    /* Create a window */
    glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
    glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT);
    glutInitWindowPosition(WINDOW_X, WINDOW_Y);
    glutCreateWindow(WINDOW_TITLE);
    glClearColor(0.0, 0.0, 0.0, 0.0);
 
    /* Set up some light sources */
    glLightfv(GL_LIGHT0, GL_POSITION, light0_pos);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_color);
    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient_light);
 
    glEnable(GL_LIGHT0);
    /* glEnable(GL_LIGHTING); */
 
    glEnable(GL_DEPTH_TEST);
 
    glShadeModel(GL_SMOOTH);
 
    /* Create a viewing frustum */
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(FOV_ANGLE, WINDOW_WIDTH/WINDOW_HEIGHT, CLIPPLANE_NEAR, 
        CLIPPLANE_FAR);
    gluLookAt(VIEWER_X, VIEWER_Y, -VIEWER_Z, CENTER_X, CENTER_Y, CENTER_Z, 
        UP_X, UP_Y, UP_Z);
 
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(VIEWER_X, VIEWER_Y, VIEWER_Z);
 
    glutDisplayFunc(draw);
    glutMouseFunc(save_position);
    glutMotionFunc(rotate);
    glutMainLoop();
 
    /* Not reached */
}
 
/*
 * Save the position of the mouse pointer where the bottun press occured
 */
void save_position(int button, int state, int x, int y) {
    if (state == GLUT_DOWN) {
        saved_x = x;
        saved_y = y;
    }
}
 
/*
 * Calculate the angle the object has rotated by since the last update
 */
void rotate(int x, int y) {
    rot_y = (GLfloat)(x - saved_x) * ROTATION_SPEED;
    rot_x = (GLfloat)(y - saved_y) * ROTATION_SPEED;
    saved_x = x;
    saved_y = y;
 
    glutPostRedisplay();
}
 
/*
 * Draw a object
 */
void draw_object(void) {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
    glBegin(GL_QUAD_STRIP);
 
      glNormal3f(0,0,1);
 
      glColor3f(0,0,0);
      glVertex3f(-0.5,-0.5,-0.5);
 
      glColor3f(0,1,0);
      glVertex3f(-0.5,0.5,-0.5);
 
      glColor3f(1,0,0);
      glVertex3f(0.5,-0.5,-0.5);
 
      glColor3f(1,1,0);
      glVertex3f(0.5,0.5,-0.5);
 
      glNormal3f(1,0,0);
      glColor3f(1,0,1);
      glVertex3f(0.5,-0.5,0.5);
 
      glColor3f(1,1,1);
      glVertex3f(0.5,0.5,0.5);    
 
      glNormal3f(0,0,1);
      glColor3f(0,0,1);
      glVertex3f(-0.5,-0.5,0.5);
      glColor3f(0,1,1);
      glVertex3f(-0.5,0.5,0.5);
 
      glNormal3f(-1,0,0);
      glColor3f(0,0,0);
      glVertex3f(-0.5,-0.5,-0.5);
      glColor3f(0,1,0);
      glVertex3f(-0.5,0.5,-0.5);
 
    glEnd();
 
 
   glBegin(GL_QUADS);
 
      glNormal3f(0,1,0);
 
      glColor3f(0,1,0);
      glVertex3f(-0.5,0.5,-0.5);
 
      glColor3f(0,1,1);
      glVertex3f(-0.5,0.5,0.5);
 
      glColor3f(1,1,1);
      glVertex3f(0.5,0.5,0.5);
 
      glColor3f(1,1,0);
      glVertex3f(0.5,0.5,-0.5);
 
    glEnd();
 
    glBegin(GL_QUADS);
 
      glNormal3f(0,-1,0);
 
      glColor3f(0,0,0);
      glVertex3f(-0.5,-0.5,-0.5);
 
      glColor3f(0,0,1);
      glVertex3f(-0.5,-0.5,0.5);
 
      glColor3f(1,0,1);
      glVertex3f(0.5,-0.5,0.5);
 
      glColor3f(1,0,0);
      glVertex3f(0.5,-0.5,-0.5);
 
    glEnd();
 
}

[LittleWhite]

Freeglut a une fonction qui ressemble à glutMainLoop, sauf qu'elle peut être quitter.

Après vous m'avez parler de mainGL, qui n'est pas du tout pareil, qu'une glutMainLoop. La glutMainLoop est une fonction de laquelle on ne sors plus jamais ( car elle boucle à l'infini, et dans la boucle, il y a la gestion des evenements ).

Voilà

[AuraHxC]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
int main(int argc, char** argv, char** arge)

Je n'ai jamais vu ce troisième argument de la fonction main, d'où vient il ? et a quoi sert il ?

[Fredchkek]

@ AuraHxC
C'est pour les variables d'environnement :

@LittleWhite

J'ai aussi vu que les paramètres de votre main sont un peu faux.

Effectivement merci !

Après vous m'avez parler de mainGL, qui n'est pas du tout pareil, qu'une glutMainLoop. La glutMainLoop est une fonction de laquelle on ne sors plus jamais ( car elle boucle à l'infini, et dans la boucle, il y a la gestion des evenements ).

Je me suis probablement fait mal comprendre ... Il me paraissait évident que dans le mainGL il y avait un glutMainLoop (comme dans l'exemple que j'ai repris).
Donc, finalement, je comprends qu'il n'est pas possible de revenir au main ???

Pour FreeGlut, j'hésite à changer et à repartir de zéro ...

[LittleWhite]

Je n'ai jamais vu ce troisième argument de la fonction main, d'où vient il ? et a quoi sert il ?

Le troisième argument est optionnel ( c'est pour cela qu'on ne le voit presque jamais ). Il va être remplie par toute les variables de l'environment.
C'est un tableau de chaine de caractères, et normallement, nous le traitons avec une boucle, car le tout dernier pointeur est un pointeur NULL ( qui permet de savoir que c'est la fin ). Voilà tout. Je ne l'ai utilisé qu'en TP, donc je ne le trouve pas très utile . Ici, je doute qu'il le soit, mais on pourrait imaginer une solution, qui par variable d'environment, détermine la taille de la fenêtre.

freeglut et GLUT sont extrèmement proche, et presque rien ne change.

Je disai que vous ne pouvez pas sortir du mainGL à cause du glutMainLoop, qui dans glut, ne quitte jamais. Dans freeglut, il faut utiliser une autre fonction, qui peut quitter ( mais glutMainLoop existe est a le même fonctionnement ). Ceci est votre seul changement.

Sinon, pour sortir du mainGL, comme je l'ai dit ( ou croit l'avoir dit ) il fatu juste utiliser un 'return' car le mainGL est une fonction comme toute les autres.

Voilà, en espérant avoir été plus clair.

[Fredchkek]

Très bien merci, je vais donc voir du côté de freeglut ...
Merci de votre aide

[oxyde356]

Je vais essayer de te donner une réponse plus pragmatique.
Pour répondre à ta première question, non ce n'est pas usuel et vu le nom que tu donne à ta fonction "mainGL" tu dois confondre quand à son utilisation. "main" ce n'est pas une fenêtre, c'est une fonction. Usuellement c'est la première fonction appelé au lancement du programme, qu'il y est zéro, une ou plusieurs fenêtres. Imbriquer plusieurs "main" n'est donc conceptuellement pas correcte en mon sens surtout vu que t'as fenêtre graphique est une sorte de sous produit de ton programme.
Après pour améliorer les choses je te conseillerais de regrouper et d'encapsuler tes données. Par exemple tu pourrais faire une classe application, une classe fenêtre etc... pour éviter de tout mettre dans le main et dans une sous fonction mainGL qui me paraît être une approche très ... C pur
Dans la plupart des IDE (codeblocks, visual studio) tu peux définir ton projet de façon à ce qu'il est une console par défaut, et avec glut (même si je te conseillerais plutôt freeglut ou même la SFML qui est bien mieux) tu créer la fenêtre graphique.

[Fredchkek]

Bonjour,

vu le nom que tu donne à ta fonction "mainGL" tu dois confondre quand à son utilisation.

Non, non je ne confonds pas et je sais bien ce qu'est un main. La seule raison pour laquelle j'ai un mainGL est que je souhaite découpler au maximum la partie graphique du reste. En gros, j'ai une application qui fait des calculs scientifiques et une partie graphique qui me permet de tester certains points. Cette partie graphique disparaitra dans la version finale du code ou pourra être un outil indépendant (le mainGL deviendra alors un main). Ce n'est peut être pas ce qu'il y a de plus simple (ou propre) mais c'est la philosophie que j'ai "malheureusement" choisie il y a trop longtemps pour changer radicalement la structure. (a la limite je peux passer à freeglut puisque c'est la partie graphique qui est la moins avancée).

Après pour améliorer les choses je te conseillerais de regrouper et d'encapsuler tes données

Alors là j'avoue ne rien comprendre ... Mais je suis preneur pour des explications !!

[oxyde356]

Regarde du côté de la programmation orienté objet. Tu trouveras énormément de tutoriels.