recursal/MDN huggingface dataset:
element.nodeType
================

La propriété en lecture seule **`Node.nodeType`** représente le type du noeud.Description
-----------

La propriété **`nodeType`** peut être utilisée pour distinguer les uns des autres les différents genres de noeuds tels que `Element`, `Text` et `Comment` .

Syntaxe
-------


```js
Type = node.nodeType;
```


Renvoie un entier (*integer*) qui spécifie le type du noeud ; les valeurs possibles sont listées dans Constantes.

Constantes
----------

### Constantes de type nœud

| Constante | Valeur | Description |
| --- | --- | --- |
| `Node.ELEMENT_NODE` | `1` | Un noeud `Element` tel que `<p>` ou `<div>``.` |
| `Node.TEXT_NODE` | `3` | Le `Text` actuel de l'`Element` ou `Attr`. |
| `Node.PROCESSING_INSTRUCTION_NODE` | `7` | Une `ProcessingInstruction` d'un document XML tel que la déclaration `<?xml-stylesheet ... ?>`. |
| `Node.COMMENT_NODE` | `8` | Un noeud `Comment`. |
| `Node.DOCUMENT_NODE` | `9` | Un noeud `Document`. |
| `Node.DOCUMENT_TYPE_NODE` | `10` | Un noeud `DocumentType` c'est-à-dire `<!DOCTYPE html>` pour des documents HTML5. |
| `Node.DOCUMENT_FRAGMENT_NODE` | `11` | Un noeud `DocumentFragment`. |

### Constantes de type noeud dépréciées 
Obsolète

Les constantes suivantes ont été dépréciées et ne doivent plus être utilisées.

|  |  |  |
| --- | --- | --- |
| Constante | Valeur | Description |
| `Node.ATTRIBUTE_NODE` | 2 | 
 Un `Attribut` d'un
 `Element`. Les attributs d'élément n'implémentent
 plus l'interface `Node` dans la spécification
 DOM4.
  |
| `Node.CDATA_SECTION_NODE` | `4` | 
 Une `CDATASection`. Supprimée dans la
 spécification DOM4.
  |
| `Node.ENTITY_REFERENCE_NODE` | 5 | 
 Un noeud référence d'entité XML. Supprimé dans la spécification
 DOM4.
  |
| `Node.ENTITY_NODE` | 6 | 
 Un noeud `<!ENTITY ...>` XML. Supprimé dans la
 spécificatioin DOM4.
  |
| `Node.NOTATION_NODE` | 12 | 
 Un noeud `<!NOTATION ...>` XML. Supprimé dans la
 spécification DOM4.
  |

Exemples
--------

### Différents types de noeuds


```js
document.nodeType === Node.DOCUMENT\_NODE; // true (vrai)
document.doctype.nodeType === Node.DOCUMENT\_TYPE\_NODE; // true (vrai)

var fragment = document.createDocumentFragment();
fragment.nodeType === Node.DOCUMENT\_FRAGMENT\_NODE; // true (vrai)

var p = document.createElement("p");
p.textContent = "Once upon a time...";

p.nodeType === Node.ELEMENT\_NODE; // true (vrai)
p.firstChild.nodeType === Node.TEXT\_NODE; // true (vrai)
```

### Commentaires

Cet exemple vérifie si le premier noeud dans l'élément du document est un noeud commentaire et si ce n'est pas le cas, affiche un message.


```js
var node = document.documentElement.firstChild;
if (node.nodeType != Node.COMMENT\_NODE)
  console.log("You should comment your code well!");
```

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

| Specification |
| --- |
| DOM Standard # ref-for-dom-node-nodetype① |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
WebGLRenderingContext.deleteBuffer()
====================================

La méthode **`WebGLRenderingContext.deleteBuffer()`** de l'API WebGL supprime le `WebGLBuffer` indiqué. Cette méthode n'a aucun effet si le tampon a déjà été supprimé.

Syntaxe
-------


```js
void gl.deleteBuffer(tampon);
```

### Paramètres

tampon

Un objet `WebGLBuffer` à supprimer.

### Valeur retournée

Aucune.

Exemples
--------

### Suppression d'un tampon


```js
var canevas = document.getElementById("canevas");
var gl = canevas.getContext("webgl");
var tampon = gl.createBuffer();

// ...

gl.deleteBuffer(tampon);
```

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

