Make It Move! Animation and Rigging in 3ds Max for Engineers and Architects

STEVE JOHNSON: Good morning, everyone. Welcome to a AU 2018. Kind of interesting for me to have a class first thing out of the gate. I don't know if that's a good thing or a bad thing. So I guess we'll find out.

My name is Steve Johnson. I am the WSP design visualization lead in our Seattle office. WSP itself is a kind of global engineering conglomerate. We do a lot of bridge work, a lot of infrastructure work, a lot of transit work.

Our group of about 40 or so in the US does most of the visualization work. So I spend a lot of time, you know, putting cars on roads and animating them going down a highway. They'll say, hey, we need a camera path going around this intersection, which is all fine and good.

But when we got this project that came along, the Interstate I-90 track bridge, it was a bit of a unique challenge for us. Essentially, what this was is a lot of light rail expansion has been going on around the Seattle area over about the last decade or so, a lot of North-South corridor light rail expansion and also a lot of East-West, which is what's shown here. The problem with Seattle is there tends to be a lot of lakes in the way of where you want to go.

So the DOT came up with the idea. They want to study the feasibility of putting a light rail track across the existing I-90 floating bridge, which is about a mile and a half long across Lake Washington that connects Seattle in the background there to Bellevue, which would be in the foreground here. The bridge itself I think is the second or third longest floating bridge in the world.

The reason it's floating is, because the lake is so deep, you can't do pilings. So at some point they said, hey, let's take this middle HOV lane and run tracks across there. Is that possible?

And they came to our company. And we said, I don't know. Let's figure it out. We've never put rail on anything that floats. But I don't know, maybe we can do it.

Our initial sort of documents we got was from a study that was done in the early 2000s, where the DOT had kind of preliminarily looked at this to see if it was even remotely possible. This was the sort of basic design they came up with. Essentially, you've got sort of a fixed side where the land would be, and then onto a floating section where that pontoon would be.

Beyond that it's just kind of a basic, some big metal bars that allow it to sort of twist and bend and hopefully deform the track enough to match the bridge angles, but not so much that it doesn't keep the track straight. Our engineers looked at this and said, well, that doesn't really work. They ran the numbers, and said, there's pinch points and all sorts of engineering jargon that they said was not good.

So we had a workshop where one of the rail engineers, legend has it, he was in the Seattle office. He went down the street to the craft store, bought some toothpicks and some balsa and sat in his hotel room and did this the night of the workshop. Came in the next day and said, hey, guys, here's my idea for a track.

Essentially, it has these curved wings that hold the track. And then you can deflect this at all different angles and not create any pinch points. It became known as these CESuRa, which I think stands for Curved Rail Support System.

Here's a little video. This is the final product of the model we're going to look at here in a second. So this kind of shows the conditions of the bridge, sort of the forces that are involved, everything the track has to account for as it transitions from what's essentially standing still on the land side to this floating section.

So you've got problems like surge. The whole bridge can roll. The water level goes up and down about 3 to 5 feet annually. Wind can push the bridge. And then you have just regular things, like track expansion, that you have in any other rail system.

Here is a sort of real quick fly through breakdown of the model. We're going to look at this whole thing in detail here in a minute. Essentially, it's fixed on these back corners and then sort of floats on this front section. These pendulum bearings allow the whole rail system to slide.

As you can see this little close up here, it's hard to see there. But that top pace is actually sliding on that bottom piece. And that allows the rail to deform.

These were some of the deflection parameters they wanted to get measurements on. Surprisingly enough, the model measured actually pretty close to their design documentation specs, which was I guess good for us. That's kind of a quick animation of the final product of our work.

So the biggest issue we had with building that was not necessarily building the model itself, which we've done lots of. Here's the plans. Can you build this model for us?

They wanted to do a workshop where everyone sat around. And they kind of designed this thing on the fly and wanted to be able to say, OK, Steve, we need the lake to go up 3 feet. And we need to see what the track will do.

We need to push the whole bridge left a foot and raise the water and then roll it 2 degrees and see what the track will do. They obviously didn't have any time for me to go back to my desk and remodel the whole thing for a day, go back to the workshop and say, here you go. They wanted it to be able to see right now how that was going to respond.

