Time Line For An Object. Physics According to Verlet. Euler Integration. Computing Position. Implementation. Example 11/8/2011.

Transcription

1 Time Line For An Object Physics According to Verlet Ian Parberry Frame Number: Acceleration Velocity Position Acceleration Velocity Position Δ Acceleration Velocity Position Now Computing Position Suppose we know,, and. Let Δ be the duration of the previous frame. Then Δ is our best guess for the duration of the current frame (which isn t over yet). We can compute and like this: Δ Δ Euler Integration This corresponds to Euler integration. Instead of integrating the curve, we are summing over discrete time slices. 3 4 Implementation We implement this by storing each object s position, velocity, acceleration, and last move time. D3DXVECTOR3 m_vp; //position D3DXVECTOR3 m_vv; //velocity D3DXVECTOR3 m_va; //acceleration int m_nlastmovetime; //time of last move We 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 time Example An object starts at rest and accelerates at 10 m/sec for 5 seconds. Where does it end up at the end of the 5 seconds? / m 315m 5 6 1

2 Velocity as a Function of Time 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 large 7 8 Velocity as a Discrete Function of Time 9 10 Verlet Integration Loup Verlet, 1951 Developed the concept that is now called Verlet integration for use in particle physics simulation. 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 don t 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. 11 1

3 Verlet s Thinking Suppose we know,, and and want to compute. Let Δ, the amount moved in the previous frame. Start by considering Δ, the amount to be moved in the current frame. We know that Δ Δ Δ / Now, Δ is a good approximation for Δ. Therefore, substituting for Δ: Δ Δ Δ / Verlet s Thinking The story so far: Δ Δ Δ / Since Δ, substituting for Δ : Δ Δ / Substituting for Δ we get Δ / Equivalently, Δ / Summary What does the resulting equation mean? Δ /. It shows us how to compute given,,, and Δ. Notice that there is no need to store velocity. We can even fake a type of friction by using Δ /. Implementation We implement this by storing each object s position, velocity, acceleration, and last move time. D3DXVECTOR3 m_vp; //position D3DXVECTOR3 m_voldp; //previous position D3DXVECTOR3 m_va; //acceleration int m_nlastmovetime; //time of last move We then update location once per frame. int t = timegettime(); //current time in millisec int dt = t - m_nlastmovetime; //frame time D3DXVECTOR3 vtemp = m_vp; //save m_vp += m_vp - m_voldp + m_va*dt*dt/.0f; //update m_voldp = vtemp; //remember m_nlastmovetime = t; //update time Optimization Assume dt is constant. In fact, make it 1. D3DXVECTOR3 m_vp; //position D3DXVECTOR3 m_voldp; //previous position D3DXVECTOR3 m_va; //acceleration Even better, ignore the divide by. Ramp the acceleration down to compensate if you need to. D3DXVECTOR3 vtemp = m_vp; //save m_vp += m_vp - m_voldp + m_va; //update m_voldp = vtemp; //remember But, But, But But 1. However, we can repeat this code many times per frame. For example, const int ITERATIONS = 4; //Why 4? Why not. D3DXVECTOR3 vtemp; for(int i=0; i<iterations; i++){ vtemp = m_vp; //save m_vp += m_vp - m_voldp + m_va; //update m_voldp = vtemp; //remember

4 Implementation Store each object s position, acceleration, and last move time. D3DXVECTOR3 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 millisec int dt = t - m_nlastmovetime; //frame time Now, dt is typically in the range of tens of milliseconds. D3DXVECTOR3 vtemp; for(int i=0; i<dt; i++){ vtemp = m_vp; //save m_vp += m_vp - m_voldp + m_va; //update m_voldp = vtemp; //remember m_nlastmovetime = t; //update time Satisfying Constraints We mentioned earlier that Verlet integration makes it easy to enforce constraints on the particles. For example, let s 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 A Sticky Situation m_vp1 flen Suppose its ends are at positions m_vp1 and m_vp, and it is supposed to have length LEN. const float LEN = 4.0f D3DXVECTOR3 m_vp1, m_vp; First we get a vector vstick along the stick and find its length flen. D3DXVECTOR3 vstick = m_vp1 - m_vp; float m_vp A Sticky Situation m_vp1 LEN flen Then we find the difference between the stick now and what it should be. We split the difference between the two ends. m_vp1 += 0.5f * vstick; m_vp -= 0.5f * vstick; So far, so good. m_vp 1 One Stick Summary Declarations: D3DXVECTOR3 vstick; float flen; Code: vstick = m_vp1 - m_vp; m_vp1 += 0.5f * vstick; m_vp -= 0.5f * vstick; Remember this code. We ll use it again 3 slides from now Two Sticks But what if we ve got sticks joined at the ends? m_vp3 m_vp3 m_vp1 m_vp m_vp1 m_vp Satisfying one constraint may violate the other. m_vp3 m_vp1 m_vp 3 4 4

