OpenGL Shading Language

Un article de Wikipédia, l'encyclopédie libre.

OpenGL Shading Language
Date de première version Voir et modifier les données sur Wikidata
Site web www.opengl.orgVoir et modifier les données sur Wikidata

L’OpenGL Shading Language (GLSL) est un langage de programmation de shaders de haut niveau dont la syntaxe est fondée sur le langage C. Ces derniers permettent un contrôle avancé du pipeline de la carte graphique. Le GLSL a été développé par l’OpenGL Architecture Review Board afin de faciliter la programmation de shaders avec l'API OpenGL sans avoir à utiliser le ARB assembly language (en) ou des langages spécifiques à chaque matériel.

Historique[modifier | modifier le code]

Avec l'évolution des cartes graphiques, de nouvelles fonctionnalités ont été ajoutées pour permettre une plus grande flexibilité dans le pipeline de rendu au niveau du traitement des sommets (aussi appelé « vertex ») et des fragments. Ces éléments sont devenus programmables à l'aide de shaders de fragments et de sommets.

À l'origine, cette fonctionnalité s'obteneait en écrivant des shaders en ARB assembly language (en), une tâche complexe et peu intuitive. L'OpenGL Architecture Review Board a créé l'OpenGL Shading Language pour fournir une méthode plus intuitive de programmation des processeurs graphiques tout en conservant les avantages d'un standard libre qui a fait l'histoire d'OpenGL.

Initialement introduit comme une extension d'OpenGL 1.4, GLSL a été officiellement inclus dans le noyau d'OpenGL 2.0 en 2004 par l'OpenGL ARB. Il s'agissait de la première révision majeure d'OpenGL depuis la création d'OpenGL 1.0 en 1992.

Plusieurs des avantages de GLSL :

  • Une compatibilité multiplateforme sur plusieurs systèmes d'exploitation, incluant Linux, macOS et Windows.
  • La possibilité d'écrire des shaders pouvant être utilisés sur la carte graphique de n'importe quel fournisseur de matériel prenant en charge le GLSL.
  • Chaque fournisseur de matériel inclut un compilateur GLSL dans son pilote, permettant ainsi à chaque fournisseur de créer un code optimisé pour l’architecture de sa carte graphique.

Versions[modifier | modifier le code]

Les versions de GLSL ont évolué parallèlement à des versions spécifiques de l'API OpenGL. Ce n'est qu'avec les versions 3.3 et ultérieures d'OpenGL que les numéros de version majeure et mineure de GLSL et d'OpenGL correspondent. Voici les versions de GLSL pour chaque version d'OpenGL :

Version de GLSL Version d'OpenGL Date Code préprocesseur
1.10.59[1] 2.0 30 avril 2004 #version 110
1.20.8[2] 2.1 07 septembre 2006 #version 120
1.30.10[3] 3.0 22 novembre 2009 #version 130
1.40.08[4] 3.1 22 novembre 2009 #version 140
1.50.11[5] 3.2 04 décembre 2009 #version 150
3.30.6[6] 3.3 11 mars 2010 #version 330
4.00.9[7] 4.0 24 juillet 2010 #version 400
4.10.6[8] 4.1 24 juillet 2010 #version 410
4.20.11[9] 4.2 12 décembre 2011 #version 420
4.30.8[10] 4.3 7 février 2013 #version 430
4.40.9[11] 4.4 16 juin 2014 #version 440
4.50.7[12] 4.5 09 mai 2017 #version 450
4.60.5[13] 4.6 14 juin 2018 #version 460

OpenGL ES et WebGL utilisent l'OpenGL ES Shading Language (GLSL ES).

Version de GLSL ES Version d'OpenGL ES Version de WebGL Version de GLSL Date Code préprocesseur
1.00.17[14] 2.0 1.0 1.20 12 mai 2009 #version 100
3.00.6[15] 3.0 2.0 3.30 29 janvier 2016 #version 300 es
3.10.5[16] 3.1 GLSL ES 3.00 29 janvier 2016 #version 310 es
3.20.6[17] 3.2 GLSL ES 3.10 10 juillet 2019 #version 320 es

Les deux langages sont liés mais ne sont pas entièrement compatibles. Ils peuvent être transcompilés l'un en l'autre à l'aide de SPIR-Cross.

Langage[modifier | modifier le code]

Opérateurs[modifier | modifier le code]

Le langage GLSL bénéficie des mêmes opérateurs que le C à l'exception des pointeurs. Les opérateurs bit à bit ont été ajouté dans la version 1.30.

Fonctions et structures de contrôle[modifier | modifier le code]

A l'image du C, le langage GLSL supporte les boucles et les branchements (ex: if-else, for, switch). La récursion est proscrite et son absence est vérifiée durant la compilation.

