Discussion :

[FoX_*D i E*]

OpenGL (glut) en langage C++

Bonjour,

Je lutte comme un dingue pour pouvoir déplacer la vue (ou la camera) dans une scène. Je sais, c'est la scène qui se déplace et non la vue mais quand même, ca me chagrine de ne pas réussir se truc (ou qu'il n'y ai pas de fonction glu dès le départ qui gère ca)

Question n°0: y a-t-il une manière de définir l'Identité à la position (et aux angles) actuel, un genre de glSaveIdentity, pour que le glLoadIdentity charge dorénavant la position que l'on vient de sauvée?

Donc j'ai utiliser 2 manières: une a base de gluLookAt , l'autre à base d'une série de glRotate et glTranslate. Je ne suis arrivé a mes fins avec aucune, j'ai eu beaucoup de faux espoirs...

Note: pour les interactions clavier, j'utilise un clavier QWERTY et dans l'idéal, je voudrais avoir (par rapport à la vue actuelle):
tourne gauche a -- d tourne droit
regarde en haut w -- s regarde en bas
pivote gauche q -- e pivote droit

vas a gauche j -- l vas a droite
monte i -- k descent
avance o -- u recule

Question 1: quelle est la formule magique en cosinus et sinus pour que le gluLookAt fonctionne correctement?

Code :

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
const GLdouble PI = 3.1415926535898;

GLvoid Keyboard(unsigned char , int , int);

//View locate parameters
GLdouble eyex=0.;
GLdouble eyey=0.;
GLdouble eyez=0.;
GLdouble centrex=0.;
GLdouble centrey=0.;
GLdouble centrez=0.;
GLdouble upx=0.;
GLdouble upy=1.;
GLdouble upz=0.;
GLdouble anglexz=0;
GLdouble angley=0;

GLvoid DrawScene(GLvoid)
{
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  glPushMatrix();

 //ca devient critique comment j'en peut plus
/*en gros pour le centrex-centrez, je rajoute un sinus-cosinus pour que l'on regarde l'objet fictif sur le cercle trigonometrique dont la vue actuelle est le centre, et ca fonctionnent pour tourner gauche-droite
remarque: nos interactions clavier font que les eyei =centrei*/
 gluLookAt(eyex,eyey,eyez,centrex+sin(anglexz),centrey,centrez+cos(anglexz),sin(angley)*cos(anglexz),cos(angley)*cos(anglexz),sin(angley)*cos(anglexz));

  DessineSalle();

   glutPostRedisplay();
   glutSwapBuffers();
  glFlush();

  glPopMatrix();
}

GLvoid
Keyboard(unsigned char key , int x, int y)
{
  switch(key)
    {
////////////////// ROTATE
    case 'e':
      angley-=PI/144;
      break;
    case 'q':
      angley+=PI/144;
      break;
    case 'd' :
      anglexz-=PI/144;
      break;
    case 'a' :
      anglez+=PI/144;
      break;
    case 's' :
      anglex-=PI/144;
      break;
    case 'w' :
      anglex+=PI/144;
      break;

//////////////TRANSLATE
    case 'j' :
      centrex-=0.25;
      eyex-=0.25;
      break;
    case 'l':
      centrex+=0.25;
      eyex+=0.25;
      break;
    case 'k' :
      centrey-=0.25;
      eyey-=0.25;
      break;
    case 'i' :
      centrey+=0.25;
      eyey+=0.25;
      break;
    case 'o' :
      centrez-=0.25;
      eyez-=0.25;
      break;
    case 'u' :
      centrez+=0.25;
      eyez+=0.25;
      break;

    case 'V':
      glLoadIdentity();
      break;

    case 27:
      exit(1);
      break;
    }

     glutPostRedisplay();
}

Question 2: Pourquoi cette astuce de la fonction en glRotate et glTranslate ne marche pas du tout?

Code :

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

GLvoid Keyboard(unsigned char , int , int);


GLvoid Camera(GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat );//move the camera
GLfloat angleX = 0;
GLfloat angleY = 0;
GLfloat angleZ = 0;
GLfloat posX = 0;
GLfloat posY = 0;
GLfloat posZ = 0;

GLvoid DrawScene(GLvoid)
{

  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  glPushMatrix();

  DessineSalle();

   glutPostRedisplay();
   glutSwapBuffers();
  glFlush();

  glPopMatrix();



}

GLvoid
Keyboard(unsigned char key , int x, int y)
{
  switch(key)
    {
////////////////// ROTATE
    case 'e':
      Camera(0.,0.,1.,0.,0.,0.);
      break;
    case 'q':
      Camera(0.,0.,-1.,0.,0.,0.);
      break;
    case 's' :
      Camera(1.,0.,0.,0.,0.,0.);
      break;
    case 'w' :
      Camera(-1.,0.,0.,0.,0.,0.);
      break;
    case 'd' :
      Camera(0.,1.,0.,0.,0.,0.);
      break;
    case 'a' :
      Camera(0.,-1.,0.,0.,0.,0.);
      break;

//////////////TRANSLATE
    case 'j' :
    Camera(0.,0.,0.,1.,0.,0.);
      break;
    case 'l':
     Camera(0.,0.,0.,-1.,0.,0.);
      break;
    case 'k' :
    Camera(0.,0.,0.,0.,1.,0.);
      break;
    case 'i' :
    Camera(0.,0.,0.,0.,-1.,0.);
      break;
    case 'o' :
    Camera(0.,0.,0.,0.,0.,1.);
      break;
    case 'u' :
    Camera(0.,0.,0.,0.,0.,-1.);
      break;

    case 'V':
      glLoadIdentity();
      break;

    case 27:
      exit(1);
      break;
    }

      glutPostRedisplay();
}