| Specification |
| --- |
| WebGL Specification # 5.14.5 |

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

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

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

* `WebGLRenderingContext.bindBuffer()`
* `WebGLRenderingContext.createBuffer()`
* `WebGLRenderingContext.isBuffer()`
* Autres tampons : `WebGLFramebuffer`, `WebGLRenderbuffer` (en-US)
WebGLRenderingContext.uniformMatrix[234]fv()
============================================

Les méthodes **`WebGLRenderingContext.uniformMatrix[234]fv()`** de l'API WebGL définissent des valeurs matricielles pour les variables uniform.

Les trois versions de cette méthode (`uniformMatrix2fv()`, `uniformMatrix3fv()` et `unifomMatrix4fv()`) prennent comme valeur d'entrée des vecteurs à 2, 3 et 4 composantes, respectivement.

Syntaxe
-------


```js
WebGLRenderingContext.uniformMatrix2fv(emplacement, transposer, valeur);
WebGLRenderingContext.uniformMatrix3fv(emplacement, transposer, valeur);
WebGLRenderingContext.uniformMatrix4fv(emplacement, transposer, valeur);
```

### Paramètres

`emplacement`

Un objet `WebGLUniformLocation` (en-US) contenant l'emplacement de l'attribut uniform à modifier. L'emplacement est obtenu en utilisant `getAttribLocation()`.

`transposer`

Un `GLboolean` (en-US) indiquant si la matrice doit être transposée. Doit être `false`.

`valeur`

Un `Float32Array` ou une suite de valeurs `GLfloat`.

### Valeur retournée

`undefined`

Exemples
--------


```js
gl.uniformMatrix2fv(loc, false, [2.1, 2.2]);
```

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

| Specification |
| --- |
| WebGL Specification # 5.14.10 |

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

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

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

* `WebGLRenderingContext.uniform()`
* `WebGL2RenderingContext.uniformMatrix()` (en-US) – versions WebGL 2 de ces méthodes.
WebGLRenderingContext.bindBuffer()
==================================

La méthode **`WebGLRenderingContext.bindBuffer()`** de l'API WebGL lie un `WebGLBuffer` donné à une cible.

Syntaxe
-------


```js
void gl.bindBuffer(cible, tampon);
```

### Paramètres

cible

Un `GLenum` (en-US) spécifiant le point de liaison (cible). Valeurs possibles :

* `gl.ARRAY_BUFFER` : tampon contenant des attributs de sommet, tels que des coordonnées de vertex, des données de coordonnées de texture ou des données de couleurs de sommet ;
* `gl.ELEMENT_ARRAY_BUFFER` : tampon utilisé pour les indices d'éléments ;
* Lors de l'utilisation d'un WebGL context 2, les valeurs suivantes sont disponibles en plus :
    + `gl.COPY_READ_BUFFER` : tampon pour la copie d'un objet tampon à un autre ;
    + `gl.COPY_WRITE_BUFFER` : tampon pour la copie d'un objet tampon à un autre ;
    + `gl.TRANSFORM_FEEDBACK_BUFFER` : tampon pour les opérations de retour de la transformation ;
    + `gl.UNIFORM_BUFFER` : tampon utilisé pour stocker des blocs uniformes ;
    + `gl.PIXEL_PACK_BUFFER` : tampon utilisé pour les opérations de transfert de pixels ;
    + `gl.PIXEL_UNPACK_BUFFER` : tampon utilisé pour les opérations de transfert de pixels.

tampon

Un `WebGLBuffer` à lier.

### Valeur retournée

Aucune.

### Exceptions

Une seule cible peut être liée à un `WebGLBuffer` donné. Une tentative de lier le tampon à une autre cible déclenchera une erreur `INVALID_OPERATION` et la liaison du tampon en cours restera la même.

Exemples
--------

### Liaison d'un tampon à une cible


```js
var canevas = document.getElementById("canevas");
var gl = canevas.getContext("webgl");
var tampon = gl.createBuffer();

gl.bindBuffer(gl.ARRAY\_BUFFER, tampon);
```

### Récupération des liaisons en cours

Pour vérifier les liaisons de tampon en cours, interrogez les constantes ARRAY\_BUFFER\_BINDING et ELEMENT\_ARRAY\_BUFFER\_BINDING.


