Jeu : casse brique 3d

Soyez le premier à donner votre avis sur cette source.

Vue 34 405 fois - Téléchargée 1 209 fois

Description

J'ai fait une mauvaise manip et j'ai perdu tout ce que j'avais ecris alors je vais pas tout réécrire.
En gros, pendant le jeu taper sur F1 et vous aurez toutes les explications sur les touches et la souris.

Dans le zip, il y a glut32.dll et glaux.dll, il faut les laisser dans le dossier du casse brique.
Par contre glut.h et glaux.h doivent etre placer dans le meme dossier que gl.h et glu.h(les debutants, faut chercher un peu sur votre pc :-) )

nb: ça été fait sous windows

Source / Exemple :


#include<GL/glaux.h> 
#include<GL/glut.h>
#include<GL/glu.h>
#include<GL/gl.h>
#include<math.h>

//============================================
# define BRIQUE  1
# define RAQUETTE 2
# define CADRE   3
# define AXES    4
//--------prototype des fonctions
void creer_objet_brique(GLfloat color[4]);
void creer_objet_RAQUETTE();
void creer_objet_cadre();
void creer_objet_axes3d( void );
void initialisation( void );
void rectangle(GLfloat largeur,GLfloat hauteur,GLfloat x,GLfloat y,GLfloat z);
void calcul_1_afficheur( int p, int n );
void calcul( int n );
void afficher_score( void );
void timer( int duree );
static void afficher( void );
static void ecrire(void *font, const char* string);
static void redessiner( int width, int height);
static void clavier( unsigned char k, int x, int y );
static void clavier_special( int k, int x, int y );
static void souris_bouton( int button, int state, int x, int y);
static void souris_deplacement( int x, int y);
void gerer_menu_jeu(int item);

    GLint largeur=600, hauteur=600;   //taille fenetre
    int memxy[2],cliquex,cliquey;
    GLint etat=0;
    int key,memkey=1;
    int i,j,k;
    int angle=90,angle2;
    int NbBrique[3]={6,6,6};
    int brique[6][6][6]; //tableau representant l'etat de chaque brique (visible ou caché)
    int BriqueATester[3]; //indices pour brique[][][]
    GLfloat color[4]={0,0,1,1};
    
    //affichage du score
    GLfloat c[35];
    GLfloat L1=.75, L2=.25, tabulation=2;
    int A[5];
    int score=0;
     //========== DIMENSION ==========
     GLfloat DimBrique[3]={2,1,1};
     GLfloat DimBoule[3]={0.5,10,10};
     GLfloat DimRaquette[3]={2,.6,1};
     GLfloat DimCadre[3];
     //========== POSITION ==========
     GLfloat PosBrique[3]={0,10,0};
     GLfloat PosBoule[3]={4,6,0.5};
     GLfloat PosRaquette[3]={4,0,0};
     GLfloat PosLight1[4] = {6, 6, 5, 1};
     GLfloat PosCamera[3]={13,2*M_PI/5,0}; // rayon, theta, phi
     GLfloat PosCible[3]={6,8,3};
     //========== DEPLACEMENT ==========
     GLfloat DirBoule[3]={.05,.07,.05};
     GLfloat pasBoule=0.05;
     GLfloat PasRaquette[3]={0,0,0};
     GLfloat PasCamera[3]={0,0,0}; // increment de rayon, theta, phi
     //========== PROJECTIONS ==========
     //projection sur z
     GLfloat projMat[16]={  1,0,0,0,
                            0,1,0,0,
                            0,0,0,0,
                            0,0,0,1};
     //projection sur y
     GLfloat projMat2[16]={ 1,0,0,0,
                            0,0,0,0,
                            0,0,1,0,
                            0,0,0,1};
     //projection sur x  
     GLfloat projMat3[16]={ 0,0,0,0,
                            0,1,0,0,
                            0,0,1,0,
                            0,0,0,1}; 
     //-------choix des couleurs des materiaux------
     GLfloat no_mat[4] = { 0.0, 0.0, 0.0, 1.0 };
     float Mat_Amb[4] = {0, 1, 0, 1};     
     float Mat_Dif[4] = {1, 0, 0, 1};
     float Mat_Spec[4] = {0, 0, 1, 1};
     //-------choix des couleurs des lumieres-------
     float Light1_Amb[4] = {1, 1, 1, 1};
     float Light1_Dif[4] = {1, 1, 1, 1};
     float Light1_Spec[4] = {1, 1, 1, 1};
     float Spot1_Dir[3] = {0.0f, 0.0f, -1.0f};
