All language subtitles for 3月8日 (7)

hey there

welcome to chapter 5 deformers

sorry I just get a little excited about using deformers

they're super fun

and can be used for a variety of different reasons

they can be used to clean up messy edges

minimum collisions

or drive one piece of geometry with another

deformers are also great for adding a little

extra prep into an animation rig

in this chapter

we'll take a look at a few different

examples on how we can use deformers effectively

but first let me show you as many deformers as I can

in under one minute

you can use a

blend shape to morph from one

target with similar topology to the next

you can use clusters to move a group of points together

and like most deformers

you can paint a map to control the area of influence

you can use a lattice to deform your

volume with a given number of

points on a rectangular prism

wire deformers can be used to drive a mesh with a curve

there are tons of non linear deformers that you can use

to bend

flare twist or create sine waves

you can use sculptiformers to mimic collisions

a shrink wrap to suck one geometry onto another

a standard wrap

deformer can be used to drive a high resolution mesh

with a low RES mesh

and in my 2020

you can have multiple drivers affecting your mesh

with a proximity wrap

you can even use a texture map to drive deformations

I'm showing all this not to overwhelm you

but to give you some

examples on what's available to you

we won't use every deformer in this chapter

but we'll take a look at a few of them

and I'll do my best to give you a

general overview of how deformers work

in the next lesson

we'll take a look at cluster deformers

in this lesson

we'll take a look at a few different ways we can use

cluster to formers

the cluster does not automatically

normalize weights like skin

clusters do

in other words all the influences in a skin cluster

when combined

add up to equal a weight value of 1 per vertex

clusters regardless of how many you have

function independently upon your mesh

this means you can stack them on top of each other

you can also have a weight value greater than 1

although I see very few reasons to do that

let's start out by

selecting our mesh and going to deform

cluster we've now created a

cluster

on our sphere

when you select an object and create a cluster

all the points of that object get attached

alternatively

you can select the points that you want to just form

and then create a cluster

form cluster now

every point that I have selected will be

assigned to that cluster

one thing to keep in mind when creating

clusters is that a deformation stack additively

in other words if I were to select both

and move them

you'd see double transformations coming from the second

deformer

I wanted to show you clusters first

because they are a very basic deformer

and many of the other

types of deformers share the same properties

for example

if I select my object and right click go down the paint

find my deformer

will go on the first one

and you can paint a map for how your object deforms

so if I go here to tool setting

I'm just going to start by replacing with a value of

0 and saying flood

so now the deformer has no effect

and then I'm going to replace with the value of 1

start to paint

so now I'm just going to smooth this

we'll see a nice fall off

so wherever there's a value of 1

the cluster will move 1 to 1

that vertex and then it will fall off

with the value that we painted

another attribute that most deformers have is called

envelope

so if I go here to my cluster I can see it

and it has a value of once to 0

so if I move cluster to see some deformation

and then if I were to take this and set it to 0

it's essentially turning off that deformer

if I go up here to the top to Windows

relationship editors

the former sets

I get this nice menu

and I can see all the deformers that are in my scene

if I were to expand this set

I could see the points that are associated with

this deformer

and if I expand the second one there are not as many

because we only added a few points to this cluster

over here on the right

we can see what objects they're associated with

so for instance if I were to move this

and then with the second cluster set selected

if I wanted to remove this object

from this deformer

I could just go ahead and click on it here

and if I wanted to add it back in watch what happens

everything comes with it

and that's because we didn't add points back in

we added the entire object

so remove and add

go ahead and set this back to 0

I'm also just going to go ahead and delete this second

cluster

let's take a look at what's going on in the Graph

Editor

by select my cluster handle here in the outliner

open up my Node Editor

and go ahead and say Graph Input Output Connections

here we get a little node network

this cluster handle

this is the transform node so I can use it to move my

cluster around

this shape is

this little icon here

and this is the the deformer itself

