Shader

Un shader, ou nuanceur (le mot est issu du verbe anglais to shade pris dans le sens de « nuancer »), est un programme informatique, utilisé en image de synthèse, pour paramétrer une partie du processus de rendu réalisé par une carte graphique ou un moteur de rendu logiciel. Il sert à décrire l'absorption et la diffusion de la lumière, la texture à utiliser, les réflexions et réfractions, l'ombrage, le déplacement de primitives et des effets post-traitement. Par la conception même du processus de rendu, les shaders sont également les candidats idéaux pour une exécution parallèle par le processeur graphique d'une carte graphique.

Deux versions du shading : ombrage par facettes (à gauche) et Ombrage de Phong (à droite). Amélioration de l’ombrage de Gouraud par un meilleur contraste des surfaces éclairées, l'algorithme de Phong a constitué l'un des premiers apports de l'infographie naissante.

Les shaders sont polyvalents et efficaces : des surfaces apparemment compliquées peuvent être rendues à partir de géométrie simple. Par exemple, un shader peut être utilisé pour générer un carrelage en céramique à partir de la simple description d'un plan.

L'avantage principal d'employer des shaders vient de leur flexibilité, qui permet un temps d'élaboration plus rapide ainsi que meilleur marché, mais permet également de rendre les travaux plus riches.

Historique

Introduits en mai 1988 par Pixar dans la version 3.0 de sa spécification RIS (RenderMan Interface Specification), les shaders ont suscité un intérêt croissant auprès du public avec la fréquence accrue d’œuvres visuelles ou cinématographiques réalisées en image de synthèse, et l’évolution de l’offre matérielle informatique accompagnant ce mouvement.

Division du travail entre CPU et GPU.

Comme les processeurs graphiques (GPU) évoluaient, les grandes bibliothèques logicielles graphiques telles qu'OpenGL et Direct3D commencèrent à supporter les shaders. À partir de 2001, ils ont été introduits dans les interfaces de programmation 3D temps réel telles que DirectX 8.0 et OpenGL 1.4, puis ont été supportés par les grands constructeurs de cartes graphiques comme nVidia ou ATI. Les premiers GPU utilisant les shaders supportaient uniquement le pixel shading, mais les vertex shaders furent rapidement introduits dès que les développeurs réalisèrent la puissance des shaders.

La première carte graphique équipée d'un pixel shader programmable fut la Nvidia GeForce 3 (processeur NV20), sortie en 2001. Les Geometry shaders furent introduits avec Direct3D 10 et OpenGL 3.2. Ultérieurement, les cartes graphiques ont évolué vers un modèle de shader unifié.

Différents langages

Un langage de shader a habituellement des types de données propres comme les couleurs et les vecteurs, mais en raison des divers intervenants industriels, du type d'utilisation et de la forte évolution du secteur, différents langages de shader ont été développés.

Pour le calcul réaliste

Ce genre de langage de shader est conçu pour une qualité maximum d'image. Les propriétés matérielles sont totalement ignorées, peu de compétences de programmation et aucune connaissance du matériel n'est exigée pour leur utilisation basique. Elle peut cependant être nécessaire pour leur optimisation. De tels shaders sont souvent créés par des artistes pour obtenir le bon rendu.

La réalisation de ce genre de shader est habituellement un processus long. La puissance informatique exigée pour obtenir ce genre d'ombrage peut être élevée mais il permet d'obtenir des résultats complexes, photoréalistes ou fantaisistes, selon les besoins. La majeure partie du temps, le rendu est produit par une grille de calcul. Des unités de calcul dédiés, en nombre plus ou moins importants, sont présents dans tous les processeurs géométriques 3D modernes.

RenderMan Shader Language

Le RenderMan Shading Language (RSL) est l'un des composants de la spécification d'interface RenderMan (RenderMan Interface Specification). Sa syntaxe est proche du C. Un shader écrit en RSL peut donc être utilisé par n'importe quel moteur de rendu compatible comme PhotoRealistic RenderMan de Pixar, 3Delight (en) de DNA Research, Air de Sitexgraphics ou des solutions open source comme Pixie ou Aqsis (en).

