Discussion :

[betsprite]

Bonjour,

je cherche depuis peu à inclure des événements dans mon univers 3D (pour l'instant très pauvre pour les tests :p -> un carré blanc en z = -5).

J'ai alors ajouter à mon programme des événements avec les touches directionneles du clavier HAUT-BAS-GAUCHE-DROITE et F1 et F2 aussi pour des tests) définis tels que :

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
GLvoid callback_special(int key, int x, int y){
 
float speed = 0.5f;						// Vitesse de déplacement de la caméra
 
	switch (key)
	{
		case GLUT_KEY_UP:					// Flèche vers le haut : 
			zCam -= speed;					// on déplace la caméra selon z-
			glutPostRedisplay();			// et on demande le réaffichage.
			break;
 
		case GLUT_KEY_DOWN:					// Flèche vers le bas :
			zCam += speed;					// on déplace la caméra selon z+
			glutPostRedisplay();			// et on demande le réaffichage.
			break;
 
        case GLUT_KEY_LEFT:					// Flèche vers la gauche : 
			centreX -= speed;					// on déplace la caméra selon centreX-
			glutPostRedisplay();			// et on demande le réaffichage.
			break;
 
        case GLUT_KEY_RIGHT:					// Flèche vers la droite : 
			centreX += speed;					// on déplace la caméra selon centreX+
			glutPostRedisplay();			// et on demande le réaffichage.
			break;
 
        case GLUT_KEY_F1:
            xCam -= speed;
            glutPostRedisplay();			// et on demande le réaffichage.
			break;
 
        case GLUT_KEY_F2:
            xCam += speed;
            glutPostRedisplay();			// et on demande le réaffichage.
			break;
	}
 
}

Avec

Code :

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

1
2
3
double zCam = 1.0;
double centreX = 0.0;
double xCam = 0.0;

Et dans ma fonction "display()" :

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
void display ( void )   // Create The Display Function
{
    if (!initialized) {
		init();
		initialized = true;
	}
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	//clear de la Couleur et de la profondeur.
 
   	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();                       // On initialise la matrice de vue avec la matrice identité. 
 
    gluLookAt(xCam,0.0,zCam, xCam+ centreX,0.0,0.0, 0.0,1.0,0.0);
 
    glBegin(GL_QUADS);
 
    // In front of :
    glTexCoord2i(0,0); glVertex3f(-1,-1,-5); 
    glTexCoord2i(1,0); glVertex3f(1,-1,-5); 
    glTexCoord2i(1,1); glVertex3f(1,1,-5); 
    glTexCoord2i(0,1); glVertex3f(-1,1,-5); 
 
 
 
    glEnd(); 
 
    glutPostRedisplay();
 
   glutSwapBuffers ( ); // buffer de travail.
}

Malheureusement, le résultat n'est pas du tout celui attendu.
Avec cette méthode, la caméra n'est pas entièrement libre dans l'univers 3D et reste attaché aux 3 axes absolus X,Y,Z (z étant la profondeur, x la largeur, et y la hauteur).
Ainsi, si je pivote un peu la caméra en visant un vecteur avec un X plus grand (rotation vers la droite), et que j'essai de me déplacer latéralement vers la gauche (en prenant en compte la petite rotation vers la droite), au lieu de se déplacerlatéralement, la caméra "recule" (car le déplacement latérale est sur l'axe des X décroissant et ne prend pas en compte la rotation et donc le CHANGEMENT DE REPERES).

J'éspère que vous comprenez mon problème. Si jamais vous avez une alternative cela m'aiderait beaucoup !

Merci !

[stardeath]

en fait à chaque fois que tu pivotes ta caméra, il faut calculer le vecteur direction et le vecteur "droite" correspondant, et utilisant ces vecteurs pour te déplacer.

[betsprite]

Je ne comprends pas bien ton explication.

