Cutting Simulation for Soft Objects in Newton

Executive Summary

Recommendation: build three tracks. Track A is an MPM cutting benchmark in Newton now. Track B is a VBD mesh cutting prototype using DiSECt-style virtual-node/cohesive interface mechanics. Track C is an X-FEM solver prototype for high-fidelity mesh-independent cuts. X-FEM is now concrete enough to explore, but it should be its own solver path rather than a small option inside SolverVBD.

What Newton Already Has

Newton has the right raw pieces for this exploration. ModelBuilder.add_soft_grid() and add_soft_mesh() create particles, surface triangles, bending edges, tet_indices, tet_poses, and tet_materials. SolverVBD consumes those arrays through local vertex-block solves for triangles, edges, springs, contacts, and tetrahedral Neo-Hookean elasticity. It also requires builder.color(), which matters because changing topology invalidates particle coloring and adjacency.

SolverImplicitMPM.register_custom_attributes() already registers per-particle material and state attributes including mpm:young_modulus, mpm:poisson_ratio, pressure and deviatoric yield parameters, hardening/softening, viscosity, particle_Jp, and particle_stress. That is unusually close to a cutting material model: we mainly need damage/toughness attributes, knife geometry/contact, and a separation rule that prevents cut material from numerically healing across the grid.

For X-FEM specifically, Newton's builder already has the custom-attribute machinery needed to attach per-tet cut metadata. The branch now adds solver-owned arrays for enriched displacement/velocity DOFs, cut state, and fixed-capacity shell cut-cell quadrature descriptors. The remaining high-fidelity piece is the mixed physical/enriched residual and its graph coloring or iterative solve. Current VBD tet kernels read exactly four particle positions per tet, so true volumetric X-FEM is not a one-line material scaling change.

Literature Map

The cutting literature splits into a few implementation families. They are not interchangeable: each makes a different bet about topology, force realism, and real-time cost.

Application Tracks

The broader capability should be framed by application, not by solver family. A robot knife cutting soft tissue or food is a tool-driven separation problem with measured blade forces. Tearing cloth or paper is a thin-shell crack propagation problem where bending, anisotropy, and adaptive refinement dominate. Fracturing a rigid object is often a stress- or impact-driven fragmentation problem where the main output is stable debris geometry, contact, and momentum transfer.

These tracks share a fracture-energy idea but differ in state representation. Soft cutting can use a cohesive process zone tied to blade work:

Thin-sheet tearing should instead resolve crack-tip energy on a surface mesh, usually with anisotropic toughness for paper grain or woven cloth:

Rigid fracture should expose both physical and authorable criteria. The physically meaningful test is stress-intensity or maximum principal stress, while real-time applications often combine this with precomputed fracture patterns:

Implementation recommendation: keep one shared fracture/cut material description, but expose three solver tracks. Track A remains soft cutting with MPM/VBD/X-FEM. Track B is thin-sheet tearing in the cloth solver with adaptive crack-local refinement. Track C is rigid fracture with stress-triggered fragment generation and rigid-body debris. Trying to force all three through one "cutting solver" would hide the real differences in geometry, forces, and validation.

Implemented Newton Baselines

I added an experimental Newton branch, eric-heiden/cutting-soft-objects, with three concrete examples under newton/examples/cutting/: MPM, VBD, and the new Track C X-FEM solver. They share a rigid blade mesh with a sampled edge spline, cohesive process-zone damage law, force logger, and cut-surface rendering that follows the simulated particle motion without deleting cells or shrinking the object volume. For cloth X-FEM, the report cases now start from ordinary Newton cloth grids with no duplicate seam particles and no cohesive seam springs. SolverXFEMCut owns the shell enrichment displacement/velocity fields, cut-side labels, triangle cut state, and fixed side-aware quadrature records for cut triangles, while Newton VBD continues to integrate the triangle membrane and bending material. The shell renderer evaluates the opened sides from that enrichment field, clips cut triangles in rest space, locally refines active shell triangles, filters degenerate slivers, and updates the OpenGL index buffer every frame.

MPM force profile

VBD force profile

Adaptive remesh complexity

Track C X-FEM solver scenarios