//============================================
AUX_RGBImageRec * texture;
void initialisation( void ){
//     printf("initialisation:\n");

     glPixelStorei(GL_UNPACK_ALIGNMENT,1);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);//GL_CLAMP
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); //(...,...,GL_LINEAR)
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); //GL_DECAL

     texture = auxDIBImageLoad("metal sheet64.bmp");
     glTexImage2D(GL_TEXTURE_2D,0,3,
                  texture->sizeX,texture->sizeY,0,GL_RGB,
                  GL_UNSIGNED_BYTE,
                  texture->data);

     //==========  ==========
     for(i=0;i<3;i++) DimCadre[i]=PosBrique[i]+NbBrique[i]*DimBrique[i];

     //========== CREATION ==========
     //-------creation des objets-------------------
     glNewList(BRIQUE, GL_COMPILE);
       creer_objet_brique(color);
     glEndList();
     glNewList(RAQUETTE, GL_COMPILE);
       creer_objet_RAQUETTE();
     glEndList();
     glNewList(CADRE, GL_COMPILE);
       creer_objet_cadre();
     glEndList();
     glNewList(AXES, GL_COMPILE);
       creer_objet_axes3d();
     glEndList();
     //-------creation des materiaux----------------
     glMaterialfv(GL_FRONT,GL_AMBIENT,Mat_Amb);
     glMaterialfv(GL_FRONT,GL_DIFFUSE,Mat_Dif);     
     glMaterialfv(GL_FRONT,GL_SPECULAR,Mat_Spec);
     //-------creation des lumieres-----------------
     glLightfv(GL_LIGHT0, GL_DIFFUSE, Light1_Dif);
     glLightfv(GL_LIGHT0, GL_SPECULAR, Light1_Spec);
     glLightfv(GL_LIGHT0, GL_AMBIENT, Light1_Amb);
     glLighti(GL_LIGHT0, GL_SPOT_CUTOFF, 180);  //90-> angle d'ouverture du spot

     //========== AUTRE ==========
//init des briques
	for(k=0;k<NbBrique[2];k++)
		for(j=0;j<NbBrique[1];j++)
        	for(i=0;i<NbBrique[0];i++)
				brique[i][j][k] = (int) floor(rand()*4/RAND_MAX);

    //-------initialisation des transparences------
     glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
     glPolygonMode(GL_BACK,GL_LINE);
     glPolygonMode(GL_FRONT,GL_FILL);
    //--------activation des fonctionnalites--------
    //glShadeModel( GL_FLAT );
	//glutSetCursor( GLUT_CURSOR_SPRAY );
}

//============================================
static void afficher( void ){
	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
	glClearColor( 0,0,0,0);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	gluLookAt(    PosCible[0]+PosCamera[0]*cos(PosCamera[2])*cos(PosCamera[1]),
                  PosCible[1]-PosCamera[0]*sin(PosCamera[2]),
                  PosCible[2]+PosCamera[0]*cos(PosCamera[2])*sin(PosCamera[1]),
                  PosCible[0],
                  PosCible[1],
                  PosCible[2],
                  0,1,0);

//affichage de la lumiere
    glEnable(GL_COLOR_MATERIAL);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);

    glLightfv(GL_LIGHT0, GL_POSITION, PosLight1);

//affichage du cadre
    glCallList(CADRE);
  
//affichage score
    glPushMatrix();
    glTranslatef( 1.5,5,0 );
    afficher_score();
    glPopMatrix();

    glEnable( GL_BLEND );

  //Projection à l'aide de la matrice d'ombre
    glPushMatrix();
    glMultMatrixf(projMat);
    glTranslatef( PosBoule[0], PosBoule[1], PosBoule[2] );
    glColor4f(.5, .5, .5, .4);
    glutSolidSphere ( 0.5, 10, 10);  
    glPopMatrix();
  //Projection à l'aide de la matrice d'ombre
    glPushMatrix();
    glMultMatrixf(projMat2);
    glTranslatef( PosBoule[0], PosBoule[1], PosBoule[2] );
    glColor4f(.5, .5, .5, .4);
    glutSolidSphere ( 0.5, 10, 10);  
    glPopMatrix();
  //Projection à l'aide de la matrice d'ombre
    glPushMatrix();
    glMultMatrixf(projMat3);
    glTranslatef( PosBoule[0], PosBoule[1], PosBoule[2] );
    glColor4f(.5, .5, .5, .4);
    glutSolidSphere ( 0.5, 10, 10);  
    glPopMatrix();    

    glEnable(GL_DEPTH_TEST);
