Original subtitles

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!