All language subtitles for 04 RandomOffset

At this stage we have our
bricks in a grid pattern,

but we actually want each row
to be offset, so let's do that!

If we add some value to the X coordinate,
we can offset all the bricks horizontally,

but we actually want to offset each row of bricks
differently. So to change the offset based on the

vertical position, we can use the Y axis to drive
the offset. Let's add a Separate XYZ node, and

connect it with Alt right click. Then we can add
a Combine XYZ node and connect it to the offset.

Lastly, we connect the Y output to the X input,
so that the higher the vertical coordinate,

the more offset the bricks will be. And we can
multiply the value to set the amount of offset.

This looks kinda cool, but it's not exactly
what we want. The thing is that the Y value

is changing within each brick, so the bricks also
get a varying offset. To deal with this, we can

use the Floor operation that we used before, to
hold the values within the height of each row.

We're getting closer, but the offset is
still not matching our brick height, and

that's because this Floor operation is being done
before we scaled the Y coordinate of our bricks.

If we take a look at the output, we can see how
the coordinates are being offset at every unit.

Let's turn this into a group, so that we
can easily add it inside the bricks setup.

Let's not forget to add a Reroute to avoid
duplicate inputs, and then we can Ctrl+G. And

tabbing out, we can name it. We can get rid of
it for now, and then tab into our Bricks group,

and place it after the transformation.
Adding a Reroute can be helpful,

to easily place the new node on both connections
at once. Sometimes it doesn't update right away,

but then you just need to change a
value for the shader to actually update.

Now the offset is working exactly as
expected, and if we set it to 0.5,

it works exactly like a standard brick
pattern, with every other row offset by

half a brick. But when it comes to shaders,
we all know that the less neat something is,

the cooler it looks, so let's actually
mess up this perfect brickwork!

To offset each row by a random amount, we can use
the White Noise node like we used before, but this

time, instead of generating a random value per
brick, we'll generate a random value per row.

As we are inputting just the single Y
value here, we want to set it to 1D.

Now, here we have our random rows.

Let's just Tab out for a bit, and remember to
select a node that is not a group, when tabbing

out, to avoid entering the selected group instead.
Then we can set the viewer to the final output

again, and Tab back into our two groups. Now, once
we plug this in, the bricks have a random offset.

When we change the intensity of the offset,
we see that all bricks move in one direction,

and that's because the random values are
all positive values between zero and one.

This doesn't really matter, but
just for the sake of completeness,

let's subtract 0.5, so that our
average movement stays centered.

Now we can expose this offset intensity as a group
input, so that we can control it from outside.

Let's name it, and tidy up our group.

Tabbing out of the offset group, we can
tidy up in here as well, and let's not

forget to expose the offset once again, so that
we can access it all the way from the outside.

Then we can choose a value that looks
nice, and that is our randomized offset!