Original subtitles

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.