Camera en opengl avec gluLookAt

Version imprimable

Bonjour,

Je comprends pas bien commen faire et j'ai beau a essayer.ca marche pas comme je voulais.

Voici le code:

Code:

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
#include <SDL/SDL.h>
#include <GL/gl.h>
#include <GL/glu.h>
int up,right;
SDL_Event event;
void draw_screen(void)
{
while (1)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();                       
if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_UP)
{
 up = (up + 1);
}
if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_DOWN)
{
 up = (up - 1);
}
if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_LEFT)
{
 right = (right + 1);
}
if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_RIGHT)
{
 right = (right - 1);
}
 
gluLookAt(right,up,1,0,0,0,0,1,0);
 
glTranslatef(0.0f,0.0f,0.0f);          
glBegin(GL_QUADS);
 glColor3d(1,0,0);
 glVertex3i(1,1,1);
 glColor3d(-1,-9,0);
 glColor3d(1,-3,5);
 glVertex3i(1,-1,1);
 glColor3d(3,1,-1);
 glVertex3i(-1,-1,1);
 glColor3d(-1,-1,0);
 glVertex3i(-1,1,1);
 glColor3d(1,1,0);
 glVertex3i(1,1,-1);
 glColor3d(-1,-1,-1);
 glVertex3i(1,-1,-1);
 glColor3d(-1,-1,0);
 glVertex3i(-1,-1,-1);
 glColor3d(-1,-1,0);
 glVertex3i(-1,1,-1);
 glColor3d(1,0,-1);
 glVertex3i(1,1,1);
 glColor3d(2,-1,0);
 glVertex3i(1,-1,1);
 glVertex3i(1,-1,-1);
 glColor3d(-1,-1,0);
 glVertex3i(1,1,-1);
 glColor3d(1,3,0);
 glVertex3i(-1,1,1);
 glColor3d(-1,4,-1);
 glVertex3i(-1,-1,1);
 glColor3d(3,-1,0);
 glVertex3i(-1,-1,-1);
 glColor3d(1,0,0);
 glVertex3i(-1,1,-1);
 glColor3d(-1,0,6);
 glVertex3i(-1,1,-1);
 glColor3d(-1,2,-2);
 glVertex3i(-1,1,1);
 glColor3d(1,-5,0);
 glVertex3i(1,1,1);
 glColor3d(-1,-1,0);
 glVertex3i(1,1,-1);
 glColor3d(-1,-1,0);
 glVertex3i(-1,-1,-1);
 glVertex3i(-1,-1,1);
 glColor3d(-3,2,0);
 glVertex3i(1,-1,1);
 glColor3d(-1,-2,3);
 glVertex3i(1,-1,-1);
glEnd();
SDL_GL_SwapBuffers();
SDL_PollEvent (&event);
if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE)
{
 SDL_Quit();
 return;
}
}
}
void setup_opengl( int hauteur, int largeur )
{
   float ratio = (float) hauteur / (float) largeur;
   glClearColor(0, 0, 0, 0);
   glViewport(0, 0, hauteur, largeur);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   gluPerspective(45, ratio, 0.5, 50);
   glMatrixMode(GL_MODELVIEW);
   glEnable(GL_DEPTH_TEST);
}
 
int main(int argc, char **argv)
{
   int hauteur = 800;
   int largeur = 600;
   int bits = 32;
   int flags = 0;
   SDL_Init(SDL_INIT_VIDEO);
   flags = SDL_OPENGL;
   SDL_SetVideoMode(hauteur,largeur,bits,flags);
   setup_opengl(hauteur,largeur);
   draw_screen();
   return 0;
}

gluLookAt(0,0,0,0,0,0,0,0,0);
je sais que les 1eres 3 zero c'est le point x,y,z ou se trouve la caméra, les 3 suivantes .. c'est le point x,y,z ou elle regarde.. et les dernieres 3dernieres je sais pas ce que ca fais.

Mais le resultat n'est pas bon.Est ce que vous savez comment s'ii prendre? Merci d'avance :D

13/07/2005, 09h02
Antickriszt

déjà, si tu ne nous dis pas ce que tu veux, c'est pas nous qui allons le devnier.. ça marche pas comme tu l'attend, ok, c'ets cool, mais c'est quoi que t'attend ?

les trois dernières donne la "direction du haut", en gro c'est les coordonnées d'un vecteur qui serait colinaires au pied de la camera ;)

