Rigging Mechanical Objects in 3ds Max

GEORGE MAESTRI: OK. Hi, I'm George Maestri. Today we're going to talk about using rigging tools for mechanical objects.

So it's going to be part slides, part PowerPoint, part hands-on. I'm just going to show you some basic tools. I would consider this, probably, a beginning to intermediate course. So if you're an expert rigger, this will just be review for you.

But how many people actually do any sort of rigging in their work? Oh, a lot of you. OK. So I'm just going to go through some tools, some advice, and probably 50% hands-on. So shout out questions if you have them. So let's just go ahead and dive into it.

So let's start off with the first slide. So the course outline, obviously, you read it if you signed up for it. But basically, we're going to learn some techniques for rigging mechanical objects, things such as vehicles, machines, that sort of thing.

Now originally, rigging tools were created mostly for character animations. So a lot of those tools do transfer over to things such as mechanical objects. A lot of this is used in VFX.

My personal history was I started out in character animation. And then I'm moving more into CAD and 3D. And I'm finding these tools are still very valuable.

So our outline here is-- we're going to just do a quick intro to some rigging concepts and ideas on how to work. And then we're going to create some basic rigs using some simple tools. And sometimes I find the simplest tools, actually, are most effective. And I'll show you some ideas for that.

Then we're going to understand some ways to control rigs. I think rigging controls are really important. And I'll talk a little bit about that.

And we're going to go into some more advanced rigging tools. Obviously, I can't cover the entire suite of tools that 3ds Max has. I'm just going to go on a high level and cover the ones I think are most important. But there's tons of tools out there. And then we'll wrap up and go from there.

So a little bit about me. I started off in character animation, spent a lot of time in Hollywood. And then around 2008, 2009, I went full time with lynda.com. And Lynda was an old friend from the animation world.

And I did a lot of character courses at first, but now we're doing tons and tons of CAD, architecture, industrial design, that sort of thing. And so I'm kind of pivoting and learning to use all my skills in those areas as well.

Now couple of years ago LinkedIn Learning bought lynda.com. And so what we're doing is we're slowly transferring our library over into the LinkedIn Learning ecosystem. So if you are a LinkedIn member, you can have access to that. And so, also, I unlocked a couple of our rigging courses on LinkedIn Learning if you want to take a look at those.

So what is rigging? Well, the very basic term-- it's just basically a process that makes complex assemblies of objects easier to manage. So when you have-- originally it was associated with character animation. And you had a lot of things on a character that you needed to move and control and animate.

And one of the things we found over the years is, as we started rigging more and more complex characters, is that we needed to have rigs that were animator-friendly. And so somewhere in the 90s everything forked off into-- there were animators and then there were technical directors who built all the rigs and stuff like that. And they did all the technical stuff.

But basically, we're building a rig so that it will be animated well. So all the tools here that we have for rigging characters can go directly over into something like rigging a car, or landing gear, or an excavator, or really anything like that.

So the most important thing to remember is that a rig is a user interface. So you have to use user interface concepts when you're thinking about what to do when you build a rig. You do want to automate as much as possible. If you can have just one control that controls three or four different things-- that it will always be animated together-- then yes, do a control. But it has to be animator-friendly.

So if one of those things that you're controlling can be turned in the opposite direction for some reason, then you have to give animators that control. But you also have to kind of restrict them. So if your machine doesn't bend beyond 85 degrees, try and limit it to that motion. So try and keep it as realistic as possible.

You don't want the animator to bend your rigs out of kilter or give them the freedom to animate something that isn't really going to be-- that really is going to be able accomplish in real world. So a lot of these things that will animators for demos, that sort of thing. So you want to make it as realistic as possible and allow for realistic movement.

And then, as with any user interface, you want to try and make it easy to use. So you want to add in color-coding, naming schemes, all of that sort of thing, can really help with rigging. So let's talk a little bit about creating rigs. So when you create a rig, the first thing you need to do is just understand how the object moves.

Towards the end here we're going to have just a short thing about landing gear. But one of the things I've found is I kind of dove deep into landing gear. And there's like thousands of YouTube videos on landing gear. And you can just sit there for hours watching 747 and fighter jet landing gears. And they all come out in these really interesting ways.

