Question

i’m trying to implement kinetic scrolling of a list object, but i’m having a problem determining the amount of friction (duration) to apply based on the velocity.

my applyFriction() method evenly reduces the velocity of the scrolling object based on a duration property. however, using the same duration (IE: 1 second) for every motion doesn’t appear natural.

for motions with a small amount of velocity (IE: 5 – 10 pixels) a 1 second duration appears fine, but applying friction over a 1 second duration for motions with lots of velocity (IE: 100+ pixels) the scrolling object will appear to slow and stop much faster.

essentially, i’m trying to determine the appropriate duration for each motion so that both small and large amounts of velocity will share a matching friction, so the moving object will appear to always have a constant “weight”.

is there a general algorithm for determining the duration of kinetic movement based on different velocities?

---

note: i’m programming in ActionScript 3.0 and employing the Tween class to reduce the velocity of a moving object over a duration.

Answer 1

A better model for friction is that the frictional force is proportional to velocity. You’ll need a constant to determine the relationship between force and acceleration (mass, more or less). Writing the relationships as a difference equation,

F[n] = -gamma * v[n-1]
a[n] = F[n]/m
v[n] = v[n-1] + dt * a[n]
     = v[n-1] + dt * F[n] / m
     = v[n-1] - dt * gamma * v[n-1] / m
     = v[n-1] * (1 - dt*gamma/m)

So, if you want your deceleration to look smooth and natural, instead of linearly decreasing your velocity you want to pick some constant slightly less than 1 and repeatedly multiply the velocity by this constant. Of course, this only asymptotically approaches zero, so you probably want to have a threshold below which you just set velocity to zero.

So, for example:

v_epsilon = <some minimum velocity>;
k_frict = 0.9; // play around with this a bit

while (v > v_epsilon) {
    v = v * k_frict;
    usleep(1000);
}

v = 0;

I think you’ll find this looks much more natural.

If you want to approximate this with a linear speed reduction, then you’ll want to make the amount of time you spend slowing down proportional to the natural log of the initial velocity. This won’t look quite right, but it’ll look somewhat better than what you’ve got now.

(Why natural log? Because frictional force proportional to velocity sets up a first-order differential equation, which gives an exp(-t/tau) kind of response, where tau is a characteristic of the system. The time to decay from an arbitrary velocity to a given limit is proportional to ln(v_init) in a system like this.)