//affichage des briques
	for(k=0;k<NbBrique[2];k++)
		for(j=0;j<NbBrique[1];j++)
        	for(i=0;i<NbBrique[0];i++){
        // printf("%d,%d,%d",i,j,k);
				if(brique[i][j][k]){
                    //printf("brique[i][j][k]:%d",brique[i][j][k]);               
                	glPushMatrix();
                	glTranslatef( PosBrique[0]+i*DimBrique[0], PosBrique[1]+j*DimBrique[1], PosBrique[2]+k*DimBrique[2] );
                    if(brique[i][j][k]==1) glColor4f( 0, 0, 1, 1);
                    if(brique[i][j][k]==2) glColor4f( 0, 1, 0, 1);
                    if(brique[i][j][k]==3) glColor4f( 1, 0, 0, 1);
                	glCallList(BRIQUE);
                	glPopMatrix();
		        }
            }
    glDisable( GL_BLEND );

//affichage de la boule
    glPushMatrix();
    glTranslatef( PosBoule[0], PosBoule[1], PosBoule[2] );
    glColor3d(.5, .5, .5);
    glutSolidSphere ( 0.5, 10, 10);
    glPopMatrix();
//affichage de Raquette
    glEnable(GL_TEXTURE_2D);
	glPushMatrix();
    glTranslatef( PosRaquette[0], PosRaquette[1], PosRaquette[2] );
    glCallList(RAQUETTE);
    glPopMatrix();
    glDisable(GL_TEXTURE_2D);

    glDisable(GL_COLOR_MATERIAL);
    glDisable(GL_LIGHTING);
    glDisable(GL_LIGHT0);
    glDisable(GL_DEPTH_TEST);
//affichage des axes
    //glCallList(AXES);

//simule une lampe
   glPushMatrix();
   glTranslatef (PosLight1[0],PosLight1[1],PosLight1[2]);
   glMaterialfv(GL_FRONT, GL_EMISSION, Light1_Dif);
   glutSolidSphere(0.1, 16, 16);
   glPopMatrix();
   glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);

//affichage
	glPushMatrix();
    glColor4f(1, .7, .7, 1);
    glRasterPos3f( PosCible[0], PosCible[1], PosCible[2] );
    if(etat==2) ecrire(GLUT_BITMAP_TIMES_ROMAN_24, "PAUSE");
    if(etat==3) ecrire(GLUT_BITMAP_TIMES_ROMAN_24, "PERDU");
    glPopMatrix();
    
	glFinish();  //mise à l'ecran
	glutSwapBuffers();   //changement de buffer(car on est en double buffering)
}
//============================================
static void ecrire(void *font, const char* string){
    while (*string)  glutBitmapCharacter(font, *string++);
}
//============================================
static void redessiner( int width, int height){
    largeur = width;
    hauteur = height;
	glViewport( 0, 0, (GLint)width, (GLint)height );
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	if(largeur>hauteur)	gluPerspective(angle,largeur/hauteur,1,100 );
	else gluPerspective(angle,hauteur/largeur,1,100 );
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}