GLvoid Camera(GLfloat rotX, GLfloat rotY, GLfloat rotZ, GLfloat transX , GLfloat transY, GLfloat transZ)
{
//je ne pourrais pas expliquer ce que j'observe, en tout cas c'est pas ce que j'attend...
     glTranslated(posX,posY,posZ);
    glRotated(angleX,1.,0.,0.);
    glRotated(angleY,0.,1.,0.);
    glRotated(angleZ,0.,0.,1.);

    angleX-=rotX;
    angleY-=rotY;
    angleZ-=rotZ;
    posX-=transX;
    posY-=transY;
    posZ-=transZ;

    glRotated(-angleZ,0.,0.,1.);
    glRotated(-angleY,0.,1.,0.);
    glRotated(-angleX,1.,0.,0.);
    glTranslated(-posX,-posY,-posZ);


}

[LittleWhite]

Bonjour,

Lorsque l'on ne peut pas expliquer quelque chose, on rajoute des captures d'écrans .

Sinon, moi ma formule "magique", pour le déplacement de la caméra est la suivante:

Code :

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
 
case 37:	// Left
 
				look_z -= (sin_angle * cos_inclinaison * distance) /100 ;
 
				look_x += (cos_angle * cos_inclinaison * distance) /100 ;
 
				break;
 
			case 38:	// Up
 
				look_z = look_z + (cos_angle * cos_inclinaison * distance) /100 ;
 
				look_x = look_x + (sin_angle * cos_inclinaison * distance) /100 ;
 
				break;
 
			case 39:	// Right
 
				look_z += (sin_angle * cos_inclinaison * distance) /100 ;
 
				look_x -= (cos_angle * cos_inclinaison * distance) /100 ;
 
				break;
 
			case 40:	// Down
 
				look_z = look_z - (cos_angle * cos_inclinaison * distance) /100 ;
 
				look_x = look_x - (sin_angle * cos_inclinaison * distance) /100 ;
 
				break;

et

Code :

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

1
2
3
4
5
6
7
8
 
glLoadIdentity();
 
	gluLookAt(	look_x , look_y, look_z ,
 
				sin_angle * cos_inclinaison * distance + look_x , sin_inclinaison * distance + look_y , cos_angle * cos_inclinaison * distance + look_z,
 
				0, 1, 0 );

Pour le coup du glTranslate et glRotate, je n'ai jamais aimé cette méthode ( surtout que cela peut changer la position des objets si on ne fait pas attention).

[FoX_*D i E*]

ouai moi aussi je prefere carement lookat que rotate et translate, mais j'ai tellement gallere avec les formules en cosinus que j'ai lache l'affaire^^

Je pense que meme avec des captures d'ecran, j'aurais rien pu expliquer du tout

sinon, j'vais adapter ca a mon code je reviens pour les festivites

[FoX_*D i E*]

ok, c'est pas reelement ce que je veux.
En fait je l'avait deja tout ca, et meme un peu plus.

Ce que je veux c'est: 6 degres de liberte (dont la torsion selon l'axe des Z, comme quand on penche la tete)

+

Par rapport a la vue actuelle (donc qui s'actualise apres chaque mouvement)

par exemple, si je regarde un peu en haut, puis j'avance, je voudrais avancer dans la direction de mon regard, et non parallelement au sol. Un peu comme un avion de chasse.

[stardeath]

pour ça il suffit d'utiliser (selon moi pour plus de simplicité) les matrices et/ou les quaternions avec l'algo suivant :

soit V la matrice de vue.

à chaque "frame de déplacement" :
- on extrait les 3 axes de la matrice V, qu'on appellera U (vecteur haut), R (vecteur right) et D (vecteur du direction de regard).
- on construit des matrice/quaternions de rotation avec les axes U, R et D selon ce que l'utilisateur veut.
- on multiplie tout ça, que l'on multiplie aussi à V
et voilà !

[FoX_*D i E*]

oulala, eclaire moi,

J'ai lu deux trois article du red book, mais ca ne m'avance pas (ils propose un pilotView qui n'est pas ce que je veux)

peux tu m'expliquer plus en code parce que la, je ne sais meme pas quoi chercher

Merci

[FoX_*D i E*]

OK, j'ai fait une analyse de la camera,
Rappelez-vous que je veux que toutes les rotations et les translations soit par rapport à la vue actuelle, et non par rapport à la vue-zéro

Base sur ce code, j'ai essayé des ordres différents de transformation là ou il y a des *********

Voici mon code simplifié:

Code :

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
 
 
    GLfloat angleX = 33;
    GLfloat angleY = 159;
    GLfloat angleZ = 57;
    GLfloat posX = -2.3;
    GLfloat posY = -1.5;
    GLfloat posZ = 5;
 
int main(int argc , char **argv)
{
    glutInit(&argc,argv);
    Initialise(argv[0]);  
    glutKeyboardFunc(Keyboard);
    glutDisplayFunc(DrawScene);  
    glutReshapeFunc(Resize);
    glutMainLoop();
    return 0;
}
 
GLvoid Initialise(char * Titre)
{
    GLvoid DefineWindow(char *);
    glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE );
    glutInitWindowPosition(0,0);
    glutInitWindowSize(800,600);
    glutCreateWindow(Titre);
    glClearColor(0.7,0.7,1., 1.);
}
 
GLvoid Resize(GLsizei WindowWidth , GLsizei WindowHeight  )
{
    glViewport( 0, 0,WindowWidth , WindowHeight) ;
    GLfloat ratio = (GLfloat)  WindowWidth /  WindowHeight;
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.,ratio,0.1,130);
    glMatrixMode(GL_MODELVIEW);
}
 
