# Color, efectos y texturas

> Degradados, paletas, tono, saturación, modos de fusión y capas, efectos de pantalla (viñeta, líneas de barrido, grano) e imágenes.

Source: https://albakore.github.io/pyzed/es/shading/nodes/color-effects/

Cada ejemplo de esta página se ejecuta después de estas dos líneas y termina enviando un color al nodo Salida:

```python
from pyzed import shading

g = shading.Graph("demo")
```

## Color

Los colores son `vec3` (r, g, b) o `vec4` (r, g, b, a) con valores de 0 a 1, no de 0 a 255: `(1, 0.5, 0)` es naranja.

### HSV a RGB

*HSV to RGB* · `hsv_to_rgb` · Color · `g.hsv_to_rgb(...)`

Un color a partir de tono (de 0 a 1 alrededor de la rueda), saturación y valor.

Un color a partir del tono (0..1 alrededor de la rueda: rojo, amarillo, verde, cian, azul, magenta, rojo), la saturación y el valor. Conecta el Tiempo al tono para un arcoíris que gira.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `h` · tono | `float` | `0` |
| `s` · saturación | `float` | `1` |
| `v` · valor | `float` | `1` |

| Salida | Tipo |
| --- | --- |
| `rgb` | `vec3` |

```python title="Ejemplo"
uv = g.uv()
g.output(g.rgba(g.hsv_to_rgb(uv["x"], 0.8, 1.0), 1.0))
```

### RGB a HSV

*RGB to HSV* · `rgb_to_hsv` · Color · `g.rgb_to_hsv(...)`

El tono, la saturación y el valor de un color.

Separa un color en tono, saturación y valor, para cambiar uno de ellos.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `rgb` | `vec3` | `(1, 0, 0)` |

| Salida | Tipo |
| --- | --- |
| `hsv` | `vec3` |
| `h` · tono | `float` |
| `s` · saturación | `float` |
| `v` · valor | `float` |

```python title="Ejemplo"
hsv = g.rgb_to_hsv([1.0, 0.5, 0.0])
g.output(g.rgba(g.hsv_to_rgb(hsv["h"], 0.3, hsv["v"]), 1.0))
```

### Desplazar tono

*Hue shift* · `hue_shift` · Color · `g.hue_shift(...)`

Gira el tono de un color (shift de 0 a 1 es una vuelta completa).

Gira el tono de un color por la rueda (`shift` 1 es una vuelta completa).

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `rgb` | `vec3` | `(1, 0, 0)` |
| `shift` · desplazamiento | `float` | `0.25` |

| Salida | Tipo |
| --- | --- |
| `rgb` | `vec3` |

```python title="Ejemplo"
g.output(g.rgba(g.hue_shift([1.0, 0.2, 0.2], g.time(scale=0.2)["time"]), 1.0))
```

### Saturación

*Saturation* · `saturation` · Color · `g.saturation(...)`

Más (por encima de 1) o menos (por debajo de 1) colorido; 0 es gris.

Más (por encima de 1) o menos (por debajo de 1) colorido; 0 es gris.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `rgb` | `vec3` | `(1, 0.5, 0)` |
| `amount` · cantidad | `float` | `1.5` |

| Salida | Tipo |
| --- | --- |
| `rgb` | `vec3` |

```python title="Ejemplo"
c = g.palette(g.uv()["x"])
g.output(g.rgba(g.saturation(c, 0.4), 1.0))
```

### Brillo y contraste

*Brightness and contrast* · `brightness_contrast` · Color · `g.brightness_contrast(...)`

Más claro u oscuro, y más o menos contraste.

Más claro u oscuro, y más o menos contraste, como en un editor de fotos.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `rgb` | `vec3` | `(0.5, 0.5, 0.5)` |
| `brightness` · brillo | `float` | `0` |
| `contrast` · contraste | `float` | `1` |

| Salida | Tipo |
| --- | --- |
| `rgb` | `vec3` |

```python title="Ejemplo"
c = g.palette(g.uv()["x"])
g.output(g.rgba(g.brightness_contrast(c, 0.1, 1.4), 1.0))
```

### Luminancia

*Luminance* · `luminance` · Color · `g.luminance(...)`

Lo brillante que se ve un color, de 0 a 1.

Lo brillante que parece un color al ojo, como un número de 0 a 1.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `rgb` | `vec3` | `(1, 1, 1)` |

| Salida | Tipo |
| --- | --- |
| `value` · valor | `float` |

```python title="Ejemplo"
l = g.luminance([0.2, 0.7, 0.3])
g.output(g.rgba(l, 1.0))
```

### Escala de grises

*Grayscale* · `grayscale` · Color · `g.grayscale(...)`

El color en tonos de gris.

El color en tonos de gris (blanco y negro).

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `rgb` | `vec3` | `(1, 0.5, 0)` |

