Original subtitles

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.