Docs menu · Simulations

Documentation

Simulations

How simulations work

Solver nodes (marked SIM in the graph) are stateful: frame 10 depends on frame 9. Tessera handles that for you:

  • Every solver has a start_frame (default 1) and substeps (solver steps per frame).
  • When you go to a frame, the solver steps forward frame by frame from start_frame and caches every frame. Going back, or playing again, reads the cache.
  • Before start_frame the node outputs its start state.
  • Changing any parameter of the solver, or anything upstream, clears the cache and restarts the sim. Reset sim in the parameter panel clears it by hand.
  • Caches live in memory; restarting Tessera clears them.

Set the frame range and fps in the timeline, then press Space. The first play computes the frames (progress shows in the viewport); after that it plays from the cache. To look at one moment, jump straight to that frame (for example 48).

Raising substeps makes fast motion more stable and accurate but costs time linearly. Keep resolutions moderate while you iterate and raise them for the final result.

Destruction and rigid bodies

Break something, then simulate the pieces:

  1. Fracture a closed mesh: voronoi_fracture (count pieces, optionally clustered around an impact point), plane_fracture, boolean_fracture or shatter_glass. Each piece gets a primitive name.
  2. Optionally glue neighbouring pieces with glue_constraints (break threshold strength in m/s) so the object holds until hit.
  3. Optionally set per-piece properties with rbd_configure / rbd_activate.
  4. Simulate with rbd_solver: input 0 pieces, input 1 glue network, input 2 static colliders.

The defaults already give a good shot: gravity, a ground plane at y = 0 and a heavy ball fired at the pieces along +X (projectile auto). Turn on explosion for a blast, or use activation radius so only pieces near an impact start moving. Pieces fall asleep when they come to rest. Typical: 20-300 pieces, substeps 10-20. See the Stone column destruction example.

Shatter a sphere into 50 pieces and knock it over
{"ops": [
  {"op":"add","type":"sphere","name":"ball","params":{"type":"ico","radius":0.8,"center":[0,0.8,0]}},
  {"op":"add","type":"voronoi_fracture","name":"pieces","inputs":["ball"],"params":{"count":50}},
  {"op":"add","type":"rbd_solver","name":"sim","inputs":["pieces"],"display":true},
  {"op":"frame","frame":48}
]}

Cloth and soft bodies

  • cloth_solver: XPBD cloth. Input 0 is any polygon mesh with enough resolution (a grid with many rows and columns); input 1 optional colliders. Pin points with a point group (pin_group) or a pin_expression. Controls for stretch and bend stiffness, wind and turbulence, ground, a built-in collision sphere, friction and self-collision. cloth_configure prepares pins and per-point properties. See the Cloth drape example.
  • soft_body: squishy closed meshes (balloons, jelly, rubber toys) with surface constraints, a volume constraint (pressure) and optional shape matching that pulls back toward the rest shape.

Particles

particle_solver is a POP network in one node: it emits from input 0 every frame (birth_rate per second, life), then applies gravity, drag and wind, curl-noise turbulence, an optional attractor (input 2) and bounces off the ground and colliders (input 1). Output is points with v, age, pscale and a colour ramp over age. Add particle_trails for streaks or particles_to_spheres for geometry. See the Curl-noise particles example.

Pyro: smoke and fire

pyro_solver is an Eulerian smoke, fire and explosion solver on a voxel grid. Feed it any geometry and it rasterizes it with the preset’s emission, so sphere → pyro_solver already gives rising, billowing smoke. For more control put pyro_source in between.

  • preset: smoke, fire, explosion or candle.
  • Domain: auto (source bounds padded by pad_side, pad_up, pad_down) or explicit. Resolution: source_res voxels across the source, capped at max_res.
  • Look: buoyancy, cooling, dissipation, vorticity, turbulence; fire: burn_rate, heat, soot, flame_lifetime.
  • Output: volumes density, temperature and flame, rendered as real volumes in the viewport.

See the Smoke plume and Campfire examples.

FLIP water

flip_solver simulates liquid as particles on a grid. A closed mesh on input 0 is filled with particles; emission continuous refills it every frame for taps and waterfalls. The container is auto (a dam-break tank) or explicit; walls box or ground only. Particles turn white as foam above foam_speed. Mesh the result with fluid_surface.

The defaults (box → flip_solver) give a dam break that splashes and settles in about 4 seconds, with about 25k particles at 0.1-0.3 s per frame. Halving particle_sep gives 8× the particles. See the Water splash example.

Ocean

ocean is not a cached solver but a time-dependent node: a Tessendorf FFT deep-water ocean whose wave height follows wind_speed (10 m/s gives about 2 m waves), with choppiness for sharp crests and foam from folding crests. It tiles seamlessly every size metres. Press Play to animate. See the Ocean example.

Exporting a simulation

Export a frame range as a numbered sequence: export with frame_start / frame_end writes one file per frame (put $F4 in the file name for a 4-digit frame number). See File formats & export. GLB, OBJ, PLY and STL carry meshes (PLY also point clouds); the Tessera .tgeo.npz cache also keeps volumes and all attributes.

Tips

  • Preview at low resolution and few substeps, then raise for the final.
  • Use timeshift to freeze a sim at a frame, or stash to bake a result into the scene.
  • Heavy sims use a lot of memory per cached frame; shorten the frame range while iterating.
  • Units are metres, kilograms and seconds; gravity is -9.81 m/s² on most solvers.