All language subtitles for 03-BrickProfile

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.