//============================================
static void clavier( unsigned char k, int x, int y ){
    //printf("touche: %c\n",k);   
	switch (k){

  //------------------
  //aide
        case 'a':
             clavier_special( GLUT_KEY_F1, 0, 0 ); break;
             break;
  //------------------
  //zoomer
        case 'z': 
             angle2=angle-2;
             if(50<angle2 && angle2<110) angle=angle2;
             break;
  //------------------  
  //dezoomer
        case 'e': 
             angle2=angle+2;
             if(50<angle2 && angle2<110) angle=angle2;
             break;
  //------------------
  //arret du programme
        case 'q':
		case 27: //touche Echap
			//glutLeaveMainLoop();
			//glutDestroyWindow();
			exit(0);
			break;
  //------------------
  //start new game
        case 's':
             PosBoule[0]=4;
             PosBoule[1]=6;
             PosBoule[2]=.5;
             DirBoule[0]=0;
             DirBoule[1]=.07;
             DirBoule[2]=0;
             initialisation();
             etat=1;
             score=0;
             glutTimerFunc( 100, timer, 0 );
             break;
  //------------------
  //pause     
        case 'p':
             if(etat==2){etat=0; printf("reprise du jeu\n"); }
             else if(etat==0 || etat==1){etat=2; printf("pause\n");}
             break;
  //------------------  
        case '7': 
             PosLight1[0]-= 0.5;
             break;
  //------------------  
        case '8': 
             PosLight1[0]+= 0.5;
             break;
  //------------------  
        case '4': 
             PosLight1[1]-= 0.5;
             break;
  //------------------  
        case '5': 
             PosLight1[1]+= 0.5;
             break;
  //------------------  
        case '1': 
             PosLight1[2]-= 0.5;
             break;
  //------------------  
        case '2': 
             PosLight1[2]+= 0.5;
             break;

	}
	redessiner(largeur, hauteur);
    glutPostRedisplay();
}
//============================================
static void clavier_special( int k, int x, int y ){
       switch (k){
              case GLUT_KEY_F1:
                   printf("\nCOMMANDES DU CLAVIER:\n");
                   printf(" -- Echap: permet de quitter le jeu.\n");
                   printf(" -- F1: Afficher les commandes du clavier et de la souris.\n");
                   printf(" -- F2: Vue de face.\n");
                   printf(" -- F3: Vue 3/4 droite.\n");
                   printf(" -- F4: Vue de droite.\n");                   
                   printf(" -- F5: Vue de dessous.\n");
                   printf(" -- F6: Mettre le jeu en plein ecran (attention: non reversible).\n");
                   printf(" -- p : Mettre/Enlever la pause.\n");
                   printf(" -- a : Aide.\n");
                   printf(" -- z : Zoomer.\n");
                   printf(" -- e : Dezoomer.\n");
                   printf(" -- q : Quitter.\n");
                   printf(" -- s : Start nouveau jeu.\n");
                   printf(" -- 7/8 : deplacer la lampe sur l'axe x.\n");
                   printf(" -- 4/5 : deplacer la lampe sur l'axe y.\n");
                   printf(" -- 1/2 : deplacer la lampe sur l'axe z.\n");
                   printf("\nCOMMANDES DE LA SOURIS:\n");
                   printf(" -- Bouton gauche enfonce: le deplacement de la souris permet de deplacer la raquette.\n");
                   printf(" -- Bouton droit  enfonce: le deplacement de la souris permet de deplacer la camera.\n");
                   printf(" -- Bouton centre  appuye: permet d'acceder au menu du jeu (Nouveau Jeu,..., Quitter).\n");
                   break;
      //------------------         
              case GLUT_KEY_F2:
                   PosCamera[1]=M_PI/2;
                   PosCamera[2]=0;
                   break;
      //------------------         
              case GLUT_KEY_F3:
                   PosCamera[1]=M_PI/5;
                   PosCamera[2]=0;
                   break;
      //------------------         
              case GLUT_KEY_F4:
                   PosCamera[1]=0;
                   PosCamera[2]=0;
                   break;
      //------------------         
              case GLUT_KEY_F5:
                   PosCamera[1]=M_PI/2;
                   PosCamera[2]=M_PI/2-.01;
                   break;
      //------------------         
              case GLUT_KEY_F6:
                   glutFullScreen();
                   break;
/* autres touches:
GLUT_KEY_F1, GLUT_KEY_F2, ..., GLUT_KEY_F12 - F1 through F12 keys 
GLUT_KEY_PAGE_UP, GLUT_KEY_PAGE_DOWN - Page Up and Page Down keys 
GLUT_KEY_HOME, GLUT_KEY_END - Home and End keys 
GLUT_KEY_LEFT, GLUT_KEY_RIGHT, GLUT_KEY_UP, GLUT_KEY_DOWN - Arrow keys 
GLUT_KEY_INSERT - Insert key */
       }
}
//============================================
static void souris_bouton( int button, int state, int x, int y){
       switch (button){
              case GLUT_LEFT_BUTTON:
                   if (state==GLUT_DOWN) key=1;
                   if (state==GLUT_UP) {
                                       PasRaquette[0]=0;
                                       PasRaquette[2]=0;
                                       memxy[0]=0;
                                       memxy[1]=0;        
                                       key=0;}              
                   break;
              case GLUT_MIDDLE_BUTTON:
                   break;
              case GLUT_RIGHT_BUTTON:
                   //printf("souris appuyee en: (%d,%d)\n",x,y);
                   if (state==GLUT_DOWN) key=2;
                   if (state==GLUT_UP) key=0;
                   break;
       }
       cliquex=x;   cliquey=y;
}
//============================================
float signe( GLfloat a){ return a>0 ? 1 : -1;}