I press 2 you can see what is connected so we have

our

transforms going into the cluster moving it

and the result is going into

our geometry giving us the final output on our mesh

if I select my cluster handle

go ahead and close my node editor for now

and open the attribute editor

I can see my

cluster my cluster shape and my cluster handle

and I want to show you a little trick

that I think a lot of people don't know about clusters

in the cluster shape tab

we go to the weighted node

we can

see here the cluster 1 handle that's our transform

we can actually replace this with something else

say it's a control

or for this example let's just use a locator

and we want it to be

generally like where this deformation is happening

so I would pull this on a character

say a face we add like a little tweaker

it would be on the

surface of the skin

so I would orient it to that surface

and then I could go ahead and just use this transform

instead of the

cluster handle

to move

the deformation so go ahead and paste that there

now this locator is actually

my new handle

and it's oriented to how I oriented the locator

which is really useful in the outliner

if I were to turn on

shape display you can see my cluster shape

is under my locator handle now

and we

don't really need this cluster handle anymore

so I can just go ahead and delete that

and everything still works

so those are clusters in a nutshell

in the next lesson

we'll talk about how we will go

about layering multiple deformers on a single object

I'll see you over in chapter 5.3 Deformer Stacks

hey welcome back

let's make something fun together

you can either open up the block scene from the course

materials or create your own Geo

we're going to make this block dance

first go into one of your orthographic views

then go to Create

Curve Tools

EP Curve Tool option box

make sure you're in linear so that your

curve is a straight line

and then I'm just gonna make a little triangle

if I hold down the X key I can snap to my points

I'm just gonna draw this triangle over the head of our

block

and then we're going to color it

let's go ahead and make this yellow

I like to make all my main controllers yellow

so in the attribute editor

go to the shape node go down to drawing overrides

enable overrides click that on

then you can use one of the Maya default and

yellow is around here

or you could use RGB value

now let's get bendy

select your Geo

then go to deform

on linear deformers bend

now you can

go to the curvature middle mass drag and bend your

cube

and let's snap this down to the origin here

and set our low bound to 0 high bound to 2

so we can bend from the base of the object

for this example I'm actually gonna create

two bend handles

so I'll select my Geo

and hit the G key to repeat the last command

and then I'm gonna do the same thing I did to the

last bend handle to this one

except for this bend handle

we'll want to rotate at 90 degrees in y

so it can bend in the other direction

if you chose to use your own Geo

you might have to set a different value for the high

bound depending on the height of your object

I'm just going to get organized here

I'll rename some things C

Block

Control

and we can make this one our bend wand

because it bends left and right

we can call this

C bend

left

right

bend

handle

and then copy this for the next one and

replace that name with

front back

to rename the actual deformer

go over here in the channel box

I'm just gonna paste my handle name but remove handle

and I'll do that for the other one as well

bend one

just replace this name

let's have our control drive the bend handles

select the control

I'm going to change the pivot

so in other graphic view press d to enter pivot mode

press and hold X to snap to the grid

and your pivot is now at the base of this triangle

let's now bend our block

do you remember set driven keys

make sure you're in the animation menu

put a key

set driven keyframe

option box and load this control as your driver object

and we're going to use translate

z as the driver attribute

so forward and backwards

and for the driven we want to select our deformer

make sure you select it in the channel box

and we'll drive the curvature of this deformer

so go ahead and set our keyframe

now let's bend it negative 90

for the forward

when you do this

be sure to move your driver attribute first

otherwise

your driven object will just snap back to the previous

keyframe so we'll select it again

set the curvature to negative 90

and we'll have a keyframe

with the driver at 4

so let's move it back now to negative 4

and we'll set the

curvature to 90

and then we'll make a keyframe

now we have forward and backwards movement

let's do the same thing for the left right side

except for this time we'll use Translate

X as the driver

I'll fast forward through this part a little bit

but basically I'm just doing the same thing as I did

