L'exécutable

Objet.h

/* Auteur: Nicolas JANEY              */
/* nicolas.janey@univ-fcomte.fr       */
/* Octobre 2005                       */
/* Superclasse de gestion d'objets    */

#ifndef OBJET
#define OBJET

class Objet {
  public :
    Objet(void);
    ~Objet(void);
    void print(char *format);
    void dessine(void);
};

#endif

Objet.cpp

/* Auteur: Nicolas JANEY              */
/* nicolas.janey@univ-fcomte.fr       */
/* Octobre 2005                       */
/* Superclasse de gestion d'objets    */

#include "ModuleFont.h"

#include "Objet.h"

Objet::Objet(void) {
}

Objet::~Objet(void) {
}

void Objet::dessine(void) {
}

void Objet::print(char *format) {
  simpleBitmapOutput(1,REGULAR8x13,"%p",this);
}

Vecteur.h

/* Auteur: Nicolas JANEY             */
/* nicolas.janey@univ-fcomte.fr      */
/* Octobre 2005                      */
/* Classe de gestion de vecteurs     */
/* a quatre coordonnees              */

#ifndef VECTEUR
#define VECTEUR

#include "Objet.h"

class Vecteur : public Objet {
  public :
    float x;
    float y;
    float z;
    float t;

  public :
    Vecteur(void);
    Vecteur(float x,float y,float z,float t);
    ~Vecteur(void);
    void print(char *format);
};

#endif

Vecteur.cpp

/* Auteur: Nicolas JANEY             */
/* nicolas.janey@univ-fcomte.fr      */
/* Octobre 2005                      */
/* Classe de gestion de vecteurs     */
/* a quatre coordonnees              */

#include "ModuleFont.h"

#include "Vecteur.h"

Vecteur::Vecteur(void) {
  this->x = 0.0F;
  this->y = 0.0F;
  this->z = 0.0F;
  this->t = 0.0F;
}

Vecteur::Vecteur(float x,float y,float z,float t) {
  this->x = x;
  this->y = y;
  this->z = z;
  this->t = t;
}

Vecteur::~Vecteur(void) {
}

void Vecteur::print(char *format) {
  simpleBitmapOutput(1,REGULAR8x13,format,x,y,z);
}

Position.h

/* Auteur: Nicolas JANEY             */
/* nicolas.janey@univ-fcomte.fr      */
/* Octobre 2005                      */
/* Classe de gestion de positions 3D */
/* en coordonnees homogenes          */

#ifndef POSITION
#define POSITION

#include "Vecteur.h"

class Position : public Vecteur {
  public :
    Position(void);
    Position(float x,float y,float z);
    Position(Position *p);
    ~Position(void);
    float Position::distance(Position *p);
    void dessine(void);
};

#endif

Position.cpp

/* Auteur: Nicolas JANEY             */
/* nicolas.janey@univ-fcomte.fr      */
/* Octobre 2005                      */
/* Classe de gestion de positions 3D */
/* en coordonnees homogenes          */

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

#include <math.h>

#include "Position.h"

Position::Position(void) : Vecteur(0.0F,0.0F,0.0F,1.0F) {
}

Position::Position(float x,float y,float z) : Vecteur(x,y,z,1.0F) {
}

Position::Position(Position *p) : Vecteur(p->x,p->y,p->z,1.0F) {
}

Position::~Position(void) {
}

