Projet OpenGL

Ce projet consiste à réaliser une application ludique présentant les possibilités de la bibliothèque openGl. Dans ce cadre, l'application présente consiste en une scène simple où évolue un ours doué d'un talent certain pour le jonglage.

Toutes les fonctionnalités offertes par l'application sont détaillées ci-dessous.

Les fonctionnalités offertes :

Controle souris:

Bouton gauche	Déplacement de la vue autour du centre de la scène
Bouton droit	Accès au menu (cf -2- Menu)
Shift + Bouton gauche	Déplacement des lampes 2(verte) et 3(bleue)

Menus:

Toggle lightmotion	Démarre ou arrète la rotation des deux lampes mobiles
Toggle textures	Valide ou invalide l'application des textures
Toggle shadows	Affichage des ombres
Toggle reflection	Affichage des réflections
Toggle bear	Affichage de l'ours
Toggle ball	Affichage des balles
Draw light sources	Affichage des lampes

Clavier:

Rendu video et textures:
W	Mode fil de fer
S	Mode plein
r	Changement de mode de lissage de la texture au sol GL_NEAREST (par defaut) GL_LINEAR GL_LINEAR_MIPMAP_LINEAR
/	Diminution du nombre de facettes des objets de la scène (slice, stack)
*	Diminution du nombre de facettes des objets de la scène
Paramètres de jonglage
q	Diminution de la hauteur de balle
a	Augmentation de la hauteur de balle
z	Diminution de la largeur de balle
e	Augmentation de la largeur de balle
Touches de tests
Q	Diminution de la hauteur absolue de balle
A	Augmentation de la hauteur absolue de balle
Z	Diminution de la largeur de absolue balle
E	Augmentation de la largeur de absolue balle
o	Ralentissement du mouvement des bras (independemment des balles)
l	Accélération du mouvement des bras
Gestion des mouvements
+	Accélération de l'animation
-	Ralentissement de l'animation
j	Commutation entre les modes de jongglage -0- (par défaut pas de jonglage) -1- Cascade -2- Carambole
Gestion des déplacements du personnage
KEY_UP	Avancer
KEY_DOWN	Reculer
KEY_LEFT	Tourner à gauche
KEY_RIGHT	Tourner à droite (les déplacements ne peuvent malheureusement simultanés)
Decor
t	Changement de texture -0- texture paramétrée -1- texture psychedelique d'un gout douteux (par défaut) -2- texture ciel -3- texture sol rose -4- texture lave en fusion
1	Changement d'état de la lampe 1 -0- spotlight -1- lumière omnidirectionnelle -2- lumière éteinte
2	Changement d'état de la lampe 2 -- idem lampe 1
3	Changement d'état de la lampe 3 -- idem lampe 2
Autres
ESCAPE	Sortie du programme

La structure du programme :

Il s'organise en 4 parties distinctes:

1. Decor.h, Decor.cpp : La définition de la scène où évoluent les objets (ours, balles).
2. character.h, character.cpp : La définition des "acteurs" de la scène.
3. Tex.cpp, tex.h : Définition de fonctionnalités pour le chargement de textures au format raw.
4. Scene.c : La partie principale, où sont définis le comportement des acteurs et de l'application.
5. global.h : Réunit les variables globales communes à chaque partie.

Dans ce module sont définis les textures de type paramétré, les textures importées, les types de lumières de la scène, la définition du sol et des ombres qui s'y projettent.

 Textures paramétrées : :

Il s'agit d'un tableau de caractères représentant chacun une valeur de pixel.

static char *carres[] = {
"vbvbvbvb",	// v:pixel vert
"bbb.b.bb",	// b:pixel bleu
"v.bbvbbb",	// .:pixel par défaut
"bbvbbbvv",	// dans cet example
"bbvbbbvv",
"v.bbvbbb",
"bbb.b.bb",
"vbvbvbvb",
};

