Quelques techniques de rendu

Principe

Ce document vise à recenser les techniques de rendu les plus usuelles.

Plusieurs explications sont fortement inspirées de la source officielle pour l'apprentissage d'OpenGL, le Red Book, qui aborde de manière très réussie certaines problématiques du rendu qui ne sont pas uniquement relatives à OpenGL.

Double-buffering

Ce terme, difficile à traduire ("utilisation d'un double tampon vidéo") décrit une technique courante utilisée afin que les animations soient fluides.

L'idée la plus naturelle pour réaliser une animation est de faire se succéder des images à grande vitesse pour, comme dans le cas des films, donner l'illusion d'un mouvement continu grâce à la persistance rétinienne. Ainsi, si chaque seconde 24 images se succèdent, l'animation est agréable à l'oeil et ne paraît pas trop saccadée (au contraire des films de Charlie Chaplin qui n'en avaient que 16 par seconde).

On pense alors à un algorithme du genre :

tant que temps < tempsMax 
{
	effacerFenetre()
	dessinerImage( temps )
	attendreFinVingtquatriemeDeSeconde()
}			

Le défaut d'une telle technique est que les images affichées ne sont pas d'emblée complètes. Ainsi, pour une scène compliquée, le rendu peut durer presque la totalité du vingt-quatrième de seconde, et les effets des dernières primitives graphiques ne seront donc restés à l'écran très peu de temps, alors que ceux des premières primitives auront été présents presque la totalité du temps imparti. Cela donne des animations à la qualité visuelle mauvaise.

Une bien meilleure technique est celle du double buffering, qui consiste à utiliser tour-à-tour deux mémoires vidéo. Quand l'une des deux sera visible, on dessinera dans l'autre, et à chaque vingt-quatrième de seconde, on les inversera.

Les avantages de cette technique sont certains : chaque image est d'emblée complète, sans que cela nécessite plus de ressources (hormis l'espace mémoire correspondant au second tampon vidéo) que la technique précédente : dans les deux cas, pendant chaque intervalle de temps (un vingt-quatrième de seconde par exemple), une image est dessinée.

Cela donne un algorithme du genre :

tant que temps < tempsMax 
{
	effacerFenetre()
	dessinerImage( temps )
	echangerTamponsVideo()
	attendreFinVingtquatriemeDeSeconde()
}			

Une dernière amélioration, qui cette fois-ci nécessite que le matériel le permette, est de se synchroniser l'interversion des tampons vidéo sur la fréquence de rafraîchissement de l'écran, c'est-à-dire de ne jamais modifier un tampon visible lorsque l'écran est en train de le balayer en l'affichant.

Cela évite des scintillements et pleurages (tearing) qui nuisent à la perception de l'animation : avec une telle synchronisation, une image ne sera pas dessinée à cheval sur deux rafraîchissements successifs de l'écran.

Triple buffering

Appelée aussi semi-triple buffering, cette technique, comme son nom l'indique, consiste à utiliser non plus deux mais trois tampons vidéo. Cette adjonction ne sert pas à rendre directement l'animation plus fluide (deux tampons suffisent pour cela), mais permet d'avoir un double-buffering classique dans la mémoire vidéo tout en utilisant un troisième tampon en mémoire principale. Ce tampon sera celui où le rendu effectif sera réalisé, et une fois achevé il sera copié (blitté, c'est-à-dire transféré le plus efficacement possible dans une autre zone de mémoire) en mémoire vidéo, dans le tampon de rendu, en attendant, par le jeu du double-buffering, d'être visible.

Cette technique est intéressante dans la mesure où écrire et surtout lire dans la mémoire vidéo est extrêmement long. Il est donc souvent plus efficace de réaliser toutes les modifications dans la mémoire principale avant de transmettre le résultat au système de double buffering.

Une telle organisation n'est néanmoins pas applicable avec OpenGL, puisque le rôle de ce dernier est de prendre en charge le rendu effectif, et de le réaliser (à l'exception des implémentations logicielles) directement en mémoire vidéo.

OpenGL

OpenGL n'est pas en lui-même une technique de rendu, mais un moyen de faire directement usage des capacités de rendu de la la carte graphique, qui sont souvent prises en charge de manière matérielle, donc accélérées et susceptibles de décharger d'autant le processeur principal (CPU). OpenGL est donc une interface normalisée qui permet, grâce à plus de 150 commandes, de contrôler le système graphique de manière uniforme, et de l'utiliser pour représenter des données tridimensionnelles.

Son intérêt est donc non seulement de donner accès à la ressource précieuse de l'éventuel processeur graphique (GPU), souvent nécessaire pour qu'une application graphique et interactive ait des performances suffisantes, mais aussi de donner un accès uniforme, c'est-à-dire indépendant de la réalisation matérielle sous-jacente. Ainsi, grâce à OpenGL, on peut demander le rendu d'un polygone texturé sans avoir à prendre en compte quelle carte vidéo est installée.

Pour qu'OpenGL soit réellement indépendant de la plate-forme, il ne prend en compte ni la gestion des fenêtres de l'environnement graphique, ni la collecte des événements en provenance des périphériques d'entrée, issus de l'utilisateur. Il est donc nécessaire de lui adjoindre d'autres ingrédients logiciels, comme SDL [Plus d'infos sur OpenGL (avec SDL)].

N'hésitez pas à nous faire part de votre avis !

Si vous disposez d'informations plus détaillées ou plus récentes que celles présentées dans ce document, si vous avez remarqué des erreurs, oublis, ou points insuffisamment traités, envoyez-nous un courriel !