- 166 Views
- Uploaded on
- Presentation posted in: General

Five Physics Simulators for Articulated Bodies

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 - - - - - - - - - - - - - - - - - - - - - - - - - -

- 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

- 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

- 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

- 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

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...

- 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

- 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)

- 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

- 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

- 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 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

- 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

- 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!

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

position

time

dy/dx = -y

dy/dx = -10y

- 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

- 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?

- 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.

- 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

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

- RK

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

- 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”)

- 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

- open problem
- solve vs. minimize?

- 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

- 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