The new SolverXFEMCut is implemented as a proper Newton solver in newton/_src/solvers/xfem_cut. It owns cut-side state, per-particle shifted-Heaviside enrichment displacement/velocity arrays, per-tet cut state/damage/weight arrays, shell cut-cell quadrature descriptors, material softening, knife normal/friction force accumulation, table/glue projection, and direct tangent-velocity drag for sawing cases. For cloth, the current report path no longer uses virtual-node seam springs: the X-FEM kernels classify the rest-space cut, update enrichment, mark edge/triangle cut state, and bound the knife impulse while Newton VBD integrates the triangle membrane/bending material. For spline cuts, the visible rigid blade yaws with the local path tangent while the solver classifies the cut against the fixed rest-space spline, so the rendered topology and force model no longer drift apart. The next step is the full mixed physical/enriched residual for both volumetric and shell X-FEM.

Cuboid force profile

Vegetable force profile

Paper force profile

Hanging cloth force profile

Curved cloth force profile

Bread force profile

The shared knife update uses a compact process-zone model around a rigid blade-edge spline. Let \(\Gamma_k(t)\) be the world-space cutting edge of the knife mesh, sampled as a polyline, and let \(h_y\) be the half-thickness of the blade process zone. For particle or vertex \(i\), the edge distance and active weight are

This same closest-edge query is used by the NumPy reference update, the MPM/VBD Warp kernels, and SolverXFEMCut.set_knife_state(..., edge_points=...). The report videos render the same blade mesh, so the visible knife corresponds to the force geometry.

Damage grows monotonically and the estimated knife force combines yield-like contact resistance with a fracture-energy term:

For VBD, cut tetrahedra are softened from the particle damage field as a first mesh-based coupling:

# Shared pattern used by the examples.
launch_mpm_knife_cut(state_0, damage, colors, accum, knife, material, dt, particle_volume, time, device)
solver_mpm.step(state_0, state_1, control=None, contacts=None, dt=dt)

state_0.clear_forces()
launch_vbd_knife_cut(state_0, damage, colors, accum, knife, material, dt, particle_volume, time, device)
launch_cut_tet_degradation(model, damage, base_tet_materials)
solver_vbd.step(state_0, state_1, control, contacts, dt)

Each MP4 is 360 ViewerGL frames at 60 fps, giving 6 seconds of simulated cutting and 6 seconds of playback. Simulation FPS isolates the physics update. Report-video FPS is the full ViewerGL asset-generation throughput, including rendering, capture, and encoding preparation, so it is lower for the higher-tet half-cylinder scenes and for the CPU-side shell split renderer. Raw logs are available as MPM stats, VBD stats, X-FEM cuboid stats, X-FEM vegetable stats, X-FEM paper stats, X-FEM hanging cloth stats, X-FEM curved cloth stats, and X-FEM bread stats.

Cloth quality diagnostics

The regenerated shell videos also write per-frame geometry checks from the physical cloth triangles and enriched cut quadrature records. These metrics are meant to catch the exact artifact that made earlier videos unacceptable: triangle area blow-up or an unbounded visual opening after the cut state activates.

Physics-step complexity benchmarks

The benchmark sweep disables split-mesh rendering and runs a null viewer for 120 physics frames. It is meant to answer solver cost, not video-generation cost. The regenerated shell rows below are the current regular-grid VBD shell-cloth plus X-FEM enrichment/quadrature runs.

Complexity sweep

Raw benchmark data: JSON and CSV.

Why X-FEM is slower here

The current X-FEM numbers are expected for this prototype, but they should not be treated as a lower bound for the method. The tet X-FEM benchmark runs an XPBD backbone plus extra Warp kernels for knife classification, side labels, enrichment displacement, damage, frictional force accumulation, table/glue projection, and material softening. The updated shell-cloth path uses VBD for the triangle membrane and bending solve while retaining the same X-FEM knife/discontinuity kernels and fixed cut-cell quadrature buffers. MPM is also not doing sharp mesh separation in the physics solve, so it avoids cut-cell quadrature and remesh bookkeeping; in this small sweep its fixed grid and solver overhead dominate enough that particle-count scaling looks flatter than a large production run would.

The much lower report-video FPS for X-FEM vegetable, bread, paper, hanging cloth, and curved cloth is a rendering/topology extraction issue, not the physics step alone. The half-cylinder split-tet and shell split-triangle renderers currently build the visible opened mesh through CPU/NumPy arrays after ViewerGL.get_frame() simulation frames. The implementation target is to move that to Warp: classify active tets/triangles, compact active lists, prefix-sum output counts, emit split exterior polygons, tet cut walls, and shell cut boundaries into fixed-capacity buffers, and keep those buffers graph-capture friendly.

