Skip to content
AnimationStudiosBLUX Physics SuiteGet BLUX
Discord

Impact overview

Impact simulates breaking and colliding rigid pieces: demolition, fracture and joints. By default it runs the pieces on Jolt Physics on the CPU, with BLUX’s own XPBD solver on the GPU for loose particles (see Engines). A mesh is cut into Voronoi shards, the shards are glued together with breakable bonds, and the solver breaks the bonds when loads pass a threshold.

The quickest start is Quick Demolition on a mesh, or an Impact template: Mortar Wall, Staged Demolition, Reinforced Pillar, Demolition Dust or Wrecking Chain.

  1. Fracture a mesh into shards with Fracture Selected Mesh. The shards go into a BLUX fracture collection, and a graph is set up for them.
  2. Add colliders and forces (ground plane, a projectile, gravity, an explosion).
  3. Decide how the structure holds together with bonds and rebar, and when parts wake up with groups, activation and triggers.
  4. Press Run, or Bake. You can bake the result to object keyframes (location and rotation) from the Solver panel’s Keyframes section.
Node Purpose
Impact Source (RBD Source) The fractured collection or object to simulate.
Impact Material What the pieces are made of: density, friction, bounce and glue strength. Wire it into the Impact Source’s Material input.
Forces Gravity, wind, drag, explosion, vortex, turbulence, attractor, curve.
Colliders Object Collider and Ground Plane. Kill Volumes are not part of the rigid solver.
Impact Constraint The glue bonds between pieces.
Impact Rebar Reinforcement that holds broken concrete together.
Impact Debris Chips and dust spawned when pieces break.
Impact Joint A hinge, slider, ball, spring or weld between pieces.
Impact Chain Joints Joins a collection of pieces into a chain, one joint per link.
Impact Group, Group Combine Select sets of pieces.
Impact Activation When groups wake up.
Impact Trigger Volumes and frame ranges that act on pieces.
Impact Solver Runs the simulation.
Setting Default What it does
Engine Auto What simulates the pieces: Auto, Jolt (CPU) or Impact (GPU). See Engines below.
Piece Points off Also sends and draws the collision spheres of every piece. Off, the piece objects show the motion and frames carry only poses and debris, which is faster.
Auto-Fit Domain on Computes the domain from the fractured asset’s bounding box plus a clearance margin.
Debris Clearance Margin 2.5 Multiplier around the asset that lets debris fly freely.
Substeps 10 More is more accurate for stacks and glued chunks, and slower.
Solver Iterations 4 Constraint passes per substep. More makes glue and contacts stiffer.
Bond Stiffness 1,000,000 Stiffness of the glue bonds.
Breaking Force 45 The threshold that snaps glue bonds.
Chunk Friction 0.6 Friction for chunk-ground and chunk-chunk contact.
Chunk Restitution 0.25 Bounciness.
Restitution Threshold 0.2 m/s Impacts slower than this do not bounce, so resting stacks settle without jitter.
CCD Speed 3 m/s Chunks faster than this are swept with continuous collision detection to stop tunnelling. 0 keeps it always on.
Sound Speed 0 Speed of the stress wave through glued chunks. Bonds crack only once the wave reaches them. Concrete is about 3,400 m/s, steel about 5,100. 0 is instant.
Linear / Angular Sleep Speed 0.04, 0.06 Below these, chunks begin to sleep.
Sleep Delay Frames 12 Frames at rest before freezing.
Dynamic Re-Fracture on Shards re-fracture in flight on high-energy impacts.
Setting Default What it does
Shatter Speed 7.5 m/s Minimum approach speed that triggers shattering.
Shatter Energy 25 J/kg Minimum impact energy per kilogram (0.5v²; 25 is about 7 m/s). Each doubling above it adds a piece.
Max Fracture Depth 2 How many times a shard can be re-fractured.
Max Pieces 4 Most pieces one impact breaks a shard into.
Eject Speed 1 m/s Speed the new pieces fly apart at.
Min Shard Volume 0.0005 m³ Shards below this do not fracture further.

On the Jolt engine, a hit at the Shatter Speed and Energy splits the struck piece into 2 to Max Pieces Voronoi pieces, small near the hit, and BLUX cuts the piece’s mesh along the same cells. The pieces are exact convex cells of the piece, keep its motion plus the Eject Speed, throw chips along the cracks, and keep the glue, rebar and cracks where those attach, so a piece still glued to the wall stays in it. Spheres, jointed pieces (chains) and pinned pieces do not shatter.

Static Friction gives shards a separate friction that holds a resting contact. Friction Combine and Bounce Combine decide how the friction and restitution of two different surfaces combine.

Every setting is in the Solver reference.

The Impact Solver’s Engine setting chooses what simulates the pieces. The nodes, the templates and the result stay the same.

Engine What it is
Auto (default) Runs Jolt unless the scene needs the Impact engine: loose particles instead of Impact Sources, or a Jolt library that does not run on the computer. The node shows which engine ran and why.
Jolt (CPU) Jolt Physics 5.6 on the CPU. Pieces collide with their true shapes and weigh their mesh volume times their density. The fastest for chains, walls and piles.
Impact (GPU) BLUX’s own particle-based solver on the GPU. The only engine for loose particles.

