↑ Vocaro Guide to MPM

Neighboring & Related Methods

The MPM-relative comparisons — when to reach for which, the trade-off quadrant chart, and the side-by-side table — live in Theory §8. This document defines each method on its own terms: what it is, how it works, what it is good and bad at, and where it ships. Read it when a comparison elsewhere references a method you don’t already know.

These are the simulation methods the Material Point Method is most often weighed against, plus the geometry/texture representations that frequently sit alongside a physics solver (or stand in for one entirely). MPM’s own direct ancestors — PIC / FLIP / APIC — are deliberately not here: APIC is a component inside modern MPM, not an alternative to it, so the particle-in-cell lineage is covered in Prerequisites §6 and Theory §5. (See §3 below.)

1. Alternative continuum-simulation methods

The five methods below solve the same broad problem MPM solves — simulating deformable solids and/or flowing matter — by other means. Each makes a different trade between tracking material identity/history and handling large deformation (the two axes of the Theory §8 chart).

1.1 FEM — the Finite Element Method

What it is. The dominant method for deformable solids in engineering and a workhorse in film. The material domain is discretized into a mesh of elements (tetrahedra, hexahedra); the governing equations are solved in their weak form on that mesh, with quantities interpolated inside each element by polynomial basis functions.

How it works. Assemble per-element stiffness/force contributions into a global system from the weak form of momentum balance, then integrate in time — usually implicitly (backward Euler + Newton), which permits large timesteps. The mesh is Lagrangian: nodes are glued to the material and move with it.

Strengths. Highest accuracy for moderate-deformation elasticity; excellent conservation; no transfer dissipation; decades of mature theory, solvers, and tooling.

Weaknesses. The mesh tangles under large deformation, and fracture, self-collision, topology change, and multi-material coupling each need bolt-on machinery (remeshing, contact solvers, cutting algorithms). This is precisely the pain MPM trades away.

Where it ships. The default in mechanical/civil/structural engineering (FEA); in graphics, intact elastic solids — muscle, flesh, soft tissue. The Sifakis & Barbič SIGGRAPH course is the standard graphics-oriented introduction.

1.2 SPH — Smoothed Particle Hydrodynamics

What it is. A pure-Lagrangian, meshless particle method. Every field quantity (density, pressure, forces) at a particle is a kernel-weighted sum over its neighboring particles — no grid, no mesh.

How it works. Each step: find each particle’s neighbors within the smoothing radius, estimate density from the weighted neighbor count, derive pressure from density via an equation of state, and sum pressure/viscosity forces from the neighbors. The per-step neighbor search (usually via a spatial hash or grid) is the characteristic cost. WCSPH (weakly-compressible SPH) uses a stiff Tait equation of state so the fluid is nearly incompressible without a global pressure solve — the same weakly-compressible idea an MPM fluid uses (see Implementation).

Strengths. Conceptually simple; topology change is free (no mesh); natural for splashing free-surface fluids and large numbers of independent particles.

Weaknesses. The neighbor search is expensive and irregular; tensile instability (particles spuriously clump under tension) plagues solid/elastic use; free-surface and boundary handling need care; stress and contact are generally less well-behaved than a grid-based field gives. And, decisively for anyone hoping to reuse a fluid solver for granular material, there is no rest state — see below.

Why SPH cannot stand in for a granular material (first-hand, unpublished). A complete SPH sand implementation was built and abandoned, and the failure is structural rather than a tuning miss. SPH resists compression by recomputing inter-particle pressure every step, and that pressure never reaches equilibrium — it micro-oscillates perpetually, so a pile vibrates forever, and two-way coupling transmits that jitter into anything resting on it. There is no Coulomb static-friction term, no rest state, and no particle sleeping — precisely the list that defines a granular material. A heap at rest is held by static friction at its contacts: a discontinuous, history-dependent force SPH does not represent. So the lowest-energy configuration available to it is a flowing equilibrium with residual pressure oscillation, not a static pile.

Every damping lever reduces the jitter monotonically, asymptotes above zero, and hits a hard ceiling before the pile is still. Measured as the fraction of pixels changing across 30 ticks of idle: the solver’s default viscosity left 6.4 % moving, 4× default left 3.4 %, and 16× diverged and hard-crashed. Powder-style repulsion made it worse. A static-pressure term did buy a real angle of repose — broad shallow mounds instead of water’s flat level — but not stillness. Giving the solver the sleep state it lacks, by flagging settled particles immovable, works on its own terms and then fails at the coupling.

This is the negative result that makes plasticity, not damping, the answer: a granular MPM material yields through a Drucker-Prager return map, which is the Coulomb condition SPH is missing.

