Effet de brouillard réaliste

Nous recherchons toujours des traducteurs pour finir ce projet de traduction des articles de NeHe. Votre aide serait appréciée ! Vous êtes intéressé ? Alors contactez-nous à l'adresse suivante : .

Vous voulez donc ajouter du brouillard à votre programme OpenGL. Bien, dans ce tutoriel, je vais vous montrer comment le faire. C'est la première fois que j'écris un tutoriel, et, je suis relativement nouveau à la programmation OpenGL / C++, donc, s'il vous plaît, si vous trouvez quelque chose de faux, faites-le-moi savoir et ne me sautez pas dessus. Ce code est basé sur le code de la leçon 7.

Nous allons commencer par définir toutes les variables nécessaires pour définir le brouillard. La variable fogMode va être utilisée pour contenir les trois types de brouillard : GL_EXP, GL_EXP2 et GL_LINEAR. Je vais vous expliquer les différences entre ces trois variables plus tard. Les variables sont placées au début du code après la ligne GLuint texture[3]. La variable fogfilter va être utilisée pour garder une trace du type de brouillard que nous utilisons. La variable fogColor va contenir la couleur que nous souhaitons avoir pour le brouillard. J'ai aussi ajouté une variable booléenne gp, en haut du code, pour savoir si la touche 'g' a été pressée.

bool   gp;                        // G Pressée ? (AJOUT) 
GLuint filter;                        // Quel filtre utiliser 
GLuint fogMode[]= { GL_EXP, GL_EXP2, GL_LINEAR };    // Stockage pour trois types de brouillard 
GLuint fogfilter= 0;                    // Quel brouillard utiliser 
GLfloat fogColor[4]= {0.5f, 0.5f, 0.5f, 1.0f};        // Couleur du brouillard

Maintenant que nous avons établi nos variables, nous pouvons passer à InitGL. La ligne glClearColor() a été modifiée pour effacer l'écran avec la même couleur que celle du brouillard afin d'avoir un meilleur effet. Il n'y a pas beaucoup de code pour faire fonctionner le brouillard. Vous allez trouver le code très simpliste par rapport aux autres que vous pourrez trouver.

glClearColor(0.5f,0.5f,0.5f,1.0f);            // Nous allons effacer l'écran avec la couleur du brouillard (MODIFIÉ) 

glEnable(GL_FOG);                    // Active GL_FOG 
glFogi(GL_FOG_MODE, fogMode[fogfilter]);        // Mode du brouillard 
glFogfv(GL_FOG_COLOR, fogColor);            // Définit la couleur du brouillard 
glFogf(GL_FOG_DENSITY, 0.35f);                // Définit la densité du brouillard 
glHint(GL_FOG_HINT, GL_DONT_CARE);            // Définit l'indice du brouillard 
glFogf(GL_FOG_START, 1.0f);                // Définit la distance où commence le brouillard 
glFogf(GL_FOG_END, 5.0f);                // Définit la distance où s'arrête le brouillard

Prenons d'abord les trois premières lignes. La première ligne glEnable(GL_FOG); est explicite. Cela active le brouillard.

La deuxième ligne, glFogi(GL_FOG_MODE, fogMode[fogfilter]); définit le mode de filtrage du brouillard. Plus tôt nous avons déclaré le tableau fogMode. Il contient GL_EXP, GL_EXP2 et GL_LINEAR. C'est ici où les variables rentrent en jeu. Laissez-moi vous expliquer chacune d'elles :

* GL_EXP - rendu basique du brouillard, qui cache tout sur l'écran. Cela ne donne pas vraiment un effet de brouillard, mais fait le travail sur les vieux PC ;

* GL_EXP2 - c'est la prochaine étape après GL_EXP. Cela va cacher tout sur l'écran, bien que cela va donner plus de profondeur à la scène ;

* GL_LINEAR - c'est le meilleur rendu de brouillard. Les objets vont entrer et sortir du brouillard beaucoup mieux.

La troisième ligne, glFogfv(GL_FOG_COLOR, fogcolor); définit la couleur du brouillard. Plus tôt, nous avions défini cela à (0.5f,0.5f,0.5f,1.0f) dans la variable fogcolor, donnant une jolie couleur grise.

Regardez ensuite les quatre prochaines lignes de code. La ligne glFogf(GL_FOG_DENSITY, 0.35f); définit la densité du brouillard. Augmentez ce nombre et le brouillard deviendra plus dense, réduirez-le et il deviendra moins dense.