float Position::distance(Position *p) {
  float dx = p->x-x;
  float dy = p->y-y;
  float dz = p->z-z;
  return((float) sqrt(dx*dx+dy*dy+dz*dz));


void Position::dessine(void) {
  glPushMatrix();
  glTranslatef(x,y,z);
  glutSolidSphere(0.1,36,36);
  glPopMatrix();
}

Direction.h

/* Auteur: Nicolas JANEY              */
/* nicolas.janey@univ-fcomte.fr       */
/* Octobre 2005                       */
/* Classe de gestion de directions 3D */
/* en coordonnees homogenes           */

#ifndef DIRECTION
#define DIRECTION

#include "Position.h"
#include "Vecteur.h"

class Direction : public Vecteur {
  public :
    Direction(void);
    Direction(float x,float y,float z);
    Direction(Position *p1,Position *p2);
    Direction(Direction *d);
    ~Direction(void);
    float norme(void);
    void normalise(void);
    float produitScalaire(Direction *d);
    void produitVectoriel(Direction *d1,Direction *d2);
    int estVecteurNul(void);
    int estColineaire(Direction *d);
};

#endif

Direction.cpp

/* Auteur: Nicolas JANEY              */
/* nicolas.janey@univ-fcomte.fr       */
/* Octobre 2005                       */
/* Classe de gestion de directions 3D */
/* en coordonnees homogenes           */

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

#include "ModuleFont.h"

#include "Direction.h"
#include "Position.h"

Direction::Direction(void) : Vecteur(0.0F,0.0F,0.0F,0.0F) {
}

Direction::Direction(float x,float y,float z) : Vecteur(x,y,z,0.0F) {
}

Direction::Direction(Position *p1,Position *p2) : Vecteur(p2->x-p1->x,p2->y-p1->y,p2->z-p1->z,0.0F) {
}

Direction::Direction(Direction *d) : Vecteur(d->x,d->y,d->z,1.0F) {
}

Direction::~Direction(void) {
}

float Direction::norme() {
  return((float) pow(pow((double) x,2.0)+pow((double) y,2.0)+pow((double) z,2.0),0.5));
}

void Direction::normalise(void) {
  float n = norme();
  if ( n != 0 ) {
    x /= n;
    y /= n;
    z /= n; }
}

float Direction::produitScalaire(Direction *d2) {
  return(x*d2->x+y*d2->y+z*d2->z);
}

void Direction::produitVectoriel(Direction *d1,Direction *d2) {
  Direction *d = new Direction(d1->y*d2->z-d1->z*d2->y,
                               d1->z*d2->x-d1->x*d2->z,
                               d1->x*d2->y-d1->y*d2->x);
  x = d->x;
  y = d->y;
  z = d->z;
  t = 0.0F;
  delete(d);
}

int Direction::estVecteurNul(void) {
  if ( fabs(x) > 0.000001F )
    return(0);
  if ( fabs(y) > 0.000001F )
    return(0);
  if ( fabs(z) > 0.000001F )
    return(0);
  return(1);
}

int Direction::estColineaire(Direction *d2) {
  Direction *pv = new Direction();
  pv->produitVectoriel(d2,this);
  if ( fabs(pv->x) > 0.000001F )
    return(0);
  if ( fabs(pv->y) > 0.000001F )
    return(0);
  if ( fabs(pv->z) > 0.000001F )
    return(0);
  return(1);
}

Triangle.h

/* Auteur: Nicolas JANEY                       */
/* nicolas.janey@univ-fcomte.fr                */
/* Octobre 2005                                */
/* Classe de gestion de facettes triangulaires */

#ifndef TRIANGLE
#define TRIANGLE

#include "Position.h"
#include "Direction.h"
#include "Objet.h"

class Triangle : public Objet {
  public :
    Position *p1;
    Position *p2;
    Position *p3;
    Direction *d1;
    Direction *d2;

  public :
    Triangle(void);
    Triangle(Position *p1,Position *p2,Position *p3);
    Triangle(Position *p1,Direction *d1,Direction *d2);
    ~Triangle(void);
    Direction *normale(void);
    int estParallele(Triangle *t);
    void dessine();
 };

#endif

Triangle.cpp

/* Auteur: Nicolas JANEY                       */
/* nicolas.janey@univ-fcomte.fr                */
/* Octobre 2005                                */
/* Classe de gestion de facettes triangulaires */

#include <stdlib.h>
#include <math.h>

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

#include "ModuleFleche.h"

#include "Triangle.h"

Triangle::Triangle(void) {
  this->p1 = NULL;
  this->p2 = NULL;
  this->p3 = NULL;
  this->d1 = NULL;
  this->d2 = NULL;
}

Triangle::Triangle(Position *p1,Position *p2,Position *p3){
  this->p1 = p1;
  this->p2 = p2;
  this->p3 = p3;
  this->d1 = new Direction(p1,p2);
  this->d2 = new Direction(p1,p3);
}

Triangle::Triangle(Position *p1,Direction *d1,Direction *d2){
  this->p1 = p1;
  this->d1 = d1;
  this->d2 = d2;
  this->p2 = new Position(p1->x+d1->x,p1->y+d1->y,p1->z+d1->z);
  this->p3 = new Position(p1->x+d2->x,p1->y+d2->y,p1->z+d2->z);
}

Triangle::~Triangle(void){
}

Direction* Triangle::normale(void){
  Direction *d = new Direction();
  d->produitVectoriel(d1,d2);
  d->normalise();
  return(d);
}

int Triangle::estParallele(Triangle *t) {
  Direction *d = new Direction();
  d->produitVectoriel(d1,d2);
  { float ps = d->produitScalaire(t->d1);
    if ( fabs(ps) > 0.000001F )
      return(0); }
  { float ps = d->produitScalaire(t->d2);
    if ( fabs(ps) > 0.000001F )
      return(0); }
  return(1);
}

void Triangle::dessine() {
  p1->dessine();
  glPushMatrix();
  glTranslatef(p1->x,p1->y,p1->z);
  flecheEnVolume(d1->x,d1->y,d1->z,0.1F,0.5F,0.025F);
  flecheEnVolume(d2->x,d2->y,d2->z,0.1F,0.5F,0.025F);
  Direction *n = normale();
  glBegin(GL_POLYGON);
  glNormal3f(n->x,n->y,n->z);
  glVertex3f(0.0F,0.0F,0.0F);
  glVertex3f(d1->x,d1->y,d1->z);
  glVertex3f(d2->x,d2->y,d2->z);
  glEnd();
  glPopMatrix();
}

MathematiquesInfographie.cpp

/* Auteur: Nicolas JANEY             */
/* nicolas.janey@univ-fcomte.fr      */
/* Octobre 2005                      */
/* Calculs mathematiques             */
/* sur les vecteurs et les facettes  */

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

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

#include "Position.h"
#include "Direction.h"
#include "Triangle.h"

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

static int question = 0;
static int f1 ;
static int f2 ;
static Direction *v1;
static Direction *v2;
static Triangle *t;
static Direction *v11 = new Direction(1.9F,0.0F,0.0F);
static Direction *v21 = new Direction(0.0F,1.8F,0.0F);
static Direction *v12 = new Direction(1.5F,1.0F,1.0F);
static Direction *v22 = new Direction(-1.0F,-1.2F,-1.8F);
static Position *p1 = new Position(-1.3F,1.6F,-1.5F);
static Position *p2 = new Position(1.7F,-1.2F, 1.8F);
static Direction *v = new Direction();
static Direction *n = new Direction();
static Direction *pv = new Direction();
static Triangle *f = new Triangle(new Position(-1.5F,-1.3F,-0.6F),
                                  new Direction(3.0F,-0.2F,3.1F),
                                  new Direction(2.4F,2.8F,0.3F));
static Triangle *t1 = new Triangle(new Position(-1.8F,-0.6F,1.1F),
                                   new Direction(3.0F,-0.2F,3.1F),
                                   new Direction(2.4F,2.8F,0.3F));
static Triangle *t2 = new Triangle(new Position(-1.8F,-0.6F,1.1F),
                                   new Direction(3.0F,-0.2F,3.1F),
                                   new Direction(2.1F,2.3F,1.8F));

void scene1(void) {
  glDisable(GL_LIGHTING);
  axes();
  glEnable(GL_LIGHTING);
  glPushMatrix();
  glTranslatef(p1->x,p1->y,p1->z);
  v = new Direction(p1,p2);
  glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,couleurVert());
  flecheEnVolume(v->x,v->y,v->z,0.1F,0.5F,0.025F);
  n = new Direction(p1,p2);
  n->normalise();
  glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,couleurRouge());
  flecheEnVolume(n->x,n->y,n->z,0.1F,0.5F,0.04F);
  glPopMatrix();
  glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,couleurJaune());
  p1->dessine();
  glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,couleurBleu());
  p2->dessine();
}

