---
title: Shaders
description: Les shaders ouvrent un monde de possibilités.
author: alvarosabu
thumbnail: /recipes/shaders.png
difficulty: 2
---
# Shaders
Ce guide vous aidera à démarrer avec les shaders dans TresJS.
Nous allons construire une scène simple avec un blob. Ensuite, nous l'animerons pour le déformer doucement.
::: warning
_Il est nécessaire d’avoir des connaissances de base sur le fonctionnement des shaders_
:::
## Configurer la scène (facultatif)
Nous importons tous les modules dont nous avons besoin. Pour plus de commodité, nous pouvons utiliser les orbit-controls de cientos.
[Voir ici comment](/cookbook/orbit-controls).
Mettons notre caméra en position `[11,11,11]`.
Enfin, pour nous aider avec le placement, ajoutons un plan simple, tourné sur l'axe X, avec une mesure de `[10, 10]` unités.
```vue
```
## ShaderMaterial
Comme vous le savez, chaque instance dans [ThreeJs](https://threejs.org/) est disponible dans **TresJs**, nous pouvons donc également utiliser le `ShaderMaterial`, il suffit d'ajouter le préfixe `Tres` pour l'utiliser.
Pour notre blob, nous pourrions utiliser un simple `SphereGeometry` en ajoutant des `widthSegments` et `heightSegments` pour créer un effet fluide et positionner notre blob 4 unités sur l'axe Y positif.
```vue
```
Le `ShaderMaterial` accepte des propriétés spéciales, telles que `uniforms`, `vertexShader` et `fragmentShader`, afin que nous puissions le créer dans notre section de script et établir la connexion à notre instance.
Pour cet exemple, nos uniformes ressemblent à ceci :
```ts
import { Vector2 } from 'three'
// ...
const uniforms = {
uTime: { value: 0 },
uAmplitude: { value: new Vector2(0.1, 0.1) },
uFrequency: { value: new Vector2(20, 5) },
}
// ..
```
Notre fragment shader ressemble à ceci :
```ts
// ...
const fragmentShader = `
precision mediump float;
varying vec2 vUv;
void main() {
gl_FragColor = vec4(1.0, vUv.y, 0.5, 1.0);
}
`
// ..
```
Et enfin notre `vertexShader`:
```ts
const vertexShader = `
uniform vec2 uAmplitude;
uniform vec2 uFrequency;
uniform float uTime;
varying vec2 vUv;
void main() {
vec4 modelPosition = modelMatrix * vec4(position, 1.0);
modelPosition.y += sin(modelPosition.x * uFrequency.x - uTime) * uAmplitude.x;
modelPosition.x += cos(modelPosition.y * uFrequency.y - uTime) * uAmplitude.y;
vec4 viewPosition = viewMatrix * modelPosition;
gl_Position = projectionMatrix * viewPosition;
vUv = uv;
}
`
// ..
```
## Animer le blob
Semblable à ce que nous avons appris dans l'exemple des [Animations de bases](/cookbook/basic-animations), Nous commençons par référencer notre blob en utilisant [Template Ref](https://vuejs.org/guide/essentials/template-refs.html)
```vue
```
Une fois que nous avons fait cela, nous pouvons utiliser le rappel `onLoop` pour animer notre `uTime`.
```ts
import { TresCanvas, useRenderLoop } from '@tresjs/core'
// ...
const { onLoop } = useRenderLoop()
onLoop(({ elapsed }) => {
if (blobRef.value) {
blobRef.value.material.uniforms.uTime.value = elapsed
}
})
// ...
```
Et voilà, notre shader de base fonctionne correctement.
## Avec GLSL vite-plugin (optionel)
_Cette étape est totalement facultative et hors du cadre de l'équipe **TresJs**._
Définir notre shader en ligne n'est pas toujours la meilleure idée, mais si vous utilisez [vite](https://vitejs.dev/), vous pouvez mettre vos fichiers `GLSL` dans un fichier différent en utilisant le [vite-plugin-glsl](https://www.npmjs.com/package/vite-plugin-glsl). (voir lien pour la documentation officielle)
Et vous devriez avoir une structure similaire à celle-ci :
```
├── src/
│ ├── myTresJsComponent.vue
│ ├── shaders/
│ ├── vertexShader.glsl
│ ├── fragmentShader.glsl
```