So, assuming you have angles *previousAngle* and *nextAngle*, and you want to transition from the first to the second smoothly. If it’s like from 358 to 2, a simple linear interpolation will awfully go through almost a full circle down from 358 to 2, when a simple four degree transition forward would have been enough, i.e. you should have been going to 362 degrees instead. So, how to figure out what’s the shortest transition?

I remember hitting against this problem numerous times, always remembering that I have solved it previously but always seem unable to find the previous solution. And I still can’t just write it out by heart.

Once again I had to solve this, so this time I tried to Google for it (“angle wrap delta”), and found out that somebody named Jason S had posted a nice generalization to a related question in Stackoverflow.com.

For your convenience, I’m posting a modified C version of the code here.

// Fancy generalization for wrapping below (e.g. for angles).

// Original code found from:

// http://stackoverflow.com/questions/2500430/calculating-rotation-in-360-deg-situations

```
```// symmetric modulo:

// y = smod(x,m) = x+k*m where k is an integer,

// and y is always in the range [-0.5,0.5)*m

static float smod(float x, float m)

{

return x - ((floorf(x / m + 0.5f)) * m);

}

`// Unwraps a value, used for e.g. angles.`

// Caveat: Doesn't handle negative input values correctly.

// Workaround: Wrap original value prev to [0..range) before applying this.

// e.g.: prev = fmodf(fmodf(prev, range) + range, range);

static float unwrap(float prev, float next, float range)

{

return prev + smod(next - prev, range);

}

There’s one **caveat**: it doesn’t seem to work correctly for negative angles. Just now I don’t have the time now to figure that out. But an easy workaround is to wrap the original angle first with angle=fmodf(fmodf(angle,2*pi)+2*pi,2*pi) and then transition from that angle to the destination. If somebody posts a better version I’ll update the post. :)