Blender 3.0 Beginner Tutorial Part 15: Rendering

>> Blender comes with two ways
to render your final image.

You've got Eevee, which is your fast
game engine-style approach to rendering,

and then you've got Cycles which
is slower but is true ray tracing,

so it usually results in
a more realistic result.

But with some finessing if you know what you're
doing you can drastically crush those Cycles

render times down to something much
more palatable for the average machine.

So in this video I'm going to show you
precisely that: how to render with Eevee,

how to render with Cycles, and
then what trade-offs to be aware

of when you start tweaking those settings.

But speaking of realistic if you want
better renders, you need better assets.

With Poliigon's models, textures, and HDRS, you
can create architecture and environmental scenes

that look amazing from every angle.

Sign up today at poliigon.com or by
clicking the link in the description.

Alright, so I'm actually going to start with
Cycles, because I think that is the engine

that most of you are going
to want to end up using,

because we will crush the render times down.

I'm convinced you will be happy enough
with it that you'll want to use it.

And let's turn off Noise Threshold and denoise,

because I think that can kind
of complicate the final result.

And I'm also just so that I can see it
I'm just going to turn off my compositor.

And I'm just using a really low
sample count of 100 samples just

so that I can demonstrate
what is going on with Cycles.

So I went over this a little bit at the start,
but explaining it again, the way path tracers

like Cycles work is it starts noisy, and
then the longer you let it render for,

the more refined and clearer that noise becomes.

And that noise is determined by your samples.

So the lower your samples, the more noise
-- so it basically it starts at 1, right?

A 1 sample image would be
basically unusable, right?

It's so, so noisy.

And then, the more samples that
you throw at it then, you know,

the more -- the less noisy it becomes.

You know, you do 100 samples
et cetera, et cetera.

So the sample count is very
important, and it is, you know, --

it's the biggest determining factor
on how usable an image becomes.

Because although there is this magical,
I mean that really is the closest word

to describe what a denoiser is doing
-- although there is a denoiser and --

let's switch slots here so
that I can compare the two.

It's still -- it has to base it off of
what it gets from the renderer, okay?

So it's basically it's going -- this is --
by the way, I'm swapping between slots just

by you can type the number in the top
row, and you can switch slots there

or by hitting J to swap between them.

But anyway, so it has to base it off of this
and then it's doing a denoise operation.

And because of that, because it had to
do it on this very noisy-looking image,

you can see that I've got splotchiness appearing
in my my shadows here, which might not be

that much of an issue for a still image.

But we're doing an animation, and it doesn't
have temporal stability I believe it's called,

where it'll try to base it on an
animation like over a number of frames.

It'll just do it per frame, so you would get
a lot of flickering in this splotchiness,

and it would be sort of unusable.

So really the amount of samples that like -- the
original raw image without denoising is the one

that matters most before it does that denoiser.

So I recommend turning the denoiser off, and
then once you're happy with the sample count,

then using your denoiser on top of it.

By the way speaking of denoiser, I mentioned
it this like I think in the first video maybe

of this series, second video, I
was talking about the denoiser,

and I was like huh, oh that's weird.

I don't know why it's using the open
image denoiser for the final render.

I later learned that Optics is the
one that is best for your viewport,

because it is fast, but it is less accurate.

It doesn't create as good
of a denoise operation.

So you want to use Optics
for your your viewport,

but then for your final render you want to
use the intel one, because it will do a much,

much better -- it uses way better
algorithm to actually like figure out,

yeah, to smooth it out essentially.

So anyways but as I said, I want to turn it
off so that I can just focus on the samples.

Okay. So the aim of the game is
really to try to get the least amount

of noise possible in the least amount of time.

That is the game every 3D
artist is essentially playing.

So there's all sorts of settings
and things you can tweak,

but obviously the biggest one
is, you know, your sample count.

I would say like okay, if you -- without
Noise Threshold we'll talk about that,

but with just 200 samples, the
difference between 100 samples

and 200 samples is going to
be a big difference, right?

And it's not actually going to
add that much to the render time,

because I think it's got three seconds of
build time to actually create, you know,

compile all the objects, put it on the
graphics card memory, and render it.

So it's only adding one second.

And it's clearing up the image substantially.

So that would be a good investment in your
render time, right, to increase your samples.