So a couple of issues with that-- you know, nothing is straight on the bridge. The approaches are at an angle. The bridge deck itself is at an angle, which makes it a little bit more complicated when everything is at an angle, because nothing's at zero. Nothing points up. Nothing is flat. Like it says there, no zero, zero, zero.

Linking the pieces together-- for example, if you get the vertical rise to work. But then you trying to get it to roll, and it breaks the whole thing. So lots of links can get screwed up.

The model itself had to be simple enough that they could remodel this thing on the fly without, again, me going back to my desk for a week. And above all that, I didn't really have much experience with rigging beyond putting a camera on a spline or just key framing some cars. So that led me to sort of research and use sort of this list of stuff, which is what we're going to look at right now.

Let me jump over here. So hopefully, I can get through most of this model. See how much-- hopefully, I have a clock in here.

If I ram through this pretty fast, it might give you some idea of some things to go research. I doubt this is going to be helpful enough to use these out of the box. But it'll give you some ideas of some of the tools that are out there in Max.

OK. So here is sort of our initial model that I simplified a little bit for this class. We're just going to put in one track bridge that connects right here. So here we have sort of our fixed land side.

It goes across a transition span. And then this would be the pontoon section that would go sort of out across the lake. The most basic tool in the toolbox for this thing is just a simple link command.

Link is up here. Essentially, it just says that. It links two pieces together. Sort of tell it, one object is going to control other object's typically just transformation. So if it moves left, the other object moves left, other object moves right.

And to simplify that a little bit, I have it here what's called a dummy object. I'm sure most people in here probably are familiar with the dummy object. It just gives you a non-renderable point in space that's useful for linking things to or checking in measurements from.

In this case, things get a little bit more complicated further down the line. So it's kind of good to keep all your links out of geometry as much as you can and sort of keep things linked to just these null objects. Because it just sort of simplifies sort of the flow.

So for a simple linking exercise on this, I'm just going to take this bridge span, select the Link tool. You can clip the object and just sort of drag the rubber band object to what you want it to control, so sort of child to parent.

And now if I move that pontoon structure, that bridge deck will move around with it. I can link that whole thing to what I have labeled as my main pontoon control dummy down here. So now, this dummy I'm going to use to essentially control the entire bridge for the rest of the project.

It's going to control the water changing height. It's going to control any roll. It's going to control any horizontal sway movement.

I have a sort of stand-in water object down here. I can link that also to my control dummy. Now, you can see, if I move the dummy, it also will essentially affect the lake level. The problem is, if this rolls, the lake's going to roll, too. Then that's clearly not going to work.

So going along with linking is usually a useful little sub-piece. If you go under the Hierarchy tab and Link Info, you've got this little Inherit box down here. This will tell the child object what motions to grab from its parent object.

So in this case, we really only want it to move in z for vertical. So we don't need any x and y. We won't need the water to rotate at all.

In this case, scale is not an issue, because we're not scaling anything. So now if we go back to our dummy, our lake level still works. It will no longer translate an x and y.

But you'll see, if we rotate, it's not rotating the water. But it's still moving vertically, which is because it's using this object's pivot. And it's essentially rotating it like a clock hand as that pivot continues to look at the other pivot.

Quick fix for that is if we just line those pivots up to each other. So here I'm aligning the water pivot to that objects pivot. So now that water pivot is lined up with our main dummy object.

Now, if we roll this guy, it no longer rolls. And it stays pretty much totally solid unless we do a vertical movement. So that's about half of our initial sort of rigging of our model.

Second part is we need this transition span to stay linked to our solid land side. This would be Earth under here. We need it to always sort of look at this whole pontoon structure.

So for that I have another dummy set up here that I'm going to say, OK, I need this bridge span to always just look at wherever this dummy is. For its pivot, I'm going to move it back to where it would sort of actually pivot in the real world. And then if you go under the Motion tab, under Assign Controller, you'll see this object's sort of main controls for its positions in Max.

Typically, when you create an object, you have a position x, y, z and some kind of rotation x, y, z. Because, for the most part, all you're doing is moving and rotating objects. If you get a little bit more advanced under some of these controllers, if you click this little Assign Controller box, it brings up some other options.

In this case, the rotation we no longer just want to be whatever x, y, z we set. We can tell it to look at something with a look at constraint. Click OK. That brings up another little dialog box over here.