And you have to understand how that object moves if you want to rig it properly. So you need to understand how the parts are connected. How do they interact? What drives what? Where's the motor? And where's the support linkage? Is the wheel driving the object, or is the wheel just rolling?

All of those sorts of things you need to understand as you go into that rig. And then you also need to understand what limits motion. Will your arm only go to 85 degrees or whatever?

And then you also need to get technical. Now, as a character animator I just-- if it looked good, it was good. But as you get into more technical types of animation, you need to respect that technical aspect of what you're animating and what you're rigging.

So you may have to talk to the engineer or the designer for clarification. It's like, does this move first, and the other thing move second? How does this unfold?

So you need to kind of get a sense for how it moves. And a lot of times you're working with things that are kind of virtual. So they haven't been built yet. They haven't been prototyped. So you really need to have clarity as to how it moves.

Look at reference. Again, I geeked out on landing gear the other day, just looking at them. And understand how similar objects move. So again, look at reference. Understand your subject matter before you dive in.

And then as you go into your rig, you need to decide what exactly needs to be animated. What do you want to control? And what do you want to follow?

So what are the main motions that you are animating? What are the secondary motions? What objects are flexible? Are there hoses, springs, that sort of thing? What objects are rigid? And so on.

So again, I just want to reiterate-- make it animator-friendly. The rig really is the user interface for the objects being animated. So it has to be easy to use.

You want to make sure you observe good interface and design practices. So make your controls easy to spot. Color-code things. Use shapes to define function and so on. So when you look at this object, you want to make it as easy to understand as possible.

So when we create a rig, one of the things we need to do is we need to understand things such as controls. What exactly are we animating? Now what I like to do-- what what's typically the norm in rigging-- is to abstract the actual controls from the geometry. And I'll get to that in just a little bit.

But you want to have controls that are, again, easy to understand. And we have a couple of different classes of these. So you maybe have on-object control. So we click on it, and it moves an exact object.

You could have multi-purpose controls. So you could have one for rotate and scale and all that. So as you move at different directions, it does different things. And then you can also create control panels. Now this is used a lot in character animation for facial animation. But you can also use it in mechanical animation.

And then finally, when you create a rig, you want to make it solid. So test it through all ranges of motion. Make sure that it doesn't break. Because it's a real pain to have an animator come to you and say, this isn't working. And then you have to unwind it and then redo it. And then you've lost time and effort.

OK. So that's the theory portion of the program. So let's take a look at some basic rigging tools. So Max has a number of rigging tools. Some are really simple and easy to use, direct. Others are a little bit more sophisticated.

Now my rules of thumb are keep the rig as simple as possible. If you can do something with a simple tool, and it has the effect desired, then go ahead and use that tool. Simple is usually better.

The complex tools that 3ds Max has-- they're really powerful. And they're really great. And they provide a lot of functionality. And use them if you need them. But if you can do the same thing with a simple tool. I would always veer towards the simpler tools.

And the reason you do that, because other people may have to debug your rigs. So if you keep them easy to understand, it's just easier for production. So now we'll get to the basic four rigging tools.

So I think there's four basic tools, that if you know these tools really well, you can get a lot of stuff rigged, OK? And these are really simple. And these are basic-- a lot of these are 3ds Max 101.

But they're pivots, links and hierarchies, IK-- inverse kinematics-- and constraints. With those four tools you can do a lot of really cool rigs. So pivots, obviously, we understand pivots. They allow for proper rotation and scale. They create a center of motion for an object. We can use those to align and orient objects easily. We can snap to pivots, that sort of thing.

Hierarchies, obviously, connect things together in the proper order. But you have to remember that when you create hierarchies, you're creating a hierarchy a lot of times for animation. So it may not be the exact hierarchy that we have in the real world. There'd be something that makes it easier to animate.

And then hierarchies also allow us to do things like lock position, rotation, and scale. So you can't move it in a way that it doesn't need to move. We can also inherit position, rotation, scale, or not. So if you don't want something to rotate with another object, that's where hierarchies come in.

IK-- everybody is familiar with IK-- got a lot of different solvers. History-independent is the one I use 99% percent of the time. We also have history-dependent, which can also be used for things like sliding parts. It's kind of an older technology, but it works.

