Discussion :

[Acropole]

Il y'a déjà pas mal de posts et de tutos sur ce sujet, mais aucun ne m'a permis d'avoir une idée claire, et encore moins d'obtenir le résultat que je souhaite
J'aimerais donc avoir des éclaircicements sur le point précis qui m'occupe :

- Le point de vue est celui du pilote d'un vaisseau spatial.
- Le déplacement du vaisseau est le suivants :
-- Il peut avancer et reculer, s'arréter, se déplacer latéralement et verticalement. Tout ceci étant gérré par le clavier à la manière d'un doom-like
-- Il peut pivoter dans n'importe quelle direction sans limite. C'est a dire qu'il peut faire un tour complet sur lui même sur n'importe quel axe. Ces rotations son gérrées par la souris mais diffèrent des doom-like sur un point important : le mouvement sur Y de la souris correspond à une rotation sur l'axe Y du vaisseau et non du repère fixe d'opengl.

Or, j'utilise deux commandes succéssives opengl :

glRotatef(xRot, 1.0, 0.0, 0.0);
glRotatef(yRot, 0.0, 1.0, 0.0);

ce qui pose un problème. En effet, lorsqu'on regarde vers le haut ou vers le bas (xRot = 90 ou -90) le mouvement obtenu par le mouvement latéral de la souris (sur Y) aboutit à une rotation des objets autour du centre de l'écran, et non à une translation de la gauche vers la droite ou de la droite vers la gauche.

Bref, j'ai eu beau regarder les divers tutoriaux je n'arrive pas à coder le bon comportement. Quelqu'un pourrait-il m'aider ?

PS : pour ceux qui connaissent, le comportement des rotations est exactement le même que celui des vaisseaux dans AS-Mothership d'unreal tournament 2004.

[Zenol]

A ta plaece, j'aurais effetuer une rotation du point de vue, et non des objets, come sa les o bjets résterais fixe, tu n'aurais a te soucier que du déplacement du point de vue.

Nb : Je débute avec l'openGL.

[Acropole]

C'est à dire ? (je débute aussi )

Dans mon code je place et pivote chaque objet avec un push/pop matrix indépendemment, et une fois qu'ils sont tous placés je fais les rotations et translation globales.

Comment tu procède pour faire pivoter le point de vue ?

[Omfraax]

Ben euh tu veux en fait savoir comment on avance dans les coordonnées du monde (x,y,z) alors que le vaisseau est tout chamboulé par rapport à ces directions.

Pour ça, il faut te lancer dans les coordonnées sphériques qui relient les axes du vaisseaux aux axes absolus via les deux angles. Tu dois pouvoir trouver ça assez facilement sur internet....

Et pour pivoter le point de vue utlise
gluLookAt(xorigine,yorigine,zorigine, xvisé,yvisé,zvisé, xrot,yrot,zrot)

où le vecteur xrot,yrot,zrot défini le vecteur haut (et qui gère la rotation de la caméra autour de son axe de visée)

[Acropole]

J'ai trouvé des trucs sur le net mais le résultat donne plus ou moins n'importe quoi à chaque fois. Alors je dois surement oublier un truc quelque part...

En gros, voila comment j'ai compris le truc :

les deux glRotate donnent deux quaternions :
xRot, 1.0,0.0, 0.0 et yRot,0.0,1.0,0.0

qu'il faut normaliser puis multiplier et mettre le resultat dans un seul glRotate ?

[Omfraax]

Le problème c'est que glRotatef ne font que rotationner les objets, si après tu veux avancer devant toi (sur un axe lié au vaisseau) ça ne sera pas fait avec glRotatef. Mettons que tu repeère tes coordonnées de vaisseau par x,y,z, coordonnée du monde absolu, quand tu appui la flèche avant, ce n'est pas juste

Code :

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

x+=pas;

qu'il faut executer mais un truc faisant intervenir les 2 angles de rotation de ton vaisseau.... Il faut dissocier la physique de l'affichage 3D....

[djo.mos]

Normalemnt, toutes tes rotations, et toutes tes translations se font dans repère relatif au vaisseau, et pas à celui d'openGL, n'est ce pas ?
dans ce cas, pas besoin de quaternions, car ils servent à faire des rotations dans repère absolue.

