Presentation on theme: "Five Physics Simulators for Articulated Bodies Chris Hecker definition six, inc."— Presentation transcript:
Five Physics Simulators for Articulated Bodies Chris Hecker definition six, inc. firstname.lastname@example.org
Prerequisites comfortable with math concepts, modeling, and equations kinematics vs. dynamics familiar with rigid body dynamics –probably have written a physics simulator for a game, even a hacky one, –or at least read about it in detail, –or are using a licensed simulator at a low level
Takeaway key2 key concepts, vital to understand even if youre licensing physics: –degrees of freedom –degrees of freedom, configuration space, etc. –stiffness –stiffness, and why it is important for games pros and cons & subtleties of 4 different simulation techniques –all are useful, but different strengths all examples are 2D, but generalize directly to 3D not going to be detailed physics tutorial
Problem Domain Highly Redundant IK Simulate a human figure under mouse control –for a game about rock climbing...demo Before going to physics, I tried... –Cyclic Coordinate Descent (CCD) IK –works okay, simple to code, but problems: non-physical movement no closed loops no clear path to adding muscle controls gave a GDC talk about CCD problems, slides on d6.com
Solving IK with Dynamics rigid bodies with constraints need to simulate enough to make articulated figure 1st-order dynamics f = mv no inertia/momentum; no force, no movement mouse attached by spring or constraint must be tight control hands/feet attached by springs or constraints must stay locked to the positions
I Tried 4 Simulation Techniques coordinate type integration type augmented coordinates generalized coordinates explicit integrationimplicit integration Lagrange Multipliers Stiff Springs Composite Rigid Body Method Recursive Newton-Euler Wacky demo of all 4 running simultaneously...
Obvious Axes of the Techniques Augmented vs. Generalized Coordinates –ways of representing the degrees-of-freedom (DOF) of the systems Explicit vs. Implicit Integration –ways of stepping those DOFs forward in time, and how to deal with system stiffness
Degrees Of Freedom (DOF) DOF is a critical concept in all math find the DOF to understand the system coordinates necessary and sufficient to reach every valid state examples: point in 2D: 2DOF, point in 3D: 3DOF 2D rigid body: 3DOF, 3D rigid body: 6DOF point on a line: 1DOF, point on a plane: 2DOF simple desk lamp: 3DOF (or 5DOF counting head)
DOF Continued systems have DOF, equations on those DOF constrain them and subtract DOF example, 2D point, on line configuration space is the space of the DOF manifold is the c-space, usually viewed as embedded in the original space (x,y) x = 2y (x,y) = (t,2t) 2DOF 2DOF - 1DOF = 1DOF
Augmented Coordinates aka. Lagrange Multipliers, constraint methods simulate each body independently calculate constraint forces and apply them constraint forces keep bodies together 3DOF + 3DOF - 2DOF = 4DOF f
Generalized Coordinates aka. reduced coordinates, embedded methods, recursive methods calculate and simulate only the real DOF of the system one rigid body and joints 3DOF + 1DOF = 4DOF
Augmented vs. Generalized Coordinates, Revisited augmented coordinates: dynamics equations + constraint equations general, modular, plugnplay, breakable big (often sparse) systems simulating useless DOF, drift generalized coordinates: dynamics equations small systems, no redundant DOFs, no drift complicated, custom coded dense systems no closed loops, no nonholonomic constraints
Stiffness fast-changing systems are stiff the real world is incredibly stiff rigid body is a simplification to avoid stiffness most game UIs are incredibly stiff the mouse is insanely stiff...IK demo FPS control is stiff, 3rd person move change, etc. kinematically animating objects can be arbitrarily stiff animating the position with no derivative constraints have keyframes drag around a ragdoll closely
Handling Stiffness You want to handle as much stiffness as you can! gives designers control you can always make things softer, thats easy its very hard to handle stiffness robustly explicit integrator will not handle stiff systems without tiny timestep thats sometimes used as a definition of numerical stiffness!
Stiffness Example example: exponential decay phase space diagram, position vs. time demo of increasing spring constant dy/dx = -ydy/dx = -10y time position
Explicit vs. Implicit Integrators Non-stiff Problem explicit jumps forward to next position blindly leap forward based on current information implicit jumps back from next position find a next position that points back to current
explicit jumps forward to next position blindly leap forward based on current information implicit jumps back from next position find a next position that points back to current Explicit vs. Implicit Integrators Stiff Problem
Four Simulators In More Detail Augmented Coordinates / Explicit Integration Lagrange Multipliers Augmented Coordinates / Implicit Integration Implicit Springs Generalized Coordinates / Explicit Integration Composite Rigid Body Method Generalized Coordinates / Implicit Integration Implicit Recursive Newton Euler spend a few slides on this technique best for game humans?
Four Simulators In More Detail Augmented / Explicit Lagrange Multipliers form dynamics equations for bodies form constraint equations solve for constraint forces given external forces –the constraint forces are called Lagrange Multipliers apply forces to bodies integrate bodies forward in time forward euler, RK explicit integrator, etc. pros: simple, modular, general cons: medium sized matrices, drift, nonstiff references: Baraff, Shabana, Barzel & Barr, my ponytail articles
Four Simulators In More Detail Augmented / Implicit Implicit Springs form dynamics equations write constraints as stiff springs use implicit integrator to solve for next state e.g. Shampines ode23s adaptive timestep, or semi- implicit Euler pros: simple, modular, general, stiff cons: inexact, big matrices, needs derivatives references: Baraff (cloth), Kass, Lander
Four Simulators In More Detail Generalized / Explicit Composite Rigid Body Method form tree structured augmented system traverse tree computing dynamics on generalized coordinates incrementally outward and inward iterations integrate state forward RK pros: small matrices, explicit joints cons: dense, nonstiff, not modular references: Featherstone, Mirtich, Balafoutis
Four Simulators In More Detail Generalized / Implicit Implicit Recursive Newton Euler form generalized coordinate dynamics differentiate for implicit integrator fully implicit backward Euler solve system for new state pros: small matrices, explicit joints, stiff cons: dense, not modular, needs derivatives references: Wu, Featherstone
Generalized / Implicit Some Derivation Warning: 2 slides of hot and heavy math! f = f int + f ext = mv Forward Dynamics Algorithm given forces, compute velocities (accelerations) v = m -1 (f int + f ext ) Inverse Dynamics Algorithm given velocities (accelerations), compute forces f int = mv - f ext Insight: you can use an IDA to check for equilibrium given a velocity if f int = 0, then the current velocity balances the external forces, or f - mv = 0 (which is just a rewrite of f = mv)
Generalized / Implicit Some Derivation (cont.) IDA computes F(q,q) (ie. forces given state) when F(q,q) = 0, then system is moving correctly we want to do implicit integration, so we want F(q 1, q 1) = 0, the solution at the new time implicit Euler equation: q 1 = q 0 + h q 1 q 1 = q 0 + h q 1... q 1 = (q 1 - q 0 ) / h plugnchug: F(q 0 + h q 1, q 1) = 0 this is a function in q 1, because q 0 is known we can use a nonlinear equation solver to solve F for q 1, then use this to step forward with implicit Euler
Solving F(q 1 ) = 0 can be hard, even impossible! (but its a very well documented impossible problem!) open problem solve vs. minimize?
The 5th Simulator Current best: implicit Euler with F(q) = 0 Newton solve lots of wacky subdivision and searching to help find solutions –want to avoid adaptivity, but cant in reality doesnt always work, finds no solution, bails Idea: an adaptive implicit integrator will find the answer, but slowly the Newton solve sometimes cannot find the answer, no matter how slowly because it lacks info spend time optimizing the adaptive integrator, because at least it has more information to go on
Summary simulating an articulated rigid body is hard, and there are a lot of tradeoffs and subtleties there is no single perfect algorithm yet? stiffness is very important to handle for most games generalized coordinates with implicit integration is the best bet so far for run-time maybe augmented explicit (?) for author-time tools Ill put the slides on my page at d6.com
Your consent to our cookies if you continue to use this website.