Discussion :

[Sephi]

Hello,

Je me suis mis il y a peu de temps à OpenGL et j'ai un petit souci.
Mon but est de créer un rectangle qui, lors de l'appui sur une touche, se déplace à droite. J'ai procédé comme cela :

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
void PongDisplay()
{
	pong_x += 0.001;
	glutPostRedisplay();
}
 
void keyb(unsigned char key, int x, int y)
{
	switch(key)
	{
		case 97:
			glutIdleFunc(PongDisplay);
			break;
		default:
			glutIdleFunc(NULL);
			break;
	}
 
}

Mon rectangle se déplace bien vers la droite, cependant je n'arrive pas à l'arrêter ! Puisque la fonction du clavier ne permet pas de récupérer l'état de la touche... J'ai essayé en mettant le contenu de ma fonction PongDisplay sous le case 97 mais bien sûr c'est très lent et de plus ça saccade (puisque je dois augmenter l'intervalle de laquelle va avancer mon rectangle).
Voilà je voulais donc savoir comment arrêter le défilement de ce rectangle.
Merci !

[Viquel]

Tu devrais peut-être jeter un oeil à la fonction suivante:

Code :

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

void glutKeyboardFunc (void (*func)(unsigned char key, int x, int y));

ou alors:

Code :

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

void glutSpecialFunc (void (*func)(int key, int x, int y));

La dernière fonction te permettant de gérée les touches clavier qui n'ont pas de code ASCII (les flèches, F1, ...)

Plus d'info ici

Bonne chance.

[Sephi]

Hello,

J'utilise déjà la fonction glutKeyboardFunc pour gérer la frappe au clavier (glutKeyboardFunc(keyb) dans mon exemple) mais le problème est toujours là : je ne peux pas savoir quel est l'état de la touche !

[Sphax]

Salut,

ça fait un moment que j'ai pas utilisé glut mais si je me souviens bien tu as une fonction glutKeyboardUp ou qque chose comme ça qui te signale qu'une touche n'est plus appuyée.

[Viquel]

Bizarre... si je ne m'abuse glutKeyboardFunc ne renseigne key que si une touche est pressée.

Pour ton problème de saccade, c'est surement dû au fait que tu lances le raffraichissement seulement quand il y a une interaction au clavier.
Essaye de modifier la variable sur la position de ton rectangle quand tu appuie au clavier mais lance le rafraichissement toujours dans glutIdleFunc (que tu ne devrais pas appeler via l'intéraction du joueur).

Voila, bonne chance.
PS: Si tu as toujours des pb tu peux m'envoyer ton code, j'y jeterais un coup d'oeil.

[Sephi]

Ok c'est bon, il suffisait d'utiliser la fonction glutKeyboardUpFunc.
Merci à tous !

P.S.: Pour la fonction, voir ici http://pyopengl.sourceforge.net/documentation/manual/glutKeyboardUpFunc.3GLUT.html

[Sephi]

Tiens au fait, avant de mettre le topic comme résolu... Voici mon code, pourriez-vous me dire si c'est correct ou si c'est du bûcheronnage ?
En fait je fait un casse briques et j'aimerais savoir si je pars juste... Ou si j'aurai de la peine pour la suite si je commence comme ça ! Merci !

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
#include <stdio.h>
#include <GL/glut.h>
 
float pong_x = 0.0;
float pong_y = -0.8;
float go_x = 0.0;
 
void init()
{
	glClearColor(0.0, 0.0, 0.0, 0.0);
	glShadeModel(GL_FLAT);
}
 
void display()
{
	glClear(GL_COLOR_BUFFER_BIT);
 
	glBegin(GL_POLYGON);
		glVertex2f(pong_x, pong_y);
		glVertex2f(pong_x, pong_y+0.05);
		glVertex2f(pong_x + 0.2, pong_y + 0.05);
		glVertex2f(pong_x + 0.2, pong_y);
	glEnd();
 
	glutSwapBuffers();
}
 
void PongDisplay()
{
	pong_x += go_x;
	glutPostRedisplay();
}
 
void keyb(unsigned char key, int x, int y)
{
	switch(key)
	{
		case 'a':
			go_x = -0.001;
			glutIdleFunc(PongDisplay);
			break;
		case 'd':
			go_x = 0.001;
			glutIdleFunc(PongDisplay);
			break;
		default:
			glutIdleFunc(NULL);
			break;
	}
	printf("%d\n", key);
}
 
void keybup(unsigned char key, int x, int y)
{
	glutIdleFunc(NULL);
}
 
int main(int argc, char **argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
	glutInitWindowSize(300, 300);
	glutInitWindowPosition(100, 100);
	glutCreateWindow(argv[0]);
	init();
	glutDisplayFunc(display);
	glutKeyboardFunc(keyb);
	glutKeyboardUpFunc(keybup);
	glutMainLoop();
	return 0;
}

[bafman]

Salut,

Personnellement je te conseil d'afficher tes carré dans une display liste et de faire appel à ces display liste quand tu a besoin d'afficher un carré en utilisant des glTranslated() pour le placer, c'est bien plus rapide.

[sebhh]

Sa ne vaut pas le coup de faire une display list pour des petits éléments: on perd plus de temps en appel de la list qu'on en gagne en dessin.
C'est ce qui est dit dans le livre d'OpenGL.
(ya un appelle a glTranslate en plus alors juste pour un carré!!)
Sa reste à vérifier........

[Ti-R]

Une display list peu êre ou pas utilisé dans ton cas, et puis pour un casse brique c'est pas cela qui va tt faire rammer

Sinon je te conseil pas trop d'utiliser "glutIdleFunc" dans ce sens, si mes souvenirs sont bon, c'est la fonction qui est lancé dans les moments "libre" de ton programme et du CPU.

Donc si tu utilises glutIdleFunc(PongDisplay); et que tu appuyes sur la touche toto ton triangles va se déplacer a l'infini comme tu l'as deja constaté, à cela tu as trouvé la parade glutIdleFunc(NULL);

glutIdleFunc() qui contient en principe un pointeur de fonction dans laquelle on trouve glutPostRedisplay() permet l'affichage de ta scène.

Pour l'instant pas de problème tout marche sur des roulettes.
Mais si tu veux que ton carré s'anime de bas en haut (pour une option qui tombe), il faut que glutPostRedisplay() soit relancé regulièrement pour voir l'animation du cube "tomber", première solution tu appuyes sur une touche et "o" miracle tu vas voir l'animation, mais problème...

Bon je sais pas si c'est clair tout ce que je raconte.

En gros un petit changement serait le bienvenu je pense dans ton mini programme.

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
 
// dans main ajouter 
/* Main Loop */
void main_loop(void);
 
/* Start Main*/
int main(int argc, char **argv) 
{ 
...
// a ajouter
   glutIdleFunc(main_loop); 
...
   glutMainLoop();
}
 
//dans main loop
/* ------------------------- Main Loop ------------------------- */
 
void main_loop(void)
{
	glutPostRedisplay();
}
// beyb "simplifié"
void keyb(unsigned char key, int x, int y) 
{ 
   switch(key) 
   { 
      case 'a': {
         pong_x -= 0.001; 
         };break; 
      case 'd': {
         pong_x += 0.001; 
         };break; 
   } 
   printf("%d\n", key); 
}

C'est simplifié, et il y a beaucoup encore a faire, pour "détacher" l'objet qui tombe et le rendre + "static" ou le faire disparaitre
mais c'est un bon début et un bon sujet d'étude.

Have fun !!

[Sephi]

Ok je vais étudier tout ça et je vous en donnerai des nouvelles.
Merci pour toutes ces précieuses infos !