Transcripts
1. Blender production rendering: Welcome back. Aaron F
Ross here once again with Part six of six of Blender
Basics, The Bouncing Ball. And this is all about
production rendering. Really important
topic, actually, deserving an entire course. We're going to look at not
just the basics of, let's say, how to define your output
directory or your resolution, but we'll also go into the
cycles render properties and set up those
sampling settings to optimize speed and quality. So we'll get good
quality images, but we won't have to
wait as long for them. And then we're going
to take those images and compress them into a movie that can then be uploaded to an online
hosting service or whatever. So let's get started with production rendering in Blender.
2. Using the exercise files: Let's take a look at
the exercise files for the course sequence. You should have downloaded
those exercise files and extracted them at
the very beginning of the course sequence. And within there, there will be three D scenes for the
blender SEM files. There's an input
textures folder for all the bitmaps
applied onto objects, surfaces, and environments, and there are also
output renderings. And for this course, we're
going to be creating files. We're going to be creating
an image sequence and also a movie, and I've provided
examples of those, and I've named them with the word example in their
folder name so that we don't have a conflict
between the files that you're creating and
these example files.
3. Setting Output resolution and file options: Before rendering our animation, we can take one last look
at it in the Viewport. We can play that back at normal speed and check it,
make sure everything's good. We can also analyze the
animation in slow motion. That's pretty
helpful. And that's found in the output properties. We previously set the frame
rate at 30 frames per second. But if we go to that
pull down list, at the very bottom, we have the option to choose
a custom frame rate. And once we do that, then
we see this base field, and that's a divisor
for the frame rate. If we set the base to two, then our effective frame
rate is 15 frames per second because 30/2 is 15. And if we rewind
and play this back, the animation is actually
playing back at half speed. Very good for analysis. And we can bring that
base down even further. If I set it to a value of five, then the effective frame rate
is six frames per second. Rewind and play that
back. And now we can really clearly see any issues that might be in our animation. I'm pretty sure this is fine. So we can go ahead
and stop that and set the frame rate back
to 30 frames per second. Now we want to set up our output parameters for the rendering. Most importantly,
the resolution, the number of pixels in X and Y, or the number of pixels
horizontally and vertically. It's set to 1920 by 1080 or full high
definition by default. You can leave it at
that if you want. I'm going to reduce
the resolution so that I'll be able to put a full frame within a panel
on this screen capture. So, in other words, I want
the image to be smaller than the available area just for the purposes of the
screen capture itself. So I'm going to reduce
the resolution. I'll set the X to 12 80 and
notice that when I did that, the framing changed
in the viewport here, and that's because
the aspect ratio of the image is determined
by the resolution. I'll set the Y
value down to 720, and that's going to give me
the same aspect ratio of 16 by nine as we had with the full high definition
image at 19:20 by 1080. Below that, you'll
see aspect X and Y. And this is not the aspect
ratio of the image itself. It's not the shape of the frame. This is the aspect
ratio of pixels. And this is pretty archaic. In the bad old days
of digital video, there was such a thing
as non square pixels, where you could, for
example, cram more pixels in the horizontal
dimension than you do proportionally in
the vertical dimension. That's a very rare special case. Nowadays. 99.999% of the time, you're going to leave the
aspect X and Y at one. We've set our frame
range to start at frame one and end at frame
65, and that's what we want. Scrolling down, we want to
set our file output options. And first, we want to talk
about the media type. It's set to image. And you'll see you have
some options here. You can also render
to a video file. You don't want to do that. You always want to
render to a still image. The multilayer EXR is
also a still image. It's just a high
dynamic range image. So you're never
going to render to a video file in production, and there are a lot
of reasons for that. If you render it
to a video file, all your options are bad. Either it's going
to be uncompressed, which means it's
a mega huge file, or it's going to be compressed, which means it's
going to have thrown away information that
you can never recover. Also, if you need to stop
and start the rendering, then you want to render to
individual still images. And if you want to render
on multiple computers, then you have to render
to an image file. So there are a lot
of reasons why you render to a sequence of individual still images
rather than a movie. The production process is you render out to a numbered
sequence of individual still frames that are either uncompressed or
losslessly compressed. The default file format is P&G
portable network graphics, and that is losslessly
compressed. It just compacts the data without actually
throwing anything away. Below that, we have
the color mode. We have black and white,
red, green, blue, or the default, which is red, green, and blue and Alpha. PNG has transparency
built into it, but it's kind of an unorthodox
form of transparency, and not all applications
handle it very well, and we don't need transparency
in our rendering anyway, because there's no
part of the frame here where we can
see the background. And so there will be no
transparency in this shot. So let's set the
color type to RGB. Below that, we have
the color depth, which is the number
of bits per pixel per channel for a standard
dynamic range image, eight bits per each RGB channel will give us pretty
faithful reproduction. We'll have a palette of 16
million possible colors, and that's usually enough. If you did need to do a lot
of color correction in post, you'd want to save
out to an EXR file, which has a very,
very wide gamut, a very, very high dynamic range. So if you're just rendering
out to a final image, then eight bits per pixel
per channel is fine. We also see
compression down here, and it's set to 15%. We want to turn this
all the way up to 100%. That's going to compress the
data as much as possible. And PNG is lossless, so it's not actually throwing
any information away. It's just compacting it as small as it can
possibly be compacted. And that takes a
little bit longer. In this case, it's going to
be fractions of a second. We're not going to
notice any difference, but our file sizes
will be smaller.
4. Rendering to a relative path directory: We've established our resolution
for the rendered frame, and we've set our
file format options. Now we need to set an output
path and a file name. And that's this field here. We could just click
on the Browse button, but if we did that, we would
be setting an absolute path. An absolute path is the actual location of
something in your file system. What hard drive is it on? Is it on a network drive? What precise folder is it in? What's the entire path
to that location? But we actually don't
want an absolute path. We want what's known as
a relative path in which the path simply refers to
some relative location. In this case, relative to the location of the
actual scene file. Why do we want to do
that, so that we can, for example, take
our project folder here labeled exercise files, and let's say rename
it or move it to a different drive or even
a different computer, or even a different
operating system. If we use relative paths, then Blender doesn't care
where the SEN file is. That SEN file can be
literally anywhere. It's going to render out to some directory that's relative to the current SEN file location
wherever that might be. Okay, so that's why we
want to do relative paths. It's going to give
us flexibility. It's going to make it easier
for us to find things, too. Because if we just leave this
output as it is right now, it's going to save
to a folder called TMP at the root of
our system drive, and then it's just
going to give it a file name derived
from the current scene. So we want to plug
something in here, we need to type it in manually. So the first thing we
need to know is how do we indicate current location? How do we put in current
location of this scene file? And in blender, that's done with two slashes, slash slash. Now, that's different from the ordinary convention
in computing. Usually, double slash means
some network location. But on planet Blender, double slash means the location of the current scene file. Okay, and that's going to be
inside three D scenes here. So from three D scenes, we need to go up one level. And to do that,
we need to put in two dots in the
output path here. Type in dot dot. Next, we need to go
down into this folder, which is called
output renderings. So we type in a slash and
then the name of that folder. Exactly. And if you put in some folder
that doesn't exist, then Blender will create that folder. And we
want that to happen. Actually, we want to
create a subfolder for an image sequence. We don't want to
have more than one image sequence in
a single folder. That'll make them
all get mixed up. We could think of the whole
image sequence as a movie, and that needs to be
in its own folder. So I'll put in another slash and then the name of a folder that
I want Blender to create. And I'll call that
BALL underscore 01. And then finally, we need
to give a file name, so we'll put in another slash, and then our file
name, which can also be BALL underscore 01. But there's going
to be some numbers appended to the end of this. It's going to be a
numbered image sequence. We want to separate
this version number, version one from the
image file number. Okay? So each image files
got its own unique number. That's its frame number.
We want to separate that from the version number that
I put in here, ballo one. Separate that with
another underscore, and then we indicate
the number of digits to our frame number by hash
symbols or pound symbols. And it's usually safe
to use four digits. I'll put in four pound
symbols or four hash marks. So this is going to
save out to wherever the current scene
file is up one level, down into a folder called
output renderings. Then it's going to create
a folder called ball 01. Within that, it's going
to create a sequence of images called ball 01, and they'll be numbered
000-12-0065, in this case. That's how to set
up a relative path for rendered file output.
5. Wrangling the UI for rendering: A our next step is to do some test renders
in order to get the sample settings for cycles optimized for fast renders
that have high quality. And that'll all be done in
the render properties here. But we need to set up an
interface for that because blender is not actually set
up to do that very well. To illustrate, let's say I go down to frame 30 on my timeline, and I initiate a test render. I can do that by going up
here to the render menu, and I can choose render Image or use the keyboard
shortcut, which is F 12. And by default, that's going
to launch its own window. And we can see our
rendering is going. Now this is fine if we've got a multi monitor setup and we can put this window on a
different monitor. But with a single monitor
setup, it might be a problem. It definitely is a
problem on Windows, because as soon as I go back to the main UI in order
to make a change, that render window is now
behind the main blender window. So that means I've got to
somehow find that window. I got to bring it back, okay, from my task bar or whatever. This is really sub
optimal in terms of user interface. So
that's not going to work. There's also a
rendering workspace, and we can go in there,
and that's a lot better. We're now seeing the image
viewer editor or area. But we don't need
all this stuff. Right now, we've got a
sidebar we don't need. We can get rid of that
with the end key. We've got overlays and gizmos. We don't need any of that.
We can turn all that off. Most importantly, we're seeing a half size image here,
and that's no good. We need to see the image at its original resolution
or one to one scale, go into the view menu
and choose Zoom 100%. Okay, so now this rendering
workspace is all set up. But if I go to render Image, it's still going to
launch this other window that we don't need or want because it's doing the
exact same thing as this area in that workspace. So I'm going to
close that window, and I'm going to go
into the preferences and change that behavior. Go to edit preferences. In the interface tab, open up temporary
editors and set render in to image editor. And that way,
whenever we render, the image editor will appear, and we won't have to worry
about those floating windows. Now, as an aside,
this is going to work fine in this rendering
workspace up here. Just be aware if you're in some other workspace and
you initiate a render, the image editor is going to appear in whatever panel
or area had focus. Okay. So now I can
do a rendering, and I can use the
keyboard shortcut, which is F 12, and that render takes place directly in
this rendering workspace. It's not in a floating window, and I have the ability to
go back and forth between the rendered image and my settings in the
rendered properties.
6. Optimizing offline Sampling quality: With our environment set
up for test renders, let's take a look at
the sample settings in the cycles renderer. In the render properties, I've got the render
engine set to cycles and the device
set to GPU compute. I strongly recommend that
it's going to be a lot faster than the CPU
in almost every case. I've already set my
Viewpoort sampling settings in a previous movie
in the course sequence. Don't need that anymore, so
I can just collapse that. Below that are the
render settings which are for the offline file output. To refresh your
memory, a sample is a test for the color
of a particular pixel. If we sample the
pixel more times, we'll get a more accurate
color rendition. The noise threshold up here
allows adaptive sampling. And if the grain or
the contrast between nearby pixels is greater
than some amount, then more samples will be taken. Then at the bottom,
we have denoising, which is a post
processing effect, which is going to remove
any residual noise. Let's do a render with just these default settings
and see what we get. I'll press F 12, and then that starts to
render in the image viewer. We can see the number of
samples progressing here, and it keeps going
up and up and up, but the image quality
doesn't improve. This is an indication that
we have too many samples. We can reduce the number of samples and still get
pretty good quality. We also see the elapsed
time over here. It took about 14 seconds to render that frame
on my computer. I've rendered into
slot one over here. We can render a bunch of images into different slots
and compare them. Let's try slot number two and see what that looks
like with no denoising. Let's turn denoise off, leave everything else
the same. Press F 12. And what we'll see here is
it's basically the same. We won't be able to tell
really any difference. So the denoising is not really
doing a lot in this case. Once that's finished, we can get in really close
and examine this. Let's go to the View menu and choose Zoom eight to one, 800%. And navigating this panel
with the middle mouse button, we want to see the
reflections and shadows. Those are going to give us
the clearest indication of any grain or noise. So this is slot two
with no denoising. Let's take a look at slot one, and it's almost the same. Slot two and slot
one are different, but slot two is only marginally
more noisy than slot one. So that tells me that
the denoising algorithm really wasn't that
necessary in this case. Denising works with mid
range amounts of noise. When there's a small
amount of noise, denoising doesn't do much. When there's a large
amount of noise, denoising is going
to create artifacts. So let's take a look at that. First thing I'll do is I'll
turn off noise threshold, so there's no adaptive
sampling going on. Then I'll set the
number of samples down to the minimum of one. And let's go to slot three
and see what that gives us. One sample with no denoising, press F 12, and
it's super grainy. Okay? That's what I expect
to see with only one sample. There's just not enough
information there to determine the color of a
pixel with any accuracy. Okay, let's go to slot four and we'll turn on denoise and
see what we get from that. And it's also going to be very fast because there's
only one sample, but it's going to be
a little bit slower because it has to run
the denoise algorithm. Okay, we can see that there
are some artifacts here, and it's blurry
and kind of weird. If we compare slot number
four to slot number two, we can see there's a pretty
big difference there. Remember, slot two is a
version with no denoising. Slot four is the version with
one sample with denoising. And the artifacts are so extreme here that we
can see them even if we go back to Zoom
factor of 100%, the artifacts from the deniser are still pretty obvious here. And if I switch this
back to slot two, that's the version with
a high number of samples and no denoising
compared to slot four, which is only one sample, but a high amount of denoising, and it's created a
lot of artifacts. And especially in an animation, we don't want that
because those artifacts might change from frame to
frame causing flickering. Okay, so what can we do? Well, we can go back to a high number of
samples, for example. We can set that back up
to its default of 4,096. We can re enable
the noise threshold and just increase the threshold. So if we set this to a
higher value like 0.1, that's going to
allow more noise. Let's go to slot number
five now and press F 12. And that finished a
lot more quickly, but it is noticeably grainy. We'll need to get
in really close. Go back to the view
menu and zoom back in to 800%. Take a look at this. So here it is with
4,096 samples, but with a high noise threshold, more grain is allowed
to show through. It's not doing as many
adaptive samples. Okay, so increasing the noise threshold
did speed things up, but at the cost of
reduced image quality. Well, what can we do instead? I'll turn the noise
threshold back off again and set the number of samples to a relatively low
number like, let's say, 64. And we'll render that
into another slot, slot six, press F 12. And with 64 samples and no
denoising, it was pretty fast. It took less than 2 seconds, but it is still kind of noisy. So let's turn denoising back on, and I'll go into the
settings for that. I've got Invidia hardware
so I can set my deniser to optics and then
go to a new slot. Let's do slot seven. And once again, press F 12. And again, that only
takes a couple seconds, and now it's looking
pretty decent. I'm not seeing a huge
amount of grain here, and it only took 2 seconds. So if I compare that
to the first version, which is the default settings, there's not a huge
difference there. Slot number one was
the default settings with a low noise threshold, a high number of
samples, and denoising. In this case, slot
number seven is the version with no
adaptive sampling, only 64 samples and using
the denoise algorithm. And this is pretty
well optimized. So I can go back to viewing
with a Zoom factor of 100%. And again, compare slot
seven to slot one, and zoomed out like this, I can't see any difference. And it rendered in
less than 2 seconds instead of 14 seconds. So every scene is going
to be different and even actually every shot is
going to be different. You'll need to play
with those settings to optimize your render times, but this is a good
place to start.
7. Analyzing image levels: Before we kick off our
animation rendering, I want to show you how
to analyze an image. We can look at data
about the image in order to evaluate if
the levels are correct, if we're having issues
such as oversaturation, and that's all done from
within the image editor. We need to have an image
there. And in this scene file, I don't have an
image rendered yet, so I'll hit F 12, and that renders frame 30 with the cycles sampling settings
we set up in the last movie. Now let's open up
the side bar with the end key and go
to the Scopes tab. And we have lots of ways
of analyzing our image. This is a really cool feature of blender. Let's take
a look at these. First, we have the histogram, and you may be familiar
with something like that from a program
like Photoshop. It's showing us the number of pixels that have various values. And the values go
from zero or black on the left to one or perfectly
white on the right. And we're currently seeing RGB. Each one of these
curves is the red, green or blue channels, and the height of the curve
indicates the number of pixels that have that
particular value. This is telling me
I've got a lot of red pixels and not very
many black pixels. We can also display this
in luminance or luma mode, and this is just showing
everything as a gray scale. So we can see here there
are a lot of pixels that have a value
of approximately, let's say, 0.66 or
something like that. Almost no pixels with a
value of zero over here. Below that is the
waveform monitor, and I can make that a little bit bigger by expanding that. A Waveform monitor is a type of test equipment for
video production, and it's going to show us similar information
to the histogram, but just display it a
little bit differently. It'll be easier to see
if I go down here, scroll down into the
samples section, open that up, and if I
turn on full sample, now the waveform monitor is sampling all the
pixels in the image. Previously, it was just sampling 30% of the pixels just randomly. So we see in the waveform
monitor a graph of the brightness at a particular
horizontal location. And we can see these
lines extending downward. Those indicate the slits in
between these fence posts. So this is telling
me at that location, there is some black area. And at this other
location, it's white. And this ranges 0-100%. So that's the waveform monitor. And if you work in video, you're also familiar
with the vector scope. That's down here, and this shows us the hue and saturation. The hue is indicated by
the angular value here, and the saturation is indicated by the distance
out from the center. A pixel that has a saturation of zero is going to be right
in the center there. It's telling me that
I have a lot of red, a lot of green, a lot of yellow, a lot of blue, and that
makes perfect sense because I used primary colors
for the bouncing ball. Finally, below that, we
have the sample line, and that allows us to sample
some particular area, and that's done by clicking on the sample line button and then clicking and
dragging in the viewport. And as I hold my mouse down, I'm seeing an
interactive preview of the histogram at
that particular line, at that particular location. I can click on
Sample line and draw a really small line here
in this white area, and the histogram turns
completely white. If I want to get
rid of that line, I can click on Sample line and then just click
outside the image. Okay, so those are the scopes, and it tells us a
lot about our image. And what this tells me is that
my image is well exposed. If it was poorly exposed, then the waveform monitor wouldn't go all
the way up to 100. Or the saturation values would not go all the
way out to the edge. The saturation of
some of these colors is a little bit hotter
than it should be. I can see that the green is
going out beyond that circle. And if I looked really closely, I could see that this area here is a little bit overexposed.
But you know what? It's going to go by so fast in the animation that we'll
never notice that. I'll hide the side
bar with the end key. And I'm now ready to
kick off the rendering. Go into the render menu and
choose render animation, and that'll render our
entire image sequence. And that'll take a couple
of minutes to render. We'll let that finish and
then check the output. Once that rendering
is completed, we can check the output in our project folder inside
output renderings. We now have a folder
called ball 01, and inside there, we have a sequence of
numbered PNG files, and we can spot check these, load them into an image editor, and make sure everything is looking the way
we want it to.
8. Configuring the Video Editing Workspace: We've rendered an
image sequence, and now we want to encode
that to a movie file. And amazingly,
Blender can do that. Blender is not just
a three D program, but it's also a two D
compositing program and even a primitive video
editing program. Pretty cool. You get all that for free. So let's import
our image sequence and encode it to
an MP four movie. To do that, we want to go into the video editing workspace. As you know, we have
a lot of workspaces up here on the main
Windows header, but there are more
workspaces included with blender that can fit
onto that header. So there's a plus sign
on the far right. Click on that to add workspace. Go down to Video Editing
and choose video editing. We can optimize this a bit. We don't need this
browser over here. I'm going to hover my mouse in the lower left corner of
this preview area and then drag my mouse
over on top of that browser until my
cursor tool tip says, Replace this area,
release the mouse. And now I'm not bothered by
that unnecessary browser. We can also hide this toolbar
over here with the T key. And let's also turn
off the gizmos and the overlays because we just want to see a
preview of our movie. We don't need all
that extra stuff. One thing about this
that's a little bit unusual is that by default, we can't really do anything
in this sequencer timeline. We have to reference a scene, and this is a strange concept in Blender that a scene file, which is the dot blend file, can have multiple
scenes within it, and those scenes are completely siloed off and isolated
from one another. And they can have completely
different geometry, completely different
animation, render settings, and there's no overlap
between those scenes. And this is very, very strange. And there's no other
three D program that has anything even
remotely like this. In every other three D program, the scene file and the
scene are the same thing. But in blender, you can have
multiple scenes per file. So with this sequencer window, we need to reference
our existing scene because we want to grab the render settings
from the scene. Okay? Assuming that the
currently loaded file is the one that we used
to render our shot, we want to load that scene
into this sequencer window. And that's done from this
pull down list on the header. Browse scene to be linked. And if you click on that,
there's only one entry in there because every blender scene file starts out with a blank scene, and that's the one
we want to choose. So click on scene and now suddenly all our render
settings have been loaded. We now have 65 frames
in our timeline. And if we go over to
our properties panel to the output properties, we can see the resolution and the frame rate are what
we set previously. All right, we've set up our
video editing workspace.
9. Setting video Output properties: We've set up the video
editing workspace and we've set the
scene properly, and that's loaded in the
resolution and frame rate. But if we scroll down in
the output properties, we'll see that we've still got the PNG output, so we
need to change that. So instead of rendering
out to an image sequence, we're going to convert an image
sequence to a movie file. First thing is to put
in our output path. I'm going to save into the
output renderings folder, but I'm going to
create a new folder in there called movies. And then within that, I'm going to create a
new movie file, which is called ball 01. And by the way, on Windows, it wants us to use backslashes, but we can use either
forward or back slashes to separate those
directories in that path. So I'm going to be
creating a new movie file in output renderings, movies, and that movie file is going to be called ball 01. Then we have the
media type down here. We're going to switch
that over to video. And it's, of course, going
to be red green and blue. We want to check in on our
color management and make sure that that is following
the scene, which it is. Let's go into the
encoding section here, and we want to choose
our file type. Metroska or MKV is the default, and that's an open
source standard, but the MP four standard
is a bit better supported. So let's choose MPEG
four as our container. Within that, we need to choose the codec or the
compressor decompressor, and the default is h264, and that's the universal
codec for video. Basically every device in
the universe can read this, so let's leave it at h264. We have the color depth, and it doesn't really make
much difference here. If you wanted a little
bit extra quality, if you saw any banding
in your image, you might choose a
ten bit color depth. The output quality,
I do want to change. Instead of setting that
to medium quality, I'm going to set
that to lossless. And this would be suitable for uploading to YouTube or whatever because a service
like YouTube is going to recompress
whatever you upload. So if you lossy, compressed something and
then uploaded it to YouTube, it would then be
lossy compressed again and you would
have more artifacts. So I'm going to set the
output quality to lossless. The encoding speed
isn't going to make any difference for the
final output in this case, but if we set it to slowest, that's going to usually
give the best results. Now, I have Invidia hardware, and so it's likely
going to be using the Invidia Lossless encoder. And if you have
different hardware, you might have different
options available here. But basically, you
want to save out to something that is
losslessly encoded. So if you're not able
to set these settings, then you might want to
investigate some of these others. For example, you
could save out to QuickTime animation
with 100% quality. And that's also a
lossless Codec. ProRes is an Apple
Codec that is lossy, but it is very, very good. Even though it's lossy,
it's effectively lossless. Okay, those are
some other options in case this doesn't
work for you, but I'm going to be saving
out an MP four file that's encoded with the h264 codec
with lossless quality.
10. Adding an image sequence: With our output property set, we're now ready to import an image sequence into
the sequencer down here, and I can zoom in on that
using the scroll bar. The only area we're interested
in is this 65 frames. Go to the header menu to add
and choose Image sequence. Now you need to navigate
to your image sequence. I've got a bookmark for the
exercise files project, and my images are in the
output renderings folder. Inside there is a folder for the image
sequence, ball oh one. And over here in the options, we want to change
this up a little bit. We don't want to
move the strips. When we import something, we're allowed to move
it around during the import process. I
don't want to do that. I just want to import to the current location in
time, which is frame one. And down here we
have the fit method. You'll need this just in case the incoming image sequence doesn't match the current
render output settings. It'll scale to fit, but you want to actually set
this to use original size. That way, you'll
be able to tell if there's any scaling happening. And then although
there is a checkbox that says detect sequences, I have not been
able to just select the first frame and have Blender automatically
detect the sequence. I've had to select
all of the frames. So I've selected frame one, scroll down Shift
select the last frame. And with all those selected, click Add Image strip. And now we have the
sequence loaded into Channel one of the
video sequencer, and we've got 65 frames worth. We can play that back and see it's playing back just fine. We want to make sure
we're not zooming in or out of this window as well. It is automatically
set up to do that, and we never really
want to do that. I always recommend
viewing any image at one to one size so
that one pixel on your image maps onto one
pixel on your display. If you don't do
that, then you'll get some weird artifacting. I'll go up into the
View menu and choose Zoom 100% one to one. And now I'm absolutely certain that this is what I'm going
to get when I render. All right, so that's
all there is to that. We can now go ahead and execute this rendering by once again going to the render menu and
choose render animation. And that's going
to be very fast. It's just converting an
image sequence to a movie.
11. Checking the video file: Our final step is to simply check our work and make
sure everything came out right in the project folder
in output renderings, there's now a folder
called movies. And inside there, we've
got our movie file. Bender appended
the frame numbers at the end, whether we
wanted that or not. I'm just going to change that,
change the file name here to just Bolo one. And
let's take a look. If you double
click, it'll launch whatever movie player is
associated with an MP four file. I've got the VLC
player installed. That's an open
source video player, double click, and
that'll launch up. And I've also set it, so it will loop infinitely down here so I can evaluate that this
is looking the way I want. Very cool. So that's how we do
a bouncing ball and blender from start to finish.
12. Next steps: I Alright, at the end of this six hour
course on Blender Basics, the bouncing ball, we have
a finished animation. And along the way,
we've learned all about the production
processes in Blender, such as set up and layout, materials, camera, lighting,
and, of course, animation. But we didn't really cover
modeling in this course. However, I'm planning
on producing some more courses in Blender,
including modeling courses, and also courses
covering topics such as advanced materials and my
own personal favorite, which is advanced lighting. So stay tuned for
more courses to come. Thanks for watching and goodbye.
Aaron Ross, Artist, author, educator