En fait, je suis en train de me demander s'il n'existe pas une méthode de déplacement plus indépendante des axes X, Y, Z (avec plus de libertés dans l'espace que le déplacement sur ces 3 axes).

Comme par exemple le calcul direct de la position dans l'espace en fonction de la touche préssée et de la position antérieure (avec calcul en coordonnées sphériques ou polaire y = 0, X, Z (sans pouvoir sauter ou se déplacer en hauteur).

Si vous avez des idées ou liens pour mieux comprendre comment s'y prendre pour avoir plus de liberté pour un déplacement 3D, cela m'aiderait beaucoup !

Je vous remercie d'avance !

[stardeath]

alors comment expliquer ça simplement ...

en vrai, quand tu te déplaces, la direction de ton regard forme un vecteur, et quand tu avances, tu te déplaces selon ce même vecteur. hors quand tu tournes la tête, ce vecteur change, et quand tu avanceras tu le feras selon ce nouveau vecteur.

maintenant dans ta scène 3d c'est la même chose, quand tu déplaces ta vue à la souris, il faut que tu recalcules le vecteur correspondant à la direction de ton regard. comme ça quand tu avances, tu le fais toujours selon le vecteur de vue.

[betsprite]

C'est encore un peu flou :s

Pour le vecteur de direction, tu parles du 2eme vecteur de la fonction gluLookAt() ?
Si oui, en gros quand tu avances, il faut reculer ce vecteur pour que le vecteur visé soit toujours à la même distance de toi c'est bien ça ?

Et si tu pivotes, le vecteur visé change également.

Je pense avoir compris si c'est ça.

Maintenant, comment se libérer des axes X,Z dans le plan Y=0 ? Parce que tu as beau faire une petite rotation vers la gauche ou la droite, après ton déplacement ne pourras pas s'effectuer en diagonale par exemple ... ou en avanceant tout droit (en appuyant sur HAUT) suivant l'angle de rotation que tu auras donné avant...)

J'ai du mal à voir comment m'y prendre avec les coordonnées dans le plan X,Z, Y=0.

[stardeath]

en fait admettons qu'on ait une caméra défini comme suit :

Code :

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

1
2
3
4
5
6
7
8
9
10
struct camera
{
    vec3 position;
    vec3 direction; // vecteur normé !!!
    vec3 up;
};
camera cam;
cam.position(0, 0, 0); // je me place au centre de ma scène
cam.direction(0, 0, 1); // je regarde vers les Z positifs
cam.up(0, 1, 0);

mon gluLookAt sera donc comme ça :

Code :

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

gluLookAt(cam.position, cam.position+cam.direction, cam.up);

lorsqu'on avance, on ajoute direction à la position de la caméra :

Code :

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

1
2
3
4
void avancer()
{
    cam.position += cam.direction;
}

mettons qu'on tourne la caméra vers la gauche ou la droite, on va donc change le vecteur direction de la camera :

Code :

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

1
2
3
4
5
void tourner()
{
    matrix m = générer_matrice_de_rotation autour_de_l_axe_y(angle_de_rotation);
    cam.direction *= m;
}

avec ça, tu ne dépends jamais des axes x et z quand tu te déplaces, tu dépends de ton vecteur direction que tu mets à jour à chaque rotation de ta caméra.

[betsprite]

Ha ok, je vois à peu près l'idée !

Au lieu de faire des incrémentations sur X et Z séparément, tu incrémentes le vecteur en entier.

Seulement, je comprends mal le dernier code :

mettons qu'on tourne la caméra vers la gauche ou la droite, on va donc change le vecteur direction de la camera :

Code :

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

1
2
3
4
void tourner()
{
    matrix m = générer_matrice_de_rotation autour_de_l_axe_y(angle_de_rotation);
    cam.direction *= m;

}

Je ne comprends pas bien la ligne :

Code :

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

matrix m = générer_matrice_de_rotation autour_de_l_axe_y(angle_de_rotation);

En gros tu as m qui est un vecteur et

Code :

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

générer_matrice_de_rotation_autour_de_l_axe_y()

prend en paramètre l'angle de rotation.
Mais je ne vois pas bien comment ça marcherait à l'intérieur de cette fonction. Comment s'écrirait vraiment la matrice m ?

Aussi, comment s'appelerait cette fonction à l'intérieur du de la fonction d'affichage dsplay() ?
En fait, tu tournerais plutot la scène que la caméra ?

Merci pour ton aide

[stardeath]

effectivement pour tourner c'est pas clair;

pour "faire tourner" un vecteur il y a plusieurs solution, j'ai choisi de multiplier le vecteur direction par une matrice de rotation.

