All language subtitles for 04 SettingUpOurBlenderEnvironment

Before we begin with the actual project, let's
optimize our Blender environment with some

useful settings, and set up our scene.

Firstly, opening the preferences, I'm setting
the UI scale a bit bigger, just to make everything

easier to see in the screen captures, but
this is totally up to you.

Now, if we switch to lookdev mode, which is
the third shading mode at the top of the viewport,

we can see our scene under different lighting
environments that come with Blender.

These are spherical high dynamic range images,
or HDRIs for short.

They allow a scene to be lit with natural
environment lighting, captured from the real

world.

I'll just stick with the forest lighting.

We can also rotate the lighting sphere.

I found that for the wall we'll be working
on, a rotation of -25 degrees for the forest

sphere gives a nice lighting angle.

Feel free to experiment with different lighting
while working on shaders, as it gives you

a good idea of how things will behave under
different lighting conditions.

But for the purpose of this course, I'll always
be using this setup, to give a consistent

view of the shader as it evolves.

If we switch to rendered view, the only lighting
on the cube is from the default lamp, and

the gray background.

That's because we didn't set up any fancier
lighting for the actual render.

In this course, we'll be setting the rendered
view to Cycles, while lookdev mode always

uses Eevee, which gives us a convenient way
to switch between the two, which we'll be

doing a lot.

So to make the Cycles rendered view and the
Eevee lookdev view consistent, let's reproduce

the same lighting.

Firstly, we'll need a node editor.

Since we are not animating anything, we don't
need a timeline, so let's just expand the

timeline, and clicking on the editor mode
drop-down we can turn it into a shader editor.

I'll be using a single window layout, for
the sake of the screen capture, but if you

have multiple monitors, it can be very productive
to pop an editor into a separate window, by

Shift clicking and dragging any corner of
the editor.

This gives you much more space to work with.

Personally, I like to have a whole window
for just my 3D viewport, and use the other

one for the controls, like the node editor,
properties panel, and outliner.

With the node editor open, we can set up the
world lighting.

For that we can switch over from the object
shader to the world shader.

The world shader gets evaluated whenever a
ray doesn't hit any object and goes off into

infinity.

This could either be a ray coming directly
from the camera, or after bouncing off an

object.

Here we see the that there is a background
shader, which basically works the same way

as an emission shader which we talked about
before.

Here it's emitting a gray color.

But we want to use the same HDRI as in lookdev
mode, and for that we'll need an environment

texture node, to load in the image.

If we switch back to lookdev for a second,
and hover over the image in the HDRI selector,

we can see the name of the texture file, which
in this case is forest.exr.

Let's remember that, and go back to rendered
view.

Now we can click the open button and browse
to our Blender installation directory.

I'm using a custom Blender installation, but
you can see the standard installation directories

for the different operating systems on the
screen.

From the directory of our Blender version,
we can find the HDRIs in datafiles, studiolights,

world.

And there we see the forest file.

With the texture loaded, we can just connect
the Color output to the background shader.

Now we can see the HDRI, and it's lighting
the cube as well, but if we toggle between

rendered and lookdev, an obvious difference
is that in rendered mode we can actually see

the HDRI in the background.

This gets very distracting, so let's set it
up such that it only affects the lighting,

and not the background.

Firstly, let's add a Mix RGB node, which allows
us to blend between two different colors.

When the factor is zero, it uses the first
color fully, and when the factor is one, it

uses the second color.

So let's drag it all the way up, and set the
color that we want for the background in the

second socket.

Now we are using this gray both for the background
and the lighting, so we need a way to select

which to use in each case.

For that, we can add a light path node.

As we talked about before, the light path
node gives us information about the current

ray.

We want the very first socket, which outputs
one if the ray is coming directly from the

camera, and zero if it bounced off of some
object first.

So feeding this into the factor allows us
to switch between the different colors when

looking directly at the background, and when
it's used for anything else, like lighting

or reflections.

That takes care of the background, but now
if we toggle the view modes, the cube still

doesn't look exactly the same, because we
rotated the HDRI in lookdev mode.

