GLSL pour les builders : un labo shader vraiment utilisable

Les shaders GLSL deviennent intuitifs dès que vous pouvez changer un seul nombre et voir le résultat à 60 fps. Ce labo interactif propose des shaders prédéfinis que vous pouvez modifier en temps réel : des ondes sinusoïdales qui modulent des champs de couleur, des fonctions de bruit qui génèrent du terrain et du ray marching qui construit des scènes 3D à partir des seules mathématiques.

J’ai appris les shaders en changeant un nombre à la fois et en regardant ce qui se passait. Lire les mathématiques m’apprenait ce que fait une onde sinusoïdale. Déplacer un curseur me montrait à quoi cela ressemble quand une onde sinusoïdale module un champ de couleur à 60 fps. C’est le second type de compréhension qui reste. Ce labo fait partie de la série Interactive Explorations et du territoire plus large du design engineering.

L’article ci-dessous inclut un labo GLSL en direct avec des shaders prédéfinis que vous pouvez modifier en temps réel. La structure est celle d’un atelier, pas d’un cours magistral : itération rapide, retour visuel et suffisamment d’annotations pour comprendre ce que fait chaque curseur et pourquoi.

TL;DR

Si vous voulez devenir bon en GLSL, arrêtez de lire passivement la théorie des shaders et commencez à manipuler les uniforms sans retenue. Modifiez un seul paramètre à la fois, observez comment les champs d’espace et de temps se déforment, puis formalisez ce que vous avez appris en patterns réutilisables. Le labo interactif ci-dessous vous donne une boucle pratique : choisissez un preset, ajustez Speed, Scale, Detail et Color Shift, et construisez votre intuition grâce à un retour visuel immédiat.1



Pourquoi c’est important pour le travail produit

Les shaders résolvent de vrais problèmes produit. L’article sur la science de la couleur dans les interfaces explique comment fonctionne la perception des couleurs sur le plan théorique ; les shaders sont l’endroit où cette théorie devient un rendu visuel en temps réel. Ils sont utiles pour :

  • des arrière-plans animés d’ambiance qui restent légers
  • des signatures visuelles de marque sans livrer de lourds assets vidéo
  • des blocs de storytelling interactif au sein de contenus éditoriaux
  • des systèmes visuels génératifs paramétrables par campagne

Le labo de cette page est lui-même un exemple en production : un composant WebGL sans dépendance, intégré dans un article de blog rendu côté serveur, sans outils de build, qui respecte chacun des garde-fous décrits plus bas.

Un cas concret : le Sorting Visualizer de ce site utilise un fragment shader plein écran comme arrière-plan d’ambiance derrière l’animation de tri. Le shader affiche un dégradé lent qui réagit à la progression de l’algorithme de tri : la phase de couleur se décale à mesure que les échanges s’accumulent, ce qui crée une « température » visuelle qui monte avec le travail algorithmique. L’implémentation tient en 48 lignes de GLSL (une variante de plasma pilotée par un unique uniform u_progress allant de 0,0 à 1,0). Sur le MacBook Air M1 de l’auteur, le shader ajoute 0,3 ms par frame au budget de rendu, un coût négligeable à 60 fps (budget de 16,6 ms). Sur un iPhone 12 Mini (A14, testé via le débogage à distance de Safari), le même shader ajoute 0,8 ms par frame, ce qui reste largement dans le budget. Le shader a remplacé une animation de dégradé CSS qui exigeait 6 Ko de définitions de keyframes, ne pouvait pas réagir à l’état de l’application et provoquait des recalculs de layout à chaque changement de couleur. La version GLSL est plus petite (1,2 Ko), composée sur le GPU (aucun coût de layout) et paramétrée (l’uniform de progression se branche sur n’importe quelle source de données).

La contrainte pratique est toujours la performance. Si le budget de frame s’effondre sur mobile, l’idée visuelle est morte, aussi élégantes que soient les mathématiques.

Le modèle mental qui tient vraiment

Considérez chaque fragment shader comme trois problèmes résolus l’un après l’autre :2

  1. un problème de transformation de coordonnées
  2. un problème de signal périodique
  3. un problème de mapping des couleurs

En GLSL, chaque étape tient en quelques lignes. Les types vec2, vec3 et vec4 sont les types vectoriels intégrés de GLSL pour des floats à 2, 3 et 4 composantes, utilisés respectivement pour les coordonnées, les couleurs et les pixels de sortie :

