Rotation interpolation

pippy2 · Post by **pippy2** » Thu Mar 06, 2008 3:14 am

I have two rotations, a target and a current(old) rotation vector. I need to animate a smooth transition between the two.

How do I get a rotation that is between the two vector3fs?

night_hawk · Post by **night_hawk** » Thu Mar 06, 2008 7:53 am

Code: Select all

vector3df base,target;
irr::f32 speed;
... //assign them here

vector3df move=(target-base).normalise();

base+=move*speed*delta; //delta is a value to make it framerate independent
//assign base to your node via ->setRotation()

This is only the simple version. The longer version is to also check if it's the shortest rotation path.

hybrid · Post by **hybrid** » Thu Mar 06, 2008 8:10 am

You mean rotated vecotr, or rotation vector?. If you have two rotations, it's best to interpolate by quaternions, using the slerp() method.

dlangdev · Post by **dlangdev** » Thu Mar 06, 2008 7:15 pm

This is an interesting thread, I'd like to know more about slerp() as I'm studying timelines and keyframe animation.

Specifically, I'd like to know how easing-in and easing-out is implemented in combination with slerp().

pippy2 · Post by **pippy2** » Sat Mar 08, 2008 10:13 am

night_hawk: thanks heaps for your code =D

I would love a method that checked for the shortest path. for example if the original X was at 20, and the target X was at 270 it would be quicker to go down instead of up...

My code for doing this looks like someone threw it up, and it still doesn't work right, at certain angles it goes the wrong way.

morris · Post by **morris** » Sat Mar 08, 2008 5:17 pm

the "shortest" path is easily defined. consider a rotation around, lets say, the Y axis. any rotation R bigger than 180° can be described as "long", and the shorter path is -(360°-R). so, after calculating your rotation vector [edit: but BEFORE normalizing it], check for each axis if the rotation is bigger than 180° (and maybe also -180°) and set the shorter angle if yes [edit: or just change the sign of that axis].

edit:
in fact, it IS a problem if you have rotations on all axes - you really should therefore stick to quaternions' slerp(). otherwise you'll have to handle some special cases (for example when your object makes a looping) as the rotation vector will not be returned continously, but there will be some "jumps".

pippy2 · Post by **pippy2** » Thu Mar 13, 2008 3:36 am

Thanks morris. I tried to work out the interpolation using this code:

Code: Select all

core::vector3df rotinterpol(const core::vector3df &actualCamera, const core::vector3df &orginalRotation, const u32 &interpolation){
				
	core::vector3df base = actualCamera;
	core::vector3df move = (actualCamera-orginalRotation);

	if(move.Y > 180)
		move.Y = -move.Y;
	if(move.Y < -180)
		move.Y = -move.Y;
	if(move.X > 180)
		move.X = -move.X;
	if(move.X < -180)
		move.X = -move.X;
	if(move.Z > 180)
		move.Z = -move.Z;
	if(move.Z < -180)
		move.Z = -move.Z;

	move =  move.normalize ();
	base -= move * interpolation; 
	return base;
};

as you can tell it didn't work. I'll read up more about slerp now. I still don't understand exactly what it does.

pippy2 · Post by **pippy2** » Fri Mar 14, 2008 5:20 am

I got closer with the previous method than this one:

Code: Select all

core::vector3df rotinterpol(const core::vector3df &actualCamera, const core::vector3df &orginalRotation, const f32 &interpolation){
	core::quaternion tmp;
	tmp.slerp( core::quaternion(actualCamera), core::quaternion(orginalRotation),  interpolation);

	core::vector3df ret;
	tmp.toEuler (ret);
 	return ret;
};

It's most likely not working because I don't really understand what the slerp code does. The code looks like someone threw up :/

xDan · Post by **xDan** » Fri Mar 14, 2008 11:25 am

For some strange reason the quaternion classes take radians... Or is it: for some strange reason scene nodes use degrees?

Code: Select all

core::vector3df rotinterpol(const core::vector3df &actualCamera, const core::vector3df &orginalRotation, const f32 &interpolation){
	core::quaternion tmp;
	tmp.slerp( core::quaternion(actualCamera * core::DEGTORAD), core::quaternion(orginalRotation * core::DEGTORAD),  interpolation);

	core::vector3df ret;
	tmp.toEuler (ret);
 	return ret * core::RADTODEG;
};

hybrid · Post by **hybrid** » Fri Mar 14, 2008 3:07 pm

All methods should explicitly state which type they take in their API docs. But yes, there are methods which take one or the other, so you have to be careful.

pippy2 · Post by **pippy2** » Sat Mar 15, 2008 5:42 am

ah, thanks xDan!

Edit: For some reason it doesn't interpolate the Z coordinate. I'll look into it more

Halifax · Post by **Halifax** » Sat Mar 15, 2008 7:31 am

xDan wrote:For some strange reason the quaternion classes take radians... Or is it: for some strange reason scene nodes use degrees?

Code: Select all

core::vector3df rotinterpol(const core::vector3df &actualCamera, const core::vector3df &orginalRotation, const f32 &interpolation){
	core::quaternion tmp;
	tmp.slerp( core::quaternion(actualCamera * core::DEGTORAD), core::quaternion(orginalRotation * core::DEGTORAD),  interpolation);

	core::vector3df ret;
	tmp.toEuler (ret);
 	return ret * core::RADTODEG;
};

EDIT:
I am curious as to why you are passing 'interpolation' as a constant reference. Correct me if I am wrong, but if you have SSE/SSE2/SEE3 they have 128-bit registers which makes the passing of float/double values by reference unneeded.

Otherwise, that is a good code snippet right there.

BlindSide · Post by **BlindSide** » Sat Mar 15, 2008 2:04 pm

MMX is for integers.

Halifax · Post by **Halifax** » Sat Mar 15, 2008 4:27 pm

BlindSide wrote:MMX is for integers.

Hmm, thanks for specifying that. I always wondered why my machine supported MMX and SSE.

Ah well, I will edit that post. (MMX removed).