La ligne glHint(GL_FOG_HINT, GL_DONT_CARE); définit l'indice. J'ai utilisé GL_DONT_CARE, parce que la valeur de l'indice m'importe peu.

Eric Desrosiers ajoute : petite explication sur glHint(GL_FOG_HINT, hintval) :

hintval peut être : GL_DONT_CARE, GL_NICEST ou GL_FASTEST

• GL_DONT_CARE - laisse OpenGL choisir la nature du brouillard (par vertex ou par pixel) et une formule inconnue ;
• GL_NICEST - donne un brouillard par pixel (donne un bon effet) ;
• GL_FASTEST - donne un brouillard par vertex (plus rapide, mais moins beau).

La prochaine ligne glFogf(GL_FOG_START, 1.0f); va définir la distance à laquelle le brouillard devra commencer. Vous pouvez changer ce nombre par ce que vous voulez, dépendant de l'endroit où vous voulez commencer le brouillard. La prochaine ligne est similaire, glFogf(GL_FOG_END, 5.0f);. Ceci indique au programme OpenGL la distance à laquelle le brouillard devra s'arrêter.

Maintenant que nous avons défini le code du dessin du brouillard, nous allons ajouter la commande clavier pour changer les modes de brouillard. Le code sera situé à la fin du programme avec tout le reste du code de gestion des touches.

if (keys['G'] && !gp)                    // La touche G est-elle appuyée ? 
{ 
    gp=TRUE;                    // gp est mis à TRUE 
    fogfilter+=1;                    // Augmente fogfilter de un 
    if (fogfilter>2)                // Si fogfilter est plus grand que 2 
    { 
        fogfilter=0;                // On redéfinit fogfilter à zéro 
    } 
    glFogi (GL_FOG_MODE, fogMode[fogfilter]);    // Mode de brouillard 
} 
if (!keys['G'])                        // La touche G a-t-elle été relâchée ? 
{ 
    gp=FALSE;                    // gp est mis à FALSE 
}

Voilà ! C'est fait ! Vous avez maintenant du brouillard dans votre programme OpenGL. Je voudrais dire que c'était sans peine…

Christopher Aliotta (Precursor)

Jeff Molofee (NeHe)

Compte tenu du nombre de versions de codes source pour les tutoriels NeHe, nous les laissons en anglais. En principe, si vous avez compris le code présenté dans ce tutoriel (et les tutoriels antérieurs), vous n'aurez pas de mal à les comprendre :

• Borland C++ Builder 6 (Conversion by Christian Kindahl) ;
• C# (Conversion by Brian Holley) ;
• Code Warrior 5.3 (Conversion by Scott Lupton) ;
• Cygwin (Conversion by Stephan Ferraro) ;
• Delphi (Conversion by Michal Tucek) ;
• Dev C++ (Conversion by Dan) ;
• Euphoria (Conversion by Evan Marshall) ;
• Game GLUT (Conversion by Milikas Anastasios) ;
• Irix/GLUT (Conversion by Rob Fletcher) ;
• Java (Conversion by Jeff Kirby) ;
• JoGL (Conversion by Nicholas Campbell) ;
• LCC Win32 (Conversion by Robert Wishlaw) ;
• Linux (Conversion by Daniel Davis) ;
• Linux/GLX (Conversion by Mihael Vrbanec) ;
• Linux/SDL (Conversion by Ti Leggett) ;
• LWJGL (Conversion by Mark Bernard) ;
• Mac OS (Conversion by Anthony Parker) ;
• Mac OS X/Cocoa (Conversion by Bryan Blackburn) ;
• MASM (Conversion by Greg Helps) ;
• Visual C++/OpenIL (Conversion by Denton Woods) ;
• Pelles C (Conversion by Pelle Orinius) ;
• SDL (Conversion by Ken Rockot) ;
• Visual Basic (Conversion by Ross Dawson) ;
• Visual Basic (Conversion by Peter De Tagyos) ;
• Visual C++ ;
• Visual Studio .NET (Conversion by Grant James).

Merci Winjerome pour sa relecture ainsi que ClaudeLELOUP pour ses corrections.

Sommaire.

Tutoriel précédent : Application de texture sur les polices vectorielles.

Tutoriel suivant : Texture 2D de police