Un comportement plutot particulier [OPENGL] [GLUT] [DEV-CPP 4.9.9.2]

[Résolu]
Signaler
Messages postés
99
Date d'inscription
vendredi 24 juin 2005
Statut
Membre
Dernière intervention
17 septembre 2005
-
Messages postés
99
Date d'inscription
vendredi 24 juin 2005
Statut
Membre
Dernière intervention
17 septembre 2005
-
Bonjour a tous

Je suis toujours a la decouverte de OpenGL, j'ai meme acheter le livre OpenGL 1.4 Guide Officiel.

Le code qui va suivre est un mélange de tuto trouvé ici et sur Internet avec ce livre.

Le comportement que je trouve etrange est celui ci : j'ai cree une fenetre et une sous fenetre, quand je tape sur le clavier en positionnant la souris sur la sous fenetre (celle qui est milieu de ma fenetre principale) le code fonctionne et j'obtiens l'effet desiré.
Mais si je positionne la souris sur la fenetre principale j'obtiens une erreur fatale

Je ne comprend pas d'ou viens ce changement de comportement.

#include<windows.h>
#include<GL/glut.h>
#include <GL/glext.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>


static float RX=0.0;
static float RY=0.0;
static float RZ=0.0;
int r=0;
int POSITIONY=5;
GLubyte space[]=
{
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
};
GLubyte letters[][13]={
{0x00,0x00,0xc3,0xc3,0xc3,0xc3,0xff,0xc3,0xc3,0xc3,0x66,0x3c,0x18},
{0x00,0x00,0xfe,0xc7,0xc3,0xc3,0xc7,0xfe,0xc7,0xc3,0xc3,0xc7,0xfe},
{0x00,0x00,0x7e,0xe7,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xe7,0x7e},
{0x00,0x00,0xfc,0xce,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc7,0xce,0xfc},
{0x00,0x00,0xff,0xc0,0xc0,0xc0,0xc0,0xfc,0xc0,0xc0,0xc0,0xc0,0xff},
{0x00,0x00,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xfc,0xc0,0xc0,0xc0,0xff},
{0x00,0x00,0x7e,0xe7,0xc3,0xc3,0xcf,0xc0,0xc0,0xc0,0xc0,0xe7,0x7e},
{0x00,0x00,0xc3,0xc3,0xc3,0xc3,0xc3,0xff,0xc3,0xc3,0xc3,0xc3,0xc3},
{0x00,0x00,0x7e,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x7e},
{0x00,0x00,0x7c,0xee,0xc6,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06},
{0x00,0x00,0xc3,0xc6,0xcc,0xd8,0xf0,0xe0,0xf0,0xd8,0xcc,0xc6,0xc3},
{0x00,0x00,0xff,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0},
{0x00,0x00,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xdb,0xff,0xff,0xe7,0xc3},
{0x00,0x00,0xc7,0xc7,0xcf,0xcf,0xdf,0xdb,0xfb,0xf3,0xf3,0xe3,0xe3},
{0x00,0x00,0x7e,0xe7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xe7,0x7e},
{0x00,0x00,0xc0,0xc0,0xc0,0xc0,0xc0,0xfe,0xc7,0xc3,0xc3,0xc7,0xfe},
{0x00,0x00,0x3f,0x6e,0xdf,0xdb,0xc3,0xc3,0xc3,0xc3,0xc3,0x66,0x3c},
{0x00,0x00,0xc3,0xc6,0xcc,0xd8,0xf0,0xfe,0xc7,0xc3,0xc3,0xc7,0xfe},
{0x00,0x00,0x7e,0xe7,0x03,0x03,0x07,0x7e,0xe0,0xc0,0xc0,0xe7,0x7e},
{0x00,0x00,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0xff},
{0x00,0x00,0x7e,0xe7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3},
{0x00,0x00,0x18,0x3c,0x3c,0x66,0x66,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3},
{0x00,0x00,0xc3,0xe7,0xff,0xff,0xdb,0xdb,0xc3,0xc3,0xc3,0xc3,0xc3},
{0x00,0x00,0xc3,0x66,0x66,0x3c,0x3c,0x18,0x3c,0x3c,0x66,0x66,0xc3},
{0x00,0x00,0x18,0x18,0x18,0x18,0x18,0x18,0x3c,0x3c,0x66,0x66,0xc3},
{0x00,0x00,0xff,0xc0,0xc0,0x60,0x30,0x7e,0x0c,0x06,0x03,0x03,0xff}
};


GLuint fontOffset;


/***********************************************************/
void makeMasterFont(void)
{
GLuint i,j;
glPixelStorei(GL_UNPACK_ALIGNMENT,1);

fontOffset=glGenLists(128);
for (i=0,j='A';i<26 ;i++,j++)
{
glNewList(fontOffset+j,GL_COMPILE);
glBitmap(8,13,0.0,2.0,10.0,0.0,letters[i]);
glEndList();
}
glNewList(fontOffset+' ',GL_COMPILE);
glBitmap(8,13,0.0,2.0,10.0,0.0,space);
glEndList();
}
/********************************************************/
void printString(char *s)
{
glPushAttrib(GL_LIST_BIT);
glListBase(fontOffset);
glCallLists(strlen(s),GL_UNSIGNED_BYTE, (GLubyte *)s);
glPopAttrib();
}


