# Lógica, variables y utilidades

> Comparaciones y si/si no, valores con nombre, desvíos, tu propio WGSL, otros shaders como funciones, comentarios y el nodo Salida.

Source: https://albakore.github.io/pyzed/es/shading/nodes/logic-utility/

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

## Lógica

Valores verdadero/falso y elegir entre dos valores. Los shaders corren en todos los píxeles a la vez: prefiere Mezclar y Paso suave para transiciones suaves y deja Elegir para elecciones tajantes.

### Comparar

*Compare* · `compare` · Lógica · `g.compare(...)`

Si a es menor, mayor o igual que b (en vectores: todos los componentes).

Compara `a` y `b` (`<`, `<=`, `>`, `>=`, `==`, `!=`) y da verdadero o falso.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `a` | `T` | `0` |
| `b` | `T` | `0.5` |

| Salida | Tipo |
| --- | --- |
| `result` · resultado | `bool` |

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `op` | `<`, `<=`, `>`, `>=`, `==`, `!=` | `<` |

```python title="Ejemplo"
left = g.compare(g.uv()["x"], 0.5, op="<")
g.output(g.rgba(g.select(left, 1.0, 0.2), 1.0))
```

### Elegir

*Select* · `select` · Lógica · `g.select(...)`

si condition entonces a, si no b.

Si `condition` es verdadero, `a` (entonces); si no, `b` (si no).

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `condition` · condición | `bool` | `true` |
| `a` · entonces | `T` | `1` |
| `b` · si no | `T` | `0` |

| Salida | Tipo |
| --- | --- |
| `result` · resultado | `T` |

```python title="Ejemplo"
inside = g.mouse()["inside"]
g.output(g.rgba(g.select(inside, [0.2, 0.8, 0.4], [0.3, 0.3, 0.3]), 1.0))
```

### Lógica

*Logic* · `logic` · Lógica · `g.logic(...)`

and, or, xor y not de valores verdadero/falso.

`and`, `or`, `xor` y `not` de valores verdadero/falso.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `a` | `bool` | `true` |
| `b` | `bool` | `false` |

| Salida | Tipo |
| --- | --- |
| `result` · resultado | `bool` |

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `op` | `and`, `or`, `xor`, `not` | `and` |

```python title="Ejemplo"
uv = g.uv()
both = g.logic(g.compare(uv["x"], 0.5, op=">"), g.compare(uv["y"], 0.5, op=">"), op="and")
g.output(g.rgba(g.select(both, 1.0, 0.0), 1.0))
```

## Variables

Valores con nombre dentro del grafo: calcula algo una vez, ponle nombre y léelo en cualquier lugar sin un cable largo por el lienzo.

### Guardar valor

*Set value* · `set_var` · Variables · `g.set_var(...)`

Da nombre a un valor para que los nodos Leer valor lo lean en cualquier parte sin una conexión larga.

Da nombre a un valor. Cualquier **Leer valor** con el mismo nombre lo lee, así puedes reutilizarlo lejos sin un cable que cruce todo el lienzo.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `value` · valor | `T` | `0` |

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

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `name` | `text` | `value1` |

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

### Leer valor

*Get value* · `get_var` · Variables · `g.get_var(...)`

Lee un valor nombrado por un nodo Guardar valor.

Lee un valor al que un nodo **Guardar valor** puso nombre.

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

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `name` | `local` | `value1` |

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

## Utilidades

Nodos que mantienen ordenados los grafos grandes y te dejan ir más allá del catálogo.

### Desvío

*Reroute* · `reroute` · Utilidades · `g.reroute(...)`

Un punto para desviar una conexión alrededor de otros nodos.

Un punto que solo desvía un cable alrededor de otros nodos: no cambia nada.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `in` · entrada | `T` | `0` |

| Salida | Tipo |
| --- | --- |
| `out` · salida | `T` |

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

### Expresión

*Expression* · `expression` · Utilidades · `g.expression(...)`

Tu propio WGSL: una expresión con a, b, c y d (y uv, px, size, time), o el cuerpo de una función con return. Los tipos de a a d siguen lo que esté conectado.

Tu propia línea de WGSL cuando ningún nodo hace lo que necesitas: una expresión de `a`, `b`, `c` y `d` (más `uv`, `px`, `size` y `time`), o el cuerpo de una función con `return`. Elige el `type` del resultado.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `a` | `any` | `0` |
| `b` | `any` | `0` |
| `c` | `any` | `0` |
| `d` | `any` | `0` |

| Salida | Tipo |
| --- | --- |
| `result` · resultado | `float` |

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `code` | `code` | `a + b` |
| `type` | `float`, `vec2`, `vec3`, `vec4`, `int`, `bool` | `float` |

Los tipos de `a` a `d` siguen lo que se les conecta (`any`); `type` fija el del resultado.

```python title="Ejemplo"
e = g.expression(g.uv()["x"], 8.0, code="abs(sin(a * b + time))", type="float")
g.output(g.rgba(e, 1.0))
```

### Función shader

*Shader function* · `subgraph` · Utilidades · `g.subgraph(...)`

Otro .pzshad usado como función: sus variables mutables son entradas y su salida es el color. Conecta uv para moverlo, repetirlo o deformarlo.

Usa otro `.pzshad` como función: sus variables mutables se vuelven entradas y su color la salida. Pasa un `uv` para mover, repetir o deformar el shader entero.

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

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

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `path` | `file` | — |

Además de `uv`, cada variable mutable del otro shader se vuelve una entrada.

Un Shader function necesita otro archivo `.pzshad`: `g.subgraph(path="plasma.pzshad", uv=...)`. En el diseñador, haz doble clic en el nodo para abrir ese archivo.

### Comentario

*Comment* · `comment` · Utilidades · `g.comment(...)`

Una nota en el grafo.

Una nota en el lienzo para explicar una parte del grafo. No afecta al shader.

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `text` | `text` | `Note` |

```python title="Ejemplo"
g.comment(text="Sky: gradient from top to bottom")
g.output(g.gradient(g.uv()["y"]))
```

## Salida

Todo shader tiene un nodo Salida: lo que llega a él es el color del píxel.

### Salida

*Output* · `output` · Salida · `g.output(...)`

El color de cada píxel. Alpha, si se conecta, reemplaza el alfa de color.

El final del grafo: el color que recibe es el color del píxel. Si `alpha` está conectado, reemplaza el alfa del color. En Python, `g.output(color)` lo añade o lo encuentra.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `color` | `vec4` | `(0, 0, 0, 1)` |
| `alpha` | `float` | — (sin usar hasta que se conecta) |

```python title="Ejemplo"
g.output([1.0, 0.4, 0.1, 1.0], alpha=g.radial_gradient(radius=0.5))
```

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