# Mettre les éléments à jour ([name])

Tous les objets mettent par défaut automatiquement leur matrice à jour si ils ont été ajoutés dans la scène avec

`const object = new THREE.Object3D(); scene.add( object );` ou si ils sont l'enfant d'un autre objet qui a été ajouté à la scène: `const object1 = new THREE.Object3D(); const object2 = new THREE.Object3D(); object1.add( object2 ); scene.add( object1 ); //object1 and object2 will automatically update their matrices`

Cependant, si vous savez que l'objet va être statique, vous pouvez désactiver ce comportement et mettre la matrice à jour manuellement quand le besoin se présente.

`object.matrixAutoUpdate = false; object.updateMatrix();`

## BufferGeometry

Les BufferGeometries stockent des informations comme (la position des sommets, l'indice des faces, les normales, les couleurs, les UVs et tout autre attribut customisé) dans [page:BufferAttribute buffers] - c'est un, [link:https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays typed arrays]. Ceci les rend généralement plus rapides que les Geometries standard, le contrecoup est qu'il est plus difficile de les utiliser.

En ce qui concerne la mise à jour des BufferGeometries, la chose la plus importante à comprendre est que vous ne pouvez pas changer la taille des buffers (c'est très coûteux, en réalité, c'est équivalent à créer une nouvelle forme). Vous pouvez toutefois mettre à jour le contenu des buffers.

Ce qui signifie que si vous savez qu'un attribut de votre BufferGeometry va augmenter, disons le nombre de sommets, vous devez pré-allouer un buffer assez grand pour contenir n'importe quel nouveau sommet qui pourra être créé. Évidemment, cela signifie également qu'il y aura une taille maximale pour votre BufferGeometry - il n'y a aucun moyen de créer une BufferGeometry qui peut être étendue à l'infini d'une manière efficiente.

Nous utiliserons l'exemple d'une ligne qui est étendue à chaque rendu. Nous allouerons de l'espace dans le buffer pour 500 sommets mais nous n'en dessinerons que deux au début, en utilisant [page:BufferGeometry.drawRange].

`const MAX_POINTS = 500; // geometry const geometry = new THREE.BufferGeometry(); // attributes const positions = new Float32Array( MAX_POINTS * 3 ); // 3 vertices per point geometry.setAttribute( 'position', new THREE.BufferAttribute( positions, 3 ) ); // draw range const drawCount = 2; // draw the first 2 points, only geometry.setDrawRange( 0, drawCount ); // material const material = new THREE.LineBasicMaterial( { color: 0xff0000 } ); // line const line = new THREE.Line( geometry, material ); scene.add( line );`

Ensuite nous ajouterons aléatoirement des points à l'aide d'un pattern comme:

`const positions = line.geometry.attributes.position.array; let x, y, z, index; x = y = z = index = 0; for ( let i = 0, l = MAX_POINTS; i < l; i ++ ) { positions[ index ++ ] = x; positions[ index ++ ] = y; positions[ index ++ ] = z; x += ( Math.random() - 0.5 ) * 30; y += ( Math.random() - 0.5 ) * 30; z += ( Math.random() - 0.5 ) * 30; }`

If you want to change the number of points rendered after the first render, do this:

`line.geometry.setDrawRange( 0, newValue );`

If you want to change the position data values after the first render, you need to set the needsUpdate flag like so:

`line.geometry.attributes.position.needsUpdate = true; // required after the first render`

If you change the position data values after the initial render, you may need to recompute bounding volumes so other features of the engine like view frustum culling or helpers properly work.

`line.geometry.computeBoundingBox(); line.geometry.computeBoundingSphere();`

[link:https://jsfiddle.net/t4m85pLr/1/ Here is a fiddle] showing an animated line which you can adapt to your use case.

### Examples

[example:webgl_custom_attributes WebGL / custom / attributes]
[example:webgl_buffergeometry_custom_attributes_particles WebGL / buffergeometry / custom / attributes / particles]

## Materiaux

Toutes les valeurs uniformes peuvent être changées librement(e.g. couleurs, textures, opacité, etc), les valeurs sont envoyées aux shaders à chaque frame.

De plus, les paramètresen relation avec GLstate peuvent changer à tout moment (depthTest, blending, polygonOffset, etc).

Les propriétés suivantes ne peuvent pas être changées facilement durant l'exécution (une fois que le matériau a été rendu au moins une fois):

- numbers and types of uniforms
- présence ou non de
  - texture
  - fog
  - vertex colors
  - morphing
  - shadow map
  - alpha test
  - transparent

Des changements dans ces propriétés exigent la création d'un nouveau programme de shader. Vous devrez définir

`material.needsUpdate = true`

Gardez à l'esprit que cela risque d'être assez lent et de causer des saccades dans le framerate (particulièrement sur Windows, étant donné que la compilation de shader est plus lente dans DirectX que dans OpenGL).

Pour des expériences pluis fluides vous pouvez émuler des changements dans ces fonctionnalités pour qu'elles contiennent un genre de valeurs "factices" comme zéro en intensité de lumières, des textures blanches ou zéro brouillard.

Vous pouvez librement changer le matériau utilisé pour les différents morceaux de formes, mais pas comment un objet est divisé en morceaux (selon le matériau des faces).

### Si vous avez besoin d'avoir différentes configurations de matériaux durant l'exécution:

Si le nombre de matériaux / morceaux est petit, vous pouvez pré-diviser l'objet préalablement (e.g. cheveux / visage / corps / vêtements supérieurs / pantalon pour un humain, avant / côtés / toit / fenêtres / pneu / intérieur pour une voiture.).

Si le nombre est grand (e.g. chaque face peut potentiellement être différente), songez à utiliser une autre solution, comme l'utilisation d'attributs / textures pour avoir une apparence différente par face.

### Exemples

[example:webgl_materials_car WebGL / materials / car]
[example:webgl_postprocessing_dof WebGL / webgl_postprocessing / dof]

## Textures

Les images, canvas, vidéos et les données des textures doivent avoir le flag suivant si elles sont changées:

`texture.needsUpdate = true;`

La cible du rendu se met automatiquement à jour.

### Exemples

[example:webgl_materials_video WebGL / materials / video]
[example:webgl_rtt WebGL / rtt]

## Caméras

La position de la caméra et sa cible sont automatiquement mises à jour. Si vous devez changer

- fov
- aspect
- near
- far

alors vous aurez besoin de recalculer la matrice de projection:

`camera.aspect = window.innerWidth / window.innerHeight; camera.updateProjectionMatrix();`