// Step 1: Coordinates, where am I in normalized space?
vec2 uv = gl_FragCoord.xy / u_resolution;  // 0.0 to 1.0
vec2 p = uv * u_scale;                     // scale the coordinate space

// Step 2: Signal, what scalar field exists at this point and time?
float signal = sin(p.x * 6.28 + u_time);   // periodic wave across x-axis

// Step 3: Color, how do I map that scalar to visible output?
vec3 color = vec3(signal * 0.5 + 0.5);      // remap -1..1 to 0..1
gl_FragColor = vec4(color, 1.0);             // WebGL 1.0 (GLSL ES 1.00) output

Les valeurs u_resolution, u_scale et u_time sont des uniforms : des valeurs que le CPU envoie au GPU à chaque frame. Les uniforms forment la surface de contrôle. Modifier u_scale zoome dans l’espace de coordonnées. Modifier u_time anime le signal. Le code du shader reste identique ; le comportement change parce que les entrées changent. Le labo ci-dessous expose quatre uniforms (Speed, Scale, Detail, Color Shift) pour que vous le ressentiez directement.

Presque tout peut se construire à partir de cette boucle en trois étapes.

Trois presets, trois comportements

Le labo propose trois comportements de shader pour que vous puissiez comparer les patterns :

  • Plasma : des ondes sin() superposées créent des motifs d’interférence. Trois ondes sinusoïdales de fréquences et de phases différentes se superposent et produisent une interférence constructive (des bandes claires là où les ondes s’alignent) et une interférence destructive (des bandes sombres là où elles s’annulent). L’uniform Scale contrôle combien de cycles d’onde tiennent dans le viewport. Poussez-le vers le haut et le motif d’interférence se resserre en un grain fin. Baissez-le et de larges dégradés organiques apparaissent.3

    glsl float a = sin(p.x + t * 1.1) ; float b = sin((p.y + t * 0.9) * 1.3) ; float c = sin((p.x + p.y + t * 0.7) * 0.8) ; float signal = (a + b + c) / 3.0 ;

  • Contour Rings : length() calcule la distance radiale depuis le centre, ce qui crée un dégradé doux qui croît vers l’extérieur, de 0,0 au centre jusqu’à des valeurs plus grandes sur les bords. sin() fait ensuite osciller cette distance en croissance continue pour en tirer des ondes répétées, pour la même raison que les rides d’un étang forment des anneaux concentriques. abs() + smoothstep() affûtent ces ondes douces en bandes distinctes, avec le même effet visuel que les courbes de niveau d’une carte topographique. L’uniform Detail contrôle la densité des bandes en multipliant la distance avant que sin() ne la replie : plus de détail signifie des anneaux plus serrés. Le résultat visuel évoque un balayage radar ou un relevé topographique.

    glsl float d = length(p) ; float wave = sin((d * 18.0 * u_detail) - t * 2.0) ; float bands = smoothstep(0.1, 0.85, abs(wave)) ;

  • Flow Warp : le shader convertit les coordonnées cartésiennes en forme polaire (atan pour l’angle, length pour le rayon). Les coordonnées polaires sont la clé : l’angle augmente linéairement quand on tourne autour du centre, donc sin(8.0 * angle) crée huit rayons (huit cycles sinusoïdaux complets sur 360 degrés). Le rayon augmente depuis le centre vers l’extérieur, donc cos(12.0 * radius) crée douze ondulations concentriques. Leur somme produit le motif d’interférence : des rayons qui croisent des anneaux. Un terme de lueur exponentielle (exp(-3.0 * radius)) ajoute une décroissance de luminosité depuis le centre, parce que exp(-x) décroît rapidement quand x grandit. L’uniform Color Shift fait tourner le mapping des teintes et révèle comment le même champ de distorsion produit des palettes de couleurs différentes.

    glsl float angle = atan(p.y, p.x) ; float radius = length(p) ; float field = sin(8.0 * angle + t * 2.2) + cos(12.0 * radius - t * 1.7) ; float glow = exp(-3.0 * radius) * (0.6 + 0.4 * sin(t + radius * 8.0)) ;

Ils partagent la même interface d’uniforms (Speed, Scale, Detail, Color Shift), pour que vous sentiez comment des contrôles identiques produisent des résultats différents selon la conception du signal.

Stratégie gagnante pour apprendre vite