Meta SL

Meta SL est un méta langage créé par la société Mental Images (en) (éditrice de Mental Ray et de Iray qui a maintenant intégré Nvidia), qui permet d'utiliser un code unique pour générer des shaders dédiés à de multiples utilisations que ce soit en rendu réaliste ou en rendu temps réel.

Open Shading Language

Open Shading Language (en) (OSL) est un langage développé par Sony Pictures Imageworks afin d'être utilisé dans le moteur de rendu Arnold. Ce langage est aussi supporté par le moteur Octane de la société OTOY, V-Ray 3, et par Cycles, le moteur de rendu de Blender (à partir de la version 2.65).

Pour le calcul en temps réel

Schéma d’un pipeline de carte 3D classique représentant la position des unités de traitement des shaders.

Avant l'apparition des shaders, les programmeurs ne pouvaient pas avoir un tel niveau de contrôle sur le traitement réalisé par les cartes graphiques, les shaders sont maintenant largement répandus. Ils fournissent une abstraction sur le matériel et un modèle de programmation plus flexible comparés au paradigme précédent du « tout câblé », suivi de la programmation bas niveau. Ce cumul permet aux programmeurs un plus grand contrôle sur le processus de rendu, et permet de fournir un contenu plus riche à un coût généralement inférieur.

Ces shaders sont exécutés à même le processeur de traitement graphique (GPU) de la carte graphique en se plaçant dans la file de traitement et permettant ainsi des performances optimales. L'architecture des cartes n'a pas eu besoin d'évoluer, étant basée sur un modèle de traitement par flux, le calcul des shaders a trouvé sa place dans la structure globale des cartes.

Ce genre de langage est habituellement dépendant de l'interface de programmation graphique utilisée, bien que quelques applications fournissent également de tels langages intégrant des fonctionnalités limitées.

Historiquement, seulement une poignée de langages ont réussi à s'imposer, et maintenant le marché est fermé, les constructeurs préférant s'aligner sur ceux existants. Une courte description de ces langages est présentée ci-dessous.

OpenGL shading language

Aussi connu sous le nom de GLSL ou glslang, c'est un langage de shader standardisé par l'OpenGL Architecture Review Board.

Le langage fournit des éléments riches et cela depuis le début, unifiant le processus de traitement sur la géométrie (vertex processing) et sur les pixels (fragment processing) avec le même ensemble d'instructions, permettant des boucles d'instructions, et (plus généralement) des branchements conditionnels.

Historiquement, le langage GLSL a succédé à diverses extensions comparables qui se trouvaient dans OpenGL, telles que ARB_vertex_program, ARB_fragment_program et d’autres. Ces extensions utilisent toutefois un langage de bas niveau de type assembleur avec certaines restrictions, et leur utilisation est maintenant déconseillée. Ces deux extensions ont été également précédées par d'autres propositions qui ne sont pas restées dans les dernières spécifications.

DirectX High-Level Shader Language

Probablement le langage le plus populaire, principalement de par le support de Microsoft, combiné avec le fait qu'il soit le premier à proposer un langage de type C — contre un langage de type assembleur — utilisable pour générer des rendus en temps réel. Le high level shader language, couramment appelé HLSL, est une abstraction du langage de shader de type assembleur. Ces langages de bas niveau ont été introduits à partir de DirectX 8.0 en version (appelées « Shader Model ») 1.x, puis en version 2.x et 3.x avec DirectX 9 et ont été supportés rapidement par les constructeurs. Le HLSL a devancé l'apparition de son principal rival, le GLSL, toutefois il a dû ensuite être étendu par deux fois pour bénéficier de fonctionnalités qu'il ne possédait pas.

Cg Shader Language

Ce langage développé par nVidia a été conçu pour faciliter et optimiser la production intégrée. Le langage fournit une interface de programmation indépendante et est livré avec un éventail large d'outils libres favorisant son utilisation en production.

