Original subtitles

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.