Performance upgrades that follow directly from the literature and the benchmark results are: narrow-band active kernels around the blade and crack tip, fused classify/damage/friction kernels, inactive-tet early-outs, Warp-side render extraction without .numpy() copies, non-contributing DOF constraints for grazing cuts, and incremental matrix/preconditioner updates when the final X-FEM solver moves from XPBD backing to mixed physical/enriched residuals. Hecht et al.'s sparse Cholesky update work is useful inspiration for solver-side local matrix changes, while Koschier et al. and Ton-That/Kry/Andrews are the most relevant references for robust X-FEM cut geometry and constrained enrichment.

Current limitation: Track C now has solver-owned enrichment, cut-state arrays, and fixed shell cut-cell quadrature, and the render mesh visibly splits in the cut wake. The volumetric elastic backbone is still XPBD over physical particles plus material softening, not the final full mixed physical/enriched quadrature solve. Shell cloth now uses VBD membrane/bending response plus enriched side fields, but still needs calibrated anisotropic cloth/fracture parameters, crack-tip refinement, and a solve over physical plus enriched DOFs for the final model.

MPM Baseline

The MPM track should target force validation first. The knife should be an analytic SDF or mesh SDF collider with a sharp-edge model, a blade normal, and a blade tangent for slicing. Each particle carries fracture/damage variables. Each step accumulates normal indentation work, tangential sliding work, and local stress. Once the local work reaches a toughness threshold, damage grows and cohesive/tensile resistance is reduced.

Minimal new attributes can be registered through Newton's existing custom-attribute mechanism:

SolverImplicitMPM.register_custom_attributes(builder)
builder.add_custom_attribute(newton.ModelBuilder.CustomAttribute(
    name="fracture_energy", namespace="cut", frequency=newton.Model.AttributeFrequency.PARTICLE,
    assignment=newton.Model.AttributeAssignment.MODEL, dtype=wp.float32, default=100.0))
builder.add_custom_attribute(newton.ModelBuilder.CustomAttribute(
    name="damage", namespace="cut", frequency=newton.Model.AttributeFrequency.PARTICLE,
    assignment=newton.Model.AttributeAssignment.STATE, dtype=wp.float32, default=0.0))
builder.add_custom_attribute(newton.ModelBuilder.CustomAttribute(
    name="cut_side", namespace="cut", frequency=newton.Model.AttributeFrequency.PARTICLE,
    assignment=newton.Model.AttributeAssignment.STATE, dtype=wp.int32, default=0))

Warp-shaped damage update:

@wp.kernel
def update_cut_damage(pos, stress, fracture_energy, damage, cut_side, knife_sdf, dt):
    p = wp.tid()
    phi, n, blade_tangent = eval_knife_sdf(knife_sdf, pos[p])
    if phi < knife_sdf.process_zone:
        sigma_n = normal_stress(stress[p], n)
        work = wp.max(sigma_n, 0.0) * knife_sdf.edge_speed * dt
        d_inc = work / wp.max(fracture_energy[p], 1.0e-6)
        damage[p] = wp.min(1.0, damage[p] + d_inc)
        if damage[p] > 0.95:
            cut_side[p] = sign_to_int(wp.dot(pos[p] - knife_sdf.tip, n))

In continuum terms, the toy damage update is the discrete version of a work-to-toughness rule:

The MPM issue is not damage detection. It is separation. A single velocity field can smear or heal the two sides of a cut. The first Newton baseline should test two separation choices: particle-side labels with contact filtering near the knife, and a multi-field or multi-material velocity solve in cut cells. CRESSim-MPM is a recent robotics/surgical reference for making MPM cutting and suturing real time.

Mesh-Based VBD Track

For Newton's current mesh soft-body stack, the most natural cutting implementation is a VBD extension rather than a new global FEM solver. VBD already solves per-particle blocks from adjacent triangles, springs, and tets. A cut event can duplicate or virtually duplicate DOFs along the knife path, add cohesive links across the prospective cut, and weaken those links using a damage law.

Concrete first implementation:

1. Add cut material metadata: per-tet or per-interface fracture_energy, cohesive_strength, damage, and optional anisotropic grain direction.
2. Build a CPU NumPy cut-event pass that classifies tets by knife plane/SDF, creates paired cut-surface vertices, and inserts cohesive springs between twins.
3. Use the existing VBD spring path for cohesive forces. A spring stiffness is scaled by (1 - damage)^2 and goes to zero when the local work exceeds toughness.
4. After a topology event, rebuild the VBD adjacency, coloring, and self-contact filters. During ordinary frames, keep arrays fixed and graph-capturable.

