All language subtitles for 05-RandomHeaderRows

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.