Suivez cette séquence dans le labo :

  1. Commencez par Plasma, réglez Scale bas, puis augmentez Speed.
  2. Passez à Contour Rings, augmentez Detail et réduisez Speed.
  3. Passez à Flow Warp, puis faites glisser Color Shift pour voir le mapping de phase.
  4. Mettez l’animation en pause et comparez des images fixes d’un preset à l’autre.
  5. Revenez à votre preset préféré et réglez-le vers un objectif de style bien délimité (calme, agressif, technique, cinématographique).

Cette boucle impose des choix de goût explicites plutôt que des réglages au hasard. Le même type d’exploration esthétique structurée s’applique à la tension entre beauté et brutalisme dans le design, où la contrainte révèle le caractère.

Exercice : après l’étape 5, notez trois mots qui décrivent le visuel que vous avez créé. Poussez ensuite un curseur jusqu’à l’extrême opposé et notez trois nouveaux mots. Comparez les deux descriptions. L’écart entre elles est votre surface de goût : l’éventail des résultats visuels que vous savez nommer et atteindre intentionnellement. Recommencez avec d’autres presets pour élargir cette surface.

Erreurs fréquentes quand on débute en GLSL

Trois erreurs apparaissent dans presque tous les premiers shaders :

Oublier de normaliser les coordonnées. gl_FragCoord renvoie des coordonnées en pixels (de 0 à 1920 sur un écran 1080p). Sans division par u_resolution, chaque sin() et cos() travaille sur des valeurs énormes et produit du bruit visuel au lieu de motifs doux. La correction est toujours la première ligne : vec2 uv = gl_FragCoord.xy / u_resolution;

Traiter la plage de couleurs comme allant de -1 à 1. sin() renvoie des valeurs de -1,0 à 1,0, mais les canaux de couleur attendent des valeurs de 0,0 à 1,0. Les valeurs de couleur négatives sont ramenées au noir et produisent des bandes dures au lieu de dégradés doux. La formule de remappage signal * 0.5 + 0.5 convertit la plage -1..1 en 0..1. Tous les shaders du labo ci-dessus utilisent ce pattern.

Animer sans u_time. Un shader qui n’utilise que des coordonnées spatiales produit une image statique. L’animation exige un uniform de temps que le CPU incrémente à chaque frame et envoie au GPU. Le shader lui-même ne suit jamais le temps : il reçoit l’instant courant sous forme d’uniform et calcule la frame comme si ce moment était le seul. Chaque frame est une fonction pure de ses entrées.


Déboguer les erreurs de shader

Les erreurs de shader WebGL apparaissent dans la console du navigateur. Elles paraissent cryptiques au début, mais suivent des schémas prévisibles. Voici les trois erreurs que vous rencontrerez le plus souvent et ce qu’elles signifient :

ERROR: 0:12: 'u_resolution' : undeclared identifier : le shader fait référence à un uniform qui n’a jamais été déclaré. Soit la déclaration uniform manque dans le source du shader, soit elle est mal orthographiée. Correction : ajoutez uniform vec2 u_resolution; en haut du fragment shader, avant void main().

ERROR: 0:8: '' : compilation terminated : le shader contient une erreur de syntaxe avant la ligne 8. GLSL exige une syntaxe de type C : un point-virgule à la fin de chaque instruction, des accolades appariées et aucune virgule finale. La cause la plus fréquente est un point-virgule manquant sur la ligne précédente. Correction : vérifiez les lignes 1-7 à la recherche de points-virgules manquants, de parenthèses non fermées ou de noms de types incorrects.

Un canvas noir ou blanc sans erreur dans la console : le shader a été compilé et lié avec succès, mais les valeurs de sortie sont hors de la plage 0,0-1,0. gl_FragColor attend chaque canal (R, G, B, A) entre 0,0 et 1,0. Les valeurs supérieures à 1,0 sont ramenées au blanc. Les valeurs inférieures à 0,0 sont ramenées au noir. Correction : ajoutez la formule de remappage (signal * 0.5 + 0.5) pour déplacer votre signal de la plage -1..1 vers la plage 0..1. Si le canvas est entièrement blanc, toutes vos valeurs sont au-dessus de 1,0. S’il est entièrement noir, elles sont toutes en dessous de 0,0.

