Recomposed
Shader

Introduction aux Shaders

Oct 20, 2026 · 6 min read

Introduction aux Shaders

Ce qu'est réellement un shader

Un shader est un petit programme exécuté par le GPU, pas une fonction que vous appelez une seule fois. Pour un , ce programme s'exécute une fois par pixel, pour chaque pixel à l'intérieur de la zone dessinée, à chaque frame.

AGSL (Android Graphics Shading Language) est le langage de shading d'Android. Ce n'est pas une nouvelle invention : c'est un dialecte restreint de , qui est lui-même proche de GLSL ES. Vous l'écrivez sous forme de simple chaîne de caractères, vous le compilez à l'exécution avec RuntimeShader, et vous utilisez le résultat comme Brush ou comme RenderEffect partout où Compose en attend un.

L'intuition

Il est tentant d'imaginer un shader comme un filtre que l'on configure une fois et que l'on applique à toute une image, de la même manière que fonctionnent BlurEffect ou ColorMatrix. Un shader n'est pas ça. C'est plus proche d'une fonction qui n'a même pas idée qu'une image existe :

  • Le GPU invoque le main de votre shader séparément pour chaque pixel de la zone dessinée, en parallèle, sans ordre garanti entre les invocations.
  • Chaque invocation ne connaît que les coordonnées de son propre pixel et les valeurs que vous lui avez transmises avant l'appel de dessin. Elle ne peut pas lire un pixel voisin, boucler sur l'image, ni se souvenir de quoi que ce soit concernant le pixel d'à côté ou la frame précédente.
  • Tout ce qu'un shader « voit » au-delà de ses propres coordonnées, une texture, un dégradé, le résultat de la frame précédente, doit être explicitement échantillonné, car rien n'est implicitement partagé entre les invocations.

C'est tout le changement d'état d'esprit : un shader décrit la couleur d'un seul pixel comme une fonction pure de ses coordonnées et de ses uniforms, et le GPU est ce qui exécute cette description des millions de fois par frame.

Un shader AGSL minimal

Voici un shader de fragment qui dessine un champ de plasma animé : une couleur calculée à partir de la position de chaque pixel et du temps actuel, se recombinant en bandes qui se déplacent continuellement. Un Brush.radialGradient peut simuler un vignettage statique, mais rien dans Brush ne peut simuler ceci, car la couleur de chaque pixel est une fonction non linéaire de deux entrées à la fois, la position et le temps, recalculée par le GPU à chaque frame. Le code source AGSL est une chaîne de caractères, en rien différente de tout autre littéral de chaîne Kotlin :

private const val PLASMA_SHADER = """
    uniform float2 resolution;
    uniform float time;
 
    half4 main(float2 fragCoord) {
        float2 uv = fragCoord / resolution;
        float wave = sin(uv.x * 10.0 + time) + cos(uv.y * 10.0 - time * 1.3);
        float3 color = 0.5 + 0.5 * cos(float3(wave, wave + 2.0, wave + 4.0));
        return half4(color, 1.0);
    }
"""

Remarquez ce que main reçoit réellement : fragCoord, le pixel dont cette invocation est responsable, rien d'autre. Ni resolution ni time ne sont automatiques, les deux sont des uniforms que vous êtes censé définir vous-même, car le shader n'a aucune notion intégrée de « la taille de ce dans quoi je dessine » ou de « depuis combien de temps l'application tourne ».

Le câbler dans Compose consiste à le compiler une fois avec RuntimeShader, à maintenir les deux uniforms à jour, resolution quand la taille change et time à chaque frame, et à transmettre le résultat à n'importe quelle API qui prend un Brush :

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
    val plasmaShader = remember { RuntimeShader(PLASMA_SHADER) }
    val elapsedSeconds by produceState(0f) {
        val start = withFrameMillis { it }
        while (true) {
            withFrameMillis { value = (it - start) / 1000f }
        }
    }
 
    Box(
        modifier = Modifier
            .fillMaxSize()
            .onSizeChanged { size ->
                plasmaShader.setFloatUniform(
                    "resolution",
                    size.width.toFloat(),
                    size.height.toFloat(),
                )
            }
            .drawBehind {
                plasmaShader.setFloatUniform("time", elapsedSeconds)
                drawRect(brush = ShaderBrush(plasmaShader))
            },
    )
}