void display1() {
  glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
  glPushMatrix();
  manipulateurSouris();
  manipulateurClavier();
  scene1();
  glPopMatrix();
  glFlush();
  glutSwapBuffers();
  glutPostWindowRedisplay(f2);
  int error = glGetError();
  if ( error != GL_NO_ERROR )
    printf("Attention, erreur OpenGL %d\n",error);
}

void scene2() {
  glDisable(GL_LIGHTING);
  axes();
  glEnable(GL_LIGHTING);
  glPushMatrix();
  glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,couleurVert());
  flecheEnVolume(v1->x,v1->y,v1->z,0.1F,0.5F,0.025F);
  glPopMatrix();
  glPushMatrix();
  glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,couleurRouge());
  flecheEnVolume(v2->x,v2->y,v2->z,0.1F,0.5F,0.025F);
  glPopMatrix();
  pv->produitVectoriel(v1,v2);
  glPushMatrix();
  glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,couleurJaune());
  flecheEnVolume(pv->x,pv->y,pv->z,0.1F,0.5F,0.025F);
  glPopMatrix();
}

void display2() {
  v1 = v11;
  v2 = v21;
  glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
  glPushMatrix();
  manipulateurSouris();
  manipulateurClavier();
  scene2();
  glPopMatrix();
  glFlush();
  glutSwapBuffers();
  glutPostWindowRedisplay(f2);
  int error = glGetError();
  if ( error != GL_NO_ERROR )
    printf("Attention, erreur OpenGL %d\n",error);
}

