Original subtitles

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.