Lumière en mouvement

Préalables: Pour ce tutoriel, vous aurez besion du composant [SetupGL].

Survol du tutoriel

Au petit menu :

Spécification de réfléctivité de matière (Petit truc)
Créer une lumière éclairant un objet en mouvement
Éclairage se déplacant avec le point de vue

Spécification de réfléctivité de matière (Petit truc)

Vous vous rappelez que dans le quatrième tutorial nous avons abordez la manière de procéder pour spécifier les propriétés réflectives de la matière d'un objet ? Si vous vous en rappelez alors alors je suis sur que vous avez remarquez qu'il est long et gourmand en mémoire de déclarer 3 variables distintes pour chaque matière situés dans une scène. Ce que je vous propose c'est de spécifier la réflectivé de votre matière non pas en racourcissant votre code de programmation mais en réduisant les variables utilisés pour le faire. Par contre cette commande s'avèrera intéressante(Optimisation) que si vous devez spécifier qu'un seul paramètre de matière pour la majorité des sommets de la scène. Dans mon exemple, à téléchargé en bas, vous constaterez que j'ai utilisé cette commande pour toutes les paramètre mais ici ce n'est pas important car ce n'est que pour comprendre le principe. Une fois que vous avez terminez l'utilisation de cette commande il est conseillé de la désactivé pour agumenter les performances de votre application.
Activation et désactivation de la commande en question :

glEnable( GL_COLOR_MATERIAL );
   ... 
     Spécification des paramères de réflectivité des ou de la matières     
   ...
glDisable( GL_COLOR_MATERIAL );

Créer une lumière éclairant un objet en mouvement

Comme la lumière doit suivre l'objet en question alors la position de celle-ci doit toujours être invoquée juste après la transformation de l'objet à suivre. Notez que si vous dessinez d'autres primitives après avoir invoqué la position de la lumière celle-ci affectera aussi ces primitives. Si vous désirez dessiner plusieurs primitives dans votre scène alors n'oubliez pas de vous servir grâcieusement des deux commandes magiques : glPushMatrix et glPopMatrix. Je parle encore des deux commandes magiques car il ne faut pas oublier que la lumière affecte autant la matrice de modélisation que la lumière peut affecter la couleur des primitives dans la scène.

Si vous désirez afficher une primitive représentant la lumière elle-même alors elle ne devrait pas être affecter par sa propre source de lumière donc il serait mieux d'éteindre la lumière, d'afficher la primitive représentant la lumière et d'ensuite réallumer la lumière. Comment faire ?

{Activer la l'éclairage}
 glEnable( GL_LIGHTNING );
  
 {On dessine la primitive représentant la source de lumière}
  
{Désactiver l'éclairage}
 glDisable( GL_LIGHTNING );

Maintenant nous alons constuire une plate-forme avec un projecteur se déplacant au-dessus d'elle. Ce n'est pas difficile mais soyez tout de même attentif à chaque paramètre qui seront utilisés...

     glPushMatrix();

{Déplacement aléatoire de la lumière au-dessus de la plate-forme}
         glTranslated(-4 * Cos(DegreRot1) * -5 * Cos(DegreRot2),
                       5 * Sin(DegreRot1),
                      -6 * Cos(DegreRot1) * 4 * Sin(DegreRot2));

         glLightf( GL_LIGHT0, GL_SPOT_EXPONENT, 30 + (10 * Sin(DegreRot2)) );
         glLightfv( GL_LIGHT0, GL_POSITION, @Lumiere0_Position );

{On dessine la primitive représentant la source lumineuse}
         glDisable( GL_LIGHTING );
            glPointSize( 3.0 );
            glColor3f( 1.0, 1.0, 1.0);
            glBegin( GL_POINTS );
               glVertex3d( Lumiere0_Position[0], 
                           Lumiere0_Position[1], 
                           Lumiere0_Position[2] );
            glEnd();
         glEnable( GL_LIGHTING );

     glPopMatrix();

glTranslated...: En premier lieu, une translation est effectuée dans tous les sens pour faire pivoter la première lumière. Le but est seulement d'en faire un projecteur actif alors il n'y a rien de spécial à comprendre ici, à part le fait d'appliquer pleins de rotations dans la matrice de modélisation.
glLightf( GL_LIGHT0, GL_SPOT_EXPONENT...: Ici, on modifie l'intensité de la lumière. Maintenant pour faire un genre d'effet de rotation aléatoire, on se sert de variables qui représente des degrées qui sont incrémentés à chaque rafraîchissement de la scène.
glLightf( GL_LIGHT0, GL_POSITION...: La variable tableau "Lumiere0_Position" possède 3 valeurs GLfloat qui représente la position de la lumière. Quand la scène bouge ou plutôt dire quand la matrice de modélisation est affectée par des déplacements quelconques alors la lumière se déplace en fonction du mouvement de la scène. Donc la position de la lumière n'est plus spécifiée par la variable " Lumiere0_Position " mais plutôt récupérée par celle-ci.
glPointSize( 3.0 ): Humm! Nouvelle commande innédite... Elle n'a vraiment rien d'extraordinaire à part le fait de spécifer la grosseur des pixels dessinés dans la scène. Cette commande est surtout utilisée dans un procédé appelé Antialiasing. L'Antialiasing sera expliqué un peu plus tard.
glVertex3d( Lumiere0_Position[0], ... );: Vous connaissez déjà cette commande j'espère . Comme la variable " Lumiere0_Position " a récupéré la nouvelle position de la lumière dans la scène alors nous nous en servons pour placer un gros Pixel qui représente le projecteur lui-même. Mais remarquez que cela aurait pu être une sphère ou toutes autres primitives de votre choix.

Éclairage se déplacant avec le point de vue: Si l'on veut déplacer la lumière avec le point de vue ou plutôt, déplacer le point de vue et que la lumière suivre, il faut spécifier sa position dans l'événement OnResize(), juste avant la transformation de visualisation (PROJECTION), ou si vous aimez mieux juste avant que la matrice de projection soit activée/modifiée.
Comme ceci :

     glLightfv( GL_LIGHT0, GL_POSITION, @LumiereX_Position );

     glViewport( 0, 0, ClientWidth, ClientHeight );
     glMatrixMode( GL_PROJECTION );
     glLoadIdentity();

     gluPerspective( 45, Width / Height, 0.1, 200.0 );

Capture d'écran: Très bel effet non ?
On dirait un planché de danse...

Programme relié

Cet exemple n'est pas des plus originales mais elle représente des projecteurs situés en haut d'une plateforme qui réflète la lumière de ceux-ci. Ce qui est est à surveiller, c'est l'optimisation possible que l'on peut apporter à cette petite application, comme par exemple les fonctions Cos et Sin qui sont extrêmement utilisées. Pour remédier à ce problème il faudrait créer deux tableaux précalculés de leurs valeurs... De plus, quelques commandes OpenGL sont répétées en double à mainte reprise et cela n'est fait que dans un but pédagogique, donc il ne servent à rien. Pour vous pratiquer vous pourriez :

Optimiser le programme (Si vous comprennez bien le fonctionnement).
Créer des murs à la plateforme et s'organiser pour que les lumières réflètent sur ceux-ci.
(Petit truc: servez vous de la direction de la lumière).
Mais n'oubliez surtout pas de vous amuser...

Source

Retour