convert content to md

33 files changed, 2385 insertions, 2913 deletions

diff --git a/files/fr/web/api/webglrenderingcontext/activetexture/index.md b/files/fr/web/api/webglrenderingcontext/activetexture/index.md
index 2967ea1329..86065baf61 100644
--- a/files/fr/web/api/webglrenderingcontext/activetexture/index.md
+++ b/files/fr/web/api/webglrenderingcontext/activetexture/index.md
@@ -9,77 +9,60 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/activeTexture
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La méthode <strong><code>WebGLRenderingContext.activeTexture()</code></strong> de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> indique quelle unité de texture doit être rendue active.</p>
+La méthode **`WebGLRenderingContext.activeTexture()`** de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API) indique quelle unité de texture doit être rendue active.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var><em>void gl</em>.activeTexture</var><var>(texture);</var>
-</pre>
+    void gl.activeTexture(texture);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>texture</code></dt>
- <dd>L'unité de texture à rendre active. La valueur est une <code>gl.TEXTURE<em>I</em></code> où <em>I</em> est dans la plage de 0 à<code>gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1</code>.</dd>
-</dl>
+- `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`.
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+### Valeur retournée
 
-<p>Aucune.</p>
+Aucune.
 
-<h3 id="Exceptions">Exceptions</h3>
+### Exceptions
 
-<p>Si <em>texture</em> n'est pas l'une des <code>gl.TEXTURE<em>I</em></code>, où <em>I</em> est dans la plage de 0 à<code>gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1</code>, une erreur <code>gl.INVALID_ENUM</code> est déclenchée.</p>
+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.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>L'appel suivant choisit <code>gl.TEXTURE1</code> comme texture en cours. Les appels suivants qui modifient l'état de la texture affecteront cette texture.</p>
+L'appel suivant choisit `gl.TEXTURE1` comme texture en cours. Les appels suivants qui modifient l'état de la texture affecteront cette texture.
 
-<pre class="brush: js">gl.activeTexture(gl.TEXTURE1);
-</pre>
+```js
+gl.activeTexture(gl.TEXTURE1);
+```
 
-<p>Le nombre d'unités de texture dépend de l'implémentation, vous pouvez obtenir ce nombre à l'aide de la constante <code>MAX_COMBINED_TEXTURE_IMAGE_UNITS</code>. Il est, de par la spécification, d'au moins 8.</p>
+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.
 
-<pre class="brush: js">gl.getParameter(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS);
-</pre>
+```js
+gl.getParameter(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS);
+```
 
-<p>Pour obtenir la texture en cours, faire une requête sur la constante <code>ACTIVE_TEXTURE</code>.</p>
+Pour obtenir la texture en cours, faire une requête sur la constante `ACTIVE_TEXTURE`.
 
-<pre class="brush: js">gl.activeTexture(gl.TEXTURE0);
+```js
+gl.activeTexture(gl.TEXTURE0);
 gl.getParameter(gl.ACTIVE_TEXTURE);
 // retourne "33984" (0x84C0, valeur enum pour gl.TEXTURE0)
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statué</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.3", "activeTexture")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glActiveTexture.xml", "glActiveTexture")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man de l'API OpenGL.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.WebGLRenderingContext.activeTexture")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("WebGLRenderingContext.getParameter()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                    | Statué                               | Commentaire               |
+| ------------------------------------------------------------------------------------------------ | ------------------------------------ | ------------------------- |
+| {{SpecName('WebGL', "#5.14.3", "activeTexture")}}                                 | {{Spec2('WebGL')}}             | Définition initiale.      |
+| {{SpecName('OpenGL ES 2.0', "glActiveTexture.xml", "glActiveTexture")}} | {{Spec2('OpenGL ES 2.0')}} | Page man de l'API OpenGL. |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.WebGLRenderingContext.activeTexture")}}
+
+## Voir aussi
+
+- {{domxref("WebGLRenderingContext.getParameter()")}}
diff --git a/files/fr/web/api/webglrenderingcontext/attachshader/index.md b/files/fr/web/api/webglrenderingcontext/attachshader/index.md
index 9b2c2b9be7..0cda2deaaa 100644
--- a/files/fr/web/api/webglrenderingcontext/attachshader/index.md
+++ b/files/fr/web/api/webglrenderingcontext/attachshader/index.md
@@ -6,29 +6,27 @@ tags:
   - WebGL
 translation_of: Web/API/WebGLRenderingContext/attachShader
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La méthode <strong>WebGLRenderingContext.attachShader()</strong> de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> attache un {{domxref("WebGLShader")}} de fragment ou de sommet à un {{domxref("WebGLProgram")}}.</p>
+La méthode **WebGLRenderingContext.attachShader()** de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API) attache un {{domxref("WebGLShader")}} de fragment ou de sommet à un {{domxref("WebGLProgram")}}.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">void <var><em>gl</em>.attach</var>Shader<var>(programme, shader);</var>
-</pre>
+    void gl.attachShader(programme, shader);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>programme</code></dt>
- <dd>Un {{domxref("WebGLProgram")}}.</dd>
- <dt><code>shader</code></dt>
- <dd>Un {{domxref("WebGLShader")}} de fragment ou de sommet.</dd>
-</dl>
+- `programme`
+  - : Un {{domxref("WebGLProgram")}}.
+- `shader`
+  - : Un {{domxref("WebGLShader")}} de fragment ou de sommet.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Le code suivant attache des shaders pré-existants à un {{domxref("WebGLProgram")}}.</p>
+Le code suivant attache des shaders pré-existants à un {{domxref("WebGLProgram")}}.
 
-<pre class="brush: js">var programme = gl.createProgram();
+```js
+var programme = gl.createProgram();
 
 // Attacher des shaders pré-existants
 gl.attachShader(programme, shaderDeSommet);
