# WebGL gradient: shadere forklaret for designere

[Canonical HTML page](https://gradiently.design/da/guide/shader-gradients)

Nogle gradienter på nettet driver, gløder og flimrer på en måde, intet billede og ingen CSS-regel kan. De er shadere. Sådan virker de, med ord en designer kan bruge.

## The short version

- 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.

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](https://gradiently.design/da/guide/css-linear-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å.

```text
#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);
}
```

En WebGL2-fragment-shader i GLSL. `smoothstep` blødgør hver overgang, sinusbølgen flytter grænsen, og de sidste linjer tilføjer korn, som også skjuler banding.

- Natbund: #120a2e
- Violet: #7c3aed
- Koral: #fa7373

De tre farver i shaderen. GLSL skriver farve som 0 til 1 pr. kanal, så #7c3aed bliver til 124, 58 og 237 divideret med 255.

## 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.

| Aspekt | CSS-gradient | Shadergradient |
| --- | --- | --- |
| Defineres af | Farver, stop og en retning | En formel, der køres pr. pixel |
| Bevægelse | At flytte position og størrelse eller animere custom properties | Alt, du kan udtrykke i matematik, i hvert billede |
| Tekstur og korn | Kræver et ekstra lag, for eksempel SVG-støj | Indbygget, og det kan bevæge sig |
| Pris for at køre | Meget lav, når den først er malet | Holder GPU’en i gang, mens den animerer |
| Virker uden JavaScript | Ja | Nej: et script sætter lærredet op |
| Virker i e-mail | Delvist, afhængigt af klienten | Nej |

Ingen af dem er bedst generelt. Hver vinder på sin egen opgave.

CSS-fallbacken: `linear-gradient(180deg, #120a2e 0%, #4c1d95 40%, #7c3aed 62%, #fa7373 100%)`

Samme palet som en stillestående CSS-gradient. Enhver shaderbaggrund bør leveres med en fallback som denne, der vises, før shaderen starter, og når den ikke kan køre.

## 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](https://gradiently.design/da/guide/grainy-gradients).
- **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](https://gradiently.design/da/guide/gradient-banding) 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](https://gradiently.design/da/guide/css-gradient-performance) 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](https://gradiently.design/da/guide/reduced-motion) 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å.

```js
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)
}
```

Sikkerhedsnettet på få linjer: en fallback, når WebGL mangler, kun ét billede ved reduceret bevægelse og ingen tegning uden for skærmen eller i en skjult fane.

Som reference dokumenterer [WebGL API’et på MDN](https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API) hvert kald, der bruges her, og [caniuse](https://caniuse.com/webgl2) 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.

> **Bedøm den først i stilstand** Sæt shaderen på pause i et tilfældigt billede, og se på det som et statisk billede. Ser et stillbillede ikke godt ud, redder bevægelsen det ikke. Bevægelse skal lægge noget til et design, der allerede virker.

## 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](https://gradiently.design/da/guide/what-is-a-mark) forklarer hele opskriften.

En Mark er en shaderopskrift med et navn, en kode og én ejer. Dens side viser den, mens den tegnes live.

## FAQ

### 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.
