GLSL für Builder: Ein Shader-Lab, das Sie wirklich nutzen können
GLSL-Shader werden intuitiv, sobald Sie eine einzelne Zahl ändern und das Ergebnis mit 60 fps sehen können. Dieses interaktive Lab enthält Preset-Shader, die Sie in Echtzeit verändern können: Sinuswellen, die Farbfelder modulieren, Noise-Funktionen, die Terrain erzeugen, und Ray Marching, das 3D-Szenen allein aus Mathematik aufbaut.
Ich habe Shader gelernt, indem ich eine Zahl nach der anderen geändert und beobachtet habe, was passiert. Die Mathematik zu lesen sagte mir, was eine Sinuswelle tut. Einen Slider zu bewegen zeigte mir, wie es aussieht, wenn eine Sinuswelle ein Farbfeld mit 60 fps moduliert. Die zweite Art von Verständnis bleibt hängen. Dieses Lab gehört zur Serie Interactive Explorations und zum weiteren Themenfeld Design Engineering.
Der folgende Beitrag enthält ein live nutzbares GLSL-Lab mit Preset-Shadern, die Sie in Echtzeit verändern können. Die Struktur ist eine Werkstatt, keine Vorlesung: schnelle Iteration, visuelles Feedback und genug Erläuterung, damit Sie verstehen, was jeder Regler tut und warum.
TL;DR
Wenn Sie in GLSL wirklich gut werden wollen, hören Sie auf, Shader-Theorie passiv zu lesen, und manipulieren Sie stattdessen Uniforms entschlossen. Ändern Sie jeweils nur einen Parameter, beobachten Sie, wie sich Raum- und Zeitfelder verformen, und halten Sie das Gelernte dann in wiederverwendbaren Mustern fest. Das interaktive Lab unten bietet Ihnen dafür einen praktischen Loop: Preset wählen, Speed, Scale, Detail und Color Shift anpassen und durch unmittelbares visuelles Feedback Intuition aufbauen.1
Warum das für Produktarbeit wichtig ist
Shader lösen echte Produktprobleme. Der Beitrag zur Farbwissenschaft von Interfaces behandelt, wie Farbwahrnehmung auf theoretischer Ebene funktioniert; in Shadern wird diese Theorie zu visueller Ausgabe in Echtzeit. Nützlich sind sie für:
- atmosphärische Motion-Backgrounds, die leichtgewichtig bleiben
- markentypische visuelle Signaturen, ohne schwere Video-Assets auszuliefern
- interaktive Storytelling-Blöcke innerhalb redaktioneller Inhalte
- generative visuelle Systeme, die sich pro Kampagne parametrieren lassen
Das Lab auf dieser Seite ist selbst ein Produktionsbeispiel: eine WebGL-Komponente ohne Abhängigkeiten, eingebettet in einen serverseitig gerenderten Blogbeitrag ohne Build-Tools, die jede der unten beschriebenen Leitplanken einhält.
Ein konkreter Fall: Der Sorting Visualizer auf dieser Website nutzt einen bildschirmfüllenden Fragment-Shader als atmosphärischen Hintergrund hinter der Sortieranimation. Der Shader rendert einen langsam fließenden Verlauf, der auf den Fortschritt des Sortieralgorithmus reagiert: Die Farbphase verschiebt sich mit jeder weiteren Vertauschung und erzeugt so eine visuelle „Temperatur“, die mit der algorithmischen Arbeit steigt. Die Implementierung umfasst 48 Zeilen GLSL (eine Plasma-Variante, gesteuert von einem einzigen u_progress-Uniform zwischen 0,0 und 1,0). Auf dem M1 MacBook Air des Autors kostet der Shader 0,3 ms pro Frame im Render-Budget, vernachlässigbar bei 60 fps (16,6 ms Budget). Auf einem iPhone 12 Mini (A14, getestet über Safari Remote Debugging) kostet derselbe Shader 0,8 ms pro Frame, also immer noch deutlich im Budget. Der Shader ersetzte eine CSS-Verlaufsanimation, die 6 KB an Keyframe-Definitionen benötigte, nicht auf den Anwendungszustand reagieren konnte und bei jedem Farbwechsel Layout-Neuberechnungen auslöste. Die GLSL-Version ist kleiner (1,2 KB), wird auf der GPU komponiert (keine Layout-Kosten) und ist parametriert (das Progress-Uniform lässt sich an jede beliebige Datenquelle anbinden).
Die praktische Grenze ist immer die Performance. Wenn das Frame-Budget auf Mobilgeräten kollabiert, ist die visuelle Idee tot, egal wie elegant die Mathematik ist.
Das mentale Modell, das wirklich hängen bleibt
Betrachten Sie jeden Fragment-Shader als drei Probleme, die nacheinander gelöst werden:2
- ein Koordinatentransformationsproblem
- ein periodisches Signalproblem
- ein Farbabbildungsproblem
In GLSL entspricht jeder Schritt wenigen Zeilen. Die Typen vec2, vec3 und vec4 sind die eingebauten Vektortypen von GLSL für Floats mit 2, 3 und 4 Komponenten, die jeweils für Koordinaten, Farben und Ausgabepixel verwendet werden:
// Step 1: Coordinates, where am I in normalized space?
vec2 uv = gl_FragCoord.xy / u_resolution; // 0.0 to 1.0
vec2 p = uv * u_scale; // scale the coordinate space
// Step 2: Signal, what scalar field exists at this point and time?
float signal = sin(p.x * 6.28 + u_time); // periodic wave across x-axis
// Step 3: Color, how do I map that scalar to visible output?
vec3 color = vec3(signal * 0.5 + 0.5); // remap -1..1 to 0..1
gl_FragColor = vec4(color, 1.0); // WebGL 1.0 (GLSL ES 1.00) output
Die Werte u_resolution, u_scale und u_time sind Uniforms: Werte, die die CPU in jedem Frame an die GPU sendet. Uniforms sind die Steuerfläche. Eine Änderung von u_scale zoomt den Koordinatenraum. Eine Änderung von u_time animiert das Signal. Der Shader-Code bleibt gleich; das Verhalten ändert sich, weil sich die Eingaben ändern. Das Lab unten stellt vier Uniforms bereit (Speed, Scale, Detail, Color Shift), damit Sie das unmittelbar spüren.
Aus diesem dreistufigen Loop lässt sich fast alles aufbauen.
Drei Presets, drei Verhaltensweisen
Das Lab liefert drei Shader-Verhaltensweisen, damit Sie Muster vergleichen können:
-
Plasma: Geschichtete
sin()-Wellen erzeugen Interferenzmuster. Drei Sinuswellen mit unterschiedlichen Frequenzen und Phasen überlagern sich und erzeugen konstruktive Interferenz (helle Bänder, wo die Wellen übereinstimmen) und destruktive Interferenz (dunkle Bänder, wo sie sich auslöschen). Das Scale-Uniform bestimmt, wie viele Wellenzyklen in den Viewport passen. Drehen Sie es hoch, verdichtet sich das Interferenzmuster zu feiner Körnung. Drehen Sie es herunter, entstehen breite, organische Verläufe.3glsl float a = sin(p.x + t * 1.1); float b = sin((p.y + t * 0.9) * 1.3); float c = sin((p.x + p.y + t * 0.7) * 0.8); float signal = (a + b + c) / 3.0; -
Contour Rings:
length()berechnet den radialen Abstand vom Zentrum und erzeugt so einen weichen Verlauf, der von 0,0 im Zentrum nach außen hin zu größeren Werten an den Rändern ansteigt.sin()lässt diesen stetig wachsenden Abstand dann zu sich wiederholenden Wellen oszillieren, aus demselben Grund, aus dem Wellen in einem Teich konzentrische Ringe bilden.abs()+smoothstep()schärfen diese weichen Wellen zu diskreten Bändern, mit demselben visuellen Effekt wie Höhenlinien auf einer topografischen Karte. Das Detail-Uniform steuert die Banddichte, indem es den Abstand multipliziert, bevorsin()ihn umbricht: Mehr Detail bedeutet engere Ringe. Das visuelle Ergebnis erinnert an einen Radarscan oder eine topografische Anzeige.glsl float d = length(p); float wave = sin((d * 18.0 * u_detail) - t * 2.0); float bands = smoothstep(0.1, 0.85, abs(wave)); -
Flow Warp: Der Shader wandelt kartesische Koordinaten in Polarform um (
atanfür den Winkel,lengthfür den Radius). Die Polarkoordinaten sind der Schlüssel: Der Winkel wächst linear, während man das Zentrum umrundet, daher erzeugtsin(8.0 * angle)acht radiale Speichen (acht volle Sinuszyklen über 360 Grad). Der Radius wächst vom Zentrum nach außen, daher erzeugtcos(12.0 * radius)zwölf konzentrische Wellenringe. Ihre Summe ergibt das Interferenzmuster: Speichen, die Ringe kreuzen. Ein exponentieller Glow-Term (exp(-3.0 * radius)) fügt einen Helligkeitsabfall vom Zentrum hinzu, weilexp(-x)mit wachsendem x schnell abklingt. Das Color-Shift-Uniform dreht die Farbtonzuordnung und zeigt so, wie dasselbe Verzerrungsfeld unterschiedliche Farbpaletten hervorbringt.glsl float angle = atan(p.y, p.x); float radius = length(p); float field = sin(8.0 * angle + t * 2.2) + cos(12.0 * radius - t * 1.7); float glow = exp(-3.0 * radius) * (0.6 + 0.4 * sin(t + radius * 8.0));
Alle drei teilen sich dieselbe Uniform-Schnittstelle (Speed, Scale, Detail, Color Shift), damit Sie spüren, wie identische Regler je nach Signaldesign zu unterschiedlichen Ergebnissen führen.
Erfolgsstrategie für schnelles Lernen
Gehen Sie im Lab in dieser Reihenfolge vor:
- Beginnen Sie mit Plasma, setzen Sie Scale niedrig und erhöhen Sie dann Speed.
- Wechseln Sie zu Contour Rings, erhöhen Sie Detail und reduzieren Sie Speed.
- Wechseln Sie zu Flow Warp und ziehen Sie dann Color Shift, um das Phasen-Mapping zu sehen.
- Pausieren Sie die Animation und vergleichen Sie Standbilder der verschiedenen Presets.
- Kehren Sie zu Ihrem Lieblingspreset zurück und stimmen Sie es auf ein klar umrissenes Stilziel ab (ruhig, aggressiv, technisch, cineastisch).
Dieser Loop erzwingt explizite Geschmacksentscheidungen statt zufälligen Herumprobierens. Dieselbe Art strukturierter ästhetischer Erkundung gilt für das Spannungsfeld zwischen Schönheit und Brutalismus im Design, in dem die Beschränkung den Charakter offenlegt.
Übung: Schreiben Sie nach Schritt 5 drei Wörter auf, die das von Ihnen erzeugte Bild beschreiben. Schieben Sie dann einen Slider ans entgegengesetzte Extrem und schreiben Sie drei neue Wörter auf. Vergleichen Sie die beiden Beschreibungen. Der Abstand zwischen ihnen ist Ihre Geschmacksfläche: die Bandbreite visueller Ergebnisse, die Sie benennen und gezielt ansteuern können. Wiederholen Sie das mit anderen Presets, um diese Fläche zu erweitern.
Häufige Fehler beim Einstieg in GLSL
Drei Fehler tauchen in fast jedem ersten Shader auf:
Koordinaten nicht normalisieren. gl_FragCoord liefert Pixelkoordinaten (0 bis 1920 auf einem 1080p-Display). Ohne die Division durch u_resolution arbeitet jedes sin() und cos() mit riesigen Werten und erzeugt visuelles Rauschen statt weicher Muster. Die Korrektur ist immer die erste Zeile: vec2 uv = gl_FragCoord.xy / u_resolution;
Den Farbbereich als -1 bis 1 behandeln. sin() liefert Werte von -1,0 bis 1,0, Farbkanäle erwarten aber 0,0 bis 1,0. Negative Farbwerte werden auf Schwarz geklemmt und erzeugen harte Bänder statt weicher Verläufe. Die Umrechnungsformel signal * 0.5 + 0.5 überführt den Bereich -1..1 in 0..1. Jeder Shader im Lab oben nutzt dieses Muster.
Animieren ohne u_time. Ein Shader, der nur räumliche Koordinaten verwendet, erzeugt ein statisches Bild. Animation erfordert ein Zeit-Uniform, das die CPU in jedem Frame erhöht und an die GPU sendet. Der Shader selbst verfolgt nie die Zeit; er erhält die aktuelle Zeit als Uniform und berechnet den Frame so, als wäre dieser Moment der einzige. Jeder Frame ist eine reine Funktion seiner Eingaben.
Shader-Fehler debuggen
WebGL-Shader-Fehler erscheinen in der Browserkonsole. Anfangs wirken sie kryptisch, folgen aber vorhersehbaren Mustern. Hier sind die drei Fehler, denen Sie am häufigsten begegnen werden, und was sie bedeuten:
ERROR: 0:12: 'u_resolution' : undeclared identifier: Der Shader verweist auf ein Uniform, das nie deklariert wurde. Entweder fehlt die uniform-Deklaration im Shader-Quelltext, oder sie ist falsch geschrieben. Korrektur: Fügen Sie uniform vec2 u_resolution; oben im Fragment-Shader ein, vor void main().
ERROR: 0:8: '' : compilation terminated: Der Shader enthält vor Zeile 8 einen Syntaxfehler. GLSL verlangt eine Syntax im Stil von C: Semikolons am Ende jeder Anweisung, passende geschweifte Klammern und keine abschließenden Kommas. Die häufigste Ursache ist ein fehlendes Semikolon in der vorherigen Zeile. Korrektur: Prüfen Sie die Zeilen 1-7 auf fehlende Semikolons, nicht geschlossene Klammern oder falsche Typnamen.
Eine schwarze oder weiße Canvas ohne Konsolenfehler: Der Shader wurde erfolgreich kompiliert und gelinkt, aber die Ausgabewerte liegen außerhalb des Bereichs 0,0-1,0. gl_FragColor erwartet jeden Kanal (R, G, B, A) zwischen 0,0 und 1,0. Werte über 1,0 werden auf Weiß geklemmt. Werte unter 0,0 werden auf Schwarz geklemmt. Korrektur: Fügen Sie die Umrechnungsformel (signal * 0.5 + 0.5) hinzu, um Ihr Signal vom Bereich -1..1 in den Bereich 0..1 zu verschieben. Ist die Canvas rein weiß, liegen alle Ihre Werte über 1,0. Ist sie rein schwarz, liegen alle unter 0,0.
Eine Debugging-Technik für jeden Shader: Setzen Sie gl_FragColor = vec4(uv, 0.0, 1.0); als letzte Zeile. Diese Zeile malt einen Verlauf von Schwarz (unten links, bei uv = (0, 0)) nach Gelb (oben rechts, bei uv = (1, 1)), mit Rot entlang der x-Achse und Grün entlang der y-Achse. Sieht der Verlauf korrekt aus, funktioniert Ihr Koordinatenraum, und das Problem liegt im Signal oder in der Farbabbildung. Ist der Verlauf falsch (etwa komplett einfarbig oder invertiert), hat die Koordinatentransformation einen Fehler. Die Technik grenzt ein, welches der drei Probleme (Koordinaten, Signal, Farbe) den Fehler enthält.
Leitplanken für die Produktion
Wenn Sie Shader auf Content-Seiten ausliefern, halten Sie diese Grenzen ein:
- begrenzen Sie die Canvas-Auflösung über die Device-Pixel-Ratio, um Overdraw-Spitzen zu vermeiden
- stellen Sie nur eine kleine, sinnvolle Steuerfläche bereit
- bieten Sie einen statischen Fallback, wenn
WebGLnicht verfügbar ist - pausieren Sie das Rendering, wenn der Tab verborgen ist
- vermeiden Sie teure Verzweigungen und verschachtelte Schleifen im Fragment-Code
Das Lab folgt diesen Regeln, sodass Sie es als Vorlage verwenden können. Auf der Testhardware des Autors (M1 MacBook Air, integrierte GPU) halten diese Shader 60 fps bei einer Device-Pixel-Ratio von 1x; die Ergebnisse hängen von der GPU ab, doch die Shader-Komplexität ist bewusst niedrig genug für die meiste Hardware gehalten. Bei 2x DPR auf einem Retina-Display vervierfacht sich die Pixelanzahl; die Begrenzung auf Math.min(dpr, 2) verhindert, dass die GPU die vierfache Arbeit für einen visuellen Unterschied leistet, den die meisten Nutzer nicht wahrnehmen können.8
Hier ist das Muster zum Pausieren bei verborgenem Tab in JavaScript, zwei Zeilen, die verhindern, dass der Shader auf einem unsichtbaren Tab GPU-Zyklen verbrennt:
document.addEventListener('visibilitychange', () => {
if (document.hidden) cancelAnimationFrame(frameId);
else frameId = requestAnimationFrame(render);
});
Und die DPR-Begrenzung:
const dpr = Math.min(window.devicePixelRatio || 1, 2);
canvas.width = canvas.clientWidth * dpr;
canvas.height = canvas.clientHeight * dpr;
Beide Muster sind im Lab oben bereits implementiert. Übernehmen Sie sie direkt in Ihre eigenen WebGL-Projekte.
Was Sie als Nächstes bauen können
Sinnvolle nächste Schritte:
-
Uniforms in die Zwischenablage kopieren. Stellen Sie den aktuellen Zustand
{ speed, scale, detail, colorShift }als JSON-Objekt bereit. Ein „Copy Preset“-Button schreibt ihn in die Zwischenablage. Ein Preset wiederherzustellen istObject.assign(state, JSON.parse(clipboard)). Die Serialisierung von Presets ist wichtig, weil ästhetische Erkundung standardmäßig flüchtig ist: Sobald Sie einen Slider bewegen, ist der vorherige Zustand verloren. Ein serialisierbares Preset macht aus einem flüchtigen Bild ein speicherbares, teilbares Artefakt. -
Verlaufs-Snapshots exportieren. Rufen Sie
canvas.toDataURL('image/png')auf, um den aktuellen Frame als statisches Bild festzuhalten. Dimensionieren Sie die Export-Canvas auf Social-Card-Formate (1200x630 für Open Graph, 1080x1080 für Instagram). Der Shader erzeugt einzigartige, markenkonforme Verläufe ohne Stockfotos. -
Die Scroll-Position auf ein Uniform abbilden. Verwenden Sie
IntersectionObserveroder einen Scroll-Listener, um einen Fortschrittswert zwischen 0,0 und 1,0 zu berechnen, und übergeben Sie ihn als Uniform. Der Shader reagiert auf die Position des Lesers auf der Seite, weil die GPU einen sich stetig ändernden Wert erhält, der den visuellen Zustand steuert: derselbe Mechanismus wie beim Speed-Slider, nur über das Scrollen statt über ein UI-Element gesteuert. Das Ergebnis sind erzählerische Übergänge, bei denen sich das Bild mit dem Fortschreiten des Inhalts entwickelt.4 -
Die Farbphase an externen Zustand koppeln. Übergeben Sie Tageszeit, Kampagnenparameter oder Benutzereinstellungen als Uniforms. Ein Shader, der den Farbton abhängig von der lokalen Uhrzeit verschiebt, schafft atmosphärische Personalisierung, ohne unterschiedliche Assets auszuliefern.
Entscheidend ist der Schritt von „Shader als Spielzeug“ zu „Shader als wiederverwendbares Produkt-Primitive“. Das interaktive Beispiel zur Hamming-Fehlerkorrektur und der Tokenization Visualizer folgen derselben Philosophie: Sie machen abstrakte Konzepte durch direkte Manipulation greifbar. Und das räumliche Denken, das Shader intuitiv macht, ist mit demselben räumlichen Denken in der Wissenstopologie durch Embeddings verwandt, wo hochdimensionale Vektorräume semantische Bedeutung kodieren.
Die wichtigsten Erkenntnisse
Für Entwickler, die GLSL lernen:
-
Uniforms entschlossen manipulieren, Theorie passiv lesen. Jeweils einen Parameter zu ändern und das visuelle Ergebnis zu beobachten, baut Intuition schneller auf, als die Mathematik isoliert zu studieren. Das Lab oben existiert, um diesen Loop schnell zu machen.
-
Jeder Fragment-Shader löst drei Probleme nacheinander. Koordinatentransformation, periodisches Signal, Farbabbildung. Sobald dieses mentale Modell sitzt, können Sie jeden Shader, dem Sie begegnen, in seine drei Schichten zerlegen und jede davon für sich verstehen.
Für Teams, die Shader in Produktion ausliefern:
-
Constraint-Design ist wichtiger als Shader-Komplexität. DPR begrenzen, bei verborgenem Tab pausieren, Fallbacks bereitstellen und eine kleine Steuerfläche anbieten: Das sind die Produktionsentscheidungen, die bestimmen, ob ein Shader den Kontakt mit echten Nutzern auf echter Hardware übersteht.
-
Shader sind wiederverwendbare Produkt-Primitives, keine Spielzeuge. Markenhintergründe, kampagnenspezifische Visuals, scrollgesteuerte Übergänge und atmosphärische Personalisierung sind Produktionsanwendungsfälle, die Shader ohne Video-Assets, CDN-Bandbreite oder Framework-Abhängigkeiten abdecken.
Häufige Fragen
Was ist GLSL, und wie funktionieren Fragment-Shader in WebGL?
GLSL (OpenGL Shading Language) ist die C-ähnliche Sprache, in der Shader-Programme geschrieben werden, die auf der GPU laufen. WebGL ist die Browser-API, die Zugriff auf OpenGL ES bietet, das diese Shader ausführt. Ein in GLSL geschriebener Fragment-Shader läuft einmal pro Fragment und Frame; bei einem einfachen bildschirmfüllenden Quad wie im Lab oben entspricht jedes Fragment einem Pixel, sodass der Shader effektiv für jedes Pixel eine Farbe berechnet, basierend auf dessen Koordinaten, der aktuellen Zeit und allen Uniform-Werten, die die CPU liefert. Das Lab oben nutzt WebGL, um GLSL-Fragment-Shader direkt im Browser zu kompilieren und auszuführen, ganz ohne Plugins oder Erweiterungen.5
Was sind Uniforms in der Shader-Programmierung?
Uniforms sind schreibgeschützte Werte, die in jedem Frame von der CPU (JavaScript) an die GPU (GLSL-Shader) gesendet werden. Anders als Vertex-Attribute (die pro Vertex variieren) oder Varyings (die über ein Dreieck interpoliert werden) bleiben Uniforms innerhalb eines Draw Calls für jedes Pixel konstant. Typische Uniforms sind Zeit, Auflösung, Mausposition und eigene Steuerwerte. Das Lab stellt vier Uniforms bereit (Speed, Scale, Detail, Color Shift), die Sie über Slider manipulieren können, um zu sehen, wie veränderte Werte auf der CPU-Seite die visuelle Ausgabe auf der GPU-Seite in Echtzeit verändern.
Wie erreichen Shader Echtzeit-Performance?
Fragment-Shader laufen parallel auf Tausenden von GPU-Kernen. Die Berechnung jedes Pixels ist von allen anderen Pixeln unabhängig, daher verarbeitet die GPU sie gleichzeitig statt nacheinander. Eine Canvas mit 1920x1080 hat rund 2 Millionen Fragmente. Eine CPU verarbeitet sie weitgehend sequenziell (SIMD hilft, doch der Durchsatz liegt immer noch um Größenordnungen niedriger). Eine GPU verteilt sie auf Tausende von Kernen und ist in Millisekunden fertig. Die Einschränkung: Kein Pixel kann im selben Durchlauf das Ergebnis der Berechnung eines anderen Pixels lesen. Deshalb verlangt Shader-Programmierung ein anderes mentales Modell als sequenzieller CPU-Code.6
Kann ich WebGL-Shader sicher in Webprojekten in Produktion einsetzen?
Das geht, mit Einschränkungen. Begrenzen Sie die Canvas-Auflösung relativ zur Device-Pixel-Ratio, um Overdraw auf hochauflösenden Bildschirmen zu vermeiden. Pausieren Sie die Animationsschleife, wenn der Tab nicht sichtbar ist (lauschen Sie auf das Event visibilitychange an document). Stellen Sie ein statisches Fallback-Bild oder einen CSS-Verlauf bereit, wenn WebGL nicht verfügbar ist. Vermeiden Sie teure Operationen wie verschachtelte Schleifen, Textur-Lookups in bedingten Zweigen oder übermäßige Verzweigungen generell. Das Lab hält alle diese Leitplanken für die Produktion ein.
Was sollte ich nach diesem Lab lernen?
Wechseln Sie zu The Book of Shaders von Patricio Gonzalez Vivo und Jen Lowe, einem strukturierten Lehrgang zu Noise-Funktionen, Distanzfeldern und fortgeschritteneren GLSL-Techniken.1 Speziell für Distanzfeld-Techniken sind die Artikel von Inigo Quilez zu Signed Distance Functions die maßgebliche Referenz.7 Sobald Sie mit Fragment-Shadern sicher umgehen, erkunden Sie Vertex-Shader (Geometriemanipulation) und Compute-Shader (allgemeine Berechnungen auf der GPU).
-
Patricio Gonzalez Vivo und Jen Lowe, The Book of Shaders, thebookofshaders.com. Die maßgebliche interaktive Lernressource für GLSL. Behandelt Fragment-Shader von der einfachen Farbausgabe über Noise und Fraktale bis zur Bildverarbeitung, mit live bearbeitbaren Beispielen. ↩↩
-
Diese dreistufige Zerlegung (Koordinaten, Signal, Farbe) vereinfacht das in The Book of Shaders, Kapitel 5-7, vorgestellte Modell, das Shaping-Funktionen, Farben und Formen als aufeinanderfolgende Schichten beim Aufbau eines Fragment-Shaders behandelt. ↩
-
Das Plasma-Preset demonstriert Fourier-Synthese: den Aufbau eines komplexen Musters durch das Addieren von Sinuswellen unterschiedlicher Frequenzen. Das Fourier-Theorem besagt, dass sich jedes komplexe periodische Signal aus Sinuswellen unterschiedlicher Frequenzen und Phasen aufbauen (oder in sie zerlegen) lässt. Mehr Sinusterme erzeugen komplexere Interferenzmuster. Siehe auch: Gonzalez Vivo, „Shaping Functions“, thebookofshaders.com/05/. ↩
-
Scrollgesteuerte Shader-Animationen folgen demselben Prinzip wie CSS
scroll-timeline, allerdings mit beliebigen, auf der GPU berechneten Visuals. Das Uniform erhält eine normalisierte Scroll-Position (0,0 oben, 1,0 unten), und der Shader interpoliert zwischen visuellen Zuständen. MDN dokumentiert die zugrunde liegende Scroll-Event-API: developer.mozilla.org/en-US/docs/Web/API/Document/scroll_event. ↩ -
WebGL 1.0 (basierend auf OpenGL ES 2.0) wird von über 98 % der Browser weltweit unterstützt. Siehe caniuse.com/webgl. WebGL 2.0 (basierend auf OpenGL ES 3.0) ergänzt Transform Feedback, Multiple Render Targets und weitere Funktionen, ist für Fragment-Shader-Arbeit wie im Lab oben aber nicht erforderlich. Compute-Shader sind über WebGPU verfügbar, nicht über WebGL. ↩
-
Das parallele Ausführungsmodell von GPUs ist der Grund, warum Shader-Programmierung die Kommunikation zwischen Pixeln innerhalb eines einzelnen Draw Calls verbietet. John Owens et al., „A Survey of General-Purpose Computation on Graphics Hardware“, Computer Graphics Forum, Vol. 26, No. 1, S. 80-113, 2007. Diese Einschränkung prägt das gesamte Programmiermodell von GLSL. ↩
-
Inigo Quilez, „Distance Functions“, iquilezles.org/articles/distfunctions2d/. Quilez’ Katalog von 2D- und 3D-Signed-Distance-Functions ist die Standardreferenz für prozedurale Geometrie in Shadern. ↩
-
Das parallele Ausführungsmodell der GPU, das Fragment-Shader schnell macht, schränkt zugleich ein, wie sie arbeiten. Akenine-Moller, T., Haines, E., und Hoffman, N., Real-Time Rendering, 4. Auflage, A K Peters/CRC Press, 2018, Kapitel 3 (The Graphics Processing Unit). Das Buch bietet die umfassendste Darstellung der GPU-Architektur für Grafikprogrammierer, einschließlich des Zusammenhangs zwischen Fragment-Durchsatz, Füllrate und DPR. Die Khronos Group pflegt die GLSL-ES-Spezifikation, die die in diesem Lab verwendete Sprache definiert: registry.khronos.org/OpenGL/specs/es/2.0/GLSL_ES_Specification_1.00.pdf. ↩