void display3() {
  v1 = v12;
  v2 = v22;
  glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
  glPushMatrix();
  manipulateurSouris();
  manipulateurClavier();
  scene2();
  glPopMatrix();
  glFlush();
  glutSwapBuffers();
  glutPostWindowRedisplay(f2);
  int error = glGetError();
  if ( error != GL_NO_ERROR )
    printf("Attention, erreur OpenGL %d\n",error);
}

void scene4(void) {
  glDisable(GL_LIGHTING);
  axes();
  glEnable(GL_LIGHTING);
  glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,couleurBleu());
  f->p1->dessine();
  glPushMatrix();
  glTranslatef(f->p1->x,f->p1->y,f->p1->z);
  flecheEnVolume(f->d1->x,f->d1->y,f->d1->z,0.1F,0.5F,0.025F);
  flecheEnVolume(f->d2->x,f->d2->y,f->d2->z,0.1F,0.5F,0.025F);
  glPopMatrix();
  n = f->normale();
  glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,couleurBlanc());
  glPushMatrix();
  glTranslatef(f->p1->x+(f->d1->x+f->d2->x)/3.0F,
               f->p1->y+(f->d1->y+f->d2->y)/3.0F,
               f->p1->z+(f->d1->z+f->d2->z)/3.0F);
  flecheEnVolume(n->x,n->y,n->z,0.1F,0.5F,0.025F);
  glPopMatrix();
  glPushMatrix();
  glMaterialfv(GL_FRONT,GL_DIFFUSE,couleurRouge(0.5F));
  glMaterialfv(GL_BACK,GL_DIFFUSE,couleurVert(0.5F));
  glTranslatef(f->p1->x,f->p1->y,f->p1->z);
  glBegin(GL_POLYGON);
  glNormal3f(n->x,n->y,n->z);
  glVertex3f(0.0F,0.0F,0.0F);
  glVertex3f(f->d1->x,f->d1->y,f->d1->z);
  glVertex3f(f->d2->x,f->d2->y,f->d2->z);
  glEnd();
  glPopMatrix();
}

void display4() {
  glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
  glPushMatrix();
  manipulateurSouris();
  manipulateurClavier();
  scene4();
  glPopMatrix();
  glFlush();
  glutSwapBuffers();
  glutPostWindowRedisplay(f2);
  int error = glGetError();
  if ( error != GL_NO_ERROR )
    printf("Attention, erreur OpenGL %d\n",error);
}

void scene5(void) {
  glDisable(GL_LIGHTING);
  axes();
  glEnable(GL_LIGHTING);
  glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,couleurRouge(0.5F));
  f->dessine();
  glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,couleurBleu(0.5F));
  t->dessine();
}

void display5() {
  t = t1;
  glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
  glPushMatrix();
  manipulateurSouris();
  manipulateurClavier();
  scene5();
  glPopMatrix();
  glFlush();
  glutSwapBuffers();
  glutPostWindowRedisplay(f2);
  int error = glGetError();
  if ( error != GL_NO_ERROR )
    printf("Attention, erreur OpenGL %d\n",error);
}

void display6() {
  t = t2;
  glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
  glPushMatrix();
  manipulateurSouris();
  manipulateurClavier();
  scene5();
  glPopMatrix();
  glFlush();
  glutSwapBuffers();
  glutPostWindowRedisplay(f2);
  int error = glGetError();
  if ( error != GL_NO_ERROR )
    printf("Attention, erreur OpenGL %d\n",error);
}

