Bonjour,

Je me suis mis depuis quelques temps à étudier (en douceur) la bibliothèque OpenGL. Pour y voir plus clair j'ai acheté le Guide officiel OpenGL (Red Book) en français et feuilleté ce qui me paraissait intéressant.

Mais voilà, je m'embrouille avec les fonctions qui concernent la matrice de modélisation-visualition et la matrice de projection. Et tout ça parce que je ne comprends pas la différence entre visualisation et projection.

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
 
/*
 *  cube.c
 *  This program demonstrates a single modeling transformation,
 *  glScalef() and a single viewing transformation, gluLookAt().
 *  A wireframe cube is rendered.
 */
#include <GL/glut.h>
#include <stdlib.h>
 
void init(void) 
{
   glClearColor (0.0, 0.0, 0.0, 0.0);
   glShadeModel (GL_FLAT);
}
 
void display(void)
{
   glClear (GL_COLOR_BUFFER_BIT);
   glColor3f (1.0, 1.0, 1.0);
   glLoadIdentity ();             /* clear the matrix */
           /* viewing transformation  */
   gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
   glScalef (1.0, 2.0, 1.0);      /* modeling transformation */ 
   glutWireCube (1.0);
   glFlush ();
}
 
void reshape (int w, int h)
{
   glViewport (0, 0, (GLsizei) w, (GLsizei) h); 
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity ();
   glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
   glMatrixMode (GL_MODELVIEW);
}
 
void keyboard(unsigned char key, int x, int y)
{
   switch (key) {
      case 27:
         exit(0);
         break;
   }
}
 
int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
   glutInitWindowSize (500, 500); 
   glutInitWindowPosition (100, 100);
   glutCreateWindow (argv[0]);
   init ();
   glutDisplayFunc(display); 
   glutReshapeFunc(reshape);
   glutKeyboardFunc(keyboard);
   glutMainLoop();
   return 0;
}

En suivant la progression du programme :
GLUT est initialisée, puis on créé une fenêtre et on appelle la fonction init().
On dit à GLUT les fonctions dont il va se servir, puis on lance la boucle principale.
Au premier affichage de la fenêtre, reshape() est appelée.
On fait la transformation de cadrage. Puis on positionne la matrice active comme étant celle de projection, on effectue des transformations de projection, et on remet la matrice active comme étant celle de modélisation.

Jusque là tout va bien.
Ensuite pour dessiner la fenêtre, la fonction display() est appelée.
On vide la fenêtre. On vide la matrice active (qui est donc ici la matrice de modélisation-visualisation. Et là... on appelle gluLookAt().

C'est là que je coince. On me dit que c'est une transformation de visualisation, mais lorsque j'y pense, pour moi c'est plutôt une transformation de projection et aussi de visualisation. Je suis complètement embrouillé sur la différence entre visualisation et projection !

Est-ce que quelqu'un peut m'expliquer la différence ?

Merci, et bon développement