CodeS-SourceS est hébergé par Frontier.fr

Ce site au démarrage

begin process at 2010 02 09 21:59:10

Accueil Codes Tutoriels Forum Livres Emploi Services Connexion

Trouver un code source :

dans

[ Dernières recherches ]

Accueil >

JEU : CASSE BRIQUE 3D

Information sur la source

Note :

10,00 / 10

Catégorie :OpenGL Classé sous :casse, brique, 3d, jeu, game Niveau :Débutant Date de création :06/07/2005 Date de mise à jour :26/10/2005 19:24:39 Vu / téléchargé :27 995 / 862

Auteur : goygoy

Ecrire un message privé

Site perso

Commentaire sur cette source (22)

Ajouter un commentaire et/ou une note

Description

Cliquez pour voir la capture en taille normale

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

#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 );
}

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

Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

CasseBrique.dev932 octets
CasseBrique6.c 28 531 octets
devcpp_glut.zip93 701 octets
glaux.dll1 386 496 octets
glaux.h 12 026 octets
glut32.dll221 184 octets
metal sheet64.bmp 5 174 octets

Télécharger le zip

Historique

26 octobre 2005 19:24:39 :: Comme l'indique l'un des commentaires, il y a un bug si on essait de compiler le fichier tel quel sous 'dev-cpp'. Il faut l'inclure dans un projet et aller dans 'option du projet' puis changer certaines choses. Je rajoute donc le fichier 'CasseBrique.dev' au zip. Il suffit de l'ouvrir et de cliquer sur compiler. Et ça devrait marcher... En tout cas je croise les doigts pour vous.

Sources de la même categorie

JEU DE DAMES 3D par vbclaude

CHARGEMENT DES TEXTURES EN OPENGL par Jackyzgood

OPENGL - UN PEU DE NEIGE... par underprog

JEU DE LA VIE 3D OPENGL AVEC GESTION SOURIS par fratleym

SPEAD RACER par jngl

Toutes les sources de la catégorie OpenGL

Sources en rapport avec celle ci

JEU DE COMBAT 3D GAME STUDIO par prankblack

ASTEROID DIRECT X par f_l_a_s_h_b_a_c_k

OPENGL - JEU DE BILLARD EN 3D PAS FINI par acx01b

UN CASSE BRIQUE AVEC UN MENU (CONSOLE) par crazy lapinou

JEU DE CASSE-BRIQUES [DEV-C++] par Neo020585

Commentaires et avis

Commentaire de skinia le 11/07/2005 10:44:07

avoir des cours d'opengl, quelle chance mon gars

Commentaire de LordBob le 11/07/2005 20:08:01

SKINIA << je ne sais pas qu'elle age tu as... enfin pour avoir des cours d'OpenGL faut déjà choisir un cursus informatique et avoir un bon niveau en math ! comme j'ai dit je ne connais pas ton age, mais il n'est peut etre pas trop tard encore !!!

Commentaire de skinia le 12/07/2005 10:27:30

si malheureusement il est trop tard, j'ai fini les etudes d'informatique mais j'ai jamais eu de cours en opengl. parce que contrairement à ce que tu crois on n'a pas des cours d'opengl dans tous les cursus, c'est même très rare et c'est souvent en début d'etude (1ère année d'iut par ex).
tu verras qu'après tu vas vite oublier l'opengl :)

Commentaire de dletozeun le 12/07/2005 19:26:31

"tu verras qu'après tu vas vite oublier l'opengl :) "

c'est a dire?

Commentaire de Tellmarch le 13/07/2005 19:58:07

bah je suis en licence, et j'ai aussi eu des cours d'opengl...
Je pense que c'est assez fréquent.

Commentaire de iopiopiop le 03/08/2005 13:06:55

Je n'aie pas eu de cours Open Gl, je te remercie donc de nous faire profité de ton savoir faire...
MERCI

Commentaire de skinia le 03/08/2005 15:53:21

juste par curiosité,
licence de koi exactement tellmarch?

Commentaire de Tellmarch le 19/08/2005 11:30:48