for front back on

the left and right side

next let's go to the

control and set some transform limits

so if we go to the transform node and go to translate

we'll set some limits on the minim max values for Z

and X once we're happy with our transform limits

we can go ahead and move this

control around to see what it looks like

if it's not looking right

we might want to change our deformation order

this way we can change which bend deformer is evaluated

first you can right click your geometry and go down

to inputs to see

what the formers are connected to your geometry

middle mouse drag them to rearrange

now our

rig should favor the backwards and forwards movement

over the left and right

because of our deformation order

let's go ahead and set this back to 0

and then we can add another level of deformation

let's give our object some twist

select our object

go to deform

nonlinear twist

we can load our twistoformer in as the driven object

and what we want to drive is our end angle

so we want to rotate it 360 degrees

and for the driver for this one we'll make it the

controls rotate y

so when the control rotates it's going to be negative

360 and it's actually the opposite direction of twist

so we'll set that to 360

and have a keyframe here

and then we'll go ahead and move over to the other side

so set our control to 360 and our twist to negative 360

and we'll put a key

there

and now our control drives the twist of our block

let's see what happens when we bend the block forward

and then apply some twist

not so great is it

that's because the twist is being applied

after the bend

if we right click our Geo

go down to inputs

all inputs we can change that

so let's middle mouse

drag this twist all the way here to the front

go ahead and close this

now our twist is being applied before the bend

so we'll still move around

and the twist is being calculated first

so go ahead and zero this out real quick

I'm just going to

clean up the channel box on my control

to make it a little bit easier to animate

so if I select the channels I don't want

I can then go to lock and hide selected

and now the animator can't play with them

let's add one last deformat to this setup

select your Geo

go to deform nonlinear

this time we'll select

squash

so we have now

the capability to do some squash and stretch

let's move this down to the origin just like we did

with the bend handles by pressing X

and we'll change the low bound to 0 and high bound to 2

and now it will squash and stretch from the base

let's go ahead and add our squash handle

as the driven object

and we'll want to drive the

factor with translate y

so go ahead and set a key here

now if I go into my side view

let's see what the factor of one looks like

so let's bring it up to 1

and we want our control to sit about here

so if I move it there

it's going to snap off but that's okay

I just want to figure out

where to put my control

so now I go ahead and set that factor again

and set a keyframe

now we go down

and let's see what a factor of negative one looks like

so I bring my control down to here and we'll set this

factor to negative one again

and hit a keyframe

now

I move up and down

I get some squash

set this to 0

we're done setting driven keys for now

so let's go ahead and close this

do a quick check on your animation

if your set driven keyframes have any

ease in or ease out

we'll want to change that

select them

go into the graph editor

and select all your keys

and click on this icon to set them to linear

animators prefer to be in

control of the E's in and ease out

and they won't be accessing our sub driven keys

in the bottom right hand corner of your screen

select your preferences

go to animation settings

and change your tangents to be linear

by default that way when you create a set driven key

it's always linear

let's go ahead and set some transform limits for our

new attributes

so translate y we know can go to negative 3

and positive six

and our rotate y negative 360

and positive 360

let's take a look at what happens when we move our

control

in conjunction

width translate y

doing some weird stuff again

so let's change the deformation order

and we'll put our squash up front

so the squash is the first thing that happens now

to move this now

it squashes

or stretches before we

bend I may have lied when I said

we're done setting drawing keys

you notice

when I stretch all the way up and bend forward

our

bend handle doesn't go all the way through our object

so we'll want to increase that

there's one of two ways we could drive this

one thing we could do is drive it with our

control

or we could actually drive it with the squash height

directly from the deformer itself

so we'll do that

let's also load in our bend handles

and using the factor of the squash

we'll drive the high bounds of both our bends

so we'll set a key there

bring it up

and set our high bound to 4

and we'll key that

and then bring it all the way down

and set a key at a high bound of value one

