OpenGL avec Delphi

La brume, bien qu'elle soit fatigante quand on conduit elle s'avère très utile pour ce qui est d'animation 3D.

Nous verrons pourquoi… Le brouillard nous offre beaucoup d'avantages dont les suivants :

• apporter du réalisme aux scènes et à l’effet 3D (par rapport à leurs distances entre la vue du spectateur et l'objet lui-même. Par exemple regardez des montagnes de très loin et elles vous apparaîtront s'affadirent, mais comparé à un objet vu de près, il est très clair et précis) ;
• dans un simulateur de vol, la brume peut s'avérer utile pour donner l'impression d'une visibilité réduite ;
• sur des GROS programmes de simulation 3D, le fog peut améliorer les performances en éliminant les objets dont leur distance est trop éloignée pour être perçus ;
• donner une meilleure impression d'être sous l'eau ;
• il y a des tonnes d'autres avantages…

Bon maintenant je dois vous aviser qu'activer le FOG sous OpenGL est une vraie farce, une affaire de deux secondes tout au plus . Voilà la manière de procéder :

FogCouleur :Array[0..3] Of TGLfloat = (0.5, 0.5, 0.5, 1.0 );
glFogf( GL_FOG_MODE, GL_LINEAR );
glFogf( GL_FOG_DENSITY, 0.35 );
glFogi( GL_FOG_START, 3.0);
glFogi( GL_FOG_END, 30.0);
glFogfv( GL_FOG_COLOR, @FogCouleur );

glClearColor( 0.5, 0.5, 0.5, 1.0 );    
glEnable( GL_DEPTH_TEST );
glEnable( GL_FOG );

FogCouleur :Array[0..3] Of TGLfloat = (0.5, 0.5, 0.5, 1.0 );
Variable tableau contenant la couleur de la brume, donnée sous format (R, G, B, A).
Ordinairement grisâtre…

glFogf( GL_FOG_MODE, GL_LINEAR );
Détermine le facteur de brume, GL_LINEAR, GL_EXP ou GL_EXP2. Celui le plus couramment utilisé est le mode linéaire. Pour plus d'informations, consultez le fichier OpenGL.hlp que je vous ai donné au premier tutoriel.

glFogf( GL_FOG_DENSITY, 0.35 );
Détermine la densité de la brume d'où la plus petite valeur est 0.0 et la valeur la plus élevée est 1.0.

glFogi( GL_FOG_START, 3.0);
Détermine la position où la brume commence à faire son effet.

glFogi( GL_FOG_END, 30.0);
Détermine la position où la brume perd son effet et par conséquent où OpenGL arrête de dessiner les primitives, car elles sont « PERDUES DANS LA BRUME ».

glFogfv( GL_FOG_COLOR, @FogCouleur );
Affecte une couleur à la brume, ici la couleur est contenue dans notre variable tableau FogCouleur. Comme cette commande demande un pointeur (adresse) sur un tableau ayant les paramètres requis pour la couleur alors c'est pour cela que nous plaçons un « @ » devant le nom de la variable tableau.

glClearColor( 0.5, 0.5, 0.5, 1.0 );
Bien, vous allez me dire qu'on a déjà vu cette commande et qu'elle sert à vider le tampon chromatique avec une couleur passée en paramètre ou encore en d'autres mots elle sert à effacer l'écran. Et bien ici, elle a l'utilité de donner un effet normal à la brume, normalement la couleur de vidage est la même que celle de la brume. Comme la brume est plus que souvent grisâtre alors…

glEnable( GL_DEPTH_TEST );
Activation du tampon de profondeur.

glEnable( GL_FOG );
Bien entendu, si l'on veut utiliser la brume nous devons l'activer.

Le tout assisté de quelques lumières pour donner des couleurs, cela donne une très belle scène… Alors ce n'est pas sorcier ? Si vous avez des questions, n'hésitez pas à me contacter.

Qu'est-ce que c'est que ça encore ?

Surprise je vous explique comment se servir des objets quadriques de l'utilitaire GLU. Celui-ci nous offre la possibilité de construire des primitives telle que :

• gluCylinder : afficher un cylindre ;
• gluDisk : afficher un disque ou plutôt un cercle plein ;
• gluPartialDisk : même chose que le précédent, mais possibilité de le construire partiellement donc par exemple une pointe de tarte ;
• gluSphere : à la sphère… Indispensable.

Je parle de ces quadriques, car ils sont plus pratiques que ceux générés par l'utilitaire GLUT. On peut les texturer et non ceux de GLUT, car les coordonnées de textures ne sont pas spécifiées. On pourrait tout de même utiliser la texturation automatique pour texturer les primitives de GLUT, mais on verra ça dans un autre tutoriel. J'espère que vous êtes impatient de savoir comment ils fonctionnent ?

Pour créer un quadrique, on procède de la manière suivante :

Var
 {Object quadratique (GLU)}
   Objet :GLUquadricObj;
  ...
Begin
     {Créer l'object quadratics}
     Objet := gluNewQuadric;
     
     {Créer une sphère avec ses coordonnées de texture}
     gluQuadricTexture( Objet, GL_TRUE );
     gluSphere( Objet, 1.0, 20, 20 );

     {Créer une sphère SANS coordonnée de texture}
     gluQuadricTexture( Objet, GL_FALSE );
     gluSphere( Objet, 1.0, 20, 20 );
     
     ...
     
     {Ne pas oublier de supprimer l'objet}
     gluDeleteQuadric( Objet );
End;

C'est une petite intro de ce que l'on peut faire de ces objets, mais je vous propose de jeter un coup d'œil dans le fichier d'aide d'OpenGL pour accéder aux autres possibilités de ceux-ci.

Bon OK… Ce n'est pas Quake, mais au moins les lumières s'éteignent !
Quand vous pressez les touches de 1 à 3 vous pouvez éteindre les lumières dans l'ordre avant vers l'arrière. Ce n'est pas un petit exemple, car j'ai conclu que la brume était trop facile à gérer alors j'ai mis un peu de « challenge » pour la fin. Bon apprentissage…

Source

Pour ceux que cela intéresse, voici l'autre manière. Source (à la C++)