# VBD tet/damage sketch inside the force evaluation path.
d = cut_damage[tet_id]
scale = (1.0 - d) * (1.0 - d)
mu_eff = tet_materials[tet_id, 0] * scale
lambda_eff = tet_materials[tet_id, 1] * scale
f_tet, h_tet = evaluate_volumetric_neo_hookean_force_and_hessian(
    tet_id, vertex_order, pos_prev, pos, tet_indices, tet_poses[tet_id],
    mu_eff, lambda_eff, tet_materials[tet_id, 2], dt)

For DiSECt-style robot cutting, the important feature is continuous damage: the knife contact force gradually weakens cohesive links before they fail. This keeps gradients and force traces smoother than instant remesh/delete events, and it gives parameters that map to measured cutting forces.

X-FEM Solver Track

X-FEM is the mathematically cleanest mesh-based route for a knife that cuts through existing tetrahedra without forcing the simulation mesh to conform to the blade. Instead of splitting every intersected tet, it augments the displacement field with discontinuous basis functions. For a complete cut, the practical starting point is shifted-Heaviside enrichment:

Here \(\mathbf{u}_i\) are Newton's ordinary particle displacements, \(\mathbf{a}_i\) are extra vector DOFs, \(\phi\) is the signed cut-surface distance, and \(H\) is the side indicator. The shifted form makes enrichment vanish at the owning node, which keeps the standard nodal field interpretable and improves conditioning. Partial/progressive cuts need crack-tip enrichment or a process-zone substitute near the knife front; complete cuts can start with Heaviside only.

The literature has converged on three practical lessons. First, X-FEM avoids remeshing but does not avoid geometry: every cut tet still needs side-aware quadrature for mass, stiffness, elastic energy, and internal force. Second, real-time stability depends on suppressing non-contributing or tiny-volume enrichment DOFs; otherwise nearly singular matrices appear when a blade grazes a vertex or sliver of material. Third, X-FEM must still be coupled to a cohesive fracture law if we want cutting forces rather than just a geometric discontinuity.

Track C now has a first Newton implementation. SolverXFEMCut lives under newton/_src/solvers/xfem_cut/, is exported as newton.solvers.SolverXFEMCut, and runs through Warp kernels plus Newton's XPBD tetrahedral backbone for solids or VBD shell cloth backbone for triangle sheets. The implemented state is intentionally explicit:

solver.particle_damage          # float[particle_count]
solver.particle_cut_side        # -1, 0, +1 shifted-Heaviside side label
solver.particle_enrichment_q    # vec3[particle_count] enriched side displacement
solver.particle_enrichment_qd   # vec3[particle_count] enriched side velocity
solver.tet_cut_state            # 0 uncut, 1 enriched/process-zone, 2 cut
solver.tet_damage               # float[tet_count]
solver.tet_cut_weight           # process-zone/wake weight
solver.knife_edge_points        # fixed-capacity sampled rigid blade edge
solver.force_accum              # total, active, damage, normal, friction, enriched count

The more realistic food scenes now use generated tetrahedral geometry instead of coarse cuboids. A gmsh-backed helper builds an extruded half-disk volume with a flat table face, orients and compacts the tetrahedra, and passes the raw vertices/indices through ModelBuilder.add_soft_mesh. The vegetable scenario uses 1,323 particles and 5,772 tetrahedra; the bread scenario uses 882 particles and 3,720 tetrahedra. Both use the same SolverXFEMCut path as the cuboid.

The current force kernel uses the rigid edge-spline process zone, an X-FEM-inspired shifted-Heaviside side label for the discontinuity, cohesive damage, and Coulomb-like blade friction for sawing:

Here \(s_i=\mathrm{sign}(y_i-y_c)\) is the cut side, \(\mathbf{n}_{s_i}\) separates the two sides, \(\boldsymbol{\tau}\) is the blade-axis tangent, and the normal force uses the same yield-plus-fracture-energy scale as the MPM/VBD baselines. The solver also projects bottom vertices against a table/glue model for food-on-table scenes:

The paper scenario exposed a useful numerical lesson: very thin, high-aspect tetrahedra are the wrong primitive for paper in this prototype. The branch now routes paper tearing through a Newton cloth grid and a shell/triangle cut renderer; the volumetric X-FEM path remains for food/tissue-like solids, while the paper/cloth path is treated as a surface-fracture problem.

A simple cohesive normal-traction law for the first solver prototype can be written as:

Concrete Newton data layout:

model.cut.fracture_energy[tet]      # J/m^2, per tet or material region
model.cut.cohesive_strength[tet]    # Pa
state.cut.damage[cut_facet]         # 0..1 cohesive damage state