GLvoid Keyboard(unsigned char key , int x, int y)
{
  switch(key)
    {
////////////////// ROTATE
    case 'e':
      Camera(0.,0.,1.,0.,0.,0.);
      break;
    case 'q':
      Camera(0.,0.,-1.,0.,0.,0.);
      break;
    case 's' :
      Camera(1.,0.,0.,0.,0.,0.);
      break;
    case 'w' :
      Camera(-1.,0.,0.,0.,0.,0.);
      break;
    case 'd' :
      Camera(0.,1.,0.,0.,0.,0.);
      break;
    case 'a' :
      Camera(0.,-1.,0.,0.,0.,0.);
      break;
//////////////TRANSLATE
    case 'j' :
    Camera(0.,0.,0.,1.,0.,0.);
      break;
    case 'l':
    Camera(0.,0.,0.,-1.,0.,0.);
      break;
    case 'k' :
    Camera(0.,0.,0.,0.,1.,0.);
      break;
    case 'i' :
    Camera(0.,0.,0.,0.,-1.,0.);
      break;
    case 'o' :
    Camera(0.,0.,0.,0.,0.,1.);
      break;
    case 'u' :
    Camera(0.,0.,0.,0.,0.,-1.);
      break;
 
    case 'v':
      glLoadIdentity();
      break;
    case 27:
      exit(1);
      break;
    }
   glutPostRedisplay();
}
 
GLvoid Camera(GLfloat rotX, GLfloat rotY, GLfloat rotZ, GLfloat transX , GLfloat transY, GLfloat transZ)
{
    angleX+=rotX;
    angleY+=rotY;
    angleZ+=rotZ;
    posX+=transX;
    posY+=transY;
    posZ+=transZ;
}
 
GLvoid DrawScene(GLvoid)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glPushMatrix();
 
   ***************
 
    glutSolidTeapot(0.5);
    DrawRoom();
 
    glutPostRedisplay();
    glutSwapBuffers();
    glPopMatrix();
}

Voici tout ce que je veux vérifier:
* Rotation par rapport a l'axe des X actuelle
* Rotation par rapport a l'axe des Y actuelle
* Rotation par rapport a l'axe des Z actuelle
* Translation suivant l'axe des X actuelle
* Translation suivant l'axe des Y actuelle
* Translation suivant l'axe des Z actuelle


Et voici les ordres que j'ai testé, ceux-ci sont mis aux ********** dans le code

Ordre 1

Code :

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

1
2
3
4
    glRotated(angleX,1.,0.,0.);
    glRotated(angleY,0.,1.,0.);
    glRotated(angleZ,0.,0.,1.);
    glTranslated(posX,posY,posZ);

* Rotation par rapport a l'axe des X actuelle : OK
* Rotation par rapport a l'axe des Y actuelle : OK
* Rotation par rapport a l'axe des Z actuelle :NON, c'est une rotation par rapport a l'axe des Z dans la vue-Zero translate sur la vue actuelle , pourquoi?? seulement translate a notre vue, mais pas rotate pourquoi !!!!! Si ce n'etait pas un succès, je m'attendais a tourner autour de l'axe des Zde la vue-Zero, mais non, c'est le'axe de la vue-zéro translate dans la vue actuelle (bien!), mais pas tourne dans la direction de visée (pas bien!)
* Translation suivant l'axe des X actuelle : NON, suit l'axe des X de la vue-Zero
* Translation suivant l'axe des Y actuelle : NON, suit l'axe des Y de la vue-Zero
* Translation suivant l'axe des Z actuelle : NON, suit l'axe des Z de la vue-Zero


Ordre 2

Code :

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

1
2
3
4
5
 
   glTranslated(posX,posY,posZ);
    glRotated(angleX,1.,0.,0.);
    glRotated(angleY,0.,1.,0.);
    glRotated(angleZ,0.,0.,1.);

* Rotation par rapport a l'axe des X actuelle : NON, on tourne autour de l'axe des X de la vue-zero, tourne comme notre vue actuelle (mais pas translate) pourquoi???
* Rotation par rapport a l'axe des Y actuelle : NON, on tourne autour de l'axe des Y de la vue-zero, tourne comme notre vue actuelle (mais pas translate) pourquoi???
* Rotation par rapport a l'axe des Z actuelle : NON, on tourne autour de l'axe des Z de la vue-zero d'origine
* Translation suivant l'axe des X actuelle : OK
* Translation suivant l'axe des Y actuelle : OK
* Translation suivant l'axe des Z actuelle : OK



Order 3

Code :

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

1
2
3
4
5
   glTranslated(posX,posY,posZ);
 
    glRotated(angleZ,0.,0.,1.);
    glRotated(angleX,1.,0.,0.);
    glRotated(angleY,0.,1.,0.);

* Rotation par rapport a l'axe des X actuelle : NON, on tourne autour de l'axe des X de la vue-zero
* Rotation par rapport a l'axe des Y actuelle : NON, on tourne autour de l'axe des Y de la vue-zero
* Rotation par rapport a l'axe des Z actuelle : NON, on tourne autour de l'axe des Z de la vue-zero, tourne comme notre vue actuelle (mais pas translate) pourquoi???
* Translation suivant l'axe des X actuelle : OK
* Translation suivant l'axe des Y actuelle : OK
* Translation suivant l'axe des Z actuelle : OK



........... OK, je ne vais pas essayer les 4! = 24 possibilités, mais je veux trouver un moyen (peut-être un ordre magique, un truc avec les matrices ou autre chose) de vérifier toutes ces transformations.