5 Declarations Using the same declarations as before: const float LEN = 4.0f D3DXVECTOR3 m_vp1, m_vp, m_vp3; D3DXVECTOR3 vstick; float flen; Treat the Sticks Independently We saw this code 3 slides ago vstick = m_vp1 - m_vp; m_vp1 += 0.5f * vstick; m_vp -= 0.5f * vstick; vstick = m_vp - m_vp3; m_vp += 0.5f * vstick; m_vp3 -= 0.5f * vstick; Ditto Remember this code. We ll use it again slides from now 5 6 Details The code is not exactly as we drew it in the picture. When we move m_vp the second time, it s not starting from its original position. But it s making progress towards where it needs to be. m_vp m_vp m_vp Relaxation So repeat the process. It s called relaxation. const int ITERATIONS = 7; for(int i=0; i<iterations; i++){ vstick = m_vp1 - m_vp; m_vp1 += 0.5f * vstick; m_vp -= 0.5f * vstick; vstick = m_vp - m_vp3; m_vp += 0.5f * vstick; m_vp3 -= 0.5f * vstick; We saw this code slides ago. We ll see it again 5 slides from now. 7 8 Jacobi/Gauss/Seidel Iteration This is Jacobi or Gauss Seidel iteration. It is a general method for satisfying multiple constraints that works quite well. Works quite well means that if the 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. If ITERATIONS is small, the stick acts like a spring. (This can actually be useful!) As ITERATIONS gets larger, the spring becomes more stick like. Jacobi Gauss Seidel 9 Box or Screen Collision Detection Suppose we want to constrain our particles to be within a box that is 104 by 768 by This is all it takes: m_pp = D3DXVec3Minimize( D3DXVec3Maximize(m_pP, D3DXVECTOR3(0,0,0)), D3DXVECTOR3(104, 768, 1000) ); 30 5

6 Cloth == A Bunch of Springs Cloth Declarations extern const float LEN; extern const int NUMPARTICLES; extern const int NUMSPRINGS; extern const int ITERATIONS; //small D3DXVECTOR3 m_pp[numparticles]; struct SpringType{ int nend1, nend; //indices into m_pp float flen; //rest length ; SpringType m_pspring[numsprings]; 31 3 Cloth Code for(int i=0; i<iterations; i++){ for(int j=0; j<numsprings; j++){ SpringType& s = m_pspring[j]; D3DXVECTOR3& vp1 = m_pp[s.nend1]; D3DXVECTOR3& vp = m_pp[s.nend]; D3DXVECTOR3 vspr = vp1 - vp; float flen=d3dxvec3length(&vspr); vspr *= (flen s.flen)/flen; vp1 += 0.5f * vspr; vp -= 0.5f * vspr; Familiar? Look back 5 slides 33 Giving the Boot to Square Roots The call to D3DXVec3Length uses a implicit square root, which is slow. We can replace it by a division. Here s what we started with: D3DXVECTOR3 vspr = vp1 - vp; float flen = D3DXVec3Length(&vSpr); vspr *= (flen s.flen)/flen; vp1 += 0.5f * vspr; vp -= 0.5f * vspr; 34 Giving the Boot to Square Roots Instead we can eliminate the square root by sticking with squares. D3DXVECTOR3 vspr = vp1 - vp; float flsq = D3DXVec3Dot(&vSpr, &vspr); float L = s.flen * s.flen; vspr *= L/(fLSq + L) 0.5f; vp1 += vspr; vp -= vspr; Technically, this is approximating the square root with one iteration of Newton Raphson. How Many Particles?

7 1 particles If is Even If is Odd Number of Particles If is even, If is odd, Therefore number of particles is /. What is this operator? More on the next slide. Reminder If is a real number, then, pronounced floor of, is the largest integer less than or equal to, and, pronounced ceiling of, is the smallest integer greater than or equal to. If is a floating point value stored in variable float r; is implemented as(int)r. If is an integer stored in variable int n; / is implemented as n/. / /. Therefore, / is implemented as n - n/ How Many Springs? Example:

8 Example: 7 Example: Example: rows of 1springs. / rows of springs. columns of 1springs. 1diagonals of 1springs. 1back diagonals of 1springs. Total is therefore: Sanity Check 1 Let, be the number of springs in our grid. Does, 3 match our examples? Recall that we found that:, 7 7 3, , , 7 88 Sanity Check Check that,7 3 7 :, , , ,

9 Number of Particles and Springs Number of particles is /. Number of springs is 3. Therefore we need these declarations: extern const int NR; //number of rows extern const int NC; //number of cols const int NUMPARTICLES = NR*NC + NR/; const int NUMSPRINGS = (3*NR )*NC NR + NR/; 49 9