All language subtitles for 33-MossVariation

The moss is looking good, but it's growing
everywhere, so let's randomize the moss distribution

throughout the surface.

We're joining the moss and the wall with the
depth comparison technique.

So we can easily create variation in the moss
by pushing it into the wall where we want

less moss, and letting it come farther out
of the wall where we want more moss.

So let's add a Noise Texture to control this
depth variation, set it to 2D, and connect

it to the texture coordinates.

Let's take a look at it, and make it much
bigger, to create big moss patches on the

wall.

Let's also increase the Detail and Roughness,
so that it doesn't look too smooth and uniform.

Then we can add a Math node to subtract 0.5,
so that the displacement is centered around

the current moss depth.

And another Math node to multiply the intensity.

Then we can move this over, and insert a Math
node in between, to add the noise onto the

depth map.

And then we can see how this affects the moss
texture.

Then, let's take a look at the shader.

If we start increasing the intensity, we see
the moss forming bigger patches in some places,

and disappearing in others.

At this point, we might have too much moss,
so to control the amount of moss coverage

over the whole wall, let's create some more
space here and insert a subtraction into the

chain, so that we can offset the whole moss
surface into or out of the wall.

This value now controls the amount of moss,
while the noise intensity controls the amount

of variation in the moss distribution.

One thing that we might notice, is that there
seems to be more moss on the dark parts of

the wall than the light ones.

That's because the Noise Texture we're using
has a similar scale to the one we used for

the color variation, which causes them to
almost match each other.

To break this relationship, we can just offset
the moss texture with a Vector Math node.

If we set it to subtract, and connect it to
the coordinates that we're feeding into the

Noise, we can simply drag the noise across
the surface, shifting the distribution along

with it.

This allows us to have a different part of
the noise that doesn't look the same as the

color texture.

This also enables us to have better control,
and find a distribution that looks the way

we want.

This applies to any texture, so if we were
unhappy with the pattern of any other noise

in the shader, we could add a Vector Math
node there as well, and offset it to find

another pattern.

Now the moss is randomly distributed on the
wall, but the moss clusters are still a bit

uniform.

So far we have the high frequency Voronoi
Texture, and this very low frequency texture,

so what we're missing, is a medium frequency
texture, to fill in that extra variation.

This will basically be the same setup as for
the low frequency texture.

So let's duplicate the Noise, and make it
a bit finer and more detailed.

Let's also duplicate the subtraction and multiplication.

Then let's make a bit more space here, and
again, add the texture onto the setup.

Then, if we look at the moss texture, we can
see how increasing this texture's intensity

affects the depth map.

Let's take a look at the shader output.

In Cycles, we can make a render border with
Ctrl+B to render only part of the viewport,

and enabling the subdivisions, we see how
this texture affects the wall.

If we disable the texture, for comparison,
it's clear how this makes it look more organic.

Now we can snap all these nodes into place,
and set the appropriate node colors for the

different textures.

There is one more thing we can do.

Since we already have this low frequency texture
here, we can take advantage of it, to sneak

some extra variation into the color texture.

So let's add a Map Range, to control the effect,
and a Math node, to multiply the new texture

into the Value.

Then we need a Separate RGB to get another
channel from the Noise Texture.

Let's skip the R channel that's already used
for the displacement, and take another channel

for the color.

Then we can plug it into the multiplication,
compress the range a bit, and set some brighter

values for the output.

Comparing the color with and without the noise
shows how this helps to reduce the uniformity.

Then we can just finish organizing the node
graph, and our moss is one step closer to

completion.