solver.xfem_node_indices            # int32[enriched_node_count]
solver.xfem_particle_to_node        # int32[particle_count], -1 if not enriched
solver.xfem_q, solver.xfem_qd       # vec3 enrichment displacement/velocity
solver.xfem_tet_flags               # active, complete cut, tip, constrained
solver.xfem_tet_side_fraction       # positive/negative material volume
solver.xfem_tet_quad                # fixed-capacity cut-cell quadrature records

Warp-shaped force evaluation for one cut tet:

# At each side-aware quadrature point q:
Hq = 1.0 if phi_q >= 0.0 else -1.0
F = mat33(0.0)
for local in range(4):
    p = tet_indices[tet, local]
    grad = tet_shape_grad[tet, local]
    x = particle_q[p]
    e = xfem_particle_to_node[p]
    if e >= 0:
        x = x + (Hq - tet_node_H[tet, local]) * xfem_q[e]
    F += outer(x, grad)

force, hessian = neo_hookean_cut_quad(F, quad_weight, mu, lambda)
scatter_to_physical_and_enriched_blocks(force, hessian)

The same kernel is evaluating the quadrature-point deformation gradient:

The scatter step is the main reason this should be its own solver. A VBD-style block descent is still possible, but the coloring graph must include both physical nodes and enriched nodes. A matrix-free PCG/Newton-Krylov variant is also plausible because X-FEM naturally wants residual and Jacobian-vector products over mixed DOFs.

I added a second report-local NumPy artifact, xfem_enrichment_exploration.py, with a standard-library test, test_xfem_enrichment.py. It clips tetrahedra by a knife plane, estimates positive/negative material fractions, counts shifted-Heaviside enriched nodes, estimates cut-cell quadrature subcells, and flags enrichment variables whose stiffness contribution is near-null. Results are saved as xfem_enrichment_results.json.

Interpretation: the enriched DOF overhead gets better with refinement because the cut support is surface-like, but the quadrature workload and sliver handling are real. Even a generic oblique plane creates many small material fractions. Koschier et al.'s non-contributing-DOF constraints and Ton-That/Kry/Andrews-style Boolean integration are not optional polish; they are core robustness requirements for a Newton X-FEM solver.

Next X-FEM milestone: replace the current XPBD-backbone prototype with a static complete-cut residual over physical plus enriched DOFs. No crack tip, no repeated Boolean cuts, no remeshing at first. Overallocate enrichment/quadrature buffers, support one explicit cut surface, run implicit block descent or PCG over the mixed unknowns, and validate force-displacement against an equivalent cut-aligned/remeshed FEM block. Add progressive cutting and multiple/intersecting cuts only after the complete-cut residual is stable.

Shell/Triangle X-FEM for Paper and Cloth

Paper, cloth, film, foil, and packaging should be a 2D manifold embedded in 3D, not a one-element-thick tet block. The report cloth cases now remain regular Newton source grids: paper has 693 particles and 1,280 triangles, hanging cloth has 1,073 particles and 2,016 triangles, and the curved clamped sheet has 1,925 particles and 3,672 triangles. The X-FEM discontinuity is represented by solver-owned enrichment and side-aware cut-cell quadrature records rather than duplicate seam particles or zero-rest springs. Newton VBD continues integrating the base triangle membrane/bending material, while SolverXFEMCut owns the knife damage, side labels, enriched side displacement, edge/triangle cut state, and frictional blade drag.

On a triangle \(T\), the shell analogue of the shifted-Heaviside field is

The implemented shell quadrature clips every triangle against the rest-space cut curve and emits positive/negative subcell area records with parent triangle id, barycentric position, side label, and area. That is enough for conservative diagnostics and for the next mixed residual over shell membrane/bending and enrichment variables:

Here \(G_c(\alpha)\) can encode paper grain or woven-cloth anisotropy. That matters for validation: a torn sheet should expose crack-tip direction changes, bending near the tear mouth, and a force plateau governed by fracture energy, not only a visual seam.

The current branch no longer performs 2D X-FEM cuts with seam springs. The builder creates an ordinary cloth mesh with add_springs=False. A CPU cut-cell pass computes the fixed shell quadrature records once from the rest-space cut path, SolverXFEMCut.set_shell_quadrature() uploads those records to Warp arrays, and update_xfem_shell_enrichment_kernel advances the enriched side displacement after the VBD membrane/bending step. cut_xfem_cloth_triangles_kernel records visible cut state for the renderer while preserving the base triangle membrane material, so the quality logs measure physical triangle area from the unsplit cloth grid and opening from the enriched quadrature field.

