• Introduction
• Utilisation des tampons
• Tests et opérations sur les fragments
• Requête d'occlusion
• Le tampon d'accumulation
• Exercice

Après la rastérisation (y compris le texturage et le fog), les données sont des fragments qui contiennent des coordonnées correspondant à un pixel, ainsi que des valeurs chromatiques et de profondeur.
Ces fragments subissent une série de tests ( le test de scission, le test alpha, le test de stencil et de profondeur ) et d'opérations (logiques et de fondu) avant de devenir des pixels.


Définitions

• Une zone mémoire permettant de stocker une certaine quantité de données fixe par pixel est appelée tampon (buffer).
• Un tampon stockant un seul bit par pixel est appelé bitplan.
  
• Le tampon servant à stocker la couleur de chaque pixel est appelé Tampon chromatique ou Frame-Buffer.
• Le tampon servant à stocker la profondeur de chaque pixel est appelé Tampon de profondeur ou Z-Buffer.
• Le tampon servant à restreindre le rendu à certaines portions de l'écran est appeléTampon Pochoir, Tampon Stencil ouStencil-Buffer.
• Le tampon servant à accumuler une série d'images dans une image finale est appelé Tampon d'Accumulation ou Accumulation-Buffer.


Le Tampon d'Image est le système OpenGL qui contient tous les tampons :
• les tampons chromatiques : (selon l'implémentation) avant-gauche, avant-droit, arrière-gauche, arrière-droit et un nombre quelconque de tampons chromatiques auxilliaires
• le tampon de profondeur
• le tampon stencil
• le tampon d'accumulation

Tampons stockant des couleurs

Tampons chromatiques

Les tampons chromatiques contiennent des données en mode couleur indexée ou RVB, et peuvent également accueillir des valeurs alpha.
• Une implémentation OpenGL supportant la stéréo comprend des tampons chromatiques gauche et droit. Si la stéréo n'est pas prise en charge, seuls les tampons de gauche sont utilisés.
• De même, si le double-buffering est supporté, le système comprend des tampons avant et arrière. En simple buffering, seuls les tampons avant sont utilisés.

  Tampon d'accumulation

  Il contient des données chromatiques RVBA. Le résultat de l'utilisation du tampon d'accumulation en mode couleurs indexées n'est pas défini. On ne dessine pas directement dans le tampon d'accumulation, les opérations d'accumulation se font par des transferts de données depuis ou vers un tampon chromatique.

Caractéristiques

Les capacités des tampons sont accessibles à l'aide de la fonction glGetIntegerv( ).
• Celles du tampon chromatique en mode RVBA sont données par les paramètres GL_RED_BITS, GL_GREEN_BITS, GL_BLUE_BITS, GL_ALPHA_BITS.
• Celles du tampon chromatique en mode couleurs indexées sont données par le paramètre GL_INDEX_BITS.
• Celles du du tampon de profondeur sont données par le paramètre GL_DEPTH_BITS.
• Celles du du tampon stencil sont données par le paramètre GL_STENCIL_BITS.
• Celles du du tampon d'accumulation sont données par les paramètres GL_ACCUM_RED_BITS, GL_ACCUM_GREEN_BITS, GL_ACCUM_BLUE_BITS, GL_ACCUM_ALPHA_BITS.

De plus :
• Les paramètres GET_STEREO et GET_DOUBLEBUFFER permettent de savoir si la stéréo et le double buffering sont supportés.
• Le nombre de tampons auxiliaires est donné en utilisant le paramètre GL_AUX_BUFFERS.
  

Utilisation des tampons

Allouer les tampons

Il faut faire appel à la fonction glutInitDisplayMode(... ) pour allouer la mémoire des tampons que l'on utilise
Dans main(): glutInitDisplayMode(... ) avec selon les besoins, les valeurs GLUT_ACCUM, GLUT_DEPTH, GLUT_STENCIL.

Vider les tampons

Selon la taille du tampon, le vider peut constituer une des opérations les plus longues de l'application graphique. Certaines implémentations d'OpenGL permettent de vider plusieurs tampons en même temps. Pour en bénéficier, il faut commencer par spécifier les valeurs à écrire dans chaque tampon à vider, puis effectuer le vidage en appelant la fonction glClear() à laquelle on passe la liste de tous les tampons à vider.

Pour définir les valeurs de vidage des tampons, utiliser les commandes suivantes :

• void glClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha );
• void glClearIndex( GLfloat index );
• void glClearDepth( GLclampd depth );
• void glClearStencil( GLint s);
• void glClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha );

Ensuite, pour procéder au vidage, utiliser : glClear( GLbitfield mask ); avec comme valeur de mask, un OU logique parmi GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_STENCIL_BUFFER_BIT et GL_ACCUM_BUFFER_BIT.
Lors du vidage du tampon chromatique, tous les tampons chromatiques activés en écriture sont vidés.
Le test d'appartenance du pixel, le test de scission et le dithering sont appliqués à l'opération de vidage, s'ils sont actifs. Les opérations de masquage, telles que glColorMask() et glIndexMask() sont également opérationnelles.

