Position-Based Dynamics · Projects

A C++ body simulator built on position-based dynamics (PBD), following Müller et al. Instead of accumulating spring forces and integrating them into velocities, PBD works directly on positions: it predicts where particles will move, then projects those positions onto a set of constraints. The scheme is stabler than mass-spring at large timesteps, generalizes to many constraint types, and costs less per step.

Each step first moves every particle by its external forces alone, producing a predicted position $p_{i}$ . The predictions ignore internal interactions and generally violate the constraints (a stretched edge, an overlapping pair), so the solver corrects them. Each constraint $C (p) = 0$ is enforced by a position correction along its gradient,

Δ p_{i} = - s w_{i} \nabla_{p_{i}} C, s = \frac{C ( p )}{\sum _{j} w _{j} ∥ \nabla _{p_{j}} C ∥ ^{2}},

where $w_{i} = 1/ m_{i}$ is the inverse mass, so heavier particles move less. The scaling $s$ lands the correction exactly on the constraint for a linearized $C$ , and weighting by inverse mass conserves linear and angular momentum.

A predicted particle sits off the constraint (the curve

C = 0

). The solver moves it along the constraint gradient onto the nearest point that satisfies

C

; the arrow is that projection.

Geometrically, $\nabla_{p_{i}} C$ points normal to the constraint surface, so the correction moves each particle along that normal; the factor $s$ sets how far, chosen so a single step reaches $C = 0$ when the constraint is locally linear and is re-solved when it is not.

Constraints are projected one after another in a Gauss-Seidel sweep, each seeing the corrections of the ones before it, and the whole set is swept a few times per step, with more iterations stiffening the material toward rigid. Once the projections settle, velocities are read back from how far each particle actually moved:

Algorithm:

\textsc{Step}(h)

— one position-based dynamics update

1
input: timestep $h$ , positions $\mathbf x_i$ , velocities $\mathbf v_i$ , constraints $\{C\}$ , solver iterations $n$
2
for each particle $i$ do
3
$\mathbf v_i \gets \mathbf v_i + h\,w_i\,\mathbf f_i^{\text{ext}}$
4
$\mathbf p_i \gets \mathbf x_i + h\,\mathbf v_i$
5
for $k \gets 1$ to $n$ do
6
for each constraint $C$ do
7
project $\mathbf p$ so that $C(\mathbf p) = 0$
8
for each particle $i$ do
9
$\mathbf v_i \gets (\mathbf p_i - \mathbf x_i) / h$
10
$\mathbf x_i \gets \mathbf p_i$

A hanging chain under position-based dynamics. Each frame predicts positions from gravity, then projects the pairwise distance constraints the selected number of times; links tint orange as they stretch past rest length. One iteration leaves the chain visibly elastic under a whip, twelve pull it taut — changing the count re-kicks the swing so the difference shows immediately.

Position-based chain

Because a correction is a position projection rather than a force, there is no stiff spring constant to overshoot and blow up the integrator. A force-based solver picks a stiffness $k$ and then must keep $Δ t ≲ m / k$ , so a rigid material demands a tiny timestep; PBD instead moves the particle straight onto the constraint, and stiffness becomes the number of solver iterations — a quantity that can only converge, never diverge. That is why PBD holds together at the large, fixed timestep a game loop runs on, and why the same solver handles distance, volume, and collision constraints without retuning: each is just another $C (p) = 0$ to project onto.

The same solver in 2-D: a cloth patch hung from a rail of pins across its whole top edge — distance constraints along warp and weft (drawn), plus compression-only diagonal floors across each quad — the weave shears and the sheet swings freely, while a fold that crushes a diagonal gets pushed back out — under gravity, an ambient breeze, and a gust on demand. Links tint orange as the weave stretches — with one iteration a gust billows the cloth into visible sag, with twelve it recovers a stiff drape.

Position-based cloth

References

Project repository
Reference notes: Linear Algebra

╌╌ END ╌╌