Physics & Rendering Expert: Rope Dynamics & Constraint Solving

Expert in computational physics for real-time rope/cable dynamics, constraint solving, and physically-based simulations.

When to Use This Skill

Use for:

• Real-time rope/cable/chain simulation (leashes, climbing ropes)

• Position-Based Dynamics (PBD) implementation

• Constraint solvers (Gauss-Seidel, Jacobi)

• Quaternion/dual-quaternion rotation math

• Verlet integration for particle systems

• Tangle detection (multi-rope collisions)

Do NOT use for:

• Fluid dynamics → specialized SPH/MPM solvers

• Fracture simulation → requires FEM or MPM

• Offline cinematic physics → different constraints

• Unity/Unreal physics → use built-in systems

Expert vs Novice Shibboleths

Topic Novice Expert

Constraint approach Uses spring forces (F=ma) Uses PBD (directly manipulates positions)

Why PBD "Springs work fine" Springs require tiny timesteps; PBD is unconditionally stable

Solver choice "Just iterate until done" Gauss-Seidel for chains, Jacobi for GPU

Iterations 20+ iterations 5-10 is optimal; diminishing returns after

Rotation Uses Euler angles Uses quaternions (no gimbal lock)

Integration Forward Euler Verlet (symplectic, energy-conserving)

Common Anti-Patterns

Force-Based Springs for Stiff Constraints

What it looks like Why it's wrong

force = k * (distance - rest_length) with high k High k requires tiny dt for stability; low k gives squishy ropes

Instead: Use PBD - directly move particles to satisfy constraints

Euler Angles for Rotation

What it looks like Why it's wrong

rotation = vec3(pitch, yaw, roll)

Gimbal lock at 90° pitch; unstable composition

Instead: Use quaternions - 4 numbers, no gimbal lock, stable SLERP

Over-Iteration

What it looks like Why it's wrong

solver_iterations = 50

Diminishing returns after 5-10; wastes cycles

Instead: Use 5-10 iterations; if more needed, use XPBD compliance

Single-Threaded Gauss-Seidel for Large Systems

What it looks like Why it's wrong

Gauss-Seidel on 1000+ constraints Gauss-Seidel is inherently sequential

Instead: Use Jacobi solver for GPU parallelization

Quick Reference

Why PBD Beats Force-Based Physics

• Unconditionally stable (large timesteps OK)

• Direct control over constraint satisfaction

• No spring constants to tune

• Predictable behavior

Solver Choice

Solver Parallelizable Convergence Use Case

Gauss-Seidel No Fast Chains, ropes

Jacobi Yes (GPU) Slower Large meshes, cloth

Rotation Representation

• 3D rotation → Quaternion (never Euler)

• Rotation + translation → Dual quaternion

• Skinning/blending → Dual quaternion (no candy-wrapper artifact)

Performance Targets

System Budget Notes

Single rope (100 particles) <0.5ms 5 iterations sufficient

Three-dog leash (60 particles) <0.7ms Include tangle detection

Cloth (1000 particles) <2ms Use Jacobi on GPU

Evolution Timeline

Era Key Development

Pre-2006 Mass-spring systems, stability issues

2006-2015 PBD introduced (Müller et al.), unconditional stability

2016-2020 XPBD adds compliance for soft constraints

2021-2024 ALEM (2024 SIGGRAPH), BDEM, neural physics

2025+ XPBD standard, hybrid CPU/GPU, learned corrections

Decision Trees

Choosing constraint solver:

• Sequential structure (rope/chain)? → Gauss-Seidel

• Large parallel system (cloth/hair)? → Jacobi (GPU)

• Need soft constraints? → XPBD with compliance

Choosing integration:

• Position-only needed? → Basic Verlet

• Need velocity for forces? → Velocity Verlet

• High accuracy required? → RK4 (but PBD usually sufficient)

Integrates With

• metal-shader-expert - GPU compute shaders for Jacobi solver

• native-app-designer - Visualization and debugging UI

Reference Files

File Contents

references/core-algorithms.md

PBD loop, Verlet, quaternions, solver implementations

references/tangle-physics.md

Multi-rope collision, Capstan friction, TangleConstraint

Remember: Real-time physics is about stability and visual plausibility, not physical accuracy. PBD with 5-10 iterations at 60fps looks great and runs fast.