Worldlex Wiki
Article de reference

Langage d'ombrage OpenGL

Les jeux vidéo externalisent les calculs de rendu au GPU via OpenGL en temps réel. Les shaders sont écrits en OpenGL Shading Language et compilés. Les programmes compilés sont e...

Worldlex WikiFrancaisLecture gratuite
Les jeux vidéo externalisent les calculs de rendu au GPU via OpenGL en temps réel. Les shaders sont écrits en OpenGL Shading Language et compilés. Les programmes compilés sont exécutés sur le GPU.

OpenGL Shading Language ( GLSL ) est un langage de shading de haut niveau dont la syntaxe est basée sur le langage de programmation C. Il a été créé par l' OpenGL ARB (OpenGL Architecture Review Board) pour donner aux développeurs un contrôle plus direct du pipeline graphique sans avoir à utiliser le langage assembleur ARB ou des langages spécifiques au matériel.

Arrière-plan

Avec les progrès des cartes graphiques, de nouvelles fonctionnalités ont été ajoutées pour permettre une plus grande flexibilité dans le pipeline de rendu au niveau des vertex et des fragments . La programmabilité à ce niveau est obtenue grâce à l'utilisation de shaders de fragment et de vertex .

À l'origine, cette fonctionnalité était obtenue en écrivant des shaders en langage assembleur ARB , une tâche complexe et peu intuitive. L' ARB OpenGL a créé le langage OpenGL Shading pour fournir une méthode plus intuitive de programmation de l' unité de traitement graphique tout en conservant l'avantage des normes ouvertes qui ont guidé OpenGL tout au long de son histoire.

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.

Voici quelques avantages de l’utilisation de GLSL :

  • Compatibilité multiplateforme sur plusieurs systèmes d'exploitation, notamment Linux , macOS et Windows .
  • La possibilité d'écrire des shaders qui peuvent être utilisés sur la carte graphique de n'importe quel fournisseur de matériel prenant en charge le langage OpenGL Shading.
  • Chaque fournisseur de matériel inclut le compilateur GLSL dans son pilote, permettant ainsi à chaque fournisseur de créer du code optimisé pour l'architecture de sa carte graphique particulière.

Versions

Les versions GLSL ont évolué parallèlement aux versions spécifiques de l'API OpenGL. Ce n'est qu'avec les versions OpenGL 3.3 et supérieures que les numéros de version majeurs et mineurs de GLSL et d'OpenGL correspondent. Ces versions pour GLSL et OpenGL sont liées dans le tableau suivant :

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

OpenGL ES et WebGL utilisent OpenGL ES Shading Language (abrégé : GLSL ES ou ESSL ).

Version ES de GLSL Version OpenGL ES Version WebGL Basé sur la version GLSL Date Préprocesseur de shader
1.00.17 2.0 1.0 1.20 12 mai 2009 #version 100
3.00.6 3.0 2.0 3.30 29 janvier 2016 #version 300 fr
3.10.5 3.1 GLSL ES 3.00 29 janvier 2016 #version 310 fr
3.20.6 3.2 GLSL ES 3.10 10 juillet 2019 #version 320 fr

Les deux langages sont apparentés mais pas directement compatibles. Ils peuvent être interconvertis grâce à SPIRV-Cross .

Langue

Opérateurs

GLSL contient les mêmes opérateurs que les opérateurs de C et C++ , à l'exception des pointeurs . Les opérateurs au niveau du bit ont été ajoutés dans la version 1.30.

Fonctions et structures de contrôle

Similaire au langage de programmation C , GLSL prend en charge les boucles et les ramifications, par exemple : if-else, for, switch, etc. La récursivité est interdite et vérifiée lors de la compilation.

Les fonctions définies par l'utilisateur sont prises en charge et des fonctions intégrées sont fournies. Le fabricant de la carte graphique peut optimiser les fonctions intégrées au niveau matériel. Beaucoup de ces fonctions sont similaires à celles de la bibliothèque mathématique du langage de programmation C tandis que d'autres sont spécifiques à la programmation graphique. La plupart des fonctions et opérateurs intégrés peuvent fonctionner à la fois sur des scalaires et des vecteurs (jusqu'à 4 éléments), pour un ou les deux opérandes. Les fonctions intégrées courantes fournies et couramment utilisées à des fins graphiques sont : mix, smoothstep, normalize, inversesqrt, clamp, length, distance, dot, cross, reflect, refractet vector minet max. D'autres fonctions comme abs, sin, pow, etc. sont fournies mais elles peuvent également toutes fonctionner sur des quantités vectorielles, c'est-à-dire pow(vec3(1.5, 2.0, 2.5), abs(vec3(0.1, -0.2, 0.3))). GLSL prend en charge la surcharge de fonctions (pour les fonctions et opérateurs intégrés et les fonctions définies par l'utilisateur), il peut donc y avoir plusieurs définitions de fonctions portant le même nom, ayant un nombre différent de paramètres ou de types de paramètres. Chacune d'entre elles peut avoir son propre type de retour indépendant.

Préprocesseur

GLSL définit un sous-ensemble du préprocesseur C (CPP), associé à ses propres directives spéciales pour spécifier les versions et les extensions OpenGL. Les parties supprimées du CPP sont celles relatives aux noms de fichiers tels que #includeet __FILE__.

L' GL_ARB_shading_language_includeextension (implémentée par exemple dans les pilotes Nvidia sous Windows et Linux, et dans tous les pilotes Mesa 20.0.0 sous Linux, FreeBSD et Android) implémente la possibilité d'utiliser #includele code source, permettant un partage plus facile du code et des définitions entre plusieurs shaders sans prétraitement manuel supplémentaire. Des extensions similaires existent pour utiliser GLSL avec Vulkan, GL_GOOGLE_include_directiveet GL_GOOGLE_cpp_style_line_directivesont prises en charge dans le compilateur de référence SPIR-V ( glslangalias glslangValidator).

Compilation et exécution

Les shaders GLSL ne sont pas des applications autonomes ; ils nécessitent une application qui utilise l'API OpenGL, qui est disponible sur de nombreuses plates-formes différentes (par exemple, Linux , macOS , Windows ). Il existe des liaisons de langage pour C , C++ , C# , JavaScript , Delphi , Java et bien d'autres.

Les shaders GLSL eux-mêmes sont simplement un ensemble de chaînes qui sont transmises au pilote du fournisseur de matériel pour être compilées à partir d'une application à l'aide des points d'entrée de l'API OpenGL. Les shaders peuvent être créés à la volée à partir d'une application ou lus sous forme de fichiers texte, mais doivent être envoyés au pilote sous la forme d'une chaîne.

L'ensemble des API utilisées pour compiler, lier et transmettre des paramètres aux programmes GLSL est spécifié dans trois extensions OpenGL et fait partie du noyau OpenGL à partir de la version 2.0 d'OpenGL. L'API a été étendue avec des shaders de géométrie dans OpenGL 3.2, des shaders de tessellation dans OpenGL 4.0 et des shaders de calcul dans OpenGL 4.3. Ces API OpenGL se trouvent dans les extensions :

  • Shader de vertex ARB
  • Shader de fragments ARB
  • Objets shader ARB
  • Shader géométrique ARB 4
  • Shader de tessellation ARB
  • Shader de calcul ARB

Les shaders GLSL peuvent également être utilisés avec Vulkan et constituent un moyen courant d'utiliser les shaders dans Vulkan. 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 , généralement à l'aide d'un compilateur hors ligne.

Plus d articles de Worldlex Wiki

Revenez a l index pour explorer davantage de pages sur l histoire, la science, la culture, la geographie et la societe en francais.

Explorer l index