donc m est une matrice de rotation et générer_matrice_de_rotation autour_de_l_axe_y(...) créé une matrice de rotation qui simulera la rotation "de la tête". (voir plus loin pour la générer à la main)

pour l'appeler, dans la fonction de prise en compte des entrées utilisateurs, il suffira de faire par exemple :

Code :

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

1
2
3
4
if( flèche_gauche )
    tourner(+10);
else if( flèche droite )
    tourner(-10);

pour ce qui est de tourner la scène, j'ai jamais compris en quoi on tourne la scène mais c'est pas la question.

donc maintenant comment on créé une matrice de rotation autour de l'axe y avec un angle a :

Code :

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

1
2
3
4
 cos a    0    sin a    0
     0    1        0    0
-sin a    0    cos a    0
     0    0        0    1

[betsprite]

Ok j'y vois plus clair merci beaucoup !

Juste une dernière question, dans la fonction display() :

A quel moment doit se faire l'appel de la fonction gluLookAt avec les paramètres position, direction, ...

Aussi, il faut que dans la fonction de prise en compte des entrée je marque :

Code :

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

1
2
glutPostRedisplay();			// et on demande le réaffichage.
			break;

non ?

Ainsi que dans la fonction display() ou je dois mettre à la fin de mon code :

Code :

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

1
2
glutPostRedisplay() non ?
Enfin un seul appel de cette fonction dans la fonction de prise en compte des entrées de suffirait pas ?

Merci encore !

[stardeath]

heu ... le gluLookAt, après le clear.

oui pour le glutPostRedisplay(); à la fin de chaque fonction de gestion des entrées utilisateurs.

et non pas à la fin de display, enfin je crois, j'utilise pas glut.

[Djakisback]

Salut,
j'ajouterais que ton glulookat te sert à rien, tu pourrais remplacer ça par des transformations basique de la matrice et que quittes à stocker ton repère local, et vu que tu en auras sans doute besoin pour tes objets, tu devrais créer une structure avec 3 axes x, y, z plutôt que le pitch, yaw, roll, qui, à mon sens, n'en a aucun.
Apparemment t'es en C, tu devrais développer/utiliser une lib qui manipule les vecteur.

[betsprite]

Merci tout d'abord stardeath !

Par contre, n'étant pas sûr que cela fonctionne avec des vecteurs dans l'appel de la fonction glutLookAt, j'ai tout décomposé selon chaque coordonnée. J'ai donc marqué :

Code :

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

