TD : Les calculs de diffusion Lambertienne

Question 1

typedef struct couleur {
  float r ;
  float v ;
  float b ; } couleur ;

typedef struct dir_3D {
  float dx ;
  float dy ;
  float dz ; } dir_3D ;

typedef struct dirLight {
  dir_3D dir ;
  couleur coul ;
  float energie ; } dirLight ;

Question 2

typedef struct materiau {
  couleur diffusion ;
  /* couleur reflexion ; */
  /* couleur transmission ; */
  /* couleur emission ; */ } materiau ;

Question 3

Lambert02.gif (10808 octets)

typedef struct facette {
struct coord_3D pa ;
struct coord_3D pb ;
struct coord_3D pc ; } facette ;

typedef struct energie {
float er ;
float ev ;
float eb ; } energie ;

void calculEnergieRecue(coord_3D *p,
                        dirLight *l,
                        energie *e) {
e->er = l->energie * l->coul.r ;
e->ev = l->energie * l->coul.v ;
e->eb = l->energie * l->coul.b ;
}

void calculEnergieDiffusee(facette *f,
                           materiau *m,
                           dirLight *l,
                           energie *e) {
dir_3D n ;
calculNormaleFacette(f,&n);
energie recu ;
calculEnergieRecue(&f->pa,l,&recu) ;
float scal = -produitScalaire(&l->dir,&n) ;
if ( scal < 0.0F )
    scal = 0.0F ;
e->er = recu.er * scal * m->diffusion.r ;
e->ev = recu.ev * scal * m->diffusion.v ;
e->eb = recu.eb * scal * m->diffusion.b ;
}

Question 4

typedef struct coord_3D {
  float x ;
  float y ;
  float z ; } coord_3D ;

typedef struct couleur {
  float r ;
  float v ;
  float b ; } couleur ;

typedef struct pointLight {
  coord_3D pos ;
  couleur coul ;
  float energie ; } pointLight ;

Question 5

float distance(coord_3D *p1,
               coord_3D *p2) {
  double x = p1->x - p2->x ; 
  double y = p1->y - p2->y ; 
  double z = p1->z - p2->z ;
  double d2 = x*x + y*y + z*z ;
  return((float) pow(d2,0.5)) ;
} 

void calculVecteurNorme(coord_3D *pi,
                        coord_3D *pf,
                        dir_3D *n) {
  double x = pf->x - pi->x ; 
  double y = pf->y - pi->y ; 
  double z = pf->z - pi->z ;
  double d2 = distance(pi,pf) ;
  n->dx =(float) (x / d2) ;
  n->dy =(float) (y / d2) ;
  n->dz =(float) (z / d2) ;
}

void calculVecteur(coord_3D *pi,
                   coord_3D *pf,
                   dir_3D *n) {
  n->dx = pf->x - pi->x ; 
  n->dy = pf->y - pi->y ; 
  n->dz = pf->z - pi->z ;
} 

float produitScalaire(dir_3D *d1,
                      dir_3D *d2) {
  return(d1->dx*d2->dx +
         d1->dy*d2->dy +
         d1->dz*d2->dz) ;
}

void produitVectoriel(dir_3D *v1,dir_3D *v2,dir_3D *n) {
  n->dx = v1->dy*v2->dz - v1->dz*v2->dy;
  n->dy = v1->dz*v2->dx - v1->dx*v2->dz;
  n->dz = v1->dx*v2->dy - v1->dy*v2->dx;
}

void calculNormaleFacette(facette *f,dir_3D *n) {
  dir_3D v1;
  dir_3D v2;
  calculVecteur(&f->pa,&f->pb,&v1) ;
  calculVecteur(&f->pa,&f->pc,&v2) ;
  produitVectoriel(&v1,&v2,n);
  normalise(n);
}

void calculEnergieRecueSansAttenuation(coord_3D *p,
                                       pointLight *l,
                                       energie *e) {
  e->er = l->energie * l->coul.r ;
  e->ev = l->energie * l->coul.v ;
  e->eb = l->energie * l->coul.b ;
}