A l'initialisation des textures le tableau est converti en tableau de pixels et mappé sur le sol grâce à la fonction glTexImage2D(...........).

Il existe 3 types de lissages de textures qui sont GL_NEAREST, GL_LINEAR, GL_LINEAR_MIPMAPS, dans le sens de la texture la moins lissée à la plus lissée.

	GL_NEAREST
	GL_LINEAR_MIPMAPS

 Textures importées : :

Ces textures appliquées sur le sol sont importées à partir de fichiers raw situés dans le répertoire 'textures'. Elles sont chargées à l'aide des fonctions définies dans le module Tex.

 Les Lumières : :

La scène comporte 3 lumières(rouge, verte, bleue). Elles sont toutes du type suivant:

glLightfv(GL_LIGHT1, GL_DIFFUSE, lightColor[1]);

glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, 0.1);

glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.05);

La lumière ambiante est spécifiée sur la première lampe. Les lampes de la scène ont deux modes de fonctionnement: lumière multidirectionnelle et cone de lumière. Ces derniers modes ainsi que l'affichage des lampes sont gérés dans le module Scène.

 La définition du sol : :

Le sol est un simple rectangle sur lequel sont appliquées les textures paramétrées ou importées à partir de fichiers *.raw. La taille du quadrillage peut être spécifiée de la façon suivante:

glBegin(GL_QUAD_STRIP);

...

glTexCoord2f((i+1)/(float)(10)*t, j/(float)(10)*t);

...

glEnd();

où t correspond au nombre de cases présente sur le sol.

 Les ombres : :

Pour le calcul des ombres est définie une matrice de projection à partir de la position des lumières et de l'équation du plan (sol). Le rendu des ombres est par la suite traité dans le module Scène.

Ce module définit sous forme de listes les objets présents dans la scène (ours + balles).

glNewList(OBJET1, GL_COMPILE);

...

// définition de l'apparence, la forme,

// la position par défaut,

// la précision du rendu.

glEndList();

Chaque élément est défini de telle façon qu'il n'est pas nécessaire par la suite d'effectuer des transformations supplémentaires lors de leur appel à l'initialisation. La gestion des mouvements est faite dans le module Scene en effectuant les transformations adéquates pour créer le mouvement des acteurs de la scène.

Le module contient la fonction de chargement des textures à partir de fichiers *.raw (24-bits). Ce module a été écrit par Scott Franke (sfranke@scf.usc.edu). La fonction de chargement texGLLoadRAW() permet de permet de mapper des textures selon 2 modes:

mip = 1, uses gluBuild2DMipmaps

mip = 0, uses glTexImage2d

Deux fonctions dessinent les "personnages" présents dans la scène: drawbear(...) et drawball(...)

Ces fonctions appellent les différents éléments qui constitue les acteurs en fonction des paramètres de mouvements spécifiés dans la fonction idle(). A chaque affichage de la scène, qui s'effectue dans redraw(), les fonctions drawbear(...) et drawball(...) redessine les acteurs.

La cadence de l'animation est déterminée dans le idle() à partir du temps écoulé depuis le lancement du programme.

Le chemin des balles est déterminé à partir d'un tableau qui contient les coordonnées du parcours des balles, un calcul paramétré permet un jonglage plus ou moins large.

Deux fonctions permettent la gestion de la souris: mouse(...) et motion(...).

La gestion du clavier est effectuée de plusieurs façons:

Pour les touches "normales":
glutKeyboardFunc(key) et key(char c,....)
Cette fonction détermine les variables globales à modifier en fonction de la touche.

Pour les touches "spéciales": GLUT_KEY_UP, GLUT_F4, ...
glutSpecialFunc(specialKey) et specialKey(int state,...)
Cette fonction fonctionne de la même façon que la précédente.

Pour l'évênement "touche relâchée" (touches spéciales): glutSpecialUpFunc(specialKeyUp) et specialKey(int state,...)
Permet d'arreter le déplacement lorsque la touche de controle est relachée.