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.