To reproduce the same thing in rendered mode,
we can select the texture node, and in the

N panel, under texture mapping, we can rotate
the texture -25 degrees around the Z axis,

just like in lookdev.

Now the lighting is almost identical, but
the cube is still a bit brighter in rendered

mode.

That's because we also have a lamp here.

If we toggle its visibility in the outliner,
we see the same brightness difference, and

with it disabled, lookdev and rendered view
are the same.

But rather than removing the light, we can
tell Blender to also take it into account

in lookdev mode.

If we just open the viewport shading properties,
we can check Scene Lights, which enables all

the lamps in the scene in lookdev as well.

Now the lighting in lookdev and rendered view
is fully consistent, so we can move on to

the rest of the setup.

When we select a node, all the links that
are connected to it get highlighted.

This is a really useful feature to see what's
connected to what, but it's not very visible,

as the highlight is white, which is very similar
to the link color itself, so I like to change

it to something more visible.

For that, we can just open the preferences
again, and switching to the Themes tab, and

opening the Node Editor section, we can find
the Wire Select color.

I like to switch it to green, but it's up
to personal preference.

The last thing we'll need to change in the
settings, is in the Add-ons tab.

There we can search for the Node Wrangler
add-on which comes packaged with Blender,

and enable it.

This add-on has a bunch of features that make
life much easier when working with nodes in

Blender.

To conclude our Blender setup, let's enable
the node color, and expand that section in

the properties panel.

This allows us to set a display color, which
we will use a lot, to organize our nodes.

We'll often want to copy the color from another
node, and this feature is hidden in the arrow

menu next to the color field.

This is not very convenient, so to have quick
access to this, let's right click, and select

assign shortcut.

Then we can press the key combination we want.

Ctrl+Shift+C is a convenient shortcut that
is still unused here.

Then we can disable the node color again,
as we don't need it for now.

With the Blender configuration done, let's
set up the rest of the actual scene.

Even though the environment shader takes care
of most of the lighting, the extra lamp is

nice for some more highlights.

Let's change it into a sun lamp, which makes
it directional.

Now, if we switch to rendered view, and mute
the mix node with the M key, we can see the

environment, and look for the sun direction,
so that we can align the lamp in roughly the

same direction.

With that done, the cube looks very overexposed,
so let's turn down the light intensity.

That looks fine, so let's enable the mix node
again.

Now, in the render tab, we can change the
render engine to Cycles.

Now we can switch to lookdev view when we
want to check the shader in Eevee, and switch

to rendered view for Cycles, and both have
the same lighting.

Now, let's just prepare the geometry for the
wall.

Let's get rid of the cube, and add a plane.

Then, in edit mode, let's scale it up something
like ten times, and maybe scale it down to

half that along the Y axis.

It's important to do this in edit mode, to
preserve the object scale.

We'll cover why this is relevant in the chapter
on coordinate spaces.

We'll be using displacement in this shader,
which requires us to have actual geometry

to displace.

So let's add a Subdivision Surface modifier
and set it to simple.

We'll need a lot of geometry, so let's set
the render subdivisions to something like

seven, and the viewport subdivisions to, say,
five, just to keep it a bit faster for now.

This still won't be enough geometry, but rather
than increasing subdivisions more, which are

dynamically calculated, let's add some more
geometry in the actual mesh.

This will speed up our render previews a bit,
and allow for faster iteration.

So in edit mode, let's add a loop cut in the
middle, and subdivide the whole thing ten

times.

Finally, let's get the shader ready to start
working.

So switching the shader editor back to object
mode, let's add the material that Blender

had automatically created for the cube onto
the plane.

And let's just delete the Principled shader,
as we don't need it for now, and this way

we have a clean canvas to start working on.

And to conclude the displacement setup, let's
go over to the material settings, and change

the displacement mode from Bump Only to Displacement
and Bump.

We go over what these settings do, in the
Displacement and Bump Chapter.

Lastly, let's just make sure to save the file.

Note that you can find this file, along with
the files for every chapter, in the course

materials.

And we're ready to begin the shading journey!