But still this is not this is not an
acceptable amount of noise for your engine and,

you know -- before it does the denoise.

You'll get better at predicting what that
level is, but just take my word for it for now,

this is not an acceptable amount of noise.

So previous to maybe 2.93 was when
we got this Noise Threshold release,

and then with the release of
Version 3 we've now got Time Limit.

So now this is actually complicated.

It's made a little bit more advanced.

Essentially with Noise Threshold and
Time Limit as well, these three values --

this one, this one, and this one -- it will stop
the render when one of these is reached, okay?

So sometimes -- like for example, the Noise
Threshold by default is like set to .01, okay?

But if I was to just hit give
another render of this, okay?

So from 200 samples, 200 samples again,
but with a different Noise Threshold,

the difference between them is nothing, okay?

Okay?

Across the entire image, I've
got the exact same result,

even though now I'm using the Noise Threshold.

So the reason for that is that this Noise
Threshold is actually a really low --

it's a low amount, but actually it's --

the lower the value, the
clearer the noise it will --

it's looking for essentially, your threshold.

So that's kind of a high threshold.

So basically the sample count is so low,
that it's rendering all of the samples,

200 samples, and then it has to stop.

So it's stopping the image before
that Noise Threshold is reached.

So whether that's enabled or not makes no
difference, because my sample count is so low.

On the flip side, if I was to use a high sample
count and then use a low Noise Threshold,

but again it's a higher threshold.

kind of hard to think about the
thresholds like that, but anyways.

Okay. Let's do this.

Okay, let's set this.

So I've set my Noise Threshold
to .1, but my Max Samples is now

at a much higher Max Sample amount.

And then let's go to slot Number 4 now.

And let's type in -- what was I doing?

Just trying to think.

Noise Threshold -- yeah.

Now let's like double this, okay?

So times 2.

Will this make a difference?

It shouldn't, because it will not have
-- it hasn't reached the Max Samples.

So it's basing the stop value
and it's stopping the render

on the Noise Threshold, not the Max Samples.

Okay. So the difference between them -- I mean
there is a difference, but I think it's just

because it has to it has to kick
in a Noise Threshold and it like --

I don't know there is some
weird calculation that goes

on when you're using a Noise Threshold,
so you lose a little bit regardless.

But you can see the image hasn't changed.

I'm swapping between those two
with doubling my Max Sample amount,

and it's not making any difference
to my render engine.

Sorry if this is like going
too -- in like explaining it.

Maybe you get it, but it is a very
important point to think about,

because when you start working on a scene,
you're like yeah which one is it actually using?

is it stopping the image
from the Noise Threshold,

or is it stopping the image
from the Max Samples?

And it kind of depends, because the Noise
Threshold, you'll really see it work

in like a scene with like lots going on.

Like lots of complex objects.

You've got like a tree, you've got a house,
you've got a river, different shaders.

You've got a shadowy part,
you've got different things.

It then has to render longer in
certain areas to clear up that noise,

and then less time in other areas.

So the Noise Threshold really kicks in.

This is a much more uniform object,
but there is still differences

because the subsurface scattering in
the icing is a very costly calculation.

But it's quite easy on this hard candy here.

So it should need to spend longer rendering
this area than it does this area here.

So it's actually a good thing that it's
stopping at the Noise Threshold here,

or that we're using the Noise Threshold,

because it should stop rendering this
area here before it stops rendering --

but it'll render longer in this area.

So anyways.

Hope this is starting to make sense.

But I think the best thing you can do
is to actually use a high sample count,

but then base your, like,
what Noise Threshold do I use?

Look at the noisiest part of your image.

And then basically reduce this
until you're happy with --

until it is at a noise level
that you are happy with.

Okay. So let's go -- this is half that amount.

So it's now -- it should be twice as noise-free.

I guess that's the wording
you would use for that.

And you can see it's taking
a lot longer to render.

But it should be finished a lot sooner as well.

Okay, so that's 20 something seconds.

Wow it's almost coming up to 30 seconds.

Wow, because it's almost
hitting the sample count.

I think it might actually stop with the samples.

There you go.

Okay, but here's an example,
right, of the Noise Threshold.

You can see big differences here in
the noise, but here on my hard candy,

there's not actually a lot of difference
and in fact I think if I look over here --