Encore une fois, je sais que en OpenGL c'est la scène et non pas pour la caméra qui bouge, mais quand même, je dois avoir une parfaite maîtrise de ma camera pour continuer mon travail

[stardeath]

plus en code, j'ai pas sous la main, j'ai bien du code directx mais je doute que ça aide, je vais tenter une nouvelle explication :

ton gluLookAt construit en fait une matrice de rotation dont les colonnes représentent les 3 vecteurs U, R et D de mon précédent post (je ne sais jamais dans quel ordre, mais ça se retrouve, suffit juste de faire un gluLookAt et de récupérer la matrice pour vérifier)

ces 3 vecteurs correspondent à :
- D : vecteur direction, celui où tu regardes
- R : vecteur right, celui quand tu strafes
- U : vecteur up, celui quand tu "sautes"

ainsi tu peux te servir de ces axes pour te déplacer, ou pour construire des matrices de rotations correspondant au roulis, tangage et au lacet.

[FoX_*D i E*]

ok, a la place des etoiles dans mon code j'ai essaye ca:

Code :

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

1
2
3
4
5
6
 
    GLfloat TrMatrix[]={(GLfloat)(cos(angleY)*cos(angleZ)),(GLfloat)(-cos(angleY)*sin(angleZ)),(GLfloat)sin(angleY),posX,
                        (GLfloat)(sin(angleX)*sin(angleY)*cos(angleZ)+cos(angleX)*sin(angleZ)),(GLfloat)(-sin(angleX)*sin(angleY)*sin(angleZ)+cos(angleX)*cos(angleZ)),(GLfloat)-sin(angleX)*cos(angleY),posY,
                        (GLfloat)(-cos(angleX)*sin(angleY)*cos(angleZ)+sin(angleX)*sin(angleZ)),(GLfloat)(cos(angleX)*sin(angleY)*sin(angleZ)+sin(angleX)*cos(angleZ)),(GLfloat)cos(angleX)*cos(angleY),posZ,    0.f,0.f,0.f,1.f};
 
glLoadMatrixf(TrMatrix);

