# Entradas, parámetros y constantes

> Los nodos de los que parte todo shader: dónde está el píxel, el tiempo, el ratón, tus variables y valores fijos.

Source: https://albakore.github.io/pyzed/es/shading/nodes/inputs/

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

## Entrada

Dónde está el píxel que se pinta, el tamaño del área, el tiempo y el ratón. Casi todo grafo empieza con uno de estos.

### UV

`uv` · Entrada · `g.uv(...)`

Dónde está el píxel, de (0, 0) arriba a la izquierda a (1, 1) abajo a la derecha.

El nodo más usado. `x` va de 0 a la izquierda a 1 a la derecha e `y` de 0 arriba a 1 abajo, sea cual sea el tamaño del widget. Conecta `x` a un Degradado para obtener una rampa horizontal.

| Salida | Tipo |
| --- | --- |
| `uv` | `vec2` |
| `x` | `float` |
| `y` | `float` |

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

### Píxel

*Pixel* · `pixel` · Entrada · `g.pixel(...)`

Dónde está el píxel, en píxeles desde arriba a la izquierda.

Como UV pero en píxeles: úsalo para lo que debe mantener su tamaño en píxeles cuando el widget crece, como líneas cada 3 píxeles.

| Salida | Tipo |
| --- | --- |
| `px` · píxel | `vec2` |
| `x` | `float` |
| `y` | `float` |

```python title="Ejemplo"
px = g.pixel()
lines = g.fract(px["y"] / 4.0)
g.output(g.rgba(g.step(0.5, lines), 1.0))
```

### Tamaño

*Size* · `size` · Entrada · `g.size(...)`

El tamaño del área sombreada en píxeles y su proporción (ancho / alto).

El ancho y el alto del área en píxeles. `aspect` (ancho ÷ alto) mantiene redondos los círculos en widgets anchos; Centered UV ya lo usa por ti.

| Salida | Tipo |
| --- | --- |
| `size` · tamaño | `vec2` |
| `width` · ancho | `float` |
| `height` · alto | `float` |
| `aspect` · proporción | `float` |

```python title="Ejemplo"
s = g.size()
g.output(g.rgba(g.fract(s["aspect"]), 1.0))
```

### Tiempo

*Time* · `time` · Entrada · `g.time(...)`

Segundos desde que arrancó la app (por scale), y su seno y coseno.

Segundos desde que arrancó la app: todo lo que se conecta a él se mueve. `sin` y `cos` oscilan suavemente entre −1 y 1, perfectos para pulsos. `scale` lo acelera o lo frena.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `scale` · escala | `float` | `1` |

| Salida | Tipo |
| --- | --- |
| `time` · tiempo | `float` |
| `sin` | `float` |
| `cos` | `float` |

```python title="Ejemplo"
t = g.time(scale=2.0)
pulse = t["sin"] * 0.5 + 0.5
g.output(g.rgba(g.hsv_to_rgb(0.6, 0.8, pulse), 1.0))
```

### Ratón

*Mouse* · `mouse` · Entrada · `g.mouse(...)`

Dónde está el puntero de 0 a 1 (el centro mientras está fuera), y si está sobre el shader.

Dónde está el puntero, en UV (0 a 1). Mientras está fuera del shader, `position` es el centro e `inside` es falso. Ideal para focos y efectos al pasar el ratón.

| Salida | Tipo |
| --- | --- |
| `position` · posición | `vec2` |
| `inside` · dentro | `bool` |

```python title="Ejemplo"
m = g.mouse()
light = g.radial_gradient(center=m["position"], radius=0.3)
g.output(g.rgba(light, 1.0))
```

### UV centrado

*Centered UV* · `centered_uv` · Entrada · `g.centered_uv(...)`

UV con (0, 0) en el centro y círculos redondos: donde dibujar formas. UV con proporción va de 0 a la proporción a lo ancho, para que el ruido y las celdas queden cuadrados.

Las coordenadas para dibujar formas: (0, 0) es el centro y una unidad es la altura, así un círculo sigue redondo en cualquier widget. `aspect_uv` mantiene cuadrados el ruido y las celdas.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `uv` | `vec2` | *UV* (contexto) |

| Salida | Tipo |
| --- | --- |
| `centered` · centrado | `vec2` |
| `aspect_uv` · uv con proporción | `vec2` |

```python title="Ejemplo"
c = g.centered_uv()
d = g.length(c["centered"])
g.output(g.rgba(g.smoothstep(0.4, 0.0, d), 1.0))
```