@@ -40,57 +38,40 @@ if ( !gl.getProgramParameter( programme, gl.LINK_STATUS) ) {
   var info = gl.getProgramInfoLog(programme);
   throw 'Impossible de compiler le program WebGL. \n\n' + info;
 }
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.9", "attachShader")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glAttachShader.xml", "glAttachShader")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man OpenGL.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.WebGLRenderingContext.attachShader")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("WebGLProgram")}}</li>
- <li>{{domxref("WebGLShader")}}</li>
- <li>{{domxref("WebGLRenderingContext.attachShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.compileShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.createProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.createShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.deleteProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.deleteShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.detachShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getAttachedShaders()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getProgramParameter()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getProgramInfoLog()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getShaderParameter()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getShaderPrecisionFormat()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getShaderInfoLog()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getShaderSource()")}}</li>
- <li>{{domxref("WebGLRenderingContext.isProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.isShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.linkProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.shaderSource()")}}</li>
- <li>{{domxref("WebGLRenderingContext.useProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.validateProgram()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                | Statut                               | Commentaire          |
+| -------------------------------------------------------------------------------------------- | ------------------------------------ | -------------------- |
+| {{SpecName('WebGL', "#5.14.9", "attachShader")}}                             | {{Spec2('WebGL')}}             | Définition initiale. |
+| {{SpecName('OpenGL ES 2.0', "glAttachShader.xml", "glAttachShader")}} | {{Spec2('OpenGL ES 2.0')}} | Page man OpenGL.     |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.WebGLRenderingContext.attachShader")}}
+
+## Voir aussi
+
+- {{domxref("WebGLProgram")}}
+- {{domxref("WebGLShader")}}
+- {{domxref("WebGLRenderingContext.attachShader()")}}
+- {{domxref("WebGLRenderingContext.compileShader()")}}
+- {{domxref("WebGLRenderingContext.createProgram()")}}
+- {{domxref("WebGLRenderingContext.createShader()")}}
+- {{domxref("WebGLRenderingContext.deleteProgram()")}}
+- {{domxref("WebGLRenderingContext.deleteShader()")}}
+- {{domxref("WebGLRenderingContext.detachShader()")}}
+- {{domxref("WebGLRenderingContext.getAttachedShaders()")}}
+- {{domxref("WebGLRenderingContext.getProgramParameter()")}}
+- {{domxref("WebGLRenderingContext.getProgramInfoLog()")}}
+- {{domxref("WebGLRenderingContext.getShaderParameter()")}}
+- {{domxref("WebGLRenderingContext.getShaderPrecisionFormat()")}}
+- {{domxref("WebGLRenderingContext.getShaderInfoLog()")}}
+- {{domxref("WebGLRenderingContext.getShaderSource()")}}
+- {{domxref("WebGLRenderingContext.isProgram()")}}
+- {{domxref("WebGLRenderingContext.isShader()")}}
+- {{domxref("WebGLRenderingContext.linkProgram()")}}
+- {{domxref("WebGLRenderingContext.shaderSource()")}}
+- {{domxref("WebGLRenderingContext.useProgram()")}}
+- {{domxref("WebGLRenderingContext.validateProgram()")}}
diff --git a/files/fr/web/api/webglrenderingcontext/bindbuffer/index.md b/files/fr/web/api/webglrenderingcontext/bindbuffer/index.md
index 72cc698db6..33c12df96c 100644
--- a/files/fr/web/api/webglrenderingcontext/bindbuffer/index.md
+++ b/files/fr/web/api/webglrenderingcontext/bindbuffer/index.md
@@ -9,122 +9,120 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/bindBuffer
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La méthode <strong><code>WebGLRenderingContext.bindBuffer()</code></strong> de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> lie un {{domxref("WebGLBuffer")}} donné à une cible.</p>
+La méthode **`WebGLRenderingContext.bindBuffer()`** de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API) lie un {{domxref("WebGLBuffer")}} donné à une cible.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">void <var>gl</var>.bindBuffer(<var>cible</var>, <var>tampon</var>);
-</pre>
+    void gl.bindBuffer(cible, tampon);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt>cible</dt>
- <dd>Un {{domxref ("GLenum")}} spécifiant le point de liaison (cible). Valeurs possibles :</dd>
-</dl>
+- cible
+  - : Un {{domxref ("GLenum")}} spécifiant le point de liaison (cible). Valeurs possibles :
 
-<ul>
- <li><code>gl.ARRAY_BUFFER</code> : 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 ;</li>
- <li><code>gl.ELEMENT_ARRAY_BUFFER</code> : tampon utilisé pour les indices d'éléments ;</li>
- <li>Lors de l'utilisation d'un {{domxref("WebGL2RenderingContext", "WebGL context 2", "", 1)}}, les valeurs suivantes sont disponibles en plus :
-  <ul>
-   <li><code>gl.COPY_READ_BUFFER</code> : tampon pour la copie d'un objet tampon à un autre ;</li>
-   <li><code>gl.COPY_WRITE_BUFFER</code> : tampon pour la copie d'un objet tampon à un autre ;</li>
-   <li><code>gl.TRANSFORM_FEEDBACK_BUFFER</code> : tampon pour les opérations de retour de la transformation ;</li>
-   <li><code>gl.UNIFORM_BUFFER</code> : tampon utilisé pour stocker des blocs uniformes ;</li>
-   <li><code>gl.PIXEL_PACK_BUFFER</code> : tampon utilisé pour les opérations de transfert de pixels ;</li>
-   <li><code>gl.PIXEL_UNPACK_BUFFER</code> : tampon utilisé pour les opérations de transfert de pixels.</li>
-  </ul>
- </li>
-</ul>
+<!---->
 
-<dl>
- <dt>tampon</dt>
- <dd>Un {{domxref ("WebGLBuffer")}} à lier.</dd>
-</dl>
+- `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 {{domxref("WebGL2RenderingContext", "WebGL context 2", "", 1)}}, les valeurs suivantes sont disponibles en plus :
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+  - `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.
 
-<p>Aucune.</p>
+<!---->
 
-<h3 id="Exceptions">Exceptions</h3>
+- tampon
+  - : Un {{domxref ("WebGLBuffer")}} à lier.
 
-<p>Une seule cible peut être liée à un {{domxref ("WebGLBuffer")}} donné. Une tentative de lier le tampon à une autre cible déclenchera une erreur <code>INVALID_OPERATION</code> et la liaison du tampon en cours restera la même.</p>
+### Valeur retournée
 
-<h2 id="Exemples">Exemples</h2>
+Aucune.
 
-<h3 id="Liaison_d'un_tampon_à_une_cible">Liaison d'un tampon à une cible</h3>
+### Exceptions
 
-<pre class="brush: js">var canevas = document.getElementById('canevas');
+Une seule cible peut être liée à un {{domxref ("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);
-</pre>
+```
 
-<h3 id="Récupération_des_liaisons_en_cours">Récupération des liaisons en cours</h3>
+### Récupération des liaisons en cours
 
-<p>Pour vérifier les liaisons de tampon en cours, interrogez les constantes ARRAY_BUFFER_BINDING et ELEMENT_ARRAY_BUFFER_BINDING.</p>
+Pour vérifier les liaisons de tampon en cours, interrogez les constantes ARRAY_BUFFER_BINDING et ELEMENT_ARRAY_BUFFER_BINDING.
 
-<pre class="brush: js">gl.getParameter(gl.ARRAY_BUFFER_BINDING);
+```js
+gl.getParameter(gl.ARRAY_BUFFER_BINDING);
 gl.getParameter(gl.ELEMENT_ARRAY_BUFFER_BINDING);
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
 <table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.5", "bindBuffer")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>
-    <p>Définition initiale pour WebGL.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glBindBuffer.xml", "glBindBuffer")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man de l’API OpenGL ES 2 (similaire).</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL2', "#3.7.1", "bindBuffer")}}</td>
-   <td>{{Spec2('WebGL2')}}</td>
-   <td>
-    <p>Définition mise à jour pour WebGL 2.</p>
-
-    <p>Ajoute de nouveaux tampons <code>cible</code> :<br>
-     <code>gl.COPY_READ_BUFFER</code>,<br>
-     <code>gl.COPY_WRITE_BUFFER</code>,<br>
-     <code>gl.TRANSFORM_FEEDBACK_BUFFER</code>,<br>
-     <code>gl.UNIFORM_BUFFER</code>,<br>
-     <code>gl.PIXEL_PACK_BUFFER</code>,<br>
-     <code>gl.PIXEL_UNPACK_BUFFER</code></p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 3.0', "glBindBuffer.xhtml", "glBindBuffer")}}</td>
-   <td>{{Spec2('OpenGL ES 3.0')}}</td>
-   <td>Page man de l’API OpenGL ES 3 (similaire).</td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <th scope="col">Spécification</th>
+      <th scope="col">Statut</th>
+      <th scope="col">Commentaire</th>
+    </tr>
+    <tr>
+      <td>{{SpecName('WebGL', "#5.14.5", "bindBuffer")}}</td>
+      <td>{{Spec2('WebGL')}}</td>
+      <td><p>Définition initiale pour WebGL.</p></td>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('OpenGL ES 2.0', "glBindBuffer.xml", "glBindBuffer")}}
+      </td>
+      <td>{{Spec2('OpenGL ES 2.0')}}</td>
+      <td>Page man de l’API OpenGL ES 2 (similaire).</td>
+    </tr>
+    <tr>
+      <td>{{SpecName('WebGL2', "#3.7.1", "bindBuffer")}}</td>
+      <td>{{Spec2('WebGL2')}}</td>
+      <td>
+        <p>Définition mise à jour pour WebGL 2.</p>
+        <p>
+          Ajoute de nouveaux tampons <code>cible</code> :<br /><code
+            >gl.COPY_READ_BUFFER</code
+          >,<br /><code>gl.COPY_WRITE_BUFFER</code>,<br /><code
+            >gl.TRANSFORM_FEEDBACK_BUFFER</code
+          >,<br /><code>gl.UNIFORM_BUFFER</code>,<br /><code
+            >gl.PIXEL_PACK_BUFFER</code
+          >,<br /><code>gl.PIXEL_UNPACK_BUFFER</code>
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('OpenGL ES 3.0', "glBindBuffer.xhtml", "glBindBuffer")}}
+      </td>
+      <td>{{Spec2('OpenGL ES 3.0')}}</td>
+      <td>Page man de l’API OpenGL ES 3 (similaire).</td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.WebGLRenderingContext.bindBuffer")}}</p>
+{{Compat("api.WebGLRenderingContext.bindBuffer")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{domxref("WebGLRenderingContext.createBuffer()")}}</li>
- <li>{{domxref("WebGLRenderingContext.deleteBuffer()")}}</li>
- <li>{{domxref("WebGLRenderingContext.isBuffer()")}}</li>
- <li>Autres tampons : {{domxref("WebGLFramebuffer")}}, {{domxref("WebGLRenderbuffer")}}</li>
-</ul>
+- {{domxref("WebGLRenderingContext.createBuffer()")}}
+- {{domxref("WebGLRenderingContext.deleteBuffer()")}}
+- {{domxref("WebGLRenderingContext.isBuffer()")}}
+- Autres tampons : {{domxref("WebGLFramebuffer")}}, {{domxref("WebGLRenderbuffer")}}
diff --git a/files/fr/web/api/webglrenderingcontext/bindtexture/index.md b/files/fr/web/api/webglrenderingcontext/bindtexture/index.md
index 662c18a8be..fd75432b79 100644
--- a/files/fr/web/api/webglrenderingcontext/bindtexture/index.md
+++ b/files/fr/web/api/webglrenderingcontext/bindtexture/index.md
@@ -10,110 +10,106 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/bindTexture
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La méthode <strong><code>WebGLRenderingContext.bindTexture()</code></strong> de l'API WebGL lie la {{domxref("WebGLTexture")}} donnée à une cible (point de liaison).</p>
+La méthode **`WebGLRenderingContext.bindTexture()`** de l'API WebGL lie la {{domxref("WebGLTexture")}} donnée à une cible (point de liaison).
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">void <var>gl</var>.bindTexture(<var>cible</var>, <var>texture</var>);
-</pre>
+    void gl.bindTexture(cible, texture);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt>cible</dt>
- <dd>Un {{domxref ("GLenum")}} indiquant le point de liaison (cible). Valeurs possibles :
- <ul>
-  <li><code>gl.TEXTURE_2D</code> : une texture bidimensionnelle ;</li>
-  <li><code>gl.TEXTURE_CUBE_MAP</code> : une texture mappée sur un cube ;</li>
-  <li>lors de l'utilisation d'un {{domxref("WebGL2RenderingContext", "WebGL 2 context", "", 1)}}, les valeurs suivantes sont en outre disponibles :
-   <ul>
-    <li><code>gl.TEXTURE_3D</code> : une texture tridimensionnelle ;</li>
-    <li><code>gl.TEXTURE_2D_ARRAY</code> : une texture en tableau bidimensionnelle.</li>
-   </ul>
-  </li>
- </ul>
- </dd>
- <dt>texture</dt>
- <dd>Un objet {{domxref ("WebGLTexture")}} à lier.</dd>
-</dl>
+- cible
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+  - : Un {{domxref ("GLenum")}} indiquant le point de liaison (cible). Valeurs possibles :
 
-<p>Aucune.</p>
+    - `gl.TEXTURE_2D` : une texture bidimensionnelle ;
+    - `gl.TEXTURE_CUBE_MAP` : une texture mappée sur un cube ;
+    - lors de l'utilisation d'un {{domxref("WebGL2RenderingContext", "WebGL 2 context", "", 1)}}, les valeurs suivantes sont en outre disponibles :
 
-<h3 id="Exceptions">Exceptions</h3>
+      - `gl.TEXTURE_3D` : une texture tridimensionnelle ;
+      - `gl.TEXTURE_2D_ARRAY` : une texture en tableau bidimensionnelle.
 
-<p>Une erreur <code>gl.INVALID_ENUM</code> est déclenchée si <code>cible</code> n'est pas <code>gl.TEXTURE_2D</code>, <code>gl.TEXTURE_CUBE_MAP</code>, <code>gl.TEXTURE_3D</code>, ou <code>gl.TEXTURE_2D_ARRAY</code>.</p>
+- texture
+  - : Un objet {{domxref ("WebGLTexture")}} à lier.
 
-<h2 id="Exemples">Exemples</h2>
+### Valeur retournée
 
-<h3 id="Liaison_d'une_texture">Liaison d'une texture</h3>
+Aucune.
 
-<pre class="brush: js">var canevas = document.getElementById('canevas');
+### Exceptions
+
+Une erreur `gl.INVALID_ENUM` est déclenchée si `cible` n'est pas `gl.TEXTURE_2D`, `gl.TEXTURE_CUBE_MAP`, `gl.TEXTURE_3D`, ou `gl.TEXTURE_2D_ARRAY`.
+
+## Exemples
+
+### Liaison d'une texture
+
+```js
+var canevas = document.getElementById('canevas');
 var gl = canevas.getContext('webgl');
 var texture = gl.createTexture();
 
 gl.bindTexture(gl.TEXTURE_2D, texture);
-</pre>
+```
 
-<h3 id="Obtention_des_liaisons_en_cours">Obtention des liaisons en cours</h3>
+### Obtention des liaisons en cours
 
-<p>Pour vérifier la liaison de texture en cours, interrogez les constantes <code>gl.TEXTURE_BINDING_2D</code> ou <code>gl.TEXTURE_BINDING_CUBE_MAP</code>.</p>
+Pour vérifier la liaison de texture en cours, interrogez les constantes `gl.TEXTURE_BINDING_2D` ou `gl.TEXTURE_BINDING_CUBE_MAP`.
 
-<pre class="brush: js">gl.getParameter(gl.TEXTURE_BINDING_2D);
-</pre>
+```js
+gl.getParameter(gl.TEXTURE_BINDING_2D);
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
 <table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.8", "bindTexture")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>
-    <p>Définition initiale pour WebGL.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glBindTexture.xml", "glBindTexture")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>
-    <p>Page man de l’API OpenGL ES 2.0 (similaire).</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL2', "#3.7.1", "bindTexture")}}</td>
-   <td>{{Spec2('WebGL2')}}</td>
-   <td>Définition mise à jour pour WebGL 2.<br>
-    Ajoute : <code>gl.TEXTURE_3D</code> et  <code>gl.TEXTURE_2D_ARRAY</code></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 3.0', "glBindTexture.xhtml", "glBindTexture")}}</td>
-   <td>{{Spec2('OpenGL ES 3.0')}}</td>
-   <td>Page man de l’API OpenGL ES 3.0 (similaire).</td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <th scope="col">Spécification</th>
+      <th scope="col">Statut</th>
+      <th scope="col">Commentaire</th>
+    </tr>
+    <tr>
+      <td>{{SpecName('WebGL', "#5.14.8", "bindTexture")}}</td>
+      <td>{{Spec2('WebGL')}}</td>
+      <td><p>Définition initiale pour WebGL.</p></td>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('OpenGL ES 2.0', "glBindTexture.xml", "glBindTexture")}}
+      </td>
+      <td>{{Spec2('OpenGL ES 2.0')}}</td>
+      <td><p>Page man de l’API OpenGL ES 2.0 (similaire).</p></td>
+    </tr>
+    <tr>
+      <td>{{SpecName('WebGL2', "#3.7.1", "bindTexture")}}</td>
+      <td>{{Spec2('WebGL2')}}</td>
+      <td>
+        Définition mise à jour pour WebGL 2.<br />Ajoute :
+        <code>gl.TEXTURE_3D</code> et  <code>gl.TEXTURE_2D_ARRAY</code>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('OpenGL ES 3.0', "glBindTexture.xhtml", "glBindTexture")}}
+      </td>
+      <td>{{Spec2('OpenGL ES 3.0')}}</td>
+      <td>Page man de l’API OpenGL ES 3.0 (similaire).</td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.WebGLRenderingContext.bindTexture")}}</p>
+{{Compat("api.WebGLRenderingContext.bindTexture")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
-</ul>
+<!---->
 
-<ul>
- <li>{{domxref("WebGLRenderingContext.createTexture()")}}</li>
- <li>{{domxref("WebGLRenderingContext.deleteTexture()")}}</li>
- <li>{{domxref("WebGLRenderingContext.isTexture()")}}</li>
- <li>{{domxref("WebGLRenderingContext.texImage2D()")}}</li>
-</ul>
+- {{domxref("WebGLRenderingContext.createTexture()")}}
+- {{domxref("WebGLRenderingContext.deleteTexture()")}}
+- {{domxref("WebGLRenderingContext.isTexture()")}}
+- {{domxref("WebGLRenderingContext.texImage2D()")}}
diff --git a/files/fr/web/api/webglrenderingcontext/bufferdata/index.md b/files/fr/web/api/webglrenderingcontext/bufferdata/index.md
index e9512ad7bd..acab216dbb 100644
--- a/files/fr/web/api/webglrenderingcontext/bufferdata/index.md
+++ b/files/fr/web/api/webglrenderingcontext/bufferdata/index.md
@@ -9,153 +9,144 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/bufferData
 ---
-<div>{{APIRef("WebGL")}}</div>
-
-<p>La méthode <strong><code>WebGLRenderingContext.bufferData()</code></strong> de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> initialise et crée le magasin de données de l'objet tampon.</p>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">// WebGL1:
-void gl.bufferData(cible, taille, utilisation);
-void gl.bufferData(cible, ArrayBuffer? donneesSrc, utilisation);
-void gl.bufferData(cible, ArrayBufferView donneesSrc, utilisation);
-
-// WebGL2:
-void gl.bufferData(cible, ArrayBufferView donneesSrc, utilisation, decalageSrc, longueur);
-</pre>
-
-<h3 id="Paramètres">Paramètres</h3>
-
-<dl>
- <dt>cible</dt>
- <dd>Un {{domxref ("GLenum")}} spécifiant le point de liaison (cible). Valeurs possibles :
- <ul>
-  <li><code>gl.ARRAY_BUFFER</code> : tampon contenant des attributs de sommet, tels que des coordonnées de sommet, des données de coordonnées de texture ou des données de couleurs de sommet ;</li>
-  <li><code>gl.ELEMENT_ARRAY_BUFFER</code> : tampon utilisé pour les indices d'éléments ;</li>
-  <li>lors de l'utilisation d'un {{domxref ("WebGL2RenderingContext", "WebGL context 2", "", 1)}}, les valeurs suivantes sont en outre disponibles :
-   <ul>
-    <li><code>gl.COPY_READ_BUFFER</code> : tampon pour la copie d'un objet tampon à un autre ;</li>
-    <li><code>gl.COPY_WRITE_BUFFER</code> : tampon pour la copie d'un objet tampon à un autre ;</li>
-    <li><code>gl.TRANSFORM_FEEDBACK_BUFFER</code> : tampon pour les opérations de retour de transformation ;</li>
-    <li><code>gl.UNIFORM_BUFFER</code> : tampon utilisé pour stocker des blocs uniform ;</li>
-    <li><code>gl.PIXEL_PACK_BUFFER</code> : tampon utilisé pour les opérations de transfert de pixels ;</li>
-    <li><code>gl.PIXEL_UNPACK_BUFFER</code> : tampon utilisé pour les opérations de transfert de pixels.</li>
-   </ul>
-  </li>
- </ul>
- </dd>
- <dt>taille</dt>
- <dd>Un {{domxref("GLsizeiptr")}} définissant la taille du magasin de données de l'objet tampon.</dd>
- <dt>donneesSrc {{optional_inline}}</dt>
- <dd>Un {{jsxref("ArrayBuffer")}}, {{jsxref("SharedArrayBuffer")}} ou l'un des types de tableau typés {{domxref("ArrayBufferView")}} à copier dans le magasin de données. Si <code>null</code>, un magasin de données est quand même créé, mais son contenu n'est ni initialisé, ni défini.</dd>
- <dt>utilisation</dt>
- <dd>Un {{domxref("GLenum")}} indiquant le modèle d'utilisation du magasin de données. Valeurs possibles :
- <ul>
-  <li><code>gl.STATIC_DRAW</code> : le contenu du tampon est susceptible d'être utilisé souvent mais de ne pas changer souvent ; du contenu est écrit dans le tampon, mais non lu ;</li>
-  <li><code>gl.DYNAMIC_DRAW</code> : le contenu du tampon est susceptible d'être souvent utilisé et de changer souvent ; du contenu est écrit dans le tampon, mais non lu ;</li>
-  <li><code>gl.STREAM_DRAW</code> : le contenu du tampon est susceptible de ne pas être utilisé souvent ; du contenu est écrit dans le tampon, mais non lu ;</li>
-  <li>lors de l'utilisation d'un {{domxref("WebGL2RenderingContext", "WebGL 2 context", "", 1)}}, les valeurs suivantes the following values sont en outre disponibles :
-   <ul>
-    <li><code>gl.STATIC_READ</code> : le contenu du tampon est susceptible d'être utilisé souvent et de ne pas changer souvent ; du contenu est lu depuis le tampon, mais non écrit ;</li>
-    <li><code>gl.DYNAMIC_READ</code> : le contenu du tampon est susceptible d'être utilisé souvent et de changer souvent ; du contenu est lu depuis le tampon, mais non écrit ;</li>
-    <li><code>gl.STREAM_READ</code> : le contenu du tampon est susceptible de ne pas être utilisé souvent ; du contenu est lu depuis le tampon, mais non écrit ;</li>
-    <li><code>gl.STATIC_COPY</code> : le contenu du tampon est susceptible d'être utilisé souvent et de ne pas changer souvent ; aucun contenu n'est écrit ou lu par l'utilisateur ;</li>
-    <li><code>gl.DYNAMIC_COPY</code> : le contenu du tampon est susceptible d'être utilisé souvent et de changer souvent ; aucun contenu n'est écrit ou lu par l'utilisateur ;</li>
-    <li><code>gl.STREAM_COPY</code> : le contenu du tampon est susceptible d'être utilisé souvent et de ne pas changer souvent ; aucun contenu n'est écrit ou lu par l'utilisateur.</li>
-   </ul>
-  </li>
- </ul>
- </dd>
- <dt>decalageSrc</dt>
- <dd>Un {{domxref("GLuint")}} indiquant le décalage d'indice d'élément où commencer à lire dans le tampon.</dd>
- <dt><code>longueur</code> {{optional_inline}}</dt>
- <dd>Un {{domxref("GLuint")}} valant 0 par défaut.</dd>
-</dl>
-
-<h3 id="Valeur_retournée">Valeur retournée</h3>
-
-<p>Aucune.</p>
-
-<h3 id="Exceptions">Exceptions</h3>
-
-<ul>
- <li>Une erreur <code>gl.OUT_OF_MEMORY</code> est déclenchée si le contexte ne peut pas créer un magasin de données de la <code>taille</code> indiquée.</li>
- <li>Une erreur<code>gl.INVALID_VALUE</code> est déclenchée si <code>taille</code> est négative.</li>
- <li>Une erreur <code>gl.INVALID_ENUM</code> est déclenchée si <code>cible</code> ou<code>utilisation</code> ne sont pas l'un des enums autorisés.</li>
-</ul>
-
-<h2 id="Exemples">Exemples</h2>
-
-<h3 id="Utilisation_de_bufferData">Utilisation de <code>bufferData</code></h3>
-
-<pre class="brush: js">var canevas = document.getElementById('canevas');
+{{APIRef("WebGL")}}
+
+La méthode **`WebGLRenderingContext.bufferData()`** de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API) initialise et crée le magasin de données de l'objet tampon.
+
+## Syntaxe
+
+    // WebGL1:
+    void gl.bufferData(cible, taille, utilisation);
+    void gl.bufferData(cible, ArrayBuffer? donneesSrc, utilisation);
+    void gl.bufferData(cible, ArrayBufferView donneesSrc, utilisation);
+
+    // WebGL2:
+    void gl.bufferData(cible, ArrayBufferView donneesSrc, utilisation, decalageSrc, longueur);
+
+### Paramètres
+
+- cible
+
+  - : Un {{domxref ("GLenum")}} spécifiant le point de liaison (cible). Valeurs possibles :
+
+    - `gl.ARRAY_BUFFER` : tampon contenant des attributs de sommet, tels que des coordonnées de sommet, 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 {{domxref ("WebGL2RenderingContext", "WebGL context 2", "", 1)}}, les valeurs suivantes sont en outre disponibles :
+
+      - `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 transformation ;
+      - `gl.UNIFORM_BUFFER` : tampon utilisé pour stocker des blocs uniform ;
+      - `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.
+
+- taille
+  - : Un {{domxref("GLsizeiptr")}} définissant la taille du magasin de données de l'objet tampon.
+- donneesSrc {{optional_inline}}
+  - : Un {{jsxref("ArrayBuffer")}}, {{jsxref("SharedArrayBuffer")}} ou l'un des types de tableau typés {{domxref("ArrayBufferView")}} à copier dans le magasin de données. Si `null`, un magasin de données est quand même créé, mais son contenu n'est ni initialisé, ni défini.
+- utilisation
+
+  - : Un {{domxref("GLenum")}} indiquant le modèle d'utilisation du magasin de données. Valeurs possibles :
+
+    - `gl.STATIC_DRAW` : le contenu du tampon est susceptible d'être utilisé souvent mais de ne pas changer souvent ; du contenu est écrit dans le tampon, mais non lu ;
+    - `gl.DYNAMIC_DRAW` : le contenu du tampon est susceptible d'être souvent utilisé et de changer souvent ; du contenu est écrit dans le tampon, mais non lu ;
+    - `gl.STREAM_DRAW` : le contenu du tampon est susceptible de ne pas être utilisé souvent ; du contenu est écrit dans le tampon, mais non lu ;
+    - lors de l'utilisation d'un {{domxref("WebGL2RenderingContext", "WebGL 2 context", "", 1)}}, les valeurs suivantes the following values sont en outre disponibles :
+
+      - `gl.STATIC_READ` : le contenu du tampon est susceptible d'être utilisé souvent et de ne pas changer souvent ; du contenu est lu depuis le tampon, mais non écrit ;
+      - `gl.DYNAMIC_READ` : le contenu du tampon est susceptible d'être utilisé souvent et de changer souvent ; du contenu est lu depuis le tampon, mais non écrit ;
+      - `gl.STREAM_READ` : le contenu du tampon est susceptible de ne pas être utilisé souvent ; du contenu est lu depuis le tampon, mais non écrit ;
+      - `gl.STATIC_COPY` : le contenu du tampon est susceptible d'être utilisé souvent et de ne pas changer souvent ; aucun contenu n'est écrit ou lu par l'utilisateur ;
+      - `gl.DYNAMIC_COPY` : le contenu du tampon est susceptible d'être utilisé souvent et de changer souvent ; aucun contenu n'est écrit ou lu par l'utilisateur ;
+      - `gl.STREAM_COPY` : le contenu du tampon est susceptible d'être utilisé souvent et de ne pas changer souvent ; aucun contenu n'est écrit ou lu par l'utilisateur.
+
+- decalageSrc
+  - : Un {{domxref("GLuint")}} indiquant le décalage d'indice d'élément où commencer à lire dans le tampon.
+- `longueur` {{optional_inline}}
+  - : Un {{domxref("GLuint")}} valant 0 par défaut.
+
+### Valeur retournée
+
+Aucune.
+
+### Exceptions
+
+- Une erreur `gl.OUT_OF_MEMORY` est déclenchée si le contexte ne peut pas créer un magasin de données de la `taille` indiquée.
+- Une erreur`gl.INVALID_VALUE` est déclenchée si `taille` est négative.
+- Une erreur `gl.INVALID_ENUM` est déclenchée si `cible` ou`utilisation` ne sont pas l'un des enums autorisés.
+
+## Exemples
+
+### Utilisation de `bufferData`
+
+```js
+var canevas = document.getElementById('canevas');
 var gl = canevas.getContext('webgl');
 var tampon = gl.createBuffer();
 gl.bindBuffer(gl.ARRAY_BUFFER, tampon);
 gl.bufferData(gl.ARRAY_BUFFER, 1024, gl.STATIC_DRAW);
-</pre>
+```
 
-<h3 id="Récupération_de_l'information_de_tampon">Récupération de l'information de tampon</h3>
+### Récupération de l'information de tampon
 
-<p>Pour vérifier l'utilisation du tampon en cours et la taille du tampon, utiliser la méthode {{domxref("WebGLRenderingContext.getBufferParameter()")}}.</p>
+Pour vérifier l'utilisation du tampon en cours et la taille du tampon, utiliser la méthode {{domxref("WebGLRenderingContext.getBufferParameter()")}}.
 
-<pre class="brush: js">gl.getBufferParameter(gl.ARRAY_BUFFER, gl.BUFFER_SIZE);
+```js
+gl.getBufferParameter(gl.ARRAY_BUFFER, gl.BUFFER_SIZE);
 gl.getBufferParameter(gl.ARRAY_BUFFER, gl.BUFFER_USAGE);
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
 <table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.5", "bufferData")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glBufferData.xml", "glBufferData")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>
-    <p>Page man de l’API OpenGL.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 3.0', "glBufferData.xhtml", "glBufferData")}}</td>
-   <td>{{Spec2('OpenGL ES 3.0')}}</td>
-   <td>
-    <p>Page man de l’API OpenGL ES 3 (similaire).</p>
-    Ajoute les noouveaux tampons <code>cible</code> :<br>
-    <code>gl.COPY_READ_BUFFER</code>,<br>
-    <code>gl.COPY_WRITE_BUFFER</code>,<br>
-    <code>gl.TRANSFORM_FEEDBACK_BUFFER</code>,<br>
-    <code>gl.UNIFORM_BUFFER</code>,<br>
-    <code>gl.PIXEL_PACK_BUFFER</code>,<br>
-    <code>gl.PIXEL_UNPACK_BUFFER</code><br>
-    <br>
-    Ajoute les nouvelles indications d'<code>utilisation</code> :<br>
-    <code>gl.STATIC_READ</code>,<br>
-    <code>gl.DYNAMIC_READ</code>,<br>
-    <code>gl.STREAM_READ</code>,<br>
-    <code>gl.STATIC_COPY</code>,<br>
-    <code>gl.DYNAMIC_COPY</code>,<br>
-    <code>gl.STREAM_COPY</code>.</td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <th scope="col">Spécification</th>
+      <th scope="col">Statut</th>
+      <th scope="col">Commentaire</th>
+    </tr>
+    <tr>
+      <td>{{SpecName('WebGL', "#5.14.5", "bufferData")}}</td>
+      <td>{{Spec2('WebGL')}}</td>
+      <td>Définition initiale.</td>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('OpenGL ES 2.0', "glBufferData.xml", "glBufferData")}}
+      </td>
+      <td>{{Spec2('OpenGL ES 2.0')}}</td>
+      <td><p>Page man de l’API OpenGL.</p></td>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('OpenGL ES 3.0', "glBufferData.xhtml", "glBufferData")}}
+      </td>
+      <td>{{Spec2('OpenGL ES 3.0')}}</td>
+      <td>
+        <p>Page man de l’API OpenGL ES 3 (similaire).</p>
+        Ajoute les noouveaux tampons <code>cible</code> :<br /><code
+          >gl.COPY_READ_BUFFER</code
+        >,<br /><code>gl.COPY_WRITE_BUFFER</code>,<br /><code
+          >gl.TRANSFORM_FEEDBACK_BUFFER</code
+        >,<br /><code>gl.UNIFORM_BUFFER</code>,<br /><code
+          >gl.PIXEL_PACK_BUFFER</code
+        >,<br /><code>gl.PIXEL_UNPACK_BUFFER</code><br /><br />Ajoute les
+        nouvelles indications d'<code>utilisation</code> :<br /><code
+          >gl.STATIC_READ</code
+        >,<br /><code>gl.DYNAMIC_READ</code>,<br /><code>gl.STREAM_READ</code
+        >,<br /><code>gl.STATIC_COPY</code>,<br /><code>gl.DYNAMIC_COPY</code
+        >,<br /><code>gl.STREAM_COPY</code>.
+      </td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.WebGLRenderingContext.bufferData")}}</p>
+{{Compat("api.WebGLRenderingContext.bufferData")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{domxref("WebGLRenderingContext.createBuffer()")}}</li>
- <li>{{domxref("WebGLRenderingContext.bufferSubData()")}}</li>
- <li>Autres tampons : {{domxref("WebGLFramebuffer")}}, {{domxref("WebGLRenderbuffer")}}</li>
-</ul>
+- {{domxref("WebGLRenderingContext.createBuffer()")}}
+- {{domxref("WebGLRenderingContext.bufferSubData()")}}
+- Autres tampons : {{domxref("WebGLFramebuffer")}}, {{domxref("WebGLRenderbuffer")}}
diff --git a/files/fr/web/api/webglrenderingcontext/canvas/index.md b/files/fr/web/api/webglrenderingcontext/canvas/index.md
index ccdfa7ed8a..e6d36646bd 100644
--- a/files/fr/web/api/webglrenderingcontext/canvas/index.md
+++ b/files/fr/web/api/webglrenderingcontext/canvas/index.md
@@ -9,66 +9,57 @@ tags:
 translation_of: Web/API/WebGLRenderingContext/canvas
 original_slug: Web/API/WebGLRenderingContext/canevas
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La propriété <code>WebGLRenderingContext.canvas</code> est une référence en lecture seule à l'objet {{domxref("HTMLCanvasElement")}} ou {{domxref("OffscreenCanvas")}} associé au contexte. Il peut s'agir de {{jsxref("null")}} s'il n'est pas associé à un élément {{HTMLElement("canvas")}} ou à un objet {{domxref("OffscreenCanvas")}}.</p>
+La propriété `WebGLRenderingContext.canvas` est une référence en lecture seule à l'objet {{domxref("HTMLCanvasElement")}} ou {{domxref("OffscreenCanvas")}} associé au contexte. Il peut s'agir de {{jsxref("null")}} s'il n'est pas associé à un élément {{HTMLElement("canvas")}} ou à un objet {{domxref("OffscreenCanvas")}}.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var><em>gl</em></var>.canvas;</pre>
+    gl.canvas;
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+### Valeur retournée
 
-<p>Soit un objet {{domxref("HTMLCanvasElement")}} ou {{domxref("OffscreenCanvas")}}, soit {{jsxref("null")}}.</p>
+Soit un objet {{domxref("HTMLCanvasElement")}} ou {{domxref("OffscreenCanvas")}}, soit {{jsxref("null")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Élément_canevas">Élément canevas</h3>
+### Élément canevas
 
-<p>Étant donné cet élément {{HTMLElement("canvas")}} :</p>
+Étant donné cet élément {{HTMLElement("canvas")}} :
 
-<pre class="brush: html">&lt;canvas id="canevas"&gt;&lt;/canvas&gt;
-</pre>
+```html
+<canvas id="canevas"></canvas>
+```
 
-<p>Vous pouvez en récupérer une référence à partir du <code>WebGLRenderingContext</code> en utilisant la propriété <code>canvas</code> :</p>
+Vous pouvez en récupérer une référence à partir du `WebGLRenderingContext` en utilisant la propriété `canvas` :
 
-<pre class="brush: js">var canevas = document.getElementById('canevas');
+```js
+var canevas = document.getElementById('canevas');
 var gl = canevas.getContext('webgl');
 gl.canvas; // HTMLCanvasElement
-</pre>
+```
 
-<h3 id="Canevas_hors_écran">Canevas hors écran</h3>
+### Canevas hors écran
 
-<p>Exemple d'utilisation de l'objet expérimental {{domxref("OffscreenCanvas")}}.</p>
+Exemple d'utilisation de l'objet expérimental {{domxref("OffscreenCanvas")}}.
 
-<pre class="brush: js">var horsEcran = new OffscreenCanvas(256, 256);
+```js
+var horsEcran = new OffscreenCanvas(256, 256);
 var gl = horsEcran.getContext('webgl');
-gl.canvas; // OffscreenCanvas</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#DOM-WebGLRenderingContext-canvas", "WebGLRenderingContext.canvas")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.WebGLRenderingContext.canvas")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("CanvasRenderingContext2D.canvas")}}</li>
- <li>{{domxref("OffscreenCanvas")}}</li>
-</ul>
+gl.canvas; // OffscreenCanvas
+```
+
+## Spécifications
+
+| Spécification                                                                                                            | Statut                   | Commentaire          |
+| ------------------------------------------------------------------------------------------------------------------------ | ------------------------ | -------------------- |
+| {{SpecName('WebGL', "#DOM-WebGLRenderingContext-canvas", "WebGLRenderingContext.canvas")}} | {{Spec2('WebGL')}} | Définition initiale. |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.WebGLRenderingContext.canvas")}}
+
+## Voir aussi
+
+- {{domxref("CanvasRenderingContext2D.canvas")}}
+- {{domxref("OffscreenCanvas")}}
diff --git a/files/fr/web/api/webglrenderingcontext/clear/index.md b/files/fr/web/api/webglrenderingcontext/clear/index.md
index 69acd2f1d1..803a50fd26 100644
--- a/files/fr/web/api/webglrenderingcontext/clear/index.md
+++ b/files/fr/web/api/webglrenderingcontext/clear/index.md
@@ -9,85 +9,66 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/clear
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La méthode <strong><code>WebGLRenderingContext.clear()</code></strong> de <a href="/fr/docs/Web/API/WebGL_API">l'API WebGL</a> efface les tampons avec des valeurs prédéfinies.</p>
+La méthode **`WebGLRenderingContext.clear()`** de [l'API WebGL](/fr/docs/Web/API/WebGL_API) efface les tampons avec des valeurs prédéfinies.
 
-<p>Ces valeurs prédéfinies peuvent être affectées par {{domxref("WebGLRenderingContext.clearColor", "clearColor()")}}, {{domxref("WebGLRenderingContext.clearDepth", "clearDepth()")}} ou {{domxref("WebGLRenderingContext.clearStencil", "clearStencil()")}}.</p>
+Ces valeurs prédéfinies peuvent être affectées par {{domxref("WebGLRenderingContext.clearColor", "clearColor()")}}, {{domxref("WebGLRenderingContext.clearDepth", "clearDepth()")}} ou {{domxref("WebGLRenderingContext.clearStencil", "clearStencil()")}}.
 
-<p>Les masques d'écriture, de détourage, de tramage et de tampon peuvent affecter la méthode <code>clear()</code>.</p>
+Les masques d'écriture, de détourage, de tramage et de tampon peuvent affecter la méthode `clear()`.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">void <var>gl</var>.clear(<var>masque</var>);
-</pre>
+    void gl.clear(masque);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>masque</code></dt>
- <dd>Un masque OU par bits {{domxref("GLbitfield")}} qui indique les tampons à effacer. Les valeurs possibles sont :
- <ul>
-  <li><code>gl.COLOR_BUFFER_BIT</code></li>
-  <li><code>gl.DEPTH_BUFFER_BIT</code></li>
-  <li><code>gl.STENCIL_BUFFER_BIT</code></li>
- </ul>
- </dd>
-</dl>
+- `masque`
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+  - : Un masque OU par bits {{domxref("GLbitfield")}} qui indique les tampons à effacer. Les valeurs possibles sont :
 
-<p>Aucune.</p>
+    - `gl.COLOR_BUFFER_BIT`
+    - `gl.DEPTH_BUFFER_BIT`
+    - `gl.STENCIL_BUFFER_BIT`
 
-<h3 id="Exceptions">Exceptions</h3>
+### Valeur retournée
 
-<p>Si <em>masque</em> n'est pas l'une des valeurs possibles listées, une erreur <code>gl.INVALID_ENUM</code> est déclenchée.</p>
+Aucune.
 
-<h2 id="Exemples">Exemples</h2>
+### Exceptions
 
-<p>La méthode <code>clear()</code> accepte des valeurs multiples.</p>
+Si *masque* n'est pas l'une des valeurs possibles listées, une erreur `gl.INVALID_ENUM` est déclenchée.
 
-<pre class="brush: js">gl.clear(gl.DEPTH_BUFFER_BIT);
+## 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);
-</pre>
+```
 
-<p>Pour obtenir les valeurs d'effacement courantes, interrogez les constantes <code>COLOR_CLEAR_VALUE</code>, <code>DEPTH_CLEAR_VALUE</code> et <code>STENCIL_CLEAR_VALUE</code> grâce à la méthode <code>getParameter()</code>.</p>
+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()`.
 
-<pre class="brush: js">gl.getParameter(gl.COLOR_CLEAR_VALUE);
+```js
+gl.getParameter(gl.COLOR_CLEAR_VALUE);
 gl.getParameter(gl.DEPTH_CLEAR_VALUE);
 gl.getParameter(gl.STENCIL_CLEAR_VALUE);
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.11", "clear")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glClear.xml", "glClear")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man de l'API OpenGL.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.WebGLRenderingContext.clear")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("WebGLRenderingContext.clearColor()")}}</li>
- <li>{{domxref("WebGLRenderingContext.clearDepth()")}}</li>
- <li>{{domxref("WebGLRenderingContext.clearStencil()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                            | Statut                               | Commentaire               |
+| ------------------------------------------------------------------------ | ------------------------------------ | ------------------------- |
+| {{SpecName('WebGL', "#5.14.11", "clear")}}                 | {{Spec2('WebGL')}}             | Définition initiale.      |
+| {{SpecName('OpenGL ES 2.0', "glClear.xml", "glClear")}} | {{Spec2('OpenGL ES 2.0')}} | Page man de l'API OpenGL. |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.WebGLRenderingContext.clear")}}
+
+## Voir aussi
+
+- {{domxref("WebGLRenderingContext.clearColor()")}}
+- {{domxref("WebGLRenderingContext.clearDepth()")}}
+- {{domxref("WebGLRenderingContext.clearStencil()")}}
diff --git a/files/fr/web/api/webglrenderingcontext/compileshader/index.md b/files/fr/web/api/webglrenderingcontext/compileshader/index.md
index 4727567959..e0334e3e36 100644
--- a/files/fr/web/api/webglrenderingcontext/compileshader/index.md
+++ b/files/fr/web/api/webglrenderingcontext/compileshader/index.md
@@ -9,77 +9,58 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/compileShader
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La méthode <strong>WebGLRenderingContext.compileShader()</strong> de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> compile un shader GLSL en données binaires, de sorte qu'il puisse être utilisé par un {{domxref("WebGLProgram")}}.</p>
+La méthode **WebGLRenderingContext.compileShader()** de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API) compile un shader GLSL en données binaires, de sorte qu'il puisse être utilisé par un {{domxref("WebGLProgram")}}.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">void <var><em>gl</em>.compileShader</var><var>(shader);</var>
-</pre>
+    void gl.compileShader(shader);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>shader</code></dt>
- <dd>Un {{domxref("WebGLShader")}} de fragments ou de sommets.</dd>
-</dl>
+- `shader`
+  - : Un {{domxref("WebGLShader")}} de fragments ou de sommets.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">var shader = gl.createShader(gl.VERTEX_SHADER);
+```js
+var shader = gl.createShader(gl.VERTEX_SHADER);
 gl.shaderSource(shader, sourceShader);
 gl.compileShader(shader);
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.9", "compileShader")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glCompileShader.xml", "glCompileShader")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man OpenGL.</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                    | Statut                               | Commentaire          |
+| ------------------------------------------------------------------------------------------------ | ------------------------------------ | -------------------- |
+| {{SpecName('WebGL', "#5.14.9", "compileShader")}}                                 | {{Spec2('WebGL')}}             | Définition initiale. |
+| {{SpecName('OpenGL ES 2.0', "glCompileShader.xml", "glCompileShader")}} | {{Spec2('OpenGL ES 2.0')}} | Page man OpenGL.     |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.WebGLRenderingContext.compileShader")}}</p>
+{{Compat("api.WebGLRenderingContext.compileShader")}}
 
-<h2 id="Voire_aussi">Voire aussi</h2>
+## Voire aussi
 
-<ul>
- <li>{{domxref("WebGLProgram")}}</li>
- <li>{{domxref("WebGLShader")}}</li>
- <li>{{domxref("WebGLRenderingContext.attachShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.createProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.createShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.deleteProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.deleteShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.detachShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getAttachedShaders()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getProgramParameter()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getProgramInfoLog()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getShaderParameter()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getShaderPrecisionFormat()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getShaderInfoLog()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getShaderSource()")}}</li>
- <li>{{domxref("WebGLRenderingContext.isProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.isShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.linkProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.shaderSource()")}}</li>
- <li>{{domxref("WebGLRenderingContext.useProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.validateProgram()")}}</li>
-</ul>
+- {{domxref("WebGLProgram")}}
+- {{domxref("WebGLShader")}}
+- {{domxref("WebGLRenderingContext.attachShader()")}}
+- {{domxref("WebGLRenderingContext.createProgram()")}}
+- {{domxref("WebGLRenderingContext.createShader()")}}
+- {{domxref("WebGLRenderingContext.deleteProgram()")}}
+- {{domxref("WebGLRenderingContext.deleteShader()")}}
+- {{domxref("WebGLRenderingContext.detachShader()")}}
+- {{domxref("WebGLRenderingContext.getAttachedShaders()")}}
+- {{domxref("WebGLRenderingContext.getProgramParameter()")}}
+- {{domxref("WebGLRenderingContext.getProgramInfoLog()")}}
+- {{domxref("WebGLRenderingContext.getShaderParameter()")}}
+- {{domxref("WebGLRenderingContext.getShaderPrecisionFormat()")}}
+- {{domxref("WebGLRenderingContext.getShaderInfoLog()")}}
+- {{domxref("WebGLRenderingContext.getShaderSource()")}}
+- {{domxref("WebGLRenderingContext.isProgram()")}}
+- {{domxref("WebGLRenderingContext.isShader()")}}
+- {{domxref("WebGLRenderingContext.linkProgram()")}}
+- {{domxref("WebGLRenderingContext.shaderSource()")}}
+- {{domxref("WebGLRenderingContext.useProgram()")}}
+- {{domxref("WebGLRenderingContext.validateProgram()")}}
diff --git a/files/fr/web/api/webglrenderingcontext/createbuffer/index.md b/files/fr/web/api/webglrenderingcontext/createbuffer/index.md
index 6970f50070..e40ea5f601 100644
--- a/files/fr/web/api/webglrenderingcontext/createbuffer/index.md
+++ b/files/fr/web/api/webglrenderingcontext/createbuffer/index.md
@@ -9,67 +9,63 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/createBuffer
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La méthode <strong><code>WebGLRenderingContext.createBuffer() </code></strong>de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> crée et initialise un {{domxref ("WebGLBuffer")}} stockant des données telles que des sommets ou des couleurs.</p>
+La méthode **`WebGLRenderingContext.createBuffer() `**de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API) crée et initialise un {{domxref ("WebGLBuffer")}} stockant des données telles que des sommets ou des couleurs.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">WebGLBuffer <var>gl</var>.createBuffer();
-</pre>
+    WebGLBuffer gl.createBuffer();
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<p>Aucun.</p>
+Aucun.
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+### Valeur retournée
 
-<p>Un {{domxref("WebGLBuffer")}} stockant des données telles que des sommets ou des couleurs.</p>
+Un {{domxref("WebGLBuffer")}} stockant des données telles que des sommets ou des couleurs.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Création_d'un_tampon">Création d'un tampon</h3>
+### Création d'un tampon
 
-<pre class="brush: js">var canevas = document.getElementById('canevas');
+```js
+var canevas = document.getElementById('canevas');
 var gl = canevas.getContext('webgl');
 var tampon = gl.createBuffer();
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
 <table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.5", "createBuffer")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>
-    <p>Définition initiale.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glGenBuffers.xml", "glGenBuffers")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>
-    <p>Page man de l’API OpenGL (similaire).</p>
-   </td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <th scope="col">Spécification</th>
+      <th scope="col">Statut</th>
+      <th scope="col">Commentaire</th>
+    </tr>
+    <tr>
+      <td>{{SpecName('WebGL', "#5.14.5", "createBuffer")}}</td>
+      <td>{{Spec2('WebGL')}}</td>
+      <td><p>Définition initiale.</p></td>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('OpenGL ES 2.0', "glGenBuffers.xml", "glGenBuffers")}}
+      </td>
+      <td>{{Spec2('OpenGL ES 2.0')}}</td>
+      <td><p>Page man de l’API OpenGL (similaire).</p></td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.WebGLRenderingContext.createBuffer")}}</p>
+{{Compat("api.WebGLRenderingContext.createBuffer")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{domxref("WebGLRenderingContext.bindBuffer()")}}</li>
- <li>{{domxref("WebGLRenderingContext.deleteBuffer()")}}</li>
- <li>{{domxref("WebGLRenderingContext.isBuffer()")}}</li>
- <li>Autres tampons : {{domxref("WebGLFramebuffer")}}, {{domxref("WebGLRenderbuffer")}}</li>
-</ul>
+- {{domxref("WebGLRenderingContext.bindBuffer()")}}
+- {{domxref("WebGLRenderingContext.deleteBuffer()")}}
+- {{domxref("WebGLRenderingContext.isBuffer()")}}
+- Autres tampons : {{domxref("WebGLFramebuffer")}}, {{domxref("WebGLRenderbuffer")}}
diff --git a/files/fr/web/api/webglrenderingcontext/createprogram/index.md b/files/fr/web/api/webglrenderingcontext/createprogram/index.md
index 4b59a8b581..cf6ce1d9b9 100644
--- a/files/fr/web/api/webglrenderingcontext/createprogram/index.md
+++ b/files/fr/web/api/webglrenderingcontext/createprogram/index.md
@@ -9,28 +9,28 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/createProgram
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La méthode <code><strong>WebGLRenderingContext.createProgram()</strong></code> de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> crée et initialise un objet {{domxref("WebGLProgram")}}.</p>
+La méthode **`WebGLRenderingContext.createProgram()`** de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API) crée et initialise un objet {{domxref("WebGLProgram")}}.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">WebGLProgram <var>gl</var>.createProgram();
-</pre>
+    WebGLProgram gl.createProgram();
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<p>Aucun.</p>
+Aucun.
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+### Valeur retournée
 
-<p>Un objet {{domxref("WebGLProgram")}} qui est une combinaison de deux {{domxref("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.</p>
+Un objet {{domxref("WebGLProgram")}} qui est une combinaison de deux {{domxref("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.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Création_d'un_programme_WebGL">Création d'un programme WebGL</h3>
+### Création d'un programme WebGL
 
-<pre class="brush: js">var programme = gl.createProgram();
+```js
+var programme = gl.createProgram();
 
 // Attacher les shaders pré-existants
 gl.attachShader(programme, shaderDeSommet);
@@ -42,44 +42,27 @@ if ( !gl.getProgramParameter( programme, gl.LINK_STATUS) ) {
   var info = gl.getProgramInfoLog(program);
   throw 'Impossible de compiler le programme WebGL. \n\n' + info;
 }
-</pre>
-
-<p>Voir {{domxref ("WebGLShader")}} pour plus d'informations sur la création du <code>shaderDeSommet</code> et du <code>shaderDeFragment</code> dans l'exemple ci-dessus.</p>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.9", "createProgram")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glCreateProgram.xml", "glCreateProgram")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man de l'API OpenGL (similaire).</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.WebGLRenderingContext.createProgram")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("WebGLRenderingContext.deleteProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.isProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.linkProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.useProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.validateProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getProgramParameter()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getProgramInfoLog()")}}</li>
-</ul>
+```
+
+Voir {{domxref ("WebGLShader")}} pour plus d'informations sur la création du `shaderDeSommet` et du `shaderDeFragment` dans l'exemple ci-dessus.
+
+## Spécifications
+
+| Spécification                                                                                    | Statut                               | Commentaire                           |
+| ------------------------------------------------------------------------------------------------ | ------------------------------------ | ------------------------------------- |
+| {{SpecName('WebGL', "#5.14.9", "createProgram")}}                                 | {{Spec2('WebGL')}}             | Définition initiale.                  |
+| {{SpecName('OpenGL ES 2.0', "glCreateProgram.xml", "glCreateProgram")}} | {{Spec2('OpenGL ES 2.0')}} | Page man de l'API OpenGL (similaire). |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.WebGLRenderingContext.createProgram")}}
+
+## Voir aussi
+
+- {{domxref("WebGLRenderingContext.deleteProgram()")}}
+- {{domxref("WebGLRenderingContext.isProgram()")}}
+- {{domxref("WebGLRenderingContext.linkProgram()")}}
+- {{domxref("WebGLRenderingContext.useProgram()")}}
+- {{domxref("WebGLRenderingContext.validateProgram()")}}
+- {{domxref("WebGLRenderingContext.getProgramParameter()")}}
+- {{domxref("WebGLRenderingContext.getProgramInfoLog()")}}
diff --git a/files/fr/web/api/webglrenderingcontext/createshader/index.md b/files/fr/web/api/webglrenderingcontext/createshader/index.md
index d67f27443d..a2e973949c 100644
--- a/files/fr/web/api/webglrenderingcontext/createshader/index.md
+++ b/files/fr/web/api/webglrenderingcontext/createshader/index.md
@@ -10,76 +10,56 @@ tags:
   - WebGL
 translation_of: Web/API/WebGLRenderingContext/createShader
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La méthode <strong>WebGLRenderingContext.createShader() de l'</strong><a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> crée un {{domxref("WebGLShader")}}, qui peut alors être configuré davantage en utilisant {{domxref("WebGLRenderingContext.shaderSource()")}} et {{domxref("WebGLRenderingContext.compileShader()")}}.</p>
+La méthode **WebGLRenderingContext.createShader() de l'**[API WebGL](/fr-FR/docs/Web/API/WebGL_API) crée un {{domxref("WebGLShader")}}, qui peut alors être configuré davantage en utilisant {{domxref("WebGLRenderingContext.shaderSource()")}} et {{domxref("WebGLRenderingContext.compileShader()")}}.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">WebGLShader <var><em>gl</em>.</var>createShader<var>(type);</var>
-</pre>
+    WebGLShader gl.createShader(type);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>type</code></dt>
- <dd>Soit <code>gl.VERTEX_SHADER</code>, soit <code>gl.FRAGMENT_SHADER</code></dd>
-</dl>
+- `type`
+  - : Soit `gl.VERTEX_SHADER`, soit `gl.FRAGMENT_SHADER`
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Voir {{domxref("WebGLShader")}} pour l'utilisation et des exemples.</p>
+Voir {{domxref("WebGLShader")}} pour l'utilisation et des exemples.
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.9", "createShader")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glCreateShader.xml", "glCreateShader")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man OpenGL.</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                | Statut                               | Commentaire          |
+| -------------------------------------------------------------------------------------------- | ------------------------------------ | -------------------- |
+| {{SpecName('WebGL', "#5.14.9", "createShader")}}                             | {{Spec2('WebGL')}}             | Définition initiale. |
+| {{SpecName('OpenGL ES 2.0', "glCreateShader.xml", "glCreateShader")}} | {{Spec2('OpenGL ES 2.0')}} | Page man OpenGL.     |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.WebGLRenderingContext.createShader")}}</p>
+{{Compat("api.WebGLRenderingContext.createShader")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{domxref("WebGLProgram")}}</li>
- <li>{{domxref("WebGLShader")}}</li>
- <li>{{domxref("WebGLRenderingContext.attachShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.bindAttribLocation()")}}</li>
- <li>{{domxref("WebGLRenderingContext.compileShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.createProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.createShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.deleteProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.deleteShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.detachShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getAttachedShaders()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getProgramParameter()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getProgramInfoLog()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getShaderParameter()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getShaderPrecisionFormat()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getShaderInfoLog()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getShaderSource()")}}</li>
- <li>{{domxref("WebGLRenderingContext.isProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.isShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.linkProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.shaderSource()")}}</li>
- <li>{{domxref("WebGLRenderingContext.useProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.validateProgram()")}}</li>
-</ul>
+- {{domxref("WebGLProgram")}}
+- {{domxref("WebGLShader")}}
+- {{domxref("WebGLRenderingContext.attachShader()")}}
+- {{domxref("WebGLRenderingContext.bindAttribLocation()")}}
+- {{domxref("WebGLRenderingContext.compileShader()")}}
+- {{domxref("WebGLRenderingContext.createProgram()")}}
+- {{domxref("WebGLRenderingContext.createShader()")}}
+- {{domxref("WebGLRenderingContext.deleteProgram()")}}
+- {{domxref("WebGLRenderingContext.deleteShader()")}}
+- {{domxref("WebGLRenderingContext.detachShader()")}}
+- {{domxref("WebGLRenderingContext.getAttachedShaders()")}}
+- {{domxref("WebGLRenderingContext.getProgramParameter()")}}
+- {{domxref("WebGLRenderingContext.getProgramInfoLog()")}}
+- {{domxref("WebGLRenderingContext.getShaderParameter()")}}
+- {{domxref("WebGLRenderingContext.getShaderPrecisionFormat()")}}
+- {{domxref("WebGLRenderingContext.getShaderInfoLog()")}}
+- {{domxref("WebGLRenderingContext.getShaderSource()")}}
+- {{domxref("WebGLRenderingContext.isProgram()")}}
+- {{domxref("WebGLRenderingContext.isShader()")}}
+- {{domxref("WebGLRenderingContext.linkProgram()")}}
+- {{domxref("WebGLRenderingContext.shaderSource()")}}
+- {{domxref("WebGLRenderingContext.useProgram()")}}
+- {{domxref("WebGLRenderingContext.validateProgram()")}}
diff --git a/files/fr/web/api/webglrenderingcontext/createtexture/index.md b/files/fr/web/api/webglrenderingcontext/createtexture/index.md
index 2ac9c1fd62..a073857b80 100644
--- a/files/fr/web/api/webglrenderingcontext/createtexture/index.md
+++ b/files/fr/web/api/webglrenderingcontext/createtexture/index.md
@@ -10,67 +10,65 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/createTexture
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La méthode <strong><code>WebGLRenderingContext.createTexture()</code></strong> de l'API WebGL crée et initialise un objet {{domxref("WebGLTexture")}}.</p>
+La méthode **`WebGLRenderingContext.createTexture()`** de l'API WebGL crée et initialise un objet {{domxref("WebGLTexture")}}.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">WebGLTexture <var>gl</var>.createTexture();
-</pre>
+    WebGLTexture gl.createTexture();
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<p>Aucun.</p>
+Aucun.
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+### Valeur retournée
 
-<p>Un objet {{domxref("WebGLTexture")}} auquel des images peuvent être liées.</p>
+Un objet {{domxref("WebGLTexture")}} auquel des images peuvent être liées.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Voir aussi le <a href="/fr-FR/docs/Web/API/WebGL_API/Tutorial">tutoriel WebGL</a> sur l'<a href="/fr-FR/docs/Web/API/WebGL_API/Tutorial/Using_textures_in_WebGL">Utilisation de textures en WebGL</a>.</p>
+Voir aussi le [tutoriel WebGL](/fr-FR/docs/Web/API/WebGL_API/Tutorial) sur l'[Utilisation de textures en WebGL](/fr-FR/docs/Web/API/WebGL_API/Tutorial/Using_textures_in_WebGL).
 
-<h3 id="Création_d'une_texture">Création d'une texture</h3>
+### Création d'une texture
 
-<pre class="brush: js">var canevas = document.getElementById('canevas');
+```js
+var canevas = document.getElementById('canevas');
 var gl = canevas.getContext('webgl');
 var texture = gl.createTexture();
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
 <table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.8", "createTexture")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>
-    <p>Définition initiale.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glGenTextures.xml", "glGenTextures")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man de l’API OpenGL (similaire).</td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <th scope="col">Spécification</th>
+      <th scope="col">Statut</th>
+      <th scope="col">Commentaire</th>
+    </tr>
+    <tr>
+      <td>{{SpecName('WebGL', "#5.14.8", "createTexture")}}</td>
+      <td>{{Spec2('WebGL')}}</td>
+      <td><p>Définition initiale.</p></td>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('OpenGL ES 2.0', "glGenTextures.xml", "glGenTextures")}}
+      </td>
+      <td>{{Spec2('OpenGL ES 2.0')}}</td>
+      <td>Page man de l’API OpenGL (similaire).</td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.WebGLRenderingContext.createTexture")}}</p>
+{{Compat("api.WebGLRenderingContext.createTexture")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{domxref("WebGLRenderingContext.bindTexture()")}}</li>
- <li>{{domxref("WebGLRenderingContext.deleteTexture()")}}</li>
- <li>{{domxref("WebGLRenderingContext.isTexture()")}}</li>
- <li>{{domxref("WebGLRenderingContext.texImage2D()")}}</li>
-</ul>
+- {{domxref("WebGLRenderingContext.bindTexture()")}}
+- {{domxref("WebGLRenderingContext.deleteTexture()")}}
+- {{domxref("WebGLRenderingContext.isTexture()")}}
+- {{domxref("WebGLRenderingContext.texImage2D()")}}
diff --git a/files/fr/web/api/webglrenderingcontext/deletebuffer/index.md b/files/fr/web/api/webglrenderingcontext/deletebuffer/index.md
index 561e0c77c6..47fbedaa04 100644
--- a/files/fr/web/api/webglrenderingcontext/deletebuffer/index.md
+++ b/files/fr/web/api/webglrenderingcontext/deletebuffer/index.md
@@ -9,69 +9,51 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/deleteBuffer
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La méthode <strong><code>WebGLRenderingContext.deleteBuffer()</code></strong> de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> supprime le {{domxref ("WebGLBuffer")}} indiqué. Cette méthode n'a aucun effet si le tampon a déjà été supprimé.</p>
+La méthode **`WebGLRenderingContext.deleteBuffer()`** de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API) supprime le {{domxref ("WebGLBuffer")}} indiqué. Cette méthode n'a aucun effet si le tampon a déjà été supprimé.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">void <var>gl</var>.deleteBuffer(<em>tampon</em>);
-</pre>
+    void gl.deleteBuffer(tampon);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt>tampon</dt>
- <dd>Un objet {{domxref("WebGLBuffer")}} à supprimer.</dd>
-</dl>
+- tampon
+  - : Un objet {{domxref("WebGLBuffer")}} à supprimer.
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+### Valeur retournée
 
-<p>Aucune.</p>
+Aucune.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Suppression_d'un_tampon">Suppression d'un tampon</h3>
+### Suppression d'un tampon
 
-<pre class="brush: js">var canevas = document.getElementById('canevas');
+```js
+var canevas = document.getElementById('canevas');
 var gl = canevas.getContext('webgl');
 var tampon = gl.createBuffer();
 
 // ...
 
-gl.deleteBuffer(tampon);</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.5", "deleteBuffer")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glDeleteBuffers.xml", "glDeleteBuffers")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man de l’API OpenGL (similaire).</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.WebGLRenderingContext.deleteBuffer")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("WebGLRenderingContext.bindBuffer()")}}</li>
- <li>{{domxref("WebGLRenderingContext.createBuffer()")}}</li>
- <li>{{domxref("WebGLRenderingContext.isBuffer()")}}</li>
- <li>Autres tampons : {{domxref("WebGLFramebuffer")}}, {{domxref("WebGLRenderbuffer")}}</li>
-</ul>
+gl.deleteBuffer(tampon);
+```
+
+## Spécifications
+
+| Spécification                                                                                    | Statut                               | Commentaire                           |
+| ------------------------------------------------------------------------------------------------ | ------------------------------------ | ------------------------------------- |
+| {{SpecName('WebGL', "#5.14.5", "deleteBuffer")}}                                 | {{Spec2('WebGL')}}             | Définition initiale.                  |
+| {{SpecName('OpenGL ES 2.0', "glDeleteBuffers.xml", "glDeleteBuffers")}} | {{Spec2('OpenGL ES 2.0')}} | Page man de l’API OpenGL (similaire). |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.WebGLRenderingContext.deleteBuffer")}}
+
+## Voir aussi
+
+- {{domxref("WebGLRenderingContext.bindBuffer()")}}
+- {{domxref("WebGLRenderingContext.createBuffer()")}}
+- {{domxref("WebGLRenderingContext.isBuffer()")}}
+- Autres tampons : {{domxref("WebGLFramebuffer")}}, {{domxref("WebGLRenderbuffer")}}
diff --git a/files/fr/web/api/webglrenderingcontext/deleteshader/index.md b/files/fr/web/api/webglrenderingcontext/deleteshader/index.md
index 01a62f3e7a..82f2677183 100644
--- a/files/fr/web/api/webglrenderingcontext/deleteshader/index.md
+++ b/files/fr/web/api/webglrenderingcontext/deleteshader/index.md
@@ -9,62 +9,44 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/deleteShader
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La méthode <strong><code>WebGLRenderingContext.deleteShader()</code></strong> de l'API WebGL marque l'objet {{domxref("WebGLShader")}} indiqué pour suppression. Il sera ensuite supprimé dès que le shader ne sera plus utilisé. Cette méthode n'a aucun effet si le shader a déjà été supprimé, et le {{domxref ("WebGLShader")}} est automatiquement marqué pour la suppression lorsqu'il est détruit par le garbage collector.</p>
+La méthode **`WebGLRenderingContext.deleteShader()`** de l'API WebGL marque l'objet {{domxref("WebGLShader")}} indiqué pour suppression. Il sera ensuite supprimé dès que le shader ne sera plus utilisé. Cette méthode n'a aucun effet si le shader a déjà été supprimé, et le {{domxref ("WebGLShader")}} est automatiquement marqué pour la suppression lorsqu'il est détruit par le garbage collector.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">void <var>gl</var>.deleteShader(<var>shader</var>);
-</pre>
+    void gl.deleteShader(shader);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt>shader</dt>
- <dd>Un objet {{domxref("WebGLShader")}} à détruire.</dd>
-</dl>
+- shader
+  - : Un objet {{domxref("WebGLShader")}} à détruire.
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+### Valeur retournée
 