We can tell it what we want our object to look at. We can tell it to either keep its initial offset, which in this case we do. If we don't, it'll try to match its parent object's pivot which sometimes will flip it around in odd ways.

So typically it'll keep initial offset. You add a target. In this case, it's our dummy. And now, when we move this object around, that bridge will always look at that guy no matter where he's going.

We can link this dummy back again to our main pontoon control. And now that whole system will start working as a sort of one object. So that rolls, goes around.

I notice when I rotate this guy, I want this bridge deck to actually match up over here. The reason that's staying vertical is because, under its lookout parameters, you can tell it what you want it's up node to be, in other words, which direction it will think up is. In this case, the default is world, meaning its z will always just point up.

You can tell it what you want its up to be. In this case, I'm going to use, again, our main pontoon control. That way when we rotate that guy it actually rotates with the whole bridge deck. And then ideally on this end, the expansion joint will take up that slack.

Also, note most of these movements I'm doing here would never actually occur in real life. The real parameters on this bridge are typically in inches, maybe feet. I'm moving this-- 45 degrees is not going to happen. But for examples of our bridge, it looks a little more visually interesting.

OK. Final step on this before we jump to the next chunk of stuff, one useful thing that you can do with a lot of these model parts, you'll notice my main pontoon control here is at some-- well, it's actually at the center point of this whole pontoon. And vertically, I've got it right at the water level. Which means in my real world model space, it's at some just random bizarre unit location, which makes it really hard if this thing gets out of whack to put it back where I had it other than Control Z.

So when that's not an option, if you just want a quick way to return this to a spot where you want it to be, if you hold Alt and right click, it will bring up these little transform controls here. You can do Freeze Transformation or Freeze Rotation, and that will just lock it in that spot, but leave it movable. And I'll show you what that means.

So I'm going to do a Freeze Transformation. It's telling me it's going to add a track over here to its position controller, which is fine. And I can also return it at any point. So I'll say, yes.

So now if this thing gets all out of whack and someone bumps it or some crazy position, if you hold Alt and right click again, you can go transform back to zero. And it pops it right back to where it was. So this will also come in handy later when we do some of the little bit more advanced rigging pieces.

OK, so that's kind of our first little setup. Let me jump down to the wings. OK, so this is kind of the sort of the bread and butter of this whole contraption. If these guys don't work, the whole thing doesn't work. Because these are the two wings that will lift up and raise as the bridge deck goes that deforms that whole track.

So to get these guys working, first I'm going to kind of look at how they work. Let me hide these real quick. So they sit on top of these sort of six pivot points, these little guys.

So they're fixed. They're fixed on these end corners. And then they rotate on the axis towards the second point. And then it sort of floats on this moving bridge point.

So the first thing I'm going to do is, these guys that need to move, I'm just going to link them down to my bridge deck. So now when I move my bridge, those little points will move. I'm going to unhide my wings.

Right now, their pivots are just sort of where they were when we made the object. We're going to move the pivot to where it would actually be for the actual wing down there. It can do both of them. I'm probably only going to wire up one of these guys.

And then I'm going to rotate this, so the pivot is pointing right at that second pivot position. I'm going to move these down just a little bit, so they're sort of where that actually would pivot if this was a real bridge. So now if we rotate these guys around in their local axis, you can see that sort of local axis.

You see, it's sort of staying fixed on those two fixed side locations and then pivoting around [INAUDIBLE] that bridge. So essentially, this bridge deck will drive this bearing, which will push up on this wing and drive these guys in their right form. Again, since these end up at all sorts of crazy locations and rotations, I'm going to right click again, Alt. Get the freeze rotation. That way if these get sort of all whacked out of position, I can quickly change it back to where they were.

Next up on these guys is what's going to be called a wiring parameter. So what that allows you to do is to take two objects and let their values drive each other, which will make more sense in a second once I show you. So what we want to do is we want the rotation of this wing to be driven by the vertical position of these bearing objects.

To get the position number out of these guys to feed into the rotation of our wings, I'm going to use another dummy object just so I have something to link to a little easier. I'm going to link these down to those-- whoop, just one, but not the wing. I'll link these down to these little bearing guys.

So now, when we move our whole-- I'm just grabbing our main pontoon dummy back there. Now, when we move our bridge, you can see those dummies will stay sort of linked where they're supposed to go there. Now in this case, I stuck these dummies at just a zero world z position.