/*********************************************************/
void reshape(int w, int h)
{
glViewport(0,0,(GLsizei) w,(GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0,0,(GLdouble) w,(GLdouble) h);
}
/**********************************************************/
void Init(void)
{
glViewport(0,0,0,100);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(1,10,220,10);
makeMasterFont();
}
/*************************************************************/
void display(void)
{
char Phrase[0];
//char *essai="FEORNILHK";


//Phrase[0]="UN ESSAI CONCLUANT";
glClearColor(1,1,0,0);
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluOrtho2D(0,0,0,0);
glColor3f(0,0,0);
glRasterPos2i(1,15);
printString("TAPEZ SUR UNE TOUCHE DU CLAVIER");
glRasterPos2i(1,POSITIONY+20);
strcat(Phrase,"POUR FAIRE DESCENDRE");
printString(Phrase);
//strcat(Phrase,"OUIIIIIIIII");
glRasterPos2i(1,POSITIONY+40);
printString("LES LIGNES ");
glutSwapBuffers();
glutPostRedisplay();

}
/*******************************************************************/
void draw()
{
glClearColor(0,1,0,0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluLookAt(0,0,0,0,-15,0,10,20,5);


glRotatef(RX,1.0f,0,0);
glRotatef(RY,0,1.0f,0);
glRotatef(RZ,0,0,1.0f);


glColor3f(1.0f,0,0);
glBegin(GL_QUADS);
glVertex3f(1.0f,1.0f,1.0f);
glVertex3f(1.0f,-1.0f,1.0f);
glVertex3f(-1.0f,-1.0f,1.0f);
glVertex3f(-1.0f,1.0f,1.0f);
glEnd();


glColor3f(0,1.0f,0);
glBegin(GL_QUADS);


glVertex3f(1.0f,1.0f,-1.0f);
glVertex3f(1.0f,-1.0f,-1.0f);
glVertex3f(-1.0f,-1.0f,-1.0f);
glVertex3f(-1.0f,1.0f,-1.0f);
glEnd();


glColor3f(0,0,1.0f);
glBegin(GL_QUADS);


glVertex3f(1.0f,1.0f,1.0f);
glVertex3f(1.0f,-1.0f,1.0f);
glVertex3f(1.0f,-1.0f,-1.0f);
glVertex3f(1.0f,1.0f,-1.0f);
glEnd();


glColor3f(0,1.0f,1.0f);
glBegin(GL_QUADS);


glVertex3f(-1.0f,1.0f,1.0f);
glVertex3f(-1.0f,-1.0f,1.0f);
glVertex3f(-1.0f,-1.0f,-1.0f);
glVertex3f(-1.0f,1.0f,-1.0f);
glEnd();


glColor3f(1.0f,1.0f,0);
glBegin(GL_QUADS);


glVertex3f(-1.0f,1.0f,-1.0f);
glVertex3f(-1.0f,1.0f,1.0f);
glVertex3f(1.0f,1.0f,1.0f);
glVertex3f(1.0f,1.0f,-1.0f);
glEnd();


glColor3f(1.0f,0,1.0f);
glBegin(GL_QUADS);


glVertex3f(-1.0f,-1.0f,-1.0f);
glVertex3f(-1.0f,-1.0f,1.0f);
glVertex3f(1.0f,-1.0f,1.0f);
glVertex3f(1.0f,-1.0f,-1.0f);
glEnd();


glutSwapBuffers();
glutPostRedisplay();
}
/****************************************************/
void Idle(){
RX+=1.0f;
RY+=2.0f;
RZ+=3.0f;
if(glutGet(GLUT_WINDOW_FORMAT_ID)==0) exit(0);// pour du code portable
}
/****************************************************************************/
void clavier( unsigned char key, int x, int y )
{

MessageBox (NULL, "Clavier", "Quel partie ?", MB_ICONINFORMATION);
POSITIONY=POSITIONY+5;

}


/***************************************************************************/


int main( int argc, char *argv[ ])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
glutInitWindowSize(800,600); //Optionnel
glutCreateWindow("Ma première fenêtre OpenGL !");
glutDisplayFunc(display);
glutKeyboardFunc(clavier);
Init();
glutCreateSubWindow(1,100,150,600,300);
glutDisplayFunc(draw);
glutReshapeFunc(reshape);
glutIdleFunc(Idle);
glutKeyboardFunc(clavier);
Init();
glutMainLoop();
exit(0);
}

Merci d'avance
A voir également:

10 réponses

Messages postés
326
Date d'inscription
vendredi 13 août 2004
Statut
Membre
Dernière intervention
2 novembre 2007
2
Ben fais comme pour OpenGL alors : achetes des books !!!! (au moins un de C pour commencer...)

Je ne pense pas qu' un seul exemple puisse couvrir tout ce qu'il y a comprendre.... mais bon je vais t'aiguiller un peu:

La fonction malloc retourne un pointeur (comme new) et sert a allouer un espace de memoire en nombre d'octets. La fonction free sert a liberer la memoire allouer par malloc (ou realloc,....) et delete pour la memoire allouée par le new.
Je n'irai pas plus loin sur le new et le delete c'est du C++ alors faut pas melanger.

Exemple sur "coucou" on peut faire
char s[7]="coucou";
OU
char *s=NULL;
s=(char*)malloc(7); (ici ca marche car un char est sur un octet.. normalement on fait
malloc(7*sizeof(char));
puis remplir s[i] avec s[6]='\0'; (ne jamais oublier!! enfin des fois si pour des trames par exemple) et condition que s!=NULL.
puis pour liberer s : free(s);

Je sais pas si tu comprendras.... désolé.

KeniiyK
Messages postés
326
Date d'inscription
vendredi 13 août 2004
Statut
Membre
Dernière intervention
2 novembre 2007
2
Ben la seule limite c'est la memoire qu'il te restes.... la RAM donc.

Dans l'exemple que je t'ai donné, j'ai mis 7 en dur dans le malloc mais on peut aussi faire
malloc(X*sizeof(TypeDeDonnée)); avec X étant une variable valant ce quelle vaut au moment de l'execution : c'est l'allocation dynamique...

La limite c'est justement quand on fait des TypeDeDonnées X[10]; ou la on ne peut avoir un 11eme X.

KeniiyK
Messages postés
326
Date d'inscription
vendredi 13 août 2004
Statut
Membre
Dernière intervention
2 novembre 2007
2
char phrase[0], joli !!!!! t'arrive a compiler avec ca ?? pas sur ....
tu fais 2 appels a Init() dans ton main....
return 0, pas exit 0

KeniiyK
Messages postés
99
Date d'inscription
vendredi 24 juin 2005
Statut
Membre
Dernière intervention
17 septembre 2005

Bonsoir,

Je suis tres fort si si ca compile et meme ca cree un exe.

Les deux appels sont dus a la fenetre et a la sous fenetre.

Que je mette exit(0) ou return(0) cela compile de la meme facon mais je pense que tu as raison prenons les bonnes habitudes des le début.

je precise que je programme en etant sous windowsXP service pack 2.
Messages postés
326
Date d'inscription
vendredi 13 août 2004
Statut
Membre
Dernière intervention
2 novembre 2007
2
T'arrives a compiler ??? pas possible c'est une vrai .... ce DEVCPP et ca fait quoi un char[0] comme variable ?

Ne fais qu'un seul appel a MakeRasterFont() (avec un parametre dans Init par exemple), OpenGL est une machine a état... d'ailleurs c'est possible que ton erreur vienne des display lists

KeniiyK
Messages postés
99
Date d'inscription
vendredi 24 juin 2005
Statut
Membre
Dernière intervention
17 septembre 2005

Exact je n'avais pas vu les 2 appels a MakeRasterFont() merci.

c'etait un essai pour pouvoir mettre une variable dans printString

glRasterPos2i(1,POSITIONY+20);
strcat(Phrase,"POUR FAIRE DESCENDRE");// ici la modification de la phrase
printString(Phrase);// la bonne ecriture : printString("la solution la plus simple");

Je ne sais pas si c'est tres politiquement correct mais en faisant ainsi ca a l'air d'initialiser la variable Phrase.

Le but etant de pouvoir avoir une phrase que l'on peut modifier avant de l'afficher.
Messages postés
326
Date d'inscription
vendredi 13 août 2004
Statut
Membre
Dernière intervention
2 novembre 2007
2
Si tu ne veux afficher des string static declare les :
char phrase[7]="coucou"; par exemple

Si tu veux afficher une string dynamique fais une allocation :
malloc puis free pour liberer si en C
new puis delete si C++

Ca plante tjrs ?

KeniiyK
Messages postés
99
Date d'inscription
vendredi 24 juin 2005
Statut
Membre
Dernière intervention
17 septembre 2005

ah....j'attaque les choses serieuses on dirait
Je te precise que je debute en C j'ai des notions de programmations mais les mallocs ou new je ne maitrise pas encore.
Pour moi new c'est pour creer un pointeur sur un objet , je crois.
Par contre si tu avais un exemple ca serait sympa
C'est quoi la difference entre C et C++ ?
Je prend l'un ou l'autre puisque le compilo me demande ce que je veux a la creation du projet
Messages postés
99
Date d'inscription
vendredi 24 juin 2005
Statut
Membre
Dernière intervention
17 septembre 2005

Je crois que j'ai compris.

La longueur doit toujours etre initiliser et jamais depasser et c'est que se situe mon probleme.

Y a vraiment pas moyen de contourner cette limite ?
Messages postés
99
Date d'inscription
vendredi 24 juin 2005
Statut
Membre
Dernière intervention
17 septembre 2005

Ok merci et j'ai trouvé d'ou venait le probleme grace a toi.
en fait je faisais grandir ma variable dans la fonction display qui est appele regulierment d'ou le depassement.
la solution etait de faire le changement dans la fonction clavier avec la bonne initialisation bien sur

Merci encore