Tornado de partículas en Houdini

• Versión: Houdini 22.0 Apprentice. En Indie o FX es igual; en versiones anteriores algunos nodos pueden verse distintos.
• Unidades: 1 unidad = 1 metro. El eje Y apunta hacia arriba.
• Animación: 24 fps, frames 1 a 240 (el reloj abajo a la derecha, Global Animation Options).
• Crear nodos: dentro de una red pulsa Tab y escribe el nombre (p. ej. grid). Doble clic o I para entrar a un nodo; U para salir.
• Renombra cada nodo como dice la guía (doble clic en el nombre). Algunas rutas (SOP Path) usan esos nombres.
• Display flag (la bandera azul a la derecha del nodo): indica qué nodo se ve en el viewport.

Dos redes: la de geometría (SOPs), con el piso, el emisor y el eje; y la de simulación (DOPs), donde se mueven las partículas.

emisor y atributos_vortex no tienen cables hacia la simulación: los nodos de adentro los leen por su ruta (SOP Path).

1. En /obj, Tab → Geometry. Llámalo tornado_vortex.
2. Entra con doble clic. Todo lo que sigue va adentro, salvo la cámara, las luces y el render.

Este es el piso que se ve. El que choca con las partículas es el Ground Plane del paso 6, y ese no aparece en el render.

Un círculo acostado en el piso. Las partículas nacen sobre su superficie. No se conecta a nada.

Es el paso clave. Una línea vertical de 45 m cuyos puntos le dicen al Vortex Force qué tan ancho es el embudo a cada altura, qué tan rápido gira y cuánto empuja hacia arriba. Además se mueve con ruido para que la columna serpentee.

1. Tab → Line, nombre eje_tornado: Length 45, Points 16. La dirección (0, 1, 0) es la de por defecto.

2. Debajo, Tab → Attribute Wrangle, nombre atributos_vortex (Run Over: Points). Pega el código:

// h: 0 en el piso, 1 arriba del tornado
float h = @P.y / 45.0;
// silueta del embudo: angosto abajo, ancho arriba
f@orbitrad  = chf("radio_base") + (chf("radio_tope") - chf("radio_base")) * pow(h, chf("curvatura"));
f@orbitvel  = chf("velocidad_orbita");   // m/s tangencial
f@orbitlift = chf("lift");               // fuerza hacia arriba (la punta la controla punta_dispersa)
f@orbitmaxd = f@orbitrad * chf("alcance"); // hasta donde llega la fuerza
// la columna serpentea: el ruido crece con la altura (la base queda fija en el piso)
vector n = noise(set(h * chf("ondas"), @Time * chf("velocidad_onda"), 0.0)) - 0.5;
vector n2 = noise(set(h * chf("ondas") + 17.3, @Time * chf("velocidad_onda"), 5.1)) - 0.5;
@P.x += n.x * 2 * chf("serpenteo") * h;
@P.z += n2.x * 2 * chf("serpenteo") * h;

3. Pulsa Create spare parameters y escribe los valores:

Los nombres de los atributos tienen que ser exactamente esos: son los que el Vortex Force busca por defecto.

Tab → DOP Network, nombre sim_tornado. Entra en él: los pasos 6 y 7 son adentro.

Código de punta_dispersa (después pulsa Create spare parameters):

// Cada particula tiene su propia altura de "muerte" entre altura_min y altura_max,
// asi la punta queda irregular y no se apilan en una tapa.
float limite = fit01(rand(@id * 13.7), chf("altura_min"), chf("altura_max"));
float zona   = fit(@P.y, limite - chf("zona_fade"), limite, 0, 1);
// encogen al acercarse a su limite (se desvanecen en vez de cortarse)
f@pscale = 0.04 * (1 - zona);
// cerca del limite se abren hacia afuera, como el humo que sale por arriba
vector rad = set(@P.x, 0, @P.z);
v@force += normalize(rad) * chf("empuje_afuera") * zona;
if (@P.y > limite) i@dead = 1;

Aquí es donde es más fácil equivocarse. Sigue el orden y compara con la captura de la red DOP del mapa.

1. particulas → 1ª entrada (Object) de pop_solver.
2. emitir_base → ruido_turbulencia → punta_dispersa → 3ª entrada (Sources) de pop_solver. La 2ª (Pre-Solve) queda vacía.
3. ground_plane → 1ª entrada (izquierda) de merge1; pop_solver → 2ª entrada.
4. merge1 → 1ª entrada de fuerza_vortex.
5. curva_eje → 2ª entrada de fuerza_vortex.
6. fuerza_vortex → gravity1 → output. El display flag va en output.

particulas ─────────────────────────────────────→ pop_solver  [1: Object]
emitir_base → ruido_turbulencia → punta_dispersa → pop_solver  [3: Sources]

ground_plane ─┐  (izquierda)
pop_solver ───┴→ merge1 → fuerza_vortex → gravity1 → output
                              ↑ [2]
                          curva_eje

Sal de sim_tornado con U y crea:

// color por altura: polvo oscuro abajo, gris claro arriba
float h = fit(@P.y, 0, 30, 0, 1);
v@Cd = lerp({0.32,0.26,0.20}, {0.75,0.75,0.78}, h);
// pscale viene de la simulacion (punta_dispersa); se agranda para Karma
f@pscale *= chf("escala_render");

escala_render en 3 hace las partículas más gruesas para que se vean en Karma. Para OpenGL puedes dejarlo en 1.

1. En /out, Tab → Karma, nombre karma_tornado.
2. Valid Frame Range Render Frame Range, frames 1 a 168. Camera /obj/cam_tornado, Resolution 1280 × 720.
3. Output Picture: una carpeta tuya, p. ej. $HIP/render/tornado_karma.$F4.jpg.
4. Rendering Engine: CPU si tu equipo no tiene GPU NVIDIA; XPU si tienes una RTX (mucho más rápido).
5. Render to Disk.

Para armar el video con los frames (opcional, con ffmpeg):

ffmpeg -framerate 24 -i tornado_karma.%04d.jpg -c:v libx264 -crf 23 -pix_fmt yuv420p tornado.mp4

En el frame 192 deberías tener, más o menos:

• ~34 000 partículas vivas (Geometry Spreadsheet de importar_particulas).
• Altura máxima de ~50 m, sin un anillo o "tapa" arriba: la cantidad baja poco a poco con la altura.
• Muchas partículas en la base (el polvo) y casi ninguna a más de 30 m del centro.
• La columna se dobla y se mueve; la base se queda en su lugar.

No hace falta para replicarlo, pero ayuda a modificarlo.