# WebGL-liukuvärit ja shaderit suunnittelijalle selitettynä

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

Jotkin verkon liukuvärit ajelehtivat, hehkuvat ja hohtavat tavalla, johon mikään kuva tai CSS-sääntö ei pysty. Ne ovat shadereita. Näin ne toimivat, sanoin, joita suunnittelija voi käyttää.

## The short version

- WebGL-liukuvärin piirtää shader: pieni ohjelma, joka toimii grafiikkapiirillä ja päättää jokaisen pikselin värin, usein monta kertaa sekunnissa.
- Koska shader laskee värin matematiikalla eikä lue tallennettua kuvaa, se voi lisätä liikettä, kohinaa, rakeisuutta ja valoa missä tahansa koossa ilman, että tiedosto kasvaa.
- Shader-liukuvärit ovat CSS-liukuvärejä raskaampia ajaa, joten hyvä shader pysähtyy, kun se ei ole näkyvissä, kunnioittaa liikkeen vähentämistä ja sisältää tavallisen CSS-varavaihtoehdon.
- Käytä CSS:ää liikkumattomiin sekoituksiin ja yksinkertaiseen liikkeeseen ja tartu shaderiin, kun tekstuuri, syvyys tai liike on suunnitelman ydin.

**WebGL-liukuväri** on liukuväri, jonka selaimesi maalaa shaderilla: lyhyellä ohjelmalla, joka toimii grafiikkapiirillä (GPU) ja vastaa yhteen kysymykseen jokaisen näytön pikselin kohdalla: ”minkä värinen olet juuri nyt?” CSS-liukuväri on kiinteä resepti värejä ja sijainteja. Shader on kaava, joten se voi taivuttaa, rakeistaa, hehkuttaa ja liikuttaa väriä ja tehdä sen uudelleen kuusikymmentä kertaa sekunnissa ilman, että yhtään kuvaa ladataan.