The visual bug in the earlier paper tearing video came from treating a thin object like a volume and then trying to reveal a cut with tet-style rendering. A second bug interpolated new seam vertices between already-separated sides, producing a fan of long triangles after the hanging lower panel fell. A third bug let the knife impulse move too much low-mass cloth during a curved turn. The revised cloth path never deletes sheet area, never disables membrane material to fake a cut, and no longer depends on seam springs. The regular physical sheet remains bounded, while the opened side geometry comes from X-FEM enrichment and cut-cell quadrature. The curved-spline example now uses tangent-aligned blade yaw, a compact planar footprint, low normal/friction coupling, and bounded shell impulses, so the final seam stays narrow instead of opening into a broad dark gap. Remaining limitations are physical rather than visual: the current cloth solver still lacks calibrated orthotropic cloth, crack-tip refinement, and a full enriched shell residual, so it is a first shell X-FEM baseline rather than the final paper/cloth model.

Adaptive Remeshing

I added a first Warp-based adaptive remeshing implementation to the Newton cutting branch. It is currently a render-side surface remesher, not a solver-owned tet topology update: the MPM/VBD solvers keep their particle/tet arrays fixed, while a fixed-capacity GPU remesher generates duplicated render geometry, finite-gap cut-wall triangles, and local x refinement around the knife front each frame. The shell X-FEM path now uses regular source-grid cloth with solver-owned enrichment/quadrature plus a CPU/NumPy split-triangle renderer for active straight and spline cuts that should move to Warp next. This is the right intermediate step because it exercises the geometry path, particle-motion coupling, and fixed-buffer design before we make topology changes part of the volumetric physics solve.

The cuboid implementation lives in AdaptiveCutSurfaceRemesher. A small per-frame schedule marks coarse x-cells near the knife front for subdivision; Warp kernels then emit surface and wall triangles into preallocated buffers. Generated rest-space vertices are deformed from the current solver particles using side-aware inverse-distance displacement sampling, so the rendered dissection follows particles on the corresponding side of the cut rather than averaging across the discontinuity.

For the half-cylinder X-FEM scenes, the branch also includes TetMeshCutSurfaceRenderer. It uses the actual Newton surface triangles for uncut regions, clips triangles that cross or touch the cut plane inside the knife wake into separate positive/negative side polygons, and computes internal cut faces by intersecting each rest tetrahedron with the cut plane behind the knife. The generated exterior and cut-wall vertices are then interpolated from current physical plus enriched particle positions. This keeps curved tetrahedral objects volume-preserving in the videos while removing exterior triangles that used to bridge both sides of the cut.

Adaptive cutting remeshing deep dive

The literature separates three robust strategies. Bielser et al. use a state machine for tetrahedra so cuts through vertices, edges, faces, and interiors take deterministic subdivision transitions. Turkiyyah et al. focus on real-time mesh surgery and quality control during physical simulation. Molino/Bao/Fedkiw and Wang/Jiang/Schroeder/Teran avoid the worst sliver cases with virtual nodes: the simulation element can remain well-shaped while the embedded material surface is duplicated and cut. Dick/Georgii/Westermann show the related adaptive-grid route: refine near the cutting tool, cut along well-conditioned cell faces, and build a split boundary surface for rendering. For thin sheets, Narain/Samii/O'Brien and Pfaff/Narain/de Joya/O'Brien are the most relevant guides: remesh locally around curvature, velocity gradients, and crack tips, then coarsen away from active fracture so the mesh neither loses material nor accumulates sliver triangles.

The artifact in the earlier bread video is a classic side-ownership error. If a rest edge \(\overline{\mathbf{X}_i\mathbf{X}_j}\) crosses the cut at \(\mathbf{X}_c=(1-\alpha)\mathbf{X}_i+\alpha\mathbf{X}_j\), the negative cut wall must use the displacement of a negative-side endpoint and the positive cut wall must use the displacement of a positive-side endpoint:

The tempting interpolation \((1-\alpha)\mathbf{x}_i^-+\alpha\mathbf{x}_j^+\) is wrong after the material has separated: it creates vertices in empty space between two independently moving halves, producing long fan triangles and apparent volume loss. The branch now uses side-owned generated render vertices in both TetMeshCutSurfaceRenderer and ShellCutSurfaceRenderer. The same rule applies to cloth: the crack boundary is an enriched material boundary, not a deleted strip. With zero artificial display gap, the split shell triangulation preserves total area; with the small display gap used in the report videos, the gap is a visualization of separated boundary curves, not missing simulation elements.

