Question

I have a server and a client.
I have 40 opengl cubes. There state is described by 3d vector for position and 3×3 rotation matrix(or a quaternion).

How can I send intermediate packets and predict the object state on the client between those packets(extrapolation)?

for object position I can use a linear predictor on velocity.
How to predict quaternion states?

Answer 1

The easiest thing, parallel to what you’re doing with linear velocity, is to use a linear predictor on angular velocity.

If you have two quaternions, q_0 and q_t, representing global orientations that are t seconds apart, you can compute the finite difference between the two quaternions and use that to find an angular velocity that can be used for extrapolation.

1. Make sure that the inner-product between q_0 and q_t is non-negative. If it’s negative, negate all the components of one of the quaternions. This makes sure that we’re not trying to go the long way around. If your bodies are rotating really fast relative to your sampling, this is a problem and you’ll need a more complicated model that accounts for the previous angular velocity and makes assumptions about maximum possible acceleration. We’ll assume that’s not the case.
2. Then we compute the relative difference quaternion. dq = q_t * q_0′ (where q_0′ is the quaternion rotational inverse/conjugate). If you have the luxury of having fixed-sized steps, you can stop here and predict then next orientation t seconds into the future: q_2t = dq*d_t.
3. If we can’ step forward by integer multiples of t, we compute the angle of rotation from dq. Quaternions and angular velocities are both variations on “axis-angle” representations of changes in orientation. If you rotate by Θ around unit-length axis [x,y,z], then the quaternion representation of that is q = [cos(Θ/2), sin(Θ/2)x, sin(Θ/2)y, sin(Θ/2)z] (using the quaternion convention where the w component comes first). If you rotate by Θ/t around axis [x,y,z], then the angular velocity is v = [Θx,Θy,Θz]/t. So v = Θ[q.x,q.y,q.z]/(t||[q.x,q.y,q.z]||). We can compute the angle two ways: Θ = 2acos(q.w) = 2asin(||[q.x,q.y,q.z]||). These will always be the same because of step 1. Numerics make it nicer to use sine since we need to find m = ||[q.x,q.y,q.z]|| anyway for the next step.

4. If m is large enough, then we just find the angular velocity:

   v = 2asin(m)[dq.x,dq.y,dq.z]/(m*t)

   However, if m‘s not large enough, we’ll face numeric issues trying to divide by near-zero. So programmers will use the Taylor expansion of the sinc() function around zero, which happens to be very accurate in this case. Remember that m = sin(Θ/2). With m<1e-4, we can accurately compute asin(m)/m = 6/(6-m*m). Then you just need to multiply the result by 2*[dq.x,dq.y,dq.z]/t and you have your angular velocity. Phew.

5. Extrapolating is then a matter of multiplying your angular velocity times the time that has passed. Then you go backwards, converting the angular change to a quaternion and multiplying it onto q_t.

It seems like there must be an easier way…