```js
gl.getParameter(gl.ARRAY\_BUFFER\_BINDING);
gl.getParameter(gl.ELEMENT\_ARRAY\_BUFFER\_BINDING);
```

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

| Specification |
| --- |
| WebGL Specification # 5.14.5 |
| WebGL 2.0 Specification # 3.7.1 |

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

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

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

* `WebGLRenderingContext.createBuffer()`
* `WebGLRenderingContext.deleteBuffer()`
* `WebGLRenderingContext.isBuffer()`
* Autres tampons : `WebGLFramebuffer`, `WebGLRenderbuffer` (en-US)
WebGLRenderingContext.drawArrays()
==================================

La méthode **`WebGLRenderingContext.drawArrays()`** de l'API WebGL dessine des primitives à partir de données tabulaires.

Syntaxe
-------


```js
void gl.drawArrays(mode, premier, compte);
```

### Paramètres

`mode`

Un `GLenum` (en-US) indiquant la primitive de type à dessiner. Les valeurs possibles sont :

* `gl.POINTS` : dessine un seul point ;
* `gl.LINE_STRIP` : dessine une ligne droite jusqu'au sommet suivant ;
* `gl.LINE_LOOP` : dessine une ligne droite jusqu'au sommet suivant, et relie le dernier sommet au premier ;
* `gl.LINES` : dessine une ligne entre une paire de sommets ;
* `gl.TRIANGLE_STRIP`
* `gl.TRIANGLE_FAN`
* `gl.TRIANGLES` : dessine un triangle pour un groupe de trois sommets.

`premier`

Un `GLint` (en-US) indiquant de l'indice de départ dans le tableau des points des vecteurs.

`compte`

Un `GLsizei` (en-US) indiquant le nombre d'indices à dessiner.

### Valeur retournée

None.

### Exceptions

* Si `mode` n'est pas l'une des valeurs acceptables, une erreur `gl.INVALID_ENUM` est déclenchée.
* Si `premier` ou `compte` sont négatifs, une erreur `gl.INVALID_VALUE` est déclenchée.
* Si `gl.CURRENT_PROGRAM` est `null`, une erreur `gl.INVALID_OPERATION` est déclenchée.
Exemples
--------


```js
gl.drawArrays(gl.POINTS, 0, 8);
```

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

| Specification |
| --- |
| WebGL Specification # 5.14.11 |

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

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

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

* `WebGLRenderingContext.drawElements()` (en-US)
* `ext.drawArraysInstancedANGLE()` (en-US)
* `ext.drawElementsInstancedANGLE()` (en-US)
* `ext.vertexAttribDivisorANGLE()` (en-US)
* `WebGL2RenderingContext.drawArraysInstanced()` (en-US)
* `WebGL2RenderingContext.drawElementsInstanced()` (en-US)
* `WebGL2RenderingContext.vertexAttribDivisor()` (en-US)
WebGLRenderingContext.getShaderParameter()
==========================================

La méthode `WebGLRenderingContext.getShaderParameter()` de l'API WebGL retourne des informations sur le shader donné.

Syntaxe
-------


```js
quelconque gl.getShaderParameter(shader, nomp);
```

### Parameters

shader

Un `WebGLShader` depuis lequel obtenir une information de paramètre.

nomp

Un `Glenum` (en-US) indiquant l'information à retrouver. Valeurs possibles :

* `gl.DELETE_STATUS` : retourne un `GLboolean` (en-US) indicating si le shader est marqué pour suppression ou non.
* `gl.COMPILE_STATUS` : retourne un `GLboolean` (en-US) indiquant si la dernière compilation du shader a réussi ou non.
* `gl.SHADER_TYPE` : retourne un `GLenum` (en-US) indiquant si le shader est un objet shader de sommets (`gl.VERTEX_SHADER`) ou shader de fragment (`gl.FRAGMENT_SHADER`).

### Valeur retournée

Retourne l'information de shader demandée (telle qu'indiquée par `nomp`).

Exemples
--------


```js
gl.getShaderParameter(shader, gl.SHADER\_TYPE);
```

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

| Specification |
| --- |
| WebGL Specification # 5.14.9 |

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

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

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

* `WebGLRenderingContext.getProgramParameter()` (en-US)
WebGLRenderingContext.createProgram()
=====================================

