Discussion :

[Clad3]

Bonjour à tous ! Je dois pour ma fac faire un semblant de jeu, la bibliothèque GLUT m'étant imposée . Et j'avoue que étant habitué à la SDL j'en ai perdu mes marques et je n'arrive pas a recréer une boucle de jeu correcte .

J'aimerai avoir ceci :

Code :

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

1
2
3
4
5
6
7
8
 
//Init
 
// Boucle
// -> Update()
// -> Render()
 
// Close

En gros quelques chose qui me semble logique, d'abord j'initialise toute mes bibliothèque et mes données, ensuite je lance le jeu a proprement aparlé, et enfin je clean tout avant de quiter .

Avec glut et son sytème de callback je n'arrive pas à retomber sur ce genre de schéma.
Il ne m'a pas lair judicieux de placer la phase INIT, avant l'aplle a glutmainloop(), car openGL n'est pas initialisé avant, si ? ( j'ai cru voir que non avec quelques test ).

POur le moment je retrouve avec ca en gros dans mon main

Code :

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

1
2
3
4
5
6
 
    glutIdleFunc(Boucle);
 
    glutDisplayFunc(display);
 
    glutMainLoop();

Ma fonction display est simplement vide, je veux dessienr quand j'en ai envie dans mon prgoramme et non quand glut en a envie (surtout car comme ca, je suis sur de ce qui se apsse et je vois mieux comment mon prog marche)

Ma fonction boucle reprend l'idée d'une boucle de jeu.

Il manque toujours une pahse INIT et une pahse CLOSE ( que je veux à un endroit logique et de facons propre dans mon jeu ) [ pour le moment j'ai un horrible if i==0 (....) i++ dans ma boucle pour faire l'init . ]

Je supose que toute l'étape de cleaning va se faire en récupérant les input et/ou apuie sur la croix de la fenêtre , mais la encrore je trouve un peu déroutant ( ca n'engage que moi, je suis sur que c'est une tehcnbique tout à fait valable)

Vos avis, vos conseils seront les bienvenues.

[bafman]

ha mais non...
ce n'est pas comme ca qu'il faut faire avec glut en fait
déjà, pour l'initialisation, il faut utiliser la fonction qu'ils on judicieusement appelé glutInit
ensuite, il faut créer un context graphique. la tu a plusieur possibilité, perso, j'utilise le game mode qui permet de faire du fullscreen.
après, tu lui donne les pointeurs de fonction vers la fonction d'affichage, de gestion du clavier et autre. ce sont des callback, elle sont donc appelée par la boucle principale de glut (donc tu ne doit SURTOUT PAS faire toi même la boucle de rendu)
ensuite, tu lance la boucle principale de glut qui va appeler les callback, et pour quitter, il faut faire un petit glutExitGameMode() (ou glutLeaveGameMode, sait plus).
en gros, voila une init standard de glut :

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
 
void main(int argc,char** argv)
{
    glutInit(&argc,argv);
 
    glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH);
    glutGameModeString("1024x768:32@85");
    glutEnterGameMode();
 
    glutDisplayFunc(dessin);
    glutIdleFunc(programme);
    glutMouseFunc(souris);
    glutKeyboardFunc(clavier);
    glutReshapeFunc(reshapeWindow);
 
    glutMainLoop();
}

[Clad3]

Merci, je répond un peu tardivement, désolé .

Cette histoire de GameMode ne semble se justifier que lorsque l'on veux faire du plein ecran visiblement . Je peux m'en passer ( d'ailleur rien dans mon projet ne requiert ud plein écran a tout prix ) .

Je compile avec une console, et j'ai un comportement que je n'explique pas :
Quand j'exécute mon prog, il mouvre ma fenetre et la console : trés bien. Par contre, lorsque je ferme la fenêtre, glut continue de passer dans ma fonction Idle, et je suis obligé de fermé la fenetre pour qu'il quite enfin mon rpogramme . Y-a-til moyen de faire en sorte que le programme quite lorsque je ferme ma fentetre et non ma fentre puis ma console ? ( ca me permettrai de voir des affichage de données en fin de prog par exemple, sans apsser par un fichier ou autre)

Concernant la logique Init , Boucle, Fin ...c'est encore flou.

J'ai mis un atexit(...) pour spécifier une fonciton de fin, mais ca force a déclarer des chose en globale a priori si je veux libérer correctement toute mes données, ca va induire un design moins propre que prévu (je n'ai pas approfndi la chose, mais je le vois comme ca).

