Setting up the arm for squash and stretch

00:03

With the spine, we were able to check when it was stretching by using the curve.

00:08

But obviously, we can't do that with the arm.

00:11

So we need to find a different way of getting its length.

00:14

And then finding out when it should be stretching,

00:17

let's build some of the basic nodes first.

00:20

So jump back into the node editor

00:23

first, we need a new multiply divide node and this will act as a scale factor node.

00:29

So rename it to arm left scale factor

00:33

and open it.

00:35

Let's have a quick look back at the spines network.

00:39

We used the curve info node to give us the length of the curve.

00:43

But we could also use this to check when it was stretching

00:46

and convert that into a usable value too. With the scale factor node here,

00:51

let's go back

00:54

and change the operation to divide.

00:57

So we need to find the arm's current length,

00:59

but we already have everything we need to find this.

01:03

Let's find the arm joints.

01:05

If I select the lower arm joint here

01:08

we see the distance.

01:09

This is from the upper arm joint over here in the attribute editor.

01:14

This is because we corrected the orientations.

01:16

So the Y axis is pointing down to the lower arm.

01:20

So make a note of this value.

01:23

Now select the hand joint.

01:25

And again, we can see the distance this is from the lower arm joints here.

01:30

So remember this value too,

01:33

all we need to do is add those together like this. And we get the arm length.

01:38

Let's bring back the note editor

01:41

and add that into the scale factor node

01:44

in both input one X and input two X.

01:48

So that's stage one.

01:50

Now we need to check for when the arm is stretching.

01:53

So when the control here is moving away from the arm,

01:57

what we can do is get the distance from the arm IK control to the root control.

02:02

And when that goes above the arm's length, we know it should be stretching.

02:07

Let's bring the root control into the node editor.

02:11

Now we can't use the IK control directly

02:14

because it will cause some evaluation issues.

02:17

But we can use a dummy node instead.

02:20

Let's just use a locator.

02:23

We can duplicate this one,

02:25

the arm left IK swap position one we created earlier in the workshop

02:30

and simply match it to the hand joints, position and orientation.

02:36

Let's rename this to end pause

02:38

because it will indicate the arms end position.

02:42

So we have our two nodes now that will mark the start and the end of the arm

02:47

create a new node. Now this time a distance between node.

02:52

This will do exactly as the name suggests

02:54

and tell us the distance between two points

02:57

call this arm left stretch distance.

03:02

Connect world matrix zero from the root control

03:07

to in matrix one

03:09

and world matrix zero from the end position locator

03:13

to in matrix two,

03:16

the distance attribute here will output the distance

03:19

between these two and keep it updated.

03:22

So we will see when the arm should be stretching,

03:26

Connect that to input one X on the scale factor multiply divide node.

03:32

So here we have the distance value. Now

03:36

if I move the arm control away,

03:38

you see it's increased.

03:41

OK, I do that.

03:44

So this is set up and will output a value of one when both values are equal.

03:50

Now we need the two blend color nodes.

03:53

Let's just duplicate the ones we created for the spine

03:58

and rename them to arm left instead.

04:02

So the rest of the setup is exactly the same as the spine.

04:07

Let's connect the main attributes to the blender attributes. Next,

04:11

bring the arm I care control in

04:14

and connect stretchiness

04:17

to the stretch blend nodes, blender attribute.

04:20

Now connect

04:22

IKK switch

04:23

to the stretch I

04:24

blend nodes, blender attribute.

04:28

So there we have our two main controls.

04:31

Let's make this a bit bigger.

04:34

We now need the main scale amount.

04:36

So connect output X from the scale factor node

04:40

to color one hour on the stretch blend node.

04:43

So that will blend between the scale value here and one.