void calculEnergieDiffusee(coord_3D *p,
                           facette *f,
                           materiau *m,
                           pointLight *l,
                           energie *e,
                           int atten) {
  energie recu ;
  switch (atten) {
    case 0 : calculEnergieRecueSansAttenuation(p,l,&recu) ;
             break;
    case 1 : calculEnergieRecueAvecAttenuation(p,l,&recu) ;
             break; }
  dir_3D li ;
  calculVecteurNorme(&l->pos,p,&li) ;
  dir_3D n ;
  calculNormaleFacette(f,&n);
  float scal = -produitScalaire(&li,&n) ;
  if ( scal < 0.0F )
    scal = 0.0F ;
  e->er = recu.er * scal * m->diffusion.r ;
  e->ev = recu.ev * scal * m->diffusion.v ;
  e->eb = recu.eb * scal * m->diffusion.b ;
}

Question 6

void calculEnergieRecueAvecAttenuation(coord_3D *p,
pointLight *l,
energie *e) {
float d = distance(p,&l->pos) ;
float atten = 1.0F / d / d ;
e->er = atten * l->energie * l->coul.r ;
e->ev = atten * l->energie * l->coul.v ;
e->eb = atten * l->energie * l->coul.b ;
}

L'exécutable

Enter pour changer de question
1, 2, 3, 7, 8 et 9 pour changer la position de la lumière ponctuelle ou la direction de la lumière directionnelle
s et S pour jouer sur la sensibilité
e et E pour jouer sur l'énergie émise
r, R, v, V, b et B pour changer les caractéristiques chromatiques du matériau de la facette ou de la lumière ponctuelle
Espace pour choisir entre modification des caractéristiques chromatiques du matériau de la facette ou de la lumière ponctuelle
d et D pour jouer sur la discrétisation de la facette

Le source : TD-DiffusionLambert.cpp

/* Auteur: Nicolas JANEY              */
/* nicolas.janey@univ-fcomte.fr       */
/* Avril 2001                         */
/* Calculs sur l'energie diffusee     */
/* par une surface plane triangulaire */

#include <stdio.h>
#include <math.h>

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

#include "ModuleCouleurs.h"
#include "ModuleManipulateur.h"
#include "ModuleReshape.h"
#include "ModuleFont.h"
#include "ModuleFleche.h"
#include "ModuleMenus.h"

typedef struct coord_3D {
  float x ;
  float y ;
  float z ; } coord_3D ;

typedef struct couleur {
  float r ;
  float v ;
  float b ; } couleur ;

typedef struct pointLight {
  coord_3D pos ;
  couleur coul ;
  float energie ; } pointLight ;

typedef struct dir_3D {
  float dx ;
  float dy ;
  float dz ; } dir_3D ;

typedef struct dirLight {
  dir_3D dir ;
  couleur coul ;
  float energie ; } dirLight ;

typedef struct materiau {
  couleur diffusion ;
  /* couleur reflexion ; */
  /* couleur transmission ; */
  /* couleur emission ; */ } materiau ;

typedef struct facette {
  struct coord_3D pa ;
  struct coord_3D pb ;
  struct coord_3D pc ; } facette ;

typedef struct energie {
  float er ;
  float ev ;
  float eb ; } energie ;

enum {
  MATERIEL = 0,
  LUMIERE };

static int question = 0;
static int t = 3;
static float sensibilite = 1.0F;
static int modif = MATERIEL;
static pointLight pl = { {-1.0F,2.0F,2.0F},
                         {1.0F,0.5F,0.3F},
                         2.5F } ;
static dirLight dl = { {0.5F,-0.5F,-1.0F},
                       {1.0F,0.5F,0.5F},
                       2.5F } ;
static materiau m = { {0.5F,0.5F,1.0F},
                      /* {0.0F,0.0F,0.0F}, */
                      /* {0.0F,0.0F,0.0F}, */
                      /* {0.0F,0.0F,0.0F} */ } ;
static facette f = { {-1.2F,-1.5F,-0.5F},
                     { 1.1F,-0.1F, 1.4F},
                     { -0.2F, 1.1F, 0.4F} };

float distance(coord_3D *p1,
               coord_3D *p2) {
  double x = p1->x - p2->x ;
  double y = p1->y - p2->y ;
  double z = p1->z - p2->z ;
  double d2 = x*x + y*y + z*z ;
  return((float) pow(d2,0.5)) ;
}

