All language subtitles for 32-MossColorTexture

With the moss in place, let's add some color
variation. This will mostly be similar to

what we already did in other parts of the shader,
without much in the way of unexplored techniques,

but we get to apply it in a
slightly different context.

So let's drag our moss shader somewhere with a
bit more space. And to start we will yet again

add a Texture Coordinate node and a Noise
node. You might see a trend emerging here.

Let's take a look at the Noise, and set it to 2D.
Then, just like we did for the brick colors, let's

add a Hue Saturation node, to manipulate the moss
color. And let's copy our existing color over.

Then we can start by modulating
the Value with the noise.

And again, we can use a Map Range to adjust the
Value range. Let's raise the minimum output,

and compress the range a bit,
to get some more contrast.

Let's also make the Noise bigger,
to get some medium scale variation.

And let's set the interpolation to
Smooth Step, to avoid ugly sharp edges.

The Noise is looking a bit too
smooth, so let's increase the Detail.

And maybe we could use a bit of a higher Roughness
as well, to push those high frequency layers up

a bit. Increasing the Roughness shows that we
could probably still use a bit higher Detail.

This is looking pretty good, so let's modulate the
Hue next. We'll need another channel, so let's add

a Separate RGB node here and connect the color.
Then let's connect the second output to the Map

Range, because the Hue is above the Value, and
this way we avoid crossing links over each other.

Then let's connect it to the Hue, and add another
Map Range in there. Let's set it to Smooth Step as

well, and let's set the range to something around
0.5, so that we're not changing the Hue too much.

And compressing the input range
a bit doesn't hurt either.

Comparing the color with and
without the Hue modulation,

we can see that it's kinda subtle, but it
definitely makes it a bit more natural.

What we can also do, is modulate
the Hue based on the Value channel.

Currently the Hue and Value have completely
independent noise patterns, which is good,

but we might also want to, say, make the
lighter parts more green than the darker parts.

So let's duplicate the Value Map Range with
Ctrl+Shift+D, to keep the input connection. Then,

we can use this to offset the Hue that
we computed with the other noise channel.

So let's add a Math node onto the Hue
link, and connect our new Map Range.

Now, if we set both outputs to zero,
it doesn't do anything. But then,

higher output values shift the Hue clockwise,
and lower values shift it counter-clockwise.

So if we want to push the dark parts a bit more
towards red, perhaps to make it look like older

slightly dried moss, we can just put a lower
value in the min output. The result is that

the Hue is still decoupled from the Value, as
we're feeding it an independent noise channel,

but because we're additionally also
feeding it the same channel as the Value,

we're biasing the darker parts more towards red.

At this point the color is looking a
bit dark, so let's brighten it up a bit.

And now we can plug it into the
shader, and look at the result.

It's definitely looking more natural, now
that it doesn't have a single flat color.

But if we look more closely, on an individual
level, the moss clumps are still very uniform.

Conveniently, the Voronoi, which we
are using to create this clumpy effect,

gives us a random value for each cell, which
we can now use to modulate the color as well.

So let's add a Separate RGB again,
and connect it to the color output.

Now we can bring this to our moss color setup,
and if we just plug this directly into the Value,

we see how each clump gets a different brightness.
But we'll want to control this better with a Map

Range. So let's raise the lower output a bit,
so that it doesn't go all the way to black.

That's good, but we still want the
big noise to affect our Value as well,

so let's plug it back, and combine
them with a multiplication.

This creates a really nice and mossy effect,
with variation at different scale levels.

Finally, let's also play a bit with the
Saturation. Since we defined that the

brighter moss parts are supposed to be more fresh,
let's also make them a bit more saturated than the

dark parts, so that they pop a bit more. We can
do that by getting another Map Range in here,

and using it to map the combined
brightness onto the Saturation.

So let's connect it up. Then everything
becomes desaturated, as we're even feeding

it negative Saturation values. So let's
set this back up to one, and go from there.

We can really desaturate it if we push
it down a lot, but let's keep it subtle.

We can also tweak the input range a bit, to
bias it more towards the saturated parts.

Then let's take a look at the shader, to
confirm that it's looking a lot nicer. And

then it's time to maximize the node editor to
tidy everything up. Let's frame this and call it

Moss Color. And let's also copy the node color
over. Then we can snap everything into place.

Lastly, let's not forget to color code our
different patterns based on their frequency.