Original subtitles

- [Instructor] Before we start animating our character,

I'd like to talk a bit about rotations

and how Blender and 3D application in general, and all them.

One key component to understand

is that orientation and rotation are two different things.

Rotation is the action or the motion

of rotating around an axis or multiple axes

while orientation is the result of those rotation

at a specific moment in time.

In this example, the orientation

is where the arrow is pointing at.

It's currently oriented straight up

because it has no rotation values.

So what we see per frames are just orientation.

And when we have different orientation in sequence,

we can simulate a rotation.

In this example,

I have a bunch of different arrow object

with different colors,

and they all have different orientation

and they will appear only on one frame at a time.

But if I played the animation

and I displayed those different arrows

with different orientation in sequence,

we feel like there is a rotating arrow.

Don't worry, you don't need to think about this

whenever you're animating.

What I'm just pointing out here

is that you can bring the feeling of rotation

or rotating motion in different ways.

And sometime your graph editor might not exactly reflect

the sensation of rotation you have

playing in your animation.

In this next example,

I have two arrows with exactly the same orientation,

but one is rotated by a 360 degrees on the X axis

while the other one has no rotation.

And if I insert a keyframe

for the rotation channels of those two arrows,

we can see that for the same orientation,

we have two different values.

So the rotation motion

would be a variation of those values over time.

But if in this case I do a 360 degree turn

over only one frame,

I don't see any rotation on screen.

So it's kind of a stupid example,

but my goal here is to show you

that even if the graph editor

is outputting a rotation motion,

the feeling on screen or in your output might be different.

And so it's very important

to check your motion path,

your arcs, and your spacing

whenever you are animating a rotation.

In the end, when we are manipulating rotation curve,

99% of the time it does make sense and it's logical

but sometime, especially with quaternions,

it won't be logical at all

and it's better to focus on the output

than how you got there.

Let's have a quick look to the different rotation types

and when to use them.

You can change the rotation type

of most item in the transform panel

by clicking in the rotation menu.

We will find quaternions rotation mode,

different Euler rotation,

and finally the axis angle mode

that we won't be talking about

because I never ever use it.

Eulers are very cool

because they are very easy to understand

especially when manipulating only one axis.

You can input the value you want

on the rotation axis of your choice

and the object will rotate around this axis.

For example here, around the X axis.

And the cool thing about Euler rotation on one axis

is that it's very easy

and logical to read in the graph editor.

To illustrate it, I will create a full revolution animation

around the X axis.

A revolution around one axis is a 360 degree rotation.

In this case, around the X axis.

I will then add an empty that I will parent to the arrow,

placing it on the tip of the arrow

and calculate its motion path

so that we can see the spacing of our revolution motion.

When we now watch the result,

we can clearly see the difference of spacing

around frame 15

where the curve has the most value variation

while around frame 0 and frame 30,

we have some easing.

So single axis Euler rotation curve

are super easy to read

and they are the perfect choice

whenever you are using a controller

that need to rotate only on one axis

like elbows, finger joints, foot roll, or knees.

Since Eulers are awesome,

why don't we use them all the time?

Let's input a bit of Y rotation into our arrow.

With this 30 degree rotation on the Y axis,

I changed the orientation of the arrow.

So how will be its motion now?

Will it still rotate around its X axis?

Well, not exactly.

It's still doing a revolution, but the axis has changed.

It's like we have given it a new orientation

before we start the revolution motion.

When we input a Y value, it's like we are changing

the initial orientation of our arrow

and while the arrow, it's still doing a revolution motion,

it's not doing it anymore around the same visual axis.

So why is that and how can we handle this?

Basically, to define the orientation of the arrow.

Blender is reading the Euler rotation value in sequence

and this is why we can change different type

of Euler rotation.

It will simply change the order of the sequence.

When I say in sequence, I mean that,

Blender will first read in this case,

the Z rotation axis,

then the Y rotation axis,

and finally the X rotation axis.

So basically, it start by the end.

For the XYZ Euler rotation, it will first read Z,

then Y and finally X.

For a ZYX Euler rotation,

it will first read X then Y and finally Z,

and this is why, in a way,

we feel like the Z axis and the Y axis

are giving a different orientation

while we are executing the revolution around the X axis.

But this is not exactly true.

And what happen if we input some motion

onto those two axes?

If I get rid of the rotation on the Z axis

and I'll input some rotation motion onto the Y axis

while maintaining the rotation motion onto the Y axis,

we can see we get a very weird motion.

And if I track now the tip of my arrow,

it's super strange.

I will get rid of the interpolation of my curve,

so that we have a linear motion,

and now if I mute the Y axis,

I see my classical rotation

but as I mute the X axis

and have only the Y rotation,

we can see that the rotation or revolution on the Y

depends on the value on the X

and it totally changed the behavior of the arrow.

So this is one of the main issue regarding Euler rotation

and it's linked to the gimbal lock.

To illustrate the gimbal lock,

we will use this Suzanne head.

I have three different rotation object.

Each object can rotate only on one single axis.

Red is X, green is Y, and blue is Z.