yep, on this side of the donut, there's
almost no difference between the two

because it actually hit the Noise
Threshold before it hit the samples.

So that's the difference there.

So we're talking about, you know, fixing
this if, you know, if I was to render this,

I would really probably need about 30
seconds of frame for rendering on --

this is on Dual Titan RTX's, and I know most
of you watching don't have hardware like that.

That's quite a long render time.

Now why is Cycles slow?

Well, this is actually quite a complex scene.

and what I mean by that is because
of one thing, my shader here.

As I said subsurface scattering
is a very costly calculation.

If I set this all the way to zero,
watch how much faster it is to render.

Here we go.

It should now start to rock it.

And then we've got five seconds.

We went from 30 seconds with this noisy
result, to a cleaner image in five seconds.

Okay. Now what is the difference?

Okay, you can see with subsurface scattering,
yes, you get light that sort of like bleeds

into the icing a little bit better.

It is technically more accurate.

You also see it kind of around the -- not
just in the shadowy areas, but also on,

you know, this part of the icing as well.

Yes. But from afar, the difference is minimal.

Right? So is it worth like a
six or even 10 times the amount

of render time required, just
for that tiny difference?

I would honestly say no.

For most of you watching, I don't
think you need subsurface scattering.

So I think turn it off.

Because I think for most of you watching,
you'll be much happier with the render time

and the fact that you don't have to
yeah, render for 10 times the amount

of time just for that tiny little difference.

So I would do that.

And then I would probably still because
now, you know, I'm down to five seconds,

why not just kick it up a little more.

Let's go -- let's double or
more than double the threshold

and let's get it even clearer for my render.

So it's not going to stop 5
seconds, 6 seconds, 7 seconds, 9, 10.

Maybe that's a little too far.

Maybe I went a little too extreme on that one.

The difference -- yeah 12
seconds but, you know what?

It looks alright.

So that's probably the one that I would go with,

and then I would do it --
maybe okay, let's go .03.

I'm going to use this as my final amount.

So Max Samples 81, 92, .03 for my
Noise Threshold denoiser intel.

And then also as well as this, because
we've got stuff in the background,

and I didn't mention depth
of field or motion blur.

So motion blur, first of all
that is the easiest one of all.

It's just a checkbox in your
render settings checkbox.

And then I think that the shutter
speed by default is set to .5.

I set mine to 1, because I
want there to be like a nice --

I'll just show you what it looks like
when you render it with motion blur.

I want there to be a nice motion
blur when it's spinning around here.

By the way motion blur got so much faster in
-- like when motion blur was first introduced

for Cycles, I think probably I guess
with its inception, it was really slow.

But they like -- I think there was
like one release where they're like,

yeah we reduced the render times for
motion blur like 20 times or something.

So it is now so much faster to use
motion blur than it used to be.

So that's good.

Alright, so that's motion blur.

And then depth of field there's no
setting for depth of field here.

It's actually done in your camera setting.

So with your camera selected in your
Outliner, then go to your Camera options,

and then here I want to use depth of field.

Check that button.

And then if you look at the rendered view, you
would see that everything looks out of focus.

And it's basing it off of
this distance value here.

So you would basically adjust this to
adjust where you want your focus to be.

But actually I find the easiest way to do it is
to use this Eyedropper tool for Focus object.

And then you just select the object you want
to focus on, which in this case is my donut.

And there it is.

Now which part of the donut?

Because some part of it is closer
to the camera than the others.

It's doing it based off of the
origin point of your donut.

So if for whatever reason your origin
point was like, way over there,

your depth of field be totally wrong.

So you just have to right-click,
Set origin, Origin to geometry

and it would reset it to the center of mass.

And then your depth of field should be correct.

And I think I'm having second
thoughts about this Noise Threshold.

I think that is -- I think .05.

I think I could get away with that,
and also I'd go -- yeah let's halve it.

Max Samples.

Let's see how this looks.

Because -- yeah, because I demonstrated at
the start, you know, that the render times,

you know, if I wanted to get it down
to yeah, eight seconds, I think --

I think that's acceptable in terms of like
glitchiness or any sort of shadow patchiness.

You usually need to render a few frames to
see how it's going to like flicker across it

because of -- as I mentioned, it's an animation.