IK limb solver-- eh. It works for two-bone chains-- it's a good solver, but it doesn't do much. So H-I works a lot better. And then Spline IK works great for things such as hoses and springs and anything that's flexible.

Now constraints. There's a lot of constraints in 3ds Max. And I'm going to go over a lot of these. So I'm just kind of giving you some terminology here before we dive in.

But basically, everybody in here is familiar with constraint. It basically allows you to tie the motion of one object to another. So you can tie position, rotation. You can have objects look at each other.

So we have position, orientation look at, path constraints. There's a bunch of others. But I find these ones are the ones we use the most in rigging. So before we get onto any other slides, let's go ahead and just go through some simple stuff. And I'm going to go through, and let's just show you some basic rigging here, OK?

So here we have a very mechanical object. It's an excavator. And a lot of times, you'll get these models in, and you'll need to make sure that everything is rigged properly. So I'm just going to do a basic rig of this with just those four tools.

So first thing is just pivots. You need to make sure that your objects have the pivots in the right place. So a lot of this might be review, but here we go into the hierarchy tab. We have pivots. We can move our pivot. We can center it to object.

But center-to-object actually centers to the bounding box of the object. So what we should probably do here is actually move that pivot to the point where it needs to rotate, right? So this is very common-- oh, sorry.

So again, here we're basically just aligning the pivots to the objects. Now something like this scoop here, you need to make sure you understand where that's rotating. And in this case, it's around that pivot there.

Now once you have the pivots in place, then you just link it all up, right? So that's all simple. We have hierarchies. We can do select and link. So now we've got this-- basically, it's just connecting things together. So now when I rotate this everything moves.

But the thing is is that these other linkages aren't moving. And one of the reasons for that is because they need to be animated a little bit differently. So this is where we're actually going to get into constraints. But at this point, I've got a basic rig here. So if I want to I can rotate this and move my arm, that sort of thing.

Now you start to get into a little bit more complex rigging when you have things that are attached, such as these pistons or the linkage here in the scoop. So let's show you some real simple ways to do that just using constraints and IKs.

So we're going to start off with some constraints here. And one of the things we want here is we want all of this to move as if it is a piston. Well, we can use constraints for that fairly easily. And the constraints, we basically find them here under constraints. And we have a bunch. Everybody see that? Yeah, OK.

So the one we're probably going to use the most in this case is the look-at constraint. So I want this to actually be connected to this. But what we have is we really want this object here is going to rotate around this axis. But it's going to look at this object's pivot, which is here.

So all we need to do is just create a look-at constraint. Link it there. Now when we do that, a lot of times it will snap up here. And so what we need to do is go into our motion panel. Go into rotation. Go into the list here. Find our look-at constraint.

And you're going to be pressing this button a lot, which is called keep initial offset. So now this is actually looking at that pivot point. And if these objects are, basically, linked to their respective parts, we should have that-- OK, so now that's pointing at that. But we need to have this pointing at this.

Now if I had this pointing at this, I'm going to get what's called a dependency loop. So what I need to do is insert what's called a helper object to have this look at something else that's at that same point. So I can do under create, helper-- let's just create what's called a point.

Now we can use almost any object. I use points. A lot of people use dummies. But basically, that's just a point in space. I'm going to position that over an object there, and then make sure it's centered there. And now we should have something. So now I can do my look-at here.

And again, that flips over, so we want to make sure we keep initial offset. So now simple pivot, OK? So that's just a constraint. Real simple. So with a look-at constraint, we now have the action of a piston, OK?

So we can do that again here. Let's do that really quickly. The base--I'm going to want to make sure I link that to that. Link this to this. And then add in a point right there. And let's do look-at. So this just like that. Look at that. Offset. This looks at the point.

For some reason, I'm not getting this. So OK. Well, let's move on here. We understand the process here. Now the other thing we have here is this rotational joint here. So we have the scoop moving. But we don't have this moving here. So this linkage here needs to move along with that.

And IK works great for that. So let's just do a quick IK chain. Everybody familiar with create, systems, bones, IK chain?

So we can draw out a bone chain that goes from there-- I didn't sign the H-I solver. So we can do IK solvers. I'll select my root joint here. Select my root joint here and do an H-I solver to there. So now I have this bone chain.

And I think I created it a little off-center here. Yeah, there it is. So I can move these in a little bit. There we go.

