Direct3D Le pipeline de rendu
Un article de Mangue.org, l'encyclopéde libre.
Tel les pipelines gigantesques transportant du pétrole d'un point à un autre, le pipeline de rendu de DirectX transporte vos données à travers votre carte 3D et votre CPU afin de produire leur représentation à l'écran. Pour afficher une image à l'écran, DirectX exploite les informations que nous lui fournissons à travers les différents modules composant le pipeline, afin d'arriver au rendu final. Pour simplifier, on peut distinguer trois modules : le module de géométrie, le module de texturing, et pour finir le module de rasterization. Examinons un à un chacun de ces modules.
| Sommaire |
Module de géométrie
Une fois les données préparées au sein du programme, elles résident dans le CPU et en mémoire système. Lors du lancement du processus de rendu, elles sont envoyées en mémoire AGP ou dans la mémoire de la carte elle-même, d'où elles sont transmises soit à l'unité de transformation et d'éclairage (Transform and Lightning, le fameux T&L) soit à l'unité qui traite les vertex shaders, selon la technique utilisée par le programme. Si les données sont traitées par le T&L, on leur applique les transformations demandées (le terme "transformation" désigne les opérations de translation, rotation et homothétie, c'est à dire la modification de la taille d'un objet dans son ensemble). Une fois ces traitements appliqués, l'éclairage peut être calculé, suivant les sources de lumières définies. Dans le cas contraire, les données seront traitées par vertex shaders. Sous ce nom trompeur (shade = ombre en anglais) se cache un outil extrêmement puissant. Comme nous le verrons, un objet 3D est constitué de vertices. (un vertex, des vertices) Les vertex shaders permettent tout simplement de manipuler les données des vertices à partir de la carte 3D. Ainsi, si l'on souhaite déformer un objet représentant un visage afin de lui donner une expression, il n'est plus nécessaire de faire calculer d'abord par le CPU le nouvel objet déformé avant de l'envoyer au T&L ; on peut dorénavant faire exécuter ces opérations par la carte 3D elle-même. Plus concrètement, les vertex shaders octroient la faculté d'écrire de petits programmes exécutés par la carte et qui vont manipuler les données des vertices. Quand bien même ces opérations seraient réalisées plus rapidement par le CPU que par la carte, cette méthode permet de minimiser les échanges de données entre le CPU et la carte, qui représente un goulot d'étranglement non négligeable. Cette façon de faire est donc, au final, plus efficace.
Attention, les données transitent ou bien via le T&L, ou bien via l'unité de traitement des vertex shaders: en conséquence, si vous souhaitez à la fois utiliser les shaders et appliquer des transformations et des lumières à vos objets, il faudra l'implémenter dans les shaders.
Une fois ce stade passé, les données sont envoyées à l'unité de clipping, qui va se charger d'éliminer des données 3D qui transitent la part qui ne sera pas visible à l'écran, de façon à ne pas effectuer de calculs pour des données qui n'apparaitront pas dans le résultat final.
Vue d'ensemble du pipeline.
Module de texturing
Après l'étape de transformation géométrique, passons au texturing. Les données passent soit par l'unité de multitexturing, soit par l'unité qui traite les pixels shaders. Le multitexturing, comme son nom l'indique, permet d'appliquer une ou plusieurs textures sur une surface. Les cartes 3D "modernes" permettent d'appliquer plusieurs textures d'un seul coup (on dit "en une seule passe") au même objet. Par exemple, une geForce3 permet d'habiller un objet avec quatre textures en une seule passe. C'est grâce au multitexturing qu'on peut utiliser la technique du lightmapping, qui permet d'obtenir des résultats très réalistes. Cette méthode consiste à utiliser un jeu de textures pour donner son aspect général à un objet, et un autre jeu pour lui appliquer des effets de lumière précalculés.
Si les vertex shaders permettent une plus grande flexibilité dans la manipulation de la géométrie des objets, les pixels shaders sont leurs équivalents pour les pixels. On peut grâce à eux changer la façon dont les pixels sont sélectionnés, mélangés et rendus. Cela permet par exemple de créer des effets comme la gestion de l'éclairage par pixel (plutôt que de la gérer par vertices, puis d'interpoler) ou le bump-mapping.
Si un brouillard a été demandé par le programme, c'est une fois le multitexturing ou le pixel shading achevé qu'il sera ajouté. Utile pour créer des ambiances, (montages embrumées, rue sombres...) il est cependant souvent utilisé pour limiter la profondeur de champ d'une scène, de façon à économiser des ressources en n'affichant pas les objets lointains, masqués par le brouillard.
Certains jeux utilisent le brouillard pour masquer l'horizon, et d'autres pour l'ambiance...
Module de rasterization
La rasterization désigne le processus qui, à partir des informations contenues dans les vertices, (couleurs, lumières diffuse et spéculaire, etc...) calcule quelles seront les valeurs de ces informations pour chaque pixel à afficher. Dans la majorité des cas, l'algorithme utilisé est l'interpolation bilinéaire.
Dans ce module, DirectX effectue des tests à l'aide du stencil buffer et du depth buffer, et calcule également les effets de transparence. Le test de profondeur (avec le depth buffer) détermine si le pixel courant est plus près de la caméra que l'ancien pixel occupant la même position. Si c'est le cas, il vient le remplacer, sinon il n'est pas affiché. Le test utilisant le stencil buffer effectue une opération binaire suivant des données et des paramètres définis par le programmeur. (nous verrons cela en détail dans l'article consacré au stencil buffer) Enfin, le test de transparence (l'alpha blending) définit en général comment la couleur du nouveau pixel se mélange avec celle de l'ancien. Nous précisons "en général", car ce comportement peut être changé via diverses options pour créer d'autres effets.
Rendu terminé !
L'image finale est maintenant générée, elle est copié dans le frame buffer, puis affichée à l'écran. On peut également, plutôt que d'afficher l'image à l'écran, la stocker dans une texture afin de l'appliquer plus tard à un objet, ce qui se révèle très utile pour le rendu, par exemple, d'un miroir.
Conclusion
Nous savons maintenant quel processus suit DirectX pour générer une image 3D. Cela nous sera très utile pour la compréhension d'autres notions, mais également lorsque nous nous attacherons à optimiser notre code.
