Original subtitles

Now we can actually make the brick shape. Firstly, these corners are way too sharp,

so let's round them. For this we can use a Smooth Minimum. This will do the same as

the Minimum operation, but wherever the two values are closer to each other than this distance value,

it will smoothly interpolate between them.

We can also scale the coordinates so that it becomes easier to input dimensions.

This horizontal distance is our reference, so it spans one unit in our coordinate system,

and the vertical distance spans a proportional amount based on the ratio,

in this case, a third. So if we multiply these values by the actual physical horizontal

dimension in whatever unit we want, we can keep using that unit down the line.

As we are modeling this based on standard UK bricks, we know they should be 215mm long,

but our tiling also includes one mortar width, which we know is normally 10mm,

so we can just multiply everything by 225, and then we can input measurements in millimeters.

So say we want to use that standard 10mm mortar, we calculate that half of that surrounds each

brick, so we just input five into our Less Than, and that's our 10mm mortar gap. This works,

as we now scaled the values such that the gradient along the width of the bricks no longer spans a 0

to 1 range, but rather a 0 to 225 range. And the gradient along the height of the bricks

also got scaled proportionately to 75, which is indeed the height of a row of these bricks.

Note that with these dimensions we could go up to 37.5, which is half the height of the bricks,

at which point the mortar would meet in the middle, as the height is the shortest dimension.

Now let's finally move from the realm of plotting

black and white shapes on a plane into the realm of actual shading!

Let's get our trusty Principled BSDF in here,

and for now we can just quickly set up a temporary color.

We want this shader to be 3D and actually break free from this flatness,

so we'll be using a Displacement node (not to be confused with the Vector Displacement node).

Now we can use the values that we calculated before, to drive the Height of the Displacement,

and connect it to the Displacement Material Output.

Now we see the bricks emerge in our shader, but it still looks like a very flat plane,

and this brick outline is always one pixel wide, regardless of our zoom level.

This is because at the moment Eevee does not support actual displacement,

so it is instead treating our input as a bump map, and changing the normals,

and the thin outline is because we don't have any falloff in our height map.

But if we switch to rendered mode, we see that Cycles actually does displace our mesh.

Maybe this is a bit of an extreme depth for bricks, so let's turn it down a bit.

And we also see that our map is actually inverted, and the bricks are sticking inwards,

so let's change our Less Than to a Greater Than, to invert that.

That's better, but everything is very harsh, with our displacement consisting of just two levels,

the surface of the bricks, and the deeper mortar. There is no falloff, or rounding

to smooth things out. This also emphasizes the low resolution of our mesh in these corners.

So instead of just using a binary Greater Than operation,

let's use a Map Range node, where instead of a hard cutoff we can set a start and an end point,

and set which heights they should map to. So let's set the start point to the five of the mortar,

and then give it five or ten more millimeters of gradient. Now we actually have something

usable in Eevee, and if we look at Cycles, the whole thing looks much smoother as well.

If we were going for a kind of beveled brick look, we could stop here,

but let's give these edges a nice rounded profile. For this we can use a Power operation.

The nice thing about power is that it keeps zero and one unchanged,

but remaps everything in between onto a curve. And this curve has the great property of being

tangent to the horizontal axis at zero, for any power greater than one, and this becomes

especially visible with a power of two or more, so it is ideal to create a smooth easing in effect.

This is smoothing our shape, but on the side closest to zero,

making the other side sharper. But we actually want to round over the edge of the brick,

So we should first invert this zero to one range, and we can do this by subtracting it from one.

In fact, we'll be using this a lot, so let's Ctrl+G it into a more convenient group.

We don't need this other value, as we are always subtracting from one,

so let's remove it, and then let's just name the group.

Now our height map is smoothed in the proper place, but we still need to un-invert it,

and then it becomes very apparent how much smoother this looks.

We can change the power to change how much smoothing to apply.

Note that higher powers will push the edge of the brick closer and closer to the edge of the mortar.

As we're starting to actually work on the shading, it is good to properly see how the lighting works,

and as most walls stand upright, let's set ours up like that as well, so that it is lit by the

HDRI from the proper angles. There is also a big difference in brightness between Eevee and Cycles,

and that's because the lookdev view is ignoring our sun lamp. So let's turn that on over here.

Now we have a good view of our wall. Let's perhaps make it a bit less shiny. Let's also

not forget to tidy our tree up a bit. We can move this down to keep the tree from getting too long,

and with Shift right click and drag, we can add a few Reroutes,

and snap them into place by holding down Ctrl, so that this connection becomes more readable.

One more thing we can do, is select all these nodes that we

are using to create the shape of the bricks, and frame them with Ctrl+J.

Then we can name it with F2, so that we still know what is what as our tree gets bigger.