Where it ships. Originated in astrophysics (Gingold & Monaghan and Lucy, both 1977); widely used for interactive CG fluids since Müller et al. (2003), and in many games for water and splashes.

1.3 PBD — Position-Based Dynamics

What it is. A real-time simulation paradigm that works directly on positions by satisfying geometric constraints, rather than integrating forces. Ubiquitous in game engines for cloth, ropes, soft bodies, rigid stacks, and even fluids.

How it works. Predict each particle’s next position from its velocity, then iteratively project a set of constraints (distance, volume, collision, …) onto the positions with a Gauss–Seidel sweep, then back out the corrected velocity from the position change. XPBD (extended PBD) adds compliance so a material’s stiffness is independent of the iteration count and timestep, fixing PBD’s biggest physical wart.

Strengths. Fast, unconditionally stable, trivially controllable, and easy to author a huge variety of effects in one unified solver — which is why it dominates real-time games.

Weaknesses. Not physically grounded in the classic form: stiffness is iteration- and timestep-dependent, and it approximates behavior rather than solving the governing continuum equations. Material parameters don’t map cleanly to real measured quantities.

Where it ships. Everywhere in real-time: cloth and soft-body systems in most engines, position-based fluids, granular piles. Müller et al. (2007) introduced it; Macklin et al. extended it (Unified Particle Physics, XPBD). Notably, EA SEED’s PB-MPM borrows PBD’s compliant-constraint stability to make MPM real-time-stable — the two paradigms meet there (Theory §5, Implementation).

1.4 Eulerian grid fluids

What it is. The classic fixed-grid approach to fluid simulation: velocity, pressure, and density live at grid nodes/faces, and the fluid is evolved by moving (advecting) those field quantities through the stationary grid. Nothing is tracked as a persistent particle.

How it works. Split each step into advection (transport quantities along the velocity field — Stam’s Stable Fluids uses unconditionally-stable semi-Lagrangian advection), external forces (gravity, buoyancy), and a pressure projection that enforces incompressibility by solving a Poisson system on the grid. Free surfaces/interfaces are tracked with extra machinery (level sets, or marker/FLIP particles).

Strengths. Smooth, stable large-scale fluids; no particle-count ceiling; very mature (the backbone of film smoke/fire/water). The grid makes spatial derivatives and the pressure solve clean.

Weaknesses. Numerical diffusion smears small-scale features and material identity smears across the grid — there is no Lagrangian history, so distinct materials and sharp interfaces are hard to preserve. This material-smearing is exactly the Eulerian weakness MPM’s particles fix.

Where it ships. Smoke, fire, and large bodies of water in visual effects. Bridson’s Fluid Simulation for Computer Graphics is the standard reference; Stam’s Stable Fluids (1999) is the seminal real-time-friendly formulation. (The grid-fluid world’s own particle-grid hybrid — FLIP fluids — connects back to the Prerequisites §6 PIC/FLIP lineage MPM also descends from.)

1.5 Height-field / shallow-water fluids

What it is. The 2.5D answer to water: rather than simulate a 3D volume, represent the liquid as a single height value per column over a 2D grid — a height field — and evolve it with the Shallow Water Equations (SWE), the depth-averaged simplification of Navier–Stokes valid when water is much wider than it is deep. This is the technique behind essentially all real-time river, lake, and shoreline water in games.

How it works. State is a depth hh and a horizontal velocity 𝒗=(u,w)\mathbf{v} = (u, w) per column on a staggered grid (heights at cell centers, velocities at faces), over a terrain height HH; the water surface is η=H+h\eta = H + h:

DhDt=−h∇⋅𝒗(mass)\frac{Dh}{Dt} = -h\,\nabla\cdot\mathbf{v} \qquad \text{(mass)}

D𝒗Dt=−g∇η+𝒂ext(momentum)\frac{D\mathbf{v}}{Dt} = -g\,\nabla\eta + \mathbf{a}_\mathrm{ext} \qquad \text{(momentum)}

Each step advects velocity through itself, integrates height from the divergence of h𝒗h\mathbf{v} (upwind, which conserves mass exactly and is more stable than averaging), then accelerates velocity down the surface gradient. Explicit integration is the real-time norm: implicit SWE solvers are unconditionally stable but need either an iterative solve every frame or a pre-factorization that then freezes the boundary conditions.

The horizontal velocity field is the whole point, and the reason SWE is preferred over the simpler 2D wave equation for game water: the wave equation carries only a vertical velocity, so whirlpools, river flow, and the advection of foam and floating objects cannot be expressed at all. Pipe models (adjacent cells joined by virtual pipes, flow driven by height difference) are the other common cheap formulation and share that missing-vortices problem.

Two features separate a production height-field solver from a textbook one:

