El control de flujo: loop, continuing y el switch sin fallthrough

El control de flujo de WGSL tiene una pieza que no existe en ningún lenguaje de propósito general: el bloque continuing, del que salen por azúcar sintáctico el for y el while. Y le faltan dos que sí existen en todos: el fallthrough del switch y el salto etiquetado. Las tres ausencias y la presencia responden al mismo requisito, que es que todo el control de flujo tiene que ser estructurado para poder traducirse a lo que entiende una GPU.

Condicionales

if acepta la condición con paréntesis o sin ellos, y encadena con else if. La condición tiene que ser un bool escalar: una comparación de vectores hay que reducirla con all o any.

if intensidad > 1.0 {
  color = color / intensidad;
} else if intensidad > 0.0 {
  color = color * intensidad;
} else {
  color = vec3f(0.0);
}

Las llaves son obligatorias siempre, incluso para una sola sentencia. Se acabaron los if de una línea sin llaves y la clase de bugs que producían.

loop y el bloque continuing

loop es la construcción primitiva, y es un bucle infinito del que se sale con break:

var i = 0u;
loop {
  if i >= n { break; }
  suma = suma + datos[i];
  i = i + 1u;
}

Lo interesante viene con el bloque opcional continuing, que se ejecuta al final de cada iteración, tanto si la iteración terminó normalmente como si terminó con un continue:

var i = 0u;
loop {
  if datos[i] < 0.0 { continue; }    // salta al continuing, no al principio
  suma = suma + datos[i];

  continuing {
    i = i + 1u;                      // se ejecuta siempre
    break if i >= n;                 // condicion de salida al final: un do-while
  }
}

Dos reglas sobre el continuing: no puede contener un continue que se refiera a ese mismo bucle, y el único break que admite es un break if como última sentencia. Esa sentencia es la que convierte el bucle en un do-while, porque la condición se evalúa después del cuerpo.

Con eso en la mano, for y while se explican solos. Este bucle:

for (var i = 0u; i < n; i = i + 1u) {
  if datos[i] < 0.0 { continue; }
  suma = suma + datos[i];
}

es exactamente esto:

{
  var i = 0u;
  loop {
    if !(i < n) { break; }
    if datos[i] < 0.0 { continue; }
    suma = suma + datos[i];
    continuing { i = i + 1u; }
  }
}

Y de ahí sale la respuesta a la pregunta que todo el mundo se hace la primera vez: sí, un continue dentro de un for ejecuta el incremento. No es un salto al principio de la comprobación: es un salto al continuing, que contiene el incremento. Es el mismo comportamiento que en C, pero aquí se ve por qué.

Las tres declaraciones del for son opcionales: for (;;) { } es un bucle infinito legal, y for (; i < n;) { } es un while con otro nombre.

switch sin fallthrough

El selector tiene que ser de tipo entero, i32 o u32. Cada cláusula case puede tener varios valores separados por comas, y su cuerpo es un bloque con llaves. No hay fallthrough: cada cláusula termina donde termina su bloque, sin break explícito.

var color : vec3f;
switch (tipoMaterial) {
  case 0u: {
    color = vec3f(1.0, 0.0, 0.0);
  }
  case 1u, 2u: {          // dos valores, un cuerpo
    color = vec3f(0.0, 1.0, 0.0);
  }
  default: {
    color = vec3f(0.5);
  }
}

La cláusula default es obligatoria y solo puede haber una. No es una recomendación de estilo: sin ella el módulo no compila. La razón es que el compilador necesita que el switch sea total —que haya una rama para cualquier valor posible del selector— para poder generar control de flujo estructurado sin un camino sin definir.

Los valores de los case tienen que ser expresiones de tiempo de compilación y no se pueden repetir entre cláusulas.

Salir: return, discard y el break que no existe

return sale de la función, con valor si la función lo declara. En un punto de entrada, sale del shader.

discard solo existe en fragment shaders y anula la contribución de ese fragmento. No es un return: es una sentencia que puede aparecer en cualquier punto, y el lenguaje está definido de forma que la ejecución posterior no invalida las derivadas de las invocaciones vecinas.

Y lo que no existe: no hay break con etiqueta y no hay goto. Salir de dos bucles anidados de golpe exige un centinela:

var encontrado = false;
var resultado = 0u;

for (var y = 0u; y < alto; y = y + 1u) {
  for (var x = 0u; x < ancho; x = x + 1u) {
    if rejilla[y * ancho + x] == objetivo {
      resultado = y * ancho + x;
      encontrado = true;
      break;                 // sale solo del bucle interior
    }
  }
  if encontrado { break; }   // y este del exterior
}

La alternativa más limpia cuando el cuerpo lo permite es extraer los dos bucles a una función y usar return, que sí sale de todo de una vez.

Falta la restricción que convierte esto en un problema de verdad: el control de flujo uniforme.