recursal/MDN huggingface dataset:
Exemple basique
===============

1. Introduction
2. Exemple basique
3. Génération de HTML
4. Différences entre les navigateurs
5. Ressources
Exemple basique
---------------

Ce premier exemple présente les bases de l'utilisation d'une transformation XSLT dans un navigateur. L'exemple utilise un document XML qui contient des informations (titre, liste d'auteurs et corps de texte) à propos d'un article pour en tirer une version lisible par un humain.

La figure 1 montre le code source de l'exemple XSLT. Le document XML (exemple.xml) contient les informations à propos de l'article. En utilisant l'instruction de traitement `?xml-stylesheet?`, il est lié à la feuille de style XSLT (exemple.xsl) via son attribut `href`.

Une feuille de style XSLT débute par l'élément `xsl:stylesheet`, qui contient tous les modèles utilisés pour créer le résultat final. L'exemple de la figure 1 possède deux modèles - un qui s'applique au nœud racine et un aux nœuds `Author`. Le modèle correspondant au nœud racine produit en sortie le titre de l'article puis déclenche le traitement de tous les autres modèles (via `apply-templates`) correspondant aux nœuds `Author` qui sont les descendants du nœud `Authors`.

Figure 1 : exemple XSLT simple

Document XML (exemple.xml) :


```xml
<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="exemple.xsl"?>
<Article>
  <Title>Mon article</Title>
  <Authors>
    <Author>M. Foo</Author>
    <Author>M. Bar</Author>
  </Authors>
  <Body>Ceci est le texte de mon article.</Body>
</Article>
```


Feuille de style XSL (exemple.xsl) :


```xml
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

  <xsl:output method="text"/>

  <xsl:template match="/">
    Article - <xsl:value-of select="/Article/Title"/>
    Auteurs&nbsp;: <xsl:apply-templates select="/Article/Authors/Author"/>
  </xsl:template>

  <xsl:template match="Author">
    - <xsl:value-of select="." />
  </xsl:template>

</xsl:stylesheet>
```


Sortie dans le navigateur :
```

Article - Mon article
Auteurs&nbsp;:
- M. Foo
- M. Bar
```

* « Précédent
* Suivant »
WorkerGlobalScope.dump()
========================

**Attention :** Cette fonctionnalité n'est ni standard, ni en voie de standardisation. Ne l'utilisez pas pour des sites accessibles sur le Web : elle ne fonctionnera pas pour tout utilisateur. Il peut également y avoir d'importantes incompatibilités entre les implémentations et son comportement peut être modifié dans le futur.

La méthode **`dump()`** de l'interface `WorkerGlobalScope` permet d'écrire des messages vers `stdout` — i.e. dans le terminal, seulement sur Firefox. C'est la même chose que `window.dump` dans Firefox, mais pour les *worker*s.

Syntaxe
-------


```js
dump("Mon message\n");
```

### Paramètre

Une `DOMString` contenant le message que vous voulez envoyer.

### Retour

Rien.

Exemple
-------

Pour écrire quelque chose depuis votre *worker* vers votre terminal, vous devez d'abord ouvrir une instance de Firefox depuis votre invité de commande ou terminal. Par exemple, sous Mac OS X vous le lancer en utilisant quelque chose comme (en supposant que vous êtes dans le répertoire de l'application):


```bash
./Firefox.app/Contents/MacOS/firefox-bin -profile /tmp -no-remote
```


Maintenant allez dans `about:config` et activez la préférence `browser.dom.window.dump.enabled`.

Après, lancez un worker contenant la ligne suivante:


```js
dump("test\n");
```


Vous devriez observer le message «test» apparaître dans le terminal.

Spécifications
--------------

Cette méthode n'apparaît dans aucune spécification.

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

`WorkerGlobalScope`
WorkerGlobalScope.onlanguagechange
==================================

La propriété **`onlanguagechange`** de l'interface `WorkerGlobalScope` représente un gestionnaire d'évènement à appeler lorsque l'événement `languagechange` survient et se propage à travers le `Worker`.