-<p>Aucune.</p>
+Aucune.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Suppression_d'un_shader">Suppression d'un shader</h3>
+### Suppression d'un shader
 
-<pre class="brush: js">gl.deleteShader(shader);</pre>
+```js
+gl.deleteShader(shader);
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.9", "deleteShader")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glDeleteShader.xml", "glDeleteShader")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man de l'API OpenGL (similaire).</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                | Statut                               | Commentaire                           |
+| -------------------------------------------------------------------------------------------- | ------------------------------------ | ------------------------------------- |
+| {{SpecName('WebGL', "#5.14.9", "deleteShader")}}                             | {{Spec2('WebGL')}}             | Définition initiale.                  |
+| {{SpecName('OpenGL ES 2.0', "glDeleteShader.xml", "glDeleteShader")}} | {{Spec2('OpenGL ES 2.0')}} | Page man de l'API OpenGL (similaire). |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.WebGLRenderingContext.deleteShader")}}</p>
+{{Compat("api.WebGLRenderingContext.deleteShader")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{domxref("WebGLRenderingContext.createShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.isShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getAttachedShaders()")}}</li>
-</ul>
+- {{domxref("WebGLRenderingContext.createShader()")}}
+- {{domxref("WebGLRenderingContext.isShader()")}}
+- {{domxref("WebGLRenderingContext.getAttachedShaders()")}}
diff --git a/files/fr/web/api/webglrenderingcontext/drawarrays/index.md b/files/fr/web/api/webglrenderingcontext/drawarrays/index.md
index 8bdffeed97..f9d4ce2d0d 100644
--- a/files/fr/web/api/webglrenderingcontext/drawarrays/index.md
+++ b/files/fr/web/api/webglrenderingcontext/drawarrays/index.md
@@ -9,91 +9,86 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/drawArrays
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La méthode <strong><code>WebGLRenderingContext.drawArrays()</code></strong> de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> dessine des primitives à partir de données tabulaires.</p>
+La méthode **`WebGLRenderingContext.drawArrays()`** de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API) dessine des primitives à partir de données tabulaires.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">void <var>gl</var>.drawArrays(<var>mode</var>, <em>premier</em>, <var>compte</var>);
-</pre>
+    void gl.drawArrays(mode, premier, compte);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>mode</code></dt>
- <dd>Un {{domxref ("GLenum")}} indiquant la primitive de type à dessiner. Les valeurs possibles sont :
- <ul>
-  <li><code>gl.POINTS</code> : dessine un seul point ;</li>
-  <li><code>gl.LINE_STRIP</code> : dessine une ligne droite jusqu'au sommet suivant ;</li>
-  <li><code>gl.LINE_LOOP</code> : dessine une ligne droite jusqu'au sommet suivant, et relie le dernier sommet au premier ;</li>
-  <li><code>gl.LINES</code> : dessine une ligne entre une paire de sommets ;</li>
-  <li><code><a href="https://en.wikipedia.org/wiki/Triangle_strip">gl.TRIANGLE_STRIP</a></code></li>
-  <li><code><a href="https://en.wikipedia.org/wiki/Triangle_fan">gl.TRIANGLE_FAN</a></code></li>
-  <li><code>gl.TRIANGLES</code> : dessine un triangle pour un groupe de trois sommets.</li>
- </ul>
- </dd>
- <dt><code>premier</code></dt>
- <dd>Un {{domxref("GLint")}} indiquant de l'indice de départ dans le tableau des points des vecteurs.</dd>
- <dt><code>compte</code></dt>
- <dd>Un {{domxref("GLsizei")}} indiquant le nombre d'indices à dessiner.</dd>
-</dl>
+- `mode`
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+  - : Un {{domxref ("GLenum")}} indiquant la primitive de type à dessiner. Les valeurs possibles sont :
 
-<p>None.</p>
+    - `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`](https://en.wikipedia.org/wiki/Triangle_strip)
+    - [`gl.TRIANGLE_FAN`](https://en.wikipedia.org/wiki/Triangle_fan)
+    - `gl.TRIANGLES` : dessine un triangle pour un groupe de trois sommets.
 
-<h3 id="Exceptions">Exceptions</h3>
+- `premier`
+  - : Un {{domxref("GLint")}} indiquant de l'indice de départ dans le tableau des points des vecteurs.
+- `compte`
+  - : Un {{domxref("GLsizei")}} indiquant le nombre d'indices à dessiner.
 
-<ul>
- <li>Si <code>mode</code> n'est pas l'une des valeurs acceptables, une erreur <code>gl.INVALID_ENUM</code> est déclenchée.</li>
- <li>Si <code>premier</code> ou <code>compte</code> sont négatifs, une erreur <code>gl.INVALID_VALUE</code> est déclenchée.</li>
- <li>Si <code>gl.CURRENT_PROGRAM</code> est {{jsxref("null")}}, une erreur <code>gl.INVALID_OPERATION</code> est déclenchée.</li>
-</ul>
+### Valeur retournée
 
-<h2 id="Exemples">Exemples</h2>
+None.
 
-<pre class="brush: js">gl.drawArrays(gl.POINTS, 0, 8);
-</pre>
+### Exceptions
 
-<h2 id="Spécifications">Spécifications</h2>
+- 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 {{jsxref("null")}}, une erreur `gl.INVALID_OPERATION` est déclenchée.
+
+## Exemples
+
+```js
+gl.drawArrays(gl.POINTS, 0, 8);
+```
+
+## Spécifications
 
 <table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.11", "drawArrays")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>
-    <p> </p>
-    Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glDrawArrays.xml", "glDrawArrays")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>
-    <p>Page man de l’API OpenGL.</p>
-   </td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <th scope="col">Spécification</th>
+      <th scope="col">Statut</th>
+      <th scope="col">Commentaire</th>
+    </tr>
+    <tr>
+      <td>{{SpecName('WebGL', "#5.14.11", "drawArrays")}}</td>
+      <td>{{Spec2('WebGL')}}</td>
+      <td>
+        <p> </p>
+        Définition initiale.
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('OpenGL ES 2.0', "glDrawArrays.xml", "glDrawArrays")}}
+      </td>
+      <td>{{Spec2('OpenGL ES 2.0')}}</td>
+      <td><p>Page man de l’API OpenGL.</p></td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.WebGLRenderingContext.drawArrays")}}</p>
+{{Compat("api.WebGLRenderingContext.drawArrays")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{domxref("WebGLRenderingContext.drawElements()")}}</li>
- <li>{{domxref("ANGLE_instanced_arrays.drawArraysInstancedANGLE()", "ext.drawArraysInstancedANGLE()")}}</li>
- <li>{{domxref("ANGLE_instanced_arrays.drawElementsInstancedANGLE()", "ext.drawElementsInstancedANGLE()")}}</li>
- <li>{{domxref("ANGLE_instanced_arrays.vertexAttribDivisorANGLE()", "ext.vertexAttribDivisorANGLE()")}}</li>
- <li>{{domxref("WebGL2RenderingContext.drawArraysInstanced()")}}</li>
- <li>{{domxref("WebGL2RenderingContext.drawElementsInstanced()")}}</li>
- <li>{{domxref("WebGL2RenderingContext.vertexAttribDivisor()")}}</li>
-</ul>
+- {{domxref("WebGLRenderingContext.drawElements()")}}
+- {{domxref("ANGLE_instanced_arrays.drawArraysInstancedANGLE()", "ext.drawArraysInstancedANGLE()")}}
+- {{domxref("ANGLE_instanced_arrays.drawElementsInstancedANGLE()", "ext.drawElementsInstancedANGLE()")}}
+- {{domxref("ANGLE_instanced_arrays.vertexAttribDivisorANGLE()", "ext.vertexAttribDivisorANGLE()")}}
+- {{domxref("WebGL2RenderingContext.drawArraysInstanced()")}}
+- {{domxref("WebGL2RenderingContext.drawElementsInstanced()")}}
+- {{domxref("WebGL2RenderingContext.vertexAttribDivisor()")}}
diff --git a/files/fr/web/api/webglrenderingcontext/enable/index.md b/files/fr/web/api/webglrenderingcontext/enable/index.md
index 3a4a7633b1..d207dd636e 100644
--- a/files/fr/web/api/webglrenderingcontext/enable/index.md
+++ b/files/fr/web/api/webglrenderingcontext/enable/index.md
@@ -10,133 +10,68 @@ tags:
 translation_of: Web/API/WebGLRenderingContext/enable
 original_slug: Web/API/WebGLRenderingContext/activer
 ---
-<div>{{APIRef("WebGL")}}</div>
-
-<p>La méthode <code>WebGLRenderingContext.enable()</code> de l'API WebGL active des fonctionnalités WebGL particulières pour ce contexte.</p>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">void <var>gl</var>.enable(<em>fon</em>);
-</pre>
-
-<h3 id="Paramètres">Paramètres</h3>
-
-<dl>
- <dt><code>fon</code></dt>
- <dd><p>Un {{domxref("GLenum")}} indiquant quelle fonctionnalité WebGL activer. Valeurs possibles :</p>
- <table class="standard-table">
-  <thead>
-   <tr>
-    <th scope="col">Constante</th>
-    <th scope="col">Description</th>
-   </tr>
-  </thead>
-  <tbody>
-   <tr>
-    <td><code>gl.BLEND</code></td>
-    <td>Active le mélange des valeurs de couleur de fragment calculées. Voir {{domxref("WebGLRenderingContext.blendFunc()")}}.</td>
-   </tr>
-   <tr>
-    <td><code>gl.CULL_FACE</code></td>
-    <td>Active le masquage des polygones. Voir {{domxref("WebGLRenderingContext.cullFace()")}}.</td>
-   </tr>
-   <tr>
-    <td><code>gl.DEPTH_TEST</code></td>
-    <td>Active les comparaisons et les mises à jour dans le tampon de profondeur. Voir {{domxref("WebGLRenderingContext.depthFunc()")}}.</td>
-   </tr>
-   <tr>
-    <td><code>gl.DITHER</code></td>
-    <td>Active le tramage des composantes de couleur avant qu'elles ne soient écrites dans le tampon de couleur.</td>
-   </tr>
-   <tr>
-    <td><code>gl.POLYGON_OFFSET_FILL</code></td>
-    <td>Active l'ajout d'un décalage aux valeurs de profondeur des fragments de polygone. Voir {{domxref("WebGLRenderingContext.polygonOffset()")}}.</td>
-   </tr>
-   <tr>
-    <td><code>gl.SAMPLE_ALPHA_TO_COVERAGE</code></td>
-    <td>Active le calcul d'une valeur de couverture temporaire déterminée par la valeur alpha.</td>
-   </tr>
-   <tr>
-    <td><code>gl.SAMPLE_COVERAGE</code></td>
-    <td>Active le ET de la couverture des fragments avec la valeur de couverture temporaire. Voir {{domxref("WebGLRenderingContext.sampleCoverage()")}}.</td>
-   </tr>
-   <tr>
-    <td><code>gl.SCISSOR_TEST</code></td>
-    <td>Active le test de détourage qui supprime les fragments se trouvant en dehors du rectangle de détourage. Voir {{domxref("WebGLRenderingContext.scissor()")}}.</td>
-   </tr>
-   <tr>
-    <td><code>gl.STENCIL_TEST</code></td>
-    <td>Active le test et les mises à jour stencil dans le stencil buffer. Voir {{domxref("WebGLRenderingContext.stencilFunc()")}}.</td>
-   </tr>
-  </tbody>
- </table>
- <p>Lors de l'utilisation d'un {{domxref("WebGL2RenderingContext", "WebGL 2 context", "", 1)}}, les valeurs suivantes sont en outre disponibles :</p>
- <table class="standard-table">
-  <thead>
-   <tr>
-    <th scope="col">Constante</th>
-    <th scope="col">Description</th>
-   </tr>
-  </thead>
-  <tbody>
-   <tr>
-    <td><code>gl.RASTERIZER_DISCARD</code></td>
-    <td>Les primitives sont supprimées immédiatement après l'étape de rastérisation, mais après l'étape de renvoi de transformation optionnelle. Les commandes <code>gl.clear()</code> sont ignorées.</td>
-   </tr>
-  </tbody>
- </table>
- </dd>
-</dl>
-
-<h3 id="Valeur_retournée">Valeur retournée</h3>
-
-<p>Aucune.</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<pre class="brush: js">gl.enable(gl.DITHER);
-</pre>
-
-<p>Pour vérifier que cette fonctionnalité est activée, utilisez la méthode {{domxref("WebGLRenderingContext.isEnabled()")}} :</p>
-
-<pre class="brush: js">gl.isEnabled(gl.DITHER);
+{{APIRef("WebGL")}}
+
+La méthode `WebGLRenderingContext.enable()` de l'API WebGL active des fonctionnalités WebGL particulières pour ce contexte.
+
+## Syntaxe
+
+    void gl.enable(fon);
+
+### Paramètres
+
+- `fon`
+
+  - : Un {{domxref("GLenum")}} indiquant quelle fonctionnalité WebGL activer. Valeurs possibles :
+
+    | Constante                     | Description                                                                                                                                                                |
+    | ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+    | `gl.BLEND`                    | Active le mélange des valeurs de couleur de fragment calculées. Voir {{domxref("WebGLRenderingContext.blendFunc()")}}.                                     |
+    | `gl.CULL_FACE`                | Active le masquage des polygones. Voir {{domxref("WebGLRenderingContext.cullFace()")}}.                                                                   |
+    | `gl.DEPTH_TEST`               | Active les comparaisons et les mises à jour dans le tampon de profondeur. Voir {{domxref("WebGLRenderingContext.depthFunc()")}}.                           |
+    | `gl.DITHER`                   | Active le tramage des composantes de couleur avant qu'elles ne soient écrites dans le tampon de couleur.                                                                   |
+    | `gl.POLYGON_OFFSET_FILL`      | Active l'ajout d'un décalage aux valeurs de profondeur des fragments de polygone. Voir {{domxref("WebGLRenderingContext.polygonOffset()")}}.               |
+    | `gl.SAMPLE_ALPHA_TO_COVERAGE` | Active le calcul d'une valeur de couverture temporaire déterminée par la valeur alpha.                                                                                     |
+    | `gl.SAMPLE_COVERAGE`          | Active le ET de la couverture des fragments avec la valeur de couverture temporaire. Voir {{domxref("WebGLRenderingContext.sampleCoverage()")}}.        |
+    | `gl.SCISSOR_TEST`             | Active le test de détourage qui supprime les fragments se trouvant en dehors du rectangle de détourage. Voir {{domxref("WebGLRenderingContext.scissor()")}}. |
+    | `gl.STENCIL_TEST`             | Active le test et les mises à jour stencil dans le stencil buffer. Voir {{domxref("WebGLRenderingContext.stencilFunc()")}}.                              |
+
+    Lors de l'utilisation d'un {{domxref("WebGL2RenderingContext", "WebGL 2 context", "", 1)}}, les valeurs suivantes sont en outre disponibles :
+
+    | Constante               | Description                                                                                                                                                                        |
+    | ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+    | `gl.RASTERIZER_DISCARD` | Les primitives sont supprimées immédiatement après l'étape de rastérisation, mais après l'étape de renvoi de transformation optionnelle. Les commandes `gl.clear()` sont ignorées. |
+
+### Valeur retournée
+
+Aucune.
+
+## Exemples
+
+```js
+gl.enable(gl.DITHER);
+```
+
+Pour vérifier que cette fonctionnalité est activée, utilisez la méthode {{domxref("WebGLRenderingContext.isEnabled()")}} :
+
+```js
+gl.isEnabled(gl.DITHER);
 // true
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.3", "enable")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale pour WebGL.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glEnable.xml", "glEnable")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man de l'API OpenGL ES 2.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 3.0', "glEnable.xhtml", "glEnable")}}</td>
-   <td>{{Spec2('OpenGL ES 3.0')}}</td>
-   <td>Page man de l'API OpenGL ES 3.0 API.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.WebGLRenderingContext.enable")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("WebGLRenderingContext.disable()")}}</li>
- <li>{{domxref("WebGLRenderingContext.isEnabled()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                    | Statut                               | Commentaire                          |
+| -------------------------------------------------------------------------------- | ------------------------------------ | ------------------------------------ |
+| {{SpecName('WebGL', "#5.14.3", "enable")}}                         | {{Spec2('WebGL')}}             | Définition initiale pour WebGL.      |
+| {{SpecName('OpenGL ES 2.0', "glEnable.xml", "glEnable")}}     | {{Spec2('OpenGL ES 2.0')}} | Page man de l'API OpenGL ES 2.0.     |
+| {{SpecName('OpenGL ES 3.0', "glEnable.xhtml", "glEnable")}} | {{Spec2('OpenGL ES 3.0')}} | Page man de l'API OpenGL ES 3.0 API. |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.WebGLRenderingContext.enable")}}
+
+## Voir aussi
+
+- {{domxref("WebGLRenderingContext.disable()")}}
+- {{domxref("WebGLRenderingContext.isEnabled()")}}
diff --git a/files/fr/web/api/webglrenderingcontext/enablevertexattribarray/index.md b/files/fr/web/api/webglrenderingcontext/enablevertexattribarray/index.md
index a573a50f6c..0ef32e590c 100644
--- a/files/fr/web/api/webglrenderingcontext/enablevertexattribarray/index.md
+++ b/files/fr/web/api/webglrenderingcontext/enablevertexattribarray/index.md
@@ -17,48 +17,42 @@ tags:
   - sommet
 translation_of: Web/API/WebGLRenderingContext/enableVertexAttribArray
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La méthode {{domxref ("WebGLRenderingContext")}} <strong><code>enableVertexAttribArray()</code> -</strong> qui fait partie de l'API WebGL - active le tableau générique des attributs de sommet à l'indice spécifié dans la liste des tableaux d'attributs.</p>
+La méthode {{domxref ("WebGLRenderingContext")}} **`enableVertexAttribArray()` -** qui fait partie de l'API WebGL - active le tableau générique des attributs de sommet à l'indice spécifié dans la liste des tableaux d'attributs.
 
-<div class="note">
-<p><strong>Note :</strong> Vous pouvez désactiver le tableau d'attributs en appelant {{domxref("WebGLRenderingContext.disableVertexAttribArray", "disableVertexAttribArray()")}}.</p>
-</div>
+> **Note :** Vous pouvez désactiver le tableau d'attributs en appelant {{domxref("WebGLRenderingContext.disableVertexAttribArray", "disableVertexAttribArray()")}}.
 
-<p>Dans WebGL, les valeurs s'appliquant à un sommet particulier sont stockées dans des attributs. Ceux-ci ne sont disponibles que pour le code JavaScript et le shader de sommet. Les attributs sont référencés par un numéro d'indice dans la liste des attributs gérés par la GPU. Certains indices d'attributs de sommet peuvent avoir des buts prédéfinis, suivant la plate-forme et/ou la GPU. D'autres sont affectés par la couche WebGL lorsque vous créez les attributs.</p>
+Dans WebGL, les valeurs s'appliquant à un sommet particulier sont stockées dans des attributs. Ceux-ci ne sont disponibles que pour le code JavaScript et le shader de sommet. Les attributs sont référencés par un numéro d'indice dans la liste des attributs gérés par la GPU. Certains indices d'attributs de sommet peuvent avoir des buts prédéfinis, suivant la plate-forme et/ou la GPU. D'autres sont affectés par la couche WebGL lorsque vous créez les attributs.
 
-<p>De toute façon, puisque les attributs ne peuvent pas être utilisés sauf s'ils sont activés, et ils sont désactivés par défaut, vous devez appeler <code>enableVertexAttribArray()</code> pour activer les attributs individuels, afin qu'ils puissent être utilisés. Ceci fait, d'autres méthodes peuvent être utilisées pour accéder à l'attribut, y compris {{domxref("WebGLRenderingContext.vertexAttribPointer", "vertexAttribPointer()")}}, {{domxref("WebGLRenderingContext.vertexAttrib", "vertexAttrib*()")}}, et {{domxref("WebGLRenderingContext.getVertexAttrib"," getVertexAttrib()")}}.</p>
+De toute façon, puisque les attributs ne peuvent pas être utilisés sauf s'ils sont activés, et ils sont désactivés par défaut, vous devez appeler `enableVertexAttribArray()` pour activer les attributs individuels, afin qu'ils puissent être utilisés. Ceci fait, d'autres méthodes peuvent être utilisées pour accéder à l'attribut, y compris {{domxref("WebGLRenderingContext.vertexAttribPointer", "vertexAttribPointer()")}}, {{domxref("WebGLRenderingContext.vertexAttrib", "vertexAttrib*()")}}, et {{domxref("WebGLRenderingContext.getVertexAttrib"," getVertexAttrib()")}}.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">void <var>gl</var>.enableVertexAttribArray(<var>indice</var>);
-</pre>
+    void gl.enableVertexAttribArray(indice);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>indice</code></dt>
- <dd>Un {{domxref("GLuint")}} indiquant le numéro d'indice identifiant de façon unique l'attribut de sommet à activer. Si vous connaissez le nom de l'attribut mais pas son indice, vous pouvez obtenir l'indice en appelant {{domxref ("WebGLRenderingContext.getAttribLocation", "getAttribLocation()")}}.</dd>
-</dl>
+- `indice`
+  - : Un {{domxref("GLuint")}} indiquant le numéro d'indice identifiant de façon unique l'attribut de sommet à activer. Si vous connaissez le nom de l'attribut mais pas son indice, vous pouvez obtenir l'indice en appelant {{domxref ("WebGLRenderingContext.getAttribLocation", "getAttribLocation()")}}.
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+### Valeur retournée
 
-<p><code>undefined</code>.</p>
+`undefined`.
 
-<h3 id="Erreurs">Erreurs</h3>
+### Erreurs
 
-<p>Pour vérifier d'éventuelles erreurs  après l'appel à <code>enableVertexAttribArray()</code>, appelez {{domxref("WebGLRenderingContext.getError", "getError()")}}.</p>
+Pour vérifier d'éventuelles erreurs  après l'appel à `enableVertexAttribArray()`, appelez {{domxref("WebGLRenderingContext.getError", "getError()")}}.
 
-<dl>
- <dt><code>WebGLRenderingContext.INVALID_VALUE</code></dt>
- <dd>L'<code>indice</code> spécifié est invalide, c'est-à-dire qu'il est supérieur ou égal au nombre maximal d'entrées autorisées dans la liste des attributs de sommet du contexte, comme indiqué par la valeur de <code>WebGLRenderingContext.MAX_VERTEX_ATTRIBS</code>.</dd>
-</dl>
+- `WebGLRenderingContext.INVALID_VALUE`
+  - : L'`indice` spécifié est invalide, c'est-à-dire qu'il est supérieur ou égal au nombre maximal d'entrées autorisées dans la liste des attributs de sommet du contexte, comme indiqué par la valeur de `WebGLRenderingContext.MAX_VERTEX_ATTRIBS`.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<p>Ce code — un extrait de l'exemple complet <a href="/fr-FR/docs/Web/API/WebGL_API/Basic_2D_animation_example">Un exemple d'animation 2D WebGL de base</a> — montre l'utilisation de <code>enableVertexArray()</code> pour activer l'attribut qui sera utilisé par la couche WebGL pour passer des sommets individuels depuis le tampon des sommets à la fonction shader de sommet.</p>
+Ce code — un extrait de l'exemple complet [Un exemple d'animation 2D WebGL de base](/fr-FR/docs/Web/API/WebGL_API/Basic_2D_animation_example) — montre l'utilisation de `enableVertexArray()` pour activer l'attribut qui sera utilisé par la couche WebGL pour passer des sommets individuels depuis le tampon des sommets à la fonction shader de sommet.
 
-<pre class="brush: js">gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
+```js
+gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
 
 aVertexPosition =
     gl.getAttribLocation(programmeShader, "aVertexPosition");
@@ -67,53 +61,52 @@ gl.enableVertexAttribArray(aVertexPosition);
 gl.vertexAttribPointer(aVertexPosition, vertexNumComponents,
       gl.FLOAT, false, 0, 0);
 
-gl.drawArrays(gl.TRIANGLES, 0, vertexCount);</pre>
+gl.drawArrays(gl.TRIANGLES, 0, vertexCount);
+```
 
-<div class="note">
-  <p><strong>Note :</strong> Cet extrait de code provient de <a href="/fr-FR/docs/Web/API/WebGL_API/Basic_2D_animation_example#Drawing_and_animating_the_scene">la fonction animateScene()</a> dans "Un exemple d'animation WebGL 2D de base". Voir cet article pour l'exemple complet et pour voir l'animation résultante en action.</p>
-</div>
+> **Note :** Cet extrait de code provient de [la fonction animateScene()](/fr-FR/docs/Web/API/WebGL_API/Basic_2D_animation_example#Drawing_and_animating_the_scene) dans "Un exemple d'animation WebGL 2D de base". Voir cet article pour l'exemple complet et pour voir l'animation résultante en action.
 
-<p>Ce code définit le tampon des sommets qui sera utilisé pour dessiner les triangles de la forme en appelant {{domxref("WebGLRenderingContext.bindBuffer", "bindBuffer()")}}. Ensuite, l'indice de l'attribut de position des sommets est obtenu à partir du programme shader en appelant {{domxref("WebGLRenderingContext.getAttribLocation", "getAttribLocation()")}}.</p>
+Ce code définit le tampon des sommets qui sera utilisé pour dessiner les triangles de la forme en appelant {{domxref("WebGLRenderingContext.bindBuffer", "bindBuffer()")}}. Ensuite, l'indice de l'attribut de position des sommets est obtenu à partir du programme shader en appelant {{domxref("WebGLRenderingContext.getAttribLocation", "getAttribLocation()")}}.
 
-<p>Avec l'indice de l'attribut de position des sommets maintenant disponible dans <code>aVertexPosition</code>, nous appelons <code>enableVertexAttribArray()</code> pour activer l'attribut de position afin qu'il puisse être utilisé par le programme shader (en particulier, par le shader de sommet).</p>
+Avec l'indice de l'attribut de position des sommets maintenant disponible dans `aVertexPosition`, nous appelons `enableVertexAttribArray()` pour activer l'attribut de position afin qu'il puisse être utilisé par le programme shader (en particulier, par le shader de sommet).
 
-<p>Le tampon des sommets est alors lié à l'attribut <code>aVertexPosition</code> en appelant {{domxref("WebGLRenderingContext.vertexAttribPointer", "vertexAttribPointer()")}}. Cette étape n'est pas évidente, puisque cette liaison est presque un effet de biais. Mais cela a pour résultat qu'un accès à <code>aVertexPosition</code> récupére désormais des données à partir du tampon des sommets.</p>
+Le tampon des sommets est alors lié à l'attribut `aVertexPosition` en appelant {{domxref("WebGLRenderingContext.vertexAttribPointer", "vertexAttribPointer()")}}. Cette étape n'est pas évidente, puisque cette liaison est presque un effet de biais. Mais cela a pour résultat qu'un accès à `aVertexPosition` récupére désormais des données à partir du tampon des sommets.
 
-<p>Avec l'association définie entre le tampon des sommets de notre forme et l'attribut <code>aVertexPosition</code> utilisé pour fournir les sommets un par un dans le shader de sommet, nous sommes prêts à dessiner la forme en appelant {{domxref ("WebGLRenderingContext.drawArrays", "drawArrays()")}}.</p>
+Avec l'association définie entre le tampon des sommets de notre forme et l'attribut `aVertexPosition` utilisé pour fournir les sommets un par un dans le shader de sommet, nous sommes prêts à dessiner la forme en appelant {{domxref ("WebGLRenderingContext.drawArrays", "drawArrays()")}}.
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
 <table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.10", "enableVertexAttribArray")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glEnableVertexAttribArray.xml", "glEnableVertexAttribArray")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>
-    <p>Page man de l’API OpenGL.</p>
-   </td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <th scope="col">Spécification</th>
+      <th scope="col">Statut</th>
+      <th scope="col">Commentaire</th>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('WebGL', "#5.14.10", "enableVertexAttribArray")}}
+      </td>
+      <td>{{Spec2('WebGL')}}</td>
+      <td>Définition initiale.</td>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('OpenGL ES 2.0', "glEnableVertexAttribArray.xml", "glEnableVertexAttribArray")}}
+      </td>
+      <td>{{Spec2('OpenGL ES 2.0')}}</td>
+      <td><p>Page man de l’API OpenGL.</p></td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.WebGLRenderingContext.enableVertexAttribArray")}}</p>
+{{Compat("api.WebGLRenderingContext.enableVertexAttribArray")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr-FR/docs/Web/API/WebGL_API/Data">Données en WebGL</a></li>
- <li><a href="/fr-FR/docs/Web/API/WebGL_API/Tutorial/Adding_2D_content_to_a_WebGL_context">Ajout de contenu 2D à un contexte WebGL</a></li>
- <li><a href="/fr-FR/docs/Web/API/WebGL_API/Basic_2D_animation_example">Un exemple d'animation WebGL 2D de base</a></li>
- <li>{{domxref("WebGLRenderingContext.disableVertexAttribArray", "disableVertexAttribArray()")}}</li>
-</ul>
+- [Données en WebGL](/fr-FR/docs/Web/API/WebGL_API/Data)
+- [Ajout de contenu 2D à un contexte WebGL](/fr-FR/docs/Web/API/WebGL_API/Tutorial/Adding_2D_content_to_a_WebGL_context)
+- [Un exemple d'animation WebGL 2D de base](/fr-FR/docs/Web/API/WebGL_API/Basic_2D_animation_example)
+- {{domxref("WebGLRenderingContext.disableVertexAttribArray", "disableVertexAttribArray()")}}
diff --git a/files/fr/web/api/webglrenderingcontext/generatemipmap/index.md b/files/fr/web/api/webglrenderingcontext/generatemipmap/index.md
index d97ee1aa73..c9d4cdbca6 100644
--- a/files/fr/web/api/webglrenderingcontext/generatemipmap/index.md
+++ b/files/fr/web/api/webglrenderingcontext/generatemipmap/index.md
@@ -10,82 +10,55 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/generateMipmap
 ---
-<div>{{APIRef("WebGL")}}</div>
-
-<p>La méthode <strong><code>WebGLRenderingContext.generateMipmap()</code></strong> de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> génère un ensemble de mipmaps pour un objet {{domxref("WebGLTexture")}}.</p>
-
-<p>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.</p>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">void <var>gl</var>.generateMipmap(<em>cible</em>);
-</pre>
-
-<h3 id="Paramètres">Paramètres</h3>
-
-<dl>
- <dt>cible</dt>
- <dd>Un {{domxref("GLenum")}} indiquant le point de liaison (cible) de la texture active dont les mipmaps seront générées. Valeurs possibles :
- <ul>
-  <li><code>gl.TEXTURE_2D</code> : une  texture bi-dimensionnelle.</li>
-  <li><code>gl.TEXTURE_CUBE_MAP</code> : une texture appliquée sur un cube.</li>
-  <li>Lorsqu'un {{domxref("WebGL2RenderingContext", "WebGL 2 context", "", 1)}} est utilisé, les valeurs suivantes sont en outre disponibles :
-   <ul>
-    <li><code>gl.TEXTURE_3D</code> : une texture tri-dimensionnelle.</li>
-    <li><code>gl.TEXTURE_2D_ARRAY</code> : une texture bi-dimensionnelle en tableau.</li>
-   </ul>
-  </li>
- </ul>
- </dd>
-</dl>
-
-<h3 id="Valeur_retournée">Valeur retournée</h3>
-
-<p>Aucune.</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<pre class="brush: js">gl.generateMipmap(gl.TEXTURE_2D);
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.8", "generateMipmap")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale pour WebGL.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glGenerateMipmap.xml", "glGenerateMipmap")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man de l'API (similaire) d'OpenGL ES 2.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 3.0', "glGenerateMipmap.xhtml", "glGenerateMipmap")}}</td>
-   <td>{{Spec2('OpenGL ES 3.0')}}</td>
-   <td>Page man de l'API (similaire) d'OpenGL ES 3.0<br>
-    Ajoute : <code>gl.TEXTURE_3D</code> et <code>gl.TEXTURE_2D_ARRAY</code></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.WebGLRenderingContext.generateMipmap")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("WebGLRenderingContext.createTexture()")}}</li>
- <li>{{domxref("WebGLRenderingContext.bindTexture()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getTexParameter()")}}</li>
- <li>{{domxref("WebGLRenderingContext.texParameter", "WebGLRenderingContext.texParameterf()")}}</li>
- <li>{{domxref("WebGLRenderingContext.texParameter", "WebGLRenderingContext.texParameteri()")}}</li>
-</ul>
+{{APIRef("WebGL")}}
+
+La méthode **`WebGLRenderingContext.generateMipmap()`** de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API) génère un ensemble de mipmaps pour un objet {{domxref("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
+
+    void gl.generateMipmap(cible);
+
+### Paramètres
+
+- cible
+
+  - : Un {{domxref("GLenum")}} 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 {{domxref("WebGL2RenderingContext", "WebGL 2 context", "", 1)}} 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
+
+| Spécification                                                                                        | Statut                               | Commentaire                                                                                     |
+| ---------------------------------------------------------------------------------------------------- | ------------------------------------ | ----------------------------------------------------------------------------------------------- |
+| {{SpecName('WebGL', "#5.14.8", "generateMipmap")}}                                 | {{Spec2('WebGL')}}             | Définition initiale pour WebGL.                                                                 |
+| {{SpecName('OpenGL ES 2.0', "glGenerateMipmap.xml", "glGenerateMipmap")}}     | {{Spec2('OpenGL ES 2.0')}} | Page man de l'API (similaire) d'OpenGL ES 2.0.                                                  |
+| {{SpecName('OpenGL ES 3.0', "glGenerateMipmap.xhtml", "glGenerateMipmap")}} | {{Spec2('OpenGL ES 3.0')}} | Page man de l'API (similaire) d'OpenGL ES 3.0 Ajoute : `gl.TEXTURE_3D` et `gl.TEXTURE_2D_ARRAY` |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.WebGLRenderingContext.generateMipmap")}}
+
+## Voir aussi
+
+- {{domxref("WebGLRenderingContext.createTexture()")}}
+- {{domxref("WebGLRenderingContext.bindTexture()")}}
+- {{domxref("WebGLRenderingContext.getTexParameter()")}}
+- {{domxref("WebGLRenderingContext.texParameter", "WebGLRenderingContext.texParameterf()")}}
+- {{domxref("WebGLRenderingContext.texParameter", "WebGLRenderingContext.texParameteri()")}}
diff --git a/files/fr/web/api/webglrenderingcontext/getattriblocation/index.md b/files/fr/web/api/webglrenderingcontext/getattriblocation/index.md
index d12d46f1c6..8242d0739b 100644
--- a/files/fr/web/api/webglrenderingcontext/getattriblocation/index.md
+++ b/files/fr/web/api/webglrenderingcontext/getattriblocation/index.md
@@ -9,61 +9,42 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/getAttribLocation
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La méthode <strong><code>WebGLRenderingContext.getAttribLocation()</code></strong> de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> retourne l'emplacement d'une variable d'attribut dans le {{domxref("WebGLProgram")}} indiqué.</p>
+La méthode **`WebGLRenderingContext.getAttribLocation()`** de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API) retourne l'emplacement d'une variable d'attribut dans le {{domxref("WebGLProgram")}} indiqué.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">GLint <var>gl</var>.getAttribLocation(<var>programme</var>, <var>nom</var>);
-</pre>
+    GLint gl.getAttribLocation(programme, nom);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt>programme</dt>
- <dd>Un {{domxref("WebGLProgram")}} contenant la variable d'attribut.</dd>
- <dt>nom</dt>
- <dd>Un {{domxref("DOMString")}} indiquant le nom de la variable d'attribut dont l'emplacement est à retourner.</dd>
-</dl>
+- programme
+  - : Un {{domxref("WebGLProgram")}} contenant la variable d'attribut.
+- nom
+  - : Un {{domxref("DOMString")}} indiquant le nom de la variable d'attribut dont l'emplacement est à retourner.
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+### Valeur retournée
 
-<p>Un nombre {{domxref("GLint")}} indiquant l'emplacement du nom de la variable si trouvé. Retourne -1 sinon.</p>
+Un nombre {{domxref("GLint")}} indiquant l'emplacement du nom de la variable si trouvé. Retourne -1 sinon.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">gl.getAttribLocation(programme, 'vColor');
-</pre>
+```js
+gl.getAttribLocation(programme, 'vColor');
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.10", "getAttribLocation")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glGetAttribLocation.xml", "glGetAttribLocation")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page principale de l'API OpenGL.</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                            | Statut                               | Commentaire                      |
+| -------------------------------------------------------------------------------------------------------- | ------------------------------------ | -------------------------------- |
+| {{SpecName('WebGL', "#5.14.10", "getAttribLocation")}}                                 | {{Spec2('WebGL')}}             | Définition initiale.             |
+| {{SpecName('OpenGL ES 2.0', "glGetAttribLocation.xml", "glGetAttribLocation")}} | {{Spec2('OpenGL ES 2.0')}} | Page principale de l'API OpenGL. |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.WebGLRenderingContext.getAttribLocation")}}</p>
+{{Compat("api.WebGLRenderingContext.getAttribLocation")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{domxref("WebGLRenderingContext.getUniformLocation()")}}</li>
-</ul>
+- {{domxref("WebGLRenderingContext.getUniformLocation()")}}
diff --git a/files/fr/web/api/webglrenderingcontext/geterror/index.md b/files/fr/web/api/webglrenderingcontext/geterror/index.md
index 1e3d624e40..cd310e0a29 100644
--- a/files/fr/web/api/webglrenderingcontext/geterror/index.md
+++ b/files/fr/web/api/webglrenderingcontext/geterror/index.md
@@ -9,97 +9,51 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/getError
 ---
-<div>{{APIRef("WebGL")}}</div>
-
-<p>La méthode <strong><code>WebGLRenderingContext.getError()</code></strong> de l'<a href="/fr-Fr/docs/Web/API/WebGL_API">API WebGL</a> retourne des informations d'erreur.</p>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">GLenum <var>gl</var>.getError();
-</pre>
-
-<h3 id="Paramètres">Paramètres</h3>
-
-<p>Aucun.</p>
-
-<h3 id="Valeur_retournée">Valeur retournée</h3>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Constante</th>
-   <th scope="col">Description</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>gl.NO_ERROR</code></td>
-   <td>Aucune erreur n'a été enregistrée. La valeur de cette constante est 0.</td>
-  </tr>
-  <tr>
-   <td><code>gl.INVALID_ENUM</code></td>
-   <td>Une valeur non acceptable a été spécifiée pour un argument énuméré. La commande est ignorée et l'indicateur d'erreur est positionné.</td>
-  </tr>
-  <tr>
-   <td><code>gl.INVALID_VALUE</code></td>
-   <td>Un argument numérique est hors de sa plage. La commande est ignorée et l'indicateur d'erreur est positionné.</td>
-  </tr>
-  <tr>
-   <td><code>gl.INVALID_OPERATION</code></td>
-   <td>La commande indiquée n'est pas permise dans l'état courant. La commande est ignorée et l'indicateur d'erreur est positionné.</td>
-  </tr>
-  <tr>
-   <td><code>gl.INVALID_FRAMEBUFFER_OPERATION</code></td>
-   <td>Le tampon d'images actuellement lié n'est pas complet lors d'une tentative de rendu ou de relecture.</td>
-  </tr>
-  <tr>
-   <td><code>gl.OUT_OF_MEMORY</code></td>
-   <td>Plus assez de mémoire restante pour exécuter la commande.</td>
-  </tr>
-  <tr>
-   <td><code>gl.CONTEXT_LOST_WEBGL</code></td>
-   <td>Si le contexte WebGL est perdu, cette erreur est retournée lors du premier appel à <code>getError</code>. Après cela et jusqu'à ce que le contexte soit restauré, elle retourne <code>gl.NO_ERROR</code>.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Exemples">Exemples</h2>
-
-<pre class="brush: js">gl.getError(); // gl.NO_ERROR (0)
+{{APIRef("WebGL")}}
+
+La méthode **`WebGLRenderingContext.getError()`** de l'[API WebGL](/fr-Fr/docs/Web/API/WebGL_API) retourne des informations d'erreur.
+
+## Syntaxe
+
+    GLenum gl.getError();
+
+### Paramètres
+
+Aucun.
+
+### Valeur retournée
+
+| Constante                          | Description                                                                                                                                                                         |
+| ---------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `gl.NO_ERROR`                      | Aucune erreur n'a été enregistrée. La valeur de cette constante est 0.                                                                                                              |
+| `gl.INVALID_ENUM`                  | Une valeur non acceptable a été spécifiée pour un argument énuméré. La commande est ignorée et l'indicateur d'erreur est positionné.                                                |
+| `gl.INVALID_VALUE`                 | Un argument numérique est hors de sa plage. La commande est ignorée et l'indicateur d'erreur est positionné.                                                                        |
+| `gl.INVALID_OPERATION`             | La commande indiquée n'est pas permise dans l'état courant. La commande est ignorée et l'indicateur d'erreur est positionné.                                                        |
+| `gl.INVALID_FRAMEBUFFER_OPERATION` | Le tampon d'images actuellement lié n'est pas complet lors d'une tentative de rendu ou de relecture.                                                                                |
+| `gl.OUT_OF_MEMORY`                 | Plus assez de mémoire restante pour exécuter la commande.                                                                                                                           |
+| `gl.CONTEXT_LOST_WEBGL`            | Si le contexte WebGL est perdu, cette erreur est retournée lors du premier appel à `getError`. Après cela et jusqu'à ce que le contexte soit restauré, elle retourne `gl.NO_ERROR`. |
+
+## Exemples
+
+```js
+gl.getError(); // gl.NO_ERROR (0)
 
 gl.enable(gl.MACHINTRUC);
 gl.getError(); // gl.INVALID_ENUM;
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.3", "getError")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glGetError.xml", "glGetError")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man de l'API OpenGL.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.WebGLRenderingContext.getError")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("WebGLRenderingContext")}}</li>
- <li>{{domxref("WebGLContextEvent")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                    | Statut                               | Commentaire               |
+| -------------------------------------------------------------------------------- | ------------------------------------ | ------------------------- |
+| {{SpecName('WebGL', "#5.14.3", "getError")}}                     | {{Spec2('WebGL')}}             | Définition initiale.      |
+| {{SpecName('OpenGL ES 2.0', "glGetError.xml", "glGetError")}} | {{Spec2('OpenGL ES 2.0')}} | Page man de l'API OpenGL. |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.WebGLRenderingContext.getError")}}
+
+## Voir aussi
+
+- {{domxref("WebGLRenderingContext")}}
+- {{domxref("WebGLContextEvent")}}
diff --git a/files/fr/web/api/webglrenderingcontext/getshaderparameter/index.md b/files/fr/web/api/webglrenderingcontext/getshaderparameter/index.md
index 46c5369067..e89237d889 100644
--- a/files/fr/web/api/webglrenderingcontext/getshaderparameter/index.md
+++ b/files/fr/web/api/webglrenderingcontext/getshaderparameter/index.md
@@ -9,67 +9,47 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/getShaderParameter
 ---
-<div>{{APIRef("WebGL")}}</div>
-
-<p>La méthode <code>WebGLRenderingContext.getShaderParameter()</code> de l'API WebGL retourne des informations sur le shader donné.</p>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">quelconque <var>gl</var>.getShaderParameter(<var>shader</var>, <var>nomp</var>);
-</pre>
-
-<h3 id="Parameters">Parameters</h3>
-
-<dl>
- <dt>shader</dt>
- <dd>Un {{domxref("WebGLShader")}} depuis lequel obtenir une information de paramètre.</dd>
- <dt>nomp</dt>
- <dd>Un {{domxref("Glenum")}} indiquant l'information à retrouver. Valeurs possibles :
- <ul>
-  <li><code>gl.DELETE_STATUS</code> : retourne un {{domxref("GLboolean")}} indicating si le shader est marqué pour suppression ou non.</li>
-  <li><code>gl.COMPILE_STATUS</code> : retourne un {{domxref("GLboolean")}} indiquant si la dernière compilation du shader a réussi ou non.</li>
-  <li><code>gl.SHADER_TYPE</code> : retourne un {{domxref("GLenum")}} indiquant si le shader est un objet shader de sommets (<code>gl.VERTEX_SHADER</code>) ou shader de fragment (<code>gl.FRAGMENT_SHADER</code>).</li>
- </ul>
- </dd>
-</dl>
-
-<h3 id="Valeur_retournée">Valeur retournée</h3>
-
-<p>Retourne l'information de shader demandée (telle qu'indiquée par <code>nomp</code>).</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<pre class="brush: js">gl.getShaderParameter(shader, gl.SHADER_TYPE);
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.9", "getShaderParameter")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glGetShaderiv.xml", "glGetShaderiv")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man de l'API OpenGL (similaire).</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.WebGLRenderingContext.getShaderParameter")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("WebGLRenderingContext.getProgramParameter()")}}</li>
-</ul>
+{{APIRef("WebGL")}}
+
+La méthode `WebGLRenderingContext.getShaderParameter()` de l'API WebGL retourne des informations sur le shader donné.
+
+## Syntaxe
+
+    quelconque gl.getShaderParameter(shader, nomp);
+
+### Parameters
+
+- shader
+  - : Un {{domxref("WebGLShader")}} depuis lequel obtenir une information de paramètre.
+- nomp
+
+  - : Un {{domxref("Glenum")}} indiquant l'information à retrouver. Valeurs possibles :
+
+    - `gl.DELETE_STATUS` : retourne un {{domxref("GLboolean")}} indicating si le shader est marqué pour suppression ou non.
+    - `gl.COMPILE_STATUS` : retourne un {{domxref("GLboolean")}} indiquant si la dernière compilation du shader a réussi ou non.
+    - `gl.SHADER_TYPE` : retourne un {{domxref("GLenum")}} 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
+
+| Spécification                                                                            | Statut                               | Commentaire                           |
+| ---------------------------------------------------------------------------------------- | ------------------------------------ | ------------------------------------- |
+| {{SpecName('WebGL', "#5.14.9", "getShaderParameter")}}                 | {{Spec2('WebGL')}}             | Définition initiale.                  |
+| {{SpecName('OpenGL ES 2.0', "glGetShaderiv.xml", "glGetShaderiv")}} | {{Spec2('OpenGL ES 2.0')}} | Page man de l'API OpenGL (similaire). |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.WebGLRenderingContext.getShaderParameter")}}
+
+## Voir aussi
+
+- {{domxref("WebGLRenderingContext.getProgramParameter()")}}
diff --git a/files/fr/web/api/webglrenderingcontext/gettexparameter/index.md b/files/fr/web/api/webglrenderingcontext/gettexparameter/index.md
index a153da3ba0..38342d8c00 100644
--- a/files/fr/web/api/webglrenderingcontext/gettexparameter/index.md
+++ b/files/fr/web/api/webglrenderingcontext/gettexparameter/index.md
@@ -10,190 +10,194 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/getTexParameter
 ---
-<div>{{APIRef("WebGL")}}</div>
-
-<p>La méthode <strong><code>WebGLRenderingContext.getTexParameter()</code></strong> de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> retourne des informations concernant la texture indiquée.</p>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">quelconque <var>gl</var>.getTexParameter(<var>cible</var>, <var>nomp</var>);
-</pre>
-
-<h3 id="Paramètres">Paramètres</h3>
-
-<dl>
- <dt>cible</dt>
- <dd>Un {{domxref("GLenum")}} indiquant le point de liaison (cible). Valeurs possibles :
- <ul>
-  <li><code>gl.TEXTURE_2D</code> : une texture bi-dimensionnelle.</li>
-  <li><code>gl.TEXTURE_CUBE_MAP</code> : une texture appliquée à un cube.</li>
-  <li>Lorsqu' un {{domxref("WebGL2RenderingContext", "WebGL 2 context", "", 1)}} est utilisé, les valeurs suivantes sont en outre disponibles :
-   <ul>
-    <li><code>gl.TEXTURE_3D</code> : une texture tri-dimensionnelle.</li>
-    <li><code>gl.TEXTURE_2D_ARRAY</code> : une texture bi-dimensionnelle en tableau.</li>
-   </ul>
-  </li>
- </ul>
- </dd>
- <dt>nomp</dt>
- <dd>Un {{domxref("Glenum")}} indiquant l'information à obtenir. Valeurs possibles :
- <table class="standard-table">
-  <thead>
-   <tr>
-    <th scope="col">nomp</th>
-    <th scope="col">Type retourné</th>
-    <th scope="col">Description</th>
-    <th scope="col">Valeurs retournées possibles</th>
-   </tr>
-  </thead>
-  <tbody>
-   <tr>
-    <th colspan="4">Disponible dans un contexte WebGL 1</th>
-   </tr>
-   <tr>
-    <td><code>gl.TEXTURE_MAG_FILTER</code></td>
-    <td>{{domxref("GLenum")}}</td>
-    <td>Filtre de grossissement de texture</td>
-    <td><code>gl.LINEAR</code> (valeur par défaut), <code>gl.NEAREST</code>.</td>
-   </tr>
-   <tr>
-    <td><code>gl.TEXTURE_MIN_FILTER</code></td>
-    <td>{{domxref("GLenum")}}</td>
-    <td>Filtre de réduction de texture</td>
-    <td><code>gl.LINEAR</code>, <code>gl.NEAREST</code>, <code>gl.NEAREST_MIPMAP_NEAREST</code>, <code>gl.LINEAR_MIPMAP_NEAREST</code>, <code>gl.NEAREST</code>_MIPMAP_LINEAR (valeur par défaut), <code>gl.LINEAR_MIPMAP_LINEAR</code>.</td>
-   </tr>
-   <tr>
-    <td><code>gl.TEXTURE_WRAP_S</code></td>
-    <td>{{domxref("GLenum")}}</td>
-    <td>Fonction d'emballage pour la coordonnée de texture <code>s</code></td>
-    <td><code>gl.REPEAT</code> (valeur par défaut), <code>gl.CLAMP_TO_EDGE</code>, <code>gl.MIRRORED_REPEAT</code>.</td>
-   </tr>
-   <tr>
-    <td><code>gl.TEXTURE_WRAP_T</code></td>
-    <td>{{domxref("GLenum")}}</td>
-    <td>Fonction d'emballage pour la coordonnée de texture <code>t</code></td>
-    <td><code>gl.REPEAT</code> (valeur par défaut), <code>gl.CLAMP_TO_EDGE</code>, <code>gl.MIRRORED_REPEAT</code>.</td>
-   </tr>
-   <tr>
-    <th colspan="4">Disponible en outre lorsque l'extension {{domxref("EXT_texture_filter_anisotropic")}} est utilisée</th>
-   </tr>
-   <tr>
-    <td><code>ext.TEXTURE_MAX_ANISOTROPY_EXT</code></td>
-    <td>{{domxref("GLfloat")}}</td>
-    <td>Anisotropie maximum pour une texture</td>
-    <td>Toutes valeurs float.</td>
-   </tr>
-   <tr>
-    <th colspan="4">Disponible en outre lorsqu'un contexte WebGL 2 est utilisé</th>
-   </tr>
-   <tr>
-    <td><code>gl.TEXTURE_BASE_LEVEL</code></td>
-    <td>{{domxref("GLint")}}</td>
-    <td>Niveau  de mipmap de texture</td>
-    <td>Toutes valeurs int.</td>
-   </tr>
-   <tr>
-    <td><code>gl.TEXTURE_COMPARE_FUNC</code></td>
-    <td>{{domxref("GLenum")}}</td>
-    <td>Fonction de comparaison</td>
-    <td><code>gl.LEQUAL</code> (valeurs par défaut), <code>gl.GEQUAL</code>, <code>gl.LESS</code>, <code>gl.GREATER</code>, <code>gl.EQUAL</code>, <code>gl.NOTEQUAL</code>, <code>gl.ALWAYS</code>, <code>gl.NEVER</code>.</td>
-   </tr>
-   <tr>
-    <td><code>gl.TEXTURE_COMPARE_MODE</code></td>
-    <td>{{domxref("GLenum")}}</td>
-    <td>Mode de comparaison de texture</td>
-    <td><code>gl.NONE</code> (valeur par défaut), <code>gl.COMPARE_REF_TO_TEXTURE</code>.</td>
-   </tr>
-   <tr>
-    <td><code>gl.TEXTURE_IMMUTABLE_FORMAT</code></td>
-    <td>{{domxref("GLboolean")}}</td>
-    <td>Immuabilité du format et de la taille de la texture</td>
-    <td>true ou false.</td>
-   </tr>
-   <tr>
-    <td><code>gl.TEXTURE_IMMUTABLE_LEVELS</code></td>
-    <td>{{domxref("GLuint")}}</td>
-    <td>?</td>
-    <td>Toutes valeurs uint.</td>
-   </tr>
-   <tr>
-    <td><code>gl.TEXTURE_MAX_LEVEL</code></td>
-    <td>{{domxref("GLint")}}</td>
-    <td>Niveau maximum  de mipmap de texture en tableau</td>
-    <td>Toutes valeurs int.</td>
-   </tr>
-   <tr>
-    <td><code>gl.TEXTURE_MAX_LOD</code></td>
-    <td>{{domxref("GLfloat")}}</td>
-    <td>Valeur de niveau-de-détail maximum de texture</td>
-    <td>Toutes valeurs float.</td>
-   </tr>
-   <tr>
-    <td><code>gl.TEXTURE_MIN_LOD</code></td>
-    <td>{{domxref("GLfloat")}}</td>
-    <td>Valeur de niveau-de-détail minimum de texture</td>
-    <td>Toutes valeurs float.</td>
-   </tr>
-   <tr>
-    <td><code>gl.TEXTURE_WRAP_R</code></td>
-    <td>{{domxref("GLenum")}}</td>
-    <td>Fonction d'emballage pour la coordonnée de texture  <code>r</code></td>
-    <td><code>gl.REPEAT</code> (valeur par défaut), <code>gl.CLAMP_TO_EDGE</code>, <code>gl.MIRRORED_REPEAT</code>.</td>
-   </tr>
-  </tbody>
- </table>
- </dd>
-</dl>
-
-<h3 id="Valeur_retournée">Valeur retournée</h3>
-
-<p>Retourne l'information de texture demandée (telle qu'indiquée par <code>nomp</code>). Si une erreur se produit, {{jsxref("null")}} est retourné.</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<pre class="brush: js">gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER);
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.8", "getTexParameter")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale pour WebGL.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glGetTexParameter.xml", "glGetTexParameter")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man de l'API OpenGL ES 2.0 (similaire).</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL2', "#3.7.6", "getTexParameter")}}</td>
-   <td>{{Spec2('WebGL2')}}</td>
-   <td>Définition mise à jour pour WebGL.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 3.0', "glGetTexParameter.xhtml", "glGetTexParameter")}}</td>
-   <td>{{Spec2('OpenGL ES 3.0')}}</td>
-   <td>Page man de l'API OpenGL ES 3.0 (similaire).</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.WebGLRenderingContext.getTexParameter")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("WebGLRenderingContext.texParameter", "WebGLRenderingContext.texParameterf()")}}</li>
- <li>{{domxref("WebGLRenderingContext.texParameter", "WebGLRenderingContext.texParameteri()")}}</li>
- <li>{{domxref("EXT_texture_filter_anisotropic")}}</li>
-</ul>
+{{APIRef("WebGL")}}
+
+La méthode **`WebGLRenderingContext.getTexParameter()`** de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API) retourne des informations concernant la texture indiquée.
+
+## Syntaxe
+
+    quelconque gl.getTexParameter(cible, nomp);
+
+### Paramètres
+
+- cible
+
+  - : Un {{domxref("GLenum")}} indiquant le point de liaison (cible). Valeurs possibles :
+
+    - `gl.TEXTURE_2D` : une texture bi-dimensionnelle.
+    - `gl.TEXTURE_CUBE_MAP` : une texture appliquée à un cube.
+    - Lorsqu' un {{domxref("WebGL2RenderingContext", "WebGL 2 context", "", 1)}} 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.
+
+- nomp
+
+  - : Un {{domxref("Glenum")}} indiquant l'information à obtenir. Valeurs possibles :
+
+    <table class="standard-table">
+      <thead>
+        <tr>
+          <th scope="col">nomp</th>
+          <th scope="col">Type retourné</th>
+          <th scope="col">Description</th>
+          <th scope="col">Valeurs retournées possibles</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr>
+          <th colspan="4">Disponible dans un contexte WebGL 1</th>
+        </tr>
+        <tr>
+          <td><code>gl.TEXTURE_MAG_FILTER</code></td>
+          <td>{{domxref("GLenum")}}</td>
+          <td>Filtre de grossissement de texture</td>
+          <td>
+            <code>gl.LINEAR</code> (valeur par défaut), <code>gl.NEAREST</code>.
+          </td>
+        </tr>
+        <tr>
+          <td><code>gl.TEXTURE_MIN_FILTER</code></td>
+          <td>{{domxref("GLenum")}}</td>
+          <td>Filtre de réduction de texture</td>
+          <td>
+            <code>gl.LINEAR</code>, <code>gl.NEAREST</code>,
+            <code>gl.NEAREST_MIPMAP_NEAREST</code>,
+            <code>gl.LINEAR_MIPMAP_NEAREST</code>,
+            <code>gl.NEAREST</code>_MIPMAP_LINEAR (valeur par défaut),
+            <code>gl.LINEAR_MIPMAP_LINEAR</code>.
+          </td>
+        </tr>
+        <tr>
+          <td><code>gl.TEXTURE_WRAP_S</code></td>
+          <td>{{domxref("GLenum")}}</td>
+          <td>Fonction d'emballage pour la coordonnée de texture <code>s</code></td>
+          <td>
+            <code>gl.REPEAT</code> (valeur par défaut),
+            <code>gl.CLAMP_TO_EDGE</code>, <code>gl.MIRRORED_REPEAT</code>.
+          </td>
+        </tr>
+        <tr>
+          <td><code>gl.TEXTURE_WRAP_T</code></td>
+          <td>{{domxref("GLenum")}}</td>
+          <td>Fonction d'emballage pour la coordonnée de texture <code>t</code></td>
+          <td>
+            <code>gl.REPEAT</code> (valeur par défaut),
+            <code>gl.CLAMP_TO_EDGE</code>, <code>gl.MIRRORED_REPEAT</code>.
+          </td>
+        </tr>
+        <tr>
+          <th colspan="4">
+            Disponible en outre lorsque l'extension
+            {{domxref("EXT_texture_filter_anisotropic")}} est
+            utilisée
+          </th>
+        </tr>
+        <tr>
+          <td><code>ext.TEXTURE_MAX_ANISOTROPY_EXT</code></td>
+          <td>{{domxref("GLfloat")}}</td>
+          <td>Anisotropie maximum pour une texture</td>
+          <td>Toutes valeurs float.</td>
+        </tr>
+        <tr>
+          <th colspan="4">
+            Disponible en outre lorsqu'un contexte WebGL 2 est utilisé
+          </th>
+        </tr>
+        <tr>
+          <td><code>gl.TEXTURE_BASE_LEVEL</code></td>
+          <td>{{domxref("GLint")}}</td>
+          <td>Niveau  de mipmap de texture</td>
+          <td>Toutes valeurs int.</td>
+        </tr>
+        <tr>
+          <td><code>gl.TEXTURE_COMPARE_FUNC</code></td>
+          <td>{{domxref("GLenum")}}</td>
+          <td>Fonction de comparaison</td>
+          <td>
+            <code>gl.LEQUAL</code> (valeurs par défaut), <code>gl.GEQUAL</code>,
+            <code>gl.LESS</code>, <code>gl.GREATER</code>, <code>gl.EQUAL</code>,
+            <code>gl.NOTEQUAL</code>, <code>gl.ALWAYS</code>, <code>gl.NEVER</code>.
+          </td>
+        </tr>
+        <tr>
+          <td><code>gl.TEXTURE_COMPARE_MODE</code></td>
+          <td>{{domxref("GLenum")}}</td>
+          <td>Mode de comparaison de texture</td>
+          <td>
+            <code>gl.NONE</code> (valeur par défaut),
+            <code>gl.COMPARE_REF_TO_TEXTURE</code>.
+          </td>
+        </tr>
+        <tr>
+          <td><code>gl.TEXTURE_IMMUTABLE_FORMAT</code></td>
+          <td>{{domxref("GLboolean")}}</td>
+          <td>Immuabilité du format et de la taille de la texture</td>
+          <td>true ou false.</td>
+        </tr>
+        <tr>
+          <td><code>gl.TEXTURE_IMMUTABLE_LEVELS</code></td>
+          <td>{{domxref("GLuint")}}</td>
+          <td>?</td>
+          <td>Toutes valeurs uint.</td>
+        </tr>
+        <tr>
+          <td><code>gl.TEXTURE_MAX_LEVEL</code></td>
+          <td>{{domxref("GLint")}}</td>
+          <td>Niveau maximum  de mipmap de texture en tableau</td>
+          <td>Toutes valeurs int.</td>
+        </tr>
+        <tr>
+          <td><code>gl.TEXTURE_MAX_LOD</code></td>
+          <td>{{domxref("GLfloat")}}</td>
+          <td>Valeur de niveau-de-détail maximum de texture</td>
+          <td>Toutes valeurs float.</td>
+        </tr>
+        <tr>
+          <td><code>gl.TEXTURE_MIN_LOD</code></td>
+          <td>{{domxref("GLfloat")}}</td>
+          <td>Valeur de niveau-de-détail minimum de texture</td>
+          <td>Toutes valeurs float.</td>
+        </tr>
+        <tr>
+          <td><code>gl.TEXTURE_WRAP_R</code></td>
+          <td>{{domxref("GLenum")}}</td>
+          <td>
+            Fonction d'emballage pour la coordonnée de texture  <code>r</code>
+          </td>
+          <td>
+            <code>gl.REPEAT</code> (valeur par défaut),
+            <code>gl.CLAMP_TO_EDGE</code>, <code>gl.MIRRORED_REPEAT</code>.
+          </td>
+        </tr>
+      </tbody>
+    </table>
+
+### Valeur retournée
+
+Retourne l'information de texture demandée (telle qu'indiquée par `nomp`). Si une erreur se produit, {{jsxref("null")}} est retourné.
+
+## Exemples
+
+```js
+gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER);
+```
+
+## Spécifications
+
+| Spécification                                                                                            | Statut                               | Commentaire                                  |
+| -------------------------------------------------------------------------------------------------------- | ------------------------------------ | -------------------------------------------- |
+| {{SpecName('WebGL', "#5.14.8", "getTexParameter")}}                                     | {{Spec2('WebGL')}}             | Définition initiale pour WebGL.              |
+| {{SpecName('OpenGL ES 2.0', "glGetTexParameter.xml", "glGetTexParameter")}}     | {{Spec2('OpenGL ES 2.0')}} | Page man de l'API OpenGL ES 2.0 (similaire). |
+| {{SpecName('WebGL2', "#3.7.6", "getTexParameter")}}                                     | {{Spec2('WebGL2')}}             | Définition mise à jour pour WebGL.           |
+| {{SpecName('OpenGL ES 3.0', "glGetTexParameter.xhtml", "glGetTexParameter")}} | {{Spec2('OpenGL ES 3.0')}} | Page man de l'API OpenGL ES 3.0 (similaire). |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.WebGLRenderingContext.getTexParameter")}}
+
+## Voir aussi
+
+- {{domxref("WebGLRenderingContext.texParameter", "WebGLRenderingContext.texParameterf()")}}
+- {{domxref("WebGLRenderingContext.texParameter", "WebGLRenderingContext.texParameteri()")}}
+- {{domxref("EXT_texture_filter_anisotropic")}}
diff --git a/files/fr/web/api/webglrenderingcontext/getuniformlocation/index.md b/files/fr/web/api/webglrenderingcontext/getuniformlocation/index.md
index 89393bd4f7..27f389fd28 100644
--- a/files/fr/web/api/webglrenderingcontext/getuniformlocation/index.md
+++ b/files/fr/web/api/webglrenderingcontext/getuniformlocation/index.md
@@ -14,70 +14,51 @@ tags:
   - getUniformLocation
 translation_of: Web/API/WebGLRenderingContext/getUniformLocation
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}Faisant partie de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API), la méthode {{domxref("WebGLRenderingContext")}} **`getUniformLocation()`** retourne l'emplacement d'une variable **uniform** particulière appartenant au {{domxref ("WebGLProgram")}} indiqué. La variable uniform est retournée sous la forme d'un objet {{domxref("WebGLUniformLocation")}}, qui est un identificateur opaque utilisé pour indiquer où se trouve la variable uniform dans la mémoire de la GPU. Une fois que vous avez l'emplacement de l'uniform, vous pouvez accéder à l'uniform lui-même en utilisant l'une des autres méthodes d'accès uniform, en passant l'emplacement de l'uniform comme l'une des entrées :
 