static void souris_deplacement( int x, int y){
       if(!memxy[0])memxy[0]=cliquex;
       if(!memxy[1])memxy[1]=cliquey;
       
       switch(key){
                   case 1:
                        PasRaquette[0] = (sin(PosCamera[1])*(x-memxy[0])+
                                        cos(PosCamera[1])*(y-memxy[1]))/
                                        27.;
                        PasRaquette[2] = signe(sin(M_PI/4-PosCamera[2]))*
                                       (-cos(PosCamera[1])*(x-memxy[0])+
                                        sin(PosCamera[1])*(y-memxy[1]))/
                                        27.;
                        if( PosRaquette[0]+PasRaquette[0]>=0 &&
                            PosRaquette[2]+PasRaquette[2]>=0 &&
                            PosRaquette[0]+PasRaquette[0]+DimRaquette[0]<=DimCadre[0] &&
                            PosRaquette[2]+PasRaquette[2]+DimRaquette[2]<=DimCadre[2])
                            {PosRaquette[0]+=PasRaquette[0];
                             PosRaquette[2]+=PasRaquette[2];}
                        break;
                   case 2:
                        PasCamera[1]=(x-cliquex)/5000.;
                        PasCamera[2]=(cliquey-y)/5000.;
                        break;
       }
       memxy[0]=x;   memxy[1]=y;
       redessiner(largeur, hauteur);
       glutPostRedisplay();
}
//============================================
void rectangle(GLfloat largeur,GLfloat hauteur,GLfloat x,GLfloat y,GLfloat z){
		glBegin( GL_QUADS ); 
		         glVertex3f( x,y,z  );
    	         glVertex3f( x+largeur,y,z );
                 glVertex3f( x+largeur,y+hauteur,z );
    		     glVertex3f( x,y+hauteur,z );
		glEnd();
}
//============================================
void afficher_score(){
	calcul(score);
	for(i=0;i<5;i++){
		glColor3f(0,c[0+i*7],0);
		rectangle(L1,L2,        i*tabulation+L2,    0    ,0);
		glColor3f(0,c[1+i*7],0);
		rectangle(L1,L2,        i*tabulation+L2,    L1+L2    ,0);
		glColor3f(0,c[2+i*7],0);
		rectangle(L1,L2,        i*tabulation+L2,    2*(L1+L2)    ,0);
		glColor3f(0,c[3+i*7],0);
		rectangle(L2,L1,        i*tabulation,       L2    ,0);
		glColor3f(0,c[4+i*7],0);
		rectangle(L2,L1,        i*tabulation,       2*L2+L1    ,0);
		glColor3f(0,c[5+i*7],0);
		rectangle(L2,L1,        i*tabulation+L2+L1, L2    ,0);
		glColor3f(0,c[6+i*7],0);
		rectangle(L2,L1,        i*tabulation+L2+L1, 2*L2+L1    ,0);
	}
}
//============================================
void calcul_1_afficheur(int p,int n){
     if (n==0 |        n==2 | n==3 |        n==5 | n==6 |        n==8 | n==9 )  c[0+(4-p)*7]=1; //centre,bas
     if (              n==2 | n==3 | n==4 | n==5 | n==6 |        n==8 | n==9 )  c[1+(4-p)*7]=1; //centre,milieu
     if (n==0 |        n==2 | n==3 |        n==5 | n==6 | n==7 | n==8 | n==9 )  c[2+(4-p)*7]=1; //centre,haut
     if (n==0 |        n==2 |                      n==6 |        n==8        )  c[3+(4-p)*7]=1; //gauche,bas
     if (n==0 |                      n==4 | n==5 | n==6 |        n==8 | n==9 )  c[4+(4-p)*7]=1; //gauche,haut
     if (n==0 | n==1 |        n==3 | n==4 | n==5 | n==6 | n==7 | n==8 | n==9 )  c[5+(4-p)*7]=1; //droite,bas
     if (n==0 | n==1 | n==2 | n==3 | n==4 |               n==7 | n==8 | n==9 )  c[6+(4-p)*7]=1; //droite,haut
}
//============================================
void calcul (int n){
     A[4]=n/10000;
     A[3]=(n-A[4]*10000)/1000;
     A[2]=(n-A[4]*10000-A[3]*1000)/100;
     A[1]=(n-A[4]*10000-A[3]*1000-A[2]*100)/10;
     A[0]=(n-A[4]*10000-A[3]*1000-A[2]*100-A[1]*10);
     for(i=0;i<35;i++)  c[i]=0;
     for(i=0;i<5;i++) calcul_1_afficheur(i,A[i]);
//     for(i=0;i<5;i++) printf("%d\n",A[i]);
}
//============================================
void timer( int duree ){
    if(etat!=2 && etat!=3){
         //BriqueATester contiendra les indices(pour le tableau brique) de la brique à tester
         for(i=0;i<3;i++){
             PosBoule[i]+=DirBoule[i];
             BriqueATester[i] = floor(PosBoule[i]-PosBrique[i])/DimBrique[i];
         }
         //le rebond sur S
         if(PosBoule[1]-DimBoule[0]<DimRaquette[1] &&
            PosBoule[0]>PosRaquette[0]             &&
            PosBoule[0]<PosRaquette[0]+DimRaquette[0]     &&
            PosBoule[2]>PosRaquette[2]             &&
            PosBoule[2]<PosRaquette[2]+DimRaquette[2]       )
            {DirBoule[0]+=PasRaquette[0]/2;
             DirBoule[1]=-DirBoule[1];
             DirBoule[2]+=PasRaquette[2]/2;}
         
         //le rebond sur les briques      
         if(BriqueATester[1]>=0)
            if( k = brique[BriqueATester[0]][BriqueATester[1]][BriqueATester[2]]){
                if(k!=3){ // 3=> incassable
                     score+=k;
                     brique[BriqueATester[0]][BriqueATester[1]][BriqueATester[2]]=0;
                }
               DirBoule[1]=-DirBoule[1];}
         
         //si la boule est descendue trop bas => perdu
         if(PosBoule[1]-DimBoule[0]<0){etat=3; return;}
         
         //rebondir sur les murs
         for(i=0;i<3;i++)
             if(PosBoule[i]-DimBoule[0]<0 || PosBoule[i]+DimBoule[0]>DimCadre[i])
                  DirBoule[i]=-DirBoule[i];
     }

     //rotation de la camera 
     if(key==2){
          PosCamera[1]+=PasCamera[1];
          PosCamera[2]+=PasCamera[2];
          //printf("%f\n",PosCamera[2]);
     }

     glutPostRedisplay();
     //si on demande une nouvelle partie, le timer s'arrete dans les 30 ms qui suivent la demande
     //pendant la demande de nouvelle partie(voir la fonction 'gerer_menu_jeu' case:1)
     //if(etat!=1) 
     glutTimerFunc( 30, timer, 0 );
    // else etat=0;
}
//============================================
void gerer_menu_principal(int item){
     switch(item){
                  //pause
                  case 1: clavier('p',0,0); break;
                  //aide
                  case 2: clavier_special( GLUT_KEY_F1, 0, 0 ); break;
     }
}
//============================================
void gerer_menu_jeu(int item){
     switch(item){
                  //start new game
                  case 1: clavier('s',0,0); break;
                  //quitter
                  case 2: clavier('q',0,0); break;             
     }
     
}
//============================================
int main( int argc, char *argv[] ){
	glutInit( &argc, argv );
	glutInitWindowPosition( 100, 100 );
	glutInitWindowSize( largeur, hauteur );
	glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
	glutCreateWindow( "CASSE BRIQUE" );

    int jeu = glutCreateMenu( gerer_menu_jeu );
    glutAddMenuEntry( "Nouveau", 1 );
    glutAddMenuEntry( "Quitter", 2 );

    int menu = glutCreateMenu( gerer_menu_principal );
    glutAddSubMenu( "JEU", jeu );
    glutAddMenuEntry( "PAUSE", 1 );
    glutAddMenuEntry( "AIDE", 2 );
    glutAttachMenu( GLUT_MIDDLE_BUTTON );

	initialisation();
	glutDisplayFunc( afficher );
	glutReshapeFunc( redessiner );
	glutKeyboardFunc( clavier );
	glutSpecialFunc( clavier_special );
	glutMouseFunc( souris_bouton );
	glutMotionFunc( souris_deplacement );
	glutTimerFunc( 30, timer, 0 );
	glutMainLoop();
	return 0;
}
//============================================
void creer_objet_brique(GLfloat color[4]){
    	glBegin( GL_QUADS );

     //devant
//    	glColor4f( 0 , 0, 1, 1);
    	glVertex3f( 0, 0, DimBrique[2]);
//    	glColor4f( 0.5 , 0, 0.5, 1);
    	glVertex3f( DimBrique[0], 0, DimBrique[2]);
//    	glColor4f( 0 , 0, 1, 1);
    	glVertex3f( DimBrique[0], DimBrique[1], DimBrique[2]);
    	glColor4f( 0.5 , 0.2, 0.5, 1);
    	glVertex3f( 0, DimBrique[1], DimBrique[2]);

     //derriere
    	glColor4f( 1 , 0, 1, .6);
    	glVertex3f( 0, 0, 0);
    	glVertex3f( 0, DimBrique[1], 0);
    	glVertex3f( DimBrique[0], DimBrique[1], 0);
    	glVertex3f( DimBrique[0], 0, 0);

     //dessous
    	glColor4f( 0 , 1, 1, .9);
    	glVertex3f( 0, 0, 0);
    	glColor4f( 0 , 0.7, 0, .9);
    	glVertex3f( DimBrique[0], 0, 0);
    	glColor4f( 0 , 1, 1, .9);
    	glVertex3f( DimBrique[0], 0, DimBrique[2]);
    	glColor4f( 0 , 0.7, 0, .9);
    	glVertex3f( 0, 0, DimBrique[2]);

     //dessus    	
    	glColor4f( 0 , 1, 1, .9);
    	glVertex3f( 0, DimBrique[1], 0);
    	glColor4f( 0 , 0.7, 0, .9);
    	glVertex3f( 0, DimBrique[1], DimBrique[2]);
    	glColor4f( 0 , 1, 1, .9);
    	glVertex3f( DimBrique[0], DimBrique[1], DimBrique[2]);
    	glColor4f( 0 , 0.7, 0, .9);
    	glVertex3f( DimBrique[0], DimBrique[1], 0);

     //cotes
    	glColor4f( 1 , 1, 1, .8);    	
    	glVertex3f( 0, 0, 0);
    	glVertex3f( 0, 0, DimBrique[2]);
    	glVertex3f( 0, DimBrique[1], DimBrique[2]);
    	glVertex3f( 0, DimBrique[1], 0);
    	
    	glVertex3f( DimBrique[0], 0, 0);
    	glVertex3f( DimBrique[0], DimBrique[1], 0);
    	glVertex3f( DimBrique[0], DimBrique[1], DimBrique[2]);
    	glVertex3f( DimBrique[0], 0, DimBrique[2]);

    	glEnd();
}