1
2
3
4
5
void tourner(double a)
{
    viséeX = cos(a)*viséeX+viséeZ*(sin(a));
    viséeZ = -sin(a)*viséeX+viséeZ*cos(a);
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void avancer()
{
    positionX -= 0.5*viséeX; 
    positionZ -= 0.5*viséeZ;
}
 
void reculer()
{
    positionX += 0.5*viséeX; 
    positionZ += 0.5*viséeZ;
}

avec les événements pour le clavier :

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
GLvoid callback_special(int key, int x, int y){
 
	switch (key)
	{
		case GLUT_KEY_UP:					// Flèche vers le haut : 
 
             avancer();   				
 
			glutPostRedisplay();			// et on demande le réaffichage.
			break;
 
		case GLUT_KEY_DOWN:					// Flèche vers le bas :
 
                reculer();					// on déplace la caméra selon z+
 
			glutPostRedisplay();			// et on demande le réaffichage.
			break;
 
        case GLUT_KEY_RIGHT:
            tourner(+1.0);
            glutPostRedisplay();			// et on demande le réaffichage.
			break;
 
        case GLUT_KEY_LEFT:
            tourner(-1.0);
            glutPostRedisplay();			// et on demande le réaffichage.
			break;
	}

Seulement, ma fonction tourner() ne fonctionne pas... J'ai un véritable problème pour la rotation et je ne vois pas bien d'ou sa vient, malgré les dessins de trigonométrie que j'ai pu faire. ( Si je fais une fois GAUCHE, cela semble fonctionner, avec une rotation du bon côté, mais dés le deuxième appui, la rotation change de sens (GAUCHE -> rotation à droite, et lorsque j'appui un certain nombre de fois, je ne peux plus bouger quelque soit la touche directionnelle préssée... )

Aussi, les fonctions avancer() et reculer() fonctionnent sauf si je fais une rotation avant (dans ce cas, il n'y pas même plus de mouvement à l'appui des touches UP et DOWN...)

Si jamais vous savez je suis preneur :p

Merci encore !

Djakisback merci pour ta réponse. Mais je ne comprend pas bien ce que tu dis :s

[stardeath]

alors l'angle que tu donnes à la fonction tourner est en radian, donc tourner(1.0f); effectue donc une rotation de 60° environ, c'est assez énorme.

ensuite ta fonction pour tourner me semble bizarre, mais je peux déjà te dire qu'il faut obligatoirement que le vecteur visee soit un vecteur unitaire, il faut le renormaliser à chaque rotation.

ps : j'ai trouvé pourquoi ça me semblait bizarre, il faut mettre ça à ta fonction tourner :

Code :

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

1
2
3
4
5
6
7
8
void tourner(double a)
{
	float nViseeX = cos(a)*viseeX+viseeZ*(sin(a));
	float nViseeZ = -sin(a)*viseeX+viseeZ*cos(a);
 
	viseeX = nViseeX;
	viseeZ = nViseeZ;
}

et donc pas besoin de renormaliser, la rotation n'est pas censée toucher à la norme (bien que par sécurité on peut le faire).

[betsprite]

Merci pour ta réponse stardeath

Bon alors, j'ai donc modifié mon code de la façon suivante :

Code :

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

1
2
3
4
5
6
7
8
void tourner(double a)
{
    float nviseeX = cos(a*piover180)*viseeX+viseeZ*(sin(a*piover180));
	float nviseeZ = -sin(a*piover180)*viseeX+viseeZ*cos(a*piover180);
 
	viseeX = nviseeX;
	viseeZ = nviseeZ;
}

Et dans la fonction de gestion du clavier :

Code :

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

1
2
3
4
5
6
7
8
9
case GLUT_KEY_RIGHT:
            tourner(+15.0);
            glutPostRedisplay();			// et on demande le réaffichage.
			break;
 
        case GLUT_KEY_LEFT:
            tourner(-15.0);
            glutPostRedisplay();			// et on demande le réaffichage.
			break;

Seulement, il y a encore un problème avec l'angle qui oscille rapidement (pas le temps de faire un tour en appuyant sur DROITE (ou GAUCHE) que la rotation repart de l'autre côté (oscillation entre rotation vers la gauche et la droite en appuyant continuellement sur une touche directionnelle).

Aussi, lorsqu'on avance (UP) ou recule (DOWN), la rotation effectuée antérieurement ne semble pas être prise en compte dans le déplacement.
Voici, pour que se soit plus clair, les foctions avancer() et reculer() :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void avancer()
{
    positionX -= 0.5*viseeX; 
    positionZ -= 0.5*viseeZ;
}
 
void reculer()
{
    positionX += 0.5*viseeX; 
    positionZ += 0.5*viseeZ;
}

Si vous avez des idées n'hésitez pas

Merci encore !

[stardeath]

normalement de toute façon on ne fait jamais de déplacement sans prendre en compte le temps écoulé depuis la dernière frame (ici nommé elapsedTime)

normalement on fait ça :

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
// en variable globale par exemple
float vitesseRotationAutourDeY = 15.0f; // on souhaite une rotation de 15 degré par seconde
float d2r = M_PI / 180.0f;
 
// dans la fonction tourner
void tourner()
{
    // elapsed doit être en seconde car vitesseRotationAutourDeY est en degré/s
    float a = vitesseRotationAutourDeY * elapsedTime * d2r;
 
    float nviseeX = cos(a)*viseeX+viseeZ*sin(a);
    float nviseeZ = -sin(a)*viseeX+viseeZ*cos(a);
 
    viseeX = nviseeX;
    viseeZ = nviseeZ;
}

et chez moi avancer et reculer marche correctement comme je les ai indiqué

ps : bon il y a des trucs qui peuvent ne pas être recalculés à chaque appel (comme a entre autre)

[betsprite]

D'accord ! merci pour l'aide

J'ai donc maintenant :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void tourner()
{
    // elapsed doit être en seconde car vitesseRotationAutourDeY est en degré/s
    float a = vitesseRotationAutourDeY * elapsedTime * d2r;
 
    float nviseeX = cos(a)*viseeX+viseeZ*sin(a);
    float nviseeZ = -sin(a)*viseeX+viseeZ*cos(a);
 
    viseeX = nviseeX;
    viseeZ = nviseeZ;
}

Avec en déclaration :

Code :

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

1
2
3
float vitesseRotationAutourDeY = 15.0f; // on souhaite une rotation de 15 degré par seconde
float d2r = PI / 180.0f;
double elapsedTime = 2.0;

Et sans changement dans le display().

Mais j'ai toujours un problème de rotation. La rotation commence et change vite de sens faisant comme ça une oscillation sans que la caméra tourne sur elle-même.

Si vous avez une explication à me donner cela m'aiderait beaucoup :p j'ai du oublier quelque chose ^^

Merci !

[stardeath]

Mais j'ai toujours un problème de rotation. La rotation commence et change vite de sens faisant comme ça une oscillation sans que la caméra tourne sur elle-même.

sachant que je ne comprend toujours pas ton phénomène, que tu donnes pas de code, que tu as pas l'air de regarder les valeurs que prennent tes variables ...

[betsprite]

Oui désolé stardeath, j'avais laissé des bouts de code et pas tout le programme en même temps.

Sinon en ce qui concerne le problème, j'ai posé ça en trigonométrie et je pense avoir trouvé la solution !

Je te remercie pour ton aide

[stardeath]

je remarque avec un peu de recul que ma réponse était pas franchement très sympa, je m'en excuse.

bref si tu trouves pas, essaie de plus détailler ton problème, c'est un peu flou là ><

[betsprite]

Il n'y a pas de problèmes stardeath

J'aurais du préciser d'avantage mes difficultés pour ma part ...

Bon en fait j'ai pas mal avancé !

J'ai trouvé aussi, en ce qui concerne les événements de la souris, comment permettre en maintenant le bouton gauche et en déplaçant la souris vers la GAUCHE (la DROITE), faire pivoter la caméra vers la gauche (la droite). Voici le code tel que je l'ai trouvé :

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
/*********************************
****** EVENEMENT SOURIS **********
*********************************/
 
 
// Clic de la souris :
 
void mouse(int bouton,int etat,int x,int y) {
  button = bouton;
  mx = x ;
  my = y ; 
  if ( etat == GLUT_DOWN ) {
    mouvement = 1 ; }
  if ( etat == GLUT_UP ) {
    mouvement = 0 ; } 
}
 
 
// Mouvement de la souris avec clic maintenu :
 
void motion(int x,int y) {
  switch ( button ) {
    case GLUT_LEFT_BUTTON :
      if ( mouvement == 1 ) {
          angle -= (x-mx)/200.0F );
        mx = x; 
        my = y; 
        glutPostRedisplay(); }
        break; }
}