RuntimeShader compile le code source AGSL immédiatement, donc une faute de frappe dans la chaîne du shader lève une exception à la construction, pas au moment du dessin. ShaderBrush est ce qui fait le pont vers Compose : il implémente Brush, donc tout ce qui peint avec un Brush (background, Canvas.drawRect, la couleur d'un Text) peut peindre avec un shader au lieu d'une couleur unie ou d'un dégradé.

FIG. 01
Animated plasma shader filling a Box: color bands shifting continuously from sin/cos of position and time, something no static Brush gradient can reproduce.

Le fondamental

Un shader est un programme sans état, parallèle sur les données, par pixel. « Parallèle sur les données » signifie que le même programme s'exécute indépendamment sur de nombreux pixels à la fois au lieu de boucler sur eux un par un. « Sans état » signifie que chaque invocation démarre à zéro : aucune mémoire des autres pixels, aucune mémoire de la frame précédente, à moins que vous ne la réinjectiez explicitement comme uniform ou comme texture échantillonnée.

Où cela se manifeste dans de vraies applications

Le champ de plasma ci-dessus est délibérément un jouet. Le même modèle par pixel est ce qui fonctionne réellement derrière des effets que vous avez déjà vus en production :

  • Dialogues en verre dépoli / flou en arrière-plan : le shader échantillonne un instantané de ce qui se trouve derrière lui et le floute pixel par pixel, c'est ainsi que fonctionne le flou des dialogues et du volet de notifications sous Android 12+ via RenderEffect.
  • Étalonnage des couleurs et filtres LUT : le RGB de chaque pixel est remappé via une fonction de lookup, la même idée qu'utilisent les filtres de style Instagram ou Lightroom, juste exprimée en mathématiques AGSL plutôt qu'avec un ColorMatrix fixe.
  • Ondulation tactile et retour de distorsion : le shader échantillonne son propre shader de contenu à un décalage calculé à partir de la distance au toucher et du temps écoulé, produisant un « squish » en ondulation d'eau à mesure que le doigt se déplace, la même famille d'effet derrière les interactions personnalisées de pull-to-refresh et de swipe liquide (pas le RippleDrawable intégré d'Android, qui est un simple révélateur d'alpha circulaire sans aucun shader impliqué).
  • Textures procédurales et grain : arrière-plans, bruit et motifs de tramage générés à partir de mathématiques pures au moment du dessin, comme le champ de plasma de cet article, plutôt que de livrer un asset bitmap qui doit être mis à l'échelle et carrelé.
  • Aberration chromatique et effets de glitch : les canaux rouge, vert et bleu sont échantillonnés à des décalages de coordonnées légèrement différents, un effet stylistique courant dans les applications d'appareil photo et de retouche photo.

Chacun de ces exemples est le même modèle mental de cet article appliqué à une fonction par pixel différente : seules les mathématiques à l'intérieur de main changent.

Ailleurs : même fondamental, framework différent

  • GLSL (OpenGL/WebGL) : le langage de shading dont descendent à la fois AGSL et SkSL. Le void main() d'un shader de fragment WebGL qui écrit dans gl_FragColor est exactement le même modèle par pixel et sans état, juste avec les conventions de binding d'OpenGL au lieu de celles de RuntimeShader.
  • HLSL (Direct3D, Unity) : même point d'entrée par pixel, syntaxe et modèle de binding différents. La fonction frag d'un shader de fragment Unity reçoit des données interpolées par pixel et retourne une couleur exactement comme le fait main en AGSL.
  • Metal Shading Language (iOS/macOS) : une fonction annotée fragment qui s'exécute une fois par pixel/fragment, en lisant des arguments explicites pour tout ce dont elle a besoin, sans accès implicite à la sortie voisine.
  • SkSL (Skia) : pas seulement un analogue, le véritable parent d'AGSL. Skia utilise SkSL en interne pour ses propres effets, et AGSL est le sous-ensemble public, légèrement restreint, exposé au code applicatif.

Où cela piège réellement les gens

  • Ça plante à l'exécution en dessous de l'API 33, pas à la compilation. RuntimeShader nécessite Android 13 (Tiramisu). Il n'y a aucun avertissement de compilation pour l'appeler sur un minSdk plus ancien, le plantage ne se produit que la première fois que ce chemin de code s'exécute, donc la vérification Build.VERSION.SDK_INT n'est pas du boilerplate optionnel, elle est structurelle.
  • Le shader compile mais le résultat est noir ou entièrement transparent. La cause la plus courante est un uniform non renseigné : resolution est par défaut à (0, 0) jusqu'à ce que vous appeliez setFloatUniform, donc fragCoord / resolution divise par zéro dès la première frame si vous le définissez après le premier dessin plutôt qu'avant.
  • AGSL utilise par défaut la pleine précision float, pas le mediump de GLSL ES. Porter un shader de fragment GLSL ES qui repose sur la plage plus étroite de mediump float pour un effet intentionnel de banding ou de wraparound ne reproduira pas le même artefact en AGSL, sauf si vous tenez compte explicitement de la précision par défaut plus large.

Le modèle mental à utiliser réellement

Arrêtez de demander « que voit ce shader ». Demandez plutôt : « que sait ce pixel » Un shader ne voit jamais l'image, l'écran, ou la frame précédente, il ne voit toujours que ses propres coordonnées et les uniforms que vous avez pensé à définir, ce qui explique aussi exactement pourquoi il peut s'exécuter un million de fois par frame sans se gêner lui-même.

Keep reading

Related reads

Recevez les nouveaux articles par e-mail