All language subtitles for 26 MoistureInfiltration

So far, all the variation we added was completely
random, and only driven by noise textures.

But a lot of things follow more specific
patterns. A common problem with old walls

is mold caused by infiltration at the bottom
of the wall, due to rain and ground moisture.

Let's emulate this effect. First, we'll need a
way to tell the top and bottom of the wall apart,

so let's add another Texture Coordinate node here,

that way we don't need a long
connection from somewhere else.

Then let's select the Object coordinates, and add
a Separate XYZ node, so that we can use just the Y

channel. Then, with a Map Range, we can set
where we want the gradient for the infiltration.

Let's lower the Min and Max input values, so
that the gradient is a bit lower on the wall.

And let's set the interpolation to Smooth Step.

Then let's invert the output range, so
that it affects the bottom of the wall,

rather than the top. And let's make some
space here, so that we can alter the color.

Now we can add a Hue Saturation node, for our
color manipulation. Note that we are adding

this after we mix in the mortar color, so that
it affects the whole wall, including the mortar.

We could also use a color mix node instead,
to mix in the color of the mold, but the Hue

Saturation is nice in this case, as it let's us
shift the color, while preserving the texture.

Then let's take a look at the Color output,
and plug the Map Range into the factor.

Now, if we start lowering the value, the
bottom of the wall starts getting darker.

Let's also shift the hue a bit, to get a green
tint, to simulate some mossy moldy kind of thing.

And let's really darken this quite a bit.

Then, taking a look at the shader output,

it looks OK, but that completely straight
transition doesn't look natural at all.

So let's randomize the gradient. To get some
randomness, as always, we'll need a Noise node.

We want the height of the infiltration
to vary along the length of the wall,

so we'll need a Noise that
varies along the X axis.

So let's set the Noise to 1D, and connect it to
the X output. Now we have these random streaks,

which are probably a bit too fine, so
let's make the texture a bit bigger.

Then, to use this as an offset for
the height, let's again subtract 0.5,

and add a multiply node, to
scale the amount of distortion.

Now we can add this onto the
Y channel, to vary the height.

Then let's increase the intensity quite
a bit, and tune our Noise parameters,

to find a shape that looks suitable. And let's
take a look to see what it does to the output.

This gradient now has some randomness,
but these streaks are still very smooth,

so let's add another layer of randomness,
by distorting this whole texture,

using our handy Distort2D
node on the input coordinates.

Let's zoom in here, and start
tuning the distortion parameters.

let's increase the Intensity, perhaps
make the texture a bit bigger,

and increase the Detail and Roughness.
This is looking a lot better.

Now let's organize the nodes, and frame them.

Let's call this Frame something
like Water Infiltration.

Lastly, perhaps this texture
is looking a bit too intense,

so let's lower the maximum influence a
bit, to get a slightly more subtle effect.