Loading in 5 sec....

Five Physics Simulators for Articulated BodiesPowerPoint Presentation

Five Physics Simulators for Articulated Bodies

- 192 Views
- Uploaded on

Download Presentation
## PowerPoint Slideshow about 'five physics simulators for articulated bodies' - albert

**An Image/Link below is provided (as is) to download presentation**

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

implicit jumps back from next position

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

- 2 key concepts, vital to understand even if you’re licensing physics:
- degrees of freedom, configuration space, etc.
- 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 DomainHighly 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 1st-order dynamics mouse attached by spring or constraint hands/feet attached by springs or constraints

- rigid bodies with constraints
- need to simulate enough to make articulated figure

- f = mv
- no inertia/momentum; no force, no movement

- must be tight control

- must stay locked to the positions

I Tried 4 Simulation Techniques

integration type

explicit integration

implicit integration

augmented

coordinates

Lagrange

Multipliers

Stiff Springs

coordinate type

generalized

coordinates

Recursive

Newton-Euler

Composite Rigid

Body Method

- 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) “coordinates necessary and sufficient to reach every valid state” examples:

- DOF is a critical concept in all math
- find the DOF to understand the system

- 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 “configuration space” is the space ofthe DOF “manifold” is the c-space, usuallyviewed as embedded in theoriginal space

- systems have DOF, equations on those DOF constrain them and subtract DOF
- example, 2D point, on line

(x,y)

2DOF

x = 2y

(x,y) = (t,2t)

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

f

3DOF + 3DOF - 2DOF = 4DOF

Generalized Coordinates

- aka. reduced coordinates, embedded methods, recursive methods
- calculate and simulate only the real DOF of the system
- one rigid body and joints

q

3DOF + 1DOF = 4DOF

Augmented vs. Generalized Coordinates, Revisited generalized coordinates:dynamics equations

- augmented coordinates: dynamics equations + constraint equations
- general, modular, plug’n’play, breakable
- big (often sparse) systems
- simulating useless DOF, drift

- small systems, no redundant DOFs, no drift
- complicated, custom coded
- dense systems
- no closed loops, no nonholonomic constraints

Stiffness most game UIs are incredibly stiff kinematically animating objects can be arbitrarily stiff

- fast-changing systems are stiff
- the real world is incredibly stiff
- “rigid body” is a simplification to avoid stiffness

- the mouse is insanely stiff...IK demo
- FPS control is stiff, 3rd person move change, etc.

- animating the position with no derivative constraints
- have keyframes drag around a ragdoll closely

Handling Stiffness it’s very hard to handle stiffness robustly explicit integrator will not handle stiff systems without tiny timestep

- You want to handle as much stiffness as you can!
- gives designers control
- you can always make things softer, that’s easy

- that’s sometimes used as a definition of numerical stiffness!

Stiffness Example demo of increasing spring constant

- example: exponential decay
- phase space diagram, position vs. time

position

time

dy/dx = -y

dy/dx = -10y

Explicit vs. Implicit IntegratorsNon-stiff Problem implicit jumps back from next position

- explicit jumps forward to next position
- blindly leap forward based on current information

- find a next position that points back to current

Explicit vs. Implicit IntegratorsStiff Problem

- explicit jumps forward to next position
- blindly leap forward based on current information

- find a next position that points back to current

Four Simulators In More Detail Augmented Coordinates / Implicit Integration Generalized Coordinates / Explicit Integration Generalized Coordinates / Implicit Integration

- Augmented Coordinates / Explicit Integration
- Lagrange Multipliers

- Implicit Springs

- Composite Rigid Body Method

- Implicit Recursive Newton Euler
- spend a few slides on this technique
- best for game humans?

Four Simulators In More Detail Augmented / ExplicitLagrange Multipliers apply forces to bodies integrate bodies forward in time pros: simple, modular, general cons: medium sized matrices, drift, nonstiff references: Baraff, Shabana, Barzel & Barr, my ponytail articles

- form dynamics equations for bodies
- form constraint equations
- solve for constraint forces given external forces
- the constraint forces are called “Lagrange Multipliers”

- forward euler, RK explicit integrator, etc.

Four Simulators In More Detail Augmented / ImplicitImplicit Springs pros: simple, modular, general, stiff cons: inexact, big matrices, needs derivatives references: Baraff (cloth), Kass, Lander

- form dynamics equations
- write constraints as stiff springs
- use implicit integrator to solve for next state
- e.g. Shampine’s ode23s adaptive timestep, or semi-implicit Euler

Four Simulators In More Detail Generalized / ExplicitComposite Rigid Body Method integrate state forward pros: small matrices, explicit joints cons: dense, nonstiff, not modular references: Featherstone, Mirtich, Balafoutis

- form tree structured augmented system
- traverse tree computing dynamics on generalized coordinates incrementally
- outward and inward iterations

- RK

Four Simulators In More Detail Generalized / ImplicitImplicit Recursive Newton Euler solve system for new state pros: small matrices, explicit joints, stiff cons: dense, not modular, needs derivatives references: Wu, Featherstone

- form generalized coordinate dynamics
- differentiate for implicit integrator
- fully implicit backward Euler

Generalized / ImplicitSome DerivationWarning: 2 slides of hot and heavy math! Inverse Dynamics Algorithm Insight: you can use an IDA to check for equilibrium given a velocity

- f = fint + fext = mv
- Forward Dynamics Algorithm
- given forces, compute velocities (accelerations)
- v = m-1(fint + fext)

- given velocities (accelerations), compute forces
- fint = mv - fext

- if fint = 0, then the current velocity balances the external forces, or f - mv = 0 (which is just a rewrite of “f = mv”)

Generalized / ImplicitSome Derivation (cont.) implicit Euler equation: q1 = q0 + h q1’ plug’n’chug: F(q0 + h q1’, q1’) = 0 we can use a nonlinear equation solver to solve F for q1’, then use this to step forward with implicit Euler

- 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 wantF(q1, q1’) = 0, the solution at the new time

- q1 = q0 + h q1’ ... q1’ = (q1 - q0) / h

- this is a function in q1’, because q0 is known

Solving F(q1’) = 0 can be hard, even impossible!(but it’s a very well documented impossible problem!)

- open problem
- solve vs. minimize?

The 5th Simulator Idea:

- 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 can’t in reality

- doesn’t always work, finds no solution, bails

- 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 stiffness is very important to handle for most games generalized coordinates with implicit integration is the best bet so far for run-time I’ll put the slides on my page at d6.com

- simulating an articulated rigid body is hard, and there are a lot of tradeoffs and subtleties
- there is no single perfect algorithm
- yet?

- maybe augmented explicit (?) for author-time tools

Download Presentation

Connecting to Server..