Sélectionner les tampons chromatiques en écriture et en lecture

Les opérations de lecture peuvent s'effectuer depuis n'importe quel tampon chromatique. Celui-ci sera spécifié par glReadBuffer().
De même, le résulat des opérations de dessin ou d'écriture peut s'effectuer vers n'importe quel tampon chromatique, spécifié par glDrawBuffer().


Masquer les tampons

Avant qu'OpenGL n'écrive des données dans les tampons chromatique, de profondeur ou stencil actifs, une opération de masquage est appliquée aux données. Un ET logique est effectué entre le masque et les données à écrire.

Les fonctions correspondant sont glIndexMask, glColorMask, glDepthMask, et glStencilMask.

En particulier, pour désactiver le tampon de profondeur en écriture, ce qui est utile lors de l'affichage d'objets translucides, appeler glDepthMask(false).

Tests et opérations sur les fragments

Une fois que les fragments sont générés, 7 tests et opérations sont effectués pour intégrer le tampon d'image :

Test de scission (test de découpe)

Ce test permet de restreindre l'affichage à un rectangle donné dans la fenêtre. Il est utile, par exemple, dans le cas où différents processeurs sont utilisés pour calculer des parties d'une même image.
Pour activer/desactiver le test de découpe : glEnable/glDisable(GL_SCISSOR_TEST).
Pour définir le rectangle, on utilise glScissor(GLint x, GLint y, GLsizei largeur, GLsizei hauteur), où (x, y) sont les coordonnées du coin inférieur gauche de la fenêtre.

Par défaut, le test de découpe est désactivé.

Test alpha

Ce test permet d'utiliser la valeur de la composante alpha d'un fragment pour accepter ou rejeter celui-ci. Par exemple pour gérer correctement la transparence, on restitue une première fois la scène avec les fragments opaques, puis on désactive l'écriture dans le tampon de profondeur pour restituer la scène en acceptant uniquement les fragments dont la valeur alpha est différente de 1.
Pour activer/desactiver le test alpha glEnable/glDisable(GL_ALPHA_TEST).
Pour indiquer la fonction de comparaison, et la valeur de référence : glAlphaFunc(GLenum fonction, GLclampf val). La valeur de référence val est arrondie entre 0 et 1.

Par défaut, le test alpha est désactivé.

Test stencil (test du pochoir)

Ce test est utilisé en association avec le Tampon Stencil.
Pour activer/desactiver le test stencil glEnable/glDisable(GL_STENCIL_TEST).
Pour indiquer la fonction de comparaison glStencilFunc(), et les opérations à réaliser glStencilOp().

Par défaut, le test stencil est désactivé.

Test de profondeur

Pour activer/desactiver le test de profondeur glEnable/glDisable(GL_DEPTH_TEST).
Pour indiquer la fonction de comparaison glDepthFunc().

Par défaut, le test de profondeur est désactivé. La fonction de comparaison, elle, vaut GL_LESS : le fragment entrant est accepté si sa valeur est inférieure à celle du tampon de profondeur.
Le z correspond à la distance entre le point de vue et l'objet. Plus l'objet est proche, plus son z est petit.

Blending

Pour activer/desactiver le blending glEnable/glDisable(GL_BLEND).
Pour indiquer la fonction de blending, on utilise glBlendFunc() ou glBlendFuncSeparate(), qui permet d'avoir une opération de blending pour les composantes RVB distincte de celle de la composante Alpha.
Lorsqu'une couleur constante est spécifiée, elle est définie par la fonction glBlendColor().
On peut également combiner les pixels à l'aide d'équations de blending, avec glBlendEquation() ou glBlendEquationSeparate().

Dithering (tramage)

Il s'agit d'une méthode qui permet de simuler une couleur lorsque le nombre de couleurs est limité, en juxtaposant des points de couleurs différentes.
Pour activer/desactiver le dithering : glEnable/glDisable(GL_DITHER).

Par défaut, le dithering est activé.

Opérations logiques

Il s'agit d'opérations comme OR, XOR ou INVERT, qui s'appliquent aux fragments source ou destination.
Pour activer/desactiver les opérations logiques, on utilise glEnable/glDisable(GL_COLOR_LOGIC_OP) en mode RVBA, ou glEnable/glDisable(GL_INDEX_LOGIC_OP) en mode couleurs indexées.
Pour indiquer l'opération à effectuer glLogicOp(GLenum op).

Par défaut, les opérations logiques sur les fragments sont désactivées.

Requête d'occlusion

Le tampon de profondeur permet de tester si un objet est visible. En l'interrogeant, on peut connaître le nombre de fragments qui passent le test de profondeur.
C'est utile, par exemple, pour éviter de restituer un objet complexe si la requête d'occlusion de sa boîte englobante retourne qu'aucun fragment n'est visible.
La requête et sont traitement s'opérent en 6 étapes :
1. Générer un identifiant de requête, à l'aide de glGenQueries().
2. Indiquer le début de la requête avec glBeginQuery(GL_SAMPLES_PASSED, ...).
3. Restituer la géométrie à tester
4. Indiquer la fin de la requête avec glEndQuery(GL_SAMPLES_PASSED).
5. Demander le nombre de fragments visibles avec glGetQueryObject[u]iv().
6. Libérer les ressources liées aux requêtes, avec glDeleteQueries().
   

