Cet exemple a été implémenté en Visual C++ 4.0 sous Windows NT™, c'est une application console n'utilisant qu’OpenGL™ et la librairie "AUX". Cette application représente le système solaire parcouru par le vaisseau spatial .
Il illustre les différentes caméras implémentables, le double buffering, l'implémentation de la hiérarchisation du système solaire et les moyens d’interactions de la librairie "AUX".
Pour plus de précisions sur l'implémentation, référez-vous aux commentaires du listing.
LIBRE :
Cette caméra est une caméra totalement libre, Elle est libre de se positionner n'importe où et de s'orienter dans n'importe quel sens.
EMBARQUEE:
Cette caméra se positionne en fonction d'un point de référence: elle se place à une certaine distance (*Pos.z) d'un point de référence (*Ref) et s'oriente de façon arbitraire (* Ang).
* : noms des variables dans les listings (fichier camera.c)
« INTELLIGENTE » :
Enfin cette caméra permet de se positionner en un point arbitraire (* Pos) et de regarder dans la direction d'un point de référence (* Ref).
* : noms des variables dans les listings (fichier camera.c)
Voici une représentation (non - complète) du système solaire qui tente d'expliquer le concept de hiérarchisation:
Dans notre exemple, toutes les transformations appliquée au soleil se répercutent sur la terre; car la position de la terre dépend de la position du soleil. Il en est de même pour la lune et la terre.
Par le concept de hiérarchisation, on entend le fait que toute transformation appliquée au soleil se répercute sur la terre et sur la lune, toute transformation appliquée à la terre se répercute également sur la lune.
Ce concept est important en images de synthèse car il a énormément d'applications dans tous les domaines : les planètes d'un système solaire, les doigts d'une main , les roue d'une voiture, ...
Les moyens d'interactions de la librairie "AUX":
/////////////////////////////////////////////
// Ferretti Fabio //
// Mémoire (1997) //
// service: modélisation moléculaire //
// //
// Sujet : Définition d'un objet caméra //
// //
// Header file camera.h //
/////////////////////////////////////////////
#ifndef __GL_LIB_
#define __GL_LIB_
#include <afxwin.h>
#include <afxext.h>
#include <gl\gl.h>
#include <gl\glu.h>
#include <gl\glaux.h>
#endif
#ifndef __GL_CAMERA_
#define __GL_CAMERA_
#include <math.h>
#define PI 3.1415926535
#define RAD_TO_DEG 180/PI
/* definition d'une structure Point 3d*/
typedef struct tagPTS { GLfloat x,y,z;}PTS;
//////////////////////////////////
// definition de l'objet caméra //
//////////////////////////////////
class Camera
{public:
Camera();
PTS Pos; // position de la camera
PTS Ref; // position du point de référence
PTS Ang; // orientation de la caméra (3 axes)
int Type; // type de camera
virtual void Follow(void);
virtual void Round(void);
virtual void Free(void);
virtual void Place(void);
virtual void Init(void);
};
#endif
/////////////////////////////////////////////
// Ferretti Fabio //
// Mémoire (1997) //
// service: modélisation moléculaire //
// //
// Sujet : Définition d'un objet caméra //
// //
// file camera.c //
/////////////////////////////////////////////
#include "camera.h"
////////////////////////////////////////
// Constructeur standart d'une camera //
////////////////////////////////////////
Camera::Camera()
{
Init();
Type=0;
}
/////////////////////////////////
// initialisation de la caméra //
/////////////////////////////////
void Camera::Init(void)
{
Pos.x=Pos.y=Pos.z=0.0;
Ref.x=Ref.y=Ref.z=0.0;
Ang.x=Ang.y=Ang.z=0.0;
Type=0;
}
///////////////////////////////////////
// procédure qui permet d'appeler la //
// bonne fonction en fonction de la //
// propriété type //
///////////////////////////////////////
void Camera::Place(void)
{
switch( Type )
{
case 0:
/* camera totalement libre " position et direction" */
{ Free();break;}
case 1:
/* camera est placée en un point et suit un autre */
{ Follow();break;}
case 2:
/* camera qui peut tourné autour d'un point */
{ Round();break;}
}
}
///////////////////////////////////////////
// procédure qui place la caméra en un //
// point arbitraire (Pos) et l'oriente //
// de façon arbitraire (Ang) //
///////////////////////////////////////////
void Camera::Free(void)
{ glRotatef(Ang.x,1.0,0.0,0.0);
glRotatef(Ang.y,0.0,1.0,0.0);
glRotatef(Ang.z,0.0,0.0,1.0);
glTranslatef(-Pos.x,-Pos.y,-Pos.z);
}
///////////////////////////////////////////
// procédure qui place la caméra en un //
// point arbitraire (Pos) et l'oriente //
// de vers un point (Ang) //
///////////////////////////////////////////
void Camera::Follow(void)
{ PTS d; float r,tmp;
d.x=(Pos.x-Ref.x);
d.y=(Pos.y-Ref.y);
d.z=(Pos.z-Ref.z);
tmp=(d.x*d.x)+(d.z*d.z);
r=sqrt(tmp+(d.y*d.y));
tmp=sqrt(tmp);
if(tmp!=0)
{ //teta
Ang.y=asin(-d.x/tmp)*RAD_TO_DEG;
if(d.z<0)Ang.y=-Ang.y;
}
else Ang.y=0.0;
if(r!=0)
{ //phi
Ang.x=asin(d.y/r)*RAD_TO_DEG;
if(d.z<0)Ang.x=180-Ang.x;
}
else Ang.y=0.0;
if(d.z<0) glRotatef(180.0,0.0,0.0,1.0);
glRotatef(Ang.x,1.0,0.0,0.0);
glRotatef(Ang.y,0.0,1.0,0.0);
glTranslatef(-Pos.x,-Pos.y,-Pos.z);
}
///////////////////////////////////////////
// procédure qui place la caméra en un //
// point a une distance Pos.z d'un point //
// de réference (Ref) et orineté de //
// façon arbitraire (Ang) //
///////////////////////////////////////////
void Camera::Round(void)
{ if(Pos.z>0) glTranslatef(0.0,0.0,-Pos.z);
else glTranslatef(0.0,0.0, Pos.z);
glRotatef(Ang.x,1.0,0.0,0.0);
glRotatef(Ang.y,0.0,1.0,0.0);
glRotatef(Ang.z,0.0,0.0,1.0);
glTranslatef(-Ref.x,-Ref.y,-Ref.z);
}
Systeme.h
/////////////////////////////////////////////
// Ferretti Fabio //
// Mémoire (1997) //
// service: modélisation moléculaire //
// //
// Sujet : Animation 3D illustrant les //
// possibilités d'OpenGL //
// //
// Header file system.h //
// definition des objets astre et sun //
/////////////////////////////////////////////
#ifndef __GL_LIB_
#define __GL_LIB_
#include <afxwin.h>
#include <afxext.h>
#include <gl\gl.h>
#include <gl\glu.h>
#include <gl\glaux.h>
#endif
#ifndef __GL_SYSTEM_
#define __GL_SYSTEM_
//////////////////////////////////
// definition de l'objet astre //
//////////////////////////////////
class Astre
{
public:
Astre();
GLfloat rayon;
GLfloat distance;
GLfloat periode;
GLfloat inclinaison;
GLint couleur;
GLfloat ang;
BOOL anneaux;
Astre *son;
Astre *bro;
virtual void Draw( int sphere);
} ;
//////////////////////////////////////////
// definition de l'objet Sun (<-astre) //
//////////////////////////////////////////
class Sun : public Astre
{
public:
virtual void Draw( int sphere);
} ;
#endif
/////////////////////////////////////////////
// Ferretti Fabio //
// Mémoire (1997) //
// service: modélisation moléculaire //
// //
// Sujet : Animation 3D illustrant les //
// possibilités d'OpenGL //
// //
// file system.c //
// definition des objets astre et sun //
/////////////////////////////////////////////
#include "system.h"
#include "c:\memoire\gl_plus\gl_plus.h"
//////////////////////////////////////
// Constructeur standart d'un astre //
//////////////////////////////////////
Astre::Astre()
{ rayon;
distance=0;
periode=0;
inclinaison=0;
couleur=0;
ang=0;
anneaux=FALSE;
son=bro=NULL;
}
////////////////////////////////////////
// Procédure d'affichage de l'astre //
// //
// Paramètre : //
// sphere =1 ==> shpere //
// =0 ==> icosaèdre //
////////////////////////////////////////
void Astre::Draw( int sphere)
{
/* mise sur la pile de la matrice de transformation */
glPushMatrix();
glCallList(couleur );
if(inclinaison!=0)glRotatef(5*inclinaison,0.0,0.0,1.0);
if(periode!=0){ang+=1000.0/periode;glRotatef(ang,0.0,1.0,0.0);}
if(distance!=0) glTranslatef(distance,0.0,0.0);
if(sphere==1) auxSolidSphere(rayon); else Drawico(rayon);
if(anneaux==TRUE) auxSolidCone(rayon*1.5,0.0);
/* appel de l'astre qui subit les mêmes transformation (ex lune) */
if (son!=NULL) son->Draw(sphere);
/* restauration de la matrice de transformation */
glPopMatrix();
/* appel de l'astre qui ne subit pas les mêmes transformations*/
if(bro!=NULL) bro->Draw(sphere);
}
////////////////////////////////////////
// Procédure d'affichage du soleil //
// //
// Paramètre : //
// sphere =1 ==> shpere //
// =0 ==> icosaèdre //
// idem que astre mais + lumière //
////////////////////////////////////////
void Sun::Draw( int sphere)
{
glPushMatrix();
glCallList(couleur );
if(inclinaison!=0)glRotatef(5*inclinaison,0.0,0.0,1.0);
if(periode!=0){ang+=1000.0/periode;glRotatef(ang,0.0,1.0,0.0);}
if(distance!=0)glTranslatef(distance,0.0,0.0);
/* mise sur la pile des attibuts de lumière */
glPushAttrib(GL_LIGHTING_BIT);
glDisable(GL_LIGHTING);
glColor3f(1.0, 1.0, 0.5);
if (sphere==1)auxSolidSphere(rayon);else Drawico(rayon);;
if (anneaux==TRUE) auxSolidCone(rayon*1.5,0.0);
/* restauration des attributs de lumière */
glPopAttrib();
if (son!=NULL) son->Draw(sphere);
glPopMatrix();
if (bro!=NULL) bro->Draw(sphere);
}
/////////////////////////////////////////////
// Ferretti Fabio //
// Mémoire (1997) //
// service: modélisation moléculaire //
// //
// Sujet : Animation 3D illustrant les //
// possibilités d'OpenGL //
// //
// Header file solar.h //
/////////////////////////////////////////////
#ifndef __GL_LIB_
#define __GL_LIB_
#include <afxwin.h>
#include <afxext.h>
#include <gl\gl.h>
#include <gl\glu.h>
#include <gl\glaux.h>
#endif
#include <stdio.h>
#include <math.h>
#include "d:\memoire\system\system.h"
#include "d:\memoire\camera\camera.h"
#include "d:\memoire\gl_plus\gl_plus.h"
Solar.c
/////////////////////////////////////////////
// Ferretti Fabio //
// Mémoire (1997) //
// service: modélisation moléculaire //
// //
// Sujet : Animation 3D illustrant les //
// possibilités d'OpenGL //
// //
// file solar.c //
/////////////////////////////////////////////
#include "solar.h"
#define PI 3.1415926535
#define A_D 180/PI
////////////////////////////////////////////
// définition des attibuts de couleurs //
////////////////////////////////////////////
GLfloat whiteAmbient[] = {0.3, 0.3, 0.3, 1.0};
GLfloat whiteDiffuse[] = {1.0, 1.0, 1.0, 1.0};
GLfloat whiteSpecular[] = {1.0, 1.0, 1.0, 1.0};
GLfloat redAmbient[] = {0.3, 0.1, 0.1, 1.0};
GLfloat redDiffuse[] = {1.0, 0.0, 0.0, 1.0};
GLfloat redSpecular[] = {1.0, 0.0, 0.0, 1.0};
GLfloat greenAmbient[] = {0.1, 0.3, 0.1, 1.0};
GLfloat greenDiffuse[] = {0.0, 1.0, 0.0, 1.0};
GLfloat greenSpecular[] = {0.0, 1.0, 0.0, 1.0};
GLfloat blueAmbient[] = {0.1, 0.1, 0.3, 1.0};
GLfloat blueDiffuse[] = {0.0, 0.0, 1.0, 1.0};
GLfloat blueSpecular[] = {0.0, 0.0, 1.0, 1.0};
GLfloat greyAmbient[] = {0.1, 0.1, 0.1, 1.0};
GLfloat greyDiffuse[] = {0.5, 0.5, 0.5, 1.0};
GLfloat greySpecular[] = {1.0, 1.0, 1.0, 1.0};
GLfloat lightPosition0[] = {0.0, 0.0, 0.0, 1.0};
GLvoid initialize(GLvoid);
GLvoid CALLBACK drawScene(GLvoid);
GLvoid CALLBACK resize(GLsizei, GLsizei);
void drawfusee(float size) ;
void InitMaterial(void);
void InitAstre(void);
void InitCamera(void);
GLuint spheres,fusee;
Gluint Soleil, Mercure, Venus, Terre, Mars, Jupiter, Saturn, Uranus, Neptune, Pluton, Lune;
Astre mercure, venus, terre, mars, jupiter, saturn, uranus, neptune, pluton, lune;
Sun soleil;
Camera Cam;
GLfloat dx,dy,dz,angx,angy,angz;
int step;
int flame_long;
///////////////////////////////////////////////////////////////////
// Procédure d'affichage des touches d'utilisation de l'exemples //
///////////////////////////////////////////////////////////////////
void aff_txt(void)
{
printf("\n UP & DOWN: Pos.x FREE ----- FOLLOW\n");
printf(" LEFT & RIGHT : Pos.y FREE ----- FOLLOW\n");
printf(" a & q ______ : Pos.z FREE ROUND FOLLOW\n");
printf("\n 7 & 4 & 1 _: Ang.x FREE ROUND ------\n");
printf(" 8 & 5 & 2 ___: Ang.y FREE ROUND ------\n");
printf(" 9 & 6 & 3 ___: Ang.z FREE ROUND ------\n");
printf("\n t & g _____: Ref.x FREE ROUND FOLLOW\n");
printf(" y & h _______: Ref.y FREE ROUND FOLLOW\n");
printf(" u & j _______: Ref.z FREE ROUND FOLLOW\n");
printf("\n o & p _____: v de rotation FREE ROUND FOLLOW\n");
printf("\n s _________: Sphere ou Dodeca.FREE ROUND FOLLOW\n");
printf("\n f __________:Mode camera FREE!ROUND!FOLLOW\n");
printf("\n MOUSE_LEFT _:Pos de defaut FREE ROUND FOLLOW\n");
printf("\n MOUSE_RIGHT : Pos=(0,0,0) FREE ROUND FOLLOW\n");
switch( Cam.Type )
{
case 0:
{ printf("\n FREE");break;}
case 1:
{ printf("\n FOLLOW");break;}
case 2:
{ printf("\n ROUND");break;}
}
printf("==> CURENT MODE \n\n");
}
////////////////////////////////
// Procédure de la touche : s //
////////////////////////////////
static void CALLBACK Key_s(void){spheres=(spheres+1)%2;}
////////////////////////////////
// Procédure de la touche : f //
////////////////////////////////
static void CALLBACK Key_f(void)
{Cam.Type=(Cam.Type+1)%3;aff_txt();}
////////////////////////////////
// Procédure du bouton gauche //
////////////////////////////////
static void CALLBACK Mouse_left(AUX_EVENTREC *event)
{InitCamera();}
////////////////////////////////
// Procédure du bouton droit //
////////////////////////////////
static void CALLBACK Mouse_right(AUX_EVENTREC *event)
{Cam.Pos.x=Cam.Pos.y=Cam.Pos.z=0.0;}
/////////////////////////////////////
// Procédure de la touche : doite //
/////////////////////////////////////
static void CALLBACK Key_right(void){Cam.Pos.x += 0.1;}
/////////////////////////////////////
// Procédure de la touche : gauche //
/////////////////////////////////////
static void CALLBACK Key_left(void){Cam.Pos.x -= 0.1;}
////////////////////////////////////
// Procédure de la touche : haut //
////////////////////////////////////
static void CALLBACK Key_up(void){Cam.Pos.y += 0.1;}
///////////////////////////////////
// Procédure de la touche : bas //
///////////////////////////////////
static void CALLBACK Key_down(void){Cam.Pos.y -= 0.1;}
////////////////////////////////
// Procédure de la touche : q //
////////////////////////////////
static void CALLBACK Key_q(void){Cam.Pos.z += 0.1;}
////////////////////////////////
// Procédure de la touche : a //
////////////////////////////////
static void CALLBACK Key_a(void){Cam.Pos.z -= 0.1;}
////////////////////////////////
// Procédure de la touche : t //
////////////////////////////////
static void CALLBACK Key_t(void){Cam.Ref.x += 0.1;}
////////////////////////////////
// Procédure de la touche : g //
////////////////////////////////
static void CALLBACK Key_g(void){Cam.Ref.x -= 0.1;}
////////////////////////////////
// Procédure de la touche : y //
////////////////////////////////
static void CALLBACK Key_y(void){Cam.Ref.y += 0.1;}
////////////////////////////////
// Procédure de la touche : h //
////////////////////////////////
static void CALLBACK Key_h(void){Cam.Ref.y -= 0.1;}
////////////////////////////////
// Procédure de la touche : u //
////////////////////////////////
static void CALLBACK Key_u(void){Cam.Ref.z += 0.1;}
////////////////////////////////
// Procédure de la touche : j //
////////////////////////////////
static void CALLBACK Key_j(void){Cam.Ref.z -= 0.1;}
////////////////////////////////
// Procédure de la touche : 9 //
////////////////////////////////
static void CALLBACK Key_9(void){Cam.Ang.z+=5.0;}
////////////////////////////////
// Procédure de la touche : 6 //
////////////////////////////////
static void CALLBACK Key_6(void){Cam.Ang.z=0.0;}
////////////////////////////////
// Procédure de la touche : 3 //
////////////////////////////////
static void CALLBACK Key_3(void){Cam.Ang.z-=5.0;}
////////////////////////////////
// Procédure de la touche : 8 //
////////////////////////////////
static void CALLBACK Key_8(void){Cam.Ang.y+=5.0;}
////////////////////////////////
// Procédure de la touche : 5 //
////////////////////////////////
static void CALLBACK Key_5(void){Cam.Ang.y=0.0;}
////////////////////////////////
// Procédure de la touche : 2 //
////////////////////////////////
static void CALLBACK Key_2(void){Cam.Ang.y-=5.0;}
////////////////////////////////
// Procédure de la touche : 7 //
////////////////////////////////
static void CALLBACK Key_7(void){Cam.Ang.x+=5.0;}
////////////////////////////////
// Procédure de la touche : 4 //
////////////////////////////////
static void CALLBACK Key_4(void){Cam.Ang.x=0.0;}
////////////////////////////////
// Procédure de la touche : 1 //
////////////////////////////////
static void CALLBACK Key_1(void){Cam.Ang.x-=5.0;}
////////////////////////////////////////
// programme principal : //
// appel de l'initialisation, //
// affichage des touches utilisées //
// definition de la fonction boucle //
////////////////////////////////////////
int main()
{ flame_long=0;
initialize();
aff_txt();
auxMainLoop( drawScene );
exit(0);
return 0;
}
////////////////////////////////////////////
// fonction d'initialisation des couleurs //
// des astres //
////////////////////////////////////////////
void InitMaterial(void)
{
int i=1;
Soleil=i;
glNewList(Soleil, GL_COMPILE);
glEndList();
Terre=i++;
GLfloat Ambient[] = {0.0,0.385,0.625,0.0};
GLfloat Diffuse[] = {0.783,0.783,0.783,0.0};
GLfloat Specular[] ={0.755,0.755,0.755,0.0};
DefMat(Terre,Ambient,Diffuse,Specular);
Venus=Lune=Jupiter=i++;
Ambient[0]= 0.240; Ambient[1]= 0.110; Ambient[2]= 0.0;
Diffuse[0]= 0.929; Diffuse[1]= 0.771; Diffuse[2]= 0.673;
Specular[0]=0.755; Specular[1]=0.755; Specular[2]=0.755;
DefMat(Venus,Ambient,Diffuse,Specular);
Saturn=i++;
Ambient[0]= 0.326; Ambient[1]= 0.157; Ambient[2]= 0.0;
Diffuse[0]= 0.771; Diffuse[1]= 0.748; Diffuse[2]= 0.759;
Specular[0]=0.755; Specular[1]=0.755; Specular[2]=0.755;
DefMat(Saturn,Ambient,Diffuse,Specular);
Neptune=Uranus=i++;
Ambient[0]= 0.0; Ambient[1]= 0.385; Ambient[2]= 0.625;
Diffuse[0]= 0.783; Diffuse[1]= 0.783; Diffuse[2]= 0.783;
Specular[0]=0.755; Specular[1]=0.755; Specular[2]=0.755;
DefMat(Neptune,Ambient,Diffuse,Specular);
Mars=i++;
Ambient[0]= 0.303; Ambient[1]= 0.145; Ambient[2]= 0.0;
Diffuse[0]= 0.661; Diffuse[1]= 0.661; Diffuse[2]= 0.661;
Specular[0]=0.755; Specular[1]=0.755; Specular[2]=0.755;
DefMat(Mars,Ambient,Diffuse,Specular);
Mercure=i++;
Ambient[0]= 0.303; Ambient[1]= 0.110; Ambient[2]= 0.0;
Diffuse[0]= 0.503; Diffuse[1]= 0.503; Diffuse[2]= 0.0;
Specular[0]=0.917; Specular[1]=0.917; Specular[2]=0.917;
DefMat(Mercure,Ambient,Diffuse,Specular);
Pluton=i++;
Ambient[0]= 0.531; Ambient[1]= 0.444; Ambient[2]= 0.157;
Diffuse[0]= 0.204; Diffuse[1]= 0.696; Diffuse[2]= 0.503;
Specular[0]=0.755; Specular[1]=0.755; Specular[2]=0.755;
DefMat(Pluton,Ambient,Diffuse,Specular);
}
////////////////////////////////////////
// initialisation des moyens //
// d'interactions //
////////////////////////////////////////
void Ini_interaction(void)
{ auxMouseFunc(AUX_LEFTBUTTON,AUX_MOUSEDOWN, Mouse_left);
auxMouseFunc(AUX_RIGHTBUTTON,AUX_MOUSEDOWN,Mouse_right);
auxKeyFunc(AUX_s, Key_s);
auxKeyFunc(AUX_f, Key_f);
auxKeyFunc(AUX_a, Key_a);
auxKeyFunc(AUX_q, Key_q);
auxKeyFunc(AUX_UP, Key_up);
auxKeyFunc(AUX_DOWN, Key_down);
auxKeyFunc(AUX_LEFT, Key_left);
auxKeyFunc(AUX_RIGHT, Key_right);
auxKeyFunc(AUX_t, Key_t);
auxKeyFunc(AUX_g, Key_g);
auxKeyFunc(AUX_y, Key_y);
auxKeyFunc(AUX_h, Key_h);
auxKeyFunc(AUX_u, Key_u);
auxKeyFunc(AUX_j, Key_j);
auxKeyFunc(AUX_9, Key_9);
auxKeyFunc(AUX_8, Key_8);
auxKeyFunc(AUX_7, Key_7);
auxKeyFunc(AUX_6, Key_6);
auxKeyFunc(AUX_5, Key_5);
auxKeyFunc(AUX_4, Key_4);
auxKeyFunc(AUX_3, Key_3);
auxKeyFunc(AUX_2, Key_2);
auxKeyFunc(AUX_1, Key_1);
auxIdleFunc( drawScene );
}
//////////////////////////////////////////
// fonction d'initialisation des astres //
//////////////////////////////////////////
void InitAstre(void)
{
/* initialisation des rayons des astres */
soleil.rayon=0.125;
mercure.rayon=0.03;
venus.rayon=0.05;
terre.rayon=0.05;
mars.rayon=0.03;
jupiter.rayon=0.08;
saturn.rayon=0.08;
uranus.rayon=0.07;
neptune.rayon=0.07;
pluton.rayon=0.01;
lune.rayon=0.01;
/* initialisation du rayon de rotation des astres */
soleil.distance=0;
mercure.distance=0.25;
venus.distance=0.4;
terre.distance=0.6;
mars.distance=1.0;
jupiter.distance=2.0;
saturn.distance=3.0;
uranus.distance=4.0;
neptune.distance=5.0;
pluton.distance=6.0;
lune.distance=0.11;
/* initialisation de la période de rotation des astres */
soleil.periode=0;
mercure.periode=88.0;
venus.periode=224.7;
terre.periode=365.26;
mars.periode=686.96;
jupiter.periode=1000.0;
saturn.periode=2000.0;
uranus.periode=3000.0;
neptune.periode=4000.0;
pluton.periode=5000.0;
lune.periode=27.32;
/* initialisation de l'inclinaison de l'axe de rotation */
soleil.inclinaison=0;
mercure.inclinaison=7.0;
venus.inclinaison=3.4;
terre.inclinaison=0.0;
mars.inclinaison=1.8;
jupiter.inclinaison=1.3;
saturn.inclinaison=2.5;
uranus.inclinaison=0.8;
neptune.inclinaison=1.8;
pluton.inclinaison=17.2;
lune.inclinaison=5;
/* initialisation de la couleur des astres */
soleil.couleur=Soleil;
mercure.couleur=Mercure;
venus.couleur=Venus;
terre.couleur=Terre;
mars.couleur=Mars;
jupiter.couleur=Jupiter;
saturn.couleur=Saturn;
uranus.couleur=Uranus;
neptune.couleur=Neptune;
pluton.couleur=Pluton;
lune.couleur=Lune;
/* initialisation de la variable présence d'anneaux */
soleil.anneaux=FALSE;
mercure.anneaux=FALSE;
venus.anneaux=FALSE;
terre.anneaux=FALSE;
mars.anneaux=FALSE;
jupiter.anneaux=FALSE;
saturn.anneaux=TRUE;
uranus.anneaux=FALSE;
neptune.anneaux=FALSE;
pluton.anneaux=FALSE;
lune.anneaux=FALSE;
/* initialisation de la hierarchie des astres dans
le systeme solaire */
soleil.son=&mercure;
terre.son=&lune;
mercure.bro=&venus;
venus.bro=&terre;
terre.bro=&mars;
mars.bro=&jupiter;
jupiter.bro=&saturn;
saturn.bro=&uranus;
uranus.bro=&neptune;
neptune.bro=&pluton;
}
////////////////////////////////////////////
// fonction d'initialisation de la camera //
////////////////////////////////////////////
void InitCamera(void)
{
Cam.Init();
Cam.Pos.z=1.0;
Cam.Ref.z=0.5;
}
//////////////////////////////////////////
// fonction qui appelle les différentes //
// initialisations //
//////////////////////////////////////////
GLvoid initialize(GLvoid)
{ IniGL("solar");
spheres=step=0;
fusee=1;
dx=dy=dz=angx=angy=angz=0.0;
Ini_interaction();
InitMaterial();
InitAstre();
InitCamera();
}
///////////////////////////////////////////
// fonction qui calcul la trajectoire de //
// la fusée //
///////////////////////////////////////////
void Trajectoire(int step)
{ float nx,ny,nz,r,tmp;
dx=sin(step/(5*PI))/20;
dz=cos(step/(5*PI))/20;
r=sqrt(dx*dx+dz*dz);
if (r!=0)
{ nx=dx/r;
nz=dz/r;
if(nx<0) angy=acos(-nz)*A_D; else angy=-acos(-nz)*A_D;
}
}
////////////////////////////////////
// fonction de dessin de la scène //
////////////////////////////////////
GLvoid CALLBACK drawScene(GLvoid)
{ glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
/*calcul de la trajectoire et modification du point de référence */
Trajectoire(step++);
Cam.Ref.x+=dx;
Cam.Ref.y+=dy;
Cam.Ref.z+=dz;
glPushMatrix();
/* placement de la camera */
Cam.Place();
glLightfv(GL_LIGHT0, GL_POSITION, lightPosition0);
glPushMatrix();
/* dessin de la fusée */
glTranslatef( Cam.Ref.x,Cam.Ref.y, Cam.Ref.z);
glRotatef(angy, .0,1.0, .0);
drawfusee(0.3);
glPopMatrix();
/* affichage du système solaire */
soleil.Draw(spheres);
glPopMatrix();
/* swapping de buffer */
auxSwapBuffers();
}
////////////////////////////////////
// fonction de dessin de la fusée //
////////////////////////////////////
void drawfusee(float size)
{
glPushMatrix();
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, whiteAmbient );
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, whiteDiffuse );
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR,whiteSpecular);
glMaterialf(GL_FRONT, GL_SHININESS, 30.0);
glPushMatrix();
glScalef(0.5*size,0.1*size,0.5*size);
glTranslatef( 0.0, 1.0, -0.3);
if (spheres==1)auxSolidSphere(0.25);else Drawico(0.25);
glRotatef(80.0,1.0,0.0,0.0);
auxSolidCone(0.05,1.0);
glPopMatrix();
glPushMatrix();
glScalef(0.07*size,0.07*size,0.3*size);
glTranslatef( 0.9, 1.0, 0.3);
if (spheres==1)auxSolidSphere(0.25);else Drawico(0.25);
glPushMatrix();
glRotatef(-260.0,1.0,0.0,0.0);
glRotatef(-45.0,0.0,1.0,0.0);
auxSolidCone(0.05,1.6);
glPopMatrix();
glTranslatef( -1.8, 0.0, 0.0);
if (spheres==1)auxSolidSphere(0.25);else Drawico(0.25);
glRotatef(-260.0,1.0,0.0,0.0);
glRotatef(45.0,0.0,1.0,0.0);
auxSolidCone(0.05,1.6);
glPopMatrix();
glPushMatrix();
glScalef(0.1*size,0.1*size,0.4*size);
if (spheres==1)auxSolidSphere(0.25);else Drawico(0.25);
flame_long=((flame_long+1)%6);
glPushAttrib(GL_LIGHTING_BIT);
glDisable(GL_LIGHTING);
glColor3f(1.0, 1.0, 0.5);
glTranslatef( 0.0, 0.0, 0.23);
auxSolidCone( 0.07, 0.025*(flame_long+1) );
glPopAttrib();
glPopMatrix();
glPopMatrix();
}
4.1.3.1. Exemple : « MOLECULE ».
Cet exemple a été implémenté en Visual C++ 4.0 sous Windows NT™, c'est une application console utilisant la librairie "GL_PLUS" et OpenGL™.
Il est destiné à illustrer l'utilisation de la librairie implémentée "GL_PLUS".
Voici le pseudocode de l'application "Molécule":
Initialiser la librairie GL_PLUS (1)
Pour i allant de 0 à <nombre d'itération>
Construire l'image i (2)
Afficher l'image i (3)
Fin pour.
L'initialisation de la librairie GL_PLUS s'effectue en deux étapes : l'initialisation d'OpenGL™ et l'initialisation du type de lumière.
La construction de l'image se fait par modification de la position des atomes.
L'affichage s'effectue comme un appel à un "PutPixel" de C standard, si ce n'est que l'on passe en paramètre tous les atomes et des données qui permettent de définir les molécules et les types de formes à afficher.
Modélisation ou représentation d'un objet sous une forme bidirectionnelle.
Modélisation ou représentation d'un objet sous une forme tridirectionnelle.
Effet visuel indésirable obtenu lors de l'affichage d'images courbes ou diagonales ainsi que lors du passage d'une couleur ou d'une texture à une autre.
L'angle de prise de vue est l'angle formé par l'axe de visée de la caméra avec la position théorique de cet axe en position neutre. La position neutre d'une caméra est celle où les lignes horizontales et verticales du décor ne présentent pas d'effet de «fuite» : l'axe de visée de la caméra est perpendiculaire au plan principal du décor.
Technique de filtrage des contours utilisée pour réduire les effets visuels d'escalier (lignes courbes ou diagonales ) ou indésirables (débordement des couleurs ou textures) lors de l'affichage d'images de synthèse.
Acronyme de Application Programming Interface.
Les artefacts sont des défauts involontaires dans une image qui sont induits par une limitation d'un procédé d'affichage ou une mauvaise utilisation d'un algorithme ou d'un matériel.
Ainsi, une ligne oblique tracée sur un écran « bitmap » donne parfois un effet d'escalier. Cet artefact peut être supprimé par une méthode d'anti-aliasing.
Image graphique composée par un certain nombre de points par pouce. Se dit également d’une mémoire de « trame » qui stocke chaque points de l’écran sous la forme d’un bit ou plus.
Les B-Splines sont des généralisations des surfaces de BEZIER créées par Pierre Bézier en 1972. Ces surfaces sont créées à partir de matrices MxN de points de contrôle qui permettent un contrôle local de la surface.
Acronymes pour Conception Assistée par Ordinateur et Présentation Assistée par Ordinateur.
Position x=0 y=0 et z=0 : il est souvent appelé centre du monde car tous les objets ont une position en fonction de celui-ci.
Le mode console, aussi appelé ligne de commande, est un mode d'interaction homme - machine non graphique (clavier) dans un environnement graphique.
C'est le cas du Shell sous UNIX et du Dos sous Windows NT™ .
Angle de vision couvert par l'objectif d'une caméra.
Implémentation "Cross-plateform" çè implémentation indépendante de tout système d'exploitation et de toute machine.
La géométrie constructive (CSG en anglais) revient à manipuler des objets par des opérations booléennes comme fusion de deux objets, soustraction, intersection... On peut ainsi créer une table à partir d'un cube dont on soustrait deux autres volumes rectangulaires pour évider le bloc. Ces opérations sont surtout utilisées pour percer des trous dans des objets existants et pour obtenir des objets mâles-femelles qui s'emboîtent parfaitement.
Technique de traitement d'image permettant la simulation de couleurs sur des périphériques ayant une palette de couleurs limitée.
C'est une technique très utilisée en animation qui permet le fait de voir l'image se dessiner par morceaux. Elle consiste à dessiner en mémoire et à recopier en une fois l'image à l'écran.
Les méthodes de vu/caché dans l'espace-objet utilisent les informations X, Y et Z de l'environnement 3D pour déterminer si une surface en cache une autre ou si elle est cachée par une autre. Par exemple, le Ray_tracing.
En opposition avec les méthodes dans l'espace-image, ces méthodes sont plus générales, mais aussi nettement plus voraces en ressources diverses.
En modélisation tridimensionnelle, les facettes sont des petites surfaces délimitées par des contours géométriques (droites ou courbes), destinées à "approximer" une surface. En général ces formes géométriques sont des triangles ou des rectangles.
Un film est une succession d’images donnant l’illusion du mouvement.
Technique d'ombrage simple des objets en synthèse d'images ne donnant qu'un aspect mat et sans reflet à ceux-ci. Le flat-shading n'utilise qu'une normale au centre de la surface pour calculer la luminosité de toute la face; il n'utilise aucun lissage de couleur ce qui implique que toute la face a la même luminosité.
Cette technique de lissage due à Henri Gouraud (1971) est la plus simple : Elle consiste à évaluer l'intensité lumineuse au niveau de chaque sommet d'une facette, puis l'intensité de chaque pixel d'une ligne de balayage, qui parcourt la facette, par une double interpolation linéaire.
Acronyme pour High Definition TeleVision.
Une hiérarchie est un groupe d'objets organisés en arborescence. Quand on déplace l'objet-père, les objets-fils suivent le mouvement automatiquement. Les personnages sont toujours organisés en hiérarchie.
HLS signifie : Hue, Luminance, Saturation. C'est un codage de la couleur différent de la méthode RGB, plus commune dans les cartes écran car plus proche de la réalité physique d'un tube-écran.
La méthode HLS est considérée comme plus intuitive pour l'oeil humain. On choisit une teinte, puis sa luminosité (proportion de noir et de blanc), puis sa saturation (entre la teinte pure et les couleurs neutres : blanc, gris ou noir).
Les HMD ou « Head Mounted Display » sont des doubles écrans vidéos montés sur des lunettes. En général, un capteur de position de la tête y est incorporé, permettant aux programmes de réalité virtuelle de calculer un point de vue correspondant à celui de l'utilisateur.
Procédé consistant à adoucir l'aspect heurté de certains contours en synthèse d'images. Le lissage est basé sur différentes techniques d'interpolation et permet, par exemple, de rendre imperceptible les facettes d'un visage.
Acronyme de Microsoft Fundation Class.
La matrice quatre fois quatre d'OpenGL™ qui transforme les points, lignes et polygones des coordonnées objet (espace virtuel de dessin) vers les coordonnées observateur.
Acronyme de Motion Picture Expert Group. Il s'agit d'une norme définissant la compression/décompression d'images vidéos animées. Cette norme est d'application au niveau multimédia.
Le standard TV américain NTSC (Never Twice Same Color (joke!)) posséde une définition moins bonne que le système PAL européen, mais possède une fréquence rafraîchissement d'image de 30 Hz, ce qui donne une meilleur fluidité au mouvement.
La taille de l'image est de 640x480 pixels.
Acronyme de Non-Uniform Rational B-Splines. Il s'agit d'une famille de courbes et de surfaces très souples permettant de modéliser des formes gauches comme les carrosseries de voitures par exemple.
Technique de calcul permettant d'appliquer une ou plusieurs sources de lumière sur une scène et d'obtenir l'intensité de lumière en chaque point.
Faces des objets ne recevant pas de lumière.
Zones d'ombres engendrées par les différents objets en dehors des faces à l'ombre des objets eux-mêmes.
Le standard TV européen PAL (Phase Alternate Line) correspond à une taille d'image de 720x576 pixels. Du point de vue de la taille, le standard français SECAM conserve les mêmes dimensions.
Ces deux standards sont d'ailleurs compatibles jusqu'à un certain point : les images PAL peuvent être lues (en noir et blanc) sur un système SECAM.
La fréquence de balayage de 25 Hz est inférieure à celle du NTS américain.
Le panoramique est un mouvement par lequel la caméra pivote autour de son axe, sans toutefois se déplacer physiquement. Le panoramique peut également être horizontal, vertical ou diagonal.
D'une manière très générale, on pourrait dire que le panoramique pur reste plus loin de l'action, qu'il est plus descriptif, alors que le travelling colle de plus près à l'action, fait participer le spectateur à son mouvement.
On peut évidemment créer des mouvements de caméra mixtes, combinant travelling, panoramique et éventuellement zoom.
Acronyme de Picture Element. Il constitue le plus petit élément de l'image et est donc, en quelque sorte, l'équivalent d'un point.
Un plan est une portion de film qui est filmée en une fois sans éteindre la caméra. Ces plans sont regroupés en séquences et l’ensemble des séquences donne le film.
Elément de base d'un logiciel graphique (point, ligne, courbe, surface de base , volume de base,...).
La profondeur de champ est la zone de netteté en-deça et au-delà de laquelle les objets présents dans le champ apparaissent flous. Alors que dans le cinéma réel, la profondeur de champ est déterminée par la focale et l'ouverture de diaphragme utilisée, en 3D, la profondeur de champ (la présence de zones floues) est toujours un effet à demander, lorsque le logiciel employé le permet.
«Le champ» est la portion d'espace découpé par la caméra, fonction de sa focale et de son angle de prise de vue.
Technique de représentation d'un objet réel à trois dimensions sur un support à deux dimensions en conservant sa forme et ses proportions. Cette méthode est particulièrement utilisée dans le cas du dessin technique.
Technique de représentation d'un objet réel à trois dimensions sur un support à deux dimensions, non plus en conservant strictement sa forme et ses proportions mais tel qu'il apparaît à l'œil de l'observateur. Les objets représentés en perspective sont caractérisés par un effet de "raccourci" et par l'existence de points de fuites. Cette méthode est largement utilisée en synthèse d'images.
Opération qui consiste à réafficher à l'écran (habituellement 25 fois par seconde) l'image qu'il contient pour éviter l’effet désagréable de scintillement.
Type de réflexion dans laquelle la lumière est réfléchie uniformément dans toutes les directions. C'est le cas des surfaces mates.
Type de réflexion dans laquelle la lumière est renvoyée dans une direction précise. C'est le cas principalement des surfaces brillantes comme le miroir ou les surfaces métalliques.
Procédé de transformation d'un objet à partir d'une description mathématique pour en faire une image réaliste. Il existe plusieurs techniques de rendu telles que le placage de texture, l'ombrage, le lancé de rayon (ray-tracing), souvent utilisées en combinaison.
Acronyme de Red, Green et Blue (Rouge, vert et bleu). Mode de composition des couleurs basé sur le principe des couleurs additives.
Une surface très lisse et opaque comme celle d'une bille d'acier ou d'un miroir présentera surtout des réflexions spéculaires. De nombreux génériques de télévision usent et abusent des effets spéculaires sur des logos d'aspect métallique, car ils mettent en valeur les mouvements de caméra.
La rugosité peut être chiffrée par un nombre compris entre 0 et 1, qui sera utilisé comme paramètre pour choisir l'algorithme d'éclairement approprié. Un objet 100% rugueux réfléchira la lumière dans toutes les directions, tandis qu'un objet lisse à 100% obéira strictement à la loi de Lambert.
Une séquence est un regroupement de plans qui se suivent et se déroulent dans le même décor. La réunion de toutes les séquences donne le film.
Mode de traitement qui permet l'interprétation des données immédiatement après leur arrivée dans le circuit informatique, sans délai sensible.
Représentation synthétique des matières constituant les surfaces des objets modélisés (grain des pierres, poli des métaux, rainure du bois,...).
Le travelling désigne un déplacement physique de la caméra en cours de plan. Il est généralement caractérisé par sa direction . Le travelling est utilisé le plus souvent pour accompagner le mouvement d'un mobile.
On appelle UP-VECTOR le vecteur vertical situé dans le plan de la caméra.. C'est grosso modo la verticale du caméraman.
Elément de base du dessin : il représente le point.
Le vertical retrace est une technique qui, associée au double buffering, permet d'éviter le scintillement des animations. Elle consiste a attendre que le rayon de balayage de l'écran remonte (n'affiche plus) pour copier l'image de la mémoire vers l'écran.
Le Viewport est la partie d'une fenêtre d'affichage dans laquelle on dessine. Dans de nombreux cas, il s'agit de la totalité de la fenêtre, mais pas toujours. En effet, le programmeur peut vouloir réserver une zone de la fenêtre courante pour des boutons, des menus ou d'autres Viewport.
Le « walk-through » est le fait de se déplacer en temps réel dans une scène de type achitectural.
C'est une méthode de vu/caché. Une table de données est tenue à jour. Elle contient la coordonnée Z de chaque pixel affiché à l'écran. Pour cela, lors de la transformation en coordonnées de l'écran, on transfère la valeur Z de la troisième coordonnée à l'emplacement correspondant de la table. Cette table est appelée Z-Buffer.
Si à l'emplacement du pixel à afficher, une valeur Z existe déjà, on compare cette valeur à la valeur Z du nouveau pixel. Si la valeur Z du nouveau pixel que l'on ajoute est supérieure à celle du pixel déjà affiché à cette même place, c'est qu'il est plus proche de l'observateur que ce dernier, et il peut donc prendre sa place. On affiche donc le nouveau pixel à l'écran et on met à jour le Z-Buffer.
Dans le cas contraire, le pixel déjà présent est conservé et le Z-Buffer n'est pas modifié. Cette méthode est correcte dans tous les cas, quelle que soit la complexité de la scène, le nombre et les positions relatives des objets, etc...
Le zoom est un changement de focale de l'objectif de la caméra qui rapproche ou éloigne les objets en cadrant une portion plus ou moins grande du champ. Les longs zooms (télé-objectif de 1 00 mm par ex.) écrasent très fort les perspectives, atténuent l'impression de vitesse des objets et sont donc souvent à déconseiller dans les scènes d'actions.
A ne pas confondre avec le travelling qui est le mouvement d'avancement d'une caméra le long de son axe, comme si elle était posée sur un chariot.
Ref : [Cou95]
Titre : L'indispensable pour l'image de synthèse. du réel au virtuel.
Auteur : J-P. Couwenbergh
Editeur : Marabout
Ref : [Lon95]
Titre : Livre d'or Visual C++ 4.0.
Auteur : P. Longuet.
Editeur : Sybex.
Ref : [GSS92]
Titre : Graphics Development Toolkit (Volume 1-2-3).
Auteur : Graphic Software Systems.
Editeur : Graphic Software Systems
Ref : [SGI92]
Titre : Graphics Library Programming Guide.
Auteur : Silicon Graphics.
Editeur : Silicon Graphics.
Ref : [ORM92]
Titre : the OpenGL Reference Manual.
Auteur : OpenGL Architecture Review Board.
Editeur : Addison-Wesley.
Ref : [OPG92]
Titre : OpenGL Programming Guide.
Auteurs : J. Neider, T. Davis et M. Woo.
Editeur : Addison-Wesley.
Ref : [HIL90]
Titre : Computer Graphics.
Auteur : F.S. Hill Jr.
Editeur : Maxwell Macmillan international
Ref : [H&B86]
Titre : Computer Graphics.
Auteurs : D. Hearn et M. Pauline Baker.
Editeur : Prentice-Hall.
Titre : OpenGl Specification.
Auteur : Uwe Behrens.
Adresse : acm.org.
Titre : The Mesa 3-D Graphics Library.
Auteur : Brian Paul
Organisation :University of Wisconsin : Space Science and Engineering Center
Adresse : ssec.wisc.edu.
Titre : The OpenGL WWW Center.
Auteur : Andy Vesper.
Organisation : Silicon Graphics.
Adresse : www.sgi.com
Titre : The OpenGL WWW Pages.
Organisation : Silicon Graphics.
Adresse : www.sgi.com
Titre : The OpenGL FAQ.
Organisation : Silicon Graphics.
Adresse : www.sgi.com
Titre : OpenGL Basics.
Auteur : Aaron D. Fuegi
Adresse : www.bu.edu
Ref : [MVC96]
Titre : Aide de Microsoft Visual C++ 4.0.
Organisation : Microsoft
support : Aide.
Ref : [Her95]
Titre : Cours d’infographie.
Auteur : Mr Herquet.
Organisation : Université de Mons-Hainaut.
support : Cours de deuxième candidature informatique.
Ref : [L&M94]
Titre : 3D Animation . L'encyclopédie Multimédia de l'image de synthèse.
Auteurs : B. Labaye et B. Michel.
Organisation : Neurones Production.
support : CD-ROM.
Ref : [Cat95]
Titre : Les films d’images de synthèse.
Auteurs : Catonio Claude.
Organisation : Université de Mons-Hainaut.
support : Raport projet de première licence.