[B]Pour le premier[/B], je voudrais, au milieu d'un programme, affiché mon image et qu'ensuite le programme continu.
J'utilise ce code (test est la structure ou toutes les info sont stockées):
[U]Main:[/U]
/************************************* Initialization OpenGL ***************************************/
/* Initialize GLUT state - glut will take any command line arguments
that pertain to it or X Windows */
glutInit(&argc, argv);
/* Select type of Display mode: Single buffer, RGB color*/
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
/***************************************************************************************************/
Chargement de l'image
/******************* Display the image thanks to OpenGL *************************/
glutInitWindowSize(test.Largeur(), test.Hauteur());
/* the window starts at the upper left corner of the screen */
glutInitWindowPosition(0,0);
/* Open a window */
window1 = glutCreateWindow(test.GetNom());
/* Initialize our window. */
InitGL();
/* Register the function to do all our OpenGL drawing. */
glutDisplayFunc(&DrawScene);
/* Start Event Processing Engine */
glutMainLoop();
/***************************************************************************/
[U]Fonction drawscene:[/U]
/* The main drawing function. */
void DrawScene(){
// Clear The Screen
glClear(GL_COLOR_BUFFER_BIT);
glDrawPixels( test.Hauteur(), test.Largeur(), GL_LUMINANCE, GL_UNSIGNED_BYTE, test.GetImage() );
/* don't wait! start processing buffered OpenGL routines */
glFlush ();
}
Mon problème est que le programme s'arrête quand il exécute glutMainLoop().
Je pense que c'est normal, le problème c'est que si je le met à la fin, mon programme affiche les images qu'a la fin.
Et j'aimerais qu'elle s'affiche au fur et à mesure (En faite j'ai plusieurs images à afficher au fur et a mesure).
Est-ce qu'il y a une fonction pour afficher l'image et continuer le programme après ??
Comme mettre l'image en fond en faite.
[B]Mon second problème[/B] est l'image affichée. Elle n'est bonne.
Voici ce que ca donne:
Comme vous pouvez le voir elle est toute étirée !!
l'image originale est Lena.pgm, en P2.
La je pense que j'ai un souci avec ma fonction d'affichage:
glDrawPixels( test.Hauteur(), test.Largeur(), GL_LUMINANCE, GL_UNSIGNED_BYTE, test.GetImage() );
Est-ce que vous sauriez résoudre ca?
(J'ai essayé en inversant Hauteur et Largeur mais ca n'a rien changé ou en mettant GL_BYTE mais la ca m'a sorti une exception à l'éxécution)
Comme matrice je lui envoi la matrice de l'image et elle est sous forme de byte*.
Je continu à faire des essais avec on programme encore, et en faite, j'arrive bien à afficher une image en P5 mais pas une image en P2 (Je vous ai mis un exemple de ce que ca fait avec une P2 dans mon premier post !!!) !!
alors que j'utilise la meme façon de stocker les pixels !!
Est-ce que quelqu'un saurait d'ou cela peut provenir ??
Et pour mon probleme de boucle infini a cause de glutMainLoop(), quelqu'un aurait une solution ??
le comportement me semble normal. La fonction glutMainLoop entre dans la boucle principale de traitement des evénements. L'objectif principal de cette boucle est de traiter les entrées utilisateurs comme l'appui sur une touche, les déplacements de la souris, etc. Au préalable, tu dois enregistrer des fonctions de rappel que Glut appelera dès la survenance d'un événement.
Donc ton programme va rester dans cette boucle et tout le code situé après ne sera exécuté qu'une fois sorti de la boucle.
Glut est autonome et décide tout seul quand mettre à jour la fenêtre contenant l'image. Cependant, tu peux lui forcer la main en marquant la fenêtre comme devant être redessinée.
Si tu veux afficher des images intermédiaires, il faut, après avoir tout initialisé, ne surtout pas utiliser glutMainLoop mais plutôt remplir ton tampon d'image et de forcer le rendu par un appel à glutPostRedisplay. Celà va forcer Glut à redessiner le rendu et donc à appeler la fonction de rappel que tu auras spécifiée via la fonction glutDisplayFunc.
Pour résumer, disons que tant que tu n'as que quelques images à afficher, utilise glutPostRedisplay. Ensuite, dès que tu veux traiter des entrées utilisateur, alors là tu peux entrer dans la boucle principale avec glutMainLoop.