Le tampon d'accumulation

Son utilisation est la suivante : une série d'images, générées chacune dans l'un des tampons chromatiques, sont accumulées une à une dans le tampon d'accumulation. Lorsque l'accumulation est terminée, le résultat est copié dans un tampon chromatique pour affichage.
Pour réduire les erreurs d'arrondis, le tampon d'accumulation peut disposer d'une précision plus élevée (plus de bits par pixels par exemple) que les tampons chromatiques standards.
Plusieurs restitutions d'une scène prennent plus de temps qu'une seule, mais le résultat est de meilleure qualité.

void glAccum(GLenum op, GLfloat value); contrôle le tampon d'accumulation.
Le paramètre op sélectionne l'opération, et peut avoir pour valeur GL_ACCUM, GL_LOAD, GL_RETURN, GL_ADD ou GL_MULT.
value est un nombre à utiliser dans cette opération.

• GL_ACCUM lit chaque pixel du tampon sélectionné avec glReadBuffer(), multiplie les valeurs RVBA par value et ajoute les valeurs obtenues au tampon d'accumulation.
• GL_LOAD est semblable à GL_ACCUM, mais les valeurs calculées remplacent le contenu du tampon d'accumulation.
• GL_RETURN prend les valeurs du tampon d'accumulation, les multiplie par value, et place le résultat dans le ou les tampons chromatiques activés en écriture.
• GL_ADD ajoute (resp. GL_MULT multiplie ) value à (resp. par ) la valeur de chaque pixel du tampon d'accumulation et retourne le résultat dans le tampon d'accumulation. Pour GL_MULT, value est arrondi à l'intervalle [-1.0, 1.0], GL_ADD il n'est pas arrondi.

Voici un récapitulatif des opérations :

glAccum(GL_ACCUM, v) :	TamponAccumulation =	TamponAccumulation + v*TamponChromatique
glAccum(GL_LOAD, v) :	TamponAccumulation =	v*TamponChromatique
glAccum(GL_RETURN, v) :	TamponChromatique =	v*TamponAccumulation
glAccum(GL_ADD, v) :	TamponAccumulation =	v+ TamponAccumulation
glAccum(GL_MULT, v) :	TamponAccumulation =	v *TamponAccumulation

Lisser une scène

Pour effectuer l'antialiasing d'une scène, le principe est d'accumuler n versions de la même scène, légèrement décalées :
• Commencer par vider le tampon d'accumulation
• Accumuler chaque image par : glAccum(GL_ACCUM, 1.0/n);
• Afficher l'image finale par glAccum(GL_RETURN, 1.0);
Noter que cette méthode est un peu plus rapide si la première image est chargée dans le tampon d'accumulation sans le vider, en utilisant GL_LOAD à la place de GL_ACCUM.

Pour éviter que les n images intermédiaires de la scène ne soient affichées, dessinez-les dans un tampon chromatique qui n'est pas affiché.

Jittering

Le procédé selon lequel on applique un léger décalage aux versions intérmédiaire la scène s'appelle jittering. Le décalage doit avoir une valeur de moins d'un pixel en x et y par rapport à l'image de référence.
Les routines accPerspective() et accFrustum() de l'exemple accpersp.c peuvent être employées à la place de gluPerspective() et glFrustum().
Si vous avez choisi une perspective cavalière, comme dans l'exemple accanti.c, utilisez glTranslate*() pour décaler la scène, en vous rappelant que le décalage doit être inférieur à 1 pixel mesuré en coordonnées écran.
Le fichier jitter.h donne des valeurs de décalages utilisables pour n=2,3,4,8,15,24 et 66.

Fondu enchaîné

Pour créer un effet de fondu-enchaîné, ou une impression de mouvement, copiez la scène obtenue au temps précédent dans le tampon d'accumulation, et appelez glAccum(GL_MULT, coeffAttenuation); avec un coefficient compris strictement entre 0.0 et 1.0, afin d'atténuer l'image. Calculez ensuite la nouvelle scène,

Profondeur de champ

La mise au point d'une photographie n'est parfaite que pour les éléments se trouvant à une certaine de l'appareil photographique.
Pour simuler cet effet avec OpenGL, le tampon d'accumulation va servir à accumuler différentes images dans lesquelles seul un plan de mise au point parfaite va rester stable.
Le fichier dof.c est un exemple de simulation de la profondeur de champ.

Simulez un effet de fondu-enchaîné sur une théière en rotation autour de son axe vertical.
Cela se réalise avec les fonctions suivantes : (pour un paramètre alpha compris entre 0 et 1)

TamponAccumulation = SceneCourante + alpha*TamponAccumulation
SceneCourante = TamponAccumulation