Syntaxe
-------


```js
self.onlanguagechange = function() { ... };
```

Exemple
-------

L'extrait de code suivant montre un gestionnaire `onlanguagechange` placé au sein d'un worker :


```js
self.onlanguagechange = function () {
  console.log("Your preferred language settings have been changed");
};
```

Spécifications
--------------

| Specification |
| --- |
| HTML Standard # event-languagechange |
| HTML Standard # handler-workerglobalscope-onlanguagechange |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

L'interface `WorkerGlobalScope` à laquelle elle appartient.
WorkerGlobalScope.location
==========================

La propriété en lecture seule **`location`** de l'interface `WorkerGlobalScope` retourne l'objet `WorkerLocation` associé au worker. C'est un objet location spécifique, essentiellement un sous-ensemble de `Location` pour les contextes de navigation, mais adapté aux workers.

Syntaxe
-------


```js
var locationObj = self.location;
```

### Valeur de retour

Un objet `WorkerLocation`.

Exemple
-------

Si vous appelez l'instruction suivante dans un document délivré par `localhost:8000`


```js
console.log(location);
```


à l'intérieur d'un worker (ce qui équivaut à `self.console.log(self.location);`, puisqu'il est appelé dans le contexte du worker qui peut être référencé par `WorkerGlobalScope.self`), la console vous retournera un objet `WorkerLocation` — comme ce qui suit :


```js
WorkerLocation {hash: "", search: "", pathname: "/worker.js", port: "8000", hostname: "localhost"…}
  hash: ""
  host: "localhost:8000"
  hostname: "localhost"
  href: "http://localhost:8000/worker.js"
  origin: "http://localhost:8000"
  pathname: "/worker.js"
  port: "8000"
  protocol: "http:"
  search: ""
  \_\_proto\_\_: WorkerLocation
```


Vous pouvez utiliser l'objet location pour récupérer des informations supplémentaires sur la localisation du document, comme vous pourriez le faire avec un objet `Location` normal.

**Note :** Firefox rencontre un bogue avec l'utilisation de `console.log` à l'intérieur des workers partagés/service (voir bug Firefox 1058644), ce qui peut occasionner d'étranges résultats, mais cela devrait être bientôt corrigé.

Spécifications
--------------

| Specification |
| --- |
| HTML Standard # dom-workerglobalscope-location-dev |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

`WorkerGlobalScope`
WorkerGlobalScope.importScripts()
=================================

La méthode **`importScripts()`** de l'interface synchrome `WorkerGlobalScope` importe un ou plusieurs scripts dans l'environnement du worker.

Syntaxe
-------


```js
self.importScripts('foo.js');
self.importScripts('foo.js', 'bar.js', ...);
```

### Paramètres

Une liste d'objets `DOMString` séparés par des virgules et représentant les scripts à importer.

### Valeur de retour

Rien.

### Exceptions

| Exception | Description |
| --- | --- |
| `NetworkError` | Importer un script qui n'est pas servi avec un type MIME valide. (i.e. `text/javascript`). |

Exemple
-------

Si vous disposez d'un code présent dans un script indépendant appelé `foo.js` que vous souhaitez utiliser à l'intérieur de worker.js, vous pouvez l'importer de la façon suivante:


```js
importScripts("foo.js");
```


`importScripts()` et `self.importScripts()` sont effectivement équivalentes — les deux expressions correspondent à la façon d'appeler `importScripts()` au sein du contexte local du worker.

Spécifications
--------------

| Specification |
| --- |
| HTML Standard # dom-workerglobalscope-importscripts-dev |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

`WorkerGlobalScope`
WorkerGlobalScope.ononline
==========================

La propriété **`ononline`** de l'interface `WorkerGlobalScope` représente un gestionnaire d'évènement à appeler lorsque l'événement `online` survient et se propage à travers le `Worker`.

Syntaxe
-------


```js
self.ononline = function() { ... };
```

Exemple
-------

L'extrait de code suivant montre un gestionnaire `ononline` placé dans un worker :


```js
self.ononline = function () {
  console.log("Your worker is now online");
};
```

Spécifications
--------------

| Specification |
| --- |
| HTML Standard # handler-workerglobalscope-ononline |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

L'interface `WorkerGlobalScope` à laquelle il appartient.
WorkerGlobalScope.onoffline
===========================

La propriété **`onoffline`** de l'interface `WorkerGlobalScope` représente un gestionnaire d'évènement à appeler lorsque l'événement `offline` survient et se propage à travers le `Worker`.

Syntaxe
-------


```js
self.onoffline = function() { ... };
```

Exemple
-------

L'extrait de code suivant montre un gestionnaire `onoffline` placé dans un worker :


```js
self.onoffline = function () {
  console.log("Your worker is now offline");
};
```

Spécifications
--------------

| Specification |
| --- |
| HTML Standard # handler-workerglobalscope-onoffline |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

L'interface `WorkerGlobalScope` à laquelle il appartient.
WorkerGlobalScope.navigator
===========================

La propriété en lecture seule **`navigator`** de l'interface `WorkerGlobalScope` retourne le `WorkerNavigator` (en-US) associé au worker. C'est un objet navigator spécifique, essentiellement un sous-ensemble de `Navigator` pour les contextes de navigation, mais adapté aux workers.

Syntaxe
-------


```js
var navigatorObj = self.navigator;
```

### Valeur de retour

Un objet `WorkerNavigator` (en-US).

Exemple
-------

Si vous appelez


```js
console.log(navigator);
```


à l'intérieur d'un worker (ce qui équivaut à `self.console.log(self.navigator);`, puisqu'il est appelé dans le contexte du worker qui peut être référencé par `WorkerGlobalScope.self`), la console vous retournera un objet `WorkerNavigator` (en-US) — comme ce qui suit :


```js
Object {onLine: true, userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10\_10\_1) Ap…ML, like Gecko) Chrome/40.0.2214.93 Safari/537.36", product: "Gecko", platform: "MacIntel", appVersion: "5.0 (Macintosh; Intel Mac OS X 10\_10\_1) AppleWebKi…ML, like Gecko) Chrome/40.0.2214.93 Safari/537.36"…}
    appCodeName: "Mozilla"
    appName: "Netscape"
    appVersion: "5.0 (Macintosh; Intel Mac OS X 10\_10\_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/40.0.2214.93 Safari/537.36"
    hardwareConcurrency: 4
    onLine: true
    platform: "MacIntel"
    product: "Gecko"
    userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10\_10\_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/40.0.2214.93 Safari/537.36"
    \_\_proto\_\_: Object
```


Vous pouvez utiliser l'objet navigator pour récupérer des informations supplémentaires sur l'environnement d'exécution, comme vous pourriez le faire avec un objet `Navigator` normal.

**Note :** Firefox rencontre un bogue avec l'utilisation de `console.log` à l'intérieur des workers partagés/service (voir bug Firefox 1058644), ce qui peut occasionner d'étranges résultats, mais cela devrait être bientôt corrigé.

Spécifications
--------------

| Specification |
| --- |
| HTML Standard # dom-worker-navigator-dev |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

`WorkerNavigator` (en-US)
WorkerGlobalScope.self
======================

La propriété en lecture seule **`self`** de l'interface `WorkerGlobalScope` retourne une référence au `WorkerGlobalScope` lui-même. La plupart du temps il s'agit d'un contexte spécifique comme `DedicatedWorkerGlobalScope`, `SharedWorkerGlobalScope` (en-US), ou `ServiceWorkerGlobalScope` (en-US).

Syntaxe
-------


```js
var selfRef = self;
```

### Valeur

Un objet global scope (qui diffère selon le type du worker concerné, comme indiqué ci-dessus).

Exemple
-------

Si vous appelez


```js
console.log(self);
```


au sein d'un worker, vous obtiendrez un worker global scope du même type que l'objet worker écrit sur la console — quelque chose comme ce qui suit :


```js
DedicatedWorkerGlobalScope {
undefined: undefined, Infinity: Infinity, Math: MathConstructor, NaN: NaN, Intl: Object…}
    Infinity: Infinity
    Array: function Array() { [native code] }
      arguments: null
      caller: null
      isArray: function isArray() { [native code] }
      length: 1
      name: "Array"
      observe: function observe() { [native code] }
      prototype: Array[0]
      unobserve: function unobserve() { [native code] }
      \_\_proto\_\_: function Empty() {}
      <function scope>
    ArrayBuffer: function ArrayBuffer() { [native code] }
    Blob: function Blob() { [native code] }
    Boolean: function Boolean() { [native code] }
    DataView: function DataView() { [native code] }
    Date: function Date() { [native code] }
    DedicatedWorkerGlobalScope: function DedicatedWorkerGlobalScope() { [native code] }
    Error: function Error() { [native code] }
// etc. etc.
```


Cette trace fournit la liste complète des objets disponibles dans le contexte d'un worker, et constitue un test très utile lorsqu'il s'agit de savoir ce qui est disponible ou non au sein d'un worker. Nous maintenons aussi une liste des Fonctions et classes disponibles dans les Web Workers.

Spécifications
--------------

| Specification |
| --- |
| HTML Standard # dom-workerglobalscope-self-dev |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

`WorkerGlobalScope`
WorkerGlobalScope.onerror
=========================

La propriété **`onerror`** de l'interface `WorkerGlobalScope` représente un gestionnaire d'évènement à appeler lorsque l'événement `error` survient et se propage à travers le `Worker`.

Syntaxe
-------


```js
self.onerror = function() { ... };
```

Exemple
-------

L'extrait de code suivant montre un gestionnaire `onerror` placé au sein d'un worker :


```js
self.onerror = function () {
  console.log("There is an error inside your worker!");
};
```

Spécifications
--------------

| Specification |
| --- |
| HTML Standard # handler-workerglobalscope-onerror |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

L'interface `WorkerGlobalScope` à laquelle il appartient.
Les données en WebGL
====================

Les programmes shaders ont accès à trois types de stockage de données, chacun d'entre eux ayant un usage particulier. Chaque type de variable est accessible par l'un des types de programmes de shader ou par les deux (en fonction du type de stockage de données), et éventuellement, par le code JavaScript du site, suivant le type de variable particulier.

Types de données GLSL
---------------------

<<documenter les types de base, les vecteurs, etc. ; voir Data Type (GLSL) sur le wiki WebGL de Khronos >>

Variables GLSL
--------------

Il existe trois types de stockage "variable" ou de stockage de données dans GLSL, chacun ayant son propre but et ses propres cas d'utilisation : **attributes**, **varyings**, et **uniforms**.

### Attributes

Les **attributes** sont des variables GLSL qui ne sont disponibles que pour le shader de sommet (en tant que variables) et le code JavaScript. Les attributs sont généralement utilisés pour stocker des informations de couleur, des coordonnées de texture et toutes les autres données calculées ou récupérées qui doivent être partagées entre le code JavaScript et le shader de sommet.

<<add how to use them>>

### Varyings

Les **varyings** sont des variables déclarées par le shader de sommet et elle sont utilisées pour transmettre des données du shader de sommet au shader de fragment. Ceci est communément utilisé pour partager un sommet normal après qu'il a été calculé par le shader de sommet.

<<how to use>>

### Uniforms

Les **uniforms** sont définis par le code JavaScript et sont disponibles à la fois pour le shader de sommet et pour celui de fragment. Ils sont utilisés pour fournir des valeurs qui seront les mêmes pour tout ce qui est dessiné dans le cadre, telles que les positions et les intensités d'éclairage, la transformation globale et les détails de la perspective, et ainsi de suite.

<<add details>>

Tampons
-------

<<add information>>

Textures
--------

<<add information>>
Types WebGL
===========

Les types suivants sont utilisés dans les interfaces WebGL.

WebGL 1
-------

Ces types sont utilisés à l'intérieur d'un `WebGLRenderingContext`.

|  |  |  |
| --- | --- | --- |
| Type | Type Web IDL | Description |
| `GLenum` | `unsigned long` | Utilisé pour les enums. Voir aussi la liste des constantes (en-US). |
| `GLboolean` | `boolean` | Un `Boolean`. |
| `GLbitfield` | `unsigned long` | 
 Un champ de bits stockant plusieurs bits logiques. Utilisé par exemple
 dans `WebGLRenderingContext.clear()`.
  |
| `GLbyte` | `byte` | Entier signé en complément à deux sur 8 bits. |
| `GLshort` | `short` | Entier signé en complément à deux sur 16 bits. |
| `GLint` | `long` | Entier signé en complément à deux sur 32 bits. |
| `GLsizei` | `long` | 
 Utilisé pour les tailles (par ex., la largeur et la hauteur du tampon de
 dessin).
  |
| `GLintptr` | `long long` | Type spécial pour l'arithmétique de pointeur. |
| `GLsizeiptr` | `long long` | Type spécial pour l'arithmétique de pointeur. |
| `GLubyte` | `octet` | Entier non signé en complément à deux sur 8 bits. |
| `GLushort` | `unsigned short` | Entier non signé en complément à deux sur 16 bits. |
| `GLuint` | `unsigned long` | Entier non signé en complément à deux sur 32 bits. |
| `GLfloat` | `unrestricted float` | Nombre en virgule flottante IEEE sur 32 bits. |
| `GLclampf` | `unrestricted float` | Nombre en virgule flottante IEEE sur 32 bits borné. |

WebGL 2
-------

Ces types sont utilisés à l'intérieur d'un `WebGL2RenderingContext`. Tous les types WebGL 1 sont également utilisés.

|  |  |  |
| --- | --- | --- |
| Type | Type Web IDL | Description |
| `GLint64` | `long long` | Nombre entier sur 64 bits signé. |

Extensions WebGL
----------------

Ces types sont utilisés à l'intérieur des extensions WebGL (en-US).

|  |  |  |
| --- | --- | --- |
| Type | Type Web IDL | Description |
| `GLuint64EXT` | `long long` | Nombre entier sur 64 bits non signé. |

Spécifications
--------------

| Specification |
| --- |
| WebGL # 5.1 |
| WebGL2 # 3.1 |
| EXT\_disjoint\_timer\_query  |

Voir aussi
----------

* `WebGLRenderingContext`
Tutoriel WebGL
==============

WebGL permet au contenu web d'utiliser une API basée sur OpenGL ES 2.0 pour effectuer des rendus 3D dans un `<canvas>` HTML dans les navigateurs qui le supportent, sans avoir recours à des modules complémentaires. Les programmes WebGL sont constitués de code de contrôle rédigé en JavaScript, et de code d'effets spéciaux (code shader) qui est exécuté sur l'Unité de Traitement Graphique (GPU) d'un ordinateur. Les éléments WebGL peuvent être mélangés avec d'autres éléments HTML et composés avec d'autres parties de la page ou du fond de la page.

Ce tutoriel décrit comment utiliser l'élément `<canvas>` pour dessiner des graphiques WebGL, en commençant par les bases. Les exemples suivants devraient vous donner des idées de ce que vous pouvez faire avec WebGL et vont vous fournir des fragments de code qui pourraient vous aider à construire votre propre contenu.

Avant que vous ne commenciez
----------------------------

L'utilisation de l'élément `<canvas>` n'est pas très difficile, mais vous avez besoin d'une compréhension de base de l'HTML et du JavaScript. L'élément `<canvas>` et WebGL ne sont pas supportés par certains anciens navigateurs, mais ils sont supportés dans les versions récentes de tous les principaux navigateurs. Pour dessiner des graphiques sur le canevas, on utilise un objet de contexte Javascript, qui crée des graphiques à la volée.

Dans ce tutoriel
----------------

Commencer avec WebGL

Comment mettre en place un contexte WebGL.

Ajouter du contenu à WebGL

Comment faire un rendu simple de figures planes avec WebGL.

Ajouter des couleurs avec les nuanceurs

Démontre comment ajouter de la couleur aux formes avec des nuanceurs.

Animer des objets avec WebGL

Montre comment tourner et déplacer des objets pour créer des animations simples.

Créer des objets 3D avec WebGL

Montre comment créer et animer un objet 3D (dans ce cas, un cube).

Utilisation des textures en WebGL

Démontrer comment appliquer des textures sur les faces d'un objet.

Éclairage en WebGL

Comment simuler des effets d'illumination dans votre contexte WebGL.

Animation de textures en WebGL

Montre comment animer des textures ; dans ce cas, en appliquant une vidéo Ogg sur les faces d'un cube en rotation.
Modèle 1
========

* « Précédent
* Suivant »

Dans cet article, on décrit les fragments de code qui seront réutilisés pour les exemples suivants (où ils seront masqués pour une meilleur lisibilité). Parmi ce code, on définit une fonction JavaScript utilitaire qui permet de simplifier l'initialisation de WebGL.

Socle pour l'initialisation du contexte WebGL
---------------------------------------------

Nous avons vu plusieurs fois les mêmes morceaux de HTML, CSS et JavaScript. Nous allons donc les cacher par la suite afin de mieux nous concentrer sur les parties du code qui sont pertinentes pour l'apprentissage de WebGL.

Plus précisément, le code HTML contiendra

* Un élément `<p>` qui décrira l'exemple et qui permettra d'afficher des messages d'erreur
* Un élément `<canvas>`
* Un bouton (élément `<button>`)

Les règles CSS s'appliqueront aux éléments `body`, `canvas` et `button`. Les éléments supplémentaires pour le code CSS et HTML seront détaillés dans les pages des exemples concernés.

Dans les exemples suivants, on utilisera la fonction utilitaire JavaScript `getRenderingContext` pour initialiser le contexte de rendu WebGL. Grâce aux exemples précédents, vous devriez pouvoir comprendre le rôle de cette fonction. Pour résumer, celle-ci

* Obtient le contexte de rendu de la part de l'élément `canvas`
* Initialise le buffer de dessin
* Nettoie le buffer avec `clear`
* Applique le contexte initialisé

S'il y a une erreur, la fonction affiche un message d'erreur et renvoie `null`.

Enfin, tout le code JavaScript est exécuté par une fonction immédiatement appelée (une technique plutôt commune avec JavaScript). La déclaration de la fonction et son invocation seront cachées.


```html
<p>[ Un texte qui décrit l'exemple. ]</p>
<button>[ Un bouton optionnel pour les interactions. ]</button>
<canvas
 >Il semblerait que votre navigateur ne supporte pas le canevas HTML5.</canvas
>
```



```css
body {
  text-align: center;
}
canvas {
  display: block;
  width: 280px;
  height: 210px;
  margin: auto;
  padding: 0;
  border: none;
  background-color: black;
}
button {
  display: block;
  font-size: inherit;
  margin: auto;
  padding: 0.6em;
}
```



```js
function getRenderingContext() {
  var canvas = document.querySelector("canvas");
  canvas.width = canvas.clientWidth;
  canvas.height = canvas.clientHeight;
  var gl =
    canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
  if (!gl) {
    var paragraph = document.querySelector("p");
    paragraph.innerHTML =
      "Échec de l'obtention du " +
      "contexte WebGL." +
      "Votre navigateur ou appareil ne supporte " +
      "peut-être pas WebGL.";
    return null;
  }
  gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);
  gl.clearColor(0.0, 0.0, 0.0, 1.0);
  gl.clear(gl.COLOR\_BUFFER\_BIT);
  return gl;
}
```


Le code source de cet exemple est également disponible sur GitHub.

* « Précédent
* Suivant »