All language subtitles for 14 FineMortarTexture

At this point, our bricks are
starting to look pretty good,

so let's take a moment to bring
the mortar up to the same level.

Our viewport is a bit slow, because we took
the subdivisions up in the last chapter,

so let's set the viewport levels a couple of
steps lower. Remember that the subdivisions are

only relevant for the displacement in Cycles,
so this doesn't change anything here in Eevee.

Currently, our mortar is just a completely
flat plane, whose displacement level is

defined by this single Value node.
Instead of just a constant value,

we can create a texture to vary the height
of the mortar, like we did with the bricks.

This time, let's see how we can combine different
patterns to create a more complex texture.

Mortar often has a kinda blobby
characteristic, and for that,

a good starting point is the Voronoi Texture.

Now we need to feed it a reasonable texture
coordinate. For the mortar, we want a continuous

texture throughout the plane, so we don't
want to use our tiled coordinates. Rather,

we can just add a new Texture Coordinate node,
and plug in the plain Object coordinates.

Then we can use Ctrl+H to hide the unused
sockets, to keep everything more compact.

The Voronoi Texture has a few outputs.
If we take a look at the first one,

we see some radial gradients in cells. The cells
are spawned from points scattered in space,

and the gradient color within each
cell, tells us the distance from

the cell's seed point. This means that at
the seed point, the value should be zero,

however, we don't see a black dot at the center
of each cell here. That's because the points

are being evaluated in 3D space, so not all
points are located on the surface of the plane.

In this case, we just want to
compute a 2D texture, on the plane,

so let's set the Voronoi to evaluate in
2D. This makes it ignore the Z channel

in the coordinate space, and now we
see a black dot inside every cell.

Now let's add a Reroute after the Value node,
which allows us to easily plug other values into

both the Greater Than and Maximum nodes at once.
Then we can plug our new texture into the Reroute,

and taking a look at the Maximum, we see
the bricks and the Voronoi texture combined.

Now let's see what this does to our
shader, by looking at the final output.

One thing we can notice is that the
Voronoi texture is causing the mortar

to poke through the bricks in some places, as
the texture is going higher than the bricks.

Our texture is also a bit too big for
the concrete look that we are going for,

so let's adjust the scale a bit. Now,
taking a closer look, these seem like cones,

pointing inwards towards the wall, and
indeed that's exactly what's happening here.

We want our blobs to come out of the wall instead,
so let's invert these cones with a subtraction.

Subtracting them from a value will invert
them, and also allow us to offset them at once.

As the range of distance values from the
Voronoi tends to be between zero and one

(though they can also go above
one), let's subtract it from 0.5,

that way, our range will be around -0.5 to 0.5,
and therefore centered around the zero plane.

Now the cones are pointing away
from the wall, like we wanted,

and they are also poking through the bricks less
often, as we offset them a bit into the wall.

But now we still have a texture that looks
like a field of cones, with these sharp points,

which is not exactly what we want.
But we can easily round the points,

using the same technique that we used
to round the edges of the bricks.

If we look at the values before the subtraction,
the points of the cones have a value of zero,

and as we saw when we beveled the
bricks, a power plot has a smooth curve,

and is tangent to the horizontal axis at zero. So
it's perfect to completely round over our points.

Adding a Math node, setting it to power,
and using an exponent of, perhaps, two,

the points in the center
of the cells get smoothed.

Now looking at the final output, we get
the blobby texture we were looking for,

rather than the sharp pointy texture we had.
But at the base of the blobs, where they touch

each other, we still have a completely sharp
line. Basically nothing in the real world has

such sharp lines, so it'd be nice to soften
that. Luckily, we can easily achieve this,

by changing the Voronoi mode from F1 to Smooth
F1. This immediately softens the transition.

Changing the mode also exposed a new Smoothness
input, which we can use to control how soft we

want the transition to be. One is probably a bit
too much, so let's set it to something like 0.5.

The texture is smooth now, but it's unnaturally
neat. We want to make these blobs noisy. We could

just add a noise texture on top of this, but
then the shapes of the blobs would still be the

same. Instead, we can actually distort the blob
texture itself, to make it more noisy and natural.

For that we can again use our handy Distort
group, that we made in the previous chapter.

Let's increase the Scale a bit,
to make the noise slightly finer,

but not too much, as we still want it to have
a broad effect on the shape of the cells.

Then let's increase the Detail and
Roughness to get that rough concrete look.

Now, increasing the intensity, we see the blobs
get a lot more fuzzy. At higher values like this,

it's difficult to see the individual cells, but
the Voronoi still contributes to the specific

look of this texture, which is something we
wouldn't be able to achieve with just a Noise.

Let's take a look at the new texture
in Cycles, with the displacement.

To get a good look, let's crank up the
viewport subdivisions to seven again.

It looks like the mortar texture might be a bit
too intense with the displacement, so let's add

a Math node after this whole setup, so that we
can multiply the texture to make it less intense.

Something like 0.3 seems more reasonable.

Changing the distortion intensity
allows us to set how much of the

blobbiness we want to show through,
versus how noisy it should look.

Switching back to Eevee we can
lower the subdivisions again.

Then we can frame the new nodes, and call it
Mortar. And then just align everything nicely.

Now just to recap what's going on here, for the
mortar, we are generating a texture that covers

the entire plane continuously. Then we have a
texture for the bricks, which leaves the gaps

at a very low value, well below zero. Then, to
combine the two, we use a Maximum. Because the

mortar texture has lower values than the
brick texture wherever there's a brick,

but higher values in the gaps, this causes the
mortar texture to only show through in the gaps.

And finally, to create a mask that
differentiates between the bricks

and mortar at the exact boundary where
they meet, we are using a Greater Than,

which just tells us where the brick
texture is higher than the mortar texture.

The great thing about this setup,

is that no matter what texture we
use for the bricks, or the mortar,

they'll always join nicely, without the need
for us to manually make a mask to combine them.

That brings us to the shader
output. And now we can delete

the Value node that we were using as
a placeholder for the mortar texture.