All language subtitles for 04-06-Constraints

- [Pierre] So far, using the layer method

we have been able to create
the space motion for our robot.

But how do we get to this,

where every part of the robot

are moving in reaction to the body motion?

We could use the same method
and start with the main body

working first on the Z location curve

and then on the rotation,

and then go ahead with the hips, the head,

and everything that is attached to it.

But what if we had a
solution that would allow us

to source the base motion we have created

to generate those additional motion,

finding method that
will allow us to iterate

or modify the animation
on the fly with ease?

We can do it by using a
technique I will show you

in the next video.

But to do so, we need to learn a bit

about the base constraints in Blender.

I've created a blend file
with a couple of objects,

including arrows, that
will help us identifying

the orientation they have.

In Blender, We can find
the Object Constraint

under the Constraint tab.

We will find the same
constraint for the rig or bones,

but we will see that in the next video.

The list of constraints is pretty big,

but in the end we will
just use a few of them.

Mostly, the Copy Transform constraint

and some tracking constraints.

Constraints will allow us

to modify the behavior
of an object or a bone

using another object or another bone.

To add the constraint, we
can simply select the object,

go to the Constraint tab
and select, for example,

the Copy Location.

As I've just added it, we
can see that the icon is red.

It means that the constraint
is currently not working

because the owner is not
constraint to anything.

So we need to choose a target,

and I will choose the arrow number one.

As soon as I do, we
can see our small arrow

snapping onto the large arrow.

The small rural object

is now copying the location
or position in the world space

of the large arrow.

Remember, that as an object,

the position or any transform

are performed on the origin of the object.

And by default, a newly created constraint

is using world space for both
the target and the owner.

This way, whatever we do,

the owner will be on top
of the target in our scene.

If on the single object,

we switch to local space to local space,

we won't see that much of a difference.

Because by default,

the local space of a single object

is aligned with world space,

as we have seen in the local
space and world space video.

So the only way to see the difference

is currently to create
a parent to this object.

Now, if I switch back the constraint

from local space to local
space and move the parent,

we can see that the object is moving,

but it only follow the
location of the target.

Whenever I rotate it, nothing's happened.

If I now switch back from
world space to world space,

it will override the parenting

and the constraint arrow

will be snapped onto the target arrow.

Let's get rid of the parent,

switch back to local space to local space,

and use the offset.

It will allow us to still be able to

move the constraint object,

and any transformation
generated by the constraint

will be added on top of the
local space of the object.

The Copy Location constraint
will only affect location,

rotating or scaling the
object won't do anything.

While if we were parenting
the object to the other,

then it will follow any transformation

the first object does.

The other copy constraint behave the same.

If I add a Copy Rotation
constraint and rotate the object,

the other one will follow.

But moving it or scaling
it won't change anything.

And if we had a Copy Scale,
I think you've guessed it,

moving it or rotate it
won't change anything,

while scaling will scale both objects.

The Copy Transform constraint

will currently perform a Copy Location,

Copy Rotation, and Copy
Scale at the same time.

We can no longer move the target

unless we switch the Mix mode

to Before Original or After Original.

But I won't go further into this

because we won't need all those options.

Some very useful constraints
are the tracking constraints.

You're already using one

which is the Inverse Kinematic constraint,

which is a tracking constraint too.

But here, we will use other constraints.

So I have my arrow object,

I have created a target object,

let's add a dump truck
constraint to our arrow

and choose as a target the target object.

You can use the eyedropper
in the constraint

and then source the object
directly in the 3D viewport.

As soon as we select it,

we can see our arrow slightly
rotating to point towards it.

And as we move the target,

our constraint object will follow it.

It's a super useful constraint
to rig eyes, for example.

It's a pretty easy constraint to be used.

By default, it will track
along the positive y-axis.

If we switch to the positive z-axis,

we can see our object rotating

so that it's positive z-axis
point toward the target.

If we do the same with the x-axis,

the object will shift again.

Choosing the minus y-axis will
flip our arrow orientation

but it will still the
pointing at the target

using its y-axis.

The locked track constraint
will kind of behave the same,

but this time the object
will be all to rotate

only on one axis.

We still have to define the track axis

and the locked axis will be the one

we are allowed to rotate around.

So in this case, I can see the green arrow

pointing toward the target,

but the object only rotate
around the blue arrows,

the z-axis arrows.

If I switch the track access
to use the positive x-axis,

we will see our object shifting

and still rotating along its z-axis.

This is the constraint I've used

to rig the sensor of the robot

so that it follows the target.

The ring with the sensor and the sphere

each have a separated
locked track constraint

allowing us to animate the
sensor by just moving the target.

It's the same for the mini gun arm.

To summarize, we have seen
that we can use constraints

to move or transform an
object using another one.

Constraints will override the
parent-child relationship.

We can constraint multiple
objects using only one object.