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"?