there are two more things about this setup that are not

completely satisfied with

one is if we stretch all the way up and bend forward

our object goes past the ground plane

I would kind of like that to stop so it only

goes to a degree of 180 instead of 360

the other thing is that when we squash all the way down

we get some crashing Geo and I don't like that either

we can fix this by creating a more complex node network

before we do that

let's move on to the next lesson

where we'll discuss the difference between pre

and post deformation blend shapes

thanks for watching and I'll see you over there

hey everyone

in this lesson

we'll take a look at what happened when we add

blend shapes to our block rig

we'll look at pre

and post information

blend shapes and talk about

different ways we could use them

before we start adding blend shape targets

let's actually make some blend shapable geometry

to do this

I'm going to show you a couple fun

deformers along the way

I'll speed through this part

but basically I'm just gonna create

two spheres I'm gonna combine them

I'm gonna remove some pieces and then

bridge these edges together so that we get a nice

rounded shape

and this is essentially what we want to use as our

target

but watch what happens when I create a blend shape

from our target Geo to the mesh

it won't let us because

the topology is different

so what I'll do now is duplicate our mesh

and use this as the target Geo

but we want it to look like our pill shaped object

so how can we do that

I'm going to start out by

scaling this down just a little bit

and then

what we want to do is use a shrink wrap deformer

so select your target

and then select the shape you want to shrink wrap to

just going to rename this real quick

so again for shrink wrap you select the driven object

then the driver

go up to the deform menu

select your shrink wrap

we'll just want to change a couple settings

so let's use the projection method closest point

so our target points go to the

closest point on our rounded object

and then let's also smooth this out a little bit

so if we set this to 4

I wouldn't go past 4

because you could think of it as like

a subdivision level

and that would just get very slow very quickly

with our envelope set to 0

go ahead and apply a delta mush deformer

this tries to maintain the

object's original

shape when the delta mush was applied

to get around that turn on inward gun straight

and then crank up your

smoothing iterations to evenly distribute

our edges now that we have a nice smooth object

we can go ahead and delete our history

and we can also remove the build

geometry as we'll no longer be needing it

we're now ready to create our blunt shape

first select your target

then the object you want to deform

go to deform

blend shape and we'll go to the option box here

in Advanced Settings

choose pre deformation and hit create

and you can just say no

we do not want to use post deformation order instead

if we look here in the channel box

we can see that our

blunt shape is applied to the front of the chain

and we can

activate our target if we select it in that middle

mouse drag now if we move our controller around

we can see the effects of the

blend shape are being evaluated

before our fun little twist and squash and stretch

I did just notice one thing on this twist however

looks like our twist is being applied after our squash

so let's just go ahead and move this up one

now

the

controls rotation will get the full effective twists

no matter what the squash value is

because this blend shape still exists in our scene

we can modify the points to change the target

and you can see it is reflected on our geometry here

and it retains this shape change

I also want to mention

that I have transformations on my target geometry

if I were to freeze them

that would essentially offset my

point information

to the value of what my transform was ineffect

that would offset our mesh as well

and we don't want that

I also want to point out that you can paint

weights on your blend shape target

so if we go down to paint

blend shape go to your blend shape

now select the target you want to paint

and

I'm just going to replace some of the weights and then

smooth them back out

now we've removed

the top part of the blend shape from our block

let's duplicate our target

and make a post deformer blend shape

first I'm just going to turn off

our

pre deformer blend shape by removing the envelope

so we have our cube again

and then I'll select our new target

and then shift select our geometry

go to Deform Blend Shape option box

go to advance

and we'll say post a formation and hit create

now if we were to take our

control and deform this geometry sum

then we want to apply our new blend shape

it's going to overwrite everything

leaving only the target

a good standard for

blend shapes would be to think of predeformation shapes

as facial blend shapes and post deformation

as corrective shapes or shot sculpts

in the next lesson

