All language subtitles for 08 Mortar

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!