En plus de casser tout mon dessins de ma salle (certains murs ne s'affiche pas, la lumiere est fausse... la translation n'est pas relative.

Bon bin les outils se font de plus en plus rare, ca m'etonne de chercher autant pour un truc qui devrait etre automatique en infographie.

[stardeath]

Bon bin les outils se font de plus en plus rare, ca m'etonne de chercher autant pour un truc qui devrait etre automatique en infographie.

heu l'infographie ça s'invente pas, il faut quand même un minimum de connaissance en maths ><

et as tu regardé ce que j'ai écrit dans mon post précédent?

ps: bon en essayant d'écrire un exemple pour toi, je me suis rappelé pourquoi je déteste opengl : la nécessité de recourir à des bibliothèques tierces dès qu'on a besoin de quelque chose, les 12000 define nécessaires pour avoir toutes les fonctions et le chargement à la main des pointeurs de fonctions. donc je verrai ça plus tard si personne ne lit ce thread d'ici là.

[plegat]

Bon bin les outils se font de plus en plus rare, ca m'etonne de chercher autant pour un truc qui devrait etre automatique en infographie.

stardeath t'a donné la méthode habituellement utilisée, à savoir les quaternions. Ce n'est pas pour rien que tu as du mal à trouvé des explications avec les formules à coup de sinus et cosinus, c'est d'une complexité trop complexe! (pas en termes d'outils mathématiques, mais en termes de longueur de formules...)
En prime, OpenGL est une lib graphique... pas un moteur de rendu, ni un moteur de jeu, ni... Donc normal que tu n'y trouves pas tout et n'importe quoi.

Utiliser les quaternions est beaucoup plus simple pour cela.
Tu gères ta matrice MODELVIEW à partir d'un quaternion lié à ta caméra, que tu modifies à coup de rotations par rapport aux axes x et y et z locaux à ta vue, et tu réinjectes la matrice correspondant au quaternion dans la mtrice MODELVIEW OpenGL. C'est au moins 2 fois plus simple, voire plus...

Il y a une FAQ Quaternion sur le site, je te laisse y jeter un oeil. Et pas mal de doc sur le net. Sinon fait une recherche avec "trackball" comme mot clef également, ça devrait te donner des pistes.

[FoX_*D i E*]

J'ai pas voulu reveiller les esprits revolutionnaire des fondamentalistes de l'infographie en disant ca, mais cela reste vrai, meme tres vrai, que c'est etonnant de gallerer autant pour faire des deplacement par rapport a la vue actuelle.

Pas de fonctions dans openGL, pourquoi pas, mais pas de fonction chez glut ou encore pas des choses toutes faites sur le net, la ca devient ridicule. (attention, je ne remet pas en cause la definition de glut!!)

Bon, ma reponse est peut-etre chez les quarternions, donc je vais poster ce que j'aurais trouver ici

(non mais serieusement, je ne dois pas etre le seul gars qui chercher a maitriser parfaitement la camera dans openGL, vu qu'on peut faire de l'animation et tout, et selon moi, pour gerer parfaitement la camera, pas mieux que de la controler par rapport a la vue actuelle)

ca me tue...

[icer]

Bonjour,

Je n'ai pas bien compris ton problème de gestion de caméra. Qu'est-ce que tu veux dire par "vue actuelle" ? La matrice de vue/modèle actuelle?

Autrement, gluLookAt() fonctionne très bien pour placer la caméra dans la scène. On spécifie sa position, une cible (la position du sujet) et un vecteur indiquant vers où pointe le haut de la caméra... et hop on a une belle prise de vue à l'écran!

[plegat]

Pas de fonctions dans openGL, pourquoi pas, mais pas de fonction chez glut ou encore pas des choses toutes faites sur le net, la ca devient ridicule. (attention, je ne remet pas en cause la definition de glut!!)

Recherche Google
66400 liens... ridicule disais-tu?

Tu peux aussi chercher des infos avec "arcball" comme mot-clef.
Une bonne référence est le tuto de chez Nehe (les tutos du site sont LA base pour qui veut faire de l'openGL)

Bon, ma reponse est peut-etre chez les quarternions, donc je vais poster ce que j'aurais trouver ici

Ca marche super bien les quaternions, franchement, passe une heure à comprendre comment ça fonctionne, ensuite ça va rouler tout seul...
Une petite démo de ce que ça donne avec mon moteur à moi (les zoom et translations ne sont pas géré par quaternions eux)

[FoX_*D i E*]

Recherche Google
66400 liens... ridicule disais-tu?

Je ne parlais pas d'une recherche google sur Trackball ( quel simplicisme!!!) Je parlais de bouger la camera (ok, y a pas le concepte de camera dans openGL, mais qu'en meme) a 6 degres de liberte, ce que, avec toutes les recherches que j'ai effectue jusqu'a present, reste encore un mistere.

C'est effectivement ridicule que je dois mettre pas mal de moyen pour enfin comprendre que la solution c'est a base de trackball, en utilisant les quaternions, et que je peux oublier les glRotate et les glulookat.

Et encore, j'ai rien qui fonctionne a present, pour dire quel jardin secret c'est que ce truc.

J'suis allez faire un tour sur NeHe, et comme par hazard, les seuls trucs que je trouve c'est limite a 3 ou 4 degree de liberte, quand je veux l'appliquer a 6, ca va plus...

...donc oui, ca devient ridicule qu'il m'y ai pas de fonction chez glut ou encore pas des choses toutes faites sur le net.

Je sais pas pour vous mais pour moi ca sonne comme evident, voir obligatoire qu'on veuille controler les mouvements de la camera depuis la ou elle se trouve, et on m'a rien apporte comme reponse que je peux appliquer tout de suite, comme quoi, le jardin secret...

Ne soyez pas beginner en OpenGL, c'est la merde!!! lol

Bon ceci dit, je baisse pas les bras, j'fais de la recherche, et quand j'aurais mon truc, je promet je le poste ici.


merci plegat pour la demo, mais justement je ne recherche pas du tout ca, je veux que la camera tourne, et non pas l'objet.

icer, pour faire ca un peu plus clair, je veux me promener dans la scene comme je veux, comme si j'etais une abeille si tu veux, et donc tourner a gauche c'est faire une rotation par rapport a l'axe qui traverse mon corps, et non le centre de la scene.

J'ai commencer a etudier la question avec gluLookAt, mais les equation devenais trop complique, j'ai lache l'affaire. Voila ou je me suis arrete:

Code :

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
const GLdouble PI = 3.1415926535898;

GLvoid Keyboard(unsigned char , int , int);

//View locate parameters
GLdouble eyex=0.;
GLdouble eyey=0.;
GLdouble eyez=0.;
GLdouble centrex=0.;
GLdouble centrey=0.;
GLdouble centrez=0.;
GLdouble upx=0.;
GLdouble upy=1.;
GLdouble upz=0.;
GLdouble anglexz=0;
GLdouble angley=0;

GLvoid DrawScene(GLvoid)
{
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  glPushMatrix();

 //ca devient critique comment j'en peut plus
/*en gros pour le centrex-centrez, je rajoute un sinus-cosinus pour que l'on regarde l'objet fictif sur le cercle trigonometrique dont la vue actuelle est le centre, et ca fonctionnent pour tourner gauche-droite
remarque: nos interactions clavier font que les eyei =centrei*/
 gluLookAt(eyex,eyey,eyez,centrex+sin(anglexz),centrey,centrez+cos(anglexz),sin(angley)*cos(anglexz),cos(angley)*cos(anglexz),sin(angley)*cos(anglexz));

  DessineSalle();

   glutPostRedisplay();
   glutSwapBuffers();
  glFlush();

  glPopMatrix();
}

GLvoid
Keyboard(unsigned char key , int x, int y)
{
  switch(key)
    {
////////////////// ROTATE
    case 'e':
      angley-=PI/144;
      break;
    case 'q':
      angley+=PI/144;
      break;
    case 'd' :
      anglexz-=PI/144;
      break;
    case 'a' :
      anglez+=PI/144;
      break;
    case 's' :
      anglex-=PI/144;
      break;
    case 'w' :
      anglex+=PI/144;
      break;

//////////////TRANSLATE
    case 'j' :
      centrex-=0.25;
      eyex-=0.25;
      break;
    case 'l':
      centrex+=0.25;
      eyex+=0.25;
      break;
    case 'k' :
      centrey-=0.25;
      eyey-=0.25;
      break;
    case 'i' :
      centrey+=0.25;
      eyey+=0.25;
      break;
    case 'o' :
      centrez-=0.25;
      eyez-=0.25;
      break;
    case 'u' :
      centrez+=0.25;
      eyez+=0.25;
      break;

    case 'V':
      glLoadIdentity();
      break;

    case 27:
      exit(1);
      break;
    }

     glutPostRedisplay();
}

tourne gauche a -- d tourne droit
regarde en haut w -- s regarde en bas
pivote gauche q -- e pivote droit

vas a gauche j -- l vas a droite
monte i -- k descent
avance o -- u recule

[plegat]

merci plegat pour la demo, mais justement je ne recherche pas du tout ca, je veux que la camera tourne, et non pas l'objet.

Désolé de te contredire, mais mon objet est fixe... c'est la caméra qui bouge...

Après, je ne comprends pas grand chose à ta prose. Tu "rales" qu'il n'y a rien sur le net, hors il y a toute l'info que l'on veut, que ce soit théorique, ou prêt à utliser. Si tu veux quelque chose "out of the box", tape dans du moteur graphique déjà prêt, et encore, ce n'est pas certain que tu aies le comportement que tu veux du premier coup sans faire des réglages.

Sinon, si tu veux mettre les mains dans le cambouis, c'est soit les sinus/cosinus (mais bonne chance pour trouver de l'aide pour résoudre d'éventuels problèmes dans les formules), soit matrice 4x4/quaternion/glLoadMatrix...

[icer]

Peut-être que tu devrait mieux nous expliquer ton problème clairement et de façons posé, au lieu de "raler" comme le dit plegat.

Je suis très certain que ce que tu faire soit réalisable OpenGL. C'est un langage très éprouvé pour la programmation graphique et n'a de limite que l'imagination du programmeur. C'est un langage peut-être difficile pour le débutant(quels langages ne l'est pas? ), mais si tu t'y met vraiment, alors OpenGL deviendra un outil formidable.

...donc oui, ca devient ridicule qu'il m'y ai pas de fonction chez glut ou encore pas des choses toutes faites sur le net.

Et tu voudrais pas non plus cent balles et un mars?

Si tu penses qu'il manque de l'information sur internet, publie!

Ne soyez pas beginner en OpenGL, c'est la merde!!! lol

Pour en revenir à ton problème, qu'est-ce que tu veux faire exactement. Qu'est-ce que tu veux dire par 6 degrés de liberté? Je pense que j'ai compris ton exemple avec l'abeille, et qu'il soit tout à fait possible de faire des rotations par rapports au centre de l'abeille et non le centre de la scène.

[FoX_*D i E*]

Désolé de te contredire, mais mon objet est fixe... c'est la caméra qui bouge...

Je vois que tu n'as toujours pas compris ce que je veux faire...

le centre de l'objet, on en a rien a faire, ce qui compte c'est le centre d'ou est actuellement la camera. Touner autour de l'axe X? ok, mais pas l'axe x0, non non, l'axe du "bras droit" de la camera/ l'axe de l'ecran de ton ordi... ton affichage quoi.

T'inkiete, depuis le temps que je travaille dessus (ce qui m'a permi de vous faire ressentir mon abasourdisme concernant l'absence d'une fonctionnalite aussi simple, que ce soit chez glut ou accessible directement sur le net...)
...depuis ce temps la, je sais que l'objet tourne ou la camera tourne dans l'autre sens c'est idem

Après, je ne comprends pas grand chose à ta prose. Tu "rales" qu'il n'y a rien sur le net, hors il y a toute l'info que l'on veut, que ce soit théorique, ou prêt à utliser. Si tu veux quelque chose "out of the box", tape dans du moteur graphique déjà prêt, et encore, ce n'est pas certain que tu aies le comportement que tu veux du premier coup sans faire des réglages.

Tout est beau, tout est bien fait, OpenGL ne manque de rien et personne n'a le droit de critiquer un manque.... bin moi si, et si tu comprend ce que je recherche, tu comprendra que c'est loin d'etre "out of box", donc toute l'info que je veux sur internet.... nan nan, sinon c'est bien cacher!!

Sinon, si tu veux mettre les mains dans le cambouis, c'est soit les sinus/cosinus (mais bonne chance pour trouver de l'aide pour résoudre d'éventuels problèmes dans les formules), soit matrice 4x4/quaternion/glLoadMatrix...

Je crois avoir trouver un truc, j'arrange tout ca et je le poste, comme ca on pourra enfin discuter sur le fait que c'est deja sur internet ou pas

Peut-être que tu devrait mieux nous expliquer ton problème clairement et de façons posé, au lieu de "raler" comme le dit plegat.

........

Et tu voudrais pas non plus cent balles et un mars?

Si tu penses qu'il manque de l'information sur internet, publie!

C'est loin d'etre tirer par les cheveux ce que je demande, du coup, vu que je galere grave pour ca, je vous fait ressentir mon abasourdisme concernant l'absence d'une fonctionnalite aussi simple, que ce soit chez glut ou accessible directement sur le net.
Et je me dis que je ne dois etre le premier a vouloir faire ca, alors c'est vraiment pas trop de demander une fonctionnalite pareil directement sous la main, ou en creusant un peu sur internet...... sauf que moi j'ai creuse beaucoups, et meme ici on me donne pas de reponse. Alors du coups je trouve ca hallucinant. Toi aussi tu dis que tout est super bien fait, que rien ne manque et du coups tu ne critique rien? Ma critique est justifiee, par le fait du simplicisme de la demande, et je l'ecrit parce qu'on est dans un forum. "Raler"?... Faut arreter de dire que les gens ralent a tout va, faut creuser plus loin pour comprendre la cause, et prendre la critique comme elle est, au lieu de systematiquement remettre le celui qui critique en cause (culturellement purement francais ca! mais ca a des bons cotes...).

Justement le probleme c'est que je ne devrais pas me donner la peine de publier sur le net pour un truc aussi simple. Cent balles et un mars ca m'aiderais bien mais pas pour ca nan.

Effectivement OpenGl est tres peu fourni et on doit tout faire soit meme, comme quoi etre beginner en OpenGL ca craint... autant commencer en language moyen-niveau genre Coin3D

Pour en revenir à ton problème, qu'est-ce que tu veux faire exactement. Qu'est-ce que tu veux dire par 6 degrés de liberté? Je pense que j'ai compris ton exemple avec l'abeille, et qu'il soit tout à fait possible de faire des rotations par rapports au centre de l'abeille et non le centre de la scène.

J'ai trouver une petite astuce, et vous allez pouvoir observer le resulta en temps directement.

[FoX_*D i E*]

OpenGL - langage C
Avoir une camera libre, First Person View, avec des transformations relatives a la position de la camera, a 6 degres de liberte (DOF)

Ca y est j'y suis arrive !!!!!

Apres plusieurs heures a tester les glRotate et glTranslate, gluLookAt et chargement de grosses matrices, j'ai enfin ce que je veux!!

Certains n'ont pas capter ce que je voulais, et on a beaucoup discuter sur la disponibilite de ce genre de fonctionnalite, mais enfin de compte j'y suis arrive par moi meme a force de perceverance.

Merci pour avoir essayer de comprendre mon probleme et pour m'avoir fourni des informations, maintenant je vous invite a compiler et a voir le resultat.


Bon, ya surement de quoi simplifier mais bon....

J'ai mis ca en piece jointe mais au cas ou, voici le contenu du fichier a compiler:

Code :

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
267
268
 
 
/*
04/12/2010
 
This code shows how to move the "camera" in OpenGL like a First Person Viewer (camera piloting)
It moves the camera relatively to its position in 6 degrees of fredom.
 
The most important code is in : GLvoid transfomCamera()  and in    GLvoid DrawScene
See also   GLvoid Keyboard   for the key used
 
 
build links to:
oprngl32
glu32
glut32
gdi32
winmm
*/
 
#include <stdlib.h>//standard C library, used for exit()
//OpenGL libraries, with glut
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <math.h>//Mathematics
 
GLvoid Initialise( char * Titre);//Initialization of the scene
GLvoid DrawScene(GLvoid);// Drawing method, called in loop
GLvoid Resize(const GLsizei ,const  GLsizei);// Used when resizing the application window
GLvoid Keyboard(unsigned char , int , int);// Keyboard and mouse interaction
GLvoid DefineLight(const GLint);//Initialise the light source
GLvoid transfomCamera();//Move the free camera
 
    GLboolean toggleRotX = 0;
    GLboolean toggleRotY = 0;
    GLboolean toggleRotZ = 0;
    GLboolean toggleTransX = 0;
    GLboolean toggleTransY = 0;
    GLboolean toggleTransZ = 0;
    GLboolean toggleRotXX = 0;
    GLboolean toggleRotYY = 0;
    GLboolean toggleRotZZ = 0;
    GLboolean toggleTransXX = 0;
    GLboolean toggleTransYY = 0;
    GLboolean toggleTransZZ = 0;
    GLfloat rotX = 1.f;
    GLfloat rotY = 1.f;
    GLfloat rotZ = 1.f;
    GLfloat transX = 0.05f;
    GLfloat transY = 0.05f;
    GLfloat transZ = 0.05f;
    GLfloat TrMatrix[]={1.f,0.f,0.f,0.f,0.f,1.f,0.f,0.f,0.f,0.f,1.f,0.f,0.f,0.f,0.f,1.f};
 
    const GLfloat EPSILON = 0.00000000000001f;
 
int main(int argc , char **argv)
{
    glutInit(&argc,argv);
    Initialise(argv[0]);  /* Fonction à écrire pour initialiser la machine OpenGL */
    glutKeyboardFunc(Keyboard);
    glutDisplayFunc(DrawScene);  /* fonction à appeler avec la fonction principale de rendu à écrire */
    glutReshapeFunc(Resize);
    glutMainLoop(); /* Fonction de boucle infinie */
    return 0;
}
 
GLvoid Initialise(char * Titre)
{
    GLvoid DefineWindow(char *);
    glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE );
    glPointSize(1.f);
    glLineWidth(1.f);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_BLEND);
    glEnable(GL_POINT_SMOOTH);
    glEnable(GL_LINE_SMOOTH);
    glDisable(GL_CULL_FACE );
    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
    glPolygonMode(GL_FRONT_AND_BACK,GL_FILL );
    glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,1.f);
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
    DefineLight(4);
}
GLvoid Resize(GLsizei WindowWidth , GLsizei WindowHeight  )
{
    glViewport( 0, 0,WindowWidth , WindowHeight) ;
    GLfloat ratio = (GLfloat)  WindowWidth /  WindowHeight;
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.f,ratio,0.1f,130.f);
    glMatrixMode(GL_MODELVIEW);
}
 