But, you know, if you're, you know, for
something like TikTok, you know, Twitter,

the compression is so high,
you're not going to see it.

So depends on what the platform
it is you're uploading to.

If it's for like a feature film, you
want to go for that extra low amount.

Okay, the other thing that will make
a big difference is persistent data.

That will -- is especially important
over over frames, because it basically --

the build time which, like, it has to take
the the mesh, the object data, and then like,

put it on the graphics card memory.

and then, you know, in order to render it.

It'll only have to do that once.

And then for all the other frames that follow
it, it'll just use the build time from before,

which is -- so that'll make a big difference.

What's the other thing I need to enable?

Yes, post processing.

I turned off compositor.

The compositor will add usually
in my experience about a second.

I think it just uses your CPU.

Somebody correct me if I'm wrong there.

But yeah, it'll use your CPU.

And obviously it depends on how much
complexity you got going on in your compositor.

We don't have that much.

So a little bit of extra time there.

And the other really big thing that I think
I mentioned would make a big difference is --

I said this at the very start, but
just to recap, use your GPU, right?

I'm using Dual Titan RTX's.

If I was to switch to, you know, none; I would
not get this GPU option over here, right,

and then I would have to use my CPU.

And the CPU render times are extreme.

So it obviously depends on how good your CPU is,

but mine is nowhere near as
good as my graphics cards.

So wow. It says what it's gonna be 24 hours.

That can't be right.

Well, it's wrong.

I assume it's wrong.

But yeah, it would it would not
be fun to render this on a CPU.

So if you've got the option for those,
you know, whatever would show up here,

make sure you're using that, or HIP if
you've got an AMD that's suitable for it.

Now another couple of other things.

I mean, I wouldn't really recommend this, but
there's max bounces as well, which is the number

of bounces that it's going
to do, you know, off objects.

Right? And you've got a max for like,
you know, if you want to control all

of these different amounts, diffuse, gloss,
transmission, all -- if you want to cap it.

If I set this to 1, it would
cap all of those at one bounce.

And it will be faster but it will
also be noticeably different, right?

Like if I was to -- okay, this
was the previous render, I guess.

Was it? Denoise, hmm.

Hang on. Let's do a render -- okay, well I'll
just do a render with the light paths at 1.

And then I'll do another one at the
light paths at another one -- let's see.

Okay, so we got that down to
8 seconds, 11 seconds alright.

And then let's change the light parts back
to 12, and then I'll show you the difference.

And usually it means that
you'll get -- it'll be darker.

Sorry, when you're using less light bounces,
it'll be darker, especially in like crevices

because there'll be less light that's bouncing.

Right? So and because I've got
persistent data -- that's the thing.

With persistent data, it's deceiving.

because it's now borrowed
the build time from before.

So it's saving time.

So that's why it's actually -- it's
doing more computations, but it's faster.

So it's not -- but, you know, you could
play with light bounces if you want.

I wouldn't recommend it, because I think
it's actually fine at the defaults.

Clamping. I mean that's -- I
think the default is set to 10.

The higher you set that to.

The faster it'll render, because it
doesn't have to clear up bounces.

It's most noticeable in like, you know,

a closed-off room interior
with like a single point lamp.

It'll, you know -- that's
where it's most noticeable.

For something like this, it's not
really going to be noticeable.

But I usually recommend turning it
off, because you get a better result.

You get more light coming into the scene.

And then reflective refractive.

If you. Turn off caustics, it'll make a minor,

minor difference to your
render times but not by much.

And was anything else, I'm just trying to think.

Performance, Threads?

No. I mean hey, if there's anything
I've missed, in terms of like speeding

up render times, let me know in the comments.

Because I'm sure other people
would like to know.

I'm also curious what hardware you guys
have got and what your render times are,

because I think a lot of people are very,
like, unhappy with their render times,

and they want to say like, is this normal?

Is it normal for it to take
20 minutes per frame?

So comment below what hardware you've got,
if you're rendering CPU, GPU, what that is,

and then what render time you've
got so that other people can see.

Because I think that a lot of
people would like to know that.

So there we go.

That's the difference between
the -- what did I even enable?

I'm just talking while I'm doing stuff.

Now let's switch to Eevee, because I think
a lot of you would be curious to know --

