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