So what I need to do is just, basically, link this chain into my hierarchy. And that links to that. My IK handle, I can find it. There it is.

OK, so I can link that to that. So now we're rotating this. Where are the IK chains? Because I did not get my IK chain created, so let's go ahead and create it again. OK.

Well, let me show you the final-- we're running on time here. So let's show you the-- OK, so here we have that rig. So what we have is we have our bone chain here. And we have our IK handle here. And now when this rotates it goes there, OK?

So basically, what I've done is I've taken these linkages, attach them to the bones. The scoop is actually controlling the IK handle, and then that rotates. Now one of the things you saw was that I can actually rotate that in the wrong direction, right? So if I rotate that like that along maybe x or something, then that's a problem.

Well this is again, where hierarchies and that sort of thing comes in. So we have our link info. We also have our locks. So if I wanted to, I could block out rotate on x and z. And now this will only rotate along the proper axis, OK?

So now I've got a basic rig. So if I wanted to, I can select this and rotate it and rotate this or this. I'm having a little bit of a problem getting these handles. My screen's really small here. So that all makes sense, right? Is that pretty straightforward? OK.

So I did all of this. It's actually a nice little rig. It works fairly well. But I did it all using those four basic tools. So again, these tools can be really powerful if you use them correctly. Now we can also use-- let me show you one more little thing using these tools.

And we're going to rig something a little bit more complex. And this is something you may run into is converting rotational motion to linear motion, OK? And again we can do that using constraints.

So this is a classic example of a piston. So I've got this crankshaft that's turning. But I want the piston and the piston rod to all move into place. Now I've already added in a couple of helper objects here. I have two points here I have one at the top, one at the bottom.

And we can make this work fairly simple by just doing a little bit of linking and a couple of constraints. So first thing I want to do is I want to get this point rotating with the crankshaft. Now this is centered to the piston rod.

So when it rotates, it basically just moves with the crankshaft. So that's linked hierarchically. But I want this, also, to move in that same direction. Now for this, I'm actually going to use a position constraint.

So we go into constraints, position, and I'm going to link it to this. Now position constraint just makes the position of one object follow another. And if I just do it by default, it snaps to that object. And they move together.

But I don't really want that. I want to press my favorite button here called keep initial offset. Now what that does is it takes this motion here and translates it up to the level of the piston. And all it translates is the position. It doesn't translate rotation.

Now notice how this is actually changing in orientation. But my second helper is actually working just a long position. So now I have the basis to connect this piston.

So all I have to do is do a hierarchies. I'm going to link this piston to that helper. And, of course, it follows. But I don't want it to follow completely. I just want it to follow along one axis.

So I'm going to go back into my hierarchy panel here. And I don't want to inherit x or-- I believe it's x or z. Let's see. No, it is-- what? Oh, I'm doing rotate-- sorry. Position. There we go. So again, we're working with position. Thank you.

So what I've done is it's not inheriting any position information but the z-information. So now I've translated rotational motion to linear motion. Does that make sense? OK.

And then all we have to do now is hook up the piston rod. And so we can do that. And one way to do that is just using constraints. So I can constrain the position of this to maybe that helper object, OK? And then I can just add in a look-at constraint. So I want this to look at that piston.

OK, so if we do initial offset. Let's see--oops, no. And do the rotation constraint. OK, so let's try that again. OK, there we go. OK so do constraint look-at. So I'm going to look at the piston. There we go. Keep initial offset.

And now I'm probably going to get a little bit of joint flipping here. Yeah, there it goes. But we're getting it. And so what we need to do is we need to just switch a few of these parameters here-- the look-at axis and then the source.

And there we go. That should work. I'm getting a little bit of twisting here. So what you have to do is align the axes here, so that you're not getting that twisting. There we go.

So what I've done is I've changed the axis that it's pointing to. And so sometimes if you get that wrong, you'll get that sort of flipping. So now with just a couple of constraints, I've converted a rotational motion to linear motion, OK? And that's just using all of those basic tools.

OK so I think the point here is that constraints, hierarchies, IK-- they may seem like they're just simple tools. It's kind of like grade school stuff. It's like elementary addition. But you can do a lot.

And sometimes that's like, oh I want to use the new, cool tool. It's like, yeah, but this works. And it's simple, easy to use, easy to de-bug, and it's production-proven. So I always like starting simple. Other people will disagree with me. But that's my theory.

