Original subtitles

- [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.