//============================================
void creer_objet_RAQUETTE(){
    	glBegin( GL_QUADS );
    	
    	glColor3f( 1 , 0, 0);
    	glTexCoord2f(1.0,0.0);
    	glVertex3f( 0, 0, 0);
    	glTexCoord2f(1.0,1.0);
    	glVertex3f( 0, DimRaquette[1], 0);
    	glTexCoord2f(0.0,1.0);
    	glVertex3f( DimRaquette[0], DimRaquette[1], 0);
    	glTexCoord2f(0.0,0.0);
    	glVertex3f( DimRaquette[0], 0, 0);
    	
    	glColor3f( 0 , 0, 0);
    	glTexCoord2f(1.0,0.0);
    	glVertex3f( 0, 0, 0);
    	glTexCoord2f(1.0,1.0);
    	glVertex3f( DimRaquette[0], 0, 0);
    	glTexCoord2f(0.0,1.0);
    	glVertex3f( DimRaquette[0], 0, DimRaquette[2]);
    	glTexCoord2f(0.0,0.0);
    	glVertex3f( 0, 0, DimRaquette[2]);

    	glColor3f( .5 , 1, .5);
    	glTexCoord2f(1.0,0.0);
    	glVertex3f( 0, DimRaquette[1], 0);
    	glTexCoord2f(1.0,1.0);
    	glVertex3f( 0, DimRaquette[1], DimRaquette[2]);
    	glTexCoord2f(0.0,1.0);
    	glVertex3f( DimRaquette[0], DimRaquette[1], DimRaquette[2]);
    	glTexCoord2f(0.0,0.0);
    	glVertex3f( DimRaquette[0], DimRaquette[1], 0);
   
    	glColor3f( 0 , 0, 0);
    	glTexCoord2f(1.0,0.0);
    	glVertex3f( 0, 0, 0);
        glTexCoord2f(1.0,1.0);
    	glVertex3f( 0, 0, DimRaquette[2]);
    	glTexCoord2f(0.0,1.0);
    	glVertex3f( 0, DimRaquette[1], DimRaquette[2]);
    	glTexCoord2f(0.0,0.0);
    	glVertex3f( 0, DimRaquette[1], 0);
    	
    	glTexCoord2f(1.0,0.0);
    	glVertex3f( DimRaquette[0], 0, 0);
    	glTexCoord2f(1.0,1.0);
    	glVertex3f( DimRaquette[0], DimRaquette[1], 0);
    	glTexCoord2f(0.0,1.0);
    	glVertex3f( DimRaquette[0], DimRaquette[1], DimRaquette[2]);
    	glTexCoord2f(0.0,0.0);
    	glVertex3f( DimRaquette[0], 0, DimRaquette[2]);
    	
    	glColor3f( 0 , 0, 1);
    	glTexCoord2f(1.0,0.0);
    	glVertex3f( 0, 0, DimRaquette[2]);
    	glTexCoord2f(1.0,1.0);
    	glVertex3f( DimRaquette[0], 0, DimRaquette[2]);
    	glTexCoord2f(0.0,1.0);
    	glVertex3f( DimRaquette[0], DimRaquette[1], DimRaquette[2]);
    	glTexCoord2f(0.0,0.0);
    	glVertex3f( 0, DimRaquette[1], DimRaquette[2]);

    	glEnd();
}

