# Ruido y patrones

> Aleatoriedad orgánica (Perlin, simplex, fractal, Voronoi) y patrones regulares (damero, rayas, cuadrícula, puntos, degradados, ondas).

Source: https://albakore.github.io/pyzed/es/shading/nodes/noise-patterns/

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

## Ruido

El ruido da valores entre 0 y 1 que parecen aleatorios pero cambian suavemente: la base de nubes, fuego, agua, mármol y terrenos.

### Ruido

*Noise* · `noise` · Ruido · `g.noise(...)`

Valores aleatorios suaves de 0 a 1 (ruido de valor, Perlin o simplex).

Aleatoriedad suave de 0 a 1. **Perlin** es la clásica, **simplex** se ve más natural, **value** es más cuadrada y más barata. `scale` es cuántas ondulaciones caben.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `p` | `vec2` | *UV con proporción* (contexto) |
| `scale` · escala | `float` | `8` |

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

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `kind` | `value`, `perlin`, `simplex` | `perlin` |

**Entradas de la barra lateral**

| Entrada | Qué hace | En Python |
| --- | --- | --- |
| Ruido | Valores aleatorios suaves de 0 a 1 (ruido de valor, Perlin o simplex). | `g.noise(...)` |
| Ruido de valor | Ruido suave en bloques de 0 a 1. | `g.value_noise(...)` |
| Ruido simplex | Ruido simplex de 0 a 1. | `g.simplex_noise(...)` |

```python title="Ejemplo"
n = g.noise(scale=5.0, kind="simplex")
g.output(g.rgba(n, 1.0))
```

### Ruido fractal

*Fractal noise* · `fbm` · Ruido · `g.fbm(...)`

Capas de ruido, cada una más fina y tenue (fBm): nubes, humo, fuego, terreno.

Varias capas de ruido, cada una más fina y más tenue: el aspecto de nubes, humo y montañas. Más `octaves` añaden detalle (y coste).

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `p` | `vec2` | *UV con proporción* (contexto) |
| `scale` · escala | `float` | `4` |
| `octaves` · octavas | `int` | `5` |
| `lacunarity` · lacunaridad | `float` | `2` |
| `gain` · ganancia | `float` | `0.5` |

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

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `kind` | `value`, `perlin`, `simplex` | `value` |

```python title="Ejemplo"
n = g.fbm(scale=3.0, octaves=6)
g.output(g.gradient(n))
```

### Voronoi

`voronoi` · Ruido · `g.voronoi(...)`

Celdas alrededor de puntos aleatorios: la distancia al punto más cercano y al segundo, al borde más cercano, y un número aleatorio por celda. Phase mueve los puntos.

Celdas alrededor de puntos aleatorios, como barro agrietado, cristales o piel de jirafa. `edge` es pequeño cerca de los bordes y `cell` es un número aleatorio por celda (ideal para un color por celda). `phase` mueve los puntos.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `p` | `vec2` | *UV con proporción* (contexto) |
| `scale` · escala | `float` | `6` |
| `jitter` · dispersión | `float` | `1` |
| `phase` · fase | `float` | *Tiempo* (contexto) |

| Salida | Tipo |
| --- | --- |
| `distance` · distancia | `float` |
| `second` · segundo | `float` |
| `edge` · borde | `float` |
| `cell` · celda | `float` |

```python title="Ejemplo"
v = g.voronoi(scale=6.0)
color = g.palette(v["cell"])
g.output(g.rgba(color * g.smoothstep(0.0, 0.05, v["edge"]), 1.0))
```

### Ruido blanco

*White noise* · `white_noise` · Ruido · `g.white_noise(...)`

Un número aleatorio distinto, de 0 a 1, para cada valor de p.

Un número aleatorio distinto para cada valor de entrada, sin suavidad: estática de TV, destellos, tramado.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `p` | `vec2` | *Píxel* (contexto) |

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

```python title="Ejemplo"
n = g.white_noise()
g.output(g.rgba(n, 1.0))
```

### Aleatorio

*Random* · `random` · Ruido · `g.random(...)`

Un número aleatorio de 0 a 1 para una semilla (misma semilla, mismo número).

Un número aleatorio para una semilla: la misma semilla da siempre el mismo número. Pásale el número de una celda para dar a cada celda su propio valor.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `seed` · semilla | `float` | `1` |

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

```python title="Ejemplo"
r = g.repeat(cell=[0.2, 0.2])
v = g.random(r["cell"].x * 7.0 + r["cell"].y)
g.output(g.rgba(v, 1.0))
```

## Patrones

Patrones regulares, casi siempre 0 o 1 (negro o blanco). Multiplica un color por ellos, o úsalos como `t` de un Mezclar o un Degradado.

### Tablero

*Checker* · `checker` · Patrones · `g.checker(...)`

Un tablero de ajedrez de 0 y 1.