-<div>Faisant partie de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a>, la méthode {{domxref("WebGLRenderingContext")}} <code><strong>getUniformLocation()</strong></code> retourne l'emplacement d'une variable <strong>uniform</strong> particulière appartenant au {{domxref ("WebGLProgram")}} indiqué. La variable uniform est retournée sous la forme d'un objet {{domxref("WebGLUniformLocation")}}, qui est un identificateur opaque utilisé pour indiquer où se trouve la variable uniform dans la mémoire de la GPU.</div>
+- {{domxref ("WebGLRenderingContext.getUniform", "getUniform()")}}
+  - : Retourne la valeur de l'uniform à l'emplacement indiqué.
+- {{domxref ("WebGLRenderingContext.uniform", "uniform[1234] [fi] [v]()")}}
+  - : Affecte à la valeur de l'uniform la valeur spécifiée, qui peut être un nombre flottant ou entier unique, ou un vecteur de 2 à 4 composantes spécifié soit comme une liste de valeurs, soit comme un {{jsxref ("Float32Array")}} ou un {{ jsxref ("Int32Array")}}.
+- {{domxref ("WebGLRenderingContext.uniformMatrix", "uniformMatrix[234][fv]()")}}
+  - : Affecte à la valeur de l'uniforme la matrice spécifiée, éventuellement avec transposition. La valeur est représentée comme une suite de valeurs GLfloat ou comme un Float32Array.
 
-<div> </div>
+L'uniform lui-même est déclaré dans le programme shader en utilisant GLSL.
 
-<div>Une fois que vous avez l'emplacement de l'uniform, vous pouvez accéder à l'uniform lui-même en utilisant l'une des autres méthodes d'accès uniform, en passant l'emplacement de l'uniform comme l'une des entrées :</div>
+## Syntaxe
 
-<div> </div>
+    WebGLUniformLocation = WebGLRenderingContext.getUniformLocation(programme, nom);
 
-<dl>
- <dt>{{domxref ("WebGLRenderingContext.getUniform", "getUniform()")}}</dt>
- <dd>Retourne la valeur de l'uniform à l'emplacement indiqué.</dd>
- <dt><br>
- {{domxref ("WebGLRenderingContext.uniform", "uniform[1234] [fi] [v]()")}}</dt>
- <dd>Affecte à la valeur de l'uniform la valeur spécifiée, qui peut être un nombre flottant ou entier unique, ou un vecteur de 2 à 4 composantes spécifié soit comme une liste de valeurs, soit comme un {{jsxref ("Float32Array")}} ou un {{ jsxref ("Int32Array")}}.</dd>
- <dt><br>
- {{domxref ("WebGLRenderingContext.uniformMatrix", "uniformMatrix[234][fv]()")}}</dt>
- <dd>Affecte à la valeur de l'uniforme la matrice spécifiée, éventuellement avec transposition. La valeur est représentée comme une suite de valeurs GLfloat ou comme un Float32Array.</dd>
-</dl>
+### Paramètres
 
-<p><br>
- L'uniform lui-même est déclaré dans le programme shader en utilisant GLSL.</p>
+- `programme`
+  - : Le {{domxref ("WebGLProgram")}} dans lequel localiser la variable uniform indiquée.
+- `nom`
+  - : Une {{domxref ("DOMString")}} indiquant le nom de la variable uniform dont l'emplacement doit être retourné. Le nom ne peut contenir aucun espace, et vous ne pouvez pas utiliser cette fonction pour obtenir l'emplacement d'aucun uniform commençant par la chaîne réservée `"gl_"`, du fait que ceux-ci sont internes à la couche WebGL.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+### Valeur retournée
 
-<pre class="syntaxbox"><em>WebGLUniformLocation</em> = <em>WebGLRenderingContext</em>.getUniformLocation(<em>programme</em>, <em>nom</em>);
-</pre>
+Une valeur {{domxref ("WebGLUniformLocation")}} indiquant l'emplacement de la variable nommée, si elle existe. Si la variable indiquée n'existe pas, {{jsxref("null")}} est retourné à la place.
 
-<h3 id="Paramètres">Paramètres</h3>
+`WebGLUniformLocation` est une valeur opaque utilisée pour identifier de manière unique l'emplacement dans la mémoire de la GPU auquel se trouve la variable uniform. Avec cette valeur en main, vous pouvez appeler d'autres méthodes WebGL pour accéder à la valeur de la variable uniform.
 
-<dl>
- <dt><code>programme</code></dt>
- <dd>Le {{domxref ("WebGLProgram")}} dans lequel localiser la variable uniform indiquée.</dd>
- <dt><code>nom</code></dt>
- <dd>Une {{domxref ("DOMString")}} indiquant le nom de la variable uniform dont l'emplacement doit être retourné. Le nom ne peut contenir aucun espace, et vous ne pouvez pas utiliser cette fonction pour obtenir l'emplacement d'aucun uniform commençant par la chaîne réservée <code>"gl_"</code>, du fait que ceux-ci sont internes à la couche WebGL.</dd>
-</dl>
+> **Note :** Le type `WebGLUniformLocation` est compatible avec le type `GLint` pour indiquer l'indice ou l'emplacement d'un attribut uniform.
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+### Erreurs
 
-<p>Une valeur {{domxref ("WebGLUniformLocation")}} indiquant l'emplacement de la variable nommée, si elle existe. Si la variable indiquée n'existe pas, {{jsxref("null")}} est retourné à la place.</p>
+Les erreurs suivantes peuvent se produire ; pour vérifier les erreurs après le retour de getUniformLocation(), appelez {{domxref ("WebGLRenderingContext.getError", "getError()")}}.
 
-<p><code>WebGLUniformLocation</code> est une valeur opaque utilisée pour identifier de manière unique l'emplacement dans la mémoire de la GPU auquel se trouve la variable uniform. Avec cette valeur en main, vous pouvez appeler d'autres méthodes WebGL pour accéder à la valeur de la variable uniform.</p>
+- GL_INVALID_VALUE
+  - : Le paramètre `programme` n'est pas une valeur ou un objet généré par WebGL.
+- GL_INVALID_OPERATION
+  - : Le paramètre `programme` ne correspond pas à un programme GLSL généré par WebGL, ou le programme indiqué n'a pas été lié avec succès.
 
-<div class="note">
-<p><strong>Note :</strong> Le type <code>WebGLUniformLocation</code> est compatible avec le type <code>GLint</code> pour indiquer l'indice ou l'emplacement d'un attribut uniform.</p>
-</div>
+## Exemple
 