La méthode **`WebGLRenderingContext.createProgram()`** de l'API WebGL crée et initialise un objet `WebGLProgram`.

Syntaxe
-------


```js
WebGLProgram gl.createProgram();
```

### Paramètres

Aucun.

### Valeur retournée

Un objet `WebGLProgram` qui est une combinaison de deux `WebGLShader`s compilés, constitués d'un shader de sommet et d'un shader de fragment (tous deux écrits en GLSL). Ceux-ci sont ensuite liés en un programme utilisable.

Exemples
--------

### Création d'un programme WebGL


```js
var programme = gl.createProgram();

// Attacher les shaders pré-existants
gl.attachShader(programme, shaderDeSommet);
gl.attachShader(programme, shaderDeFragment);

gl.linkProgram(programme);

if (!gl.getProgramParameter(programme, gl.LINK\_STATUS)) {
  var info = gl.getProgramInfoLog(program);
  throw "Impossible de compiler le programme WebGL. \n\n" + info;
}
```


Voir `WebGLShader` pour plus d'informations sur la création du `shaderDeSommet` et du `shaderDeFragment` dans l'exemple ci-dessus.

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

| Specification |
| --- |
| WebGL Specification # 5.14.9 |

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

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

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

* `WebGLRenderingContext.deleteProgram()` (en-US)
* `WebGLRenderingContext.isProgram()` (en-US)
* `WebGLRenderingContext.linkProgram()` (en-US)
* `WebGLRenderingContext.useProgram()`
* `WebGLRenderingContext.validateProgram()` (en-US)
* `WebGLRenderingContext.getProgramParameter()` (en-US)
* `WebGLRenderingContext.getProgramInfoLog()` (en-US)
WebGLRenderingContext.generateMipmap()
======================================

La méthode **`WebGLRenderingContext.generateMipmap()`** de l'API WebGL génère un ensemble de mipmaps pour un objet `WebGLTexture`.

Les mipmaps sont utilisées pour créer de la distance avec des objets. Une mipmap de haute résolution est utilisée pour les objets qui sont proches, et une mipmap de résolution inférieure est utilisée pour les objets qui sont plus éloignés. Elles commencent avec la résolution de l'image de texture, puis la résolution est divisée par deux jusqu'à ce qu'une image de texture de dimension 1x1 soit créée.

Syntaxe
-------


```js
void gl.generateMipmap(cible);
```

### Paramètres

cible

Un `GLenum` (en-US) indiquant le point de liaison (cible) de la texture active dont les mipmaps seront générées. Valeurs possibles :

* `gl.TEXTURE_2D` : une texture bi-dimensionnelle.
* `gl.TEXTURE_CUBE_MAP` : une texture appliquée sur un cube.
* Lorsqu'un WebGL 2 context est utilisé, les valeurs suivantes sont en outre disponibles :
    + `gl.TEXTURE_3D` : une texture tri-dimensionnelle.
    + `gl.TEXTURE_2D_ARRAY` : une texture bi-dimensionnelle en tableau.

### Valeur retournée

Aucune.

Exemples
--------


```js
gl.generateMipmap(gl.TEXTURE\_2D);
```

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

| Specification |
| --- |
| WebGL Specification # 5.14.8 |

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

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

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

* `WebGLRenderingContext.createTexture()`
* `WebGLRenderingContext.bindTexture()`
* `WebGLRenderingContext.getTexParameter()`
* `WebGLRenderingContext.texParameterf()`
* `WebGLRenderingContext.texParameteri()`
WebGLRenderingContext.viewport()
================================

La méthode **`WebGLRenderingContext.viewport()`** de l'API WebGL définit le viewport, qui indique la transformation affine de x et de y, de coordonnées d'appareil normalisées en coordonnées de fenêtre.

Syntaxe
-------


```js
void gl.viewport(x, y, largeur, hauteur);
```

### Paramètres

`x`

Un `GLint` (en-US) indiquant la coordonnée horizontale du coin inférieur gauche de l'origine du viewport. Valeur par défaut : 0.

`y`

Un `GLint` (en-US) indiquant la coordonnée verticale du coin inférieur gauche de l'origine du viewport. Valeur par défaut : 0.

largeur