void displayV1(void) {
  glClearColor(0.0F,0.0F,0.0F,1.0F) ;
  glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
  glPushMatrix();
  float pos = 1.0F;
  glColor4fv(couleurJaune());
  placeFontCursor(5.0F,-pos*20.0F,0.0F) ;
  p1->print("P1    :  %8.4f %8.4f %8.4f");
  pos += 1.0F;
  glColor4fv(couleurBleu());
  placeFontCursor(5.0F,-pos*20.0F,0.0F) ;
  p2->print("P2    :  %8.4f %8.4f %8.4f");
  pos += 1.0F;
  glColor4fv(couleurVert());
  placeFontCursor(5.0F,-pos*20.0F,0.0F) ;
  v->print("V     :  %8.4f %8.4f %8.4f");
  pos += 1.0F;
  glColor4fv(couleurBlanc());
  placeFontCursor(5.0F,-pos*20.0F,0.0F) ;
  simpleBitmapOutput(1,REGULAR8x13,"NORME :  %8.4f",v->norme());
  pos += 1.0F;
  glColor4fv(couleurRouge());
  placeFontCursor(5.0F,-pos*20.0F,0.0F) ;
  n->print("N     :  %8.4f %8.4f %8.4f");
  glPopMatrix();
  glFlush();
  glutSwapBuffers();
}

void displayV2(void) {
  glClearColor(0.0F,0.0F,0.0F,1.0F) ;
  glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
  glPushMatrix();
  float pos = 1.0F;
  glColor4fv(couleurVert());
  placeFontCursor(5.0F,-pos*20.0F,0.0F) ;
  v1->print("V1    :  %8.4f %8.4f %8.4f");
  pos += 1.0F;
  glColor4fv(couleurRouge());
  placeFontCursor(5.0F,-pos*20.0F,0.0F) ;
  v2->print("V2    :  %8.4f %8.4f %8.4f");
  pos += 1.0F;
  glColor4fv(couleurBlanc());
  placeFontCursor(5.0F,-pos*20.0F,0.0F) ;
  simpleBitmapOutput(1,REGULAR8x13,"V1.V2 :  %8.4f",v1->produitScalaire(v2));
  pos += 1.0F;
  glColor4fv(couleurJaune());
  placeFontCursor(5.0F,-pos*20.0F,0.0F) ;
  pv->print("V1^V2 :  %8.4f %8.4f %8.4f");
  glPopMatrix();
  glFlush();
  glutSwapBuffers();
}

void displayV4(void) {
  glClearColor(0.0F,0.0F,0.0F,1.0F) ;
  glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
  glPushMatrix();
  float pos = 1.0F;
  glColor4fv(couleurBleu());
  placeFontCursor(5.0F,-pos*20.0F,0.0F) ;
  f->p1->print("P  :  %8.4f %8.4f %8.4f");
  pos += 1.0F;
  glColor4fv(couleurRouge());
  placeFontCursor(5.0F,-pos*20.0F,0.0F) ;
  f->d1->print("D1 :  %8.4f %8.4f %8.4f");
  pos += 1.0F;
  glColor4fv(couleurRouge());
  placeFontCursor(5.0F,-pos*20.0F,0.0F) ;
  f->d2->print("D2 :  %8.4f %8.4f %8.4f");
  pos += 1.0F;
  glColor4fv(couleurBlanc());
  placeFontCursor(5.0F,-pos*20.0F,0.0F) ;
  n->print("N  :  %8.4f %8.4f %8.4f");
  glPopMatrix();
  glFlush();
  glutSwapBuffers();
}

void displayV5(void) {
  glClearColor(0.0F,0.0F,0.0F,1.0F) ;
  glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
  glPushMatrix();
  float pos = 1.0F;
  glColor4fv(couleurRouge());
  placeFontCursor(5.0F,-pos*20.0F,0.0F) ;
  f->p1->print("F1 P  :  %8.4f %8.4f %8.4f");
  pos += 1.0F;
  placeFontCursor(5.0F,-pos*20.0F,0.0F) ;
  f->d1->print("F1 D1 :  %8.4f %8.4f %8.4f");
  pos += 1.0F;
  placeFontCursor(5.0F,-pos*20.0F,0.0F) ;
  f->d2->print("F1 D2 :  %8.4f %8.4f %8.4f");
  pos += 1.0F;
  glColor4fv(couleurBleu());
  placeFontCursor(5.0F,-pos*20.0F,0.0F) ;
  t->p1->print("F2 P  :  %8.4f %8.4f %8.4f");
  pos += 1.0F;
  placeFontCursor(5.0F,-pos*20.0F,0.0F) ;
  t->d1->print("F2 D1 :  %8.4f %8.4f %8.4f");
  pos += 1.0F;
  placeFontCursor(5.0F,-pos*20.0F,0.0F) ;
  t->d2->print("F2 D2 :  %8.4f %8.4f %8.4f");
  pos += 1.0F;
  glColor4fv(couleurBlanc());
  placeFontCursor(5.0F,-pos*20.0F,0.0F) ;
  if ( f->estParallele(t) )
    simpleBitmapOutput(1,REGULAR8x13,"FACETTES PARALLELES");
    else
    simpleBitmapOutput(1,REGULAR8x13,"FACETTES NON PARALLELES");
  glPopMatrix();
  glFlush();
  glutSwapBuffers();
}