void calculVecteurNorme(coord_3D *pi,
                        coord_3D *pf,
                        dir_3D *n) {
  double x = pf->x - pi->x ;
  double y = pf->y - pi->y ;
  double z = pf->z - pi->z ;
  double d2 = distance(pi,pf) ;
  n->dx =(float) (x / d2) ;
  n->dy =(float) (y / d2) ;
  n->dz =(float) (z / d2) ;
}

void normalise(dir_3D *n) {
  float d2 = n->dx*n->dx + n->dy*n->dy + n->dz*n->dz ;
  d2 =(float) pow((double) d2,0.5) ;
  n->dx /= d2 ;
  n->dy /= d2 ;
  n->dz /= d2 ;
}

void calculVecteur(coord_3D *pi,
                   coord_3D *pf,
                   dir_3D *n) {
  n->dx = pf->x - pi->x ;
  n->dy = pf->y - pi->y ;
  n->dz = pf->z - pi->z ;
}

float produitScalaire(dir_3D *d1,
                      dir_3D *d2) {
  return(d1->dx*d2->dx +
         d1->dy*d2->dy +
         d1->dz*d2->dz) ;
}

void produitVectoriel(dir_3D *v1,dir_3D *v2,dir_3D *n) {
  n->dx = v1->dy*v2->dz - v1->dz*v2->dy;
  n->dy = v1->dz*v2->dx - v1->dx*v2->dz;
  n->dz = v1->dx*v2->dy - v1->dy*v2->dx;
}

void calculNormaleFacette(facette *f,dir_3D *n) {
  dir_3D v1;
  dir_3D v2;
  calculVecteur(&f->pa,&f->pb,&v1) ;
  calculVecteur(&f->pa,&f->pc,&v2) ;
  produitVectoriel(&v1,&v2,n);
  normalise(n);
}

void calculEnergieRecueAvecAttenuation(coord_3D *p,
                                       pointLight *l,
                                       energie *e) {
  float d = distance(p,&l->pos) ;
  float atten = 5.0F / d / d ;
  e->er = atten * l->energie * l->coul.r ;
  e->ev = atten * l->energie * l->coul.v ;
  e->eb = atten * l->energie * l->coul.b ;
}

void calculEnergieRecueSansAttenuation(coord_3D *p,
                                       pointLight *l,
                                       energie *e) {
  e->er = l->energie * l->coul.r ;
  e->ev = l->energie * l->coul.v ;
  e->eb = l->energie * l->coul.b ;
}

void calculEnergieRecue(coord_3D *p,
                        dirLight *l,
                        energie *e) {
  e->er = l->energie * l->coul.r ;
  e->ev = l->energie * l->coul.v ;
  e->eb = l->energie * l->coul.b ;
}

void calculEnergieDiffusee(coord_3D *p,
                           facette *f,
                           materiau *m,
                           pointLight *l,
                           energie *e,
                           int atten) {
  energie recu ;
  switch (atten) {
    case 0 : calculEnergieRecueSansAttenuation(p,l,&recu) ;
             break;
    case 1 : calculEnergieRecueAvecAttenuation(p,l,&recu) ;
             break; }
  dir_3D li ;
  calculVecteurNorme(&l->pos,p,&li) ;
  dir_3D n ;
  calculNormaleFacette(f,&n);
  float scal = -produitScalaire(&li,&n) ;
  if ( scal < 0.0F )
    scal = 0.0F ;
  e->er = recu.er * scal * m->diffusion.r ;
  e->ev = recu.ev * scal * m->diffusion.v ;
  e->eb = recu.eb * scal * m->diffusion.b ;
}

void calculEnergieDiffusee(facette *f,
                           materiau *m,
                           dirLight *l,
                           energie *e) {
  dir_3D n ;
  calculNormaleFacette(f,&n);
  energie recu ;
  calculEnergieRecue(&f->pa,l,&recu) ;
  float scal = -produitScalaire(&l->dir,&n) ;
  if ( scal < 0.0F )
    scal = 0.0F ;
  e->er = recu.er * scal * m->diffusion.r ;
  e->ev = recu.ev * scal * m->diffusion.v ;
  e->eb = recu.eb * scal * m->diffusion.b ;
}

void milieu(coord_3D *p1,coord_3D *p2,coord_3D *p) {
  p->x = (p1->x+p2->x)/2.0F;
  p->y = (p1->y+p2->y)/2.0F;
  p->z = (p1->z+p2->z)/2.0F;
}

