Discussion :

[thecaptain]

Salut à tous

J'essaie d'utiliser les quaternions pour gérer la caméra dans mon programme OpenGL. Pour ce faire, j'ai une classe Camera qui contient les valeur x,y,z, angleXY (pour regarder à gauche/droite), angleZ (haut/bas) et angleRotate (pour le 'roll').

Voici le bout de code que j'utilise au départ pour insérer la matrice de vue :

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
 
//variable pour les variante
Quaternion* old = new Quaternion();
double oldAngleZ = 90;
double oldAngleXY = -90;
double oldAngleRotate = 0;
 
void Camera::place() const
{
    //calcul des différences entre les angles de la frame pré
    double zc = angleZ - oldAngleZ;
    double xyc = angleXY - oldAngleXY;
    double rc = angleRotate - oldAngleRotate;
 
    //Quaternion t1(zc, xyc, rc);
    Quaternion t1(zc, rc, xyc); //création du quaternion avec yaw / pitch / roll
    Quaternion t2(t1 * *(old));
    Quaternion* q = new Quaternion(t2.normalize());
 
    //enregistrement du quaternion pour la prochaine frame (ainsi que les angles)
    delete old;
    old = q;
 
    oldAngleRotate = angleRotate;
    oldAngleXY = angleXY;
    oldAngleZ = angleZ;
 
    if (useQuaternion) //utilisation du quaternion pour la matrice de projection
    {
        double* qv = q->to4x4RotationMatrix();
        glMultMatrixd(qv);
        delete qv;
 
        glTranslated(-x, -y, -z);
    }
    else
    { 
        //gestion standarde avec glulookat
    }
}

Je fais varier anglerXY et angleZ avec la souris. En mode normal (gluLookAt), tout se passe bien. Par contre avec le quaternion, suivant l'angle que j'utilise c'est le roll qui change...

J'imagine que ce doit être un bête truc de calcul qui me manque quelque part, mais impossible de trouver quoi

Merci d'avance !

@++

[stardeath]

qu'est ce que tu appelles "tout ce passe bien", parce que gérer une caméra avec un angle XY et Z ou avec un quaternion, à la base ce n'est pas du tout pour la même utilisation;

le quaternion te servira si tu dois stocker en permanence le repère de ta caméra, utile si tu fais des rotations dans TOUS les sens (style caméra dans un simulateur d'avions), par contre avec les angles, c'est parfait pour une caméra de type première personne.

si ta solution fonctionne comme tu le souhaites, pourquoi essayer de mettre un quaternion?

[thecaptain]

Salut,

Justement, j'ai une vue dans un cockpit d'avion qui est incliné par rapport au sol. Et j'ai effectivement besoin à d'autres endroits de faire des rotations dans tous les sens (typiquement pour mettre la caméra dans un missile qui tournera).

Merci d'avance !

@++

[N_I_C_S]

Salut,
en fait je pense que tu as un problème d'ordre des axes dans la transformation. Le bon ordre pour une caméra première personne est :

1 - l'axe Y : ton angleXY,
2 - l'axe X : ton angleZ,
3 - l'axe Z : ton angleRotate

Je préconiserais donc d'essayer

Code :

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

Quaternion t1(xyc, zc, rc);

[thecaptain]

Salut,

Merci pour ta réponse :-)
Malheureusement ça ne marche pas... de plus ça m'inverse les contrôles de la souris.

J'ai fait quelques modifications du 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
31
32
33
34
35
36
37
38
Quaternion save(90, -90, -90); //initialisation des angles (qui marche pas...)
double oldAngleZ = 0;
double oldAngleXY = 0;
double oldAngleRotate = 0;
 
void Camera::place() const
{
    double zc = angleZ - oldAngleZ;
    double xyc = -angleXY + oldAngleXY;
    double rc = angleRotate - oldAngleRotate;
 
    Quaternion delta(zc, xyc, rc);
    save = delta*save;
    save.normalize();
 
    oldAngleRotate = angleRotate;
    oldAngleXY = angleXY;
    oldAngleZ = angleZ;
 
    if (useQuaternion)
    {
        double angle, ax, ay, az;
        save.quat2AxisRot(&angle, &ax, &ay, &az);
 
        glRotated(angle, ax, ay, az);
        glTranslated(-x, -y, -z);
    }
    else
    {
        double ar = angleXY*PI_OVER_180;
        double az = angleZ*PI_OVER_180;
        double cx = x + cos(ar)*cos(az);
        double cy = y + sin(ar)*cos(az);
        double cz = z + sin(az);
 
        gluLookAt(x, y, z, cx, cy, cz, 0, 0, 1);
    }
}

Mon idée est la suivante : en appuyant sur une touche on passe du mode "standard" (gluLookAt) au mode quaternions. Logiquement, avec les mêmes angles, la vue devrait rester la même... hors il n'en est rien et je n'arrive pas à calquer mon quaternion sur ma vue standarde.

Il y a probablement quelque chose que je n'ai pas compris

Merci d'avance !

@++

[stardeath]

Salut,

Justement, j'ai une vue dans un cockpit d'avion qui est incliné par rapport au sol. Et j'ai effectivement besoin à d'autres endroits de faire des rotations dans tous les sens (typiquement pour mettre la caméra dans un missile qui tournera).

Merci d'avance !

@++

si tu es dans un cokpit d'avion ou dans un missile, il vaudrait mieux que tu utilises les quaternions en permanence.

mais quel est le comportement qui te gène entre les 2 systèmes?

[thecaptain]

Salut,

Je pense que ma première question est : peut-on avoir du 1 pour 1 entre le système des quaternions et un gluLookAt (si on garde le roll à zéro donc) ?

Jusqu'a maintenant, je gère un freecam via gluLookAt qui fonctionne très bien (avancer, straffer). Le souci (avec mon deuxième code) quand je passe aux quaternions est que visiblement je gère mal les angles puisque quand je regarde en haut et j'avance, ca me fait descendre... et il me semble que si j'inverse cela, du coup ce sont les touches avancer/straffer qui sont à un angle de 45 degrés (du moins c'est ce que je pense).

N'utiliser que les quaternions ne me pose pas de problème, mais comme mes angles sont correctements définis en utilisant gluLookAt, j'essaie d'obtenir le même comportement avec les quaternions, ce que je n'arrive pas à avoir dans la situation actuelle.

J'essaie de jouer avec le Quaternion d'intialisation (save dans le code ci-dessus), mais pas moyen d'avoir exactement le comportement d'un gluLookAt avec roll=0. Je dois probablement rater quelque chose mais ou ?

Merci d'avance de vos réponses

@++

[stardeath]

oui tu peux faire du 1 pour 1.

puisque quand je regarde en haut et j'avance, ca me fait descendre

heu ça, ça a pas l'air d'être la faute au quaternion, mais plutôt dans la récupération du repère associé.

ta classe Quaternion, elle est défini comment?