//============================================
void creer_objet_cadre(){
    	glBegin( GL_QUADS );

    	glColor4f( .6 , .6, .9, 1);
    	glVertex3f( -.01, -.01, -.01);
    	glVertex3f( DimCadre[0]+.01, -.01, -.01);
    	glVertex3f( DimCadre[0]+.01, DimCadre[1], -.01);
    	glVertex3f( -.01, DimCadre[1], -.01);
   
    	glColor4f( .6 , .6, .7, 1);
    	glVertex3f( -.01, -.01, -.01);
    	glVertex3f( -.01, -.01, DimCadre[2]);
    	glVertex3f( DimCadre[0]+.01, -.01, DimCadre[2]);
    	glVertex3f( DimCadre[0]+.01, -.01, -.01);
 
    	glColor4f( .9 , .6, .9, 1);
    	glVertex3f( -.01, -.01, -.01);
    	glVertex3f( -.01, DimCadre[1], -.01);
    	glVertex3f( -.01, DimCadre[1], DimCadre[2]);
    	glVertex3f( -.01, -.01, DimCadre[2]);

    	glColor4f( .9 , .6, .9, 1);
    	glVertex3f( DimCadre[0]+.01, -.01, -.01);
    	glVertex3f( DimCadre[0]+.01, -.01, DimCadre[2]);
    	glVertex3f( DimCadre[0]+.01, DimCadre[1], DimCadre[2]);   	
    	glVertex3f( DimCadre[0]+.01, DimCadre[1], -.01);

        glEnd();
}

