Hi. I'm Doug Appleton, the Visual Effects Director here at Perception.
And for this tutorial, we're going to talk about how we can use animation to add
complexity to your designs. And we're going to do that with this cool globe that
we have here. And you'll see we have some of these beacons that are popping up and
animating. Some of our tick marks over here are animating. There's a lot of cool
little details here that are going to add a lot of interest to your design.
So let's get started. So, the first thing we're going to do is,
make those beacons. And we're going to do that by going to our
top menu, grab our Pen tool up here. You'll go down to this...make sure we have
Enable Snap on. And make sure our Workplane Snap is on. The same way with
Grid Point Snap. So you can see, we're snapping to our grids.
Because we just want to do a nice straight line,
and that's it, real simple. Grab a Circle.
And then let's also grab a Sweep. We'll go back into here. Our Circle,
you want to make sure, is set to XY. Otherwise, when you put in your Sweep,
it's going to look all weird, and not do you any good. So, our Circle,
let's change you to about three centimeters. And we're just going to
animate our Start Growth and our End Growth. You'll see that does that.
This animates from there. So, set everything to zero. Make a frame...
Oops. Make a frame on both. Let's go to five,
let's change End Growth there and key frame both of those guys.
And then we'll go to 15 and then we'll set Start Growth to 100.
And then key frame both of those again. And then we're going to go to frame 30 and
key frame both of those again. You'll see why we do that in a second.
So, we go down here to our curves. You'll see we got this thing right here.
If you hit S, it just will zoom in on whatever you have selected.
So, we see our nice keys over here. I'm going to click on Sweep.
On After, let's change that to Repeat. Change those Repetitions to 99.
And what's that going to do, if we zoom out, you'll see we are now repeating those
keys 99 times. And 99's kind of arbitrary, just want to have...make sure we have a
lot of repetitions here, so we don't have to go in and start animating a ton of
stuff. It's just one simple little thing that repeats a bunch.
And the reason why we added our keys at the beginning and at the end,
even if we weren't changing anything, is because this now becomes our loop.
So if we went into Start Growth, and let's say, deleted that point and deleted the
end point here and we pressed play, you'll see it starts getting all real weird
because this is repeating just 10 frames, whereas End Growth is repeating 30 frames
and they're just off. So, it's not going to line up. So even if we're not animating
anything on there, you want to make sure we have those keys, and it's basically
just telling it, "Repeat this whole section for both of these." So we get
that. So now let's do the little beacon part at the end of that.
So what you want to do is grab a Torus. Just take this Torus, we'll set it to
zero. And we're going to animate our Ring Radius and our Pipe Radius.
So, we'll put a key again, at zero. Let's go to five. And we'll make another key on
those. And then let's go, let's say 30. We'll put that up to...that's
probably good. And then Pipe Radius, key that again.
And then we'll go to 40, and that is to... Sorry, we want this at 30,
[inaudible] 30. There we go. We'll go that. Let's say there. So,
you want to make sure this is the same length as this one. So,
they're repeating in the same amount of time. So now this is doing that,
not doing exactly what we want. So, let's go to, I don't know, frame 12. Why not?
Pipe Radius, we will animate that up. Now, what we should get...there we go...is a
pipe that animates on and then disappears. Let's click this.
Let's tweak this a little bit. So, Ring Radius...let's go into this guy and just
like pull that like this. And what that's going to give us is,
more of this like explosion at the start and then easing out.
You'll see how it kind of pops quick and then it eases out. And that's exactly what
we want with that guy. And we can go in here and just sort of pull that just a
little bit, just to adjust the curves. Let's try that one more time.
There it is. So, I think that's nice. So, let's grab this Torus.
Let's duplicate it. And just take everything here,
and just move it down just a few frames. We can move this over, let's say,
two frames. Now, we should have two of these guys. And I want to have a little
more pause between the two of them, so it's really just taking the frames in the
beginning and just shifting them down.
That's probably a little too much.
You know, we're really just trying to get a feel for this nice pulse there.
So I think this one...yeah, I think that's good. We're going to do the same thing
with these that we did with the Sweep, is make sure we select those.
After, change that to Repeat. Let's change that to 99 so it repeats forever-ish.
And we'll get that. Perfect. But now, this needs to go over there.
So, we're going to do that by selecting our Torus, changing both of them to
negative X. For this one, they could both be positive X, doesn't make a big
difference for this. Let's find a frame where we can see how long that is.
And then turn off our snapping, since we don't need snapping.
And let's just move these guys to the end. And then what that's going to give us,
should be a nice pulse that hits and gives a little pulse at the end of it as well.
Great. So now that we have our beacon, let's make a new Null object.
Put that in there. We'll call you, "beacon." And let's make a Sphere,
because now we're going to work on the globe part of this. So this Radius, we'll
put this up to 1,500. We'll change this to Icosahedron, and then let's increase the
Segments on this. Let's go up to 60. I also want to delete our Phong Tag.
And then, also uncheck Render Perfect, and what that's going to do for us is render
this and be able to see the tessellation on here, which will be a really nice look
when we get everything put together. So, just really quickly, to make our lives a
little bit easier, let's make two shaders. One just a white Luminance,
and we'll put that on the beacon. So that when this is animated,
we can see our guy right there. And then on our sphere, we'll make a new shader.
This one's going to be a little different. Let's keep the color.
We're going to put on a Fresnel, and we really want to get... What we want here
is... Oops, sorry. I think I did that in the wrong thing. Yeah,
I did the Luminance some more. Fresnel, there we go. We want to get a
white kind of outline on this. So, we do something like this and that should give
us something like that. So we get this nice white outline,
and you can really see what's going on here. We can see the tessellation
on this stuff, which is really cool.
So, in Reflectance, this is just going to remain default.
We can change this, if we want this spot to be a little tighter.
We don't want it as big. So, we could do that. So, really nothing fancy going on
with this, nothing too crazy. So, good. I like that guy.
So these are our two objects in here. So, we want to get our beacons around our
sphere. We're going to do that with a Cloner. And we're going to put our beacon
inside of our Cloner, change our Cloner to an Object Cloner. And we want to clone it
on the sphere. So, it's going to go crazy for a second, because it's going on every
single vertices. We don't want that, we want it to be Surface.
And we can set it to, I think 20's good. You can obviously increase it,
if you want to, but right now I think 20 is good for what we're doing.
The other thing we want to do is, you can see how everything is on here now,
animating at the same time and random directions, none of which is what we're
looking for. So let's go to our Cloner. Uncheck Fix Clone and go to your beacon
group and let's just rotate this 90 degrees. What that's going to do is have
these beacons shoot out of our sphere now. So, these are all looking cool,
but what we're really missing is that off-set of all of that animation.
So we want to click on our Cloner and our Effectors. We want to add a Random
Effector. So, let's go into MoGraph, Random. Let's turn off Position,
we don't really need that. But on Scale, turn on Uniform Scale. Let's just
adjust it a little bit, just for a little bit of variety here.
Nothing too crazy, but the important thing down here is the
Time Offset. Let's change that to 20. And what that's going to do is look at the
animation inside of our Cloner and then offset each clone by 20 frames.
So you'll see now, we have this really nice offset. You can see we're already
adding complexity to this entire thing. So let's keep going with making the rest of
this globe. So we have our sphere, we want to add a little bit more. We add some more
detail on that guy. So let's duplicate that. We'll delete our shading,
from here we don't need that. Let's put this inside of an Atom Array.
And then we'll leave this, as is right now. Because I think we have this...we're
starting to get this nice cool look to this. It's a little big,
let's just put this down to one and, let's say three. We want it a little finer,
just like that. That's good. We'll make another shader and this one... We'll turn
off that stuff. Just use the Luminance, and we'll make this, I don't know,
a little gray. That'll go on top of our Atom Array. And
let's duplicate that Atom Array one more time. And then take the Sphere and let's
make it a little bigger. You can probably also reduce this. Let's go down to 30.
And what we're going to do with this guy...let's see, we have this looking good
so far. It's still a little big. Let's put that down to .1, so we have this nice fine
outer Atom Array on here. We're going to do a little something
different with this, we're going to go back, get another Random Effector,
put that underneath our Sphere. Position we will do zero, zero but we'll leave
this for right now. On Deformer, let's change that to Point. And let me just
select this, so you can see what's going on here. So, with this set to Point,
we're deforming the points. We're getting a little variation on this guy,
which is nice. But what we want is a little bit of animation on that too.
So, click on the random effector again. Click on Effector, Random Mode,
we're going to set that to Noise. And what that's going to do...this is hard to
see, so we'll turn our Atom Array off for right now. What that's going to do is give
us some animation on top of our deformed sphere, on our outer sphere,
which is exactly what we're looking for. So, let's go back into the parameters
here, and we'll just increase this to get a little more variation in there.
So now we've got this nice cool thing, it's probably going a little fast.
So, just, on Animation Speed, let's put that down to 50, so it's nice and slow.
Turn our Atom Array back on and if we zoom in here, you can really see what's going
on. So, I think that's really cool. That's really nice. Let's do a quick test
on that. And you can see how this Atom Array looks on the outside.
So, let's keep working on this guy. Let's duplicate this outside Sphere.
Delete that, we don't need that anymore, and we will increase this even more.
And let's add another Cloner and another Sphere, put that inside of our Cloner.
This guy is tiny, let's set this to like three segments. Three is good for that.
What we're going to do is then, turn this into an Object Cloner again,
and clone our new sphere. And then turn the visibility off on this
guy. Oops, not that guy, on this guy. So, what we want to do is,
just grab that same random effector from here, put it underneath...let's duplicate
that...put it underneath this guy here. And you'll see now, we're just adding a
little more variation to our dots on the outside. So this thing's looking pretty
cool so far. And everything, as you can see, is animated here.
If you want a little bit of variety there, you can go here and increase this speed.
Let's say, 75. So these outside ones are going to be moving faster than those
inside guys. So, let's also...we want to make those tick marks that we had.
But first, let's clean this up a little bit. So, we have this,
and these are our beacons. So we'll call you, "beacon_GRP." I'm going to just
turn that off for a second. And then, all this stuff here is our
spheres. So we'll call this, "spheres_GRP."
That's not how you spell that.
Let's put all of this inside of there. Cool. So now we have our two groups,
so let's make those tick marks. We'll just turn these off for right now.
And these tick marks, we want a Cube and we want a Cloner. So we'll throw our Cube
inside of our Cloner. Our Cloner, we're going to change to Radial.
I'll turn on our spheres, just to see how big we need to make this.
I think we're at 59, so let's try 2,500. Probably a little less than that,
2,000. There you go. That's probably good, probably go a little bigger.
Great. And then our cloner, let's change it to 360 and you'll see right now,
they look kind of crazy. That's useless to us. So let's go in here,
make these all smaller. We still got these nice dots, but we want tick marks.
So, let's put this up to, let's say 25, and so we get this nice fine tick mark
radial element around here. And let's duplicate that, and we'll put you to 50.
And you can see, we're getting this nice look here.
So let's again go to Effector, Random effector. We don't need our Position,
but we do want Scale. So our Scale, we'll crank up a bit. Let's put that at,
let's say three. And then we also want this to animate because right now it's not
doing anything. So we'll go back to our Noise, and press play.
And you can see our animation here. And one interesting thing to look at with
this stuff, is you can really see what Scale is doing on our Noise.
Our Scale here is adjusting the scale of the Noise itself. So,
when this is really, really big, you can see how it's very, very smooth.
Looks almost like it could possibly be a wave form, if these were much larger.
You know, if we were to take this and make these a lot bigger. You can see how this
starts to look, maybe like a wave form, maybe like audio, something like that.
But we want these smaller and if we take the Scale here and make it smaller,
you can see how each one of them, sort of individually looks like it's moving.
That's because the noise that's affecting it is much, much smaller.
You want something in between so, you know, we'll do somewhere around here.
I think this is nice. So now that we've got this,
we just want a few more of these.
So, we will make another Cloner. We'll put this guy inside of that.
Let's move that up. So in this Cloner, I want to keep it linear.
Let's turn that off. And then, we'll set this to 110, so we can get these to scale
up a little bit. And then let's animate...not animate. Let's just adjust
some of these, which I think is cool. So, now we got this kind of look
We press play, everything's animating. Everything's working out well.
What we want to do is go into our Cloner, our Transform of our Cloner.
You see we get this stuff moving here. Let's make a key in the beginning here.
Let's go to frame, let's say, 40 and just move that and, let's say, that.
This stuff is kind of arbitrary here. Let's set that key, press play.
So, you can see everything is moving, but we kind of want this to do the same thing
that the other stuff is doing and just move, animate indefinitely.
So, I want to go down into... I'm sorry. Go down into our Timeline here and we're
animating our Cloner. You can see, right now we have this nice curve here.
We don't want that, we want it to be linear. So, you go up to here,
to this guy. Click Linear. That'll make it linear, so we're not easing in and out.
And then, the same thing we were doing before, except instead of going to Repeat,
let's do Continue. And that'll continue this line
indefinitely. It'll just go forever, and that's exactly what we want.
So now, let me play this. It keeps moving. So if this is too fast,
we could do... The nice thing about doing it this way is, just grab this key frame,
drag it down, and now it should be a little bit slower. And if that's still too
fast, you can ease them all the way out and just move it all the way over there.
Now, you got this nice slow animation on that. And the final thing we want to
do, because now that we have...let's turn this guy on too...now that we have
everything animating the way we like, some things are a little static.
The globe itself is a little static, so let's take everything off first.
Let's put these guys in here and we'll call this, "tickMark_GRP."
And then let's make a new Null and we'll call this, "globe_GRP." Throw all of this
in here. And then really, simply key frame, key frame, and then the same thing
we did last time. Clicking on our curves here, setting them to Linear,
and then setting it to Continue. Let's see how that looks.
So, I think that's probably going a little too quickly, so we'll just drag
this. Let's drag this guy all the way down, so it slows down.
Now, I have this nice, slow rotating globe. And let's just look at this.
And there you go. And so we have this cool looking FUI globe, with a lot of
animation, a lot of complex animation that's very, very simple to do.
But by using Cloners and offsetting the time, you really get this complexity here,
that's actually very simple to do. We maybe have, I don't know,
10 key frames in this whole thing and the rest of it's being animated with Noise.
So, it's really, really simple but you get a lot of bang for your buck in this
method. So I hope you enjoyed that. I hope you guys learned something
and thanks for watching.
My name is Russ Gautier. I'm the Art Director at Perception.
Today, we're going to talk about animating HUDs to go into your FUI fighter jet or
space fighter cockpits. We've got a project file that's already set up here
for us. Everything is live in that, so you can take it and tweak it,
and use whatever fonts you want, or change all the elements around.
What we're going to be talking about today is primarily how to animate it.
Not just how to animate it, but how to animate it based on the movements of a
camera through space. So we've got a camera that's flying along a path,
and we're going to use the data that that camera generates to actually move all of
our HUD gauges and displays, and what not. So let's jump right in.
All right. So we can see we have a whole bunch of things going on in here.
We'll explain all of these here in just a moment. You can see,
we've got a bunch of splines and everything. Let's go ahead and hide some
of these elements, so that we can better understand what's going on here.
I'll hide this guy too, so we don't have that line in there. So under Static
Elements, we have a couple of boxes with some text. We've got a couple of these
spline masks with a Connect object, a Null, and then a couple cloners under it,
and those are generating our tick marks and our numbers, and they slide up and
down. The same thing on the other side with our air speed there.
Now, if you look at the hierarchy here, we've got these Connect objects in the
spline masks. What that does is actually connect all of those cloners together,
and then mask them out using that square, so you don't get numbers that go all the
way up and down the screen. We just isolate them in those little areas there.
Let's go ahead and hide that, and then let's look at our Pitch Ladders.
Now, the Pitch Ladders in here, we have a spline representing our horizon,
and then we have two cloners. If you jump out here, you can see that those are
actually Radio cloners that go all the way around the camera to represent the pitch.
Let's go ahead and hide that, and let's take a look inside this Rig Null.
Now, in here, you'll find a bunch of different things. We've got a couple of
splines and a Null here. So if we look at those splines, they actually describe a
flight path that we're using an Align to Spline tag to actually fly the camera
along. So you can see here, it's got this kind of crazy, looping path.
If I hit Play, there goes the camera following it along right there.
We're actually going to use that information to move our gauges and what
not in our HUD. Let's go ahead and hide those, and then look inside this heading
and reticle. You'll notice here, again, we have a cloner that's set to Radio,
and this time it's on the XZ Plane. If we look through the camera,
you can see exactly what we've got going on here. So we've got a couple of splines
here. We've got a box with some text in it. We've got an effector that is turning
off all of the clones outside of our box, and then we have our cloners,
and then in here is just some splines that build our reticle. All right.
Let's go ahead and hide those, and we're going to hide our rig and we're going to
jump right into animating our static elements. But before we do,
I actually want to talk a little bit about an Expresso node that I use a ton in this
tutorial. So to help me here, I've got a sphere and a cube, and we're just going to
drop in an Expresso tag here on either one of those guys. I'm going to just shrink
this guy down a little bit and move it over, so we have a little space,
and I'm going to drop in my friend, the Range Mapper node. This is a super-useful
node that basically takes a number range as an input, and remaps it and outputs a
different number range. That can be all kinds of things. But here,
we're just going to start with a Global Position Z from our sphere as an input.
Then, I'm going to take my cube, bring that guy in here on the other side,
and pipe into its Global Position Z, as well. Just scale these guys up just a
little bit, and pipe that into the output there. So what we're going to see here
isn't terribly spectacular just yet. But I'm going to grab my sphere.
I'm going to move him in Z, and you can see the cube moves right along beside it.
If we look here at the Range Mapper, you see our input range is zero to one and our
output range is zero to one. So nothing is actually happening.
But if we change this to an output range of 0 to 0.5, now we're going to see that
cube move half the distance of that sphere. We can see here, if we type in
"400" for the sphere, we've only moved 200 for the cube, which is exactly what we
expected to see. The same thing in both directions, backwards and forwards here.
So we're not limited to the same types of values, either. It can be any input and
any output. So let's delete this Range Mapper and just drop in a fresh one under
the Calculate menu here. So for this one, I think I'm going to try something
different. I'm going to take the Global Rotation, let's try Heading,
and we're going to pipe that into our Range Mapper. We're going to output to the
Global Position Z for the cube. So now, if we look under here,
we need to change our input type to Degrees, which you see changes to 360.
Let's output 0 to 10, and turn on the wireframe, so we can see things a little
clearer. Now, if we rotate our sphere, you can see our cube is moving just a little
bit. It's not moving terribly far, so let's go ahead and take that to 100.
Let's make that a little bit more extreme, so we can really see it.
If we take this value to 360 and we can go back to our cube, you can see here we're
at 100, which is exactly what the Range Mapper says, 0 to 360 is outputting 0 to
100. So we can also reverse that. We can go 100 to 0, and what that's going to do
is the inverse. So when I rotate my sphere, my cube is actually going to go
backwards from where it was before. So if I set my Rotation to zero,
you can see now my cube is sitting at a Z Position of 100, which is what the Range
Mapper is telling me it would do right here. This is a wildly useful tool.
I use it all the time, and I use it in just about every step of this tutorial.
I use it for moving all of my gauges, remapping Position to Position,
remapping Rotation to Rotation, and then remapping Position to Rotation in some
cases. It should also be noted that I've actually figured out a lot of these
numbers ahead of time, and I'm not just pulling numbers out of thin air when I'm
plugging them into these Range Mappers. These are just values that I've found work
particularly nicely with this rig that I've built here. Feel free to change them
and experiment, and go nuts. The first thing we're going to need is an Expresso
tag, and I'm going to put it on the camera here. It doesn't really matter where it
goes. But the camera is a nice central location. I'm going to set its priority to
one, and that's because we want it to calculate after the Align to Spline tag
that's on our Plane object here. I'm going to drop our Plane object in here,
and I'm going to show the Global Position Y output. Now, we're going to drop in our
first Range Mapper node. So we're going to go down here and grab that,
pipe that in there, and set our ranges. So we're going to use a maximum input of
20,000. That represents the maximum Y offset for the camera path,
and then our output range is going to be negative 1,050 and negative 1,150,
respectively. That represents the minimum and maximum Y offset for my gauge itself.
Now, next, we drop in our Null object and we just pipe the output of the Range
Mapper into Position Y. If I hit Play, you can see here, just a little bit of
movement in there. So it is clearly doing the right thing. Next,
we want to animate that text in the box, and we want to use the output from our
Range Mapper. The problem is the output values are negative, and we do not want a
negative altitude. That would be bad. So we're going to use a Math node,
and we're going to multiply the output of that Range Mapper by negative 10 to invert
those numbers back to a positive, and then make them 10 times larger.
I'm going to grab the text, and we're actually going to want to clamp that to an
integer. So I'm going to drop in a Calculate a Clamp node, and we're going to
pipe that into the output of the Multiply. We're going to set it to Integer,
and we're going to go into the parameters and just set these to some absurdly small
and large values, so we don't ever hit the limits. We're going to pipe that right
into our text. So we'll see this number change now if I hit the Play button.
There we go. Because of that Clamp node, we don't have any decimals in there.
We just have integers. So moving on to air speed, we're going to want to pull the
Position velocity off of our Plane object, and we're going to grab another Range
Mapper node. We're just going to pipe that into the Position velocity,
so we can take the velocities off of our Plane object and remap them so that they
can offset our airspeed gauge. So we're going to set our input range from 0 to
6,000. That represents the input velocities. Then, we're going to set our
output from negative 750 to negative 800, and that represents the Y offset of the
gauge itself. We're just going to drop in our Null object and do the exact same
thing, Position Y offset, pipe that right in. So with Position velocity,
you have to hit the Play button in order to actually see any velocity change.
But you can see here, our scale is moving appropriately over here.
So to do the text, we're going to pipe the Range Mapper into another Range Mapper,
and we're going to set our input lower and upper limits to the output upper and lower
limits from the other Range Mapper. Then, we're going to set 380 and 403 as our
output limits. Again, we're going to do our Clamp to integers,
and then just drop in our Text object and pipe the Clamp right into the text field.
If we hit the Play button now, we see our text field animating and that looks great.
All right. Well, now that we have those elements done, we can actually move on to
the next piece. So let's go ahead and hide our static elements,
and let's animate this heading. So I'm going to go ahead and show the heading
information here. Now, the heading actually lives outside of our main Plane
object here. So we're going to need a Constraint tag to make it follow along.
We're going to set a PSR Constraint, and we're going to set its priority to one,
again, so it takes place after our Align to Spline. We're going to turn off
Rotation, because we just want the Position values from our Plane object.
Then, we're going to turn on a Spring Constraint, just for our Rotation value.
Again, we're going to drop in our Plane object, and we're going to set a Drag to
80, because we don't really want it to be springy. We just want it to sort of drag
behind a little bit, and set its stiffness to something like 25.
Now, if I hit the Play button, you can see, it moves in this really interesting
way, where it's trying to keep up with the camera. Now, since we're using a Spring
Constraint, if you go back to the beginning of the timeline, sometimes it
lags behind. You've just got to hit the A key a couple of times to get it to come
back. So let's go back into our Expresso tag here, and let's animate these heading
settings. So what I need is the Global Rotation H, the heading of our Plane
object here. We're going to start by animating the cloners that make up all the
tick marks. So I'm just going to go under here, and I'm going to grab those two
cloners. This one is going to be super-easy. All I've got to do is pipe
that Global Rotation right into the offset value of our Cloner objects here.
I'm just going to pipe those right in, real quick. So once those are all
connected up, we're actually just going to animate the text in here as well.
So the text lives right under here, under this box, and the first thing we're going
to need is our friend, the Degree node. Because Cinema works in radians,
but we want a display in degrees, we have to drop in this node here,
right in the beginning. Then, our friend the Math node, what we want to do is
actually subtract from 360 degrees, our value here. So we're going to pipe that
into the second input. That's pretty important for a subtraction.
Then, we want to grab our Clamp. So we again clamp to integer values.
Except this time, we're not going to do crazy large values. We're just going to do
0 to 359, and then we're going to pipe that, of course, right into our text.
Drop that right in there. Now, if I hit the Play button, you can see our heading
is ticking along as well as in our text box. So there's Heading all buttoned up
for us. All right. So we can close out that Expresso window. Let's not hide that,
actually. Let's hide the entire thing, and let's move on to the Pitch Ladders.
Now, Pitch Ladders is kind of a weird beast. I just have to follow along here,
because we're going to constrain a bunch of different things to each other.
So the very first thing we're going to do is drop in a brand new Null object,
and we're going to name this "Earth Reference Objects." That's going to make
sense here in just a second. We're going to duplicate that Null object.
We're going to drop it inside itself, and we're going to name this "Front Null",
and then we're going to duplicate Front Null and name this "Up Null."
We want to make sure that we have all our values set to zero, zero,
zero, and we're going to set our Up Null to a Y of positive 500 and our Front Null
to a Z of positive 500. What we're doing is creating a Target and an Up Vector for
a Target tag that we're going to use here in just a minute. Just for the sake of
visualization, we're going to turn on Cube mode for our Null objects so we can see
them a little better. So now that we have those made, we want those to sort of
follow along the camera. So in order to do that, again, we're going to use our
Constraint tag. In this case, we're going to use a Parent Constraint and we're going
to set the priority to one, just like we've been doing. Then, we just want
Position. So we're going to turn off Rotation. We're going to take our Plane
object, we're going to drop it in there, and zero out all the local attributes
here. If I hit Play, you can see something is going on. Nothing is happening to our
Pitch Ladders yet, so we've got to fix that. But at least we have some kind of
movement on the Nulls. Now, to get those Pitch Ladders to move,
we got to connect those up over here. So we're going to use that Target tag that
I was talking about, and we're going to put our Front Null into the Target object
and our Up Null into Up Vector. Now, if I hit Play, you can see,
my Pitch Ladders and horizon line are following along my Null Switches.
Fantastic. The problem is, they just seem to want to drift off to the side.
So what we want to do is make sure that they're always looking or trying to look
forward. So in order to do that, I actually need another Null object.
We're going to drop that guy in there, and we're just going to rename this thing
"Rotation Reference." Now that we have our Rotation Reference,
that's going to reference the rotation of the camera itself, so that we're always
pointing our Pitch Ladders in the right direction, and we're going to of course
drop in a Constraint tag. In this case, we're going to use a PSR Constraint.
We're going to set its priority to two, because we want it to take place after the
Position and we want the Rotation to take place a little later.
So we're going to turn off our Position, because we've got that covered.
We just need the Rotation values. We're going to drop in our Plane object,
of course, here, and what we need is to connect the Earth Reference Objects to our
Rotation Reference. So we're going to drop an Expresso tag. We're going to take our
Rotation Reference Global H. We're going to pipe that right into our Earth
Reference Global H, just like that, and we want to make sure to set this priority to
three, because we want this to take place after all of our other calculations are
taking place. Now, if I hit Play, you can see we've got our Pitch Ladders pitching.
We've got our horizon line going. Now, if I turn on this, you can actually see,
I've got a Gradient setup with a horizon line here, and you can see that's
following along very nicely to the horizon. We're getting pitch as the camera
pitches up. So that's all working okay. But I think what we want is something a
little more interesting than just a regular Rotation. I think we want to use a
Spring Constraint. So let's go ahead and set that Spring Constraint up sort of the
same way. We're going to set our Rotation. We're going to set its Drag to 80.
Now, when I hit Play, you can see the Pitch Ladders are behaving appropriately.
But now, when the camera moves around, you can see the Pitch Ladders don't sit
exactly in the middle. They're always kind of trying to follow the camera around,
which creates this really cool, kind of organic movement that you see in fighter
jet HUDs. Now, let's turn everything back on and just make sure everything is still
cooperating, and we'll hit the Play button here after hiding a couple of our elements
we don't really need to see. We have our heading. We have our Pitch Ladders.
We have our altitude. We have our air speed. As we're kind of flipping around
here in space, we've got everything moving in concert, and it's looking really rad.
So this is a version that I whipped up really quick, just to show you guys
something a little different. We've got some more aggressive angles and some
different colors, and there's a little Rotation on the reticle element in the
middle there, as we're flying through our sort of "Cubetron Starfield" world.
All right. So we learned a whole lot about Constraint tags and setting up
relationships with Expresso to create really interesting, dynamic movements and
visual elements here in Cinema 4D. I hope you guys enjoyed it.
We'll see you on the next one.