Les premières implémentations de Cg étaient plutôt restrictives. Il permettait à la majorité des matériels de le supporter, mais était tout de même innovant comparées aux méthodes précédentes. Le Cg semble avoir bien survécu à l'introduction des langages shader de nouvelle génération, principalement par son avance prise sur le secteur de la création de contenu numérique, toutefois le langage semble rarement être employé dans les produits finaux. À noter cependant que les jeux vidéo développés sur la console de jeu de Sony, la PlayStation 3, implémentent leurs shaders avec ce langage.

Une fonctionnalité intéressante que Cg propose réside dans l'utilisation de connecteurs, des types de données spéciales pour lier les différentes étapes du processus. Des connecteurs sont utilisés pour définir l'entrée de l'application à l'étape de traitement géométrique (vertex processing) et aux attributs à interpoler dont le résultat est utilisé pour le traitement des pixels (fragment processing).

Structure pour le calcul en temps réel

Plusieurs approches des shader existent en raison des diverses applications technologiques visées. Les langages de shader pour la production de film sont habituellement d'un niveau d’abstraction plus élevé, et évitent d'utiliser du code spécifique pour l'éclairage ou l'ombrage. En revanche, les shader temps réel intègrent le calcul d'ombre et de lumière. Dans ces langages, les lumières sont passées à la fonction de shader en tant que paramètres.

Il existe actuellement deux applications différentes des shaders dans les langages temps réel. Bien que leurs fonctionnalités aient convergé — il est ainsi possible d'écrire un vertex shader en utilisant les mêmes fonctions qu'un fragment shader — les différents rôles imposent des limitations propre à chacun qu’il faut reconnaître.

Vertex shaders

Les vertex shaders calculent la projection des sommets (les vertex) des primitives à partir de l'espace 3D dans l'espace d'écran en 2D, ils s'exécutent une fois pour chaque sommet. Ils prennent en entrée diverses propriétés telles que la position, la couleur ou les coordonnées de textures, ils les manipulent et les transmettent aux étapes suivantes du pipeline graphique. Si cette étape permet un contrôle puissant de la position, du mouvement, de l'éclairage et des couleurs dans la scène, elle ne permet pas de créer des nouveaux sommets (rôle de la tessellation et du geometry shader).

Dans la plupart des vertex shaders, on applique une matrice de projection qui contient en quelque sorte les informations de la caméra (position, rotation, ...), par exemple ce programme en HLSL :

 float4x4 projection;

 float4 VS_Transform(float4 position : POSITION0)
 {
     return mul(projection, position );
 }

Il prend en entrée le vecteur position, le multiplie par la variable uniforme projection et renvoie le résultat. Ceci permet de placer le point d'observation correctement dans la scène.

Geometry shaders

