Introduction to Game Physics with Box2D2. Mathematics for Game
Physics Lecture 2.2: Digital Calculus Ian Parberry Dept. of
Computer Science & Engineering University of North Texas
Contents Euler and Verlet Integration Gauss-Seidel
RelaxationChapter 2 Introduction to Game Physics with Box2D 2
Chapter 2 Introduction to Game Physics with Box2D 3
Discrete CalculusChapter 2 Introduction to Game Physics with
Box2D 4
Time Line For An Object Frame Number: 1 2 3 NowChapter 2
Introduction to Game Physics with Box2D 5
Computing PositionChapter 2 Introduction to Game Physics with
Box2D 6
Euler IntegrationThis corresponds to Euler integration. Instead
ofintegrating the curve, we are summing overdiscrete
time-slices.Chapter 2 Introduction to Game Physics with Box2D
7
ImplementationWe implement this by storing each
objectsposition, velocity, acceleration, and last move time.
D3DXVECTOR2 m_vP; //position D3DXVECTOR2 m_vV; //velocity
D3DXVECTOR2 m_vA; //acceleration int m_nLastMoveTime; //time of
last moveWe then update position and velocity once per frame. int t
= timeGetTime(); //current time in msec int dt = t -
m_nLastMoveTime; //frame time m_vP += m_vV * dt; //update position
m_vV += m_vA * dt; //update velocity m_nLastMoveTime = t; //update
timeChapter 2 Introduction to Game Physics with Box2D 8
ExampleChapter 2 Introduction to Game Physics with Box2D 9
But in a Game? We compute the distance moved in each frame and
accumulate all those distances to get the total distances. We have
to assume that the velocity is constant within each frame. We end
up with the following set of distances, which is too smallChapter 2
Introduction to Game Physics with Box2D 10
Chapter 2 Introduction to Game Physics with Box2D 11
Velocity as a Continuous Function of TimeChapter 2 Introduction
to Game Physics with Box2D 12
Velocity as a Discrete Function of TimeChapter 2 Introduction
to Game Physics with Box2D 13
Verlet Integration Loup Verlet, 1951- Developed the concept
that is now called Verlet integration for use in particle physics
simulation.Chapter 2 Introduction to Game Physics with Box2D
14
Why Do We Care? There are mathematical reasons for using Verlet
integration instead of Euler integration when simulating real
particle systems. But what about in games? We dont care so much
about reality. One useful feature of Verlet integration is that it
is easy to incorporate constraints, for example, to fix lengths and
angles. This means that Verlet integration makes it easier to code
soft-body animation including cloth and ragdoll.Chapter 2
Introduction to Game Physics with Box2D 15
Verlets ThinkingChapter 2 Introduction to Game Physics with
Box2D 16
Verlets Thinking 2Chapter 2 Introduction to Game Physics with
Box2D 17
Summary of Verlet IntegrationChapter 2 Introduction to Game
Physics with Box2D 18
Compare and Contrast Euler: Verlet:Chapter 2 Introduction to
Game Physics with Box2D 19
ImplementationWe implement this by storing each objects
position,previous position, acceleration, and last move time.
D3DXVECTOR2 m_vP; //position D3DXVECTOR2 m_vOldP; //previous
position D3DXVECTOR2 m_vA; //acceleration int m_nLastMoveTime;
//time of last moveWe then update position and velocity once per
frame. int t = timeGetTime(); //current time in millisec int dt = t
- m_nLastMoveTime; //frame time D3DXVECTOR2 vTemp = m_vP; //save
m_vP += m_vP - m_vOldP + m_vA*dt*dt/2.0f; //update m_vOldP = vTemp;
//remember m_nLastMoveTime = t; //update timeChapter 2 Introduction
to Game Physics with Box2D 20
OptimizationAssume dt is constant. In fact, make it 1.
D3DXVECTOR2 m_vP; //position D3DXVECTOR2 m_vOldP; //previous
position D3DXVECTOR2 m_vA; //accelerationEven better, ignore the
divide by 2. Ramp the accelerationdown to compensate if you need
to. D3DXVECTOR2 vTemp = m_vP; //save m_vP += m_vP - m_vOldP + m_vA;
//update m_vOldP = vTemp; //rememberChapter 2 Introduction to Game
Physics with Box2D 21
But, But, But const int ITERATIONS = 42; //Why 42? Why not.
D3DXVECTOR2 vTemp; for(int i=0; i
ImplementationStore each objects position, acceleration, and
lastmove time. D3DXVECTOR2 m_vP, m_vOldP, m_vA; //as before int
m_nLastMoveTime; //time of last move We then update position
multiple times per frame. int t = timeGetTime(); //current time in
ms int dt = t - m_nLastMoveTime; //frame timeChapter 2 Introduction
to Game Physics with Box2D 23
Implementationdt is typically in the range of tens of
millisecs. D3DXVECTOR2 vTemp; for(int i=0; i
Satisfying ConstraintsChapter 2 Introduction to Game Physics
with Box2D 25
Satisfying Constraints We mentioned earlier that Verlet
integration makes it easy to enforce constraints on the particles.
For example, lets model a stick by applying Verlet integration to
two particles at the ends of the stick. The constraint is that the
distance between the particles must remain constant. We move the
particles at the ends of the stick independently, then try to fix
their positions before rendering if they are the wrong distance
apart.Chapter 2 Introduction to Game Physics with Box2D 26
fLenA Sticky Situation m_vP1 m_vP2Suppose its ends are at
positions m_vP1 andm_vP2, and it is supposed to have length LEN.
const float LEN = 42.0f; D3DXVECTOR2 m_vP1, m_vP2;First we get a
vector vStick along the stickand find its length fLen. D3DXVECTOR2
vStick = m_vP1 - m_vP2; float fLen =
D3DXVec2Length(&vStick);Chapter 2 Introduction to Game Physics
with Box2D 27
fLenA Sticky Situation m_vP1 m_vP2 LENThen we find the
difference between the sticknow and what it should be. vStick *=
(fLenLEN)/fLen;We split the difference between the two ends. m_vP1
+= 0.5f * vStick; m_vP2 -= 0.5f * vStick;So far, so good.Chapter 2
Introduction to Game Physics with Box2D 28
One Stick Summary Remember this code. Well useDeclarations: it
again 3 slides from now D3DXVECTOR2 vStick; float fLen;Code: vStick
= m_vP1 - m_vP2; fLen = D3DXVec2Length(&vStick); vStick *=
(fLenLEN)/fLen; m_vP1 += 0.5f * vStick; m_vP2 -= 0.5f *
vStick;Chapter 2 Introduction to Game Physics with Box2D 29
Two SticksBut what if weve got 2 sticks joined at the ends?
m_vP3 m_vP3 m_vP1 m_vP2 m_vP1 m_vP2 Satisfying one constraint may
violate the other. m_vP3 m_vP1 m_vP2Chapter 2 Introduction to Game
Physics with Box2D 30
DeclarationsUsing the same declarations as before: const float
LEN = 42.0f D3DXVECTOR2 m_vP1, m_vP2, m_vP3; D3DXVECTOR2 vStick1,
vStick2; float fLen;Chapter 2 Introduction to Game Physics with
Box2D 31
We saw Treat the Sticks Independentlythis code 3slides ago
vStick = m_vP1 - m_vP2; fLen = D3DXVec2Length(&vStick); vStick
*= (fLenLEN)/fLen; m_vP1 += 0.5f * vStick; Remember m_vP2 -= 0.5f *
vStick; this code. Well use it vStick = m_vP2 - m_vP3; again 2
slides fLen = D3DXVec2Length(&vStick); from now Ditto vStick *=
(fLenLEN)/fLen; m_vP2 += 0.5f * vStick; m_vP3 -= 0.5f * vStick;
Chapter 2 Introduction to Game Physics with Box2D 32
Details The code is not exactly as we drew it in the picture.
When we move m_vP2 the second time, its not starting from its
original position. But its making progress towards where it needs
to be. m_vP2 m_vP2 m_vP2Chapter 2 Introduction to Game Physics with
Box2D 33
RelaxationRepeat the process. Its called relaxation. const int
ITERATIONS = 7; for(int i=0; i
SpringsTo make springs instead of sticks, replace: vStick *=
(fLenLEN)/fLen;with the following, where m_fRestitution is
acoefficient of restitution between 0 and 1: vStick *=
m_fRestitution*(fLenLEN)/fLen; 0 1Chapter 2 Introduction to Game
Physics with Box2D 35
Jacobi/Gauss/Seidel Iteration This is Jacobi or Gauss-Seidel
iteration. Jacobi It is a general method for satisfying multiple
constraints that works quite well. Works quite well means that if
the Gauss conditions are right, it will converge. The number of
ITERATIONS will depend on the physical system being modeled, and
details such as the speeds and the floating point precision.
SeidelChapter 2 Introduction to Game Physics with Box2D 36
ConclusionChapter 2 Introduction to Game Physics with Box2D
37
Suggested ReadingSections 2.3, 2.4.Chapter 2 Introduction to
Game Physics with Box2D 38