Discussion :

[Houlala]

Bonjour à tous,

J'ai un soucis sur un calcul de maths (et de vecteurs) ^^. Je m'explique :

J'ai les coordonnées des 3 points d'un triangle quelconque. Je connais sa normale. Le but du jeu est de, en fonction de la normale au triangle, trouver les angles de rotations pour qu'un carré, soit coplanaire (confondu ou non) au triangle.
En gros, le carré doit représenter le plan qui passe par les 3 points.

Pour le moment en fait, j'ai ça :

- Point P(xp, yp, zp), barycentre du triangle
- Normale N(xn, yn, zn), normale au triangle

- angle en x = arccos(xn) * 180.0 / PI
- angle en y = arccos(yn) * 180.0 / PI
- angle en z = arccos(zn) * 180.0 / PI

Donc lors de l'affichage de mon carré, je fais ceci :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
glPushMatrix();
	glRotatef(x, 1, 0, 0);
	glRotatef(y, 0, 1, 0);
	glRotatef(z, 0, 0, 1);
	glTranslatef(xg, yg, zg);
 
	glBegin(GL_QUADS);
		glVertex3f(-1, 0, -1);
		glVertex3f(+1, 0, -1);
		glVertex3f(+1, 0, +1);
		glVertex3f(-1, 0, +1);
	glEnd();
glPopMatrix();

Le problème c'est que ça coincide pas toujours avec mon triangle ^^'.
J'ai regardé du coté des angles d'Euler et des quaternions mais j'ai pas trouvé de solutions, ou mal cherché peut-être.

Si vous aviez une solution au problème, je vous remercie grandement ^^.
Merci à tous.

[Laurent Gomila]

Je pense que le plus simple sera d'utiliser le repère définissant ton plan, défini par :
- La normale à ton plan
- Un vecteur quelconque non nul appartenant à ton plan (par exemple un côté du triangle)
- Le produit vectoriel des deux précédents

Ensuite tu peux par exemple construire une matrice à l'aide de ces 3 vecteurs (un dans chaque colonne, la position souhaitée dans la 4ème), l'envoyer en tant que matrice model-view, puis dessiner ton cube comme tu le fais.

[Houlala]

Ok je vois le truc mais j'arrive pas à le mettre en place...

J'ai :
- vecteur t, translation pour se placer au barycentre
- vecteur u (coté du triangle) normalisé.
- vecteur n, normale au triangle

Je fais :
- v = u ^ n
- normalisation de v
- construction de la matrice (transposée, car openGL fonctionne avec des matrices ligne il me semble)

Donc en gros, à la fin j'ai un m[4][4]

Code :

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

1
2
3
4
| nx ny nz 0 |
| ux uy uz 0 |
| vx vy vz 0 |
| tx ty tz 1 |

Et je fais

Code :

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

1
2
3
4
5
6
7
8
9
10
11
glPushMatrix();
	glMatrixMode(GL_MODELVIEW);
	glMultMatrixf(&m[0][0]);
 
	glBegin(GL_QUADS);
		glVertex3f(-1, 0, -1);
		glVertex3f(+1, 0, -1);
		glVertex3f(+1, 0, +1);
		glVertex3f(-1, 0, +1);
	glEnd();
glPopMatrix();

Mais aucune transformation ne se fait...

[Laurent Gomila]

Tu devrais placer glMatrixMode(GL_MODELVIEW); en premier, parce que là tu ne sais pas quelle matrice tu sauvegarde avec glPushMatrix(). En revanche c'est la matrice model-view qui est restaurée avec glPopMatrix().

Ensuite utilise plutôt glLoadMatrix, à moins que tu saches ce qui se trouve dans la matrice model-view à ce moment.

[Houlala]

J'ai remonté le glMatrixMode et je suis reparti d'un exemple simple.

Seulement, toujours le même problème... Je vois pas où est l'erreur
Je mets mon code, on ne sait jamais ^^

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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
typedef float point[3];
typedef float vecteur[3];
 