OK, so we've got those tools. And now we have these rigs, but what we're doing is we're actually touching the geometry. So when we take a look at that excavator rig that we did initially, you're actually grabbing the body of the excavator or the scoop.

And one of the things I find is that animators are sloppy. And sometimes you'll do something like-- here, we're going to use that excavator. So let's go ahead and bring it up here.

So they'll say, oh, I'm going to go ahead and animate this. And then they pick the wrong thing. And they move it. And they're like, oops. And then they try to undo it, and maybe they don't.

And now it's out of alignment. And your rig is broke. It's not looking right in animation. And then they got to go back and rotate it back into place.

And so, really, what you want to do is you want to keep it dead-simple to the animator and just give them only those things that they need. So for those, we use what are called controls. And controls can be really simple or really complex. I'm going to just do some simple controls here, because we don't have a lot of time.

Controls just help make the rig easy to animate. They're, basically, just a generic term for helper objects, proxy objects, interface items, that are used to manipulate the rig. Generally, the rule of thumb is work the controls, not the geometry, OK?

So you want to make sure that you're touching just those controls that I give you and not actually digging down into the actual geometry. So again, we have those same types of controls that I talked about. And so let's go ahead-- very simple side.

So let's go ahead and talk about adding controls here. So I'm going to go ahead and open a file. OK, here we go. OK, so here we have our excavator. Now if we want to manipulate it, yeah, maybe I can, again, dig down here and hopefully select the right piece of geometry.

But I've actually set up some controls here. So I'm going to go into my scene explorer here. And I have just a bunch of splines that I created. And so they're rendering only in the viewport So when I render these don't show. But I'm going to use these to manipulate the object.

And it's actually a very simple process. You basically just use a constraint on that which you want to be animated. So in this case, this is all just rotational stuff, right?

So we're going to use an orient constraint. So all I have to do is select this. Animate constrain. Orientation constrain. So I'm going to constrain that to the body. So this is my main control for the body.

So now when I select this, I can-- let's try this again. Sorry. So what I want to do-- actually, what I did was I constrained it the wrong way. You start with the object being constrained. I went the wrong direction.

So you start with the object being constrained, and then you constrain it using an orientation constraint. So the body of this excavator is going to be constrained by this. And again, we get that flip. But we can just-- again, keep initial offset is your best friend when you're working with constraints.

And now I select this and I can rotate it, OK? Let's do the same. I'm going to go ahead and do this. Let's just go ahead and pull this off. Orientation constraints, so that's going to be a constraint to that. Keep initial offset.

Now if I had all my pivots aligned to world, this probably wouldn't be happening. But I built this fairly quickly. I imported it from someplace else. So I have no idea what the other person did. So again, what we're doing here is we're just doing all of these orientation constraints.

So now that I've got everything constrained, I can go into my scene explorer. Actually, I can select everything but my controls. Right click. Let's just freeze these. So now, I can't select anything but the controls.

And so now when I rotate my controls, I can rotate my rig. And I can lock down the controls by limiting rotation and all that. And I can even put limits onto those. So now this is just a simple control setup, but again, it works.

Now the one thing I didn't do was I didn't put my controls into a hierarchy. Now these controls do need to be in the same hierarchy as our objects. So this needs to be attached to that. That needs to be attached to that. And that needs to be attached to that. And so now as you can see--oops.

OK, that goes to there. That goes to there. And that goes to there. So now, once I have this hierarchy in place, I should be able to just rotate these and have everything work according to plan.

So this is a really simple example, but you can extrapolate this to understand exactly how to do direct controls of an object. So-- oh my gosh, it's 10:15 already? OK. Is this over at 10:15? Yeah, OK. We're running a little fast.

OK, so I'm going to show you some other examples here. So another way to do controls is to do controls that do more than one thing. So this is a different type of control here.

So this is a different control rig. And what this does is, basically, just uses one control to control everything. Now what I've done is I've set up IK on the arm. So by selecting this one object, I can just move the scoop and everything moves with it, OK?

So I can rotate this to rotate the scoop. And I can move this to dig. And then if I want to, I could actually move this left to right, and the object will move with it, OK? So this is just another level of control here.