So that way when these-- essentially, I'm going to tell it when these dummies are at z zero, the rotation of this guy is whatever its current just zero rotation is now, which is its current position. So that seems like it should work. The problem is when you link this to this guy, this guy picks up the location of this as its parent.

So all of a sudden, this rotation is going to read off of this negative 16. But I need it to read off of this zero. So one more little trick on this one is under the Create Helpers, there's the Expose Transform Control.

You can click it anywhere in the screen. This is a non-renderable point object. You can really put it anywhere. I'm going to use it with these dummies. So I'll just kind of stick them over by here just to keep it straight which goes with which.

So if you select this Expose Transform Helper, it essentially just says, what node do you want? What object do you want me to show you all its transforms for? So in this case, I'm going to pick this dummy.

That says, OK, it's local position is 16, because it's getting picked up off of this node down here. But I want to be able to use this world z. So in this case, that will sort of keep this constant no matter where it ends up in space. And it will always give me its relative position.

So next up in connecting this all up, collect our wing. If you right click on it, go down to Wire Parameters. It'll bring up this little menu, which is essentially every editable feature about this wing.

You've got all of this x, y, z positions. You've got sort of all of it's editable poly things. You've even got the material that's on there. So any of these things can be linked to other numerical controls.

For this, I need to do its rotation. Our key frame x, y, z is the one we just froze. So I need that to be at zero location.

Or you need its x rotation, which is its far pivot. That brings up this little rubber band object. And then you can sort of select what object you want to drive the thing you're wiring to.

So if I click this Expose Control, there's the Object Exposed Helper. This brings up a dropdown of all the values from that dummy that it's linked to. So in this case, I'll just check my notes to make sure I'm grabbing the right one. I believe it's the-- I need to link it to I think the world z.

Yup. So we click this, the world z position. This will bring up the Wiring Parameter dialog box, which is just telling you, OK, you've selected the rotation for the wing. On the other node, you've selected this world z position for the object that you linked the dummy to.

Which one do you want to control which? In this case, there's only one possible direction. Depending on the objects, it'll let you control the other way around, or one can control the other. In this case, we're going to have this expose controller rotation.

After that, just click Connect. And it should work, right? That's your clue for no, it won't work.

So if I come down here to my dummy control, move this thing. It's like, oh, that's not good. It's like, OK, first of all, it's moving the wrong direction and clearly moving completely bizarrely too much.

Wrong direction is easy enough. This little box down here is essentially just a little Mac script box. Anything you can do a Mac script, you can pretty much do down here.

So I can tell it to be negative. Click Update. We go back to our motion. OK, now it's rotating the right way, but rotating way too much.

It turns out that the rotations in the Wiring Parameter dialogue seem to be in radians. So anytime this object moves, what, 3.14 units, it's moving around 180 degrees. So I'm sure there's some engineering math behind there that you could do to figure out what that's supposed to be.

I just kind of tinkered around with it until it looked about right. And I'd just multiply that by about 0.0105. And that seemed to kind of sort of factor out our radian quantity and bring it down to sort of a degree translation.

So now when we rotate that, it's only rotating 0.105 radians for every one unit of this vertical positioning. So that works pretty good. Getting some sort of realistic looking rotation out of that wing.

It rotates. It still sort of works. The side to side is not working. Whoops. Easy fix for that, we can wire another parameter for its z rotation, so it stays flat.

Wire Parameters, Transform, Rotation, Key Frame, z to Helper Object, Expose, Transform, z rotation. So I'm going to wire this to that dummy object's z rotation. So whenever this little guy rotates, which is the world Euler z-- Control, again, radians to weird degrees to weird horizontal translation. After tinkering around, it seem to be about a 2.8 to 1 ratio.

So now if we move this guy, now it will stay sort of pointed at this sliding bearing. Again, the bridge will never actually be able to move that far. But if it does, it would actually still work.

I maybe bring up sort of the fully rigged version. So here I've got the other wing sort of hooked in. I can see they're both-- so we've got one dummy object now controlling our wings, our bridge, our water, rotation. Clearly, some clipping going on, but the bridge, if rubber rolled that far, everyone would be dead anyway, so it wouldn't matter.