The particle layer — what patches the 2.5D limitation. A height field structurally cannot represent an overturning wave, a waterfall, or a splash: one height per column admits no overhang. The standard fix (Chentanez & Müller 2010) is to detect where the height field is about to fail and convert that water into particles, which carry the mass and momentum away and are reabsorbed on landing:

Particles come in three flavors — spray (small fast droplets), splash (the remainder), and foam (advected across the surface by the horizontal velocity field, which is what sells swirling flow) — and are deliberately non-interacting point masses that exchange only mass and momentum with the field. That is what keeps them cheap.

Sub-grid detail is faked, not simulated. Waves shorter than the grid spacing are added as an FFT-generated wave texture advected with the velocity field, faded out where the flow stretches it (measured from the Green strain of the advected texture coordinates) and periodically re-seeded with phase-shifted copies to hide the accumulated distortion.

Two-way rigid coupling is analytic rather than contact-based: buoyancy from the displaced-prism volume under each surface triangle, plus drag and lift from relative velocity; in the other direction, a solid sweeping through cells writes the height and velocity fields directly along its swept path.

Strengths. Very cheap — cost scales with surface area, not volume, so the grid is orders of magnitude smaller than an equivalent 3D one. The original CUDA implementation ran complete scenes in ~4–18 ms/frame on a GTX 480 at 128² to 900×135 grids with tens to hundreds of thousands of particles. Large water bodies, arbitrary terrain slopes, arbitrary depth, and interactive boats all come nearly free.

Weaknesses. The one-height-per-column restriction is fundamental: no caves, no water under an overhang, no genuinely 3D flow — the particle layer treats the symptoms, not the constraint. Explicit integration means stability is bought with clamps (on depth, on velocity magnitude, on the effective depth used for height integration) rather than guaranteed. Volume is not conserved outside the height-integration step — the solid coupling and the anti-overshoot filter both leak. And there is no material identity and no material history: a plain SWE height field is water and only water, and cannot change phase. (Height-field methods have been pushed to granular material — Su et al.’s real-time height-field sand/water mixtures, SIGGRAPH Asia 2023 — but each material is a bespoke extension, not a constitutive-model swap.)

Where it ships. This is the dominant real-time water technique. Chentanez & Müller’s SCA 2010 paper is the canonical reference; its 2015 successor adds two-way coupling to a full 3D Eulerian solver so the expensive method runs only where it is needed. In engines, Fluid Flux (Unreal, 2022–) is a commercial implementation of that exact 2010 algorithm — faithful enough that it has served as the fluid solver in a peer-reviewed river digital twin validated against a real-scale flow experiment. See Games §4.

Touchpoint with MPM. Height-field fluids are the incumbent MPM must justify itself against for water specifically, and on cost the comparison is unflattering: for a lake, a river, or a shoreline, SWE is far cheaper and looks excellent. MPM’s case is everything the height field structurally cannot do — material variety (snow, sand, mud and their mixtures in one solver), phase change and mixing, genuinely 3D flow, and material identity/history. Note also a convergent pattern: the height-field world’s own answer to expense is to demote liquid into the cheapest representation that still looks right and promote it back on demand — height field ↔︎ particles here, height field ↔︎ 3D Eulerian ↔︎ particles in the 2015 successor. The same demote-when-settled idea recurs in MPM performance work (regional time stepping, particle sleeping — References).

2. Geometry representations (rendering & collision)

Not simulation methods — ways to represent shape. They earn a place next to physics for two reasons: a single representation can serve both rendering and collision (§2.1), and in shipped games a shape representation is very often what stands in for a solver entirely (§2.3). When judging a claim that some game has “deformable snow” or “destructible terrain,” the technique in question is at least as likely to live in this section as in §1.

2.1 SDF — Signed Distance Field / Function

What it is. A function that returns, for any point in space, the distance to the nearest surface of an object — positive outside, negative inside, zero exactly on the surface. It may be a closed-form formula (a sphere is length(p)−r\mathrm{length}(p) - r) or sampled into a volume texture / grid (the “field”). The gradient of the SDF is the surface normal.

Why it shows up in physics-forward / stylized games:

Where it ships. Claybook is the landmark — a fully SDF-based, deformable world (rendered by ray tracing the distance field; Sebastian Aaltonen’s GDC 2018 talk is the reference) — along with many ray-marched indie and demoscene titles. Inigo Quilez’s distance-function articles are the canonical practical primer.

Touchpoint with MPM. SDFs commonly appear inside a grid-based solver as the collision-object representation: a grid-velocity boundary condition reads the distance and normal straight off the field, so static and animated colliders are cheap to impose. The CPIC extension (Theory §5) goes further, using colored distance fields to model cutting and two-sided/open boundaries. So in an MPM pipeline an SDF is typically the collision/coupling geometry, not a rival way to simulate the material.