GLvoid DefineWindow(char * Titre)
{
    GLsizei ScreenWidth,ScreenHeight;
    GLsizei WindowWidth, WindowHeight;
    ScreenWidth=glutGet(GLUT_SCREEN_WIDTH);
    ScreenHeight=glutGet(GLUT_SCREEN_HEIGHT);
    glutInitWindowPosition(0,0);
    glutInitWindowSize(ScreenWidth,ScreenHeight);
    glutCreateWindow(Titre);
    glClearColor(0.7f,0.7f,1.f, 1.f);
    WindowWidth  = glutGet(GLUT_WINDOW_WIDTH) ;
    WindowHeight = glutGet(GLUT_WINDOW_HEIGHT);
    Resize(WindowWidth,WindowHeight);
}
 
GLvoid DefineLight(GLint numberofLights)
{
    int i;
    const GLfloat LumiereAmbient[]={ 0.f, 0.0f, 0.0f, 0.0f};
    const GLfloat LumiereDiffuse[]={1.f, 1.f, 1.f, 1.f };
    const GLfloat LumiereSpecular[]={1.0f, 1.0f, 1.0f, 1.0f};
    const GLfloat cst_attenuation =0.025f*numberofLights;
    const GLfloat ln_attenuation= 0.1525f*numberofLights;
    const GLfloat qua_attenuation= 0.0025f*numberofLights;
    const GLint Lights[]= {GL_LIGHT0,GL_LIGHT1,GL_LIGHT2,GL_LIGHT3,GL_LIGHT4,GL_LIGHT5,GL_LIGHT6,GL_LIGHT7};
    glEnable(GL_LIGHTING);
    glEnable(GL_NORMALIZE);
    glDepthFunc(GL_LESS);
    glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1 );
    glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE );
 
    for (i = 0 ; i<numberofLights ; i++) {
        glEnable(Lights[i]);
        glLightfv(Lights[i],GL_AMBIENT,LumiereAmbient);
        glLightfv(Lights[i],GL_DIFFUSE,LumiereDiffuse);
        glLightfv(Lights[i],GL_SPECULAR,LumiereSpecular);
        glLightf(Lights[i],GL_CONSTANT_ATTENUATION,  cst_attenuation);
        glLightf(Lights[i],GL_LINEAR_ATTENUATION,  ln_attenuation);
        glLightf(Lights[i],GL_QUADRATIC_ATTENUATION,  qua_attenuation);
    }
}
 
