Gestion du clavier

Version imprimable

Gestion du clavier

Salut,
J’ai un problème avec les interuption glut :^/
J’aimerai pouvoir me déplacer dans ma scène 3d. Pour cela, un simple « glTranslatef » suffi seulement, quel interuption utiliser ? Si j’utilise glutKeyboardFunc, le déplacement n’est pas celui souété car il faut attendre un certain moment avec la touche enfoncé avent que la fonction ce lance en boucle.
Une solution sous glu été d’utiliser les interruptions WM_KEYDOWN et WM_KEYUP dans WindowProc pour détecter l’appuie et le relâchement. Seulement, je ne croi pas qu’il existe un équivalent d’une interruption de relâchement d’une touche sous glut :^/
Dans un ancien poste, shenron666 m’avait dit que glu et glut pouvaient fonctionner ensemble ce que d’ailleurs je fais. Mais es qu’il est aussi possible d’utilier en meme temps des interuption de glu et glut dans le meme programme ? car je n’ai pas reussi a faire cela :^/
Ou bien si cela n’est pas possible existe-t-il un sollution a mon problème ?

Merci

Code actuelle :
Code:

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 int main(int argc,char **argv) { glutInit(&argc,argv); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); glutInitWindowPosition(200,200); glutInitWindowSize(640,480); glutCreateWindow("window"); // Initialisation d'OpenGL glClearColor(0.0,0.0,0.0,0.0); glColor3f(1.0,1.0,1.0); glEnable(GL_DEPTH_TEST); // enregistrement des fonctions de rappel glutReshapeFunc(Reshape); glutDisplayFunc(Draw); glutKeyboardFunc(GestionClavier); // Entree dans la boucle principale glut glutMainLoop(); return 0; } void GestionClavier(unsigned char key, int x, int y) { If (key == ‘z’) y++ ; }

10/08/2005, 16h38
Djakisback

Salut, jette un coup d'oeil dans la doc à glutSetKeyRepeat(GLUT_KEY_REPEAT_OFF); je crois que ca peut t'aider.
Sans oublier de le remettre à on avant de quitter.
10/08/2005, 16h40
Djakisback

C'est l'inverse faut le mettre à on et ensuite le remettre à off.
11/08/2005, 09h45
Ekinoks

Ok, merci pour tes réponses =) malheureusement, il y a encore un petit souci... avec cette solution, il est impossible de resté appuyé sur plusieurs touche a la foi... aurai tu une autre solution pour résoudre ce problème ?

Merci
11/08/2005, 10h29
shenron666

mauvaise solution à la base, tu ne dois pas réagir en fonction d'une touche qui reste appuyée, si tu regardes dans les tutoriaux sur le net, voici comment ils font :

tu as un buffer qui va contenir les infos dont tu as besoin, disons que tu veux les 4 directions, tu crées un
bool buffer[4] = {false}; // 0->3 = Haut-Bas-Gauche-Droite
ta fonction qui détecte l'appui sur les touches du clavier va modifier dans ce buffer le booléen qui correspond à la touche appuyée
il faut une fonction callback GestionClavier qui soit appelée lorsqu'une touche est appuyée et relachée
lorsque la touche haut sera appuyée, GestionClavier va faire buffer[0] = true;
et lorsque la touche Haut sera relachée, GestionClavier va remettre à false le booléen
dans ta boucle principale tu regardes quelles touches sont appuyées
11/08/2005, 10h54
Ekinoks

shenron666> Oui exactement, le probleme est justement la...
glut n'a pas, ou je n'ai pas vu en tout cas, d'événement qui correspond a la touche relâchée :’(
11/08/2005, 11h15
Ekinoks

Ha si ! Tien...
Il existe une fonction pour détecter le relâchement d'une touche :
- glutKeyboardUpFunc(...);
- glutSpecialUpFunc(...);
Je croyais quelle n'exister pas sur glut car la dernier foi j'avais passé plusieurs heur a chercher cette fonction et je ne l'avais pas trouvé.

Merci pour votre aide =)

glutKeyboardUpFunc :

Code:

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
bool bufferClavier[4] = {false};
 
int main(int argc,char **argv) 
{ 
  glutInit(&argc,argv); 
  glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); 
  glutInitWindowPosition(200,200); 
  glutInitWindowSize(640,480); 
  glutCreateWindow("window"); 
 
  // Initialisation d'OpenGL 
  glClearColor(0.0,0.0,0.0,0.0); 
  glColor3f(1.0,1.0,1.0); 
  glEnable(GL_DEPTH_TEST); 
 
  // enregistrement des fonctions de rappel 
  glutReshapeFunc(Reshape); 
  glutDisplayFunc(Draw); 
  glutKeyboardFunc(ClavierKeyPress); // callback touche appuyée
  glutKeyboardUpFunc(ClavierKeyRelease); // callback touche relachée
  // Entree dans la boucle principale glut 
  glutMainLoop(); 
  return 0; 
} 
 
void GestionClavier(unsigned char key, bool press) 
{ 
  If (key == ‘z’) 
    bufferClavier[0] = press; 
} 
 
void ClavierKeyPress(unsigned char key, int x, int y) 
{
  GestionClavier(key, true);
}
 
void ClavierKeyRelease(unsigned char key, int x, int y) 
{
  GestionClavier(key, false);
}

EDIT : tu as trouvé tout seul :P

11/08/2005, 11h46
Ekinoks
^^ oui, mais merci quand même pour cette exemple =)
Par contre j'ai une petite dergniere question...
Je suppose donc qu'il faudra mètre une fonction du tipe :
Code:

1 2 3 4 5 6 7 8 void deplacement(void) { if (bufferClavier[0] == 1) { translatx = translaty + 0.1; } }
et placer cette fonction dans l'événement glutDisplayFunc(...);
Seulement, dans se cas, la rapidité du processeur graphique influera sur la rapidité de déplacement non ?
Et suivent ou on se trouve dans la scène, si il y a beaucoup d'élément a afficher ou pas, la fréquence d'exécution de glutDisplayFunc(...); fluctuera, et la rapidité de déplacement fluctuera aussi... qu’en pense tu ?

Pour éviter que la vitesse de déplacement ne soit dépendante de la puissance de la machine, tu dois mesurer le temps avec des appels à GetTickCount() (sous Win32) qui va récupérer le temps en millisecondes écoulé depuis le lancement de windows

je te donne un exemple à la volée, c'est basique et il vaut mieux passer par une classe si ton programme devient complexe
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 void deplacement(void) { static DWORD lastTime = GetTickCount(); // un static qui conservera sa valeur après chaque appel DWORD newTime = GetTickCount(); // on récupère le temps actuel float moveFactor = (newTime - lastTime) / 1000.f; // on calcule un facteur basé sur le temps écoulé lastTime = newTime; // on mémorise le moment du dernier appel if (bufferClavier[0] == 1) { translatx = translaty + (1 * moveFactor); // on se déplace à 1 unité par seconde réelle } }

11/08/2005, 13h15
Ekinoks

Ok, merci pour l'astuce =)
22/08/2005, 14h34
bafman
et sous glut c'est
Code:

1 2 glutGet(GLUT_ELAPSED_TIME);
22/08/2005, 14h36
shenron666

Toujours bon à savoir
Thanks