Discussion :

[angioedema]

Bonjour,

J'essaie de faire une rotation autour des axes, mais sans changement de ceux-ci. En gros sur la figure au dessous, je souhaiterais tourner autour des axes en bleus sans changement et mouvement des axes comme c'est le cas en rouge.



Cette image est issue de ce forum : http://gamedev.stackexchange.com/que...und-fixed-axis . J'ai adapté le code (qui marche normalement) en C++ et ça ne donne pas grand chose ...

Pour avancer, je pensais afficher mes axes, pour vérifier le comportement actuel. Ma caméra est en postions 0,0,0. Seulement, le code suivant ne marche pas pour une origine en 0,0,0 ; je n'ai aucun problème pour une origine en 0.1,0.1,0.1 mais mes axes ne sont donc pas centré sur ma caméra. Est ce normal que je n'ai rien pour une origine 0,0,0 ? Je tiens à préciser que j'affiche un cube de -1 a 1 pour chaque face, je me retrouve donc dans le cube, à priori au centre, et je n'ai aucun problème d'affichage dans ce cas là. Voici le code des axes :

L'initialisation

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
98
99
100
101
102
103
 
            m_vertices[0] = 0.0;//0.1f; 0.0 ne marche pas, par contre 0.1 sans problème (sauf qu'il ne se trouve pas où je le souhaite ....)
            m_vertices[1] = 0.0;//0.1f;
            m_vertices[2] = 0.0;//0.1f;
 
            m_vertices[3] = 0.9f;
            m_vertices[4] = 0.0f;
            m_vertices[5] = 0.0f;
 
            m_vertices[6] = 0.0f;
            m_vertices[7] = 0.9f;
            m_vertices[8] = 0.0f;
 
            m_vertices[9] = 0.0f;
            m_vertices[10] = 0.0f;
            m_vertices[11] = 0.9f;
 
            m_vertices[12] = -1.0f;
            m_vertices[13] = 0.0f;
            m_vertices[14] = 0.0f;
 
            m_vertices[15] = 0.0f;
            m_vertices[16] = -1.0f;
            m_vertices[17] = 0.0f;
 
            m_vertices[18] = 0.0f;
            m_vertices[19] = 0.0f;
            m_vertices[20] = -1.0f;
 
 
 
            m_colors[0] = 1.0f;
            m_colors[1] = 1.0f;
            m_colors[2] = 1.0f;
 
            m_colors[3] = 1.0f;
            m_colors[4] = 0.0f;
            m_colors[5] = 0.0f;
 
            m_colors[6] = 0.0f;
            m_colors[7] = 1.0f;
            m_colors[8] = 0.0f;
 
            m_colors[9] = 0.0f;
            m_colors[10] = 0.0f;
            m_colors[11] = 1.0f;
 
            m_colors[12] = 1.0f;
            m_colors[13] = 0.0f;
            m_colors[14] = 0.0f;
 
            m_colors[15] = 0.0f;
            m_colors[16] = 1.0f;
            m_colors[17] = 0.0f;
 
            m_colors[18] = 0.0f;
            m_colors[19] = 0.0f;
            m_colors[20] = 1.0f;
 
 
 
            m_vboIndexVertex[0] = 0;
            m_vboIndexVertex[1] = 1;
 
            m_vboIndexVertex[2] = 0;
            m_vboIndexVertex[3] = 2;
 
 
            m_vboIndexVertex[4] = 0;
            m_vboIndexVertex[5] = 3;
 
            m_vboIndexVertex[6] = 0;
            m_vboIndexVertex[7] = 4;
 
            m_vboIndexVertex[8] = 0;
            m_vboIndexVertex[9] = 5;
 
            m_vboIndexVertex[10] = 0;
            m_vboIndexVertex[11] = 6;
 
 
 
            glGenVertexArrays(1, &m_vao);
 
            glBindVertexArray(m_vao);
 
            glGenBuffers(3, m_vbo);
 
            glBindBuffer(GL_ARRAY_BUFFER, m_vbo[0]);
            glBufferData(GL_ARRAY_BUFFER, sizeof(m_vertices) * sizeof(GLfloat), m_vertices, GL_STATIC_DRAW);
            glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
            glEnableVertexAttribArray(0);
 
            glBindBuffer(GL_ARRAY_BUFFER, m_vbo[1]);
            glBufferData(GL_ARRAY_BUFFER, sizeof(m_colors) * sizeof(GLfloat), m_colors, GL_STATIC_DRAW);
            glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
            glEnableVertexAttribArray(1);
 
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_vbo[2]);
            glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(m_vboIndexVertex) * sizeof(GLuint), m_vboIndexVertex, GL_STATIC_DRAW);
 
            program->bindAttributeLocation("a_position", 0);
            program->bindAttributeLocation("a_color", 1);