Une technique de débogage valable pour tout shader : placez gl_FragColor = vec4(uv, 0.0, 1.0); en dernière ligne. Cette ligne peint un dégradé du noir (en bas à gauche, où uv = (0, 0)) au jaune (en haut à droite, où uv = (1, 1)), avec du rouge le long de l’axe x et du vert le long de l’axe y. Si le dégradé paraît correct, votre espace de coordonnées fonctionne et le problème se situe dans le signal ou dans le mapping des couleurs. Si le dégradé est faux (par exemple d’une seule couleur, ou inversé), la transformation de coordonnées contient un bug. La technique isole lequel des trois problèmes (coordonnées, signal, couleur) contient l’erreur.


Garde-fous de production

Si vous déployez des shaders sur des pages de contenu, respectez ces contraintes :

  • plafonnez la résolution du canvas selon le device pixel ratio pour éviter les pics d’overdraw
  • n’exposez qu’une petite surface de contrôle pertinente
  • prévoyez un fallback statique quand WebGL n’est pas disponible
  • mettez le rendu en pause quand l’onglet est masqué
  • évitez les branches coûteuses et les boucles imbriquées dans le code de fragment

Le labo suit ces règles pour que vous puissiez l’utiliser comme modèle. Sur le matériel de test de l’auteur (MacBook Air M1, GPU intégré), ces shaders tiennent 60 fps avec un device pixel ratio de 1x ; les résultats varient selon le GPU, mais la complexité des shaders est volontairement assez faible pour la plupart des machines. À 2x de DPR sur un écran Retina, le nombre de pixels est multiplié par quatre ; plafonner à Math.min(dpr, 2) évite au GPU de fournir quatre fois plus de travail pour une différence visuelle que la plupart des utilisateurs ne peuvent pas percevoir.8

Voici le pattern de pause en cas d’onglet masqué, en JavaScript : deux lignes qui empêchent le shader de brûler des cycles GPU dans un onglet invisible.

document.addEventListener('visibilitychange', () => {
  if (document.hidden) cancelAnimationFrame(frameId);
  else frameId = requestAnimationFrame(render);
});

Et le plafond de DPR :

const dpr = Math.min(window.devicePixelRatio || 1, 2);
canvas.width = canvas.clientWidth * dpr;
canvas.height = canvas.clientHeight * dpr;

Ces deux patterns sont déjà implémentés dans le labo ci-dessus. Copiez-les directement dans vos propres projets WebGL.

Que construire ensuite

De bonnes pistes pour la suite :

  • Copier les uniforms dans le presse-papiers. Exposez l’état courant { speed, scale, detail, colorShift } sous forme d’objet JSON. Un bouton « Copy Preset » l’écrit dans le presse-papiers. Restaurer un preset revient à Object.assign(state, JSON.parse(clipboard)). La sérialisation des presets compte parce que l’exploration esthétique est éphémère par défaut : dès que vous déplacez un curseur, l’état précédent disparaît. Un preset sérialisable transforme un visuel passager en un artefact que l’on peut enregistrer et partager.

  • Exporter des instantanés de dégradés. Appelez canvas.toDataURL('image/png') pour capturer la frame courante en image statique. Dimensionnez le canvas d’export aux formats des cartes sociales (1200x630 pour Open Graph, 1080x1080 pour Instagram). Le shader produit des dégradés uniques et sûrs pour la marque, sans photos de banque d’images.

  • Associer la position de défilement à un uniform. Utilisez IntersectionObserver ou un écouteur de défilement pour calculer une valeur de progression entre 0,0 et 1,0 et transmettez-la comme uniform. Le shader réagit à la position du lecteur dans la page parce que le GPU reçoit une valeur en changement continu qui pilote l’état visuel : le même mécanisme que le curseur Speed, mais commandé par le défilement plutôt que par un contrôle d’interface. Le résultat : des transitions narratives où le visuel évolue au fil du contenu.4

  • Lier la phase de couleur à un état externe. Transmettez l’heure de la journée, des paramètres de campagne ou des préférences utilisateur comme uniforms. Un shader qui décale la teinte selon l’heure locale crée une personnalisation d’ambiance sans servir d’assets différents.

L’essentiel est de passer du « shader comme jouet » au « shader comme primitive produit réutilisable ». L’interactif sur la correction d’erreurs de Hamming et le visualiseur de tokenisation suivent la même philosophie : rendre tangibles des concepts abstraits par la manipulation directe. Et le raisonnement spatial qui rend les shaders intuitifs rejoint la même pensée spatiale que dans la topologie de la connaissance par les embeddings, où des espaces vectoriels de grande dimension encodent le sens sémantique.

Points clés