we'll take a look at how we can advance our no network

skills by

cleaning up some of the functionality in this rig

thanks for watching and I'll see you in the next lesson

hey everyone welcome back

in this lesson

we'll learn how we can modify our node network

to improve the functionality in this rig

if you recall from the third lesson

I wasn't completely satisfied with the way

this is functioning

right now it's bending past our ground plane

and it's squashing too far

select the front

and back bend handle

and graph the input and output connections

with no nodes selected

press P this pins your nodes

preventing them from moving around automatically

when we start to make connections

I'll also select some nodes that I don't want to see

and remove them from my grasp

by clicking this icon with the minus sign

then I'll space out my remaining nodes here

when we bend the block forward and stretch upwards

I want the curvature to be half as much

to do this

will need to remap the output of our set driven key

we can do this by creating a set range node

let's connect the translate y from our control

into the first value value x on our set range

this is the value that we'll want to remap

we know a y value of

0 to 6 controls our stretch

so let's change

our old min and max to 0 and 6

basically what we want to do

is take our curvature and divide it by 2

so we'll create a multiply divide node and connect our

curvature to the input 1 x

and we'll set input 2 x to 2

we'll also want to make sure our

operation is set to divide

now if we were to connect this into the curvature

it would take our

setriven key and divided by two

now our curvature is half of our subtrab and key value

but this isn't exactly what we want

we only want to divide by 2 when translate y is at 6

we don't want to divide our curvature

when there is no stretch

or y equals 0

I'm going to pin these nodes and rearrange a little bit

here

let's set our new min

x to 1 and our max x to 2

now when y equals 0

our node outputs 1 and when y equals 6 it outputs 2

connect the outvalue x into input 2

x on our multiply divide node

awesome

now our setup won't pass the ground when we stretch

but what about the squash

again we'll want to divide our curvature by 2

but this time we'll drive it by a range of values that

control the squash

it gets a little trickier here

because our squash range is different than our stretch

range

stretches from 0 to 6 and squash is 0 to negative 3

we'll need to keep

0 as our old min and set max to 3

because our max cannot be a negative value

I set the new mini max to 1 and 2

just like we did for stretch

to keep our squash values from being negative

we could just multiply by negative 1

but I want to show you this little trick

to get the absolute or a non negative value

you'll need to create

two multiply divide nodes

for the first we'll raise our

translate y to the power of 2 or square the number

now it's positive value

make sure the operation is set to power

for both multiply divide nodes

let's then connect the output from our first

multiply divide node

into the first input on our second one

for the second

we'll raise to the power of 0.5 to get the square root

now we can connect the output from our square root

into the set range value Y

be sure to connect the output of our multiplied divide

that has the absolute value we just created

now let's connect the out value y

into our input 2 I of the multiply divide node

we also want to connect our curvature

into the input 1 y

I'm just going to also pin these nodes while I'm here

now our multiply divide node has two connections

and we know that the output

X is working for our stretch

but what about our squash

if we connect our output y

into the curvature

that's what we want to see

so now our squash is working

but if I try and do stretch again it's

not really working how it should be

so how do we fix this how can we use both the values

well we need to create a condition node

so if we go here and type in condition

we can create our node

this allows us to compare two values

using the first and second term

we'll want to compare our controls translate y

to 0 to see if it's positive or negative

so we'll connect that to our first term

and change the operation to greater than

now if y is greater than 0

we'll want to use our output X

so connect that into color if true R

and connect output y into color if false R

then go ahead and connect the Outcolor R

into our bends curvature

also go ahead and delete this

extra unit conversion node as we're no longer using it

now look at that

our setup works for both squash and stretch

why don't you take a second

to try and do this for the left and right

side

here's a little hint

we only need to create

another multiplay divide node

and another condition node

we can leave these the same

and instead of using the front and back set driven key

we'll use the left and right

set driven key for extra points

you can go ahead and add some attributes to