Un damero: 0 y 1 en cuadros alternos.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `uv` | `vec2` | *UV con proporción* (contexto) |
| `cells` · celdas | `vec2` | `(8, 8)` |

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

```python title="Ejemplo"
c = g.checker(cells=[8.0, 8.0])
g.output(g.rgba(g.mix(0.2, 0.9, c), 1.0))
```

### Franjas

*Stripes* · `stripes` · Patrones · `g.stripes(...)`

Franjas paralelas de 0 y 1 (ángulo en radianes, ancho de 0 a 1).

Rayas paralelas en cualquier ángulo; `width` es cuánto de cada raya es blanco.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `uv` | `vec2` | *UV* (contexto) |
| `count` · cantidad | `float` | `10` |
| `angle` · ángulo | `float` | `0` |
| `width` · ancho | `float` | `0.5` |

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

```python title="Ejemplo"
s = g.stripes(count=12.0, angle=0.785)
g.output(g.rgba(s, 1.0))
```

### Cuadrícula

*Grid* · `grid` · Patrones · `g.grid(...)`

Líneas de cuadrícula: 1 sobre las líneas, 0 entre ellas (grosor de 0 a 1 de una celda).

Líneas finas de cuadrícula: papel milimetrado, planos y suelos synthwave.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `uv` | `vec2` | *UV con proporción* (contexto) |
| `cells` · celdas | `vec2` | `(8, 8)` |
| `thickness` · grosor | `float` | `0.06` |

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

```python title="Ejemplo"
l = g.grid(cells=[10.0, 10.0], thickness=0.05)
g.output(g.rgba(g.mix([0.05, 0.05, 0.15], [0.2, 0.8, 1.0], l), 1.0))
```

### Puntos

*Dots* · `dots` · Patrones · `g.dots(...)`

Una cuadrícula de puntos redondos: 1 dentro, 0 fuera (radio de 0 a 0,5 de una celda).

Una cuadrícula de puntos redondos: lunares y aspecto de trama de imprenta.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `uv` | `vec2` | *UV con proporción* (contexto) |
| `cells` · celdas | `vec2` | `(10, 10)` |
| `radius` · radio | `float` | `0.3` |

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

```python title="Ejemplo"
d = g.dots(cells=[12.0, 12.0], radius=0.25)
g.output(g.rgba(d, 1.0))
```

### Degradado lineal

*Linear gradient* · `linear_gradient` · Patrones · `g.linear_gradient(...)`

De 0 a 1 a lo ancho del área en una dirección (ángulo en radianes).

De 0 a 1 a lo ancho del área en una dirección (`angle` en radianes, 0 es de izquierda a derecha).

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `uv` | `vec2` | *UV* (contexto) |
| `angle` · ángulo | `float` | `0` |

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

```python title="Ejemplo"
t = g.linear_gradient(angle=1.57)
g.output(g.gradient(t))
```

### Degradado radial

*Radial gradient* · `radial_gradient` · Patrones · `g.radial_gradient(...)`

1 en el centro, se desvanece hasta 0 en el radio (respeta la proporción).

1 en el centro que se desvanece a 0 en `radius`: focos, brillos suaves y viñetas.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `uv` | `vec2` | *UV* (contexto) |
| `center` · centro | `vec2` | `(0.5, 0.5)` |
| `radius` · radio | `float` | `0.5` |

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

```python title="Ejemplo"
r = g.radial_gradient(radius=0.5)
g.output(g.rgba(g.compose(r, r * 0.6, 0.2), 1.0))
```

### Onda

*Wave* · `wave` · Patrones · `g.wave(...)`

Una onda repetida de 0 a 1 (seno, triangular, cuadrada o diente de sierra): frequency ondas por unidad de x.

Una onda repetida de 0 a 1 en cuatro formas: **sine** (suave), **triangle**, **square** (encendido/apagado, parpadeo) y **sawtooth** (rampa). Con la `x` por defecto (el tiempo) se anima; conecta una coordenada UV para obtener bandas.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `x` | `float` | *Tiempo* (contexto) |
| `frequency` · frecuencia | `float` | `1` |
| `phase` · fase | `float` | `0` |

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

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `shape` | `sine`, `triangle`, `square`, `sawtooth` | `sine` |

**Entradas de la barra lateral**

| Entrada | Qué hace | En Python |
| --- | --- | --- |
| Onda | Una onda repetida de 0 a 1 (seno, triangular, cuadrada o diente de sierra): frequency ondas por unidad de x. | `g.wave(...)` |
| Onda cuadrada | Encendido y apagado: 0 o 1, repetido. | `g.square_wave(...)` |
| Onda diente de sierra | Sube de 0 a 1 y vuelve a empezar. | `g.sawtooth_wave(...)` |

```python title="Ejemplo"
w = g.wave(g.uv()["x"], frequency=6.0, shape="triangle")
g.output(g.rgba(w, 1.0))
```

**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/)