All language subtitles for 20 HighFrequencyTexture

So far, we have been focusing almost
exclusively on the displacement texture,

and haven't given much attention to the shading.

Our colors are completely flat so
far, so let's work on that a bit.

Here we made a texture with streaks, and it would
be nice to have something similar in the color as

well. So let's make use of the waviness that
we already made with the displacement here,

and let's duplicate this Noise while
maintaining the inputs, using Ctrl+Shift+D.

Then we can un-parent it from the Frame with
Alt+P, and drag it over to our color setup.

Let's take a look at the color. Here we
are calculating the HSV Value offset,

which is a good place to add some texture. So
let's duplicate this multiplication, and add it

into the node chain as well. Note that it doesn't
matter in which order we do these multiplications

as multiplication is commutative, meaning that
the order of operations doesn't change the result,

so let's just place them in the most
convenient order for the node layout.

Now we can see the texture appear in
the color. But this texture is still

identical to the one we used for the displacement,

so let's change some settings to make it more
interesting for the color. Let's make it a bit

smaller, and also increase the detail and
roughness, to get a more gritty texture.

Let's also remove the node label that was
carried along with the copy, as it isn't relevant

here. Then let's add another Map Range, and put it
after the texture, to increase the contrast a bit.

Let's compress the input range
a bit more, and set the outputs.

A max value of one means that the
texture won't lighten the color anywhere,

and a minimum of .5 should probably be
enough darkening. Then let's set the

interpolation to Smooth Step for that extra
contrast, to really make the texture pop.

Since we made this texture much finer, let's
color code it with the high frequency yellow,

by copying it from another node. Then let's
also copy this color to the connected Map Range.

Now that we are adding more stuff to the color
setup, let's also color code the parts responsible

for the per-brick colors, so that we don't lose
track of things. Since these are using a discrete

texture, it would make sense to use another color
scheme here. Let's use a color that we haven't

used yet, like green. And then set the saturation
and value to the more faded values we used before.

Then let's copy this color
to the other related nodes.

Let's also move these nodes over a bit,

so that we can neaten this long
connection with some Reroutes.

Then let's also organize
the rest of the tree a bit,

and move the color setup closer
to the principled shader.

Now, finally taking a look at the shader output,

we can see how the color variation made
it look a bit more grungy. And toggling

this multiply with the M key shows the
difference with and without the noise.

But other than color, we haven't really
textured any other shading parameters.

One parameter that is especially significant
for realism, is the roughness. If we look at

the wall at a grazing angle we see the effect of
the roughness very clearly. Basically, we can see

that the wall is equally shiny everywhere,
but that's rarely the case in real life.

So let's add another Map Range, and take the
same texture output. That way we can couple

the color variation and roughness together. We
could imagine that the darker parts are dirtier,

or have some slightly different clay, making
them less shiny, or in other words, more rough.

So let's again compress the input
range a bit, and set it to Smooth Step.

Then, taking our current roughness of .7 as a
basis, let's set our output around that. The

minimum output corresponds to the darker parts in
our color here, so let's set a higher roughness,

and the max corresponds to the lighter
parts, so let's set a lower roughness here.

Plugging this into the roughness, we
get much richer and more varied shading.

We can also check it in Cycles, to see all
the shading combined with our displacement.

Then let's just organize this last
bit, and it's on to the next chapter.