So let's go into a little bit more complex rigging here. And we can talk a little bit about other tools that we can use. Probably the most important one is wire parameters. We can also use expressions, deformers. Reaction manager is really cool, and many more.

So wire parameters is one of your best friends when it comes to rigging. It allows you to link any two object parameters together in a viewport. And it's great for creating things such as control panels in a rig.

So let me show you a little bit about how to do that. So we have the same rig here. But let's say we wanted to control a little bit more like the real world. We wanted sliders or something else to manipulate it.

Now control panels are basically controls that are actually off the object. A lot of times you can use things like manipulators. So if you go into create helpers, we have under manipulators, we have sliders.

And we can take these sliders and actually use the manipulator tool here to change the value. And that value can be used with something like a wire parameter. So if I wanted to, I could take, say, the body of this and go into wire parameters.

So I could wire in the z-rotation-- let's try this again-- to this object. And so what I'm going to do is I'm going to wire the value of this here to the rotation. So this slider manipulator is going to go ahead and control that. And when I select the slider and manipulate it, we're going to get, actually, kind of a-- manipulator, there we go. We're going to get a lot of motion here.

And the reason for that is that this is going from 0 to 100. And rotations in 3ds Max are in, what, radians. So we need to do a little bit of math. This is where things like expressions come in.

So what we need to do is, basically, just divide this by the value of this slider, which is 100. And then multiply it by pi, 3.14. We update that. Now 0 to 100 rotates it all the way around, OK?

So what we've done here is we've just wired one attribute to another attribute. And we can do that throughout the whole rig. We can build up an entire control panel using that.

So if I wanted to, I could say my minimum here is negative 100, maximum is 100. And so now-- boom. And I could actually wire in a whole set of control panels. And so here we go, exact same thing. And now I've created a whole control panel here in my viewport.

And so this is very similar to the actual levers you would see in the cab of that excavator, right? You'd have one for each motion of the objects. And so now you've kind of got an analog of that, OK?

Now wire parameters can also be used for other things such as gears. So we have something like this. So I've got my pistons that I just rigged. And as you can see, they're moving. But my gears aren't moving.

Well, gears are great for things like expressions and that sort of thing. And we can use expressions to create those ratios. So again, we can use wire parameters.

So let's say I wanted to have this working off of this. So I can, basically, just do a-- animation, wire parameter. So I'm going to wire my gear. In this case, I believe it's y-rotation.

And then I want the crankshaft to control the gear. So here we have what controls what. It can be bi-directional or one way. And so now that's controlling that.

Now one of the nice things about this view of this parameter wiring dialogue is that you can actually keep working in it. So if I wanted to, I could select this gear, load it here, and then just select the rotation I want here. In this case, it's going to be z. This was actually flipped a little bit.

So this is going to control that. So now that's controlling that. But one of the things you'll notice is that, well, this particular gear is 16. This is 8. So what we need to do is we need to do a little bit of math.

Now we can actually just divide by 2. Or actually it would be twice the speed, right? Because that's the smaller gear. So now that works. So what we're doing is we're actually building in the gear ratios.

Now the gear ratio for this is, basically, the driving gear divided by the driven gear. So whatever is driving-- so in this case, this would be 16 divided by 8. So that would be 2. This one here is 8. This one here is 24. So it would be 8 over 24. And that would be your ratio.

So once we get all that rigged up, you have something like this. So now just with one motion here-- all I'm doing is turning the crankshaft. So now the one crankshaft is moving the entire assembly. And so now that crankshaft is moving all of the gears, all the pistons, and so on.

And in a real world, that's kind of what you want. It's like, we don't really want the gears animating in a different way than they're actually supposed to. So this sort of rig works great.

We have other stuff here. So we go a little bit further with this. We can do something like a pulley. So now I've got all these gears turning. Why don't we turn a pulley?

Well, something like this is going to be a little bit different. Because what we really need to do is we need to create that belt. Now there are a bunch of different ways to do this. This is the way that I'm going to use, which is, basically, deforming this to a pass.

So what I've done is I've drawn a spline around this. And then I've added a normalized spline. And that just makes it the same distance between points. So that way when we deform this it doesn't get all wonky. So all we have to do is to select this, and then do a path to form.

So this is going to connect to that-- well, not there. There we go. So along x, but we want to also click move to path.