-<h3 id="Erreurs">Erreurs</h3>
+Dans cet exemple, extrait de la méthode `animateScene()` dans l'article [Un exemple d'animation 2D WebGL de base](/fr-FR/docs/Web/API/WebGL_API/Basic_2D_animation_example#Drawing_and_animating_the_scene), retrouve les emplacements de trois uniforms du programme d'ombrage, puis définit la valeur de chacun des trois uniforms.
 
-<p>Les erreurs suivantes peuvent se produire ; pour vérifier les erreurs après le retour de getUniformLocation(), appelez {{domxref ("WebGLRenderingContext.getError", "getError()")}}.</p>
-
-<dl>
- <dt>GL_INVALID_VALUE</dt>
- <dd>Le paramètre <code>programme</code> n'est pas une valeur ou un objet généré par WebGL.</dd>
- <dt>GL_INVALID_OPERATION</dt>
- <dd>Le paramètre <code>programme</code> ne correspond pas à un programme GLSL généré par WebGL, ou le programme indiqué n'a pas été lié avec succès.</dd>
-</dl>
-
-<h2 id="Exemple">Exemple</h2>
-
-<p>Dans cet exemple, extrait de la méthode <code>animateScene()</code> dans l'article <a href="/fr-FR/docs/Web/API/WebGL_API/Basic_2D_animation_example#Drawing_and_animating_the_scene">Un exemple d'animation 2D WebGL de base</a>, retrouve les emplacements de trois uniforms du programme d'ombrage, puis définit la valeur de chacun des trois uniforms.</p>
-
-<pre class="brush: js">gl.useProgram(programmeShader);
+```js
+gl.useProgram(programmeShader);
 
 uScalingFactor =
     gl.getUniformLocation(programmeShader, "uScalingFactor");
@@ -88,55 +69,52 @@ uRotationVector =
 
 gl.uniform2fv(uScalingFactor, currentScale);
 gl.uniform2fv(uRotationVector, currentRotation);
-gl.uniform4fv(uGlobalColor, [0.1, 0.7, 0.2, 1.0]);</pre>
+gl.uniform4fv(uGlobalColor, [0.1, 0.7, 0.2, 1.0]);
+```
 
-<div class="note">
-  <p><strong>Note :</strong> Cet extrait de code provient de <a href="/fr-FR/docs/Web/API/WebGL_API/Basic_2D_animation_example#Drawing_and_animating_the_scene">la fonction animateScene()</a> dans "Un exemple d'animation WebGL 2D de base". Voir cet article pour l'exemple complet et pour voir l'animation résultante en action.</p>
-</div>
+> **Note :** Cet extrait de code provient de [la fonction animateScene()](/fr-FR/docs/Web/API/WebGL_API/Basic_2D_animation_example#Drawing_and_animating_the_scene) dans "Un exemple d'animation WebGL 2D de base". Voir cet article pour l'exemple complet et pour voir l'animation résultante en action.
 
-<p>Après avoir défini le programme d'ombrage en cours comme <code>programmeShader</code>, ce code récupère les trois uniforms <code>"uScalingFactor"</code>, <code>"uGlobalColor"</code> et <code>"uRotationVector"</code>, en appelant <code>getUniformLocation()</code> une fois pour chaque uniform.</p>
+Après avoir défini le programme d'ombrage en cours comme `programmeShader`, ce code récupère les trois uniforms `"uScalingFactor"`, `"uGlobalColor"` et `"uRotationVector"`, en appelant `getUniformLocation()` une fois pour chaque uniform.
 
-<p>Ensuite, les valeurs des trois uniforms sont définies :</p>
+Ensuite, les valeurs des trois uniforms sont définies :
 
-<ul>
- <li>L'uniform <code>uScalingFactor</code> - un sommet à 2 composantes - reçoit les facteurs d'échelle horizontale et verticale à partir de la variable <code>currentScale</code>.</li>
- <li>L'uniform <code>uRotationVector</code> reçoit le contenu de la variable <code>currentRotation</code>. C'est également un sommet à deux composantes.</li>
- <li>Enfin, l'uniform <code>uGlobalColor</code> reçoit la couleur <code>[0.1, 0.7, 0.2, 1.0]</code>, les composants de ce vecteur à quatre composants représentant respectivement les valeurs rouge, vert, bleu et alpha.</li>
-</ul>
+- L'uniform `uScalingFactor` - un sommet à 2 composantes - reçoit les facteurs d'échelle horizontale et verticale à partir de la variable `currentScale`.
+- L'uniform `uRotationVector` reçoit le contenu de la variable `currentRotation`. C'est également un sommet à deux composantes.
+- Enfin, l'uniform `uGlobalColor` reçoit la couleur `[0.1, 0.7, 0.2, 1.0]`, les composants de ce vecteur à quatre composants représentant respectivement les valeurs rouge, vert, bleu et alpha.
 
-<p>Cela fait, la prochaine fois que les fonctions d'ombrage seront appelées, leurs propres variables nommées <code>uScalingFactor</code>, <code>uGlobalColor</code> et <code>uRotationVector</code> auront toutes les valeurs fournies par le code JavaScript.</p>
+Cela fait, la prochaine fois que les fonctions d'ombrage seront appelées, leurs propres variables nommées `uScalingFactor`, `uGlobalColor` et `uRotationVector` auront toutes les valeurs fournies par le code JavaScript.
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
 <table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.10", "getUniformLocation")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>
-    <p>Définition initiale.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glGetUniformLocation.xml", "glGetUniformLocation")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man de l’API OpenGL.</td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <th scope="col">Spécification</th>
+      <th scope="col">Statut</th>
+      <th scope="col">Commentaire</th>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('WebGL', "#5.14.10", "getUniformLocation")}}
+      </td>
+      <td>{{Spec2('WebGL')}}</td>
+      <td><p>Définition initiale.</p></td>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('OpenGL ES 2.0', "glGetUniformLocation.xml", "glGetUniformLocation")}}
+      </td>
+      <td>{{Spec2('OpenGL ES 2.0')}}</td>
+      <td>Page man de l’API OpenGL.</td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.WebGLRenderingContext.getUniformLocation")}}</p>
+{{Compat("api.WebGLRenderingContext.getUniformLocation")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{domxref("WebGLRenderingContext.getAttribLocation()")}}</li>
- <li>{{domxref("WebGLUniformLocation")}}</li>
-</ul>
+- {{domxref("WebGLRenderingContext.getAttribLocation()")}}
+- {{domxref("WebGLUniformLocation")}}
diff --git a/files/fr/web/api/webglrenderingcontext/index.md b/files/fr/web/api/webglrenderingcontext/index.md
index 437dbe6f19..4fd4ec5792 100644
--- a/files/fr/web/api/webglrenderingcontext/index.md
+++ b/files/fr/web/api/webglrenderingcontext/index.md
@@ -8,360 +8,320 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}L'interface **WebGLRenderingContext** fournit le contexte de rendu OpenGL ES 2.0 pour le dessin d'une suface dans un élément HTML {{HTMLElement("canvas")}}**.**
 
-<div>L'interface <strong>WebGLRenderingContext</strong> fournit le contexte de rendu OpenGL ES 2.0 pour le dessin d'une suface dans un élément HTML {{HTMLElement("canvas")}}<strong>.</strong></div>
+Pour obtenir une instance de cette interface, appelez {{domxref("HTMLCanvasElement.getContext()", "getContext()")}} sur un élément `<canvas>`, en spécifiant "webgl" en paramètre :
 
-<div> </div>
-
-<p>Pour obtenir une instance de cette interface, appelez {{domxref("HTMLCanvasElement.getContext()", "getContext()")}} sur un élément <code>&lt;canvas&gt;</code>, en spécifiant "webgl" en paramètre :</p>
-
-<pre class="brush: js">var canvas = document.getElementById('myCanvas');
+```js
+var canvas = document.getElementById('myCanvas');
 var gl = canvas.getContext('webgl');
-</pre>
-
-<p>Une fois que avez le contexte de rendu WebGL, vous pouvez dessiner à l'intérieur.</p>
-
-<p>Le <a href="/fr/docs/Web/API/WebGL_API/Tutorial">tutoriel WebGL</a> contient plus d'informations, d'exemples, et de ressources sur comment débuter en WebGL.</p>
-
-<h2 id="Constants">Constants</h2>
-
-<p>See the <a href="/en-US/docs/Web/API/WebGL_API/Constants">WebGL constants</a> page.</p>
-
-<h2 id="The_WebGL_context">The WebGL context</h2>
-
-<p>The following properties and methods provide general information and functionality to deal with the WebGL context:</p>
-
-<dl>
- <dt>{{domxref("WebGLRenderingContext.canvas")}}</dt>
- <dd>A read-only back-reference to the {{domxref("HTMLCanvasElement")}}. Might be {{jsxref("null")}} if it is not associated with a {{HTMLElement("canvas")}} element.</dd>
- <dt>{{domxref("WebGLRenderingContext.commit()")}} {{experimental_inline}}</dt>
- <dd>
- <p>Pushes frames back to the original {{domxref("HTMLCanvasElement")}}, if the context is not directly fixed to a specific canvas.</p>
- </dd>
- <dt>{{domxref("WebGLRenderingContext.drawingBufferWidth")}}</dt>
- <dd>The read-only width of the current drawing buffer. Should match the width of the canvas element associated with this context.</dd>
- <dt>{{domxref("WebGLRenderingContext.drawingBufferHeight")}}</dt>
- <dd>The read-only height of the current drawing buffer. Should match the height of the canvas element associated with this context.</dd>
- <dt>{{domxref("WebGLRenderingContext.getContextAttributes()")}}</dt>
- <dd>Returns a <code>WebGLContextAttributes</code> object that contains the actual context parameters. Might return {{jsxref("null")}}, if the context is lost.</dd>
- <dt>{{domxref("WebGLRenderingContext.isContextLost()")}}</dt>
- <dd>Returns <code>true</code> if the context is lost, otherwise returns <code>false</code>.</dd>
-</dl>
-
-<h2 id="Viewing_and_clipping">Viewing and clipping</h2>
-
-<dl>
- <dt>{{domxref("WebGLRenderingContext.scissor()")}}</dt>
- <dd>Defines the scissor box.</dd>
- <dt>{{domxref("WebGLRenderingContext.viewport()")}}</dt>
- <dd>Sets the viewport.</dd>
-</dl>
-
-<h2 id="State_information">State information</h2>
-
-<dl>
- <dt>{{domxref("WebGLRenderingContext.activeTexture()")}}</dt>
- <dd>Selects the active texture unit.</dd>
- <dt>{{domxref("WebGLRenderingContext.blendColor()")}}</dt>
- <dd>Sets the source and destination blending factors.</dd>
- <dt>{{domxref("WebGLRenderingContext.blendEquation()")}}</dt>
- <dd>Sets both the RGB blend equation and alpha blend equation to a single equation.</dd>
- <dt>{{domxref("WebGLRenderingContext.blendEquationSeparate()")}}</dt>
- <dd>Sets the RGB blend equation and alpha blend equation separately.</dd>
- <dt>{{domxref("WebGLRenderingContext.blendFunc()")}}</dt>
- <dd>Defines which function is used for blending pixel arithmetic.</dd>
- <dt>{{domxref("WebGLRenderingContext.blendFuncSeparate()")}}</dt>
- <dd>Defines which function is used for blending pixel arithmetic for RGB and alpha components separately.</dd>
- <dt>{{domxref("WebGLRenderingContext.clearColor()")}}</dt>
- <dd>Specifies the color values used when clearing color buffers.</dd>
- <dt>{{domxref("WebGLRenderingContext.clearDepth()")}}</dt>
- <dd>Specifies the depth value used when clearing the depth buffer.</dd>
- <dt>{{domxref("WebGLRenderingContext.clearStencil()")}}</dt>
- <dd>Specifies the stencil value used when clearing the stencil buffer.</dd>
- <dt>{{domxref("WebGLRenderingContext.colorMask()")}}</dt>
- <dd>Sets which color components to enable or to disable when drawing or rendering to a {{domxref("WebGLFramebuffer")}}.</dd>
- <dt>{{domxref("WebGLRenderingContext.cullFace()")}}</dt>
- <dd>Specifies whether or not front- and/or back-facing polygons can be culled.</dd>
- <dt>{{domxref("WebGLRenderingContext.depthFunc()")}}</dt>
- <dd>Specifies a function that compares incoming pixel depth to the current depth buffer value.</dd>
- <dt>{{domxref("WebGLRenderingContext.depthMask()")}}</dt>
- <dd>Sets whether writing into the depth buffer is enabled or disabled.</dd>
- <dt>{{domxref("WebGLRenderingContext.depthRange()")}}</dt>
- <dd>Specifies the depth range mapping from normalized device coordinates to window or viewport coordinates.</dd>
- <dt>{{domxref("WebGLRenderingContext.disable()")}}</dt>
- <dd>Disables specific WebGL capabilities for this context.</dd>
- <dt>{{domxref("WebGLRenderingContext.enable()")}}</dt>
- <dd>Enables specific WebGL capabilities for this context.</dd>
- <dt>{{domxref("WebGLRenderingContext.frontFace()")}}</dt>
- <dd>Specifies whether polygons are front- or back-facing by setting a winding orientation.</dd>
- <dt>{{domxref("WebGLRenderingContext.getParameter()")}}</dt>
- <dd>Returns a value for the passed parameter name.</dd>
- <dt>{{domxref("WebGLRenderingContext.getError()")}}</dt>
- <dd>Returns error information.</dd>
- <dt>{{domxref("WebGLRenderingContext.hint()")}}</dt>
- <dd>Specifies hints for certain behaviors. The interpretation of these hints depend on the implementation.</dd>
- <dt>{{domxref("WebGLRenderingContext.isEnabled()")}}</dt>
- <dd>Tests whether a specific WebGL capability is enabled or not for this context.</dd>
- <dt>{{domxref("WebGLRenderingContext.lineWidth()")}}</dt>
- <dd>Sets the line width of rasterized lines.</dd>
- <dt>{{domxref("WebGLRenderingContext.pixelStorei()")}}</dt>
- <dd>Specifies the pixel storage modes</dd>
- <dt>{{domxref("WebGLRenderingContext.polygonOffset()")}}</dt>
- <dd>Specifies the scale factors and units to calculate depth values.</dd>
- <dt>{{domxref("WebGLRenderingContext.sampleCoverage()")}}</dt>
- <dd>Specifies multi-sample coverage parameters for anti-aliasing effects.</dd>
- <dt>{{domxref("WebGLRenderingContext.stencilFunc()")}}</dt>
- <dd>Sets the both front and back function and reference value for stencil testing.</dd>
- <dt>{{domxref("WebGLRenderingContext.stencilFuncSeparate()")}}</dt>
- <dd>Sets the front and/or back function and reference value for stencil testing.</dd>
- <dt>{{domxref("WebGLRenderingContext.stencilMask()")}}</dt>
- <dd>Controls enabling and disabling of both the front and back writing of individual bits in the stencil planes.</dd>
- <dt>{{domxref("WebGLRenderingContext.stencilMaskSeparate()")}}</dt>
- <dd>Controls enabling and disabling of front and/or back writing of individual bits in the stencil planes.</dd>
- <dt>{{domxref("WebGLRenderingContext.stencilOp()")}}</dt>
- <dd>Sets both the front and back-facing stencil test actions.</dd>
- <dt>{{domxref("WebGLRenderingContext.stencilOpSeparate()")}}</dt>
- <dd>Sets the front and/or back-facing stencil test actions.</dd>
-</dl>
-
-<h2 id="Buffers">Buffers</h2>
-
-<dl>
- <dt>{{domxref("WebGLRenderingContext.bindBuffer()")}}</dt>
- <dd>Binds a <code>WebGLBuffer</code> object to a given target.</dd>
- <dt>{{domxref("WebGLRenderingContext.bufferData()")}}</dt>
- <dd>Updates buffer data.</dd>
- <dt>{{domxref("WebGLRenderingContext.bufferSubData()")}}</dt>
- <dd>Updates buffer data starting at a passed offset.</dd>
- <dt>{{domxref("WebGLRenderingContext.createBuffer()")}}</dt>
- <dd>Creates a <code>WebGLBuffer</code> object.</dd>
- <dt>{{domxref("WebGLRenderingContext.deleteBuffer()")}}</dt>
- <dd>Deletes a <code>WebGLBuffer</code> object.</dd>
- <dt>{{domxref("WebGLRenderingContext.getBufferParameter()")}}</dt>
- <dd>Returns information about the buffer.</dd>
- <dt>{{domxref("WebGLRenderingContext.isBuffer()")}}</dt>
- <dd>Returns a Boolean indicating if the passed buffer is valid.</dd>
-</dl>
-
-<h2 id="Framebuffers">Framebuffers</h2>
-
-<dl>
- <dt>{{domxref("WebGLRenderingContext.bindFramebuffer()")}}</dt>
- <dd>Binds a <code>WebGLFrameBuffer</code> object to a given target.</dd>
- <dt>{{domxref("WebGLRenderingContext.checkFramebufferStatus()")}}</dt>
- <dd>Returns the status of the framebuffer.</dd>
- <dt>{{domxref("WebGLRenderingContext.createFramebuffer()")}}</dt>
- <dd>Creates a <code>WebGLFrameBuffer</code> object.</dd>
- <dt>{{domxref("WebGLRenderingContext.deleteFramebuffer()")}}</dt>
- <dd>Deletes a <code>WebGLFrameBuffer</code> object.</dd>
- <dt>{{domxref("WebGLRenderingContext.framebufferRenderbuffer()")}}</dt>
- <dd>Attaches a <code>WebGLRenderingBuffer</code> object to a <code>WebGLFrameBuffer</code> object.</dd>
- <dt>{{domxref("WebGLRenderingContext.framebufferTexture2D()")}}</dt>
- <dd>Attaches a textures image to a <code>WebGLFrameBuffer</code> object.</dd>
- <dt>{{domxref("WebGLRenderingContext.getFramebufferAttachmentParameter()")}}</dt>
- <dd>Returns information about the framebuffer.</dd>
- <dt>{{domxref("WebGLRenderingContext.isFramebuffer()")}}</dt>
- <dd>Returns a Boolean indicating if the passed <code>WebGLFrameBuffer</code> object is valid.</dd>
- <dt>{{domxref("WebGLRenderingContext.readPixels()")}}</dt>
- <dd>Reads a block of pixels from the <code>WebGLFrameBuffer</code>.</dd>
-</dl>
-
-<h2 id="Renderbuffers">Renderbuffers</h2>
-
-<dl>
- <dt>{{domxref("WebGLRenderingContext.bindRenderbuffer()")}}</dt>
- <dd>Binds a <code>WebGLRenderBuffer</code> object to a given target.</dd>
- <dt>{{domxref("WebGLRenderingContext.createRenderbuffer()")}}</dt>
- <dd>Creates a <code>WebGLRenderBuffer</code> object.</dd>
- <dt>{{domxref("WebGLRenderingContext.deleteRenderbuffer()")}}</dt>
- <dd>Deletes a <code>WebGLRenderBuffer</code> object.</dd>
- <dt>{{domxref("WebGLRenderingContext.getRenderbufferParameter()")}}</dt>
- <dd>Returns information about the renderbuffer.</dd>
- <dt>{{domxref("WebGLRenderingContext.isRenderbuffer()")}}</dt>
- <dd>Returns a Boolean indicating if the passed <code>WebGLRenderingBuffer</code> is valid.</dd>
- <dt>{{domxref("WebGLRenderingContext.renderbufferStorage()")}}</dt>
- <dd>Creates a renderbuffer data store.</dd>
-</dl>
-
-<h2 id="Textures">Textures</h2>
-
-<dl>
- <dt>{{domxref("WebGLRenderingContext.bindTexture()")}}</dt>
- <dd>Binds a <code>WebGLTexture</code> object to a given target.</dd>
- <dt>{{domxref("WebGLRenderingContext.compressedTexImage2D()")}}</dt>
- <dd>Specifies a 2D texture image in a compressed format.</dd>
- <dt>{{domxref("WebGLRenderingContext.compressedTexSubImage2D()")}}</dt>
- <dd>Specifies a 2D texture sub-image in a compressed format.</dd>
- <dt>{{domxref("WebGLRenderingContext.copyTexImage2D()")}}</dt>
- <dd>Copies a 2D texture image.</dd>
- <dt>{{domxref("WebGLRenderingContext.copyTexSubImage2D()")}}</dt>
- <dd>Copies a 2D texture sub-image.</dd>
- <dt>{{domxref("WebGLRenderingContext.createTexture()")}}</dt>
- <dd>Creates a <code>WebGLTexture</code> object.</dd>
- <dt>{{domxref("WebGLRenderingContext.deleteTexture()")}}</dt>
- <dd>Deletes a <code>WebGLTexture</code> object.</dd>
- <dt>{{domxref("WebGLRenderingContext.generateMipmap()")}}</dt>
- <dd>Generates a set of mipmaps for a <code>WebGLTexture</code> object.</dd>
- <dt>{{domxref("WebGLRenderingContext.getTexParameter()")}}</dt>
- <dd>Returns information about the texture.</dd>
- <dt>{{domxref("WebGLRenderingContext.isTexture()")}}</dt>
- <dd>Returns a Boolean indicating if the passed <code>WebGLTexture</code> is valid.</dd>
- <dt>{{domxref("WebGLRenderingContext.texImage2D()")}}</dt>
- <dd>Specifies a 2D texture image.</dd>
- <dt>{{domxref("WebGLRenderingContext.texSubImage2D()")}}</dt>
- <dd>Updates a sub-rectangle of the current <code>WebGLTexture</code>.</dd>
- <dt>{{domxref("WebGLRenderingContext.texParameter", "WebGLRenderingContext.texParameterf()")}}</dt>
- <dd>Sets texture parameters.</dd>
- <dt>{{domxref("WebGLRenderingContext.texParameter", "WebGLRenderingContext.texParameteri()")}}</dt>
- <dd>Sets texture parameters.</dd>
-</dl>
-
-<h2 id="Programs_and_shaders">Programs and shaders</h2>
-
-<dl>
- <dt>{{domxref("WebGLRenderingContext.attachShader()")}}</dt>
- <dd>Attaches a <code>WebGLShader</code> to a <code>WebGLProgram</code>.</dd>
- <dt>{{domxref("WebGLRenderingContext.bindAttribLocation()")}}</dt>
- <dd>Binds a generic vertex index to a named attribute variable.</dd>
- <dt>{{domxref("WebGLRenderingContext.compileShader()")}}</dt>
- <dd>Compiles a <code>WebGLShader</code>.</dd>
- <dt>{{domxref("WebGLRenderingContext.createProgram()")}}</dt>
- <dd>Creates a <code>WebGLProgram</code>.</dd>
- <dt>{{domxref("WebGLRenderingContext.createShader()")}}</dt>
- <dd>Creates a <code>WebGLShader</code>.</dd>
- <dt>{{domxref("WebGLRenderingContext.deleteProgram()")}}</dt>
- <dd>Deletes a <code>WebGLProgram</code>.</dd>
- <dt>{{domxref("WebGLRenderingContext.deleteShader()")}}</dt>
- <dd>Deletes a <code>WebGLShader</code>.</dd>
- <dt>{{domxref("WebGLRenderingContext.detachShader()")}}</dt>
- <dd>Detaches a <code>WebGLShader</code>.</dd>
- <dt>{{domxref("WebGLRenderingContext.getAttachedShaders()")}}</dt>
- <dd>Returns a list of <code>WebGLShader</code> objects attached to a <code>WebGLProgram</code>.</dd>
- <dt>{{domxref("WebGLRenderingContext.getProgramParameter()")}}</dt>
- <dd>Returns information about the program.</dd>
- <dt>{{domxref("WebGLRenderingContext.getProgramInfoLog()")}}</dt>
- <dd>Returns the information log for a <code>WebGLProgram</code> object.</dd>
- <dt>{{domxref("WebGLRenderingContext.getShaderParameter()")}}</dt>
- <dd>Returns information about the shader.</dd>
- <dt>{{domxref("WebGLRenderingContext.getShaderPrecisionFormat()")}}</dt>
- <dd>Returns a <code>WebGLShaderPrecisionFormat</code> object describing the precision for the numeric format of the shader.</dd>
- <dt>{{domxref("WebGLRenderingContext.getShaderInfoLog()")}}</dt>
- <dd>Returns the information log for a <code>WebGLShader</code> object.</dd>
- <dt>{{domxref("WebGLRenderingContext.getShaderSource()")}}</dt>
- <dd>Returns the source code of a <code>WebGLShader</code> as a string.</dd>
- <dt>{{domxref("WebGLRenderingContext.isProgram()")}}</dt>
- <dd>Returns a Boolean indicating if the passed <code>WebGLProgram</code> is valid.</dd>
- <dt>{{domxref("WebGLRenderingContext.isShader()")}}</dt>
- <dd>Returns a Boolean indicating if the passed <code>WebGLShader</code> is valid.</dd>
- <dt>{{domxref("WebGLRenderingContext.linkProgram()")}}</dt>
- <dd>Links the passed <code>WebGLProgram</code> object.</dd>
- <dt>{{domxref("WebGLRenderingContext.shaderSource()")}}</dt>
- <dd>Sets the source code in a <code>WebGLShader</code>.</dd>
- <dt>{{domxref("WebGLRenderingContext.useProgram()")}}</dt>
- <dd>Uses the specified <code>WebGLProgram</code> as part the current rendering state.</dd>
- <dt>{{domxref("WebGLRenderingContext.validateProgram()")}}</dt>
- <dd>Validates a <code>WebGLProgram</code>.</dd>
-</dl>
-
-<h2 id="Uniforms_and_attributes">Uniforms and attributes</h2>
-
-<dl>
- <dt>{{domxref("WebGLRenderingContext.disableVertexAttribArray()")}}</dt>
- <dd>Disables a vertex attribute array at a given position.</dd>
- <dt>{{domxref("WebGLRenderingContext.enableVertexAttribArray()")}}</dt>
- <dd>Enables a vertex attribute array at a given position.</dd>
- <dt>{{domxref("WebGLRenderingContext.getActiveAttrib()")}}</dt>
- <dd>Returns information about an active attribute variable.</dd>
- <dt>{{domxref("WebGLRenderingContext.getActiveUniform()")}}</dt>
- <dd>Returns information about an active uniform variable.</dd>
- <dt>{{domxref("WebGLRenderingContext.getAttribLocation()")}}</dt>
- <dd>Returns the location of an attribute variable.</dd>
- <dt>{{domxref("WebGLRenderingContext.getUniform()")}}</dt>
- <dd>Returns the value of a uniform variable at a given location.</dd>
- <dt>{{domxref("WebGLRenderingContext.getUniformLocation()")}}</dt>
- <dd>Returns the location of a uniform variable.</dd>
- <dt>{{domxref("WebGLRenderingContext.getVertexAttrib()")}}</dt>
- <dd>Returns information about a vertex attribute at a given position.</dd>
- <dt>{{domxref("WebGLRenderingContext.getVertexAttribOffset()")}}</dt>
- <dd>Returns the address of a given vertex attribute.</dd>
- <dt>{{domxref("WebGLRenderingContext.uniform()", "WebGLRenderingContext.uniform[1234][fi][v]()")}}</dt>
- <dd>Specifies a value for a uniform variable.</dd>
- <dt>{{domxref("WebGLRenderingContext.uniformMatrix()", "WebGLRenderingContext.uniformMatrix[234]fv()")}}</dt>
- <dd>Specifies a matrix value for a uniform variable.</dd>
- <dt>{{domxref("WebGLRenderingContext.vertexAttrib()", "WebGLRenderingContext.vertexAttrib[1234]f[v]()")}}</dt>
- <dd>Specifies a value for a generic vertex attribute.</dd>
- <dt>{{domxref("WebGLRenderingContext.vertexAttribPointer()")}}</dt>
- <dd>Specifies the data formats and locations of vertex attributes in a vertex attributes array.</dd>
-</dl>
-
-<h2 id="Drawing_buffers">Drawing buffers</h2>
-
-<dl>
- <dt>{{domxref("WebGLRenderingContext.clear()")}}</dt>
- <dd>Clears specified buffers to preset values.</dd>
- <dt>{{domxref("WebGLRenderingContext.drawArrays()")}}</dt>
- <dd>Renders primitives from array data.</dd>
- <dt>{{domxref("WebGLRenderingContext.drawElements()")}}</dt>
- <dd>Renders primitives from element array data.</dd>
- <dt>{{domxref("WebGLRenderingContext.finish()")}}</dt>
- <dd>Blocks execution until all previously called commands are finished.</dd>
- <dt>{{domxref("WebGLRenderingContext.flush()")}}</dt>
- <dd>Empties different buffer commands, causing all commands to be executed as quickly as possible.</dd>
-</dl>
-
-<h2 id="Working_with_extensions">Working with extensions</h2>
-
-<p>These methods manage WebGL extensions:</p>
-
-<dl>
- <dt>{{domxref("WebGLRenderingContext.getSupportedExtensions()")}}</dt>
- <dd>Returns an {{jsxref("Array")}} of {{domxref("DOMString")}} elements with all the supported WebGL extensions.</dd>
- <dt>{{domxref("WebGLRenderingContext.getExtension()")}}</dt>
- <dd>Returns an extension object.</dd>
-</dl>
-
-<h2 id="Examples">Examples</h2>
-
-<h3 id="WebGL_context_feature_detection">WebGL context feature detection</h3>
-
-<p>{{page("/en-US/Learn/WebGL/By_example/Detect_WebGL", "summary")}}</p>
-
-<p>{{page("/en-US/Learn/WebGL/By_example/Detect_WebGL", "detect-webgl-source")}}</p>
-
-<p>{{EmbedLiveSample("detect-webgl-source", 660,150 ,"" , "Learn/WebGL/By_example/Detect_WebGL")}}</p>
-
-<h3 id="Effect_of_canvas_size_on_rendering_with_WebGL">Effect of canvas size on rendering with WebGL</h3>
-
-<p>{{page("/en-US/Learn/WebGL/By_example/Canvas_size_and_WebGL", "canvas-size-and-webgl-intro")}}</p>
-
-<p>{{page("/en-US/Learn/WebGL/By_example/Canvas_size_and_WebGL", "canvas-size-and-webgl-source")}}</p>
-
-<p>{{EmbedLiveSample("canvas-size-and-webgl-source", 660,180 ,"" , "Learn/WebGL/By_example/Canvas_size_and_WebGL")}}</p>
-
-<h2 id="Specifications">Specifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14", "WebGLRenderingContext")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Initial definition</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Browser compatibility</h2>
-
-<p>{{Compat("api/WebGLRenderingContext", "WebGLRenderingContext")}}</p>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li>{{domxref("HTMLCanvasElement")}}</li>
-</ul>
+```
+
+Une fois que avez le contexte de rendu WebGL, vous pouvez dessiner à l'intérieur.
+
+Le [tutoriel WebGL](/fr/docs/Web/API/WebGL_API/Tutorial) contient plus d'informations, d'exemples, et de ressources sur comment débuter en WebGL.
+
+## Constants
+
+See the [WebGL constants](/en-US/docs/Web/API/WebGL_API/Constants) page.
+
+## The WebGL context
+
+The following properties and methods provide general information and functionality to deal with the WebGL context:
+
+- {{domxref("WebGLRenderingContext.canvas")}}
+  - : A read-only back-reference to the {{domxref("HTMLCanvasElement")}}. Might be {{jsxref("null")}} if it is not associated with a {{HTMLElement("canvas")}} element.
+- {{domxref("WebGLRenderingContext.commit()")}} {{experimental_inline}}
+  - : Pushes frames back to the original {{domxref("HTMLCanvasElement")}}, if the context is not directly fixed to a specific canvas.
+- {{domxref("WebGLRenderingContext.drawingBufferWidth")}}
+  - : The read-only width of the current drawing buffer. Should match the width of the canvas element associated with this context.
+- {{domxref("WebGLRenderingContext.drawingBufferHeight")}}
+  - : The read-only height of the current drawing buffer. Should match the height of the canvas element associated with this context.
+- {{domxref("WebGLRenderingContext.getContextAttributes()")}}
+  - : Returns a `WebGLContextAttributes` object that contains the actual context parameters. Might return {{jsxref("null")}}, if the context is lost.
+- {{domxref("WebGLRenderingContext.isContextLost()")}}
+  - : Returns `true` if the context is lost, otherwise returns `false`.
+
+## Viewing and clipping
+
+- {{domxref("WebGLRenderingContext.scissor()")}}
+  - : Defines the scissor box.
+- {{domxref("WebGLRenderingContext.viewport()")}}
+  - : Sets the viewport.
+
+## State information
+
+- {{domxref("WebGLRenderingContext.activeTexture()")}}
+  - : Selects the active texture unit.
+- {{domxref("WebGLRenderingContext.blendColor()")}}
+  - : Sets the source and destination blending factors.
+- {{domxref("WebGLRenderingContext.blendEquation()")}}
+  - : Sets both the RGB blend equation and alpha blend equation to a single equation.
+- {{domxref("WebGLRenderingContext.blendEquationSeparate()")}}
+  - : Sets the RGB blend equation and alpha blend equation separately.
+- {{domxref("WebGLRenderingContext.blendFunc()")}}
+  - : Defines which function is used for blending pixel arithmetic.
+- {{domxref("WebGLRenderingContext.blendFuncSeparate()")}}
+  - : Defines which function is used for blending pixel arithmetic for RGB and alpha components separately.
+- {{domxref("WebGLRenderingContext.clearColor()")}}
+  - : Specifies the color values used when clearing color buffers.
+- {{domxref("WebGLRenderingContext.clearDepth()")}}
+  - : Specifies the depth value used when clearing the depth buffer.
+- {{domxref("WebGLRenderingContext.clearStencil()")}}
+  - : Specifies the stencil value used when clearing the stencil buffer.
+- {{domxref("WebGLRenderingContext.colorMask()")}}
+  - : Sets which color components to enable or to disable when drawing or rendering to a {{domxref("WebGLFramebuffer")}}.
+- {{domxref("WebGLRenderingContext.cullFace()")}}
+  - : Specifies whether or not front- and/or back-facing polygons can be culled.
+- {{domxref("WebGLRenderingContext.depthFunc()")}}
+  - : Specifies a function that compares incoming pixel depth to the current depth buffer value.
+- {{domxref("WebGLRenderingContext.depthMask()")}}
+  - : Sets whether writing into the depth buffer is enabled or disabled.
+- {{domxref("WebGLRenderingContext.depthRange()")}}
+  - : Specifies the depth range mapping from normalized device coordinates to window or viewport coordinates.
+- {{domxref("WebGLRenderingContext.disable()")}}
+  - : Disables specific WebGL capabilities for this context.
+- {{domxref("WebGLRenderingContext.enable()")}}
+  - : Enables specific WebGL capabilities for this context.
+- {{domxref("WebGLRenderingContext.frontFace()")}}
+  - : Specifies whether polygons are front- or back-facing by setting a winding orientation.
+- {{domxref("WebGLRenderingContext.getParameter()")}}
+  - : Returns a value for the passed parameter name.
+- {{domxref("WebGLRenderingContext.getError()")}}
+  - : Returns error information.
+- {{domxref("WebGLRenderingContext.hint()")}}
+  - : Specifies hints for certain behaviors. The interpretation of these hints depend on the implementation.
+- {{domxref("WebGLRenderingContext.isEnabled()")}}
+  - : Tests whether a specific WebGL capability is enabled or not for this context.
+- {{domxref("WebGLRenderingContext.lineWidth()")}}
+  - : Sets the line width of rasterized lines.
+- {{domxref("WebGLRenderingContext.pixelStorei()")}}
+  - : Specifies the pixel storage modes
+- {{domxref("WebGLRenderingContext.polygonOffset()")}}
+  - : Specifies the scale factors and units to calculate depth values.
+- {{domxref("WebGLRenderingContext.sampleCoverage()")}}
+  - : Specifies multi-sample coverage parameters for anti-aliasing effects.
+- {{domxref("WebGLRenderingContext.stencilFunc()")}}
+  - : Sets the both front and back function and reference value for stencil testing.
+- {{domxref("WebGLRenderingContext.stencilFuncSeparate()")}}
+  - : Sets the front and/or back function and reference value for stencil testing.
+- {{domxref("WebGLRenderingContext.stencilMask()")}}
+  - : Controls enabling and disabling of both the front and back writing of individual bits in the stencil planes.
+- {{domxref("WebGLRenderingContext.stencilMaskSeparate()")}}
+  - : Controls enabling and disabling of front and/or back writing of individual bits in the stencil planes.
+- {{domxref("WebGLRenderingContext.stencilOp()")}}
+  - : Sets both the front and back-facing stencil test actions.
+- {{domxref("WebGLRenderingContext.stencilOpSeparate()")}}
+  - : Sets the front and/or back-facing stencil test actions.
+
+## Buffers
+
+- {{domxref("WebGLRenderingContext.bindBuffer()")}}
+  - : Binds a `WebGLBuffer` object to a given target.
+- {{domxref("WebGLRenderingContext.bufferData()")}}
+  - : Updates buffer data.
+- {{domxref("WebGLRenderingContext.bufferSubData()")}}
+  - : Updates buffer data starting at a passed offset.
+- {{domxref("WebGLRenderingContext.createBuffer()")}}
+  - : Creates a `WebGLBuffer` object.
+- {{domxref("WebGLRenderingContext.deleteBuffer()")}}
+  - : Deletes a `WebGLBuffer` object.
+- {{domxref("WebGLRenderingContext.getBufferParameter()")}}
+  - : Returns information about the buffer.
+- {{domxref("WebGLRenderingContext.isBuffer()")}}
+  - : Returns a Boolean indicating if the passed buffer is valid.
+
+## Framebuffers
+
+- {{domxref("WebGLRenderingContext.bindFramebuffer()")}}
+  - : Binds a `WebGLFrameBuffer` object to a given target.
+- {{domxref("WebGLRenderingContext.checkFramebufferStatus()")}}
+  - : Returns the status of the framebuffer.
+- {{domxref("WebGLRenderingContext.createFramebuffer()")}}
+  - : Creates a `WebGLFrameBuffer` object.
+- {{domxref("WebGLRenderingContext.deleteFramebuffer()")}}
+  - : Deletes a `WebGLFrameBuffer` object.
+- {{domxref("WebGLRenderingContext.framebufferRenderbuffer()")}}
+  - : Attaches a `WebGLRenderingBuffer` object to a `WebGLFrameBuffer` object.
+- {{domxref("WebGLRenderingContext.framebufferTexture2D()")}}
+  - : Attaches a textures image to a `WebGLFrameBuffer` object.
+- {{domxref("WebGLRenderingContext.getFramebufferAttachmentParameter()")}}
+  - : Returns information about the framebuffer.
+- {{domxref("WebGLRenderingContext.isFramebuffer()")}}
+  - : Returns a Boolean indicating if the passed `WebGLFrameBuffer` object is valid.
+- {{domxref("WebGLRenderingContext.readPixels()")}}
+  - : Reads a block of pixels from the `WebGLFrameBuffer`.
+
+## Renderbuffers
+
+- {{domxref("WebGLRenderingContext.bindRenderbuffer()")}}
+  - : Binds a `WebGLRenderBuffer` object to a given target.
+- {{domxref("WebGLRenderingContext.createRenderbuffer()")}}
+  - : Creates a `WebGLRenderBuffer` object.
+- {{domxref("WebGLRenderingContext.deleteRenderbuffer()")}}
+  - : Deletes a `WebGLRenderBuffer` object.
+- {{domxref("WebGLRenderingContext.getRenderbufferParameter()")}}
+  - : Returns information about the renderbuffer.
+- {{domxref("WebGLRenderingContext.isRenderbuffer()")}}
+  - : Returns a Boolean indicating if the passed `WebGLRenderingBuffer` is valid.
+- {{domxref("WebGLRenderingContext.renderbufferStorage()")}}
+  - : Creates a renderbuffer data store.
+
+## Textures
+
+- {{domxref("WebGLRenderingContext.bindTexture()")}}
+  - : Binds a `WebGLTexture` object to a given target.
+- {{domxref("WebGLRenderingContext.compressedTexImage2D()")}}
+  - : Specifies a 2D texture image in a compressed format.
+- {{domxref("WebGLRenderingContext.compressedTexSubImage2D()")}}
+  - : Specifies a 2D texture sub-image in a compressed format.
+- {{domxref("WebGLRenderingContext.copyTexImage2D()")}}
+  - : Copies a 2D texture image.
+- {{domxref("WebGLRenderingContext.copyTexSubImage2D()")}}
+  - : Copies a 2D texture sub-image.
+- {{domxref("WebGLRenderingContext.createTexture()")}}
+  - : Creates a `WebGLTexture` object.
+- {{domxref("WebGLRenderingContext.deleteTexture()")}}
+  - : Deletes a `WebGLTexture` object.
+- {{domxref("WebGLRenderingContext.generateMipmap()")}}
+  - : Generates a set of mipmaps for a `WebGLTexture` object.
+- {{domxref("WebGLRenderingContext.getTexParameter()")}}
+  - : Returns information about the texture.
+- {{domxref("WebGLRenderingContext.isTexture()")}}
+  - : Returns a Boolean indicating if the passed `WebGLTexture` is valid.
+- {{domxref("WebGLRenderingContext.texImage2D()")}}
+  - : Specifies a 2D texture image.
+- {{domxref("WebGLRenderingContext.texSubImage2D()")}}
+  - : Updates a sub-rectangle of the current `WebGLTexture`.
+- {{domxref("WebGLRenderingContext.texParameter", "WebGLRenderingContext.texParameterf()")}}
+  - : Sets texture parameters.
+- {{domxref("WebGLRenderingContext.texParameter", "WebGLRenderingContext.texParameteri()")}}
+  - : Sets texture parameters.
+
+## Programs and shaders
+
+- {{domxref("WebGLRenderingContext.attachShader()")}}
+  - : Attaches a `WebGLShader` to a `WebGLProgram`.
+- {{domxref("WebGLRenderingContext.bindAttribLocation()")}}
+  - : Binds a generic vertex index to a named attribute variable.
+- {{domxref("WebGLRenderingContext.compileShader()")}}
+  - : Compiles a `WebGLShader`.
+- {{domxref("WebGLRenderingContext.createProgram()")}}
+  - : Creates a `WebGLProgram`.
+- {{domxref("WebGLRenderingContext.createShader()")}}
+  - : Creates a `WebGLShader`.
+- {{domxref("WebGLRenderingContext.deleteProgram()")}}
+  - : Deletes a `WebGLProgram`.
+- {{domxref("WebGLRenderingContext.deleteShader()")}}
+  - : Deletes a `WebGLShader`.
+- {{domxref("WebGLRenderingContext.detachShader()")}}
+  - : Detaches a `WebGLShader`.
+- {{domxref("WebGLRenderingContext.getAttachedShaders()")}}
+  - : Returns a list of `WebGLShader` objects attached to a `WebGLProgram`.
+- {{domxref("WebGLRenderingContext.getProgramParameter()")}}
+  - : Returns information about the program.
+- {{domxref("WebGLRenderingContext.getProgramInfoLog()")}}
+  - : Returns the information log for a `WebGLProgram` object.
+- {{domxref("WebGLRenderingContext.getShaderParameter()")}}
+  - : Returns information about the shader.
+- {{domxref("WebGLRenderingContext.getShaderPrecisionFormat()")}}
+  - : Returns a `WebGLShaderPrecisionFormat` object describing the precision for the numeric format of the shader.
+- {{domxref("WebGLRenderingContext.getShaderInfoLog()")}}
+  - : Returns the information log for a `WebGLShader` object.
+- {{domxref("WebGLRenderingContext.getShaderSource()")}}
+  - : Returns the source code of a `WebGLShader` as a string.
+- {{domxref("WebGLRenderingContext.isProgram()")}}
+  - : Returns a Boolean indicating if the passed `WebGLProgram` is valid.
+- {{domxref("WebGLRenderingContext.isShader()")}}
+  - : Returns a Boolean indicating if the passed `WebGLShader` is valid.
+- {{domxref("WebGLRenderingContext.linkProgram()")}}
+  - : Links the passed `WebGLProgram` object.
+- {{domxref("WebGLRenderingContext.shaderSource()")}}
+  - : Sets the source code in a `WebGLShader`.
+- {{domxref("WebGLRenderingContext.useProgram()")}}
+  - : Uses the specified `WebGLProgram` as part the current rendering state.
+- {{domxref("WebGLRenderingContext.validateProgram()")}}
+  - : Validates a `WebGLProgram`.
+
+## Uniforms and attributes
+
+- {{domxref("WebGLRenderingContext.disableVertexAttribArray()")}}
+  - : Disables a vertex attribute array at a given position.
+- {{domxref("WebGLRenderingContext.enableVertexAttribArray()")}}
+  - : Enables a vertex attribute array at a given position.
+- {{domxref("WebGLRenderingContext.getActiveAttrib()")}}
+  - : Returns information about an active attribute variable.
+- {{domxref("WebGLRenderingContext.getActiveUniform()")}}
+  - : Returns information about an active uniform variable.
+- {{domxref("WebGLRenderingContext.getAttribLocation()")}}
+  - : Returns the location of an attribute variable.
+- {{domxref("WebGLRenderingContext.getUniform()")}}
+  - : Returns the value of a uniform variable at a given location.
+- {{domxref("WebGLRenderingContext.getUniformLocation()")}}
+  - : Returns the location of a uniform variable.
+- {{domxref("WebGLRenderingContext.getVertexAttrib()")}}
+  - : Returns information about a vertex attribute at a given position.
+- {{domxref("WebGLRenderingContext.getVertexAttribOffset()")}}
+  - : Returns the address of a given vertex attribute.
+- {{domxref("WebGLRenderingContext.uniform()", "WebGLRenderingContext.uniform[1234][fi][v]()")}}
+  - : Specifies a value for a uniform variable.
+- {{domxref("WebGLRenderingContext.uniformMatrix()", "WebGLRenderingContext.uniformMatrix[234]fv()")}}
+  - : Specifies a matrix value for a uniform variable.
+- {{domxref("WebGLRenderingContext.vertexAttrib()", "WebGLRenderingContext.vertexAttrib[1234]f[v]()")}}
+  - : Specifies a value for a generic vertex attribute.
+- {{domxref("WebGLRenderingContext.vertexAttribPointer()")}}
+  - : Specifies the data formats and locations of vertex attributes in a vertex attributes array.
+
+## Drawing buffers
+
+- {{domxref("WebGLRenderingContext.clear()")}}
+  - : Clears specified buffers to preset values.
+- {{domxref("WebGLRenderingContext.drawArrays()")}}
+  - : Renders primitives from array data.
+- {{domxref("WebGLRenderingContext.drawElements()")}}
+  - : Renders primitives from element array data.
+- {{domxref("WebGLRenderingContext.finish()")}}
+  - : Blocks execution until all previously called commands are finished.
+- {{domxref("WebGLRenderingContext.flush()")}}
+  - : Empties different buffer commands, causing all commands to be executed as quickly as possible.
+
+## Working with extensions
+
+These methods manage WebGL extensions:
+
+- {{domxref("WebGLRenderingContext.getSupportedExtensions()")}}
+  - : Returns an {{jsxref("Array")}} of {{domxref("DOMString")}} elements with all the supported WebGL extensions.
+- {{domxref("WebGLRenderingContext.getExtension()")}}
+  - : Returns an extension object.
+
+## Examples
+
+### WebGL context feature detection
+
+{{page("/en-US/Learn/WebGL/By_example/Detect_WebGL", "summary")}}
+
+{{page("/en-US/Learn/WebGL/By_example/Detect_WebGL", "detect-webgl-source")}}
+
+{{EmbedLiveSample("detect-webgl-source", 660,150 ,"" , "Learn/WebGL/By_example/Detect_WebGL")}}
+
+### Effect of canvas size on rendering with WebGL
+
+{{page("/en-US/Learn/WebGL/By_example/Canvas_size_and_WebGL", "canvas-size-and-webgl-intro")}}
+
+{{page("/en-US/Learn/WebGL/By_example/Canvas_size_and_WebGL", "canvas-size-and-webgl-source")}}
+
+{{EmbedLiveSample("canvas-size-and-webgl-source", 660,180 ,"" , "Learn/WebGL/By_example/Canvas_size_and_WebGL")}}
+
+## Specifications
+
+| Specification                                                            | Status                   | Comment            |
+| ------------------------------------------------------------------------ | ------------------------ | ------------------ |
+| {{SpecName('WebGL', "#5.14", "WebGLRenderingContext")}} | {{Spec2('WebGL')}} | Initial definition |
+
+## Browser compatibility
+
+{{Compat("api/WebGLRenderingContext", "WebGLRenderingContext")}}
+
+## See also
+
+- {{domxref("HTMLCanvasElement")}}
diff --git a/files/fr/web/api/webglrenderingcontext/isbuffer/index.md b/files/fr/web/api/webglrenderingcontext/isbuffer/index.md
index 8a10a0f09c..bc696a54f4 100644
--- a/files/fr/web/api/webglrenderingcontext/isbuffer/index.md
+++ b/files/fr/web/api/webglrenderingcontext/isbuffer/index.md
@@ -8,70 +8,66 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/isBuffer
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La méthode <strong><code>WebGLRenderingContext.isBuffer()</code></strong> de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> renvoie <code>true</code> si le {{domxref ("WebGLBuffer")}} passé est valide et <code>false</code> dans le cas contraire.</p>
+La méthode **`WebGLRenderingContext.isBuffer()`** de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API) renvoie `true` si le {{domxref ("WebGLBuffer")}} passé est valide et `false` dans le cas contraire.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">GLboolean <var>gl</var>.isBuffer(<var>tampon</var>);
-</pre>
+    GLboolean gl.isBuffer(tampon);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt>tampon</dt>
- <dd>Un {{domxref("WebGLBuffer")}} à vérifier.</dd>
-</dl>
+- tampon
+  - : Un {{domxref("WebGLBuffer")}} à vérifier.
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+### Valeur retournée
 
