Original subtitles

In this chapter, we won't be adding anything new to our shader.

Our tree is really going to start growing quickly in the coming chapters,

so let's take some time to make everything more readable, for the sake of our sanity later on.

As we're not changing any shading properties,

we don't need to see the viewport, so with the mouse in the shader graph,

let's press Ctrl+Space, to maximize it, so that we can focus only on the node tree.

So far, this upper left part has been dedicated to the bricks,

and this lower right bit is responsible for the mortar.

So to be able to tell the different sections apart at a glance, let's do some color coding.

With the Mortar Frame selected, let's press N to open the side bar, where we can find the

node properties. Making sure that we are in the item tab, let's enable the node color checkbox.

This allows us to set a custom background color for any node.

Different people have different color coding systems, and you can come up with your own as

well, but what I like to do is make the node colors related to the corresponding colors

in the shader. So for the mortar background, let's just copy the mortar color itself, by

pressing Ctrl+C while hovering the field, and then pasting it into the background color with Ctrl+V.

The colors look much darker on the node backgrounds,

so I like to brighten them up quite a bit. Something like .6 works well in this case,

and I also like to lower the saturation a bit, so that the colors are not distracting.

Now we can easily copy the same color to the other related nodes, with the shortcut we configured

in the Blender setup video. It works by copying the color from the active node to all the other

selected nodes, so let's select the mortar related nodes, making sure the one we already colored is

selected last. Then, pressing Ctrl+Shift+C the colors automatically get transferred.

All the other frames are dealing with the bricks themselves, and as that is the main

part of the shader, it makes sense to just leave them with the default background,

as we really just want to be able to easily tell the different sections apart.

Now we can do some more localized color coding. In a Frame like the Mortar Frame,

we have multiple chains of related nodes, responsible for different things. These nodes on

the top make the main gritty bubbly texture, these nodes make the medium scale surface bumpiness,

and these nodes create a the gaps in the mortar. We can follow these chains of nodes, by looking

at their connections, but it would be much easier to tell, if they were grouped by color.

One way I like to classify sections is by the scale or frequency of the texture. When we combine

different textures into a compound texture, more often than not, each of the sub-textures

is responsible for a different scale of detail. So if we take a quick look, we see that the gaps

texture is the biggest, the bumpy texture has a medium size, and the main texture is quite fine.

So starting with the lowest frequency, I like to use a saturation of .2 and a value of .7,

while leaving the hue at zero, but you can, of course, use whatever parameters look nice to you.

Then we can copy this to the other node in the chain, again with Ctrl+Shift+C.

Now let's use this same color as the basis for the medium frequency texture.

Leaving the same saturation and value, let's set it to a hue that is just different enough

that we can easily tell them apart. And again, copy it to the related nodes.

Then copying the color for the last chain, let's step the hue a bit further again.

And copy it to the other related nodes.

With these consistent steps in hue, we get a nice sequence of colors to indicate the scale of the

texture. And now we can see each section at a glance, so if we would want to adjust something

in, say, the fine texture, we know that it must be one of the yellow nodes.

This really cuts down on the time spent trying to follow the web of node connections,

especially as the tree gets more and more complicated.

Another thing I like to do, for extra clarity is to name the most important nodes in each chain.

It's usually the first node in the chain, and it gives extra context to all the other nodes.

So for this one let's name it Gaps. Let's call the next one something like Bumpiness.

Let's call the Voronoi Blobs, and in this chain, the distortion is also a significant node,

so let's name it as well. Something like Grit will do.

Over at the brick texture, we also have a couple of different chains. Taking a quick look at them,

we can see that the top one is more high frequency than the bottom, one, but neither

of them really has big features. So I'd say that the top one is high frequency, and the

bottom one is medium frequency. So let's copy the colors we previously assigned, with Ctrl+Shift+C.

Note that this is all subjective, and there isn't really a specific threshold on the noise scale

that makes it high or low frequency, as there are a bunch of parameters that affect this,

like the detail and roughness, as well as the context they are used in.

It's all relative, I just try to classify them based on how they look in that specific texture,

and what we might call low frequency for the mortar, might not be low frequency

for the bricks, if we add much lower frequency features there, for example.

Then let's name the nodes. The bottom one is used for breaking some chips out of the bricks,

and the top one is just some general grittiness.

In the Random Rotation Frame there aren't really separate identifiable chains of nodes,

as it really is more of a single unit, so nothing to color code there. Now in the Brick Shape Frame,

there's this main chain on the top where we're calculating the brick shape,

but we also have this bit at the bottom, where we're using a Noise to compute

different aspects of the brick shape. But this Noise is being used for multiple functions,

like the corner radius, and the bevel width, so we can't really name it something specific.

But we can still color code all the nodes that are related to the noise.

I'd call it a medium frequency noise, so let's copy the medium color.

Then we can still name these nodes that are using the noise values.

This one is computing the rounded corners, and this one the bevel.

Then, to make it even easier to follow, we can also copy these names to the nodes that

we are using to compute their inputs. Just like with the background colors,

if we select the nodes, we can copy the name from the active node, this time, using Shift+V.

And there we have it. It's still exactly the same tree,

but with the extra visual separation it's much easier to follow and see which parts are related.

And now we are ready to add a lot more complexity to our tree!