Original subtitles

To create more variation let's add some rows of headers.

Normally the headers would be spaced regularly, but as we are building a poorly constructed wall,

let's suppose that the header bonds were just laid randomly.

We could change the size of the bricks by adjusting the scaling in the Bricks group,

but in the Offset group we already have a White Noise to get our randomness from, so let's set it

up there instead. Just like in the Bricks group, we can add a multiplier here to change the size.

Now we again add a Combine XYZ, but we don't want to take the same value from

the White Noise, as that would couple the offset and brick size together.

Instead, we use a Separate RGB, to get another channel from the White Noise.

The Red channel is always the same as the Value output,

but we have two extra channels with different seeds.

So we can, for example, take the Green output. But we don't want to just plug this into our scaling,

as we don't want the bricks to be randomly sized, instead, we just want two different sizes.

So we need a binary operation that will give us some rows of one size,

and some rows of another. For this, we can again use a Less Than operation.

This let's us conveniently specify how many of the rows should have each size.

The values output from the White Noise, follow a uniform distribution between zero and one,

this means that any value between zero and one is equally likely to be output.

With that in mind, we can see that, on average, half of the computed values will be below 0.5,

and half above. Likewise, if we choose another threshold, say 0.3,

30% of the values will be below the threshold, and 70% will be above. So the threshold effectively

becomes a factor to control how often something happens, in this case, the small brick rows.

But this is still not what we plug into the scaling. This just tells us which rows are small,

but we still need to set the scaling factor for them. So now we can use a Map Range

node to map this mask to the actual scaling factors. Our input range is already correct,

as the mask is either zero or one. We know that our total laid brick size has a ratio of 6:3:2,

which makes the math really easy, as the depth of the brick is half the length.

Now for the output range, if we consider the zero valued rows to be full rows,

and the one valued rows to be half rows, we need to map the Min output to one,

to keep the same size, and map the Max to two, so that they will be split in half.

Note that even though we are looking at values of one and two now,

we can still see the difference between the rows. That's because our color management

is compressing our scene space into our display space, allowing us to visualize values above one.

Let's also set the X and Y channels of the Combine XYZ node to one for now,

so that the multiplication doesn't change anything yet, and the values don't get collapsed to zero.

Now if we just Tab out and look at the Fraction output, we can Tab back in,

and connect the scaling factor to the X input, to scale the width.

Now we have these half rows, but if we look at the final output, we see that the mortar also

gets scaled down. This is because unlike with the vertical scaling that we compensated for,

we have not included the horizontal scaling in our scale correction.

In Chapter 2 We already exposed the brick size as a vector, so all we have to do now,

is plug in our new X value. We need to expose our scaling factor from the Offset group,

but remember that ultimately we want to output the inverse scale,

so let's first invert the value, by calculating one divided by it.

For more info on this setup, you can check out Chapter 2,

about the distance field, where we cover this in more detail.

And now we can connect it and name it appropriately.

Then we can Tab out, and finally, it's a matter of plugging the width

into the X channel of the Size output. And we see that it immediately gets corrected,

as the rest of the correction is already set up downstream.

Lastly, it would be nice to be able to control the frequency of the headers from outside the group.

So let's Tab back in, and expose this Threshold as well.

It controls the factor of small bricks, so let's name it like that.

Then we can Tab out, and once again, connect it to the Group Input, to control it from the root

of the tree. And tabbing out one last time, we have our completed random rows of headers,

and we can easily change how many we want by changing the factor at any time.