Original subtitles

Now that the brick shape is somewhat defined, let's add the actual mortar in between.

We want to fill the space between the bricks,

so we can use a Maximum operation to introduce a plane along the height of the displacement.

This is giving us the greatest value among the inputs,

so wherever this value is higher than the brick displacement, it is used instead.

This allows us to intersect a plane, similarly to a waterline,

and in fact this is generally how you would fill a procedural terrain with water.

And it is also generally useful whenever you want to intersect two different textures.

If we look at Cycles, we see that the depth is actually changing in the displaced mesh as well.

But we have a limitation, which is that the floor of the displacement is set to zero,

and with the Maximum we cannot go below that, as Maximum returns the greatest value,

which in this case, any value below zero cannot be.

It would be useful to be able to go deeper with the mortar, as we'll be adding a Noise

Texture to displace it later, as well as gaps where it has been chipped away.

So we need to lower the level of the gaps between the bricks.

For this, let's first create a mask that selects only the gaps all the way at the bottom of the

displacement. We can add a Math node, and take the value that we are passing to the Map Range.

Then with a Less Than operation, we can create a hard mask.

In the Map Range we had input five as the start of where the bricks get displaced,

so if we input the same into the Less Than, we get only the very bottom of the displacement texture.

Then we have a mask that is zero at the bricks, and one in the gaps.

Now we can multiply this by some larger value, say ten.

And finally, subtract it from the displacement map,

before the Maximum, pushing the gaps deeper in the displacement.

This doesn't visibly change anything in Eevee, as the normals stay the same, but the new values

are there, and if we look at Cycles, we see that the gaps are being displaced much deeper.

This looks similar to just increasing the Displacement Scale,

however, note that the profile of the bricks is unchanged here.

But if we plug the original map back, and just increase the scale,

the profile of the bricks gets stretched, because the scale is just multiplying the height map,

while our subtraction is specifically offsetting the gaps, while leaving the bricks untouched.

Now we can plug this new height map into the Maximum, and remember to break the other link

that automatically gets made. Plugging this into the Displacement, and taking a look at Cycles,

we can see that we have a much wider range of depths to use with our mortar.

One last thing we need, is a mask to differentiate the brick and the mortar shaders. For this we can

use a Greater Than operation. This will give us a binary mask of where the bricks are sticking out

above a certain value. So if this threshold is set to the same value as the Maximum,

it will tell us exactly where one or the other of the Maximum inputs is being used.

This is not the same as the mask we calculated before, for the gaps between bricks, as that one

only took the lowest part in the brick height map, regardless of what level the mortar is at.

So to keep the Greater Than at the same value as the Maximum,

let's add a Value node and connect it to both nodes. Then we can set it to 0, as we had before.

Then we can use this mask to mix two different colors. So let's add a Color Mix node,

connect the Greater Than to the factor, and copy the base color from our shader into the second

color socket. To copy the color, we just need to press Ctrl+C while hovering the field we want,

then we can Ctrl+V over our destination field. This actually works for any value in Blender.

Let's take a look at this, and select a color for the mortar.

Now, connecting it to the shader, and looking at the output, we can properly adjust the color, and

we see that the colors do indeed align perfectly with the transition between the bricks and mortar

in the height map. And looking at Cycles, we can see this in action with the displacement as well.

Finally, let's organize these new nodes, by framing the different clusters with Ctrl+J,

and naming them with F2. This one is where we are applying the mortar to the brick texture.

A useful tip is to first snap the frame to the grid, and then snap the nodes inside,

that way, if you move the frame later, the nodes stay aligned to the grid.

This other cluster of nodes is used for masking the gaps,

so let's name it, and snap everything to the grid.

And that's the basic mortar!