maybe your CPU -- you had to render on CPU
and it was going to take 24 hours of frame.

How can you render on Eevee?

So the good thing about Eevee is that
it is basically -- it's real time.

So you get it all for free.

But you generally -- unlike Cycles where
everything is like accurate and ready to go

and you have to then like crush those render
times, with Eevee, it's fast but you also have

to turn things on in order
for it to behave correctly.

So I've actually set all my -- because
I think we changed it at the very start.

But some of you might have different settings.

So I've set it all to the defaults,
and I'm just going to go through

and just quickly show you how to set up
Eevee for rendering this type of scene.

So the biggest one is underneath shadows
in your render settings, Eevee shadows.

We've got Cube size, which is a --
the Cascade is for lamps, sun lamps,

which we don't have any sun
lamps, so it's not important.

But Cube size is for all the other lamps.

And that is this basically the size of your
objects in kind of like a blocky volume field,

where it's going to be starting
to calculate shadows from.

It's most obvious like if
-- okay, that's the default.

If I was to set this to its maximum.

Do we see any difference?

Oh okay. We actually won't
see any difference, I think,

because none of our lamps
have shadows turned on.

So let's see, actually let's turn
off the fill, let's turn off the rim,

and let's just turn on shadow
for my key lamp here.

And now let's go back here and
let's set this to its maximum.

Okay.

So this is set to nothing.

This is set to its maximum.

Nothing, okay.

What's actually going on now?

Oh okay, so does this need to be lower?

what's actually going on now?

I'm very confused.

Okay. So something is happening.

Oh, the clippings start.

Okay. That was set too low.

Okay.

So I mean it's really it's the --
like it's all just kind of like --

I mean you have to learn what bias means.

It's kind of it's based on
like Blender's unit scale.

Because we're working on
like such a small tiny donut,

all these values are kind of wrong by default.

So I have to turn them all
the way down basically.

This one though I have to turn up,
oddly, in order for it to work.

But now that I've done that,
you can see the difference here.

So this is with 512.

You can see that it's -- I've got
light bleeding through my object here.

But then when I turn up the resolution,
it's able to detect more of the object

and go okay this part should be in shadow.

I'm getting less light bleed around there.

Okay. Then another one, because
this is my key lamp,

I want to see some shadows on my sprinkles.

And you can see that I've got
one side of my sprinkle in shadow

but I don't have any shadow cast onto the icing.

So for that I would turn on contact shadows.

And with that, I wouldn't see any results by
default, because the values are again wrong.

So let's turn the bias all
the way down to 0 or 0.001.

Okay. And now I can see results.

So contact shadow you should
know, is a fakery, okay?

It's not real shadow casting.

It's basing it on what it can see on
the screen and it's doing a fakery.

So what I mean by that is as an
example look in the bottom --

like on the left hand corner of the screen now.

Watch what happens to this
shadow of this blue ball here.

If I just drag across there, you
can see that it is disappearing.

The shadow is disappearing, and
that's because it's only able

to detect it when it's on the screen.

When it's offscreen, even though there should
be shadow there, it's not able to detect it.

So that is just a limitation
of that type of calculation.

And by the way, that is the
same in Unreal Engine.

You see it a lot in animations done with
Unreal Engine, the exact same thing.

It's just the way it works.

So contact shadow should be done basically
in animations where the camera's not moving

where you, you know, it's
not going to be an issue.

But for something like this, it's not a problem.

Distance. I guess I just have to
make sure it's not set to zero.

And then thickness, the other one.

Yeah thickness.

So you can see, if I look at this --
this is what it was set to before.

The shadow from my blue ball here is --

it's casting shadows on things
behind it, which is odd.

Again it's like how -- what
exactly is it calculating on?

I mean you just have to fiddle with it.

I find you have to set this value to not its
lowest, but somewhere around .03 it starts

to look correct, .0034 for this scale of object.

Again your scale might be different, but
that is what is looking correct to me.

Okay that's the key lamp.

Now let's go the rim.

The rim, turn on Shadow and then set
your Bias all the way down to zero.

And that is basically -- oh
and then your clipping amount.

Clip start.

You just want to turn that up
from zero essentially, okay?

And then my fill lamp.

Turn on Shadow.

Turn the Bias all the way down
to zero, and then Clipping start.