void traceFacetteSousDirectionnalLight(facette *f,
                                       materiau *m,
                                       dirLight *l) {
  energie ed ;
  calculEnergieDiffusee(f,m,l,&ed) ;
  glColor4f(ed.er*sensibilite,
            ed.ev*sensibilite,
            ed.eb*sensibilite,
            1.0F);
  glBegin(GL_POLYGON);
  glVertex3f(f->pa.x,f->pa.y,f->pa.z);
  glVertex3f(f->pb.x,f->pb.y,f->pb.z);
  glVertex3f(f->pc.x,f->pc.y,f->pc.z);
  glEnd();
}

void traceFacetteSousPointLight(facette *f,
                                int t,
                                materiau *m,
                                pointLight *l,
                                int atten) {
  if ( t == 0 ) {
    energie eda;
    energie edb;
    energie edc;
    calculEnergieDiffusee(&f->pa,f,m,l,&eda,atten) ;
    calculEnergieDiffusee(&f->pb,f,m,l,&edb,atten) ;
    calculEnergieDiffusee(&f->pc,f,m,l,&edc,atten) ;
    glBegin(GL_POLYGON);
    glColor4f(eda.er*sensibilite,
              eda.ev*sensibilite,
              eda.eb*sensibilite,
              1.0F);
    glVertex3f(f->pa.x,f->pa.y,f->pa.z);
    glColor4f(edb.er*sensibilite,
              edb.ev*sensibilite,
              edb.eb*sensibilite,
              1.0F);
    glVertex3f(f->pb.x,f->pb.y,f->pb.z);
    glColor4f(edc.er*sensibilite,
              edc.ev*sensibilite,
              edc.eb*sensibilite,
              1.0F);
    glVertex3f(f->pc.x,f->pc.y,f->pc.z);
    glEnd(); }
    else {
    coord_3D pab;
    coord_3D pac;
    coord_3D pbc;
    milieu(&f->pa,&f->pb,&pab);
    milieu(&f->pa,&f->pc,&pac);
    milieu(&f->pb,&f->pc,&pbc);
    facette ff;
    ff.pa = f->pa;
    ff.pb = pab;
    ff.pc = pac;
    traceFacetteSousPointLight(&ff,t-1,m,l,atten);
    ff.pb = f->pb;
    ff.pa = pab;
    ff.pc = pbc;
    traceFacetteSousPointLight(&ff,t-1,m,l,atten);
    ff.pc = f->pc;
    ff.pa = pac;
    ff.pb = pbc;
    traceFacetteSousPointLight(&ff,t-1,m,l,atten);
    ff.pc = pab;
    ff.pb = pac;
    ff.pa = pbc;
    traceFacetteSousPointLight(&ff,t-1,m,l,atten); }
}

void centre(facette *f,coord_3D *p) {
  p->x =(f->pa.x+f->pb.x+f->pc.x)/3.0F;
  p->y =(f->pa.y+f->pb.y+f->pc.y)/3.0F;
  p->z =(f->pa.z+f->pb.z+f->pc.z)/3.0F;
}