Avec en déclaration de variables globales :

Code :

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

1
2
3
4
5
6
static int mx;
static int my;
 
static int mouvement = 0 ;      // Pour activer le mouvement si le clic de la souris est maintenu
static int button = 0 ;
static float angle = 0.0F;

En ce qui concerne ce code, j'ai du mal à comprendre le fonctionnement de la rotation, à savoir, le code avec le clique maintenu :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
// Mouvement de la souris avec clic maintenu :
 
void motion(int x,int y) {
  switch ( button ) {
    case GLUT_LEFT_BUTTON :
      if ( mouvement == 1 ) {
          angle -= (x-mx)/200.0F ); 
        mx = x; 
        my = y; 
        glutPostRedisplay(); }
        break; }

-> Tout d'abord, a aucun moment, dans les fonctions d'événements pour la souris, on donne en entrée la valeur des paramètres

Code :

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

(int x,int y)

-> De même, on définit bien ici que le mouvement aura lieu que si le clic gauche est maintenu, mais ou dit-on que le mouvement dépend du déplacement de la souris vers la gauche ou la droite ?

-> Aussi, je ne comprends pas d'ou vient la valeur de l'incrémentation de l'angle (pourquoi cette valeur ?)

Code :

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

angle -= (x-mx)/200.0F );

, et enfin, l'affectation

Code :

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

1
2
 mx = x; 
my = y;

Je vous remercie pour votre aide