2.2 Voronoi / convex decomposition — geometric pre-fracture

What it is. A Voronoi diagram partitions space around a set of seed points: every location joins the cell of its nearest seed, and the cells come out convex and tile the volume with no gaps. Drop seeds inside a solid, clip the cells to its boundary, and the shape is cut into a jigsaw of interlocking convex pieces. Two jobs lean on this:

Where it ships. Pre-score-then-shatter is the workhorse of game and film destruction (the “wall bursts into chunks” set-piece). It pairs with an impulse-based rigid-body solver: the geometry step decides the shape of the break, the rigid-body step runs the dynamics of the pieces.

Touchpoint with MPM — the two fracture paradigms. Voronoi is the geometric answer to fracture, opposite the continuum answer the grid solvers give:

The two can be combined — pre-score with Voronoi seams but let a deformable solver carry the pieces so they can still bend or break again — trading the rigid path’s speed for the continuum path’s richness.

2.3 Height-map displacement & parallax occlusion mapping — deformation as a texture

What it is. The cheapest possible “deformable ground”: leave the terrain geometry static, store the deformation in a 2D height/displacement texture, and let the renderer sell the depth. Nothing is simulated — the surface is a picture of a surface. This is what “deformable snow / sand / mud” almost always means in a shipped game.

How it works. Three layers stack:

  1. A deformation mask. Objects that should disturb the ground write into a render target — typically by rasterizing a handful of analytic primitives (spheres, capsules) parented to feet, wheels, or limbs, which is far cheaper than rendering the actual meshes. One indie snow implementation uses two spheres, one per leg, plus a larger one on the torso, chosen explicitly because primitives “eat up way fewer resources compared to textures.”
  2. A relaxation pass. A diffusion/blur step spreads and softens the mask so trenches slump instead of ending in hard walls, and normals are re-derived and smoothed from the result (the same operation as a mesh “smooth normals”). Optionally a scatter of particles decorates the disturbed edge.
  3. Parallax occlusion mapping (POM) for fine detail. Instead of tessellating geometry, the pixel shader marches the view ray through the height texture in a few steps, offsetting the UV until it hits the stored surface. Bumps then occlude one another and shift correctly with viewing angle — the surface reads as displaced without adding a triangle.

The result is close to free: the implementation above reports ~140 fps on a laptop RTX 3050 with a low triangle count and a small mask texture, because nearly all perceived detail comes from the parallax shader rather than from geometry.

Strengths. Extremely cheap, trivially art-directable, scales to a whole level, no stability concerns, runs on any hardware.

Weaknesses — and they are precisely the continuum behaviors. Because there is no material, there is no material behavior. Critique of well-executed examples converges on the same list, which doubles as a catalog of what displacement cannot do:

Where it ships. Nearly everywhere snow, sand, or mud deforms in a shipped game. It is the default because it is cheap and reliable; the failure modes above are usually managed by keeping deformation shallow and traversal fast.

Touchpoint with MPM. This is the rendering-side incumbent, in the same way SWE height fields (§1.5) are the simulation-side incumbent, and the two are worth keeping distinct — a claim about “deformable snow” in a shipped game is very often this, and not a solver at all. It also states MPM’s value proposition unusually precisely: every item on the weakness list — compaction, cohesion, conserved volume, bulk failure, depth-correct resistance — falls out of a continuum solver by construction, because each is a consequence of having a constitutive model and a mass-conserving transfer rather than a feature to be added. The converse holds just as firmly: where deformation stays shallow and decorative, a continuum solver does not pay for itself, and POM is the correct engineering answer.

3. Not here: PIC / FLIP / APIC

These read like “other methods” but they are MPM’s direct lineage, and APIC is a component of modern MPM (the affine transfer scheme), not an alternative to it. They are defined where they belong — as the particle-in-cell family MPM generalizes — in Prerequisites §6, with their role in the algorithm in Theory §5. The Theory §8 “vs. FLIP/PIC” note frames the relationship as ancestry, not rivalry.

Sources for this document

Every work behind this page — the FEM, SPH, PBD, Eulerian and height-field landmarks, the parallax/relief-mapping and SDF references, and the geometric-fracture papers — is listed with venue, year and DOI in References, under Adjacent methods, Surface reconstruction & rendering and Fracture & advanced material models. The MPM-side fracture work (CD-MPM, AnisoMPM) is there too.

Two things named above are tools rather than papers, and have no entry: approximate convex decomposition via V-HACD, and the production fracture implementations — Houdini’s Voronoi Fracture SOP, Blender’s Cell Fracture, NVIDIA Blast/PhysX, and Bullet.