Discussion :

[Ekinoks]

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 :

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
 
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++ ;
}

[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.

[Djakisback]

C'est l'inverse faut le mettre à on et ensuite le remettre à off.

[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

[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

[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 :’(

[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 =)

[shenron666]

glutKeyboardUpFunc :

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

[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 :

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

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 ?

[shenron666]

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 :

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

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
    } 
}

[Ekinoks]

Ok, merci pour l'astuce =)

[bafman]

et sous glut c'est

Code :

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

1
2
 
glutGet(GLUT_ELAPSED_TIME);

[shenron666]

Toujours bon à savoir
Thanks