Un `Glsizei` (en-US) non négatif indiquant la largeur du viewport. Valeur par défaut : la largeur du canevas.

height

Un `Glsizei` (en-US) non négatif indiquant la hauteur du viewport. Valeur par défaut : la hauteur du canevas.

### Valeur retournée

Aucune.

### Erreurs déclenchées

Si *largeur* ou *hauteur* est une valeur négative, une erreur `gl.INVALID_VALUE` est déclenchée.

Exemples
--------

Lorsque vous créez un contexte WebGL pour la première fois, la taille de la fenêtre correspondra à celle du canevas. Toutefois, si vous redimensionnez le canevas, vous devrez indiquer au contexte de WebGL une nouvelle définition de viewport. Dans cette situation, vous pouvez utiliser `gl.viewport`.


```js
gl.viewport(0, 0, canevas.width, canevas.height);
```


La largeur et la hauteur de la fenêtre sont limitées à une plage dépendante de l'implémentation. Pour obtenir cette plage, vous pouvez utiliser la constante `MAX_VIEWPORT_DIMS`, qui renvoie un `Int32Array`.


```js
gl.getParameter(gl.MAX\_VIEWPORT\_DIMS);
// Par ex., Int32Array[16384, 16384]
```


Pour obtenir le viewport en cours, faites une requête sur la constante `VIEWPORT`.


```js
gl.getParameter(gl.VIEWPORT);
// e.g. Int32Array[0, 0, 640, 480]
```

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

| Specification |
| --- |
| WebGL Specification # 5.14.4 |

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

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

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

* `WebGLRenderingContext.scissor()` (en-US)
* `WebGLRenderingContext.getParameter()` (en-US)
WebGLRenderingContext.useProgram()
==================================

La méthode **`WebGLRenderingContext.useProgram()`** de l'API WebGL définit le `WebGLProgram` spécifié comme faisant partie de l'état de rendu en cours.

Syntaxe
-------


```js
void gl.useProgram(programme);
```

### Paramètres

programme

Un `WebGLProgram` à utiliser.

### Valeur retournée

Aucune.

Exemples
--------


```js
var programme = gl.createProgram();

// Attacher les shaders pré-existants
gl.attachShader(programme, vertexShader);
gl.attachShader(programme, fragmentShader);

gl.linkProgram(programme);
gl.useProgram(programme);
```

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

| Specification |
| --- |
| WebGL Specification # 5.14.9 |

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

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

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

* `WebGLRenderingContext.createProgram()`
* `WebGLRenderingContext.deleteProgram()` (en-US)
* `WebGLRenderingContext.isProgram()` (en-US)
* `WebGLRenderingContext.linkProgram()` (en-US)
* `WebGLRenderingContext.validateProgram()` (en-US)
* `WebGLRenderingContext.getProgramParameter()` (en-US)
* `WebGLRenderingContext.getProgramInfoLog()` (en-US)
WebGLRenderingContext.activeTexture()
=====================================

La méthode **`WebGLRenderingContext.activeTexture()`** de l'API WebGL indique quelle unité de texture doit être rendue active.

Syntaxe
-------


```js
void gl.activeTexture(texture);
```

### Paramètres

`texture`

L'unité de texture à rendre active. La valueur est une `gl.TEXTUREI` où *I* est dans la plage de 0 à `gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1`.

### Valeur retournée

Aucune.

### Exceptions

Si *texture* n'est pas l'une des `gl.TEXTUREI`, où *I* est dans la plage de 0 à `gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1`, une erreur `gl.INVALID_ENUM` est déclenchée.

Exemples
--------

L'appel suivant choisit `gl.TEXTURE1` comme texture en cours. Les appels suivants qui modifient l'état de la texture affecteront cette texture.


```js
gl.activeTexture(gl.TEXTURE1);
```


Le nombre d'unités de texture dépend de l'implémentation, vous pouvez obtenir ce nombre à l'aide de la constante `MAX_COMBINED_TEXTURE_IMAGE_UNITS`. Il est, de par la spécification, d'au moins 8.


```js
gl.getParameter(gl.MAX\_COMBINED\_TEXTURE\_IMAGE\_UNITS);
```


Pour obtenir la texture en cours, faire une requête sur la constante `ACTIVE_TEXTURE`.


