Shader

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.

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

Meta SL est un méta langage créé par la société Mental Images (éditrice de Mental Ray et de Iray qui a maintenant intégré Nvidia[1]), 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 (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).

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.

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.

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.

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).

Les vertex shaders calculent la projection des sommets 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 tels que la position, la couleur ou les coordonnées de textures, ils les manipulent et les transmettent aux étapes suivantes du pipeline graphique. 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 du tesselation et 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.

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

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

En temps réel, l'éclairage est souvent calculé au moment du T&L ou du vertex shader (voir ombrage 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.

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).