[LAUGHTER]

OK. I'm just going to run through this one real quick, not really show quite how it works. But wiring parameters don't have to be translation to translation. It can really be any two numerical values you want.

Here I have the expansion joint which would sort of connect those two points where cars would roll over. So here you can see it stays connected as the whole bridge moves for the most part. It kind of breaks a little bit.

But all I've done here for this guy is I've wired a box with a twist modifier and a bend modifier. I've come in here. And I said, OK, I've got this bend and twist.

And all I've done is wire that to the pontoon's x and z position. So any time this pontoon moves in an x and z, it's just reading its position and translating that into a value for this twist and feeding it back into this box for these two values. So you can get pretty creative on what you can wire together.

I mean, you could wire an object's position to other object's color parameter and material. It's really pretty powerful. And if you're any good at scripting, you can do a bunch of fun stuff down here. Anything you can script you can put it here, a conditional, if then statements, so on and so forth.

So that kind of wraps up wiring. Let me jump to the next little section, which is the bear bars and pendulum bearing. Sort of the next key after the wings is these pendulum bearings, which kind of is how the whole system works.

Engineering wise, the idea is this bottom bearing stays fixed to the wing. This top bearing is fixed to this bear bar, which holds the track. And then as the bridge moves, these two objects can actually slide around in each other.

So it just sort of stays in force by gravity. But as it gets tension on it, it can pull. It can sort of rotate.

So for this to work, again, kind of some basic linking, I'm going to link each of those bottom bearings to the wings. So now when we move our wings, our bearings just sort of sit on there. The rest of this stuff I'm going to just link all together to the main bear bar piece.

So now, this guy just sort of has all those pieces. And then I'm going to take this whole assembly I just linked together and link it back to this bottom bearing. So now when that bottom bearing moves, this whole piece will move.

So we'll see it's kind of starting to work, OK? Everything's staying sort of together. Obviously, this side is staying way too locked, the other side not locked at all.

So to fix that, I'm going to do our first little trick of our look at constraint. Since I know this is fixed to this point, I'm just going to tell this whole assembly just to keep looking at the other side. So we go to there.

We're going to our Rotation, Assign Controller, Look At Constraint, Keep Initial Offset, Add Target, the other bottom bearing. I'm going to set its up node to the bearing itself. So that way when the bearing position rotates, it'll rotate the whole assembly.

So that should get us a little closer. So that's kind of working. It's staying a little too locked over here and sort of sliding off the side over there, which is because it's getting all of the x, y, z positioning from this guy and pushing it off to the side.

So to fix that, go back to this guy's translation controls. We don't need it to move in the y, which is across the bridge. We only need it to move in, essentially, the x and z. We don't need to worry about rotation.

So now if we move this bridge vertically, that bear bar is staying centered on those pendulum bearings, which works pretty good for the vertical. It works reasonably well if we roll the bridge. It's still working. Not working yet for our side to side control.

Make sure I got all my notes on that guy. OK. So to get the side to side working, we're going to use another new object to sort drive the side to side motion. I'll show you this whole bridge rigged up first here.

So there's all the pieces hooked up with our little wiring we just did. You can see it's working pretty good there. Everything's sort of staying sort of where it's supposed to be, again, clearly not real world conditions.

OK. For the side to side, we're going use an object called a hose. It looks like sort of a octagonal tube, but this is a helper object-- or, excuse me, an extended object. If you look under the Extended Primitives, you'll find the Hose object.

This is essentially an object that says, tell me what two points you want me to stick to, and I'll try to maintain a connection between those two points. So you'll see here, if I grab our pontoon control and move this guy around, it's going to try to stick to those two dummies that I have linked to our bridge deck. And I'm going to use that x, y position points along this whole hose to drive the x, y position of our bear bars.

A quick run through of the hose object, essentially you can say bind to a couple objects. Pick a top object. Pick a bottom object. You can play around with the tension, so it's kind of sort of moving about how you want.

In this case, I have it set to 32 segments, which seem to be fine. Round is fine. I set it to non-renderable, so we're just using sort of its own dummy object.

It's a round hose. I gave it six sides. So I'm going to have this flat surface I'm going to use later on to attach some dummies to. OK. So let me unhide the rest of my objects from our last scene.