void questionLumiereDirectionnelle() {
  coord_3D pcentre;
  centre(&f,&pcentre);
  glPushMatrix();
  manipulateurSouris();
  manipulateurClavier();
  glEnable(GL_DEPTH_TEST);
  glColor4fv(couleurBlanc());
  traceFacetteSousDirectionnalLight(&f,&m,&dl);
  dir_3D nm ;
  calculNormaleFacette(&f,&nm);
  glPushMatrix();
  glColor4fv(couleurRouge());
  glTranslatef(pcentre.x,pcentre.y,pcentre.z);
  flecheEnVolume(nm.dx,nm.dy,nm.dz,0.05F,0.2F,0.015F) ;
  glPopMatrix();
  glPushMatrix();
  glTranslatef(-1.0F,1.0F,1.0F);
  glColor3f(pl.coul.r,pl.coul.v,pl.coul.b);
  flecheEnVolume(dl.dir.dx,dl.dir.dy,dl.dir.dz,0.05F,0.2F,0.015F) ;
  glPopMatrix();
  glPopMatrix();
  energie e ;
  energie ed ;
  glDisable(GL_DEPTH_TEST);
  float xmin = getXmin();
  float ymax = getYmax();
  float tpix = getTaillePixel();
  setAntialiased(1);
  setBold(1);
  setEcartementCaracteres(15.0F);
  glColor4fv(couleurRouge());
  strokeOutput(xmin,-ymax+70*tpix,0.65F,"Dir light");
  strokeOutput(xmin,-ymax+50*tpix,0.65F,"Couleur emise : %f %f %f\n",pl.coul.r,pl.coul.v,pl.coul.b);
  strokeOutput(xmin,-ymax+30*tpix,0.65F,"Energie emise : %f\n",pl.energie);
  strokeOutput(xmin,-ymax+10*tpix,0.65F,"Direction : %f %f %f\n",pl.pos.x,pl.pos.y,pl.pos.z);
  strokeOutput(xmin,ymax-16*tpix,0.65F,"Materiau : %f %f %f\n",m.diffusion.r,m.diffusion.v,m.diffusion.b) ;
  calculEnergieRecue(&pcentre,&dl,&e) ;
  strokeOutput(xmin,ymax-36*tpix,0.65F,"Energie recue : %f %f %f\n",e.er,e.ev,e.eb) ;
  calculEnergieDiffusee(&f,&m,&dl,&ed) ;
  strokeOutput(xmin,ymax-56*tpix,0.65F,"Energie diffusee : %f %f %f\n",ed.er,ed.ev,ed.eb) ;
  setAntialiased(0);
  setBold(0);
  setEcartementCaracteres(0.0F);
}

void questionLumierePonctuelle() {
  coord_3D pcentre;
  centre(&f,&pcentre);
  energie e ;
  energie ed ;
  glPushMatrix();
  manipulateurSouris();
  manipulateurClavier();
  glEnable(GL_DEPTH_TEST);
  traceFacetteSousPointLight(&f,t,&m,&pl,0);
  glPushMatrix();
  glTranslatef(pl.pos.x,pl.pos.y,pl.pos.z);
  glColor3f(pl.coul.r,pl.coul.v,pl.coul.b);
  glutSolidSphere(0.05F,20,20);
  glPopMatrix();
  dir_3D nm ;
  calculNormaleFacette(&f,&nm);
  glPushMatrix();
  glColor4fv(couleurRouge());
  glTranslatef(pcentre.x,pcentre.y,pcentre.z);
  flecheEnVolume(nm.dx,nm.dy,nm.dz,0.05F,0.2F,0.015F) ;
  glPopMatrix();
  glPopMatrix();
  glDisable(GL_DEPTH_TEST);
  float xmin = getXmin();
  float ymax = getYmax();
  float tpix = getTaillePixel();
  setAntialiased(1);
  setBold(1);
  setEcartementCaracteres(15.0F);
  glColor4fv(couleurBlanc());
  strokeOutput(xmin,-ymax+70*tpix,0.65F,"Point light");
  strokeOutput(xmin,-ymax+50*tpix,0.65F,"Couleur emise : %f %f %f\n",pl.coul.r,pl.coul.v,pl.coul.b);
  strokeOutput(xmin,-ymax+30*tpix,0.65F,"Energie emise : %f\n",pl.energie);
  strokeOutput(xmin,-ymax+10*tpix,0.65F,"Position : %f %f %f\n",pl.pos.x,pl.pos.y,pl.pos.z);
  strokeOutput(xmin,ymax-16*tpix,0.65F,"Materiau : %f %f %f\n",m.diffusion.r,m.diffusion.v,m.diffusion.b) ;
  calculEnergieRecueSansAttenuation(&pcentre,&pl,&e) ;
  strokeOutput(xmin,ymax-36*tpix,0.65F,"Energie recue : %f %f %f\n",e.er,e.ev,e.eb) ;
  calculEnergieDiffusee(&pcentre,&f,&m,&pl,&ed,0) ;
  strokeOutput(xmin,ymax-56*tpix,0.65F,"Energie diffusee : %f %f %f\n",ed.er,ed.ev,ed.eb) ;
  setAntialiased(0);
  setBold(0);
  setEcartementCaracteres(0.0F);
}

