Shader

vignette|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. Un , ou nuanceur... recommandé par l'OQLF (le mot est issu du verbe anglais 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.

Les sont polyvalents et efficaces : des surfaces apparemment compliquées peuvent être rendues à partir de géométrie simple. Par exemple, un 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 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 par Pixar dans la version 3.0 de sa spécification RIS (RenderMan Interface Specification)., les 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. vignette|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 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 ont été développés.

Pour le calcul réaliste Ce genre de langage de 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 sont souvent créés par des artistes pour obtenir le bon rendu.

La réalisation de ce genre de 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.

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, de DNA Research, Air. de Sitexgraphics ou des solutions open source comme Pixie. ou .

est un méta langage créé par la société (é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 dédiés à de multiples utilisations que ce soit en rendu réaliste ou en rendu temps réel.

(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 thumb|right|upright=2|Schéma d’un de carte 3D classique représentant la position des unités de traitement des . Avant l'apparition des , les programmeurs ne pouvaient pas avoir un tel niveau de contrôle sur le traitement réalisé par les cartes graphiques, les 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 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 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.

Aussi connu sous le nom de GLSL ou glslang, c'est un langage de 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 () et sur les pixels () 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.

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 , couramment appelé HLSL, est une abstraction du langage de 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.

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 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 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 () et aux attributs à interpoler dont le résultat est utilisé pour le traitement des pixels ().

Structure pour le calcul en temps réel Plusieurs approches des existent en raison des diverses applications technologiques visées. Les langages de 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 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 en tant que paramètres.

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

Les 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 et du ).

Dans la plupart des , 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.

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 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 (); }

ou Le ou est un 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 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