Files that chose Impact or Jolt keep their choice. Files that never set the engine use Auto. All five rigid templates run on Jolt.

  • Pieces collide with convex hulls of their mesh vertices. A concave piece, such as a chain link, is split into convex parts. Spheres stay spheres.
  • Glued pieces move as one rigid body until impacts break the glue. A wall stands perfectly still until it is hit, and the hit cracks the glue around it. A step that breaks glue is run again with the pieces apart, so the struck piece takes the impact.
  • Joints (every Impact Joint type and Chain Joints), rebar, triggers, activation pins, surface materials, explosions and moving colliders work as on the Impact engine.
  • Cracked glue, plastic and elastic glue, debris, dynamic re-fracture, force fields, wrangles, SDF colliders and the Blaze dust coupling also run on Jolt. Only loose particles still need the Impact engine.
  • The engine is a small native library that ships with the add-on for Windows, Linux (x86_64) and macOS on Apple Silicon. It needs no Python package. Intel Macs use the Impact engine.

Every frame the solver sends one pose (location and rotation) per piece, and BLUX sets it on the piece’s object. The piece objects themselves move. The viewport point cloud shows only the debris (chips, dust and rubble).

Piece Points (off by default) also sends and draws the collision spheres of every piece, which is useful to check how a piece is sampled. It costs time on big scenes: on a 1,000-box rubble scene the frame packet is 1.3 ms with Piece Points off and 33 ms with it on. A scene of loose particles always sends its points, since there is nothing else to show.

Wire an Impact Material node (Add > Materials) into an Impact Source’s Material input to set what its pieces are made of. A preset writes typical values. Changing a value turns the preset to Custom.

Preset Density (kg/m³) Friction / static Bounce Glue Strength
Concrete 2400 0.6 / 0.75 0.15 1.0
Brick 1900 0.65 / 0.8 0.1 0.7
Wood 600 0.45 / 0.6 0.3 1.5
Glass 2500 0.4 / 0.5 0.3 0.4
Steel 7850 0.55 / 0.7 0.35 3.0
Rubber 1100 1.0 / 1.1 0.8 2.0
  • Density replaces the source’s Density. Mass is the piece’s mesh volume times the density. A shard’s blux_density custom property still overrides it per shard.
  • Friction, Static Friction and Bounce replace the source’s Surface Material. They are combined with the other surface at every contact (Friction Combine and Bounce Combine on the solver). A shard’s blux_friction, blux_static_friction and blux_bounce custom properties still override them per shard.
  • Glue Strength multiplies the strength of every bond between the source’s pieces. The base strength comes from the glue settings (Impact Constraint > Breaking Force) and the fracture dialog. Below 1 the pieces come apart sooner. Above 1 they hold longer.

The densities are handbook values. The friction and bounce figures are typical dry-contact values against a hard floor, rounded: they set a look, not a measurement.

The Impact Solver has two quality controls:

  • Substeps split each frame into that many solver steps. A step is the frame time divided by Substeps (1/24 s and 20 substeps make 2.1 ms steps). Shorter steps catch contacts earlier and make fast motion more exact. The cost grows roughly in proportion.
  • Solver Iterations are the passes the solver makes over the contacts, the glue and the joints inside one step. More passes make stacks and chains stiffer within the step, at a smaller cost than more substeps.

On the Jolt engine a step runs max(10, 2 × Iterations) velocity passes and max(2, Iterations / 2) position passes, so 1 to 5 iterations behave alike for contacts. Joints get 6 velocity passes per iteration. A heavy ball on light chain links needs them: on the Wrecking Chain, more iterations halved the stretch (1.2% to 0.6%) for 3% more frame time.

Start from a template’s values (14 to 20 substeps, 6 to 8 iterations), then change one control at a time:

What you see Change
A chain stretches, a joint wobbles, a stack sinks into itself Raise Solver Iterations.
Fast or thin pieces pass through each other or through a collider Raise Substeps, and check Collisions > CCD Speed.
Pieces jitter at rest Raise Substeps a little, and check that pieces do not start overlapping.
A wall shatters at once or holds too long Change the glue’s Breaking Force or the material’s Glue Strength.
It is too slow and looks fine Lower Substeps first, while the motion stays the same. Then Iterations.

Measured on a Ryzen 7 3700X with Blender 5.2, on the Jolt engine with Piece Points off:

Template Solver, ms a frame Live run, ms a frame Live / solver
Mortar Wall (86 pieces) 31.6 33.3 1.05
Wrecking Chain (87 pieces) 18.4 20.2 1.10

In a live run the solver steps on its own thread while Blender moves the pieces (about 2 ms a frame for 87 objects). With Piece Points on, the Wrecking Chain’s ratio is 1.28. A bake is slower than a live run, because it writes each frame to disk and keys every piece one after the other: 1.4 and 1.7 times the solver time on these two templates.

For comparison, the Jolt engine solved a 17-link chain in 3.1 ms a frame where the GPU Impact engine (GTX 1060) took 188 ms. It solved 1,000 loose boxes in 23 ms, where Blender’s own rigid body world takes 64 ms.

Rigid-body bonding and fracture use SciPy. See Dependencies.