GLvoid DrawScene(GLvoid)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
    glLoadIdentity();
    transfomCamera();
    glGetFloatv(GL_MODELVIEW_MATRIX, TrMatrix);
 
    glPushMatrix();
        glTranslatef(0.f,0.f,-6.f);
        glutSolidTeapot(1);
        glTranslatef(3.f,0.f,-3.f);
        glutSolidTeapot(1);
        glTranslatef(-9.f,0.f,-5.f);
    glutSolidTeapot(1);
    //DessineSalle();
    glPopMatrix();
 
    glutSwapBuffers();
    glutPostRedisplay();
 
}
 
GLvoid Keyboard(unsigned char key , int x, int y)
{
  switch(key)
    {
////////////////// ROTATE
    case 'e':
      toggleRotZ = 1;
      break;
    case 'q':
      toggleRotZZ = 1;
      break;
    case 's' :
      toggleRotX = 1;
      break;
    case 'w' :
      toggleRotXX = 1;
      break;
    case 'd' :
      toggleRotY = 1;
      break;
    case 'a' :
      toggleRotYY = 1;
      break;
//////////////TRANSLATE
    case 'j' :
        toggleTransX = 1;
      break;
    case 'l':
        toggleTransXX = 1;
      break;
    case 'i' :
        toggleTransZ = 1;
      break;
    case 'k' :
        toggleTransZZ = 1;
      break;
    case 'u' :
        toggleTransY = 1;
      break;
    case 'o' :
        toggleTransYY = 1;
      break;
 
    case 'v':
        glLoadIdentity();
        glGetFloatv(GL_MODELVIEW_MATRIX, TrMatrix);
      break;
 
    case 27:
      exit(1);
      break;
    }
 
      glutPostRedisplay();
}
 