## Parámetros

Un nodo **Parámetro** lee una de las variables del shader: los valores que cambia tu código Python (o un deslizador en la pestaña Vista previa).

### Parámetro

*Parameter* · `parameter` · Parámetros · `g.parameter(...)`

Lee una variable del shader (ver la lista Variables): una mutable cambia sin recompilar, una constante queda dentro del código.

Los mandos de tu shader. `g.uniform(...)` añade una variable mutable y un nodo Parámetro a la vez; en el diseñador, arrastra una variable de la Estructura (Outline) al grafo. Una variable `color` da las salidas `color`, `rgb` y `alpha`.

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

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `name` | `variable` | — |

La salida toma el tipo de la variable; una variable `color` da `color`, `rgb` y `alpha`.

```python title="Ejemplo"
tint = g.uniform("tint", "color", "#22d3ee")
glow = g.radial_gradient(radius=0.6)
g.output(g.rgba(tint["rgb"] * glow, 1.0))
```

## Constantes

Valores fijos escritos en el shader. Si un valor nunca cambia, una constante es lo más simple; si quieres cambiarlo desde código, usa una variable.

### Decimal

*Float* · `float` · Constantes · `g.float(...)`

Un número fijo.

Un número fijo. La mayoría de las entradas ya aceptan un valor escrito directamente, así que solo necesitas este nodo para llevar el mismo número a varios sitios.

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

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `value` | `float` | `0.5` |

```python title="Ejemplo"
half = g.float(0.5)
g.output(g.rgba(g.compose(half, half, 1.0), 1.0))
```

### Entero

*Int* · `int` · Constantes · `g.int(...)`

Un número entero fijo.

Un número entero fijo, para entradas como las octavas de Ruido fractal.

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

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `value` | `int` | `1` |

```python title="Ejemplo"
octaves = g.int(3)
n = g.fbm(octaves=octaves)
g.output(g.rgba(n, 1.0))
```

### Booleano

*Bool* · `bool` · Constantes · `g.bool(...)`

Un verdadero o falso fijo.

Un verdadero o falso fijo, para los nodos Elegir y Lógica.

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

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `value` | `bool` | `true` |

```python title="Ejemplo"
on = g.bool(True)
g.output(g.rgba(g.select(on, 1.0, 0.2), 1.0))
```

### Vector2

`vec2` · Constantes · `g.vec2(...)`

Dos números fijos.

Dos números fijos: un punto o un tamaño.

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

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `value` | `vec2` | `(0.5, 0.5)` |

```python title="Ejemplo"
center = g.vec2([0.3, 0.5])
g.output(g.rgba(g.radial_gradient(center=center, radius=0.3), 1.0))
```

### Vector3

`vec3` · Constantes · `g.vec3(...)`

Tres números fijos.

Tres números fijos: a menudo un color RGB escrito con números de 0 a 1.

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

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `value` | `vec3` | `(1, 1, 1)` |

```python title="Ejemplo"
orange = g.vec3([1.0, 0.5, 0.0])
g.output(g.rgba(orange, 1.0))
```

### Vector4

`vec4` · Constantes · `g.vec4(...)`

Cuatro números fijos.

Cuatro números fijos: un color con alfa, en números.

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

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `value` | `vec4` | `(1, 1, 1, 1)` |

```python title="Ejemplo"
g.output(g.vec4([0.1, 0.2, 0.4, 1.0]))
```

### Color

`color` · Constantes · `g.color(...)`

Un color fijo.

Un color fijo elegido con el selector de color (o escrito como `#rrggbb`).

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

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `value` | `color` | `#7c3aed` |

```python title="Ejemplo"
g.output(g.color("#7c3aed"))
```

### Constantes matemáticas

*Math constants* · `math_constants` · Constantes · `g.math_constants(...)`

π, τ (2π), e y la proporción áurea.

π, τ (2π), e y φ, para no escribir 3.14159. Multiplica un valor 0..1 por τ para obtener una vuelta completa en radianes.

| Salida | Tipo |
| --- | --- |
| `pi` · π | `float` |
| `tau` · τ | `float` |
| `e` | `float` |
| `phi` · φ | `float` |

```python title="Ejemplo"
k = g.math_constants()
wave = g.sin(g.uv()["x"] * k["tau"] * 3.0) * 0.5 + 0.5
g.output(g.rgba(wave, 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/)