For a solver-owned remeshed tet method in Newton, the most practical path is not naive global retetrahedralization every frame. The robust version is an event pipeline:

1. Classify active tets in a narrow band around the blade and crack front.
2. Evaluate a deterministic cut case for each active tet from rest-space signed values.
3. Emit an embedded material surface and duplicated side vertices into fixed-capacity Warp buffers using prefix sums.
4. Transfer mass, damage, and material state by volume or area fractions.
5. Update only affected adjacency, coloring, collision filters, and cohesive cut-surface constraints.
6. Recapture Newton graphs only when the physical solver topology changes; keep render-only extraction graph-capturable every frame.

This argues for two Newton implementations, not one. The current branch should keep the render-side adaptive remesher as a validation and perception-output tool. A future solver-owned remesher should look closer to adaptive virtual nodes: physical particles/tets stay stable when possible, while material-side nodes and cohesive interfaces carry the discontinuity. That design is more compatible with Warp fixed buffers and avoids generating poor-quality tets just to make the visible surface conform to the knife.

Particle-following deformation is computed as a GPU-side weighted displacement blend with side hints on duplicated seam vertices:

# New render path in the examples.
remesher = AdaptiveCutSurfaceRemesher(
    block_lo, block_hi, knife,
    base_segments=24, refine_factor=4,
    refine_band=0.13, height_segments=6)

stats = remesher.log(
    viewer, model.device, sim_time,
    rest_particle_points=rest_particle_q,
    particle_points=state_0.particle_q)

With 24 coarse x-cells and a 4x local refinement factor, the cuboid remesher reduces local spacing from about 3.7 cm to 9.3 mm near the knife front, while keeping the rest of the block coarse. The MPM/VBD cuboid topology peaks at 1,488 surface triangles plus 840-864 finite-gap cut-wall triangles. The X-FEM cuboid uses a finer setting and peaks at 1,928 surface triangles plus 1,120 wall triangles. The paper and hanging-cloth reports now render regular source-grid cloth through the enriched shell cut renderer, so their surface triangle counts come from clipped cut polygons rather than pre-split virtual-node topology. The curved-spline path reports solver-marked cut triangles and uses 3x local visible refinement to smooth the non-straight seam. For curved tetrahedral meshes, the half-cylinder path reports cut tets and emits both opened wall sides; the 6-second vegetable scene averages 516 cut tets and 1,289 cut-wall triangles, while the bread scene averages 500 cut tets and 1,333 cut-wall triangles.

The adaptive virtual node literature is particularly relevant because it avoids sliver tetrahedra by embedding cut geometry in larger well-shaped elements. That is likely better for Newton than naive tet subdivision once we need repeated cuts. The concrete next experiment is a Warp cut-tet extraction kernel using prefix sums and fixed-capacity triangle buffers; this branch now has the remeshing stats/export plumbing needed to compare that against the current parametric cuboid remesher.

Toy Exploration

I added a report-local NumPy script, toy_cutting_exploration.py, and saved its output as toy_cutting_results.json. It builds Newton-like five-tet grids, crosses them with an oblique knife plane, and counts touched tets, cut edges, estimated cut-surface triangles, and force scales.

Interpretation: the touched set scales like a surface through the volume. That is good news for localized cut events. The 16 x 16 x 8 case touches only 8% of tets, but it still creates enough new surface primitives that per-frame allocation would be risky inside CUDA graph capture.

Force scale used here:

It is intentionally simple, but it gives Newton parameter ranges that can be checked against real knife force data before a full solver exists.

Validation Plan

Cutting should be validated against measured force traces, not only visual cuts. The minimum useful experiment is a robot or linear stage with a force-torque sensor, fixed blade geometry, known vertical and slicing velocities, and soft samples with measured bulk and fracture properties.

A physically useful model needs at least four effects: bulk finite-strain deformation, fracture/cohesive resistance, pressure-dependent friction, and pressure-independent adhesion or wear. The 2026 soft-material cutting study is a good reminder that these terms interact; a force match from friction alone is not a reliable fracture model.

Implementation Roadmap

Source Notes