informatique fondamentale il me semble :-)
mais bon c'est juste un nom, on suit les cours qu'on veut ou presque :-)

Commentaire de barbichette le 27/09/2005 08:42:00

Profitez les gars, car moi, je n'est que 25 ans et quand j'était en cours, il y a juste 5 à 6 ans, il n'y avait pas de cours d'OPENGL, c'était encore le temps des cours d'info en ligne de commande sous linux (pour éviter le piratage).
D'ailleur, j'ai vite arrêter le massacre des cours de cobol (c'était encore la mode...).
Alors le graphique, c'était rare, mais en 3D en plus...

Barbichette

Commentaire de Tellmarch le 27/09/2005 10:41:31

t'as pas choisi la bonne fac alors... ça fait plus de 20 ans qu'il y a des cours d'image et de 3d en info :-)

Commentaire de skinia le 27/09/2005 12:59:39

20 ans et puis quoi encore
désolé mais maintenant les études d'info sont plus tournées vers
les entreprises donc plus vers les nouvelles technologies style
J2EE ou .NET alors il peut y avoir quelques cours de programation
3D en début de cursus mais plus on va dans les études, plus ca disparait

Commentaire de Tellmarch le 27/09/2005 16:48:51

c'est toi qui choisit ce que tu veux faire comme info, si tu choisis des cours de BDD forcement y aura pas de 3d... Mais va pas te plaindre de ça :-)

Commentaire de RM50Man le 25/10/2005 23:34:55

Si en licence art et technique de l image ya des cours de 3D !!
Programmation graphique que ca...

Commentaire de RM50Man le 26/10/2005 00:03:32

J arrive pas a faire marcher ton code avec dev cpp
le compilateur me met:
[Build error][Project1]error1

Commentaire de goygoy le 26/10/2005 19:28:35

J'ai rajouté le fichier 'CasseBrique.dev' qui contient tous les parametres qu'il faut pour la compilation.

Commentaire de RM50Man le 26/10/2005 20:09:20

Maintenant ca me met
`M_PI' undeclared here (not in a function)

`RAND_MAX' undeclared (first use in this function)

Commentaire de goygoy le 27/10/2005 13:02:45

M_PI et RAND_MAX sont deux constantes que j'ai du trouvé dans un package de math(mais je sais plus où).
Donc tu peux rajouter la ligne: 'int M_PI=3.14159;'

Par contre je ne sais pas si le RAND_MAX est necessaire à la ligne 'brique[i][j][k] = (int) floor(rand()*4/RAND_MAX);'

Le but de cette instruction est d'associer à chaque brique un nombre {0,1,2,ou 3}. Par ex. le numero 3 rend la brique incassable. On pourrait dire qu'une brique de numero 2 rapporte plus de points qu'une brique 1 ou 0.

Le numero de brique est testé dans le timer, lorsque la boule rebondi sur la brique.

En conclusion: je crois que 'brique[i][j][k] = (int) floor(rand()*4);' est suffisant.

Commentaire de rei3 le 17/11/2005 10:11:12

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

Commentaire de dletozeun le 18/11/2005 22:17:09

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

Commentaire de rei3 le 19/11/2005 14:28:13

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.

Commentaire de dletozeun le 20/11/2005 15:10:45

merci pour l'information! :)

Commentaire de Je sais pas le 20/12/2006 14:50:57

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

Ajouter un commentaire

Discussions en rapport avec ce code source dans le forum

un ptit jeu [ par BLaFarD ] euh, je viens de me pondre un petit moteur 3d de merde en opengldonc, si qlqun veut me filer des model 3d k'il a fait (sous 3dsmax si possible), bah, Faire un jeu (Voiture) [ par skone007 ] Voilà depuis peu le modeuleur 3D du projet nous a quitter. Nous recherchons des personnes capables de faires des voitures et des circuits en 3D. Nou chaos game 2 en c++ [ par clira82 ] coucou je recherche de l aide pour programmer un jeu en visual c++c'est un triangle de sierpinski en recursif:Il y a un point a chaque sommet du grand casse brique pb collision [ par mat74 ] voila je suis en train de faire un casse brique et je n'arrive pas a gerer les collisions entre les briques et la balle "correctement" .je connais le projet jeu voiture 3D [ par supergrey ] Bonjour a tous.Dans le cadre de notre dernier projet de développement, nous proposons au modéliste 3D un partenariat des plus simples.En effet nous vo Pipe Game ? [ par loicus ] J'ai absolument besoin de votre aide,Je recherche le code source d'un pipe game (jeu ou il faut construire une tuyauterie au fur et a mesur que l'eau Projet de jeu sur quimper [ par vini123 ] ça y est après avoir fini mes études et connaissant une petite période de chômage j'en profite pour me lancer dans la programmation d'un moteur 3D. J' jeu casse_briques [ par ghounaya ] je veut obtenir le code sources et la simulation du jeu casse_briques en langage c++...merci lancement d'un .exe externe dans un jeu (3d, fmod) [ par aubry ] Bonjour, j'ai un problème et  c'est assez urgent...c'est pour le collège j'ai un sujet d'arts plastiques ou il faut illustrer l'ex pb lancer executable [ par mat74 ] salut a ts voila je suis en train de faire un casse brique . j'ai également fais un éditeur de niveauce sont 2 exe différent mais j'aim

Nos sponsors

Derniers Blogs

[DIVERS] SUIVRE VOS SéRIES PRéFéRéS SUR LA TOILE par orion

TECHDAYS PARIS 2010 : LA BI DANS SHAREPOINT 2010 par ROMELARD Fabrice

TECHDAYS PARIS 2010 : DéPLOIEMENT DE NOUVELLES TECHNOLOGIES - RETOUR D'EXPéRIENCE PAR L'INFORMATIQUE DE MICROSOFT par ROMELARD Fabrice

TECHDAYS PARIS 2010 : PLAN DE MIGRATION VERS SHAREPOINT 2010 par ROMELARD Fabrice

TECHDAYS PARIS 2010 : LA PLEINIèRE DU SECOND JOUR par ROMELARD Fabrice

Forum

RE : SDL ET WINDOWS.H SOUS SYGWIN par agent933

[C] RéALISATION D'UN MINI SGBD AVEC LES STRUCTURES DE DONNéES ET LES FICHIERS par abdelhaq007

SDL ET WINDOWS.H SOUS SYGWIN par agent933

WIN API par omarino_007

RE : COMMENT PILOTER LE PORT LPT SOUS VISTA? par gt70

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

PLATEFORME SUR L ESOTERISME VOYANCE - sans charte graphique
Budget : 3 500€
Joomla 15 module paiement adaptation composant cuisine
Budget : 250€
Integrateur web dans template
Budget : 500€

Logiciels

DB-MAIN (9.1.0)
DB-MAIN (9.1.0)

DB-MAIN is a data-modeling and data-architecture tool. It is designed to help developers and anal...

Cliquez pour télécharger DB-MAIN
Xilisoft DPG Convertisseur (5.1.37.0120)
XILISOFT DPG CONVERTISSEUR (5.1.37.0120)

Xilisoft DPG Convertisseur offre aux fans de Nintendo DS une bonne solution leur permettant de dé...

Cliquez pour télécharger Xilisoft DPG Convertisseur
GraphicsGale (2.01.01)
GRAPHICSGALE (2.01.01)

GraphicsGale est un logiciel de PixelArt avec de nombreuse fonctionnalités permettant de réalisé ...

Cliquez pour télécharger GraphicsGale
Architecte 3D (Platinum 2010)
ARCHITECTE 3D (PLATINUM 2010)

Architecte 3D Platinium vous permet de concevoir facilement les plans votre future maison, de l'é...

Cliquez pour télécharger Architecte 3D
TeamViewer 5 (TeamViewer 5)
TEAMVIEWER 5 (TEAMVIEWER 5)

Dépanner un ami,expliquer une manipulation devient un jeu d'enfant. Prise en main d'un autre ord...

Cliquez pour télécharger TeamViewer 5