All language subtitles for 18 RandomDepth

The general texture of the bricks and mortar is
coming together nicely, but if we take a look

at the displacement in Cycles, the geometry of the
wall is still pretty plain, so let's work on that.

So far, all the bricks in our wall are sitting
at the same displacement level. Forming a

perfectly flat wall. That would be ideal if
we were looking for a skillfully built wall,

but of course, that's also boring. So
let's have some fun with the brick levels.

To make changes to the bricks, without
affecting the mortar, we want to work

before the Mask Gaps Frame, like when we added the
brick texture. So let's duplicate this Math node,

and connect it here in between. As we are
working on the height map of the bricks here,

changing this value allows us to change the
level of all the bricks. We can see that

adding a higher value shifts all the bricks
outwards, making the mortar look much deeper.

And we can also push the bricks in the other
direction, even putting them behind the mortar.

So now, what we want is to feed a random value
for each brick into this addition. Way in the

beginning when we were making the tiling for
the bricks, we did compute a random value for

each brick, which we have already been using to
randomize a few things. Here we used the first

random channel for the rotation angle. And if we
follow this connection, all the way on the other

side of the tree, we used the other two channels
to randomize different aspects of the brick color.

That means that we are out of random channels
here. If we would now use any of the three

channels to also randomize the brick depth, we
would be coupling the depth to another property,

and we don't want that. So let's see
how we can get more random values.

If we take a look inside the Bricks group,
we can remind ourselves of what we used to

generate the random values. Here we find that the
Random output is coming from a White Noise node,

and the input to the White Noise is given by the
floored coordinates that we are using as index.

With that in mind, let's tab out again,
and add another White Noise node.

A node just processes the
inputs to generate its outputs,

so by definition if we pass the same input into
identical nodes, we will get identical outputs.

And indeed, we can see that if we plug the index
into the White Noise, and set the mode to 2D,

like the other White Noise node, we can switch
between them, and the outputs are identical.

So how can we generate a different random
pattern? Well, we can just use the random

output from one node as the input for another.
Then it's generating a random value based on

a new set of inputs. If we switch between then
now, we can see that they are indeed different.

And we can do this as much as we want,
chaining White Noise nodes together,

to generate an unlimited amount
of different random values.

But we can actually make it a bit
more efficient, by switching to 1D,

and feeding just one of the random channels as
input. Because these input values are already

completely random and unordered, using one channel
is just as good as using two or three. And then we

could generate new sets of random outputs from
each channel of a previous White Noise output.

But for now we just need the one. Let's shift
these nodes over a bit, so that we can add a

Reroute to make this a bit more neat. And then
let's create some space for our new setup,

and bring the White Noise over, creating
a neat path with Reroutes along the way.

Now, if we take a look at the output,
and connect the Noise to the addition,

there is a bit of variation in the brick
levels. But to make it more pronounced,

let's add a Math node, and set it
to multiply, to increase the effect.

Setting it to a high value like five, the
effect is very visible, but probably a bit

too much, as bricks would practically be
falling out of the wall at this point,

so let's set it to something like two.

Now, the amount of depth variation is more
reasonable, but it would be nice to have

a bit more contrast, so that the bricks that
are sticking out further are more noticeable.

One way we can get this, is by adding
a power before the multiplication.

Because the values from the Noise
are in a range between zero and one,

a Power operation doesn't change this range,
as zero and one don't change with any power.

But with an exponent above one, values
closer to zero become even closer to zero,

while values closer to one don't change that
much. This effectively changes our distribution

of values, such that there are more low values
than high values. And while this does generally

decrease how much most bricks are being displaced,
it makes it so that the bricks that are displaced

a lot stand out more in comparison to the other
bricks around, making the effect more noticeable.

The higher we set the exponent, the flatter
our wall becomes, and the fewer bricks are

displaced significantly. An exponent of
three seems to give a good balance here.

Now because we are only displacing
the bricks in the positive direction,

they all moved a bit outwards, making
the mortar deeper by comparison.

So now, with another Math node, we can subtract
a value to shift the bricks back into the wall.

Too much, and it will go behind
the mortar, like we saw before,

but a value like .5 seems to be just
enough that we get a bit of mortar

overlapping the bricks in some places,
for visual interest, but not too much.

Now to wrap up this chapter,
let's just frame these nodes,

and we can call it something
relevant like Randomize Brick Depth.

And we can leave the background color on default
here, as this is still part of the bricks setup.