le render:

Code :

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

1
2
3
 
glBindVertexArray(m_vao);
    glDrawElements(GL_LINES, 12, GL_UNSIGNED_INT, 0);

Cette architecture est identique au cube qui fonctionne.

Pour la rotation j'ai fait ce type de code pour chaque axe (ici x), valeur changé avec un curseur Qt, comme beaucoup d'exemple Qt:

Code :

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

1
2
3
4
5
6
7
 
       m_transformation.setToIdentity();
        m_xAngle = float(angle);
 
        m_transformation.rotate(m_xAngle, 1.0, 0.0, 0.0);
        m_transformation.rotate(m_yAngle, 0.0, 1.0, 0.0);
        m_transformation.rotate(m_zAngle, 0.0, 0.0, 1.0);

Et l'idée était de pouvoir bouger avec seulement la souris j'ai donc fait ceci et modifié le code précédent comme suivant :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
       QMatrix4x4 tempTransformation;
        tempTransformation.setToIdentity();
        //m_transformation.setToIdentity();
        m_xAngle = float(angle);
 
        tempTransformation.rotate(m_xAngle, 1.0, 0.0, 0.0);
        tempTransformation.rotate(m_yAngle, 0.0, 1.0, 0.0);
        tempTransformation.rotate(m_zAngle, 0.0, 0.0, 1.0);
        //tempTransformation= tempTransformation.transposed();
 
        m_transformation = m_transformation * tempTransformation;

avec pour méthode de gestion de la souris :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
    int dx = event->x() - m_lastClick->x();
    int dy = event->y() - m_lastClick->y();
 
    dx = dx * 0.01;//scale factor
    dy = dy * 0.01;
 
    setXRotation(dy);
    setYRotation(dx);
 
    m_lastClick->setX(event->x());
    m_lastClick->setY(event->y());

Seulement je n'obtiens pas ce que je souhaite...

Si vous avez des idées sur ces deux problèmes Merci !

[monwarez]

Ce qu'il faut avoir bien en tête c'est que les transformations de l'espace ne sont pas commutative, et donc l'ordre des rotations sont importantes. Ce que tu fais actuellement est la méthode des angles d'Euler, reste à vérifier que tu multiplie tes matrices dans le bon ordre. http://jeux.developpez.com/faq/math/...formations#Q35. Une autre méthode serait d'utiliser les quaternions pour effectuer la transformation, puis de convertir ces dernier en matrice.
Petite note pratique: penser transformation comme un changement de repère
Par rapport au deuxième problème, tu devrais penser aux système de coordonnées sphérique: rayon, theta, phi , avec le rayon égal à 1

[quentinb56]

Sauf erreur de ma part tu n'initialises pas la position, l'angle, et fear & near de ta caméra.

gluLookAt (ex, ey, ez, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

[angioedema]

Merci pour vos réponse. Il est vrai que je n'ai pas précisé, je ne travaille pas avec glu (donc pas de lookAt même si je crois avoir un équivalent sur les objet matrice Qt, mais ce n'était pas concluant).

Du coup si je comprends bien, si je ne veux pas de changement de repère, la méthode d'Euler (ou Quaternion) est à oublier ? Du coup, je dois passer sur du polaire (sphérique), j'avoue avoir un peu de mal dans ce système là :S Vous auriez des exemple de conseil de lecture, des exemples éventuellement d'une gestion OpenGL assez équivalente ?

Merci encore

[monwarez]

Le problème est que je ne vois pas comment tu veux effectuer des transformations sans changer le repère.