Pour les ingénieurs qui apprennent GLSL :

  • Manipulez les uniforms sans retenue, lisez la théorie passivement. Modifier un paramètre à la fois et observer le résultat visuel construit l’intuition plus vite qu’étudier les mathématiques isolément. Le labo ci-dessus existe pour rendre cette boucle rapide.

  • Chaque fragment shader résout trois problèmes l’un après l’autre. Transformation de coordonnées, signal périodique, mapping des couleurs. Une fois ce modèle mental acquis, vous pouvez décomposer n’importe quel shader rencontré en ses trois couches et comprendre chacune indépendamment.

Pour les équipes qui livrent des shaders en production :

  • La conception des contraintes compte plus que la complexité du shader. Plafonner le DPR, mettre en pause quand l’onglet est masqué, prévoir des fallbacks et exposer une petite surface de contrôle : ce sont ces décisions de production qui déterminent si un shader survit au contact de vrais utilisateurs sur du vrai matériel.

  • Les shaders sont des primitives produit réutilisables, pas des jouets. Arrière-plans de marque, visuels propres à une campagne, transitions pilotées par le défilement et personnalisation d’ambiance sont des cas d’usage en production que les shaders couvrent sans assets vidéo, sans bande passante CDN et sans dépendance à un framework.


Questions fréquentes

Qu’est-ce que GLSL et comment fonctionnent les fragment shaders dans WebGL ?

GLSL (OpenGL Shading Language) est le langage proche du C utilisé pour écrire les programmes de shaders qui s’exécutent sur le GPU. WebGL est l’API du navigateur qui donne accès à OpenGL ES, lequel exécute ces shaders. Un fragment shader écrit en GLSL s’exécute une fois par fragment à chaque frame ; dans un simple quad plein écran comme celui du labo ci-dessus, chaque fragment correspond à un pixel, si bien que le shader calcule en pratique une couleur pour chaque pixel à partir de ses coordonnées, du temps courant et des valeurs d’uniforms fournies par le CPU. Le labo ci-dessus utilise WebGL pour compiler et exécuter des fragment shaders GLSL directement dans le navigateur, sans plugin ni extension.5

Que sont les uniforms en programmation de shaders ?

Les uniforms sont des valeurs en lecture seule envoyées du CPU (JavaScript) au GPU (shader GLSL) à chaque frame. Contrairement aux attributs de sommet (qui varient d’un sommet à l’autre) ou aux varyings (qui sont interpolés sur un triangle), les uniforms restent constants pour chaque pixel au sein d’un même draw call. Les uniforms courants incluent le temps, la résolution, la position de la souris et des valeurs de contrôle personnalisées. Le labo expose quatre uniforms (Speed, Scale, Detail, Color Shift) que vous pouvez manipuler avec des curseurs pour voir comment la modification des valeurs côté CPU change en temps réel le rendu visuel côté GPU.

Comment les shaders atteignent-ils des performances temps réel ?

Les fragment shaders s’exécutent en parallèle sur des milliers de cœurs GPU. Le calcul de chaque pixel est indépendant de celui de tous les autres, ce qui permet au GPU de les traiter simultanément plutôt que séquentiellement. Un canvas de 1920x1080 compte environ 2 millions de fragments. Un CPU les traite de façon largement séquentielle (le SIMD aide, mais le débit reste inférieur de plusieurs ordres de grandeur). Un GPU les répartit sur des milliers de cœurs et termine en quelques millisecondes. La contrainte : aucun pixel ne peut lire le résultat du calcul d’un autre pixel dans la même passe, et c’est pourquoi la programmation de shaders exige un modèle mental différent de celui du code CPU séquentiel.6

Puis-je utiliser des shaders WebGL en toute sécurité sur des projets web en production ?

C’est possible, avec des contraintes. Plafonnez la résolution du canvas par rapport au device pixel ratio pour éviter l’overdraw sur les écrans haute densité. Mettez la boucle d’animation en pause quand l’onglet n’est pas visible (écoutez l’événement visibilitychange sur document). Prévoyez une image statique ou un dégradé CSS de repli quand WebGL n’est pas disponible. Évitez les opérations coûteuses comme les boucles imbriquées, les lectures de textures dans des branches conditionnelles ou, plus généralement, l’excès de branchements. Le labo respecte tous ces garde-fous de production.

Que faut-il apprendre après ce labo ?