void special(int key,int x,int y) {
  if ( specialManipulateur(key,x,y) ) {
    glutPostWindowRedisplay(f1); }
}

void key(unsigned char k,int x,int y) {
  if ( keyManipulateur(k,x,y) )
    glutPostWindowRedisplay(f1);
    else
    switch ( k ) {
      case 0x0D   : { question = (question+1)%6;
                      int win = glutGetWindow();
                      switch ( question ) {
                        case 0 : glutSetWindow(f1);
                                 glutDisplayFunc(display1);
                                 glutSetWindow(f2);
                                 glutReshapeWindow(370,110);
                                 glutDisplayFunc(displayV1);
                                 break;
                        case 1 : glutSetWindow(f1);
                                 glutDisplayFunc(display2);
                                 glutSetWindow(f2);
                                 glutReshapeWindow(370,90);
                                 glutDisplayFunc(displayV2);
                                 break;
                        case 2 : glutSetWindow(f1);
                                 glutDisplayFunc(display3);
                                 glutSetWindow(f2);
                                 glutReshapeWindow(370,90);
                                 glutDisplayFunc(displayV2);
                                 break;
                        case 3 : glutSetWindow(f1);
                                 glutDisplayFunc(display4);
                                 glutSetWindow(f2);
                                 glutReshapeWindow(370,90);
                                 glutDisplayFunc(displayV4);
                                 break;
                        case 4 : glutSetWindow(f1);
                                 glutDisplayFunc(display5);
                                 glutSetWindow(f2);
                                 glutReshapeWindow(370,150);
                                 glutDisplayFunc(displayV5);
                                 break;
                        case 5 : glutSetWindow(f1);
                                 glutDisplayFunc(display6);
                                 glutSetWindow(f2);
                                 glutReshapeWindow(370,150);
                                 glutDisplayFunc(displayV5);
                                 break; }
                      glutSetWindow(win);
                      glutPostWindowRedisplay(f1); }
                    break ; }
}

void myInit() {
  glEnable(GL_AUTO_NORMAL);
  glEnable(GL_NORMALIZE);
  glEnable(GL_DEPTH_TEST);
  glEnable(GL_LIGHT0);
  glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,1);
  glShadeModel(GL_SMOOTH);
  glEnable(GL_BLEND);
  glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  glClearColor(0.5F,0.5F,0.5F,1.0F);
}

void reshapeV(int w,int h) {
  glViewport(0,0,w,h);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glOrtho(0,w,-h,0,-1.0,1.0); 
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
}

int main(int argc,char **argv) {
  glutInit(&argc,argv);
  glutInitWindowSize(270,270);
  glutInitWindowPosition(50,50);
  glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_DOUBLE);
  f1 = glutCreateWindow("Mathematiques de l'infographie");
  myInit();
  creationMenuBasique();
  setParametresOrthoBasique(-2.5,2.5,-2.5,2.5,-50.0,50.0);
  setManipulateurDistance(1.0F);
  setManipulateurSourisAngle(10.0F,-20.0F,0.0F);
  glutReshapeFunc(reshapeOrthoBasique);
  glutMotionFunc(motionBasique);
  glutMouseFunc(sourisBasique);
  glutKeyboardFunc(key);
  glutDisplayFunc(display1);
  glutSpecialFunc(special);
  glutInitWindowSize(370,110);
  glutInitWindowPosition(60,360);
  glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_DOUBLE);
  f2 = glutCreateWindow("Valeurs");
  creationMenuBasique();
  glutDisplayFunc(displayV1);
  glutReshapeFunc(reshapeV);
  glutKeyboardFunc(key);
  glutSpecialFunc(special);
  glutMainLoop();
  return(0);
}

Les modules utilitaires : Modules.zip

RETOUR