control the shape of this object

maybe add some attributes for the start

smoothness and end smoothness to

change the shape here

or maybe even just add attribute for the blind shape

so you can turn that on and off

and we can get this nice random shape

and these points I speak of are pretty much fictitious

so go ahead and do it just for fun

all right that concludes this lesson

in the next one

we'll take a look at how we can use a lattice to

control the squash on our bike's tires

see you over there

hey what's up

welcome to the final lesson in this chapter

in this one we'll take a look at lattice deformers

and how we can use them to drive the

squash on our bikes tires

but first

I'll show you a very simple example on a sphere

so if we create our sphere

we can go up to deform and create a lattice

in the deform menu

lattices can be used to deform a mesh

by moving around these lattice points

you can increase the division

to get a more detailed lattice

I use these all the time when modeling

it makes it easy to get

clean deformations on a high resolution mesh

but the fun doesn't end there

lattices are unique deformer

because you can actually deform them

with other deformers

even a skin cluster

let's go ahead and open up our bike rig

from the end of Chapter 2

first thing we want to do is select our tire

and go to deform lattice

now we have a lattice and we can move

these points around

to deform our tire

select the lattice and lattice base in that liner

press shift I to isolate select right click

go to lattice points and then select the top row

then create a cluster deformer

select each lattice object press d to enter pivot mode

then hold V

to snap your pivot to the cluster you just created

you can go ahead and delete this cluster now

as we only created it to find the

center of the top row next

let's go into an orthographic view

and move our lattice dipormer

down to the area of the bike we want to squash

make sure it sits below the rim

if I kiss this bite

you can actually just hold X and snap to the grid

one unit above the ground

I didn't plan this to be one unit

but it actually works out quite nicely

as you'll soon see

now go ahead and scale the lattice

so that the top two rows contain the tire Geo

notice that

I'm applying transformations on both the lattice

and the lattice base

if you don't move these together

your geometry will be deformed

and we don't want that yet

in my orthographic views

I'm going to sculpt my lattice points

so that it looks like my tire is squashing

most of this deformation

will come from the top two rows of my lattice

I'm

creating a locator to use as a visual representation

for a half unit

so I'll move this over

and set translate y to point five

I'm using one unit for my tire deformable area length

and half a unit for the squash length

because we'll need to do some counter animation

to make a believable

ground contact

these values just make it easier to do

now if you select the lattice and base together

and move them up and down

you can start to see what our tire

squash deformation is going to look like

go back

into an orthographic view and move the lattices back

down to the ground plane

by holding X to snap to grid

then press Ctrl G to group them together

I'd like to move the

group's pivot to the center of the top row

to do this I'll create another cluster

just to help us find the correct center location

I'll snap this locator here as well

as we'll want to use it for measuring the distance

with nothing selected

press shift I to return from isolate selected

then select your group and locator

press shift I again to isolate them

now snap the group's pivot to the locator

just go ahead and rename my group here

and then we'll rename this locator to C Back Tire

Start Locator

and then I'm going to go ahead and duplicate this

and we'll have an end locator as well

and we can use these

to measure the distance of our tire

squash from the ground

so go ahead and move the start locator up one unit

to create our measurement

let's open up our node editor

first I'll add my locators by middle mouse

dragging them into the editor

the node I want to use is called distance between

so press tab and start typing that name

to create the node

you can right click it and go to show all attributes

to see what this node has to offer

we will tell the locator's position

by connecting their world matrix

into the distance nodes in matrix 1 into

attributes

we'll want our

start locator to follow the body of the bike

so let's show our

secondary controls and find the innermost cog control

constrain our locator to this

just reset my

settings and make sure maintain offset is turned on

using a set driven key

let's now have our distance drive

the lattice groups translate y

so switch over to the animation menu set

go to key

Set driven key option box

then let's load in our

distance between node as the driver

and scroll down to use