-<p>Un {{domxref("GLboolean")}} indiquant si le tampon est ou non valide.</p>
+Un {{domxref("GLboolean")}} indiquant si le tampon est ou non valide.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Création_d'un_tampon">Création d'un tampon</h3>
+### Création d'un tampon
 
-<pre class="brush: js">var canevas = document.getElementById('canevas');
+```js
+var canevas = document.getElementById('canevas');
 var gl = canevas.getContext('webgl');
 var tampon = gl.createBuffer();
 
 gl.isBuffer(tampon);
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
 <table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.5", "isBuffer")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glIsBuffer.xml", "glIsBuffer")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>
-    <p>Page man de l’API OpenGL.</p>
-   </td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <th scope="col">Spécification</th>
+      <th scope="col">Statut</th>
+      <th scope="col">Commentaire</th>
+    </tr>
+    <tr>
+      <td>{{SpecName('WebGL', "#5.14.5", "isBuffer")}}</td>
+      <td>{{Spec2('WebGL')}}</td>
+      <td>Définition initiale.</td>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('OpenGL ES 2.0', "glIsBuffer.xml", "glIsBuffer")}}
+      </td>
+      <td>{{Spec2('OpenGL ES 2.0')}}</td>
+      <td><p>Page man de l’API OpenGL.</p></td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.WebGLRenderingContext.isBuffer")}}</p>
+{{Compat("api.WebGLRenderingContext.isBuffer")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{domxref("WebGLRenderingContext.bindBuffer()")}}</li>
- <li>{{domxref("WebGLRenderingContext.createBuffer()")}}</li>
- <li>{{domxref("WebGLRenderingContext.deleteBuffer()")}}</li>
- <li>Autres tampons : {{domxref("WebGLFramebuffer")}}, {{domxref("WebGLRenderbuffer")}}</li>
-</ul>
+- {{domxref("WebGLRenderingContext.bindBuffer()")}}
+- {{domxref("WebGLRenderingContext.createBuffer()")}}
+- {{domxref("WebGLRenderingContext.deleteBuffer()")}}
+- Autres tampons : {{domxref("WebGLFramebuffer")}}, {{domxref("WebGLRenderbuffer")}}
diff --git a/files/fr/web/api/webglrenderingcontext/shadersource/index.md b/files/fr/web/api/webglrenderingcontext/shadersource/index.md
index 7825a72f7b..91b7d1629e 100644
--- a/files/fr/web/api/webglrenderingcontext/shadersource/index.md
+++ b/files/fr/web/api/webglrenderingcontext/shadersource/index.md
@@ -9,66 +9,48 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/shaderSource
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La méthode <strong><code>WebGLRenderingContext.shaderSource()</code></strong> de l'<a href="/en-US/docs/Web/API/WebGL_API">API WebGL</a> définit le code source d'un {{domxref("WebGLShader")}}.</p>
+La méthode **`WebGLRenderingContext.shaderSource()`** de l'[API WebGL](/en-US/docs/Web/API/WebGL_API) définit le code source d'un {{domxref("WebGLShader")}}.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">void <var>gl</var>.shaderSource(<var>shader</var>, <var>source</var>);
-</pre>
+    void gl.shaderSource(shader, source);
 
-<h3 id="Parameters">Parameters</h3>
+### Parameters
 
-<dl>
- <dt>shader</dt>
- <dd>Un objet {{domxref("WebGLShader")}} dans lequel définir le code source.</dd>
- <dt>source</dt>
- <dd>Une {{domxref("DOMString")}} contenant le code source GLSL à définir.</dd>
-</dl>
+- shader
+  - : Un objet {{domxref("WebGLShader")}} dans lequel définir le code source.
+- source
+  - : Une {{domxref("DOMString")}} contenant le code source GLSL à définir.
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+### Valeur retournée
 
-<p>Aucune.</p>
+Aucune.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<pre class="brush: js">var shader = gl.createShader(gl.VERTEX_SHADER);
+```js
+var shader = gl.createShader(gl.VERTEX_SHADER);
 gl.shaderSource(shader, originalSource);
 