| Salida | Tipo |
| --- | --- |
| `rgb` | `vec3` |

```python title="Ejemplo"
c = g.palette(g.uv()["x"])
g.output(g.rgba(g.grayscale(c), 1.0))
```

### Invertir

*Invert* · `invert` · Color · `g.invert(...)`

El color opuesto: 1 − color (conserva el alfa).

El negativo de un color (1 − color); el alfa se mantiene.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `color` | `T` | `(1, 0.5, 0)` |

| Salida | Tipo |
| --- | --- |
| `color` | `T` |

```python title="Ejemplo"
c = g.gradient(g.uv()["x"])
g.output(g.invert(c["color"]))
```

### Gamma

`gamma` · Color · `g.gamma(...)`

Aclara (por encima de 1) u oscurece (por debajo de 1) los tonos medios.

Aclara (por encima de 1) u oscurece (por debajo de 1) los medios tonos sin tocar el blanco y el negro.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `rgb` | `vec3` | `(0.5, 0.5, 0.5)` |
| `gamma` | `float` | `2.2` |

| Salida | Tipo |
| --- | --- |
| `rgb` | `vec3` |

```python title="Ejemplo"
v = g.uv()["x"]
g.output(g.rgba(g.gamma(g.compose(v, v, v), 2.2), 1.0))
```

### Posterizar

*Posterize* · `posterize` · Color · `g.posterize(...)`

Conserva solo unos pocos niveles de cada componente.

Deja solo unos pocos escalones de cada color: sombreado cel y aspecto retro.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `color` | `T` | `(0.3, 0.6, 0.9)` |
| `steps` · niveles | `float` | `4` |

| Salida | Tipo |
| --- | --- |
| `color` | `T` |

```python title="Ejemplo"
c = g.palette(g.uv()["x"])
g.output(g.rgba(g.posterize(c, 4.0), 1.0))
```

### Fusionar

*Blend* · `blend` · Color · `g.blend(...)`

Fusiona layer sobre base como los modos de capa de un editor de imágenes.

Mezcla `layer` sobre `base` como los modos de capa de un editor de imágenes: normal, multiply, screen, overlay, add, subtract, difference, darken, lighten, soft light, color dodge y color burn.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `base` | `vec3` | `(0.2, 0.4, 0.8)` |
| `layer` · capa | `vec3` | `(1, 0.6, 0.2)` |
| `opacity` · opacidad | `float` | `1` |

| Salida | Tipo |
| --- | --- |
| `rgb` | `vec3` |

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `mode` | `normal`, `multiply`, `screen`, `overlay`, `add`, `subtract`, `difference`, `darken`, `lighten`, `soft_light`, `color_dodge`, `color_burn` | `multiply` |

```python title="Ejemplo"
base = g.gradient(g.uv()["y"])
clouds = g.fbm(scale=3.0)
layer = g.compose(clouds, clouds, clouds)
g.output(g.rgba(g.blend(base["rgb"], layer, 0.8, mode="screen"), 1.0))
```

### Paleta

*Palette* · `palette` · Color · `g.palette(...)`

Un color suave tipo arcoíris para t, con las paletas de coseno de Inigo Quilez: a + b × cos(2π(c × t + d)).

Convierte un número de 0 a 1 en un color suave tipo arcoíris con una fórmula de cosenos. Cambia `d` para desplazar los colores; es la forma más rápida de colorear un ruido.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `t` | `float` | `0` |
| `a` | `vec3` | `(0.5, 0.5, 0.5)` |
| `b` | `vec3` | `(0.5, 0.5, 0.5)` |
| `c` | `vec3` | `(1, 1, 1)` |
| `d` | `vec3` | `(0, 0.33, 0.67)` |

| Salida | Tipo |
| --- | --- |
| `rgb` | `vec3` |

```python title="Ejemplo"
n = g.noise(scale=4.0)
g.output(g.rgba(g.palette(n), 1.0))
```

### Degradado

*Gradient* · `gradient` · Color · `g.gradient(...)`

Una rampa de color: el color en t (0 a 1) entre las paradas que elijas.

Una rampa de color que editas con paradas: el color en `t` entre las paradas. En el diseñador arrastras las paradas; en Python pasa `stops=[[posición, color], ...]`.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `t` | `float` | `0.5` |

| Salida | Tipo |
| --- | --- |
| `color` | `vec4` |
| `rgb` | `vec3` |
| `alpha` | `float` |

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `stops` | `stops` | `0` #1e1b4b, `0.5` #db2777, `1` #fde047 |

```python title="Ejemplo"
ramp = g.gradient(g.uv()["x"], stops=[[0.0, "#0f172a"], [0.6, "#7c3aed"], [1.0, "#f472b6"]])
g.output(ramp)
```