OK. So a couple of things going on here. I'm going to use this dummy stuck to this hose that I'm going to link to some other dummies that I'm going to tell this bear bar to interpret all those positions and get the y position from this guy. So you're thinking, OK, I'll just come over here. I'll stick this down on the hose.

I'll grab the Link tool. And I'll grab this dummy. And I'll link it to the hose. And voila, if I move the hose, this dummy will move around. And no, it doesn't move around.

The reason the link doesn't work on that is because this hose is sort of a dynamic object. And it's just deforming the mesh, but not doing anything with the pivot of the object. The Link tool is only seeing this object's pivot. So if that doesn't move, this isn't going to move.

So kind of go back to where we were. I'll unlink that guy. So the way around that is back in our controller roll out, you go to Position. There is a little controller called the attachment controller. This is like the link on steroids.

Click OK. It brings up another little dialog. You can pick the object you want it to attach to, in this case the hose. You can click the Set Position.

And now you can pretty much, with your mouse, just drag it around this object where you want it to go. You'll notice it sort of sticks to the face. It observes the orientation of the faces. You can't really tell it's a square on this as much easily.

But let's just fix it there. I'm going to stick it right under this bear bar. Turn off set position. Now, when we move this hose object, that dummy will stay linked to that hose no matter where it is.

So like I said, kind of like link on steroids. This little group over here, this is where I'm going to use to generate sort of this initial zero position even though it's not zero in any means of the imagination. I have two nested dummies and an exposed transform control.

This expose transform control, normally we're just using it to expose one object to get its transforms. In this case, I'm going to tell it a second object, which is this outer dummy, to use as its reference. This way this inner object will always have this local z or actual x, y, and z compared to this object.

So these two objects can be anywhere in the scene. And this expose control will always see this inner dummy as zero relative to this outer dummy. So this gives you a way to get a zero point in your scene even if you're scene is millions of units away from where your model is.

So if we link-- let me try the dummies here. So if we link this inner dummy to our dummy on our hose, there's that guy. And then we really only need it to transform in the y position, because that's all we're going to use it for.

Now if we move our hose around with our link dummy, you'll see it picks up that horizontal translation. And since we restricted it to y, you'll see it doesn't matter where this object goes in space. It's only going to pick up its y position.

So now the last step, if we wire the transform y of our bare bar to the transform object [INAUDIBLE] transform local y of our child dummy, click Connect. The should work, since it's just a 1 to 1 ratio.

You can see now we've got our bear bar sort of staying fixed in its spot. It's getting a little bit of slide as it's being driven. It's getting a little bit of vertical motion.

So it's starting to sort of drive it in other ways. So now that thing is nicely stuck. It sort of breaks if you go crazy, crazy with it.

But for the most part, it is nicely stuck together. OK. Let me open up sort of the fully rigged piece. Here, I've started to get some of the tracks in here.

This is literally just pieces that are just directly linked to our main transition span. Trying to get an angle here. So you can see all those pieces are nicely connected, staying together. Nothing's flying apart too much.

OK. Last couple steps is the track itself. OK. For the track-- let me move that guy out of the way. I've laid the track across here. It goes through these little clips. And I've just sliced up the track at each point where the clip would connect the track.

So the real track would just be clearly a continuous piece. But for our model, I've sliced it up in these little parts. I've moved each little track pieces pivot point to its back half and then just told it to always point at its friend in front of him.

So here it's such a look at constraint. If I go to Rotation, it's just looking essentially at the next track piece. So this piece looks at this guy. This piece just keeps looking at this guy. This piece looks at this guy.

The last piece out here I've just attached a dummy sort of out in space to stay looking at him. This dummy just links to the rest of the bridge. So when you do that, then when you move the pontoon around, that track sort of starts bending with the rest of the system you can see there.

So if we go too crazy, it starts to sort of pull itself apart. But within operating parameters, it's pretty accurate. Now you'll notice the little track pieces, as well as pointing to their neighbor, they're also sliding in these clips.

This is by design. They were created back here. There's some kind of slip joint where these tracks can slip past each other for mainly track expansion.

And you'll see if we do some vertical motion, that's essentially pushing and pulling the track back and forth. So the way that works without breaking the rest of everything else is under the wiring parameters all I did was wire each little piece's tracks exposition, so it's longitudinal position along that track, to-- I've done actually two different wiring parameters for a single x position.

