All language subtitles for DisplacementAndBump

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.