### RGBA

`rgba` · Color · `g.rgba(...)`

Un color con alfa a partir de un color vec3 y una opacidad.

Une un color RGB y una opacidad en el `vec4` que quiere la Salida.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `rgb` | `vec3` | `(1, 1, 1)` |
| `alpha` | `float` | `1` |

| Salida | Tipo |
| --- | --- |
| `color` | `vec4` |

```python title="Ejemplo"
g.output(g.rgba([0.2, 0.6, 1.0], 0.5))
```

### Capa

*Layer* · `layer` · Color · `g.layer(...)`

Pone front sobre back usando el alfa de front.

Pone `front` sobre `back` usando el alfa de front, como apilar dos capas.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `back` · fondo | `vec4` | `(0, 0, 0, 1)` |
| `front` · frente | `vec4` | `(1, 1, 1, 0.5)` |

| Salida | Tipo |
| --- | --- |
| `color` | `vec4` |

```python title="Ejemplo"
back = g.gradient(g.uv()["y"])
spot = g.rgba([1.0, 1.0, 1.0], g.fill(g.circle(radius=0.2)))
g.output(g.layer(back["color"], spot))
```

## Efectos

Efectos de pantalla que devuelven un número cercano a 1: multiplica tu color final por ellos.

### Viñeta

*Vignette* · `vignette` · Efectos · `g.vignette(...)`

Oscurece hacia las esquinas: multiplica un color por él.

Oscurece hacia las esquinas y lleva la mirada al centro.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `uv` | `vec2` | *UV* (contexto) |
| `strength` · intensidad | `float` | `0.8` |

| Salida | Tipo |
| --- | --- |
| `value` · valor | `float` |

```python title="Ejemplo"
c = g.gradient(g.uv()["x"])
g.output(g.rgba(c["rgb"] * g.vignette(strength=0.9), 1.0))
```

### Líneas de barrido

*Scanlines* · `scanlines` · Efectos · `g.scanlines(...)`

Las líneas horizontales de una pantalla CRT: multiplica un color por ellas.

Las líneas horizontales de un televisor antiguo; `speed` las hace desplazarse.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `px` · píxel | `vec2` | *Píxel* (contexto) |
| `spacing` · espaciado | `float` | `3` |
| `strength` · intensidad | `float` | `0.25` |
| `speed` · velocidad | `float` | `0` |

| Salida | Tipo |
| --- | --- |
| `value` · valor | `float` |

```python title="Ejemplo"
c = g.gradient(g.uv()["y"])
g.output(g.rgba(c["rgb"] * g.scanlines(spacing=3.0, strength=0.3), 1.0))
```

### Grano de película

*Film grain* · `grain` · Efectos · `g.grain(...)`

Motas aleatorias que cambian cada fotograma: multiplica un color por ellas.

Motas aleatorias que cambian en cada fotograma, como en una película.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `px` · píxel | `vec2` | *Píxel* (contexto) |
| `strength` · intensidad | `float` | `0.12` |

| Salida | Tipo |
| --- | --- |
| `value` · valor | `float` |

```python title="Ejemplo"
c = g.gradient(g.uv()["x"])
g.output(g.rgba(c["rgb"] * g.grain(strength=0.15), 1.0))
```

## Textura

Imágenes en un shader: añade una variable `texture` (un archivo de imagen) y lee sus colores.

### Muestrear textura

*Sample texture* · `sample_texture` · Textura · `g.sample_texture(...)`

El color de una textura (una variable de imagen) en uv.

Lee el color de una imagen en un UV. Añade una variable `texture` cuyo valor sea la ruta de una imagen (relativa al `.pzshad`), conéctala a `texture` y deforma antes el UV para ondas o pixelado.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `texture` · textura | `texture` | — |
| `uv` | `vec2` | *UV* (contexto) |

| Salida | Tipo |
| --- | --- |
| `color` | `vec4` |
| `rgb` | `vec3` |
| `alpha` | `float` |

```python title="Ejemplo"
photo = g.uniform("photo", "texture", "photo.png")
uv = g.pixelate(cells=[40.0, 30.0])
g.output(g.sample_texture(photo, uv["uv"]))
```

**Siempre al día:**

Esta página se genera a partir del catálogo de nodos de `pyzed.shading`, así que los puertos, tipos y valores por defecto son siempre los de esta versión. Cada ejemplo se compila al construir la documentación.

**Ver también:** [Primeros pasos](https://albakore.github.io/pyzed/es/shading/getting-started/) · [La vista Shader](https://albakore.github.io/pyzed/es/shading/shader-designer/) · [Recetas](https://albakore.github.io/pyzed/es/shading/recipes/) · [Grafos de shader en Python](https://albakore.github.io/pyzed/es/shading/shader-graphs/)