Original subtitles

Let's randomize our wall even more, by adding slight random rotations to the bricks.

Let's create some space just before we offset the coordinates for the distortion,

and Shift right click and drag to add a Reroute, so that we can work on this link.

To rotate our bricks, we'll use the aptly named Vector Rotate node.

This allows us to rotate the coordinates around any axis of the input coordinate system,

and centered around any given point. As we are doing this after fractioning the bricks,

each brick effectively has their own coordinate system, so they will rotate independently, and

as we centered the coordinates by subtracting 0.5, they have a (0,0) point in the middle, so we can

keep the center vector as zero, and the rotation pivot will be in the middle of each brick.

With the Axis Angle rotation type, there is an Axis vector input around which the rotation will

happen. By default it is set to a vector pointing straight up along the Z axis, as indicated by the

single 1 value in the Z channel of the Axis input. This might not seem like what we want,

as our rotation axis should be perpendicular to our wall, like the normal direction.

But it is important to keep in mind which coordinate system we are working in,

and in this case, we are working with Object coordinates.

While we did transform our coordinates in various ways, by fractioning and scaling them, we didn't

perform any operation that rotates them, so they are still aligned with the Object coordinates. And

as it happens, the Object coordinates are aligned with the object transformation. So in this case,

it doesn't matter along which world axis we want to rotate, but rather which object axis.

As we rotated our plane, the coordinates no longer match the world axes,

and to easily visualize around which axis we want to rotate,

we can enable the axis viewport display in the object properties. And we can see that

the default already happens to be correct here, as we do indeed want to rotate around the Z axis.

And to confirm, we can change the angle and see that our bricks are rotating as expected.

We can also see that the bricks get clipped at the tiling boundaries,

as the coordinates are rotated within each individual tile. This means that we can only

rotate within the space allotted for the mortar. This is a slight limitation, but we don't need

such an extreme rotation, so in this case, we can just work within these boundaries.

As we are rotating around a vector that is perfectly aligned to an axis,

we can actually just set that axis in the rotation type, to make it more explicit.

And we can see that it still works the same way.

We don't need the axis display anymore, so let's turn it off.

Now we want to actually randomize the rotation for each brick,

so let's take a look at the Random output. We just need a single value

to randomize the angle, so we can place a Separate XYZ node in here.

If we look at the final output, and plug the random value into the angle,

we can see that it's being rotated way too much. This is interesting, because the random value has

a range from zero to one, but if we input one into the angle field, it only rotates slightly.

The value has such a different effect when input into the field or connected to another node,

because internally the values are being processed in radians, while in the UI they

are being displayed in degrees, unless you have specifically configured it to display radians.

So actually, the values being stored are in radians, they are converted from degrees when

you input them into a field, and just converted back for display. But Blender only does this for

fields that are explicitly used for angles, as it wouldn't make sense to convert generic numeric

fields. So always keep in mind that when values passing through the tree are used as angles,

they are interpreted as radians. And remember that a full circle is 2pi radians.

Now, to limit the maximum rotation, we can simply multiply this random value.

But we also see that it is only rotating clockwise, because all the values are

positive values between zero and one. So let's as usual subtract 0.5 to center them around zero.

Now to find the actual maximum rotation we can use,

it's easier to just plug a Value node in there, instead of the random values,

so that we can see just one maximum rotation applied to all the bricks.

Let's also turn off the distortion for now, by pressing M to mute the vector addition.

This will just make it easier for us to see what's going on.

Now we can lower the value until the bricks just clear the boundary of the tiles.

There we go, that's our maximum rotation.

We can now input the value we found into the multiplication, and plug it back into the angle.

But we are not actually making use of the full range of rotation. As we subtracted

0.5 from the random value, the maximum we can get is no longer one, but rather 0.5,

and the same in the negative direction. So we actually need to double the value

in the multiplication, and then our bricks are nicely rotated.

Now we can also notice that the rotation is much less visible in the header bricks,

as their shorter width allows for less change in height over the width of a brick,

thus reducing the visual contrast between the differently rotated bricks.

But this also means that we can rotate them more before they hit the boundary of the tiling.

So let's find their maximum rotation, by plugging the Value node into the angle again.

Then we can see that we can rotate them about three times as much as the stretchers.

Now we just need a way to use these different rotation amounts for the different brick rows.

We have all the information we need to differentiate the rows,

in the Size output of the Bricks group. There the X component tells us the width

of the bricks, so we can use that to set the different rotation amounts.

Let's add a Separate XYZ, so that we can isolate the X component. Now here we have the inverse

of the scaling factor, which also happens to be the actual width of the resulting bricks.

We had set our stretchers as reference, giving them a width of one,

and the headers were set to half size, giving them a value of 0.5. Now,

we can use a Map Range node, to map these known values to the rotation factors we found before.

Let's set the inputs to the known widths of the bricks, 0.5 and one. And then we can map those to

the angles we found before. 0.1 for the full length bricks, and 0.15 for the half bricks.

Then we can connect it to the multiplication input, and take a look at the result. Let's

also not forget that we should still double the angle for the half bricks,

like we did with the other ones, to get the full rotation range.

Perhaps the maximum possible rotation is actually a bit too much for the headers,

so let's lower it until it looks good. 0.2 seems to work alright here.

Then we can organize our nodes. Let's also add some Reroutes with Shift right click,

and align these links to the grid,

eliminating link crossings at shallow angles, which are hard to read.

Then we can use Ctrl+J to frame these nodes, and name it, for that extra bit of readability.

Lastly, let's not forget to re-enable the distortion.

And there we have it, with the distortion and rotation, our wall looks that much more dynamic.