point triangle[3];
vecteur normale;
float m[4][4];
 
 
void vnormaliser(vecteur _v)
{
	float n;
 
	n = _v[0] * _v[0] + _v[1] * _v[1] + _v[2] * _v[2];
 
	if(n > 0.0000001)
	{
		n = sqrtf(n);
		_v[0] /= n;
		_v[1] /= n;
		_v[2] /= n;
	}
}
 
 
void vvectoriel(vecteur _v1, vecteur _v2, vecteur _vr)
{	
	_vr[0] = _v1[1] * _v2[2] - _v1[2] * _v2[1];
	_vr[1] = _v1[2] * _v2[0] - _v1[0] * _v2[2];
	_vr[2] = _v1[0] * _v2[1] - _v1[1] * _v2[0];
}
 
 
void vcalcul(point _p1, point _p2, vecteur _u)
{
	_u[0] = _p2[0] - _p1[0];
	_u[1] = _p2[1] - _p1[1];
	_u[2] = _p2[2] - _p1[2];
}
 
 
void vmatrice4x4(vecteur _v1, vecteur _v2, vecteur _v3, float _m[4][4])
{
	int i;
	for(i = 0; i < 16; i++)
		*(_m[0] + i) = (i % 5 == 0);
 
	for(i = 0; i < 3; i++)
	{
		_m[0][i] = _v1[i];
		_m[1][i] = _v2[i];
		_m[2][i] = _v3[i];
	}
}
 
 
void affichageGL()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	gluLookAt(0, 1, 2, 0, 0, 0, 0, 1, 0);
 
	glColor3f(0.8, 0.5, 0.5);
	glBegin(GL_TRIANGLES);
		glVertex3fv(triangle[0]);
		glVertex3fv(triangle[1]);
		glVertex3fv(triangle[2]);
	glEnd();		
 
 
	glPushMatrix();
		glMultMatrixf(&m[0][0]);
		glColor3f(0.5, 0.5, 0.8);
		glBegin(GL_QUADS);
			glVertex3f(-1, 0, -1);
			glVertex3f( 1, 0, -1);
			glVertex3f( 1, 0,  1);
			glVertex3f(-1, 0,  1);	
		glEnd();
	glPopMatrix();    
	glutSwapBuffers();
}
 
 
void redimGL(int _w, int _h)
{
	glViewport(0, 0, _w, _h);
 
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
 
	gluPerspective(60, (GLfloat)_w/(GLfloat)_h, 0.1, 128.0);
 
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	gluLookAt(0, 1, 2, 0, 0, 0, 0, 1, 0);
}
 
 
void clavierGL(unsigned char _k, int _x, int _y)
{
	vecteur u, v, r;
 
	switch(_k)
	{
		case 'a' : 
			triangle[0][2] -= 0.1;
			break;
 
		case 'q' : 
			triangle[0][2] += 0.1;
			break;
 
		case 27 : 
			exit(0);
			break;
	}
 
	vcalcul(triangle[0], triangle[1], u);
	vnormaliser(u);
 
	vcalcul(triangle[0], triangle[2], v);	
	vnormaliser(v);	
 
	vvectoriel(u, v, normale);
	vnormaliser(normale);
 
	vvectoriel(u, normale, r);
	vnormaliser(r);
 
	vmatrice4x4(u, normale, r, m);
	glutPostRedisplay();	
}
 
 
void initGL()
{
	int i;
 
	glClearColor(0.5, 0.5, 0.5, 1.0);
 
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);
 
	triangle[0][0] = 0;
	triangle[0][1] = 0.5;
	triangle[0][2] = 0;
	triangle[1][0] = -0.5;
	triangle[1][1] = -0.5;
	triangle[1][2] = 0;
	triangle[2][0] = 0.5;
	triangle[2][1] = -0.5;
	triangle[2][2] = 0;
 
	normale[0] = 0;
	normale[1] = 0;
	normale[2] = 1;
 
	for(i = 0; i < 16; i++)
		*(m[0] + i) = (i % 5 == 0);
}
 
 
int main(int _argc, char ** _argv)
{
	int win_x, win_y;
	glutInit(&_argc, _argv);
 
	win_x = (glutGet(GLUT_SCREEN_WIDTH)  - 500)/2;
	win_y = (glutGet(GLUT_SCREEN_HEIGHT) - 500)/2;
 
	glutInitWindowSize(500, 500);
	glutInitWindowPosition(win_x, win_y);
	glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
	glutCreateWindow("Test orientation");
 
	glutDisplayFunc(affichageGL);
	glutReshapeFunc(redimGL);
	glutKeyboardFunc(clavierGL);
 
	initGL();
 
	glutMainLoop();
 
	return 0;
}

En fait, je viens de me rendre compte d'un autre problème. Mon carré est dans le plan XZ, ce qui n'est pas forcémment le cas de mon triangle... Encore un problème de plus -__-

[Houlala]

Bon, j'ai finalement réussi à trouver ce qui clochait...

Dans la gestion du trackball Gtk (que j'utilise), y a une variable qui s'apelle m, meme nom que ma matrice de rotation... Ah tiens...

Donc voilà, j'ai résolu le problème ^^
Merci beaucoup de ton aide en tout cas, ca m'a vraiment servi