Transcripts
1. Blender Animation Basics: Welcome back. Aaron F
Ross here once again with part four of Blender
Basics, the bouncing ball. In this course,
we're going to look at the fundamentals
of animation, how to create keyframes and also a bit about how
to set up a basic rig. And we'll delve into some
of the minutiae of blender, having to deal with
how it creates parent child links and the issues that can
come up from that. It's going to be a bit of a side quest for us
to deal with that. It's not pretty, but we will have to kind of suffer through that part in order to set
up our rig correctly. But by the end of this course, we will have some basic
keyframe knowledge and also some deep understanding of how parent child
linking works. And then we'll be
in a good place to progress to finessing that animation in the next
course, which is P five. So let's take a
look at setting up a basic rig to start
with. All right.
2. Using the exercise files: Let's take a look at
the exercise files I provided with
this course series. You should have downloaded the exercise files and extracted them from the ZIP document at the very beginning
of the course series. And that means you should have a folder full of scene files, labeled three D scenes. And also some input textures, which are image files and some
example output renderings. In the three D scenes folder, we've got the
Blender scene files. There's usually one scene
file for each movie, and they're numbered
according to, first of all, the course number
in the sequence, then the chapter number
within that course, and then the movie number
within that chapter. Generally, these scene files
flow from one to the next. For any given scene file, it's the begin state of
that similarly named movie, and it's also the end state
for the previous movie. With a few exceptions, if there is no subsequent
movie in the sequence, then I will have provided
a finished version, which is the end
state of that movie.
3. Understanding transform hierarchies: The bouncing ball is the classic first
animation project for new animators or for
someone learning a new animation program because
it's deceptively complex. In the final rendered animation,
it looks pretty simple. There's just a ball,
but there needs to be a control mechanism
behind the scenes that allows us to move and rotate and to form the ball in
the way that we want. In order to art direct
that animation, we have to have
what's called rig. The simplest kind of rig
is called a hierarchy, and that's the inheritance of transforms from one
object to another. And this goes by many names. You'll see it called a
transform hierarchy, an animation hierarchy,
a scene hierarchy. You'll see it called
parenting or linking. All those terms mean
the same thing. It's the inheritance of transforms from a
parent to a child. I've got this
simple example here of an artist
mannequin character, and all the mesh objects are linked together
in a hierarchy. Now, this is a teaching example. In a real character
animation workflow, you would not actually link the mesh objects
directly to one another. You would use an internal
structure called an armature. But this is just a
teaching example to show you how
hierarchies work. If we select one of
these objects such as a shoulder and transform it with one of the
tools such as rotate, will see that some of the
objects follow and some do not. The shoulder object is the
parent of this elbow object, and the elbow is in turn the
parent of this wrist object. And so when we
transform a parent, the children will inherit
that transformation. But the children have
their own transforms, independent of their parent. For example, if I go
to the move tool, select the elbow, I can move
that elbow independently. And if we do that and
look really closely, we'll see a dashed black line. That's a relationship
line showing the linkage from the
child to the parent. Okay, I'll undo that
with Control Z. If we select, for example, this chest and rotate it, then multiple children are going to rotate with that chest. The head and both
of the shoulders are children of the chest. So we've got some simple rules
around hierarchies here. Number one, children inherit the transforms of their parent. Number two, a parent
can have many children. But there's also a
corollary to that, which is that a child may
have only one parent. Now, there are workarounds
for that using constraints, but let's not get ahead
of ourselves here. For the simple bouncing ball, all we're going to need is a straight up animation
hierarchy and nothing fancy. Let's investigate this
a little bit further. If we go to the outliner, we'll see there's a peel
this object listed. And if we click on the
right facing arrow, we can open that hierarchy up and we'll see that it includes
a bunch of other stuff. Now we are a little bit
distracted by the fact that the object data
properties are also displayed here in the
outliner by default, and that's kind of muddying
the waters here a little bit. We can turn that display off if we go up to the filters here, and we can turn off
object contents. And then we're only seeing
the transform nodes, the object properties, and
not the data properties. Okay, we can continue
to open this up and see that there's a
bunch more stuff linked. If we shift click on a parent, we can expand the
entire hierarchy and all of its descendants. So we've got a bunch of objects that are
linked to one another. Okay? So that's how
hierarchies work. It's nothing fancy, really. It's just simply an object will inherit the
transforms of its parent. And again, the other rules are that an object can
have only one parent, but a parent can
have many children.
4. The value of the Empty: In any three D program, there's a non rendering
transform node. It's an object that doesn't have any polygons, doesn't
have a surface. All it is is just a
location in space. And its purpose is
to allow us to build different kinds of hierarchical structures
or animation rigs. And this non rendering transform
node goes by many names. Its names are legion. I first learned it as a null, but it's also known as a dummy, a point helper, a locator, or in Blender, it's
known as an empty. And that doesn't really give a sense of how important it is. It makes it sound kind of
insignificant. It's empty. But an empty or a null is one of the most important
things in a three D program, and allows us to do
interesting things like make the ball, move, rotate, and deform
in different directions. So it's really a
key component of any animation is this empty
or null or dummy or locator? We're going to create
a locator or an empty, but I want to just clean up
my view a little bit here. I want to focus only
on my ball rig. I'm going to go over to the
outliner and hide everything else by clicking on the visibility icons,
little eye icons. I'm going to hide the ground, the camera, and the backdrop. And now I've just got my ball. I'll go back to my
standard single layout. So that's a little
bit easier to see. And I'm just going
to create the empty. From the viewport menu, go to add empty. And we see we have
some options here. This is just how the empty is going to
display in the viewport. What is its icon or
Gizmo or manipulator. And we can change this later. So it doesn't matter
what we choose now. I'll just go with
plain axes for now. So it's created at the origin because that's where
my three D cursor is. Previously, in the course, I hid the three D cursor
because I never use it, and I only want objects to
be created at the origin. So the empty is created. And if we go to its
transforms, we'll see, Okay, it's at the origin. It's
got a scale of one. If we go to its data properties, we see we can
change its display. We can set that to
something else like a sphere and increase
or decrease its size. So I'm going to bring this up
to a radius of 0.2 meters. That's going to make it a little bit larger than the ball. Generally speaking, you want your control objects
or rig objects to be slightly outside the
renderable mesh object. Okay, we want to
rename it, as well. I'll go into the outliner.
Double click on that. And I'm going to call
this position empty. We're going to have
multiple empties, but this is going to
be the first one, and it's going to be the
most significant one because all the other parts of the rig are going to derive their position from this empty.
5. A simple animation rig: Continuing with the building of a simple rig for
the bouncing ball, we need a couple more empties. Right now, we've got
a position empty. And that, as the name indicates, is going to determine where our rig is,
where the ball is. But we need a couple
more empties. We need an empty to control the rotations
because, for example, we want the ball to be oriented
in some interesting way, so it can be turned at some diagonal relative
to the world. But we want it to spin in some axis that is aligned with the world
in a controlled fashion. And although it looks
like we can do that here, if we tried to
actually animate that, we would lose
control of the ball, and it would spin in
crazy directions. So in order to have actual control over the
rotation of the ball, we need to link that ball
to a helper or an empty. I'll undo those
rotations Control Z, set that back to neutral, and we need another empty. We've got a position empty,
and it's at the origin. We also need a rotation empty. So I'll go back to add empty. And for this one, I don't
want to use a sphere. I want to use something
that'll be really clear in the viewports exactly how
the object is oriented. The sphere isn't really a
clear indicator of that. But if I choose a cube,
that's really clear. When it's set to a
diagonal rotation, I'll be able to see
that really easily. And I probably want to
make that larger, as well, bring its size up to 0.2
meters and rename it, go into the outliner, double click on it,
and I'll rename it. Rotation empty. And finally, we also need an empty to determine the orientation
of the deformer. We're going to add some
squash and stretch to this. That squash and stretch
is going to happen at rotation angles that are different from the
ball's actual spin. We want the deformation
to start out being oriented with the
Z axis of the world, so the ball will actually
squash downward. And then after that,
as the ball rotates, we want the deformer to rotate, as well in synchronization
with the ball's spin. So to do all of that, we
also need a deformer empty. So I'll create one
more. Go to add empty. And in this case, the
optimal display type is a single arrow. That's going to very clearly indicate the orientation
of the deformer. So I'll choose
empty, single arrow. And I want to go into its object data properties,
increase its size. Let me bring that up to
let's say 0.3 meters so that it actually extends
beyond those other objects. Now, all those empties
are at the origin. I also want to place my ball
at the origin, select it, go to the object properties, and just drag my mouse
across location X, Y, and Z, type in a zero. Rotation and scale
were already at zero. So now I've got the
essentials of this rig. I've got all the parts. Our next step is to link
all of the parts together. But I'm going to need
to go on a bit of a side quest because the way the Blender deals with linkages is extremely
problematic, and it's actually
the number one most problematic thing
in all of Blender. So in the next movie, we're going to need to
take a little bit of a detour to look at the issues around
linking and Blender.
6. How not to link to a parent: Nothing in the world is perfect. There's no perfect
three D program. Every program has
got some issue, something about it
that we don't like or that we wish had been
designed otherwise. Well, Blender actually
has quite a lot of those, and it's because Blender
developed in isolation, and the design is almost
aggressively unconventional. It's almost as if
the designers just wanted to throw away
every convention that had been developed
over the course of decades of the three D industry, and they wanted to just sort
of blaze their own trail. Well, that's fine
until it's not. And one of the things that's a major issue with
Blender is how it handles the display
of child transforms. So I want to go into
this and show you what that issue is and how
to avoid the problem. You have to take
special extra steps in Blender to make it behave correctly around how child
transforms are displayed. We also have a limitation in Blender where we're not allowed to have different colors for
the empties or null objects. And that's kind of bizarre. We can only set a theme color if we really needed
to have different colors for different empties, we would want to actually create curve objects and
use them as empties. But in this case, I just want to make these empties more visible. I'm going to go into the
edit menu to preferences, to the themes, and we want to go into the
three D viewport, and these are all
the color settings. And here's the color of an
empty. It's just black. I'm going to click on
that color swatch, go to RGB mode. I'm going to make these
empties all solid green. They will now be super
obvious. They will stand out. We cannot possibly miss them. Maybe make it a little
bit less intense. We can bring that green
down a little bit. But okay, now we can actually see what
we're dealing with. So I want to move the ball and one of the empties away from the origin to illustrate
what the issue is around child
transform display. So I'll go over to the outliner, select the position empty, control select the ball
and grab the move tool, and I'm just going
to position those both back out with
Control middle mouse. And I want to position
both in X and Y. So we have non zero
values for both X and Y. And they're both at these
transform values as shown here in the object
properties. Okay? So those two objects are
exactly on top of each other. If I select the ball, we'll
see those transform values. If I select the empty, we see the transform
values did not change. Okay. Now, the way the
transform inheritance works is child transforms are
calculated in parent space. So every object has its own
local coordinate system. You could think of it
as axes that extend outward from the origin or the
pivot point of the object. So every object has its own
local coordinate space. If an object doesn't
have a parent, then its parent is the world. And those are the values
we see displayed here. These objects don't
have parents, and so their values are in parent space, which
is world space. Okay, if we have a child, then the child's transforms are calculated relative
to the parent in the space of the parent. So if you have a child that's in exactly the same
place as its parent, then the child's location is zero. This is
really important. It's not trivial at all. If we want to be able to effectively animate something
that's in a hierarchy, we need the child transform values to not only be
calculated in parent space, but also be displayed in
parent space so that we can, for example, control the
movement in various axes. I can't stress this enough. This is really, really critical. We have to have
transform values of children displayed
in parent space. That is not what Blender does. Blender is the only program
that has this issue. It displays the child
transforms as where they were in world space at the moment that
the link was created. And then if you move the
child away from its parent, the child transforms
will be displayed as an offset from where the child
was before it was linked. If you think too
much about this, it's going to make
your head explode. It's really, really problematic. It's a very, very
problematic design decision. And I have no idea what the Blender
developers were thinking, but this is a big deal. I'm going to do a link, and
you'll see what happens. I'm going to select the ball and then I'm going to
shift select the empty, and I'm going to create a link. We can do that by going
to the object menu, and we want to choose
parent object. That's just an ordinary
parent child command. That's done. And we see
over in the outliner, position empty has a
little arrow next to it. I can open that up,
and it shows that the ball is a child of
the position empty. If I select the
ball, those values did not get reset to zero. Okay, in any other program
when we do a link, the child's transforms are going to be displayed as
relative to the parent. But that's not what's
happening here. Okay? Well, it gets worse. If I select the parent, which is the position empty, and I send it back to the origin by typing in a zero
for location X and Y. Now the position empty
location values are zero. Okay, well, what about the ball? The ball has completely
wacky values here. Those values have no relevance
to anything except for where the ball was at the exact moment that
we created the link. So the ball is actually
at the origin. The ball is also exactly in the same location as its parent. And because the ball
and the position empty are exactly superimposed
over one another, the child transform
should read out as zero. So anyway you slice it, this is deeply, deeply wrong. The ball is not displaying any values that are meaningful or helpful
to us in any way. This is really, really crazy. This is not how you link. This is how you don't link. This is how you not
link things because Blender is going to introduce this bizarre convention
here, where, again, child transforms are displayed as an
offset to where they were when the child was
linked, which is insane. So in the next movie, we're
going to look at how to actually create links
instead of this craziness.
7. Linking and unlinking: In the last movie,
we saw that the way Blender displays
child transforms is insane and really a big problem and makes it very
hard for us to function, even at this very simple,
basic fundamental level. So we need to work
around that issue. There is a command for that, but it's not well labeled. It's not easy to understand, but you're just going to
have to memorize this. Whenever you create a link, you do not use the
ordinary parent command. Otherwise, you're going to
get that bizarre offset that we saw in the last movie. You need to use a
special command to get just an ordinary
parent relationship. Okay? So to refresh your
memory, once again, if a child is exactly in the
same location as its parent, then the child's
position is zero because child transforms are calculated in the space of their parent. Okay, so we need that to happen. When I link the ball to
this position empty, I want the ball's location
values to read out as zero. So we're going to
select the ball. Shift select the position empty, go into the object
menu under parent, and we have to go to this really problematically
named obscure command. Make parent without inverse, keep transform. What
does this mean? This means just do what would
be in any other program, just an ordinary
parent child link. Just do a parent child link. Don't do all this other stuff that's the opposite of helpful. Okay? So this is what we want. Make parent without
inverse keep transform. Boom. We have a
parent child link. Position empty is the
parent. Ball is the child. If I select the ball,
its location in X, Y, and Z is zero. Its position is calculated
in parent space. And if I move the
ball, let's say, a meter away in X, that's a meter offset
from its parent. And we see it's kind
of hard to see, but there is a black
relationship line there. If I move the position empty, that's a little
bit easier to see. The transforms of the child
are relative to the parent. So the parent is wherever
it is in world space. The child is always 1 meter away as I move that
parent around. Or if I rotate that
parent or whatever I do, the child is calculated
in parent space. Okay, so I'm going to control Z back up through all of that. Do a bunch of undue commands, send it back to where it was, or I could have just typed
in zeros, but in any event, I want to send that
ball back to where it was because I also need to show you there's an unlink
command that is again, special and strange and bizarre
and hard to comprehend, but you have to do it this way. Otherwise, things
are going to fly off into some other
weird position. Okay. So normally,
in any program, you would select a child and you would issue
a command link. And in Blender, it's
in the object menu. And here we've got parent and within here, you've
got clear parent. But if you just do clear
parent, weird things happen. The parent stays where it was. The ball moves to the numeric values that were its offset from the parent or where it
was in parent space. Now it's using
those same values, but it's assumed a
different parent, which is the world axis. The world grid is
now the parent. So it was at a position of zero relative to its old parent. Now it's at a position of zero relative to its new parent, but that's not what we want
when we unlink something. We don't want it to move. We
don't want to just have it assume some numeric values
and have a new parent, but just keep those same values. We want the child to stay put. And again, that's
the way it works in every three D program
except Blender. So I'm going to undo
this Control Z, the ball is a child once again. Go back into object, parent. And just as there's this bizarre command
that we need to issue for creating a parent, there's also a bizarre
command that we need to issue to destroy a
parent child link. And that is clear and
keep transformation. When we do that, the
parent child link is broken and the child stays put. It doesn't just jump back to whatever numeric
values in world space. It stays where it was. It remains in the same
position in world space. It just no longer has a parent. Okay, so that's all about
how to actually link. So I'm going to send these
objects back to the origin. Type in zeros here. I need to do that twice
because we're not allowed to move more than
one object at a time. And now I want to
create some links. I want to make the ball geometry the child of the rotation empty, and then the rotation empty, the child of the position empty. Okay? So I can do that mainly from the outliner
here, make it easier. I want to select what's
going to be the child, which is the rotation empty, control, select what's
going to be the parent, the position empty in the menus, Object, parent make parent without inverse, keep transform. Now the position empty is the parent of
the rotation empty. Next, I want to make
the ball the child of the rotation empty.
Select the ball. Control, select the
rotation empty. Object parent, make parent without
inverse, keep transform. Okay, now, I've set this up so that the positions going to control everything in terms
of where it's located. The rotation empty is going to control the
spin of the ball, but the ball geometry
has its own transforms, so I can orient
that ball geometry arbitrarily without
affecting the spin. Okay, and one last
thing is the deformer, and I neglected to rename that empty, so I'll
double click on that. I'll call that the
deformer empty. And it just needs to be the
child of the position empty. Control select that
position empty. And again, object parent, make parent without
inverse, keep transform. Now, if you were thinking, Hey, if everything is
at the origin and all the transform values
are already zeroed out, then I don't need
to use that special make parent without inverse,
keep transform command. I could just use the ordinary
parent object command. And you know what? You
would be absolutely right. This is a special case. If everything is at the origin, then you can just use the
parent object command, and you won't have any issues. I'm using the make
parent without inverse, keep transform
command intentionally in order to hopefully
instill good habits, and we don't want to rely
on the fact of everything always being at
the origin because that's almost never the case. This is a very, very simple example in which everything
is at the origin. But if you had,
for example, some mechanism with
many moving parts, they're not all going
to be at the origin. Okay, so we've got our simple rig, and
we can test this out. I'll go into material
preview mode. If I select the rotation
empty and rotate it, we see that the ball rotates with it
because it's a child. But I can select that ball itself and orient it
any way arbitrarily. While still having a
very controlled rotation from the rotation empty, okay? And then everything is a
child of this position empty. I'm just going to
change the location of the whole rig using
that position empty. And the deformer empty,
we'll get to that later. Actually, that's going to
be in the next course, but we'll need that in order to control the orientation
of the deformation. Okay? I'm just going to reset
everything back to neutral. Values of zero for
everybody, rotation values, zero, ball rotations, zero, and we've built our simple rig.
8. Animation setup: We're now ready to begin
our animation journey. We want to set up our scene before we start
creating keyframes. The first thing I want to
do is some housekeeping. I previously hid my set, the backdrop and
the ground objects. I want to bring those
back from the outliner, Renable visibility for the
ground and the backdrop. I'm going to choose
to leave the camera invisible because I've established that
camera's position, and I'm not going to
be changing that. Now, there's another
thing to consider here, which is protecting
ourselves from ourselves. We want to set it up so
that it's not possible to accidentally move the backdrop
or the ground around. And the easiest way to
do that is to simply make them unselectb
in the viewport. That can be accomplished
from the outliner. And there's a set of
restriction toggles. That's these columns here. Visibility is a
restriction toggle. The camera icon
is renderability. If we disable renderability, then that object won't render, regardless of whether it's visible in the viewport or not. Let's change up these
restriction toggles. Let's go into the filters
in the upper right corner. At the very top, we see
restriction toggles. We want to enable selectable, which is the triangular
arrow facing left. And we're not going
to use renderability, so we can turn that off just to save a
little bit of space. And also to streamline
the interface, let's turn off object
contents so that we don't see object data properties or modifiers displayed
within the outliner. We'll only see the
object properties or the transform nodes. Going back to the outliner, I can now disable selectibility for the backdrop and the ground, so I actually cannot select them nor transform
them in the viewport. But I can still select
them within the outliner, even if they're not
selectble in the viewport. So if I needed to go into a modifier or whatever,
I can still do that. In fact, I can still
do transformations here within the
object properties. Okay, undo that with Control Z. I just protected myself from myself so I can't accidentally move the backdrop
or the ground around. And let's just move the ball up, select the position
empty and bring that up. And now let's go to the
four viewport layout that I set up earlier. So we'll go to the
four views workspace, and we have a
rendered view here. We have director's
view over here, and we've got orthographic
top and front views. So now let's set up our
animation parameters, specifically the frame
rate and the frame range. Frame rate is how many
frames per second. Frame range is how many frames. And we can change
these at any point. They're going to be found
in the output properties. And if I design this, I
probably wouldn't put these in the output properties because that kind of gives
the wrong impression. We're not actually dealing with an output property here, per se. We're dealing with
something more fundamental. When we look at frame rate, that is how many segments
a second is divided into. And we actually want to set that up in advance
and never change it. Technically, it's
possible for us to change the frame rate after we've
created our animation, but that's going to
cause a lot of problems. So if you create keyframes and then change the frame rate, then your keyframes
are going to maintain their position in time
based on milliseconds, but they're going to land
on different frames. And even worse, in order
to preserve the timing, keyframes are going to need
to land on fractional frames, that is some value in
between two frames. If I animated the ball so that it touched the
ground at, let's say, frame 31 and then
changed the frame rate, the ball would no longer
touch the ground at frame 31. It might touch the
ground at frame 24.3 or something
weird like that. Well, when we render the shot, there is no frame 24.3. There's a frame 24 and
there's a frame 25, and there's no image rendered
in between those two. And that would create a
situation where there would be no frame at which the ball
actually contacted the ground. This is why you shouldn't change the frame rate after animating. It could have unforeseen
consequences. So I'm going to
set my frame rate first before doing anything. And it set to 24 frames
per second by default, which is the standard for cinematic film in
the United States. I'm going to get a little bit
better temporal resolution by setting this to 30. The screen capture
you're looking at is also at a frame rate of
30 frames per second, so everything's
going to line up. Then we have our frame range. What's our first frame and
last frame of the animation? And it's set to 250 frames here. Well, I don't
need that much. We're only going to
animate a couple seconds worth of time here. And 2 seconds times 30 frames
per second is 60 frames. I can set the frame range to 60. And we saw something change
in our timeline down here. We have an area that is
the current time range, and it's a little bit lighter. Let me make this a little bit easier to see by
making this bigger. So this is the
current frame range, and the darker area is
outside that frame range. And if I press play, we see that it cycles within
that time range. We see also that that
range is listed here. We can zoom in or out
in this timeline. There's a scroll
bar at the bottom, so I can go over to the right
side of that scroll bar, drag it to the left, and just zoom in on my
current time range. Notice, by the way, that
we can actually have negative numbers and have things happen before frame zero. And negative time is
sometimes helpful, especially in physical
simulations when you need a run up before the
actual animation starts. Okay, we've set up B
scene in the outliner, and we've established our
frame rate and frame range. A
9. Understanding keyframes: Before we start animating
by creating keyframes, I just want to introduce you
to the concept of keyframes. There's also another piece of
housekeeping I need to do, which is I neglected
to remember that the outliner settings are
unique per workspace. I changed the settings
for the layout workspace. I need to do the same for
this four views workspace. So I need to go into the filters again and enable selectable, disable renderable and
disable object contents. Okay, so now both of those
have the same settings. So let's talk about keyframing. A keyframe is some value
for a property such as a transform on a particular
frame at a particular time. And we can set a different value for that same property at
a different point in time, that'll create
another keyframes, and the computers going to fill in all of the in between values. That's called interpolation. And the term
keyframes comes from traditional animation in which the most important frames or the keyframes of
the animation were drawn by the most
senior animators. And the in between frames were
drawn by junior animators. In computer animation,
the computer itself is our army
of junior animators, drawing all the in
between frames for us. I've created a simple animation
here just to demonstrate, and I'll press the play button. And it's just a
ball rolling across the frame. Nothing fancy there. I've just animated the
position empty and the rotation empty.
Okay? I'll stop that. If I select the position
empty in the outliner, down in our timeline, we'll see some orange dots. And let's expand that timeline because we see
multiple orange dots. This can be a little bit
confusing to new users. It looks like we've got
four keyframes on frame one and four keyframes on frame 60, but
that's not the case. There's only one keyframe at each one of
those time indices. And there's a tiny little arrow on the extreme left
of the timeline. If you click on that,
you'll expand the summary. And this shows
categories of keyframes. At the top is all of the keyframes on the
selected object. And we could click on one of those and select all
those keyframes. We have a category, which
is the object itself. Within that is another category, which is a so called action. An action is a container
for animation data. We're not going to
be using that, but you could use it
to, for example, gather different parameters or properties from different
aspects of an object, its transforms and its materials could be stored within
a single action. Within that, we have a category for the
object transforms, and deep down within that, we have the X location, and this is the
actual keyframes. Everything above that
is not a keyframes. And in some programs, it's even referred
to as a fake key. So these are not keyframes. There are ways for us to
select keyframes by category. So don't let that throw you off. Actually, in this case, no
matter what you click on, any one of these five things are going to select
the X location keyframes because X location is a channel within
the object transforms, which is a category within
this animation action, which is a category within
the position empty, and that is within the
overall scene in the world. This is a little
bit off putting. It looks like we have
a lot of keyframes. We only have two keyframes here, and those are in the location, animation channel or track. So there's a keyframe
on frame one and another keyframe
on frame 60. If we go to the outliner, open that up, we can
choose the rotation empty, and we see if we expand all these categories
within the summary, once again, there's
only one set of keys. There's only one animated
channel or track, and that is the Y rotation. And it says Y Euler rotation. Euler is the name of the
mathematician who initially developed this system
of three D rotations. Can always tell if an animation channel or
track or property is animated because its
data entry field in the Properties panel is going to have
some color in it. If it's green,
that means there's animation data somewhere
on that property. If we position our time index directly over a keyframes
like frame one, we see that this is now
displaying in gold, and that's an
indicator that we're parked on a frame that
has a keyframes on it. Okay, so those are some of
the basics around keyframes. We'll create some keyframes
in the next couple of movies.
10. Inserting keyframes: Now let's create some animation. The command for that
is insert keyframes. And I want to show you all the different ways you can do that. First, let's make our
properties visible, the object properties, so we can see the transform values. And I want to just start
with the position. Select the position empty and use the move tool,
press the G key, and position that ball, so it's a little
bit out of frame as seen in our rendered
viewport here. And now we can
create a keyframes. So let's do it manually first. There is a command within
the viewport menu. You can go into the
object menu and drill way down into animation and
you'll see insert keyframes. But that's really going
to slow you down. You just want to use the
keyboard shortcut, which is I. Now, that keyboard shortcut is going to operate differently depending upon where your
mouse cursor is hovering. So if your mouse cursor
is hovering over a viewport and you
press the I key, all of the transform channels
will receive keyframes. We've just placed keyframes on all the location rotation
and scale channels. Well, we're not actually
animating all that. For this particular object, we're only animating
location X and location Z. So we've just created
a whole bunch of extra information that's
just going to clutter up our animation editor views and make it more
difficult for us to work. Now, there are situations
when you would want to use the ee
key in the viewport, and that would be if you
have character animation that's been set up in
advance with something called a keying set
where you've directly determined which channels are going to be animated when
you press the ee key. But in the absence
of a keying set, it's just going to blast all of the transforms
with keyframes. In this simple animation, that's not a desirable outcome. We don't want to
keyframe all this stuff. So I'm going to undo
that with Control Z. Now, if you hover your
mouse over the timeline or any animation editor
and press the I key, you'll get a pop up menu, saying, Do you want to
keyframes all the channels? Do you want to keyframe
only the selected channels? Do you want to keyframes
the active group? Well, no matter what
you choose here, if there's no animation
on the selected object, then nothing's going to happen. So this is a bit of a gotcha. If I set all channels
by clicking on that, I would expect that
it's going to keyframe all the channels because I said keyframes all the channels. But that's not how the
animation editors work. They'll only be able
to create keyframes on channels that already exist. So you actually have to
have a keyframe already there in order to create more keyframes for that
particular property. If you go over to the
Properties panel and hover your mouse over one of
the transforms and press I, then all three of those axes
are going to get keyed. Well, that's an
improvement, but I'm still keyframing
the Y dimension, but the balls not going
to be moving in Y. So that's not the
perfect solution. It's certainly
better than blasting all the transforms
with keyframes. But I'm going to undo that
again with Control Z. What I recommend in
a simple scenario such as this is don't
use the eye key. Use the little dot on the far right of each
one of these properties, and that will create
a keyframe only for that property on
the current frame. For the location X property, I'll click on that little dot, which is labeled
animate property, and I've got a keyframe there. I'll do the same for the Z axis. Now I've got keyframes for X
and Z location or position. And I can go to some
other point in time. I can change my play
head to, let's say, frame 25 and then move the position empty down near the center of
the frame here. And we see that location X and location Z are now
displayed in orange. And this is something
called dirty data. This means that we've changed the values of those parameters or properties so that they no longer correspond to the data
that's currently stored. The stored data is the position of that
empty on frame one, but now I've moved it, and so it's no longer
at that position. Now, if I scrub in my timeline or change my time index
to anything else, the object is just
going to snap back to the data that's actually
stored in the file. So your process for creating
manual keyframes like this is to go to
some time index, some frame number,
make your change, and then store those changes. And we're doing that using the animate property
button over here. I'll click on location
X, the little Diamond. Now there's a keyframes
there and Location Z, click on the Little diamond, and now there's a keyframes
there as well. I can rewind and playback, and I've created some
very simple animation. I've keyframes location X and Z.
11. Automatic keyframing: There's an alternate method
for creating keyframes, which is auto key,
automatic keyframing. And that's when if you just make a change to some property, you'll automatically
create keyframes. And this can be helpful. It can be a time saver, but there are some maybe
unexpected consequences of the logic around
how auto key works. Let's start from
a simple example. I want to insert some rotation keys to
make the ball spin, and that'll be on
my rotation empty. Click on position
empty in the outliner, select the rotation empty. And on frame one,
I need to create my first keyframe manually
for each channel. Auto key will not do
anything if there are no keyframes on that channel
or track or property. So if I turn on Auto key, which is this dot over here, and I try to change some
property like rotate Y. Click on Rotate Y and drag that, I am changing Rotate Y, but I'm not creating keyframes. Okay, I'll undo that
with Control Z. To make Auto key work, I have to create a keyframe
manually first. Go over to the Properties
panel to rotation Y and create a keyframes manually by clicking on the
animate property dot. Now I've got a keyframe for Rotate Y at frame
one. Auto key is on. I'll go down to the end
of my timeline frame 60 and rotate around the Y axis. And I can do that
interactively in the viewport, press the R key and rotate around Y in
that front viewport. And we see the values updating. We see rotation Y is in this orange color
indicating dirty data. But as soon as I
release the mouse, all three rotate X, Y, and Z channels turn to gold, indicating that
there are keyframes on all three of those channels. If we use Auto key, we'll need to
delete keyframes or delete entire animation channels that we're not
actually animating. Just to declutter our
animation editors. I'll rewind and playback, and we can see that
rotate Y is animated. All right, very good. I can investigate this with
rotation empty selected. I can open up the summary in the timeline and open
up all this stuff. You may need to expand the
size of that timeline. And we see we have keyframes
on Y Euler rotation, X Euler rotation,
Z Euler rotation. The only thing we
care about is Y. So we could select these
keyframes here and press delete. The other thing we could do
is go to that point in time. And then over here, we can disable animate
property. Click on that. And if we're parked
on a keyframes, that means we want to
delete that keyframes. And if we delete the only
keyframes for that property, it turns gray once again. So rotation Z is not
animated at all. Okay. Now let's look at
the logic around auto key. I'll go back to the position empty and back to the
move tool with the G key. I'm on frame 60, and I'll move the object in
X with auto key turned on. Change the X location, and just bring that out
of frame as seen in the camera view in the upper
right. Release the mouse. Location X got keyed because that's what
I actually changed. Location Y got keyed because that's the
logic of Auto key. Okay, so the logic
is as follows. The very first time you change some transform
in auto key mode. It's going to
create keyframes on that channel and any channels that don't have
keyframes on them. Okay, so I changed location X. I created a keyframe
on location X. There was no keyframe
on location Y, so it created that, even
though we didn't want it. But it did not create
a keyframe on Z. And the reason is we didn't
change the animation in Z. So that's the logic here is it's only going to create
keyframes if either it's going to change
the animation or if no keyframes
exist on that channel. If I go to some other point in time and do something
like in auto key, move the ball up in Z, now I get a keyframes
on Z location, but I didn't get a keyframe on X or Y because I
didn't change those. And there were already keyframes on both
of those channels. And so if I rewind
and play back, the ball maintains
its vertical position throughout the last
portion of the animation. Okay. And it's all because of the order in which
I did these things. So, again, it's going to
take a while for you to kind of anticipate what Auto key is going to do
because it has a mind of its own and it follows
its own internal logic. And so, auto key is
great until it's not. So I actually recommend
just creating keyframes by clicking on the animate property
button over here. That's what's going to
give you the most control. You're not going to get
any unexpected results, no unpleasant surprises. Okay, I'm going to undo that last auto key
with Control Z. My need to go back
a couple steps. Rewind and play
this back. I've got a very simple animation. This is by far, not the
end of the process, but that is the end of
this particular course in animation basics, because our next step is to start working with
keyframe interpolation, and that's a whole
new wonderful world that we'll need to go
into in the next course. So I'm going to
disable auto key, and that's all we're going
to do for this course.
12. Next steps: I'm sorry to have had to
interrupt our process. We're now in a state of
animats interrupt us, but I have to break up
the courses somehow, and that's a natural
point at which to stop where we've got some
basic understanding of how to create keyframes. And we also have
learned the hard part, which is the issues around parent child
linking in Blender. But now you won't be confused by your child transforms reading
out in bizarre numbers, and Blender will operate in the normal way that a three
D program always does. So now we're in a good
place to progress to the finesse of animation, talking about interpolation
or the in betweens between keyframes and also how to animate deformations
for squash and stretch. I'll see you in part five.
Aaron Ross, Artist, author, educator