So in this case, its x is going to be driven by the x and y position of our main pontoon control. So it's telling it, OK, as this thing goes up and down z, push the track back and forth x amount. As it goes left and right, you're either going to push or pull the track back and forth x amount.

The way you can wire the same x-coordinate to two separate objects is under its controller I've added in-- you barely see it there. If you add a float list, it will essentially just give you continuous drop-downs where you can continue to wire parameters to an object. So here, Float List, you can add as many additional controllers as you want to this list, which makes it nice. In this case, like I said, we have multiple things driving a single x translation.

So let me grab one final file-- doing pretty good on time. First time I ran through this in my head, it was like two and 1/2 hours. So I guess I'm making pretty good time.

OK, last little tool really doesn't have much to do with the bridge model itself, but was really convenient for when we were all sitting around and I was driving this thing on the computer. You know, they'd say, OK, raise the lake level to some point. OK, now zoom in to this little piece. OK. Now, go back and rotate the water. And I'm zooming around.

The problem was I always had to have this dummy selected to move the bridge around, which was kind of inconvenient in a workflow setting when you're sitting around with 20 engineers. And they're all telling you 10 different things at the same time. So there's this nifty little tool called the Parameter Collector under the Animation roll out, which is just this little window.

It lets you add controllers to it from essentially any number of objects, any types of controllers, and puts them in one little window that just sort of is models. It will sit there by itself. It doesn't have to be the objects selected to control it.

So like, for example, I can come in here. If I wanted to add something else, like I could grab-- I think if you're selected, it'll pick something like a wing. So there's the wing. I can grab the wings.

You have to dig through this a little bit. But say I wanted to grab the wing's y position for some reason. So that adds this little dialogue in here, sort of reports its current position. You've then got a little controller where you can sort of move that on the fly.

It doesn't have to be selected. Here, I don't have the wings selected. I can still control that object's parameter.

In this case, most of these controls are set to the dummy. You can come in. You can rename these guys under the Edit controls.

So I've renamed it for the workshop. So when they would tell me to heave, I wouldn't have to think, OK, what's heave mean. So here we've got vertical motion.

It doesn't even have to be selected. We can do our roll. We can come back over here and do this guy, do this guy, move it all these positions.

The nice thing is to reset this guy I don't have to go back and select it. You can just, like any spinner, right click it, set it back to zero. Extra a little feature with this-- on the controller, again, if you set where its parameters are, if you add in a float limit to it, it'll take the controller that's currently connected to, put it inside this float limit controller. And that lets you set up these little dialogs that will let you just set an upper and lower limit for its object. So that way, when you go to move it with the spinner, it will only let you move it that many units.

So here we've got plus or minus 25. So this was super useful for the engineers who aren't excited about seeing their bridge flip over 180 degrees. You can set the limits to sort of the real world roll and surge.

That way you can sort of play with these controls all you want. And it only rolls or does whatever whatever amount you set it to no matter how much I try to sort of alter it.

OK, so that kind of sums up sort of all those controls, up until this bridge, I had really never used before besides maybe linking and dummies. Pretty much all that stuff I sat at my desk and researched for a few months while I was trying to put this thing together. I went through about four major iterations.

Those pendulum bearings were originally a little boxes with heavy duty wheels on them that would rotate all weird. And I had that all rigged up. And they said, we're not doing that anymore.

And I said, I just spent a week making this. And they said, sorry, we researched pendulum bearings. We're doing that now.

So long story short, DOT said, we love this. Let's go ahead and build one out in our testing facility in the desert. This is the actual track bridge model they built to run light rail vehicles on.

There's one of the light rail vehicles they shipped from Washington out to- someone quote me on where the national rail facility testing. I think it's out in New Mexico maybe, somewhere out there? Anyways, it's out in the desert.

AUDIENCE: [INAUDIBLE]

STEVE JOHNSON: Sounds right. They wired this whole thing up sort of to sort of test real world, all our parameters. We measured out of that model, sort of a cool project.

Fast forward to today, and they're currently building it across the water. They have stations ready on both sides. They've got the bridge prepped. And they're starting the work on laying the track and putting that track bridge on there. OK. I burned through that pretty quick, hopefully, saved enough time for any random questions.