Character Physics and Animation in Full Auto David Wu Pseudo Interactive
Dec 10, 2015
Introduction
Physical simulation of characters is an important problem in games.
In this lecture, the Framework for character simulation and animation that PI is developing will be presented.
Introduction (cont)
This framework is part of the latest incarnation of our physics engine, and is the basis for a game in development.
This means that the framework needs to actually work.
Goal
The primary goal of this presentation is to describe a collection of algorithms that can be used to solve the dynamic equations of characters, incorporate animation data into the solutions and integrate the results forward in time.
Goal
The main algorithms are:The Structurally Recursive
methods for inverse dynamicsImplicit Euler integrationMathematical Optimization
Goal (cont)
By the end of the lecture you should have an intuitive understanding of how the structurally recursive methods work to solve for the dynamics of a character and how implicit Euler can use the results to evolve the system dynamics through time.
Framework
1) Q’’
3) Residual
0) Q’’ initial guess
2) Q’’,Q’,Q
Note: Colorful text suggested by Casey
Framework
1) Q’’
3) Residual
0) Q’’ initial guess
2) Q’’,Q’,Q
Note: Colorful text suggested by Casey
The Framework
Physics in games is similar to where 3d rendering was in the early ‘90s.
There are many different approaches to solving the problem.
There is no commonly accepted standard.I.e. no “Triangle”.
The Framework
I predict that this framework will become the “Triangle” of physics in games.
1) Q’’
3) Residual
0) Q’’ initial guess
2) Q’’,Q’,Q
Note: Colorful text suggested by Casey
The Framework
VersatileRobustStable performanceSimple APIExplicit Control of DOF
• useful for Animation
1) Q’’
3) Residual
0) Q’’ initial guess
2) Q’’,Q’,Q
Note: Colorful text suggested by Casey
Physical Entities
All Physical entities are made up of “Frames”A Frame has Degrees of Freedom (DOF) and can perform spatial transformation from local space to global space.For this lecture we will only consider rigid bodies, although the algorithms that are described can support arbitrary DOF, including, for example, finite element nodes.
Character Example
Each set of arrows is a FrameAll frames are related to their parent using relative coordinatesEach frame is Rigid from a physics stand point (although the mesh uses skinning) Closed loops require constraints
Character Example
DOF Breakdown: Root (chest) 6 Pelvis 3 Thighs 3 (*2) Knees 1 (*2) Feet 3 (*2) Shoulders 3 (*2) Elbows 1 (*2) Wrists 3 (*2)
Total: 14 Frames, 37 DOF
Physics of Characters
There are a number of ways to derive the dynamics of characters. The method that I will describe is based on the structurally recursive methods. There are a number related techniques that all use the same concepts:
Featherstone's method Articulated Rigid Body Method Recursive Newton-Euler Equations Composite Rigid Body Method Etc.
Physics of Characters
An intuitive understand of how the method works is important.As such, the presentation will start from first principles and emphasize verbal descriptions.Part of the motivation behind this is the difficulty of writing equations or code in PowerPoint.
First PrinciplesConsider the momentum of a single rigid body at time t0:
Mt0*Vt0
M is a sparse 6x6 Matrix Mass Moments of Inertia
V is a 6d vector 3d Velocity at Center of
mass 3d Angular velocity This is often called the
“Spatial Velocity Vector”
M
vw
Some notes on the M matrix
Since M is in global coordinates, it is generally dependant on the rigid bodies orientation in space. This is what gives rise to the coriolis terms
If V was chosen to be at a point other than the center of mass, M would be less sparse and it would represent centrifugal effects.
Using the momentum equations we can safely ignore these effects - they are handled implicitly. I.e. when a valid solution is found, derivatives
of M will have contributed to the solution.
DynamicsConservation of momentum provides the
following constraint: Mt1*Vt1 = Mt0*Vt0 + integral(F,t0,t1)
F are external forces and torques
By the definition of velocity we have: Qt1 = Qt0 + integral(V,t0,t1)
Q is position and orientation These are the main equations that we
need to solve to ensure that the simulation is physically accurate.
Forward Euler
In order to approximate integral(F,t0,t1) we could compute F at t0 and then multiply it by (t1-t0).
Mt1*Vt1 = Mt0*Vt0 + Ft0*dt This is convenient because we know
the state of the system at t0, so we can just compute forces directly.
The approximation is that the forces at t0 are constant throughout the time step, which is pretty accurate if t1-t0 is very small.
Forward Euler
Another difficulty is computing Mt1
We don’t have the system state at t1 so computing the system inertia at that time is not trivial.
If we further assumed that Mt1 = Mt0 we would have:
Mt0*Vt1 = Mt0*Vt0 + Ft0*dt
Multiplying everything by Mt0-1:
(Vt1 -Vt0) = Mt0-1 *Ft0*dt
This can be solved explicitly, we are extrapolating acceleration.
Unfortunately it is not very stable.
Implicit Euler
With Forward Euler, we replaced all Integral(X,t0,t1)’s with Xt0*(t1-t0)
Assuming that we can ignore the difficulties of computing quantities at future points in time, we could instead replace Integral(X,t0,t1) with Xt1*(t1-t0)
This is implicit Euler, which is unconditionally stable for stable systems.
Implicit Euler
A simple example is a stiff spring
Ft0
Ft1
Vt0
Vt1
There is negative feedback for conservative potentials
Implicit Euler
We can now approximate integral(F) as Ft1:
Mt1*Vt1 = Mt0*Vt0 + Ft1*dt
And we can similarly approximate integral(V,t0,t1) as Vt1*dt.
Qt1 = Qt0 + Vt1*dt
For convenience, we will add a pseudo acceleration equation to represent delta V from t1 to t0:
Vt1 = Vt0 + V’*dt
Nonlinear Equations
The implicit equations are difficult to solve because we need values at future points in time.
Another way of saying this is that we have unknowns all over the place, and some of the relationships are nonlinear.
Nonlinear Equations
As it turns out, these equations can be transformed into a convex optimization problem.
The function that we are minimizing is related to the systems kinetic and potential energy:
E=(Mt1*Vt1 - Mt0*Vt0 - Ft1*dt)*Vt1
The unknowns are the accelerationsThe convex constraints are the physical
constraints
Convex Optimization
As it turns out, these equations can be transformed into a convex optimization problem.
The function that we are minimizing is related to the systems kinetic and potential energy (the Lagrangian):
E=(Mt1*Vt1 - Mt0*Vt0 - Ft1*dt)*V’
The unknowns are the accelerations (V’)The convex constraints are the physical
constraints
Minimizing Energy
E=(Mt1*Vt1 - Mt0*Vt0 - Ft1*dt)*V’
In the limit as |t1-t0| -> 0, minimizing this function is equivalent to minimizing the system Lagrangian.
The constants are different, but the minima is at the same place and the system preserves momentum and energy.
Interior point methods
E=(Mt1*Vt1 - Mt0*Vt0 - Ft1*dt)*V’
One way to solve convex optimization problems is piecewise quadratic programming, another is the interior point method which is what we will use.
The interior point methods transform the constraints into penalty functions and then minimizes unconstrained nonlinear equations.
Penalty Methods
Penalty methods are intuitive - game developers have been using them for years, even developers who don’t know what they are.
The spring analogy provides a metaphor and API that is easy to use and understand.
You don’t have to worry too much about overconstrained systems, which are very difficult to avoid in games.
Nonlinear Equations
If we know what the acceleration is, we can step the system forward in time to compute Vt1, Mt1.
With this updated state we can compute Ft1.
We can then compute the Residual: R = Mt1*Vt1 - Mt0*Vt0 - Ft1*dt To see if the acceleration was physically correct.
Ft1
Vt1Vt0
step
Mathematical Optimization
There is a good management analogy here:
Rather than trying to find a solution, we can let someone else try out solutions and just let them know how wrong they are.
This is essentially the interface to mathematical optimizers
i.e. Conjugate Gradient Method, Newton's method, Gauss Seidel iterations
Minimizing Residual
For a given acceleration we compute
R = Mt1*Vt1 - Mt0*Vt0 - Ft1*dt.
R is how wrong the acceleration is.- If R is 0, the solution is correct.- In practice we don’t need exact 0’s, if we sufficiently minimize R the answer is good enough.
Optimizer API
The mathematical optimizer will use the residual to guide a search. The search tests a series of accelerations and eventually converges on the optimal solution.
Q’’ Residual
HessianNewton’s Method
minimizes nonlinear equations by approximating them as a piecewise quadratic function.
The Hessian is the matrix that represents the quadratic coefficients:
q*H*qt + qt*b + c = 0
Hessian
The Hessian of these equations turns out to be:
System inertia with respect to the DOF
+ a low pass filter due to implicit Euler integration
+ a filter due to constraints and penalty methods
Hessian
Intuitively the equation that the optimizer solves is similar to
F = MAM is the Hessian.
Constraints add “infite inertia”
Stiff springs make the system heavier w.r.t. their direction of action
Hessian
Due to the nature of physics, if we linearalize the equation:
R = Mt1*Vt1 - Mt0*Vt0 - Ft1*dt.
about a given acceleration, the Hessian is symmetric and positive definite.
This can be solved with the Conjugate gradient method
Hessian
Semi implicit Euler assumes that the Hessian is constant.
This will not handle unilateral constraints, or highly nonlinear termsI.e. collisions, friction
Truncated Newton
Fully implicit Euler requires a full non linear solve, which handles a non-constant Hessian.
Truncated Newton uses piecewise truncated linear solutions in conjunctions with nonlinear line searches.
Truncated Newton
If the Hessian does not change significantly fully implicit is as efficient as partially efficient.
It only does extra work when required.
Simulation
In order to simulate the rigid body we: Guess at what the acceleration is, and give this
to the optimizer. The optimizer will feed us a number of guesses. For each guess we:
Step the system forward with the kinematic equations:
Vt1 = Vt0 + V’*dt Qt1 = Qt0 + Vt1*dt
Compute Ft1
Compute Mt1*Vt1
Compute the residual: R=Mt1*Vt1 - Mt0*Vt0 - Ft1*dt
Feed the residual back to the optimizer.
Simulation
In the case of unconstrained rigid bodies, the Hessian is Diagonally dominant, Conjugate gradient can solve these systems to a reasonable error in one step.
Inverse Dynamics
Computing Mt1*Vt1 - Mt0*Vt0 is similar to Inverse Dynamics, but in this case we are dealing with a finite change in time and velocity rather than an infinitesimal change. Inverse Dynamics computes forces
from accelerations. The problems are similar enough
that we can use similar techniques
Inverse Dynamics
Inverse dynamics is generally much easier than forward dynamics.A number of efficient methods for computing inverse dynamics have been developed by the robotics community.
A common application is to find a set of actuator torques required to achieve a set of joint accelerations
This technique can be used to efficiently determine physical quantities from animation data
Degrees of Freedom
In the case of a single unconstrained rigid body, the Spatial velocity vector is a natural choice to represent degrees of freedom. However in many cases we may want to use different degrees of freedom.
Angular velocity about a specific axis (i.e. elbow joint)
Linear velocity at an arbitrary point in space Time derivative of a quaternion Angular velocity of one body relative to another Etc.
Jacobian
For any set of degrees of freedom, we can derive the resulting spatial velocity and compute momentum from there.This transformation a Jacobian.dV/dq’
q’
wV
Jacobian
Jacobian
dV/dq’A rectangular matrix of partial derivatives that relates the derivatives of generalized DOF to the velocity of Rigid bodies.
q’
wV
Jacobian
Degrees of Freedom
Rigid bodies with their spatial velocities serve as a convenient Interface for various things such as constraints, potentials, contacts, computation of momentum etc.So most systems can only worry about rigid bodies and not deal with the fact that it might be a part of a character.
Attempting to interface at this level of abstraction is not recommended at social functions.
q’
wV
Jacobian
Degrees of Freedom
We can use the Jacobian to project spatial forces back into the coordinate system of the DOF.The Jacobian is often represented symbolically to exploit it’s sparsity and recursive relationships.I.e. for a typical character the complete Jacobian might be a 37x84 matrix
tau
Jacobian
F
Simulation- Hessian
Q’’
V’
A Hessian is the System inertia projected into DOF space + a low pass filter due to Implicit Euler
Simulation- arbitrary DOF
So in order to simulate any physical mechanism we can do the following:
Given the system state at t0, and an acceleration q’’.
Compute updated positions and velocities (q’,q) Compute spatial velocity (V), position and
orientation of the Rigid bodies Compute the Momentum of the rigid bodies Compute external forces Compute the residual R=Mt1*Vt1 - Mt0*Vt0 - Ft1*dt Project the residual back into DOF space for the
Mathematical Optimization system to deal with
vw
Constrained Rigid Body
Consider a rigid body constrained to rotate about an axis a.It has 1 degree of freedom (q, q’)The Jacobian relating q’ to V is the 1x6 matrix:
J = { Cross(a,r), a }t
V = J*q’M*V = M*J*q’So the residual in terms of q’’
projected onto q is:R=(M*J*(q’+q’’*dt) – Mt0*Vt0 - F) * Jt
a
r
F
Linked Bodies
Consider the two Linked bodies, L0 and L1
L0 is the Parent of L1 L1 is pinned to L0 at the point p L1 has 3 Degrees of freedom
relative to L0, it can rotate about the point.
The degrees of freedom that we will use are 6 spatial DOF for L0 and 3 relative angular DOF for L1 (q1), which are in the local space of L0.
M
vw
M
vw
L0
L1
F
F
p
q1
Linked Bodies Kinematics
R0 is the vector from L0’s center of mass to the pivot pR1 is the vector from p to L1’s center of mass.A0 is the orientation of L0The angular velocity of L1 is:
Vl0.angular + A0*q1
The linear velocity of L1 is: Vl0.linear +
cross(Vl0.angular,r0) + cross(A0*q1,r1)
M
vw
M
vw
L0
L1
F
F
p
r0
r1
Jacobians
The Jacobian for L0 is just I for it’s own DOF (since it is using spatial velocity) and 0 for L1’s DOF.The Jacobian for L1 projects from L0’s DOF and L1’s DOF to the spatial velocity of L1, so it is a 9x6 matrix which computes:
Vl0.angular + q1 Vl0.linear + cross(Vl0.angular,r0+r1)
+ cross(A0*q1,r1) Writing this expression as a matrix in
PowerPoint is beyond the scope of this presentation.
M
vw
M
vw
L0
L1
F1
F0
p
r0
r1
Jacobians
The complete Jacobian for the system is 9x12.While it is tempting to just treat the Jacobian as a black box matrix, it is helpful to have an intuitive feel for what is happening.
M
vw
M
vw
L0
L1
F1
F0
p
r0
r1
Jacobians
In the case of articulated rigid bodies the block corresponding to the relationship between some q’ and a child’s spatial velocity can be computed by:
Projecting the q’ to a spatial vector Usually a rotation or an projection
along an axis Translating the spatial velocity to
the cofm of the rigid body linear = linear + cross(angular, r) angular = angular
M
M
vw
L0
L1
p
r0
r1
Jacobians
Conceptually you think of L0 and L1 as one large composite rigid body.
Angular velocity is constant throughout
Linear velocity at a point p1 (i.e. the cofm of L1) is the linear velocity of the composite body at point p0 + cross(angular velocity, p1-p0)
L0
L1
p0
p1
p1-p0
V
w
Jacobians
When projecting from spatial forces back into DOF the block corresponding to the relationship between the force on a body and a parent’s DOF can be computed by:
Translating the spatial force to pivot (or cofm) of the DOF Linear = linear angular = angular + cross(r,linear)
Projecting the spatial vector onto the DOF Usually a rotation or an projection
along an axis This is the Transpose of what we saw
on the last slide
M
M
L0
L1
F1
F0
p
r0
r1
Jacobians
Considering L0 and L1 as one large composite rigid body,
Linear Force is applied at any point results in a constant force throughout
Linear Force applied to point p1 creates an addition angular torque (moment) at p0 equal to cross(p1-p0, F)
L0
L1
p0
p1
p1-p0
F
Residual
Armed with the Jacobian, computing the residual is straight forward.
Spatial Momentum (M*V) is computed for each body
Spatial forces (F0,F1) are computed on each body as usual
The residual is computed for each body:
R=(Mt1*Vt1 – Mt0*Vt0 - F) The residuals are projected
onto the DOF using the Jacobian.
M
vw
M
vw
L0
L1
F1
F0
p
r0
r1
N Bodies
This solution is readily extendable to tree structured mechanisms with an arbitrary number of degrees of freedom. I.e. characters that are not wearing straight jackets, hand cuffs or other devices that might create closed loops.
N Bodies
Direct computation of the Jacobian requires O(n2) time and O(n2) space.We can use a recursive technique that processes direct child-parent relationships to compute the product of the Jacobian and a vector in O(n) time. These are called the Recursive Newton Euler equations.
N Bodies
The process is a straight forward extension of what was used to solve the two body case.From Root to Leaves:
Each frame uses its acceleration to update its relative velocity, position and orientation.
Frames combine the effects of their relative DOF with their parent’s composite spatial DOF to compute their new spatial DOF.
N Bodies
Compute External Forces on all bodiesFrom Leaves to Root, for each frame:
Compute spatial momentum
Compute local residual Add the composite
residual of all children Project the residual onto
DOF
N Bodies
When a parent passes its composite velocity down to its children it is providing the results from O(n) grand parents.When each child passes its composite residual up to its parent it is providing the results of O(n) grandchildren.This is how the problem is reduced from O(n2) time to O(n) time.
Just another Jacobian
The DOF of Articulated characters can seamlessly interact with the DOF other dynamic systemsWe just a way to compute the Jacobian for the DOF
Dof-Kinematics-Inertia-Potentials
Particles
Rigid Bodies
Articulated Figures
Finite Elements
Forward Dynamics
This technique can be extended to forward dynamics
I.e. the Articulated rigid body method
Unfortunately when you have constraints and closed loops (i.e. contacts) things rapidly increase above O(n) time.Forward dynamics can be used to precondition the system for the optimizer.
Kinematics
A convenient property of this solution is that specific DOF can be set to kinematic with very few changes:The accelerations of the kinematic DOF are not given to the mathematical optimizer, instead they are assumed to be constants.When the residual is computed for Kinematic DOF, it is not given back to the optimizer.
Kinematics
Kinematic DOF reduce the number of unknowns that the optimizer has to solve for. This improves convergence and speeds up the solution.A technique that we use to LOD simulation is to “Bake” certain DOF when stress is high.
I.e. wrists and ankles are dynamic ¼ of the time, and kinematic with q’’ = -q’*kd the rest of the time.
Animation
Animation data can be applied to dynamic characters as follows:
All DOF are set to kinematic with q’’ derived from the animation
The DOF space residuals are compared with some threshold representing the maximum force/torque that the characters muscles can apply.
If the residual is <= this limit, everything is fine.
If the residual is >= this limit, the limit is applied and the DOF is switched to dynamic.
Animation
This provides a very efficient mechanism to combine animations with physics.When all residuals are within limits, the costs are very similar to that of straight animation playback.
I.e. there are 0 unknown DOF, which is easy to solve for.
Animation
Switching back and forth between dynamic and kinematic is perfectly legal within the context of convex optimization, provided that the actuator force applied when the DOF are dynamic are >= than the highest residual seen when they were kinematic.
Animation
Rather than removing the kinematic DOF from the optimizer, you can just set the residual’s to 0 and the optimizer will not change the DOF. This is equivalent to applying a force that is exactly equal and opposite to the residual at the DOF, which is what an ideal actuator would do.The function is min(torque limit,residual) This would break a semi implicit integrator.
Semi Implicit vs Fully Implicit
When the torque hits the limit, the Hessian changes. Semi implicit integrators consider the Hessian to be constantA non-linear optimizer will find the transition in the line search.
Limitations
Finding the wrong root. A non-linear system can have multiple local
minima. The worst offenders are rotational DOF with
very little inertia subject to large external forces I.e. foot on ground supporting body Luckily the animation actuator increases the effective
inertia of the DOF It helps to give characters strong calves.
In order for this to be a problem at a 60hz simulation rate, you have to encounter angular accelerations that are ~ 3600 radians/second2
Limitations
First order accurate For us the error is acceptable when
simulating at >= 60hz.
Adds damping