-var source = gl.getShaderSource(shader);</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.9", "shaderSource")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glShaderSource.xml", "glShaderSource")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man de l'API OpenGL (similaire).</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.WebGLRenderingContext.shaderSource")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("WebGLRenderingContext.createShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.isShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.deleteShader()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getShaderSource()")}}</li>
-</ul>
+var source = gl.getShaderSource(shader);
+```
+
+## Spécifications
+
+| Spécification                                                                                | Statut                               | Commentaire                           |
+| -------------------------------------------------------------------------------------------- | ------------------------------------ | ------------------------------------- |
+| {{SpecName('WebGL', "#5.14.9", "shaderSource")}}                             | {{Spec2('WebGL')}}             | Définition initiale.                  |
+| {{SpecName('OpenGL ES 2.0', "glShaderSource.xml", "glShaderSource")}} | {{Spec2('OpenGL ES 2.0')}} | Page man de l'API OpenGL (similaire). |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.WebGLRenderingContext.shaderSource")}}
+
+## Voir aussi
+
+- {{domxref("WebGLRenderingContext.createShader()")}}
+- {{domxref("WebGLRenderingContext.isShader()")}}
+- {{domxref("WebGLRenderingContext.deleteShader()")}}
+- {{domxref("WebGLRenderingContext.getShaderSource()")}}
diff --git a/files/fr/web/api/webglrenderingcontext/teximage2d/index.md b/files/fr/web/api/webglrenderingcontext/teximage2d/index.md
index af95e8f3c8..c8d54e80c9 100644
--- a/files/fr/web/api/webglrenderingcontext/teximage2d/index.md
+++ b/files/fr/web/api/webglrenderingcontext/teximage2d/index.md
@@ -10,231 +10,217 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/texImage2D
 ---
-<div>{{APIRef("WebGL")}}</div>
-
-<p>La méthode <strong><code>WebGLRenderingContext.texImage2D()</code></strong> de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> spécifie une image de texture bidimensionnelle.</p>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">// WebGL1:
-void <var>gl</var>.texImage2D(<var>cible</var>, <var>niveau</var>, <var>formatinterne</var>, <var>largeur</var>, <var>hauteur</var>, <var>bordure</var>, <var>format</var>, <var>type</var>, ArrayBufferView? <var>pixels</var>);
-void <var>gl</var>.texImage2D(<var>cible</var>, <var>niveau</var>, <var>formatinterne</var>, <var>format</var>, <var>type</var>, ImageData? <var>pixels</var>);
-void <var>gl</var>.texImage2D(<var>cible</var>, <var>niveau</var>, <var>formatinterne</var>, <var>format</var>, <var>type</var>, HTMLImageElement? <var>pixels</var>);
-void <var>gl</var>.texImage2D(<var>cible</var>, <var>niveau</var>, <var>formatinterne</var>, <var>format</var>, <var>type</var>, HTMLCanvasElement? <var>pixels</var>);
-void <var>gl</var>.texImage2D(<var>cible</var>, <var>niveau</var>, <var>formatinterne</var>, <var>format</var>, <var>type</var>, HTMLVideoElement? <var>pixels</var>);
-void <var>gl</var>.texImage2D(<var>cible</var>, <var>niveau</var>, <var>formatinterne</var>, <var>format</var>, <var>type</var>, ImageBitmap? <var>pixels</var>);
-
-// WebGL2:
-void gl.texImage2D(<var>cible</var>, <var>niveau</var>, <var>formatinterne</var>, <var>largeur</var>, <var>hauteur</var>, <var>bordure</var>, <var>format</var>, <var>type</var>, GLintptr <em>decalage</em>);
-void gl.texImage2D(<var>cible</var>, <var>niveau</var>, <var>formatinterne</var>, <var>largeur</var>, <var>hauteur</var>, <var>bordure</var>, <var>format</var>, <var>type</var>, HTMLCanvasElement <em>source</em>);
-void gl.texImage2D(<var>cible</var>, <var>niveau</var>, <var>formatinterne</var>, <var>largeur</var>, <var>hauteur</var>, <var>bordure</var>, <var>format</var>, <var>type</var>, HTMLImageElement <em>source</em>);
-void gl.texImage2D(<var>cible</var>, <var>niveau</var>, <var>formatinterne</var>, <var>largeur</var>, <var>hauteur</var>, <var>bordure</var><em>, format, type</em>, HTMLVideoElement <em>source</em>);
-void gl.texImage2D(<var>cible</var>, <var>niveau</var>, <var>formatinterne</var>, <var>largeur</var>, <var>hauteur</var>, <var>bordure</var><em>, format, type</em>, ImageBitmap <em>source</em>);
-void gl.texImage2D(<var>cible</var>, <var>niveau</var>, <var>formatinterne</var>, <var>largeur</var>, <var>hauteur</var>, <var>bordure</var><em>, format, type</em>, ImageData <em>source</em>);
-void gl.texImage2D(<var>cible</var>, <var>niveau</var>, <var>formatinterne</var>, <var>largeur</var>, <var>hauteur</var>, <var>bordure</var><em>, format, type</em>, ArrayBufferView <em>donneesSrc</em>, <em>decalageSrc</em>);
-</pre>
-
-<h3 id="Paramètres">Paramètres</h3>
-
-<dl>
- <dt><code>cible</code></dt>
- <dd><p>Un {{domxref ("GLenum")}} indiquant le point de liaison (cible) de la texture active. Valeurs possibles :</p>
- <ul>
-  <li><code>gl.TEXTURE_2D</code> : une texture bidimensionnelle ;</li>
-  <li><code>gl.TEXTURE_CUBE_MAP_POSITIVE_X</code> : face X positive pour une texture mappée sur un cube ;</li>
-  <li><code>gl.TEXTURE_CUBE_MAP_NEGATIVE_X</code> : face X négative pour une texture mappée sur un cube ;</li>
-  <li><code>gl.TEXTURE_CUBE_MAP_POSITIVE_Y</code> : face Y positive pour une texture mappée sur un cube ;</li>
-  <li><code>gl.TEXTURE_CUBE_MAP_NEGATIVE_Y</code> : face Y négative pour une texture mappée sur un cube ;</li>
-  <li><code>gl.TEXTURE_CUBE_MAP_POSITIVE_Z</code> : face Z positive pour une texture mappée sur un cube ;</li>
-  <li><code>gl.TEXTURE_CUBE_MAP_NEGATIVE_Z</code> : face Z négative pour une texture mappée sur un cube.</li>
- </ul>
- </dd>
- <dt><code>niveau</code></dt>
- <dd>Un {{domxref ("GLint")}} indiquant le niveau de détail. Le niveau 0 est le niveau de l'image de base et le niveau n est le n-ième niveau de réduction du mipmap.</dd>
- <dt><code>formatinterne</code></dt>
- <dd><p>Un {{domxref ("GLint")}} indiquant les composantes de couleur dans la texture. Valeurs possibles :</p>
- <ul>
-  <li><code>gl.ALPHA</code> : ignore les composantes rouge, vert et bleu, et lit la composante alpha ;</li>
-  <li><code>gl.RGB</code> : ignore la composante alpha et lit les composantes rouge, vert et bleu ;</li>
-  <li><code>gl.RGBA</code> : les composantes rouge, vert, bleu et alpha sont lues à partir du tampon des couleurs ;</li>
-  <li><code>gl.LUMINANCE</code> : chaque composante de couleur est une composante de luminance, alpha vaut 1,0 ;</li>
-  <li><code>gl.LUMINANCE_ALPHA</code> : chaque composante est une composante de luminance/alpha ;</li>
-  <li>lors de l'utilisation de l'extension {{domxref("WEBGL_depth_texture")}} :
-   <ul>
-    <li><code>gl.DEPTH_COMPONENT</code></li>
-    <li><code>gl.DEPTH_STENCIL</code></li>
-   </ul>
-  </li>
-  <li>lors de l'utilisation de l'extension {{domxref("EXT_sRGB")}} :
-   <ul>
-    <li><code>ext.SRGB_EXT</code></li>
-    <li><code>ext.SRGB_ALPHA_EXT</code></li>
-   </ul>
-  </li>
-  <li>Lors de l'utilisation d'un {{domxref("WebGL2RenderingContext", "WebGL 2 context", "", 1)}}, les valeurs suivantes sont en outre disponibles :
-   <ul>
-    <li><code>gl.R8</code></li>
-    <li><code>gl.R16F</code></li>
-    <li><code>gl.R32F</code></li>
-    <li><code>gl.R8UI</code></li>
-    <li><code>gl.RG8</code></li>
-    <li><code>gl.RG16F</code></li>
-    <li><code>gl.RG32F</code></li>
-    <li><code>gl.RG8UI</code></li>
-    <li><code>gl.RG16UI</code></li>
-    <li><code>gl.RG32UI</code></li>
-    <li><code>gl.RGB8</code></li>
-    <li><code>gl.SRGB8</code></li>
-    <li><code>gl.RGB565</code></li>
-    <li><code>gl.R11F_G11F_B10F</code></li>
-    <li><code>gl.RGB9_E5</code></li>
-    <li><code>gl.RGB16F</code></li>
-    <li><code>gl.RGB32F</code></li>
-    <li><code>gl.RGB8UI</code></li>
-    <li><code>gl.RGBA8</code></li>
-    <li><code>gl.SRGB8_APLHA8</code></li>
-    <li><code>gl.RGB5_A1</code></li>
-    <li><code>gl.RGB10_A2</code></li>
-    <li><code>gl.RGBA4</code></li>
-    <li><code>gl.RGBA16F</code></li>
-    <li><code>gl.RGBA32F</code></li>
-    <li><code>gl.RGBA8UI</code></li>
-   </ul>
-  </li>
- </ul>
- </dd>
- <dt><code>largeur</code></dt>
- <dd>Un {{domxref ("GLsizei")}} indiquant la largeur de la texture.</dd>
- <dt><code>hauteur</code></dt>
- <dd>Un {{domxref ("GLsizei")}} indiquant la hauteur de la texture.</dd>
- <dt><code>bordure</code></dt>
- <dd>Un {{domxref("GLint")}} indiquant la largeur de la bordure. Doit être 0.</dd>
- <dt><code>format</code></dt>
- <dd>Un {{domxref("GLenum")}} indiquant le format des données de texel. En WebGL 1, cela doit être identique à <code>formatinterne</code> (voir ci-dessus). En WebGL 2, les combinaisons sont répertoriées dans <a href="https://www.khronos.org/registry/webgl/specs/latest/2.0/#TEXTURE_TYPES_FORMATS_FROM_DOM_ELEMENTS_TABLE">ce tableau</a>.</dd>
- <dt><code>type</code></dt>
- <dd><p>Un {{domxref("GLenum")}} indiquant le type de données des données de texel. Valeurs possibles :</p>
- <ul>
-  <li><code>gl.UNSIGNED_BYTE</code> : 8 bits par canal pour <code>gl.RGBA</code> ;</li>
-  <li><code>gl.UNSIGNED_SHORT_5_6_5</code> : 5 bits de rouge, 6 bits de vert, 5 bits de bleu ;</li>
-  <li><code>gl.UNSIGNED_SHORT_4_4_4_4</code> : 4 bits de rouge, 4 bits de vert, 4 bits de bleu, 4 bits d'alpha ;</li>
-  <li><code>gl.UNSIGNED_SHORT_5_5_5_1</code> : 5 bits de rouge, 5 bits de vert, 5 bits de bleu, 1 bit d'alpha ;</li>
-  <li>lors de l'utilisation de l'extension {{domxref ("WEBGL_depth_texture")}} :
-   <ul>
-    <li><code>gl.UNSIGNED_SHORT</code></li>
-    <li><code>gl.UNSIGNED_INT</code></li>
-    <li><code>ext.UNSIGNED_INT_24_8_WEBGL</code> (constante fournie par l'extension)</li>
-   </ul>
-  </li>
-  <li>lors de l'utilisation de l'extension {{domxref("OES_texture_float")}} :
-   <ul>
-    <li><code>gl.FLOAT</code></li>
-   </ul>
-  </li>
-  <li>lors de l'utilisation de l'extension {{domxref("OES_texture_half_float")}} :
-   <ul>
-    <li><code>ext.HALF_FLOAT_OES</code> (constante fournie par l'extension)</li>
-   </ul>
-  </li>
-  <li>lors de l'utilisation d'un {{domxref("WebGL2RenderingContext", "WebGL 2 context", "", 1)}}, les valeurs suivantes sont en outre disponibles :
-   <ul>
-    <li><code>gl.BYTE</code></li>
-    <li><code>gl.UNSIGNED_SHORT</code></li>
-    <li><code>gl.SHORT</code></li>
-    <li><code>gl.UNSIGNED_INT</code></li>
-    <li><code>gl.INT</code></li>
-    <li><code>gl.HALF_FLOAT</code></li>
-    <li><code>gl.FLOAT</code></li>
-    <li><code>gl.UNSIGNED_INT_2_10_10_10_REV</code></li>
-    <li><code>gl.UNSIGNED_INT_10F_11F_11F_REV</code></li>
-    <li><code>gl.UNSIGNED_INT_5_9_9_9_REV</code></li>
-    <li><code>gl.UNSIGNED_INT_24_8</code></li>
-    <li><code>gl.FLOAT_32_UNSIGNED_INT_24_8_REV</code> (les pixels doivent être {{jsxref("null")}})</li>
-   </ul>
-  </li>
- </ul>
- </dd>
- <dt><code>pixels</code></dt>
- <dd><p>L'un des objets suivants peut être utilisé comme source de pixels pour la texture :</p>
- <ul>
-  <li>{{domxref("ArrayBufferView")}},
-   <ul>
-    <li>un {{jsxref("Uint8Array")}} doit être utilisé si <code>type</code> est <code>gl.UNSIGNED_BYTE</code> ;</li>
-    <li>un {{jsxref("Uint16Array")}} doit être utilisé si <code>type</code> est <code>gl.UNSIGNED_SHORT_5_6_5</code>, <code>gl.UNSIGNED_SHORT_4_4_4_4</code>, <code>gl.UNSIGNED_SHORT_5_5_5_1</code>, <code>gl.UNSIGNED_SHORT</code> ou <code>ext.HALF_FLOAT_OES</code> ;</li>
-    <li>un {{jsxref("Uint32Array")}} doit être utilisé si <code>type</code> est <code>gl.UNSIGNED_INT</code> ou <code>ext.UNSIGNED_INT_24_8_WEBGL</code> ;</li>
-    <li>un {{jsxref("Float32Array")}} doit être utilisé si <code>type</code> est <code>gl.FLOAT</code> ;</li>
-   </ul>
-  </li>
-  <li>{{domxref("ImageData")}},</li>
-  <li>{{domxref("HTMLImageElement")}},</li>
-  <li>{{domxref("HTMLCanvasElement")}},</li>
-  <li>{{domxref("HTMLVideoElement")}},</li>
-  <li>{{domxref("ImageBitmap")}}.</li>
- </ul>
- </dd>
- <dt><code><strong>decalage</strong></code></dt>
- <dd>(WebGL 2 seulement) Un décalage en octets {{domxref("GLintptr")}} dans le magasin de données du {{domxref("WebGLBuffer")}}. Utilisé pour télécharger des données vers la {{domxref ("WebGLTexture")}} liée, depuis le <code>WebGLBuffer</code> lié à la cible <code>PIXEL_UNPACK_BUFFER</code>.</dd>
-</dl>
-
-<h3 id="Valeur_retournée">Valeur retournée</h3>
-
-<p>Aucune.</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<pre class="brush: js">gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
+{{APIRef("WebGL")}}
+
+La méthode **`WebGLRenderingContext.texImage2D()`** de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API) spécifie une image de texture bidimensionnelle.
+
+## Syntaxe
+
+    // WebGL1:
+    void gl.texImage2D(cible, niveau, formatinterne, largeur, hauteur, bordure, format, type, ArrayBufferView? pixels);
+    void gl.texImage2D(cible, niveau, formatinterne, format, type, ImageData? pixels);
+    void gl.texImage2D(cible, niveau, formatinterne, format, type, HTMLImageElement? pixels);
+    void gl.texImage2D(cible, niveau, formatinterne, format, type, HTMLCanvasElement? pixels);
+    void gl.texImage2D(cible, niveau, formatinterne, format, type, HTMLVideoElement? pixels);
+    void gl.texImage2D(cible, niveau, formatinterne, format, type, ImageBitmap? pixels);
+
+    // WebGL2:
+    void gl.texImage2D(cible, niveau, formatinterne, largeur, hauteur, bordure, format, type, GLintptr decalage);
+    void gl.texImage2D(cible, niveau, formatinterne, largeur, hauteur, bordure, format, type, HTMLCanvasElement source);
+    void gl.texImage2D(cible, niveau, formatinterne, largeur, hauteur, bordure, format, type, HTMLImageElement source);
+    void gl.texImage2D(cible, niveau, formatinterne, largeur, hauteur, bordure, format, type, HTMLVideoElement source);
+    void gl.texImage2D(cible, niveau, formatinterne, largeur, hauteur, bordure, format, type, ImageBitmap source);
+    void gl.texImage2D(cible, niveau, formatinterne, largeur, hauteur, bordure, format, type, ImageData source);
+    void gl.texImage2D(cible, niveau, formatinterne, largeur, hauteur, bordure, format, type, ArrayBufferView donneesSrc, decalageSrc);
+
+### Paramètres
+
+- `cible`
+
+  - : Un {{domxref ("GLenum")}} indiquant le point de liaison (cible) de la texture active. Valeurs possibles :
+
+    - `gl.TEXTURE_2D` : une texture bidimensionnelle ;
+    - `gl.TEXTURE_CUBE_MAP_POSITIVE_X` : face X positive pour une texture mappée sur un cube ;
+    - `gl.TEXTURE_CUBE_MAP_NEGATIVE_X` : face X négative pour une texture mappée sur un cube ;
+    - `gl.TEXTURE_CUBE_MAP_POSITIVE_Y` : face Y positive pour une texture mappée sur un cube ;
+    - `gl.TEXTURE_CUBE_MAP_NEGATIVE_Y` : face Y négative pour une texture mappée sur un cube ;
+    - `gl.TEXTURE_CUBE_MAP_POSITIVE_Z` : face Z positive pour une texture mappée sur un cube ;
+    - `gl.TEXTURE_CUBE_MAP_NEGATIVE_Z` : face Z négative pour une texture mappée sur un cube.
+
+- `niveau`
+  - : Un {{domxref ("GLint")}} indiquant le niveau de détail. Le niveau 0 est le niveau de l'image de base et le niveau n est le n-ième niveau de réduction du mipmap.
+- `formatinterne`
+
+  - : Un {{domxref ("GLint")}} indiquant les composantes de couleur dans la texture. Valeurs possibles :
+
+    - `gl.ALPHA` : ignore les composantes rouge, vert et bleu, et lit la composante alpha ;
+    - `gl.RGB` : ignore la composante alpha et lit les composantes rouge, vert et bleu ;
+    - `gl.RGBA` : les composantes rouge, vert, bleu et alpha sont lues à partir du tampon des couleurs ;
+    - `gl.LUMINANCE` : chaque composante de couleur est une composante de luminance, alpha vaut 1,0 ;
+    - `gl.LUMINANCE_ALPHA` : chaque composante est une composante de luminance/alpha ;
+    - lors de l'utilisation de l'extension {{domxref("WEBGL_depth_texture")}} :
+
+      - `gl.DEPTH_COMPONENT`
+      - `gl.DEPTH_STENCIL`
+
+    - lors de l'utilisation de l'extension {{domxref("EXT_sRGB")}} :
+
+      - `ext.SRGB_EXT`
+      - `ext.SRGB_ALPHA_EXT`
+
+    - Lors de l'utilisation d'un {{domxref("WebGL2RenderingContext", "WebGL 2 context", "", 1)}}, les valeurs suivantes sont en outre disponibles :
+
+      - `gl.R8`
+      - `gl.R16F`
+      - `gl.R32F`
+      - `gl.R8UI`
+      - `gl.RG8`
+      - `gl.RG16F`
+      - `gl.RG32F`
+      - `gl.RG8UI`
+      - `gl.RG16UI`
+      - `gl.RG32UI`
+      - `gl.RGB8`
+      - `gl.SRGB8`
+      - `gl.RGB565`
+      - `gl.R11F_G11F_B10F`
+      - `gl.RGB9_E5`
+      - `gl.RGB16F`
+      - `gl.RGB32F`
+      - `gl.RGB8UI`
+      - `gl.RGBA8`
+      - `gl.SRGB8_APLHA8`
+      - `gl.RGB5_A1`
+      - `gl.RGB10_A2`
+      - `gl.RGBA4`
+      - `gl.RGBA16F`
+      - `gl.RGBA32F`
+      - `gl.RGBA8UI`
+
+- `largeur`
+  - : Un {{domxref ("GLsizei")}} indiquant la largeur de la texture.
+- `hauteur`
+  - : Un {{domxref ("GLsizei")}} indiquant la hauteur de la texture.
+- `bordure`
+  - : Un {{domxref("GLint")}} indiquant la largeur de la bordure. Doit être 0.
+- `format`
+  - : Un {{domxref("GLenum")}} indiquant le format des données de texel. En WebGL 1, cela doit être identique à `formatinterne` (voir ci-dessus). En WebGL 2, les combinaisons sont répertoriées dans [ce tableau](https://www.khronos.org/registry/webgl/specs/latest/2.0/#TEXTURE_TYPES_FORMATS_FROM_DOM_ELEMENTS_TABLE).
+- `type`
+
+  - : Un {{domxref("GLenum")}} indiquant le type de données des données de texel. Valeurs possibles :
+
+    - `gl.UNSIGNED_BYTE` : 8 bits par canal pour `gl.RGBA` ;
+    - `gl.UNSIGNED_SHORT_5_6_5` : 5 bits de rouge, 6 bits de vert, 5 bits de bleu ;
+    - `gl.UNSIGNED_SHORT_4_4_4_4` : 4 bits de rouge, 4 bits de vert, 4 bits de bleu, 4 bits d'alpha ;
+    - `gl.UNSIGNED_SHORT_5_5_5_1` : 5 bits de rouge, 5 bits de vert, 5 bits de bleu, 1 bit d'alpha ;
+    - lors de l'utilisation de l'extension {{domxref ("WEBGL_depth_texture")}} :
+
+      - `gl.UNSIGNED_SHORT`
+      - `gl.UNSIGNED_INT`
+      - `ext.UNSIGNED_INT_24_8_WEBGL` (constante fournie par l'extension)
+
+    - lors de l'utilisation de l'extension {{domxref("OES_texture_float")}} :
+
+      - `gl.FLOAT`
+
+    - lors de l'utilisation de l'extension {{domxref("OES_texture_half_float")}} :
+
+      - `ext.HALF_FLOAT_OES` (constante fournie par l'extension)
+
+    - lors de l'utilisation d'un {{domxref("WebGL2RenderingContext", "WebGL 2 context", "", 1)}}, les valeurs suivantes sont en outre disponibles :
+
+      - `gl.BYTE`
+      - `gl.UNSIGNED_SHORT`
+      - `gl.SHORT`
+      - `gl.UNSIGNED_INT`
+      - `gl.INT`
+      - `gl.HALF_FLOAT`
+      - `gl.FLOAT`
+      - `gl.UNSIGNED_INT_2_10_10_10_REV`
+      - `gl.UNSIGNED_INT_10F_11F_11F_REV`
+      - `gl.UNSIGNED_INT_5_9_9_9_REV`
+      - `gl.UNSIGNED_INT_24_8`
+      - `gl.FLOAT_32_UNSIGNED_INT_24_8_REV` (les pixels doivent être {{jsxref("null")}})
+
+- `pixels`
+
+  - : L'un des objets suivants peut être utilisé comme source de pixels pour la texture :
+
+    - {{domxref("ArrayBufferView")}},
+
+      - un {{jsxref("Uint8Array")}} doit être utilisé si `type` est `gl.UNSIGNED_BYTE` ;
+      - un {{jsxref("Uint16Array")}} doit être utilisé si `type` est `gl.UNSIGNED_SHORT_5_6_5`, `gl.UNSIGNED_SHORT_4_4_4_4`, `gl.UNSIGNED_SHORT_5_5_5_1`, `gl.UNSIGNED_SHORT` ou `ext.HALF_FLOAT_OES` ;
+      - un {{jsxref("Uint32Array")}} doit être utilisé si `type` est `gl.UNSIGNED_INT` ou `ext.UNSIGNED_INT_24_8_WEBGL` ;
+      - un {{jsxref("Float32Array")}} doit être utilisé si `type` est `gl.FLOAT` ;
+
+    - {{domxref("ImageData")}},
+    - {{domxref("HTMLImageElement")}},
+    - {{domxref("HTMLCanvasElement")}},
+    - {{domxref("HTMLVideoElement")}},
+    - {{domxref("ImageBitmap")}}.
+
+- **`decalage`**
+  - : (WebGL 2 seulement) Un décalage en octets {{domxref("GLintptr")}} dans le magasin de données du {{domxref("WebGLBuffer")}}. Utilisé pour télécharger des données vers la {{domxref ("WebGLTexture")}} liée, depuis le `WebGLBuffer` lié à la cible `PIXEL_UNPACK_BUFFER`.
+
+### Valeur retournée
+
+Aucune.
+
+## Exemples
+
+```js
+gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
+```
+
+## Spécifications
 
 <table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.8", "texImage2D")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>
-    <p>Définition initiale pour WebGL.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glTexImage2D.xml", "glTexImage2D")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>
-    <p>Page man de l’API OpenGL ES 2.0 (similaire).</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL2', "#3.7.6", "texImage2D")}}</td>
-   <td>{{Spec2('WebGL2')}}</td>
-   <td>Définition mise à jour pour WebGL.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 3.0', "glTexImage2D.xhtml", "glTexImage2D")}}</td>
-   <td>{{Spec2('OpenGL ES 3.0')}}</td>
-   <td>Page man de l’API OpenGL ES 3.0 (similaire).</td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <th scope="col">Spécification</th>
+      <th scope="col">Statut</th>
+      <th scope="col">Commentaire</th>
+    </tr>
+    <tr>
+      <td>{{SpecName('WebGL', "#5.14.8", "texImage2D")}}</td>
+      <td>{{Spec2('WebGL')}}</td>
+      <td><p>Définition initiale pour WebGL.</p></td>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('OpenGL ES 2.0', "glTexImage2D.xml", "glTexImage2D")}}
+      </td>
+      <td>{{Spec2('OpenGL ES 2.0')}}</td>
+      <td><p>Page man de l’API OpenGL ES 2.0 (similaire).</p></td>
+    </tr>
+    <tr>
+      <td>{{SpecName('WebGL2', "#3.7.6", "texImage2D")}}</td>
+      <td>{{Spec2('WebGL2')}}</td>
+      <td>Définition mise à jour pour WebGL.</td>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('OpenGL ES 3.0', "glTexImage2D.xhtml", "glTexImage2D")}}
+      </td>
+      <td>{{Spec2('OpenGL ES 3.0')}}</td>
+      <td>Page man de l’API OpenGL ES 3.0 (similaire).</td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.WebGLRenderingContext.texImage2D")}}</p>
+{{Compat("api.WebGLRenderingContext.texImage2D")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{domxref("WebGLRenderingContext.createTexture()")}}</li>
- <li>{{domxref("WebGLRenderingContext.bindTexture()")}}</li>
- <li>{{domxref("WebGLRenderingContext.texSubImage2D()")}}</li>
- <li>{{domxref("WebGLRenderingContext.compressedTexImage2D()")}}</li>
- <li>{{domxref("WebGLRenderingContext.copyTexImage2D()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getTexParameter()")}}</li>
- <li>{{domxref("WEBGL_depth_texture")}}</li>
- <li>{{domxref("OES_texture_float")}}</li>
- <li>{{domxref("OES_texture_half_float")}}</li>
- <li>{{domxref("EXT_sRGB")}}</li>
-</ul>
+- {{domxref("WebGLRenderingContext.createTexture()")}}
+- {{domxref("WebGLRenderingContext.bindTexture()")}}
+- {{domxref("WebGLRenderingContext.texSubImage2D()")}}
+- {{domxref("WebGLRenderingContext.compressedTexImage2D()")}}
+- {{domxref("WebGLRenderingContext.copyTexImage2D()")}}
+- {{domxref("WebGLRenderingContext.getTexParameter()")}}
+- {{domxref("WEBGL_depth_texture")}}
+- {{domxref("OES_texture_float")}}
+- {{domxref("OES_texture_half_float")}}
+- {{domxref("EXT_sRGB")}}
diff --git a/files/fr/web/api/webglrenderingcontext/texparameter/index.md b/files/fr/web/api/webglrenderingcontext/texparameter/index.md
index ec02f92374..705a95ba60 100644
--- a/files/fr/web/api/webglrenderingcontext/texparameter/index.md
+++ b/files/fr/web/api/webglrenderingcontext/texparameter/index.md
@@ -1,5 +1,5 @@
 ---
-title: 'WebGLRenderingContext.texParameter[fi]()'
+title: WebGLRenderingContext.texParameter[fi]()
 slug: Web/API/WebGLRenderingContext/texParameter
 tags:
   - API
@@ -10,168 +10,168 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/texParameter
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>Les méthodes <strong><code>WebGLRenderingContext.texParameter[fi]()</code></strong> de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> définissent les paramètres de texture.</p>
+Les méthodes **`WebGLRenderingContext.texParameter[fi]()`** de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API) définissent les paramètres de texture.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">void <var>gl</var>.texParameterf(GLenum <var>cible</var>, GLenum <var>nomp</var>, GLfloat <var>param</var>);
-void <var>gl</var>.texParameteri(GLenum <var>cible</var>, GLenum <var>nomp</var>, GLint <var>param</var>);
-</pre>
+    void gl.texParameterf(GLenum cible, GLenum nomp, GLfloat param);
+    void gl.texParameteri(GLenum cible, GLenum nomp, GLint param);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt>cible</dt>
- <dd>Un {{domxref("GLenum")}} indiquant le point de liaison (cible). Valeurs possibles :
- <ul>
-  <li><code>gl.TEXTURE_2D</code> : une texture bi-dimensionelle.</li>
-  <li><code>gl.TEXTURE_CUBE_MAP</code> : une texte appliquée sur un cube.</li>
-  <li>Lorsqu'un {{domxref("WebGL2RenderingContext", "WebGL 2 context", "", 1)}} est utilisé, les valeurs suivantes sont en outre disponibles :
-   <ul>
-    <li><code>gl.TEXTURE_3D</code> : une texture tri-dimensionnelle.</li>
-    <li><code>gl.TEXTURE_2D_ARRAY</code> : une texture bi-dimensionnelle en tableau.</li>
-   </ul>
-  </li>
- </ul>
- </dd>
-</dl>
+- cible
 
-<p>Le paramètre <code>nomp</code> est un {{domxref("Glenum")}} indiquant le paramètre de texture à définir. Le paramètre <code>param</code> est un {{domxref("GLfloat")}} ou un {{domxref("GLint")}} indiquant la valeur pour le paramètre <code>nomp</code> indiqué.</p>
+  - : Un {{domxref("GLenum")}} indiquant le point de liaison (cible). Valeurs possibles :
+
+    - `gl.TEXTURE_2D` : une texture bi-dimensionelle.
+    - `gl.TEXTURE_CUBE_MAP` : une texte appliquée sur un cube.
+    - Lorsqu'un {{domxref("WebGL2RenderingContext", "WebGL 2 context", "", 1)}} 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.
+
+Le paramètre `nomp` est un {{domxref("Glenum")}} indiquant le paramètre de texture à définir. Le paramètre `param` est un {{domxref("GLfloat")}} ou un {{domxref("GLint")}} indiquant la valeur pour le paramètre `nomp` indiqué.
 
 <table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col"><code>pnom</code></th>
-   <th scope="col">Description</th>
-   <th scope="col"><code>param</code></th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <th colspan="3">Disponible en WebGL 1</th>
-  </tr>
-  <tr>
-   <td><code>gl.TEXTURE_MAG_FILTER</code></td>
-   <td>Filtre de grossissement de texture</td>
-   <td><code>gl.LINEAR</code> (valeur par défaut), <code>gl.NEAREST</code>.</td>
-  </tr>
-  <tr>
-   <td><code>gl.TEXTURE_MIN_FILTER</code></td>
-   <td>Filtre de réduction de texture</td>
-   <td><code>gl.LINEAR</code>, <code>gl.NEAREST</code>, <code>gl.NEAREST_MIPMAP_NEAREST</code>, <code>gl.LINEAR_MIPMAP_NEAREST</code>, <code>gl.NEAREST_MIPMAP_LINEAR</code> (valeur par défaut), <code>gl.LINEAR_MIPMAP_LINEAR</code>.</td>
-  </tr>
-  <tr>
-   <td><code>gl.TEXTURE_WRAP_S</code></td>
-   <td>Fonction d'emballage pour la coordonnée de texture <code>s</code></td>
-   <td><code>gl.REPEAT</code> (valeur par défaut),<code>gl.CLAMP_TO_EDGE</code>, <code>gl.MIRRORED_REPEAT</code>.</td>
-  </tr>
-  <tr>
-   <td><code>gl.TEXTURE_WRAP_T</code></td>
-   <td>Fonction d'emballage pour la coordonnée de texture <code>t</code></td>
-   <td><code>gl.REPEAT</code> (valeur par défaut),<code>gl.CLAMP_TO_EDGE</code>, <code>gl.MIRRORED_REPEAT</code>.</td>
-  </tr>
-  <tr>
-   <th colspan="3">Disponible en outre quand l'extension {{domxref("EXT_texture_filter_anisotropic")}} est utilisée</th>
-  </tr>
-  <tr>
-   <td><code>ext.TEXTURE_MAX_ANISOTROPY_EXT</code></td>
-   <td>Anisotropie maximum pour une texture</td>
-   <td>Une valeur {{domxref("GLfloat")}}.</td>
-  </tr>
-  <tr>
-   <th colspan="3">Disponible en outre quand un contexte WebGL 2 est utilisé</th>
-  </tr>
-  <tr>
-   <td><code>gl.TEXTURE_BASE_LEVEL</code></td>
-   <td>Niveau de mipmap de texture</td>
-   <td>Toutes valeurs int.</td>
-  </tr>
-  <tr>
-   <td><code>gl.TEXTURE_COMPARE_FUNC</code></td>
-   <td>Fonction de comparaison de texture</td>
-   <td><code>gl.LEQUAL</code> (valeur par défaut), <code>gl.GEQUAL</code>, <code>gl.LESS</code>, <code>gl.GREATER</code>, <code>gl.EQUAL</code>, <code>gl.NOTEQUAL</code>, <code>gl.ALWAYS</code>, <code>gl.NEVER</code>.</td>
-  </tr>
-  <tr>
-   <td><code>gl.TEXTURE_COMPARE_MODE</code></td>
-   <td>Mode de comparaison de texture</td>
-   <td><code>gl.NONE</code> (valeur défaut), <code>gl.COMPARE_REF_TO_TEXTURE</code>.</td>
-  </tr>
-  <tr>
-   <td><code>gl.TEXTURE_MAX_LEVEL</code></td>
-   <td>Niveau maximum de mipmap de texture en tableau</td>
-   <td>Toutes valeurs int.</td>
-  </tr>
-  <tr>
-   <td><code>gl.TEXTURE_MAX_LOD</code></td>
-   <td>
-    <p>Valeur de niveau-de-détail maximum de texture</p>
-   </td>
-   <td>Toutes valeurs float.</td>
-  </tr>
-  <tr>
-   <td><code>gl.TEXTURE_MIN_LOD</code></td>
-   <td>Valeur de niveau-de-détail minimum de texture</td>
-   <td>Toutes valeurs float.</td>
-  </tr>
-  <tr>
-   <td><code>gl.TEXTURE_WRAP_R</code></td>
-   <td>Fonction d'emballage pour la coordonnée de texture  <code>r</code></td>
-   <td><code>gl.REPEAT</code> (valeur par défaut), <code>gl.CLAMP_TO_EDGE</code>, <code>gl.MIRRORED_REPEAT</code>.</td>
-  </tr>
- </tbody>
+  <thead>
+    <tr>
+      <th scope="col"><code>pnom</code></th>
+      <th scope="col">Description</th>
+      <th scope="col"><code>param</code></th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <th colspan="3">Disponible en WebGL 1</th>
+    </tr>
+    <tr>
+      <td><code>gl.TEXTURE_MAG_FILTER</code></td>
+      <td>Filtre de grossissement de texture</td>
+      <td>
+        <code>gl.LINEAR</code> (valeur par défaut), <code>gl.NEAREST</code>.
+      </td>
+    </tr>
+    <tr>
+      <td><code>gl.TEXTURE_MIN_FILTER</code></td>
+      <td>Filtre de réduction de texture</td>
+      <td>
+        <code>gl.LINEAR</code>, <code>gl.NEAREST</code>,
+        <code>gl.NEAREST_MIPMAP_NEAREST</code>,
+        <code>gl.LINEAR_MIPMAP_NEAREST</code>,
+        <code>gl.NEAREST_MIPMAP_LINEAR</code> (valeur par défaut),
+        <code>gl.LINEAR_MIPMAP_LINEAR</code>.
+      </td>
+    </tr>
+    <tr>
+      <td><code>gl.TEXTURE_WRAP_S</code></td>
+      <td>Fonction d'emballage pour la coordonnée de texture <code>s</code></td>
+      <td>
+        <code>gl.REPEAT</code> (valeur par
+        défaut),<code>gl.CLAMP_TO_EDGE</code>, <code>gl.MIRRORED_REPEAT</code>.
+      </td>
+    </tr>
+    <tr>
+      <td><code>gl.TEXTURE_WRAP_T</code></td>
+      <td>Fonction d'emballage pour la coordonnée de texture <code>t</code></td>
+      <td>
+        <code>gl.REPEAT</code> (valeur par
+        défaut),<code>gl.CLAMP_TO_EDGE</code>, <code>gl.MIRRORED_REPEAT</code>.
+      </td>
+    </tr>
+    <tr>
+      <th colspan="3">
+        Disponible en outre quand l'extension
+        {{domxref("EXT_texture_filter_anisotropic")}} est
+        utilisée
+      </th>
+    </tr>
+    <tr>
+      <td><code>ext.TEXTURE_MAX_ANISOTROPY_EXT</code></td>
+      <td>Anisotropie maximum pour une texture</td>
+      <td>Une valeur {{domxref("GLfloat")}}.</td>
+    </tr>
+    <tr>
+      <th colspan="3">
+        Disponible en outre quand un contexte WebGL 2 est utilisé
+      </th>
+    </tr>
+    <tr>
+      <td><code>gl.TEXTURE_BASE_LEVEL</code></td>
+      <td>Niveau de mipmap de texture</td>
+      <td>Toutes valeurs int.</td>
+    </tr>
+    <tr>
+      <td><code>gl.TEXTURE_COMPARE_FUNC</code></td>
+      <td>Fonction de comparaison de texture</td>
+      <td>
+        <code>gl.LEQUAL</code> (valeur par défaut), <code>gl.GEQUAL</code>,
+        <code>gl.LESS</code>, <code>gl.GREATER</code>, <code>gl.EQUAL</code>,
+        <code>gl.NOTEQUAL</code>, <code>gl.ALWAYS</code>, <code>gl.NEVER</code>.
+      </td>
+    </tr>
+    <tr>
+      <td><code>gl.TEXTURE_COMPARE_MODE</code></td>
+      <td>Mode de comparaison de texture</td>
+      <td>
+        <code>gl.NONE</code> (valeur défaut),
+        <code>gl.COMPARE_REF_TO_TEXTURE</code>.
+      </td>
+    </tr>
+    <tr>
+      <td><code>gl.TEXTURE_MAX_LEVEL</code></td>
+      <td>Niveau maximum de mipmap de texture en tableau</td>
+      <td>Toutes valeurs int.</td>
+    </tr>
+    <tr>
+      <td><code>gl.TEXTURE_MAX_LOD</code></td>
+      <td><p>Valeur de niveau-de-détail maximum de texture</p></td>
+      <td>Toutes valeurs float.</td>
+    </tr>
+    <tr>
+      <td><code>gl.TEXTURE_MIN_LOD</code></td>
+      <td>Valeur de niveau-de-détail minimum de texture</td>
+      <td>Toutes valeurs float.</td>
+    </tr>
+    <tr>
+      <td><code>gl.TEXTURE_WRAP_R</code></td>
+      <td>
+        Fonction d'emballage pour la coordonnée de texture  <code>r</code>
+      </td>
+      <td>
+        <code>gl.REPEAT</code> (valeur par défaut),
+        <code>gl.CLAMP_TO_EDGE</code>, <code>gl.MIRRORED_REPEAT</code>.
+      </td>
+    </tr>
+  </tbody>
 </table>
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+### Valeur retournée
 
-<p>Aucune.</p>
+Aucune.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">gl.texParameterf(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+```js
+gl.texParameterf(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_NEAREST);
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.8", "texParameter[fi]")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale pour WebGL.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glTexParameter.xml", "glTexParameter")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man de l’API OpenGL ES 2.0 API (similaire).</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL2', "#3.7.6", "texParameter[fi]")}}</td>
-   <td>{{Spec2('WebGL2')}}</td>
-   <td>Définition mise à jour pour WebGL.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 3.0', "glTexParameter.xhtml", "glTexParameter")}}</td>
-   <td>{{Spec2('OpenGL ES 3.0')}}</td>
-   <td>Page man de l’API OpenGL ES 3.0 API (similaire).</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                    | Statut                               | Commentaire                                      |
+| ------------------------------------------------------------------------------------------------ | ------------------------------------ | ------------------------------------------------ |
+| {{SpecName('WebGL', "#5.14.8", "texParameter[fi]")}}                             | {{Spec2('WebGL')}}             | Définition initiale pour WebGL.                  |
+| {{SpecName('OpenGL ES 2.0', "glTexParameter.xml", "glTexParameter")}}     | {{Spec2('OpenGL ES 2.0')}} | Page man de l’API OpenGL ES 2.0 API (similaire). |
+| {{SpecName('WebGL2', "#3.7.6", "texParameter[fi]")}}                             | {{Spec2('WebGL2')}}             | Définition mise à jour pour WebGL.               |
+| {{SpecName('OpenGL ES 3.0', "glTexParameter.xhtml", "glTexParameter")}} | {{Spec2('OpenGL ES 3.0')}} | Page man de l’API OpenGL ES 3.0 API (similaire). |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.WebGLRenderingContext.texParameterf")}}</p>
+{{Compat("api.WebGLRenderingContext.texParameterf")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{domxref("WebGLRenderingContext.getTexParameter()")}}</li>
- <li>{{domxref("EXT_texture_filter_anisotropic")}}</li>
-</ul>
+- {{domxref("WebGLRenderingContext.getTexParameter()")}}
+- {{domxref("EXT_texture_filter_anisotropic")}}
diff --git a/files/fr/web/api/webglrenderingcontext/uniform/index.md b/files/fr/web/api/webglrenderingcontext/uniform/index.md
index cb27eaeb2c..6dea122f90 100644
--- a/files/fr/web/api/webglrenderingcontext/uniform/index.md
+++ b/files/fr/web/api/webglrenderingcontext/uniform/index.md
@@ -1,5 +1,5 @@
 ---
-title: 'WebGLRenderingContext.uniform[1234][fi][v]()'
+title: WebGLRenderingContext.uniform[1234][fi][v]()
 slug: Web/API/WebGLRenderingContext/uniform
 tags:
   - API
@@ -9,89 +9,68 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/uniform
 ---
-<div>{{APIRef("WebGL")}}</div>
-
-<p>Les méthodes <strong><code>WebGLRenderingContext.uniform[1234][fi][v]()</code></strong> de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> indiquent les valeurs des variables uniform.</p>
-
-<div class="note">
-<p><strong>Note :</strong> Beaucoup des fonctions décrites ici ont des interfaces WebGL 2 étendues, qui peuvent être trouvées en {{domxref("WebGL2RenderingContext.uniform","WebGL2RenderingContext.uniform[1234][uif][v]()")}}.</p>
-</div>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">void <var>gl</var>.uniform1f(<var>emplacement</var>, <var>v0</var>);
-void <var>gl</var>.uniform1fv(<var>emplacement</var>, <var>valeur</var>);
-void <var>gl</var>.uniform1i(<var>emplacement</var>, <var>v0</var>);
-void <var>gl</var>.uniform1iv(<var>emplacement</var>, <var>valeur</var>);
-
-void <var>gl</var>.uniform2f(<var>emplacement</var>, <var>v0</var>, <var>v1</var>);
-void <var>gl</var>.uniform2fv(<var>emplacement</var>, <var>valeur</var>);
-void <var>gl</var>.uniform2i(<var>emplacement</var>, <var>v0</var>, <var>v1</var>);
-void <var>gl</var>.uniform2iv(<var>emplacement</var>, <var>valeur</var>);
-
-void <var>gl</var>.uniform3f(<var>emplacement</var>, <var>v0</var>, <var>v1</var>, <var>v2</var>);
-void <var>gl</var>.uniform3fv(<var>emplacement</var>, <var>valeur</var>);
-void <var>gl</var>.uniform3i(<var>emplacement</var>, <var>v0</var>, <var>v1</var>, <var>v2</var>);
-void <var>gl</var>.uniform3iv(<var>emplacement</var>, <var>valeur</var>);
-
-void <var>gl</var>.uniform4f(<var>emplacement</var>, <var>v0</var>, <var>v1</var>, <var>v2</var>, <var>v3</var>);
-void <var>gl</var>.uniform4fv(<var>emplacement</var>, <var>valeur</var>);
-void <var>gl</var>.uniform4i(<var>emplacement</var>, <var>v0</var>, <var>v1</var>, <var>v2</var>, <var>v3</var>);
-void <var>gl</var>.uniform4iv(<var>emplacement</var>, <var>valeur</var>);
-</pre>
-
-<h3 id="Paramètres">Paramètres</h3>
-
-<dl>
- <dt>emplacement</dt>
- <dd>Un objet {{domxref("WebGLUniformLocation")}} contenant l'emplacement de l'attribut uniform à modifier.</dd>
- <dt><code>valeur, v0, v1, v2, v3</code></dt>
- <dd>La nouvelle valeur à utiliser pour la variable uniform. Types possibles :
- <ul>
-  <li>Un {{jsxref("Number")}} flottant pour les valeurs flottantes (méthodes avec "f").</li>
-  <li>Une suite de nombres flottants (par exemple, un {{jsxref("Float32Array")}} ou un {{jsxref("Array")}} de nombres) pour les méthodes de vecteurs de flottants (méthodes avec "fv").</li>
-  <li>Un {{jsxref("Number")}} entier pour les valeurs entières (méthodes avec "i").</li>
-  <li>Un {{jsxref("int32Array")}} pour les méthodes de vecteur d'entiers (méthodes avec "iv").</li>
- </ul>
- </dd>
-</dl>
-
-<h3 id="Valeur_retournée">Valeur retournée</h3>
-
-<p>Aucune.</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<pre class="brush: js">gl.uniform1f(u_alpha, 0.8);</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.10", "uniform")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glUniform.xml", "glUniform")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man de l'API OpenGL.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.WebGLRenderingContext.uniform1f")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("WebGLRenderingContext.uniformMatrix()")}}</li>
-</ul>
+{{APIRef("WebGL")}}
+
+Les méthodes **`WebGLRenderingContext.uniform[1234][fi][v]()`** de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API) indiquent les valeurs des variables uniform.
+
+> **Note :** Beaucoup des fonctions décrites ici ont des interfaces WebGL 2 étendues, qui peuvent être trouvées en {{domxref("WebGL2RenderingContext.uniform","WebGL2RenderingContext.uniform[1234][uif][v]()")}}.
+
+## Syntaxe
+
+    void gl.uniform1f(emplacement, v0);
+    void gl.uniform1fv(emplacement, valeur);
+    void gl.uniform1i(emplacement, v0);
+    void gl.uniform1iv(emplacement, valeur);
+
+    void gl.uniform2f(emplacement, v0, v1);
+    void gl.uniform2fv(emplacement, valeur);
+    void gl.uniform2i(emplacement, v0, v1);
+    void gl.uniform2iv(emplacement, valeur);
+
+    void gl.uniform3f(emplacement, v0, v1, v2);
+    void gl.uniform3fv(emplacement, valeur);
+    void gl.uniform3i(emplacement, v0, v1, v2);
+    void gl.uniform3iv(emplacement, valeur);
+
+    void gl.uniform4f(emplacement, v0, v1, v2, v3);
+    void gl.uniform4fv(emplacement, valeur);
+    void gl.uniform4i(emplacement, v0, v1, v2, v3);
+    void gl.uniform4iv(emplacement, valeur);
+
+### Paramètres
+
+- emplacement
+  - : Un objet {{domxref("WebGLUniformLocation")}} contenant l'emplacement de l'attribut uniform à modifier.
+- `valeur, v0, v1, v2, v3`
+
+  - : La nouvelle valeur à utiliser pour la variable uniform. Types possibles :
+
+    - Un {{jsxref("Number")}} flottant pour les valeurs flottantes (méthodes avec "f").
+    - Une suite de nombres flottants (par exemple, un {{jsxref("Float32Array")}} ou un {{jsxref("Array")}} de nombres) pour les méthodes de vecteurs de flottants (méthodes avec "fv").
+    - Un {{jsxref("Number")}} entier pour les valeurs entières (méthodes avec "i").
+    - Un {{jsxref("int32Array")}} pour les méthodes de vecteur d'entiers (méthodes avec "iv").
+
+### Valeur retournée
+
+Aucune.
+
+## Exemples
+
+```js
+gl.uniform1f(u_alpha, 0.8);
+```
+
+## Spécifications
+
+| Spécification                                                                    | Statut                               | Commentaire               |
+| -------------------------------------------------------------------------------- | ------------------------------------ | ------------------------- |
+| {{SpecName('WebGL', "#5.14.10", "uniform")}}                     | {{Spec2('WebGL')}}             | Définition initiale.      |
+| {{SpecName('OpenGL ES 2.0', "glUniform.xml", "glUniform")}} | {{Spec2('OpenGL ES 2.0')}} | Page man de l'API OpenGL. |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.WebGLRenderingContext.uniform1f")}}
+
+## Voir aussi
+
+- {{domxref("WebGLRenderingContext.uniformMatrix()")}}
diff --git a/files/fr/web/api/webglrenderingcontext/uniformmatrix/index.md b/files/fr/web/api/webglrenderingcontext/uniformmatrix/index.md
index 14f4da6939..7b3c46bc01 100644
--- a/files/fr/web/api/webglrenderingcontext/uniformmatrix/index.md
+++ b/files/fr/web/api/webglrenderingcontext/uniformmatrix/index.md
@@ -1,5 +1,5 @@
 ---
-title: 'WebGLRenderingContext.uniformMatrix[234]fv()'
+title: WebGLRenderingContext.uniformMatrix[234]fv()
 slug: Web/API/WebGLRenderingContext/uniformMatrix
 tags:
   - API
@@ -16,73 +16,68 @@ tags:
   - uniformMatrix4fv
 translation_of: Web/API/WebGLRenderingContext/uniformMatrix
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>Les méthodes <strong><code>WebGLRenderingContext.uniformMatrix[234]fv()</code></strong> de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> définissent des valeurs matricielles pour les variables uniform.</p>
+Les méthodes **`WebGLRenderingContext.uniformMatrix[234]fv()`** de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API) définissent des valeurs matricielles pour les variables uniform.
 
-<p>Les trois versions de cette méthode (<code>uniformMatrix2fv()</code>, <code>uniformMatrix3fv()</code> et <code>unifomMatrix4fv()</code>) prennent comme valeur d'entrée des vecteurs à 2, 3 et 4 composantes, respectivement.</p>
+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.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><em>WebGLRenderingContext</em>.uniformMatrix2fv(<em>emplacement</em>, <em>transposer</em>, <em>valeur</em>);
-<em>WebGLRenderingContext</em>.uniformMatrix3fv(<em>emplacement</em>, <em>transposer</em>, <em>valeur</em>);
-<em>WebGLRenderingContext</em>.uniformMatrix4fv(<em>emplacement</em>, <em>transposer</em>, <em>valeur</em>);
-</pre>
+    WebGLRenderingContext.uniformMatrix2fv(emplacement, transposer, valeur);
+    WebGLRenderingContext.uniformMatrix3fv(emplacement, transposer, valeur);
+    WebGLRenderingContext.uniformMatrix4fv(emplacement, transposer, valeur);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>emplacement</code></dt>
- <dd>Un objet {{domxref("WebGLUniformLocation")}} contenant l'emplacement de l'attribut uniform à modifier. L'emplacement est obtenu en utilisant {{domxref("WebGLRenderingContext.getAttribLocation", "getAttribLocation()")}}.</dd>
- <dt><code>transposer</code></dt>
- <dd>Un {{domxref("GLboolean")}} indiquant si la matrice doit être transposée. Doit être <code>false</code>.</dd>
- <dt><code>valeur</code></dt>
- <dd>
- <p>Un {{jsxref("Float32Array")}} ou une suite de valeurs <code>GLfloat</code>.</p>
- </dd>
-</dl>
+- `emplacement`
+  - : Un objet {{domxref("WebGLUniformLocation")}} contenant l'emplacement de l'attribut uniform à modifier. L'emplacement est obtenu en utilisant {{domxref("WebGLRenderingContext.getAttribLocation", "getAttribLocation()")}}.
+- `transposer`
+  - : Un {{domxref("GLboolean")}} indiquant si la matrice doit être transposée. Doit être `false`.
+- `valeur`
+  - : Un {{jsxref("Float32Array")}} ou une suite de valeurs `GLfloat`.
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+### Valeur retournée
 
-<p><code>undefined</code></p>
+`undefined`
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">gl.uniformMatrix2fv(loc, false, [2.1, 2.2]);</pre>
+```js
+gl.uniformMatrix2fv(loc, false, [2.1, 2.2]);
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
 <table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.10", "uniformMatrix")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>
-    <p>Définition initiale.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glUniform.xml", "glUniform")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>
-    <p>Page man de l’API OpenGL.</p>
-   </td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <th scope="col">Spécification</th>
+      <th scope="col">Statut</th>
+      <th scope="col">Commentaire</th>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('WebGL', "#5.14.10", "uniformMatrix")}}
+      </td>
+      <td>{{Spec2('WebGL')}}</td>
+      <td><p>Définition initiale.</p></td>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('OpenGL ES 2.0', "glUniform.xml", "glUniform")}}
+      </td>
+      <td>{{Spec2('OpenGL ES 2.0')}}</td>
+      <td><p>Page man de l’API OpenGL.</p></td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.WebGLRenderingContext.uniformMatrix2fv")}}</p>
+{{Compat("api.WebGLRenderingContext.uniformMatrix2fv")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{domxref("WebGLRenderingContext.uniform()")}}</li>
- <li>{{domxref("WebGL2RenderingContext.uniformMatrix()")}} – versions WebGL 2 de ces méthodes.</li>
-</ul>
+- {{domxref("WebGLRenderingContext.uniform()")}}
+- {{domxref("WebGL2RenderingContext.uniformMatrix()")}} – versions WebGL 2 de ces méthodes.
diff --git a/files/fr/web/api/webglrenderingcontext/useprogram/index.md b/files/fr/web/api/webglrenderingcontext/useprogram/index.md
index dced5c95a4..5c9c37bf30 100644
--- a/files/fr/web/api/webglrenderingcontext/useprogram/index.md
+++ b/files/fr/web/api/webglrenderingcontext/useprogram/index.md
@@ -9,29 +9,27 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/useProgram
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La méthode <strong><code>WebGLRenderingContext.useProgram()</code></strong> de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> définit le {{domxref("WebGLProgram")}} spécifié comme faisant partie de l'état de rendu en cours.</p>
+La méthode **`WebGLRenderingContext.useProgram()`** de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API) définit le {{domxref("WebGLProgram")}} spécifié comme faisant partie de l'état de rendu en cours.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">void <var>gl</var>.useProgram(<var>programme</var>);
-</pre>
+    void gl.useProgram(programme);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt>programme</dt>
- <dd>Un {{domxref("WebGLProgram")}} à utiliser.</dd>
-</dl>
+- programme
+  - : Un {{domxref("WebGLProgram")}} à utiliser.
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+### Valeur retournée
 
-<p>Aucune.</p>
+Aucune.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">var programme = gl.createProgram();
+```js
+var programme = gl.createProgram();
 
 // Attacher les shaders pré-existants
 gl.attachShader(programme, vertexShader);