Passez à The Book of Shaders de Patricio Gonzalez Vivo et Jen Lowe, un cursus structuré qui couvre les fonctions de bruit, les champs de distance et des techniques GLSL plus avancées.1 Pour les techniques de champs de distance en particulier, les articles d’Inigo Quilez sur les fonctions de distance signée sont la référence canonique.7 Une fois à l’aise avec les fragment shaders, explorez les vertex shaders (manipulation de la géométrie) et les compute shaders (calcul généraliste sur GPU).



  1. Patricio Gonzalez Vivo et Jen Lowe, The Book of Shaders, thebookofshaders.com. La ressource interactive de référence pour apprendre GLSL. Elle couvre les fragment shaders, de la sortie de couleur de base jusqu’au bruit, aux fractales et au traitement d’image, avec des exemples modifiables en direct. ↩↩

  2. Cette décomposition en trois étapes (coordonnées, signal, couleur) simplifie le modèle présenté dans The Book of Shaders, chapitres 5-7, qui traitent les fonctions de mise en forme, les couleurs et les formes comme des couches successives de la construction d’un fragment shader. ↩

  3. Le preset Plasma illustre la synthèse de Fourier : construire un motif complexe en additionnant des ondes sinusoïdales de fréquences différentes. Le théorème de Fourier énonce que tout signal périodique complexe peut être construit à partir d’ondes sinusoïdales (ou décomposé en ondes sinusoïdales) de fréquences et de phases différentes. Ajouter des termes sinusoïdaux produit des motifs d’interférence plus complexes. Voir aussi : Gonzalez Vivo, « Shaping Functions », thebookofshaders.com/05/. ↩

  4. Les animations de shader pilotées par le défilement reposent sur le même principe que scroll-timeline en CSS, mais avec des visuels arbitraires calculés par le GPU. L’uniform reçoit une position de défilement normalisée (0,0 en haut, 1,0 en bas) et le shader interpole entre des états visuels. MDN documente l’API d’événement de défilement sous-jacente : developer.mozilla.org/en-US/docs/Web/API/Document/scroll_event. ↩

  5. WebGL 1.0 (basé sur OpenGL ES 2.0) est pris en charge par plus de 98 % des navigateurs dans le monde. Voir caniuse.com/webgl. WebGL 2.0 (basé sur OpenGL ES 3.0) ajoute le transform feedback, les render targets multiples et d’autres fonctionnalités, mais n’est pas nécessaire pour un travail sur les fragment shaders comme dans le labo ci-dessus. Les compute shaders sont disponibles via WebGPU, pas via WebGL. ↩

  6. Le modèle d’exécution parallèle des GPU explique pourquoi la programmation de shaders interdit toute communication entre pixels au sein d’un même draw call. John Owens et al., « A Survey of General-Purpose Computation on Graphics Hardware », Computer Graphics Forum, Vol. 26, No. 1, pp. 80-113, 2007. Cette contrainte façonne tout le modèle de programmation de GLSL. ↩

  7. Inigo Quilez, « Distance Functions », iquilezles.org/articles/distfunctions2d/. Le catalogue de Quilez de fonctions de distance signée en 2D et en 3D est la référence standard pour la géométrie procédurale dans les shaders. ↩

  8. Le modèle d’exécution parallèle du GPU qui rend les fragment shaders rapides contraint aussi leur fonctionnement. Akenine-Moller, T., Haines, E. et Hoffman, N., Real-Time Rendering, 4e édition, A K Peters/CRC Press, 2018, chapitre 3 (The Graphics Processing Unit). L’ouvrage offre le traitement le plus complet de l’architecture GPU pour les programmeurs graphiques, y compris la relation entre le débit de fragments, le fill rate et le DPR. Le Khronos Group maintient la spécification GLSL ES qui définit le langage utilisé dans ce labo : registry.khronos.org/OpenGL/specs/es/2.0/GLSL_ES_Specification_1.00.pdf. ↩

Articles connexes

Codes de Hamming : comment les ordinateurs corrigent leurs propres erreurs

De la RAM aux QR codes : une exploration interactive de la détection et correction d’erreurs par les codes de Hamming.

9 min de lecture

Des boids aux agents : les règles du vol groupé appliquées aux systèmes d'IA

Les boids de Craig Reynolds (1986) : trois règles locales font émerger le vol groupé, comme dans l'IA multi-agents.

19 min de lecture

The Shader Gallery That Lied: Debugging 216 WebGL Presets

A user said the shader playground looked broken. Pixel-readback testing found 30 dead presets, 11 that never compiled, a…

14 min de lecture