distance as the driving attribute

for the driven

we'll load in our lattice group

use translate y is the driven attribute and hit

key

we can actually just go ahead and collapse the node

editor

for now

currently

the distance between our two logators is one unit

translate the Cod control down

negative point five and translate y

our distance becomes half a unit

now set the lattice groups translate y to 0.5

so that our tire rests on top of the ground plane

after you set your key

if you play with the cogs translation

your tire appears to

squash on contact with the ground plane

next we can go ahead and give our squash setup a

control and constrain it in our rig

we'll go ahead and close the SDK menu

go into perspective

and create a nerves primitive circle

set the sections to 4

the degree to 1

then rotate 45 degrees

so we have a square

resize regroup reposition then rename

let's give this control a unique color

by enabling drawing overrides in the Attribute Editor

then

let's group our end locator and lattice group together

snap our group's pivot to the locator

we'll rename it

and use a parent constraint

to have it follow along with our new control

now we can raise and lower this

control to get some tire squash

now we want this control to follow along our bike

but we don't want it to

translate up when our bike moves up

we want it to always remain on the ground

no matter where our bike is in space

so what we can do is parent constrain the

control group to our car

but

we'll want to change a few of the constraint settings

first we don't want this to orient

or move upwards

that said

let's uncheck the box for rotation and translate y

go ahead and hit apply

and now our control follows along the bike

on the ground

however

it's not orienting properly

we want it to always be aiming towards our front tire

but we still want it to remain flat

let's create a locator and we'll rename this to C

Back Tire Aim Locator

then let's parent constrain it to our carb

remember to reset your settings

because we'll want to constrain it in all axes

next

let's create an aim constraint from our locator to our

controls constraint group

we'll want to turn on maintain allset

our control is looking down

Z towards our locator

so we'll set the aim vector to Z

a vector we can leave is y

and we'll change the world up type to cnup

which is essentially the same thing as our

current setting

also we only want to rotate in y

now our control

always aims along with our bike

but remains flat on the ground

while following underneath the back tire

let's take a closer look at our decoramations

I move up and down

everything looks okay

but what happens if I bank and rotate to an odd angle

uh oh

it looks like the edges are clipping somewhere

to see our lattice base

you need to select it in the outliner

if we zoom in closely

we can see when the tire is positioned

outside of the base

we get some nasty results

simply select your lattice and base together

and scale an X

and now we no longer have jagged edges

just two more things left to do now

first let's clean up our rig

we'll start by hiding our locators in lattice

then I'm going to group them all together and call it C

Tire squash group

we compare this to our global

control

now the squash group is along with the bike in world

space

and we can offset the bike from the

squash using any of the other controls

the last thing we want to do is fix our global scale

I know it's not going to work properly

usually when you create some kind of measurement

you'll need to compensate for this

if I set the global scale to 50

and look at the tire squash

I can see that my

control is not properly colliding with the mesh

to fix this let's open up our node

editor and graph the output connections at

one of our measurement locators

to find the distance between node

let's take a look at this connection here

I'll create a multiply divide node

so that we can divide our distance by our global scale

connect the distance into input 1

x

let's then middle mouse drag our global control

into the node editor

and we can connect the global scale into input 2 x

you can connect the output

X into the input of our set driven keyframe

but be sure to set the operation to divide

now our squash should work as expected

why don't you take a little time

to go through these steps again

for the front tire

to see our squash in action

you can open up the scene from Chapter 4

go to File Reference Editor

then select the Bike Reference

then at the top go to Reference

Replace Reference

and navigate to where you saved your latest bike setup

you should see the new tire

controls appear in your seam

lower the cog slightly

and just like Major Tom

your tire should come in contact with their ground

control select your motion path and dial in the U value

make sure the squash depermission

stays at the base of the tire

and that's it we're done

thanks for watching

and I'll see you again in the next chapter

where we will take our first steps into the world

descripting in Maya