Now in the ideal world, you will model the belt exactly the length that you want. But I'm a little bit off. So I'm going to just go ahead and stretch it just a little bit for the sake of filmmaking here. But there we go.

So now what we have here is we have this-- point, I think it's 1.2 is my magic number here. There we go. So what we have here is we have a percentage along the path.

So this number here, if I can animate that in concert with this, then I've got a rotational thing. And again, that's just a wire parameter. So I'm going to basically wire this rotation to here.

And we're running out of time here. So I'm just going to load the final here. [INAUDIBLE] end. So we load this. We do a little bit of math. Now you can actually calculate that, or you can estimate it.

What I do sometimes is I just look at it. And I keep adjusting that fudge factor. And what you do is you just multiply this rotation by this rotation, and there you go.

So again, that's just another way of rigging. And it's getting a little bit more complex. So let's do one more thing here. And we have a conveyor belt driven by the pulley. Now with this we're going to use something-- there are a number of different ways to do this.

The way I'm going to show you is, basically, just animate this along a path. And then again, just like we did when we with the pulley, we're going to animate the percentage of that using a wire parameter. So this here, I just want to attach it to this path.

So I have this path here that's the same size as what the conveyor belt will be. And then all I have to do is do a constraint. So animations, constraints, path constraint. That goes there.

Well, that doesn't work. But we can fix that. We can go into our path constraint here. And we can change-- we can have it follow. I'm going to allow upside-down. And then I'm going to flip my access here.

So now what this does is it just animates that along the path. And you can already see, I've got one of these on the conveyor belt. Now when you add in a path constraint, it actually adds in some keys. And those keys are, basically, just go from 0 to 100 to animate it along that path.

So as you can see it goes a little bit faster if I bring them together. But I don't really need these keys. I'm going to control this using wire parameters. So all I have to do here is, basically, just do a wire parameter of this position, path constraint, percent. OK?

And then I'm going to link that to that pulley here. And I believe it's z-rotation-- z-rotation-- OK, there we go. So pulley controls, tread, connect. So now that goes around.

Now we can, obviously, this is going probably going a little bit-- it's going way faster than the pulley. But all we have to do is just divide by an amount here. And now we're getting something a little bit more, OK? And then what you do is you just repeat that for each tread. This is where scripts come in handy. And you get something like this.

So what I've done here is I basically just done that same expression. Actually, I did a different expression. We have one master tread. And then the successor treads basically just subtract out the percentage along the path.

So with this one here, my master tread is always going to be at 0. This second path here is just going to be the percentage minus 0.4 or 0.04, or whatever. And so now I've got-- there we go. So that works, OK?

We got five minutes left. OK. And then finally, the last thing I want to do is I want to talk a little bit about reactor. Has everybody use reactor here? Reactor's awesome. Reactor allows you to control multiple objects with one.

So I'm going to go ahead and open up the final. And then I'll go ahead and show you. So I have this manipulator here. And that one manipulator controls multiple objects. And we're doing that with reactor. Now how reactor works is we've got the reaction man-- actually, it's called reactor manager.

But basically, what we do is we load up all of our objects. One object is what we call the master. Everything else is a slave. And so the position of this will control the position of everything else along a curve.

So if I have this object here you can see it's animating along this curve. This object here has different curves, OK? So this here, this goes first, right? So as I go from 0 to 50, it goes from here to here. And the doors, they stay still. And they go from there to there.

So we can do this very simply by creating a reaction. So I'll just create a simple reaction here. I will add in a manipulator here. Let's create a slider. OK, so that slider is going to be the master. We're going to add that in. Select it. Is it selected? Yeah.

I'm going to add in master. OK, well-- oh, I see. OK. So we're going to add in the master. What you have to do is you have to give it the actual value that you're adding in. You're not adding in the whole object. You're only adding in one controller.

So we're going to add in that slider manipulator--oops. No, that's not what we want. We want to add in the value of that object. And then for all of these, we're just going to add in-- in this case, the rotation is x.

OK, let's just do it for this object here. So now I can say when this is 0, this rotation is this. So what we can do is we can move this up to say 50, and then create another state.

So in this case, then all I have to do is type in the value here where it's retracted. And now I manipulate that. And then I can add these in for all the other objects, OK?