Was ein Shader eigentlich ist
Ein Shader ist ein kleines Programm, das die GPU ausführt, keine Funktion, die man einmal aufruft. Bei einem läuft dieses Programm einmal pro Pixel, für jedes Pixel innerhalb der gezeichneten Fläche, in jedem einzelnen Frame.
AGSL (Android Graphics Shading Language) ist Androids Shader-Sprache.
Sie ist keine Neuerfindung, sondern ein eingeschränkter Dialekt von
,
das selbst nahe an GLSL ES liegt. Man schreibt sie als einfachen String,
kompiliert sie zur Laufzeit mit RuntimeShader und verwendet das Ergebnis
überall dort als Brush oder RenderEffect, wo Compose eines erwartet.
Die Intuition
Es liegt nahe, sich einen Shader als Filter vorzustellen, den man einmal
konfiguriert und auf ein ganzes Bild anwendet, so wie BlurEffect oder
ColorMatrix funktionieren. So ist ein Shader nicht. Er kommt eher einer
Funktion gleich, die keine Ahnung hat, dass überhaupt ein Bild existiert:
- Die GPU ruft die
main-Funktion des Shaders für jedes Pixel in der Zeichenfläche separat auf, parallel, ohne garantierte Reihenfolge zwischen den Aufrufen. - Jeder Aufruf kennt nur seine eigene Pixelkoordinate und die -Werte, die man ihm vor dem Zeichenaufruf übergeben hat. Er kann kein benachbartes Pixel lesen, nicht über das Bild iterieren und sich an nichts vom Nachbarpixel oder vom vorherigen Frame erinnern.
- Alles, was ein Shader über seine eigene Koordinate hinaus "sieht", eine Textur, einen Gradienten, die Ausgabe des letzten Frames, muss explizit abgetastet werden, denn zwischen den Aufrufen wird nichts implizit geteilt.
Das ist der ganze mentale Wechsel: Ein Shader beschreibt die Farbe eines Pixels als reine Funktion seiner Koordinate und seiner Uniforms, und die GPU ist das, was diese Beschreibung Millionen Mal pro Frame ausführt.
Ein minimaler AGSL-Shader
Hier ist ein Fragment-Shader, der ein animiertes Plasmafeld zeichnet: Die
Farbe wird aus der Position jedes Pixels und der aktuellen Zeit berechnet
und fügt sich zu Bändern zusammen, die sich kontinuierlich verschieben.
Ein Brush.radialGradient kann eine statische Vignette vortäuschen, aber
nichts in Brush kann das hier vortäuschen, weil die Farbe an jedem Pixel
eine nichtlineare Funktion von zwei Eingaben gleichzeitig ist, Position
und Zeit, die von der GPU in jedem einzelnen Frame neu berechnet wird. Der
AGSL-Quelltext ist ein String, nicht anders als jedes andere
Kotlin-String-Literal:
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);
}
"""Man beachte, was main tatsächlich erhält: fragCoord, das Pixel, für
das genau dieser Aufruf verantwortlich ist, nichts weiter. Weder
resolution noch time ist automatisch vorhanden, beide sind Uniforms,
die man selbst setzen muss, denn der Shader hat keinen eingebauten Begriff
von "der Größe des Dings, in das ich zeichne" oder "wie lange die App
schon läuft".
Ihn in Compose einzubinden bedeutet, ihn einmal mit RuntimeShader zu
kompilieren, beide Uniforms aktuell zu halten, resolution wenn sich die
Größe ändert und time in jedem einzelnen Frame, und das Ergebnis an
jede API zu übergeben, die einen Brush entgegennimmt:
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 kompiliert den AGSL-Quelltext sofort, sodass ein
Tippfehler im Shader-String schon bei der Konstruktion und nicht erst
beim Zeichnen eine Exception auslöst. ShaderBrush ist das, was die
Brücke zu Compose schlägt: Es implementiert Brush, sodass alles, was
mit einem Brush malt (background, Canvas.drawRect, eine
Text-Farbe), statt mit einer Flächenfarbe oder einem Gradienten mit
einem Shader malen kann.
Das Fundamentale
Ein Shader ist ein datenparalleles, zustandsloses Pro-Pixel-Programm. "Datenparallel" bedeutet, dass dasselbe Programm gleichzeitig und unabhängig auf vielen Pixeln läuft, statt sie einzeln in einer Schleife abzuarbeiten. "Zustandslos" bedeutet, dass jeder Aufruf von Neuem beginnt: keine Erinnerung an andere Pixel, keine Erinnerung an den letzten Frame, sofern man sie nicht explizit als Uniform oder abgetastete Textur wieder einspeist.
Wo das in echten Apps auftaucht
Das Plasmafeld oben ist bewusst nur ein Spielzeugbeispiel. Dasselbe Pro-Pixel-Modell läuft tatsächlich hinter Effekten, die man schon in produktiven Apps gesehen hat:
- Frosted-Glass- / Blur-behind-Dialoge: Der Shader tastet einen
Snapshot von allem ab, was sich dahinter befindet, und verwischt ihn
pro Pixel, so funktioniert der Dialog- und Notification-Shade-Blur von
Android 12+ unter
RenderEffect. - Color-Grading und LUT-Filter: Der RGB-Wert jedes Pixels wird über
eine Lookup-Funktion neu abgebildet, dieselbe Idee, die
Instagram- oder Lightroom-artige Filter verwenden, nur als AGSL-Mathematik
ausgedrückt statt als feste
ColorMatrix. - Touch-Ripple- und Verzerrungs-Feedback: Der Shader tastet seinen
eigenen Inhalts-Shader an einem Offset ab, der aus dem Abstand zur
Berührung und der verstrichenen Zeit berechnet wird, und erzeugt so ein
wasserwellenartiges "Squish", während sich der Finger bewegt, dieselbe
Effektfamilie steckt hinter benutzerdefiniertem Pull-to-Refresh und
Liquid-Swipe-Interaktionen (nicht Androids eingebautes
RippleDrawable, das ein einfacher kreisförmiger Alpha-Reveal ohne Shader-Beteiligung ist). - Prozedurale Texturen und Grain: Hintergründe, Rauschen und Dither-Muster, die zur Zeichenzeit aus reiner Mathematik erzeugt werden, wie das Plasmafeld in diesem Beitrag, statt ein Bitmap-Asset mitzuliefern, das skaliert und gekachelt werden muss.
- Chromatische Aberration und Glitch-Effekte: Der rote, grüne und blaue Kanal werden an leicht unterschiedlichen Koordinaten-Offsets abgetastet, ein verbreiteter Stileffekt in Kamera- und Fotobearbeitungs-Apps.
Jeder dieser Effekte ist dasselbe mentale Modell aus diesem Beitrag,
angewendet auf eine andere Pro-Pixel-Funktion: Nur die Mathematik
innerhalb von main ändert sich.
Anderswo: gleiches Fundament, anderes Framework
- GLSL (OpenGL/WebGL): die Shading-Sprache, von der sowohl AGSL als
auch SkSL abstammen. Die
void main()-Funktion eines WebGL-Fragment-Shaders, die ingl_FragColorschreibt, ist genau dasselbe Pro-Pixel-, zustandslose Modell, nur mit OpenGLs Bindungskonventionen statt denen vonRuntimeShader. - HLSL (Direct3D, Unity): derselbe Pro-Pixel-Einstiegspunkt, andere
Syntax und ein anderes Bindungsmodell. Die
frag-Funktion eines Unity-Fragment-Shaders erhält interpolierte Pro-Pixel-Daten und gibt eine Farbe zurück, genau wiemainin AGSL. - Metal Shading Language (iOS/macOS): eine mit
fragmentannotierte Funktion, die einmal pro Pixel/Fragment läuft und explizite Argumente für alles liest, was sie benötigt, kein impliziter Zugriff auf benachbarte Ausgaben. - SkSL (Skia): nicht nur eine Analogie, sondern AGSLs tatsächlicher Elternteil. Skia nutzt SkSL intern für seine eigenen Effekte, und AGSL ist die öffentliche, leicht eingeschränkte Teilmenge davon, die für App-Code freigegeben ist.
Wo man hier wirklich stolpert
- Es stürzt zur Laufzeit unterhalb von API 33 ab, nicht zur
Kompilierzeit.
RuntimeShaderbenötigt Android 13 (Tiramisu). Es gibt keine Kompilierwarnung dafür, es auf einem älterenminSdkaufzurufen, der Absturz passiert erst, wenn dieser Codepfad zum ersten Mal ausgeführt wird, sodass dieBuild.VERSION.SDK_INT-Prüfung kein optionaler Boilerplate ist, sondern tragend. - Der Shader kompiliert, aber die Ausgabe ist schwarz oder vollständig
transparent. Die häufigste Ursache ist ein unangetastetes Uniform:
resolutionist standardmäßig(0, 0), bis mansetFloatUniformaufruft, sodassfragCoord / resolutionim allerersten Frame durch Null teilt, wenn man es nach dem ersten Zeichenvorgang statt davor setzt. - AGSL verwendet standardmäßig volle
float-Präzision, nicht GLSL ES'smediump. Portiert man einen GLSL-ES-Fragment-Shader, der sich auf den schmaleren Wertebereich vonmediump floatfür einen beabsichtigten Banding- oder Wraparound-Effekt verlässt, reproduziert man in AGSL nicht dasselbe Artefakt, sofern man die breitere Standardpräzision nicht explizit berücksichtigt.
Mentales Modell, das man tatsächlich nutzen sollte
Man sollte aufhören zu fragen "was sieht dieser Shader". Man sollte stattdessen fragen: "Was weiß dieses eine Pixel?" Ein Shader sieht niemals das Bild, den Bildschirm oder den vorherigen Frame, er sieht immer nur seine eigene Koordinate und die Uniforms, die man daran gedacht hat zu setzen, und genau deshalb kann er eine Million Mal pro Frame laufen, ohne sich selbst im Weg zu stehen.