mais bon, si tu veux un conseil ne fais pas une camera avec un glulookat... calcul tes matrices à coup de quaternions et fais un beau glMulMatrix final... c'est plus mieux, ça te permettra de gérer facilemet n'importe quel type de camera (camera 3eme, première personne, jeu d'avion, ...) enfin moi j'ai comencé à réussir à faire une classe de camera cohérente à partir du moment où je me suis intéréssé aux quaternions... c'est donc mon conseil, fais signe si tu veux des docs sur ces outils d'algèbre qui ne sont pas des notions évidentes pour tout le monde, a commencé par moi (et je m'en suis sorti, alors..)

voili ;)

ps : au lieu décrire a = (a + 1), qui est relativement lourd, pense à l'opérateur a += 1
13/07/2005, 12h56
Happy

Merci pour ta rep :D , désolé j'ai oublier de preciser :( , je voulais bien gerer la camera, par exemple quand j'appuye sur la fleche gauche .. que ca tourne a gauche sur un axe..j'arrive pas..
Il faut utiliser l'axe des 3 dernieres 0 du gluLookAt si j'ai bien compri?
Sinon quaternions ca a l'aire un peu plus compliqué ,je vais voir .. encore merci. :D
13/07/2005, 16h10
Antickriszt
il faut réfléchir deux secondes... qu'est ce qu'il se passe lorque tu appuies sur la gauche la... tu une coordonnée de ton vecteur position qui s'incrémente, autrement dit, tu subi une espèce de translation suivant une composante, et en même temps une rotation puisque ton vecteur "direction de la camera" est fixe (il pointe sur l'ortigine)

en fait, si tu veux faire effectuer un rotation tout en restant immobile (rotation suivant un des axe du repère lié à la camera), tu dois changer le vecteurde la direction !

bon c'est pas très clair tout ça...

glulookat prend trois vecteurs, position, direction, orientation (va t on les appeler ici)

position designe la position de la camera au sein de la scène en 3d, direction designe le point fixé par la camera, et orientation designe en gros si on a la tête en haut en bas ou dans un position intermédiare
ne nous occupons pas celui là...

nous avons donc position et direction, orientation reste constant et a pour valeur (0, 1, 0) si on considère que le cameraman est sobre
la difficulté de gérer une telle camera en mouvement est de calculer la bonne valeur du vecteur direction... en effet lorsque tu tournes autour de toi, position est contant, ok ? tu ne bouges car tu es au centre de la rotation... donc ce n'est pas sur ce vecteur que l'on va agir...

ton glulookat à cette geule :

Code:

gluLookAt(pos[0], pos[1], pos[2], dir[0], dir[1], dir[2], 0.0, 1.0, 0.0);

avec à t = 0 :
Code:

1 2 3 4 pos[0] = pos[1] = pos[2] = 0.0; dir[0] = pos[0]; dir[1] = pos[1]; dir[2] = pos[2] + 20; // tu regardes devant toi sur z (convention)
maintenant si tu avances (up) :
Code:

1 2 3 pos[0] += dir[0] * speed; pos[1] += dir[1] * speed; pos[2] += dir[2] * speed;
(-= si tu recules (down))

et quand tu tournes... ben il faut que ton vecteur direction garde une norme constante... donc tu ajoutes une composante sur x que tu retranche sur z... sur y on va dire que ça bouge pas (le gars peut pas lever les yeux au ciel... sinon c'est trop chiant :lol:)

bon alors si on va à gauche, on calcul :
depl = speed;
sinon (droite),
depl = -speed;

puis
Code:

1 2 dir[0] += depl; dir[2] -= depl;
voili... bon alors y'a rien de garanti, c'est plus pour expliquer, hein ? le code source je l'ai tapé à l'arache mais je pens que mon truc est cohérent...
bon après comme je t'ai dit, tout ça, c'est avant de se pencher sur es quaternions ;) ça t'ouvre des portes fabuleuses ce truc !

tiens, je viens d'avoir uen autre idée, tu initialises un angle theta = 0, et tu dis que :
dir[0] = sin(theta) * dist; // dist est une constante (20 dans l'exemple précédent)
dir[1] = 0.0;
dir[2] = cos(theta) * dist;

après, lorsque tu appuies sur droite et gauche, tu fais sincrémenter ou se décrémenter la valeur de theta en fonction de la constante speed, et tu recalcules tes coordonées en cosinus et sinus à chaque fois... ça devrait marcher !