Mathématiquement: tu as un cube avec 24 sommets, pour effectuer un transformations t , tu fais t(s) pour chaque sommets. Pour connaitre t, il faut savoir l'image d'un repère affine de R³ par t.
Un repère affine(canonique) de R³ est ((0,0,0),(1,0,0),(0,1,0),(0,0,1)), si la transformation est bijective, elle envoie un repère affine sur un repère affine. On va supposer que la transformation est bijective, donc dans ce cas,
si l'image du repère est le même, la transformation est l’identité. Et donc la seule transformation qui conserve le repère est l'identité. Morale : après transformations, les axes changent, donc il faut y penser.
Une dernière chose, les transformations ne sont pas commutatives en général, donc faire une rotation suivie d'une translation est différend de faire une translation suivie d'une rotation en général.

Quelle méthode utilise tu pour générer la matrice de projection ?

[dragonjoker59]

Salut!

C'est quoi cette histoire de ne pas changer de repère?
Lorsque tu appliques une matrice de transformation à un objet, le repère local de l'objet change automatiquement.
Par contre le repère de ta caméra (par exemple) n'est pas modifié.

Peux-tu donc expliciter ce que tu entends par "ne pas changer de repère"?

[angioedema]

Merci pour vos réponses. Alors pour les transformations non communicative, pas de soucis là dessus ^^

Je pense avoir compris mon erreur, le repère change quoi qu'il arrive. Idéalement je souhaiterais implémenter la souris comme dans un jeux vidéo, avec le changement de regard sans limitation en x et en y (en gros notre tête n'est pas limité dans les axes). Je pensais donc qu'il fallait agir sur la matrice mvp, dont le code est ici :

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
 
void OpenGLView::initialize()
{
...
m_projection.perspective(60.0, float(this->size().width())/float(this->size().height()), 0.1, 100.0);
...
}
 
void OpenGLView::render()
{
...
QMatrix4x4 mvp = m_projection * m_transformation;
mvp.transposed();
m_program->setUniformValue(m_projectionUniform, mvp);
 
myObject->render();
....
}

Or si je comprends bien, il faudrait appliquer la transformation seulement au cube (chose qui semble logique) ? Toutefois, ça implique qu'à chaque render, je suis obligée de recalculer et d'envoyer les coordonnées des vertex... Pour un simple cube, ce n'est pas le problème mais pour une scène complexe, faut il faire de même (chose qui me semble lourde) ? Si non, comment dois je m'y prendre ?

[dragonjoker59]

Si tu veux implémenter une caméra de n'importe quel type, tes transformations doivent s'appliquer à la caméra, pas aux objets.

[monwarez]

La méthode que j'utilise pour la caméra consiste à d'abord définir la position et la cible de la caméra, pour la cible j'utilise les coordonnées sphériques.
Au niveau des matrices je fais:projection * camera * model. Projection et camera me sont donné à l'aide de glm.
Quelque extraits de code

Code :

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

1
2
3
4
5
6
7
8
9
10
 
input.UpdateEvent();
camera.KeyBoardEvent(input);    
camera.Move(input,elapsed);
unsigned int begin = SDL_GetTicks();
// do graphical stuff
// do animation 
engine.SetCameraLocation(camera.GetPosition(),camera.GetTarget(),config.up);
engine.Init();
engine.Draw(totalTime);

SetCameraLocation va générer la matrice de la caméra
Extrait de la boucle de rendu de engine.Draw

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
glm::mat4    mvp;
objectNode.DoTransformation(mvp);
/ Send to OpenGL the modelview before apply camera transformation and after object transformation
glUniformMatrix4fv(modelviewloc, 1, GL_FALSE, glm::value_ptr(mvp));
mvp    =    m_projection * m_modelview * mvp;
// send to OpenGL
glUniformMatrix4fv(mvpLocation, 1, GL_FALSE, glm::value_ptr(mvp));
// send material
m_pShader->SetMatSpecularIntensity(1.0);
m_pShader->SetMatSpecularPower(2);
// then draw it
objectNode.object->Draw(elapsed, m_pShader,objectNode.animation);

Pour l'orientation tu peux essayer ceci en supposant que l'axe vertical est Z

Code :

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

1
2
3
4
5
6
7
8
 
