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
mainde 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é.
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
ColorMatrixfixe. - 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
RippleDrawableinté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 dansgl_FragColorest exactement le même modèle par pixel et sans état, juste avec les conventions de binding d'OpenGL au lieu de celles deRuntimeShader. - HLSL (Direct3D, Unity) : même point d'entrée par pixel, syntaxe
et modèle de binding différents. La fonction
fragd'un shader de fragment Unity reçoit des données interpolées par pixel et retourne une couleur exactement comme le faitmainen AGSL. - Metal Shading Language (iOS/macOS) : une fonction annotée
fragmentqui 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.
RuntimeShadernécessite Android 13 (Tiramisu). Il n'y a aucun avertissement de compilation pour l'appeler sur unminSdkplus ancien, le plantage ne se produit que la première fois que ce chemin de code s'exécute, donc la vérificationBuild.VERSION.SDK_INTn'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é :
resolutionest par défaut à(0, 0)jusqu'à ce que vous appeliezsetFloatUniform, doncfragCoord / resolutiondivise 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 lemediumpde GLSL ES. Porter un shader de fragment GLSL ES qui repose sur la plage plus étroite demediump floatpour 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.