Pour l'initilisation, openGL n'est initialisé qu'a son entrée dans le main loop ou pas ? Si oui, je ne vois pas ou faire une init de mon programme ( comme l'init de devIL par ex ). Sinon, pas de problème, je mettrai une fonciton init() avant le mainloop.

Pour la boucle, la je suis perdu.
Quand est-ce que glut va refaire un affichage? Quand ca lui chante? Toutes les x ms ? Quand j'apelle une certaine fonction? [ je compte travailler en double buffer ] Et dans ce cas, ma routine de mise a jour du prog, je la met ou? Dans Idle ?
: lost :

[bafman]

va voir ici : http://tbayart.developpez.com/articl...enetrage/glut/
tu aura plus d'explications.

[Clad3]

Merci du lien, j'ai appris un deux trucs et avec les conseils d'un prof j'en suis arrivé a cela ( mais il y a encore des problèmes):

Mon initilisation se fera juste avant l'apel à GlutMainLoop(), comme ca pas de problème, mon context openGL est pret et je devrai pouvoir tout initialiser tranquilement .

Ma boucle sera dans Idle et mon affichage dans DIsplay.

Le problème est ma fonction atexit().
Je Ferme la fenêtre openGl, ce qui n'arrete en rien glut ( et ca j'aimerai bien ....), et donc je me retrouve juste avec ma console et mes callback glut saans affichage, bon soit ! Ensuite je veux fermer la fenêtre et la malheurn la prog plante ... sauf si ma fonciton atexit() est vide!

Cette fonction qui plante est consistué simplement d'un apelle a std::cout pour le moment et elle ne plante que avec glut ( si je commente de mainloop ), tout va bien .

Une idée?

edit : ca ca compile et ca sexécute ...

void Fermeture()
{
/*std::cout << "Phase de fermeture du programme commence ..." << std::endl;

std::cout << "Fin le la phase de fermeture du programme ..." << std::endl ;*/
printf("lol");
}

J'aurais dit que la cosole se fermait avant le std::cout et que ca merdait a ce niveau, mais si le printf passe .... je sais pas

[fearyourself]

Il faudrait avoir un code minimal qui provoque ce problème. A mon avis, à la fermeture du programme, tu dois faire quelque chose d'incorrect.

Jc

[bafman]

si tu utilise freeglut, tu peut utiliser la fonction glutLeaveMainLoop au lieu de quitter avec exit. comme ca, il te suffit de mettre le code de terminaison du programme après l'appel a glutMainLoop pour avoir u truc plus propre. Malheureusement, ca n'existe que sous freeglut et pas sous la glut standard

[Clad3]

Je doit utiliser glut et rien d'autre, donc pas de freeglut possible.

Voilà un code minimal qui devrai reproduire le pb :

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
 
#include <windows.h>
#include <GL/glut.h>
#include <iostream>
 
void Display(void)
{
 
}
 
void Reshape(int w, int h)
{
    glViewport(0,0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0, w, 0, h);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glClear(GL_COLOR_BUFFER_BIT);
}
 
void Boucle()
{
 
}
 
void Fermeture()
{
	std::cout <<"bug" <<std::endl;
}
 
int main(int argc, char **argv)
{ 
	atexit(Fermeture);
 
    glutInit(&argc, argv);
 
    glutInitDisplayMode (GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
 
    glutInitWindowSize(1024,768);
 
    glutCreateWindow("Test");
 
    glutReshapeFunc(Reshape);
 
    glutPositionWindow(5, 25); 
 
	glutIdleFunc(Boucle);
 
    glutDisplayFunc(Display);
 
    glutMainLoop();
 
    return 1;
}

Pour linstant, je me suis résolu a ne pas faire de "cout" pendant ma pahse de destruction.

[shenron666]

si j'ai bien compris tu veux exécuter du code après avoir quitté le programme ou plutot lorsque l'utilisateur a provoqué la fermeture de la fenêtre GLUT

si je reprend le code source du tuto sur le fenêtrage GLUT et que j'y ajoute un atexit(Fermeture) avec

Code :

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

1
2
3
4
void Fermeture(void)
{
    std::cout << "Fermeture" << std::endl;
}

je n'ai pas de plantage et le texte apparait bien dans la console

si tu es sous windows, assures toi d'avoir la bonne version de bibliothèque GLUT par rapport à la DLL
assures toi aussi que ton fichier de lien soit compatible avec ton compilateur

[fearyourself]

je n'ai pas de plantage et le texte apparait bien dans la console

Moi non plus (avec ton code Clad3)
Jc

[Clad3]

Bon, je vais rechercher les dernièers version de re-tester alros, merci !
Je vous tient au courant.