Original subtitles

Displacement is useful for adding surface detail that is inconvenient or too small to

model.

Displacement works by actually moving the vertices of a mesh, based on a displacement

map, though at the moment, this is only supported in Cycles.

We can use a shader to move vertices anywhere in space, which is called vector displacement,

but in this course we'll only cover the simpler normal displacement, which uses a height map

to displace along the surface normals.

We can use any technique we want to generate the height map, which consists of a single

value that indicates how far to displace a given point.

For instance, here we have a Noise Texture that we can use as a height map.

The Material Output node has a socket for Displacement, but it's expecting a vector

indicating how far, and in which direction to move, so we can't plug our height map in

there directly.

Note that the Displacement socket is just like any other vector socket, so if we plug

a value in there, it would just trigger the usual value to vector conversion, and all

three vector channels would carry the same value, resulting in a diagonal displacement,

which is basically never what we want.

This is not to say that we would never want a diagonal displacement, but just that this

is not a reasonable way to achieve it, as we have no control over the direction.

To properly displace using a height map, we can use the Displacement node, from the Vector

category, not to be confused with the Vector Displacement node.

The Displacement node will compute the displacement vectors along the surface normals for us.

So let's apply a simple shader, connect the Noise Texture to the displacement height,

and connect the displacement vector to the Material Output.

This causes a change in shading, but the plane is still flat.

That's because by default displacement is not enabled, so we need to go to the material

settings, and change the displacement from Bump Only, to one of the actual displacement

options, let's use Displacement Only for now.

The plane still doesn't seem to be displaced properly, and that's because, as I mentioned

before, displacement works on the actual mesh vertices, and here we just have four of them.

The way it works, is that before the actual render starts, the displacement texture is

evaluated at each vertex's exact location, and the vertices are displaced accordingly.

So to get the proper effect we'll need more geometry.

We can, for example, use a subdivision modifier.

Now as we increase the subdivision levels, we see the displacement also getting more

detailed.

So it's important to always have enough geometry for whatever kind of texture we're using for

displacement.

Let's take a look at the displacement parameters.

The Space parameter, when set to Object Space, causes the displacement to inherit the object

scale, so the amount of displacement gets scaled together with the object.

Meanwhile, when set to World Space, the displacement always uses world units, so the amount of

displacement is not proportional to the object scale.

As we saw, the Height input is where we plug our height map.

The Midlevel is the value that will be treated as the object's typical surface level, meaning

no displacement.

For procedural textures, we can generally set this to zero, but with image textures,

negative values are often not supported, so to be able to displace both into and out of

the surface, a value of 0.5 is often reasonable.

But all this does is offset the whole surface in or out, by subtracting the Midlevel value

from the whole height map.

The Scale determines how much one unit in our texture represents.

This is really just a multiplier for our height.

If the Scale is set to one, then one unit in our texture represents one unit in the

output space.

So if we selected world space, that's one Blender unit, and if we selected Object space

it's also scaled by the Object scale.

This parameter is important if you are working with real world units, or just to have a sense

of scale in general.

Lastly, Blender will fill in the surface normals automatically, so we can leave the Normal

input disconnected, unless we have some different normals that we computed in the shader.

Now if we switch to Eevee, even though the displacement is not supported, we see that

the texture is affecting the shading, just like it was with Cycles before we switched

on the actual displacement in the material settings.

What's happening is that it's using our height map as a bump map.

This works in the same way as the Bump node.

The way a bump map works is that whenever a ray hits the mesh, even though the actual

position is not affected by the height map, it calculates what the surface normal would

have been if it had actually been displaced.

This way, the rays bounce off the surface, as if the mesh was pointing in the displaced

direction.

It calculates the normal by evaluating the height map at the point where the ray hit,

but also at a couple of nearby points, and based on the height difference, it calculates

the normal angle.

This means that this is one of the few instances where something is calculated not only at

the actual point where the ray hit the mesh, but also some other nearby points.

Though that also means that this is quite an expensive operation, as the height map

is evaluated three times for each ray.

Now that we know about bump mapping, we can go back to the material settings, and look

at the displacement mode again.

The compound Displacement and Bump mode is useful as it will displace the mesh, but also

compute the correct normal according to the height map.

This means that even if we don't have enough subdivisions to show every tiny detail, we

can still see them in the shading, while the displacement takes care of the major shapes.

Note that this will slow the render down significantly, compared to using just displacement, but it

can be worth it for the extra detail, thought sometimes increasing the subdivisions is actually

faster than enabling bump.

This is something to benchmark case by case, and it also depends if your priority is speed

or memory usage, as subdivisions could cause you to run out of memory, in which case adding

the bump is the only option.