All language subtitles for 13-ChippedDisplacement

Our bricks are nice and rough, and the
edges are looking good, but to really

sell this as an old wall, the surface of the
bricks also needs some deeper imperfections.

Let's create a texture to make the bricks
look chipped. We'll need another Noise,

and we can make this one a bit less detailed
and rough, and also quite a bit bigger.

But unlike last time, when we applied a texture
to the whole surface of the bricks, here we just

want to create some local features in limited
places. For that, we can use a Map Range node.

If we bump up the from min, making sure that
Clamp is enabled, we start clamping the values,

such that most areas are just zero, and we only
see the very peaks of the noise come through.

Now that we have these spots, let's actually make

them a bit more stretched, by copying
the vector multiply node we used before,

un-parenting it from the Frame with Alt+P,
and connecting it to the Vector input.

Then we can change the scaling factors in
each axis to create this more stretched look.

Now, to apply this to the displacement, we
want to subtract it from our height map,

as we actually want the higher values
to be deeper in the displacement.

To avoid long connections, we can
actually subtract the new texture

from the main surface texture here, before
we add it to the complete brick texture,

and that will have the same effect as
placing the subtraction onto the bricks

themselves after the addition, as order
of operations doesn't matter in this case.

Let's take a look at the output. In
Eevee the effect is relatively subtle,

but we can see some of these streaks on
the bricks. Now, if we switch to Cycles,

we get a clearer view of what it's doing, with
some chunks of the bricks getting cut out. And

especially if we set the surface noise to
zero, then we can see the effect by itself.

If we lower the minimum threshold, it
really creates a more bumpy surface,

and increasing the upper end of the
range also intensifies the effect.

But we don't actually want to overdo it, because
with too low a threshold, it ends up having a

strong effect on all the bricks, which reduces the
visual variation, and makes it look more uniform.

So we can actually get more out of an
effect like this by using it sparingly.

Now let's snap these nodes
into the Brick Texture Frame.

The texture that we just created
has a good amount of variation,

but the streaks are completely straight as
we are stretching undistorted coordinates,

so to make it a bit more natural, let's
distort the coordinates before stretching them.

We already made a handy node group to
generate a distortion pattern before,

so let's add it here. Then we can connect
it to the input coordinates of our texture,

and take a look at the texture output, to
have a better view of what we're doing.

Then we can connect a Vector Math
node to the input coordinates as well,

and plug that into our texture, removing the
other link that got moved to the second socket.

Now, if we plug the Distortion into the
addition, the texture gets a bit wavy.

Then it's a matter of adjusting the
parameters, to get a look we like.

If we toggle the addition with the M key,

we can see the difference with
and without the distortion.

Here we have a good opportunity to
create another convenient node group.

Every time we want to distort some coordinates,
we need to add the distortion with a Vector

Math node, and more often than not, the
coordinates that we are distorting are

the same that we plug into the Noise, to
generate the distortion pattern itself.

So let's add a Reroute
here, and group these nodes.

Then let's organize them
and expose all the controls.

Tabbing out, we now have a group that we can
just drop anywhere to distort the coordinates,

without having to manually
add the Vector Math node.

This group distorts whatever
vectors you input into it,

while the other group just
generated the distortion pattern,

to differentiate between these behaviors, I like
to name groups with a verb whenever they modify

something, and use a noun whenever the group
generates something. So as the other group

is already following this rule, being called
Distortion2D, let's call this one Distort2D.

Then we can drag this into the Frame as
well. And take a look at the final output.

One last tweak that we can make, is to set
the Map Range interpolation to Smooth Step.

This is barely noticeable in this
case, but it makes sure that we are

not creating unnaturally sharp edges
where we are clipping the noise.

This is a good moment to switch to
Cycles, and admire our creation so far,

before moving on to the next chapter.