@@ -39,42 +37,25 @@ gl.attachShader(programme, fragmentShader);
 
 gl.linkProgram(programme);
 gl.useProgram(programme);
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.9", "useProgram")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glUseProgram.xml", "glUseProgram")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man de l'API OpenGL.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibilité_des_navigateurs">Browser compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.WebGLRenderingContext.useProgram")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("WebGLRenderingContext.createProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.deleteProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.isProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.linkProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.validateProgram()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getProgramParameter()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getProgramInfoLog()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                            | Statut                               | Commentaire               |
+| ---------------------------------------------------------------------------------------- | ------------------------------------ | ------------------------- |
+| {{SpecName('WebGL', "#5.14.9", "useProgram")}}                             | {{Spec2('WebGL')}}             | Définition initiale.      |
+| {{SpecName('OpenGL ES 2.0', "glUseProgram.xml", "glUseProgram")}} | {{Spec2('OpenGL ES 2.0')}} | Page man de l'API OpenGL. |
+
+## Browser compatibilité des navigateurs
+
+{{Compat("api.WebGLRenderingContext.useProgram")}}
+
+## Voir aussi
+
+- {{domxref("WebGLRenderingContext.createProgram()")}}
+- {{domxref("WebGLRenderingContext.deleteProgram()")}}
+- {{domxref("WebGLRenderingContext.isProgram()")}}
+- {{domxref("WebGLRenderingContext.linkProgram()")}}
+- {{domxref("WebGLRenderingContext.validateProgram()")}}
+- {{domxref("WebGLRenderingContext.getProgramParameter()")}}
+- {{domxref("WebGLRenderingContext.getProgramInfoLog()")}}
diff --git a/files/fr/web/api/webglrenderingcontext/vertexattribpointer/index.md b/files/fr/web/api/webglrenderingcontext/vertexattribpointer/index.md
index 93961c4fda..eaf1aee0b2 100644
--- a/files/fr/web/api/webglrenderingcontext/vertexattribpointer/index.md
+++ b/files/fr/web/api/webglrenderingcontext/vertexattribpointer/index.md
@@ -9,142 +9,133 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/vertexAttribPointer
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La méthode <strong><code>WebGLRenderingContext.vertexAttribPointer()</code> </strong>de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> spécifie la disposition en mémoire de l'objet de tampon vertex. Elle doit être appelée une fois pour chaque attribut de sommet.</p>
+La méthode **`WebGLRenderingContext.vertexAttribPointer()` **de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API) spécifie la disposition en mémoire de l'objet de tampon vertex. Elle doit être appelée une fois pour chaque attribut de sommet.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">void <em>gl</em>.vertexAttribPointer(<em>indice</em>, <em>taille</em>, <em>type</em>, <em>normalise</em>, <em>pas</em>, <em>decalage</em>);
-</pre>
+    void gl.vertexAttribPointer(indice, taille, type, normalise, pas, decalage);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>indice</code></dt>
- <dd>Un {{domxref("GLuint")}} indiquant l'indice de l'attribut de sommet à modifier.</dd>
- <dt><code>taille</code></dt>
- <dd>Un {{domxref("GLint")}} indiquant le nombre de composantes par attribut de sommet. Doit être 1, 2, 3 ou 4.</dd>
- <dt><code>type</code></dt>
- <dd>Un {{domxref ("GLenum")}} spécifiant le type de données de chaque composante dans le tableau. Valeurs possibles :
- <ul>
-  <li><code>gl.BYTE</code> : entier signé sur 8 bits, à valeurs dans [-128, 127]</li>
-  <li><code>gl.SHORT</code> : entier signé sur 16 bits, à valeurs dans [-32768, 32767]</li>
-  <li><code>gl.UNSIGNED_BYTE</code> : entier non signé sur 8 bits, à valeurs dans [0, 255]</li>
-  <li><code>gl.UNSIGNED_SHORT</code> : entier non signé sur 16 bits, à valeurs dans [0, 65535]</li>
-  <li><code>gl.FLOAT</code> : nombre flottant IEEE 32 bits</li>
-  <li>lors de l'utilisation d'un {{domxref("WebGL2RenderingContext", "WebGL context 2", "", 1)}}, la valeur suivante est en outre disponible :
-   <ul>
-    <li><code>gl.HALF_FLOAT</code> : nombre flottant IEEE 16 bits</li>
-   </ul>
-  </li>
- </ul>
- </dd>
- <dt><code>normalise</code></dt>
- <dd>Un {{domxref("GLboolean")}} indiquant si les valeurs des données entières doivent être normalisées dans une certaine plage lorsqu'elles sont converties en flottant.
- <ul>
-  <li>Pour les types <code>gl.BYTE</code> et <code>gl.SHORT</code>, normalise les valeurs à [-1, 1] si <code>true</code>.</li>
-  <li>Pour les types <code>gl.UNSIGNED_BYTE</code> et <code>gl.UNSIGNED_SHORT</code>, normalise les valeurs à [0, 1] si <code>true</code>.</li>
-  <li>Pour les types <code>gl.FLOAT</code> et <code>gl.HALF_FLOAT</code>, ce paramètre est sans effet.</li>
- </ul>
- </dd>
- <dt><code>pas</code></dt>
- <dd>Un {{domxref ("GLsizei")}} spécifiant le décalage en octets entre le début des attributs de sommets consécutifs. Ne peut être supérieur à 255. Si la valeur de <code>pas</code> est 0, l'attribut est supposé être étroitement compacté, c'est-à-dire que les attributs ne sont pas entrelacés mais que chaque attribut se trouve dans un bloc distinct et que l'attribut du sommet suivant suit immédiatement le sommet en cours.</dd>
- <dt><code>decalage</code></dt>
- <dd>Un {{domxref ("GLintptr")}} spécifiant le décalage en octets de la première composante dans le tableau d'attributs de sommets. Doit être un multiple de <code>type</code>.</dd>
-</dl>
+- `indice`
+  - : Un {{domxref("GLuint")}} indiquant l'indice de l'attribut de sommet à modifier.
+- `taille`
+  - : Un {{domxref("GLint")}} indiquant le nombre de composantes par attribut de sommet. Doit être 1, 2, 3 ou 4.
+- `type`
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+  - : Un {{domxref ("GLenum")}} spécifiant le type de données de chaque composante dans le tableau. Valeurs possibles :
 
-<p>Aucune.</p>
+    - `gl.BYTE` : entier signé sur 8 bits, à valeurs dans \[-128, 127]
+    - `gl.SHORT` : entier signé sur 16 bits, à valeurs dans \[-32768, 32767]
+    - `gl.UNSIGNED_BYTE` : entier non signé sur 8 bits, à valeurs dans \[0, 255]
+    - `gl.UNSIGNED_SHORT` : entier non signé sur 16 bits, à valeurs dans \[0, 65535]
+    - `gl.FLOAT` : nombre flottant IEEE 32 bits
+    - lors de l'utilisation d'un {{domxref("WebGL2RenderingContext", "WebGL context 2", "", 1)}}, la valeur suivante est en outre disponible :
 
-<h3 id="Exceptions">Exceptions</h3>
+      - `gl.HALF_FLOAT` : nombre flottant IEEE 16 bits
 
-<ul>
- <li>Une erreur <code>gl.INVALID_VALUE</code> est déclenchée si <code>decalage</code> est négatif.</li>
- <li>Une erreur <code>gl.INVALID_OPERATION</code> est déclenchée si  <code>pas</code> et <code>decalage</code> ne sont pas des multiples de la taille du type de données.</li>
- <li>Une erreur  <code>gl.INVALID_OPERATION</code> est déclenchée si aucun WebGLBuffer n'est lié à la cible ARRAY_BUFFER.</li>
- <li>Lors de l'utilisation d'un {{domxref("WebGL2RenderingContext", "WebGL 2 context", "", 1)}}, une erreur  <code>gl.INVALID_OPERATION</code> est déclenchée si l'attribut du sommet est défini comme entier dans le shader de sommet (par ex., <code>uvec4</code> or <code>ivec4</code>, iau lieu de <code>vec4</code>).</li>
-</ul>
+- `normalise`
 
-<h2 id="Description">Description</h2>
+  - : Un {{domxref("GLboolean")}} indiquant si les valeurs des données entières doivent être normalisées dans une certaine plage lorsqu'elles sont converties en flottant.
 
-<p>Supposons que nous voulions afficher une géométrie 3D, et que pour cela, nous ayons besoin de fournir nos sommets au Shader de Sommet. Chaque sommet a un certain nombre d'attributs, tels que la position, le vecteur normal ou les coordonnées de texture, qui sont définis dans un {{jsxref("ArrayBuffer")}} et qui seront fournis à l'Objet de Tampon de Sommets (OTS). Grâce à cette méthode <code>gl.vertexAttribPointer()</code>, nous spécifions dans quel ordre les attributs sont stockés, et quel est leur type de données. De plus, nous devons inclure le pas, qui est la longueur totale en octets de tous les attributs pour un sommet. Également, nous devons appeler {{domxref("WebGLRenderingContext/enableVertexAttribArray", "gl.enableVertexAttribArray()")}} pour indiquer à WebGL que cet attribut doit être rempli avec les données de notre tampon de tableaux.</p>
+    - Pour les types `gl.BYTE` et `gl.SHORT`, normalise les valeurs à \[-1, 1] si `true`.
+    - Pour les types `gl.UNSIGNED_BYTE` et `gl.UNSIGNED_SHORT`, normalise les valeurs à \[0, 1] si `true`.
+    - Pour les types `gl.FLOAT` et `gl.HALF_FLOAT`, ce paramètre est sans effet.
 
-<p>Habituellement, votre géométrie 3D se trouve déjà dans un certain format binaire, de sorte que vous devez lire la spécification de ce format particulier pour comprendre la disposition en mémoire. Cependant, si vous concevez le format vous-même, ou si votre géométrie se trouve dans des fichiers texte (comme les fichiers Wavefront .obj) et doit être convertie en <code>ArrayBuffer</code> à l'exécution, vous êtes libre de choisir comment structurer la mémoire. Pour des performances optimales, entrelacez les attributs et utilisez le plus petit type de données représentant néanmoins fidèlement votre géométrie.</p>
+- `pas`
+  - : Un {{domxref ("GLsizei")}} spécifiant le décalage en octets entre le début des attributs de sommets consécutifs. Ne peut être supérieur à 255. Si la valeur de `pas` est 0, l'attribut est supposé être étroitement compacté, c'est-à-dire que les attributs ne sont pas entrelacés mais que chaque attribut se trouve dans un bloc distinct et que l'attribut du sommet suivant suit immédiatement le sommet en cours.
+- `decalage`
+  - : Un {{domxref ("GLintptr")}} spécifiant le décalage en octets de la première composante dans le tableau d'attributs de sommets. Doit être un multiple de `type`.
 
-<p>Le nombre maximum d'attributs de vertex dépend de la carte graphique, et vous pouvez appeler <code>gl.getParameter(gl.MAX_VERTEX_ATTRIBS)</code> pour obtenir cette valeur. Sur les cartes graphiques haut de gamme, le maximum est de 16, sur les cartes graphiques de bas de gamme, la valeur sera inférieure.</p>
+### Valeur retournée
 
-<h3 id="Indice_d'attribut">Indice d'attribut</h3>
+Aucune.
 
-<p>Pour chaque attribut, vous devez spécifier son indice. Cela est indépendant de l'emplacement à l'intérieur de la mémoire tampon de tableaux, de sorte que vos attributs peuvent être envoyés dans un ordre différent de celui dans lequel ils sont stockés dans le tampon de tableaux. Vous avez deux options :</p>
+### Exceptions
 
-<ul>
- <li>Soit vous spécifiez l'index vous-même. Dans ce cas, vous appelerez {{domxref("WebGLRenderingContext.bindAttribLocation()", "gl.bindAttribLocation()")}} pour connecter un attribut nommé du shader de sommet à l'index que vous voulez utiliser. Cela doit être fait avant d'appeler {{domxref("WebGLRenderingContext.linkProgram()", "gl.linkProgram()")}}. Vous pouvez alors fournir ce même index à <code>gl.vertexAttribPointer()</code>.</li>
- <li>En variante, vous pouvez utiliser l'index affecté par la carte graphique lors de la compilation du shader de sommet. Suivant la carte graphique, l'index varie, aussi devrez-vous appeler {{domxref("WebGLRenderingContext.getAttribLocation()", "gl.getAttribLocation()")}} pour trouver l'index, puis le fournir à <code>gl.vertexAttribPointer()</code>.<br>
-  Si vous utilisez WebGL 2, vous pouvez spécifier l'index vous-même dans le code du shader de sommet et remplacer la valeur par défaut utilisée par la carte graphique, par ex. <code>layout(location = 3) in vec4 position;</code> définirait l'attribut <code>"position"</code> à l'indice 3.</li>
-</ul>
+- Une erreur `gl.INVALID_VALUE` est déclenchée si `decalage` est négatif.
+- Une erreur `gl.INVALID_OPERATION` est déclenchée si  `pas` et `decalage` ne sont pas des multiples de la taille du type de données.
+- Une erreur  `gl.INVALID_OPERATION` est déclenchée si aucun WebGLBuffer n'est lié à la cible ARRAY_BUFFER.
+- Lors de l'utilisation d'un {{domxref("WebGL2RenderingContext", "WebGL 2 context", "", 1)}}, une erreur  `gl.INVALID_OPERATION` est déclenchée si l'attribut du sommet est défini comme entier dans le shader de sommet (par ex., `uvec4` or `ivec4`, iau lieu de `vec4`).
 
-<h3 id="Attributs_entiers">Attributs entiers</h3>
+## Description
 
-<p>Bien que le <code>ArrayBuffer</code> puisse être rempli à la fois d'entiers et de flottants, les attributs seront toujours convertis en flottant lorsqu'ils seront envoyés au shader de sommet. Si vous avez besoin d'utiliser des entiers dans votre code de shader de sommet, vous pouvez, soit reconvertir les flottants en entiers dans le shader de sommet (par exemple, <code>(int) floatNumber</code>), soit utiliser {{domxref("WebGL2RenderingContext.vertexAttribIPointer()", "gl.vertexAttribIPointer()")}} à partir de WebGL2.</p>
+Supposons que nous voulions afficher une géométrie 3D, et que pour cela, nous ayons besoin de fournir nos sommets au Shader de Sommet. Chaque sommet a un certain nombre d'attributs, tels que la position, le vecteur normal ou les coordonnées de texture, qui sont définis dans un {{jsxref("ArrayBuffer")}} et qui seront fournis à l'Objet de Tampon de Sommets (OTS). Grâce à cette méthode `gl.vertexAttribPointer()`, nous spécifions dans quel ordre les attributs sont stockés, et quel est leur type de données. De plus, nous devons inclure le pas, qui est la longueur totale en octets de tous les attributs pour un sommet. Également, nous devons appeler {{domxref("WebGLRenderingContext/enableVertexAttribArray", "gl.enableVertexAttribArray()")}} pour indiquer à WebGL que cet attribut doit être rempli avec les données de notre tampon de tableaux.
 
-<h3 id="Valeurs_d'attribut_par_défaut">Valeurs d'attribut par défaut</h3>
+Habituellement, votre géométrie 3D se trouve déjà dans un certain format binaire, de sorte que vous devez lire la spécification de ce format particulier pour comprendre la disposition en mémoire. Cependant, si vous concevez le format vous-même, ou si votre géométrie se trouve dans des fichiers texte (comme les fichiers Wavefront .obj) et doit être convertie en `ArrayBuffer` à l'exécution, vous êtes libre de choisir comment structurer la mémoire. Pour des performances optimales, entrelacez les attributs et utilisez le plus petit type de données représentant néanmoins fidèlement votre géométrie.
 
-<p>Le code de vertex shader peut inclure un certain nombre d'attributs, mais nous n'avons pas besoin de spécifier les valeurs pour chaque attribut. A la place, nous pouvons fournir une valeur par défaut qui sera identique pour tous les sommets. Nous pouvons appeler <code>{{domxref("WebGLRenderingContext.disableVertexAttribArray()", "gl.disableVertexAttribArray()")}}</code> pour indiquer à WebGL d'utiliser la valeur par défaut, tandis que l'appel à {{domxref("WebGLRenderingContext.enableVertexAttribArray ()", "gl.enableVertexAttribArray () ")}} lira les valeurs du buffer du tableau comme spécifié avec <code>gl.vertexAttribPointer()</code>.</p>
+Le nombre maximum d'attributs de vertex dépend de la carte graphique, et vous pouvez appeler `gl.getParameter(gl.MAX_VERTEX_ATTRIBS)` pour obtenir cette valeur. Sur les cartes graphiques haut de gamme, le maximum est de 16, sur les cartes graphiques de bas de gamme, la valeur sera inférieure.
 
-<p>De façon similaire, si notre shader de sommet attend par ex. un attribut à 4 composantes avec <code>vec4</code>, mais que dans notre appel à <code>gl.vertexAttribPointer()</code>, nous définissons la taille à 2, alors WebGL définira les deux premières composantes en se basant sur le tampon des tableaux, tandis que les troisième et quatrième composantes prendront la valeur par défaut.</p>
+### Indice d'attribut
 
-<p>La valeur par défaut est <code>vec4(0.0, 0.0, 0.0, 1.0)</code> par défaut, mais nous pouvons spécifier une valeur par défaut différente avec <code>{{domxref ("WebGLRenderingContext.vertexAttrib()", "gl.vertexAttrib[1234]f[v]()")}}</code>.</p>
+Pour chaque attribut, vous devez spécifier son indice. Cela est indépendant de l'emplacement à l'intérieur de la mémoire tampon de tableaux, de sorte que vos attributs peuvent être envoyés dans un ordre différent de celui dans lequel ils sont stockés dans le tampon de tableaux. Vous avez deux options :
 
-<p>Par exemple, votre shader de sommet peut utiliser une position et un attribut de couleur. La plupart des maillages ont leur couleur spécifiée au niveau des sommets, mais certains maillages ont une teinte uniforme. Pour ces maillages, il n'est pas nécessaire de définir la même couleur pour chaque sommet dans le tampon des tableaux, aussi vous utiliserez <code>gl.vertexAttrib4fv()</code> pour définir une couleur constante.</p>
+- Soit vous spécifiez l'index vous-même. Dans ce cas, vous appelerez {{domxref("WebGLRenderingContext.bindAttribLocation()", "gl.bindAttribLocation()")}} pour connecter un attribut nommé du shader de sommet à l'index que vous voulez utiliser. Cela doit être fait avant d'appeler {{domxref("WebGLRenderingContext.linkProgram()", "gl.linkProgram()")}}. Vous pouvez alors fournir ce même index à `gl.vertexAttribPointer()`.
+- En variante, vous pouvez utiliser l'index affecté par la carte graphique lors de la compilation du shader de sommet. Suivant la carte graphique, l'index varie, aussi devrez-vous appeler {{domxref("WebGLRenderingContext.getAttribLocation()", "gl.getAttribLocation()")}} pour trouver l'index, puis le fournir à `gl.vertexAttribPointer()`.
+  Si vous utilisez WebGL 2, vous pouvez spécifier l'index vous-même dans le code du shader de sommet et remplacer la valeur par défaut utilisée par la carte graphique, par ex. `layout(location = 3) in vec4 position;` définirait l'attribut `"position"` à l'indice 3.
 
-<h3 id="Interrogation_des_paramètres_en_cours">Interrogation des paramètres en cours</h3>
+### Attributs entiers
 
-<p>Vous pouvez appeler {{domxref ("WebGLRenderingContext.getVertexAttrib()", "gl.getVertexAttrib()")}} et {{domxref ("WebGLRenderingContext.getVertexAttribOffset()", "gl.getVertexAttribOffset()")}} pour obtenir les paramètres en cours d'un attribut, par ex., le type de données ou si l'attribut doit être normalisé. Gardez présent à l'esprit que ces fonctions WebGL ont des performances faibles et qu'il est préférable de stocker l'état dans votre application JavaScript. Cependant, ces fonctions sont idéales pour déboguer un contexte WebGL sans toucher au code de l'application.</p>
+Bien que le `ArrayBuffer` puisse être rempli à la fois d'entiers et de flottants, les attributs seront toujours convertis en flottant lorsqu'ils seront envoyés au shader de sommet. Si vous avez besoin d'utiliser des entiers dans votre code de shader de sommet, vous pouvez, soit reconvertir les flottants en entiers dans le shader de sommet (par exemple, `(int) floatNumber`), soit utiliser {{domxref("WebGL2RenderingContext.vertexAttribIPointer()", "gl.vertexAttribIPointer()")}} à partir de WebGL2.
 
-<h2 id="Exemples">Exemples</h2>
+### Valeurs d'attribut par défaut
 
-<p>Cet exemple montre comment envoyer vos attributs de sommet au programme shader. Nous utilisons une structure de données imaginaire, dans laquelle les attributs de chaque sommet sont stockés entrelacés avec une longueur de 20 octets par sommet :</p>
+Le code de vertex shader peut inclure un certain nombre d'attributs, mais nous n'avons pas besoin de spécifier les valeurs pour chaque attribut. A la place, nous pouvons fournir une valeur par défaut qui sera identique pour tous les sommets. Nous pouvons appeler `{{domxref("WebGLRenderingContext.disableVertexAttribArray()", "gl.disableVertexAttribArray()")}}` pour indiquer à WebGL d'utiliser la valeur par défaut, tandis que l'appel à {{domxref("WebGLRenderingContext.enableVertexAttribArray ()", "gl.enableVertexAttribArray () ")}} lira les valeurs du buffer du tableau comme spécifié avec `gl.vertexAttribPointer()`.
 
-<ol>
- <li><strong>position :</strong> nous devons stocker les coordonnées X, Y et Z. Pour une précision maximale, nous utilisons des flottants 32 bits ; au total, cela utilise 12 octets ;</li>
- <li><strong>vecteur normal :</strong> nous avons besoin de stocker les composantes X, Y et Z du vecteur normal, mais comme la précision n'est pas si importante que cela, nous utilisons des entiers signés sur 8 bits. Pour de meilleures performances, nous alignons les données sur 32 bits en stockant également une quatrième composante de valeur zéro, ce qui porte la taille totale à 4 octets. Également, nous indiquons à WebGL de normaliser les valeurs, car nos normales sont toujours dans la plage [-1, 1] ;</li>
- <li><strong>coordonnées de texture :</strong> nous avons besoin de stocker les coordonnées U et V ; pour que ces nombres entiers non signés sur 16 bits offrent suffisamment de précision, la taille totale est de 4 octets. Nous indiquons également à WebGL de normaliser les valeurs à [0, 1].</li>
-</ol>
+De façon similaire, si notre shader de sommet attend par ex. un attribut à 4 composantes avec `vec4`, mais que dans notre appel à `gl.vertexAttribPointer()`, nous définissons la taille à 2, alors WebGL définira les deux premières composantes en se basant sur le tampon des tableaux, tandis que les troisième et quatrième composantes prendront la valeur par défaut.
 
-<p>Par exemple, le sommet suivant :</p>
+La valeur par défaut est `vec4(0.0, 0.0, 0.0, 1.0)` par défaut, mais nous pouvons spécifier une valeur par défaut différente avec `{{domxref ("WebGLRenderingContext.vertexAttrib()", "gl.vertexAttrib[1234]f[v]()")}}`.
 
-<pre class="brush: json">{
+Par exemple, votre shader de sommet peut utiliser une position et un attribut de couleur. La plupart des maillages ont leur couleur spécifiée au niveau des sommets, mais certains maillages ont une teinte uniforme. Pour ces maillages, il n'est pas nécessaire de définir la même couleur pour chaque sommet dans le tampon des tableaux, aussi vous utiliserez `gl.vertexAttrib4fv()` pour définir une couleur constante.
+
+### Interrogation des paramètres en cours
+
+Vous pouvez appeler {{domxref ("WebGLRenderingContext.getVertexAttrib()", "gl.getVertexAttrib()")}} et {{domxref ("WebGLRenderingContext.getVertexAttribOffset()", "gl.getVertexAttribOffset()")}} pour obtenir les paramètres en cours d'un attribut, par ex., le type de données ou si l'attribut doit être normalisé. Gardez présent à l'esprit que ces fonctions WebGL ont des performances faibles et qu'il est préférable de stocker l'état dans votre application JavaScript. Cependant, ces fonctions sont idéales pour déboguer un contexte WebGL sans toucher au code de l'application.
+
+## Exemples
+
+Cet exemple montre comment envoyer vos attributs de sommet au programme shader. Nous utilisons une structure de données imaginaire, dans laquelle les attributs de chaque sommet sont stockés entrelacés avec une longueur de 20 octets par sommet :
+
+1.  **position :** nous devons stocker les coordonnées X, Y et Z. Pour une précision maximale, nous utilisons des flottants 32 bits ; au total, cela utilise 12 octets ;
+2.  **vecteur normal :** nous avons besoin de stocker les composantes X, Y et Z du vecteur normal, mais comme la précision n'est pas si importante que cela, nous utilisons des entiers signés sur 8 bits. Pour de meilleures performances, nous alignons les données sur 32 bits en stockant également une quatrième composante de valeur zéro, ce qui porte la taille totale à 4 octets. Également, nous indiquons à WebGL de normaliser les valeurs, car nos normales sont toujours dans la plage \[-1, 1] ;
+3.  **coordonnées de texture :** nous avons besoin de stocker les coordonnées U et V ; pour que ces nombres entiers non signés sur 16 bits offrent suffisamment de précision, la taille totale est de 4 octets. Nous indiquons également à WebGL de normaliser les valeurs à \[0, 1].
+
+Par exemple, le sommet suivant :
+
+```json
+{
   "position": [1.0, 2.0, 1.5],
   "normale": [1.0, 0.0, 0.0],
   "coordTex": [0.5, 0.25]
 }
-</pre>
+```
 
-<p>sera stocké dans le tampon des tableaux comme suit :</p>
+sera stocké dans le tampon des tableaux comme suit :
 
 <table>
- <tbody>
-  <tr>
-   <td>00 00 80 3F</td>
-   <td>00 00 00 40</td>
-   <td>00 00 0C 3F</td>
-   <td>7F</td>
-   <td>00</td>
-   <td>00</td>
-   <td>00</td>
-   <td>7F FF</td>
-   <td>3F FF</td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <td>00 00 80 3F</td>
+      <td>00 00 00 40</td>
+      <td>00 00 0C 3F</td>
+      <td>7F</td>
+      <td>00</td>
+      <td>00</td>
+      <td>00</td>
+      <td>7F FF</td>
+      <td>3F FF</td>
+    </tr>
+  </tbody>
 </table>
 
-<h3 id="Création_du_tampon_des_tableaux">Création du tampon des tableaux</h3>
+### Création du tampon des tableaux
 
-<p>Tout d'abord, nous créons dynamiquement le tampon des tableaux à partir de données JSON en utilisant un {{domxref("DataView")}}. Notez l'utilisation de <code>true</code>, car WebGL s'attend à ce que nos données soient en little-endian.</p>
+Tout d'abord, nous créons dynamiquement le tampon des tableaux à partir de données JSON en utilisant un {{domxref("DataView")}}. Notez l'utilisation de `true`, car WebGL s'attend à ce que nos données soient en little-endian.
 
-<pre class="brush: js">// Charger la géometrie avec fetch() et Response.json()
+```js
+// Charger la géometrie avec fetch() et Response.json()
 const response = await fetch('assets/geometry.json');
 const sommets = await response.json();
 
@@ -152,7 +143,7 @@ const sommets = await response.json();
 const tampon = new ArrayBuffer(20 * sommets.length);
 // Remplir le tampon des tableaux
 const dv = new DataView(tampon);
-for (let i = 0; i &lt; sommets.length; i++) {
+for (let i = 0; i < sommets.length; i++) {
   dv.setFloat32(20 * i, sommets[i].position[0], true);
   dv.setFloat32(20 * i + 4, sommets[i].position[1], true);
   dv.setFloat32(20 * i + 8, sommets[i].position[2], true);
@@ -162,27 +153,31 @@ for (let i = 0; i &lt; sommets.length; i++) {
   dv.setInt8(20 * i + 15, 0);
   dv.setUint16(20 * i + 16, sommets[i].coordTex[0] * 0xFFFF, true);
   dv.setUint16(20 * i + 18, sommets[i].coordTex[1] * 0xFFFF, true);
-}</pre>
+}
+```
 
-<p>Pour de meilleures performances, nous pourrions également effectuer la conversion JSON vers ArrayBuffer précédente du côté serveur, par ex. avec Node.js. Nous pourrions alors charger le fichier binaire et l'interpréter comme un tampon de tableaux :</p>
+Pour de meilleures performances, nous pourrions également effectuer la conversion JSON vers ArrayBuffer précédente du côté serveur, par ex. avec Node.js. Nous pourrions alors charger le fichier binaire et l'interpréter comme un tampon de tableaux :
 
-<pre class="brush: js">const response = await fetch('assets/geometry.bin');
+```js
+const response = await fetch('assets/geometry.bin');
 const tampon = await response.arrayBuffer();
-</pre>
+```
 
-<h3 id="Utiliser_le_tampon_de_tableaux_avec_WebGL">Utiliser le tampon de tableaux avec WebGL</h3>
+### Utiliser le tampon de tableaux avec WebGL
 
-<p>Tout d'abord, nous créons un nouvel Objet Tampon de Sommets (OTS) et nous l'alimentons avec notre tampon de tableaux :</p>
+Tout d'abord, nous créons un nouvel Objet Tampon de Sommets (OTS) et nous l'alimentons avec notre tampon de tableaux :
 
-<pre class="brush: js">// Lier le tampon de tableaux à l'Objet Tampon de Sommets
+```js
+// Lier le tampon de tableaux à l'Objet Tampon de Sommets
 const ots = gl.createBuffer();
 gl.bindBuffer(gl.ARRAY_BUFFER, ots);
 gl.bufferData(gl.ARRAY_BUFFER, buffer, gl.STATIC_DRAW);
-</pre>
+```
 
-<p>Ensuite, nous spécifions la disposition en mémoire du tampon de tableaux, soit en définissant nous-mêmes l'indice :</p>
+Ensuite, nous spécifions la disposition en mémoire du tampon de tableaux, soit en définissant nous-mêmes l'indice :
 
-<pre class="brush: js">// Décrire la disposition du tampon :
+```js
+// Décrire la disposition du tampon :
 //1. position, non normalisé
 gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 20, 0);
 gl.enableVertexAttribArray(0);
@@ -200,11 +195,12 @@ gl.bindAttribLocation(shaderProgram, 2, 'texUV');
 // Du fait que indices des attributs ont changé, nous devons refaire l'édition de liens du shader
 // Noter que cela réinitialisera tous les uniforms qui avaient été précédemment définis.
 gl.linkProgram(shaderProgram);
-</pre>
+```
 
-<p>soit en utilisant l'indice fourni par la carte graphique, au lieu de le définir nous-mêmes ; cela évite la réédition des liens du programme shader.</p>
+soit en utilisant l'indice fourni par la carte graphique, au lieu de le définir nous-mêmes ; cela évite la réédition des liens du programme shader.
 
-<pre class="brush: js">const positionLoc = gl.getAttribLocation(shaderProgram, 'position');
+```js
+const positionLoc = gl.getAttribLocation(shaderProgram, 'position');
 gl.vertexAttribPointer(positionLoc, 3, gl.FLOAT, false, 20, 0);
 gl.enableVertexAttribArray(positionLoc);
 
@@ -215,40 +211,38 @@ gl.enableVertexAttribArray(normalLoc);
 const texUVLoc = gl.getAttribLocation(shaderProgram, 'texUV');
 gl.vertexAttribPointer(texUVLoc, 2, gl.UNSIGNED_SHORT, true, 20, 16);
 gl.enableVertexAttribArray(texUVLoc);
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
 <table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.10", "vertexAttribPointer")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>
-    <p>Définition initiale.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glVertexAttribPointer.xml", "glVertexAttribPointer")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>
-    <p>Page man de l’API OpenGL.</p>
-   </td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <th scope="col">Spécification</th>
+      <th scope="col">Statut</th>
+      <th scope="col">Commentaire</th>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('WebGL', "#5.14.10", "vertexAttribPointer")}}
+      </td>
+      <td>{{Spec2('WebGL')}}</td>
+      <td><p>Définition initiale.</p></td>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('OpenGL ES 2.0', "glVertexAttribPointer.xml", "glVertexAttribPointer")}}
+      </td>
+      <td>{{Spec2('OpenGL ES 2.0')}}</td>
+      <td><p>Page man de l’API OpenGL.</p></td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.WebGLRenderingContext.vertexAttribPointer")}}</p>
+{{Compat("api.WebGLRenderingContext.vertexAttribPointer")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="https://www.khronos.org/opengl/wiki/Vertex_Specification">Vertex Specification</a> sur le wiki OpenGL</li>
-</ul>
+- [Vertex Specification](https://www.khronos.org/opengl/wiki/Vertex_Specification) sur le wiki OpenGL
diff --git a/files/fr/web/api/webglrenderingcontext/viewport/index.md b/files/fr/web/api/webglrenderingcontext/viewport/index.md
index 76290a9bd6..beed6333a7 100644
--- a/files/fr/web/api/webglrenderingcontext/viewport/index.md
+++ b/files/fr/web/api/webglrenderingcontext/viewport/index.md
@@ -9,84 +9,67 @@ tags:
   - WebGLRenderingContext
 translation_of: Web/API/WebGLRenderingContext/viewport
 ---
-<div>{{APIRef("WebGL")}}</div>
+{{APIRef("WebGL")}}
 
-<p>La méthode <strong><code>WebGLRenderingContext.viewport()</code></strong> de l'<a href="/fr-FR/docs/Web/API/WebGL_API">API WebGL</a> 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.</p>
+La méthode **`WebGLRenderingContext.viewport()`** de l'[API WebGL](/fr-FR/docs/Web/API/WebGL_API) 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.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var><em>void gl</em>.viewport</var><var>(x, y, largeur, hauteur);</var>
-</pre>
+    void gl.viewport(x, y, largeur, hauteur);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>x</code></dt>
- <dd>Un {{domxref("GLint")}} indiquant la coordonnée horizontale du coin inférieur gauche de l'origine du viewport. Valeur par défaut : 0.</dd>
- <dt><code>y</code></dt>
- <dd>Un {{domxref("GLint")}} indiquant la coordonnée verticale du coin inférieur gauche de l'origine du viewport. Valeur par défaut : 0.</dd>
- <dt>largeur</dt>
- <dd>Un {{domxref("Glsizei")}} non négatif indiquant la largeur du viewport. Valeur par défaut : la largeur du canevas.</dd>
- <dt>height</dt>
- <dd>Un {{domxref("Glsizei")}} non négatif indiquant la hauteur du viewport. Valeur par défaut : la hauteur du canevas.</dd>
-</dl>
+- `x`
+  - : Un {{domxref("GLint")}} indiquant la coordonnée horizontale du coin inférieur gauche de l'origine du viewport. Valeur par défaut : 0.
+- `y`
+  - : Un {{domxref("GLint")}} indiquant la coordonnée verticale du coin inférieur gauche de l'origine du viewport. Valeur par défaut : 0.
+- largeur
+  - : Un {{domxref("Glsizei")}} non négatif indiquant la largeur du viewport. Valeur par défaut : la largeur du canevas.
+- height
+  - : Un {{domxref("Glsizei")}} non négatif indiquant la hauteur du viewport. Valeur par défaut : la hauteur du canevas.
 
-<h3 id="Valeur_retournée">Valeur retournée</h3>
+### Valeur retournée
 
-<p>Aucune.</p>
+Aucune.
 
-<h3 id="Erreurs_déclenchées">Erreurs déclenchées</h3>
+### Erreurs déclenchées
 
-<p>Si <em>largeur</em> ou <em>hauteur</em> est une valeur négative, une erreur <code>gl.INVALID_VALUE</code> est déclenchée.</p>
+Si *largeur* ou *hauteur* est une valeur négative, une erreur `gl.INVALID_VALUE` est déclenchée.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>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 <code>gl.viewport</code>.</p>
+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`.
 
-<pre class="brush: js">gl.viewport(0, 0, canevas.width, canevas.height);
-</pre>
+```js
+gl.viewport(0, 0, canevas.width, canevas.height);
+```
 
-<p>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 <code>MAX_VIEWPORT_DIMS</code>, qui renvoie un {{jsxref ("Int32Array")}}.</p>
+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 {{jsxref ("Int32Array")}}.
 
-<pre class="brush: js">gl.getParameter(gl.MAX_VIEWPORT_DIMS);
+```js
+gl.getParameter(gl.MAX_VIEWPORT_DIMS);
 // Par ex., Int32Array[16384, 16384]
-</pre>
+```
 
-<p>Pour obtenir le viewport en cours, faites une requête sur la constante <code>VIEWPORT</code>.</p>
+Pour obtenir le viewport en cours, faites une requête sur la constante `VIEWPORT`.
 
-<pre class="brush: js">gl.getParameter(gl.VIEWPORT);
+```js
+gl.getParameter(gl.VIEWPORT);
 // e.g. Int32Array[0, 0, 640, 480]
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('WebGL', "#5.14.4", "viewport")}}</td>
-   <td>{{Spec2('WebGL')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('OpenGL ES 2.0', "glViewport.xml", "glViewport")}}</td>
-   <td>{{Spec2('OpenGL ES 2.0')}}</td>
-   <td>Page man de l'API OpenGL.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.WebGLRenderingContext.viewport")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("WebGLRenderingContext.scissor()")}}</li>
- <li>{{domxref("WebGLRenderingContext.getParameter()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                    | Statut                               | Commentaire               |
+| -------------------------------------------------------------------------------- | ------------------------------------ | ------------------------- |
+| {{SpecName('WebGL', "#5.14.4", "viewport")}}                     | {{Spec2('WebGL')}}             | Définition initiale.      |
+| {{SpecName('OpenGL ES 2.0', "glViewport.xml", "glViewport")}} | {{Spec2('OpenGL ES 2.0')}} | Page man de l'API OpenGL. |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.WebGLRenderingContext.viewport")}}
+
+## Voir aussi
+
+- {{domxref("WebGLRenderingContext.scissor()")}}
+- {{domxref("WebGLRenderingContext.getParameter()")}}