All language subtitles for 07-RandomRotation

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.