//============================================
void creer_objet_axes3d( void ){
 	   glLineWidth( 2 );
       glBegin( GL_LINES );
       glColor3f( 1, 0, 0 );
       glVertex3f( 0., 0., 0. );
       glVertex3f( 1., 0., 0. );
       glColor3f( 0, 1, 0);
       glVertex3f( 0., 0., 0. );
       glVertex3f( 0., 1., 0. );
       glColor3f( 0, 0, 1 );
       glVertex3f( 0., 0., 0. );
       glVertex3f( 0., 0., 1. );
       glEnd();
       glLineWidth( 1 );
}

Conclusion :


c'est un projet fait à la demande du prof d'infographie.
On n'as eut que 6 cours donc le niveau est debutant cependant il y a beaucoup de petites choses interessantes à copier: utilisation de transparence, de lumiere, de texture etc...

Le code est commenté et structuré, il est donc relativement facil de trouver le bout de programme que l'on cherche.

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
8
Date d'inscription
jeudi 22 juillet 2004
Statut
Membre
Dernière intervention
20 décembre 2006

Bonjour !!!

Je n'arrive pas à lancer ton programme casses briques.J'ai des erreurs sur le M_PI et sur la variable jeu dans le main (int jeu = glutCreateMenu( gerer_menu_jeu );

Je rencontre l'erreur sur la ligne glutAddSubMenu("JEU",jeu);

Si tu pouvais m'aider !

Merci d'avance
Messages postés
546
Date d'inscription
vendredi 13 février 2004
Statut
Membre
Dernière intervention
9 janvier 2008

merci pour l'information! :)
Messages postés
24
Date d'inscription
vendredi 30 juillet 2004
Statut
Membre
Dernière intervention
26 avril 2006

Ben la licence que j'ai fais étais en alternance donc y peuvent pas mettre non plus trop d'heures. Ca s'appel licence pro informatique option imagerie numérique. Mais y a pas que ca, il y en a pour tout les niveaux des formations, si tu veut y a des master spécialisé dans ce dommaine et de la prog 3D tu va bouffé que de ca. Sinon y a des iut info option imagerie numérique ou tu fais pas mal de 3D aussi.
Messages postés
546
Date d'inscription
vendredi 13 février 2004
Statut
Membre
Dernière intervention
9 janvier 2008

c'est interessant ca! Mais comment s'appellent ces licences? c'est juste une spécialisation? Parce que la en tout ca fait pas enorme comme nombre d'heure...
Messages postés
24
Date d'inscription
vendredi 30 juillet 2004
Statut
Membre
Dernière intervention
26 avril 2006

Si vous voulez faire des études dans ce domaine, il exsite des licence informatique imagerie 3D temps réel. Au programme synthèse d'image avec 3ds max(100h) programmation DirectX(30h), OpenGL(30h) et CG(30h). Il faut juste prendre la bonne voix :p
Afficher les 22 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.