Sinun ei tarvitse kirjoittaa shadereita suunnitellaksesi niillä, mutta kun tiedät, mihin ne pystyvät ja mihin eivät, osaat ohjeistaa kehittäjää, arvioida työkalua ja päättää, milloin tavallinen [CSS-liukuväri](https://gradiently.design/fi/guide/css-linear-gradient) on parempi valinta.

## Mikä shader on, selkokielellä

WebGL on selaimen tapa puhua GPU:lle, ja jokainen WebGL-piirros käyttää kahdenlaista shaderia. **Vertex shader** sijoittaa muodot, ja koko näytön liukuvärissä se on vain yksi suorakulmio, joka peittää canvasin. **Fragment shader** tekee kiinnostavan työn: se ajetaan kerran pikseliä kohden, se saa pikselin sijainnin ja nykyisen ajan ja palauttaa värin.

Koska GPU ajaa tuhansia näitä pieniä ohjelmia rinnakkain, kaava, joka olisi tavallisessa koodissa hidas, on niin kevyt, että sen voi piirtää uudelleen joka ruudulla. Tässä on kokonainen fragment shader kolmen värin liukuvärille, jonka raja huojuu lempeästi ajan myötä ja jonka päällä on kerros rakeisuutta.

```text
#version 300 es
precision highp float;

uniform vec2 u_resolution;   // piirtoalueen koko pikseleinä
uniform float u_time;        // sekunnit aloituksesta
out vec4 outColor;

void main() {
  vec2 uv = gl_FragCoord.xy / u_resolution;   // 0:sta 1:een piirtoalueen poikki

  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

  // Hidas aalto taivuttaa värien sekoitusta niin, että värit liukuvat.
  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));

  // Hieno rakeisuus: eri satunnaisarvo jokaiselle pikselille ja kuvalle.
  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);
}
```

WebGL2:n fragment shader GLSL-kielellä. `smoothstep` pehmentää jokaisen siirtymän, siniaalto liikuttaa rajaa, ja viimeiset rivit lisäävät rakeisuutta, joka myös piilottaa raidoittumisen.

- Yöpohja: #120a2e
- Violetti: #7c3aed
- Koralli: #fa7373

Shaderin kolme väriä. GLSL kirjoittaa värin arvoina 0 ja 1 väliltä kanavaa kohden, joten #7c3aed on 124, 58 ja 237 jaettuna 255:llä.

## Miten shader-liukuväri eroaa CSS-liukuväristä

CSS-liukuväri on deklaratiivinen: luettelet värit ja sijainnit, ja selain maalaa ne. Se on useimmiten oikea työkalu. Shader on proseduraalinen: kuvaat, miten värin pitää käyttäytyä, ja matematiikka tuottaa sen. Ero näkyy siinä, mihin kumpikin pystyy ja mitä kumpikin maksaa.

| Ominaisuus | CSS-liukuväri | Shader-liukuväri |
| --- | --- | --- |
| Määritellään | Väreillä, pysäytyspisteillä ja suunnalla | Kaavalla, joka ajetaan pikseli kerrallaan |
| Liike | Sijainnin tai koon liikuttaminen tai animoidut mukautetut ominaisuudet | Kaikki, minkä voi ilmaista matematiikalla, joka ruudulla |
| Tekstuuri ja rakeisuus | Tarvitsee lisäkerroksen, kuten SVG-kohinan | Sisäänrakennettu, ja se voi liikkua |
| Ajamisen hinta | Hyvin pieni, kun se on maalattu | Pitää GPU:n kiireisenä animoinnin ajan |
| Toimii ilman JavaScriptiä | Kyllä | Ei: skripti pystyttää canvasin |
| Toimii sähköpostissa | Osittain, sähköpostiohjelmasta riippuen | Ei |

Kumpikaan ei ole yleisesti parempi. Kumpikin voittaa eri tehtävässä.

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

Sama paletti liikkumattomana CSS-liukuvärinä. Jokaisen shader-taustan mukana pitäisi olla tällainen varavaihtoehto, joka näytetään ennen shaderin käynnistymistä ja aina, kun sitä ei voi ajaa.

## Miksi shader-liukuvärit tuntuvat eläviltä

Kolme tekniikkaa tekee suurimman osan työstä, ja kuulet kehittäjien mainitsevan ne. **Kohina** on tasaista satunnaisuutta: suoran sekoituksen sijaan väri seuraa pehmeiden kumpujen maisemaa, minkä vuoksi shader-liukuvärit näyttävät orgaanisilta eivätkä geometrisilta. **Domain warping** syöttää kohinan takaisin itseensä, jolloin väri laskostuu ja pyörteilee kuin muste vedessä. **Aika** liu’uttaa koko maisemaa eteenpäin, mikä muuttaa liikkumattoman kentän ajelehtivaksi.

- **Rakeisuus** voidaan tuottaa pikseli- ja ruutukohtaisesti, joten se väreilee kuin filmi eikä pysy paikallaan kuin päälle laskettu tekstuuri. Katso [rakeiset liukuvärit](https://gradiently.design/fi/guide/grainy-gradients).
- **Valoa** voi jäljitellä muutamalla rivillä: kohinaa seuraava korostus näyttää kiillolta silkin tai lasin pinnalla.
- **Tarkkuus** on ilmaista. Kaava ajetaan siinä koossa, joka näytöllä on, joten shader-liukuväri pysyy terävänä puhelimessa ja 4K-näytöllä samalla koodilla.
- **Raidoittuminen** on helpompi voittaa, koska shader voi lisätä hieman ditheröintiä ennen kuin väri pyöristetään 8 bittiin. [Liukuvärin raidoittuminen](https://gradiently.design/fi/guide/gradient-banding) selittää, miksi sillä on merkitystä.

### Käytä CSS:ää, kun

- Liukuväri on liikkumaton tai liikkuu yhdellä yksinkertaisella tavalla
- Se on pitkän sivun runsaan tekstin takana
- Sen täytyy toimia ilman skriptejä tai sähköpostissa
- Tarvitset sen yhdellä koodirivillä

### Käytä shaderia, kun

- Liike tai tekstuuri on suunnitelman ydin
- Kyse on yhdestä hero-alueesta, ei jokaisesta osiosta
- Haluat rakeisuutta, kiiltoa tai virtausta, jota CSS ei pysty jäljittelemään
- Voit tarjota CSS-varavaihtoehdon ja tauon

## Liikkuvan WebGL-taustan hinta

Animoituva shader pitää GPU:n töissä niin kauan kuin se on näkyvissä. Pöytäkoneella sitä tuskin huomaa. Vanhemmalla puhelimella se voi tarkoittaa lämpimiä käsiä, tyhjenevää akkua ja sivua, joka vierii vähemmän sulavasti. Hinta kasvaa pikselien määrän ja kaavan monimutkaisuuden mukana, joten koko näytön shader tiheällä näytöllä on raskain tapaus. [Hidastavatko liukuvärit verkkosivua](https://gradiently.design/fi/guide/css-gradient-performance) kertoo, miten sen voi mitata.

1. **Näytä ensin CSS-varavaihtoehto** Maalaa liikkumaton liukuväri heti ja häivytä canvas esiin, kun shader on piirtänyt ensimmäisen ruutunsa. Kenenkään ei pitäisi nähdä tyhjää laatikkoa.
2. **Tarkista, että WebGL on käytettävissä** Jotkin selaimet, laitteet ja yksityisyysasetukset kytkevät sen pois. Jos kontekstia ei voi luoda, pidä varavaihtoehto.
3. **Kunnioita liikkeen vähentämistä** Jos kävijä pyytää vähemmän liikettä, piirrä yksi ruutu ja pysähdy. [Vähennetty liike](https://gradiently.design/fi/guide/reduced-motion) selittää asetuksen.
4. **Pysäytä, kun sitä ei näy** Pysäytä animaatiosilmukka, kun canvas vierii pois näkyvistä tai välilehti on piilossa.
5. **Renderöi järkevällä tarkkuudella** Pehmeät liukuvärit tarvitsevat harvoin jokaista laitepikseliä. Piirtäminen puolella tarkkuudella ja skaalauksen jättäminen selaimelle voi vähentää työtä paljon, eikä sumeassa kuvassa eroa huomaa.

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

Suojakaiteet muutamalla rivillä: varavaihtoehto, kun WebGL puuttuu, vain yksi ruutu, kun liikettä vähennetään, eikä piirtämistä näkymän ulkopuolella tai piilotetussa välilehdessä.

Viitteeksi: [WebGL API MDN:ssä](https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API) dokumentoi jokaisen tässä käytetyn kutsun, ja [caniuse](https://caniuse.com/webgl2) seuraa WebGL2-tukea eri selaimissa.

## Shader-liukuvärin suunnittelu: mitä ohjeistaa

Voit ohjata shaderia lukematta GLSL:ää. Ohjeista se kuten ohjeistaisit materiaalin, et värimallia. Anna pohjaväri ja sen päällä elävät kolmesta viiteen väriä heksoina. Kuvaile rakenne: pehmeät lammikot, pitkät kaistat, laskostettu silkki. Ilmoita nopeus sekunteina kierrosta kohden äläkä sanalla ”hidas”, koska hidas tarkoittaa eri ihmisille eri asioita. Kerro, kuinka paljon rakeisuutta on ja liikkuuko se. Kerro lopuksi, missä teksti on, jotta kentän levottomin osa pysyy siitä poissa.

> **Arvioi se ensin liikkumattomana** Pysäytä shader satunnaiseen ruutuun ja katso sitä staattisena kuvana. Jos pysäytyskuva ei näytä hyvältä, liike ei pelasta sitä. Liikkeen pitää lisätä jotakin suunnitelmaan, joka jo toimii.

## Miten Gradiently piirtää Markit shadereilla

Gradientlyn Markit ovat shader-liukuvärejä. Jokainen Mark on resepti, johon kuuluu värejä, enintään kolme pinottua materiaalia, valoa, rakeisuutta ja liikettä, ja Studio piirtää sen elävänä WebGL2:lla kaiken suunnittelemasi takana. Koska se lasketaan eikä tallenneta, sama Mark piirtyy terävänä missä tahansa alustakoossa ja liikkuu, kun viet silmukkavideon. Renderöijä tietää myös, missä sanasi ovat, joten se voi siirtää kentän rauhallisimman osan niiden taakse. [Mikä on Mark](https://gradiently.design/fi/guide/what-is-a-mark) selittää reseptin kokonaan.

Mark on shader-resepti, jolla on nimi, koodi ja yksi omistaja. Sen sivu näyttää sen piirtyvän elävänä.

## FAQ

### Mikä on WebGL-liukuväri?

Se on shaderin piirtämä liukuväri. Shader on pieni grafiikkapiirillä toimiva ohjelma, joka laskee jokaisen pikselin värin. Koska se on kaava, se voi liikkua, lisätä rakeisuutta ja piirtyä missä tahansa koossa.

### Onko shader-liukuväri huono suorituskyvylle?

Liikkumaton tai pysäytetty shader maksaa vähän, mutta animoituva pitää GPU:n kiireisenä niin kauan kuin se on näkyvissä. Pysäytä se, kun se ei näy, piirrä järkevällä tarkkuudella ja pidä CSS-varavaihtoehto.

### Kunnioittavatko shader-liukuvärit liikkeen vähentämisen asetuksia?

Vain, jos ne on rakennettu niin. Tarkista prefers-reduced-motion-mediakysely JavaScriptissä ja piirrä yksi pysäytysruutu, kun se on asetettu.

### Mikä on GLSL?

GLSL on WebGL:n käyttämä shader-kieli. Sillä kirjoitetut fragment shaderit päättävät jokaisen pikselin värin, ja selain kääntää ne grafiikkapiirille.