• Molino, Bao, and Fedkiw, A Virtual Node Algorithm for Changing Mesh Topology During Simulation, 2004.
• Wang, Jiang, Schroeder, and Teran, An Adaptive Virtual Node Algorithm with Robust Mesh Cutting, SCA 2014, DOI 10.2312/sca.20141125.
• Bielser, Glardon, Teschner, and Gross, A state machine for real-time cutting of tetrahedral meshes, Graphical Models 2004.
• Turkiyyah, Bou Karam, Ajami, and Nasri, Mesh cutting during real-time physical simulation, Computer-Aided Design 2011.
• Dick, Georgii, and Westermann, A Flexible and Interactive Approach for Cutting Deformable Objects, 2011 technical report.
• Narain, Samii, and O'Brien, Adaptive Anisotropic Remeshing for Cloth Simulation, ACM TOG/SIGGRAPH Asia 2012.
• Pfaff, Narain, de Joya, and O'Brien, Adaptive Tearing and Cracking of Thin Sheets, ACM TOG/SIGGRAPH 2014.
• Moës, Dolbow, and Belytschko, A finite element method for crack growth without remeshing, IJNME 1999.
• Moës and Belytschko, Extended finite element method for cohesive crack growth, Engineering Fracture Mechanics 2002.
• Jerabkova and Kuhlen, Stable Cutting of Deformable Objects in Virtual Environments Using XFEM, IEEE Computer Graphics and Applications 2009.
• Schoch, Suwelack, Speidel, Dillmann, and Heuveline, Simulation of Surgical Cutting of Soft Tissue using the X-FEM, EMCL Preprint 2013.
• Paulus, Suwelack, Schoch, Speidel, Dillmann, and Heuveline, Simulation of Complex Cuts in Soft Tissue with the Extended Finite Element Method (X-FEM), EMCL Preprint 2014.
• Koschier, Bender, and Thuerey, Robust eXtended Finite Elements for Complex Cutting of Deformables, ACM TOG/SIGGRAPH 2017.
• Ton-That, Kry, and Andrews, Generalized eXtended Finite Element Method for Deformable Cutting via Boolean Operations, Computer Graphics Forum/SCA 2024.
• Niroomandi, Alfaro, Gonzalez, Cueto, and Chinesta, Real-time simulation of surgery by reduced-order modeling and X-FEM techniques, IJNMBE 2012.
• Bui, Tomar, and Bordas, Corotational Cut Finite Element Method for real-time surgical simulation, CMAME 2018.
• Hecht, Lee, Shewchuk, and O'Brien, Updated Sparse Cholesky Factors for Corotational Elastodynamics, ACM TOG 2012.
• Ambati, Pan, Yuan, and Zhang, Application of material point methods for cutting process simulations, Computational Materials Science 2012.
• Nairn, Numerical Simulation of Orthogonal Cutting using the Material Point Method, Engineering Fracture Mechanics 2015.
• Ou and Tavakoli, CRESSim-MPM: A Material Point Method Library for Surgical Soft Body Simulation with Cutting and Suturing, IROS 2025.
• Heiden, Macklin, Narang, Fox, Garg, and Ramos, DiSECt: A Differentiable Simulator for Parameter Inference and Control in Robotic Cutting, 2022 extended version.
• Moreno-Mateos and Steinmann, Cutting soft materials: how material differences shape the response, npj Computational Materials 2026.
• Duncan, Sarapas, Defante, Beers, and Chan, Cutting to Measure the Elasticity and Fracture of Soft Gels, Soft Matter 2020.
• Baraff and Witkin, Large Steps in Cloth Simulation, SIGGRAPH 1998.
• Vandenberghe and Villermaux, Forced tearing of ductile and brittle thin sheets, Physical Review Letters 2013.
• O'Brien and Hodgins, Graphical Modeling and Animation of Brittle Fracture, SIGGRAPH 1999.
• O'Brien, Bargteil, and Hodgins, Graphical modeling and animation of ductile fracture, SIGGRAPH 2002.
• Muller, McMillan, Dorsey, and Jagnow, Real-time simulation of deformation and fracture of stiff materials, SCA 2001.
• Parker and O'Brien, Real-Time Deformation and Fracture in a Game Environment, SCA 2009.
• Muller, Chentanez, and Kim, Real Time Dynamic Fracture with Volumetric Approximate Convex Decompositions, SIGGRAPH 2013.
• Kakouris and Triantafyllou, Phase-field material point method for dynamic brittle fracture, CMAME 2019.
• Wang and Ma, A review of virtual cutting methods and technology in deformable objects, International Journal of Medical Robotics 2018.
• Yu, Zhao, Wang, and Pan, Real-time soft body dissection simulation with parallelized graph-based shape matching on GPU, Computer Methods and Programs in Biomedicine 2024.

Last updated: 2026-06-05 UTC.