m_phi               +=  -yRel * m_sensitive;
m_theta             +=  -xRel * m_sensitive;
// phiRad, thetaRad c'est m_phi et m_theta convertis en rad
m_orientation.x         =   cos(phiRad)*cos(thetaRad);
m_orientation.y         =   cos(phiRad)*sin(thetaRad);
m_orientation.z         =   sin(phiRad);
m_target = m_position + m_orientation;

[angioedema]

Ok. Dans ce cas, j'ai du mal procéder pour avoir cette effet avec la souris. Que dois faire ? Quel est la méthode la plus adapté et juste ?

[monwarez]

Si tu veux obtenir une rotation qui dépend du mouvement de la souris, lorsque tu fait dx = event->x() - m_lastClick->x();, tu obtiens un déplacement relatif de la souris, donc quand tu fais setXRotation(dy); tu auras une petite rotation qui dépend du mouvement relatif.
Après je ne sais pas si tu accumules les produits matriciel avec setXRotation, si c'est le cas à cause des erreurs d'arrondis, la matrice finale n'est plus une matrice de rotation,c'est pourquoi il est préférable d'incrémenter les angles relatifs et d'effectuer le calcul matriciels en une seule fois. Dans l'autre cas, si tu n'accumulais pas les calculs matriciel, tu devais avoir comme résultat un blocage dans l'orientation.

[angioedema]

Actuellement j'ai ça :

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
 
void OpenGLView::mouseMoveEvent(QMouseEvent* event)
{
    int dx = event->x() - m_lastClick->x();
    int dy = event->y() - m_lastClick->y();
 
    dx = dx * 0.01;//scale factor
    dy = dy * 0.01;
 
    setXRotation(dy);
    setYRotation(dx);
 
    m_lastClick->setX(event->x());
    m_lastClick->setY(event->y());
}
 
void OpenGLView::setXRotation(int angle){
 
    if(m_xAngle != angle)
    {
        m_transformation.setToIdentity();
        m_xAngle = float(angle);
 
        m_transformation.rotate(m_xAngle, 1.0, 0.0, 0.0);
        m_transformation.rotate(m_yAngle, 0.0, 1.0, 0.0);
        m_transformation.rotate(m_zAngle, 0.0, 0.0, 1.0);
    }
}

La méthode est identique pour setY et setZ. Normalement la QMatrix4x4 fait la rotation selon l'axe donné. Il est vrai que je fais la rotation de chaque axe les un après les autres, mais normalement ça devrait revenir au même, non ?

[monwarez]

Ton problème vient du fait que tu donne un angle relatif, tu devrais plutôt incrémenter l'angle au lieu de le changer par l'angle relatif

[angioedema]

l'incrémenter via un slider, je vois, par contre avec la souris je ne comprends pas trop l'idée.... Serait ce quelque chose comme ça :
- je prends la différence entre ma position à t-1 et à t (t étant maintenant)
- je calcule l'angle entre ma caméra fixe, t-1 et ma caméra fixe, t
- j'ajoute cet angle à celui calculer à t-1
- je mets à jours mes matrices (comme en dessous) avec un rotate sur chaque axe

Le problème est que je ne vois pas comment différencié le calcul sur x et y (voir z), ma trigo remonte pour le coup...

[fifafou]

Salut
Je ne sait pas si j'ai compris le problème mais soit tu veut faire une camera freefly,pour le deplacement d'un personnage par exemple, ou alors comme dans un jeu d'avion ou la camera tourne en fonction de son regard
premier cas il faut definir deux angles phi et theta et la distance r pour les coordonnées sphériques et le convertir en vecteur comme ceci:
if (phi > 1.5)
phi = 1.5;
else if (phi < -1.5)
phi = -1.5;
double r_temp = cos(phi);
zv = sin(phi)/10;
xv = r_temp*cos(theta)*r;
yv = r_temp*sin(theta)*r;
(+limitation d'angle)
deuxième cas
il est expliqué à http://jeux.developpez.com/faq/math/...ransformations mais je n'ai pas tout compris

[angioedema]

Désolé pour le retard, j'ai bien vu vos postes, j'ai du reporter cette tache je n'ai donc pas avancé. Je reviendrais dès que ce sera le cas, merci beaucoup pour vos réponses en tout cas !!