Gestion d'une caméra

**momo l'plus bô** · 02/05/2013, 17h10

Bonjour tout le monde,

Je me bas depuis hier pour essayer de faire fonctionner correctement le déplacement de ma caméra sous OpenGL; J'ai volontairement choisi de ne pas suivre à la lettre les tutos trouvés sur le web, car je voulais que la solution vienne de moi.

Je pense m'en être sorti en ce qui concerne le déplacement droit devant la caméra (même si celà reste à prouver), mais je galère vraiment pour la partie orientation avec la souris.En effet, je me retrouve avec des valeurs assez incohérentes, bien qu'ayant repris les calculs du tuto. Voici le code que j'ai réalisé:

camera.h

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
#ifndef CAMERA_H
#define CAMERA_H
 
#include <SDL/SDL.h>
 
#include <gl/gl.h>
#include <gl/glu.h>
 
#include "math.h"
 
class camera
{
private:
    int posX;       //position X
    int posY;       //position Y
    int posZ;       //position Z
    double viseX;      //Position où regarde la caméra X
    double viseY;      //Position où regarde la caméra Y
    double viseZ;      //Position où regarde la caméra Z
    float axeX;     //Angle de la caméra X
    float axeY;     //Angle de la caméra Y
    float axez;     //Angle de la caméra Z
 
    SDL_Event *event;
    int preX;
    int preY;
 
    float teta;
    float phi;
public:
        camera(int unePosX, int unePosY, int unePosZ, int uneViseX, int uneViseY, int uneViseZ, float unAxeX, float unAxeY, float unAxeZ, SDL_Event *unEvent);
 
        //*****************************************************
        //*********** vitesse doit être différent de 1 ********   //D'ailleurs je sais pas pourquoi, je sais juste que ça ne marche pas
        //*****************************************************
        void deplacementLongitudinal(int vitesse);
        void deplacementLateral(int vitesse);
        void tournerCam(SDL_Event *event);
        virtual ~camera();
};
 
#endif // CAMERA_H

camera.cpp

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
#include "camera.h"
 
camera::camera(int unePosX,
               int unePosY,
               int unePosZ,
               int uneViseX,
               int uneViseY,
               int uneViseZ,
               float unAxeX,
               float unAxeY,
               float unAxeZ,
               SDL_Event *unEvent)
{
    //ctor
    posX = unePosX;
    posY = unePosY;
    posZ = unePosZ;
    viseX = uneViseX;
    viseY = uneViseY;
    viseZ = uneViseZ;
    axeX = unAxeX;
    axeY = unAxeY;
    axez = unAxeZ;
 
    event = unEvent;
    preX = event->motion.x;
    preY = event->motion.y;
 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(posX,posY,posZ,viseX,viseY,viseZ,0,0,1);
}
 
void camera::deplacementLongitudinal(int vitesse)
{
    float angleX = 0;
    float angleY = 0;
    float angleZ = 0;
 
    angleX = atan((posZ-viseZ)/(posY-viseY));
    angleY = atan((posZ-viseZ)/(posX-viseX));
    angleZ = atan((posX-viseX)/(posY-viseY));
 
    posX=(int)(posX+vitesse*(sin(angleX)));
    posY=(int)(posY+vitesse*(sin(angleY)));
    posZ=(int)(posZ+vitesse*(sin(angleZ)));
 
    viseX=(int)(viseX+vitesse/2*(sin(angleX)));
    viseY=(int)(viseY+vitesse/2*(sin(angleY)));
    viseZ=(int)(viseZ+vitesse/2*(sin(angleZ)));
 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(posX,posY,posZ,viseX,viseY,viseZ,0,0,1);
}
 
void camera::deplacementLateral(int vitesse)
{
    //Pas vraiment d'idées mais pas encore vraiment cherché...
}
 
