All language subtitles for 27-InfiltrationBrickPattern

Now we have this infiltration, but we are applying
it with one solid mask here at the bottom.

In reality, there would be a lot more variation as
the moisture wouldn't affect every part equally.

One interesting thing that we can do, is apply
the pattern of the bricks themselves onto the

infiltration, in such a way that it is stronger
at the mortar. This could represent moisture

accumulating in the crevices, or just the
different permeability of different materials.

Here we have the distance field of the bricks,
which we can use to apply a gradient onto the

infiltration. Remember that the part that
looks white is not actually constant,

but just goes much above one, as each unit
represents one millimeter of distance.

So let's add a Map Range,
to create the gradient mask.

If we set the maximum to a much higher value, we
can actually see the gradient into the bricks.

Let's set the minimum to where the bricks start,
so that the texture is fully active at the mortar,

and fades into the bricks. If we take a look
at the node where we set the brick bevel,

we see that we have set the edge
of the brick to start at five.

So let's set the same minimum here.

Now, because we want the texture
to be at its maximum in the mortar,

and fade down into the bricks, let's invert
the output. Then, with a lower maximum input,

we see the texture fade all the way
to black in the middle of the bricks.

Let's make some space here, and add
this node to our infiltration setup.

And as always, let's improve
the layout of this node link.

Now let's add a Math node so that we can combine
these textures by just multiplying them together.

This gives us the basic pattern, so let's
take a look at what it does to our shader.

This does make the infiltration fade away in
the bricks, but it still looks very uniform,

so let's get some variation in here. For the
brick bevel, we modulated the Max input with

a noise texture, which creates a very nice
effect. So let's try the same thing here.

We can even reuse the same Noise, as
it seems to have a suitable pattern.

But since we don't want the pattern to
actually match the one we used for the bevel,

let's use this last free output we have from
this Noise. So let's add a Map Range to set

the noise influence, and connect it to the third
channel. And let's drop it next to the new mask.

Let's look at this output, and connect
the new Map Range to the Maximum input.

Then we can set the range appropriately. We'll
need a much higher value for the maximum.

And increasing it, we see that the pattern
immediately starts looking a lot more organic.

We can also increase the Min, to push the
whole texture a bit more into the bricks.

With this extra bit of variation,
the wall looks a lot more grungy.

We can compare it to the wall without this
gradient mask, by setting both outputs to one,

and we see that this makes all the difference.

But there is still one more thing that we can do
to really push this to the next level. Currently,

the infiltration has a constant intensity from the
bottom of the wall, all the way to where it ends

in the middle. In reality, the infiltration would
gradually fade as we get farther from the bottom.

To get this effect, we could just apply a gradient
as a fade, but we can do better than that!

Since we are considering that the bricks are
absorbing less moisture than the mortar, we can

exploit this, and modulate how far into the bricks
the moisture infiltrates, based on the height.

We already have the vertical coordinates here,
so let's add a Map Range to control the gradient.

Let's set the input parameters roughly
to where we want the fade to happen.

And what we can do now, is multiply this with the

texture that we are using to determine
the infiltration depth into the bricks.

Let's take a look at what's happening
here. We have this texture that we are

using to determine the infiltration depth.
The dark values in the texture map to a

lower infiltration and the brighter
parts map to a higher infiltration.

So by multiplying it with the gradient, we
are making the infiltration less deep at

the dark parts of the gradient, while keeping
it the same where the gradient clamps to one.

So if we now take a look at the mask output, we
see that indeed the depth changes dynamically,

based on the gradient. But
the texture is upside down,

as we want the lower parts to be more covered,
so let's invert the output range of the gradient.

Then we can also tweak the gradient range, and
perhaps set the interpolation to Smooth Step.

Let's take a look at the output
with the cutoff mask as well,

and tweak the range properly,
now that we see it in context.

We can also compress the input range
where we set the amount of infiltration,

to give it a bit more contrast,
and make it look more rough.

And maybe even increase the maximum infiltration
depth, to really get good coverage at the bottom.

Now let's take a look at the result! It
looks much nicer and more dynamic than

with a constant intensity over the whole
surface, but it's looking a bit faint.

Now that we broke up the pattern, we can
increase the effect to full intensity.

Now, if we compare it with what we had in the
last chapter, by setting the intensity to one

everywhere, we can see just how much more
natural it looks. And comparing it with the

plain wall without any of this reveals how much
this effect contributes to that nice grungy look.

All that remains now, is organizing
the new nodes and connections we added.