And I will parent the monkey head to the red one,

the red one to the green one,

and the green one to the blue one,

so that we can rotate them in sequence as with Eulers.

So rotating the X object will make the head rotate.

If I rotate the Y object,

both the head and the red one will rotate,

and finally, rotating Z will rotate everything.

I can easily create revolution animation

or any rotation animation around the X axis.

If I rotate a bit Y,

it will change the initial orientation of X,

thus, the revolution axis of the head.

The problem is with this evaluation of orientation

through sequence, if I rotate Y by 90 degrees,

then X and Z will be aligned

and from there, rotating whether Z or X,

won't change the behavior of our head

and this is what we call a gimbal lock.

We have isolated one rotation axis

in this case, the original X axis.

So to keep things simple, whenever you are using Euler,

just forget about the middle axis in the sequence

and use Eulers only for one or two

axis rotation controllers.

If your controller is supposed to rotate freely

around the three axes,

we will favorize quaternions.

When I need to choose

which type of Euler sequence I'm going to use,

I make sure that the first in the sequence

is the most important axis

the one that will rotate the most.

The one in the middle is the one I want to isolate,

the one I don't want to use,

and the third one is kind of a secondary axis.

On the foot roll controller, for example,

I will favorize the X axis,

and the Z axis will come in second position,

and I don't want to rotate around the Y axis.

For the shoulder, it's a bit the same.

The X axis will be the main rotation axis,

the Z the secondary.

I keep the Y axis available

because I know we can do find the tweaking,

but those are going to be very low angle adjustments.

Let's have a look to quaternions.

With my arrow selected,

I will choose in the Rotation Menu, Quaternions.

We now have four channels.

When I changed the value on X, Y, or Z,

the arrow rotate around the X, Y, or Z axis.

So it seems to behave as it did before,

but that's not exactly the case.

We generally use quaternions

from a value of 1 to minus 1.

If I set the value on the Y axis to 1,

I will see my arrow rotated by 90 degree around the Y axis,

and minus Y will be minus 90 degree.

But if I want to do a 180 degree rotation on the Y axis,

I will get stuck.

As I go beyond a value of 1 which I can do,

the arrow will go beyond the 90 degree angle

but there is a lot of easing

and the closer I get to 180 degree,

the more and more I need to increase the value

and I won't be able to get to this 180 degree angle

even if I push the value to the infinite.

If I now try to reach this orientation manually

instead of using the value inputs,

we can see our Y value changing as expected,

but also the W value.

These values that was 1 got to 0

and is now getting to minus 1,

while the Y value is also changing at the same time.

And this is because those are not rotation values,

but each channels equal an orientation.

And the values we are manipulating are the quantity

or the weight of each of those orientation we are giving

to set the final orientation of our object.

This is something that was super well explained

on the sociamix YouTube channel,

and I will put the link in the documentation.

Here, I have four different object,

each one has a value of 1

on one of the quaternions input.

If I set a value of 0.5 on W and on X,

you can see our object pointing down.

It's half way the orientation on W,

and half way the orientation on X.

I can repeat the process with W and Z,

and now the object will be facing us.

So I believe it can be a little bit abstract,

and it is also for me.

The benefit of quaternions

is that it will take the shortest path

from one orientation to another.

So if I use my initial arrow,

and I will key different orientation in space,

and I will then set my curve to linear interpolation

and calculate the motion path,

you can see those clean arcs

going from one position to the other.

While if I switch to Euler rotation

and key exactly the same orientation at the same time,

you will see that my curve change,

and it is kind of zigzagging in a smooth manner.

So the big strength of quaternion

is to not have any gimbal lock

and being able to go to one orientation

to the other flawlessly.

It's perfect for any tracking motion

like the head, the arm, the wrist, or even the spine,

but it has some limitation.

You can't do a proper revolution with quaternions,

it's very complicated to read the curve interpolation

since it's generally a mixture of all the channels

at the same time.

So the best way to deal with quaternions

is to track your arcs

whenever you are polishing your animation.

A classic bug with quaternions

is when you're trying to do a revolution

and see the orientation flipping.

This can happen often

especially if you don't go into a very detailed blocking,

and the simplest way to fix it

is to animate on once whenever you are transitioning

from one orientation to the other

and you have these flipping problem.

We will probably face these issues

in the incoming chapters.

Don't worry if it's a bit confusing,

you don't need to know all these theory

to become a good animator.

To summarize, we have seen that the orientation

is the result of any rotation

at a specific moment in time.

A sequence of different orientation

can give the impression of rotation motion.

You should use Euler rotation

whenever you are rotating around one or two axis maximum.

Eulers are awesome because they are very easy to read

and edit in the graph editor,

and you can do a full revolution with them.

But they can have confusing behavior

whenever you are trying to manipulate

multiple axes at the same time,

and you may also encounter gimbal lock trouble.

Quaternions won't have any gimbal lock.

They have a consistent behavior

no matter the orientation you are trying to reach,

but the graph editor can be a bit confusing.

You can't, or it's very hard

to execute in your revolution using quaternions.