Let's turn that up, and there we go.

Okay so, my key, my fill, and my rim all
together looks a little bit like that.

And we can improve it with
some Screen Space Reflections,

which you'll see most noticeably
on these shiny balls here, okay?

It's not true reflection, by the way.

It's not really doing an accurate
reflection of what's around it.

It's doing an okay, passable job, but it's not
anywhere near as accurate as full ray tracing,

which is what you get with Cycles.

But it's like -- it's doing a pretty good job
for something that you get for free essentially.

It's doing a great job.

The other setting you might want
to use is called Ambient Occlusion.

Ambient Occlusion if you missed it from the
start, it will add in darkening in the crevices,

which is what you see naturally in real life.

It's what Cycles would generate,
you know, accurately by default.

But you turn on here.

And you won't see anything, and it would
actually confuse me when I was practicing

for this tutorial, because I'm
like why is Ambient Occlusion?

And it's because it's actually it's kind of
basing it off of the -- [keyboard clicking].

Oh dear sorry about that.

Slackbot, very annoying.

Thank you.

The strength -- it's basing it off of
the strength of the world lighting,

and then it's doing an ambient on top of it.

So if this is set to zero,
you won't get any ambient.

So basically you have to
set this to something else,

like you have to have a little
bit of world lighting.

And then when you do that, you'll see that
there's a slight difference between ambient --

I mean, is there a slight difference?

It's so subtle.

You can kind of see it in here.

On, off; on, off.

I mean can you see it?

I actually don't know.

I mean because you guys are watching
on YouTube, it's like even subtler.

But yeah, there's a slight
darkening going on there,

and that's with the factor all the way up.

Oh you can go higher.

Oh I can enter a value higher than 1.

I might want to do that.

But yeah, that's what you would do if you
wanted to get nice looking results from Eevee.

There is sampling for Eevee, but
it's not the same sampling as Cycles.

It is just a -- it's basically like
-- I'll show you the difference.

Alright.

Let's do a render with this.

Okay look at that.

Wow, one second.

One second, and one-and-a-half seconds.

And then if I set this to this like, 12 samples

and I'll show you the difference
between the two.

Okay? It is faster okay, but
it's like it's doing less of that

like calculation of the lamp to make it soft.

It's doing less of that.

So look, I mean what difference
does it make, right?

When you've got render times
down to this amount,

it's really -- it's splitting hairs here.

I'd just go 64 who cares

Bloom, we don't need because we've got it.

It's working in the compositor, but you could,
you know, use that instead if you wanted to.

Indirect light.

That's really only used for like big scenes.

It's a sort of a more advanced
way of generating it.

But yeah, there you go.

So it's kind of cool, you know, with having
Eevee and Cycles right next to each other

and kind of their values are independent.

Like all that stuff that we did with
the lamp here doesn't make a difference

to Cycles, because Cycles doesn't need it.

But when I switch to Eevee,
it will just use that instead.

So there you go.

So I'll just quickly show you the
comparison of the two side by side.

This is with 4,096, samples 0.05,
and I'll show you the render times.

It's around 11 seconds.

Oh it's going to be 13, I
guess with the compositor

on top, 15 with the denoising as well.

Alright, so I'd probably maybe try to get
that down a little further, but I think it was

like -- I thought it was
like 10 before, but anyways.

There's a big difference,
right, between Eevee and Cycles.

And it's really -- it's just this part.

I mean, that's the biggest part,
which you could actually fake

if you put a lamp in there that was pink.

So there are ways to fake it.

You would have to work extra hard
to fake the bounce around each

of the individual sprinkles, though.

That it would not help you with, so there are
-- I mean that there's just trade-offs, right?

So alright, I won't make this
any more longer than it needs

to be, because I think that's about it.

So don't actually render this though, okay,
because I don't want you to render this

and put it into a video file or anything like
that, because that's not the way to render.

And I've got a few little tips
that I want to include on how

to make your donut look even better.

So believe it or not, we're actually
gonna do the rendering in this next video,

the one that's called Compiling the Animation.

So go ahead click here.

I'll show you how to fix your donut make
it look even better than it already does,

and we'll render it out, and
we'll create that final video file

that you could then upload to
your social media, et cetera.

So click there, and I will
see you in the next part.

Bye.