Ce qui va plutôt t'interesser, ce sont les matrices.
Ce que j'ai fait, c'est de :
- laisser tomber les glRotatef et les glTRanslatef
- construire une petite librairie Matrices 4x4 qui implementen les rotations et les translations (il y'a des tonnes de docs et de sources la dssus sur le net)
- ensuite, utilises les matrices pour les transformations!

par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
 
Vaisseau_mat.Identity();
Vaisseau_mat.RotateX(30);
Vaisseau_mat.RotateY(15);
Vaisseau_mat.TranslateX(5);
 
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMultMatrixf(addr(Vaisseau_mat.getMatrix));

(j'utilise Delphi).
De cette façon, t'auras un controle absolue sur les transformations.

bonne chance.

[Acropole]

Justement mon problème concerne la rotation globale de l'univers par rapport au point de vue.

Mon code :

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
	mvtSouris();
	SetCursorPos(400, 300);
 
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();				
	actKey();
 
	glPushMatrix(); *************************************
		glRotatef(xRot,1.0, 0.0, 0.0);
		glRotatef(yRot,0.0, 1.0, 0.0);   AFFICHAGE DU CIEL
			monde.afficherCiel();
	glPopMatrix();*************************************
 
 
//ROTATIONS ET MOUVEMENTS DE LA CAMERA
 
	glRotatef(xRot, 1.0, 0.0, 0.0);
	glRotatef(yRot, 0.0, 1.0, 0.0);
 
	glTranslatef(lateralCam, verticalCam, distCam);
 
			GLfloat lightPos[] = {10.0, 10.0, 1.0, 0.0};
			GLfloat couleurSoleil[] = {1.0,0.2,0.2,1.0};
			GLfloat ambientSoleil[] = {0.2,0.2,0.2,1.0};
 
			glLightfv(GL_LIGHT0, GL_DIFFUSE, couleurSoleil);
			glLightfv(GL_LIGHT0, GL_AMBIENT, ambientSoleil);
			glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
 
		monde.afficher(); // AFFICHAGE DU MONDE

dans monde.afficher() ;

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
 
void MAP::afficher()
{	
	position pos;
	for (int i=0; i < nbrObjets; i++)
	{	
		glPushMatrix();
// position *****************
		pos = (*tabVaisseau[i]).m_Pos;
		glTranslated(pos.x, pos.y, pos.z);
		glRotatef(-90, 1.0f, 0.0f, 0.0f);
 
// ************* MAILAGE
		glCallList(listes[(*tabVaisseau[i]).maillageIndex]);
		glPopMatrix();
	}
}

Comme on le vois, les mouvements des vaisseaux sont dans monde.afficher() entre push et pop matrix, donc en "local".

Mais, une fois que tous les objets sont disposés par monde.afficher(), j'applique les rotations et translations globales à l'ensemble.

En gros, chaque vaisseau fait sont mouvement puis le tout est déplacé et pivoté par rapport aux mouvement de la souris et du clavier, c'est à dire au point de vue du joueur.

[shenron666]

[...]pas besoin de quaternions, car ils servent à faire des rotations dans repère absolue.

Ce qui va plutôt t'interesser, ce sont les matrices.

Autant que je sache, les quaternions servent à résoudre les problème et/ou à simplifier les transformations en rapport avec des repères relatifs

D'autre part, un fait des calculs avec des quaternions et on en extrait la matrice que l'on transfère à OpenGL via un glLoadMatrix
donc les matrices ne sont pas un remplacement des quaternions, les quaternions sont simplement un complément des matrices

Si vous voulez un tutorial (costaud mais en français) sur les quaternions :
http://miageprojet.unice.fr/twiki/bin/view/Projets/CameraQuaternions

En anglais il y a aussi un article sur nehe pour créer un système de caméra sans quaternions :
http://nehe.gamedev.net/data/articles/article.asp?article=08

D'autres articles sur Gamedev.net traitent des quaternions :
http://www.gamedev.net/reference/list.asp?categoryid=28#250

Je pense que vous devriez trouver votre bonheur dans tout cela

[djo.mos]

J'ai jamais dit que les quaternions etaient des remplacants de matrices !

J'ai dit que les quaternions servent à faire des rotations dans un repère absolu car ils ne souffrent pas du problème du gimbal lock qu'on rencontre sur les matrices, donc, une mèthode élegante d'effectuer des rotations 3D est :
- d'utiliser les matrices pour les rotation locales (càd dans le repère de l'objet)
- d'utiliser les quaternions pour faire lesd rotations dans le repère global

Et c'est pas trop compliqué d'aller d'une matrice orthonormale à un quaternion unitaire et vice versa.

[shenron666]

J'ai jamais dit que les quaternions etaient des remplacants de matrices !

Désolé, j'ai un peu hativement déduit cela de ta remarque.

J'ai dit que les quaternions servent à faire des rotations dans un repère absolu car ils ne souffrent pas du problème du gimbal lock qu'on rencontre sur les matrices...

Tout à fait d'accord, et comme tu le fais si bien remarquer, on passe facilement d'un quaternion à une matrice et vice-versa

[djo.mos]

Voici quelques liens qui traitent de ce sujet (les transformations 3D, notamment en OpenGL), le seul hic, c'est que c'est en anglais :


http://www.gamedev.net/reference/pro...s/default.html
--> qlqs pages qui parlent des quaternions



http://www.j3d.org/matrix_faq/matrfaq_latest.html
--> une excellente faq à propos des matrices et des quaternions.



http://<br /> http://www.flipcode.c...sue04-pf.shtml

http://www.sjbaker.org/steve/omniv/eulers_are_evil.html
--> ça parle des problèmes qu'on rencontre avec les angles d'euler.

http://www.anticz.com/eularqua.htm
www.euclideanspace.com

J'espère que ca peut vous aider.

[shenron666]

Le lien Gamedev est mort...
j'en ai donné un plus haut qui renvoie à la sous-catégorie et qui donne tous les liens gamedev vers des articles sur les quaternions

les autres sont très intéressants

Merci pour les liens

[djo.mos]

c vrai, désolé, j'ai pas verifié.
voici un autre lien à la place de l'ancien
http://www.gamedev.net/reference/art...rticle1095.asp