void camera::tournerCam(SDL_Event *Event)
{
    teta -= Event->motion.xrel;
    phi -= Event->motion.yrel;
 
    if(phi >= 90)
        phi = 90;
 
    else if(phi<=-90)
        phi = -90;
 
    fprintf(stderr, "phi = %f\n", phi);
    fprintf(stderr, "teta = %f\n", teta);
    fprintf(stderr, "phi*3.14/180 = %f\n", phi*3.14/180);
    fprintf(stderr, "teta*3.14/180 = %f\n", teta*3.14/180);
    fprintf(stderr, "cos(phi*3.14/180) = %f\n", cos(phi*3.14/180));
    fprintf(stderr, "cos(teta*3.14/180) = %f\n", cos(teta*3.14/180));
    fprintf(stderr, "viseX = %d\n\n", viseX);
 
    viseX = ((cos(phi*3.14/180))*(cos(teta*3.14/180)));
    viseY = ((cos(phi*3.14/180))*(sin(teta*3.14/180)));
    viseZ = (sin(phi*3.14/180));
 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(posX,posY,posZ,viseX,viseY,viseZ,0,0,1);
}
 
 
camera::~camera()
{
    //dtor
}

le résultat de mes logs:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
...
 
phi = 60.000000
teta = -206.000000
phi*3.14/180 = 1.046667
teta*3.14/180 = -3.593556
cos(phi*3.14/180) = 0.500460
cos(teta*3.14/180) = -0.899592
viseX = -1696566979
 
...

Le résultat est que l'orientation ne bouge quasiment pas (à peine visible) et si je met des coefficients multiplacateur à mes viseX, viseY et viseZ, je ne peux pas tourner à 360°...

Si vous voulez d'avantages d'info. n'hésitez pas à demander, je ne sais pas exactement ce qui pourrait vous être utile...

En vous remerciant!

**LittleWhite** · 03/05/2013, 00h34

Bonjour,

J'imagine que vous voulez faire une caméra FPS, du coup.
Je vous conseille de penser en terme de vecteur et donc de dire que votre caméra a une orientation (un vecteur qui va vers devant elle).

Ensuite, autour du point de la position de la caméra, imaginez une sphère.

Vous avez deux angles (l'inclinaison et l'orientation). Ces deux changent suivant le déplacement de la souris. En Y l'inclinaison et en X l'orientation.
Grâce à des calculs, vous pouvez retranscrire ces deux angles en un point sur la sphère autour de la caméra. C'est plutôt simple, il faut une feuille de papier, son cercle trigonométrique du collège et c'est. En fait, il suffit de faire quelques cosinus/sinus et le tour est joué.

Ce point indique où la camera regarde. Pour la fonction gluLookAt, vous allez juste faire "position + point de regard (celui généré à partir de l'inclinaison/orientation)" et vous aurez le point où regarde la caméra.

Je crois que j'ai tout dit. N'hésitez pas à m'en demander plus.

**momo l'plus bô** · 03/05/2013, 08h01

Merci LittleWhite!

En faite, je pense que c'est exactement ce que j'ai fais. C'est vrai que je n'appelais pas ça vecteur, mais je pense qu'au final c'est ce que j'ai.
Mon problème se situe justement au niveau de ces calculs. En effet, lorsque j'exécute mon programme, j'ai bien un monde qui bouge, mais sans me donner l'impression que je suis dans une sphère... :/
ça ressemble d'avantages à du n'importe quoi! ^^"

Donc si justement tu pouvais t'assurer de la véracité de mes calculs ce serait top! (même si d'après les exemples sur internet, ils me paraissent bon...) Ensuite, faudra peut être reparler du code!

Merci de ton aide!

**plegat** · 03/05/2013, 09h10

Salut

Envoyé par momo l'plus bô

Le résultat est que l'orientation ne bouge quasiment pas (à peine visible) et si je met des coefficients multiplacateur à mes viseX, viseY et viseZ, je ne peux pas tourner à 360°...

ça, ça vient de là:

Code :

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