GLvoid transfomCamera()
{
    if(toggleRotX) {
        glRotatef(rotX,1.f,0.f,0.f);glMultMatrixf(TrMatrix);
        toggleRotX = 0;
    }
    else if(toggleRotXX) {
        glRotatef(-rotX,1.f,0.f,0.f);glMultMatrixf(TrMatrix);
        toggleRotXX = 0;
    }
    else if(toggleRotY) {
        glRotatef(rotY,0.f,1.f,0.f);glMultMatrixf(TrMatrix);
        toggleRotY = 0;
    }
    else if(toggleRotYY) {
        glRotatef(-rotY,0.f,1.f,0.f);glMultMatrixf(TrMatrix);
        toggleRotYY = 0;
    }
    else if(toggleRotZ) {
        glRotatef(rotZ,0.f,0.f,1.f);glMultMatrixf(TrMatrix);
        toggleRotZ = 0;
    }
    else if(toggleRotZZ) {
        glRotatef(-rotZ,0.f,0.f,1.f);glMultMatrixf(TrMatrix);
        toggleRotZZ = 0;
    }
/////////////
    else if(toggleTransX) {
        glTranslatef(transX,0.f,0.f);glMultMatrixf(TrMatrix);
        toggleTransX = 0;
    }
    else if(toggleTransXX) {
        glTranslatef(-transX,0.f,0.f);glMultMatrixf(TrMatrix);
        toggleTransXX = 0;
    }
    else if(toggleTransY) {
        glTranslatef(0.f,transY,0.f);glMultMatrixf(TrMatrix);
        toggleTransY = 0;
    }
    else if(toggleTransYY) {
        glTranslatef(0.f,-transY,0.f);glMultMatrixf(TrMatrix);
        toggleTransYY = 0;
    }
    else if(toggleTransZ) {
        glTranslatef(0.f,0.f,transZ);glMultMatrixf(TrMatrix);
        toggleTransZ = 0;
    }
    else if(toggleTransZZ) {
        glTranslatef(0.f,0.f,-transZ);glMultMatrixf(TrMatrix);
        toggleTransZZ = 0;
    }
    else glMultMatrixf(TrMatrix);
}

[FoX_*D i E*]

Encore une fois,
merci d'avoir essayer de m'aider, j'espere que cette astuce vous sera utile dans un future projet.