void questionLumierePonctuelleAttenuation() {
  coord_3D pcentre;
  centre(&f,&pcentre);
  energie e ;
  energie ed ;
  glPushMatrix();
  manipulateurSouris();
  manipulateurClavier();
  glEnable(GL_DEPTH_TEST);
  glColor4fv(couleurBlanc());
  traceFacetteSousPointLight(&f,t,&m,&pl,1);
  glPushMatrix();
  glTranslatef(pl.pos.x,pl.pos.y,pl.pos.z);
  glColor3f(pl.coul.r,pl.coul.v,pl.coul.b);
  glutSolidSphere(0.05F,20,20);
  glPopMatrix();
  dir_3D nm ;
  calculNormaleFacette(&f,&nm);
  glPushMatrix();
  glColor4fv(couleurRouge());
  glTranslatef(pcentre.x,pcentre.y,pcentre.z);
  flecheEnVolume(nm.dx,nm.dy,nm.dz,0.05F,0.2F,0.015F) ;
  glPopMatrix();
  glPopMatrix();
  glDisable(GL_DEPTH_TEST);
  float xmin = getXmin();
  float ymax = getYmax();
  float tpix = getTaillePixel();
  setAntialiased(1);
  setBold(1);
  setEcartementCaracteres(15.0F);
  glColor4fv(couleurBlanc());
  strokeOutput(xmin,-ymax+70*tpix,0.65F,"Point light");
  strokeOutput(xmin,-ymax+50*tpix,0.65F,"Couleur emise : %f %f %f\n",pl.coul.r,pl.coul.v,pl.coul.b);
  strokeOutput(xmin,-ymax+30*tpix,0.65F,"Energie emise : %f\n",pl.energie);
  strokeOutput(xmin,-ymax+10*tpix,0.65F,"Position : %f %f %f\n",pl.pos.x,pl.pos.y,pl.pos.z);
  strokeOutput(xmin,ymax-16*tpix,0.65F,"Materiau : %f %f %f\n",m.diffusion.r,m.diffusion.v,m.diffusion.b) ;
  calculEnergieRecueAvecAttenuation(&pcentre,&pl,&e) ;
  strokeOutput(xmin,ymax-36*tpix,0.65F,"Energie recue : %f %f %f\n",e.er,e.ev,e.eb) ;
  calculEnergieDiffusee(&pcentre,&f,&m,&pl,&ed,1) ;
  strokeOutput(xmin,ymax-56*tpix,0.65F,"Energie diffusee : %f %f %f\n",ed.er,ed.ev,ed.eb) ;
  setAntialiased(0);
  setBold(0);
  setEcartementCaracteres(0.0F);
}

void display() {
  glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
  glPushMatrix();
  switch ( question ) {
    case 0 : questionLumierePonctuelle();
             break;
    case 1 : questionLumierePonctuelleAttenuation();
             break;
    case 2 : questionLumiereDirectionnelle();
             break;}
  glPopMatrix();
  glutSwapBuffers();
}