1
2
3
4
 
    viseX = ((cos(phi*3.14/180))*(cos(teta*3.14/180)));
    viseY = ((cos(phi*3.14/180))*(sin(teta*3.14/180)));
    viseZ = (sin(phi*3.14/180));

quoi que tu faaaaaaaaaaaasses, oùùùùùùùù que tu sois (oui, je fais du Goldman, je sais, mais c'est vendredi!), tes viseX/Y/Z seront toujours entre -1 et 1 (produits de cos/sin). Pas vraiment ce que tu cherches, vu que tu gères ta caméra avec un GluLookAt, la position de ta caméra et ton point de visée.
Comme le suggère LittleWhite, pense avec des vecteurs. Ton point de visée c'est ta position, à laquelle tu ajoutes un vecteur, donc une distance multipliée par tes produits de cos/sin. Et pas directement tes produits de cos/sin.

Envoyé par momo l'plus bô

En faite, je pense que c'est exactement ce que j'ai fais.

Pas tout à fait. Tu as exactement fait ça, mais en supposant que ta caméra reste bloquée sur l'origine. Hors là, elle bouge...

**momo l'plus bô** · 04/05/2013, 14h53

Merci plegat de ta réponse!

tes viseX/Y/Z seront toujours entre -1 et 1

Pour avoir donc un angle sur 360° j'ai finalement simplement multiplié le résultat de mon produit par 360, ce qui à l'air de fonctionner.
Mais maintenant mon problème est sur la partie qui me semblait fonctionner correctement. En effet, le déplacement longitudinal ne se comporte pas normalement...

Pas tout à fait. Tu as exactement fait ça, mais en supposant que ta caméra reste bloquée sur l'origine. Hors là, elle bouge...

Je suppose que c'est de ça que tu parlais. Mais je ne vois pas comment adapter mon calcul. :/ Il est vrai que lorsque j'arrive au point (0,0,0), j'ai un sérieux bug (au lieu d'avancer, je pars à reculons...) Et je ne me déplace pas du tout dans la bonne direction! (du moins rarement et je pense que c'est des coups de chance ^^ )...

Voici la dernière version de code que j'ai pour cette partie:

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
void camera::deplacementLongitudinal(int vitesse)
{
    float angleX = 0;
    float angleY = 0;
    float angleZ = 0;
 
    angleX = atan((saPosZ-sonViseZ)/(saPosY-sonViseY));
    angleY = atan((saPosZ-sonViseZ)/(saPosX-sonViseX));
    angleZ = atan((saPosX-sonViseX)/(saPosY-sonViseY));
 
    //if(sin(angleX)!=0 && sin(angleY)!=0 && sin(angleZ)!=0)
 
        saPosX=(int)(saPosX+vitesse*(sin(angleX)));
        saPosY=(int)(saPosY+vitesse*(sin(angleY)));
        saPosZ=(int)(saPosZ+vitesse*(sin(angleZ)));
 
        sonViseX=(int)(sonViseX+vitesse*(sin(angleX)));
        sonViseY=(int)(sonViseY+vitesse*(sin(angleY)));
        sonViseZ=(int)(sonViseZ+vitesse*(sin(angleZ)));
 
 
    #ifdef DEBUG
        fprintf(stderr, "vitesse = %d\n", vitesse);
        fprintf(stderr, "saPosX = %d, saPosY = %d, saPosZ = %d\n", saPosX, saPosY, saPosZ);
        fprintf(stderr, "sonViseX = %d, sonViseY = %d, sonViseZ = %d\n", sonViseX, sonViseY, sonViseZ);
        fprintf(stderr, "sin(angleX) = %d, sin(angleY) = %d, sin(angleZ) = %d\n\n", sin(angleX), sin(angleY), sin(angleZ));
    #endif // DEBUG
 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(saPosX,saPosY,saPosZ,sonViseX,sonViseY,sonViseZ,0,0,1);
}

Donc si quelqu'un a une petite idée concernant mon déplacement longitudinal, je suis preneur!

Très cordialement!

**LittleWhite** · 04/05/2013, 14h57

Il n'y a pas besoin de multiplier par 360 les valeurs normalisés de l'orientation.

Sinon, sonVise ne prend toujours pas en compte la position du joueur et pour moi, saPos ne devrait pas dépendre d'un quelconque angle, car c'est une position absolue dans l'espace.
Par contre ,le déplacement du joueur s'effectuera avec un sonVise normalisé : en l'ajoutant simplement à saPos.

**plegat** · 04/05/2013, 19h44

Envoyé par LittleWhite

Il n'y a pas besoin de multiplier par 360 les valeurs normalisés de l'orientation.

+1
Je ne comprends pas trop le principe de multiplier par 360 un produit de sinus/cosinus d'un angle pour revenir à un angle... mathématiquement, y'a un truc qui m'échappe!

Envoyé par LittleWhite

Sinon, sonVise ne prend toujours pas en compte la position du joueur et pour moi, saPos ne devrait pas dépendre d'un quelconque angle, car c'est une position absolue dans l'espace.
Par contre ,le déplacement du joueur s'effectuera avec un sonVise normalisé : en l'ajoutant simplement à saPos.

Il ne travaille pas avec des vecteurs, donc ça bidouille... mais je te rejoins.

Par contre attention avec la fonction atan... ça fait parfois autre chose que ce que l'on veut! Il y a des cas où il vaut mieux passer par atan2 pour que ça colle mieux au besoin.

De toute manière, ça m'a l'air bien compliqué toutes ces formules... (et à 95% faux...)

Comme proposé par LittleWhite, quelque chose du genre:

Code :

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

1
2
 
saPosX=saPosX+vitesse*(saViseX-saPosX)/norme(saPos,saVise)

et idem en Y et en Z, ça irait aussi vite et ça éviterait de se prendre la tête avec de la trigo...

**momo l'plus bô** · 04/05/2013, 20h12

Merci de vos réponses!

Bon j'avoue que j'ai voulu faire simple et je crois qu'au final mon truc devient super compliqué...

Il est vrai que je n'utilise pas de vecteurs. Uniquement parce que je n'avais pas trop d'idées de comment je devais m'y prendre pour les implémenter. Et de plus, l'utilisation de la trigo est ce qui m'a paru le plus intuitif.

Je ne comprends pas trop le principe de multiplier par 360 un produit de sinus/cosinus d'un angle pour revenir à un angle... mathématiquement, y'a un truc qui m'échappe!

C'est vrai que je ne suis pas très bon en maths, mais si mon produit cos/sin me renvois un angle compris entre 0 et 1, je me suis dis qu'il fallait certainement le multiplier par 360 pour avoir un tour de rotation complet (et visiblement ça fonctionne). Mais j'admet que ça reste du bricolage.

Après pour la véracité des formules, j'admet que la plupart peuvent être fausses étant donné qu'elles sont de moi.

Code :

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

1
2
3
    sonViseX = (int)(360*(cos(phi*3.14/180))*(cos(teta*3.14/180)));
    sonViseY = (int)(360*(cos(phi*3.14/180))*(sin(teta*3.14/180)));
    sonViseZ = (int)(360*sin(phi*3.14/180));

A la différence près que j'ai rajouté les coefficients 360.

Après, l'histoire que sonVise ne prend pas en compte la position du joueur est du au fait que je recalcul sonVise en l'ayant déplacé d'autant que je déplace le joueurs. Donc au final on peut dire (enfin je pense) que c'est lié. Et là encore, j'admet qu'utiliser les vecteurs serait peut être plus simple, mais j'ai peur d'avoir les mêmes problèmes au moment de les implémenter (à moins qu'il existe quelques chose de tout fait, mais à ce moment là, je n'en n'ai pas entendu parler... ).

Encore merci de vous pencher sur mon problème!

**LittleWhite** · 04/05/2013, 21h41

Ce n'est pas que je souhaite que vous rajoutiez des vecteurs, nous pouvons très bien faire sans.

Il faut comprendre, que dans la première explication donnée, "le vecteur orientation" dont je parlais est en fait, un point, qui est placé sur une sphère de rayon un autour de l'origine.

Si on place le joueur à l'origine, le point se situant sur une sphère de rayon un, peut être considéré comme là où il regarde.

Si le joueur se déplace, ce point n'est pas déplacé (il n'y a pas de lien). gluLookAt demande à ce que ce point soit déplacé pour qu'il soit relatif au joueur. Afin qu'il devienne relatif au joueur, il suffit d'ajouter la position du joueur aux valeurs x,y,z de ce point (donc on effectue une translation) afin que tout aille bien.

Car imaginez vous avez un joueur en 10, 0, 0 et que mon point est toujours relatif à l'origine (0, 0, 0). Alors le joueur regardera toujours en direction de l'origine (avec au maximum, un décalage de -1 et 1). Mais il ne pourra jamais se retourner.

Prenez une feuille de papier, pour mieux comprendre et faire des dessins, cela est primordiale dans ce genre de mise en place d'algorithme.

Pour ce qu'ils font sur le site, c'est déterminer notre point sur la sphère.

Pourquoi la multiplication avec 360 ne fonctionne pas ? c'est car si le joueur est à la position 500, 0, 0, encore une fois, il ne pourra plus se retourner.
Vous pouvez vous dire que, ce n'est pas grave, le joueur ne bouge pas autant, sauf que même s'il va juste à 350, 0, 0, il y aura un décalage significatif. Seul une petite portion de la sphère sera derrière lui (donc difficile à regarder) et une très grande devant lui.

**plegat** · 05/05/2013, 11h29

Envoyé par momo l'plus bô

C'est vrai que je ne suis pas très bon en maths, mais si mon produit cos/sin me renvois un angle compris entre 0 et 1, je me suis dis qu'il fallait certainement le multiplier par 360 pour avoir un tour de rotation complet (et visiblement ça fonctionne). Mais j'admet que ça reste du bricolage.

Disons que c'est plutôt l'explication du 360 qui pose soucis!

Multiplier tes produits sin/cos par un facteur, c'est exactement ce qu'il faut faire. Mais par un rayon, pour placer le point visé sur la sphère autour de ta position. Mais pas par 360 "pour revenir à un angle". Tu aurais dit que tu prenais un rayon de 360, ça passait tout seul...

Envoyé par momo l'plus bô

Code :

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

1
2
3
    sonViseX = (int)(360*(cos(phi*3.14/180))*(cos(teta*3.14/180)));
    sonViseY = (int)(360*(cos(phi*3.14/180))*(sin(teta*3.14/180)));
    sonViseZ = (int)(360*sin(phi*3.14/180));

A la différence près que j'ai rajouté les coefficients 360.

Il faut faire attention avec les formules "que l'on récupère sur internet". Elles fonctionnent généralement bien, mais dans leur contexte. Il suffit que tu modifies une données pour qu'elles ne fonctionnent plus correctement.
Pour ces formules, on en revient à la discussion qu'on a depuis le début, et le problème qu'on essaie de te faire comprendre avec LittleWhite, à savoir que ces formules fonctionnent très bien pour donner le point visé en supposant que l'on est positionné à l'origine. Si tu n'y est plus, il faut ajouter la translation de ta position, donc mettre un +posX pour le terme en X, et pareil pour les autres.

Après, c'est super simple. Quand tu tournes la caméra, tu recalcules tes viseX/Y/Z avec les formules précédentes, quand tu déplaces la caméra (longitudinal ou latéral), tu modifies tes posX et viseX de la même manière (et pareil pour posY/viseY et posZ/viseZ).
Je t'ai donné une formule dans mon post précédent, yaka l'utiliser pour commencer...

Gestion d'une caméra

GLUT

Discussions similaires

Partager

Partager