Original subtitles

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!