Les geometry shaders permettent de modifier la géométrie de chaque polygone ainsi que de créer de nouveaux polygones. Ils sont exécutés entre le vertex shader et le fragment shader. Ce type de shader est apparu dans les versions 10 de DirectX et 3.2 de OpenGL (ou OpenGL 1.1 en utilisant l'extension EXT_geometry_shader4).

Un geometry shader reçoit en entrée les données d'une primitive géométrique, et en renvoie une ou plusieurs. Un geometry shader sans effet particulier renvoie simplement la primitive reçue en entrée. En voici un exemple en GLSL :

#version 120
#extension GL_EXT_geometry_shader4 : enable
 
void main (void)
{
  for (int i = 0; i < gl_VerticesIn; ++i)
  {
    gl_Position = gl_PositionIn[i];
    EmitVertex ();
  }
  EndPrimitive ();
}

Fragment shaders ou Pixel shaders

Le fragment shader ou pixel shader est un shader dont le but est de calculer la couleur de chaque pixel individuellement. Il prend ainsi en entrée les données de chaque pixel de l'image (position, coordonnées de texture, couleur) et renvoie la couleur de celui-ci.

Voici un exemple de fragment shader en Cg :

float4 main	(float3 color : COLOR0,
		 float3 texCoords : TEXCOORD0,
		 uniform sampler2D texture)
{
	float3 texColor = tex2D(texture, texCoords).rgb;
	return float4(color * texColor, 1);
}

Tessellation shaders

A partir d'OpenGL 4.0 et de Direct3D 11, une nouvelle classe de shader appelée tessellation shader a été introduite. Elle ajoute deux nouveaux étages de shaders au modèle traditionnel : les tessellation control shaders (appelés également Hull shaders) et les tessellation evaluation shaders (appelés également Domain shaders), qui ensemble permettent de subdiviser des mailles grossières en mailles plus fines en temps réel selon une fonction mathématique. La fonction peut dépendre de plusieurs types de variables, et notamment la distance à la caméra pour permettre une mise à l'échelle active du niveau de détail. Cela permet aux objets proches de la caméra d'avoir des détails fins, tandis que d'autres plus éloignés peuvent avoir des maillages plus grossiers, tout en paraissant de qualité comparable. Il peut aussi réduire considérablement la bande passante de maillage requise en permettant aux maillages d'être raffinés une fois à l'intérieur des unités de shader au lieu de télécharger des maillages très complexes depuis la mémoire. Certains algorithmes peuvent suréchantillonner n'importe quel maillage, tandis que d'autres permettent de "piocher" dans les maillages pour retenir les sommets et les arêtes les plus caractéristiques.

Primitive et Mesh shaders

En juillet 2017, la microarchitecture AMD Vega a rajouté le support d'un nouvel étage de shader — les primitive shaders — qui, un peu comme les compute shaders, accèdent aux données nécessaires pour traiter la géométrie. De même, Nvidia a introduit les mesh et task shaders avec sa microarchitecture Turing en 2018 qui fournissent des fonctionnalités similaires et comme les primitive shaders d'AMD, fonctionnent un peu comme les compute shaders.

En 2020, AMD et NVidia ont sorti les microarchitectures RDNA 2 (en) et Ampere qui supportent le mesh shading dans DirectX 12 Ultimate. Ces mesh shaders permettent au GPU de gérer des algorithmes plus complexes, transférant plus de travail du CPU vers le GPU, et dans le cas d'un rendu appelant beaucoup d'algorithmes, accroissant la cadence d'affichage ou le nombre de triangles dans une scène d'un ordre de grandeur. Intel a annoncé que les GPU Intel Arc Alchemist qui sortiront en 2022 supporteront les mesh shaders.

Ray tracing shaders

Les ray tracing shaders sont supportés par Microsoft via DirectX Raytracing (en), par Khronos Group via Vulkan, GLSL et SPIR-V et par Apple via Metal.

Exemples d'utilisation des shaders en temps réel

Ci-dessous quelques exemples de rendus possibles obtenus grâce aux shaders (et non aux outils techniques des shaders).

Per-pixel lighting

En temps réel, l'éclairage est souvent calculé au moment du T&L ou du vertex shader (voir ombrage de Gouraud). Il est néanmoins possible d'obtenir un éclairage beaucoup plus précis grâce au per-pixel lighting.

Sa mise en œuvre se fait en deux étapes : le vertex shader calcule la provenance de la lumière pour chaque vertex et l'indique au pipeline, généralement via l'utilisation ainsi détournée des coordonnées de texture.

Le pixel shader récupère ensuite ces données ainsi que la normale virtuelle du pixel en cours de traitement dans le sampler de la bump map. Il connaît alors la normale et la provenance de la lumière, il peut donc calculer l'éclairage du pixel qu'il lui suffira de multiplier avec la couleur provenant de la texture classique.

Toon shading

Le toon shading (toon, abréviation de cartoon, signifiant dessin animé) ou cel-shading (en référence aux celluloïds utilisé en dessin animé traditionnel), en français ombrage de celluloïd consiste à rendre une image en aplats de couleur (similaire aux bandes dessinées).

Voir aussi

Articles connexes

• Rastérisation
• Synthèse d'image 3D