select, mix, step y smoothstep: escribir sin ramas

Estas cuatro funciones son las que convierten condiciones en aritmética, y son el vocabulario con el que se escriben los shaders que no ramifican. Tres son idénticas a las de GLSL. La cuarta, select, existe solo en WGSL, tiene los argumentos en un orden que nadie acierta a la primera, y produce un bug perfectamente silencioso cuando te equivocas: el shader compila, dibuja, y todo sale invertido.

select y su orden de argumentos

select(valorSiFalso, valorSiCierto, condicion)

El valor falso va primero. Es el orden inverso al del operador ternario de casi todos los lenguajes, donde la condición abre la expresión, y es la causa de una cantidad notable de shaders con el color de fondo y el de frente intercambiados.

// Ternario mental: cond ? a : b
// En WGSL:
let color = select(b, a, cond);

La forma de recordarlo que funciona es pensar en el orden numérico: el caso false es el 0 y va primero, el caso true es el 1 y va segundo, y la condición cierra.

select tiene además una forma por componentes que no tiene equivalente en un ternario: si la condición es un vector de booleanos, la selección se hace componente a componente.

let a = vec3f(1.0, 2.0, 3.0);
let b = vec3f(9.0, 9.0, 9.0);
let m = vec3<bool>(true, false, true);
let r = select(a, b, m);        // vec3f(9.0, 2.0, 9.0)

Fíjate en que aquí a es el valor falso: r.y toma a.y porque m.y es false.

Y una propiedad importante: select evalúa las dos expresiones. No es un condicional perezoso. Si uno de los dos lados es caro o tiene un efecto colateral, select no te ahorra nada; para eso hace falta un if.

mix, clamp y saturate

mix(e1, e2, e3)      // e1 * (1 - e3) + e2 * e3
clamp(e, bajo, alto) // min(max(e, bajo), alto)
saturate(e)          // clamp(e, 0.0, 1.0)

mix acepta el tercer argumento escalar o vectorial. Con escalar, interpola los dos vectores enteros con el mismo factor; con vector, cada componente con el suyo, lo cual sirve para combinar dos texturas con una máscara de tres canales en una sola operación.

El factor no está acotado: mix(a, b, 2.0) extrapola más allá de b, y mix(a, b, -1.0) extrapola en la dirección contraria. Es útil deliberadamente —así se hacen los ajustes de saturación y de contraste—, y es un bug cuando el factor viene de una división que se sale de rango sin que lo esperases. Si necesitas acotar, saturate el factor primero.

clamp con bajo mayor que alto no está definido de forma útil: no supongas que devuelve algo razonable. Es una situación que aparece cuando los dos límites vienen de datos, y merece una comprobación en el lado de la CPU.

step y smoothstep

step(borde, x)              // 0.0 si x < borde, 1.0 si no
smoothstep(bajo, alto, x)   // 0 por debajo, 1 por encima, curva suave en medio

step es un escalón duro y su uso principal es convertir una comparación en un número que multiplica. smoothstep es su versión suavizada, y su interior es el polinomio de Hermite t * t * (3 - 2t) sobre el valor normalizado entre los dos bordes, con derivada nula en los dos extremos.

Esa derivada nula es lo que la hace útil para transiciones: una interpolación con smoothstep no tiene esquinas visibles donde empieza y donde acaba, al contrario que una interpolación lineal.

// Atenuacion suave de una luz con radio.
let d = distance(p, luz.posicion);
let atenuacion = 1.0 - smoothstep(luz.radio * 0.7, luz.radio, d);

Si bajo y alto están al revés o son iguales, el resultado no es fiable; y si necesitas el escalón inverso, la forma idiomática es restar de uno, como arriba, y no intercambiar los bordes.

Escribir sin ramas

Con estas cuatro funciones se construye cualquier función por tramos. El patrón general es acumular contribuciones multiplicadas por sus máscaras:

// Una rampa de tres colores segun la altura, sin un solo if.
fn colorPorAltura(h : f32) -> vec3f {
  let arena  = vec3f(0.76, 0.70, 0.50);
  let hierba = vec3f(0.25, 0.45, 0.20);
  let roca   = vec3f(0.45, 0.45, 0.47);

  var c = arena;
  c = mix(c, hierba, smoothstep(0.15, 0.25, h));
  c = mix(c, roca,   smoothstep(0.55, 0.70, h));
  return c;
}

Cada mix sucesivo sobrescribe progresivamente el anterior, y las transiciones se solapan de forma continua. Escrito con if daría bordes duros y tres ramas.