```js
gl.activeTexture(gl.TEXTURE0);
gl.getParameter(gl.ACTIVE\_TEXTURE);
// retourne "33984" (0x84C0, valeur enum pour gl.TEXTURE0)
```

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

| Specification |
| --- |
| WebGL Specification # 5.14.3 |

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

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

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

* `WebGLRenderingContext.getParameter()` (en-US)
WebGLRenderingContext.compileShader()
=====================================

La méthode **WebGLRenderingContext.compileShader()** de l'API WebGL compile un shader GLSL en données binaires, de sorte qu'il puisse être utilisé par un `WebGLProgram`.

Syntaxe
-------


```js
void gl.compileShader(shader);
```

### Paramètres

`shader`

Un `WebGLShader` de fragments ou de sommets.

Exemples
--------


```js
var shader = gl.createShader(gl.VERTEX\_SHADER);
gl.shaderSource(shader, sourceShader);
gl.compileShader(shader);
```

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

| Specification |
| --- |
| WebGL Specification # 5.14.9 |

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

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

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

* `WebGLProgram`
* `WebGLShader`
* `WebGLRenderingContext.attachShader()`
* `WebGLRenderingContext.createProgram()`
* `WebGLRenderingContext.createShader()`
* `WebGLRenderingContext.deleteProgram()` (en-US)
* `WebGLRenderingContext.deleteShader()`
* `WebGLRenderingContext.detachShader()` (en-US)
* `WebGLRenderingContext.getAttachedShaders()` (en-US)
* `WebGLRenderingContext.getProgramParameter()` (en-US)
* `WebGLRenderingContext.getProgramInfoLog()` (en-US)
* `WebGLRenderingContext.getShaderParameter()`
* `WebGLRenderingContext.getShaderPrecisionFormat()` (en-US)
* `WebGLRenderingContext.getShaderInfoLog()` (en-US)
* `WebGLRenderingContext.getShaderSource()` (en-US)
* `WebGLRenderingContext.isProgram()` (en-US)
* `WebGLRenderingContext.isShader()` (en-US)
* `WebGLRenderingContext.linkProgram()` (en-US)
* `WebGLRenderingContext.shaderSource()`
* `WebGLRenderingContext.useProgram()`
* `WebGLRenderingContext.validateProgram()` (en-US)
WebGLRenderingContext.clear()
=============================

La méthode **`WebGLRenderingContext.clear()`** de l'API WebGL efface les tampons avec des valeurs prédéfinies.

Ces valeurs prédéfinies peuvent être affectées par `clearColor()` (en-US), `clearDepth()` (en-US) ou `clearStencil()` (en-US).

Les masques d'écriture, de détourage, de tramage et de tampon peuvent affecter la méthode `clear()`.

Syntaxe
-------


```js
void gl.clear(masque);
```

### Paramètres

`masque`

Un masque OU par bits `GLbitfield` (en-US) qui indique les tampons à effacer. Les valeurs possibles sont :

* `gl.COLOR_BUFFER_BIT`
* `gl.DEPTH_BUFFER_BIT`
* `gl.STENCIL_BUFFER_BIT`

### Valeur retournée

Aucune.

### Exceptions

Si *masque* n'est pas l'une des valeurs possibles listées, une erreur `gl.INVALID_ENUM` est déclenchée.

Exemples
--------

La méthode `clear()` accepte des valeurs multiples.


```js
gl.clear(gl.DEPTH\_BUFFER\_BIT);
gl.clear(gl.DEPTH\_BUFFER\_BIT | gl.COLOR\_BUFFER\_BIT);
```


Pour obtenir les valeurs d'effacement courantes, interrogez les constantes `COLOR_CLEAR_VALUE`, `DEPTH_CLEAR_VALUE` et `STENCIL_CLEAR_VALUE` grâce à la méthode `getParameter()`.


```js
gl.getParameter(gl.COLOR\_CLEAR\_VALUE);
gl.getParameter(gl.DEPTH\_CLEAR\_VALUE);
gl.getParameter(gl.STENCIL\_CLEAR\_VALUE);
```

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

| Specification |
| --- |
| WebGL Specification # 5.14.11 |

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

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

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

* `WebGLRenderingContext.clearColor()` (en-US)
* `WebGLRenderingContext.clearDepth()` (en-US)
* `WebGLRenderingContext.clearStencil()` (en-US)