L'utilisateur peut définir ses propres fonctions mais le langage intègre aussi des fonctions natives. Les fabricants de carte graphique sont susceptible de les optimiser au niveau matériel. Plusieurs de ces fonctions sont semblables à la bibliothèque mathématique du C tandis que d'autres sont spécifiques à la programmation graphique. La plupart des fonctions natives et des opérateurs peuvent opérer sur des scalaires et des vecteurs (jusqu'à 4 éléments) pour une ou plusieurs opérandes. C'est notamemnt le cas pour ces fonctions communément utilisées : mix​, smoothstep​, normalize​, inversesqrt​, clamp​, length​, distance​, dot​, cross​, reflect​, refract​ and vector min​ and max​. Other functions like abs​, sin​, pow​. Le langage GLSL supporte également la surcharge de fonction (pour les opérateur et les fonctions natives mais aussi pour les fonctions définies par l'utilisateur), ce qui veut dire qu'il peut y avoir plusieurs fonctions portant le même nom, ou possédent un nombre ou des types de variables différents. Chacune de ces fonctions peuvent avoir un type de retour différent.

Préprocesseur[modifier | modifier le code]

Le GLSL défini un sous-ensemble du préprocesseur C (CPP) combiné avec ses propres directives spécifiant sa versions et les extensions d'OpenGL supportées. Tout ce qui relate aux noms de fichier comme #include​ and __FILE__​[18] est retiré de CPP.

L'extension GL_ARB_shading_language_include​[19] (implementé notamment dans les pilotes Nvidia[20] sur Windows et Linux, et tous les pilotes Mesa 20.0.0[21] sur Linux, FreeBSD et Android) implémente la possibilité d'utiliser #include​ dans le code source, rendant plus facile le partage de code et de définition entre plusieurs shaders sans manipulation manuelle supplémentaire. Des extensions similaires comme GL_GOOGLE_include_directive​ et GL_GOOGLE_cpp_style_line_directive​ existent en GLSL avec Vulkan et sont supportées par le compilateur de référence SPIR-V (glslang​, de son nom complet "glslangValidator").[22],[23],[24]

Compilation et exécution[modifier | modifier le code]

Les shaders GLSL ne sont pas des programmes autonomes. Il est nécessaire d'avoir un programme qui exploite l'API d'OpenGL pour les exécuter. Cette API est disponible sur différentes plateformes (ex: Linux, macOS, Windows) et dans un nombre très varié de langages comme le C, C++, C#, JavaScript, Delphi, Java.

Les shaders en eux-mêmes ne sont que de simples chaînes de caractères transmises pour compilation par le programme utilisant l'API d'OpenGL au pilote du fabricant matériel. Les shaders peuvent être créé à la volée au sein de l'application, ou lu en tant que fichier texte, mais doivent être envoyées au pilote en tant que chaine de caractères.

L'ensemble des API utilisées pour compiler, lier et transmettre les paramètres aux programmes GLSL sont spécifiés dans trois extensions d'OpenGL et sont devenu une partie intégrante d'OpenGL à partir de la version 2.0. L'API a été étendu aux shaders de géométrie à partir d'OpenGL 3.2, les shaders de tessellation à partir d'OpenGL 4.0 et les shaders de calcul à partir d'OpenGL 4.3. Ces APIs d'OpenGL se trouvent dans ces extensions :

  • ARB vertex shader
  • ARB fragment shader
  • ARB shader objects
  • ARB geometry shader 4
  • ARB tessellation shader
  • ARB compute shader

Le langage GLSL peut aussi être utilisé avec l'API Vulkan. Il constitue un moyen courant d'utiliser les shaders sous cette API. Les shaders GLSL sont précompilés avant utilisation, ou au moment de l'exécution dans un format de bytecode binaire appelé SPIR-V.

Voir aussi[modifier | modifier le code]

Articles connexes[modifier | modifier le code]

Autres langages de shaders[modifier | modifier le code]

  • Cg, un langage de haut niveau pour la programmation de shaders de vertex et de pixel
  • Gallium3D, un projet libre d'accélération 3D et son langage de shaders TGSI
  • AMD, un fabricant de carte graphique et son langage de shaders AMDIL

Références[modifier | modifier le code]

Citations
  1. « GLSL Language Specification, Version 1.10.59 »
  2. « GLSL Language Specification, Version 1.20.8 »
  3. « GLSL Language Specification, Version 1.30.10 »
  4. « GLSL Language Specification, Version 1.40.08 »
  5. « GLSL Language Specification, Version 1.50.11 »
  6. « GLSL Language Specification, Version 3.30.6 »
  7. « GLSL Language Specification, Version 4.00.9 »
  8. « GLSL Language Specification, Version 4.10.6 »
  9. « GLSL Language Specification, Version 4.20.11 »
  10. « GLSL Language Specification, Version 4.30.8 »
  11. « GLSL Language Specification, Version 4.40.9 »
  12. « GLSL Language Specification, Version 4.50.7 »
  13. « GLSL Language Specification, Version 4.60.5 »
  14. « GLSL ES Language Specification, Version 1.00, revision 17 »
  15. « GLSL ES Language Specification, Version 3.00, revision 6 »
  16. « The OpenGL ES® Shading Language, version 3.10, revision 5 »
  17. « The OpenGL ES® Shading Language, Version 3.20.6 »
  18. (en) OpenGL Programming Guide: The Official Guide to Learning OpenGL, Version 4.3, Eighth Edition (lire en ligne), « Shader Preprocessor »
  19. « ARB_shading_language_include », sur Khronos.org (consulté le )
  20. « NVIDIA driver 265.90 WHQL Quadro », sur LaptopVideo2Go Forums
  21. « Mesa 20.0.0 Release Notes / 2020-02-19 », sur www.mesa3d.org (consulté le )
  22. (en) « #include directive support by antiagainst · Pull Request #46 · KhronosGroup/glslang », sur GitHub (consulté le )
  23. (en) « Preprocessing line number handling by antiagainst · Pull Request #38 · KhronosGroup/glslang », sur GitHub
  24. (en) « Extend the syntax of #line and __FILE__ to support filename strings by antiagainst · Pull Request #43 · KhronosGroup/glslang », sur GitHub

Liens externes[modifier | modifier le code]