Kort fortalt
- En WebGL-gradient tegnes af en shader: et lille program, der kører på grafikchippen og bestemmer farven på hver pixel, ofte mange gange i sekundet.
- Fordi en shader regner farven ud med matematik i stedet for at læse et gemt billede, kan den tilføje bevægelse, støj, korn og lys i enhver størrelse, uden at filen bliver større.
- Shadergradienter koster mere at køre end CSS-gradienter, så en god en holder pause, når den er uden for skærmen, respekterer reduceret bevægelse og har en enkel CSS-fallback.
- Brug CSS til statiske overgange og enkel bevægelse, og grib til en shader, når teksturen, dybden eller bevægelsen er pointen med designet.
På denne side
En WebGL gradient er en gradient, som din browser maler med en shader: et kort program, der kører på grafikchippen (GPU’en) og besvarer ét spørgsmål for hver pixel på skærmen: »hvilken farve har du lige nu?« En CSS-gradient er en fast opskrift af farver og positioner. En shader er en formel, så den kan bøje farven, give den korn, glød og bevægelse og gøre det igen tres gange i sekundet, uden at noget billede bliver downloadet.
Du behøver ikke skrive shadere for at designe med dem, men når du ved, hvad de kan og ikke kan, er det lettere at briefe en udvikler, vurdere et værktøj og afgøre, hvornår en almindelig CSS-gradient er det bedre valg.
Hvad en shader er, med almindelige ord
WebGL er browserens måde at tale med GPU’en på, og enhver WebGL-tegning bruger to slags shadere. Vertex-shaderen placerer former. For en gradient i fuld skærm er det blot ét rektangel, der dækker lærredet. Fragment-shaderen gør det interessante arbejde: den kører én gang pr. pixel, modtager pixlens position og det aktuelle tidspunkt og returnerer en farve.
Fordi GPU’en kører tusindvis af disse små programmer parallelt, bliver en formel, der ville være langsom i almindelig kode, billig nok til at blive tegnet om i hvert billede. Her er en komplet fragment-shader til en gradient i tre farver, hvis grænse svajer blidt over tid, med en linje korn ovenpå.
#version 300 es
precision highp float;
uniform vec2 u_resolution; // lærredets størrelse i pixel
uniform float u_time; // sekunder siden start
out vec4 outColor;
void main() {
vec2 uv = gl_FragCoord.xy / u_resolution; // 0 til 1 hen over lærredet
vec3 night = vec3(0.07, 0.04, 0.18); // #120a2e
vec3 violet = vec3(0.49, 0.23, 0.93); // #7c3aed
vec3 coral = vec3(0.98, 0.45, 0.45); // #fa7373
// En langsom bølge bøjer overgangen, så farverne glider.
float wave = sin(u_time * 0.3 + uv.x * 3.0) * 0.08;
float t = clamp(uv.y + wave, 0.0, 1.0);
vec3 color = mix(night, violet, smoothstep(0.0, 0.6, t));
color = mix(color, coral, smoothstep(0.55, 1.0, t));
// Fine korn: en ny tilfældig værdi pr. pixel og billede.
float n = fract(sin(dot(gl_FragCoord.xy + u_time, vec2(12.9898, 78.233))) * 43758.5453);
color += (n - 0.5) * 0.04;
outColor = vec4(color, 1.0);
}smoothstep blødgør hver overgang, sinusbølgen flytter grænsen, og de sidste linjer tilføjer korn, som også skjuler banding.Sådan adskiller en shadergradient sig fra en CSS-gradient
En CSS-gradient er deklarativ: du lister farver og positioner, og browseren maler dem. Det er det rigtige værktøj det meste af tiden. En shader er procedural: du beskriver, hvordan farven skal opføre sig, og matematikken frembringer den. Den forskel viser sig i, hvad hver kan, og hvad hver koster.
CSS-gradient
Shadergradient
CSS-gradient
Shadergradient
CSS-gradient
Shadergradient
CSS-gradient
Shadergradient
CSS-gradient
Shadergradient
CSS-gradient
Shadergradient
linear-gradient(180deg, #120a2e 0%, #4c1d95 40%, #7c3aed 62%, #fa7373 100%)Derfor føles shadergradienter levende
Tre teknikker gør det meste af arbejdet, og du vil høre udviklere nævne dem. Støj er blød tilfældighed: i stedet for en lige overgang følger farven et landskab af bløde bakker, og derfor ser shadergradienter organiske ud frem for geometriske. Domain warping fører støjen tilbage i sig selv, så farven folder og hvirvler som blæk i vand. Tid skubber hele landskabet af sted, hvilket gør en stillestående flade til en drift.
- Korn kan genereres pr. pixel og pr. billede, så det flimrer som film i stedet for at ligge stille som en tekstur lagt ovenpå. Se kornede gradienter.
- Lys kan efterlignes med få linjer: et højlys, der følger støjen, læses som glans på silke eller glas.
- Opløsning er gratis. Formlen kører i den størrelse, skærmen har, så en shadergradient står skarpt på en telefon og på en 4K-skærm med samme kode.
- Banding er lettere at slå, fordi shaderen kan tilføje lidt dither, før farven afrundes til 8 bit. Banding i gradienter forklarer, hvorfor det betyder noget.
Brug CSS, når
- Gradienten står stille eller bevæger sig på én enkel måde
- Den ligger bag masser af tekst på en lang side
- Den skal virke med scripts slået fra eller i e-mail
- Du har brug for den på én linje kode
Brug en shader, når
- Bevægelsen eller teksturen er pointen med designet
- Det er ét hero-område, ikke hver sektion
- Du vil have korn, glans eller flow, som CSS ikke kan efterligne
- Du kan levere en CSS-fallback og en pause
Prisen for en WebGL-baggrund i bevægelse
En shader, der animerer, holder GPU’en i arbejde, så længe den er på skærmen. På en computer er det knap mærkbart. På en ældre telefon kan det betyde varme hænder, et batteri, der tømmes, og en side, der ruller mindre glat. Prisen følger antallet af pixels og formlens kompleksitet, så en shader i fuld skærm på en skærm med høj pixeltæthed er det tungeste tilfælde. Gør gradienter et website langsomt gennemgår, hvordan du måler det.
- 1
Vis CSS-fallbacken først
Mal den stillestående gradient med det samme, og ton så lærredet ind, når shaderen har tegnet sit første billede. Ingen bør se en tom boks.
- 2
Tjek, at WebGL er tilgængelig
Nogle browsere, enheder og privatlivsindstillinger slår det fra. Kan konteksten ikke oprettes, så behold fallbacken.
- 3
Respektér reduceret bevægelse
Beder den besøgende om mindre bevægelse, så tegn ét billede og stop. Reduceret bevægelse forklarer indstillingen.
- 4
Hold pause, når den ikke kan ses
Stop animationsloopet, når lærredet ruller ud af syne, eller fanen er skjult.
- 5
Tegn i en fornuftig opløsning
Bløde gradienter har sjældent brug for hver eneste enhedspixel. Tegner du i halv opløsning og lader browseren skalere op, kan det skære meget af arbejdet væk for en sløring, du ikke kan se forskel på.
const canvas = document.querySelector('#hero-canvas')
const gl = canvas.getContext('webgl2')
const still = matchMedia('(prefers-reduced-motion: reduce)').matches
let visible = true
if (!gl) {
canvas.remove() // the CSS gradient behind it stays
} else {
new IntersectionObserver(([entry]) => {
visible = entry.isIntersecting
}).observe(canvas)
const frame = (ms) => {
if (visible && !document.hidden) draw(gl, ms / 1000) // your draw call
if (!still) requestAnimationFrame(frame)
}
requestAnimationFrame(frame)
}Som reference dokumenterer WebGL API’et på MDN hvert kald, der bruges her, og caniuse følger understøttelsen af WebGL2 på tværs af browsere.
Design af en shadergradient: det skal du briefe
Du kan styre en shader uden at læse GLSL. Brief den, som du ville briefe et materiale, ikke en farveprøve. Angiv bundfarven og de tre til fem farver, der lever på den, i hex. Beskriv strukturen: bløde pøle, lange bånd, foldet silke. Angiv hastigheden i sekunder pr. cyklus frem for »langsom«, for langsom betyder forskellige ting for forskellige mennesker. Sig, hvor meget korn, og om det bevæger sig. Sig til sidst, hvor teksten skal stå, så den mest urolige del af fladen holder sig væk fra den.
Sådan tegner Gradiently Marks med shadere
Marks i Gradiently er shadergradienter. Hver Mark er en opskrift af farver, op til tre stablede materialer, lys, korn og bevægelse, og studiet tegner den live med WebGL2 bag det, du designer. Fordi den beregnes og ikke gemmes, tegnes samme Mark skarpt i enhver af platformsstørrelserne og bevæger sig, når du eksporterer en loopende video. Rendereren ved også, hvor dine ord er, så den kan flytte den roligste del af fladen ind bag dem. Hvad er en Mark forklarer hele opskriften.
GR·RXWA·2K
Nara Key
Se denne MarkSpørgsmål, folk stiller
Hvad er en WebGL-gradient?
Det er en gradient tegnet af en shader, et lille program på grafikchippen, der beregner farven på hver pixel. Fordi den er en formel, kan den bevæge sig, tilføje korn og tegnes i enhver størrelse.
Er en shadergradient dårlig for ydeevnen?
En stillestående shader eller en på pause koster lidt, men en, der animerer, holder GPU’en i gang, mens den er på skærmen. Sæt den på pause, når den er ude af syne, tegn i en fornuftig opløsning, og behold en CSS-fallback.
Respekterer shadergradienter indstillinger for reduceret bevægelse?
Kun hvis de er bygget til det. Tjek media queryen prefers-reduced-motion i JavaScript, og tegn et enkelt stillbillede, når den er slået til.
Hvad er GLSL?
GLSL er det shadersprog, WebGL bruger. Fragment-shadere skrevet i det bestemmer farven på hver pixel, og browseren kompilerer dem til grafikchippen.
Skrevet af Gradiently
Holdet bag Gradiently, et designværktøj bygget om Marks: levende gradienter, der får alt, du designer, til at ligne dig.
Se vores profil