void key(unsigned char key,int x,int y) {
  if ( keyManipulateur(key,x,y) )
    glutPostRedisplay();
    else
  switch ( key ) {
    case '1'    : if ( question == 2 )
                    dl.dir.dx -= 0.05F;
                    else
                    pl.pos.x -= 0.05F;
                  break;
    case '7'    : if ( question == 2 )
                    dl.dir.dx += 0.05F;
                    else
                    pl.pos.x += 0.05F;
                  break;
    case '2'    : if ( question == 2 )
                    dl.dir.dy -= 0.05F;
                    else
                    pl.pos.y -= 0.05F;
                  break;
    case '8'    : if ( question == 2 )
                    dl.dir.dy += 0.05F;
                    else
                    pl.pos.y += 0.05F;
                  break;
    case '3'    : if ( question == 2 )
                    dl.dir.dz -= 0.05F;
                    else
                    pl.pos.z -= 0.05F;
                  break;
    case '9'    : if ( question == 2 )
                    dl.dir.dz += 0.05F;
                    else
                    pl.pos.z += 0.05F;
                  break;
    case 's'    : sensibilite /= 1.02F;
                  break;
    case 'S'    : sensibilite *= 1.02F;
                  break;
    case 'e'    : if ( question == 2 )
                    dl.energie /= 1.02F;
                    else
                    pl.energie /= 1.02F;
                  break;
    case 'E'    : if ( question == 2 )
                    dl.energie *= 1.02F;
                    else
                    pl.energie *= 1.02F;
                  break;
    case 'R'    : switch ( modif ) {
                    case MATERIEL : m.diffusion.r += 0.01F;
                                     if ( m.diffusion.r > 1.0F )
                                       m.diffusion.r = 1.0F ;
                                    break;
                    case LUMIERE  : pl.coul.r += 0.01F;
                                     if ( pl.coul.r > 1.0F )
                                       pl.coul.r = 1.0F ;
                                    break; }
                  break;
    case 'r'    : switch ( modif ) {
                    case MATERIEL : m.diffusion.r -= 0.01F;
                                     if ( m.diffusion.r < 0.0F )
                                       m.diffusion.r = 0.0F ;
                                    break;
                    case LUMIERE  : pl.coul.r -= 0.01F;
                                     if ( pl.coul.r < 0.0F )
                                       pl.coul.r = 0.0F ;
                                    break; }
                  break;
    case 'V'    : switch ( modif ) {
                    case MATERIEL : m.diffusion.v += 0.01F;
                                     if ( m.diffusion.v > 1.0F )
                                       m.diffusion.v = 1.0F ;
                                    break;
                    case LUMIERE  : pl.coul.v += 0.01F;
                                     if ( pl.coul.v > 1.0F )
                                       pl.coul.v = 1.0F ;
                                    break; }
                  break;
    case 'v'    : switch ( modif ) {
                    case MATERIEL : m.diffusion.v -= 0.01F;
                                     if ( m.diffusion.v < 0.0F )
                                       m.diffusion.v = 0.0F ;
                                    break;
                    case LUMIERE  : pl.coul.v -= 0.01F;
                                     if ( pl.coul.v < 0.0F )
                                       pl.coul.v = 0.0F ;
                                    break; }
                  break;
    case 'B'    : switch ( modif ) {
                    case MATERIEL : m.diffusion.b += 0.01F;
                                     if ( m.diffusion.b > 1.0F )
                                       m.diffusion.b = 1.0F ;
                                    break;
                    case LUMIERE  : pl.coul.b += 0.01F;
                                     if ( pl.coul.b > 1.0F )
                                       pl.coul.b = 1.0F ;
                                    break; }
                  break;
    case 'b'    : switch ( modif ) {
                    case MATERIEL : m.diffusion.b -= 0.01F;
                                     if ( m.diffusion.b < 0.0F )
                                       m.diffusion.b = 0.0F ;
                                    break;
                    case LUMIERE  : pl.coul.b -= 0.01F;
                                     if ( pl.coul.b < 0.0F )
                                       pl.coul.b = 0.0F ;
                                    break; }
                  break;
    case 'd'    : t--;
                  if ( t < 0 )
                    t = 0 ;
                  break;
    case 'D'     : t++;
                  if ( t > 6 )
                    t = 6;
                  break;
    case 32     : modif = (modif+1)%2;
                  break;
    case 0x0D   : question = (question+1)%3;
                  break; }
  glutPostRedisplay();
}

void special(int k,int x,int y) {
  if ( specialManipulateur(k,x,y) )
    glutPostRedisplay();
    else
    switch (k) {
      case GLUT_KEY_F1    : modif = MATERIEL ;
                            glutPostRedisplay();
                            break;
      case GLUT_KEY_F2    : modif = LUMIERE ;
                            glutPostRedisplay();
                            break; }
}

void myInit() {
  glEnable(GL_AUTO_NORMAL);
  glEnable(GL_NORMALIZE);
  glShadeModel(GL_SMOOTH);
}

int main(int argc,char **argv) {
  glutInit(&argc,argv);
  glutInitWindowSize(400,400);
  glutInitWindowPosition(50,50);
  glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_DOUBLE);
  glutCreateWindow("Calcul diffusions");
  myInit();
  creationMenuBasique();
  setParametresOrthoBasique(-6.0,6.0,-6.0,6.0,-500.0,500.0);
  setManipulateurDistance(1.0F);
  glutReshapeFunc(reshapeOrthoBasique);
  glutMotionFunc(motionBasique);
  glutMouseFunc(sourisBasique);
  glutKeyboardFunc(key);
  glutSpecialFunc(special);
  glutDisplayFunc(display);
  glutMainLoop();
  return(0);
}

Les modules utilitaires : Modules.zip

RETOUR